前置知识速览
概述
本章为零基础或跨领域读者提供快速的知识补充，帮助理解后续章节的核心概念。
深度学习基础
神经网络基本概念
┌─────────────────────────────────────────────────────────────────────────────┐
│ 神经网络基本结构 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ 输入层 隐藏层 隐藏层 输出层 │
│ │
│ ○ ○ ○ ○ │
│ │╲ ╱│╲ ╱│╲ ╱│ │
│ ○──────────────○────────────────○──────────────○ │
│ │╱ ╲│╱ ╲│╱ ╲│ │
│ ○ ○ ○ ○ │
│ │
│ x1, x2, ... h1 h2 y │
│ │
│ 前向传播: y = f(W2 × f(W1 × x + b1) + b2) │
│ 反向传播: 计算损失对每个参数的梯度 │
│ 优化: 使用梯度下降更新参数 W = W - lr × ∇W │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
核心概念:
• 张量 (Tensor): 多维数组，神经网络的基本数据结构
• 层 (Layer): 一组参数和计算操作
• 损失函数 (Loss): 衡量预测与真实值的差距
• 优化器 (Optimizer): SGD, Adam 等更新参数的算法
• 批次 (Batch): 一次处理多个样本，提高效率
Transformer 架构
┌─────────────────────────────────────────────────────────────────────────────┐
│ Transformer 架构 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────┐ │
│ │ Output Probs │ │
│ └───────────┬─────────────┘ │
│ │ │
│ ┌───────────┴─────────────┐ │
│ │ Linear + Softmax │ │
│ └───────────┬─────────────┘ │
│ │ │
│ ┌───────────┴─────────────┐ │
│ ╔══│ Transformer Block │══╗ × N 层 │
│ ║ │ │ ║ │
│ ║ │ ┌─────────────────┐ │ ║ │
│ ║ │ │ Layer Norm │ │ ║ │
│ ║ │ └────────┬────────┘ │ ║ │
│ ║ │ │ │ ║ │
│ ║ │ ┌────────┴────────┐ │ ║ │
│ ║ │ │ Feed Forward │◀───┤──╫─── 残差连接 │
│ ║ │ │ (FFN) │ │ ║ │
│ ║ │ └────────┬────────┘ │ ║ │
│ ║ │ │ │ ║ │
│ ║ │ ┌────────┴────────┐ │ ║ │
│ ║ │ │ Layer Norm │ │ ║ │
│ ║ │ └────────┬────────┘ │ ║ │
│ ║ │ │ │ ║ │
│ ║ │ ┌────────┴────────┐ │ ║ │
│ ║ │ │ Multi-Head │◀───┤──╫─── 残差连接 │
│ ║ │ │ Attention │ │ ║ │
│ ║ │ └─────────────────┘ │ ║ │
│ ╚══└─────────────────────────┘══╝ │
│ │ │
│ ┌───────────┴─────────────┐ │
│ │ Positional Encoding │ │
│ └───────────┬─────────────┘ │
│ │ │
│ ┌───────────┴─────────────┐ │
│ │ Embedding │ │
│ └───────────┬─────────────┘ │
│ │ │
│ ┌───────────┴─────────────┐ │
│ │ Input Tokens │ │
│ └─────────────────────────┘ │
│ │
│ 注意力机制: │
│ Attention(Q, K, V) = softmax(Q × K^T / √d) × V │
│ │
│ 多头注意力: 并行计算多个注意力，捕获不同特征 │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
大语言模型 (LLM)
LLM 核心概念:
1. 自回归生成
输入: "今天天气"
模型: P(下一个词 | 已有词) → "很" → "好" → "。"
输出: "今天天气很好。"
2. 模型规模
┌────────────────────────────────────────────────────┐
│ 模型 │ 参数量 │ 显存需求(FP16) │ 训练成本 │
├────────────────────────────────────────────────────┤
│ GPT-2 │ 1.5B │ ~3GB │ ~$50K │
│ LLaMA-7B │ 7B │ ~14GB │ ~$200K │
│ LLaMA-70B │ 70B │ ~140GB │ ~$2M │
│ GPT-4 │ ~1.8T? │ ~3.6TB │ ~$100M │
└────────────────────────────────────────────────────┘
3. 训练阶段
预训练 (Pre-training): 大规模无标注数据，学习语言知识
↓
指令微调 (Instruction Tuning): 有标注数据，学习遵循指令
↓
人类反馈强化学习 (RLHF): 人类偏好对齐
GPU 基础
GPU vs CPU
┌─────────────────────────────────────────────────────────────────────────────┐
│ GPU vs CPU 架构对比 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ CPU (Central Processing Unit) │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ ┌───────────────────────────────────────────────────────────────┐ │ │
│ │ │ Control Unit │ │ │
│ │ └───────────────────────────────────────────────────────────────┘ │ │
│ │ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ │ │
│ │ │Core │ │Core │ │Core │ │Core │ 4-64 个强大的核心 │ │
│ │ │ ALU │ │ ALU │ │ ALU │ │ ALU │ │ │
│ │ └─────┘ └─────┘ └─────┘ └─────┘ │ │
│ │ ┌───────────────────────────────────────────────────────────────┐ │ │
│ │ │ Large L3 Cache (MB级) │ │ │
│ │ └───────────────────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ 特点: 复杂控制逻辑，大缓存，适合串行复杂任务 │
│ │
│ GPU (Graphics Processing Unit) │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ ┌───┐┌───┐┌───┐┌───┐┌───┐┌───┐┌───┐┌───┐┌───┐┌───┐┌───┐┌───┐ │ │
│ │ │ALU││ALU││ALU││ALU││ALU││ALU││ALU││ALU││ALU││ALU││ALU││ALU│ │ │
│ │ └───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘ │ │
│ │ ┌───┐┌───┐┌───┐┌───┐┌───┐┌───┐┌───┐┌───┐┌───┐┌───┐┌───┐┌───┐ │ │
│ │ │ALU││ALU││ALU││ALU││ALU││ALU││ALU││ALU││ALU││ALU││ALU││ALU│ │ │
│ │ └───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘ │ │
│ │ ... 成千上万个小核心 (CUDA Cores / Tensor Cores) │ │
│ │ ┌───────────────────────────────────────────────────────────────┐ │ │
│ │ │ High Bandwidth Memory (GB级) │ │ │
│ │ └───────────────────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ 特点: 简单控制，大量核心，高带宽，适合并行计算 │
│ │
│ 性能对比 (矩阵乘法): │
│ ┌────────────────────────────────────────────────────────────────────┐ │
│ │ 设备 │ TFLOPS (FP32) │ 内存带宽 │ 矩阵乘法加速比 │ │
│ ├────────────────────────────────────────────────────────────────────┤ │
│ │ Intel i9-13900K │ ~1 TFLOPS │ ~90 GB/s │ 1x (基准) │ │
│ │ NVIDIA RTX 4090 │ ~83 TFLOPS │ ~1 TB/s │ ~50-100x │ │
│ │ NVIDIA A100 │ ~312 TFLOPS │ ~2 TB/s │ ~200-300x │ │
│ │ NVIDIA H100 │ ~990 TFLOPS │ ~3.35 TB/s │ ~500-1000x │ │
│ └────────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
GPU 内存层次
GPU 内存层次 (以 A100 为例):
┌─────────────────────────────────────────────────────────────────────────────┐
│ │
│ ┌──────────────────────────┐ │
│ Registers │ 256KB/SM × 108 SM │ ~19 TB/s │
│ 寄存器 │ 每个线程私有 │ 最快 │
│ └────────────┬─────────────┘ │
│ │ │
│ ┌────────────▼─────────────┐ │
│ Shared Memory │ 164KB/SM │ ~19 TB/s │
│ 共享内存 │ 同一线程块共享 │ 块内通信 │
│ └────────────┬─────────────┘ │
│ │ │
│ ┌────────────▼─────────────┐ │
│ L2 Cache │ 40 MB │ ~5 TB/s │
│ 二级缓存 │ 全局共享 │ 缓存全局内存 │
│ └────────────┬─────────────┘ │
│ │ │
│ ┌────────────▼─────────────┐ │
│ HBM (Global) │ 80 GB │ 2 TB/s │
│ 全局内存 │ 所有 SM 可访问 │ 容量最大 │
│ └────────────┬─────────────┘ │
│ │ │
│ ┌────────────▼─────────────┐ │
│ Host Memory │ 系统内存 (CPU) │ ~25 GB/s (PCIe) │
│ 主机内存 │ 通过 PCIe 传输 │ 最慢 │
│ └──────────────────────────┘ │
│ │
│ 优化原则: │
│ 1. 尽量使用寄存器和共享内存 │
│ 2. 合并全局内存访问 (Coalesced Access) │
│ 3. 减少 CPU-GPU 数据传输 │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
分布式系统基础
分布式训练概念
为什么需要分布式训练?
问题:
• 模型太大，单卡放不下 (GPT-4 需要 ~3TB 显存)
• 训练太慢，需要加速 (单卡训练 LLaMA 需要数年)
• 数据太多，需要并行处理
解决方案:
1. 数据并行 (Data Parallelism)
┌─────────────────────────────────────────────────────────────────────────┐
│ │
│ 数据集 │
│ │ │
│ ▼ │
│ ┌────────────┬────────────┬────────────┬────────────┐ │
│ │ Batch 1 │ Batch 2 │ Batch 3 │ Batch 4 │ │
│ └─────┬──────┴─────┬──────┴─────┬──────┴─────┬──────┘ │
│ ▼ ▼ ▼ ▼ │
│ GPU 0 GPU 1 GPU 2 GPU 3 │
│ (完整模型) (完整模型) (完整模型) (完整模型) │
│ │ │ │ │ │
│ └────────────┴─────┬──────┴────────────┘ │
│ ▼ │
│ AllReduce │
│ (梯度同步) │
│ │
│ 特点: 每个 GPU 有完整模型，处理不同数据 │
│ 适用: 模型能放进单卡 │
└─────────────────────────────────────────────────────────────────────────┘
2. 模型并行 (Model Parallelism)
┌─────────────────────────────────────────────────────────────────────────┐
│ │
│ 张量并行 (Tensor Parallel) 流水线并行 (Pipeline Parallel) │
│ │
│ ┌─────────────────────┐ ┌──────────────────────────┐ │
│ │ 一个矩阵 │ │ Layer 1-10 (GPU 0) │ │
│ │ ┌─────┬─────┐ │ ├──────────────────────────┤ │
│ │ │GPU 0│GPU 1│ │ │ Layer 11-20 (GPU 1) │ │
│ │ ├─────┼─────┤ │ ├──────────────────────────┤ │
│ │ │GPU 2│GPU 3│ │ │ Layer 21-30 (GPU 2) │ │
│ │ └─────┴─────┘ │ ├──────────────────────────┤ │
│ └─────────────────────┘ │ Layer 31-40 (GPU 3) │ │
│ └──────────────────────────┘ │
│ 特点: 切分单个层的计算 特点: 切分不同的层 │
│ 适用: 单层太大 适用: 层数很多 │
└─────────────────────────────────────────────────────────────────────────┘
3. 混合并行
大规模训练通常组合使用: DP + TP + PP
集合通信
常用集合通信操作:
1. Broadcast (广播)
GPU 0: [A, B, C, D] ──┐
GPU 1: [_, _, _, _] │ GPU 0: [A, B, C, D]
GPU 2: [_, _, _, _] ──┼──▶ GPU 1: [A, B, C, D]
GPU 3: [_, _, _, _] │ GPU 2: [A, B, C, D]
└ GPU 3: [A, B, C, D]
2. AllReduce (全规约)
GPU 0: [A0] GPU 0: [A0+A1+A2+A3]
GPU 1: [A1] ──▶ GPU 1: [A0+A1+A2+A3]
GPU 2: [A2] GPU 2: [A0+A1+A2+A3]
GPU 3: [A3] GPU 3: [A0+A1+A2+A3]
应用: 分布式训练梯度同步
3. AllGather (全收集)
GPU 0: [A] GPU 0: [A, B, C, D]
GPU 1: [B] ──▶ GPU 1: [A, B, C, D]
GPU 2: [C] GPU 2: [A, B, C, D]
GPU 3: [D] GPU 3: [A, B, C, D]
4. ReduceScatter (规约分发)
GPU 0: [A0,B0,C0,D0] GPU 0: [sum(A)]
GPU 1: [A1,B1,C1,D1] ──▶ GPU 1: [sum(B)]
GPU 2: [A2,B2,C2,D2] GPU 2: [sum(C)]
GPU 3: [A3,B3,C3,D3] GPU 3: [sum(D)]
Kubernetes 基础
核心概念
Kubernetes 核心对象:
┌─────────────────────────────────────────────────────────────────────────────┐
│ │
│ Pod (基本调度单元) │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ ┌───────────────┐ ┌───────────────┐ │ │
│ │ │ Container 1 │ │ Container 2 │ 共享网络和存储 │ │
│ │ │ (Python App) │ │ (Sidecar) │ │ │
│ │ └───────────────┘ └───────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ │
│ Deployment (管理 Pod 副本) │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ replicas: 3 │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │
│ │ │ Pod 1 │ │ Pod 2 │ │ Pod 3 │ 自动扩缩容、滚动更新 │ │
│ │ └─────────┘ └─────────┘ └─────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ │
│ Service (服务发现和负载均衡) │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 客户端 ──▶ Service (ClusterIP) ──┬──▶ Pod 1 │ │
│ │ ├──▶ Pod 2 │ │
│ │ └──▶ Pod 3 │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ │
│ Node (工作节点) │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ ┌──────────────────────────────────────────────────────────────┐ │ │
│ │ │ kubelet │ 运行容器、管理 Pod │ │ │
│ │ │ kube-proxy │ 网络代理 │ │ │
│ │ │ 容器运行时 │ Docker / containerd │ │ │
│ │ └──────────────────────────────────────────────────────────────┘ │ │
│ │ 资源: CPU, Memory, GPU (nvidia.com/gpu) │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
GPU 资源管理
# 请求 GPU 资源的 Pod 示例
apiVersion: v1
kind: Pod
metadata:
name: gpu-pod
spec:
containers:
- name: cuda-container
image: nvidia/cuda:12.0-base
resources:
limits:
nvidia.com/gpu: 2 # 请求 2 个 GPU
requests:
memory: "16Gi"
cpu: "4"
Python 与 PyTorch 快速入门
基础代码模式
"""
PyTorch 基础模式
"""
import torch
import torch.nn as nn
import torch.optim as optim
# 1. 定义模型
class SimpleNet(nn.Module):
def __init__(self, input_size, hidden_size, output_size):
super().__init__()
self.fc1 = nn.Linear(input_size, hidden_size)
self.relu = nn.ReLU()
self.fc2 = nn.Linear(hidden_size, output_size)
def forward(self, x):
x = self.fc1(x)
x = self.relu(x)
x = self.fc2(x)
return x
# 2. 创建模型和优化器
model = SimpleNet(784, 256, 10)
optimizer = optim.Adam(model.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss()
# 3. 训练循环
def train_step(data, target):
optimizer.zero_grad() # 清空梯度
output = model(data) # 前向传播
loss = criterion(output, target) # 计算损失
loss.backward() # 反向传播
optimizer.step() # 更新参数
return loss.item()
# 4. GPU 使用
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)
data = data.to(device)
# 5. 分布式训练 (基础)
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP
# 初始化分布式环境
dist.init_process_group(backend="nccl")
local_rank = int(os.environ["LOCAL_RANK"])
model = model.to(local_rank)
model = DDP(model, device_ids=[local_rank])
常用命令速查
# Docker 相关
docker build -t myimage . # 构建镜像
docker run --gpus all myimage # 运行 GPU 容器
docker ps # 查看运行中的容器
# Kubernetes 相关
kubectl get pods # 查看 Pod
kubectl describe pod <name> # 查看 Pod 详情
kubectl logs <pod-name> # 查看日志
kubectl apply -f deployment.yaml # 应用配置
# GPU 相关
nvidia-smi # 查看 GPU 状态
nvidia-smi topo -m # 查看 GPU 拓扑
watch -n 1 nvidia-smi # 实时监控 GPU
# PyTorch 相关
torch.cuda.is_available() # 检查 CUDA 可用
torch.cuda.device_count() # GPU 数量
torch.cuda.memory_summary() # 显存使用详情
# 分布式训练启动
torchrun --nproc_per_node=4 train.py # 单机多卡
torchrun --nnodes=2 --nproc_per_node=4 \ # 多机多卡
--node_rank=0 --master_addr=... train.py
推荐学习资源
在线教程
书籍推荐
- 《深度学习》(花书) - 理论基础
- 《动手学深度学习》- 实践入门
- 《Kubernetes in Action》- K8s 实战
视频课程
- Stanford CS231n (计算机视觉)
- Stanford CS224n (NLP)
- NVIDIA DLI (深度学习学院)
下一步
完成基础知识后，推荐从以下章节开始深入：