caffe 自带例子之MNIST的网络解析

网络结构

lenet 各层网络的定义在:examples/mnist/lenet_train_test.prototxt.

各层的定义:

  1. DATA layer
    minist的数据源自lmdb文件, 数据的读取定义在data layer
    layer {
      name: "mnist"
      type: "Data"
      transform_param {
        scale: 0.00390625
      }
      data_param {
        source: "mnist_train_lmdb"
        backend: LMDB
        batch_size: 64
      }
      top: "data"
      top: "label"
    }

该层的名字是"mnist", type: data, 该层从指定的lmdb文件源读取数据. batch size = 64, 将读入的像素rescale到[0,1]范围内, 归一化因子等于1/256 = 0.00390625. 最终这一层会产生两个blobs, 一个是data blob, 另一个是label blob.

  1. 第一个卷基层 CONV
    layer {
      name: "conv1"
      type: "Convolution"
      param { lr_mult: 1 }
      param { lr_mult: 2 }
      convolution_param {
        num_output: 20
        kernel_size: 5
        stride: 1
        weight_filler {
          type: "xavier"
        }
        bias_filler {
          type: "constant"
        }
      }
      bottom: "data"
      top: "conv1"
    }

该层承接data blob, 产生conv1 层. 该层共产生20个channel, 每个channel的kernel size = 5, stride = 1. 在该层, 每一个filter可以随机初始化weight和bias, 对于权重, 我们采用"xavier"算法, 根据输入和输出神经元的个数来决定权重初始化的尺度. 对于bias, 我们简单的采用固定值来初始化, 默认值为0.
'lr_mult's 是该层可学习参数的学习率. 在这里, 我们设置权值的学习率为solver中指定的学习率, bias的学习率设置为2倍solver中指定的学习率. 这样的设置通常会有比较好的聚合率.

  1. pooling layer
    pooling layer的定义相对较简单
    layer {
      name: "pool1"
      type: "Pooling"
      pooling_param {
        kernel_size: 2
        stride: 2
        pool: MAX
      }
      bottom: "conv1"
      top: "pool1"
    }

上面的设置表示, 我们将采用max pooling, pool kernel size = 2, stride = 2 (相邻的pooling region 不会重叠)

  1. 第二个conv 和pooling layer的解释和上面的解释大同小异.
  2. fully connected layer
    layer {
      name: "ip1"
      type: "InnerProduct"
      param { lr_mult: 1 }
      param { lr_mult: 2 }
      inner_product_param {
        num_output: 500
        weight_filler {
          type: "xavier"
        }
        bias_filler {
          type: "constant"
        }
      }
      bottom: "pool2"
      top: "ip1"
    }

上面的语法定义了一个全连接层(或者叫innerProduct 层),该层具有500个输出, 其他的选项和之前介绍的类似.

  1. Relu 层
  layer {
    name: "relu1"
    type: "ReLU"
    bottom: "ip1"
    top: "ip1"
  }

ReLU 是对逐个元素的操作(每个输入都要进行relu), 因此我们可以采用"in-place"内置操作的方式来节省内存, 具体就是给才曾的bottom 和top blobs 相同的名字.

  1. ReLU之后, 另一个inner product层:
    layer {
      name: "ip2"
      type: "InnerProduct"
      param { lr_mult: 1 }
      param { lr_mult: 2 }
      inner_product_param {
        num_output: 10
        weight_filler {
          type: "xavier"
        }
        bias_filler {
          type: "constant"
        }
      }
      bottom: "ip1"
      top: "ip2"
    }
  1. Loss Layer
    终于写到了这层
    layer {
      name: "loss"
      type: "SoftmaxWithLoss"
      bottom: "ip2"
      bottom: "label"
    }

softmax loss 层同时实现了softmax 和multinomial logical loss(节省时间改善数值稳定性). 该层接收两个blob, 第一个是prediction,第二个是label(由第一层data layer 提供). 该层不产生任何输出, 他的作用在于计算loss function value, 当 back propagation开始时report it. 同时, 开始计算相对于上一层"ip2"的梯度. (initiates the gradient with respect to 'ip2'.)

  1. Additional Notes: '定义层'的规则
    层的定义可以包含一些规则, 可以根据这些规则来确定是否以及如何来进行某些特定的操作.
    举例如下:
    layer {
      // ...layer definition...
      include: { phase: TRAIN }
    }

对于这个规则, 可以根据网络的状态来判定是否将整层包含入内. 具体来讲, 该层只有在训练阶段才会被包含如网络. 如果将'TRAIN' 改为'TEST',则该层只会在训练阶段被包含入网络内.
默认情况下是没有layer rules的, 一个定义好了的层会一直被包含在网络里. 因此, 'lenet_train_test.prototxt' 有两个'DATA'层(不同的'batch size'), 一个用于训练阶段,一个用于测试阶段.
同样的, 'lenet_train_test.prototxt' 定义了一个只有在测试阶段会被包含入网络的'Accuracy' 层, 该层会在测试阶段,每100iteration汇报一次网络accuracy.

Solver的定义

    # The train/test net protocol buffer definition
    net: "examples/mnist/lenet_train_test.prototxt"
    # test_iter specifies how many forward passes the test should carry out.
    # In the case of MNIST, we have test batch size 100 and 100 test iterations,
    # covering the full 10,000 testing images.
    test_iter: 100
    # Carry out testing every 500 training iterations.
    test_interval: 500
    # The base learning rate, momentum and the weight decay of the network.
    base_lr: 0.01
    momentum: 0.9
    weight_decay: 0.0005
    # The learning rate policy
    lr_policy: "inv"
    gamma: 0.0001
    power: 0.75
    # Display every 100 iterations
    display: 100
    # The maximum number of iterations
    max_iter: 10000
    # snapshot intermediate results
    snapshot: 5000
    snapshot_prefix: "examples/mnist/lenet"
    # solver mode: CPU or GPU
    solver_mode: GPU

Training and Testing the Model

网络的训练相对简单, 当你写好了network definition protobuf 和 solver protobuf 文件之后, 运行'train_lenet.sh'就可以了. 或者直接运行一下命令:

cd $CAFFE_ROOT
./examples/mnist/train_lenet.sh

'train_lenet.sh' 是一个简单的脚本, 简单解释之: 主要用于训练的工具是'caffe' 以 'train' 和 solver protobuf 文件作为它的参数.
当你运行之后, 你会看到大量的信息飞过, 如:

    I1203 net.cpp:66] Creating Layer conv1
    I1203 net.cpp:76] conv1 <- data
    I1203 net.cpp:101] conv1 -> conv1
    I1203 net.cpp:116] Top shape: 20 24 24
    I1203 net.cpp:127] conv1 needs backward computation.

这样的信息是初始化信息, 它告诉你每一层的细节: 链接情况, 输出的尺寸, 这些信息有助于debug. 初始化之后, 网络开始训练:

    I1203 net.cpp:142] Network initialization done.
    I1203 solver.cpp:36] Solver scaffolding done.
    I1203 solver.cpp:44] Solving LeNet

基于solver的设置, 系统将在每100 iteration 打印出 training loss, 每500iteration测试网络. 你会看到类似的信息:

    I1203 solver.cpp:204] Iteration 100, lr = 0.00992565
    I1203 solver.cpp:66] Iteration 100, loss = 0.26044
    ...
    I1203 solver.cpp:84] Testing net
    I1203 solver.cpp:111] Test score #0: 0.9785
    I1203 solver.cpp:111] Test score #1: 0.0606671

对于训练的每个iteration, 'lr' 是该次iteration的学习率, 'loss' 是训练的loss. 对于测试阶段的输出, score 0 是accuracy, score 1 是测试的loss function.
数分钟后, 训练完成.

    I1203 solver.cpp:84] Testing net
    I1203 solver.cpp:111] Test score #0: 0.9897
    I1203 solver.cpp:111] Test score #1: 0.0324599
    I1203 solver.cpp:126] Snapshotting to lenet_iter_10000
    I1203 solver.cpp:133] Snapshotting solver state to lenet_iter_10000.solverstate
    I1203 solver.cpp:78] Optimization Done.

最终的模型, 会存储为一个二进制protobuf文件:

    lenet_iter_10000

这个文件,可以作为训练好的模型在你的应用中部署.

How about GPU training?

其实刚才一直使用的是GPU训练. 实际上, 如果你想要在CPU上训练, 只需要修改'lenet_solver.prototxt'的对应行即可.

    # solver mode: CPU or GPU
    solver_mode: CPU

MNIST是一个比较小的数据集, 因此在GPU上进行训练并没有多少提高(由于GPU内部通信的开支). 在更大型的数据集上采用更复杂的模型进行训练时, 例如 ImageNet, 计算时间将会得到更大的提升.

如何在固定的阶段降低学习率?

Look at lenet_multistep_solver.prototxt

推荐阅读更多精彩内容