Génération autonome d'embeddings

Aperçu

Cette fonctionnalité est soumise aux "Conditions des offres de pré-DG" de la section "Conditions générales du service" des Conditions spécifiques du service. Les fonctionnalités pré-DG sont disponibles "en l'état" et peuvent avoir une prise en charge limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

Remarque : Pour envoyer des commentaires ou demander de l'aide concernant cette fonctionnalité, contactez [e-mail]

Ce document explique comment utiliser la génération autonome d'embeddings pour vos données, ce qui permet à BigQuery de gérer une colonne d'embeddings dans une table en fonction d'une colonne source. Lorsque vous ajoutez ou modifiez des données dans la colonne source, BigQuery génère ou met automatiquement à jour la colonne d'embeddings pour ces données à l'aide d'un modèle d'embeddings Vertex AI. Cela est utile si vous souhaitez que BigQuery gère vos embeddings lorsque vos données sources sont mises à jour régulièrement.

Les embeddings sont utiles pour les applications d'IA générative modernes telles que la génération augmentée par récupération (RAG), mais elles peuvent être complexes à créer, à gérer et à interroger. Vous pouvez utiliser la génération autonome d'embeddings pour simplifier le processus de création, de gestion et d'interrogation des embeddings à utiliser dans les recherches de similarité et d'autres applications d'IA générative.

Par exemple, vous pouvez utiliser des requêtes semblables à celles ci-dessous pour créer une table avec la génération autonome d'embeddings activée, insérer des données, puis effectuer une recherche sémantique :

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');

Avant de commencer

Pour activer la génération autonome d'embeddings dans une table, vous devez disposer des autorisations et de la connexion nécessaires, et activer l'API Vertex AI pour votre projet.

Rôles requis

Pour obtenir les autorisations nécessaires pour activer la génération autonome d'embeddings, demandez à votre administrateur de vous accorder les rôles IAM suivants :

• Pour utiliser une ressource de connexion: utilisateur de connexions BigQuery (roles/bigquery.connectionUser) sur la connexion
• Pour créer une table : éditeur de données BigQuery (roles/bigquery.dataEditor) sur la table
• Attribuez le rôle suivant au compte de service de la connexion afin qu'il puisse accéder aux modèles hébergés dans les points de terminaison Vertex AI : utilisateur Vertex AI (roles/aiplatform.user) sur le projet contenant la connexion

Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Vous pouvez également obtenir les autorisations requises avec des rôles personnalisés ou d'autres rôles prédéfinis.

Créer une connexion et accorder des autorisations à un compte de service

Pour activer la génération autonome d'embeddings dans une table, vous devez créer une connexion à une ressource Cloud. Ensuite, attribuez le rôle d'utilisateur Vertex AI (roles/aiplatform.user) au compte de service créé lorsque vous avez créé la connexion.

Créer une table avec la génération autonome d'embeddings

Vous pouvez utiliser la génération autonome d'embeddings pour générer des embeddings à l'aide de la AI.EMBED fonction dans une CREATE TABLE instruction.

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)
);

Remplacez les éléments suivants :

• DATASET_ID : nom de l'ensemble de données dans lequel vous souhaitez créer la table.
• TABLE: nom de la table sur laquelle créer la génération autonome d'embeddings.
• COLUMN, ...: toutes les colonnes que votre table doit contenir en plus de la colonne que vous souhaitez intégrer automatiquement.
• STRING_COL : nom de la colonne STRING que vous souhaitez intégrer automatiquement.
• EMBEDDING_COL_NAME: nom de la colonne d'embeddings générée automatiquement.
• CONNECTION_ID: valeur STRING contenant le nom d'une connexion à utiliser, par exemple my_project.us.example_connection. Vous devez attribuer le rôle d'utilisateur Vertex AI au compte de service de la connexion dans le projet dans lequel vous créez la table.
• ENDPOINT : valeur STRING qui spécifie un point de terminaison de modèle d'embeddings textuels Vertex AI compatible à utiliser pour le modèle d'embeddings textuels. La valeur du point de terminaison que vous spécifiez doit inclure la version du modèle, par exemple text-embedding-005. Si vous spécifiez le nom du modèle plutôt qu'une URL, BigQuery ML identifie automatiquement le modèle et utilise le point de terminaison complet du modèle.

Le job de génération d'embeddings en arrière-plan démarre peu de temps après la création de votre table ou après la mise à jour des données dans la colonne source.

Pour suivre la progression de la génération d'embeddings, vous pouvez utiliser une requête semblable à la suivante :

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;

Une fois la table avec les embeddings créée, vous pouvez créer un index vectoriel sur la colonne STRUCT contenant l'embedding générée automatiquement.

Exemple

Supposons que vous soyez un grand détaillant qui vend de nombreux produits différents. Vous disposez d'une table de noms et de descriptions de produits, et vous souhaitez aider vos clients à trouver les produits qu'ils recherchent. Les requêtes suivantes vous montrent comment configurer la génération autonome d'embeddings pour faciliter la recherche sémantique de vos descriptions de produits.

Commencez par créer un ensemble de données :

CREATE SCHEMA mydataset;

Ensuite, créez une table avec la génération autonome d'embeddings activée pour stocker les informations sur vos produits. La colonne générée automatiquement est appelée description_embedding et est basée sur la colonne 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 requête suivante insère des noms et des descriptions de produits dans la table. Vous ne spécifiez pas de valeur pour description_embedding, car elle est générée automatiquement.

# 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.");

Vous pouvez éventuellement créer un index vectoriel sur la table pour accélérer la recherche. Un index vectoriel nécessite plus de trois lignes. La requête suivante suppose donc que vous avez inséré des données supplémentaires. Chaque fois que vous insérez des données, la colonne description_embedding est automatiquement mise à jour.

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

Enfin, vous pouvez utiliser la AI.SEARCH fonction pour effectuer une recherche sémantique sur vos produits afin de trouver un jouet amusant :

# 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   |
 +------------------+----------------------------------------------+----------------------*/

Obtenir des informations sur les colonnes d'embeddings générées automatiquement

Pour vérifier qu'une colonne est une colonne d'embeddings générée automatiquement, interrogez la INFORMATION_SCHEMA.COLUMNS vue.

La requête suivante vous montre des informations sur toutes vos colonnes d'embeddings générées automatiquement :

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

Le champ generation_expression affiche l'appel à la fonction AI.EMBED utilisée pour générer les embeddings dans la colonne.

Utiliser votre propre réservation

Par défaut, BigQuery utilise des emplacements à la demande pour gérer le traitement nécessaire à la gestion de la colonne d'embeddings générée. Pour garantir des performances prévisibles et cohérentes, vous pouvez éventuellement créer une réservation et définir job_type sur BACKGROUND. Lorsqu'une réservation en arrière-plan est présente, BigQuery l'utilise à la place pour gérer la colonne d'embeddings générée.

Dépannage

La colonne d'embeddings générée contient deux champs : result et status. Si une erreur se produit lorsque BigQuery tente de générer un embedding pour une ligne particulière de votre table, le champ result est NULL et le champ status décrit l'erreur. Par exemple, si la colonne source est NULL alors l'embedding result est également NULL et l'état est NULL value is not supported for embedding generation.

Une erreur plus grave peut bloquer la génération d'embeddings. Dans ce cas, vous pouvez interroger la INFORMATION_SCHEMA.JOBS vue pour le job en arrière-plan et examiner les informations dans le error_result champ. L'ID de job d'un job d'embeddings en arrière-plan est précédé du préfixe gc_. Par exemple, la requête suivante extrait tous les jobs en arrière-plan dont le résultat d'erreur n'est pas 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;

Suivre les coûts

La génération autonome d'embeddings envoie des requêtes à Vertex AI, ce qui peut entraîner des coûts. Pour suivre les coûts Vertex AI engendrés par les jobs d'embeddings en arrière-plan, procédez comme suit :

1. Affichez vos rapports sur la facturation dans Cloud Billing.

2. Affinez les résultats à l'aide de filtres.

   Pour les services, sélectionnez Vertex AI.

3. Pour afficher les frais d'un job spécifique, filtrez par libellé.

   Définissez la clé sur bigquery_ml_job et la valeur sur l' ID de job du job d'embeddings. Tous les jobs d'embeddings en arrière-plan ont le préfixe gc_.

L'affichage de certains frais dans Cloud Billing peut prendre jusqu'à 24 heures.

Limites

• Chaque table accepte au maximum une colonne d'embeddings générée automatiquement.
• Les opérations LMD simultanées peuvent entraîner des retards et des échecs temporaires dans la génération d'embeddings. Pour améliorer les performances et réduire les coûts, nous vous recommandons d'injecter des données par lot et d'éviter les mises à jour LMD fréquentes.
• Si vous utilisez l'API BigQuery Storage Write pour ingérer des données, il peut y avoir des retards avant le début de la génération d'embeddings.
• Rien n'indique qu'une colonne est générée automatiquement lorsque vous affichez le schéma d'une table à l'aide de la Google Cloud console, de la bq show commande, ou du champ ddl de la vue INFORMATION_SCHEMA.TABLES.
• Vous ne pouvez pas ajouter de colonnes d'embeddings générées à une table existante à l'aide de ALTER TABLE ADD COLUMN.
• Si vous créez une copie, un clone ou un instantané d'une table comportant une colonne d'embeddings générée, seules les données sont copiées. La configuration de la génération ne s'applique pas à la nouvelle table, et les mises à jour de la colonne source de la nouvelle table n'entraîneront pas de nouveaux embeddings.
• Si vous restaurez une table pour laquelle la génération autonome d'embeddings était activée à partir d'un instantané, la configuration de la génération d'embeddings n'est pas restaurée.
• Vous ne pouvez créer des colonnes d'embeddings générées qu'à l'aide de SQL. Vous ne pouvez pas utiliser les commandes bq mk ou bq update pour créer des colonnes d'embeddings générées.
• La colonne source de la colonne générée doit être une colonne STRING.

• Une fois la colonne d'embeddings générée créée, les limites suivantes s'appliquent :

  • Vous ne pouvez pas supprimer ni renommer la colonne source, mais vous pouvez toujours supprimer ou renommer la colonne d'embeddings générée. Si vous supprimez la colonne d'embeddings, vous pouvez supprimer ou renommer la colonne source.
  • Vous ne pouvez pas modifier le type de données de la colonne source ni de la colonne d'embeddings générée.

• Vous ne pouvez pas spécifier de valeurs par défaut pour les colonnes d'embeddings générées automatiquement.

• Vous ne pouvez pas écrire directement dans les colonnes d'embeddings générées à l'aide des méthodes suivantes :

  • DML
  • Écritures en flux continu
  • bq insert
  • bq copy -a

• Les tables comportant des colonnes d'embeddings générées ne sont compatibles avec aucune règle de sécurité au niveau des colonnes, comme les tags de stratégie.

• Lorsque vous appelez une fonction de recherche, telle que VECTOR_SEARCH ou AI.SEARCH, les lignes dont les embeddings sont manquantes dans la table de base sont ignorées lors de la recherche.

• Vous ne pouvez pas créer d'index vectoriel partitionné sur une table pour laquelle la génération autonome d'embeddings est activée.

• Si vous créez un index vectoriel sur la colonne d'embeddings générée automatiquement, l'entraînement de l'index commence une fois qu'au moins 80 % des lignes ont généré des embeddings. Vous pouvez utiliser la requête suivante pour vérifier le pourcentage d'embeddings générées dans votre table :

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

Étape suivante

• Découvrez comment créer et gérer des index vectoriels.
• Consultez la section Présentation de la recherche vectorielle.