Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Semantinis panašumas

Paskaita 3 iš 18 Atnaujinta 2026 m. lapkričio 2 d. Kūrėjas
Šiame puslapyje
  1. Teksto artumo matavimas
  2. Euklido atstumas
  3. Kosinusinis panašumas
  4. Panašumo matrica
  5. Paprasta semantinė paieška
  6. Aktualumo slenkstis
  7. Svarbiausi punktai

Teksto artumo matavimas

Kai tekstus paversi vektoriais naudodamas mistral-embed, galėsi kiekybiškai įvertinti, kaip semantiškai arti yra du tekstai. Tai yra semantinės paieškos esmė: lyginamos prasmės, o ne tik žodžiai. Kol SQL užklausa LIKE '%sąskaita%' grąžina tiesiog „taip“ arba „ne“, panašumo metrika suteikia skaitinę reikšmę, leidžiančią sudaryti reitingą. Būtent šis reitingas daro visą sistemą vertinga.

Šioje pamokoje įgyvendinsi pagrindines panašumo metrikas ir pamatysi, kaip jos veikia praktiškai, naudodamas konkrečius Python pavyzdžius.

Euklido atstumas

Euklido atstumas matuoja atkarpos ilgį tarp dviejų taškų vektorių erdvėje. Kuo mažesnis atstumas, tuo tekstai panašesni. Toliau pateiktame pavyzdyje lyginami trys sakiniai: pirmieji du sako tą patį, naudodami skirtingą žodyną, o trečiasis kalba apie obuolių pyragą. Sakiniai A ir B neturi bendrų žodžių, tačiau jų atstumas bus žymiai mažesnis nei atstumas tarp A ir 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

Kosinusinis panašumas

Kosinusinis panašumas yra plačiausiai naudojama įterpimų metrika. Ji matuoja kampą tarp dviejų vektorių, nepriklausomai nuo jų dydžio. Rezultatas svyruoja nuo -1 iki 1, suteikdamas iškart suprantamą skalę: gali nustatyti slenkstį ir jį perteikti verslo komandai, nereikalaudamas aiškinti vektorių normų.

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)

Skirtumas tarp 0,92 ir 0,35 yra naudinga informacija: svarbi ne absoliuti reikšmė, o riba, skirianti aktualius rezultatus nuo nesusijusių tavo konkrečiame duomenų rinkinyje. Metriką gali įgyvendinti ir rankiniu būdu, jei tik nori patikrinti, ką daro scikit-learn, arba išvengti priklausomybių ribotoje aplinkoje:

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

Panašumo matrica

Norėdamas palyginti kelis dokumentus tarpusavyje, gali sukurti panašumo matricą. Toliau pateiktame korpuse tyčia sumaišytos dvi temos – dirbtinis intelektas ir gastronomija, todėl struktūra iškart matoma: 0, 1 ir 3 dokumentai yra susiję tarpusavyje, o 2 ir 4 dokumentai sudaro atskirą klasterį. Būtent šį signalą išnaudoja klasterizavimo algoritmai.

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

Paprasta semantinė paieška

Visa tai kartu sudaro mini paieškos variklį. Užklausa koduojama tuo pačiu modeliu kaip ir korpusas – tai būtina sąlyga, nes du skirtingi modeliai sukuria nepalyginamas erdves – tada argsort apverčia reitingą, kad aukščiausi balai atsidurtų viršuje.

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']}")

Aktualumo slenkstis

Šis variklis turi trūkumą, kurį greitai pastebėsi gamyboje: jis visada grąžina tris rezultatus, net jei klausimas neturi nieko bendro su korpusu. Paklausk apie orus, ir jis grąžins tris mažiausiai nutolusius dokumentus su juokingais balais, bet išoriškai normaliu reitingu. Praktiškai todėl turi nustatyti panašumo slenkstį, žemiau kurio dokumentas laikomas nereikšmingu:

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)

Skirk laiko šiam slenksčiui sukalibruoti pagal apie trisdešimt realių užklausų, prieš atverdamas servisą naudotojams. Nustatysi per aukštai – ir tavo variklis atsakys „nežinau“ į teisėtus klausimus. Nustatysi per žemai – ir maitinsi LLM nesusijusiu kontekstu, sukurdamas būtent tas haliucinacijas, kurias RAG turėjo užkirsti.

Svarbiausi punktai

  • Kosinusinis panašumas yra standartinė metrika įterpimams lyginti
  • Greitiems skaičiavimams naudok sklearn.metrics.pairwise.cosine_similarity
  • Panašumo matrica leidžia palyginti visus dokumentus tarpusavyje
  • Nustatyk aktualumo slenkstį, pritaikytą tavo naudojimui (0,7 yra geras numatytasis dydis)
  • Semantinė paieška randa rezultatus pagal prasmę, o ne pagal tikslų žodžių sutapimą