# One-hot 编码
vocab = {"猫": 0, "狗": 1, "鱼": 2, "汽车": 3}
cat = [1, 0, 0, 0]
dog = [0, 1, 0, 0]
# 猫和狗的向量距离 = 猫和汽车的距离 = √2
# 这显然不合理——猫和狗应该更相似

# 分布式表示（2维示意）
cat = [0.8, 0.3]    # 动物维度高，宠物维度高
dog = [0.7, 0.5]    # 与猫相近
fish = [0.6, 0.1]   # 动物维度高，但宠物维度低
car = [0.1, 0.9]    # 动物维度低，机械维度高
# 猫和狗的距离 < 猫和汽车的距离 ✓

import numpy as np
from collections import defaultdict

def build_cooccurrence_matrix(corpus, window_size=2):
    vocab = sorted(set(word for sentence in corpus for word in sentence))
    word_to_idx = {word: i for i, word in enumerate(vocab)}
    vocab_size = len(vocab)
    matrix = np.zeros((vocab_size, vocab_size))

    for sentence in corpus:
        for i, word in enumerate(sentence):
            for j in range(max(0, i - window_size), min(len(sentence), i + window_size + 1)):
                if i != j:
                    context_word = sentence[j]
                    matrix[word_to_idx[word]][word_to_idx[context_word]] += 1

    return matrix, vocab

# 示例
corpus = [
    ["I", "love", "natural", "language", "processing"],
    ["I", "love", "deep", "learning"],
    ["natural", "language", "is", "fascinating"],
    ["deep", "learning", "is", "powerful"],
]

matrix, vocab = build_cooccurrence_matrix(corpus, window_size=2)
print(f"Vocabulary: {vocab}")
print(f"Matrix shape: {matrix.shape}")

def compute_ppmi(cooccurrence_matrix):
    total = cooccurrence_matrix.sum()
    row_sums = cooccurrence_matrix.sum(axis=1, keepdims=True)
    col_sums = cooccurrence_matrix.sum(axis=0, keepdims=True)

    p_w = row_sums / total
    p_c = col_sums / total
    p_wc = cooccurrence_matrix / total

    pmi = np.log2(p_wc / (p_w * p_c + 1e-10) + 1e-10)
    ppmi = np.maximum(0, pmi)
    return ppmi

from sklearn.decomposition import TruncatedSVD

# 对 PPMI 矩阵进行 SVD 降维
svd = TruncatedSVD(n_components=50, random_state=42)
word_vectors = svd.fit_transform(ppmi_matrix)
print(f"降维后词向量维度: {word_vectors.shape}")

# 计算词相似度
from sklearn.metrics.pairwise import cosine_similarity

def most_similar(word, vocab, vectors, topk=5):
    idx = vocab.index(word)
    sims = cosine_similarity([vectors[idx]], vectors)[0]
    top_indices = sims.argsort()[-topk-1:][::-1]
    return [(vocab[i], sims[i]) for i in top_indices if vocab[i] != word]

print(most_similar("love", vocab, word_vectors))

import numpy as np

class SkipGram:
    def __init__(self, vocab_size, embedding_dim, lr=0.025):
        self.vocab_size = vocab_size
        self.embedding_dim = embedding_dim
        self.lr = lr
        # 初始化词向量
        self.W_in = np.random.randn(vocab_size, embedding_dim) * 0.01
        self.W_out = np.random.randn(vocab_size, embedding_dim) * 0.01

    def sigmoid(self, x):
        return 1 / (1 + np.exp(-np.clip(x, -6, 6)))

    def train_step(self, center_word, context_word, negative_samples):
        # 正样本梯度
        h = self.W_in[center_word]
        target = self.W_out[context_word]
        pred = self.sigmoid(np.dot(target, h))
        grad = (1 - pred) * h

        # 更新
        self.W_out[context_word] += self.lr * (1 - pred) * h
        self.W_in[center_word] += self.lr * (1 - pred) * target

        # 负样本
        for neg in negative_samples:
            target_neg = self.W_out[neg]
            pred_neg = self.sigmoid(np.dot(target_neg, h))
            self.W_out[neg] -= self.lr * pred_neg * h
            self.W_in[center_word] -= self.lr * pred_neg * target_neg

    def get_word_vector(self, word_idx):
        return self.W_in[word_idx]

def word_analogy(a, b, c, vocab, vectors):
    """a : b :: c : ?"""
    idx_a = vocab.index(a)
    idx_b = vocab.index(b)
    idx_c = vocab.index(c)

    target = vectors[idx_b] - vectors[idx_a] + vectors[idx_c]

    best_word = None
    best_sim = -1
    for i, word in enumerate(vocab):
        if word in [a, b, c]:
            continue
        sim = np.dot(target, vectors[i]) / (np.linalg.norm(target) * np.linalg.norm(vectors[i]))
        if sim > best_sim:
            best_sim = sim
            best_word = word

    return best_word, best_sim

from gensim.models import Word2Vec
from gensim.test.utils import common_texts

# 训练 Word2Vec 模型
model = Word2Vec(sentences=common_texts, vector_size=100, window=5,
                 min_count=1, workers=4, sg=1)  # sg=1 使用 Skip-gram

# 查看词向量
print(model.wv["computer"])

# 最相似的词
print(model.wv.most_similar("computer", topn=5))

# 词类比
print(model.wv.most_similar(positive=["woman", "king"], negative=["man"], topn=3))

# 词相似度
print(model.wv.similarity("computer", "human"))

from gensim.models import KeyedVectors
import numpy as np

# 加载预训练词向量（示例使用小模型）
# 实际使用时可下载大规模预训练向量
# wget https://dl.fbaipublicfiles.com/fasttext/vectors-crawl/cc.zh.300.vec.gz

def load_word_vectors(filepath, max_words=50000):
    vectors = {}
    with open(filepath, "r", encoding="utf-8") as f:
        for i, line in enumerate(f):
            if i >= max_words:
                break
            values = line.strip().split()
            word = values[0]
            vector = np.array(values[1:], dtype=float)
            vectors[word] = vector
    return vectors

# 计算文本相似度
def text_similarity(text1, text2, word_vectors):
    words1 = [w for w in text1 if w in word_vectors]
    words2 = [w for w in text2 if w in word_vectors]

    if not words1 or not words2:
        return 0.0

    vec1 = np.mean([word_vectors[w] for w in words1], axis=0)
    vec2 = np.mean([word_vectors[w] for w in words2], axis=0)

    return np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))

from sklearn.decomposition import PCA
import matplotlib.pyplot as plt

def visualize_words(words, word_vectors, title="Word Vectors (PCA)"):
    indices = [list(word_vectors.keys()).index(w) for w in words if w in word_vectors]
    vectors = np.array([list(word_vectors.values())[i] for i in indices])

    pca = PCA(n_components=2)
    reduced = pca.fit_transform(vectors)

    plt.figure(figsize=(10, 8))
    for i, word in enumerate(words):
        if word in word_vectors:
            plt.scatter(reduced[i, 0], reduced[i, 1])
            plt.annotate(word, (reduced[i, 0], reduced[i, 1]), fontsize=12)

    plt.title(title)
    plt.xlabel("PC1")
    plt.ylabel("PC2")
    plt.grid(True, alpha=0.3)
    plt.show()

# 可视化语义关系
words = ["猫", "狗", "鱼", "鸟", "汽车", "火车", "飞机", "轮船"]
# visualize_words(words, word_vectors)