Organiza tus páginas con colecciones
Guarda y categoriza el contenido según tus preferencias.
BigQuery se integra con Document AI para ayudar a crear análisis de documentos y casos de uso de IA generativa. A medida que se acelera la transformación digital, las organizaciones generan grandes cantidades de texto y otros datos de documentos, todos los cuales tienen un inmenso potencial para obtener estadísticas y potenciar casos de uso novedosos de IA generativa. Para aprovechar estos datos, nos complace anunciar una integración entre BigQuery y Document AI, que te permite extraer estadísticas a partir de los datos de documentos y compilar nuevas aplicaciones de modelos de lenguaje grande (LLM).
Descripción general
Los clientes de BigQuery ahora pueden crear extractores personalizados de Document AI, potenciados por los modelos de base de vanguardia de Google, que pueden personalizar en función de sus propios documentos y metadatos. Luego, estos modelos personalizados se pueden invocar desde BigQuery para extraer datos estructurados de documentos de manera segura y controlada, con la simplicidad y la potencia de SQL.
Antes de esta integración, algunos clientes intentaron crear canalizaciones independientes de Document AI, lo que implicaba seleccionar manualmente la lógica y el esquema de extracción. La falta de capacidades de integración integradas los obligó a desarrollar una infraestructura personalizada para sincronizar y mantener la coherencia de los datos. Esto convirtió cada proyecto de análisis de documentos en una tarea sustancial que requirió una inversión significativa.
Ahora, con esta integración, los clientes pueden crear modelos remotos en BigQuery para sus extractores personalizados en Document AI y usarlos para realizar análisis de documentos y aprovechar la IA generativa a gran escala, lo que marca el comienzo de una nueva era de estadísticas basadas en datos y de innovación.
Una experiencia unificada y administrada de datos a IA
Puedes crear un extractor personalizado en Document AI en tres pasos:
Define los datos que necesitas extraer de tus documentos. Se llama document schema y se almacena con cada versión del extractor personalizado, al que se puede acceder desde BigQuery.
De manera opcional, proporciona documentos adicionales con anotaciones como muestras de la extracción.
Entrena el modelo para el extractor personalizado, según los modelos de base proporcionados en Document AI.
Además de los extractores personalizados que requieren entrenamiento manual, Document AI también proporciona extractores listos para usar para gastos, recibos, facturas, formularios fiscales, documentos de identidad gubernamentales y una multitud de otros casos de uso en la galería de procesadores.
Luego, una vez que tengas listo el extractor personalizado, puedes pasar a BigQuery Studio para analizar los documentos con SQL en los siguientes cuatro pasos:
Registra un modelo remoto de BigQuery para el extractor con SQL. El modelo puede comprender el esquema del documento (creado anteriormente), invocar el extractor personalizado y analizar los resultados.
Crea tablas de objetos con SQL para los documentos almacenados en Cloud Storage. Puedes controlar los datos no estructurados en las tablas configurando políticas de acceso a nivel de la fila, lo que limita el acceso de los usuarios a ciertos documentos y, por lo tanto, restringe la potencia de la IA para la privacidad y la seguridad.
Usa la función ML.PROCESS_DOCUMENT en la tabla de objetos para extraer los campos relevantes realizando llamadas de inferencia al extremo de API. También puedes filtrar los documentos para las extracciones con una cláusula WHERE fuera de la función.
La función devuelve una tabla estructurada, en la que cada columna es un campo extraído.
Une los datos extraídos con otras tablas de BigQuery para combinar datos estructurados y no estructurados, lo que generará valores comerciales.
En el siguiente ejemplo, se ilustra la experiencia del usuario:
# Create an object table in BigQuery that maps to the document files stored in Cloud Storage.CREATEORREPLACEEXTERNALTABLE`my_dataset.document`WITHCONNECTION`my_project.us.example_connection`OPTIONS(object_metadata='SIMPLE',uris=['gs://my_bucket/path/*'],metadata_cache_mode='AUTOMATIC',max_staleness=INTERVAL1HOUR);# Create a remote model to register your Doc AI processor in BigQuery.CREATEORREPLACEMODEL`my_dataset.layout_parser`REMOTEWITHCONNECTION`my_project.us.example_connection`OPTIONS(remote_service_type='CLOUD_AI_DOCUMENT_V1',document_processor='PROCESSOR_ID');# Invoke the registered model over the object table to parse PDF documentSELECTuri,total_amount,invoice_dateFROMML.PROCESS_DOCUMENT(MODEL`my_dataset.layout_parser`,TABLE`my_dataset.document`,PROCESS_OPTIONS=> (JSON'{"layout_config": {"chunking_config": {"chunk_size": 250}}}'))WHEREcontent_type='application/pdf';
Tabla de resultados
Casos de uso de análisis de texto, resumen y otros análisis de documentos
Una vez que hayas extraído el texto de tus documentos, podrás realizar análisis de documentos de las siguientes maneras:
Usa BigQuery ML para realizar análisis de texto: BigQuery ML admite el entrenamiento y la implementación de modelos de incorporación de varias maneras. Por ejemplo, puedes usar BigQuery ML para identificar la opinión de los clientes en las llamadas de asistencia o para clasificar los comentarios sobre los productos en diferentes categorías. Si eres usuario de Python, también puedes usar BigQuery DataFrames para Pandas y APIs similares a scikit-learn para el análisis de texto en tus datos.
Usa el LLM text-embedding-004 para generar embeddings a partir de los documentos divididos en fragmentos:
BigQuery tiene una función ML.GENERATE_EMBEDDING que llama al modelo text-embedding-004 para generar embeddings. Por ejemplo, puedes usar Document AI para extraer comentarios de los clientes y resumirlos con PaLM 2, todo con SQL de BigQuery.
Une los metadatos del documento con otros datos estructurados almacenados en tablas de BigQuery:
Por ejemplo, puedes generar embeddings con los documentos fragmentados y usarlos para la búsqueda de vectores.
# Example 1: Parse the chunked dataCREATEORREPLACETABLEdocai_demo.demo_result_parsedAS(SELECTuri,JSON_EXTRACT_SCALAR(json,'$.chunkId')ASid,JSON_EXTRACT_SCALAR(json,'$.content')AScontent,JSON_EXTRACT_SCALAR(json,'$.pageFooters[0].text')ASpage_footers_text,JSON_EXTRACT_SCALAR(json,'$.pageSpan.pageStart')ASpage_span_start,JSON_EXTRACT_SCALAR(json,'$.pageSpan.pageEnd')ASpage_span_endFROMdocai_demo.demo_result,UNNEST(JSON_EXTRACT_ARRAY(ml_process_document_result.chunkedDocument.chunks,'$'))json)# Example 2: Generate embeddingCREATEORREPLACETABLE`docai_demo.embeddings`ASSELECT*FROMML.GENERATE_EMBEDDING(MODEL`docai_demo.embedding_model`,TABLE`docai_demo.demo_result_parsed`);
Implementa casos de uso de la búsqueda y la IA generativa
Una vez que hayas extraído el texto estructurado de tus documentos, puedes crear índices optimizados para las búsquedas de aguja en un pajar, lo que es posible gracias a las capacidades de búsqueda y de indexación de BigQuery, que desbloquean una potente capacidad de búsqueda.
Esta integración también ayuda a desbloquear nuevas aplicaciones de LLM generativos, como la ejecución del procesamiento de archivos de texto para el filtrado de privacidad, las verificaciones de seguridad del contenido y la división en fragmentos de tokens con SQL y modelos personalizados de Document AI. El texto extraído, combinado con otros metadatos, simplifica la selección del corpus de entrenamiento necesario para ajustar los modelos de lenguaje grandes. Además, compilas casos de uso de LLM sobre datos empresariales gobernados que se fundamentan a través de las capacidades de generación de embeddings y administración de índices vectoriales de BigQuery. Si sincronizas este índice con Vertex AI, puedes implementar casos de uso de generación mejorada por recuperación para obtener una experiencia de IA más controlada y optimizada.
Aplicación de ejemplo
Para obtener un ejemplo de una aplicación de extremo a extremo con el conector de Document AI:
Consulta esta demostración del informe de gastos en GitHub.
[[["Fácil de comprender","easyToUnderstand","thumb-up"],["Resolvió mi problema","solvedMyProblem","thumb-up"],["Otro","otherUp","thumb-up"]],[["Difícil de entender","hardToUnderstand","thumb-down"],["Información o código de muestra incorrectos","incorrectInformationOrSampleCode","thumb-down"],["Faltan la información o los ejemplos que necesito","missingTheInformationSamplesINeed","thumb-down"],["Problema de traducción","translationIssue","thumb-down"],["Otro","otherDown","thumb-down"]],["Última actualización: 2025-09-04 (UTC)"],[[["\u003cp\u003eBigQuery now integrates with Document AI, enabling users to extract insights from document data and create new large language model (LLM) applications.\u003c/p\u003e\n"],["\u003cp\u003eCustomers can create custom extractors in Document AI, powered by Google's foundation models, and then invoke these models from BigQuery to extract structured data using SQL.\u003c/p\u003e\n"],["\u003cp\u003eThis integration simplifies document analytics projects by eliminating the need for manually building extraction logic and schemas, thus reducing the investment needed.\u003c/p\u003e\n"],["\u003cp\u003eBigQuery's \u003ccode\u003eML.PROCESS_DOCUMENT\u003c/code\u003e function, along with remote models, object tables, and SQL, facilitates the extraction of relevant fields from documents and the combination of this data with other structured data.\u003c/p\u003e\n"],["\u003cp\u003ePost-extraction, BigQuery ML and the \u003ccode\u003etext-embedding-004\u003c/code\u003e model can be leveraged for text analytics, generating embeddings, and building indexes for advanced search and generative AI applications.\u003c/p\u003e\n"]]],[],null,["# BigQuery integration\n====================\n\nBigQuery integrates with Document AI to help build document analytics and generative AI\nuse cases. As digital transformation accelerates, organizations are generating vast\namounts of text and other document data, all of which holds immense potential for\ninsights and powering novel generative AI use cases. To help harness this data,\nwe're excited to announce an integration between [BigQuery](/bigquery)\nand [Document AI](/document-ai), letting you extract insights from document data and build\nnew large language model (LLM) applications.\n\nOverview\n--------\n\nBigQuery customers can now create Document AI [custom extractors](/blog/products/ai-machine-learning/document-ai-workbench-custom-extractor-and-summarizer), powered by Google's\ncutting-edge foundation models, which they can customize based on their own documents\nand metadata. These customized models can then be invoked from BigQuery to\nextract structured data from documents in a secure, governed manner, using the\nsimplicity and power of SQL.\nPrior to this integration, some customers tried to construct independent Document AI\npipelines, which involved manually curating extraction logic and schema. The\nlack of built-in integration capabilities left them to develop bespoke infrastructure\nto synchronize and maintain data consistency. This turned each document analytics\nproject into a substantial undertaking that required significant investment.\nNow, with this integration, customers can create remote models in BigQuery\nfor their custom extractors in Document AI, and use them to perform document analytics\nand generative AI at scale, unlocking a new era of data-driven insights and innovation.\n\nA unified, governed data to AI experience\n-----------------------------------------\n\nYou can build a custom extractor in the Document AI with three steps:\n\n1. Define the data you need to extract from your documents. This is called `document schema`, stored with each version of the custom extractor, accessible from BigQuery.\n2. Optionally, provide extra documents with annotations as samples of the extraction.\n3. Train the model for the custom extractor, based on the foundation models provided in Document AI.\n\nIn addition to custom extractors that require manual training, Document AI also\nprovides ready to use extractors for expenses, receipts, invoices, tax forms,\ngovernment ids, and a multitude of other scenarios, in the processor gallery.\n\nThen, once you have the custom extractor ready, you can move to BigQuery Studio\nto analyze the documents using SQL in the following four steps:\n\n1. Register a BigQuery remote model for the extractor using SQL. The model can understand the document schema (created above), invoke the custom extractor, and parse the results.\n2. Create object tables using SQL for the documents stored in Cloud Storage. You can govern the unstructured data in the tables by setting row-level access policies, which limits users' access to certain documents and thus restricts the AI power for privacy and security.\n3. Use the function `ML.PROCESS_DOCUMENT` on the object table to extract relevant fields by making inference calls to the API endpoint. You can also filter out the documents for the extractions with a `WHERE` clause outside of the function. The function returns a structured table, with each column being an extracted field.\n4. Join the extracted data with other BigQuery tables to combine structured and unstructured data, producing business values.\n\nThe following example illustrates the user experience:\n\n # Create an object table in BigQuery that maps to the document files stored in Cloud Storage.\n CREATE OR REPLACE EXTERNAL TABLE `my_dataset.document`\n WITH CONNECTION `my_project.us.example_connection`\n OPTIONS (\n object_metadata = 'SIMPLE',\n uris = ['gs://my_bucket/path/*'],\n metadata_cache_mode= 'AUTOMATIC',\n max_staleness= INTERVAL 1 HOUR\n );\n\n # Create a remote model to register your Doc AI processor in BigQuery.\n CREATE OR REPLACE MODEL `my_dataset.layout_parser`\n REMOTE WITH CONNECTION `my_project.us.example_connection`\n OPTIONS (\n remote_service_type = 'CLOUD_AI_DOCUMENT_V1', \n document_processor='\u003cvar translate=\"no\"\u003ePROCESSOR_ID\u003c/var\u003e'\n );\n\n # Invoke the registered model over the object table to parse PDF document\n SELECT uri, total_amount, invoice_date\n FROM ML.PROCESS_DOCUMENT(\n MODEL `my_dataset.layout_parser`,\n TABLE `my_dataset.document`,\n PROCESS_OPTIONS =\u003e (\n JSON '{\"layout_config\": {\"chunking_config\": {\"chunk_size\": 250}}}')\n )\n WHERE content_type = 'application/pdf';\n\nTable of results\n\nText analytics, summarization and other document analysis use cases\n-------------------------------------------------------------------\n\nOnce you have extracted text from your documents, you can then perform document\nanalytics in a few ways:\n\n- Use BigQuery ML to perform text-analytics: BigQuery ML supports training and deploying embedding models in a variety of ways. For example, you can use BigQuery ML to identify customer sentiment in support calls, or to classify product feedback into different categories. If you are a Python user, you can also use BigQuery DataFrames for pandas, and scikit-learn-like APIs for text analysis on your data.\n- Use `text-embedding-004` LLM to generate embeddings from the chunked documents: BigQuery has a `ML.GENERATE_EMBEDDING` function that calls the `text-embedding-004` model to generate embeddings. For example, you can use a Document AI to extract customer feedback and summarize the feedback using PaLM 2, all with BigQuery SQL.\n- Join document metadata with other structured data stored in BigQuery tables:\n\nFor example, you can generate embeddings using the chunked documents and use it for vector search. \n\n # Example 1: Parse the chunked data\n\n CREATE OR REPLACE TABLE docai_demo.demo_result_parsed AS (SELECT\n uri,\n JSON_EXTRACT_SCALAR(json , '$.chunkId') AS id,\n JSON_EXTRACT_SCALAR(json , '$.content') AS content,\n JSON_EXTRACT_SCALAR(json , '$.pageFooters[0].text') AS page_footers_text,\n JSON_EXTRACT_SCALAR(json , '$.pageSpan.pageStart') AS page_span_start,\n JSON_EXTRACT_SCALAR(json , '$.pageSpan.pageEnd') AS page_span_end\n FROM docai_demo.demo_result, UNNEST(JSON_EXTRACT_ARRAY(ml_process_document_result.chunkedDocument.chunks, '$')) json)\n\n # Example 2: Generate embedding\n\n CREATE OR REPLACE TABLE `docai_demo.embeddings` AS\n SELECT * FROM ML.GENERATE_EMBEDDING(\n MODEL `docai_demo.embedding_model`,\n TABLE `docai_demo.demo_result_parsed`\n );\n\nImplement search and generative AI use cases\n--------------------------------------------\n\nOnce you've extracted structured text from your documents, you can build indexes\noptimized for needle in the haystack queries, made possible by BigQuery's search\nand indexing capabilities, unlocking powerful search capability.\nThis integration also helps unlock new generative LLM applications like executing\ntext-file processing for privacy filtering, content safety checks, and token chunking\nusing SQL and custom Document AI models. The extracted text, combined with other metadata,\nsimplifies the curation of the training corpus required to fine-tune large language\nmodels. Moreover, you're building LLM use cases on governed, enterprise data\nthat's been grounded through BigQuery's embedding generation and vector index\nmanagement capabilities. By synchronizing this index with Vertex AI, you can\nimplement retrieval-augmented generation use cases, for a more governed and\nstreamlined AI experience.\n\nSample application\n------------------\n\nFor an example of an end-to-end application using the Document AI Connector:\n\n- Refer to this expense report demo on [GitHub](https://github.com/GoogleCloudPlatform/smart-expenses).\n- Read the companion [blog post](/blog/topics/developers-practitioners/smarter-applications-document-ai-workflows-and-cloud-functions).\n- Watch a deep dive [video](https://www.youtube.com/watch?v=Bnac6JnBGQg&t=1s) from Google Cloud Next 2021."]]