Etäisyys ja kosinussimilariteetti
Tällä sivulla
Tavoitteet
- Ymmärtää kosinussimilariteetti ja sen etulyöntiasema
- Toteuttaa vektorivertailu Pythonilla
- Tulkita similariteettipisteitä
Vektorien välisen läheisyyden mittaaminen
Kun olet muuntanut tekstisi vektoreiksi, kaikki riippuu yhdestä kysymyksestä: miten päätät, ovatko kaksi vektoria “lähellä” toisiaan? Vastauksia on kolme, ja valinnalla on väliä.
Euklidinen etäisyys on klassinen geometrinen etäisyys – se, jonka mittaisit viivaimella kahden pisteen välillä. Se on intuitiivinen, mutta riippuu vektorin suuruudesta: kaksi samaa merkitystä sisältävää tekstiä, joista toinen on koodattu suuremmalla amplitudilla, näyttäisivät keinotekoisen kaukana toisistaan.
import numpy as np
def euclidean_distance(a: list[float], b: list[float]) -> float:
return np.linalg.norm(np.array(a) - np.array(b))
Pistetulo laskee yhteen alkiokohtaiset tulot. Se on perheen nopein operaatio – sen suoritin ajaa tehokkaimmin suurilla matriiseilla.
def dot_product(a: list[float], b: list[float]) -> float:
return np.dot(a, b)
Kosinussimilariteetti puolestaan mittaa kahden vektorin välistä kulmaa niiden pituudesta riippumatta, mikä tekee siitä upotusten standardimittarin: vain merkityksen suunta ratkaisee, ei sen intensiteetti.
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))
Se vaihtelee välillä -1 vastakkaisille suunnille ja +1 identtisille suunnille. Yksi käytännön yksityiskohta on tärkeä: OpenAI-upotukset on jo normalisoitu, eli niiden pituus on 1. Nimittäjä on siten 1, ja pistetulo tuottaa täsmälleen saman tuloksen kuin kosinussimilariteetti – pienemmällä laskentakustannuksella. Tätä oikotietä käytämme koko tämän kurssin ajan.
Käytännön vertailu
Mikään ei voita oikeiden lauseiden mittaamista. Verrataan lausetta, sen täydellistä paraphrasointia ja aiheeseen kuulumatonta lausetta:
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
# Vertailtavat lauseet
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()}
# Vertaillaan kaikkia pareja
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()
Tyypillinen tulos:
sim(a, b) = 0.8923 ← hyvin lähellä oleva merkitys
sim(a, c) = 0.1247 ← eri aiheet
sim(b, c) = 0.1189 ← eri aiheet
Lauseet a ja b eivät jaa yhtäkään sanaa – kissa/felidi, nukkuu/torkkuu, sohva/divaani – mutta ne saavat pistemääräksi 0,89. Tämä on täsmälleen se, mihin mikään leksikaalinen menetelmä ei pysty.
Pisteiden tulkinta
Kynnysarvot riippuvat käyttötarkoituksestasi, mutta alla oleva taulukko antaa vertailukohtia pistemäärän lukemiseen ilman suuruusluokan virheitä.
| Pisteet | Tulkinta |
|---|---|
| > 0,85 | Erittäin samankaltaiset (parafraasit, synonyymit) |
| 0,70 – 0,85 | Temaattisesti liittyvät |
| 0,40 – 0,70 | Väljästi liittyvät |
| < 0,40 | Eri aiheet |
Nämä arvot vaihtelevat mallin ja toimialan mukaan: juridinen aineisto, jossa kaikissa teksteissä on sama muodollinen sanasto, tuottaa yleensä korkeampia pisteitä kuin yleiskäyttöinen aineisto, niin paljon että 0,70:n kynnys muuttuu liian sallivaksi. Kalibroi arvot aina omalla datallasi tarkkailemalla noin kolmeakymmentä paria, joissa tiedät odotetun vastauksen.
Lähimmän naapurin haku
Asiakirjan löytäminen tarkoittaa similariteetin laskemista kyselyvektorin ja kaikkien aineiston vektorien välillä, minkä jälkeen parhaat k tulosta pidetään tallella. Temppu on välttää silmukointia Pythonissa: NumPy-matriisikertolasku laskee kaikki similariteetit kerralla murto-osassa ajasta.
def search_similar(
query_embedding: list[float],
corpus_embeddings: np.ndarray,
k: int = 5
) -> list[tuple[int, float]]:
"""Palauttaa k samankaltaisinta asiakirjaa."""
query = np.array(query_embedding)
# Kaikkien similariteettien vektoroitu laskenta
similarities = corpus_embeddings @ query
# (toimii, koska OpenAI-upotukset on normalisoitu)
# Parhaiden k-pisteiden indeksit
top_k_indices = np.argsort(similarities)[-k:][::-1]
return [(int(i), float(similarities[i])) for i in top_k_indices]
# Käyttö
corpus = np.load("embeddings.npy") # matriisi (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}")
Osio [-k:][::-1] ansaitsee toisen katsauksen: argsort lajittelee nousevassa järjestyksessä, joten otamme taulukon lopun saadaksemme parhaat pisteet ja käännämme järjestyksen arvokkaimmasta vähiten arvokkaaseen.
Scikit-learnin kanssa
Kun et etsi yksittäistä asiakirjaa, vaan haluat verrata koko aineistoa itseensä – esimerkiksi kaksoiskappaleiden havaitsemiseksi tai klusterointia varten valmistautuessa – scikit-learn tarjoaa optimoidun funktion, joka palauttaa koko matriisin.
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np
# Similariteettimatriisi kaikkien asiakirjojen välillä
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}")
Pidä mielessä, että tämä matriisi on kooltaan n × n: kymmenentuhatta asiakirjaa tuottaa sata miljoonaa arvoa, noin 400 Mt float32-muodossa. Muutaman tuhannen elementin yli prosessoi lohkoissa yhden kutsun sijaan.
Keskeiset asiat
- Kosinussimilariteetti mittaa vektorien välistä kulmaa niiden suuruudesta riippumatta
- OpenAI-upotukset on normalisoitu: pistetulo = kosini
- Pisteet > 0,85 osoittavat erittäin samankaltaisia tekstejä
- Lähimmän naapurin haku tehdään tehokkaasti NumPyllä tai scikit-learnilla