深入解析ChatGPT神经网络：从Transformer到RLHF的技术演进

1次阅读

共计 2798 个字符，预计需要花费 7 分钟才能阅读完成。

ChatGPT 的出现标志着自然语言处理（NLP）领域的一次重大突破。与传统基于 RNN/LSTM 的模型相比，ChatGPT 采用了 Transformer 架构，解决了长期依赖问题，并显著提升了训练效率。

RNN/LSTM 的局限性：传统循环神经网络存在梯度消失 / 爆炸问题，且无法有效处理长距离依赖关系。虽然 LSTM 有所改善，但训练速度仍然较慢。
Transformer 的优势：通过自注意力机制，Transformer 可以并行处理所有输入 token，同时捕获全局依赖关系，训练效率大幅提升。

graph LR
    A[输入嵌入] --> B[QKV 计算]
    B --> C[注意力分数]
    C --> D[softmax 归一化]
    D --> E[加权求和]
    E --> F[输出]

自注意力机制的核心是通过 Query、Key、Value 三个矩阵计算 token 之间的相关性，然后加权求和得到新的表示。

监督微调（Supervised Fine-Tuning）：使用人工标注的对话数据微调基础模型
奖励建模（Reward Modeling）：训练一个奖励模型来预测人类偏好的输出
强化学习（Reinforcement Learning）：使用 PPO 算法优化模型，使其输出更符合人类偏好

import torch
import torch.nn as nn

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, num_heads):
        super().__init__()
        self.d_model = d_model  # 模型维度
        self.num_heads = num_heads  # 注意力头数
        self.head_dim = d_model // num_heads  # 每个头的维度

        # 线性变换层
        self.Wq = nn.Linear(d_model, d_model)
        self.Wk = nn.Linear(d_model, d_model)
        self.Wv = nn.Linear(d_model, d_model)
        self.Wo = nn.Linear(d_model, d_model)

    def forward(self, x):
        # x 形状: [batch_size, seq_len, d_model]
        batch_size = x.size(0)

        # 计算 Q,K,V [batch_size, num_heads, seq_len, head_dim]
        Q = self.Wq(x).view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2)
        K = self.Wk(x).view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2)
        V = self.Wv(x).view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2)

        # 计算注意力分数 [batch_size, num_heads, seq_len, seq_len]
        scores = torch.matmul(Q, K.transpose(-2, -1)) / torch.sqrt(torch.tensor(self.head_dim))
        attention = torch.softmax(scores, dim=-1)

        # 加权求和 [batch_size, num_heads, seq_len, head_dim]
        output = torch.matmul(attention, V)

        # 合并多头 [batch_size, seq_len, d_model]
        output = output.transpose(1, 2).contiguous().view(batch_size, -1, self.d_model)
        return self.Wo(output)

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# 加载预训练模型
tokenizer = AutoTokenizer.from_pretrained("gpt2")
model = AutoModelForCausalLM.from_pretrained("gpt2")

# 准备微调数据
texts = ["Hello, how are you?", "What's your name?"]
inputs = tokenizer(texts, return_tensors="pt", padding=True, truncation=True)

# 微调训练循环
optimizer = torch.optim.AdamW(model.parameters(), lr=5e-5)
for epoch in range(3):
    outputs = model(**inputs, labels=inputs["input_ids"])
    loss = outputs.loss
    loss.backward()
    optimizer.step()
    optimizer.zero_grad()
    print(f"Epoch {epoch}, Loss: {loss.item()}")