Bibliothèque cliente Azure Form Recognizer pour Python - version 3.3.2

  • Article

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

  • Disposition : extrayez le contenu et la structure (par exemple, mots, marques de sélection, tableaux) à partir de documents.
  • Document : analysez les paires clé-valeur en plus de la disposition générale des documents.
  • Lecture : lire les informations de page à partir de documents.
  • Prédéfini : extrayez les valeurs de champ courantes de certains types de documents (par exemple, reçus, factures, cartes de visite, documents d’identité, documents fiscaux U.S. W-2, entre autres) à l’aide de modèles prédéfinis.
  • Personnalisé : créez des modèles personnalisés à partir de vos propres données pour extraire des valeurs de champ personnalisées en plus de la disposition générale des documents.
  • Classifieurs : créez des modèles de classification 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.
  • Fonctionnalités de module complémentaire : extraire des codes-barres/CODES QR, des formules, une police/style, etc. ou activer le mode haute résolution pour les documents volumineux avec des paramètres facultatifs.

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

Prise en main

Prérequis

Installer le package

Installez la bibliothèque cliente Azure Form Recognizer pour Python avec pip :

pip install 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
3.3.X - Dernière version en disponibilité générale 2.0, 2.1, 31/08/2022, 31/07/2023 (par défaut)
3.2.X 2.0, 2.1, 31-08-2022 (par défaut)
3.1.X 2.0, 2.1 (par défaut)
3.0.0 2.0

Remarque : À compter de la version 3.2.X, 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 mise à jour du code d’application à partir de la version de la bibliothèque cliente ou d’une version 3.1.X inférieure vers la dernière version. En outre, consultez le Journal des modifications pour plus d’informations. Le tableau ci-dessous décrit la relation entre chaque client et sa ou 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 Cognitive Services ou Form Recognizer

Document Intelligence prend en charge l’accès multiservices et à 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 des ressources à 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 form recognizer
az cognitiveservices account create \
    --name <your-resource-name> \
    --resource-group <your-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 les informations d’emplacement et de référence, consultez ici.

Authentifier le client

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

Obtenir le point de terminaison

Vous trouverez 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 unique à la ressource Form Recognizer. Ils ne peuvent être utilisés 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 le client avec AzureKeyCredential

Pour utiliser une clé API comme credential paramètre, passez la clé en tant que chaîne dans un instance d’AzureKeyCredential.

from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer import DocumentAnalysisClient

endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/"
credential = AzureKeyCredential("<api_key>")
document_analysis_client = DocumentAnalysisClient(endpoint, credential)

Créer le client avec des 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 nom de sous-domaine personnalisé pour votre ressource afin d’utiliser ce type d’authentification.

Pour utiliser le type DefaultAzureCredential indiqué ci-dessous ou d’autres types d’informations d’identification fournis avec le Kit de développement logiciel (SDK) Azure, installez le azure-identity package :

pip install 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.

Une fois terminé, 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.

"""DefaultAzureCredential will use the values from these environment
variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET
"""
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.identity import DefaultAzureCredential

endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
credential = DefaultAzureCredential()

document_analysis_client = DocumentAnalysisClient(endpoint, credential)

Concepts clés

DocumentAnalysisClient

DocumentAnalysisClient fournit des opérations d’analyse des documents d’entrée à l’aide de modèles prédéfinis et personnalisés via les begin_analyze_document API et begin_analyze_document_from_url . Utilisez le model_id paramètre pour sélectionner le type de modèle à analyser. Consultez la liste complète des modèles pris en charge ici. Fournit DocumentAnalysisClient également des opérations de classification des documents via les begin_classify_document API et begin_classify_document_from_url . Les modèles de classification personnalisés peuvent classifier chaque page d’un fichier d’entrée pour identifier le ou les documents à l’intérieur et peuvent également identifier plusieurs documents ou plusieurs instances d’un seul document dans un fichier d’entrée.

Des exemples d’extraits de code sont fournis pour illustrer l’utilisation d’un DocumentAnalysisClient ici. Pour 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, consultez 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. Un DocumentModelDetails est retourné indiquant le ou les types de document que le modèle peut analyser, ainsi que la confiance estimée pour chaque champ. Consultez la documentation du service pour obtenir une explication plus détaillée.
  • Création d’un modèle composé à partir d’une collection de modèles existants.
  • Gérer les modèles créés dans votre compte.
  • Répertorier les opérations ou obtenir une opération de modèle spécifique créée au cours des dernières 24 heures.
  • Copier un modèle personnalisé d’une ressource Form Recognizer vers une autre.
  • Créez et gérez un modèle de classification personnalisé pour classifier les documents que vous traitez dans votre application.

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

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 se composent d’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 échouée, et si elle a réussi, pour obtenir le résultat.

Les méthodes qui analysent des documents, des modèles de génération ou des modèles de copie/composition sont modélisées comme des opérations de longue durée. Le client expose une begin_<method-name> méthode qui retourne un LROPoller ou .AsyncLROPoller Les appelants doivent attendre que l’opération se termine en appelant result() sur l’objet poller retourné par la begin_<method-name> 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 Document Intelligence les plus courantes, notamment :

Extraire la disposition

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

from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer import DocumentAnalysisClient

endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]

document_analysis_client = DocumentAnalysisClient(
    endpoint=endpoint, credential=AzureKeyCredential(key)
)
with open(path_to_sample_documents, "rb") as f:
    poller = document_analysis_client.begin_analyze_document(
        "prebuilt-layout", document=f
    )
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 polygon '{}'".format(
                line_idx,
                len(words),
                line.content,
                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 polygon '{}' and has a confidence of {}".format(
                selection_mark.state,
                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,
                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 polygon '{}'".format(
                    region.page_number,
                    region.polygon,
                )
            )

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

Utilisation du 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 Document Intelligence. Sélectionnez le modèle de document général en passant model_id="prebuilt-document" dans la begin_analyze_document méthode :

from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer import DocumentAnalysisClient

endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]

document_analysis_client = DocumentAnalysisClient(
    endpoint=endpoint, credential=AzureKeyCredential(key)
)
with open(path_to_sample_documents, "rb") as f:
    poller = document_analysis_client.begin_analyze_document(
        "prebuilt-document", document=f
    )
result = poller.result()

for style in result.styles:
    if style.is_handwritten:
        print("Document contains handwritten content: ")
        print(",".join([result.content[span.offset:span.offset + span.length] for span in style.spans]))

print("----Key-value pairs found in document----")
for kv_pair in result.key_value_pairs:
    if kv_pair.key:
        print(
                "Key '{}' found within '{}' bounding regions".format(
                    kv_pair.key.content,
                    kv_pair.key.bounding_regions,
                )
            )
    if kv_pair.value:
        print(
                "Value '{}' found within '{}' bounding regions\n".format(
                    kv_pair.value.content,
                    kv_pair.value.bounding_regions,
                )
            )

for page in result.pages:
    print("----Analyzing document 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 {} words and text '{}' within bounding polygon '{}'".format(
                line_idx,
                len(words),
                line.content,
                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 polygon '{}' and has a confidence of {}".format(
                selection_mark.state,
                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,
                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 polygon '{}'\n".format(
                    region.page_number,
                    region.polygon,
                )
            )
print("----------------------------------------")
  • Pour en savoir plus sur les fonctionnalités fournies par le prebuilt-document modèle , cliquez ici.

Utilisation de modèles prédéfinis

Extrayez des champs de certains types de documents, tels que des reçus, des factures, des cartes de visite, des documents d’identité et des documents fiscaux U.S. W-2 à l’aide de modèles prédéfinis fournis par le service Document Intelligence.

Par exemple, pour analyser les champs d’un reçu de vente, utilisez le modèle de reçu prédéfini fourni en passant model_id="prebuilt-receipt" dans la begin_analyze_document méthode :

from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer import DocumentAnalysisClient

endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]

document_analysis_client = DocumentAnalysisClient(
    endpoint=endpoint, credential=AzureKeyCredential(key)
)
with open(path_to_sample_documents, "rb") as f:
    poller = document_analysis_client.begin_analyze_document(
        "prebuilt-receipt", document=f, locale="en-US"
    )
receipts = poller.result()

for idx, receipt in enumerate(receipts.documents):
    print(f"--------Analysis of receipt #{idx + 1}--------")
    print(f"Receipt type: {receipt.doc_type if receipt.doc_type else 'N/A'}")
    merchant_name = receipt.fields.get("MerchantName")
    if merchant_name:
        print(
            f"Merchant Name: {merchant_name.value} has confidence: "
            f"{merchant_name.confidence}"
        )
    transaction_date = receipt.fields.get("TransactionDate")
    if transaction_date:
        print(
            f"Transaction Date: {transaction_date.value} has confidence: "
            f"{transaction_date.confidence}"
        )
    if receipt.fields.get("Items"):
        print("Receipt items:")
        for idx, item in enumerate(receipt.fields.get("Items").value):
            print(f"...Item #{idx + 1}")
            item_description = item.value.get("Description")
            if item_description:
                print(
                    f"......Item Description: {item_description.value} has confidence: "
                    f"{item_description.confidence}"
                )
            item_quantity = item.value.get("Quantity")
            if item_quantity:
                print(
                    f"......Item Quantity: {item_quantity.value} has confidence: "
                    f"{item_quantity.confidence}"
                )
            item_price = item.value.get("Price")
            if item_price:
                print(
                    f"......Individual Item Price: {item_price.value} has confidence: "
                    f"{item_price.confidence}"
                )
            item_total_price = item.value.get("TotalPrice")
            if item_total_price:
                print(
                    f"......Total Item Price: {item_total_price.value} has confidence: "
                    f"{item_total_price.confidence}"
                )
    subtotal = receipt.fields.get("Subtotal")
    if subtotal:
        print(f"Subtotal: {subtotal.value} has confidence: {subtotal.confidence}")
    tax = receipt.fields.get("TotalTax")
    if tax:
        print(f"Total tax: {tax.value} has confidence: {tax.confidence}")
    tip = receipt.fields.get("Tip")
    if tip:
        print(f"Tip: {tip.value} has confidence: {tip.confidence}")
    total = receipt.fields.get("Total")
    if total:
        print(f"Total: {total.value} has confidence: {total.confidence}")
    print("--------------------------------------")

Vous n’êtes pas limité aux reçus ! Il existe quelques modèles prédéfinis parmi lesquels choisir, chacun d’entre eux ayant son propre ensemble de champs pris en charge. Consultez les autres modèles prédéfinis pris en charge 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 lequel il a été entraîné. Fournissez une URL SAP de conteneur à votre conteneur d’objets blob stockage Azure dans lequel vous stockez les documents d’apprentissage.

Pour plus d’informations sur la configuration d’un conteneur et de la structure de fichiers requise, consultez la documentation du service.

from azure.ai.formrecognizer import (
    DocumentModelAdministrationClient,
    ModelBuildMode,
)
from azure.core.credentials import AzureKeyCredential

endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]
container_sas_url = os.environ["CONTAINER_SAS_URL"]

document_model_admin_client = DocumentModelAdministrationClient(
    endpoint, AzureKeyCredential(key)
)
poller = document_model_admin_client.begin_build_document_model(
    ModelBuildMode.TEMPLATE,
    blob_container_url=container_sas_url,
    description="my model description",
)
model = poller.result()

print(f"Model ID: {model.model_id}")
print(f"Description: {model.description}")
print(f"Model created on: {model.created_on}")
print(f"Model expires on: {model.expires_on}")
print("Doc types the model can recognize:")
for name, doc_type in model.doc_types.items():
    print(
        f"Doc Type: '{name}' built with '{doc_type.build_mode}' mode which has the following fields:"
    )
    for field_name, field in doc_type.field_schema.items():
        print(
            f"Field: '{field_name}' has type '{field['type']}' and confidence score "
            f"{doc_type.field_confidence[field_name]}"
        )

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

Analysez les champs de document, les tables, les marques de sélection, etc. Ces modèles sont entraînés avec vos propres données. Ils sont donc adaptés à vos documents. Pour obtenir de meilleurs résultats, vous devez analyser uniquement les documents du même type de document que celui avec lequel le modèle personnalisé a été créé.

from azure.core.credentials import AzureKeyCredential
from azure.ai.formrecognizer import DocumentAnalysisClient

endpoint = os.environ["AZURE_FORM_RECOGNIZER_ENDPOINT"]
key = os.environ["AZURE_FORM_RECOGNIZER_KEY"]
model_id = os.getenv("CUSTOM_BUILT_MODEL_ID", custom_model_id)

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

# Make sure your document's type is included in the list of document types the custom model can analyze
with open(path_to_sample_documents, "rb") as f:
    poller = document_analysis_client.begin_analyze_document(
        model_id=model_id, document=f
    )
result = poller.result()

for idx, document in enumerate(result.documents):
    print(f"--------Analyzing document #{idx + 1}--------")
    print(f"Document has type {document.doc_type}")
    print(f"Document has document type confidence {document.confidence}")
    print(f"Document was analyzed with model with ID {result.model_id}")
    for name, field in document.fields.items():
        field_value = field.value if field.value else field.content
        print(
            f"......found field of type '{field.value_type}' with value '{field_value}' and with confidence {field.confidence}"
        )

# iterate over tables, lines, and selection marks on each page
for page in result.pages:
    print(f"\nLines found on page {page.page_number}")
    for line in page.lines:
        print(f"...Line '{line.content}'")
    for word in page.words:
        print(f"...Word '{word.content}' has a confidence of {word.confidence}")
    if page.selection_marks:
        print(f"\nSelection marks found on page {page.page_number}")
        for selection_mark in page.selection_marks:
            print(
                f"...Selection mark is '{selection_mark.state}' and has a confidence of {selection_mark.confidence}"
            )

for i, table in enumerate(result.tables):
    print(f"\nTable {i + 1} can be found on page:")
    for region in table.bounding_regions:
        print(f"...{region.page_number}")
    for cell in table.cells:
        print(
            f"...Cell[{cell.row_index}][{cell.column_index}] has text '{cell.content}'"
        )
print("-----------------------------------")

Vous pouvez également utiliser une URL de document pour analyser des documents à l’aide de la begin_analyze_document_from_url méthode .

document_url = "<url_of_the_document>"
poller = document_analysis_client.begin_analyze_document_from_url(model_id=model_id, document_url=document_url)
result = poller.result()

Gérer vos modèles

Gérez les modèles personnalisés attachés à votre compte.

from azure.ai.formrecognizer import DocumentModelAdministrationClient
from azure.core.credentials import AzureKeyCredential
from azure.core.exceptions import ResourceNotFoundError

endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/"
credential = AzureKeyCredential("<api_key>")

document_model_admin_client = DocumentModelAdministrationClient(endpoint, credential)

account_details = document_model_admin_client.get_resource_details()
print("Our account has {} custom models, and we can have at most {} custom models".format(
    account_details.custom_document_models.count, account_details.custom_document_models.limit
))

# Here we get a paged list of all of our models
models = document_model_admin_client.list_document_models()
print("We have models with the following ids: {}".format(
    ", ".join([m.model_id for m in models])
))

# Replace with the custom model ID from the "Build a model" sample
model_id = "<model_id from the Build a Model sample>"

custom_model = document_model_admin_client.get_document_model(model_id=model_id)
print("Model ID: {}".format(custom_model.model_id))
print("Description: {}".format(custom_model.description))
print("Model created on: {}\n".format(custom_model.created_on))

# Finally, we will delete this model by ID
document_model_admin_client.delete_document_model(model_id=custom_model.model_id)

try:
    document_model_admin_client.get_document_model(model_id=custom_model.model_id)
except ResourceNotFoundError:
    print("Successfully deleted model with id {}".format(custom_model.model_id))

Fonctionnalités des modules complémentaires

Document Intelligence prend en charge des fonctionnalités d’analyse plus sophistiquées. Ces fonctionnalités facultatives peuvent être activées et désactivées en fonction du scénario d’extraction de document.

Les fonctionnalités de complément suivantes sont disponibles pour les versions 2023-07-31 (GA) et ultérieures :

Notez que certaines fonctionnalités de module complémentaire entraînent des frais supplémentaires. Consultez la tarification : https://azure.microsoft.com/pricing/details/ai-document-intelligence/.

Dépannage

Général

Form Recognizer bibliothèque cliente déclenche des exceptions définies dans Azure Core. Les codes d’erreur et les messages déclenchés par le service Document Intelligence se trouvent dans la documentation du service.

Journalisation

Cette bibliothèque utilise la bibliothèque de journalisation standard pour la journalisation.

Les informations de base sur les sessions HTTP (URL, en-têtes, etc.) sont enregistrées au INFO niveau.

La journalisation détaillée DEBUG de niveau, y compris les corps de requête/réponse et les en-têtes non expurgés, peut être activée sur le client ou par opération avec l’argument logging_enable mot clé.

Consultez la documentation complète sur la journalisation du KIT de développement logiciel (SDK) avec des exemples ici.

Configuration facultative

Les arguments facultatifs mot clé peuvent être transmis au niveau du client et par opération. La documentation de référence azure-core décrit les configurations disponibles pour les nouvelles tentatives, la journalisation, les protocoles de transport, etc.

Étapes suivantes

Autres exemples de code

Consultez l’exemple README pour obtenir plusieurs extraits de code illustrant les modèles courants utilisés dans l’API Python Form Recognizer.

Documentation complémentaire

Pour obtenir une documentation plus complète sur Azure AI Document Intelligence, consultez la documentation Document Intelligence sur docs.microsoft.com.

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, consultez 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.