from gensim.models import Word2Vec
from gensim.utils import simple_preprocess

# 读入文件与预处理
with open('homework3_input.txt', encoding = 'utf-8') as f:
    text = f.read()

sentences = text.split('\n')

corpus = [sentence.split(' ') for sentence in sentences]
# print(corpus)
# print(type(corpus))

# 传入的是二维列表！
# corpus = [simple_preprocess(sentence) for sentence in sentences]
# print(corpus)

# 模型训练
model = Word2Vec(sentences=corpus, vector_size=100, window=5, min_count=1, workers=4, epochs=5, min_alpha=0.005, sg=0)

# 模型保存
model.save("word2vec.model")

# 模型加载
model = Word2Vec.load("word2vec.model")

# 相似度计算函数
def similarity_compute(word1, word2):
    similarity = model.wv.similarity(word1, word2)
    print(f"{word1} 和 {word2} 相似度为：{similarity}")

# 找到前5个相近词
def most_similar(word):
    simi_words = model.wv.most_similar(word, topn=5)
    print(f"{word}的前五个相近词：")
    for ans, score in simi_words:
        print(f"{ans} : {score}")

# 计算5组词之间的相似度
similarity_compute('俄罗斯', '乌克兰')
similarity_compute('舅舅', '叔叔')
similarity_compute('证券', '金融')
similarity_compute('足球', '篮球')
similarity_compute('火锅', '麻辣烫')

# 寻找相近词
most_similar('足球')
most_similar('新华社')
most_similar('舅舅')
most_similar('欧洲')
most_similar('心脏')

# 计算'爸爸-男人+女人'的结果
result = model.wv.most_similar(positive=['爸爸', '女人'], negative=['男人'], topn=5)
for word, score in result:
    print(f"可能的答案: {word}, 相似度：{score}")

import torch
from transformers import BertTokenizer
from transformers import BertModel
from sklearn.metrics.pairwise import cosine_similarity

# 中文Bert
model_name = '../第二周/bert-base-chinese/bert-base-chinese'
tokenizers = BertTokenizer.from_pretrained(model_name)
model = BertModel.from_pretrained(model_name)

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')  # 这句话不要忘了是字符串...

model.to(device)  # 将模型移动到指定的设备（GPU 或 CPU）
model.eval()  # 将模型设置为评估模式（关闭 dropout 等训练时的特殊操作）

def get_sentence_embedding(sentence):
    inputs = tokenizers(sentence, return_tensors='pt', truncation=True, max_length=128) # 
    inputs = {k: v.to(device) for k,v in inputs.items()} # 将输入数据移动到指定的设备（GPU 或 CPU）

    with torch.no_grad():
        outputs = model(**inputs) # 函数解包，将inputs传给模型，得到输出

    cls_embedding = outputs.last_hidden_state[:, 0, :]  # 取出[CLS]对应的向量作为句子的embedding
    return cls_embedding.cpu().numpy()  # 将embedding从GPU转回CPU，并转为numpy数组返回

def compute_sentence_similarity(sentence1, sentence2):
    embedding1 = get_sentence_embedding(sentence1)  # 这里的embedding1就是句子1的embedding
    embedding2 = get_sentence_embedding(sentence2)  # 这里的embedding2就是句子2的embedding

    sim = cosine_similarity(embedding1, embedding2)[0][0]  # 会返回如$$[0.9926]] 这样的(1,1)矩阵结果，需要用[0][0]进行提取
    print(f"句子相似度: {sim:.4f}")

sentence1 = "中国队大胜尼日利亚队"
sentence2 = "尼日利亚队大败中国队"
sentence3 = '吃葡萄不吐葡萄皮'
sentence4 = '不吃葡萄倒吐葡萄皮'
sentence5 = '夏洛特烦恼'
sentence6 = '西红市首富赚了100万，于是开了开心麻花'
sentence7 = '他正在学习自然语言处理'
sentence8 = '他正在学习人工智能技术'
sentence9 = '这部电影非常精彩，值得一看'
sentence10 = '这部电影太无聊了，浪费时间'

compute_sentence_similarity(sentence1, sentence2)
compute_sentence_similarity(sentence3, sentence4)
compute_sentence_similarity(sentence5, sentence6)
compute_sentence_similarity(sentence7, sentence8)
compute_sentence_similarity(sentence9, sentence10)

# 英文Bert
model_name = '../第二周/bert-base-cased/bert-base-cased'
tokenizers = BertTokenizer.from_pretrained(model_name)
model = BertModel.from_pretrained(model_name)

'''中间省略'''

sentence1 = "The weather is nice today, and the sun is shining."
sentence2 = "I love you."
sentence3 = "I enjoy eating apples and bananas."
sentence4 = "Apples and bananas are my favorite fruits."
sentence5 = "He is studying natural language processing."
sentence6 = "The cat is sleeping."
sentence7 = "This movie is fantastic and worth watching."
sentence8 = "That bookis so boring and a waste of time."
sentence9 = "She went to Beijing yesterday."
sentence10 = "He has married a beautiful girl."

import torch
from transformers import GPT2Tokenizer
from transformers import GPT2Model
from sklearn.metrics.pairwise import cosine_similarity

model_name = './gpt2'
tokenizers = GPT2Tokenizer.from_pretrained(model_name)
model = GPT2Model.from_pretrained(model_name)

inputs = {
    'input_ids': tensor1,
    'attention_mask': tensor2
}

input_ids=tensor1, attention_mask=tensor2

outputs = model(**inputs)

outputs = model(input_ids=inputs['input_ids'], attention_mask=inputs['attention_mask'])

inputs = {
    'input_ids': torch.tensor([[1, 2, 3]]),
    'attention_mask': torch.tensor([[1, 1, 1]])
}

model(input_ids=torch.tensor([[1, 2, 3]]), attention_mask=torch.tensor([[1, 1, 1]]))

import torch
import torch.nn as nn

# 定义CBOW模型
class CBOWModel(nn.Module):
    def __init__(self, vocab_size, embedding_dim):
        '''参数初始化'''
        super(CBOWModel, self).__init__() # 继承父类(nn.Module)的初始化方法
        self.vocab_size = vocab_size  # 词汇表大小
        self.embedding_dim = embedding_dim  # 词向量维度
        self.input_embeddings = nn.Embedding(vocab_size, embedding_dim)  # 输入词向量嵌入层
        self.output_embeddings = nn.Embedding(vocab_size, embedding_dim)  # 输出词向量嵌入层
        self.init_emb()  # 初始化词向量

    def init_emb(self):
        initrange = 0.5 / self.embedding_dim  # 随机初始化范围
        self.input_embeddings.weight.data.uniform_(-initrange, initrange)  # 输入词向量初始化, uniform_()方法用于将权重张量初始化为均匀分布
        self.output_embeddings.weight.data.uniform_(-0, 0)  # 输出词向量初始化

    def forward(self, context_words, target_words, negative_words):
        '''
        context_words: 上下文词的索引，形状为 (batch_size, context_size)
        target_words: 目标词的索引，形状为 (batch_size)
        negative_words: 负采样的词索引，形状为 (batch_size, num_negatives)
        '''
        # 将上下文词通过输入嵌入层转换为向量，得到形状 (batch_size, context_size, embedding_dim)
        context_emb = self.input_embeddings(context_words)  # (batch, context_size, embed_dim) 
        # 对上下文词的嵌入取平均，得到单个向量表示整个上下文，形状变为 (batch_size, embedding_dim)
        context_emb = torch.mean(context_emb, dim=1)  # (batch, embed_dim)
        # 目标词和负样本通过输出嵌入层转换为向量，形状分别为 (batch_size, embedding_dim) 和 (batch_size, num_negatives, embedding_dim)。
        target_emb = self.output_embeddings(target_words)  # (batch, embed_dim)
        negative_emb = self.output_embeddings(negative_words)  # (batch, neg, embed_dim)

        # 计算正样本的损失
        # 分数计算：上下文向量与目标词向量的逐元素乘积之和（点积），表示两者的相似性。
        positive_score = torch.sum(context_emb * target_emb, dim=1)  # (batch)
        # 损失转换：通过sigmoid将分数映射到(0,1)区间，取对数并添加极小值（1e-10）防止数值溢出。
        positive_loss = torch.log(torch.sigmoid(positive_score) + 1e-10)

        # 计算负样本的损失
        # 分数计算：context_emb.unsqueeze(2) 扩展维度为 (batch, embed_dim, 1)，torch.bmm（批量矩阵乘法）计算每个负样本与上下文向量的点积，得到形状 (batch_size, num_negatives)
        negative_score = torch.bmm(negative_emb, context_emb.unsqueeze(2)).squeeze()  # (batch, neg)
        # 损失转换：对负样本分数取负号（因为希望负样本得分低），通过sigmoid和log计算损失，并对所有负样本求和。
        negative_loss = torch.sum(torch.log(torch.sigmoid(-negative_score) + 1e-10), dim=1)  # (batch)

        loss = -(positive_loss + negative_loss) # (batch)，负号是为了最小化loss
        return loss.mean()  # 平均loss

negative_score = torch.bmm(negative_emb, context_emb.unsqueeze(2)).squeeze()  # (batch, neg)
negative_loss = torch.sum(torch.log(torch.sigmoid(-negative_score) + 1e-10), dim=1)

loss = -(positive_loss + negative_loss).mean()

import numpy as np

# 负采样分布
def get_negative_sampling_distribution(word_counts):
    # 使用词频的0.75次方
    power = 0.75
    print(word_counts)
    distribution = word_counts ** power  # 计算负采样分布，给词频乘以0.75次方，进行平滑处理
    print(distribution)
    distribution /= distribution.sum()  # 归一化
    print(distribution)
    return distribution  # 返回负采样分布

class NegativeSampler:
    def __init__(self, distribution):
        self.distribution = distribution  # 初始化分布
        self.vocab_size = len(distribution)  # 设置词汇表大小就是分布大小

    def sample(self, batch_size, num_negatives):
        # 使用numpy的choice进行批量采样
        return np.random.choice(self.vocab_size, size=(batch_size, num_negatives), p=self.distribution)  # 按照负采样分布采样，通过设置每个词的采样概率p实现，返回的是一个二维数组，shape=(batch_size, num_negatives)，采样的范围是 [0, vocab_size)，其中，二维数组的每一行表示每个正样本对应的负样本索引

import torch
import numpy as np
from torch import optim
from tqdm import tqdm

class Trainer:
    def __init__(self, model, config, dataloader, word2idx, idx2word, sampler):
        # 参数初始化
        self.model = model  
        self.config = config
        self.dataloader = dataloader
        self.word2idx = word2idx
        self.idx2word = idx2word
        self.sampler = sampler
        
        # 设备设置
        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
        self.model.to(self.device)
        
        # 优化器设置
        self.optimizer = optim.Adam(self.model.parameters(), lr=config.learning_rate)
        
        self.loss_history = []  # 记录损失
        
    def _train_epoch(self, epoch):
        '''训练单轮epoch'''
        train_loss = 0   # 初始化训练损失
        progress_bar = tqdm(self.dataloader, desc=f"Epoch {epoch+1}/{self.config.epochs}")  # 进度条
        for batch in progress_bar:  
            if self.config.mode == 'skip-gram':  # skip-gram模式
                center, target = batch  # skip-gram模式,sentences为中心词和目标词对
                inputs = torch.tensor(center, dtype=torch.long).to(self.device)  # 转换为tensor
            else:
                context, target = batch  # cbow模式,sentences为上下文词构成的元组和目标词对
                inputs = torch.tensor(context, dtype=torch.long).to(self.device)  # 转换为tensor
            
            targets = torch.tensor(target, dtype=torch.long).to(self.device)  # 将目标词转换为tensor
            batch_size = targets.size(0)  # 批量大小，即中心词个数
            
            # 负采样
            negative_samples = self.sampler.sample(batch_size, self.config.num_negatives)  # 进行负采样，其中负采样的个数为num_negatives，结果是一个batch_size*num_negatives的矩阵
            negative_samples = torch.tensor(negative_samples, dtype=torch.long).to(self.device) # 将负采样结果转换为tensor
            
            # 清空原本的梯度，进行前向传播
            self.optimizer.zero_grad()
            loss = self.model(inputs, targets, negative_samples) # 计算损失
            
            # loss进行反向传播，更新优化器参数
            loss.backward()
            self.optimizer.step()
            
            # 记录损失
            train_loss += loss.item()
            # progress_bar.set_postfix(loss=loss.item())
        
        # 计算平均损失
        avg_loss = train_loss / len(self.dataloader)
        self.loss_history.append(avg_loss)  # 记录损失

        return avg_loss

    def train(self):
        for epoch in range(self.config.epochs):
            avg_loss = self._train_epoch(epoch)  # 训练单轮epoch
            print(f"Epoch {epoch+1}/{self.config.epochs}, Loss: {avg_loss:.4f}")

    def get_and_save(self):
        # 获取词向量
        embeddings = self.model.input_embeddings.weight.data.cpu().numpy() 
        
        # 保存词向量
        with open(self.config.save_path, 'w', encoding='utf-8') as f:
            for idx, word in self.idx2word.items():
                # map 是 Python 的内置函数，它会对一个可迭代对象（如列表）中的每个元素应用指定的函数（这里是 str 函数），并返回一个新的迭代器
                # join 是 Python 的内置函数，它会将序列中的元素以指定的字符连接起来，并返回一个新的字符串
                vector = ' '.join(map(str, embeddings[idx])) 
                f.write(f"{word} {vector}\n")  # 保存词以及对应的词向量
        print(f"Word vectors saved to {self.config.save_path}")

        # 构建词向量矩阵并进行归一化
        norm_embeddings = embeddings / (np.linalg.norm(embeddings, axis=1, keepdims=True) + 1e-10)

        return norm_embeddings
    

import torch
import random
import numpy as np
from torch.utils.data import DataLoader
from torch import optim
from utils.configs import Config
from utils.dataloader import Word2VecDataset, read_data, build_vocab
from utils.negative_sampler import NegativeSampler, get_negative_sampling_distribution
from utils.metrics import cosine_similarity, find_most_similar
from models.skip_gram import SkipGramModel
from models.cbow import CBOWModel
from trainers import Trainer

# 设置随机种子以确保结果可复现
torch.manual_seed(0)
random.seed(0)
np.random.seed(0)

def main():
    # 解析命令行参数
    config = Config()
    print("配置参数：")
    print(f"embedding_dim: {config.embedding_dim}")
    print(f"window_size: {config.window_size}")
    print(f"num_negatives: {config.num_negatives}")
    print(f"batch_size: {config.batch_size}")
    print(f"epochs: {config.epochs}")
    print(f"learning_rate: {config.learning_rate}")
    print(f"mode: {config.mode}")
    print(f"data_path: {config.data_path}")
    print(f"save_path: {config.save_path}")
    
    # 读取数据
    corpus = read_data(config.data_path)
    word2idx, idx2word, word_counts = build_vocab(corpus, min_count=1)  # 构建词汇表
    vocab_size = len(word2idx)  # 词汇表大小
    print(f"Vocab size: {vocab_size}")  # 打印词汇表大小
    
    # 负采样分布
    distribution = get_negative_sampling_distribution(word_counts)  # 根据词频构建分布
    sampler = NegativeSampler(distribution)  # 根据分布构建负采样器

    # 创建Dataset和DataLoader
    dataset = Word2VecDataset(corpus, word2idx, config.window_size, mode=config.mode)  # 创建Dataset
    dataloader = DataLoader(dataset, batch_size=config.batch_size, shuffle=True)  # 创建DataLoader

    # 初始化模型
    if config.mode == 'skip-gram':
        model = SkipGramModel(vocab_size, config.embedding_dim)  # 初始化Skip-gram模型
    else:
        model = CBOWModel(vocab_size, config.embedding_dim)  # 初始化CBOW模型

    # 初始化训练器
    trainer = Trainer(
        model=model,
        config=config,
        dataloader=dataloader,
        word2idx=word2idx,
        idx2word=idx2word,
        sampler=sampler
    )
    
    # 训练模型
    trainer.train()
    
    # 保存词向量，并获得归一化的词向量
    norm_embeddings = trainer.get_and_save()

    word_a = '新华社'  
    word_b = '法新社'  
    if word_a in word2idx and word_b in word2idx:  # 判断词是否在词汇表中
        vec_a = norm_embeddings[word2idx[word_a]]  # 先将词转成索引，再取出对应的词向量
        vec_b = norm_embeddings[word2idx[word_b]]
        similarity = cosine_similarity(vec_a, vec_b)  # 计算余弦相似度
        print(f"'{word_a}' 与 '{word_b}' 的相似度为: {similarity:.4f}")
    else:
        print(f"'{word_a}' 或 '{word_b}' 不在词汇表中。")

    # 示例：查找与指定词最相似的前N个词
    target_word = '搜狐'  
    top_n = 5
    similar_words = find_most_similar(target_word, word2idx, idx2word, norm_embeddings, top_n=top_n)  # 找到与target_word最相似的前N个词
    if similar_words:
        print(f"与 '{target_word}' 最相似的前 {top_n} 个词:")
        for word, score in similar_words:
            print(f"{word}: {score:.4f}")

if __name__ == "__main__":
    main() # 调用main函数

self.model.parameters()  # 包括 input_embeddings 和 output_embeddings 的权重

loss = self.model(inputs, targets, negative_samples)

loss.backward()  # 计算梯度

self.optimizer.step()  # 更新参数

loss = self.model(inputs, targets, negative_samples)

loss.backward()

self.optimizer.step()

self.optimizer.zero_grad()  # 清空上一批次的梯度

loss = self.model(...)  # 前向传播
loss.backward()         # 反向传播
self.optimizer.step()   # 参数更新

loss = self.model(inputs, targets, negative_samples)

loss = self.model.forward(inputs, targets, negative_samples)

loss = self.model(inputs, targets, negative_samples)

def forward(self, context_words, target_words, negative_words):

class Word2VecDataset(Dataset):
    def __init__(self, corpus, word2idx, window_size, mode='skip-gram'):
        self.pairs = []  # 保存中心词和上下文词对
        self.mode = mode # 设置 skip-gram 或 cbow 模式
        for sentence in corpus:
            # 过滤掉不在词汇表中的词，并将句子中的词索引化，得到一个一维列表
            indices = [word2idx[word] for word in sentence if word in word2idx]
            for center_pos, center_word in enumerate(indices):
                # 定义上下文窗口
                start = max(0, center_pos - window_size)  # 窗口起始位置，注意这里有边界问题，如果窗口越界，则取0
                end = min(len(indices), center_pos + window_size + 1)  # 窗口结束位置，注意这里也有边界问题，如果窗口越界，则取序列长度
                context = indices[start:center_pos] + indices[center_pos+1:end]  # 上下文词列表
                for context_word in context:
                    if mode == 'skip-gram':
                        self.pairs.append((center_word, context_word))  # 保存中心词和上下文词对，将中心词与每一个上下文词配对，共配对len(context)次，表示中心词预测上下文词
                    elif mode == 'cbow':
                        self.pairs.append((list(context), center_word))  # 保存上下文词列表和中心词对，注意这里用了元组，表示多个上下文词共同预测中心词
        print(f"Total pairs for {mode}: {len(self.pairs)}")

    def __len__(self):
        return len(self.pairs)  # 返回样本数

    def __getitem__(self, idx):
        return self.pairs[idx] # 返回第idx个配对

# skip-gram:
[center_word, context_word1]
...
[center_word, context_wordn]

# cbow
[[context], center_word]
...
[[context], center_word]

# 假设数据集返回的样本是 (tensor, label)
sample1 = (torch.tensor([1, 2, 3]), 0)
sample2 = (torch.tensor([4, 5, 6]), 1)

# 默认的 collate_fn 会将它们组合成：
batch = (torch.tensor([[1, 2, 3], [4, 5, 6]]), torch.tensor([0, 1]))

from torch.nn.utils.rnn import pad_sequence

def collate_fn(batch):
    # batch 是一个列表，每个元素是 (sequence, label)
    sequences, labels = zip(*batch)
    # 对序列进行填充
    sequences_padded = pad_sequence(sequences, batch_first=True, padding_value=0)
    labels = torch.tensor(labels)
    return sequences_padded, labels

def collate_fn(batch):
    # batch 是一个列表，每个元素是 {"data": tensor, "label": int}
    data = torch.stack([item["data"] for item in batch])
    labels = torch.tensor([item["label"] for item in batch])
    return {"data": data, "label": labels}

def collate_fn(batch):
    images, labels = zip(*batch)
    # 对图像进行归一化
    images = torch.stack([normalize(img) for img in images])
    labels = torch.tensor(labels)
    return images, labels

from torch.utils.data import DataLoader

# 假设 dataset 是你的数据集
dataloader = DataLoader(dataset, batch_size=32, shuffle=True, collate_fn=collate_fn)

def collate_fn_cbow(batch):
    contexts, targets = zip(*batch) # 把batch解包
    max_len = max(len(ctx) for ctx in contexts)
    padded_contexts = [ctx + [0]*(max_len - len(ctx)) for ctx in contexts]  # 假设0是PAD的索引
    return torch.LongTensor(padded_contexts), torch.LongTensor(targets)

def build_vocab(corpus, min_count=1):
    counter = Counter()  # 词频统计
    for sentence in corpus:
        counter.update(sentence)  # 统计每个词的词频，update方法可以累加计数
    # 过滤低频词
    vocab = {word for word, count in counter.items() if count >= min_count}  # 保留词频大于等于min_count的词
    word2idx = {word: idx for idx, word in enumerate(vocab)}  # 词到索引的映射
    idx2word = {idx: word for word, idx in word2idx.items()}  # 索引到词的映射
    word_counts = np.array([counter[idx2word[i]] for i in range(len(idx2word))], dtype=np.float32)  # 词频数组
    return word2idx, idx2word, word_counts 

def build_vocab(corpus, min_count=1):
    counter = Counter()
    for sentence in corpus:
        counter.update(sentence)
    
    # 显式添加PAD标记
    special_tokens = ['<PAD>']  # 索引0
    sorted_words = special_tokens + sorted(
        [word for word, count in counter.items() if count >= min_count],
        key=lambda x: (-counter[x], x))  # 其他词按词频排序
    
    word2idx = {word: idx for idx, word in enumerate(sorted_words)}
    idx2word = {idx: word for idx, word in enumerate(sorted_words)}
    word_counts = np.array([counter.get(word, 0) for word in sorted_words], dtype=np.float32)  # 从 counter 中获取 word 的词频。如果 word 不在 counter 中（例如 <PAD>），则返回默认值 0
    return word2idx, idx2word, word_counts

def collate_fn_cbow(batch):
    # 解包批次数据：contexts是多个上下文词列表，targets是对应的中心词
    contexts, targets = zip(*batch)
    # 计算当前批次中最长的上下文长度
    max_len = max(len(ctx) for ctx in contexts)
    # 获取PAD标记的索引（假设是0）
    pad_idx = 0
    # 初始化填充后的上下文列表
    padded_contexts = []
    
    # 对每个上下文进行填充
    for ctx in contexts:
        # 计算需要填充的长度
        padding_needed = max_len - len(ctx)
        # 填充PAD标记（0）
        padded_ctx = ctx + [pad_idx] * padding_needed
        padded_contexts.append(padded_ctx)
    
    # 转换为Tensor（形状：[batch_size, max_len]）
    padded_contexts = torch.LongTensor(padded_contexts)
    targets = torch.LongTensor(targets)
    
    return padded_contexts, targets

class CBOWModel(nn.Module):
	'''
	前面的内容不变
	'''
	def forward(self, context_words, target_words, negative_words):
		# context_words形状: [batch_size, context_len]
		batch_size, context_len = context_words.shape
		
		# 步骤1：创建掩码（Mask），标识哪些位置是真实的上下文词（非PAD）
		# 假设PAD的索引是0，非PAD位置的掩码为True，PAD位置为False
		mask = (context_words != 0)  # [batch_size, context_len]
		
		# 步骤2：获取上下文词向量
		context_emb = self.input_embeddings(context_words)  # [batch, context_len, embed_dim]
		
		# 步骤3：应用掩码，将PAD位置的向量置零
		# 扩展掩码的维度以匹配词向量的形状：[batch, context_len, 1]
		mask_expanded = mask.unsqueeze(-1).float()
		context_emb_masked = context_emb * mask_expanded  # [batch, context_len, embed_dim]
		
		# 步骤4：计算有效上下文的均值（忽略PAD）
		# 求和：沿着context_len维度求和
		context_emb_sum = torch.sum(context_emb_masked, dim=1)  # [batch, embed_dim]
		
		# 计算有效上下文词的数量（每个样本的context_len减去PAD的数量）
		valid_word_counts = torch.sum(mask.float(), dim=1)  # [batch]
		
		# 避免除以零（如果某个样本的上下文全是PAD）
		valid_word_counts = valid_word_counts.clamp(min=1e-10)
		
		# 计算均值
		context_emb_mean = context_emb_sum / valid_word_counts.unsqueeze(-1)  # [batch, embed_dim]
		
		# 步骤5：计算目标词和负样本的词向量
		# 目标词和负样本通过输出嵌入层转换为向量，形状分别为 (batch_size, embedding_dim) 和 (batch_size, num_negatives, embedding_dim)。
		target_emb = self.output_embeddings(target_words)  # (batch, embed_dim)
		negative_emb = self.output_embeddings(negative_words)  # (batch, neg, embed_dim)
	
		# 计算正样本的损失
		# 分数计算：上下文向量与目标词向量的逐元素乘积之和（点积），表示两者的相似性。
		positive_score = torch.sum(context_emb_mean * target_emb, dim=1)  # (batch)
		# 损失转换：通过sigmoid将分数映射到(0,1)区间，取对数并添加极小值（1e-10）防止数值溢出。
		positive_loss = torch.log(torch.sigmoid(positive_score) + 1e-10)
	
		# 计算负样本的损失
		# 分数计算：context_emb.unsqueeze(2) 扩展维度为 (batch, embed_dim, 1)，torch.bmm（批量矩阵乘法）计算每个负样本与上下文向量的点积，得到形状 (batch_size, num_negatives)
		negative_score = torch.bmm(negative_emb, context_emb_mean.unsqueeze(2)).squeeze()  # (batch, neg)
		# 损失转换：对负样本分数取负号（因为希望负样本得分低），通过sigmoid和log计算损失，并对所有负样本求和。
		negative_loss = torch.sum(torch.log(torch.sigmoid(-negative_score) + 1e-10), dim=1)  # (batch)
	
		loss = -(positive_loss + negative_loss) # (batch)，负号是为了最小化loss
		return loss.mean()  # 平均loss

context_words = [
    [2, 3, 0],  # 样本1（第三个位置是PAD）
    [4, 1, 7]   # 样本2（无PAD）
]

from sklearn.feature_extraction.text import TfidfVectorizer

# 文档集合
documents = [
    "The cat is on the mat.",
    "The dog barked at the cat.",
    "The fox jumped over the dog.",
    "The lazy dog slept all day.",
    "A quick brown fox jumps high."
]

# 初始化TF-IDF向量器
vectorizer = TfidfVectorizer()

# 计算TF-IDF矩阵
tfidf_matrix = vectorizer.fit_transform(documents)

# 获取词汇表
feature_names = vectorizer.get_feature_names_out()

# 输出TF-IDF矩阵
import pandas as pd
df = pd.DataFrame(tfidf_matrix.toarray(), columns=feature_names)
import ace_tools as tools
tools.display_dataframe_to_user(name="TF-IDF 矩阵", dataframe=df)

import os
import thulac
import math
from collections import defaultdict

# 读取文件夹内容
def read_documents(folder_path):
    documents = []
    for filename in os.listdir(folder_path):
        if filename.endswith('.txt'):
            filepath = os.path.join(folder_path, filename)
            with open(filepath, 'r', encoding='utf-8') as f:
                text = f.read()
                documents.append(text)
    return documents

# 计算词频(TF)
def compute_tf(tokens):
    tf = defaultdict(int)
    for token in tokens:
        tf[token] += 1
    total_terms = len(tokens)
    for token in tf:
        tf[token] /= total_terms
    return tf

# 计算文档频率(DF)，这里算的是整个文档集合的频率
def compute_df(documents_tokens):
    df = defaultdict(int)
    for tokens in documents_tokens:
        unique_tokens = set(tokens)
        for token in unique_tokens:
            df[token] += 1
    return df

# 计算逆文档频率(IDF)
def compute_idf(df, total_docs):
    idf = {}
    for token, freq in df.items():
        idf[token] = math.log((total_docs + 1) / (1 + freq)) + 1
    return idf

# 计算TF-IDF
def compute_tfidf(documents_tokens, idf):
    tfidf = {}
    for i, tokens in enumerate(documents_tokens):
        tf = compute_tf(tokens)
        for token, tf_value in tf.items():
            tfidf_value = tf_value * idf[token]
            if i in tfidf:
                tfidf[i][token] = tfidf_value
            else:
                tfidf[i] = {token: tfidf_value}
    return tfidf

# 停用词处理
def remove_stopwords(filepath):
    with open(filepath, 'r', encoding='utf-8' ) as f:
        stopwords = f.read().split('\n')
    return stopwords

# 加载分词工具
thu1 = thulac.thulac(seg_only=True)
# print(type(thu1))

with open("作业用到的数据\homework2_input.txt", encoding='utf-8') as f:
    input_text = f.read()

folder_path = '作业用到的数据\homework2_Corpus'
documents = read_documents(folder_path)

documents = [input_text] + documents # 整个文档集合

stopwords_path = '作业用到的数据\homework2_stop.txt'
stopwords = remove_stopwords(stopwords_path)
stopwords += ['，', '。', '、', '“', '”'] # 手动添加一些停用词
# print(stopwords)

# 分词 + 去停用词，这里得到的是二维列表
documents_tokens = []
for document in documents:
    word_str = thu1.cut(document, text=True) # 分词
    word_list = word_str.split() # 词列表
    filtered_words = [word for word in word_list if word not in stopwords]  # 列表推导式
    documents_tokens.append(filtered_words)

df_results = compute_df(documents_tokens)
idf_results = compute_idf(df_results, len(documents))
tfidf_results = compute_tfidf(documents_tokens, idf_results)

# 输出第一个文档结果,按照TF-IDF值从大到小排序
sorted_items = sorted(tfidf_results[0].items(), key=lambda x: x[1], reverse=True)[:10]
print("前十个TF-IDF值最高的词：")
for word, score in sorted_items:
    print(f"{word}: {score:.4f}")

def compute_df(documents_tokens):
    df = defaultdict(int)
    for tokens in documents_tokens:
        unique_tokens = set(tokens)
        for token in unique_tokens:
            df[token] += 1
    return df

# 计算逆文档频率(IDF)
def compute_idf(df, total_docs):
    idf = {}
    for token, freq in df.items():
        idf[token] = math.log((total_docs + 1) / (1 + freq)) + 1
    return idf

d = {}
print(d['missing'])  # 试图访问不存在的键 'missing'

tf = {}
for token in tokens:
    tf[token] += 1

from collections import defaultdict

dd = defaultdict(int)
print(dd['apple'])  # 由于 'apple' 不存在，会自动调用 int() 返回 0，然后输出 0

from collections import defaultdict

tf = defaultdict(int)
for token in tokens:
    tf[token] += 1

import jieba
import networkx as nx
from collections import Counter
from itertools import combinations

def extract_keywords(text, top_k=5, window_size=2):
    # 1. 分词
    words = [w for w in jieba.cut(text) if len(w) > 1]
    
    # 2. 构建词图
    graph = nx.Graph()
    for w1, w2 in combinations(words, 2):
        if abs(words.index(w1) - words.index(w2)) < window_size:
            graph.add_edge(w1, w2)
    
    # 3. 计算 TextRank 评分
    scores = nx.pagerank(graph)

    # 4. 排序 & 选取关键词
    keywords = sorted(scores, key=scores.get, reverse=True)[:top_k]
    return keywords

text = "深度学习是机器学习的一个分支，它在图像识别、自然语言处理等领域表现优秀。"
print(extract_keywords(text))

import jieba
import jieba.analyse

with open('作业用到的数据\homework2_input.txt', 'r', encoding='utf-8') as f:
    text = f.read()
    
res = jieba.analyse.textrank(text, topK=10, withWeight=True, allowPOS=('ns', 'n'))

print(res)

import thulac
from matplotlib import pyplot as plt
import numpy as np
from collections import defaultdict

with open('作业用到的数据\homework2_input.txt', 'r', encoding='utf-8') as f:
    text = f.read()
    
with open('作业用到的数据\homework2_stop.txt', 'r', encoding='utf-8') as f:
    stopwords = f.read().split()

stopwords = ['，', '。', '“', '”', '、', '（', '）'] + stopwords

# 模型初始化
thu1 = thulac.thulac(seg_only=False)
words = thu1.cut(text)
# print(words)

# 只保留名词
words = [word[0] for word in words if word[1] == 'n']

# 去除停用词
words = [word for word in words if word not in stopwords]
# print(len(words))

def build_cooccurrence_graph(words, window_size=2):
    graph = defaultdict(lambda: defaultdict(int))  # 构建无向图
    for i in range(len(words)):
        for j in range(i + 1, i + window_size + 1):
            if j >= len(words):  # 超出窗口大小
                break
            w1 = words[i]  # 窗口左侧词
            w2 = words[j]  # 窗口右侧词
            if w1 == w2:  # 同一个词不参与构建图
                continue
            # 注意无向图
            graph[w1][w2] += 1  # 左侧词指向右侧词
            graph[w2][w1] += 1  # 右侧词指向左侧词
    
    return graph

graph = build_cooccurrence_graph(words)  # 构建图
# print(graph)

max_iter = 100  # 最大迭代次数
damping = 0.85  # 阻尼系数
nodes = len(graph)  # 节点数
min_diff = 1e-5 # 收敛值

rank = defaultdict(float)
# 初始化TextRank
rank = {node: 1/len(graph)  for node in graph}  # 初始化为 1/N
# 预计算每个节点的出边权重总和
outSum = {node: sum(graph[node].values()) for node in graph}

change = []

for iteration in range(max_iter):
    rank_new = {}  # 新一轮的TextRank
    max_change = 0  # 最大变化量
    for node in graph:  # 遍历图中的所有节点
        # print(f"正在处理节点 {node}")
        rank_sum = 0.0
        for neighbor in graph[node]:  # 遍历邻居
            # rank_sum += graph[node][neighbor] * (rank[neighbor] / len(graph[neighbor]))  # 计算TextRank
            rank_sum += (graph[node][neighbor] / outSum[neighbor]) * rank[neighbor]
            # rank_sum += (1 / len(graph[neighbor])) * rank[neighbor]
        rank_new[node] = (1 - damping) + damping * rank_sum  # 更新TextRank
        max_change = max(max_change, abs(rank_new[node] - rank[node]))  # 更新最大变化量
    change.append(max_change)
    # print(f"迭代 {iteration+1} 次，最大变化量：{max_change:.8f}")
    rank = rank_new
    if max_change < min_diff:  # 收敛
        print(f"迭代在第 {iteration+1} 次时收敛")
        break
    
rank_res = sorted(rank.items(), key=lambda x: x[1], reverse=True)[:10]
print(rank_res)

# 绘制change值变化图
plt.plot(change)
plt.xlabel("Iteration")
plt.ylabel("Change")
# plt.yscale("log")
plt.title("Change of max_change in each iteration")
plt.show()

import thulac
from matplotlib import pyplot as plt
from collections import defaultdict

# 读入文本与停用词
with open('作业用到的数据/homework2_input.txt', 'r', encoding='utf-8') as f:
    text = f.read()
with open('作业用到的数据/homework2_stop.txt', 'r', encoding='utf-8') as f:
    stopwords = f.read().split()

# 额外的标点符号停用词
stopwords = ['，', '。', '“', '”', '、', '（', '）'] + stopwords

# 模型初始化，分词并只保留名词
thu1 = thulac.thulac(seg_only=False)
words_tag = thu1.cut(text)
words = [word for word, tag in words_tag if tag == 'n']
# 去除停用词
words = [word for word in words if word not in stopwords]

# 建立单词到编号的映射
unique_words = list(set(words))
word_to_id = {w: i for i, w in enumerate(unique_words)}
id_to_word = {i: w for w, i in word_to_id.items()}
N = len(unique_words)

# 用滑动窗口统计共现（仅记一次，无向边只记录一份）
window_size = 2
edge_dict = {}  # key: (min(u, v), max(u, v))  value: 权重
for i in range(len(words)):
    u = word_to_id[words[i]]
    for j in range(i+1, min(i+window_size+1, len(words))):
        v = word_to_id[words[j]]
        if u == v:
            continue
        a, b = (u, v) if u < v else (v, u)
        edge_dict[(a, b)] = edge_dict.get((a, b), 0) + 1

# 使用链式前向星存储图（无向图，我们将每条边添加为双向，但权重只累加一次）
head = [-1] * N   # head[u]指向u的第一条边的下标
nxt = []        # nxt[i]指向同一节点的下一条边下标
to = []         # to[i]表示第i条边的终点
w_list = []     # w_list[i]表示第i条边的权重
edge_count = 0

def add_edge(u, v, weight):
    global edge_count
    nxt.append(head[u])
    to.append(v)
    w_list.append(weight)
    head[u] = edge_count
    edge_count += 1

# 根据边字典构造链式前向星——对于每条无向边 (u,v) 加入两条有向边
for (u, v), weight in edge_dict.items():
    add_edge(u, v, weight)
    add_edge(v, u, weight)

# 计算每个节点的邻边数（度数）
deg = [0] * N
for u in range(N):
    i = head[u]
    while i != -1:
        deg[u] += 1
        i = nxt[i]

# TextRank 算法参数设置
max_iter = 100
damping = 0.85
min_diff = 1e-5
rank = [1.0 / N] * N  # 初始得分均等
change_list = []

# 迭代更新得分
for iteration in range(max_iter):
    rank_new = [(1 - damping)] * N
    # 遍历每个节点，将其得分分摊给所有邻居
    for v in range(N):
        if deg[v] == 0:
            continue
        contribution = damping * rank[v] / deg[v]
        i = head[v]
        while i != -1:
            u = to[i]
            rank_new[u] += contribution
            i = nxt[i]
    max_change = max(abs(rank_new[i] - rank[i]) for i in range(N))
    change_list.append(max_change)
    rank = rank_new
    if max_change < min_diff:
        print(f"迭代在第 {iteration+1} 次时收敛")
        break

# 按得分排序，输出前10个关键词
rank_items = [(id_to_word[i], rank[i]) for i in range(N)]
rank_items.sort(key=lambda x: x[1], reverse=True)
top10 = rank_items[:10]
print("Top 10 关键词及其得分：")
for word, score in top10:
    print(word, score)

# 绘制每次迭代最大变化量图
plt.plot(change_list)
plt.xlabel("Iteration")
plt.ylabel("Max Change")
plt.title("Change of max_change in each iteration")
plt.show()

# 导入相关metrics
import jieba
import hanlp
import thulac
from nltk.metrics import precision, recall, f_measure

# 读入文件
# 待分词文件
with open('作业\homework1_input.txt', 'r', encoding='utf-8') as f:
    test = f.read() # 读取时是一整个字符串
    
# 标准分词文件
with open('作业\homework1_lac_labels.txt', 'r', encoding='utf-8') as f:
    answer = f.read()

answer = answer.split(" ") # 按空格分割，得到一个列表
# print(answer)

def evaluate(pred_sentence, gold_sentence):
    """使用nltk.metric评测f1值, precision, recall"""
    precision_score = precision(set(pred_sentence), set(gold_sentence))
    recall_score = recall(set(pred_sentence), set(gold_sentence))
    f1_score = f_measure(set(pred_sentence), set(gold_sentence))
    return precision_score, recall_score, f1_score

# 分词 jieba
jieba_res = jieba.cut(test, cut_all=False)
jieba_res = list(jieba_res)
# print(jieba_res)

# 评测
precision_jieba, recall_jieba, f1_jieba = evaluate(jieba_res, answer)
print("jieba分词结果: ", precision_jieba, recall_jieba, f1_jieba)

# hanlp
HanLP = hanlp.load(hanlp.pretrained.tok.COARSE_ELECTRA_SMALL_ZH)  # 加载模型
hanlp_res = HanLP(test)
# print(hanlp_res)

# 评测
precision_han, recall_han, f1_han = evaluate(hanlp_res, answer)
print("hanlp分词结果: ",precision_han, recall_han, f1_han)

# thulac
thulac_res = []
thu1 = thulac.thulac(seg_only=True)  # 注意这里要设置为True，否则会顺便进行词性标注，影响结果
thulac_res = thu1.cut(test, text=True)  # 注意这个的返回结果跟jieba和hanlp不同，thulac返回的还是字符串，要做split

thulac_res = thulac_res.split()
# print(thulac_res)

# 评测
precision_thu, recall_thu, f1_thu = evaluate(thulac_res, answer)
print("thulac分词结果: ", precision_thu, recall_thu, f1_thu)