主流大模型技术解析：GPT、Llama、ChatGLM、Qwen 与 DeepSeek

SFT >> Supervised Fine-Tuning 监督微调，使用人工标注引导模型学习人类偏好

RM >> Reward Model 训练奖励模型

PPO >> 用 PPO 算法更新模型，让 SFT 模型根据奖励模型的反馈不断改进

1. SFT 阶段：人类通过标注理想答案，监督微调大模型，让其初步学习人类偏好 2. RM 阶段：人类对模型生成的多个答案进行排序，用这些排序数据训练一个奖励模型 3. PPO 阶段：用奖励模型打出的分数作为反馈信号，通过强化学习让大模型不断优化

人类标注 → SFT 微调 → 人类排序 → RM 奖励模型 → PPO 强化学习 → ChatGPT

后序 RLHF 因人工标注成本问题进阶 RLAIF >> 基于 AI 反馈的强化学习 LLM 有这个能力

四、GPT vs BERT 本质区别

五、ChatGPT 优缺点总结

✅ 优点

• 回答更理性、全面、多角度
• 降低学习与内容创作成本

❌ 缺点

• 服务不稳定
• 可能'一本正经地胡说八道'

六、GPT 总结

ChatGPT 的成功并非一蹴而就，而是 GPT 系列模型四年演进的集大成者。从 GPT-1 的单向生成，到 GPT-2 的多任务尝试，再到 GPT-3 的规模爆发，最后通过 RLHF 实现人类对齐 —— 这是一条从'模型能力'走向'人类价值对齐'的技术路径。ChatGPT 的真正突破，不只是大，而是学会了'听人话，说人话'。

LLM 主流开源大模型

一、主流大模型概览

二、各模型核心亮点

🦙 LLaMA（Meta）

SwiGLU + RMSNorm + RoPE

SwiGLU >> ff 前馈连接层替换 relu，门控机制增强非线性能力，避免神经元死亡，收敛更快，非线性特征信息提取能力+++

RMSNorm >> 层归一化前置，只计算方差不计算均值，去掉了 bias 计算，参数量降一倍

RoPE >> 绝对位置编码➕相对位置编码，通过在 Attention 计算中注意旋转矩阵实现

• 迭代：Llama 1（研究用）→ Llama 2（免费商用）→ Llama 3（405B 超大）
• 核心改进：SwiGLU + RMSNorm + RoPE
• 衍生模型：Alpaca、Vicuna、BELLE、Chinese LLaMA

🇨🇳 ChatGLM（清华）

Prefix-Decoder

本质是利用 decoder 实现 (encoder 中双向注意力机制➕MLM 机制)➕decoder 中单向预测

输入序列 Prefix 前缀部分使用双向注意力➕MLM，预测序列 Generation 使用单向注意力

结合 Bert 双向理解 ➕ GPT 单向生成

• 特点：中英双语，6B 可在消费级显卡运行
• 迭代：GLM-130B → ChatGLM-6B → GLM-4（128K 上下文）
• 技术：Prefix-Decoder（双向注意力）

☁️ Qwen（阿里）

Llama 的 SwiGLU➕RMSNorm➕RPPE

Deepseek 的 MOE 混合专家机制 Plus 版 (激活率 3.7%)➕量化优化

独创的混合注意力机制

• 迭代：Qwen1.5（32K）→ Qwen2（128K）→ Qwen2.5（1M 上下文）→ Qwen3（235B MoE）
• 特色：支持百万 token 上下文，多模态版本 Qwen2.5-VL

🔥 DeepSeek（深度求索）

MLA 多头潜在注意力，利用低秩压缩技术，将模型参数压缩到极致

MOE 混合专家机制，ff 前馈连接层整体分为 N 个专家主导，利用 linear 层加权求和的方式算出专家的得分 logits，利用 softmax 算出专家的权重比例，topk 选择排名靠前的专家进行激活计算，抓重点，专业的事交给专业的部分搞定，大幅节省算力 (激活率 5.5%)

FP8 采用 FP8 精度，量化压缩 50%

RLAIF AI 强化学习，节省人工标注成本，让模型更懂人性，听人话

AI 标注>>有监督微调>>排序实现奖励模型>>PPO 强化学习>>反向促进模型成长

Deepseek Sparse Attention 稀疏注意力机制，抓重点部分做计算，节省半数算力

DSA 是通过 linear 层不断更新参数，不断学习如何筛选更优质的注意力部分

混合专家机制 MOE 专项理解:

混合专家模式 MOE 的意义从来不是像 MLA 或者 DSA 这样直接的节省参数计算量，反而分配多个专家会导致算力消耗翻倍，但是收益确实指数级增长的，利用低算力的成本，敲动高算力成果

处理层级是 ff 前馈连接层，假定 100 个专家，我们给这 100 个专家均配备标准的 ff 层用以反向梯度更新参数，重点是我们提前对输入维度经过 linear 层输出到 100 个 logits(对应 100 个专家),经过 softmax(logtis) 得到相应的专家权重分布比例，经过 topv 可以得到权重靠前的 5 个专家，我们通过激活靠前的 5 个专家来更新他们的参数，从而达到用 5 倍算力撬动 100 倍算力的杠杆效果，激活率 5%

激活专家的方式是通过将专家权重矩阵中不需要计算的专家权重置为 0，来规避他们的更新，同时我们引入惩罚系数，强制模型雨露均沾，避免一些专家饿死，让他们都能得到参数的更新，这就是 deepseek 的负载均衡机制 (惩罚系数)

MoE 源码剖析

# 共享 + 路由专家模型
import torch
import torch.nn as nn
import torch.nn.functional as F

# ===================== 专家网络定义 =====================
class Expert(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super().__init__()
        # 第一层全连接层，将输入维度映射到隐藏层维度
        self.fc1 = nn.Linear(input_dim, hidden_dim)
        # 第二层全连接层，将隐藏层映射到输出维度
        self.fc2 = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        # 先经过第一层并激活
        x = F.relu(self.fc1(x))
        # 再经过第二层输出
        return self.fc2(x)

# ===================== 路由门控网络定义 =====================
class RoutingGate(nn.Module):
    def __init__(self, input_dim, num_routed_experts, k=2):
        super().__init__()
        # 全连接层输出每个专家的分数
        self.fc = nn.Linear(input_dim, num_routed_experts)
        self.k = k  # Top-k，表示每个输入只选择 k 个专家

    def forward(self, x):
        # logits: [batch, num_routed_experts]，每个专家的分数
        logits = self.fc(x)
        # 取 Top-k 分数及其索引
        topk_val, topk_idx = torch.topk(logits, self.k, dim=-1)
        # 对 Top-k 分数做 softmax，得到归一化权重
        weights = F.softmax(topk_val, dim=-1)
        print("weights:", weights)
        # 构造与 logits 同形状的全零权重
        routed_weights = torch.zeros_like(logits)
        # 将 Top-k 权重填入对应位置，其余为 0
        routed_weights.scatter_(-1, topk_idx, weights)
        print("Routed weights:", routed_weights)
        return routed_weights  # [batch, num_routed_experts]

# ===================== MoE 主结构：包含路由专家和共享专家 =====================
class MoEWithRouting(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim, num_routed_experts, num_shared_experts, k=2):
        super().__init__()
        # 路由专家列表，每个专家是一个 Expert 实例
        self.routed_experts = nn.ModuleList(
            [Expert(input_dim, hidden_dim, output_dim) for _ in range(num_routed_experts)]
        )
        # 共享专家列表
        self.shared_experts = nn.ModuleList(
            [Expert(input_dim, hidden_dim, output_dim) for _ in range(num_shared_experts)]
        )
        # 路由门控网络
        self.routing_gate = RoutingGate(input_dim, num_routed_experts, k)
        # 共享专家的权重参数（可学习），初始均分
        self.shared_weights = nn.Parameter(
            torch.ones(num_shared_experts) / num_shared_experts, requires_grad=True
        )

    def forward(self, x):
        # ========== 路由专家部分 ==========
        # 计算每个输入分配到各个路由专家的权重 [batch, num_routed_experts]
        routed_weights = self.routing_gate(x)
        print("routed_weights:", routed_weights)
        # 计算所有路由专家的输出，堆叠成 [batch, output_dim, num_routed_experts]
        routed_outputs = torch.stack(
            [expert(x) for expert in self.routed_experts], dim=2
        )
        print("routed_outputs:", routed_outputs)
        # 按权重加权求和，得到路由专家的最终输出 [batch, output_dim]
        routed_result = torch.sum(routed_weights.unsqueeze(1) * routed_outputs, dim=2)
        print("routed_result:", routed_result)

        # ========== 共享专家部分 ==========
        # 计算所有共享专家的输出，堆叠成 [batch, output_dim, num_shared_experts]
        shared_outputs = torch.stack(
            [expert(x) for expert in self.shared_experts], dim=2
        )
        # 对共享专家权重做 softmax 归一化 [num_shared_experts]
        shared_weights = F.softmax(self.shared_weights, dim=0)
        # 按权重加权求和，得到共享专家的最终输出 [batch, output_dim]
        shared_result = torch.sum(
            shared_weights.unsqueeze(0).unsqueeze(1) * shared_outputs, dim=2
        )

        # ========== 融合输出 ==========
        # 路由专家输出与共享专家输出相加，作为最终输出
        output = routed_result + shared_result
        return output

# ===================== 测试代码 =====================
# 定义各参数
input_dim = 10  # 输入特征维度
hidden_dim = 20  # 专家网络隐藏层维度
output_dim = 5  # 输出特征维度
num_routed_experts = 4  # 路由专家数量
num_shared_experts = 2  # 共享专家数量
k = 2  # Top-k，路由门控每次选择的专家数
seq_len = 8  # 输入序列长度（batch size）

# 实例化模型
model = MoEWithRouting(
    input_dim, hidden_dim, output_dim,
    num_routed_experts, num_shared_experts, k
)

# 构造随机输入
x = torch.randn(seq_len, input_dim)

# 前向传播
output = model(x)

# 打印输出形状和内容
print("Output shape:", output.shape, output)  # [seq_len, output_dim]

数据流转图示

"""
═══════════════════════════════════════════════════════════════
输入数据 x 形状：[8, 10] (batch=8, dim=10)
═══════════════════════════════════════════════════════════════
│ ┌─────────────────┼─────────────────┐ │ │ │ ▼ ▼ ▼ ┌────────┐ ┌────────┐ ┌────────┐ │门控网络│ │路由专家│ │共享专家│ │ │ │ (4 个) │ │ (2 个) │ └────────┘ └────────┘ └────────┘ │ │ │ ▼ ▼ ▼ ┌────────┐ ┌────────────────────────────┐ │[8,4] │ │ 每个专家内部：│ │(权重) │ │ ┌────────────────────────┐ │ └────────┘ │ │ 输入：[8,10] │ │ │ │ │ ↓ │ │ │ │ │ fc1: Linear(10→20) │ │ │ │ │ ↓ │ │ │ │ │ ReLU │ │ │ │ │ ↓ │ │ │ │ │ fc2: Linear(20→5) │ │ │ │ │ ↓ │ │ │ │ │ 输出：[8,5] │ │ │ │ └────────────────────────┘ │ │ │ │ │ │ 4 个专家各自输出：│ │ │ E0: [8,5] │ │ │ E1: [8,5] │ │ │ E2: [8,5] │ │ │ E3: [8,5] │ │ │ ↓ │ │ │ stack(dim=2) │ │ │ ↓ │ │ │ [8,5,4] ←────────────┐ │ │ │ │ │ │ └───────────────────────┼────┘ │ │ ▼ ▼ ┌─────────────────────────────────────────────────┐ │ 路由加权求和：[8,1,4] × [8,5,4] = [8,5,4] │ │ sum(dim=2) → [8,5] │ └─────────────────────────────────────────────────┘ │ ▼ routed_result: [8,5] │ │ ┌────────────────────────────┐ │ │ 共享专家 (2 个): │ │ │ 每个专家内部：│ │ │ 输入：[8,10] │ │ │ ↓ │ │ │ fc1: Linear(10→20) │ │ │ ↓ │ │ │ ReLU │ │ │ ↓ │ │ │ fc2: Linear(20→5) │ │ │ ↓ │ │ │ 输出：[8,5] │ │ │ │ │ │ S0: [8,5] │ │ │ S1: [8,5] │ │ │ ↓ │ │ │ stack(dim=2) │ │ │ ↓ │ │ │ [8,5,2] │ │ └────────────────────────────┘ │ │ │ ▼ │ shared_weights: [2] │ │ │ ▼ │ ┌─────────────────────────────┐ │ │ 共享加权求和：│ │ │ [1,1,2] × [8,5,2] = [8,5,2] │ │ │ sum(dim=2) → [8,5] │ │ └─────────────────────────────┘ │ │ │ ▼ │ shared_result: [8,5] │ │ └──────┬───────┘ ▼ ┌─────────────────────────┐ │ 最终输出 = routed + shared │ │ [8,5] + [8,5] = [8,5] │ └─────────────────────────┘ │ ▼ ════════════════════════════ 最终输出：[8, 5] ════════════════════════════
"""

• 核心技术：
  • MLA（多头潜在注意力）：减少记忆体 30%
  • MoE（混合专家）：671B 总参数，仅激活 37B
  • FP8 混合精度训练：省资源、加速
• 开源协议：MIT（最宽松，可自由商用）

三、硬件配置参考（本地部署）

参数 FP16，两倍打底 推理加三成，全量训练乘六倍 量化降一半，LoRA 省大头，不训练全部参数，只训练'小插件'（低秩矩阵）

主要就是两个途径，1.通过量化压缩显存 2.通过低秩矩阵转换，减少参数量级 (lora)

四、开源协议速查

五、一句话总结

LLaMA 是开源先驱 ChatGLM 中文友好 Qwen 长上下文最强 DeepSeek 架构最创新且协议最宽松。