Разстояние и косинусова подобност
На тази страница
Цели
- Да разберете косинусовата подобност и защо тя е предпочитаният метод
- Да реализирате сравнение на вектори на Python
- Да интерпретирате резултатите от подобността
Измерване на близостта между вектори
След като превърнете текстовете си във вектори, всичко зависи от един въпрос: как решавате дали два вектора са „близки“? Съществуват три отговора и изборът има значение.
Евклидовото разстояние е класическото геометрично разстояние – това, което бихте измерили с линийка между две точки. То е интуитивно, но зависи от големината (магнитуда) на вектора: два текста със същото значение, единият от които е кодиран с по-голяма амплитуда, биха изкуствено се оказали далеч един от друг.
import numpy as np
def euclidean_distance(a: list[float], b: list[float]) -> float:
return np.linalg.norm(np.array(a) - np.array(b))
Скаларното произведение сумира произведенията на елементите по двойки. Това е най-бързата операция в семейството – тази, която процесорът изпълнява най-ефективно при големи матрици.
def dot_product(a: list[float], b: list[float]) -> float:
return np.dot(a, b)
Косинусовата подобност накрая измерва ъгъла между два вектора, независимо от тяхната дължина, което я прави стандартната метрика за вгражданията (embeddings): има значение само посоката на смисъла, а не неговата интензивност.
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))
Стойността ѝ варира от -1 за противоположни посоки до +1 за идентични посоки. Един практически детайл е от съществено значение: вгражданията на OpenAI вече са нормализирани, което означава, че имат дължина 1. Следователно знаменателят е равен на 1 и скаларното произведение дава точно същия резултат като косинусовата подобност – но с по-ниски изчислителни разходи. Това е съкращението, което ще използваме през целия курс.
Практическо сравнение
Нищо не може да замени измерването на реални изречения. Нека сравним едно изречение, неговия пълен парафраз и едно изречение извън темата:
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
# Изречения за сравнение
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()}
# Сравняване на всички двойки
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()
Типичен резултат:
sim(a, b) = 0.8923 ← много близък смисъл
sim(a, c) = 0.1247 ← различни теми
sim(b, c) = 0.1189 ← различни теми
Изреченията a и b нямат общи думи – cat/feline, sleeps/dozes, couch/sofa – въпреки това получават оценка 0.89. Това е точно онова, което никой лексикален метод не може да постигне.
Интерпретиране на оценките
Праговете зависят от вашия случай на употреба, но таблицата по-долу дава отправни точки за четене на резултата, без да се бърка с порядък.
| Оценка | Интерпретация |
|---|---|
| > 0.85 | Много сходни (парафрази, синоними) |
| 0.70 – 0.85 | Тематично свързани |
| 0.40 – 0.70 | Слабо свързани |
| < 0.40 | Различни теми |
Тези стойности варират според модела и домейна: юридически корпус, където всички текстове споделят една и съща формална лексика, произвежда като цяло по-високи оценки от корпус с общо предназначение, дотолкова, че праг от 0.70 става твърде допустим. Винаги калибрирайте върху собствените си данни, като наблюдавате около тридесет двойки, за които знаете очаквания отговор.
Търсене на най-близкия съсед
Намирането на документ означава изчисляване на подобността между вектора на заявката и всички вектори в корпуса, след което се запазват топ k. Триъкът е да избегнете цикли в Python: умножението на матрици с NumPy изчислява всички подобности наведнъж, за част от времето.
def search_similar(
query_embedding: list[float],
corpus_embeddings: np.ndarray,
k: int = 5
) -> list[tuple[int, float]]:
"""Връща k-те най-подобни документа."""
query = np.array(query_embedding)
# Векторизирано изчисление на всички подобности
similarities = corpus_embeddings @ query
# (работи, защото вгражданията на OpenAI са нормализирани)
# Индекси на топ k резултатите
top_k_indices = np.argsort(similarities)[-k:][::-1]
return [(int(i), float(similarities[i])) for i in top_k_indices]
# Употреба
corpus = np.load("embeddings.npy") # матрица (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] заслужава втори поглед: argsort сортира във възходящ ред, затова взимаме края на масива, за да получим най-добрите оценки, след което обръщаме реда, за да ги класираме от най-релевантните към най-малко релевантните.
С scikit-learn
Когато не търсите конкретен документ, а искате да сравните целия корпус със самия него – например за откриване на дубликати или подготовка за клъстериране – scikit-learn предоставя оптимизирана функция, която връща пълната матрица.
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np
# Матрица на подобността между всички документи
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}")
Имайте предвид, че тази матрица е с размер n × n: десет хиляди документа произвеждат сто милиона стойности, около 400 MB във формат float32. При повече от няколко хиляди елемента обработвайте на блокове, вместо да правите едно единствено извикване.
Ключови изводи
- Косинусовата подобност измерва ъгъла между векторите, независимо от тяхната големина
- Вгражданията на OpenAI са нормализирани: скаларно произведение = косинусова подобност
- Оценка > 0.85 показва много сходни текстове
- Търсенето на най-близкия съсед се извършва ефективно с NumPy или scikit-learn