Classer du texte

La fonction ai.classify est un outil d'IA AlloyDB intégré qui classe les entrées de texte dans un ensemble de classes ou d'étiquettes que vous définissez. En intégrant cette fonctionnalité directement dans la base de données, AlloyDB pour PostgreSQL vous permet de traiter des données non structurées sans créer de pipelines ETL (extraction, transformation et chargement) complexes ni d'intégrations de services externes.

La fonction de classification de texte offre les avantages suivants :

  • Classification en temps réel : apporte les connaissances de Gemini sur le monde aux données d'entreprise à l'aide de SQL.
  • Évolutivité : compatible avec le traitement par lot intelligent pour les fonctions d'IA (également appelé accélération des fonctions d'IA), une fonctionnalité d'optimisation automatique de l'exécution des requêtes dans AlloyDB AI qui regroupe de manière transparente les appels de fonctions d'IA scalaires individuels, ligne par ligne, en requêtes de modèle par lot en arrière-plan lors de l'exécution des requêtes. Il est également compatible avec le traitement basé sur des tableaux et des curseurs pour gérer efficacement des milliers de lignes.
  • Simplicité : fournit une abstraction de haut niveau qui gère automatiquement l'appel du modèle et la préparation des données.

La fonction de classification de texte d'AlloyDB AI est compatible avec plusieurs cas d'utilisation, y compris les suivants :

  • Classification par thème : attribuez des thèmes prédéfinis (tels que le sport, la technologie ou la finance) à des documents ou des articles.
  • Détection du spam : identifier les e-mails, commentaires ou messages entrants comme du spam.
  • Reconnaissance de l'intention : déterminer l'objectif de l'utilisateur derrière une requête, comme réserver un vol, consulter la météo ou commander à manger.

Avant de commencer

Assurez-vous de remplir les conditions suivantes avant d'utiliser la fonction ai.classify :

  • Version de PostgreSQL : la fonction ai.classify est compatible avec PostgreSQL 18 et versions ultérieures. Assurez-vous que votre cluster AlloyDB exécute PostgreSQL 18 ou une version ultérieure. Pour en savoir plus, consultez la section Versions de base de données compatibles.
  • Version de l'extension : assurez-vous que la dernière version de l'extension google_ml_integration (version 1.6.1 ou ultérieure) est installée et que la fonctionnalité d'aperçu est activée.

Activer l'extension

Assurez-vous que la dernière version de l'extension google_ml_integration (version 1.6.1 ou ultérieure) est installée et que la fonctionnalité d'aperçu est activée.

Pour activer les options google_ml_integration.enable_ai_query_engine et google_ml_integration.enable_preview_ai_functions dans AlloyDB, utilisez la commande SET. Ces options contrôlent l'accès au moteur de requêtes d'IA et aux fonctions d'IA en preview telles que ai.classify.

  1. Assurez-vous que votre extension google_ml_integration est de version 1.6.1 ou ultérieure. Pour vérifier la version, exécutez la commande suivante :

    SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';

  2. Activez les options pour la session en cours ou pour l'ensemble de la base de données. Pour activer les options pour votre session actuelle, exécutez la commande suivante :

    SET google_ml_integration.enable_ai_query_engine = 'on';
SET google_ml_integration.enable_preview_ai_functions = 'on';

    Cette modification ne nécessite pas de redémarrer la base de données. La valeur par défaut de ces options est off.

Créer un exemple de table

Pour suivre les exemples de la fonction de classification de ce document, créez une table et remplissez-la avec les exemples d'avis sur les produits suivants.

CREATE TABLE IF NOT EXISTS product_reviews (
    id INT PRIMARY KEY,
    review TEXT
);

INSERT INTO product_reviews (id, review) VALUES
(1, 'Fantastic, would buy again!'),
(2, 'Broken on arrival.'),
(3, 'Mediocre, not worth the price.');

Classer une seule chaîne

Pour catégoriser une seule entrée de texte, utilisez la version scalaire de ai.classify. Pour obtenir une documentation détaillée sur l'API, consultez la documentation de référence sur ai.classify.

SELECT ai.classify(
  input => 'TEXT_CONTENT',
  categories => ARRAY['CATEGORY1', 'CATEGORY2', 'CATEGORY3'],
  examples => 'EXAMPLES', -- Optional
  output_mode => 'OUTPUT_MODE', -- Optional. Can be 'single' or 'multi'.
  model_id => 'MODEL_ID' -- Optional. The default value is gemini-3.5-flash-lite.
);

Classer du texte dans des catégories mutuellement exclusives

L'exemple suivant montre un cas d'utilisation de base consistant à classer un seul texte dans l'une des catégories mutuellement exclusives :

SELECT ai.classify(
  input => 'This is a sales report for Q1.',
  categories => ARRAY['Report', 'Invoice', 'Memo']
);

Voici un exemple de résultat :

Report

Classer un sujet multi-étiquette

L'exemple suivant classe un titre d'actualité dans plusieurs thèmes en définissant output_mode sur 'multi' et en fournissant des descriptions de catégories :

SELECT ai.classify(
  input => 'The government announced new regulations on AI development, citing both economic opportunities and potential security risks.',
  categories => ARRAY[
    ARRAY['politics', 'Questions about politics'],
    ARRAY['technology', 'Questions about technology'],
    ARRAY['security', 'Questions about security']
  ],
  output_mode => 'multi'
);

Voici un exemple de résultat :

politics,technology,security

Utiliser des catégories avec des descriptions

L'exemple suivant illustre la méthode recommandée pour fournir des catégories à l'aide d'un format de tableau 2D avec des libellés et des descriptions pour plus de clarté :

SELECT ai.classify(
  input => 'The patient reported mild fever and headache.',
  categories => ARRAY[
    ARRAY['urgent', 'Requires immediate medical attention'],
    ARRAY['non-urgent', 'Routine check-up or minor symptoms'],
    ARRAY['query', 'A question about services or appointments']
  ]
);

Voici un exemple de résultat :

non-urgent

Fournir des exemples few-shot

L'exemple suivant montre comment guider la classification du modèle en fournissant des exemples d'entrées et de sorties attendues :

SELECT ai.classify(
  input => 'Is this item returnable after 90 days?',
  categories => ARRAY[
    ARRAY['policy', 'Questions about return, warranty, or other policies'],
    ARRAY['shipping', 'Questions about order shipment and delivery'],
    ARRAY['payment', 'Questions about payment methods or issues'],
    ARRAY['other', 'Any other type of question']
  ],
  examples => '[
    {"input": "When will my order arrive?", "output": "shipping"},
    {"input": "What is the warranty on this?", "output": "policy"},
    {"input": "My discount code isn''t working.", "output": "payment"}
  ]'
);

Voici un exemple de résultat :

policy

Utiliser un ID de modèle spécifique

L'exemple suivant montre comment utiliser une version ou un type de modèle spécifique en référençant son ID :

SELECT ai.classify(
  input => 'This new song is a banger!',
  categories => ARRAY[
    ARRAY['positive', 'Expresses approval or enjoyment'],
    ARRAY['negative', 'Expresses disapproval or dislike']
  ],
  model_id => 'MODEL_ID'
);

Voici un exemple de résultat :

positive

Remplacez MODEL_ID par l'ID d'un modèle préenregistré compatible ou d'un modèle personnalisé que vous avez enregistré. Pour obtenir la liste des modèles préenregistrés compatibles, consultez Modèles d'IA compatibles. Pour savoir comment enregistrer d'autres points de terminaison de modèle, consultez Enregistrer et appeler des modèles d'IA distants à l'aide de la gestion des points de terminaison de modèle.

Classer par lots

Lorsque vous classez de grands ensembles de données sur plusieurs lignes, vous pouvez optimiser les performances en utilisant le traitement par lot intelligent pour les fonctions IA ou en utilisant la version basée sur un tableau de ai.classify.

Traitement par lot intelligent

Pour accélérer les requêtes qui exécutent des ai.classify scalaires sur plusieurs lignes sans écrire de requêtes d'agrégation de tableaux complexes, activez le traitement par lot intelligent pour les fonctions d'IA en définissant l'indicateur de base de données google_ml_integration.enable_ai_function_acceleration sur on :

SET google_ml_integration.enable_ai_function_acceleration = 'on';

Lorsque cette option est activée, AlloyDB regroupe automatiquement les appels scalaires ai.classify individuels en lots intelligents en arrière-plan.

SELECT
  id,
  ai.classify(
    input => review,
    categories => ARRAY['positive', 'neutral', 'negative']
  ) AS sentiment
FROM product_reviews
ORDER BY id;

Traitement par lot basé sur un tableau

Pour un contrôle explicite du traitement par lot sur des ensembles de données plus volumineux, utilisez la version basée sur un tableau de ai.classify pour traiter plusieurs entrées à la fois en transmettant un tableau SQL d'entrées. Pour obtenir une documentation détaillée sur l'API, consultez la documentation de référence sur ai.classify.

SELECT ai.classify(
  inputs => TEXT[],
  categories => TEXT[][],
  examples => TEXT, -- Optional.
  output_mode => VARCHAR, -- Optional. The default value is single.
  batch_size => INT, -- Optional. The default value is 10.
  model_id => VARCHAR(100) -- Optional. The default value is gemini-3.5-flash-lite.
);

L'exemple suivant classe plusieurs avis à la fois :

SELECT unnest(
  ai.classify(
    inputs => ARRAY(SELECT review FROM product_reviews ORDER BY id),
    categories => ARRAY[
      ARRAY['positive', 'Good sentiment'],
      ARRAY['neutral',  'Neither good nor bad sentiment'],
      ARRAY['negative', 'Bad sentiment']
    ],
    batch_size => 5
  )
) AS sentiment;

Voici un exemple de résultat :

 sentiment
-----------
 positive
 negative
 negative

Classer à l'aide de curseurs

La fonction basée sur un curseur traite efficacement les grands ensembles de données en permettant au système de diffuser les données via le modèle d'IA par lots gérables, sans avoir à charger toutes les données en mémoire en même temps. Pour en savoir plus, consultez la documentation de référence sur ai.classify.

La signature de la fonction pour la version basée sur un curseur de ai.classify est la suivante :

CREATE OR REPLACE FUNCTION ai.classify(
    input_cursor REFCURSOR,
    categories TEXT[][],
    examples TEXT DEFAULT NULL,
    output_mode VARCHAR DEFAULT NULL,
    batch_size INT DEFAULT NULL,
    model_id VARCHAR(100) DEFAULT NULL)
  RETURNS REFCURSOR

L'exemple suivant montre comment utiliser un curseur pour fournir des entrées à ai.classify :

DO $$
DECLARE
  cur REFCURSOR;
  result_cur REFCURSOR;
  input_val TEXT;
  sentiment TEXT;
BEGIN
  OPEN cur FOR SELECT review FROM product_reviews ORDER BY id;

  result_cur := ai.classify(
    input_cursor => cur,
    categories => ARRAY[
      ARRAY['positive', 'Good sentiment'],
      ARRAY['neutral',  'Neither good nor bad sentiment'],
      ARRAY['negative', 'Bad sentiment']
    ],
    batch_size => 20
  );

  LOOP
    FETCH result_cur INTO input_val, sentiment;
    EXIT WHEN NOT FOUND;
    RAISE NOTICE 'Sentiment: %', sentiment;
  END LOOP;

  CLOSE result_cur;
  CLOSE cur;
END $$;

Étapes suivantes