GSP924

Présentation

L'API Document AI est une solution de reconnaissance de documents qui permet de mieux comprendre, analyser et utiliser des données non structurées, telles que des documents et des e-mails. Avec le processeur de formulaires général utilisé dans cet atelier, vous pouvez extraire des paires clé/valeur d'un simple document.

Dans cet atelier, vous allez apprendre à créer des analyseurs de documents à l'aide de Document AI, à envoyer des documents pour traitement via Google Cloud à l'aide de la console Cloud et de la ligne de commande, et à utiliser Python pour effectuer des appels d'API synchrones.

Points abordés

Vous allez apprendre à effectuer les opérations suivantes :

• Créer et tester un processeur Document AI à l'aide de la console
• Tester les processeurs Document AI à l'aide de la ligne de commande
• Tester les appels synchrones vers l'API Document AI à l'aide de Python

Préparation

Avant de cliquer sur le bouton "Démarrer l'atelier"

Lisez ces instructions. Les ateliers sont minutés, et vous ne pouvez pas les mettre en pause. Le minuteur, qui démarre lorsque vous cliquez sur Démarrer l'atelier, indique combien de temps les ressources Google Cloud resteront accessibles.

Cet atelier pratique vous permet de suivre les activités dans un véritable environnement cloud, et non dans un environnement de simulation ou de démonstration. Des identifiants temporaires vous sont fournis pour vous permettre de vous connecter à Google Cloud le temps de l'atelier.

Pour réaliser cet atelier :

• Vous devez avoir accès à un navigateur Internet standard (nous vous recommandons d'utiliser Chrome).

Remarque : Ouvrez une fenêtre de navigateur en mode incognito (recommandé) ou de navigation privée pour effectuer cet atelier. Vous éviterez ainsi les conflits entre votre compte personnel et le compte temporaire de participant, qui pourraient entraîner des frais supplémentaires facturés sur votre compte personnel.

• Vous disposez d'un temps limité. N'oubliez pas qu'une fois l'atelier commencé, vous ne pouvez pas le mettre en pause.

Remarque : Utilisez uniquement le compte de participant pour cet atelier. Si vous utilisez un autre compte Google Cloud, des frais peuvent être facturés à ce compte.

Démarrer l'atelier et se connecter à la console Google Cloud

1. Cliquez sur le bouton Démarrer l'atelier. Si l'atelier est payant, une boîte de dialogue s'affiche pour vous permettre de sélectionner un mode de paiement. Sur la gauche, vous trouverez le panneau "Détails concernant l'atelier", qui contient les éléments suivants :

   • Le bouton "Ouvrir la console Google Cloud"
   • Le temps restant
   • Les identifiants temporaires que vous devez utiliser pour cet atelier
   • Des informations complémentaires vous permettant d'effectuer l'atelier

2. Cliquez sur Ouvrir la console Google Cloud (ou effectuez un clic droit et sélectionnez Ouvrir le lien dans la fenêtre de navigation privée si vous utilisez le navigateur Chrome).

   L'atelier lance les ressources, puis ouvre la page "Se connecter" dans un nouvel onglet.

   Conseil : Réorganisez les onglets dans des fenêtres distinctes, placées côte à côte.

   Remarque : Si la boîte de dialogue Sélectionner un compte s'affiche, cliquez sur Utiliser un autre compte.

3. Si nécessaire, copiez le nom d'utilisateur ci-dessous et collez-le dans la boîte de dialogue Se connecter.

   {{{user_0.username | "Username"}}}

   Vous trouverez également le nom d'utilisateur dans le panneau "Détails concernant l'atelier".

4. Cliquez sur Suivant.

5. Copiez le mot de passe ci-dessous et collez-le dans la boîte de dialogue Bienvenue.

   {{{user_0.password | "Password"}}}

   Vous trouverez également le mot de passe dans le panneau "Détails concernant l'atelier".

6. Cliquez sur Suivant.

   Important : Vous devez utiliser les identifiants fournis pour l'atelier. Ne saisissez pas ceux de votre compte Google Cloud. Remarque : Si vous utilisez votre propre compte Google Cloud pour cet atelier, des frais supplémentaires peuvent vous être facturés.

7. Accédez aux pages suivantes :

   • Acceptez les conditions d'utilisation.
   • N'ajoutez pas d'options de récupération ni d'authentification à deux facteurs (ce compte est temporaire).
   • Ne vous inscrivez pas à des essais sans frais.

Après quelques instants, la console Cloud s'ouvre dans cet onglet.

Remarque : Pour accéder aux produits et services Google Cloud, cliquez sur le menu de navigation ou saisissez le nom du service ou du produit dans le champ Recherche.

Activer Cloud Shell

Cloud Shell est une machine virtuelle qui contient de nombreux outils pour les développeurs. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud. Cloud Shell vous permet d'accéder via une ligne de commande à vos ressources Google Cloud.

1. Cliquez sur Activer Cloud Shell  en haut de la console Google Cloud.

2. Passez les fenêtres suivantes :

   • Accédez à la fenêtre d'informations de Cloud Shell.
   • Autorisez Cloud Shell à utiliser vos identifiants pour effectuer des appels d'API Google Cloud.

Une fois connecté, vous êtes en principe authentifié et le projet est défini sur votre ID_PROJET : . Le résultat contient une ligne qui déclare l'ID_PROJET pour cette session :

Your Cloud Platform project in this session is set to {{{project_0.project_id | "PROJECT_ID"}}}

gcloud est l'outil de ligne de commande pour Google Cloud. Il est préinstallé sur Cloud Shell et permet la complétion par tabulation.

3. (Facultatif) Vous pouvez lister les noms des comptes actifs à l'aide de cette commande :

gcloud auth list

4. Cliquez sur Autoriser.

Résultat :

ACTIVE: * ACCOUNT: {{{user_0.username | "ACCOUNT"}}} To set the active account, run: $ gcloud config set account `ACCOUNT`

5. (Facultatif) Vous pouvez lister les ID de projet à l'aide de cette commande :

gcloud config list project

Résultat :

[core] project = {{{project_0.project_id | "PROJECT_ID"}}} Remarque : Pour consulter la documentation complète sur gcloud, dans Google Cloud, accédez au guide de présentation de la gcloud CLI.

Tâche 1 : Activer l'API Cloud Document AI

Dans cette tâche, vous allez activer l'API Document AI avant de créer et de tester un processeur de formulaires général. Ce processeur pourra traiter tous types de documents et extraire tous les contenus textuels qu'il identifie dans un document. Il ne se limite pas au texte imprimé. Il peut traiter du texte manuscrit ou orienté dans n'importe quel sens. De plus, ce processeur prend en charge plusieurs langues. Il comprend aussi comment les éléments de données des formulaires sont liés les uns aux autres, afin que vous puissiez extraire des paires clé/valeur des champs de formulaire assortis d'étiquettes textuelles.

Activer l'API Cloud Document AI

Avant de pouvoir utiliser Document AI, vous devez activer l'API.

1. Dans le menu de navigation (), cliquez sur API et services > Bibliothèque.

2. Recherchez API Cloud Document AI, puis cliquez sur le bouton Activer pour pouvoir utiliser l'API dans votre projet Google Cloud.

Si elle est déjà activée, un bouton Gérer apparaît à la place. Vous pouvez alors passer à la suite de l'atelier.

Cliquez sur Vérifier ma progression pour valider les objectifs.

Activer l'API Cloud Document AI

Tâche 2 : Créer et tester un processeur de formulaires général

Ensuite, vous allez créer un processeur Document AI à l'aide de l'analyseur de formulaires Document AI.

Créer un processeur

1. Dans le menu de navigation de la console (), cliquez sur Document AI > Aperçu.

2. Cliquez sur Explorer les processeurs.

3. Cliquez sur Créer un processeur de type Analyseur de formulaires, qui est un type de processeur général.

4. Indiquez form-parser comme nom de processeur et sélectionnez la région US (États-Unis) dans la liste.

5. Cliquez sur Créer pour créer le processeur général form-parser.

Cette opération va créer le processeur et afficher de nouveau la page d'informations le concernant. Sur cette page, vous trouverez l'identifiant du processeur, son état et le point de terminaison de prédiction.

6. Notez l'identifiant du processeur, car vous l'utiliserez avec curl pour effectuer un appel POST à l'API dans une tâche ultérieure.

Télécharger l'exemple de formulaire

Dans cette tâche, vous allez télécharger l'exemple de formulaire depuis Cloud Storage. Pour importer ce formulaire dans la prochaine tâche, vous devez d'abord le télécharger sur votre ordinateur local.

1. Téléchargez le fichier form.pdf sur votre ordinateur local.

Le fichier devrait se télécharger directement. Si le fichier s'ouvre dans votre navigateur, téléchargez-le à l'aide des commandes de fichier de votre navigateur. Le fichier form.pdf est un FORMULAIRE MÉDICAL D'ADMISSION contenant des exemples de données manuscrites.

Importer un formulaire pour traitement par Document AI

Maintenant, vous allez importer l'exemple de formulaire que vous avez téléchargé dans votre processeur form-parser. Il sera ensuite analysé, et les résultats s'afficheront dans la console.

1. Sur la page form-parser, cliquez sur le bouton Importer un document de test. Une boîte de dialogue s'affiche. Sélectionnez le fichier que vous avez téléchargé lors de la tâche précédente pour l'importer.

Une barre de progression indique le niveau d'achèvement du processus d'analyse, et les résultats s'affichent à la fin. Vous pouvez constater que le processeur général a capturé les données du formulaire dans un ensemble de paires clé/valeur.

Les paires clé/valeur analysées à partir du document source s'affichent dans la console. Le volet de gauche répertorie les données, tandis que le volet de droite affiche les emplacements sources à l'aide de rectangles bleus dans le document analysé. Examinez le résultat et comparez-le aux données sources.

Dans cette tâche, vous allez tester un processeur de formulaires général Document AI en effectuant des appels d'API à partir de la ligne de commande.

Cliquez sur Vérifier ma progression pour valider les objectifs.

Créer et tester un processeur de formulaires général

Tâche 3 : Configurer l'instance de l'atelier

Dans cette section, vous allez configurer l'instance de l'atelier pour utiliser l'API Document AI.

Se connecter à l'instance de VM de l'atelier via SSH

Vous effectuerez le reste des tâches de l'atelier dans la VM de l'atelier nommée document-ai-dev.

1. Dans le menu de navigation (), cliquez sur Compute Engine > Instances de VM.

2. Cliquez sur le lien SSH pour l'instance de VM nommée document-ai-dev.

À cette étape, vous aurez besoin de l'identifiant de processeur Document AI du processeur que vous avez créé lors de la tâche 2. Si vous ne l'avez pas noté, rendez-vous dans l'onglet de la console Cloud :

• Ouvrez le menu de navigation ().
• Cliquez sur Document AI > Processeurs.
• Cliquez sur le nom de votre processeur pour ouvrir la page d'informations.
• Vous pourrez alors copier l'identifiant du processeur.

3. Dans la session SSH, créez une variable d'environnement qui pourra contenir l'ID du processeur Document AI. Vous devez remplacer l'espace réservé [your processor id] :

export PROCESSOR_ID=[your processor id]

4. Dans la session SSH, vérifiez que la variable d'environnement contient l'ID du processeur Document AI :

echo Your processor ID is:$PROCESSOR_ID

5. L'identifiant du processeur doit s'afficher, comme dans l'exemple suivant :

Your processor ID is:4897d834d2f4415d

Vous utiliserez cette session SSH pour les tâches restantes de cet atelier.

Authentifier les requêtes API

Pour envoyer des requêtes à l'API Document AI, vous devez fournir des identifiants valides. Dans cette tâche, vous allez créer un compte de service, limiter les autorisations accordées à ce compte de service à celles requises pour l'atelier, puis générer un identifiant pour ce compte qui pourra être utilisé pour authentifier les requêtes API Document AI.

1. Définissez une variable d'environnement avec l'ID de votre projet, que vous utiliserez tout au long de cet atelier :

export PROJECT_ID=$(gcloud config get-value core/project)

2. Créez un compte de service pour accéder à l'API Document AI à l'aide de la commande suivante :

export SA_NAME="document-ai-service-account" gcloud iam service-accounts create $SA_NAME --display-name $SA_NAME

3. Associez le compte de service au rôle utilisateur de l'API Document AI :

gcloud projects add-iam-policy-binding ${PROJECT_ID} \ --member="serviceAccount:$SA_NAME@${PROJECT_ID}.iam.gserviceaccount.com" \ --role="roles/documentai.apiUser"

4. Créez les identifiants qui serviront à vous connecter en tant que nouveau compte de service et enregistrez-les dans un fichier JSON nommé key.json dans votre répertoire de travail :

gcloud iam service-accounts keys create key.json \ --iam-account $SA_NAME@${PROJECT_ID}.iam.gserviceaccount.com

5. Définissez la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS, qui permet à la bibliothèque de rechercher vos identifiants, pour qu'elle pointe vers le fichier d'identifiants :

export GOOGLE_APPLICATION_CREDENTIALS="$PWD/key.json"

6. Vérifiez que la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS est définie sur le chemin d'accès complet au fichier JSON des identifiants que vous avez créé précédemment :

echo $GOOGLE_APPLICATION_CREDENTIALS

Cette variable d'environnement est utilisée par l'outil de ligne de commande gcloud pour spécifier les identifiants qui doivent être utilisés lors de l'exécution des commandes. Pour en savoir plus sur l'authentification de ce formulaire, consultez le guide sur les identifiants par défaut de l'application.

Télécharger l'exemple de formulaire sur l'instance de VM

Vous pouvez maintenant télécharger un exemple de formulaire, puis l'encoder en base64 pour l'envoyer à l'API Document AI.

1. Saisissez la commande suivante dans la fenêtre SSH pour télécharger l'exemple de formulaire dans votre répertoire de travail :

gsutil cp gs://spls/gsp924/health-intake-form.pdf .

2. Créez un fichier de requête JSON pour envoyer le formulaire encodé en base64 à traiter :

echo '{"inlineDocument": {"mimeType": "application/pdf","content": "' > temp.json base64 health-intake-form.pdf >> temp.json echo '"}}' >> temp.json cat temp.json | tr -d \\n > request.json

Cliquez sur Vérifier ma progression pour valider les objectifs.

Authentifier les requêtes API et télécharger l'exemple de formulaire

Tâche 4 : Envoyer une requête de traitement de document synchrone à l'aide de curl

Dans cette tâche, vous allez traiter l'exemple de document en effectuant un appel au point de terminaison synchrone de l'API Document AI à l'aide de curl.

1. Envoyez un formulaire pour traitement via curl. Le résultat sera stocké dans output.json :

export LOCATION="us" export PROJECT_ID=$(gcloud config get-value core/project) curl -X POST \ -H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \ -H "Content-Type: application/json; charset=utf-8" \ -d @request.json \ https://${LOCATION}-documentai.googleapis.com/v1beta3/projects/${PROJECT_ID}/locations/${LOCATION}/processors/${PROCESSOR_ID}:process > output.json

2. Assurez-vous que votre fichier output.json contient les résultats de l'appel d'API :

cat output.json Si vous recevez une erreur d'authentification, assurez-vous que la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS pointe vers le fichier JSON des identifiants que vous avez créé précédemment. Vous devrez peut-être attendre quelques minutes pour que la stratégie IAM se propage. Si vous recevez un message d'erreur, réessayez.

Le jeton d'accès pour le compte de service Cloud IAM est généré à la volée et transmis à l'API à l'aide de l'en-tête HTTP Authorization:. La réponse contient des données au format JSON qui sont enregistrées dans le fichier output.json.

Extraire les entités du formulaire

Ensuite, examinez certaines des informations extraites de l'exemple de formulaire.

1. Extrayez le texte brut détecté dans le document comme suit :

sudo apt-get update sudo apt-get install jq cat output.json | jq -r ".document.text"

Cette liste contient tout le texte détecté dans le document importé.

2. Extrayez la liste des champs de formulaire détectés par le processeur de formulaires :

cat output.json | jq -r ".document.pages[].formFields"

Cette commande répertorie les données d'objet pour tous les champs de formulaire détectés dans le document. Les valeurs textAnchor.startIndex et textAnchor.endIndex de chaque formulaire peuvent être utilisées pour localiser les noms des formulaires détectés dans le champ document.text. Le script Python que vous utiliserez dans la tâche suivante effectuera ce mappage pour vous.

Le fichier JSON est assez volumineux, car il inclut le document source encodé en base64, ainsi que l'ensemble du texte détecté et les propriétés du document. Vous pouvez explorer le fichier JSON en l'ouvrant dans un éditeur de texte ou en utilisant un éditeur de requêtes JSON comme jq.

Vérifier qu'un document a bien été traité à l'aide de l'API Document AI

Tâche 5 : Tester un processeur de formulaires Document AI à l'aide des bibliothèques clientes Python

Effectuez un appel synchrone à l'API Document AI à l'aide des bibliothèques clientes Python Document AI.

Vous allez maintenant traiter un document à l'aide du point de terminaison synchrone. Pour traiter simultanément d'importants volumes de documents, vous pouvez utiliser l'API asynchrone. Pour en savoir plus sur l'utilisation des API Document AI, consultez ce guide.

Si vous souhaitez exécuter directement des scripts Python, vous devez leur fournir les identifiants appropriés pour qu'ils puissent appeler l'API à l'aide d'un compte de service configuré avec les autorisations adéquates. Pour en savoir plus sur la configuration de ce type d'authentification, consultez la documentation Authentification en tant que compte de service.

Configurer votre instance de VM pour utiliser le client Python Document AI

Installez maintenant les bibliothèques clientes Google Cloud Python dans l'instance de VM.

1. Saisissez la commande suivante dans l'interface shell du terminal SSH pour importer les fichiers de l'atelier dans votre instance de VM :

gsutil cp gs://spls/gsp924/synchronous_doc_ai.py .

2. Saisissez la commande suivante pour installer les bibliothèques clientes Python dont a besoin Document AI, ainsi que les autres bibliothèques requises pour cet atelier :

sudo apt install python3-pip python3 -m pip install --upgrade google-cloud-documentai google-cloud-storage prettytable

Le résultat qui s'affiche doit indiquer que les bibliothèques ont bien été installées.

Vérifier le code Python de l'API Document AI

Prenez quelques instants pour passer en revue le code Python dans l'exemple de fichier. Vous pouvez utiliser l'éditeur de votre choix, comme vi ou nano, pour examiner le code dans la session SSH. Vous pouvez aussi utiliser la commande de la section précédente pour copier l'exemple de code dans Cloud Shell et utiliser l'éditeur de code pour afficher le code source si vous préférez.

1. Les deux premiers blocs de code importent les bibliothèques requises et analysent les paramètres pour initialiser les variables qui identifient le processeur Document AI et les données d'entrée.

import argparse from google.cloud import documentai_v1beta3 as documentai from google.cloud import storage from prettytable import PrettyTable parser = argparse.ArgumentParser() parser.add_argument("-P", "--project_id", help="Google Cloud Project ID") parser.add_argument("-D", "--processor_id", help="Document AI Processor ID") parser.add_argument("-F", "--file_name", help="Input file name", default="form.pdf") parser.add_argument("-L", "--location", help="Processor Location", default="us") args = parser.parse_args()

2. La fonction process_document sert à effectuer un appel synchrone vers un processeur Document AI. Cette fonction crée un objet client API Document AI.

Le nom de processeur requis par l'appel d'API est créé à l'aide des paramètres project_id, location et processor_id. Le document à traiter est lu et stocké dans une structure mime_type.

Le nom du processeur et le document sont ensuite transmis à l'objet client de l'API Document AI, et un appel synchrone à l'API est effectué. Si la requête aboutit, l'objet "document" renvoyé inclut les propriétés qui contiennent les données détectées par le processeur Document AI.

def process_document(project_id, location, processor_id, file_path ): # Instancie un client client = documentai.DocumentProcessorServiceClient() # Nom complet de la ressource du processeur, par exemple : # projects/project-id/locations/location/processor/processor-id # Vous devez d'abord créer de nouveaux processeurs dans la console Cloud. name = f"projects/{project_id}/locations/{location}/processors/{processor_id}" # Lire le fichier en mémoire with open(file_path, "rb") as image: image_content = image.read() # Créer l'objet document document = {"content": image_content, "mime_type": "application/pdf"} # Configurer la demande de processus request = {"name": name, "document": document} # Utilisez le point de terminaison synchrone du client Document AI pour traiter la demande result = client.process_document(request=request) return result.document

3. Le script appelle ensuite la fonction process_document avec les paramètres requis et enregistre la réponse dans la variable document.

document = process_document(args.project_id,args.location,args.processor_id,args.file_name )

4. Le dernier bloc de code affiche la propriété .text qui contient tout le texte détecté dans le document, puis les informations du formulaire à l'aide des données d'ancrage de texte pour chacun des champs de formulaire détectés par l'analyseur de formulaires.

print("Document processing complete.") # imprimer le texte brut print("Text: \n{}\n".format(document.text)) # Définir une fonction permettant de récupérer un dictionnaire d'objets pour un élément nommé def get_text(doc_element: dict, document: dict): """ Document AI identifies form fields by their offsets in document text. This function converts offsets to text snippets. """ response = "" # Si un segment de texte s'étend sur plusieurs lignes, il sera # stocké dans différents segments de texte. for segment in doc_element.text_anchor.text_segments: start_index = ( int(segment.start_index) if segment in doc_element.text_anchor.text_segments else 0 ) end_index = int(segment.end_index) response += document.text[start_index:end_index] return response # Récupérez chaque paire clé/valeur et leurs scores de confiance correspondants. document_pages = document.pages print("Form data detected:\n") # Pour chaque page, récupérer chaque champ du formulaire et afficher le nom du champ, la valeur et les scores de confiance for page in document_pages: print("Page Number:{}".format(page.page_number)) for form_field in page.form_fields: fieldName=get_text(form_field.field_name,document) nameConfidence = round(form_field.field_name.confidence,4) fieldValue = get_text(form_field.field_value,document) valueConfidence = round(form_field.field_value.confidence,4) print(fieldName+fieldValue +" (Confidence Scores: (Name) "+str(nameConfidence)+", (Value) "+str(valueConfidence)+")\n")

Cliquez sur Vérifier ma progression pour valider les objectifs.

Tester un processeur de formulaires Document AI

Tâche 6 : Exécuter le code Python pour Document AI

Exécutez l'exemple de code et traitez le même fichier que précédemment.

1. Créez des variables d'environnement pour l'ID du projet et le fichier d'identifiants du compte de service IAM :

export PROJECT_ID=$(gcloud config get-value core/project) export GOOGLE_APPLICATION_CREDENTIALS="$PWD/key.json"

2. Appelez le programme Python synchronous_doc_ai.py avec les paramètres requis :

python3 synchronous_doc_ai.py \ --project_id=$PROJECT_ID \ --processor_id=$PROCESSOR_ID \ --location=us \ --file_name=health-intake-form.pdf | tee results.txt

Le bloc de texte suivant s'affiche : 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 ...

Le premier bloc de texte est un élément de texte unique contenant tout le texte du document. Ce bloc de texte ne tient pas compte des données basées sur des formulaires. Par conséquent, certains éléments, tels que les entrées Date et Name, sont mélangés dans cette valeur de texte brut.

Le code génère ensuite une vue plus structurée des données à l'aide des données de formulaire que form-parser a déduites de la structure du document. Cette sortie structurée inclut également le score de confiance pour les noms et les valeurs des champs de formulaire. La sortie de cette section fournit un mappage beaucoup plus utile entre les noms des champs de formulaire et les valeurs, comme on peut le voir avec le lien entre les champs de formulaire Date et Name et leurs valeurs correctes.

Form data detected: Page Number:1 Phone #: (906) 917-3486 (Confidence Scores: (Name) 1.0, (Value) 1.0) ... Date: 9/14/19 (Confidence Scores: (Name) 0.9999, (Value) 0.9999) ... Name: Sally Walker (Confidence Scores: (Name) 0.9973, (Value) 0.9973) ...

Cliquez sur Vérifier ma progression pour valider les objectifs.

Exécuter le code Python pour Document AI

Félicitations !

Vous avez utilisé l'API Document AI pour extraire des données de documents à l'aide d'un processeur de formulaires général. Dans cet atelier, vous avez créé et testé un processeur Document AI à l'aide de la console et de la ligne de commande, et vous avez effectué des appels synchrones à l'API Document AI à l'aide de Python.

Étapes suivantes et informations supplémentaires

• Pour en savoir plus, consultez la documentation de l'API Cloud Document AI.

Formations et certifications Google Cloud

Les formations et certifications Google Cloud vous aident à tirer pleinement parti des technologies Google Cloud. Nos cours portent sur les compétences techniques et les bonnes pratiques à suivre pour être rapidement opérationnel et poursuivre votre apprentissage. Nous proposons des formations pour tous les niveaux, à la demande, en salle et à distance, pour nous adapter aux emplois du temps de chacun. Les certifications vous permettent de valider et de démontrer vos compétences et votre expérience en matière de technologies Google Cloud.

Dernière mise à jour du manuel : 17 avril 2024

Dernier test de l'atelier : 7 décembre 2023

Copyright 2025 Google LLC. Tous droits réservés. Google et le logo Google sont des marques de Google LLC. Tous les autres noms d'entreprises et de produits peuvent être des marques des entreprises auxquelles ils sont associés.