Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Similaridade Semântica

Aula 3 de 18 Atualizada a 2 de novembro de 2026 Programador
Nesta página
  1. Medir a Proximidade de Texto
  2. Distância Euclidiana
  3. Similaridade de Cosseno
  4. Matriz de Similaridade
  5. Pesquisa Semântica Simples
  6. Limiar de Relevância
  7. Pontos-chave

Medir a Proximidade de Texto

Assim que transformar os seus textos em vetores utilizando o mistral-embed, consegue quantificar o quão semanticamente próximos dois textos estão. Esta é a essência da pesquisa semântica: comparar significados, e não apenas palavras. Enquanto uma consulta SQL LIKE '%fatura%' devolve um simples sim ou não, uma métrica de similaridade fornece-lhe um número, permitindo a ordenação. É essa ordenação que torna todo o sistema valioso.

Nesta lição, vai implementar as principais métricas de similaridade e observar como funcionam na prática com exemplos concretos em Python.

Distância Euclidiana

A distância euclidiana mede o comprimento do segmento entre dois pontos no espaço vetorial. Quanto menor a distância, mais similares são os textos. O exemplo abaixo compara três frases: as duas primeiras dizem a mesma coisa usando vocabulário diferente, enquanto a terceira discute tarte de maçã. As frases A e B não partilham palavras comuns, contudo, a sua distância será significativamente menor do que a distância entre A e 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

Similaridade de Cosseno

A similaridade de cosseno é a métrica mais utilizada para embeddings. Mede o ângulo entre dois vetores, independentemente da sua magnitude. O resultado varia entre -1 e 1, fornecendo uma escala imediatamente legível: pode definir um limiar e comunicá-lo a uma equipa de negócios sem ter de explicar normas vetoriais.

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)

A diferença entre 0,92 e 0,35 é a informação útil: não é o valor absoluto que importa, mas a margem que separa os resultados relevantes dos temas fora de contexto no seu conjunto de dados específico. Pode também implementar a métrica manualmente, se não for para verificar o que o scikit-learn está a fazer ou para evitar dependências num ambiente restrito:

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

Matriz de Similaridade

Para comparar múltiplos documentos entre si, pode construir uma matriz de similaridade. O corpus abaixo mistura intencionalmente dois temas — IA e gastronomia — para que a estrutura salte à vista: os documentos 0, 1 e 3 relacionam-se entre si, enquanto os documentos 2 e 4 formam um cluster separado. Este é exatamente o sinal que os algoritmos de agrupamento (clustering) exploram.

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

Pesquisa Semântica Simples

Tudo o que foi apresentado acima combina-se num mini motor de pesquisa. A consulta é codificada com o mesmo modelo que o corpus — uma condição não negociável, já que dois modelos diferentes produzem espaços incomparáveis — e depois o argsort inverte a ordenação para trazer as pontuações mais altas para o topo.

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

Limiar de Relevância

Este motor tem uma falha que descobrirá rapidamente em produção: devolve sempre três resultados, mesmo quando a pergunta nada tem a ver com o corpus. Pergunte-lhe sobre o tempo atmosférico e ele devolverá os três documentos menos distantes, com pontuações irrisórias mas uma ordenação aparentemente normal. Na prática, deve portanto definir um limiar de similaridade abaixo do qual um documento é considerado irrelevante:

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)

Dedique tempo a calibrar este limiar com cerca de trinta consultas reais antes de abrir o serviço aos utilizadores. Se o definir demasiado alto, o seu motor dirá «não sei» a perguntas legítimas. Se o definir demasiado baixo, alimentará o LLM com contexto fora de tema, criando exatamente as alucinações que o RAG deveria prevenir.

Pontos-chave

  • A similaridade de cosseno é a métrica padrão para comparar embeddings
  • Utilize sklearn.metrics.pairwise.cosine_similarity para cálculos rápidos
  • Uma matriz de similaridade permite comparar todos os documentos entre si
  • Defina um limiar de relevância adaptado ao seu caso de uso (0,7 é um bom padrão)
  • A pesquisa semântica encontra resultados pelo significado, não por correspondência exata de palavras