Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Générer et gérer des embeddings vectoriels automatiques pour les grandes tables

Vous pouvez générer et gérer des embeddings vectoriels pour une colonne de table entière, ce qui vous offre une solution évolutive pour la création d'embeddings vectoriels à grande échelle. Cette solution est particulièrement utile pour faciliter la recherche sémantique et la génération augmentée par récupération (RAG) sur le contenu textuel, y compris les éléments suivants :

Créer un embedding vectoriel initial pour une nouvelle table
Générer des embeddings après une importation de données volumineuses
Actualiser les embeddings après des modifications importantes des données
Mettre à jour les embeddings de manière incrémentielle

Comprendre les embeddings vectoriels automatiques

Les embeddings vectoriels automatiques dans AlloyDB offrent un moyen évolutif d'automatiser la génération et la maintenance des embeddings vectoriels pour vos données. Au lieu de générer manuellement des embeddings pour chaque nouveau texte ou texte modifié, vous pouvez configurer des embeddings vectoriels automatiques pour gérer ce processus à votre place. Cela est particulièrement utile pour les applications qui s'appuient sur des embeddings à jour pour la recherche sémantique, la génération augmentée par récupération (RAG) et d'autres fonctionnalités optimisées par l'IA.

Les représentations vectorielles continues automatiques vous permettent d'effectuer les opérations suivantes :

Initialiser les embeddings pour une table entière : générez des embeddings pour toutes les données existantes dans une colonne de table avec une seule commande.
Synchronisez les embeddings : mettez-les à jour automatiquement lorsque les données sources changent. Vos applications d'IA fonctionnent ainsi toujours avec les informations les plus récentes.
Générez des embeddings à grande échelle : créez efficacement des embeddings pour les grandes tables comportant des millions de lignes.
Configurez et gérez les embeddings pour plusieurs colonnes d'une même table en appelant les fonctions de gestion pour chaque colonne d'embedding.

Cette fonctionnalité simplifie le développement et la maintenance des applications d'IA en masquant la complexité de la création et de la maintenance des embeddings vectoriels.

Avant de commencer

Avant de pouvoir générer et gérer des embeddings vectoriels pour les grandes tables, procédez comme suit :

Vérifiez et augmentez les quotas de Gemini Enterprise Agent Platform : pour garantir des performances optimales et éviter les opérations lentes, les faibles RPS ou les multiples tentatives, vérifiez et, si nécessaire, augmentez vos quotas Agent Platform.

Pour vérifier et augmenter vos quotas, procédez comme suit :
1. Dans la console Google Cloud , accédez à la page Quotas.
2. Filtrez les métriques suivantes en fonction de votre modèle et de votre région :
  - Pour les requêtes par minute (RPM) : Regional online prediction requests per base model per minute per region per base_model
  - Pour les jetons Gemini : Embed content input tokens per minute per region per base_model
3. Si vos limites actuelles sont insuffisantes pour la taille de votre tableau, recherchez la valeur de quota que vous souhaitez modifier, puis cochez la case à côté du quota.
4. Cliquez sur Modifier. La boîte de dialogue Modifications de quotas s'affiche.
  
  Pour en savoir plus, consultez Demander un ajustement de quota.
Pour connaître les limites des modèles d'embedding Agent Platform et obtenir la liste complète des quotas, consultez Quotas et limites d'Agent Platform.

Remarque : La génération initiale d'embeddings pour les grandes tables (par exemple, des millions de lignes) peut être limitée par les quotas de la plate-forme d'agents par défaut, ce qui entraîne un faible RPS et de fréquentes tentatives. Augmenter votre quota à l'avance est le moyen le plus efficace de garantir une initialisation rapide et réussie.
Connectez-vous à votre base de données à l'aide de psql ou d'AlloyDB pour PostgreSQL Studio en tant qu'utilisateur postgres.
Vérifiez que l'extension google_ml_integration est installée et que sa version est 1.5.6 ou ultérieure.
Vérifiez que les options google_ml_integration.enable_model_support et google_ml_integration.enable_faster_embedding_generation sont définies sur on.
Avant de pouvoir générer des embeddings à partir d'une base de données AlloyDB, vous devez configurer AlloyDB pour qu'il fonctionne avec Agent Platform. Pour en savoir plus, consultez Intégrer votre base de données à la plate-forme d'agents.
Pour gérer et surveiller la génération d'embeddings automatiques, les utilisateurs disposent de l'accès Select aux tables google_ml.embed_gen_progress et google_ml.embed_gen_settings par défaut.

Pour autoriser un utilisateur à gérer la génération d'intégrations automatiques, accordez-lui les autorisations INSERT, UPDATE et DELETE sur les tables google_ml.embed_gen_progress et google_ml.embed_gen_settings :
```
GRANT INSERT, UPDATE, DELETE ON google_ml.embed_gen_progress TO 'USER_NAME';
```
Remplacez les éléments suivants :
- USER_NAME : nom de l'utilisateur pour lequel les autorisations sont accordées.
Terminez la configuration initiale décrite dans Générer des embeddings textuels.
Vérifiez que AUTOCOMMIT est défini sur ON dans le client PostgreSQL que vous utilisez.

Vérifier la version de l'extension

Pour vérifier la version de l'extension google_ml_integration, exécutez la commande suivante :

SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';

Si vous devez mettre à jour l'extension, exécutez la commande suivante :

ALTER EXTENSION google_ml_integration UPDATE;

Vérifiez que les options de base de données sont définies sur `on`.

Pour vérifier que les indicateurs de base de données sont correctement définis, exécutez les commandes suivantes :

SHOW google_ml_integration.enable_model_support;
SHOW google_ml_integration.enable_faster_embedding_generation;

Si ces options sont définies sur off, consultez Configurer les options de base de données d'une instance. Pour en savoir plus sur ces options, consultez la section Options de base de données compatibles.

Préparer votre tableau

Avant de pouvoir générer des embeddings automatiques, vous devez créer une colonne dans votre tableau pour stocker les vecteurs obtenus. Cette colonne utilise généralement le type vector(DIMENSION) et doit avoir une valeur DEFAULT NULL.

Par exemple, pour ajouter une colonne pour les embeddings de dimension 768 à une table nommée user_reviews :

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

Initialiser les embeddings pour une table

Les fonctions de gestion des embeddings vectoriels automatiques sont disponibles dans les schémas ai et google_ml. Le schéma ai fournit une interface simplifiée pour les dernières fonctionnalités d'IA dans AlloyDB.

Utilisez la fonction SQL ai.initialize_embeddings() pour générer des embeddings pour la colonne de contenu d'une table. Il s'agit d'un appel bloquant, ce qui signifie que la session de base de données attend la fin de l'opération avant de renvoyer un résultat et de vous permettre d'exécuter de nouvelles commandes dans cette session. Toutefois, les autres connexions à la base de données ne sont pas bloquées et peuvent continuer à fonctionner avec la table :

Si la fonction renvoie une valeur indiquant que l'opération a réussi, la création de l'embedding vectoriel est terminée.
La fonction tente automatiquement de résoudre les problèmes temporaires, comme les erreurs de quota de modèle. Un échec ne vous est renvoyé que si ces tentatives de récupération échouent. En cas de problèmes persistants, comme un batch_size mal configuré qui entraîne le dépassement des limites de taille de la requête, ou si l'opération a été annulée manuellement, vous devez relancer l'appel manuellement.

Cette fonction est compatible avec les modèles fournis par Google (par exemple, le modèle text-embedding-005 d'Agent Platform), ainsi qu'avec les modèles personnalisés que vous enregistrez.

Effectuer une génération par lot

Par défaut, AlloyDB utilise le traitement par lot pour générer des embeddings pour plusieurs entrées de texte dans une même requête, ce qui améliore l'efficacité. Si vous ne fournissez pas de taille de lot spécifique, AlloyDB applique une valeur par défaut déterminée automatiquement.

Taille du lot d'indices

Le paramètre batch_size dans ai.initialize_embeddings vous permet de guider l'optimiseur de requêtes d'AlloyDB en suggérant une taille de lot préférée pour les modèles directement compatibles. AlloyDB peut réduire dynamiquement cette taille en fonction des limites ou des quotas du modèle, mais votre indication permet d'influencer le plan d'exécution de la requête.

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

Utiliser un modèle d'embedding personnalisé avec prise en charge des lots

Si vous souhaitez utiliser un modèle personnalisé ou externe compatible avec le traitement par lot, définissez les fonctions de transformation par lot et spécifiez-les comme model_batch_in_transform_fn et model_batch_out_transform_fn lorsque vous créez un modèle. Vous pouvez également spécifier un batch_size dans l'appel initialize_embeddings. Pour les modèles compatibles avec le traitement par lot, nous vous recommandons d'utiliser une valeur batch_size supérieure à 1 pour améliorer les performances.

Définissez les fonctions d'entrée, de sortie et de transformation par lot de votre modèle personnalisé.

-- 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[][];

Pour créer votre modèle, spécifiez les fonctions de transformation par lot.

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

Générez des embeddings vectoriels avec votre modèle personnalisé.

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

Vous pouvez également utiliser la fonctionnalité d'intégration automatique avec des modèles personnalisés qui ne sont pas compatibles avec le traitement par lot. Pour ce faire, vous devez toujours définir les fonctions de transformation par lot model_batch_in_transform_fn et model_batch_out_transform_fn. Pour un modèle sans traitement par lot, définissez ces fonctions pour traiter une seule entrée à la fois à partir du tableau d'entrée. Lorsque vous appelez ai.initialize_embeddings pour ce modèle, définissez batch_size sur 1.

Utiliser une dimensionnalité personnalisée avec la prise en charge des lots

Pour utiliser une fonction de transformation d'entrée par lot personnalisée avec le paramètre OUTPUT_DIMENSIONALITY, vous pouvez définir une fonction qui spécifie les dimensions sélectionnées dans les paramètres de la requête. Cela est utile pour optimiser la génération d'embeddings pour les modèles qui acceptent des tailles de sortie variables.

Par exemple, la fonction suivante définit une transformation d'entrée par lot personnalisée pour un modèle qui nécessite une dimensionnalité de sortie de 768 :

CREATE OR REPLACE FUNCTION google_ml.vertexai_text_embedding_batch_input_transform_with_768_dims(model_id VARCHAR(100), input_list TEXT[])
RETURNS JSON
LANGUAGE SQL
AS $$
  SELECT pg_catalog.json_build_object(
    'instances',
    pg_catalog.json_agg(pg_catalog.json_build_object('content', content)),
    'parameters',
    pg_catalog.json_build_object('outputDimensionality', 768)
  ) FROM unnest(input_list) AS content;
$$;

Utiliser l'optimisation JSONB avec des modèles personnalisés

Vous pouvez utiliser le type de données JSONB dans vos fonctions de transformation de sortie personnalisées pour améliorer les performances. Lorsque vous créez un modèle personnalisé compatible avec les lots, l'extension google_ml_integration recherche et utilise automatiquement une variante JSONB de vos fonctions de transformation.

Cette optimisation peut améliorer considérablement les performances de la génération d'embeddings automatiques, car JSONB est un format binaire plus efficace pour stocker et traiter les données JSON dans PostgreSQL.

Pour profiter de cette fonctionnalité, vous devez fournir une autre version de votre fonction de transformation qui accepte un argument JSONB au lieu de JSON.

Par exemple, si vous disposez d'une fonction de transformation de sortie par lot avec la signature suivante :

CREATE OR REPLACE FUNCTION my_batch_output_transform(model_id TEXT, model_output JSON) RETURNS real[][];

Vous pouvez créer une variante JSONB comme suit :

CREATE OR REPLACE FUNCTION my_batch_output_transform(model_id TEXT, model_output JSONB) RETURNS real[][];

L'extension détecte automatiquement la présence de la version JSONB de la fonction et l'utilise pour le traitement par lot. Si vous avez déjà créé un enregistrement de modèle qui utilise une fonction de transformation JSON, vous n'avez pas besoin de mettre à jour votre appel ai.create_model. Tant que la nouvelle fonction JSONB utilise exactement le même nom que la fonction JSON existante, l'extension détecte et utilise de manière transparente la variante JSONB pour le traitement par lot.

Actualiser les embeddings de manière incrémentielle

Lorsque vous actualisez un embedding, il est régénéré en fonction de la dernière valeur de la colonne de contenu d'entrée.

Pour vous permettre de contrôler la cohérence et les performances, AlloyDB est compatible avec différents modes d'actualisation incrémentielle des embeddings. Vous pouvez sélectionner un mode à l'aide de l'argument d'énumération incremental_refresh_mode dans ai.initialize_embeddings(). Voici une liste des modes possibles :

transactional : les embeddings sont actualisés lors de la mise à jour de la colonne de contenu. Ce processus, qui utilise souvent un mécanisme semblable à un déclencheur de base de données pour générer automatiquement des embeddings lorsque la colonne de contenu est mise à jour, peut entraîner des frais généraux et ralentir les opérations de mise à jour. La surcharge introduite est un compromis pour maintenir la sémantique transactionnelle et s'assurer que les embeddings sont synchronisés avec le contenu. Ce mode s'appuie sur les fonctions de transformation scalaire de votre modèle. Vous devez donc définir model_in_transform_fn et model_out_transform_fn lorsque vous créez le modèle. Pour utiliser le mode transactional, vous devez disposer du rôle de propriétaire pour le tableau.
```
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'
);
```
En mode transactional, la fonction ai.refresh_embeddings() est désactivée, car les embeddings sont synchronisés automatiquement à l'aide de déclencheurs. Pour régénérer les embeddings pour l'ensemble de la table ou pour récupérer les données après un appel ai.initialize_embeddings() interrompu dans ce mode, vous devez d'abord supprimer la configuration à l'aide de la fonction ai.drop_embedding_config(), puis relancer l'appel ai.initialize_embeddings().

Ce mode automatisé est utile pour les démonstrations, les petits ensembles de données ou les tables où le volume d'insertions et de mises à jour est faible par rapport au chargement initial (par exemple, quelques centaines de mises à jour quotidiennes sur une table d'un million de lignes). Cette option est appropriée lorsque le maintien de la cohérence immédiate des données est plus important que la latence supplémentaire introduite lors des opérations de mise à jour.
manual : il s'agit du mode par défaut. Dans ce mode, une nouvelle colonne de suivi booléenne est ajoutée à votre tableau pour suivre les embeddings obsolètes. L'appel de la fonction ai.refresh_embeddings() effectue une actualisation incrémentielle périodique en générant uniquement des embeddings pour les lignes nouvelles ou mises à jour. Nous recommandons ce mode aux utilisateurs qui ont besoin de mieux contrôler les performances, en particulier lorsqu'ils gèrent un grand nombre d'insertions ou de mises à jour après le chargement initial. Il est utile dans les scénarios où la minimisation de la latence d'écriture est une priorité et où il est acceptable d'avoir des embeddings temporairement obsolètes ou nuls jusqu'à ce qu'une actualisation incrémentielle périodique soit déclenchée à l'aide de ai.refresh_embeddings. Pour mettre à jour les lignes obsolètes ou nouvelles, utilisez la fonction ai.refresh_embeddings() comme décrit dans la section Actualiser tous les embeddings d'une table.

Choisir un mode d'actualisation

Le tableau suivant compare les deux modes d'actualisation incrémentielle pour vous aider à choisir l'approche la mieux adaptée à votre application.

Mode	Description	Cohérence et performances	Application idéale
`transactional`	Les embeddings sont mis à jour dans le cadre de la transaction de base de données à l'aide d'un mécanisme semblable à un déclencheur. Notez que `ai.refresh_embeddings()` est désactivé dans ce mode.	Cohérence immédiate : Forte surcharge de latence d'écriture, car chaque `INSERT` ou `UPDATE` déclenche une génération d'embedding.	Démonstrations, petits ensembles de données ou tableaux où la cohérence des données est essentielle.
`manual` (par défaut)	Utilise une colonne de suivi booléenne pour surveiller les lignes obsolètes ou nouvelles. Vous devez appeler `ai.refresh_embeddings()` pour déclencher une actualisation incrémentielle périodique.	Cohérence à terme : Latence d'écriture minimale, car les embeddings sont générés par lot au moment de votre choix.	Ensembles de données volumineux, environnements de production avec une fréquence d'écriture élevée ou applications sensibles aux performances.

Actualiser tous les embeddings d'une table

Une fois que vous avez exécuté ai.initialize_embeddings() pour une table en mode d'actualisation incrémentielle manual, vous pouvez effectuer une actualisation incrémentielle périodique de vos embeddings, déclenchée à l'aide de ai.refresh_embeddings. Vous pouvez utiliser une opération d'actualisation pour mettre à jour les embeddings des lignes modifiées simultanément lors du premier appel initialize_embeddings ou pour effectuer une actualisation incrémentielle périodique.

Si le processus de création d'embeddings est interrompu en mode manuel, par exemple par pg_cancel, appelez la fonction ai.refresh_embeddings() pour terminer la génération pour les lignes restantes.

La fonction d'actualisation réutilise les paramètres de l'appel initial. Vous n'avez donc qu'à spécifier la table et la colonne d'intégration. Vous pouvez également fournir un batch_size facultatif pour remplacer la valeur par défaut.

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

Utiliser des données de table lors de la création d'embeddings vectoriels

Bien que ai.initialize_embeddings() soit un appel bloquant pour la session dans laquelle il s'exécute, d'autres connexions peuvent continuer à fonctionner avec la table. Le processus d'embedding vectoriel automatique met à jour les lignes par lots à l'aide du verrouillage standard au niveau des lignes. Cela signifie que les opérations LMD (Data Modification Language) simultanées, telles que UPDATE ou DELETE, provenant d'autres connexions ne sont bloquées que brièvement si elles tentent de modifier les mêmes lignes ciblées par la tâche d'intégration active. Les requêtes SELECT non modifiantes ne sont pas bloquées.

Supprimer les paramètres d'embedding vectoriel automatique

Si vous devez supprimer la configuration d'embedding vectoriel automatique pour une combinaison spécifique de table et de colonne d'embedding, utilisez la fonction ai.drop_embedding_config(). Cette fonction peut être utile pour le nettoyage ou lorsque vous reconfigurez la gestion des embeddings pour une colonne.

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

Utiliser des tables partitionnées

La fonctionnalité d'embedding vectoriel automatique est compatible avec les tables partitionnées. Cela vous permet de gérer efficacement les embeddings pour les grands ensembles de données partitionnés. Voici les cas d'utilisation courants des tables partitionnées.

Initialiser les embeddings sur une table partitionnée

Vous ne pouvez initialiser les embeddings que sur la partition racine d'une table. Il s'agit d'une opération unique pour l'ensemble de la table partitionnée.

CALL ai.initialize_embeddings(
    model_id => 'text-embeddings-005',
    table_name => 'documents', -- This is the root partitioned table
    content_column => 'content',
    embedding_column => 'content_embeddings'
);

Actualiser les embeddings sur une table partitionnée

Après l'initialisation, vous pouvez actualiser les embeddings sur n'importe quelle partition, y compris la partition racine, les sous-partitions ou les partitions feuilles individuelles. Pour les grands ensembles de données, vous pouvez améliorer les performances en actualisant les embeddings pour différentes partitions en parallèle à partir de différentes connexions à la base de données :

Pour actualiser l'intégralité du tableau, exécutez la commande suivante :

CALL ai.refresh_embeddings(
    table_name => 'documents', -- This is the root partitioned table
    embedding_column => 'content_embeddings'
);

Pour actualiser une seule partition, exécutez la commande suivante :

CALL ai.refresh_embeddings(
    table_name => 'documents_eu',
    embedding_column => 'content_embeddings'
);

Actualiser les embeddings pour les partitions récemment ajoutées ou associées

La fonctionnalité d'intégration automatique permet de générer des embeddings pour les partitions qui sont intégrées à votre table principale après la configuration initiale. Les étapes spécifiques dépendent de si vous ajoutez une toute nouvelle partition ou si vous associez une table préexistante.

Partition nouvellement ajoutée : si vous ajoutez une partition à la table, vous pouvez générer des embeddings pour celle-ci en appelant ai.refresh_embeddings sur la nouvelle partition.

-- Add a new partition
CREATE TABLE documents_africa PARTITION OF documents
    FOR VALUES IN ('africa');

-- Refresh embeddings for the new partition
CALL ai.refresh_embeddings(
    table_name => 'documents_africa',
    embedding_column => 'content_embeddings'
);

Partition nouvellement associée : pour associer une table existante en tant que partition, utilisez d'abord la procédure ai.embedding_prepare_partition pour vous assurer que son schéma est compatible avec la table partitionnée. La fonctionnalité d'intégration automatique permet d'ajouter ou de joindre des partitions à n'importe quel niveau d'une configuration de partition hiérarchique. La procédure ai.embedding_prepare_partition garantit que le schéma est compatible avec n'importe quelle table parente de la hiérarchie.

Pour associer une table existante en tant que partition, utilisez d'abord la procédure ai.embedding_prepare_partition pour vous assurer que son schéma est compatible avec la table partitionnée :

-- Prepare the table to be attached
CALL ai.embedding_prepare_partition(
    parent_table => 'documents',
    child_table => 'documents_misc'
);

-- Attach the partition
ALTER TABLE documents ATTACH partition documents_misc DEFAULT;

-- Refresh embeddings for the newly attached partition
CALL ai.refresh_embeddings(
    table_name => 'documents_misc',
    embedding_column => 'content_embeddings'
);

La fonctionnalité d'intégration automatique permet d'ajouter ou de joindre des partitions à n'importe quel niveau d'une configuration de partition hiérarchique. La procédure ai.embedding_prepare_partition garantit que le schéma est compatible avec n'importe quelle table parente de la hiérarchie :

-- Prepare a sub-partition for a non-root parent table
CALL ai.embedding_prepare_partition(
    parent_table => 'documents_eu', -- An existing partition
    child_table => 'documents_eu_germany'
);

-- Attach the new sub-partition
ALTER TABLE documents_eu ATTACH PARTITION documents_eu_germany
    FOR VALUES IN ('germany');

-- Refresh embeddings for the new sub-partition
CALL ai.refresh_embeddings(
    table_name => 'documents_eu_germany',
    embedding_column => 'content_embeddings'
);

Suivre la progression de la génération d'embeddings

Vous pouvez surveiller l'état en temps réel des appels initialize_embeddings et refresh_embeddings actifs en interrogeant ai.embedding_progress_view. Cette vue fournit des informations sur la progression de l'opération, y compris le pourcentage d'achèvement, le temps écoulé et le temps restant estimé.

Pour vérifier la progression, exécutez la requête suivante :

SELECT
  table_name,
  content_column,
  embedding_column,
  model_id,
  percent_progress,
  status,
  elapsed_time,
  rows_processed,
  partition_root
FROM
  ai.embedding_progress_view;

La vue fournit les informations suivantes :

Colonne	Description
`table_name`	Nom de la table ou de la partition en cours de traitement.
`content_column`	Colonne contenant le contenu source pour l'intégration.
`embedding_column`	Colonne dans laquelle les embeddings sont stockés.
`model_id`	Modèle utilisé pour la génération.
`percent_progress`	Pourcentage de l'opération qui est terminé.
`status`	État actuel de l'opération (par exemple, en cours d'exécution, réussie).
`elapsed_time`	Temps écoulé depuis le début de l'opération.
`rows_processed`	Nombre de lignes traitées jusqu'à présent.
`partition_root`	Nom de la table partitionnée racine.

Exemples de génération d'embeddings dans Auto

Cette section fournit des exemples de génération d'embeddings en mode automatique à l'aide de points de terminaison de modèles enregistrés.

Modèle d'embedding OpenAI

Pour générer des embeddings à l'aide du point de terminaison de modèle text-embedding-3-small enregistré fourni par OpenAI, exécutez l'instruction suivante :

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

Modèles d'embedding personnalisés

Pour vos propres modèles ou ceux compatibles en externe, vous devez définir des fonctions de transformation d'entrée et de sortie, puis les enregistrer avec ai.create_model. Si vous prévoyez d'utiliser la fonctionnalité d'embedding automatique, vous devez spécifier à la fois les fonctions de transformation scalaire (par exemple, acme_text_input_transform, acme_text_output_transform) et les fonctions de transformation par lot (par exemple, acme_text_batch_input_transform, acme_text_batch_output_transform).