Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Semanttinen samankaltaisuus

Oppitunti 3 / 18 Päivitetty 2. marraskuuta 2026 Kehittäjä
Tällä sivulla
  1. Tekstin läheisyyden mittaaminen
  2. Euklidinen etäisyys
  3. Kosinussamankaltaisuus
  4. Samankaltaisuusmatriisi
  5. Yksinkertainen semanttinen haku
  6. Osuvuuskynnys
  7. Keskeiset asiat

Tekstin läheisyyden mittaaminen

Kun olet muuntanut tekstisi vektoreiksi mistral-embed-mallilla, voit kvantifioida, kuinka semanttisen lähellä kaksi tekstiä toisiaan ovat. Tämä on semanttisen haun ydin: merkitysten vertailua, ei pelkkien sanojen. Kun SQL-kysely LIKE '%lasku%' palauttaa yksinkertaisen kyllä tai ei -vastauksen, samankaltaisuusmittari antaa sinulle numeerisen arvon, jonka avulla tulokset voidaan järjestää. Juuri tämä järjestys tekee koko järjestelmästä arvokkaan.

Tässä oppitunnissa toteutat tärkeimmät samankaltaisuusmittarit ja näet, miten ne toimivat käytännössä konkreettisilla Python-esimerkeillä.

Euklidinen etäisyys

Euklidinen etäisyys mittaa vektoriavaruudessa olevan kahden pisteen välisen janan pituutta. Mitä pienempi etäisyys, sitä samankaltaisempia tekstit ovat. Alla oleva esimerkki vertaa kolmea lausetta: kaksi ensimmäistä sanovat saman asian eri sanastolla, kun taas kolmas käsittelee omenapiirakkaa. Lauseilla A ja B ei ole yhteisiä sanoja, mutta niiden välinen etäisyys on silti huomattavasti pienempi kuin A:n ja C:n välinen etäisyys.

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

Kosinussamankaltaisuus

Kosinussamankaltaisuus on upotuksissa käytetyin mittari. Se mittaa kahden vektorin välistä kulmaa niiden suuruudesta riippumatta. Tulos vaihtelee välillä -1–1, mikä tarjoaa heti ymmärrettävän asteikon: voit asettaa kynnyksen ja viestiä siitä liiketoimintatiimille joutumatta selittämään vektorinormeja.

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)

Ero arvojen 0,92 ja 0,35 välillä on hyödyllinen tieto: absoluuttinen arvo ei ole se, mikä ratkaisee, vaan marginaali, joka erottaa oleelliset tulokset aiheesta poikkeavista juuri sinun aineistossasi. Voit myös toteuttaa mittarin manuaalisesti, vaikka vain varmistaaksesi, mitä scikit-learn tekee, tai välttääksesi riippuvuuksia rajoitetussa ympäristössä:

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

Samankaltaisuusmatriisi

Vertaillaksesi useita dokumentteja keskenään voit rakentaa samankaltaisuusmatriisin. Alla oleva aineisto sekoittaa tarkoituksellisesti kahta teemaa – tekoälyä ja gastronomiaa – jotta rakenne hyppää silmille: dokumentit 0, 1 ja 3 liittyvät toisiinsa, kun taas dokumentit 2 ja 4 muodostavat erillisen klusterin. Tämä on täsmälleen se signaali, jota klusterointialgoritmit hyödyntävät.

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

Yksinkertainen semanttinen haku

Kaikki edellä mainittu yhdistyy pieneksi hakukoneeksi. Kysely koodataan samalla mallilla kuin aineistokin – tämä on ehdoton edellytys, sillä kaksi eri mallia tuottaa vertailukelvottomia avaruuksia – minkä jälkeen argsort kääntää järjestyksen niin, että korkeimmat pisteet nousevat kärkeen.

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

Osuvuuskynnys

Tässä moottorissa on vika, jonka huomaat nopeasti tuotantoympäristössä: se palauttaa aina kolme tulosta, vaikka kysymyksellä ei olisi mitään tekemistä aineiston kanssa. Kysy säätiedoista, ja se palauttaa kolme vähiten etäistä dokumenttia, olemattomin pistein mutta näennäisen normaalilla järjestyksellä. Käytännössä sinun on siis määriteltävä osuvuuskynnys, jonka alapuolella dokumentti katsotaan epäoleelliseksi:

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)

Käytä aikaa tämän kynnyksen kalibrointiin noin kolmellakymmenellä aidolla kyselyllä ennen kuin avaat palvelun käyttäjille. Jos asetat sen liian korkealle, moottorisi vastaa “en tiedä” myös legitiimeihin kysymyksiin. Jos asetat sen liian matalalle, syötät LLM:lle aiheeseen kuulumatonta kontekstia, mikä luo juuri niitä hallusinaatioita, jotka RAG:n piti estää.

Keskeiset asiat

  • Kosinussamankaltaisuus on standardimittari upotusten vertailuun
  • Käytä funktiota sklearn.metrics.pairwise.cosine_similarity nopeisiin laskelmiin
  • Samankaltaisuusmatriisin avulla voit verrata kaikkia dokumentteja toisiinsa
  • Määrittele käyttötapaustasi vastaava osuvuuskynnys (0,7 on hyvä oletusarvo)
  • Semanttinen haku löytää tulokset merkityksen, ei tarkan sanavastaavuuden perusteella