Podobieństwo semantyczne
Na tej stronie
Pomiar bliskości tekstów
Gdy przekształcisz swoje teksty w wektory za pomocą mistral-embed, możesz zmierzyć, jak bardzo są one zbliżone semantycznie. To sedno wyszukiwania semantycznego: porównujesz znaczenia, a nie same słowa. Podczas gdy zapytanie SQL LIKE '%faktura%' zwraca proste tak lub nie, metryka podobieństwa daje Ci liczbę, co umożliwia rankingowanie. To właśnie ranking czyni cały system wartościowym.
W tej lekcji zaimplementujesz główne metryki podobieństwa i zobaczysz, jak działają w praktyce na konkretnych przykładach w Pythonie.
Odległość euklidesowa
Odległość euklidesowa mierzy długość odcinka łączącego dwa punkty w przestrzeni wektorowej. Im mniejsza odległość, tym bardziej podobne są teksty. Poniższy przykład porównuje trzy zdania: pierwsze dwa mówią o tym samym, używając innego słownictwa, podczas gdy trzecie dotyczy szarlotki. Zdania A i B nie mają żadnych wspólnych słów, a jednak ich odległość będzie znacznie mniejsza niż odległość między A i C.
import numpy as np
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
def get_embedding(text):
"""Get the embedding for a text via mistral-embed."""
response = client.embeddings.create(
model="mistral-embed",
inputs=[text],
)
return np.array(response.data[0].embedding)
# Three sentences to compare
phrase_a = "Machine learning transforms data into predictions."
phrase_b = "Automatic learning converts data into results."
phrase_c = "The recipe for apple pie is simple."
emb_a = get_embedding(phrase_a)
emb_b = get_embedding(phrase_b)
emb_c = get_embedding(phrase_c)
# Euclidean distances
dist_ab = np.linalg.norm(emb_a - emb_b)
dist_ac = np.linalg.norm(emb_a - emb_c)
print(f"Distance A-B (semantically close): {dist_ab:.4f}")
print(f"Distance A-C (semantically distant): {dist_ac:.4f}")
# A-B will be significantly lower than A-C
Podobieństwo kosinusowe
Podobieństwo kosinusowe to najczęściej stosowana metryka dla osadzeń (embeddings). Mierzy ono kąt między dwoma wektorami, niezależnie od ich wielkości. Wynik mieści się w zakresie od -1 do 1, co zapewnia natychmiast czytelną skalę: możesz ustawić próg i zakomunikować go zespołowi biznesowemu bez konieczności tłumaczenia norm wektorowych.
from sklearn.metrics.pairwise import cosine_similarity
# With scikit-learn
sim_ab = cosine_similarity([emb_a], [emb_b])[0][0]
sim_ac = cosine_similarity([emb_a], [emb_c])[0][0]
print(f"Cosine similarity A-B: {sim_ab:.4f}") # ~0.92 (very close)
print(f"Cosine similarity A-C: {sim_ac:.4f}") # ~0.35 (distant)
Różnica między 0,92 a 0,35 to kluczowa informacja: nie chodzi o wartość bezwzględną, lecz o margines oddzielający trafne wyniki od tych niezwiązanych z tematem w Twoim konkretnym zbiorze danych. Możesz również zaimplementować tę metrykę ręcznie, choćby po to, by zweryfikować działanie biblioteki scikit-learn lub uniknąć zależności w środowisku o ograniczonych zasobach:
def cosine_sim(vec_a, vec_b):
"""Manual cosine similarity."""
dot = np.dot(vec_a, vec_b)
norm_a = np.linalg.norm(vec_a)
norm_b = np.linalg.norm(vec_b)
return dot / (norm_a * norm_b)
print(f"Manual verification A-B: {cosine_sim(emb_a, emb_b):.4f}")
Macierz podobieństwa
Aby porównać ze sobą wiele dokumentów, możesz zbudować macierz podobieństwa. Poniższy korpus celowo miesza dwa tematy – sztuczną inteligencję i gastronomię – dzięki czemu struktura rzuca się w oczy: dokumenty 0, 1 i 3 są ze sobą powiązane, podczas gdy dokumenty 2 i 4 tworzą osobny klaster. To dokładnie ten sygnał, który wykorzystują algorytmy klasteryzacji.
from sklearn.metrics.pairwise import cosine_similarity
documents = [
"Mistral AI develops language models.",
"LLMs generate text from prompts.",
"French cuisine is renowned worldwide.",
"NLP is a branch of artificial intelligence.",
"Croissants taste best in the morning.",
]
# Encode all documents
response = client.embeddings.create(
model="mistral-embed",
inputs=documents,
)
embeddings = np.array([d.embedding for d in response.data])
# Similarity matrix (5x5)
sim_matrix = cosine_similarity(embeddings)
print("Similarity Matrix:")
for i, doc in enumerate(documents):
for j, doc2 in enumerate(documents):
if j > i:
print(f" [{i}]-[{j}]: {sim_matrix[i][j]:.3f}")
Proste wyszukiwanie semantyczne
Wszystkie powyższe elementy składają się na mini silnik wyszukiwania. Zapytanie jest kodowane tym samym modelem co korpus – jest to warunek konieczny, ponieważ dwa różne modele generują nieporównywalne przestrzenie – a następnie funkcja argsort odwraca ranking, aby umieścić najwyższe wyniki na górze.
def recherche_semantique(query, documents, embeddings, top_k=3):
"""Finds the most relevant documents for a query."""
# Encode the query
query_response = client.embeddings.create(
model="mistral-embed",
inputs=[query],
)
query_embedding = np.array(query_response.data[0].embedding)
# Calculate similarities
similarities = cosine_similarity(
[query_embedding], embeddings
)[0]
# Sort by descending similarity
ranked_indices = np.argsort(similarities)[::-1][:top_k]
results = []
for idx in ranked_indices:
results.append({
"document": documents[idx],
"score": similarities[idx],
"index": int(idx),
})
return results
# Usage example
query = "How does Mistral's AI work?"
results = recherche_semantique(query, documents, embeddings)
for r in results:
print(f" Score: {r['score']:.3f} -- {r['document']}")
Próg trafności
Ten silnik ma wadę, którą szybko odkryjesz w środowisku produkcyjnym: zawsze zwraca trzy wyniki, nawet gdy pytanie nie ma nic wspólnego z korpusem. Zapytaj go o pogodę, a zwróci trzy najmniej odległe dokumenty, z śmiesznie niskimi wynikami, ale z pozoru normalnym rankingiem. W praktyce musisz więc zdefiniować próg podobieństwa, poniżej którego dokument uznaje się za nieistotny:
SEUIL_PERTINENCE = 0.7
def recherche_avec_seuil(query, documents, embeddings, seuil=SEUIL_PERTINENCE):
"""Search with filtering by relevance threshold."""
results = recherche_semantique(query, documents, embeddings, top_k=len(documents))
return [r for r in results if r["score"] >= seuil]
# A threshold of 0.7 is a good starting point
# Adjust based on your use case:
# - 0.8+: very strict (few results, high relevance)
# - 0.6-0.7: balanced
# - 0.5: permissive (many results, variable relevance)
Poświęć czas na kalibrację tego progu na około trzydziestu rzeczywistych zapytaniach, zanim udostępnisz usługę użytkownikom. Jeśli ustawisz go zbyt wysoko, Twój silnik odpowie „nie wiem“ na legitne pytania. Jeśli ustawisz go zbyt nisko, dostarczysz modelowi LLM kontekst niezwiązany z tematem, tworząc właśnie te halucynacje, którym RAG miał zapobiec.
Kluczowe wnioski
- Podobieństwo kosinusowe to standardowa metryka do porównywania osadzeń (embeddings)
- Do szybkich obliczeń używaj
sklearn.metrics.pairwise.cosine_similarity - Macierz podobieństwa pozwala porównać wszystkie dokumenty ze sobą nawzajem
- Zdefiniuj próg trafności dostosowany do swojego przypadku użycia (0,7 to dobry domyślny wybór)
- Wyszukiwanie semantyczne znajduje wyniki na podstawie znaczenia, a nie dokładnego dopasowania słów