1. 模型的本质是什么？
模型 = 一个数学函数 + 一堆参数（权重）
最简单的例子：线性回归
y = w * x + b
- w和b就是"参数"（也叫权重）
- 训练就是找到最好的w和b，让预测值y尽量接近真实值
神经网络就是把很多这样的函数叠加起来：
第1层: h1 = w1 * x + b1
第2层: h2 = w2 * h1 + b2
第3层: h3 = w3 * h2 + b3
...
输出层: y = wn * hn-1 + bn用代码理解：
# 一个最简单的"模型"
class SimpleModel:
def __init__(self):
# 这些就是"参数"，初始是随机的
self.w1 = random() # 比如 0.5
self.w2 = random() # 比如 0.3
self.b = random() # 比如 0.1
def forward(self, x):
# 这就是"前向传播"，用参数计算输出
return self.w1 * x + self.w2 * x**2 + self.b
# 模型就是：结构（forward函数）+ 参数（w1, w2, b）
# 保存模型 = 保存这些参数的值2. 训练的本质是什么？
训练 = 不断调整参数，让模型的输出越来越接近正确答案
┌─────────────────────────────────────────────────────────────┐
│ 第1步：随机初始化参数 │
│ w = 0.5, b = 0.1（瞎猜的） │
└─────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────┐
│ 第2步：前向传播（用当前参数计算预测值） │
│ 输入x=2，预测 y_pred = 0.5*2 + 0.1 = 1.1 │
│ 真实答案 y_true = 3.0 │
└─────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────┐
│ 第3步：计算损失（预测值和真实值差多远） │
│ loss = (y_pred - y_true)² = (1.1 - 3.0)² = 3.61 │
│ loss越大，说明预测越差 │
└─────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────┐
│ 第4步：反向传播（计算每个参数对loss的影响） │
│ 求导：∂loss/∂w = ? ∂loss/∂b = ? │
│ 这一步是PyTorch/TensorFlow自动帮你算的 │
└─────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────┐
│ 第5步：更新参数（让loss变小） │
│ w_new = w_old - learning_rate * ∂loss/∂w │
│ b_new = b_old - learning_rate * ∂loss/∂b │
│ 这就是"梯度下降" │
└─────────────────────────────────────────────────────────────┘
↓
重复第2-5步，直到loss足够小用代码理解：
# 完整的训练循环
model = SimpleModel()
optimizer = SGD(model.parameters(), lr=0.01) # 优化器，lr就是learning_rate
for epoch in range(100): # 训练100轮
for x, y_true in training_data:
# 第2步：前向传播
y_pred = model.forward(x)
# 第3步：计算损失
loss = (y_pred - y_true) ** 2
# 第4步：反向传播（PyTorch自动算梯度）
loss.backward()
# 第5步：更新参数
optimizer.step()
optimizer.zero_grad()
print(f"Epoch {epoch}, Loss: {loss}")
# Loss会越来越小：3.61 → 2.1 → 0.8 → 0.2 → 0.05 → ...3. ResNet-50是什么？
ResNet-50 = 一个有50层的神经网络结构
"结构"是什么意思？就是定义了：
- 有多少层
- 每层有多少个神经元
- 层与层之间怎么连接
ResNet的特点是有"残差连接"（跳跃连接），解决深层网络难训练的问题
┌─────┐ ┌─────┐ ┌─────┐
│第1层│ ──→ │第2层│ ──→ │第3层│ ──→ ...
└─────┘ └─────┘ └─────┘
↑ │
└────────────┘ ← 这就是"残差连接"，让梯度能直接传过去ResNet-50的参数量：约2500万个参数
# ResNet-50的结构（简化版）
class ResNet50:
def __init__(self):
self.conv1 = Conv2d(...) # 第1层，有若干参数
self.conv2 = Conv2d(...) # 第2层
self.conv3 = Conv2d(...) # 第3层
# ... 一共50层
self.fc = Linear(2048, 1000) # 最后一层，输出1000类
# 总共约2500万个参数（w和b）4. 预训练权重是什么？
预训练权重 = 别人已经训练好的参数值
ImageNet是一个超大数据集：
- 1400万张图片
- 1000个类别（猫、狗、汽车、飞机...）
有人（Google/Facebook）用这个数据集训练了ResNet-50：
- 花了几周时间
- 用了几十张GPU
- 得到了一组很好的参数值
这组参数就是"预训练权重"，可以下载使用预训练权重文件长什么样？
# 预训练权重就是一个字典，存储每一层的参数值
pretrained_weights = {
"conv1.weight": [[0.23, 0.45, ...], [0.12, 0.67, ...], ...], # 第1层的w
"conv1.bias": [0.01, 0.02, ...], # 第1层的b
"conv2.weight": [[...], [...], ...], # 第2层的w
"conv2.bias": [...], # 第2层的b
# ... 所有层的参数
}
# 保存成文件：resnet50-imagenet.pth（约100MB）5. 迁移学习是什么意思？
迁移学习 = 借用别人训练好的参数，在自己的数据上微调
为什么能迁移？
- 神经网络的前面几层学到的是"通用特征"：边缘、纹理、形状
- 这些特征对所有图像任务都有用
- 只需要调整最后几层，适应你的具体任务
打个比方：
- 预训练 = 学会了"看图的基本能力"（识别边缘、颜色、形状）
- 迁移学习 = 用这个能力去做"垃圾分类"这个具体任务迁移学习的代码：
from torchvision.models import resnet50, ResNet50_Weights
# ========== 方法1：从头训练（不用预训练权重）==========
model = resnet50(weights=None) # 随机初始化参数
# 需要大量数据 + 很长时间才能训练好
# ========== 方法2：迁移学习（用预训练权重）==========
# 第1步：加载预训练权重
model = resnet50(weights=ResNet50_Weights.IMAGENET1K_V1)
# 现在model的参数已经是ImageNet上训练好的值了
# 第2步：冻结前面的层（不训练，保持原样）
for param in model.parameters():
param.requires_grad = False # 冻结，不更新
# 第3步：替换最后一层（适应你的任务）
# 原来：输出1000类（ImageNet的类别数）
# 现在：输出4类（垃圾分类：可回收、有害、厨余、其他）
model.fc = nn.Linear(2048, 4) # 只有这一层需要训练
# 第4步：只训练最后一层
optimizer = SGD(model.fc.parameters(), lr=0.001) # 只优化fc层
# 这样训练很快，因为只需要调整最后一层的参数！迁移学习的效果对比：
| 方法 | 需要数据量 | 训练时间 | 准确率 |
|---|---|---|---|
| 从头训练 | 100万+ | 几天 | 可能很差 |
| 迁移学习 | 几万 | 几小时 | 很好 |
6. 训练集、验证集、测试集是干嘛的？
这是防止"作弊"的机制
想象一个学生准备考试：
- 训练集 = 平时做的练习题（可以反复做，知道答案）
- 验证集 = 模拟考试（检验学习效果，调整学习方法）
- 测试集 = 正式考试（最终评估，只考一次）
如果用练习题的成绩来评价学生，不公平！
因为他可能把题目背下来了，但不会举一反三具体作用：
# 数据划分：80%训练，10%验证，10%测试
all_data = load_data() # 2.9万张图片
train_data = all_data[:23200] # 训练集：2.32万
val_data = all_data[23200:26100] # 验证集：0.29万
test_data = all_data[26100:] # 测试集：0.29万
# 训练过程
for epoch in range(50):
# 1. 在训练集上训练
model.train()
for x, y in train_data:
loss = compute_loss(model(x), y)
loss.backward()
optimizer.step()
# 2. 在验证集上评估（不训练，只看效果）
model.eval()
val_accuracy = evaluate(model, val_data)
print(f"Epoch {epoch}, 验证集准确率: {val_accuracy}")
# 3. 根据验证集效果调整策略
if val_accuracy < last_accuracy:
# 验证集效果变差了，可能过拟合了
# 可以早停、调学习率、加正则化等
learning_rate *= 0.1
# 训练完成后，在测试集上最终评估
test_accuracy = evaluate(model, test_data)
print(f"最终测试集准确率: {test_accuracy}") # 这个数字才能对外说为什么要分开？
问题：过拟合 = 模型把训练数据"背下来"了，但不会泛化
例子：
训练集准确率: 99%（练习题全对）
测试集准确率: 60%（考试不及格）
这说明模型没有真正"学会"，只是记住了训练数据
验证集的作用：
在训练过程中监控模型的"泛化能力"
如果验证集准确率开始下降，就该停止训练了（早停）
测试集的作用：
最终评估模型效果，这个数字才能写进论文/简历
注意：测试集只能用一次！不能用它来调参数7. 保存模型保存的是什么？
保存模型 = 保存所有参数的值
模型文件里存的就是一个字典：
{
"layer1.weight": tensor([[0.23, 0.45, ...], ...]),
"layer1.bias": tensor([0.01, 0.02, ...]),
"layer2.weight": tensor([[...], ...]),
...
}
这些数字就是训练完成后每个参数的最优值代码演示：
# ========== 保存模型 ==========
# 方法1：只保存参数（推荐）
torch.save(model.state_dict(), "model_weights.pth")
# 文件大小约100MB（取决于模型参数量）
# 方法2：保存整个模型（包括结构和参数）
torch.save(model, "model_full.pth")
# ========== 加载模型 ==========
# 方法1：先定义结构，再加载参数
model = ResNet50() # 先创建模型结构
model.load_state_dict(torch.load("model_weights.pth")) # 再加载参数
# 现在model的参数就是训练好的值了
# 方法2：直接加载整个模型
model = torch.load("model_full.pth")
# ========== 使用模型 ==========
model.eval() # 切换到评估模式
image = load_image("垃圾.jpg")
prediction = model(image) # 输出：[0.1, 0.8, 0.05, 0.05] → 有害垃圾8. 参数为什么有用？
参数 = 模型从数据中学到的"知识"
训练前：
参数是随机的 → 输入垃圾图片 → 输出随机猜测
训练后：
参数被调整过 → 输入垃圾图片 → 输出正确分类
参数的值"编码"了：
- 什么样的边缘特征代表塑料瓶
- 什么样的颜色特征代表厨余垃圾
- 什么样的形状特征代表电池
这些知识就存储在那2500万个参数里直观理解：
想象参数是"决策规则"：
if 参数w1 > 0.5 and 边缘特征 == 圆形:
可能是塑料瓶
if 参数w2 > 0.3 and 颜色特征 == 绿色:
可能是厨余垃圾
...
实际的神经网络更复杂，但本质就是用参数组合特征做决策
训练就是找到最好的参数组合