Text-Embeddings sind ein zentrales Werkzeug in der Verarbeitung natürlicher Sprache (NLP). Dabei werden Texte als numerische Vektoren dargestellt, in denen jedes Wort oder jede Phrase als dichter Vektor reeller Zahlen codiert ist.
Der große Vorteil dieser Embeddings liegt darin, semantische Bedeutungen und Beziehungen zwischen Wörtern oder Phrasen abzubilden. So können Maschinen menschliche Sprache besser verstehen und effizienter verarbeiten.
Text-Embeddings sind unverzichtbar bei Aufgaben wie Textklassifikation, Informationsretrieval und dem Erkennen semantischer Ähnlichkeiten.
OpenAI, bekannt für wegweisende Beiträge zur Künstlichen Intelligenz, empfiehlt derzeit das Ada V2-Modell zur Erstellung von Text-Embeddings. Dieses Modell basiert auf der GPT-Reihe und wurde darauf trainiert, kontextuelle Bedeutungen und Zusammenhänge im Text noch präziser zu erfassen.
Wenn du mit der OpenAI API oder dem openai-Python-Paket noch nicht vertraut bist, lies vorab Using GPT-3.5 and GPT-4 via the OpenAI API in Python. Diese Anleitung hilft dir bei der Einrichtung und zeigt die Vorteile der API-Nutzung.
In diesem Tutorial kommt außerdem Clustering zum Einsatz — eine Machine-Learning-Technik, mit der ähnliche Instanzen gruppiert werden. Wenn du Clustering, insbesondere k-Means, noch nicht kennst, empfehlen wir Introduction to k-Means Clustering with scikit-learn in Python.
Wofür kannst du Text-Embeddings einsetzen?
Text-Embeddings lassen sich in zahlreichen Use Cases nutzen, unter anderem:
- Textklassifikation. Text-Embeddings helfen, präzise Modelle für Sentimentanalyse oder Themenzuordnung zu bauen.
- Informationsretrieval. Sie ermöglichen es, zu einer konkreten Anfrage relevante Informationen zu finden — ähnlich wie in einer Suchmaschine.
- Erkennung semantischer Ähnlichkeit. Embeddings identifizieren und quantifizieren semantische Ähnlichkeit zwischen Textausschnitten.
- Empfehlungssysteme. Durch das Verständnis von Nutzerpräferenzen anhand von Textinteraktionen verbessern sie Empfehlungen.
- Textgenerierung. Embeddings tragen dazu bei, kohärentere und kontextuell passendere Texte zu erzeugen.
- Maschinelle Übersetzung. Text-Embeddings erfassen Bedeutungen über Sprachen hinweg und können so die Übersetzungsqualität verbessern.
Setup
Für die Arbeit mit Text-Embeddings brauchst du mehrere Python-Pakete:
- os: Eingebaute Python-Bibliothek zur Interaktion mit dem Betriebssystem.
- openai: Python-Client für die OpenAI API.
- scipy.spatial.distance: Funktionen zur Distanzberechnung zwischen Datenpunkten.
- sklean.cluster.KMeans: Für KMeans-Clustering.
- umap.UMAP: Eine Technik zur Reduktion hochdimensionaler Daten.
Installiere vorab openai, scipy, plotly sklearn und umap mit folgendem Befehl. Der vollständige Code steht in diesem DataLab-Workbook bereit.
pip install -U openai, scipy, plotly-express, scikit-learn, umap-learnNach erfolgreicher Installation kannst du die Bibliotheken so importieren:
import os
import openai
from scipy.spatial import distance
import plotly.express as px
from sklearn.cluster import KMeans
from umap import UMAPJetzt legen wir den OpenAI API-Schlüssel fest:
openai.api_key = "<YOUR_API_KEY_HERE>"Hinweis: Du musst deinen eigenen API-Schlüssel verwenden. Der im Quellcode erwähnte Schlüssel ist nicht verfügbar und war nur für den persönlichen Gebrauch.
Das Code-Muster für API-Aufrufe an GPT
Die folgende Hilfsfunktion bettet eine Textzeile mit der OpenAI API ein. Im Code nutzen wir die aktuelle ada Version 2, um die Embeddings zu erzeugen.
def get_embedding(text_to_embed):
# Embed a line of text
response = openai.Embedding.create(
model= "text-embedding-ada-002",
input=[text_to_embed]
)
# Extract the AI output embedding as a list of floats
embedding = response["data"][0]["embedding"]
return embeddingZum Datensatz
In diesem Abschnitt verwenden wir die frei verfügbaren Amazon-Reviews zu Musikinstrumenten von Kaggle. Die Daten kannst du alternativ auch aus meinem Github-Account laden:
import pandas as pd
data_URL = "https://raw.githubusercontent.com/keitazoumana/Experimentation-Data/main/Musical_instruments_reviews.csv"
review_df = pd.read_csv(data_URL)
review_df.head()
Von allen Spalten interessiert uns nur die Spalte reviewText.
review_df = review_df[['reviewText']]
print("Data shape: {}".format(review_df.shape))
display(review_df.head())Data shape: (10261, 1)
Der Datensatz enthält sehr viele Reviews. Um Kosten zu sparen, verwenden wir nur 100 zufällig ausgewählte Zeilen.
Nun erzeugen wir für jede Zeile Embeddings, indem wir die obige Funktion per Lambda-Ausdruck anwenden:
review_df = review_df.sample(100)
review_df["embedding"] = review_df["reviewText"].astype(str).apply(get_embedding)
# Make the index start from 0
review_df.reset_index(drop=True)
review_df.head(10)
Die ersten 10 Zeilen der Reviews und Embeddings
Textähnlichkeit verstehen
Um semantische Ähnlichkeit zu veranschaulichen, betrachten wir zwei Reviews mit vermutlich ähnlicher Stimmung:
„This product is fantastic!“
„It really exceeded my expectations!“
Mit pdist() aus scipy.spatial.distance berechnen wir die euklidische Distanz zwischen ihren Embeddings.
Die euklidische Distanz entspricht der Quadratwurzel aus der Summe der quadrierten Differenzen zwischen zwei Embeddings. Die folgende Grafik illustriert dies:
Illustration der euklidischen Distanz (Quelle)
Sind die Reviews tatsächlich ähnlich, sollte die Distanz relativ klein sein.
Betrachten wir als Nächstes zwei unterschiedliche Reviews:
„This product is fantastic!"
"I'm not satisfied with the item."
Die Distanz zwischen diesen Embeddings wird deutlich größer ausfallen als zwischen den ähnlichen Reviews.
Case Study: Text-Embeddings für Clusteranalyse
Die erzeugten Text-Embeddings können für eine Clusteranalyse genutzt werden, um ähnliche Bewertungen zu Musikinstrumenten zu gruppieren.
Es gibt verschiedene Clustering-Algorithmen wie K-Means, DBSCAN, hierarchisches Clustering und Gaussian Mixture Models. In diesem Use Case verwenden wir KMeans. Unser Beitrag An Introduction to Hierarchical Clustering in Python bietet zudem einen guten Einstieg in Funktionsweise und Implementierung des hierarchischen Clusterings.
Textdaten clustern
K-Means erfordert die Vorgabe der Clusteranzahl. Wir setzen sie mit dem Parameter n_clusters auf 3:
kmeans = KMeans(n_clusters=3)
kmeans.fit(review_df["embedding"].tolist())Dimensionen der eingebetteten Textdaten reduzieren
Menschen können in der Regel höchstens drei Dimensionen visualisieren. Hier verwenden wir UMAP — ein schnelles, skalierbares Verfahren zur Dimensionalitätsreduktion.
Dazu instanziieren wir UMAP und wenden fit_transform auf die Embeddings an. So entsteht eine zweidimensionale Darstellung der Review-Embeddings, die wir plotten können.
reducer = UMAP()
embeddings_2d = reducer.fit_transform(review_df["embedding"].tolist())Cluster visualisieren
Zum Schluss erstellen wir einen Scatterplot der 2D-Embeddings. Die x- und y-Koordinaten stammen aus embeddings_2d[: , 0] bzw. embeddings_2d[: , 1]
Die Cluster werden visuell klar erkennbar sein:
fig = px.scatter(x=embeddings_2d[:, 0], y=embeddings_2d[:, 1], color=kmeans.labels_)
fig.show()
Cluster-Visualisierung
Insgesamt ergeben sich drei Hauptcluster in verschiedenen Farben. Die Farbe jeder Review im Plot wird durch das vom K-Means-Modell vergebene Clusterlabel bestimmt. Die Position der Punkte zeigt zudem anschaulich, wie ähnlich eine Review den anderen ist.
Nächster Schritt
Wenn du dein Verständnis für Text-Embeddings und die OpenAI API vertiefen willst, schau dir diese DataCamp-Ressourcen an: Fine-Tuning GPT-3 Using the OpenAI API and Python und The OpenAI API in Python Cheat Sheet. Sie zeigen dir, wie du das volle Potenzial von GPT-3 per Fine-Tuning ausschöpfst und die OpenAI API mit Python für deinen konkreten Use Case einsetzt.
