Compartir a través de

Biblioteca cliente de Azure Document Intelligence para Java: versión 4.1.2

  • Artículo

Azure Document Intelligence (anteriormente conocido como Form Recognizer) es un servicio en la nube que usa el aprendizaje automático para analizar texto y datos estructurados de los documentos. Incluye las siguientes características principales:

  • Diseño: extraiga texto, estructuras de tabla y marcas de selección, junto con sus coordenadas de región delimitador, de los documentos.
  • Documento: analice entidades, pares clave-valor, tablas y marcas de selección de documentos mediante el modelo de documento precompilado general.
  • Precompilado: analice datos de determinados tipos de documentos comunes (como recibos, facturas, tarjetas de presentación, documentos de identidad o formularios fiscales W2 de EE. UU.) mediante modelos creados previamente.
  • Personalizado: cree modelos personalizados para extraer texto, valores de campo, marcas de selección y datos de tabla de documentos. Los modelos personalizados se crean con sus propios datos, por lo que se adaptan a los documentos.
  • Leer: leer información sobre elementos textuales, como palabras de página y líneas, además de información de idioma de texto.
  • Clasificadores: cree clasificadores personalizados para clasificar documentos en clases predefinidas.

Código | fuentePaquete (Maven) | Documentación | de referencia de APIDocumentación del | productoMuestras

Introducción

Requisitos previos

Inclusión del paquete

Inclusión del archivo BOM

Incluya azure-sdk-bom en el proyecto para que dependa de la versión de disponibilidad general de la biblioteca. En el fragmento de código siguiente, reemplace el marcador de posición {bom_version_to_target} por el número de versión. Para más información sobre la lista de materiales, consulte el archivo Léame bom del SDK de 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>

A continuación, incluya la dependencia directa en la sección de dependencias sin la etiqueta de versión.

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

Inclusión de dependencias directas

Si desea depender de una versión determinada de la biblioteca que no está presente en la lista de materiales, agregue la dependencia directa al proyecto como se indica a continuación.

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

Nota: Esta versión de la biblioteca cliente tiene como valor predeterminado la "2023-07-31" versión del servicio.

En esta tabla se muestra la relación entre las versiones del SDK y las versiones de la API admitidas del servicio:

Versión del SDK Versión de la API admitidas del servicio
3.0.x 2.0
3.1.X - 3.1.12 2.0, 2.1 (valor predeterminado)
4.0.0 2.0, 2.1, 2022-08-31 (valor predeterminado)
4.1.0 2.0, 2.1, 2022-08-31, 2023-07-31 (valor predeterminado)

Nota: A partir de la versión 4.0.X, se introdujo un nuevo conjunto de clientes para aprovechar las características más recientes del servicio Form Recognizer. Consulte la Guía de migración para obtener instrucciones detalladas sobre cómo actualizar el código de aplicación de la versión 3.1.X de la biblioteca cliente o una versión anterior a la versión más reciente. Para obtener más información, consulte Registro de cambios. En la tabla siguiente se describe la relación de cada cliente y sus versiones de API admitidas:

Versión de API Clientes compatibles
2023-07-31 DocumentAnalysisClient y DocumentModelAdministrationClient
2022-08-31 DocumentAnalysisClient y DocumentModelAdministrationClient
2.1 FormRecognizerClient y FormTrainingClient
2.0 FormRecognizerClient y FormTrainingClient

Creación de un recurso de Form Recognizer

Form Recognizer admite el acceso de varios servicios y de un solo servicio. Cree un recurso de Cognitive Services si planea acceder a varios servicios cognitivos en un único punto de conexión o clave. Para acceder únicamente a Form Recognizer, cree un recurso de Form Recognizer.

Puede crear cualquiera de los recursos mediante .

Opción 1:Azure Portal

Opción 2:CLI de Azure

A continuación se muestra un ejemplo de cómo puede crear un recurso de Form Recognizer mediante la 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 el cliente

Para interactuar con el servicio Form Recognizer, deberá crear una instancia del cliente de Análisis de documentos. Los clientes asincrónicos y sincrónicos se pueden crear mediante DocumentAnalysisClientBuilder. La invocación buildClient() creará el cliente sincrónico, mientras que la invocación buildAsyncClient creará su homólogo asincrónico.

Necesitará un punto de conexión y una clave para crear una instancia de un objeto de cliente.

Búsqueda del punto de conexión

Puede encontrar el punto de conexión del recurso de Form Recognizer en el Azure Portal o la CLI de Azure.

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

Creación de un cliente de Análisis de documentos mediante AzureKeyCredential

Para usar AzureKeyCredential la autenticación, proporcione la clave como una cadena a AzureKeyCredential. Esta clave se puede encontrar en el Azure Portal del recurso de Form Recognizer creado o ejecutando el siguiente comando de la CLI de Azure para obtener la clave del recurso Form Recognizer:

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

Use la clave de API como parámetro de credencial para autenticar al cliente:

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

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

Creación de un cliente de Análisis de documentos con credenciales de Azure Active Directory

Azure SDK para Java admite un paquete de identidad de Azure, lo que facilita la obtención de credenciales de Plataforma de identidad de Microsoft.

La autenticación con AAD requiere una configuración inicial:

  • Adición del paquete de identidad de Azure
<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity</artifactId>
    <version>1.10.0</version>
</dependency>

Después de la configuración, puede elegir el tipo de credencial de azure-identity que se va a usar. Por ejemplo, Se puede usar DefaultAzureCredential para autenticar al cliente: establezca los valores del identificador de cliente, el identificador de inquilino y el secreto de cliente de la aplicación de AAD como variables de entorno: AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET.

La autorización es más fácil mediante DefaultAzureCredential. Encuentra la mejor credencial para usar en su entorno en ejecución. Para más información sobre el uso de la autorización de Azure Active Directory con Form Recognizer, consulte la documentación asociada.

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

Conceptos clave

DocumentAnalysisClient

DocumentAnalysisClient y DocumentAnalysisAsyncClient proporcionan operaciones sincrónicas y asincrónicas para analizar documentos de entrada mediante modelos personalizados y creados previamente a través de los beginAnalyzeDocument métodos y beginAnalyzeDocumentFromUrl . Consulte aquí una lista completa de los modelos admitidos.

Fragmentos de código de ejemplo para ilustrar el uso de DocumentAnalysisClient aquí. Puede encontrar más información sobre el análisis de documentos, incluidas las características admitidas, las configuraciones regionales y los tipos de documento aquí.

DocumentModelAdministrationClient

DocumentModelAdministrationClient y DocumentModelAdministrationAsyncClient proporcionan operaciones sincrónicas y asincrónicas.

  • Cree modelos de análisis de documentos personalizados para analizar el contenido de texto, los campos y los valores que se encuentran en los documentos personalizados. Vea el ejemplo Creación de un modelo de documento. Se devuelve un DocumentModelDetails valor que indica los tipos de documento que el modelo puede analizar, junto con los campos y esquemas que extraerá.
  • Para administrar los modelos creados en su cuenta, cree, muestre, elimine y vea el límite de modelos personalizados de su cuenta. Consulte el ejemplo Administración de modelos.
  • La copia de un modelo personalizado entre recursos de Form Recognizer.
  • Crear un modelo compuesto a partir de una colección de modelos compilados existentes.
  • Enumerar las operaciones del modelo de documento asociadas al recurso Form Recognizer.

Aquí se proporcionan fragmentos de código de ejemplo para ilustrar el uso de ejemplos de DocumentModelAdministrationClient.

Operaciones de larga duración

Las operaciones de larga duración son operaciones que constan de una solicitud inicial enviada al servicio para iniciar una operación, seguida de sondear el servicio a intervalos para determinar si la operación se ha completado o no, y si se ha realizado correctamente, para obtener el resultado.

Los métodos que compilan modelos, analizan valores de documentos o copian y redactan modelos se modelan como operaciones de larga duración. El cliente expone un begin<MethodName> método que devuelve una SyncPoller instancia o PollerFlux . Los autores de llamadas deben esperar a que se complete la operación llamando getFinalResult() a en la operación devuelta desde el begin<MethodName> método . A continuación se proporcionan fragmentos de código de ejemplo para ilustrar el uso de operaciones de larga duración.

Ejemplos

En la sección siguiente se proporcionan varios fragmentos de código que abarcan algunas de las tareas Form Recognizer más comunes, entre las que se incluyen:

Extraer diseño

Extraiga texto, estructuras de tabla y marcas de selección como botones de radio y casillas, junto con sus coordenadas de cuadro de límite de documentos sin necesidad de crear un 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 un modelo de documento general

Analice pares clave-valor, tablas, estilos y marcas de selección de documentos mediante el modelo de documento general proporcionado por el servicio Form Recognizer. Seleccione el modelo de documento general pasando modelId="prebuilt-document" al método beginAnalyzeDocumentFromUrl de la siguiente manera:

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

Uso de modelos precompilados

Extraiga campos de tipos de documentos seleccionados, como recibos, facturas, tarjetas de presentación y documentos de identidad mediante modelos creados previamente proporcionados por el servicio Form Recognizer. Los modelos precompilados admitidos son:

  • Analizar recibos mediante el prebuilt-receipt modelo (los campos reconocidos por el servicio se pueden encontrar aquí)
  • Analizar tarjetas de presentación mediante el prebuilt-businessCard modelo (los campos reconocidos por el servicio se pueden encontrar aquí).
  • Analizar facturas mediante el prebuilt-invoice modelo (los campos reconocidos por el servicio se pueden encontrar aquí).
  • Analizar documentos de identidad mediante el prebuilt-idDocuments modelo (los campos reconocidos por el servicio se pueden encontrar aquí).
  • Analice los formularios fiscales W2 de EE. UU. mediante el prebuilt-tax.us.w2 modelo. Campos admitidos.

Por ejemplo, para analizar campos de un recibo de ventas, en el 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 obtener más información y ejemplos con modelos creados previamente, consulte:

Compilación de un modelo de documento

Cree un modelo de aprendizaje automático en su propio tipo de documento. El modelo resultante podrá analizar los valores de los tipos de documentos en los que se creó. Proporcione una dirección URL de SAS de contenedor al contenedor de blobs de Azure Storage donde va a almacenar los documentos de entrenamiento. Consulte los detalles sobre cómo configurarlo en la documentación de inicio rápido del servicio.

Note

Puede usar la versión preliminar de Form Recognizer Studio para crear un archivo etiquetado para los formularios de entrenamiento. Puede encontrar más detalles sobre la configuración de un contenedor y la estructura de archivos necesaria en aquí.

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

Análisis de documentos mediante un modelo personalizado

Analice los pares clave-valor y los datos de tabla de los documentos. Estos modelos se crean con sus propios datos, por lo que se adaptan a los documentos. Solo debe analizar documentos del mismo tipo de documento en el que se creó el modelo personalizado.

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

Administración de los modelos

Administre los modelos de la cuenta de Form Recognizer.

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

Clasificación de un documento

El servicio Form Recognizer admite clasificadores de documentos personalizados que pueden clasificar documentos en un conjunto de categorías predefinidas basadas en un conjunto de datos de entrenamiento. Los documentos se pueden clasificar con un clasificador personalizado mediante el beginClassifyDocument método o beginClassifyDocumentFromUrl de DocumentAnalysisClient. En el ejemplo siguiente se muestra cómo clasificar un documento mediante un clasificador 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 obtener ejemplos más detallados, consulte ejemplos.

Solución de problemas

General

Form Recognizer clientes generan HttpResponseExceptionexcepciones. Por ejemplo, si intenta proporcionar una dirección URL de origen de archivo no válida, se producirá una excepción HttpResponseException con un error que indica la causa. En el siguiente fragmento de código, el error se controla correctamente mediante la captura y presentación de la información adicional sobre el error.

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

Habilitación del registro de cliente

Los SDK de Azure para Java ofrecen una historia de registro coherente para ayudar a solucionar errores de aplicación y acelerar su resolución. Los registros generados capturarán el flujo de una aplicación antes de alcanzar el estado terminal para ayudar a encontrar el problema raíz. Vea la wiki de registro para obtener instrucciones sobre cómo habilitar el registro.

Cliente HTTP predeterminado

Todas las bibliotecas cliente usan de forma predeterminada el cliente HTTP de Netty. Agregue la dependencia anterior para configurar automáticamente la biblioteca cliente para usar el cliente HTTP de Netty. La configuración o el cambio del cliente HTTP se detalla en la wiki de clientes HTTP.

Pasos siguientes

En la sección siguiente se proporcionan varios fragmentos de código que ilustran patrones comunes que se usan en la API de Form Recognizer. Estos ejemplos de código muestran operaciones de escenario comunes con la biblioteca cliente de Azure Form Recognizer.

API asincrónicas

Todos los ejemplos mostrados hasta ahora han estado usando API sincrónicas, pero también proporcionamos compatibilidad completa con las API asincrónicas. Tendrá que usar DocumentAnalysisAsyncClient

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

Documentación adicional

Consulte el archivo Léame de ejemplo para ver varios fragmentos de código que ilustran patrones comunes que se usan en el SDK de Java de Form Recognizer. Para obtener documentación más amplia sobre azure Cognitive Services Form Recognizer, consulte la documentación de Form Recognizer.

Contribuciones

Este proyecto agradece las contribuciones y sugerencias. La mayoría de las contribuciones requieren que acepte un Contrato de licencia para el colaborador (CLA) que declara que tiene el derecho a concedernos y nos concede los derechos para usar su contribución.

Cuando se envía una solicitud de incorporación de cambios, un bot de CLA determinará de forma automática si tiene que aportar un CLA y completar la PR adecuadamente (por ejemplo, la etiqueta, el comentario). Solo siga las instrucciones que le dará el bot. Solo será necesario que lo haga una vez en todos los repositorios con nuestro CLA.

El proyecto ha adoptado el Código de conducta de código abierto de Microsoft. Para obtener más información, consulte las preguntas más frecuentes del código de conducta o póngase en contacto con opencode@microsoft.com si tiene cualquier otra pregunta o comentario.

Impresiones