学步园

test_example_CNN.m

function test_example_CNN
load mnist_uint8;

% 将样本调整大小，并进行归一化
train_x = double(reshape(train_x',28,28,60000))/255;
test_x = double(reshape(test_x',28,28,10000))/255;
train_y = double(train_y');
test_y = double(test_y');

%% ex1 Train a 6c-2s-12c-2s Convolutional neural network 
%will run 1 epoch in about 200 second and get around 11% error. 
%With 100 epochs you'll get around 1.2% error

rand('state',0)


% CNN的网络结构，这些只是说明卷积层和下采样层，CNN是一个结构数组
cnn.layers = {
    struct('type', 'i') %input layer
    struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer
    struct('type', 's', 'scale', 2) %sub sampling layer
    struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer
    struct('type', 's', 'scale', 2) %subsampling layer
};


opts.alpha = 1;        %BP算法的学习速率
opts.batchsize = 50;   %进行一个训练的样本的大小
opts.numepochs = 5;    %迭代次数


cnn = cnnsetup(cnn, train_x, train_y);        %设置CNN的结构
cnn = cnntrain(cnn, train_x, train_y, opts);  %训练CNN

[er, bad] = cnntest(cnn, test_x, test_y);     %测试CNN

%plot mean squared error
figure; plot(cnn.rL);
assert(er<0.12, 'Too big error');

er                   %显示错误率
save('CNN-10');      %保存神经网络

1. 将读取训练样本和测试样本；
2. 将样本恢复为图像，并归一化为0~1；
3. 设置CNN网络的层数，每一层的结构，学习速率，batch的大小，迭代的次数；
4. 调用cnnsetup函数，初始化CNN的结构和参数；
5. 调用cnntrain函数，训练CNN；
6. 调用cnntest函数，对测试样本进行预测；
7. 输出错误率。

cnnsetup.m
function net = cnnsetup(net, x, y)
%    assert(~isOctave() || compare_versions(OCTAVE_VERSION, '3.8.0', '>='), ['Octave 3.8.0 or greater is required for CNNs as there is a bug in convolution in previous versions. See http://savannah.gnu.org/bugs/?39314. Your version is ' OCTAVE_VERSION]);
    
    % 每一层输入的特征图的个数
    inputmaps = 1;
    mapsize = size(squeeze(x(:, :, 1)));

    for l = 1 : numel(net.layers)   %  layer
        
        if strcmp(net.layers{l}.type, 's')   %下采样层
            mapsize = mapsize / net.layers{l}.scale;  %修改特征图的大小
            assert(all(floor(mapsize)==mapsize), ['Layer ' num2str(l) ' size must be integer. Actual: ' num2str(mapsize)]);
            for j = 1 : inputmaps
                net.layers{l}.b{j} = 0;  %下采样层的偏移初始化为0，此处并没有安装经典的LeNet-5中设置一个系数参数
            end
        end
        
        if strcmp(net.layers{l}.type, 'c')  %卷积层
            mapsize = mapsize - net.layers{l}.kernelsize + 1;  %卷积层特征图大小
            fan_out = net.layers{l}.outputmaps * net.layers{l}.kernelsize ^ 2;
            for j = 1 : net.layers{l}.outputmaps  %  output map
                fan_in = inputmaps * net.layers{l}.kernelsize ^ 2;
                for i = 1 : inputmaps  %  input map
                    net.layers{l}.k{i}{j} = (rand(net.layers{l}.kernelsize) - 0.5) * 2 * sqrt(6 / (fan_in + fan_out));  %卷积核参数随机初始化，此处为矩阵
                end
                net.layers{l}.b{j} = 0;   %卷积层的偏置初始化为0
            end
            inputmaps = net.layers{l}.outputmaps; %将下一层的输入特征图个数更新为此卷积层的输出特征图个数
        end
    end
    
    % 'onum' is the number of labels, that's why it is calculated using size(y, 1). If you have 20 labels so the output of the network will be 20 neurons.
    % 'fvnum' is the number of output neurons at the last layer, the layer just before the output layer.
    % 'ffb' is the biases of the output neurons.
    % 'ffW' is the weights between the last layer and the output neurons. Note that the last layer is fully connected to the output layer, that's why the size of the weights is (onum * fvnum)
    fvnum = prod(mapsize) * inputmaps;  
    onum = size(y, 1);     %输出层的神经元个数

    net.ffb = zeros(onum, 1);  %初始化为0
    net.ffW = (rand(onum, fvnum) - 0.5) * 2 * sqrt(6 / (onum + fvnum)); %随机初始化
end

function net = cnnff(net, x)
%This function is used to calculateing the forward 
    n = numel(net.layers);
    net.layers{1}.a{1} = x; 
    inputmaps = 1;

    for l = 2 : n   %  for each layer
        
        if strcmp(net.layers{l}.type, 'c')     %卷积层
            %  !!below can probably be handled by insane matrix operations
            for j = 1 : net.layers{l}.outputmaps   %  for each output map
                %  create temp output map
                z = zeros(size(net.layers{l - 1}.a{1}) - [net.layers{l}.kernelsize - 1 net.layers{l}.kernelsize - 1 0]);
                
                for i = 1 : inputmaps   %  for each input map    %所有输入层都进行卷积并相加？
                    %  convolve with corresponding kernel and add to temp output map
                    z = z + convn(net.layers{l - 1}.a{i}, net.layers{l}.k{i}{j}, 'valid'); 
                end
                %  add bias, pass through nonlinearity
                net.layers{l}.a{j} = sigm(z + net.layers{l}.b{j});  %上采样层经过Sigmoid函数进行激活
            end
            
            %  set number of input maps to this layers number of outputmaps
            inputmaps = net.layers{l}.outputmaps;
            
            
        elseif strcmp(net.layers{l}.type, 's')  % 下采样层没有和乘以一个系数和加上一个偏置
            %  downsample
            for j = 1 : inputmaps
                z = convn(net.layers{l - 1}.a{j}, ones(net.layers{l}.scale) / (net.layers{l}.scale ^ 2), 'valid');   %  !! replace with variable
                net.layers{l}.a{j} = z(1 : net.layers{l}.scale : end, 1 : net.layers{l}.scale : end, :);             % 下采样层没有经过Sigmoid函数激活？
            end
        end
    end

    
    %  concatenate all end layer feature maps into vector
    % 将最后一层特征图展开为列向量的形式
    net.fv = [];
    for j = 1 : numel(net.layers{n}.a)
        sa = size(net.layers{n}.a{j});
        net.fv = [net.fv; reshape(net.layers{n}.a{j}, sa(1) * sa(2), sa(3))];
    end
    
    %  feedforward into output perceptrons
    net.o = sigm(net.ffW * net.fv + repmat(net.ffb, 1, size(net.fv, 2)));  % 输出层为普通sigm激活？

end

function [er, bad] = cnntest(net, x, y)
    %  feedforward
    net = cnnff(net, x);
    
    % CNN给出的样本的输出的类别，此类别为输出神经元中最大的部分，此部分与传统神经BP神经网络一致
    [~, h] = max(net.o);
    
    % 样本的实际输出类别
    [~, a] = max(y);
    
    % 寻找预测错误的样本
    bad = find(h ~= a);

    er = numel(bad) / size(y, 2);
end