Enterprise Document OCR

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

Descripción general

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

• Digitalización de texto: Extrae texto y datos de 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 de lenguaje grandes: Usa la comprensión contextual de los LLM y las capacidades de extracción de texto y diseño del OCR para automatizar 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áquina para mejorar la accesibilidad a los documentos.

Cómo elegir el mejor OCR para tu caso de uso

Detección y extracción

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

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

Las funciones configurables del OCR empresarial de documentos incluyen lo siguiente:

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

• Corrección de rotación: Usa el OCR empresarial de documentos para preprocesar imágenes de documentos y corregir 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 ayudar con el enrutamiento de documentos. La puntuación de calidad de la imagen te proporciona métricas de calidad a nivel de la página en ocho dimensiones, incluidas la falta de nitidez, la presencia de fuentes más pequeñas de lo habitual y el deslumbramiento.

• Especificar rango de páginas: Especifica el rango de páginas de un documento de entrada para el OCR. Esto ahorra tiempo de procesamiento y de inversión en páginas innecesarias.

• Detección de idiomas: 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 una sugerencia de idioma o escritura a mano según las características conocidas de tu conjunto de datos.

Para obtener información sobre cómo habilitar la configuración del OCR, consulta Cómo habilitar la configuración del 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 capacidades de complementos están disponibles para las versiones estable pretrained-ocr-v2.0-2023-06-02 y pretrained-ocr-v2.1-2024-08-07, y la versión candidata a lanzamiento pretrained-ocr-v2.1.1-2025-01-31.

• OCR de ecuaciones: Identifica y extrae fórmulas de documentos en formato LaTeX.
• Extracción de casillas de verificación: Detecta casillas de verificación y extrae su estado (marcado o sin marcar) en la respuesta de Enterprise Document OCR.
• Detección de estilo de fuente: Identifica las propiedades de la fuente a nivel de la palabra, incluidos el tipo, el estilo, la escritura a mano, el grosor y el color.

Para obtener información sobre cómo habilitar los complementos mencionados, 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.

El OCR empresarial de documentos también admite archivos DocX de hasta 15 páginas de forma síncrona y 30 páginas de forma asíncrona. 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 Vista previa. Las actualizaciones de los modelos subyacentes de OCR basados en IA o AA pueden generar cambios en el comportamiento del OCR. Si se requiere coherencia estricta, usa una versión del modelo inmovilizada para fijar el comportamiento en un modelo de OCR heredado durante un máximo de 18 meses. Esto garantiza el mismo resultado de la función de OCR de imágenes. Consulta la tabla sobre las versiones del procesador.

Versiones del procesador

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

Usa Enterprise Document OCR para procesar documentos

En esta guía de inicio rápido, se presenta el OCR de documentos empresariales. En él, se muestra cómo optimizar los resultados del OCR de documentos para tu flujo de trabajo habilitando o inhabilitando cualquiera de los parámetros de configuración de OCR disponibles.

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.

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

Go to project selector

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

Enable the Document AI API.

Enable the API

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

Go to project selector

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

Enable the Document AI API.

Enable the API

Crea un procesador de Enterprise Document OCR

Primero, crea un procesador de Enterprise Document OCR. Para obtener más información, consulta Crea y administra procesadores.

Configuraciones de OCR

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

Para obtener más información, consulta Envía una solicitud de procesamiento.

Análisis de la calidad de la imagen

El análisis inteligente de la calidad del documento usa el aprendizaje automático para evaluar la calidad de un documento según la legibilidad de su contenido. Esta evaluación de calidad se devuelve 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 devuelve una lista de motivos de calidad negativos (ordenados por probabilidad). Una probabilidad mayor que 0.5 se considera una detección positiva.

Si se considera que el documento es defectuoso, la API devuelve los siguientes ocho tipos de defectos:

• 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 de calidad del documento actual tiene algunas limitaciones:

• Puede devolver detecciones de falsos positivos con documentos digitales sin defectos. Esta función se usa mejor en documentos escaneados o fotografiados.

• Los defectos de reflejo son locales. Su presencia podría no dificultar la legibilidad general del documento.

Entrada

Para habilitar esta opción, configura ProcessOptions.ocrConfig.enableImageQualityScores como true en la solicitud de procesamiento. Esta función adicional agrega latencia a la llamada de proceso comparable con el procesamiento de OCR.

  {
    "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 completos de resultados.

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 habilitar esta opción, establece 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 completos de resultados.

Detección de símbolos

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

Entrada

Para habilitar esta opción, 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 propagará el campo Document.pages[].symbols[].

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

Análisis de PDF integrado

Extrae el texto incorporado de los archivos PDF digitales. Cuando está habilitado, 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 habilitar esta opción, 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 personajes en el recuadro

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:



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

Entrada

Para inhabilitar esta opción, 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 alternativa al algoritmo de detección de diseño actual basado en AA. Esta no es la configuración recomendada. Los clientes pueden elegir el algoritmo de diseño más adecuado según el flujo de trabajo de sus documentos.

Entrada

Para habilitar esta opción, configura ProcessOptions.ocrConfig.advancedOcrOptions como ["legacy_layout"] en la solicitud de procesamiento.

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

Cómo especificar 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 o rangos de páginas específicos y extraer texto solo de esas páginas.

Existen tres formas 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 primeras tres 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.

A continuación, se muestra un ejemplo de representación en LaTeX:

• Se detectó una imagen

  

• Conversión a LaTeX

  

Entrada

Para habilitar esta opción, 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 de ecuaciones 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á habilitado, el modelo intenta extraer todas las casillas de verificación y los botones de opción del documento, junto con las coordenadas del cuadro delimitador.

Entrada

Para habilitar esta opción, 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 del estilo de fuente

Con la detección de estilo de fuente habilitada, el OCR empresarial de documentos extrae atributos de fuente, que se pueden usar para un mejor 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 habilitar esta opción, 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 de font-style 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 la API 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. Aquí tienes 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 completa vertices para las solicitudes de imágenes y solo completa normalized_vertices para las solicitudes de PDF. La respuesta de Document AI y el convertidor completan 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 completa 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 completen 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 habilite los complementos y la configuración del 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 Selecciona una versión del 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 con interacción humana).
  • true: Se omite la revisión humana.
  • false: Habilita la revisión manual (configuración predeterminada).
• MIME_TYPE^†: Una de las opciones de tipo de MIME válidas.
• IMAGE_CONTENT^†: Uno de los contenidos de documentos intercalados válidos, representado como un flujo de bytes. Para las representaciones JSON, es la codificación en base64 (cadena ASCII) de los datos de la imagen binaria. Esta cadena debería ser similar a la siguiente:
  • /9j/4QAYRXhpZgAA...9tAVx/zDQDlGxn//2Q==
  Visita el tema 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
• Configuraciones de OCR
  • ENABLE_NATIVE_PDF_PARSING: (Booleano) Extrae el texto incorporado de los PDFs, 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 del OCR.
  • LANGUAGE_HINTS: Es una 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 aún más el comportamiento del OCR. Los valores válidos actuales son los siguientes:
    • legacy_layout: Es un algoritmo de detección de diseño basado en heurísticas que sirve como alternativa al algoritmo de detección de diseño basado en AA actual.
• 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 para procesar.
  • 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?

• Revisa la lista de procesadores.
• Separa documentos en fragmentos legibles con el analizador de diseño.
• Crea un clasificador personalizado.