این صفحه به‌وسیله ‏Cloud Translation API‏ ترجمه شده است.

مدیریت پردازشگرهای هوش مصنوعی سند با پایتون

1. بررسی اجمالی

Document AI چیست؟

Document AI پلتفرمی است که به شما امکان می دهد بینش را از اسناد خود استخراج کنید. در قلب، فهرست رو به رشدی از پردازشگرهای سند (که بسته به عملکرد آنها تجزیه کننده یا تقسیم کننده نیز نامیده می شود) را ارائه می دهد.

دو روش وجود دارد که می توانید پردازشگرهای Document AI را مدیریت کنید:

به صورت دستی، از کنسول وب؛
به صورت برنامه نویسی، با استفاده از Document AI API.

در اینجا یک اسکرین شات نمونه است که لیست پردازنده شما را هم از روی کنسول وب و هم از کد پایتون نشان می دهد:

در این آزمایشگاه، شما بر روی مدیریت پردازشگرهای Document AI به صورت برنامه نویسی با کتابخانه کلاینت پایتون تمرکز خواهید کرد.

چیزی که خواهید دید

چگونه محیط خود را تنظیم کنیم
نحوه واکشی انواع پردازنده
نحوه ایجاد پردازنده
نحوه فهرست کردن پردازنده های پروژه
نحوه استفاده از پردازنده ها
نحوه فعال/غیرفعال کردن پردازنده ها
نحوه مدیریت نسخه های پردازنده
نحوه حذف پردازنده ها

آنچه شما نیاز دارید

یک پروژه Google Cloud
مرورگری مانند کروم یا فایرفاکس
آشنایی با استفاده از پایتون

نظرسنجی

چگونه از این آموزش استفاده خواهید کرد؟

فقط از طریق آن را بخوانید

آن را بخوانید و تمرینات را کامل کنید

تجربه خود را با پایتون چگونه ارزیابی می کنید؟

تازه کار

متوسط

مسلط

تجربه خود را با خدمات Google Cloud چگونه ارزیابی می کنید؟

تازه کار

متوسط

مسلط

2. راه اندازی و الزامات

تنظیم محیط خود به خود

به Google Cloud Console وارد شوید و یک پروژه جدید ایجاد کنید یا از یک موجود استفاده مجدد کنید. اگر قبلاً یک حساب Gmail یا Google Workspace ندارید، باید یک حساب ایجاد کنید .

نام پروژه نام نمایشی برای شرکت کنندگان این پروژه است. این یک رشته کاراکتری است که توسط API های Google استفاده نمی شود. همیشه می توانید آن را به روز کنید.
شناسه پروژه در تمام پروژه‌های Google Cloud منحصربه‌فرد است و تغییرناپذیر است (پس از تنظیم نمی‌توان آن را تغییر داد). Cloud Console به طور خودکار یک رشته منحصر به فرد تولید می کند. معمولاً برای شما مهم نیست که چیست. در اکثر کدها، باید شناسه پروژه خود را ارجاع دهید (معمولاً با نام PROJECT_ID شناخته می شود). اگر شناسه تولید شده را دوست ندارید، ممکن است یک شناسه تصادفی دیگر ایجاد کنید. از طرف دیگر، می‌توانید خودتان را امتحان کنید، و ببینید آیا در دسترس است یا خیر. پس از این مرحله نمی توان آن را تغییر داد و در طول مدت پروژه باقی می ماند.
برای اطلاع شما، یک مقدار سوم وجود دارد، یک شماره پروژه ، که برخی از API ها از آن استفاده می کنند. در مورد هر سه این مقادیر در مستندات بیشتر بیاموزید.

در مرحله بعد، برای استفاده از منابع Cloud/APIها باید صورتحساب را در کنسول Cloud فعال کنید . اجرا کردن از طریق این کد لبه هزینه زیادی نخواهد داشت. برای خاموش کردن منابع برای جلوگیری از تحمیل صورت‌حساب فراتر از این آموزش، می‌توانید منابعی را که ایجاد کرده‌اید حذف کنید یا پروژه را حذف کنید. کاربران جدید Google Cloud واجد شرایط برنامه آزمایشی رایگان 300 دلاری هستند.

Cloud Shell را راه اندازی کنید

در حالی که Google Cloud را می توان از راه دور از لپ تاپ شما کار کرد، در این آزمایشگاه از Cloud Shell استفاده می کنید، یک محیط خط فرمان در حال اجرا در Cloud.

Cloud Shell را فعال کنید

از Cloud Console، روی Activate Cloud Shell کلیک کنید .

اگر این اولین باری است که Cloud Shell را راه اندازی می کنید، با یک صفحه میانی روبرو می شوید که آن را توصیف می کند. اگر با یک صفحه میانی مواجه شدید، روی Continue کلیک کنید.

تهیه و اتصال به Cloud Shell فقط باید چند لحظه طول بکشد.

این ماشین مجازی با تمام ابزارهای توسعه مورد نیاز بارگذاری شده است. این یک فهرست اصلی 5 گیگابایتی دائمی ارائه می‌کند و در Google Cloud اجرا می‌شود، که عملکرد و احراز هویت شبکه را بسیار افزایش می‌دهد. بسیاری از کارهای شما، اگر نه همه، در این کد لبه با مرورگر قابل انجام است.

پس از اتصال به Cloud Shell، باید ببینید که احراز هویت شده اید و پروژه به ID پروژه شما تنظیم شده است.

برای تایید احراز هویت، دستور زیر را در 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 ~

یک محیط مجازی پایتون برای جداسازی وابستگی ها ایجاد کنید:

virtualenv venv-docai

فعال کردن محیط مجازی:

source venv-docai/bin/activate

IPython، کتابخانه مشتری AI Document، و python-tablete (که از آن برای چاپ زیبا نتایج درخواست استفاده خواهید کرد) را نصب کنید:

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

در مراحل بعدی، از یک مفسر تعاملی پایتون به نام 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  ...

می توانید از روش synchronous 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 را با استفاده از پایتون مدیریت کنید!

پاک کن

برای پاکسازی محیط توسعه خود، از Cloud Shell:

اگر هنوز در جلسه IPython خود هستید، به پوسته برگردید: exit
استفاده از محیط مجازی پایتون را متوقف کنید: 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
جزئیات پردازنده هوش مصنوعی سند: https://cloud.google.com/document-ai/docs/processors-list
پایتون در Google Cloud: https://cloud.google.com/python
کتابخانه های کلاود کلاینت برای پایتون: https://github.com/googleapis/google-cloud-python

مجوز

این اثر تحت مجوز Creative Commons Attribution 2.0 Generic مجوز دارد.