Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Attālums un kosinusa līdzība

Nodarbība 4 no 22 Atjaunota 2026. gada 29. jūlijs Programmētājs
Šajā lapā
  1. Mērķi
  2. Attāluma mērīšana starp vektoriem
  3. Praktisks salīdzinājums
  4. Rezultātu interpretēšana
  5. Tuvākā kaimiņa meklēšana
  6. Izmantojot scikit-learn
  7. Galvenās atziņas

Mērķi

  • Saprast kosinusa līdzību un iemeslus, kāpēc tā ir vēlamā metode
  • Implementēt vektoru salīdzināšanu valodā Python
  • Interpretēt līdzības rezultātus

Attāluma mērīšana starp vektoriem

Kad esi pārvērtis savus tekstus vektoros, viss ir atkarīgs no viena jautājuma: kā tu nosaki, vai divi vektori ir “tuvu”? Pastāv trīs atbildes, un izvēlei ir nozīme.

Eiklīda attālums ir klasiskais ģeometriskais attālums – tas, ko tu mērītu ar lineālu starp diviem punktiem. Tas ir intuitīvs, taču ir atkarīgs no vektora lieluma: divi teksti ar vienādu nozīmi, kur viens ir kodēts ar lielāku amplitūdu, šķistu mākslīgi tālu viens no otra.

import numpy as np

def euclidean_distance(a: list[float], b: list[float]) -> float:
    return np.linalg.norm(np.array(a) - np.array(b))

Skalārais reizinājums saskaita elementu pa elementam reizinātos rezultātus. Tā ir ātrākā operācija šajā saimē – tā, ko procesors visefektīvāk izpilda lieliem matricu masīviem.

def dot_product(a: list[float], b: list[float]) -> float:
    return np.dot(a, b)

Kosinusa līdzība, visbeidzot, mēra leņķi starp diviem vektoriem neatkarīgi no to garuma, padarot to par standarta metrikai iegulējumiem: svarīgs ir tikai nozīmes virziens, nevis tās intensitāte.

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))

Tā svārstās no -1 pretējiem virzieniem līdz +1 identiskiem virzieniem. Viens praktisks detalizējums ir svarīgs: OpenAI iegulējumi jau ir normalizēti, kas nozīmē, ka tiem ir garums 1. Tādējādi saucējs ir vienāds ar 1, un skalārais reizinājums dod tieši tādu pašu rezultātu kā kosinusa līdzība – ar mazākām aprēķinu izmaksām. Šo īsceļu mēs izmantosim visā šī kursa laikā.

Praktisks salīdzinājums

Nekas nepārspēj reālu teikumu mērīšanu. Salīdzināsim teikumu, tā pilnu parafrazi un teikumu, kas nav par tēmu:

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

# Salīdzināmie teikumi
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()}

# Salīdzināt visus pārus
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()

Tipisks rezultāts:

sim(a, b) = 0.8923   ← ļoti līdzīga nozīme
sim(a, c) = 0.1247   ← dažādas tēmas
sim(b, c) = 0.1189   ← dažādas tēmas

Teikumiem a un b nav kopīgu vārdu – cat/feline, sleeps/dozes, couch/sofa – tomēr tie iegūst 0,89. Tieši to nevar panākt neviena leksikālā metode.

Rezultātu interpretēšana

Sliekšņi ir atkarīgi no tava lietojuma gadījuma, taču zemāk esošā tabula sniedz atsauces punktus rezultāta lasīšanai, nekļūdoties par kārtu.

RezultātsInterpretācija
> 0,85Ļoti līdzīgi (parafrazes, sinonīmi)
0,70 – 0,85Tematiski saistīti
0,40 – 0,70Vāji saistīti
< 0,40Dažādas tēmas

Šīs vērtības mainās atkarībā no modeļa un domēna: juridisks korpuss, kurā visiem tekstiem ir vienāda formāla vokabulāra, ģenerē kopumā augstākus rezultātus nekā vispārējs korpuss, līdz pat punktam, kur 0,70 slieksnis kļūst pārāk liberāls. Vienmēr kalibrē uz saviem datiem, novērojot aptuveni trīsdesmit pārus, kuros zini paredzamo atbildi.

Tuvākā kaimiņa meklēšana

Dokumenta atrašana nozīmē līdzības aprēķināšanu starp vaicājuma vektoru un visiem korpusa vektoriem, pēc tam saglabājot labākos k. Triks ir izvairīties no cikla valodā Python: NumPy matricas reizināšana aprēķina visas līdzības vienlaikus, daļā no laika.

def search_similar(
    query_embedding: list[float],
    corpus_embeddings: np.ndarray,
    k: int = 5
) -> list[tuple[int, float]]:
    """Atgriež k līdzīgākos dokumentus."""
    query = np.array(query_embedding)

    # Visu līdzību vektorizēts aprēķins
    similarities = corpus_embeddings @ query
    # (darbojas, jo OpenAI iegulējumi ir normalizēti)

    # Labāko k rezultātu indeksi
    top_k_indices = np.argsort(similarities)[-k:][::-1]

    return [(int(i), float(similarities[i])) for i in top_k_indices]

# Lietošana
corpus = np.load("embeddings.npy")  # matrica (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] ir pelnījis otro skatienu: argsort kārto augošā secībā, tāpēc mēs ņemam masīva beigas, lai iegūtu labākos rezultātus, un pēc tam apgriežam otrādi, lai rangotu tos no visatbilstošākajiem līdz vismazāk atbilstošajiem.

Izmantojot scikit-learn

Kad tu nemeklē konkrētu dokumentu, bet vēlies salīdzināt visu korpusu ar sevi pašu – piemēram, lai noteiktu dublikātus vai sagatavotos klasterizācijai – scikit-learn nodrošina optimizētu funkciju, kas atgriež pilnu matricu.

from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

# Līdzības matrica starp visiem dokumentiem
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}")

Paturi prātā, ka šī matrica ir n × n liela: desmit tūkstoši dokumentu rada simts miljonus vērtību, aptuveni 400 MB float32 formātā. Pārsniedzot dažus tūkstošus elementu, apstrādā blokos, nevis veic vienu vienīgu izsaukumu.

Galvenās atziņas

  • Kosinusa līdzība mēra leņķi starp vektoriem, neatkarīgi no to lieluma
  • OpenAI iegulējumi ir normalizēti: skalārais reizinājums = kosinuss
  • Rezultāts > 0,85 norāda uz ļoti līdzīgiem tekstiem
  • Tuvākā kaimiņa meklēšana tiek veikta efektīvi, izmantojot NumPy vai scikit-learn