Riassumere i contenuti

Anteprima

Questa funzionalità è soggetta ai "Termini dell'offerta pre-GA" nella sezione dei Termini di servizio generali dei Termini specifici dei servizi. Le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per ulteriori informazioni, consulta le descrizioni della fase di lancio.

Nota: questo lancio sperimentale è un'offerta pre-GA.

La funzione ai.summarize utilizza modelli linguistici di grandi dimensioni (LLM) come Gemini per riformulare e riorganizzare il testo di input nella sua forma più essenziale. Questa funzione acquisisce la tesi principale di un documento preservando il tono e le sfumature originali dell'autore. Utilizzando questa funzione, puoi estrarre risultati e conclusioni chiave da set di dati di grandi dimensioni senza revisione manuale e controllare la lunghezza dell'output specificando vincoli come il numero di parole o i limiti di frasi nel prompt. Puoi anche utilizzare l'elaborazione batch o gli snapshot basati su cursore per elaborare milioni di righe in modo asincrono.

Nota :la funzione ai.summarize è supportata su PostgreSQL versione 17 e successive.

La funzione di riepilogo dei contenuti di AlloyDB AI supporta vari casi d'uso, inclusi, a titolo esemplificativo:

• Trascrizioni delle riunioni: riassumi il testo della conversazione per concentrarti su decisioni e attività.
• Documentazione tecnica: riassumi metodologie, risultati e implicazioni complessi in panoramiche di alto livello.
• Log dell'assistenza clienti: aggrega più recensioni degli utenti o richieste di assistenza in un unico riepilogo unificato dei problemi comuni.

Prima di iniziare

Prima di utilizzare la funzione ai.summarize, assicurati di soddisfare i seguenti requisiti.

Attivare l'estensione

Assicurati di aver installato l'ultima versione dell'estensione google_ml_integration.enable_preview_ai_functions (versione 1.5.7 o successiva) con la funzionalità di anteprima attivata.

Per attivare il flag google_ml_integration.enable_preview_ai_functions in AlloyDB, utilizza il comando SET. Questo flag controlla l'accesso alle funzioni di AI di anteprima come ai.summarize.

1. Assicurati che la versione di google_ml_integration extension sia 1.5.7 o successive. Puoi controllare la versione eseguendo il comando seguente:

   SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';
   

   Se devi eseguire l'upgrade a una versione che include queste funzioni di anteprima, chiama quanto segue:

   CALL google_ml.upgrade_to_preview_version();
   

2. Attiva il flag per la sessione corrente o per l'intero database. Per abilitare il flag per la sessione corrente, esegui questo comando:

   SET google_ml_integration.enable_preview_ai_functions = 'on';
   

   Questa modifica non richiede il riavvio del database. Il valore predefinito di questo flag è off.

Creare una tabella di esempio

Per seguire gli esempi della funzione di riepilogo in questo documento, crea una tabella e compilala con le seguenti recensioni di film.

CREATE TABLE movie_reviews (
    id INT PRIMARY KEY,
    movie_id INT,
    review TEXT
);

INSERT INTO movie_reviews (id, movie_id, review) VALUES
(1, 1, 'The Midnight Echo represents a masterclass in atmospheric tension. The cinematography captures the isolation of the frozen tundra perfectly while the lead actor delivers a superb performance. Although the pacing slows down significantly in the second act, the final twist remains unexpected. This is a truly remarkable experience.'),
(2, 1, 'Neon Velocity delivers high octane action but lacks the narrative depth required to make the stakes feel real. The visual effects are undeniably stunning, creating a vibrant cyberpunk world that pops off the screen. However, the dialogue feels cliched and the secondary characters are thin. This film is a shallow blockbuster.'),

-- more rows are present in this table

Riassumere una singola stringa

Per elaborare un singolo blocco di testo, utilizza la versione scalare di ai.summarize.

SELECT ai.summarize(
  prompt => 'TEXT_CONTENT',
  model_id => 'MODEL_ID' -- Optional
);

Esegui la seguente query di esempio per fornire un riepilogo conciso delle recensioni dei film:

SELECT ai.summarize(review) FROM movie_reviews;

Di seguito è riportato l'output di esempio:

 id |                         summary
----+-----------------------------------------------------------
  1 | "Atmospheric thriller with a haunting performance and shocking twist."
  2 | "Visually stunning cyberpunk action film lacks narrative depth."
...

Riassumere in batch

Per elaborare più record in modo efficiente, utilizza la versione basata su array.

SELECT ai.summarize(
  prompts => TEXT[],
  batch_size => INT, -- Optional. The default is 10.
  model_id => VARCHAR(100) -- Optional. The default value is gemini-2.5-flash-lite.
);

L'esempio seguente mostra come utilizzare la versione basata su array della funzione ai.summarize per elaborare in modo efficiente più record di testo in una singola chiamata.

WITH summarized_results AS (
SELECT
  ARRAY_AGG(id ORDER BY id) as ids,
  ai.summarize(
    prompts => array_agg( 'Please summarize this in max 10 words, review : ' || review
      ORDER BY id),
    batch_size => 15) as summaries
FROM movie_reviews
),
correlated_results AS (
    SELECT ids[i] as ID, summaries[i] as summary
    FROM summarized_results,
    generate_series(1, array_length(ids, 1)) AS i
)
SELECT movie_reviews.id, correlated_results.summary as summary
FROM movie_reviews
JOIN correlated_results ON movie_reviews.id = correlated_results.id
ORDER BY movie_reviews.id DESC ;

Di seguito è riportato l'output di esempio:

 id | summary
---+----------------------------------------------------------------------------
  1 | "Masterclass in tension, haunting performance with a twist."
  2 | "High octane action, stunning visuals, shallow blockbuster."
  3 | "Gentle, moving exploration of  emotional honesty."

Riassumere utilizzando i cursori

Puoi utilizzare i cursori per gestire in modo efficiente set di recensioni potenzialmente di grandi dimensioni, inserirli in una funzione AI e poi elaborare i risultati uno per uno per memorizzarli di nuovo nel database.

L'esempio seguente mostra come utilizzare i cursori con la funzione ai.summarize per elaborare in modo efficiente le righe della tabella movie_reviews, generare un riepilogo per ogni recensione e archiviare questi riepiloghi in una nuova tabella denominata review_summaries. Questo approccio basato sui cursori è utile per gestire set di dati di grandi dimensioni che potrebbero essere troppo grandi per essere elaborati in un singolo batch o per essere contenuti tutti in una volta nella memoria.

Il parametro input_cursor accetta un REFCURSOR. Ciò significa che devi fornire un nome cursore, che funge da puntatore ai risultati di una query SQL. La funzione ai.summarize recupera quindi i dati da questo cursore da utilizzare come input per il riepilogo.

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

Il seguente esempio crea una tabella review_summaries (se necessario), quindi itera le recensioni di film, genera un riepilogo conciso per ciascuna utilizzando una funzione AI e memorizza i riepiloghi collegati ai relativi ID recensione originali nella tabella.

-- Create a table to store the results
CREATE TABLE IF NOT EXISTS review_summaries (
    review_id INT, 
    summary_text TEXT
);

DO $$
DECLARE
    -- Use descriptive cursor and variable names
    review_cursor   REFCURSOR;
    result_record   RECORD;
    cursor_response  REFCURSOR;
    id_array        INT[];
    idx             INT := 1; 
BEGIN
    -- 1. Open cursor for the input text
    OPEN review_cursor FOR 
        SELECT review AS prompt FROM movie_reviews ORDER BY id;

    -- 2. Call the AI summarize function
    cursor_response := ai.summarize(
        prompt       => 'Please summarize the following review in max 10 words: ',
        input_cursor => review_cursor
    );

    -- 3. Map IDs into an array to maintain relational integrity during the loop
    SELECT ARRAY_AGG(id ORDER BY id) INTO id_array FROM movie_reviews;

    -- 4. Iterate through AI results and insert into the results table
    LOOP
        FETCH cursor_response INTO result_record;
        EXIT WHEN NOT FOUND;

        INSERT INTO review_summaries (review_id, summary_text)
        VALUES (id_array[idx], result_record.output);

        idx := idx + 1;
    END LOOP;

    -- 5. Clean up cursors
    CLOSE review_cursor;
    CLOSE cursor_response;
END;
$$;

-- Verify results
SELECT * FROM review_summaries;

Di seguito è riportato l'output di esempio:

 review_id | summary_text
-----------+---------------------------------------------------------------------------
         1 | "Masterclass in atmospheric tension with haunting performance, devastating twist."
         2 | "High octane action, stunning visuals, but shallow blockbuster."
         3 | "Gentle, moving exploration of grief with poetic screenplay."

Riepilogo aggregato tra le righe

La funzione ai.agg_summarize opera su più righe di una colonna. Aggrega i valori in un prompt unificato per generare un unico riepilogo per l'intero gruppo.

La seguente query SQL utilizza la funzione di aggregazione ai.agg_summarize per generare un unico riepilogo unificato per ogni movie_id in base a tutte le recensioni nella tabella movie_reviews.

select ai.agg_summarize(review) from movie_reviews group by movie_id;

A differenza di ai.summarize, che riepiloga ogni riga singolarmente, ai.agg_summarize combina il testo di più righe in un unico input per produrre un riepilogo consolidato per l'intero gruppo di righe.

Di seguito è riportato l'output di esempio:

agg_summarize
"The Midnight Echo is a masterclass in atmospheric tension, featuring haunting performances and stunning cinematography, though its pacing falters in the second act before a final twist. Neon Velocity offers stunning visual effects and high-octane action within a vibrant cyberpunk world, but suffers from shallow narrative depth, cliched dialogue, and underdeveloped characters. Garden of Whispers is a gentle, moving, and emotionally honest exploration of and life, characterized by poetic screenwriting and natural performances. Shadow Protocol ambitiously attempts to reinvent the spy thriller with a non-linear narrative and precise action, but ultimately confuses the audience and presents a derivative central mystery. The Last Alchemist uniquely blends historical drama with subtle fantasy, boasting meticulous production design and electric chemistry between its protagonists."

Passaggi successivi

• Valuta il sentiment.
• Leggi la panoramica delle funzioni di AI.