ประมวลผลเอกสารการจำนองด้วยการประมวลผลเอกสารอัจฉริยะโดยใช้ Amazon Texttract และ Amazon Comprehend

องค์กรในอุตสาหกรรมการให้กู้ยืมและการจำนองดำเนินการกับเอกสารหลายพันฉบับในแต่ละวัน ตั้งแต่การสมัครจำนองใหม่ไปจนถึงการรีไฟแนนซ์จำนอง กระบวนการทางธุรกิจเหล่านี้เกี่ยวข้องกับเอกสารหลายร้อยฉบับต่อใบสมัคร ปัจจุบันมีระบบอัตโนมัติที่จำกัดในการประมวลผลและดึงข้อมูลจากเอกสารทั้งหมด โดยเฉพาะอย่างยิ่งเนื่องจากรูปแบบและเค้าโครงที่แตกต่างกัน เนื่องจากมีแอปพลิเคชันจำนวนมาก การรวบรวมข้อมูลเชิงลึกเชิงกลยุทธ์และรับข้อมูลสำคัญจากเนื้อหาจึงเป็นกระบวนการที่ใช้เวลานาน ดำเนินการด้วยตนเองสูง เกิดข้อผิดพลาดได้ง่าย และมีค่าใช้จ่ายสูง เครื่องมือการรู้จำอักขระด้วยแสง (OCR) แบบเก่านั้นไม่คุ้มทุน เกิดข้อผิดพลาดได้ง่าย เกี่ยวข้องกับการกำหนดค่าจำนวนมาก และปรับขนาดได้ยาก การประมวลผลเอกสารอัจฉริยะ (IDP) พร้อมบริการปัญญาประดิษฐ์ของ AWS (AI) ช่วยให้การประมวลผลแอปพลิเคชันสินเชื่อบ้านเป็นไปอย่างอัตโนมัติและรวดเร็ว โดยมีเป้าหมายในการตัดสินใจที่รวดเร็วและมีคุณภาพ ในขณะที่ลดต้นทุนโดยรวม

ในโพสต์นี้ เราสาธิตวิธีที่คุณสามารถใช้ความสามารถการเรียนรู้ของเครื่อง (ML) ด้วย Amazon Textและ เข้าใจ Amazon เพื่อประมวลผลเอกสารในใบสมัครจำนองใหม่ โดยไม่ต้องใช้ทักษะ ML เราสำรวจขั้นตอนต่างๆ ของ IDP ดังแสดงในรูปต่อไปนี้ และวิธีที่เชื่อมโยงกับขั้นตอนที่เกี่ยวข้องในกระบวนการสมัครจำนอง เช่น การส่งใบสมัคร การรับประกันภัย การตรวจสอบ และการปิดบัญชี

แม้ว่าใบสมัครจำนองแต่ละใบอาจไม่ซ้ำกัน แต่เราคำนึงถึงเอกสารทั่วไปบางส่วนที่รวมอยู่ในใบสมัครจำนอง เช่น แบบฟอร์มใบสมัครสินเชื่อที่อยู่อาศัยแบบรวม (URLA-1003) แบบฟอร์ม 1099 และใบบันทึกการจำนอง

ภาพรวมโซลูชัน

Amazon Texttract เป็นบริการ ML ที่แยกข้อความ ลายมือ และข้อมูลจากเอกสารที่สแกนโดยอัตโนมัติโดยใช้โมเดล ML ที่ผ่านการฝึกอบรมล่วงหน้า Amazon Comprehend เป็นบริการประมวลผลภาษาธรรมชาติ (NLP) ที่ใช้ ML เพื่อเปิดเผยข้อมูลเชิงลึกอันมีค่าและการเชื่อมต่อในข้อความ และสามารถทำการจัดประเภทเอกสาร การรู้จำชื่อเอนทิตี (NER) การสร้างแบบจำลองหัวข้อ และอื่นๆ

รูปต่อไปนี้แสดงขั้นตอนของ IDP ที่เกี่ยวข้องกับขั้นตอนของกระบวนการขอสินเชื่อที่อยู่อาศัย

ในตอนเริ่มต้นของกระบวนการ เอกสารจะถูกอัปโหลดไปที่an บริการจัดเก็บข้อมูลอย่างง่ายของ Amazon (Amazon S3) ถัง การดำเนินการนี้จะเริ่มต้นกระบวนการจัดประเภทเอกสารเพื่อจัดประเภทเอกสารเป็นหมวดหมู่ที่ทราบ หลังจากจัดประเภทเอกสารแล้ว ขั้นตอนต่อไปคือการดึงข้อมูลสำคัญออกจากเอกสาร จากนั้น เราดำเนินการปรับปรุงสำหรับเอกสารที่เลือก ซึ่งอาจเป็นสิ่งที่ต้องการ การแก้ไขข้อมูลส่วนบุคคล (PII) การติดแท็กเอกสาร การอัปเดตข้อมูลเมตา และอื่นๆ ขั้นตอนต่อไปคือการตรวจสอบความถูกต้องของข้อมูลที่ดึงออกมาในขั้นตอนก่อนหน้าเพื่อให้แน่ใจว่าใบสมัครจำนองมีความครบถ้วนสมบูรณ์ การตรวจสอบสามารถทำได้โดยใช้กฎการตรวจสอบทางธุรกิจและกฎการตรวจสอบข้ามเอกสาร คะแนนความเชื่อมั่นของข้อมูลที่ดึงออกมายังสามารถเปรียบเทียบกับเกณฑ์ที่ตั้งไว้และกำหนดเส้นทางไปยังผู้ตรวจสอบที่เป็นมนุษย์โดยอัตโนมัติผ่าน อเมซอน เสริม AI (Amazon A2I) หากไม่เป็นไปตามเกณฑ์ ในขั้นตอนสุดท้ายของกระบวนการ ข้อมูลที่แยกออกมาและตรวจสอบแล้วจะถูกส่งไปยังระบบดาวน์สตรีมเพื่อการจัดเก็บ การประมวลผล หรือการวิเคราะห์ข้อมูลเพิ่มเติม

ในส่วนต่อไปนี้ เราจะพูดถึงขั้นตอนของ IDP ที่เกี่ยวข้องกับขั้นตอนของการขอสินเชื่อที่อยู่อาศัยโดยละเอียด เราดำเนินการตามขั้นตอนต่างๆ ของ IDP และหารือเกี่ยวกับประเภทของเอกสาร เราจัดเก็บ จัดประเภท และดึงข้อมูลอย่างไร และเราปรับปรุงเอกสารอย่างไรโดยใช้การเรียนรู้ของเครื่อง

การจัดเก็บเอกสาร

Amazon S3 เป็นบริการพื้นที่จัดเก็บอ็อบเจ็กต์ที่นำเสนอความสามารถในการปรับขนาด ความพร้อมใช้งานของข้อมูล ความปลอดภัย และประสิทธิภาพระดับแนวหน้าของอุตสาหกรรม เราใช้ Amazon S3 เพื่อจัดเก็บเอกสารการจำนองอย่างปลอดภัยในระหว่างและหลังขั้นตอนการสมัครจำนอง อา ใบสมัครจำนอง อาจมีแบบฟอร์มและเอกสารหลายประเภท เช่น URLA-1003, 1099-INT/DIV/RR/MISC, W2, paystubs, รายการเดินบัญชีธนาคาร, ใบแจ้งยอดบัตรเครดิต และอื่นๆ เอกสารเหล่านี้จะถูกส่งโดยผู้สมัครในขั้นตอนการสมัครจำนอง หากไม่ตรวจสอบด้วยตนเอง อาจไม่ชัดเจนในทันทีว่าเอกสารใดบ้างที่รวมอยู่ในแพ็กเก็ต กระบวนการด้วยตนเองนี้อาจใช้เวลานานและมีราคาแพง ในระยะต่อไป เราทำให้กระบวนการนี้เป็นแบบอัตโนมัติโดยใช้ Amazon Comprehend เพื่อจัดประเภทเอกสารเป็นหมวดหมู่ที่เกี่ยวข้องกันด้วยความแม่นยำสูง

การจัดประเภทเอกสาร

การจัดประเภทเอกสารเป็นวิธีการที่สามารถจัดประเภทและติดฉลากเอกสารที่ไม่สามารถระบุได้จำนวนมาก เราดำเนินการจัดประเภทเอกสารนี้โดยใช้ Amazon Comprehend ลักษณนามที่กำหนดเอง. ตัวแยกประเภทที่กำหนดเองคือโมเดล ML ที่สามารถฝึกด้วยชุดเอกสารที่มีป้ายกำกับเพื่อจำแนกคลาสที่คุณสนใจ หลังจากที่โมเดลได้รับการฝึกอบรมและปรับใช้เบื้องหลังปลายทางที่โฮสต์แล้ว เราสามารถใช้ตัวแยกประเภทเพื่อกำหนดหมวดหมู่ (หรือคลาส) ของเอกสารเฉพาะ ในกรณีนี้ เราฝึกตัวแยกประเภทแบบกำหนดเองใน โหมดหลายคลาสซึ่งสามารถทำได้ด้วยไฟล์ CSV หรือไฟล์ Manifest เสริม สำหรับวัตถุประสงค์ของการสาธิตนี้ เราใช้ไฟล์ CSV เพื่อฝึกตัวแยกประเภท อ้างถึงของเรา พื้นที่เก็บข้อมูล GitHub สำหรับตัวอย่างโค้ดแบบเต็ม ต่อไปนี้เป็นภาพรวมระดับสูงของขั้นตอนที่เกี่ยวข้อง:

1. แยกข้อความธรรมดาที่เข้ารหัส UTF-8 ออกจากรูปภาพหรือไฟล์ PDF โดยใช้ Amazon Texttract ตรวจหาข้อความเอกสาร API
2. เตรียมข้อมูลการฝึกอบรมเพื่อฝึกตัวแยกประเภทที่กำหนดเองในรูปแบบ CSV
3. ฝึกตัวแยกประเภทที่กำหนดเองโดยใช้ไฟล์ CSV
4. ปรับใช้โมเดลที่ผ่านการฝึกอบรมด้วยปลายทางสำหรับการจัดประเภทเอกสารแบบเรียลไทม์หรือใช้โหมดหลายคลาส ซึ่งรองรับการทำงานแบบเรียลไทม์และแบบอะซิงโครนัส

ไดอะแกรมต่อไปนี้แสดงกระบวนการนี้

คุณสามารถจัดประเภทเอกสารโดยอัตโนมัติโดยใช้ปลายทางที่ปรับใช้เพื่อระบุและจัดหมวดหมู่เอกสาร ระบบอัตโนมัตินี้มีประโยชน์ในการตรวจสอบว่าเอกสารที่จำเป็นทั้งหมดมีอยู่ในแพ็กเก็ตจำนองหรือไม่ เอกสารที่ขาดหายไปสามารถระบุได้อย่างรวดเร็ว โดยไม่ต้องมีการแทรกแซง และแจ้งให้ผู้สมัครทราบล่วงหน้าในกระบวนการ

การแยกเอกสาร

ในขั้นตอนนี้ เราดึงข้อมูลจากเอกสารโดยใช้ Amazon Texttract และ Amazon Comprehend สำหรับเอกสารที่มีโครงสร้างและกึ่งโครงสร้างที่มีแบบฟอร์มและตาราง เราใช้ Amazon Text วิเคราะห์เอกสาร เอพีไอ สำหรับเอกสารเฉพาะทาง เช่น เอกสารประจำตัว Amazon Text จะจัดเตรียม วิเคราะห์ID เอพีไอ เอกสารบางฉบับอาจมีข้อความหนาแน่น และคุณอาจต้องแยกคำสำคัญเฉพาะธุรกิจออกจากเอกสารเหล่านี้ หรือเรียกอีกอย่างว่า หน่วยงาน. เราใช้ การรับรู้เอนทิตีแบบกำหนดเอง ความสามารถของ Amazon Comprehend ในการฝึกอบรมตัวรู้จำเอนทิตีแบบกำหนดเอง ซึ่งสามารถระบุเอนทิตีดังกล่าวจากข้อความที่หนาแน่น

ในส่วนต่อไปนี้ เราจะอธิบายตัวอย่างเอกสารที่มีอยู่ในแพ็กเก็ตใบสมัครจำนอง และอภิปรายถึงวิธีการที่ใช้ในการดึงข้อมูลจากเอกสารเหล่านั้น สำหรับแต่ละตัวอย่างเหล่านี้ ข้อมูลโค้ดและเอาต์พุตตัวอย่างสั้นๆ จะรวมอยู่ด้วย

ดึงข้อมูลจาก Unified Residential Loan Application URLA-1003

ใบสมัครสินเชื่อที่อยู่อาศัยแบบรวม (URLA-1003) เป็นแบบฟอร์มใบสมัครสินเชื่อจำนองมาตรฐานอุตสาหกรรม เป็นเอกสารที่ค่อนข้างซับซ้อนซึ่งมีข้อมูลเกี่ยวกับผู้ขอจำนอง ประเภทของทรัพย์สินที่ซื้อ จำนวนเงินที่จัดหาเงินทุน และรายละเอียดอื่นๆ เกี่ยวกับลักษณะของการซื้ออสังหาริมทรัพย์ ต่อไปนี้เป็นตัวอย่าง URLA-1003 และความตั้งใจของเราคือดึงข้อมูลจากเอกสารที่มีโครงสร้างนี้ เนื่องจากเป็นแบบฟอร์ม เราจึงใช้ AnalyzeDocument API กับประเภทคุณลักษณะของ รูปแบบ.

ประเภทฟีเจอร์ของ FORM จะดึงข้อมูลแบบฟอร์มจากเอกสาร ซึ่งจะถูกส่งกลับในรูปแบบคู่คีย์-ค่า ข้อมูลโค้ดต่อไปนี้ใช้ amazon-textract-textractor ไลบรารี Python เพื่อดึงข้อมูลแบบฟอร์มด้วยโค้ดเพียงไม่กี่บรรทัด วิธีอำนวยความสะดวก call_textract() เรียกไฟล์ AnalyzeDocument ภายใน API และพารามิเตอร์ที่ส่งผ่านไปยังวิธีการสรุปการกำหนดค่าบางอย่างที่ API จำเป็นต้องเรียกใช้งานการแยก Document เป็นวิธีการอำนวยความสะดวกที่ใช้เพื่อช่วยแยกวิเคราะห์การตอบสนอง JSON จาก API มันให้นามธรรมระดับสูงและทำให้เอาต์พุต API ทำซ้ำได้และง่ายต่อการดึงข้อมูลออกมา สำหรับข้อมูลเพิ่มเติม โปรดดูที่ ตัวแยกวิเคราะห์การตอบกลับข้อความ และ ตัวแยกข้อความ.

from textractcaller.t_call import call_textract, Textract_Features
from trp import Document

response_urla_1003 = call_textract(input_document='s3://<your-bucket>/URLA-1003.pdf', 
                                   features=[Textract_Features.FORMS])
doc_urla_1003 = Document(response_urla_1003)
for page in doc_urla_1003.pages:
    forms=[]
    for field in page.form.fields:
        obj={}
        obj[f'{field.key}']=f'{field.value}'
        forms.append(obj)
print(json.dumps(forms, indent=4))

โปรดทราบว่าผลลัพธ์ประกอบด้วยค่าสำหรับกล่องกาเครื่องหมายหรือปุ่มตัวเลือกที่มีอยู่ในแบบฟอร์ม ตัวอย่างเช่น ในเอกสารตัวอย่าง URLA-1003 ค่า การซื้อ ได้เลือกตัวเลือก เอาต์พุตที่สอดคล้องกันสำหรับปุ่มตัวเลือกจะถูกแยกเป็น “Purchase” (คีย์) และ “SELECTED” (ค่า) แสดงว่าได้เลือกปุ่มตัวเลือกแล้ว

[
    { "No. of Units": "1" },
    { "Amount": "$ 450,000.00" },
    { "Year Built": "2010" },
    { "Purchase": "SELECTED" },
    { "Title will be held in what Name(s)": "Alejandro Rosalez" },
    { "Fixed Rate": "SELECTED" },
    ...
]

ดึงข้อมูลจาก 1099 รูปแบบ

แพ็กเก็ตคำขอจำนองอาจมีเอกสาร IRS จำนวนหนึ่ง เช่น 1099-DIV, 1099-INT, 1099-MISC และ 1099-R เอกสารเหล่านี้แสดงรายได้ของผู้สมัครผ่านดอกเบี้ย เงินปันผล และองค์ประกอบรายได้เบ็ดเตล็ดอื่น ๆ ที่เป็นประโยชน์ในระหว่างการรับประกันการจัดจำหน่ายในการตัดสินใจ รูปภาพต่อไปนี้แสดงชุดเอกสารเหล่านี้ซึ่งมีโครงสร้างคล้ายกัน อย่างไรก็ตาม ในบางกรณี เอกสารจะมีข้อมูลแบบฟอร์ม (ทำเครื่องหมายโดยใช้กรอบสีแดงและสีเขียว) รวมถึงข้อมูลแบบตาราง (ทำเครื่องหมายด้วยกรอบสีเหลือง)

ในการดึงข้อมูลแบบฟอร์ม เราใช้รหัสที่คล้ายกันตามที่อธิบายไว้ก่อนหน้าด้วย AnalyzeDocument เอพีไอ เราผ่านคุณสมบัติเพิ่มเติมของ ตาราง ไปที่ API เพื่อระบุว่าเราต้องการทั้งข้อมูลแบบฟอร์มและตารางที่ดึงมาจากเอกสาร ข้อมูลโค้ดต่อไปนี้ใช้ AnalyzeDocument API พร้อมฟีเจอร์ FORMS และ TABLES ในเอกสาร 1099-INT:

from textractcaller.t_call import call_textract, Textract_Features
from trp import Document
response_1099_int = call_textract(input_document='s3://<your-bucket>/1099-INT-2018.pdf',
                                  features=[Textract_Features.TABLES, 
                                            Textract_Features.FORMS])
doc_1099_int = Document(response_1099_int)
num_tables=1
for page in doc_1099_int.pages:     
    for table in page.tables:
        num_tables=num_tables+1
        for r, row in enumerate(table.rows):
            for c, cell in enumerate(row.cells):
                print(f"Cell[{r}][{c}] = {cell.text}")
        print('n')

เนื่องจากเอกสารมีตารางเดียว ผลลัพธ์ของรหัสจึงเป็นดังนี้:

Table 1
-------------------
Cell[0][0] = 15 State 
Cell[0][1] = 16 State identification no. 
Cell[0][2] = 17 State tax withheld 
Cell[1][0] = 
Cell[1][1] = 34564 
Cell[1][2] = $ 2000 
Cell[2][0] = 
Cell[2][1] = 23543 
Cell[2][2] = $ 1000

ข้อมูลตารางประกอบด้วยตำแหน่งเซลล์ (แถว 0, คอลัมน์ 0 เป็นต้น) และข้อความที่เกี่ยวข้องภายในแต่ละเซลล์ เราใช้วิธีอำนวยความสะดวกที่สามารถเปลี่ยนข้อมูลตารางนี้เป็นมุมมองกริดที่อ่านง่าย:

from textractprettyprinter.t_pretty_print import Textract_Pretty_Print, get_string, Pretty_Print_Table_Format
print(get_string(textract_json=response_1099_int, 
                 table_format=Pretty_Print_Table_Format.grid, 
                 output_type=[Textract_Pretty_Print.TABLES]))

เราได้รับผลลัพธ์ต่อไปนี้:

+----------+-----------------------------+-----------------------+
| 15 State | 16 State identification no. | 17 State tax withheld |
+----------+-----------------------------+-----------------------+
|          | 34564                       | $ 2000                |
+----------+-----------------------------+-----------------------+
|          | 23543                       | $ 1000                |
+----------+-----------------------------+-----------------------+

เพื่อให้ได้ผลลัพธ์ในรูปแบบ CSV ที่ง่ายต่อการบริโภค ประเภทรูปแบบของ Pretty_Print_Table_Format.csv สามารถส่งผ่านเข้าสู่ .ได้ table_format พารามิเตอร์. รองรับรูปแบบอื่นๆ เช่น TSV (ค่าที่คั่นด้วยแท็บ), HTML และ Latex สำหรับข้อมูลเพิ่มเติม โปรดดูที่ Text-PrettyPrinter.

ดึงข้อมูลจากใบจำนอง

แพ็กเก็ตใบสมัครจำนองอาจมีเอกสารที่ไม่มีโครงสร้างและมีข้อความหนาแน่น ตัวอย่างของเอกสารข้อความหนาแน่น ได้แก่ สัญญาและข้อตกลง บันทึกการจำนองเป็นข้อตกลงระหว่างผู้ยื่นคำขอจำนองกับผู้ให้กู้หรือบริษัทจำนอง และมีข้อมูลในย่อหน้าที่มีข้อความหนาแน่น ในกรณีเช่นนี้ การขาดโครงสร้างทำให้ยากต่อการค้นหาข้อมูลสำคัญทางธุรกิจที่มีความสำคัญในกระบวนการขอสินเชื่อ มีสองวิธีในการแก้ปัญหานี้:

ในบันทึกการจำนองตัวอย่างต่อไปนี้ เราสนใจที่จะค้นหาจำนวนเงินที่ชำระรายเดือนและเงินต้นเป็นพิเศษ

สำหรับแนวทางแรก เราใช้ Query และ QueriesConfig วิธีอำนวยความสะดวกในการกำหนดค่าชุดคำถามที่ส่งไปยัง Amazon Texttract AnalyzeDocument การเรียก API ในกรณีที่เอกสารมีหลายหน้า (PDF หรือ TIFF) เรายังสามารถระบุหมายเลขหน้าที่ Amazon Texttract ควรค้นหาคำตอบสำหรับคำถาม ข้อมูลโค้ดต่อไปนี้สาธิตวิธีสร้างการกำหนดค่าการสืบค้น ทำการเรียก API และแยกวิเคราะห์การตอบสนองในภายหลังเพื่อรับคำตอบจากการตอบกลับ:

from textractcaller import QueriesConfig, Query
import trp.trp2 as t2

#Setup the queries
query2 = Query(text="What is the principal amount borrower has to pay?", alias="PRINCIPAL_AMOUNT", pages=["1"])
query4 = Query(text="What is the monthly payment amount?", alias="MONTHLY_AMOUNT", pages=["1"])

#Setup the query config with the above queries
queries_config = QueriesConfig(queries=[query1, query2, query3, query4])
#Call AnalyzeDocument with the queries_config
response_mortgage_note = call_textract(input_document='s3://<your-bucket>/Mortgage-Note.pdf',
                                       features=[Textract_Features.QUERIES],
                                       queries_config=queries_config)
doc_mortgage_note: t2.TDocumentSchema = t2.TDocumentSchema().load(response_mortgage_note) 

entities = {}
for page in doc_mortgage_note.pages:
    query_answers = doc_mortgage_note.get_query_answers(page=page)
    if query_answers:
        for answer in query_answers:
            entities[answer[1]] = answer[2]
print(entities)

เราได้รับผลลัพธ์ต่อไปนี้:

{
    'PRINCIPAL_AMOUNT': '$ 555,000.00',
    'MONTHLY_AMOUNT': '$2,721.23',
}

สำหรับแนวทางที่สอง เราใช้ Amazon Comprehend ตรวจหาเอนทิตี API พร้อมบันทึกการจำนอง ซึ่งส่งคืนเอนทิตีที่ตรวจพบภายในข้อความจาก a ชุดเอนทิตีที่กำหนดไว้ล่วงหน้า. สิ่งเหล่านี้คือเอนทิตีที่ตัวรู้จำเอนทิตีของ Amazon Comprehend ได้รับการฝึกอบรมล่วงหน้าด้วย อย่างไรก็ตาม เนื่องจากข้อกำหนดของเราคือการตรวจจับเอนทิตีเฉพาะ ตัวรู้จำเอนทิตีแบบกำหนดเองของ Amazon Comprehend จึงได้รับการฝึกอบรมด้วยชุดตัวอย่างเอกสารบันทึกการจำนองและรายการเอนทิตี เรากำหนดชื่อเอนทิตีเป็น PRINCIPAL_AMOUNT และ MONTHLY_AMOUNT. ข้อมูลการฝึกอบรมจัดทำขึ้นตามการฝึกอบรม Amazon Comprehend แนวทางการจัดเตรียมข้อมูล สำหรับการรับรู้เอนทิตีแบบกำหนดเอง ตัวรู้จำเอนทิตีสามารถฝึกได้ด้วย คำอธิบายประกอบเอกสาร หรือกับ รายการนิติบุคคล. สำหรับจุดประสงค์ของตัวอย่างนี้ เราใช้รายการเอนทิตีเพื่อฝึกโมเดล หลังจากที่เราฝึกโมเดล เราสามารถปรับใช้กับ a จุดสิ้นสุดตามเวลาจริง หรือใน โหมดแบทช์ เพื่อตรวจหาเอนทิตีทั้งสองจากเนื้อหาเอกสาร ต่อไปนี้คือขั้นตอนที่เกี่ยวข้องในการฝึกอบรมตัวจำแนกเอนทิตีแบบกำหนดเองและปรับใช้ สำหรับคำแนะนำแบบสมบูรณ์ โปรดดูที่ที่เก็บ GitHub ของเรา

1. เตรียมข้อมูลการฝึกอบรม (รายการเอนทิตีและเอกสารที่มีรูปแบบข้อความธรรมดา (เข้ารหัส UTF-8))
2. เริ่มการฝึกอบรมตัวจำแนกเอนทิตีโดยใช้ CreateEntityRecognizer API โดยใช้ข้อมูลการฝึกอบรม
3. ปรับใช้โมเดลที่ผ่านการฝึกอบรมด้วยปลายทางแบบเรียลไทม์โดยใช้ สร้างจุดสิ้นสุด API

ดึงข้อมูลจากหนังสือเดินทางสหรัฐ

สารสกัดอเมซอน วิเคราะห์เอกสารประจำตัว ความสามารถสามารถตรวจจับและดึงข้อมูลจากเอกสารประจำตัวของสหรัฐฯ เช่น ใบขับขี่และหนังสือเดินทาง ดิ AnalyzeID API มีความสามารถในการตรวจจับและตีความฟิลด์โดยนัยในเอกสาร ID ซึ่งทำให้ง่ายต่อการดึงข้อมูลเฉพาะจากเอกสาร เอกสารระบุตัวตนมักเป็นส่วนหนึ่งของชุดคำขอจำนอง เนื่องจากใช้เพื่อยืนยันตัวตนของผู้กู้ในระหว่างกระบวนการรับประกัน และเพื่อตรวจสอบความถูกต้องของข้อมูลชีวประวัติของผู้ยืม

เราใช้วิธีการอำนวยความสะดวกที่ชื่อว่า call_textract_analyzeidซึ่งเรียก AnalyzeID API ภายใน จากนั้นเราทำซ้ำการตอบสนองเพื่อรับคู่คีย์-ค่าที่ตรวจพบจากเอกสาร ID ดูรหัสต่อไปนี้:

from textractcaller import call_textract_analyzeid
import trp.trp2_analyzeid as t2id

response_passport = call_textract_analyzeid(document_pages=['s3://<your-bucket>/Passport.pdf'])
doc_passport: t2id.TAnalyzeIdDocument = t2id.TAnalyzeIdDocumentSchema().load(response_passport)

for id_docs in response_passport['IdentityDocuments']:
    id_doc_kvs={}
    for field in id_docs['IdentityDocumentFields']:
        if field['ValueDetection']['Text']:
            id_doc_kvs[field['Type']['Text']] = field['ValueDetection']['Text']
print(id_doc_kvs)

AnalyzeID ส่งกลับข้อมูลในโครงสร้างที่เรียกว่า IdentityDocumentFieldsซึ่งมีคีย์ที่ทำให้เป็นมาตรฐานและค่าที่สอดคล้องกัน ตัวอย่างเช่นในผลลัพธ์ต่อไปนี้ FIRST_NAME เป็นคีย์ปกติและค่าเป็น ALEJANDRO. ในภาพหนังสือเดินทางตัวอย่าง ฟิลด์สำหรับชื่อจะมีป้ายกำกับว่า “Given Names / Prénoms / Nombre” AnalyzeID สามารถทำให้เป็นมาตรฐานได้เป็นชื่อคีย์ FIRST_NAME. สำหรับรายการฟิลด์นอร์มัลไลซ์ที่รองรับ โปรดดูที่ อ็อบเจ็กต์การตอบกลับเอกสารประจำตัว.

{
    'FIRST_NAME': 'ALEJANDRO',
    'LAST_NAME': 'ROSALEZ',
    'DOCUMENT_NUMBER': '918268822',
    'EXPIRATION_DATE': '31 JAN 2029',
    'DATE_OF_BIRTH': '15 APR 1990',
    'DATE_OF_ISSUE': '29 JAN 2009',
    'ID_TYPE': 'PASSPORT',
    'ENDORSEMENTS': 'SEE PAGE 27',
    'PLACE_OF_BIRTH': 'TEXAS U.S.A.'
}

แพ็กเก็ตจำนองอาจมีเอกสารอื่นๆ เช่น paystub แบบฟอร์ม W2 ใบแจ้งยอดธนาคาร ใบแจ้งยอดบัตรเครดิต และจดหมายยืนยันการจ้างงาน เรามีตัวอย่างสำหรับเอกสารเหล่านี้แต่ละฉบับพร้อมกับรหัสที่จำเป็นในการดึงข้อมูลจากเอกสารเหล่านี้ สำหรับฐานรหัสทั้งหมด โปรดดูสมุดบันทึกใน .ของเรา พื้นที่เก็บข้อมูล GitHub.

การตกแต่งเอกสาร

หนึ่งในรูปแบบที่พบบ่อยที่สุดของการตกแต่งเอกสารคือ การเปิดเผยข้อมูลที่ละเอียดอ่อนหรือเป็นความลับในเอกสาร ซึ่งอาจได้รับคำสั่งเนื่องจากกฎหมายหรือข้อบังคับเกี่ยวกับความเป็นส่วนตัว ตัวอย่างเช่น paystub ของผู้ขอจำนองอาจมีข้อมูล PII ที่ละเอียดอ่อน เช่น ชื่อ ที่อยู่ และ SSN ที่อาจต้องมีการแก้ไขสำหรับพื้นที่จัดเก็บเพิ่มเติม

ในเอกสาร paystub ตัวอย่างก่อนหน้านี้ เราดำเนินการแก้ไขข้อมูล PII เช่น SSN ชื่อ หมายเลขบัญชีธนาคาร และวันที่ ในการระบุข้อมูล PII ในเอกสาร เราใช้ Amazon Comprehend การตรวจจับ PII ความสามารถผ่าน ตรวจหา PIIEntities เอพีไอ API นี้จะตรวจสอบเนื้อหาของเอกสารเพื่อระบุการมีอยู่ของข้อมูล PII เนื่องจาก API นี้ต้องการอินพุตในรูปแบบข้อความธรรมดาที่เข้ารหัส UTF-8 เราจึงแยกข้อความออกจากเอกสารโดยใช้ Amazon Texttract ตรวจหาข้อความเอกสาร API ซึ่งส่งคืนข้อความจากเอกสารและส่งคืนข้อมูลทางเรขาคณิต เช่น ขนาดและพิกัดของกรอบ จากนั้นนำเอาเอาท์พุตทั้งสองมาผสมกันเพื่อวาดการแก้ไขบนเอกสารซึ่งเป็นส่วนหนึ่งของกระบวนการตกแต่ง

ตรวจสอบ ตรวจสอบ และรวมข้อมูล

ข้อมูลที่ดึงออกมาจากขั้นตอนการดึงเอกสารอาจต้องมีการตรวจสอบกับกฎเกณฑ์ทางธุรกิจที่เฉพาะเจาะจง ข้อมูลเฉพาะอาจได้รับการตรวจสอบในเอกสารหลายฉบับหรือที่เรียกว่า การตรวจสอบข้ามเอกสาร. ตัวอย่างการตรวจสอบข้ามเอกสารสามารถเปรียบเทียบชื่อผู้สมัครในเอกสารประจำตัวกับชื่อในเอกสารคำขอจำนองได้ คุณยังสามารถทำการตรวจสอบความถูกต้องอื่นๆ เช่น การประเมินมูลค่าทรัพย์สินและการตัดสินใจรับประกันภัยตามเงื่อนไขในระยะนี้

การตรวจสอบประเภทที่สามเกี่ยวข้องกับคะแนนความเชื่อมั่นของข้อมูลที่แยกออกมาในขั้นตอนการแยกเอกสาร Amazon Texttract และ Amazon Comprehend ส่งคืนคะแนนความเชื่อมั่นสำหรับแบบฟอร์ม ตาราง ข้อมูลข้อความ และเอนทิตีที่ตรวจพบ คุณสามารถกำหนดค่าเกณฑ์คะแนนความเชื่อมั่นเพื่อให้แน่ใจว่าระบบจะส่งเฉพาะค่าที่ถูกต้องเท่านั้น ซึ่งทำได้ผ่าน Amazon A2I ซึ่งเปรียบเทียบคะแนนความเชื่อมั่นของข้อมูลที่ตรวจพบกับเกณฑ์ความเชื่อมั่นที่กำหนดไว้ล่วงหน้า หากไม่เป็นไปตามเกณฑ์ เอกสารและเอาต์พุตที่แยกออกมาจะถูกส่งไปยังเจ้าหน้าที่เพื่อตรวจสอบผ่าน UI ที่ใช้งานง่าย ผู้ตรวจสอบจะดำเนินการแก้ไขข้อมูลและบันทึกเพื่อดำเนินการต่อไป สำหรับข้อมูลเพิ่มเติม โปรดดูที่ แนวคิดหลักของ Amazon A2I.

สรุป

ในโพสต์นี้ เราได้พูดถึงขั้นตอนของการประมวลผลเอกสารอัจฉริยะที่เกี่ยวข้องกับขั้นตอนของการขอสินเชื่อ เราดูตัวอย่างทั่วไปของเอกสารที่สามารถพบได้ในแพ็กเก็ตใบสมัครจำนอง นอกจากนี้เรายังกล่าวถึงวิธีการแยกและประมวลผลเนื้อหาที่มีโครงสร้าง กึ่งมีโครงสร้าง และไม่มีโครงสร้างจากเอกสารเหล่านี้ IDP มอบวิธีในการประมวลผลเอกสารจำนองแบบ end-to-end โดยอัตโนมัติ ซึ่งสามารถปรับขนาดเป็นเอกสารหลายล้านฉบับ ปรับปรุงคุณภาพของการตัดสินใจในการสมัคร ลดต้นทุน และให้บริการลูกค้าได้รวดเร็วยิ่งขึ้น

ในขั้นตอนต่อไป คุณสามารถลองใช้ตัวอย่างโค้ดและโน้ตบุ๊กใน พื้นที่เก็บข้อมูล GitHub. หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับวิธีที่ IDP สามารถช่วยปริมาณงานในการประมวลผลเอกสารของคุณ โปรดไปที่ ประมวลผลข้อมูลจากเอกสารโดยอัตโนมัติ.

เกี่ยวกับผู้แต่ง

อัญชัน บิสวาส เป็นสถาปนิกอาวุโสด้านโซลูชันบริการ AI โดยมุ่งเน้นที่ AI/ML และการวิเคราะห์ข้อมูล Anjan เป็นส่วนหนึ่งของทีมบริการ AI ทั่วโลกและทำงานร่วมกับลูกค้าเพื่อช่วยให้พวกเขาเข้าใจ และพัฒนาวิธีแก้ปัญหาทางธุรกิจด้วย AI และ ML Anjan มีประสบการณ์มากกว่า 14 ปีในการทำงานกับองค์กรซัพพลายเชน การผลิต และการค้าปลีกระดับโลก และคอยช่วยเหลือลูกค้าในการเริ่มต้นและปรับขนาดบริการ AWS AI

ทวิติ ปะตัก เป็นผู้จัดการบัญชีด้านเทคนิคอาวุโสในซานดิเอโก เธอมุ่งเน้นที่การช่วยเหลืออุตสาหกรรมเซมิคอนดักเตอร์ให้มีส่วนร่วมใน AWS ในเวลาว่าง เธอชอบอ่านเกี่ยวกับเทคโนโลยีใหม่ๆ และเล่นเกมกระดาน

บาลาจี ปูหลี่ เป็นสถาปนิกโซลูชั่นที่ตั้งอยู่ในเบย์แอเรีย แคลิฟอร์เนีย ขณะนี้ได้ช่วยเหลือลูกค้าด้านวิทยาศาสตร์ชีวภาพด้านการดูแลสุขภาพในภาคตะวันตกเฉียงเหนือของสหรัฐฯ ให้เร่งการนำ AWS Cloud ไปใช้ Balaji สนุกกับการเดินทางและชอบสำรวจอาหารต่างๆ