Vous pouvez réduire les coûts opérationnels et améliorer la réactivité des requêtes en utilisant des fonctions d'IA optimisées dans AlloyDB pour PostgreSQL. Les fonctions d'IA optimisées minimisent l'utilisation de grands modèles de langage (LLM) pour les tâches de classification ou de filtrage ligne par ligne en traitant la plupart de vos requêtes avec un modèle proxy plus petit et plus rapide, et en ne recourant à un LLM plus grand que lorsque cela est nécessaire.
Les fonctions AlloyDB AI telles que ai.if() peuvent présenter une latence élevée en raison des appels distants aux LLM. Les fonctions optimisées résolvent ce problème de latence en utilisant des modèles de proxy plus petits et entraînés localement (comme des modèles de régression logistique) pour traiter vos requêtes. Ces modèles sont entraînés sur un échantillon de vos données, en utilisant la sortie du LLM comme source de vérité.
Vous pouvez configurer des vérifications de précision à effectuer au moment de l'exécution à l'aide de l'option google_ml_integration.proxy_models_enable_accuracy_check, qui est définie sur off par défaut. Les vérifications de précision évaluent un échantillon de lignes de la requête à l'aide du LLM de référence pour s'assurer que la précision respecte le seuil défini par l'option google_ml_integration.proxy_models_f1_score_threshold. Si la vérification de la précision échoue, la requête utilise le LLM (ou génère une erreur si le remplacement est désactivé).
Workflow des fonctions d'IA optimisées
Lorsque vous utilisez une fonction d'IA optimisée et que vous définissez l'option google_ml_integration.proxy_models_enable_accuracy_check sur true, AlloyDB effectue les opérations suivantes.
Planification de l'entraînement : lorsque vous exécutez une requête contenant la fonction
ai.if()sur une table, AlloyDB planifie automatiquement l'entraînement d'un modèle de proxy léger en arrière-plan.Utilise le LLM comme solution de remplacement : pendant l'entraînement du modèle proxy, ou si aucun modèle proxy n'est disponible, AlloyDB utilise le LLM distant pour évaluer la requête (sauf si la solution de remplacement est désactivée).
Exécute des requêtes optimisées : une fois le modèle entraîné, AlloyDB utilise le modèle proxy entraîné pour traiter les requêtes ultérieures localement, ce qui accélère les performances.
Le schéma suivant illustre le flux logique de traitement des requêtes avec des fonctions d'IA optimisées :
Avant de commencer
Avant d'utiliser les fonctions d'IA optimisées, procédez comme suit :
- Connectez-vous à votre base de données à l'aide de psql. Vous pouvez également vous connecter à l'aide d'AlloyDB Studio en tant qu'utilisateur
postgresou en tant qu'utilisateur ayant accès à la table où résident les données. Vérifiez que l'extension
google_ml_integrationversion 1.6.3 ou ultérieure est installée.SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';Le résultat ressemble à ce qui suit :
extversion ------------ 1.6.3 (1 row)Si l'extension n'est pas installée ou si sa version est antérieure à la version 1.6.3, mettez-la à jour :
CREATE EXTENSION IF NOT EXISTS google_ml_integration; ALTER EXTENSION google_ml_integration UPDATE;Configurez AlloyDB pour qu'il fonctionne avec Gemini Enterprise Agent Platform. Pour en savoir plus, consultez Intégrer à Agent Platform.
Vérifiez que les indicateurs de base de données suivants sont activés au niveau de l'instance. Pour en savoir plus, consultez Indicateurs de base de données compatibles, Indicateurs de base de données pour les fonctions AI optimisées et Configurer les indicateurs de base de données d'une instance.
Examinez les options de base de données de validation de la précision et de remplacement, que vous pouvez configurer au niveau de la session ou de la base de données à l'aide de SQL (
SETouALTER DATABASE) :google_ml_integration.proxy_models_enable_llm_fallback: contrôle si une requête se rabat sur un LLM distant si un modèle proxy n'est pas disponible. Cette option est définie suronpar défaut. Lorsqu'elle est définie suroff, la base de données génère une erreur au lieu de basculer vers le LLM distant.google_ml_integration.proxy_models_enable_accuracy_check: active les vérifications de précision de l'environnement d'exécution par rapport au LLM de référence. Cette option est définie suroffpar défaut.
Examinez les indicateurs de base de données de réentraînement périodique :
google_ml_integration.proxy_models_retraining_interval_minutes: contrôle la fréquence du job de réentraînement en arrière-plan, en minutes. La valeur par défaut est1440(24 heures). Le fait de définir cette valeur sur0désactive le réentraînement périodique.google_ml_integration.proxy_models_retraining_batch_size: contrôle le nombre de modèles réentraînés en une seule itération (la valeur par défaut est1).
Pour AlloyDB Omni, vérifiez que les extensions suivantes sont chargées dans
shared_preload_libraries:google_job_schedulergoogle_ml_integration
Générer des embeddings pour la table que vous souhaitez interroger. Pour en savoir plus, consultez Générer et gérer des embeddings vectoriels automatiques pour les tables volumineuses.
Tenez compte des exigences suivantes :
- La colonne de données source doit être de type
TEXTouVARCHAR. - La colonne d'embedding qui fournit l'entrée à la fonction AI optimisée doit être de type
REAL[]ouVECTOR. - Les fonctions d'IA optimisées ne sont disponibles que dans les régions où les modèles génératifs d'Agent Platform sont disponibles. Pour obtenir la liste des régions disponibles, consultez Déploiements et points de terminaison.
- La colonne de données source doit être de type
Exécuter une requête optimisée
Suivez cet exemple pour exécuter une instruction SELECT standard avec la fonction ai.if() :
Créez une table
restaurant_reviews. La colonnereviewqui contient les données sources est de typeTEXT, et la colonnereview_embeddingutilisée pour les requêtes est de typeVECTOR(768).CREATE TABLE restaurant_reviews ( id SERIAL, name VARCHAR(64), city VARCHAR(64), review TEXT, review_embedding VECTOR(768) );Générez des embeddings vectoriels pour les données sources à l'aide de la procédure
ai.initialize_embeddings():CALL ai.initialize_embeddings( model_id => 'text-embedding-005', table_name => 'restaurant_reviews', content_column => 'review', embedding_column => 'review_embedding' );La génération d'embeddings est nécessaire, car les fonctions IA optimisées s'appuient sur des embeddings vectoriels comme entrées de caractéristiques pour entraîner et évaluer le modèle de proxy léger. Au lieu d'envoyer du texte brut à un LLM distant pour chaque ligne, le modèle proxy effectue une inférence locale rapide directement sur les représentations vectorielles. Si les embeddings ne sont pas générés, AlloyDB ne peut pas entraîner le modèle proxy et revient à l'évaluation de toutes les lignes avec le LLM distant.
Notez les exigences d'embedding suivantes :
- La sortie
ai.if()est évaluée àNULLsi la colonne d'embedding contient des valeursNULL. L'entraînement et l'inférence du modèle nécessitent des embeddings valides. - La fonction
ai.if()génère une erreur si les dimensions d'embedding de la requête ne correspondent pas aux dimensions stockées dans le modèle de proxy entraîné.
Pour en savoir plus sur les options d'embedding et les actualisations incrémentielles, consultez Générer et gérer des embeddings vectoriels automatiques pour les tables volumineuses.
- La sortie
Exécutez une instruction
SELECTavec la fonctionai.if(). Cette requête planifie automatiquement l'entraînement d'un modèle proxy pour les fonctions d'IA optimisées en arrière-plan :SELECT r.name, r.city FROM restaurant_reviews r WHERE ai.if('Is the following a positive review? Review: ' || r.review, r.review_embedding, 'gemini-3.5-flash-lite') GROUP BY r.name, r.city HAVING COUNT(*) > 500;La première exécution de la requête déclenche l'entraînement de manière asynchrone. Pendant l'entraînement du modèle proxy, si l'option
google_ml_integration.proxy_models_enable_llm_fallbackest définie suron(valeur par défaut), AlloyDB revient à l'évaluation de la requête avec le LLM distant et renvoie un avertissement indiquant que la fonction d'IA optimisée n'est pas encore disponible. Sigoogle_ml_integration.proxy_models_enable_llm_fallbackest défini suroff, la requête renvoie une erreur au lieu de basculer.Les requêtes ultérieures correspondant à la même expression de contenu (
content_expr), à la même colonne d'embedding et à la même table utilisent le modèle de proxy entraîné pour l'accélération. La mise à jour des valeurs de ligne, la suppression de lignes ou l'ajout de données à la table n'entraînent pas le recours au LLM par AlloyDB. Le modèle proxy continue de traiter les données localement, et la dérive des données est gérée par un réentraînement périodique en arrière-plan.Les modèles de proxy sont identifiés de manière unique par le type de fonction, l'OID de la table, l'expression de contenu et la colonne d'embedding (
func_type,table_oid,content_expr,embedding_column). Grâce à cette architecture, vous pouvez partager des modèles entre différentes requêtes SQL tant que les entrées deai.if()restent inchangées.AlloyDB n'utilise pas le modèle de proxy existant. À la place, il lance l'entraînement en arrière-plan d'un nouveau modèle de proxy et se rabat sur le LLM distant (sous réserve de l'option
google_ml_integration.proxy_models_enable_llm_fallback) dans les scénarios suivants :- L'expression
CONTENTdansai.if()change (par exemple, la chaîne de requête ou l'expression de colonne concaténée est modifiée). - Le nom
EMBEDDING_COLUMNdansai.if()change. - Le paramètre
llm_model_idchange. - Si les vérifications de précision de l'exécution sont activées et que le modèle proxy échoue à la vérification de précision au début de la requête.
- L'expression
Entraînement en ligne et exécution bloquante
AlloyDB est compatible avec un workflow d'entraînement en ligne pour les fonctions optimisées, contrôlé par l'indicateur de base de données google_ml_integration.proxy_models_enable_online_training. Par défaut, cette option est définie sur off.
Lorsque cette option est activée et qu'une fonction ai.if() non entraînée est exécutée, la requête déclenche le processus d'entraînement et utilise l'exécution bloquante. La requête initiale bloque activement et attend que l'entraînement du modèle de proxy en arrière-plan se termine avant de continuer. Cela garantit que la requête utilise immédiatement le modèle proxy optimisé, ce qui évite les coûts d'inférence LLM à distance lors de l'exécution initiale.
La durée maximale pendant laquelle la requête bloque et attend la fin de l'entraînement en ligne est contrôlée par l'option google_ml_integration.proxy_models_training_wait_timeout (en secondes, la valeur par défaut est 60). Si l'entraînement ne se termine pas dans cet intervalle, la requête expire ou revient à l'état précédent en fonction de vos paramètres de remplacement.
Pour activer l'entraînement en ligne :
-- Enable online training (blocking execution)
SET google_ml_integration.proxy_models_enable_online_training = on;
-- Set the maximum wait timeout in seconds (default is 60)
SET google_ml_integration.proxy_models_training_wait_timeout = 30;
Configurer le remplacement par un LLM distant
Par défaut, le remplacement par le LLM distant est activé. Si un modèle proxy n'est pas entraîné, est en cours d'entraînement ou échoue aux vérifications de précision, la requête est redirigée vers le LLM distant et entraîne des coûts d'API Agent Platform standards.
Vous pouvez configurer le comportement de remplacement à l'aide de l'option de base de données google_ml_integration.proxy_models_enable_llm_fallback :
Lorsque le remplacement est activé (
on, par défaut) : si le modèle proxy n'est pas disponible, AlloyDB évalue la requête à l'aide du LLM distant et renvoie un avertissement :WARNING: Optimized AI Function is unavailable. Expect reduced performance.Lorsque le remplacement est désactivé (
off) : si le modèle proxy n'est pas disponible ou échoue à la validation de la justesse, la requête génère immédiatement une erreur au lieu d'appeler le LLM distant :ERROR: Optimized AI Function: Optimized model fallback to LLM prevented by GUC google_ml_integration.proxy_models_enable_llm_fallback
Pour désactiver le remplacement par LLM pour la session en cours :
SET google_ml_integration.proxy_models_enable_llm_fallback = off;
Pour désactiver le remplacement par LLM pour l'ensemble de la base de données :
ALTER DATABASE DATABASE_NAME SET google_ml_integration.proxy_models_enable_llm_fallback = off;
Remplacez DATABASE_NAME par le nom de votre base de données.
Configurer des vérifications de précision de l'exécution
Les vérifications de précision de l'environnement d'exécution évaluent un échantillon de lignes de la requête à l'aide du LLM distant pour s'assurer que le modèle proxy répond aux exigences de précision de référence avant l'exécution.
Les vérifications de précision sont contrôlées par l'indicateur de base de données google_ml_integration.proxy_models_enable_accuracy_check (désactivé par défaut).
Pour activer les contrôles de précision pour la session en cours :
SET google_ml_integration.proxy_models_enable_accuracy_check = on;
Pour désactiver les contrôles de précision pour la session en cours :
SET google_ml_integration.proxy_models_enable_accuracy_check = off;
Pour activer les contrôles de précision pour l'ensemble de la base de données :
ALTER DATABASE DATABASE_NAME SET google_ml_integration.proxy_models_enable_accuracy_check = on;
Afficher les modèles de proxy existants
Pour inspecter les modèles de proxy existants, vérifier leur état d'entraînement et examiner leurs métadonnées, interrogez la vue google_ml.optimized_functions_view (ou son alias dans le schéma ai, ai.optimized_functions_view) :
sql
SELECT * FROM ai.optimized_functions_view;
Pour obtenir une description des colonnes de cette vue, consultez Vue ai.optimized_functions_view.
Vous pouvez filtrer cette vue par table_name ou status pour vérifier si l'entraînement d'un modèle est terminé (READY) ou pour identifier les valeurs content_expr et embedding_column exactes nécessaires pour un réentraînement manuel.
Réentraîner et gérer des modèles de proxy
Les modèles de proxy sont entraînés sur les données présentes dans votre table au moment de l'entraînement initial. Si des données plus récentes sont ajoutées à la table, ou si des lignes sont modifiées ou supprimées, le modèle proxy peut devenir obsolète au fil du temps. Pour maintenir la précision à mesure que les données changent, les modèles de proxy peuvent être automatiquement réentraînés régulièrement en arrière-plan ou manuellement à la demande.
Réentraînement périodique en arrière-plan
Sur les instances dotées d'au moins 32 vCPU avec les paramètres de configuration par défaut, AlloyDB peut réentraîner périodiquement les modèles de proxy en arrière-plan.
Le réentraînement périodique est contrôlé par les indicateurs de base de données suivants :
google_ml_integration.proxy_models_retraining_interval_minutes: contrôle la fréquence du job de réentraînement en arrière-plan, en minutes. La valeur par défaut est1440(24 heures). La définir sur0désactive le réentraînement périodique.google_ml_integration.proxy_models_retraining_batch_size: contrôle le nombre de modèles réentraînés en une seule itération (la valeur par défaut est1).
Réentraînement manuel
Vous pouvez réentraîner manuellement les modèles de proxy à l'aide des fonctions du schéma ai (ou de leurs équivalents dans le schéma google_ml).
Réentraîner tous les modèles d'une table
Pour réentraîner tous les modèles de proxy associés à une table spécifique ou pour réentraîner un sous-ensemble filtré de modèles pour une table, appelez ai.retrain_optimized_models() :
SELECT ai.retrain_optimized_models(
table_name => 'restaurant_reviews',
embedding_column => 'review_embedding', -- Optional
content_expr => '(''Is the following a positive review? Review: ''::text || review)', -- Optional
llm_model_id => 'LLM_MODEL_ID' -- Optional
);
Pour obtenir une description des paramètres, consultez la section Fonction ai.retrain_optimized_models().
Réentraîner un modèle spécifique par ID de modèle
Pour réentraîner un modèle de proxy spécifique à l'aide de son identifiant de modèle unique, appelez ai.retrain_optimized_model() avec le paramètre model_id :
SELECT ai.retrain_optimized_model(model_id => 'MODEL_ID');
Pour obtenir une description des paramètres, consultez la section Fonction ai.retrain_optimized_model().
Réentraîner un modèle spécifique en fonction des paramètres d'entraînement du modèle
Pour réentraîner un modèle de proxy spécifique à l'aide de son nom de table, de son expression de contenu et de sa colonne d'embedding, appelez ai.retrain_optimized_model() :
SELECT ai.retrain_optimized_model(
table_name => 'restaurant_reviews',
embedding_column => 'review_embedding',
content_expr => '(''Is the following a positive review? Review: ''::text || review)',
llm_model_id => 'LLM_MODEL_ID' -- Optional
);
Pour obtenir une description des paramètres, consultez la section Fonction ai.retrain_optimized_model().
Supprimer les modèles de proxy
Vous pouvez supprimer des modèles de proxy individuels ou tous les modèles à l'aide des fonctions suivantes. Ces opérations doivent être effectuées par un utilisateur disposant des droits alloydbsuperuser ou d'autorisations accordées par un administrateur.
Pour trouver l'élément model_id interne requis pour supprimer un modèle de proxy spécifique, interrogez la table google_ml.proxy_models_expr_mapping :
SELECT model_id, table_oid::regclass, content_expr
FROM google_ml.proxy_models_expr_mapping;
-- Delete a specific proxy model
SELECT ai.delete_optimized_model('com_if_12345_67890');
-- Delete all proxy models and stop the background automated retraining job
CALL ai.delete_all_optimized_models();
Surveillance
Vous pouvez surveiller les jobs d'entraînement des nœuds de calcul en arrière-plan et vérifier l'état opérationnel du modèle.
Vérifier l'état et l'historique de l'entraînement du modèle
Pour vérifier si l'entraînement d'un modèle proxy est terminé, a échoué ou est en cours de réentraînement, interrogez ai.optimized_functions_view :
SELECT table_name, content_expr, status, last_trained_at, training_duration
FROM ai.optimized_functions_view;
La colonne status indique l'état opérationnel actuel du modèle et fournit les valeurs suivantes :
READY: l'entraînement du modèle proxy s'est terminé correctement et le modèle est prêt à accélérer les requêtes entrantes.UNTRAINED: le modèle a été enregistré ou planifié, mais l'entraînement en arrière-plan n'est pas encore terminé. Si l'entraînement initial en arrière-plan échoue, le modèle reste à l'étatUNTRAINEDet les requêtes sont redirigées vers le LLM distant (ou une erreur est renvoyée si la redirection est désactivée).RETRAINING_IN_PROGRESS: le réentraînement en arrière-plan est en cours.RETRAINING_FAILED: l'exécution de l'entraînement en arrière-plan ou manuel le plus récent a échoué. Dans la plupart des cas, si des pondérations de modèle pré-réentraînement existent, AlloyDB continue de les utiliser pour l'inférence. Si les pondérations de modèle existantes ne sont pas disponibles (ou si les vérifications de précision de l'environnement d'exécution échouent), AlloyDB évalue les requêtes à l'aide du LLM distant (sous réserve degoogle_ml_integration.proxy_models_enable_llm_fallback) jusqu'à ce que le modèle soit réentraîné avec succès.
Pour en savoir plus sur toutes les colonnes disponibles dans cette vue, consultez Afficher les modèles de proxy existants.
Limites
- Les fonctions d'IA optimisées ne sont compatibles qu'avec la fonction
ai.if(). - Le réentraînement automatique périodique en arrière-plan des modèles de proxy n'est pas compatible avec les instances de base de données comportant moins de 32 vCPU.
- Sécurité au niveau des lignes (RLS) : les modèles entraînés sur des tables à l'aide de règles de sécurité au niveau des lignes (RLS) peuvent divulguer des informations de sécurité en s'entraînant avec les autorisations d'un utilisateur initiateur spécifique. L'entraînement de modèles de proxy sur des tables avec des règles RLS est désactivé.
- Modifications d'entrée : si vous modifiez la colonne de contenu source, la colonne d'embedding, la chaîne de requête ou l'ID du modèle LLM de base fourni à
ai.if(), le modèle proxy existant est ignoré et une nouvelle requête d'entraînement en arrière-plan est lancée pour cette combinaison. - Restrictions SQL :
- La requête doit contenir une clause
FROMvalide. - Tous les arguments de la fonction AI doivent provenir du même alias de table.
- Incluez des colonnes dans l'expression
ai.if()en tant que colonnes sources pour l'embedding. - Ne placez pas la fonction
ai.if()dans une sous-requête ou une expression de table commune (CTE).
- La requête doit contenir une clause