import numpy as np

class SkipGram:
    """Word2Vec Skip-gram: predict context from center word"""

    def __init__(self, vocab_size, embed_dim=50):
        # Two embedding matrices
        self.W_in = np.random.randn(vocab_size, embed_dim) * 0.01
        self.W_out = np.random.randn(embed_dim, vocab_size) * 0.01

    def forward(self, center_idx):
        """Get embedding for center word"""
        self.h = self.W_in[center_idx]  # (embed_dim,)
        scores = self.h @ self.W_out     # (vocab_size,)
        # Softmax
        exp_s = np.exp(scores - np.max(scores))
        self.probs = exp_s / exp_s.sum()
        return self.probs

    def train_pair(self, center_idx, context_idx, lr=0.01):
        """Train on one (center, context) pair"""
        probs = self.forward(center_idx)
        # Gradient
        grad = probs.copy()
        grad[context_idx] -= 1  # softmax - one_hot
        # Update
        self.W_out -= lr * np.outer(self.h, grad)
        self.W_in[center_idx] -= lr * (self.W_out @ grad)

# After training: W_in contains word embeddings!
# Famous result: king - man + woman ≈ queen

import numpy as np

def load_glove(filepath, vocab=None):
    """Load GloVe embeddings from text file"""
    embeddings = {}
    with open(filepath, 'r', encoding='utf-8') as f:
        for line in f:
            parts = line.strip().split()
            word = parts[0]
            if vocab and word not in vocab:
                continue
            vec = np.array(parts[1:], dtype=np.float64)
            embeddings[word] = vec
    return embeddings

# Usage: download glove.6B.50d.txt from nlp.stanford.edu
# glove = load_glove('glove.6B.50d.txt')
# print(glove['king'].shape)  # (50,)

def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

def find_analogy(embeddings, a, b, c):
    """a is to b as c is to ???"""
    target = embeddings[b] - embeddings[a] + embeddings[c]
    best_word, best_sim = None, -1
    for word, vec in embeddings.items():
        if word in {a, b, c}: continue
        sim = cosine_similarity(target, vec)
        if sim > best_sim:
            best_word, best_sim = word, sim
    return best_word

# find_analogy(glove, "man", "king", "woman")  → "queen"

import numpy as np
import re

class TextPipeline:
    """Complete text preprocessing pipeline"""

    def __init__(self, max_vocab=10000, max_len=50):
        self.max_vocab = max_vocab
        self.max_len = max_len
        self.word2idx = {"<PAD>": 0, "<UNK>": 1}
        self.idx2word = {0: "<PAD>", 1: "<UNK>"}

    def tokenize(self, text):
        text = text.lower().strip()
        text = re.sub(r'[^a-z0-9\s]', '', text)
        return text.split()

    def build_vocab(self, texts):
        word_counts = {}
        for text in texts:
            for word in self.tokenize(text):
                word_counts[word] = word_counts.get(word, 0) + 1
        top_words = sorted(word_counts, key=word_counts.get, reverse=True)
        for w in top_words[:self.max_vocab - 2]:
            idx = len(self.word2idx)
            self.word2idx[w] = idx
            self.idx2word[idx] = w

    def encode(self, text):
        tokens = self.tokenize(text)
        indices = [self.word2idx.get(t, 1) for t in tokens]
        # Pad or truncate
        if len(indices) < self.max_len:
            indices += [0] * (self.max_len - len(indices))
        return np.array(indices[:self.max_len])

    def encode_batch(self, texts):
        return np.array([self.encode(t) for t in texts])

# Usage
pipe = TextPipeline(max_vocab=5000, max_len=20)
texts = ["I love this movie", "Terrible film"]
pipe.build_vocab(texts)
encoded = pipe.encode_batch(texts)
print(encoded.shape)  # (2, 20)

import numpy as np

class EmbeddingLayer:
    def __init__(self, vocab_size, embed_dim, pretrained=None):
        if pretrained is not None:
            self.W = pretrained.copy()
        else:
            self.W = np.random.randn(vocab_size, embed_dim) * 0.01

    def forward(self, indices):
        """indices: (batch, seq_len) → (batch, seq_len, embed_dim)"""
        self.indices = indices
        return self.W[indices]

    def backward(self, d_out, lr=0.01):
        """Update embeddings for used words only"""
        np.add.at(self.W, self.indices, -lr * d_out)

# Full NLP model: TextPipeline → Embedding → LSTM → FC → Softmax