20_GloVe词嵌入：全局词频矩阵的高效表示

J = \sum_{i,j=1}^{V} f(X_{ij}) (w_i^T \tilde{w}_j + b_i + \tilde{b}_j - log X_{ij})^2

f(x) = \begin{cases} (x/x_{max})^{\alpha} & \text{if } x < x_{max} \\ 1 & \text{otherwise} \end{cases}

w_i^T \tilde{w}_j + b_i + \tilde{b}_j = log P_{ij}

w_i^T \tilde{w}_k - w_j^T \tilde{w}_k = log(P_{ik}/P_{jk})

(w_i - w_j)^T \tilde{w}_k = log P_{ik} - log P_{jk}

J = \sum_{i,j=1}^{V} f(X_{ij}) (w_i^T \tilde{w}_j + b_i + \tilde{b}_j - log X_{ij})^2

w_i^{final} = (w_i + \tilde{w}_i) / 2

import numpy as np
import matplotlib.pyplot as plt
from sklearn.manifold import TSNE
from gensim.models import KeyedVectors
from gensim.scripts.glove2word2vec import glove2word2vec
import os

# 示例文本数据（实际应用中会使用更大的语料库）
sample_text = """
词嵌入技术是自然语言处理领域的重要技术。
Word2Vec和GloVe是两种主要的词嵌入方法。
Word2Vec通过局部上下文学习词向量，而GloVe利用全局统计信息。
GloVe构建词-词共现矩阵，并通过最小化平方损失函数来学习向量表示。
词嵌入向量能够捕捉词语之间的语义关系，使得语义相似的词在向量空间中距离更近。
在实际应用中，我们可以根据任务需求选择合适的词嵌入方法。
"""

# 保存示例文本到文件
with open('sample_text.txt', 'w', encoding='utf-8') as f:
    f.write(sample_text)

# 注意：这里我们使用预训练的GloVe模型作为示例
# 实际应用中，您可能需要使用glove-python库或其他工具训练自己的GloVe模型

# 下载预训练的GloVe模型（这里仅作为示例，实际使用时需要下载）
# 可以从GloVe官方网站下载预训练模型：https://nlp.stanford.edu/projects/glove/

# 假设我们已经有了预训练的GloVe模型文件 'glove.6B.100d.txt'
# 如果文件不存在，我们将创建一个模拟的GloVe模型文件作为示例
if not os.path.exists('glove_sample.100d.txt'):
    print("创建示例GloVe模型文件...")
    # 创建一个简单的词汇表
    words = ["词嵌入", "自然语言", "处理", "Word2Vec", "GloVe", "语义", "向量", "共现", "矩阵", "训练"]
    with open('glove_sample.100d.txt', 'w', encoding='utf-8') as f:
        for word in words:
            # 生成随机向量作为示例
            vector = ' '.join([str(np.random.uniform(-0.5, 0.5)) for _ in range(100)])
            f.write(f"{word} {vector}\n")
    print("示例GloVe模型文件创建完成。")

# 将GloVe格式转换为Word2Vec格式
glove_input_file = 'glove_sample.100d.txt'
word2vec_output_file = 'glove_sample.100d.word2vec'
glove2word2vec(glove_input_file, word2vec_output_file)

# 加载转换后的模型
model = KeyedVectors.load_word2vec_format(word2vec_output_file, binary=False)

# 查找相似词
def find_similar_words(model, word, top_n=5):
    try:
        similar_words = model.most_similar(word, topn=top_n)
        return similar_words
    except KeyError:
        return f"词 '{word}' 不在词汇表中"

# 可视化词向量
def visualize_word_embeddings(model, top_n=10):
    words = list(model.key_to_index.keys())[:top_n]
    vectors = np.array([model[word] for word in words])
    
    # 使用t-SNE降维
    tsne = TSNE(n_components=2, random_state=42)
    vectors_tsne = tsne.fit_transform(vectors)
    
    # 绘制散点图
    plt.figure(figsize=(10, 8))
    for i, word in enumerate(words):
        plt.scatter(vectors_tsne[i, 0], vectors_tsne[i, 1])
        plt.annotate(word, xy=(vectors_tsne[i, 0], vectors_tsne[i, 1]),
                     xytext=(5, 2), textcoords='offset points')
    
    plt.title('GloVe Word Embeddings Visualization')
    plt.grid(True)
    plt.show()

# 查找相似词示例
for word in ["词嵌入", "GloVe", "语义"]:
    print(f"\n与 '{word}' 相似的词：")
    similar_words = find_similar_words(model, word)
    if isinstance(similar_words, list):
        for w, similarity in similar_words:
            print(f"{w}: {similarity:.4f}")
    else:
        print(similar_words)

# 可视化词向量
visualize_word_embeddings(model)

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from collections import defaultdict, Counter
import matplotlib.pyplot as plt
from sklearn.manifold import TSNE

# 设置随机种子
def set_seed(seed=42):
    np.random.seed(seed)
    torch.manual_seed(seed)
    if torch.cuda.is_available():
        torch.cuda.manual_seed_all(seed)

# 预处理文本
def preprocess_text(text):
    """预处理文本，分词并构建词汇表"""
    # 简单分词（实际应用中可能需要使用更复杂的分词方法）
    words = text.lower().split()
    
    # 构建词汇表
    word_counts = Counter(words)
    word_to_idx = {word: i for i, (word, _) in enumerate(word_counts.most_common())}
    idx_to_word = {i: word for word, i in word_to_idx.items()}
    
    return words, word_to_idx, idx_to_word

# 构建共现矩阵
def build_cooccurrence_matrix(words, word_to_idx, window_size=2):
    """构建词-词共现矩阵"""
    vocab_size = len(word_to_idx)
    cooccurrence_matrix = defaultdict(float)
    
    # 扫描文本，构建共现矩阵
    for i, word in enumerate(words):
        center_idx = word_to_idx[word]
        
        # 上下文窗口
        start = max(0, i - window_size)
        end = min(len(words), i + window_size + 1)
        
        # 计算中心词与上下文词的共现次数
        for j in range(start, end):
            if i != j:
                context_idx = word_to_idx[words[j]]
                # 距离衰减权重
                distance = abs(i - j)
                weight = 1.0 / distance
                
                # 更新共现矩阵（使用元组作为键，避免重复）
                pair = tuple(sorted((center_idx, context_idx)))
                cooccurrence_matrix[pair] += weight
    
    return cooccurrence_matrix

# 定义GloVe模型
class GloVeModel(nn.Module):
    def __init__(self, vocab_size, embedding_dim):
        super(GloVeModel, self).__init__()
        # 中心词嵌入
        self.center_embeddings = nn.Embedding(vocab_size, embedding_dim)
        # 上下文词嵌入
        self.context_embeddings = nn.Embedding(vocab_size, embedding_dim)
        # 中心词偏置
        self.center_biases = nn.Embedding(vocab_size, 1)
        # 上下文词偏置
        self.context_biases = nn.Embedding(vocab_size, 1)
        
        # 初始化权重
        nn.init.xavier_uniform_(self.center_embeddings.weight)
        nn.init.xavier_uniform_(self.context_embeddings.weight)
        nn.init.zeros_(self.center_biases.weight)
        nn.init.zeros_(self.context_biases.weight)
    
    def forward(self, center_indices, context_indices, cooccurrence_counts):
        # 获取嵌入向量和偏置
        center_embed = self.center_embeddings(center_indices)
        context_embed = self.context_embeddings(context_indices)
        center_bias = self.center_biases(center_indices).squeeze(1)
        context_bias = self.context_biases(context_indices).squeeze(1)
        
        # 计算点积加上偏置
        dot_product = torch.sum(center_embed * context_embed, dim=1)
        prediction = dot_product + center_bias + context_bias
        
        # 计算权重函数
        weights = torch.pow(cooccurrence_counts, 0.75)
        weights = torch.min(weights, torch.ones_like(weights) * 100)  # 限制最大值为100
        
        # 计算加权平方损失
        loss = torch.mean(weights * torch.pow(prediction - torch.log(cooccurrence_counts + 1), 2))
        
        return loss
    
    def get_embeddings(self):
        """获取最终的词嵌入（中心词和上下文词嵌入的平均值）"""
        return (self.center_embeddings.weight + self.context_embeddings.weight) / 2

# 准备训练数据
def prepare_training_data(cooccurrence_matrix):
    """将共现矩阵转换为训练数据"""
    center_indices = []
    context_indices = []
    cooccurrence_counts = []
    
    for (center_idx, context_idx), count in cooccurrence_matrix.items():
        center_indices.append(center_idx)
        context_indices.append(context_idx)
        cooccurrence_counts.append(count)
        
        # 由于共现矩阵是对称的，添加对称样本
        center_indices.append(context_idx)
        context_indices.append(center_idx)
        cooccurrence_counts.append(count)
    
    return (
        torch.LongTensor(center_indices),
        torch.LongTensor(context_indices),
        torch.FloatTensor(cooccurrence_counts)
    )

# 训练GloVe模型
def train_glove_model(model, train_data, epochs=100, learning_rate=0.05, batch_size=32):
    """训练GloVe模型"""
    center_indices, context_indices, cooccurrence_counts = train_data
    
    # 创建数据加载器
    dataset = torch.utils.data.TensorDataset(center_indices, context_indices, cooccurrence_counts)
    data_loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True)
    
    # 定义优化器
    optimizer = optim.Adam(model.parameters(), lr=learning_rate)
    
    # 记录损失
    losses = []
    
    # 训练模型
    model.train()
    for epoch in range(epochs):
        total_loss = 0
        
        for center_batch, context_batch, count_batch in data_loader:
            # 清零梯度
            optimizer.zero_grad()
            
            # 前向传播
            loss = model(center_batch, context_batch, count_batch)
            
            # 反向传播
            loss.backward()
            
            # 更新权重
            optimizer.step()
            
            total_loss += loss.item() * len(batch)
        
        # 计算平均损失
        avg_loss = total_loss / len(dataset)
        losses.append(avg_loss)
        
        if (epoch + 1) % 10 == 0:
            print(f"Epoch [{epoch+1}/{epochs}], Loss: {avg_loss:.4f}")
    
    return losses

# 示例文本数据
sample_text = """
词嵌入技术是自然语言处理领域的重要技术。
Word2Vec和GloVe是两种主要的词嵌入方法。
Word2Vec通过局部上下文学习词向量，而GloVe利用全局统计信息。
GloVe构建词-词共现矩阵，并通过最小化平方损失函数来学习向量表示。
词嵌入向量能够捕捉词语之间的语义关系，使得语义相似的词在向量空间中距离更近。
在实际应用中，我们可以根据任务需求选择合适的词嵌入方法。
"""

# 设置随机种子
set_seed()

# 预处理文本
words, word_to_idx, idx_to_word = preprocess_text(sample_text)
vocab_size = len(word_to_idx)
print(f"词汇表大小: {vocab_size}")

# 构建共现矩阵
window_size = 2
cooccurrence_matrix = build_cooccurrence_matrix(words, word_to_idx, window_size)
print(f"共现矩阵中非零元素数量: {len(cooccurrence_matrix)}")

# 准备训练数据
train_data = prepare_training_data(cooccurrence_matrix)

# 模型参数
embedding_dim = 50
epochs = 100
batch_size = 32
learning_rate = 0.05

# 创建模型
model = GloVeModel(vocab_size, embedding_dim)

# 训练模型
losses = train_glove_model(model, train_data, epochs, learning_rate, batch_size)

# 绘制损失曲线
plt.figure(figsize=(10, 6))
plt.plot(losses)
plt.title('GloVe Training Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.grid(True)
plt.show()

# 获取词嵌入
word_embeddings = model.get_embeddings().detach().numpy()

# 查找相似词
def find_similar_words(embeddings, word_to_idx, idx_to_word, word, top_n=5):
    if word not in word_to_idx:
        return f"词 '{word}' 不在词汇表中"
    
    word_idx = word_to_idx[word]
    word_embedding = embeddings[word_idx]
    
    # 计算与所有词的相似度
    similarities = []
    for i in range(len(idx_to_word)):
        if i != word_idx:
            similarity = np.dot(word_embedding, embeddings[i]) / (
                np.linalg.norm(word_embedding) * np.linalg.norm(embeddings[i])
            )
            similarities.append((idx_to_word[i], similarity))
    
    # 按相似度排序
    similarities.sort(key=lambda x: x[1], reverse=True)
    
    return similarities[:top_n]

# 可视化词嵌入
def visualize_word_embeddings(embeddings, idx_to_word, n_words=15):
    words = [idx_to_word[i] for i in range(min(n_words, len(idx_to_word)))]
    vectors = embeddings[:min(n_words, len(idx_to_word))]
    
    # 使用t-SNE降维
    tsne = TSNE(n_components=2, random_state=42)
    vectors_tsne = tsne.fit_transform(vectors)
    
    # 绘制散点图
    plt.figure(figsize=(10, 8))
    for i, word in enumerate(words):
        plt.scatter(vectors_tsne[i, 0], vectors_tsne[i, 1])
        plt.annotate(word, xy=(vectors_tsne[i, 0], vectors_tsne[i, 1]),
                     xytext=(5, 2), textcoords='offset points')
    
    plt.title('GloVe Word Embeddings Visualization')
    plt.grid(True)
    plt.show()

# 查找相似词
for word in ["词嵌入", "glove", "语义"]:
    print(f"\n与 '{word}' 相似的词：")
    similar_words = find_similar_words(word_embeddings, word_to_idx, idx_to_word, word)
    if isinstance(similar_words, list):
        for w, similarity in similar_words:
            print(f"{w}: {similarity:.4f}")
    else:
        print(similar_words)

# 可视化词嵌入
visualize_word_embeddings(word_embeddings, idx_to_word)

import numpy as np
from scipy.stats import spearmanr, pearsonr

def evaluate_word_similarity(word_embeddings, word_to_idx, similarity_dataset):
    """评估词嵌入在词相似度任务上的性能"""
    model_scores = []
    human_scores = []
    
    for word1, word2, score in similarity_dataset:
        if word1 in word_to_idx and word2 in word_to_idx:
            # 获取词向量
            vec1 = word_embeddings[word_to_idx[word1]]
            vec2 = word_embeddings[word_to_idx[word2]]
            
            # 计算余弦相似度
            cosine_sim = np.dot(vec1, vec2) / (
                np.linalg.norm(vec1) * np.linalg.norm(vec2)
            )
            
            model_scores.append(cosine_sim)
            human_scores.append(score)
    
    # 计算Spearman相关系数
    spearman_corr, _ = spearmanr(model_scores, human_scores)
    # 计算Pearson相关系数
    pearson_corr, _ = pearsonr(model_scores, human_scores)
    
    return {
        'spearman_correlation': spearman_corr,
        'pearson_correlation': pearson_corr,
        'evaluated_pairs': len(model_scores)
    }

# 示例：使用模拟的相似度数据集
similarity_dataset = [
    ("词嵌入", "向量", 0.9),
    ("GloVe", "Word2Vec", 0.8),
    ("自然语言", "处理", 0.7),
    ("共现", "矩阵", 0.6),
    ("训练", "学习", 0.5),
    ("语义", "语法", 0.4),
    ("模型", "算法", 0.3)
]

# 评估词相似度
results = evaluate_word_similarity(word_embeddings, word_to_idx, similarity_dataset)
print(f"词相似度评估结果：")
print(f"Spearman相关系数: {results['spearman_correlation']:.4f}")
print(f"Pearson相关系数: {results['pearson_correlation']:.4f}")
print(f"评估的词对数量: {results['evaluated_pairs']}")

def evaluate_word_analogy(word_embeddings, word_to_idx, idx_to_word, analogy_dataset):
    """评估词嵌入在词类比任务上的性能"""
    correct = 0
    total = 0
    
    for a, b, c, d in analogy_dataset:
        if a in word_to_idx and b in word_to_idx and c in word_to_idx and d in word_to_idx:
            # 获取词向量
            vec_a = word_embeddings[word_to_idx[a]]
            vec_b = word_embeddings[word_to_idx[b]]
            vec_c = word_embeddings[word_to_idx[c]]
            
            # 计算类比向量：vec_d = vec_b - vec_a + vec_c
            vec_d_pred = vec_b - vec_a + vec_c
            
            # 查找最相似的词
            similarities = []
            for idx in range(len(word_embeddings)):
                # 跳过输入的词
                if idx not in [word_to_idx[a], word_to_idx[b], word_to_idx[c]]:
                    similarity = np.dot(vec_d_pred, word_embeddings[idx]) / (
                        np.linalg.norm(vec_d_pred) * np.linalg.norm(word_embeddings[idx])
                    )
                    similarities.append((idx, similarity))
            
            # 按相似度排序
            similarities.sort(key=lambda x: x[1], reverse=True)
            
            # 检查预测是否正确
            if similarities[0][0] == word_to_idx[d]:
                correct += 1
            total += 1
    
    # 计算准确率
    accuracy = correct / total if total > 0 else 0
    
    return {
        'accuracy': accuracy,
        'correct': correct,
        'total': total
    }

# 示例：使用模拟的类比数据集
analogy_dataset = [
    ("国王", "女王", "男人", "女人"),
    ("GloVe", "Word2Vec", "全局", "局部"),
    ("自然语言", "处理", "计算机", "程序")
]

# 评估词类比
results = evaluate_word_analogy(word_embeddings, word_to_idx, idx_to_word, analogy_dataset)
print(f"词类比评估结果：")
print(f"准确率: {results['accuracy']:.4f}")
print(f"正确数量: {results['correct']}/{results['total']}")

import torch
import torch.nn as nn
import torch.nn.functional as F

class TextClassifier(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_dim, output_dim, pretrained_embeddings=None):
        super(TextClassifier, self).__init__()
        
        # 嵌入层
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        
        # 如果提供了预训练嵌入，使用它初始化嵌入层
        if pretrained_embeddings is not None:
            self.embedding.weight.data.copy_(torch.from_numpy(pretrained_embeddings))
            # 可以选择是否冻结嵌入层
            # self.embedding.weight.requires_grad = False
        
        # 循环神经网络层
        self.rnn = nn.LSTM(embedding_dim, hidden_dim, batch_first=True)
        
        # 输出层
        self.fc = nn.Linear(hidden_dim, output_dim)
    
    def forward(self, text):
        # 文本嵌入
        embedded = self.embedding(text)
        
        # RNN前向传播
        output, (hidden, _) = self.rnn(embedded)
        
        # 使用最后一个时间步的隐藏状态
        hidden = hidden.squeeze(0)
        
        # 输出层
        return self.fc(hidden)

# 假设我们有预训练的GloVe嵌入
# 创建分类器模型
classifier = TextClassifier(
    vocab_size=vocab_size,
    embedding_dim=embedding_dim,
    hidden_dim=128,
    output_dim=2,  # 二分类任务
    pretrained_embeddings=word_embeddings
)

import numpy as np
import pandas as pd
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report

# 加载情感分析数据集
# 这里使用模拟数据，实际应用中可以使用真实数据集如IMDB、SST等
def load_sentiment_data():
    # 模拟情感分析数据
    texts = [
        "这部电影非常精彩，我很喜欢",
        "剧情很无聊，浪费时间",
        "演员表演出色，推荐观看",
        "画面很美，但故事情节一般",
        "这是我看过的最糟糕的电影之一",
        "音乐很棒，增强了观影体验",
        "情节紧凑，扣人心弦",
        "对白生硬，难以理解"
    ]
    labels = [1, 0, 1, 1, 0, 1, 1, 0]  # 1表示正面情感，0表示负面情感
    
    return texts, labels

# 文本预处理和向量化
def preprocess_for_sentiment_analysis(texts, word_to_idx, max_length=10):
    features = []
    for text in texts:
        # 简单分词
        words = text.split()
        # 转换为词索引序列
        seq = [word_to_idx.get(word, 0) for word in words]  # 未知词用0表示
        # 填充或截断到固定长度
        if len(seq) < max_length:
            seq += [0] * (max_length - len(seq))
        else:
            seq = seq[:max_length]
        features.append(seq)
    return np.array(features)

# 定义情感分析模型
class SentimentClassifier(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_dim, output_dim, pretrained_embeddings=None):
        super(SentimentClassifier, self).__init__()
        
        # 嵌入层
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        
        # 使用预训练的GloVe嵌入
        if pretrained_embeddings is not None:
            self.embedding.weight.data.copy_(torch.from_numpy(pretrained_embeddings))
            # 可以选择是否冻结嵌入层
            # self.embedding.weight.requires_grad = False
        
        # 全连接层
        self.fc1 = nn.Linear(embedding_dim * max_length, hidden_dim)
        self.fc2 = nn.Linear(hidden_dim, output_dim)
        self.dropout = nn.Dropout(0.5)
        
    def forward(self, x):
        # 文本嵌入
        embedded = self.embedding(x)
        # 展平
        embedded = embedded.view(embedded.size(0), -1)
        # 全连接层
        out = torch.relu(self.fc1(embedded))
        out = self.dropout(out)
        out = self.fc2(out)
        return out

# 加载数据
texts, labels = load_sentiment_data()

# 假设我们已经有了词汇表和GloVe嵌入
# 在实际应用中，这里应该加载预训练的GloVe模型
vocab_size = len(word_to_idx)
embedding_dim = 50
max_length = 10

# 预处理数据
X = preprocess_for_sentiment_analysis(texts, word_to_idx, max_length)
y = np.array(labels)

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)

# 转换为PyTorch张量
train_data = TensorDataset(torch.LongTensor(X_train), torch.LongTensor(y_train))
test_data = TensorDataset(torch.LongTensor(X_test), torch.LongTensor(y_test))

# 创建数据加载器
batch_size = 2
train_loader = DataLoader(train_data, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_data, batch_size=batch_size)

# 创建模型
model = SentimentClassifier(
    vocab_size=vocab_size,
    embedding_dim=embedding_dim,
    hidden_dim=32,
    output_dim=2,
    pretrained_embeddings=word_embeddings
)

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练模型
epochs = 10
for epoch in range(epochs):
    model.train()
    train_loss = 0
    for inputs, labels in train_loader:
        # 清零梯度
        optimizer.zero_grad()
        
        # 前向传播
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        
        # 反向传播和优化
        loss.backward()
        optimizer.step()
        
        train_loss += loss.item() * inputs.size(0)
    
    # 计算平均损失
    train_loss = train_loss / len(train_loader.dataset)
    
    # 评估模型
    model.eval()
    y_pred = []
    y_true = []
    
    with torch.no_grad():
        for inputs, labels in test_loader:
            outputs = model(inputs)
            _, predicted = torch.max(outputs, 1)
            y_pred.extend(predicted.tolist())
            y_true.extend(labels.tolist())
    
    # 计算准确率
    accuracy = accuracy_score(y_true, y_pred)
    
    print(f'Epoch {epoch+1}/{epochs}, Loss: {train_loss:.4f}, Accuracy: {accuracy:.4f}')

# 打印分类报告
print("\n分类报告:")
print(classification_report(y_true, y_pred, target_names=['负面', '正面']))

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

# 文档集合
documents = [
    "词嵌入技术是自然语言处理的重要基础",
    "GloVe模型通过全局统计信息学习词向量",
    "Word2Vec和GloVe是两种主要的词嵌入方法",
    "词向量能够捕捉词语之间的语义关系",
    "GloVe在信息检索任务中表现出色"
]

# 简单的搜索引擎类
class SimpleSearchEngine:
    def __init__(self, documents, word_embeddings, word_to_idx):
        self.documents = documents
        self.word_embeddings = word_embeddings
        self.word_to_idx = word_to_idx
        self.document_vectors = self.compute_document_vectors()
    
    def compute_document_vectors(self):
        """计算文档向量"""
        doc_vectors = []
        for doc in self.documents:
            words = doc.split()
            # 计算文档中所有词的词向量平均值
            vecs = [self.word_embeddings[self.word_to_idx.get(word, 0)] 
                    for word in words if word in self.word_to_idx]
            if vecs:
                doc_vector = np.mean(vecs, axis=0)
            else:
                # 如果文档中没有词汇表中的词，使用零向量
                doc_vector = np.zeros_like(self.word_embeddings[0])
            doc_vectors.append(doc_vector)
        return np.array(doc_vectors)
    
    def search(self, query, top_k=3):
        """搜索与查询最相关的文档"""
        # 计算查询向量
        words = query.split()
        vecs = [self.word_embeddings[self.word_to_idx.get(word, 0)] 
                for word in words if word in self.word_to_idx]
        
        if not vecs:
            return []
        
        query_vector = np.mean(vecs, axis=0)
        
        # 计算查询向量与所有文档向量的余弦相似度
        similarities = cosine_similarity([query_vector], self.document_vectors)[0]
        
        # 按相似度排序并返回前k个结果
        results = [(i, similarities[i], self.documents[i]) 
                  for i in range(len(self.documents))]
        results.sort(key=lambda x: x[1], reverse=True)
        
        return results[:top_k]

# 创建搜索引擎实例
search_engine = SimpleSearchEngine(documents, word_embeddings, word_to_idx)

# 测试搜索
queries = [
    "什么是GloVe模型",
    "词嵌入方法有哪些",
    "信息检索技术"
]

for query in queries:
    print(f"\n查询: {query}")
    results = search_engine.search(query)
    for i, (doc_idx, score, doc) in enumerate(results, 1):
        print(f"结果{i} (相似度: {score:.4f}): {doc}")

import numpy as np
import pandas as pd
from sklearn.metrics import mean_squared_error

# 模拟用户-物品交互数据
def load_recommendation_data():
    # 用户-物品评分矩阵
    # rows: users, columns: items
    ratings = np.array([
        [5, 4, 0, 0, 1],
        [4, 0, 0, 3, 1],
        [0, 0, 0, 0, 5],
        [0, 2, 5, 0, 0],
        [0, 0, 4, 0, 0],
        [1, 0, 0, 5, 0]
    ])
    
    # 物品描述
    item_descriptions = [
        "这是一部科幻电影，讲述了未来世界的故事",
        "一部感人的爱情电影，情节跌宕起伏",
        "紧张刺激的动作大片，特效震撼",
        "悬疑推理电影，结局出人意料",
        "轻松幽默的喜剧电影，让人捧腹大笑"
    ]
    
    return ratings, item_descriptions

# 基于GloVe的推荐系统类
class GloVeRecommender:
    def __init__(self, ratings, item_descriptions, word_embeddings, word_to_idx):
        self.ratings = ratings
        self.item_descriptions = item_descriptions
        self.word_embeddings = word_embeddings
        self.word_to_idx = word_to_idx
        self.num_users, self.num_items = ratings.shape
        
        # 计算物品向量
        self.item_vectors = self.compute_item_vectors()
        # 初始化用户向量
        self.user_vectors = np.random.rand(self.num_users, self.word_embeddings.shape[1])
    
    def compute_item_vectors(self):
        """基于物品描述计算物品向量"""
        item_vectors = []
        for desc in self.item_descriptions:
            words = desc.split()
            vecs = [self.word_embeddings[self.word_to_idx.get(word, 0)] 
                    for word in words if word in self.word_to_idx]
            if vecs:
                item_vector = np.mean(vecs, axis=0)
            else:
                item_vector = np.zeros_like(self.word_embeddings[0])
            item_vectors.append(item_vector)
        return np.array(item_vectors)
    
    def train(self, epochs=100, learning_rate=0.01):
        """训练推荐模型"""
        for epoch in range(epochs):
            for user_idx in range(self.num_users):
                for item_idx in range(self.num_items):
                    # 只更新有评分的用户-物品对
                    if self.ratings[user_idx, item_idx] > 0:
                        # 预测评分
                        pred = np.dot(self.user_vectors[user_idx], self.item_vectors[item_idx])
                        # 计算误差
                        error = self.ratings[user_idx, item_idx] - pred
                        # 更新用户向量
                        self.user_vectors[user_idx] += learning_rate * error * self.item_vectors[item_idx]
            
            # 计算训练集上的均方误差
            if (epoch + 1) % 10 == 0:
                mse = self.compute_mse()
                print(f"Epoch {epoch+1}/{epochs}, MSE: {mse:.4f}")
    
    def compute_mse(self):
        """计算均方误差"""
        predictions = []
        actuals = []
        for user_idx in range(self.num_users):
            for item_idx in range(self.num_items):
                if self.ratings[user_idx, item_idx] > 0:
                    pred = np.dot(self.user_vectors[user_idx], self.item_vectors[item_idx])
                    predictions.append(pred)
                    actuals.append(self.ratings[user_idx, item_idx])
        return mean_squared_error(actuals, predictions)
    
    def recommend(self, user_idx, top_k=3):
        """为用户推荐物品"""
        # 计算用户对所有物品的预测评分
        scores = np.dot(self.user_vectors[user_idx], self.item_vectors.T)
        
        # 找出用户还没有评分的物品
        unrated_items = np.where(self.ratings[user_idx] == 0)[0]
        
        # 按预测评分排序
        recommendations = [(item_idx, scores[item_idx], self.item_descriptions[item_idx]) 
                          for item_idx in unrated_items]
        recommendations.sort(key=lambda x: x[1], reverse=True)
        
        return recommendations[:top_k]

# 加载数据
ratings, item_descriptions = load_recommendation_data()

# 创建并训练推荐系统
recommender = GloVeRecommender(ratings, item_descriptions, word_embeddings, word_to_idx)
recommender.train(epochs=100, learning_rate=0.01)

# 为用户推荐物品
for user_idx in range(recommender.num_users):
    print(f"\n为用户{user_idx+1}的推荐:")
    recommendations = recommender.recommend(user_idx)
    for i, (item_idx, score, desc) in enumerate(recommendations, 1):
        print(f"推荐{i} (预测评分: {score:.2f}): 物品{item_idx+1} - {desc}")