इस पेज का अनुवाद Cloud Translation API से किया गया है.

Python की मदद से, दस्तावेज़ के एआई प्रोसेसर को मैनेज करना

1. खास जानकारी

डॉक्यूमेंट एआई (AI) क्या है?

दस्तावेज़ एआई एक ऐसा प्लैटफ़ॉर्म है जो आपको अपने दस्तावेज़ों से अहम जानकारी निकालने की सुविधा देता है. खास तौर पर, यह दस्तावेज़ प्रोसेसर की बढ़ती सूची उपलब्ध कराता है. इन प्रोसेसर को उनके काम करने के तरीके के आधार पर पार्सर या स्प्लिटर भी कहा जाता है.

दस्तावेज़ एआई प्रोसेसर को मैनेज करने के दो तरीके हैं:

मैन्युअल रूप से, वेब कंसोल से
प्रोग्राम के हिसाब से, Document AI API का इस्तेमाल किया जा सकता है.

यहां एक स्क्रीनशॉट दिया गया है, जिसमें आपकी प्रोसेसर सूची को वेब कंसोल और Python कोड, दोनों से दिखाया गया है:

इस लैब में, आपको Python क्लाइंट लाइब्रेरी की मदद से, दस्तावेज़ एआई (AI) प्रोसेसर को प्रोग्राम के हिसाब से मैनेज करने पर फ़ोकस करना होगा.

आपको क्या दिखेगा

अपना एनवायरमेंट सेट अप करने का तरीका
प्रोसेसर के टाइप फ़ेच करने का तरीका
प्रोसेसर बनाने का तरीका
प्रोजेक्ट प्रोसेसर की सूची बनाने का तरीका
प्रोसेसर इस्तेमाल करने का तरीका
प्रोसेसर को चालू/बंद करने का तरीका
प्रोसेसर वर्शन को मैनेज करने का तरीका
प्रोसेसर मिटाने का तरीका

आपको इन चीज़ों की ज़रूरत होगी

Google Cloud प्रोजेक्ट
Chrome या Firefox जैसा ब्राउज़र
Python का इस्तेमाल करना

सर्वे

इस ट्यूटोरियल का इस्तेमाल कैसे किया जाएगा?

इसे सिर्फ़ पढ़ें

इसे पढ़ें और कसरतों को पूरा करें

Python के साथ अपने अनुभव को आप कितनी रेटिंग देंगे?

शुरुआती

इंटरमीडिएट

कुशल

Google Cloud की सेवाओं का इस्तेमाल करने का आपका अनुभव कैसा रहा?

शुरुआती

इंटरमीडिएट

कुशल

2. सेटअप और ज़रूरी शर्तें

अपने हिसाब से एनवायरमेंट सेटअप करना

Google Cloud Console में साइन इन करें और नया प्रोजेक्ट बनाएं या किसी मौजूदा प्रोजेक्ट का फिर से इस्तेमाल करें. अगर आपके पास पहले से Gmail या Google Workspace खाता नहीं है, तो आपको नया खाता बनाना होगा.

295004821बाबा6a87.png

प्रोजेक्ट का नाम, इस प्रोजेक्ट में हिस्सा लेने वाले लोगों का डिसप्ले नेम होता है. यह एक वर्ण स्ट्रिंग है, जिसका इस्तेमाल Google API नहीं करता. इसे कभी भी अपडेट किया जा सकता है.
प्रोजेक्ट आईडी, Google Cloud के सभी प्रोजेक्ट के लिए यूनीक होता है. साथ ही, इसे बदला नहीं जा सकता. इसे सेट करने के बाद बदला नहीं जा सकता. Cloud Console, एक यूनीक स्ट्रिंग अपने-आप जनरेट करता है; आम तौर पर, आपको उसके होने की कोई परवाह नहीं होती. ज़्यादातर कोडलैब में, आपको अपना प्रोजेक्ट आईडी बताना होगा. आम तौर पर, इसकी पहचान PROJECT_ID के रूप में की जाती है. अगर आपको जनरेट किया गया आईडी पसंद नहीं है, तो किसी भी क्रम में एक और आईडी जनरेट किया जा सकता है. दूसरा तरीका यह है कि आप खुद भी आज़माकर देखें कि वह उपलब्ध है या नहीं. इस चरण के बाद, इसे बदला नहीं जा सकता. साथ ही, यह प्रोजेक्ट के खत्म होने तक बना रहता है.
आपकी जानकारी के लिए, प्रोजेक्ट नंबर नाम की एक तीसरी वैल्यू दी गई है. इसका इस्तेमाल कुछ एपीआई करते हैं. दस्तावेज़ में इन तीनों वैल्यू के बारे में ज़्यादा जानें.

इसके बाद, आपको क्लाउड संसाधनों/एपीआई का इस्तेमाल करने के लिए, Cloud Console में बिलिंग चालू करनी होगी. इस कोडलैब का इस्तेमाल करने पर, आपको ज़्यादा पैसे नहीं चुकाने होंगे. इस ट्यूटोरियल के अलावा, बिलिंग से बचने के लिए संसाधनों को बंद करें. इसके लिए, अपने बनाए गए संसाधनों को मिटाएं या प्रोजेक्ट को मिटाएं. Google Cloud के नए उपयोगकर्ता, 300 डॉलर के मुफ़्त ट्रायल वाले प्रोग्राम में हिस्सा ले सकते हैं.

Cloud Shell शुरू करना

Google Cloud को आपके लैपटॉप से, कहीं से भी इस्तेमाल किया जा सकता है. हालांकि, इस लैब में Cloud Shell का इस्तेमाल किया जा रहा है. यह क्लाउड में चलने वाला कमांड लाइन एनवायरमेंट है.

Cloud Shell चालू करें

Cloud Console में, Cloud Shell चालू करें पर क्लिक करें.

अगर आपने Cloud Shell का इस्तेमाल पहली बार किया है, तो आपको बीच में आने वाली स्क्रीन दिखेगी. इसमें यह बताया जाएगा कि यह क्या है. अगर आपको बीच के लेवल पर मिलने वाली स्क्रीन दिखती है, तो जारी रखें पर क्लिक करें.

प्रावधान करने और Cloud Shell से कनेक्ट होने में कुछ ही समय लगेगा.

इस वर्चुअल मशीन में डेवलपमेंट के सभी ज़रूरी टूल मौजूद हैं. इसमें लगातार पांच जीबी की होम डायरेक्ट्री मिलती है और यह 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.

अब दस्तावेज़ एआई (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 ...

अब आप दस्तावेज़ एआई क्लाइंट लाइब्रेरी का इस्तेमाल करने के लिए तैयार हैं!

इन एनवायरमेंट वैरिएबल को सेट करें:

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

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

अब से, सभी चरण एक ही सेशन में पूरे किए जाने चाहिए.

पक्का करें कि आपके एनवायरमेंट वैरिएबल सही तरीके से तय किए गए हैं:

echo $PROJECT_ID

echo $API_LOCATION

अगले चरणों में, आपको IPython नाम के एक इंटरैक्टिव Python अनुवादक का इस्तेमाल करना होगा, जिसे आपने अभी-अभी इंस्टॉल किया है. Cloud Shell में ipython चलाकर सेशन शुरू करें:

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

type कॉलम में, प्रोसेसर टाइप वाली स्ट्रिंग दिखती है, जिसका इस्तेमाल प्रोसेसर बनाते समय करना है.
category कॉलम दिखाता है कि प्रोसेसर सामान्य है, खास है या पसंद के मुताबिक है.
allow_creation कॉलम से पता चलता है कि आपके प्रोजेक्ट के लिए प्रोसेसर को अनुमति है या नहीं. पाबंदी वाले प्रोसेसर टाइप का इस्तेमाल करने के लिए, आपको कंसोल से ऐक्सेस का अनुरोध करना होगा और पहले ही मंज़ूरी लेनी होगी.

अब, अगले चरण में आपके पास प्रोसेसर बनाने के लिए सभी ज़रूरी जानकारी मौजूद है.

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)

सभी प्रोसेसर, दस्तावेज़ को पहले ऑप्टिकल कैरेक्टर रिकग्निशन (ओसीआर) से पास करते हैं. ओसीआर पास की मदद से पहचाने गए टेक्स्ट की समीक्षा करें:

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. बधाई हो!

आपने Python का इस्तेमाल करके, दस्तावेज़ एआई प्रोसेसर को मैनेज करने का तरीका सीखा है!

व्यवस्थित करें

Cloud Shell की मदद से, अपने डेवलपमेंट एनवायरमेंट को खाली करने के लिए:

अगर आप अब भी अपने IPython सेशन में हैं, तो शेल पर वापस जाएं: exit
Python वर्चुअल एनवायरमेंट का इस्तेमाल बंद करें: deactivate
अपना वर्चुअल एनवायरमेंट फ़ोल्डर मिटाएं: cd ~ ; rm -rf ./venv-docai

Cloud Shell से अपना Google Cloud प्रोजेक्ट मिटाने के लिए:

अपना मौजूदा प्रोजेक्ट आईडी वापस पाएं: 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
एआई (AI) प्रोसेसर की जानकारी का दस्तावेज़: https://cloud.google.com/document-ai/docs/processors-list
Google Cloud पर Python: https://cloud.google.com/python
Python के लिए Cloud क्लाइंट लाइब्रेरी: https://github.com/googleapis/google-cloud-python

लाइसेंस

इस काम को क्रिएटिव कॉमंस एट्रिब्यूशन 2.0 जेनरिक लाइसेंस के तहत लाइसेंस मिला है.