Se usó la API de Cloud Translation para traducir esta página.

Genera y administra embeddings de vectores automáticos para tablas grandes

Puedes generar y administrar embeddings de vectores para toda una columna de la tabla, lo que te brinda una solución escalable para la creación de embeddings de vectores a gran escala. Esta solución es particularmente útil para facilitar la búsqueda semántica y la generación mejorada por recuperación (RAG) en el contenido de texto, lo que incluye lo siguiente:

Crea un embedding de vector inicial para una tabla nueva
Generar embeddings después de una importación de datos grande
Actualiza los embeddings después de cambios significativos en los datos
Cómo mantener las incorporaciones de forma incremental

Información sobre los embeddings de vectores automáticos

Los embeddings de vectores automáticos en AlloyDB proporcionan una forma escalable de automatizar la generación y el mantenimiento de embeddings de vectores para tus datos. En lugar de generar manualmente embeddings para cada fragmento de texto nuevo o actualizado, puedes configurar los embeddings de vector automáticos para que se encarguen de este proceso. Esto es especialmente útil para las aplicaciones que dependen de embeddings actualizados para la búsqueda semántica, la generación mejorada por recuperación (RAG) y otras funciones potenciadas por IA.

Con los embeddings de vectores automáticos, puedes hacer lo siguiente:

Inicializa embeddings para una tabla completa: Genera embeddings para todos los datos existentes en una columna de tabla con un solo comando.
Mantén las incorporaciones sincronizadas: Actualiza automáticamente las incorporaciones cuando cambien los datos de origen, lo que garantiza que tus aplicaciones de IA siempre funcionen con la información más actual.
Genera embeddings a gran escala: Crea embeddings de manera eficiente para tablas grandes con millones de filas.
Configura y administra las incorporaciones para varias columnas en la misma tabla llamando a las funciones de administración para cada columna de incorporación.

Esta función simplifica el desarrollo y el mantenimiento de las aplicaciones basadas en IA, ya que abstrae la complejidad de la creación y el mantenimiento de las incorporaciones de vectores.

Antes de comenzar

Antes de generar y administrar embeddings de vectores para tablas grandes, haz lo siguiente:

Conéctate a tu base de datos con psql o AlloyDB para PostgreSQL Studio como el usuario postgres.
Verifica que la extensión google_ml_integration esté instalada.
Verifica que la marca google_ml_integration.enable_model_support esté establecida en on.
Verifica que la extensión google_ml_integration sea la versión 1.5.2 o posterior, y que la marca google_ml_integration.enable_faster_embedding_generation esté establecida en on.

Para verificar la versión de tu extensión, usa el siguiente comando:
```
SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';
```
Si necesitas actualizar la extensión, usa el comando ALTER EXTENSION google_ml_integration UPDATE;.

Nota: Si no tienes los permisos necesarios, comunícate con el administrador de la base de datos para realizar la actualización. Como alternativa, puedes esperar a que la nueva versión se lance automáticamente en tu clúster.
Antes de generar embeddings desde una base de datos de AlloyDB, debes configurar AlloyDB para que funcione con Vertex AI. Para obtener más información, consulta Integra tu base de datos en Vertex AI.
Para administrar y supervisar la generación de la incorporación automática, los usuarios tienen acceso Select a las tablas google_ml.embed_gen_progress y google_ml.embed_gen_settings de forma predeterminada.

Para permitir que un usuario administre la generación de la incorporación automática, otorga los permisos INSERT, UPDATE y DELETE en las tablas google_ml.embed_gen_progress y google_ml.embed_gen_settings:
```
GRANT INSERT, UPDATE, DELETE ON google_ml.embed_gen_progress TO 'USER_NAME';
```
Reemplaza lo siguiente:
- USER_NAME: Es el nombre del usuario al que se le otorgan los permisos.
Verifica que AUTOCOMMIT esté configurado como ON en el cliente de PostgreSQL que usas.
Confirma que el modelo de embedding que usas tiene suficiente cuota para los embeddings de vectores automáticos. Si la cuota es insuficiente, la operación de incorporación automática puede ser lenta o fallar. Por ejemplo, estos son los límites para los modelos de embeddings de Vertex AI:
- Límites de la incorporación de texto: Cada solicitud puede tener hasta 250 textos de entrada que generen una incorporación por texto de entrada y 20,000 tokens por solicitud. Solo se usan los primeros 2,048 tokens de cada texto de entrada para calcular las incorporaciones.
- Solicitudes por minuto:
  - base_model : text-embedding : 1500
  - base_model : gemini-embedding : 100000
- Límite de tokens del modelo de Gemini Embedding: A diferencia de otros modelos de Embedding que se limitaban principalmente por las cuotas de RPM, la serie de modelos de Gemini Embedding se limita a 5,000,000 de tokens por minuto por proyecto.

Inicializa embeddings para una tabla

Las funciones para administrar las incorporaciones de vectores automáticas están disponibles en el esquema ai. Este esquema proporciona una interfaz para las funciones de IA más recientes de AlloyDB.

Usa la función de SQL ai.initialize_embeddings() para generar embeddings para la columna de contenido de una tabla. Esta es una llamada de bloqueo:

Si la función devuelve un resultado exitoso, se completó la creación de la incorporación de vectores.
La función intenta recuperarse automáticamente de problemas transitorios, como errores de cuota del modelo. Solo recibirás una respuesta de error si estos intentos de recuperación no son satisfactorios. En el caso de problemas persistentes, como un batch_size mal configurado que hace que la solicitud supere los límites de tamaño, o si la operación se canceló de forma manual, debes volver a emitir la llamada de forma manual.

Esta función admite modelos proporcionados por Google (por ejemplo, text-embedding-005 de Vertex AI), así como modelos personalizados que hayas registrado.

Antes de generar embeddings, crea una columna content_embeddings en tu tabla. Por lo general, esta columna tiene un tipo vector(DIMENSION) y un valor DEFAULT NULL.

ALTER TABLE user_reviews ADD COLUMN IF NOT EXISTS content_embeddings vector(768) DEFAULT NULL;

Realiza la generación por lotes

De forma predeterminada, AlloyDB usa el procesamiento por lotes para generar embeddings para varias entradas de texto en una sola solicitud, lo que mejora la eficiencia. Si no proporcionas un tamaño de lote específico, AlloyDB aplica un valor predeterminado determinado automáticamente.

Tamaño de lote de sugerencias

El parámetro batch_size en ai.initialize_embeddings te permite guiar el optimizador de consultas de AlloyDB sugiriendo un tamaño de lote preferido para los modelos admitidos directamente. AlloyDB podría reducir dinámicamente este tamaño según los límites o las cuotas del modelo, pero tu sugerencia ayuda a influir en el plan de ejecución de la consulta.

CALL ai.initialize_embeddings(
    model_id => 'text-embedding-005',
    table_name => 'user_reviews',
    content_column => 'content',
    embedding_column => 'content_embeddings',
    batch_size => 50
);

Usa un modelo de incorporación personalizado con compatibilidad para lotes

Si deseas usar un modelo personalizado o compatible de forma externa que admita el procesamiento por lotes, define las funciones de transformación por lotes y especifícalas como model_batch_in_transform_fn y model_batch_out_transform_fn cuando crees un modelo. También puedes especificar un batch_size en la llamada a initialize_embeddings. En el caso de los modelos que admiten el procesamiento por lotes, te recomendamos que uses un batch_size mayor que 1 para obtener un mejor rendimiento.

Define las funciones de entrada, salida y transformación por lotes de tu modelo personalizado.

-- Scalar input transform functions
CREATE OR REPLACE FUNCTION acme_text_input_transform(model_id TEXT, input TEXT) RETURNS JSON;
CREATE OR REPLACE FUNCTION acme_text_output_transform(model_id TEXT, model_output JSON) RETURNS real[];
CREATE OR REPLACE FUNCTION acme_generate_headers(model_id TEXT, input TEXT) RETURNS JSON;
-- Batch input transform functions
CREATE OR REPLACE FUNCTION acme_text_batch_input_transform(model_id TEXT, input TEXT[]) RETURNS JSON;
CREATE OR REPLACE FUNCTION acme_text_batch_output_transform(model_id TEXT, model_output JSON) RETURNS real[][];

Para crear tu modelo, especifica las funciones de transformación por lotes.

CALL
  ai.create_model(
    model_id => 'custom-embedding-model',
    model_request_url => 'https://acme.com/models/text/embeddings/v1',
    model_type => 'text_embedding',
    model_in_transform_fn => 'acme_text_input_transform',
    model_out_transform_fn => 'acme_text_output_transform',
    generate_headers_fn => 'acme_generate_headers',
    model_batch_in_transform_fn => 'acme_text_batch_input_transform',
    model_batch_out_transform_fn => 'acme_text_batch_output_transform'
  );

Genera embeddings de vectores con tu modelo personalizado.

CALL
  ai.initialize_embeddings(
    model_id => 'custom-embedding-model',
    table_name => 'user_reviews',
    content_column => 'content',
    embedding_column => 'content_embeddings',
    batch_size => 10
);

También puedes usar la función de incorporación automática con modelos personalizados que no admiten de forma nativa el procesamiento por lotes. Para ello, debes definir las funciones de transformación por lotes model_batch_in_transform_fn y model_batch_out_transform_fn. Para un modelo que no procesa por lotes, define estas funciones para procesar una sola entrada a la vez desde el array de entrada. Cuando llames a ai.initialize_embeddings para este modelo, establece batch_size en 1.

Actualiza las incorporaciones de forma incremental

Cuando actualizas una incorporación, se vuelve a generar según el valor más reciente de la columna de contenido de entrada.

Para brindarte control sobre la coherencia y el rendimiento, AlloyDB admite varios modos para las actualizaciones incrementales de la incorporación. Puedes seleccionar un modo con el argumento de enumeración incremental_refresh_mode en ai.initialize_embeddings(). A continuación, se incluye una lista de los modos posibles:

transactional: Las incorporaciones se actualizan como parte de la transacción que actualiza la columna de contenido. Este proceso, que a menudo usa un mecanismo similar a un activador de base de datos para generar automáticamente incorporaciones cuando se actualiza la columna de contenido, puede generar una sobrecarga y ralentizar las operaciones de actualización. La sobrecarga introducida es una compensación para mantener la semántica transaccional y garantizar que las incorporaciones estén sincronizadas con el contenido. Este modo se basa en las funciones de transformación escalar de tu modelo, por lo que debes definir model_in_transform_fn y model_out_transform_fn cuando crees el modelo. Para usar el modo transactional, debes tener el rol de propietario en la tabla.
```
CALL
  ai.initialize_embeddings(
    model_id => 'text-embedding-005',
    table_name => 'user_reviews',
    content_column => 'content',
    embedding_column => 'content_embeddings',
    batch_size => 10,
    incremental_refresh_mode => 'transactional'
);
```
none: Este es el modo predeterminado. En este modo, AlloyDB no actualiza las incorporaciones automáticamente. No se realiza un seguimiento de los cambios incrementales, por lo que llamar a la función ai.refresh_embeddings() regenera las incorporaciones de toda la tabla. Este modo proporciona control total.

Actualiza todos los embeddings de una tabla

Después de ejecutar ai.initialize_embeddings() correctamente para una tabla, puedes usar la función ai.refresh_embeddings() para volver a generar los embeddings. Puedes usar una operación de actualización para actualizar las incorporaciones de las filas que se modifican de forma simultánea durante la llamada inicial a initialize_embeddings o para realizar una actualización completa periódica.

La función de actualización reutiliza la configuración de la llamada inicial, por lo que solo debes especificar la tabla y la columna de incorporación. También puedes proporcionar un batch_size opcional para anular el valor predeterminado.

CALL ai.refresh_embeddings(
    table_name => 'user_reviews',
    embedding_column => 'content_embeddings',
    batch_size => 50  -- Optional override
);

Trabaja con datos de tablas durante la creación de embeddings de vectores

Si bien ai.initialize_embeddings() es una llamada de bloqueo para la sesión en la que se ejecuta, otras conexiones pueden seguir trabajando con la tabla. El proceso de incorporación automática de vectores actualiza las filas en lotes, lo que implica el bloqueo estándar a nivel de la fila. Esto significa que las operaciones DML simultáneas, como UPDATE o DELETE, solo se bloquean brevemente si intentan modificar las mismas filas que actualiza el proceso de incorporación. No se bloquean las consultas de otras conexiones. Ten en cuenta que initialize_embeddings omite las filas que se modifican de forma simultánea. Si incremental_refresh_mode es none, las incorporaciones de estas filas modificadas no se actualizan hasta que se llama a una actualización posterior.

-- connection1 (starts embedding generation)
SELECT
  ai.initialize_embeddings(
    model_id => 'text-embedding-005',
    table_name => 'user_reviews',
    content_column => 'content',
    embedding_column => 'content_embeddings'
  );

-- connection2 (performs DMLs/queries without blocking)
INSERT INTO user_reviews(id, review_time, is_edited, content)
VALUES (48290, now(), false, 'I really liked the product functionality, but wish it came in orange color');

UPDATE user_reviews
SET is_edited = TRUE, content = 'Changing to 5 star. My issue is resolved by the support'
WHERE id = 700;

Si cancelas initialize_embeddings con pg_cancel o si initialize_embeddings falla debido a un error interno, se muestra un estado de falla. No se revierten los vectores de incorporación creados correctamente. Para recuperarte del error y completar la creación de la incorporación de vectores, primero debes limpiar la configuración con la función ai.drop_embedding_config() y, luego, volver a emitir la llamada ai.initialize_embeddings().

Para actualizar las incorporaciones de las filas modificadas de forma simultánea, llama a ai.refresh_embeddings después de que se complete la llamada a ai.initialize_embeddings. Esta llamada de actualización regenera las incorporaciones para toda la tabla.

Borra la configuración de los embeddings de vectores automáticos

Si necesitas quitar la configuración de embedding de vector automático para una combinación específica de tabla y columna de embedding, usa la función ai.drop_embedding_config(). Esta función puede ser útil para la limpieza o cuando vuelves a configurar la administración de la incorporación para una columna.

CALL
  ai.drop_embedding_config(
    table_name => 'user_reviews',
    embedding_column => 'content_embeddings');

Ejemplos para generar embeddings en el automóvil

En esta sección, se proporcionan ejemplos para generar incorporaciones de forma automática con extremos de modelos registrados.

Modelo de embedding de OpenAI

Para generar embeddings con el extremo del modelo text-embedding-3-small registrado que proporciona OpenAI, ejecuta la siguiente instrucción:

CALL ai.initialize_embeddings(
    model_id => 'text-embedding-3-small',
    table_name => 'user_reviews',
    chunk_column => 'content',
    embedding_column => 'content_embeddings'
);

Modelos de incorporación personalizados

En el caso de los modelos propios o compatibles de forma externa, debes definir funciones de transformación de entrada y salida, y registrarlas con ai.create_model. Si planeas usar la función de incorporación automática, debes especificar tanto las funciones de transformación escalar (por ejemplo, acme_text_input_transform, acme_text_output_transform) como las funciones de transformación por lotes (por ejemplo, acme_text_batch_input_transform, acme_text_batch_output_transform).