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

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

Document AI क्या है?

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

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

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

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

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

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

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

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

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

सर्वे

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

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

इसे पढ़ें और एक्सरसाइज़ पूरी करें

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

शुरुआती

सामान्य

एडवांस

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

शुरुआती

सामान्य

एडवांस

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

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

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

प्रोजेक्ट का नाम, इस प्रोजेक्ट में हिस्सा लेने वाले लोगों के लिए डिसप्ले नेम होता है. यह एक वर्ण स्ट्रिंग है, जिसका इस्तेमाल Google API नहीं करते. इसे कभी भी अपडेट किया जा सकता है.
प्रोजेक्ट आईडी, सभी 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 के बारे में जानकारी दी गई होगी. अगर आपको इंटरमीडिएट स्क्रीन दिखती है, तो जारी रखें पर क्लिक करें.

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 का इस्तेमाल शुरू करने से पहले, Cloud Shell में यह निर्देश चलाएं, ताकि Document AI API को चालू किया जा सके:

gcloud services enable documentai.googleapis.com

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

Operation "operations/..." finished successfully.

अब Document AI का इस्तेमाल किया जा सकता है!

अपनी होम डायरेक्ट्री पर जाएं:

cd ~

डिपेंडेंसी को अलग करने के लिए, Python का वर्चुअल एनवायरमेंट बनाएं:

virtualenv venv-docai

वर्चुअल एनवायरमेंट चालू करें:

source venv-docai/bin/activate

IPython, Document AI क्लाइंट लाइब्रेरी, और python-tabulate इंस्टॉल करें. 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"

आपके ऐप्लिकेशन में, दोनों एनवायरमेंट वैरिएबल का इस्तेमाल किया जाएगा.
API_LOCATION की मदद से, यह चुना जा सकता है कि अनुरोध कहां किए जाएंगे ("us" अमेरिका के लिए, "eu" यूरोपियन यूनियन के लिए). प्रोसेसर का इस्तेमाल कई जगहों पर किया जा सकता है. हालांकि, इस लैब में हम एक ही जगह पर प्रोसेसर का इस्तेमाल करेंगे, ताकि इसे आसानी से समझा जा सके.

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

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

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

Google Cloud प्रोजेक्ट मिटाने के लिए, Cloud Shell में जाकर यह तरीका अपनाएं:

अपना मौजूदा प्रोजेक्ट आईडी पाएं: PROJECT_ID=$(gcloud config get-value core/project)
पक्का करें कि आपको यही प्रोजेक्ट मिटाना है: echo $PROJECT_ID
प्रोजेक्ट मिटाएं: gcloud projects delete $PROJECT_ID

ज़्यादा जानें

अपने ब्राउज़र में Document AI आज़माएं: https://cloud.google.com/document-ai/docs/drag-and-drop
Document AI प्रोसेसर के बारे में जानकारी: https://cloud.google.com/document-ai/docs/processors-list
Google Cloud पर Python: https://cloud.google.com/python
Python के लिए Cloud Client Libraries: https://github.com/googleapis/google-cloud-python

लाइसेंस

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