Semantics

def word_overlap(sent1, sent2):
    """Calculate similarity by counting shared words."""
    words1 = set(sent1.lower().split())
    words2 = set(sent2.lower().split())
    overlap = len(words1 & words2)
    total = len(words1 | words2)
    return overlap / total if total > 0 else 0

s1 = "The cat sat on the mat"
s2 = "A feline rested on the rug"
print(f"Word overlap similarity: {word_overlap(s1, s2):.2f}")

import numpy as np
import matplotlib.pyplot as plt

# Toy embeddings for animal words (2D for visualization)
embeddings = {
    'cat': np.array([0.8, 0.9]),
    'dog': np.array([0.9, 0.8]),
    'kitten': np.array([0.75, 0.95]),
    'puppy': np.array([0.95, 0.75]),
    'car': np.array([0.1, 0.1]),
    'vehicle': np.array([0.15, 0.05])
}

# Visualize
plt.figure(figsize=(8, 8))
for word, vec in embeddings.items():
    plt.scatter(vec[0], vec[1], s=100)
    plt.annotate(word, vec, fontsize=12)
plt.xlabel('Dimension 1')
plt.ylabel('Dimension 2')
plt.title('Toy Word Embeddings in 2D Space')
plt.grid(True, alpha=0.3)
plt.show()

def cosine_similarity(a, b):
    """Calculate cosine similarity between two vectors."""
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

# Compare similarities
cat_dog = cosine_similarity(embeddings['cat'], embeddings['dog'])
cat_kitten = cosine_similarity(embeddings['cat'], embeddings['kitten'])
cat_car = cosine_similarity(embeddings['cat'], embeddings['car'])

print(f"cat-dog similarity: {cat_dog:.3f}")
print(f"cat-kitten similarity: {cat_kitten:.3f}")
print(f"cat-car similarity: {cat_car:.3f}")

# Simplified skip-gram training concept
def generate_training_pairs(text, window_size=2):
    """Generate (center_word, context_word) pairs."""
    words = text.split()
    pairs = []
    
    for i, center in enumerate(words):
        # Get context words within window
        start = max(0, i - window_size)
        end = min(len(words), i + window_size + 1)
        
        for j in range(start, end):
            if i != j:  # Don't pair word with itself
                pairs.append((center, words[j]))
    
    return pairs

text = "the quick brown fox jumps over the lazy dog"
pairs = generate_training_pairs(text, window_size=2)
print(f"Training pairs: {pairs[:10]}")

import ollama
import numpy as np

def get_embedding(word):
    """Get embedding vector for a word using Ollama."""
    response = ollama.embeddings(model='nomic-embed-text', prompt=word)
    return np.array(response['embedding'])

def cosine_similarity(a, b):
    """Calculate cosine similarity between vectors."""
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

def analogy(a, b, c, candidate_words):
    """Solve analogy: a is to b as c is to ?
    
    Args:
        a, b, c: The analogy words (e.g., 'king', 'man', 'woman')
        candidate_words: List of potential answer words to search
    """
    print(f"Computing: {a} - {b} + {c} = ?")
    
    # Get embeddings
    emb_a = get_embedding(a)
    emb_b = get_embedding(b)
    emb_c = get_embedding(c)
    
    # Perform vector arithmetic: king - man + woman
    result_vec = emb_a - emb_b + emb_c
    
    # Find closest word among candidates
    best_word = None
    best_sim = -1
    
    print("\nCandidate similarities:")
    for word in candidate_words:
        if word.lower() in [a.lower(), b.lower(), c.lower()]:
            continue
            
        word_emb = get_embedding(word)
        sim = cosine_similarity(result_vec, word_emb)
        print(f"  {word}: {sim:.4f}")
        
        if sim > best_sim:
            best_sim = sim
            best_word = word
    
    return best_word, best_sim

# Test the classic example
candidates = ['queen', 'prince', 'princess', 'duke', 'duchess', 
              'lord', 'lady', 'emperor', 'empress']

answer, similarity = analogy('king', 'man', 'woman', candidates)
print(f"\n Best answer: {answer} (similarity: {similarity:.4f})")

import ollama
import numpy as np

def cosine_similarity(a, b):
    """Calculate cosine similarity between vectors."""
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

def get_word_embedding(word):
    """Get embedding for a single word using Ollama."""
    response = ollama.embeddings(model='nomic-embed-text', prompt=word)
    return np.array(response['embedding'])

def sentence_embedding_average(sentence):
    """Create sentence embedding by averaging word vectors."""
    words = sentence.lower().split()
    vectors = []
    
    print(f"Getting embeddings for: {words}")
    for word in words:
        vec = get_word_embedding(word)
        vectors.append(vec)
    
    if not vectors:
        return np.zeros(768)  # nomic-embed-text uses 768 dimensions
    
    return np.mean(vectors, axis=0)

# Example usage
sent1 = "The cat sat on the mat"
sent2 = "A feline rested on the rug"
sent3 = "Python is a programming language"

print("Computing sentence embeddings by averaging word vectors...\n")

emb1 = sentence_embedding_average(sent1)
emb2 = sentence_embedding_average(sent2)
emb3 = sentence_embedding_average(sent3)

# Calculate similarities
sim_1_2 = cosine_similarity(emb1, emb2)
sim_1_3 = cosine_similarity(emb1, emb3)
sim_2_3 = cosine_similarity(emb2, emb3)

print(f"\n Results:")
print(f"'{sent1}' vs '{sent2}': {sim_1_2:.3f}")
print(f"'{sent1}' vs '{sent3}': {sim_1_3:.3f}")
print(f"'{sent2}' vs '{sent3}': {sim_2_3:.3f}")

def get_sentence_embedding(sentence):
    """Get embedding for entire sentence using Ollama."""
    response = ollama.embeddings(model='nomic-embed-text', prompt=sentence)
    return np.array(response['embedding'])

print("\n" + "="*60)
print("Now using PROPER sentence embeddings (context-aware):\n")

# Get proper sentence embeddings
sent_emb1 = get_sentence_embedding(sent1)
sent_emb2 = get_sentence_embedding(sent2)
sent_emb3 = get_sentence_embedding(sent3)

# Calculate similarities
proper_sim_1_2 = cosine_similarity(sent_emb1, sent_emb2)
proper_sim_1_3 = cosine_similarity(sent_emb1, sent_emb3)

print(f" Results with proper embeddings:")
print(f"'{sent1}' vs '{sent2}': {proper_sim_1_2:.3f}")
print(f"'{sent1}' vs '{sent3}': {proper_sim_1_3:.3f}")

# Calculate discrimination: how well does each approach separate similar from different?
avg_discrimination = sim_1_2 - sim_1_3  # similar - different
proper_discrimination = proper_sim_1_2 - proper_sim_1_3

print("\n Discrimination Analysis (Similar - Different):")
print(f"Higher scores = better at distinguishing similar from different\n")
print(f"Averaged words approach:")
print(f"  Similar: {sim_1_2:.3f} | Different: {sim_1_3:.3f}")
print(f"  Discrimination: {avg_discrimination:.3f}")

print(f"\nProper embeddings approach:")
print(f"  Similar: {proper_sim_1_2:.3f} | Different: {proper_sim_1_3:.3f}")
print(f"  Discrimination: {proper_discrimination:.3f}")

print(f"\n Winner: {'Proper embeddings' if proper_discrimination > avg_discrimination else 'Averaged words'}")
print(f"   Improvement: {abs(proper_discrimination - avg_discrimination):.3f}")
print(f"   ({abs((proper_discrimination - avg_discrimination) / avg_discrimination * 100):.1f}% better)")

import ollama
import numpy as np

def get_embedding(text):
    """Get embedding using Ollama."""
    response = ollama.embeddings(model='nomic-embed-text', prompt=text)
    return np.array(response['embedding'])

def semantic_search(query, documents):
    """Find most relevant documents using embeddings."""
    print(f"🔍 Searching for: '{query}'\n")
    
    # Get query embedding
    query_emb = get_embedding(query)
    
    # Get document embeddings
    doc_embs = [get_embedding(doc) for doc in documents]
    
    # Calculate similarities
    similarities = [cosine_similarity(query_emb, doc_emb) for doc_emb in doc_embs]
    
    # Return documents sorted by relevance
    ranked = sorted(zip(documents, similarities), 
                   key=lambda x: x[1], reverse=True)
    return ranked

# Example documents
docs = [
    "Machine learning is a subset of AI",
    "Python is great for data science",
    "The weather today is sunny",
    "Neural networks learn from data"
]

# Search with different queries
queries = [
    "artificial intelligence and algorithms",
    "programming languages for statistics",
    "how's the climate outside?"
]

for query in queries:
    results = semantic_search(query, docs)
    
    print("📊 Results:")
    for doc, score in results:
        # Add visual indicator
        bar = "█" * int(score * 20)
        print(f"{score:.3f} {bar:20s} {doc}")
    print("\n" + "="*70 + "\n")

import ollama
import numpy as np
from sklearn.cluster import KMeans

def get_embedding(text):
    """Get embedding using Ollama."""
    response = ollama.embeddings(model='nomic-embed-text', prompt=text)
    return np.array(response['embedding'])

# Collection of documents
documents = [
    "Machine learning is a subset of AI",
    "Python is great for data science",
    "The weather today is sunny",
    "Neural networks learn from data",
    "JavaScript is used for web development",
    "It's raining cats and dogs outside",
    "Deep learning uses multi-layer neural networks",
    "Ruby on Rails is a web framework",
    "The temperature dropped to freezing",
    "AI systems can recognize patterns in data"
]

print(" Embedding documents...")
# Embed all documents
docs_emb = np.array([get_embedding(doc) for doc in documents])
print(f" Created embeddings: {docs_emb.shape}\n")

# Cluster into k groups
n_clusters = 3
kmeans = KMeans(n_clusters=n_clusters, random_state=42)
clusters = kmeans.fit_predict(docs_emb)

print(f" Document clusters (k={n_clusters}): {clusters}\n")

# Display documents by cluster
print("="*70)
for cluster_id in range(n_clusters):
    print(f"\n Cluster {cluster_id}:")
    cluster_docs = [doc for doc, c in zip(documents, clusters) if c == cluster_id]
    for doc in cluster_docs:
        print(f"   • {doc}")

# Calculate cluster cohesion
print("\n" + "="*70)
print("\n Cluster Analysis:")

def cosine_similarity(a, b):
    """Calculate cosine similarity between vectors."""
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

for cluster_id in range(n_clusters):
    cluster_indices = [i for i, c in enumerate(clusters) if c == cluster_id]
    cluster_vectors = docs_emb[cluster_indices]
    
    # Calculate average intra-cluster similarity
    if len(cluster_vectors) > 1:
        similarities = []
        for i in range(len(cluster_vectors)):
            for j in range(i+1, len(cluster_vectors)):
                sim = cosine_similarity(cluster_vectors[i], cluster_vectors[j])
                similarities.append(sim)
        
        avg_similarity = np.mean(similarities)
        print(f"\nCluster {cluster_id} ({len(cluster_indices)} docs):")
        print(f"  Average intra-cluster similarity: {avg_similarity:.3f}")
        print(f"  Cohesion: {'High' if avg_similarity > 0.6 else 'Medium' if avg_similarity > 0.4 else 'Low'}")