Introducción a Document Intelligence

Importante

• Azure Cognitive Services Form Recognizer ahora es Azure AI Document Intelligence.
• Algunas plataformas siguen esperando la actualización de cambio de nombre.
• Todas las menciones de Form Recognizer o Documento de inteligencia en nuestra documentación se refieren al mismo servicio de Azure.

Este contenido se aplica a:v4.0 (versión preliminar)Versiones anteriores:v3.1 (GA)v3.0 (GA)

• Comience a usar la última versión preliminar de Azure AI Document Intelligence (2024-02-29-preview).

• Documento de inteligencia de Azure AI / Form Recognizer es un componente del servicio de Azure AI basado en la nube que usa el aprendizaje automático para extraer pares clave-valor, texto, tablas y datos clave de documentos.

• Puede integrar fácilmente modelos de procesamiento de documentos en los flujos de trabajo y las aplicaciones mediante un SDK de lenguaje de programación o una llamada a la API de REST.

• Para este inicio rápido, se recomienda usar el servicio gratuito mientras se está aprendiendo la tecnología. Recuerde que el número de páginas gratuitas se limita a 500 al mes.

Para más información sobre las características y las opciones de desarrollo de la API, visite nuestra página de información general.

Biblioteca cliente | Referencia de SDK | Referencia de API de REST | Paquete| Muestras|Versión de API de REST admitida

En este inicio rápido, se utilizan las siguientes características para analizar y extraer datos y valores tanto de formularios como de documentos:

• Modelo de diseño: analizar y extraer tablas, líneas, palabras y marcas de selección, como botones de radio y casillas en documentos, sin necesidad de entrenar un modelo.

• Modelo precompilado: análisis y extracción de campos comunes de tipos de documentos específicos mediante un modelo precompilado.

Requisitos previos

• Una suscripción a Azure: cree una cuenta gratuita.

• Versión actual del IDE de Visual Studio.

• Recurso de servicios de Azure AI o Document Intelligence. Una vez que tenga la suscripción de Azure, cree un recurso de servicio único o de varios servicios en Azure AI para obtener la clave y el punto de conexión.

• Puede usar el plan de tarifa gratis (F0) para probar el servicio y actualizarlo más adelante a un plan de pago para producción.

Sugerencia

Cree un recurso de servicios de Azure AI si tiene previsto acceder a varios servicios de Azure AI en un único punto de conexión o clave. Para obtener acceso solo a Documento de inteligencia cree un recurso de Documento de inteligencia. Tenga en cuenta que necesitará un recurso de servicio único si piensa usar autenticación de Microsoft Entra.

• Una vez implementado el recurso, seleccione Ir al recurso. Necesitará la clave y el punto de conexión del recurso que ha creado para conectar la aplicación a API de Document Intelligence. En una sección posterior de este mismo inicio rápido, va a pegar la clave y el punto de conexión en el código:

  

Configurar

1. Inicie Visual Studio.

2. En la página de inicio, elija Crear un proyecto nuevo.

   

3. En la página Crear un proyecto, escriba consola en el cuadro de búsqueda. Elija la plantilla Aplicación de consola y, a continuación, seleccione Siguiente.

   

4. En la ventana de diálogo Configure su nuevo proyecto, escriba doc_intel_quickstart en el cuadro Nombre de proyecto. Después, haga clic en Siguiente.

5. En la ventana de diálogo Información adicional, seleccione .NET 6.0 (Compatibilidad a largo plazo) y, a continuación, seleccione Crear.

   

Instalación de la biblioteca cliente con NuGet

1. Haga clic con el botón derecho en el proyecto doc_intel_quickstart y seleccione Administrar paquetes NuGet... .

   

2. Seleccione la pestaña Examinar y escriba Azure.AI.DocumentIntelligence. Elija la casilla Include prerelease y seleccione la versión 1.0.0-beta.1 en el menú desplegable

   

Compilación de la aplicación

Para interactuar con el servicio Document Intelligence, tiene que crear una instancia de la clase DocumentIntelligenceClient. Para ello, creará un elemento AzureKeyCredential con key de Azure Portal y una instancia de DocumentIntelligenceClient con AzureKeyCredential y el endpoint de Document Intelligence.

Nota

• A partir de .NET 6, los nuevos proyectos que usan la plantilla console generan un nuevo estilo de programa que difiere de las versiones anteriores.
• El nuevo tipo de salida usa características recientes de C# que simplifican el código que debe escribir.
• Cuando se usa la versión más reciente, solo es necesario escribir el cuerpo del método Main. Es decir, no es necesario incluir instrucciones de nivel superior, directivas Using globales o directivas Using implícitas.
• Para obtener más información, consulteLas nuevas plantillas de C# generan instrucciones de nivel superior.

1. Abra el archivo Program.cs.

2. Elimine el código existente, incluida la línea Console.Writeline("Hello World!"), y seleccione uno de los siguientes ejemplos de código para copiar y pegar en el archivo Program.cs de la aplicación:

   • Modelo de diseño

   • Modelo precompilado

Importante

Recuerde quitar la clave del código cuando haya terminado y no hacerla nunca pública. En el caso de producción, use una forma segura de almacenar sus credenciales y acceder a ellas, como Azure Key Vault. Para más información, consulteSeguridad de los servicios de Azure AI.

Modelo de diseño

Extraiga de los documentos texto, marcas de selección, estilos de texto, estructuras de tablas y coordenadas de su región delimitadora.

• Para este ejemplo, necesitará un archivo de documento en un identificador URI. Puede usar nuestro documento de ejemplo para esta guía de inicio rápido.
• Se ha agregado el valor del URI del archivo a la variable Uri fileUri de la parte superior del script.
• Para extraer el diseño de un archivo determinado en un identificador URI, use el método StartAnalyzeDocumentFromUri y pase prebuilt-layout como identificador de modelo. El valor devuelto es un objeto AnalyzeResult que contiene datos del documento enviado.

Agregue el ejemplo de código siguiente al archivo Program.cs. Asegúrese de actualizar las variables de clave y punto de conexión con valores de la instancia de Document Intelligence en Azure Portal:

using Azure;
using Azure.AI.DocumentIntelligence;

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

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

Operation<AnalyzeResult> operation = await client.AnalyzeDocumentAsync(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)," +
        $" 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}:");
        Console.WriteLine($"    Content: '{line.Content}'");

        Console.Write("    Bounding polygon, with points ordered clockwise:");
        for (int j = 0; j < line.Polygon.Count; j += 2)
        {
            Console.Write($" ({line.Polygon[j]}, {line.Polygon[j + 1]})");
        }

        Console.WriteLine();
    }

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

        Console.WriteLine($"  Selection Mark {i} is {selectionMark.State}.");
        Console.WriteLine($"    State: {selectionMark.State}");

        Console.Write("    Bounding polygon, with points ordered clockwise:");
        for (int j = 0; j < selectionMark.Polygon.Count; j++)
        {
            Console.Write($" ({selectionMark.Polygon[j]}, {selectionMark.Polygon[j + 1]})");
        }

        Console.WriteLine();
    }
}

for (int i = 0; i < result.Paragraphs.Count; i++)
{
    DocumentParagraph paragraph = result.Paragraphs[i];

    Console.WriteLine($"Paragraph {i}:");
    Console.WriteLine($"  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)
        {
            var handwrittenContent = result.Content.Substring(span.Offset, span.Length);
            Console.WriteLine($"  {handwrittenContent}");
        }
    }
}

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}) is a '{cell.Kind}' with content: {cell.Content}");
    }
}

Ejecución de la aplicación

Una vez que agregue una muestra de código a su aplicación, elija el botón verde Iniciar junto a formRecognizer_quickstart para crear y ejecutar su programa, o pulse F5.

Modelo precompilado

Análisis y extracción de campos comunes de tipos de documentos específicos mediante un modelo precompilado. En este ejemplo, se analiza una factura mediante el modelo de factura precompilada.

Sugerencia

No está limitado a las facturas: hay varios modelos precompilados entre los que elegir, cada uno de los cuales tiene su propio conjunto de campos admitidos. El modelo que se va a usar para la analyze operación depende del tipo de documento que se va a analizar. Consulte extracción de datos del modelo.

• Análisis de una factura mediante el modelo de factura precompilada. Puede usar nuestro documento de factura de ejemplo para este inicio rápido.
• Se ha agregado el valor del URI del archivo a la variable Uri invoiceUri de la parte superior del archivo Program.cs.
• Para analizar un archivo determinado en un identificador URI, use el método StartAnalyzeDocumentFromUri y pase prebuilt-invoice como identificador de modelo. El valor devuelto es un objeto AnalyzeResult que contiene datos del documento enviado.
• Por motivos de simplicidad, aquí no se muestran todos los pares clave-valor que devuelve el servicio. Para ver la lista de todos los campos admitidos y los tipos correspondientes, consulte nuestra página de concepto de factura.

Agregue el ejemplo de código siguiente al archivo Program.cs. Asegúrese de actualizar las variables de clave y punto de conexión con valores de la instancia de Document Intelligence en Azure Portal:

using Azure;
using Azure.AI.DocumentIntelligence;

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

//sample invoice document

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

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

AnalyzeResult result = operation.Value;

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

    AnalyzedDocument document = result.Documents[i];

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

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

    if (document.Fields.TryGetValue("Items", out DocumentField itemsField)
        && itemsField.Type == DocumentFieldType.Array)
    {
        foreach (DocumentField itemField in itemsField.ValueArray)
        {
            Console.WriteLine("Item:");

            if (itemField.Type == DocumentFieldType.Object)
            {
                IReadOnlyDictionary<string, DocumentField> itemFields = itemField.ValueObject;

                if (itemFields.TryGetValue("Description", out DocumentField itemDescriptionField)
                    && itemDescriptionField.Type == DocumentFieldType.String)
                {
                    string itemDescription = itemDescriptionField.ValueString;
                    Console.WriteLine($"  Description: '{itemDescription}', with confidence {itemDescriptionField.Confidence}");
                }

                if (itemFields.TryGetValue("Amount", out DocumentField itemAmountField)
                    && itemAmountField.Type == DocumentFieldType.Currency)
                {
                    CurrencyValue itemAmount = itemAmountField.ValueCurrency;
                    Console.WriteLine($"  Amount: '{itemAmount.CurrencySymbol}{itemAmount.Amount}', with confidence {itemAmountField.Confidence}");
                }
            }
        }
    }

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

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

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

Ejecución de la aplicación

Una vez que agregue una muestra de código a su aplicación, elija el botón verde Iniciar junto a formRecognizer_quickstart para crear y ejecutar su programa, o pulse F5.

Biblioteca cliente | Referencia de SDK | Referencia de la API de REST | Paquete (Maven) | Muestras |Versión de la API de REST admitida

En este inicio rápido, se utilizan las siguientes características para analizar y extraer datos y valores tanto de formularios como de documentos:

• Diseño: analizar y extraer tablas, líneas, palabras y marcas de selección, como botones de radio y casillas en documentos, sin necesidad de entrenar un modelo.

• Factura pregenerada: análisis y extracción de campos comunes de tipos de documentos específicos mediante un modelo entrenado previamente.

Requisitos previos

• Una suscripción a Azure: cree una cuenta gratuita.

• La versión más reciente de Visual Studio Code o el IDE que prefiera. ConsulteJava en Visual Studio Code.

  Sugerencia

  • Visual Studio Code ofrece un paquete de codificación para Java para Windows y macOS. El paquete de codificación es un conjunto de VS Code, el Kit de desarrollo de Java (JDK) y una colección de extensiones sugeridas por Microsoft. El paquete de codificación también se puede usar para corregir un entorno de desarrollo existente.
  • Si usa VS Code y el paquete de codificación para Java, instale la extensión Gradle para Java.

• Si no usa Visual Studio Code, asegúrese de que tiene lo siguiente instalado en el entorno de desarrollo:

  • Un kit de desarrollo de Java (JDK), versión 8 o posterior. Para obtener más información, consulteMicrosoft Build de OpenJDK.

  • Gradle, versión 6.8 o posterior.

• Recurso de servicios de Azure AI o Document Intelligence. Una vez que tenga la suscripción de Azure, cree un recurso de Document Intelligence de servicio único o de varios servicios en Azure Portal para obtener la clave y el punto de conexión. Puede usar el plan de tarifa gratis (F0) para probar el servicio y actualizarlo más adelante a un plan de pago para producción.

  Sugerencia

  Cree un recurso de servicios de Azure AI si tiene previsto acceder a varios servicios de Azure AI en un único punto de conexión o clave. Para obtener acceso solo a Documento de inteligencia cree un recurso de Documento de inteligencia. Tenga en cuenta que necesitará un recurso de servicio único si piensa usar autenticación de Microsoft Entra.

• Una vez implementado el recurso, seleccione Ir al recurso. Necesitará la clave y el punto de conexión del recurso que ha creado para conectar la aplicación a API de Document Intelligence. Posteriormente, pegará la clave y el punto de conexión en el código:

  

Configurar

Creación de un proyecto de Gradle

1. En una ventana de consola (como CMD, PowerShell o Bash), cree un nuevo directorio para la aplicación que se llame doc-intel-app y vaya hasta él.

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

   mkdir doc-intel-app; cd doc-intel-app
   

2. Ejecute el comando gradle init desde el directorio de trabajo. Este comando creará archivos de compilación esenciales para Gradle, como build.gradle.kts, que se usa en el entorno de ejecución para crear y configurar la aplicación.

   gradle init --type basic
   

3. Cuando se le solicite que elija un DSL, seleccione Kotlin.

4. Acepte el nombre predeterminado del proyecto (doc-intel-app). Para ello, presione la tecla INTRO o ENTRAR.

Instalación de la biblioteca cliente

En este inicio rápido se usa el administrador de dependencias Gradle. Puede encontrar la biblioteca de cliente y la información de otros administradores de dependencias en el repositorio central de Maven.

Abra el archivo build.gradle.kts del proyecto en el IDE. Copie y pegue el código siguiente para incluir la biblioteca cliente como una instrucción implementation, junto con los complementos y la configuración necesarios.

   plugins {
       java
       application
   }
   application {
       mainClass.set("DocIntelligence")
   }
   repositories {
       mavenCentral()
   }
   dependencies {
       implementation group: 'com.azure', name: 'azure-ai-documentintelligence', version: '1.0.0-beta.2'

   }

Creación de una aplicación Java

Para interactuar con el servicio Document Intelligence, tiene que crear una instancia de la clase DocumentIntelligenceClient. Para ello, creará un elemento AzureKeyCredential con key de Azure Portal y una instancia de DocumentIntelligenceClient con AzureKeyCredential y el endpoint de Document Intelligence.

1. En el directorio doc-intel-app, ejecute el siguiente comando:

   mkdir -p src/main/java
   

   Va a crear la estructura de directorios siguiente:

   

2. Vaya al directorio java y cree un archivo denominado DocIntelligence.java.

   Sugerencia

   • Puede crear un nuevo archivo mediante PowerShell.
   • Abra una ventana de PowerShell en el directorio del proyecto. Para ello, mantenga presionada la tecla Mayús y haga clic con el botón derecho en la carpeta.
   • Escriba el siguiente comando New-Item DocIntelligence.java.

3. Abra el archivo DocIntelligence.java . Copie y pegue uno de los ejemplos de código siguientes en la aplicación:

   • Diseño

   • Factura precompilada

Importante

Recuerde quitar la clave del código cuando haya terminado y no hacerla nunca pública. En el caso de producción, use una forma segura de almacenar sus credenciales y acceder a ellas, como Azure Key Vault. Para más información, consulteSeguridad de los servicios de Azure AI.

Modelo de diseño

Extraiga de los documentos texto, marcas de selección, estilos de texto, estructuras de tablas y coordenadas de su región delimitadora.

• Para este ejemplo, necesitará un archivo de documento en un identificador URI. Puede usar nuestro documento de ejemplo para esta guía de inicio rápido.
• Para analizar un archivo determinado en un URI, usará el método beginAnalyzeDocumentFromUrl y pasará prebuilt-layout como identificador del modelo. El valor devuelto es un objeto AnalyzeResult que contiene datos sobre el documento enviado.
• Se ha agregado el valor del URI del archivo a la variable documentUrl en el método main.

Agregue el siguiente código de ejemplo al archivo DocIntelligence.java. Asegúrese de actualizar las variables de clave y punto de conexión con valores de la instancia de Document Intelligence en Azure Portal:

import com.azure.ai.documentintelligence;

import com.azure.ai.documentintelligence.models.AnalyzeDocumentRequest;
import com.azure.ai.documentintelligence.models.AnalyzeResult;
import com.azure.ai.documentintelligence.models.AnalyzeResultOperation;
import com.azure.ai.documentintelligence.models.DocumentTable;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.util.List;

public class DocIntelligence {

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

  public static void main(String[] args) {

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

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

    SyncPoller <AnalyzeResultOperation, AnalyzeResultOperation> analyzeLayoutResultPoller =
      client.beginAnalyzeDocument(modelId, documentUrl);

    AnalyzeResult analyzeLayoutResult = analyzeLayoutPoller.getFinalResult().getAnalyzeResult();

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

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

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

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

    // tables
    List < DocumentTable > tables = analyzeLayoutResult.getTables();
    for (int i = 0; i < tables.size(); i++) {
      DocumentTable documentTable = tables.get(i);
      System.out.printf("Table %d has %d rows and %d columns.%n", i, documentTable.getRowCount(),
        documentTable.getColumnCount());
      documentTable.getCells().forEach(documentTableCell -> {
        System.out.printf("Cell '%s', has row index %d and column index %d.%n", documentTableCell.getContent(),
          documentTableCell.getRowIndex(), documentTableCell.getColumnIndex());
      });
      System.out.println();
    }

    // styles
    analyzeLayoutResult.getStyles().forEach(documentStyle -
      > System.out.printf("Document is handwritten %s.%n", documentStyle.isHandwritten()));
  }
}

Compilación y ejecución de la aplicación

Tras haber agregado un ejemplo de código a la aplicación, vuelva al directorio principal del proyecto: doc-intel-app.

1. Compile la aplicación con el comando build:

   gradle build
   

2. Ejecute la aplicación con el comando run:

   gradle run
   

Modelo precompilado

Análisis y extracción de campos comunes de tipos de documentos específicos mediante un modelo precompilado. En este ejemplo, se analiza una factura mediante el modelo de factura precompilada.

Sugerencia

No está limitado a las facturas: hay varios modelos precompilados entre los que elegir, cada uno de los cuales tiene su propio conjunto de campos admitidos. El modelo que se va a usar para la analyze operación depende del tipo de documento que se va a analizar. Consulte extracción de datos del modelo.

• Análisis de una factura mediante el modelo de factura precompilada. Puede usar nuestro documento de factura de ejemplo para este inicio rápido.
• Se ha agregado el valor de la dirección URL del archivo a la variable invoiceUrl de la parte superior del archivo.
• Para analizar un archivo determinado de un URI, usará el método beginAnalyzeDocuments y transferirá PrebuiltModels.Invoice como identificador del modelo. El valor devuelto es un objeto result que contiene datos sobre el documento enviado.
• Por motivos de simplicidad, aquí no se muestran todos los pares clave-valor que devuelve el servicio. Para ver la lista de todos los campos admitidos y los tipos correspondientes, consulte nuestra página de concepto de factura.

Agregue el siguiente código de ejemplo al archivo DocIntelligence.java. Asegúrese de actualizar las variables de clave y punto de conexión con valores de la instancia de Document Intelligence en Azure Portal:

import com.azure.ai.documentintelligence;

import com.azure.ai.documentintelligence.models.AnalyzeDocumentRequest;
import com.azure.ai.documentintelligence.models.AnalyzeResult;
import com.azure.ai.documentintelligence.models.AnalyzeResultOperation;
import com.azure.ai.documentintelligence.models.Document;
import com.azure.ai.documentintelligence.models.DocumentField;
import com.azure.ai.documentintelligence.models.DocumentFieldType;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.io.IOException;
import java.time.LocalDate;
import java.util.List;
import java.util.Map;

public class DocIntelligence {

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

  public static void main(String[] args) {

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

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

    public static void main(final String[] args) throws IOException {
      // Instantiate a client that will be used to call the service.
      DocumentIntelligenceClient client = new DocumentIntelligenceClientBuilder()
        .credential(new AzureKeyCredential("{key}"))
        .endpoint("https://{endpoint}.cognitiveservices.azure.com/")
        .buildClient();

      SyncPoller < OperationResult, AnalyzeResult > analyzeLayoutResultPoller =
        client.beginAnalyzeDocument(modelId, invoiceUrl);

      AnalyzeResult analyzeInvoiceResult = analyzeInvoicesPoller.getFinalResult().getAnalyzeResult();

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

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

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

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

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

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

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

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

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

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

Compilación y ejecución de la aplicación

Tras haber agregado un ejemplo de código a la aplicación, vuelva al directorio principal del proyecto: doc-intel-app.

1. Compile la aplicación con el comando build:

   gradle build
   

2. Ejecute la aplicación con el comando run:

   gradle run
   

Biblioteca cliente | Referencia de la API de REST | Paquete (npm) | Muestras |Versión de la API de REST admitida

En este inicio rápido, se utilizan las siguientes características para analizar y extraer datos y valores tanto de formularios como de documentos:

• Diseño: analizar y extraer tablas, líneas, palabras y marcas de selección, como botones de radio y casillas en documentos, sin necesidad de entrenar un modelo.

• Factura pregenerada: análisis y extracción de campos comunes de tipos de documentos específicos mediante un modelo de factura entrenado previamente.

Requisitos previos

• Una suscripción a Azure: cree una cuenta gratuita.

• La versión más reciente de Visual Studio Code o el IDE que prefiera. Para obtener más información, consulteNode.js en Visual Studio Code.

• La LTS versión más reciente de Node.js.

• Recurso de servicios de Azure AI o Document Intelligence. Una vez que tenga la suscripción de Azure, cree un recurso de Document Intelligence de servicio único o de varios servicios en Azure Portal para obtener la clave y el punto de conexión. Puede usar el plan de tarifa gratis (F0) para probar el servicio y actualizarlo más adelante a un plan de pago para producción.

  Sugerencia

  Cree un recurso de servicios de Azure AI si tiene previsto acceder a varios servicios de Azure AI en un único punto de conexión o clave. Para obtener acceso solo a Documento de inteligencia cree un recurso de Documento de inteligencia. Tenga en cuenta que necesitará un recurso de servicio único si piensa usar autenticación de Microsoft Entra.

• Una vez implementado el recurso, seleccione Ir al recurso. Necesitará la clave y el punto de conexión del recurso que ha creado para conectar la aplicación a API de Document Intelligence. En una sección posterior de este mismo inicio rápido, va a pegar la clave y el punto de conexión en el código:

  

Configurar

1. Cree una nueva aplicación de Node.js Express: en una ventana de la consola (como cmd, PowerShell o Bash), cree un directorio para la aplicación que se llame doc-intel-app y acceda a este.

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

2. Ejecute el comando npm init para inicializar la aplicación y aplicar scaffold al proyecto.

   npm init
   

3. Especifique los atributos del proyecto mediante las indicaciones que se presentan en el terminal.

   • Los atributos más importantes son el nombre, el número de versión y el punto de entrada.
   • Se recomienda mantener index.js para el nombre del punto de entrada. La descripción, el comando de prueba, el repositorio de GitHub, las palabras clave, el autor y la información de la licencia son atributos opcionales; se pueden omitir para este proyecto.
   • Acepte las sugerencias entre paréntesis seleccionando Retorno o Entrar.
   • Después de completar las solicitudes, se creará un archivo package.json en el directorio doc-intel-app.

4. Instale la biblioteca cliente ai-document-intelligence y el paquete npm azure/identity:

   npm i @azure-rest/ai-document-intelligence@1.0.0-beta.2 @azure/identity
   
   

   El archivo package.json de la aplicación se actualiza con las dependencias.

5. Cree un archivo denominado index.js en el directorio de aplicaciones.

   Sugerencia

   • Puede crear un nuevo archivo mediante PowerShell.
   • Abra una ventana de PowerShell en el directorio del proyecto. Para ello, mantenga presionada la tecla Mayús y haga clic con el botón derecho en la carpeta.
   • Escriba el siguiente comando New-Item index.js.

Compilación de la aplicación

Para interactuar con el servicio Document Intelligence, tiene que crear una instancia de la clase DocumentIntelligenceClient. Para ello, creará un elemento AzureKeyCredential con key de Azure Portal y una instancia de DocumentIntelligenceClient con AzureKeyCredential y el endpoint de Document Intelligence.

1. Abra el archivo index.js en Visual Studio Code o su IDE favorito. Copie y pegue uno de los ejemplos de código siguientes en la aplicación:

   • Diseño

   • Factura precompilada

Importante

Recuerde quitar la clave del código cuando haya terminado y no hacerla nunca pública. En el caso de producción, use una forma segura de almacenar sus credenciales y acceder a ellas, como Azure Key Vault. Para más información, consulteSeguridad de los servicios de Azure AI.

Modelo de diseño

Extraiga de los documentos texto, marcas de selección, estilos de texto, estructuras de tablas y coordenadas de su región delimitadora.

• Para este ejemplo, necesitará un archivo de documento de una URL. Puede usar nuestro documento de ejemplo para esta guía de inicio rápido.
• Se ha agregado el valor de la dirección URL del archivo a la variable formUrl cerca de la parte superior del archivo.
• Para analizar un archivo determinado de una dirección URL, usará el método beginAnalyzeDocuments y lo pasará a prebuilt-layout como identificador de modelo.

    const { DocumentIntelligenceClient } = require("@azure-rest/ai-document-intelligence");
    const  { AzureKeyCredential } = require("@azure/core-auth");

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

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

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

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

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

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

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

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

Ejecución de la aplicación

Tras haber agregado un ejemplo de código a la aplicación, ejecute el programa:

1. Acceda a la carpeta en la que tiene la aplicación Documento de inteligencia (doc-intel-app).

2. Escriba el siguiente comando en el terminal:

   node index.js
   

Modelo precompilado

En este ejemplo, se analiza una factura mediante el modelo de factura precompilada.

Sugerencia

No está limitado a las facturas: hay varios modelos precompilados entre los que elegir, cada uno de los cuales tiene su propio conjunto de campos admitidos. El modelo que se va a usar para la analyze operación depende del tipo de documento que se va a analizar. Consulte extracción de datos del modelo.

• Análisis de una factura mediante el modelo de factura precompilada. Puede usar nuestro documento de factura de ejemplo para este inicio rápido.
• Se ha agregado el valor de la dirección URL del archivo a la variable invoiceUrl de la parte superior del archivo.
• Para analizar un archivo determinado de un URI, usará el método beginAnalyzeDocuments y transferirá PrebuiltModels.Invoice como identificador del modelo. El valor devuelto es un objeto result que contiene datos sobre el documento enviado.
• Por motivos de simplicidad, aquí no se muestran todos los pares clave-valor que devuelve el servicio. Para ver la lista de todos los campos admitidos y los tipos correspondientes, consulte nuestra página de concepto de factura.

const { DocumentIntelligenceClient } = require("@azure-rest/ai-document-intelligence");
const  { AzureKeyCredential } = require("@azure/core-auth");

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

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

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

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

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

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

Ejecución de la aplicación

Tras haber agregado un ejemplo de código a la aplicación, ejecute el programa:

1. Acceda a la carpeta en la que tiene la aplicación Documento de inteligencia (doc-intel-app).

2. Escriba el siguiente comando en el terminal:

   node index.js
   

Biblioteca cliente |Referencia de SDK | Referencia de la API de REST | Paquete (PyPi) | Muestras | Versión de la API de REST admitida

En este inicio rápido, se utilizan las siguientes características para analizar y extraer datos de formularios y documentos:

• Diseño: analizar y extraer tablas, líneas, palabras y marcas de selección, como botones de radio y casillas y pares clave-valor, sin necesidad de entrenar un modelo.

• Factura pregenerada: análisis y extracción de campos comunes de tipos de documentos específicos mediante un modelo entrenado previamente.

Requisitos previos

• Una suscripción a Azure: cree una cuenta gratuita.

• Python 3.7 o versiones posteriores.

  • La instalación de Python debe incluir pip. Puede comprobar si tiene pip instalado mediante la ejecución de pip --version en la línea de comandos. Para obtener pip, instale la versión más reciente de Python.

• La versión más reciente de Visual Studio Code o el IDE que prefiera. Para más información, consulteIntroducción a Python en Visual Studio Code.

• Recurso de servicios de Azure AI o Document Intelligence. Una vez que tenga la suscripción de Azure, cree un recurso de Document Intelligence de servicio único o de varios servicios en Azure Portal para obtener la clave y el punto de conexión. Puede usar el plan de tarifa gratis (F0) para probar el servicio y actualizarlo más adelante a un plan de pago para producción.

Sugerencia

Cree un recurso de servicios de Azure AI si tiene previsto acceder a varios servicios de Azure AI en un único punto de conexión o clave. Para obtener acceso solo a Documento de inteligencia cree un recurso de Documento de inteligencia. Tenga en cuenta que necesitará un recurso de servicio único si piensa usar autenticación de Microsoft Entra.

• Una vez implementado el recurso, seleccione Ir al recurso. Necesitará la clave y el punto de conexión del recurso que ha creado para conectar la aplicación a API de Document Intelligence. En una sección posterior de este mismo inicio rápido, va a pegar la clave y el punto de conexión en el código:

  

Configurar

Abra una ventana de terminal en el entorno local e instale la biblioteca cliente de Azure AI Document Intelligence para Python con pip:

pip install azure-ai-documentintelligence==1.0.0b2

Creación de la aplicación Python

Para interactuar con el servicio Document Intelligence, tiene que crear una instancia de la clase DocumentIntelligenceClient. Para ello, creará un elemento AzureKeyCredential con key de Azure Portal y una instancia de DocumentIntelligenceClient con AzureKeyCredential y el endpoint de Document Intelligence.

1. Cree un archivo de Python nuevo y asígnele el nombre doc_intel_quickstart.pyen el editor o IDE que prefiera.

2. Abra el archivo doc_intel_quickstart.py y seleccione uno de los siguientes ejemplos de código para copiar y pegar en la aplicación:

   • Diseño

   • Factura precompilada

Importante

Recuerde quitar la clave del código cuando haya terminado y no hacerla nunca pública. En el caso de producción, use una forma segura de almacenar sus credenciales y acceder a ellas, como Azure Key Vault. Para más información, consulteSeguridad de los servicios de Azure AI.

Modelo de diseño

Extraiga de los documentos texto, marcas de selección, estilos de texto, estructuras de tablas y coordenadas de su región delimitadora.

• Para este ejemplo, necesitará un archivo de documento de una URL. Puede usar nuestro documento de ejemplo para esta guía de inicio rápido.
• Se ha agregado el valor de la dirección URL del archivo a la variable formUrl en la función analyze_layout.
• Para analizar un archivo determinado de una dirección URL, usará el método begin_analyze_document_from_url y transferirá prebuilt-layout como identificador del modelo. El valor devuelto es un objeto result que contiene datos sobre el documento enviado.

Agregue el siguiente ejemplo de código a la aplicación doc_intel_quickstart.py. Asegúrese de actualizar las variables de clave y punto de conexión con valores de la instancia de Document Intelligence en Azure Portal:

# import libraries
import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.documentintelligence import DocumentIntelligenceClient
from azure.ai.documentintelligence.models import AnalyzeResult

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

# helper functions

def get_words(page, line):
    result = []
    for word in page.words:
        if _in_span(word, line.spans):
            result.append(word)
    return result


def _in_span(word, spans):
    for span in spans:
        if word.span.offset >= span.offset and (
            word.span.offset + word.span.length
        ) <= (span.offset + span.length):
            return True
    return False


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

    document_intelligence_client = DocumentIntelligenceClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller = document_intelligence_client.begin_analyze_document(
        "prebuilt-layout", formUrl
    )

    analyze_request = AnalyzeDocumentRequest(
        url_source=formUrl
    )

    result: AnalyzeResult = poller.result()

    if result.styles and any([style.is_handwritten for style in result.styles]):
        print("Document contains handwritten content")
    else:
        print("Document does not contain handwritten content")

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

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

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

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

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

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


if __name__ == "__main__":
    analyze_layout()

Ejecución de la aplicación

Tras haber agregado un ejemplo de código a la aplicación, compile y ejecute el programa:

1. Vaya a la carpeta donde tiene el archivo doc_intel_quickstart.py.

2. Escriba el siguiente comando en el terminal:

   python doc_intel_quickstart.py
   

---

Modelo precompilado

Análisis y extracción de campos comunes de tipos de documentos específicos mediante un modelo precompilado. En este ejemplo, se analiza una factura mediante el modelo de factura precompilada.

Sugerencia

No está limitado a las facturas: hay varios modelos precompilados entre los que elegir, cada uno de los cuales tiene su propio conjunto de campos admitidos. El modelo que se va a usar para la analyze operación depende del tipo de documento que se va a analizar. Consulte extracción de datos del modelo.

• Análisis de una factura mediante el modelo de factura precompilada. Puede usar nuestro documento de factura de ejemplo para este inicio rápido.
• Se ha agregado el valor de la dirección URL del archivo a la variable invoiceUrl de la parte superior del archivo.
• Para analizar un archivo determinado de un URI, usará el método begin_analyze_document_from_url y transferirá prebuilt-invoice como identificador del modelo. El valor devuelto es un objeto result que contiene datos sobre el documento enviado.
• Por motivos de simplicidad, aquí no se muestran todos los pares clave-valor que devuelve el servicio. Para ver la lista de todos los campos admitidos y los tipos correspondientes, consulte nuestra página de concepto de factura.

Agregue el siguiente ejemplo de código a la aplicación doc_intel_quickstart.py. Asegúrese de actualizar las variables de clave y punto de conexión con valores de la instancia de Document Intelligence en Azure Portal:

# import libraries
import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.documentintelligence import DocumentIntelligenceClient


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

def analyze_invoice():
    # sample document

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

    document_intelligence_client = DocumentIntelligenceClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller = document_intelligence_client.begin_analyze_document(
        "prebuilt-invoice", invoiceUrl
    )
    invoices = poller.result()

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


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


if __name__ == "__main__":
    analyze_invoice()

Ejecución de la aplicación

Tras haber agregado un ejemplo de código a la aplicación, compile y ejecute el programa:

1. Vaya a la carpeta donde tiene el archivo doc_intel_quickstart.py.

2. Escriba el siguiente comando en el terminal:

   python doc_intel_quickstart.py
   

| API de REST de Documento de inteligencia | SDK de Azure admitidos

En este inicio rápido, aprenderá a utilizar la API de REST de Documento de inteligencia para analizar y extraer datos y valores de documentos:

Requisitos previos

• Una suscripción a Azure: cree una cuenta gratuita

• Herramienta de línea de comandos de curl instalada.

  • Windows
  • Mac o Linux

• PowerShell versión 7.*, o superior (o una aplicación de la línea de comandos similar):

  • Windows
  • macOS
  • Linux

• Para comprobar la versión de PowerShell, escriba el siguiente comando relativo al sistema operativo:

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

• Un recurso de Document Intelligence (servicio único) o servicios de Azure AI (multiservicio). Una vez que tenga la suscripción de Azure, cree un recurso de Document Intelligence de servicio único o de varios servicios en Azure Portal para obtener la clave y el punto de conexión. Puede usar el plan de tarifa gratis (F0) para probar el servicio y actualizarlo más adelante a un plan de pago para producción.

Sugerencia

Cree un recurso de servicios de Azure AI si tiene previsto acceder a varios servicios de Azure AI en un único punto de conexión o clave. Para obtener acceso solo a Documento de inteligencia cree un recurso de Documento de inteligencia. Tenga en cuenta que necesitará un recurso de servicio único si piensa usar autenticación de Microsoft Entra.

• Una vez implementado el recurso, seleccione Ir al recurso. Necesitará la clave y el punto de conexión del recurso que ha creado para conectar la aplicación a API de Document Intelligence. En una sección posterior de este mismo inicio rápido, va a pegar la clave y el punto de conexión en el código:

  

Análisis de documentos y obtención de resultados

Las solicitudes POST se usan para analizar documentos con un modelo precompilado o personalizado. Las solicitudes GET se usan para recuperar el resultado de una llamada de análisis de documentos. modelId se usa con POST y resultId con las operaciones GET.

Análisis de documento (solicitud POST)

Antes de ejecutar el comando cURL, realice los siguientes cambios en la solicitud POST:

1. Reemplace el valor {endpoint} por el valor del punto de conexión de la instancia de Document Intelligence en Azure Portal.

2. Reemplace el valor {key} por el valor de clave de la instancia de Document Intelligence en Azure Portal.

3. Con tabla siguiente como referencia, reemplace {modelID} y {your-document-url} por los valores deseados.

4. Necesitará un archivo de documento en una dirección URL. Para este inicio rápido, puede usar los formularios de ejemplo que se proporcionan en la siguiente tabla para cada característica:

Documentos de muestra

Característica	{modelID}	{your-document-url}
Lectura	prebuilt-read	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/read.png
Diseño	diseño preelaborado	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/layout.png
Tarjeta de seguro de salud	prebuilt-healthInsuranceCard.us	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/insurance-card.png
W-2	prebuilt-tax.us.w2	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/w2.png
Factura	prebuilt-invoice	https://github.com/Azure-Samples/cognitive-services-REST-api-samples/raw/master/curl/form-recognizer/rest-api/invoice.pdf
Recibo	Recibo precompilado	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/receipt.png
Documento de identificación	prebuilt-idDocument	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/identity_documents.png

Importante

Recuerde quitar la clave del código cuando haya terminado y no hacerla nunca pública. En el caso de producción, use una forma segura de almacenar sus credenciales y acceder a ellas, como Azure Key Vault. Para más información, consulteSeguridad de servicios de Azure AI.

Solicitud POST

curl -v -i POST "{endpoint}/documentintelligence/documentModels/{modelId}:analyze?api-version=2024-02-29-preview" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: {key}" --data-ascii "{'urlSource': '{your-document-url}'}"

Respuesta POST (resultID)

Recibe una respuesta 202 (Success) que incluye un encabezado Operation-Location de solo lectura. El valor de este encabezado contiene una instancia de resultID que se puede consultar para obtener el estado de la operación asincrónica y recuperar los resultados mediante una solicitud GET con la misma clave de suscripción de recursos:

Obtención de los resultados del análisis (solicitud GET)

Después de llamar a la API Analyze document, llame a la API Get analyze result para obtener el estado de la operación y los datos extraídos. Antes de ejecutar el comando, realice estos cambios:

1. Reemplace el encabezado Operation-Location {resultID} de la respuesta POST.

2. Reemplace el valor {key} por el valor de clave de la instancia de Document Intelligence en Azure Portal.

Solicitud GET

curl -v -X GET "{endpoint}/documentintelligence/documentModels/{modelId}/analyzeResults/{resultId}?api-version=2024-02-29-preview" -H "Ocp-Apim-Subscription-Key: {key}"

Examen de la respuesta

Recibe una respuesta 200 (Success) con la salida JSON. El primer campo, "status", indica el estado de la operación. Si la operación no está completa, el valor de "status" es "running" o "notStarted" y debe volver a llamar a la API, ya sea manualmente o a través de un script. Se recomienda un intervalo de uno o varios segundos entre llamadas.

Respuesta de ejemplo para la factura de muestra

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

Campos de documento admitidos

Los modelos precompilados extraen conjuntos predefinidos de campos de documento. Consulte Extracción de datos del modelo para conocer los nombres de campo, tipos y descripciones extraídos, además de ejemplos.

Eso es todo, ¡enhorabuena!

En este inicio rápido, ha usado un modelo de Documento de inteligencia para analizar varios formularios y documentos. A continuación, explore Document Intelligence Studio y la documentación de referencia para obtener información sobre la API de Document Intelligence en profundidad.

Pasos siguientes

• Para obtener una experiencia mejorada y un modelo de calidad avanzada, pruebe Document Intelligence Studio

• Para la migración de v3.1 a v4.0, consulte las Guías de migración de registro de cambios.