Biblioteca cliente de Azure Form Recognizer para Python: versión 3.3.2

Azure Document Intelligence (anteriormente conocido como Form Recognizer) es un servicio en la nube que usa el aprendizaje automático para analizar texto y datos estructurados de los documentos. Incluye las siguientes características principales:

• Diseño: extraiga contenido y estructura (por ejemplo, palabras, marcas de selección, tablas) de documentos.
• Documento: analice pares clave-valor además del diseño general de los documentos.
• Leer: leer información de página de documentos.
• Precompilado: extraiga valores de campo comunes de los tipos de documento seleccionados (por ejemplo, recibos, facturas, tarjetas de presentación, documentos de identificación, documentos fiscales W-2 de EE. UU., entre otros) mediante modelos precompilados.
• Personalizado: cree modelos personalizados a partir de sus propios datos para extraer valores de campo personalizados además del diseño general de los documentos.
• Clasificadores: cree modelos de clasificación personalizados que combinen características de diseño y lenguaje para detectar e identificar con precisión los documentos que procesa dentro de la aplicación.
• Funcionalidades de complemento: extraiga códigos de barras/CÓDIGOS QR, fórmulas, fuente/estilo, etc. o habilite el modo de alta resolución para documentos grandes con parámetros opcionales.

Código | fuentePaquete (PyPI) | Paquete (Conda) | Documentación | de referencia de APIDocumentación | del productoMuestras

Introducción

Requisitos previos

• Se requiere Python 3.7 o posterior para usar este paquete.
• Debe tener una suscripción de Azure y un recurso de Cognitive Services o Form Recognizer para usar este paquete.

Instalar el paquete

Instale la biblioteca cliente de Azure Form Recognizer para Python con pip:

pip install azure-ai-formrecognizer

Nota: Esta versión de la biblioteca cliente tiene como valor predeterminado la 2023-07-31 versión del servicio.

En esta tabla se muestra la relación entre las versiones del SDK y las versiones de la API admitidas del servicio:

Versión del SDK	Versión de la API admitidas del servicio
3.3.X: versión más reciente de disponibilidad general	2.0, 2.1, 2022-08-31, 2023-07-31 (valor predeterminado)
3.2.X	2.0, 2.1, 2022-08-31 (valor predeterminado)
3.1.X	2.0, 2.1 (valor predeterminado)
3.0.0	2.0

Nota: A partir de la versión 3.2.X, se introdujo un nuevo conjunto de clientes para aprovechar las características más recientes del servicio De inteligencia de documentos. Consulte la Guía de migración para obtener instrucciones detalladas sobre cómo actualizar el código de aplicación de la versión 3.1.X de la biblioteca cliente o una versión inferior a la versión más reciente. Además, consulte el registro de cambios para obtener información más detallada. En la tabla siguiente se describe la relación de cada cliente y sus versiones de API admitidas:

Versión de API	Clientes compatibles
2023-07-31	DocumentAnalysisClient y DocumentModelAdministrationClient
2022-08-31	DocumentAnalysisClient y DocumentModelAdministrationClient
2.1	FormRecognizerClient y FormTrainingClient
2.0	FormRecognizerClient y FormTrainingClient

Creación de un recurso de Cognitive Services o Form Recognizer

La inteligencia de documentos admite el acceso de varios servicios y de un solo servicio. Cree un recurso de Cognitive Services si tiene previsto acceder a varios servicios de Cognitive Services en un único punto de conexión o clave. Solo para el acceso a La inteligencia de documentos, cree un recurso de Form Recognizer. Tenga en cuenta que necesitará un recurso de servicio único si piensa usar la autenticación de Azure Active Directory.

Puede crear cualquiera de los recursos mediante:

• Opción 1: Azure Portal.
• Opción 2: CLI de Azure.

A continuación se muestra un ejemplo de cómo puede crear un recurso de Form Recognizer mediante la 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

Para obtener más información sobre cómo crear el recurso o cómo obtener la información de ubicación y SKU, consulte aquí.

Autenticar el cliente

Para interactuar con el servicio De inteligencia de documentos, deberá crear una instancia de un cliente. Se necesita un punto de conexión y una credencial para crear una instancia del objeto de cliente.

Obtención del punto de conexión

Puede encontrar el punto de conexión del recurso de Form Recognizer mediante Azure Portal o la CLI de Azure:

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

Se puede usar un punto de conexión regional o un subdominio personalizado para la autenticación. Tienen el formato siguiente:

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

Un punto de conexión regional es el mismo para cada recurso de una región. Aquí se puede consultar una lista completa de los puntos de conexión regionales admitidos. Tenga en cuenta que los puntos de conexión regionales no admiten la autenticación de AAD.

Un subdominio personalizado, por otro lado, es un nombre que es único para el recurso de Form Recognizer. Los recursos de un solo servicio solo los pueden usar.

Obtención de la clave de API

La clave de API se puede encontrar en Azure Portal o mediante la ejecución del siguiente comando de la CLI de Azure:

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

Creación del cliente con AzureKeyCredential

Para usar una clave de API como credential parámetro, pase la clave como una cadena a una instancia de 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)

Creación del cliente con una credencial de Azure Active Directory

AzureKeyCredential La autenticación se usa en los ejemplos de esta guía de introducción, pero también puede autenticarse con Azure Active Directory mediante la biblioteca azure-identity . Tenga en cuenta que los puntos de conexión regionales no admiten la autenticación de AAD. Cree un nombre de subdominio personalizado para el recurso con el fin de usar este tipo de autenticación.

Para usar el tipo DefaultAzureCredential que se muestra a continuación u otros tipos de credenciales proporcionados con el SDK de Azure, instale el azure-identity paquete:

pip install azure-identity

También tendrá que registrar una nueva aplicación de AAD y conceder acceso a Document Intelligence mediante la asignación del rol a la "Cognitive Services User" entidad de servicio.

Una vez completado, establezca los valores del identificador de cliente, el identificador de inquilino y el secreto de cliente de la aplicación de AAD como variables de entorno: AZURE_CLIENT_ID, , AZURE_TENANT_IDAZURE_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)

Conceptos clave

DocumentAnalysisClient

DocumentAnalysisClient proporciona operaciones para analizar documentos de entrada mediante modelos precompilados y personalizados a través de las begin_analyze_document API y begin_analyze_document_from_url . Use el model_id parámetro para seleccionar el tipo de modelo para su análisis. Consulte una lista completa de los modelos admitidos aquí. DocumentAnalysisClient También proporciona operaciones para clasificar documentos a través de las begin_classify_document API y begin_classify_document_from_url . El modelo de clasificación personalizado puede clasificar cada página en un archivo de entrada para identificar los documentos que contiene y también puede identificar varios documentos o varias instancias de un único documento dentro de un archivo de entrada.

Aquí se proporcionan fragmentos de código de ejemplo para ilustrar el uso de ejemplos de DocumentAnalysisClient. Puede encontrar más información sobre el análisis de documentos, incluidas las características admitidas, las configuraciones regionales y los tipos de documento en la documentación del servicio.

DocumentModelAdministrationClient

DocumentModelAdministrationClient proporciona operaciones para:

• Crear modelos personalizados para analizar campos específicos que especifique mediante el etiquetado de los documentos personalizados. Se devuelve un DocumentModelDetails valor que indica los tipos de documento que el modelo puede analizar, así como la confianza estimada para cada campo. Consulte la documentación del servicio para obtener una explicación más detallada.
• Crear un modelo compuesto a partir de una colección de modelos existentes.
• La administración de los modelos creados en una cuenta.
• Enumerar las operaciones o obtener una operación de modelo específica creada en las últimas 24 horas.
• La copia de un modelo personalizado entre recursos de Form Recognizer.
• Compile y administre un modelo de clasificación personalizado para clasificar los documentos que procesa dentro de la aplicación.

Tenga en cuenta que los modelos también se pueden crear mediante una interfaz gráfica de usuario, como Document Intelligence Studio.

Aquí se proporcionan fragmentos de código de ejemplo para ilustrar el uso de ejemplos de DocumentModelAdministrationClient.

Operaciones de larga duración

Las operaciones de larga duración son operaciones que constan de una solicitud inicial enviada al servicio para iniciar una operación, seguidas de sondear el servicio a intervalos para determinar si la operación se ha completado o no, y si se ha realizado correctamente, para obtener el resultado.

Los métodos que analizan documentos, modelos de compilación o modelos de copia o redacción se modelan como operaciones de larga duración. El cliente expone un begin_<method-name> método que devuelve o LROPollerAsyncLROPoller. Los autores de llamadas deben esperar a que se complete la operación llamando result() al objeto de sondeo devuelto desde el begin_<method-name> método . A continuación se proporcionan fragmentos de código de ejemplo para ilustrar el uso de operaciones de larga duración .

Ejemplos

En la sección siguiente se proporcionan varios fragmentos de código que abarcan algunas de las tareas más comunes de Inteligencia de documentos, entre las que se incluyen:

• Extraer diseño
• Uso del modelo de documento general
• Uso de modelos precompilados
• Compilación de un modelo personalizado
• Analizar documentos mediante un modelo personalizado
• Administrar los modelos
• Clasificar documentos
• Funcionalidades de complementos

Extraer diseño

Extraiga texto, marcas de selección, estilos de texto y estructuras de tabla, junto con sus coordenadas de región delimitador, de documentos.

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("----------------------------------------")

Uso del modelo de documento general

Analice pares clave-valor, tablas, estilos y marcas de selección de documentos mediante el modelo de documento general proporcionado por el servicio Document Intelligence. Seleccione el modelo de documento general pasando model_id="prebuilt-document" al begin_analyze_document método :

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("----------------------------------------")

• Obtenga más información sobre las características proporcionadas por el prebuilt-document modelo aquí.

Uso de modelos precompilados

Extraiga campos de tipos de documentos seleccionados, como recibos, facturas, tarjetas de presentación, documentos de identidad y documentos fiscales W-2 de EE. UU. mediante modelos creados previamente proporcionados por el servicio Document Intelligence.

Por ejemplo, para analizar campos de un recibo de ventas, use el modelo de recibo precompilado proporcionado pasando model_id="prebuilt-receipt" al begin_analyze_document método :

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("--------------------------------------")

¡No se limita a los recibos! Hay algunos modelos precompilados entre los que elegir, cada uno de los cuales tiene su propio conjunto de campos admitidos. Consulte otros modelos precompilados admitidos aquí.

Compilación de un modelo personalizado

Cree un modelo personalizado en su propio tipo de documento. El modelo resultante se puede usar para analizar valores de los tipos de documentos en los que se entrenó. Proporcione una dirección URL de SAS de contenedor al contenedor de blobs de Azure Storage donde va a almacenar los documentos de entrenamiento.

Puede encontrar más detalles sobre cómo configurar un contenedor y la estructura de archivos necesaria en la documentación del servicio.

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

Analizar documentos mediante un modelo personalizado

Analice campos de documento, tablas, marcas de selección, etc. Estos modelos se entrenan con sus propios datos, por lo que se adaptan a los documentos. Para obtener los mejores resultados, solo debe analizar documentos del mismo tipo de documento con el que se creó el modelo personalizado.

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("-----------------------------------")

Como alternativa, también se puede usar una dirección URL de documento para analizar documentos mediante el begin_analyze_document_from_url método .

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()

Administrar los modelos

Administre los modelos personalizados asociados a su cuenta.

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))

Funcionalidades del complemento

La inteligencia de documentos admite funcionalidades de análisis más sofisticadas. Estas características opcionales se pueden habilitar y deshabilitar en función del escenario de extracción de documentos.

Las siguientes funcionalidades de complemento están disponibles para las versiones 2023-07-31 (GA) y posteriores:

• código de código de barras/QR
• Fórmula
• font/style
• modo de alta resolución
• language

Tenga en cuenta que algunas funcionalidades de complemento incurrirán en cargos adicionales. Consulte precios: https://azure.microsoft.com/pricing/details/ai-document-intelligence/.

Solución de problemas

General

Form Recognizer biblioteca cliente generará excepciones definidas en Azure Core. Los códigos de error y los mensajes generados por el servicio Document Intelligence se pueden encontrar en la documentación del servicio.

Registro

Esta biblioteca usa la biblioteca de registro estándar para el registro.

La información básica sobre las sesiones HTTP (direcciones URL, encabezados, etc.) se registra en el INFO nivel.

El registro de nivel detallado DEBUG , incluidos los cuerpos de solicitud/respuesta y los encabezados no aprobados , se puede habilitar en el cliente o por operación con el argumento de palabra logging_enable clave.

Consulte la documentación completa del registro del SDK con ejemplos aquí.

Configuración opcional

Los argumentos de palabra clave opcionales se pueden pasar en el nivel de cliente y por operación. En la documentación de referencia de azure-core se describen las configuraciones disponibles para reintentos, registro, protocolos de transporte, etc.

Pasos siguientes

Más código de ejemplo

Consulte el archivo Léame de ejemplo para ver varios fragmentos de código que ilustran patrones comunes que se usan en la API de Python de Form Recognizer.

Documentación adicional

Para obtener documentación más amplia sobre La inteligencia de documentos de Azure AI, consulte la documentación de Document Intelligence sobre docs.microsoft.com.

Contribuciones

Este proyecto agradece las contribuciones y sugerencias. La mayoría de las contribuciones requieren que acepte un Contrato de licencia para el colaborador (CLA) que declara que tiene el derecho a concedernos y nos concede los derechos para usar su contribución. Para más información, visite cla.microsoft.com.

Cuando se envía una solicitud de incorporación de cambios, un bot de CLA determinará de forma automática si tiene que aportar un CLA y completar la PR adecuadamente (por ejemplo, la etiqueta, el comentario). Solo siga las instrucciones que le dará el bot. Solo será necesario que lo haga una vez en todos los repositorios con nuestro CLA.

Este proyecto ha adoptado el Código de conducta de Microsoft Open Source. Para más información, consulte las preguntas más frecuentes del código de conducta o póngase en contacto con opencode@microsoft.com si tiene cualquier otra pregunta o comentario.