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

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

เกี่ยวกับ Codelab นี้

subjectอัปเดตล่าสุดเมื่อ มิ.ย. 20, 2023
account_circleเขียนโดย Laurent Picard

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