Odległość i podobieństwo kosinusowe
Na tej stronie
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.
| Wynik | Interpretacja |
|---|---|
| > 0,85 | Bardzo podobne (parafrazy, synonimy) |
| 0,70 – 0,85 | Tematycznie powiązane |
| 0,40 – 0,70 | Luźno powiązane |
| < 0,40 | Róż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