【大模型】- 开源模型架构

宋 算法
  2026-08-19 09:14 2026-08-19 09:14 创建   2026-08-21 16:20:12 2026-08-21 16:20:12 更新      1.2k 字  5 分钟

开源模型架构

分析主流 LLM 的设计选择

类型： 学习　｜　语言： Python　｜　🏷 前置：《开源模型架构》（本系列第 13 篇）

学习目标

  • 了解主流开源 LLM 架构
  • 分析不同模型的设计选择
  • 理解架构对性能的影响
  • 比较不同模型的优缺点
  • 选择适合特定任务的模型

主流开源 LLM

LLaMA 系列

LLaMA（Large Language Model Meta AI）是 Meta 开发的开源 LLM 系列。

架构特点

1
2
3
4
5
6
7
8
9
10
11
# LLaMA 架构配置
llama_config = {
    "hidden_size": 4096,
    "intermediate_size": 11008,
    "num_attention_heads": 32,
    "num_hidden_layers": 32,
    "rms_norm_eps": 1e-6,
    "vocab_size": 32000,
    "max_position_embeddings": 2048,
    "rope_theta": 10000.0,
}

关键创新

  1. RMSNorm：简化层归一化
  2. SwiGLU：改进的激活函数
  3. RoPE：旋转位置编码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class RMSNorm(nn.Module):
    def __init__(self, dim, eps=1e-6):
        super().__init__()
        self.eps = eps
        self.weight = nn.Parameter(torch.ones(dim))
    
    def forward(self, x):
        norm = torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps)
        return x * norm * self.weight

class SwiGLU(nn.Module):
    def __init__(self, dim, hidden_dim):
        super().__init__()
        self.w1 = nn.Linear(dim, hidden_dim, bias=False)
        self.w2 = nn.Linear(hidden_dim, dim, bias=False)
        self.w3 = nn.Linear(dim, hidden_dim, bias=False)
    
    def forward(self, x):
        return self.w2(F.silu(self.w1(x)) * self.w3(x))

Mistral 架构

Mistral 是 Mistral AI 开发的高效 LLM。

架构特点

1
2
3
4
5
6
7
8
9
10
mistral_config = {
    "hidden_size": 4096,
    "intermediate_size": 14336,
    "num_attention_heads": 32,
    "num_hidden_layers": 32,
    "num_key_value_heads": 8,  # 分组查询注意力
    "vocab_size": 32000,
    "max_position_embeddings": 32768,
    "sliding_window": 4096,
}

关键创新

  1. 分组查询注意力（GQA）：减少 KV 缓存
  2. 滑动窗口注意力：处理长序列
  3. 滚缓冲区：高效内存管理
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
class GroupedQueryAttention(nn.Module):
    def __init__(self, dim, n_heads, n_kv_heads):
        super().__init__()
        self.n_heads = n_heads
        self.n_kv_heads = n_kv_heads
        self.n_rep = n_heads // n_kv_heads
        
        self.wq = nn.Linear(dim, n_heads * head_dim, bias=False)
        self.wk = nn.Linear(dim, n_kv_heads * head_dim, bias=False)
        self.wv = nn.Linear(dim, n_kv_heads * head_dim, bias=False)
        self.wo = nn.Linear(n_heads * head_dim, dim, bias=False)
    
    def forward(self, x, mask=None, cache=None):
        bsz, seqlen, _ = x.shape
        
        # 计算 Q, K, V
        xq = self.wq(x).view(bsz, seqlen, self.n_heads, head_dim)
        xk = self.wk(x).view(bsz, seqlen, self.n_kv_heads, head_dim)
        xv = self.wv(x).view(bsz, seqlen, self.n_kv_heads, head_dim)
        
        # 重复 K, V 以匹配 Q 的头数
        xk = xk.repeat_interleave(self.n_rep, dim=2)
        xv = xv.repeat_interleave(self.n_rep, dim=2)
        
        # 注意力计算
        scores = torch.matmul(xq, xk.transpose(-2, -1)) / math.sqrt(head_dim)
        
        if mask is not None:
            scores = scores + mask
        
        attn = torch.softmax(scores, dim=-1)
        output = torch.matmul(attn, xv)
        
        return self.wo(output.reshape(bsz, seqlen, -1))

Gemma 架构

Gemma 是 Google 开发的轻量级 LLM。

架构特点

1
2
3
4
5
6
7
8
9
gemma_config = {
    "hidden_size": 2048,
    "intermediate_size": 16384,
    "num_attention_heads": 8,
    "num_hidden_layers": 18,
    "num_key_value_heads": 1,
    "vocab_size": 256000,
    "max_position_embeddings": 8192,
}

关键创新

  1. 多查询注意力（MQA）：极致的 KV 缓存优化
  2. Gemma embedding：改进的embedding 层
  3. GeGLU：门控线性单元

Phi 架构

Phi 是 Microsoft 开发的小型高效 LLM。

架构特点

1
2
3
4
5
6
7
8
phi_config = {
    "hidden_size": 2048,
    "intermediate_size": 8192,
    "num_attention_heads": 32,
    "num_hidden_layers": 24,
    "vocab_size": 51200,
    "max_position_embeddings": 2048,
}

关键创新

  1. 小但高效：参数量小但性能好
  2. 高质量数据：使用高质量训练数据
  3. 课程学习：渐进式训练

架构比较

参数效率

模型 参数量 上下文长度 特点
LLaMA-7B 7B 2048 通用
Mistral-7B 7B 32768 高效
Gemma-7B 7B 8192 轻量
Phi-2 2.7B 2048 小型

注意力机制比较

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 标准多头注意力
class MultiHeadAttention(nn.Module):
    def __init__(self, dim, n_heads):
        self.n_heads = n_heads
        # Q, K, V 都有 n_heads 个头

# 分组查询注意力（GQA）
class GroupedQueryAttention(nn.Module):
    def __init__(self, dim, n_heads, n_kv_heads):
        self.n_heads = n_heads
        self.n_kv_heads = n_kv_heads  # n_kv_heads < n_heads
        # K, V 的头数少于 Q

# 多查询注意力（MQA）
class MultiQueryAttention(nn.Module):
    def __init__(self, dim, n_heads):
        self.n_heads = n_heads
        # K, V 只有一个头

位置编码比较

编码类型 模型 优点 缺点
绝对位置编码 GPT-2 简单 长度固定
RoPE LLaMA, Mistral 相对位置 计算复杂
ALiBi BLOOM 简单高效 精度略低

选择模型

任务需求

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
def select_model(task_type, constraints):
    """根据任务和约束选择模型"""
    
    if task_type == "code_generation":
        # 代码生成任务
        if constraints.get("size") == "small":
            return "Phi-2"  # 小型但高效
        else:
            return "CodeLlama"  # 代码优化
    
    elif task_type == "long_context":
        # 长上下文任务
        return "Mistral-7B"  # 32K 上下文
    
    elif task_type == "multilingual":
        # 多语言任务
        return "LLaMA-2"  # 多语言支持
    
    elif task_type == "edge_deployment":
        # 边缘部署
        return "Gemma-2B"  # 轻量级
    
    else:
        # 通用任务
        return "LLaMA-7B"  # 通用性能好

硬件约束

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def check_hardware_requirements(model, available_memory):
    """检查硬件要求"""
    model_sizes = {
        "LLaMA-7B": 14,  # GB
        "Mistral-7B": 14,
        "Gemma-7B": 14,
        "Phi-2": 5.4,
        "Gemma-2B": 4,
    }
    
    required_memory = model_sizes.get(model, 0)
    
    if required_memory > available_memory:
        return False, f"需要 {required_memory}GB，但只有 {available_memory}GB"
    
    return True, "满足要求"

架构演进趋势

1. 效率优化

  • 分组查询注意力：减少 KV 缓存
  • 滑动窗口：处理长序列
  • 量化支持：减少内存使用

2. 上下文扩展

  • RoPE 缩放：扩展上下文长度
  • Flash Attention：高效长序列处理
  • 稀疏注意力：减少计算复杂度

3. 多模态支持

  • 视觉编码器：处理图像
  • 音频编码器：处理语音
  • 统一架构：多模态融合

总结

开源 LLM 架构各有特点。LLaMA 通用性强，Mistral 效率高，Gemma 轻量，Phi 小型高效。选择模型需要考虑任务需求、硬件约束和性能要求。

下一步

下一课将介绍推测解码，加速自回归生成。

📚 本文改编自 AI Engineering from Scratch（MIT License · 作者 Rohit Ghumare），中文内容来自官方中文镜像。原课程共 503 课 · 20 阶段 · 免费开源，教程网站见 aiengineeringfromscratch.com。

  • 标题: 【大模型】- 开源模型架构
  • 作者: 宋
  • 创建于 : 2026-08-19 09:14:00
  • 更新于 : 2026-08-21 16:20:12
  • 链接: https://sxl-space.tk/2026/08/19/010_LLM/010_LLM-14-OpenModelsArchitecture/
  • 版权声明: 版权所有 © 宋，禁止转载。
目录
【大模型】- 开源模型架构
  1. 1. 开源模型架构
  2. 2. 学习目标
  3. 3. 主流开源 LLM
    1. 3.1. LLaMA 系列
      1. 3.1.1. 架构特点
      2. 3.1.2. 关键创新
    2. 3.2. Mistral 架构
      1. 3.2.1. 架构特点
      2. 3.2.2. 关键创新
    3. 3.3. Gemma 架构
      1. 3.3.1. 架构特点
      2. 3.3.2. 关键创新
    4. 3.4. Phi 架构
      1. 3.4.1. 架构特点
      2. 3.4.2. 关键创新
  4. 4. 架构比较
    1. 4.1. 参数效率
    2. 4.2. 注意力机制比较
    3. 4.3. 位置编码比较
  5. 5. 选择模型
    1. 5.1. 任务需求
    2. 5.2. 硬件约束
  6. 6. 架构演进趋势
    1. 6.1. 1. 效率优化
    2. 6.2. 2. 上下文扩展
    3. 6.3. 3. 多模态支持
  7. 7. 总结
  8. 8. 下一步
  9. 9. 下一课将介绍推测解码，加速自回归生成。