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: v3.1 (GA) Versiones anteriores: v3.0 v2.1

• Introducción a la versión más reciente de disponibilidad general de Azure Form Recognizer (2023-07-31).

• 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 | Paquete (NuGet) | 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:

• 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.

• Un recurso de servicios de Azure AI o Form Recognizer. 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 acceder únicamente a Form Recognizer, cree un recurso de Form Recognizer. 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 la API de Form Recognizer. 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 form_recognizer_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 8.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 form_recognizer_quickstart y seleccione Administrar paquetes NuGet....

   

2. Seleccione la pestaña Examinar y escriba Azure.AI.FormRecognizer. Seleccione la versión 4.1.0 en el menú desplegable

   

Compilación de la aplicación

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

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, consulte Las 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 referentes a la instancia de Form Recognizer en Azure Portal:

using Azure;
using Azure.AI.FormRecognizer.DocumentAnalysis;

//set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal to create your `AzureKeyCredential` and `DocumentAnalysisClient` instance
string endpoint = "<your-endpoint>";
string key = "<your-key>";
AzureKeyCredential credential = new AzureKeyCredential(key);
DocumentAnalysisClient client = new DocumentAnalysisClient(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");

AnalyzeDocumentOperation operation = await client.AnalyzeDocumentFromUriAsync(WaitUntil.Completed, "prebuilt-layout", fileUri);

AnalyzeResult result = operation.Value;

foreach (DocumentPage page in result.Pages)
{
    Console.WriteLine($"Document Page {page.PageNumber} has {page.Lines.Count} line(s), {page.Words.Count} word(s),");
    Console.WriteLine($"and {page.SelectionMarks.Count} selection mark(s).");

    for (int i = 0; i < page.Lines.Count; i++)
    {
        DocumentLine line = page.Lines[i];
        Console.WriteLine($"  Line {i} has content: '{line.Content}'.");

        Console.WriteLine($"    Its bounding box is:");
        Console.WriteLine($"      Upper left => X: {line.BoundingPolygon[0].X}, Y= {line.BoundingPolygon[0].Y}");
        Console.WriteLine($"      Upper right => X: {line.BoundingPolygon[1].X}, Y= {line.BoundingPolygon[1].Y}");
        Console.WriteLine($"      Lower right => X: {line.BoundingPolygon[2].X}, Y= {line.BoundingPolygon[2].Y}");
        Console.WriteLine($"      Lower left => X: {line.BoundingPolygon[3].X}, Y= {line.BoundingPolygon[3].Y}");
    }

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

        Console.WriteLine($"  Selection Mark {i} is {selectionMark.State}.");
        Console.WriteLine($"    Its bounding box is:");
        Console.WriteLine($"      Upper left => X: {selectionMark.BoundingPolygon[0].X}, Y= {selectionMark.BoundingPolygon[0].Y}");
        Console.WriteLine($"      Upper right => X: {selectionMark.BoundingPolygon[1].X}, Y= {selectionMark.BoundingPolygon[1].Y}");
        Console.WriteLine($"      Lower right => X: {selectionMark.BoundingPolygon[2].X}, Y= {selectionMark.BoundingPolygon[2].Y}");
        Console.WriteLine($"      Lower left => X: {selectionMark.BoundingPolygon[3].X}, Y= {selectionMark.BoundingPolygon[3].Y}");
    }
}

foreach (DocumentStyle style in result.Styles)
{
    // Check the style and style confidence to see if text is handwritten.
    // Note that value '0.8' is used as an example.

    bool isHandwritten = style.IsHandwritten.HasValue && style.IsHandwritten == true;

    if (isHandwritten && style.Confidence > 0.8)
    {
        Console.WriteLine($"Handwritten content found:");

        foreach (DocumentSpan span in style.Spans)
        {
            Console.WriteLine($"  Content: {result.Content.Substring(span.Index, span.Length)}");
        }
    }
}

Console.WriteLine("The following tables were extracted:");

for (int i = 0; i < result.Tables.Count; i++)
{
    DocumentTable table = result.Tables[i];
    Console.WriteLine($"  Table {i} has {table.RowCount} rows and {table.ColumnCount} columns.");

    foreach (DocumentTableCell cell in table.Cells)
    {
        Console.WriteLine($"    Cell ({cell.RowIndex}, {cell.ColumnIndex}) has kind '{cell.Kind}' and content: '{cell.Content}'.");
    }
}

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.

Salida del modelo de diseño

Este es un fragmento de la salida esperada:

  Document Page 1 has 69 line(s), 425 word(s), and 15 selection mark(s).
  Line 0 has content: 'UNITED STATES'.
    Its bounding box is:
      Upper left => X: 3.4915, Y= 0.6828
      Upper right => X: 5.0116, Y= 0.6828
      Lower right => X: 5.0116, Y= 0.8265
      Lower left => X: 3.4915, Y= 0.8265
  Line 1 has content: 'SECURITIES AND EXCHANGE COMMISSION'.
    Its bounding box is:
      Upper left => X: 2.1937, Y= 0.9061
      Upper right => X: 6.297, Y= 0.9061
      Lower right => X: 6.297, Y= 1.0498
      Lower left => X: 2.1937, Y= 1.0498

Para ver la salida completa, visite el repositorio de ejemplos de Azure GitHub para ver la salida del modelo de diseño.

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 referentes a la instancia de Form Recognizer en Azure Portal:

using Azure;
using Azure.AI.FormRecognizer.DocumentAnalysis;

//set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal to create your `AzureKeyCredential` and `FormRecognizerClient` instance
string endpoint = "<your-endpoint>";
string key = "<your-key>";
AzureKeyCredential credential = new AzureKeyCredential(key);
DocumentAnalysisClient client = new DocumentAnalysisClient(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 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))
    {
        if (vendorNameField.FieldType == DocumentFieldType.String)
        {
            string vendorName = vendorNameField.Value.AsString();
            Console.WriteLine($"Vendor Name: '{vendorName}', with confidence {vendorNameField.Confidence}");
        }
    }

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

    if (document.Fields.TryGetValue("Items", out DocumentField itemsField))
    {
        if (itemsField.FieldType == DocumentFieldType.List)
        {
            foreach (DocumentField itemField in itemsField.Value.AsList())
            {
                Console.WriteLine("Item:");

                if (itemField.FieldType == DocumentFieldType.Dictionary)
                {
                    IReadOnlyDictionary<string, DocumentField> itemFields = itemField.Value.AsDictionary();

                    if (itemFields.TryGetValue("Description", out DocumentField itemDescriptionField))
                    {
                        if (itemDescriptionField.FieldType == DocumentFieldType.String)
                        {
                            string itemDescription = itemDescriptionField.Value.AsString();

                            Console.WriteLine($"  Description: '{itemDescription}', with confidence {itemDescriptionField.Confidence}");
                        }
                    }

                    if (itemFields.TryGetValue("Amount", out DocumentField itemAmountField))
                    {
                        if (itemAmountField.FieldType == DocumentFieldType.Currency)
                        {
                            CurrencyValue itemAmount = itemAmountField.Value.AsCurrency();

                            Console.WriteLine($"  Amount: '{itemAmount.Symbol}{itemAmount.Amount}', with confidence {itemAmountField.Confidence}");
                        }
                    }
                }
            }
        }
    }

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

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

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

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.

Salida del modelo precompilado

Este es un fragmento de la salida esperada:

  Document 0:
  Vendor Name: 'CONTOSO LTD.', with confidence 0.962
  Customer Name: 'MICROSOFT CORPORATION', with confidence 0.951
  Item:
    Description: 'Test for 23 fields', with confidence 0.899
    Amount: '100', with confidence 0.902
  Sub Total: '100', with confidence 0.979

Para ver la salida completa, visite el repositorio de ejemplos de Azure GitHub para ver la salida del modelo de factura precompilada.

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. Consulte Java 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 Java Development Kit (JDK) versión 8 o posterior. Para obtener más información, consulte Microsoft Build of 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 la ventana de la consola (como cmd, PowerShell o Bash), cree un directorio para la aplicación llamado form-recognize-app y vaya hasta él.

   mkdir form-recognize-app && form-recognize-app
   

   mkdir form-recognize-app; cd form-recognize-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 de proyecto predeterminado (form-recognize-app) seleccionando Retorno 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("FormRecognizer")
   }
   repositories {
       mavenCentral()
   }
   dependencies {
       implementation group: 'com.azure', name: 'azure-ai-formrecognizer', version: '4.1.0'

   }

Creación de una aplicación Java

Para interactuar con el servicio Document Intelligence, tiene que crear una instancia de la clase DocumentAnalysisClient. Para ello, creará un elemento AzureKeyCredential con key de Azure Portal y una instancia de DocumentAnalysisClient 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:

   

1. Vaya al directorio java y cree un archivo denominado FormRecognizer.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 FormRecognizer.java.

2. Abra el archivo FormRecognizer.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 FormRecognizer.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.formrecognizer.documentanalysis.models.*;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClient;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClientBuilder;

import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.io.IOException;
import java.util.List;
import java.util.Arrays;
import java.time.LocalDate;
import java.util.Map;
import java.util.stream.Collectors;

public class FormRecognizer {

  // 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
    DocumentAnalysisClient client = new DocumentAnalysisClientBuilder()
      .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 < OperationResult, AnalyzeResult > analyzeLayoutResultPoller =
      client.beginAnalyzeDocumentFromUrl(modelId, documentUrl);

    AnalyzeResult analyzeLayoutResult = analyzeLayoutResultPoller.getFinalResult();

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

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

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

      // 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.getBoundingPolygon().toString(),
          documentSelectionMark.getConfidence()));
    });

    // tables
    List < DocumentTable > tables = analyzeLayoutResult.getTables();
    for (int i = 0; i < tables.size(); i++) {
      DocumentTable documentTable = tables.get(i);
      System.out.printf("Table %d has %d rows and %d columns.%n", i, documentTable.getRowCount(),
        documentTable.getColumnCount());
      documentTable.getCells().forEach(documentTableCell -> {
        System.out.printf("Cell '%s', has row index %d and column index %d.%n", documentTableCell.getContent(),
          documentTableCell.getRowIndex(), documentTableCell.getColumnIndex());
      });
      System.out.println();
    }
  }
  // Utility function to get the bounding polygon coordinates
  private static String getBoundingCoordinates(List < Point > boundingPolygon) {
    return boundingPolygon.stream().map(point -> String.format("[%.2f, %.2f]", point.getX(),
      point.getY())).collect(Collectors.joining(", "));
  }
}

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: form-recognize-app.

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

   gradle build
   

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

   gradle run
   

Salida del modelo de diseño

Este es un fragmento de la salida esperada:

  Table 0 has 5 rows and 3 columns.
  Cell 'Title of each class', has row index 0 and column index 0.
  Cell 'Trading Symbol', has row index 0 and column index 1.
  Cell 'Name of exchange on which registered', has row index 0 and column index 2.
  Cell 'Common stock, $0.00000625 par value per share', has row index 1 and column index 0.
  Cell 'MSFT', has row index 1 and column index 1.
  Cell 'NASDAQ', has row index 1 and column index 2.
  Cell '2.125% Notes due 2021', has row index 2 and column index 0.
  Cell 'MSFT', has row index 2 and column index 1.
  Cell 'NASDAQ', has row index 2 and column index 2.
  Cell '3.125% Notes due 2028', has row index 3 and column index 0.
  Cell 'MSFT', has row index 3 and column index 1.
  Cell 'NASDAQ', has row index 3 and column index 2.
  Cell '2.625% Notes due 2033', has row index 4 and column index 0.
  Cell 'MSFT', has row index 4 and column index 1.
  Cell 'NASDAQ', has row index 4 and column index 2.

Para ver la salida completa, visite el repositorio de ejemplos de Azure GitHub para ver la salida del modelo de diseño.

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 FormRecognizer.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.formrecognizer.documentanalysis.models.*;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClient;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClientBuilder;

import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.io.IOException;
import java.util.List;
import java.util.Arrays;
import java.time.LocalDate;
import java.util.Map;
import java.util.stream.Collectors;

public class FormRecognizer {

  // 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(final String[] args) throws IOException {

    // create your `DocumentAnalysisClient` instance and `AzureKeyCredential` variable
    DocumentAnalysisClient client = new DocumentAnalysisClientBuilder()
      .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";

    SyncPoller < OperationResult, AnalyzeResult > analyzeInvoicePoller = client.beginAnalyzeDocumentFromUrl(modelId, invoiceUrl);

    AnalyzeResult analyzeInvoiceResult = analyzeInvoicePoller.getFinalResult();

    for (int i = 0; i < analyzeInvoiceResult.getDocuments().size(); i++) {
      AnalyzedDocument 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.getValueAsString();
          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.getValueAsString();
          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.getValueAsString();
          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.getValueAsString();
          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.getValueAsString();
          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.getValueAsDate();
          System.out.printf("Invoice Date: %s, confidence: %.2f%n",
            invoiceDate, invoiceDateField.getConfidence());
        }
      }

      DocumentField invoiceTotalField = invoiceFields.get("InvoiceTotal");
      if (customerAddressRecipientField != null) {
        if (DocumentFieldType.DOUBLE == invoiceTotalField.getType()) {
          Double invoiceTotal = invoiceTotalField.getValueAsDouble();
          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.LIST == invoiceItemsField.getType()) {
          List < DocumentField > invoiceItems = invoiceItemsField.getValueAsList();
          invoiceItems.stream()
            .filter(invoiceItem -> DocumentFieldType.MAP == invoiceItem.getType())
            .map(documentField -> documentField.getValueAsMap())
            .forEach(documentFieldMap -> documentFieldMap.forEach((key, documentField) -> {

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

              if ("Description".equals(key)) {
                if (DocumentFieldType.STRING == documentField.getType()) {
                  String name = documentField.getValueAsString();
                  System.out.printf("Description: %s, confidence: %.2fs%n",
                    name, documentField.getConfidence());
                }
              }
              if ("Quantity".equals(key)) {
                if (DocumentFieldType.DOUBLE == documentField.getType()) {
                  Double quantity = documentField.getValueAsDouble();
                  System.out.printf("Quantity: %f, confidence: %.2f%n",
                    quantity, documentField.getConfidence());
                }
              }
              if ("UnitPrice".equals(key)) {
                if (DocumentFieldType.DOUBLE == documentField.getType()) {
                  Double unitPrice = documentField.getValueAsDouble();
                  System.out.printf("Unit Price: %f, confidence: %.2f%n",
                    unitPrice, documentField.getConfidence());
                }
              }
              if ("ProductCode".equals(key)) {
                if (DocumentFieldType.DOUBLE == documentField.getType()) {
                  Double productCode = documentField.getValueAsDouble();
                  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
   

Salida del modelo precompilado

Este es un fragmento de la salida esperada:

  ----------- Analyzing invoice  0 -----------
  Analyzed document has doc type invoice with confidence : 1.00
  Vendor Name: CONTOSO LTD., confidence: 0.92
  Vendor address: 123 456th St New York, NY, 10001, confidence: 0.91
  Customer Name: MICROSOFT CORPORATION, confidence: 0.84
  Customer Address Recipient: Microsoft Corp, confidence: 0.92
  Invoice ID: INV-100, confidence: 0.97
  Invoice Date: 2019-11-15, confidence: 0.97

Para ver la salida completa, visite el repositorio de ejemplos de Azure GitHub para ver la salida del modelo de factura precompilada.

Biblioteca cliente | Referencia de SDK | Referencia de API de REST | Paquete (npm) | 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:

• 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, consulte Node.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-form-recognizer y el paquete npm azure/identity:

   npm i @azure/ai-form-recognizer@5.0.0 @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 DocumentAnalysisClient. Para ello, creará un elemento AzureKeyCredential con key de Azure Portal y una instancia de DocumentAnalysisClient con AzureKeyCredential y el endpoint de Form Recognizer.

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.

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

 const { AzureKeyCredential, DocumentAnalysisClient } = require("@azure/ai-form-recognizer");

    // 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 = new DocumentAnalysisClient(endpoint, new AzureKeyCredential(key));

    const poller = await client.beginAnalyzeDocumentFromUrl("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
   

Salida del modelo de diseño

Este es un fragmento de la salida esperada:

Pages:
- Page 1 (unit: inch)
  8.5x11, angle: 0
  69 lines, 425 words
Tables:
- Extracted table: 3 columns, 5 rows (15 cells)

Para ver la salida completa, visite el repositorio de ejemplos de Azure GitHub para ver la salida del modelo de diseño.

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 {
    AzureKeyCredential,
    DocumentAnalysisClient
} = require("@azure/ai-form-recognizer");

// 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 = new DocumentAnalysisClient(endpoint, new AzureKeyCredential(key));

    const poller = await client.beginAnalyzeDocumentFromUrl("prebuilt-invoice", invoiceUrl);

    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 (page.lines && page.lines.length > 0) {
                console.log("  Lines:");

                for (const line of page.lines) {
                    console.log(`  - "${line.content}"`);

                    // The words of the line can also be iterated independently. The words are computed based on their
                    // corresponding spans.
                    for (const word of line.words()) {
                        console.log(`    - "${word.content}"`);
                    }
                }
            }
        }
    }

    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
   

Salida del modelo precompilado

Este es un fragmento de la salida esperada:

  Vendor Name: CONTOSO LTD.
  Customer Name: MICROSOFT CORPORATION
  Invoice Date: 2019-11-15T00:00:00.000Z
  Due Date: 2019-12-15T00:00:00.000Z
  Items:
  - <no product code>
    Description: Test for 23 fields
    Quantity: 1
    Date: undefined
    Unit: undefined
    Unit Price: 1
    Tax: undefined
    Amount: 100

Para ver la salida completa, visite el repositorio de ejemplos de Azure GitHub para ver la salida del modelo de factura precompilada.

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, consulte Introducció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-formrecognizer==3.3.0

Creación de la aplicación Python

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

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

2. Abra el archivo form_recognizer_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 form_recognizer_quickstart.py. Asegúrese de actualizar las variables de clave y punto de conexión con valores referentes a la instancia de Form Recognizer en Azure Portal:

# import libraries
import os
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential

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

def format_polygon(polygon):
    if not polygon:
        return "N/A"
    return ", ".join(["[{}, {}]".format(p.x, p.y) for p in polygon])

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_analysis_client = DocumentAnalysisClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller = document_analysis_client.begin_analyze_document_from_url(
            "prebuilt-layout", formUrl)
    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 box '{}'".format(
                    line_idx,
                    len(words),
                    line.content,
                    format_polygon(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 box '{}' and has a confidence of {}".format(
                    selection_mark.state,
                    format_polygon(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,
                    format_polygon(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 box '{}'".format(
                        region.page_number,
                        format_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 form_recognizer_quickstart.py.

2. Escriba el siguiente comando en el terminal:

   python form_recognizer_quickstart.py
   

Salida del modelo de diseño

Este es un fragmento de la salida esperada:

  ----Analyzing layout from page #1----
  Page has width: 8.5 and height: 11.0, measured with unit: inch
  ...Line # 0 has word count 2 and text 'UNITED STATES' within bounding box '[3.4915, 0.6828], [5.0116, 0.6828], [5.0116, 0.8265], [3.4915, 0.8265]'
  ......Word 'UNITED' has a confidence of 1.0
  ......Word 'STATES' has a confidence of 1.0
  ...Line # 1 has word count 4 and text 'SECURITIES AND EXCHANGE COMMISSION' within bounding box '[2.1937, 0.9061], [6.297, 0.9061], [6.297, 1.0498], [2.1937, 1.0498]'
  ......Word 'SECURITIES' has a confidence of 1.0
  ......Word 'AND' has a confidence of 1.0
  ......Word 'EXCHANGE' has a confidence of 1.0
  ......Word 'COMMISSION' has a confidence of 1.0
  ...Line # 2 has word count 3 and text 'Washington, D.C. 20549' within bounding box '[3.4629, 1.1179], [5.031, 1.1179], [5.031, 1.2483], [3.4629, 1.2483]'
  ......Word 'Washington,' has a confidence of 1.0
  ......Word 'D.C.' has a confidence of 1.0

Para ver la salida completa, visite el repositorio de ejemplos de Azure GitHub para ver la salida del modelo de diseño.

---

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.
• 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.

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.

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

# import libraries
import os
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential

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


def format_bounding_region(bounding_regions):
    if not bounding_regions:
        return "N/A"
    return ", ".join(
        "Page #{}: {}".format(region.page_number, format_polygon(region.polygon))
        for region in bounding_regions
    )


def format_polygon(polygon):
    if not polygon:
        return "N/A"
    return ", ".join(["[{}, {}]".format(p.x, p.y) for p in polygon])


def analyze_invoice():

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

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

    poller = document_analysis_client.begin_analyze_document_from_url(
        "prebuilt-invoice", invoiceUrl
    )
    invoices = poller.result()

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

2. Escriba el siguiente comando en el terminal:

   python form_recognizer_quickstart.py
   

Salida del modelo precompilado

Este es un fragmento de la salida esperada:

  --------Recognizing invoice #1--------
  Vendor Name: CONTOSO LTD. has confidence: 0.919
  Vendor Address: 123 456th St New York, NY, 10001 has confidence: 0.907
  Vendor Address Recipient: Contoso Headquarters has confidence: 0.919
  Customer Name: MICROSOFT CORPORATION has confidence: 0.84
  Customer Id: CID-12345 has confidence: 0.956
  Customer Address: 123 Other St, Redmond WA, 98052 has confidence: 0.909
  Customer Address Recipient: Microsoft Corp has confidence: 0.917
  Invoice Id: INV-100 has confidence: 0.972
  Invoice Date: 2019-11-15 has confidence: 0.971
  Invoice Total: CurrencyValue(amount=110.0, symbol=$) has confidence: 0.97
  Due Date: 2019-12-15 has confidence: 0.973

Para ver la salida completa, visite el repositorio de ejemplos de Azure GitHub para ver la salida del modelo de factura precompilada.

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

Característica	{modelID}	{your-document-url}
Documento general	prebuilt-document	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf
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
Tarjeta de presentación	prebuilt-businessCard	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/de5e0d8982ab754823c54de47a47e8e499351523/curl/form-recognizer/rest-api/business_card.jpg

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}/formrecognizer/documentModels/{modelID}:analyze?api-version=2023-07-31" -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}/formrecognizer/documentModels/{modelId}/analyzeResults/{resultId}?api-version=2023-07-31" -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": "2023-08-25T19:31:37Z",
    "lastUpdatedDateTime": "2023-08-25T19:31:43Z",
    "analyzeResult": {
        "apiVersion": "2023-07-31",
        "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.

• Encuentre más ejemplos en GitHub.