Compartilhar via


Introdução à Informação de Documentos

Importante

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

Este conteúdo se aplica a: marca de seleção v4.0 (versão prévia) Versões anteriores: marca de seleção azul v3.1 (GA) marca de seleção azul v3.0 (GA)

  • Introdução à IA do Azure para Informação de Documentos na versão prévia mais recente (2024-07-31-preview).

Este conteúdo se aplica a: marca de seleção v3.1 (GA) Versões anteriores: marca de seleção azul v3.0 marca de seleção azul v2.1

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

Este conteúdo se aplica a: marca de seleção v3.0 (GA) Versão mais recente: marca de seleção azul v3.1 marca de seleção azul v2.1

  • Introdução ao Reconhecimento de Formulários do Azure na versão herdada para disponibilidade geral (2022-08-31).
  • A IA do Azure para Informação de Documentos / Reconhecimento de Formulários é um serviço da IA do Azure baseado em nuvem que usa modelos de aprendizado de máquina para extrair pares de chave-valor, texto, tabelas e dados importantes dos documentos.

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

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

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

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

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

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

Pré-requisitos

  • Um recurso de Inteligência de Documento ou serviços de IA do Azure. Depois de ter sua assinatura do Azure, crie um recurso de serviço único ou multisserviço de IA do Azure, no portal do Azure, para obter sua chave e ponto de extremidade do serviço.

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

Dica

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

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

    Captura de tela da localização das chaves e do ponto de extremidade no portal do Azure.

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

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

Dica

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

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

    Captura de tela da localização das chaves e 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 da 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.

  1. Na janela do diálogo Configurar seu novo projeto, insira doc_intel_quickstart na caixa Nome do projeto. Em seguida, escolha Avançar.
  1. Na janela do diálogo Configurar seu novo projeto, insira form_recognizer_quickstart na caixa Nome do projeto. Em seguida, escolha Avançar.
  1. Na janela de diálogo Informações adicionais, selecione .NET 8.0 (Suporte de longo prazo) e, em seguida, selecione Criar.

    Captura de tela da 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 em seu projeto doc_intel_quickstart e selecione Gerenciar Pacotes NuGet... .

    Captura de tela da janela selecionada do pacote de pré-lançamento do NuGet no Visual Studio.

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

  3. Marque a caixa de seleção Include prerelease.

    Captura de tela do pacote NuGet selecionado em pré-lançamento no Visual Studio.

  4. Escolha a versão no menu suspenso e instale o pacote no projeto.

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

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

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

    Captura de tela do pacote de Reconhecimento de Formulários NuGet selecionado no Visual Studio.

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

    Captura de tela da janela do pacote NuGet no Visual Studio.

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

    Captura de tela do pacote herdado NuGet selecionado no Visual Studio.

Crie seu aplicativo

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

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

Observação

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

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

Importante

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

Modelo de layout

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

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

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


using Azure;
using Azure.AI.DocumentIntelligence;

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

AnalyzeDocumentContent content = new AnalyzeDocumentContent()
{
    UrlSource= fileUri
};

Operation<AnalyzeResult> operation = await client.AnalyzeDocumentAsync(WaitUntil.Completed, "prebuilt-layout", content);

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)," +
        $" 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}:");
        Console.WriteLine($"    Content: '{line.Content}'");

        Console.Write("    Bounding polygon, with points ordered clockwise:");
        for (int j = 0; j < line.Polygon.Count; j += 2)
        {
            Console.Write($" ({line.Polygon[j]}, {line.Polygon[j + 1]})");
        }

        Console.WriteLine();
    }

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

        Console.WriteLine($"  Selection Mark {i} is {selectionMark.State}.");
        Console.WriteLine($"    State: {selectionMark.State}");

        Console.Write("    Bounding polygon, with points ordered clockwise:");
        for (int j = 0; j < selectionMark.Polygon.Count; j++)
        {
            Console.Write($" ({selectionMark.Polygon[j]}, {selectionMark.Polygon[j + 1]})");
        }

        Console.WriteLine();
    }
}

for (int i = 0; i < result.Paragraphs.Count; i++)
{
    DocumentParagraph paragraph = result.Paragraphs[i];

    Console.WriteLine($"Paragraph {i}:");
    Console.WriteLine($"  Content: {paragraph.Content}");

    if (paragraph.Role != null)
    {
        Console.WriteLine($"  Role: {paragraph.Role}");
    }
}

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)
        {
            var handwrittenContent = result.Content.Substring(span.Offset, span.Length);
            Console.WriteLine($"  {handwrittenContent}");
        }
    }
}

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}) is a '{cell.Kind}' with content: {cell.Content}");
    }
}

Executar seu aplicativo

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

Captura de tela do botão executar o programa do Visual Studio.

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

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

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

//sample document
Uri fileUri = new Uri ("https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf");

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

AnalyzeResult result = operation.Value;

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

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

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

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

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

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

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

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

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

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

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

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

Executar seu aplicativo

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

Captura de tela do local do botão de execução do programa Visual Studio.

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.

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 polygon (points ordered clockwise):");

        for (int j = 0; j < line.BoundingPolygon.Count; j++)
        {
            Console.WriteLine($"      Point {j} => X: {line.BoundingPolygon[j].X}, Y: {line.BoundingPolygon[j].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 polygon (points ordered clockwise):");

        for (int j = 0; j < selectionMark.BoundingPolygon.Count; j++)
        {
            Console.WriteLine($"      Point {j} => X: {selectionMark.BoundingPolygon[j].X}, Y: {selectionMark.BoundingPolygon[j].Y}");
        }
    }
}

Console.WriteLine("Paragraphs:");

foreach (DocumentParagraph paragraph in result.Paragraphs)
{
    Console.WriteLine($"  Paragraph content: {paragraph.Content}");

    if (paragraph.Role != null)
    {
        Console.WriteLine($"    Role: {paragraph.Role}");
    }
}

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}'.");
    }
}
Extract the layout of a document from a file stream
To extract the layout from a given file at a file stream, use the AnalyzeDocument method and pass prebuilt-layout as the model ID. The returned value is an AnalyzeResult object containing data about the submitted document.

string filePath = "<filePath>";
using var stream = new FileStream(filePath, FileMode.Open);

AnalyzeDocumentOperation operation = await client.AnalyzeDocumentAsync(WaitUntil.Completed, "prebuilt-layout", stream);
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 polygon (points ordered clockwise):");

        for (int j = 0; j < line.BoundingPolygon.Count; j++)
        {
            Console.WriteLine($"      Point {j} => X: {line.BoundingPolygon[j].X}, Y: {line.BoundingPolygon[j].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 polygon (points ordered clockwise):");

        for (int j = 0; j < selectionMark.BoundingPolygon.Count; j++)
        {
            Console.WriteLine($"      Point {j} => X: {selectionMark.BoundingPolygon[j].X}, Y: {selectionMark.BoundingPolygon[j].Y}");
        }
    }
}

Console.WriteLine("Paragraphs:");

foreach (DocumentParagraph paragraph in result.Paragraphs)
{
    Console.WriteLine($"  Paragraph content: {paragraph.Content}");

    if (paragraph.Role != null)
    {
        Console.WriteLine($"    Role: {paragraph.Role}");
    }
}

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

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

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

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

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

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

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

Executar seu aplicativo

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

Captura de tela da opção executar seu programa do Visual Studio.

Modelo predefinido

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

Dica

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

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

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


using Azure;
using Azure.AI.DocumentIntelligence;

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

AnalyzeDocumentContent content = new AnalyzeDocumentContent()
{
    UrlSource = invoiceUri
};

Operation<AnalyzeResult> operation = await client.AnalyzeDocumentAsync(WaitUntil.Completed, "prebuilt-invoice", content);

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)
        && vendorNameField.Type == DocumentFieldType.String)
    {
        string vendorName = vendorNameField.ValueString;
        Console.WriteLine($"Vendor Name: '{vendorName}', with confidence {vendorNameField.Confidence}");
    }

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

    if (document.Fields.TryGetValue("Items", out DocumentField itemsField)
        && itemsField.Type == DocumentFieldType.Array)
    {
        foreach (DocumentField itemField in itemsField.ValueArray)
        {
            Console.WriteLine("Item:");

            if (itemField.Type == DocumentFieldType.Object)
            {
                IReadOnlyDictionary<string, DocumentField> itemFields = itemField.ValueObject;

                if (itemFields.TryGetValue("Description", out DocumentField itemDescriptionField)
                    && itemDescriptionField.Type == DocumentFieldType.String)
                {
                    string itemDescription = itemDescriptionField.ValueString;
                    Console.WriteLine($"  Description: '{itemDescription}', with confidence {itemDescriptionField.Confidence}");
                }

                if (itemFields.TryGetValue("Amount", out DocumentField itemAmountField)
                    && itemAmountField.Type == DocumentFieldType.Currency)
                {
                    CurrencyValue itemAmount = itemAmountField.ValueCurrency;
                    Console.WriteLine($"  Amount: '{itemAmount.CurrencySymbol}{itemAmount.Amount}', with confidence {itemAmountField.Confidence}");
                }
            }
        }
    }

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

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

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

Executar seu aplicativo

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

Captura de tela do botão executar o programa do Visual Studio.

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


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

//set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal to create your `AzureKeyCredential` and `FormRecognizerClient` instance
string endpoint = "<your-endpoint>";
string key = "<your-key>";
AzureKeyCredential credential = new AzureKeyCredential(key);
DocumentAnalysisClient client = new DocumentAnalysisClient(new Uri(endpoint), credential);

//sample invoice document

Uri invoiceUri = new Uri ("https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf");

Operation operation = await client.AnalyzeDocumentAsync(WaitUntil.Completed, "prebuilt-invoice", invoiceUri);

AnalyzeResult result = operation.Value;

for (int i = 0; i < result.Documents.Count; i++)
{
    Console.WriteLine($"Document {i}:");

    AnalyzedDocument document = result.Documents[i];

    if (document.Fields.TryGetValue("VendorName", out DocumentField vendorNameField))
    {
        if (vendorNameField.FieldType == DocumentFieldType.String)
        {
            string vendorName = vendorNameField.Value.AsString();
            Console.WriteLine($"Vendor Name: '{vendorName}', with confidence {vendorNameField.Confidence}");
        }
    }

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

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

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

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

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

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

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

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

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

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

Executar seu aplicativo

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

Captura de tela do local do botão de execução do programa Visual Studio.

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.

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


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

//set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal to create your `AzureKeyCredential` and `FormRecognizerClient` instance
string endpoint = "<your-endpoint>";
string key = "<your-key>";
AzureKeyCredential credential = new AzureKeyCredential(key);
DocumentAnalysisClient client = new DocumentAnalysisClient(new Uri(endpoint), credential);

//sample invoice document

Uri invoiceUri = new Uri ("https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf");

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

Captura de tela da opção executar seu programa do Visual Studio.

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

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

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

Pré-requisitos

  • Assinatura do Azure – crie uma gratuitamente.

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

    Dica

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

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

    Dica

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

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

    Captura de tela da localização das chaves e do ponto de extremidade no portal do Azure.

Configuração

Criar um novo projeto Gradle

  1. Em uma janela de console (como o cmd, o PowerShell ou o Bash), crie um diretório para seu aplicativo chamado doc-intel-app e navegue até ele.

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

    gradle init --type basic
    
  3. Quando solicitado a escolher uma DSL, escolha Kotlin.

  4. Aceite o nome do projeto padrão (doc-intel-app) selecionando Retornar ou Enter.

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

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

    gradle init --type basic
    
  3. Quando solicitado a escolher uma DSL, escolha Kotlin.

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

Instalar a biblioteca de clientes

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

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

   plugins {
       java
       application
   }
   application {
       mainClass.set("DocIntelligence")
   }
   repositories {
       mavenCentral()
   }
   dependencies {
       implementation group: 'com.azure', name: 'azure-ai-documentintelligence', version: '1.0.0-beta.4'

   }

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

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

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

   }

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

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

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


   }

Criar um aplicativo Java

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

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

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

    mkdir -p src/main/java
    

    Você cria a seguinte estrutura de diretório:

    Captura de tela da estrutura de diretórios Java

  1. Navegue até o diretório do java e crie um arquivo chamado DocIntelligence.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.
    • Digite o comando a seguir New-Item DocIntelligence.java.
  2. Abra o arquivo DocIntelligence.java . Copie e cole um dos seguintes exemplos de código no aplicativo:

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

    Dica

    • Você pode criar um arquivo usando o PowerShell.
    • Abra uma janela do PowerShell no diretório do projeto mantendo a tecla Shift e clicando com o botão direito do mouse na pasta.
    • No terminal, digite o comando New-Item FormRecognizer.java.
  2. Abra o arquivo FormRecognizer.java . Copie e cole um dos seguintes exemplos de código no aplicativo:

Importante

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

Modelo de layout

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

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

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


import com.azure.ai.documentintelligence.models.AnalyzeDocumentRequest;
import com.azure.ai.documentintelligence.models.AnalyzeResult;
import com.azure.ai.documentintelligence.models.AnalyzeResultOperation;
import com.azure.ai.documentintelligence.models.DocumentTable;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.util.List;

public class DocIntelligence {

  // 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 `DocumentIntelligenceClient` instance and `AzureKeyCredential` variable
    DocumentIntelligenceClient client = new DocumentIntelligenceClientBuilder()
      .credential(new AzureKeyCredential(key))
      .endpoint(endpoint)
      .buildClient();

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

    SyncPoller <AnalyzeResultOperation, AnalyzeResultOperation> analyzeLayoutPoller =
      client.beginAnalyzeDocument(modelId,
          null,
          null,
          null,
          null,
          null,
          null,
          new AnalyzeDocumentRequest().setUrlSource(documentUrl));

    AnalyzeResult analyzeLayoutResult = analyzeLayoutPoller.getFinalResult().getAnalyzeResult();

    // 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.getPolygon()));

      // 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.getPolygon(),
          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();
    }

    // styles
    analyzeLayoutResult.getStyles().forEach(documentStyle -
      > System.out.printf("Document is handwritten %s.%n", documentStyle.isHandwritten()));
  }
}

Compile e execute o aplicativo

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

  1. Crie seu aplicativo com o comando build:

    gradle build
    
  2. Execute seu aplicativo com o comando run:

    gradle run
    

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


import com.azure.ai.formrecognizer.documentanalysis.models.*;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClient;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClientBuilder;

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

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

public class FormRecognizer {

  // set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal
  private static final String endpoint = "<your-endpoint>";
  private static final String key = "<your-key>";

  public static void main(String[] args) {

    // create your `DocumentAnalysisClient` instance and `AzureKeyCredential` variable
    DocumentAnalysisClient client = new DocumentAnalysisClientBuilder()
      .credential(new AzureKeyCredential(key))
      .endpoint(endpoint)
      .buildClient();

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

    SyncPoller < OperationResult, AnalyzeResult > analyzeLayoutResultPoller =
      client.beginAnalyzeDocumentFromUrl(modelId, documentUrl);

    AnalyzeResult analyzeLayoutResult = analyzeLayoutResultPoller.getFinalResult();

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

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

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

      // selection marks
      documentPage.getSelectionMarks().forEach(documentSelectionMark ->
        System.out.printf("Selection mark is %s and is within a bounding polygon %s with confidence %.2f.%n",
          documentSelectionMark.getState().toString(),
          documentSelectionMark.getBoundingPolygon().toString(),
          documentSelectionMark.getConfidence()));
    });

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

Compile e execute o aplicativo

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

  1. Crie seu aplicativo com o comando build:

    gradle build
    
  2. Execute seu aplicativo com o comando run:

    gradle run
    

Saída do modelo de layout

Aqui está um trecho da saída esperada:

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

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

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


import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClient;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClientBuilder;
import com.azure.ai.formrecognizer.documentanalysis.models.AnalyzeResult;
import com.azure.ai.formrecognizer.documentanalysis.models.OperationResult;
import com.azure.ai.formrecognizer.documentanalysis.models.DocumentTable;
import com.azure.ai.formrecognizer.documentanalysis.models.Point;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.util.List;
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 > analyzeLayoutPoller =
      client.beginAnalyzeDocumentFromUrl(modelId, documentUrl);

    AnalyzeResult analyzeLayoutResult = analyzeLayoutPoller.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(),
          getBoundingCoordinates(documentLine.getBoundingPolygon())));

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

    // styles
    analyzeLayoutResult.getStyles().forEach(documentStyle -
      > System.out.printf("Document is handwritten %s.%n", documentStyle.isHandwritten()));
  }

  /**
   * Utility function to get the bounding polygon coordinates.
   */
  private static String getBoundingCoordinates(List < Point > boundingPolygon) {
    return boundingPolygon.stream().map(point -> String.format("[%.2f, %.2f]", point.getX(),
      point.getY())).collect(Collectors.joining(", "));
  }
}

Compile e execute o aplicativo

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

  1. Crie seu aplicativo com o comando build:

    gradle build
    
  2. Execute seu aplicativo com o comando run:

    gradle run
    

Modelo predefinido

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

Dica

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

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

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


import com.azure.ai.documentintelligence.models.AnalyzeDocumentRequest;
import com.azure.ai.documentintelligence.models.AnalyzeResult;
import com.azure.ai.documentintelligence.models.AnalyzeResultOperation;
import com.azure.ai.documentintelligence.models.Document;
import com.azure.ai.documentintelligence.models.DocumentField;
import com.azure.ai.documentintelligence.models.DocumentFieldType;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.io.IOException;
import java.time.LocalDate;
import java.util.List;
import java.util.Map;

public class DocIntelligence {

  // 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) {

    // 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";

    public static void main(final String[] args) throws IOException {

      // Instantiate a client that will be used to call the service.
      DocumentIntelligenceClient client = new DocumentIntelligenceClientBuilder()
        .credential(new AzureKeyCredential(key))
        .endpoint(endpoint)
        .buildClient();

      SyncPoller<AnalyzeResultOperation, AnalyzeResultOperation > analyzeInvoicesPoller =
        client.beginAnalyzeDocument(modelId, 
            null,
            null,
            null,
            null,
            null,
            null,
            new AnalyzeDocumentRequest().setUrlSource(invoiceUrl));

      AnalyzeResult analyzeInvoiceResult = analyzeInvoicesPoller.getFinalResult().getAnalyzeResult();

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

        DocumentField invoiceTotalField = invoiceFields.get("InvoiceTotal");
        if (customerAddressRecipientField != null) {
          if (DocumentFieldType.NUMBER == invoiceTotalField.getType()) {
            Double invoiceTotal = invoiceTotalField.getValueNumber();
            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.ARRAY == invoiceItemsField.getType()) {
            List < DocumentField > invoiceItems = invoiceItemsField.getValueArray();
            invoiceItems.stream()
              .filter(invoiceItem -> DocumentFieldType.OBJECT == invoiceItem.getType())
              .map(documentField -> documentField.getValueObject())
              .forEach(documentFieldMap -> documentFieldMap.forEach((key, documentField) -> {

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

                if ("Description".equals(key)) {
                  if (DocumentFieldType.STRING == documentField.getType()) {
                    String name = documentField.getValueString();
                    System.out.printf("Description: %s, confidence: %.2fs%n",
                      name, documentField.getConfidence());
                  }
                }
                if ("Quantity".equals(key)) {
                  if (DocumentFieldType.NUMBER == documentField.getType()) {
                    Double quantity = documentField.getValueNumber();
                    System.out.printf("Quantity: %f, confidence: %.2f%n",
                      quantity, documentField.getConfidence());
                  }
                }
                if ("UnitPrice".equals(key)) {
                  if (DocumentFieldType.NUMBER == documentField.getType()) {
                    Double unitPrice = documentField.getValueNumber();
                    System.out.printf("Unit Price: %f, confidence: %.2f%n",
                      unitPrice, documentField.getConfidence());
                  }
                }
                if ("ProductCode".equals(key)) {
                  if (DocumentFieldType.NUMBER == documentField.getType()) {
                    Double productCode = documentField.getValueNumber();
                    System.out.printf("Product Code: %f, confidence: %.2f%n",
                      productCode, documentField.getConfidence());
                  }
                }
              }));
          }
        }
      }
    }
  }
}

Compile e execute o aplicativo

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

  1. Crie seu aplicativo com o comando build:

    gradle build
    
  2. Execute seu aplicativo com o comando run:

    gradle run
    

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


import com.azure.ai.formrecognizer.documentanalysis.models.*;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClient;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClientBuilder;

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

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

public class FormRecognizer {

  // set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal
  private static final String endpoint = "<your-endpoint>";
  private static final String key = "<your-key>";

  public static void main(final String[] args) throws IOException {

    // create your `DocumentAnalysisClient` instance and `AzureKeyCredential` variable
    DocumentAnalysisClient client = new DocumentAnalysisClientBuilder()
      .credential(new AzureKeyCredential(key))
      .endpoint(endpoint)
      .buildClient();

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

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

    AnalyzeResult analyzeInvoiceResult = analyzeInvoicePoller.getFinalResult();

    for (int i = 0; i < analyzeInvoiceResult.getDocuments().size(); i++) {
      AnalyzedDocument analyzedInvoice = analyzeInvoiceResult.getDocuments().get(i);
      Map < String, DocumentField > invoiceFields = analyzedInvoice.getFields();
      System.out.printf("----------- Analyzing invoice  %d -----------%n", i);
      DocumentField vendorNameField = invoiceFields.get("VendorName");
      if (vendorNameField != null) {
        if (DocumentFieldType.STRING == vendorNameField.getType()) {
          String merchantName = vendorNameField.getValueAsString();
          System.out.printf("Vendor Name: %s, confidence: %.2f%n",
            merchantName, vendorNameField.getConfidence());
        }
      }

      DocumentField vendorAddressField = invoiceFields.get("VendorAddress");
      if (vendorAddressField != null) {
        if (DocumentFieldType.STRING == vendorAddressField.getType()) {
          String merchantAddress = vendorAddressField.getValueAsString();
          System.out.printf("Vendor address: %s, confidence: %.2f%n",
            merchantAddress, vendorAddressField.getConfidence());
        }
      }

      DocumentField customerNameField = invoiceFields.get("CustomerName");
      if (customerNameField != null) {
        if (DocumentFieldType.STRING == customerNameField.getType()) {
          String merchantAddress = customerNameField.getValueAsString();
          System.out.printf("Customer Name: %s, confidence: %.2f%n",
            merchantAddress, customerNameField.getConfidence());
        }
      }

      DocumentField customerAddressRecipientField = invoiceFields.get("CustomerAddressRecipient");
      if (customerAddressRecipientField != null) {
        if (DocumentFieldType.STRING == customerAddressRecipientField.getType()) {
          String customerAddr = customerAddressRecipientField.getValueAsString();
          System.out.printf("Customer Address Recipient: %s, confidence: %.2f%n",
            customerAddr, customerAddressRecipientField.getConfidence());
        }
      }

      DocumentField invoiceIdField = invoiceFields.get("InvoiceId");
      if (invoiceIdField != null) {
        if (DocumentFieldType.STRING == invoiceIdField.getType()) {
          String invoiceId = invoiceIdField.getValueAsString();
          System.out.printf("Invoice ID: %s, confidence: %.2f%n",
            invoiceId, invoiceIdField.getConfidence());
        }
      }

      DocumentField invoiceDateField = invoiceFields.get("InvoiceDate");
      if (customerNameField != null) {
        if (DocumentFieldType.DATE == invoiceDateField.getType()) {
          LocalDate invoiceDate = invoiceDateField.getValueAsDate();
          System.out.printf("Invoice Date: %s, confidence: %.2f%n",
            invoiceDate, invoiceDateField.getConfidence());
        }
      }

      DocumentField invoiceTotalField = invoiceFields.get("InvoiceTotal");
      if (customerAddressRecipientField != null) {
        if (DocumentFieldType.DOUBLE == invoiceTotalField.getType()) {
          Double invoiceTotal = invoiceTotalField.getValueAsDouble();
          System.out.printf("Invoice Total: %.2f, confidence: %.2f%n",
            invoiceTotal, invoiceTotalField.getConfidence());
        }
      }

      DocumentField invoiceItemsField = invoiceFields.get("Items");
      if (invoiceItemsField != null) {
        System.out.printf("Invoice Items: %n");
        if (DocumentFieldType.LIST == invoiceItemsField.getType()) {
          List < DocumentField > invoiceItems = invoiceItemsField.getValueAsList();
          invoiceItems.stream()
            .filter(invoiceItem -> DocumentFieldType.MAP == invoiceItem.getType())
            .map(documentField -> documentField.getValueAsMap())
            .forEach(documentFieldMap -> documentFieldMap.forEach((key, documentField) -> {

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

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

Compile e execute o aplicativo

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

  1. Crie seu aplicativo com o comando build:

    gradle build
    
  2. Execute seu aplicativo com o comando run:

    gradle run
    

Saída de modelo predefinido

Aqui está um trecho da saída esperada:

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

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

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


import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClient;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClientBuilder;
import com.azure.ai.formrecognizer.documentanalysis.models.AnalyzeResult;
import com.azure.ai.formrecognizer.documentanalysis.models.AnalyzedDocument;
import com.azure.ai.formrecognizer.documentanalysis.models.DocumentField;
import com.azure.ai.formrecognizer.documentanalysis.models.DocumentFieldType;
import com.azure.ai.formrecognizer.documentanalysis.models.OperationResult;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.io.IOException;
import java.time.LocalDate;
import java.util.List;
import java.util.Map;

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 modelId = "prebuilt-invoice";
    String invoiceUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf";

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

    AnalyzeResult analyzeInvoiceResult = analyzeInvoicePoller.getFinalResult();

    for (int i = 0; i < analyzeInvoiceResult.getDocuments().size(); i++) {
      AnalyzedDocument analyzedInvoice = analyzeInvoiceResult.getDocuments().get(i);
      Map < String, DocumentField > invoiceFields = analyzedInvoice.getFields();
      System.out.printf("----------- Analyzing invoice  %d -----------%n", i);
      DocumentField vendorNameField = invoiceFields.get("VendorName");
      if (vendorNameField != null) {
        if (DocumentFieldType.STRING == vendorNameField.getType()) {
          String merchantName = vendorNameField.getValueAsString();
          System.out.printf("Vendor Name: %s, confidence: %.2f%n",
            merchantName, vendorNameField.getConfidence());
        }
      }

      DocumentField vendorAddressField = invoiceFields.get("VendorAddress");
      if (vendorAddressField != null) {
        if (DocumentFieldType.STRING == vendorAddressField.getType()) {
          String merchantAddress = vendorAddressField.getValueAsString();
          System.out.printf("Vendor address: %s, confidence: %.2f%n",
            merchantAddress, vendorAddressField.getConfidence());
        }
      }

      DocumentField customerNameField = invoiceFields.get("CustomerName");
      if (customerNameField != null) {
        if (DocumentFieldType.STRING == customerNameField.getType()) {
          String merchantAddress = customerNameField.getValueAsString();
          System.out.printf("Customer Name: %s, confidence: %.2f%n",
            merchantAddress, customerNameField.getConfidence());
        }
      }

      DocumentField customerAddressRecipientField = invoiceFields.get("CustomerAddressRecipient");
      if (customerAddressRecipientField != null) {
        if (DocumentFieldType.STRING == customerAddressRecipientField.getType()) {
          String customerAddr = customerAddressRecipientField.getValueAsString();
          System.out.printf("Customer Address Recipient: %s, confidence: %.2f%n",
            customerAddr, customerAddressRecipientField.getConfidence());
        }
      }

      DocumentField invoiceIdField = invoiceFields.get("InvoiceId");
      if (invoiceIdField != null) {
        if (DocumentFieldType.STRING == invoiceIdField.getType()) {
          String invoiceId = invoiceIdField.getValueAsString();
          System.out.printf("Invoice ID: %s, confidence: %.2f%n",
            invoiceId, invoiceIdField.getConfidence());
        }
      }

      DocumentField invoiceDateField = invoiceFields.get("InvoiceDate");
      if (customerNameField != null) {
        if (DocumentFieldType.DATE == invoiceDateField.getType()) {
          LocalDate invoiceDate = invoiceDateField.getValueAsDate();
          System.out.printf("Invoice Date: %s, confidence: %.2f%n",
            invoiceDate, invoiceDateField.getConfidence());
        }
      }

      DocumentField invoiceTotalField = invoiceFields.get("InvoiceTotal");
      if (customerAddressRecipientField != null) {
        if (DocumentFieldType.DOUBLE == invoiceTotalField.getType()) {
          Double invoiceTotal = invoiceTotalField.getValueAsDouble();
          System.out.printf("Invoice Total: %.2f, confidence: %.2f%n",
            invoiceTotal, invoiceTotalField.getConfidence());
        }
      }

      DocumentField invoiceItemsField = invoiceFields.get("Items");
      if (invoiceItemsField != null) {
        System.out.printf("Invoice Items: %n");
        if (DocumentFieldType.LIST == invoiceItemsField.getType()) {
          List < DocumentField > invoiceItems = invoiceItemsField.getValueAsList();
          invoiceItems.stream()
            .filter(invoiceItem -> DocumentFieldType.MAP == invoiceItem.getType())
            .map(documentField -> documentField.getValueAsMap())
            .forEach(documentFieldMap -> documentFieldMap.forEach((key, documentField) -> {

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

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

Compile e execute o aplicativo

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

  1. Crie seu aplicativo com o comando build:

    gradle build
    
  2. Execute seu aplicativo com o comando run:

    gradle run
    

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

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

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

Pré-requisitos

  • Assinatura do Azure – crie uma gratuitamente.

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

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

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

    Dica

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

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

    Captura de tela da localização das chaves e 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 doc-intel-app e navegue até ele.

    mkdir doc-intel-app && cd doc-intel-app
    
  2. Execute o comando npm init para inicializar o aplicativo e fazer scaffold do projeto.

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

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

    npm i @azure-rest/ai-document-intelligence@1.0.0-beta.3 @azure/core-auth
    

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

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

    npm i @azure/ai-form-recognizer@5.0.0 @azure/identity
    
    • O arquivo package.json do seu aplicativo é atualizado com as dependências.
  1. Instale o pacote npm ai-form-recognizer da biblioteca de clientes azure/identity:

    npm i @azure/ai-form-recognizer@4.0.0 @azure/identity
    
  1. Crie um novo arquivo chamado index.js no diretório do aplicativo.

    Dica

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

Crie seu aplicativo

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

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

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

Importante

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

Modelo de layout

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

  • Para este exemplo, você precisará de um arquivo de documento de uma URL. Você pode usar nosso documento de exemplo para este início rápido.
  • Adicione o valor de URL do arquivo à variável formUrl na parte superior do arquivo.
  • Para analisar um dado arquivo em um URL, use o método beginAnalyzeDocuments e passe prebuilt-layout como a ID do modelo.
    const DocumentIntelligence = require("@azure-rest/ai-document-intelligence").default,
  { getLongRunningPoller, isUnexpected } = require("@azure-rest/ai-document-intelligence");

  const { AzureKeyCredential } = require("@azure/core-auth");

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


    const initialResponse = await client
      .path("/documentModels/{modelId}:analyze", "prebuilt-layout")
      .post({
        contentType: "application/json",
        body: {
          urlSource: formUrl
        },
       });

       if (isUnexpected(initialResponse)) {
       throw initialResponse.body.error;
     }

    const poller = await getLongRunningPoller(client, initialResponse);
    const analyzeResult = (await poller.pollUntilDone()).body.analyzeResult;

    const documents = analyzeResult?.documents;

    const document = documents && documents[0];
    if (!document) {
    throw new Error("Expected at least one document in the result.");
    }

    console.log(
    "Extracted document:",
    document.docType,
    `(confidence: ${document.confidence || "<undefined>"})`,
    );
    console.log("Fields:", document.fields);
}

main().catch((error) => {
    console.error("An error occurred:", error);
    process.exit(1);
});

Executar seu aplicativo

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

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

  2. No terminal, digite o seguinte comando:

    node index.js
    

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


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

    // set `<your-key>` and `<your-endpoint>` variables with the values from the Azure portal.
    const key = "<your-key>";
    const endpoint = "<your-endpoint>";

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

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

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

    const {
        pages,
        tables
    } = await poller.pollUntilDone();

    if (pages.length <= 0) {
        console.log("No pages were extracted from the document.");
    } else {
        console.log("Pages:");
        for (const page of pages) {
            console.log("- Page", page.pageNumber, `(unit: ${page.unit})`);
            console.log(`  ${page.width}x${page.height}, angle: ${page.angle}`);
            console.log(`  ${page.lines.length} lines, ${page.words.length} words`);
        }
    }

    if (tables.length <= 0) {
        console.log("No tables were extracted from the document.");
    } else {
        console.log("Tables:");
        for (const table of tables) {
            console.log(
                `- Extracted table: ${table.columnCount} columns, ${table.rowCount} rows (${table.cells.length} cells)`
            );
        }
    }
}

main().catch((error) => {
    console.error("An error occurred:", error);
    process.exit(1);
});

Executar seu aplicativo

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

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

  2. No terminal, digite o seguinte comando:

    node index.js
    

Saída do modelo de layout

Aqui está um trecho da saída esperada:

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

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

Modelo predefinido

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

Dica

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

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

const DocumentIntelligence = require("@azure-rest/ai-document-intelligence").default,
  { getLongRunningPoller, isUnexpected } = require("@azure-rest/ai-document-intelligence");

const { AzureKeyCredential } = require("@azure/core-auth");

    // 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 invoiceUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf"

async function main() {

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

    const initialResponse = await client
    .path("/documentModels/{modelId}:analyze", "prebuilt-invoice")
    .post({
      contentType: "application/json",
      body: {
        // The Document Intelligence service will access the URL to the invoice image and extract data from it
        urlSource: invoiceUrl,
      },
    });

    if (isUnexpected(initialResponse)) {
       throw initialResponse.body.error;
     }

    const poller = await getLongRunningPoller(client, initialResponse);

    poller.onProgress((state) => console.log("Operation:", state.result, state.status));
    const analyzeResult = (await poller.pollUntilDone()).body.analyzeResult;

    const documents = analyzeResult?.documents;

    const result = documents && documents[0];
    if (result) {
      console.log(result.fields);
    } else {
      throw new Error("Expected at least one invoice in the result.");
    }

console.log(
    "Extracted invoice:",
    document.docType,
    `(confidence: ${document.confidence || "<undefined>"})`,
  );
  console.log("Fields:", document.fields);
}


main().catch((error) => {
    console.error("An error occurred:", error);
    process.exit(1);
});

Executar seu aplicativo

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

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

  2. No terminal, digite o seguinte comando:

    node index.js
    

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

// set `<your-key>` and `<your-endpoint>` variables with the values from the Azure portal.
const key = "<your-key>";
const endpoint = "<your-endpoint>";
// sample document
invoiceUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf"

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

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

    const {
        pages,
        tables
    } = await poller.pollUntilDone();

    if (pages.length <= 0) {
        console.log("No pages were extracted from the document.");
    } else {
        console.log("Pages:");
        for (const page of pages) {
            console.log("- Page", page.pageNumber, `(unit: ${page.unit})`);
            console.log(`  ${page.width}x${page.height}, angle: ${page.angle}`);
            console.log(`  ${page.lines.length} lines, ${page.words.length} words`);

            if (page.lines && page.lines.length > 0) {
                console.log("  Lines:");

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

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

    if (tables.length <= 0) {
        console.log("No tables were extracted from the document.");
    } else {
        console.log("Tables:");
        for (const table of tables) {
            console.log(
                `- Extracted table: ${table.columnCount} columns, ${table.rowCount} rows (${table.cells.length} cells)`
            );
        }
    }
}

main().catch((error) => {
    console.error("An error occurred:", error);
    process.exit(1);
});

Executar seu aplicativo

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

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

  2. No terminal, digite o seguinte comando:

    node index.js
    

Saída de modelo predefinido

Aqui está um trecho da saída esperada:

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

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

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

  // set `<your-key>` and `<your-endpoint>` variables with the values from the Azure portal.
      const key = "<your-key>";
      const endpoint = "<your-endpoint>";
// sample document
    invoiceUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf"

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

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

    const {
    documents: [document],
  } = await poller.pollUntilDone();


  if (document) {
    const {
      vendorName,
      customerName,
      invoiceDate,
      dueDate,
      items,
      subTotal,
      previousUnpaidBalance,
      totalTax,
      amountDue,
    } = document.fields;

    // The invoice model has many fields. For details, *see* [Invoice model field extraction](../../prebuilt/invoice.md#field-extraction)
    console.log("Vendor Name:", vendorName && vendorName.value);
    console.log("Customer Name:", customerName && customerName.value);
    console.log("Invoice Date:", invoiceDate && invoiceDate.value);
    console.log("Due Date:", dueDate && dueDate.value);

    console.log("Items:");
    for (const item of (items && items.values) || []) {
      const { productCode, description, quantity, date, unit, unitPrice, tax, amount } =
        item.properties;

      console.log("-", (productCode && productCode.value) || "<no product code>");
      console.log("  Description:", description && description.value);
      console.log("  Quantity:", quantity && quantity.value);
      console.log("  Date:", date && date.value);
      console.log("  Unit:", unit && unit.value);
      console.log("  Unit Price:", unitPrice && unitPrice.value);
      console.log("  Tax:", tax && tax.value);
      console.log("  Amount:", amount && amount.value);
    }

    console.log("Subtotal:", subTotal && subTotal.value);
    console.log("Previous Unpaid Balance:", previousUnpaidBalance && previousUnpaidBalance.value);
    console.log("Tax:", totalTax && totalTax.value);
    console.log("Amount Due:", amountDue && amountDue.value);
  } else {
    throw new Error("Expected at least one receipt in the result.");
  }
}


main().catch((error) => {
    console.error("An error occurred:", error);
    process.exit(1);
});

Executar seu aplicativo

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

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

  2. No terminal, digite o seguinte comando:

    node index.js
    

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

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

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

Pré-requisitos

  • Assinatura do Azure – crie uma gratuitamente.

  • Python 3.7 ou posterior.

    • A instalação do Python deve incluir o pip. Você pode executar pip --version na linha de comando para verificar se o pip está instalado. Instale a versão mais recente do Python para obter o pip.
  • A versão mais recente do Visual Studio Code ou do seu IDE preferido. Para mais informações, consulte Introdução ao Python no Visual Studio Code.

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

Dica

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

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

    Captura de tela da localização das chaves e 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 da IA do Azure para Informação de Documentos para Python com pip:

pip install azure-ai-documentintelligence==1.0.0b4

pip install azure-ai-formrecognizer==3.3.0

pip install azure-ai-formrecognizer==3.2.0b6

Criar seu aplicativo Python

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

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

  2. Abra o arquivo doc_intel_quickstart.py e selecione um dos seguintes códigos de exemplo para copiar e cole em seu aplicativo:

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

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

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

Importante

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

Modelo de layout

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

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

Adicione o seguinte código de exemplo ao seu aplicativo doc_intel_quickstart.py. Certifique-se de atualizar as variáveis de chave e ponto de extremidade com os valores da sua instância de Informação de Documentos no portal do Azure:


# import libraries
import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.documentintelligence import DocumentIntelligenceClient
from azure.ai.documentintelligence.models import AnalyzeResult
from azure.ai.documentintelligence.models import AnalyzeDocumentRequest

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

# helper functions

def get_words(page, line):
    result = []
    for word in page.words:
        if _in_span(word, line.spans):
            result.append(word)
    return result


def _in_span(word, spans):
    for span in spans:
        if word.span.offset >= span.offset and (
            word.span.offset + word.span.length
        ) <= (span.offset + span.length):
            return True
    return False


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

    document_intelligence_client = DocumentIntelligenceClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller = document_intelligence_client.begin_analyze_document(
        "prebuilt-layout", AnalyzeDocumentRequest(url_source=formUrl
    ))

    result: AnalyzeResult = poller.result()

    if result.styles and any([style.is_handwritten for style in result.styles]):
        print("Document contains handwritten content")
    else:
        print("Document does not contain handwritten content")

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

        if page.lines:
            for line_idx, line in enumerate(page.lines):
                words = get_words(page, line)
                print(
                    f"...Line # {line_idx} has word count {len(words)} and text '{line.content}' "
                    f"within bounding polygon '{line.polygon}'"
                )

                for word in words:
                    print(
                        f"......Word '{word.content}' has a confidence of {word.confidence}"
                    )

        if page.selection_marks:
            for selection_mark in page.selection_marks:
                print(
                    f"Selection mark is '{selection_mark.state}' within bounding polygon "
                    f"'{selection_mark.polygon}' and has a confidence of {selection_mark.confidence}"
                )

    if result.tables:
        for table_idx, table in enumerate(result.tables):
            print(
                f"Table # {table_idx} has {table.row_count} rows and "
                f"{table.column_count} columns"
            )
            if table.bounding_regions:
                for region in table.bounding_regions:
                    print(
                        f"Table # {table_idx} location on page: {region.page_number} is {region.polygon}"
                    )
            for cell in table.cells:
                print(
                    f"...Cell[{cell.row_index}][{cell.column_index}] has text '{cell.content}'"
                )
                if cell.bounding_regions:
                    for region in cell.bounding_regions:
                        print(
                            f"...content on page {region.page_number} is within bounding 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 doc_intel_quickstart.py.

  2. No terminal, digite o seguinte comando:

    python doc_intel_quickstart.py
    

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

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


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

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

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

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

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

    poller = document_analysis_client.begin_analyze_document_from_url(
            "prebuilt-layout", formUrl)
    result = poller.result()

    for idx, style in enumerate(result.styles):
        print(
            "Document contains {} content".format(
                "handwritten" if style.is_handwritten else "no handwritten"
            )
        )

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

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

            for word in words:
                print(
                    "......Word '{}' has a confidence of {}".format(
                        word.content, word.confidence
                    )
                )

        for selection_mark in page.selection_marks:
            print(
                "...Selection mark is '{}' within bounding box '{}' and has a confidence of {}".format(
                    selection_mark.state,
                    format_polygon(selection_mark.polygon),
                    selection_mark.confidence,
                )
            )

    for table_idx, table in enumerate(result.tables):
        print(
            "Table # {} has {} rows and {} columns".format(
                table_idx, table.row_count, table.column_count
            )
        )
        for region in table.bounding_regions:
            print(
                "Table # {} location on page: {} is {}".format(
                    table_idx,
                    region.page_number,
                    format_polygon(region.polygon),
                )
            )
        for cell in table.cells:
            print(
                "...Cell[{}][{}] has content '{}'".format(
                    cell.row_index,
                    cell.column_index,
                    cell.content,
                )
            )
            for region in cell.bounding_regions:
                print(
                    "...content on page {} is within bounding box '{}'".format(
                        region.page_number,
                        format_polygon(region.polygon),
                    )
                )

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


if __name__ == "__main__":
    analyze_layout()

Executar o aplicativo

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

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

  2. No terminal, digite o seguinte comando:

    python form_recognizer_quickstart.py
    

Saída do modelo de layout

Aqui está um trecho da saída esperada:

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

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

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

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

    poller = document_analysis_client.begin_analyze_document_from_url(
        "prebuilt-layout", formUrl
    )
    result = poller.result()

    for idx, style in enumerate(result.styles):
        print(
            "Document contains {} content".format(
                "handwritten" if style.is_handwritten else "no handwritten"
            )
        )

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

        for line_idx, line in enumerate(page.lines):
            words = line.get_words()
            print(
                "...Line # {} has word count {} and text '{}' within bounding polygon '{}'".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 polygon '{}' 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 polygon '{}'".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
    

Modelo predefinido

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

Dica

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

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

Adicione o seguinte código de exemplo ao seu aplicativo doc_intel_quickstart.py. Certifique-se de atualizar as variáveis de chave e ponto de extremidade com os valores da sua instância de Informação de Documentos no portal do Azure:


# import libraries
import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.documentintelligence import DocumentIntelligenceClient
from azure.ai.documentintelligence.models import AnalyzeResult
from azure.ai.documentintelligence.models import AnalyzeDocumentRequest



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

def analyze_invoice():
    # sample document

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

    document_intelligence_client = DocumentIntelligenceClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller = document_intelligence_client.begin_analyze_document(
        "prebuilt-invoice", AnalyzeDocumentRequest(url_source=invoiceUrl)
    )
    invoices = poller.result()

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


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


if __name__ == "__main__":
    analyze_invoice()


Executar o aplicativo

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

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

  2. No terminal, digite o seguinte comando:

    python doc_intel_quickstart.py
    

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

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

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

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


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


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


def analyze_invoice():

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

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

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

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

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

if __name__ == "__main__":
    analyze_invoice()


Executar o aplicativo

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

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

  2. No terminal, digite o seguinte comando:

    python form_recognizer_quickstart.py
    

Saída de modelo predefinido

Aqui está um trecho da saída esperada:

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

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

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


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

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


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


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

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

    poller = document_analysis_client.begin_analyze_document_from_url(
        "prebuilt-layout", formUrl
    )
    result = poller.result()

    for idx, style in enumerate(result.styles):
        print(
            "Document contains {} content".format(
                "handwritten" if style.is_handwritten else "no handwritten"
            )
        )


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

    for line_idx, line in enumerate(page.lines):
        words = line.get_words()
        print(
            "...Line # {} has word count {} and text '{}' within bounding polygon '{}'".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 polygon '{}' 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 polygon '{}'".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
    

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

Pré-requisitos

  • Assinatura do Azure – Criar uma gratuitamente

  • ferramenta de linha de comando curl instalada.

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

Dica

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

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

    Captura de tela da localização das chaves e 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 de Informação de Documentos no portal do Azure.

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

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

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

Documentos de amostra

Recurso {modelID} {your-document-url}
Leitura prebuilt-read https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/read.png
Layout prebuilt-layout https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/layout.png
cartão do seguro de saúde prebuilt-healthInsuranceCard.us https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/insurance-card.png
W-2 prebuilt-tax.us.w2 https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/w2.png
Fatura prebuilt-invoice https://github.com/Azure-Samples/cognitive-services-REST-api-samples/raw/master/curl/form-recognizer/rest-api/invoice.pdf
Receipt prebuilt-receipt https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/receipt.png
Documento de identificação prebuilt-idDocument https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/identity_documents.png

Documentos de amostra

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

Importante

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

Solicitação POST

curl -v -i POST "{endpoint}/documentintelligence/documentModels/{modelId}:analyze?api-version=2024-07-31-preview" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: {key}" --data-ascii "{'urlSource': '{your-document-url}'}"
curl -v -i POST "{endpoint}/formrecognizer/documentModels/{modelID}:analyze?api-version=2023-07-31" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: {key}" --data-ascii "{'urlSource': '{your-document-url}'}"
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 (resultID)

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

{alt-text}

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

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

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

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

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

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

Solicitação GET

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

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

Examinar a resposta

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

Resposta de exemplo para fatura pré-criada

{
    "status": "succeeded",
    "createdDateTime": "2024-03-25T19:31:37Z",
    "lastUpdatedDateTime": "2024-03-25T19:31:43Z",
    "analyzeResult": {
        "apiVersion": "2024-07-31-preview",
        "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
                                }
                      }],
              }]
      }
}
{
    "status": "succeeded",
    "createdDateTime": "2023-08-25T19:31:37Z",
    "lastUpdatedDateTime": "2023-08-25T19:31:43Z",
    "analyzeResult": {
        "apiVersion": "2023-07-31",
        "modelId": "prebuilt-invoice",
        "stringIndexType": "textElements"...
    ..."pages": [
            {
                "pageNumber": 1,
                "angle": 0,
                "width": 8.5,
                "height": 11,
                "unit": "inch",
                "words": [
                    {
                        "content": "CONTOSO",
                        "boundingBox": [
                            0.5911,
                            0.6857,
                            1.7451,
                            0.6857,
                            1.7451,
                            0.8664,
                            0.5911,
                            0.8664
                        ],
                        "confidence": 1,
                        "span": {
                            "offset": 0,
                            "length": 7
                                }
                      }],
              }]
      }
}
{
    "status": "succeeded",
    "createdDateTime": "2022-09-25T19:31:37Z",
    "lastUpdatedDateTime": "2022-09-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!

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

Próximas etapas

Este conteúdo se aplica a: marca de seleção v2.1 | Versão mais recente: marca de seleção azul v4.0 (versão prévia)

Comece a usar a IA do Azure para Informação de Documentos usando a linguagem de programação de sua escolha ou a API REST. A IA do Azure para Informação de Documentos é um serviço da IA do Azure baseado em nuvem que usa modelos de aprendizado de máquina para extrair pares de chave-valor, texto e tabelas dos seus documentos. 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 e opções de desenvolvimento da Informação de Documentos, visite a página Visão Geral.

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

Neste início rápido, você usa 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 Inteligência de Documento ou serviços de IA do Azure. Assim que tiver sua assinatura do Azure, crie um recurso de serviço único ou multisserviço de Informação de Documentos no portal do Azure para obter sua chave e seu ponto de extremidade. Use o tipo de preço gratuito (F0) para experimentar o serviço e atualizar mais tarde para um nível pago para produção.

    Dica

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

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

    Captura de tela da localização das chaves e 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 da 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 da 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 da 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 selecionado da Informação de Documentos.

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

Crie seu aplicativo

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

Observação

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

  2. 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 da opção 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 uma maneira segura de armazenar e acessar suas credenciais, como o Azure Key Vault. Para obter mais informações, confira o artigo sobre segurança dos serviços de IA do Azure.

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 em um URI. Você pode usar nosso documento de exemplo 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 com suporte no momento no serviço de Informação de Documentos:

  • 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 da opção 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ê usa as seguintes APIs para extrair dados estruturados de formulários e documentos:

Pré-requisitos

  • Assinatura do Azure – crie uma gratuitamente.

  • Um Java Development Kit (JDK) versão 8 ou posterior. Para mais informações, consulte Versões com suporte do Java e cronograma de atualizações.

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

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

    Captura de tela da localização das chaves e 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 cria arquivos de build essenciais para o Gradle, incluindo o build.gradle.kts, que é usado no runtime para criar e configurar seu aplicativo.

    gradle init --type basic
    
  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ê cria 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. Para obter mais informações, consulte a segurança dos serviços de IA do Azure.

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 em um URI. Você pode usar nosso documento de exemplo 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 seu aplicativo com o seguinte código (certifique-se de atualizar as variáveis de chave e de ponto de extremidade com os valores da sua instância de Informação de Documentos 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 com suporte no momento no serviço de Informação de Documentos:

  • 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 seu aplicativo com o seguinte código (certifique-se de atualizar as variáveis de chave e de ponto de extremidade com os valores da sua instância de Informação de Documentos 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ê usa 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 Inteligência de Documento ou serviços de IA do Azure. Assim que tiver sua assinatura do Azure, crie um recurso de serviço único ou multisserviço de Informação de Documentos no portal do Azure para obter sua chave e seu ponto de extremidade. Use o tipo de preço gratuito (F0) para experimentar o serviço e atualizar mais tarde para um nível pago para produção.

    Dica

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

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

    Captura de tela da localização das chaves e 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 é 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. Para obter mais informações, consulte a segurança dos serviços de IA do Azure.

Experimente: modelo de layout

  • Para este exemplo, você precisará de um arquivo de documento em um URI. Você pode usar nosso documento de exemplo para este início rápido.
  • 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 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 com suporte no momento no serviço de Informação de Documentos:

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

    Dica

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

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

    Captura de tela da localização das chaves e 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 da IA do Azure para Informação de Documentos para 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. Para obter mais informações, consulte a segurança dos serviços de IA do Azure.

Experimente: modelo de layout

  • Para este exemplo, você precisará de um arquivo de documento em um URI. Você pode usar nosso documento de exemplo para este início rápido.
  • 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 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 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 com suporte no momento no serviço de Informação de Documentos:

  • 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 de Informação de Documentos | Referência da API REST do Azure |

Neste início rápido, você usa 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 Inteligência de Documento ou serviços de IA do Azure. Assim que tiver sua assinatura do Azure, crie um recurso de serviço único ou multisserviço de Informação de Documentos no portal do Azure para obter sua chave e seu ponto de extremidade. Use o tipo de preço gratuito (F0) para experimentar o serviço e atualizar mais tarde para um nível pago para produção.

    Dica

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

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

    Captura de tela da localização das chaves e 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. Para obter mais informações, consulte a segurança dos serviços de IA do Azure.

Experimente: modelo de layout

  • Para este exemplo, você precisará de um arquivo de documento em um URI. Você pode usar nosso documento de exemplo para este início rápido.
  1. Substitua {endpoint} pelo valor do ponto de extremidade que você obteve com sua assinatura da Informação de Documentos.
  2. Substitua {key} pela chave que você copiou na etapa anterior.
  3. Substitua \"{your-document-url} por uma URL de documento 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ê vai 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 valor do ponto de extremidade que você obteve com sua assinatura da Informação de Documentos.
  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ê vai receber uma 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á é selected ou unselected.
  • 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 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 com suporte no momento no serviço de Informação de Documentos:

  • 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 valor do ponto de extremidade que você obteve com sua assinatura da Informação de Documentos.

  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ê vai 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 valor do ponto de extremidade que você obteve com sua chave da Informação de Documentos. Você pode encontrá-lo na guia Visão Geral do seu recurso de Informação de Documentos.
  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á uma resposta 200 (Success) com uma saída em 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! Muito bem!

Próximas etapas

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

    • O Studio dá suporte a qualquer modelo treinado com dados rotulados v2.1.

    • Os changelogs fornecem informações detalhadas sobre a migração da v3.1 para a v4.0.