# 深入浅出：解密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

sudo apt install golang-go
```

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 "subje
```
### 六、运行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服务器构建虚拟局域网

## 引言

    最近调试大疆无人机，在进行二次发开时遇到一个Linux的新知识点————USB Gadget框架。网上搜索相关资料后总结出本篇博文。
    
 
USB Gadget 框架（USB Gadget Framework）是一个主要在 Linux 内核中使用的软件框架，它允许一个通常作为 USB 主机（Host）的设备（例如嵌入式 Linux 系统、单板计算机）模拟成一个 USB 从设备（Peripheral，也称 Gadget）。



简单来说，当你的 Linux 设备通过 USB 连接到另一台计算机（通常是 PC）时，USB Gadget 框架可以让你的 Linux 设备扮演各种 USB 设备的角色。

USB Gadget 框架的用途非常广泛，它使得嵌入式设备或计算机能够模拟标准 USB 设备类别：

- 虚拟串口 (Serial Gadget / CDC ACM): 允许通过 USB 在主机和从设备之间建立一个串行通信通道，常用于调试或简单的数据传输。
- 虚拟以太网适配器 (Ethernet Gadget / RNDIS, CDC Ethernet, EEM): 使得从设备可以通过 USB 与主机进行网络通信，就像连接了一个 USB 网卡一样。这对于文件传输、网络服务等非常有用。
- 大容量存储设备 (Mass Storage Gadget): 可以让从设备的存储空间（如 SD 卡、内存的一部分）在主机上显示为一个 U 盘或移动硬盘，方便文件交换。
- 人机接口设备 (HID Gadget): 模拟键盘、鼠标、游戏手柄等输入设备。
- 音频设备 (Audio Gadget): 模拟麦克风或扬声器。
- MTP/PTP 设备 (Media Transfer Protocol / Picture Transfer Protocol): 允许主机像访问数码相机或媒体播放器一样访问从设备上的媒体文件。

*由此可以推断出安卓手机的USB网络共享的本质其实就是利用了USB Gadget框架，将USB接口模拟成一个虚拟网卡，实现电脑共享手机的网络。*

那么USB Gadget框架解决了什么问题呢？
1. 赋予嵌入式设备多样化的 USB 从设备能力： 许多嵌入式系统自身可能没有专门的硬件来实现特定的 USB 从设备功能（如网络适配器、存储设备等）。USB Gadget 框架通过软件模拟，使得这些设备能够灵活地扮演这些角色，而无需额外的硬件成本。
2. 简化了 USB 从设备驱动的开发： 它提供了一套标准的 API 和结构，开发者可以专注于实现特定 USB 功能的逻辑（例如如何处理网络数据包或存储读写请求），而不用从头处理复杂的 USB 协议底层细节。
3. 提高了配置的灵活性（尤其通过 ConfigFS）： 早期的 Gadget 驱动配置可能需要在内核编译时确定，或者通过 sysfs 进行有限的运行时配置。引入 ConfigFS (Configuration Filesystem) 后，用户可以在运行时动态地创建、配置和启用不同的 USB Gadget 功能和组合，极大地增强了灵活性和易用性。例如，可以方便地修改 USB 设备的描述符（如 VID, PID, 序列号等）和所提供的功能。
4. 促进了设备间的互操作性： 通过模拟标准的 USB 设备类别，可以确保与各种主流操作系统的 USB 主机驱动程序兼容。

在调试无人机的过程中，使用到了一种叫做BULK的端点，这里涉及到USB通信中的Endpoint (端点)————即描述设备内部与主机进行数据交换的具体通信信道或缓冲区的术语。
想象一下 USB 设备（如 U盘、打印机、扫描仪）和主机（如电脑）之间的通信。数据需要在两者之间流动。端点就是这些数据流动的特定“出入口”或“管道口”。USB 定义了四种主要的传输类型，每种类型对应不同特性的端点：

1. Control Endpoints (控制端点): 用于设备配置、命令和状态查询。每个USB设备都必须有控制端点0。
2. Interrupt Endpoints (中断端点): 用于传输少量、有及时性要求的数据，例如鼠标点击或键盘按键。数据传输有保证的延迟。
3. Isochronous Endpoints (等时端点): 用于传输大量、连续的实时数据，如音频或视频流。它保证带宽，但如果发生错误，数据可能会丢失（不重传）。
4. BULK Endpoints (批量端点): 用于传输大量数据，如向U盘写入文件或从扫描仪读取图像。


BULK 端点的主要特点就是面向大块数据传输，同时还有一个特性：单向性， 每个批量端点都是单向的。
BULK IN Endpoint: 数据从 USB 设备传输到主机。
BULK OUT Endpoint: 数据从主机传输到 USB 设备。
如果一个设备需要双向批量数据传输，它需要分别配置一个 BULK IN 端点和一个 BULK OUT 端点。

Linux下的USB gadget框架

随着DeepSeek-R1大模型的开源，中国国内掀起了新的AI风潮，各行各业纷纷基于开源模型优化自己的服务。腾讯基于自己公众号的海量数据接入deepseek，并迅速抓住机遇开发了腾讯元宝软件以占领市场，知乎也基于自己平台高质量中文问答接入了deepseek。作为科研工作者，也需要抓住机遇合理的利用AI辅助自己的研究，本文将主要从AI平台，论文写作和文献搜寻展开。


### AI大模型和平台
以下是目前主流的AI大模型根据智力分析得到的排名，目前openAI的o3-mini(high)的综合水平最高，deepseek-r1在推理和中文上具备一定的优势，claude 3.7在编程上具备优势,谷歌家的gemini在上下文和生成速度上遥遥领先。


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

对于研究而言，**编程问题**优先推荐claude，工具推荐cursor. cursor是一个基于vscode开发的ide，内部集成了AI，可以自动关联上下文，熟悉vscode的工作者使用cursor可以更加顺手。而**文献查找问题**，可以使用谷歌的gemini，因为谷歌学术平台的数据库肯定被用来训练了，里面大量的文献元数据有利于gemini查找文献相关的问题：比如推荐某个领域的前沿研究。但是要注意，AI依旧可能生成虚假的文献信息，必须要仔细查证。

### 文献解析
利用AI解析文献是本文的重点，通常将pdf文件上传，然后输入提示词解析，下面是常用的提示词

=== 基础信息提取模板 ===

```
1. 请提取论文的核心研究问题、理论框架及学科定位，用不超过300字概括其学术坐标
2. 分析作者在采用的研究方法，按照①实验设计 ②数据来源 ③分析工具 ④验证方式的结构列表呈现

```
=== 深度内容挖掘提示 ===


```
对比该文献领域近三年顶刊论文，从以下维度识别创新性：
理论突破（权重30%）
方法革新（权重40%）
应用价值（权重30%） 给出量化评分及依据,
并将全文论证逻辑可视化为思维导图，要求包含：
核心论点（红色节点）
支撑论据（蓝色节点）
反驳观点（黄色节点）
数据支撑（绿色节点） 输出Markdown格式流程图
```


下面我将做一个简单的benchmark,上传一篇论文的pdf，然后根据输入以上提示词得到最后的思维导图

#### gemini 2.0 flash（chat）

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

#### gpt-4o （chat）

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

#### deepseek-r1（api）

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

#### gemini 2.0 pro（chat）

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

#### deepseek-r1官方(chat)

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

简单对比了这几个常用的模型生成的思维导图，完全符合要求的只有deepseek-r1的api，其他几家各有问题。目前而言，在一众免费可用的模型中，还是deepseek-r1比较强，其他几家更优秀的模型我并未对比，因为成本相对过于高昂。此外使用api控制好tp值，设置在较低的情况下，对于论文分析的生成效果会更好。调用api是通过chatbox本地解析，不排除解析pdf对于生成效果的影响，有可能优秀的pdf解析会考虑到多模态。

AI大模型时代下的做研究思路

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!