com.azure.ai.formrecognizer

Azure Form Recognizer es un servicio basado en la nube proporcionado por Microsoft Azure que usa el aprendizaje automático para extraer información de varios tipos de formularios. Está diseñado para automatizar el proceso de reconocimiento de formularios, extracción de datos y comprensión de formularios. Azure Form Recognizer puede controlar formularios estructurados, como facturas, recibos y encuestas, así como datos de formulario no estructurados, como contratos, contratos e informes financieros.

El servicio usa tecnología avanzada de reconocimiento óptico de caracteres (OCR) para extraer pares de texto y clave-valor de formularios personalizados, lo que permite a las organizaciones automatizar las tareas de entrada de datos que, de lo contrario, requerirían un esfuerzo manual. Puede reconocer y extraer información como fechas, direcciones, números de factura, elementos de línea y otros puntos de datos pertinentes de formularios.

La biblioteca cliente de Azure Form Recognizer permite a los desarrolladores de Java interactuar con el servicio azure Form Recognizer. Proporciona un conjunto de clases y métodos que abstraen la API RESTful subyacente de Azure Form Recognizer, lo que facilita la integración del servicio en aplicaciones Java.

La biblioteca cliente de Azure Form Recognizer proporciona las siguientes funcionalidades:

1. Reconocimiento de formularios: permite enviar formularios para extraer información como texto, pares clave-valor, tablas y campos de formulario. Puede analizar documentos estructurados y no estructurados.
2. Administración de modelos: permite entrenar modelos personalizados proporcionando datos de entrenamiento etiquetados. También puede enumerar y eliminar modelos existentes.
3. Reconocer resultados: proporciona métodos para recuperar e interpretar los resultados del análisis, incluidos los valores de texto y campo extraídos, las puntuaciones de confianza y la información de diseño de formulario.
4. Sondeo y devoluciones de llamada: incluye mecanismos para sondear el servicio para comprobar el estado de una operación de análisis o registrar devoluciones de llamada para recibir notificaciones cuando se complete el análisis.

Introducción

La biblioteca de Azure Form Recognizer proporciona clientes de análisis como FormRecognizerAsyncClient y FormRecognizerClient para conectarse a la Form Recognizer Azure Cognitive Service para analizar información de formularios y extraerla en datos estructurados. También proporciona clientes de entrenamiento como FormTrainingClient y FormTrainingAsyncClient para compilar y administrar modelos a partir de formularios personalizados.

Nota:Este cliente solo admite com.azure.ai.formrecognizer.FormRecognizerServiceVersion#V2_1 y reduce. Se recomienda usar una versión DocumentAnalysisClient de servicio más reciente y DocumentModelAdministrationClient.

Consulte la guía de migración para usar las versiones de API 2022-08-31 y versiones posteriores.

Los clientes de servicio son el punto de interacción para que los desarrolladores usen Azure Form Recognizer. FormRecognizerClient es el cliente de servicio sincrónico y FormRecognizerAsyncClient es el cliente de servicio asincrónico. Los ejemplos que se muestran en este documento usan un objeto de credencial denominado DefaultAzureCredential para la autenticación, que es adecuado para la mayoría de los escenarios, incluidos los entornos de desarrollo y producción locales. Además, se recomienda usar la identidad administrada para la autenticación en entornos de producción. Puede encontrar más información sobre las distintas formas de autenticación y sus tipos de credenciales correspondientes en la documentación de Identidad de Azure".

Ejemplo: Construcción de un formRecognizerClient con DefaultAzureCredential

En el ejemplo de código siguiente se muestra la creación de un FormRecognizerClient, con "DefaultAzureCredentialBuilder" para configurarlo.

 FormRecognizerClient formRecognizerClient = new FormRecognizerClientBuilder()
     .endpoint("{endpoint}")
     .credential(new DefaultAzureCredentialBuilder().build())
     .buildClient();
 

Además, consulte el ejemplo de código siguiente para usarlo AzureKeyCredential para la creación de clientes.

 FormRecognizerClient formRecognizerClient = new FormRecognizerClientBuilder()
     .credential(new AzureKeyCredential("{key}"))
     .endpoint("{endpoint}")
     .buildClient();
 

Echemos un vistazo a los escenarios de cliente de análisis y su uso respectivo a continuación.

Análisis de formularios con modelos precompilados

Form Recognizer modelos y su salida asociada para ayudarle a elegir el mejor modelo para satisfacer las necesidades del escenario del documento.

Puede usar modelos específicos de dominio o entrenar un modelo personalizado adaptado a sus necesidades empresariales y casos de uso específicos.

Ejemplo: Reconocimiento de datos de recibos mediante un origen de dirección URL

En el ejemplo de código siguiente se muestra cómo detectar y extraer datos de recibos mediante el reconocimiento óptico de caracteres (OCR).

 String receiptUrl = "https://raw.githubusercontent.com/Azure/azure-sdk-for-java/main/sdk/formrecognizer"
         + "/azure-ai-formrecognizer/src/samples/resources/sample-forms/receipts/contoso-allinone.jpg";
 SyncPoller<FormRecognizerOperationResult, List<RecognizedForm>> syncPoller =
     formRecognizerClient.beginRecognizeReceiptsFromUrl(receiptUrl);
 List<RecognizedForm> receiptPageResults = syncPoller.getFinalResult();

 for (int i = 0; i < receiptPageResults.size(); i++) {
     RecognizedForm recognizedForm = receiptPageResults.get(i);
     Map<String, FormField> recognizedFields = recognizedForm.getFields();
     System.out.printf("----------- Recognizing receipt info for page %d -----------%n", i);
     FormField merchantNameField = recognizedFields.get("MerchantName");
     if (merchantNameField != null) {
         if (FieldValueType.STRING == merchantNameField.getValue().getValueType()) {
             String merchantName = merchantNameField.getValue().asString();
             System.out.printf("Merchant Name: %s, confidence: %.2f%n",
                 merchantName, merchantNameField.getConfidence());
         }
     }

     FormField merchantPhoneNumberField = recognizedFields.get("MerchantPhoneNumber");
     if (merchantPhoneNumberField != null) {
         if (FieldValueType.PHONE_NUMBER == merchantPhoneNumberField.getValue().getValueType()) {
             String merchantAddress = merchantPhoneNumberField.getValue().asPhoneNumber();
             System.out.printf("Merchant Phone number: %s, confidence: %.2f%n",
                 merchantAddress, merchantPhoneNumberField.getConfidence());
         }
     }

     FormField transactionDateField = recognizedFields.get("TransactionDate");
     if (transactionDateField != null) {
         if (FieldValueType.DATE == transactionDateField.getValue().getValueType()) {
             LocalDate transactionDate = transactionDateField.getValue().asDate();
             System.out.printf("Transaction Date: %s, confidence: %.2f%n",
                 transactionDate, transactionDateField.getConfidence());
         }
     }

     FormField receiptItemsField = recognizedFields.get("Items");
     if (receiptItemsField != null) {
         System.out.printf("Receipt Items: %n");
         if (FieldValueType.LIST == receiptItemsField.getValue().getValueType()) {
             List<FormField> receiptItems = receiptItemsField.getValue().asList();
             receiptItems.stream()
                 .filter(receiptItem -> FieldValueType.MAP == receiptItem.getValue().getValueType())
                 .map(formField -> formField.getValue().asMap())
                 .forEach(formFieldMap -> formFieldMap.forEach((key, formField) -> {
                     if ("Quantity".equals(key)) {
                         if (FieldValueType.FLOAT == formField.getValue().getValueType()) {
                             Float quantity = formField.getValue().asFloat();
                             System.out.printf("Quantity: %f, confidence: %.2f%n",
                                 quantity, formField.getConfidence());
                         }
                     }
                 }));
         }
     }
 }
 

También puede extraer datos de un recibo local con modelos creados previamente mediante el beginRecognizeReceipts método .

Para obtener más información sobre qué modelo compatible debe usar, consulte la documentación de uso de modelos.

Analice un formulario personalizado con un modelo entrenado con o sin etiquetas.

Analice un formulario personalizado con un modelo entrenado con o sin etiquetas. Los modelos personalizados se entrenan con sus propios datos, por lo que se adaptan a los documentos.

Para más información, consulte Entrenamiento de un modelo con etiquetas.

Ejemplo: Análisis de un formulario personalizado con un modelo entrenado con etiquetas

En este ejemplo se muestra cómo reconocer campos de formulario y otro contenido de los formularios personalizados mediante modelos entrenados con sus propios tipos de formulario.

 String trainingFilesUrl = "{SAS_URL_of_your_container_in_blob_storage}";
 boolean useTrainingLabels = true;

 SyncPoller<FormRecognizerOperationResult, CustomFormModel> trainingPoller =
     formTrainingClient.beginTraining(trainingFilesUrl,
         useTrainingLabels,
         new TrainingOptions()
             .setModelName("my model trained with labels"),
         Context.NONE);

 CustomFormModel customFormModel = trainingPoller.getFinalResult();

 // Model Info
 System.out.printf("Model Id: %s%n", customFormModel.getModelId());

 String customFormUrl = "customFormUrl";
 String modelId = customFormModel.getModelId();
 SyncPoller<FormRecognizerOperationResult, List<RecognizedForm>> recognizeFormPoller =
     formRecognizerClient.beginRecognizeCustomFormsFromUrl(modelId, customFormUrl);

 List<RecognizedForm> recognizedForms = recognizeFormPoller.getFinalResult();

 for (int i = 0; i < recognizedForms.size(); i++) {
     RecognizedForm form = recognizedForms.get(i);
     System.out.printf("----------- Recognized custom form info for page %d -----------%n", i);
     System.out.printf("Form type: %s%n", form.getFormType());
     System.out.printf("Form type confidence: %.2f%n", form.getFormTypeConfidence());
     form.getFields().forEach((label, formField) ->
         System.out.printf("Field %s has value %s with confidence score of %f.%n", label,
             formField.getValueData().getText(),
             formField.getConfidence())
     );
 }
 

Para obtener un enfoque sugerido para extraer información de formularios personalizados con campos conocidos, consulte escritura fuerte de un formulario reconocido.