Analisar o sentimento do texto

Selecione uma versão da documentação:

A função ai.analyze_sentiment é uma ferramenta de IA integrada do AlloyDB que classifica o sentimento do texto como positivo, negativo ou neutro. Ao incorporar esse recurso diretamente no banco de dados, o AlloyDB Omni permite processar dados não estruturados sem criar pipelines complexos de extração, transformação e carregamento (ETL) ou integrações de serviços externos.

A função de análise de sentimento oferece os seguintes benefícios:

  • Conhecimento do mundo: a vasta coleção de fatos, conceitos, relações e compreensão contextual do mundo que os modelos de linguagem grandes (LLMs) adquirem durante a fase de pré-treinamento.
  • Análise em tempo real: traz o conhecimento do mundo do Gemini para os dados corporativos usando SQL.
  • Escalonabilidade: oferece suporte ao processamento baseado em matrizes e cursores para lidar com milhares de linhas de maneira eficiente.
  • Simplicidade: fornece uma abstração de alto nível que gerencia automaticamente a invocação de modelos e a preparação de dados.

A função de análise de sentimento feita pela IA do AlloyDB é compatível com vários casos de uso, incluindo os seguintes:

  • Feedback do cliente: classifique milhares de avaliações de produtos brutas e não estruturadas para identificar os níveis de satisfação do cliente.
  • Monitoramento de redes sociais: analise o sentimento em menções ou comentários em redes sociais para avaliar a percepção do público sobre uma marca.

Antes de começar

Verifique se você atende aos seguintes requisitos antes de usar a função ai.analyze_sentiment.

Ativar a extensão

Verifique se você tem a extensão google_ml_integration (versão 1.6.3 ou mais recente) instalada com o mecanismo de consulta de IA ativado.

Para ativar a flag google_ml_integration.enable_ai_query_engine no AlloyDB Omni, use o comando SET. Essa flag controla o acesso a funções de IA, como ai.analyze_sentiment.

  1. Verifique se a extensão google_ml_integration é a versão 1.6.3 ou mais recente. Para verificar a versão, execute o seguinte:

    SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';

    Se você precisar atualizar a extensão, execute o seguinte comando:

    ALTER EXTENSION google_ml_integration UPDATE;

  2. Ative a flag para a sessão atual ou para todo o banco de dados. Para ativar a flag na sessão atual, execute o seguinte:

    SET google_ml_integration.enable_ai_query_engine = 'on';

    Essa mudança não exige a reinicialização do banco de dados. O valor padrão dessa flag é off.

Criar uma tabela de exemplo

Para seguir os exemplos da função de análise de sentimento neste documento, crie uma tabela e preencha-a com as seguintes avaliações de filmes.

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

Analisar o sentimento de uma única string

Para avaliar o sentimento de uma única entrada de texto, use a versão escalar 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.
);

O exemplo a seguir mostra como realizar uma análise de sentimento em nível de linha em dados de texto armazenados em uma tabela chamada reviews com as colunas id e review_content para armazenar dados de avaliação. O exemplo executa uma consulta SELECT que aplica a função ai.analyze_sentiment() à coluna review_content para cada linha na tabela. Essa função processa cada avaliação individualmente e retorna o sentimento calculado (positive, negative ou neutral).

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

Veja um exemplo de saída:

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

Analisar sentimentos em lotes

Para melhorar o desempenho em conjuntos de dados maiores, use a versão da função baseada em matriz para processar várias strings em uma única chamada.

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

WITH sentiment_results AS (
SELECT
  ARRAY_AGG(id ORDER BY id) as ids,
  ai.analyze_sentiment( 
    inputs => array_agg(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;

Veja um exemplo de saída:

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

Analisar sentimentos usando cursores

A função baseada em cursor é destinada ao processamento eficiente de grandes conjuntos de dados, porque permite que o sistema transmita dados pelo modelo de IA em lotes gerenciáveis sem exigir que todos os dados sejam carregados na memória de uma só vez.

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

Agora você pode usar a função ai.analyze_sentiment. Como ele espera um REFCURSOR, é necessário abrir um cursor para os dados de entrada que você quer analisar. Neste exemplo, você analisa o review_content da tabela reviews.

O exemplo a seguir mostra como alimentar dados para a função ai.analyze_sentiment linha por linha usando um cursor:

-- Start a transaction
BEGIN;

-- Declare a cursor for the review content
DECLARE review_cursor REFCURSOR;

-- 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
DECLARE result_cursor REFCURSOR;
SELECT ai.analyze_sentiment(
    input_cursor => review_cursor,
    batch_size => 5  -- Optional: Process in batches of 5
) INTO result_cursor;

-- Fetch and display results from the result_cursor
-- The exact way to fetch from a REFCURSOR depends on the SQL environment.
-- This is a conceptual example.
FETCH ALL FROM result_cursor;

-- Close the cursors
CLOSE review_cursor;
CLOSE result_cursor;

-- End the transaction
COMMIT;

A saída é esta:

              input               |  output
----------------------------------+----------
 This movie is very good          | positive
 The actors play the parts well   | positive
 I like the music in this film    | positive
 The story is easy to follow      | positive
 Many people will enjoy this show | positive
 The film is too long             | negative
 I do not like the ending         | negative
 This movie is very boring        | negative
 The story is okay                | neutral
 Some parts are fine              | neutral

A seguir