llama3-from-scratch_zh.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 从零实现 Llama3 模型\n",
    "\n",
    "## 注意\n",
    "\n",
    "1. 本文翻译自大佬的 [llama3-from-scratch](https://github.com/naklecha/llama3-from-scratch) 仓库，本人只是将英文翻译为中文，并无任何改动，略微改动模型权重文件，方便加载。原版英文：[README_en.md](README_en.md)。\n",
    "2. 原版模型已上传至ModelScope，大小约 15G，[Meta-Llama-3-8B-Instruct](https://www.modelscope.cn/models/wdndev/Meta-Llama-3-8B-Instruct-torch/summary)；\n",
    "3. 因原版 Llama3 8B 模型32层 Transformers，且大佬仓库使用CPU加载，如果加载全部的参数，16G内存机器加载失败，故选取原版 Llama3 8B 模型权重的前2层，重新保存，大小约为2.7G，此文档也可以直接加载，**实际测试内存占用约4~5G**，唯一缺点是后续推理结果不对，但不影响学习矩阵变换等其他知识，链接为 [Meta-Llama-3-8B-Instruct-2layers](https://www.modelscope.cn/models/wdndev/Meta-Llama-3-8B-Instruct-2layers/summary).\n",
    "4. 如果对你有用麻烦点一下star，谢谢！\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 从零实现 Llama3 模型\n",
    "\n",
    "在这个文件中，从头实现了 Llama3，其中包含张量和矩阵乘法。\n",
    "\n",
    "此外，直接从 Meta 提供的 Llama3 模型文件中加载张量，在运行此文件之前，需要下载权重。\n",
    "这是官方链接： https://llama.meta.com/llama-downloads/\n",
    "\n",
    "> 原版模型已上传至ModelScope，大小约 15G，[Meta-Llama-3-8B-Instruct](https://www.modelscope.cn/models/wdndev/Meta-Llama-3-8B-Instruct-torch/summary)\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/archi.png\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## tokenizer\n",
    "\n",
    "不会实现一个 BPE 分词器（但 Andrej Karpathy 也有一个非常简洁的实现）\n",
    "\n",
    "这是他的项目地址： https://github.com/karpathy/minbpe\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/karpathyminbpe.png\" width=\"600\"/>\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello world!'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from pathlib import Path\n",
    "import tiktoken\n",
    "from tiktoken.load import load_tiktoken_bpe\n",
    "import torch\n",
    "import json\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "tokenizer_path = \"Meta-Llama-3-8B-Instruct-2layers/tokenizer.model\"\n",
    "special_tokens = [\n",
    "            \"<|begin_of_text|>\",\n",
    "            \"<|end_of_text|>\",\n",
    "            \"<|reserved_special_token_0|>\",\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",
    "mergeable_ranks = load_tiktoken_bpe(tokenizer_path)\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+\",\n",
    "    mergeable_ranks=mergeable_ranks,\n",
    "    special_tokens={token: len(mergeable_ranks) + i for i, token in enumerate(special_tokens)},\n",
    ")\n",
    "\n",
    "tokenizer.decode(tokenizer.encode(\"hello world!\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 读取模型文件\n",
    "\n",
    "通常，读取模型文件,往往取决于模型类的编写方式以及其中的变量名。\n",
    "\n",
    "但由于要从零实现 Llama3，将一次性读取一个张量。\n",
    "\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/model.png\" width=\"600\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "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",
      "    \"norm.weight\"\n",
      "]\n"
     ]
    }
   ],
   "source": [
    "model = torch.load(\"Meta-Llama-3-8B-Instruct-2layers/consolidated_2layers.pth\")\n",
    "print(json.dumps(list(model.keys())[:20], indent=4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'dim': 4096,\n",
       " 'n_layers': 2,\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(\"Meta-Llama-3-8B-Instruct-2layers/params.json\", \"r\") as f:\n",
    "    config = json.load(f)\n",
    "config"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 使用这些配置推理模型的细节\n",
    "\n",
    "1. 模型有 32 个 Transformer 层\n",
    "2. 每个多头注意力块有 32 个头\n",
    "3. 词汇表大小等"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "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": [
    "## 将文本转换为 token\n",
    "\n",
    "这里使用 tiktoken（OpenAI 的库）作为分词器\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/tokens.png\" width=\"600\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "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 = \"the answer to the ultimate question of life, the universe, and everything is \"\n",
    "tokens = [128000] + tokenizer.encode(prompt)\n",
    "print(tokens)\n",
    "tokens = torch.tensor(tokens)\n",
    "prompt_split_as_tokens = [tokenizer.decode([token.item()]) for token in tokens]\n",
    "print(prompt_split_as_tokens)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 将 token 转换为 embedding\n",
    "\n",
    "这里使用内置的神经网络模块\n",
    "\n",
    "无论如何, `[17x1]` token 现在是 `[17x4096]`，即每个 token 的长度为 4096 的 embeddings\n",
    "\n",
    "\n",
    "注意：跟踪 shapes，这样一切将变得理解更容易\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/embeddings.png\" width=\"600\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 4096])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "embedding_layer = torch.nn.Embedding(vocab_size, dim)\n",
    "embedding_layer.weight.data.copy_(model[\"tok_embeddings.weight\"])\n",
    "token_embeddings_unnormalized = embedding_layer(tokens).to(torch.bfloat16)\n",
    "token_embeddings_unnormalized.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 接下来使用 RMS 归一化嵌入\n",
    "\n",
    "请注意，经过此步骤后 shapes 不变， 只是值被归一化\n",
    "\n",
    "需要注意的是，需要一个 norm_eps（来自配置）以避免不小心将 RMS 设置为 0 并导致除以 0 的情况\n",
    "\n",
    "这是公式:\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/rms.png\" width=\"600\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def rms_norm(tensor, norm_weights):\n",
    "#     rms = (tensor.pow(2).mean(-1, keepdim=True) + norm_eps)**0.5\n",
    "#     return tensor * (norm_weights / rms)\n",
    "\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": "markdown",
   "metadata": {},
   "source": [
    "# 构建第一个 Transformer 层\n",
    "\n",
    "\n",
    "### 归一化\n",
    "\n",
    "从模型字典中访问 `layer.0` （这是第一层）\n",
    "\n",
    "\n",
    "归一化后 shapes 仍然是 `[17x4096]`， 与嵌入相同但已归一化\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/norm.png\" width=\"600\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 4096])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "token_embeddings = rms_norm(token_embeddings_unnormalized, model[\"layers.0.attention_norm.weight\"])\n",
    "token_embeddings.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 从头实现注意力机制\n",
    "\n",
    "加载第一个 Transformer 层的注意力头\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/qkv.png\" width=\"600\"/>\n",
    "</div>\n",
    "\n",
    "<br>\n",
    "\n",
    "当我们从模型中加载 `query`， `key`，`value` 和 `output`  向量时，注意到 shapes 分别为 `[4096x4096]`， `[1024x4096]`， `[1024x4096]`， `[4096x4096]`\n",
    "\n",
    "乍一看这有些奇怪，因为在理想情况下我们希望每个头单独拥有各自的 q，k，v 和 o\n",
    "\n",
    "这里作者将其捆绑在一起，为什么会这样呢? 因为这样有助于并行化注意力头的计算\n",
    "\n",
    "将展开所有内容..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "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": [
    "print(\n",
    "    model[\"layers.0.attention.wq.weight\"].shape,\n",
    "    model[\"layers.0.attention.wk.weight\"].shape,\n",
    "    model[\"layers.0.attention.wv.weight\"].shape,\n",
    "    model[\"layers.0.attention.wo.weight\"].shape\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 展开 query\n",
    "\n",
    "在下一节中，将展开多个注意力头的 query，得到的 shapes 为 `[32x128x4096]`\n",
    "\n",
    "\n",
    "这里的 32 是 Llama3 的注意力头数量，128 是 query 向量的大小，4096 是 token 嵌入的大小"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([32, 128, 4096])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q_layer0 = model[\"layers.0.attention.wq.weight\"]\n",
    "head_dim = q_layer0.shape[0] // n_heads\n",
    "q_layer0 = q_layer0.view(n_heads, head_dim, dim)\n",
    "q_layer0.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 实现第一层的第一个头\n",
    "\n",
    "这里查询了第一个层的第一个头的 `query` 权重矩阵，其大小为 `[128x4096]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([128, 4096])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q_layer0_head0 = q_layer0[0]\n",
    "q_layer0_head0.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 现在将 query 权重与 token 嵌入相乘，以获得每个 token 的 query\n",
    "\n",
    "这里可以看到得到的 shape 是 `[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": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 128])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q_per_token = torch.matmul(token_embeddings, q_layer0_head0.T)\n",
    "q_per_token.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 位置编码\n",
    "\n",
    "当前，每个 token 都有一个 query 向量，但如果你想一想 -- 其实各个 query 向量并不知道它们在 prompt 中的位置。\n",
    "\n",
    "```text\n",
    "query: \"the answer to the ultimate question of life, the universe, and everything is \"\n",
    "```\n",
    "\n",
    "在我示例 prompt 中，使用了三次 `\"the\"`，需要根据它们在 prompt 中的位置为每个 `\"the\"` token 生成不同的 `query` 向量（每个长度为128）。可以使用 RoPE（旋转位置编码）来实现这一点。\n",
    "\n",
    "### RoPE\n",
    "来看看这个视频(我就是看的这个)可以理解其中的数据学逻辑。\n",
    "https://www.youtube.com/watch?v=o29P0Kpobz0&t=530s\n",
    "\n",
    "> 等我传到B站，再更新链接\n",
    "\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/rope.png\" width=\"600\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 64, 2])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "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": [
    "这里为 prompt 中每个位置生成了旋转位置编码。可以看到，这些编码是正弦和余弦函数的组合。\n",
    "\n",
    "在上的步骤里, 将 `query` 向量分成对, 并对每对应用旋转角度移位!\n",
    "\n",
    "\n",
    "现在有一个大小为 `[17x64x2]` 的向量，这是针对 prompt 中的每个 token 将 128 个长度的 query 分为 64 对！ 这 64 对中的每一对都将旋转 `m*(theta)`，其中 `m` 是旋转查询的 token 的位置！\n",
    "\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/qsplit.png\" width=\"600\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 使用复数点积计算旋转向量\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/freq_cis.png\" width=\"600\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "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": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zero_to_one_split_into_64_parts = torch.tensor(range(64))/64\n",
    "zero_to_one_split_into_64_parts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "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": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "freqs = 1.0 / (rope_theta ** zero_to_one_split_into_64_parts)\n",
    "freqs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "freqs_for_each_token = torch.outer(torch.arange(17), freqs)\n",
    "freqs_cis = torch.polar(torch.ones_like(freqs_for_each_token), freqs_for_each_token)\n",
    "freqs_cis.shape\n",
    "\n",
    "# viewing tjhe third row of freqs_cis\n",
    "value = freqs_cis[3]\n",
    "plt.figure()\n",
    "for i, element in enumerate(value[:17]):\n",
    "    plt.plot([0, element.real], [0, element.imag], color='blue', linewidth=1, label=f\"Index: {i}\")\n",
    "    plt.annotate(f\"{i}\", xy=(element.real, element.imag), color='red')\n",
    "plt.xlabel('Real')\n",
    "plt.ylabel('Imaginary')\n",
    "plt.title('Plot of one row of freqs_cis')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 现在每个 token 的 query 元素都有一个复数（角度变化向量）\n",
    "\n",
    "可以将 query（将其拆分成对）转换为复数，然后进行点积以根据位置旋转查询"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 64])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q_per_token_as_complex_numbers = torch.view_as_complex(q_per_token_split_into_pairs)\n",
    "q_per_token_as_complex_numbers.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 64])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q_per_token_as_complex_numbers_rotated = q_per_token_as_complex_numbers * freqs_cis\n",
    "q_per_token_as_complex_numbers_rotated.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 得到旋转向量后\n",
    "\n",
    "可以通过再次将复数看作实数来返回成对的 query"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 64, 2])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q_per_token_split_into_pairs_rotated = torch.view_as_real(q_per_token_as_complex_numbers_rotated)\n",
    "q_per_token_split_into_pairs_rotated.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "旋转对现在已合并，现在有了一个新的 query 向量（旋转 query 向量），其 shape 为 `[17x128]`，其中 17 是 token 的数量，128 是 query 向量的维度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 128])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q_per_token_rotated = q_per_token_split_into_pairs_rotated.view(q_per_token.shape)\n",
    "q_per_token_rotated.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# keys（几乎与 query 一模一样）\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/keys.png\" width=\"600px\"/>\n",
    "</div>\n",
    "\n",
    "我是个懒鬼，所以不打算详细讲 keys 的数学过程，只需要记住以下几点：\n",
    "\n",
    "- keys 生成的 key 向量的维度也是 128\n",
    "- **keys 的权重只有 query 的 1/4，因为 keys 的权重在 4 个头之间共享，以减少计算量**\n",
    "- keys 也像 query 一样被旋转以添加位置信息，其原因相同"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([8, 128, 4096])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k_layer0 = model[\"layers.0.attention.wk.weight\"]\n",
    "k_layer0 = k_layer0.view(n_kv_heads, k_layer0.shape[0] // n_kv_heads, dim)\n",
    "k_layer0.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([128, 4096])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k_layer0_head0 = k_layer0[0]\n",
    "k_layer0_head0.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 128])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k_per_token = torch.matmul(token_embeddings, k_layer0_head0.T)\n",
    "k_per_token.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 64, 2])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k_per_token_split_into_pairs = k_per_token.float().view(k_per_token.shape[0], -1, 2)\n",
    "k_per_token_split_into_pairs.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 64])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k_per_token_as_complex_numbers = torch.view_as_complex(k_per_token_split_into_pairs)\n",
    "k_per_token_as_complex_numbers.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 64, 2])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k_per_token_split_into_pairs_rotated = torch.view_as_real(k_per_token_as_complex_numbers * freqs_cis)\n",
    "k_per_token_split_into_pairs_rotated.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 128])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k_per_token_rotated = k_per_token_split_into_pairs_rotated.view(k_per_token.shape)\n",
    "k_per_token_rotated.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 现在，已经有了每个 token 的旋转后的 query 和 key\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/keys0.png\" width=\"600px\"/>\n",
    "</div>\n",
    "\n",
    "每个 query 和 key 的 shape 都是 `[17x128]`。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 接下来，将 query 和 key 的矩阵相乘\n",
    "\n",
    "这样做会得到每一个 token 相互映射的分数\n",
    "\n",
    "这个分数描述了每个 token 的 query 与每个 token 的 key 的相关度。这就是自注意力 :)\n",
    "\n",
    "注意力得分矩阵（qk_per_token）的 shape 是 `[17x17]`，其中 17 是 prompt 中的 token 数量\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/qkmatmul.png\" width=\"600px\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 17])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qk_per_token = torch.matmul(q_per_token_rotated, k_per_token_rotated.T)/(head_dim)**0.5\n",
    "qk_per_token.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 现在必须屏蔽 QK 分数\n",
    "\n",
    "在 llama3 的训练过程中，未来的 token qk 分数被屏蔽。\n",
    "\n",
    "为什么？因为在训练过程中，只学习使用过去的 token 来预测 token 。\n",
    "\n",
    "因此，在推理过程中，将未来的 token 设置为零。\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/mask.png\" width=\"600px\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def display_qk_heatmap(qk_per_token):\n",
    "    _, ax = plt.subplots()\n",
    "    im = ax.imshow(qk_per_token.to(float).detach(), cmap='viridis')\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",
    "    ax.figure.colorbar(im, ax=ax)\n",
    "    \n",
    "display_qk_heatmap(qk_per_token)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "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.]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mask = torch.full((len(tokens), len(tokens)), float(\"-inf\"), device=tokens.device)\n",
    "mask = torch.triu(mask, diagonal=1)\n",
    "mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "qk_per_token_after_masking = qk_per_token + mask\n",
    "display_qk_heatmap(qk_per_token_after_masking)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div>\n",
    "    <img src=\"images/softmax.png\" width=\"600px\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "qk_per_token_after_masking_after_softmax = torch.nn.functional.softmax(qk_per_token_after_masking, dim=1).to(torch.bfloat16)\n",
    "display_qk_heatmap(qk_per_token_after_masking_after_softmax)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## values (注意力机制的最后部分) \n",
    "\n",
    "<div>\n",
    "    <img src=\"images/value.png\" width=\"600px\"/>\n",
    "</div>\n",
    "\n",
    "这些分数（0-1）用于确定每个 token 中使用了多少 value 矩阵\n",
    "\n",
    "> these scores (0-1) are used to determine how much of value matrix is used per token\n",
    "\n",
    "和 key 一样，value 权重也在每 4 个注意力头之间进行共享（以节省计算量）\n",
    "\n",
    "因此，下面的 value 权重矩阵的 shape 为 `[8x128x4096]`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([8, 128, 4096])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v_layer0 = model[\"layers.0.attention.wv.weight\"]\n",
    "v_layer0 = v_layer0.view(n_kv_heads, v_layer0.shape[0] // n_kv_heads, dim)\n",
    "v_layer0.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the first layer, first head value weight matrix is given below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([128, 4096])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v_layer0_head0 = v_layer0[0]\n",
    "v_layer0_head0.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## value 向量\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/v0.png\" width=\"600px\"/>\n",
    "</div>\n",
    "\n",
    "现在使用 value 权重来获取每个 token 的注意力值，其大小为 `[17x128]`，其中 17 是 prompt 中的 token 数，128 是每个 tokene 的 value 向量的维度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 128])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v_per_token = torch.matmul(token_embeddings, v_layer0_head0.T)\n",
    "v_per_token.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 注意力(attention)\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/attention.png\" width=\"600px\"/>\n",
    "</div>\n",
    "\n",
    "和每个 token 的 value 相乘后得到的注意力向量的 shape 为 `[17*128]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 128])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qkv_attention = torch.matmul(qk_per_token_after_masking_after_softmax, v_per_token)\n",
    "qkv_attention.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 多头注意力 (multi head attention)\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/heads.png\" width=\"600px\"/>\n",
    "</div>\n",
    "\n",
    "现在已经有了第一层和第一个头的注意力值\n",
    "\n",
    "现在将运行一个循环，并执行与上面单元格中相同的数学运算，但只针对第一层中的每个头"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qkv_attention_store = []\n",
    "\n",
    "for head in range(n_heads):\n",
    "    q_layer0_head = q_layer0[head]\n",
    "    k_layer0_head = k_layer0[head//4] # key weights are shared across 4 heads\n",
    "    v_layer0_head = v_layer0[head//4] # value weights are shared across 4 heads\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",
    "    q_per_token_split_into_pairs = q_per_token.float().view(q_per_token.shape[0], -1, 2)\n",
    "    q_per_token_as_complex_numbers = torch.view_as_complex(q_per_token_split_into_pairs)\n",
    "    q_per_token_split_into_pairs_rotated = torch.view_as_real(q_per_token_as_complex_numbers * freqs_cis[:len(tokens)])\n",
    "    q_per_token_rotated = q_per_token_split_into_pairs_rotated.view(q_per_token.shape)\n",
    "\n",
    "    k_per_token_split_into_pairs = k_per_token.float().view(k_per_token.shape[0], -1, 2)\n",
    "    k_per_token_as_complex_numbers = torch.view_as_complex(k_per_token_split_into_pairs)\n",
    "    k_per_token_split_into_pairs_rotated = torch.view_as_real(k_per_token_as_complex_numbers * freqs_cis[:len(tokens)])\n",
    "    k_per_token_rotated = k_per_token_split_into_pairs_rotated.view(k_per_token.shape)\n",
    "\n",
    "    qk_per_token = torch.matmul(q_per_token_rotated, k_per_token_rotated.T)/(128)**0.5\n",
    "    mask = torch.full((len(tokens), len(tokens)), float(\"-inf\"), device=tokens.device)\n",
    "    mask = torch.triu(mask, diagonal=1)\n",
    "    qk_per_token_after_masking = qk_per_token + mask\n",
    "    qk_per_token_after_masking_after_softmax = torch.nn.functional.softmax(qk_per_token_after_masking, dim=1).to(torch.bfloat16)\n",
    "    qkv_attention = torch.matmul(qk_per_token_after_masking_after_softmax, v_per_token)\n",
    "    qkv_attention = torch.matmul(qk_per_token_after_masking_after_softmax, v_per_token)\n",
    "    qkv_attention_store.append(qkv_attention)\n",
    "\n",
    "len(qkv_attention_store)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div>\n",
    "    <img src=\"images/stacked.png\" width=\"600px\"/>\n",
    "</div>\n",
    "\n",
    "现在有了第一个层的 32 个头的 qkv_attention 矩阵，接下来将把所有注意力分数合并成一个大矩阵，大小为 `[17x4096]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 4096])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stacked_qkv_attention = torch.cat(qkv_attention_store, dim=-1)\n",
    "stacked_qkv_attention.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 权重矩阵，最后几步之一\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/weightmatrix.png\" width=\"600px\"/>\n",
    "</div>\n",
    "\n",
    "对于第0层，最后要做的一件事是，将权重矩阵相乘"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([4096, 4096])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w_layer0 = model[\"layers.0.attention.wo.weight\"]\n",
    "w_layer0.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 这是一个简单的线性层，所以只需要进行乘法运算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 4096])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "embedding_delta = torch.matmul(stacked_qkv_attention, w_layer0.T)\n",
    "embedding_delta.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div>\n",
    "    <img src=\"images/afterattention.png\" width=\"600px\"/>\n",
    "</div>\n",
    "\n",
    "注意之后，现在有了嵌入值的变化，应该将其添加到原始的 token embeddings 中"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 4096])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "embedding_after_edit = token_embeddings_unnormalized + embedding_delta\n",
    "embedding_after_edit.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 将其归一化，然后运行一个前馈神经网络\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/norm_after.png\" width=\"600px\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 4096])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "embedding_after_edit_normalized = rms_norm(embedding_after_edit, model[\"layers.0.ffn_norm.weight\"])\n",
    "embedding_after_edit_normalized.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 加载 FFN 权重并实现前馈网络\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/swiglu.png\" width=\"600px\"/>\n",
    "</div>\n",
    "\n",
    "在 llama3 中，使用了 `SwiGLU` 前馈网络，这种网络架构非常擅长非线性计算。\n",
    "\n",
    "如今，在 LLMS 中使用这种前馈网络架构是相当常见的"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 4096])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w1 = model[\"layers.0.feed_forward.w1.weight\"]\n",
    "w2 = model[\"layers.0.feed_forward.w2.weight\"]\n",
    "w3 = model[\"layers.0.feed_forward.w3.weight\"]\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": {},
   "source": [
    "# 在第一层之后，终于为每个 token 编辑了新的 EMBEDDINGS\n",
    "\n",
    "离结束还剩 31 层（一层 for 循环）\n",
    "\n",
    "可以将经过编辑的 embedding 想象为包含有关第一层上提出的所有 query 的信息\n",
    "\n",
    "现在，对所有提出的问题每一层都会对 query 进行越来越复杂的编码，直到得到一个 embedding，其中包含了需要的下一个 token 的所有信息。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 4096])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "layer_0_embedding = embedding_after_edit+output_after_feedforward\n",
    "layer_0_embedding.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 整合\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/god.png\" width=\"600px\"/>\n",
    "</div>\n",
    "\n",
    "就是这样。 之前为每一层所做的一切都需要一次性完成。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_embedding = token_embeddings_unnormalized\n",
    "for layer in range(n_layers):\n",
    "    qkv_attention_store = []\n",
    "    layer_embedding_norm = rms_norm(final_embedding, model[f\"layers.{layer}.attention_norm.weight\"])\n",
    "    q_layer = model[f\"layers.{layer}.attention.wq.weight\"]\n",
    "    q_layer = q_layer.view(n_heads, q_layer.shape[0] // n_heads, dim)\n",
    "    k_layer = model[f\"layers.{layer}.attention.wk.weight\"]\n",
    "    k_layer = k_layer.view(n_kv_heads, k_layer.shape[0] // n_kv_heads, dim)\n",
    "    v_layer = model[f\"layers.{layer}.attention.wv.weight\"]\n",
    "    v_layer = v_layer.view(n_kv_heads, v_layer.shape[0] // n_kv_heads, dim)\n",
    "    w_layer = model[f\"layers.{layer}.attention.wo.weight\"]\n",
    "    for head in range(n_heads):\n",
    "        q_layer_head = q_layer[head]\n",
    "        k_layer_head = k_layer[head//4]\n",
    "        v_layer_head = v_layer[head//4]\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",
    "        q_per_token_split_into_pairs = q_per_token.float().view(q_per_token.shape[0], -1, 2)\n",
    "        q_per_token_as_complex_numbers = torch.view_as_complex(q_per_token_split_into_pairs)\n",
    "        q_per_token_split_into_pairs_rotated = torch.view_as_real(q_per_token_as_complex_numbers * freqs_cis)\n",
    "        q_per_token_rotated = q_per_token_split_into_pairs_rotated.view(q_per_token.shape)\n",
    "        k_per_token_split_into_pairs = k_per_token.float().view(k_per_token.shape[0], -1, 2)\n",
    "        k_per_token_as_complex_numbers = torch.view_as_complex(k_per_token_split_into_pairs)\n",
    "        k_per_token_split_into_pairs_rotated = torch.view_as_real(k_per_token_as_complex_numbers * freqs_cis)\n",
    "        k_per_token_rotated = k_per_token_split_into_pairs_rotated.view(k_per_token.shape)\n",
    "        qk_per_token = torch.matmul(q_per_token_rotated, k_per_token_rotated.T)/(128)**0.5\n",
    "        mask = torch.full((len(token_embeddings_unnormalized), len(token_embeddings_unnormalized)), float(\"-inf\"))\n",
    "        mask = torch.triu(mask, diagonal=1)\n",
    "        qk_per_token_after_masking = qk_per_token + mask\n",
    "        qk_per_token_after_masking_after_softmax = torch.nn.functional.softmax(qk_per_token_after_masking, dim=1).to(torch.bfloat16)\n",
    "        qkv_attention = torch.matmul(qk_per_token_after_masking_after_softmax, v_per_token)\n",
    "        qkv_attention_store.append(qkv_attention)\n",
    "\n",
    "    stacked_qkv_attention = torch.cat(qkv_attention_store, dim=-1)\n",
    "    w_layer = model[f\"layers.{layer}.attention.wo.weight\"]\n",
    "    embedding_delta = torch.matmul(stacked_qkv_attention, w_layer.T)\n",
    "    embedding_after_edit = final_embedding + embedding_delta\n",
    "    embedding_after_edit_normalized = rms_norm(embedding_after_edit, model[f\"layers.{layer}.ffn_norm.weight\"])\n",
    "    w1 = model[f\"layers.{layer}.feed_forward.w1.weight\"]\n",
    "    w2 = model[f\"layers.{layer}.feed_forward.w2.weight\"]\n",
    "    w3 = model[f\"layers.{layer}.feed_forward.w3.weight\"]\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",
    "    final_embedding = embedding_after_edit+output_after_feedforward"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 得到最终 Embedding，对下一个 token 做预测\n",
    "\n",
    "embedding 的 shape 与常规 token embedding shape `[17x4096]` 相同，其中 17 是 token 数量，4096 是 embedding 维度\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/last_norm.png\" width=\"600px\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([17, 4096])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final_embedding = rms_norm(final_embedding, model[\"norm.weight\"])\n",
    "final_embedding.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 最后，将 embedding 解码为 token value\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/finallayer.png\" width=\"600px\"/>\n",
    "</div>\n",
    "\n",
    "将使用输出解码器将最终 embedding 转换为 token。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([128256, 4096])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model[\"output.weight\"].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 使用最后一个 token 的 embedding 来预测下一个值\n",
    "\n",
    "希望在我们预料之内, 42 :)\n",
    "\n",
    "注意：根据《银河系漫游指南》书中提到，“生命、宇宙和一切的终极问题的答案是 42 ” 。大多数现代语言模型在这里应该会回答 42，这应该能验证我们的整个代码！祝我好运 :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([128256])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "logits = torch.matmul(final_embedding[-1], model[\"output.weight\"].T)\n",
    "logits.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 模型预测的 token 编号是 2983，这是否代表 42 的 token 编号？\n",
    "\n",
    "这已经是代码的最后一部分了，希望你已经信心满满 :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(50210)"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next_token = torch.argmax(logits, dim=-1)\n",
    "next_token"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 解码\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/42.png\" width=\"600px\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'.updateDynamic'"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tokenizer.decode([next_token.item()])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 感恩, 爱你哟 :)\n",
    "\n",
    "这就是结尾了。希望你喜欢！\n",
    "\n",
    "如果你想支持我的工作：\n",
    "\n",
    "1. 在 Twitter 上关注我：https://twitter.com/naklecha\n",
    "2. 或者给我买杯咖啡：[https://www.buymeacoffee.com/naklecha](https://www.buymeacoffee.com/naklecha)\n",
    "\n",
    "说实话，如果你能到这一步，已经让我很开心了:)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}