
读完这篇文章后,你会取得什么成就?你将能够自己构建和训练大型语言模型 (LLM),同时与我一起编写代码。虽然我们正在构建一个将任何给定文本从英语翻译成马来语的 LLM,但你可以轻松地修改此 LLM 架构以用于其他语言翻译任务。
LLM 是 ChatGPT、Gemini、MetaAI、Mistral AI 等最流行的 AI 聊天机器人的核心基础。每个 LLM 的核心都有一个名为Transformer 的架构。因此,我们将首先根据著名论文“Attention is all you need”构建 Transformer 架构。

论文《Attention is all you need》中的 Transformer 架构
首先,我们将逐块构建 Transformer 模型的所有组件。然后,我们将组装所有块以构建我们的模型。之后,我们将使用从 Hugging Face 数据集中获取的数据集来训练和验证我们的模型。最后,我们将通过对新的翻译文本数据执行翻译来测试我们的模型。
重要提示:我将逐步编写 Transformer 架构中的所有组件,并提供关于什么、为什么和如何的概念的必要解释。我还会对我认为需要解释的逐行代码提供注释。这样,我相信您可以在自己编码时与整体工作流程联系起来。

让我们一起编码吧!
步骤 1:加载数据集
为了使 LLM 模型能够完成从英语翻译成汉语的任务,我们需要使用包含源语言(英语)和目标语言(汉语)对的数据集。因此,我们将使用 Huggingface 的数据集“ Helsinki-NLP/opus-100 ”。它有 100 万对英语-汉语训练数据集,足以获得良好的准确性,并且在验证和测试数据集中各有 1000 个数据。它已经预先分割,所以我们不必再次进行数据集分割。
opus-100-en-ch下载地址
https://download.csdn.net/download/sikh_0529/89971506
#步骤1:加载数据并将其分为训练、验证和测试数据
import os
import math
import torch
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader, random_split
from pathlib import Path
from datasets import load_dataset
from tqdm import tqdm
if not os.path.exists("./chinesegpt"):
os.mkdir("./chinesegpt")
if not os.path.exists("./tokenizer_en"):
os.mkdir("./tokenizer_en")
if not os.path.exists("./tokenizer_zh"):
os.mkdir("./tokenizer_zh")
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
dataset = load_dataset("parquet", data_files={'train': './data/train-00000-of-00001.parquet', 'validation': './data/validation-00000-of-00001.parquet'})
train_dataset = dataset['train']
validation_dataset = dataset['validation']
raw_train_dataset, rt_to_skip = random_split(train_dataset, [4800,len(train_dataset)-4800])
raw_validation_dataset, vt_to_skip = random_split(validation_dataset, [100,len(validation_dataset)-100])
步骤 2:创建 Tokenizer
Transformer 模型不处理原始文本,它只处理数字。因此,我们必须做一些事情来将原始文本转换为数字。为此,我们将使用一种流行的标记器,称为 BPE 标记器,这是一种子词标记器,正在 GPT3 等模型中使用。我们将首先在我们在步骤 1 中准备的语料库数据(在我们的例子中是训练数据集)上训练 BPE 标记器。流程如下图所示。

标记器流程
训练完成后,分词器会为英语和汉语生成词汇表。词汇表是来自语料库数据的唯一标记的集合。由于我们正在执行翻译任务,因此我们需要两种语言的分词器。BPE 分词器获取原始文本,将其与词汇表中的标记进行映射,并为输入原始文本中的每个单词返回一个标记。标记可以是单个单词或子词。这是子词分词器相对于其他分词器的优势之一,因为它可以克服 OOV(词汇表之外)问题。然后,分词器返回词汇表中标记的唯一索引或位置 ID,该索引或位置 ID 将进一步用于创建嵌入,如上图所示。
#步骤2:创建分词器
from tokenizers import Tokenizer
from tokenizers.models import BPE
from tokenizers.trainers import BpeTrainer
from tokenizers.pre_tokenizers import Whitespace
def get_ds_iterator(raw_train_dataset, lang):
for data in raw_train_dataset:
yield data['translation'][lang]
# 创建源分词器 - 英文
tokenizer_en = Tokenizer(BPE(unk_token="[UNK]"))
trainer_en = BpeTrainer(min_frequency=2, special_tokens=["[PAD]","[UNK]","[CLS]", "[SEP]", "[MASK]"])
# 我们还需要添加预分词器将输入拆分成单词,因为如果没有预分词器,我们可能会得到与几个单词重叠的分词:例如,我们可以得到“there is”因为这两个词经常出现在一起,所以将它们合并为一个词。
# 使用预标记器将确保没有标记大于预标记器返回的单词。
tokenizer_en.pre_tokenizer = Whitespace()
tokenizer_en.train_from_iterator(get_ds_iterator(raw_train_dataset, "en"), trainer=trainer_en)
tokenizer_en.save("./tokenizer_en/tokenizer_en.json")
# 创建目标标记器 - 汉语
tokenizer_zh = Tokenizer(BPE(unk_token="[UNK]"))
trainer_zh = BpeTrainer(min_frequency=2, special_tokens=["[PAD]","[UNK]","[CLS]", "[SEP]", "[MASK]"])
tokenizer_zh.pre_tokenizer = Whitespace()
tokenizer_zh.train_from_iterator(get_ds_iterator(raw_train_dataset, "zh"), trainer=trainer_zh)
tokenizer_zh.save("./tokenizer_zh/tokenizer_zh.json")
tokenizer_en = Tokenizer.from_file("./tokenizer_en/tokenizer_en.json")
tokenizer_zh = Tokenizer.from_file("./tokenizer_zh/tokenizer_zh.json")
source_vocab_size = tokenizer_en.get_vocab_size()
target_vocab_size = tokenizer_zh.get_vocab_size()
# 计算源数据集和目标数据集的整个训练数据集中的最大序列长度
max_seq_len_source = 0
max_seq_len_target = 0
for data in raw_train_dataset:
enc_ids = tokenizer_en.encode(data['translation']['en']).ids
dec_ids = tokenizer_zh.encode(data['translation']['zh']).ids
max_seq_len_source = max(max_seq_len_source, len(enc_ids))
max_seq_len_target = max(max_seq_len_target, len(dec_ids))
print(f'max_seqlen_source: {max_seq_len_source}') # 根据您的情况可能有所不同
print(f'max_seqlen_target: {max_seq_len_target}') # 根据您的情况可能有所不同
# 为了使其成为我们训练的标准,我们只需采用 max_seq_len_source 并添加 20-50 即可覆盖其他标记,例如 PAD、 CLS,SEP
max_seq_len = 480
步骤 3:准备数据集和DataLoader
在此步骤中,我们将为源语言和目标语言准备一个数据集,稍后将使用该数据集来训练和验证我们将要构建的模型。我们将创建一个接收原始数据集的类,并定义一个使用源 (tokenizer_en) 和目标 (tokenizer_zh) 标记器分别对源文本和目标文本进行编码的函数。最后,我们将为训练和验证数据集创建一个 DataLoader,该 DataLoader 会分批迭代数据集(在我们的示例中,批大小将设置为 10)。批大小可以根据数据大小和可用的处理能力进行更改。
# 步骤 3:准备数据集和数据加载器
# 将原始数据集转换为可由模型
class EncodeDataset(Dataset):
def __init__(self, raw_dataset, max_seq_len):
super().__init__()
self.raw_dataset = raw_dataset
self.max_seq_len = max_seq_len
def __len__(self):
return len(self.raw_dataset)
def __getitem__(self, index):
# 获取给定索引值的包含英语和汉语的单个数据raw_text。
raw_text = self.raw_dataset[index]
# 按源语言和目标语言分隔文本,稍后将用于编码。
source_text = raw_text['translation']['en']
target_text = raw_text['translation']['zh']
# 使用英语标记器对源文本进行编码,使用汉语标记器对目标文本进行编码
source_text_encoded = tokenizer_en.encode(source_text).ids
target_text_encoded = tokenizer_zh.encode(target_text).ids
# 使用标记器将 CLS、SEP 和 PAD 标记转换为词汇表中相应的索引 id [该 id 与任一标记器相同]
CLS_ID = torch.tensor([tokenizer_zh.token_to_id("[CLS]")], dtype=torch.int64)
SEP_ID = torch.tensor([tokenizer_zh.token_to_id("[SEP]")], dtype=torch.int64)
PAD_ID = torch.tensor([tokenizer_zh.token_to_id("[PAD]")], dtype=torch.int64)
# 为了训练模型,每个输入的序列长度应等于最大序列长度。因此,如果长度不等于最大序列长度,则会向输入序列添加额外的填充数。
num_source_padding = self.max_seq_len - len(source_text_encoded) - 2
num_target_padding = self.max_seq_len - len(target_text_encoded) - 1
encoder_padding = torch.tensor([PAD_ID] * num_source_padding, dtype = torch.int64)
decoder_padding = torch.tensor([PAD_ID] * num_target_padding, dtype = torch.int64)
#encoder_input的第一个标记是句子的开头-CLS_ID,接着是源编码,然后是句末标记-SEP。
#为了达到所需的max_seq_len,将在末尾添加额外的PAD令牌。
encoder_input = torch.cat([CLS_ID, torch.tensor(source_text_encoded, dtype=torch.int64), SEP_ID, encoder_padding], dim=0)
#decoder_input的第一个标记是句子的开头-CLS_ID,后面是目标编码。
#为了达到所需的max_seq_len,将在末尾添加额外的PAD令牌。解码器输入中没有句末标记-SEP。
decoder_input = torch.cat([CLS_ID, torch.tensor(target_text_encoded, dtype=torch.int64), decoder_padding ], dim=0)
# 训练期间需要 target_label 进行损失计算,以比较预测标签和目标标签。
# target_label 具有第一个标记作为目标编码,后跟实际目标编码。目标标签中没有句子开头标记 - CLS。
# 为了达到所需的 max_seq_len,将在末尾添加额外的 PAD 标记。
target_label = torch.cat([torch.tensor(target_text_encoded, dtype=torch.int64),SEP_ID,decoder_padding], dim=0)
# 由于我们在输入编码中添加了额外的填充标记,因此我们不希望模型训练此标记。
# 因此,我们将使用编码器掩码在编码器块中产生自注意的输出之前使填充值无效
encoder_mask = (encoder_input != PAD_ID).unsqueeze(0).unsqueeze(0).int()
# 我们不希望任何标记在解码阶段影响未来的标记。 因此,在掩蔽多头注意期间实施因果掩码来处理这个问题。
decoder_mask = (decoder_input != PAD_ID).unsqueeze(0).unsqueeze(0).int() & causal_mask(decoder_input.size(0))
return {
'encoder_input': encoder_input,
'decoder_input': decoder_input,
'target_label': target_label,
'encoder_mask': encoder_mask,
'decoder_mask': decoder_mask,
'source_text': source_text,
'target_text': target_text
}
# 因果掩码将确保当前标记之后的任何标记都将被掩码,这意味着该值将被负无穷替换,并在 softmax 操作后转换为零或接近
1819



被折叠的 条评论
为什么被折叠?



