Informationen zu diesem Codelab
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 das so vor:
Text ist wie eine komplexe Sprache voller Nuancen und Ambiguität.
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 mithilfe von maschinellem Lernen: Text-Embeddings können als Merkmale in Modellen für maschinelles Lernen verwendet werden, was zu einer besseren Leistung bei Aufgaben wie Sentimentanalyse, Textklassifizierung und Themenmodellierung führt.
Anwendungsfälle für Texteinbettungen
Texteinbettungen ermöglichen durch die Umwandlung von Text in numerische Darstellungen eine Vielzahl von Anwendungen im Bereich 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 Einbettungen einer Suchanfrage mit Dokumenteinbettungen können Suchmaschinen Dokumente identifizieren, die ähnliche Themen oder Konzepte abdecken.
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 Artikel empfehlen, indem es die Einbettungen von Produkten, Artikeln oder anderen Inhalten vergleicht, mit denen der Nutzer interagiert hat.
3. Plagiatserkennung:
Der Vergleich der Einbettungen zweier Textteile kann bei der Identifizierung potenzieller Plagiate helfen, indem erhebliche Ähnlichkeiten in ihrer semantischen Struktur festgestellt werden.
Dies sind nur einige Beispiele. Mit der Weiterentwicklung der Text-Embedding-Techniken werden immer mehr Möglichkeiten eröffnet. Da Computer durch Einbettungen ein besseres Sprachverständnis gewinnen, können wir in Zukunft noch weitere 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-Skript. Mit diesem Skript wird Folgendes ausgeführt:
- Verwenden Sie die Vertex API, um textembedding-gecko@003 aufzurufen und Text in Texteinbettungen (Vektoren) umzuwandeln.
- Eine simulierte Datenbank aus Text und deren 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
- So verwenden Sie Texteinbettungen in der GCP
- textembedding-gecko@003 aufrufen
- Ausführung in Workbench
- Scripts mit Vertex AI Workbench ausführen
Voraussetzungen
- Eine aktuelle Version von Chrome
- Kenntnisse in Python
- Ein Google Cloud-Projekt
- Zugriff auf Vertex AI – Workbench
2. Einrichtung
Vertex AI Workbench-Instanz erstellen
- Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.
- Projektauswahl aufrufen
- Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.
- 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 finden Sie hier.
- Rufen Sie in der Google Cloud Console die Seite „Instanzen“ auf, auf die Sie über das Vertex AI-Menü im Abschnitt „Notebooks“ zugreifen können, und klicken Sie auf Workbench.
- Rufen Sie „Instanzen“ auf.
- Klicken Sie auf „Neu erstellen“.
- Geben Sie im Dialogfeld „Instanz erstellen“ im Abschnitt „Details“ die folgenden Informationen für die neue Instanz an:
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 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-Installation 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, sofern eines konfiguriert ist. Wenn Sie im Hostprojekt eine freigegebene VPC verwenden, müssen Sie dem Notebooks-Dienst-Agent aus dem Dienstprojekt auch die Rolle „Compute-Netzwerknutzer“ zuweisen.
Im Feld „Netzwerk“: Wählen Sie das gewünschte Netzwerk aus. Sie können ein VPC-Netzwerk auswählen, sofern für das Netzwerk der private Google-Zugriff aktiviert ist oder auf das Internet zugegriffen werden 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“.
- 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
- Klicken Sie im JupyterLab im Launcher im Abschnitt „Notebooks“ auf das Symbol mit dem Python-Logo, das „Python3“ steht.
- Ein Jupyter-Notebook mit dem Namen Untitled und der Erweiterung ipynb wird erstellt.
- 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 das JupyterLab geöffnet wurde, müssen Sie alle erforderlichen Bibliotheken für das Codelab installieren.
Wir benötigen Folgendes:
- numpy
- pandas
- TextEmbeddingInput, TextEmbeddingModel von vertexai.language_models
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 Datensätze. So wird sie erstellt:
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
Dies 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“ die sich auf eine simulierte Bedienungsanleitung eines von Google hergestellten Autos beziehen.
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 als Vektor codierten Text 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 namens list_embedded_values speichern und hängen wir den codierten Text jeder Zeile an.
Mit der iterrows-Methode von pandas können wir jede Zeile im DataFrame iterieren und die Werte aus der Spalte Text (die die manuellen Informationen aus unserer simulierten Datenbank enthält) abrufen.
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 im Dataframe eine neue Spalte namens Embedded Text (Eingebetteter Text) mit der Liste der Vektoren, die basierend auf dem Modell 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
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. Das heißt, wir können jetzt den Vektor der Frage mit allen Vektoren in unserer Datenbank vergleichen, um herauszufinden, welcher unserer Frage am nächsten kommt.
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 so aussehen:
Code analysieren
Zuerst konvertieren wir die Spalte mit dem eingebetteten Text oder den Vektoren unserer Datenbank in eine Liste und speichern sie in „list_embedded_text_from_db“.
Außerdem haben wir die Variable „shortest_distance“ mit 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
Dann iterieren wir mit einer for-Schleife und ermitteln 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.
Dann wird die kürzeste Entfernung sowie die Position in der Liste erfasst, 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 auf der Liste des Vektors mit der kürzesten Entfernung zwischen der Frage und der Datenbank kennen, 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 erhalten Sie in etwa Folgendes:
9. Glückwunsch
Herzlichen Glückwunsch! Sie haben Ihre erste Anwendung mit dem Modell textembedding-gecko@003 in einem realen Anwendungsfall erfolgreich erstellt.
Sie haben die Grundlagen von Text-Embeddings kennengelernt und gelernt, wie Sie das Modell „gecko003“ in der GCP Workbench verwenden.
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: