Generación de embeddings autónoma

En este documento, se describe cómo usar la generación de embeddings autónoma para tus datos, lo que permite que BigQuery mantenga una columna de embeddings en una tabla en función de 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 quieres permitir que BigQuery mantenga tus embeddings cuando tus datos de origen se actualizan con regularidad.

Los embeddings son útiles para las aplicaciones de IA generativa modernas, como la generación mejorada por recuperación (RAG), pero pueden ser complejos de crear, administrar y consultar. Puedes usar la generación de embeddings autónoma para simplificar el proceso de creación, mantenimiento y consulta de embeddings para usarlos 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ónoma 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 de incorporaciones autónomas 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 de incorporaciones autónomas, pídele a tu administrador que te otorgue los siguientes roles de IAM:

  • Para usar un recurso de conexión: 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 embeddings generada automáticamente

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

Cuando defines la función AI.EMBED para una columna de incorporación generada automáticamente, si no especificas el argumento task_type y tu modelo admite task_type, BigQuery establece task_type en RETRIEVAL_DOCUMENT de forma predeterminada. Cuando consultas la tabla con la función AI.SEARCH o la función VECTOR_SEARCH, BigQuery genera la incorporación de la consulta sobre la marcha con el siguiente comportamiento de task_type:

  • Si la columna de incorporación de la tabla usa RETRIEVAL_DOCUMENT, ya sea de forma predeterminada o especificada de forma explícita, BigQuery usa RETRIEVAL_QUERY para incorporar la consulta de búsqueda.
  • De lo contrario, BigQuery usa el mismo task_type configurado para la columna de incorporación de la tabla.

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

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

SQL

Usa una sentencia CREATE TABLE para crear una tabla con una columna de embeddings 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 embeddings autónoma.
    • COLUMN, ...: cualquier columna que deba 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 de forma automática.
    • EMBEDDING_COL_NAME: Es el nombre de la columna de embedding generada automáticamente.
    • CONNECTION_ID: Es 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: Es un valor STRING que especifica un extremo de 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): 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 los embeddings. 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 incorporaciones 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 generar embeddings.

    [
  {
    "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 de incorporaciones autónoma.
  • COLUMN, ...: Cualquier columna que deba contener tu tabla, además de la columna que deseas incorporar de forma automática.
  • STRING_COL: Es el nombre de la columna STRING que deseas incorporar de forma automática.
  • EMBEDDING_COL_NAME: Es el nombre de la columna de embedding generada automáticamente.
  • CONNECTION_ID: Es 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 de 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 el extremo completo del modelo.

  • 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 los embeddings. No se envían datos a Agent Platform ni 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 embeddings generada automáticamente a una tabla existente con una declaración ALTER TABLE ADD COLUMN.

SQL

Usa una sentencia ALTER TABLE ADD COLUMN para agregar una columna de embeddings 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 de forma automática.
    • CONNECTION_ID: Es un valor STRING que contiene el nombre de una conexión que se usará, como my_project.us.example_connection.
    • ENDPOINT: Es un valor STRING que especifica un extremo de modelo de embedding de texto de Agent Platform compatible que se usará para el modelo de embedding de texto.
    • MODEL (versión preliminar): 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 los embeddings. 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 incorporaciones 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 embeddings generada automáticamente. En el siguiente ejemplo, se muestra la definición de una columna de embeddings basada en una columna de origen. En este ejemplo, se usa un extremo de Agent Platform para generar embeddings.

    [
  {
    "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 incorporaciones en segundo plano se inicia poco después de que se crea o modifica la 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 embeddings, 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 embeddings, puedes crear un índice de vectores en la columna STRUCT que contiene el embedding generado automáticamente.

Ejemplo

Supongamos que eres un gran minorista 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. En las siguientes consultas, se muestra cómo configurar la generación de incorporaciones autónomas 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 de tus productos. 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 forma opcional, puedes crear un índice de vectores en la tabla para acelerar la búsqueda. Un índice vectorial 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 en tus productos de 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   |
 +------------------+----------------------------------------------+----------------------*/

Se generaron embeddings a partir de ObjectRef columnas

Puedes agregar columnas de embeddings 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 embeddings generadas automáticamente

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

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

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

En el campo generation_expression, se muestra la llamada a la función AI.EMBED que se usa para generar los embeddings en la columna, incluido el argumento task_type => 'RETRIEVAL_DOCUMENT' predeterminado si no especificaste un task_type para un modelo que lo admita.

Usa tu propia reserva

De forma predeterminada, BigQuery usa ranuras a pedido para controlar el procesamiento necesario para mantener la columna de embeddings 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 incorporaciones 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 embeddings 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, los embeddings 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 embeddings 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 es NULL y el campo status describe el error. Por ejemplo, si la columna de origen es NULL, el embedding 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 incorporaciones. 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 los siguientes:

  • Errores de permiso denegado
  • Errores de recurso no encontrado
  • Errores de extremos de modelos de embeddings no compatibles
  • Errores de la API de Vertex AI no habilitada

Una vez que el siguiente trabajo de generación de embeddings se complete de forma correcta, 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://docs.cloud.google.com/bigquery/docs/permissions-for-ai-functions to set up permissions.",
        ...
      }
    }
  }
]

También puedes consultar la vista INFORMATION_SCHEMA.JOBS del trabajo en segundo plano y revisar la información en el campo error_result. El ID de tarea 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 de embeddings autónomos se dividen en las siguientes categorías.

Costos de DML en segundo plano de BigQuery

Los embeddings generados se escriben en tu tabla con trabajos de 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 a pedido de DML.

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

Para hacer un seguimiento de los valores total_slot_ms y total_bytes_billed de 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: Es la región del conjunto de datos que contiene tu tabla, por ejemplo, us.
  • PROJECT_ID: 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ónoma 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 las ranuras de BigQuery. No se envían solicitudes a Agent Platform ni se generan 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 de incorporaciones autónoma envía solicitudes a Gemini Enterprise Agent Platform, lo que puede generar costos. Para hacer un seguimiento de los costos de Agent Platform que generan 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 de 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 embeddings generada automáticamente.
  • Las operaciones de DML simultáneas pueden causar demoras y fallas temporales en la generación de embeddings. Para mejorar el rendimiento y reducir los costos, te recomendamos insertar datos en lotes y evitar las actualizaciones frecuentes de 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 incorporaciones.
  • Cuando usas la API de BigQuery Storage Write (gRPC), los trabajos de generación de incorporaciones en segundo plano pueden fallar 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 desperdician costos de cuota de Agent Platform ni de DML en segundo plano.
  • Para obtener una mayor capacidad de procesamiento 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 indicios de que una columna se genere automáticamente cuando visualizas el esquema de una tabla con la consola de Google Cloud o el campo ddl de la vista INFORMATION_SCHEMA.TABLES.
  • Si creas una copia, una clonación o una instantánea de una tabla que tiene una columna de embedding 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 incorporaciones nuevas.
  • Si restableces una tabla que tenía habilitada la generación autónoma de embeddings desde una instantánea, 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 embeddings generada, se aplican las siguientes limitaciones:

    • No puedes quitar ni cambiar el nombre de la columna de origen, pero puedes quitar o cambiar el nombre de la columna de incorporación generada. Si quitas la columna de incorporación, puedes quitar la columna de origen o cambiarle el nombre.
    • 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 embeddings 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 generadas no admiten ninguna política de seguridad a nivel de columna, como las etiquetas de política.

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

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

  • Si creas un índice vectorial en la columna de embeddings generada automáticamente, el entrenamiento del índice comenzará después de que al menos el 80% de las filas hayan generado embeddings. Para verificar el progreso de la generación de embeddings, 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?