【NLP】使用 PyTorch 从头构建自己的大型语言模型 (LLM)

news2024/11/13 4:01:20

读完这篇文章后,你会取得什么成就?你将能够自己构建和训练大型语言模型 (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下载地址icon-default.png?t=O83Ahttps://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 操作后转换为零或接近零。因此,模型将忽略这些值或无法学习任何东西。
def causal_mask(size):
        # 创建一个尺寸为“size x size”的方阵,并用 1 填充
        mask = torch.triu(torch.ones(1, size, size), diagonal = 1).type(torch.int)
        return mask == 0

# 创建一个数据加载器用于模型训练和验证
train_ds = EncodeDataset(raw_train_dataset, max_seq_len)
val_ds = EncodeDataset(raw_validation_dataset, max_seq_len)

train_dataloader = DataLoader(train_ds, batch_size = 12, shuffle = True)
val_dataloader = DataLoader(val_ds, batch_size = 1, shuffle = True)

步骤 4:输入嵌入和位置编码

输入嵌入:步骤 2 中从标记器生成的标记 ID 序列将被输入到嵌入层。嵌入层将标记 ID 映射到词汇表,并为每个标记生成一个维度为 512 的嵌入向量。[维度 512 取自注意力论文]。嵌入向量可以根据训练标记的训练数据集捕获标记的语义含义。嵌入向量内的每个维度值代表与标记相关的某种特征。例如,如果标记是狗,则某个维度值将代表眼睛、嘴巴、腿、身高等。如果我们在 n 维空间中绘制一个向量,看起来相似的物体(如狗和猫)将彼此靠近,而看起来不相似的物体(如学校和家庭)的嵌入向量将位于更远的地方。

位置编码: Transformer 架构的优点之一是它可以并行处理任意数量的输入序列,从而减少大量训练时间,并使预测速度更快。然而,一个缺点是,在并行处理许多 token 序列时,句子中 token 的位置将不按顺序排列。这可能会导致句子的含义或上下文不同,具体取决于 token 的位置。因此,为了解决这个问题,注意力论文实现了位置编码方法。本文建议在每个 token 的 512 维的索引级别上应用两个数学函数(一个是正弦,一个是余弦)。下面是简单的正弦和余弦数学函数。

sin函数应用于每个偶数维值,而Cosine函数应用于嵌入向量的奇数维值。最后,将生成的位置编码器向量添加到嵌入向量中。现在,我们有了可以捕获标记的语义含义以及标记的位置的嵌入向量。请注意,位置编码的值在每个序列中保持不变。

import torch
import torch.nn as nn
import math

# 步骤 4:输入嵌入和位置编码
class EmbeddingLayer(nn.Module):
    def __init__(self, d_model: int, vocab_size: int):
        super().__init__()
        self.d_model = d_model
        # 使用 pytorch 模型嵌入层将 token id 映射到具有 (vocab_size, d_model) 形状的嵌入向量
        # vocab_size 是步骤 2 中由 tokenizer 创建的训练数据的词汇量The vocab_size is the vocabulary size of the training data created by tokenizer in step 2
        self.embedding = nn.Embedding(vocab_size, d_model)

    def forward(self, input):
        # 除了为嵌入提供输入之外,额外乘以 d_model 的平方根是为了规范化嵌入层输出
        embedding_output = self.embedding(input) * math.sqrt(self.d_model)
        return embedding_output

class PositionalEncoding(nn.Module):
    def __init__(self, d_model: int, max_seq_len: int, dropout_rate: float):
        super().__init__()
        self.dropout = nn.Dropout(dropout_rate)
        pe = torch.zeros(max_seq_len, d_model)

        pos = torch.arange(0, max_seq_len, dtype=torch.float).unsqueeze(1)
        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))

        pe[:, 0::2] = torch.sin(pos * div_term)
        pe[:, 1::2] = torch.cos(pos * div_term)

        # 因为我们希望分批输入句子,所以需要在 0 位置添加额外的维度来满足批号
        pe = pe.unsqueeze(0)
        self.register_buffer('pe', pe)

    def forward(self, input_embdding):
        input_embdding = input_embdding + (self.pe[:, :input_embdding.shape[1], :]).requires_grad_(False)   # to prevent from calculating gradient
        return self.dropout(input_embdding)

步骤 5:多头注意力模块

正如 Transformer 是 LLM 的核心一样,自注意力机制是 Transformer 架构的核心。

那么为什么需要自我注意力呢?让我们用下面的一个简单的例子来回答这个问题。

句子 1句子2,单词“银行”显然有两个不同的含义。然而,“银行”在两个句子中是相同的。这不是正确的事物。我们希望嵌入值能够根据句子的上下文而改变。因此,我们需要一种机制,其中嵌入值可以动态改变,以根据句子的整体含义给出上下文含义. 自注意力机制可以根据句子动态地更新表示上下文含义的 embedding 值。

如果自注意力机制已经如此出色,为什么我们还需要多头自注意力机制?让我们看下面的另一个例子来找出答案。

在这个例子中,如果我们使用自注意力,它可能只关注句子的一个方面,可能只是一个“什么”方面,因为它只能捕获“约翰做了什么?”。然而,其他方面,如“何时”或“何地”,对于模型更好的表现也同样重要。所以,我们需要找到一种方法让自注意力机制一次学习一个句子中的多种关系。因此,这就是多头自注意力(多头注意力可以互换使用)的用武之地。在多头注意力中,单头嵌入将被分成多个头,以便每个头将研究句子的不同方面并相应地学习。这正是我们想要的。

现在,我们知道了为什么需要多头注意力。让我们看看如何实现。多头注意力实际上是如何工作的?让我们深入研究一下。

如果你熟悉矩阵乘法,那么理解该机制对你来说是一件非常容易的事情。让我们先看一下整个流程图,我将在下面逐点描述中解释多头注意力从输入到输出的流程。

图片来源:https://github.com/hkproj/transformer 从头笔记开始

1. 首先,让我们制作 3 个编码器输入副本(输入嵌入和位置编码的组合,我们在步骤 4 中已经完成了)。让我们给它们每个起一个名字 Q、K 和 V。它们每个都只是编码器输入的一个副本。编码器输入形状:(seq_len,d_model),seq_len:最大序列长度,d_model:嵌入向量维度在本例中为 512。

2. 接下来,我们将对 Q 和权重 W_q、K 和权重 W_k 以及 V 和权重 W_v 进行矩阵乘法。每个权重矩阵的形状为 (d_model, d_model)。生成的新查询嵌入向量的形状为 (seq_len, d_model)。权重参数将由模型随机初始化,稍后将在模型开始训练时更新。为什么我们首先需要权重矩阵乘法?因为这些是查询、键和值嵌入向量需要的可学习参数,以提供更好的表示。

3. 根据注意力论文,头部数量为 8。每个新的查询嵌入向量将被划分为 8 个较小的查询、键和值嵌入向量单元。嵌入向量的新形状为 (seq_len, d_model/num_heads) 或 (seq_len, d_k)。[ d_k = d_model/num_heads ]。

4. 每个查询嵌入向量将对其自身的关键嵌入向量的转置以及序列中所有其他嵌入向量执行点积运算。此点积给出注意力分数。注意力分数显示给定标记与给定输入序列中所有其他标记的相似程度。分数越高,相似度越高。

  • 然后,注意力得分将除以 d_k 的平方根,这是对矩阵中的分数值进行归一化所必需的。但为什么必须除以 d_k 才能归一化,它可以是任何其他数字。主要原因是,随着嵌入向量维数的增加,注意力矩阵中的总方差会成比例增加。这就是为什么除以 d_k 会平衡方差的增加。如果我们不除以 d_k,对于任何给定的较高注意力得分,softmax 函数将给出一个非常高的概率值,同样,对于任何低注意力得分值,softmax 函数将给出一个非常低的概率值。这最终会使模型只关注学习具有这些概率值的特征而忽略具有较低概率值的特征,这将导致梯度消失。因此,对注意力得分矩阵进行归一化是非常必要的。
  • 在执行 softmax 函数之前,如果编码器掩码不为 None,则注意力得分将与编码器掩码进行矩阵乘法。如果掩码是因果掩码,则输入序列中位于其后的嵌入标记的注意力得分值将被 -ve 无穷大替换。softmax 函数将 -ve 无穷大值转换为接近零的值。因此,模型将不会学习当前标记之后的那些特征。这就是我们可以防止未来标记影响我们的模型学习的方法。

5. 然后将 softmax 函数应用于注意力分数矩阵并输出形状为 (seq_len, seq_len) 的权重矩阵。

6. 然后,这些权重矩阵将与相应的嵌入向量进行矩阵乘法。这将产生 8 个具有形状 (seq_len, d_v) 的注意力头。[ d_v = d_model/num_heads ]。

7. 最后,所有 head 将被连接成一个具有新形状 (seq_len, d_model) 的单个 Head。这个新的单个 head 将与输出权重矩阵 W_o (d_model, d_model) 进行矩阵乘法。多头注意力的最终输出代表单词的上下文含义以及学习输入句子的多个方面的能力。

有了它,让我们开始编写更简单、更简短的多头注意力块。

# Step 5: Multihead Attention
class MultiHeadAttention(nn.Module):
    def __init__(self, d_model: int, num_heads: int, dropout_rate: float):
        super().__init__()
        # Defining dropout to prevent overfitting
        self.dropout = nn.Dropout(dropout_rate)
        self.num_heads = num_heads
        assert d_model % num_heads == 0, "d_model must be divisible by number of heads"

        # d_k is the new dimension of each self attention heads
        self.d_k = d_model // num_heads

        # Weight matrix are defined which are all learnable parameters
        self.W_q = nn.Linear(d_model, d_model, bias=False)
        self.W_k = nn.Linear(d_model, d_model, bias=False)
        self.W_v = nn.Linear(d_model, d_model, bias=False)
        self.W_o = nn.Linear(d_model, d_model, bias=False)

    def forward(self, q, k, v, encoder_mask):

        # Please note that we'll be training our model with not just a single sequence but rather batches of sequence, hence we'll include batch_size in the shape
        # query, Key and value are calculated by matrix multiplication of corresponding weights with the input embeddings
        # Change of shape: q(batch_size, seq_len, d_model) @ W_q(d_model, d_model) => query(batch_size, seq_len, d_model) [same goes to key and value]
        query = self.W_q(q)
        key = self.W_k(k)
        value = self.W_v(v)

        # Dividing query, key and value into number of heads, hence new dimenstion will be d_k.
        # Change of shape: query(batch_size, seq_len, d_model) => query(batch_size, seq_len, num_heads, d_k) -> query(batch_size,num_heads, seq_len,d_k) [same goes to key and value]
        query = query.view(query.shape[0], query.shape[1], self.num_heads ,self.d_k).transpose(1,2)
        key = key.view(key.shape[0], key.shape[1], self.num_heads ,self.d_k).transpose(1,2)
        value = value.view(value.shape[0], value.shape[1], self.num_heads ,self.d_k).transpose(1,2)

        # :: SELF ATTENTION BLOCK STARTS ::

        # Attention score is calculated to find the similarity or relation of query with key of itself and all other embedding in the sequence
        #  Change of shape: query(batch_size,num_heads, seq_len,d_k) @ key(batch_size,num_heads, seq_len,d_k) => attention_score(batch_size,num_heads, seq_len,seq_len)
        attention_score = (query @ key.transpose(-2,-1))/math.sqrt(self.d_k)

        # If mask is provided the attention score needs to modify as per the mask value. Refer to the details in point no 4.
        if encoder_mask is not None:
          attention_score.masked_fill_(encoder_mask==0, -1e9)

        # Softmax operation calculates the probability distribution among all the attention scores. This will determine which embedding is more similar to the given query embedding and assign the attention weight accordingly.
        # Change of shape: same as attention_score
        attention_score = attention_score.softmax(dim=-1)

        if self.dropout is not None:
          attention_score = self.dropout(attention_score)

        # Final step of Self attention block is to matrix multiplication of attention_weight with value embedding.
        # Change of shape: attention_score(batch_size,num_heads, seq_len,seq_len) @  value(batch_size,num_heads, seq_len,d_k) => attention_output(batch_size,num_heads, seq_len,d_k)
        attention_output = attention_score @ value

        # :: SELF ATTENTION BLOCK ENDS ::

        # Now, all the heads will be concated back to for a single head
        # Change of shape:attention_output(batch_size,num_heads, seq_len,d_k) => attention_output(batch_size,seq_len,num_heads,d_k) => attention_output(batch_size,seq_len,d_model)
        attention_output = attention_output.transpose(1,2).contiguous().view(attention_output.shape[0], -1, self.num_heads * self.d_k)

        # Finally attention_output is matrix multiplied with output weight matrix to give the final Multi-Head attention output.
        # The shape of the multihead_output is same as the embedding input
        # Change of shape: attention_output(batch_size,seq_len,d_model) @ W_o(d_model, d_model) => multihead_output(batch_size, seq_len, d_model)
        multihead_output = self.W_o(attention_output)

        return multihead_output

步骤 6:前馈网络、层归一化和 AddAndNorm

前馈网络:前馈网络使用深度神经网络来学习两个线性层(第一层有 d_model 节点,第二层有 d_ff 节点,根据注意力论文分配值)中嵌入向量的所有特征,并且将 ReLU 激活函数应用于第一线性层的输出,为嵌入值提供非线性,并应用 dropout 以进一步避免过度拟合。

层归一化:我们对嵌入值应用层规范化,以确保网络中嵌入向量的值分布保持一致。这确保了学习的顺利进行。我们将使用称为 gamma 和 beta 的额外学习参数根据网络需要缩放和移动嵌入值。

AddAndNorm:这由一个跳跃连接和一个分层归一化(前面已解释)组成。在前向传播过程中,跳跃连接确保前一层的特征在后续阶段仍能被记住,从而在计算输出时做出必要的贡献。同样,在反向传播过程中,跳跃连接通过在每个阶段少执行一次反向传播来确保防止梯度消失。AddAndNorm 在编码器(2 次)和解码器块(3 次)中均有使用。它从前一层获取输入并首先对其进行归一化,然后将其添加到前一层的输出中。

# Step 6: Feedfoward Network, Layer Normalization and AddAndNorm

class FeedForward(nn.Module):
    def __init__(self, d_model: int, d_ff: int, dropout_rate: float):
        super().__init__()

        self.dropout = nn.Dropout(dropout_rate)
        self.layer_1 = nn.Linear(d_model, d_ff)
        self.layer_2 = nn.Linear(d_ff, d_model)

    def forward(self, input):
        return self.layer_2(self.dropout(torch.relu(self.layer_1(input))))

class LayerNorm(nn.Module):
    # def __init__(self, features:int=512, eps: float = 1e-5):
    def __init__(self, eps: float = 1e-5):
        super().__init__()
        # epsilon is a very small value and is plays an important role to avoid division by zero problem
        self.eps = eps
        #Extra learning parameters gamma and beta are introduced to scale and shift the embedding value as the network needed.
        self.gamma = nn.Parameter(torch.ones(512))  # 512 = advisable to initialize with same number as d_model
        self.beta = nn.Parameter(torch.zeros(512))

    def forward(self, input):
        mean = input.mean(dim = -1, keepdim=True)
        std = input.std(dim = -1, keepdim=True)
        return self.gamma * (input - mean)/(std + self.eps) + self.beta

class AddAndNorm(nn.Module):
  def __init__(self, dropout_rate: float):
        super().__init__()
        self.dropout = nn.Dropout(dropout_rate)
        self.layer_norm = LayerNorm()

  def forward(self, input, sub_layer):
        return input + self.dropout(sub_layer(self.layer_norm(input)))

步骤 7:编码器块和编码器

编码器块:编码器块内部有两个主要组件:多头注意力和前馈。还有 2 个 Add 和 Norm 单元。我们将首先按照 Attention 论文中的流程在 EncoderBlock 类中组装所有这些组件。根据论文,此编码器块已重复 6 次。

编码器:然后我们将创建一个名为 Encoder 的附加类,它将获取 EncoderBlock 堆栈列表并给出最终的编码器输出。

#Step 7: Encoder block and Encoder

class EncoderBlock(nn.Module):
    # def __init__(self, features: int, self_attention_block: MultiHeadAttention, feed_forward_block: FeedForward, dropout_rate: float) -> None:
    def __init__(self, multihead_attention: MultiHeadAttention, feed_forward: FeedForward, dropout_rate: float) -> None:
        super().__init__()
        self.multihead_attention = multihead_attention
        self.feed_forward = feed_forward
        self.addnorm_1 = AddAndNorm(dropout_rate)
        self.addnorm_2 = AddAndNorm(dropout_rate)

    def forward(self, encoder_input, encoder_mask):
        # First AddAndNorm unit taking encoder input from skip connection and adding it with the output of MultiHead attention block
        encoder_input = self.addnorm_1(encoder_input, lambda encoder_input: self.multihead_attention(encoder_input, encoder_input, encoder_input, encoder_mask))
        # Second AddAndNorm unit taking output of MultiHead attention block from skip connection and adding it with the output of Feedforward layer
        encoder_input = self.addnorm_2(encoder_input, self.feed_forward)
        return encoder_input

class Encoder(nn.Module):
    def __init__(self, encoderblocklist: nn.ModuleList) -> None:
        super().__init__()
        # Encoder class initialized by taking encoderblock list
        self.encoderblocklist = encoderblocklist
        self.layer_norm = LayerNorm()

    def forward(self, encoder_input, encoder_mask):
        # Looping through all the encoder block - 6 times
        for encoderblock in self.encoderblocklist:
            encoder_input = encoderblock(encoder_input, encoder_mask)
        # Normalize the final encoder block output and return. This encoder output will be used later on as key and value for the cross attention in decoder block
        encoder_output = self.layer_norm(encoder_input)
        return encoder_output

步骤 8:解码器块、解码器和投影层

解码器块:解码器块中有三个主要组件:Masked Multi-Head Attention、Multi-Head Attention 和 Feedforward。解码器块还有 3 个 Add 和 Norm 单元。我们将按照 Attention 论文中的流程在 DecoderBlock 类中组装所有这些组件。根据论文,这个解码器块已经重复了 6 次。

解码器:我们将创建一个名为 Decoder 的附加类,它将获取 DecoderBlock 列表、将其堆叠,并给出最终的解码器输出。

解码器块中有两种类型的多头注意力。第一种是屏蔽多头注意力。它将解码器输入作为查询、键和值以及解码器掩码(也称为因果掩码)。因果掩码可防止模型查看序列顺序中领先的嵌入。其工作原理的详细说明请参见步骤 3 和步骤 5。

投影层:最终的解码器输出将被传递到投影层。在此层中,解码器输出将首先输入到线性层,其中嵌入的形状将按照下面的代码部分提供的方式发生变化。随后,softmax 函数将解码器输出转换为词汇表上的概率分布,并选择概率最高的标记作为预测输出。

#Step 8: Decoder block and decoder and the projection

class DecoderBlock(nn.Module):
    # def __init__(self, features: int, self_attention_block: MultiHeadAttention, cross_attention_block: MultiHeadAttention, feed_forward_block: FeedForward, dropout_rate: float) -> None:
    def __init__(self, masked_multihead_attention: MultiHeadAttention, cross_multihead_attention: MultiHeadAttention, feed_forward: FeedForward, dropout_rate: float) -> None:
        super().__init__()
        self.masked_multihead_attention = masked_multihead_attention
        self.cross_multihead_attention = cross_multihead_attention
        self.feed_forward = feed_forward
        self.addnorm_1 = AddAndNorm(dropout_rate)
        self.addnorm_2 = AddAndNorm(dropout_rate)
        self.addnorm_3 = AddAndNorm(dropout_rate)

    def forward(self, decoder_input, encoder_output, encoder_mask, decoder_mask):
        # First AddAndNorm unit taking decoder input from skip connection and adding it with the output of Masked Multi-Head attention block
        decoder_input = self.addnorm_1(decoder_input, lambda decoder_input: self.masked_multihead_attention(decoder_input, decoder_input, decoder_input, decoder_mask))
        # Second AddAndNorm unit taking output of Masked Multi-Head attention block from skip connection and adding it with the output of MultiHead attention block
        decoder_input = self.addnorm_2(decoder_input, lambda decoder_input: self.cross_multihead_attention(decoder_input, encoder_output, encoder_output, encoder_mask))
        # Third AddAndNorm unit taking output of MultiHead attention block from skip connection and adding it with the output of Feedforward layer
        decoder_input = self.addnorm_3(decoder_input, self.feed_forward)
        return decoder_input

class Decoder(nn.Module):
    # def __init__(self, features: int, layers: nn.ModuleList) -> None:
    def __init__(self, decoderblocklist: nn.ModuleList) -> None:
        super().__init__()
        self.decoderblocklist = decoderblocklist
        self.layer_norm = LayerNorm()

    def forward(self, decoder_input, encoder_output, encoder_mask, decoder_mask):
        for decoderblock in self.decoderblocklist:
            decoder_input = decoderblock(decoder_input, encoder_output, encoder_mask, decoder_mask)
        decoder_output = self.layer_norm(decoder_input)
        return decoder_output

class ProjectionLayer(nn.Module):
    def __init__(self, d_model, vocab_size) -> None:
        super().__init__()
        self.projection_layer = nn.Linear(d_model, vocab_size)

    def forward(self, decoder_output) -> None:
        # Projection layer first take in decoder output and feed into the linear layer of shape (d_model, vocab_size)
        #Change in shape: decoder_output(batch_size, seq_len, d_model) @ linear_layer(d_model, vocab_size) => output(batch_size, seq_len, vocab_size)
        output = self.projection_layer(decoder_output)
        return output

步骤 9:创建并构建 Transformer

最后,我们完成了 Transformer 架构中所有组件块的构建。唯一未完成的任务是将它们组装在一起。

首先我们创建一个Transformer 类,它将初始化所有组件类的实例。在 Transformer 类中,我们首先定义编码函数,该函数执行 Transformer 编码器部分的所有任务并生成编码器输出。

其次,我们定义一个解码函数,它完成 Transformer 的解码器部分的所有任务并生成解码器输出。

第三,我们定义一个投影函数,它接收解码器输出并将输出映射到词汇表进行预测。

现在,Transformer 架构已准备就绪。我们现在可以构建翻译 LLM 模型,方法是定义一个函数,该函数接受以下代码中给出的所有必要参数。

#Step 9: Create and build Transfomer

class Transformer(nn.Module):
    def __init__(self, encoder: Encoder, decoder: Decoder, source_embed: EmbeddingLayer, target_embed: EmbeddingLayer, source_pos: PositionalEncoding, target_pos: PositionalEncoding, projection_layer: ProjectionLayer) -> None:
        super().__init__()

        self.source_embed = source_embed
        self.source_pos = source_pos
        self.encoder = encoder

        self.target_embed = target_embed
        self.target_pos = target_pos
        self.decoder = decoder

        self.projection_layer = projection_layer

    def encode(self, encoder_input, encoder_mask):
        encoder_input = self.source_embed(encoder_input)
        encoder_input = self.source_pos(encoder_input)
        encoder_output = self.encoder(encoder_input, encoder_mask)
        return encoder_output

    def decode(self, encoder_output, encoder_mask, decoder_input, decoder_mask):
        decoder_input = self.target_embed(decoder_input)
        decoder_input = self.target_pos(decoder_input)
        decoder_output = self.decoder(decoder_input, encoder_output, encoder_mask, decoder_mask)
        return decoder_output

    def project(self, decoder_output):
        return self.projection_layer(decoder_output)

def build_model(source_vocab_size: int, target_vocab_size: int, source_seq_len: int, target_seq_len: int, d_model: int=512, num_blocks: int=6, num_heads: int=8, dropout_rate: float=0.1, d_ff: int=2048) -> Transformer:
    # Create the embedding layers
    source_embed = EmbeddingLayer(d_model, source_vocab_size)
    target_embed = EmbeddingLayer(d_model, target_vocab_size)

    # Create the positional encoding layers
    source_pos = PositionalEncoding(d_model, source_seq_len, dropout_rate)
    target_pos = PositionalEncoding(d_model, target_seq_len, dropout_rate)

    # Create the encoder-block-list
    encoderblocklist = []
    for _ in range(num_blocks):
        multihead_attention = MultiHeadAttention(d_model, num_heads, dropout_rate)
        feed_forward = FeedForward(d_model, d_ff, dropout_rate)
        encoder_block = EncoderBlock(multihead_attention, feed_forward, dropout_rate)
        encoderblocklist.append(encoder_block)
    # Create the encoder
    encoder = Encoder(nn.ModuleList(encoderblocklist))

    # Create the decoder-block-list
    decoderblocklist = []
    for _ in range(num_blocks):
        masked_multihead_attention = MultiHeadAttention(d_model,num_heads, dropout_rate)
        cross_multihead_attention = MultiHeadAttention(d_model, num_heads, dropout_rate)
        feed_forward = FeedForward(d_model, d_ff, dropout_rate)
        decoder_block = DecoderBlock(masked_multihead_attention, cross_multihead_attention, feed_forward, dropout_rate)
        decoderblocklist.append(decoder_block)
    # Create the decoder
    decoder = Decoder(nn.ModuleList(decoderblocklist))

    # Create the projection layer
    projection_layer = ProjectionLayer(d_model, target_vocab_size)

    # Now that we've initialized all the required blocks of transformer, we can now inititiate a model
    model = Transformer(encoder, decoder, source_embed, target_embed, source_pos, target_pos, projection_layer)

    # For the first time, we'll initialize the model parameters using xavier uniform method. Once training begings the parameters will be updated by the network
    for p in model.parameters():
        if p.dim() > 1:
            nn.init.xavier_uniform_(p)

    return model
# Let's build the the final model.
model = build_model(tokenizer_en.get_vocab_size(), tokenizer_zh.get_vocab_size(),max_seq_len, max_seq_len, d_model=512).to(device)

# Let's look at the architecture that we've just build ourself
print(model)
Transformer(
  (source_embed): EmbeddingLayer(
    (embedding): Embedding(9326, 512)
  )
  (source_pos): PositionalEncoding(
    (dropout): Dropout(p=0.1, inplace=False)
  )
  (encoder): Encoder(
    (encoderblocklist): ModuleList(
      (0-5): 6 x EncoderBlock(
        (multihead_attention): MultiHeadAttention(
          (dropout): Dropout(p=0.1, inplace=False)
          (W_q): Linear(in_features=512, out_features=512, bias=False)
          (W_k): Linear(in_features=512, out_features=512, bias=False)
          (W_v): Linear(in_features=512, out_features=512, bias=False)
          (W_o): Linear(in_features=512, out_features=512, bias=False)
        )
        (feed_forward): FeedForward(
          (dropout): Dropout(p=0.1, inplace=False)
          (layer_1): Linear(in_features=512, out_features=2048, bias=True)
          (layer_2): Linear(in_features=2048, out_features=512, bias=True)
        )
        (addnorm_1): AddAndNorm(
          (dropout): Dropout(p=0.1, inplace=False)
          (layer_norm): LayerNorm()
        )
        (addnorm_2): AddAndNorm(
          (dropout): Dropout(p=0.1, inplace=False)
          (layer_norm): LayerNorm()
        )
      )
    )
    (layer_norm): LayerNorm()
  )
  (target_embed): EmbeddingLayer(
    (embedding): Embedding(13004, 512)
  )
  (target_pos): PositionalEncoding(
    (dropout): Dropout(p=0.1, inplace=False)
  )
  (decoder): Decoder(
    (decoderblocklist): ModuleList(
      (0-5): 6 x DecoderBlock(
        (masked_multihead_attention): MultiHeadAttention(
          (dropout): Dropout(p=0.1, inplace=False)
          (W_q): Linear(in_features=512, out_features=512, bias=False)
          (W_k): Linear(in_features=512, out_features=512, bias=False)
          (W_v): Linear(in_features=512, out_features=512, bias=False)
          (W_o): Linear(in_features=512, out_features=512, bias=False)
        )
        (cross_multihead_attention): MultiHeadAttention(
          (dropout): Dropout(p=0.1, inplace=False)
          (W_q): Linear(in_features=512, out_features=512, bias=False)
          (W_k): Linear(in_features=512, out_features=512, bias=False)
          (W_v): Linear(in_features=512, out_features=512, bias=False)
          (W_o): Linear(in_features=512, out_features=512, bias=False)
        )
        (feed_forward): FeedForward(
          (dropout): Dropout(p=0.1, inplace=False)
          (layer_1): Linear(in_features=512, out_features=2048, bias=True)
          (layer_2): Linear(in_features=2048, out_features=512, bias=True)
        )
        (addnorm_1): AddAndNorm(
          (dropout): Dropout(p=0.1, inplace=False)
          (layer_norm): LayerNorm()
        )
        (addnorm_2): AddAndNorm(
          (dropout): Dropout(p=0.1, inplace=False)
          (layer_norm): LayerNorm()
        )
        (addnorm_3): AddAndNorm(
          (dropout): Dropout(p=0.1, inplace=False)
          (layer_norm): LayerNorm()
        )
      )
    )
    (layer_norm): LayerNorm()
  )
  (projection_layer): ProjectionLayer(
    (projection_layer): Linear(in_features=512, out_features=13004, bias=True)
  )
)

步骤 10:训练和验证我们构建的 LLM 模型

现在是时候训练我们的模型了。训练过程非常简单。我们将使用在步骤 3 中创建的训练 DataLoader。由于总训练数据集数量为 100 万,我强烈建议在 GPU 设备上训练我们的模型。我花了大约 5 小时完成 20 个 epoch。每个 epoch 之后,我们将保存模型权重以及优化器状态,​​这样就可以更容易地从停止之前的点恢复训练,而不是从头开始恢复。

每次迭代后,我们都会使用验证 DataLoader 启动一次验证。验证数据集的大小为 2000,这非常合理。在验证过程中,我们只需要计算一次编码器输出,直到解码器输出获得句末标记 [SEP],这是因为在解码器获得 [SEP] 标记之前,我们必须一次又一次地发送相同的编码器输出,这毫无意义

解码器输入将首先从句子标记 [CLS] 的开头开始。每次预测后,解码器输入将附加下一个生成的标记,直到到达句子标记 [SEP] 的结尾。最后,投影层将输出映射到相应的文本表示。

#Step 10: Training and Validation of chineseGPT

def run_validation(model, validation_ds, tokenizer_en, tokenizer_zh, max_seq_len, device, print_msg, global_step):
    model.eval()
    count = 0

    with torch.no_grad():
        for batch in validation_ds:
            count += 1
            encoder_input = batch["encoder_input"].to(device)
            encoder_mask = batch["encoder_mask"].to(device)

            cls_id = tokenizer_zh.token_to_id('[CLS]')
            sep_id = tokenizer_zh.token_to_id('[SEP]')

            # Computing the output of the encoder for the source sequence
            encoder_output = model.encode(encoder_input, encoder_mask)
            # for prediction task, the first token that goes in decoder input is the [CLS] token
            decoder_input = torch.empty(1, 1).fill_(cls_id).type_as(encoder_input).to(device)
            # since we need to keep adding the output back to the input until the [SEP] - end token is received.
            while True:
                # check if the max length is received
                if decoder_input.size(1) == max_seq_len:
                    break

                # recreate mask each time the new output is added the decoder input for next token prediction
                decoder_mask = causal_mask(decoder_input.size(1)).type_as(encoder_mask).to(device)

                # apply projection only to the next token
                out = model.decode(encoder_output, encoder_mask, decoder_input, decoder_mask)

                # apply projection only to the next token
                prob = model.project(out[:, -1])

                # select the token with highest probablity which is a greedy search implementation
                _, next_word = torch.max(prob, dim=1)
                decoder_input = torch.cat(
                    [decoder_input, torch.empty(1, 1).type_as(encoder_input).fill_(next_word.item()).to(device)], dim=1
                )
                # check if the new token is the end of token
                if next_word == sep_id:
                    break
            # final output is the concatinated decoder input till the end token is reached
            model_out = decoder_input.squeeze(0)

            source_text = batch["source_text"][0]
            target_text = batch["target_text"][0]
            model_out_text = tokenizer_zh.decode(model_out.detach().cpu().numpy())

            # Print the source, target and model output
            print_msg('-'*55)
            # print_msg(f"{f'SOURCE: ':>12}{source_text}")
            # print_msg(f"{f'TARGET: ':>12}{target_text}")
            # print_msg(f"{f'PREDICTED: ':>12}{model_out_text}")
            print_msg(f'Source Text: {source_text}')
            print_msg(f'Target Text: {target_text}')
            print_msg(f'Predicted by ChineseGPT: {model_out_text}')

            if count == 2:
                break

def train_model(preload_epoch=None):
    # The entire training, validation cycle will run for 20 cycles or epochs.
    EPOCHS = 10
    initial_epoch = 0
    global_step = 0

    # Adam is one of the most commonly used optimization algorithms that hold the current state and will update the parameters based on the computed gradients.
    optimizer = torch.optim.AdamW(model.parameters(), lr=2e-4, eps=1e-9)

    # If the preload_epoch is not none, that means the training will start with the weights, optimizer that has been last saved and start with preload epoch + 1
    if preload_epoch is not None:
      model_filename = f"./malaygpt/model_{preload_epoch}.pt"
      state = torch.load(model_filename)
      model.load_state_dict(state['model_state_dict'])
      initial_epoch = state['epoch'] + 1
      optimizer.load_state_dict(state['optimizer_state_dict'])
      global_step = state['global_step']

    # The CrossEntropyLoss loss function computes the difference between the projection output and target label.
    loss_fn = nn.CrossEntropyLoss(ignore_index=tokenizer_en.token_to_id('[PAD]'), label_smoothing=0.1).to(device)

    for epoch in range(initial_epoch, EPOCHS):
        # torch.cuda.empty_cache()
        model.train()
        batch_iterator = tqdm(train_dataloader, desc=f"Processing Epoch {epoch:02d}")
        for batch in batch_iterator:
            encoder_input = batch['encoder_input'].to(device) # (b, seq_len)
            decoder_input = batch['decoder_input'].to(device) # (B, seq_len)
            encoder_mask = batch['encoder_mask'].to(device) # (B, 1, 1, seq_len)
            decoder_mask = batch['decoder_mask'].to(device) # (B, 1, seq_len, seq_len)
            target_label = batch['target_label'].to(device) # (B, seq_len)

            # Run the tensors through the encoder, decoder and the projection layer
            encoder_output = model.encode(encoder_input, encoder_mask) # (B, seq_len, d_model)
            decoder_output = model.decode(encoder_output, encoder_mask, decoder_input, decoder_mask) # (B, seq_len, d_model)
            projection_output = model.project(decoder_output) # (B, seq_len, vocab_size)

            # Compute the loss using a simple cross entropy
            loss = loss_fn(projection_output.view(-1, tokenizer_zh.get_vocab_size()), target_label.view(-1))
            batch_iterator.set_postfix({"loss": f"{loss.item():6.3f}"})

            # Backpropagate the loss
            loss.backward()

            # Update the weights
            optimizer.step()
            optimizer.zero_grad(set_to_none=True)

            global_step += 1

        # VALIDATION BLOCK STARTS HERE [Runs every epoch after the training block is complete]
        run_validation(model, val_dataloader, tokenizer_en, tokenizer_zh, max_seq_len, device, lambda msg: batch_iterator.write(msg), global_step)

        # Save the model at the end of every epoch
        model_filename = f"./chinesegpt/model_{epoch}.pt"
        torch.save({
            'epoch': epoch,
            'model_state_dict': model.state_dict(),
            'optimizer_state_dict': optimizer.state_dict(),
            'global_step': global_step
        }, model_filename)


# Train our model
train_model(preload_epoch=None)

步骤 11:创建一个函数来使用我们建立的模型测试新的翻译任务

我们将为我们的翻译函数赋予一个新的通用名称,称为 chinesegpt。该函数接收用户输入的英语原始文本,并输出汉语翻译文本。让我们运行该函数并尝试一下。

#Step 11: Finally testing our chineseGPT model to translated new sentences. Let's give it a try.

def chinesegpt(user_input_text):

    # validation using input text
    user_input_text = str(user_input_text).strip()

    # Let's get the model Define the device, tokenizers, and model
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    tokenizer_en = Tokenizer.from_file("./tokenizer_en/tokenizer_en.json")
    tokenizer_zh = Tokenizer.from_file("./tokenizer_zh/tokenizer_zh.json")

    # Build our model
    # model = build_model(tokenizer_en.get_vocab_size(), tokenizer_my.get_vocab_size(), max_seq_len, max_seq_len, d_model=512).to(device)
    # model = get_model(tokenizer_en.get_vocab_size(), tokenizer_my.get_vocab_size()).to(device)
    model = build_model(tokenizer_en.get_vocab_size(), tokenizer_zh.get_vocab_size(),max_seq_len, max_seq_len, d_model=512).to(device)

    # Load the specific checkpoint of the model that you've saved during training.
    checkpoint_number = 9    # for this test, I am taking checkpoint number 10
    model_filename = f"./chinesegpt/model_{checkpoint_number}.pt"
    state = torch.load(model_filename)
    model.load_state_dict(state['model_state_dict'])

    # Lets beging the inferencing
    model.eval()
    with torch.no_grad():
        # Precompute the encoder output and reuse it for every generation step
        source_text_encoding = tokenizer_en.encode(user_input_text)
        source_text_encoding = torch.cat([
            torch.tensor([tokenizer_en.token_to_id('[CLS]')], dtype=torch.int64),
            torch.tensor(source_text_encoding.ids, dtype=torch.int64),
            torch.tensor([tokenizer_en.token_to_id('[SEP]')], dtype=torch.int64),
            torch.tensor([tokenizer_en.token_to_id('[PAD]')] * (max_seq_len - len(source_text_encoding.ids) - 2), dtype=torch.int64)
        ], dim=0).to(device)
        source_mask = (source_text_encoding != tokenizer_en.token_to_id('[PAD]')).unsqueeze(0).unsqueeze(0).int().to(device)
        encoder_output = model.encode(source_text_encoding, source_mask)

        # Initialize the decoder input with the sos token
        decoder_input = torch.empty(1, 1).fill_(tokenizer_zh.token_to_id('[CLS]')).type_as(source_text_encoding).to(device)

        # Generate the translation word by word
        while decoder_input.size(1) < max_seq_len:
            # build mask for target and calculate output
            decoder_mask = torch.triu(torch.ones((1, decoder_input.size(1), decoder_input.size(1))), diagonal=1).type(torch.int).type_as(source_mask).to(device)
            out = model.decode(encoder_output, source_mask, decoder_input, decoder_mask)

            # project next token
            prob = model.project(out[:, -1])
            _, next_word = torch.max(prob, dim=1)
            decoder_input = torch.cat([decoder_input, torch.empty(1, 1).type_as(source_text_encoding).fill_(next_word.item()).to(device)], dim=1)

            # print the translated word
            # print(f"{tokenizer_zh.decode([next_word.item()])}", end=' ')

            # break if we predict the end of sentence token
            if next_word == tokenizer_zh.token_to_id('[SEP]'):
                break

    # convert ids to tokens
    return tokenizer_zh.decode(decoder_input[0].tolist())

测试时间到了!让我们进行一些翻译测试。 


# Test 1: Translation using chineseGPT
user_input = "This term may extend to seven years and with fine in case of subsequent violations."
transalated_text = chinesegpt(user_input)

print(f"User input (in English): {user_input}")
print(f"Translation (in Chinese): {transalated_text}")

# Test 2: Translation using chineseGPT
user_input = "Delegations welcomed the progress made by CEB in ensuring a coordinated approach by the system on this issue."
transalated_text = chinesegpt(user_input)

print(f"User input (in English): {user_input}")
print(f"Translation (in Chinese): {transalated_text}")

“ 翻译效果似乎还不错。”

就是这样!我非常有信心,您现在能够使用 PyTorch 从头开始​​构建自己的大型语言模型。您也可以在其他语言数据集上训练此模型,并以该语言执行翻译任务。现在,您已经学会了如何从头开始构建原始转换器,我可以向您保证,您现在能够在目前市场上大多数可用的 LLM 上学习和实现自己的应用程序。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/2238048.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

css:还是语法

emmet的使用 emmet是一个插件&#xff0c;Emmet 是 Zen Coding 的升级版&#xff0c;由 Zen Coding 的原作者进行开发&#xff0c;可以快速的编写 HTML、CSS 以及实现其他的功能。很多文本编辑器都支持&#xff0c;我们只是学会使用它&#xff1a; 生成html结构 <!-- emme…

YOLO即插即用---PConv

Run, Don’t Walk: Chasing Higher FLOPS for Faster Neural Networks 论文地址&#xff1a; 1. 论文解决的问题 2. 解决问题的方法 3. PConv 的适用范围 4. PConv 在目标检测中的应用 5. 评估方法 6. 潜在挑战 7. 未来研究方向 8.即插即用代码 论文地址&#xff1a; …

小白NAS磁盘规划实践:一次科学、高效的存储旅程

引言 如今,数字化生活正逐步渗透到我们生活的方方面面。从家庭影音到工作文件,从珍贵的照片到大型游戏库,数据的存储需求日益增加。许多朋友开始关注NAS(网络附加存储)设备。作为一个专为数据存储和管理设计的系统,NAS能为我们提供安全、高效的存储方案。但如何科学地规…

ADC前端控制与处理模块--AD7606_Module

总体框架 AD7606_Module主要由3个模块组成组成&#xff0c;AD7606_Data_Pkt和AD7606_Drive以及AD7606_ctrl。 1.AD7606_Data_Pkt主要作用是把AD芯片数据组好数据包&#xff0c;然后发送给上位机&#xff1b; 2.AD7606_Drive主要负责和芯片的交互部分 3.AD7606_ctrl控制模块的作…

注意力机制篇 | YOLO11改进 | 即插即用的高效多尺度注意力模块EMA

前言&#xff1a;Hello大家好&#xff0c;我是小哥谈。与传统的注意力机制相比&#xff0c;多尺度注意力机制引入了多个尺度的注意力权重&#xff0c;让模型能够更好地理解和处理复杂数据。这种机制通过在不同尺度上捕捉输入数据的特征&#xff0c;让模型同时关注局部细节和全局…

dell服务器安装ESXI8

1.下载镜像在官网 2.打开ipmi&#xff08;idrac&#xff09;&#xff0c;将esxi镜像挂载&#xff0c;然后服务器开机 3.进入bios设置cpu虚拟化开启&#xff0c;进入boot设置启动选项为映像方式 4..进入安装引导界面3.加载完配置进入安装 系统提示点击继 5.选择安装磁盘进行…

Linux -- 操作系统(软件)

目录 什么是操作系统&#xff1f; 计算机的层状结构 为什么要有操作系统 操作系统到底层硬件 驱动程序 操作系统如何管理硬件&#xff1f; 操作系统到用户 系统调用接口 库函数 回到问题 什么是操作系统&#xff1f; 操作系统&#xff08;Operating System&#xf…

【大数据算法】MapReduce算法概述之:MapReduce基础模型

MapReduce基础模型 1、引言2、MapReduce基础模型2.1 定义2.2 核心原理2.3 优点2.4 缺点2.5 局限性2.6 实例 3、总结 1、引言 小屌丝&#xff1a;鱼哥&#xff0c;鱼哥&#xff0c; 不得了啊 小鱼&#xff1a;啥事情这么慌慌张张的 小屌丝&#xff1a;这不是慌张啊 小鱼&#x…

深入解析 Transformers 框架(四):Qwen2.5/GPT 分词流程与 BPE 分词算法技术细节详解

前面我们已经通过三篇文章&#xff0c;详细介绍了 Qwen2.5 大语言模型在 Transformers 框架中的技术细节&#xff0c;包括包和对象加载、模型初始化和分词器技术细节&#xff1a; 深入解析 Transformers 框架&#xff08;一&#xff09;&#xff1a;包和对象加载中的设计巧思与…

商品详情 API 接口的返回结果通常包含哪些信息?

商品详情 API 接口的返回结果通常包含以下几类信息&#xff1a; 一、商品基本信息&#xff1a; 商品 ID&#xff1a;唯一标识商品的编号&#xff0c;在电商平台的数据库中具有唯一性&#xff0c;用于区分不同的商品。商品标题&#xff1a;对商品的简要描述&#xff0c;通常包…

探索 Seata 分布式事务

Seata&#xff08;Simple Extensible Autonomous Transaction Architecture&#xff09;是阿里巴巴开源的一款分布式事务解决方案&#xff0c;旨在帮助开发者解决微服务架构下的分布式事务问题。它提供了高效且易于使用的分布式事务管理能力&#xff0c;支持多种事务模式&#…

AI写作(七)的核心技术探秘:情感分析与观点挖掘

一、AI 写作中的关键技术概述 情感分析与观点挖掘在 AI 写作中起着至关重要的作用。情感分析能够帮助 AI 理解文本中的情感倾向&#xff0c;无论是正面、负面还是中性。在当今信息时代&#xff0c;准确把握用户情绪对于提供个性化体验和做出明智决策至关重要。例如&#xff0c;…

容器化技术入门:Docker详解

&#x1f493; 博客主页&#xff1a;瑕疵的CSDN主页 &#x1f4dd; Gitee主页&#xff1a;瑕疵的gitee主页 ⏩ 文章专栏&#xff1a;《热点资讯》 容器化技术入门&#xff1a;Docker详解 容器化技术入门&#xff1a;Docker详解 容器化技术入门&#xff1a;Docker详解 引言 Doc…

Flutter运行App时出现“Running Gradle task ‘assembleDebug“问题解决

在参考了众多解决办法中最有用并且最快的方法 Gradle Distributions 在这个地方下载对应你这个文件中的gradle版本 然后将 最后一行本来不是这样的,我们把下载好的zip包保存到本地,然后用这个代替网址,最后成功运行

Spark中的shuffle

Shuffle的本质基于磁盘划分来解决分布式大数据量的全局分组、全局排序、重新分区【增大】的问题。 1、Spark的Shuffle设计 Spark Shuffle过程也叫作宽依赖过程&#xff0c;Spark不完全依赖于内存计算&#xff0c;面临以上问题时&#xff0c;也需要Shuffle过程。 2、Spark中哪…

window11安装elasticsearch+Kibana

1、下载elasticsearch与elasticsearch 下载elasticsearch 查看elasticsearch对应的Kibana版本 下载elasticsearch解压后文件目录如下 可执行脚本文件,包括启动elasticsearch服务、插件管理、函数命令等 bin配置文件目录,如elasticsearch配置、角色配置、jvm配置等 conf 默认…

linux rocky 9.4部署和管理docker harbor私有源

文章目录 Harbor简介安装Harbor技术细节1.安装系统(略),设置主机名和IP2.安装docker3.安装docker-compose4.安装Harbor私有源仓库5 测试登录1.本机登录2.客户端登录Harbor服务器配置docker源1. 下载镜像2.把镜像上传到Harbor私有仓库源3.客户端下载镜像,并且启动容器linux …

【计算机网络五】HTTP协议!网站运行的奥秘!

目录 HTTP协议 1.HTTP是什么&#xff1f; 2.Fiddler抓包查看HTTP协议格式 3.HTTP请求 4.HTTP响应 HTTP协议 1.HTTP是什么&#xff1f; HTTP ( 全称为 " 超文本传输协议 ") 诞生与 1991 年 . 目前已经发展为最主流使用的一种应用层协议 . HTTP 的前几个版本…

嵌入式硬件实战基础篇(一)-STM32+DAC0832 可调信号发生器-产生方波-三角波-正弦波

引言&#xff1a;本内容主要用作于学习巩固嵌入式硬件内容知识&#xff0c;用于想提升下述能力&#xff0c;针对学习STM32与DAC0832产生波形以及波形转换&#xff0c;对于硬件的降压和对于前面硬件篇的实际运用&#xff0c;针对仿真的使用&#xff0c;具体如下&#xff1a; 设…

ubuntu 24.04运行chattts时cuda安装错误原因分析

使用ubuntu 24.04&#xff0c;按照2noise/ChatTTS官方流程安装依赖时报错。ChatTTShttps://github.com/2noise/ChatTTS 这是因为cuda版本不对&#xff0c;ChatTTS目前的版本&#xff0c;要求支持cuda 12.4及以上&#xff0c;但是如果nvidia显卡驱动版本较老&#xff0c;无法支…