Kaugus ja koosinussarnasus
Sellel lehel
Eesmärgid
- Mõista koosinussarnasust ja seda, miks see on eelistatud meetod
- Teostada vektorite võrdlemist Pythonis
- Tõlgendada sarnasusskoore
Vektorite läheduse mõõtmine
Kui oled oma tekstid vektoriteks teisendanud, taandub kõik ühele küsimusele: kuidas otsustada, kas kaks vektorit on „lähedal“? Eksisteerib kolm vastust ja valik loeb.
Eukleidiline kaugus on klassikaline geomeetriline kaugus – see, mida mõõdad joonlauaga kahe punkti vahel. See on intuitiivne, kuid sõltub vektori suurusest: kaks sama tähendusega teksti, kusjuures üks on kodeeritud suurema amplituudiga, paistaksid kunstlikult kaugele asetsevatena.
import numpy as np
def euclidean_distance(a: list[float], b: list[float]) -> float:
return np.linalg.norm(np.array(a) - np.array(b))
Skalaarkorrutis liidab elementide kaupa korrutatud väärtused. See on pere kiireim tehe – selle, mida protsessor suurte maatriksite puhul kõige tõhusamalt täidab.
def dot_product(a: list[float], b: list[float]) -> float:
return np.dot(a, b)
Koosinussarnasus mõõdab lõpuks kahe vektori vahelist nurka sõltumata nende pikkusest, muutes selle embeddingsite standardmõõdikuks: oluline on ainult tähenduse suund, mitte selle intensiivsus.
def cosine_similarity(a: list[float], b: list[float]) -> float:
a, b = np.array(a), np.array(b)
return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
See ulatub vastassuundade puhul -1-st identsete suundade puhul +1-ni. Üks praktiline detail on oluline: OpenAI embeddingsid on juba normaliseeritud, mis tähendab, et nende pikkus on 1. Nimetaja on seega võrdne 1-ga ja skalaarkorrutis annab täpselt sama tulemuse kui koosinussarnasus – väiksema arvutusliku kuluga. See on otsetee, mida kasutame kogu selle kursuse vältel.
Praktiline võrdlus
Midagi ei asenda reaalsete lausete mõõtmist. Võrdleme lauset, selle täielikku parafrasi ja teemavälist lauset:
from openai import OpenAI
client = OpenAI()
def get_embedding(text: str) -> list[float]:
response = client.embeddings.create(
input=text,
model="text-embedding-3-large"
)
return response.data[0].embedding
# Võrreldavad laused
sentences = {
"a": "The cat sleeps on the couch",
"b": "The feline dozes on the sofa",
"c": "Python is a programming language",
}
embeddings = {k: get_embedding(v) for k, v in sentences.items()}
# Võrdle kõiki paare
from itertools import combinations
for (k1, v1), (k2, v2) in combinations(sentences.items(), 2):
sim = cosine_similarity(embeddings[k1], embeddings[k2])
print(f"sim({k1}, {k2}) = {sim:.4f}")
print(f" {v1}")
print(f" {v2}")
print()
Tüüpiline tulemus:
sim(a, b) = 0.8923 ← väga sarnane tähendus
sim(a, c) = 0.1247 ← erinevad teemad
sim(b, c) = 0.1189 ← erinevad teemad
Lausetel a ja b pole ühtegi ühist sõna – cat/feline, sleeps/dozes, couch/sofa – ometi on nende skoor 0,89. See on täpselt see, mida ükski leksikaalne meetod saavutada ei suuda.
Skooride tõlgendamine
Läved sõltuvad sinu kasutusjuhtumist, kuid allolev tabel annab võrdluspunktid skoori lugemiseks, et mitte eksida suurusjärgu võrra.
| Skoor | Tõlgendus |
|---|---|
| > 0,85 | Väga sarnane (parafrasid, sünonüümid) |
| 0,70 – 0,85 | Temaatiliselt seotud |
| 0,40 – 0,70 | Kaudselt seotud |
| < 0,40 | Erinevad teemad |
Need väärtused varieeruvad mudeli ja valdkonna lõikes: juriidiline korpus, kus kõik tekstid jagavad sama formaalset sõnavara, toodab üldiselt kõrgemaid skoore kui üldotstarbeline korpus, nii et 0,70 lävi muutub liiga lubavaks. Kalibreeri alati oma andmetel, vaadeldes umbes kolmekümmet paari, kus sa tead oodatavat vastust.
Lähima naabri otsing
Dokumendi leidmine tähendab sarnasuse arvutamist päringuvektori ja korpuse kõigi vektorite vahel, seejärel parimate k tulemuste säilitamist. Nipp seisneb Pythonis tsükli vältimises: NumPy maatrikskorrutis arvutab kõik sarnasused korraga, murdosa ajaga.
def search_similar(
query_embedding: list[float],
corpus_embeddings: np.ndarray,
k: int = 5
) -> list[tuple[int, float]]:
"""Tagastab k kõige sarnasemat dokumenti."""
query = np.array(query_embedding)
# Kõigi sarnasuste vektoriseeritud arvutus
similarities = corpus_embeddings @ query
# (töötab, kuna OpenAI embeddingsid on normaliseeritud)
# Parimate k skooride indeksid
top_k_indices = np.argsort(similarities)[-k:][::-1]
return [(int(i), float(similarities[i])) for i in top_k_indices]
# Kasutamine
corpus = np.load("embeddings.npy") # maatriks (n, 3072)
query_emb = get_embedding("How do I install Python?")
results = search_similar(query_emb, corpus, k=5)
for idx, score in results:
print(f"Document {idx}: score = {score:.4f}")
[-k:][::-1] väärib teist pilku: argsort sorteerib kasvavas järjekorras, seega võtame massiivi lõpu, et saada parimad skoorid, ja pöörame seejärel ümber, et järjestada need kõige asjakohasemast vähem asjakohemani.
Koos scikit-learniga
Kui sa ei otsi konkreetset dokumenti, vaid soovid võrrelda kogu korpust iseendaga – näiteks duplikaatide tuvastamiseks või klasterdamiseks ettevalmistamisel – pakub scikit-learn optimeeritud funktsiooni, mis tagastab täismaatriksi.
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np
# Sarnasusmaatriks kõigi dokumentide vahel
corpus = np.array(embeddings_list)
sim_matrix = cosine_similarity(corpus)
print(f"Shape: {sim_matrix.shape}") # (n, n)
print(f"Similarity doc 0 ↔ doc 1: {sim_matrix[0][1]:.4f}")
Pea meeles, et see maatriks on suurusega n × n: kümme tuhat dokumenti toodab sada miljonit väärtust, mis on float32-formaadis umbes 400 MB. Üle paari tuhande elemendi töötle plokkidena, mitte ära tee ühte suurt väljakutset.
Peamised punktid
- Koosinussarnasus mõõdab vektorite vahelist nurka, sõltumata nende suurusest
- OpenAI embeddingsid on normaliseeritud: skalaarkorrutis = koosinus
- Skoor > 0,85 viitab väga sarnastele tekstidele
- Lähima naabri otsing tehakse tõhusalt NumPy või scikit-learniga