在日常的开发和运维工作中，我们经常需要传输大量文件。当传输单个大文件时，网络带宽通常能被充分利用，速度令人满意。然而，一旦面对成千上万个小文件，传输速度便会急剧下降，令人抓狂。这背后的原因在于，每次文件传输都伴随着网络连接建立、元数据读写等额外开销。对于小文件而言，这些固定开销所占比例远超实际数据传输的时间. 本文参考美团技术团队的博客：https://tech.meituan.com/2021/01/07/pack-gzip-zstd-lz4.html
选择isa-l算法和Pigz算法进行测试。



### 测试平台
使用macbook air m4 16g内存，4+4 核心，单核频率最大4.5GHz

### isa-l算法
ISA-L 是一套在 IA 架构上加速算法执行的开源函数库，目的在于解决存储系统的计算需求。 ISA-L 使用的是 BSD-3-Clause License ，因此在商业上同样可以使用。

使用过 SPDK（Storage Performance Development Kit ）或者 DPDK（Data Plane Development Kit）应该也听说过 ISA-L ，前者使用了 ISA-L 的 CRC 部分，后者使用了它的压缩优化。ISA-L 通过使用高效的 SIMD （Single Instruction, Multiple Data）指令和专用指令，最大化的利用 CPU 的微架构来加速存储算法的计算过程。ISA-L底层函数都是使用手工汇编代码编写，并在很多细节上做了调优（现在经常要考虑 ARM 平台，本文中所提及的部分指令在该平台支持度不高甚至是不支持）。

首先安装

```
brew install isa-l
```

测试压缩：

```
time tar cf - ./海事事故数据 | igzip > demo.tar.gz
```
这个文件夹大约7.95G,大量的小型pdf文件，测试结果：

```
tar cf - ./海事事故数据  0.18s user 1.53s system 3% cpu 51.342 total
igzip > demo.tar.gz  41.62s user 1.26s system 83% cpu 51.343 total
```

测试解压：

```
time igzip -dc demo.tar.gz | tar xf -
```
测试结果：

```
igzip -dc demo.tar.gz  15.86s user 1.53s system 82% cpu 20.961 total
tar xf -  0.26s user 4.06s system 20% cpu 20.962 total
```

### Pigz算法

测试压缩：

```
time tar -cf - ./海事事故数据 | pigz > demo.tar.gz
```

测试结果：

```
tar -cf - ./海事事故数据  0.31s user 2.85s system 11% cpu 28.507 total
pigz > demo.tar.gz  163.13s user 6.14s system 593% cpu 28.508 total
```

解压测试：

```
time pigz -dc demo.tar.gz | tar -xf -
```

测试结果：

```
pigz -dc demo.tar.gz  9.26s user 3.81s system 117% cpu 11.169 total
tar -xf -  0.33s user 4.56s system 43% cpu 11.175 total
```

### 结果分析
可以看到Pigz算法在压缩速度上优势比较明显，因为是并行的，如果是服务器100多核心的，可能优势更大。不过占用资源也是真的。一般来讲，服务器不需要跑什么服务，或者不是用在生产环节，使用Pigz能够更加节约时间。
⚠️：一定不要在U盘下进行压缩操作，U盘的读写速度非常差，并且很多文件格式只支持最大4G!!!

### 补充分卷压缩指令

压缩大文件，每个分卷3G
```
tar -cf - large_project | pigz | split -b 3G - large_project_archive.tar.gz.
```

解压分卷

```
cat /path/to/archive.tar.gz.* | pigz -dc | tar -xf -
```

大批量小文件传输优化方案

有时候服务器没有安装显示器，无法提供ui界面，想要使用mihomo，就必须通过命令行操作，以下是具体教程：




### 首先第一步更新系统

```bash
sudo apt-get update
```

### 下载clash

新建一个目录来存放clash

```bash
mkdir clash
```

随后进入目录

```bash
cd clash
```

下载clash

请务必根据自己的系统来灵活调整下载的版本，查询系统详情的命令为uname -a

```bash
wget https://github.com/doreamon-design/clash/releases/download/v2.0.24/clash_2.0.24_linux_amd64.tar.gz
```

解压

```bash
#注意活用tab键补齐
tar -zxvf clash_2.0.24_linux_amd64.tar.gz
```

重命名方便使用

```bash
mv clash_2.0.24_linux_amd64.tar.gz clash
```

赋予clash可执行权限

```bash
chmod 777 clash
```

### 设置配置文件

```bash
#订阅链接请自行替换，另外curl获取的链接一定要加上引号
wget -qO config.yaml http://xxxxx
```

成功后会在当前目录生成一个config.yaml文件
然后下载分流数据库：

```
wget https://raw.gitmirror.com/adysec/IP_database/main/geolite/GeoLite2-Country.mmdb
```


```
mv GeoLite2-Country.mmdb Country.mmdb 
```

运行以下命令启动clash

```bash
#运行的时候会使用当前文件夹的config.yaml文件
./clash -d ./
```

命令运行时会自动配置所需文件，需要等待一会儿

设置命令行代理

```bash
export https_proxy=http://127.0.0.1:7897 http_proxy=http://127.0.0.1:7897
```

```bash
#访问下google看看是否有返回
curl "www.google.com"
```

取消命令行代理

```bash
unset http_proxy
unset https_proxy
```

### 在服务器中

最简单的方式就是使用nohup命令

```
nohup ./clash -d ./ &
```


原文参考
：https://www.noseeflower.icu

在无UI的情况下使用mihomo

在使用 Docker 的过程中，从 Docker Hub 拉取镜像是我们日常操作的一部分。然而，由于网络环境的复杂性，我们常常会遇到镜像拉取速度缓慢，甚至因网络波动导致下载中断的问题。这篇博客将为你详细介绍如何通过更换国内镜像源来加速 Docker 镜像的拉取，并探讨在遇到下载中断时如何实现类似“断点续传”的效果。


默认情况下，Docker 从官方的 Docker Hub 拉取镜像，但由于服务器在国外，国内用户的下载速度往往不尽人意。幸运的是，我们可以通过配置国内的镜像加速器来解决这个问题

### 修改配置文件

```
sudo vim /etc/docker/daemon.json
```

添加内容：

```
{
  "registry-mirrors": [
    "https://docker.m.daocloud.io"
  ]
}
```
然后执行：

```
sudo systemctl daemon-reload && sudo systemctl restart docker
```

docker 换源与断点续传

对于在Ubuntu系统上进行深度学习、科学计算或任何需要GPU加速的任务，正确安装NVIDIA显卡驱动、CUDA Toolkit和cuDNN是至关重要的第一步。本教程将为您提供一个详尽的、逐步的指南，在Ubuntu系统上顺利完成安装。



### 首先禁用原来的驱动Nouveau

```
sudo vim /etc/default/grub
将---> GRUB_CMDLINE_LINUX_DEFAULT="quiet splash"
替换为---> GRUB_CMDLINE_LINUX_DEFAULT="quiet splash modprobe.blacklist=nouveau"
保存后更新---> sudo update-grub
更新后重启系统---> sudo reboot

```

### 选择合适的驱动
首先更新软件包索引

```
sudo apt update
```

然后检测合适的驱动版本，这里选择recommended 的那一个驱动就行

```
ubuntu-drivers devices
```

![image.png](/static/img/fa114a11aea86dede59e4fda55a82c6c.image.webp)

开始安装【⚠️注意：一定要先把旧的驱动卸载掉，如果安装过就的N卡驱动】

卸载命令【没有旧版本就不需要执行卸载命令】：

```
sudo apt remove --purge '^nvidia-.*'
sudo apt autoremove --purge
sudo apt autoclean
```
再开始安装
```
sudo apt install nvidia-driver-575
```


### 安装cuda 
首先查看ubuntu的版本信息

```
lsb_release -a
```
输出

```
No LSB modules are available.
Distributor ID:	Ubuntu
Description:	Ubuntu 22.04.5 LTS
Release:	22.04
Codename:	jammy
```

再输入以下命令查看当前显卡驱动支持最高的cuda版本：

```
nvidia-smi
```
点开链接https://developer.nvidia.com/cuda-toolkit-archive 查看自己对应的版本然后根据官方的指令下载cuda

例如：
 
![image.png](/static/img/5593e728b75e50494c45cf8cf1dbb92b.image.webp)

⚠️注意：标红的那一行命令要根据提示输入，一般执行完上一行命令会提示，不要直接输入带有*符号的这一行命令

最后检查安装和更新环境变量：

输入：

```
 /usr/local/cuda-12.9/bin/nvcc -V
```

![image.png](/static/img/b01b195d02868b93079b6c6c1142168b.image.webp)

根据上图可以看到安装成功了，但是需要引入环境变量：
在~/.bashrc 或者 ~/.zshrc 中的文件末尾添加以下内容：
```
export PATH="/usr/local/cuda-12.0/bin:$PATH" 
export LD_LIBRARY_PATH="/usr/local/cuda-12.0/lib64:$LD_LIBRARY_PATH" 

```
最后执行【取决于你用的什么shell】：

```
source ~/.zshrc
# 或者执行
source ~/.bashrc
```
### 安装cuDnn
安装CUDA之后，首先根据自己的显卡驱动和cuda版本查找对应的cudnn版本：https://docs.nvidia.com/deeplearning/cudnn/backend/latest/reference/support-matrix.html

然后进入搜索对应的CuDNN版本，选择合适的版本下载压缩包。

### 安装pytorch

```
pip3 install torch torchvision
```

### 测试安装是否成功


完成所有安装后，创建一个test_cudnn.py文件测试：

```python
#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""
一个用于检测 CUDA 和 cuDNN 是否可用的 Python 脚本。
它会分别使用 PyTorch 和 TensorFlow 这两个主流框架进行测试。
"""

import sys
import platform

def print_separator(char='=', length=70):
    """打印一个分隔符，用于美化输出。"""
    print(char * length)

def test_pytorch():
    """
    使用 PyTorch 检测 CUDA 和 cuDNN。
    """
    print_separator()
    print(">>> 开始检测 PyTorch 的 CUDA 和 cuDNN 配置 <<<")
    print_separator()
    
    try:
        import torch
        print(f"PyTorch 版本: {torch.__version__}")

        # 1. 检查 CUDA 是否可用
        is_cuda_available = torch.cuda.is_available()
        print(f"CUDA 是否可用 (torch.cuda.is_available()): {'是 (Yes)' if is_cuda_available else '否 (No)'}")

        if not is_cuda_available:
            print("\n[警告] PyTorch 无法找到 CUDA。")
            print("可能的原因：")
            print("1. 未安装 NVIDIA 驱动。")
            print("2. 安装了 CPU 版本的 PyTorch。请访问 https://pytorch.org/get-started/locally/ 获取正确的安装命令。")
            print("3. CUDA Toolkit 版本与 PyTorch 不兼容。")
            return

        # 2. 获取 CUDA 设备信息
        print(f"可用的 GPU 数量: {torch.cuda.device_count()}")
        current_device_id = torch.cuda.current_device()
        print(f"当前 GPU 设备 ID: {current_device_id}")
        current_device_name = torch.cuda.get_device_name(current_device_id)
        print(f"当前 GPU 设备名称: {current_device_name}")

        # 3. 检查 PyTorch 编译时使用的 CUDA 版本
        # 注意：这不一定是您系统上安装的 CUDA 版本，而是 PyTorch 构建时所依赖的版本。
        print(f"PyTorch 编译所用的 CUDA 版本: {torch.version.cuda}")

        # 4. 检查 cuDNN 是否可用
        is_cudnn_available = torch.backends.cudnn.is_available()
        print(f"cuDNN 是否可用 (torch.backends.cudnn.is_available()): {'是 (Yes)' if is_cudnn_available else '否 (No)'}")
        
        if is_cudnn_available:
            # 打印 cuDNN 版本
            cudnn_version = torch.backends.cudnn.version()
            print(f"cuDNN 版本: {cudnn_version}")
        
        print("\n[结论] PyTorch 的 CUDA 和 cuDNN 环境配置正确。")

    except ImportError:
        print("\n[信息] 未安装 PyTorch (torch)。跳过 PyTorch 检测。")
        print("如需安装，请运行: pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cuXXX (请根据你的CUDA版本替换cuXXX)")
    except Exception as e:
        print(f"\n[错误] 检测过程中发生未知错误: {e}")

def test_tensorflow():
    """
    使用 TensorFlow 检测 CUDA 和 cuDNN。
    """
    print_separator()
    print(">>> 开始检测 TensorFlow 的 CUDA 和 cuDNN 配置 <<<")
    print_separator()

    try:
        import tensorflow as tf
        print(f"TensorFlow 版本: {tf.__version__}")

        # 1. 检查 GPU 设备
        gpu_devices = tf.config.list_physical_devices('GPU')
        print(f"找到的 GPU 设备: {len(gpu_devices)}")

        if not gpu_devices:
            print("\n[警告] TensorFlow 无法找到 GPU。")
            print("可能的原因：")
            print("1. 未安装 NVIDIA 驱动。")
            print("2. 未正确安装 CUDA Toolkit 和 cuDNN，或其路径未配置。")
            print("3. TensorFlow 版本与 CUDA/cuDNN 版本不兼容。")
            print("4. 安装了 CPU 版本的 TensorFlow (tensorflow-cpu)。")
            return

        # 2. 打印 GPU 详细信息
        for i, device in enumerate(gpu_devices):
            print(f"  - GPU {i}: {device.name}")
        
        # 3. TensorFlow 的 cuDNN 检测是隐式的。如果 GPU 可用且日志中没有 cuDNN 错误，则通常 cuDNN 也在工作。
        # 我们可以通过构建信息来查看 TensorFlow 是否是为 GPU 构建的。
        build_info = tf.sysconfig.get_build_info()
        is_cuda_build = build_info.get("is_cuda_build", False)
        print(f"TensorFlow 是否为 CUDA 构建: {'是 (Yes)' if is_cuda_build else '否 (No)'}")
        if 'cudnn_version' in build_info:
            print(f"TensorFlow 编译所用的 cuDNN 版本: {build_info['cudnn_version']}")
        if 'cuda_version' in build_info:
            print(f"TensorFlow 编译所用的 CUDA 版本: {build_info['cuda_version']}")

        # 4. 运行一个简单的矩阵运算来实际使用 GPU
        try:
            print("\n尝试在 GPU 上执行一个简单的矩阵乘法...")
            with tf.device('/GPU:0'):
                a = tf.constant([[1.0, 2.0], [3.0, 4.0]])
                b = tf.constant([[1.0, 1.0], [0.0, 1.0]])
                c = tf.matmul(a, b)
            print("GPU 运算成功！")
            # print("结果:\n", c.numpy())
        except Exception as e:
            print(f"[错误] 在 GPU 上执行运算时失败: {e}")

        print("\n[结论] TensorFlow 的 GPU 环境配置正确。")
        
    except ImportError:
        print("\n[信息] 未安装 TensorFlow。跳过 TensorFlow 检测。")
        print("如需安装 GPU 版本，请运行: pip install tensorflow")
    except Exception as e:
        print(f"\n[错误] 检测过程中发生未知错误: {e}")

def main():
    """
    主函数，执行所有检测。
    """
    print("CUDA/cuDNN 环境检测脚本")
    print(f"Python 版本: {sys.version}")
    print(f"操作系统: {platform.system()} {platform.release()}")
    
    test_pytorch()
    print("\n")
    test_tensorflow()
    
    print_separator(char='*')
    print("检测完成。")
    print_separator(char='*')

if __name__ == "__main__":
    main()
```

ubuntu显卡驱动和cuda与cudnn安装教程

# 深入浅出：解密GPT-2，从模型结构到源码实现

在人工智能的星辰大海中，GPT-2（Generative Pre-trained Transformer 2）无疑是一座耀眼的灯塔。它的出现，标志着自然语言生成技术的一次重大飞跃，也为我们今天所熟知的ChatGPT等大型语言模型奠定了坚实的基础。

尽管GPT2推出的时间在2019年，截止目前已经过去了6年了。但是其对于理解transformer和大语言模型具备一定意义。本文将详细的讲解GPT2的模型结构和代码实现，尽管GPT2与现代大模型的结构存在很大差异，但是作为初学者的一个学习样本依旧足够。




## 预备工作
在开始讲解GPT2之前，需要掌握transformer的结构和原理，尤其是多头注意力机制。除此之外，要理解GPT2的源码，还需要对pytorch具备一定的熟悉程度。俗话说：**“授人以鱼不如授人以渔”**
下面是我在学习过程中发现的一些优秀资源：
1. B站李宏毅详解transformer的视频
2. https://poloclub.github.io/transformer-explainer/ 一个GPT2可视化的网站【具备一定交互】
3. B站up 3blue1brown的视频 https://www.bilibili.com/video/BV1qM4m1d7is
4. GPT2 pytorch的实现 https://github.com/karpathy/nanoGPT


## GPT2结构的预备知识
下面我将一边展示源码，一边展示原理，将GPT2的模型进行切块讲解，最后再汇总从宏观的层次上讲解. 首先让我们看GPT2的全貌：

![image.png](/static/img/621a4f9034e2142933602aacb3d9f084.image.webp)

可以看到整体架构中有非常多个小的模块，下面我将一个一个模块的讲解。


#### Tokenizer 分词器
在将内容输入给大模型之前还需要分词器做预处理，Tokenizer（分词器/标记器） 是一个程序，它的核心任务是将一段原始文本（比如一个句子或一篇文章）分解成一个个更小的、有意义的单元。这些单元被称为 “词元”或“标记”（Token）。这个过程，就叫做 Tokenization（分词或标记化）。下面将简单介绍一下常见的分词方法：

**1.基于词 (Word-based)**

通常按照空格或标点符号来切分，方法很简单。对于英文来说，可以根据标点和空格切分，对于中文无法很好的适配。并且如果模型在训练时没见过某个词（比如 "tokenization"），在预测时就无法处理它，会将其视为未知词（<UNK>）。英语中有名词单复数、动词时态变化（如 run, runs, running），它们都会被当作不同的 Token，导致词表非常大。
    
e.g:
文本: "I have a new cat."
Tokens: ["I", "have", "a", "new", "cat", "."]

**2.基于字符(Character-based)**

将文本切分成最基本的单元——字符，中英都适配。并且没有没有 OOV （Out-of-Vocabulary）问题: 任何词都可以由有限的字符组成，词表非常小。但是会丢失语义信息: 单个字母 c a t 本身没有 “猫” 的完整含义。
并且导致序列过长: 一个句子会被切成非常长的序列，增加了模型的计算负担。
    
e.g:文本: "cat" Tokens: ["c", "a", "t"]

**3.基于子词 (Subword-based)**

基于子词是本文tokenizer的核心，也是目前主流大模型（GPT, Gemini等）使用的分词方法。这种方法将常见词保持为完整的 Token，不常见的词则被拆分成更小的、有意义的子词片段。可以有效解决 OOV 问题: 即使遇到新词，也可以通过已知的子词组合来表示它。例如，即使没见过 “swimmingly”，也可以拆分成 [“swimm”, “##ingly”]。能够处理词形变化: run 和 running 共享了 run 这个子词，模型能更好地理解它们之间的关系。这种方法平衡了效率和精度。
    
e.g: 常见词 "this is a cat" -> ["this","is","a","cat"],  不常见词 "tokenization" -> ["token", "ization"]

下面我将介绍GPT2使用的分词算法：**BPE (Byte-Pair Encoding)**
从一个由单个字符组成的初始词表开始，通过迭代地、贪婪地合并最常出现的相邻“词元对”（Token Pair），来构建一个最终的词表和一套合并规则。

可以把它想象成一个“乐高”游戏：

- 初始状态：你有一大堆最基础的乐高积木（单个字符）。
- 游戏规则：找出你最常拼在一起的两种积木（最频繁的相邻字符对），把它们粘成一个新积木块，并给这个新积木块起个名字。
- 重复游戏：不断重复这个过程，用现有的积木块（包括新粘合的）去拼出更复杂的积木块。
- 游戏结束：直到你的积木库（词表）达到了预设的大小，或者没有可以再合并的了。
最终，你就得到了一套从基础到复杂的“乐高积木”（词表），以及一套如何用它们拼装的“说明书”（合并规则）。
    
假设我们的 训练语料库 是一个词频词典（为了简化，通常会对原始文本进行预分词，并统计词频）：
    
```
{
    "low": 5,
    "lower": 2,
    "newest": 6,
    "wider": 3
}
```
将每个词拆分成字符序列，并在词尾添加一个特殊的结束符< /w>以区分词的边界。这非常重要，因为它能让模型区分 st（在 stop 中）和 st< /w>（在 fast 中）。
    
```
5 "l o w < /w>"
2 "l o w e r < /w>"
6 "n e w e s t < /w>"
3 "w i d e r < /w>"
```
创建初始词表 (Vocabulary)：词表就是语料中出现的所有单个字符。
    
```
    初始词表: {'<', '/', '>', 'd', 'e', 'i', 'l', 'n', 'o', 'r', 's', 't', 'w'}
```
    
现在，我们开始循环，每次找出频率最高的相邻词元对进行合并。假设我们的目标是执行 8次 合并操作。
    
 迭代 1:

计算频率：计算所有相邻词元对的出现频率。
    
(l, o): 5 (from "low") + 2 (from "lower") = 7
    
(o, w): 5 (from "low") + 2 (from "lower") = 7
    
(e, s): 6 (from "newest")
    
(s, t): 6 (from "newest")
... 其他频率较低的组合
    
选择合并：假设我们选择 (l, o) 进行合并（当频率相同时，选择任意一个）。
执行合并：将语料中所有的 l o 替换为 lo。
合并规则 1: (l, o) -> lo
更新语料:
    
```
5 "lo w < /w>"
2 "lo w e r < /w>"
6 "n e w e s t < /w>"
3 "w i d e r < /w>"
```
更新我们的词表：词表 += {'lo'}
    
迭代 2:

计算频率：
    
(lo, w): 5 + 2 = 7
    
(e, s): 6
    
(s, t): 6
...
    
选择合并：(lo, w) 频率最高。
执行合并:
合并规则 2: (lo, w) -> low
更新语料:
    
```
5 "low < /w>"
2 "low e r < /w>"
6 "n e w e s t < /w>"
3 "w i d e r < /w>"
```
    
更新词表: 词表 += {'low'}
... 以此类推 ...

我们继续这个过程，直到达到预设的词表大小或合并次数。最终，我们可能会学到如下的合并规则（按优先级排序）：

1. (l, o) -> lo
2. (lo, w) -> low
3. (e, s) -> es
4. (s, t) -> st (假设在另一次迭代中被选择)
5. (es, t) -> est
6. (n, e) -> ne
7. (ne, w) -> new
8. (new, est) -> newest
...等等。

训练产出：

- 最终词表 (Final Vocabulary)：包含初始字符和所有合并生成的新子词。
    
- 合并规则 (Merge Rules)：一个按优先级排序的合并操作列表。
    
根据词表和合并规则，现在我们可以开始分词了：
例如，我们要对单词 "lowest" 进行分词。

初始拆分：先将单词拆分为字符序列，并加上结束符。
l o w e s t < /w>
    
应用规则：按照学习到的合并规则的优先级，从高到低（或从学习顺序）依次在序列中查找并执行合并。
    
找最高优先级的合并：在 l o w e s t < /w> 中，查找我们学到的规则。
    
假设我们学到的规则中有 (l, o) -> lo。
    
应用后变为：lo w e s t < /w>
    
再查找下一个最高优先级的规则，比如 (lo, w) -> low。
    
应用后变为：low e s t < /w>
    
再查找，假设我们没有学过 (low, e)，但学过 (s, t) -> st。
    
应用后变为：low e st < /w>
    
再查找，假设我们没有学过 (e, st)，也没有学过 (st, < /w>)。
    
结束：没有更多可应用的合并规则了。
    
最终结果：单词 "lowest" 被分词为：
["low", "e", "st", "< /w>"] （通常在实际使用中会去掉 < /w>）
 
⚠️ 像 ChatGPT 这样的模型，其 Tokenizer（名为 cl100k_base），不会将字符作为基本单位了，而是使用的BPE算法的变体，而是把 字节 (Byte) 作为基本单位。一个 Unicode 字符可能由 1 到 4 个字节组成。
    
BPE算法实际上也是需要预料库进行训练的，不过幸运的是已经有训练好的模型可以直接用了，下面是简单的一个案例：

```
import tiktoken
import torch

input_str = "帮我编写一个读取txt的python程序"
enc = tiktoken.get_encoding("gpt2") # 初始化gpt2的tokenizer
train_ids = enc.encode_ordinary(input_str) # 编码
print(train_ids)

print(f"输入的字符串长度为{len(input_str)}")
print(f"编码后的长度为{len(train_ids)}")
```
输出结果：
    
```
[30585, 106, 22755, 239, 163, 120, 244, 37863, 247, 31660, 10310, 103, 46237, 119, 20998, 244, 14116, 21410, 29412, 163, 101, 233, 41753, 237]
输入的字符串长度为20
编码后的长度为24
```
    
可以看到每个token被转化为了一个token ID， **最大 Token ID = 词汇表大小 (Vocabulary Size) - 1** 。
 
此时，我们只是将字符串转化为了由 Token ID 构成的列表，由于GPT2模型的预训练是无监督训练，仅让模型学习人类语言的规则，没有学习遵循人类指令。所以输入模型的每一个字符串都是block_size = 1024的长度，一本书的内容，会被从不同位置给切出一个1024长度的Token 序列。因此，**大模型的最原始输入应该是一个 [batch_size, block_size]形状的张量。**
    
肯定有人好奇，为什么有时候与AI聊天的时候可以随便输入长度不超过最大限制的字符串，因为简单来说，你输入的内容 ≠ 模型最终处理的内容。模型最大长度是1024个Token，“你好”可能只有2个Token。系统会用一个特殊的、无意义的\<pad>符号【通常对应一个特殊的token id, 一般叫做】把剩下的4094个位置填满，然后送给模型。模型被训练过，知道要忽略这些填充符号。下面是一些常见的特殊的Token。
    
- [UNK] (Unknown): 代表词汇表中没有的词。
- [CLS] (Classification): 在BERT等模型中，通常放在序列开头，其对应的输出向量用于分类任务。
- [SEP] (Separator): 用于分隔两个不同的句子。
- [BOS] (Beginning of Sequence/Sentence): 标记序列的开始。
- [EOS] (End of Sequence): 标记序列的结束。
- [PAD] (Padding): 用于将序列填充到固定长度。
    
### 1.Token Embed 层
这一个层的作用是将自然语言转化为计算机可以理解的语言，也就是向量(**每个token对应一个固定维度的向量**)。我们给模型的最原始输入通常是一串文字，然后我们会将文字切割，每个独立的单元叫做token，所谓的大模型根据token计费就是根据输入模型的独立单元的数量计费。利用Token Embed 可以将每个token转化为一个向量。每个token的向量维度都是一致的，token的语义越接近，token的向量欧式距离就越近。

现在我们来看源码实现：

```
 wte = nn.Embedding(config.vocab_size, config.n_embd) # vocab_size 表示词表大小
```
 利用了pytorch封装好的模块，只需要一行代码即可实现Token Embed层，下面将举个例子看看什么是Embedding层，如何转化token id为向量的:
    

```
import torch.nn as nn
batch_size = 24 
block_size = 1024
vocab_size = 50304 # gpt2的词表大小
n_embd = 768 # gpt2的词嵌入维度
# Generate a 2D tensor of random integers
input_tensor = torch.randint(0, vocab_size, (batch_size, block_size)) # 假设这是经过分词器处理后的24个句子
print(input_tensor.shape)

wte = nn.Embedding(vocab_size, n_embd)
token_embeddings = wte(input_tensor)
print(token_embeddings.shape)
print(wte.weight.shape) # 可以看出内部就是一个权重矩阵，矩阵尺寸由vocab_size, n_embd决定
```
输出：
    
```
torch.Size([24, 1024])
torch.Size([24, 1024, 768])
torch.Size([50304, 768])
```
可以看到，输入的24个token长度等于1024的句子，每个token都被转化为了一个768维的向量。我们打印出token embedding层的权重形状，可以看到内部就是一个矩阵，token id 的最大值对应这个矩阵的最大行数-1，有了输入的token ID（标量）和嵌入矩阵，转换过程就非常简单了：直接去矩阵里“查”对应的行。

**这本质上是一个索引操作。** 输入token ID 1 ("我")，就去嵌入矩阵中取出第1行的向量 [0.91, 0.33, -0.24, -0.56, 0.78]。
    
### 2 位置嵌入层 (Position Embding)
实现代码：

```
pos = torch.arange(0, block_size, dtype=torch.long, device=device) # 形状为 (block_size)
    
wpe = nn.Embedding(config.block_size, config.n_embd),

pos_emb = wpe(pos) # 位置嵌入，形状为 (b,t, n_embd)

```

### 3.归一化层（LN）
归一化层的作用是对单个样本的所有特征进行归一化，能够加速模型收敛，提高训练稳定性，减少对初始化的依赖。除此之外LN在一定程度上限制了模型的表达能力，有助于防止过拟合。 **相比较于BN层，对于小样本更加友好**【因为显存的原因，有时候batch_size比较小】,因为BN层是对一个批次的所有样本在单个特征上进行归一化，强依赖于批次大小，批次太小会导致统计量不准。

LN的数学模型：
假设一个神经网络的某一层有 H 个神经元，其激活值（输入）构成一个向量：$
X = ( x_{1}, x_{2}, \dots, x_{H} )
$;层归一化的计算过程如下:
$$
{\bf y}=\gamma\odot\frac{{\bf x}-\mu} {\sqrt{\sigma^{2}+\epsilon}}+\beta
$$
其中，⊙ 表示逐元素相乘，$\mu$表示$X$向量的均值，其中，ϵ (epsilon) 是一个非常小的正数（例如 10 
e−5 ），其作用是为了防止分母为零，增加数值稳定性。

单纯的归一化可能会限制模型的表达能力，因为强制将每层的输入都变成了标准正态分布。为了恢复模型的表达能力，LN引入了两个可学习的参数：增益（gain）$\gamma$ 和 偏置（bias） β。这两个参数和权重 W 一样，都是通过反向传播学习得到的。⚠️：$\gamma$ 与 $\beta$ 都是与词嵌入相同维度的向量。

σ表示均方差，计算方式如下：
$$
\sigma^{2}=\frac{1} {H} \sum_{i=1}^{H} ( x_{i}-\mu)^{2}
$$


实现源码：

```
from torch.nn import functional as F

class LayerNorm(nn.Module):
    """层归一化模块，支持可选的偏置参数。PyTorch原生LayerNorm不直接支持关闭偏置，此实现解决了该问题。"""
    
    def __init__(self, ndim, bias):
        """
        初始化层归一化模块。

        参数:
        ndim (int): 归一化的维度，通常为输入特征的维度。
        bias (bool): 是否使用偏置参数。True 表示使用，False 表示不使用。
        """
        super().__init__()
        # 初始化可训练的权重参数，形状为 (ndim,)，初始值全为 1。该权重用于对归一化后的输入进行缩放。
        self.weight = nn.Parameter(torch.ones(ndim))
        # 根据 bias 参数决定是否初始化可训练的偏置参数。
        # 若 bias 为 True，则初始化形状为 (ndim,) 且初始值全为 0 的偏置参数；
        # 若 bias 为 False，则不初始化偏置参数，将其设为 None。
        self.bias = nn.Parameter(torch.zeros(ndim)) if bias else None

    def forward(self, input):
        """
        前向传播方法，对输入进行层归一化操作。

        参数:
        input (torch.Tensor): 输入张量，需要进行层归一化的输入数据。
        返回:
        torch.Tensor: 经过层归一化处理后的张量。
        """
        # 使用 PyTorch 的 layer_norm 函数进行层归一化操作
        # input: 输入张量，即需要进行归一化处理的数据
        # self.weight.shape: 归一化的形状，使用权重的形状作为归一化的维度
        # self.weight: 可学习的权重参数，用于对归一化后的输入进行缩放
        # self.bias: 可学习的偏置参数，若初始化时未启用则为 None
        # 1e-5: 数值稳定性的小常数，防止分母为零
        return F.layer_norm(input, self.weight.shape, self.weight, self.bias, 1e-5)

layer_norm_model = LayerNorm(n_embd, bias=False)
layer_norm_output = layer_norm_model(token_embeddings)
print("输入张量形状:", token_embeddings.shape)
print("输出张量形状:", layer_norm_output.shape)

# 对比第一个样本的均值和方差变化

print("第一个样本原始的均值", token_embeddings[0, 0, :].mean())
print("第一个样本原始的方差", token_embeddings[0, 0, :].std())

print("第一个样本经过LN后的均值:", layer_norm_output[0, 0, :].mean()) # 接近0
print("第一个样本经过LN的方差:", layer_norm_output[0, 0, :].std()) # 接近1

```
    
输出：

```
输入张量形状: torch.Size([24, 1024, 768])
输出张量形状: torch.Size([24, 1024, 768])
第一个样本原始的均值 tensor(0.0453, grad_fn=<MeanBackward0>)
第一个样本原始的方差 tensor(0.9664, grad_fn=<StdBackward0>)
第一个样本经过LN后的均值: tensor(0., grad_fn=<MeanBackward0>)
第一个样本经过LN的方差: tensor(1.0006, grad_fn=<StdBackward0>)  

```
    
### 四、注意力机制
理解多头之前，必须先掌握它的基本单元：缩放点积注意力（Scaled Dot-Product Attention）。

这是 Transformer 中使用的标准注意力形式。它的输入是三个向量：查询（Query, Q）、键（Key, K） 和 值（Value, V）。

Q, K, V 是什么？
它们都是由同一个输入序列（比如一句话的词向量序列）通过不同的线性变换（乘以不同的权重矩阵）得到的。

Query (Q): 代表当前正在处理的词，它要去“查询”与其他词的关系。
Key (K): 代表序列中可以被查询的词，它与 Q 进行匹配，以计算相关性。
Value (V): 同样代表序列中的词，但它包含了词的实际信息。一旦计算出注意力权重，我们就用这些权重去加权求和 V。

![image.png](/static/img/d0f80b42e876b4a2475fbba03b8ecf80.image.webp)
            <center>图：6个token根据Q K V权重矩阵计算$q,k,v$向量</center>

深入浅出GPT2的模型结构和源码

Welcome to my tech blog! Here, I document my coding journey and explore various technologies, focusing on practical solutions and streamlined techniques. From programming insights to tool recommendations, I share hands-on experiences that help sharpen your skills. Let’s learn and grow together!