تمت ترجمة هذه الصفحة بواسطة Cloud Translation API‏.

إدارة معالجات الذكاء الاصطناعي للمستندات باستخدام Python

1. نظرة عامة

ما هو Document AI؟

الذكاء الاصطناعي للمستندات هي منصّة تتيح لك استخراج الإحصاءات من مستنداتك. وهي في الأساس تقدّم قائمة متزايدة من معالِجات المستندات (تسمى أيضًا المحللات اللغوية أو المقسِّمات، حسب وظائفها).

هناك طريقتان لإدارة معالِجات معالجة المستندات المستنِدة إلى الذكاء الاصطناعي (Document AI):

يدويًا من وحدة تحكم الويب؛
آليًا باستخدام Document AI API

في ما يلي مثال على لقطة شاشة تعرِض قائمة المعالِجات، من وحدة تحكّم الويب ومن رمز Python:

سوف تركِّز في هذا التمرين المعملي على إدارة معالجات Document AI آليًا باستخدام مكتبة برامج Python.

المحتوى الذي سيظهر

كيفية إعداد البيئة
كيفية استرجاع أنواع المعالجات
كيفية إنشاء معالِجات البيانات
كيفية سرد معالجات المشروع
كيفية استخدام معالِجات البيانات
كيفية تفعيل المعالجات أو إيقافها
طريقة إدارة إصدارات المعالج
كيفية حذف معالِجات البيانات

المتطلبات

مشروع على Google Cloud
متصفح، مثل Chrome أو Firefox
الإلمام باستخدام بايثون

استطلاع

كيف ستستخدم هذا البرنامج التعليمي؟

القراءة فقط

اقرأها وأكمِل التمارين

كيف تقيّم تجربتك مع Python؟

حديث

متوسط

بارع

كيف تقيّم تجربتك مع خدمات Google Cloud؟

حديث

متوسط

بارع

2. الإعداد والمتطلبات

إعداد بيئة ذاتية

سجِّل الدخول إلى Google Cloud Console وأنشئ مشروعًا جديدًا أو أعِد استخدام مشروع حالي. إذا لم يكن لديك حساب على Gmail أو Google Workspace، عليك إنشاء حساب.

اسم المشروع هو الاسم المعروض للمشاركين في هذا المشروع. وهي سلسلة أحرف لا تستخدمها Google APIs. ويمكنك تعديلها في أي وقت.
يكون رقم تعريف المشروع فريدًا في جميع مشاريع Google Cloud وغير قابل للتغيير (لا يمكن تغييره بعد تحديده). تنشئ Cloud Console سلسلة فريدة تلقائيًا. فعادةً لا تهتم بما هو. في معظم الدروس التطبيقية حول الترميز، يجب الإشارة إلى رقم تعريف المشروع (الذي يتم تحديده عادةً على أنّه PROJECT_ID). وإذا لم يعجبك رقم التعريف الذي تم إنشاؤه، يمكنك إنشاء رقم تعريف عشوائي آخر. ويمكنك بدلاً من ذلك تجربة طلبك الخاص ومعرفة ما إذا كان متاحًا. ولا يمكن تغييره بعد هذه الخطوة ويبقى طوال مدة المشروع.
لمعلوماتك، هناك قيمة ثالثة، وهي رقم المشروع، الذي تستخدمه بعض واجهات برمجة التطبيقات. اطّلِع على مزيد من المعلومات حول هذه القيم الثلاث في المستندات.

بعد ذلك، عليك تفعيل الفوترة في Cloud Console لاستخدام الموارد/واجهات برمجة التطبيقات في Cloud. لن يؤدي إكمال هذا الدرس التطبيقي حول الترميز إلى فرض أي تكاليف، إن وُجدت. لإيقاف تشغيل الموارد لتجنب تحمُّل الفواتير إلى ما هو أبعد من هذا البرنامج التعليمي، يمكنك حذف الموارد التي أنشأتها أو حذف المشروع. يكون مستخدمو Google Cloud الجدد مؤهَّلون للانضمام إلى برنامج فترة تجريبية مجانية بقيمة 300 دولار أمريكي.

بدء Cloud Shell

يمكن إدارة Google Cloud عن بُعد من الكمبيوتر المحمول، إلا أنّك تستخدم في هذا التمرين المعملي Cloud Shell، وهي بيئة سطر أوامر يتم تشغيلها في السحابة الإلكترونية.

تفعيل Cloud Shell

من Cloud Console، انقر على تفعيل Cloud Shell .

إذا كانت هذه هي المرة الأولى التي تبدأ فيها Cloud Shell، ستظهر لك شاشة وسيطة تصف ماهيتها. إذا ظهرت لك شاشة وسيطة، انقر على متابعة.

من المفترَض أن تستغرق عملية إدارة الحسابات والاتصال بخدمة Cloud Shell بضع دقائق فقط.

يتم تحميل هذا الجهاز الافتراضي مع جميع أدوات التطوير اللازمة. وتوفّر هذه الشبكة دليلاً رئيسيًا دائمًا بسعة 5 غيغابايت ويتم تشغيله في Google Cloud، ما يحسّن بشكل كبير من أداء الشبكة والمصادقة. يمكنك تنفيذ معظم عملك، إن لم يكن كلّه، في هذا الدرس التطبيقي حول الترميز باستخدام متصفّح.

بعد الربط بخدمة 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 ~

أنشئ بيئة بايثون افتراضية لعزل التبعيات:

virtualenv venv-docai

تفعيل البيئة الافتراضية:

source venv-docai/bin/activate

ثبِّت IPython ومكتبة برامج Document AI وميزة python-tab (التي ستستخدمها لطباعة نتائج الطلب بشكل محسّن):

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)

أدرِج الإصدارات المتاحة لمعالج التعرّف البصري على الأحرف:

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
تفاصيل معالج الذكاء الاصطناعي للمستندات: 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

الترخيص

هذا العمل مرخّص بموجب رخصة المشاع الإبداعي 2.0 مع نسب العمل إلى مؤلف عام.