Document AI (Python) की मदद से फ़ॉर्म पार्स करना

1. परिचय

इस कोडलैब में, आपको दस्तावेज़ एआई फ़ॉर्म पार्सर इस्तेमाल करने का तरीका बताया जाएगा. इससे, आपको Python के साथ हाथ से लिखे गए फ़ॉर्म को पार्स करने का तरीका पता चलेगा.

हम उदाहरण के तौर पर, मेडिकल इनटेक फ़ॉर्म का इस्तेमाल करेंगे. हालांकि, यह प्रोसेस DocAI के साथ काम करने वाले किसी भी सामान्य फ़ॉर्म के साथ काम करेगी.

ज़रूरी शर्तें

यह कोडलैब, अन्य दस्तावेज़ एआई कोडलैब में मौजूद कॉन्टेंट के आधार पर बनता है.

हमारा सुझाव है कि आगे बढ़ने से पहले, यहां दिए गए कोडलैब (कोड बनाना सीखना) पूरा करें.

आपको इनके बारे में जानकारी मिलेगी

  • Document AI फ़ॉर्म पार्सर का इस्तेमाल करके, स्कैन किए गए फ़ॉर्म से डेटा पार्स करने और उसे एक्सट्रैक्ट करने का तरीका.

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

  • Google Cloud प्रोजेक्ट
  • ब्राउज़र, जैसे कि Chrome या Firefox
  • Python 3 की जानकारी

सर्वे

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

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

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

शुरुआती इंटरमीडिएट कुशल

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

शुरुआती इंटरमीडिएट कुशल

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

इस कोडलैब के लिए यह मान लिया जाता है कि आपने Document AI ओसीआर कोडलैब में दिए गए, Document AI को सेटअप करने के सभी चरण पूरे कर लिए हैं.

आगे बढ़ने से पहले, कृपया नीचे दिए गए चरणों को पूरा करें:

आपको Pandas भी इंस्टॉल करना होगा, जो Python के लिए ओपन सोर्स डेटा विश्लेषण लाइब्रेरी है.

pip3 install --upgrade pandas

3. फ़ॉर्म पार्सर प्रोसेसर बनाएं

सबसे पहले आपको इस ट्यूटोरियल के लिए Document AI Platform में इस्तेमाल करने के लिए फ़ॉर्म पार्सर प्रोसेसर इंस्टेंस बनाना होगा.

  1. कंसोल में, दस्तावेज़ एआई प्लैटफ़ॉर्म की खास जानकारी पर जाएं
  2. प्रोसेसर बनाएं पर क्लिक करें और फ़ॉर्म पार्सर चुनेंप्रोसेसर
  3. प्रोसेसर का नाम डालें और सूची में से अपना क्षेत्र चुनें.
  4. अपना प्रोसेसर बनाने के लिए, बनाएं पर क्लिक करें
  5. अपना प्रोसेसर आईडी कॉपी करें. आपको बाद में अपने कोड में इसका इस्तेमाल करना होगा.

Cloud Console में प्रोसेसर की जांच करें

दस्तावेज़ अपलोड करके, कंसोल में अपने प्रोसेसर की जांच की जा सकती है. दस्तावेज़ अपलोड करें पर क्लिक करें और पार्स करने के लिए कोई फ़ॉर्म चुनें. अगर आपके पास इस्तेमाल के लिए कोई फ़ॉर्म नहीं है, तो इस सैंपल फ़ॉर्म को डाउनलोड करके इस्तेमाल किया जा सकता है.

हेल्थ फ़ॉर्म

आपका आउटपुट ऐसा दिखना चाहिए: पार्स किया गया फ़ॉर्म

4. सैंपल फ़ॉर्म डाउनलोड करें

हमारे पास एक सैंपल दस्तावेज़ है, जिसमें चिकित्सा से जुड़ी जानकारी देने वाला एक सामान्य फ़ॉर्म दिया गया है.

नीचे दिए गए लिंक का इस्तेमाल करके, PDF डाउनलोड की जा सकती है. इसके बाद, इसे Cloud Shell इंस्टेंस में अपलोड करें.

इसके अलावा, इसे gsutil का इस्तेमाल करके, हमारे सार्वजनिक Google Cloud Storage बकेट से डाउनलोड किया जा सकता है.

gsutil cp gs://cloud-samples-data/documentai/codelabs/form-parser/intake-form.pdf .

नीचे दिए गए निर्देश का इस्तेमाल करके, पुष्टि करें कि फ़ाइल आपके Cloud Shell में डाउनलोड हो गई है:

ls -ltr intake-form.pdf

5. फ़ॉर्म कुंजी/वैल्यू पेयर निकालें

इस चरण में, पहले बनाए गए फ़ॉर्म पार्सर प्रोसेसर को कॉल करने के लिए, ऑनलाइन प्रोसेसिंग एपीआई का इस्तेमाल किया जा सकता है. इसके बाद, दस्तावेज़ में मिले की-वैल्यू पेयर को एक्सट्रैक्ट करें.

ऑनलाइन प्रोसेसिंग का मतलब है, कोई एक दस्तावेज़ भेजना और उसके जवाब का इंतज़ार करना. अगर आपको एक से ज़्यादा फ़ाइलें भेजनी हैं या फ़ाइल का साइज़, ऑनलाइन प्रोसेस किए जाने वाले ज़्यादा से ज़्यादा पेजों से ज़्यादा है, तब भी बैच प्रोसेसिंग का इस्तेमाल किया जा सकता है. यह करने का तरीका जानने के लिए, ओसीआर कोडलैब में जाएं.

प्रोसेस का अनुरोध करने का कोड, प्रोसेसर आईडी के अलावा हर तरह के प्रोसेसर के लिए एक जैसा होता है.

दस्तावेज़ के रिस्पॉन्स ऑब्जेक्ट में, इनपुट दस्तावेज़ के पेजों की सूची होती है.

हर page ऑब्जेक्ट के टेक्स्ट में, फ़ॉर्म फ़ील्ड और उनकी जगहों की सूची होती है.

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

form_parser.py नाम की एक फ़ाइल बनाएं और नीचे दिए गए कोड का इस्तेमाल करें.

form_parser.py

import pandas as pd
from google.cloud import documentai_v1 as documentai


def online_process(
    project_id: str,
    location: str,
    processor_id: str,
    file_path: str,
    mime_type: str,
) -> documentai.Document:
    """
    Processes a document using the Document AI Online Processing API.
    """

    opts = {"api_endpoint": f"{location}-documentai.googleapis.com"}

    # Instantiates a client
    documentai_client = documentai.DocumentProcessorServiceClient(client_options=opts)

    # The full resource name of the processor, e.g.:
    # projects/project-id/locations/location/processor/processor-id
    # You must create new processors in the Cloud Console first
    resource_name = documentai_client.processor_path(project_id, location, processor_id)

    # Read the file into memory
    with open(file_path, "rb") as image:
        image_content = image.read()

        # Load Binary Data into Document AI RawDocument Object
        raw_document = documentai.RawDocument(
            content=image_content, mime_type=mime_type
        )

        # Configure the process request
        request = documentai.ProcessRequest(
            name=resource_name, raw_document=raw_document
        )

        # Use the Document AI client to process the sample form
        result = documentai_client.process_document(request=request)

        return result.document


def trim_text(text: str):
    """
    Remove extra space characters from text (blank, newline, tab, etc.)
    """
    return text.strip().replace("\n", " ")


PROJECT_ID = "YOUR_PROJECT_ID"
LOCATION = "YOUR_PROJECT_LOCATION"  # Format is 'us' or 'eu'
PROCESSOR_ID = "FORM_PARSER_ID"  # Create processor in Cloud Console

# The local file in your current working directory
FILE_PATH = "intake-form.pdf"
# Refer to https://cloud.google.com/document-ai/docs/processors-list
# for supported file types
MIME_TYPE = "application/pdf"

document = online_process(
    project_id=PROJECT_ID,
    location=LOCATION,
    processor_id=PROCESSOR_ID,
    file_path=FILE_PATH,
    mime_type=MIME_TYPE,
)

names = []
name_confidence = []
values = []
value_confidence = []

for page in document.pages:
    for field in page.form_fields:
        # Get the extracted field names
        names.append(trim_text(field.field_name.text_anchor.content))
        # Confidence - How "sure" the Model is that the text is correct
        name_confidence.append(field.field_name.confidence)

        values.append(trim_text(field.field_value.text_anchor.content))
        value_confidence.append(field.field_value.confidence)

# Create a Pandas Dataframe to print the values in tabular format.
df = pd.DataFrame(
    {
        "Field Name": names,
        "Field Name Confidence": name_confidence,
        "Field Value": values,
        "Field Value Confidence": value_confidence,
    }
)

print(df)

कोड अभी चलाएं. टेक्स्ट निकालने के बाद, आपको अपने कंसोल में प्रिंट किया हुआ टेक्स्ट दिखेगा.

अगर हमारे सैंपल दस्तावेज़ का इस्तेमाल किया जा रहा है, तो आपको यह आउटपुट दिखेगा:

$ python3 form_parser.py
                                           Field Name  Field Name Confidence                                        Field Value  Field Value Confidence
0                                            Phone #:               0.999982                                     (906) 917-3486                0.999982
1                                  Emergency Contact:               0.999972                                         Eva Walker                0.999972
2                                     Marital Status:               0.999951                                             Single                0.999951
3                                             Gender:               0.999933                                                  F                0.999933
4                                         Occupation:               0.999914                                  Software Engineer                0.999914
5                                        Referred By:               0.999862                                               None                0.999862
6                                               Date:               0.999858                                            9/14/19                0.999858
7                                                DOB:               0.999716                                         09/04/1986                0.999716
8                                            Address:               0.999147                                     24 Barney Lane                0.999147
9                                               City:               0.997718                                             Towaco                0.997718
10                                              Name:               0.997345                                       Sally Walker                0.997345
11                                             State:               0.996944                                                 NJ                0.996944
...

6. टेबल को पार्स करें

फ़ॉर्म पार्सर, दस्तावेज़ों में मौजूद टेबल से भी डेटा एक्सट्रैक्ट कर सकता है. इस चरण में, हम दस्तावेज़ का एक नया सैंपल डाउनलोड करेंगे और टेबल से डेटा एक्सट्रैक्ट करेंगे. हम डेटा को Pandas में लोड कर रहे हैं, इसलिए यह डेटा, एक ही तरीके से कॉल करने पर CSV फ़ाइल और कई दूसरे फ़ॉर्मैट में मिल सकता है.

टेबल की मदद से सैंपल फ़ॉर्म डाउनलोड करना

हमारे पास एक सैंपल दस्तावेज़ है, जिसमें सैंपल फ़ॉर्म और एक टेबल है.

नीचे दिए गए लिंक का इस्तेमाल करके, PDF डाउनलोड की जा सकती है. इसके बाद, इसे Cloud Shell इंस्टेंस में अपलोड करें.

इसके अलावा, इसे gsutil का इस्तेमाल करके, हमारे सार्वजनिक Google Cloud Storage बकेट से डाउनलोड किया जा सकता है.

gsutil cp gs://cloud-samples-data/documentai/codelabs/form-parser/form_with_tables.pdf .

नीचे दिए गए निर्देश का इस्तेमाल करके, पुष्टि करें कि फ़ाइल आपके Cloud Shell में डाउनलोड हो गई है:

ls -ltr form_with_tables.pdf

टेबल का डेटा एक्सट्रैक्ट करना

टेबल के डेटा को प्रोसेस करने का अनुरोध, की-वैल्यू पेयर को एक्सट्रैक्ट करने की प्रक्रिया जैसा ही होता है. इनमें अंतर होता है कि हम रिस्पॉन्स वाले फ़ील्ड से डेटा एक्सट्रैक्ट करते हैं. टेबल का डेटा, pages[].tables[] फ़ील्ड में सेव किया जाता है.

इस उदाहरण में, हर टेबल और पेज के लिए, टेबल की हेडर पंक्तियों और बॉडी पंक्तियों से जानकारी ली गई है. इसके बाद, टेबल को प्रिंट करके उसे CSV फ़ाइल के तौर पर सेव किया गया है.

table_parsing.py नाम की एक फ़ाइल बनाएं और नीचे दिए गए कोड का इस्तेमाल करें.

table_parsing.py

# type: ignore[1]
"""
Uses Document AI online processing to call a form parser processor
Extracts the tables and data in the document.
"""
from os.path import splitext
from typing import List, Sequence

import pandas as pd
from google.cloud import documentai


def online_process(
    project_id: str,
    location: str,
    processor_id: str,
    file_path: str,
    mime_type: str,
) -> documentai.Document:
    """
    Processes a document using the Document AI Online Processing API.
    """

    opts = {"api_endpoint": f"{location}-documentai.googleapis.com"}

    # Instantiates a client
    documentai_client = documentai.DocumentProcessorServiceClient(client_options=opts)

    # The full resource name of the processor, e.g.:
    # projects/project-id/locations/location/processor/processor-id
    # You must create new processors in the Cloud Console first
    resource_name = documentai_client.processor_path(project_id, location, processor_id)

    # Read the file into memory
    with open(file_path, "rb") as image:
        image_content = image.read()

        # Load Binary Data into Document AI RawDocument Object
        raw_document = documentai.RawDocument(
            content=image_content, mime_type=mime_type
        )

        # Configure the process request
        request = documentai.ProcessRequest(
            name=resource_name, raw_document=raw_document
        )

        # Use the Document AI client to process the sample form
        result = documentai_client.process_document(request=request)

        return result.document


def get_table_data(
    rows: Sequence[documentai.Document.Page.Table.TableRow], text: str
) -> List[List[str]]:
    """
    Get Text data from table rows
    """
    all_values: List[List[str]] = []
    for row in rows:
        current_row_values: List[str] = []
        for cell in row.cells:
            current_row_values.append(
                text_anchor_to_text(cell.layout.text_anchor, text)
            )
        all_values.append(current_row_values)
    return all_values


def text_anchor_to_text(text_anchor: documentai.Document.TextAnchor, text: str) -> str:
    """
    Document AI identifies table data by their offsets in the entirety of the
    document's text. This function converts offsets to a string.
    """
    response = ""
    # If a text segment spans several lines, it will
    # be stored in different text segments.
    for segment in text_anchor.text_segments:
        start_index = int(segment.start_index)
        end_index = int(segment.end_index)
        response += text[start_index:end_index]
    return response.strip().replace("\n", " ")


PROJECT_ID = "YOUR_PROJECT_ID"
LOCATION = "YOUR_PROJECT_LOCATION"  # Format is 'us' or 'eu'
PROCESSOR_ID = "FORM_PARSER_ID"  # Create processor before running sample

# The local file in your current working directory
FILE_PATH = "form_with_tables.pdf"
# Refer to https://cloud.google.com/document-ai/docs/file-types
# for supported file types
MIME_TYPE = "application/pdf"

document = online_process(
    project_id=PROJECT_ID,
    location=LOCATION,
    processor_id=PROCESSOR_ID,
    file_path=FILE_PATH,
    mime_type=MIME_TYPE,
)

header_row_values: List[List[str]] = []
body_row_values: List[List[str]] = []

# Input Filename without extension
output_file_prefix = splitext(FILE_PATH)[0]

for page in document.pages:
    for index, table in enumerate(page.tables):
        header_row_values = get_table_data(table.header_rows, document.text)
        body_row_values = get_table_data(table.body_rows, document.text)

        # Create a Pandas Dataframe to print the values in tabular format.
        df = pd.DataFrame(
            data=body_row_values,
            columns=pd.MultiIndex.from_arrays(header_row_values),
        )

        print(f"Page {page.page_number} - Table {index}")
        print(df)

        # Save each table as a CSV file
        output_filename = f"{output_file_prefix}_pg{page.page_number}_tb{index}.csv"
        df.to_csv(output_filename, index=False)

कोड अभी चलाएं. टेक्स्ट निकालने के बाद, आपको अपने कंसोल में प्रिंट किया हुआ टेक्स्ट दिखेगा.

अगर हमारे सैंपल दस्तावेज़ का इस्तेमाल किया जा रहा है, तो आपको यह आउटपुट दिखेगा:

$ python3 table_parsing.py
Page 1 - Table 0
     Item    Description
0  Item 1  Description 1
1  Item 2  Description 2
2  Item 3  Description 3
Page 1 - Table 1
  Form Number:     12345678
0   Form Date:   2020/10/01
1        Name:   First Last
2     Address:  123 Fake St

आपके पास उस डायरेक्ट्री में दो नई CSV फ़ाइलें भी होनी चाहिए जिससे कोड चलाया जा रहा है.

$ ls
form_with_tables_pg1_tb0.csv form_with_tables_pg1_tb1.csv table_parsing.py

7. बधाई हो

बधाई हो, आपने हाथ से लिखे गए फ़ॉर्म से डेटा निकालने के लिए, Document AI API का सही तरीके से इस्तेमाल कर लिया है. हमारा सुझाव है कि आप फ़ॉर्म के अन्य दस्तावेज़ों को आज़माकर देखें.

स्टोरेज खाली करें

इस ट्यूटोरियल में इस्तेमाल किए गए संसाधनों के लिए, आपके Google Cloud खाते पर लगने वाले शुल्क से बचने के लिए:

  • Cloud Console में, संसाधन मैनेज करें पेज पर जाएं.
  • प्रोजेक्ट की सूची में, अपना प्रोजेक्ट चुनें. इसके बाद, 'मिटाएं' पर क्लिक करें.
  • डायलॉग बॉक्स में, प्रोजेक्ट आईडी टाइप करें. इसके बाद, प्रोजेक्ट मिटाने के लिए 'शट डाउन करें' पर क्लिक करें.

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

इन फ़ॉलो-अप कोडलैब की मदद से, दस्तावेज़ एआई (AI) के बारे में ज़्यादा जानें.

संसाधन

लाइसेंस

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