Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Etäisyys ja kosinussimilariteetti

Oppitunti 4 / 22 Päivitetty 29. heinäkuuta 2026 Kehittäjä
Tällä sivulla
  1. Tavoitteet
  2. Vektorien välisen läheisyyden mittaaminen
  3. Käytännön vertailu
  4. Pisteiden tulkinta
  5. Lähimmän naapurin haku
  6. Scikit-learnin kanssa
  7. Keskeiset asiat

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ä.

PisteetTulkinta
> 0,85Erittäin samankaltaiset (parafraasit, synonyymit)
0,70 – 0,85Temaattisesti liittyvät
0,40 – 0,70Väljästi liittyvät
< 0,40Eri 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