Introdução à Inteligência Documental

Importante

• O Azure Cognitive Services Form Recognizer agora é o Azure AI Document Intelligence.
• Algumas plataformas ainda aguardam a atualização de renomeação.
• Todas as menções ao Reconhecedor de Formulários ou Inteligência de Documentos em nossa documentação referem-se ao mesmo serviço do Azure.

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

• Introdução à versão mais recente do GA do Azure Form Recognizer (2023-07-31).

• O Azure AI Document Intelligence / Form Recognizer é um serviço de IA do Azure baseado na nuvem que utiliza aprendizagem automática para extrair pares chave-valor, texto, tabelas e dados chave dos seus documentos.

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

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

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

Referência | do SDK da biblioteca | cliente Pacote de referência | da API (NuGet) | Exemplos | Versão suportada da API REST

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

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

• Modelo pré-construído—Analise e extraia campos comuns de tipos de documentos específicos usando um modelo pré-construído.

Pré-requisitos

• Subscrição do Azure - Crie uma gratuitamente.

• A versão atual do Visual Studio IDE.

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

• Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção.

Gorjeta

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 Reconhecimento de Formulário, crie um recurso de Reconhecimento de Formulário. Observe que você precisará de um recurso de serviço único se pretender usar a autenticação do Microsoft Entra.

• Depois que o recurso for implantado, selecione Ir para o recurso. Você precisa da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo à API do Form Recognizer. Cole sua chave e ponto de extremidade no código mais adiante no início rápido:

  

Configurar

1. Inicie o Visual Studio.

2. Na página inicial, escolha Criar um novo projeto.

   

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

   

4. Na janela de diálogo Configurar seu novo projeto, digite 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 cliente com o NuGet

1. Clique com o botão direito do mouse em seu projeto form_recognizer_quickstart e selecione Gerenciar pacotes NuGet... .

   

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

   

Compilar a aplicação

Para interagir com o serviço Form Recognizer, você precisa criar uma instância da DocumentAnalysisClient classe. Para fazer isso, crie um AzureKeyCredential com o seu key a partir do portal do Azure e uma DocumentAnalysisClient instância com o AzureKeyCredential e seu Reconhecedor endpointde Formulário .

Nota

• A partir do .NET 6, novos projetos usando o console modelo geram um novo estilo de programa que difere das versões anteriores.
• A nova saída usa recursos recentes do C# que simplificam o código que você precisa escrever.
• Quando você usa a versão mais recente, você só precisa escrever o Main corpo do método. Não é necessário incluir instruções de nível superior, diretivas de uso global ou diretivas de uso implícito.
• Para obter mais informações, consulte Novos modelos C# geram instruçõ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 seguintes exemplos de código para copiar e colar no arquivo Program.cs do aplicativo:

   • Modelo de layout

   • Modelo pré-construído

Importante

Lembre-se de remover a chave do seu código quando terminar e nunca publicá-la 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 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 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.
• Adicionamos o valor de URI do arquivo à Uri fileUri variável na parte superior do script.
• Para extrair o layout de um determinado arquivo em um URI, use o StartAnalyzeDocumentFromUri método e passe prebuilt-layout como a ID do modelo. O valor retornado é um AnalyzeResult objeto que contém dados do documento enviado.

Adicione o exemplo de código a seguir ao arquivo Program.cs. Certifique-se de atualizar as variáveis de chave e ponto de extremidade com valores de sua instância do Reconhecedor de Formulário 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}'.");
    }
}

Execute seu aplicativo

Depois de adicionar um exemplo de código ao seu aplicativo, escolha o botão verde Iniciar ao lado de formRecognizer_quickstart para criar 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, visite o repositório de exemplos do Azure no GitHub para exibir a saída do modelo de layout.

Modelo pré-construído

Analise e extraia campos comuns de tipos de documentos específicos usando um modelo pré-construído. Neste exemplo, analisamos uma fatura usando o modelo de fatura pré-incorporada.

Gorjeta

Você não está limitado a faturas — há vários modelos pré-criados para escolher, cada um com seu próprio conjunto de campos suportados. O modelo a utilizar para a analyze operação depende do tipo de documento a analisar. Consulte a extração de dados do modelo.

• Analise uma fatura usando o modelo de fatura pré-incorporada. Você pode usar nosso exemplo de documento de fatura para este início rápido.
• Adicionamos o valor de URI do arquivo à Uri invoiceUri variável na parte superior do arquivo Program.cs.
• Para analisar um determinado arquivo em um URI, use o StartAnalyzeDocumentFromUri método e passe prebuilt-invoice como a ID do modelo. O valor retornado é um AnalyzeResult objeto 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 suportados e tipos correspondentes, consulte a nossa página de conceito de fatura .

Adicione o exemplo de código a seguir ao seu arquivo Program.cs. Certifique-se de atualizar as variáveis de chave e ponto de extremidade com valores de sua instância do Reconhecedor de Formulário 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}");
        }
    }
}

Execute seu aplicativo

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

Saída do modelo pré-construído

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, visite o repositório de exemplos do Azure no GitHub para exibir a saída do modelo de fatura pré-criado.

Referência | do SDK da biblioteca | cliente Pacote de referência | da API REST (Maven) | Exemplos| Versão suportada da API REST

Neste guia de início rápido, use 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 pré-criada—Analise e extraia campos comuns de tipos de documentos específicos usando um modelo pré-treinado.

Pré-requisitos

• Subscrição do Azure - Crie uma gratuitamente.

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

  Gorjeta

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

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

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

  • Gradle, versão 6.8 ou posterior.

• Um recurso de serviços de IA do Azure ou Document Intelligence. Depois de ter sua assinatura do Azure, crie um recurso de Document Intelligence de serviço único ou multisserviço , no portal do Azure, para obter sua chave e ponto de extremidade. Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção.

  Gorjeta

  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. Apenas para acesso ao Document Intelligence, crie um recurso Document Intelligence. Observe que você precisará de um recurso de serviço único se pretender usar a autenticação do Microsoft Entra.

• Depois que o recurso for implantado, selecione Ir para o recurso. Você precisa da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo à API de Document Intelligence. Mais tarde, você cola sua chave e ponto de extremidade no código:

  

Configurar

Criar um novo projeto Gradle

1. Na janela do 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 a gradle init partir do seu diretório de trabalho. Este comando cria arquivos de compilação essenciais para o Gradle, incluindo build.gradle.kts, que é usado em tempo de execução para criar e configurar seu aplicativo.

   gradle init --type basic
   

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

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

Instalar a biblioteca de cliente

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

Abra o arquivo build.gradle.kts do projeto no IDE. Copay e passado o código a seguir para incluir a biblioteca do cliente como uma implementation instrução, juntamente com os plugins e configurações necessárias.

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

   }

Criar uma aplicação Java

Para interagir com o serviço de Inteligência de Documentos, você precisa criar uma instância da DocumentAnalysisClient classe. Para fazer isso, crie um AzureKeyCredential com o seu key a partir do portal do Azure e uma DocumentAnalysisClient instância com o AzureKeyCredential e seu Document Intelligence endpoint.

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

   mkdir -p src/main/java
   

   Você cria a seguinte estrutura de diretórios:

   

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

   Gorjeta

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

2. Abra o ficheiro FormRecognizer.java. Copie e cole um dos seguintes exemplos de código em seu aplicativo:

   • Esquema

   • Fatura pré-construída

Importante

Lembre-se de remover a chave do seu código quando terminar e nunca publicá-la 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 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 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 beginAnalyzeDocumentFromUrl método e passará prebuilt-layout como a ID do modelo. O valor retornado é um AnalyzeResult objeto que contém dados sobre o documento enviado.
• Adicionamos o valor de URI do arquivo à documentUrl variável no método principal.

Adicione o seguinte exemplo de código ao FormRecognizer.java arquivo. Certifique-se de atualizar as variáveis de chave e ponto de extremidade com valores da sua instância de Document Intelligence do 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(", "));
  }
}

Compilar e executar o aplicativo

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

1. Crie seu aplicativo com o build comando:

   gradle build
   

2. Execute seu aplicativo com o run comando:

   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, visite o repositório de exemplos do Azure no GitHub para exibir a saída do modelo de layout.

Modelo pré-construído

Analise e extraia campos comuns de tipos de documentos específicos usando um modelo pré-construído. Neste exemplo, analisamos uma fatura usando o modelo de fatura pré-incorporada.

Gorjeta

Você não está limitado a faturas — há vários modelos pré-criados para escolher, cada um com seu próprio conjunto de campos suportados. O modelo a utilizar para a analyze operação depende do tipo de documento a analisar. Consulte a extração de dados do modelo.

• Analise uma fatura usando o modelo de fatura pré-incorporada. Você pode usar nosso exemplo de documento de fatura para este início rápido.
• Adicionámos o valor do URL do invoiceUrl ficheiro à variável na parte superior do ficheiro.
• Para analisar um determinado arquivo em um URI, você usará o beginAnalyzeDocuments método e passará PrebuiltModels.Invoice como a ID do modelo. O valor retornado é um result objeto 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 suportados e tipos correspondentes, consulte a nossa página de conceito de fatura .

Adicione o seguinte exemplo de código ao FormRecognizer.java arquivo. Certifique-se de atualizar as variáveis de chave e ponto de extremidade com valores da sua instância de Document Intelligence do 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());
                }
              }
            }));
        }
      }
    }
  }
}

Compilar e executar o aplicativo

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

1. Crie seu aplicativo com o build comando:

   gradle build
   

2. Execute seu aplicativo com o run comando:

   gradle run
   

Saída do modelo pré-construído

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, visite o repositório de exemplos do Azure no GitHub para exibir a saída do modelo de fatura pré-criado.

Referência | do SDK da biblioteca | do cliente Pacote de referência | da API REST (npm) | Exemplos |Versão suportada da API REST

Neste guia de início rápido, use 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 pré-criada—Analise e extraia campos comuns de tipos de documentos específicos usando um modelo de fatura pré-treinado.

Pré-requisitos

• Subscrição do Azure - Crie uma gratuitamente.

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

• A última LTS versão do Node.js.

• Um recurso de serviços de IA do Azure ou Document Intelligence. Depois de ter sua assinatura do Azure, crie um recurso de Document Intelligence de serviço único ou multisserviço , no portal do Azure, para obter sua chave e ponto de extremidade. Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção.

  Gorjeta

  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. Apenas para acesso ao Document Intelligence, crie um recurso Document Intelligence. Observe que você precisará de um recurso de serviço único se pretender usar a autenticação do Microsoft Entra.

• Depois que o recurso for implantado, selecione Ir para o recurso. Você precisa da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo à API de Document Intelligence. Cole sua chave e ponto de extremidade no código mais adiante no início rápido:

  

Configurar

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

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

2. Execute o npm init comando para inicializar o aplicativo e organizar seu projeto.

   npm init
   

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

   • Os atributos mais importantes são nome, número da versão e ponto de entrada.
   • Recomendamos manter index.js o nome do ponto de entrada. A descrição, o comando de teste, o 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 Devolver ou Enter.
   • Depois de concluir os prompts, um package.json arquivo será criado no diretório doc-intel-app.

4. Instale a biblioteca do cliente e azure/identity os ai-form-recognizer pacotes npm:

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

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

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

   Gorjeta

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

Compilar a aplicação

Para interagir com o serviço de Inteligência de Documentos, você precisa criar uma instância da DocumentAnalysisClient classe. Para fazer isso, crie um AzureKeyCredential com o seu key a partir do portal do Azure e uma DocumentAnalysisClient instância com o AzureKeyCredential e seu Reconhecedor endpointde Formulário .

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

   • Esquema

   • Fatura pré-construída

Importante

Lembre-se de remover a chave do seu código quando terminar e nunca publicá-la 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 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 coordenadas de região delimitadora de documentos.

• Neste exemplo, você precisará de um arquivo de documento de uma URL. Você pode usar nosso documento de exemplo para este início rápido.
• Adicionámos o valor do URL do formUrl ficheiro à variável junto à parte superior do ficheiro.
• Para analisar um determinado arquivo a partir de uma URL, você usará o beginAnalyzeDocuments método e passará prebuilt-layout como a ID do modelo.

Adicione o seguinte exemplo de código ao index.js arquivo. Certifique-se de atualizar as variáveis de chave e ponto de extremidade com valores da sua instância de Document Intelligence do 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);
});

Execute seu aplicativo

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

1. Navegue até a pasta onde você tem seu aplicativo Document Intelligence (doc-intel-app).

2. Digite o seguinte comando no seu terminal:

   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, visite o repositório de exemplos do Azure no GitHub para exibir a saída do modelo de layout.

Modelo pré-construído

Neste exemplo, analisamos uma fatura usando o modelo de fatura pré-incorporada.

Gorjeta

Você não está limitado a faturas — há vários modelos pré-criados para escolher, cada um com seu próprio conjunto de campos suportados. O modelo a utilizar para a analyze operação depende do tipo de documento a analisar. Consulte a extração de dados do modelo.

• Analise uma fatura usando o modelo de fatura pré-incorporada. Você pode usar nosso exemplo de documento de fatura para este início rápido.
• Adicionámos o valor do URL do invoiceUrl ficheiro à variável na parte superior do ficheiro.
• Para analisar um determinado arquivo em um URI, você usará o beginAnalyzeDocuments método e passará PrebuiltModels.Invoice como a ID do modelo. O valor retornado é um result objeto 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 suportados e tipos correspondentes, consulte a nossa página de conceito de 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);
});

Execute seu aplicativo

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

1. Navegue até a pasta onde você tem seu aplicativo Document Intelligence (doc-intel-app).

2. Digite o seguinte comando no seu terminal:

   node index.js
   

Saída do modelo pré-construído

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, visite o repositório de exemplos do Azure no GitHub para exibir a saída do modelo de fatura pré-criado.

Referência | do SDK da biblioteca |do cliente Pacote de referência | da API REST (PyPi) | Amostras | Versão da API REST suportada

Neste guia de 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 opção e caixas de seleção, e pares chave-valor, sem a necessidade de treinar um modelo.

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

Pré-requisitos

• Subscrição do Azure - Crie uma gratuitamente.

• Python 3.7 ou posterior.

  • Sua instalação do Python deve incluir pip. Você pode verificar se você tem pip instalado executando pip --version na linha de comando. Obtenha pip instalando a versão mais recente do Python.

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

• Um recurso de serviços de IA do Azure ou Document Intelligence. Depois de ter sua assinatura do Azure, crie um recurso de Document Intelligence de serviço único ou multisserviço , no portal do Azure, para obter sua chave e ponto de extremidade. Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção.

Gorjeta

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. Apenas para acesso ao Document Intelligence, crie um recurso Document Intelligence. Observe que você precisará de um recurso de serviço único se pretender usar a autenticação do Microsoft Entra.

• Depois que o recurso for implantado, selecione Ir para o recurso. Você precisa da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo à API de Document Intelligence. Cole sua chave e ponto de extremidade no código mais adiante no início rápido:

  

Configurar

Abra uma janela de terminal em seu ambiente local e instale a biblioteca de cliente do Azure AI Document Intelligence para Python com pip:

pip install azure-ai-formrecognizer==3.3.0

Crie seu aplicativo Python

Para interagir com o serviço de Inteligência de Documentos, você precisa criar uma instância da DocumentAnalysisClient classe. Para fazer isso, crie um AzureKeyCredential com o seu key a partir do portal do Azure e uma DocumentAnalysisClient instância com o AzureKeyCredential e seu Document Intelligence endpoint.

1. Crie um novo arquivo Python chamado form_recognizer_quickstart.py em seu editor ou IDE preferido.

2. Abra o arquivo form_recognizer_quickstart.py e selecione um dos seguintes exemplos de código para copiar e colar em seu aplicativo:

   • Esquema

   • Fatura pré-construída

Importante

Lembre-se de remover a chave do seu código quando terminar e nunca publicá-la 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 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 coordenadas de região delimitadora de documentos.

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

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

Adicione o exemplo de código a seguir ao seu aplicativo form_recognizer_quickstart.py. Certifique-se de atualizar as variáveis de chave e ponto de extremidade com valores de sua instância do Reconhecedor de Formulário 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()

Execute o aplicativo

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

1. Navegue até a pasta onde você tem seu arquivo form_recognizer_quickstart.py .

2. Digite o seguinte comando no seu terminal:

   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, visite o repositório de exemplos do Azure no GitHub para exibir a saída do modelo de layout.

---

Modelo pré-construído

Analise e extraia campos comuns de tipos de documentos específicos usando um modelo pré-construído. Neste exemplo, analisamos uma fatura usando o modelo de fatura pré-incorporada.

Gorjeta

Você não está limitado a faturas — há vários modelos pré-criados para escolher, cada um com seu próprio conjunto de campos suportados. O modelo a utilizar para a analyze operação depende do tipo de documento a analisar. Consulte a extração de dados do modelo.

• Analise uma fatura usando o modelo de fatura pré-incorporada. Você pode usar nosso exemplo de documento de fatura para este início rápido.
• Adicionámos o valor do URL do invoiceUrl ficheiro à variável na parte superior do ficheiro.
• 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 suportados e tipos correspondentes, consulte a nossa página de conceito de fatura .

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

Adicione o exemplo de código a seguir ao seu aplicativo form_recognizer_quickstart.py. Certifique-se de atualizar as variáveis de chave e ponto de extremidade com valores de sua instância do Reconhecedor de Formulário 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()

Execute o aplicativo

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

1. Navegue até a pasta onde você tem seu arquivo form_recognizer_quickstart.py .

2. Digite o seguinte comando no seu terminal:

   python form_recognizer_quickstart.py
   

Saída do modelo pré-construído

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, visite o repositório de exemplos do Azure no GitHub para exibir a saída do modelo de fatura pré-criado.

| SDKs do Azure suportados pela API | REST do Document Intelligence |

Neste guia de início rápido, aprenda a usar a API REST do Document Intelligence para analisar e extrair dados e valores de documentos:

Pré-requisitos

• Subscrição do Azure - Criar uma gratuitamente

• ferramenta de linha de comando curl instalada.

  • Windows
  • Mac ou Linux

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

  • Windows
  • macOS
  • Linux

• Para verificar sua versão do PowerShell, digite o seguinte comando relativo ao seu sistema operacional:

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

• Um recurso de Document Intelligence (serviço único) ou serviços de IA do Azure (multisserviço). Depois de ter sua assinatura do Azure, crie um recurso de Document Intelligence de serviço único ou multisserviço , no portal do Azure, para obter sua chave e ponto de extremidade. Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção.

Gorjeta

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. Apenas para acesso ao Document Intelligence, crie um recurso Document Intelligence. Observe que você precisará de um recurso de serviço único se pretender usar a autenticação do Microsoft Entra.

• Depois que o recurso for implantado, selecione Ir para o recurso. Você precisa da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo à API de Document Intelligence. Cole sua chave e ponto de extremidade no código mais adiante no início rápido:

  

Analise documentos e obtenha resultados

Uma solicitação POST é usada para analisar documentos com um modelo pré-construído ou personalizado. Uma solicitação GET é usada para recuperar o resultado de uma chamada de análise de documentos. O modelId é usado com operações POST e resultId 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 Document Intelligence do portal do Azure.

2. Substitua {key} pelo valor da chave da sua instância de Document Intelligence do portal do Azure.

3. Usando a tabela a seguir como referência, substitua {modelID} e {your-document-url} pelos valores desejados.

4. Você precisa de um arquivo de documento em uma URL. Para este início rápido, você pode usar os formulários de exemplo fornecidos na tabela a seguir para cada recurso:

Exemplos de documentos

Funcionalidade	{modelID}	{seu-documento-url}
Documento Geral	documento pré-construído	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf
Ler	leitura pré-embutida	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/read.png
Esquema	layout pré-construído	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/layout.png
Cartão de seguro de doença	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	pré-construído-tax.us.w2	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/w2.png
Fatura	fatura pré-embutida	https://github.com/Azure-Samples/cognitive-services-REST-api-samples/raw/master/curl/form-recognizer/rest-api/invoice.pdf
Receção	recibo pré-embutido	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	cartão de visita pré-construído	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 publicá-la 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 Segurança dos serviços de IA do Azure.

Pedido 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ê recebe uma 202 (Success) resposta que inclui um cabeçalho Operation-Location somente leitura. 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 de análise (GET Request)

Depois de chamar a Analyze document API, 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 estas alterações:

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

2. Substitua {key} pelo valor da chave da sua instância de Inteligência Documental no portal do Azure.

Pedido 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ê recebe uma 200 (Success) resposta com saída JSON. O primeiro campo, "status", indica o status da operação. Se a operação não estiver concluída, o valor de is "running" ou "notStarted", e você deverá chamar a API novamente, manualmente ou por meio de "status" um script. Recomendamos um intervalo de um segundo ou mais entre as chamadas.

Exemplo de resposta para fatura pré-construída

{
    "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 suportados

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

É isso, parabéns!

Neste guia de início rápido, você usou um modelo de inteligência de documentos para analisar vários formulários e documentos. Em seguida, explore o Document Intelligence Studio e a documentação de referência para saber mais sobre a API de Document Intelligence em profundidade.

Próximos passos

• Para uma experiência aprimorada e qualidade de modelo avançada, experimente o Document Intelligence Studio

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

• Encontre mais exemplos no GitHub.