AI开发第四课:Transfomer和BERT、GPT模型
·
01_Seq2Seq
import numpy as np
import torch
import random
import torch.nn as nn
# 构建语料库,每行包含中文、英文(解码器输入)和翻译成英文后的目标输出 3 个句子
sentences = [
# sos:start of sentence, 模型翻译的起始位置。
# eos:end of sentence,模型翻译的结束位置。
# 原始文本使用 空格 划分为token
# 原始文本、 解码输入、 解码输出
['毛老师 喜欢 人工智能', '<sos> TeacherMao likes AI', 'TeacherMao likes AI <eos>'],
['我 爱 学习 世界', '<sos> I love studying world', 'I love studying world <eos>'],
['深度学习 改变 世界', '<sos> DL changed the world', 'DL changed the world <eos>'],
['自然 语言 处理 很 强大', '<sos> NLP is so powerful', 'NLP is so powerful <eos>'],
['神经网络 非常 复杂', '<sos> Neural-Nets are complex', 'Neural-Nets are complex <eos>']
]
# 遍历每一个句子并将单词添加到词汇表中
word_list_cn, word_list_en = [], []
for s in sentences:
word_list_cn.extend(s[0].split())
word_list_en.extend(s[1].split())
word_list_en.extend(s[2].split())
# 去重,得到没有重复单词的词汇表
word_list_cn = list(set(word_list_cn)) # 词典 包含所有的单词,唯一一次就够
word_list_en = list(set(word_list_en))
# 构建单词到索引的映射(embeeding、rnn、lstm)
# 构建词汇表
word2idx_cn = {w: i for i, w in enumerate(word_list_cn)}
word2idx_en = {w: i for i, w in enumerate(word_list_en)}
# 构建索引到单词的映射
idx2word_cn = {i: w for i, w in enumerate(word_list_cn)}
idx2word_en = {i: w for i, w in enumerate(word_list_en)}
# 计算词汇表的大小
voc_size_cn = len(word_list_cn)
voc_size_en = len(word_list_en)
# 定义一个函数,随机选择一个句子和词汇表生成输入、输出和目标数据
def make_data(sentences):
# 随机选择一个句子进行训练
random_sentence = random.choice(sentences)
# 将输入句子中的单词转换为对应的索引
encoder_input = np.array([[word2idx_cn[n] for n in random_sentence[0].split()]])
# 将输出句子中的单词转换为对应的索引
decoder_input = np.array([[word2idx_en[n] for n in random_sentence[1].split()]])
# 将目标句子中的单词转换为对应的索引
target = np.array([[word2idx_en[n] for n in random_sentence[2].split()]])
# 将输入、输出和目标批次转换为 LongTensor
encoder_input = torch.LongTensor(encoder_input)
decoder_input = torch.LongTensor(decoder_input)
target = torch.LongTensor(target)
return encoder_input, decoder_input, target
# 使用 make_data 函数生成输入、输出和目标张量
encoder_input, decoder_input, target = make_data(sentences)
for s in sentences: # 获取原始句子
if all([word2idx_cn[w] in encoder_input[0] for w in s[0].split()]):
original_sentence = s
print(" 原始句子:", original_sentence) # 打印原始句子
print(" 编码器输入张量的形状:", encoder_input.shape) # 打印输入张量形状
print(" 解码器输入张量的形状:", decoder_input.shape) # 打印输出张量形状
print(" 目标张量的形状:", target.shape) # 打印目标张量形状
print(" 编码器输入张量:", encoder_input) # 打印输入张量
print(" 解码器输入张量:", decoder_input) # 打印输出张量
print(" 目标张量:", target) # 打印目标张量
# 定义编码器类,继承自 nn.Module
class Encoder(nn.Module):
# 将输入的序列编码成一个包含其全部语义信息的上下文向量
def __init__(self, input_size, hidden_size):
super(Encoder, self).__init__()
self.hidden_size = hidden_size # 设置隐藏层大小
self.embedding = nn.Embedding(input_size, hidden_size) # 创建词嵌入层 input_size 词表大小
self.rnn = nn.RNN(hidden_size, hidden_size, batch_first=True) # 创建 RNN 层
def forward(self, inputs, hidden): # 前向传播函数
embedded = self.embedding(inputs) # 将输入转换为嵌入向量
output, hidden = self.rnn(embedded, hidden) # 将嵌入向量输入 RNN 层并获取输出
return output, hidden
class Decoder(nn.Module):
def __init__(self, hidden_size, output_size):
super(Decoder, self).__init__()
self.hidden_size = hidden_size
self.embedding = nn.Embedding(output_size, hidden_size)
self.rnn = nn.RNN(hidden_size, hidden_size, batch_first=True)
# 全链接层,维度转换
self.out = nn.Linear(hidden_size, output_size) # 全连接层, 目标词汇表的大小
def forward(self, inputs, hidden):
embedded = self.embedding(inputs)
output, hidden = self.rnn(embedded, hidden)
output = self.out(output)
return output, hidden
n_hidden = 128 # 设置隐藏层数量
# 创建编码器和解码器
encoder = Encoder(voc_size_cn, n_hidden)
decoder = Decoder(n_hidden, voc_size_en)
print(' 编码器结构:', encoder) # 打印编码器的结构
print(' 解码器结构:', decoder) # 打印解码器的结构
class Seq2Seq(nn.Module):
def __init__(self, encoder, decoder):
super(Seq2Seq, self).__init__()
# 初始化编码器和解码器
self.encoder = encoder
self.decoder = decoder
def forward(self, enc_input, hidden, dec_input): # 定义前向传播函数
# enc_input 中文输入
# hidden 初始化状态
encoder_output, encoder_hidden = self.encoder(enc_input, hidden)
# encoder_hidden 最终隐藏状态
decoder_hidden = encoder_hidden
# 英文输入序列
decoder_output, _ = self.decoder(dec_input, decoder_hidden)
return decoder_output
model = Seq2Seq(encoder, decoder)
print('模型结构:', model)
# 定义训练函数
def train_seq2seq(model, criterion, optimizer, epochs):
for epoch in range(epochs): # epoch
# 文本 -》 id
encoder_input, decoder_input, target = make_data(sentences)
# 初始化编码器的初始隐藏状态
hidden = torch.zeros(1, encoder_input.size(0), n_hidden)
optimizer.zero_grad() # 梯度清零
output = model(encoder_input, hidden, decoder_input)
loss = criterion(output.view(-1, voc_size_en), target.view(-1)) # 分类
if (epoch + 1) % 100 == 0: # 打印损失
print(f"Epoch: {epoch + 1:04d} cost = {loss:.6f}")
loss.backward() # 反向传播
optimizer.step() # 更新参数
# 训练模型
epochs = 500 # 训练轮次
criterion = nn.CrossEntropyLoss() # 损失函数
optimizer = torch.optim.Adam(model.parameters(), lr=0.001) # 优化器
train_seq2seq(model, criterion, optimizer, epochs) # 调用函数训练模型
# 定义测试函数
def test_seq2seq(model, source_sentence):
# 将输入的句子转换为索引
encoder_input = np.array([[word2idx_cn[n] for n in source_sentence.split()]])
# 构建输出的句子的索引,以 '<sos>' 开始,后面跟 '<eos>',长度与输入句子相同
decoder_input = np.array([word2idx_en['<sos>']] + [word2idx_en['<eos>']] * (len(encoder_input[0]) - 1))
# 转换为 LongTensor 类型
encoder_input = torch.LongTensor(encoder_input)
decoder_input = torch.LongTensor(decoder_input).unsqueeze(0)
hidden = torch.zeros(1, encoder_input.size(0), n_hidden)
predict = model(encoder_input, hidden, decoder_input)
predict = predict.data.max(2, keepdim=True)[1] # 概率最大的单词
# 打印输入的句子和预测的句子
print(source_sentence, '->', [idx2word_en[n.item()] for n in predict.squeeze()])
# 测试模型
test_seq2seq(model, '毛老师 喜欢 人工智能') # 没有解码器输入
02_Attention
import torch
import torch.nn.functional as F
# 一个形状为 (batch_size, seq_len, feature_dim) 的张量(矩阵) x
# 两个样本, 每个样本3 个词语长度,每个词语编码为4维
x = torch.randn(2, 3, 4) # (batch_size, seq_len, feature_dim)
# 定义头数和每个头的维度
num_heads = 2
head_dim = 2
# feature_dim 必须是 num_heads * head_dim 的整数倍
assert x.size(-1) == num_heads * head_dim
# 定义线性层用于将 x 转换为 Q, K, V 向量
# Wq Wk Wv
linear_q = torch.nn.Linear(4, 4) # 每次创建全链接层,随机参数
linear_k = torch.nn.Linear(4, 4)
linear_v = torch.nn.Linear(4, 4)
# 通过线性层计算 Q, K, V
Q = linear_q(x) # (batch_size, seq_len, feature_dim)
K = linear_k(x) # (batch_size, seq_len, feature_dim)
V = linear_v(x) # (batch_size, seq_len, feature_dim)
# 将 Q, K, V 分割成 num_heads 个头
def split_heads(tensor, num_heads):
# (batch_size, seq_len, feature_dim) -》 (batch_size, num_heads, seq_len, feature_dim)
batch_size, seq_len, feature_dim = tensor.size()
head_dim = feature_dim // num_heads
output = tensor.view(batch_size, seq_len, num_heads, head_dim).transpose(1, 2)
# view 维度转换
# transpose 维度交换
# (batch_size, num_heads, seq_len, feature_dim)
return output
Q = split_heads(Q, num_heads) # (batch_size, num_heads, seq_len, head_dim)
K = split_heads(K, num_heads) # (batch_size, num_heads, seq_len, head_dim)
V = split_heads(V, num_heads) # (batch_size, num_heads, seq_len, head_dim)
# 计算 Q 和 K 的点积,作为相似度分数 , 也就是自注意力原始权重
# 第i行第j列:第i个词对第j个词的关注程度
raw_weights = torch.matmul(Q, K.transpose(-2, -1)) # (batch_size, num_heads, seq_len, seq_len)
# transpose(-2, -1) -》 (batch_size, num_heads, head_dim, seq_len)
# 对自注意力原始权重进行缩放, 防止梯度爆炸
scale_factor = K.size(-1) ** 0.5 # 根号 head_dim
scaled_weights = raw_weights / scale_factor # (batch_size, num_heads, seq_len, seq_len)
# 对缩放后的权重进行 softmax 归一化,得到注意力权重
# 归一化操作 / 激活函数
attn_weights = F.softmax(scaled_weights, dim=-1) # (batch_size, num_heads, seq_len, seq_len)
# 将注意力权重应用于 V 向量,计算加权和,得到加权信息
# 每个词的输出 = 该词对所有Value的加权平均
attn_outputs = torch.matmul(attn_weights, V) # (batch_size, num_heads, seq_len, head_dim)
def combine_heads(tensor, num_heads):
batch_size, num_heads, seq_len, head_dim = tensor.size()
feature_dim = num_heads * head_dim
output = tensor.transpose(1, 2).contiguous().view(batch_size, seq_len, feature_dim)
return output # (batch_size, seq_len, feature_dim)
attn_outputs = combine_heads(attn_outputs, num_heads) # (batch_size, seq_len, feature_dim)
# 对拼接后的结果进行线性变换
linear_out = torch.nn.Linear(4, 4)
attn_outputs = linear_out(attn_outputs) # (batch_size, seq_len, feature_dim)
print(" 加权信息 :", attn_outputs)
03_QKV
import torch
import torch.nn.functional as F
#1. 创建 Query、Key 和 Value 张量
q = torch.randn(2, 3, 4) # 形状 (batch_size, seq_len1, feature_dim)
k = torch.randn(2, 4, 4) # 形状 (batch_size, seq_len2, feature_dim)
v = torch.randn(2, 4, 4) # 形状 (batch_size, seq_len2, feature_dim)
# 2. 计算点积,得到原始权重,形状为 (batch_size, seq_len1, seq_len2)
# 批量矩阵乘法 Batched Matrix Multiplication
raw_weights = torch.bmm(q, k.transpose(1, 2))
# 3. 将原始权重进行缩放(可选),形状仍为 (batch_size, seq_len1, seq_len2)
scaling_factor = q.size(-1) ** 0.5
scaled_weights = raw_weights / scaling_factor
# 4. 应用 softmax 函数,使结果的值在 0 和 1 之间,且每一行的和为 1
attn_weights = F.softmax(scaled_weights, dim=-1) # 形状仍为 (batch_size, seq_len1, seq_len2)
# 5. 与 Value 相乘,得到注意力分布的加权和 , 形状为 (batch_size, seq_len1, feature_dim)
attn_output = torch.bmm(attn_weights, v)
04_Seq2Seq_with_Attention
import numpy as np
import torch
import random
import torch.nn as nn
import matplotlib.pyplot as plt # 导入 matplotlib
import seaborn as sns # 导入 seaborn
plt.rcParams["font.family"] = ['SimHei'] # 用来设定字体样式
plt.rcParams['font.sans-serif'] = ['SimHei'] # 用来设定无衬线字体样式
plt.rcParams['axes.unicode_minus'] = False # 用 来 正 常 显 示 负 号
# 加入的文本
# 我 今天 喜欢 深度学习,但明天 喜欢 机器学习。
# 构建语料库,每行包含中文、英文(解码器输入)和翻译成英文后的目标输出 3 个句子
sentences = [
['毛老师 喜欢 人工智能', '<sos> TeacherMao likes AI', 'TeacherMao likes AI <eos>'],
['我 爱 学习 世界', '<sos> I love studying world', 'I love studying world <eos>'],
['深度学习 改变 世界', '<sos> DL changed the world', 'DL changed the world <eos>'],
['自然 语言 处理 很 强大', '<sos> NLP is so powerful', 'NLP is so powerful <eos>'],
['神经网络 非常 复杂', '<sos> Neural-Nets are complex', 'Neural-Nets are complex <eos>']
]
word_list_cn, word_list_en = [], []
for s in sentences:
word_list_cn.extend(s[0].split())
word_list_en.extend(s[1].split())
word_list_en.extend(s[2].split())
# 去重,得到没有重复单词的词汇表
word_list_cn = list(set(word_list_cn))
word_list_en = list(set(word_list_en))
# 构建单词到索引的映射
word2idx_cn = {w: i for i, w in enumerate(word_list_cn)}
word2idx_en = {w: i for i, w in enumerate(word_list_en)}
# 构建索引到单词的映射
idx2word_cn = {i: w for i, w in enumerate(word_list_cn)}
idx2word_en = {i: w for i, w in enumerate(word_list_en)}
# 计算词汇表的大小
voc_size_cn = len(word_list_cn)
voc_size_en = len(word_list_en)
def make_data(sentences):
# 随机选择一个句子进行训练
random_sentence = random.choice(sentences)
# 将输入句子中的单词转换为对应的索引
encoder_input = np.array([[word2idx_cn[n] for n in random_sentence[0].split()]])
# 将输出句子中的单词转换为对应的索引
decoder_input = np.array([[word2idx_en[n] for n in random_sentence[1].split()]])
# 将目标句子中的单词转换为对应的索引
target = np.array([[word2idx_en[n] for n in random_sentence[2].split()]])
# 将输入、输出和目标批次转换为 LongTensor
encoder_input = torch.LongTensor(encoder_input)
decoder_input = torch.LongTensor(decoder_input)
target = torch.LongTensor(target)
return encoder_input, decoder_input, target
encoder_input, decoder_input, target = make_data(sentences)
for s in sentences:
if all([word2idx_cn[w] in encoder_input[0] for w in s[0].split()]):
original_sentence = s
class Attention(nn.Module):
# 点积注意力(Dot-Product Attention)
def __init__(self):
super(Attention, self).__init__()
def forward(self, decoder_context, encoder_context):
# 计算 decoder_context 和 encoder_context 的点积,得到注意力分数
scores = torch.matmul(decoder_context, encoder_context.transpose(-2, -1))
# 归一化分数
attn_weights = nn.functional.softmax(scores, dim=-1)
# 将注意力权重乘以 encoder_context,得到加权的上下文向量
context = torch.matmul(attn_weights, encoder_context)
return context, attn_weights
class Encoder(nn.Module):
def __init__(self, input_size, hidden_size):
super(Encoder, self).__init__()
self.hidden_size = hidden_size # 设置隐藏层大小
self.embedding = nn.Embedding(input_size, hidden_size) # 创建词嵌入层
self.rnn = nn.RNN(hidden_size, hidden_size, batch_first=True) # 创建 RNN 层
def forward(self, inputs, hidden): # 前向传播函数
embedded = self.embedding(inputs) # 将输入转换为嵌入向量
output, hidden = self.rnn(embedded, hidden) # 将嵌入向量输入 RNN 层并获取输出
return output, hidden
# 定义解码器类
class DecoderWithAttention(nn.Module):
def __init__(self, hidden_size, output_size):
super(DecoderWithAttention, self).__init__()
self.hidden_size = hidden_size # 设置隐藏层大小
self.embedding = nn.Embedding(output_size, hidden_size) # 创建词嵌入层
self.rnn = nn.RNN(hidden_size, hidden_size, batch_first=True) # 创建 RNN 层
self.attention = Attention() # 创建注意力层
self.out = nn.Linear(2 * hidden_size, output_size) # 修改线性输出层,考虑隐藏状态和上下文向量
def forward(self, dec_input, hidden, enc_output):
embedded = self.embedding(dec_input) # 将输入转换为嵌入向量
rnn_output, hidden = self.rnn(embedded, hidden) # 将嵌入向量输入 RNN 层并获取输出
context, attn_weights = self.attention(rnn_output, enc_output) # 计算注意力上下文向量
dec_output = torch.cat((rnn_output, context), dim=-1) # 将上下文向量与解码器的输出拼接
dec_output = self.out(dec_output) # 使用线性层生成最终输出
return dec_output, hidden, attn_weights
n_hidden = 128 # 设置隐藏层数量
# 创建编码器和解码器
encoder = Encoder(voc_size_cn, n_hidden)
decoder = DecoderWithAttention(n_hidden, voc_size_en)
print(' 编码器结构:', encoder) # 打印编码器的结构
print(' 解码器结构:', decoder) # 打印解码器的结构
# 定义 Seq2Seq 类
class Seq2Seq(nn.Module):
def __init__(self, encoder, decoder):
super(Seq2Seq, self).__init__()
# 初始化编码器和解码器
self.encoder = encoder
self.decoder = decoder
def forward(self, encoder_input, hidden, decoder_input):
# 将输入序列通过编码器并获取输出和隐藏状态
encoder_output, encoder_hidden = self.encoder(encoder_input, hidden)
# 将编码器的隐藏状态传递给解码器作为初始隐藏状态
decoder_hidden = encoder_hidden
# 将目标序列通过解码器并获取输出 - 此处更新解码器调用
decoder_output, _, attn_weights = self.decoder(decoder_input, decoder_hidden, encoder_output)
return decoder_output, attn_weights
# 创建 Seq2Seq 模型
model = Seq2Seq(encoder, decoder)
print('模型结构:', model) # 打印模型的结构
# 定义训练函数
def train_seq2seq(model, criterion, optimizer, epochs):
for epoch in range(epochs):
encoder_input, decoder_input, target = make_data(sentences) # 训练数据的创建
hidden = torch.zeros(1, encoder_input.size(0), n_hidden) # 初始化隐藏状态
optimizer.zero_grad() # 梯度清零
output, _ = model(encoder_input, hidden, decoder_input) # 获取模型输出
loss = criterion(output.view(-1, voc_size_en), target.view(-1)) # 计算损失
if (epoch + 1) % 40 == 0: # 打印损失
print(f"Epoch: {epoch + 1:04d} cost = {loss:.6f}")
loss.backward() # 反向传播
optimizer.step() # 更新参数
# 训练模型
epochs = 400 # 训练轮次
criterion = nn.CrossEntropyLoss() # 损失函数
optimizer = torch.optim.Adam(model.parameters(), lr=0.001) # 优化器
train_seq2seq(model, criterion, optimizer, epochs) # 调用函数训练模型
def visualize_attention(source_sentence, predicted_sentence, attn_weights):
plt.figure(figsize=(10, 10)) # 画布
ax = sns.heatmap(attn_weights, annot=True, cbar=False,
xticklabels=source_sentence.split(),
yticklabels=predicted_sentence, cmap="Greens") # 热力图
plt.xlabel(" 源序列 ")
plt.ylabel(" 目标序列 ")
plt.show() # 显示图片
# 定义测试函数
def test_seq2seq(model, source_sentence):
# 将输入的句子转换为索引
encoder_input = np.array([[word2idx_cn[n] for n in source_sentence.split()]])
# 构建输出的句子的索引,以 '<sos>' 开始,后面跟 '<eos>',长度与输入句子相同
decoder_input = np.array([word2idx_en['<sos>']] + [word2idx_en['<eos>']] * (len(encoder_input[0]) - 1))
# 转换为 LongTensor 类型
encoder_input = torch.LongTensor(encoder_input)
decoder_input = torch.LongTensor(decoder_input).unsqueeze(0) # 增加一维
hidden = torch.zeros(1, encoder_input.size(0), n_hidden) # 初始化隐藏状态
# 获取模型输出和注意力权重
predict, attn_weights = model(encoder_input, hidden, decoder_input)
predict = predict.data.max(2, keepdim=True)[1] # 获取概率最大的索引
# 打印输入的句子和预测的句子
print(source_sentence, '->', [idx2word_en[n.item()] for n in predict.squeeze()])
# 可视化注意力权重
attn_weights = attn_weights.squeeze(0).cpu().detach().numpy()
visualize_attention(source_sentence, [idx2word_en[n.item()] for n in predict.squeeze()], attn_weights)
# 测试模型
test_seq2seq(model, '毛老师 喜欢 人工智能')
05_Transformer
import numpy as np # 导入 numpy 库,用于科学计算
import torch # 导入 torch 库,用于构建神经网络
import torch.nn as nn # 导入 torch.nn 库,包含了各种神经网络层
from collections import Counter
# --- 全局参数 ---
d_k = 64 # Q 和 K 向量的维度
d_v = 64 # V 向量的维度
d_embedding = 128 # 词嵌入的维度
n_heads = 8 # 多头注意力机制中头的数量
n_layers = 6 # 编码器和解码器的层数
batch_size = 3 # 训练批次大小
epochs = 10 # 训练轮次
# --- 注意力机制模块 ---
class ScaledDotProductAttention(nn.Module):
"""
缩放点积注意力模块
根据 Q、K、V 计算注意力分数和上下文向量
"""
def __init__(self):
super(ScaledDotProductAttention, self).__init__()
def forward(self, Q, K, V, attn_mask):
# 1. 计算注意力分数
# 将 Q 与 K 的转置相乘,并除以 sqrt(d_k) 进行缩放
# scores 的维度: [batch_size, n_heads, len_q, len_k]
scores = torch.matmul(Q, K.transpose(-1, -2)) / np.sqrt(d_k)
# 2. 应用注意力掩码
# 将 attn_mask 中为 True 的位置的 scores 替换为一个极小值 (-1e9)
# 这样在 softmax 之后,这些位置的权重将接近于0
scores.masked_fill_(attn_mask, -1e9)
# 3. 对分数进行 softmax 归一化
# 沿着最后一个维度 (len_k) 进行 softmax
# weights 的维度: [batch_size, n_heads, len_q, len_k]
weights = nn.Softmax(dim=-1)(scores)
# 4. 计算上下文向量
# 将归一化后的权重与 V 相乘
# context 的维度: [batch_size, n_heads, len_q, dim_v]
context = torch.matmul(weights, V)
# 返回上下文向量和注意力权重
return context, weights
# 层的用途是什么?
# 层的输入和输出维度是什么?
class MultiHeadAttention(nn.Module):
"""
多头注意力机制模块
将输入投影到多个子空间,并并行计算注意力,最后将结果拼接
"""
def __init__(self):
super(MultiHeadAttention, self).__init__()
# 线性投影层,用于生成 Q, K, V
self.W_Q = nn.Linear(d_embedding, d_k * n_heads)
self.W_K = nn.Linear(d_embedding, d_k * n_heads)
self.W_V = nn.Linear(d_embedding, d_v * n_heads)
# 最后的线性层,将拼接后的多头输出投影回原始维度
self.linear = nn.Linear(n_heads * d_v, d_embedding)
# 层归一化(Layer Normalization), 样本的特征进行归一化,使其均值为 0,方差为 1
self.layer_norm = nn.LayerNorm(d_embedding)
def forward(self, Q, K, V, attn_mask):
# Q, K, V 的维度: [batch_size, len_q/k/v, d_embedding]
residual, batch_size = Q, Q.size(0)
# 1. 线性投影并重塑
# 将输入 Q, K, V 投影到多头子空间,并调整维度以便并行计算
# .view() 和 .transpose() 操作将维度变为: [batch_size, n_heads, len_q/k/v, d_q=k/v]
q_s = self.W_Q(Q).view(batch_size, -1, n_heads, d_k).transpose(1, 2)
k_s = self.W_K(K).view(batch_size, -1, n_heads, d_k).transpose(1, 2)
v_s = self.W_V(V).view(batch_size, -1, n_heads, d_v).transpose(1, 2)
# 2. 复制注意力掩码
# 将 attn_mask 复制 n_heads 次,以适应多头注意力
# attn_mask 的维度: [batch_size, n_heads, len_q, len_k]
attn_mask = attn_mask.unsqueeze(1).repeat(1, n_heads, 1, 1)
# 3. 计算缩放点积注意力
context, weights = ScaledDotProductAttention()(q_s, k_s, v_s, attn_mask)
# context 的维度: [batch_size, n_heads, len_q, dim_v]
# weights 的维度: [batch_size, n_heads, len_q, len_k]
# 4. 拼接多头结果
# 调整维度并使用 .contiguous() 确保内存连续,然后用 .view() 将多头结果拼接
# context 的维度: [batch_size, len_q, n_heads * dim_v]
context = context.transpose(1, 2).contiguous().view(batch_size, -1, n_heads * d_v)
# 5. 最终线性投影和层归一化
# 将拼接后的结果通过线性层投影回 d_embedding 维度
output = self.linear(context)
# 将输出与残差连接相加,并进行层归一化
# output 的维度: [batch_size, len_q, d_embedding]
output = self.layer_norm(output + residual)
# 返回最终输出和注意力权重
return output, weights
# --- 前馈网络模块 ---
class PoswiseFeedForwardNet(nn.Module):
"""
逐位置前馈网络模块
对序列中的每个位置独立地应用一个全连接前馈网络
"""
def __init__(self, d_ff=2048):
super(PoswiseFeedForwardNet, self).__init__()
# 两个一维卷积层,相当于两个全连接层 (实现的结果、做维度变换)
self.conv1 = nn.Conv1d(in_channels=d_embedding, out_channels=d_ff, kernel_size=1) # nn.Linear nn.Conv1d 维度转换
self.conv2 = nn.Conv1d(in_channels=d_ff, out_channels=d_embedding, kernel_size=1)
# 层归一化
self.layer_norm = nn.LayerNorm(d_embedding)
def forward(self, inputs):
# inputs 的维度: [batch_size, len_q, d_embedding]
residual = inputs
# 1. 维度转换并应用第一个卷积层
# inputs.transpose(1, 2) 将维度变为 [batch_size, d_embedding, len_q]
# 卷积操作后,output 的维度: [batch_size, d_ff, len_q]
output = nn.ReLU()(self.conv1(inputs.transpose(1, 2)))
# 2. 应用第二个卷积层并转换维度
# 卷积操作后,output 的维度: [batch_size, d_embedding, len_q]
# .transpose(1, 2) 将维度恢复为 [batch_size, len_q, d_embedding]
output = self.conv2(output).transpose(1, 2)
# 3. 残差连接和层归一化
output = self.layer_norm(output + residual)
return output
# --- 位置编码和掩码函数 ---
def get_sin_enc_table(n_position, embedding_dim):
"""
生成正弦位置编码表
用于在序列中引入词语的绝对位置信息
"""
# 初始化正弦编码表
sinusoid_table = np.zeros((n_position, embedding_dim))
# 计算不同位置和维度的角度
for pos_i in range(n_position):
for hid_j in range(embedding_dim):
angle = pos_i / np.power(10000, 2 * (hid_j // 2) / embedding_dim)
sinusoid_table[pos_i, hid_j] = angle
# 将偶数维应用 sin 函数,奇数维应用 cos 函数
sinusoid_table[:, 0::2] = np.sin(sinusoid_table[:, 0::2])
sinusoid_table[:, 1::2] = np.cos(sinusoid_table[:, 1::2])
# 转换为 PyTorch 张量
return torch.FloatTensor(sinusoid_table)
def get_attn_pad_mask(seq_q, seq_k):
"""
生成填充注意力掩码
用于在注意力计算中忽略填充 <pad> 词语 特殊的词
"""
# seq_q 的维度: [batch_size, len_q]
# seq_k 的维度: [batch_size, len_k]
batch_size, len_q = seq_q.size()
batch_size, len_k = seq_k.size()
# 找到 seq_k 中所有值为 0 (<pad>) 的位置
# pad_attn_mask 的维度: [batch_size, 1, len_k]
pad_attn_mask = seq_k.data.eq(0).unsqueeze(1)
# 将掩码扩展到与注意力分数相同的形状
# pad_attn_mask 的维度: [batch_size, len_q, len_k]
pad_attn_mask = pad_attn_mask.expand(batch_size, len_q, len_k)
return pad_attn_mask
def get_attn_subsequent_mask(seq):
"""
生成后续注意力掩码 (仅用于解码器)
用于在注意力计算中忽略当前位置之后的信息,防止信息泄露
"""
# seq 的维度: [batch_size, seq_len]
attn_shape = [seq.size(0), seq.size(1), seq.size(1)]
# 创建一个上三角矩阵,k=1 表示主对角线上方的元素为 1
# subsequent_mask 的维度: [batch_size, seq_len, seq_len]
subsequent_mask = np.triu(np.ones(attn_shape), k=1)
# 转换为 PyTorch 字节张量 (布尔类型)
subsequent_mask = torch.from_numpy(subsequent_mask).byte()
return subsequent_mask
# --- 编码器和解码器模块 ---
class EncoderLayer(nn.Module):
"""
编码器的一层
包含一个多头自注意力层和一个位置前馈网络
"""
def __init__(self):
super(EncoderLayer, self).__init__()
self.enc_self_attn = MultiHeadAttention()
self.pos_ffn = PoswiseFeedForwardNet()
def forward(self, enc_inputs, enc_self_attn_mask):
# enc_inputs 的维度: [batch_size, seq_len, d_embedding]
# enc_self_attn_mask 的维度: [batch_size, seq_len, seq_len]
# 将相同的 Q, K, V 输入多头自注意力层
enc_outputs, attn_weights = self.enc_self_attn(enc_inputs, enc_inputs,
enc_inputs, enc_self_attn_mask)
# 将自注意力输出输入位置前馈网络
enc_outputs = self.pos_ffn(enc_outputs)
# 返回最终输出和注意力权重
return enc_outputs, attn_weights
class Encoder(nn.Module):
"""
Transformer 编码器
由词嵌入层、位置嵌入层和多个编码器层组成
"""
def __init__(self, corpus):
super(Encoder, self).__init__()
self.src_emb = nn.Embedding(len(corpus.src_vocab), d_embedding)
# 从预计算的位置编码表初始化位置嵌入层,并冻结参数
self.pos_emb = nn.Embedding.from_pretrained(
get_sin_enc_table(corpus.src_len + 1, d_embedding), freeze=True)
# 堆叠 n_layers 个编码器层
self.layers = nn.ModuleList(EncoderLayer() for _ in range(n_layers))
def forward(self, enc_inputs):
# enc_inputs 的维度: [batch_size, source_len]
# 生成位置索引序列
pos_indices = torch.arange(1, enc_inputs.size(1) + 1).unsqueeze(0).to(enc_inputs)
# 词嵌入和位置嵌入相加
enc_outputs = self.src_emb(enc_inputs) + self.pos_emb(pos_indices)
# 生成填充注意力掩码
enc_self_attn_mask = get_attn_pad_mask(enc_inputs, enc_inputs)
enc_self_attn_weights = []
# 逐层通过编码器层
for layer in self.layers:
enc_outputs, enc_self_attn_weight = layer(enc_outputs, enc_self_attn_mask)
enc_self_attn_weights.append(enc_self_attn_weight)
# 返回最终输出和所有层的注意力权重
return enc_outputs, enc_self_attn_weights
class DecoderLayer(nn.Module):
"""
解码器的一层
包含一个多头自注意力层、一个编码器-解码器注意力层和一个位置前馈网络
"""
def __init__(self):
super(DecoderLayer, self).__init__()
self.dec_self_attn = MultiHeadAttention()
self.dec_enc_attn = MultiHeadAttention()
self.pos_ffn = PoswiseFeedForwardNet()
def forward(self, dec_inputs, enc_outputs, dec_self_attn_mask, dec_enc_attn_mask):
# dec_inputs 的维度: [batch_size, target_len, d_embedding]
# enc_outputs 的维度: [batch_size, source_len, d_embedding]
# 1. 第一个注意力子层: 多头自注意力
# Q, K, V 都来自解码器输入
dec_outputs, dec_self_attn = self.dec_self_attn(dec_inputs, dec_inputs,
dec_inputs, dec_self_attn_mask)
# 2. 第二个注意力子层: 编码器-解码器注意力
# Q 来自解码器输出,K, V 来自编码器输出
dec_outputs, dec_enc_attn = self.dec_enc_attn(dec_outputs, enc_outputs,
enc_outputs, dec_enc_attn_mask)
# 3. 位置前馈网络
dec_outputs = self.pos_ffn(dec_outputs)
# 返回最终输出和两个注意力层的权重
return dec_outputs, dec_self_attn, dec_enc_attn
class Decoder(nn.Module):
"""
Transformer 解码器
由词嵌入层、位置嵌入层和多个解码器层组成
"""
def __init__(self, corpus):
super(Decoder, self).__init__()
self.tgt_emb = nn.Embedding(len(corpus.tgt_vocab), d_embedding)
# 从预计算的位置编码表初始化位置嵌入层,并冻结参数
self.pos_emb = nn.Embedding.from_pretrained(
get_sin_enc_table(corpus.tgt_len + 1, d_embedding), freeze=True)
# 堆叠 n_layers 个解码器层
self.layers = nn.ModuleList([DecoderLayer() for _ in range(n_layers)])
def forward(self, dec_inputs, enc_inputs, enc_outputs):
# dec_inputs 的维度: [batch_size, target_len]
# enc_inputs 的维度: [batch_size, source_len]
# enc_outputs 的维度: [batch_size, source_len, d_embedding]
# 生成位置索引序列
pos_indices = torch.arange(1, dec_inputs.size(1) + 1).unsqueeze(0).to(dec_inputs)
# 词嵌入和位置嵌入相加
dec_outputs = self.tgt_emb(dec_inputs) + self.pos_emb(pos_indices)
# 1. 生成解码器自注意力掩码
dec_self_attn_pad_mask = get_attn_pad_mask(dec_inputs, dec_inputs)
dec_self_attn_subsequent_mask = get_attn_subsequent_mask(dec_inputs)
# 将填充掩码和后续掩码相加,结果大于 0 的位置为 True
dec_self_attn_mask = torch.gt((dec_self_attn_pad_mask
+ dec_self_attn_subsequent_mask), 0)
# 2. 生成编码器-解码器注意力掩码 (仅考虑填充)
dec_enc_attn_mask = get_attn_pad_mask(dec_inputs, enc_inputs)
dec_self_attns, dec_enc_attns = [], []
# 逐层通过解码器层
for layer in self.layers:
dec_outputs, dec_self_attn, dec_enc_attn = layer(dec_outputs, enc_outputs,
dec_self_attn_mask, dec_enc_attn_mask)
dec_self_attns.append(dec_self_attn)
dec_enc_attns.append(dec_enc_attn)
# 返回最终输出和所有层的注意力权重
return dec_outputs, dec_self_attns, dec_enc_attns
# --- Transformer 模型 ---
class Transformer(nn.Module):
"""
Transformer 模型的总框架
由编码器、解码器和最后的线性投影层组成
"""
def __init__(self, corpus):
super(Transformer, self).__init__()
self.encoder = Encoder(corpus)
self.decoder = Decoder(corpus)
# 最后的线性层,将解码器输出映射到目标词汇表大小
self.projection = nn.Linear(d_embedding, len(corpus.tgt_vocab), bias=False)
def forward(self, enc_inputs, dec_inputs):
# enc_inputs 的维度: [batch_size, source_seq_len]
# dec_inputs 的维度: [batch_size, target_seq_len]
# 1. 编码器前向传播
enc_outputs, enc_self_attns = self.encoder(enc_inputs)
# enc_outputs 的维度: [batch_size, source_len, d_embedding]
# 2. 解码器前向传播
dec_outputs, dec_self_attns, dec_enc_attns = self.decoder(dec_inputs, enc_inputs, enc_outputs)
# dec_outputs 的维度: [batch_size, target_len, d_embedding]
# 3. 线性投影
dec_logits = self.projection(dec_outputs)
# dec_logits 的维度: [batch_size, target_len, tgt_vocab_size]
# 返回逻辑值和所有注意力权重
return dec_logits, enc_self_attns, dec_self_attns, dec_enc_attns
class TranslationCorpus:
"""
数据处理类,用于管理语料库、词汇表和批次生成
"""
def __init__(self, sentences):
self.sentences = sentences
self.src_len = max(len(sentence[0].split()) for sentence in sentences) + 1
self.tgt_len = max(len(sentence[1].split()) for sentence in sentences) + 2
self.src_vocab, self.tgt_vocab = self.create_vocabularies()
self.src_idx2word = {v: k for k, v in self.src_vocab.items()}
self.tgt_idx2word = {v: k for k, v in self.tgt_vocab.items()}
def create_vocabularies(self):
src_counter = Counter(word for sentence in self.sentences for word in sentence[0].split())
tgt_counter = Counter(word for sentence in self.sentences for word in sentence[1].split())
src_vocab = {'<pad>': 0, **{word: i + 1 for i, word in enumerate(src_counter)}}
tgt_vocab = {'<pad>': 0, '<sos>': 1, '<eos>': 2,
**{word: i + 3 for i, word in enumerate(tgt_counter)}}
return src_vocab, tgt_vocab
def make_batch(self, batch_size, test_batch=False):
input_batch, output_batch, target_batch = [], [], []
# 随机选择句子索引
sentence_indices = torch.randperm(len(self.sentences))[:batch_size]
for index in sentence_indices:
src_sentence, tgt_sentence = self.sentences[index]
# 将句子转换为索引序列
src_seq = [self.src_vocab[word] for word in src_sentence.split()]
tgt_seq = ([self.tgt_vocab['<sos>']] +
[self.tgt_vocab[word] for word in tgt_sentence.split()] +
[self.tgt_vocab['<eos>']])
# 对序列进行填充
src_seq += [self.src_vocab['<pad>']] * (self.src_len - len(src_seq))
tgt_seq += [self.tgt_vocab['<pad>']] * (self.tgt_len - len(tgt_seq))
input_batch.append(src_seq)
# 在测试模式下,解码器输入只包含 <sos> 符号
output_batch.append([self.tgt_vocab['<sos>']] +
([self.tgt_vocab['<pad>']] * (self.tgt_len - 2)) if test_batch else tgt_seq[:-1])
target_batch.append(tgt_seq[1:])
return torch.LongTensor(input_batch), torch.LongTensor(output_batch), torch.LongTensor(target_batch)
# --- 训练和推理 ---
# 定义语料库
sentences = [
# 原始句子 目标输出
['毛老师 喜欢 人工智能', 'TeacherMao likes AI'], # 一个样本
['我 爱 学习 人工智能', 'I love studying AI'],
['深度学习 改变 世界', ' DL changed the world'],
['自然语言处理 很 强大', 'NLP is powerful'],
['神经网络 非常 复杂', 'Neural-networks are complex']
]
# 创建语料库实例
corpus = TranslationCorpus(sentences)
# 实例化模型、损失函数和优化器
model = Transformer(corpus)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.0001)
# 模型训练
print("--- 开始训练 ---")
for epoch in range(epochs):
optimizer.zero_grad()
enc_inputs, dec_inputs, target_batch = corpus.make_batch(batch_size)
outputs, _, _, _ = model(enc_inputs, dec_inputs)
# 调整输出和目标张量维度以适应损失函数
loss = criterion(outputs.view(-1, len(corpus.tgt_vocab)), target_batch.view(-1))
if (epoch + 1) % 1 == 0:
print(f"Epoch: {epoch + 1:04d} cost = {loss:.6f}")
loss.backward()
optimizer.step()
# 模型推理 (翻译)
print("\n--- 开始翻译 ---")
# 创建一个大小为 1 的测试批次
# enc_inputs 原始文本
# dec_inputs 目标文本,推理时候, 可以只包含 <sos>
enc_inputs, dec_inputs, target_batch = corpus.make_batch(batch_size=1, test_batch=True)
# 打印输入数据
print("编码器输入 :", enc_inputs)
print("解码器输入 :", dec_inputs)
print("目标数据 :", target_batch)
# 进行翻译预测
# 解码的结果
predict, enc_self_attns, dec_self_attns, dec_enc_attns = model(enc_inputs, dec_inputs)
# 后处理预测结果
predict = predict.view(-1, len(corpus.tgt_vocab))
predict = predict.data.max(1, keepdim=True)[1] # 贪婪解码(Greedy Decoding)
# 将索引转换为单词
translated_sentence = [corpus.tgt_idx2word[idx.item()] for idx in predict.squeeze()]
input_sentence = ' '.join([corpus.src_idx2word[idx.item()] for idx in enc_inputs[0]])
# 打印翻译结果
print(f"输入句子: '{input_sentence}'")
print(f"翻译结果: '{' '.join(translated_sentence)}'")
# Transformer 原理 和 内部结构 -》 面试、 理解专业名词使用用
# 1. 自己不会从头搭建 Transformer -》 用pytorch内置
# 2. 在特定的任务中会使用领域模型(BERT、GPT) 内置了 Transformer -》 用 BERT、GPT
06_GPT
import numpy as np # 导入 numpy 库
import torch # 导入 torch 库
import torch.nn as nn # 导入 torch.nn 库
import torch.optim as optim # 导入优化器
from collections import Counter
d_k = 64 # K(=Q) 维度
d_v = 64 # V 维度
# 定义缩放点积注意力类
class ScaledDotProductAttention(nn.Module):
def __init__(self):
super(ScaledDotProductAttention, self).__init__()
def forward(self, Q, K, V, attn_mask):
# Q K V [batch_size, n_heads, len_q/k/v, dim_q=k/v] (dim_q=dim_k)
# attn_mask [batch_size, n_heads, len_q, len_k]
# 计算注意力分数(原始权重)[batch_size,n_heads,len_q,len_k]
scores = torch.matmul(Q, K.transpose(-1, -2)) / np.sqrt(d_k)
# scores [batch_size, n_heads, len_q, len_k]
# 使用注意力掩码,将 attn_mask 中值为 1 的位置的权重替换为极小值
# attn_mask [batch_size, n_heads, len_q, len_k], 形状和 scores 相同
scores.masked_fill_(attn_mask.bool(), -1e9)
# 对注意力分数进行 softmax 归一化
weights = nn.Softmax(dim=-1)(scores)
# weights [batch_size, n_heads, len_q, len_k], 形状和 scores 相同
# 计算上下文向量(也就是注意力的输出), 是上下文信息的紧凑表示
context = torch.matmul(weights, V)
# context [batch_size, n_heads, len_q, dim_v]
return context, weights # 返回上下文向量和注意力分数
# 定义多头自注意力类
d_embedding = 512 # Embedding 的维度
n_heads = 8 # Multi-Head Attention 中头的个数
batch_size = 3 # 每一批的数据大小
class MultiHeadAttention(nn.Module):
def __init__(self):
super(MultiHeadAttention, self).__init__()
self.W_Q = nn.Linear(d_embedding, d_k * n_heads) # Q的线性变换层
self.W_K = nn.Linear(d_embedding, d_k * n_heads) # K的线性变换层
self.W_V = nn.Linear(d_embedding, d_v * n_heads) # V的线性变换层
self.linear = nn.Linear(n_heads * d_v, d_embedding)
self.layer_norm = nn.LayerNorm(d_embedding)
def forward(self, Q, K, V, attn_mask):
# Q K V [batch_size, len_q/k/v, embedding_dim]
residual, batch_size = Q, Q.size(0) # 保留残差连接
# 将输入进行线性变换和重塑,以便后续处理
q_s = self.W_Q(Q).view(batch_size, -1, n_heads, d_k).transpose(1, 2)
k_s = self.W_K(K).view(batch_size, -1, n_heads, d_k).transpose(1, 2)
v_s = self.W_V(V).view(batch_size, -1, n_heads, d_v).transpose(1, 2)
# q_s k_s v_s: [batch_size, n_heads, len_q/k/v, d_q=k/v]
# 将注意力掩码复制到多头 attn_mask: [batch_size, n_heads, len_q, len_k]
attn_mask = attn_mask.unsqueeze(1).repeat(1, n_heads, 1, 1)
# attn_mask [batch_size, n_heads, len_q, len_k]
# 使用缩放点积注意力计算上下文和注意力权重
context, weights = ScaledDotProductAttention()(q_s, k_s, v_s, attn_mask)
# context [batch_size, n_heads, len_q, dim_v]
# weights [batch_size, n_heads, len_q, len_k]
# 通过调整维度将多个头的上下文向量连接在一起
context = context.transpose(1, 2).contiguous().view(batch_size, -1, n_heads * d_v)
# context [batch_size, len_q, n_heads * dim_v]
# 用一个线性层把连接后的多头自注意力结果转换,原始地嵌入维度
output = self.linear(context)
# output [batch_size, len_q, embedding_dim]
# 与输入 (Q) 进行残差链接,并进行层归一化后输出
output = self.layer_norm(output + residual)
# output [batch_size, len_q, embedding_dim]
return output, weights # 返回层归一化的输出和注意力权重
class PoswiseFeedForwardNet(nn.Module):
def __init__(self, d_ff=2048):
super(PoswiseFeedForwardNet, self).__init__()
# 定义一维卷积层 1,用于将输入映射到更高维度
self.conv1 = nn.Conv1d(in_channels=d_embedding, out_channels=d_ff, kernel_size=1)
# 定义一维卷积层 2,用于将输入映射回原始维度
self.conv2 = nn.Conv1d(in_channels=d_ff, out_channels=d_embedding, kernel_size=1)
# 定义层归一化
self.layer_norm = nn.LayerNorm(d_embedding)
def forward(self, inputs):
# inputs [batch_size, len_q, embedding_dim]
residual = inputs # 保留残差连接
# 在卷积层 1 后使用 ReLU 激活函数
output = nn.ReLU()(self.conv1(inputs.transpose(1, 2)))
# output [batch_size, d_ff, len_q]
# 使用卷积层 2 进行降维
output = self.conv2(output).transpose(1, 2)
# output [batch_size, len_q, embedding_dim]
# 与输入进行残差链接,并进行层归一化
output = self.layer_norm(output + residual)
#------------------------- 维度信息 --------------------------------
# output [batch_size, len_q, embedding_dim]
return output # 返回加入残差连接后层归一化的结果
# 生成正弦位置编码表的函数,用于在 Transformer 中引入位置信息
def get_sin_enc_table(n_position, embedding_dim):
# n_position: 输入序列的最大长度
# embedding_dim: 词嵌入向量的维度
# 根据位置和维度信息,初始化正弦位置编码表
sinusoid_table = np.zeros((n_position, embedding_dim))
# 遍历所有位置和维度,计算角度值
for pos_i in range(n_position):
for hid_j in range(embedding_dim):
angle = pos_i / np.power(10000, 2 * (hid_j // 2) / embedding_dim)
sinusoid_table[pos_i, hid_j] = angle
sinusoid_table[:, 0::2] = np.sin(sinusoid_table[:, 0::2]) # dim 2i 偶数维
sinusoid_table[:, 1::2] = np.cos(sinusoid_table[:, 1::2]) # dim 2i+1 奇数维
# sinusoid_table 的维度是 [n_position, embedding_dim]
return torch.FloatTensor(sinusoid_table) # 返回正弦位置编码表
# 定义填充注意力掩码函数
def get_attn_pad_mask(seq_q, seq_k):
# seq_q 的维度是 [batch_size, len_q]
# seq_k 的维度是 [batch_size, len_k]
batch_size, len_q = seq_q.size()
batch_size, len_k = seq_k.size()
# 生成布尔类型张量
pad_attn_mask = seq_k.data.eq(0).unsqueeze(1) # <PAD>token 的编码值为 0
# pad_attn_mask 的维度是 [batch_size,1,len_k]
# 变形为与注意力分数相同形状的张量
pad_attn_mask = pad_attn_mask.expand(batch_size, len_q, len_k)
# pad_attn_mask 的维度是 [batch_size,len_q,len_k]
return pad_attn_mask # 返回填充位置的注意力掩码
# 定义编码器层类
class EncoderLayer(nn.Module):
def __init__(self):
super(EncoderLayer, self).__init__()
self.enc_self_attn = MultiHeadAttention() # 多头自注意力层
self.pos_ffn = PoswiseFeedForwardNet() # 位置前馈神经网络层
def forward(self, enc_inputs, enc_self_attn_mask):
# enc_inputs 的维度是 [batch_size, seq_len, embedding_dim]
# enc_self_attn_mask 的维度是 [batch_size, seq_len, seq_len]
# 将相同的 Q,K,V 输入多头自注意力层 , 返回的 attn_weights 增加了头数
enc_outputs, attn_weights = self.enc_self_attn(enc_inputs, enc_inputs,
enc_inputs, enc_self_attn_mask)
# enc_outputs 的维度是 [batch_size, seq_len, embedding_dim]
# attn_weights 的维度是 [batch_size, n_heads, seq_len, seq_len]
# 将多头自注意力 outputs 输入位置前馈神经网络层
enc_outputs = self.pos_ffn(enc_outputs) # 维度与 enc_inputs 相同
# enc_outputs 的维度是 [batch_size, seq_len, embedding_dim]
return enc_outputs, attn_weights # 返回编码器输出和每层编码器注意力权重
# 定义编码器类
n_layers = 6
class Encoder(nn.Module):
def __init__(self, corpus):
super(Encoder, self).__init__()
self.src_emb = nn.Embedding(len(corpus.src_vocab), d_embedding) # 词嵌入层
self.pos_emb = nn.Embedding.from_pretrained( \
get_sin_enc_table(corpus.src_len + 1, d_embedding), freeze=True) # 位置嵌入层
self.layers = nn.ModuleList(EncoderLayer() for _ in range(n_layers)) # 编码器层数
def forward(self, enc_inputs):
# enc_inputs 的维度是 [batch_size, source_len]
# 创建一个从 1 到 source_len 的位置索引序列
pos_indices = torch.arange(1, enc_inputs.size(1) + 1).unsqueeze(0).to(enc_inputs)
# pos_indices 的维度是 [1, source_len]
# 对输入进行词嵌入和位置嵌入相加 [batch_size, source_len,embedding_dim]
enc_outputs = self.src_emb(enc_inputs) + self.pos_emb(pos_indices)
# enc_outputs 的维度是 [batch_size, seq_len, embedding_dim]
# 生成自注意力掩码
enc_self_attn_mask = get_attn_pad_mask(enc_inputs, enc_inputs)
# enc_self_attn_mask 的维度是 [batch_size, len_q, len_k]
enc_self_attn_weights = [] # 初始化 enc_self_attn_weights
# 通过编码器层 [batch_size, seq_len, embedding_dim]
for layer in self.layers:
enc_outputs, enc_self_attn_weight = layer(enc_outputs, enc_self_attn_mask)
enc_self_attn_weights.append(enc_self_attn_weight)
# enc_outputs 的维度是 [batch_size, seq_len, embedding_dim] 维度与 enc_inputs 相同
# enc_self_attn_weights 是一个列表,每个元素的维度是 [batch_size, n_heads, seq_len, seq_len]
return enc_outputs, enc_self_attn_weights # 返回编码器输出和编码器注意力权重
# 生成后续注意力掩码的函数,用于在多头自注意力计算中忽略未来信息
def get_attn_subsequent_mask(seq):
# seq 的维度是 [batch_size, seq_len(Q)=seq_len(K)]
# 获取输入序列的形状
attn_shape = [seq.size(0), seq.size(1), seq.size(1)]
# attn_shape 是一个一维张量 [batch_size, seq_len(Q), seq_len(K)]
# 使用 numpy 创建一个上三角矩阵(triu = triangle upper)
subsequent_mask = np.triu(np.ones(attn_shape), k=1)
# subsequent_mask 的维度是 [batch_size, seq_len(Q), seq_len(K)]
# 将 numpy 数组转换为 PyTorch 张量,并将数据类型设置为 byte(布尔值)
subsequent_mask = torch.from_numpy(subsequent_mask).byte()
# 返回的 subsequent_mask 的维度是 [batch_size, seq_len(Q), seq_len(K)]
return subsequent_mask # 返回后续位置的注意力掩码
# 定义解码器层类
class DecoderLayer(nn.Module):
def __init__(self):
super(DecoderLayer, self).__init__()
self.self_attn = MultiHeadAttention() # 多头自注意力层
self.feed_forward = PoswiseFeedForwardNet() # 逐位置前馈网络层
self.norm1 = nn.LayerNorm(d_embedding) # 第一个层归一化
self.norm2 = nn.LayerNorm(d_embedding) # 第二个层归一化
def forward(self, dec_inputs, attn_mask=None):
# 使用多头自注意力处理输入
attn_output, _ = self.self_attn(dec_inputs, dec_inputs, dec_inputs, attn_mask)
# 将注意力输出与输入相加并进行第一个层归一化
norm1_outputs = self.norm1(dec_inputs + attn_output)
# 将归一化后的输出输入到位置前馈神经网络
ff_outputs = self.feed_forward(norm1_outputs)
# 将前馈神经网络输出与第一次归一化后的输出相加并进行第二个层归一化
dec_outputs = self.norm2(norm1_outputs + ff_outputs)
return dec_outputs # 返回解码器层输出
# 定义解码器类
n_layers = 6 # 设置 Decoder 的层数
class Decoder(nn.Module):
def __init__(self, vocab_size, max_seq_len):
super(Decoder, self).__init__()
# 词嵌入层(参数为词典维度)
self.src_emb = nn.Embedding(vocab_size, d_embedding)
# 位置编码层(参数为序列长度)
self.pos_emb = nn.Embedding(max_seq_len, d_embedding)
# 初始化 N 个解码器层
self.layers = nn.ModuleList([DecoderLayer() for _ in range(n_layers)])
def forward(self, dec_inputs):
# 创建位置信息
positions = torch.arange(len(dec_inputs), device=dec_inputs.device).unsqueeze(-1)
# 将词嵌入与位置编码相加
inputs_embedding = self.src_emb(dec_inputs) + self.pos_emb(positions)
# 生成自注意力掩码
attn_mask = get_attn_subsequent_mask(inputs_embedding).to(device)
# 初始化解码器输入,这是第一层解码器层的输入
dec_outputs = inputs_embedding
for layer in self.layers:
# 将输入数据传递给解码器层,并返回解码器层的输出,作为下一层的输入
dec_outputs = layer(dec_outputs, attn_mask)
return dec_outputs # 返回解码器输出
# 定义 GPT 模型
class GPT(nn.Module):
def __init__(self, vocab_size, max_seq_len):
super(GPT, self).__init__()
self.decoder = Decoder(vocab_size, max_seq_len) # 解码器,用于学习文本生成能力
self.projection = nn.Linear(d_embedding, vocab_size) # 全连接层,输出预测结果
def forward(self, dec_inputs):
dec_outputs = self.decoder(dec_inputs) # 将输入数据传递给解码器
logits = self.projection(dec_outputs) # 传递给全连接层以生成预测
return logits # 返回预测结果
# 构建语料库
class LanguageCorpus:
def __init__(self, sentences):
self.sentences = sentences
# 计算语言的最大句子长度,并加 2 以容纳特殊符号 <sos> 和 <eos>
self.seq_len = max([len(list(sentence)) for sentence in sentences]) + 2
self.vocab = self.create_vocabulary() # 创建源语言和目标语言的词汇表
self.idx2word = {v: k for k, v in self.vocab.items()} # 创建索引到单词的映射
def create_vocabulary(self):
vocab = {'<pad>': 0, '<sos>': 1, '<eos>': 2}
counter = Counter()
# 统计语料库的单词频率
for sentence in self.sentences:
words = list(sentence)
counter.update(words)
# 创建词汇表,并为每个单词分配一个唯一的索引
for word in counter:
if word not in vocab:
vocab[word] = len(vocab)
print(vocab)
return vocab
def make_batch(self, batch_size, test_batch=False):
input_batch, output_batch = [], [] # 初始化批数据
sentence_indices = torch.randperm(len(self.sentences))[:batch_size] # 随机选择句子索引
for index in sentence_indices:
sentence = self.sentences[index]
# 将句子转换为索引序列
seq = [self.vocab['<sos>']] + [self.vocab[word] for word in list(sentence)] + [self.vocab['<eos>']]
seq += [self.vocab['<pad>']] * (self.seq_len - len(seq)) # 对序列进行填充
# 将处理好的序列添加到批次中
input_batch.append(seq[:-1])
output_batch.append(seq[1:])
return torch.LongTensor(input_batch), torch.LongTensor(output_batch)
with open("lang.txt", "r", encoding="utf-8") as file: # 从文件中读入语料
sentences = [line.strip() for line in file.readlines()]
corpus = LanguageCorpus(sentences) # 创建语料库
vocab_size = len(corpus.vocab) # 词汇表大小
max_seq_len = corpus.seq_len # 最大句子长度(用于设置位置编码)
print(f" 语料库词汇表大小 : {vocab_size}") # 打印词汇表大小
print(f" 最长句子长度 : {max_seq_len}") # 打印最大序列长
device = "cuda" if torch.cuda.is_available() else "cpu" # 设置设备
model = GPT(vocab_size, max_seq_len).to(device) # 创建 GPT 模型实例
criterion = nn.CrossEntropyLoss() # 损失函数
optimizer = optim.Adam(model.parameters(), lr=0.0001) # 优化器
epochs = 500 # 训练轮次
for epoch in range(epochs): # 训练 epochs 轮
optimizer.zero_grad() # 梯度清零
inputs, targets = corpus.make_batch(batch_size) # 创建训练数据
inputs, targets = inputs.to(device), targets.to(device)
outputs = model(inputs) # 获取模型输出
loss = criterion(outputs.view(-1, vocab_size), targets.view(-1)) # 计算损失
if (epoch + 1) % 100 == 0: # 打印损失
print(f"Epoch: {epoch + 1:04d} cost = {loss:.6f}")
loss.backward() # 反向传播
optimizer.step() # 更新参数
# 测试文本生成
def generate_text(model, input_str, max_len=50):
model.eval() # 将模型设置为评估(测试)模式,关闭 dropout 和 batch normalization 等训练相关的层
# 将输入字符串中的每个 token 转换为其在词汇表中的索引
input_tokens = [corpus.vocab[token] for token in input_str]
# 创建一个新列表,将输入的 tokens 复制到输出 tokens 中 , 目前只有输入的词
output_tokens = input_tokens.copy()
with torch.no_grad(): # 禁用梯度计算,以节省内存并加速测试过程
for _ in range(max_len): # 生成最多 max_len 个 tokens
# 将输出的 token 转换为 PyTorch 张量,并增加一个代表批次的维度 [1, len(output_tokens)]
inputs = torch.LongTensor(output_tokens).unsqueeze(0).to(device)
outputs = model(inputs) # 输出 logits 形状为 [1, len(output_tokens), vocab_size]
# 在最后一个维度上获取 logits 中的最大值,并返回其索引(即下一个 token)
_, next_token = torch.max(outputs[:, -1, :], dim=-1)
next_token = next_token.item() # 将张量转换为 Python 整数
if next_token == corpus.vocab["<eos>"]:
break # 如果生成的 token 是 EOS(结束符),则停止生成过程
output_tokens.append(next_token) # 将生成的 tokens 添加到 output_tokens 列表
# 将输出 tokens 转换回文本字符串
output_str = " ".join([corpus.idx2word[token] for token in output_tokens])
return output_str
input_str = list("机器学习和人工智能")
generated_text = generate_text(model, input_str) # 模型跟着这个词生成后续文本
print(" 生成的文本 :", generated_text) # 打印预测文本
# gpt 1 -》 2 -》 3 -》 chatgpt / qwen
07_huggingface
import torch
# 模型:分词器, 模型结构(权重)
# Auto 自动推理 模型权重和配置,加载对应的模块
# Tokenizer 分词器: 类似jieba 每个bert / qwen /ds 都有自己的 分词器
# ModelForMaskedLM 加载一个模型,修改输出结构用于MLM
from transformers import AutoTokenizer, AutoModelForMaskedLM
# transformers 语言建模的库,模型结构
# 所有bert 、gpt (qwen、ds、chatgpt) 使用的时候 需要加载两部分: tokenizer、 model
# 每个模型的token划分方法 和 词表都不同
# modelscope 国内特色版本的huggingface
# pip install modelscope
# 下载命令 modelscope download --model google-bert/bert-base-chinese --local_dir models/google-bert/bert-base-chinese
# https://www.modelscope.cn/models/google-bert/bert-base-chinese/
# https://huggingface.co/google-bert/bert-base-chinese 谷歌官方推出原始的bert版本,用于中文的建模
tokenizer = AutoTokenizer.from_pretrained("../models/google-bert/bert-base-chinese")
model = AutoModelForMaskedLM.from_pretrained("../models/google-bert/bert-base-chinese") # 400mb
# 待处理的文本
text = "我喜欢人工智能westart鋐" # 分词 subword
# ['[CLS]', '我', '喜', '欢', '人', '工', '智', '能', '。', '[SEP]']
# bert 字作为token
# token: 文本切分之后的最小单位,输入到模型的单位
# Special Tokens: [CLS] [SEP] 标记特殊的用途的token
# [CLS] BERT 句首标记,聚合句子表示用于分类
# [SEP] 句子分隔(单句结尾或句子对中间)
# 使用分词器对文本进行编码
encoded_input = tokenizer(text, return_tensors='pt') # 文本转换为token,token 编码
print("编码后的输入张量:")
print(encoded_input)
print("-----------------------")
"""
{'input_ids': tensor([[ 101, 782, 2339, 3255, 5543, 511, 102, 782, 2339, 3255, 5543, 511, 102]]),
'token_type_ids': tensor([[0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1]]), 句子1 句子2
'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])} 有效输入
"""
# input_ids token 在 词表中的次序
# token_type_ids 区分 句子1的token 句子2的token
# attention_mask 告诉模型哪些token有效,哪些无效(padding)
# 打印分词结果
tokens = tokenizer.convert_ids_to_tokens(encoded_input['input_ids'][0])
print("分词结果:")
print(tokens)
# 增加一个文本示例
text_to_feature_extraction = "自然语言处理是人工智能的一个重要分支。"
# 对文本进行编码
encoded_input_features = tokenizer(text_to_feature_extraction, return_tensors='pt')
# 将编码后的输入传递给模型,禁用梯度计算以节省内存和提高速度
with torch.no_grad():
# 语法糖,字典中的键值对作为关键字参数传递给模型
outputs = model(**encoded_input_features, output_hidden_states=True)
# outputs是一个包含多个元素的元组或对象
# 第一个元素是 logits (用于完形填空任务),第二个元素是隐藏层状态
# outputs.hidden_states 包含了所有层的隐藏层输出,是一个元组
# 最后一个元素是最后一层的输出,倒数第二个是倒数第二层的输出
last_hidden_state = outputs.hidden_states[-1]
# 也可以访问倒数第二层
second_to_last_hidden_state = outputs.hidden_states[-2]
print("文本的token ID数量:", encoded_input_features['input_ids'].shape[1])
print("最后一层隐藏层输出的形状:", last_hidden_state.shape)
print("倒数第二层隐藏层输出的形状:", second_to_last_hidden_state.shape)
# 隐藏层输出的形状为:[batch_size, sequence_length, hidden_size]
# last_hidden_state[0] 代表批次中的第一个(也是唯一一个)样本
# last_hidden_state[0][0] 代表 [CLS] token 的向量表示
cls_embedding = last_hidden_state[0][0]
print("[CLS] token 的向量表示形状:", cls_embedding.shape)
# 获取整个序列的特征向量(例如,取所有 token 向量的平均值)
# 这是一个简单的池化策略
mean_pooling_embedding = torch.mean(last_hidden_state[0], dim=0)
print("通过均值池化得到的序列特征向量形状:", mean_pooling_embedding.shape)
# 句子有n个token 输入, 提取特征 n * 768 维度
08_BERT
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.optim import Adam
from collections import Counter
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
import tqdm
import random
import pickle
import tqdm
import math
class BertEmbedding(nn.Module):
'''
BertEmbedding包括三部分, 三部分相加并输出:
1. TokenEmbedding / 2. PositionalEmbedding / 3. SegmentEmbedding
'''
def __init__(self, vocab_size, embed_size, dropout=0.1):
super(BertEmbedding, self).__init__()
self.dropout = nn.Dropout(dropout)
# 词向量层
self.token_embed = TokenEmbedding(vocab_size, embed_size)
# 位置编码层
self.position_embed = PositionalEmbedding(embed_size)
# 句子类型编码层
self.segment_embed = SegmentEmbedding(embed_size)
def forward(self, sequence, segment_label):
# 词嵌入、位置嵌入和句子嵌入相加
x = self.token_embed(sequence) + self.position_embed(sequence) + self.segment_embed(segment_label)
return self.dropout(x)
class TokenEmbedding(nn.Embedding):
# 词嵌入层
def __init__(self, vocab_size, embed_size=512):
super().__init__(vocab_size, embed_size, padding_idx=0)
class PositionalEmbedding(nn.Module):
# 位置编码层,使用正弦和余弦函数
def __init__(self, embed_size, max_len=512):
super(PositionalEmbedding, self).__init__()
pe = torch.zeros(max_len, embed_size) # (max_len, model_dim)
pe.requires_grad = False # 位置编码不需要梯度
position = torch.arange(0, max_len).unsqueeze(1) # (max_len, 1)
# 计算分母,用于控制正弦余弦的频率
div = torch.exp(torch.arange(0., embed_size, 2) * (- math.log(10000.) / embed_size))
pe[:, 0::2] = torch.sin(position * div) # 偶数位置使用sin
pe[:, 1::2] = torch.cos(position * div) # 奇数位置使用cos
pe = pe.unsqueeze(0) # (1, max_len, model_dim)
self.register_buffer('pe', pe) # 将位置编码存入缓冲区,不作为模型参数
def forward(self, x):
# 返回对应输入序列长度的位置编码
# x.size(1) 获取输入序列的长度
return self.pe[:, x.size(1)] # (b, max_len, model_dim)
class SegmentEmbedding(nn.Embedding):
# 句子类型嵌入层,用于区分句子A和句子B
def __init__(self, embed_size=512):
super().__init__(3, embed_size, padding_idx=0) # 0: padding, 1: 句子A, 2: 句子B
# --------------------------------- TransformerBlock -------------------------------------------
class TransformerBlock(nn.Module):
"""
Transformer = MultiHead_Attention + Feed_Forward with sublayer connection
"""
def __init__(self, hidden, head, feed_forward_hidden, dropout):
super(TransformerBlock, self).__init__()
# 多头注意力机制
self.attention = MultiHeadedAttention(hidden, head, dropout=dropout)
# 前馈网络
self.feed_forward = FeedForward(hidden, feed_forward_hidden, dropout=dropout)
# 自注意力层的残差连接和层归一化
self.attn_sublayer = SubLayerConnection(hidden, dropout)
# 前馈网络的残差连接和层归一化
self.ff_sublayer = SubLayerConnection(hidden, dropout)
self.dropout = nn.Dropout(dropout)
def forward(self, x, mask):
# 自注意力模块的前向传播
x = self.attn_sublayer(x, lambda x: self.attention(x, x, x, mask))
# 前馈网络的前向传播
x = self.ff_sublayer(x, self.feed_forward)
return self.dropout(x)
class LayerNorm(nn.Module):
# 层归一化
def __init__(self, features, eps=1e-6):
super(LayerNorm, self).__init__()
# 可学习的缩放参数
self.alpha = nn.Parameter(torch.ones(features))
# 可学习的平移参数
self.beta = nn.Parameter(torch.zeros(features))
self.eps = eps
def forward(self, x):
x_mean = x.mean(-1, keepdim=True)
x_std = x.std(-1, keepdim=True)
return self.alpha * (x - x_mean) / (x_std + self.eps) + self.beta
class SubLayerConnection(nn.Module):
# 残差连接和层归一化
def __init__(self, hidden, dropout):
super(SubLayerConnection, self).__init__()
self.layer_norm = LayerNorm(hidden)
self.dropout = nn.Dropout(dropout)
def forward(self, x, sublayer):
# 归一化后执行子层操作,然后进行残差连接和dropout
return x + self.dropout(sublayer(self.layer_norm(x)))
def attention(q, k, v, mask=None, dropout=None):
# q=k=v: (b, head, max_len, dk)
# mask: (b, max_len, max_len)
dk = q.size(-1)
# 计算注意力分数,q和k的乘积除以根号dk
scores = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(dk) # (b, head, max_len, max_len)
if mask is not None:
# 对padding部分进行掩码,使用一个很大的负值
scores = scores.masked_fill(mask == 0, -1e9) # padding_mask, 极小值填充
# softmax操作得到注意力权重
attention = F.softmax(scores, dim=-1) # (b, head, max_len, max_len)
if dropout is not None:
attention = dropout(attention) # (b, head, max_len, max_len)
# 注意力权重和v相乘
return torch.matmul(attention, v), attention
class MultiHeadedAttention(nn.Module):
# 多头注意力机制
def __init__(self, hidden, head, dropout=0.1):
super(MultiHeadedAttention, self).__init__()
self.dk = hidden // head # 每个头的维度
self.head = head # 头数
# 3个线性层分别用于q, k, v的投影
self.input_linears = nn.ModuleList([nn.Linear(hidden, hidden) for _ in range(3)])
# 输出线性层
self.output_linear = nn.Linear(hidden, hidden)
self.dropout = nn.Dropout(dropout)
self.attn = None
def forward(self, q, k, v, mask=None):
# q=k=v: (b, max_len, hidden)
batch_size = q.size(0)
if mask is not None:
mask = mask.unsqueeze(1) # (b, 1, max_len, max_len)
# 线性投影并进行分头操作
# q,k,v: (b, head, max_len, dk)
q, k, v = [linear(x).view(batch_size, -1, self.head, self.dk).transpose(1, 2)
for linear, x in zip(self.input_linears, (q, k, v))]
# 调用自定义的 attention 函数
# x: (b, head, max_len, dk)
# attn: (b, head, max_len, max_len)
x, self.attn = attention(q, k, v, mask=mask, dropout=self.dropout)
# 将多头的结果拼接,并进行线性投影
x = x.transpose(1, 2).contiguous().view(batch_size, -1, self.head * self.dk) # (b, max_len, hidden)
return self.output_linear(x) # (b, max_len, hidden)
class FeedForward(nn.Module):
# 前馈网络
def __init__(self, hidden, ff_dim, dropout=0.1):
super(FeedForward, self).__init__()
self.linear1 = nn.Linear(hidden, ff_dim)
self.linear2 = nn.Linear(ff_dim, hidden)
self.dropout = nn.Dropout(dropout)
self.activation = GLUE() # 使用GLUE激活函数
def forward(self, x):
return self.linear2(self.dropout(self.activation(self.linear1(x))))
class GLUE(nn.Module):
# GLUE激活函数
def forward(self, x):
return 0.5 * x * (1 + torch.tanh(math.sqrt(2 / math.pi) * (x + 0.044715 * torch.pow(x, 3))))
# ------------------------------------ Bert ----------------------------------
class Bert(nn.Module):
'''
BertEmbedding + TransformerBlock
'''
def __init__(self, vocab_size, hidden=768, n_layers=12, head=12, dropout=0.1):
super(Bert, self).__init__()
self.hidden = hidden
self.n_layers = n_layers
self.head = head
self.feed_forward_hidden = hidden * 4
# 嵌入层
self.embedding = BertEmbedding(vocab_size=vocab_size, embed_size=hidden, dropout=dropout)
# 堆叠多个Transformer Block
self.transformer_blocks = nn.ModuleList(
[TransformerBlock(hidden, head, hidden * 4, dropout) for _ in range(n_layers)])
def forward(self, x, segment_info):
# x: (b, max_len)
# segment_info: (b, max_len)
# 创建注意力掩码,将padding部分设置为0
mask = (x > 0).unsqueeze(1).repeat(1, x.size(1), 1) # (b, max_len, max_len)
# 嵌入层的前向传播
x = self.embedding(x, segment_info) # (b, max_len, embed_size)
# 循环执行Transformer Block
for transformer in self.transformer_blocks:
x = transformer(x, mask)
return x
# ---------------------------------- BertDataset ------------------------------------
class BertDataset(Dataset):
def __init__(self, corpus_path, vocab, seq_len, encoding='utf-8', corpus_lines=None):
self.vocab = vocab
self.seq_len = seq_len
# 加载语料库
with open(corpus_path, encoding=encoding) as f:
self.datas = [line[:-1].split("\t")
for line in tqdm.tqdm(f, desc="Loading Dataset", total=corpus_lines)]
def __len__(self):
return len(self.datas)
def __getitem__(self, item):
# 随机选择下一句
t1, (t2, is_next_label) = self.datas[item][0], self.random_sent(item)
# 对句子进行随机掩码
t1_random, t1_label = self.random_word(t1)
t2_random, t2_label = self.random_word(t2)
# 添加特殊标记 [CLS] 和 [SEP]
t1 = [self.vocab.sos_index] + t1_random + [self.vocab.eos_index]
t2 = t2_random + [self.vocab.eos_index]
t1_label = [self.vocab.pad_index] + t1_label + [self.vocab.pad_index]
t2_label = t2_label + [self.vocab.pad_index]
# 拼接句子
bert_input = (t1 + t2)[:self.seq_len]
bert_label = (t1_label + t2_label)[:self.seq_len]
# 构造句子类型标签
segment_label = ([1 for _ in range(len(t1))] + [2 for _ in range(len(t2))])[:self.seq_len]
# 如果句子不足进行padding
padding = [self.vocab.pad_index for _ in range(self.seq_len - len(bert_input))]
bert_input.extend(padding)
bert_label.extend(padding)
segment_label.extend(padding)
output = {
'bert_input': bert_input,
'bert_label': bert_label,
'segment_label': segment_label,
'is_next': is_next_label
}
return {key: torch.tensor(value) for key, value in output.items()}
def random_word(self, sentence):
tokens = sentence.split()
sent_label = [] # 0是没有被mask,有数值的是mask的位置
for i, token in enumerate(tokens):
prob = random.random()
if prob < 0.15:
prob /= 0.15
# 80%用mask替换
if prob < 0.8:
tokens[i] = self.vocab.mask_index
# 10%词表中随机一个词替换
elif prob < 0.9:
tokens[i] = random.randrange(len(self.vocab))
else:
# 10%用当前词不变
tokens[i] = self.vocab.stoi.get(tokens, self.vocab.unk_index)
sent_label.append(self.vocab.stoi.get(token, self.vocab.unk_index))
else:
tokens[i] = self.vocab.stoi.get(token, self.vocab.unk_index)
sent_label.append(0)
return tokens, sent_label
def random_sent(self, item):
# 50%概率选择下一句,50%概率选择随机一句
if random.random > 0.5:
return self.datas[item][1], 1 # 是下一句
else:
return self.datas[random.randrange(len(self.datas))][1], 0 # 不是下一句
# --------------------------------------- Bert预训练任务及BertTrainer ---------------------------------
class BertLM(nn.Module):
'''
BERT 语言模型 (两个预训练任务)
Masked Language Model + Next Sentence Prediction Model
'''
def __init__(self, bert, vocab_size):
super(BertLM, self).__init__()
self.bert = bert
# 掩码语言模型,用于预测被掩码的词
self.mask_lm = MaskedLanguageModel(self.bert.hidden, vocab_size)
# 下一句预测模型
self.next_sentence = NextSentencePrediction(self.bert.hidden)
def forward(self, x, segment_label):
out = self.bert(x, segment_label) # (b, max_len, hidden)
return self.mask_lm(out), self.next_sentence(out) # (b, max_len, vocab_size) / (b, 2)
class MaskedLanguageModel(nn.Module):
'''
n分类问题:n-class = vocab_size
'''
def __init__(self, hidden, vocab_size):
super(MaskedLanguageModel, self).__init__()
self.linear = nn.Linear(hidden, vocab_size)
self.softmax = nn.LogSoftmax(dim=-1)
def forward(self, x):
return self.softmax(self.linear(x)) # 对所有位置进行预测
class NextSentencePrediction(nn.Module):
"""
2-class分类: is_next, is_not_next
"""
def __init__(self, hidden):
super(NextSentencePrediction, self).__init__()
self.linear = nn.Linear(hidden, 2)
self.softmax = nn.LogSoftmax(dim=-1)
def forward(self, x):
# 只在 [CLS] token 的输出上进行预测 (即序列的第一个位置)
return self.softmax(self.linear(x[:, 0])) # 只在x的0位置上进行预测
class BertTtrainer:
'''
Bert预训练模型包括两个LM预训练任务:
1. Masked Language Model (掩码语言模型)
2. Next Sentence prediction (下一句预测)
'''
def __init__(self, bert, vocab_size, train_dataloader, test_dataloader=None, lr=1e-4,
betas=(0.9, 0.999), weight_decay=0.01):
self.bert = bert
self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# 将 BERT 模型和两个预训练任务组合
self.bert_lm = BertLM(bert, vocab_size).to(self.device)
if torch.cuda.device_count() > 1:
# 如果有多个GPU,使用DataParallel
self.bert_lm = nn.DataParallel(self.bert_lm)
self.train_data = train_dataloader
self.test_data = test_dataloader
# 优化器
self.optim = Adam(self.bert_lm.parameters(), lr=lr, betas=betas, weight_decay=weight_decay)
# 损失函数,忽略padding位置
self.criterion = nn.NLLLoss(ignore_index=0)
# 打印总参数数量
print('Total Parameters:', sum([p.nelement() for p in self.bert_lm.parameters()]))
def train(self, epoch):
self.iteration(epoch, self.train_data)
def test(self, epoch):
self.iteration(epoch, self.test_data, mode='test')
def iteration(self, epoch, data_loader, mode='train'):
total_loss = 0.0
total_correct = 0
total_element = 0
for i, data in enumerate(data_loader):
# 将数据移动到指定设备
data = {key: value.to(self.device) for key, value in data.items()}
# 前向传播
mask_lm_output, next_sentence_output = self.bert_lm(data['bert_input'], data['segment_label'])
# 计算掩码语言模型的损失
mask_loss = self.criterion(mask_lm_output.transpose(1, 2), data['bert_label'])
# 计算下一句预测的损失
next_loss = self.criterion(next_sentence_output, data['is_next'])
# 总损失为两个任务的损失之和
loss = mask_loss + next_loss
if mode == 'train':
self.optim.zero_grad()
loss.backward()
self.optim.step()
# 计算下一句预测的准确率
correct = next_sentence_output.argmax(dim=-1).eq(data['is_next']).sum().item()
total_loss += loss.item()
total_correct += correct
total_element += data['is_next'].nelement()
print('mode: %s, epoch:%d, avg_loss: %.5f, total_acc: %.5f' % (
mode, epoch, total_loss / len(data_loader), total_correct * 100.0 / total_element))
def save(self, epoch, save_path='bert_pretrain.model'):
# 保存模型,先将模型移到CPU
torch.save(self.bert.cpu(), save_path)
self.bert.to(self.device)
model = Bert(3000, 768, 12, 12, 0.1)
print(model)
09_BERT文本分类
import numpy as np
import pandas as pd
import torch
from torch.utils.data import Dataset, DataLoader
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from transformers import BertTokenizer, AutoTokenizer
from transformers import BertForSequenceClassification
# -------------------------- 1. 数据准备 --------------------------
# 加载数据集,指定分隔符为制表符,并无表头
dataset = pd.read_csv("./dataset.csv", sep="\t", header=None)
print(dataset)
# 初始化并拟合标签编码器,将文本标签(如“体育”)转换为数字标签(如0, 1, 2...)
lbl = LabelEncoder()
lbl.fit(dataset[1].values)
# 将数据按8:2的比例分割为训练集和测试集
# stratify 参数确保训练集和测试集中各类别的样本比例与原始数据集保持一致
x_train, x_test, train_label, test_label = train_test_split(
list(dataset[0].values[:500]),
lbl.transform(dataset[1].values[:500]),
test_size=0.2,
stratify=dataset[1][:500].values
)
# 加载BERT预训练的分词器(Tokenizer)
# 分词器负责将文本转换为模型可识别的输入ID、注意力掩码等
# tokenizer = BertTokenizer.from_pretrained('../models/google-bert/bert-base-chinese')
# tokenizer = BertTokenizer.from_pretrained('bert-base-chinese', cache_dir='./models')
try:
tokenizer = AutoTokenizer.from_pretrained('ckiplab/bert-tiny-chinese', cache_dir='./models')
except Exception as e:
print(f"加载失败: {e}")
# 对训练集和测试集的文本进行编码
# truncation=True:如果句子长度超过max_length,则截断
# padding=True:将所有句子填充到max_length
# max_length=64:最大序列长度
train_encoding = tokenizer(x_train, truncation=True, padding=True, max_length=64)
test_encoding = tokenizer(x_test, truncation=True, padding=True, max_length=64)
# -------------------------- 2. 数据集和数据加载器 --------------------------
# 自定义数据集类,继承自PyTorch的Dataset
# 用于处理编码后的数据和标签,方便后续批量读取
class NewsDataset(Dataset):
def __init__(self, encodings, labels):
self.encodings = encodings
self.labels = labels
# 获取单个样本的方法
def __getitem__(self, idx):
# 从编码字典中提取input_ids, attention_mask等,并转换为PyTorch张量
item = {key: torch.tensor(val[idx]) for key, val in self.encodings.items()}
# 添加标签,并转换为张量
item['labels'] = torch.tensor(int(self.labels[idx]))
return item
# 返回数据集总样本数的方法
def __len__(self):
return len(self.labels)
# 实例化自定义数据集
train_dataset = NewsDataset(train_encoding, train_label) # 单个样本读取的数据集
test_dataset = NewsDataset(test_encoding, test_label)
# 使用DataLoader创建批量数据加载器
# batch_size=16:每个批次包含16个样本
# shuffle=True:在每个epoch开始时打乱数据,以提高模型泛化能力
train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True) # 批量读取样本
test_dataloader = DataLoader(test_dataset, batch_size=16, shuffle=True)
for batch_data in train_loader:
break
# -------------------------- 3. 模型和优化器 --------------------------
# 加载BERT用于序列分类的预训练模型
# num_labels=12:指定分类任务的类别数量
# https://huggingface.co/docs/transformers/v4.56.0/en/model_doc/bert#transformers.BertForSequenceClassification
# model = BertForSequenceClassification.from_pretrained('../models/google-bert/bert-base-chinese', num_labels=17)
# model = BertForSequenceClassification.from_pretrained('bert-base-chinese', cache_dir='./models', num_labels=17)
model = BertForSequenceClassification.from_pretrained('ckiplab/bert-tiny-chinese', cache_dir='./models', num_labels=17)
# 设置设备,优先使用CUDA(GPU),否则使用CPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# 将模型移动到指定的设备上
model.to(device)
# 定义优化器,使用AdamW,lr是学习率
optim = torch.optim.AdamW(model.parameters(), lr=2e-5)
# 定义精度计算函数
def flat_accuracy(preds, labels):
# 获取预测结果的最高概率索引
pred_flat = np.argmax(preds, axis=1).flatten()
# 展平真实标签
labels_flat = labels.flatten()
# 计算准确率
return np.sum(pred_flat == labels_flat) / len(labels_flat)
# -------------------------- 4. 训练和验证函数 --------------------------
# 定义训练函数
def train():
# 设置模型为训练模式
model.train()
total_train_loss = 0
iter_num = 0
total_iter = len(train_loader)
# 遍历训练数据加载器
for batch in train_loader:
# 清除上一轮的梯度
optim.zero_grad()
# 将批次数据移动到指定设备
input_ids = batch['input_ids'].to(device)
attention_mask = batch['attention_mask'].to(device)
labels = batch['labels'].to(device)
# 执行前向传播,得到损失和logits
outputs = model(input_ids, attention_mask=attention_mask, labels=labels) # 自动计算损失
loss = outputs[0]
total_train_loss += loss.item()
# 反向传播计算梯度
loss.backward()
# 梯度裁剪,防止梯度爆炸
torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
# 更新模型参数
optim.step()
iter_num += 1
# 每100步打印一次训练进度
if (iter_num % 100 == 0):
print("epoth: %d, iter_num: %d, loss: %.4f, %.2f%%" % (
epoch, iter_num, loss.item(), iter_num / total_iter * 100))
# 打印平均训练损失
print("Epoch: %d, Average training loss: %.4f" % (epoch, total_train_loss / len(train_loader)))
# 定义验证函数
def validation():
# 设置模型为评估模式
model.eval()
total_eval_accuracy = 0
total_eval_loss = 0
# 遍历测试数据加载器
for batch in test_dataloader:
# 在验证阶段,不计算梯度
with torch.no_grad():
# 将批次数据移动到指定设备
input_ids = batch['input_ids'].to(device)
attention_mask = batch['attention_mask'].to(device)
labels = batch['labels'].to(device)
# 执行前向传播
outputs = model(input_ids, attention_mask=attention_mask, labels=labels)
loss = outputs[0]
logits = outputs[1]
total_eval_loss += loss.item()
# 将logits和标签从GPU移动到CPU,并转换为numpy数组
logits = logits.detach().cpu().numpy()
label_ids = labels.to('cpu').numpy()
total_eval_accuracy += flat_accuracy(logits, label_ids)
# 计算平均准确率
avg_val_accuracy = total_eval_accuracy / len(test_dataloader)
print("Accuracy: %.4f" % (avg_val_accuracy))
print("Average testing loss: %.4f" % (total_eval_loss / len(test_dataloader)))
print("-------------------------------")
# -------------------------- 5. 主训练循环 --------------------------
# 循环训练4个epoch
for epoch in range(4):
print("------------Epoch: %d ----------------" % epoch)
# 训练模型
train()
# 验证模型
validation()
10_BERT文本分类
import pandas as pd
import torch
from sklearn.model_selection import train_test_split
from transformers import BertTokenizer, BertForSequenceClassification, Trainer, TrainingArguments
# BertForSequenceClassification bert 用于 文本分类
# Trainer: 直接实现 正向传播、损失计算、参数更新
# TrainingArguments: 超参数、实验设置
from sklearn.preprocessing import LabelEncoder
from datasets import Dataset
import numpy as np
# 加载和预处理数据
dataset_df = pd.read_csv("./dataset.csv", sep="\t", header=None)
# 初始化 LabelEncoder,用于将文本标签转换为数字标签
lbl = LabelEncoder()
# 拟合数据并转换前500个标签,得到数字标签
labels = lbl.fit_transform(dataset_df[1].values[:500])
# 提取前500个文本内容
texts = list(dataset_df[0].values[:500])
# 分割数据为训练集和测试集
x_train, x_test, train_labels, test_labels = train_test_split(
texts, # 文本数据
labels, # 对应的数字标签
test_size=0.2, # 测试集比例为20%
stratify=labels # 确保训练集和测试集的标签分布一致
)
# 从预训练模型加载分词器和模型
tokenizer = BertTokenizer.from_pretrained('../models/google-bert/bert-base-chinese')
model = BertForSequenceClassification.from_pretrained('../models/google-bert/bert-base-chinese', num_labels=17)
# 使用分词器对训练集和测试集的文本进行编码
# truncation=True:如果文本过长则截断
# padding=True:对齐所有序列长度,填充到最长
# max_length=64:最大序列长度
train_encodings = tokenizer(x_train, truncation=True, padding=True, max_length=64)
test_encodings = tokenizer(x_test, truncation=True, padding=True, max_length=64)
# 将编码后的数据和标签转换为 Hugging Face `datasets` 库的 Dataset 对象
train_dataset = Dataset.from_dict({
'input_ids': train_encodings['input_ids'], # 文本的token ID
'attention_mask': train_encodings['attention_mask'], # 注意力掩码
'labels': train_labels # 对应的标签
})
test_dataset = Dataset.from_dict({
'input_ids': test_encodings['input_ids'],
'attention_mask': test_encodings['attention_mask'],
'labels': test_labels
})
# 定义用于计算评估指标的函数
def compute_metrics(eval_pred):
# eval_pred 是一个元组,包含模型预测的 logits 和真实的标签
logits, labels = eval_pred
# 找到 logits 中最大值的索引,即预测的类别
predictions = np.argmax(logits, axis=-1)
# 计算预测准确率并返回一个字典
return {'accuracy': (predictions == labels).mean()}
# 配置训练参数
training_args = TrainingArguments(
output_dir='./results', # 训练输出目录,用于保存模型和状态
num_train_epochs=4, # 训练的总轮数
per_device_train_batch_size=16, # 训练时每个设备(GPU/CPU)的批次大小
per_device_eval_batch_size=16, # 评估时每个设备的批次大小
warmup_steps=500, # 学习率预热的步数,有助于稳定训练, step 定义为 一次 正向传播 + 参数更新
weight_decay=0.01, # 权重衰减,用于防止过拟合
logging_dir='./logs', # 日志存储目录
logging_steps=100, # 每隔100步记录一次日志
eval_strategy="epoch", # 每训练完一个 epoch 进行一次评估
save_strategy="epoch", # 每训练完一个 epoch 保存一次模型
load_best_model_at_end=True, # 训练结束后加载效果最好的模型
)
# 实例化 Trainer 简化模型训练代码
trainer = Trainer(
model=model, # 要训练的模型
args=training_args, # 训练参数
train_dataset=train_dataset, # 训练数据集
eval_dataset=test_dataset, # 评估数据集
compute_metrics=compute_metrics, # 用于计算评估指标的函数
)
# 深度学习训练过程,数据获取,epoch batch 循环,梯度计算 + 参数更新
# 开始训练模型
trainer.train()
# 在测试集上进行最终评估
trainer.evaluate()
# trainer 是比较简单,适合训练过程比较规范化的模型
# 如果我要定制化训练过程,trainer无法满足
11_MY_BERT文本分类
import pandas as pd
import torch
from sklearn.model_selection import train_test_split
from transformers import BertTokenizer, BertForSequenceClassification, Trainer, TrainingArguments
# BertForSequenceClassification bert 用于 文本分类
# Trainer: 直接实现 正向传播、损失计算、参数更新
# TrainingArguments: 超参数、实验设置
from sklearn.preprocessing import LabelEncoder
from datasets import Dataset
import numpy as np
import os
# model_path = "./models/google-bert/models--bert-base-chinese"
# if os.path.exists(model_path):
# print("路径存在")
# else:
# print("路径不存在,请检查模型文件是否下载完整")
# 加载和预处理数据
# 每行为一条数据,以_!_分割的个字段,从前往后分别是 新闻ID,分类code,分类名称,新闻字符串,新闻关键词
dataset_df = pd.read_csv("./toutiao_cat_data.txt", sep="_!_", header=None, engine='python')
# 初始化 LabelEncoder,用于将文本标签转换为数字标签
lbl = LabelEncoder()
# 拟合数据并转换前500个标签,得到[分类名称]标签
labels = lbl.fit_transform(dataset_df[2].values[:500])
# 提取前500个[新闻字符串]内容
texts = list(dataset_df[3].values[:500])
# 分割数据为训练集和测试集
x_train, x_test, train_labels, test_labels = train_test_split(
texts, # 文本数据
labels, # 对应的数字标签
test_size=0.2, # 测试集比例为20%
stratify=labels # 确保训练集和测试集的标签分布一致
)
# 从预训练模型加载分词器和模型
tokenizer = BertTokenizer.from_pretrained('./models/google-bert/models--bert-base-chinese/snapshots/8f23c25b06e129b6c986331a13d8d025a92cf0ea')
model = BertForSequenceClassification.from_pretrained('./models/google-bert/models--bert-base-chinese/snapshots/8f23c25b06e129b6c986331a13d8d025a92cf0ea', num_labels=15)
# 使用分词器对训练集和测试集的文本进行编码
# truncation=True:如果文本过长则截断
# padding=True:对齐所有序列长度,填充到最长
# max_length=64:最大序列长度
train_encodings = tokenizer(x_train, truncation=True, padding=True, max_length=64)
test_encodings = tokenizer(x_test, truncation=True, padding=True, max_length=64)
# 将编码后的数据和标签转换为 Hugging Face `datasets` 库的 Dataset 对象
train_dataset = Dataset.from_dict({
'input_ids': train_encodings['input_ids'], # 文本的token ID
'attention_mask': train_encodings['attention_mask'], # 注意力掩码
'labels': train_labels # 对应的标签
})
test_dataset = Dataset.from_dict({
'input_ids': test_encodings['input_ids'],
'attention_mask': test_encodings['attention_mask'],
'labels': test_labels
})
# 定义用于计算评估指标的函数
def compute_metrics(eval_pred):
# eval_pred 是一个元组,包含模型预测的 logits 和真实的标签
logits, labels = eval_pred
# 找到 logits 中最大值的索引,即预测的类别。axis=-1,它会找到每个子数组中最大值的索引
predictions = np.argmax(logits, axis=-1)
# 计算预测准确率并返回一个字典
return {'accuracy': (predictions == labels).mean()}
# 配置训练参数
training_args = TrainingArguments(
output_dir='./results', # 训练输出目录,用于保存模型和状态
num_train_epochs=4, # 训练的总轮数
per_device_train_batch_size=8, # 训练时每个设备(GPU/CPU)的批次大小,16常见值,适合大多数情况
per_device_eval_batch_size=8, # 评估时每个设备的批次大小,16常见值,适合大多数情况
gradient_accumulation_steps=4, # 累积4步才更新一次参数,实际等效批次大小 = 8 * 4 = 32,只和per_device_train_batch_size参数有关
# warmup_steps=500, # 学习率预热的步数,有助于稳定训练, step 定义为 一次 正向传播 + 参数更新
warmup_ratio=0.1, # 预热 10% 的训练步数
weight_decay=0.01, # 权重衰减,用于防止过拟合
logging_dir='./logs', # 日志存储目录
logging_steps=100, # 每隔100步记录一次日志
eval_strategy="epoch", # 每训练完一个 epoch 进行一次评估
save_strategy="epoch", # 每训练完一个 epoch 保存一次模型
load_best_model_at_end=True, # 训练结束后加载效果最好的模型
)
# 实例化 Trainer 简化模型训练代码
trainer = Trainer(
model=model, # 要训练的模型
args=training_args, # 训练参数
train_dataset=train_dataset, # 训练数据集
eval_dataset=test_dataset, # 评估数据集
compute_metrics=compute_metrics, # 用于计算评估指标的函数
)
# 深度学习训练过程,数据获取,epoch batch 循环,梯度计算 + 参数更新
# 开始训练模型
trainer.train()
# 在测试集上进行最终评估,该方法返回一个字典,包含评估结果,如损失值、准确率等指标。
trainer.evaluate()
# trainer 是比较简单,适合训练过程比较规范化的模型
# 如果我要定制化训练过程,trainer无法满足
# # 测试新样本
# print("\n测试新样本:")
# test_samples = [
# "上联:山水醉人何须酒。如何对下联?"
# ]
#
# for sample in test_samples:
# prediction = fine_tuner.predict(sample)
# sentiment = "Positive" if prediction == 1 else "Negative"
# print(f"文本: '{sample}' -> 预测: {sentiment} (类别: {prediction})")
#
# def main():
# print("加载BERT模型并进行微调...")
#
# # 生成示例数据
# texts, labels = generate_sample_data()
# print(f"数据集大小: {len(texts)} 条样本")
#
# # 初始化微调器
# fine_tuner = BERTFineTuner(model_name='bert-base-uncased', num_classes=2)
#
# # 准备数据
# fine_tuner.prepare_data(texts, labels, test_size=0.3, batch_size=4)
#
# # 训练模型
# print("开始训练模型...")
# fine_tuner.train(epochs=2, lr=2e-5)
#
# # 测试新样本
# print("\n测试新样本:")
# test_samples = [
# "This is an amazing product!",
# "I hate this, it's terrible",
# "Not bad, could be better",
# "Absolutely wonderful experience"
# ]
#
# for sample in test_samples:
# prediction = fine_tuner.predict(sample)
# sentiment = "Positive" if prediction == 1 else "Negative"
# print(f"文本: '{sample}' -> 预测: {sentiment} (类别: {prediction})")
#
#
# if __name__ == "__main__":
# main()
bert_finetune
import torch
import torch.nn as nn
from transformers import BertTokenizer, BertForSequenceClassification
from torch.optim import AdamW
from torch.utils.data import DataLoader, Dataset
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report
import numpy as np
import pandas as pd
from tqdm import tqdm
# 自定义数据集类
class TextDataset(Dataset):
def __init__(self, texts, labels, tokenizer, max_len=128):
self.texts = texts
self.labels = labels
self.tokenizer = tokenizer
self.max_len = max_len
def __len__(self):
return len(self.texts)
def __getitem__(self, idx):
text = str(self.texts[idx])
label = self.labels[idx]
encoding = self.tokenizer.encode_plus(
text,
add_special_tokens=True,
max_length=self.max_len,
return_token_type_ids=False,
padding='max_length',
truncation=True,
return_attention_mask=True,
return_tensors='pt'
)
return {
'input_ids': encoding['input_ids'].flatten(),
'attention_mask': encoding['attention_mask'].flatten(),
'label': torch.tensor(label, dtype=torch.long)
}
# 微调BERT模型的类
class BERTFineTuner:
def __init__(self, model_name='bert-base-uncased', num_classes=2, max_len=128):
self.tokenizer = BertTokenizer.from_pretrained(model_name)
self.model = BertForSequenceClassification.from_pretrained(model_name, num_labels=num_classes)
self.max_len = max_len
self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
self.model.to(self.device)
def prepare_data(self, texts, labels, test_size=0.2, batch_size=16):
# 划分训练集和验证集
train_texts, val_texts, train_labels, val_labels = train_test_split(
texts, labels, test_size=test_size, random_state=42
)
# 创建数据集
train_dataset = TextDataset(train_texts, train_labels, self.tokenizer, self.max_len)
val_dataset = TextDataset(val_texts, val_labels, self.tokenizer, self.max_len)
# 创建数据加载器
self.train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
self.val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)
def train(self, epochs=3, lr=2e-5):
optimizer = AdamW(self.model.parameters(), lr=lr)
criterion = nn.CrossEntropyLoss()
self.model.train()
for epoch in range(epochs):
total_loss = 0
progress_bar = tqdm(self.train_loader, desc=f'Epoch {epoch + 1}/{epochs}')
for batch in progress_bar:
optimizer.zero_grad()
input_ids = batch['input_ids'].to(self.device)
attention_mask = batch['attention_mask'].to(self.device)
labels = batch['label'].to(self.device)
outputs = self.model(input_ids=input_ids, attention_mask=attention_mask, labels=labels)
loss = outputs.loss
loss.backward()
optimizer.step()
total_loss += loss.item()
progress_bar.set_postfix({'loss': loss.item()})
avg_loss = total_loss / len(self.train_loader)
print(f'Epoch {epoch + 1} 平均损失: {avg_loss:.4f}')
# 验证
self.evaluate()
def evaluate(self):
self.model.eval()
predictions = []
actual_labels = []
with torch.no_grad():
for batch in self.val_loader:
input_ids = batch['input_ids'].to(self.device)
attention_mask = batch['attention_mask'].to(self.device)
labels = batch['label'].to(self.device)
outputs = self.model(input_ids=input_ids, attention_mask=attention_mask)
preds = torch.argmax(outputs.logits, dim=1)
predictions.extend(preds.cpu().numpy())
actual_labels.extend(labels.cpu().numpy())
accuracy = accuracy_score(actual_labels, predictions)
print(f'验证集准确率: {accuracy:.4f}')
print(classification_report(actual_labels, predictions))
self.model.train()
def predict(self, text):
self.model.eval()
encoding = self.tokenizer.encode_plus(
text,
add_special_tokens=True,
max_length=self.max_len,
return_token_type_ids=False,
padding='max_length',
truncation=True,
return_attention_mask=True,
return_tensors='pt'
)
input_ids = encoding['input_ids'].to(self.device)
attention_mask = encoding['attention_mask'].to(self.device)
with torch.no_grad():
outputs = self.model(input_ids=input_ids, attention_mask=attention_mask)
prediction = torch.argmax(outputs.logits, dim=1)
return prediction.cpu().numpy()[0]
# 示例数据生成函数
def generate_sample_data():
# 创建示例数据集(情感分析)
positive_texts = [
"I love this movie, it's fantastic!",
"This is the best product I've ever used",
"Amazing experience, highly recommended",
"Wonderful service and great quality",
"I'm so happy with my purchase",
"Excellent work, very satisfied",
"Outstanding performance and great value",
"This exceeded my expectations",
"Brilliant idea and well executed",
"I can't recommend this enough"
]
negative_texts = [
"This movie is terrible, I hate it",
"Worst product ever, complete waste of money",
"Awful experience, would not recommend",
"Poor service and bad quality",
"I'm very disappointed with this purchase",
"Terrible work, completely unsatisfied",
"Disappointing performance and poor value",
"This was below my expectations",
"Bad idea and poorly executed",
"I would not recommend this to anyone"
]
texts = positive_texts + negative_texts
labels = [1] * len(positive_texts) + [0] * len(negative_texts)
return texts, labels
# 主函数
def main():
print("加载BERT模型并进行微调...")
# 生成示例数据
texts, labels = generate_sample_data()
print(f"数据集大小: {len(texts)} 条样本")
# 初始化微调器
fine_tuner = BERTFineTuner(model_name='bert-base-uncased', num_classes=2)
# 准备数据
fine_tuner.prepare_data(texts, labels, test_size=0.3, batch_size=4)
# 训练模型
print("开始训练模型...")
fine_tuner.train(epochs=2, lr=2e-5)
# 测试新样本
print("\n测试新样本:")
test_samples = [
"This is an amazing product!",
"I hate this, it's terrible",
"Not bad, could be better",
"Absolutely wonderful experience"
]
for sample in test_samples:
prediction = fine_tuner.predict(sample)
sentiment = "Positive" if prediction == 1 else "Negative"
print(f"文本: '{sample}' -> 预测: {sentiment} (类别: {prediction})")
if __name__ == "__main__":
main()
AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念,把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起,为开发者提供从开发、训练到部署的一站式体验。
更多推荐
所有评论(0)