Biblioteca de clientes do Azure Document Intelligence para Java – versão 4.1.2

O Azure Document Intelligence (anteriormente conhecido como Reconhecimento de Formulários) é um serviço de nuvem que usa o aprendizado de máquina para analisar texto e dados estruturados de seus documentos. Ele inclui os seguintes recursos de main:

• Layout – extraia texto, estruturas de tabela e marcas de seleção, juntamente com suas coordenadas de região delimitador, de documentos.
• Documento – Analisar entidades, pares chave-valor, tabelas e marcas de seleção de documentos usando o modelo de documento predefinido geral.
• Predefinido – analise dados de determinados tipos de documentos comuns (como recibos, faturas, cartões de visita, documentos de identidade ou formulários fiscais W2 dos EUA) usando modelos predefinidos.
• Personalizado – crie modelos personalizados para extrair texto, valores de campo, marcas de seleção e dados de tabela de documentos. Modelos personalizados são criados com seus próprios dados, portanto, eles são adaptados aos seus documentos.
• Leitura – Leia informações sobre elementos textuais, como palavras de página e linhas, além de informações de linguagem de texto.
• Classificadores – crie classificadores personalizados para categorizar documentos em classes predefinidas.

Código-fonte | Pacote (Maven) | Documentação | de referência da APIDocumentação | do produtoAmostras

Introdução

Pré-requisitos

• Um Java Development Kit (JDK) versão 8 ou posterior.
• Assinatura do Azure
• Os Serviços Cognitivos ou Reconhecimento de Formulários conta para usar esse pacote.

Incluir o Pacote

Incluir o arquivo da BOM

Inclua o azure-sdk-bom para seu projeto para assumir a dependência da versão ga da biblioteca. No trecho a seguir, substitua o espaço reservado {bom_version_to_target} pelo número de versão. Para saber mais sobre o BOM, consulte o BOM README do SDK do AZURE.

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.azure</groupId>
            <artifactId>azure-sdk-bom</artifactId>
            <version>{bom_version_to_target}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

Em seguida, inclua a dependência direta na seção de dependências sem a marca de versão.

<dependencies>
  <dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-ai-formrecognizer</artifactId>
  </dependency>
</dependencies>

Incluir dependência direta

Se você quiser assumir a dependência de uma versão específica da biblioteca que não está presente no BOM, adicione a dependência direta ao seu projeto da seguinte maneira.

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-ai-formrecognizer</artifactId>
    <version>4.1.2</version>
</dependency>

Observação: essa versão da biblioteca de clientes usa como padrão a "2023-07-31" versão do serviço.

Esta tabela mostra a relação entre as versões do SDK e as versões de API com suporte do serviço:

Observação: a partir da versão 4.0.X, um novo conjunto de clientes foi introduzido para aproveitar os recursos mais recentes do serviço Reconhecimento de Formulários. Consulte o Guia de Migração para obter instruções detalhadas sobre como atualizar o código do aplicativo da biblioteca de clientes versão 3.1.X ou inferior à versão mais recente. Para obter mais informações, consulte Changelog. A tabela abaixo descreve a relação de cada cliente e suas versões de API com suporte:

Criar um recurso do Reconhecimento de Formulários

Reconhecimento de Formulários dá suporte ao acesso de vários serviços e de serviço único. Crie um recurso do Serviço Cognitivo se você planeja acessar vários serviços cognitivos em um único ponto de extremidade/chave. Para acesso somente de Reconhecimento de Formulários, crie um recurso Reconhecimento de Formulários.

Você pode criar qualquer recurso usando o

Opção 1:portal do Azure

Opção 2:CLI do Azure

Veja abaixo um exemplo de como você pode criar um recurso de Reconhecimento de Formulários usando a CLI:

# Create a new resource group to hold the Form Recognizer resource -
# if using an existing resource group, skip this step
az group create --name <your-resource-group> --location <location>

# Create Form Recognizer
az cognitiveservices account create \
    --name <your-form-recognizer-resource-name> \
    --resource-group <your-resource-group> \
    --kind FormRecognizer \
    --sku <sku> \
    --location <location> \
    --yes

Autenticar o cliente

Para interagir com o serviço Reconhecimento de Formulários, você precisará criar uma instância do cliente análise de documentos. Os clientes assíncronos e síncronos podem ser criados usando DocumentAnalysisClientBuilder. Invocar buildClient() criará o cliente síncrono, enquanto invocar buildAsyncClient criará seu equivalente assíncrono.

Você precisará de um ponto de extremidade e uma chave para instanciar um objeto cliente.

Pesquisando o ponto de extremidade

Você pode encontrar o ponto de extremidade do recurso Reconhecimento de Formulários no portal do Azure ou na CLI do Azure.

# Get the endpoint for the resource
az cognitiveservices account show --name "resource-name" --resource-group "resource-group-name" --query "endpoint"

Criar um cliente de Análise de Documentos usando AzureKeyCredential

Para usar AzureKeyCredential a autenticação, forneça a chave como uma cadeia de caracteres para o AzureKeyCredential. Essa chave pode ser encontrada no portal do Azure no recurso de Reconhecimento de Formulários criado ou executando o seguinte comando da CLI do Azure para obter a chave do recurso Reconhecimento de Formulários:

az cognitiveservices account keys list --resource-group <your-resource-group-name> --name <your-resource-name>

Use a chave de API como o parâmetro de credencial para autenticar o cliente:

DocumentAnalysisClient documentAnalysisClient = new DocumentAnalysisClientBuilder()
    .credential(new AzureKeyCredential("{key}"))
    .endpoint("{endpoint}")
    .buildClient();

DocumentModelAdministrationClient client =
    new DocumentModelAdministrationClientBuilder()
        .credential(new AzureKeyCredential("{key}"))
        .endpoint("{endpoint}")
        .buildClient();

Criar um cliente de Análise de Documentos com a credencial do Azure Active Directory

O SDK do Azure para Java dá suporte a um pacote de Identidade do Azure, facilitando a obtenção de credenciais de plataforma de identidade da Microsoft.

A autenticação com o AAD requer alguma configuração inicial:

• Adicionar o pacote de Identidade do Azure

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity</artifactId>
    <version>1.10.0</version>
</dependency>

• Registrar um novo aplicativo do Azure Active Directory
• Conceda acesso a Reconhecimento de Formulários atribuindo a "Cognitive Services User" função à sua entidade de serviço.

Após a configuração, você pode escolher qual tipo de credencial do azure-identity usar. Por exemplo, DefaultAzureCredential pode ser usado para autenticar o cliente: defina os valores da ID do cliente, da ID do locatário e do segredo do cliente do aplicativo AAD como variáveis de ambiente: AZURE_CLIENT_ID, AZURE_TENANT_ID AZURE_CLIENT_SECRET.

A autorização é mais fácil usando DefaultAzureCredential. Ele encontra a melhor credencial a ser usada em seu ambiente de execução. Para obter mais informações sobre como usar a autorização do Azure Active Directory com Reconhecimento de Formulários, consulte a documentação associada.

DocumentAnalysisClient documentAnalysisClient = new DocumentAnalysisClientBuilder()
    .endpoint("{endpoint}")
    .credential(new DefaultAzureCredentialBuilder().build())
    .buildClient();

Principais conceitos

DocumentAnalysisClient

O DocumentAnalysisClient e o DocumentAnalysisAsyncClient fornecem operações síncronas e assíncronas para analisar documentos de entrada usando modelos personalizados e predefinidos por meio dos beginAnalyzeDocument métodos e beginAnalyzeDocumentFromUrl . Veja uma lista completa de modelos com suporte aqui.

Snippets de código de exemplo para ilustrar o uso de um DocumentAnalysisClient aqui. Mais informações sobre como analisar documentos, incluindo recursos com suporte, localidades e tipos de documentos, podem ser encontradas aqui.

DocumentModelAdministrationClient

DocumentModelAdministrationClient e DocumentModelAdministrationAsyncClient fornecem operações síncronas e assíncronas

• Crie modelos de análise de documentos personalizados para analisar conteúdo de texto, campos e valores encontrados em seus documentos personalizados. Confira o exemplo Criar um modelo de documento. Um DocumentModelDetails é retornado indicando os tipos de documento que o modelo pode analisar, juntamente com os campos e esquemas que ele extrairá.
• Gerenciar modelos criados em sua conta criando, listando, excluindo e vendo o limite de modelos personalizados de sua conta. Confira o exemplo Gerenciar modelos.
• Copiar um modelo personalizado de um recurso de Reconhecimento de Formulários para outro.
• Criando um modelo composto a partir de uma coleção de modelos criados existentes.
• Listando operações de modelo de documento associadas ao recurso Reconhecimento de Formulários.

Snippets de código de exemplo são fornecidos para ilustrar usando um DocumentModelAdministrationClient aqui.

Operações de execução longa

Operações de execução prolongada são operações que consistem em uma solicitação inicial enviada ao serviço para iniciar uma operação, seguidas pela sondagem do serviço em intervalos para determinar se a operação foi concluída ou falhou e, se foi bem-sucedida, para obter o resultado.

Métodos que criam modelos, analisam valores de documentos ou copiam e compõem modelos são modelados como operações de execução longa. O cliente expõe um begin<MethodName> método que retorna uma SyncPoller instância ou PollerFlux . Os chamadores devem aguardar a conclusão da operação chamando getFinalResult() a operação retornada do begin<MethodName> método . Snippets de código de exemplo são fornecidos para ilustrar o uso de operações de execução longa abaixo.

Exemplos

A seção a seguir fornece vários snippets de código que abrangem algumas das tarefas de Reconhecimento de Formulários mais comuns, incluindo:

• Extrair Layout
• Usar um modelo de documento geral
• Usar modelos predefinidos
• Criar um modelo de documento
• Analisar documentos usando um modelo personalizado
• Gerenciar seus modelos
• Classificar um documento

Extrair Layout

Extraia texto, estruturas de tabela e marcas de seleção, como botões de opção e caixas de marcar, juntamente com suas coordenadas de caixa delimitadora de documentos sem a necessidade de criar um modelo.

// analyze document layout using file input stream
File layoutDocument = new File("local/file_path/filename.png");
Path filePath = layoutDocument.toPath();
BinaryData layoutDocumentData = BinaryData.fromFile(filePath, (int) layoutDocument.length());

SyncPoller<OperationResult, AnalyzeResult> analyzeLayoutResultPoller =
    documentAnalysisClient.beginAnalyzeDocument("prebuilt-layout", layoutDocumentData);

AnalyzeResult analyzeLayoutResult = analyzeLayoutResultPoller.getFinalResult();

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

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

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

// tables
List<DocumentTable> tables = analyzeLayoutResult.getTables();
for (int i = 0; i < tables.size(); i++) {
    DocumentTable documentTable = tables.get(i);
    System.out.printf("Table %d has %d rows and %d columns.%n", i, documentTable.getRowCount(),
        documentTable.getColumnCount());
    documentTable.getCells().forEach(documentTableCell -> {
        System.out.printf("Cell '%s', has row index %d and column index %d.%n", documentTableCell.getContent(),
            documentTableCell.getRowIndex(), documentTableCell.getColumnIndex());
    });
    System.out.println();
}

Usar um modelo de documento geral

Analise pares chave-valor, tabelas, estilos e marcas de seleção de documentos usando o modelo de documento geral fornecido pelo serviço Reconhecimento de Formulários. Selecione o Modelo de Documento Geral passando modelId="prebuilt-document" para o método beginAnalyzeDocumentFromUrl da seguinte maneira:

String documentUrl = "{document-url}";
String modelId = "prebuilt-document";
SyncPoller<OperationResult, AnalyzeResult> analyzeDocumentPoller =
    documentAnalysisClient.beginAnalyzeDocumentFromUrl(modelId, documentUrl);

AnalyzeResult analyzeResult = analyzeDocumentPoller.getFinalResult();

for (int i = 0; i < analyzeResult.getDocuments().size(); i++) {
    final AnalyzedDocument analyzedDocument = analyzeResult.getDocuments().get(i);
    System.out.printf("----------- Analyzing document %d -----------%n", i);
    System.out.printf("Analyzed document has doc type %s with confidence : %.2f%n",
        analyzedDocument.getDocType(), analyzedDocument.getConfidence());
}

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

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

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

// tables
List<DocumentTable> tables = analyzeResult.getTables();
for (int i = 0; i < tables.size(); i++) {
    DocumentTable documentTable = tables.get(i);
    System.out.printf("Table %d has %d rows and %d columns.%n", i, documentTable.getRowCount(),
        documentTable.getColumnCount());
    documentTable.getCells().forEach(documentTableCell -> {
        System.out.printf("Cell '%s', has row index %d and column index %d.%n",
            documentTableCell.getContent(),
            documentTableCell.getRowIndex(), documentTableCell.getColumnIndex());
    });
    System.out.println();
}

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

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

Usar modelos predefinidos

Extraia campos de tipos de documentos selecionados, como recibos, faturas, cartões de visita e documentos de identidade usando modelos predefinidos fornecidos pelo serviço Reconhecimento de Formulários. Os modelos predefinidos com suporte são:

• Analisar recibos usando o prebuilt-receipt modelo (os campos reconhecidos pelo serviço podem ser encontrados aqui)
• Analise cartões de visita usando o prebuilt-businessCard modelo (os campos reconhecidos pelo serviço podem ser encontrados aqui).
• Analise faturas usando o prebuilt-invoice modelo (os campos reconhecidos pelo serviço podem ser encontrados aqui).
• Analise documentos de identidade usando o prebuilt-idDocuments modelo (os campos reconhecidos pelo serviço podem ser encontrados aqui).
• Analise formulários fiscais do US W2 usando o prebuilt-tax.us.w2 modelo. Campos com suporte.

Por exemplo, para analisar campos de um recibo de vendas, no beginAnalyzeDocumentFromUrl método :

String receiptUrl = "https://raw.githubusercontent.com/Azure/azure-sdk-for-java/main/sdk/formrecognizer"
    + "/azure-ai-formrecognizer/src/samples/resources/sample-documents/receipts/contoso-allinone.jpg";

SyncPoller<OperationResult, AnalyzeResult> analyzeReceiptPoller =
    documentAnalysisClient.beginAnalyzeDocumentFromUrl("prebuilt-receipt", receiptUrl);

AnalyzeResult receiptResults = analyzeReceiptPoller.getFinalResult();

for (int i = 0; i < receiptResults.getDocuments().size(); i++) {
    AnalyzedDocument analyzedReceipt = receiptResults.getDocuments().get(i);
    Map<String, DocumentField> receiptFields = analyzedReceipt.getFields();
    System.out.printf("----------- Analyzing receipt info %d -----------%n", i);
    DocumentField merchantNameField = receiptFields.get("MerchantName");
    if (merchantNameField != null) {
        if (DocumentFieldType.STRING == merchantNameField.getType()) {
            String merchantName = merchantNameField.getValueAsString();
            System.out.printf("Merchant Name: %s, confidence: %.2f%n",
                merchantName, merchantNameField.getConfidence());
        }
    }

    DocumentField merchantPhoneNumberField = receiptFields.get("MerchantPhoneNumber");
    if (merchantPhoneNumberField != null) {
        if (DocumentFieldType.PHONE_NUMBER == merchantPhoneNumberField.getType()) {
            String merchantAddress = merchantPhoneNumberField.getValueAsPhoneNumber();
            System.out.printf("Merchant Phone number: %s, confidence: %.2f%n",
                merchantAddress, merchantPhoneNumberField.getConfidence());
        }
    }

    DocumentField transactionDateField = receiptFields.get("TransactionDate");
    if (transactionDateField != null) {
        if (DocumentFieldType.DATE == transactionDateField.getType()) {
            LocalDate transactionDate = transactionDateField.getValueAsDate();
            System.out.printf("Transaction Date: %s, confidence: %.2f%n",
                transactionDate, transactionDateField.getConfidence());
        }
    }

    DocumentField receiptItemsField = receiptFields.get("Items");
    if (receiptItemsField != null) {
        System.out.printf("Receipt Items: %n");
        if (DocumentFieldType.LIST == receiptItemsField.getType()) {
            List<DocumentField> receiptItems = receiptItemsField.getValueAsList();
            receiptItems.stream()
                .filter(receiptItem -> DocumentFieldType.MAP == receiptItem.getType())
                .map(documentField -> documentField.getValueAsMap())
                .forEach(documentFieldMap -> documentFieldMap.forEach((key, documentField) -> {
                    if ("Name".equals(key)) {
                        if (DocumentFieldType.STRING == documentField.getType()) {
                            String name = documentField.getValueAsString();
                            System.out.printf("Name: %s, confidence: %.2fs%n",
                                name, documentField.getConfidence());
                        }
                    }
                    if ("Quantity".equals(key)) {
                        if (DocumentFieldType.DOUBLE == documentField.getType()) {
                            Double quantity = documentField.getValueAsDouble();
                            System.out.printf("Quantity: %f, confidence: %.2f%n",
                                quantity, documentField.getConfidence());
                        }
                    }
                }));
        }
    }
}

Para obter mais informações e exemplos usando modelos predefinidos, consulte:

• Cartões de visita
• Documentos de Identidade
• Faturas
• Exemplo de recibos

Criar um modelo de documento

Crie um modelo de aprendizado de máquina em seu próprio tipo de documento. O modelo resultante poderá analisar valores dos tipos de documentos nos quais foi criado. Forneça uma URL SAS de contêiner para o contêiner de Blob de Armazenamento do Azure em que você está armazenando os documentos de treinamento. Confira detalhes sobre como configurar isso na documentação de início rápido do serviço.

Observação

Você pode usar a versão prévia do Reconhecimento de Formulários Studio para criar um arquivo rotulado para seus formulários de treinamento. Mais detalhes sobre como configurar um contêiner e a estrutura de arquivos necessária podem ser encontrados no aqui.

// Build custom document analysis model
String blobContainerUrl = "{SAS_URL_of_your_container_in_blob_storage}";
// The shared access signature (SAS) Url of your Azure Blob Storage container with your forms.
String prefix = "{blob_name_prefix}}";
SyncPoller<OperationResult, DocumentModelDetails> buildOperationPoller =
    documentModelAdminClient.beginBuildDocumentModel(blobContainerUrl,
        DocumentModelBuildMode.TEMPLATE,
        prefix,
        new BuildDocumentModelOptions().setModelId("my-build-model").setDescription("model desc"),
        Context.NONE);

DocumentModelDetails documentModelDetails = buildOperationPoller.getFinalResult();

// Model Info
System.out.printf("Model ID: %s%n", documentModelDetails.getModelId());
System.out.printf("Model Description: %s%n", documentModelDetails.getDescription());
System.out.printf("Model created on: %s%n%n", documentModelDetails.getCreatedOn());
documentModelDetails.getDocumentTypes().forEach((key, documentTypeDetails) -> {
    System.out.printf("Document type: %s%n", key);
    documentTypeDetails.getFieldSchema().forEach((name, documentFieldSchema) -> {
        System.out.printf("Document field: %s%n", name);
        System.out.printf("Document field type: %s%n", documentFieldSchema.getType().toString());
        System.out.printf("Document field confidence: %.2f%n", documentTypeDetails.getFieldConfidence().get(name));
    });
});

Analisar documentos usando um modelo personalizado

Analise os pares chave/valor e os dados da tabela de documentos. Esses modelos são criados com seus próprios dados, portanto, eles são adaptados aos seus documentos. Você só deve analisar documentos do mesmo tipo de documento no qual o modelo personalizado foi criado.

String documentUrl = "{document-url}";
String modelId = "{custom-built-model-ID}";
SyncPoller<OperationResult, AnalyzeResult> analyzeDocumentPoller =
    documentAnalysisClient.beginAnalyzeDocumentFromUrl(modelId, documentUrl);

AnalyzeResult analyzeResult = analyzeDocumentPoller.getFinalResult();

for (int i = 0; i < analyzeResult.getDocuments().size(); i++) {
    final AnalyzedDocument analyzedDocument = analyzeResult.getDocuments().get(i);
    System.out.printf("----------- Analyzing custom document %d -----------%n", i);
    System.out.printf("Analyzed document has doc type %s with confidence : %.2f%n",
        analyzedDocument.getDocType(), analyzedDocument.getConfidence());
    analyzedDocument.getFields().forEach((key, documentField) -> {
        System.out.printf("Document Field content: %s%n", documentField.getContent());
        System.out.printf("Document Field confidence: %.2f%n", documentField.getConfidence());
        System.out.printf("Document Field Type: %s%n", documentField.getType());
        System.out.printf("Document Field found within bounding region: %s%n",
            documentField.getBoundingRegions().toString());
    });
}

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

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

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

// tables
List<DocumentTable> tables = analyzeResult.getTables();
for (int i = 0; i < tables.size(); i++) {
    DocumentTable documentTable = tables.get(i);
    System.out.printf("Table %d has %d rows and %d columns.%n", i, documentTable.getRowCount(),
        documentTable.getColumnCount());
    documentTable.getCells().forEach(documentTableCell -> {
        System.out.printf("Cell '%s', has row index %d and column index %d.%n",
            documentTableCell.getContent(),
            documentTableCell.getRowIndex(), documentTableCell.getColumnIndex());
    });
    System.out.println();
}

Gerenciar seus modelos

Gerencie os modelos em sua conta Reconhecimento de Formulários.

AtomicReference<String> modelId = new AtomicReference<>();

// First, we see how many models we have, and what our limit is
ResourceDetails resourceDetails = documentModelAdminClient.getResourceDetails();
System.out.printf("The resource has %s models, and we can have at most %s models",
    resourceDetails.getCustomDocumentModelCount(), resourceDetails.getCustomDocumentModelLimit());

// Next, we get a paged list of all of our models
PagedIterable<DocumentModelSummary> customDocumentModels = documentModelAdminClient.listDocumentModels();
System.out.println("We have following models in the account:");
customDocumentModels.forEach(documentModelSummary -> {
    System.out.printf("Model ID: %s%n", documentModelSummary.getModelId());
    modelId.set(documentModelSummary.getModelId());

    // get custom document analysis model info
    DocumentModelDetails documentModel = documentModelAdminClient.getDocumentModel(documentModelSummary.getModelId());
    System.out.printf("Model ID: %s%n", documentModel.getModelId());
    System.out.printf("Model Description: %s%n", documentModel.getDescription());
    System.out.printf("Model created on: %s%n", documentModel.getCreatedOn());
    documentModel.getDocumentTypes().forEach((key, documentTypeDetails) -> {
        documentTypeDetails.getFieldSchema().forEach((field, documentFieldSchema) -> {
            System.out.printf("Field: %s", field);
            System.out.printf("Field type: %s", documentFieldSchema.getType());
            System.out.printf("Field confidence: %.2f", documentTypeDetails.getFieldConfidence().get(field));
        });
    });
});

// Delete Model
documentModelAdminClient.deleteDocumentModel(modelId.get());

Classificar um documento

O serviço Reconhecimento de Formulários dá suporte a classificadores de documentos personalizados que podem classificar documentos em um conjunto de categorias predefinidas com base em um conjunto de dados de treinamento. Os documentos podem ser classificados com um classificador personalizado usando o beginClassifyDocument método ou beginClassifyDocumentFromUrl de DocumentAnalysisClient. O exemplo a seguir mostra como classificar um documento usando um classificador personalizado:

String documentUrl = "{file_source_url}";
String classifierId = "{custom_trained_classifier_id}";

documentAnalysisClient.beginClassifyDocumentFromUrl(classifierId, documentUrl, Context.NONE)
    .getFinalResult()
    .getDocuments()
    .forEach(analyzedDocument -> System.out.printf("Doc Type: %s%n", analyzedDocument.getDocType()));

Para obter exemplos mais detalhados, consulte exemplos.

Solução de problemas

Geral

Reconhecimento de Formulários clientes geram HttpResponseExceptionexceções. Por exemplo, se você tentar fornecer uma URL de origem de arquivo inválida, uma HttpResponseException será gerada com um erro indicando a causa da falha. No snippet de código a seguir, o erro é tratado normalmente com a captura da exceção e a exibição de informações adicionais sobre o erro.

try {
    documentAnalysisClient.beginAnalyzeDocumentFromUrl("prebuilt-receipt", "invalidSourceUrl");
} catch (HttpResponseException e) {
    System.out.println(e.getMessage());
    // Do something with the exception
}

Habilitar o log do cliente

Os SDKs do Azure para Java oferecem uma história de log consistente para ajudar a solucionar problemas de erros do aplicativo e agilizar a resolução. Os logs produzidos capturam o fluxo de um aplicativo antes que acessem o estado do terminal para ajudar a localizar o problema raiz. Exiba o wiki de log para obter diretrizes sobre como habilitar o registro em log.

Cliente HTTP padrão

Por padrão, todas as bibliotecas de cliente usam o cliente HTTP do Netty. Adicione a dependência acima para configurar automaticamente a biblioteca de clientes para usar o cliente HTTP do Netty. A configuração ou a alteração do cliente HTTP é detalhada no wiki de clientes HTTP.

Próximas etapas

A seção a seguir fornece vários snippets de código ilustrando padrões comuns usados na API Reconhecimento de Formulários. Esses exemplos de código mostram operações de cenário comuns com a biblioteca de clientes do Azure Reconhecimento de Formulários.

• Analisar cartão de negócios de uma URL: AnalyzeBusinessCardFromUrl
• Analisar documentos de identidade de uma URL: AnalyzeIdentityDocumentsFromUrl
• Analisar fatura de uma URL: AnalyzeInvoiceFromUrl
• Analisar recibos: AnalyzeReceipts
• Analisar recibos de uma URL: AnalyzeReceiptsFromUrl
• Extrair layout: AnalyzeLayout
• Analisar documentos personalizados de uma URL: AnalyzeCustomDocumentFromUrl
• Criar um modelo: BuildModel
• Gerenciar modelos personalizados: ManageCustomModels
• Copiar um modelo entre Reconhecimento de Formulários recursos: CopyModel
• Criar um modelo composto de uma coleção de modelos personalizados: ComposeModel
• Obter/listar operações de modelo de documento associadas ao recurso Reconhecimento de Formulários: GetOperation
• Criar um classificador de documento: BuildDocumentClassifier

APIs assíncronas

Todos os exemplos mostrados até agora foram usando APIs síncronas, mas também fornecemos suporte completo para APIs assíncronas. Você precisará usar DocumentAnalysisAsyncClient

DocumentAnalysisAsyncClient documentAnalysisAsyncClient = new DocumentAnalysisClientBuilder()
    .credential(new AzureKeyCredential("{key}"))
    .endpoint("{endpoint}")
    .buildAsyncClient();

• Analisar cartão de negócios de uma URL: AnalyzeBusinessCardFromUrlAsync
• Analisar documentos de identidade de uma URL: AnalyzeIdentityDocumentsFromUrlAsync
• Analisar fatura: AnalyzeInvoiceAsync
• Analisar recibos: AnalyzeReceiptsAsync
• Analisar recibos de uma URL: AnalyzeReceiptsFromUrlAsync
• Extrair layout de uma URL: AnalyzeLayoutFromUrlAsync
• Analisar documentos personalizados: AnalyzeCustomDocumentAsync
• Criar um modelo de documento: BuildModelAsync
• Gerenciar modelos personalizados: ManageCustomModelsAsync
• Copiar um modelo de documento entre recursos Reconhecimento de Formulários: CopyModelAsync
• Criar um modelo de documento composto de uma coleção de modelos personalizados: ComposeModelAsync
• Obter/listar operações de modelo de documento associadas ao recurso Reconhecimento de Formulários: GetOperationAsync
• Criar um classificador de documento: BuildDocumentClassifierAsync

Documentação adicional

Consulte o LEIAME de exemplo para obter vários snippets de código que ilustram padrões comuns usados no SDK do Java Reconhecimento de Formulários. Para obter uma documentação mais abrangente sobre os Serviços Cognitivos do Azure Reconhecimento de Formulários, consulte a documentação do Reconhecimento de Formulários.

Contribuição

Este projeto aceita contribuições e sugestões. A maioria das contribuições exige que você concorde com um CLA (Contrato de Licença do Colaborador) declarando que você tem o direito de nos conceder e de fato concede, os direitos de usar sua contribuição.

Quando você envia uma solicitação de pull, um bot do CLA determina automaticamente se você precisa fornecer um CLA e preencher a PR corretamente (por exemplo, rótulo, comentário). Basta seguir as instruções fornecidas pelo bot. Você só precisará fazer isso uma vez em todos os repositórios que usam nosso CLA.

Este projeto adotou o Código de Conduta de Software Livre da Microsoft. Para obter mais informações, confira as Perguntas frequentes sobre o código de conduta ou entre em contato com opencode@microsoft.com para enviar outras perguntas ou comentários.