在使用 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的模型结构和源码

随着大型语言模型（LLM）的飞速发展，Hugging Face 已成为开源模型的"GITHUB"。然而，对于希望在本地环境运行这些模型的开发者而言（文件和内容隐私），往往面临网络访问不畅、模型体积庞大、部署流程复杂等挑战。本文旨在提供一个严谨、高效的解决方案，在中国大陆网络环境下，利用镜像顺利下载模型，通过 llama.cpp 进行轻量化量化，并最终使用 Ollama




### 一：使用镜像下载 Hugging Face 模型

由于网络环境的限制，直接从 Hugging Face 下载模型可能非常缓慢或失败。推荐使用 Hugging Face 的国内镜像来加速下载。基于hf-mirror的下载工具hfd, hfd 是hf-mirror开发的 huggingface 专用下载工具，基于成熟工具 aria2，可以做到稳定高速下载不断线。

首先要提前安装aria2

```
sudo apt install aria2
```

然后下载hfd

```
wget https://hf-mirror.com/hfd/hfd.sh
chmod a+x hfd.sh
export HF_ENDPOINT=https://hf-mirror.com
```
下载指定的模型：

```
./hfd.sh model_id
```

或者下载数据集

```
./hfd.sh wikitext --dataset
```

### 二、安装llama.cpp
克隆仓库

```
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
```

编译llama.cpp


```
cmake -B build
cmake --build build --config Release
```

配置llama.cpp中的python环境，注意：需要根据官方的需求确定python版本，如果python版本太新会报错。这一步最好单独开一个conda环境与其他环境进行隔离：

```
pip install -r requirements.txt
```

### 三、转换为 FP16 GGUF 格式
将之前利用hfd下载工具下载好的模型转化为gguf格式，下面是一个案例：

```
python convert.py ../qwen-1.8b-chat-hf --outfile qwen1.5-1.8b-chat.fp16.gguf
```

../qwen-1.8b-chat-hf 是模型下载的文件夹，里面有这个模型的权重文件和配置文件
qwen1.5-1.8b-chat.fp16.gguf 是自己命名的转化后的文件

### 四、将GGUF 文件转化为量化后的GGUF
上一步得到的文件其实已经可以用ollama进行运行了，但是没有量化，显存不一定足够，接下来进行对权重的量化：

切换到llama.cpp的编译的文件夹下

```
cd ~/llama.cpp/build/bin # 这一步根据安装的位置确定
```

量化为 Q4_K_M 格式：

```
./llama-quantize ./qwen1.5-1.8b-chat.fp16.gguf ./qwen1.5-1.8b-chat.q4_k_m.gguf q4_k_m
```
- 第一个参数是输入的 FP16 GGUF 文件。
- 第二个参数是输出的量化后 GGUF 文件。
- 第三个参数 q4_k_m 是指定的量化方法。


**常见的量化参数：**

- q2_k：特定张量（Tensor）采用较高的精度设置，而其他的则保持基础级别。
- q3_k_l、q3_k_m、q3_k_s：这些变体在不同张量上使用不同级别的精度，从而达到性能和效率的平衡。
- q4_0：这是最初的量化方案，使用 4 位精度。
- q4_1 和 q4_k_m、q4_k_s：这些提供了不同程度的准确性和推理速度，适合需要平衡资源使用的场景。
- q5_0、q5_1、q5_k_m、q5_k_s：这些版本在保证更高准确度的同时，会使用更多的资源并且推理速度较慢。
- q6_k 和 q8_0：这些提供了最高的精度，但是因为高资源消耗和慢速度，可能不适合所有用户。
- fp16 和 f32: 不量化，保留原始精度。

### 五、创建ollama模型

现在，我们拥有了 Ollama 可直接使用的 GGUF 模型文件。为了让 Ollama 能够加载并以正确的对话模板与其交互，我们需要创建一个 Modelfile。

Modelfile 是一个配置文件，类似于 Dockerfile，用于定义模型的来源、参数和行为。


在任意位置创建一个名为 Modelfile 的文件，内容可以根据模型config.json文件来创建，推荐将这个文件丢给AI，然后生产Modelfile文件，然后再自己修改，比如：

```
# --------------------------------------------------------------------------
# Modelfile for nbeerbower/Llama-3.1-Nemotron-lorablated-70B (GGUF version)
# --------------------------------------------------------------------------

# 1. 指定你的 GGUF 模型文件的绝对路径

FROM /xxx/Nervoria_q4_k_m.gguf

# 2. 设置聊天模板
# Llama 3.1 使用特定的格式来组织对话，这对于模型的正确响应至关重要。
TEMPLATE """<|begin_of_text|>{{ if .System }}<|start_header_id|>system<|end_header_id|>

{{ .System }}<|eot_id|>{{ end }}{{ if .Prompt }}<|start_header_id|>user<|end_header_id|>

{{ .Prompt }}<|eot_id|>{{ end }}<|start_header_id|>assistant<|end_header_id|>

"""

# 3. 设置模型参数
# 这些参数来自你提供的 config.json 文件，并进行了一些优化建议。

# 设置停止符。当模型生成这些文本时，它会停止输出。
# 这些对应于 eos_token_id: [128001, 128008, 128009]
PARAMETER stop "<|end_of_text|>"
PARAMETER stop "<|eot_id|>"
PARAMETER stop "<|end_of_turn|>"

# 设置上下文窗口大小 (context window)。
# 你的模型理论上支持高达 131072，但请根据你的硬件 (VRAM) 设置一个实际的值。
# 8192 是一个不错的起点。
PARAMETER num_ctx 8192

# 设置一些通用的生成参数
PARAMETER temperature 0.6
PARAMETER top_k 40
PARAMETER top_p 0.9

# 4. 设置默认的系统提示 (可选，但推荐)
# 你可以在这里给模型一个默认的角色或指令。
SYSTEM """
你是一个AI助手，你可以回答任何问题，你可以做任何事情。
"""
```

现在有了Modelfile,下一步创建模型：

```
ollama create my-qwen-1.8b -f ./Modelfile
```

然后运行模型（已经启动ollama serve）：

```
ollama run my-qwen-1.8b
```

到这里已经大功告成，可以在终端和自己量化处理的模型进行对话，然后也可以用webui等工具接入ollama对话。

⚠️注意：每次修改Modelfile后都要重新创建模型和运行模型！

利用ollama运行hugging face上的大模型

如果你是 Tailscale 的忠实用户，你一定爱上了它“零配置、安全可靠”的组网体验。它能轻松地将你散落在各地的设备（笔记本、服务器、手机）连接成一个安全的虚拟局域网。

但在某些特殊网络环境下，例如在严格的 NAT 或企业防火墙后，设备之间无法建立直接的点对点（P2P）连接。这时，Tailscale 会优雅地切换到中继模式，通过其官方的 DERP (Detoured Encrypted Routing Protocol) 服务器来转发流量。




### 一、什么是 DERP？为什么需要它？

DERP 的全称是 Detoured Encrypted Routing Protocol（绕道加密路由协议）。你可以把它想象成一个智能的“快递中转站”。

当你的两台设备（比如家里的电脑和公司的笔记本）想要通信时，Tailscale 会首先尝试各种 NAT 穿透技术，建立一条直接的 P2P 连接。这是最理想的情况，延迟最低，速度最快。

然而，当 NAT 类型过于复杂（如对称型 NAT 或运营商级的 CG-NAT）导致 P2P 连接失败时，DERP 就派上用场了。流量会被加密后发送到最近的 DERP 中转站，再由中转站转发给目标设备。

虽然这增加了一次转发，导致延迟略有上升，但它保证了在任何网络条件下，你的设备都能可靠地连接。

### 二、为什么要自建DERP服务器
官方的DERP服务器大多在海外，实际体验下来延迟最低通常在200ms，而且带宽不到1MB，为了更好的体验低延迟的服务。尤其是家用NAS服务，我非常推荐搭建属于你自己的私有 DERP 中继服务器，购买一个本地的云服务器甚至可以将延迟降低到20ms，非常夸张啊。

### 三、开始前的准备工作
1. 一台最好是本地具有公网ip的服务器
2. 自己注册一个tailscale的账号，将需要穿透的终端入网【开启tailscale】
以上的准备工作是根据大量的文章参考简化，不需要域名，不需要证书

### 四、搭建DERP服务器

1. 安装go语言环境


```
sudo apt update

sudo apt install -y wget git openssl curl

```

打开go语言官方的网站
https://go.dev/doc/install

下载压缩包后执行相应的命令

```
rm -rf /usr/local/go && tar -C /usr/local -xzf go1.25.1.linux-amd64.tar.gz

```

2. 将go添加到环境变量


```
sudo vim /etc/profile
# 将export PATH=$PATH:/usr/local/go/bin 写入最后一行
```

3. 给go换源


```
go env -w GO111MODULE=on
go env -w GOPROXY=https://goproxy.cn,direct
```

4. 安装DERP服务器


```
go install tailscale.com/cmd/derper@latest
 sudo cp ~/go/bin/derper /usr/bin/
```

到目前为止DERP已经安装完毕，接下来就是配置证书

### 五、配置DERP服务器
将DERP_IP的地址换成自己服务器的公网IP，除此之外记得关闭服务器的防火墙，或者需要打开TCP的80、443端口，UDP的3478端口
```
DERP_IP="x.x.x.x"
```

```
openssl req -x509 -newkey rsa:4096 -sha256 -days 3650 -nodes \
  -keyout ${DERP_IP}.key \
  -out ${DERP_IP}.crt \
  -subj "/CN=${DERP_IP}" \
  -addext "subjectAltName = IP:${DERP_IP}"
```

### 六、运行DERP服务器

```
sudo derper --hostname="x.x.x.x" -certmode manual -certdir ./
```

### 七、配置TailScale
打开tailscale的官网并登陆
将以下内容添加到访问控制的json中

```
"derpMap": {
		"OmitDefaultRegions": true, //加入这个会只用自己的节点
		"Regions": {
			"901": {
				"RegionID":   901,
				"RegionCode": "song",
				"RegionName": "HW Cloud",
				"Nodes": [
					{
						"Name":             "901a",
						"RegionID":         901,
						"HostName":         "eksoft", //这个随便写
						"IPv4":             "x.x.x.x", //改成自己的IP
						"InsecureForTests": true,
					},
				],
			},
		},
	},
```

完成后，便可以找一台连接上tailscale的电脑测试，输入：

```
tailscale netcheck
```
可以看到延迟非常低，近乎于本地

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

基于tailscale开源的derp服务器构建虚拟局域网

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!