Introdução à Inteligência Documental

Importante

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

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

• Comece a usar a versão mais recente e estável do Azure Document Intelligence v4.0 2024-11-30 (GA).

• Azure Document Intelligence / Form Recognizer é um serviço Foundry Tools baseado na cloud que utiliza aprendizagem automática para extrair pares-chave-valor, texto, tabelas e dados chave dos seus documentos.

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

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

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

Biblioteca do cliente | Referência da API REST | Pacote| Exemplos|Versão da API REST suportada

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

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

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

Pré-requisitos

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

• A versão atual do Visual Studio IDE.

• Um recurso de Foundry Tools ou de Inteligência de Documentos. Depois de ter a sua subscrição Azure, crie um recurso de serviço único ou Azure multi-serviço, no portal do Azure, para obter a sua chave e endpoint.

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

Gorjeta

Crie um recurso Microsoft Foundry se planeia aceder a várias ferramentas Foundry sob um único endpoint/chave. Apenas para acesso ao Document Intelligence, crie um recurso de Document Intelligence. Você precisa de um recurso de serviço único se pretende usar a autenticação do Microsoft Entra.

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

  

Configurar

1. Inicie o Visual Studio.

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

   

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

   

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

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

   

Instalar a biblioteca de cliente com o NuGet

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

   

2. Clique na guia Procurar e escreva Azure.AI.DocumentIntelligence.

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

   

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

Compilar a aplicação

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

Nota

• A partir do .NET 6, novos projetos usando o console modelo geram um novo estilo de programa que difere das versões anteriores.
• A nova saída usa recursos recentes do C# que simplificam o código que você precisa escrever.
• Quando você usa a versão mais recente, você só precisa escrever o Main corpo do método. Não é necessário incluir instruções de nível superior, diretivas de uso global ou diretivas de uso implícito.
• Para obter mais informações, consulte Novos modelos C# geram instruções de nível superior.

1. Abra o arquivo Program.cs .

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

   • Modelo de layout

   • Modelo pré-construído

Importante

Recomendamos a autenticação do Microsoft Entra ID com identidades gerenciadas para recursos do Azure para evitar o armazenamento de credenciais com seus aplicativos executados na nuvem.

Use chaves de API com cuidado. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente. Se estiver usando chaves de API, armazene-as com segurança no Cofre de Chaves do Azure, gire as chaves regularmente e restrinja o acesso ao Cofre de Chaves do Azure usando controle de acesso baseado em função e restrições de acesso à rede. Para obter mais informações sobre como usar chaves de API com segurança em seus aplicativos, consulte Chaves de API com o Cofre de Chaves do Azure.

Para obter mais informações sobre segurança de serviços de IA, consulte Autenticar solicitações para serviços de IA do Azure.

Modelo de layout

Extraia texto, marcas de seleção, estilos de texto, estruturas de tabela e coordenadas das regiões delimitadoras de documentos.

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

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

Execute seu aplicativo

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

Modelo pré-construído

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

Gorjeta

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

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

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

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

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

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

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

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

                if (itemFields.TryGetValue("Amount", out DocumentField itemAmountField)
                    && itemAmountField.FieldType == 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.FieldType == 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.FieldType == 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.FieldType == DocumentFieldType.Currency)
    {
        CurrencyValue invoiceTotal = invoiceTotalField.ValueCurrency;
        Console.WriteLine($"Invoice Total: '{invoiceTotal.CurrencySymbol}{invoiceTotal.Amount}', with confidence {invoiceTotalField.Confidence}");
    }
}

Execute seu aplicativo

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

Biblioteca de clientes | Referência da API REST | Pacote (Maven) | Amostras |Versão suportada da API REST

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

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

• Fatura predefinida—Analise e extraia campos comuns de determinados tipos de documentos usando um modelo pré-treinado.

Pré-requisitos

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

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

  Gorjeta

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

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

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

  • Gradle, versão 6.8 ou posterior.

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

  Gorjeta

  Crie um recurso Microsoft Foundry se planeia aceder a várias ferramentas Foundry sob um único endpoint/chave. Apenas para acesso ao Document Intelligence, crie um recurso de Document Intelligence. Você precisa de um recurso de serviço único se pretende usar a autenticação do Microsoft Entra.

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

  

Configurar

Criar um novo projeto Gradle

1. Na janela do console (como cmd, PowerShell ou Bash), crie um novo diretório para seu aplicativo chamado 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 no seu diretório de trabalho. Este comando cria arquivos de compilação essenciais para o Gradle, incluindo build.gradle.kts, que é usado em tempo de execução para criar e configurar seu aplicativo.

   gradle init --type basic
   

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

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

Instalar a biblioteca de cliente

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

Abra o arquivo build.gradle.kts do projeto no IDE. Copie e cole o seguinte código para incluir a biblioteca do cliente como uma declaração implementation, juntamente com os plugins e configurações necessários.

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

   }

Criar uma aplicação Java

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

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

   mkdir -p src/main/java
   

   Você cria a seguinte estrutura de diretórios:

   

2. Navegue até o java diretório e crie um arquivo chamado DocIntelligence.java.

   Gorjeta

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

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

   • Esquema

   • Fatura pré-fabricada

Importante

Recomendamos a autenticação do Microsoft Entra ID com identidades gerenciadas para recursos do Azure para evitar o armazenamento de credenciais com seus aplicativos executados na nuvem.

Use chaves de API com cuidado. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente. Se estiver usando chaves de API, armazene-as com segurança no Cofre de Chaves do Azure, gire as chaves regularmente e restrinja o acesso ao Cofre de Chaves do Azure usando controle de acesso baseado em função e restrições de acesso à rede. Para obter mais informações sobre como usar chaves de API com segurança em seus aplicativos, consulte Chaves de API com o Cofre de Chaves do Azure.

Para obter mais informações sobre segurança de serviços de IA, consulte Autenticar solicitações para serviços de IA do Azure.

Modelo de layout

Extraia texto, marcas de seleção, estilos de texto, estruturas de tabela e coordenadas das regiões delimitadoras de documentos.

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

Adicione o seguinte exemplo de código ao DocIntelligence.java arquivo. Certifique-se de atualizar as variáveis de chave e ponto de extremidade com valores da sua instância de Document Intelligence do portal do Azure:

import com.azure.ai.documentintelligence.DocumentIntelligenceClient;
import com.azure.ai.documentintelligence.DocumentIntelligenceClientBuilder;
import com.azure.ai.documentintelligence.models.AnalyzeDocumentOptions;
import com.azure.ai.documentintelligence.models.AnalyzeOperationDetails;
import com.azure.ai.documentintelligence.models.AnalyzeResult;
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";

    AnalyzeDocumentOptions options = new AnalyzeDocumentOptions(documentUrl);

    SyncPoller<AnalyzeOperationDetails, AnalyzeResult> analyzeLayoutPoller = client.beginAnalyzeDocument(modelId, options);

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

Compilar e executar o aplicativo

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

1. Crie seu aplicativo com o build comando:

   gradle build
   

2. Execute seu aplicativo com o run comando:

   gradle run
   

Modelo pré-construído

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

Gorjeta

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

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

Adicione o seguinte exemplo de código ao DocIntelligence.java arquivo. Certifique-se de atualizar as variáveis de chave e ponto de extremidade com valores da sua instância de Document Intelligence do portal do Azure:

import com.azure.ai.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());
                  }
                }
              }));
          }
        }
      }
    }
  }
}

Compilar e executar o aplicativo

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

1. Crie seu aplicativo com o build comando:

   gradle build
   

2. Execute seu aplicativo com o run comando:

   gradle run
   

Biblioteca do cliente | Referência da API REST | Pacote (npm) | Exemplos |Versão suportada da API REST

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

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

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

Pré-requisitos

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

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

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

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

  Gorjeta

  Crie um recurso Microsoft Foundry se planeia aceder a várias ferramentas Foundry sob um único endpoint/chave. Apenas para acesso ao Document Intelligence, crie um recurso de Document Intelligence. Você precisa de um recurso de serviço único se pretende usar a autenticação do Microsoft Entra.

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

  

Configurar

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

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

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

   npm init
   

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

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

4. Instale a biblioteca de cliente ai-document-intelligence e os pacotes npm azure/identity.

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

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

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

   Gorjeta

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

Compilar a aplicação

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

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

   • Esquema

   • Fatura pré-fabricada

Importante

Recomendamos a autenticação do Microsoft Entra ID com identidades gerenciadas para recursos do Azure para evitar o armazenamento de credenciais com seus aplicativos executados na nuvem.

Use chaves de API com cuidado. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente. Se estiver usando chaves de API, armazene-as com segurança no Cofre de Chaves do Azure, gire as chaves regularmente e restrinja o acesso ao Cofre de Chaves do Azure usando controle de acesso baseado em função e restrições de acesso à rede. Para obter mais informações sobre como usar chaves de API com segurança em seus aplicativos, consulte Chaves de API com o Cofre de Chaves do Azure.

Para obter mais informações sobre segurança de serviços de IA, consulte Autenticar solicitações para serviços de IA do Azure.

Modelo de layout

Extraia texto, marcas de seleção, estilos de texto, estruturas de tabela e coordenadas das regiões delimitadoras de documentos.

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

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

Execute seu aplicativo

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

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

2. Digite o seguinte comando no seu terminal:

   node index.js
   

Modelo pré-construído

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

Gorjeta

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

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

const 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);
});

Execute seu aplicativo

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

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

2. Digite o seguinte comando no seu terminal:

   node index.js
   

Biblioteca | de clientesReferência | Pacote (PyPi) | Amostras | Versão da API REST suportada

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

• Layout—Analise e extraia tabelas, linhas, palavras e marcas de seleção, como botões de opção e caixas de seleção, e pares chave-valor, sem a necessidade de treinar um modelo.

• Fatura predefinida—Analise e extraia campos comuns de determinados tipos de documentos usando um modelo pré-treinado.

Pré-requisitos

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

• Python 3.7 ou posterior.

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

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

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

Gorjeta

Crie um recurso Microsoft Foundry se planeia aceder a várias ferramentas Foundry sob um único endpoint/chave. Apenas para acesso ao Document Intelligence, crie um recurso de Document Intelligence. Você precisa de um recurso de serviço único se pretende usar a autenticação do Microsoft Entra.

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

  

Configurar

Abra uma janela de terminal no seu ambiente local e instale a biblioteca cliente Azure Document Intelligence no Foundry Tools para Python com pip:

pip install azure-ai-documentintelligence==1.0.0b4

Crie seu aplicativo Python

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

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 exemplos de código para copiar e colar em seu aplicativo:

   • Esquema

   • Fatura pré-fabricada

Importante

Recomendamos a autenticação do Microsoft Entra ID com identidades gerenciadas para recursos do Azure para evitar o armazenamento de credenciais com seus aplicativos executados na nuvem.

Use chaves de API com cuidado. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente. Se estiver usando chaves de API, armazene-as com segurança no Cofre de Chaves do Azure, gire as chaves regularmente e restrinja o acesso ao Cofre de Chaves do Azure usando controle de acesso baseado em função e restrições de acesso à rede. Para obter mais informações sobre como usar chaves de API com segurança em seus aplicativos, consulte Chaves de API com o Cofre de Chaves do Azure.

Para obter mais informações sobre segurança de serviços de IA, consulte Autenticar solicitações para serviços de IA do Azure.

Modelo de layout

Extraia texto, marcas de seleção, estilos de texto, estruturas de tabela e coordenadas das regiões delimitadoras de documentos.

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

Adicione o exemplo de código a seguir ao seu aplicativo doc_intel_quickstart.py. Certifique-se de atualizar as variáveis de chave e ponto de extremidade com valores da sua instância de Document Intelligence do portal do Azure:

# import 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()

Execute o aplicativo

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

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

2. Digite o seguinte comando no seu terminal:

   python doc_intel_quickstart.py
   

---

Modelo pré-construído

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

Gorjeta

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

• Analise uma fatura usando o modelo de fatura pré-incorporada. Você pode usar nosso exemplo de documento de fatura para este início rápido.
• Adicionámos o valor do URL do ficheiro à variável invoiceUrl na parte superior do ficheiro.
• Para simplificar, todos os pares chave-valor que o serviço retorna não são mostrados aqui. Para ver a lista de todos os campos suportados e tipos correspondentes, consulte a nossa página de conceito de fatura .

Adicione o exemplo de código a seguir ao seu aplicativo doc_intel_quickstart.py. Certifique-se de atualizar as variáveis de chave e ponto de extremidade com valores da sua instância de Document Intelligence do portal do Azure:

# import 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()

Execute o aplicativo

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

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

2. Digite o seguinte comando no seu terminal:

   python doc_intel_quickstart.py
   

| API REST do Document Intelligence | SDKs do Azure suportados

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

Pré-requisitos

• Subscrição do Azure - Criar uma gratuitamente

• A cURL ferramenta de linha de comando instalada.

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

  • Windows
  • macOS
  • Linux

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

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

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

Gorjeta

Crie um recurso Microsoft Foundry se planeia aceder a várias ferramentas Foundry sob um único endpoint/chave. Apenas para acesso ao Document Intelligence, crie um recurso de Document Intelligence. Você precisa de um recurso de serviço único se pretende usar a autenticação do Microsoft Entra.

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

  

Analise documentos e obtenha resultados

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

Analisar documento (Solicitação POST)

Antes de executar o comando cURL, faça as seguintes alterações no pedido POST:

1. Substitua {endpoint} pelo valor do ponto de extremidade da sua instância de Análise de Documentos no portal Azure.

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

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

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

Exemplos de documentos

Funcionalidade	{modelID}	{seu-documento-url}
Ler	prebuilt-read	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/read.png
Esquema	prebuilt-layout	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/layout.png
Cartão de seguro de doença	prebuilt-healthInsuranceCard.us	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/insurance-card.png
W-2	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
Receção	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 publicá-la publicamente. Para produção, use uma maneira segura de armazenar e acessar suas credenciais, como o Azure Key Vault. Para mais informações, consulte a secção de Segurança das Ferramentas da Fundição.

Requisição POST

curl -v -i POST "{endpoint}/documentintelligence/documentModels/{modelId}:analyze?api-version=2024-11-30" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: {key}" --data-ascii "{'urlSource': '{your-document-url}'}"

Resposta ao POST (resultID)

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

Obter resultados de análise (GET Request)

Depois de chamar a Analyze document API, chame a API Get analyze result&preserve-view=true&tabs=HTTP) para obter o status da operação e os dados extraídos. Antes de executar o comando, faça estas alterações:

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

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

Pedido GET

curl -v -X GET "{endpoint}/documentintelligence/documentModels/{modelId}/analyzeResults/{resultId}?api-version=2024-11-30" -H "Ocp-Apim-Subscription-Key: {key}"

Examinar a resposta

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

Exemplo de resposta para fatura predefinida

{
    "status": "succeeded",
    "createdDateTime": "2024-03-25T19:31:37Z",
    "lastUpdatedDateTime": "2024-03-25T19:31:43Z",
    "analyzeResult": {
        "apiVersion": "2024-11-30",
        "modelId": "prebuilt-invoice",
        "stringIndexType": "textElements"...
    ..."pages": [
            {
                "pageNumber": 1,
                "angle": 0,
                "width": 8.5,
                "height": 11,
                "unit": "inch",
                "words": [
                    {
                        "content": "CONTOSO",
                        "boundingBox": [
                            0.5911,
                            0.6857,
                            1.7451,
                            0.6857,
                            1.7451,
                            0.8664,
                            0.5911,
                            0.8664
                        ],
                        "confidence": 1,
                        "span": {
                            "offset": 0,
                            "length": 7
                                }
                      }],
              }]
      }
}

Campos de documento suportados

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

É isso, parabéns!

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

Próximos passos

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

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

• Encontre mais exemplos no GitHub.