Introdução à Informação de Documentos

Importante

• O Reconhecimento de Formulários dos Serviços Cognitivos do Azure agora é IA do Azure para Informação de Documentos.
• Algumas plataformas ainda estão aguardando a atualização de renomeação.
• Todas as menções ao Reconhecimento de Formulários ou à Informação de Documentos na nossa documentação se referem ao mesmo serviço do Azure.

Este conteúdo se aplica a: v3.1 (GA) Versões anteriores: v3.0 v2.1

• Introdução ao Reconhecimento de Formulários do Azure na versão mais recente para disponibilidade geral (2023-07-31).

• A IA do Azure para Informação de Documentos / Reconhecimento de Formulários é um serviço da IA do Azure baseado em nuvem que usa modelos de aprendizado de máquina para extrair pares de chave-valor, texto, tabelas e dados importantes dos documentos.

• Você pode integrar os modelos de processamento de documentos com facilidade nos seus fluxos de trabalho e aplicativos usando um SDK na linguagem de programação ou chamando a API REST.

• Para um início rápido, recomendamos usar o serviço gratuito quando estiver aprendendo a tecnologia. Lembre-se de que o número de páginas gratuitas é limitado a 500 por mês.

Para saber mais sobre os recursos da API e ver as opções de desenvolvimento, visite a página Visão geral.

Biblioteca de clientes | Referência de SDK | Referência da API | Pacote (NuGet) | Amostras | Versões com suporte de API REST

Nesse início rápido, utilize os seguintes recursos para analisar e extrair dados e valores de formulários e documentos:

• Modelo de layout – analisar e extrair tabelas, linhas, palavras e marcas de seleção como botões de rádio e caixas de seleção em documentos, sem a necessidade de treinar um modelo.

• Modelo predefinido – Analisar e extrair campos comuns de tipos de documentos específicos usando um modelo predefinido.

Pré-requisitos

• Assinatura do Azure – crie uma gratuitamente.

• A versão atual do IDE do Visual Studio.

• Um recurso dos serviços de IA do Azure ou do Reconhecimento de Formulários. Depois de ter sua assinatura do Azure, crie um recurso de serviço único ou multisserviço de IA do Azure, no portal do Azure, para obter sua chave e ponto de extremidade do serviço.

• Use o tipo de preço gratuito (F0) para experimentar o serviço e atualizar mais tarde para um nível pago para produção.

Dica

Crie um recurso de serviços de IA do Azure se você planeja acessar vários serviços de IA do Azure em um único ponto de extremidade/chave. Para acesso somente de Reconhecimento de Formulários, crie um recurso Reconhecimento de Formulários. Observe que você precisará de um recurso de serviço único se pretende usar a autenticação do Microsoft Entra.

• Após a implantação do recurso, selecione Ir para o recurso. Você vai precisar da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo à API do Reconhecimento de Formulários. Você vai colar a chave e o ponto de extremidade no código mais adiante no guia de início rápido:

  

Configuração

1. Inicie o Visual Studio.

2. Na página Iniciar, escolha Criar um projeto.

   

3. Na página Criar um projeto, insira console na caixa de pesquisa. Escolha o modelo Aplicativo de Console e selecione Avançar.

   

4. Na janela do diálogo Configurar seu novo projeto, insira form_recognizer_quickstart na caixa Nome do projeto. Em seguida, escolha Avançar.

5. Na janela de diálogo Informações adicionais, selecione .NET 8.0 (Suporte de longo prazo) e, em seguida, selecione Criar.

   

Instalar a biblioteca de clientes com o NuGet

1. Clique com o botão direito do mouse no projeto form_recognizer_quickstart e selecione Gerenciar Pacotes do NuGet....

   

2. Selecione a guia Procurar e digite Azure.AI.FormRecognizer. Selecione a versão 4.1.0 no menu suspenso

   

Crie seu aplicativo

Para interagir com o serviço Reconhecimento de Formulários, você precisa criar uma instância da classe DocumentAnalysisClient. Para fazer isso, você cria uma AzureKeyCredential com sua key no portal do Azure e uma instância de DocumentAnalysisClient com a AzureKeyCredential e o endpoint do Reconhecimento de Formulários.

Observação

• A partir do .NET 6, os novos projetos que usam o modelo console geram um novo estilo de programa diferente das versões anteriores.
• A nova saída usa recursos recentes do C# que simplificam a codificação.
• Ao usar a versão mais recente, você só precisa escrever o corpo do método Main. Você não precisa incluir instruções de nível superior, diretivas de uso globais nem diretivas de uso implícitas.
• Para mais informações, consulte Novos modelos C# geram declarações de nível superior.

1. Abra o arquivo Program.cs.

2. Exclua o código pré-existente, incluindo a linha Console.Writeline("Hello World!") e selecione um dos exemplos de código a seguir para copiar e colar no arquivo Program.cs do aplicativo:

   • Modelo de layout

   • Modelo predefinido

Importante

Lembre-se de remover a chave do seu código quando terminar e nunca poste-a publicamente. Para produção, use uma maneira segura de armazenar e acessar suas credenciais, como o Azure Key Vault. Para obter mais informações, confira a segurança dos serviços de IA do Azure.

Modelo de layout

Extraia texto, marcas de seleção, estilos de texto, estruturas de tabela e as coordenadas de região delimitadora de documentos.

• Para este exemplo, você precisará de um arquivo de documento de um URI. Você pode usar nosso documento de exemplo para este início rápido.
• Adicione o valor de URI do arquivo à variável Uri fileUri na parte superior do script.
• Para extrair o layout de um determinado arquivo em um URI, use o método StartAnalyzeDocumentFromUri e passe prebuilt-layout como a ID do modelo. O valor retornado é um objeto AnalyzeResult que contém dados do documento enviado.

Adicione o seguinte exemplo de código ao arquivo Program.cs. Lembre-se de atualizar as variáveis de chave e de ponto de extremidade com os valores da sua instância do Reconhecimento de Formulários do portal do Azure:

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

Executar seu aplicativo

Depois de adicionar um exemplo de código ao seu aplicativo, escolha o botão Iniciar verde ao lado de formRecognizer_quickstart para compilar e executar o programa ou pressione F5.

Saída do modelo de layout

Aqui está um trecho da saída 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 exibir toda a saída, acesse o repositório de amostras do Azure no GitHub para exibir a saída do modelo de layout.

Modelo predefinido

Analise e extraia campos comuns de tipos de documentos específicos usando um modelo predefinido. Neste exemplo, analisamos uma fatura usando o modelo de fatura predefinido.

Dica

Você não está limitado a faturas – há vários modelos predefinidos para escolher, cada um deles com o próprio conjunto de campos com suporte. O modelo a ser utilizado para a operação analyze depende do tipo de documento a analisar. Consulte extração de dados do modelo.

• Analise uma fatura usando o modelo de fatura predefinido. Você pode usar um documento de fatura de exemplo para este início rápido.
• Adicionamos o valor de URI do arquivo à variável Uri invoiceUri na parte superior do arquivo Program.cs.
• Para analisar um dado arquivo em um URI, use o método StartAnalyzeDocumentFromUri e passe prebuilt-invoice como a ID do modelo. O valor retornado é um objeto AnalyzeResult que contém dados do documento enviado.
• Para simplificar, todos os pares chave-valor que o serviço retorna não são mostrados aqui. Para ver a lista de todos os campos compatíveis e tipos correspondentes, confira nossa página de conceito da Fatura.

Adicione o seguinte exemplo de código ao seu arquivo Program.cs. Lembre-se de atualizar as variáveis de chave e de ponto de extremidade com os valores da sua instância do Reconhecimento de Formulários do portal do Azure:

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

Executar seu aplicativo

Depois de adicionar um exemplo de código ao seu aplicativo, escolha o botão Iniciar verde ao lado de formRecognizer_quickstart para compilar e executar o programa ou pressione F5.

Saída de modelo predefinido

Aqui está um trecho da saída 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 exibir toda a saída, acesse o repositório de amostras do Azure no GitHub para exibir a saída do modelo de fatura predefinido.

Biblioteca de clientes | Referência de SDK | Referência da API REST | Pacote (Maven) | Amostras| Versões com suporte de API REST

Nesse início rápido, utilize os seguintes recursos para analisar e extrair dados e valores de formulários e documentos:

• Layout– analise e extraia tabelas, linhas, palavras e marcas de seleção, como botões de opção e caixas de seleção em documentos, sem a necessidade de treinar um modelo.

• Fatura predefinida – Analise e extraia campos comuns de tipos de documentos específicos usando um modelo pré-treinado.

Pré-requisitos

• Assinatura do Azure – crie uma gratuitamente.

• A versão mais recente do Visual Studio Code ou do seu IDE preferido. Consulte Java no Visual Studio Code.

  Dica

  • Visual Studio Code oferece um Pacote de Codificação para Java para Windows e macOS. O pacote de codificação é um pacote de VS Code, o JDK (Java Development Kit) e uma coleção de extensões sugeridas pela Microsoft. O Pacote de Codificação também pode ser usado para corrigir um ambiente de desenvolvimento existente.
  • Se você estiver usando VS Code e o Pacote de Codificação para Java, instale a extensão Gradle para Java.

• Se não estiver usando Visual Studio Code, você deverá ter o seguinte instalado em seu ambiente de desenvolvimento:

  • Um Java Development Kit (JDK) versão 8 ou posterior. Para mais informações, consulte Microsoft Build do OpenJDK.

  • Gradle, versão 6.8 ou posterior.

• Um recurso de Inteligência de Documento ou serviços de IA do Azure. Assim que tiver sua assinatura do Azure, crie um recurso serviço único ou multisserviço de Informação de Documentos no portal do Azure para obter sua chave e seu ponto de extremidade. Use o tipo de preço gratuito (F0) para experimentar o serviço e atualizar mais tarde para um nível pago para produção.

  Dica

  Crie um recurso de serviços de IA do Azure se você planeja acessar vários serviços de IA do Azure em um único ponto de extremidade/chave. Somente para acesso ao Document Intelligence, crie um recurso do Document Intelligence. Observe que você precisará de um recurso de serviço único se pretende usar a autenticação do Microsoft Entra.

• Após a implantação do recurso, selecione Ir para o recurso. Você precisará da chave e do ponto de extremidade do recurso que você criar para conectar seu aplicativo à API de Informação de Documentos. Mais adiante, você vai colar a chave e o ponto de extremidade no código:

  

Configuração

Criar um novo projeto Gradle

1. Na janela de console (como cmd, PowerShell ou Bash), crie um novo diretório para seu aplicativo chamado form-recognize-app e navegue até ele.

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

   mkdir form-recognize-app; cd form-recognize-app
   

2. Execute o comando gradle init em seu diretório de trabalho. Esse comando cria arquivos de build essenciais para o Gradle, incluindo o build.gradle.kts, que é usado no runtime para criar e configurar seu aplicativo.

   gradle init --type basic
   

3. Quando solicitado a escolher uma DSL, escolha Kotlin.

4. Aceite o nome do projeto padrão (form-recognize-app) selecionando Return ou ENTER.

Instalar a biblioteca de clientes

Este início rápido usa o gerenciador de dependência do Gradle. Você pode encontrar a biblioteca de clientes e informações para outros gerenciadores de dependência no Repositório Central do Maven.

Abra o arquivo build.gradle.kts do projeto em seu IDE. Copie e cole o código a seguir para incluir a biblioteca de clientes como uma instrução implementation, juntamente com as configurações e os plug-ins necessários.

   plugins {
       java
       application
   }
   application {
       mainClass.set("FormRecognizer")
   }
   repositories {
       mavenCentral()
   }
   dependencies {
       implementation group: 'com.azure', name: 'azure-ai-formrecognizer', version: '4.1.0'

   }

Criar um aplicativo Java

Para interagir com o serviço de Informação de Documentos, você precisa criar uma instância da classe DocumentAnalysisClient. Para fazê-lo, você deve criar uma AzureKeyCredential com sua key no portal do Azure e uma instância de DocumentAnalysisClient com a AzureKeyCredential e seu endpoint de Informação de Documentos.

1. No diretório doc-intel-app, execute o seguinte comando:

   mkdir -p src/main/java
   

   Você cria a seguinte estrutura de diretório:

   

1. Navegue até o diretório do java e crie um arquivo chamado FormRecognizer.java.

   Dica

   • Você pode criar um arquivo usando o PowerShell.
   • Abra uma janela do PowerShell no diretório do projeto mantendo a tecla Shift e clicando com o botão direito do mouse na pasta.
   • No terminal, digite o comando New-Item FormRecognizer.java.

2. Abra o arquivo FormRecognizer.java . Copie e cole um dos seguintes exemplos de código no aplicativo:

   • Layout

   • Fatura predefinida

Importante

Lembre-se de remover a chave do seu código quando terminar e nunca poste-a publicamente. Para produção, use uma maneira segura de armazenar e acessar suas credenciais, como o Azure Key Vault. Para obter mais informações, confira a segurança dos serviços de IA do Azure.

Modelo de layout

Extraia texto, marcas de seleção, estilos de texto, estruturas de tabela e as coordenadas de região delimitadora de documentos.

• Para este exemplo, você precisará de um arquivo de documento em um URI. Você pode usar nosso documento de exemplo para este início rápido.
• Para analisar um determinado arquivo em um URI, você usará o método beginAnalyzeDocumentFromUrl e passará prebuilt-layout como ID do modelo. O valor retornado é um objeto AnalyzeResult que contém dados sobre o documento enviado.
• Adicionamos o valor de URI do arquivo à variável documentUrl no método Main.

Adicione o exemplo de código a seguir ao arquivo FormRecognizer.java. Certifique-se de atualizar as variáveis de chave e ponto de extremidade com os valores da sua instância de Informação de Documentos no portal do Azure:

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

Compile e execute o aplicativo

Após adicionar um código de exemplo ao seu aplicativo, navegue de volta para o diretório principal do projeto — form-recognize-app.

1. Crie seu aplicativo com o comando build:

   gradle build
   

2. Execute seu aplicativo com o comando run:

   gradle run
   

Saída do modelo de layout

Aqui está um trecho da saída 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 exibir toda a saída, acesse o repositório de amostras do Azure no GitHub para exibir a saída do modelo de layout.

Modelo predefinido

Analise e extraia campos comuns de tipos de documentos específicos usando um modelo predefinido. Neste exemplo, analisamos uma fatura usando o modelo de fatura predefinido.

Dica

Você não está limitado a faturas – há vários modelos predefinidos para escolher, cada um deles com o próprio conjunto de campos com suporte. O modelo a ser utilizado para a operação analyze depende do tipo de documento a analisar. Consulte extração de dados do modelo.

• Analise uma fatura usando o modelo de fatura predefinido. Você pode usar um documento de fatura de exemplo para este início rápido.
• Adicione o valor de URL do arquivo à variável invoiceUrl na parte superior do arquivo.
• Para analisar um determinado arquivo em um URI, você usará o método beginAnalyzeDocuments e passará PrebuiltModels.Invoice como ID do modelo. O valor retornado é um objeto result que contém dados sobre o documento enviado.
• Para simplificar, todos os pares chave-valor que o serviço retorna não são mostrados aqui. Para ver a lista de todos os campos compatíveis e tipos correspondentes, confira nossa página de conceito da Fatura.

Adicione o exemplo de código a seguir ao arquivo FormRecognizer.java. Certifique-se de atualizar as variáveis de chave e ponto de extremidade com os valores da sua instância de Informação de Documentos no portal do Azure:

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

Compile e execute o aplicativo

Após adicionar um código de exemplo ao seu aplicativo, navegue de volta para o diretório principal do projeto — doc-intel-app.

1. Crie seu aplicativo com o comando build:

   gradle build
   

2. Execute seu aplicativo com o comando run:

   gradle run
   

Saída de modelo predefinido

Aqui está um trecho da saída 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 exibir toda a saída, acesse o repositório de amostras do Azure no GitHub para exibir a saída do modelo de fatura predefinido.

Biblioteca de clientes | Referência de SDK | Referência da API REST | Pacote (npm) | Amostras |Versões com suporte de API REST

Nesse início rápido, utilize os seguintes recursos para analisar e extrair dados e valores de formulários e documentos:

• Layout– analise e extraia tabelas, linhas, palavras e marcas de seleção, como botões de opção e caixas de seleção em documentos, sem a necessidade de treinar um modelo.

• Fatura predefinida – Analise e extraia campos comuns de tipos de documentos específicos usando um modelo de fatura pré-treinado.

Pré-requisitos

• Assinatura do Azure – crie uma gratuitamente.

• A versão mais recente do Visual Studio Code ou do seu IDE preferido. Para mais informações, consulte Node.js no Visual Studio Code.

• A versão LTS mais recente do Node.js.

• Um recurso de Inteligência de Documento ou serviços de IA do Azure. Assim que tiver sua assinatura do Azure, crie um recurso serviço único ou multisserviço de Informação de Documentos no portal do Azure para obter sua chave e seu ponto de extremidade. Use o tipo de preço gratuito (F0) para experimentar o serviço e atualizar mais tarde para um nível pago para produção.

  Dica

  Crie um recurso de serviços de IA do Azure se você planeja acessar vários serviços de IA do Azure em um único ponto de extremidade/chave. Somente para acesso ao Document Intelligence, crie um recurso do Document Intelligence. Observe que você precisará de um recurso de serviço único se pretende usar a autenticação do Microsoft Entra.

• Após a implantação do recurso, selecione Ir para o recurso. Você precisará da chave e do ponto de extremidade do recurso que você criar para conectar seu aplicativo à API de Informação de Documentos. Você vai colar a chave e o ponto de extremidade no código mais adiante no guia de início rápido:

  

Configuração

1. Crie um aplicativo Node.js Express: em uma janela de console (como cmd, PowerShell ou Bash), crie um diretório para seu aplicativo doc-intel-app e navegue até ele.

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

2. Execute o comando npm init para inicializar o aplicativo e fazer scaffold do projeto.

   npm init
   

3. Especifique os atributos do projeto usando os prompts apresentados no terminal.

   • Os atributos mais importantes são nome, número de versão e ponto de entrada.
   • É recomendável manter index.js para o nome do ponto de entrada. Descrição, comando de teste, repositório GitHub, palavras-chave, autor e informações de licença são atributos opcionais - eles podem ser ignorados para este projeto.
   • Aceite as sugestões entre parênteses selecionando Retornar ou Enter.
   • Depois que você concluir os prompts, um arquivo package.json será criado no diretório doc-intel-app.

4. Instale o pacote npm ai-form-recognizer da biblioteca de clientes azure/identity:

   npm i @azure/ai-form-recognizer@5.0.0 @azure/identity
   

   • O arquivo package.json do seu aplicativo é atualizado com as dependências.

5. Crie um novo arquivo chamado index.js no diretório do aplicativo.

   Dica

   • Você pode criar um arquivo usando o PowerShell.
   • Abra uma janela do PowerShell no diretório do projeto mantendo a tecla Shift e clicando com o botão direito do mouse na pasta.
   • No terminal, digite o comando New-Item index.js.

Crie seu aplicativo

Para interagir com o serviço de Informação de Documentos, você precisa criar uma instância da classe DocumentAnalysisClient. Para fazer isso, você cria uma AzureKeyCredential com sua key no portal do Azure e uma instância de DocumentAnalysisClient com a AzureKeyCredential e o endpoint do Reconhecimento de Formulários.

1. Abra o arquivo index.js no Visual Studio Code ou seu IDE favorito. Copie e cole um dos seguintes exemplos de código no aplicativo:

   • Layout

   • Fatura predefinida

Importante

Lembre-se de remover a chave do seu código quando terminar e nunca poste-a publicamente. Para produção, use uma maneira segura de armazenar e acessar suas credenciais, como o Azure Key Vault. Para obter mais informações, confira a segurança dos serviços de IA do Azure.

Modelo de layout

Extraia texto, marcas de seleção, estilos de texto, estruturas de tabela e as coordenadas de região delimitadora de documentos.

• Para este exemplo, você precisará de um arquivo de documento de uma URL. Você pode usar nosso documento de exemplo para este início rápido.
• Adicione o valor de URL do arquivo à variável formUrl na parte superior do arquivo.
• Para analisar um dado arquivo em um URL, use o método beginAnalyzeDocuments e passe prebuilt-layout como a ID do modelo.

Adicione o exemplo de código a seguir ao arquivo index.js. Certifique-se de atualizar as variáveis de chave e ponto de extremidade com os valores da sua instância de Informação de Documentos no portal do Azure:

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

Executar seu aplicativo

Depois de adicionar um código de exemplo ao aplicativo, execute o programa:

1. Navegue até a pasta onde você tem seu aplicativo de Informação de Documentos (doc-intel-app).

2. No terminal, digite o seguinte comando:

   node index.js
   

Saída do modelo de layout

Aqui está um trecho da saída esperada:

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

Para exibir toda a saída, acesse o repositório de amostras do Azure no GitHub para exibir a saída do modelo de layout.

Modelo predefinido

Neste exemplo, analisamos uma fatura usando o modelo de fatura predefinido.

Dica

Você não está limitado a faturas – há vários modelos predefinidos para escolher, cada um deles com o próprio conjunto de campos com suporte. O modelo a ser utilizado para a operação analyze depende do tipo de documento a analisar. Consulte extração de dados do modelo.

• Analise uma fatura usando o modelo de fatura predefinido. Você pode usar um documento de fatura de exemplo para este início rápido.
• Adicione o valor de URL do arquivo à variável invoiceUrl na parte superior do arquivo.
• Para analisar um determinado arquivo em um URI, você usará o método beginAnalyzeDocuments e passará PrebuiltModels.Invoice como ID do modelo. O valor retornado é um objeto result que contém dados sobre o documento enviado.
• Para simplificar, todos os pares chave-valor que o serviço retorna não são mostrados aqui. Para ver a lista de todos os campos compatíveis e tipos correspondentes, confira nossa página de conceito da Fatura.

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

Executar seu aplicativo

Depois de adicionar um código de exemplo ao aplicativo, execute o programa:

1. Navegue até a pasta onde você tem seu aplicativo de Informação de Documentos (doc-intel-app).

2. No terminal, digite o seguinte comando:

   node index.js
   

Saída de modelo predefinido

Aqui está um trecho da saída 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 exibir toda a saída, acesse o repositório de amostras do Azure no GitHub para exibir a saída do modelo de fatura predefinido.

Biblioteca de clientes |Referência de SDK | Referência da API REST | Pacote (PyPi) | Amostras | Versões com suporte de API REST

Nesse início rápido, use os seguintes recursos para analisar e extrair dados de formulários e documentos:

• Layout – analise e extraia tabelas, linhas, palavras e marcas de seleção, como botões de rádio e caixas de seleção, e pares chave-valor, sem a necessidade de treinar um modelo.

• Fatura predefinida – Analise e extraia campos comuns de tipos de documentos específicos usando um modelo pré-treinado.

Pré-requisitos

• Assinatura do Azure – crie uma gratuitamente.

• Python 3.7 ou posterior.

  • A instalação do Python deve incluir o pip. Você pode executar pip --version na linha de comando para verificar se o pip está instalado. Instale a versão mais recente do Python para obter o pip.

• A versão mais recente do Visual Studio Code ou do seu IDE preferido. Para mais informações, consulte Introdução ao Python no Visual Studio Code.

• Um recurso de Inteligência de Documento ou serviços de IA do Azure. Assim que tiver sua assinatura do Azure, crie um recurso serviço único ou multisserviço de Informação de Documentos no portal do Azure para obter sua chave e seu ponto de extremidade. Use o tipo de preço gratuito (F0) para experimentar o serviço e atualizar mais tarde para um nível pago para produção.

Dica

Crie um recurso de serviços de IA do Azure se você planeja acessar vários serviços de IA do Azure em um único ponto de extremidade/chave. Somente para acesso ao Document Intelligence, crie um recurso do Document Intelligence. Observe que você precisará de um recurso de serviço único se pretende usar a autenticação do Microsoft Entra.

• Após a implantação do recurso, selecione Ir para o recurso. Você precisará da chave e do ponto de extremidade do recurso que você criar para conectar seu aplicativo à API de Informação de Documentos. Você vai colar a chave e o ponto de extremidade no código mais adiante no guia de início rápido:

  

Configuração

Abra uma janela de terminal no seu ambiente local e instale a biblioteca de clientes da IA do Azure para Informação de Documentos para Python com pip:

pip install azure-ai-formrecognizer==3.3.0

Criar seu aplicativo Python

Para interagir com o serviço de Informação de Documentos, você precisa criar uma instância da classe DocumentAnalysisClient. Para fazê-lo, você deve criar uma AzureKeyCredential com sua key no portal do Azure e uma instância de DocumentAnalysisClient com a AzureKeyCredential e seu endpoint de Informação de Documentos.

1. Criar um novo arquivo Python chamado form_recognizer_quickstart.py no seu editor ou IDE preferido.

2. Abra o arquivo form_recognizer_quickstart.py e selecione um dos exemplos de código a seguir para copiar e colar no aplicativo:

   • Layout

   • Fatura predefinida

Importante

Lembre-se de remover a chave do seu código quando terminar e nunca poste-a publicamente. Para produção, use uma maneira segura de armazenar e acessar suas credenciais, como o Azure Key Vault. Para obter mais informações, confira a segurança dos serviços de IA do Azure.

Modelo de layout

Extraia texto, marcas de seleção, estilos de texto, estruturas de tabela e as coordenadas de região delimitadora de documentos.

• Para este exemplo, você precisará de um arquivo de documento de uma URL. Você pode usar nosso documento de exemplo para este início rápido.
• Adicionamos o valor da URL do arquivo à variável formUrl na função analyze_layout.

Para analisar um determinado arquivo em uma URL, você usará o método begin_analyze_document_from_url e passará em prebuilt-layout como ID do modelo. O valor retornado é um objeto result que contém dados sobre o documento enviado.

Adicione o código de exemplo a seguir ao aplicativo form_recognizer_quickstart.py. Lembre-se de atualizar as variáveis de chave e de ponto de extremidade com os valores da sua instância do Reconhecimento de Formulários do portal do Azure:

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

Executar o aplicativo

Depois de adicionar um código de exemplo ao aplicativo, compile e execute o programa:

1. Navegue até a pasta em que você tem o arquivo form_recognizer_quickstart.py.

2. No terminal, digite o seguinte comando:

   python form_recognizer_quickstart.py
   

Saída do modelo de layout

Aqui está um trecho da saída 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 exibir toda a saída, acesse o repositório de amostras do Azure no GitHub para exibir a saída do modelo de layout.

---

Modelo predefinido

Analise e extraia campos comuns de tipos de documentos específicos usando um modelo predefinido. Neste exemplo, analisamos uma fatura usando o modelo de fatura predefinido.

Dica

Você não está limitado a faturas – há vários modelos predefinidos para escolher, cada um deles com o próprio conjunto de campos com suporte. O modelo a ser utilizado para a operação analyze depende do tipo de documento a analisar. Consulte extração de dados do modelo.

• Analise uma fatura usando o modelo de fatura predefinido. Você pode usar um documento de fatura de exemplo para este início rápido.
• Adicione o valor de URL do arquivo à variável invoiceUrl na parte superior do arquivo.
• Para simplificar, todos os pares chave-valor que o serviço retorna não são mostrados aqui. Para ver a lista de todos os campos compatíveis e tipos correspondentes, confira nossa página de conceito da Fatura.

Para analisar um determinado arquivo em um URI, você usará o método begin_analyze_document_from_url e passará prebuilt-invoice como ID do modelo. O valor retornado é um objeto result que contém dados sobre o documento enviado.

Adicione o código de exemplo a seguir ao aplicativo form_recognizer_quickstart.py. Lembre-se de atualizar as variáveis de chave e de ponto de extremidade com os valores da sua instância do Reconhecimento de Formulários do portal do Azure:

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

Executar o aplicativo

Depois de adicionar um código de exemplo ao aplicativo, compile e execute o programa:

1. Navegue até a pasta em que você tem o arquivo form_recognizer_quickstart.py.

2. No terminal, digite o seguinte comando:

   python form_recognizer_quickstart.py
   

Saída de modelo predefinido

Aqui está um trecho da saída 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 exibir toda a saída, acesse o repositório de amostras do Azure no GitHub para exibir a saída do modelo de fatura predefinido.

| API REST da Informação de Documentos | SDKS do Azure com Suporte |

Nesse início rápido, saiba como usar a API REST do Informação de Documentos para analisar e extrair dados e valores de documentos:

Pré-requisitos

• Assinatura do Azure – Criar uma gratuitamente

• ferramenta de linha de comando curl instalada.

  • Windows
  • Mac ou Linux

• PowerShell versão 7* e superiores (ou um aplicativo de linha de comando semelhante):

  • Windows
  • macOS
  • Linux

• Para verificar sua versão do PowerShell, digite o seguinte comando em relação ao sistema operacional:

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

• Um recurso de Informação de Documentos (serviço único) ou serviços de IA do Azure (multisserviço. Assim que tiver sua assinatura do Azure, crie um recurso serviço único ou multisserviço de Informação de Documentos no portal do Azure para obter sua chave e seu ponto de extremidade. Use o tipo de preço gratuito (F0) para experimentar o serviço e atualizar mais tarde para um nível pago para produção.

Dica

Crie um recurso de serviços de IA do Azure se você planeja acessar vários serviços de IA do Azure em um único ponto de extremidade/chave. Somente para acesso ao Document Intelligence, crie um recurso do Document Intelligence. Observe que você precisará de um recurso de serviço único se pretende usar a autenticação do Microsoft Entra.

• Após a implantação do recurso, selecione Ir para o recurso. Você precisará da chave e do ponto de extremidade do recurso que você criar para conectar seu aplicativo à API de Informação de Documentos. Você vai colar a chave e o ponto de extremidade no código mais adiante no guia de início rápido:

  

Analisar documentos e obter resultados

Uma solicitação POST é usada para analisar documentos com um modelo predefinido ou personalizado. Uma solicitação GET é usada para recuperar o resultado de uma chamada de análise de documento. O modelId é usado com POST e resultId, com operações GET.

Analisar documento (solicitação POST)

Antes de executar o comando cURL, faça as seguintes alterações na solicitação post:

1. Substitua {endpoint} pelo valor do ponto de extremidade da sua instância de Informação de Documentos no portal do Azure.

2. Substitua {key} pelo valor da chave da sua instância de Informação de Documentos no portal do Azure.

3. Usando a seguinte tabela como referência, substitua {modelID} e {your-document-url} por valores que você queira.

4. Você vai precisar de um arquivo de documento em uma URL. Neste início rápido, você pode usar os formulários de exemplo fornecidos na seguinte tabela para cada recurso:

Documentos de amostra

Recurso	{modelID}	{your-document-url}
Documento geral	prebuilt-document	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf
Leitura	prebuilt-read	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/read.png
Layout	prebuilt-layout	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/layout.png
cartão do seguro de saúde	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
Fatura	prebuilt-invoice	https://github.com/Azure-Samples/cognitive-services-REST-api-samples/raw/master/curl/form-recognizer/rest-api/invoice.pdf
Receipt	prebuilt-receipt	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/receipt.png
Documento de identificação	prebuilt-idDocument	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/identity_documents.png
Cartão de visita	prebuilt-businessCard	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/de5e0d8982ab754823c54de47a47e8e499351523/curl/form-recognizer/rest-api/business_card.jpg

Importante

Lembre-se de remover a chave do seu código quando terminar e nunca poste-a publicamente. Para produção, use uma maneira segura de armazenar e acessar suas credenciais, como o Azure Key Vault. Para obter mais informações, consulte a segurança dos serviços de IA do Azure.

Solicitação 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}'}"

Resposta POST (resultID)

Você vai receber uma resposta 202 (Success) com um cabeçalho somente leitura Operation-Location. O valor desse cabeçalho contém um resultID que pode ser consultado para obter o status da operação assíncrona e recuperar os resultados usando uma solicitação GET com a mesma chave de assinatura de recurso:

Obter resultados da análise (Solicitação GET)

Após chamar a API Analyze document, chame a API Get analyze result para obter o status da operação e os dados extraídos. Antes de executar o comando, faça essas alterações:

1. Substitua o cabeçalho {resultID} Operation-Location da resposta POST.

2. Substitua {key} pelo valor da chave da sua instância de Informação de Documentos no portal do Azure.

Solicitação GET

curl -v -X GET "{endpoint}/formrecognizer/documentModels/{modelId}/analyzeResults/{resultId}?api-version=2023-07-31" -H "Ocp-Apim-Subscription-Key: {key}"

Examinar a resposta

Você receberá uma resposta 200 (Success) com uma saída em JSON. O primeiro campo, "status", indica o status da operação. Se a operação não estiver concluída, o valor de "status" será "running" ou "notStarted", e você deverá chamar a API novamente, manualmente ou por meio de um script. Recomendamos dar um intervalo de um segundo ou mais entre chamadas.

Resposta de exemplo para fatura pré-criada

{
    "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 com suporte

Os modelos pré-criados extraem conjuntos predefinidos de campos de documento. Consulte Extração de dados de modelo para nomes de campo extraídos, tipos, descrições e exemplos.

É isso, parabéns!

Nesse guia de início rápido, você usou o modelo da Informação de Documentos para analisar diversos formulários e documentos. A seguir, explore o Estúdio de Informação de Documentos e a documentação de referência para se aprofundar e saber mais sobre a API de Informação de Documentos.

Próximas etapas

• Para obter uma experiência aprimorada e modelos de qualidade avançada, experimente o Estúdio da Informação de Documentos

• Para a migração v3.1 para v4.0, consulte Guias de Migração do Changelog.

• Confira mais exemplos no GitHub.