Deepdive-llama3-from-scratch-zh.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# 深入挖掘llama3的从零实现\n",
    "\n",
    "<center>\n",
    "    <img src=\"images/logo.png\" width=\"600px\"/>\n",
    "</center>\n",
    "\n",
    "本项目是基于 [naklecha/llama3-from-scratch](https://github.com/naklecha/llama3-from-scratch) 的增强版本。在原项目的基础上进行了全面的改进和优化，旨在帮助大家更轻松地理解和掌握llama3模型的实现原理以及详细的推理流程，感谢原作者的贡献 :)\n",
    "<br><br>\n",
    "<span style=\"font-size: 1.2em; font-weight: bold;\">\n",
    "以下是本项目的核心改进点：\n",
    "</span>\n",
    "\n",
    "\n",
    "1. **结构优化**  \n",
    "   重新编排了内容顺序，调整了目录结构，使学习过程更加清晰合理，便于大家循序渐进地理解代码。\n",
    "   \n",
    "2. **代码注释**  \n",
    "   添加了大量详细的代码注释，手把手教你理解每一段代码的作用，即使是初学者也能轻松上手。\n",
    "   \n",
    "3. **维度追踪**  \n",
    "   完整注解了每一步计算中矩阵维度的变化，让你更容易的理解整个流程。\n",
    "   \n",
    "4. **原理说明**  \n",
    "   补充了丰富的原理类说明，大量的细节推导，不仅告诉你“要怎么做”，还深入解释了“为什么要这么做”，帮助你从根本上掌握模型的设计思想。\n",
    "   \n",
    "5. **KV-Cache**  \n",
    "   额外增加了KV-Cache的推导章节，涵盖详细的核心思想、原理推导以及在注意力机制中的应用流程等内容，让你从根源了解KV-Cache的每个细节及思考。\n",
    "   \n",
    "6. **双语文档**  \n",
    "   提供了中英双语的代码文件，原生的中文翻译避免机翻的词不达意。\n",
    "<br><br>   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "<span style=\"font-size: 1.5em; font-weight: bold;\">\n",
    "下面让我们开始正式的学习过程！\n",
    "</span>\n",
    "<br><br>\n",
    "\n",
    "在这个文件中，我从头开始实现了llama3，一次一个张量和矩阵乘法。\n",
    "<br>\n",
    "此外，我将直接从meta为llama3提供的模型文件（Meta-Llama-3-8B）中加载张量，您需要在运行此文件之前下载权重。\n",
    "这里是下载权重的官方链接：https://llama.meta.com/llama-downloads/\n",
    "<br><br>\n",
    "注1：本项目目前实现了基于Huggingface的模型文件下载方式，你将在下面的加载模型章节看到。同样的，你也可以在官网或ModelScope等模型下载源进行自行下载，而无需运行下面的模型下载代码\n",
    "<br>\n",
    "注2：本项目使用的是原始模型文件，即下载的模型文件中的\"original\"文件夹下的模型\n",
    "<br><br>\n",
    "\n",
    "<span style=\"font-size: 1.5em; font-weight: bold;\">\n",
    "    请注意！图中有个小错误：<br>\n",
    "    <span style=\"font-size: 0.9em; font-weight: normal;\">\n",
    "        在每个transformer块中，第二次的add的输入应该为feed-forward的输出以及第一次add的输出，而非normalization后的结果。\n",
    "        <br>\n",
    "        如果把multi-head self-attention和feed-forward看作是相同的操作（均为特征变换），则两次的 归一化(normalization)-特征变换-残差连接(add) 的形式和过程是一模一样的\n",
    "    </span>\n",
    "</span>\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/archi.png\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 加载模型\n",
    "\n",
    "让我们首先下载一下指定版本的llama3模型文件（将从Huggingface中进行下载）\n",
    "\n",
    "注意，如果你已经通过其他方式获取或下载了模型文件，请依旧运行本节的所有单元格（除了 \"下载模型文件\" 单元格），以避免后续相关库或字段的缺失"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 如果在 Google Colab 运行此单元格，请安装所需的库\n",
    "# ! pip install tiktoken blobfile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 导入相关库\n",
    "from pathlib import Path  # 用于从文件路径中获取文件名/模型名\n",
    "import tiktoken  # openai开发的开源库，用于文本编解码（文本和tokenid的相互转换）\n",
    "from tiktoken.load import load_tiktoken_bpe  # 加载BPE模型\n",
    "import torch  # 用于搭建模型和矩阵计算\n",
    "import json  # 用于加载配置文件\n",
    "import matplotlib.pyplot as plt  # 用于绘图\n",
    "from huggingface_hub import login, hf_hub_download  # 使我们可以从 HuggingFace 下载权重"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 登录 HuggingFace，以便我们可以下载权重\n",
    "login()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 选择模型在什么设备上进行加载和计算\n",
    "device = 'cuda' if torch.cuda.is_available() else 'cpu'  # 如果有GPU则运行在GPU上，否则运行在CPU上\n",
    "print(f\"使用设备: {device}\")\n",
    "torch.set_default_device(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 选择要下载和使用的模型\n",
    "\n",
    "# 注意，默认推荐的模型为 Meta-Llama-3-8B\n",
    "# 本项目中的模型架构、超参数等，均是基于该模型进行的分析，不同模型间可能会有一点差异是正常的\n",
    "\n",
    "# 要从 HuggingFace 获取权重，您需要访问模型的 URL 并请求访问权限。\n",
    "# 例如，对于模型 Meta-Llama-3-8B，您需要访问 https://huggingface.co/meta-llama/Meta-Llama-3-8B\n",
    "# 并请求被授予访问权限。\n",
    "\n",
    "# 选择任何版本或变体的 Llama。\n",
    "# 您可以选择 3.0、3.1 或 3.2 版本。\n",
    "# 3.2 版本提供 3B 或 1B 参数大小。\n",
    "# 您还可以选择 \"Instruct\" 版本。\n",
    "\n",
    "# \"Instruct\" 版本与普通版本有什么区别？\n",
    "# \"Vanilla\"（普通版）是尚未对齐的 \"基础模型\"。\n",
    "# \"Instruct\" 版本经过对齐，并且能够回答问题。\n",
    "# 代码是相同的，唯一的区别是权重的不同，这对学习来说很有意义。\n",
    "\n",
    "model_path = \"Meta-Llama-3-8B\"             # https://huggingface.co/meta-llama/Meta-Llama-3-8B\n",
    "\n",
    "# model_path = \"Llama-3.1-8B\"                # https://huggingface.co/meta-llama/Llama-3.1-8B\n",
    "\n",
    "# model_path = \"Llama-3.2-3B\"                # https://huggingface.co/meta-llama/Llama-3.2-3B\n",
    "# model_path = \"Llama-3.2-1B\"                  # https://huggingface.co/meta-llama/Llama-3.2-1B\n",
    "\n",
    "# model_path = \"Meta-Llama-3-8B-Instruct\"    # https://huggingface.co/meta-llama/Meta-Llama-3-8B-Instruct\n",
    "\n",
    "# model_path = \"Llama-3.1-8B-Instruct\"       # https://huggingface.co/meta-llama/Llama-3.1-8B-Instruct\n",
    "\n",
    "# model_path = \"Llama-3.2-3B-Instruct\"       # https://huggingface.co/meta-llama/Llama-3.2-3B-Instruct\n",
    "# model_path = \"Llama-3.2-1B-Instruct\"       # https://huggingface.co/meta-llama/Llama-3.2-1B-Instruct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 下载模型文件\n",
    "\n",
    "repo_id = f\"meta-llama/{model_path}\"\n",
    "\n",
    "files = [\n",
    "    \"original/consolidated.00.pth\",   # PyTorch 格式的模型权重\n",
    "    \"original/params.json\",           # 模型配置\n",
    "    \"original/tokenizer.model\",       # 分词器模型\n",
    "]\n",
    "\n",
    "for file in files:\n",
    "    file_path = hf_hub_download(\n",
    "        repo_id=repo_id,\n",
    "        filename=file,\n",
    "        local_dir=f\"./{model_path}\",\n",
    "        use_auth_token=True\n",
    "    )\n",
    "    print(f\"已下载 {file} 到 {file_path}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 此时，我们需要确保 model_path 目录中包含以下 3 个文件：\n",
    "assert Path(f\"{model_path}/original/tokenizer.model\").exists()\n",
    "assert Path(f'{model_path}/original/consolidated.00.pth').exists()\n",
    "assert Path(f\"{model_path}/original/params.json\").exists()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## 加载分词器tokenizer\n",
    "\n",
    "分词器用于将输入的文本字符串切割为子词序列，从而便于输入给模型\n",
    "<br>\n",
    "我不打算实现bpe分词器（但andrej karpathy有一个非常干净的实现），链接到他的实现：https://github.com/karpathy/minbpe\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/karpathyminbpe.png\" width=\"600\"/>\n",
    "</div>\n",
    "<br><br>\n",
    "\n",
    "<span style=\"font-size: 1.2em; font-weight: bold;\">\n",
    "加载基于BPE的tokenizer的步骤总结：\n",
    "</span>\n",
    "\n",
    "1. 常规词字典加载：加载本地tokenizer模型字典（只包含常规子词，无特殊token）\n",
    "2. 特殊词字典定义：手动定义特殊tokens（用现成的或基于现成的进行修改）\n",
    "3. 文本粗分割规则定义：定义文本粗分割的正则表达式（用现成的即可）。输入将经过粗分割（基于正则）和细分割（基于BPE）两步，得到最终的分词结果\n",
    "4. 创建tokenizer：基于openai开源的tiktoken库创建文本编解码器对象（可以在粗分割结果的基础上进一步基于BPE算法进行分割处理）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecutionIndicator": {
     "show": false
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:40:18.844549Z",
     "iopub.status.busy": "2025-02-19T04:40:18.844205Z",
     "iopub.status.idle": "2025-02-19T04:40:20.540166Z",
     "shell.execute_reply": "2025-02-19T04:40:20.539467Z",
     "shell.execute_reply.started": "2025-02-19T04:40:18.844529Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "create tokenizer successed!\n",
      "原始字符串: Hello world! It's a test. 这是一个测试. alongwords. a long words. 123 456 789.\n",
      "正则分割结果: ['Hello', ' world', '!', ' It', \"'s\", ' a', ' test', '.', ' 这是一个测试', '.', ' alongwords', '.', ' a', ' long', ' words', '.', ' ', '123', ' ', '456', ' ', '789', '.']\n",
      "tokenizer分割结果: ['Hello', ' world', '!', ' It', \"'s\", ' a', ' test', '.', ' 这', '是一个', '测试', '.', ' along', 'words', '.', ' a', ' long', ' words', '.', ' ', '123', ' ', '456', ' ', '789', '.']\n",
      "tokenizer分割结果id: [('Hello', 9906), (' world', 1917), ('!', 0), (' It', 1102), (\"'s\", 596), (' a', 264), (' test', 1296), ('.', 13), (' 这', 122255), ('是一个', 122503), ('测试', 82805), ('.', 13), (' along', 3235), ('words', 5880), ('.', 13), (' a', 264), (' long', 1317), (' words', 4339), ('.', 13), (' ', 220), ('123', 4513), (' ', 220), ('456', 10961), (' ', 220), ('789', 16474), ('.', 13)]\n"
     ]
    }
   ],
   "source": [
    "# 加载基于BPE的tokenizer\n",
    "\n",
    "tokenizer_path = f\"{model_path}/original/tokenizer.model\"  # 分词器模型的路径\n",
    "\n",
    "# 常规词典外的特殊token\n",
    "# 在\"Meta-Llama-3-8B/\"路径下的'tokenizer.json'和'tokenizer_config.json'的added_tokens字段下都有这些特殊token\n",
    "special_tokens = [\n",
    "            \"<|begin_of_text|>\",\n",
    "            \"<|end_of_text|>\",\n",
    "            \"<|reserved_special_token_0|>\",  # 保留了从0到250的特殊token\n",
    "            \"<|reserved_special_token_1|>\",\n",
    "            \"<|reserved_special_token_2|>\",\n",
    "            \"<|reserved_special_token_3|>\",\n",
    "            \"<|start_header_id|>\",  # 头部信息的开始，用于标记包裹结构化数据的头部信息，如元数据\n",
    "            \"<|end_header_id|>\",  # 头部信息的结束\n",
    "            \"<|reserved_special_token_4|>\",\n",
    "            \"<|eot_id|>\",  # end of turn，多轮对话里标记当前轮次对话的结束\n",
    "        ] + [f\"<|reserved_special_token_{i}|>\" for i in range(5, 256 - 5)]\n",
    "\n",
    "\n",
    "# 加载BPE模型（实际是一个字典）\n",
    "# 一个字典，子词(bytes类型，用utf-8解码)-rank(id)对，128000词，不包含上面的256个特殊token（所以模型的总词典大小是128256）\n",
    "# 其中rank值是从0递增的序列，用于决定子词单元合并的优先顺序，优先级越高的会优先合并，因此这里的名字是mergeable ranks而非BPE或字典等类似的名字\n",
    "# 没把特殊token加到字典里应该是出于灵活性考虑，便于面对不同模型架构或任务有不同特殊token时添加特定的token，而且保持字典大小不变\n",
    "mergeable_ranks = load_tiktoken_bpe(tokenizer_path)\n",
    "\n",
    "\n",
    "# 创建一个文本编解码器对象\n",
    "# 其中的pat_str大致分为三个类型：带缩写的单词 & 单词、中文片段、1-3位的数字 & 其他特殊字符\n",
    "tokenizer = tiktoken.Encoding(\n",
    "    name=Path(tokenizer_path).name,  # 编码器名称，便于调试和日志记录使用的不同的编码器\n",
    "    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+\",  # 用于初步的粗分割文本为token序列的正则表达式\n",
    "    mergeable_ranks=mergeable_ranks,  # 传入加载的BPE模型\n",
    "    special_tokens={token: len(mergeable_ranks) + i for i, token in enumerate(special_tokens)},  # 添加特殊token-id对的字典\n",
    ")\n",
    "\n",
    "\n",
    "# 测试是否创建成功，即编解码器是否能正确运行\n",
    "print(tokenizer.decode(tokenizer.encode(\"create tokenizer successed!\")))\n",
    "\n",
    "\n",
    "# 下面是一个案例测试，来测试pat_str粗分割和tokenizer细分割的效果和区别\n",
    "# pat_str的正则只是提供了一个初步的分割，一些长句子或中文等不会分割，会在tokenizer中进一步基于BPE算法进行细化分割\n",
    "import regex  # 由于pat_str中用到了Unicode的一些语法，如\\p{L}，所以不能用re库\n",
    "\n",
    "## 创建正则\n",
    "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+\"\n",
    "pattern = regex.compile(pat_str)\n",
    "\n",
    "## 文本切分\n",
    "text = \"Hello world! It's a test. 这是一个测试. alongwords. a long words. 123 456 789.\"  # 测试文本\n",
    "re_tokens = pattern.findall(text)  # 使用正则表达式分割字符串\n",
    "merge_tokens_id = tokenizer.encode(text)  # 使用tokenizer分割字符串\n",
    "merge_tokens = [tokenizer.decode([i]) for i in merge_tokens_id]  # 将tokenizer分割结果的id序列转换为实际的子词序列\n",
    "\n",
    "## 结果输出\n",
    "print(\"原始字符串:\", text)\n",
    "print(\"正则分割结果:\", re_tokens)\n",
    "print(\"tokenizer分割结果:\", merge_tokens)\n",
    "print(\"tokenizer分割结果id:\", list(zip(merge_tokens, merge_tokens_id)))\n",
    "\n",
    "## 从结果将会看到所有单词的前缀空格都被保留了下来，而非单独一个空格token或将其删除，有利于模型正确理解单词间的边界信息，如例子中的alongwords\n",
    "\n",
    "\n",
    "_=\"\"\"\n",
    "输出结果：\n",
    "\n",
    "create tokenizer successed!\n",
    "原始字符串: Hello world! It's a test. 这是一个测试. alongwords. a long words. 123 456 789.\n",
    "正则分割结果: ['Hello', ' world', '!', ' It', \"'s\", ' a', ' test', '.', ' 这是一个测试', '.', ' alongwords', '.',\n",
    "               ' a', ' long', ' words', '.', ' ', '123', ' ', '456', ' ', '789', '.']\n",
    "tokenizer分割结果: ['Hello', ' world', '!', ' It', \"'s\", ' a', ' test', '.', ' 这', '是一个', '测试', '.',\n",
    "                    ' along', 'words', '.', ' a', ' long', ' words', '.', ' ', '123', ' ', '456', ' ', '789', '.']\n",
    "tokenizer分割结果id: [('Hello', 9906), (' world', 1917), ('!', 0), (' It', 1102), (\"'s\", 596), (' a', 264),\n",
    "                      (' test', 1296), ('.', 13), (' 这', 122255), ('是一个', 122503), ('测试', 82805), ('.', 13),\n",
    "                      (' along', 3235), ('words', 5880), ('.', 13), (' a', 264), (' long', 1317), (' words', 4339),\n",
    "                      ('.', 13), (' ', 220), ('123', 4513), (' ', 220), ('456', 10961), (' ', 220), ('789', 16474), ('.', 13)]\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 读取模型文件和配置文件\n",
    "\n",
    "通常，读取模型文件取决于它的模型类是如何编写的以及其中的变量名。\n",
    "<br>\n",
    "但是由于我们是从零开始实现llama3，因此我们将每次读取一个张量文件。\n",
    "<div>\n",
    "    <img src=\"images/model.png\" width=\"600\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:40:20.541942Z",
     "iopub.status.busy": "2025-02-19T04:40:20.541508Z",
     "iopub.status.idle": "2025-02-19T04:41:24.631841Z",
     "shell.execute_reply": "2025-02-19T04:41:24.631361Z",
     "shell.execute_reply.started": "2025-02-19T04:40:20.541912Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[\n",
      "    \"tok_embeddings.weight\",\n",
      "    \"layers.0.attention.wq.weight\",\n",
      "    \"layers.0.attention.wk.weight\",\n",
      "    \"layers.0.attention.wv.weight\",\n",
      "    \"layers.0.attention.wo.weight\",\n",
      "    \"layers.0.feed_forward.w1.weight\",\n",
      "    \"layers.0.feed_forward.w3.weight\",\n",
      "    \"layers.0.feed_forward.w2.weight\",\n",
      "    \"layers.0.attention_norm.weight\",\n",
      "    \"layers.0.ffn_norm.weight\",\n",
      "    \"layers.1.attention.wq.weight\",\n",
      "    \"layers.1.attention.wk.weight\",\n",
      "    \"layers.1.attention.wv.weight\",\n",
      "    \"layers.1.attention.wo.weight\",\n",
      "    \"layers.1.feed_forward.w1.weight\",\n",
      "    \"layers.1.feed_forward.w3.weight\",\n",
      "    \"layers.1.feed_forward.w2.weight\",\n",
      "    \"layers.1.attention_norm.weight\",\n",
      "    \"layers.1.ffn_norm.weight\",\n",
      "    \"layers.2.attention.wq.weight\"\n",
      "]\n"
     ]
    }
   ],
   "source": [
    "# 加载模型，一个网络层名称-tensor类型参数的字典\n",
    "model = torch.load(f\"{model_path}/original/consolidated.00.pth\", weights_only=False, map_location=device)\n",
    "\n",
    "# 输出前20层网络名，验证是否正确加载\n",
    "print(json.dumps(list(model.keys())[:20], indent=4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:24.632649Z",
     "iopub.status.busy": "2025-02-19T04:41:24.632410Z",
     "iopub.status.idle": "2025-02-19T04:41:24.682896Z",
     "shell.execute_reply": "2025-02-19T04:41:24.682507Z",
     "shell.execute_reply.started": "2025-02-19T04:41:24.632632Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'dim': 4096,\n",
       " 'n_layers': 32,\n",
       " 'n_heads': 32,\n",
       " 'n_kv_heads': 8,\n",
       " 'vocab_size': 128256,\n",
       " 'multiple_of': 1024,\n",
       " 'ffn_dim_multiplier': 1.3,\n",
       " 'norm_eps': 1e-05,\n",
       " 'rope_theta': 500000.0}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 加载配置文件，每个配置的具体含义见下节\n",
    "with open(f\"{model_path}/original/params.json\", \"r\") as f:\n",
    "    config = json.load(f)\n",
    "config"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 使用配置文件推断模型的细节\n",
    "\n",
    "| 配置项 | 配置值 | 含义 |\n",
    "| ---- | ---- | ---- |\n",
    "| dim | 4096 | 隐藏层维度，即每个token的向量表示的维度为4096维 |\n",
    "| n_layers | 32 | 模型的层数，即该模型有32个transformer层，或者说transformer块 |\n",
    "| n_heads | 32 | 多头注意力的头数，即每个多头注意力块有32个头，所谓的多头即同时使用了多个独立的注意力机制，以捕捉输入数据的不同特征或信息 |\n",
    "| n_kv_heads | 8 | 键值注意力的头数，用于分组查询注意力GQA，即键值注意力有8个头，而查询有n_heads=32个头，每4个查询头会共享一组键值对 |\n",
    "| vocab_size | 128256 | 词汇表大小，128000个普通token，256个特殊token |\n",
    "| multiple_of | 1024 | 隐藏层维度的倍数约束，即限制模型隐藏层维数应为1024的倍数，从而优化计算效率 |\n",
    "| ffn_dim_multiplier | 1.3 | 前馈网络层的隐藏层维度乘数，用于计算FFN隐藏层维度，计算过程可见对应节 |\n",
    "| norm_eps | 1e-05 | 层归一化计算中在分母里加的常量，防止除零，保证数值稳定性 |\n",
    "| rope_theta | 500000.0 | 旋转位置编码RoPE中的基础频率缩放因子，控制位置编码的周期性和分辨率，从而影响模型对不同长度序列和位置关系的捕捉能力 |\n",
    "\n",
    "<br>\n",
    "\n",
    "<span style=\"font-size: 1.2em; font-weight: bold;\">\n",
    "基于上述配置细节，可推断出给定一个输入，attention内部的计算流程为：\n",
    "</span>\n",
    "    \n",
    "<pre>\n",
    "input(L, 4096) -> query_proj(L, 128, 32)\n",
    "               -> key_proj(L, 128, 8)\n",
    "               -> value_proj(L, 128, 8)\n",
    "                                           -> group_query_attention(L, 128, 32)\n",
    "                                           -> output_proj(L, 4096)\n",
    "                                                                                   -> output(L, 4096)\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:24.683558Z",
     "iopub.status.busy": "2025-02-19T04:41:24.683372Z",
     "iopub.status.idle": "2025-02-19T04:41:24.686506Z",
     "shell.execute_reply": "2025-02-19T04:41:24.686089Z",
     "shell.execute_reply.started": "2025-02-19T04:41:24.683543Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# 记录这些配置，后面将逐渐用到\n",
    "dim = config[\"dim\"]\n",
    "n_layers = config[\"n_layers\"]\n",
    "n_heads = config[\"n_heads\"]\n",
    "n_kv_heads = config[\"n_kv_heads\"]\n",
    "vocab_size = config[\"vocab_size\"]\n",
    "multiple_of = config[\"multiple_of\"]\n",
    "ffn_dim_multiplier = config[\"ffn_dim_multiplier\"]\n",
    "norm_eps = config[\"norm_eps\"]\n",
    "rope_theta = torch.tensor(config[\"rope_theta\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 将输入文本转换为嵌入向量\n",
    "\n",
    "将字符串形式的文本输入给网络层之前，需要将其转换为向量形式，以进行数学计算。\n",
    "<br>\n",
    "需要的流程为：使用分词器将输入文本切分为子词序列 -> 将子词转换为向量表示\n",
    "\n",
    "## 将文本转换为token id序列\n",
    "这里我们使用tiktoken（来自openai的库）作为tokenizer\n",
    "<div>\n",
    "    <img src=\"images/tokens.png\" width=\"600\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecutionIndicator": {
     "show": false
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:24.687842Z",
     "iopub.status.busy": "2025-02-19T04:41:24.687623Z",
     "iopub.status.idle": "2025-02-19T04:41:24.691288Z",
     "shell.execute_reply": "2025-02-19T04:41:24.690842Z",
     "shell.execute_reply.started": "2025-02-19T04:41:24.687827Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[128000, 1820, 4320, 311, 279, 17139, 3488, 315, 2324, 11, 279, 15861, 11, 323, 4395, 374, 220]\n",
      "['<|begin_of_text|>', 'the', ' answer', ' to', ' the', ' ultimate', ' question', ' of', ' life', ',', ' the', ' universe', ',', ' and', ' everything', ' is', ' ']\n"
     ]
    }
   ],
   "source": [
    "# 将输入的文本prompt转换为token id序列\n",
    "prompt = \"the answer to the ultimate question of life, the universe, and everything is \"  # 输入文本\n",
    "tokens = [128000] + tokenizer.encode(prompt)  # 做子词切分，并在文本开头加入指示文本开始了的特殊token：<|begin_of_text|>，维度：[17]\n",
    "print(tokens)  # 查看下切分后的结果\n",
    "tokens = torch.tensor(tokens)  # 转换为张量类型，便于后续矩阵计算，[17]\n",
    "\n",
    "# 将token id序列转换为具体的token子词序列，仅作为展示用，实际不需要\n",
    "prompt_split_as_tokens = [tokenizer.decode([token]) for token in tokens]\n",
    "print(prompt_split_as_tokens)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 将token id序列转换为embedding嵌入向量\n",
    "\n",
    "很抱歉，这里是这个代码库中我唯一使用了内置神经网络模块的部分\n",
    "<br>\n",
    "总之，我们原本的[17x1]token序列现在是[17x4096]，即17个长度为4096的嵌入（每个token一个）\n",
    "<br><br>\n",
    "注意：关注这个张量形状的变化，这会让你更容易理解整个流程（我将全程注释形状的变化情况）\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/embeddings.png\" width=\"600\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:24.691935Z",
     "iopub.status.busy": "2025-02-19T04:41:24.691728Z",
     "iopub.status.idle": "2025-02-19T04:41:27.857169Z",
     "shell.execute_reply": "2025-02-19T04:41:27.856668Z",
     "shell.execute_reply.started": "2025-02-19T04:41:24.691921Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 4096])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 创建一个嵌入层网络，用于将离散的token id映射到连续的向量空间\n",
    "embedding_layer = torch.nn.Embedding(vocab_size, dim)\n",
    "\n",
    "# 将嵌入层网络的参数替换为llama3中预训练好的参数值\n",
    "embedding_layer.weight.data.copy_(model[\"tok_embeddings.weight\"])\n",
    "\n",
    "# 使用嵌入层网络，将输入的token id序列转换为向量表示\n",
    "# 嵌入层网络仅是基于id查字典来找到对应的向量，不涉及token间的交互\n",
    "# [17] -> [17x4096]\n",
    "token_embeddings_unnormalized = embedding_layer(tokens).to(torch.bfloat16)  # 默认是float32全精度，这里换成半精度格式，降低内存占用\n",
    "\n",
    "token_embeddings_unnormalized.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# 构建第一层的transformer块\n",
    "\n",
    "从下面展示的第一层transformer块所涉及的预训练参数来看，包含了：\n",
    "1. 两次归一化（attention_norm及ffn_norm）\n",
    "2. 注意力机制的实现（4个attention.w）\n",
    "3. 前馈网络层的实现（3个feed_forward.w）\n",
    "4. （当然还包含两次不需要预训练参数的残差连接操作）\n",
    "\n",
    "总的来说，一个transformer块中的操作流程如下：\n",
    "<br>\n",
    "归一化 -> 多头自注意力 -> 残差连接 -> 归一化 -> 前馈神经网络 -> 残差连接"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecutionIndicator": {
     "show": false
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:27.859108Z",
     "iopub.status.busy": "2025-02-19T04:41:27.857807Z",
     "iopub.status.idle": "2025-02-19T04:41:27.862020Z",
     "shell.execute_reply": "2025-02-19T04:41:27.861615Z",
     "shell.execute_reply.started": "2025-02-19T04:41:27.859082Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "layers.0.attention.wq.weight torch.Size([4096, 4096])\n",
      "layers.0.attention.wk.weight torch.Size([1024, 4096])\n",
      "layers.0.attention.wv.weight torch.Size([1024, 4096])\n",
      "layers.0.attention.wo.weight torch.Size([4096, 4096])\n",
      "layers.0.feed_forward.w1.weight torch.Size([14336, 4096])\n",
      "layers.0.feed_forward.w3.weight torch.Size([14336, 4096])\n",
      "layers.0.feed_forward.w2.weight torch.Size([4096, 14336])\n",
      "layers.0.attention_norm.weight torch.Size([4096])\n",
      "layers.0.ffn_norm.weight torch.Size([4096])\n"
     ]
    }
   ],
   "source": [
    "# 展示第一层transformer块的所有权重参数及形状\n",
    "for k, v in model.items():\n",
    "    if not k.startswith('layers'):\n",
    "        continue\n",
    "    if k.startswith('layers.1'):\n",
    "        break\n",
    "    print(k, v.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里有两个需要注意的点\n",
    "1. 神经网络的权重矩阵的形状为 (输出维度, 输入维度)，在进行计算时会将参数矩阵W进行转置操作，变为 (输入维度, 输出维度) 后，再与输入X相乘，即输出Y=XW.T，你将在后续的计算中看到\n",
    "2. 由于llama3是分组注意力机制，因此每4个查询头会共享一组kv向量（详情见上述配置文件细节章节），所以kv的权重矩阵维度为[1024, 4096]，是q（[4096, 4096]）的1/4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## 归一化\n",
    "\n",
    "归一化操作旨在约束数据的尺度差异，避免因为向量值的差异过大而导致训练的不稳定等问题\n",
    "<br><br>\n",
    "在归一化后，张量的形状仍然是[17x4096]，和embedding嵌入一样\n",
    "<div>\n",
    "    <img src=\"images/norm.png\" width=\"600\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 使用RMS归一化embedding嵌入\n",
    "\n",
    "llama3使用的是RMS归一化方法，其计算公式如图所示\n",
    "<br>\n",
    "需要注意的是，我们需要一个norm_eps参数（来自config配置信息），因为我们不想意外的将RMS设置为0并除以0\n",
    "<br>\n",
    "公式如下：\n",
    "<div>\n",
    "    <img src=\"images/rms.png\" width=\"600\"/>\n",
    "</div>\n",
    "<br>\n",
    "\n",
    "此外，你可能发现了公式中有一个gi参数，这是一个在模型训练过程中学习好的缩放因子，用于对每个维度的归一化结果再次进行放缩，以增强模型的表达能力，其维度和嵌入向量的特征维度相同，即[4096]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:27.862737Z",
     "iopub.status.busy": "2025-02-19T04:41:27.862500Z",
     "iopub.status.idle": "2025-02-19T04:41:27.865345Z",
     "shell.execute_reply": "2025-02-19T04:41:27.864937Z",
     "shell.execute_reply.started": "2025-02-19T04:41:27.862722Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# 定义RMS归一化的计算函数\n",
    "# 会将每个token进行独立的归一化\n",
    "# norm_weights为预训练的缩放因子（即公式中的gi），以增强模型的表达能力。可以从模型文件中加载，4096维\n",
    "# torch.rsqrt计算tensor的平方根的倒数，即1/RMS(a)\n",
    "def rms_norm(tensor, norm_weights):\n",
    "    return (tensor * torch.rsqrt(tensor.pow(2).mean(-1, keepdim=True) + norm_eps)) * norm_weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecutionIndicator": {
     "show": false
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:27.866046Z",
     "iopub.status.busy": "2025-02-19T04:41:27.865820Z",
     "iopub.status.idle": "2025-02-19T04:41:28.055901Z",
     "shell.execute_reply": "2025-02-19T04:41:28.055368Z",
     "shell.execute_reply.started": "2025-02-19T04:41:27.866032Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([4096]), torch.Size([17, 4096]))"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 归一化输入\n",
    "token_embeddings = rms_norm(token_embeddings_unnormalized, model[\"layers.0.attention_norm.weight\"])  # [17x4096] & [4096] -> [17x4096]\n",
    "model[\"layers.0.attention_norm.weight\"].shape, token_embeddings.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 从零实现单头的attention注意力机制\n",
    "\n",
    "每一层的多头注意力计算中，都涉及到了32个头的计算，但是这些头的计算过程是完全相同且独立的，因此，本节将首先实现单头的注意力计算流程，并在下一节中扩展为多头的计算\n",
    "<div>\n",
    "    <img src=\"images/qkv.png\" width=\"600\"/>\n",
    "</div>\n",
    "<br><br>\n",
    "\n",
    "<span style=\"font-size: 1.2em; font-weight: bold;\">\n",
    "注意力机制的核心即下图中的计算公式\n",
    "</span>\n",
    "\n",
    "1. 我们需要通过对输入的嵌入向量进行线性映射来获取query，key和value向量\n",
    "2. 随后，基于QK向量得到token间的注意力权重，即对于每个token来说，其它token对它的重要性或相关性的打分\n",
    "3. 最后，基于注意力权重，对value向量进行加权，从而得到每个token对应的注意力结果\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/softmax.png\" width=\"600px\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "言归正传，让我们先加载第一层transformer的attention头\n",
    "<br>\n",
    "&gt; 当我们从模型中加载query，key，value和output权重矩阵时（output权重矩阵用于多头间的信息融合，以产生最终的注意力输出），我们会注意到它们的形状是：[4096x4096], [1024x4096], [1024x4096], [4096x4096]\n",
    "<br>\n",
    "&gt; 乍一看这很奇怪，因为理想情况下，我们希望每个头的q,k,v是相互独立的（此时它们的形状将会是：32x[128x4096], 8x[128x4096], 8x[128x4096]）\n",
    "<br>\n",
    "&gt; 代码的作者将他们绑定在一起，是因为这样有助于注意力头的乘法计算并行化\n",
    "<br>\n",
    "&gt; 但我们将展开所有东西... "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecutionIndicator": {
     "show": false
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:28.056982Z",
     "iopub.status.busy": "2025-02-19T04:41:28.056590Z",
     "iopub.status.idle": "2025-02-19T04:41:28.060406Z",
     "shell.execute_reply": "2025-02-19T04:41:28.059829Z",
     "shell.execute_reply.started": "2025-02-19T04:41:28.056954Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([4096, 4096]) torch.Size([1024, 4096]) torch.Size([1024, 4096]) torch.Size([4096, 4096])\n"
     ]
    }
   ],
   "source": [
    "# 展示当前的q,k,v和o的注意力权重矩阵形状\n",
    "print(\n",
    "    model[\"layers.0.attention.wq.weight\"].shape,  # [4096x4096]\n",
    "    model[\"layers.0.attention.wk.weight\"].shape,  # [1024x4096]\n",
    "    model[\"layers.0.attention.wv.weight\"].shape,  # [1024x4096]\n",
    "    model[\"layers.0.attention.wo.weight\"].shape   # [4096x4096]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 得到输入token对应的qkv向量\n",
    "\n",
    "在这一节中，我们将把输入的token嵌入向量转换为query、key和value向量，以用于注意力机制的计算"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 得到query向量"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 展开query权重矩阵\n",
    "\n",
    "我们将首先从多注意头中展开queries，最终的形状将是[32x128x4096]\n",
    "<br>\n",
    "这里，32是llama3的注意力头的数量，128是query头的向量维度，4096是token嵌入的维度（之所以嵌入的维度在最后一维，是因为输入和权重相乘时通常是=X\\*W.T，即乘的是权重的转置）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:28.061618Z",
     "iopub.status.busy": "2025-02-19T04:41:28.061155Z",
     "iopub.status.idle": "2025-02-19T04:41:28.066162Z",
     "shell.execute_reply": "2025-02-19T04:41:28.065626Z",
     "shell.execute_reply.started": "2025-02-19T04:41:28.061590Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([32, 128, 4096])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 加载并修改layers.0的query权重矩阵的形状，使其以多头的形式展开\n",
    "q_layer0 = model[\"layers.0.attention.wq.weight\"]  # 默认形状为[4096x4096]\n",
    "head_dim = q_layer0.shape[0] // n_heads  # 注意力头的维度，4096/32=128\n",
    "q_layer0 = q_layer0.view(n_heads, head_dim, dim)  # 展开后的维度，[32x128x4096]\n",
    "q_layer0.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 得到第一个头\n",
    "这里我访问了第一层的query权重矩阵的第一个头，这个query权重矩阵的形状是[128x4096]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:28.067266Z",
     "iopub.status.busy": "2025-02-19T04:41:28.066828Z",
     "iopub.status.idle": "2025-02-19T04:41:28.070813Z",
     "shell.execute_reply": "2025-02-19T04:41:28.070262Z",
     "shell.execute_reply.started": "2025-02-19T04:41:28.067238Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([128, 4096])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 取出第一个头的权重\n",
    "q_layer0_head0 = q_layer0[0]  # [32x128x4096] -> [128x4096]\n",
    "q_layer0_head0.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 将token嵌入和query权重相乘，以获得token对应的query向量\n",
    "\n",
    "这里你可以看到结果的形状是[17x128]，这是因为我们有17个token，对于每个token有一个长度为128的query向量\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/q_per_token.png\" width=\"600\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:28.071899Z",
     "iopub.status.busy": "2025-02-19T04:41:28.071496Z",
     "iopub.status.idle": "2025-02-19T04:41:28.159690Z",
     "shell.execute_reply": "2025-02-19T04:41:28.159176Z",
     "shell.execute_reply.started": "2025-02-19T04:41:28.071870Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 128])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 计算输入在第一个query头上得到的query值\n",
    "# Q0_head0 = XW0_Q_head0.T\n",
    "q_per_token = torch.matmul(token_embeddings, q_layer0_head0.T)  # [17x4096] x [4096x128] = [17x128]\n",
    "q_per_token.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### 得到key向量（几乎和query向量一样）\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/keys.png\" width=\"600px\"/>\n",
    "</div>\n",
    "\n",
    "我要偷个懒，所以我不会再详细展开讲一遍key向量的计算过程 Orz，唯一你需要记住的事情是：\n",
    "<br>\n",
    "&gt; key也是生成128维的向量\n",
    "<br>\n",
    "&gt; key的权重矩阵的参数数量只有query的1/4，因为每个key的权重同时由4个头共享，以减少所需的计算数量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:28.254637Z",
     "iopub.status.busy": "2025-02-19T04:41:28.254378Z",
     "iopub.status.idle": "2025-02-19T04:41:28.258172Z",
     "shell.execute_reply": "2025-02-19T04:41:28.257754Z",
     "shell.execute_reply.started": "2025-02-19T04:41:28.254620Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([8, 128, 4096])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 加载并修改layers.0的key权重矩阵的形状，使其以多头的形式展开\n",
    "# 与query权重矩阵不同，key为8个注意力头，因此参数量为query矩阵的1/4\n",
    "k_layer0 = model[\"layers.0.attention.wk.weight\"]  # [1024x4096]\n",
    "k_layer0 = k_layer0.view(n_kv_heads, k_layer0.shape[0] // n_kv_heads, dim) # [8x128x4096]\n",
    "k_layer0.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecutionIndicator": {
     "show": false
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:28.258897Z",
     "iopub.status.busy": "2025-02-19T04:41:28.258691Z",
     "iopub.status.idle": "2025-02-19T04:41:28.261809Z",
     "shell.execute_reply": "2025-02-19T04:41:28.261408Z",
     "shell.execute_reply.started": "2025-02-19T04:41:28.258883Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([128, 4096])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 取出第一个头的权重矩阵\n",
    "k_layer0_head0 = k_layer0[0]  # [8x128x4096] -> [128x4096]\n",
    "k_layer0_head0.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:28.262743Z",
     "iopub.status.busy": "2025-02-19T04:41:28.262308Z",
     "iopub.status.idle": "2025-02-19T04:41:28.274976Z",
     "shell.execute_reply": "2025-02-19T04:41:28.274444Z",
     "shell.execute_reply.started": "2025-02-19T04:41:28.262727Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 128])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 计算第一个头的token嵌入对应的key向量\n",
    "# K0_head0 = XW0_K_head0.T\n",
    "k_per_token = torch.matmul(token_embeddings, k_layer0_head0.T)  # [17x4096] x [4096x128] = [17x128]\n",
    "k_per_token.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 得到value向量（几乎和key向量一样）\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/value.png\" width=\"600px\"/>\n",
    "</div>\n",
    "\n",
    "&gt; 和key权重一样，value权重同样是每4个注意力头共享一组权重（以节省计算）\n",
    "<br>\n",
    "&gt; 因此，value权重矩阵的形状为 [8x128x4096]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:28.275799Z",
     "iopub.status.busy": "2025-02-19T04:41:28.275606Z",
     "iopub.status.idle": "2025-02-19T04:41:28.278994Z",
     "shell.execute_reply": "2025-02-19T04:41:28.278618Z",
     "shell.execute_reply.started": "2025-02-19T04:41:28.275785Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([8, 128, 4096])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 加载并修改layers.0的value权重矩阵的形状，使其以多头的形式展开\n",
    "# 与key权重矩阵一样，value同样为8个注意力头，因此参数量同样为query矩阵的1/4\n",
    "v_layer0 = model[\"layers.0.attention.wv.weight\"]  # [1024x4096]\n",
    "v_layer0 = v_layer0.view(n_kv_heads, v_layer0.shape[0] // n_kv_heads, dim)  # [1024x4096] -> [8x128x4096]\n",
    "v_layer0.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:28.279798Z",
     "iopub.status.busy": "2025-02-19T04:41:28.279445Z",
     "iopub.status.idle": "2025-02-19T04:41:28.282496Z",
     "shell.execute_reply": "2025-02-19T04:41:28.282058Z",
     "shell.execute_reply.started": "2025-02-19T04:41:28.279783Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([128, 4096])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 取出第一个头的权重矩阵\n",
    "v_layer0_head0 = v_layer0[0]  # [8x128x4096] -> [128x4096]\n",
    "v_layer0_head0.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:28.283091Z",
     "iopub.status.busy": "2025-02-19T04:41:28.282911Z",
     "iopub.status.idle": "2025-02-19T04:41:28.363537Z",
     "shell.execute_reply": "2025-02-19T04:41:28.363096Z",
     "shell.execute_reply.started": "2025-02-19T04:41:28.283077Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 128])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 计算第一个头的token嵌入对应的value向量\n",
    "# V0_head0 = XW0_V_head0.T\n",
    "v_per_token = torch.matmul(token_embeddings, v_layer0_head0.T)  # [17x4096] x [4096x128] = [17x128]\n",
    "v_per_token.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### 向query和key向量添加位置信息\n",
    "\n",
    "- 对于自然语言来说，词语之间的顺序关系和相对位置是至为重要的，例如“狗咬人”和“人咬狗”，二者的语意信息完全不同。此外，直觉也会告诉我们，距离相对较近的词之间的关联性通常也会大于距离很远的词\n",
    "- 因此，我们需要在计算注意力的过程中提供token间的位置信息，从而让模型更好地捕捉序列中的依赖关系\n",
    "- 为什么要添加到query和key向量中？因为query和key向量是用来计算注意力权重的，即每个token对其它token的重要性，这就需要二者在计算任意两个token间的相似度时，知道这两个token所在的位置及相对位置关系\n",
    "- 为什么不给value向量也添加一下？因为value向量只是用来加权求和的，位置信息已经在query和key的交互中被考虑，因此value向量只需要提供内容信息即可\n",
    "\n",
    "我们将使用RoPE（旋转位置编码）来向这些向量里添加位置信息"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### 旋转位置编码RoPE\n",
    "\n",
    "可以查看这个视频来详细理解它的数学原理（这也是我观看的）：\n",
    "https://www.youtube.com/watch?v=o29P0Kpobz0&t=530s\n",
    "<br><br>\n",
    "RoPE的大致思想是，把向量看做是在复数空间，然后基于位置生成专门的旋转矩阵，将向量与旋转矩阵相乘从而实现在复空间中的旋转，以增加向量的相对位置信息。（即将输入向量的位置关系看做是在复数空间内的不同角度的旋转）\n",
    "<br>\n",
    "（类似于机器人运动学中的基于三角函数矩阵的乘法实现平面位置坐标的绕轴旋转）\n",
    "<br><br>\n",
    "RoPE通常应用于自注意力机制中的query和key向量。在计算注意力得分时，先将query和key向量与对应的RoPE位置编码进行旋转操作，然后再进行点积运算和softmax归一化等操作，从而可以使transformer能够在计算注意力时考虑到位置信息，而更好地捕捉文本中的依赖关系\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/rope.png\" width=\"600\"/>\n",
    "</div>\n",
    "<br>\n",
    "\n",
    "<span style=\"font-size: 1.2em; font-weight: bold;\">\n",
    "具体的RoPE计算过程如下：\n",
    "</span>\n",
    "    \n",
    "1. 将每个向量的维度两两分割，作为一对（因为高维旋转矩阵推导复杂，且过高的维度会显著增加计算复杂度，而二维旋转的公式比较成熟且简单，易于计算）\n",
    "2. 对于每一对，得到 $\\Large \\theta=\\frac{1}{rope\\_theta^{i/D}}$，其中i为第i对，D为总的对数。即当前维度对在该向量内的位置信息\n",
    "3. 对于每个向量，得到 $\\Large m$，表示该向量对应的是第m个token。即当前向量在整个向量列表内的位置信息\n",
    "4. 对于每一对，$\\large res=\\begin{pmatrix} \\cos m\\theta & -\\sin m\\theta \\\\ \\sin m\\theta & \\cos m\\theta \\\\ \\end{pmatrix} \\begin{pmatrix} x^0_i \\\\ x^1_i \\\\ \\end{pmatrix}$，其中res即该向量对在复空间中旋转$m\\theta$度后的结果\n",
    "5. 对所有向量的所有维度对做上述计算，即可得到最终的RoPE位置嵌入结果\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/qsplit.png\" width=\"600\"/>\n",
    "</div>\n",
    "<br>\n",
    "\n",
    "<span style=\"font-size: 1.2em; font-weight: bold;\">\n",
    "而在实际的代码实现中，为了简化计算过程，会将上述基于旋转矩阵的计算（第4步）转换为复数域计算，原理如下：\n",
    "</span>\n",
    "\n",
    "1. 直角坐标(x, y)可看做是复数 $\\large x+yi$ 在复平面上的坐标表示\n",
    "2. 复数的极坐标形式可表示为 $\\large re^{i\\theta}$，其中r为模长，θ为角度\n",
    "3. 极坐标下的乘法计算 $\\large r_1e^{i\\theta_1} \\times r_2e^{i\\theta_2} = r_1r_2e^{i(\\theta_1 + \\theta_2)}$ 可看做是坐标1的长度增加$r_2$倍，角度旋转$\\theta_2$度\n",
    "4. 因此，如果想将坐标旋转mθ度，则可以定义一个模长为1，角度为mθ的旋转因子 $\\large e^{im\\theta}$，将它与坐标相乘即可等价于基于旋转矩阵的旋转方法\n",
    "5. 此外，根据欧拉公式可得 $\\large re^{i\\theta} = r\\cos\\theta + r\\sin{\\theta i} = x + yi$，$\\large e^{im\\theta} = \\cos{m\\theta} + \\sin{m\\theta i}$\n",
    "6. 因此，一个二维坐标(x, y)旋转mθ度就可通过 $\\large re^{i\\theta^\\prime} \\times e^{im\\theta} = (x + yi) \\times (\\cos{m\\theta} + \\sin{m\\theta i})$ 得到（两个复数的乘积）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 给query向量添加位置信息\n",
    "\n",
    "在下面步骤中，我们首先将query向量进行按对分割，随后会对每一对进行角度旋转，正如上述步骤所示\n",
    "<br><br>\n",
    "我们现在有了一个形状为[17x64x2]的向量，这是把prompt中的每个token对应的128维query向量分割成了64对，每一对都将旋转$m\\theta$度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecutionIndicator": {
     "show": false
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:28.364285Z",
     "iopub.status.busy": "2025-02-19T04:41:28.364060Z",
     "iopub.status.idle": "2025-02-19T04:41:28.367697Z",
     "shell.execute_reply": "2025-02-19T04:41:28.367283Z",
     "shell.execute_reply.started": "2025-02-19T04:41:28.364269Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 64, 2])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将query向量在维度方向上两两分组\n",
    "# [17x128] -> [17x64x2]\n",
    "q_per_token_split_into_pairs = q_per_token.float().view(q_per_token.shape[0], -1, 2)  # 换回了全精度，保证后续三角函数计算时的精度和数值稳定性\n",
    "q_per_token_split_into_pairs.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"font-size: 1.2em; font-weight: normal;\">\n",
    "开始得到旋转矩阵的复数域表示\n",
    "</span>\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/freq_cis.png\" width=\"600\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecutionIndicator": {
     "show": false
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:28.368376Z",
     "iopub.status.busy": "2025-02-19T04:41:28.368153Z",
     "iopub.status.idle": "2025-02-19T04:41:28.372730Z",
     "shell.execute_reply": "2025-02-19T04:41:28.372348Z",
     "shell.execute_reply.started": "2025-02-19T04:41:28.368361Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0.0000, 0.0156, 0.0312, 0.0469, 0.0625, 0.0781, 0.0938, 0.1094, 0.1250,\n",
       "        0.1406, 0.1562, 0.1719, 0.1875, 0.2031, 0.2188, 0.2344, 0.2500, 0.2656,\n",
       "        0.2812, 0.2969, 0.3125, 0.3281, 0.3438, 0.3594, 0.3750, 0.3906, 0.4062,\n",
       "        0.4219, 0.4375, 0.4531, 0.4688, 0.4844, 0.5000, 0.5156, 0.5312, 0.5469,\n",
       "        0.5625, 0.5781, 0.5938, 0.6094, 0.6250, 0.6406, 0.6562, 0.6719, 0.6875,\n",
       "        0.7031, 0.7188, 0.7344, 0.7500, 0.7656, 0.7812, 0.7969, 0.8125, 0.8281,\n",
       "        0.8438, 0.8594, 0.8750, 0.8906, 0.9062, 0.9219, 0.9375, 0.9531, 0.9688,\n",
       "        0.9844])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 计算θ，第一步，得到 i/D\n",
    "# [64]\n",
    "n_split = head_dim // 2\n",
    "zero_to_one_split_into_64_parts = torch.tensor(range(n_split))/n_split  # 每个特征分割后具有64个维度对，因此需要64个θ值\n",
    "zero_to_one_split_into_64_parts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecutionIndicator": {
     "show": false
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:28.373388Z",
     "iopub.status.busy": "2025-02-19T04:41:28.373174Z",
     "iopub.status.idle": "2025-02-19T04:41:28.377113Z",
     "shell.execute_reply": "2025-02-19T04:41:28.376722Z",
     "shell.execute_reply.started": "2025-02-19T04:41:28.373374Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1.0000e+00, 8.1462e-01, 6.6360e-01, 5.4058e-01, 4.4037e-01, 3.5873e-01,\n",
       "        2.9223e-01, 2.3805e-01, 1.9392e-01, 1.5797e-01, 1.2869e-01, 1.0483e-01,\n",
       "        8.5397e-02, 6.9566e-02, 5.6670e-02, 4.6164e-02, 3.7606e-02, 3.0635e-02,\n",
       "        2.4955e-02, 2.0329e-02, 1.6560e-02, 1.3490e-02, 1.0990e-02, 8.9523e-03,\n",
       "        7.2927e-03, 5.9407e-03, 4.8394e-03, 3.9423e-03, 3.2114e-03, 2.6161e-03,\n",
       "        2.1311e-03, 1.7360e-03, 1.4142e-03, 1.1520e-03, 9.3847e-04, 7.6450e-04,\n",
       "        6.2277e-04, 5.0732e-04, 4.1327e-04, 3.3666e-04, 2.7425e-04, 2.2341e-04,\n",
       "        1.8199e-04, 1.4825e-04, 1.2077e-04, 9.8381e-05, 8.0143e-05, 6.5286e-05,\n",
       "        5.3183e-05, 4.3324e-05, 3.5292e-05, 2.8750e-05, 2.3420e-05, 1.9078e-05,\n",
       "        1.5542e-05, 1.2660e-05, 1.0313e-05, 8.4015e-06, 6.8440e-06, 5.5752e-06,\n",
       "        4.5417e-06, 3.6997e-06, 3.0139e-06, 2.4551e-06])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 计算θ，第二步，得到 θ\n",
    "# rope_theta用于控制位置编码的周期性等信息，详情可见配置信息章节\n",
    "freqs = 1.0 / (rope_theta ** zero_to_one_split_into_64_parts)  # [64]\n",
    "freqs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:28.377750Z",
     "iopub.status.busy": "2025-02-19T04:41:28.377561Z",
     "iopub.status.idle": "2025-02-19T04:41:28.380153Z",
     "shell.execute_reply": "2025-02-19T04:41:28.379753Z",
     "shell.execute_reply.started": "2025-02-19T04:41:28.377735Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# 计算mθ\n",
    "# outer为外积计算，arange(17)即每个向量对应的m（输入为17个token，因此需要17个m值）\n",
    "# 结果为[17x64]的形状，即每个token对应的向量都有64个mθ值，用于计算64个维度对各自的旋转\n",
    "freqs_for_each_token = torch.outer(torch.arange(17), freqs)  # [17] & [64] -> [17x64]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:28.380874Z",
     "iopub.status.busy": "2025-02-19T04:41:28.380668Z",
     "iopub.status.idle": "2025-02-19T04:41:28.986935Z",
     "shell.execute_reply": "2025-02-19T04:41:28.986497Z",
     "shell.execute_reply.started": "2025-02-19T04:41:28.380860Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([17, 64])\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x400 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'\\n注：从展示图可以看出，token位置越靠后的旋转角度越大，而单个token内的向量维度越靠前的旋转角度越大。\\n    其中是否有数学上的考量可自行进一步探索X_X\\n'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 得到(cosmθ + sinmθi)，即将mθ转换为复数形式\n",
    "# 将旋转角度mθ看做是模长为1的极坐标形式，从而将其转换为复数表示\n",
    "# polar的两个输入分别表示模长（设为1，即只改变角度，不影响长度）和角度（即mθ）\n",
    "freqs_cis = torch.polar(torch.ones_like(freqs_for_each_token), freqs_for_each_token)  # [17x64] -> [17x64]\n",
    "print(freqs_cis.shape)\n",
    "\n",
    "# 查看部分位置的freqs_cis，仅展示用\n",
    "token_to_show = [1, 3, 5]  # 查看第2,4,6行\n",
    "fig, axs = plt.subplots(1, len(token_to_show), figsize=(5 * len(token_to_show), 4))  # 生成1行3列的3个子图图形窗口\n",
    "for i, index in enumerate(token_to_show):\n",
    "    value = freqs_cis[index]\n",
    "    for j, element in enumerate(value):\n",
    "        element = element.cpu()\n",
    "        axs[i].plot([0, element.real], [0, element.imag], color='blue', linewidth=1, label=f\"Index: {j}\")  # 以实部为横坐标，虚部为纵坐标，绘制从原点到坐标点的蓝线\n",
    "        axs[i].annotate(f\"{j}\", xy=(element.real, element.imag), color='red')  # 绘制红色的数字注释，表示第i对维度\n",
    "    axs[i].set_xlabel('Real')\n",
    "    axs[i].set_ylabel('Imaginary')\n",
    "    axs[i].set_title(f'Plot of {index + 1}th of freqs_cis')\n",
    "plt.show()\n",
    "\n",
    "\"\"\"\n",
    "注：从展示图可以看出，token位置越靠后的旋转角度越大，而单个token内的向量维度越靠前的旋转角度越大。\n",
    "    其中是否有数学上的考量可自行进一步探索X_X\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"font-size: 1.2em; font-weight: normal;\">\n",
    "现在我们为每个token对应的query向量元素都提供了一个复数（角度变化向量）\n",
    "</span>\n",
    "<br><br>\n",
    "我们现在可以把我们的query（划分成对的那个）转换成复数，然后通过点积计算来旋转这些query :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:28.987680Z",
     "iopub.status.busy": "2025-02-19T04:41:28.987469Z",
     "iopub.status.idle": "2025-02-19T04:41:28.990735Z",
     "shell.execute_reply": "2025-02-19T04:41:28.990346Z",
     "shell.execute_reply.started": "2025-02-19T04:41:28.987664Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 64])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 得到(x + yi)\n",
    "# 即把维度对转换为复数，转换后的维度将从[17x64x2]变为[17x64]\n",
    "q_per_token_as_complex_numbers = torch.view_as_complex(q_per_token_split_into_pairs)  # [17x64x2] -> [17x64]\n",
    "q_per_token_as_complex_numbers.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:28.991431Z",
     "iopub.status.busy": "2025-02-19T04:41:28.991190Z",
     "iopub.status.idle": "2025-02-19T04:41:29.005657Z",
     "shell.execute_reply": "2025-02-19T04:41:29.005231Z",
     "shell.execute_reply.started": "2025-02-19T04:41:28.991416Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 64])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 计算(x + yi) * (cosmθ + sinmθi)\n",
    "# 即执行旋转操作，得到最终结果\n",
    "q_per_token_as_complex_numbers_rotated = q_per_token_as_complex_numbers * freqs_cis  # [17x64] * [17x64] = [17x64]\n",
    "q_per_token_as_complex_numbers_rotated.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"font-size: 1.2em; font-weight: normal;\">\n",
    "获得旋转后的向量（形状复原）\n",
    "</span>\n",
    "<br><br>\n",
    "我们可以再次将复数表示为实数，从而获得维度对形式的query结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:29.006348Z",
     "iopub.status.busy": "2025-02-19T04:41:29.006103Z",
     "iopub.status.idle": "2025-02-19T04:41:29.009144Z",
     "shell.execute_reply": "2025-02-19T04:41:29.008723Z",
     "shell.execute_reply.started": "2025-02-19T04:41:29.006322Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 64, 2])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将复数结果还原回实数的维度对形式\n",
    "q_per_token_split_into_pairs_rotated = torch.view_as_real(q_per_token_as_complex_numbers_rotated)  # [17x64] -> [17x64x2]\n",
    "q_per_token_split_into_pairs_rotated.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对旋转后的维度进行合并，这样我们就有了新的query向量（旋转后的query向量），其形状为[17x128]，其中17是token数量，128是query向量的维度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:29.009780Z",
     "iopub.status.busy": "2025-02-19T04:41:29.009585Z",
     "iopub.status.idle": "2025-02-19T04:41:29.012572Z",
     "shell.execute_reply": "2025-02-19T04:41:29.012187Z",
     "shell.execute_reply.started": "2025-02-19T04:41:29.009766Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 128])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将维度对结果还原回原始query向量形式\n",
    "q_per_token_rotated = q_per_token_split_into_pairs_rotated.view(q_per_token.shape)  # [17x64x2] -> [17x128]\n",
    "q_per_token_rotated.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 给key向量也添加位置信息（和query向量过程一样）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:29.013216Z",
     "iopub.status.busy": "2025-02-19T04:41:29.013013Z",
     "iopub.status.idle": "2025-02-19T04:41:29.016157Z",
     "shell.execute_reply": "2025-02-19T04:41:29.015771Z",
     "shell.execute_reply.started": "2025-02-19T04:41:29.013201Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 64, 2])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将key向量在维度方向上两两切分，形成维度对（修改形状）\n",
    "k_per_token_split_into_pairs = k_per_token.float().view(k_per_token.shape[0], -1, 2)  # [17x128] -> [17x64x2]\n",
    "k_per_token_split_into_pairs.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:29.016841Z",
     "iopub.status.busy": "2025-02-19T04:41:29.016636Z",
     "iopub.status.idle": "2025-02-19T04:41:29.019800Z",
     "shell.execute_reply": "2025-02-19T04:41:29.019411Z",
     "shell.execute_reply.started": "2025-02-19T04:41:29.016827Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 64])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 得到(x + yi)\n",
    "# 即将维度对转换为复数形式\n",
    "k_per_token_as_complex_numbers = torch.view_as_complex(k_per_token_split_into_pairs)  # [17x64x2] -> [17x64]\n",
    "k_per_token_as_complex_numbers.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:29.020452Z",
     "iopub.status.busy": "2025-02-19T04:41:29.020240Z",
     "iopub.status.idle": "2025-02-19T04:41:29.023240Z",
     "shell.execute_reply": "2025-02-19T04:41:29.022863Z",
     "shell.execute_reply.started": "2025-02-19T04:41:29.020437Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 64, 2])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 得到(x + yi) * (cosmθ + sinmθi)，即旋转位置编码后的最终结果\n",
    "# 并将结果还原回实数形式\n",
    "k_per_token_split_into_pairs_rotated = torch.view_as_real(k_per_token_as_complex_numbers * freqs_cis)  # [17x64] * [17x64] = [17x64] -> [17x64x2]\n",
    "k_per_token_split_into_pairs_rotated.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:29.023915Z",
     "iopub.status.busy": "2025-02-19T04:41:29.023683Z",
     "iopub.status.idle": "2025-02-19T04:41:29.026606Z",
     "shell.execute_reply": "2025-02-19T04:41:29.026225Z",
     "shell.execute_reply.started": "2025-02-19T04:41:29.023901Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 128])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将维度对还原回原始key向量形式，得到最终的key向量\n",
    "k_per_token_rotated = k_per_token_split_into_pairs_rotated.view(k_per_token.shape)  # [17x64x2] -> [17x128]\n",
    "k_per_token_rotated.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"font-size: 1.2em; font-weight: normal;\">\n",
    "到了这个阶段，我们就有了每个token对应的旋转后的query向量和key向量了~\n",
    "</span>\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/keys0.png\" width=\"600px\"/>\n",
    "</div>\n",
    "\n",
    "每个query和key向量的形状仍然还是 [17x128]. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 万事俱备，我们开始计算token间的注意力权重\n",
    "\n",
    "这将涉及三步过程：\n",
    "1. 计算注意力分数：score = Q x K\n",
    "2. 屏蔽未来token部分：score = mask(score)\n",
    "3. 计算注意力权重：res = softmax(score)\n",
    "\n",
    "我们开始吧 :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 把query和key向量相乘得到注意力分数\n",
    "\n",
    "这样我们将得到每个token和其他token之间的分数值映射\n",
    "<br>\n",
    "这个分数描述了每个token的query与每个token的key之间的相关程度\n",
    "<br>\n",
    "这就是自注意力！\n",
    "<br>\n",
    "这个注意力分数矩阵（qk_per_token）的形状为[17x17]，其中17是输入的prompt的token数量\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/qkmatmul.png\" width=\"600px\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:29.027229Z",
     "iopub.status.busy": "2025-02-19T04:41:29.027036Z",
     "iopub.status.idle": "2025-02-19T04:41:29.030266Z",
     "shell.execute_reply": "2025-02-19T04:41:29.029886Z",
     "shell.execute_reply.started": "2025-02-19T04:41:29.027215Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 17])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 计算注意力分数\n",
    "# 同时进行归一化，防止后续softmax计算结果过于偏向0或1（维度较大时的点积值可能过大），而导致梯度消失或梯度爆炸，以维持数值稳定性\n",
    "qk_per_token = torch.matmul(q_per_token_rotated, k_per_token_rotated.T)/(head_dim)**0.5  # [17x128] x [128x17] = [17x17]\n",
    "qk_per_token.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### 我们现在必须屏蔽掉未来的query-key分数\n",
    "\n",
    "在llama3的训练过程中，未来token的qk分数会被屏蔽\n",
    "<br>\n",
    "为什么？因为训练过程中，我们只学习如何利用过去的token来预测当前token，如果不屏蔽未来的token，则会导致预测信息的泄露\n",
    "<br>\n",
    "因此，在推理过程中，我们也要将未来的token设置为0（保证训练和推理过程的逻辑一致性）\n",
    "<br>\n",
    "\n",
    "当然，如果你和我一样好奇了如果不进行屏蔽会发生什么，可以在学习完成后查看我在最后一节中进行的额外实验结果 (^_<)\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/mask.png\" width=\"600px\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:29.030949Z",
     "iopub.status.busy": "2025-02-19T04:41:29.030719Z",
     "iopub.status.idle": "2025-02-19T04:41:29.268076Z",
     "shell.execute_reply": "2025-02-19T04:41:29.267626Z",
     "shell.execute_reply.started": "2025-02-19T04:41:29.030935Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlcAAAGdCAYAAAA/oFbLAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAazBJREFUeJzt3XlYVGX/P/D3YZkFhgFRlEVWVzABFTW1BHs0bDENt1JTTM0WH3JXnkpxpcel1Mwle36gZWmrlaalpqZULuWSiaioQYqaG4jIgMz9+4MvJ0dQxDln2N6v6zrXxcyc8zn3OXNm5sO9HUkIIUBEREREirCr7AIQERER1SRMroiIiIgUxOSKiIiISEFMroiIiIgUxOSKiIiISEFMroiIiIgUxOSKiIiISEEOlV0Aqv7MZjPOnj0LFxcXSJJU2cUhIqIKEkLg2rVr8Pb2hp2dOvUu+fn5KCgoUCSWRqOBTqdTJJYamFyR1c6ePQtfX9/KLgYREVkpMzMTDRs2VDxufn4+Av0NOHehSJF4np6eOHXqVJVNsJhckdVcXFwAAAk/dILOoOwl9e35ForGA4ArN/SKxwQArcNNVeLaS+rcRMFOpbiSCnEd7MyKxwSAS9edVYnr45qtStxrJq3iMXMLNIrHBID6zrmqxM0rVKe8asSto8tTPKZabuYVYFf//8nf50orKCjAuQtF+PPXABhdrKsZy7lmhn+b0ygoKGByRTVXSVOgzuCgeHLlkKv8j4m9pHxMAHBwtFclLpMr9ZIre6HOteDorE4C4OCgwufBQaWyOheqE1el5MpehSTTQa9MLY0tqd21w+AiweBi3T7MqPrdT5hcERERkU0UCTOKrPz/q0io88+WkjhakIiIiEhBrLkiIiIimzBDwAzrqq6s3d4WmFwRERGRTZhhhrWNetZHUJ+qzYKxsbFISEiQHyckJCA8PFzNXQIAtm/fDkmScPXqVdX3VeLo0aN48MEHodPpbHKMFXH69GnOP0VERJWuSAhFlqquRva56tixI7KysuDq6mqzfU6dOhXOzs5IS0vD1q1b77puSbJz4MABRcugVlwiIiK6d4onV1euXEFurjrzm9wrjUYDT09Pm9bWpKen46GHHoK/vz/q1q1rs/3er4yMjMouAhER1TIlfa6sXao6RZKrmzdvYsOGDejbty+8vLyQnp5+1/WXL18OX19fODk5oV+/fsjOtpxw7/3330dwcDB0Oh2aN2+OJUuWWLz+008/ITw8HDqdDhEREVi3bp1Fjc3tzYLJyclwc3PDd999h+DgYBgMBnTv3h1ZWVn3dHxmsxnTp09Hw4YNodVqER4ejk2bNsmvS5KEX3/9FdOnT4ckSRZNoWUJDAwEALRq1QqSJCEqKuqejv35559HaGgoTCYTgOJJ2Vq1aoXBgweXG/d2Q4YMwQMPPIC5c+fe83koYTKZkJOTY7EQERGVxwyBIiuXGp9c/f777xg3bhwaNmyIwYMHw8PDA9u2bUNYWNgdtzlx4gQ++eQTfPPNN9i0aRP279+Pl19+WX599erVmDJlCmbNmoXU1FTMnj0bb7zxBlauXAkAyMnJQY8ePdCyZUv89ttvmDFjBiZNmlRuWfPy8jBv3jx88MEH+PHHH5GRkYHx48ff03EuXLgQ8+fPx7x583Do0CFER0fjqaeewvHjxwEAWVlZaNGiBcaNG4esrKxy4+7ZswcAsGXLFmRlZeGLL764p2NftGgRrl+/jsmTJwMAXnvtNVy9ehWLFy++a9yyfPLJJ3jhhRewdu1a+Pr64vHHH8fatWuRn59f7vlITEyEq6urvPDWN0RERP+o8GjBS5cu4cMPP8TKlSvxxx9/4PHHH8eSJUvw5JNPQqMpf4bb/Px8rFq1Cj4+PgCAd955B0888QTmz58PT09PTJ06FfPnz0dMTAyA4tqYI0eOYPny5RgyZAg++ugjSJKEFStWQKfTISQkBGfOnMGIESPuut/CwkIsW7YMjRo1AgCMGjUK06dPv6djnjdvHiZNmoRnnnkGAPDf//4X27Ztw4IFC/Duu+/C09MTDg4OMBgM8PT0LDeeh4cHAKBu3boW65d37AaDAR9++CEiIyPh4uKCBQsWYNu2bTAajXeNe6cyxMXFIS4uDqmpqVi5ciXGjx+PF198Ef3790dsbCwefPDBMreNj4/H2LFj5cc5OTlMsIiIqFyciuEO3nnnHUybNg0PP/wwTpw4UeEfVT8/PzmxAoAOHTrAbDYjLS0NLi4uSE9Px7BhwyySpZs3b8qd09PS0hAaGmpxP6F27dqVu18nJyc5sQIALy8vXLhwodztcnJycPbsWXTq1Mni+U6dOuHgwYPlbn+vrl+/Xu6xA8Xna/z48XKN3UMPPWT1voODg/Hmm29i9uzZmDt3Lt544w2sWbPmjqMttVottFp1bhtCREQ1lxKj/arDaMEKJ1cvvPACHBwcsGrVKrRo0QK9e/fGc889h6ioKNjZWdeFq6Qj/IoVK9C+fXuL1+ztrbtvm6Ojo8VjSZIgqtAbdK/HbjabkZKSAnt7e5w4cUKRfWdmZmL16tX44IMPcOrUKfTt2xdDhw5VJDYREVFtU+FsyNvbG6+//jqOHTuGTZs2QaPRICYmBv7+/pg8eTL++OOPu26fkZGBs2fPyo9/+eUX2NnZoVmzZmjQoAG8vb1x8uRJNG7c2GIp6azdrFkz/P7773KnbgDYu3dvRQ/jnhmNRnh7eyMlJcXi+ZSUFISEhNxXzJLm06Kif27qeS/HDgBz587F0aNHsWPHDmzatAlJSUl3jXsn165dQ3JyMh555BEEBARgw4YNGDt2LM6dO4fVq1eja9eu93VsREREd2JWaKnqrJqhvWPHjujYsSMWLlyIdevWITk5GfPmzcP+/fvRsmXLMrfR6XQYMmQI5s2bh5ycHMTFxaFfv35yH6Fp06YhLi4Orq6u6N69O0wmE/bt24crV65g7NixGDBgAF577TW88MILmDx5MjIyMjBv3jwA6t3Ne8KECZg6dSoaNWqE8PBwJCUl4cCBA1i9evV9xatfvz70ej02bdqEhg0bQqfTwdXVtdxj379/P6ZMmYLPPvsMnTp1wltvvYVXX30VkZGRCAoKumPcsvTq1QsnT57Ec889hxUrVlg0mRIREamhZMSftTGqOkWmYtDpdHjmmWewadMmZGRkwN/f/47rNm7cGDExMXj88cfx6KOPIjQ01GK6geHDh+P9999HUlISWrZsicjISCQnJ8u1N0ajEd988w0OHDiA8PBwvPbaa5gyZYpcDjXExcVh7NixGDduHFq2bIlNmzbh66+/RpMmTe4rnoODAxYtWoTly5fD29sbPXv2BHD3Y8/Pz8egQYMQGxuLHj16AChuou3SpQuee+45FBUV3TFuWZYsWYKTJ09i+vTpTKyIiIgUJAkVOx7FxsYiICCg3HmfrLV69WoMHToU2dnZ0Ov1qu6rOjp9+jQCAwNV62OWk5MDV1dXvLknEjqDsrer/PpcqKLxAOBynjrXiM7xpipx7SV13jc7leJKKsR1sFOnIeBirrMqcX3drqoSN8ek/D+Q10zlj/K+Hw0M6kwmnVeoTnmvFygf112fp3hMtdy8bsL2HkuRnZ0tj0BXUsnvxKEj9eHiYl29zrVrZoSGXFCtrEqoljduXrVqFYKCguDj44ODBw9i0qRJ6NevHxMrIiKiKkyJPlPVoc9Vtby34Llz5zBo0CAEBwdjzJgx6Nu3L9577737jmcwGO647Ny5s8LxZs+efcd4jz322H2Xk4iIqDozQ0KRlYsZtru13f1SteaqV69ecHNzUzzuxIkTMXHiRMXi3e1Gx7fOyXWvXnzxRfTr16/M1yqjds3NzQ1Tp061+X6JiIhqI9WTq+qgcePGisZzd3eHu7u7ojGt4ebmpnq/NwAY6ZYJo5Vt6bdLuap8Z/uTWfUUjwkA4oo6fUGEU/lTa9wPjaFAlbjOelP5K1WQEOr8p3otV51/dq47q9PXJq/QsfyVKii/QPmYgHp9o/666KZK3KJ85X8OLzkYFI8JAGoMljPfKP/WZ4rsRxQv1sao6qplnysiIiKqfkqa9qyNUdVVyz5XRERERPciMTERbdu2hYuLC+rXr49evXohLS1N1X0yuSIiIiKbsLYz+/3UfO3YsQOvvPIKfvnlF2zevBmFhYV49NFHcf36dZWOks2CREREZCNmIcFsZR/Kim6/adMmi8fJycmoX78+fv31V3Tu3NmqstwJkysiIiKqdnJyciwea7VaaLXacrfLzs4GAFUHnrFZsAbbvn07JEnC1atXK7soREREijYL+vr6wtXVVV4SExPL3b/ZbMbo0aPRqVMnPPDAA6odJ2uuapCoqCiEh4djwYIFlV0UIiKiUopghyIr63VKJqfJzMy0uP3NvdRavfLKKzh8+DB27dplVRnKw+SKiIiIbEIo0OeqZN47o9FYoXsLjho1CuvXr8ePP/6Ihg0bWlWG8rBZsIaIjY3Fjh07sHDhQkiSBEmScPr0aQDAr7/+ioiICDg5OaFjx46lhqB+9dVXaN26NXQ6HYKCgjBt2jTcvKnOTYiJiIhsSQiBUaNG4csvv8QPP/yAwMBA1ffJ5KqGWLhwITp06IARI0YgKysLWVlZ8PX1BQC89tprmD9/Pvbt2wcHBwc8//zz8nY7d+7E4MGD8eqrr+LIkSNYvnw5kpOTMWvWrDvuy2QyIScnx2IhIiIqT2VMxfDKK6/gww8/xEcffQQXFxecO3cO586dw40bN1Q6SiZXNYarqys0Gg2cnJzg6ekJT09P2NvbAwBmzZqFyMhIhISEYPLkyfjpp5+Qn198q4Np06Zh8uTJGDJkCIKCgtCtWzfMmDEDy5cvv+O+EhMTLToRliRxREREd1Mk7BRZKmLp0qXIzs5GVFQUvLy85GXt2rUqHSX7XNUKoaGh8t9eXl4AgAsXLsDPzw8HDx5ESkqKRU1VUVER8vPzkZeXBycnp1Lx4uPjMXbsWPlxTk4OEywiIqqShLD9zQiZXNUCjo7/3JhVkoqrU81mMwAgNzcX06ZNQ0xMTKntdDpdmfHudS4RIiKiW5khwWxlo5lZjTtXK4zJVQ2i0WhQVFRU/oq3aN26NdLS0tC4cWOVSkVERFSstty4mclVDRIQEIDdu3fj9OnTMBgMcu3U3UyZMgVPPvkk/Pz80KdPH9jZ2eHgwYM4fPgwZs6caYNSExER1Szs0F6DjB8/Hvb29ggJCYGHhwcyMjLK3SY6Ohrr16/H999/j7Zt2+LBBx/E22+/DX9/fxuUmIiIapPK6NBeGVhzVYM0bdoUP//8s8VzsbGxFo/Dw8NLde6Ljo5GdHS02sUjIqJarrjPlZU3bq4GzYJVP/0jIiIiqkZYc0VEREQ2YVbg3oIcLUhERET0f5ToM1VUCfNWVRSTK6rSmhnOKx5zr1Cns36d39VpZXdPLVAlrmPqGVXi5rUNUjxmdiPH8le6DzqDKmFx6mY9VeLan1N+fjmfH9W5j+iF1q6qxG2QVv4o6PtRYFC+H88ND3X6BhW4Kp9cmPNtk7CYYVcr5rlinysiIiIiBbHmioiIiGyiSEgoElZOImrl9rbA5IqIiIhsokiBDu1FbBYkIiIiql1Yc0VEREQ2YRZ2MFs5WtDM0YJERERExdgsSEREREQVxporIiIisgkzrB/tp85MZ8pickV3VVhYCEdHdSZwJCKi2kWZSUSrfqNb1S9hNXbp0iU8++yz8PHxgZOTE1q2bImPP/7YYp2oqCjExcVh4sSJcHd3h6enJxISEuTXhRBISEiAn58ftFotvL29ERcXBwBYvHgxHnjgAXnddevWQZIkLFu2TH6ua9eueP311+XHX331FVq3bg2dToegoCBMmzYNN2/+M0OzJElYunQpnnrqKTg7O2PWrFlKnxYiIqIajcmVivLz89GmTRts2LABhw8fxgsvvIDnnnsOe/bssVhv5cqVcHZ2xu7duzFnzhxMnz4dmzdvBgB8/vnnePvtt7F8+XIcP34c69atQ8uWLQEAkZGROHLkCP7++28AwI4dO1CvXj1s374dQHGt088//4yoqCgAwM6dOzF48GC8+uqrOHLkCJYvX47k5ORSCVRCQgKefvpp/P7773j++edLHZfJZEJOTo7FQkREVJ6Sewtau1R1Vb+E1ZiPjw/Gjx+P8PBwBAUF4d///je6d++OTz75xGK90NBQTJ06FU2aNMHgwYMRERGBrVu3AgAyMjLg6emJrl27ws/PD+3atcOIESMAAA888ADc3d2xY8cOAMD27dsxbtw4+fGePXtQWFiIjh07AgCmTZuGyZMnY8iQIQgKCkK3bt0wY8YMLF++3KI8AwYMwNChQxEUFAQ/P79Sx5WYmAhXV1d58fX1VfbEERFRjWSGpMhS1TG5UlFRURFmzJiBli1bwt3dHQaDAd999x0yMjIs1gsNDbV47OXlhQsXLgAA+vbtixs3biAoKAgjRozAl19+KTfjSZKEzp07Y/v27bh69SqOHDmCl19+GSaTCUePHsWOHTvQtm1bODk5AQAOHjyI6dOnw2AwyMuIESOQlZWFvLw8ef8RERF3Pa74+HhkZ2fLS2ZmptXnioiIar7aUnPFDu0qmjt3LhYuXIgFCxagZcuWcHZ2xujRo1FQUGCx3u0dxiVJgtlcPB7C19cXaWlp2LJlCzZv3oyXX34Zc+fOxY4dO+Do6IioqCi899572LlzJ1q1agWj0SgnXDt27EBkZKQcNzc3F9OmTUNMTEypsup0OvlvZ2fnux6XVquFVqut8PkgIiKqDZhcqSglJQU9e/bEoEGDAABmsxnHjh1DSEhIheLo9Xr06NEDPXr0wCuvvILmzZvj999/R+vWrREZGYnRo0fj008/lftWRUVFYcuWLUhJScG4cePkOK1bt0ZaWhoaN26s2DESERHdK2UmEWXNVa3WpEkTfPbZZ/jpp59Qp04dvPXWWzh//nyFkqvk5GQUFRWhffv2cHJywocffgi9Xg9/f38AxU2KderUwUcffYT169cDKE6uxo8fD0mS0KlTJznWlClT8OSTT8LPzw99+vSBnZ0dDh48iMOHD2PmzJnKHjwREdFtzEKC2dp5rqzc3haqfvpXjb3++uto3bo1oqOjERUVBU9PT/Tq1atCMdzc3LBixQp06tQJoaGh2LJlC7755hvUrVsXQHET4sMPPwxJkvDQQw8BKE64jEYjIiIiLJr4oqOjsX79enz//fdo27YtHnzwQbz99ttyokZERETWY82Vitzd3bFu3bq7rlMybcKtbt2mV69e5SZkt+/Dzs4Oly9fLnPd6OhoREdH3zGWqAY3xCQiourJrECzYHWYRJTJFREREdmEWdjBbOVoP2u3t4WqX0IiIiKiaoQ1V0RERGQTRZBQZOUkoNZubwtMrkgxfxddR36RspWh9R2Vv7VOm8CM8le6D2c9XFWJe/pgA1Xieng3USWuGtQaHGRXUP4698NBU6RK3JteJsVjnn1InTnrbvrkqxL3sqQrf6X74JirfMyCOur0YS3SKR/XbGeb/rZsFiQiIiKiCmPNFREREdlEEaxv1lOnXlhZTK6IiIjIJmpLsyCTKyIiIrIJJW68XB1u3Fz1S0hERERUjbDmioiIiGxCQILZyj5XglMxEBERERVjsyDVOMnJyXBzc6vsYhAREdVorLkiIiIimzALCWYrZwW2dntbYM1VLbF9+3YMHToU2dnZkCQJkiQhISEBAHDlyhUMHjwYderUgZOTEx577DEcP378jrFMJhNycnIsFiIiovIUwU6Rpaqr+iUkRXTs2BELFiyA0WhEVlYWsrKyMH78eABAbGws9u3bh6+//ho///wzhBB4/PHHUVhYWGasxMREuLq6youvr68tD4WIiKhKY3JVS2g0Gri6ukKSJHh6esLT0xMGgwHHjx/H119/jffffx8PP/wwwsLCsHr1apw5cwbr1q0rM1Z8fDyys7PlJTMz07YHQ0RE1VJJs6C1S1XHPle1XGpqKhwcHNC+fXv5ubp166JZs2ZITU0tcxutVgutVp2bvRIRUc1lhh3MVtbrWLu9LVT9EhIRERFVI0yuahGNRoOiIstbXgYHB+PmzZvYvXu3/NylS5eQlpaGkJAQWxeRiIhqsCIhKbJUdUyuapGAgADk5uZi69atuHjxIvLy8tCkSRP07NkTI0aMwK5du3Dw4EEMGjQIPj4+6NmzZ2UXmYiIapDa0ueKyVUt0rFjR7z44ovo378/PDw8MGfOHABAUlIS2rRpgyeffBIdOnSAEALffvstHB0dK7nERERUkwhhB7OVi6gGM7SzQ3sts3TpUixdutTiuTp16mDVqlWVVCIiIqKahckVERER2UQRJBRZeeNla7e3BSZXREREZBNmYf3ta8xCocKoqOo3XBIRERFVI6y5IsWcLtTBuVDZfN2sQsfFxs5/Kx4TAOppr6sSN6P9DVXipjr6qxJX97fy75l9geIhAQCaHHX+Bb6Wrc4ku/YuZd+SyhqFHsrHBABHzU1V4prqFZW/0n2wK7RXPKakTlEBczWJWdZu/q9TurUxqjomV0RERGQTZkgwW9lnytrtbaHqp39ERERE1QhrroiIiMgmlJhhvTrM0M7kioiIiGyitvS5qvolJCIiIqpGmFzVcAEBAViwYEFlF4OIiKi4Q7u19xa8zw7t7777LgICAqDT6dC+fXvs2bNH4aP7B5OrGiI5ORlubm6VXQwiIqI7Ev83WtCaRdxHcrV27VqMHTsWU6dOxW+//YawsDBER0fjwoULKhwlkysiIiKyEatrrf5vAYCcnByLxWQy3XG/b731FkaMGIGhQ4ciJCQEy5Ytg5OTE/7f//t/qhwnk6saYPv27Rg6dCiys7MhSRIkSUJCQoL8el5eHp5//nm4uLjAz88P7733nsX2mZmZ6NevH9zc3ODu7o6ePXvi9OnTtj0IIiKiCvD19YWrq6u8JCYmlrleQUEBfv31V3Tt2lV+zs7ODl27dsXPP/+sStmYXNUAHTt2xIIFC2A0GpGVlYWsrCyMHz9efn3+/PmIiIjA/v378fLLL+Oll15CWloaAKCwsBDR0dFwcXHBzp07kZKSAoPBgO7du6OgoOxpsU0mU6n/GIiIiMpTMlrQ2gUorhjIzs6Wl/j4+DL3efHiRRQVFaFBgwYWzzdo0ADnzp1T5TiZXNUAGo0Grq6ukCQJnp6e8PT0hMFgkF9//PHH8fLLL6Nx48aYNGkS6tWrh23btgEoboc2m814//330bJlSwQHByMpKQkZGRnYvn17mftLTEy0+G/B19fXFodJRETVnJLNgkaj0WLRatW57dT9YHJVC4SGhsp/lyRgJZ34Dh48iBMnTsDFxQUGgwEGgwHu7u7Iz89Henp6mfHi4+Mt/lvIzMy0yXEQERFVVL169WBvb4/z589bPH/+/Hl4enqqsk9OIloLODo6WjyWJAlmc/FdOnNzc9GmTRusXr261HYeHh5lxtNqtVXqPwQiIqoeKuPeghqNBm3atMHWrVvRq1ev4hhmM7Zu3YpRo0ZZVZY7YXJVQ2g0GhQVVfwW7K1bt8batWtRv359GI1GFUpGRERU7NZmPWtiVNTYsWMxZMgQREREoF27dliwYAGuX7+OoUOHWlWWO2GzYA0REBCA3NxcbN26FRcvXkReXt49bTdw4EDUq1cPPXv2xM6dO3Hq1Cls374dcXFx+Ouvv1QuNRERkfr69++PefPmYcqUKQgPD8eBAwewadOmUp3clcLkqobo2LEjXnzxRfTv3x8eHh6YM2fOPW3n5OSEH3/8EX5+foiJiUFwcDCGDRuG/Px81mQREZGilOzQXlGjRo3Cn3/+CZPJhN27d6N9+/YKH90/2CxYgyxduhRLly61eK6s+aoOHDhg8djT0xMrV65UsWRERESV1yxoa6y5IiIiIlIQa66IiIjIJmpLzRWTKyIiIrIJgYpPpVBWjKqOyRURERHZBGuuiCro1M160Bcqe0ml5Sk/e26Q/m/FYwKAn/aSKnHdHO5tWo2Kymriokrca/l1FY/pdFzxkAAAj93qvGcFLvVUiXtTr/xX9o3Asu8hai1hVqdLr9CZVYkLyV7xkPY31EkC7POUj1tkYhdsJTG5IiIiIptgzRURERGRgmpLcsV6QCIiIiIFseaKiIiIbKK21FwxuSIiIiKbEEKCsDI5snZ7W2CzoMpiY2PRq1evu66zfft2SJKEq1ev2qRMREREpB4mVzYWFRWF0aNHWzzXsWNHZGVlwdXVVdV9M4kjIqLKZIakyFLVsVmwCtBoNPD0VH4+JyIioqqktvS5Ys2VFRISEhAeHm7x3IIFCxAQEFDm+rGxsdixYwcWLlwISZIgSRJOnz5dqkYpOTkZbm5uWL9+PZo1awYnJyf06dMHeXl5WLlyJQICAlCnTh3ExcWhqKhIjv/BBx8gIiICLi4u8PT0xIABA3DhwgUAwOnTp9GlSxcAQJ06dSBJEmJjYwEAZrMZiYmJCAwMhF6vR1hYGD777DNFzxUREVFtwZorG1q4cCGOHTuGBx54ANOnTwcAeHh44PTp06XWzcvLw6JFi7BmzRpcu3YNMTExePrpp+Hm5oZvv/0WJ0+eRO/evdGpUyf0798fAFBYWIgZM2agWbNmuHDhAsaOHYvY2Fh8++238PX1xeeff47evXsjLS0NRqMRer0eAJCYmIgPP/wQy5YtQ5MmTfDjjz9i0KBB8PDwQGRkZKmymUwmmEwm+XFOTo4KZ4uIiGqa2tKhncmVDbm6ukKj0cDJyancZsDCwkIsXboUjRo1AgD06dMHH3zwAc6fPw+DwYCQkBB06dIF27Ztk5Or559/Xt4+KCgIixYtQtu2bZGbmwuDwQB3d3cAQP369eHm5gagOFGaPXs2tmzZgg4dOsjb7tq1C8uXLy8zuUpMTMS0adOsPh9ERFS7sFmQKpWTk5OcWAFAgwYNEBAQAIPBYPFcSbMfAPz666/o0aMH/Pz84OLiIidGGRkZd9zPiRMnkJeXh27dusFgMMjLqlWrkJ6eXuY28fHxyM7OlpfMzExrD5eIiGqBkpora5eqjjVXVrCzs4MQwuK5wsJCRWI7OjpaPJYkqcznzObim5hev34d0dHRiI6OxurVq+Hh4YGMjAxER0ejoODON2bNzc0FAGzYsAE+Pj4Wr2m12jK30Wq1d3yNiIiotmNyZQUPDw+cO3cOQghIUnEmfeDAgbtuo9FoLDqhK+Xo0aO4dOkS3nzzTfj6+gIA9u3bV2rfACz2HxISAq1Wi4yMjDKbAImIiJQiFGgWZM1VDRcVFYW///4bc+bMQZ8+fbBp0yZs3LgRRqPxjtsEBARg9+7dOH36tEU/KGv5+flBo9HgnXfewYsvvojDhw9jxowZFuv4+/tDkiSsX78ejz/+OPR6PVxcXDB+/HiMGTMGZrMZDz30ELKzs5GSkgKj0YghQ4YoUj4iIiIB4LYGn/uKUdWxz5UVgoODsWTJErz77rsICwvDnj17MH78+LtuM378eNjb2yMkJERuulOCh4cHkpOT8emnnyIkJARvvvkm5s2bZ7GOj48Ppk2bhsmTJ6NBgwYYNWoUAGDGjBl44403kJiYiODgYHTv3h0bNmxAYGCgImUjIiKqTSRxe6chogrKycmBq6srlv/WBnqDspWhP+c0VjQeAATp/1Y8JgA42ZnKX+k+ZJjqqhL3u7+aqxL32u/Kl9f1uOIhAQAeuy+pEvev7vVUiXtTr3zMG4F37pNpDQenm6rEvZnrWP5K98HptPJxhVrVFyr8aheZ8nFi7n+QnZ1919aX+1XyOxH22TjYO1nXZ7coz4SDfearVlYlsFmQiIiIbKK2zHPFZkEiIiIiBbHmioiIiGzCLCRItWASUSZXREREZBNCKDBasBr0FGdyRYrJNztCMit7SV0wGcpfqYLsJLPiMQHAU6POPRZbOJ1RJW5GXWWmAbnd3kY6xWMW/K38dQAARUeOqRLXqbU651b/t/KdxC9f1ygeEwByWqhUu+Cgzi+rWYV+8g55yscEAO1V5c9BUUE1yFiqESZXREREZBO1pUM7kysiIiKyCSZXRERERAqqLR3aORUDERERkYJYc0VEREQ2UVtGC7LmqoaJjY1Fr169KrsYREREpRQnV5KVS2UfRflYc1VNnT59GoGBgdi/fz/Cw8Pl5xcuXAjeLpKIiKjyMLmqYVxdXSu7CERERGWqLaMF2Sx4n5KTk+Hn5wcnJyc8/fTTmD9/Ptzc3OTXy2qeGz16NKKiouTHZrMZiYmJCAwMhF6vR1hYGD777DP59StXrmDgwIHw8PCAXq9HkyZNkJSUBAAIDAwEALRq1QqSJMlxb9+vyWRCXFwc6tevD51Oh4ceegh79+6VX9++fTskScLWrVsREREBJycndOzYEWlpaXc8dpPJhJycHIuFiIioPEKhpapjcnUfdu/ejWHDhmHUqFE4cOAAunTpgpkzZ1Y4TmJiIlatWoVly5bhjz/+wJgxYzBo0CDs2LEDAPDGG2/gyJEj2LhxI1JTU7F06VLUq1cPALBnzx4AwJYtW5CVlYUvvviizH1MnDgRn3/+OVauXInffvsNjRs3RnR0NC5fvmyx3muvvYb58+dj3759cHBwwPPPP3/Xcru6usqLr69vhY+diIiopmKz4H1YuHAhunfvjokTJwIAmjZtip9++gmbNm265xgmkwmzZ8/Gli1b0KFDBwBAUFAQdu3aheXLlyMyMhIZGRlo1aoVIiIiAAABAQHy9h4eHgCAunXrwtPTs8x9XL9+HUuXLkVycjIee+wxAMCKFSuwefNm/O9//8OECRPkdWfNmoXIyEgAwOTJk/HEE08gPz8fOl3pW5nEx8dj7Nix8uOcnBwmWEREVK7a0izI5Oo+pKam4umnn7Z4rkOHDhVKrk6cOIG8vDx069bN4vmCggK0atUKAPDSSy+hd+/e+O233/Doo4+iV69e6Nix4z3vIz09HYWFhejUqZP8nKOjI9q1a4fU1FSLdUNDQ+W/vby8AAAXLlyAn59fqbharRZarfaey0FERARAmXa9atAuyORKJXZ2dqVG7RUWFsp/5+bmAgA2bNgAHx8fi/VKEpfHHnsMf/75J7799lts3rwZ//rXv/DKK69g3rx5ipfX0fGfu5ZKUvF/BWazOjc4JiIiqsnY5+o+BAcHY/fu3RbP/fLLLxaPPTw8kJWVZfHcgQMH5L9DQkKg1WqRkZGBxo0bWyy3NrF5eHhgyJAh+PDDD7FgwQK89957AACNpvhO9kVFRXcsZ6NGjaDRaJCSkiI/V1hYiL179yIkJKRiB01ERGQtq+e4kgA2C9ZMcXFx6NSpE+bNm4eePXviu+++K9Uk+Mgjj2Du3LlYtWoVOnTogA8//BCHDx+Wm/xcXFwwfvx4jBkzBmazGQ899BCys7ORkpICo9GIIUOGYMqUKWjTpg1atGgBk8mE9evXIzg4GABQv3596PV6bNq0CQ0bNoROpys1DYOzszNeeuklTJgwAe7u7vDz88OcOXOQl5eHYcOG2eZkERER/R/O0E539OCDD2LFihVYuHAhwsLC8P333+P111+3WCc6OhpvvPEGJk6ciLZt2+LatWsYPHiwxTozZszAG2+8gcTERAQHB6N79+7YsGGDPM2CRqNBfHw8QkND0blzZ9jb22PNmjUAAAcHByxatAjLly+Ht7c3evbsWWZZ33zzTfTu3RvPPfccWrdujRMnTuC7775DnTp1VDgzREREd2b97OzWd4i3BUlwOm9FJCcnY/To0bh69WplF8XmcnJy4OrqioX7HoTeoGxl6HeXWigaDwA8derMy+WpUSeuv/aiKnE3XmqpSty9maUHQVhL94tB8ZgA4Pn2T6rEzR70oCpx9X/fVDzm5WCN4jEBIKdFYfkr3Q97dX6ydH8qfx4c8hQPCQDQXlX+HBQV5ONQ8mvIzs6G0WhUPH7J70TA/3sddk6lR6FXhDkvH6efn6laWZXAZkEiIiKyDSX6TFWDmismV0RERGQT7HNFFRIbG1srmwSJiIjIEmuuSDGFwh4Owr6yi1GuCyYXVeLWcVSng4U91JlvrLnhnCpxocJk/Rlu6gzAyLK790l5K+JaE+X7RgGAkwr9goRKvwKSozrXrVq1FqagfMVj5hepU39x47Lyb5o530bVQZxElIiIiEg5teX2N2wWJCIiIlIQa66IiIjIdqpBs561mFwRERGRTbBZkIiIiIgqjDVXREREZBu1ZLQga67IQl5eHnr37g2j0QhJkjh3FxERKUhSaKnaWHNFFlauXImdO3fip59+Qr169eDq6lrZRSIiopqCNVdUG6WnpyM4OBgPPPAAPD09IUlV/z8EIiIia50+fRrDhg1DYGAg9Ho9GjVqhKlTp6KgoKDCsZhc1TKff/45WrRoAa1Wi4CAAMyfP19+LSoqCvPnz8ePP/4ISZIQFRVVZgyTyYScnByLhYiIqFxCoUUFR48ehdlsxvLly/HHH3/g7bffxrJly/Cf//ynwrHYLFiL/Prrr+jXrx8SEhLQv39//PTTT3j55ZdRt25dxMbG4osvvsDkyZNx+PBhfPHFF9Boyr7VRmJiIqZNm2bj0hMRUbUnpOLF2hgq6N69O7p37y4/DgoKQlpaGpYuXYp58+ZVKBaTq1rkrbfewr/+9S+88cYbAICmTZviyJEjmDt3LmJjY+Hu7g4nJydoNBp4enreMU58fDzGjh0rP87JyYGvrwo3lCMiIrqD21tNtFottFqtovvIzs6Gu7t7hbdjs2Atkpqaik6dOlk816lTJxw/fhxFRUX3HEer1cJoNFosRERE5RFCmQUAfH194erqKi+JiYmKlvXEiRN45513MHLkyApvy+SKiIiIbEPBPleZmZnIzs6Wl/j4+DJ3OXnyZEiSdNfl6NGjFtucOXMG3bt3R9++fTFixIgKHyabBWuR4OBgpKSkWDyXkpKCpk2bwt7evpJKRUREVHH32nIybtw4xMbG3nWdoKAg+e+zZ8+iS5cu6NixI9577737KhuTq1pk3LhxaNu2LWbMmIH+/fvj559/xuLFi7FkyZLKLhoREdUGldCh3cPDAx4eHve07pkzZ9ClSxe0adMGSUlJsLO7vwY+Jle1SOvWrfHJJ59gypQpmDFjBry8vDB9+vRyM3oiIiIlSKJ4sTaGGs6cOYOoqCj4+/tj3rx5+Pvvv+XX7jbIqyxMrmqZ3r17o3fv3nd8fcGCBbYrDBERURWxefNmnDhxAidOnEDDhg0tXhOiYhkdO7QTERGRbVThSURjY2MhhChzqSjWXBEREZFtVOFJRJXE5IqIiIhso5bcuJnJFSkm9boPNJKjojFPXK6naDwAcNIUKh4TAM7muqoS9293F1Xi+usuqRL3IbfjisfcaxeoeEwA+KGp8tcXANhdV2dqE4+Dyl+7+jO5iscEgCst1fk8FBjUqbW4EnrvEynfM4dqkAWQKphcERERkW2w5oqIiIhIQbUkueJoQSIiIiIFseaKiIiIbIOjBYmIiIiUU5VnaFcSmwVrmOTkZLi5ucmPExISEB4ebrFOQkICGjRoAEmSsG7dOpuWj4iIqKZjzVUNN378ePz73/+WH6empmLatGn48ssv8eCDD6JOnTqVWDoiIqpVakmHdiZXNZzBYIDBYJAfp6enAwB69uwJSar67dZERETVDZsFa7hbmwUTEhLQo0cPAICdnZ1FcvX+++8jODgYOp0OzZs3x5IlSyqjuERERNUea65qkfHjxyMgIABDhw5FVlaW/Pzq1asxZcoULF68GK1atcL+/fsxYsQIODs7Y8iQIaXimEwmmEwm+XFOTo5Nyk9ERNWbBAU6tCtSEnUxuapFDAaD3Nnd09NTfn7q1KmYP38+YmJiAACBgYE4cuQIli9fXmZylZiYiGnTptmkzEREVIPUkqkY2CxYy12/fh3p6ekYNmyY3D/LYDBg5syZcv+s28XHxyM7O1teMjMzbVxqIiKqloRCSxXHmqtaLje3+KatK1asQPv27S1es7cv++azWq0WWq1W9bIRERFVR0yuarkGDRrA29sbJ0+exMCBAyu7OEREVJNxKgaqLaZNm4a4uDi4urqie/fuMJlM2LdvH65cuYKxY8dWdvGIiKiGqC0ztDO5IgwfPhxOTk6YO3cuJkyYAGdnZ7Rs2RKjR4+u7KIRERFVO+zQXsPExsbi6tWr8uOEhAQcOHBAftyrVy8IUTrtHzBgAPbv3w+TyYTLly9jx44dePrpp21QYiIiqjXYoZ2IiIhIQbWkzxVrroiIiIgUxJorIiIisgl2aCciIiJSUi2ZoZ3JFSkmQH8ROr2yl9RuO39F4wGAnUr/9ngbslWJe6PIUZW4l286qxI336x8eZsbsspf6T5ca6HOZLjhxr9UibvaP0LxmAUn3BSPCQBm73xV4krndKrEVaOTjFPdPOWDAkBd5UMW5ZnKX4nuGZMrIiIiso1a0qGdyRURERHZBPtcERERESmpltRccSoGIiIiIgWx5oqIiIhsQ4FmwepQc8XkioiIiGyDzYJEREREVFGsuSIiIiLbqCU1V0yuiIiIyCY4FQPRHZhMJphM/8zmm5OTU4mlISIiqlrY54oqLDExEa6urvLi6+tb2UUiIiKqMphcUYXFx8cjOztbXjIzMyu7SEREVB0IhZYqjs2CVGFarRZarTo3vCUiIqrumFwRERGRTbBDOxEREZHSqkFyZC32uaJSkpOTIUlSZReDiIhqmlrS54rJFZVy6tQpREZGVnYxiIiIqiU2C1IpGzduxOLFiyu7GEREVMOwzxXVWnv27KnsIhARUU1US25/w2ZBIiIiIgWx5oqIiIhsgs2CRBV05aYTtDcdFY1pummvaDwAuFGgbBlLFJrVqQj2clbn3o3ZBTpV4tbR3FA8ZgOtOufAU6dOXDPUGW0bWPey4jGPnDUoHhMAkK1RJazxtDrntsCo/M/hDZOL4jEBQBhuKh7TfMNGI8TZLEhEREREFcWaKyIiIrKNWlJzxeSKiIiIbKK29LlisyARERGRglhzRURERLZRS5oFWXNVwwUEBGDBggWVXQwiIiLeW5Cql+TkZLi5uVV2MYiIiO6opM+VtUtVx+SKiIiISEFMrmqA7du3Y+jQocjOzoYkSZAkCQkJCfLreXl5eP755+Hi4gI/Pz+89957FttnZmaiX79+cHNzg7u7O3r27InTp0/fcX8mkwk5OTkWCxERUbnYLEjVRceOHbFgwQIYjUZkZWUhKysL48ePl1+fP38+IiIisH//frz88st46aWXkJaWBgAoLCxEdHQ0XFxcsHPnTqSkpMBgMKB79+4oKCgoc3+JiYlwdXWVF19fX5scJxERVW9sFqRqQ6PRwNXVFZIkwdPTE56enjAY/rmlxeOPP46XX34ZjRs3xqRJk1CvXj1s27YNALB27VqYzWa8//77aNmyJYKDg5GUlISMjAxs3769zP3Fx8cjOztbXjIzM21xmERERNUCk6taIDQ0VP67JAG7cOECAODgwYM4ceIEXFxcYDAYYDAY4O7ujvz8fKSnp5cZT6vVwmg0WixERETlqibNgiaTCeHh4ZAkCQcOHKjw9pznqhZwdLS8UbEkSTCbzQCA3NxctGnTBqtXry61nYeHh03KR0REtUQ1medq4sSJ8Pb2xsGDB+9reyZXNYRGo0FRUVGFt2vdujXWrl2L+vXrswaKiIhqvY0bN+L777/H559/jo0bN95XDDYL1hABAQHIzc3F1q1bcfHiReTl5d3TdgMHDkS9evXQs2dP7Ny5E6dOncL27dsRFxeHv/76S+VSExFRbSIptAAoNWrdZDJZXb7z589jxIgR+OCDD+Dk5HTfcZhc1RAdO3bEiy++iP79+8PDwwNz5sy5p+2cnJzw448/ws/PDzExMQgODsawYcOQn5/PmiwiIlKWgn2ufH19LUauJyYmWlc0IRAbG4sXX3wRERERVsVis2ANsnTpUixdutTiubLmq7q9c56npydWrlypYsmIiIiUlZmZaVEJoNVqy1xv8uTJ+O9//3vXWKmpqfj+++9x7do1xMfHW102JldERERkE0rMU1Wy/b2OVh83bhxiY2Pvuk5QUBB++OEH/Pzzz6WStIiICAwcOLBClRBMroiIiMg2KmG0oIeHxz2Nfl+0aBFmzpwpPz579iyio6Oxdu1atG/fvkL7ZHJFREREtlNFZ1j38/OzeFwyGXejRo3QsGHDCsVickWKuXZTB9NNx/JXrEjMC4byV6ogR5eyb+tjratF9z+y5G5uFtmrEtfXeEWVuGZ5LI9yTGZ1vqo8NercF7Oh5pIqcfNcNYrHPOuvzsCVKxdcVIlrOKtKWGhSbyoe85qv8u8XAGQ3VvZ7FgDM+RWfyofujMkVERER2YSSfa7UFhAQACHub2dMroiIiMg2qskM7dbiPFdERERECmLNFREREdlEdWoWtAaTKyIiIrINNgsSERERUUUxuapEAQEBWLBgQWUXg4iIyCZKmgWtXao6NgtWor1798LZ2bmyi0FERGQbtaRZkMlVJbqX6fitIYRAUVERHBz4NhMREdkKmwXvQ0JCAsLDwy2eW7BgAQICAuTHsbGx6NWrF+bNmwcvLy/UrVsXr7zyCgoLC+V1bm0WHDBgAPr3728Rs7CwEPXq1cOqVasAAGazGYmJiQgMDIRer0dYWBg+++wzef3t27dDkiRs3LgRbdq0gVarxa5du3Dw4EF06dIFLi4uMBqNaNOmDfbt2ydvt2vXLjz88MPQ6/Xw9fVFXFwcrl+/fsfjN5lMyMnJsViIiIjKJRRaqjgmVyratm0b0tPTsW3bNqxcuRLJyclITk4uc92BAwfim2++QW5urvzcd999h7y8PDz99NMAgMTERKxatQrLli3DH3/8gTFjxmDQoEHYsWOHRazJkyfjzTffRGpqKkJDQzFw4EA0bNgQe/fuxa+//orJkyfD0bH49gnp6eno3r07evfujUOHDmHt2rXYtWsXRo0adcfjSkxMhKurq7z4+vpaeaaIiKg2YJ8rslqdOnWwePFi2Nvbo3nz5njiiSewdetWjBgxotS60dHRcHZ2xpdffonnnnsOAPDRRx/hqaeegouLC0wmE2bPno0tW7agQ4cOAICgoCDs2rULy5cvR2RkpBxr+vTp6Natm/w4IyMDEyZMQPPmzQEATZo0kV9LTEzEwIEDMXr0aPm1RYsWITIyEkuXLoVOpytV1vj4eIwdO1Z+nJOTwwSLiIjKxz5XZK0WLVrA3v6fm+56eXnh999/L3NdBwcH9OvXD6tXr8Zzzz2H69ev46uvvsKaNWsAACdOnEBeXp5F0gQABQUFaNWqlcVzERERFo/Hjh2L4cOH44MPPkDXrl3Rt29fNGrUCABw8OBBHDp0CKtXr5bXF0LAbDbj1KlTCA4OLlVWrVYLrVZbgTNBRERUezC5ug92dnalbuZ4a1+qEiVNbyUkSYLZbL5j3IEDByIyMhIXLlzA5s2bodfr0b17dwCQmws3bNgAHx8fi+1uT3RuH4GYkJCAAQMGYMOGDdi4cSOmTp2KNWvW4Omnn0Zubi5GjhyJuLi4UuXx8/O7Y1mJiIgqShIC0n3eDPnWGFUdk6v74OHhgXPnzkEIAUmSAAAHDhywOm7Hjh3h6+uLtWvXYuPGjejbt6+coIWEhECr1SIjI8OiCfBeNW3aFE2bNsWYMWPw7LPPIikpCU8//TRat26NI0eOoHHjxlaXn4iI6K7YLEh3EhUVhb///htz5sxBnz59sGnTJmzcuBFGo9Hq2AMGDMCyZctw7NgxbNu2TX7excUF48ePx5gxY2A2m/HQQw8hOzsbKSkpMBqNGDJkSJnxbty4gQkTJqBPnz4IDAzEX3/9hb1796J3794AgEmTJuHBBx/EqFGjMHz4cDg7O+PIkSPYvHkzFi9ebPXxEBER1TYcLXgfgoODsWTJErz77rsICwvDnj17MH78eEViDxw4EEeOHIGPjw86depk8dqMGTPwxhtvIDExEcHBwejevTs2bNiAwMDAO8azt7fHpUuXMHjwYDRt2hT9+vXDY489hmnTpgEAQkNDsWPHDhw7dgwPP/wwWrVqhSlTpsDb21uR4yEiIipRW0YLSuL2zkNEFZSTkwNXV1eM2NEHGoNj+RtUwDe/hSsaDwAcXQoUjwkA9g537k9nDYPepEpcX+MVVeK6avIVj+nueOd516xRV6W4DTWXVIl79Iby//Rsyiw9aEUJVy64qBK34Qb78le6D5rsm4rHvOarUTwmAGSr0IvDnJ+PkzNfQ3Z2tiKtMLcr+Z1oNWAW7DWlR6FXRFFBPvZ/pF5ZlcCaKyIiIiIFsc8VERER2YQSzXrVoVmQyRURERHZBkcLElWMxu4mtHaSojHtnZXvB6HWvz1OOnX6RjnYF6kSN7tAr0pcs1C+t4GdSt+m503q9Nd4wCNTlbhemmzFY3b2SVc8JgDUD7imStyP67ZRJe6Nk8pfC3bqfCWgyEn5z4PZ0TYZS22puWKfKyIiIiIFseaKiIiIbIPNgkRERETKqg7NetZisyARERGRglhzRURERLYhRPFibYwqjskVERER2QRHCxIRERFRhbHmioiIiGyDowWJiIiIlCOZixdrY1R1TK6owkwmE0ymf6YezsnJqcTSEBERVS3sc0UVlpiYCFdXV3nx9fWt7CIREVF1IBRaqjgmV1Rh8fHxyM7OlpfMTHXuo0ZERDVLyWhBa5eqjs2CVGFarRZarbayi0FERNVNLZnnijVXRERERApizRURERHZBCcRpVorOTkZkiRVdjGIiKimYYd2qq1OnTqFyMjIyi4GERFRtcRmQSpl48aNWLx4cWUXg4iIapja0izI5IpK2bNnT2UXgYiIaiKOFiQiIiKiimLNFREREdkEmwWJKuhSgTM0BRpFY5pvKj9qUQh7xWMCgKnQUZW4hUXqlFeI6jMiVOdQqErcK/lOqsQ9fEOdW0K5O+QqHjNAd1HxmGryNF5TJe7pm66KxzRkKB4SAGBvUv6zW1QgQaXiWlJitF81SK7YLEhERESkINZcERERkU2wWZCIiIhISWZRvFgbo4pjckVERES2wT5XRERERFRRTK6oTJIkYd26dZVdDCIiqkEk/NPv6r6Xyj6Ie8BmQSIiIrINztBORERERBXF5Koau3TpEp599ln4+PjAyckJLVu2xMcff2yxTlRUFOLi4jBx4kS4u7vD09MTCQkJFuscP34cnTt3hk6nQ0hICDZv3mzDoyAiotrC6iZBBaZysAU2C1Zj+fn5aNOmDSZNmgSj0YgNGzbgueeeQ6NGjdCuXTt5vZUrV2Ls2LHYvXs3fv75Z8TGxqJTp07o1q0bzGYzYmJi0KBBA+zevRvZ2dkYPXr0XfdrMplgMpnkxzk5OWodIhER1SQcLUhVnY+PD8aPH4/w8HAEBQXh3//+N7p3745PPvnEYr3Q0FBMnToVTZo0weDBgxEREYGtW7cCALZs2YKjR49i1apVCAsLQ+fOnTF79uy77jcxMRGurq7y4uurzq0+iIiIqiMmV9VYUVERZsyYgZYtW8Ld3R0GgwHfffcdMjIs7xAVGhpq8djLywsXLlwAAKSmpsLX1xfe3t7y6x06dLjrfuPj45GdnS0vmZmZCh0RERHVZJIQiixVHZsFq7G5c+di4cKFWLBgAVq2bAlnZ2eMHj0aBQUFFus5OlreUFiSJJjN5vver1arhVarve/tiYioljL/32JtjCqOyVU1lpKSgp49e2LQoEEAALPZjGPHjiEkJOSeYwQHByMzMxNZWVnw8vICAPzyyy+qlJeIiKg2YLNgNdakSRNs3rwZP/30E1JTUzFy5EicP3++QjG6du2Kpk2bYsiQITh48CB27tyJ1157TaUSExFRbVZbmgWZXFVjr7/+Olq3bo3o6GhERUXB09MTvXr1qlAMOzs7fPnll7hx4wbatWuH4cOHY9asWeoUmIiIajeh0KKiDRs2oH379tDr9ahTp06Ff1cBNgtWa+7u7uXeomb79u2lnrt9m6ZNm2Lnzp0Wz4lq8J8BERFVM1V8hvbPP/8cI0aMwOzZs/HII4/g5s2bOHz4cIXjMLkiIiKiWu/mzZt49dVXMXfuXAwbNkx+viL9mEuwWZCIiIhsQskZ2nNyciyWWye3vh+//fYbzpw5Azs7O7Rq1QpeXl547LHH7qvmiskVERER2UZJs6C1CwBfX1+LCa0TExOtKtrJkycBAAkJCXj99dexfv161KlTB1FRUbh8+XKFYjG5IiIiomonMzPTYkLr+Pj4MtebPHkyJEm663L06FF5/sfXXnsNvXv3Rps2bZCUlARJkvDpp59WqGzsc0WK+TvfAAd7hScXzXEsf50KMmvVmYHuxkV1JlY169Qp73XnQlXimow3FI95LttF8ZgAoHEoUiXubxp1bgmls7+peEwf/VXFYwJAC/1f6sR1y1IlLiKUD/n3GXWuA2OG8p/dm4XKX1tlkczFi7UxAMBoNMJoNJa7/rhx4xAbG3vXdYKCgpCVVXxt3drHSqvVIigoqNSdT8rD5IqIiIhsoxJGC3p4eMDDw6Pc9dq0aQOtVou0tDQ89NBDAIDCwkKcPn0a/v7+FdonkysiIiKq9YxGI1588UVMnToVvr6+8Pf3x9y5cwEAffv2rVAsJldERERkG0pMAqriNIxz586Fg4MDnnvuOdy4cQPt27fHDz/8gDp16lQoDpMrIiIisgklbl+j5u1vHB0dMW/ePMybN8+qOBwtSERERKQgJlfVSGxsbLn3OAoICMCCBQtsUh4iIqIKUXCeq6qMzYJV0OnTpxEYGIj9+/cjPDy8Qtvu3bsXzs7O6hSMiIjIGgKAtbPLVP3cismVrRUWFsLRUfm5m0rcy3BTIiKiylDV+1wppVY3C+7atQsPP/ww9Ho9fH19ERcXh+vXrwMA/vOf/6B9+/altgkLC8P06dPlx++//z6Cg4Oh0+nQvHlzLFmyRH7t9OnTkCQJa9euRWRkJHQ6Hd577z0YjUZ89tlnFnHXrVsHZ2dnXLt2DYGBgQCAVq1aQZIkREVFWaw7b948eHl5oW7dunjllVdQWPjPhHK3NwtKkoT3338fTz/9NJycnNCkSRN8/fXXFvG+/vprNGnSBDqdDl26dMHKlSshSRKuXr1a5nkzmUyl7ulERERExWptcpWeno7u3bujd+/eOHToENauXYtdu3Zh1KhRAICBAwdiz549SE9Pl7f5448/cOjQIQwYMAAAsHr1akyZMgWzZs1CamoqZs+ejTfeeAMrV6602NfkyZPx6quvIjU1FTExMXjmmWeQlJRksU5SUhL69OkDFxcX7NmzBwCwZcsWZGVl4YsvvpDX27ZtG9LT07Ft2zasXLkSycnJSE5OvuuxTps2Df369cOhQ4fw+OOPY+DAgfJ9kk6dOoU+ffqgV69eOHjwIEaOHInXXnvtrvESExMt7ufk66vOLMRERFTDCCjQ56qyD6J8tTa5SkxMxMCBAzF69Gg0adIEHTt2xKJFi7Bq1Srk5+ejRYsWCAsLw0cffSRvs3r1arRv3x6NGzcGAEydOhXz589HTEwMAgMDERMTgzFjxmD58uUW+xo9erS8jpeXF4YPH47vvvtOnmr/woUL+Pbbb/H8888D+Kdpr27duvD09IS7u7scq06dOli8eDGaN2+OJ598Ek888QS2bt1612ONjY3Fs88+i8aNG2P27NnIzc2VE7jly5ejWbNmmDt3Lpo1a4Znnnmm3NsExMfHW9zPKTMz8x7OOBER1Xq1pEN7rU2uDh48iOTkZBgMBnmJjo6G2WzGqVOnABTXXpUkV0IIfPzxxxg4cCAA4Pr160hPT8ewYcMsYsycOdOitgsAIiIsb1rVrl07tGjRQq7h+vDDD+Hv74/OnTuXW+4WLVrA3t5efuzl5YULFy7cdZvQ0FD5b2dnZxiNRnmbtLQ0tG3btlT57kar1cr3dLrXezsRERHVFrW2Q3tubi5GjhyJuLi4Uq/5+fkBAJ599llMmjQJv/32G27cuIHMzEz0799f3h4AVqxYUapv1q3JD4AyR+8NHz4c7777LiZPnoykpCQMHToUkiSVW+7bO8NLkiTfyVvJbYiIiBRnBlD+T135Maq4WptctW7dGkeOHJGb+MrSsGFDREZGYvXq1bhx4wa6deuG+vXrAwAaNGgAb29vnDx5Uq7NqohBgwZh4sSJWLRoEY4cOYIhQ4bIr2k0GgBAUVFRheNWVLNmzfDtt99aPLd3717V90tERLUPRwvWcJMmTcJPP/2EUaNG4cCBAzh+/Di++uoruUN7iYEDB2LNmjX49NNPSyVR06ZNQ2JiIhYtWoRjx47h999/R1JSEt56661y91+nTh3ExMRgwoQJePTRR9GwYUP5tfr160Ov12PTpk04f/48srOzlTnoMowcORJHjx7FpEmTcOzYMXzyySdyB/l7qUkjIiIiS7U2uQoNDcWOHTtw7NgxPPzww2jVqhWmTJkCb29vi/X69OmDS5cuIS8vr9Ts6MOHD8f777+PpKQktGzZEpGRkUhOTpanUijPsGHDUFBQIHdkL+Hg4IBFixZh+fLl8Pb2Rs+ePa061rsJDAzEZ599hi+++AKhoaFYunSpPFpQq9Wqtl8iIqqFakmHdkmIalDKGuqDDz7AmDFjcPbsWbkpsCqYNWsWli1bds+jAHNycuDq6op/bRgJB2dlE7Kjh5Wf5kFo1Wmwt8uzL3+l+2DWqVRe58LyV7oPRuMNxWMW3FTn3Goc1Gl6b+R+UZW4Ovubisf00V9VPCYAtND/pUrc364HqBL3j6teisf8+yt1pqlxO6H8Z/dmYT5+/n4qsrOzVRmkJP9OhIyHg711vxM3i0zYemSeamVVQq3tc1WZ8vLykJWVhTfffBMjR46s9MRqyZIlaNu2LerWrYuUlBTMnTu3VPMoERER3Zta2yxYmebMmYPmzZvD09MT8fHxlV0cHD9+HD179kRISAhmzJiBcePGISEhobKLRURENU0taRZkzVUlSEhIqFLJy9tvv4233367sotBREQ1HadiIKqYOtobcNQq3IfFrMKIxSJ1RkGaXZTvDwMAkqM63yQOGnX6G5mF8ufX6JSveEwAyC9Q5ybqnrprqsQtFMo3NpjM6vwMNNWcVyVuXYdcVeI20Stf3rVPqHNuz/+sfP+wovwi4HvFw5bCqRiIiIiIqMJYc0VERES2oUSfqWpQc8XkioiIiGzDLADJyuTIXPWTKzYLEhERESmINVdERERkG7WkWZA1V7VUcnIy3NzcKrsYRERUqygxxxWTK6qi+vfvj2PHjlV2MYiIiGocNgvWUnq9Hnq9vrKLQUREtQmbBakmu71Z8ODBg+jSpQtcXFxgNBrRpk0b7Nu3r/IKSERENY9ZKLNUcay5IgDAwIED0apVKyxduhT29vY4cOAAHB3Lnr3aZDLBZDLJj3NycmxVTCIioiqPyRUBADIyMjBhwgQ0b94cANCkSZM7rpuYmIhp06bZqmhERFRTCHPxYm2MKo7NggQAGDt2LIYPH46uXbvizTffRHp6+h3XjY+PR3Z2trxkZmbasKRERFRtWTtSUIk+WzbA5IoAAAkJCfjjjz/wxBNP4IcffkBISAi+/PLLMtfVarUwGo0WCxERUblqSZ8rJlcka9q0KcaMGYPvv/8eMTExSEpKquwiERERVTtMrgg3btzAqFGjsH37dvz5559ISUnB3r17ERwcXNlFIyKimqSWNAuyQzvB3t4ely5dwuDBg3H+/HnUq1cPMTEx7LRORETKElBgnitFSqIqJle1VGxsLGJjYwEAGo0GH3/8ceUWiIiIqIZgckVERES2UUtmaGdyRURERLZhNgOwcp4qM+e5IiIiIqpVWHNFREREtsFmQaKKuZTvBAd7raIxHa5LisYDAHOhOhW2wqROXLNOnSrwggJ1yltUpHzc3Fyd4jHV9FNWgCpxnTSFisfUOyofEwCSih5SJW5dx+uqxK2jQlw/lyuKxwSAq+HKfx7s8kzlr6SEWpJcsVmQiIiISEGsuSIiIiLbMAtYPVFVNbj9DZMrIiIisgkhzBDCuq4O1m5vC0yuiIiIyDaEAjdeZp8rIiIiotqFNVdERERkG0KBPlfVoOaKyRURERHZhtkMSFb2maoGfa7YLEhERESkINZcERERkW2wWZCobCaTCSbTP7P55uTkVGJpiIiouhBmM4SVzYLVYSoGNgtShSUmJsLV1VVefH19K7tIREREVQaTK6qw+Ph4ZGdny0tmZmZlF4mIiKqDknsLWrtUcWwWpArTarXQapW9QTMREdUCZgFINb/PFWuuiIiIiBTEmisiIiKyDSEAWDvPVdWvuWJyRURERDYhzALCymZBweSKiIiI6P8IM6yvueJUDERERES1CmuuiIiIyCbYLEhERESkpFrSLMjkiqxW8l/EzbwCxWOb8/OVj2lW578eodKnyazWF4mDOnEl3FQ8pjBLisdUU5GDqfyV7sPNwkLlYzoqHxMACiTlvw8AwKRSefMdlb9uC6+rcw6K8pS/vkpiql0rdBOFVt9a8CbUuQaUJInqUL9GVdpff/3FW+AQEdUAmZmZaNiwoeJx8/PzERgYiHPnzikSz9PTE6dOnYJOp1MkntKYXJHVzGYzzp49CxcXF0jS3WsYcnJy4Ovri8zMTBiNRsXKoEbc6lTW6ha3OpW1usWtTmWtbnGrU1krGlcIgWvXrsHb2xt2duqMdcvPz0dBgTK1eRqNpsomVgCbBUkBdnZ2Ff5Px2g0Kvolombc6lTW6ha3OpW1usWtTmWtbnGrU1krEtfV1VXxfd9Kp9NV6YRISZyKgYiIiEhBTK6IiIiIFMTkimxKq9Vi6tSp0Gq1VT5udSprdYtbncpa3eJWp7JWt7jVqaxqxqXysUM7ERERkYJYc0VERESkICZXRERERApickVERESkICZXVO1s374dkiTh6tWrlV2UKiEgIAALFiwo87XY2Fj06tXrrttXl/N5L8dyJ3l5eejduzeMRuMdjzU5ORlubm7y44SEBISHh1usk5CQgAYNGkCSJKxbt+6+yqKmu10Lam5bUyj9vpZ3zSYnJ8POzq7Wn/eaiMlVNREbG4uEhAT5cVlf/GqojB/eo0eP4sEHH4ROp0N4eDiioqIwevRom+3/bk6fPl3uLPRluf2H+34oEaOsc9mxY0dkZWWpPoHgvV5LJef4wIEDFs8vXLgQycnJ97XvlStXYufOnfjpp5/u+VjHjx+PrVu3yo9TU1Mxbdo0LF++HFlZWXjsscfuqyxKUOJauN3evXvxwgsvKBqztrjTNVue/v374/DhwzzvNRCTK7orW/3w3mrq1KlwdnZGWlqaxY9bWe73S608asW9m0IVbsp7LzQaDTw9Pe8rabQlV1fX+04o0tPTERwcjAceeOCej9VgMKBu3boWMQCgZ8+e8PT0rHHD2z08PODk5KRafCEEbt5U/ubIalPzc6nX6xESEqLqeafKweSqCrty5Qpyc3MrtQyV8cObnp6Ohx56CP7+/hg3bhx27NiBhQsXQpIkSJKE06dPAwB+/fVXPPXUUwCAgQMH4oknnoCPjw+cnJzQsmVLjBs3Dq1bt4ZOp0NQUBACAgIwatQoTJw4Ee7u7vD09LSoDRRCICEhAX5+fmjWrBkA4L///S8AYPHixXjggQfkddetWwdJkrBs2TJkZGQAALp27YrXX39dXuerr75C69atodFoMHToUGRnZ8vHkJCQAEmSMH/+fPj6+kKSJDg5OeGxxx7D8ePHS52T7du3l4oRFRUl117m5eXh+eefh1arhYODA9577z2L7TMzMxEQEFDmuby9Rmn48OGws7ODVquFwWCAo6MjNBoN8vLysHLlSvm5uLg4FBUVAQBGjx6N4OBgREREwMXFBQ0aNEBYWBj8/Pyg1+sRHByMLl26AADq1KkDSZIQFBQEDw8P6PV61KtXD/Xq1YNer0dgYCAAoFWrVvJxAqWbWEwmE+Li4lC/fn04OjrCyckJGo0GAQEBmD9/vnxcYWFhmD9/Pn788UdIkoR27drd03V4a+1wQkICevToAaD4dk+3fh7ef/99BAcHQ6fToXnz5liyZMk9xb9fZV0Lnp6e8ut5eXlo37497Ozs4Ofnh/fee08+d/PmzUP9+vWh1Wqh1WpRp04d9OzZE6dPn7ZoFhwwYAD69+9vsd/CwkLUq1cPq1atAlB8T9HExEQEBgZCr9cjLCwMn332mUU5JUnCxo0b0aZNG2i1WuzatQsHDx5Ely5d4OLiAqPRiDZt2mDfvn3ydrt27cLDDz8MvV4PX19fxMXF4fr16/JrHTp0gIODA+zt7eHg4IAWLVrg448/xn/+8x+0b98eQHENbVxcHCZOnAgHBwcYDAb5s17yfmm1Wjg5OcHR0REhISHYvHkzAODpp5/G2rVrERkZCZ1Oh/feew9Go9Hi2IDi7wBnZ2dcu3btjtdsiXnz5sHLywt169bFK6+8IidstzcLHjx4EJIkQafTwdHREXZ2dvD19cXXX39tEe/rr79GkyZNoNPp0KVLF6xcubJaNO3XKoKqlMLCQrF+/XrRp08fodVqxYEDB4QQQgwZMkRMnTpVXm/q1KkiLCxMLFu2TDRs2FDo9XrRt29fcfXqVYt4K1asEM2bNxdarVY0a9ZMvPvuuxavp6SkiLCwMKHVakWbNm3El19+KQCI/fv3CyGE2LZtmwAgrly5IoQQIikpSbi6uopNmzaJ5s2bC2dnZxEdHS3Onj17T8dXVFQkpk2bJnx8fIRGoxFhYWFi48aN8usALJZJkyaJDh06iBEjRoisrCyRlZUltmzZIgCI9u3bl1q/TZs2Ij09Xbz66qsCgKhbt67QaDSiYcOGwsHBQWi1WpGQkCBiYmJEw4YNhSRJ4vvvvxcmk0kEBAQIR0dH8e2335YZV5IksW/fPgFAjB49WtSrV0/0799fREVFiZCQEOHo6CjWrFkjhBDixx9/FEajUSQnJ4vU1FTx0ksvCUmSxLhx40RWVpa4du2aACA0Go3w8vISa9asERs3bhTR0dGicePGoqCgwOK8mUwmsWDBAmE0GuXzEB8fL8LCwoS/v79wd3cX7777rvjPf/4j3NzchJ2dnTh69KgYMmSI6NGjhwgODhaDBg0SYWFhom/fvuLpp58WjRo1Enl5eRbv8S+//CIkSRJ2dnaiY8eOYsKECcJgMAhJksSjjz4q+vXrJ3r27Cnat28vNBqNfLyvvvqqaNasmfj2229Fenq6GDlypNDr9SIiIkKkp6eL//3vf8LR0VEAEGlpaWLo0KGiZcuWYu/evWLcuHHC19dXJCQkiPT0dPHGG28IAGL+/PkiKytLXLp0Sf4M9OzZUz4ncXFxwtvbWyxcuFDY2dmJ8PBwYTQaxTvvvCP0er2YNGmS/N49+eSTIjw8XLRv3160bdu2zGuz5Nq+/TMmhBDXrl0TSUlJAoB8/oUQ4sMPPxReXl7i888/FydPnhSff/65cHd3F8nJyff0ebgft18L48aNEy1bthRCCPla6N27t/Dx8RGJiYnCzs5O9OrVSxiNRvHCCy+IoKAg0bVrV6HT6cS0adPEgAEDRLNmzYS/v794++23hRBCrF+/Xuj1enHt2jV5v998843Q6/UiJydHCCHEzJkzRfPmzcWmTZtEenq6SEpKElqtVmzfvl0I8c93R2hoqPj+++/FiRMnxKVLl0SLFi3EoEGDRGpqqjh27Jj45JNP5O+5EydOCGdnZ/H222+LY8eOiZSUFNGqVSsRGxsrv5aQkCAmTpwokpKSRIsWLUT79u2Fvb29+PjjjwUAceLECREZGSmMRqN4+eWXBQAxZ84cIUmSmDRpkvDy8hKffvqpaNq0qWjZsqVwdXUV8fHxolWrVvLnPSAgQH5Pz549K0aMGCEef/xxi/fhqaeeEoMHDxZCCLFnzx4BQGzZsqXUNWs0GsWLL74oUlNTxTfffCOcnJzEe++9J4QovuYkSZLPe4sWLQQA0aBBAzF//nyxaNEi8eyzzwqDwSDHPHnypHB0dBTjx48XR48eFR9//LHw8fGx+J6mysfkqoo4dOiQGDt2rGjQoIFwd3cXL730kvjpp5/k18tKrpydncUjjzwi9u/fL3bs2CEaN24sBgwYIK9T3hd/dna2cHd3F4MGDRJ//PGH+Pbbb0XTpk3LTa4cHR1F165dxd69e8Wvv/4qgoODLfZ7N2+99ZYwGo3i448/FkePHhUTJ04Ujo6O4tixY0IIIbKyskSLFi0skpDIyEjx6quvyjFKyrRlyxb5S23WrFkCgDhz5owQovhLyt7eXjz11FPysdvZ2Ql7e3shRPGPZVBQkGjQoIGYNGmSGD9+vKhTp46c2Nz+ZXnx4kVRt25d8e677woAIjw8XCQmJgpPT09x4cIF8eqrr8pJyWOPPSYeeOABMX36dLnMSUlJwsnJSXh5ecnPlXyRp6SkyM9dvHhR6PV68cknn5Q6d3f68ff39xeDBg0SQgjx9ttvC39/f1G/fn2xdOlSMWTIENG6dWvRrFkzYTab5XNpMpmEXq8X3333ncV7/Oyzz4rQ0FD5R0oIIfr37y80Go1wcnIS165dk5Oc6OhoMXLkSCFEcXIVGRkphBAiPz9fODk5if/9738CgPwD/fjjj8v76dGjhxg6dKi87q3X+qlTpwQA0b17d4vjvzW5ys3NFY6OjmL16tViwIABolu3bqKgoEB4e3uLOXPmiAkTJgh/f3/5PSwp34YNGwQAcePGjXs+vyVK/vG4VaNGjcRHH31k8dyMGTNEhw4dSsVX0q1lvbWcJddCyXVgNptF/fr1xYMPPij8/f3FypUr5Wuhb9++on///vK10KBBA/lHvrCwUNSrV0+sWrVK3uezzz4r+vfvL4QQZb5vQggxbNgw8eyzzwoh/vmcrlu3zmIdFxeXOyafw4YNEy+88ILFczt37hR2dnYiNjb2jq91795djBs3ToSFhYnp06eLyMhI8dBDD4n4+HjRvn17IYQQbdu2FW5ubuKjjz4S3333nXBwcBBnzpyR36+NGzfKn8kFCxZY7Gf37t3C3t5e/ify/PnzwsHBQU4kS67Zku/NEkOGDBH+/v7i5s2b8nMl512I0smVi4uLACBef/11ef3c3FwBQP4ndNKkSeKBBx6w2M9rr73G5KqKYbNgJbp06RIWLlyI1q1bIyIiAidPnsSSJUuQlZWFJUuWoEOHDnfdPj8/H6tWrUJ4eDg6d+6Md955B2vWrMG5c+cAFPddmj9/PmJiYhAYGIiYmBiMGTMGy5cvBwB89NFHkCQJK1asQEhICB577DFMmDCh3HIXFhZi2bJliIiIQOvWrTFq1Khy+0aVmDdvHiZNmoRnnnkGzZo1w3//+1+Eh4fL1eKenp5yNb6npycMBsMdY4WGhsLDwwNA8UgnAHjkkUfg7u6OP/74A0VFRdiwYQNatmyJwYMHw2w2o6ioCHl5eTAYDPjwww9x4cIFbNq0CQsWLMCKFStgMpkQFBSE+fPnAyju5+Pp6Ym6deuic+fO+OWXXwAAR44cwcsvvwyTyYRLly6hfv366NChAw4fPozQ0FAcOXIEU6ZMkZurRo4ciby8PGRlZSEvL08+Bnt7e7kpAwDq1q2LZs2aITU19Z7O563n4laenp64cOECACAnJwcnTpyAi4sLdu7ciXfffRfu7u7Iz8+X+xGVSE1NRVBQEJycnNCoUSMAQIcOHSBJEgICAizejwYNGsj7AIBr166hR48eCAgIQF5eHoYNGwYAqF+/PgwGA77//nt53Zdeeglr1qxBWFgY8vLy8Mgjj8BgMMBgMCAkJARAcVPmnaSnp6OwsBCdOnVCamoqOnXqBEdHR7Rr105+fObMmVLnxsvLCwAsyn2/rl+/jvT0dAwbNkwuu8FgwMyZM0udV1u69XhLmgzz8/PRokUL/P777/K18OWXX+LTTz+Vr4Vb+xY5ODigX79+WL16NYDiY/3qq68wcOBAAMCJEyeQl5eHbt26WRz7qlWrSh17RESExeOxY8di+PDh6Nq1K958802L9Q8ePIjk5GSLmNHR0TCbzdi3b5/8mlarhb29PR5++GGYzWZs3rwZGRkZGDhwID766CMAQMuWLfHxxx/LZfbw8MDVq1cxbNgw9OjRA0VFRWjatKn8ft36fXt7mdu1a4cWLVpg5cqVAIAPP/wQ/v7+6Ny5c7nvR4sWLWBvby8/9vLyuuP1N3bsWADFXQpKzo2zszOMRqO8TVpaGtq2bVuqfFS1MLmqRO+88w5Gjx4Ng8GAEydO4Msvv0RMTAw0Gs09be/n5wcfHx/5cYcOHWA2m5GWlnZPX/xpaWkIDQ2FTqeTY9zLh/TWH17g7l8Wt8rJycHZs2fRqVMni+dLfiArytHRUf57/fr1AICRI0fi22+/BVD8wyKEgNlshtlshiRJ0Gq18vF26NABjRs3xsGDBzFu3Dj07t0baWlpWLJkibzOsGHD5B+dqKgo7N69G0Bx3wqj0YjOnTtj+/bt2LFjByIjIxEcHIw333wTGo1GHk1mb2+P6dOnw8XFBcePH7c439aws7OD+L+7V5Wci5KySpIEs9kMALh58ybatGmDAwcOICIiAgMHDsSBAwdw7NgxDBgwoNxze/tzJfu9dR95eXk4dOgQjEaj3Ldl7ty5AIA1a9bgwIEDFiP9HnvsMfz555/o168fgOL+O8888wwOHDggv3/z5s2773Nzp2Mp6StVUm5rlPSHXLFiBQ4cOCAvhw8flpNwW7j1OgCKj/fWRKnkc+Do6Ijc3Fz5Whg4cCAiIiLka8HZ2dki7sCBA7F161ZcuHAB69atg16vR/fu3QH8c+wbNmywOPYjR46U6pt0e9yEhAT88ccfeOKJJ/DDDz8gJCQEX375pRx35MiRFjEPHjyI48ePo7CwECNHjsSLL74IJycnzJkzB19//TW2bNmCRx99FAUFBXj22WeRlpaGa9eu4eLFi8jMzJT7jpX0D1yxYgUmTJgAHx+fO75ft5cZKO6LWHINJyUlYejQoffUF/X2z9Ktn5vblXx2IiIiLM7N3bahqonJVSV64YUXMGPGDJw7dw4tWrTA0KFD8cMPP1T5L/6yviyEireo1Gg08hfjnaSlpQEo7oxa0rlUp9PhkUcewaFDh3Do0CG0bdsWzz77LOzsii97s9mMy5cvQ5IknDhxAkDx6J0ePXrIX3KHDh3C77//DgCIjIyUO5uXdFiNiorCli1bkJKSgqioKGRmZuLNN9+EJEn4/vvv0a9fP3z55Zfw9fWFEAKNGzeW9w8Uf+GXJGxAcW1mWlqaXHtzt/Pg4eGBc+fOWZz7skY3urq64vjx46hfvz5cXV3h4uKCxo0bo3HjxqVGgQYHB+PkyZMWz91+vXh4eCArK8viud27d+PmzZt48803MWDAAGi1Wvmc+vn5oXHjxvL7UnIMHh4emDBhArRaLQYMGIBPPvkEjRs3RtOmTeXX76RRo0bQaDRISUlBcHAwUlJSUFhYiL179yIkJAQpKSlo2LDhHbdXQoMGDeDt7Y2TJ0/K57NkKTlWtdx6LdzrdQAArVu3lq8FNzc36PV6ucy3XpdA8UhhX19frF27FqtXr0bfvn3lz35ISAi0Wi0yMjJKHbuvr2+55W/atCnGjBmD77//HjExMUhKSpLLd+TIkVIxGzdujDZt2uDIkSNIS0tDTEwMxo0bhx49eqBLly7ytdawYUNERkbiwoULOHr0KLp164b69esDKP4+0Ov1OHnyJDp37oxz587B2dlZfr/K+14cNGgQ/vzzTyxatAhHjhzBkCFDLN4PAOV+T92rp556qtS5KdGsWTOLAQBA8TQaVLUwuapE3t7eeP3113Hs2DFs2rQJGo0GMTEx8Pf3x+TJk/HHH3/cdfuMjAycPXtWfvzLL7/Azs4OzZo1u6cv/mbNmuH333+HyWSSY6j5ITUajfD29kZKSorF8ykpKWUmEyUCAgKwe/dunD59GhcvXrRIPku+1Bo0aACgeATh5cuXodVqcePGDWRmZsJkMqGwsBDXrl2zOKdz587FtWvX0L17d2zatAnDhg3D//73Pxw+fFhOHrRaLfz9/QEUN7eUJCO3Jlfr1q1Dfn4+Zs2ahYCAAGzYsAEjR46EJElo2rSp3BSVm5uLgQMH4uLFi3LTYLt27TBixAh5FNWgQYPg4+ODnj17lnkecnNzsXXrVly8eBHt27fH33//jZycHFy8eBHvvvsuNm7cWGo7X19f1KtXDz179oROp8OPP/6INWvWYMSIEfJIxxJxcXHyNXH8+HEsXrwYmzZtsljnkUcewb59+5Ceno7c3FxMnToVp06dgiRJeOedd/D333/jqaeewooVKwAUN+/99ttvctPx+vXrMW7cOKxZswbnz5/HkCFDsHr1anh4eCA9PR1//fUXHB0dMXv2bJw/fx7Z2dmljsnZ2RkvvfQSJkyYgA4dOmDr1q1o164drl27BicnJyxevLjUaDc1TJs2DYmJiVi0aBGOHTuG33//HUlJSXjrrbdU3e+t10JYWBj+/vtvzJkzB4WFhdi1a1eZ1wFQXBtVci2cOXMG+fn52L59u8XIz1sNGDAAy5Ytw+bNm+XmNQBwcXHB+PHjMWbMGKxcuRLp6en47bff8M4778hNZ2W5ceMGRo0ahe3bt+PPP/9ESkoK9u7di+DgYADApEmT8NNPP2HUqFE4cOAAjh8/jq+++gqjRo2SX8vMzMSGDRuwdu1aLF68GC1btsT58+ctjvHChQs4ceKERZkBIDw8HImJiUhNTYW/vz9iYmIwbdo0jBo1Cq+99tpdz3mdOnUQExODCRMm4NFHH7VI3uvXrw+9Xo9Nmzbd8ZotT8m5AYqbrW8/NyVGjhyJo0ePYtKkSTh27Bg++eQTuUatqk+nUqtUWm8vKtONGzfExx9/LKKjo4W9vb04dOiQEOLOHdq7du0qDhw4IH788UfRtGlT8cwzz8jrrFixQuj1erFw4UKRlpYmDh06JP7f//t/Yv78+UKIfzq0Dx48WBw5ckQeAQhAHr1zp9GCtyqro++dvP3228JoNIo1a9aIo0ePikmTJll0aBdCiLCwMItjTUtLEw8++KDQ6/UCgDxq68qVK6KwsFDo9XoxbNgwAUA4OTmJ+vXriyeeeELY2dkJJycnodPphMFgEDqdTjRp0kQIIcRvv/0mNBqNaN++vRgyZIhYvny50Ol08ogzZ2dnIUmSGDp0qDh37pw8CrNbt24WnbSLiorkUYhvvPGG3AlcCCE2bdokOnbsKPR6vTAajaJ+/frC2dlZABBTp04VAMQHH3wgnnvuOeHq6ir0er2Ijo62OBe3e/HFF0XdunXlGEuXLhX29vZCo9GIwYMHi1mzZgl/f3/5HJZ0As/KyhKDBw8WderUEZIkCUmSBABx6NChUu/x0KFDhSRJQq/Xix49eoh58+YJrVZr0bl7ypQpQqfTCQcHBzFmzBgxatQoERwcLAICAoRWqxUPPvigGD58uAAgHBwchIeHh4iOjhbPP/+88PT0FADkY3Z3dxcPPPCACAwMFI6OjsLDw0O0aNFC1K9fX9jZ2ckd5W8fLXjjxg3x73//W9SrV084ODgIvV4vHBwchJ+fn5g7d67FcZV0aN+/f78AIE6dOlXq3N5Ph3YhhFi9erUIDw8XGo1G1KlTR3Tu3Fl88cUXd3wPb9/n/X4N33otPPHEE8LX11dIkiQiIiLk60CI4s9TWFiYfO5KrgWdTickSRJBQUFixIgRws/PT+5YXeLIkSMCgNw5/lZms1ksWLBANGvWTH7foqOjxY4dO4QQpb87hCge6fjMM88IX19fodFohLe3t/jXv/5lcQ727NkjunXrJgwGg3B2dhahoaFi1qxZ8mtRUVHC3t5evraioqLE4MGD5eO7cuWKkCRJODg4WIx27NmzpxgyZIj8fjk6OgoHBwchSZLw8vISmzZtkju0394xvcTWrVsFgDIHnKxYsUL4+vre9ZoVwnLwx60d2kvOTclxeXt7i1GjRokbN24IV1dXkZSUJMf46quvROPGjYVWqxVRUVFi6dKldxyoQZWDyVUVdubMGZGdnS2EuPNUDEuWLBHe3t5Cp9OJPn36iMuXL1vEKO+LPyUlRYSGhgqNRiPatGkjPvroIwFAHD16VAihfHJVVFQkEhIShI+Pj3B0dCw1FYMQpZOr8pT1pXa3Y79x44YICQkpNfLoqaeeEh07dpRH9pQVt2RU0K2OHj1a6oenJinrPSdlTJkyxeKarY2q0zlYtWqVqFu3rjCZTJVdFAszZ84UDRs2rOxi0C0kIVTsLEOKiY2NRUBAgMWkl2pYvXq1PEGhXq9XdV/V0enTpxEYGKhqH7OqJjk5GaNHj+YEhSpo164dFi9eXKtHe1WHc1Ay0vepp55Cr169MGvWrEotz5IlS9C2bVvUrVsXKSkp+Pe//41Ro0Zh5syZlVou+odDZReAKteqVasQFBQEHx8fHDx4EJMmTUK/fv2YWBHZwJ49eyq7CJWuOpyDOXPmYNasWejcuTPi4+Mruzg4fvw4Zs6cicuXL8PPzw/jxo2rEuWif7DmqppQq+Zqzpw5WLJkCc6dOwcvLy/5v7L7vdfV3eal2rhxIx5++OEKxZs9ezZmz55d5msPP/zwHTvuqqU21lwREVHFMLmqJtatWwc3N7dS96yqakqGRJfFx8enwjVily9fxuXLl8t8Ta/XW8zzZQtXr17FggULVG+eJSKi6ovJFREREZGCOM8VERERkYKYXBEREREpiMkVERERkYKYXBEREREpiMkVERERkYKYXBEREREpiMkVERERkYL+P405BfohykwEAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 首先查看一下屏蔽前的分数矩阵\n",
    "def display_qk_heatmap(qk_per_token):\n",
    "    _, ax = plt.subplots()  # 创建图形窗口\n",
    "\n",
    "    # imshow通常用于显示二维数组或矩阵形式的数据，将矩阵元素映射为灰度或彩色值，因此可用于绘制热力图\n",
    "    # 将张量转换回全精度，然后从计算图中分离出来（detach），避免涉及到潜在的梯度计算和存储问题\n",
    "    # 并指定使用viridis颜色映射方案来显示图像（蓝->绿->黄）\n",
    "    im = ax.imshow(qk_per_token.to(float).detach(), cmap='viridis')\n",
    "\n",
    "    # 设定xy轴的刻度数量和标签，保证正确的一一对应\n",
    "    ax.set_xticks(range(len(prompt_split_as_tokens)))\n",
    "    ax.set_yticks(range(len(prompt_split_as_tokens)))\n",
    "    ax.set_xticklabels(prompt_split_as_tokens)\n",
    "    ax.set_yticklabels(prompt_split_as_tokens)\n",
    "\n",
    "    # 添加侧方颜色条\n",
    "    # 指定im以识别正确的颜色映射和值的范围\n",
    "    # 指定所属的子图为ax（若有多个子图，则ax=ax[i]）\n",
    "    ax.figure.colorbar(im, ax=ax)\n",
    "\n",
    "display_qk_heatmap(qk_per_token)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:29.268843Z",
     "iopub.status.busy": "2025-02-19T04:41:29.268626Z",
     "iopub.status.idle": "2025-02-19T04:41:29.279114Z",
     "shell.execute_reply": "2025-02-19T04:41:29.278541Z",
     "shell.execute_reply.started": "2025-02-19T04:41:29.268827Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf, -inf],\n",
       "         [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -inf],\n",
       "         [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]]),\n",
       " torch.Size([17, 17]))"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 生成屏蔽矩阵\n",
    "# 让需要屏蔽的元素位置设置为负无穷，而不需要屏蔽的位置设为0，后续将其与分数矩阵相加即可实现屏蔽效果（负无穷在计算softmax时将趋于0）\n",
    "\n",
    "# torch.full用于生成指定形状和指定填充值的张量，这里首先生成了全为负无穷的[17x17]矩阵\n",
    "# 指定该矩阵位置与之前token的位置相同，以确保后续计算时不出错（例如：如果之前的token在gpu上，而这里不指定设备，则mask将新建在cpu上，二者相加时将会报错）\n",
    "mask = torch.full((len(tokens), len(tokens)), float(\"-inf\"), device=tokens.device)  # [17x17]\n",
    "\n",
    "# torch.triu用于返回矩阵的上三角部分，其余部分置为0（取下三角使用torch.tril）\n",
    "# diagonal为对角线的偏移量，等于1时表示从主对角线向上偏移1个位置开始取上三角部分，以避免屏蔽自身token\n",
    "mask = torch.triu(mask, diagonal=1)  # [17x17]\n",
    "\n",
    "mask, mask.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:29.280393Z",
     "iopub.status.busy": "2025-02-19T04:41:29.279726Z",
     "iopub.status.idle": "2025-02-19T04:41:29.456041Z",
     "shell.execute_reply": "2025-02-19T04:41:29.455624Z",
     "shell.execute_reply.started": "2025-02-19T04:41:29.280368Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 屏蔽未来token的分数\n",
    "qk_per_token_after_masking = qk_per_token + mask  # [17x17] + [17x17] = [17x17]\n",
    "display_qk_heatmap(qk_per_token_after_masking)  # 展示屏蔽后的注意力分数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 计算最终的注意力权重，即softmax(注意力分数)\n",
    "<div>\n",
    "    <img src=\"images/softmax.png\" width=\"600px\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:29.456733Z",
     "iopub.status.busy": "2025-02-19T04:41:29.456525Z",
     "iopub.status.idle": "2025-02-19T04:41:29.635911Z",
     "shell.execute_reply": "2025-02-19T04:41:29.635501Z",
     "shell.execute_reply.started": "2025-02-19T04:41:29.456717Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 计算注意力权重\n",
    "# 即计算分数的softmax值\n",
    "# dim=1表示按行进行softmax的计算，结果转换为半精度，与之后的value向量保持一致\n",
    "qk_per_token_after_masking_after_softmax = torch.nn.functional.softmax(qk_per_token_after_masking, dim=1).to(torch.bfloat16)  # [17x17] -> [17x17]\n",
    "display_qk_heatmap(qk_per_token_after_masking_after_softmax)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 终于！计算单头注意力机制的最终结果！\n",
    "<div>\n",
    "    <img src=\"images/attention.png\" width=\"600px\"/>\n",
    "</div>\n",
    "\n",
    "原理：之前的注意力权重(0-1)用于确定每个token使用多少比例的value向量（即对value向量进行加权）\n",
    "\n",
    "例子：假如输入为3个token，则第一个token的注意力结果可能为：res=0.6\\*value_1 + 0.3\\*value_2 + 0.1\\*value_3\n",
    "\n",
    "经过权重矩阵和value矩阵乘法计算后的注意力结果的形状为[17x128]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:29.636622Z",
     "iopub.status.busy": "2025-02-19T04:41:29.636416Z",
     "iopub.status.idle": "2025-02-19T04:41:29.644947Z",
     "shell.execute_reply": "2025-02-19T04:41:29.644449Z",
     "shell.execute_reply.started": "2025-02-19T04:41:29.636607Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 128])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 计算单头注意力的最终结果\n",
    "qkv_attention = torch.matmul(qk_per_token_after_masking_after_softmax, v_per_token)  # [17x17] x [17x128] = [17x128]\n",
    "qkv_attention.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## 计算多头的注意力机制（一个简单的循环，将上面的过程重复）\n",
    "<div>\n",
    "    <img src=\"images/heads.png\" width=\"600px\"/>\n",
    "</div>\n",
    "\n",
    "我们现在有了第一层的第一个头的注意力值\n",
    "<br>\n",
    "\n",
    "现在我们要运行一个循环，来执行和之前单元格完全相同的数学过程，但是会计算第一层中的每个头\n",
    "<br><br>\n",
    "\n",
    "<span style=\"font-size: 1.2em; font-weight: bold;\">\n",
    "值得注意的是，在<a href=\"https://github.com/meta-llama/llama3/blob/main/llama/model.py#L90\">官方的llama3代码实现</a>中，多头注意力计算采取了一次性矩阵乘法的方式，而非费时的for循环计算，大致过程如下：\n",
    "</span>\n",
    "\n",
    "1. 基于矩阵并行，计算qkv向量，[17x4096] x [4096x4096] or [4096x1024] = [17x4096] or [17x1024]，再将形状转换为[32x17x128] or [8x17x128]\n",
    "2. 得到qkv向量后，将kv内部进行复制，从而与q向量形状保持一致，此时形状均为[32x17x128]\n",
    "3. 计算分数时，采用transpose方法将张量的最后两维位置交换从而完成矩阵乘法，如 `torch.matmul(q, k.transpose(1,2)) / head_dim ** 0.5`，此时为[32x17x128] x [32x128x17] = [32x17x17]\n",
    "4. 其他的矩阵计算同理\n",
    "<br>\n",
    "\n",
    "注：上述过程中每一步的矩阵形状变化为简化版，仅供示意以便于理解，与llama3官方实现的变化过程不同（官方实现中会涉及大量的形状变化过程）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 计算每个头的结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecutionIndicator": {
     "show": false
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:29.654560Z",
     "iopub.status.busy": "2025-02-19T04:41:29.654258Z",
     "iopub.status.idle": "2025-02-19T04:41:30.556481Z",
     "shell.execute_reply": "2025-02-19T04:41:30.555922Z",
     "shell.execute_reply.started": "2025-02-19T04:41:29.654544Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 计算多头注意力结果\n",
    "# 即之前的单头注意力计算过程的循环\n",
    "qkv_attention_store = []\n",
    "\n",
    "for head in range(n_heads):\n",
    "    # 取出当前头对应的qkv权重矩阵\n",
    "    q_layer0_head = q_layer0[head]  # [32x128x4096] -> [128x4096]\n",
    "    k_layer0_head = k_layer0[head//(n_heads // n_kv_heads)]  # 每4个头共享一个key权重，[8x128x4096] -> [128x4096]\n",
    "    v_layer0_head = v_layer0[head//(n_heads // n_kv_heads)]  # 每4个头共享一个value权重，[8x128x4096] -> [128x4096]\n",
    "    \n",
    "    # 计算XW，得到qkv向量\n",
    "    # [17x4096] x [4096x128] = [17x128]\n",
    "    q_per_token = torch.matmul(token_embeddings, q_layer0_head.T)\n",
    "    k_per_token = torch.matmul(token_embeddings, k_layer0_head.T)\n",
    "    v_per_token = torch.matmul(token_embeddings, v_layer0_head.T)\n",
    "    \n",
    "    # 给query向量加入位置信息（RoPE）\n",
    "    q_per_token_split_into_pairs = q_per_token.float().view(q_per_token.shape[0], -1, 2)  # 维度方向进行两两分组，组成维度对，[17x128] -> [17x64x2]\n",
    "    q_per_token_as_complex_numbers = torch.view_as_complex(q_per_token_split_into_pairs)  # 转换为复数表示，(x,y) -> (x+yi)，[17x64x2] -> [17x64]\n",
    "    q_per_token_as_complex_numbers_rotated = q_per_token_as_complex_numbers * freqs_cis[:len(tokens)]  # 计算(x+yi)*(cosmθ+sinmθi)，完成旋转操作，[17x64] * [17x64] = [17x64]\n",
    "    q_per_token_split_into_pairs_rotated = torch.view_as_real(q_per_token_as_complex_numbers_rotated)  # 结果还原回实数表示，(x+yi) -> (x,y)，[17x64] -> [17x64x2]\n",
    "    q_per_token_rotated = q_per_token_split_into_pairs_rotated.view(q_per_token.shape)  # 结果还原回原始向量形状，得到最终的query向量，[17x64x2] -> [17x128]\n",
    "\n",
    "    # 给key向量加入位置信息（RoPE）\n",
    "    k_per_token_split_into_pairs = k_per_token.float().view(k_per_token.shape[0], -1, 2)  # 维度方向进行两两分组，组成维度对，[17x128] -> [17x64x2]\n",
    "    k_per_token_as_complex_numbers = torch.view_as_complex(k_per_token_split_into_pairs)  # 转换为复数表示，(x,y) -> (x+yi)，[17x64x2] -> [17x64]\n",
    "    k_per_token_as_complex_numbers_rotated = k_per_token_as_complex_numbers * freqs_cis[:len(tokens)]  # 计算(x+yi)*(cosmθ+sinmθi)，完成旋转操作，[17x64] * [17x64] = [17x64]\n",
    "    k_per_token_split_into_pairs_rotated = torch.view_as_real(k_per_token_as_complex_numbers_rotated)  # 结果还原回实数表示，(x+yi) -> (x,y)，[17x64] -> [17x64x2]\n",
    "    k_per_token_rotated = k_per_token_split_into_pairs_rotated.view(k_per_token.shape)  # 结果还原回原始向量形状，得到最终的key向量，[17x64x2] -> [17x128]\n",
    "\n",
    "    # 计算注意力分数，同时归一化分数（即QxK/sqrt(dim)）\n",
    "    qk_per_token = torch.matmul(q_per_token_rotated, k_per_token_rotated.T)/(head_dim)**0.5  # [17x128] x [128x17] = [17x17]\n",
    "    \n",
    "    # 屏蔽未来token的分数\n",
    "    mask = torch.full(qk_per_token.shape, float(\"-inf\"), device=tokens.device)  # 创建和注意力分数相同形状，值全为负无穷的矩阵，并保证存储位置和其他向量一致，防止后续计算时错误，[17x17]\n",
    "    mask = torch.triu(mask, diagonal=1)  # 保留上三角部分的负无穷，将下三角设为0（即上三角区域为未来token需要屏蔽，下三角为当前及以前的token无需屏蔽），对角线偏移量为1，避免屏蔽自身token，[17x17]\n",
    "    qk_per_token_after_masking = qk_per_token + mask  # 注意力分数与屏蔽矩阵相加，使分数矩阵的上三角变为负无穷，后续softmax后将趋于0，[17x17]\n",
    "    \n",
    "    # 计算注意力权重（即softmax(score)）\n",
    "    # 同时变换回半精度（因为后续要和value向量v_per_token相乘，需要保证数据类型相同）\n",
    "    qk_per_token_after_masking_after_softmax = torch.nn.functional.softmax(qk_per_token_after_masking, dim=1).to(torch.bfloat16)  # 按行计算softmax，[17x17]\n",
    "    \n",
    "    # 计算注意力机制的最终结果（即softmax(score) x v）\n",
    "    qkv_attention = torch.matmul(qk_per_token_after_masking_after_softmax, v_per_token)  # [17x17] x [17x128] = [17x128]\n",
    "    \n",
    "    # 记录该头结果\n",
    "    qkv_attention_store.append(qkv_attention)\n",
    "\n",
    "len(qkv_attention_store)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 合并每个头的结果为一个大矩阵\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/stacked.png\" width=\"600px\"/>\n",
    "</div>\n",
    "现在我们有了第一层所有的32个头的注意力机制结果，下一步我们将合并所有的注意力值到一个大的矩阵，形状为[17x4096]\n",
    "<br>\n",
    "我们注意力层的计算马上就要到头了 :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:30.557300Z",
     "iopub.status.busy": "2025-02-19T04:41:30.557104Z",
     "iopub.status.idle": "2025-02-19T04:41:30.560748Z",
     "shell.execute_reply": "2025-02-19T04:41:30.560353Z",
     "shell.execute_reply.started": "2025-02-19T04:41:30.557283Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 4096])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 合并多头注意力矩阵\n",
    "stacked_qkv_attention = torch.cat(qkv_attention_store, dim=-1)  # 将第二维合并，即32个[17x128] -> [17x4096]\n",
    "stacked_qkv_attention.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### 头间信息交互（线性映射），自注意力层的最后一步！\n",
    "<div>\n",
    "    <img src=\"images/weightmatrix.png\" width=\"600px\"/>\n",
    "</div>\n",
    "对于layer0的attention计算的最后一步是进行最后一次的线性映射，也就是将合并的注意力矩阵与输出权重矩阵相乘"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:30.564171Z",
     "iopub.status.busy": "2025-02-19T04:41:30.563899Z",
     "iopub.status.idle": "2025-02-19T04:41:30.567041Z",
     "shell.execute_reply": "2025-02-19T04:41:30.566646Z",
     "shell.execute_reply.started": "2025-02-19T04:41:30.564155Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([4096, 4096])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 加载layers.0的output权重矩阵\n",
    "w_layer0 = model[\"layers.0.attention.wo.weight\"]  # [4096x4096]\n",
    "w_layer0.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这只是一个简单的线性层，所以我们只需要矩阵乘法即可"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "ExecutionIndicator": {
     "show": false
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:30.567796Z",
     "iopub.status.busy": "2025-02-19T04:41:30.567590Z",
     "iopub.status.idle": "2025-02-19T04:41:30.655124Z",
     "shell.execute_reply": "2025-02-19T04:41:30.654579Z",
     "shell.execute_reply.started": "2025-02-19T04:41:30.567781Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 4096])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 进行注意力矩阵的线性映射\n",
    "# 这就是注意力层的最终输出结果了\n",
    "embedding_delta = torch.matmul(stacked_qkv_attention, w_layer0.T)  # [17x4096] x [4096x4096] = [17x4096]\n",
    "embedding_delta.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 进行一下残差操作（add）\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/afterattention.png\" width=\"600px\"/>\n",
    "</div>\n",
    "现在我们有了输入向量在进行注意力机制作用后的值，这时要在它的身上添加原始的输入向量（即残差操作，保证信息的不易丢失，并缓解梯度消失问题）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:30.655848Z",
     "iopub.status.busy": "2025-02-19T04:41:30.655647Z",
     "iopub.status.idle": "2025-02-19T04:41:30.663827Z",
     "shell.execute_reply": "2025-02-19T04:41:30.663362Z",
     "shell.execute_reply.started": "2025-02-19T04:41:30.655833Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 4096])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将attention层的输出与原始输入相加，完成残差操作\n",
    "embedding_after_edit = token_embeddings_unnormalized + embedding_delta  # [17x4096] + [17x4096] = [17x4096]\n",
    "embedding_after_edit.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 进行第二次的归一化操作\n",
    "<div>\n",
    "    <img src=\"images/norm_after.png\" width=\"600px\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:30.664980Z",
     "iopub.status.busy": "2025-02-19T04:41:30.664423Z",
     "iopub.status.idle": "2025-02-19T04:41:30.758824Z",
     "shell.execute_reply": "2025-02-19T04:41:30.758360Z",
     "shell.execute_reply.started": "2025-02-19T04:41:30.664959Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 4096])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将残差结果再进行一下归一化\n",
    "embedding_after_edit_normalized = rms_norm(embedding_after_edit, model[\"layers.0.ffn_norm.weight\"])  # [17x4096] & [4096] -> [17x4096]\n",
    "embedding_after_edit_normalized.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 进行ffn前馈网络层的计算\n",
    "<div>\n",
    "    <img src=\"images/swiglu.png\" width=\"600px\"/>\n",
    "</div>\n",
    "<br>\n",
    "在llama3中，它们使用了SwiGLU前馈网络，这种网络架构可以在模型需要时很好的增加非线性特性\n",
    "<br>\n",
    "如今，这种前馈网络架构在大模型中很常用\n",
    "<br><br>\n",
    "\n",
    "<span style=\"font-size: 1.2em; font-weight: bold;\">为什么要引入非线性层：</span>\n",
    "\n",
    "- 非线性特性是神经网络模型能成为“万能函数逼近器”的核心。在传统神经网络模型中，我们要使用非线性的激活函数（如sigmoid，ReLU等）来增加模型的表达能力，使其能够拟合训练数据中隐含的复杂模式。\n",
    "- 而在transformer中，由于注意力机制本质上是对value向量的线性加权求和（尽管权重是经由softmax函数的非线性计算得到的，但对value来说依旧只是线性加权），因此它虽然能够捕捉全局依赖，但其输出仍只是输入的线性组合，此时的transformer模型是缺乏非线性能力的。\n",
    "- 因此，需要在自注意力层后添加FFN网络，给模型引入非线性变换能力，从而提升模型能够对复杂语义关系进行建模的能力。\n",
    "<br>\n",
    "\n",
    "<span style=\"font-size: 1.2em; font-weight: bold;\">大致来说，引入非线性层可以起到如下作用：</span>\n",
    "\n",
    "1. 给模型增加非线性能力以便于模型的学习训练\n",
    "2. 增加模型的信息抽象能力，使模型在逐层的学习过程中，能够表征不同层面的数据特征和模式，比如低层网络识别基础的语言结构（如词性），而在高层则能够理解更为复杂的语义信息（如情感、意图）\n",
    "3. 此外，目前的一种观点认为，注意力层主要用于输入上下文的交互，而FFN层才是大模型中主要记忆存储训练时的通用知识的地方（得益于其非线性表征能力），从而能够从通用知识中找到输入问题的答案\n",
    "<br><br>\n",
    "\n",
    "<span style=\"font-size: 1.5em; font-weight: bold;\">SwiGLU网络结构：</span>\n",
    "\n",
    "1. 将输入进行线性变换：$X^\\prime = XW_3$\n",
    "2. 门控单元：$GATE = Activation\\_Function(XW_1)$，用于有选择的通过信息，即假定 $X^\\prime$ 中的信息重要性不同，从而通过门控单元的分数对信息进行加权通过，进而提升模型的表达能力\n",
    "3. 其中的激活函数为一种Swish激活函数（因此网络称为SwiGLU，即Swish激活函数和GLU门控线性单元的结合），公式为：$Swish = X \\cdot \\sigma(\\beta X)$，其中 $\\sigma$ 为sigmoid激活函数，在SwiGLU中，$\\beta$为1（在原始公式里是一个可学习参数）\n",
    "4. 因此，门控单元的具体计算为：$GATE = XW_1 \\cdot \\sigma(XW_1)$，在pytorch中，该激活函数为silu，即 $GATE = silu(XW_1)$\n",
    "5. 门控机制应用：$X^\\prime = X^\\prime \\cdot GATE$\n",
    "6. 再次进行线性变换：$Y = X^\\prime W_2$\n",
    "<br><br>\n",
    "\n",
    "<span style=\"font-size: 1.5em; font-weight: bold;\">前馈层隐藏层维度大小的来源计算（基于llama3官方实现过程）：</span>\n",
    "\n",
    "1. 输入维度dim = 4096\n",
    "2. hidden_dim = 4 * dim = 16384  # 首先放大四倍，在transformer块中初始化前馈层时，输入hidden_dim时乘了四倍\n",
    "3. hidden_dim = int(2 * hidden_dim / 3) = 10922 # 再放大2/3倍，在前馈层内首先进行了这样的放缩\n",
    "4. hidden_dim = int(ffn_dim_multiplier * hidden_dim) = int(1.3 * 10922) = 14198  # 再放大ffn_dim_multiplier倍，在模型配置文件中定义了ffn_dim_multiplier为1.3\n",
    "5. hidden_dim = multiple_of * ((hidden_dim + multiple_of - 1) // multiple_of) = 1024 * ((14198 + 1024 - 1) // 1024) = 14336  # 调整为multiple_of的整数倍，在模型配置文件中定义了multiple_of为1024，确保模型所有隐藏层维度都是1024的倍数，以提升计算效率\n",
    "6. 最终便得到了隐藏层为14336维的结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecutionIndicator": {
     "show": false
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:30.759808Z",
     "iopub.status.busy": "2025-02-19T04:41:30.759389Z",
     "iopub.status.idle": "2025-02-19T04:41:31.061237Z",
     "shell.execute_reply": "2025-02-19T04:41:31.059096Z",
     "shell.execute_reply.started": "2025-02-19T04:41:30.759788Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([14336, 4096]) torch.Size([14336, 4096]) torch.Size([4096, 14336])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 4096])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 计算前馈网络层\n",
    "# 隐藏层维度大小为14336\n",
    "w1 = model[\"layers.0.feed_forward.w1.weight\"]  # [14336x4096]\n",
    "w3 = model[\"layers.0.feed_forward.w3.weight\"]  # [14336x4096]\n",
    "w2 = model[\"layers.0.feed_forward.w2.weight\"]  # [4096x14336]\n",
    "print(w1.shape, w3.shape, w2.shape)\n",
    "\n",
    "# output = (silu(XW1) * XW3)W2\n",
    "# [17x4096] x [4096x14336] x [14336x4096] = [17x4096]\n",
    "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)\n",
    "output_after_feedforward.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## 再次进行一下残差操作（终于得到transformer块的最终输出了！）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:31.062182Z",
     "iopub.status.busy": "2025-02-19T04:41:31.061940Z",
     "iopub.status.idle": "2025-02-19T04:41:31.154030Z",
     "shell.execute_reply": "2025-02-19T04:41:31.069802Z",
     "shell.execute_reply.started": "2025-02-19T04:41:31.062165Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 4096])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将前馈层的输出与原始输入相加，完成残差操作\n",
    "# 这就是一个transformer块的最终结果了\n",
    "layer_0_embedding = embedding_after_edit+output_after_feedforward  # [17x4096] + [17x4096] = [17x4096]\n",
    "layer_0_embedding.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "<span style=\"font-size: 1.5em; font-weight: normal;\">\n",
    "我们终于有了每个token在经过第一层之后的新的嵌入向量\n",
    "</span>\n",
    "<br><br>\n",
    "距离完成只剩31层了（只差一个for循环）\n",
    "<br>\n",
    "你可以设想，这个经过处理后的嵌入向量包含了在第一层中所提出的所有token的信息\n",
    "<br>\n",
    "现在，每一层都会对所提出的问题中的更复杂query进行编码，一直到最后，我们会得到一个嵌入向量，它知道我们所需的下一个token的所有信息"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# 一切都在这了，让我们完成全部的32层transformer块的计算，阅读愉快 :)\n",
    "<div>\n",
    "    <img src=\"images/god.png\" width=\"600px\"/>\n",
    "</div>\n",
    "\n",
    "是的，就是这样。所有我们之前所做的，都将一次性在这里全部呈现，以完成每一层的计算。\n",
    "<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "ExecutionIndicator": {
     "show": false
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:41:31.155156Z",
     "iopub.status.busy": "2025-02-19T04:41:31.154732Z",
     "iopub.status.idle": "2025-02-19T04:42:00.355737Z",
     "shell.execute_reply": "2025-02-19T04:42:00.355074Z",
     "shell.execute_reply.started": "2025-02-19T04:41:31.155136Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# 现在开始完成全部的32层transformer块的计算！\n",
    "\n",
    "# 输入token的嵌入向量作为初始值\n",
    "final_embedding = token_embeddings_unnormalized  # [17x4096]\n",
    "\n",
    "# 32层transformer块逐层计算\n",
    "for layer in range(n_layers):\n",
    "    #########################################################################################################################\n",
    "    ###################################### 第一轮 归一化-特征变换-残差 ######################################################\n",
    "    \n",
    "    ########################### 第一次归一化 ###################################################\n",
    "    \n",
    "    # 第一次归一化\n",
    "    layer_embedding_norm = rms_norm(final_embedding, model[f\"layers.{layer}.attention_norm.weight\"])  # [17x4096] & [4096] -> [17x4096]\n",
    "    \n",
    "    ########################### 第一次特征变换-多头自注意力 #####################################\n",
    "    \n",
    "    # 获取当前层注意力机制的qkv权重矩阵\n",
    "    q_layer = model[f\"layers.{layer}.attention.wq.weight\"]  # [4096x4096]\n",
    "    q_layer = q_layer.view(n_heads, q_layer.shape[0] // n_heads, dim)  # [32x128x4096]\n",
    "    k_layer = model[f\"layers.{layer}.attention.wk.weight\"]  # [1024x4096]\n",
    "    k_layer = k_layer.view(n_kv_heads, k_layer.shape[0] // n_kv_heads, dim)  # [8x128x4096]\n",
    "    v_layer = model[f\"layers.{layer}.attention.wv.weight\"]  # [1024x4096]\n",
    "    v_layer = v_layer.view(n_kv_heads, v_layer.shape[0] // n_kv_heads, dim)  # [8x128x4096]\n",
    "    \n",
    "    # 用于存储每个头的注意力机制计算结果\n",
    "    qkv_attention_store = []\n",
    "    \n",
    "    # 计算每个头的注意力机制结果\n",
    "    for head in range(n_heads):\n",
    "        # 取出当前头的qkv权重矩阵\n",
    "        q_layer_head = q_layer[head]  # [32x128x4096] -> [128x4096]\n",
    "        k_layer_head = k_layer[head//(n_heads // n_kv_heads)]  # 每4个头共享一个key权重，[8x128x4096] -> [128x4096]\n",
    "        v_layer_head = v_layer[head//(n_heads // n_kv_heads)]  # 每4个头共享一个value权重，[8x128x4096] -> [128x4096]\n",
    "        \n",
    "        # 计算XW，得到输入token的qkv向量\n",
    "        # [17x4096] x [4096x128] = [17x128]\n",
    "        q_per_token = torch.matmul(layer_embedding_norm, q_layer_head.T)\n",
    "        k_per_token = torch.matmul(layer_embedding_norm, k_layer_head.T)\n",
    "        v_per_token = torch.matmul(layer_embedding_norm, v_layer_head.T)\n",
    "        \n",
    "        # 给query向量加入位置信息（RoPE）\n",
    "        q_per_token_split_into_pairs = q_per_token.float().view(q_per_token.shape[0], -1, 2)  # 维度方向进行两两分组，组成维度对，[17x128] -> [17x64x2]\n",
    "        q_per_token_as_complex_numbers = torch.view_as_complex(q_per_token_split_into_pairs)  # 转换为复数表示，(x,y) -> (x+yi)，[17x64x2] -> [17x64]\n",
    "        q_per_token_as_complex_numbers_rotated = q_per_token_as_complex_numbers * freqs_cis  # 计算(x+yi)*(cosmθ+sinmθi)，完成旋转操作，[17x64] * [17x64] = [17x64]\n",
    "        q_per_token_split_into_pairs_rotated = torch.view_as_real(q_per_token_as_complex_numbers_rotated)  # 结果还原回实数表示，(x+yi) -> (x,y)，[17x64] -> [17x64x2]\n",
    "        q_per_token_rotated = q_per_token_split_into_pairs_rotated.view(q_per_token.shape)  # 结果还原回原始向量形状，得到最终的query向量，[17x64x2] -> [17x128]\n",
    "        \n",
    "        # 给key向量加入位置信息（RoPE）\n",
    "        k_per_token_split_into_pairs = k_per_token.float().view(k_per_token.shape[0], -1, 2)  # 维度方向进行两两分组，组成维度对，[17x128] -> [17x64x2]\n",
    "        k_per_token_as_complex_numbers = torch.view_as_complex(k_per_token_split_into_pairs)  # 转换为复数表示，(x,y) -> (x+yi)，[17x64x2] -> [17x64]\n",
    "        k_per_token_as_complex_numbers_rotated = k_per_token_as_complex_numbers * freqs_cis  # 计算(x+yi)*(cosmθ+sinmθi)，完成旋转操作，[17x64] * [17x64] = [17x64]\n",
    "        k_per_token_split_into_pairs_rotated = torch.view_as_real(k_per_token_as_complex_numbers_rotated)  # 结果还原回实数表示，(x+yi) -> (x,y)，[17x64] -> [17x64x2]\n",
    "        k_per_token_rotated = k_per_token_split_into_pairs_rotated.view(k_per_token.shape)  # 结果还原回原始向量形状，得到最终的key向量，[17x64x2] -> [17x128]\n",
    "        \n",
    "        # 计算注意力分数，同时归一化分数（即QxK/sqrt(dim)）\n",
    "        qk_per_token = torch.matmul(q_per_token_rotated, k_per_token_rotated.T)/(head_dim)**0.5  # [17x128] x [128x17] = [17x17]\n",
    "        \n",
    "        # 屏蔽未来token的分数\n",
    "        mask = torch.full(qk_per_token.shape, float(\"-inf\"), device=qk_per_token.device)  # 创建和注意力分数相同形状，值全为负无穷的矩阵，并保证存储位置和其他向量一致，防止后续计算时错误，[17x17]\n",
    "        mask = torch.triu(mask, diagonal=1)  # 保留上三角部分的负无穷，将下三角设为0（即上三角区域为未来token需要屏蔽，下三角为当前及以前的token无需屏蔽），对角线偏移量为1，避免屏蔽自身token，[17x17]\n",
    "        qk_per_token_after_masking = qk_per_token + mask  # 注意力分数与屏蔽矩阵相加，使分数矩阵的上三角变为负无穷，后续softmax后将趋于0，[17x17]\n",
    "        \n",
    "        # 计算注意力权重（即softmax(score)）\n",
    "        # 同时变换回半精度（因为后续要和value向量v_per_token相乘，需要保证数据类型相同）\n",
    "        qk_per_token_after_masking_after_softmax = torch.nn.functional.softmax(qk_per_token_after_masking, dim=1).to(torch.bfloat16)  # 按行计算softmax，[17x17]\n",
    "        \n",
    "        # 计算注意力机制的最终结果（即softmax(score)xV）\n",
    "        qkv_attention = torch.matmul(qk_per_token_after_masking_after_softmax, v_per_token)  # [17x17] x [17x128] = [17x128]\n",
    "        \n",
    "        # 记录该头结果\n",
    "        qkv_attention_store.append(qkv_attention)\n",
    "    \n",
    "    # 合并多头注意力结果\n",
    "    stacked_qkv_attention = torch.cat(qkv_attention_store, dim=-1)  # 将第二维合并，即32个[17x128] -> [17x4096]\n",
    "    \n",
    "    # 结果做线性映射，生成最终的多头自注意力机制结果\n",
    "    o_layer = model[f\"layers.{layer}.attention.wo.weight\"]\n",
    "    embedding_delta = torch.matmul(stacked_qkv_attention, o_layer.T)  # [17x4096] x [4096x4096] = [17x4096]\n",
    "    \n",
    "    ########################### 第一次残差连接 ################################################\n",
    "    \n",
    "    # 第一次残差\n",
    "    # 将attention层的输出与原始输入相加，完成残差操作\n",
    "    embedding_after_edit = final_embedding + embedding_delta  # [17x4096] + [17x4096] = [17x4096]\n",
    "    \n",
    "    \n",
    "    #########################################################################################################################\n",
    "    ###################################### 第二轮 归一化-特征变换-残差 ######################################################\n",
    "    \n",
    "    ########################### 第二次归一化 ###################################################\n",
    "    \n",
    "    # 第二次归一化\n",
    "    embedding_after_edit_normalized = rms_norm(embedding_after_edit, model[f\"layers.{layer}.ffn_norm.weight\"])  # [17x4096] & [4096] -> [17x4096]\n",
    "    \n",
    "    ########################### 第二次特征变换-前馈神经网络 #####################################\n",
    "    \n",
    "    # 加载前馈网络（SwiGLU）参数矩阵\n",
    "    w1 = model[f\"layers.{layer}.feed_forward.w1.weight\"]  # [14336x4096]\n",
    "    w3 = model[f\"layers.{layer}.feed_forward.w3.weight\"]  # [14336x4096]\n",
    "    w2 = model[f\"layers.{layer}.feed_forward.w2.weight\"]  # [4096x14336]\n",
    "    \n",
    "    # 计算前馈网络结果（output = (silu(XW1) * XW3)W2）\n",
    "    # [17x4096] x [4096x14336] x [14336x4096] = [17x4096]\n",
    "    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)\n",
    "    \n",
    "    ########################### 第二次残差连接 ##################################################\n",
    "    \n",
    "    # 第二次残差，得到当前transformer块的最终输出结果\n",
    "    # 将前馈层的输出与原始输入相加，完成残差操作\n",
    "    final_embedding = embedding_after_edit+output_after_feedforward  # [17x4096] + [17x4096] = [17x4096]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# 让我们完成最后一步，预测下一个token\n",
    "\n",
    "现在我们得到了最终的嵌入向量，这个嵌入向量中包含了预测下一个token所需的全部信息\n",
    "<br>\n",
    "这个嵌入向量的形状和输入时的token嵌入向量形状相同，均为[17x4096]，其中17为token的数量，4096是嵌入向量的维度\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/last_norm.png\" width=\"600px\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 首先对最后一层transformer的输出进行最后一次的归一化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:42:00.356811Z",
     "iopub.status.busy": "2025-02-19T04:42:00.356549Z",
     "iopub.status.idle": "2025-02-19T04:42:00.562948Z",
     "shell.execute_reply": "2025-02-19T04:42:00.562268Z",
     "shell.execute_reply.started": "2025-02-19T04:42:00.356793Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 4096])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 进行整个模型中最后一次的归一化\n",
    "final_embedding = rms_norm(final_embedding, model[\"norm.weight\"])  # [17x4096] & [4096] -> [17x4096]\n",
    "final_embedding.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## 然后基于最后一个token对应的嵌入向量进行预测（线性映射到词典维度）\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/finallayer.png\" width=\"600px\"/>\n",
    "</div>\n",
    "\n",
    "<br>\n",
    "我们将使用输出解码器（一个线性映射层）来将最后一个token的嵌入向量转换成对下一个token的预测结果（词典维度大小，如果将结果再进行一下softmax，则每一维的值即代表下一个token属于该词的概率）\n",
    "<br><br>\n",
    "\n",
    "为什么只选取最后一个token对应的输出向量来进行下一个token的预测？\n",
    "<br>\n",
    "因为模型在训练时的目标为基于当前token及以前的信息，预测下一个token，因此，每一个token对应的输出向量都是在预测相对于它自己的下一个token，而非整个输入的下一个token\n",
    "<br><br>\n",
    "\n",
    "希望在我们的例子中是42 :)\n",
    "<br>\n",
    "注：42是“the answer to the ultimate question of life, the universe, and everything is ”（“关于生命，宇宙和一切事情的终极答案是：”）的答案，根据“银河系漫游指南”这本书，大多数的现代大模型都会回答42，这将验证我们的整个代码的正确性！祝我们好运 :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:42:00.563949Z",
     "iopub.status.busy": "2025-02-19T04:42:00.563644Z",
     "iopub.status.idle": "2025-02-19T04:42:00.660523Z",
     "shell.execute_reply": "2025-02-19T04:42:00.659998Z",
     "shell.execute_reply.started": "2025-02-19T04:42:00.563923Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([128256])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 最后一次的线性映射，将嵌入向量映射成词典维度大小，以作为对下一个token的预测\n",
    "logits = torch.matmul(final_embedding[-1], model[\"output.weight\"].T)  # [17x4096] -> [4096] -> [4096] x [4096x128256] = [128256]\n",
    "logits.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 预测结果来咯"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "ExecutionIndicator": {
     "show": false
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:42:00.662517Z",
     "iopub.status.busy": "2025-02-19T04:42:00.662175Z",
     "iopub.status.idle": "2025-02-19T04:42:00.666211Z",
     "shell.execute_reply": "2025-02-19T04:42:00.665812Z",
     "shell.execute_reply.started": "2025-02-19T04:42:00.662489Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(2983)"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 取出概率最大的那一维对应的id，即预测的下一个token的id\n",
    "next_token = torch.argmax(logits, dim=-1)  # 获取最大值对应的下标，即预测的下一个token id，[128256] -> [1]\n",
    "next_token"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:42:00.666984Z",
     "iopub.status.busy": "2025-02-19T04:42:00.666678Z",
     "iopub.status.idle": "2025-02-19T04:42:00.669702Z",
     "shell.execute_reply": "2025-02-19T04:42:00.669311Z",
     "shell.execute_reply.started": "2025-02-19T04:42:00.666969Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'42'"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 基于预测的id，还原回具体预测的值\n",
    "tokenizer.decode([next_token.item()])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "<div>\n",
    "    <img src=\"images/42.png\" width=\"600px\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 让我们扩展一下，看看使用不同的嵌入或未来token屏蔽策略会对预测结果产生什么影响 :)\n",
    "\n",
    "现在我们已经得到了最终的预测结果，如果你还感兴趣的话，和我一起再了解一些之前可能提到了的问题吧~\n",
    "<br>\n",
    "\n",
    "我们会简单探究一下三种情况：\n",
    "1. 当前预测结果除了top-1，还预测了些什么，即top-k的结果\n",
    "2. 如果使用其它token的嵌入向量来做预测，能够预测到什么\n",
    "3. 如果在当初的attention计算时，没有屏蔽未来token，那么预测结果会有什么样的不同"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:42:00.670342Z",
     "iopub.status.busy": "2025-02-19T04:42:00.670135Z",
     "iopub.status.idle": "2025-02-19T04:42:00.765641Z",
     "shell.execute_reply": "2025-02-19T04:42:00.765239Z",
     "shell.execute_reply.started": "2025-02-19T04:42:00.670316Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['42', '6', '43', '41', '4', '1', '45', '3', '2', '46']"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 让我们先看一下top-k的预测结果\n",
    "logits_sort, logits_idx = torch.sort(logits, dim=-1, descending=True)  # 对预测结果做排序，使最大可能性的预测token放前面，[128256]\n",
    "[tokenizer.decode([i]) for i in logits_idx[:10]]  # 查看前10大概率的结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:42:00.766308Z",
     "iopub.status.busy": "2025-02-19T04:42:00.766116Z",
     "iopub.status.idle": "2025-02-19T04:42:01.465262Z",
     "shell.execute_reply": "2025-02-19T04:42:01.464156Z",
     "shell.execute_reply.started": "2025-02-19T04:42:00.766294Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "输入的token： ['<|begin_of_text|>', 'the', ' answer', ' to', ' the', ' ultimate', ' question', ' of', ' life', ',', ' the', ' universe', ',', ' and', ' everything', ' is', ' ']\n",
      "基于第1个token的嵌入向量的预测结果： ['Question', 'def', '#', 'The', 'import', 'Tags', 'A', 'package', 'Home', 'I']\n",
      "基于第2个token的嵌入向量的预测结果： [' ', ' best', ' first', ' most', ' new', ' world', ' last', ' same', ' way', ' number']\n",
      "基于第3个token的嵌入向量的预测结果： [' to', ' is', ' was', ' of', ' lies', ',', ' for', ' you', ' key', ' will']\n",
      "基于第4个token的嵌入向量的预测结果： [' the', ' this', ' your', ' all', ' that', ' a', ' my', ' life', ' \"', ' everything']\n",
      "基于第5个token的嵌入向量的预测结果： [' question', ' problem', ' above', ' ultimate', ' first', ' r', ' following', ' questions', ' most', ' previous']\n",
      "基于第6个token的嵌入向量的预测结果： [' question', ' questions', ' mystery', '\\xa0', ' quest', '\\n', ' life', ' philosophical', ' qu', ' problem']\n",
      "基于第7个token的嵌入向量的预测结果： [' of', '\\n', ' to', ' is', '?\\n', ',', '.\\n', ':', '...\\n', ' about']\n",
      "基于第8个token的嵌入向量的预测结果： [' life', ' Life', ' the', '\\xa0', ' everything', ' existence', '\\n', ' LIFE', ' all', ' human']\n",
      "基于第9个token的嵌入向量的预测结果： [',', ' the', '\\n', ' and', ' is', ',\\n', '.\\n', '?\\n', '...\\n', '...']\n",
      "基于第10个token的嵌入向量的预测结果： [' the', ' universe', ' and', ' etc', '\\xa0', ' is', ' death', ' of', ' or', ' everything']\n",
      "基于第11个token的嵌入向量的预测结果： [' universe', ' Universe', '\\n', '\\xa0', ' un', ' univers', ' uni', ' cosmos', ' universal', ' u']\n",
      "基于第12个token的嵌入向量的预测结果： [',', ' and', ' &', '\\n', ',\\n', ' ,', '...\\n', ',and', '...', '\\xa0']\n",
      "基于第13个token的嵌入向量的预测结果： [' and', ' everything', ' &', ' the', ' etc', '\\xa0', ' is', ' or', ' ...\\n', ' an']\n",
      "基于第14个token的嵌入向量的预测结果： [' everything', '\\xa0', ' the', ' every', '\\n', ' ever', ' all', ' Everything', ' EVERY', '...']\n",
      "基于第15个token的嵌入向量的预测结果： ['\\n', ' is', '.\\n', '.', '?\\n', ',', ' (', '\\n\\n', '...\\n', ' in']\n",
      "基于第16个token的嵌入向量的预测结果： [' ', '\\n', '...', '...\\n', ':', ' forty', ' not', ' \"', '…', ' a']\n",
      "基于第17个token的嵌入向量的预测结果： ['42', '6', '43', '41', '4', '1', '45', '3', '2', '46']\n"
     ]
    }
   ],
   "source": [
    "# 让我们再试一下用其他token的嵌入向量做预测能得到什么\n",
    "logits_all_token = torch.matmul(final_embedding, model[\"output.weight\"].T)  # 将嵌入向量映射成词典大小的维度，[17x4096] x [4096x128256] = [17x128256]\n",
    "logits_all_token_sort, logits_all_token_idx = torch.sort(logits_all_token, dim=-1, descending=True)  # 对预测结果做排序，使最大可能性的预测token放前面，[17x128256]\n",
    "\n",
    "print('输入的token：', prompt_split_as_tokens)  # 展示输入的token，[17]\n",
    "\n",
    "# 展示基于每个token的嵌入向量所做的下一个token预测的结果\n",
    "for i in range(len(final_embedding)):\n",
    "    print(f'基于第{i+1}个token的嵌入向量的预测结果：', [tokenizer.decode([j]) for j in logits_all_token_idx[i][:10]])  # 输出前10大概率的结果\n",
    "    \n",
    "_=\"\"\"\n",
    "可以看到的是，基于每个token进行预测时，其预测结果为当前token后的下一个token的可能结果，而不是整个完整输入的预测结果，因此在实际预测时，会只使用最后一个token的嵌入向量来做预测\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-02-19T04:42:01.466321Z",
     "iopub.status.busy": "2025-02-19T04:42:01.466092Z",
     "iopub.status.idle": "2025-02-19T04:42:01.469756Z",
     "shell.execute_reply": "2025-02-19T04:42:01.469347Z",
     "shell.execute_reply.started": "2025-02-19T04:42:01.466304Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# 最后，我们看一下如果在计算attention时不屏蔽未来token，预测结果会变成什么\n",
    "# 此时基于每个token的预测结果将变为如下所示\n",
    "# 可以看到，由于未来token的可见性，基于每个token的嵌入向量都将更准确的预测出“对于它来说的”下一个token（有一点点“作弊”了）\n",
    "\n",
    "_=\"\"\"\n",
    "输入的token： ['<|begin_of_text|>', 'the', ' answer', ' to', ' the', ' ultimate', ' question', ' of', ' life', ',', ' the', ' universe', ',', ' and', ' everything', ' is', ' ']\n",
    "基于第1个token的嵌入向量的预测结果： ['://', '.Forms', '_REF', ' Angeles', '.swing', '�', 'php', 'во', 'ysics', '�']\n",
    "基于第2个token的嵌入向量的预测结果： [' answer', ' Hitch', ' universe', ' question', ' ultimate', ' meaning', ' hitch', ' Universe', ' Answer', ' reason']\n",
    "基于第3个token的嵌入向量的预测结果： [' to', ' is', ',', ':', ' was', '\\n', ' ', ' (', '\\n\\n', ' of']\n",
    "基于第4个token的嵌入向量的预测结果： [' the', ' life', ' this', ' which', ' everything', ' that', ' how', ' why', ' ', ' all']\n",
    "基于第5个token的嵌入向量的预测结果： [' ultimate', ' question', ' great', ' meaning', ' universe', ' Ultimate', ' everything', ' life', ' holy', ' greatest']\n",
    "基于第6个token的嵌入向量的预测结果： [' question', ' answer', ' is', ' was', '\\n', ' questions', ' mystery', '\\n\\n', ' what', ' Question']\n",
    "基于第7个token的嵌入向量的预测结果： [' of', ' is', '\\n', ',', ' about', ':', ' to', ' in', ' (', '<|end_of_text|>']\n",
    "基于第8个token的嵌入向量的预测结果： [' life', ' existence', ' everything', ' Life', ' the', ' death', ' time', ' all', ' why', ' which']\n",
    "基于第9个token的嵌入向量的预测结果： [',', ' is', ' the', '\\n', ':', ' (', '...', ' and', ' ,', ' -']\n",
    "基于第10个token的嵌入向量的预测结果： [' the', ' and', ' is', ' death', ' The', ' which', ' or', '\\xa0', ' existence', ' don']\n",
    "基于第11个token的嵌入向量的预测结果： [' universe', ' answer', ' cosmos', ' world', ' existence', ' Universe', ' everything', ' un', ' meaning', ' question']\n",
    "基于第12个token的嵌入向量的预测结果： [',', ' and', ' is', ' &', '\\n', ' ,', '.', '...', ' (', ' ']\n",
    "基于第13个token的嵌入向量的预测结果： [' and', ' &', ' don', ' the', ' is', ' a', ' or', ' Douglas', '\\xa0', '<|end_of_text|>']\n",
    "基于第14个token的嵌入向量的预测结果： [' everything', ' dough', ' don', ' ever', ' deep', ' Douglas', ' the', ' every', ' all', ' death']\n",
    "基于第15个token的嵌入向量的预测结果： ['\\n', ' is', ',', '.', ' ', ' (', ':', '<|end_of_text|>', '\\n\\n', '.\\n']\n",
    "基于第16个token的嵌入向量的预测结果： [' ', '\\n', ' forty', '...', ' \"', '42', ' the', ':', '\\xa0', ' to']\n",
    "基于第17个token的嵌入向量的预测结果： ['42', '6', '4', '41', '1', '2', '3', '7', '5', '43']\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 需要预测多个token？使用KV-Cache吧（梳理清楚这个真的花费了我好大的精力 Orz）\n",
    "\n",
    "\n",
    "<span style=\"font-size: 1.5em; font-weight: bold;\">如何连续预测多个token</span>\n",
    "\n",
    "现在，我们完成了针对输入文本的下一个词的预测，但是，如果我们预期的输出需要多个token呢？\n",
    "<br>\n",
    "比如在实际的大模型应用中，大模型通常不会只输出一个词，而通常是一段文本，甚至是非常长的文本输出，这一能力是如何实现的呢？\n",
    "<br>\n",
    "其实很简单，只需要反复调用大模型的预测过程，就可以逐步生成完整的句子或段落。\n",
    "<br>\n",
    "这个过程就像“滚雪球”，每次预测一个词，就将这个词加入到当前的输入序列中，然后重新调用大模型进行新一轮的预测，直到遇到停止符（在llama3中是一个特殊token “<|end_of_text|>”），或达到最大长度限制（一个超参数 max_seq_len）后，停止预测。\n",
    "<br><br>\n",
    "这样听起来效率好低？是的！\n",
    "<br>\n",
    "因此就有了比如KV-Cache这一耳熟能详的缓存机制，通过缓存历史token的KV向量，来减少输入及计算量，从而提升推理效率。\n",
    "<br>\n",
    "得益于缓存机制，当我们使用大模型进行推理时，你可能会发现往往在等待第一个token输出时是最漫长的，而一旦输出了第一个token，后续token的输出速度将大大提高。\n",
    "<br><br>\n",
    "\n",
    "<span style=\"font-size: 1.5em; font-weight: bold;\">KV-Cache的优劣势</span>\n",
    "\n",
    "**优势**：持续预测时，每次只需要输入新的token即可，无需将完整的文本序列全部输入进来，从而极大提升推理时计算速度\n",
    "<br>\n",
    "**劣势**：由于缓存机制的存在，在推理时会额外占用较多的内存资源\n",
    "<br><br>\n",
    "\n",
    "<span style=\"font-size: 1.5em; font-weight: bold;\">KV-Cache的原理推导</span>\n",
    "\n",
    "KV-Cache来自于对上述矩阵计算过程的观察和分析，通过分析每个输入token在其中的计算过程，我们可以发现在大多数的计算步骤中，每个token的计算其实都是相对独立的，很少涉及到与其他token的交互，而只有计算注意力机制时会涉及到token间的交互，因此会需要历史KV向量的缓存。\n",
    "<br>\n",
    "\n",
    "<span style=\"font-size: 1.2em; font-weight: bold;\">以下是KV-Cache的具体推导逻辑：</span>\n",
    "1. **前提**：预测下一词只需要得到最后一个token的输出结果（正如我们在预测章节所做的一样）\n",
    "2. **非注意力部分只需计算新token**：除了注意力计算以外，所有部分的计算都是token间相互独立的，因此只需要计算新token即可，可以不用输入历史token（我将在下面进行展开分析）\n",
    "3. **注意力部分也只需计算新token**：注意力层中，由于屏蔽机制的存在，历史token的输出结果不会受未来新token的影响，因此其在每一层的输入和输出都是固定不变的，即历史token的QKV向量都不会因为加入新token而改变，从而只需要计算新token的注意力即可\n",
    "4. **新token注意力机制计算**：注意力层用来让token获取历史token的上下文信息，所以需要为每个新token都使用全部token的value向量进行加权和，因此需要存储历史token的value\n",
    "5. **新token注意力权重计算**：由第4条可知，我们还需要先获取新token与历史token间的重要性信息，即权重，所以需要计算新token与所有token的key向量乘积，因此需要存储历史token的key\n",
    "6. **KV-Cache的获取**：由第4,5条可知，我们需要存储历史token的KV向量，而query向量因为没有用到，所以不用存储，这就是KV-Cache的由来\n",
    "7. **KV-Cache的高效性**：由第3条可知，历史KV向量是不会变化的，因此可以在持续预测过程中不断的增量更新，而无需修改历史内容。这样，每次预测时只需要输入并计算新增token的结果，而无需将完整序列作为输入，从而大幅提升推理效率\n",
    "<br><br>\n",
    "\n",
    "<span style=\"font-size: 1.2em; font-weight: bold;\">注：KV-Cache中token计算的独立性分析</span>\n",
    "\n",
    "**除注意力层以外的所有组件（均无交互）**：\n",
    "1. **两次归一化(normalization)**：每个token向量都是在自己的特征维度上进行归一化计算，不会用到其它token\n",
    "2. **两次残差连接(add)**：每个token向量都是将自己的输出结果与自己相加，也不会用到其它token\n",
    "3. **前馈网络(FFN)**：每个token向量分别乘以相同的权重矩阵W1，W2，W3得到结果，其间也不会用到其它token。可以设想，假如输入token数为17，则FFN的计算可以简化为：[17x4096] x [4096x14336] x [14336x4096] = [17x4096]，这其实等价于每次输入一个token，然后将17个结果拼接成一个矩阵，即：17次([1x4096] x [4096x14336] x [14336x4096] = [1x4096]) = 17x[1x4096] => [17x4096]。因此，每个token在前馈层中计算时，其实和其他token也没有交互\n",
    "\n",
    "**注意力层（新token与历史token只有单向交互）**：\n",
    "1. **计算QKV向量**：每个token向量乘以相同的QKV权重矩阵得到结果，不会用到其它token\n",
    "2. **QK向量添加位置信息**：每个token向量以自身位置为基础进行独立的旋转操作，不会用到其它token的具体内容\n",
    "3. **计算注意力权重**：注意力权重代表每个token与它之前的每个历史token的相关性，而与未来token无关，因此历史token结果独立于新token。而新token需要历史token的key向量缓存\n",
    "4. **计算注意力机制结果**：注意力机制基于注意力权重进行value向量的加权和，因此和上一条的结论一样，历史token结果独立于新token。而新token需要历史token的value向量缓存\n",
    "<br><br>\n",
    "\n",
    "<span style=\"font-size: 1.5em; font-weight: bold;\">基于KV-Cache的注意力计算过程</span>\n",
    "\n",
    "为了清晰展示计算过程，仅推导单头场景（推广至多头场景的原理和过程与之前的多头注意力实现是完全一致的）：\n",
    "1. 假设历史输入token为$S_1$，长度为N，则基于KV-Cache，将存储每个头的KV结果矩阵，单个头的形状为 [Nxhead_dim] = [Nx128]\n",
    "2. 假设新增输入token为$S_2$，长度为M（可以是新预测的token，也可以是用户新一轮对话的输入等各种场景）\n",
    "3. 计算新token的QKV向量：$Q,K,V = S_2W_{Q,K,V}$ => [Mx4096] x [4096x128] = [Mx128]\n",
    "4. 给QK向量加入位置信息：新token的位置要从N+1开始算起，不能从0计算，[Mx128] -> [Mx128]\n",
    "5. 将新的KV值加入到KV缓存中，得到更新后的KV矩阵，即 [Nx128] -> [(N + M)x128]\n",
    "6. 计算新token的注意力权重：Attention_weight = softmax(QK/sqrt(d) + mask) => [Mx128] x [128x(N + M)] = [Mx(N + M)]\n",
    "7. 计算新token的注意力机制最终结果：Attention_weight x V => [Mx(N + M)] x [(N + M)x128] = [Mx128]\n",
    "8. 将每个头的结果做拼接并线性映射后，得到最终的注意力层输出，形状为 32x[Mx128] -> [Mx4096]\n",
    "<br><br>\n",
    "\n",
    "\n",
    "鉴于我们之前的学习过程已经很完整了，这里便不再进行优化方案的代码实现（感兴趣可以看llama3的官方代码，实现还是比较简单的）。就像之前提到的多头注意力的并行计算一样，知道计算过程是可以优化的就可以了~"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 感谢各位，辛苦你们的一路学习，爱你们 :)\n",
    "\n",
    "我们的学习结束了，希望你们同样享受了这个阅读过程！\n",
    "\n",
    "## From Me\n",
    "\n",
    "如果你看到了这个工作，感谢你的信任和一路学习到这里，很高兴能够帮助到你~\n",
    "\n",
    "如果你想支持我的工作\n",
    "1. 点个star⭐吧~ :) \n",
    "2. 请我一杯咖啡~ [https://ko-fi.com/therealoliver](https://ko-fi.com/therealoliver)\n",
    "\n",
    "<br>\n",
    "\n",
    "## From前身项目作者\n",
    "\n",
    "如果你想支持我的工作：\n",
    "\n",
    "1. 订阅我的twitter https://twitter.com/naklecha \n",
    "2. 或者请我一杯咖啡吧 [https://www.buymeacoffee.com/naklecha](https://www.buymeacoffee.com/naklecha)\n",
    "\n",
    "说真的，你们学习到了这里，就已经让我很开心了 :)\n",
    "\n",
    "是什么在激励我做这件事？\n",
    "\n",
    "是我和我的朋友在执行一项使命 - 让研究变得更加触手可及！\n",
    "我们创建了一个研究实验室，叫做A10 - [AAAAAAAAAA.org](http://aaaaaaaaaa.org/)\n",
    "\n",
    "A10的twitter - https://twitter.com/aaaaaaaaaaorg\n",
    "\n",
    "我们的论点：\n",
    "<div>\n",
    "    <img src=\"images/a10.png\" width=\"600px\"/>\n",
    "</div>\n",
    "<br><br>\n",
    "再次感谢原作者的基础代码和图例，也让我学到了很多"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LICENSE\n",
    "\n",
    "Copyright (c) 2025 Jinlong Zhang (https://github.com/therealoliver)\n",
    "\n",
    "Copyright (c) 2024 Nishant Aklecha\n",
    "\n",
    "MIT"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  },
  "toc-autonumbering": true,
  "toc-showtags": false
 },
 "nbformat": 4,
 "nbformat_minor": 4
}