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:v4.0 (versão prévia)Versões anteriores:v3.1 (disponibilidade geral)v3.0 (disponibilidade geral)

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

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

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

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

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

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

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

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

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

Pré-requisitos

• Assinatura do Azure – crie uma gratuitamente.

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

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

  

Configuração

1. Inicie o Visual Studio.

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

   

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

   

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

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

   

Instalar a biblioteca de clientes com o NuGet

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

   

2. Selecione a guia Procurar e digite Azure.AI.DocumentIntelligence. Escolha a caixa de seleção Include prerelease e selecione a versão 1.0.0-beta.1 no menu suspenso

   

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.

Observação

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

1. Abra o arquivo Program.cs.

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

   • Modelo de layout

   • Modelo predefinido

Importante

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

Modelo de layout

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

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

Adicione o seguinte exemplo de código ao arquivo Program.cs. 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");

Operation<AnalyzeResult> operation = await client.AnalyzeDocumentAsync(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)," +
        $" 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.

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

Operation<AnalyzeResult> 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)
        && 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.

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

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

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

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

Pré-requisitos

• Assinatura do Azure – crie uma gratuitamente.

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

  Dica

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

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

  • Um kit de desenvolvimento Java (JDK) versão 8 ou posterior. Para obter mais informações, confirao Build do OpenJDK da Microsoft.

  • Gradle, versão 6.8 ou posterior.

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

  Dica

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

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

  

Configuração

Criar um novo projeto Gradle

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

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

   }

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.

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

   mkdir -p src/main/java
   

   Você cria a seguinte estrutura de diretório:

   

2. Navegue até o diretório do java e crie um arquivo chamado 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.

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

   • Layout

   • Fatura predefinida

Importante

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

Modelo de layout

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

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

Adicione o exemplo de código a seguir ao arquivo 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;

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 `DocumentAnalysisClient` instance and `AzureKeyCredential` variable
    DocumentIntelligenceClient client = new DocumentIntelligenceClientBuilder()
      .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 <AnalyzeResultOperation, AnalyzeResultOperation> analyzeLayoutResultPoller =
      client.beginAnalyzeDocument(modelId, 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
   

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;

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

    // create your `DocumentAnalysisClient` instance and `AzureKeyCredential` variable
    DocumentIntelligenceClient client = new DocumentIntelligenceClientBuilder()
      .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";

    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("https://{endpoint}.cognitiveservices.azure.com/")
        .buildClient();

      SyncPoller < OperationResult, AnalyzeResult > analyzeLayoutResultPoller =
        client.beginAnalyzeDocument(modelId, 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
   

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

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

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

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

Pré-requisitos

• Assinatura do Azure – crie uma gratuitamente.

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

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

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

  Dica

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

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

  

Configuração

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

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

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

   npm init
   

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

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

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

   npm i @azure-rest/ai-document-intelligence@1.0.0-beta.2 @azure/identity
   
   

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

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

   Dica

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

Crie seu aplicativo

Para interagir com o serviço de Informação de Documentos, você precisa criar uma instância da classe 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. Abra o arquivo index.js no Visual Studio Code ou seu IDE favorito. Copie e cole um dos seguintes exemplos de código no aplicativo:

   • Layout

   • Fatura predefinida

Importante

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

Modelo de layout

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

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

    const { DocumentIntelligenceClient } = 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 = DocumentIntelligenceClient(endpoint, new AzureKeyCredential(key));

    const poller = await client.beginAnalyzeDocument("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
   

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

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

    const poller = await client.beginAnalyzeDocument("prebuilt-invoice", invoiceUrl);
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
   

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

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

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

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

Pré-requisitos

• Assinatura do Azure – crie uma gratuitamente.

• Python 3.7 ou posterior.

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

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

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

Dica

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

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

  

Configuração

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

pip install azure-ai-documentintelligence==1.0.0b2

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:

   • Layout

   • Fatura predefinida

Importante

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

Modelo de layout

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

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

Adicione o 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

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

    analyze_request = 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
   

---

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 begin_analyze_document_from_url e passará prebuilt-invoice como ID do modelo. O valor retornado é um objeto result que contém dados sobre o documento enviado.
• Para simplificar, todos os pares chave-valor que o serviço retorna não são mostrados aqui. Para ver a lista de todos os campos compatíveis e tipos correspondentes, confira nossa página de conceito da Fatura.

Adicione o 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


# 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", 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
   

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

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

Pré-requisitos

• Assinatura do Azure – Criar uma gratuitamente

• ferramenta de linha de comando curl instalada.

  • Windows
  • Mac ou Linux

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

  • Windows
  • macOS
  • Linux

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

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

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

Dica

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

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

  

Analisar documentos e obter resultados

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

Analisar documento (solicitação POST)

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

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

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

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

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

Documentos de amostra

Recurso	{modelID}	{your-document-url}
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

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-02-29-preview" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: {key}" --data-ascii "{'urlSource': '{your-document-url}'}"

Resposta POST (resultID)

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

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

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

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

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

Solicitação GET

curl -v -X GET "{endpoint}/documentintelligence/documentModels/{modelId}/analyzeResults/{resultId}?api-version=2024-02-29-preview" -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-02-29-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
                                }
                      }],
              }]
      }
}

Campos de documento com suporte

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

É isso, parabéns!

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

Próximas etapas

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

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