Embedding Models and Semantic Search — From Text to Vector Representations

import numpy as np
from typing import List, Dict

class EmbeddingBenchmark:
    def __init__(self):
        self.test_pairs = [
            ("The cat sat on the mat", "A feline rested on the rug"),
            ("Python is a programming language",
             "Python is a type of snake"),
            ("Machine learning is fascinating",
             "I enjoy studying artificial intelligence"),
            ("The stock market crashed today",
             "Markets fell sharply in afternoon trading"),
        ]

    def cosine_similarity(self, a: List[float], b: List[float]) -> float:
        a, b = np.array(a), np.array(b)
        return float(np.dot(a, b) / (
            np.linalg.norm(a) * np.linalg.norm(b)
        ))

    def evaluate_model(
        self, embed_func, model_name: str
    ) -> Dict:
        scores = []
        for text1, text2 in self.test_pairs:
            emb1 = embed_func(text1)
            emb2 = embed_func(text2)
            score = self.cosine_similarity(emb1, emb2)
            scores.append(score)

        return {
            "model": model_name,
            "avg_similarity": round(np.mean(scores), 4),
            "min_similarity": round(min(scores), 4),
            "max_similarity": round(max(scores), 4),
            "scores": [round(s, 4) for s in scores]
        }

# Simulate different embedding models
def mock_openai(text: str) -> List[float]:
    np.random.seed(hash(text) % 2**31)
    return np.random.randn(1536).tolist()

def mock_sbert(text: str) -> List[float]:
    np.random.seed(hash(text) % 2**31)
    return np.random.randn(384).tolist()

benchmark = EmbeddingBenchmark()
# Results comparison
models = [
    ("OpenAI text-embedding-3-small", mock_openai),
    ("Sentence-Transformers all-MiniLM-L6-v2", mock_sbert),
]

for name, func in models:
    result = benchmark.evaluate_model(func, name)
    print(f"{name}:")
    print(f"  Avg similarity: {result['avg_similarity']}")
    print(f"  Dimension: {len(func('test'))}")

from sentence_transformers import SentenceTransformer

# Load a lightweight model (384-dim embeddings)
model = SentenceTransformer(
    "all-MiniLM-L6-v2"
)

# Encode sentences
sentences = [
    "The weather is beautiful today",
    "It is sunny and warm outside",
    "I need to buy groceries for dinner",
    "The stock market had a volatile session",
]

embeddings = model.encode(sentences)
print(f"Embedding shape: {embeddings.shape}")
print(f"Embedding dtype: {embeddings.dtype}")
print(f"First 5 values: {embeddings[0][:5]}")

# Compute similarity matrix
similarities = model.similarity(embeddings, embeddings)
print(f"\nSimilarity matrix ({similarities.shape}):")
for i in range(len(sentences)):
    for j in range(i+1, len(sentences)):
        sim = similarities[i][j].item()
        print(f"  [{i}] vs [{j}]: {sim:.4f}")

import faiss
import numpy as np
from sentence_transformers import SentenceTransformer

class SemanticSearch:
    def __init__(self, model_name: str = "all-MiniLM-L6-v2"):
        self.model = SentenceTransformer(model_name)
        self.dimension = self.model.get_sentence_embedding_dimension()
        self.index = faiss.IndexFlatL2(self.dimension)
        self.documents = []

    def add_documents(self, docs: List[str]):
        embeddings = self.model.encode(
            docs, show_progress_bar=True
        )
        self.index.add(embeddings.astype(np.float32))
        self.documents.extend(docs)
        print(f"Indexed {len(docs)} documents. "
              f"Total: {len(self.documents)}")

    def search(self, query: str, k: int = 3) -> List[Dict]:
        query_embedding = self.model.encode([query])
        distances, indices = self.index.search(
            query_embedding.astype(np.float32), k
        )

        results = []
        for dist, idx in zip(distances[0], indices[0]):
            if idx < len(self.documents):
                results.append({
                    "document": self.documents[idx],
                    "score": float(1 / (1 + dist)),
                    "distance": float(dist)
                })
        return results

# Build search index
search_engine = SemanticSearch()
docs = [
    "Python is a high-level programming language.",
    "JavaScript runs in web browsers for interactive pages.",
    "Machine Learning models learn patterns from data.",
    "Vector databases store embeddings for similarity search.",
    "RAG combines retrieval with LLMs for accurate answers.",
    "FAISS is a library for efficient similarity search.",
]
search_engine.add_documents(docs)

# Search
query = "How do I find similar vectors?"
results = search_engine.search(query, k=3)
print(f"\nQuery: {query}")
for R in results:
    print(f"  Score: {R['score']:.4f} | {R['document']}")

from OpenAI import OpenAI
import numpy as np

client = OpenAI()

def get_OpenAI_embedding(
    text: str, model: str = "text-embedding-3-small"
) -> List[float]:
    response = client.embeddings.create(
        model=model,
        input=text
    )
    return response.data[0].embedding

# Compare two texts
texts = [
    "The new AI model achieves State-of-the-art results",
    "This neural network outperforms all previous approaches",
    "I need to buy milk and eggs from the store",
]

embeddings = [get_OpenAI_embedding(t) for t in texts]

# Dimension reduction option
small_embedding = get_OpenAI_embedding(
    "test", "text-embedding-3-small"
)
full_dim = len(small_embedding)
# Can request smaller dimensions via dimensions param
small_256 = client.embeddings.create(
    model="text-embedding-3-small",
    input="test",
    dimensions=256
).data[0].embedding

print(f"Full dimension: {full_dim}")
print(f"Reduced dimension: {len(small_256)}")

cos_sim = lambda a, b: np.dot(a, b) / (
    np.linalg.norm(a) * np.linalg.norm(b)
)
print(f"\nSimilarity AI-related texts: "
      f"{cos_sim(embeddings[0], embeddings[1]):.4f}")
print(f"Similarity unrelated texts: "
      f"{cos_sim(embeddings[0], embeddings[2]):.4f}")