Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Līdzība pēc nozīmes

Nodarbība 3 no 18 Atjaunota 2026. gada 2. novembris Programmētājs
Šajā lapā
  1. Teksta tuvuma mērīšana
  2. Eiklīda attālums
  3. Kosinusa līdzība
  4. Līdzības matrica
  5. Vienkārša semantiskā meklēšana
  6. Atbilstības slieksnis
  7. Galvenās atziņas

Teksta tuvuma mērīšana

Kad esi pārveidojis savus tekstus vektoros, izmantojot mistral-embed, vari kvantificēt, cik semantiski tuvu viens otram atrodas divi teksti. Tas ir semantiskās meklēšanas pamats: salīdzina nozīmes, nevis tikai vārdus. Kamēr SQL vaicājums LIKE '%invoice%' atgriež vienkāršu “jā” vai “nē”, līdzības metrika dod skaitli, kas ļauj veidot rangus. Tieši šī rangošana padara visu sistēmu vērtīgu.

Šajā nodarbībā tu ieviesīsi galvenās līdzības metrikas un redzēsi, kā tās darbojas praksē ar konkrētiem Python piemēriem.

Eiklīda attālums

Eiklīda attālums mēra nogriežņa garumu starp diviem punktiem vektoru telpā. Jo mazāks attālums, jo līdzīgāki ir teksti. Zemāk redzamais piemērs salīdzina trīs teikumus: pirmie divi saka to pašu, izmantojot atšķirīgu vārdu krājumu, bet trešais runā par ābolu pīrāgu. Teikumiem A un B nav neviena kopīga vārda, taču to attālums būs ievērojami mazāks nekā attālums starp A un 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

Kosinusa līdzība

Kosinusa līdzība ir visplašāk izmantotā metrika iegulējumiem. Tā mēra leņķi starp diviem vektoriem, neatkarīgi no to lieluma. Rezultāts ir robežās no -1 līdz 1, nodrošinot uzreiz saprotamu skalu: vari noteikt slieksni un paziņot to biznesa komandai, neizskaidrojot vektoru normas.

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)

Starpība starp 0,92 un 0,35 ir tā vērtīgā informācija: svarīga nav absolūtā vērtība, bet gan atstarpe, kas tavā konkrētajā datu kopā atdala atbilstošos rezultātus no tiem, kas nav par tēmu. Metriku vari ieviest arī manuāli, ja vien lai pārbaudītu, ko dara scikit-learn, vai lai izvairītos no atkarībām ierobežotā vidē:

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

Līdzības matrica

Lai salīdzinātu vairākus dokumentus savā starpā, vari izveidot līdzības matricu. Zemāk esošajā korpusā apzināti sajauktas divas tēmas – mākslīgais intelekts un gastronomija –, lai struktūra būtu acīmredzama: dokumenti 0, 1 un 3 ir saistīti savā starpā, bet dokumenti 2 un 4 veido atsevišķu kopu. Tieši šo signālu izmanto klasterizācijas algoritmi.

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

Vienkārša semantiskā meklēšana

Viss iepriekš minētais apvienojas mini meklētājdzinē. Vaicājums tiek kodēts ar to pašu modeli, ko arī korpuss – tas ir neatņemams nosacījums, jo divi dažādi modeļi rada nesalīdzināmas telpas –, pēc tam argsort apgriež rangus otrādi, lai augstākie rezultāti nonāktu augšgalā.

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

Atbilstības slieksnis

Šim dzinējam ir trūkums, ko ražošanas vidē atklāsi ātri: tas vienmēr atgriež trīs rezultātus, pat ja jautājumam nav nekāda sakara ar korpusu. Pajautā par laika apstākļiem, un tas atgriezīs trīs vismazāk attālos dokumentus ar niecīgiem rezultātiem, bet šķietami normālu rangojumu. Praksē tāpēc ir jādefinē līdzības slieksnis, zem kura dokuments tiek uzskatīts par neatbilstošu:

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)

Velti laiku, lai kalibrētu šo slieksni, izmantojot aptuveni trīsdesmit reālus vaicājumus, pirms atver servisu lietotājiem. Ja iestatīsi to pārāk augstu, tavs dzinējs uz leģitīmiem jautājumiem atbildēs „es nezinu”. Ja iestatīsi pārāk zemu, tu barosi LLM ar kontekstu, kas nav par tēmu, radot tieši tās halucinācijas, kuru novēršanai RAG bija paredzēts.

Galvenās atziņas

  • Kosinusa līdzība ir standarta metrika iegulējumu salīdzināšanai
  • Ātriem aprēķiniem izmanto sklearn.metrics.pairwise.cosine_similarity
  • Līdzības matrica ļauj salīdzināt visus dokumentus savā starpā
  • Definē atbilstības slieksni, kas pielāgots tavam lietojumam (0,7 ir labs noklusējums)
  • Semantiskā meklēšana atrod rezultātus pēc nozīmes, nevis pēc precīzas vārdu sakritības