การจัดการตัวประมวลผล Document AI ด้วย Python

1. ภาพรวม

c6d2ea69b1ba0eff.png

Document AI คืออะไร

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

คุณจัดการตัวประมวลผล Document AI ได้ 2 วิธี ดังนี้

  • ด้วยตนเอง จากเว็บคอนโซล
  • แบบเป็นโปรแกรม โดยใช้ Document AI API

ต่อไปนี้คือภาพหน้าจอตัวอย่างที่แสดงรายการโปรเซสเซอร์ ทั้งจากเว็บคอนโซลและจากโค้ด Python

312f0e9b3a8b8291.png

ในห้องทดลองนี้ คุณจะมุ่งเน้นที่การจัดการตัวประมวลผล Document AI แบบเป็นโปรแกรมด้วยไลบรารีของไคลเอ็นต์ Python

สิ่งที่คุณจะเห็น

  • วิธีตั้งค่าสภาพแวดล้อม
  • วิธีดึงข้อมูลประเภทตัวประมวลผลข้อมูล
  • วิธีสร้างโปรเซสเซอร์
  • วิธีแสดงรายการผู้ประมวลผลข้อมูลโปรเจ็กต์
  • วิธีใช้โปรเซสเซอร์
  • วิธีเปิด/ปิดใช้ตัวประมวลผล
  • วิธีจัดการเวอร์ชันของโปรเซสเซอร์
  • วิธีลบตัวประมวลผล

สิ่งที่คุณต้องมี

  • โปรเจ็กต์ Google Cloud
  • เบราว์เซอร์ เช่น Chrome หรือ Firefox
  • ความคุ้นเคยกับการใช้ Python

แบบสำรวจ

คุณจะใช้บทแนะนำนี้อย่างไร

อ่านเท่านั้น อ่านและทำแบบฝึกหัด

คุณจะให้คะแนนประสบการณ์การใช้งาน Python อย่างไร

มือใหม่ ระดับกลาง ผู้ชำนาญ

คุณจะให้คะแนนประสบการณ์การใช้งานบริการ Google Cloud อย่างไร

มือใหม่ ระดับกลาง ผู้ชำนาญ

2. การตั้งค่าและข้อกำหนด

การตั้งค่าสภาพแวดล้อมตามเวลาที่สะดวก

  1. ลงชื่อเข้าใช้ Google Cloud Console และสร้างโปรเจ็กต์ใหม่หรือใช้โปรเจ็กต์ที่มีอยู่ซ้ำ หากยังไม่มีบัญชี Gmail หรือ Google Workspace คุณต้องสร้างบัญชี

295004821bab6a87.png

37d264871000675d.png

96d86d3d5655cdbe.png

  • ชื่อโครงการคือชื่อที่แสดงของผู้เข้าร่วมโปรเจ็กต์นี้ เป็นสตริงอักขระที่ Google APIs ไม่ได้ใช้ โดยคุณจะอัปเดตวิธีการชำระเงินได้ทุกเมื่อ
  • รหัสโปรเจ็กต์จะไม่ซ้ำกันในทุกโปรเจ็กต์ของ Google Cloud และจะเปลี่ยนแปลงไม่ได้ (เปลี่ยนแปลงไม่ได้หลังจากตั้งค่าแล้ว) Cloud Console จะสร้างสตริงที่ไม่ซ้ำกันโดยอัตโนมัติ ปกติแล้วคุณไม่สนว่าอะไรเป็นอะไร ใน Codelab ส่วนใหญ่ คุณจะต้องอ้างอิงรหัสโปรเจ็กต์ (โดยปกติจะระบุเป็น PROJECT_ID) หากคุณไม่ชอบรหัสที่สร้างขึ้น คุณสามารถสร้างรหัสแบบสุ่มอื่นได้ หรือคุณจะลองดำเนินการเองแล้วดูว่าพร้อมให้ใช้งานหรือไม่ คุณจะเปลี่ยนแปลงหลังจากขั้นตอนนี้ไม่ได้และจะยังคงอยู่ตลอดระยะเวลาของโปรเจ็กต์
  • สำหรับข้อมูลของคุณ ค่าที่ 3 คือหมายเลขโปรเจ็กต์ ซึ่ง API บางตัวใช้ ดูข้อมูลเพิ่มเติมเกี่ยวกับค่าทั้ง 3 ค่าได้ในเอกสารประกอบ
  1. ถัดไป คุณจะต้องเปิดใช้การเรียกเก็บเงินใน Cloud Console เพื่อใช้ทรัพยากร/API ของระบบคลาวด์ การใช้งาน Codelab นี้จะไม่มีค่าใช้จ่ายใดๆ หากมี หากต้องการปิดทรัพยากรเพื่อหลีกเลี่ยงการเรียกเก็บเงินที่นอกเหนือจากบทแนะนำนี้ คุณสามารถลบทรัพยากรที่คุณสร้างหรือลบโปรเจ็กต์ได้ ผู้ใช้ Google Cloud ใหม่มีสิทธิ์เข้าร่วมโปรแกรมช่วงทดลองใช้ฟรี$300 USD

เริ่มต้น Cloud Shell

แม้ว่า Google Cloud จะทำงานจากระยะไกลจากแล็ปท็อปได้ แต่ในห้องทดลองนี้ คุณใช้ Cloud Shell ซึ่งเป็นสภาพแวดล้อมแบบบรรทัดคำสั่งที่ทำงานในระบบคลาวด์อยู่

เปิดใช้งาน Cloud Shell

  1. คลิกเปิดใช้งาน Cloud Shell d1264ca30785e435.png จาก Cloud Console

cb81e7c8e34bc8d.png

หากเริ่มต้นใช้งาน Cloud Shell เป็นครั้งแรก คุณจะเห็นหน้าจอตรงกลางที่อธิบายว่านี่คืออะไร หากระบบแสดงหน้าจอตรงกลาง ให้คลิกต่อไป

d95252b003979716.png

การจัดสรรและเชื่อมต่อกับ Cloud Shell ใช้เวลาเพียงไม่กี่นาที

7833d5e1c5d18f54.png

เครื่องเสมือนนี้โหลดด้วยเครื่องมือการพัฒนาทั้งหมดที่จำเป็น โดยมีไดเรกทอรีหลักขนาด 5 GB ถาวรและทำงานใน Google Cloud ซึ่งช่วยเพิ่มประสิทธิภาพของเครือข่ายและการตรวจสอบสิทธิ์ได้อย่างมาก งานส่วนใหญ่ใน Codelab นี้สามารถทำได้โดยใช้เบราว์เซอร์

เมื่อเชื่อมต่อกับ Cloud Shell แล้ว คุณควรเห็นข้อความตรวจสอบสิทธิ์และโปรเจ็กต์ได้รับการตั้งค่าเป็นรหัสโปรเจ็กต์แล้ว

  1. เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell เพื่อยืนยันว่าคุณได้รับการตรวจสอบสิทธิ์แล้ว
gcloud auth list

เอาต์พุตจากคำสั่ง

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`
  1. เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell เพื่อยืนยันว่าคำสั่ง gcloud รู้เกี่ยวกับโปรเจ็กต์ของคุณ
gcloud config list project

เอาต์พุตจากคำสั่ง

[core]
project = <PROJECT_ID>

หากไม่ใช่ ให้ตั้งคำสั่งด้วยคำสั่งนี้

gcloud config set project <PROJECT_ID>

เอาต์พุตจากคำสั่ง

Updated property [core/project].

3. การตั้งค่าสภาพแวดล้อม

ก่อนที่จะเริ่มใช้ Document AI ให้เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell เพื่อเปิดใช้ Document AI API

gcloud services enable documentai.googleapis.com

คุณควรจะเห็นบางสิ่งเช่นนี้:

Operation "operations/..." finished successfully.

คุณใช้ Document AI ได้แล้ว

ไปที่ไดเรกทอรีหน้าแรก

cd ~

สร้างสภาพแวดล้อมเสมือนของ Python เพื่อแยกทรัพยากร Dependency ต่อไปนี้

virtualenv venv-docai

เปิดใช้งานสภาพแวดล้อมเสมือน

source venv-docai/bin/activate

ติดตั้ง IPython, ไลบรารีของไคลเอ็นต์ Document AI และ Python-tabulate (ซึ่งคุณจะใช้เพื่อพิมพ์ผลลัพธ์ของคำขอ)

pip install ipython google-cloud-documentai tabulate

คุณควรจะเห็นบางสิ่งเช่นนี้:

...
Installing collected packages: ..., tabulate, ipython, google-cloud-documentai
Successfully installed ... google-cloud-documentai-2.15.0 ...

ตอนนี้คุณก็พร้อมใช้ไลบรารีของไคลเอ็นต์ Document AI แล้ว

ตั้งค่าตัวแปรสภาพแวดล้อมต่อไปนี้

export PROJECT_ID=$(gcloud config get-value core/project)

# Choose "us" or "eu"
export API_LOCATION="us"

จากนี้ไปขั้นตอนทั้งหมดควรที่แล้วเสร็จในเซสชันเดียวกัน

ตรวจสอบว่าได้กำหนดตัวแปรสภาพแวดล้อมอย่างถูกต้อง ดังนี้

echo $PROJECT_ID

echo $API_LOCATION

ในขั้นตอนถัดไป คุณจะต้องใช้ล่าม Python แบบอินเทอร์แอกทีฟที่ชื่อ IPython ซึ่งคุณเพิ่งติดตั้ง เริ่มเซสชันโดยการเรียกใช้ ipython ใน Cloud Shell:

ipython

คุณควรจะเห็นบางสิ่งเช่นนี้:

Python 3.9.2 (default, Feb 28 2021, 17:03:44)
Type 'copyright', 'credits' or 'license' for more information
IPython 8.14.0 -- An enhanced Interactive Python. Type '?' for help.

In [1]:

คัดลอกโค้ดต่อไปนี้ลงในเซสชัน IPython

import os
from typing import Iterator, MutableSequence, Optional, Sequence, Tuple

import google.cloud.documentai_v1 as docai
from tabulate import tabulate

PROJECT_ID = os.getenv("PROJECT_ID", "")
API_LOCATION = os.getenv("API_LOCATION", "")

assert PROJECT_ID, "PROJECT_ID is undefined"
assert API_LOCATION in ("us", "eu"), "API_LOCATION is incorrect"

# Test processors
document_ocr_display_name = "document-ocr"
form_parser_display_name = "form-parser"

test_processor_display_names_and_types = (
    (document_ocr_display_name, "OCR_PROCESSOR"),
    (form_parser_display_name, "FORM_PARSER_PROCESSOR"),
)

def get_client() -> docai.DocumentProcessorServiceClient:
    client_options = {"api_endpoint": f"{API_LOCATION}-documentai.googleapis.com"}
    return docai.DocumentProcessorServiceClient(client_options=client_options)

def get_parent(client: docai.DocumentProcessorServiceClient) -> str:
    return client.common_location_path(PROJECT_ID, API_LOCATION)

def get_client_and_parent() -> Tuple[docai.DocumentProcessorServiceClient, str]:
    client = get_client()
    parent = get_parent(client)
    return client, parent

คุณพร้อมส่งคำขอแรกและดึงข้อมูลประเภทผู้ประมวลผลข้อมูลแล้ว

4. กำลังดึงข้อมูลประเภทโปรเซสเซอร์

ก่อนที่จะสร้างโปรเซสเซอร์ในขั้นตอนถัดไป ให้ดึงข้อมูลประเภทโปรเซสเซอร์ที่มีอยู่ คุณเรียกข้อมูลรายการนี้ได้ด้วย fetch_processor_types

เพิ่มฟังก์ชันต่อไปนี้ในเซสชัน IPython

def fetch_processor_types() -> MutableSequence[docai.ProcessorType]:
    client, parent = get_client_and_parent()
    response = client.fetch_processor_types(parent=parent)

    return response.processor_types

def print_processor_types(processor_types: Sequence[docai.ProcessorType]):
    def sort_key(pt):
        return (not pt.allow_creation, pt.category, pt.type_)

    sorted_processor_types = sorted(processor_types, key=sort_key)
    data = processor_type_tabular_data(sorted_processor_types)
    headers = next(data)
    colalign = next(data)

    print(tabulate(data, headers, tablefmt="pretty", colalign=colalign))
    print(f"→ Processor types: {len(sorted_processor_types)}")

def processor_type_tabular_data(
    processor_types: Sequence[docai.ProcessorType],
) -> Iterator[Tuple[str, str, str, str]]:
    def locations(pt):
        return ", ".join(sorted(loc.location_id for loc in pt.available_locations))

    yield ("type", "category", "allow_creation", "locations")
    yield ("left", "left", "left", "left")
    if not processor_types:
        yield ("-", "-", "-", "-")
        return
    for pt in processor_types:
        yield (pt.type_, pt.category, f"{pt.allow_creation}", locations(pt))

แสดงรายการประเภทโปรเซสเซอร์ดังนี้

processor_types = fetch_processor_types()
print_processor_types(processor_types)

ซึ่งคุณควรจะได้รับสิ่งต่อไปนี้

+---------------------------------+-------------+----------------+------------+
| type                            | category    | allow_creation | locations  |
+---------------------------------+-------------+----------------+------------+
| CUSTOM_CLASSIFICATION_PROCESSOR | CUSTOM      | True           | eu, us...  |
| CUSTOM_EXTRACTION_PROCESSOR     | CUSTOM      | True           | eu, us...  |
| FORM_PARSER_PROCESSOR           | GENERAL     | True           | eu, us...  |
| OCR_PROCESSOR                   | GENERAL     | True           | eu, us...  |
| EXPENSE_PROCESSOR               | SPECIALIZED | True           | eu, us...  |
...
+---------------------------------+-------------+----------------+------------+
→ Processor types: 40

ตอนนี้คุณก็มีข้อมูลทั้งหมดที่ต้องใช้ในการสร้างโปรเซสเซอร์ในขั้นตอนถัดไปแล้ว

5. การสร้างโปรเซสเซอร์

หากต้องการสร้างโปรเซสเซอร์ ให้เรียก create_processor พร้อมชื่อที่แสดงและประเภทโปรเซสเซอร์

เพิ่มฟังก์ชันต่อไปนี้

def create_processor(display_name: str, type: str) -> docai.Processor:
    client, parent = get_client_and_parent()
    processor = docai.Processor(display_name=display_name, type_=type)

    return client.create_processor(parent=parent, processor=processor)

สร้างโปรเซสเซอร์ทดสอบดังนี้

separator = "=" * 80
for display_name, type in test_processor_display_names_and_types:
    print(separator)
    print(f"Creating {display_name} ({type})...")
    try:
        create_processor(display_name, type)
    except Exception as err:
        print(err)
print(separator)
print("Done")

ซึ่งคุณควรจะได้รับสิ่งต่อไปนี้

================================================================================
Creating document-ocr (OCR_PROCESSOR)...
================================================================================
Creating form-parser (FORM_PARSER_PROCESSOR)...
================================================================================
Done

คุณสร้างผู้ประมวลผลข้อมูลใหม่แล้ว

ถัดไป โปรดดูวิธีแสดงรายการโปรเซสเซอร์

6. แสดงรายการผู้ประมวลผลข้อมูลโปรเจ็กต์

list_processors จะแสดงรายการโปรเซสเซอร์ทั้งหมดที่เป็นของโปรเจ็กต์ของคุณ

เพิ่มฟังก์ชันต่อไปนี้

def list_processors() -> MutableSequence[docai.Processor]:
    client, parent = get_client_and_parent()
    response = client.list_processors(parent=parent)

    return list(response.processors)

def print_processors(processors: Optional[Sequence[docai.Processor]] = None):
    def sort_key(processor):
        return processor.display_name

    if processors is None:
        processors = list_processors()
    sorted_processors = sorted(processors, key=sort_key)
    data = processor_tabular_data(sorted_processors)
    headers = next(data)
    colalign = next(data)

    print(tabulate(data, headers, tablefmt="pretty", colalign=colalign))
    print(f"→ Processors: {len(sorted_processors)}")

def processor_tabular_data(
    processors: Sequence[docai.Processor],
) -> Iterator[Tuple[str, str, str]]:
    yield ("display_name", "type", "state")
    yield ("left", "left", "left")
    if not processors:
        yield ("-", "-", "-")
        return
    for processor in processors:
        yield (processor.display_name, processor.type_, processor.state.name)

เรียกใช้ฟังก์ชัน

processors = list_processors()
print_processors(processors)

ซึ่งคุณควรจะได้รับสิ่งต่อไปนี้

+--------------+-----------------------+---------+
| display_name | type                  | state   |
+--------------+-----------------------+---------+
| document-ocr | OCR_PROCESSOR         | ENABLED |
| form-parser  | FORM_PARSER_PROCESSOR | ENABLED |
+--------------+-----------------------+---------+
→ Processors: 2

หากต้องการเรียกข้อมูลโปรเซสเซอร์ตามชื่อที่แสดง ให้เพิ่มฟังก์ชันต่อไปนี้

def get_processor(
    display_name: str,
    processors: Optional[Sequence[docai.Processor]] = None,
) -> Optional[docai.Processor]:
    if processors is None:
        processors = list_processors()
    for processor in processors:
        if processor.display_name == display_name:
            return processor
    return None

ทดสอบฟังก์ชัน

processor = get_processor(document_ocr_display_name, processors)

assert processor is not None
print(processor)

คุณควรจะเห็นบางสิ่งเช่นนี้:

name: "projects/PROJECT_NUM/locations/LOCATION/processors/PROCESSOR_ID"
type_: "OCR_PROCESSOR"
display_name: "document-ocr"
state: ENABLED
...

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

7. การใช้โปรเซสเซอร์

ระบบสามารถประมวลผลเอกสารได้ 2 วิธี ดังนี้

  • พร้อมกัน: เรียกใช้ process_document เพื่อวิเคราะห์เอกสารเดียวและใช้ผลลัพธ์โดยตรง
  • ไม่พร้อมกัน: เรียกใช้ batch_process_documents เพื่อเปิดการประมวลผลแบบกลุ่มในเอกสารขนาดใหญ่หรือเอกสารหลายฉบับ

เอกสารการทดสอบ ( PDF) คือแบบสอบถามที่สแกนซึ่งมีคำตอบที่เขียนด้วยลายมือ ดาวน์โหลดลงในไดเรกทอรีที่ใช้งานอยู่จากเซสชัน IPython ได้โดยตรง โดยทำดังนี้

!gsutil cp gs://cloud-samples-data/documentai/form.pdf .

ตรวจสอบเนื้อหาไดเรกทอรีที่ใช้งานอยู่ ดังนี้

!ls

คุณควรมีสิ่งต่อไปนี้

...  form.pdf  ...  venv-docai  ...

คุณใช้เมธอด process_document แบบพร้อมกันเพื่อวิเคราะห์ไฟล์ในเครื่องได้ เพิ่มฟังก์ชันต่อไปนี้

def process_file(
    processor: docai.Processor,
    file_path: str,
    mime_type: str,
) -> docai.Document:
    client = get_client()
    with open(file_path, "rb") as document_file:
        document_content = document_file.read()
    document = docai.RawDocument(content=document_content, mime_type=mime_type)
    request = docai.ProcessRequest(raw_document=document, name=processor.name)

    response = client.process_document(request)

    return response.document

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

วิเคราะห์เอกสารดังนี้

processor = get_processor(form_parser_display_name)
assert processor is not None

file_path = "./form.pdf"
mime_type = "application/pdf"

document = process_file(processor, file_path, mime_type)

โปรเซสเซอร์ทั้งหมดจะเรียกใช้การรู้จำอักขระด้วยภาพ (OCR) กับเอกสารก่อน ตรวจสอบข้อความที่ตรวจพบโดยบัตร OCR ดังนี้

document.text.split("\n")

คุณควรจะเห็นข้อมูลต่อไปนี้

['FakeDoc M.D.',
 'HEALTH INTAKE FORM',
 'Please fill out the questionnaire carefully. The information you provide will be used to complete',
 'your health profile and will be kept confidential.',
 'Date:',
 'Sally',
 'Walker',
 'Name:',
 '9/14/19',
 'DOB: 09/04/1986',
 'Address: 24 Barney Lane City: Towaco State: NJ Zip: 07082',
 'Email: Sally, waller@cmail.com Phone #: (906) 917-3486',
 'Gender: F',
 'Single Occupation: Software Engineer',
 'Referred By: None',
 'Emergency Contact: Eva Walker Emergency Contact Phone: (906) 334-8976',
 'Marital Status:',
  ...
]

เพิ่มฟังก์ชันต่อไปนี้เพื่อพิมพ์ช่องในแบบฟอร์มที่ตรวจพบ

def print_form_fields(document: docai.Document):
    sorted_form_fields = form_fields_sorted_by_ocr_order(document)
    data = form_field_tabular_data(sorted_form_fields, document)
    headers = next(data)
    colalign = next(data)

    print(tabulate(data, headers, tablefmt="pretty", colalign=colalign))
    print(f"→ Form fields: {len(sorted_form_fields)}")

def form_field_tabular_data(
    form_fields: Sequence[docai.Document.Page.FormField],
    document: docai.Document,
) -> Iterator[Tuple[str, str, str]]:
    yield ("name", "value", "confidence")
    yield ("right", "left", "right")
    if not form_fields:
        yield ("-", "-", "-")
        return
    for form_field in form_fields:
        name_layout = form_field.field_name
        value_layout = form_field.field_value
        name = text_from_layout(name_layout, document)
        value = text_from_layout(value_layout, document)
        confidence = value_layout.confidence
        yield (name, value, f"{confidence:.1%}")

เพิ่มฟังก์ชันยูทิลิตีต่อไปนี้ด้วย

def form_fields_sorted_by_ocr_order(
    document: docai.Document,
) -> MutableSequence[docai.Document.Page.FormField]:
    def sort_key(form_field):
        # Sort according to the field name detected position
        text_anchor = form_field.field_name.text_anchor
        return text_anchor.text_segments[0].start_index if text_anchor else 0

    fields = (field for page in document.pages for field in page.form_fields)

    return sorted(fields, key=sort_key)


def text_from_layout(
    layout: docai.Document.Page.Layout,
    document: docai.Document,
) -> str:
    full_text = document.text
    segs = layout.text_anchor.text_segments
    text = "".join(full_text[seg.start_index : seg.end_index] for seg in segs)
    if text.endswith("\n"):
        text = text[:-1]

    return text

พิมพ์ช่องในแบบฟอร์มที่ตรวจพบโดยทำดังนี้

print_form_fields(document)

คุณจะได้รับเอกสารฉบับพิมพ์ดังต่อไปนี้

+--------------+-------------------------+------------+
|         name | value                   | confidence |
+--------------+-------------------------+------------+
|        Date: | 9/14/19                 |     100.0% |
|        Name: | Sally                   |      99.7% |
|              | Walker                  |            |
|         DOB: | 09/04/1986              |     100.0% |
|     Address: | 24 Barney Lane          |      99.9% |
|        City: | Towaco                  |      99.8% |
|       State: | NJ                      |      99.7% |
|         Zip: | 07082                   |      99.5% |
|       Email: | Sally, waller@cmail.com |      99.6% |
|     Phone #: | (906) 917-3486          |     100.0% |
|      Gender: | F                       |     100.0% |
|  Occupation: | Software Engineer       |     100.0% |
| Referred By: | None                    |     100.0% |
...
+--------------+-------------------------+------------+
→ Form fields: 17

ตรวจสอบชื่อช่องและค่าที่ตรวจพบ ( PDF) นี่คือช่วงครึ่งบนของแบบสอบถาม

ea7370f0bb0cc494.png

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

8. การเปิดใช้และปิดใช้โปรเซสเซอร์

เมื่อใช้ disable_processor และ enable_processor คุณจะควบคุมได้ว่าจะใช้ตัวประมวลผลหรือไม่

เพิ่มฟังก์ชันต่อไปนี้

def update_processor_state(processor: docai.Processor, enable_processor: bool):
    client = get_client()
    if enable_processor:
        request = docai.EnableProcessorRequest(name=processor.name)
        operation = client.enable_processor(request)
    else:
        request = docai.DisableProcessorRequest(name=processor.name)
        operation = client.disable_processor(request)
    operation.result()  # Wait for operation to complete

def enable_processor(processor: docai.Processor):
    update_processor_state(processor, True)

def disable_processor(processor: docai.Processor):
    update_processor_state(processor, False)

ปิดใช้ตัวประมวลผลโปรแกรมแยกวิเคราะห์แบบฟอร์ม และตรวจสอบสถานะของตัวประมวลผลดังนี้

processor = get_processor(form_parser_display_name)
assert processor is not None

disable_processor(processor)
print_processors()

ซึ่งคุณควรจะได้รับสิ่งต่อไปนี้

+--------------+-----------------------+----------+
| display_name | type                  | state    |
+--------------+-----------------------+----------+
| document-ocr | OCR_PROCESSOR         | ENABLED  |
| form-parser  | FORM_PARSER_PROCESSOR | DISABLED |
+--------------+-----------------------+----------+
→ Processors: 2

เปิดใช้ตัวประมวลผลโปรแกรมแยกวิเคราะห์แบบฟอร์มอีกครั้งโดยทำดังนี้

enable_processor(processor)
print_processors()

ซึ่งคุณควรจะได้รับสิ่งต่อไปนี้

+--------------+-----------------------+---------+
| display_name | type                  | state   |
+--------------+-----------------------+---------+
| document-ocr | OCR_PROCESSOR         | ENABLED |
| form-parser  | FORM_PARSER_PROCESSOR | ENABLED |
+--------------+-----------------------+---------+
→ Processors: 2

ถัดไป ให้ดูวิธีการจัดการเวอร์ชันของโปรเซสเซอร์

9. การจัดการเวอร์ชันของโปรเซสเซอร์

โปรเซสเซอร์พร้อมให้ใช้งานได้หลายเวอร์ชัน ดูวิธีการใช้ list_processor_versions และ set_default_processor_version

เพิ่มฟังก์ชันต่อไปนี้

def list_processor_versions(
    processor: docai.Processor,
) -> MutableSequence[docai.ProcessorVersion]:
    client = get_client()
    response = client.list_processor_versions(parent=processor.name)

    return list(response)


def get_sorted_processor_versions(
    processor: docai.Processor,
) -> MutableSequence[docai.ProcessorVersion]:
    def sort_key(processor_version: docai.ProcessorVersion):
        return processor_version.name

    versions = list_processor_versions(processor)

    return sorted(versions, key=sort_key)


def print_processor_versions(processor: docai.Processor):
    versions = get_sorted_processor_versions(processor)
    default_version_name = processor.default_processor_version
    data = processor_versions_tabular_data(versions, default_version_name)
    headers = next(data)
    colalign = next(data)

    print(tabulate(data, headers, tablefmt="pretty", colalign=colalign))
    print(f"→ Processor versions: {len(versions)}")


def processor_versions_tabular_data(
    versions: Sequence[docai.ProcessorVersion],
    default_version_name: str,
) -> Iterator[Tuple[str, str, str]]:
    yield ("version", "display name", "default")
    yield ("left", "left", "left")
    if not versions:
        yield ("-", "-", "-")
        return
    for version in versions:
        mapping = docai.DocumentProcessorServiceClient.parse_processor_version_path(
            version.name
        )
        processor_version = mapping["processor_version"]
        is_default = "Y" if version.name == default_version_name else ""
        yield (processor_version, version.display_name, is_default)

ระบุเวอร์ชันที่พร้อมใช้งานสำหรับโปรเซสเซอร์ OCR ดังนี้

processor = get_processor(document_ocr_display_name)
assert processor is not None
print_processor_versions(processor)

คุณจะได้รับเวอร์ชันของโปรเซสเซอร์ดังนี้

+--------------------------------+--------------------------+---------+
| version                        | display name             | default |
+--------------------------------+--------------------------+---------+
| pretrained-ocr-v1.0-2020-09-23 | Google Stable            | Y       |
| pretrained-ocr-v1.1-2022-09-12 | Google Release Candidate |         |
| pretrained-ocr-v1.2-2022-11-10 | Google Release Candidate |         |
+--------------------------------+--------------------------+---------+
→ Processor versions: 3

จากนั้นเพิ่มฟังก์ชันเพื่อเปลี่ยนเวอร์ชันตัวประมวลผลเริ่มต้นโดยทำดังนี้

def set_default_processor_version(processor: docai.Processor, version_name: str):
    client = get_client()
    request = docai.SetDefaultProcessorVersionRequest(
        processor=processor.name,
        default_processor_version=version_name,
    )

    operation = client.set_default_processor_version(request)
    operation.result()  # Wait for operation to complete

เปลี่ยนไปใช้โปรเซสเซอร์เวอร์ชันล่าสุดโดยทำดังนี้

processor = get_processor(document_ocr_display_name)
assert processor is not None
versions = get_sorted_processor_versions(processor)

new_version = versions[-1]  # Latest version
set_default_processor_version(processor, new_version.name)

# Update the processor info
processor = get_processor(document_ocr_display_name)
assert processor is not None
print_processor_versions(processor)

คุณจะได้รับการกำหนดค่าเวอร์ชันใหม่ดังต่อไปนี้

+--------------------------------+--------------------------+---------+
| version                        | display name             | default |
+--------------------------------+--------------------------+---------+
| pretrained-ocr-v1.0-2020-09-23 | Google Stable            |         |
| pretrained-ocr-v1.1-2022-09-12 | Google Release Candidate |         |
| pretrained-ocr-v1.2-2022-11-10 | Google Release Candidate | Y       |
+--------------------------------+--------------------------+---------+
→ Processor versions: 3

ถัดไปคือวิธีการจัดการผู้ประมวลผลข้อมูลขั้นสูงสุด (การลบ)

10. กำลังลบตัวประมวลผล

สุดท้าย ให้ดูวิธีใช้เมธอด delete_processor

เพิ่มฟังก์ชันต่อไปนี้

def delete_processor(processor: docai.Processor):
    client = get_client()
    operation = client.delete_processor(name=processor.name)
    operation.result()  # Wait for operation to complete

ลบโปรเซสเซอร์ทดสอบโดยทำดังนี้

processors_to_delete = [dn for dn, _ in test_processor_display_names_and_types]
print("Deleting processors...")

for processor in list_processors():
    if processor.display_name not in processors_to_delete:
        continue
    print(f"  Deleting {processor.display_name}...")
    delete_processor(processor)

print("Done\n")
print_processors()

ซึ่งคุณควรจะได้รับสิ่งต่อไปนี้

Deleting processors...
  Deleting form-parser...
  Deleting document-ocr...
Done

+--------------+------+-------+
| display_name | type | state |
+--------------+------+-------+
| -            | -    | -     |
+--------------+------+-------+
→ Processors: 0

คุณได้พูดถึงวิธีการจัดการผู้ประมวลผลข้อมูลทั้งหมดแล้ว ใกล้จะเสร็จเรียบร้อยแล้ว...

11. ยินดีด้วย

c6d2ea69b1ba0eff.png

คุณได้เรียนรู้วิธีจัดการตัวประมวลผล AI เอกสารโดยใช้ Python แล้ว

ล้างข้อมูล

หากต้องการล้างสภาพแวดล้อมในการพัฒนาซอฟต์แวร์ ให้ดำเนินการดังนี้จาก Cloud Shell

  • หากคุณยังอยู่ในเซสชัน IPython ให้กลับไปที่ Shell: exit
  • หยุดใช้สภาพแวดล้อมเสมือนของ Python: deactivate
  • ลบโฟลเดอร์สภาพแวดล้อมเสมือน: cd ~ ; rm -rf ./venv-docai

หากต้องการลบโปรเจ็กต์ Google Cloud จาก Cloud Shell ให้ทำดังนี้

  • เรียกข้อมูลรหัสโปรเจ็กต์ปัจจุบัน: PROJECT_ID=$(gcloud config get-value core/project)
  • ตรวจสอบว่านี่คือโปรเจ็กต์ที่คุณต้องการลบ: echo $PROJECT_ID
  • ลบโปรเจ็กต์: gcloud projects delete $PROJECT_ID

ดูข้อมูลเพิ่มเติม

ใบอนุญาต

ผลงานนี้ได้รับอนุญาตภายใต้ใบอนุญาตทั่วไปครีเอทีฟคอมมอนส์แบบระบุแหล่งที่มา 2.0