Generación autónoma de embeddings

En este documento, se describe cómo usar la generación autónoma de embeddings para tus datos, lo que permite que BigQuery mantenga una columna de embeddings en una tabla según una columna de origen. La columna de origen debe tener un tipo de datos STRING o ObjectRef. Cuando agregas o modificas datos en la columna de origen, BigQuery genera o actualiza automáticamente la columna de embedding para esos datos usando un modelo de embedding de Agent Platform. Esto es útil si deseas que BigQuery mantenga tus incorporaciones cuando tus datos fuente se actualicen con regularidad.

Las embeddings son útiles para las aplicaciones de IA generativa modernas, como la Generación mejorada por recuperación (RAG), pero pueden ser complejas de crear, administrar y consultar. Puedes usar la generación autónoma de embeddings para simplificar el proceso de creación, mantenimiento y consulta de embeddings para su uso en búsquedas de similitud y otras aplicaciones de IA generativa.

Por ejemplo, puedes usar consultas similares a las siguientes para crear una tabla con la generación de embeddings autónomos habilitada, insertar datos y, luego, realizar una búsqueda semántica:

CREATE TABLE mydataset.products (
  name STRING,
  description STRING,
  description_embedding STRUCT<result ARRAY<FLOAT64>, status STRING>
    GENERATED ALWAYS AS (
      AI.EMBED(description, connection_id => 'us.example_connection',
        endpoint => 'text-embedding-005')
      # Alternatively, you can use the syntax for a built-in model.
      # AI.EMBED(description, model => 'embeddinggemma-300m')
    ) STORED OPTIONS( asynchronous = TRUE ));

# Values in the description_embedding column are automatically generated.
INSERT INTO mydataset.products (name, description) VALUES
  ('Super slingers', 'An exciting board game for the whole family'), ...;

SELECT * FROM AI.SEARCH(TABLE mydataset.products, 'description', 'A really fun toy');

Antes de comenzar

Para habilitar la generación autónoma de incorporaciones en una tabla, debes tener los permisos y la conexión necesarios, y habilitar la API de Vertex AI para tu proyecto.

Roles obligatorios

Para obtener los permisos que necesitas para habilitar la generación autónoma de incorporaciones, pídele a tu administrador que te otorgue los siguientes roles de IAM:

  • Para usar un recurso de conexión, debes tener el rol de Usuario de conexiones de BigQuery (roles/bigquery.connectionUser) en la conexión.
  • Para crear o modificar una tabla: Editor de datos de BigQuery (roles/bigquery.dataEditor) en la tabla
  • Otorga a la cuenta de servicio de la conexión el siguiente rol para que pueda acceder a los modelos alojados en los extremos de Agent Platform: Usuario de Agent Platform (roles/aiplatform.user) en el proyecto que tiene la conexión

Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

También puedes obtener los permisos necesarios a través de roles personalizados o cualquier otro rol predefinido.

Crea una conexión y otorga permiso a una cuenta de servicio

Para habilitar la generación autónoma de embeddings en una tabla, debes crear una conexión a recursos de Cloud. Luego, otorga el rol de usuario de Agent Platform (roles/aiplatform.user) a la cuenta de servicio que se creó cuando creaste la conexión.

Crea una columna de embedding generada automáticamente

Puedes crear una columna de embedding generada automáticamente en una tabla nueva o agregar una a una tabla existente.

Crea una tabla con una columna de embeddings generada automáticamente

Puedes usar la generación autónoma de embeddings para generar embeddings con la función AI.EMBED en una sentencia CREATE TABLE.

SQL

Usa una declaración CREATE TABLE para crear una tabla con una columna de embedding generada automáticamente. Para crear la tabla, sigue estos pasos:

  1. En la consola de Google Cloud , ve a la página BigQuery.

    Ir a BigQuery

  2. En el editor de consultas, escribe la siguiente oración:

    CREATE TABLE DATASET_ID.TABLE (
  [COLUMN, ...]
  SOURCE_COL { STRING | ObjectRef },
  EMBEDDING_COL_NAME STRUCT<result ARRAY<FLOAT64>, status STRING>
    GENERATED ALWAYS AS (
      AI.EMBED(
        SOURCE_COL,
        {
          connection_id => CONNECTION_ID,
          endpoint => ENDPOINT |
          model => MODEL
        })
    )
    STORED OPTIONS (asynchronous = TRUE)
);

    Reemplaza lo siguiente:

    • DATASET_ID: Es el nombre del conjunto de datos en el que deseas crear la tabla.
    • TABLE: Es el nombre de la tabla en la que se creará la generación de incorporaciones autónoma.
    • COLUMN, ...: Son las columnas que debe contener tu tabla, además de la columna que deseas incorporar automáticamente.
    • SOURCE_COL: Es el nombre de la columna STRING o ObjectRef que deseas incorporar automáticamente.
    • EMBEDDING_COL_NAME: Es el nombre de la columna de embedding generada automáticamente.
    • CONNECTION_ID: Un valor STRING que contiene el nombre de una conexión que se usará, como my_project.us.example_connection. Debes otorgar el rol de usuario de Agent Platform a la cuenta de servicio de la conexión en el proyecto en el que creas la tabla.
    • ENDPOINT: Un valor STRING que especifica un extremo del modelo de embedding de texto compatible con Agent Platform que se usará para el modelo de embedding de texto. El valor del extremo que especifiques debe incluir la versión del modelo, por ejemplo, text-embedding-005. Si especificas el nombre del modelo en lugar de una URL, BigQuery ML identifica automáticamente el modelo y usa el extremo completo del modelo.
    • MODEL (Vista previa): Es un valor STRING que especifica un modelo de embedding de texto integrado. El único valor admitido es el modelo embeddinggemma-300m. Si especificas este parámetro, no puedes especificar los parámetros endpoint ni connection_id. Cuando especificas el parámetro MODEL, tus datos permanecen en BigQuery y tus ranuras se usan para crear las incorporaciones. No se envían datos a Agent Platform ni se generan cargos en Agent Platform.

  3. Haz clic en Ejecutar.

Si deseas obtener información sobre cómo ejecutar consultas, visita Ejecuta una consulta interactiva.

bq

Para crear una tabla con una columna de incorporación generada automáticamente con la herramienta de línea de comandos de bq, usa el comando bq mk con un archivo de esquema JSON que defina el esquema de la tabla:

  1. Crea un archivo de esquema JSON. En el siguiente ejemplo, se muestra un esquema que crea una columna de incorporación basada en una columna de origen. En este ejemplo, se usa un extremo de Agent Platform para la generación de incorporaciones.

    [
  {
    "name": "SOURCE_COL",
    "type": "STRING"
  },
  {
    "fields": [
      {
        "mode": "REPEATED",
        "name": "result",
        "type": "FLOAT"
      },
      {
        "name": "status",
        "type": "STRING"
      }
    ],
    "generatedColumn": {
      "generationExpressionInfo": {
        "asynchronous": true,
        "generationExpression": "AI.EMBED(SOURCE_COL, connection_id => 'CONNECTION_ID', endpoint => 'ENDPOINT')",
        "stored": true
      },
      "generatedMode": "GENERATED_ALWAYS"
    },
    "name": "EMBEDDING_COL_NAME",
    "type": "RECORD"
  }
]

    Si usas un modelo integrado en lugar de un extremo de Agent Platform, usa una sintaxis similar a la siguiente para generationExpression: "AI.EMBED(SOURCE_COL, model => 'MODEL')"

    Para obtener información sobre los valores que se deben usar, consulta las descripciones de SOURCE_COL, EMBEDDING_COL_NAME, CONNECTION_ID, ENDPOINT y MODEL en la pestaña SQL.

  2. Guarda el esquema en un archivo, como schema.json.

  3. Crea la tabla con el comando bq mk --table:

    bq mk --table DATASET_ID.TABLE schema.json

Reemplaza lo siguiente:

  • DATASET_ID: Es el nombre del conjunto de datos en el que deseas crear la tabla.
  • TABLE: Es el nombre de la tabla en la que se creará la generación autónoma de incorporaciones.
  • COLUMN, ...: Son las columnas que debe contener tu tabla, además de la columna que deseas incorporar automáticamente.
  • STRING_COL: Es el nombre de la columna STRING que deseas incorporar automáticamente.
  • EMBEDDING_COL_NAME: Es el nombre de la columna de embedding generada automáticamente.
  • CONNECTION_ID: Un valor STRING que contiene el nombre de una conexión que se usará, como my_project.us.example_connection. Debes otorgar el rol de usuario de Agent Platform a la cuenta de servicio de la conexión en el proyecto en el que creas la tabla.
  • ENDPOINT: Un valor STRING que especifica un extremo del modelo de embedding de texto de Agent Platform compatible que se usará para el modelo de embedding de texto. El valor del extremo que especifiques debe incluir la versión del modelo, por ejemplo, text-embedding-005. Si especificas el nombre del modelo en lugar de una URL, BigQuery ML identifica automáticamente el modelo y usa su extremo completo.

  • MODEL (versión preliminar): Un valor STRING que especifica un modelo de embedding de texto integrado. El único valor admitido es el modelo embeddinggemma-300m. Si especificas este parámetro, no puedes especificar los parámetros endpoint ni connection_id.

    Cuando especificas el parámetro MODEL, tus datos permanecen en BigQuery y tus ranuras se usan para crear las incorporaciones. No se envían datos a Agent Platform y no se generan cargos en Agent Platform.

Agrega una columna de embeddings generada automáticamente a una tabla existente

También puedes agregar una columna de embedding generada automáticamente a una tabla existente con una instrucción ALTER TABLE ADD COLUMN.

SQL

Usa una declaración ALTER TABLE ADD COLUMN para agregar una columna de embedding generada automáticamente a una tabla existente. Para agregar la columna, sigue estos pasos:

  1. En la consola de Google Cloud , ve a la página BigQuery.

    Ir a BigQuery

  2. En el editor de consultas, escribe la siguiente oración:

    ALTER TABLE DATASET_ID.TABLE
  ADD COLUMN EMBEDDING_COL_NAME
    STRUCT<result ARRAY<FLOAT64>, status STRING>
    GENERATED ALWAYS AS (
      AI.EMBED(
        SOURCE_COL,
        {
          connection_id => CONNECTION_ID,
          endpoint => ENDPOINT |
          model => MODEL
        })
    )
    STORED OPTIONS (asynchronous = TRUE)
;

    Reemplaza lo siguiente:

    • DATASET_ID: Es el nombre del conjunto de datos que contiene la tabla.
    • TABLE: Es el nombre de la tabla a la que deseas agregar la columna de embedding generada automáticamente.
    • EMBEDDING_COL_NAME: Es el nombre de la columna de embedding generada automáticamente.
    • SOURCE_COL: Es el nombre de la columna STRING o ObjectRef que deseas incorporar automáticamente.
    • CONNECTION_ID: Un valor STRING que contiene el nombre de una conexión que se usará, como my_project.us.example_connection.
    • ENDPOINT: Un valor STRING que especifica un extremo del modelo de embedding de texto compatible con Agent Platform que se usará para el modelo de embedding de texto.
    • MODEL (Vista previa): Es un valor STRING que especifica un modelo de embedding de texto integrado. El único valor admitido es el modelo embeddinggemma-300m. Si especificas este parámetro, no puedes especificar los parámetros endpoint ni connection_id. Cuando especificas el parámetro MODEL, tus datos permanecen en BigQuery y tus ranuras se usan para crear las incorporaciones. No se envían datos a Agent Platform ni se generan cargos en Agent Platform.

  3. Haz clic en Ejecutar.

Si deseas obtener información sobre cómo ejecutar consultas, visita Ejecuta una consulta interactiva.

bq

Para agregar una columna de incorporación generada automáticamente a una tabla existente con la herramienta de línea de comandos de bq, usa el comando bq update con un archivo de esquema JSON que defina el esquema de la tabla actualizado:

  1. Obtén el esquema actual de la tabla y guárdalo en un archivo, como schema.json: 
    bq show --schema --format=prettyjson DATASET_ID.TABLE > schema.json

  2. Edita schema.json para agregar la definición de la nueva columna de incorporación generada automáticamente. En el siguiente ejemplo, se muestra la definición de una columna de incorporación basada en una columna de origen. En este ejemplo, se usa un extremo de Agent Platform para la generación de incorporaciones.

    [
  {
    "name": "SOURCE_COL",
    "type": "STRING"
  },
  {
    "fields": [
      {
        "mode": "REPEATED",
        "name": "result",
        "type": "FLOAT"
      },
      {
        "name": "status",
        "type": "STRING"
      }
    ],
    "generatedColumn": {
      "generationExpressionInfo": {
        "asynchronous": true,
        "generationExpression": "AI.EMBED(SOURCE_COL, connection_id => 'CONNECTION_ID', endpoint => 'ENDPOINT')",
        "stored": true
      },
      "generatedMode": "GENERATED_ALWAYS"
    },
    "name": "EMBEDDING_COL_NAME",
    "type": "RECORD"
  }
]

    Si usas un modelo integrado en lugar de un extremo de Agent Platform, usa una sintaxis similar a la siguiente para generationExpression: "AI.EMBED(SOURCE_COL, model => 'MODEL')"

    Para obtener información sobre los valores que se deben usar, consulta las descripciones de SOURCE_COL, EMBEDDING_COL_NAME, CONNECTION_ID, ENDPOINT y MODEL en la pestaña SQL.

  3. Actualiza la tabla con el comando bq update --table:

    bq update --table DATASET_ID.TABLE schema.json

    Reemplaza lo siguiente:

    • DATASET_ID: Es el nombre del conjunto de datos que contiene la tabla.
    • TABLE: Es el nombre de la tabla a la que deseas agregar la columna de embedding generada automáticamente.

El trabajo de generación de embeddings en segundo plano comienza poco después de que se crea o modifica tu tabla, o después de que actualizas los datos en la columna de origen.

Para hacer un seguimiento del progreso de la generación de la incorporación, puedes usar una consulta similar a la siguiente:

SELECT
  COUNT(*) AS total_num_rows,
  COUNTIF(description_embedding IS NOT NULL
          AND description_embedding.status = '') AS total_num_generated_embeddings
FROM
  PROJECT_ID.DATASET_ID.TABLE;

Después de tener la tabla con las incorporaciones, puedes crear un índice de vectores en la columna STRUCT que contiene la incorporación generada automáticamente.

Ejemplo

Supongamos que eres un minorista grande que vende muchos productos diferentes. Tienes una tabla de nombres y descripciones de productos, y quieres ayudar a tus clientes a encontrar los productos que buscan. Las siguientes consultas te muestran cómo configurar la generación autónoma de incorporaciones para ayudar con la búsqueda semántica de las descripciones de tus productos.

Primero, crea un conjunto de datos:

CREATE SCHEMA mydataset;

A continuación, crea una tabla con la generación autónoma de embeddings habilitada para almacenar la información del producto. La columna generada automáticamente se llama description_embedding y se basa en la columna description.

# Create a table of products and descriptions with a generated embedding column.
CREATE TABLE mydataset.products (
  name STRING,
  description STRING,
  description_embedding STRUCT<result ARRAY<FLOAT64>, status STRING>
    GENERATED ALWAYS AS (
      AI.EMBED(description, connection_id => 'us.example_connection',
        endpoint => 'text-embedding-005')
      # Alternatively, you can use the syntax for a built-in model.
      # AI.EMBED(description, model => 'embeddinggemma-300m')
    ) STORED OPTIONS( asynchronous = TRUE )
);

La siguiente consulta inserta algunos nombres y descripciones de productos en la tabla. No especificas un valor para description_embedding porque se genera automáticamente.

# Insert product descriptions into the table.
# The description_embedding column is automatically updated.
INSERT INTO mydataset.products (name, description) VALUES
  ("Lounger chair", "A comfortable chair for relaxing in."),
  ("Super slingers", "An exciting board game for the whole family."),
  ("Encyclopedia set", "A collection of informational books.");

De manera opcional, puedes crear un índice de vectores en la tabla para acelerar la búsqueda. Un índice de vectores requiere más de tres filas, por lo que la siguiente consulta supone que insertaste datos adicionales. Cada vez que insertas datos, la columna description_embedding se actualiza automáticamente.

CREATE VECTOR INDEX my_index
ON mydataset.products(description_embedding)
OPTIONS(index_type = 'IVF');

Por último, puedes usar la función AI.SEARCH para realizar una búsqueda semántica de tus productos y encontrar un juguete divertido:

# Search for products that are fun to play with.
SELECT base.name, base.description, distance
FROM AI.SEARCH(TABLE mydataset.products, 'description', "A really fun toy");

/*------------------+----------------------------------------------+----------------------+
 | name             | description                                  | distance             |
 +------------------+----------------------------------------------+----------------------+
 | Super slingers   | An exciting board game for the whole family. | 0.80954913893618929  |
 | Lounger chair    | A comfortable chair for relaxing in.         | 0.938933930620146    |
 | Encyclopedia set | A collection of informational books.         | 1.1119297739353384   |
 +------------------+----------------------------------------------+----------------------*/

Embeddings generados a partir de columnas ObjectRef

Puedes agregar columnas de embedding generadas para una columna ObjectRef en una tabla.

En el siguiente ejemplo, se muestra cómo crear una tabla con una columna ObjectRef y, luego, agregar una columna de incorporación generada para esa columna:

# Create a table with ObjectRef columns.
CREATE TABLE mydataset.images AS
SELECT
  REGEXP_EXTRACT(ref.uri, r'.*/(.*).jpg$') AS name,
  ref
FROM mydataset.object_table;

# Add a generated embedding column for the ObjectRef column.
ALTER TABLE mydataset.images
ADD COLUMN image_embedding STRUCT<result ARRAY<FLOAT64>, status STRING>
GENERATED ALWAYS AS (
  AI.EMBED(
    ref,
    connection_id => "us.my_connection",
    endpoint => "multimodalembedding@001")
)
STORED OPTIONS (asynchronous = true);

Obtén información sobre las columnas de incorporación generadas automáticamente

Para verificar que una columna sea una columna de embedding generada automáticamente, consulta la vista INFORMATION_SCHEMA.COLUMNS.

La siguiente consulta te muestra información sobre todas las columnas de embedding generadas automáticamente:

SELECT *
FROM PROJECT_ID.DATASET_ID.INFORMATION_SCHEMA.COLUMNS
WHERE is_generated = 'ALWAYS';

El campo generation_expression muestra la llamada a la función AI.EMBED que se usa para generar los embeddings en la columna.

Usa tu propia reserva

De forma predeterminada, BigQuery usa ranuras a pedido para controlar el procesamiento necesario para mantener la columna de embedding generada. Para garantizar un rendimiento predecible y coherente, puedes crear una reserva y establecer job_type en BACKGROUND de forma opcional. Cuando hay una reserva en segundo plano, BigQuery la usa para mantener la columna de incorporación generada.

Cuotas

Cuando usas un extremo de Agent Platform para generar embeddings especificando el parámetro endpoint en la función AI.EMBED, BigQuery envía solicitudes a Agent Platform para generar embeddings. Estas solicitudes están sujetas a las cuotas de Agent Platform. La cuota de solicitudes por minuto para tu modelo de embedding afecta directamente la capacidad de procesamiento de los trabajos de generación de embeddings en segundo plano. Si la generación de incorporaciones es lenta, solicita un límite de cuota más alto para Agent Platform siguiendo las instrucciones que se indican en Solicita una cuota más alta. Si especificas el parámetro model en la función AI.EMBED, las incorporaciones se generan en BigQuery y no se envían solicitudes a Agent Platform, por lo que no se aplican las cuotas de Agent Platform.

Soluciona problemas

La columna de embedding generada contiene dos campos: result y status. Si se produce un error cuando BigQuery intenta generar una incorporación para una fila en particular de tu tabla, el campo result será NULL y el campo status describirá el error. Por ejemplo, si la columna de origen es NULL, la incorporación de result también es NULL y el estado es NULL value is not supported for embedding generation.

Un error más grave puede detener la generación de la incorporación. En este caso, puedes consultar la columna async_generation_status en la vista INFORMATION_SCHEMA.COLUMNS para identificar el error de bloqueo.

Los errores de bloqueo pueden incluir lo siguiente:

  • Errores de permiso denegado
  • Errores de no encontrado
  • Errores de extremos de modelos de incorporación no compatibles
  • Errores de API de Vertex AI no habilitada

Una vez que se complete correctamente el siguiente trabajo de generación de embeddings, se borrará la columna async_generation_status.

En la siguiente consulta, se muestra cómo verificar si hay errores de bloqueo:

SELECT
  column_name,
  async_generation_status
FROM
  mydataset.INFORMATION_SCHEMA.COLUMNS
WHERE
  table_name = 'images';

Si la columna image_embedding tiene un error de bloqueo, el resultado es similar al siguiente:

[
  {
    "column_name": "image_embedding",
    "async_generation_status": {
      "blocking_error": {
        "message": "<service_account> does not have the permission to access resources used by AI.EMBED. Please follow https://cloud.google.com/bigquery/docs/permissions-for-ai-functions to set up permissions.",
        ...
      }
    }
  }
]

También puedes consultar la vista INFORMATION_SCHEMA.JOBS para el trabajo en segundo plano y consultar la información en el campo error_result. El ID de un trabajo de incorporación en segundo plano tiene el prefijo gc_. Por ejemplo, la siguiente consulta extrae todos los trabajos en segundo plano cuyo resultado de error no es NULL:

SELECT * FROM `region-REGION.INFORMATION_SCHEMA.JOBS` j
WHERE EXISTS (
  SELECT 1
  FROM unnest(j.referenced_tables) t
  WHERE
    j.project_id = 'PROJECT_ID'
    AND t.dataset_id = 'DATASET_ID'
    AND t.table_id = 'TABLE'
)
AND starts_with(job_id, 'gc')
AND error_result IS NOT NULL
ORDER BY j.creation_time DESC;

Realiza un seguimiento de los costos

Los costos de la generación autónoma de embeddings se dividen en las siguientes categorías.

Costos de las DML en segundo plano de BigQuery

Las incorporaciones generadas se escriben en tu tabla con trabajos DML en segundo plano. De forma predeterminada, BigQuery usa ranuras a pedido para controlar estos trabajos. El proyecto de la tabla se factura según el modelo de facturación según demanda de DML.

Como alternativa, para garantizar un rendimiento predecible y coherente, puedes crear una reserva y establecer job_type en BACKGROUND. Cuando hay una reserva en segundo plano, BigQuery la usa para ejecutar los trabajos DML en segundo plano. Además, se facturará la reserva en segundo plano por el uso del tiempo de ranura de los trabajos DML en segundo plano.

Para hacer un seguimiento de los valores de total_slot_ms y total_bytes_billed para los trabajos de DML en segundo plano en una tabla, consulta la vista INFORMATION_SCHEMA.JOBS para los trabajos con un prefijo job_id de gc_:

SELECT
  job_id,
  creation_time,
  reservation_id,
  total_slot_ms,
  total_bytes_processed,
  total_bytes_billed
FROM
  `region-REGION.INFORMATION_SCHEMA.JOBS` j
WHERE
  EXISTS (
    SELECT 1
    FROM UNNEST(j.referenced_tables) t
    WHERE
      j.project_id = 'PROJECT_ID'
      AND t.dataset_id = 'DATASET_ID'
      AND t.table_id = 'TABLE'
  )
  AND STARTS_WITH(job_id, 'gc_')
ORDER BY
  j.creation_time DESC;

Reemplaza lo siguiente:

  • REGION: La región del conjunto de datos que contiene tu tabla, por ejemplo, us.
  • PROJECT_ID: Es el ID del proyecto que contiene tu tabla.
  • DATASET_ID: Es el nombre del conjunto de datos que contiene tu tabla.
  • TABLE: Es el nombre de la tabla con la generación de embeddings autónomos habilitada.

Si especificas el modelo embeddinggemma-300m integrado con el parámetro model en la función AI.EMBED, BigQuery también genera las incorporaciones directamente en estos trabajos de DML en segundo plano con ranuras de BigQuery. No se envían solicitudes a Agent Platform ni se incurre en cargos de Agent Platform. Para obtener más información, consulta Elige un modelo.

Costos de Gemini Enterprise Agent Platform

Cuando especificas un modelo de Gemini Enterprise Agent Platform con el parámetro endpoint en la función AI.EMBED, la generación autónoma de incorporaciones envía solicitudes a Gemini Enterprise Agent Platform, lo que puede generar costos. Para hacer un seguimiento de los costos de Agent Platform en los que se incurre por los trabajos de incorporación en segundo plano, sigue estos pasos:

  1. Consulta tus informes de facturación en Facturación de Cloud.

  2. Usa filtros para definir mejor los resultados.

    En Servicios, selecciona Vertex AI.

  3. Para ver los cargos de un trabajo específico, filtra por etiqueta.

    Establece la clave en bigquery_ml_job y el valor en el ID del trabajo del trabajo de incorporación. Todos los trabajos de incorporación en segundo plano tienen el prefijo gc_.

Algunos cargos pueden tardar hasta 24 horas en aparecer en la Facturación de Cloud.

Limitaciones

  • Cada tabla admite, como máximo, una columna de embedding generada automáticamente.
  • Las operaciones DML simultáneas pueden provocar demoras y fallas temporales en la generación de incorporaciones. Para obtener un mejor rendimiento y reducir los costos, te recomendamos que insertes datos en lotes y evites las actualizaciones frecuentes del DML.
  • Si usas la API de transmisión heredada para transferir datos, es posible que haya algunas demoras antes de que comience la generación de la incorporación.
  • Cuando se usa la API de BigQuery Storage Write (gRPC), es posible que fallen los trabajos de generación de incorporación en segundo plano si se ejecuta un trabajo de escritura de transmisión de forma simultánea. Cuando esto ocurre, se desperdician la cuota de Agent Platform y los costos de DML en segundo plano. El uso de la API de Storage Write (gRPC) también genera trabajos de generación de incorporaciones simultáneos en la tabla, pero BigQuery se encarga de esto y no se desperdicia ninguna cuota de la Agent Platform ni costos de DML en segundo plano.
  • Para obtener un mayor rendimiento en los extremos remotos de Agent Platform, recomendamos usar modelos de embedding de texto en lugar de modelos de Gemini. Para obtener más información, consulta Cuotas.
  • No hay ninguna indicación de que una columna se genere automáticamente cuando ves el esquema de una tabla con la consola de Google Cloud o el campoddlde la vistaINFORMATION_SCHEMA.TABLES.
  • Si creas una copia, una clonación o una instantánea de una tabla que tiene una columna de incorporación generada, solo se copian los datos. La configuración de generación no se aplica a la tabla nueva, y las actualizaciones de la columna de origen de la tabla nueva no generarán nuevas incorporaciones.
  • Si restableces desde una instantánea una tabla que tenía habilitada la generación autónoma de embeddings, no se restablecerá la configuración de generación de embeddings.
  • Cuando usas la API de BigQuery, solo puedes especificar la propiedad generatedColumn cuando creas una columna nueva. No puedes agregar, actualizar ni quitar la propiedad generatedColumn en una columna existente.

  • Después de crear la columna de incorporación generada, se aplican las siguientes limitaciones:

    • No puedes quitar ni cambiar el nombre de la columna de origen, pero sí puedes quitar o cambiar el nombre de la columna de incorporación generada. Si quitas la columna de incorporación, puedes quitar o cambiar el nombre de la columna de origen.
    • No puedes cambiar el tipo de datos de la columna de origen ni de la columna de incorporación generada.

  • No puedes especificar valores predeterminados para las columnas de incorporación generadas automáticamente.

  • No puedes escribir directamente en las columnas de embedding generadas con estos métodos:

    • DML
    • Operaciones de escritura por transmisión
    • bq insert
    • bq load
    • bq copy -a

  • Las tablas con columnas de embeddings generados no admiten ninguna política de seguridad a nivel de la columna, como las etiquetas de política.

  • Cuando llamas a una función de búsqueda, como VECTOR_SEARCH o AI.SEARCH, se omiten las filas con incorporaciones faltantes en la tabla base durante la búsqueda.

  • No puedes crear un índice de vectores particionado en una tabla que tenga habilitada la generación de embeddings autónomos.

  • Si creas un índice vectorial en la columna de incorporación generada automáticamente, el entrenamiento del índice comenzará después de que al menos el 80% de las filas hayan generado incorporaciones. Para verificar el progreso de la generación de la incorporación, sigue estos pasos:

    Consulta el porcentaje de embeddings de tu tabla que se generaron:

    SELECT
  COUNTIF(description_embedding IS NOT NULL
  AND description_embedding.status = '') * 100.0 / COUNT(*) AS percent
FROM PROJECT_ID.DATASET_ID.TABLE;

¿Qué sigue?