基于Transformer的机器翻译——中文日语
目录
3.2 构建 TorchText Vocab 对象并将句子转换为 Torch 张量
1.了解Transformer
1.1 什么是Transformer?
Google Brain翻译团队通过发表里程碑式的论文《Attention is All You Need》，彻底颠覆了以往对于序列到序列（Sequence-to-Sequence, Seq2Seq）模型架构的传统认知。这篇论文不仅仅介绍了一个新的模型，而是提出了一种革命性的设计理念，那就是Transformer——一种完全基于注意力机制构建的深度学习架构。
Transformer围绕着自注意力（Self-Attention）机制这一核心构建起整个模型框架。自注意力机制使得模型能够在处理输入序列时，动态且并行地考虑序列中的所有位置对，从而高效地捕获长距离依赖关系，这是先前模型难以有效解决的难题。
1.2 为什么使用Transformer?
Transformer出来之前，主流的序列转换模型都基于复杂的循环神经网络（RNN），包含编码器和解码器两部分。当时表现最好的模型还通过注意力机制将编码器和解码器连接起来。但是RNN编码器-解码器架构存在一个显著的缺陷——处理长序列时，会存在信息丢失。
相较于RNN模型，Transformer模型具有2个优点：
（1）处理长序列数据。Transformer采用自注意力机制，能够同时处理序列中的所有位置，捕捉长距离依赖关系，从而更准确地理解文本含义。而RNN模型则受限于其循环结构，难以处理长序列数据。
（2）实现并行化计算。由于RNN模型需要依次处理序列中的每个元素，其计算速度受到较大限制。而Transformer模型则可以同时处理整个序列，大大提高了计算效率。
1.3 Transformer架构
Transformer遵循编码器-解码器总体架构，使用堆叠的自注意力机制和逐位置的全连接层，分别用于编码器和解码器。
Encoder编码器：Transformer的编码器由6个相同的层组成，每个层包括两个子层：一个多头自注意力层和一个逐位置的前馈神经网络。在每个子层之后，都会使用残差连接和层归一化操作，这些操作统称为Add&Norm。这样的结构帮助编码器捕获输入序列中所有位置的依赖关系。
Decoder解码器：Transformer的解码器由6个相同的层组成，每层包含三个子层：掩蔽自注意力层、Encoder-Decoder注意力层和逐位置的前馈神经网络。每个子层后都有残差连接和层归一化操作，简称Add&Norm。这样的结构确保解码器在生成序列时，能够考虑到之前的输出，并避免未来信息的影响。
Transformer的核心组件
输入嵌入：将输入的文本转换为向量，便于模型处理。
位置编码：给输入向量添加位置信息，因为Transformer并行处理数据而不依赖顺序。
多头注意力：让模型同时关注输入序列的不同部分，捕获复杂的依赖关系。
残差连接与层归一化：通过添加跨层连接和标准化输出，帮助模型更好地训练，防止梯度问题。
带掩码的多头注意力：在生成文本时，确保模型只依赖已知的信息，而不是未来的内容。
前馈网络：对输入进行非线性变换，提取更高级别的特征。
2.实验环境
本次实验需要使用GPU，否则训练速度十分缓慢。我使用的是阿里云人工智能平台PAI训练的模型。以下是配置：
由于之前做CV就使用了该平台，所以我把该实验程序放在了之前的CV实例里面：
基本信息：
环境信息：
资源信息：
实验程序：
实验中下载的数据集和模型：
3.代码部分
3.1 数据导入，分词器准备
导入package，获取并行数据集。这里使用的是从 JParaCrawl 下载的日英并行数据集！[JParaCrawl]，它被描述为“NTT创建的最大的公开可用的英日平行语料库。
import math
import torchtext
import torch
import torch.nn as nn
from torch import Tensor
from torch.nn.utils.rnn import pad_sequence
from torch.utils.data import DataLoader
from collections import Counter
from torchtext.vocab import Vocab
from torch.nn import TransformerEncoder, TransformerDecoder, TransformerEncoderLayer, TransformerDecoderLayer
import io
import time
import pandas as pd
import numpy as np
import pickle
import tqdm
import sentencepiece as spm
torch.manual_seed(0)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
df = pd.read_csv('./zh-ja/zh-ja.bicleaner05.txt', sep='\\t', engine='python', header=None)
trainen = df[2].values.tolist()#[:10000]
trainja = df[3].values.tolist()#[:10000]分词器也由JParaCrawl提供，该分词器是使用SentencePiece创建的日语和英语。
# 初始化英文和日文分词器
en_tokenizer = spm.SentencePieceProcessor(model_file='enja_spm_models/spm.en.nopretok.model')
ja_tokenizer = spm.SentencePieceProcessor(model_file='enja_spm_models/spm.ja.nopretok.model')加载分词器后，可以测试一下。
# 这里en_tokenizer.encode和ja_tokenizer.encode并不支持指定out_type类型，所以我去掉了out_type,会返回一个整数列表，代表每个token的ID
en_tokenizer.encode("All residents aged 20 to 59 years who live in Japan must enroll in public pension system.")测试结果：
3.2 构建 TorchText Vocab 对象并将句子转换为 Torch 张量
接下来构建从 TorchText 导入的 Vocab 对象。
def build_vocab(sentences, tokenizer):
counter = Counter()
for sentence in sentences:
counter.update(tokenizer.encode(sentence, out_type=str))
return Vocab(counter, specials=['<unk>', '<pad>', '<bos>', '<eos>'])
ja_vocab = build_vocab(trainja, ja_tokenizer)
en_vocab = build_vocab(trainen, en_tokenizer)然后使用词汇表和分词器对象来构建训练数据的张量。
def data_process(ja, en):
data = []
for (raw_ja, raw_en) in zip(ja, en):
ja_tensor_ = torch.tensor([ja_vocab[token] for token in ja_tokenizer.encode(raw_ja.rstrip("\n"), out_type=str)],
dtype=torch.long)
en_tensor_ = torch.tensor([en_vocab[token] for token in en_tokenizer.encode(raw_en.rstrip("\n"), out_type=str)],
dtype=torch.long)
data.append((ja_tensor_, en_tensor_))
return data
train_data = data_process(trainja, trainen)3.3 创建DataLoader 对象
# 定义数据载入器，批大小为8
BATCH_SIZE = 8
PAD_IDX = ja_vocab['<pad>']
BOS_IDX = ja_vocab['<bos>']
EOS_IDX = ja_vocab['<eos>']
# 生成每个批次的输入数据
def generate_batch(data_batch):
ja_batch, en_batch = [], []
for (ja_item, en_item) in data_batch:
ja_batch.append(torch.cat([torch.tensor([BOS_IDX]), ja_item, torch.tensor([EOS_IDX])], dim=0))
en_batch.append(torch.cat([torch.tensor([BOS_IDX]), en_item, torch.tensor([EOS_IDX])], dim=0))
ja_batch = pad_sequence(ja_batch, padding_value=PAD_IDX)
en_batch = pad_sequence(en_batch, padding_value=PAD_IDX)
return ja_batch, en_batch
train_iter = DataLoader(train_data, batch_size=BATCH_SIZE,
shuffle=True, collate_fn=generate_batch)3.4 序列到序列转换器
from torch.nn import (TransformerEncoder, TransformerDecoder,
TransformerEncoderLayer, TransformerDecoderLayer)
# 定义Seq2SeqTransformer类，继承自nn.Module
class Seq2SeqTransformer(nn.Module):
def __init__(self, num_encoder_layers: int, num_decoder_layers: int,
emb_size: int, src_vocab_size: int, tgt_vocab_size: int,
dim_feedforward:int = 512, dropout:float = 0.1):
super(Seq2SeqTransformer, self).__init__()
encoder_layer = TransformerEncoderLayer(d_model=emb_size, nhead=NHEAD,
dim_feedforward=dim_feedforward)
self.transformer_encoder = TransformerEncoder(encoder_layer, num_layers=num_encoder_layers)
decoder_layer = TransformerDecoderLayer(d_model=emb_size, nhead=NHEAD,
dim_feedforward=dim_feedforward)
self.transformer_decoder = TransformerDecoder(decoder_layer, num_layers=num_decoder_layers)
self.generator = nn.Linear(emb_size, tgt_vocab_size)
self.src_tok_emb = TokenEmbedding(src_vocab_size, emb_size)
self.tgt_tok_emb = TokenEmbedding(tgt_vocab_size, emb_size)
self.positional_encoding = PositionalEncoding(emb_size, dropout=dropout)
# 前向传播函数，处理整个序列到序列的转换过程
def forward(self, src: Tensor, trg: Tensor, src_mask: Tensor,
tgt_mask: Tensor, src_padding_mask: Tensor,
tgt_padding_mask: Tensor, memory_key_padding_mask: Tensor):
src_emb = self.positional_encoding(self.src_tok_emb(src))
tgt_emb = self.positional_encoding(self.tgt_tok_emb(trg))
memory = self.transformer_encoder(src_emb, src_mask, src_padding_mask)
outs = self.transformer_decoder(tgt_emb, memory, tgt_mask, None,
tgt_padding_mask, memory_key_padding_mask)
return self.generator(outs)
def encode(self, src: Tensor, src_mask: Tensor):
return self.transformer_encoder(self.positional_encoding(
self.src_tok_emb(src)), src_mask)
def decode(self, tgt: Tensor, memory: Tensor, tgt_mask: Tensor):
return self.transformer_decoder(self.positional_encoding(
self.tgt_tok_emb(tgt)), memory,
tgt_mask)把位置编码添加到标记嵌入中，以引入词序的概念。
class PositionalEncoding(nn.Module):
def __init__(self, emb_size: int, dropout, maxlen: int = 5000):
super(PositionalEncoding, self).__init__()
den = torch.exp(- torch.arange(0, emb_size, 2) * math.log(10000) / emb_size)
pos = torch.arange(0, maxlen).reshape(maxlen, 1)
pos_embedding = torch.zeros((maxlen, emb_size))
pos_embedding[:, 0::2] = torch.sin(pos * den)
pos_embedding[:, 1::2] = torch.cos(pos * den)
pos_embedding = pos_embedding.unsqueeze(-2)
self.dropout = nn.Dropout(dropout)
self.register_buffer('pos_embedding', pos_embedding)
def forward(self, token_embedding: Tensor):
return self.dropout(token_embedding +
self.pos_embedding[:token_embedding.size(0),:])
class TokenEmbedding(nn.Module):
def __init__(self, vocab_size: int, emb_size):
super(TokenEmbedding, self).__init__()
self.embedding = nn.Embedding(vocab_size, emb_size)
self.emb_size = emb_size
def forward(self, tokens: Tensor):
return self.embedding(tokens.long()) * math.sqrt(self.emb_size)创建一个后续单词掩码来阻止目标单词关注其后续单词。创建掩码，用于屏蔽源和目标填充tokens。
def generate_square_subsequent_mask(sz):
mask = (torch.triu(torch.ones((sz, sz), device=device)) == 1).transpose(0, 1)
mask = mask.float().masked_fill(mask == 0, float('-inf')).masked_fill(mask == 1, float(0.0))
return mask
def create_mask(src, tgt):
src_seq_len = src.shape[0]
tgt_seq_len = tgt.shape[0]
tgt_mask = generate_square_subsequent_mask(tgt_seq_len)
src_mask = torch.zeros((src_seq_len, src_seq_len), device=device).type(torch.bool)
src_padding_mask = (src == PAD_IDX).transpose(0, 1)
tgt_padding_mask = (tgt == PAD_IDX).transpose(0, 1)
return src_mask, tgt_mask, src_padding_mask, tgt_padding_mask3.5 定义模型参数并实例化模型
SRC_VOCAB_SIZE = len(ja_vocab)
TGT_VOCAB_SIZE = len(en_vocab)
EMB_SIZE = 512
NHEAD = 8
FFN_HID_DIM = 512
BATCH_SIZE = 16
NUM_ENCODER_LAYERS = 3
NUM_DECODER_LAYERS = 3
NUM_EPOCHS = 16
transformer = Seq2SeqTransformer(NUM_ENCODER_LAYERS, NUM_DECODER_LAYERS,
EMB_SIZE, SRC_VOCAB_SIZE, TGT_VOCAB_SIZE,
FFN_HID_DIM)
for p in transformer.parameters():
if p.dim() > 1:
nn.init.xavier_uniform_(p)
transformer = transformer.to(device)
loss_fn = torch.nn.CrossEntropyLoss(ignore_index=PAD_IDX)
optimizer = torch.optim.Adam(
transformer.parameters(), lr=0.0001, betas=(0.9, 0.98), eps=1e-9
)
# 执行一个训练周期
def train_epoch(model, train_iter, optimizer):
model.train()
losses = 0
for idx, (src, tgt) in enumerate(train_iter):
src = src.to(device)
tgt = tgt.to(device)
tgt_input = tgt[:-1, :]
src_mask, tgt_mask, src_padding_mask, tgt_padding_mask = create_mask(src, tgt_input)
logits = model(src, tgt_input, src_mask, tgt_mask,
src_padding_mask, tgt_padding_mask, src_padding_mask)
optimizer.zero_grad()
tgt_out = tgt[1:,:]
loss = loss_fn(logits.reshape(-1, logits.shape[-1]), tgt_out.reshape(-1))
loss.backward()
optimizer.step()
losses += loss.item()
return losses / len(train_iter)
# 评估当前模型，计算损失
def evaluate(model, val_iter):
model.eval()
losses = 0
for idx, (src, tgt) in (enumerate(valid_iter)):
src = src.to(device)
tgt = tgt.to(device)
tgt_input = tgt[:-1, :]
src_mask, tgt_mask, src_padding_mask, tgt_padding_mask = create_mask(src, tgt_input)
logits = model(src, tgt_input, src_mask, tgt_mask,
src_padding_mask, tgt_padding_mask, src_padding_mask)
tgt_out = tgt[1:,:]
loss = loss_fn(logits.reshape(-1, logits.shape[-1]), tgt_out.reshape(-1))
losses += loss.item()
return losses / len(val_iter)3.6 开始训练
# 使用数据训练模型，输出每轮信息
for epoch in tqdm.tqdm(range(1, NUM_EPOCHS+1)):
start_time = time.time()
train_loss = train_epoch(transformer, train_iter, optimizer)
end_time = time.time()
print((f"Epoch: {epoch}, Train loss: {train_loss:.3f}, "
f"Epoch time = {(end_time - start_time):.3f}s"))这里是我的运行结果：
3.7 使用经过训练的模型翻译
def greedy_decode(model, src, src_mask, max_len, start_symbol):
src = src.to(device)
src_mask = src_mask.to(device)
memory = model.encode(src, src_mask)
ys = torch.ones(1, 1).fill_(start_symbol).type(torch.long).to(device)
for i in range(max_len-1):
memory = memory.to(device)
memory_mask = torch.zeros(ys.shape[0], memory.shape[0]).to(device).type(torch.bool)
tgt_mask = (generate_square_subsequent_mask(ys.size(0))
.type(torch.bool)).to(device)
out = model.decode(ys, memory, tgt_mask)
out = out.transpose(0, 1)
prob = model.generator(out[:, -1])
_, next_word = torch.max(prob, dim = 1)
next_word = next_word.item()
ys = torch.cat([ys,
torch.ones(1, 1).type_as(src.data).fill_(next_word)], dim=0)
if next_word == EOS_IDX:
break
return ys
def translate(model, src, src_vocab, tgt_vocab, src_tokenizer):
model.eval()
tokens = [BOS_IDX] + [src_vocab.stoi[tok] for tok in src_tokenizer.encode(src, out_type=str)]+ [EOS_IDX]
num_tokens = len(tokens)
src = (torch.LongTensor(tokens).reshape(num_tokens, 1) )
src_mask = (torch.zeros(num_tokens, num_tokens)).type(torch.bool)
tgt_tokens = greedy_decode(model, src, src_mask, max_len=num_tokens + 5, start_symbol=BOS_IDX).flatten()
return " ".join([tgt_vocab.itos[tok] for tok in tgt_tokens]).replace("<bos>", "").replace("<eos>", "")# 使用训练好的模型翻译句子
translate(transformer, "HSコード 8515 はんだ付け用、ろう付け用又は溶接用の機器(電気式(電気加熱ガス式を含む。)", ja_vocab, en_vocab, ja_tokenizer)我的翻译结果：
3.8 保存模型
import pickle
# open a file, where you want to store the data
file = open('en_vocab.pkl', 'wb')
# dump information to that file
pickle.dump(en_vocab, file)
file.close()
file = open('ja_vocab.pkl', 'wb')
pickle.dump(ja_vocab, file)
file.close()
# 保存模型
torch.save(transformer.state_dict(), 'inference_model')4.总结
Transformer模型通过其独特的自注意力机制和高效的并行计算能力，在机器翻译领域开启了一个新篇章，不仅推动了翻译质量的大幅提升，也为自然语言处理的其他领域带来了深远的影响。希望这篇博客能让你对Transformer有所了解，可以训练出一个简单的机器翻译模型。
742
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
