דף זה תורגם על ידי Cloud Translation API.

ניהול מעבדי Document AI באמצעות Python

1. סקירה כללית

מה זה Document AI?

Document AI היא פלטפורמה שמאפשרת לחלץ תובנות מהמסמכים. בעיקרון, היא מציעה רשימה הולכת וגדלה של מעבדי מסמכים (שנקראים גם מנתחים או מפצלים, בהתאם לפונקציונליות שלהם).

יש שתי דרכים לנהל מעבדי מסמכים ב-Document AI:

באופן ידני, ממסוף האינטרנט.
באופן פרוגרמטי, באמצעות Document AI API.

הנה צילום מסך לדוגמה שמציג את רשימת המעבדים שלך, גם ממסוף האינטרנט וגם מקוד Python:

בשיעור ה-Lab הזה, תתמקדו בניהול מעבדי Document AI באופן פרוגרמטי באמצעות ספריית הלקוח של Python.

מה יוצג

איך מגדירים את הסביבה
איך מאחזרים סוגי מעבדים
איך יוצרים מעבדי מידע
איך מציגים רשימה של מעבדי פרויקטים
איך משתמשים במעבדי מידע
איך מפעילים או משביתים מעבדים
איך לנהל גרסאות של מעבדי מידע
איך למחוק מעבדי מידע

מה צריך להכין

פרויקט ב-Google Cloud
דפדפן כמו Chrome או Firefox
היכרות עם Python

סקר

איך תשתמשו במדריך הזה?

לקריאה בלבד

לקרוא אותו ולבצע את התרגילים

איזה דירוג מגיע לדעתך לחוויה שלך עם Python?

מתחילים

בינונית

בקיאים

איזה דירוג מגיע לחוויה שלך בשירותי Google Cloud?

מתחילים

בינונית

בקיאים

2. הגדרה ודרישות

הגדרת סביבה בקצב עצמאי

נכנסים למסוף Google Cloud ויוצרים פרויקט חדש או עושים שימוש חוזר בפרויקט קיים. אם אין לכם עדיין חשבון Gmail או חשבון Google Workspace, עליכם ליצור חשבון.

Project name הוא השם המוצג של המשתתפים בפרויקט. זו מחרוזת תווים שלא משמשת את Google APIs. תמיד אפשר לעדכן.
Project ID הוא ייחודי בכל הפרויקטים ב-Google Cloud ואי אפשר לשנות אותו (אי אפשר לשנות אותו אחרי שמגדירים אותו). מסוף Cloud יוצר מחרוזת ייחודית באופן אוטומטי; בדרך כלל לא מעניין אותך מה זה. ברוב ה-codelabs תצטרכו להפנות למזהה הפרויקט שלכם (בדרך כלל מזוהה כ-PROJECT_ID). אם המזהה שנוצר לא מוצא חן בעיניכם, אתם יכולים ליצור מזהה אקראי אחר. לחלופין, אפשר לנסות שם משלך ולראות אם הוא זמין. לא ניתן לשנות אותו אחרי השלב הזה, והוא נשאר למשך הפרויקט.
לידיעתך, יש ערך שלישי, Project Number, שבו משתמשים בחלק מממשקי ה-API. מידע נוסף על כל שלושת הערכים האלה זמין במסמכי התיעוד.

בשלב הבא צריך להפעיל את החיוב במסוף Cloud כדי להשתמש במשאבים או בממשקי API של Cloud. מעבר ב-Codelab הזה לא יעלה הרבה כסף, אם בכלל. כדי להשבית משאבים ולא לצבור חיובים מעבר למדריך הזה, אתם יכולים למחוק את המשאבים שיצרתם או למחוק את הפרויקט. משתמשים חדשים ב-Google Cloud זכאים להשתתף בתוכנית תקופת ניסיון בחינם בשווי 1,200 ש"ח.

הפעלת Cloud Shell

אומנם אפשר להפעיל את Google Cloud מרחוק מהמחשב הנייד, אבל בשיעור ה-Lab הזה משתמשים ב-Cloud Shell, סביבת שורת הפקודה שרצה ב-Cloud.

הפעלת Cloud Shell

במסוף Cloud, לוחצים על Activate Cloud Shell .

אם זו הפעם הראשונה שאתם מפעילים את Cloud Shell, יוצג לכם מסך ביניים שמתוארת בו. אם הוצג לכם מסך ביניים, לוחצים על המשך.

ההקצאה וההתחברות ל-Cloud Shell נמשכת כמה דקות.

במכונה הווירטואלית הזו נמצאים כל כלי הפיתוח הדרושים. יש בה ספריית בית בנפח מתמיד של 5GB והיא פועלת ב-Google Cloud, מה שמשפר משמעותית את ביצועי הרשת והאימות. אם לא את כולן, ניתן לבצע חלק גדול מהעבודה ב-Codelab הזה באמצעות דפדפן.

אחרי ההתחברות ל-Cloud Shell, אתם אמורים לראות שהפרויקט מאומת ושהפרויקט מוגדר לפי מזהה הפרויקט שלכם.

מריצים את הפקודה הבאה ב-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`

מריצים את הפקודה הבאה ב-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 כדי לבודד את יחסי התלות:

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. שימוש במעבדים

אפשר לעבד מסמכים בשתי דרכים:

באופן סינכרוני: קוראים לפונקציה 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). הנה החלק העליון של השאלון:

ניתחת טופס שמכיל גם טקסט מודפס וגם טקסט בכתב יד. בנוסף, זיהיתם את השדות שלו ברמת סמך גבוהה. כתוצאה מכך הפיקסלים הומרו לנתונים מובְנים!

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. מעולה!

למדת איך לנהל מעבדי Document AI באמצעות Python!

הסרת המשאבים

כדי לנקות את סביבת הפיתוח, מבצעים את הפעולות הבאות ב-Cloud Shell:

אם אתם עדיין נמצאים בסשן של IPython, עליכם לחזור למעטפת: 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

מידע נוסף

אפשר לנסות את Document AI בדפדפן: https://cloud.google.com/document-ai/docs/drag-and-drop
הפרטים של מעבד מסמכים ב-Document AI: https://cloud.google.com/document-ai/docs/processors-list
Python ב-Google Cloud: https://cloud.google.com/python
ספריות לקוח של Cloud ל-Python: https://github.com/googleapis/google-cloud-python

רישיון

היצירה הזו בשימוש ברישיון Creative Commons Attribution 2.0 גנרי.