Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Udaljenost i kosinusna sličnost

Lekcija 4 od 22 Ažurirano 29. srpnja 2026. Programer
Na ovoj stranici
  1. Ciljevi
  2. Mjerenje blizine između vektora
  3. Praktična usporedba
  4. Interpretacija rezultata
  5. Pretraživanje najbližih susjeda
  6. Uz scikit-learn
  7. Ključne točke

Ciljevi

  • Razumjeti kosinusnu sličnost i zašto se preferira
  • Implementirati usporedbu vektora u Pythonu
  • Interpretirati rezultate sličnosti

Mjerenje blizine između vektora

Kada pretvoriš tekstove u vektore, sve se svodi na jedno pitanje: kako odlučiti jesu li dva vektora “blizu”? Postoje tri odgovora, a izbor je bitan.

Euklidska udaljenost klasična je geometrijska udaljenost – ona koju bi izmjerio ravnalom između dviju točaka. Intuitivna je, ali ovisi o veličini (magnitudi) vektora: dva teksta istog značenja, gdje je jedan kodiran većom amplitudom, umjetno bi se činila udaljenima.

import numpy as np

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

Skalarni umnožak (dot product) zbraja umnoške po elementima. To je najbrža operacija u obitelji – ona koju procesor najučinkovitije izvršava na velikim matricama.

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

Kosinusna sličnost, naposljetku, mjeri kut između dva vektora bez obzira na njihovu duljinu, što je čini standardnom metrikom za embedinge: bitan je samo smjer značenja, a ne njegov intenzitet.

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

Vrijednosti se kreću od -1 za suprotne smjerove do +1 za identične smjerove. Jedna praktična pojedinost je ključna: OpenAI embedinzi su već normalizirani, što znači da imaju duljinu 1. Nazivnik je stoga jednak 1, pa skalarni umnožak daje točno isti rezultat kao i kosinusna sličnost – uz manji računalni trošak. To je prečac koji ćemo koristiti tijekom cijelog ovog tečaja.

Praktična usporedba

Ništa ne nadmašuje mjerenje na stvarnim rečenicama. Usporedimo rečenicu, njezinu potpunu parafrazu i rečenicu izvan teme:

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

# Rečenice za usporedbu
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()}

# Usporedi sve parove
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()

Tipičan rezultat:

sim(a, b) = 0.8923   ← vrlo blisko značenje
sim(a, c) = 0.1247   ← različite teme
sim(b, c) = 0.1189   ← različite teme

Rečenice a i b nemaju zajedničkih riječi – cat/feline, sleeps/dozes, couch/sofa – ipak postižu rezultat 0,89. To je točno ono što nijedna leksička metoda ne može postići.

Interpretacija rezultata

Pragovi ovise o tvom slučaju upotrebe, ali donja tablica daje referentne točke za čitanje rezultata kako ne bi promašio red veličine.

RezultatInterpretacija
> 0,85Vrlo slično (parafraze, sinonimi)
0,70 – 0,85Tematski povezano
0,40 – 0,70Labavo povezano
< 0,40Različite teme

Ove vrijednosti variraju ovisno o modelu i domeni: pravni korpus, gdje svi tekstovi dijele isti formalni rječnik, proizvodi općenito više rezultate od korpusa opće namjene, do te mjere da prag od 0,70 postaje previše propustan. Uvijek kalibriraj na vlastitim podacima promatranjem tridesetak parova za koje znaš očekivani odgovor.

Pretraživanje najbližih susjeda

Pronalaženje dokumenta znači izračunavanje sličnosti između vektora upita i svih vektora u korpusu, a zatim zadržavanje najboljih k. Trik je izbjeći petlje u Pythonu: množenje NumPy matrica izračunava sve sličnosti odjednom, u djeliću vremena.

def search_similar(
    query_embedding: list[float],
    corpus_embeddings: np.ndarray,
    k: int = 5
) -> list[tuple[int, float]]:
    """Vraća k najsličnijih dokumenata."""
    query = np.array(query_embedding)

    # Vektorizirani izračun svih sličnosti
    similarities = corpus_embeddings @ query
    # (funkcionira jer su OpenAI embedinzi normalizirani)

    # Indeksi top k rezultata
    top_k_indices = np.argsort(similarities)[-k:][::-1]

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

# Upotreba
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}")

Dio [-k:][::-1] zaslužuje drugi pogled: argsort sortira u uzlaznom redoslijedu, pa uzimamo kraj niza kako bismo dobili najbolje rezultate, a zatim ga obrćemo kako bismo ih rangirali od najrelevantnijih prema najmanje relevantnima.

Uz scikit-learn

Kada ne tražiš dokument, već želiš usporediti cijeli korpus sa samim sobom – na primjer, za otkrivanje duplikata ili pripremu za klasteriranje – scikit-learn nudi optimiziranu funkciju koja vraća punu matricu.

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

# Matrica sličnosti između svih dokumenata
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}")

Imaj na umu da je ova matrica veličine n × n: deset tisuća dokumenata proizvodi sto milijuna vrijednosti, što je oko 400 MB u formatu float32. Iznad nekoliko tisuća elemenata, obrađuj podatke u blokovima umjesto jednim pozivom.

Ključne točke

  • Kosinusna sličnost mjeri kut između vektora, neovisno o njihovoj veličini
  • OpenAI embedinzi su normalizirani: skalarni umnožak = kosinus
  • Rezultat > 0,85 ukazuje na vrlo slične tekstove
  • Pretraživanje najbližih susjeda učinkovito se izvodi s NumPyjem ili scikit-learnom