Verwenden von textembedding-gecko@003 für Vektoreinbettungen

1. Einführung

Zuletzt aktualisiert:8. April 2024

Texteinbettung

Text-Embedding bezieht sich auf die Umwandlung von Textdaten in numerische Darstellungen. Diese numerischen Darstellungen, oft Vektoren, erfassen die semantische Bedeutung und die Beziehungen zwischen Wörtern in einem Text. Stellen Sie sich Folgendes vor:

Text ist wie eine komplexe Sprache, voller Nuancen und Mehrdeutigkeiten.

Beim Text-Embedding wird diese Sprache in ein einfacheres mathematisches Format übersetzt, das Computer verstehen und bearbeiten können.

Vorteile von Texteinbettungen

• Ermöglicht eine effiziente Verarbeitung: Numerische Darstellungen können von Computern viel schneller verarbeitet werden als Rohtext. Dies ist für Aufgaben wie Suchmaschinen, Empfehlungssysteme und maschinelle Übersetzungen entscheidend.
• Sie erfassen die semantische Bedeutung: Einbettungen gehen über die wörtliche Bedeutung von Wörtern hinaus. Sie erfassen den Kontext und die Beziehungen zwischen Wörtern und ermöglichen so eine differenziertere Analyse.
• Verbesserte Leistung bei der Verarbeitung von Texten: Text-Embeddings können als Merkmale in Machine-Learning-Modellen verwendet werden, was zu einer besseren Leistung bei Aufgaben wie Sentimentanalyse, Textklassifizierung und Themenmodellierung führt.

Anwendungsfälle für Text-Embeddings

Texteinbettungen ermöglichen durch die Umwandlung von Text in numerische Darstellungen eine Vielzahl von Anwendungen in der Verarbeitung natürlicher Sprache (Natural Language Processing, NLP). Hier sind einige wichtige Anwendungsfälle:

1. Suchmaschinen und Informationsabruf:

Mit Text-Embeddings können Suchmaschinen die semantische Bedeutung von Suchanfragen verstehen und sie mit relevanten Dokumenten abgleichen, auch wenn die genauen Keywords nicht vorhanden sind.

Durch den Vergleich der Embeddings einer Suchanfrage mit Dokument-Embeddings können Suchmaschinen Dokumente finden, die ähnliche Themen oder Konzepte behandeln.

2. Empfehlungssysteme:

Empfehlungssysteme verwenden Text-Embeddings, um das Nutzerverhalten und die Präferenzen zu analysieren, die in Rezensionen, Bewertungen oder im Browserverlauf zum Ausdruck kommen.

Das System kann dann ähnliche Elemente empfehlen, indem es die Einbettungen von Produkten, Artikeln oder anderen Inhalten vergleicht, mit denen der Nutzer interagiert hat.

3. Plagiatserkennung:

Durch den Vergleich der Einbettungen zweier Textstücke können Sie potenzielles Plagiat erkennen, indem Sie signifikante Ähnlichkeiten in ihrer semantischen Struktur finden.

Dies sind nur einige Beispiele. Mit der Weiterentwicklung der Text-Embedding-Techniken werden immer mehr Möglichkeiten eröffnet. Da Computer durch embeddings die Sprache besser verstehen, können wir in Zukunft noch mehr innovative Anwendungen erwarten.

textembedding-gecko@003

„Textembedding-gecko@003“ ist eine bestimmte Version eines vorab trainierten Modells für Text-Embeddings, das von der Google Cloud Platform (GCP) über Vertex AI und die zugehörigen KI-Tools und ‑Dienste angeboten wird.

Umfang

In diesem Codelab erstellen Sie ein Python-Script. Mit diesem Skript wird Folgendes ausgeführt:

• Verwenden Sie die Vertex API, um textembedding-gecko@003 aufzurufen und Text in Texteinbettungen (Vektoren) umzuwandeln.
• Simulierte Datenbank mit Text und Vektoren erstellen
• Führen Sie eine Abfrage in unserer simulierten Vektordatenbank durch, indem Sie die Vektoren vergleichen und die wahrscheinlichste Antwort erhalten.

Aufgaben in diesem Lab

• Text-Embedding in der GCP verwenden
• textembedding-gecko@003 aufrufen
• So führen Sie das in Workbench aus
• Scripts mit Vertex AI Workbench ausführen

Voraussetzungen

• Eine aktuelle Version von Chrome
• Python-Kenntnisse
• Ein Google Cloud-Projekt
• Zugriff auf Vertex AI – Workbench

2. Einrichtung

Vertex AI Workbench-Instanz erstellen

1. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

Hinweis:Wenn Sie die Ressourcen, die Sie in diesem Verfahren erstellen, nicht behalten möchten, erstellen Sie ein Projekt, anstatt ein vorhandenes Projekt auszuwählen. Wenn Sie fertig sind, können Sie das Projekt löschen und dadurch alle mit dem Projekt verknüpften Ressourcen entfernen.

2. Projektauswahl aufrufen
3. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.
4. Notebooks API aktivieren.

Sie können eine Vertex AI Workbench-Instanz mit der Google Cloud Console, der gcloud CLI oder Terraform erstellen. In dieser Anleitung erstellen wir sie mit der Google Cloud Console. Weitere Informationen zu den anderen Methoden

1. Rufen Sie in der Google Cloud Console die Seite „Instanzen“ auf. Sie finden sie im Vertex AI-Menü im Bereich „Notebooks“. Klicken Sie auf „Workbench“.
2. Rufen Sie „Instanzen“ auf.
3. Klicken Sie auf „Neu erstellen“.
4. Geben Sie im Dialogfeld „Instanz erstellen“ im Abschnitt „Details“ die folgenden Informationen für Ihre neue Instanz ein:

Notebookname: Geben Sie einen Namen für Ihre neue Instanz ein. Der Name muss mit einem Buchstaben beginnen, gefolgt von bis zu 62 Kleinbuchstaben, Ziffern oder Bindestrichen (-). Das letzte Zeichen darf kein Bindestrich sein.

Region und Zone: Wählen Sie eine Region und eine Zone für die neue Instanz aus. Wählen Sie für eine optimale Netzwerkleistung die Region aus, die Ihnen geografisch am nächsten liegt.

Keine GPU erforderlich

Geben Sie im Abschnitt „Netzwerk“ Folgendes an:

Netzwerk: Passen Sie die Netzwerkoptionen an, um ein Netzwerk in Ihrem aktuellen Projekt oder ein freigegebenes VPC-Netzwerk aus einem Hostprojekt zu verwenden, falls eines konfiguriert ist. Wenn Sie eine freigegebene VPC im Hostprojekt verwenden, müssen Sie dem Notebooks-Dienst-Agent aus dem Dienstprojekt auch die Rolle „Compute Network User“ (roles/compute.networkUser) zuweisen.

Im Feld „Netzwerk“: Wählen Sie das gewünschte Netzwerk aus. Sie können dabei auch ein VPC-Netzwerk auswählen, sofern das Netzwerk über privaten Google-Zugriff verfügt oder auf das Internet zugreifen kann.

Im Feld „Subnetzwerk“:Wählen Sie das gewünschte Subnetzwerk aus. Sie können die Standardoption auswählen.

Sie können die Standardeinstellung für die Instanzeigenschaften beibehalten, also „e2-standard-4“.

5. Klicken Sie auf „Erstellen“.

Vertex AI Workbench erstellt eine Instanz und startet sie automatisch. Sobald die Instanz einsatzbereit ist, aktiviert Vertex AI Workbench den Link „JupyterLab öffnen“. Wählen Sie diese Option aus.

Python 3-Notebook erstellen

1. Klicken Sie in JupyterLab im Launcher im Bereich „Notebook“ auf das Symbol mit dem Python-Logo, das „Python3“ lautet.
2. Ein Jupyter-Notebook mit dem Namen „Untitled“ und der Erweiterung „ipynb“ wird erstellt.
3. Sie können den Namen im Dateibrowser auf der linken Seite ändern oder ihn unverändert lassen.

Jetzt können wir unseren Code in das Notebook einfügen.

3. Erforderliche Bibliotheken importieren

Nachdem die Instanz erstellt und JupyterLab geöffnet wurde, müssen wir alle erforderlichen Bibliotheken für unser Codelab installieren.

Wir benötigen Folgendes:

1. numpy
2. pandas
3. TextEmbeddingInput, TextEmbeddingModel von vertexai.language_models

TIPP:In Workbench-Instanzen sind standardmäßig alle oben genannten Bibliotheken installiert. Sie müssen sie also nur aufrufen.

Kopieren Sie den folgenden Code und fügen Sie ihn in eine Zelle ein:

from vertexai.language_models import TextEmbeddingInput, TextEmbeddingModel

import numpy as np
import pandas as pd

Dies würde in etwa so aussehen:

4. Simulierte Vektordatenbank erstellen

Um unseren Code zu testen, erstellen wir eine Datenbank mit Text und den entsprechenden Vektoren, die mit dem Text-Embedding-Modell „gecko@003“ übersetzt wurden.

Ziel ist es, dass Nutzer nach Text suchen, ihn in einen Vektor umwandeln, in unserer Datenbank danach suchen und das am besten passende Ergebnis zurückgeben.

Unsere Vektordatenbank enthält drei Einträge. So erstellen wir sie:

Kopieren Sie den folgenden Code und fügen Sie ihn in eine neue Zelle ein.

DOCUMENT1 = {
    "title": "Operating the Climate Control System",
    "content": "Your Googlecar has a climate control system that allows you to adjust the temperature and airflow in the car. To operate the climate control system, use the buttons and knobs located on the center console.  Temperature: The temperature knob controls the temperature inside the car. Turn the knob clockwise to increase the temperature or counterclockwise to decrease the temperature. Airflow: The airflow knob controls the amount of airflow inside the car. Turn the knob clockwise to increase the airflow or counterclockwise to decrease the airflow. Fan speed: The fan speed knob controls the speed of the fan. Turn the knob clockwise to increase the fan speed or counterclockwise to decrease the fan speed. Mode: The mode button allows you to select the desired mode. The available modes are: Auto: The car will automatically adjust the temperature and airflow to maintain a comfortable level. Cool: The car will blow cool air into the car. Heat: The car will blow warm air into the car. Defrost: The car will blow warm air onto the windshield to defrost it."}

DOCUMENT2 = {
    "title": "Touchscreen",
    "content": "Your Googlecar has a large touchscreen display that provides access to a variety of features, including navigation, entertainment, and climate control. To use the touchscreen display, simply touch the desired icon.  For example, you can touch the \"Navigation\" icon to get directions to your destination or touch the \"Music\" icon to play your favorite songs."}

DOCUMENT3 = {
    "title": "Shifting Gears",
    "content": "Your Googlecar has an automatic transmission. To shift gears, simply move the shift lever to the desired position.  Park: This position is used when you are parked. The wheels are locked and the car cannot move. Reverse: This position is used to back up. Neutral: This position is used when you are stopped at a light or in traffic. The car is not in gear and will not move unless you press the gas pedal. Drive: This position is used to drive forward. Low: This position is used for driving in snow or other slippery conditions."}

documents = [DOCUMENT1, DOCUMENT2, DOCUMENT3]

df_initial_db = pd.DataFrame(documents)
df_initial_db.columns = ['Title', 'Text']
df_initial_db

Das würde so aussehen:

Code analysieren

In den Variablen DOCUMENT1, DOCUMENT2 und DOCUMENT3 speichern wir ein Wörterbuch, das Dokumente mit ihren Titeln und Inhalten emuliert. Diese „Dokumente“ beziehen sich auf eine simulierte Bedienungsanleitung für ein von Google hergestelltes Auto.

In der nächsten Zeile erstellen wir eine Liste aus diesen drei Dokumenten (Wörterbüchern).

documents = [DOCUMENT1, DOCUMENT2, DOCUMENT3]

Mithilfe von Pandas erstellen wir dann einen DataFrame aus dieser Liste, der df_initial_db genannt wird.

df_initial_db = pd.DataFrame(documents)
df_initial_db.columns = ['Title', 'Text']
df_initial_db

5. Texteinbettungen erstellen

Wir erhalten jetzt für jeden Datensatz in unserer simulierten Datenbank mit Dokumenten ein Text-Embedding mit dem Modell „gecko@003“.

Kopieren Sie den folgenden Code und fügen Sie ihn in eine neue Zelle ein:

def embed_fn(df_input):
    list_embedded_values = []
    for index, row in df_input.iterrows():        
        model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
        embeddings = model.get_embeddings([(row['Text'])])        
        list_embedded_values.append(embeddings[0].values)
    df_input['Embedded text'] = list_embedded_values
    return df_input        
                                           
df_embedded_values_db = embed_fn(df_initial_db)
df_embedded_values_db      

Das würde so aussehen:

Code analysieren

Wir haben eine Funktion namens „embed_fn“ definiert, die als Eingabe einen Pandas-DataFrame mit dem Text für das Einbetten erhält. Die Funktion gibt dann den Text als Vektor zurück.

def embed_fn(df_input):
    list_embedded_values = []
    for index, row in df_input.iterrows():        
        model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
        embeddings = model.get_embeddings([(row['Text'])])        
        list_embedded_values.append(embeddings[0].values)
    df_input['Embedded text'] = list_embedded_values
    return df_input             

In der Liste „list_embedded_values“ speichern und hängen wir den codierten Text jeder Zeile an.

Mit der Methode „iterrows“ von pandas können wir jede Zeile im DataFrame durchgehen und die Werte aus der Spalte „Text“ abrufen, die die manuellen Informationen aus unserer simulierten Datenbank enthält.

Um regulären Text zu senden und seinen Vektor mit dem Modell „gecko@003“ zurückzugeben, initialisieren wir die Variable „model“, in der wir das zu verwendende Modell durch Aufrufen der Funktion „TextEmbeddingModel.from_pretrained“ festlegen.

model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
embeddings = model.get_embeddings([(row['Text'])])                     

Anschließend erfassen wir in den Variablen-Embeddings den Vektor des Textes, den wir über die Funktion „model.get_embeddings“ senden.

Am Ende der Funktion erstellen wir eine neue Spalte im Dataframe namens „Eingebetteter Text“. Diese enthält die Liste der Vektoren, die auf Grundlage des Modells „gecko@003“ erstellt wurden.

df_input['Embedded text'] = list_embedded_values
return df_input             

In der Variablen „df_embedded_values_db“ speichern wir den DataFrame mit den ursprünglichen Daten aus der simulierten Datenbank sowie eine neue Spalte mit der Liste der Vektoren für jede Zeile.

df_embedded_values_db = embed_fn(df_initial_db)
df_embedded_values_db      

6. Frage an die Vektordatenbank stellen

Da unsere Datenbank jetzt Text und die zugehörigen Vektoren enthält, können wir eine Frage stellen und unsere Datenbank abfragen, um eine Antwort zu erhalten.

Kopieren Sie dazu den folgenden Code und fügen Sie ihn in eine neue Zelle ein:

question='How do you shift gears in the Google car?'
model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
embeddings = model.get_embeddings([(question)])        
text_to_search=embeddings[0].values
len(text_to_search)

Das Ergebnis würde in etwa so aussehen:

Code analysieren

Ähnlich wie bei der Funktion aus dem vorherigen Schritt initialisieren wir zuerst die Variable „Frage“ mit der Frage, die wir an unsere Datenbank stellen möchten.

question='How do you shift gears in the Google car?'

Anschließend legen wir in der Modellvariablen das gewünschte Modell über die Funktion „TextEmbeddingModel.from_pretrained“ fest. In diesem Fall ist das das Modell „gecko@003“.

model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")

In der Variablen „embeddings“ rufen wir die Funktion „model.get_embeddings“ auf und übergeben den Text, der in einen Vektor umgewandelt werden soll. In diesem Fall übergeben wir die Frage, die gestellt werden soll.

embeddings = model.get_embeddings([(question)])        

Die Variable „text_to_search“ enthält schließlich die Liste der aus der Frage übersetzten Vektoren.

Wir drucken die Länge des Vektors nur als Referenz aus.

text_to_search=embeddings[0].values
len(text_to_search)

7. Vektoren vergleichen

Wir haben jetzt eine Liste von Vektoren in unserer simulierten Datenbank und eine Frage, die in einen Vektor umgewandelt wurde. Wir können also den Vektor der Frage mit allen Vektoren in unserer Datenbank vergleichen, um herauszufinden, welcher am ehesten zur Beantwortung unserer Frage passt.

Dazu messen wir den Abstand zwischen dem Vektor der Frage und jedem Vektor der Datenbank. Es gibt mehrere Methoden, um Entfernungen zwischen Vektoren zu messen. In diesem Codelab verwenden wir die euklidische Entfernung oder L2-Norm.

In Python können wir dazu die numpy-Funktion verwenden.

Kopieren Sie den folgenden Code und fügen Sie ihn in eine neue Zelle ein:

list_embedded_text_from_db = df_embedded_values_db['Embedded text']
shortest_distance=1
for position, embedded_value in enumerate(list_embedded_text_from_db):
    distance=np.linalg.norm((np.array(embedded_value) - np.array(text_to_search)), ord = 2)
    print(distance)
    if distance<shortest_distance:
        shortest_distance=distance
        shortest_position=position
        
print(f'The shortest distance is {shortest_distance} and the position of that value is {shortest_position}')

Das Ergebnis sollte in etwa so aussehen:

Code analysieren

Zuerst wandeln wir die Spalte mit dem eingebetteten Text oder die Vektoren unserer Datenbank in eine Liste um und speichern sie in „list_embedded_text_from_db“.

Außerdem haben wir die Variable „shortest_distance“ mit dem Wert 1 initialisiert, um sie so lange zu aktualisieren, bis wir die tatsächlich kürzeste Entfernung gefunden haben.

list_embedded_text_from_db = df_embedded_values_db['Embedded text']
shortest_distance=1

Mit einer For-Schleife iterieren wir dann und erhalten die Entfernung zwischen dem Vektor aus der Frage und jedem Vektor in der Datenbank.

Mit der numpy-Funktion „linalg.norm“ berechnen wir die Entfernung.

Wenn die berechnete Entfernung kleiner als die in der Variablen „kürzeste_entfernung“ ist, wird die berechnete Entfernung auf diese Variable festgelegt.

Anschließend erfassen wir die kürzeste Entfernung sowie die Position in der Liste, an der sie gefunden wurde. In den Variablen „shortest_distance“ und „shortest_position“.

for position, embedded_value in enumerate(list_embedded_text_from_db):
    distance=np.linalg.norm((np.array(embedded_value) - np.array(text_to_search)), ord = 2)
    print(distance)
    if distance<shortest_distance:
        shortest_distance=distance
        shortest_position=position

8. Ergebnisse

Wenn wir die Position in der Liste des Vektors kennen, der die kürzeste Entfernung zwischen der Frage und der Datenbank hat, können wir die Ergebnisse ausdrucken.

Kopieren Sie den folgenden Code und fügen Sie ihn in eine neue Zelle ein:

print("Your question was:\n "+question+ " \nAnd our answer is:\n "+
      df_embedded_values_db.at[shortest_position, 'Title']+": "+
      df_embedded_values_db.at[shortest_position, 'Text'])

Nach der Ausführung sehen Sie in etwa Folgendes:

9. Glückwunsch

Herzlichen Glückwunsch! Sie haben Ihre erste Anwendung mit dem Modell „textembedding-gecko@003“ in einem echten Anwendungsfall erstellt.

Sie haben die Grundlagen von Text-Embeddings und die Verwendung des gecko003-Modells in der GCP Workbench kennengelernt.

Sie kennen jetzt die wichtigsten Schritte, die erforderlich sind, um Ihr Wissen auf weitere Anwendungsfälle anzuwenden.

Was liegt als Nächstes an?

Sehen Sie sich einige dieser Codelabs an:

• Erste Schritte mit Vektoreinbettungen in AlloyDB AI

Referenzdokumente

• Texteinbettungen
• Einführung in Vertex AI Workbench
• Dokumentensuche mit Einbettungen