Generación autónoma de embeddings

Versión preliminar

Esta función está sujeta a las “Condiciones de la Oferta de la Fase Previa a la DG” en la sección Condiciones del Servicio Generales de las Condiciones Específicas del Servicio. Las funciones de la fase previa a la DG están disponibles sin modificaciones y pueden tener asistencia limitada. Para obtener más información, consulta las descripciones de la etapa de lanzamiento.

Nota: Para enviar comentarios o solicitar asistencia sobre esta función, comunícate con [e-mail]

En este documento, se describe cómo usar la generación autónoma de incorporaciones para tus datos, lo que permite que BigQuery mantenga una columna de incorporaciones en una tabla según una columna de origen. Cuando agregas o modificas datos en la columna de origen, BigQuery genera o actualiza automáticamente la columna de incorporación para esos datos con un modelo de incorporación de Vertex AI. Esto es útil si deseas que BigQuery mantenga tus incorporaciones cuando tus datos fuente se actualicen con regularidad.

Los embeddings son útiles para las aplicaciones modernas de IA generativa, como la generación mejorada por recuperación (RAG), pero pueden ser complejos 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'))
    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.

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, haz lo siguiente: Usuario de conexiones de BigQuery (roles/bigquery.connectionUser) en la conexión
• Para crear una tabla, haz lo siguiente: 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 Vertex AI: Usuario de Vertex AI (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 incorporaciones en una tabla, debes crear una conexión de recursos de Cloud. Luego, otorga el rol de usuario de Vertex AI (roles/aiplatform.user) a la cuenta de servicio que se creó cuando creaste la conexión.

Crea una tabla con generación de embeddings autónoma

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

CREATE TABLE DATASET_ID.TABLE (
  [COLUMN, ...]
  STRING_COL STRING,
  EMBEDDING_COL_NAME STRUCT<result ARRAY<FLOAT64>, status STRING>
    GENERATED ALWAYS AS (
      AI.EMBED(
        STRING_COL,
        connection_id => CONNECTION_ID,
        endpoint => ENDPOINT)
    )
    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ónomas.
• 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 Vertex AI 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 del modelo de incorporación de texto de Vertex AI compatible que se usará para el modelo de incorporación 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.

El trabajo de generación de incorporaciones en segundo plano comienza poco después de que se crea 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 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 crear la tabla con los embeddings, puedes crear un índice de vectores en la columna STRUCT que contiene el embedding generado 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 de embeddings autónoma 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'
    ))
    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 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ónAI.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   |
 +------------------+----------------------------------------------+----------------------*/

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

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

La siguiente consulta te muestra información sobre todas las columnas de incorporación 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 incorporación 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.

Soluciona problemas

La columna de incorporación 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, 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 vista de INFORMATION_SCHEMA.JOBS para el trabajo en segundo plano y observar la información en el campo error_result. El ID de trabajo 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;

Seguimiento de costos

La generación autónoma de embeddings envía solicitudes a Vertex AI, lo que puede generar costos. Para hacer un seguimiento de los costos de Vertex AI 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 del trabajo de la tarea 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.
• 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 , el comando bq show o el campo ddl de la vista INFORMATION_SCHEMA.TABLES.
• No puedes agregar columnas de incorporación generadas a una tabla existente con ALTER TABLE ADD COLUMN.
• 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 incorporaciones, no se restablecerá la configuración de generación de incorporaciones.
• Solo puedes crear columnas de embeddings generados con SQL. No puedes usar los comandos bq mk o bq update para crear columnas de incorporación generadas.
• La columna de origen de la columna generada debe ser una columna STRING.

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

  • No puedes descartar ni cambiar el nombre de la columna fuente, pero sí puedes descartar o cambiar el nombre de la columna de incorporación generada. Si descartas la columna de incorporación, puedes descartar o cambiar el nombre de la columna fuente.
  • 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 incorporación generadas con estos métodos:

  • DML
  • Operaciones de escritura por transmisión
  • bq insert
  • 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 autónoma de incorporaciones.

• Si creas un índice vectorial en la columna de incorporación generada automáticamente, el entrenamiento del índice comienza después de que al menos el 80% de las filas hayan generado incorporaciones. Puedes usar la siguiente consulta para verificar qué porcentaje de embeddings de tu tabla 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?

• Obtén más información para crear y administrar índices vectoriales.
• Consulta la Introducción a la búsqueda vectorial.