Introdução ao Reconhecimento de Formulários

Este artigo se aplica a:marca de seleção do Reconhecimento de Formulários v3.0Reconhecimento 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ê usará 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 chave-valor e entidades nomeadas.

  • 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 abaixo mais adiante no guia de início rápido:

    Captura de tela: chaves e local do ponto de extremidade no portal do Azure.

Configuração

  1. Inicie o Visual Studio.

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

    Captura de tela: janela inicial do Visual Studio.

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

    Captura de tela: página Criar novo projeto do Visual Studio.

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

    Captura de tela: janela de diálogo Configurar novo projeto do Visual Studio.

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

    Captura de tela: janela de diálogo Informações adicionais do Visual Studio.

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

    Captura de tela da janela de seleção de pacote NuGet no Visual Studio.

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

    Captura de tela da seleção de pacote NuGet de pré-lançamento no Visual Studio.

  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 de Reconhecimento de Formulários, você precisará criar uma instância da classe DocumentAnalysisClient. Para fazer isso, você criará um AzureKeyCredential com seu key no portal do Azure e uma instância de DocumentAnalysisClient com o AzureKeyCredential e seu Reconhecimento de Formulários endpoint.

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:

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

Analisa e extrai texto, tabelas, estrutura, pares chave-valor e entidades nomeadas.

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

Captura de tela: executar seu programa do Visual Studio.

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.

Captura de tela: executar seu programa do Visual Studio.

Encontrei um problema ao executar o aplicativo.

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, analisaremos 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.

Captura de tela: executar seu programa do Visual Studio.

Encontrei um problema ao executar o aplicativo.

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, estruturas, pares chave-valor e entidades com nome.

  • 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 – Analisar e extrair 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 você não estiver usando VS Code, certifique-se de ter o seguinte instalado em seu ambiente de desenvolvimento:

  • 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 tarde, você vai colar a chave e o ponto de extremidade no código abaixo:

    Captura de tela: chaves e local do ponto de extremidade no portal do Azure.

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 criará 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")
    }
    

Encontrei um problema com a instalação da biblioteca de clientes.

Criar um aplicativo Java

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

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

    mkdir -p src/main/java
    

    Você criará a seguinte estrutura de diretório:

    Captura de tela: estrutura de diretórios Java

  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:

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

Extrai texto, tabelas, estrutura, pares chave-valor e entidades nomeadas 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, analisaremos 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 chave-valor, marcas de seleção e entidades 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 – Analisar e extrair 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 abaixo mais adiante no guia de início rápido:

    Captura de tela: chaves e local do ponto de extremidade no portal do Azure.

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 será atualizado com as dependências.
  5. Crie um novo arquivo chamado index.js no diretório do aplicativo.

    Dica

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

Crie seu aplicativo

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

  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:

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

Extrai texto, tabelas, estrutura, pares chave-valor e entidades nomeadas 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)
Entities:
- "$0.00000625" Quantity - Currency (0.8)
- "MSFT" Organization - <none> (0.99)
- "NASDAQ" Organization - StockExchange (0.99)
- "2.125%" Quantity - Percentage (0.8)
- "2021" DateTime - DateRange (0.8)

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

    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, analisaremos 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>";


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

    const poller = await client.beginAnalyzeDocumentFromUrl("prebuilt-layout", formUrlLayout);

    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, pares chave-valor e entidades com nome.

  • 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 – Analisar e extrair 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 VS 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 abaixo mais adiante no guia de início rápido:

    Captura de tela: chaves e local do ponto de extremidade no portal do Azure.

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 de Reconhecimento de Formulários, você precisará criar uma instância da classe DocumentAnalysisClient. Para fazer isso, você criará um AzureKeyCredential com sua key no portal do Azure e uma instância de DocumentAnalysisClient com o AzureKeyCredential e seu Reconhecimento de Formulários endpoint.

  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:

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

Extrai texto, tabelas, estrutura, pares chave-valor e entidades nomeadas 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, analisaremos 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.

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

  • 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 abaixo mais adiante no guia de início rápido:

    Captura de tela: chaves e local do ponto de extremidade no portal do Azure.

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 tabela abaixo como referência, substitua {modelID} e {your-document-url} por seus valores desejados.

  4. Você precisará de um arquivo de documento em uma URL. Para este guia de início rápido, use os formulários de exemplo fornecidos na tabela abaixo 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
    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
    Faturas prebuilt-invoice https://github.com/Azure-Samples/cognitive-services-REST-api-samples/raw/master/curl/form-recognizer/rest-api/invoice.pdf
    Recebimentos prebuilt-receipt https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/receipt.png
    Documentos de identidade prebuilt-idDocument https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/identity_documents.png
    Cartões 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ê receberá uma resposta 202 (Success) que inclui 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:

{alt-text}

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á a resposta 200 (Success) como saída JSON. O primeiro campo, "status", indica o status da operação. Se a operação não foi 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

Este artigo se aplica a:marca de seleção do Reconhecimento de Formulários v2.1Reconhecimento de Formulários v2.1. Versão posterior:Reconhecimento de Formulários v3.0

Comece a usar o Reconhecimento de Formulários do Azure usando a linguagem de programação de sua escolha ou a API REST. O Reconhecimento de Formulários do Azure é um serviço de inteligência artificial aplicado do Azure baseado em nuvem que usa aprendizado de máquina para extrair pares chave-valor, texto e tabelas de seus documentos. Você pode chamar modelos do Reconhecimento de Formulários facilmente integrando nossos SDKs de biblioteca de clientes aos fluxos de trabalho e aplicativos. 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.

Documentação de referência | Código-fonte da biblioteca | Pacote (NuGet) | Exemplos

Neste início rápido, você usará as seguintes APIs para extrair dados estruturados de formulários e documentos:

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. 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 abaixo mais adiante no guia de início rápido:

    Captura de tela: chaves e local do ponto de extremidade no portal do Azure.

Configuração

  1. Inicie o Visual Studio 2019.

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

    Captura de tela: janela inicial do Visual Studio.

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

    Captura de tela: a página Criar projeto do Visual Studio.

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

    Captura de tela: janela de diálogo Configurar novo projeto do Visual Studio.

  5. Na janela de diálogo Informações adicionais, selecione .NET 5.0 (Atual) e escolha Criar.

    Captura de tela: janela de diálogo Informações adicionais do Visual Studio.

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

    Captura de tela mostrando a janela do pacote NuGet selecionado.

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

    Captura de tela mostrando o menu suspenso do pacote do Reconhecimento de Formulários selecionado.

  3. Selecione a versão 3.1.1 no menu suspenso e selecione Instalar.

Crie seu aplicativo

Para interagir com o serviço de Reconhecimento de Formulários, você precisará criar uma instância da classe FormRecognizerClient. Para fazer isso, você criará um AzureKeyCredential com a chave e uma instância FormRecognizerClient com o AzureKeyCredential e seu Reconhecimento de Formulários endpoint.

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. Inclua as seguintes diretivas using:

using Azure;
using Azure.AI.FormRecognizer;
using Azure.AI.FormRecognizer.Models;
using System.Threading.Tasks;
  1. Defina suas variáveis de ambiente endpoint e key, então crie suas instâncias AzureKeyCredential e FormRecognizerClient:
private static readonly string endpoint = "your-form-recognizer-endpoint";
private static readonly string key = "your-api-key";
private static readonly AzureKeyCredential credential = new AzureKeyCredential(key);
  1. Exclua a linha Console.Writeline("Hello World!"); e adicione um dos exemplos de código Experimentar ao arquivo Program.cs:

    Captura de tela: adicionar o código de exemplo ao método Main.

  2. Selecione um exemplo de código para copiar e colar no método Main do seu aplicativo:

Importante

Lembre-se de remover a chave do seu código quando terminar e nunca poste-a publicamente. Para produção, use um modo seguro de armazenar e acessar suas credenciais, como o Azure Key Vault. Para obter mais informações, confira o artigo Segurança dos Serviços Cognitivos.

Experimente: modelo de layout

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

  • 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.
  • Adicionamos o valor de URI do arquivo à variável formUri.
  • Para extrair o layout de um determinado arquivo em um URI, use o método StartRecognizeContentFromUriAsync.

Adicione o seguinte código ao arquivo Program.cs do aplicativo de layout:


FormRecognizerClient recognizerClient = AuthenticateClient();

Task recognizeContent = RecognizeContent(recognizerClient);
Task.WaitAll(recognizeContent);

private static FormRecognizerClient AuthenticateClient()
            {
                var credential = new AzureKeyCredential(key);
                var client = new FormRecognizerClient(new Uri(endpoint), credential);
                return client;
            }

            private static async Task RecognizeContent(FormRecognizerClient recognizerClient)
        {
            string formUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf";
            FormPageCollection formPages = await recognizerClient
        .StartRecognizeContentFromUri(new Uri(formUrl))
        .WaitForCompletionAsync();

            foreach (FormPage page in formPages)
            {
                Console.WriteLine($"Form Page {page.PageNumber} has {page.Lines.Count} lines.");

                for (int i = 0; i < page.Lines.Count; i++)
                {
                    FormLine line = page.Lines[i];
                    Console.WriteLine($"    Line {i} has {line.Words.Count} word{(line.Words.Count > 1 ? "s" : "")}, and text: '{line.Text}'.");
                }

                for (int i = 0; i < page.Tables.Count; i++)
                {
                    FormTable table = page.Tables[i];
                    Console.WriteLine($"Table {i} has {table.RowCount} rows and {table.ColumnCount} columns.");
                    foreach (FormTableCell cell in table.Cells)
                    {
                        Console.WriteLine($"    Cell ({cell.RowIndex}, {cell.ColumnIndex}) contains text: '{cell.Text}'.");
                    }
                }
            }
        }
    }
}

Experimente: modelo predefinido

Este exemplo demonstra como analisar dados de determinados tipos de documentos comuns com modelos pré-treinados, usando uma fatura como exemplo.

  • Para este exemplo, analisaremos um documento de fatura usando um modelo predefinido. Você pode usar um documento de fatura de exemplo para este início rápido.
  • Adicionamos o valor de URI do arquivo invoiceUri à variável na parte superior do método Main.
  • Para analisar um dado arquivo em um URI, use o método StartRecognizeInvoicesFromUriAsync.
  • Para simplificar, todos os campos 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.

Escolher um modelo predefinido

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. Aqui estão os modelos predefinidos para os modelos pré-construídos atualmente com suporte no serviço de Reconhecimento de Formulários:

  • Fatura: extrai texto, marcas de seleção, tabelas, campos e informações de chave de faturas.
  • Recibo: extrai informações de texto e chave de recibos.
  • Documento de ID: extrai informações de texto e chave de licenças de driver e passaportes internacionais.
  • Cartão de visita: extrai informações de texto e chave de cartões de visita.

Adicione o código a seguir ao método de arquivo Program.cs do aplicativo de fatura predefinido

FormRecognizerClient recognizerClient = AuthenticateClient();

  Task analyzeinvoice = AnalyzeInvoice(recognizerClient, invoiceUrl);
  Task.WaitAll(analyzeinvoice);

   private static FormRecognizerClient AuthenticateClient() {
     var credential = new AzureKeyCredential(key);
     var client = new FormRecognizerClient(new Uri(endpoint), credential);
     return client;
   }

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

   private static async Task AnalyzeInvoice(FormRecognizerClient recognizerClient, string invoiceUrl) {
     var options = new RecognizeInvoicesOptions() {
       Locale = "en-US"
     };
     RecognizedFormCollection invoices = await recognizerClient.StartRecognizeInvoicesFromUriAsync(new Uri(invoiceUrl), options).WaitForCompletionAsync();

     RecognizedForm invoice = invoices[0];

     FormField invoiceIdField;
     if (invoice.Fields.TryGetValue("InvoiceId", out invoiceIdField)) {
       if (invoiceIdField.Value.ValueType == FieldValueType.String) {
         string invoiceId = invoiceIdField.Value.AsString();
         Console.WriteLine($"    Invoice Id: '{invoiceId}', with confidence {invoiceIdField.Confidence}");
       }
     }

     FormField invoiceDateField;
     if (invoice.Fields.TryGetValue("InvoiceDate", out invoiceDateField)) {
       if (invoiceDateField.Value.ValueType == FieldValueType.Date) {
         DateTime invoiceDate = invoiceDateField.Value.AsDate();
         Console.WriteLine($"    Invoice Date: '{invoiceDate}', with confidence {invoiceDateField.Confidence}");
       }
     }

     FormField dueDateField;
     if (invoice.Fields.TryGetValue("DueDate", out dueDateField)) {
       if (dueDateField.Value.ValueType == FieldValueType.Date) {
         DateTime dueDate = dueDateField.Value.AsDate();
         Console.WriteLine($"    Due Date: '{dueDate}', with confidence {dueDateField.Confidence}");
       }
     }

     FormField vendorNameField;
     if (invoice.Fields.TryGetValue("VendorName", out vendorNameField)) {
       if (vendorNameField.Value.ValueType == FieldValueType.String) {
         string vendorName = vendorNameField.Value.AsString();
         Console.WriteLine($"    Vendor Name: '{vendorName}', with confidence {vendorNameField.Confidence}");
       }
     }

     FormField vendorAddressField;
     if (invoice.Fields.TryGetValue("VendorAddress", out vendorAddressField)) {
       if (vendorAddressField.Value.ValueType == FieldValueType.String) {
         string vendorAddress = vendorAddressField.Value.AsString();
         Console.WriteLine($"    Vendor Address: '{vendorAddress}', with confidence {vendorAddressField.Confidence}");
       }
     }

     FormField customerNameField;
     if (invoice.Fields.TryGetValue("CustomerName", out customerNameField)) {
       if (customerNameField.Value.ValueType == FieldValueType.String) {
         string customerName = customerNameField.Value.AsString();
         Console.WriteLine($"    Customer Name: '{customerName}', with confidence {customerNameField.Confidence}");
       }
     }

     FormField customerAddressField;
     if (invoice.Fields.TryGetValue("CustomerAddress", out customerAddressField)) {
       if (customerAddressField.Value.ValueType == FieldValueType.String) {
         string customerAddress = customerAddressField.Value.AsString();
         Console.WriteLine($"    Customer Address: '{customerAddress}', with confidence {customerAddressField.Confidence}");
       }
     }

     FormField customerAddressRecipientField;
     if (invoice.Fields.TryGetValue("CustomerAddressRecipient", out customerAddressRecipientField)) {
       if (customerAddressRecipientField.Value.ValueType == FieldValueType.String) {
         string customerAddressRecipient = customerAddressRecipientField.Value.AsString();
         Console.WriteLine($"    Customer address recipient: '{customerAddressRecipient}', with confidence {customerAddressRecipientField.Confidence}");
       }
     }

     FormField invoiceTotalField;
     if (invoice.Fields.TryGetValue("InvoiceTotal", out invoiceTotalField)) {
       if (invoiceTotalField.Value.ValueType == FieldValueType.Float) {
         float invoiceTotal = invoiceTotalField.Value.AsFloat();
         Console.WriteLine($"    Invoice Total: '{invoiceTotal}', with confidence {invoiceTotalField.Confidence}");
       }
     }
   }
 }
}

Execute seu aplicativo.

Escolha o botão verde Iniciar ao lado de formRecognizer_quickstart para compilar e executar seu programa ou pressione F5.

Captura de tela: executar seu programa do Visual Studio.

Documentação de referência | Código-fonte da biblioteca | Pacote (Maven) | Exemplos

Neste início rápido, você usará as seguintes APIs para extrair dados estruturados de formulários e documentos:

Pré-requisitos

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 abaixo mais adiante no guia de início rápido:

    Captura de tela: chaves e local do ponto de extremidade no portal do Azure.

Configuração

Criar um novo projeto Gradle

Em uma 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
  1. Execute o comando gradle init em seu diretório de trabalho. Esse comando criará 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
    
  2. Quando solicitado a escolher uma DSL, escolha Kotlin.

  3. Aceitar o nome do projeto padrão (form-recognizer-app)

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.

No arquivo build.gradle.kts do projeto, inclua 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 = "3.1.1")
}

Criar um arquivo Java

Do diretório de trabalho, execute o seguinte comando:

mkdir -p src/main/java

Você criará a seguinte estrutura de diretório:

Captura de tela da estrutura de diretórios Java do aplicativo.

Navegue até o diretório do Java e crie um arquivo chamado FormRecognizer.java. Abra-a no editor ou IDE de sua preferência e adicione as seguintes instruções import e a seguinte declaração de pacote:

import com.azure.ai.formrecognizer.*;
import com.azure.ai.formrecognizer.models.*;

import java.util.concurrent.atomic.AtomicReference;
import java.util.List;
import java.util.Map;
import java.time.LocalDate;

import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.http.rest.PagedIterable;
import com.azure.core.util.Context;
import com.azure.core.util.polling.SyncPoller;

Selecione um exemplo de código para copiar e colar no método Main do seu aplicativo:

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. Confira o artigo segurança de Serviços Cognitivos para obter mais informações.

Experimente: modelo de layout

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

  • 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 dado arquivo em um URI, você usará o método beginRecognizeContentFromUrl.
  • Adicionamos o valor de URI do arquivo à variável formUrl no método Main.

Atualize a classe FormRecognizer do aplicativo com o seguinte código (atualize 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):


static final String key = "PASTE_YOUR_FORM_RECOGNIZER_KEY_HERE";
static final String endpoint = "PASTE_YOUR_FORM_RECOGNIZER_ENDPOINT_HERE";

public static void main(String[] args) {FormRecognizerClient recognizerClient = new FormRecognizerClientBuilder()
                .credential(new AzureKeyCredential(key)).endpoint(endpoint).buildClient();

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

    System.out.println("Get form content...");
        GetContent(recognizerClient, formUrl);
  }
    private static void GetContent(FormRecognizerClient recognizerClient, String invoiceUri) {
        String analyzeFilePath = invoiceUri;
        SyncPoller<FormRecognizerOperationResult, List<FormPage>> recognizeContentPoller = recognizerClient
                .beginRecognizeContentFromUrl(analyzeFilePath);

        List<FormPage> contentResult = recognizeContentPoller.getFinalResult();
        // </snippet_getcontent_call>
        // <snippet_getcontent_print>
        contentResult.forEach(formPage -> {
            // Table information
            System.out.println("----Recognizing content ----");
            System.out.printf("Has width: %f and height: %f, measured with unit: %s.%n", formPage.getWidth(),
                    formPage.getHeight(), formPage.getUnit());
            formPage.getTables().forEach(formTable -> {
                System.out.printf("Table has %d rows and %d columns.%n", formTable.getRowCount(),
                        formTable.getColumnCount());
                formTable.getCells().forEach(formTableCell -> {
                    System.out.printf("Cell has text %s.%n", formTableCell.getText());
                });
                System.out.println();
            });
        });
    }

Experimente: modelo predefinido

Este exemplo demonstra como analisar dados de determinados tipos de documentos comuns com modelos pré-treinados, usando uma fatura como exemplo.

  • Para este exemplo, analisaremos um documento de fatura usando um modelo predefinido. Você pode usar um documento de fatura de exemplo para este início rápido.
  • Para analisar um dado arquivo em um URI, você usará o beginRecognizeInvoicesFromUrl.
  • Adicionamos o valor de URI do arquivo à variável invoiceUrl no método Main.
  • Para simplificar, todos os campos 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.

Escolher um modelo predefinido

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. Aqui estão os modelos predefinidos para os modelos pré-construídos atualmente com suporte no serviço de Reconhecimento de Formulários:

  • Fatura: extrai texto, marcas de seleção, tabelas, campos e informações de chave de faturas.
  • Recibo: extrai informações de texto e chave de recibos.
  • Documento de ID: extrai informações de texto e chave de licenças de driver e passaportes internacionais.
  • Cartão de visita: extrai informações de texto e chave de cartões de visita.

Atualize a classe FormRecognizer do aplicativo com o seguinte código (atualize 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):


static final String key = "PASTE_YOUR_FORM_RECOGNIZER_KEY_HERE";
static final String endpoint = "PASTE_YOUR_FORM_RECOGNIZER_ENDPOINT_HERE";

public static void main(String[] args) {
    FormRecognizerClient recognizerClient = new FormRecognizerClientBuilder().credential(new AzureKeyCredential(key)).endpoint(endpoint).buildClient();

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

    System.out.println("Analyze invoice...");
        AnalyzeInvoice(recognizerClient, invoiceUrl);
  }
    private static void AnalyzeInvoice(FormRecognizerClient recognizerClient, String invoiceUrl) {
      SyncPoller < FormRecognizerOperationResult,
        List < RecognizedForm >> recognizeInvoicesPoller = recognizerClient.beginRecognizeInvoicesFromUrl(invoiceUrl);
      List < RecognizedForm > recognizedInvoices = recognizeInvoicesPoller.getFinalResult();

      for (int i = 0; i < recognizedInvoices.size(); i++) {
        RecognizedForm recognizedInvoice = recognizedInvoices.get(i);
        Map < String,
        FormField > recognizedFields = recognizedInvoice.getFields();
        System.out.printf("----------- Recognized invoice info for page %d -----------%n", i);
        FormField vendorNameField = recognizedFields.get("VendorName");
        if (vendorNameField != null) {
            if (FieldValueType.STRING == vendorNameField.getValue().getValueType()) {
                String merchantName = vendorNameField.getValue().asString();
                System.out.printf("Vendor Name: %s, confidence: %.2f%n", merchantName, vendorNameField.getConfidence());
            }
        }

        FormField vendorAddressField = recognizedFields.get("VendorAddress");
        if (vendorAddressField != null) {
            if (FieldValueType.STRING == vendorAddressField.getValue().getValueType()) {
                String merchantAddress = vendorAddressField.getValue().asString();
                System.out.printf("Vendor address: %s, confidence: %.2f%n", merchantAddress, vendorAddressField.getConfidence());
            }
        }

        FormField customerNameField = recognizedFields.get("CustomerName");
        if (customerNameField != null) {
            if (FieldValueType.STRING == customerNameField.getValue().getValueType()) {
                String merchantAddress = customerNameField.getValue().asString();
                System.out.printf("Customer Name: %s, confidence: %.2f%n", merchantAddress, customerNameField.getConfidence());
            }
        }

        FormField customerAddressRecipientField = recognizedFields.get("CustomerAddressRecipient");
        if (customerAddressRecipientField != null) {
            if (FieldValueType.STRING == customerAddressRecipientField.getValue().getValueType()) {
                String customerAddr = customerAddressRecipientField.getValue().asString();
                System.out.printf("Customer Address Recipient: %s, confidence: %.2f%n", customerAddr, customerAddressRecipientField.getConfidence());
            }
        }

        FormField invoiceIdField = recognizedFields.get("InvoiceId");
        if (invoiceIdField != null) {
            if (FieldValueType.STRING == invoiceIdField.getValue().getValueType()) {
                String invoiceId = invoiceIdField.getValue().asString();
                System.out.printf("Invoice Id: %s, confidence: %.2f%n", invoiceId, invoiceIdField.getConfidence());
            }
        }

        FormField invoiceDateField = recognizedFields.get("InvoiceDate");
        if (customerNameField != null) {
            if (FieldValueType.DATE == invoiceDateField.getValue().getValueType()) {
                LocalDate invoiceDate = invoiceDateField.getValue().asDate();
                System.out.printf("Invoice Date: %s, confidence: %.2f%n", invoiceDate, invoiceDateField.getConfidence());
            }
        }

        FormField invoiceTotalField = recognizedFields.get("InvoiceTotal");
        if (customerAddressRecipientField != null) {
            if (FieldValueType.FLOAT == invoiceTotalField.getValue().getValueType()) {
                Float invoiceTotal = invoiceTotalField.getValue().asFloat();
                System.out.printf("Invoice Total: %.2f, confidence: %.2f%n", invoiceTotal, invoiceTotalField.getConfidence());
            }
        }
    }
}

Compilar e executar 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
  1. Execute seu aplicativo com o comando run:
gradle run

Documentação de referência | Código-fonte da biblioteca | Pacote (npm) | Exemplos

Neste início rápido, você usará as seguintes APIs para extrair dados estruturados de formulários e documentos:

Pré-requisitos

  • Assinatura do Azure – crie uma gratuitamente.

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

  • 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 abaixo mais adiante no guia de início rápido:

    Captura de tela: chaves e local do ponto de extremidade no portal do Azure.

Configuração

  1. Crie um aplicativo Node.js. Em uma janela de console (como cmd, PowerShell ou Bash), crie um novo diretório para seu aplicativo e navegue até ele.

    mkdir form-recognizer-app && cd form-recognizer-app
    
  2. Execute o comando npm init para criar um aplicativo do Node com um arquivo package.json.

    npm init
    
  3. Instale o pacote npm da biblioteca de clientes ai-form-recognizer:

    npm install @azure/ai-form-recognizer
    

    O arquivo package.json do seu aplicativo será atualizado com as dependências.

  4. Crie um arquivo chamado index.js, abra-o e importe as seguintes bibliotecas:

    const { FormRecognizerClient, AzureKeyCredential } = require("@azure/ai-form-recognizer");
    
  5. Crie variáveis para a chave e o ponto de extremidade do Azure do recurso:

    const key = "PASTE_YOUR_FORM_RECOGNIZER_KEY_HERE";
    const endpoint = "PASTE_YOUR_FORM_RECOGNIZER_ENDPOINT_HERE";
    
  6. Neste ponto, seu aplicativo JavaScript deve conter as seguintes linhas de código:

    
    const { FormRecognizerClient, AzureKeyCredential } = require("@azure/ai-form-recognizer");
    
    const endpoint = "PASTE_YOUR_FORM_RECOGNIZER_ENDPOINT_HERE";
    const key = "PASTE_YOUR_FORM_RECOGNIZER_KEY_HERE";
    

Selecione um exemplo de código para copiar e colar em seu aplicativo:

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. Confira o artigo segurança de Serviços Cognitivos para obter mais informações.

Experimente: modelo de layout

  • 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.
  • Adicione o valor de URI do arquivo à variável formUrl na parte superior do arquivo.
  • Para analisar um dado arquivo em um URI, você usará o método beginRecognizeContent.

Adicione o código a seguir ao aplicativo de layout na linha abaixo da variável key

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

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

async function recognizeContent() {
    const client = new FormRecognizerClient(endpoint, new AzureKeyCredential(key));
    const poller = await client.beginRecognizeContentFromUrl(formUrl);
    const pages = await poller.pollUntilDone();

    if (!pages || pages.length === 0) {
        throw new Error("Expecting non-empty list of pages!");
    }

    for (const page of pages) {
        console.log(
            `Page ${page.pageNumber}: width ${page.width} and height ${page.height} with unit ${page.unit}`
        );
        for (const table of page.tables) {
            for (const cell of table.cells) {
                console.log(`cell [${cell.rowIndex},${cell.columnIndex}] has text ${cell.text}`);
            }
        }
    }
}

recognizeContent().catch((err) => {
    console.error("The sample encountered an error:", err);
});

Experimente: modelo predefinido

Este exemplo demonstra como analisar dados de determinados tipos de documentos comuns com modelos pré-treinados, usando uma fatura como exemplo. Confira nossa página de conceito predefinida para obter uma lista completa de campos da fatura

  • Para este exemplo, analisaremos um documento de fatura usando um modelo predefinido. Você pode usar um documento de fatura de exemplo para este início rápido.
  • Adicione o valor de URI do arquivo à variável invoiceUrl na parte superior do arquivo.
  • Para analisar um dado arquivo em um URI, você usará o método beginRecognizeInvoices.
  • Para simplificar, todos os campos 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.

Escolher um modelo predefinido

Você não está limitado a faturas – há vários modelos pré-construídos 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. Aqui estão os modelos predefinidos para os modelos pré-construídos atualmente com suporte no serviço de Reconhecimento de Formulários:

  • Fatura: extrai texto, marcas de seleção, tabelas, campos e informações de chave de faturas.
  • Recibo: extrai informações de texto e chave de recibos.
  • Documento de ID: extrai informações de texto e chave de licenças de driver e passaportes internacionais.
  • Cartão de visita: extrai informações de texto e chave de cartões de visita.

Adicione o código a seguir ao aplicativo de fatura predefinido abaixo da variável key


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

async function recognizeInvoices() {

    const client = new FormRecognizerClient(endpoint, new AzureKeyCredential(key));

    const poller = await client.beginRecognizeInvoicesFromUrl(invoiceUrl);
    const [invoice] = await poller.pollUntilDone();

    if (invoice === undefined) {
        throw new Error("Failed to extract data from at least one invoice.");
    }

    /**
     * This is a helper function for printing a simple field with an elemental type.
     */
    function fieldToString(field) {
        const {
            name,
            valueType,
            value,
            confidence
        } = field;
        return `${name} (${valueType}): '${value}' with confidence ${confidence}'`;
    }

    console.log("Invoice fields:");

    /**
     * Invoices contain a lot of optional fields, but they are all of elemental types
     * such as strings, numbers, and dates, so we will just enumerate them all.
     */
    for (const [name, field] of Object.entries(invoice.fields)) {
        if (field.valueType !== "array" && field.valueType !== "object") {
            console.log(`- ${name} ${fieldToString(field)}`);
        }
    }

    // Invoices also support nested line items, so we can iterate over them.
    let idx = 0;

    console.log("- Items:");

    const items = invoice.fields["Items"]?.value;
    for (const item of items ?? []) {
        const value = item.value;

        // Each item has several subfields that are nested within the item. We'll
        // map over this list of the subfields and filter out any fields that
        // weren't found. Not all fields will be returned every time, only those
        // that the service identified for the particular document in question.

        const subFields = [
                "Description",
                "Quantity",
                "Unit",
                "UnitPrice",
                "ProductCode",
                "Date",
                "Tax",
                "Amount"
            ]
            .map((fieldName) => value[fieldName])
            .filter((field) => field !== undefined);

        console.log(
            [
                `  - Item #${idx}`,
                // Now we will convert those fields into strings to display
                ...subFields.map((field) => `    - ${fieldToString(field)}`)
            ].join("\n")
        );
    }
}

recognizeInvoices().catch((err) => {
    console.error("The sample encountered an error:", err);
});

Documentação de referência | Código-fonte da biblioteca | Pacote (PyPi) | Amostras

Neste início rápido, você usará as seguintes APIs para extrair dados estruturados de formulários e documentos:

Pré-requisitos

  • Assinatura do Azure – Criar uma gratuitamente

  • Python 3.x

    • 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.
  • 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 abaixo mais adiante no guia de início rápido:

    Captura de tela: chaves e local do ponto de extremidade no portal do Azure.

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

Criar um novo aplicativo Python

Criar um aplicativo Python chamado form_recognizer_quickstart.py no seu editor ou IDE preferido. Depois, importe as seguintes bibliotecas:

import os
from azure.ai.formrecognizer import FormRecognizerClient
from azure.core.credentials import AzureKeyCredential

Crie variáveis para a chave e o ponto de extremidade do recurso do Azure

endpoint = "YOUR_FORM_RECOGNIZER_ENDPOINT"
key = "YOUR_FORM_RECOGNIZER_KEY"

Neste ponto, seu aplicativo Python deve conter as seguintes linhas de código:

import os
from azure.core.exceptions import ResourceNotFoundError
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential

endpoint = "YOUR_FORM_RECOGNIZER_ENDPOINT"
key = "YOUR_FORM_RECOGNIZER_KEY"

Selecione um exemplo de código para copiar e colar em seu aplicativo:

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. Confira o artigo segurança de Serviços Cognitivos para obter mais informações.

Experimente: modelo de layout

  • 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.
  • Adicione o valor de URI do arquivo à variável formUrl na parte superior do arquivo.
  • Para analisar um dado arquivo em um URI, você usará o método begin_recognize_content_from_url.

Adicione o código a seguir ao aplicativo de layout na linha abaixo da variável key


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

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

    form_recognizer_client = FormRecognizerClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller = form_recognizer_client.begin_recognize_content_from_url(formUrl)
    form_pages = poller.result()

    for idx, content in enumerate(form_pages):
        print(
            "Page has width: {} and height: {}, measured with unit: {}".format(
                content.width, content.height, content.unit
            )
        )
        for table_idx, table in enumerate(content.tables):
            print(
                "Table # {} has {} rows and {} columns".format(
                    table_idx, table.row_count, table.column_count
                )
            )
            print(
                "Table # {} location on page: {}".format(
                    table_idx, format_bounding_box(table.bounding_box)
                )
            )
            for cell in table.cells:
                print(
                    "...Cell[{}][{}] has text '{}' within bounding box '{}'".format(
                        cell.row_index,
                        cell.column_index,
                        cell.text,
                        format_bounding_box(cell.bounding_box),
                    )
                )

        for line_idx, line in enumerate(content.lines):
            print(
                "Line # {} has word count '{}' and text '{}' within bounding box '{}'".format(
                    line_idx,
                    len(line.words),
                    line.text,
                    format_bounding_box(line.bounding_box),
                )
            )
            if line.appearance:
                if (
                    line.appearance.style_name == "handwriting"
                    and line.appearance.style_confidence > 0.8
                ):
                    print(
                        "Text line '{}' is handwritten and might be a signature.".format(
                            line.text
                        )
                    )
            for word in line.words:
                print(
                    "...Word '{}' has a confidence of {}".format(
                        word.text, word.confidence
                    )
                )

        for selection_mark in content.selection_marks:
            print(
                "Selection mark is '{}' within bounding box '{}' and has a confidence of {}".format(
                    selection_mark.state,
                    format_bounding_box(selection_mark.bounding_box),
                    selection_mark.confidence,
                )
            )
        print("----------------------------------------")


if __name__ == "__main__":
    recognize_content()

Experimente: modelo predefinido

Este exemplo demonstra como analisar dados de determinados tipos de documentos comuns com modelos pré-treinados, usando uma fatura como exemplo. Confira nossa página de conceito predefinida para obter uma lista completa de campos da fatura

  • Para este exemplo, analisaremos um documento de fatura usando um modelo predefinido. Você pode usar um documento de fatura de exemplo para este início rápido.
  • Adicione o valor de URI do arquivo à variável 'formUrl' na parte superior do arquivo.
  • Para analisar um determinado arquivo em um URI, você usará o método 'begin_recognize_invoices_from_url'.
  • Para simplificar, todos os campos 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.

Escolher um modelo predefinido

Você não está limitado a faturas – há vários modelos pré-construídos 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. Aqui estão os modelos predefinidos para os modelos pré-construídos atualmente com suporte no serviço de Reconhecimento de Formulários:

  • Fatura: extrai texto, marcas de seleção, tabelas, campos e informações de chave de faturas.
  • Recibo: extrai informações de texto e chave de recibos.
  • Documento de ID: extrai informações de texto e chave de licenças de driver e passaportes internacionais.
  • Cartão de visita: extrai informações de texto e chave de cartões de visita.

Adicione o código a seguir ao aplicativo de fatura predefinido abaixo da variável key


def recognize_invoice():

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

    form_recognizer_client = FormRecognizerClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller = form_recognizer_client.begin_recognize_invoices_from_url(
        invoiceUrl, locale="en-US"
    )
    invoices = poller.result()

    for idx, invoice in enumerate(invoices):
        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):
            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__":
    recognize_invoice()

Execute seu aplicativo.

  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

| API REST do Reconhecimento de Formulários | Referência da API REST do Azure |

Neste início rápido, você usará as seguintes APIs para extrair dados estruturados de formulários e documentos:

Pré-requisitos

  • Assinatura do Azure – Criar uma gratuitamente

  • cURL instalado.

  • PowerShell versão 6.0+ ou um aplicativo de linha de comando semelhante.

  • 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 abaixo mais adiante no guia de início rápido:

    Captura de tela: chaves e local do ponto de extremidade no portal do Azure.

Selecione um exemplo de código para copiar e colar em seu aplicativo:

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. Confira o artigo segurança de Serviços Cognitivos para obter mais informações.

Experimente: modelo de layout

  • 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.
  1. Substitua {endpoint} pelo ponto de extremidade que você obteve com a assinatura do Reconhecimento de Formulários.
  2. Substitua {key} pela chave que você copiou na etapa anterior.
  3. Substitua \"{your-document-url} por uma URL de formulário de exemplo:
https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf

Solicitação

curl -v -i POST "https://{endpoint}/formrecognizer/v2.1/layout/analyze" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: {key}" --data-ascii "{​​​​​​​'urlSource': '{your-document-url}'}​​​​​​​​"

Operation-Location

Você receberá uma resposta 202 (Success) com um cabeçalho Operation-Location. O valor desse cabeçalho contém uma ID de resultado que você pode usar para consultar o status da operação assíncrona e obter os resultados:

https://cognitiveservice/formrecognizer/v2.1/layout/analyzeResults/ {resultId} .

No exemplo a seguir, como parte da URL, a cadeia de caracteres após analyzeResults/ é a ID do resultado.

https://cognitiveservice/formrecognizer/v2/layout/analyzeResults/54f0b076-4e38-43e5-81bd-b85b8835fdfb

Obter resultados do layout

Depois de ter chamado a API Analisar Layout , você chama a API Obter Resultados da Análise de Layout para obter o status da operação e os dados extraídos. Antes de executar o comando, faça essas alterações:

  1. Substitua {endpoint} pelo ponto de extremidade que você obteve com a assinatura do Reconhecimento de Formulários.
  2. Substitua {key} pela chave que você copiou na etapa anterior.
  3. Substitua {resultId} pela ID de resultado da etapa anterior.

Solicitação

curl -v -X GET "https://{endpoint}/formrecognizer/v2.1/layout/analyzeResults/{resultId}" -H "Ocp-Apim-Subscription-Key: {key}"

Examinar os resultados

Você receberá a resposta 200 (success) com conteúdo JSON.

Confira a imagem da fatura a seguir e a respectiva saída em JSON correspondente.

  • O nó "readResults" contém cada linha de texto com seu respectivo posicionamento de caixa delimitadora na página.
  • O nó selectionMarks mostra cada marca de seleção (caixa de seleção, marca de opção) e indica se o status está como "marcado" ou "não marcado".
  • A seção "pageResults" inclui as tabelas extraídas. Para cada tabela, o índice de texto, de linha e de coluna, abrangência de linha e coluna, caixa delimitadora e mais são extraídos.

Documento de declaração de projeto da Contoso com uma tabela.

Corpo da resposta

É possível exibir a saída de exemplo completo no GitHub.

Experimente: modelo predefinido

  • Para este exemplo, analisaremos um documento de fatura usando um modelo predefinido. Você pode usar um documento de fatura de exemplo para este início rápido.

Escolher um modelo predefinido

Você não está limitado a faturas – há vários modelos pré-construídos 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. Aqui estão os modelos predefinidos para os modelos pré-construídos atualmente com suporte no serviço de Reconhecimento de Formulários:

  • Fatura: extrai texto, marcas de seleção, tabelas, campos e informações de chave de faturas.
  • Recibo: extrai informações de texto e chave de recibos.
  • Documento de ID: extrai informações de texto e chave de licenças de driver e passaportes internacionais.
  • Cartão de visita: extrai informações de texto e chave de cartões de visita.

Antes de executar o comando, faça essas alterações:

  1. Substitua {endpoint} pelo ponto de extremidade que você obteve com a assinatura do Reconhecimento de Formulários.

  2. Substitua {key} pela chave que você copiou na etapa anterior.

  3. Substitua \"{your-document-url} por uma URL de fatura de exemplo:

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

Solicitação

curl -v -i POST https://{endpoint}/formrecognizer/v2.1/prebuilt/invoice/analyze" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key:  {key}" --data-ascii "{​​​​​​​'urlSource': '{your invoice URL}'}​​​​​​​​"

Operation-Location

Você receberá uma resposta 202 (Success) com um cabeçalho Operation-Location. O valor desse cabeçalho contém uma ID de resultado que você pode usar para consultar o status da operação assíncrona e obter os resultados:

https://cognitiveservice/formrecognizer/v2.1/prebuilt/receipt/analyzeResults/ {resultId}

No exemplo a seguir, como parte da URL, a cadeia de caracteres após analyzeResults/ é a ID do resultado:

https://cognitiveservice/formrecognizer/v2.1/prebuilt/invoice/analyzeResults/54f0b076-4e38-43e5-81bd-b85b8835fdfb

Obter resultados da fatura

Depois de chamar a API Analisar Fatura, chame a API Obter Resultados da Análise de Fatura para obter o status da operação e os dados extraídos. Antes de executar o comando, faça essas alterações:

  1. Substitua {endpoint} pelo ponto de extremidade que você obteve com a chave do Reconhecimento de Formulários. Encontre-o na guia Visão geral de recursos do Reconhecimento de Formulários.
  2. Substitua {resultId} pela ID de resultado da etapa anterior.
  3. Substitua {key} pela sua chave.

Solicitação

curl -v -X GET "https://{endpoint}/formrecognizer/v2.1/prebuilt/invoice/analyzeResults/{resultId}" -H "Ocp-Apim-Subscription-Key: {key}"

Examinar a resposta

Você receberá a resposta 200 (Success) como saída JSON.

  • O campo "readResults" contém todas as linhas de texto que foram extraídas da fatura.
  • O "pageResults" inclui as tabelas e as marcas de seleção extraídas da fatura.
  • O campo "documentResults" contém informações de chave/valor para as partes mais relevantes da fatura.

Confira o documento de fatura de exemplo.

Corpo da resposta

Confira a saída de exemplo completo no GitHub.

É isso, parabéns! Neste início rápido, você usou modelos do Reconhecimento de Formulários para analisar vários formulários de maneiras diferentes.

Próximas etapas

  • Para obter uma experiência aprimorada e qualidade avançada do modelo, experimente o Reconhecimento de Formulários v3.0 Studio.

  • O Studio v3.0 dá suporte a qualquer modelo treinado usando os dados rotulados da v2.1.

  • Você pode consultar o guia de migração de API para obter informações detalhadas sobre como migrar da v2.1 para a v3.0.

  • Consulte nossa API REST ou C#, Java, JavaScript ou Python SDK de início rápido para começar a usar a versão v3.0.