Bibliothèque de client Azure Document Intelligence pour Java - version 4.1.2

  • Article

Azure Document Intelligence (anciennement Form Recognizer) est un service cloud qui utilise le Machine Learning pour analyser du texte et des données structurées à partir de vos documents. Il comprend les fonctionnalités de main suivantes :

  • Disposition : extrayez du texte, des structures de tableau et des marques de sélection, ainsi que leurs coordonnées de région englobante, à partir de documents.
  • Document : analysez les entités, les paires clé-valeur, les tables et les marques de sélection à partir de documents à l’aide du modèle de document prédéfini général.
  • Prédéfini : analysez les données de certains types de documents courants (tels que les reçus, les factures, les cartes de visite, les documents d’identité ou les formulaires fiscaux W2 américains) à l’aide de modèles prédéfinis.
  • Personnalisé : créez des modèles personnalisés pour extraire du texte, des valeurs de champ, des marques de sélection et des données de tableau à partir de documents. Les modèles personnalisés sont créés avec vos propres données, de sorte qu’ils sont adaptés à vos documents.
  • Lecture : lit des informations sur les éléments textuels, tels que les mots de page et les lignes, en plus des informations sur la langue du texte.
  • Classifieurs : créez des classifieurs personnalisés pour classer les documents en classes prédéfinies.

| Code sourcePackage (Maven) | Documentation de référence sur les | APIDocumentation | produitÉchantillons

Prise en main

Prérequis

Inclure le package

Inclure le fichier de nomenclature

Incluez azure-sdk-bom à votre projet pour dépendre de la version ga de la bibliothèque. Dans l’extrait de code suivant, remplacez l’espace réservé {bom_version_to_target} par le numéro de version. Pour en savoir plus sur la nomenclature, consultez le README BOM du KIT DE DÉVELOPPEMENT LOGICIEL AZURE.

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.azure</groupId>
            <artifactId>azure-sdk-bom</artifactId>
            <version>{bom_version_to_target}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

Ensuite, incluez la dépendance directe dans la section des dépendances sans la balise de version.

<dependencies>
  <dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-ai-formrecognizer</artifactId>
  </dependency>
</dependencies>

Inclure une dépendance directe

Si vous souhaitez dépendre d’une version particulière de la bibliothèque qui n’est pas présente dans la nomenclature, ajoutez la dépendance directe à votre projet comme suit.

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-ai-formrecognizer</artifactId>
    <version>4.1.2</version>
</dependency>

Remarque : Cette version de la bibliothèque cliente utilise par défaut la "2023-07-31" version du service.

Ce tableau montre la relation entre les versions du kit de développement logiciel (SDK) et les versions d’API prises en charge du service :

Version du SDK Version d’API prise en charge du service
3.0.x 2.0
3.1.X - 3.1.12 2.0, 2.1 (par défaut)
4.0.0 2.0, 2.1, 2022-08-31 (par défaut)
4.1.0 2.0, 2.1, 2022-08-31, 2023-07-31 (par défaut)

Remarque : À compter de la version 4.0.X, un nouvel ensemble de clients a été introduit pour tirer parti des fonctionnalités les plus récentes du service Form Recognizer. Consultez le Guide de migration pour obtenir des instructions détaillées sur la mise à jour du code d’application de la bibliothèque cliente version 3.1.X ou antérieure vers la dernière version. Pour plus d’informations, consultez Journal des modifications. Le tableau ci-dessous décrit la relation entre chaque client et ses versions d’API prises en charge :

Version de l'API Clients pris en charge
2023-07-31 DocumentAnalysisClient et DocumentModelAdministrationClient
2022-08-31 DocumentAnalysisClient et DocumentModelAdministrationClient
2.1 FormRecognizerClient et FormTrainingClient
2.0 FormRecognizerClient et FormTrainingClient

Créer une ressource Form Recognizer

Form Recognizer prend en charge à la fois l’accès multiservices et l’accès à service unique. Créez la ressource d’un service cognitif si vous envisagez d’accéder à plusieurs services cognitifs sous un seul point de terminaison/clé. Pour l’accès à Form Recognizer uniquement, créez une ressource Form Recognizer.

Vous pouvez créer l’une ou l’autre ressource à l’aide de

Option 1 :Portail Azure

Option 2 :Azure CLI

Voici un exemple de création d’une ressource Form Recognizer à l’aide de l’interface CLI :

# Create a new resource group to hold the Form Recognizer resource -
# if using an existing resource group, skip this step
az group create --name <your-resource-group> --location <location>

# Create Form Recognizer
az cognitiveservices account create \
    --name <your-form-recognizer-resource-name> \
    --resource-group <your-resource-group> \
    --kind FormRecognizer \
    --sku <sku> \
    --location <location> \
    --yes

Authentifier le client

Pour interagir avec le service Form Recognizer, vous devez créer une instance du client Analyse de document. Les clients asynchrones et synchrones peuvent être créés à l’aide de DocumentAnalysisClientBuilder. L’appel buildClient() crée le client synchrone, tandis que l’appel buildAsyncClient crée son équivalent asynchrone.

Vous aurez besoin d’un point de terminaison et d’une clé pour instancier un objet client.

Recherche du point de terminaison

Vous pouvez trouver le point de terminaison de votre ressource Form Recognizer dans le Portail Azure ou Azure CLI.

# Get the endpoint for the resource
az cognitiveservices account show --name "resource-name" --resource-group "resource-group-name" --query "endpoint"

Créer un client d’analyse de document à l’aide d’AzureKeyCredential

Pour utiliser AzureKeyCredential l’authentification, fournissez la clé sous forme de chaîne à AzureKeyCredential. Cette clé se trouve dans le Portail Azure de la ressource Form Recognizer que vous avez créée, ou en exécutant la commande Azure CLI suivante pour obtenir la clé à partir de la ressource Form Recognizer :

az cognitiveservices account keys list --resource-group <your-resource-group-name> --name <your-resource-name>

Utilisez la clé API comme paramètre d’informations d’identification pour authentifier le client :

DocumentAnalysisClient documentAnalysisClient = new DocumentAnalysisClientBuilder()
    .credential(new AzureKeyCredential("{key}"))
    .endpoint("{endpoint}")
    .buildClient();

DocumentModelAdministrationClient client =
    new DocumentModelAdministrationClientBuilder()
        .credential(new AzureKeyCredential("{key}"))
        .endpoint("{endpoint}")
        .buildClient();

Créer un client Analyse de document avec les informations d’identification Azure Active Directory

Le Kit de développement logiciel (SDK) Azure pour Java prend en charge un package Azure Identity, ce qui facilite l’obtention des informations d’identification à partir de Plateforme d'identités Microsoft.

L’authentification avec AAD nécessite une configuration initiale :

  • Ajouter le package Azure Identity
<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity</artifactId>
    <version>1.10.0</version>
</dependency>

Après l’installation, vous pouvez choisir le type d’informations d’identification à utiliser à partir d’azure-identity. Par exemple, DefaultAzureCredential peut être utilisé pour authentifier le client : définissez les valeurs de l’ID client, de l’ID de locataire et de la clé secrète client de l’application AAD en tant que variables d’environnement : AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET.

L’autorisation est plus simple à l’aide de DefaultAzureCredential. Il trouve les meilleures informations d’identification à utiliser dans son environnement d’exécution. Pour plus d’informations sur l’utilisation de l’autorisation Azure Active Directory avec Form Recognizer, consultez la documentation associée.

DocumentAnalysisClient documentAnalysisClient = new DocumentAnalysisClientBuilder()
    .endpoint("{endpoint}")
    .credential(new DefaultAzureCredentialBuilder().build())
    .buildClient();

Concepts clés

DocumentAnalysisClient

DocumentAnalysisClient et DocumentAnalysisAsyncClient fournissent des opérations synchrones et asynchrones pour l’analyse des documents d’entrée à l’aide de modèles personnalisés et prédéfinis via les beginAnalyzeDocument méthodes et beginAnalyzeDocumentFromUrl . Consultez la liste complète des modèles pris en charge ici.

Exemples d’extraits de code à illustrer à l’aide d’un DocumentAnalysisClient ici. Vous trouverez plus d’informations sur l’analyse des documents, notamment les fonctionnalités prises en charge, les paramètres régionaux et les types de documents ici.

DocumentModelAdministrationClient

DocumentModelAdministrationClient et DocumentModelAdministrationAsyncClient fournissent des opérations synchrones et asynchrones

  • Créez des modèles d’analyse de documents personnalisés pour analyser le contenu, les champs et les valeurs du texte trouvés dans vos documents personnalisés. Consultez l’exemple Générer un modèle de document. Un DocumentModelDetails est retourné indiquant les types de documents que le modèle peut analyser, ainsi que les champs et les schémas qu’il extrait.
  • Gestion des modèles créés dans votre compte en créant, en répertoriant, en supprimant et en montrant la limite de modèles personnalisés de votre compte. Consultez l’exemple Gérer les modèles.
  • Copier un modèle personnalisé d’une ressource Form Recognizer vers une autre.
  • Création d’un modèle composé à partir d’une collection de modèles générés existants.
  • Liste des opérations de modèle de document associées à la ressource Form Recognizer.

Des exemples d’extraits de code sont fournis pour illustrer l’utilisation d’un DocumentModelAdministrationClient ici.

Opérations de longue durée

Les opérations de longue durée sont des opérations qui consistent en une demande initiale envoyée au service pour démarrer une opération, suivie d’un interrogation du service à intervalles réguliers pour déterminer si l’opération s’est terminée ou a échoué, et si elle a réussi, pour obtenir le résultat.

Les méthodes qui créent des modèles, analysent des valeurs à partir de documents ou copient et composent des modèles sont modélisées comme des opérations de longue durée. Le client expose une begin<MethodName> méthode qui retourne un ou PollerFlux instanceSyncPoller. Les appelants doivent attendre que l’opération soit terminée en appelant getFinalResult() sur l’opération retournée à partir de la begin<MethodName> méthode . Des exemples d’extraits de code sont fournis pour illustrer l’utilisation d’opérations de longue durée ci-dessous.

Exemples

La section suivante fournit plusieurs extraits de code couvrant certaines des tâches Form Recognizer les plus courantes, notamment :

Extraire la disposition

Extrayez du texte, des structures de tableau et des marques de sélection comme des cases d’option et des zones de case activée, ainsi que leurs coordonnées de zone englobante à partir de documents sans avoir besoin de créer un modèle.

// analyze document layout using file input stream
File layoutDocument = new File("local/file_path/filename.png");
Path filePath = layoutDocument.toPath();
BinaryData layoutDocumentData = BinaryData.fromFile(filePath, (int) layoutDocument.length());

SyncPoller<OperationResult, AnalyzeResult> analyzeLayoutResultPoller =
    documentAnalysisClient.beginAnalyzeDocument("prebuilt-layout", layoutDocumentData);

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 box %s.%n",
            documentLine.getContent(),
            documentLine.getBoundingPolygon().toString()));

    // selection marks
    documentPage.getSelectionMarks().forEach(documentSelectionMark ->
        System.out.printf("Selection mark is '%s' and is within a bounding box %s with confidence %.2f.%n",
            documentSelectionMark.getSelectionMarkState().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();
}

Utiliser un modèle de document général

Analysez les paires clé-valeur, les tables, les styles et les marques de sélection à partir de documents à l’aide du modèle de document général fourni par le service Form Recognizer. Sélectionnez le modèle de document général en passant modelId="prebuilt-document » dans la méthode beginAnalyzeDocumentFromUrl comme suit :

String documentUrl = "{document-url}";
String modelId = "prebuilt-document";
SyncPoller<OperationResult, AnalyzeResult> analyzeDocumentPoller =
    documentAnalysisClient.beginAnalyzeDocumentFromUrl(modelId, documentUrl);

AnalyzeResult analyzeResult = analyzeDocumentPoller.getFinalResult();

for (int i = 0; i < analyzeResult.getDocuments().size(); i++) {
    final AnalyzedDocument analyzedDocument = analyzeResult.getDocuments().get(i);
    System.out.printf("----------- Analyzing document %d -----------%n", i);
    System.out.printf("Analyzed document has doc type %s with confidence : %.2f%n",
        analyzedDocument.getDocType(), analyzedDocument.getConfidence());
}

analyzeResult.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 box %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()));
});

// tables
List<DocumentTable> tables = analyzeResult.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();
}

// Key-value
analyzeResult.getKeyValuePairs().forEach(documentKeyValuePair -> {
    System.out.printf("Key content: %s%n", documentKeyValuePair.getKey().getContent());
    System.out.printf("Key content bounding region: %s%n",
        documentKeyValuePair.getKey().getBoundingRegions().toString());

    System.out.printf("Value content: %s%n", documentKeyValuePair.getValue().getContent());
    System.out.printf("Value content bounding region: %s%n", documentKeyValuePair.getValue().getBoundingRegions().toString());
});

Utiliser des modèles prédéfinis

Extrayez des champs de certains types de documents tels que des reçus, des factures, des cartes de visite et des documents d’identité à l’aide de modèles prédéfinis fournis par le service Form Recognizer. Les modèles prédéfinis pris en charge sont les suivants :

  • Analyser les reçus à l’aide du prebuilt-receipt modèle (les champs reconnus par le service sont disponibles ici)
  • Analysez les cartes de visite à l’aide du prebuilt-businessCard modèle (les champs reconnus par le service sont disponibles ici).
  • Analysez les factures à l’aide du prebuilt-invoice modèle (les champs reconnus par le service sont disponibles ici).
  • Analysez les documents d’identité à l’aide du prebuilt-idDocuments modèle (les champs reconnus par le service sont disponibles ici).
  • Analysez les formulaires fiscaux US W2 à l’aide du prebuilt-tax.us.w2 modèle . Champs pris en charge.

Par exemple, pour analyser les champs d’un reçu de vente, dans la beginAnalyzeDocumentFromUrl méthode :

String receiptUrl = "https://raw.githubusercontent.com/Azure/azure-sdk-for-java/main/sdk/formrecognizer"
    + "/azure-ai-formrecognizer/src/samples/resources/sample-documents/receipts/contoso-allinone.jpg";

SyncPoller<OperationResult, AnalyzeResult> analyzeReceiptPoller =
    documentAnalysisClient.beginAnalyzeDocumentFromUrl("prebuilt-receipt", receiptUrl);

AnalyzeResult receiptResults = analyzeReceiptPoller.getFinalResult();

for (int i = 0; i < receiptResults.getDocuments().size(); i++) {
    AnalyzedDocument analyzedReceipt = receiptResults.getDocuments().get(i);
    Map<String, DocumentField> receiptFields = analyzedReceipt.getFields();
    System.out.printf("----------- Analyzing receipt info %d -----------%n", i);
    DocumentField merchantNameField = receiptFields.get("MerchantName");
    if (merchantNameField != null) {
        if (DocumentFieldType.STRING == merchantNameField.getType()) {
            String merchantName = merchantNameField.getValueAsString();
            System.out.printf("Merchant Name: %s, confidence: %.2f%n",
                merchantName, merchantNameField.getConfidence());
        }
    }

    DocumentField merchantPhoneNumberField = receiptFields.get("MerchantPhoneNumber");
    if (merchantPhoneNumberField != null) {
        if (DocumentFieldType.PHONE_NUMBER == merchantPhoneNumberField.getType()) {
            String merchantAddress = merchantPhoneNumberField.getValueAsPhoneNumber();
            System.out.printf("Merchant Phone number: %s, confidence: %.2f%n",
                merchantAddress, merchantPhoneNumberField.getConfidence());
        }
    }

    DocumentField transactionDateField = receiptFields.get("TransactionDate");
    if (transactionDateField != null) {
        if (DocumentFieldType.DATE == transactionDateField.getType()) {
            LocalDate transactionDate = transactionDateField.getValueAsDate();
            System.out.printf("Transaction Date: %s, confidence: %.2f%n",
                transactionDate, transactionDateField.getConfidence());
        }
    }

    DocumentField receiptItemsField = receiptFields.get("Items");
    if (receiptItemsField != null) {
        System.out.printf("Receipt Items: %n");
        if (DocumentFieldType.LIST == receiptItemsField.getType()) {
            List<DocumentField> receiptItems = receiptItemsField.getValueAsList();
            receiptItems.stream()
                .filter(receiptItem -> DocumentFieldType.MAP == receiptItem.getType())
                .map(documentField -> documentField.getValueAsMap())
                .forEach(documentFieldMap -> documentFieldMap.forEach((key, documentField) -> {
                    if ("Name".equals(key)) {
                        if (DocumentFieldType.STRING == documentField.getType()) {
                            String name = documentField.getValueAsString();
                            System.out.printf("Name: %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());
                        }
                    }
                }));
        }
    }
}

Pour plus d’informations et des exemples utilisant des modèles prédéfinis, consultez :

Créer un modèle de document

Créez un modèle appris par machine sur votre propre type de document. Le modèle résultant sera en mesure d’analyser les valeurs des types de documents sur 2000. Fournissez une URL SAP de conteneur à votre conteneur d’objets blob Stockage Azure dans lequel vous stockez les documents d’entraînement. Pour plus d’informations sur la configuration, consultez la documentation de démarrage rapide du service.

Remarque

Vous pouvez utiliser la préversion Form Recognizer Studio pour créer un fichier étiqueté pour vos formulaires de formation. Pour plus d’informations sur la configuration d’un conteneur et la structure de fichiers requise, consultez ici.

// Build custom document analysis model
String blobContainerUrl = "{SAS_URL_of_your_container_in_blob_storage}";
// The shared access signature (SAS) Url of your Azure Blob Storage container with your forms.
String prefix = "{blob_name_prefix}}";
SyncPoller<OperationResult, DocumentModelDetails> buildOperationPoller =
    documentModelAdminClient.beginBuildDocumentModel(blobContainerUrl,
        DocumentModelBuildMode.TEMPLATE,
        prefix,
        new BuildDocumentModelOptions().setModelId("my-build-model").setDescription("model desc"),
        Context.NONE);

DocumentModelDetails documentModelDetails = buildOperationPoller.getFinalResult();

// Model Info
System.out.printf("Model ID: %s%n", documentModelDetails.getModelId());
System.out.printf("Model Description: %s%n", documentModelDetails.getDescription());
System.out.printf("Model created on: %s%n%n", documentModelDetails.getCreatedOn());
documentModelDetails.getDocumentTypes().forEach((key, documentTypeDetails) -> {
    System.out.printf("Document type: %s%n", key);
    documentTypeDetails.getFieldSchema().forEach((name, documentFieldSchema) -> {
        System.out.printf("Document field: %s%n", name);
        System.out.printf("Document field type: %s%n", documentFieldSchema.getType().toString());
        System.out.printf("Document field confidence: %.2f%n", documentTypeDetails.getFieldConfidence().get(name));
    });
});

Analyser des documents à l’aide d’un modèle personnalisé

Analysez les paires clé/valeur et les données de table des documents. Ces modèles sont créés avec vos propres données, de sorte qu’ils sont adaptés à vos documents. Vous devez analyser uniquement les documents du même type de document sur lequel le modèle personnalisé a été construit.

String documentUrl = "{document-url}";
String modelId = "{custom-built-model-ID}";
SyncPoller<OperationResult, AnalyzeResult> analyzeDocumentPoller =
    documentAnalysisClient.beginAnalyzeDocumentFromUrl(modelId, documentUrl);

AnalyzeResult analyzeResult = analyzeDocumentPoller.getFinalResult();

for (int i = 0; i < analyzeResult.getDocuments().size(); i++) {
    final AnalyzedDocument analyzedDocument = analyzeResult.getDocuments().get(i);
    System.out.printf("----------- Analyzing custom document %d -----------%n", i);
    System.out.printf("Analyzed document has doc type %s with confidence : %.2f%n",
        analyzedDocument.getDocType(), analyzedDocument.getConfidence());
    analyzedDocument.getFields().forEach((key, documentField) -> {
        System.out.printf("Document Field content: %s%n", documentField.getContent());
        System.out.printf("Document Field confidence: %.2f%n", documentField.getConfidence());
        System.out.printf("Document Field Type: %s%n", documentField.getType());
        System.out.printf("Document Field found within bounding region: %s%n",
            documentField.getBoundingRegions().toString());
    });
}

analyzeResult.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 box %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()));
});

// tables
List<DocumentTable> tables = analyzeResult.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();
}

Gérer vos modèles

Gérez les modèles dans votre compte Form Recognizer.

AtomicReference<String> modelId = new AtomicReference<>();

// First, we see how many models we have, and what our limit is
ResourceDetails resourceDetails = documentModelAdminClient.getResourceDetails();
System.out.printf("The resource has %s models, and we can have at most %s models",
    resourceDetails.getCustomDocumentModelCount(), resourceDetails.getCustomDocumentModelLimit());

// Next, we get a paged list of all of our models
PagedIterable<DocumentModelSummary> customDocumentModels = documentModelAdminClient.listDocumentModels();
System.out.println("We have following models in the account:");
customDocumentModels.forEach(documentModelSummary -> {
    System.out.printf("Model ID: %s%n", documentModelSummary.getModelId());
    modelId.set(documentModelSummary.getModelId());

    // get custom document analysis model info
    DocumentModelDetails documentModel = documentModelAdminClient.getDocumentModel(documentModelSummary.getModelId());
    System.out.printf("Model ID: %s%n", documentModel.getModelId());
    System.out.printf("Model Description: %s%n", documentModel.getDescription());
    System.out.printf("Model created on: %s%n", documentModel.getCreatedOn());
    documentModel.getDocumentTypes().forEach((key, documentTypeDetails) -> {
        documentTypeDetails.getFieldSchema().forEach((field, documentFieldSchema) -> {
            System.out.printf("Field: %s", field);
            System.out.printf("Field type: %s", documentFieldSchema.getType());
            System.out.printf("Field confidence: %.2f", documentTypeDetails.getFieldConfidence().get(field));
        });
    });
});

// Delete Model
documentModelAdminClient.deleteDocumentModel(modelId.get());

Classifier un document

Le service Form Recognizer prend en charge les classifieurs de documents personnalisés qui peuvent classer les documents dans un ensemble de catégories prédéfinies en fonction d’un jeu de données d’entraînement. Les documents peuvent être classés avec un classifieur personnalisé à l’aide de la beginClassifyDocument méthode ou beginClassifyDocumentFromUrl de DocumentAnalysisClient. L’exemple suivant montre comment classifier un document à l’aide d’un classifieur personnalisé :

String documentUrl = "{file_source_url}";
String classifierId = "{custom_trained_classifier_id}";

documentAnalysisClient.beginClassifyDocumentFromUrl(classifierId, documentUrl, Context.NONE)
    .getFinalResult()
    .getDocuments()
    .forEach(analyzedDocument -> System.out.printf("Doc Type: %s%n", analyzedDocument.getDocType()));

Pour obtenir des exemples plus détaillés, reportez-vous aux exemples.

Dépannage

Général

Form Recognizer clients soulèvent des HttpResponseExceptionexceptions. Par exemple, si vous essayez de fournir une URL de source de fichier non valide, une exception HttpResponseException est levée avec une erreur indiquant la cause de l’échec. Dans l’extrait de code suivant, l’erreur est gérée correctement via l’interception de l’exception et en affichant des informations supplémentaires sur l’erreur en question.

try {
    documentAnalysisClient.beginAnalyzeDocumentFromUrl("prebuilt-receipt", "invalidSourceUrl");
} catch (HttpResponseException e) {
    System.out.println(e.getMessage());
    // Do something with the exception
}

Activer la journalisation du client

Les sdk Azure pour Java offrent une histoire de journalisation cohérente pour vous aider à résoudre les erreurs d’application et à accélérer leur résolution. Les journaux produits capturent le flux d’une application avant d’atteindre l’état terminal pour faciliter la localisation du problème racine. Consultez le wiki de journalisation pour obtenir des conseils sur l’activation de la journalisation.

Client HTTP par défaut

Toutes les bibliothèques de client utilisent par défaut le client HTTP Netty. Ajoutez la dépendance ci-dessus pour configurer automatiquement la bibliothèque cliente pour utiliser le client HTTP Netty. La configuration ou la modification du client HTTP sont détaillées dans le wiki pour clients HTTP.

Étapes suivantes

La section suivante fournit plusieurs extraits de code illustrant les modèles courants utilisés dans l’API Form Recognizer. Ces exemples de code illustrent les opérations de scénario courantes avec la bibliothèque cliente Azure Form Recognizer.

API asynchrones

Tous les exemples présentés jusqu’à présent utilisent des API synchrones, mais nous fournissons également une prise en charge complète des API asynchrones. Vous devrez utiliser DocumentAnalysisAsyncClient

DocumentAnalysisAsyncClient documentAnalysisAsyncClient = new DocumentAnalysisClientBuilder()
    .credential(new AzureKeyCredential("{key}"))
    .endpoint("{endpoint}")
    .buildAsyncClient();

Documentation complémentaire

Consultez l’exemple README pour obtenir plusieurs extraits de code illustrant les modèles courants utilisés dans le kit de développement logiciel (SDK) Java Form Recognizer. Pour obtenir une documentation plus complète sur les Form Recognizer Azure Cognitive Services, consultez la documentation Form Recognizer.

Contribution

Ce projet accepte les contributions et les suggestions. La plupart des contributions vous demandent d’accepter un contrat de licence de contribution (CLA) spécifiant que vous avez le droit de nous accorder les droits d’utiliser votre contribution, et que vous nous les accordez.

Quand vous envoyez une demande de tirage (pull request), un bot CLA détermine automatiquement si vous devez fournir un contrat CLA et agrémenter la demande de tirage de façon appropriée (par exemple, avec une étiquette ou un commentaire). Suivez simplement les instructions fournies par le bot. Vous ne devez effectuer cette opération qu’une seule fois sur tous les dépôts utilisant notre contrat CLA.

Ce projet a adopté le Code de conduite Open Source de Microsoft. Pour plus d'informations, consultez la FAQ du Code de conduite ou contactez opencode@microsoft.com pour toute question ou commentaire supplémentaire.

Impressions