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

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

1. সংক্ষিপ্ত বিবরণ

অনুসরণ

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

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

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

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

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

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

তুমি কি দেখতে পাবে

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

তোমার যা লাগবে

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

জরিপ

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

শুধু পুরোটা পড়ুন

এটি পড়ুন এবং অনুশীলনগুলি সম্পূর্ণ করুন।

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

নবীন

মধ্যবর্তী

দক্ষ

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

নবীন

মধ্যবর্তী

দক্ষ

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

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

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

অনুসরণ

a99b7ace416376c4.png সম্পর্কে

5e3ff691252acf41.png সম্পর্কে

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

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

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

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

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

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

3c1dabeca90e44e5.png সম্পর্কে

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

9c92662c6a846a5c.png সম্পর্কে

ক্লাউড শেলের সাথে সংযোগ স্থাপন এবং সংযোগ স্থাপন করতে মাত্র কয়েক মুহূর্ত সময় লাগবে।

9f0e51b578fecce5.png সম্পর্কে

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

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

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

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 কমান্ড-লাইন টুল ওভারভিউ দেখুন।

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

gcloud config list project

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

[core]
project = <PROJECT_ID>

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

gcloud config set project <PROJECT_ID>

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

Updated property [core/project].

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

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

gcloud services enable documentai.googleapis.com

তোমার এরকম কিছু দেখা উচিত:

Operation "operations/..." finished successfully.

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

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

cd ~

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

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

আপনার আইপিথন সেশনে নিম্নলিখিত কোডটি কপি করুন:

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

আপনি আপনার প্রথম অনুরোধ করতে এবং প্রসেসরের ধরণগুলি আনতে প্রস্তুত।

৪. প্রসেসরের প্রকারভেদ আনা হচ্ছে

পরবর্তী ধাপে একটি প্রসেসর তৈরি করার আগে, উপলব্ধ প্রসেসরের ধরণগুলি আনুন। আপনি fetch_processor_types দিয়ে এই তালিকাটি পুনরুদ্ধার করতে পারেন।

আপনার আইপিথন সেশনে নিম্নলিখিত ফাংশনগুলি যোগ করুন:

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 কলামটি দেখায় যে আপনার প্রকল্পের জন্য প্রসেসরটি অনুমোদিত কিনা। একটি সীমাবদ্ধ প্রসেসর প্রকার ব্যবহার করতে, আপনাকে কনসোল থেকে অ্যাক্সেসের অনুরোধ করতে হবে এবং আগে থেকে অনুমোদন নিতে হবে।

এখন, পরবর্তী ধাপে প্রসেসর তৈরি করার জন্য প্রয়োজনীয় সমস্ত তথ্য আপনার কাছে আছে।

৫. প্রসেসর তৈরি করা

একটি প্রসেসর তৈরি করতে, একটি ডিসপ্লে নাম এবং একটি প্রসেসরের ধরণ সহ 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

তুমি নতুন প্রসেসর তৈরি করেছো!

এরপর, প্রসেসরগুলির তালিকা কীভাবে করবেন তা দেখুন।

৬. প্রকল্প প্রসেসরের তালিকা তৈরি করা

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

এখন, তুমি জানো কিভাবে তোমার প্রোজেক্ট প্রসেসর তালিকাভুক্ত করতে হয় এবং তাদের ডিসপ্লে নামের মাধ্যমে সেগুলো পুনরুদ্ধার করতে হয়। এরপর, দেখো কিভাবে একটি প্রসেসর ব্যবহার করতে হয়।

৭. প্রসেসর ব্যবহার

নথিপত্র দুটি উপায়ে প্রক্রিয়া করা যেতে পারে:

সিঙ্ক্রোনাসলি : একটি একক ডকুমেন্ট বিশ্লেষণ করতে এবং সরাসরি ফলাফল ব্যবহার করতে process_document কল করুন।
অ্যাসিঙ্ক্রোনাসলি : একাধিক বা বৃহৎ নথিতে ব্যাচ প্রক্রিয়াকরণ শুরু করতে batch_process_documents কল করুন।

আপনার পরীক্ষার ডকুমেন্ট ( পিডিএফ ) হল একটি স্ক্যান করা প্রশ্নপত্র যা হাতে লেখা উত্তর সহ সম্পূর্ণ। এটি আপনার আইপিথন সেশন থেকে সরাসরি আপনার কার্যকরী ডিরেক্টরিতে ডাউনলোড করুন:

!gsutil cp gs://cloud-samples-data/documentai/form.pdf .

আপনার কার্যকরী ডিরেক্টরির বিষয়বস্তু পরীক্ষা করুন:

!ls

আপনার নিম্নলিখিতগুলি থাকা উচিত:

...  form.pdf  ...  venv-docai  ...

স্থানীয় ফাইল বিশ্লেষণ করতে আপনি synchronous 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:',
 '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

সনাক্ত করা ক্ষেত্রের নাম এবং মানগুলি পর্যালোচনা করুন ( পিডিএফ )। এখানে প্রশ্নাবলীর উপরের অর্ধেকটি রয়েছে:

db1a2be576a5576f.png সম্পর্কে

আপনি এমন একটি ফর্ম বিশ্লেষণ করেছেন যাতে মুদ্রিত এবং হাতে লেখা উভয় লেখাই রয়েছে। আপনি উচ্চ আত্মবিশ্বাসের সাথে এর ক্ষেত্রগুলিও সনাক্ত করেছেন। ফলাফল হল যে আপনার পিক্সেলগুলি কাঠামোগত ডেটাতে রূপান্তরিত হয়েছে!

৮. প্রসেসর সক্রিয় এবং নিষ্ক্রিয় করা

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

এরপর, প্রসেসর সংস্করণগুলি কীভাবে পরিচালনা করবেন তা দেখুন।

৯. প্রসেসর সংস্করণ পরিচালনা করা

প্রসেসর একাধিক সংস্করণে পাওয়া যেতে পারে। 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            |         |
| 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

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

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

অবশেষে, 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

তুমি প্রসেসর পরিচালনার সকল পদ্ধতি শিখে ফেলেছো! তোমার কাজ প্রায় শেষ...

১১. অভিনন্দন!

অনুসরণ

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

পরিষ্কার করা

ক্লাউড শেল থেকে আপনার ডেভেলপমেন্ট পরিবেশ পরিষ্কার করতে:

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

ক্লাউড শেল থেকে আপনার গুগল ক্লাউড প্রজেক্ট মুছে ফেলার জন্য:

আপনার বর্তমান প্রকল্প আইডিটি পুনরুদ্ধার করুন: 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
গুগল ক্লাউডে পাইথন: https://cloud.google.com/python
পাইথনের জন্য ক্লাউড ক্লায়েন্ট লাইব্রেরি: https://github.com/googleapis/google-cloud-python

লাইসেন্স

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