Verwenden von textembedding-gecko@003 für Vektoreinbettungen

1. Einführung

Letzte Aktualisierung:08.04.2024

Texteinbettung

Bei der Texteinbettung werden Textdaten in numerische Darstellungen umgewandelt. 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.

Bei der Texteinbettung wird diese Sprache in ein einfacheres, mathematisches Format übersetzt, das von Computern verstanden und manipuliert werden kann.

Vorteile der Texteinbettung

• Effiziente Verarbeitung: Numerische Darstellungen können von Computern viel schneller verarbeitet werden als Rohtext. Das ist entscheidend für Aufgaben wie Suchmaschinen, Empfehlungssysteme und maschinelle Übersetzung.
• Erfassung der semantischen 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.
• Verbesserung der Leistung von Machine-Learning-Modellen: Texteinbettungen können als Features in Machine-Learning-Modellen verwendet werden, was zu einer besseren Leistung bei Aufgaben wie Sentimentanalyse, Textklassifizierung und Themenmodellierung führt.

Anwendungsfälle der Texteinbettung

Durch die Umwandlung von Text in numerische Darstellungen eröffnen Texteinbettungen eine Vielzahl von Anwendungen im Bereich der Verarbeitung natürlicher Sprache (Natural Language Processing, NLP). Hier einige wichtige Anwendungsfälle:

1. Suchmaschinen und Informationsabruf:

Texteinbettungen ermöglichen es Suchmaschinen, die semantische Bedeutung hinter Abfragen zu verstehen und sie mit relevanten Dokumenten abzugleichen, auch wenn die genauen Keywords nicht vorhanden sind.

Durch den Vergleich der Einbettungen einer Suchanfrage mit Dokumenteinbettungen können Suchmaschinen Dokumente identifizieren, die ähnliche Themen oder Konzepte behandeln.

2. Empfehlungssysteme:

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

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

3. Plagiaterkennung:

Durch den Vergleich der Einbettungen von zwei Texten können potenzielle Plagiate erkannt werden, indem signifikante Ähnlichkeiten in ihrer semantischen Struktur gefunden werden.

Das sind nur einige Beispiele und die Möglichkeiten wachsen mit der Weiterentwicklung der Texteinbettungstechniken. Da Computer durch Einbettungen ein besseres Verständnis von Sprache erlangen, können wir in Zukunft noch mehr innovative Anwendungen erwarten.

textembedding-gecko@003

Textembedding-gecko@003 ist eine bestimmte Version eines vortrainierten Texteinbettungsmodells, das von der Google Cloud Platform (GCP) über Vertex AI und die Suite von KI-Tools und ‑Diensten angeboten wird.

Was Sie erstellen

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

• Mit der Vertex API wird textembedding-gecko@003 aufgerufen und Text in Texteinbettungen (Vektoren) umgewandelt.
• Es wird eine simulierte Datenbank aus Text und den zugehörigen Vektoren erstellt.
• Es wird eine Abfrage für unsere simulierte Vektordatenbank ausgeführt, indem die Vektoren verglichen werden, und die wahrscheinlichste Antwort wird abgerufen.

Lerninhalte

• Verwendung der Texteinbettung in der GCP
• Aufrufen von textembedding-gecko@003
• Ausführen in Workbench
• Ausführen von Skripts mit Vertex AI Workbench

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 in dieser Anleitung erstellten Ressourcen nicht behalten möchten, erstellen Sie ein Projekt, anstatt ein vorhandenes auszuwählen. Nachdem Sie diese Schritte ausgeführt haben, können Sie das Projekt löschen und damit alle Ressourcen entfernen, die mit dem Projekt verknüpft sind.

2. Zur Projektauswahl
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. Für diese Anleitung erstellen wir sie mit der Google Cloud Console. Weitere Informationen zu den anderen Methoden finden Sie hier.

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 die Seite „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:

Name: Geben Sie einen Namen für Ihre neue Instanz ein. Der Name muss mit einem Buchstaben beginnen und darf maximal 62 Kleinbuchstaben, Zahlen oder Bindestriche (-) enthalten. Er darf nicht mit einem Bindestrich enden.

Region und Zone: Wählen Sie eine Region und die 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.

GPU muss nicht installiert werden.

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, wenn eines konfiguriert ist. Wenn Sie eine freigegebene VPC im Hostprojekt verwenden, müssen Sie auch dem Notebooks-Dienst-Agent aus dem Dienstprojekt die Rolle „Compute Network User“ (roles/compute.networkUser) zuweisen.

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.

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

In den Instanzeigenschaften können Sie die Standardeinstellung beibehalten, d. h. „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“. Klicken Sie darauf.

Python 3-Notebook erstellen

1. Klicken Sie in JupyterLab im Launcher im Bereich „Notebook“ auf das Symbol mit dem Python-Logo und der Aufschrift „Python 3“.
2. Ein Jupyter-Notebook mit dem Namen „Untitled“ und der Erweiterung „ipynb“ wird erstellt.
3. Sie können es im Dateibrowser auf der linken Seite umbenennen oder es so 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:

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

TIPP:Standardmäßig sind alle oben genannten Bibliotheken in Workbench-Instanzen bereits installiert. Wir 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 aus Text und den entsprechenden Vektoren, die mit dem Texteinbettungsmodell gecko@003 übersetzt wurden.

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

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 Dictionary, das Dokumente mit ihren Titeln und Inhalten simuliert. Diese „Dokumente“ verweisen auf ein simuliertes Handbuch für ein von Google hergestelltes Auto.

In der nächsten Zeile erstellen wir eine Liste aus diesen drei Dokumenten (Dictionaries).

documents = [DOCUMENT1, DOCUMENT2, DOCUMENT3]

Schließlich erstellen wir mit pandas ein Dataframe aus dieser Liste, das den Namen „df_initial_db“ erhält.

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

5. Texteinbettungen erstellen

Jetzt erstellen wir mit dem Modell gecko@003 eine Texteinbettung für jeden Eintrag in unserer simulierten Datenbank mit Dokumenten.

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 ein pandas-Dataframe mit dem Text für die Einbettung erhält. Die Funktion gibt dann den Text als Vektor codiert 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 fügen wir den codierten Text jeder Zeile hinzu.

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

Um normalen Text zu senden und den zugehörigen Vektor mit dem Modell gecko@003 zurückzugeben, initialisieren wir die Variable „model“, in der wir das zu verwendende Modell festlegen, indem wir die Funktion „TextEmbeddingModel.from_pretrained“ aufrufen.

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

In der Variablen „embeddings“ erfassen wir dann den Vektor des Texts, den wir über die Funktion „model.get_embeddings“ senden.

Am Ende der Funktion erstellen wir eine neue Spalte im Dataframe mit dem Namen „Embedded text“, die die Liste der Vektoren enthält, die auf der Grundlage des Modells gecko@003 erstellt wurden.

df_input['Embedded text'] = list_embedded_values
return df_input             

Schließlich erfassen wir in der Variablen „df_embedded_values_db“ das Dataframe mit unseren 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

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

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 „question“ mit der Frage, die wir an unsere Datenbank stellen möchten.

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

Dann legen wir in der Variablen „model“ das zu verwendende Modell über die Funktion „TextEmbeddingModel.from_pretrained“ fest. In diesem Fall ist es 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.

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

Schließlich enthält die Variable „text_to_search“ die Liste der Vektoren, die aus der Frage übersetzt wurden.

Wir geben 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 jetzt den Vektor der Frage mit allen Vektoren in unserer Datenbank vergleichen, um herauszufinden, welcher am besten geeignet ist, unsere Frage genauer zu beantworten.

Dazu messen wir den Abstand zwischen dem Vektor der Frage und jedem Vektor der Datenbank. Es gibt mehrere Techniken, um Abstände zwischen Vektoren zu messen. Für dieses Codelab verwenden wir den euklidischen Abstand oder die L2-Norm.

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

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 so aussehen:

Code analysieren

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

Wir haben die Variable „shortest_distance“ auch auf 1 initialisiert, um sie so lange zu aktualisieren, bis wir den tatsächlichen kürzesten Abstand gefunden haben.

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

Dann durchlaufen wir mit einer „for“-Schleife die Datenbank und ermitteln den Abstand zwischen dem Vektor der Frage und jedem Vektor in der Datenbank.

Mit der Funktion „numpy linalg.norm“ berechnen wir den Abstand.

Wenn der berechnete Abstand kleiner als der in der Variablen „shortest_distance“ ist, wird der berechnete Abstand auf diese Variable festgelegt.

Anschließend erfassen wir den kürzesten Abstand sowie die Position in der Liste, an der er 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

Da wir die Position des Vektors mit dem kürzesten Abstand zwischen der Frage und der Datenbank in der Liste kennen, können wir die Ergebnisse ausgeben.

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 erhalten Sie ein Ergebnis wie dieses:

9. Glückwunsch

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

Sie haben die Grundlagen der Texteinbettung kennengelernt und erfahren, wie Sie das Modell gecko003 in der GCP Workbench verwenden.

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

Nächste Schritte

Sehen Sie sich einige dieser Codelabs an:

• Erste Schritte mit Vektoreinbettungen in AlloyDB AI

Referenzdokumente

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