Introdução ao Reconhecimento de Formulários

Este artigo se aplica a:Reconhecimento de Formulários v3.0. Versão anterior:Reconhecimento de Formulários v2.1

Introdução à versão mais recente do Azure Reconhecimento de Formulários. O Reconhecimento de Formulários do Azure é um serviço de IA aplicado do Azure baseado na nuvem que usa machine learning para extrair pares chave-valor, texto, tabelas e dados importantes de seus documentos. Você pode integrar facilmente Reconhecimento de Formulários modelos em seus fluxos de trabalho e aplicativos usando um SDK na linguagem de programação de sua escolha 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 do Reconhecimento de Formulários e ver as opções de desenvolvimento, visite a página de Visão geral.

Referência do SDK|Referência da API | Pacote (NuGet) | Exemplos | Versões da API REST com suporte

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

• Modelo de documento geral: Analisar e extrair texto, tabelas, estrutura, pares de chave-valor.

• 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 de Reconhecimento de Formulários dos Serviços Cognitivos. Quando tiver sua assinatura do Azure, crie um recurso de serviço único ou de serviço múltiplo no portal do Azure para obter a chave e o 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 dos Serviços Cognitivos se você planeja acessar vários serviços cognitivos em um só ponto de extremidade/chave. Para acesso somente de Reconhecimento de Formulários, crie um recurso Reconhecimento de Formulários. Observe que você precisa de um recurso de serviço único se pretende usar a autenticação Azure Active Directory.

• 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 formRecognizer_quickstart na caixa Nome do projeto. Em seguida, escolha Avançar.

   

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

   

Instalar a biblioteca de clientes com o NuGet

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

   

2. Selecione a guia Procurar e digite Azure.AI.FormRecognizer.

   

3. Selecione a versão 4.0.0 no menu suspenso e instale o pacote no projeto.

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 obter mais informações, consulteNovos 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 exemplos de código a seguir para copiar e colar no arquivo Program.cs do aplicativo:

   • Modelo de documento geral

   • 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 saber mais, confiraSegurança nos Serviços Cognitivos.

Modelo de documento geral

Analise e extraia texto, tabelas, estrutura, pares de chave-valor.

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

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 form 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-document", fileUri);

AnalyzeResult result = operation.Value;

Console.WriteLine("Detected key-value pairs:");

foreach (DocumentKeyValuePair kvp in result.KeyValuePairs)
{
    if (kvp.Value == null)
    {
        Console.WriteLine($"  Found key with no value: '{kvp.Key.Content}'");
    }
    else
    {
        Console.WriteLine($"  Found key-value pair: '{kvp.Key.Content}' and '{kvp.Value.Content}'");
    }
}

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 verde Iniciar ao lado de formRecognizer_quickstart para criar e executar seu programa, ou pressione F5.

Saída do modelo de documento geral

Aqui está um trecho da saída esperada:

  Detected key-value pairs:
  Found key with no value: '?'
  Found key-value pair: 'QUARTERLY REPORT PURSUANT TO SECTION 13 OR 15(d) OF THE SECURITIES EXCHANGE ACT OF 1934' and ':selected:'
  Found key-value pair: 'For the Quarterly Period Ended March 31, 2020' and 'OR'
  Found key with no value: '?'
  Found key-value pair: 'TRANSITION REPORT PURSUANT TO SECTION 13 OR 15(d) OF THE SECURITIES EXCHANGE ACT OF 1934' and ':unselected:'
  Found key with no value: 'For the Transition Period From'
  Found key-value pair: 'to Commission File Number' and '001-37845'

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

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 formulário de um URI. Você pode usar nosso exemplo de documento de formulário 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 verde Iniciar ao lado de formRecognizer_quickstart para criar e executar seu 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 usado para a operação de análise depende do tipo de documento a ser analisado. 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 `DocumentAnalysisClient` 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");

AnalyzeDocumentOperation operation = await client.AnalyzeDocumentFromUriAsync(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 verde Iniciar ao lado de formRecognizer_quickstart para criar e executar seu 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.

Referência do SDK | Referência da API | Pacote (Maven) | Exemplos| Versões da API REST com suporte

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

• Documento geral: Analisar e extrair textos, tabelas, estrutura, pares de chave-valor.

• 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. ConsulteJava 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 kit de desenvolvimento Java (JDK) versão 8 ou posterior. Para obter mais informações, confirao Build do OpenJDK da Microsoft.

  • Gradle, versão 6.8 ou posterior.

• Um recurso de Reconhecimento de Formulários dos Serviços Cognitivos. Depois de ter sua assinatura do Azure, crie um recurso de Reconhecimento de Formulários de serviço único ou serviço múltiplo no portal do Azure para obter sua chave e 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 dos Serviços Cognitivos se você planeja acessar vários serviços cognitivos em um só ponto de extremidade/chave. Para acesso somente de Reconhecimento de Formulários, crie um recurso Reconhecimento de Formulários. Observe que você precisa de um recurso de serviço único se pretende usar a autenticação Azure Active Directory.

• 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. 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-recognizer-app e navegue até ele.

   mkdir form-recognizer-app && form-recognizer-app
   

   mkdir translator-text-app; cd translator-text-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-recognizer-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.

1. 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.0.0")
   }
   

Criar um aplicativo Java

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.

1. No diretório form-recognizer-app, execute o seguinte comando:

   mkdir -p src/main/java
   

   Você cria a seguinte estrutura de diretório:

   

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

3. Abra o arquivo FormRecognizer.java e selecione um dos exemplos de código a seguir para copiar e colar no aplicativo:

   • Documentação geral

   • 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 saber mais, confiraSegurança nos Serviços Cognitivos.

Modelo de documento geral

Extraia texto, tabelas, estrutura e pares de chave-valor de documentos.

• Para este exemplo, você precisará de um arquivo de documento de formulário em um URI. Você pode usar nosso exemplo de documento de formulário para este início rápido.
• Para analisar um determinado arquivo em um URI, você usará o método beginAnalyzeDocumentFromUrl e passará prebuilt-document 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. 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 com.azure.ai.formrecognizer.*;

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-document";
    SyncPoller < OperationResult, AnalyzeResult > analyzeDocumentPoller =
      client.beginAnalyzeDocumentFromUrl(modelId, documentUrl);

    AnalyzeResult analyzeResult = analyzeDocumentPoller.getFinalResult();

    // pages
    analyzeResult.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()));
    });

    // tables
    List < DocumentTable > tables = analyzeResult.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();
    }

    // Key-value pairs
    analyzeResult.getKeyValuePairs().forEach(documentKeyValuePair -> {
      System.out.printf("Key content: %s%n", documentKeyValuePair.getKey().getContent());
      System.out.printf("Key content bounding region: %s%n",
        documentKeyValuePair.getKey().getBoundingRegions().toString());

      if (documentKeyValuePair.getValue() != null) {
        System.out.printf("Value content: %s%n", documentKeyValuePair.getValue().getContent());
        System.out.printf("Value content bounding region: %s%n", documentKeyValuePair.getValue().getBoundingRegions().toString());
      }
    });
  }
}

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-recognizer-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 documento geral

Aqui está um trecho da saída esperada:

Key content: For the Transition Period From
Key content bounding region: [com.azure.ai.formrecognizer.models.BoundingRegion@14c053c6]
Key content: to Commission File Number
Key content bounding region: [com.azure.ai.formrecognizer.models.BoundingRegion@6c2d4cc6]
Value content: 001-37845
Value content bounding region: [com.azure.ai.formrecognizer.models.BoundingRegion@30865a90]
Key content: (I.R.S. ID)
Key content bounding region: [com.azure.ai.formrecognizer.models.BoundingRegion@6134ac4a]
Value content: 91-1144442
Value content bounding region: [com.azure.ai.formrecognizer.models.BoundingRegion@777c9dc9]
Key content: Securities registered pursuant to Section 12(g) of the Act:
Key content bounding region: [com.azure.ai.formrecognizer.models.BoundingRegion@71b1a49c]
Value content: NONE

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

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 formulário em um URI. Você pode usar nosso exemplo de documento de formulário 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. 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 com.azure.ai.formrecognizer.*;

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-recognizer-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 usado para a operação de análise depende do tipo de documento a ser analisado. 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. 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 com.azure.ai.formrecognizer.*;

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 — form-recognizer-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

Referência do SDK | Referência da API | Pacote (npm) | Exemplos |Versões da API REST com suporte

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

• Documento geral: Analisar e extrair pares de chave-valor e marcas de seleção de 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 obter mais informações, consulte documentação do código do Visual Studio

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

• Um recurso de Reconhecimento de Formulários dos Serviços Cognitivos. Depois de ter sua assinatura do Azure, crie um recurso de Reconhecimento de Formulários de serviço único ou serviço múltiplo no portal do Azure para obter sua chave e 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 dos Serviços Cognitivos se você planeja acessar vários serviços cognitivos em um só ponto de extremidade/chave. Para acesso somente de Reconhecimento de Formulários, crie um recurso Reconhecimento de Formulários. Observe que você precisa de um recurso de serviço único se pretende usar a autenticação Azure Active Directory.

• 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. Crie um aplicativo Node.js Express: em uma janela de console (como cmd, PowerShell ou Bash), crie um diretório para seu aplicativo form-recognizer-app e navegue até ele.

   mkdir form-recognizer-app && cd form-recognizer-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 de concluir os prompts, um arquivo package.json será criado no diretório form-recognizer-app.

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

   npm i @azure/ai-form-recognizer @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 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.

1. Abra o arquivo index.jsem Visual Studio Code ou seu IDE favorito e selecione um dos exemplos de código a seguir para copiar e colar em seu aplicativo:

   • Documentação geral

   • 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 saber mais, confiraSegurança nos Serviços Cognitivos.

Modelo de documento geral

Extraia texto, tabelas, estrutura e pares de chave-valor de documentos.

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

Adicione o exemplo de código a seguir ao arquivo index.js. 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:

  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-document", formUrl);

    const {keyValuePairs} = await poller.pollUntilDone();

    if (!keyValuePairs || keyValuePairs.length <= 0) {
        console.log("No key-value pairs were extracted from the document.");
    } else {
        console.log("Key-Value Pairs:");
        for (const {key, value, confidence} of keyValuePairs) {
            console.log("- Key  :", `"${key.content}"`);
            console.log("  Value:", `"${(value && value.content) || "<undefined>"}" (${confidence})`);
        }
    }

}

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 em que você tem seu aplicativo de Reconhecimento de Formulários (form-recognizer-app).

2. No terminal, digite o seguinte comando:

   node index.js
   

Saída do modelo de documento geral

Aqui está um trecho da saída esperada:

Key-Value Pairs:
- Key  : "For the Quarterly Period Ended"
  Value: "March 31, 2020" (0.35)
- Key  : "From"
  Value: "1934" (0.119)
- Key  : "to"
  Value: "<undefined>" (0.317)
- Key  : "Commission File Number"
  Value: "001-37845" (0.87)
- Key  : "(I.R.S. ID)"
  Value: "91-1144442" (0.87)
- Key  : "Class"
  Value: "Common Stock, $0.00000625 par value per share" (0.748)
- Key  : "Outstanding as of April 24, 2020"
  Value: "7,583,440,247 shares" (0.838)

Para exibir toda a saída, acesse o repositório de amostras do Azure no GitHub para exibir a saída do modelo de documentação geral

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 formulário de uma URL. Você pode usar nosso exemplo de documento de formulário 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. 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:

 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 em que você tem seu aplicativo de Reconhecimento de Formulários (form-recognizer-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 usado para a operação de análise depende do tipo de documento a ser analisado. 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 (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 em que você tem seu aplicativo de Reconhecimento de Formulários (form-recognizer-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

Referência do SDK | Referência da API | Pacote (PyPi) | Exemplos | Versões da API REST com suporte

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

• Documento geral: Analisar e extrair textos, tabelas, estruturas e pares de chave-valor.

• 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 – Criar 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 obter mais informações, confiraIntrodução ao Python no Visual Studio Code.

• Um recurso de Reconhecimento de Formulários dos Serviços Cognitivos. Depois de ter sua assinatura do Azure, crie um recurso de Reconhecimento de Formulários de serviço único ou serviço múltiplo no portal do Azure para obter sua chave e 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 dos Serviços Cognitivos se você planeja acessar vários serviços cognitivos em um só ponto de extremidade/chave. Para acesso somente de Reconhecimento de Formulários, crie um recurso Reconhecimento de Formulários. Observe que você precisa de um recurso de serviço único se pretende usar a autenticação Azure Active Directory.

• 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

Abra uma janela de terminal no seu ambiente local e instale a biblioteca de clientes de Reconhecimento de Formulários do Azure para o Python com pip:

pip install azure-ai-formrecognizer==3.2.0

Criar seu aplicativo Python

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.

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:

   • Documentação geral

   • 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 saber mais, confiraSegurança nos Serviços Cognitivos.

Modelo de documento geral

Extraia texto, tabelas, estrutura e pares de chave-valor de documentos.

• Para este exemplo, você precisará de um arquivo de documento de formulário de uma URL. Você pode usar nosso exemplo de documento de formulário para este início rápido.
• Para analisar um determinado arquivo em uma URL, você usará o método begin_analyze_document_from_url e passará em prebuilt-document como ID do modelo. O valor retornado é um objeto result que contém dados sobre o documento enviado.
• Adicionamos o valor de URL do arquivo à variável docUrl na função analyze_general_documents.

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_general_documents():
    # sample document
    docUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf"

    # create your `DocumentAnalysisClient` instance and `AzureKeyCredential` variable
    document_analysis_client = DocumentAnalysisClient(endpoint=endpoint, credential=AzureKeyCredential(key))

    poller = document_analysis_client.begin_analyze_document_from_url(
            "prebuilt-document", docUrl)
    result = poller.result()

    for style in result.styles:
        if style.is_handwritten:
            print("Document contains handwritten content: ")
            print(",".join([result.content[span.offset:span.offset + span.length] for span in style.spans]))

    print("----Key-value pairs found in document----")
    for kv_pair in result.key_value_pairs:
        if kv_pair.key:
            print(
                    "Key '{}' found within '{}' bounding regions".format(
                        kv_pair.key.content,
                        format_bounding_region(kv_pair.key.bounding_regions),
                    )
                )
        if kv_pair.value:
            print(
                    "Value '{}' found within '{}' bounding regions\n".format(
                        kv_pair.value.content,
                        format_bounding_region(kv_pair.value.bounding_regions),
                    )
                )

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

        for line_idx, line in enumerate(page.lines):
            print(
                "...Line # {} has text content '{}' within bounding box '{}'".format(
                    line_idx,
                    line.content,
                    format_polygon(line.polygon),
                )
            )

        for word in page.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 '{}'\n".format(
                        region.page_number,
                        format_polygon(region.polygon),
                    )
                )
    print("----------------------------------------")


if __name__ == "__main__":
    analyze_general_documents()

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 documento geral

Aqui está um trecho da saída esperada:

  ----Key-value pairs found in document----
  Key '☒' found within 'Page #1: [0.6694, 1.7746], [0.7764, 1.7746], [0.7764, 1.8833], [0.6694, 1.8833]' bounding regions
  Key 'QUARTERLY REPORT PURSUANT TO SECTION 13 OR 15(d) OF THE SECURITIES EXCHANGE ACT OF 1934' found within 'Page #1: [0.996, 1.7804], [7.8449, 1.7804], [7.8449, 2.0559], [0.996, 2.0559]' bounding regions
  Value ':selected:' found within 'Page #1: [0.6694, 1.7746], [0.7764, 1.7746], [0.7764, 1.8833], [0.6694, 1.8833]' bounding regions

  Key 'For the Quarterly Period Ended March 31, 2020' found within 'Page #1: [0.9982, 2.1626], [3.4543, 2.1626], [3.4543, 2.2665], [0.9982, 2.2665]' bounding regions
  Value 'OR' found within 'Page #1: [4.1471, 2.2972], [4.3587, 2.2972], [4.3587, 2.4049], [4.1471, 2.4049]' bounding regions

Para exibir toda a saída, acesse o repositório de amostras do Azure no GitHub para exibir a saída do modelo de documentação geral

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 formulário de uma URL. Você pode usar nosso exemplo de documento de formulário 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 form 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 usado para a operação de análise depende do tipo de documento a ser analisado. 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 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.
• 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 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,
                )
            )

if __name__ == "__main__":
    analyze_invoice()

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

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 de Reconhecimento de Formulários | SDKs do Azure | SDKs suportados

Neste guia de início rápido, você usará a API REST do Reconhecimento de Formulários para analisar e extrair dados e valores de formulários e 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 Reconhecimento de Formulários (serviço único) ou Serviços Cognitivos (vários serviços). Depois de ter sua assinatura do Azure, crie um recurso de Reconhecimento de Formulários de serviço único ou serviço múltiplo no portal do Azure para obter sua chave e 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 dos Serviços Cognitivos se você planeja acessar vários serviços cognitivos em um só ponto de extremidade/chave. Para acesso somente de Reconhecimento de Formulários, crie um recurso Reconhecimento de Formulários. Observe que você precisa de um recurso de serviço único se pretende usar a autenticação Azure Active Directory.

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

  

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 do Reconhecimento de Formulários do portal do Azure.

2. Substitua {key} pelo valor da chave da sua instância do Reconhecimento de Formulários do 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	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 saber mais, confiraSegurança nos Serviços Cognitivos.

Solicitação POST

curl -v -i POST "{endpoint}/formrecognizer/documentModels/{modelID}:analyze?api-version=2022-08-31" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: {key}" --data-ascii "{'urlSource': '{your-document-url}'}"

Resposta POST

Você vai receber uma resposta 202 (Success) com um cabeçalho Operation-location. O valor desse cabeçalho contém uma resultID de resultado que pode ser consultada para obter o status da operação assíncrona:

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

Depois de chamar a API Analisar documento , chame a API Obter resultado da análise 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 {POST response} Operation-location da resposta POST.

2. Substitua {key} pelo valor da chave da instância de Reconhecimento de Formulários no portal do Azure.

Solicitação GET

curl -v -X GET "{POST response}" -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": "2022-03-25T19:31:37Z",
    "lastUpdatedDateTime": "2022-03-25T19:31:43Z",
    "analyzeResult": {
        "apiVersion": "2022-08-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!

Neste guia de início rápido, você usou o modelo do Reconhecimento de Formulários para analisar formulários e documentos de diferentes maneiras. Em seguida, explore a documentação de referência e o Estúdio de Reconhecimento de Formulários para saber mais sobre a API de Reconhecimento de Formulários.

Próximas etapas

Experimente o nosso Estúdio do Reconhecimento de Formulários

Explore nossa documentação de instruções e aprofunde-se nos modelos de reconhecimento de formulários