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

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

11 मिनट बाकी हैं

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

इस कोडलैब (कोड बनाना सीखने के लिए ट्यूटोरियल) के बारे में जानकारी

पिछली बार मई 13, 2025 को अपडेट किया गया

Laurent Picard ने लिखा

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

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

Document AI क्या है?

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

Document AI प्रोसेसर को मैनेज करने के दो तरीके हैं:

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

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

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

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

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

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

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

सर्वे

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

सिर्फ़ इसे पढ़ेंइसे पढ़ें और इसमें दिए गए अभ्यास पूरे करें

Python के साथ अपने अनुभव को लेकर, 1 से 5 के स्केल पर आप किस हद तक संतुष्ट हैं?

नौसिखियामध्यमप्रवीण

Google Cloud की सेवाओं के साथ आपका अनुभव कैसा रहा?

नौसिखियामध्यमप्रवीण

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

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

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

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

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

Cloud Shell शुरू करना

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

Cloud Shell चालू करें

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

अगर आपने पहली बार 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`

gcloud कमांड को आपके प्रोजेक्ट के बारे में पता है या नहीं, इसकी पुष्टि करने के लिए Cloud Shell में यह कमांड चलाएं:

gcloud config list project

कमांड का आउटपुट

[core]
project = <PROJECT_ID>

अगर ऐसा नहीं है, तो इसे इस निर्देश से सेट किया जा सकता है:

gcloud config set project <PROJECT_ID>

कमांड का आउटपुट

Updated property [core/project].

3. एनवायरमेंट सेटअप करना

Document AI का इस्तेमाल शुरू करने से पहले, Document AI API को चालू करने के लिए, Cloud Shell में यह कमांड चलाएं:

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 इंस्टॉल करें. 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

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

ipython

आपको कुछ ऐसा दिखेगा:

Python 3.12.3 (main, Feb  4 2025, 14:48:35) [GCC 13.3.0]
Type 'copyright', 'credits' or 'license' for more information
IPython 9.1.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    |
...
| FORM_PARSER_PROCESSOR                | GENERAL     | True           | eu, us    |
| LAYOUT_PARSER_PROCESSOR              | GENERAL     | True           | eu, us    |
| OCR_PROCESSOR                        | GENERAL     | True           | eu, us    |
| BANK_STATEMENT_PROCESSOR             | SPECIALIZED | True           | eu, us    |
| EXPENSE_PROCESSOR                    | SPECIALIZED | True           | eu, us    |
...
+--------------------------------------+-------------+----------------+-----------+
→ Processor types: 19

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:',
 '9/14/19',
 'Name:',
 'Sally Walker',
 'DOB: 09/04/1986',
 'Address: 24 Barney Lane',
 'City: Towaco',
 'State: NJ Zip: 07082',
 'Email: Sally, walker@cmail.com',
 '_Phone #: (906) 917-3486',
 'Gender: F',
 '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                 |      83.0% |
|           Name: | Sally Walker            |      87.3% |
|            DOB: | 09/04/1986              |      88.5% |
|        Address: | 24 Barney Lane          |      82.4% |
|           City: | Towaco                  |      90.0% |
|          State: | NJ                      |      89.4% |
|            Zip: | 07082                   |      91.4% |
|          Email: | Sally, walker@cmail.com |      79.7% |
|       _Phone #: | walker@cmail.com        |      93.2% |
|                 | (906                    |            |
|         Gender: | F                       |      88.2% |
| Marital Status: | Single                  |      85.2% |
|     Occupation: | Software Engineer       |      81.5% |
|    Referred By: | None                    |      76.9% |
...
+-----------------+-------------------------+------------+
→ 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            |         |
| pretrained-ocr-v1.1-2022-09-12 | Google Release Candidate |         |
| pretrained-ocr-v1.2-2022-11-10 | Google Release Candidate |         |
| pretrained-ocr-v2.0-2023-06-02 | Google Stable            | Y       |
| pretrained-ocr-v2.1-2024-08-07 | Google Release Candidate |         |
+--------------------------------+--------------------------+---------+
→ Processor versions: 5

अब, प्रोसेसर के डिफ़ॉल्ट वर्शन को बदलने के लिए कोई फ़ंक्शन जोड़ें:

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 |         |
| pretrained-ocr-v2.0-2023-06-02 | Google Stable            |         |
| pretrained-ocr-v2.1-2024-08-07 | Google Release Candidate | Y       |
+--------------------------------+--------------------------+---------+
→ Processor versions: 5

इसके बाद, प्रोसेसर को मैनेज करने का सबसे अच्छा तरीका (मिटाएं).

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 का इस्तेमाल करके, Document AI प्रोसेसर को मैनेज करने का तरीका जाना!

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

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
Document 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

लाइसेंस

इस काम के लिए, Creative Commons Attribution 2.0 जनरल लाइसेंस के तहत लाइसेंस मिला है.

गलती की शिकायत करें