Diese Seite wurde von der Cloud Translation API übersetzt.

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

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 Umfang. 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 automatischen Vektoreinbettungen in AlloyDB können Sie die Generierung und Verwaltung 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 synchronisieren: 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.

Hinweise

Bevor Sie Vektoreinbettungen für große Tabellen generieren und verwalten können, müssen Sie Folgendes tun:

Stellen Sie mit psql oder AlloyDB for PostgreSQL Studio als postgres-Nutzer eine Verbindung zu Ihrer Datenbank her.
Prüfen Sie, ob die Erweiterung google_ml_integration installiert ist.
Prüfen Sie, ob das Flag „google_ml_integration.enable_model_support“ auf on gesetzt ist.
Prüfen Sie, ob die google_ml_integration-Erweiterung Version 1.5.2 oder höher hat und das google_ml_integration.enable_faster_embedding_generation-Flag auf on gesetzt ist.

So prüfen Sie die Version Ihrer Erweiterung mit dem folgenden Befehl:
```
SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';
```
Wenn Sie die Erweiterung aktualisieren müssen, verwenden Sie den Befehl ALTER EXTENSION google_ml_integration UPDATE;.

Hinweis :Wenn Sie nicht die erforderlichen Berechtigungen haben, wenden Sie sich an Ihren Datenbankadministrator, um das Update durchzuführen. Alternativ können Sie warten, bis die neue Version automatisch auf Ihren Cluster angewendet wird.
Bevor Sie Einbettungen aus einer AlloyDB-Datenbank generieren können, müssen Sie AlloyDB 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 Einbettungserstellung verwalten soll, gewähren Sie 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.
Prüfen Sie, ob AUTOCOMMIT im verwendeten PostgreSQL-Client auf ON festgelegt ist.
Prüfen Sie, ob das von Ihnen verwendete Einbettungsmodell ein ausreichendes Kontingent für automatische Vektoreinbettungen hat. Ein unzureichendes Kontingent kann zu einer langsamen oder fehlgeschlagenen automatischen Einbettung führen. Hier sind beispielsweise die Grenzwerte für Vertex AI-Modelle für Einbettungen:
- Limits für Texteinbettungen: Jede Anfrage kann bis zu 250 Eingabetexte enthalten, für die jeweils eine Einbettung generiert wird, und 20.000 Tokens pro Anfrage. Für die Berechnung der Einbettungen werden nur die ersten 2.048 Tokens in jedem Eingabetext verwendet.
- Anfragen pro Minute:
  - base_model : text-embedding : 1500
  - base_model : gemini-embedding : 100000
- Tokenlimit für Gemini-Einbettungsmodelle: Im Gegensatz zu anderen Einbettungsmodellen, die hauptsächlich durch RPM-Kontingente begrenzt wurden, ist die Gemini-Einbettungsmodellreihe auf 5.000.000 Tokens pro Minute und Projekt begrenzt.

Einbettungen für eine Tabelle initialisieren

Die Funktionen zum Verwalten von automatischen Vektoreinbettungen sind im ai-Schema verfügbar. Dieses Schema bietet eine Schnittstelle für die neuesten KI-Funktionen in AlloyDB.

Mit der SQL-Funktion ai.initialize_embeddings() können Sie Einbettungen für die Inhaltsspalte einer Tabelle generieren. Dies ist ein blockierender Aufruf:

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.

Bevor Sie Einbettungen generieren, erstellen Sie eine Spalte content_embeddings in Ihrer Tabelle. Diese Spalte hat in der Regel den Typ vector(DIMENSION) und den Wert DEFAULT NULL.

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

Batchgenerierung durchführen

Standardmäßig verwendet AlloyDB 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 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 steuern, indem Sie eine bevorzugte Batchgröße für direkt unterstützte Modelle vorschlagen. AlloyDB 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.

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[][];

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

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.

Einbettungen inkrementell aktualisieren

Wenn Sie ein Embedding aktualisieren, wird es auf Grundlage des neuesten Werts in der Spalte für Eingabeinhalte neu generiert.

Damit Sie die Konsistenz und Leistung besser steuern können, unterstützt AlloyDB 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 Overhead 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. Wenn Sie den Modus transactional verwenden möchten, 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'
);
```
none: Dies ist der Standardmodus. In diesem Modus werden Einbettungen in AlloyDB nicht automatisch aktualisiert. Inkrementelle Änderungen werden nicht erfasst. Wenn Sie die Funktion ai.refresh_embeddings() aufrufen, werden die Einbettungen für die gesamte Tabelle neu generiert. In diesem Modus haben Sie die vollständige Kontrolle.

Alle Einbettungen für eine Tabelle aktualisieren

Nachdem Sie ai.initialize_embeddings() für eine Tabelle erfolgreich ausgeführt haben, können Sie die Einbettungen mit der Funktion ai.refresh_embeddings() neu generieren. Mit einem Aktualisierungsvorgang können Sie Einbettungen für Zeilen aktualisieren, die während des ursprünglichen initialize_embeddings-Aufrufs gleichzeitig geändert werden, oder eine regelmäßige vollständige Aktualisierung durchführen.

Die Aktualisierungsfunktion verwendet die Einstellungen aus dem ursprünglichen Aufruf wieder. Sie müssen also nur die Tabelle und die Spalte für Einbettungen 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
);

Um das Problem zu beheben, reduzieren Sie den Wert von batch_size in Ihrem Funktionsaufruf und versuchen Sie es noch einmal.

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 Erstellen von Vektoreinbettungen werden Zeilen in Batches aktualisiert. Dabei wird die standardmäßige Sperrung auf Zeilenebene verwendet. Das bedeutet, dass gleichzeitige DML-Vorgänge wie UPDATE oder DELETE nur kurz blockiert werden, wenn sie versuchen, dieselben Zeilen zu ändern, die vom Einbettungsprozess aktualisiert werden. Abfragen von anderen Verbindungen werden nicht blockiert. Beachten Sie, dass mit initialize_embeddings Zeilen übersprungen werden, die gleichzeitig geändert werden. Wenn incremental_refresh_mode gleich none ist, werden die Einbettungen für diese geänderten Zeilen erst bei einem nachfolgenden Aktualisierungsaufruf aktualisiert.

-- connection1 (starts embedding generation)
SELECT
  ai.initialize_embeddings(
    model_id => 'text-embedding-005',
    table_name => 'user_reviews',
    content_column => 'content',
    embedding_column => 'content_embeddings'
  );

-- connection2 (performs DMLs/queries without blocking)
INSERT INTO user_reviews(id, review_time, is_edited, content)
VALUES (48290, now(), false, 'I really liked the product functionality, but wish it came in orange color');

UPDATE user_reviews
SET is_edited = TRUE, content = 'Changing to 5 star. My issue is resolved by the support'
WHERE id = 700;

Wenn Sie initialize_embeddings mit pg_cancel abbrechen oder initialize_embeddings aufgrund eines internen Fehlers fehlschlägt, wird ein Fehlerstatus zurückgegeben. Alle erfolgreich erstellten Vektoreinbettungen werden nicht zurückgesetzt. Um den Fehler zu beheben und die Erstellung von Vektoreinbettungen abzuschließen, müssen Sie zuerst die Konfiguration mit der Funktion ai.drop_embedding_config() bereinigen und dann den Aufruf ai.initialize_embeddings() noch einmal ausführen.

Wenn Sie die Einbettungen für gleichzeitig geänderte Zeilen aktualisieren möchten, rufen Sie ai.refresh_embeddings auf, nachdem der ai.initialize_embeddings-Aufruf abgeschlossen ist. Bei diesem Aktualisierungsaufruf werden die Einbettungen für die gesamte Tabelle neu generiert.

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 Bereinigung durchführen oder die Einbettungsverwaltung für eine Spalte neu konfigurieren.

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

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 für Einbettungen

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',
    chunk_column => 'content',
    embedding_column => 'content_embeddings'
);

Benutzerdefinierte Einbettungsmodelle

Für eigene oder extern unterstützte Modelle müssen Sie Eingabe- 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.