深度学习的 Hello World : 一文读懂什么是 MNIST 的经典入门

final int numRows = 28;  // 图片的行数，MNIST 图片是 28x28 像素
final int numColumns = 28;  // 图片的列数
int outputNum = 10;  // 输出的类别数，数字 0 到 9 共 10 类
int batchSize = 128;  // 每个批次的样本数，控制每次训练时网络处理的数据量
int rngSeed = 123;  // 随机数种子，确保每次训练得到的初始权重一致，便于复现结果
int numEpochs = 15;  // 训练的轮次，定义神经网络将遍历数据集的次数

DataSetIterator mnistTrain = new MnistDataSetIterator(batchSize, true, rngSeed);
DataSetIterator mnistTest = new MnistDataSetIterator(batchSize, false, rngSeed);

public static void main(String[] args) throws Exception {
    // 定义输入图片的行和列（每张图片的大小为 28x28）
    final int numRows = 28;
    final int numColumns = 28;
    
    // 输出类别数量（MNIST 数据集包含数字 0 到 9，共 10 类）
    int outputNum = 10;
    
    // 每次训练时处理的批量样本数
    int batchSize = 128;
    
    // 随机数种子，用于确保结果的可重复性
    int rngSeed = 123;
    
    // 训练的总周期数
    int numEpochs = 15;

    // 获取训练集和测试集的数据迭代器
    DataSetIterator mnistTrain = new MnistDataSetIterator(batchSize, true, rngSeed);
    DataSetIterator mnistTest = new MnistDataSetIterator(batchSize, false, rngSeed);

    log.info("构建模型....");
    
    // 配置神经网络的架构
    MultiLayerConfiguration conf = new NeuralNetConfiguration.Builder()
            .seed(rngSeed)  // 设置随机种子，确保训练结果可重复
            .updater(new Nesterovs(0.006, 0.9))  // 使用 Nesterov 动量优化器，学习率为 0.006，动量为 0.9
            .l2(1e-4)  // 使用 L2 正则化，防止过拟合
            .list()  // 开始定义网络的层次
            .layer(new DenseLayer.Builder()  // 第一层：全连接层（输入层）
                    .nIn(numRows * numColumns)  // 输入层节点数：28x28 的图片展平为 784 个输入节点
                    .nOut(1000)  // 隐藏层节点数：设定为 1000
                    .activation(Activation.RELU)  // 激活函数：ReLU
                    .weightInit(WeightInit.XAVIER)  // 权重初始化方法：Xavier 初始化
                    .build())
            .layer(new OutputLayer.Builder(LossFunction.NEGATIVELOGLIKELIHOOD)  // 第二层：输出层
                    .nIn(1000)  // 输入节点数：1000 个隐藏层节点
                    .nOut(outputNum)  // 输出节点数：10 个类别（对应数字 0-9）
                    .activation(Activation.SOFTMAX)  // 激活函数：Softmax，用于多类分类
                    .weightInit(WeightInit.XAVIER)  // 权重初始化方法：Xavier 初始化
                    .build())
            .build();  // 构建模型配置

    // 创建神经网络模型
    MultiLayerNetwork model = new MultiLayerNetwork(conf);
    model.init();  // 初始化模型
    
    // 设置训练过程中每一轮的得分输出，1 表示每完成 1 次迭代输出一次得分
    model.setListeners(new ScoreIterationListener(1));

    log.info("开始训练模型....");
    
    // 使用训练数据集训练模型，训练 15 个 epoch（训练周期）
    model.fit(mnistTrain, numEpochs);

    log.info("评估模型....");
    
    // 使用测试数据集评估训练好的模型
    Evaluation eval = model.evaluate(mnistTest);
    log.info(eval.stats());  // 输出评估结果，包括准确率、精确率等指标

    log.info("****************示例完成********************");
}

MultiLayerNetwork model = new MultiLayerNetwork(conf);
model.init();  // 初始化模型

// 开始训练
model.fit(mnistTrain, numEpochs);  // 训练 15 个周期

// 使用测试数据集评估训练好的模型
Evaluation eval = model.evaluate(mnistTest);
log.info(eval.stats());  // 输出评估结果，包括准确率、精确率等指标

 # of classes:    10
 Accuracy:        0.9723
 Precision:       0.9723
 Recall:          0.9720
 F1 Score:        0.9721
Precision, recall & F1: macro-averaged (equally weighted avg. of 10 classes)


=========================Confusion Matrix=========================
    0    1    2    3    4    5    6    7    8    9
---------------------------------------------------
  966    0    1    2    0    3    5    1    2    0 | 0 = 0
    0 1125    2    1    0    1    3    1    2    0 | 1 = 1
    4    3 1004    5    3    1    1    7    4    0 | 2 = 2
    0    0    2  992    0    3    0    6    5    2 | 3 = 3
    1    0    5    0  960    0    3    2    2    9 | 4 = 4
    3    1    0    8    1  863    8    1    5    2 | 5 = 5
    5    3    1    0    7    7  932    0    3    0 | 6 = 6
    1   10   11    3    1    1    0  992    0    9 | 7 = 7
    3    1    2    9    3    6    5    5  938    2 | 8 = 8
    4    8    1   13   20    2    1    6    3  951 | 9 = 9

Confusion matrix format: Actual (rowClass) predicted as (columnClass) N times