Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Sličnost značenja

Lekcija 3 od 18 Ažurirano 2. studenoga 2026. Programer
Na ovoj stranici
  1. Mjerenje bliskosti teksta
  2. Euklidska udaljenost
  3. Kosinusna sličnost
  4. Matrica sličnosti
  5. Jednostavno semantičko pretraživanje
  6. Prag relevantnosti
  7. Ključne točke

Mjerenje bliskosti teksta

Kada pretvoriš svoje tekstove u vektore pomoću mistral-embed, možeš kvantificirati koliko su dva teksta semantički bliska. To je srž semantičkog pretraživanja: usporedba značenja, a ne samo riječi. Dok SQL upit LIKE '%invoice%' vraća jednostavno da ili ne, metrika sličnosti daje ti broj koji omogućuje rangiranje. Upravo to rangiranje čini cijeli sustav vrijednim.

U ovoj lekciji implementirat ćeš glavne metrike sličnosti i vidjeti kako funkcioniraju u praksi na konkretnim primjerima u Pythonu.

Euklidska udaljenost

Euklidska udaljenost mjeri duljinu segmenta između dviju točaka u vektorskom prostoru. Što je udaljenost manja, to su tekstovi sličniji. Primjer u nastavku uspoređuje tri rečenice: prve dvije govore istu stvar koristeći drugačiji rječnik, dok treća raspravlja o piti od jabuka. Rečenice A i B nemaju zajedničkih riječi, no njihova će udaljenost biti znatno manja od udaljenosti između 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

Kosinusna sličnost

Kosinusna sličnost najčešće korištena je metrika za embedinge. Mjeri kut između dva vektora, neovisno o njihovoj veličini. Rezultat se kreće od -1 do 1, pružajući lako čitljivu ljestvicu: možeš postaviti prag i priopćiti ga poslovnom timu bez potrebe da objašnjavaš norme vektora.

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)

Razlika između 0,92 i 0,35 ključna je informacija: nije bitna apsolutna vrijednost, već margina koja u tvom specifičnom skupu podataka odvaja relevantne rezultate od onih izvan teme. Metriku možeš implementirati i ručno, barem da provjeriš što scikit-learn radi ili da izbjegneš ovisnosti u ograničenom okruženju:

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

Matrica sličnosti

Za usporedbu više dokumenata međusobno možeš izgraditi matricu sličnosti. Korpus u nastavku namjerno miješa dvije teme – umjetnu inteligenciju i gastronomiju – pa ti struktura odmah skoči u oči: dokumenti 0, 1 i 3 međusobno su povezani, dok dokumenti 2 i 4 čine zaseban klaster. To je upravo signal koji algoritmi grupiranja iskorištavaju.

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

Jednostavno semantičko pretraživanje

Sve navedeno spaja se u mini tražilicu. Upit se kodira istim modelom kao i korpus – to je neupitan uvjet jer dva različita modela proizvode neusporedive prostore – zatim argsort obrće rangiranje kako bi najviši rezultati došli na vrh.

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

Prag relevantnosti

Ovaj motor ima manu koju ćeš u proizvodnji brzo otkriti: uvijek vraća tri rezultata, čak i kada pitanje nema veze s korpusom. Pitaš li ga za vremensku prognozu, vratit će tri najmanje udaljena dokumenta, s mizernim rezultatima, ali prividno normalnim rangiranjem. U praksi stoga moraš definirati prag sličnosti ispod kojeg se dokument smatra nebitnim:

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)

Odvoji vrijeme za kalibraciju ovog praga na tridesetak stvarnih upita prije nego što servis otvoriš korisnicima. Postaviš li ga previsoko, tvoj će motor na legitimna pitanja odgovoriti s „ne znam“. Postaviš li ga prenisko, LLM-u ćeš dostaviti kontekst izvan teme i stvoriti upravo one halucinacije koje je RAG trebao spriječiti.

Ključne točke

  • Kosinusna sličnost standardna je metrika za usporedbu embeddinga
  • Za brze izračune koristi sklearn.metrics.pairwise.cosine_similarity
  • Matrica sličnosti omogućuje usporedbu svih dokumenata međusobno
  • Definiraj prag relevantnosti prilagođen svom slučaju upotrebe (0,7 dobra je zadana vrijednost)
  • Semantičko pretraživanje pronalazi rezultate po značenju, a ne točnim podudaranjem riječi