Prise en main d’Intelligence documentaire

Important

• Azure Cognitive Services Form Recognizer est désormais Azure AI Intelligence documentaire.
• Certaines plateformes attendent toujours la mise à jour du changement de nom.
• Toutes les mention de Form Recognizer ou Intelligence documentaire dans notre documentation font référence au même service Azure.

Ce contenu s’applique à : v3.1 (GA) Versions précédentes : v3.0 v2.1

• Bien démarrer avec la dernière version en disponibilité générale d’Azure Form Recognizer (2023-07-31).

• Azure AI Intelligence documentaire / Form Recognizer est un service informatique Azure AI qui utilise l’apprentissage automatique pour extraire de vos documents des paires clé-valeur, du texte, des tableaux et des données clés.

• Vous pouvez intégrer facilement des modèles de traitement des documents dans vos workflows et vos applications en utilisant un SDK de langage de programmation ou en appelant l’API REST.

• Dans le cadre de ce guide de démarrage rapide, nous vous recommandons d’utiliser le service gratuit pendant que vous vous familiarisez avec la technologie. N’oubliez pas que le nombre de pages gratuites est limité à 500 par mois.

Pour en savoir plus sur les fonctionnalités et les options de développement de l’API, consultez notre page Vue d’ensemble.

Bibliothèque de client | Référence du kit de développement logiciel (SDK) | Référence de l’API | Package (NuGet) | Exemples | Version de l’API REST prise en charge

Dans ce guide de démarrage rapide, utilisez les fonctionnalités suivantes pour analyser et extraire des données et des valeurs de formulaires et de documents :

• Modèle de mise en page—Analysez et extrayez les tableaux, les lignes, les mots et les marques de sélection comme les boutons radio et les cases à cocher dans les documents, sans avoir à former un modèle.

• Modèle prédéfini – Analyser et extraire les champs communs de types de documents spécifiques à l’aide d’un modèle prédéfini.

Prérequis

• Abonnement Azure : créez-en un gratuitement.

• La version actuelle de l’IDE Visual Studio.

• Une ressource Azure AI services ou Form Recognizer. Une fois que vous avez votre abonnement Azure, créez une ressource monoservice ou multiservice Azure AI dans le portail Azure pour obtenir votre clé et votre point de terminaison.

• Vous pouvez utiliser le niveau tarifaire Gratuit (F0) pour tester le service, puis passer par la suite à un niveau payant pour la production.

Conseil

Créez une ressource Azure AI services si vous envisagez d’accéder à plusieurs services Azure AI services sous un seul point de terminaison/une seule clé. Pour l’accès à Form Recognizer uniquement, créez une ressource Form Recognizer. Veuillez noter que vous aurez besoin d’une ressource à service unique si vous avez l’intention d’utiliser l’authentification Microsoft Entra.

• Après le déploiement de votre ressource, sélectionnez Accéder à la ressource. Vous avez besoin de la clé et du point de terminaison de la ressource que vous créez pour connecter votre application à l’API Form Recognizer. Vous collez votre clé et votre point de terminaison dans le code plus loin dans ce guide de démarrage rapide :

  

Configurer

1. Démarrez Visual Studio.

2. Dans la page de démarrage, choisissez Créer un projet.

   

3. Dans la page Créer un nouveau projet, entrez console dans la zone de recherche. Choisissez le modèle Application console, puis choisissez Suivant.

   

4. Dans la fenêtre de dialogue Configurer votre nouveau projet, entrez form_recognizer_quickstart dans la zone Nom de projet. Ensuite, choisissez Suivant.

5. Dans la fenêtre de dialogue Informations supplémentaires, sélectionnez .NET 8.0 (Actuel), puis sélectionnez Créer.

   

Installer la bibliothèque de client avec NuGet

1. Cliquez avec le bouton droit sur votre projet form_recognizer_quickstart, puis sélectionnez Gérer les packages NuGet....

   

2. Sélectionnez l’onglet Parcourir, puis tapez Azure.AI.FormRecognizer. Sélectionnez la version 4.1.0 dans le menu déroulant.

   

Générer votre application

Pour interagir avec le service Form Recognizer, vous devez créer une instance de la classe DocumentAnalysisClient. Pour ce faire, vous créez un AzureKeyCredential avec votre key depuis le portail Azure et une instance DocumentAnalysisClient avec le AzureKeyCredential et votre endpoint Form Recognizer.

Notes

• À compter de .NET 6, de nouveaux projets utilisant le modèle console génèrent un nouveau style de programme qui diffère des versions précédentes.
• La nouvelle sortie utilise des fonctionnalités C# récentes qui simplifient le code que vous devez écrire.
• Lorsque vous utilisez la version la plus récente, vous devez uniquement écrire le corps de la Main méthode. Vous n’avez pas besoin d’inclure des instructions de niveau supérieur, des directives globales à l’aide de directives ou des directives implicites.
• Pour plus d’informations, consultez Les nouveaux modèles C# génèrent des instructions de plus haut niveau.

1. Ouvrez le fichier Program.cs.

2. Supprimez le code préexistant, y compris la ligne Console.Writeline("Hello World!"), puis sélectionnez l’un des exemples de code suivants à copier et coller dans le fichier Program.cs de votre application :

   • Modèle de disposition

   • Modèle prédéfini

Important

N’oubliez pas de supprimer la clé de votre code une fois que vous avez terminé, et ne la postez jamais publiquement. Pour la production, utilisez un moyen sécurisé de stocker et d’accéder à vos informations d’identification comme Azure Key Vault. Si vous souhaitez en savoir plus, veuillez consulter la rubriqueSécurité Azure AI services.

Modèle de disposition

Extrayez le texte, les marques de sélection, les styles de texte et les structures de tableaux, ainsi que les coordonnées de leurs cadres de limitation, à partir de documents.

• Pour cet exemple, vous aurez besoin d’un fichier de document au niveau d’un URL. Vous pouvez utiliser notre exemple de document pour ce guide de démarrage rapide.
• Nous avons ajouté la valeur de l’URI du fichier à la variable Uri fileUri en haut du fichier.
• Pour extraire la disposition d’un fichier donné au niveau d’un URI, utilisez la méthode StartAnalyzeDocumentFromUri et transmettez prebuilt-layout comme ID de modèle. La valeur retournée est un objet AnalyzeResult contenant des données provenant du document envoyé.

Ajoutez l’exemple de code suivant au fichier Program.cs. Veillez à mettre à jour les variables de point de terminaison et de clé avec les valeurs de votre instance Form Recognizer dans le Portail Azure :

using Azure;
using Azure.AI.FormRecognizer.DocumentAnalysis;

//set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal to create your `AzureKeyCredential` and `DocumentAnalysisClient` instance
string endpoint = "<your-endpoint>";
string key = "<your-key>";
AzureKeyCredential credential = new AzureKeyCredential(key);
DocumentAnalysisClient client = new DocumentAnalysisClient(new Uri(endpoint), credential);

//sample document
Uri fileUri = new Uri ("https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf");

AnalyzeDocumentOperation operation = await client.AnalyzeDocumentFromUriAsync(WaitUntil.Completed, "prebuilt-layout", fileUri);

AnalyzeResult result = operation.Value;

foreach (DocumentPage page in result.Pages)
{
    Console.WriteLine($"Document Page {page.PageNumber} has {page.Lines.Count} line(s), {page.Words.Count} word(s),");
    Console.WriteLine($"and {page.SelectionMarks.Count} selection mark(s).");

    for (int i = 0; i < page.Lines.Count; i++)
    {
        DocumentLine line = page.Lines[i];
        Console.WriteLine($"  Line {i} has content: '{line.Content}'.");

        Console.WriteLine($"    Its bounding box is:");
        Console.WriteLine($"      Upper left => X: {line.BoundingPolygon[0].X}, Y= {line.BoundingPolygon[0].Y}");
        Console.WriteLine($"      Upper right => X: {line.BoundingPolygon[1].X}, Y= {line.BoundingPolygon[1].Y}");
        Console.WriteLine($"      Lower right => X: {line.BoundingPolygon[2].X}, Y= {line.BoundingPolygon[2].Y}");
        Console.WriteLine($"      Lower left => X: {line.BoundingPolygon[3].X}, Y= {line.BoundingPolygon[3].Y}");
    }

    for (int i = 0; i < page.SelectionMarks.Count; i++)
    {
        DocumentSelectionMark selectionMark = page.SelectionMarks[i];

        Console.WriteLine($"  Selection Mark {i} is {selectionMark.State}.");
        Console.WriteLine($"    Its bounding box is:");
        Console.WriteLine($"      Upper left => X: {selectionMark.BoundingPolygon[0].X}, Y= {selectionMark.BoundingPolygon[0].Y}");
        Console.WriteLine($"      Upper right => X: {selectionMark.BoundingPolygon[1].X}, Y= {selectionMark.BoundingPolygon[1].Y}");
        Console.WriteLine($"      Lower right => X: {selectionMark.BoundingPolygon[2].X}, Y= {selectionMark.BoundingPolygon[2].Y}");
        Console.WriteLine($"      Lower left => X: {selectionMark.BoundingPolygon[3].X}, Y= {selectionMark.BoundingPolygon[3].Y}");
    }
}

foreach (DocumentStyle style in result.Styles)
{
    // Check the style and style confidence to see if text is handwritten.
    // Note that value '0.8' is used as an example.

    bool isHandwritten = style.IsHandwritten.HasValue && style.IsHandwritten == true;

    if (isHandwritten && style.Confidence > 0.8)
    {
        Console.WriteLine($"Handwritten content found:");

        foreach (DocumentSpan span in style.Spans)
        {
            Console.WriteLine($"  Content: {result.Content.Substring(span.Index, span.Length)}");
        }
    }
}

Console.WriteLine("The following tables were extracted:");

for (int i = 0; i < result.Tables.Count; i++)
{
    DocumentTable table = result.Tables[i];
    Console.WriteLine($"  Table {i} has {table.RowCount} rows and {table.ColumnCount} columns.");

    foreach (DocumentTableCell cell in table.Cells)
    {
        Console.WriteLine($"    Cell ({cell.RowIndex}, {cell.ColumnIndex}) has kind '{cell.Kind}' and content: '{cell.Content}'.");
    }
}

Exécuter votre application

Une fois que vous ajoutez un exemple de code à votre application, choisissez le bouton vert Démarrer en regard de formRecognizer_quickstart pour générer et exécuter votre programme, ou appuyez sur F5.

Sortie du modèle de disposition

Voici un extrait de la sortie attendue :

  Document Page 1 has 69 line(s), 425 word(s), and 15 selection mark(s).
  Line 0 has content: 'UNITED STATES'.
    Its bounding box is:
      Upper left => X: 3.4915, Y= 0.6828
      Upper right => X: 5.0116, Y= 0.6828
      Lower right => X: 5.0116, Y= 0.8265
      Lower left => X: 3.4915, Y= 0.8265
  Line 1 has content: 'SECURITIES AND EXCHANGE COMMISSION'.
    Its bounding box is:
      Upper left => X: 2.1937, Y= 0.9061
      Upper right => X: 6.297, Y= 0.9061
      Lower right => X: 6.297, Y= 1.0498
      Lower left => X: 2.1937, Y= 1.0498

Pour afficher l’intégralité de la sortie, consultez le référentiel d’exemples Azure sur GitHub pour afficher la sortie du modèle de disposition.

Modèle prédéfini

Analysez et extrayez les champs communs de types de documents spécifiques à l’aide d’un modèle prédéfini. Dans cet exemple, nous analysons une facture à l’aide du modèle de facture prédéfini.

Conseil

Vous n’êtes pas limité aux factures. Il existe plusieurs modèles prédéfinis ayant chacun leur propre ensemble de champs pris en charge. Le modèle à utiliser pour l’opération analyze dépend du type de document à analyser. Consultez Extraction de données de modèle.

• Analysez une facture à l’aide du modèle de facture prédéfini. Vous pouvez utiliser notre exemple de facture pour ce guide de démarrage rapide.
• Nous avons ajouté la valeur de l’URI du fichier à la variable Uri invoiceUri en haut du fichier.
• Pour analyser un fichier donné au niveau d’un URI, utilisez la méthode StartAnalyzeDocumentFromUri et transmettez-lui prebuilt-invoice comme ID de modèle. La valeur retournée est un objet AnalyzeResult contenant des données provenant du document envoyé.
• Par souci de simplicité, toutes les paires clé-valeur retournées par le service ne sont pas indiquées ici. Pour afficher la liste de tous les champs pris en charge et les types correspondants, consultez notre page conceptuelle Facture.

Ajoutez l’exemple de code suivant au fichier Program.cs. Veillez à mettre à jour les variables de point de terminaison et de clé avec les valeurs de votre instance Form Recognizer dans le Portail Azure :

using Azure;
using Azure.AI.FormRecognizer.DocumentAnalysis;

//set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal to create your `AzureKeyCredential` and `FormRecognizerClient` instance
string endpoint = "<your-endpoint>";
string key = "<your-key>";
AzureKeyCredential credential = new AzureKeyCredential(key);
DocumentAnalysisClient client = new DocumentAnalysisClient(new Uri(endpoint), credential);

//sample invoice document

Uri invoiceUri = new Uri ("https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf");

Operation operation = await client.AnalyzeDocumentAsync(WaitUntil.Completed, "prebuilt-invoice", invoiceUri);

AnalyzeResult result = operation.Value;

for (int i = 0; i < result.Documents.Count; i++)
{
    Console.WriteLine($"Document {i}:");

    AnalyzedDocument document = result.Documents[i];

    if (document.Fields.TryGetValue("VendorName", out DocumentField vendorNameField))
    {
        if (vendorNameField.FieldType == DocumentFieldType.String)
        {
            string vendorName = vendorNameField.Value.AsString();
            Console.WriteLine($"Vendor Name: '{vendorName}', with confidence {vendorNameField.Confidence}");
        }
    }

    if (document.Fields.TryGetValue("CustomerName", out DocumentField customerNameField))
    {
        if (customerNameField.FieldType == DocumentFieldType.String)
        {
            string customerName = customerNameField.Value.AsString();
            Console.WriteLine($"Customer Name: '{customerName}', with confidence {customerNameField.Confidence}");
        }
    }

    if (document.Fields.TryGetValue("Items", out DocumentField itemsField))
    {
        if (itemsField.FieldType == DocumentFieldType.List)
        {
            foreach (DocumentField itemField in itemsField.Value.AsList())
            {
                Console.WriteLine("Item:");

                if (itemField.FieldType == DocumentFieldType.Dictionary)
                {
                    IReadOnlyDictionary<string, DocumentField> itemFields = itemField.Value.AsDictionary();

                    if (itemFields.TryGetValue("Description", out DocumentField itemDescriptionField))
                    {
                        if (itemDescriptionField.FieldType == DocumentFieldType.String)
                        {
                            string itemDescription = itemDescriptionField.Value.AsString();

                            Console.WriteLine($"  Description: '{itemDescription}', with confidence {itemDescriptionField.Confidence}");
                        }
                    }

                    if (itemFields.TryGetValue("Amount", out DocumentField itemAmountField))
                    {
                        if (itemAmountField.FieldType == DocumentFieldType.Currency)
                        {
                            CurrencyValue itemAmount = itemAmountField.Value.AsCurrency();

                            Console.WriteLine($"  Amount: '{itemAmount.Symbol}{itemAmount.Amount}', with confidence {itemAmountField.Confidence}");
                        }
                    }
                }
            }
        }
    }

    if (document.Fields.TryGetValue("SubTotal", out DocumentField subTotalField))
    {
        if (subTotalField.FieldType == DocumentFieldType.Currency)
        {
            CurrencyValue subTotal = subTotalField.Value.AsCurrency();
            Console.WriteLine($"Sub Total: '{subTotal.Symbol}{subTotal.Amount}', with confidence {subTotalField.Confidence}");
        }
    }

    if (document.Fields.TryGetValue("TotalTax", out DocumentField totalTaxField))
    {
        if (totalTaxField.FieldType == DocumentFieldType.Currency)
        {
            CurrencyValue totalTax = totalTaxField.Value.AsCurrency();
            Console.WriteLine($"Total Tax: '{totalTax.Symbol}{totalTax.Amount}', with confidence {totalTaxField.Confidence}");
        }
    }

    if (document.Fields.TryGetValue("InvoiceTotal", out DocumentField invoiceTotalField))
    {
        if (invoiceTotalField.FieldType == DocumentFieldType.Currency)
        {
            CurrencyValue invoiceTotal = invoiceTotalField.Value.AsCurrency();
            Console.WriteLine($"Invoice Total: '{invoiceTotal.Symbol}{invoiceTotal.Amount}', with confidence {invoiceTotalField.Confidence}");
        }
    }
}

Exécuter votre application

Une fois que vous ajoutez un exemple de code à votre application, choisissez le bouton vert Démarrer en regard de formRecognizer_quickstart pour générer et exécuter votre programme, ou appuyez sur F5.

Sortie du modèle prédéfini

Voici un extrait de la sortie attendue :

  Document 0:
  Vendor Name: 'CONTOSO LTD.', with confidence 0.962
  Customer Name: 'MICROSOFT CORPORATION', with confidence 0.951
  Item:
    Description: 'Test for 23 fields', with confidence 0.899
    Amount: '100', with confidence 0.902
  Sub Total: '100', with confidence 0.979

Pour afficher l’intégralité de la sortie, consultez le référentiel d’exemples Azure sur GitHub pour afficher la sortie du modèle de facture prédéfini.

Bibliothèque de client | Référence du kit de développement logiciel (SDK) | Référence de l’API REST | Package (Maven) | Exemples| Version de l’API REST prise en charge

Dans ce guide de démarrage rapide, utilisez les fonctionnalités suivantes pour analyser et extraire des données et des valeurs de formulaires et de documents :

• Disposition – Analysez et extrayez les tableaux, les lignes, les mots et les marques de sélection telles que les cases d’option et les cases à cocher, sans avoir besoin d’entraîner un modèle.

• Facture préétablie : Analyser et extraire les champs communs des types de documents spécifiques à l’aide d’un modèle préentraîné.

Prérequis

• Abonnement Azure : créez-en un gratuitement.

• Dernière version de Visual Studio Code ou de votre IDE préféré. Consultez Java dans Visual Studio Code.

  Conseil

  • Visual Studio Code offre un pack de programmation pour Java pour Windows et macOS. Le pack de programmation est un bundle de VS Code, le Kit de développement Java (JDK) et une collection d’extensions suggérées par Microsoft. Le Pack de programmation peut également être utilisé pour corriger un environnement de développement existant.
  • Si vous utilisez VS Code et le Pack de programmation pour Java, installez l’extension Gradle pour Java.

• Si vous n’utilisez pas Visual Studio Code, vérifiez que les éléments suivants sont installés dans votre environnement de développement :

  • Un Kit de développement Java (JDK) version 8 ou ultérieure. Pour plus d’informations, consultez Build Microsoft d’OpenJDK.

  • Gradle, version 6.8 ou ultérieure.

• Une ressource Azure AI services ou Intelligence documentaire. Une fois que vous avez votre abonnement Azure, créez une ressource d’Intelligence documentaire monoservice ou multiservice dans le portail Azure pour obtenir votre clé et votre point de terminaison. Vous pouvez utiliser le niveau tarifaire Gratuit (F0) pour tester le service, puis passer par la suite à un niveau payant pour la production.

  Conseil

  Créez une ressource Azure AI services si vous envisagez d’accéder à plusieurs services Azure AI services sous un seul point de terminaison/une seule clé. Pour l’accès à Document Intelligence uniquement, créez une ressource Document Intelligence. Veuillez noter que vous aurez besoin d’une ressource à service unique si vous avez l’intention d’utiliser l’authentification Microsoft Entra.

• Après le déploiement de votre ressource, sélectionnez Accéder à la ressource. Vous avez besoin de la clé et du point de terminaison de la ressource que vous créez pour connecter votre application à l’API Azure AI Intelligence documentaire. Plus loin, vous collez votre clé et votre point de terminaison dans le code :

  

Configurer

Créer un projet Gradle

1. Dans une fenêtre de console (comme cmd, PowerShell ou Bash), créez un répertoire pour votre application appelé form-recognize-app et accédez-y.

   mkdir form-recognize-app && form-recognize-app
   

   mkdir form-recognize-app; cd form-recognize-app
   

2. Exécutez la commande gradle init à partir de votre répertoire de travail. Cette commande crée des fichiers de build essentiels pour Gradle, notamment build.gradle.kts, qui est utilisé au moment de l’exécution pour créer et configurer votre application.

   gradle init --type basic
   

3. Quand vous êtes invité à choisir un DSL, sélectionnez Kotlin.

4. Acceptez le nom du projet par défaut (form-recognize-app) en sélectionnant Retour ou Entrée.

Installer la bibliothèque de client

Ce guide de démarrage rapide utilise le gestionnaire de dépendances Gradle. Vous trouverez la bibliothèque de client et des informations concernant d’autres gestionnaires de dépendances sur le référentiel central Maven.

Ouvrez le fichier build.gradle.kts du projet dans votre IDE. Copiez et collez le code suivant pour inclure la bibliothèque de client sous la forme d’une instruction implementation, avec les plug-ins et les paramètres obligatoires.

   plugins {
       java
       application
   }
   application {
       mainClass.set("FormRecognizer")
   }
   repositories {
       mavenCentral()
   }
   dependencies {
       implementation group: 'com.azure', name: 'azure-ai-formrecognizer', version: '4.1.0'

   }

Création d’une application Java

Pour interagir avec le service d’Intelligence documentaire, vous devez créer une instance de classe DocumentAnalysisClient. Pour ce faire, vous créez un AzureKeyCredential avec votre key depuis le portail Azure et une instance DocumentAnalysisClient avec le AzureKeyCredential et votre endpoint d’Intelligence documentaire.

1. À partir du répertoire doc-intel-app, exécutez la commande suivante :

   mkdir -p src/main/java
   

   Vous créez la structure de répertoires suivante :

   

1. Accédez au répertoire java et créez un fichier nommé FormRecognizer.java.

   Conseil

   • Vous pouvez créer un nouveau fichier à l’aide de PowerShell.
   • Ouvrez une fenêtre PowerShell dans le répertoire de votre projet en maintenant la touche Maj enfoncée et en cliquant avec le bouton droit sur le dossier.
   • Tapez la commande New-Item FormRecognizer.java.

2. Ouvrez le fichier FormRecognizer.java . Copiez et collez l’un des exemples de code suivants dans votre application :

   • Disposition

   • Facture prédéfinie

Important

N’oubliez pas de supprimer la clé de votre code une fois que vous avez terminé, et ne la postez jamais publiquement. Pour la production, utilisez un moyen sécurisé de stocker et d’accéder à vos informations d’identification comme Azure Key Vault. Si vous souhaitez en savoir plus, veuillez consulter la rubriqueSécurité Azure AI services.

Modèle de disposition

Extrayez le texte, les marques de sélection, les styles de texte et les structures de tableaux, ainsi que les coordonnées de leurs cadres de limitation, à partir de documents.

• Pour cet exemple, vous aurez besoin d’un fichier de document au niveau d’un URL. Vous pouvez utiliser notre exemple de document pour ce guide de démarrage rapide.
• Pour analyser un fichier donné au niveau d’un URI, vous utilisez la méthode beginAnalyzeDocumentFromUrl et passez prebuilt-layout comme ID de modèle. La valeur retournée est un objet AnalyzeResult contenant des données sur le document envoyé.
• Nous avons ajouté la valeur de l’URI du fichier à la variable documentUrl en haut de la méthode main.

Ajoutez le code suivant au fichier FormRecognizer.java. Veillez à mettre à jour les variables de point de terminaison et de clé avec les valeurs de votre instance d’Intelligence documentaire du Portail Azure :

import com.azure.ai.formrecognizer.documentanalysis.models.*;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClient;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClientBuilder;

import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.io.IOException;
import java.util.List;
import java.util.Arrays;
import java.time.LocalDate;
import java.util.Map;
import java.util.stream.Collectors;

public class FormRecognizer {

  // set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal
  private static final String endpoint = "<your-endpoint>";
  private static final String key = "<your-key>";

  public static void main(String[] args) {

    // create your `DocumentAnalysisClient` instance and `AzureKeyCredential` variable
    DocumentAnalysisClient client = new DocumentAnalysisClientBuilder()
      .credential(new AzureKeyCredential(key))
      .endpoint(endpoint)
      .buildClient();

    // sample document
    String documentUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf";
    String modelId = "prebuilt-layout";

    SyncPoller < OperationResult, AnalyzeResult > analyzeLayoutResultPoller =
      client.beginAnalyzeDocumentFromUrl(modelId, documentUrl);

    AnalyzeResult analyzeLayoutResult = analyzeLayoutResultPoller.getFinalResult();

    // pages
    analyzeLayoutResult.getPages().forEach(documentPage -> {
      System.out.printf("Page has width: %.2f and height: %.2f, measured with unit: %s%n",
        documentPage.getWidth(),
        documentPage.getHeight(),
        documentPage.getUnit());

      // lines
      documentPage.getLines().forEach(documentLine ->
        System.out.printf("Line %s is within a bounding polygon %s.%n",
          documentLine.getContent(),
          documentLine.getBoundingPolygon().toString()));

      // words
      documentPage.getWords().forEach(documentWord ->
        System.out.printf("Word '%s' has a confidence score of %.2f%n",
          documentWord.getContent(),
          documentWord.getConfidence()));

      // selection marks
      documentPage.getSelectionMarks().forEach(documentSelectionMark ->
        System.out.printf("Selection mark is %s and is within a bounding polygon %s with confidence %.2f.%n",
          documentSelectionMark.getState().toString(),
          documentSelectionMark.getBoundingPolygon().toString(),
          documentSelectionMark.getConfidence()));
    });

    // tables
    List < DocumentTable > tables = analyzeLayoutResult.getTables();
    for (int i = 0; i < tables.size(); i++) {
      DocumentTable documentTable = tables.get(i);
      System.out.printf("Table %d has %d rows and %d columns.%n", i, documentTable.getRowCount(),
        documentTable.getColumnCount());
      documentTable.getCells().forEach(documentTableCell -> {
        System.out.printf("Cell '%s', has row index %d and column index %d.%n", documentTableCell.getContent(),
          documentTableCell.getRowIndex(), documentTableCell.getColumnIndex());
      });
      System.out.println();
    }
  }
  // Utility function to get the bounding polygon coordinates
  private static String getBoundingCoordinates(List < Point > boundingPolygon) {
    return boundingPolygon.stream().map(point -> String.format("[%.2f, %.2f]", point.getX(),
      point.getY())).collect(Collectors.joining(", "));
  }
}

Génération et exécution de l’application

Une fois que vous avez ajouté un exemple de code à votre application, revenez au répertoire de votre projet principal, form-recognize-app.

1. Générez votre application avec la commande build :

   gradle build
   

2. Exécutez votre application avec la commande run :

   gradle run
   

Sortie du modèle de disposition

Voici un extrait de la sortie attendue :

  Table 0 has 5 rows and 3 columns.
  Cell 'Title of each class', has row index 0 and column index 0.
  Cell 'Trading Symbol', has row index 0 and column index 1.
  Cell 'Name of exchange on which registered', has row index 0 and column index 2.
  Cell 'Common stock, $0.00000625 par value per share', has row index 1 and column index 0.
  Cell 'MSFT', has row index 1 and column index 1.
  Cell 'NASDAQ', has row index 1 and column index 2.
  Cell '2.125% Notes due 2021', has row index 2 and column index 0.
  Cell 'MSFT', has row index 2 and column index 1.
  Cell 'NASDAQ', has row index 2 and column index 2.
  Cell '3.125% Notes due 2028', has row index 3 and column index 0.
  Cell 'MSFT', has row index 3 and column index 1.
  Cell 'NASDAQ', has row index 3 and column index 2.
  Cell '2.625% Notes due 2033', has row index 4 and column index 0.
  Cell 'MSFT', has row index 4 and column index 1.
  Cell 'NASDAQ', has row index 4 and column index 2.

Pour afficher l’intégralité de la sortie, consultez le référentiel d’exemples Azure sur GitHub pour afficher la sortie du modèle de disposition.

Modèle prédéfini

Analysez et extrayez les champs communs de types de documents spécifiques à l’aide d’un modèle prédéfini. Dans cet exemple, nous analysons une facture à l’aide du modèle de facture prédéfini.

Conseil

Vous n’êtes pas limité aux factures. Il existe plusieurs modèles prédéfinis ayant chacun leur propre ensemble de champs pris en charge. Le modèle à utiliser pour l’opération analyze dépend du type de document à analyser. Consultez Extraction de données de modèle.

• Analysez une facture à l’aide du modèle de facture prédéfini. Vous pouvez utiliser notre exemple de facture pour ce guide de démarrage rapide.
• Nous avons ajouté la valeur d’URL du fichier à la variable invoiceUrl en haut du fichier.
• Pour analyser un fichier donné au niveau d’un URI, vous utilisez la méthode beginAnalyzeDocuments et passez PrebuiltModels.Invoice comme ID de modèle. La valeur retournée est un objet result contenant des données sur le document envoyé.
• Par souci de simplicité, toutes les paires clé-valeur retournées par le service ne sont pas indiquées ici. Pour afficher la liste de tous les champs pris en charge et les types correspondants, consultez notre page conceptuelle Facture.

Ajoutez le code suivant au fichier FormRecognizer.java. Veillez à mettre à jour les variables de point de terminaison et de clé avec les valeurs de votre instance d’Intelligence documentaire du Portail Azure :

import com.azure.ai.formrecognizer.documentanalysis.models.*;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClient;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClientBuilder;

import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.io.IOException;
import java.util.List;
import java.util.Arrays;
import java.time.LocalDate;
import java.util.Map;
import java.util.stream.Collectors;

public class FormRecognizer {

  // set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal
  private static final String endpoint = "<your-endpoint>";
  private static final String key = "<your-key>";

  public static void main(final String[] args) throws IOException {

    // create your `DocumentAnalysisClient` instance and `AzureKeyCredential` variable
    DocumentAnalysisClient client = new DocumentAnalysisClientBuilder()
      .credential(new AzureKeyCredential(key))
      .endpoint(endpoint)
      .buildClient();

    // sample document
    String modelId = "prebuilt-invoice";
    String invoiceUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf";

    SyncPoller < OperationResult, AnalyzeResult > analyzeInvoicePoller = client.beginAnalyzeDocumentFromUrl(modelId, invoiceUrl);

    AnalyzeResult analyzeInvoiceResult = analyzeInvoicePoller.getFinalResult();

    for (int i = 0; i < analyzeInvoiceResult.getDocuments().size(); i++) {
      AnalyzedDocument analyzedInvoice = analyzeInvoiceResult.getDocuments().get(i);
      Map < String, DocumentField > invoiceFields = analyzedInvoice.getFields();
      System.out.printf("----------- Analyzing invoice  %d -----------%n", i);
      DocumentField vendorNameField = invoiceFields.get("VendorName");
      if (vendorNameField != null) {
        if (DocumentFieldType.STRING == vendorNameField.getType()) {
          String merchantName = vendorNameField.getValueAsString();
          System.out.printf("Vendor Name: %s, confidence: %.2f%n",
            merchantName, vendorNameField.getConfidence());
        }
      }

      DocumentField vendorAddressField = invoiceFields.get("VendorAddress");
      if (vendorAddressField != null) {
        if (DocumentFieldType.STRING == vendorAddressField.getType()) {
          String merchantAddress = vendorAddressField.getValueAsString();
          System.out.printf("Vendor address: %s, confidence: %.2f%n",
            merchantAddress, vendorAddressField.getConfidence());
        }
      }

      DocumentField customerNameField = invoiceFields.get("CustomerName");
      if (customerNameField != null) {
        if (DocumentFieldType.STRING == customerNameField.getType()) {
          String merchantAddress = customerNameField.getValueAsString();
          System.out.printf("Customer Name: %s, confidence: %.2f%n",
            merchantAddress, customerNameField.getConfidence());
        }
      }

      DocumentField customerAddressRecipientField = invoiceFields.get("CustomerAddressRecipient");
      if (customerAddressRecipientField != null) {
        if (DocumentFieldType.STRING == customerAddressRecipientField.getType()) {
          String customerAddr = customerAddressRecipientField.getValueAsString();
          System.out.printf("Customer Address Recipient: %s, confidence: %.2f%n",
            customerAddr, customerAddressRecipientField.getConfidence());
        }
      }

      DocumentField invoiceIdField = invoiceFields.get("InvoiceId");
      if (invoiceIdField != null) {
        if (DocumentFieldType.STRING == invoiceIdField.getType()) {
          String invoiceId = invoiceIdField.getValueAsString();
          System.out.printf("Invoice ID: %s, confidence: %.2f%n",
            invoiceId, invoiceIdField.getConfidence());
        }
      }

      DocumentField invoiceDateField = invoiceFields.get("InvoiceDate");
      if (customerNameField != null) {
        if (DocumentFieldType.DATE == invoiceDateField.getType()) {
          LocalDate invoiceDate = invoiceDateField.getValueAsDate();
          System.out.printf("Invoice Date: %s, confidence: %.2f%n",
            invoiceDate, invoiceDateField.getConfidence());
        }
      }

      DocumentField invoiceTotalField = invoiceFields.get("InvoiceTotal");
      if (customerAddressRecipientField != null) {
        if (DocumentFieldType.DOUBLE == invoiceTotalField.getType()) {
          Double invoiceTotal = invoiceTotalField.getValueAsDouble();
          System.out.printf("Invoice Total: %.2f, confidence: %.2f%n",
            invoiceTotal, invoiceTotalField.getConfidence());
        }
      }

      DocumentField invoiceItemsField = invoiceFields.get("Items");
      if (invoiceItemsField != null) {
        System.out.printf("Invoice Items: %n");
        if (DocumentFieldType.LIST == invoiceItemsField.getType()) {
          List < DocumentField > invoiceItems = invoiceItemsField.getValueAsList();
          invoiceItems.stream()
            .filter(invoiceItem -> DocumentFieldType.MAP == invoiceItem.getType())
            .map(documentField -> documentField.getValueAsMap())
            .forEach(documentFieldMap -> documentFieldMap.forEach((key, documentField) -> {

              // See a full list of fields found on an invoice here:
              // https://aka.ms/formrecognizer/invoicefields

              if ("Description".equals(key)) {
                if (DocumentFieldType.STRING == documentField.getType()) {
                  String name = documentField.getValueAsString();
                  System.out.printf("Description: %s, confidence: %.2fs%n",
                    name, documentField.getConfidence());
                }
              }
              if ("Quantity".equals(key)) {
                if (DocumentFieldType.DOUBLE == documentField.getType()) {
                  Double quantity = documentField.getValueAsDouble();
                  System.out.printf("Quantity: %f, confidence: %.2f%n",
                    quantity, documentField.getConfidence());
                }
              }
              if ("UnitPrice".equals(key)) {
                if (DocumentFieldType.DOUBLE == documentField.getType()) {
                  Double unitPrice = documentField.getValueAsDouble();
                  System.out.printf("Unit Price: %f, confidence: %.2f%n",
                    unitPrice, documentField.getConfidence());
                }
              }
              if ("ProductCode".equals(key)) {
                if (DocumentFieldType.DOUBLE == documentField.getType()) {
                  Double productCode = documentField.getValueAsDouble();
                  System.out.printf("Product Code: %f, confidence: %.2f%n",
                    productCode, documentField.getConfidence());
                }
              }
            }));
        }
      }
    }
  }
}

Génération et exécution de l’application

Une fois que vous avez ajouté un exemple de code à votre application, revenez au répertoire de votre projet principal, doc-intel-app.

1. Générez votre application avec la commande build :

   gradle build
   

2. Exécutez votre application avec la commande run :

   gradle run
   

Sortie du modèle prédéfini

Voici un extrait de la sortie attendue :

  ----------- Analyzing invoice  0 -----------
  Analyzed document has doc type invoice with confidence : 1.00
  Vendor Name: CONTOSO LTD., confidence: 0.92
  Vendor address: 123 456th St New York, NY, 10001, confidence: 0.91
  Customer Name: MICROSOFT CORPORATION, confidence: 0.84
  Customer Address Recipient: Microsoft Corp, confidence: 0.92
  Invoice ID: INV-100, confidence: 0.97
  Invoice Date: 2019-11-15, confidence: 0.97

Pour afficher l’intégralité de la sortie, consultez le référentiel d’exemples Azure sur GitHub pour afficher la sortie du modèle de facture prédéfini.

Bibliothèque de client | Référence du kit de développement logiciel (SDK) | Référence de l’API REST | Package (npm) | Exemples |Version de l’API REST prise en charge

Dans ce guide de démarrage rapide, utilisez les fonctionnalités suivantes pour analyser et extraire des données et des valeurs de formulaires et de documents :

• Disposition – Analysez et extrayez les tableaux, les lignes, les mots et les marques de sélection telles que les cases d’option et les cases à cocher, sans avoir besoin d’entraîner un modèle.

• Facture préétablie : Analyser et extraire les champs communs de types de documents spécifiques à l’aide d’un modèle préentraîné de facture.

Prérequis

• Abonnement Azure : créez-en un gratuitement.

• Dernière version de Visual Studio Code ou de votre IDE préféré. Pour plus d’informations, consultez Node.js dans Visual Studio Code.

• La dernière version LTS de Node.js.

• Une ressource Azure AI services ou Intelligence documentaire. Une fois que vous avez votre abonnement Azure, créez une ressource d’Intelligence documentaire monoservice ou multiservice dans le portail Azure pour obtenir votre clé et votre point de terminaison. Vous pouvez utiliser le niveau tarifaire Gratuit (F0) pour tester le service, puis passer par la suite à un niveau payant pour la production.

  Conseil

  Créez une ressource Azure AI services si vous envisagez d’accéder à plusieurs services Azure AI services sous un seul point de terminaison/une seule clé. Pour l’accès à Document Intelligence uniquement, créez une ressource Document Intelligence. Veuillez noter que vous aurez besoin d’une ressource à service unique si vous avez l’intention d’utiliser l’authentification Microsoft Entra.

• Après le déploiement de votre ressource, sélectionnez Accéder à la ressource. Vous avez besoin de la clé et du point de terminaison de la ressource que vous créez pour connecter votre application à l’API Azure AI Intelligence documentaire. Vous collez votre clé et votre point de terminaison dans le code plus loin dans ce guide de démarrage rapide :

  

Configurer

1. Créer une application Node.js Express : dans une fenêtre de console (telle que cmd, PowerShell ou Bash), créez un répertoire nommé doc-intel-app pour votre application et accédez-y.

   mkdir doc-intel-app && cd doc-intel-app
   

2. Exécutez la commande npm init pour initialiser l’application et échafauder votre projet.

   npm init
   

3. Spécifiez les attributs de votre projet à l’aide des invites qui s’affichent dans le terminal.

   • Les attributs les plus importants sont le nom, le numéro de version et le point d’entrée.
   • Nous vous recommandons de conserver index.js comme nom du point d’entrée. La description, la commande de test, le référentiel GitHub, les mots clés, l’auteur et les informations de licence sont des attributs facultatifs. Vous pouvez les ignorer pour ce projet.
   • Acceptez les suggestions entre parenthèses en sélectionnant Retour ou Entrée.
   • Une fois que vous avez répondu aux invites, un fichier package.json est créé dans votre répertoire doc-intel-app.

4. Installez le package de la bibliothèque de client ai-form-recognizer et le package npm azure/identity :

   npm i @azure/ai-form-recognizer@5.0.0 @azure/identity
   

   • Le fichier package.json de votre application est mis à jour avec les dépendances.

5. Créez un fichier nommé index.js dans le répertoire de l’application.

   Conseil

   • Vous pouvez créer un nouveau fichier à l’aide de PowerShell.
   • Ouvrez une fenêtre PowerShell dans le répertoire de votre projet en maintenant la touche Maj enfoncée et en cliquant avec le bouton droit sur le dossier.
   • Tapez la commande New-Item index.js.

Générer votre application

Pour interagir avec le service d’Intelligence documentaire, vous devez créer une instance de classe DocumentAnalysisClient. Pour ce faire, vous créez un AzureKeyCredential avec votre key depuis le portail Azure et une instance DocumentAnalysisClient avec le AzureKeyCredential et votre endpoint Form Recognizer.

1. Ouvrez le fichier index.js dans Visual Studio Code ou dans l’IDE de votre choix. Copiez et collez l’un des exemples de code suivants dans votre application :

   • Disposition

   • Facture prédéfinie

Important

N’oubliez pas de supprimer la clé de votre code une fois que vous avez terminé, et ne la postez jamais publiquement. Pour la production, utilisez un moyen sécurisé de stocker et d’accéder à vos informations d’identification comme Azure Key Vault. Si vous souhaitez en savoir plus, veuillez consulter la rubriqueSécurité Azure AI services.

Modèle de disposition

Extrayez le texte, les marques de sélection, les styles de texte et les structures de tableaux, ainsi que les coordonnées de leurs cadres de limitation, à partir de documents.

• Pour cet exemple, vous aurez besoin d’un fichier de document au niveau d’un URL. Vous pouvez utiliser notre exemple de document pour ce guide de démarrage rapide.
• Nous avons ajouté la valeur d’URL du fichier à la variable formUrl en haut du fichier.
• Pour analyser un fichier donné à partir d’une URL, utilisez la méthode beginAnalyzeDocuments et passez-lui prebuilt-layout comme ID de modèle.

Ajoutez le code suivant au fichier index.js. Veillez à mettre à jour les variables de point de terminaison et de clé avec les valeurs de votre instance d’Intelligence documentaire du Portail Azure :

 const { AzureKeyCredential, DocumentAnalysisClient } = require("@azure/ai-form-recognizer");

    // set `<your-key>` and `<your-endpoint>` variables with the values from the Azure portal.
    const key = "<your-key>";
    const endpoint = "<your-endpoint>";

    // sample document
  const formUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf"

  async function main() {
    const client = new DocumentAnalysisClient(endpoint, new AzureKeyCredential(key));

    const poller = await client.beginAnalyzeDocumentFromUrl("prebuilt-layout", formUrl);

    const {
        pages,
        tables
    } = await poller.pollUntilDone();

    if (pages.length <= 0) {
        console.log("No pages were extracted from the document.");
    } else {
        console.log("Pages:");
        for (const page of pages) {
            console.log("- Page", page.pageNumber, `(unit: ${page.unit})`);
            console.log(`  ${page.width}x${page.height}, angle: ${page.angle}`);
            console.log(`  ${page.lines.length} lines, ${page.words.length} words`);
        }
    }

    if (tables.length <= 0) {
        console.log("No tables were extracted from the document.");
    } else {
        console.log("Tables:");
        for (const table of tables) {
            console.log(
                `- Extracted table: ${table.columnCount} columns, ${table.rowCount} rows (${table.cells.length} cells)`
            );
        }
    }
}

main().catch((error) => {
    console.error("An error occurred:", error);
    process.exit(1);
});

Exécuter votre application

Une fois que vous avez ajouté un exemple de code à votre application, exécutez votre programme :

1. Accédez au dossier contenant votre application d’Intelligence documentaire (doc-intel-app).

2. Tapez la commande suivante dans votre terminal :

   node index.js
   

Sortie du modèle de disposition

Voici un extrait de la sortie attendue :

Pages:
- Page 1 (unit: inch)
  8.5x11, angle: 0
  69 lines, 425 words
Tables:
- Extracted table: 3 columns, 5 rows (15 cells)

Pour afficher l’intégralité de la sortie, consultez le référentiel d’exemples Azure sur GitHub pour afficher la sortie du modèle de disposition.

Modèle prédéfini

Dans cet exemple, nous analysons une facture à l’aide du modèle de facture prédéfini.

Conseil

Vous n’êtes pas limité aux factures. Il existe plusieurs modèles prédéfinis ayant chacun leur propre ensemble de champs pris en charge. Le modèle à utiliser pour l’opération analyze dépend du type de document à analyser. Consultez Extraction de données de modèle.

• Analysez une facture à l’aide du modèle de facture prédéfini. Vous pouvez utiliser notre exemple de facture pour ce guide de démarrage rapide.
• Nous avons ajouté la valeur d’URL du fichier à la variable invoiceUrl en haut du fichier.
• Pour analyser un fichier donné au niveau d’un URI, vous utilisez la méthode beginAnalyzeDocuments et passez PrebuiltModels.Invoice comme ID de modèle. La valeur retournée est un objet result contenant des données sur le document envoyé.
• Par souci de simplicité, toutes les paires clé-valeur retournées par le service ne sont pas indiquées ici. Pour afficher la liste de tous les champs pris en charge et les types correspondants, consultez notre page conceptuelle Facture.

 const {
    AzureKeyCredential,
    DocumentAnalysisClient
} = require("@azure/ai-form-recognizer");

// set `<your-key>` and `<your-endpoint>` variables with the values from the Azure portal.
const key = "<your-key>";
const endpoint = "<your-endpoint>";
// sample document
invoiceUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf"

async function main() {
    const client = new DocumentAnalysisClient(endpoint, new AzureKeyCredential(key));

    const poller = await client.beginAnalyzeDocumentFromUrl("prebuilt-invoice", invoiceUrl);

    const {
        pages,
        tables
    } = await poller.pollUntilDone();

    if (pages.length <= 0) {
        console.log("No pages were extracted from the document.");
    } else {
        console.log("Pages:");
        for (const page of pages) {
            console.log("- Page", page.pageNumber, `(unit: ${page.unit})`);
            console.log(`  ${page.width}x${page.height}, angle: ${page.angle}`);
            console.log(`  ${page.lines.length} lines, ${page.words.length} words`);

            if (page.lines && page.lines.length > 0) {
                console.log("  Lines:");

                for (const line of page.lines) {
                    console.log(`  - "${line.content}"`);

                    // The words of the line can also be iterated independently. The words are computed based on their
                    // corresponding spans.
                    for (const word of line.words()) {
                        console.log(`    - "${word.content}"`);
                    }
                }
            }
        }
    }

    if (tables.length <= 0) {
        console.log("No tables were extracted from the document.");
    } else {
        console.log("Tables:");
        for (const table of tables) {
            console.log(
                `- Extracted table: ${table.columnCount} columns, ${table.rowCount} rows (${table.cells.length} cells)`
            );
        }
    }
}

main().catch((error) => {
    console.error("An error occurred:", error);
    process.exit(1);
});

Exécuter votre application

Une fois que vous avez ajouté un exemple de code à votre application, exécutez votre programme :

1. Accédez au dossier contenant votre application d’Intelligence documentaire (doc-intel-app).

2. Tapez la commande suivante dans votre terminal :

   node index.js
   

Sortie du modèle prédéfini

Voici un extrait de la sortie attendue :

  Vendor Name: CONTOSO LTD.
  Customer Name: MICROSOFT CORPORATION
  Invoice Date: 2019-11-15T00:00:00.000Z
  Due Date: 2019-12-15T00:00:00.000Z
  Items:
  - <no product code>
    Description: Test for 23 fields
    Quantity: 1
    Date: undefined
    Unit: undefined
    Unit Price: 1
    Tax: undefined
    Amount: 100

Pour afficher l’intégralité de la sortie, consultez le référentiel d’exemples Azure sur GitHub pour afficher la sortie du modèle de facture prédéfini.

Bibliothèque de client |Référence du kit de développement logiciel (SDK) | Référence de l’API REST | Package (PyPi) | Exemples | Version de l’API REST prise en charge

Dans ce guide de démarrage rapide, utilisez les fonctionnalités suivantes pour analyser et extraire des données de formulaires et de documents :

• Disposition : analysez et extrayez les tableaux, les lignes, les mots et les marques de sélection comme les cases d’option et les cases à cocher, et les paires clé-valeur, sans avoir besoin d’effectuer l’apprentissage d’un modèle.

• Facture préétablie : Analyser et extraire les champs communs des types de documents spécifiques à l’aide d’un modèle préentraîné.

Prérequis

• Abonnement Azure : créez-en un gratuitement.

• Python 3.7 ou ultérieur.

  • Votre installation Python doit inclure pip. Vous pouvez vérifier si pip est installé en exécutant pip --version sur la ligne de commande. Procurez-vous pip en installant la dernière version de Python.

• Dernière version de Visual Studio Code ou de votre IDE préféré. Pour plus d’informations, consultez Prise en main de Python dans Visual Studio Code.

• Une ressource Azure AI services ou Intelligence documentaire. Une fois que vous avez votre abonnement Azure, créez une ressource d’Intelligence documentaire monoservice ou multiservice dans le portail Azure pour obtenir votre clé et votre point de terminaison. Vous pouvez utiliser le niveau tarifaire Gratuit (F0) pour tester le service, puis passer par la suite à un niveau payant pour la production.

Conseil

Créez une ressource Azure AI services si vous envisagez d’accéder à plusieurs services Azure AI services sous un seul point de terminaison/une seule clé. Pour l’accès à Document Intelligence uniquement, créez une ressource Document Intelligence. Veuillez noter que vous aurez besoin d’une ressource à service unique si vous avez l’intention d’utiliser l’authentification Microsoft Entra.

• Après le déploiement de votre ressource, sélectionnez Accéder à la ressource. Vous avez besoin de la clé et du point de terminaison de la ressource que vous créez pour connecter votre application à l’API Azure AI Intelligence documentaire. Vous collez votre clé et votre point de terminaison dans le code plus loin dans ce guide de démarrage rapide :

  

Configurer

Ouvrez une fenêtre de terminal dans votre environnement local et installez la bibliothèque de client Azure AI Intelligence documentaire pour Python avec pip :

pip install azure-ai-formrecognizer==3.3.0

Créer votre application Python

Pour interagir avec le service d’Intelligence documentaire, vous devez créer une instance de classe DocumentAnalysisClient. Pour ce faire, vous créez un AzureKeyCredential avec votre key depuis le portail Azure et une instance DocumentAnalysisClient avec le AzureKeyCredential et votre endpoint d’Intelligence documentaire.

1. Créez une application Python nommée form_recognizer_quickstart.py dans votre éditeur ou IDE favori.

2. Ouvrez le fichier form_recognizer_quickstart.py et sélectionnez l’un des exemples de code suivants à copier et coller dans votre application :

   • Disposition

   • Facture prédéfinie

Important

N’oubliez pas de supprimer la clé de votre code une fois que vous avez terminé, et ne la postez jamais publiquement. Pour la production, utilisez un moyen sécurisé de stocker et d’accéder à vos informations d’identification comme Azure Key Vault. Si vous souhaitez en savoir plus, veuillez consulter la rubriqueSécurité Azure AI services.

Modèle de disposition

Extrayez le texte, les marques de sélection, les styles de texte et les structures de tableaux, ainsi que les coordonnées de leurs cadres de limitation, à partir de documents.

• Pour cet exemple, vous aurez besoin d’un fichier de document au niveau d’un URL. Vous pouvez utiliser notre exemple de document pour ce guide de démarrage rapide.
• Nous avons ajouté la valeur de l'URL du fichier à la variableformUrl dans la fonctionanalyze_layout.

Pour analyser un fichier donné au niveau d’un URI, vous utilisez la méthode begin_analyze_document_from_url et passez prebuilt-layout comme ID de modèle. La valeur retournée est un objet result contenant des données sur le document envoyé.

Ajoutez l’exemple de code suivant à votre application form_recognizer_quickstart.py. Veillez à mettre à jour les variables de point de terminaison et de clé avec les valeurs de votre instance Form Recognizer dans le Portail Azure :

# import libraries
import os
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential

# set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal
endpoint = "<your-endpoint>"
key = "<your-key>"

def format_polygon(polygon):
    if not polygon:
        return "N/A"
    return ", ".join(["[{}, {}]".format(p.x, p.y) for p in polygon])

def analyze_layout():
    # sample document
    formUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf"

    document_analysis_client = DocumentAnalysisClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller = document_analysis_client.begin_analyze_document_from_url(
            "prebuilt-layout", formUrl)
    result = poller.result()

    for idx, style in enumerate(result.styles):
        print(
            "Document contains {} content".format(
                "handwritten" if style.is_handwritten else "no handwritten"
            )
        )

    for page in result.pages:
        print("----Analyzing layout from page #{}----".format(page.page_number))
        print(
            "Page has width: {} and height: {}, measured with unit: {}".format(
                page.width, page.height, page.unit
            )
        )

        for line_idx, line in enumerate(page.lines):
            words = line.get_words()
            print(
                "...Line # {} has word count {} and text '{}' within bounding box '{}'".format(
                    line_idx,
                    len(words),
                    line.content,
                    format_polygon(line.polygon),
                )
            )

            for word in words:
                print(
                    "......Word '{}' has a confidence of {}".format(
                        word.content, word.confidence
                    )
                )

        for selection_mark in page.selection_marks:
            print(
                "...Selection mark is '{}' within bounding box '{}' and has a confidence of {}".format(
                    selection_mark.state,
                    format_polygon(selection_mark.polygon),
                    selection_mark.confidence,
                )
            )

    for table_idx, table in enumerate(result.tables):
        print(
            "Table # {} has {} rows and {} columns".format(
                table_idx, table.row_count, table.column_count
            )
        )
        for region in table.bounding_regions:
            print(
                "Table # {} location on page: {} is {}".format(
                    table_idx,
                    region.page_number,
                    format_polygon(region.polygon),
                )
            )
        for cell in table.cells:
            print(
                "...Cell[{}][{}] has content '{}'".format(
                    cell.row_index,
                    cell.column_index,
                    cell.content,
                )
            )
            for region in cell.bounding_regions:
                print(
                    "...content on page {} is within bounding box '{}'".format(
                        region.page_number,
                        format_polygon(region.polygon),
                    )
                )

    print("----------------------------------------")


if __name__ == "__main__":
    analyze_layout()

Exécution de l'application

Une fois que vous avez ajouté un exemple de code à votre application, générez et exécutez votre programme :

1. Accédez au dossier contenant votre fichier form_recognizer_quickstart.py.

2. Tapez la commande suivante dans votre terminal :

   python form_recognizer_quickstart.py
   

Sortie du modèle de disposition

Voici un extrait de la sortie attendue :

  ----Analyzing layout from page #1----
  Page has width: 8.5 and height: 11.0, measured with unit: inch
  ...Line # 0 has word count 2 and text 'UNITED STATES' within bounding box '[3.4915, 0.6828], [5.0116, 0.6828], [5.0116, 0.8265], [3.4915, 0.8265]'
  ......Word 'UNITED' has a confidence of 1.0
  ......Word 'STATES' has a confidence of 1.0
  ...Line # 1 has word count 4 and text 'SECURITIES AND EXCHANGE COMMISSION' within bounding box '[2.1937, 0.9061], [6.297, 0.9061], [6.297, 1.0498], [2.1937, 1.0498]'
  ......Word 'SECURITIES' has a confidence of 1.0
  ......Word 'AND' has a confidence of 1.0
  ......Word 'EXCHANGE' has a confidence of 1.0
  ......Word 'COMMISSION' has a confidence of 1.0
  ...Line # 2 has word count 3 and text 'Washington, D.C. 20549' within bounding box '[3.4629, 1.1179], [5.031, 1.1179], [5.031, 1.2483], [3.4629, 1.2483]'
  ......Word 'Washington,' has a confidence of 1.0
  ......Word 'D.C.' has a confidence of 1.0

Pour afficher l’intégralité de la sortie, consultez le référentiel d’exemples Azure sur GitHub pour afficher la sortie du modèle de disposition.

---

Modèle prédéfini

Analysez et extrayez les champs communs de types de documents spécifiques à l’aide d’un modèle prédéfini. Dans cet exemple, nous analysons une facture à l’aide du modèle de facture prédéfini.

Conseil

Vous n’êtes pas limité aux factures. Il existe plusieurs modèles prédéfinis ayant chacun leur propre ensemble de champs pris en charge. Le modèle à utiliser pour l’opération analyze dépend du type de document à analyser. Consultez Extraction de données de modèle.

• Analysez une facture à l’aide du modèle de facture prédéfini. Vous pouvez utiliser notre exemple de facture pour ce guide de démarrage rapide.
• Nous avons ajouté la valeur d’URL du fichier à la variable invoiceUrl en haut du fichier.
• Par souci de simplicité, toutes les paires clé-valeur retournées par le service ne sont pas indiquées ici. Pour afficher la liste de tous les champs pris en charge et les types correspondants, consultez notre page conceptuelle Facture.

Pour analyser un fichier donné au niveau d’un URI, vous utilisez la méthode begin_analyze_document_from_url et passez prebuilt-invoice comme ID de modèle. La valeur retournée est un objet result contenant des données sur le document envoyé.

Ajoutez l’exemple de code suivant à votre application form_recognizer_quickstart.py. Veillez à mettre à jour les variables de point de terminaison et de clé avec les valeurs de votre instance Form Recognizer dans le Portail Azure :

# import libraries
import os
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential

# set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal
endpoint = "<your-endpoint>"
key = "<your-key>"


def format_bounding_region(bounding_regions):
    if not bounding_regions:
        return "N/A"
    return ", ".join(
        "Page #{}: {}".format(region.page_number, format_polygon(region.polygon))
        for region in bounding_regions
    )


def format_polygon(polygon):
    if not polygon:
        return "N/A"
    return ", ".join(["[{}, {}]".format(p.x, p.y) for p in polygon])


def analyze_invoice():

    invoiceUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf"

    document_analysis_client = DocumentAnalysisClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller = document_analysis_client.begin_analyze_document_from_url(
        "prebuilt-invoice", invoiceUrl
    )
    invoices = poller.result()

    for idx, invoice in enumerate(invoices.documents):
        print("--------Recognizing invoice #{}--------".format(idx + 1))
        vendor_name = invoice.fields.get("VendorName")
        if vendor_name:
            print(
                "Vendor Name: {} has confidence: {}".format(
                    vendor_name.value, vendor_name.confidence
                )
            )
        vendor_address = invoice.fields.get("VendorAddress")
        if vendor_address:
            print(
                "Vendor Address: {} has confidence: {}".format(
                    vendor_address.value, vendor_address.confidence
                )
            )
        vendor_address_recipient = invoice.fields.get("VendorAddressRecipient")
        if vendor_address_recipient:
            print(
                "Vendor Address Recipient: {} has confidence: {}".format(
                    vendor_address_recipient.value, vendor_address_recipient.confidence
                )
            )
        customer_name = invoice.fields.get("CustomerName")
        if customer_name:
            print(
                "Customer Name: {} has confidence: {}".format(
                    customer_name.value, customer_name.confidence
                )
            )
        customer_id = invoice.fields.get("CustomerId")
        if customer_id:
            print(
                "Customer Id: {} has confidence: {}".format(
                    customer_id.value, customer_id.confidence
                )
            )
        customer_address = invoice.fields.get("CustomerAddress")
        if customer_address:
            print(
                "Customer Address: {} has confidence: {}".format(
                    customer_address.value, customer_address.confidence
                )
            )
        customer_address_recipient = invoice.fields.get("CustomerAddressRecipient")
        if customer_address_recipient:
            print(
                "Customer Address Recipient: {} has confidence: {}".format(
                    customer_address_recipient.value,
                    customer_address_recipient.confidence,
                )
            )
        invoice_id = invoice.fields.get("InvoiceId")
        if invoice_id:
            print(
                "Invoice Id: {} has confidence: {}".format(
                    invoice_id.value, invoice_id.confidence
                )
            )
        invoice_date = invoice.fields.get("InvoiceDate")
        if invoice_date:
            print(
                "Invoice Date: {} has confidence: {}".format(
                    invoice_date.value, invoice_date.confidence
                )
            )
        invoice_total = invoice.fields.get("InvoiceTotal")
        if invoice_total:
            print(
                "Invoice Total: {} has confidence: {}".format(
                    invoice_total.value, invoice_total.confidence
                )
            )
        due_date = invoice.fields.get("DueDate")
        if due_date:
            print(
                "Due Date: {} has confidence: {}".format(
                    due_date.value, due_date.confidence
                )
            )
        purchase_order = invoice.fields.get("PurchaseOrder")
        if purchase_order:
            print(
                "Purchase Order: {} has confidence: {}".format(
                    purchase_order.value, purchase_order.confidence
                )
            )
        billing_address = invoice.fields.get("BillingAddress")
        if billing_address:
            print(
                "Billing Address: {} has confidence: {}".format(
                    billing_address.value, billing_address.confidence
                )
            )
        billing_address_recipient = invoice.fields.get("BillingAddressRecipient")
        if billing_address_recipient:
            print(
                "Billing Address Recipient: {} has confidence: {}".format(
                    billing_address_recipient.value,
                    billing_address_recipient.confidence,
                )
            )
        shipping_address = invoice.fields.get("ShippingAddress")
        if shipping_address:
            print(
                "Shipping Address: {} has confidence: {}".format(
                    shipping_address.value, shipping_address.confidence
                )
            )
        shipping_address_recipient = invoice.fields.get("ShippingAddressRecipient")
        if shipping_address_recipient:
            print(
                "Shipping Address Recipient: {} has confidence: {}".format(
                    shipping_address_recipient.value,
                    shipping_address_recipient.confidence,
                )
            )
        print("Invoice items:")
        for idx, item in enumerate(invoice.fields.get("Items").value):
            print("...Item #{}".format(idx + 1))
            item_description = item.value.get("Description")
            if item_description:
                print(
                    "......Description: {} has confidence: {}".format(
                        item_description.value, item_description.confidence
                    )
                )
            item_quantity = item.value.get("Quantity")
            if item_quantity:
                print(
                    "......Quantity: {} has confidence: {}".format(
                        item_quantity.value, item_quantity.confidence
                    )
                )
            unit = item.value.get("Unit")
            if unit:
                print(
                    "......Unit: {} has confidence: {}".format(
                        unit.value, unit.confidence
                    )
                )
            unit_price = item.value.get("UnitPrice")
            if unit_price:
                print(
                    "......Unit Price: {} has confidence: {}".format(
                        unit_price.value, unit_price.confidence
                    )
                )
            product_code = item.value.get("ProductCode")
            if product_code:
                print(
                    "......Product Code: {} has confidence: {}".format(
                        product_code.value, product_code.confidence
                    )
                )
            item_date = item.value.get("Date")
            if item_date:
                print(
                    "......Date: {} has confidence: {}".format(
                        item_date.value, item_date.confidence
                    )
                )
            tax = item.value.get("Tax")
            if tax:
                print(
                    "......Tax: {} has confidence: {}".format(tax.value, tax.confidence)
                )
            amount = item.value.get("Amount")
            if amount:
                print(
                    "......Amount: {} has confidence: {}".format(
                        amount.value, amount.confidence
                    )
                )
        subtotal = invoice.fields.get("SubTotal")
        if subtotal:
            print(
                "Subtotal: {} has confidence: {}".format(
                    subtotal.value, subtotal.confidence
                )
            )
        total_tax = invoice.fields.get("TotalTax")
        if total_tax:
            print(
                "Total Tax: {} has confidence: {}".format(
                    total_tax.value, total_tax.confidence
                )
            )
        previous_unpaid_balance = invoice.fields.get("PreviousUnpaidBalance")
        if previous_unpaid_balance:
            print(
                "Previous Unpaid Balance: {} has confidence: {}".format(
                    previous_unpaid_balance.value, previous_unpaid_balance.confidence
                )
            )
        amount_due = invoice.fields.get("AmountDue")
        if amount_due:
            print(
                "Amount Due: {} has confidence: {}".format(
                    amount_due.value, amount_due.confidence
                )
            )
        service_start_date = invoice.fields.get("ServiceStartDate")
        if service_start_date:
            print(
                "Service Start Date: {} has confidence: {}".format(
                    service_start_date.value, service_start_date.confidence
                )
            )
        service_end_date = invoice.fields.get("ServiceEndDate")
        if service_end_date:
            print(
                "Service End Date: {} has confidence: {}".format(
                    service_end_date.value, service_end_date.confidence
                )
            )
        service_address = invoice.fields.get("ServiceAddress")
        if service_address:
            print(
                "Service Address: {} has confidence: {}".format(
                    service_address.value, service_address.confidence
                )
            )
        service_address_recipient = invoice.fields.get("ServiceAddressRecipient")
        if service_address_recipient:
            print(
                "Service Address Recipient: {} has confidence: {}".format(
                    service_address_recipient.value,
                    service_address_recipient.confidence,
                )
            )
        remittance_address = invoice.fields.get("RemittanceAddress")
        if remittance_address:
            print(
                "Remittance Address: {} has confidence: {}".format(
                    remittance_address.value, remittance_address.confidence
                )
            )
        remittance_address_recipient = invoice.fields.get("RemittanceAddressRecipient")
        if remittance_address_recipient:
            print(
                "Remittance Address Recipient: {} has confidence: {}".format(
                    remittance_address_recipient.value,
                    remittance_address_recipient.confidence,
                )
            )

        print("----------------------------------------")

if __name__ == "__main__":
    analyze_invoice()

Exécution de l'application

Une fois que vous avez ajouté un exemple de code à votre application, générez et exécutez votre programme :

1. Accédez au dossier contenant votre fichier form_recognizer_quickstart.py.

2. Tapez la commande suivante dans votre terminal :

   python form_recognizer_quickstart.py
   

Sortie du modèle prédéfini

Voici un extrait de la sortie attendue :

  --------Recognizing invoice #1--------
  Vendor Name: CONTOSO LTD. has confidence: 0.919
  Vendor Address: 123 456th St New York, NY, 10001 has confidence: 0.907
  Vendor Address Recipient: Contoso Headquarters has confidence: 0.919
  Customer Name: MICROSOFT CORPORATION has confidence: 0.84
  Customer Id: CID-12345 has confidence: 0.956
  Customer Address: 123 Other St, Redmond WA, 98052 has confidence: 0.909
  Customer Address Recipient: Microsoft Corp has confidence: 0.917
  Invoice Id: INV-100 has confidence: 0.972
  Invoice Date: 2019-11-15 has confidence: 0.971
  Invoice Total: CurrencyValue(amount=110.0, symbol=$) has confidence: 0.97
  Due Date: 2019-12-15 has confidence: 0.973

Pour afficher l’intégralité de la sortie, consultez le référentiel d’exemples Azure sur GitHub pour afficher la sortie du modèle de facture prédéfini.

| API REST Intelligence documentaire | Kits de développement logiciel (SDK) Azure pris en charge |

Dans ce démarrage rapide, apprenez à utiliser l’API REST Intelligence documentaire pour analyser et extraire des données et des valeurs de documents :

Prérequis

• Abonnement Azure - En créer un gratuitement

• Outil en ligne de commande curl installé.

  • Windows
  • Mac ou Linux

• PowerShell version 7.*+ (ou une application en ligne de commande similaire.) :

  • Windows
  • macOS
  • Linux

• Pour vérifier votre version de PowerShell, tapez la commande suivante par rapport à votre système d’exploitation :

  • Windows : Get-Host | Select-Object Version
  • macOS ou Linux : $PSVersionTable

• Une ressource d’Intelligence documentaire (monoservice) ou Azure AI services (multiservice). Une fois que vous avez votre abonnement Azure, créez une ressource d’Intelligence documentaire monoservice ou multiservice dans le portail Azure pour obtenir votre clé et votre point de terminaison. Vous pouvez utiliser le niveau tarifaire Gratuit (F0) pour tester le service, puis passer par la suite à un niveau payant pour la production.

Conseil

Créez une ressource Azure AI services si vous envisagez d’accéder à plusieurs services Azure AI services sous un seul point de terminaison/une seule clé. Pour l’accès à Document Intelligence uniquement, créez une ressource Document Intelligence. Veuillez noter que vous aurez besoin d’une ressource à service unique si vous avez l’intention d’utiliser l’authentification Microsoft Entra.

• Après le déploiement de votre ressource, sélectionnez Accéder à la ressource. Vous avez besoin de la clé et du point de terminaison de la ressource que vous créez pour connecter votre application à l’API Azure AI Intelligence documentaire. Vous collez votre clé et votre point de terminaison dans le code plus loin dans ce guide de démarrage rapide :

  

Analyser des documents et obtenir les résultats

Une requête POST est utilisée pour analyser des documents avec un modèle prédéfini ou personnalisé. Une requête GET est utilisée pour récupérer le résultat d’un appel d’analyse de document. Le modelId est utilisé avec les opérations POST et resultId avec les opérations GET.

Analyser un document (demande POST)

Avant d’exécuter la commande cURL, apportez les modifications suivantes à la demande de publication:

1. Remplacez {endpoint} par la valeur du point de terminaison de votre instance d’Intelligence documentaire du portail Azure.

2. Remplacez {key} par la valeur de la clé de votre instance d’Intelligence documentaire du portail Azure.

3. En vous servant du tableau suivant comme référence, remplacez {modelID} et {your-document-url} par les valeurs souhaitées.

4. Vous avez besoin d’un fichier de document au niveau d’une URL. Pour ce guide de démarrage rapide, vous pouvez utiliser les exemples de formulaires fournis dans le tableau suivant pour chaque fonctionnalité :

Exemples de documents

Fonctionnalité	{modelID}	{your-document-url}
Document général	prebuilt-document	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf
Lire	prebuilt-read	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/read.png
Disposition	prebuilt-layout	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/layout.png
Carte d’assurance maladie	prebuilt-healthInsuranceCard.us	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/insurance-card.png
W-2	prebuilt-tax.us.w2	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/w2.png
Facture	Facture prédéfinie	https://github.com/Azure-Samples/cognitive-services-REST-api-samples/raw/master/curl/form-recognizer/rest-api/invoice.pdf
Réception	prebuilt-receipt	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/receipt.png
Document d’identité	prebuilt-idDocument	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/identity_documents.png
Carte de visite	prebuilt-businessCard	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/de5e0d8982ab754823c54de47a47e8e499351523/curl/form-recognizer/rest-api/business_card.jpg

Important

N’oubliez pas de supprimer la clé de votre code une fois que vous avez terminé, et ne la postez jamais publiquement. Pour la production, utilisez un moyen sécurisé de stocker et d’accéder à vos informations d’identification comme Azure Key Vault. Si vous souhaitez en savoir plus, veuillez consulter la rubriqueSécurité Azure AI services.

requête POST

curl -v -i POST "{endpoint}/formrecognizer/documentModels/{modelID}:analyze?api-version=2023-07-31" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: {key}" --data-ascii "{'urlSource': '{your-document-url}'}"

Réponse POST (resultID)

Vous recevez une réponse 202 (Success) incluant un en-tête en lecture seule Operation-Location. La valeur de cet en-tête contient un resultID qui peut être interrogé pour obtenir l’état de l’opération asynchrone et récupérer les résultats à l’aide d’une requête GET avec votre même clé d’abonnement de ressource :

Obtenir les résultats d’analyse (demande GET)

Après avoir appelé l’API Analyze document, appelez l’API Obtenir les résultats d’analyse pour obtenir l’état de l’opération et les données extraites. Avant d’exécuter la commande, apportez les modifications suivantes :

1. Remplacez l’en-tête Operation-Location {resultID} de la réponse POST.

2. Remplacez {key} par la valeur de la clé de votre instance d’Intelligence documentaire dans le portail Azure.

Requête GET

curl -v -X GET "{endpoint}/formrecognizer/documentModels/{modelId}/analyzeResults/{resultId}?api-version=2023-07-31" -H "Ocp-Apim-Subscription-Key: {key}"

Examiner la réponse

Vous recevez une réponse 200 (Success) avec une sortie JSON. Le premier champ, "status", indique l’état de l’opération. Si l’opération n’est pas terminée, la valeur de "status" est "running" ou "notStarted". Vous devez alors rappeler l’API, manuellement ou via un script. Nous vous recommandons d’attendre une seconde ou plus entre chaque appel.

Exemple de réponse pour prebuilt-invoice

{
    "status": "succeeded",
    "createdDateTime": "2023-08-25T19:31:37Z",
    "lastUpdatedDateTime": "2023-08-25T19:31:43Z",
    "analyzeResult": {
        "apiVersion": "2023-07-31",
        "modelId": "prebuilt-invoice",
        "stringIndexType": "textElements"...
    ..."pages": [
            {
                "pageNumber": 1,
                "angle": 0,
                "width": 8.5,
                "height": 11,
                "unit": "inch",
                "words": [
                    {
                        "content": "CONTOSO",
                        "boundingBox": [
                            0.5911,
                            0.6857,
                            1.7451,
                            0.6857,
                            1.7451,
                            0.8664,
                            0.5911,
                            0.8664
                        ],
                        "confidence": 1,
                        "span": {
                            "offset": 0,
                            "length": 7
                                }
                      }],
              }]
      }
}

Champs de document pris en charge

Les modèles prédéfinis extraient des ensembles prédéfinis de champs de document. Consultez Extraction des données de modèle pour connaître les noms de champs et les types extraits et obtenir des descriptions et des exemples.

Voilà, félicitations !

Dans ce démarrage rapide, vous avez utilisé un modèle d’Intelligence documentaire pour analyser divers formulaires et documents. Ensuite, explorez le Studio d’Intelligence documentaire et la documentation de référence pour découvrir plus en détail l’API d’Intelligence documentaire.

Étapes suivantes

• Pour une expérience améliorée et une qualité de modèle avancée, essayez Intelligence Documentaire Studio

• Pour une migration de la version v3.1 vers la version v4.0, consultez Guides de migration du journal des modifications.

• Découvrez plus d’exemples sur GitHub.