Accélérer les requêtes à l'aide de fonctions d'IA optimisées

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.

  1. 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.

  2. 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).

  3. 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 :

Schéma de flux des fonctions d'IA optimisées

Avant de commencer

Avant d'utiliser les fonctions d'IA optimisées, procédez comme suit :

Exécuter une requête optimisée

Suivez cet exemple pour exécuter une instruction SELECT standard avec la fonction ai.if() :

  1. Créez une table restaurant_reviews. La colonne review qui contient les données sources est de type TEXT, et la colonne review_embedding utilisée pour les requêtes est de type VECTOR(768).

    CREATE TABLE restaurant_reviews (
        id SERIAL,
        name VARCHAR(64),
        city VARCHAR(64),
        review TEXT,
        review_embedding VECTOR(768)
    );
    

  2. 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 à NULL si la colonne d'embedding contient des valeurs NULL. 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.

  3. Exécutez une instruction SELECT avec la fonction ai.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_fallback est définie sur on (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. Si google_ml_integration.proxy_models_enable_llm_fallback est défini sur off, 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 de ai.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 CONTENT dans ai.if() change (par exemple, la chaîne de requête ou l'expression de colonne concaténée est modifiée).
    • Le nom EMBEDDING_COLUMN dans ai.if() change.
    • Le paramètre llm_model_id change.
    • 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.

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 :

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'état UNTRAINED et 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 de google_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 FROM valide.
    • 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).

Étapes suivantes