Génération autonome d'embeddings
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. Le type de données spécifié pour la colonne source doit être STRING ou ObjectRef. Lorsque vous ajoutez ou modifiez des données dans la colonne source, BigQuery génère ou met à jour automatiquement la colonne des embeddings pour ces données à l'aide d'un modèle d'embedding Agent Platform.
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 ils 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 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')
# 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');
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 connexion BigQuery (
roles/bigquery.connectionUser) sur la connexion -
Pour créer ou modifier 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 Agent Platform :
utilisateur Agent Platform (
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 via 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 aux ressources Cloud.
Attribuez ensuite le rôle Utilisateur Agent Platform
(roles/aiplatform.user) au compte de service créé lorsque vous
avez créé la connexion.
Créer une colonne d'embeddings générée automatiquement
Vous pouvez créer une colonne d'embeddings générée automatiquement dans une nouvelle table ou en ajouter une à une table existante.
Créer une table avec une colonne d'embeddings générée automatiquement
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.
SQL
Utilisez une instruction CREATE TABLE pour créer une table avec une colonne d'embeddings générée automatiquement. Pour créer la table, procédez comme suit :
Dans la Google Cloud console, accédez à la page BigQuery.
Dans l'éditeur de requête, saisissez l'instruction suivante :
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) );
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.SOURCE_COL: nom de la colonneSTRINGouObjectRefque vous souhaitez intégrer automatiquement.EMBEDDING_COL_NAME: nom de la colonne d'embeddings générée automatiquement.CONNECTION_ID: valeurSTRINGcontenant le nom d'une connexion à utiliser, par exemplemy_project.us.example_connection. Vous devez attribuer le rôle Utilisateur Agent Platform au compte de service de la connexion dans le projet dans lequel vous créez la table.ENDPOINT: valeurSTRINGspécifiant un point de terminaison de modèle d'embedding textuel Agent Platform compatible à utiliser pour le modèle d'embedding textuel. La valeur du point de terminaison que vous spécifiez doit inclure la version du modèle, par exempletext-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.MODEL(Aperçu) : valeurSTRINGspécifiant un modèle d'embedding textuel intégré. La seule valeur acceptée est leembeddinggemma-300mmodèle. Si vous spécifiez ce paramètre, vous ne pouvez pas spécifier les paramètresendpointniconnection_id. Lorsque vous spécifiez le paramètreMODEL, vos données restent dans BigQuery et vos emplacements sont utilisés pour créer les embeddings. Aucune donnée n'est envoyée à Agent Platform et aucun frais n'est facturé dans Agent Platform.
Cliquez sur Exécuter.
Pour en savoir plus sur l'exécution des requêtes, consultez Exécuter une requête interactive.
bq
Pour créer une table avec une colonne d'embeddings générée automatiquement à l'aide de l'outil de ligne de commande bq, utilisez la commande bq mk avec un fichier de schéma JSON qui définit le schéma de la table :
Créez un fichier de schéma JSON. L'exemple suivant montre un schéma qui crée une colonne d'embeddings basée sur une colonne source. Cet exemple utilise un point de terminaison Agent Platform pour la génération d'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 vous utilisez un modèle intégré au lieu d'un point de terminaison Agent Platform, utilisez une syntaxe semblable à la suivante pour
generationExpression:"AI.EMBED(SOURCE_COL, model => 'MODEL')"Pour en savoir plus sur les valeurs à utiliser, consultez les descriptions de
SOURCE_COL,EMBEDDING_COL_NAME,CONNECTION_ID,ENDPOINTetMODELdans l'onglet SQL.Enregistrez le schéma dans un fichier tel que
schema.json.Créez la table à l'aide de la commande
bq mk --table:bq mk --table DATASET_ID.TABLE schema.json
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 colonneSTRINGque vous souhaitez intégrer automatiquement.EMBEDDING_COL_NAME: nom de la colonne d'embeddings générée automatiquement.CONNECTION_ID: valeurSTRINGcontenant le nom d'une connexion à utiliser, par exemplemy_project.us.example_connection. Vous devez attribuer le rôle Utilisateur Agent Platform au compte de service de la connexion dans le projet dans lequel vous créez la table.ENDPOINT: valeurSTRINGspécifiant un point de terminaison de modèle d'embedding textuel Agent Platform compatible à utiliser pour le modèle d'embedding textuel. La valeur du point de terminaison que vous spécifiez doit inclure la version du modèle, par exempletext-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.MODEL(Aperçu) : valeurSTRINGspécifiant un modèle d'embedding textuel intégré. La seule valeur acceptée est leembeddinggemma-300mmodèle. Si vous spécifiez ce paramètre, vous ne pouvez pas spécifier les paramètresendpointniconnection_id.Lorsque vous spécifiez le paramètre
MODEL, vos données restent dans BigQuery et vos emplacements sont utilisés pour créer les embeddings. Aucune donnée n'est envoyée à Agent Platform et aucun frais n'est facturé dans Agent Platform.
Ajouter une colonne d'embeddings générée automatiquement à une table existante
Vous pouvez également ajouter une colonne d'embeddings générée automatiquement à une table existante en
utilisant une instruction ALTER TABLE ADD COLUMN.
SQL
Utilisez une instruction ALTER TABLE ADD COLUMN pour ajouter une colonne d'embeddings générée automatiquement à une table existante. Pour ajouter la colonne, procédez comme suit :
Dans la Google Cloud console, accédez à la page BigQuery.
Dans l'éditeur de requête, saisissez l'instruction suivante :
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) ;
Remplacez les éléments suivants :
DATASET_ID: nom de l'ensemble de données contenant la table.TABLE: nom de la table à laquelle vous souhaitez ajouter la colonne d'embeddings générée automatiquement.EMBEDDING_COL_NAME: nom de la colonne d'embeddings générée automatiquement.SOURCE_COL: nom de la colonneSTRINGouObjectRefque vous souhaitez intégrer automatiquement.CONNECTION_ID: valeurSTRINGcontenant le nom d'une connexion à utiliser, par exemplemy_project.us.example_connection.ENDPOINT: valeurSTRINGspécifiant un point de terminaison de modèle d'embedding textuel Agent Platform compatible à utiliser pour le modèle d'embedding textuel.MODEL(Aperçu) : valeurSTRINGspécifiant un modèle d'embedding textuel intégré. La seule valeur acceptée est leembeddinggemma-300mmodèle. Si vous spécifiez ce paramètre, vous ne pouvez pas spécifier les paramètresendpointniconnection_id. Lorsque vous spécifiez le paramètreMODEL, vos données restent dans BigQuery et vos emplacements sont utilisés pour créer les embeddings. Aucune donnée n'est envoyée à Agent Platform et aucun frais n'est facturé dans Agent Platform.
Cliquez sur Exécuter.
Pour en savoir plus sur l'exécution des requêtes, consultez Exécuter une requête interactive.
bq
Pour ajouter une colonne d'embeddings générée automatiquement à une table existante à l'aide de l'outil de ligne de commande bq, utilisez la commande bq update avec un fichier de schéma JSON qui définit le schéma de table mis à jour :
- Obtenez le schéma actuel de la table et enregistrez-le dans un fichier tel que
schema.json:bq show --schema --format=prettyjson DATASET_ID.TABLE > schema.json
Modifiez
schema.jsonpour ajouter la définition de la nouvelle colonne d'embeddings générée automatiquement. L'exemple suivant montre la définition d'une colonne d'embeddings basée sur une colonne source. Cet exemple utilise un point de terminaison Agent Platform pour la génération d'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 vous utilisez un modèle intégré au lieu d'un point de terminaison Agent Platform, utilisez une syntaxe semblable à la suivante pour
generationExpression:"AI.EMBED(SOURCE_COL, model => 'MODEL')"Pour en savoir plus sur les valeurs à utiliser, consultez les descriptions de
SOURCE_COL,EMBEDDING_COL_NAME,CONNECTION_ID,ENDPOINTetMODELdans l'onglet SQL.Mettez à jour la table à l'aide de la commande
bq update --table:bq update --table DATASET_ID.TABLE schema.json
Remplacez les éléments suivants :
DATASET_ID: nom de l'ensemble de données contenant la table.TABLE: nom de la table à laquelle vous souhaitez ajouter la colonne d'embeddings générée automatiquement.
La tâche de génération d'embeddings en arrière-plan démarre peu de temps après la création ou la modification 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 que vous disposez de la table avec les embeddings, vous pouvez
créer un index vectoriel
sur la colonne STRUCT contenant l'embedding généré 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 dans vos descriptions de produits.
Commencez par créer un ensemble de données :
CREATE SCHEMA mydataset;
Créez ensuite une table avec la génération autonome d'embeddings activée pour stocker les informations produit. 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')
# Alternatively, you can use the syntax for a built-in model.
# AI.EMBED(description, model => 'embeddinggemma-300m')
) 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 dans 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 |
+------------------+----------------------------------------------+----------------------*/
Embeddings générés à partir de colonnes ObjectRef
Vous pouvez ajouter des colonnes d'embeddings générées pour une colonne ObjectRef dans une table.
L'exemple suivant montre comment créer une table avec une colonne ObjectRef, puis ajouter une colonne d'embeddings générée pour cette colonne :
# 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);
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 vous montre 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.
Quotas
Lorsque vous utilisez un point de terminaison Agent Platform pour la génération d'embeddings en spécifiant le paramètre endpoint dans la fonction AI.EMBED, BigQuery envoie des requêtes à Agent Platform pour générer des embeddings. Ces requêtes sont soumises aux quotas d'
Agent Platform. Le quota de requêtes par minute pour votre modèle d'embedding affecte directement le débit des tâches de génération d'embeddings en arrière-plan. Si la génération d'embeddings est lente, demandez une
limite de quota plus élevée pour Agent Platform en suivant les instructions de la section
Demander un quota plus élevé. Si vous spécifiez le paramètre model dans la fonction AI.EMBED, les embeddings sont générés dans BigQuery et aucune requête n'est envoyée à Agent Platform. Les quotas d'Agent Platform ne s'appliquent donc pas.
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 colonne async_generation_status dans la vue
INFORMATION_SCHEMA.COLUMNS
pour identifier l'erreur de blocage.
Les erreurs de blocage peuvent inclure les éléments suivants :
- Erreurs de type autorisation refusée
- Erreurs de type "non trouvé"
- Erreurs de point de terminaison de modèle d'embedding non compatible
- Erreurs d'API Vertex AI non activée
Une fois la tâche de génération d'embeddings suivante réussie, la colonne async_generation_status est effacée.
La requête suivante vous montre comment vérifier les erreurs de blocage :
SELECT
column_name,
async_generation_status
FROM
mydataset.INFORMATION_SCHEMA.COLUMNS
WHERE
table_name = 'images';
Si la colonne image_embedding présente une erreur de blocage, le résultat est semblable à ce qui suit :
[
{
"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.",
...
}
}
}
]
Vous pouvez également interroger la
INFORMATION_SCHEMA.JOBS vue
pour la tâche en arrière-plan et examiner les informations dans le error_result champ.
L'ID de tâche d'une tâche d'embedding en arrière-plan est précédé du préfixe gc_. Par exemple, la requête suivante extrait toutes les tâches 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
Les coûts de génération autonome d'embeddings sont répartis dans les catégories suivantes.
Coûts LMD en arrière-plan BigQuery
Les embeddings générés sont écrits dans votre table à l'aide de tâches LMD en arrière-plan. Par défaut, BigQuery utilise des emplacements à la demande pour gérer ces tâches. Le projet de la table est facturé selon le modèle de facturation à la demande LMD.
Vous pouvez également créer une réservation et définir job_type sur BACKGROUND pour garantir des performances prévisibles et cohérentes. Lorsqu'une réservation en arrière-plan est présente, BigQuery l'utilise pour exécuter les tâches LMD en arrière-plan. La réservation en arrière-plan sera facturée pour l'utilisation du temps d'emplacement à partir des tâches LMD en arrière-plan.
Coûts Gemini Enterprise Agent Platform
La génération autonome d'embeddings envoie des requêtes à Gemini Enterprise Agent Platform, ce qui peut entraîner des coûts. Pour suivre les coûts Agent Platform générés par les tâches d'embedding en arrière-plan, procédez comme suit :
- Affichez vos rapports de facturation dans Cloud Billing.
Utilisez des filtres pour affiner vos résultats.
Pour les services, sélectionnez Vertex AI.
Pour afficher les frais d'une tâche spécifique, filtrez par libellé.
Définissez la clé sur
bigquery_ml_jobet la valeur sur l' ID de tâche de la tâche d'embedding. Toutes les tâches d'embedding en arrière-plan ont le préfixegc_.
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 lots et d'éviter les mises à jour LMD fréquentes.
- Si vous utilisez l'ancienne API de streaming pour ingérer des données, le démarrage de la génération d'embeddings peut être retardé.
- Lorsque vous utilisez l'API BigQuery Storage Write (gRPC), les tâches de génération d'embeddings en arrière-plan peuvent échouer si une tâche d'écriture en flux continu est exécutée simultanément. Dans ce cas, le quota Agent Platform et les coûts LMD en arrière-plan sont gaspillés. L'utilisation de l'API Storage Write (gRPC) entraîne également des tâches de génération d'embeddings simultanées dans la table, mais cela est géré par BigQuery et aucun quota Agent Platform ni coût LMD en arrière-plan n'est gaspillé.
- Pour un débit plus élevé sur les points de terminaison distants Agent Platform, nous vous recommandons d'utiliser des modèles d'embedding textuel plutôt que des modèles Gemini. Pour en savoir plus, consultez la page consacrée aux quotas.
- 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
ou du
ddlchamp de la vueINFORMATION_SCHEMA.TABLES. - 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.
- Lorsque vous utilisez l'API BigQuery, vous ne pouvez spécifier la propriété
generatedColumnque lorsque vous créez une colonne. Vous ne pouvez pas ajouter, mettre à jour ni supprimer la propriétégeneratedColumndans une colonne existante. 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 insertbq loadbq 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_SEARCHouAI.SEARCH, les lignes dont les embeddings sont manquants dans la table de base sont ignorées lors de la recherche.Vous ne pouvez pas créer d'index vectoriel partitionné dans 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. Pour vérifier la progression de la génération d'embeddings, procédez comme suit :
Interrogez le pourcentage d'embeddings générés 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.