1. Introduction
Dans cet atelier de programmation, vous allez apprendre à utiliser l'analyseur de formulaires de Document AI pour analyser un formulaire manuscrit avec Python.
Nous allons utiliser un formulaire d'admission médicale simple comme exemple, mais cette procédure fonctionne avec n'importe quel formulaire généralisé compatible avec DocAI.
Prérequis
Cet atelier s'appuie sur le contenu présenté dans d'autres ateliers de programmation Document AI.
Nous vous recommandons d'effectuer les ateliers de programmation suivants avant de continuer.
Points abordés
- Découvrez comment analyser et extraire des données d'un formulaire scanné à l'aide de l'analyseur de formulaires de Document AI.
Prérequis
Enquête
Comment allez-vous utiliser ce tutoriel ?
Quel est votre niveau d'expérience avec Python ?
Quel est votre niveau d'expérience avec les services Google Cloud ?
2. Préparation
Cet atelier de programmation suppose que vous avez effectué les étapes de configuration de Document AI présentées dans l'atelier de programmation sur l'OCR dans Document AI.
Veuillez effectuer les étapes suivantes avant de continuer :
Vous devrez également installer Pandas, une bibliothèque d'analyse de données Open Source pour Python.
pip3 install --upgrade pandas
3. Créer un processeur d'analyse de formulaires
Vous devez d'abord créer une instance d'analyseur de formulaires à utiliser sur la plate-forme Document AI lors de ce tutoriel.
- Dans la console, accédez à la page de présentation de la plate-forme Document AI.
- Cliquez sur Create Processor (Créer un processeur), puis sélectionnez Form Parser
(Analyseur de formulaires). - Spécifiez un nom de processeur, puis sélectionnez votre région dans la liste.
- Cliquez sur Créer pour créer le processeur.
- Copiez votre ID de processeur. Vous devrez l'utiliser ultérieurement dans votre code.
Tester le processeur dans la console Cloud
Vous pouvez tester votre processeur dans la console en important un document. Cliquez sur Upload Document (Importer un document), puis sélectionnez un formulaire à analyser. Vous pouvez télécharger et utiliser cet exemple de formulaire si vous n'en avez pas.
Votre résultat doit se présenter comme suit : 
4. Télécharger le formulaire d'exemple
Notre exemple de document contient un formulaire d'admission médicale simple.
Vous pouvez télécharger le PDF à l'aide du lien suivant. Ensuite, importez-le dans l'instance Cloud Shell.
Vous pouvez également le télécharger depuis notre bucket public Google Cloud Storage en utilisant gsutil.
gsutil cp gs://cloud-samples-data/documentai/codelabs/form-parser/intake-form.pdf .
Vérifiez que le fichier a bien été téléchargé dans Cloud Shell à l'aide de la commande suivante :
ls -ltr intake-form.pdf
5. Extraire les paires clé/valeur du formulaire
Dans cette étape, vous allez utiliser l'API de traitement en ligne pour appeler le processeur d'analyse de formulaires que vous avez créé précédemment. Ensuite, vous allez extraire les paires clé/valeur détectées dans le document.
Le traitement en ligne permet d'envoyer un unique document. Vous n'avez ensuite plus qu'à attendre la réponse. Vous pouvez également utiliser le traitement par lot si vous souhaitez envoyer plusieurs fichiers ou si la taille du fichier dépasse le nombre maximal de pages pour le traitement en ligne. Pour savoir comment procéder, consultez l'atelier de programmation sur l'OCR.
Le code permettant d'envoyer une requête de traitement est presque identique pour tous les types de processeurs : seul l'ID du processeur change.
L'objet de réponse Document contient une liste de pages du document d'entrée.
Chaque objet page contient une liste de champs de formulaire et leur emplacement dans le texte.
Le code suivant parcourt chaque page et en extrait l'ensemble des clés, valeurs et scores de confiance. Il s'agit de données structurées qui peuvent être plus facilement stockées dans des bases de données ou utilisées dans d'autres applications.
Créez un fichier appelé form_parser.py et utilisez le code ci-dessous.
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)
Exécutez votre code maintenant. Le texte extrait doit s'afficher dans votre console.
Si vous utilisez notre exemple de document, vous devriez obtenir le résultat suivant :
$ 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. Analyser des tableaux
L'analyseur de formulaires peut également extraire des données de tableaux dans des documents. Dans cette étape, nous allons télécharger un nouvel exemple de document et extraire les données du tableau. Puisque nous chargeons les données dans Pandas, vous pouvez les exporter dans un fichier CSV et dans de nombreux autres formats en utilisant un seul appel de méthode.
Télécharger le formulaire d'exemple contenant des tableaux
Notre exemple de document contient un formulaire et un tableau.
Vous pouvez télécharger le PDF à l'aide du lien suivant. Ensuite, importez-le dans l'instance Cloud Shell.
Vous pouvez également le télécharger depuis notre bucket public Google Cloud Storage en utilisant gsutil.
gsutil cp gs://cloud-samples-data/documentai/codelabs/form-parser/form_with_tables.pdf .
Vérifiez que le fichier a bien été téléchargé dans Cloud Shell à l'aide de la commande suivante :
ls -ltr form_with_tables.pdf
Extraire les données des tableaux
La requête de traitement des données de tableaux est identique à la requête d'extraction de paires clé/valeur. La différence réside dans les champs à partir desquels nous extrayons les données dans la réponse. Les données des tableaux sont stockées dans le champ pages[].tables[].
Cet exemple extrait les informations des lignes d'en-tête et des lignes de corps de chaque tableau sur toutes les pages, puis affiche le tableau et l'enregistre au format CSV.
Créez un fichier appelé table_parsing.py et utilisez le code ci-dessous.
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)
Exécutez votre code maintenant. Le texte extrait doit s'afficher dans votre console.
Si vous utilisez notre exemple de document, vous devriez obtenir le résultat suivant :
$ 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
Le répertoire à partir duquel vous exécutez le code devrait également comporter deux nouveaux fichiers CSV.
$ ls form_with_tables_pg1_tb0.csv form_with_tables_pg1_tb1.csv table_parsing.py
7. Félicitations
Félicitations, vous avez bien extrait des données d'un formulaire manuscrit à l'aide de l'API Document AI. Nous vous invitons à tester d'autres documents de formulaire.
Effectuer un nettoyage
Pour éviter que les ressources utilisées dans ce tutoriel soient facturées sur votre compte Google Cloud, procédez comme suit :
- Dans la console Cloud, accédez à la page Gérer les ressources.
- Dans la liste des projets, sélectionnez votre projet, puis cliquez sur "Supprimer".
- Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur "Arrêter" pour supprimer le projet.
En savoir plus
Continuez à vous familiariser avec Document AI grâce aux ateliers de programmation suivants.
- Outils de traitement spécialisés avec Document AI et Python
- Gérer les processeurs Document AI avec Python
- Document AI : human-in-the-loop (avec intervention humaine)
Ressources
Licence
Ce document est publié sous une licence Creative Commons Attribution 2.0 Generic.