阅读量:0
LLMs之llama3-from-scratch：llama3-from-scratch(从头开始利用pytorch来实现并解读LLaMA-3模型的每层代码)的简介、核心思路梳理
导读：这篇论文实现了transformer网络的llama3模型，从头开始利用pytorch来实现该模型。
背景：目前机器学习语言模型内容的复杂性不断增强，但是大多模型都是基于高度抽象和封装的框架来实现，对模型内部工作机制的理解不是很深入。这篇论文采用从零开始逐步实现的方式，帮助读者更好地理解transformer和llama3模型是如何工作的。
具体解决方案：作者加载了llama3预训练模型的参数，并按照每个算子依次实现。
流程和关键步骤：
>> 加载tokenizer对文本进行tokenize
>> 从模型文件加载各层参数
>> 对输入文本的tokens生成嵌入向量
>> 对嵌入向量进行RMSNorm标准化
>> 实现单头注意力机制，包括Q、K、V矩阵的生成、位置编码、掩码、softmax计算注意力权重等
>> 循环实现多头注意力
>> 加载FFN层的参数实现前向传播
>> 循环上述步骤实现整个模型
>> 应用训练好的输出层参数进行预测
关键技术点
>> 利用RoPE位置编码为Q、K向量添加位置信息
>> 多头注意力分头计算并拼接
>> SwiGLU结构的FFN层
>> 应用RMSNorm进行标准化
>> 循环实现每一层的计算
>> 代码运行效果
>> 最后利用加载的llama3模型在样本问题"答案是什么"上正确预测答案为42，验证了从零开始实现的整个流程是正确的。
总之，这篇论文采用详尽清晰的流程，帮助读者通过实际实现深入理解transformer模型底层工作机制，是一篇值得推荐的论文。
目录
0.1、加载tokenizer对文本进行tokenize：将文本转换为模型可以理解的数字序列（即词元或tokens）+并在生成模型输出后能将tokens转换回可读文本（解码）
0.2、从模型文件加载各层参数：从预训练模型文件中读取权重参数
1、输入嵌入层：采用tiktoken库的BPE算法将输入文本的tokens转换为嵌入向量，为模型处理做好准备
1.1、文本分词并编码：将一段文本(输入)转换为token ID(输出)。将输入的自然语言经过分词技术转换为token ID，如下所示，一句话包含17个token(可以简单理解为单词)
1.2、离散token进行嵌入向量化：将离散的token ID(输入，形状为【17,1】)转换为其连续的嵌入向量表示(输出，形状为【17,4096】)，以便进行后续的运算
1.3、采用RMSNorm对嵌入向量进行均方根归一化：仅对嵌入进行归一化处理，前后形状未变，只是确保数值稳定，避免后续计算过程中出现数值0问题
2、位置编码层：为词元嵌入添加位置信息，使模型能理解词元的顺序
2.1、背景——构建Transformer的第一个层：准备嵌入以输入到Transformer层进行处理，实现Transformer网络结构的前向传播
2.2、背景——计算每个token在Transformer第一层第一个头的query向量
2.3、真正实现RoPE：此处以Query向量进行RoPE为例讲解，但Key与Query几乎相同
3.1、MHA模块—从零开始实现注意力机制：计算不同词元之间的关联度，提取重要信息。包括Q、K、V矩阵的生成、位置编码、掩码、softmax计算注意力权重等
3.1.1、计算查询(Query)、键(Key)：生成用于注意力机制中每一个token的query和key；
3.1.2、计算注意力分数矩阵并掩码：计算注意力分数并进行掩码，确保模型不会关注未来的词元
3.1.3、值（Value）的计算：根据注意力分数和value向量计算最终的注意力输出
3.1.4、多头注意力的合并：将多个注意力头的输出合并为一个向量
3.1.5、注意力输出权重矩阵：将合并后的注意力输出转换为嵌入向量的修正
3.1.6、嵌入向量的更新：将注意力机制的输出加到原始嵌入向量上，更新嵌入信息
3.2、FFNN层：在嵌入向量上应用前馈网络，增加模型的非线性
3.3.1、所有层的迭代：将上述过程在每一层中进行迭代处理，逐层增强表示能力
3.3.2、最后的归一化：对最终嵌入向量进行归一化处理，用于预测下一个token
4.1、将嵌入向量转换为预测的token：确认logits张量的形状
5、模型推理：应用训练好的输出层参数进行预测(验证整个代码的正确性)，模型预测下一个token的编号为2983，这是42的token ID吗？
llama3-from-scratch的简介
2024年5月20日，Nishant Aklecha正式发布了该项目，在这个文件中，我从头实现了llama3，一次一个张量和矩阵乘法。此外，我将直接从Meta为llama3提供的模型文件中加载张量，在运行此文件之前需要下载权重。以下是下载权重的官方链接：https://llama.meta.com/llama-downloads/
GitHub地址：GitHub - naklecha/llama3-from-scratch: llama3 implementation one matrix multiplication at a time
llama3-from-scratch的核心思路梳理
注意：当前文章仍处于持续更新和梳理中……
0、前置
0.1、加载tokenizer对文本进行tokenize：将文本转换为模型可以理解的数字序列（即词元或tokens）+并在生成模型输出后能将tokens转换回可读文本（解码）
简介 | 我不会实现一个BPE分词器（但是Andrej Karpathy有一个非常简洁的实现） 链接到他的实现： https://github.com/karpathy/minbpe 该项目给出了一个针对中文分词任务的最小化、清晰而可读的Python实现Byte Pair Encoding(BPE)算法的代码库。它实现了两个Tokenizer对象用于文本到词元和词元到文本的转换：BasicTokenizer和RegexTokenizer。 |
思路步骤 | 从Meta下载权重文件。 使用tiktoken库加载BPE分词器，并定义特殊token。 |
核心技术点 | BPE分词：字节对编码（Byte Pair Encoding）是一种常见的分词方法，用于处理词汇表。 |
| 代码解读 | 目的是设置和测试一个自定义的
|
from pathlib import Path import tiktoken from tiktoken.load import load_tiktoken_bpe import torch import json import matplotlib.pyplot as plt tokenizer_path = "Meta-Llama-3-8B/tokenizer.model" special_tokens = [ "<|begin_of_text|>", "<|end_of_text|>", "<|reserved_special_token_0|>", "<|reserved_special_token_1|>", "<|reserved_special_token_2|>", "<|reserved_special_token_3|>", "<|start_header_id|>", "<|end_header_id|>", "<|reserved_special_token_4|>", "<|eot_id|>", # end of turn ] + [f"<|reserved_special_token_{i}|>" for i in range(5, 256 - 5)] mergeable_ranks = load_tiktoken_bpe(tokenizer_path) tokenizer = tiktoken.Encoding( name=Path(tokenizer_path).name, pat_str=r"(?i:'s|'t|'re|'ve|'m|'ll|'d)|[^\r\n\p{L}\p{N}]?\p{L}+|\p{N}{1,3}| ?[^\s\p{L}\p{N}]+[\r\n]*|\s*[\r\n]+|\s+(?!\S)|\s+", mergeable_ranks=mergeable_ranks, special_tokens={token: len(mergeable_ranks) + i for i, token in enumerate(special_tokens)}, ) tokenizer.decode(tokenizer.encode("hello world!"))0.2、从模型文件加载各层参数：从预训练模型文件中读取权重参数
简介 | 通常情况下，读取模型文件取决于模型类的编写方式和其中的变量名称。但由于我们要从头实现llama3，所以我们将逐个张量读取文件。 我们使用此配置来推断模型的细节，模型有32个Transformer层，每个多头注意力块有32个头，n_kv_heads，词汇表大小为128256等等。 下面是各个参数的含义：
|
思路步骤 | 加载模型文件，查看模型参数。 读取模型配置文件，获取模型的详细参数。 |
核心技术点 | 模型文件加载：使用torch.load加载模型权重文件。 配置解析：解析配置文件以提取模型超参数。 |
model = torch.load("Meta-Llama-3-8B/consolidated.00.pth") print(json.dumps(list(model.keys())[:20], indent=4)) [ "tok_embeddings.weight", "layers.0.attention.wq.weight", "layers.0.attention.wk.weight", "layers.0.attention.wv.weight", "layers.0.attention.wo.weight", "layers.0.feed_forward.w1.weight", "layers.0.feed_forward.w3.weight", "layers.0.feed_forward.w2.weight", "layers.0.attention_norm.weight", "layers.0.ffn_norm.weight", "layers.1.attention.wq.weight", "layers.1.attention.wk.weight", "layers.1.attention.wv.weight", "layers.1.attention.wo.weight", "layers.1.feed_forward.w1.weight", "layers.1.feed_forward.w3.weight", "layers.1.feed_forward.w2.weight", "layers.1.attention_norm.weight", "layers.1.ffn_norm.weight", "layers.2.attention.wq.weight" ] with open("Meta-Llama-3-8B/params.json", "r") as f: config = json.load(f) config {'dim': 4096, 'n_layers': 32, 'n_heads': 32, 'n_kv_heads': 8, 'vocab_size': 128256, 'multiple_of': 1024, 'ffn_dim_multiplier': 1.3, 'norm_eps': 1e-05, 'rope_theta': 500000.0} dim = config["dim"] n_layers = config["n_layers"] n_heads = config["n_heads"] n_kv_heads = config["n_kv_heads"] vocab_size = config["vocab_size"] multiple_of = config["multiple_of"] ffn_dim_multiplier = config["ffn_dim_multiplier"] norm_eps = config["norm_eps"] rope_theta = torch.tensor(config["rope_theta"]) 1、输入嵌入层：采用tiktoken库的BPE算法将输入文本的tokens转换为嵌入向量，为模型处理做好准备
1.1、文本分词并编码：将一段文本(输入)转换为token ID(输出)。将输入的自然语言经过分词技术转换为token ID，如下所示，一句话包含17个token(可以简单理解为单词)
简介 | 这里我们使用tiktoken（我认为是OpenAI的库）作为分词器。 |
思路步骤 | 输入一个提示文本，并使用分词器将其转换为tokens。 打印tokens及其对应的文本表示。 |
核心技术点 | 分词：使用分词器将文本转换为token ID。 文本表示：解码token ID为文本以验证分词过程。 |
prompt = "the answer to the ultimate question of life, the universe, and everything is " tokens = [128000] + tokenizer.encode(prompt) print(tokens) tokens = torch.tensor(tokens) prompt_split_as_tokens = [tokenizer.decode([token.item()]) for token in tokens] print(prompt_split_as_tokens) [128000, 1820, 4320, 311, 279, 17139, 3488, 315, 2324, 11, 279, 15861, 11, 323, 4395, 374, 220] ['<|begin_of_text|>', 'the', ' answer', ' to', ' the', ' ultimate', ' question', ' of', ' life', ',', ' the', ' universe', ',', ' and', ' everything', ' is', ' ']1.2、离散token进行嵌入向量化：将离散的token ID(输入，形状为【17,1】)转换为其连续的嵌入向量表示(输出，形状为【17,4096】)，以便进行后续的运算
简介 | 这是代码库中唯一使用内置神经网络模块的部分。 我们的[17x1] tokens现在是[17x4096]，即17个长度为4096的嵌入（每个token一个嵌入）。 注意：跟踪形状，这使它更容易理解一切 |
思路步骤 | 定义一个嵌入层，并加载预训练的权重。 将tokens转换为嵌入表示。 |
核心技术点 | 嵌入层：使用torch.nn.Embedding定义嵌入层，并加载预训练权重。 |
embedding_layer = torch.nn.Embedding(vocab_size, dim) embedding_layer.weight.data.copy_(model["tok_embeddings.weight"]) token_embeddings_unnormalized = embedding_layer(tokens).to(torch.bfloat16) token_embeddings_unnormalized.shape torch.Size([17, 4096])1.3、采用RMSNorm对嵌入向量进行均方根归一化：仅对嵌入进行归一化处理，前后形状未变，只是确保数值稳定，避免后续计算过程中出现数值0问题
简介 | 我们然后使用RMS归一化嵌入，请注意此步骤后形状不会改变，值只是被归一化了。需要注意的是我们需要一个norm_eps（从配置中获取），因为我们不想意外地将rms设为0并除以0。 公式如下： 归一化后我们的形状仍然是[17x4096]，与嵌入相同但已归一化。 |
思路步骤 | 对嵌入进行RMS归一化。 |
核心技术点 | RMS归一化：对嵌入向量进行均方根归一化（RMS Norm）。 |
# def rms_norm(tensor, norm_weights): # rms = (tensor.pow(2).mean(-1, keepdim=True) + norm_eps)**0.5 # return tensor * (norm_weights / rms) def rms_norm(tensor, norm_weights): return (tensor * torch.rsqrt(tensor.pow(2).mean(-1, keepdim=True) + norm_eps)) * norm_weights2、位置编码层：为词元嵌入添加位置信息，使模型能理解词元的顺序
2.1、背景——构建Transformer的第一个层：准备嵌入以输入到Transformer层进行处理，实现Transformer网络结构的前向传播
简介 | 您会看到我从这个模型字典中访问layer.0（这是第一层） 无论如何，所以归一化后，我们的形状仍然是【17x4096】，与嵌入相同但已归一化 |
思路步骤 | 构建Transformer的第一层： |
核心技术点 | 多头注意力机制（Multi-Head Attention）与残差连接 Transformer层：应用注意力机制和前馈神经网络进行特征提取和变换。 |
token_embeddings = rms_norm(token_embeddings_unnormalized, model["layers.0.attention_norm.weight"]) token_embeddings.shape torch.Size([17, 4096]) 2.2、背景——计算每个token在Transformer第一层第一个头的query向量
简介 | 让我们加载Transformer第一层的注意力头。 >> 加载查询Query、键Key、值Value和输出向量时，我们注意到它们的权重矩阵形状分别为[4096x4096]、[1024x4096]、[1024x4096]、[4096x4096]。 >> 乍一看这有点奇怪，因为我们理想情况下希望每个Query、Key、Value和输出分别对应每个头。而代码作者将它们捆绑在一起，因为这样做，有助于并行化注意力头的矩阵乘法。 接下来，我将展开所有内容... |
下一步，我将展开多个注意力头的查询，结果形状为[32x128x4096]。 这里，32是llama3的注意力头数，128是Query向量的大小，4096是token嵌入的大小。 | |
这里我访问第一层第一个头的Query权重矩阵，Query权重矩阵的大小为【128x4096】。 | |
我们现在，将Query权重【128x4096】与token嵌入【17x4096】相乘，以接收token的查询，即获得每个token的query。 结果形状为[17x128]，因为我们有17个token，每个token有一个128长度的query向量。 | |
思路步骤 | 通过查询、键和值向量计算注意力分数，提取输入中重要的信息。 加载第一层的查询、键、值和输出向量权重。 展开注意力头的查询权重矩阵。 计算token的查询向量。 |
核心技术点 | 自注意力（Self-Attention）的计算。 |
print( model["layers.0.attention.wq.weight"].shape, model["layers.0.attention.wk.weight"].shape, model["layers.0.attention.wv.weight"].shape, model["layers.0.attention.wo.weight"].shape ) torch.Size([4096, 4096]) torch.Size([1024, 4096]) torch.Size([1024, 4096]) torch.Size([4096, 4096]) q_layer0 = model["layers.0.attention.wq.weight"] head_dim = q_layer0.shape[0] // n_heads q_layer0 = q_layer0.view(n_heads, head_dim, dim) q_layer0.shape torch.Size([32, 128, 4096]) q_layer0_head0 = q_layer0[0] q_layer0_head0.shape torch.Size([128, 4096]) 2.3、真正实现RoPE：此处以Query向量进行RoPE为例讲解，但Key与Query几乎相同
| 背景 | |
痛点：现在，已经为prompt中的每个token生成了query向量，但每个单独的query向量并不知道它在prompt中的具体位置。我们现在处于每个token在我们的提示中有一个查询向量的阶段，但如果你想一想——单个查询向量对提示中的位置没有任何了解。例如：
期望：在我们的提示中我们使用了三次“the”，我们需要所有3个“the”token的查询向量（每个大小为[1x128]）根据它们在查询中的位置具有不同的query向量。 解决方案：采用RoPE（旋转位置嵌入）执行这些旋转操作。 RoPE：观看这个视频（这是我看的）来理解数学：https://www.youtube.com/watch?v=o29P0Kpobz0&t=530s | |
简介 | 在上述步骤中，我们将查询向量分成了若干对，并对每对应用一个旋转角度偏移！ 现在我们有一个大小为[17x64x2]的向量，这是将128长度的query向量，对每个prompt中的每个token分成的64对，这64对中的每一对都会按照m*(theta) 进行旋转，其中m是要为其旋转query的token的位置！ 使用复数的点积来旋转向量 |
现在我们为每个token的query元素得到了一个复数（角度变化向量），我们可以将我们的query（即我们之前分成的对）转换为复数，然后使用点积根据位置旋转query向量。 老实说，想到这一点真是太美妙了 :) | |
在获得旋转后的向量后，我们可以通过将复数，重新视为实数，来得到(或来还原)成对的query向量。 旋转后的对现在被合并，我们现在有了一个新的query向量（旋转后的query向量），其形状为 [17x128]，其中17是token的数量，128是query向量的维度。 | |
准备基向量: 基向量定义为一个由二维位置（p）索引的表情形（对于大小为128的嵌入，生成的形状为[64]）。此基向量本质上是一个在0到θ之间等距离的线性间隔。 为提示生成旋转向量 为了生成旋转向量，我们将基向量乘以0到16之间的整数，这些整数是我们提示中token的位置。此乘法后的结果形状为[17x64]，其中每行表示token的旋转向量。 应用RoPE到查询向量 最后，我们可以将我们的查询向量与旋转向量结合，生成位置编码的查询向量。每个查询向量现在被旋转以反映它们在提示中的位置。 最终位置编码的查询向量 我们现在有一个大小为[17x128]的查询向量，每个token都有它在提示中位置的旋转编码。 | |
思路步骤 | 生成RoPE（旋转位置嵌入）以编码token的位置信息。 将查询向量与位置编码向量结合，生成位置编码的查询向量。 |
核心技术点 | 旋转位置编码（RoPE）：使用旋转位置嵌入（RoPE）将位置信息编码到查询向量中。 向量旋转：使用cos和sin函数对查询向量进行旋转，结合位置编码信息。 |
zero_to_one_split_into_64_parts = torch.tensor(range(64))/64 zero_to_one_split_into_64_parts tensor([0.0000, 0.0156, 0.0312, 0.0469, 0.0625, 0.0781, 0.0938, 0.1094, 0.1250, 0.1406, 0.1562, 0.1719, 0.1875, 0.2031, 0.2188, 0.2344, 0.2500, 0.2656, 0.2812, 0.2969, 0.3125, 0.3281, 0.3438, 0.3594, 0.3750, 0.3906, 0.4062, 0.4219, 0.4375, 0.4531, 0.4688, 0.4844, 0.5000, 0.5156, 0.5312, 0.5469, 0.5625, 0.5781, 0.5938, 0.6094, 0.6250, 0.6406, 0.6562, 0.6719, 0.6875, 0.7031, 0.7188, 0.7344, 0.7500, 0.7656, 0.7812, 0.7969, 0.8125, 0.8281, 0.8438, 0.8594, 0.8750, 0.8906, 0.9062, 0.9219, 0.9375, 0.9531, 0.9688, 0.9844]) freqs = 1.0 / (rope_theta ** zero_to_one_split_into_64_parts) freqs tensor([1.0000e+00, 8.1462e-01, 6.6360e-01, 5.4058e-01, 4.4037e-01, 3.5873e-01, 2.9223e-01, 2.3805e-01, 1.9392e-01, 1.5797e-01, 1.2869e-01, 1.0483e-01, 8.5397e-02, 6.9566e-02, 5.6670e-02, 4.6164e-02, 3.7606e-02, 3.0635e-02, 2.4955e-02, 2.0329e-02, 1.6560e-02, 1.3490e-02, 1.0990e-02, 8.9523e-03, 7.2927e-03, 5.9407e-03, 4.8394e-03, 3.9423e-03, 3.2114e-03, 2.6161e-03, 2.1311e-03, 1.7360e-03, 1.4142e-03, 1.1520e-03, 9.3847e-04, 7.6450e-04, 6.2277e-04, 5.0732e-04, 4.1327e-04, 3.3666e-04, 2.7425e-04, 2.2341e-04, 1.8199e-04, 1.4825e-04, 1.2077e-04, 9.8381e-05, 8.0143e-05, 6.5286e-05, 5.3183e-05, 4.3324e-05, 3.5292e-05, 2.8750e-05, 2.3420e-05, 1.9078e-05, 1.5542e-05, 1.2660e-05, 1.0313e-05, 8.4015e-06, 6.8440e-06, 5.5752e-06, 4.5417e-06, 3.6997e-06, 3.0139e-06, 2.4551e-06]) freqs_for_each_token = torch.outer(torch.arange(17), freqs) freqs_cis = torch.polar(torch.ones_like(freqs_for_each_token), freqs_for_each_token) freqs_cis.shape # viewing tjhe third row of freqs_cis value = freqs_cis[3] plt.figure() for i, element in enumerate(value[:17]): plt.plot([0, element.real], [0, element.imag], color='blue', linewidth=1, label=f"Index: {i}") plt.annotate(f"{i}", xy=(element.real, element.imag), color='red') plt.xlabel('Real') plt.ylabel('Imaginary') plt.title('Plot of one row of freqs_cis') plt.show() q_per_token_as_complex_numbers = torch.view_as_complex(q_per_token_split_into_pairs) q_per_token_as_complex_numbers.shape torch.Size([17, 64]) q_per_token_as_complex_numbers_rotated = q_per_token_as_complex_numbers * freqs_cis q_per_token_as_complex_numbers_rotated.shape torch.Size([17, 64]) q_per_token_split_into_pairs_rotated = torch.view_as_real(q_per_token_as_complex_numbers_rotated) q_per_token_split_into_pairs_rotated.shape torch.Size([17, 64, 2]) q_per_token_rotated = q_per_token_split_into_pairs_rotated.view(q_per_token.shape) q_per_token_rotated.shape torch.Size([17, 128])3、LLaMA的核心模块
3.1、MHA模块—从零开始实现注意力机制：计算不同词元之间的关联度，提取重要信息。包括Q、K、V矩阵的生成、位置编码、掩码、softmax计算注意力权重等
3.1.1、计算查询(Query)、键(Key)：生成用于注意力机制中每一个token的query和key；
简介 | 查询Query、键Key、值Value和输出向量 |
思路步骤 | Key键向量生成 >> key向量维度为128。 >> key的权重共享机制，key的权重只有query的四分之一,，这是因为每4个头共享一次，以减少计算量。 >> key向量也进行旋转以加入位置信息，原因与query相同。 |
Query向量生成及旋转，增加位置信息。 查询向量与键向量的维度匹配。 旋转操作用于引入位置编码。 | |
在这个阶段，我们现在有了每个token旋转后的query和key，其中每一个query和key现在的形状是[17x128]。 | |
核心技术点 | 矩阵乘法与旋转位置编码 |
k_layer0 = model["layers.0.attention.wk.weight"] k_layer0 = k_layer0.view(n_kv_heads, k_layer0.shape[0] // n_kv_heads, dim) k_layer0.shape torch.Size([8, 128, 4096]) k_layer0_head0 = k_layer0[0] k_layer0_head0.shape torch.Size([128, 4096]) k_per_token = torch.matmul(token_embeddings, k_layer0_head0.T) k_per_token.shape torch.Size([17, 128]) k_per_token_split_into_pairs = k_per_token.float().view(k_per_token.shape[0], -1, 2) k_per_token_split_into_pairs.shape torch.Size([17, 64, 2]) k_per_token_as_complex_numbers = torch.view_as_complex(k_per_token_split_into_pairs) k_per_token_as_complex_numbers.shape torch.Size([17, 64]) k_per_token_split_into_pairs_rotated = torch.view_as_real(k_per_token_as_complex_numbers * freqs_cis) k_per_token_split_into_pairs_rotated.shape torch.Size([17, 64, 2]) k_per_token_rotated = k_per_token_split_into_pairs_rotated.view(k_per_token.shape) k_per_token_rotated.shape torch.Size([17, 128])3.1.2、计算注意力分数矩阵并掩码：计算注意力分数并进行掩码，确保模型不会关注未来的词元
简介 | 查询Query、键Key、值Value和输出向量 1、计算注意力分数矩阵：在下一步中，我们将Query和Key矩阵相乘，这样做会给我们一个分数矩阵，将每个token与另一个token映射或关联起来。这个分数矩阵描述了每个token的query与每个token的key之间的关系有多好(相关性)，这就是自注意力机制（Self Attention）。其中，分数矩阵（qk_per_token）的形状是[17x17]，其中17是prompt中的token数量。
2、对注意力分数矩阵中的未来token进行掩码处理：然后，我们现在必须对Query-Key分数进行掩码处理，在llama3的训练过程中，未来token的qk分数会被屏蔽。 为什么？因为在训练过程中，我们只学习使用过去的token来预测未来token。 因此，在推理时，我们将未来token的评分设置为0。
|
思路步骤 | 计算Query向量与Key向量之间的匹配得分，即自注意力得分。 使用矩阵乘法和归一化。 自注意力的核心机制：查询-键匹配得分。 |
训练过程中掩盖未来的token，确保只使用过去的token进行预测。 上三角掩码矩阵，屏蔽未来token。 | |
核心技术点 | 分数计算与未来词元掩码 |
def display_qk_heatmap(qk_per_token): _, ax = plt.subplots() im = ax.imshow(qk_per_token.to(float).detach(), cmap='viridis') ax.set_xticks(range(len(prompt_split_as_tokens))) ax.set_yticks(range(len(prompt_split_as_tokens))) ax.set_xticklabels(prompt_split_as_tokens) ax.set_yticklabels(prompt_split_as_tokens) ax.figure.colorbar(im, ax=ax) display_qk_heatmap(qk_per_token) mask = torch.full((len(tokens), len(tokens)), float("-inf"), device=tokens.device) mask = torch.triu(mask, diagonal=1) mask tensor([[0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf], [0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf], [0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf], [0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf], [0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf], [0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf], [0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf], [0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf], [0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf], [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf], [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf], [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf], [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf], [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf], [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf], [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf], [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]]) qk_per_token_after_masking = qk_per_token + mask display_qk_heatmap(qk_per_token_after_masking) qk_per_token_after_masking_after_softmax = torch.nn.functional.softmax(qk_per_token_after_masking, dim=1).to(torch.bfloat16) display_qk_heatmap(qk_per_token_after_masking_after_softmax)3.1.3、值（Value）的计算：根据注意力分数和value向量计算最终的注意力输出
简介 | 查询Query、键Key、值Value和输出向量 接下来是value，接近注意力机制的最后一步。 |
思路步骤 | 这些分数（0-1）用于确定每个token使用多少value矩阵。就和key一样，value权重也在每4个注意力头之间共享（以节省计算）。因此，下面的Value权重矩阵的形状是[8x128x4096] 。 第一层，第一个注意力头的Value权重矩阵如下所示 |
Softmax 归一化得到注意力权重：对掩码后的得分进行Softmax归一化，得到注意力权重。 使用Softmax函数将得分转换为概率分布。 | |
Values（值向量）计算：使用Value向量和注意力权重计算最终的注意力输出。Value向量与Query和Key向量的共享机制。 | |
注意力计算：现在使用Value权重来获取每个token的注意力值，矩阵的大小是[17x128]，其中17是prompt中的token数量，128是每个token的value向量的维度。 注意力：与每个token的value相乘后得到的注意力向量的形状为[17x128]。 | |
核心技术点 | 分数与值的权重合并 值向量的矩阵乘法 |
qk_per_token = torch.matmul(q_per_token_rotated, k_per_token_rotated.T)/(head_dim)**0.5 qk_per_token.shape torch.Size([17, 17])3.1.4、多头注意力的合并：将多个注意力头的输出合并为一个向量
简介 | 我们现在有了第一层中第一个头的注意力值，然后，将运行一个循环，并对第一层中的每一个头执行与上述单元格完全相同的数学运算。 然后，得到了第一层所有32个头的qkv_attention矩阵，接下来我将把所有的注意力分数合并成一个大的矩阵，其大小为[17x4096] 我们快要结束了! |
思路步骤 | 多头注意力机制：对每个注意力头分别计算注意力输出，并将其拼接。 多头注意力的并行计算和拼接。 |
线性层变换：通过线性变换将拼接后的多头注意力输出进行进一步处理。 线性层的矩阵乘法。 | |
核心技术点 | 向量的拼接 |
qkv_attention_store = [] for head in range(n_heads): q_layer0_head = q_layer0[head] k_layer0_head = k_layer0[head//4] # key weights are shared across 4 heads v_layer0_head = v_layer0[head//4] # value weights are shared across 4 heads q_per_token = torch.matmul(token_embeddings, q_layer0_head.T) k_per_token = torch.matmul(token_embeddings, k_layer0_head.T) v_per_token = torch.matmul(token_embeddings, v_layer0_head.T) q_per_token_split_into_pairs = q_per_token.float().view(q_per_token.shape[0], -1, 2) q_per_token_as_complex_numbers = torch.view_as_complex(q_per_token_split_into_pairs) q_per_token_split_into_pairs_rotated = torch.view_as_real(q_per_token_as_complex_numbers * freqs_cis[:len(tokens)]) q_per_token_rotated = q_per_token_split_into_pairs_rotated.view(q_per_token.shape) k_per_token_split_into_pairs = k_per_token.float().view(k_per_token.shape[0], -1, 2) k_per_token_as_complex_numbers = torch.view_as_complex(k_per_token_split_into_pairs) k_per_token_split_into_pairs_rotated = torch.view_as_real(k_per_token_as_complex_numbers * freqs_cis[:len(tokens)]) k_per_token_rotated = k_per_token_split_into_pairs_rotated.view(k_per_token.shape) qk_per_token = torch.matmul(q_per_token_rotated, k_per_token_rotated.T)/(128)**0.5 mask = torch.full((len(tokens), len(tokens)), float("-inf"), device=tokens.device) mask = torch.triu(mask, diagonal=1) qk_per_token_after_masking = qk_per_token + mask qk_per_token_after_masking_after_softmax = torch.nn.functional.softmax(qk_per_token_after_masking, dim=1).to(torch.bfloat16) qkv_attention = torch.matmul(qk_per_token_after_masking_after_softmax, v_per_token) qkv_attention = torch.matmul(qk_per_token_after_masking_after_softmax, v_per_token) qkv_attention_store.append(qkv_attention) len(qkv_attention_store) stacked_qkv_attention = torch.cat(qkv_attention_store, dim=-1) stacked_qkv_attention.shape torch.Size([17, 4096])3.1.5、注意力输出权重矩阵：将合并后的注意力输出转换为嵌入向量的修正
简介 | 查询Query、键Key、值Value和输出向量 |
思路步骤 | 对于第0层注意力机制的最后步骤，其一是将注意力得分矩阵与权重矩阵相乘。 这是一个简单的线性层，所以我们只需进行矩阵乘法 |
核心技术点 | 线性层（全连接层）的应用。 |
stacked_qkv_attention = torch.cat(qkv_attention_store, dim=-1) stacked_qkv_attention.shape torch.Size([17, 4096])3.1.6、嵌入向量的更新：将注意力机制的输出加到原始嵌入向量上，更新嵌入信息
简介 | 查询Query、键Key、值Value和输出向量 现在，我们有了注意力后嵌入Value的变化，应该加到原始的token嵌入中； 然后，对嵌入增量进行归一化，然后通过嵌入增量运行一个前馈神经网络； |
思路步骤 | |
核心技术点 | 残差连接 |
3.2、FFNN层：在嵌入向量上应用前馈网络，增加模型的非线性
简介 | 在Llama3中，加载前馈权重并实现前馈网络。使用了一种名为SwiGLU的前馈网络，这种网络结构在模型需要的时候，能够有效地增加非线性。 在当今的LLMs中，使用这种前馈网络架构已经相当标准。 |
思路步骤 | 归一化与前馈网络：对注意力输出进行归一化，并通过前馈神经网络进行非线性变换。 RMSNorm归一化。 SwiGLU前馈网络，用于增强非线性表达能力。 |
核心技术点 | SwiGLU激活函数与线性层 |
embedding_after_edit_normalized = rms_norm(embedding_after_edit, model["layers.0.ffn_norm.weight"]) embedding_after_edit_normalized.shape torch.Size([17, 4096]) w1 = model["layers.0.feed_forward.w1.weight"] w2 = model["layers.0.feed_forward.w2.weight"] w3 = model["layers.0.feed_forward.w3.weight"] output_after_feedforward = torch.matmul(torch.functional.F.silu(torch.matmul(embedding_after_edit_normalized, w1.T)) * torch.matmul(embedding_after_edit_normalized, w3.T), w2.T) output_after_feedforward.shape torch.Size([17, 4096])3.3、循环迭代
3.3.1、所有层的迭代：将上述过程在每一层中进行迭代处理，逐层增强表示能力
| 背景 | 现在完成了第一层之后每个token的新嵌入。现在只剩下31层了，只需通过一个循环来完成。 |
简介 | 查询Query、键Key、值Value和输出向量 我们终于在第1层之后为每个词元获得了新的编辑后的嵌入。我们还有31层才能完成（还需要一个循环）。 你可以将这个编辑后的嵌入，想象成包含了第一层中所有Query信息的嵌入。随着层数的增加，每一层都会对输入的信息进行越来越复杂的处理，直到最终得到一个，能够全面了解下一个需要预测的token的嵌入。 天哪，一切都集中在一起了 是的，就是这样。我们之前所做的所有事情，现在一次性为每个层都做了 |
思路步骤 | 重复以上步骤，处理所有Transformer子层 |
核心技术点 | 循环与层堆叠 循环迭代处理每一层。 |
layer_0_embedding = embedding_after_edit+output_after_feedforward layer_0_embedding.shape torch.Size([17, 4096])3.3.2、最后的归一化：对最终嵌入向量进行归一化处理，用于预测下一个token
简介 | |
思路步骤 | |
核心技术点 | 矩阵乘法，线性变换。 最终归一化处理 |
final_embedding = token_embeddings_unnormalized for layer in range(n_layers): qkv_attention_store = [] layer_embedding_norm = rms_norm(final_embedding, model[f"layers.{layer}.attention_norm.weight"]) q_layer = model[f"layers.{layer}.attention.wq.weight"] q_layer = q_layer.view(n_heads, q_layer.shape[0] // n_heads, dim) k_layer = model[f"layers.{layer}.attention.wk.weight"] k_layer = k_layer.view(n_kv_heads, k_layer.shape[0] // n_kv_heads, dim) v_layer = model[f"layers.{layer}.attention.wv.weight"] v_layer = v_layer.view(n_kv_heads, v_layer.shape[0] // n_kv_heads, dim) w_layer = model[f"layers.{layer}.attention.wo.weight"] for head in range(n_heads): q_layer_head = q_layer[head] k_layer_head = k_layer[head//4] v_layer_head = v_layer[head//4] q_per_token = torch.matmul(layer_embedding_norm, q_layer_head.T) k_per_token = torch.matmul(layer_embedding_norm, k_layer_head.T) v_per_token = torch.matmul(layer_embedding_norm, v_layer_head.T) q_per_token_split_into_pairs = q_per_token.float().view(q_per_token.shape[0], -1, 2) q_per_token_as_complex_numbers = torch.view_as_complex(q_per_token_split_into_pairs) q_per_token_split_into_pairs_rotated = torch.view_as_real(q_per_token_as_complex_numbers * freqs_cis) q_per_token_rotated = q_per_token_split_into_pairs_rotated.view(q_per_token.shape) k_per_token_split_into_pairs = k_per_token.float().view(k_per_token.shape[0], -1, 2) k_per_token_as_complex_numbers = torch.view_as_complex(k_per_token_split_into_pairs) k_per_token_split_into_pairs_rotated = torch.view_as_real(k_per_token_as_complex_numbers * freqs_cis) k_per_token_rotated = k_per_token_split_into_pairs_rotated.view(k_per_token.shape) qk_per_token = torch.matmul(q_per_token_rotated, k_per_token_rotated.T)/(128)**0.5 mask = torch.full((len(token_embeddings_unnormalized), len(token_embeddings_unnormalized)), float("-inf")) mask = torch.triu(mask, diagonal=1) qk_per_token_after_masking = qk_per_token + mask qk_per_token_after_masking_after_softmax = torch.nn.functional.softmax(qk_per_token_after_masking, dim=1).to(torch.bfloat16) qkv_attention = torch.matmul(qk_per_token_after_masking_after_softmax, v_per_token) qkv_attention_store.append(qkv_attention) stacked_qkv_attention = torch.cat(qkv_attention_store, dim=-1) w_layer = model[f"layers.{layer}.attention.wo.weight"] embedding_delta = torch.matmul(stacked_qkv_attention, w_layer.T) embedding_after_edit = final_embedding + embedding_delta embedding_after_edit_normalized = rms_norm(embedding_after_edit, model[f"layers.{layer}.ffn_norm.weight"]) w1 = model[f"layers.{layer}.feed_forward.w1.weight"] w2 = model[f"layers.{layer}.feed_forward.w2.weight"] w3 = model[f"layers.{layer}.feed_forward.w3.weight"] output_after_feedforward = torch.matmul(torch.functional.F.silu(torch.matmul(embedding_after_edit_normalized, w1.T)) * torch.matmul(embedding_after_edit_normalized, w3.T), w2.T) final_embedding = embedding_after_edit+output_after_feedforward4、输出层
4.1、将嵌入向量转换为预测的token：确认logits张量的形状
简介 | 生成最终的嵌入向量，用于预测下一个token的最优预测。这个嵌入的形状与常规的token嵌入相同，为[17x4096]，其中17是token的数量，4096是嵌入的维度。 |
思路步骤 | 确认logits张量的形状：确保计算得到的logits具有正确的维度，以便后续处理。 |
核心技术点 | 线性层与softmax激活函数 |
final_embedding = rms_norm(final_embedding, model["norm.weight"]) final_embedding.shape torch.Size([17, 4096])4.2、解码：将模型输出的词元转换为可读的文本
简介 | 我们将使用输出解码器，将最终嵌入转换为token值，使用输出解码器将最终的嵌入转换成一个token。确认输出解码器的尺寸是否正确，确保矩阵乘法可以顺利进行。 使用最后一个词元的嵌入通过矩阵乘法预测下一个令牌的概率分布。 通过最后一个令牌的嵌入和输出解码器权重矩阵的乘法，计算出每个可能令牌的logits。 |
思路步骤 | 获取预测的下一个令牌的索引，通过argmax函数从logits中选择概率最高的令牌，来确定下一个令牌，得到最终的预测结果。 |
核心技术点 | 分词器的逆过程 argmax函数，分类问题中的预测。 |
model["output.weight"].shape torch.Size([128256, 4096])5、模型推理：应用训练好的输出层参数进行预测(验证整个代码的正确性)，模型预测下一个token的编号为2983，这是42的token ID吗？
| 背景 | 期望：使用最后一个token的嵌入来预测下一个value，希望预测的结果是42。加载的llama3模型在样本问题"答案是什么"上正确预测答案为42，验证了从零开始实现的整个流程是正确的。 希望在我们这个例子中，是42 :) 方法：查看预测的下一个令牌是否为“42” 注意：因为根据《银河系漫游指南》一书中的说法，42是“生命、宇宙及一切的终极问题的答案”。大多数现代LLM在这里都会回答42，这将验证整个代码的正确性。 |
简介 | 模型预测下一个词元是token编号2983，这是42的token ID吗？ 我正在让你兴奋，这是最后一行的代码，希望你能享受阅读！ 结束！ |
思路步骤 | 输出预测结果 打印或返回预测的令牌索引，完成整个模型推理过程。 |
logits = torch.matmul(final_embedding[-1], model["output.weight"].T) logits.shape torch.Size([128256]) next_token = torch.argmax(logits, dim=-1) next_token tensor(2983) tokenizer.decode([next_token.item()]) '42'