Einbettungen (opens new window) sind numerische Darstellungen von Daten, die die semantische Essenz von Wörtern oder Phrasen erfassen. Diese Einbettungen werden als hochdimensionale Vektoren codiert, was eine effiziente Verarbeitung in verschiedenen Datenanwendungen ermöglicht. Einbettungen können je nach verwendeten Modellen variieren. Derselbe Text kann eine andere Einbettung haben, wenn er mit verschiedenen Modellen generiert wird. Obwohl Textdaten im Mittelpunkt stehen, sind Einbettungen nicht auf textuelle Informationen beschränkt; sie können auch auf Bilder, Graphen und andere Datentypen angewendet werden.
Einbettungen sind im Kontext von Vektor-Datenbanken (opens new window) noch wertvoller; wir können grundlegende Ähnlichkeits-/Distanzmaße auf sie anwenden, um festzustellen, wie ähnlich oder unähnlich ein Textpaar (oder andere Daten) ist. Wir können sie auch verwenden, um die am besten zugehörigen Beispiele zu finden und so weiter. Ihre Verwendung ist von grundlegender Bedeutung, ohne dass viel Hintergrundwissen erforderlich ist.
In diesem Blog werden wir untersuchen, wie man Einbettungen mit beliebten Modellen wie OpenAI, Jina und Bedrock generiert und verwendet. Die EmbedText()-Funktion von MyScale bietet einen optimierten Ansatz für die Arbeit mit Einbettungen, insbesondere bei der Verarbeitung von Daten im großen Maßstab. Durch die Nutzung dieses Tools können Sie Einbettungs-basierte Suche und andere Textverarbeitungsfunktionen nahtlos in Ihre Anwendungen integrieren und gleichzeitig von der Leistungsfähigkeit und Kosteneffizienz von MyScale profitieren.
# Einbettungsmodelle
Traditionell haben wir klassische Einbettungsmodelle wie Word2Vec (opens new window), GloVe (opens new window) und LSA (opens new window). Später wurden sie allmählich durch RNN/LSTM-basierte Modelle (opens new window) ersetzt. Die unübertroffenen Fähigkeiten von Transformern brachten einen weiteren Paradigmenwechsel, da Transformern jetzt die de facto Modelle für Einbettungen sind. Um Einbettungen zu generieren, können wir verschiedene Ansätze verwenden:
- Ein Modell trainieren: Wenn Sie über gute Rechenressourcen verfügen oder möglicherweise Datenschutzprobleme bestehen, ist das lokale Training eine gute Option. Hier bedeutet Training nicht unbedingt das Training eines Modells von Grund auf, sondern umfasst auch das Feintuning (wie wir es die meiste Zeit tun). Sobald trainiert, können wir dieses Modell verwenden, um Einbettungen zu generieren.
- Ein vortrainiertes Modell verwenden: Normalerweise müssen wir ein Modell für Einbettungen nicht trainieren oder sogar feintunen. Es gibt eine Reihe von Standardmodellen, die in den meisten Fällen für die Einbettungsgenerierung verwendet werden, wie GPT-Serien, einige SLMs wie Phi-Serien, Titan, Llama und Falcon usw.
Bei vortrainierten Modellen haben wir einige Optionen. HuggingFace-Modelle sind eine ausgezeichnete Option, wenn Sie sie lokal ausführen möchten (die Inferenz erfordert nicht unbedingt GPUs, sodass ein normaler Laptop ausreicht). Auf der anderen Seite haben wir auch viele Cloud-basierte Dienste für diese Einbettungsmodelle. OpenAI, Cohere und Jina sind einige gute Beispiele. Ein weiterer Grund, warum diese Dienste nützlich sind, ist die Nichtverfügbarkeit einiger hochmoderner Modelle (wie der GPT-4-Familie).
# Verwendung von Modellen auf HuggingFace
Eine Reihe von Transformer-Modellen sind auf Hugging Face (opens new window) gehostet, einschließlich derjenigen, die speziell für Einbettungen verwendet werden. Um ein Hugging Face-Modell zu verwenden, müssen wir das entsprechende Modell und den Tokenizer aufrufen. Diese Modelle können einige Zeit zum Herunterladen benötigen. Sobald sie heruntergeladen sind, bleiben sie im Cache und können mit der Hugging Face-Konsole von PyCharm verwaltet werden.
from transformers import AutoModel, AutoTokenizer
modelName = "TencentBAC/Conan-embedding-v1"
tokenizer = AutoTokenizer.from_pretrained(modelName)
model = AutoModel.from_pretrained(modelName)
text = "Alle Menschen sind frei und gleich an Würde und Rechten geboren. Sie sind mit Vernunft und Gewissen begabt und sollten einander im Geist der Brüderlichkeit begegnen."
inputs = tokenizer(text, return_tensors="pt")
tokenEmbeddings = model(**inputs).last_hidden_state
Es wäre nützlich, diese Token-Einbettungen in Satz-Einbettungen umzuwandeln, indem wir sie zusammenfassen.
sentenceEmbedding = tokenEmbeddings.mean(dim=1)
sentenceEmbedding[0]
Die Verwendung von Hugging Face für Einbettungen ist ziemlich gut, kann aber in einigen Fällen problematisch sein, wie z.B.:
- Begrenzte Ressourcen: Normalerweise benötigen HF-Modelle nicht viel Platz (im Durchschnitt 1 GB), aber wenn Sie wenig Speicherplatz oder Arbeitsspeicher haben, ist dies wahrscheinlich keine praktikable Option.
- Nichtverfügbarkeit einiger Modelle: Obwohl viele Modelle auf Hugging Face gehostet sind, gibt es immer noch einige Modelle, die auf dedizierten Diensten gehostet werden (GPT-4 kommt mir schnell in den Sinn, aber es gibt noch einige andere).
Um diese Modelle remote zu verwenden, verwenden wir verschiedene Dienste wie OpenAI, Amazon Bedrock, Cohere usw. Wir können sie in Verbindung mit MyScale verwenden, wie wir sehen werden.
# Abrufen von Einbettungen mit MyScale
Wie bereits erwähnt, sind Einbettungen ein zentraler Bestandteil von Anwendungen für Vektor-Datenbanken. MyScale bietet die Möglichkeit, die EmbedText-Funktion, Einbettungen (nur Text bisher) unter Verwendung verschiedener Dienste wie OpenAI, Cohere, Jina usw. zu berechnen. Diese Integration ist äußerst hilfreich, da sie die Umwandlung von Text in Vektoren vereinfacht. Sie unterstützt automatisches Batching für hohe Durchsatzraten und ist sowohl für Echtzeitsuche als auch für Stapelverarbeitung nützlich. Diese Funktion hat einige wesentliche Parameter:
text: Der Textstring, dessen Einbettung wir berechnen möchten. Zum Beispiel:'Du kannst dann keinem Menschen untreu sein.'.provider: Name des Anbieters des Einbettungsmodells (8 unterstützte Anbieter bisher; Groß-/Kleinschreibung wird nicht beachtet). Zum Beispiel:OpenAI.api_key: API-Schlüssel für das entsprechende Anbieterkonto. Er wird direkt vom Dienst bereitgestellt und hat nichts mit MyScale zu tun.
Hinweis: Alle diese Einbettungsdienste berechnen die Kosten basierend auf der Token-Verwendung, daher ist es wichtig, die Berechnung derselben Einbettungen zu vermeiden. Stattdessen sollten die Einbettungen nach der Generierung in einer Datenbank gespeichert werden, um sie effizient wiederzuverwenden.
Zusätzlich zu diesen Parametern haben wir auch base_url als optionalen Parameter (für die meisten Anbieter nicht erforderlich).
# Verwendung von OpenAI-Modellen
Der folgende Codeausschnitt zeigt, wie man OpenAI-Einbettungen mit EmbedText() verwendet:
SELECT EmbedText('<Eingabetext>', 'openAI', '', '<Zugriffsschlüssel>', '{"model":"text-embedding-3-small", "batch_size":"50"}')
Hier haben wir auch die optionalen Argumente der API-URL, der Ausgabevektordimensionen und der Benutzer-ID. OpenAI bietet 3 Einbettungsmodelle, Ada-002 und Embedding-3 (klein und groß). Wie Sie sehen können, erzeugt die große Version einen 3072-Länge Einbettungsvektor, der eine bessere Auflösung hat und bei der Verarbeitung größerer Dokumente sehr nützlich sein kann.
| Modell | Beschreibung | Ausgabedimension |
|---|---|---|
text-embedding-3-large | Leistungsfähigstes Einbettungsmodell für englische und nicht-englische Aufgaben | 3.072 |
text-embedding-3-small | Verbesserte Leistung gegenüber dem Einbettungsmodell Ada der 2. Generation | 1.536 |
text-embedding-ada-002 | Leistungsfähigstes Einbettungsmodell der 2. Generation, das 16 Einbettungsmodelle der 1. Generation ersetzt | 1.536 |
Um die Leistungsfähigkeit selbst der kleineren Modelle zu zeigen, nehmen wir einen großen Textabschnitt (ein ganzes Kapitel) und generieren seine Einbettungen.
service_provider = 'OpenAI'
textInput = 'Wir lassen Danglars mit dem Dämon des Hasses kämpfen und versuchen, dem Schiffseigner etwas Böses einzureden...' #hier absichtlich abgeschnitten
parameters = {'sampleString': textInput, 'serviceProvider': service_provider}
x = client.query("""
SELECT EmbedText({sampleString:String}, {serviceProvider:String}, '', 'sk-xxxxxxxx', '{"model":"text-embedding-3-small", "batch_size":"50"}')
""", parameters=parameters)
print(x.result_rows[0][0])
Hinweis: EmbedText() kann einen Text von bis zu 5600 Zeichen Länge verarbeiten.
Hier nehmen wir result_rows[0][0], da die Verwendung von result_rows direkt eine unnötige Verschachtelung von Liste und Tupel mit sich bringt.
# Verwendung von Bedrock-Modellen
Amazon Bedrock bietet Benutzern Zugriff auf eine Reihe von Grundlagenmodellen. Bevor Sie ein Modell verwenden können, müssen Sie zuerst darauf zugreifen (das ist ziemlich unkompliziert). Dann können wir es direkt aus MyScale aufrufen:
SELECT EmbedText('<Eingabetext>', 'Bedrock', '', '<SECRET_ACCESS_KEY>', '{"model":"amazon.titan-embed-text-v1", "region_name":"us-east-1", "access_key_id":"ACCESS_KEY_ID"}')
Das folgende Beispiel verdeutlicht dies weiter.
client.command("""
CREATE TABLE IF NOT EXISTS EmbeddingsCollection (
id UUID,
sentences String, -- Textfeld zur Speicherung Ihrer Textdaten
embeddings Array(Float32),
--CONSTRAINT check_data_length CHECK length(embeddings) = 1536
) ENGINE = MergeTree()
ORDER BY id;
""")
EmbeddingsCollection wird bald nützlich sein, da wir die generierten Einbettungen dort speichern werden. Wir nehmen einige zufällige Textbeispiele und berechnen ihre Einbettungen.
service_provider = 'Bedrock'
embeddingModel = 'amazon.titan-embed-text-v1'
embeddingsList = []
for i in range(500, 1000, 30):
randomLine = hamletLines[i]
parameters = {'sampleString': randomLine, 'serviceProvider': service_provider, 'model': embeddingModel}
if len(randomLine) < 30: #Zu kurze Passagen ignorieren.
continue
else:
x = client.query("""
SELECT EmbedText({sampleString:String}, {serviceProvider:String}, '', '12PXA8xxxxxxxxxxx', '{"model":"amazon.titan-embed-text-v1", "region_name":"us-east-1", "access_key_id":"AKIxxxxxxxx"}')
""", parameters=parameters)
_id = client.query("""SELECT generateUUIDv4()
""")
embeddingsList.append((_id.result_rows[0][0], randomLine, x.result_rows[0][0]))
Wie Sie sehen können, nehmen wir beim Hinzufügen die UUIDs auf die gleiche Weise wie das Extrahieren von Einbettungsvektoren (UUIDs sind einzelne Objekte). Diese embeddingsList kann nun in die Tabelle eingefügt und für eine Vielzahl von Aufgaben wie Ähnlichkeitssuche usw. weiterverwendet werden.
# Verwendung von Jina-Modellen
Jina ist ein relativ neuer Dienst. Um einen Jina-Dienst zu verwenden, können wir den Eingabetext, den Zugriffsschlüssel und das Modell angeben. Das Standardmodell in MyScale ist jina-embeddings-v2-base-en und es gibt 768-lange Einbettungen zurück, die im Vergleich zu den anderen Modellen eine geringere Auflösung haben.
SELECT EmbedText('<Eingabetext>', 'jina', '', '<Zugriffsschlüssel>', '{"model":"jina-embeddings-v2-base-en"}')
Hier ist ein Beispiel. Wie Sie sehen können, ist es fast dasselbe wie bei der Verwendung anderer Anbieter. EmbedText() ermöglicht es uns, die Anbieter zu kapseln, und es fühlt sich an, als würden wir mehr oder weniger denselben Dienst verwenden.
service_provider = 'jina'
textInput = "The Astronomer's Telegram (ATel) is an internet-based short-notice publication service for quickly disseminating information on new astronomical observations.[1][2] Examples include gamma-ray bursts,[3][4] gravitational microlensing, supernovae, novae, or X-ray transients, but there are no restrictions on content matter. Telegrams are available instantly on the service's website, and distributed to subscribers via email digest within 24 hours' #hier absichtlich abgeschnitten
parameters = {'sampleString': textInput, 'serviceProvider': service_provider}
x = client.query("""
SELECT EmbedText({sampleString:String}, {serviceProvider:String}, '', 'jina_faxxxxxxx', '{"model":"jina-embeddings-v2-base-en"}')
""", parameters=parameters)
x.result_rows[0][0]
# Verarbeitung von Einbettungen mit MyScale
Wir wissen jetzt, wie man diese Einbettungen mit EmbedText() erhält, schauen wir uns an, wie man sie jetzt verwendet. Da die Generierung dieser Einbettungen Kosten verursacht, müssen wir sie unmittelbar nach der Generierung in der Datenbank speichern. Mit MyScale ist dies ziemlich einfach. Erstellen Sie eine Tabelle und fügen Sie die Einbettungen dort ein.
client.command("""
CREATE TABLE IF NOT EXISTS EmbeddingsCollection (
id UUID,
sentences String, -- Textfeld zur Speicherung Ihrer Textdaten
embeddings Array(Float32),
--CONSTRAINT check_data_length CHECK length(embeddings) = 1536
) ENGINE = MergeTree()
ORDER BY id;
""")
Da wir bereits das DataFrame im Format ID mit Eingabetext und den entsprechenden Einbettungen haben, können wir einfach itertuples() aufrufen und es mit der entsprechenden Methode einfügen.
df_records = list(df.itertuples(index=False, name=None))
client.insert("EmbeddingsCollection", df_records, column_names=["id", "sentences", "embeddings"])
Jetzt, da die Daten in der Tabelle vorliegen, können wir den Vektorindex hinzufügen. Dieser Index wird bald bei der Ähnlichkeitssuche nützlich sein.
client.command("""
ALTER TABLE EmbeddingsCollection
ADD VECTOR INDEX cosine_idx embeddings
TYPE MSTG
('metric_type=Cosine')
""")
# Effizienz
Nachdem wir die Hauptarbeit erledigt haben, ist es ziemlich einfach zu erkennen, warum Einbettungen so nützlich sind und wie effizient MyScale ist. Nachdem wir die Einbettungen für das gesamte Buch gespeichert haben, können wir einige Suchen durchführen.
service_provider = 'jina'
queryString = "
parameters = {'sampleString': queryString, 'serviceProvider': service_provider}
x = client.query("""
SELECT EmbedText({sampleString:String}, {serviceProvider:String}, '', 'jina_faxxxxxxx', '{"model":"jina-embeddings-v2-base-en"}')
""", parameters=parameters)
queryEmbeddings = x.result_rows[0][0]
results = client.query(f"""
SELECT id, sentences, embeddings,
distance(embeddings, {queryEmbeddings}) as dist
FROM BookEmbeddings
ORDER BY dist LIMIT 3
""")
df = pd.DataFrame(results.result_rows)
Als Ergebnis erhalten wir die besten 3 Ergebnisse:
Mit diesen erheblichen Vorteilen - nahtlose Integration von Einbettungsmodellen, beeindruckende Leistung und Kosteneinsparungen - erweist sich MyScale als leistungsstarke Plattform für jede datengetriebene Anwendung.
# Fazit
Durch die Nutzung der EmbedText()-Funktion von MyScale haben wir gezeigt, wie nahtlos Sie beliebte Einbettungsmodelle wie OpenAI, Bedrock und Jina in Ihre Anwendungen integrieren können. Die Generierung und Verarbeitung von Einbettungen direkt in MyScale vereinfacht nicht nur Ihren Arbeitsablauf, sondern liefert auch beeindruckende Leistung - selbst bei der Verarbeitung von Daten im großen Maßstab.
Beispielsweise zeigt die Durchführung einer Ähnlichkeitssuche in einem über 800 Seiten langen Buch in nur wenigen Sekunden die Effizienz und Geschwindigkeit von MyScale. Eine solche schnelle Verarbeitung wäre mit traditionellen NLP-Modellen eine Herausforderung. Darüber hinaus sind die Fähigkeiten von MyScale nicht auf Text beschränkt; es kann Einbettungen für Bilder und andere Datentypen verarbeiten, was eine Vielzahl von Anwendungsmöglichkeiten eröffnet.
Was MyScale auszeichnet, ist nicht nur seine Leistungsfähigkeit, sondern auch seine Kosteneffizienz. Im Gegensatz zu anderen Vektor-Datenbanken bietet MyScale außergewöhnliche Flexibilität und Funktionen, ohne dass hohe Kosten anfallen. Selbst bei der Skalierung auf die Verwaltung von 80 Millionen Vektoren bleiben die Kosten bemerkenswert niedrig - mit 8 Pods, die jeweils mit weniger als 0,10 USD pro Stunde laufen.
Diese Erschwinglichkeit macht MyScale zu einer idealen Wahl für Startups und etablierte Unternehmen, ohne dass dabei das Budget gesprengt wird. MyScale ermöglicht es Ihnen im Wesentlichen, das volle Potenzial von Einbettungen zu nutzen und bietet eine leistungsstarke, skalierbare und wirtschaftliche Lösung für moderne Datenanwendungen.
