通过词表，我们可以将句子中的每个词转化为相应的数字序号，得到 [1, 2, 3, 4, 5]。这样，字符信息就成功地转化为神经网络可以处理的数字信息了。

然后神经网络同样预测的也是数字,然后我们根据词表再将神经网络的输出转化为对应的语言。这就完成了预测过程。

这一步在上面代码的__init__和__getitem__完成了

模型搭建和训练

基于seq2seq 的模型

我们使用的是Seq2Seq结构的模型,结构如图所示

两个模块:

Encoder模块Decoder模块

每个模块中由一个GRU网络组成。

这里的原理是Encoder将输入的英文的信息压缩成一个隐藏语义变量c,这个c大概可以理解为下图红框的内容:

然后将c传入解码器Decoder后,解码器根据这个语义信息和来预测我们的中文。

代码如下:

class Encoder(nn.Module):

def __init__(self, input_dim, emb_dim, hid_dim, n_layers, dropout):

super().__init__()

self.embedding = nn.Embedding(input_dim, emb_dim)

self.rnn = nn.GRU(emb_dim, hid_dim, n_layers, dropout=dropout, batch_first=True)

self.dropout = nn.Dropout(dropout)

def forward(self, src):

# src shape: [batch_size, src_len]

embedded = self.dropout(self.embedding(src))

# embedded shape: [batch_size, src_len, emb_dim]

outputs, hidden = self.rnn(embedded)

# outputs shape: [batch_size, src_len, hid_dim]

# hidden shape: [n_layers, batch_size, hid_dim]

return outputs, hidden

class Decoder(nn.Module):

def __init__(self, output_dim, emb_dim, hid_dim, n_layers, dropout):

super().__init__()

self.output_dim = output_dim

self.embedding = nn.Embedding(output_dim, emb_dim)

self.rnn = nn.GRU(emb_dim, hid_dim, n_layers, dropout=dropout, batch_first=True)

self.fc_out = nn.Linear(hid_dim, output_dim)

self.dropout = nn.Dropout(dropout)

def forward(self, input, hidden):

# input shape: [batch_size, 1]

# hidden shape: [n_layers, batch_size, hid_dim]

embedded = self.dropout(self.embedding(input))

# embedded shape: [batch_size, 1, emb_dim]

output, hidden = self.rnn(embedded, hidden)

# output shape: [batch_size, 1, hid_dim]

# hidden shape: [n_layers, batch_size, hid_dim]

prediction = self.fc_out(output.squeeze(1))

# prediction shape: [batch_size, output_dim]

return prediction, hidden

然后将Encoder和Decoder拼接在一起,形成Seq2Seq结构

class Seq2Seq(nn.Module):

def __init__(self, encoder, decoder, device):

super().__init__()

self.encoder = encoder

self.decoder = decoder

self.device = device

def forward(self, src, trg, teacher_forcing_ratio=0.5):

# src 的形状：[batch_size, src_len]

# trg 的形状：[batch_size, trg_len]

batch_size = src.shape[0] # 获取批次大小

trg_len = trg.shape[1] # 获取目标序列的长度

trg_vocab_size = self.decoder.output_dim # 获取目标词汇表的大小

# 初始化输出张量，形状为 [batch_size, trg_len, trg_vocab_size]

outputs = torch.zeros(batch_size, trg_len, trg_vocab_size).to(self.device)

# 将源序列输入编码器，获得隐藏状态

_, hidden = self.encoder(src)

# 取目标序列的第一个词作为解码器的初始输入，通常是开始标记

input = trg[:, 0].unsqueeze(1) # Start token

# 循环遍历目标序列长度，逐步生成输出

for t in range(1, trg_len):

# 将当前输入和隐藏状态输入解码器，获取输出和新的隐藏状态

output, hidden = self.decoder(input, hidden)

# 将当前时间步的输出保存到 outputs 张量中

outputs[:, t, :] = output

# 确定是否使用教师强制

teacher_force = random.random() < teacher_forcing_ratio

# 获取输出中概率最高的词的索引

top1 = output.argmax(1)

# 如果使用教师强制，下一步的输入为目标序列中的下一个词，否则使用当前时间步输出中概率最高的词

input = trg[:, t].unsqueeze(1) if teacher_force else top1.unsqueeze(1)

return outputs # 返回所有时间步的输出

这样我们的Seq2Seq构建的模型已经完成

由于Seq2Seq是NLP比较基础的一个模型,结构简单,无法并行处理。导致训练速度比较慢,而且效果可能比较智障。测了一下全部训练集跑20轮,大概要几小时。最后成绩只有不到2分。上限比较低。所以升级框架为transform框架

基于transformer的模型

后续补充…

4090全数据训练了10个epoch,大概一个小时。效果能去到13.9分

训练代码

就很经典的结构,流程如下:

通过dataloader拿到这一轮的训练数据输入进去模型,得到预测结果拿预测结果和目标句子做交叉熵损失更新梯度不断循环

def train(model, iterator, optimizer, criterion, clip):

model.train()

epoch_loss = 0

for i, (src, trg) in enumerate(iterator):

src, trg = src.to(device), trg.to(device)

optimizer.zero_grad()

output = model(src, trg)

output_dim = output.shape[-1]

output = output[:, 1:].contiguous().view(-1, output_dim)

trg = trg[:, 1:].contiguous().view(-1)

loss = criterion(output, trg)

loss.backward()

torch.nn.utils.clip_grad_norm_(model.parameters(), clip)

optimizer.step()

epoch_loss += loss.item()

return epoch_loss / len(iterator)

main代码

# 主函数

if __name__ == '__main__':

start_time = time.time() # 开始计时

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

#terminology = load_terminology_dictionary('../dataset/en-zh.dic')

terminology = load_terminology_dictionary('./data/en-zh.dic')

# 加载数据

dataset = TranslationDataset('./data/train.txt',terminology = terminology)

# 选择数据集的前N个样本进行训练

N = 1000 #int(len(dataset) * 1) # 或者你可以设置为数据集大小的一定比例，如 int(len(dataset) * 0.1)

subset_indices = list(range(N))

subset_dataset = Subset(dataset, subset_indices)

train_loader = DataLoader(subset_dataset, batch_size=32, shuffle=True, collate_fn=collate_fn)

# 定义模型参数

INPUT_DIM = len(dataset.en_vocab)

OUTPUT_DIM = len(dataset.zh_vocab)

ENC_EMB_DIM = 256

DEC_EMB_DIM = 256

HID_DIM = 512

N_LAYERS = 2

ENC_DROPOUT = 0.5

DEC_DROPOUT = 0.5

# 初始化模型

enc = Encoder(INPUT_DIM, ENC_EMB_DIM, HID_DIM, N_LAYERS, ENC_DROPOUT)

dec = Decoder(OUTPUT_DIM, DEC_EMB_DIM, HID_DIM, N_LAYERS, DEC_DROPOUT)

model = Seq2Seq(enc, dec, device).to(device)

# 定义优化器和损失函数

optimizer = optim.Adam(model.parameters())

criterion = nn.CrossEntropyLoss(ignore_index=dataset.zh_word2idx['<pad>'])

# 训练模型

N_EPOCHS = 10

CLIP = 1

for epoch in range(N_EPOCHS):

train_loss = train(model, train_loader, optimizer, criterion, CLIP)

print(f'Epoch: { epoch+1:02} | Train Loss: { train_loss:.3f}')

# 在训练循环结束后保存模型

torch.save(model.state_dict(), './translation_model_GRU.pth')

end_time = time.time() # 结束计时

# 计算并打印运行时间

elapsed_time_minute = (end_time - start_time)/60

print(f"Total running time: { elapsed_time_minute:.2f} minutes")

基于BLUE4的评估指标

BLEU是评估机器翻译和自然语言生成任务的一种标准指标。BLEU4是指采用4-gram的BLEU评分方法。BLEU评分的核心思想是通过计算机器生成的文本与参考文本之间的n-gram匹配程度来衡量生成文本的质量。具体而言，BLEU4会考虑1-gram到4-gram的匹配情况。

BLEU4 的计算步骤：

分词：将待评估的生成文本和参考文本分词。计算n-gram匹配：计算1-gram、2-gram、3-gram和4-gram的匹配情况。计算精确度：对于每个n-gram，计算生成文本中的n-gram与参考文本中的n-gram的匹配数量，然后除以生成文本中n-gram的总数，得到精确度。计算加权几何平均：将1-gram到4-gram的精确度取对数，然后计算它们的加权几何平均。惩罚因子：为了解决短文本可能获得较高分数的问题，引入惩罚因子BP（Brevity Penalty），BP的计算基于生成文本和参考文本的长度比值。计算最终的BLEU4分数：将加权几何平均与惩罚因子相乘得到最终的BLEU4分数。

举个例子：

假设生成句子和参考句子有些不同：

参考句子："The cat is on the mat"

生成句子："The cat sat on the mat"

1. 分词：

参考句子分词结果：[“The”, “cat”, “is”, “on”, “the”, “mat”]

生成句子分词结果：[“The”, “cat”, “sat”, “on”, “the”, “mat”]

2. 计算n-gram匹配：

1-gram匹配：5个 (“The”, “cat”, “on”, “the”, “mat”)2-gram匹配：4个 (“The cat”, “on the”, “the mat”)3-gram匹配：2个 (“on the mat”)4-gram匹配：1个 (“on the mat”)

3. 计算精确度：

1-gram精确度：5/6 ≈ 0.8332-gram精确度：4/5 = 0.83-gram精确度：2/4 = 0.54-gram精确度：1/3 ≈ 0.333

4. 计算加权几何平均：

BLEU4

=

exp

⁡

(

1

4

(

log

⁡

0.833

+

log

⁡

0.8

+

log

⁡

0.5

+

log

⁡

0.333

)

)

≈

0.599

\text{BLEU4} = \exp\left(\frac{1}{4} (\log 0.833 + \log 0.8 + \log 0.5 + \log 0.333)\right) ≈ 0.599

BLEU4=exp(41​(log0.833+log0.8+log0.5+log0.333))≈0.599

5. 计算惩罚因子BP：

生成句子和参考句子长度相同，因此BP = 1。

6. 计算最终的BLEU4分数：

最终的BLEU4分数 ≈ 0.599（加权几何平均） * 1（BP） ≈ 0.599

在这个例子中，生成句子和参考句子有一些不同，因此BLEU4得分相对较低，反映了生成句子与参考句子的匹配程度不高。

实现代码

import torch

from sacrebleu.metrics import BLEU

from typing import List

# 假设我们已经定义了TranslationDataset, Encoder, Decoder, Seq2Seq类

def load_sentences(file_path: str) -> List[str]:

with open(file_path, 'r', encoding='utf-8') as f:code>

return [line.strip() for line in f]

# 更新translate_sentence函数以考虑术语词典

def translate_sentence(sentence: str, model: Seq2Seq, dataset: TranslationDataset, terminology, device: torch.device, max_length: int = 50):

model.eval()

tokens = dataset.en_tokenizer(sentence)

tensor = torch.LongTensor([dataset.en_word2idx.get(token, dataset.en_word2idx['<sos>']) for token in tokens]).unsqueeze(0).to(device) # [1, seq_len]

with torch.no_grad():

_, hidden = model.encoder(tensor)

translated_tokens = []

input_token = torch.LongTensor([[dataset.zh_word2idx['<sos>']]]).to(device) # [1, 1]

for _ in range(max_length):

output, hidden = model.decoder(input_token, hidden)

top_token = output.argmax(1)

translated_token = dataset.zh_vocab[top_token.item()]

if translated_token == '<eos>':

break

# 如果翻译的词在术语词典中，则使用术语词典中的词

if translated_token in terminology.values():

for en_term, ch_term in terminology.items():

if translated_token == ch_term:

translated_token = en_term

break

translated_tokens.append(translated_token)

input_token = top_token.unsqueeze(1) # [1, 1]

return ''.join(translated_tokens)

def evaluate_bleu(model: Seq2Seq, dataset: TranslationDataset, src_file: str, ref_file: str, terminology,device: torch.device):

model.eval()

src_sentences = load_sentences(src_file)

ref_sentences = load_sentences(ref_file)

translated_sentences = []

for src in src_sentences:

translated = translate_sentence(src, model, dataset, terminology, device)

translated_sentences.append(translated)

bleu = BLEU()

score = bleu.corpus_score(translated_sentences, [ref_sentences])

return score

# 主函数

if __name__ == '__main__':

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

# 加载术语词典

terminology = load_terminology_dictionary('./data/en-zh.dic')

# 创建数据集实例时传递术语词典

dataset = TranslationDataset('./data/train.txt', terminology)

# 定义模型参数

INPUT_DIM = len(dataset.en_vocab)

OUTPUT_DIM = len(dataset.zh_vocab)

ENC_EMB_DIM = 256

DEC_EMB_DIM = 256

HID_DIM = 512

N_LAYERS = 2

ENC_DROPOUT = 0.5

DEC_DROPOUT = 0.5

# 初始化模型

enc = Encoder(INPUT_DIM, ENC_EMB_DIM, HID_DIM, N_LAYERS, ENC_DROPOUT)

dec = Decoder(OUTPUT_DIM, DEC_EMB_DIM, HID_DIM, N_LAYERS, DEC_DROPOUT)

model = Seq2Seq(enc, dec, device).to(device)

# 加载训练好的模型

model.load_state_dict(torch.load('./translation_model_GRU.pth'))

# 评估BLEU分数

bleu_score = evaluate_bleu(model, dataset, './data/dev_en.txt', './data/dev_zh.txt', terminology = terminology,device = device)

print(f'BLEU-4 score: { bleu_score.score:.2f}')

这里是对验证集进行评估,由于Seq2Seq模型训练上限比较低,看上去有点像智障。所以BLEU为0也不是什么奇怪的事情

推理