Automatische Vektoreinbettungen für große Tabellen generieren und verwalten

Wählen Sie eine Dokumentationsversion aus:

Sie können Vektoreinbettungen für eine ganze Tabellenspalte generieren und verwalten. So erhalten Sie eine skalierbare Lösung für die Erstellung von Vektoreinbettungen in großem Maßstab. Diese Lösung ist besonders nützlich, um die semantische Suche und Retrieval-Augmented Generation (RAG) für Textinhalte zu ermöglichen, einschließlich der folgenden:

  • Erstellen einer ersten Vektoreinbettung für eine neue Tabelle
  • Einbettungen nach einem großen Datenimport erstellen
  • Einbettungen nach wesentlichen Datenänderungen aktualisieren
  • Einbettungen inkrementell verwalten

Automatische Vektoreinbettungen

Mit der automatischen Vektoreinbettung in AlloyDB Omni können Sie die Generierung und Wartung von Vektoreinbettungen für Ihre Daten skalierbar automatisieren. Anstatt manuell Einbettungen für jeden neuen oder aktualisierten Text zu generieren, können Sie automatische Vektoreinbettungen konfigurieren, um diesen Prozess für Sie zu übernehmen. Das ist besonders nützlich für Anwendungen, die auf aktuellen Einbettungen für die semantische Suche, Retrieval-Augmented Generation (RAG) und andere KI-basierte Funktionen angewiesen sind.

Mit automatischen Vektoreinbettungen haben Sie folgende Möglichkeiten:

  • Einbettungen für eine gesamte Tabelle initialisieren: Mit einem einzigen Befehl Einbettungen für alle vorhandenen Daten in einer Tabellenspalte generieren.
  • Einbettungen synchron halten: Einbettungen werden automatisch aktualisiert, wenn sich die Quelldaten ändern. So arbeiten Ihre KI-Anwendungen immer mit den aktuellsten Informationen.
  • Einbettungen im großen Maßstab generieren: Erstellen Sie effizient Einbettungen für große Tabellen mit Millionen von Zeilen.
  • Sie können Einbettungen für mehrere Spalten in derselben Tabelle konfigurieren und verwalten, indem Sie die Verwaltungsfunktionen für jede Einbettungsspalte aufrufen.

Diese Funktion vereinfacht die Entwicklung und Wartung von KI-Anwendungen, da die Komplexität der Erstellung und Wartung von Vektoreinbettungen abstrahiert wird.

Hinweis

Bevor Sie Vektoreinbettungen für große Tabellen generieren und verwalten können, müssen Sie die folgenden Schritte ausführen:

  • Vertex AI-Kontingente prüfen und erhöhen: Um eine optimale Leistung zu gewährleisten und langsame Vorgänge, niedrige QPS oder mehrere Wiederholungsversuche zu vermeiden, prüfen Sie Ihre Vertex AI-Kontingente und erhöhen Sie sie bei Bedarf.

    So prüfen und erhöhen Sie Ihre Kontingente:

    1. Rufen Sie in der Google Cloud Console die Seite Kontingente auf.
    2. Filtern Sie nach den folgenden Messwerten, die für Ihr Modell und Ihre Region relevant sind:
      • Für Anfragen pro Minute (RPM): Regional online prediction requests per base model per minute per region per base_model
      • Für Gemini-Tokens: Embed content input tokens per minute per region per base_model
    3. Wenn Ihre aktuellen Limits für die Tabellengröße nicht ausreichen, suchen Sie nach dem Kontingentwert, den Sie aktualisieren möchten, und klicken Sie auf das Kästchen daneben.

    4. Klicken Sie auf Bearbeiten. Das Dialogfeld Kontingentänderungen wird angezeigt.

      Weitere Informationen finden Sie unter Kontingentanpassung anfordern.

    Informationen zu den Limits für Vertex AI-Modelle für Einbettungen finden Sie unter Tokenlimit für Gemini-Modelle für Einbettungen.

    Eine vollständige Liste der Kontingente finden Sie unter Vertex AI-Kontingente und ‑Limits.

  • Stellen Sie mit psql eine Verbindung zu Ihrer Datenbank her und melden Sie sich als postgres-Nutzer an.

  • Prüfen Sie, ob die google_ml_integration-Erweiterung installiert ist und die Version 1.5.6 oder höher ist.

  • Prüfen Sie, ob die Flags google_ml_integration.enable_model_support und google_ml_integration.enable_faster_embedding_generation auf on gesetzt sind.

  • Bevor Sie Einbettungen aus einer AlloyDB Omni-Datenbank generieren können, müssen Sie AlloyDB Omni für die Verwendung mit Vertex AI konfigurieren. Weitere Informationen finden Sie unter Datenbank in Vertex AI einbinden.

  • Zum Verwalten und Überwachen der automatischen Einbettungsgenerierung haben Nutzer standardmäßig Select-Zugriff auf die Tabellen google_ml.embed_gen_progress und google_ml.embed_gen_settings.

    Wenn ein Nutzer die automatische Generierung von Einbettungen verwalten soll, gewähren Sie ihm die Berechtigungen INSERT, UPDATE und DELETE für die Tabellen google_ml.embed_gen_progress und google_ml.embed_gen_settings:

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

    Ersetzen Sie Folgendes:

    • USER_NAME: Der Name des Nutzers, dem die Berechtigungen erteilt werden.

  • Führen Sie die unter Texteinbettungen generieren beschriebene Ersteinrichtung durch.

  • Prüfen Sie, ob AUTOCOMMIT im verwendeten PostgreSQL-Client auf ON festgelegt ist.

Erweiterungsversion prüfen

Führen Sie den folgenden Befehl aus, um die Version der google_ml_integration-Erweiterung zu prüfen:

SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';

Wenn Sie die Erweiterung aktualisieren müssen, führen Sie den folgenden Befehl aus:

ALTER EXTENSION google_ml_integration UPDATE;

Prüfen Sie, ob die Datenbank-Flags auf on gesetzt sind.

Führen Sie die folgenden Befehle aus, um zu prüfen, ob die Datenbank-Flags richtig festgelegt sind:

SHOW google_ml_integration.enable_model_support;
SHOW google_ml_integration.enable_faster_embedding_generation;

Wenn diese Flags auf off gesetzt sind, lesen Sie den Abschnitt Datenbank-Flags einer Instanz konfigurieren. Weitere Informationen zu diesen Flags finden Sie unter Unterstützte Datenbank-Flags.

Tabelle vorbereiten

Bevor Sie automatische Einbettungen generieren können, müssen Sie eine Spalte in Ihrer Tabelle erstellen, in der die resultierenden Vektoren gespeichert werden. In dieser Spalte wird in der Regel der Typ vector(DIMENSION) verwendet und sie muss einen DEFAULT NULL-Wert haben.

So fügen Sie beispielsweise einer Tabelle mit dem Namen user_reviews eine Spalte für 768-dimensionale Einbettungen hinzu:

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

Einbettungen für eine Tabelle initialisieren

Die Funktionen zum Verwalten von automatischen Vektoreinbettungen sind sowohl im ai- als auch im google_ml-Schema verfügbar. Das ai-Schema bietet eine vereinfachte Schnittstelle für die neuesten KI-Funktionen in AlloyDB Omni.

Mit der SQL-Funktion ai.initialize_embeddings() können Sie Einbettungen für die Inhaltsspalte einer Tabelle generieren. Dies ist ein blockierender Aufruf. Das bedeutet, dass die Datenbanksitzung wartet, bis der Vorgang abgeschlossen ist, bevor ein Ergebnis zurückgegeben wird und Sie neue Befehle in dieser Sitzung ausführen können. Andere Verbindungen zur Datenbank werden jedoch nicht blockiert und können weiterhin mit der Tabelle arbeiten:

  • Wenn die Funktion „success“ zurückgibt, ist die Erstellung der Vektoreinbettung abgeschlossen.
  • Die Funktion versucht automatisch, vorübergehende Probleme wie Fehler bei Modellkontingenten zu beheben. Sie erhalten nur dann eine Fehlermeldung, wenn diese Wiederherstellungsversuche fehlschlagen. Bei dauerhaften Problemen, z. B. einer falsch konfigurierten batch_size, die dazu führt, dass die Anfrage Größenbeschränkungen überschreitet, oder wenn der Vorgang manuell abgebrochen wurde, müssen Sie den Aufruf manuell neu ausgeben.

Diese Funktion unterstützt von Google bereitgestellte Modelle, z. B. text-embedding-005 von Vertex AI, sowie benutzerdefinierte Modelle, die Sie registriert haben.

Batchgenerierung durchführen

Standardmäßig verwendet AlloyDB Omni Batching, um Einbettungen für mehrere Texteingaben in einer einzelnen Anfrage zu generieren. Das verbessert die Effizienz. Wenn Sie keine bestimmte Batchgröße angeben, wendet AlloyDB Omni einen automatisch ermittelten Standardwert an.

Batchgröße für Hinweise

Mit dem Parameter batch_size in ai.initialize_embeddings können Sie den Abfrageoptimierer von AlloyDB Omni steuern, indem Sie eine bevorzugte Batchgröße für direkt unterstützte Modelle vorschlagen. AlloyDB Omni kann diese Größe basierend auf Modelllimits oder Kontingenten dynamisch reduzieren. Ihr Hinweis kann jedoch den Abfrageausführungsplan beeinflussen.

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

Benutzerdefiniertes Einbettungsmodell mit Batchunterstützung verwenden

Wenn Sie ein benutzerdefiniertes oder extern unterstütztes Modell verwenden möchten, das Batching unterstützt, definieren Sie die Batch-Transformationsfunktionen und geben Sie sie beim Erstellen eines Modells als model_batch_in_transform_fn und model_batch_out_transform_fn an. Sie können auch ein batch_size im initialize_embeddings-Aufruf angeben. Bei Modellen, die Batching unterstützen, empfehlen wir, einen batch_size größer als 1 zu verwenden, um die Leistung zu verbessern.

  1. Definieren Sie die Eingabe-, Ausgabe- und Batch-Transformationsfunktionen Ihres benutzerdefinierten Modells.

    -- 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. Geben Sie die Batch-Transformationsfunktionen an, um das Modell zu erstellen.

    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. Vektoreinbettungen mit Ihrem benutzerdefinierten Modell generieren

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

Sie können die Funktion für automatische Einbettung auch mit benutzerdefinierten Modellen verwenden, die Batching nicht nativ unterstützen. Dazu müssen Sie weiterhin die Batch-Transformationsfunktionen model_batch_in_transform_fn und model_batch_out_transform_fn definieren. Bei einem Modell ohne Batchverarbeitung definieren Sie diese Funktionen, um jeweils eine einzelne Eingabe aus dem Eingabearray zu verarbeiten. Wenn Sie ai.initialize_embeddings für dieses Modell aufrufen, setzen Sie batch_size auf 1.

Benutzerdefinierte Dimensionalität mit Batchunterstützung verwenden

Wenn Sie eine benutzerdefinierte Batch-Eingabetransformationsfunktion mit dem Parameter OUTPUT_DIMENSIONALITY verwenden möchten, können Sie eine Funktion definieren, in der die ausgewählten Dimensionen in den Anfrageparametern angegeben werden. Das ist nützlich, um die Generierung von Einbettungen für Modelle zu optimieren, die variable Ausgabegrößen unterstützen.

Die folgende Funktion definiert beispielsweise eine benutzerdefinierte Batch-Eingabetransformation für ein Modell, das eine Ausgabedimensionalität von 768 erfordert:

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;
$$;

JSONB-Optimierung mit benutzerdefinierten Modellen verwenden

Sie können den Datentyp JSONB in Ihren benutzerdefinierten Ausgabetransformationsfunktionen verwenden, um die Leistung zu verbessern. Wenn Sie ein benutzerdefiniertes Modell mit Batchunterstützung erstellen, sucht die google_ml_integration-Erweiterung automatisch nach einer JSONB-Variante Ihrer Transformationsfunktionen und verwendet sie.

Diese Optimierung kann die Leistung der automatischen Einbettungserstellung erheblich verbessern, da JSONB ein effizienteres binäres Format zum Speichern und Verarbeiten von JSON-Daten in PostgreSQL ist.

Wenn Sie diese Funktion nutzen möchten, müssen Sie eine weitere Version Ihrer Transformationsfunktion bereitstellen, die anstelle von JSON das Argument JSONB akzeptiert.

Angenommen, Sie haben eine Batch-Ausgabetransformationsfunktion mit der folgenden Signatur:

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

So erstellen Sie eine JSONB-Variante:

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

Die Erweiterung erkennt automatisch, ob die JSONB-Version der Funktion vorhanden ist, und verwendet sie für die Batchverarbeitung. Wenn Sie bereits eine Modellregistrierung erstellt haben, in der eine JSON-Transformationsfunktion verwendet wird, müssen Sie Ihren ai.create_model-Aufruf nicht aktualisieren. Solange die neue JSONB-Funktion denselben Namen wie die vorhandene JSON-Funktion hat, erkennt und verwendet die Erweiterung die JSONB-Variante für die Batchverarbeitung.

Einbettungen inkrementell aktualisieren

Wenn Sie ein Embedding aktualisieren, wird es auf Grundlage des neuesten Werts in der Spalte mit den Eingabeinhalten neu generiert.

Damit Sie die Konsistenz und Leistung steuern können, unterstützt AlloyDB Omni verschiedene Modi für inkrementelle Aktualisierungen von Einbettungen. Sie können einen Modus mit dem Enum-Argument incremental_refresh_mode in ai.initialize_embeddings() auswählen. Hier finden Sie eine Liste der möglichen Modi:

  • transactional: Einbettungen werden im Rahmen der Transaktion aktualisiert, mit der die Inhaltsspalte aktualisiert wird. Dieser Prozess, bei dem häufig ein Mechanismus ähnlich einem Datenbanktrigger verwendet wird, um automatisch Einbettungen zu generieren, wenn die Inhaltsspalte aktualisiert wird, kann zu Mehraufwand führen und Aktualisierungsvorgänge verlangsamen. Der eingeführte Aufwand ist ein Kompromiss, um die Transaktionssemantik aufrechtzuerhalten und dafür zu sorgen, dass die Einbettungen mit den Inhalten synchronisiert werden. Dieser Modus basiert auf den skalaren Transformationsfunktionen Ihres Modells. Sie müssen also model_in_transform_fn und model_out_transform_fn definieren, wenn Sie das Modell erstellen. Für den Modus transactional benötigen Sie die Rolle „Inhaber“ für die Tabelle.

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

    Im Modus transactional ist die Funktion ai.refresh_embeddings() deaktiviert, da Einbettungen automatisch über Trigger synchronisiert werden. Wenn Sie Einbettungen für die gesamte Tabelle neu generieren oder einen unterbrochenen ai.initialize_embeddings()-Aufruf in diesem Modus wiederherstellen möchten, müssen Sie zuerst die Konfiguration mit der Funktion ai.drop_embedding_config() löschen und dann den ai.initialize_embeddings()-Aufruf noch einmal ausführen.

    Dieser automatisierte Modus ist nützlich für Demos, kleine Datasets oder Tabellen, in denen das Volumen der Einfügungen und Aktualisierungen im Vergleich zum anfänglichen Laden gering ist, z. B. einige hundert tägliche Aktualisierungen in einer Tabelle mit einer Million Zeilen. Diese Option ist geeignet, wenn die sofortige Datenkonsistenz wichtiger ist als die zusätzliche Latenz, die bei Aktualisierungsvorgängen auftritt.

  • manual: Dies ist der Standardmodus. In diesem Modus wird Ihrer Tabelle eine neue boolesche Tracking-Spalte hinzugefügt, um veraltete Einbettungen zu erfassen. Beim Aufrufen der Funktion ai.refresh_embeddings() wird eine regelmäßige inkrementelle Aktualisierung durchgeführt, indem nur Einbettungen für neue oder aktualisierte Zeilen generiert werden. Wir empfehlen diesen Modus für Nutzer, die mehr Kontrolle über die Leistung benötigen, insbesondere wenn nach dem ersten Laden eine große Anzahl von Einfügungen oder Aktualisierungen erfolgt. Sie ist nützlich für Szenarien, in denen die Minimierung der Schreiblatenz Priorität hat und in denen vorübergehend veraltete oder Null-Einbettungen akzeptabel sind, bis eine regelmäßige inkrementelle Aktualisierung mit ai.refresh_embeddings ausgelöst wird. Verwenden Sie die Funktion ai.refresh_embeddings(), um alte oder neue Zeilen zu aktualisieren, wie im Abschnitt Alle Einbettungen für eine Tabelle aktualisieren beschrieben.

Aktualisierungsmodus auswählen

In der folgenden Tabelle werden die beiden Modi für die inkrementelle Aktualisierung verglichen, damit Sie die beste Methode für Ihre Anwendung auswählen können.

Modus Beschreibung Konsistenz und Leistung Optimal für
transactional Die Einbettungen werden im Rahmen der Datenbanktransaktion mit einem Mechanismus aktualisiert, der einem Trigger ähnelt. Beachten Sie, dass ai.refresh_embeddings() in diesem Modus deaktiviert ist. Sofortige Konsistenz: Hoher Overhead bei der Schreiblatenz, da jedes INSERT oder UPDATE eine Einbettungsgenerierung auslöst. Demos, kleine Datasets oder Tabellen, in denen die Datenkonsistenz entscheidend ist.
manual (Standard) Verwendet eine boolesche Tracking-Spalte, um alte oder neue Zeilen zu überwachen. Sie müssen ai.refresh_embeddings() aufrufen, um eine regelmäßige inkrementelle Aktualisierung auszulösen. Eventual Consistency: Minimale Schreiblatenz, da Einbettungen in großen Mengen zu einem Zeitpunkt Ihrer Wahl generiert werden. Große Datasets, Produktionsumgebungen mit hoher Schreibfrequenz oder leistungsempfindliche Anwendungen.

Alle Einbettungen für eine Tabelle aktualisieren

Nachdem Sie ai.initialize_embeddings() für eine Tabelle im inkrementellen Aktualisierungsmodus manual erfolgreich ausgeführt haben, können Sie eine regelmäßige inkrementelle Aktualisierung Ihrer Einbettungen durchführen, die mit ai.refresh_embeddings ausgelöst wird. Mit einem Aktualisierungsvorgang können Sie die Einbettungen für Zeilen aktualisieren, die gleichzeitig während des ursprünglichen initialize_embeddings-Aufrufs geändert werden, oder eine regelmäßige inkrementelle Aktualisierung durchführen.

Wenn der Prozess zum Erstellen von Einbettungen im manuellen Modus unterbrochen wird, z. B. durch pg_cancel, rufen Sie die Funktion ai.refresh_embeddings() auf, um die Generierung für die verbleibenden Zeilen abzuschließen.

Die Aktualisierungsfunktion verwendet die Einstellungen aus dem ursprünglichen Aufruf wieder. Sie müssen also nur die Tabelle und die Spalte für das Einbetten angeben. Sie können auch ein optionales batch_size angeben, um den Standardwert zu überschreiben.

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

Mit Tabellendaten während der Erstellung von Vektoreinbettungen arbeiten

ai.initialize_embeddings() ist zwar ein blockierender Aufruf für die Sitzung, in der er ausgeführt wird, aber andere Verbindungen können weiterhin mit der Tabelle arbeiten. Beim automatischen Einbetten von Vektoren werden Zeilen in Batches mit der standardmäßigen Sperrung auf Zeilenebene aktualisiert. Das bedeutet, dass gleichzeitige DML-Vorgänge (Data Modification Language, Datenbearbeitungssprache) wie UPDATE oder DELETE aus anderen Verbindungen nur kurz blockiert werden, wenn sie versuchen, dieselben Zeilen zu ändern, auf die die aktive Einbettungsaufgabe abzielt. SELECT-Abfragen, die keine Änderungen vornehmen, werden nicht blockiert.

Einstellungen für automatische Vektoreinbettung löschen

Wenn Sie die automatische Vektoreinbettungskonfiguration für eine bestimmte Kombination aus Tabelle und Einbettungsspalte entfernen müssen, verwenden Sie die Funktion ai.drop_embedding_config(). Diese Funktion kann nützlich sein, wenn Sie eine Spalte bereinigen oder die Einbettungsverwaltung für eine Spalte neu konfigurieren möchten.

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

Mit partitionierten Tabellen arbeiten

Die Funktion für das automatische Vektoreinbetten unterstützt partitionierte Tabellen. So können Sie Einbettungen für große, partitionierte Datasets effizient verwalten. Im Folgenden finden Sie die gängigen Anwendungsfälle für die Arbeit mit partitionierten Tabellen.

Einbettungen in einer partitionierten Tabelle initialisieren

Sie können Embeddings nur für die Stammpartition einer Tabelle initialisieren. Dies ist ein einmaliger Vorgang für die gesamte partitionierte Tabelle.

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

Einbettungen in einer partitionierten Tabelle aktualisieren

Nach der Initialisierung können Sie die Einbettungen für jede Partition aktualisieren, einschließlich der Stammpartition, der Unterpartitionen oder der einzelnen Blattpartitionen. Bei großen Datasets können Sie die Leistung verbessern, indem Sie Einbettungen für verschiedene Partitionen parallel über verschiedene Datenbankverbindungen aktualisieren:

  • Führen Sie Folgendes aus, um die gesamte Tabelle zu aktualisieren:
CALL ai.refresh_embeddings(
    table_name => 'documents', -- This is the root partitioned table
    embedding_column => 'content_embeddings'
);
  • Führen Sie Folgendes aus, um eine einzelne Partition zu aktualisieren:
CALL ai.refresh_embeddings(
    table_name => 'documents_eu',
    embedding_column => 'content_embeddings'
);

Einbettungen für neu hinzugefügte oder angehängte Partitionen aktualisieren

Die Funktion zum automatischen Einbetten unterstützt das Generieren von Einbettungen für Partitionen, die nach der Ersteinrichtung in Ihre Haupttabelle aufgenommen werden. Die genauen Schritte hängen davon ab, ob Sie eine völlig neue Partition hinzufügen oder eine vorhandene Tabelle anhängen.

  • Neu hinzugefügte Partition: Wenn Sie der Tabelle eine neue Partition hinzufügen, können Sie Einbettungen dafür generieren, indem Sie ai.refresh_embeddings für die neue Partition aufrufen.
-- 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'
);
  • Neu angehängte Partition: Wenn Sie eine vorhandene Tabelle als Partition anhängen möchten, verwenden Sie zuerst die Prozedur ai.embedding_prepare_partition, um sicherzustellen, dass ihr Schema mit der partitionierten Tabelle kompatibel ist. Mit der Funktion zum automatischen Einbetten können Sie Partitionen auf jeder Ebene einer hierarchischen Partitionierung hinzufügen oder anhängen. Die Prozedur ai.embedding_prepare_partition sorgt dafür, dass das Schema mit jeder übergeordneten Tabelle in der Hierarchie kompatibel ist.

Wenn Sie eine vorhandene Tabelle als Partition anhängen möchten, verwenden Sie zuerst die Prozedur ai.embedding_prepare_partition, um sicherzustellen, dass ihr Schema mit dem der partitionierten Tabelle kompatibel ist:

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

Mit der Funktion zum automatischen Einbetten können Sie Partitionen auf jeder Ebene einer hierarchischen Partitionierung hinzufügen oder anhängen. Die Prozedur ai.embedding_prepare_partition sorgt dafür, dass das Schema mit jeder übergeordneten Tabelle in der Hierarchie kompatibel ist:

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

Fortschritt der Einbettungserstellung überwachen

Sie können den Echtzeitstatus aktiver initialize_embeddings- und refresh_embeddings-Anrufe abrufen, indem Sie die ai.embedding_progress_view abfragen. In dieser Ansicht finden Sie Details zum Fortschritt des Vorgangs, z. B. den Prozentsatz der abgeschlossenen Schritte, die verstrichene Zeit und die geschätzte verbleibende Zeit.

Führen Sie die folgende Abfrage aus, um den Fortschritt zu prüfen:

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

Die Ansicht enthält die folgenden Informationen:

Spalte Beschreibung
table_name Der Name der Tabelle oder Partition, die verarbeitet wird.
content_column Die Spalte mit dem Quellinhalt für die Einbettung.
embedding_column Die Spalte, in der die Einbettungen gespeichert werden.
model_id Das für die Generierung verwendete Modell.
percent_progress Der Prozentsatz des Vorgangs, der abgeschlossen ist.
status Der aktuelle Status des Vorgangs (z.B. „Wird ausgeführt“, „Erfolgreich“).
elapsed_time Die Zeit, die seit Beginn des Vorgangs vergangen ist.
rows_processed Die Anzahl der bisher verarbeiteten Zeilen.
partition_root Der Name der partitionierten Stamm-Tabelle.

Beispiele für das Generieren von Einbettungen in Auto

In diesem Abschnitt finden Sie Beispiele für das automatische Generieren von Einbettungen mit registrierten Modellendpunkten.

OpenAI-Modell zur Einbettung

Führen Sie die folgende Anweisung aus, um Einbettungen mit dem von OpenAI bereitgestellten registrierten text-embedding-3-small-Modellendpunkt zu generieren:

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

Benutzerdefinierte Einbettungsmodelle

Für eigene oder extern unterstützte Modelle müssen Sie Ein- und Ausgabetransformationsfunktionen definieren und mit ai.create_model registrieren. Wenn Sie die Funktion für automatisches Einbetten verwenden möchten, müssen Sie sowohl skalare Transformationsfunktionen (z. B. acme_text_input_transform, acme_text_output_transform) als auch Batch-Transformationsfunktionen (z. B. acme_text_batch_input_transform, acme_text_batch_output_transform) angeben.

Nächste Schritte