এই পৃষ্ঠাটি Cloud Translation API অনুবাদ করেছে।

পাইথনের সাথে ডকুমেন্ট এআই প্রসেসর পরিচালনা করা

1. ওভারভিউ

ডকুমেন্ট এআই কি?

ডকুমেন্ট এআই এমন একটি প্ল্যাটফর্ম যা আপনাকে আপনার নথি থেকে অন্তর্দৃষ্টি বের করতে দেয়। হৃদয়ে, এটি ডকুমেন্ট প্রসেসরের একটি ক্রমবর্ধমান তালিকা অফার করে (তাদের কার্যকারিতার উপর নির্ভর করে পার্সার বা স্প্লিটারও বলা হয়)।

আপনি ডকুমেন্ট এআই প্রসেসর পরিচালনা করতে পারেন এমন দুটি উপায় রয়েছে:

ম্যানুয়ালি, ওয়েব কনসোল থেকে;
প্রোগ্রামগতভাবে, ডকুমেন্ট এআই API ব্যবহার করে।

ওয়েব কনসোল এবং পাইথন কোড উভয় থেকেই আপনার প্রসেসরের তালিকা দেখানোর একটি উদাহরণ স্ক্রিনশট রয়েছে:

এই ল্যাবে, আপনি পাইথন ক্লায়েন্ট লাইব্রেরির সাথে প্রোগ্রাম্যাটিকভাবে ডকুমেন্ট এআই প্রসেসর পরিচালনার উপর ফোকাস করবেন।

আপনি কি দেখতে পাবেন

আপনার পরিবেশ কিভাবে সেট আপ করবেন
কিভাবে প্রসেসরের ধরন আনতে হয়
কিভাবে প্রসেসর তৈরি করতে হয়
প্রকল্প প্রসেসর তালিকা কিভাবে
কিভাবে প্রসেসর ব্যবহার করবেন
কিভাবে প্রসেসর সক্রিয়/অক্ষম করবেন
প্রসেসর সংস্করণগুলি কীভাবে পরিচালনা করবেন
কিভাবে প্রসেসর মুছে ফেলা যায়

আপনি কি প্রয়োজন হবে

একটি Google ক্লাউড প্রকল্প
একটি ব্রাউজার, যেমন ক্রোম বা ফায়ারফক্স
পাইথন ব্যবহার করে পরিচিতি

সমীক্ষা

আপনি কিভাবে এই টিউটোরিয়াল ব্যবহার করবেন?

শুধুমাত্র মাধ্যমে এটি পড়ুন

এটি পড়ুন এবং ব্যায়াম সম্পূর্ণ করুন

পাইথনের সাথে আপনার অভিজ্ঞতাকে আপনি কীভাবে মূল্যায়ন করবেন?

নবজাতক

মধ্যবর্তী

দক্ষ

আপনি Google ক্লাউড পরিষেবাগুলির সাথে আপনার অভিজ্ঞতাকে কীভাবে মূল্যায়ন করবেন?

নবজাতক

মধ্যবর্তী

দক্ষ

2. সেটআপ এবং প্রয়োজনীয়তা

স্ব-গতিসম্পন্ন পরিবেশ সেটআপ

Google ক্লাউড কনসোলে সাইন-ইন করুন এবং একটি নতুন প্রকল্প তৈরি করুন বা বিদ্যমান একটি পুনরায় ব্যবহার করুন৷ আপনার যদি ইতিমধ্যেই একটি Gmail বা Google Workspace অ্যাকাউন্ট না থাকে, তাহলে আপনাকে অবশ্যই একটি তৈরি করতে হবে।

প্রকল্পের নাম এই প্রকল্পের অংশগ্রহণকারীদের জন্য প্রদর্শনের নাম। এটি একটি অক্ষর স্ট্রিং যা Google API দ্বারা ব্যবহৃত হয় না। আপনি সবসময় এটি আপডেট করতে পারেন.
প্রোজেক্ট আইডি সমস্ত Google ক্লাউড প্রোজেক্ট জুড়ে অনন্য এবং অপরিবর্তনীয় (সেট করার পরে পরিবর্তন করা যাবে না)। ক্লাউড কনসোল স্বয়ংক্রিয়ভাবে একটি অনন্য স্ট্রিং তৈরি করে; সাধারণত আপনি এটা কি যত্ন না. বেশিরভাগ কোডল্যাবে, আপনাকে আপনার প্রকল্প আইডি উল্লেখ করতে হবে (সাধারণত PROJECT_ID হিসাবে চিহ্নিত)। আপনি যদি জেনারেট করা আইডি পছন্দ না করেন, তাহলে আপনি অন্য একটি এলোমেলো আইডি তৈরি করতে পারেন। বিকল্পভাবে, আপনি নিজের চেষ্টা করতে পারেন, এবং এটি উপলব্ধ কিনা দেখতে পারেন। এই ধাপের পরে এটি পরিবর্তন করা যাবে না এবং প্রকল্পের সময়কালের জন্য থাকে।
আপনার তথ্যের জন্য, একটি তৃতীয় মান আছে, একটি প্রকল্প নম্বর , যা কিছু API ব্যবহার করে। ডকুমেন্টেশনে এই তিনটি মান সম্পর্কে আরও জানুন।

এরপরে, ক্লাউড রিসোর্স/এপিআই ব্যবহার করতে আপনাকে ক্লাউড কনসোলে বিলিং সক্ষম করতে হবে। এই কোডল্যাবের মাধ্যমে চালানোর জন্য খুব বেশি খরচ হবে না, যদি কিছু হয়। এই টিউটোরিয়ালের বাইরে বিলিং এড়াতে সংস্থানগুলি বন্ধ করতে, আপনি আপনার তৈরি করা সংস্থানগুলি মুছতে বা প্রকল্প মুছতে পারেন। নতুন Google ক্লাউড ব্যবহারকারীরা $300 USD বিনামূল্যের ট্রায়াল প্রোগ্রামের জন্য যোগ্য৷

ক্লাউড শেল শুরু করুন

যদিও Google ক্লাউড আপনার ল্যাপটপ থেকে দূরবর্তীভাবে পরিচালিত হতে পারে, এই ল্যাবে আপনি ক্লাউড শেল ব্যবহার করছেন, ক্লাউডে চলমান একটি কমান্ড লাইন পরিবেশ।

ক্লাউড শেল সক্রিয় করুন

ক্লাউড কনসোল থেকে, ক্লাউড শেল সক্রিয় করুন ক্লিক করুন .

যদি এটি আপনার প্রথমবার ক্লাউড শেল শুরু হয়, তাহলে এটি কী তা বর্ণনা করে আপনাকে একটি মধ্যবর্তী স্ক্রীন উপস্থাপন করা হবে। যদি আপনি একটি মধ্যবর্তী স্ক্রীনের সাথে উপস্থাপিত হন, তবে চালিয়ে যান ক্লিক করুন।

ক্লাউড শেলের সাথে সংযোগ করতে এবং সংযোগ করতে এটির মাত্র কয়েক মুহূর্ত লাগবে৷

এই ভার্চুয়াল মেশিনটি প্রয়োজনীয় সমস্ত বিকাশের সরঞ্জাম দিয়ে লোড করা হয়েছে। এটি একটি ক্রমাগত 5 GB হোম ডিরেক্টরি অফার করে এবং Google ক্লাউডে চলে, যা নেটওয়ার্ক কর্মক্ষমতা এবং প্রমাণীকরণকে ব্যাপকভাবে উন্নত করে। এই কোডল্যাবে আপনার অনেক কাজ, যদি সব না হয়, ব্রাউজার দিয়ে করা যেতে পারে।

একবার ক্লাউড শেলের সাথে সংযুক্ত হয়ে গেলে, আপনি দেখতে পাবেন যে আপনি প্রমাণীকৃত হয়েছেন এবং প্রকল্পটি আপনার প্রকল্প আইডিতে সেট করা আছে।

আপনি প্রমাণীকৃত কিনা তা নিশ্চিত করতে ক্লাউড শেলে নিম্নলিখিত কমান্ডটি চালান:

gcloud auth list

কমান্ড আউটপুট

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

gcloud কমান্ড আপনার প্রকল্প সম্পর্কে জানে তা নিশ্চিত করতে ক্লাউড শেলে নিম্নলিখিত কমান্ডটি চালান:

gcloud config list project

কমান্ড আউটপুট

[core]
project = <PROJECT_ID>

যদি এটি না হয়, আপনি এই কমান্ড দিয়ে এটি সেট করতে পারেন:

gcloud config set project <PROJECT_ID>

কমান্ড আউটপুট

Updated property [core/project].

3. পরিবেশ সেটআপ

আপনি ডকুমেন্ট এআই ব্যবহার শুরু করার আগে, ডকুমেন্ট এআই এপিআই সক্ষম করতে ক্লাউড শেলে নিম্নলিখিত কমান্ডটি চালান:

gcloud services enable documentai.googleapis.com

আপনি এই মত কিছু দেখতে হবে:

Operation "operations/..." finished successfully.

এখন, আপনি ডকুমেন্ট এআই ব্যবহার করতে পারেন!

আপনার হোম ডিরেক্টরিতে নেভিগেট করুন:

cd ~

নির্ভরতা বিচ্ছিন্ন করতে একটি পাইথন ভার্চুয়াল পরিবেশ তৈরি করুন:

virtualenv venv-docai

ভার্চুয়াল পরিবেশ সক্রিয় করুন:

source venv-docai/bin/activate

আইপিথন, ডকুমেন্ট এআই ক্লায়েন্ট লাইব্রেরি এবং পাইথন-টেবিলেট ইনস্টল করুন (যা আপনি অনুরোধের ফলাফলগুলি সুন্দর-প্রিন্ট করতে ব্যবহার করবেন):

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"

উভয় পরিবেশ ভেরিয়েবল আপনার অ্যাপ্লিকেশন ব্যবহার করা হবে.
API_LOCATION আপনাকে অনুরোধগুলি কোথায় সংঘটিত হবে তা চয়ন করতে দেয় ( মার্কিন যুক্তরাষ্ট্রের জন্য "us" , ইউরোপীয় ইউনিয়নের জন্য "eu" )। আপনি একাধিক অবস্থানে প্রসেসর ব্যবহার করতে পারেন, তবে আপনি এই ল্যাব জুড়ে একটি একক অবস্থান ব্যবহার করবেন যাতে এটি সহজ থাকে।

এখন থেকে, একই অধিবেশনে সমস্ত পদক্ষেপ সম্পন্ন করতে হবে।

নিশ্চিত করুন যে আপনার পরিবেশ ভেরিয়েবল সঠিকভাবে সংজ্ঞায়িত করা হয়েছে:

echo $PROJECT_ID

echo $API_LOCATION

পরবর্তী ধাপে, আপনি IPython নামে একটি ইন্টারেক্টিভ পাইথন ইন্টারপ্রেটার ব্যবহার করবেন, যা আপনি এইমাত্র ইনস্টল করেছেন। ক্লাউড শেলে 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 কল করুন।

আপনার পরীক্ষার নথি ( পিডিএফ ) হস্তলিখিত উত্তর সহ সম্পূর্ণ একটি স্ক্যান করা প্রশ্নাবলী। আপনার 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)

OCR প্রসেসরের জন্য উপলব্ধ সংস্করণগুলি তালিকাভুক্ত করুন:

processor = get_processor(document_ocr_display_name)
assert processor is not None
print_processor_versions(processor)

আপনি প্রসেসর সংস্করণ পাবেন:

+--------------------------------+--------------------------+---------+
| version                        | display name             | default |
+--------------------------------+--------------------------+---------+
| pretrained-ocr-v1.0-2020-09-23 | Google Stable            | Y       |
| pretrained-ocr-v1.1-2022-09-12 | Google Release Candidate |         |
| pretrained-ocr-v1.2-2022-11-10 | Google Release Candidate |         |
+--------------------------------+--------------------------+---------+
→ Processor versions: 3

এখন, ডিফল্ট প্রসেসর সংস্করণ পরিবর্তন করতে একটি ফাংশন যোগ করুন:

def set_default_processor_version(processor: docai.Processor, version_name: str):
    client = get_client()
    request = docai.SetDefaultProcessorVersionRequest(
        processor=processor.name,
        default_processor_version=version_name,
    )

    operation = client.set_default_processor_version(request)
    operation.result()  # Wait for operation to complete

সর্বশেষ প্রসেসর সংস্করণে স্যুইচ করুন:

processor = get_processor(document_ocr_display_name)
assert processor is not None
versions = get_sorted_processor_versions(processor)

new_version = versions[-1]  # Latest version
set_default_processor_version(processor, new_version.name)

# Update the processor info
processor = get_processor(document_ocr_display_name)
assert processor is not None
print_processor_versions(processor)

আপনি নতুন সংস্করণ কনফিগারেশন পাবেন:

+--------------------------------+--------------------------+---------+
| version                        | display name             | default |
+--------------------------------+--------------------------+---------+
| pretrained-ocr-v1.0-2020-09-23 | Google Stable            |         |
| pretrained-ocr-v1.1-2022-09-12 | Google Release Candidate |         |
| pretrained-ocr-v1.2-2022-11-10 | Google Release Candidate | Y       |
+--------------------------------+--------------------------+---------+
→ Processor versions: 3

এবং পরবর্তী, চূড়ান্ত প্রসেসর ব্যবস্থাপনা পদ্ধতি (মুছে ফেলা)।

10. প্রসেসর মুছে ফেলা হচ্ছে

অবশেষে, delete_processor পদ্ধতিটি কীভাবে ব্যবহার করবেন তা দেখুন।

নিম্নলিখিত ফাংশন যোগ করুন:

def delete_processor(processor: docai.Processor):
    client = get_client()
    operation = client.delete_processor(name=processor.name)
    operation.result()  # Wait for operation to complete

আপনার পরীক্ষা প্রসেসর মুছুন:

processors_to_delete = [dn for dn, _ in test_processor_display_names_and_types]
print("Deleting processors...")

for processor in list_processors():
    if processor.display_name not in processors_to_delete:
        continue
    print(f"  Deleting {processor.display_name}...")
    delete_processor(processor)

print("Done\n")
print_processors()

আপনি নিম্নলিখিত পেতে হবে:

Deleting processors...
  Deleting form-parser...
  Deleting document-ocr...
Done

+--------------+------+-------+
| display_name | type | state |
+--------------+------+-------+
| -            | -    | -     |
+--------------+------+-------+
→ Processors: 0

আপনি সমস্ত প্রসেসর ব্যবস্থাপনা পদ্ধতি কভার করেছেন! আপনি প্রায় শেষ...

11. অভিনন্দন!

আপনি শিখেছেন কিভাবে পাইথন ব্যবহার করে ডকুমেন্ট এআই প্রসেসর পরিচালনা করতে হয়!

পরিষ্কার করুন

ক্লাউড শেল থেকে আপনার উন্নয়ন পরিবেশ পরিষ্কার করতে:

আপনি যদি এখনও আপনার IPython সেশনে থাকেন, তাহলে শেল এ ফিরে যান: exit
পাইথন ভার্চুয়াল পরিবেশ ব্যবহার বন্ধ করুন: deactivate
আপনার ভার্চুয়াল পরিবেশ ফোল্ডার মুছুন: cd ~ ; rm -rf ./venv-docai

ক্লাউড শেল থেকে আপনার Google ক্লাউড প্রকল্প মুছে ফেলতে:

আপনার বর্তমান প্রকল্প আইডি পুনরুদ্ধার করুন: PROJECT_ID=$(gcloud config get-value core/project)
নিশ্চিত করুন যে এই প্রকল্পটি আপনি মুছতে চান: echo $PROJECT_ID
প্রকল্পটি মুছুন: gcloud projects delete $PROJECT_ID

আরও জানুন

আপনার ব্রাউজারে ডকুমেন্ট এআই ব্যবহার করে দেখুন: https://cloud.google.com/document-ai/docs/drag-and-drop
ডকুমেন্ট এআই প্রসেসরের বিবরণ: https://cloud.google.com/document-ai/docs/processors-list
Google ক্লাউডে পাইথন: https://cloud.google.com/python
পাইথনের জন্য ক্লাউড ক্লায়েন্ট লাইব্রেরি: https://github.com/googleapis/google-cloud-python

লাইসেন্স

এই কাজটি ক্রিয়েটিভ কমন্স অ্যাট্রিবিউশন 2.0 জেনেরিক লাইসেন্সের অধীনে লাইসেন্সপ্রাপ্ত।