Semantische Ähnlichkeit ist das, wofür Embedding-Modelle entwickelt wurden, aber diese Messungen werden von vielen verzerrenden Faktoren beeinflusst. In diesem Artikel untersuchen wir eine weit verbreitete Quelle von Bias in Text-Embedding-Modellen: die Eingabegröße.
Embeddings längerer Texte zeigen im Vergleich zu anderen Text-Embeddings generell höhere Ähnlichkeitswerte, unabhängig davon, wie ähnlich der tatsächliche Inhalt ist. Während wirklich ähnliche Texte weiterhin höhere Ähnlichkeitswerte als nicht verwandte Texte aufweisen, führen längere Texte zu einer Verzerrung — ihre Embeddings erscheinen allein aufgrund ihrer Länge im Durchschnitt ähnlicher.
Dies hat reale Konsequenzen. Es bedeutet, dass Embedding-Modelle alleine nicht gut in der Lage sind, Relevanz zu messen. Bei Embedding-basierter Suche gibt es immer eine beste Übereinstimmung, aber die Größenverzerrung bedeutet, dass Sie den Ähnlichkeitswert nicht verwenden können, um zu entscheiden, ob die beste Übereinstimmung oder geringere Übereinstimmungen tatsächlich relevant sind. Sie können nicht sagen, dass beispielsweise jede Übereinstimmung mit einem Kosinus über 0,75 relevant ist, da es leicht ein langes Dokument geben kann, das auf diesem Niveau übereinstimmt, obwohl es völlig irrelevant ist.
Wir werden dies mit einigen einfachen Beispielen demonstrieren und zeigen, warum die Kosinus-Ähnlichkeit zwischen Text-Embeddings nicht als allgemeine Methode zur Bewertung dienen kann
tagVisualisierung des Größen-Bias
Um zu zeigen, wie sich der Größen-Bias manifestiert, werden wir Jina AIs neuestes Embedding-Modell jina-embeddings-v3 mit der Option text-matching verwenden. Wir werden auch Textdokumente aus einem häufig verwendeten IR-Datensatz verwenden: Den CISI-Datensatz, den Sie von Kaggle herunterladen können.
Dieser Datensatz wird zum Training von IR-Systemen verwendet und enthält sowohl Abfragen als auch Dokumente, die zu ihnen passen. Wir werden nur die Dokumente verwenden, die sich alle in der Datei CISI.ALL befinden. Sie können sie über die Kommandozeile von einer alternativen Quelle auf GitHub mit folgendem Befehl herunterladen:
wget https://raw.githubusercontent.com/GianRomani/CISI-project-MLOps/refs/heads/main/CISI.ALL
CISI enthält 1.460 Dokumente. Die grundlegenden Statistiken über die Größen der Texte und ihre Größenverteilungen sind in der Tabelle und den Histogrammen unten zusammengefasst:
| in Words | in Sentences | |
|---|---|---|
| Average document size | 119.2 | 4.34 |
| Std. Deviation | 63.3 | 2.7 |
| Max size | 550 | 38 |
| Min size | 8 | 1 |
Lassen Sie uns die Dokumente in Python einlesen und Embeddings für sie erstellen. Der folgende Code geht davon aus, dass sich die Datei CISI.ALL im lokalen Verzeichnis befindet:
with open("CISI.ALL", "r", encoding="utf-8") as inp:
cisi_raw = inp.readlines()
docs = []
current_doc = ""
in_text = False
for line in cisi_raw:
if line.startswith("."):
in_text = False
if current_doc:
docs.append(current_doc.strip())
current_doc = ""
if line.startswith(".W"):
in_text = True
else:
if in_text:
current_doc += line
Dies füllt die Liste docs mit 1.460 Dokumenten. Sie können sie inspizieren:
print(docs[0])
The present study is a history of the DEWEY Decimal
Classification. The first edition of the DDC was published
in 1876, the eighteenth edition in 1971, and future editions
will continue to appear as needed. In spite of the DDC's
long and healthy life, however, its full story has never
been told. There have been biographies of Dewey
that briefly describe his system, but this is the first
attempt to provide a detailed history of the work that
more than any other has spurred the growth of
librarianship in this country and abroad.Nun werden wir Embeddings für jeden Text mit jina-embeddings-v3 erstellen. Dafür benötigen Sie einen API-Schlüssel von der Jina AI Website. Sie können einen kostenlosen Schlüssel für bis zu 1 Million Token Embeddings erhalten, was für diesen Artikel ausreicht.
Legen Sie Ihren Schlüssel in einer Variable an:
api_key = "<Your Key>"
Generieren Sie jetzt Embeddings mit der text-matching-Aufgabe mit jina-embeddings-v3. Dieser Code verarbeitet die Texte in docs in Batches von 10.
import requests
import json
from numpy import array
embeddings = []
url = "https://api.jina.ai/v1/embeddings"
headers = {
"Content-Type": "application/json",
"Authorization": "Bearer " + api_key
}
i = 0
while i < len(docs):
print(f"Got {len(embeddings)}...")
data = {
"model": "jina-embeddings-v3",
"task": "text-matching",
"late_chunking": False,
"dimensions": 1024,
"embedding_type": "float",
"input": docs[i:i+10]
}
response = requests.post(url, headers=headers, data=json.dumps(data))
for emb in response.json()['data']:
embeddings.append(array(emb['embedding']))
i += 10
Für jeden Text wird es ein 1024-dimensionales Embedding in der Liste embeddings geben. Sie können sehen, wie das aussieht:
print(embeddings[0])
array([ 0.0352382 , -0.00594871, 0.03808545, ..., -0.01147173,
-0.01710563, 0.01109511], shape=(1024,))),
Jetzt berechnen wir die Kosinus-Ähnlichkeit zwischen allen Paaren von Embeddings. Definieren wir zunächst die Kosinus-Funktion cos_sim mit numpy:
from numpy import dot
from numpy.linalg import norm
def cos_sim(a, b):
return float((a @ b.T) / (norm(a)*norm(b)))
Dann berechnen wir die Kosinus-Werte für jedes der 1.460 Embeddings im Vergleich zu den anderen 1.459:
all_cosines = []
for i, emb1 in enumerate(embeddings):
for j, emb2 in enumerate(embeddings):
if i != j:
all_cosines.append(cos_sim(emb1, emb2))
Das Ergebnis ist eine Liste von 2.130.140 Werten. Ihre Verteilung sollte die Kosinus-Werte zwischen "zufälligen" Dokumenten in derselben Sprache und Register approximieren. Die Tabelle und das Histogramm unten fassen die Ergebnisse zusammen.
| Number of texts | 1,460 |
|---|---|
| Number of cosines | 2,130,140 |
| Average | 0.343 |
| Std. Deviation | 0.116 |
Diese Dokumente haben, obwohl sie nicht miteinander verwandt sind, typischerweise Kosinus-Werte deutlich über null. Wir könnten versucht sein, einen Schwellenwert von 0,459 (Durchschnitt + 1 Standardabweichung) festzulegen, oder ihn vielleicht auf 0,5 aufzurunden, und zu sagen, dass jedes Dokumentenpaar mit einem Kosinus unter diesem Wert weitgehend unzusammenhängend sein muss.
Aber lassen Sie uns das gleiche Experiment mit kleineren Texten durchführen. Wir werden die nltk Bibliothek verwenden, um jedes Dokument in Sätze zu zerlegen:
import nltk
sentences = []
for doc in docs:
sentences.extend(nltk.sent_tokenize(doc))
Dies ergibt 6.331 Sätze mit einer durchschnittlichen Länge von 27,5 Wörtern und einer Standardabweichung von 16,6. Im Histogramm unten ist die Größenverteilung der Sätze in rot und die der vollständigen Dokumente in blau dargestellt, sodass Sie sie vergleichen können.
Wir werden das gleiche Modell und die gleichen Methoden verwenden, um Embeddings für jeden Satz zu erstellen:
sentence_embeddings = []
i = 0
while i < len(sentences):
print(f"Got {len(sentence_embeddings)}...")
data = {
"model": "jina-embeddings-v3",
"task": "text-matching",
"late_chunking": False,
"dimensions": 1024,
"embedding_type": "float",
"input": sentences[i:i+10]
}
response = requests.post(url, headers=headers, data=json.dumps(data))
for emb in response.json()['data']:
sentence_embeddings.append(array(emb['embedding']))
i += 10
Berechnen Sie dann den Kosinus zwischen dem Embedding jedes Satzes mit jedem anderen Satz:
sent_cosines = []
for i, emb1 in enumerate(sentence_embeddings):
for j, emb2 in enumerate(sentence_embeddings):
if i != j:
sent_cosines.append(cos_sim(emb1, emb2))
Das Ergebnis sind deutlich mehr Kosinuswerte: 40.075.230, wie in der folgenden Tabelle zusammengefasst:
| Number of sentences | 6,331 |
|---|---|
| Number of cosines | 40,075,230 |
| Average | 0.254 |
| Std. Deviation | 0.116 |
Die Satz-zu-Satz-Kosinuswerte sind im Durchschnitt deutlich niedriger als die vollständigen Dokument-zu-Dokument-Werte. Das Histogramm unten vergleicht ihre Verteilungen, und man kann deutlich erkennen, dass die Satzpaare eine nahezu identische Verteilung wie die Dokumentenpaare bilden, die jedoch nach links verschoben ist.
Um zu testen, ob diese Größenabhängigkeit robust ist, berechnen wir alle Kosinuswerte zwischen Sätzen und Dokumenten und fügen sie dem Histogramm hinzu. Ihre Informationen sind in der folgenden Tabelle zusammengefasst:
| Number of texts | 6,331 sentences & 1,460 documents |
|---|---|
| Number of cosines | 9,243,260 |
| Average | 0.276 |
| Std. Deviation | 0.119 |
Die grüne Linie unten zeigt die Verteilung der Satz-zu-Dokument-Kosinuswerte. Wir können sehen, dass diese Verteilung genau zwischen den Dokument-zu-Dokument-Kosinuswerten und den Satz-zu-Satz-Kosinuswerten liegt, was zeigt, dass der Größeneffekt beide Texte betrifft – sowohl den größeren als auch den kleineren der verglichenen Texte.
Lassen Sie uns einen weiteren Test durchführen, indem wir die Dokumente in Gruppen von zehn zusammenfügen, wodurch 146 viel größere Dokumente entstehen, und deren Kosinuswerte messen. Das Ergebnis ist unten zusammengefasst:
| Number of texts | 146 documents |
|---|---|
| Number of cosines | 21,170 |
| Average | 0.658 |
| Std. Deviation | 0.09 |
Dies liegt weit rechts von den anderen Verteilungen. Ein Kosinusschwellenwert von 0,5 würde uns sagen, dass fast alle diese Dokumente miteinander verwandt sind. Um irrelevante Dokumente dieser Größe auszuschließen, müssten wir den Schwellenwert viel höher setzen, vielleicht sogar auf 0,9, was zweifellos gute Übereinstimmungen zwischen den kleineren Dokumenten ausschließen würde.
Dies zeigt, dass wir Mindest-Kosinusschwellenwerte überhaupt nicht verwenden können, um die Qualität einer Übereinstimmung einzuschätzen, zumindest nicht ohne die Dokumentgröße irgendwie zu berücksichtigen.
tagWas verursacht den Größen-Bias?
Der Größen-Bias bei Embeddings ist nicht wie Positions-Biases in Long-Context-Modellen. Er wird nicht durch Architekturen verursacht. Es geht auch nicht grundsätzlich um die Größe. Wenn wir zum Beispiel längere Dokumente erstellt hätten, indem wir einfach Kopien desselben Dokuments immer wieder aneinandergefügt hätten, würde sich kein Größen-Bias zeigen.
Das Problem ist, dass lange Texte mehr Dinge aussagen. Selbst wenn sie durch ein Thema und einen Zweck eingeschränkt sind, besteht der Sinn des Schreibens von mehr Wörtern darin, mehr Inhalte zu vermitteln.
Längere Texte, zumindest die Art, die Menschen normalerweise erstellen, erzeugen naturgemäß Embeddings, die sich über mehr semantischen Raum "verteilen". Wenn ein Text mehr Dinge aussagt, wird sein Embedding durchschnittlich einen kleineren Winkel mit anderen Vektoren bilden, unabhängig vom Thema des Textes.
tagRelevanz messen
Die Lehre aus diesem Beitrag ist, dass man Kosinus zwischen semantischen Vektoren nicht allein verwenden kann, um festzustellen, ob etwas eine gute Übereinstimmung ist, sondern nur, dass es die beste Übereinstimmung aus den verfügbaren ist. Man muss neben der Berechnung von Kosinuswerten noch etwas anderes tun, um den Nutzen und die Gültigkeit der besten Übereinstimmungen zu überprüfen.
Man könnte eine Normalisierung versuchen. Wenn man den Größen-Bias empirisch messen kann, ist es möglicherweise möglich, ihn auszugleichen. Dieser Ansatz könnte jedoch nicht sehr robust sein. Was für einen Datensatz funktioniert, wird wahrscheinlich für einen anderen nicht funktionieren.
Asymmetrische Query-Dokument-Kodierung, die in jina-embeddings-v3 verfügbar ist, reduziert den Größen-Bias in Embedding-Modellen, eliminiert ihn aber nicht. Der Zweck der asymmetrischen Kodierung besteht darin, Dokumente so zu kodieren, dass sie weniger "verteilt" sind, und Abfragen so zu kodieren, dass sie es mehr sind.
Die rote Linie im Histogramm unten zeigt die Verteilung der Dokument-zu-Dokument-Kosinuswerte bei Verwendung der asymmetrischen Kodierung mit jina-embeddings-v3 – jedes Dokument wird mit den Flags retrieval.query und retrieval.passage kodiert, und jedes Dokument-Query-Embedding wird mit jedem Dokument-Passage-Embedding verglichen, das nicht vom selben Dokument stammt. Der durchschnittliche Kosinuswert beträgt 0,200 mit einer Standardabweichung von 0,124.
Diese Kosinuswerte sind deutlich kleiner als die, die wir oben für dieselben Dokumente mit dem Flag text-matching gefunden haben, wie im Histogramm unten gezeigt.
Die asymmetrische Kodierung hat den Größen-Bias jedoch nicht eliminiert. Das Histogramm unten vergleicht Kosinuswerte für vollständige Dokumente und Sätze bei Verwendung der asymmetrischen Kodierung.
Der Durchschnitt für Satz-Kosinuswerte beträgt 0,124, bei asymmetrischer Kodierung beträgt die Differenz zwischen dem durchschnittlichen Satz-Kosinus und dem durchschnittlichen Dokument-Kosinus also 0,076. Die Differenz der Durchschnitte bei symmetrischer Kodierung beträgt 0,089. Die Änderung des Größen-Bias ist unerheblich.
Obwohl die asymmetrische Kodierung die Embeddings für die Informationssuche verbessert, ist sie nicht besser geeignet, die Relevanz von Übereinstimmungen zu messen.
tagZukünftige Möglichkeiten
Der Reranker-Ansatz, z.B. jina-reranker-v2-base-multilingual und jina-reranker-m0, ist eine alternative Methode zur Bewertung von Query-Dokument-Übereinstimmungen, von der wir bereits wissen, dass sie die Abfragepräzision verbessert. Reranker-Scores sind nicht normalisiert, daher funktionieren sie auch nicht als objektive Ähnlichkeitsmaße. Sie werden jedoch anders berechnet, und es könnte möglich sein, Reranker-Scores so zu normalisieren, dass sie gute Schätzer für Relevanz werden.
Eine weitere Alternative ist die Verwendung von Large Language Models, vorzugsweise mit starken Reasoning-Fähigkeiten, um direkt zu bewerten, ob ein Kandidat eine gute Übereinstimmung für eine Abfrage ist. Vereinfacht ausgedrückt könnten wir ein aufgabenspezifisches Large Language Model fragen: "Auf einer Skala von 1 bis 10, ist dieses Dokument eine gute Übereinstimmung für diese Abfrage?" Bestehende Modelle sind möglicherweise nicht gut für diese Aufgabe geeignet, aber gezieltes Training und ausgereiftere Prompting-Techniken sind vielversprechend.
Es ist nicht unmöglich für Modelle, Relevanz zu messen, aber es erfordert ein anderes Paradigma als Embedding-Modelle.
tagNutzen Sie Ihre Modelle für das, wofür sie gut sind
Der oben dokumentierte Größen-Bias-Effekt zeigt eine der grundlegenden Einschränkungen von Embedding-Modellen: Sie sind hervorragend darin, Dinge zu vergleichen, aber unzuverlässig beim Messen absoluter Relevanz. Diese Einschränkung ist kein Fehler im Design – es ist eine inhärente Eigenschaft der Funktionsweise dieser Modelle.
Was bedeutet das also für Sie?
Erstens: Seien Sie skeptisch gegenüber Kosinus-Schwellenwerten. Sie funktionieren einfach nicht. Kosinus-Ähnlichkeitsmaße produzieren verlockend objektiv aussehende Gleitkommazahlen. Aber nur weil etwas Zahlen ausgibt, bedeutet das nicht, dass es objektiv etwas misst.
Zweitens: Erwägen Sie Hybrid-Lösungen. Embeddings können effizient eine große Menge von Elementen auf vielversprechende Kandidaten eingrenzen, wonach Sie ausgereiftere (und rechenintensivere) Techniken wie Reranker oder LLMs oder sogar menschliche Bewerter einsetzen können, um die tatsächliche Relevanz zu bestimmen.
Drittens: Denken Sie beim Systemdesign in Aufgaben statt in Fähigkeiten. Das objektiv klügste Modell mit den höchsten Benchmark-Werten ist immer noch Geldverschwendung, wenn es die Aufgabe nicht erfüllen kann, für die Sie es gekauft haben.
Das Verständnis der Grenzen unserer Modelle ist nicht pessimistisch – es spiegelt ein breiteres Prinzip in Anwendungen wider: Das Verständnis dessen, worin Ihre Modelle gut sind und worin nicht, ist entscheidend für den Aufbau zuverlässiger und effektiver Systeme. Genauso wie wir keinen Hammer verwenden würden, um eine Schraube festzuziehen, sollten wir keine Embedding-Modelle für Aufgaben verwenden, die sie nicht bewältigen können. Respektieren Sie, wofür Ihre Werkzeuge gut sind.
