MNIST 实战:把第一、二部分跑起来

MnistData mnist_data;
mnist_data.LoadMnistData(train_image, train_label,
                         test_image,  test_label);   1

// 每张图 = 784 个已归一化到 [0,1] 的像素
int N_train = mnist_data.train_data().size();

// 把标签数字变成 one-hot: 数字 d -> 第 d 位为 1
vector<vector<double>> train_target(N_train, vector<double>(10, 0.0));
for (int i = 0; i < N_train; i++)
  train_target[i][ mnist_data.train_labels()[i] ] = 1.0;   2

1. 一次性把 6 万张训练图 + 1 万张测试图读进来。像素在 mnist_data.h 里就已经除以 255 归一化好了——这一步很重要,不然大数值会让训练很难收敛(第 9 章)。
2. 把每个标签数字翻译成 10 维 one-hot。train_target[i] 就是第 i 张图的“正确答案分布”,交给第 4 章的交叉熵去比对。

NeuralNetwork demo_network;
demo_network.Init(vector<int>{784, 128, 64, 10});          1

demo_network.set_random_seed(42);                          2
demo_network.set_param_init_function(PARAM_INIT_HE);       3
demo_network.set_activate_function(ACTIVATE_RELU);         4
demo_network.set_softmax_function(SOFTMAX_STD);            5
demo_network.set_loss_function(LOSS_CROSS_ENTROPY);        6
demo_network.set_optimizer_function(OPTIMIZER_ADAM);       7

1. 网络结构(第 3 章):输入 784,两个隐藏层 128、64,输出 10。数据会一层层向前流动。
2. 固定随机种子:让每次运行的初始旋钮一样,结果可复现(方便调试)。
3. He 初始化(第 9 章):给旋钮一个合适的随机起点。搭配 ReLU 的标配,避免一开始就“信号消失”。
4. 激活函数 ReLU(第 2 章):每个神经元加权求和之后过一道 ReLU,给网络“掰弯”的非线性能力。
5. softmax(第 4 章):把输出层的 10 个分数变成加起来为 1 的概率。
6. 交叉熵损失(第 4 章):衡量“预测的概率分布”和 one-hot 答案差多少——分类任务的黄金搭档。
7. 优化器 Adam(第 8 章):决定拿到梯度后“怎么拧旋钮”,比朴素 SGD 收敛更快更稳。

int batch_size = 64, epochs = 5;
int steps_per_epoch = (N_train + batch_size - 1) / batch_size;
int total_steps = epochs * steps_per_epoch;
int warmup_steps = steps_per_epoch;      // 用 1 个 epoch 热身   1

demo_network.set_lr_scheduler(std::make_shared<WarmupCosineLR>(
    base_lr, warmup_steps, total_steps, min_lr));                2

1. step 的定义(第 5、9 章):一个 batch 更新一次参数叫一 step;跑完一遍全部数据(steps_per_epoch 步)叫一个 epoch。这里 batch=64、训练 5 个 epoch。
2. 把调度器挂到网络上,训练时每一步都会先问它“这一步该用多大的学习率”,再更新参数。

auto each_step = [&](NeuralNetwork &net, int step, bool &) {
  // 只在每个 epoch 末算一次 loss / 准确率, 打印出来
  double test_loss = 0;
  net.CalcLoss(test_data, test_target, test_loss);
  double acc = Accuracy(net, test_data, test_labels);       1
  cout << "epoch ... test_acc=" << acc << endl;
};

demo_network.Train(train_data, train_target,
                   each_step, total_steps, batch_size, base_lr);  2

1. 回调里顺便调 CalcLoss 看损失、调下面的 Accuracy 看准确率,让你亲眼看到它俩一个降、一个升。
2. 核心就这一句。下面这张图拆开它每一步在做什么。

net.PredictBatch(x, pred);          // 一次前向一大批, 比逐张快   1
int correct = 0;
for (int i = 0; i < pred.size(); i++) {
  int pi = argmax(pred[i]);         // 概率最高的那个数字         2
  if (pi == labels[i]) correct++;
}
return correct * 1.0 / pred.size();                              3

1. PredictBatch 就是第 3 章的前向传播,只是一次算一整批(一个大矩阵乘法),比循环逐张调 Predict 快得多。
2. argmax:10 个概率里选最大的下标。这个下标就是模型“猜的数字”。
3. 对的张数 / 总张数 = 准确率。跑完 5 个 epoch,你会看到测试准确率稳定在 97%~98%。

NeuralNetwork::NetworkParam param;
NeuralNetwork::NetworkOption option;
demo_network.ExportNetworkParam(param, option);                 1
NeuralNetworkLoader::ExportParamToFile(param, option, "demo.v2.param");

1. 把网络里的层大小、权重、偏置全部序列化成一个二进制文件。第 19 章那个语言模型也是同样的套路存模型。