Enterprise Document OCR

Puedes usar Enterprise Document OCR como parte de Document AI para detectar y extraer información de texto y diseño de varios documentos. Con las funciones configurables, puedes adaptar el sistema para que cumpla con requisitos específicos de procesamiento de documentos.

Descripción general

Puedes usar el Enterprise Document OCR para tareas como la entrada de datos basada en algoritmos o aprendizaje automático, y mejorar y verificar la precisión de los datos. También puedes usar Enterprise Document OCR para realizar tareas como las siguientes:

  • Digitalización de texto: Extrae datos de texto y diseño de documentos para la búsqueda, las canalizaciones de procesamiento de documentos basadas en reglas o la creación de modelos personalizados.
  • Uso de aplicaciones de modelos grandes de lenguaje: Usa la comprensión contextual de los LLM y las capacidades de extracción de texto y diseño de la OCR para automatizar las preguntas y respuestas. Obtén estadísticas a partir de los datos y optimiza los flujos de trabajo.
  • Archivado: Digitaliza documentos en papel en texto legible por máquinas para mejorar la accesibilidad de los documentos.

Elige el mejor OCR para tu caso de uso

Solución Producto Descripción Caso práctico
Document AI Enterprise Document OCR Es un modelo especializado para casos de uso de documentos. Las funciones avanzadas incluyen la puntuación de calidad de la imagen, las sugerencias de idioma y la corrección de rotación. Se recomienda cuando se extrae texto de documentos. Los casos de uso incluyen archivos PDF, documentos escaneados como imágenes o archivos DocX de Microsoft.
Document AI Complementos de OCR Funciones premium para requisitos específicos Solo es compatible con la versión 2.0 y posteriores de Enterprise Document OCR. Necesitas detectar y reconocer fórmulas matemáticas, recibir información sobre el estilo de fuente o habilitar la extracción de casillas de verificación.
API de Cloud Vision Detección de textos API de REST disponible a nivel mundial basada en el modelo de OCR estándar de Google Cloud . Cuota predeterminada de 1,800 solicitudes por minuto. Casos de uso generales de extracción de texto que requieren baja latencia y alta capacidad.
Cloud Vision OCR de Google Distributed Cloud (obsoleto) Aplicación de Google Cloud Marketplace que se puede implementar como contenedor en cualquier clúster de GKE con GKE Enterprise. Para cumplir con los requisitos de residencia de datos o cumplimiento.

Detección y extracción

El OCR de documentos empresariales puede detectar bloques, párrafos, líneas, palabras y símbolos de archivos PDF e imágenes, así como corregir la inclinación de los documentos para mejorar la precisión.

Atributos de detección y extracción de diseño admitidos:

Texto impreso Escritura a mano Párrafo Bloquear Line Palabra A nivel del símbolo Número de página
Predeterminado Predeterminado Predeterminado Predeterminado Predeterminado Predeterminado Configurable Predeterminado

Entre las funciones configurables de Enterprise Document OCR, se incluyen las siguientes:

  • Extrae texto incorporado o nativo de archivos PDF digitales: Esta función extrae texto y símbolos exactamente como aparecen en los documentos de origen, incluso para textos rotados, tamaños o estilos de fuente extremos y texto parcialmente oculto.

  • Corrección de rotación: Usa Enterprise Document OCR para procesar previamente las imágenes de documentos y corregir los problemas de rotación que pueden afectar la calidad de la extracción o el procesamiento.

  • Puntuación de calidad de la imagen: Recibe métricas de calidad que pueden ayudarte con el enrutamiento de documentos. El nivel de calidad de la imagen te proporciona métricas de calidad a nivel de la página en ocho dimensiones, incluidas la borrosidad, la presencia de fuentes más pequeñas de lo habitual y el resplandor.

  • Especifica el rango de páginas: Especifica el rango de páginas en un documento de entrada para el OCR. Esto ahorra tiempo de procesamiento y gastos en páginas que no se necesitan.

  • Detección de idioma: Detecta los idiomas que se usan en los textos extraídos.

  • Sugerencias de idioma y escritura a mano: Mejora la precisión proporcionando al modelo de OCR un idioma o una sugerencia de escritura a mano según las características conocidas de tu conjunto de datos.

Para obtener información sobre cómo habilitar las configuraciones de OCR, consulta Habilita las configuraciones de OCR.

Complementos de OCR

Enterprise Document OCR ofrece capacidades de análisis opcionales que se pueden habilitar en solicitudes de procesamiento individuales según sea necesario.

Las siguientes funciones de complementos están disponibles para la versión estable pretrained-ocr-v2.0-2023-06-02 y la versión candidata para lanzamiento pretrained-ocr-v2.1-2024-08-07:

  • OCR matemático: Identifica y extrae fórmulas de documentos en formato LaTeX.
  • Extracción de cuadros de verificación: Detecta cuadros de verificación y extrae su estado (marcados o no marcados) en la respuesta de OCR de documentos empresariales.
  • Detección de estilo de fuente: Identifica las propiedades de fuente a nivel de la palabra, como el tipo de fuente, el estilo de fuente, la escritura a mano, el grosor y el color.

Para obtener información sobre cómo habilitar los complementos enumerados, consulta Habilita los complementos de OCR.

Formatos de archivo compatibles

El OCR de documentos empresariales admite los formatos de archivo PDF, GIF, TIFF, JPEG, PNG, BMP y WebP. Para obtener más información, consulta Archivos compatibles.

Enterprise Document OCR también admite archivos DocX de hasta 15 páginas en sincronización y 30 páginas en modo asíncrono. La compatibilidad con DocX está en versión preliminar privada. Para solicitar acceso, envía el formulario de solicitud de asistencia de DocX .

Control de versiones avanzado

El control de versiones avanzado se encuentra en versión preliminar. Las actualizaciones de los modelos de OCR de IA/AA subyacentes pueden provocar cambios en el comportamiento del OCR. Si se requiere una coherencia estricta, usa una versión de modelo inmovilizada para fijar el comportamiento en un modelo de OCR heredado durante un máximo de 18 meses. Esto garantiza que la misma imagen tenga el mismo resultado de la función de OCR. Consulta la tabla sobre las versiones de procesadores.

Versiones de procesadores

Las siguientes versiones de procesadores son compatibles con esta función. Para obtener más información, consulta Administra versiones de procesadores.

ID de versión Canal de versiones Descripción
pretrained-ocr-v1.0-2020-09-23 Estable No se recomienda su uso y se descontinuará en Estados Unidos (EE.UU.) y la Unión Europea (UE) a partir del 30 de abril de 2025.
pretrained-ocr-v1.1-2022-09-12 Estable No se recomienda su uso y se descontinuará en Estados Unidos (EE.UU.) y la Unión Europea (UE) a partir del 30 de abril de 2025.
pretrained-ocr-v1.2-2022-11-10 Estable Versión del modelo inmovilizada de la v1.0: Archivos de modelos, configuraciones y objetos binarios de una instantánea de versión inmovilizada en una imagen de contenedor durante un máximo de 18 meses.
pretrained-ocr-v2.0-2023-06-02 Estable Modelo listo para producción especializado en casos de uso de documentos. Incluye acceso a todos los complementos de OCR.
pretrained-ocr-v2.1-2024-08-07 Versión candidata Las principales áreas de mejora de la versión 2.1 son: un mejor reconocimiento de texto impreso, una detección más precisa de las casillas de verificación y un orden de lectura más preciso.

Usa Enterprise Document OCR para procesar documentos

En esta guía de inicio rápido, se presenta el OCR de documentos empresariales. Te muestra cómo optimizar los resultados de OCR de documentos para tu flujo de trabajo habilitando o inhabilitando cualquiera de las configuraciones de OCR disponibles.

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Make sure that billing is enabled for your Google Cloud project.

  4. Enable the Document AI API.

    Enable the API

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  6. Make sure that billing is enabled for your Google Cloud project.

  7. Enable the Document AI API.

    Enable the API

Crea un procesador de OCR de documentos empresariales

Primero, crea un procesador de OCR de documentos empresariales. Para obtener más información, consulta Cómo crear y administrar procesadores.

Parámetros de configuración de OCR

Para habilitar todas las configuraciones de OCR, establece los campos correspondientes en ProcessOptions.ocrConfig en ProcessDocumentRequest o BatchProcessDocumentsRequest.

Para obtener más información, consulta Cómo enviar una solicitud de procesamiento.

Análisis de la calidad de la imagen

El análisis inteligente de la calidad de los documentos usa el aprendizaje automático para realizar una evaluación de la calidad de un documento en función de la legibilidad de su contenido. Esta evaluación de la calidad se muestra como un nivel de calidad [0, 1], en el que 1 significa calidad perfecta. Si el nivel de calidad detectado es inferior a 0.5, también se muestra una lista de motivos de calidad negativos (ordenados por probabilidad). Una probabilidad superior a 0.5 se considera una detección positiva.

Si se considera que el documento tiene defectos, la API muestra los siguientes ocho tipos de defectos de documentos:

  • quality/defect_blurry
  • quality/defect_noisy
  • quality/defect_dark
  • quality/defect_faint
  • quality/defect_text_too_small
  • quality/defect_document_cutoff
  • quality/defect_text_cutoff
  • quality/defect_glare

El análisis actual de la calidad de los documentos tiene algunas limitaciones:

  • Puede mostrar detecciones de falsos positivos con documentos digitales sin defectos. La función funciona mejor en documentos escaneados o fotografiados.
  • Los defectos de reflejo son locales. Su presencia podría no dificultar la lectura general del documento.

Entrada

Para habilitarlo, configura ProcessOptions.ocrConfig.enableImageQualityScores como true en la solicitud de procesamiento. Esta función adicional agrega latencia comparable al procesamiento de OCR a la llamada de proceso.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
        "enableImageQualityScores": true
      }
    }
  }

Salida

Los resultados de la detección de defectos aparecen en Document.pages[].imageQualityScores[].

  {
    "pages": [
      {
        "imageQualityScores": {
          "qualityScore": 0.7811847,
          "detectedDefects": [
            {
              "type": "quality/defect_document_cutoff",
              "confidence": 1.0
            },
            {
              "type": "quality/defect_glare",
              "confidence": 0.97849524
            },
            {
              "type": "quality/defect_text_cutoff",
              "confidence": 0.5
            }
          ]
        }
      }
    ]
  }

Consulta Resultado del procesador de muestra para ver ejemplos de resultados completos.

Sugerencias de idioma

El procesador de OCR admite sugerencias de idioma que defines para mejorar el rendimiento del motor de OCR. Aplicar una sugerencia de idioma permite que el OCR se optimice para un idioma seleccionado en lugar de un idioma inferido.

Entrada

Para habilitarlo, configura ProcessOptions.ocrConfig.hints[].languageHints[] con una lista de códigos de idioma BCP-47.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
        "hints": {
          "languageHints": ["en", "es"]
        }
      }
    }
  }

Consulta Resultado del procesador de muestra para ver ejemplos de resultados completos.

Detección de símbolos

Completa los datos a nivel del símbolo (o letra individual) en la respuesta del documento.

Entrada

Para habilitarlo, configura ProcessOptions.ocrConfig.enableSymbol como true en la solicitud de procesamiento.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
        "enableSymbol": true
      }
    }
  }

Salida

Si esta función está habilitada, se propaga el campo Document.pages[].symbols[].

Consulta Resultado del procesador de muestra para ver ejemplos de resultados completos.

Análisis de PDF integrado

Extrae texto incorporado de archivos PDF digitales. Cuando está habilitada, si hay texto digital, se usa automáticamente el modelo de PDF digital integrado. Si hay texto no digital, se usa automáticamente el modelo de OCR óptico. El usuario recibe ambos resultados de texto combinados.

Entrada

Para habilitarlo, configura ProcessOptions.ocrConfig.enableNativePdfParsing como true en la solicitud de procesamiento.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
        "enableNativePdfParsing": true
      }
    }
  }

Detección de caracteres en el cuadro

De forma predeterminada, Enterprise Document OCR tiene habilitado un detector para mejorar la calidad de la extracción de texto de los caracteres que se encuentran dentro de un cuadro. A continuación, se muestra un ejemplo:

enterprise-document-ocr-1

Si tienes problemas de calidad de OCR con caracteres dentro de cuadros, puedes inhabilitarlo.

Entrada

Para inhabilitarlo, establece ProcessOptions.ocrConfig.disableCharacterBoxesDetection en true en la solicitud de procesamiento.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
        "disableCharacterBoxesDetection": true
      }
    }
  }

Diseño heredado

Si necesitas un algoritmo de detección de diseño basado en heurísticas, puedes habilitar el diseño heredado, que funciona como una alternativa al algoritmo de detección de diseño actual basado en el AA. Esta no es la configuración recomendada. Los clientes pueden elegir el algoritmo de diseño más adecuado según su flujo de trabajo de documentos.

Entrada

Para habilitarlo, configura ProcessOptions.ocrConfig.advancedOcrOptions como ["legacy_layout"] en la solicitud de procesamiento.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
          "advancedOcrOptions": ["legacy_layout"]
      }
    }
  }

Especifica un rango de páginas

De forma predeterminada, el OCR extrae información de texto y diseño de todas las páginas de los documentos. Puedes seleccionar números de página o intervalos de páginas específicos y extraer solo el texto de esas páginas.

Existen tres maneras de configurar esto en ProcessOptions:

  • Para procesar solo la segunda y la quinta página, haz lo siguiente:
  {
    "individualPageSelector": {"pages": [2, 5]}
  }
  • Para procesar solo las tres primeras páginas, haz lo siguiente:
  {
    "fromStart": 3
  }
  • Para procesar solo las últimas cuatro páginas, haz lo siguiente:
  {
    "fromEnd": 4
  }

En la respuesta, cada Document.pages[].pageNumber corresponde a las mismas páginas especificadas en la solicitud.

Usos de los complementos de OCR

Estas funciones de análisis opcionales de Enterprise Document OCR se pueden habilitar en solicitudes de procesamiento individuales según sea necesario.

OCR matemático

El OCR matemático detecta, reconoce y extrae fórmulas, como ecuaciones matemáticas representadas como LaTeX junto con las coordenadas del cuadro delimitador.

Este es un ejemplo de representación LaTeX:

  • Se detectó una imagen

    enterprise-document-ocr-2

  • Conversión a LaTeX

    enterprise-document-ocr-3

Entrada

Para habilitarlo, configura ProcessOptions.ocrConfig.premiumFeatures.enableMathOcr como true en la solicitud de procesamiento.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
          "premiumFeatures": {
            "enableMathOcr": true
          }
      }
    }
  }

Salida

El resultado del OCR matemático aparece en Document.pages[].visualElements[] con "type": "math_formula".

"visualElements": [
  {
    "layout": {
      "textAnchor": {
        "textSegments": [
          {
            "endIndex": "46"
          }
        ]
      },
      "confidence": 1,
      "boundingPoly": {
        "normalizedVertices": [
          {
            "x": 0.14662756,
            "y": 0.27891156
          },
          {
            "x": 0.9032258,
            "y": 0.27891156
          },
          {
            "x": 0.9032258,
            "y": 0.8027211
          },
          {
            "x": 0.14662756,
            "y": 0.8027211
          }
        ]
      },
      "orientation": "PAGE_UP"
    },
    "type": "math_formula"
  }
]

Puedes consultar el resultado JSON completo de Document en este vínculo .

Extracción de marcas de selección

Si está habilitada, el modelo intenta extraer todas las casillas de verificación y los botones de selección del documento, junto con las coordenadas del cuadro delimitador.

Entrada

Para habilitarlo, configura ProcessOptions.ocrConfig.premiumFeatures.enableSelectionMarkDetection como true en la solicitud de procesamiento.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
          "premiumFeatures": {
            "enableSelectionMarkDetection": true
          }
      }
    }
  }

Salida

El resultado de la casilla de verificación aparece en Document.pages[].visualElements[] con "type": "unfilled_checkbox" o "type": "filled_checkbox".

"visualElements": [
  {
    "layout": {
      "confidence": 0.89363575,
      "boundingPoly": {
        "vertices": [
          {
            "x": 11,
            "y": 24
          },
          {
            "x": 37,
            "y": 24
          },
          {
            "x": 37,
            "y": 56
          },
          {
            "x": 11,
            "y": 56
          }
        ],
        "normalizedVertices": [
          {
            "x": 0.017488075,
            "y": 0.38709676
          },
          {
            "x": 0.05882353,
            "y": 0.38709676
          },
          {
            "x": 0.05882353,
            "y": 0.9032258
          },
          {
            "x": 0.017488075,
            "y": 0.9032258
          }
        ]
      }
    },
    "type": "unfilled_checkbox"
  },
  {
    "layout": {
      "confidence": 0.9148201,
      "boundingPoly": ...
    },
    "type": "filled_checkbox"
  }
],

Puedes consultar el resultado JSON completo de Document en este vínculo .

Detección de estilo de fuente

Con la detección de estilo de fuente habilitada, Enterprise Document OCR extrae atributos de fuente, que se pueden usar para mejorar el procesamiento posterior.

A nivel del token (palabra), se detectan los siguientes atributos:

  • Detección de escritura a mano
  • Estilo de fuente
  • Tamaño de fuente
  • Tipo de fuente
  • Color de fuente
  • Grosor de la fuente
  • El espacio entre letras
  • Negrita
  • Cursiva
  • Subrayado
  • Color del texto (RGBa)
  • Color de fondo (RGBa)

Entrada

Para habilitarlo, configura ProcessOptions.ocrConfig.premiumFeatures.computeStyleInfo como true en la solicitud de procesamiento.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
          "premiumFeatures": {
            "computeStyleInfo": true
          }
      }
    }
  }

Salida

El resultado del estilo de fuente aparece en Document.pages[].tokens[].styleInfo con el tipo StyleInfo.

"tokens": [
  {
    "styleInfo": {
      "fontSize": 3,
      "pixelFontSize": 13,
      "fontType": "SANS_SERIF",
      "bold": true,
      "fontWeight": 564,
      "textColor": {
        "red": 0.16862746,
        "green": 0.16862746,
        "blue": 0.16862746
      },
      "backgroundColor": {
        "red": 0.98039216,
        "green": 0.9882353,
        "blue": 0.99215686
      }
    }
  },
  ...
]

Puedes consultar el resultado JSON completo de Document en este vínculo .

Convierte objetos de documentos al formato de la API de Vision AI

La caja de herramientas de Document AI incluye una herramienta que convierte el formato Document de la API de Document AI al formato AnnotateFileResponse de Vision AI, lo que permite a los usuarios comparar las respuestas entre el procesador de OCR de documentos y la API de Vision AI. A continuación, se incluye un código de muestra.

Discrepancias conocidas entre la respuesta de la API de Vision AI y la respuesta y el convertidor de la API de Document AI:

  • La respuesta de la API de Vision AI solo propaga vertices para las solicitudes de imágenes y solo normalized_vertices para las solicitudes de PDF. La respuesta de Document AI y el convertidor propagan vertices y normalized_vertices.
  • La respuesta de la API de Vision AI propaga el detected_break en el último símbolo de la palabra. La respuesta de la API de Document AI y el convertidor propagan detected_break en la palabra y el último símbolo de la palabra.
  • La respuesta de la API de Vision AI siempre propaga los campos de símbolos. De forma predeterminada, la respuesta de Document AI no propaga los campos de símbolos. Para asegurarte de que la respuesta de Document AI y el convertidor propaguen los campos de símbolos, configura la función enable_symbol como se detalla.

Muestras de código

En las siguientes muestras de código, se muestra cómo enviar una solicitud de procesamiento que habilita configuraciones y complementos de OCR y, luego, leer e imprimir los campos en la terminal:

REST

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • LOCATION: La ubicación de tu procesador, por ejemplo:
    • us: Estados Unidos
    • eu: Unión Europea
  • PROJECT_ID: El ID de tu proyecto de Google Cloud .
  • PROCESSOR_ID: Es el ID de tu procesador personalizado.
  • PROCESSOR_VERSION: Es el identificador de la versión del procesador. Consulta Cómo seleccionar una versión de procesador para obtener más información. Por ejemplo:
    • pretrained-TYPE-vX.X-YYYY-MM-DD
    • stable
    • rc
  • skipHumanReview: Es un valor booleano para inhabilitar la revisión manual (solo es compatible con los procesadores de interacción humana).
    • true: Omite la revisión humana.
    • false: Habilita la revisión manual (opción predeterminada).
  • MIME_TYPE: Es una de las opciones válidas de tipo de MIME.
  • IMAGE_CONTENT: Es uno de los contenidos de documentos intercalados válidos, representado como un flujo de bytes. Para las representaciones JSON, la codificación en base64 (cadena ASCII) de los datos binarios de la imagen. Esta cadena debería ser similar a la siguiente:
    • /9j/4QAYRXhpZgAA...9tAVx/zDQDlGxn//2Q==
    Visita Codificación en Base64 para obtener más información.
  • FIELD_MASK: Especifica qué campos se deben incluir en el resultado de Document. Esta es una lista separada por comas de los nombres de campos completamente calificados en formato FieldMask.
    • Ejemplo: text,entities,pages.pageNumber
  • Parámetros de configuración de OCR
    • ENABLE_NATIVE_PDF_PARSING: (booleano) Extrae texto incorporado de los archivos PDF, si está disponible.
    • ENABLE_IMAGE_QUALITY_SCORES: (booleano) Habilita las puntuaciones de calidad de documentos inteligentes.
    • ENABLE_SYMBOL: (booleano) Incluye información de OCR de símbolos (letras).
    • DISABLE_CHARACTER_BOXES_DETECTION: (Booleano) Desactiva el detector de cuadros de caracteres en el motor de OCR.
    • LANGUAGE_HINTS: Es la lista de códigos de idioma BCP-47 que se usarán para el OCR.
    • ADVANCED_OCR_OPTIONS: Es una lista de opciones avanzadas de OCR para ajustar mejor su comportamiento. Los valores válidos actuales son los siguientes:
      • legacy_layout: Un algoritmo de detección de diseño heurístico, que sirve como alternativa al algoritmo de detección de diseño actual basado en el AA.
  • Complementos de OCR premium
    • ENABLE_SELECTION_MARK_DETECTION: (Booleano) Activa el detector de marcas de selección en el motor del OCR.
    • COMPUTE_STYLE_INFO (booleano): Activa el modelo de identificación de fuente y devuelve la información del estilo de fuente.
    • ENABLE_MATH_OCR: (Booleano) Activa el modelo que puede extraer fórmulas matemáticas de LaTeX.
  • INDIVIDUAL_PAGES: Es una lista de páginas individuales que se procesarán.
    • Como alternativa, proporciona el campo fromStart o fromEnd para procesar una cantidad específica de páginas desde el principio o el final del documento.

† Este contenido también se puede especificar con contenido codificado en base64 en el objeto inlineDocument.

Método HTTP y URL:

POST https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION:process

Cuerpo JSON de la solicitud:

{
  "skipHumanReview": skipHumanReview,
  "rawDocument": {
    "mimeType": "MIME_TYPE",
    "content": "IMAGE_CONTENT"
  },
  "fieldMask": "FIELD_MASK",
  "processOptions": {
    "ocrConfig": {
      "enableNativePdfParsing": ENABLE_NATIVE_PDF_PARSING,
      "enableImageQualityScores": ENABLE_IMAGE_QUALITY_SCORES,
      "enableSymbol": ENABLE_SYMBOL,
      "disableCharacterBoxesDetection": DISABLE_CHARACTER_BOXES_DETECTION,
      "hints": {
        "languageHints": [
          "LANGUAGE_HINTS"
        ]
      },
      "advancedOcrOptions": ["ADVANCED_OCR_OPTIONS"],
      "premiumFeatures": {
        "enableSelectionMarkDetection": ENABLE_SELECTION_MARK_DETECTION,
        "computeStyleInfo": COMPUTE_STYLE_INFO,
        "enableMathOcr": ENABLE_MATH_OCR,
      }
    },
    "individualPageSelector" {
      "pages": [INDIVIDUAL_PAGES]
    }
  }
}

Para enviar tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
"https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION:process"

PowerShell

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method POST `
-Headers $headers `
-ContentType: "application/json; charset=utf-8" `
-InFile request.json `
-Uri "https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION:process" | Select-Object -Expand Content

Si la solicitud se completa de forma correcta, el servidor muestra un código de estado HTTP 200 OK y la respuesta en formato JSON. El cuerpo de la respuesta contiene una instancia de Document.

Python

Para obtener más información, consulta la documentación de referencia de la API de Document AI Python.

Para autenticarte en Document AI, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.


from typing import Optional, Sequence

from google.api_core.client_options import ClientOptions
from google.cloud import documentai

# TODO(developer): Uncomment these variables before running the sample.
# project_id = "YOUR_PROJECT_ID"
# location = "YOUR_PROCESSOR_LOCATION" # Format is "us" or "eu"
# processor_id = "YOUR_PROCESSOR_ID" # Create processor before running sample
# processor_version = "rc" # Refer to https://cloud.google.com/document-ai/docs/manage-processor-versions for more information
# file_path = "/path/to/local/pdf"
# mime_type = "application/pdf" # Refer to https://cloud.google.com/document-ai/docs/file-types for supported file types


def process_document_ocr_sample(
    project_id: str,
    location: str,
    processor_id: str,
    processor_version: str,
    file_path: str,
    mime_type: str,
) -> None:
    # Optional: Additional configurations for Document OCR Processor.
    # For more information: https://cloud.google.com/document-ai/docs/enterprise-document-ocr
    process_options = documentai.ProcessOptions(
        ocr_config=documentai.OcrConfig(
            enable_native_pdf_parsing=True,
            enable_image_quality_scores=True,
            enable_symbol=True,
            # OCR Add Ons https://cloud.google.com/document-ai/docs/ocr-add-ons
            premium_features=documentai.OcrConfig.PremiumFeatures(
                compute_style_info=True,
                enable_math_ocr=False,  # Enable to use Math OCR Model
                enable_selection_mark_detection=True,
            ),
        )
    )
    # Online processing request to Document AI
    document = process_document(
        project_id,
        location,
        processor_id,
        processor_version,
        file_path,
        mime_type,
        process_options=process_options,
    )

    text = document.text
    print(f"Full document text: {text}\n")
    print(f"There are {len(document.pages)} page(s) in this document.\n")

    for page in document.pages:
        print(f"Page {page.page_number}:")
        print_page_dimensions(page.dimension)
        print_detected_languages(page.detected_languages)

        print_blocks(page.blocks, text)
        print_paragraphs(page.paragraphs, text)
        print_lines(page.lines, text)
        print_tokens(page.tokens, text)

        if page.symbols:
            print_symbols(page.symbols, text)

        if page.image_quality_scores:
            print_image_quality_scores(page.image_quality_scores)

        if page.visual_elements:
            print_visual_elements(page.visual_elements, text)


def print_page_dimensions(dimension: documentai.Document.Page.Dimension) -> None:
    print(f"    Width: {str(dimension.width)}")
    print(f"    Height: {str(dimension.height)}")


def print_detected_languages(
    detected_languages: Sequence[documentai.Document.Page.DetectedLanguage],
) -> None:
    print("    Detected languages:")
    for lang in detected_languages:
        print(f"        {lang.language_code} ({lang.confidence:.1%} confidence)")


def print_blocks(blocks: Sequence[documentai.Document.Page.Block], text: str) -> None:
    print(f"    {len(blocks)} blocks detected:")
    first_block_text = layout_to_text(blocks[0].layout, text)
    print(f"        First text block: {repr(first_block_text)}")
    last_block_text = layout_to_text(blocks[-1].layout, text)
    print(f"        Last text block: {repr(last_block_text)}")


def print_paragraphs(
    paragraphs: Sequence[documentai.Document.Page.Paragraph], text: str
) -> None:
    print(f"    {len(paragraphs)} paragraphs detected:")
    first_paragraph_text = layout_to_text(paragraphs[0].layout, text)
    print(f"        First paragraph text: {repr(first_paragraph_text)}")
    last_paragraph_text = layout_to_text(paragraphs[-1].layout, text)
    print(f"        Last paragraph text: {repr(last_paragraph_text)}")


def print_lines(lines: Sequence[documentai.Document.Page.Line], text: str) -> None:
    print(f"    {len(lines)} lines detected:")
    first_line_text = layout_to_text(lines[0].layout, text)
    print(f"        First line text: {repr(first_line_text)}")
    last_line_text = layout_to_text(lines[-1].layout, text)
    print(f"        Last line text: {repr(last_line_text)}")


def print_tokens(tokens: Sequence[documentai.Document.Page.Token], text: str) -> None:
    print(f"    {len(tokens)} tokens detected:")
    first_token_text = layout_to_text(tokens[0].layout, text)
    first_token_break_type = tokens[0].detected_break.type_.name
    print(f"        First token text: {repr(first_token_text)}")
    print(f"        First token break type: {repr(first_token_break_type)}")
    if tokens[0].style_info:
        print_style_info(tokens[0].style_info)

    last_token_text = layout_to_text(tokens[-1].layout, text)
    last_token_break_type = tokens[-1].detected_break.type_.name
    print(f"        Last token text: {repr(last_token_text)}")
    print(f"        Last token break type: {repr(last_token_break_type)}")
    if tokens[-1].style_info:
        print_style_info(tokens[-1].style_info)


def print_symbols(
    symbols: Sequence[documentai.Document.Page.Symbol], text: str
) -> None:
    print(f"    {len(symbols)} symbols detected:")
    first_symbol_text = layout_to_text(symbols[0].layout, text)
    print(f"        First symbol text: {repr(first_symbol_text)}")
    last_symbol_text = layout_to_text(symbols[-1].layout, text)
    print(f"        Last symbol text: {repr(last_symbol_text)}")


def print_image_quality_scores(
    image_quality_scores: documentai.Document.Page.ImageQualityScores,
) -> None:
    print(f"    Quality score: {image_quality_scores.quality_score:.1%}")
    print("    Detected defects:")

    for detected_defect in image_quality_scores.detected_defects:
        print(f"        {detected_defect.type_}: {detected_defect.confidence:.1%}")


def print_style_info(style_info: documentai.Document.Page.Token.StyleInfo) -> None:
    """
    Only supported in version `pretrained-ocr-v2.0-2023-06-02`
    """
    print(f"           Font Size: {style_info.font_size}pt")
    print(f"           Font Type: {style_info.font_type}")
    print(f"           Bold: {style_info.bold}")
    print(f"           Italic: {style_info.italic}")
    print(f"           Underlined: {style_info.underlined}")
    print(f"           Handwritten: {style_info.handwritten}")
    print(
        f"           Text Color (RGBa): {style_info.text_color.red}, {style_info.text_color.green}, {style_info.text_color.blue}, {style_info.text_color.alpha}"
    )


def print_visual_elements(
    visual_elements: Sequence[documentai.Document.Page.VisualElement], text: str
) -> None:
    """
    Only supported in version `pretrained-ocr-v2.0-2023-06-02`
    """
    checkboxes = [x for x in visual_elements if "checkbox" in x.type]
    math_symbols = [x for x in visual_elements if x.type == "math_formula"]

    if checkboxes:
        print(f"    {len(checkboxes)} checkboxes detected:")
        print(f"        First checkbox: {repr(checkboxes[0].type)}")
        print(f"        Last checkbox: {repr(checkboxes[-1].type)}")

    if math_symbols:
        print(f"    {len(math_symbols)} math symbols detected:")
        first_math_symbol_text = layout_to_text(math_symbols[0].layout, text)
        print(f"        First math symbol: {repr(first_math_symbol_text)}")




def process_document(
    project_id: str,
    location: str,
    processor_id: str,
    processor_version: str,
    file_path: str,
    mime_type: str,
    process_options: Optional[documentai.ProcessOptions] = None,
) -> documentai.Document:
    # You must set the `api_endpoint` if you use a location other than "us".
    client = documentai.DocumentProcessorServiceClient(
        client_options=ClientOptions(
            api_endpoint=f"{location}-documentai.googleapis.com"
        )
    )

    # The full resource name of the processor version, e.g.:
    # `projects/{project_id}/locations/{location}/processors/{processor_id}/processorVersions/{processor_version_id}`
    # You must create a processor before running this sample.
    name = client.processor_version_path(
        project_id, location, processor_id, processor_version
    )

    # Read the file into memory
    with open(file_path, "rb") as image:
        image_content = image.read()

    # Configure the process request
    request = documentai.ProcessRequest(
        name=name,
        raw_document=documentai.RawDocument(content=image_content, mime_type=mime_type),
        # Only supported for Document OCR processor
        process_options=process_options,
    )

    result = client.process_document(request=request)

    # For a full list of `Document` object attributes, reference this page:
    # https://cloud.google.com/document-ai/docs/reference/rest/v1/Document
    return result.document




def layout_to_text(layout: documentai.Document.Page.Layout, text: str) -> str:
    """
    Document AI identifies text in different parts of the document by their
    offsets in the entirety of the document"s text. This function converts
    offsets to a string.
    """
    # If a text segment spans several lines, it will
    # be stored in different text segments.
    return "".join(
        text[int(segment.start_index) : int(segment.end_index)]
        for segment in layout.text_anchor.text_segments
    )

¿Qué sigue?