Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Analyser les sentiments d'un texte

La fonction ai.analyze_sentiment est un outil d'IA AlloyDB intégré qui classe le sentiment d'un texte comme positif, négatif ou neutre. En intégrant cette fonctionnalité directement dans la base de données, AlloyDB pour PostgreSQL vous permet d'appliquer la compréhension du langage de Gemini aux données d'entreprise non structurées en temps réel à l'aide de SQL. Cela permet de prendre en charge le traitement par lot basé sur des tableaux et des curseurs sur des milliers de lignes sans pipelines ETL (extraction, transformation et chargement) complexes.

Vous pouvez utiliser ai.analyze_sentiment pour classer les avis sur les produits non structurés et les commentaires des clients, ou analyser les mentions sur les réseaux sociaux pour évaluer la perception de la marque.

Avant de commencer

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

Activer l'extension

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

Pour activer l'option google_ml_integration.enable_preview_ai_functions dans AlloyDB, utilisez la commande SET. Cette option contrôle l'accès aux fonctions AI en version preview, comme ai.analyze_sentiment.

Assurez-vous que votre extension google_ml_integration est en version 1.6.1 ou ultérieure. Vous pouvez vérifier la version en exécutant la commande suivante :
```
SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';
```
Si vous devez passer à une version incluant ces fonctions en preview, appelez la commande suivante :
```
CALL google_ml.upgrade_to_preview_version();
```
Activez l'option pour la session en cours ou pour l'ensemble de la base de données. Pour activer l'option pour votre session actuelle, exécutez la commande suivante :
```
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 cette option est off.

Créer un exemple de table

Pour suivre les exemples de la fonction d'analyse des sentiments de ce document, créez une table et renseignez-la avec les avis de films suivants.

CREATE TABLE IF NOT EXISTS reviews (
    id INT PRIMARY KEY,
    review_content TEXT
);

INSERT INTO reviews (id, review_content) VALUES 
(1, 'This movie is very good'),
(2, 'The actors play the parts well'),
(3, 'I like the music in this film'),
(4, 'The story is easy to follow'),
(5, 'Many people will enjoy this show'),
(6, 'The film is too long'),
(7, 'I do not like the ending'),
(8, 'This movie is very boring'),
(9, 'The story is okay'),
(10, 'Some parts are fine');

Analyser les sentiments d'une seule chaîne

Pour évaluer le sentiment d'une seule entrée de texte, utilisez la version scalaire de ai.analyze_sentiment.

SELECT ai.analyze_sentiment(
  input => 'TEXT_CONTENT',
  model_id => 'MODEL_ID' -- Optional. The default value is gemini-3.5-flash-lite.
);

L'exemple suivant montre comment effectuer une analyse des sentiments au niveau des lignes sur des données textuelles stockées dans une table nommée reviews avec les colonnes id et review_content pour stocker les données d'avis. L'exemple exécute une requête SELECT qui applique la fonction ai.analyze_sentiment() à la colonne review_content pour chaque ligne de la table. Cette fonction traite chaque avis individuellement et renvoie le sentiment calculé (positive, negative ou neutral).

--- Row Level sentiment analysis
SELECT ai.analyze_sentiment(review_content) FROM reviews;

Voici un exemple de résultat :

 id | analyze_sentiment
----+-------------------
  1 | positive
  2 | positive
  3 | positive
  4 | positive
  5 | positive
  6 | negative
  7 | negative
  8 | negative
  9 | neutral
 10 | neutral

Analyser les sentiments par lots

Pour de meilleures performances sur des ensembles de données plus volumineux, utilisez la version basée sur un tableau de la fonction pour traiter plusieurs chaînes en un seul appel.

SELECT ai.analyze_sentiment(
  inputs => ARRAY['TEXT_1', 'TEXT_2'],
  batch_size => BATCH_SIZE, -- Optional. The default value is 10.
  model_id => 'MODEL_ID' -- Optional. The default value is gemini-3.5-flash-lite.
);

L'exemple suivant analyse les sentiments des avis clients d'une table nommée reviews.

WITH sentiment_results AS (
SELECT
  ARRAY_AGG(id ORDER BY id) as ids,
  ai.analyze_sentiment(
    inputs => array_agg( 'Please analyze the sentiment of this review: ' || review_content
      ORDER BY id),
    batch_size => 15) as sentiments 
FROM reviews
),
correlated_results AS (
    SELECT ids[i] as id, sentiments[i] as sentiment
    FROM sentiment_results,
    generate_series(1, array_length(ids, 1)) AS i
)
SELECT reviews.id, correlated_results.sentiment as sentiment
FROM reviews
JOIN correlated_results ON reviews.id = correlated_results.id
ORDER BY reviews.id DESC;

Voici un exemple de résultat :

 id | sentiment
----+-----------
  1 | positive
  2 | positive
  3 | positive
  4 | positive
  5 | positive
  6 | negative
  7 | negative
  8 | negative
  9 | neutral
 10 | neutral

Analyser les sentiments à l'aide de curseurs

La fonction basée sur un curseur est destinée à traiter efficacement de grands ensembles de données, car elle permet au système de diffuser des données via le modèle d'IA par lots gérables sans nécessiter le chargement de toutes les données en mémoire en même temps.

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

CREATE OR REPLACE FUNCTION ai.analyze_sentiment(
    input_cursor REFCURSOR,
    batch_size INT DEFAULT NULL,
    model_id VARCHAR(100) DEFAULT NULL)
  RETURNS REFCURSOR

Vous pouvez maintenant utiliser la fonction ai.analyze_sentiment. Comme elle attend un REFCURSOR, vous devez ouvrir un curseur pour les données d'entrée que vous souhaitez analyser. Dans cet exemple, vous analysez l'élément review_content de la table reviews.

L'exemple suivant montre comment transmettre des données à la fonction ai.analyze_sentiment ligne par ligne à l'aide d'un curseur :

-- Run the cursor logic in an anonymous PL/pgSQL block
DO $$
DECLARE
    -- Declare a cursor for the review content
    review_cursor REFCURSOR;
    result_cursor REFCURSOR;
    result_record RECORD;
BEGIN
    -- Open the cursor with the query to fetch the review content
    OPEN review_cursor FOR SELECT review_content FROM reviews;

    -- Call the AI function, passing the cursor
    -- This function will return another cursor containing the results
    result_cursor := ai.analyze_sentiment(
            input_cursor => review_cursor,
        batch_size => 5  -- Optional: Process in batches of 5. The default value is 10.
    );

    -- Fetch and display results from the result_cursor
    LOOP
        FETCH result_cursor INTO result_record;
        EXIT WHEN NOT FOUND;
        RAISE NOTICE '%', result_record;
    END LOOP;

    -- Close the cursors
    CLOSE review_cursor;
    CLOSE result_cursor;
-- End the anonymous block
END $$;

Voici le résultat :

      review_content            | sentiment | score
------------------------------+-----------+-------
This movie is very good        | Positive  |   0.9
The actors play the parts well | Positive  |   0.8
I like the music in this film  | Positive  |   0.8
The story is easy to follow    | Positive  |   0.7
Many people will enjoy this show | Positive  |   0.8
The film is too long           | Negative  |  -0.6
I do not like the ending       | Negative  |  -0.8
This movie is very boring      | Negative  |  -0.9
The story is okay              | Neutral   |   0.1
Some parts are fine            | Neutral   |   0.2

Étapes suivantes

Résumer du contenu
Consultez la présentation des fonctions AI.