Generare e gestire gli auto vector embedding per tabelle di grandi dimensioni

Seleziona una versione della documentazione:

Puoi generare e gestire incorporamenti vettoriali per un'intera colonna della tabella, il che ti offre una soluzione scalabile per la creazione di incorporamenti vettoriali su larga scala. Questa soluzione è particolarmente utile per facilitare la ricerca semantica e la Retrieval Augmented Generation (RAG) sui contenuti di testo, tra cui:

  • Creazione dell'embedding vettoriale iniziale per una nuova tabella
  • Generazione di incorporamenti dopo l'importazione di grandi quantità di dati
  • Aggiornamento degli incorporamenti dopo modifiche significative ai dati
  • Mantenere gli incorporamenti in modo incrementale

Informazioni sugli incorporamenti vettoriali automatici

Gli incorporamenti vettoriali automatici in AlloyDB Omni forniscono un modo scalabile per automatizzare la generazione e la manutenzione degli incorporamenti vettoriali per i tuoi dati. Anziché generare manualmente gli incorporamenti per ogni nuovo testo o testo aggiornato, puoi configurare gli incorporamenti vettoriali automatici per gestire questo processo. Ciò è particolarmente utile per le applicazioni che si basano su incorporamenti aggiornati per la ricerca semantica, la Retrieval Augmented Generation (RAG) e altre funzionalità basate sull'AI.

Con i vector embedding automatici, puoi:

  • Inizializza gli incorporamenti per un'intera tabella: genera incorporamenti per tutti i dati esistenti in una colonna della tabella con un unico comando.
  • Mantieni sincronizzati gli incorporamenti: aggiorna automaticamente gli incorporamenti quando cambiano i dati di origine, assicurandoti che le tue applicazioni AI funzionino sempre con le informazioni più aggiornate.
  • Genera incorporamenti su larga scala: crea in modo efficiente incorporamenti per tabelle di grandi dimensioni con milioni di righe.
  • Configura e gestisci gli incorporamenti per più colonne nella stessa tabella chiamando le funzioni di gestione per ogni colonna di incorporamento.

Questa funzionalità semplifica lo sviluppo e la manutenzione delle applicazioni AI, eliminando la complessità della creazione e della manutenzione dei vector embedding.

Prima di iniziare

Prima di poter generare e gestire gli incorporamenti vettoriali per tabelle di grandi dimensioni, segui questi passaggi:

  • Controlla e aumenta le quote di Vertex AI: per garantire prestazioni ottimali ed evitare operazioni lente, QPS basso o più tentativi, verifica e, se necessario, aumenta le quote di Vertex AI.

    Per controllare e aumentare le quote:

    1. Nella console Google Cloud , vai alla pagina Quote.
    2. Filtra le seguenti metriche pertinenti al tuo modello e alla tua regione:
      • Per le richieste al minuto (RPM): Regional online prediction requests per base model per minute per region per base_model
      • Per i token Gemini: Embed content input tokens per minute per region per base_model
    3. Se i limiti attuali non sono sufficienti per le dimensioni della tabella, individua il valore della quota che vuoi aggiornare e seleziona la casella di controllo accanto alla quota.

    4. Fai clic su Modifica. Viene visualizzata la finestra di dialogo Modifiche alla quota.

      Per saperne di più, consulta Richiedi un aggiustamento delle quote.

    Per i limiti del modello di embedding Vertex AI, vedi Limite di token del modello di embedding Gemini.

    Per un elenco completo delle quote, consulta Quote e limiti di Vertex AI.

  • Connettiti al database utilizzando psql come utente postgres.

  • Verifica che l'estensione google_ml_integration sia installata e che la sua versione sia 1.5.6 o successive.

  • Verifica che i flag google_ml_integration.enable_model_support e google_ml_integration.enable_faster_embedding_generation siano impostati su on.

  • Prima di poter generare embedding da un database AlloyDB Omni, devi configurare AlloyDB Omni per funzionare con Vertex AI. Per saperne di più, consulta Integrare il database con Vertex AI.

  • Per la gestione e il monitoraggio della generazione di incorporamenti automatici, gli utenti hanno accesso Select alle tabelle google_ml.embed_gen_progress e google_ml.embed_gen_settings per impostazione predefinita.

    Per consentire a un utente di gestire la generazione automatica di incorporamenti, concedi le autorizzazioni INSERT, UPDATE e DELETE nelle tabelle google_ml.embed_gen_progress e google_ml.embed_gen_settings:

    GRANT INSERT, UPDATE, DELETE ON google_ml.embed_gen_progress TO 'USER_NAME';

    Sostituisci quanto segue:

    • USER_NAME: il nome dell'utente a cui vengono concessi i permessi.

  • Completa la configurazione iniziale descritta in Generare incorporamenti di testo.

  • Verifica che AUTOCOMMIT sia impostato su ON nel client PostgreSQL che utilizzi.

Verifica la versione dell'estensione

Per controllare la versione dell'estensione google_ml_integration, esegui questo comando:

SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';

Se devi aggiornare l'estensione, esegui questo comando:

ALTER EXTENSION google_ml_integration UPDATE;

Verifica che i flag del database siano impostati su on

Per verificare che i flag del database siano impostati correttamente, esegui questi comandi:

SHOW google_ml_integration.enable_model_support;
SHOW google_ml_integration.enable_faster_embedding_generation;

Se questi flag sono impostati su off, consulta Configurare i flag di database di un'istanza. Per saperne di più su questi flag, consulta Flag di database supportati.

Preparare il tavolo

Prima di poter generare incorporamenti automatici, devi creare una colonna nella tabella per archiviare i vettori risultanti. Questa colonna in genere utilizza il tipo vector(DIMENSION) e deve avere un valore DEFAULT NULL.

Ad esempio, per aggiungere una colonna per gli embedding a 768 dimensioni a una tabella denominata user_reviews:

ALTER TABLE user_reviews ADD COLUMN IF NOT EXISTS content_embeddings vector(768) DEFAULT NULL;

Inizializzare gli incorporamenti per una tabella

Le funzioni per la gestione degli incorporamenti vettoriali automatici sono disponibili negli schemi ai e google_ml. Lo schema ai fornisce un'interfaccia semplificata per le funzionalità di AI più recenti in AlloyDB Omni.

Utilizza la funzione SQL ai.initialize_embeddings() per generare embedding per la colonna dei contenuti di una tabella. Si tratta di una chiamata di blocco, il che significa che la sessione del database attende il completamento dell'operazione prima di restituire un risultato e consentirti di emettere nuovi comandi nella sessione. Tuttavia, le altre connessioni al database non vengono bloccate e possono continuare a funzionare con la tabella:

  • Se la funzione restituisce un esito positivo, la creazione del vector embedding è completata.
  • La funzione tenta automaticamente di risolvere problemi temporanei come gli errori di quota del modello. Un errore ti viene restituito solo se questi tentativi di recupero non vanno a buon fine. Per problemi persistenti, ad esempio un batch_size configurato in modo errato che causa il superamento dei limiti di dimensione della richiesta o se l'operazione è stata annullata manualmente, devi riemettere manualmente la chiamata.

Questa funzione supporta i modelli forniti da Google, ad esempio text-embedding-005 di Vertex AI, nonché i modelli personalizzati che hai registrato.

Eseguire la generazione batch

Per impostazione predefinita, AlloyDB Omni utilizza il batching per generare embedding per più input di testo in un'unica richiesta, il che migliora l'efficienza. Se non fornisci una dimensione del batch specifica, AlloyDB Omni applica un valore predefinito determinato automaticamente.

Dimensione del batch suggerimento

Il parametro batch_size in ai.initialize_embeddings ti consente di guidare l'ottimizzatore di query di AlloyDB Omni suggerendo una dimensione del batch preferita per i modelli supportati direttamente. AlloyDB Omni potrebbe ridurre dinamicamente questa dimensione in base ai limiti o alle quote del modello, ma il suggerimento contribuisce a influenzare il piano di esecuzione della query.

CALL ai.initialize_embeddings(
    model_id => 'text-embedding-005',
    table_name => 'user_reviews',
    content_column => 'content',
    embedding_column => 'content_embeddings',
    batch_size => 50
);

Utilizzare un modello di incorporamento personalizzato con supporto batch

Se vuoi utilizzare un modello personalizzato o supportato esternamente che supporta il batching, definisci le funzioni di trasformazione batch e specificale come model_batch_in_transform_fn e model_batch_out_transform_fn quando crei un modello. Puoi anche specificare un batch_size nella chiamata initialize_embeddings. Per i modelli che supportano il batching, ti consigliamo di utilizzare un batch_size maggiore di 1 per ottenere prestazioni migliori.

  1. Definisci le funzioni di input, output e trasformazione batch del modello personalizzato.

    -- Scalar input transform functions
CREATE OR REPLACE FUNCTION acme_text_input_transform(model_id TEXT, input TEXT) RETURNS JSON;
CREATE OR REPLACE FUNCTION acme_text_output_transform(model_id TEXT, model_output JSON) RETURNS real[];
CREATE OR REPLACE FUNCTION acme_generate_headers(model_id TEXT, input TEXT) RETURNS JSON;
-- Batch input transform functions
CREATE OR REPLACE FUNCTION acme_text_batch_input_transform(model_id TEXT, input TEXT[]) RETURNS JSON;
CREATE OR REPLACE FUNCTION acme_text_batch_output_transform(model_id TEXT, model_output JSON) RETURNS real[][];

  2. Per creare il modello, specifica le funzioni di trasformazione batch.

    CALL
  ai.create_model(
    model_id => 'custom-embedding-model',
    model_request_url => 'https://acme.com/models/text/embeddings/v1',
    model_type => 'text_embedding',
    model_in_transform_fn => 'acme_text_input_transform',
    model_out_transform_fn => 'acme_text_output_transform',
    generate_headers_fn => 'acme_generate_headers',
    model_batch_in_transform_fn => 'acme_text_batch_input_transform',
    model_batch_out_transform_fn => 'acme_text_batch_output_transform'
  );

  3. Genera vector embedding con il tuo modello personalizzato.

    CALL
  ai.initialize_embeddings(
    model_id => 'custom-embedding-model',
    table_name => 'user_reviews',
    content_column => 'content',
    embedding_column => 'content_embeddings',
    batch_size => 10
);

Puoi anche utilizzare la funzionalità di incorporamento automatico con modelli personalizzati che non supportano in modo nativo il batch. Per farlo, devi comunque definire le funzioni di trasformazione batch model_batch_in_transform_fn e model_batch_out_transform_fn. Per un modello non batch, definisci queste funzioni per elaborare un singolo input alla volta dall'array di input. Quando chiami ai.initialize_embeddings per questo modello, imposta batch_size su 1.

Utilizzare la dimensionalità personalizzata con il supporto dei batch

Per utilizzare una funzione di trasformazione dell'input batch personalizzata con il parametro OUTPUT_DIMENSIONALITY, puoi definire una funzione che specifica le dimensioni selezionate nei parametri della richiesta. Ciò è utile per ottimizzare la generazione di incorporamenti per i modelli che supportano dimensioni di output variabili.

Ad esempio, la seguente funzione definisce una trasformazione personalizzata dell'input batch per un modello che richiede una dimensionalità dell'output di 768:

CREATE OR REPLACE FUNCTION google_ml.vertexai_text_embedding_batch_input_transform_with_768_dims(model_id VARCHAR(100), input_list TEXT[])
RETURNS JSON
LANGUAGE SQL
AS $$
  SELECT pg_catalog.json_build_object(
    'instances',
    pg_catalog.json_agg(pg_catalog.json_build_object('content', content)),
    'parameters',
    pg_catalog.json_build_object('outputDimensionality', 768)
  ) FROM unnest(input_list) AS content;
$$;

Utilizzare l'ottimizzazione JSONB con modelli personalizzati

Puoi utilizzare il tipo di dati JSONB nelle funzioni di trasformazione dell'output personalizzato per migliorare le prestazioni. Quando crei un modello personalizzato con supporto batch, l'estensione google_ml_integration cerca e utilizza automaticamente una variante JSONB delle funzioni di trasformazione.

Questa ottimizzazione può migliorare significativamente le prestazioni della generazione di incorporamenti automatici perché JSONB è un formato binario più efficiente per l'archiviazione e l'elaborazione dei dati JSON in PostgreSQL.

Per usufruire di questa funzionalità, devi fornire un'altra versione della funzione di trasformazione che accetti un argomento JSONB anziché JSON.

Ad esempio, se hai una funzione di trasformazione dell'output batch con la seguente firma:

CREATE OR REPLACE FUNCTION my_batch_output_transform(model_id TEXT, model_output JSON) RETURNS real[][];

Puoi creare una variante JSONB come questa:

CREATE OR REPLACE FUNCTION my_batch_output_transform(model_id TEXT, model_output JSONB) RETURNS real[][];

L'estensione rileva automaticamente la presenza della versione JSONB della funzione e la utilizza per l'elaborazione batch. Se hai già creato una registrazione del modello che utilizza una funzione di trasformazione JSON, non devi aggiornare la chiamata ai.create_model. Se la nuova funzione JSONB utilizza esattamente lo stesso nome della funzione JSON esistente, l'estensione rileva e utilizza in modo trasparente la variante JSONB per l'elaborazione batch.

Aggiornare gli incorporamenti in modo incrementale

Quando aggiorni un incorporamento, questo viene rigenerato in base all'ultimo valore della colonna dei contenuti di input.

Per darti il controllo su coerenza e prestazioni, AlloyDB Omni supporta varie modalità per gli aggiornamenti incrementali dell'incorporamento. Puoi selezionare una modalità utilizzando l'argomento enum incremental_refresh_mode in ai.initialize_embeddings(). Di seguito è riportato un elenco delle possibili modalità:

  • transactional: gli embedding vengono aggiornati nell'ambito della transazione che aggiorna la colonna dei contenuti. Questo processo, che spesso utilizza un meccanismo simile a un trigger di database per generare automaticamente gli incorporamenti quando la colonna dei contenuti viene aggiornata, può introdurre un sovraccarico e rallentare le operazioni di aggiornamento. L'overhead introdotto è un compromesso per mantenere la semantica transazionale e garantire che gli incorporamenti siano sincronizzati con i contenuti. Questa modalità si basa sulle funzioni di trasformazione scalare del modello, pertanto devi definire model_in_transform_fn e model_out_transform_fn quando crei il modello. Per utilizzare la modalità transactional, devi disporre del ruolo Proprietario nella tabella.

    CALL
  ai.initialize_embeddings(
    model_id => 'text-embedding-005',
    table_name => 'user_reviews',
    content_column => 'content',
    embedding_column => 'content_embeddings',
    batch_size => 10,
    incremental_refresh_mode => 'transactional'
);

    Nella modalità transactional, la funzione ai.refresh_embeddings() è disattivata perché gli incorporamenti vengono sincronizzati automaticamente utilizzando i trigger. Per rigenerare gli incorporamenti per l'intera tabella o per ripristinare una chiamata ai.initialize_embeddings() interrotta in questa modalità, devi prima eliminare la configurazione utilizzando la funzione ai.drop_embedding_config() e poi riemettere la chiamata ai.initialize_embeddings().

    Questa modalità automatica è utile per demo, piccoli set di dati o tabelle in cui il volume di inserimenti e aggiornamenti è basso rispetto al caricamento iniziale, ad esempio poche centinaia di aggiornamenti giornalieri in una tabella con un milione di righe. È appropriato quando il mantenimento della coerenza immediata dei dati è più importante della latenza aggiuntiva introdotta durante le operazioni di aggiornamento.

  • manual: questa è la modalità predefinita. In questa modalità, alla tabella viene aggiunta una nuova colonna di monitoraggio booleana per monitorare gli incorporamenti obsoleti. La chiamata alla funzione ai.refresh_embeddings() esegue un aggiornamento incrementale periodico generando incorporamenti solo per le righe nuove o aggiornate. Consigliamo questa modalità agli utenti che richiedono un maggiore controllo sul rendimento, soprattutto quando gestiscono un numero elevato di inserimenti o aggiornamenti dopo il caricamento iniziale. È utile per gli scenari in cui la riduzione al minimo della latenza di scrittura è una priorità e in cui è accettabile avere incorporamenti temporaneamente obsoleti o nulli finché non viene attivato un aggiornamento incrementale periodico utilizzando ai.refresh_embeddings. Per aggiornare le righe obsolete o nuove, utilizza la funzione ai.refresh_embeddings() come descritto nella sezione Aggiornare tutti gli incorporamenti per una tabella.

Scegliere una modalità di aggiornamento

La tabella seguente confronta le due modalità di aggiornamento incrementale per aiutarti a scegliere l'approccio migliore per la tua applicazione.

Modalità Descrizione Coerenza e rendimento Ideale per
transactional Gli incorporamenti vengono aggiornati nell'ambito della transazione del database utilizzando un meccanismo simile a un trigger. Tieni presente che ai.refresh_embeddings() è disattivato in questa modalità. Coerenza immediata. Overhead elevato della latenza di scrittura poiché ogni INSERT o UPDATE attiva una generazione di incorporamento. Demo, piccoli set di dati o tabelle in cui la coerenza dei dati è fondamentale.
manual (valore predefinito) Utilizza una colonna di monitoraggio booleana per monitorare le righe obsolete o nuove. Devi chiamare il numero ai.refresh_embeddings() per attivare un aggiornamento incrementale periodico. Coerenza finale. Latenza di scrittura minima, poiché gli incorporamenti vengono generati in blocco nel momento che preferisci. Set di dati di grandi dimensioni, ambienti di produzione con alta frequenza di scrittura o applicazioni sensibili alle prestazioni.

Aggiornare tutti gli incorporamenti per una tabella

Dopo aver eseguito correttamente ai.initialize_embeddings() per una tabella utilizzando la modalità di aggiornamento incrementale manual, puoi eseguire un aggiornamento incrementale periodico dei tuoi incorporamenti, che viene attivato utilizzando ai.refresh_embeddings. Puoi utilizzare un'operazione di aggiornamento per aggiornare gli incorporamenti per le righe modificate contemporaneamente durante la chiamata initialize_embeddings iniziale o per eseguire un aggiornamento incrementale periodico.

Se il processo di creazione dell'incorporamento viene interrotto in modalità manuale, ad esempio da pg_cancel, chiama la funzione ai.refresh_embeddings() per completare la generazione per le righe rimanenti.

La funzione di aggiornamento riutilizza le impostazioni della chiamata iniziale, quindi devi specificare solo la tabella e la colonna di incorporamento. Puoi anche fornire un batch_size facoltativo per ignorare il valore predefinito.

CALL ai.refresh_embeddings(
    table_name => 'user_reviews',
    embedding_column => 'content_embeddings',
    batch_size => 50  -- Optional override
);

Utilizzare i dati delle tabelle durante la creazione di vector embedding

Anche se ai.initialize_embeddings() è una chiamata di blocco per la sessione in cui viene eseguita, altre connessioni possono continuare a funzionare con la tabella. Il processo di incorporamento automatico dei vettori aggiorna le righe in batch utilizzando il blocco standard a livello di riga. Ciò significa che le operazioni DML (Data Modification Language) simultanee, come UPDATE o DELETE, provenienti da altre connessioni vengono bloccate solo brevemente se tentano di modificare le stesse righe di destinazione dell'attività di incorporamento attiva. Le query SELECT non di modifica non vengono bloccate.

Elimina le impostazioni di incorporamento automatico dei vettori

Se devi rimuovere la configurazione dell'auto vector embedding per una combinazione specifica di tabella e colonna di embedding, utilizza la funzione ai.drop_embedding_config(). Questa funzione può essere utile per la pulizia o quando riconfiguri la gestione dell'incorporamento per una colonna.

CALL
  ai.drop_embedding_config(
    table_name => 'user_reviews',
    embedding_column => 'content_embeddings');

Utilizzare le tabelle partizionate

La funzionalità di embedding vettoriale automatico supporta le tabelle partizionate. Ciò ti consente di gestire in modo efficiente gli incorporamenti per set di dati di grandi dimensioni e partizionati. Di seguito sono riportati i casi d'uso comuni per l'utilizzo delle tabelle partizionate.

Inizializzare gli incorporamenti in una tabella partizionata

Puoi inizializzare gli incorporamenti solo nella partizione principale di una tabella. Si tratta di un'operazione una tantum per l'intera tabella partizionata.

CALL ai.initialize_embeddings(
    model_id => 'text-embeddings-005',
    table_name => 'documents', -- This is the root partitioned table
    content_column => 'content',
    embedding_column => 'content_embeddings'
);

Aggiornare gli incorporamenti in una tabella partizionata

Dopo l'inizializzazione, puoi aggiornare gli incorporamenti in qualsiasi partizione, incluse la partizione principale, le partizioni secondarie o le singole partizioni foglia. Per set di dati di grandi dimensioni, puoi migliorare le prestazioni aggiornando gli incorporamenti per partizioni distinte in parallelo da diverse connessioni al database:

  • Per aggiornare l'intera tabella, esegui il comando seguente:
CALL ai.refresh_embeddings(
    table_name => 'documents', -- This is the root partitioned table
    embedding_column => 'content_embeddings'
);
  • Per aggiornare una singola partizione, esegui questo comando:
CALL ai.refresh_embeddings(
    table_name => 'documents_eu',
    embedding_column => 'content_embeddings'
);

Aggiornare gli incorporamenti per le partizioni appena aggiunte o allegate

La funzionalità di incorporamento automatico supporta la generazione di incorporamenti per le partizioni incorporate nella tabella principale dopo la configurazione iniziale. I passaggi specifici dipendono dal fatto che tu stia aggiungendo una partizione completamente nuova o allegando una tabella preesistente.

  • Partizione appena aggiunta: se aggiungi una nuova partizione alla tabella, puoi generare incorporamenti per questa partizione chiamando ai.refresh_embeddings sulla nuova partizione.
-- Add a new partition
CREATE TABLE documents_africa PARTITION OF documents
    FOR VALUES IN ('africa');

-- Refresh embeddings for the new partition
CALL ai.refresh_embeddings(
    table_name => 'documents_africa',
    embedding_column => 'content_embeddings'
);
  • Partizione appena collegata: per collegare una tabella esistente come partizione, utilizza prima la procedura ai.embedding_prepare_partition per assicurarti che il suo schema sia compatibile con la tabella partizionata. La funzionalità di incorporamento automatico supporta l'aggiunta o l'allegato di partizioni a qualsiasi livello di una configurazione di partizioni gerarchica. La procedura ai.embedding_prepare_partition garantisce che lo schema sia compatibile con qualsiasi tabella principale nella gerarchia.

Per allegare una tabella esistente come partizione, utilizza prima la procedura ai.embedding_prepare_partition per assicurarti che il suo schema sia compatibile con la tabella partizionata:

-- Prepare the table to be attached
CALL ai.embedding_prepare_partition(
    parent_table => 'documents',
    child_table => 'documents_misc'
);

-- Attach the partition
ALTER TABLE documents ATTACH partition documents_misc DEFAULT;

-- Refresh embeddings for the newly attached partition
CALL ai.refresh_embeddings(
    table_name => 'documents_misc',
    embedding_column => 'content_embeddings'
);

La funzionalità di incorporamento automatico supporta l'aggiunta o l'allegato di partizioni a qualsiasi livello di una configurazione di partizioni gerarchica. La procedura ai.embedding_prepare_partition garantisce che lo schema sia compatibile con qualsiasi tabella principale nella gerarchia:

-- Prepare a sub-partition for a non-root parent table
CALL ai.embedding_prepare_partition(
    parent_table => 'documents_eu', -- An existing partition
    child_table => 'documents_eu_germany'
);

-- Attach the new sub-partition
ALTER TABLE documents_eu ATTACH PARTITION documents_eu_germany
    FOR VALUES IN ('germany');

-- Refresh embeddings for the new sub-partition
CALL ai.refresh_embeddings(
    table_name => 'documents_eu_germany',
    embedding_column => 'content_embeddings'
);

Monitorare l'avanzamento della generazione degli incorporamenti

Puoi monitorare lo stato in tempo reale delle chiamate initialize_embeddings e refresh_embeddings attive eseguendo query su ai.embedding_progress_view. Questa visualizzazione fornisce dettagli sull'avanzamento dell'operazione, tra cui la percentuale completata, il tempo trascorso e il tempo rimanente stimato.

Per controllare l'avanzamento, esegui la seguente query:

SELECT
  table_name,
  content_column,
  embedding_column,
  model_id,
  percent_progress,
  status,
  elapsed_time,
  rows_processed,
  partition_root
FROM
  ai.embedding_progress_view;

La visualizzazione fornisce le seguenti informazioni:

Colonna Descrizione
table_name Il nome della tabella o della partizione in fase di elaborazione.
content_column La colonna contenente i contenuti di origine per l'incorporamento.
embedding_column La colonna in cui vengono archiviati gli embedding.
model_id Il modello utilizzato per la generazione.
percent_progress La percentuale dell'operazione completata.
status Lo stato attuale dell'operazione (ad es. in esecuzione, riuscita).
elapsed_time Il tempo trascorso dall'inizio dell'operazione.
rows_processed Il numero di righe elaborate finora.
partition_root Il nome della tabella partizionata radice.

Esempi di generazione di incorporamenti in auto

Questa sezione fornisce esempi per la generazione automatica di embedding utilizzando gli endpoint del modello registrati.

Modello di embedding OpenAI

Per generare embedding utilizzando l'endpoint del modello text-embedding-3-small registrato fornito da OpenAI, esegui la seguente istruzione:

CALL ai.initialize_embeddings(
    model_id => 'text-embedding-3-small',
    table_name => 'user_reviews',
    content_column => 'content',
    embedding_column => 'content_embeddings'
);

Modelli di embedding personalizzati

Per i modelli di tua proprietà o supportati esternamente, devi definire le funzioni di trasformazione di input e output e registrarle con ai.create_model. Se prevedi di utilizzare la funzionalità di incorporamento automatico, devi specificare sia le funzioni di trasformazione scalare, ad esempio acme_text_input_transform, acme_text_output_transform, sia le funzioni di trasformazione batch, ad esempio acme_text_batch_input_transform, acme_text_batch_output_transform.

Passaggi successivi