Przejdź do głównej treści
Polski— Wybierz język
Menu

Odległość i podobieństwo kosinusowe

Lekcja 4 z 22 Zaktualizowano 29 lipca 2026 Programista
Na tej stronie
  1. Cele
  2. Pomiar bliskości między wektorami
  3. Porównanie praktyczne
  4. Interpretacja wyników
  5. Wyszukiwanie najbliższych sąsiadów
  6. Z użyciem scikit-learn
  7. Kluczowe wnioski

Cele

  • Zrozumieć podobieństwo kosinusowe i powody jego preferowania
  • Zaimplementować porównywanie wektorów w Pythonie
  • Interpretować wyniki podobieństwa

Pomiar bliskości między wektorami

Gdy już przekształcisz swoje teksty w wektory, wszystko sprowadza się do jednego pytania: jak zdecydujesz, czy dwa wektory są „bliskie“? Istnieją trzy odpowiedzi, a wybór ma znaczenie.

Odległość euklidesowa to klasyczna odległość geometryczna – taka, jaką zmierzysz linijką między dwoma punktami. Jest intuicyjna, ale zależy od wielkości wektora: dwa teksty o tym samym znaczeniu, z których jeden został zakodowany z większą amplitudą, sztucznie wydawałyby się bardzo odległe.

import numpy as np

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

Iloczyn skalarny sumuje iloczyny odpowiadających sobie elementów. Jest to najszybsza operacja w tej rodzinie – tę, którą procesor wykonuje najefektywniej na dużych macierzach.

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

Podobieństwo kosinusowe mierzy kąt między dwoma wektorami niezależnie od ich długości, co czyni je standardową metryką dla osadzeń: liczy się tylko kierunek znaczenia, a nie jego intensywność.

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

Wartość ta wynosi od -1 dla przeciwnych kierunków do +1 dla kierunków identycznych. Istnieje jeden istotny szczegół praktyczny: osadzenia OpenAI są już znormalizowane, co oznacza, że mają długość 1. Mianownik wynosi zatem 1, a iloczyn skalarny daje dokładnie ten sam wynik co podobieństwo kosinusowe – przy niższym koszcie obliczeniowym. To skrót, którego będziemy używać przez cały ten kurs.

Porównanie praktyczne

Nic nie zastąpi pomiaru na rzeczywistych zdaniach. Porównajmy zdanie, jego pełny parafraz i zdanie niezwiązane z tematem:

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

# Zdania do porównania
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()}

# Porównaj wszystkie pary
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()

Typowy wynik:

sim(a, b) = 0.8923   ← bardzo bliskie znaczenie
sim(a, c) = 0.1247   ← różne tematy
sim(b, c) = 0.1189   ← różne tematy

Zdania a i b nie mają wspólnych słów – cat/feline, sleeps/dozes, couch/sofa – a jednak osiągają wynik 0,89. To dokładnie to, czego żadna metoda leksykalna nie jest w stanie osiągnąć.

Interpretacja wyników

Progi zależą od przypadku użycia, ale poniższa tabela podaje punkty odniesienia pozwalające odczytać wynik bez pomyłki o rząd wielkości.

WynikInterpretacja
> 0,85Bardzo podobne (parafrazy, synonimy)
0,70 – 0,85Tematycznie powiązane
0,40 – 0,70Luźno powiązane
< 0,40Różne tematy

Wartości te różnią się w zależności od modelu i domeny: korpus prawny, w którym wszystkie teksty dzielą to samo formalne słownictwo, generuje ogólnie wyższe wyniki niż korpus ogólny, do tego stopnia, że próg 0,70 staje się zbyt permisjiwny. Zawsze kalibruj model na własnych danych, obserwując około trzydziestu par, dla których znasz oczekiwany wynik.

Wyszukiwanie najbliższych sąsiadów

Znalezienie dokumentu oznacza obliczenie podobieństwa między wektorem zapytania a wszystkimi wektorami w korpusie, a następnie wybranie najlepszych k. Sztuczka polega na uniknięciu pętli w Pythonie: mnożenie macierzy NumPy oblicza wszystkie podobieństwa jednocześnie, w ułamku czasu.

def search_similar(
    query_embedding: list[float],
    corpus_embeddings: np.ndarray,
    k: int = 5
) -> list[tuple[int, float]]:
    """Zwraca k najbardziej podobnych dokumentów."""
    query = np.array(query_embedding)

    # Wektoryzowane obliczenie wszystkich podobieństw
    similarities = corpus_embeddings @ query
    # (działa, ponieważ osadzenia OpenAI są znormalizowane)

    # Indeksy najlepszych k wyników
    top_k_indices = np.argsort(similarities)[-k:][::-1]

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

# Użycie
corpus = np.load("embeddings.npy")  # macierz (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"Dokument {idx}: wynik = {score:.4f}")

Fragment [-k:][::-1] zasługuje na drugie spojrzenie: argsort sortuje w kolejności rosnącej, więc bierzemy koniec tablicy, aby uzyskać najlepsze wyniki, a następnie odwracamy kolejność, aby uszeregować je od najbardziej do najmniej istotnych.

Z użyciem scikit-learn

Gdy nie szukasz konkretnego dokumentu, ale chcesz porównać cały korpus sam ze sobą – na przykład w celu wykrycia duplikatów lub przygotowania do klasteryzacji – scikit-learn udostępnia zoptymalizowaną funkcję, która zwraca pełną macierz.

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

# Macierz podobieństwa między wszystkimi dokumentami
corpus = np.array(embeddings_list)
sim_matrix = cosine_similarity(corpus)

print(f"Kształt: {sim_matrix.shape}")  # (n, n)
print(f"Podobieństwo dok 0 ↔ dok 1: {sim_matrix[0][1]:.4f}")

Pamiętaj, że macierz ta ma rozmiar n × n: dziesięć tysięcy dokumentów generuje sto milionów wartości, co zajmuje około 400 MB w formacie float32. Przy więcej niż kilku tysiącach elementów przetwarzaj dane w blokach, zamiast wykonywać pojedyncze wywołanie.

Kluczowe wnioski

  • Podobieństwo kosinusowe mierzy kąt między wektorami, niezależnie od ich wielkości
  • Osadzenia OpenAI są znormalizowane: iloczyn skalarny = podobieństwo kosinusowe
  • Wynik > 0,85 wskazuje na bardzo podobne teksty
  • Wyszukiwanie najbliższych sąsiadów wykonuje się efektywnie za pomocą NumPy lub scikit-learn