Bibliothèque de client Azure Form Recognizer pour .NET - version 4.1.0

  • Article

Remarque : en juillet 2023, le service de Form Recognizer Azure Cognitive Services a été renommé Azure AI Document Intelligence. Toutes les mentions à Form Recognizer ou Document Intelligence dans la documentation font référence au même service Azure.

Azure AI Document Intelligence 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 marques de sélection, des structures de tableau, des styles et des paragraphes, ainsi que leurs coordonnées de région englobante à partir de documents.
  • Document général : analysez les paires clé-valeur en plus de la mise en page générale des 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.
  • Prédéfini : analysez les données de certains types de documents courants à l’aide de modèles prédéfinis. Les documents pris en charge incluent les reçus, les factures, les cartes de visite, les documents d’identité, les formulaires fiscaux W2 américains, etc.
  • Analyse personnalisée : créez des modèles de documents personnalisés pour analyser du texte, des valeurs de champ, des marques de sélection, des structures de tableau, des styles et des paragraphes à 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.
  • Classification personnalisée : créez des modèles classifieur personnalisés qui combinent des fonctionnalités de disposition et de langage pour détecter et identifier avec précision les documents que vous traitez dans votre application.

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

Prise en main

Installer le package

Installez la bibliothèque de client Azure Form Recognizer pour .NET avec NuGet :

dotnet add package Azure.AI.FormRecognizer

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
4.1.0 2.0, 2.1, 2022-08-31, 2023-07-31
4.0.0 2.0, 2.1, 2022-08-31
3.1.X 2.0, 2.1
3.0.X 2.0

Remarque : À compter de la version 4.0.0, un nouvel ensemble de clients a été introduit pour tirer parti des fonctionnalités les plus récentes du service Document Intelligence. Consultez le Guide de migration pour obtenir des instructions détaillées sur la façon de mettre à jour le code de l’application à partir de la version de la bibliothèque cliente ou d’une version 3.1.X antérieure vers la version la plus récente. Pour plus d’informations, consultez le 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

Prérequis

Créer une ressource Cognitive Services ou Form Recognizer

Document Intelligence prend en charge l’accès multiservices et l’accès à service unique. Créez une ressource Cognitive Services si vous envisagez d’accéder à plusieurs services Cognitive Services sous un seul point de terminaison/clé. Pour l’accès à Document Intelligence uniquement, créez une ressource Form Recognizer. Notez que vous aurez besoin d’une ressource à service unique si vous envisagez d’utiliser l’authentification Azure Active Directory.

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

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-name> --location <location>

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

Pour plus d’informations sur la création de la ressource ou sur la façon d’obtenir l’emplacement et les informations de référence SKU , consultez ici.

Authentifier le client

Pour interagir avec le service Document Intelligence, vous devez créer un instance de la DocumentAnalysisClient classe . Un point de terminaison et des informations d’identification sont nécessaires pour instancier l’objet client.

Obtenir le point de terminaison

Vous pouvez trouver le point de terminaison de votre ressource Form Recognizer à l’aide du portail Azure ou d’Azure CLI :

# Get the endpoint for the Form Recognizer resource
az cognitiveservices account show --name "<resource-name>" --resource-group "<resource-group-name>" --query "properties.endpoint"

Un point de terminaison régional ou un sous-domaine personnalisé peut être utilisé pour l’authentification. Ils sont mis en forme comme suit :

Regional endpoint: https://<region>.api.cognitive.microsoft.com/
Custom subdomain: https://<resource-name>.cognitiveservices.azure.com/

Un point de terminaison régional est le même pour chaque ressource d’une région. Vous pouvez consulter la liste complète des points de terminaison régionaux pris en charge ici. Notez que les points de terminaison régionaux ne prennent pas en charge l’authentification AAD.

En revanche, un sous-domaine personnalisé est un nom propre à la ressource Form Recognizer. Elles ne peuvent être utilisées que par des ressources à service unique.

Obtenir la clé API

La clé API se trouve dans le portail Azure ou en exécutant la commande Azure CLI suivante :

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

Créer DocumentAnalysisClient avec AzureKeyCredential

Une fois que vous avez la valeur de la clé API, créez un AzureKeyCredential. Avec le point de terminaison et les informations d’identification de clé, vous pouvez créer le DocumentAnalysisClient:

string endpoint = "<endpoint>";
string apiKey = "<apiKey>";
var credential = new AzureKeyCredential(apiKey);
var client = new DocumentAnalysisClient(new Uri(endpoint), credential);

Créer DocumentAnalysisClient avec les informations d’identification Azure Active Directory

AzureKeyCredential L’authentification est utilisée dans les exemples de ce guide de prise en main, mais vous pouvez également vous authentifier auprès d’Azure Active Directory à l’aide de la bibliothèque Azure Identity. Notez que les points de terminaison régionaux ne prennent pas en charge l’authentification AAD. Créez un sous-domaine personnalisé pour votre ressource afin d’utiliser ce type d’authentification.

Pour utiliser le fournisseur DefaultAzureCredential indiqué ci-dessous ou d’autres fournisseurs d’informations d’identification fournis avec le kit de développement logiciel (SDK) Azure, installez le package Azure.Identity :

dotnet add package Azure.Identity

Vous devez également inscrire une nouvelle application AAD et accorder l’accès à Document Intelligence en attribuant le "Cognitive Services User" rôle à votre principal de service.

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.

string endpoint = "<endpoint>";
var client = new DocumentAnalysisClient(new Uri(endpoint), new DefaultAzureCredential());

Concepts clés

DocumentAnalysisClient

DocumentAnalysisClient propose des opérations pour :

  • Analyse des documents d’entrée à l’aide de modèles prédéfinis et personnalisés via les AnalyzeDocument API et AnalyzeDocumentFromUri .
  • Détection et identification des documents d’entrée personnalisés avec les ClassifyDocument API et ClassifyDocumentFromUri .

Des exemples d’extraits de code sont fournis pour illustrer l’utilisation 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 dans la documentation du service.

DocumentModelAdministrationClient

DocumentModelAdministrationClient propose des opérations pour :

  • Création de modèles personnalisés pour analyser des champs spécifiques que vous spécifiez en étiquetant vos documents personnalisés. Une DocumentModelDetails instance est retournée indiquant le ou les types de document que le modèle peut analyser, les champs qu’il peut analyser pour chaque type de document, ainsi que la confiance estimée pour chaque champ. Consultez la documentation du service pour obtenir une explication plus détaillée.
  • Composez un modèle à partir d’une collection de modèles existants.
  • Gérer les modèles créés dans votre compte.
  • Copier un modèle personnalisé d’une ressource Form Recognizer vers une autre.
  • Répertorier les opérations de génération ou obtenir des opérations spécifiques créées au cours des dernières 24 heures.
  • Création et gestion de modèles de classification de documents pour détecter et identifier avec précision les documents que vous traitez dans votre application.

Consultez des exemples pour Générer un modèle personnalisé, Gérer des modèles et Générer un classifieur de documents.

Notez que les modèles et les classifieurs peuvent également être générés à l’aide d’une interface utilisateur graphique telle que Document Intelligence Studio.

opérations Long-Running

Étant donné que l’analyse des documents et la création de modèles prennent du temps, ces opérations sont implémentées comme des opérations de longue durée. Les opérations de longue durée se composent d’une demande initiale envoyée au service pour démarrer une opération, suivie d’une 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.

Pour les opérations de longue durée dans le Kit de développement logiciel (SDK) Azure, le client expose une méthode qui retourne un Operation<T> objet. Vous pouvez définir son paramètre waitUntilWaitUntil.Completed sur pour attendre la fin de l’opération et obtenir son résultat ; ou lui affecter la valeur WaitUntil.Started si vous souhaitez simplement démarrer l’opération et utiliser le résultat ultérieurement. Un exemple d’extrait de code est fourni pour illustrer l’utilisation d’opérations de longue durée ci-dessous.

Sécurité des threads

Nous garantissons que toutes les méthodes de instance client sont thread-safe et indépendantes les unes des autres (instructions). Cela garantit que la recommandation de réutilisation des instances clientes est toujours sécurisée, même entre les threads.

Concepts supplémentaires

Options | du clientAccès à la réponse | Gestion des défaillances | Diagnostics | Moqueur | Durée de vie du client

Exemples

La section suivante fournit plusieurs extraits de code illustrant les modèles courants utilisés dans l’API .NET Form Recognizer. La plupart des extraits de code ci-dessous utilisent des appels de service asynchrones, mais gardez à l’esprit que le package Azure.AI.FormRecognizer prend en charge les API synchrones et asynchrones.

Exemples asynchrones

Exemples de synchronisation

Notez que ces exemples utilisent la version 4.1.0du SDK . Pour la version 3.1.1 ou ultérieure, consultez Form Recognizer Samples for V3.1.X.

Extraire la disposition

Extrayez du texte, des marques de sélection, des structures de tableau, des styles et des paragraphes, ainsi que leurs coordonnées de région englobante à partir de documents.

Uri fileUri = new Uri("<fileUri>");

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 polygon (points ordered clockwise):");

        for (int j = 0; j < line.BoundingPolygon.Count; j++)
        {
            Console.WriteLine($"      Point {j} => X: {line.BoundingPolygon[j].X}, Y: {line.BoundingPolygon[j].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 polygon (points ordered clockwise):");

        for (int j = 0; j < selectionMark.BoundingPolygon.Count; j++)
        {
            Console.WriteLine($"      Point {j} => X: {selectionMark.BoundingPolygon[j].X}, Y: {selectionMark.BoundingPolygon[j].Y}");
        }
    }
}

Console.WriteLine("Paragraphs:");

foreach (DocumentParagraph paragraph in result.Paragraphs)
{
    Console.WriteLine($"  Paragraph content: {paragraph.Content}");

    if (paragraph.Role != null)
    {
        Console.WriteLine($"    Role: {paragraph.Role}");
    }
}

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}'.");
    }
}

Pour plus d’informations et des exemples, voir ici.

Utiliser le modèle de document général prédéfini

Analysez le texte, les marques de sélection, les structures de tableau, les styles, les paragraphes et les paires clé-valeur à partir de documents à l’aide du modèle de document général prédéfini.

Uri fileUri = new Uri("<fileUri>");

AnalyzeDocumentOperation operation = await client.AnalyzeDocumentFromUriAsync(WaitUntil.Completed, "prebuilt-document", fileUri);
AnalyzeResult result = operation.Value;

Console.WriteLine("Detected key-value pairs:");

foreach (DocumentKeyValuePair kvp in result.KeyValuePairs)
{
    if (kvp.Value == null)
    {
        Console.WriteLine($"  Found key with no value: '{kvp.Key.Content}'");
    }
    else
    {
        Console.WriteLine($"  Found key-value pair: '{kvp.Key.Content}' and '{kvp.Value.Content}'");
    }
}

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 polygon (points ordered clockwise):");

        for (int j = 0; j < line.BoundingPolygon.Count; j++)
        {
            Console.WriteLine($"      Point {j} => X: {line.BoundingPolygon[j].X}, Y: {line.BoundingPolygon[j].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 polygon (points ordered clockwise):");

        for (int j = 0; j < selectionMark.BoundingPolygon.Count; j++)
        {
            Console.WriteLine($"      Point {j} => X: {selectionMark.BoundingPolygon[j].X}, Y: {selectionMark.BoundingPolygon[j].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}'.");
    }
}

Pour plus d’informations et des exemples, voir ici.

Utiliser le modèle de lecture prédéfini

Analysez les éléments textuels, tels que les mots et les lignes de page, les styles, les paragraphes et les informations de langue de texte à partir de documents à l’aide du modèle de lecture prédéfini.

Uri fileUri = new Uri("<fileUri>");

AnalyzeDocumentOperation operation = await client.AnalyzeDocumentFromUriAsync(WaitUntil.Completed, "prebuilt-read", fileUri);
AnalyzeResult result = operation.Value;

Console.WriteLine("Detected languages:");

foreach (DocumentLanguage language in result.Languages)
{
    Console.WriteLine($"  Found language with locale '{language.Locale}' and confidence {language.Confidence}.");
}

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 polygon (points ordered clockwise):");

        for (int j = 0; j < line.BoundingPolygon.Count; j++)
        {
            Console.WriteLine($"      Point {j} => X: {line.BoundingPolygon[j].X}, Y: {line.BoundingPolygon[j].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)}");
        }
    }
}

Pour plus d’informations et des exemples, voir ici.

Utiliser des modèles prédéfinis

Analysez les données de certains types de documents courants à l’aide de modèles prédéfinis fournis par le service Document Intelligence.

Par exemple, pour analyser les champs d’une facture, utilisez le modèle de facture prédéfini fourni en passant l’ID de prebuilt-invoice modèle dans la AnalyzeDocumentAsync méthode :

string filePath = "<filePath>";

using var stream = new FileStream(filePath, FileMode.Open);

AnalyzeDocumentOperation operation = await client.AnalyzeDocumentAsync(WaitUntil.Completed, "prebuilt-invoice", stream);
AnalyzeResult result = operation.Value;

// To see the list of all the supported fields returned by service and its corresponding types for the
// prebuilt-invoice model, consult:
// https://aka.ms/azsdk/formrecognizer/invoicefieldschema

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}");
        }
    }
}

Vous n’êtes pas limité aux factures ! Vous avez le choix entre deux modèles prédéfinis, chacun ayant son propre ensemble de champs pris en charge. Vous trouverez plus d’informations sur les types de documents pris en charge dans la documentation du service.

Pour plus d’informations et des exemples, consultez ici.

Créer un modèle personnalisé

Créez un modèle personnalisé sur votre propre type de document. Le modèle résultant peut être utilisé pour analyser des valeurs à partir des types de documents sur 2000.

// For this sample, you can use the training documents found in the `trainingFiles` folder.
// Upload the documents to your storage container and then generate a container SAS URL. Note
// that a container URI without SAS is accepted only when the container is public or has a
// managed identity configured.
//
// For instructions to set up documents for training in an Azure Blob Storage Container, please see:
// https://aka.ms/azsdk/formrecognizer/buildcustommodel

Uri blobContainerUri = new Uri("<blobContainerUri>");
var client = new DocumentModelAdministrationClient(new Uri(endpoint), new AzureKeyCredential(apiKey));

// We are selecting the Template build mode in this sample. For more information about the available
// build modes and their differences, please see:
// https://aka.ms/azsdk/formrecognizer/buildmode

BuildDocumentModelOperation operation = await client.BuildDocumentModelAsync(WaitUntil.Completed, blobContainerUri, DocumentBuildMode.Template);
DocumentModelDetails model = operation.Value;

Console.WriteLine($"  Model Id: {model.ModelId}");
Console.WriteLine($"  Created on: {model.CreatedOn}");

Console.WriteLine("  Document types the model can recognize:");
foreach (KeyValuePair<string, DocumentTypeDetails> documentType in model.DocumentTypes)
{
    Console.WriteLine($"    Document type: {documentType.Key} which has the following fields:");
    foreach (KeyValuePair<string, DocumentFieldSchema> schema in documentType.Value.FieldSchema)
    {
        Console.WriteLine($"    Field: {schema.Key} with confidence {documentType.Value.FieldConfidence[schema.Key]}");
    }
}

Pour plus d’informations et des exemples, voir ici.

Analyser des documents personnalisés

Analysez du texte, des valeurs de champ, des marques de sélection et des structures de tableau, des styles et des paragraphes à partir de documents personnalisés, à l’aide de modèles que vous avez créés avec vos propres types de documents.

string modelId = "<modelId>";
Uri fileUri = new Uri("<fileUri>");

AnalyzeDocumentOperation operation = await client.AnalyzeDocumentFromUriAsync(WaitUntil.Completed, modelId, fileUri);
AnalyzeResult result = operation.Value;

Console.WriteLine($"Document was analyzed with model with ID: {result.ModelId}");

foreach (AnalyzedDocument document in result.Documents)
{
    Console.WriteLine($"Document of type: {document.DocumentType}");

    foreach (KeyValuePair<string, DocumentField> fieldKvp in document.Fields)
    {
        string fieldName = fieldKvp.Key;
        DocumentField field = fieldKvp.Value;

        Console.WriteLine($"Field '{fieldName}': ");

        Console.WriteLine($"  Content: '{field.Content}'");
        Console.WriteLine($"  Confidence: '{field.Confidence}'");
    }
}

Pour plus d’informations et des exemples, voir ici.

Gérer les modèles

Gérez les modèles stockés dans votre compte.

var client = new DocumentModelAdministrationClient(new Uri(endpoint), new AzureKeyCredential(apiKey));

// Check number of custom models in the Form Recognizer resource, and the maximum number of custom models that can be stored.
ResourceDetails resourceDetails = await client.GetResourceDetailsAsync();
Console.WriteLine($"Resource has {resourceDetails.CustomDocumentModelCount} custom models.");
Console.WriteLine($"It can have at most {resourceDetails.CustomDocumentModelLimit} custom models.");

// List the first ten or fewer models currently stored in the resource.
AsyncPageable<DocumentModelSummary> models = client.GetDocumentModelsAsync();

int count = 0;
await foreach (DocumentModelSummary modelSummary in models)
{
    Console.WriteLine($"Custom Model Summary:");
    Console.WriteLine($"  Model Id: {modelSummary.ModelId}");
    if (string.IsNullOrEmpty(modelSummary.Description))
        Console.WriteLine($"  Model description: {modelSummary.Description}");
    Console.WriteLine($"  Created on: {modelSummary.CreatedOn}");
    if (++count == 10)
        break;
}

// Create a new model to store in the resource.
Uri blobContainerUri = new Uri("<blobContainerUri>");
BuildDocumentModelOperation operation = await client.BuildDocumentModelAsync(WaitUntil.Completed, blobContainerUri, DocumentBuildMode.Template);
DocumentModelDetails model = operation.Value;

// Get the model that was just created.
DocumentModelDetails newCreatedModel = await client.GetDocumentModelAsync(model.ModelId);

Console.WriteLine($"Custom Model with Id {newCreatedModel.ModelId} has the following information:");

Console.WriteLine($"  Model Id: {newCreatedModel.ModelId}");
if (string.IsNullOrEmpty(newCreatedModel.Description))
    Console.WriteLine($"  Model description: {newCreatedModel.Description}");
Console.WriteLine($"  Created on: {newCreatedModel.CreatedOn}");

// Delete the model from the resource.
await client.DeleteDocumentModelAsync(newCreatedModel.ModelId);

Pour plus d’informations et des exemples, voir ici.

Gérer les modèles de manière synchrone

Gérez les modèles stockés dans votre compte avec une API synchrone.

var client = new DocumentModelAdministrationClient(new Uri(endpoint), new AzureKeyCredential(apiKey));

// Check number of custom models in the Form Recognizer resource, and the maximum number of custom models that can be stored.
ResourceDetails resourceDetails = client.GetResourceDetails();
Console.WriteLine($"Resource has {resourceDetails.CustomDocumentModelCount} custom models.");
Console.WriteLine($"It can have at most {resourceDetails.CustomDocumentModelLimit} custom models.");

// List the first ten or fewer models currently stored in the resource.
Pageable<DocumentModelSummary> models = client.GetDocumentModels();

foreach (DocumentModelSummary modelSummary in models.Take(10))
{
    Console.WriteLine($"Custom Model Summary:");
    Console.WriteLine($"  Model Id: {modelSummary.ModelId}");
    if (string.IsNullOrEmpty(modelSummary.Description))
        Console.WriteLine($"  Model description: {modelSummary.Description}");
    Console.WriteLine($"  Created on: {modelSummary.CreatedOn}");
}

// Create a new model to store in the resource.

Uri blobContainerUri = new Uri("<blobContainerUri>");
BuildDocumentModelOperation operation = client.BuildDocumentModel(WaitUntil.Completed, blobContainerUri, DocumentBuildMode.Template);
DocumentModelDetails model = operation.Value;

// Get the model that was just created.
DocumentModelDetails newCreatedModel = client.GetDocumentModel(model.ModelId);

Console.WriteLine($"Custom Model with Id {newCreatedModel.ModelId} has the following information:");

Console.WriteLine($"  Model Id: {newCreatedModel.ModelId}");
if (string.IsNullOrEmpty(newCreatedModel.Description))
    Console.WriteLine($"  Model description: {newCreatedModel.Description}");
Console.WriteLine($"  Created on: {newCreatedModel.CreatedOn}");

// Delete the created model from the resource.
client.DeleteDocumentModel(newCreatedModel.ModelId);

Générer un classifieur de documents

Créez un classifieur de documents en chargeant des documents d’entraînement personnalisés.

// For this sample, you can use the training documents found in the `classifierTrainingFiles` folder.
// Upload the documents to your storage container and then generate a container SAS URL. Note
// that a container URI without SAS is accepted only when the container is public or has a
// managed identity configured.
//
// For instructions to set up documents for training in an Azure Blob Storage Container, please see:
// https://aka.ms/azsdk/formrecognizer/buildclassifiermodel

Uri trainingFilesUri = new Uri("<trainingFilesUri>");
var client = new DocumentModelAdministrationClient(new Uri(endpoint), new AzureKeyCredential(apiKey));

var sourceA = new BlobContentSource(trainingFilesUri) { Prefix = "IRS-1040-A/train" };
var sourceB = new BlobContentSource(trainingFilesUri) { Prefix = "IRS-1040-B/train" };

var documentTypes = new Dictionary<string, ClassifierDocumentTypeDetails>()
{
    { "IRS-1040-A", new ClassifierDocumentTypeDetails(sourceA) },
    { "IRS-1040-B", new ClassifierDocumentTypeDetails(sourceB) }
};

BuildDocumentClassifierOperation operation = await client.BuildDocumentClassifierAsync(WaitUntil.Completed, documentTypes);
DocumentClassifierDetails classifier = operation.Value;

Console.WriteLine($"  Classifier Id: {classifier.ClassifierId}");
Console.WriteLine($"  Created on: {classifier.CreatedOn}");

Console.WriteLine("  Document types the classifier can recognize:");
foreach (KeyValuePair<string, ClassifierDocumentTypeDetails> documentType in classifier.DocumentTypes)
{
    Console.WriteLine($"    {documentType.Key}");
}

Pour plus d’informations et des exemples, voir ici.

Classifier un document

Utilisez des classifieurs de documents pour détecter et identifier avec précision les documents que vous traitez dans votre application.

string classifierId = "<classifierId>";
Uri fileUri = new Uri("<fileUri>");

ClassifyDocumentOperation operation = await client.ClassifyDocumentFromUriAsync(WaitUntil.Completed, classifierId, fileUri);
AnalyzeResult result = operation.Value;

Console.WriteLine($"Document was classified by classifier with ID: {result.ModelId}");

foreach (AnalyzedDocument document in result.Documents)
{
    Console.WriteLine($"Document of type: {document.DocumentType}");
}

Pour plus d’informations et des exemples, voir ici.

Dépannage

Général

Lorsque vous interagissez avec la bibliothèque cliente Form Recognizer à l’aide du Kit de développement logiciel (SDK) .NET, les erreurs retournées par le service entraînent un RequestFailedException avec le même code de status HTTP retourné par la demande d’API REST.

Par exemple, si vous envoyez une image de reçu avec un non valide Uri, une 400 erreur est retournée, indiquant « Demande incorrecte ».

try
{
    AnalyzeDocumentOperation operation = await client.AnalyzeDocumentFromUriAsync(WaitUntil.Completed, "prebuilt-receipt", new Uri("http://invalid.uri"));
}
catch (RequestFailedException e)
{
    Console.WriteLine(e.ToString());
}

Vous remarquerez que des informations supplémentaires sont enregistrées, comme l’ID de demande client de l’opération.

Message:
    Azure.RequestFailedException: Service request failed.
    Status: 400 (Bad Request)
    ErrorCode: InvalidRequest

Content:
    {"error":{"code":"InvalidRequest","message":"Invalid request.","innererror":{"code":"InvalidContent","message":"The file is corrupted or format is unsupported. Refer to documentation for the list of supported formats."}}}

Headers:
    Transfer-Encoding: chunked
    x-envoy-upstream-service-time: REDACTED
    apim-request-id: REDACTED
    Strict-Transport-Security: REDACTED
    X-Content-Type-Options: REDACTED
    Date: Fri, 01 Oct 2021 02:55:44 GMT
    Content-Type: application/json; charset=utf-8

Les codes d’erreur et les messages déclenchés par le service Document Intelligence se trouvent dans la documentation du service.

Pour plus d’informations sur les problèmes courants, consultez notre guide de résolution des problèmes.

Configuration de la journalisation de la console

La façon la plus simple de voir les journaux consiste à activer la journalisation de la console. Pour créer un écouteur de journal du SDK Azure qui génère des messages dans la console, utilisez la méthode AzureEventSourceListener.CreateConsoleLogger.

// Setup a listener to monitor logged events.
using AzureEventSourceListener listener = AzureEventSourceListener.CreateConsoleLogger();

Pour en savoir plus sur les autres mécanismes de journalisation, consultez Exemples de diagnostics.

Étapes suivantes

Des exemples montrant comment utiliser la bibliothèque Form Recognizer sont disponibles dans ce dépôt GitHub. Des exemples sont fournis pour chaque domaine fonctionnel main :

Notez que ces exemples utilisent la version 4.1.0du SDK . Pour la version 3.1.1 ou ultérieure, consultez Form Recognizer Samples for V3.1.X.

Contribution

Ce projet accepte les contributions et les suggestions. La plupart des contributions vous demandent d’accepter un contrat de licence de contribution (CLA) déclarant que vous avez le droit de nous accorder, et que vous nous accordez réellement, les droits d’utilisation de votre contribution. Pour plus d’informations, visitez cla.microsoft.com.

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 les Questions fréquentes (FAQ) sur le code de conduite ou envoyez vos questions ou vos commentaires à opencode@microsoft.com.

Impressions