DeepLearnToolbox-master CNN

　　没想到，又回来看这代码了，结合文章Notes on Convolutional Neural Networks看效果比较好。

• 问题：

1）这代码在池化层没有参数，所以这和论文里面有点不一样。但感觉无法明白，池化层有参数（除了激活函数能够增加一些非线性之外，这有意义吗）？

2）对于bp和卷积之类的内容，理解不到位，其实理解还是不到位。

3）参数初始化理解不到位。

4）

5）

• 创新点：

1）

2）

3）

4）

• 全文总结：

1）

2）

3）

4）

5）

• 想法：

1）看看caffe代码，再对比这个代码，以及论文Notes on Convolutional Neural Networks应该效果比较好。

2）

3）

4）

5）

• 看懂本文，最好需要阅读的相关论文：

1）

2）

3）

4）

5）

6）

7）

　　结合别人写的博客，看看效果更好。

先看代码：test_example_CNN.m（依次调用 cnnsetup.m，cnntrain.m，cnntest.m）

function test_example_CNN

clear;close all;clc;
disp('当前正在执行的程序是：');
disp([mfilename('fullpath'),'.m']);

isOctave=0;
addpath(genpath('../data/'));
addpath(genpath('../CNN/'));
addpath(genpath('../Util/'));
load mnist_uint8;%加载数据

%下面的数据train_x为训练数据样本，train_y为训练数据标签。
%下面的数据test_x为测试数据样本，test_y为测试数据标签。
%由于初始的训练和测试样本格式为 nx784 28x28=784，所以把784维改变维度为28x28
%样本都是28x28的图像，样本数据格式为28x28xn（n为样本个数）
%标签数据格式为10xn (10为总类别数，所以除了对应类别为1，其余为0)，n为样本个数
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为结构体，这个结构体中字段layers的值为5个单元数组，每个单元数组中都有1个结构体
%而每个结构体中都有字段和值，下面就为定义的不同层（单元数组）对应的字段和值
%这是一个比较老的工具箱，只定义了三种层：i 输入；c 卷积；s 下采样、池化
%'c'的outputmaps是convolution之后有多少张图，也就是有多少个卷积核的意思。（不知道这个卷积到底是遍历卷积还是怎么卷积的）？
%'c'的kernelsize应该就是卷积核的尺寸吧。
%'s'的scale就是池化的尺寸为scale*scale的区域
%cnn结构如下，从后面代码中看到的隐藏信息有：卷积层的步长为1，池化层位非重叠池化（步长就是池化scale的大小）
%cnn最后池化层的输出，拉成一个[192,1](这假定只输入了一个样本)，然后输出为10类。192=4x4x12
%一个192x10的全连接网络，sigmoid为激活，值域刚好为[0,1]和标签1正好合适
%可以看出，这是一个非常古典的cnn，能看这代码，对于学习cnn很有帮助！

%特征图谱的尺寸变化为 28（i）24（c）12（s）8（c）4（s）
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
};%设置CNN的结构，输入层，卷积层，降采样，卷积，降采样


opts.alpha = 1;%学习率
opts.batchsize = 50;%每批训练数据的大小
opts.numepochs = 1;%训练的次数

%大体一看就是下面三个函数
%设置网络，初始化卷积核、偏置,第一个参数为网络的结构，第二个为训练的样本，第三个为训练的标签
cnn = cnnsetup(cnn, train_x, train_y);
%训练网络，第一个参数为网络的结构，第二个为训练的样本，第三个为训练的标签，第四个为附加选项
cnn = cnntrain(cnn, train_x, train_y, opts);
%测试网络，第一个参数为网络的结构，第二个为测试的样本，第三个为测试的标签，返回错误率和错误的标签
[er, bad] = cnntest(cnn, test_x, test_y);

%plot mean squared error
figure; plot(cnn.rL);%绘制均方误差曲线
disp(er);%显示误差
assert(er<0.12, 'Too big error');

　　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 ' myOctaveVersion]);
    %x为训练集（28x28x60000），y为训练集对应的标签（10x60000）
    
    %每层输入的特征图谱的层数，也就是上一层的输出的特征图谱的层数，
    %在这个代码中，只有卷积层才会改变网络特征图谱的层数
    %所以在每个卷积层最后，都把inputmaps改为当前层的outputmaps
    %初始的特征图谱就是一张图像,而且只有一个通道，所以 inputmaps = 1
    inputmaps = 1;
    
    %squeeze为移除单一的维度
    %初始化mapsize，为训练集的样本的尺寸，由于取得是第一个样本，所以加入了squeeze来去除第三个维度
    %mapsize作为经过卷积或池化后特征图谱的尺寸，是一个非常重要的参数。
    mapsize = size(squeeze(x(:, :, 1)));
    
    %尤其注意这几个循环的参数的设定
    %net.layers为一个单元数组，按顺序每层一个单元，所以numel(net.layers)为总层数
    for l = 1 : numel(net.layers)   %  layer,numel(net.layers)  表示有多少层
        %对于不同的层，用不同的方法来处理
        %strcmp比较字符串，对于大小写敏感
        if strcmp(net.layers{l}.type, 's')%降采样层
            %subsampling层的mapsize，直接除以scale，非重叠池化
            mapsize = mapsize / net.layers{l}.scale;
            %floor趋向于负无穷，assert生成错误，当条件违反
            %这个语句，就是说明这个代码的卷积和池化每步的尺寸，都是严格设计的
            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;%bias统一设置为0
            end
        end
        %strcmp比较字符串，对于大小写敏感
        if strcmp(net.layers{l}.type, 'c')%卷积层
            %卷积层大小为上层特征图谱大小-核大小+1,就是步长为1的卷积处理，常规的尺寸
            mapsize = mapsize - net.layers{l}.kernelsize + 1; 
            %fan_out为当前层需要学习的参数个数，由于权值共享，每层都有 net.layers{l}.kernelsize ^ 2
            %个参数，乘以层数，就是当前层的参数个数
            fan_out = net.layers{l}.outputmaps * net.layers{l}.kernelsize ^ 2;
            for j = 1 : net.layers{l}.outputmaps  %  output map
                %fan_out为假定，这层一个特征图谱对应于上层一个特征图谱，但是，这里假定的是这层的每一个特征图谱
                %都和上一层的多个特征图谱相连，所有就是inputmaps * net.layers{l}.kernelsize ^ 2
                %不过具体还是看后面的代码，这也不确定？
                fan_in = inputmaps * net.layers{l}.kernelsize ^ 2;
                for i = 1 : inputmaps  %  input map,对于每一个后层特征图，有多少个参数链到前层
                    %rand:在（0,1）内的标准正态分布,减去0.5，就是（-0.5,0.5），然后乘以2，就是（-1,1）
                    %设置每层的权重，权重设置为：-1~1之间的随机数 * sqrt（6/（输入神经元数量+输出神经元数量））
                    
                    %MATLAB中单元数组的格式为嵌套，多维单元数组是1xn签到者1xm，和数组的mxn不一样，但是调用还是一样的。
                    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;
            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)
    
    %prod为数组中元素的乘积,inputmaps改为了最后一层输出的特征图谱的层数
    %因此这儿的作用就是计算输出层之前那层神经元的个数，fvnum=4×4×12=192
    %fvnum是最后一层输出神经元的个数
    fvnum = prod(mapsize) * inputmaps;
    %输出层的神经元个数，也就是标签数
    onum = size(y, 1);
    %输出层偏置,这里是最后一层神经网络的设定
    net.ffb = zeros(onum, 1);
    %输出层权重，这样定义也是由于最后一层和输出的标签是全连接的
    net.ffW = (rand(onum, fvnum) - 0.5) * 2 * sqrt(6 / (onum + fvnum));
end

　　cnntrain.m（依次调用函数 cnnff.m，cnnbp.m，cnnapplygrads.m）

function net = cnntrain(net, x, y, opts)
%net为网络，x为训练数据，y为标签，opts为训练参数
    %m为样本数量，size（x）=[28*28*60000]
    m = size(x, 3);
    %总样本数除以训练时一批数据包含的图片数量，等于一次样本整体训练，需要的步数
    numbatches = m / opts.batchsize;
    %步数必须是可以整除的
    if rem(numbatches, 1) ~= 0
        error('numbatches not integer');
    end
    net.rL = [];%rL是最小均方差的平滑序列，绘图时使用
    for i = 1 : opts.numepochs%对于样本整体迭代的次数
        disp(['epoch ' num2str(i) '/' num2str(opts.numepochs)]);%显示当前迭代的次数
        tic;%计开始
        %每次整体训练，都重新打乱样本的顺序
        kk = randperm(m);
        for l = 1 : numbatches%分成numbatches批，MNIST分了50批，训练每个batch
            batch_x = x(:, :, kk((l - 1) * opts.batchsize + 1 : l * opts.batchsize));%获取每批的训练样本和标签
            batch_y = y(:,    kk((l - 1) * opts.batchsize + 1 : l * opts.batchsize));
            %很明显，关键的就是下面三个函数
            net = cnnff(net, batch_x);%完成前向过程
            net = cnnbp(net, batch_y);%完成误差传导和梯度计算过程
            net = cnnapplygrads(net, opts);%应用梯度，模型更新
            if isempty(net.rL)%net.L为模型的costfunction，即最小均方误差，net.rL是平滑后的序列
                net.rL(1) = net.L;
            end
            net.rL(end + 1) = 0.99 * net.rL(end) + 0.01 * net.L;
        end
        toc;%计时结束
    end
    
end

　　cnnff.m（CNN的前向传播）

function net = cnnff(net, x)
    %网络的层数
    n = numel(net.layers);
    %a是输入map，是一个[28,28,50]的序列，这里就是在每层增加一个单元数组a
    %作为当前层的激活？
    net.layers{1}.a{1} = x;
    %输入的层数，输入的是一个通道的图像
    inputmaps = 1;

    for l = 2 : n   %  for each layer
        %和初始化类似，先判断是c还是s，然后实施对应的处理
        %从第二层开始，所以用的是 if elseif 代码
        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
                %还是步长为1的卷积的基本操作，和初始化设置不同，这里是3维的处理，并且区分了输入和激活
                %对于第二层，也就是第一个卷积层：z=zeros([28,28,50]-[4,4,0]=zeros[24,24,50]
                z = zeros(size(net.layers{l - 1}.a{1}) - [net.layers{l}.kernelsize - 1 net.layers{l}.kernelsize - 1 0]);
                for i = 1 : inputmaps   
                    %convolve with corresponding kernel and add to temp output map
                    %这里是后层的每个特征图谱，都和前一层的所有特征图谱相连，这也是方便规范化编程。
                    %虽然在LeNet5中不是这样搞的，但是好像AlexNet之后都是这样搞，好像是方便GPU计算。
                    %这也算搞懂了，为什么里面这两个for是这样编写的，先output后input
                    %一开始其实很不理解这两个for这样编排，从代码整体实验来说，还是这样比较好，LeNet5这样搞
                    %只能是针对某一特定的模型，可以每层都单独编写代码，但是现在的多层NN，这样编写太费劲了
                    %还是统一的实现比较方便。
                    z = z + convn(net.layers{l - 1}.a{i}, net.layers{l}.k{i}{j}, 'valid');
                end
                %add bias, pass through nonlinearity
                %对于上一层所有特征图谱累加的结果，再通过sigmoid，由于sigmoid是单调递增的函数
                %所以这样还是可以区分出不同输入的差异。
                net.layers{l}.a{j} = sigm(z + net.layers{l}.b{j});
            end
            %  set number of input maps to this layers number of outputmaps
            %由于CNN，只会在卷积层会改变特征图谱的层数，所以在卷积层结尾都改变inputmaps为卷积层的输出
            inputmaps = net.layers{l}.outputmaps;%本层的输出作为下层的输入
        elseif strcmp(net.layers{l}.type, 's')
            %  downsample
            %就是平均池化，不改变输出的层数，所以就是遍历inputmaps
            for j = 1 : inputmaps
                %由于这里的平均池化，都是尺寸为2的平均池化。就等于2x2的卷积核，每个元素都是0.25。
                %所以才会出现下面这样的代码ones(net.layers{l}.scale)为2x2的单位矩阵（元素都为1）
                %net.layers{l}.scale ^ 2=4。所以结果为2x2的矩阵，元素都为0.25，这样也就是平静池化。
                z = convn(net.layers{l - 1}.a{j}, ones(net.layers{l}.scale) / (net.layers{l}.scale ^ 2), 'valid');
                %由于上面的卷积操作的步长为1进行的平均池化，但是池化的步长为scale。
                %所以就把计算的结果，从1开始隔一个scale进行采样，就是平均池化的结果。这还是有点巧妙的
                net.layers{l}.a{j} = z(1 : net.layers{l}.scale : end, 1 : net.layers{l}.scale : end, :);
            end
        end
    end

    %concatenate all end layer feature maps into vector
    %下面这个net.fv 就把所有输出的所有特征图谱整合成一个向量
    net.fv = [];
    %numel(net.layers{n}.a) 是输出的特征图谱的层数
    for j = 1 : numel(net.layers{n}.a)
        %取出最后一层，对应的特征图谱的尺寸，[4,4,opts.batchsize]
        %opts.batchsize为每个小批次样本的个数
        sa = size(net.layers{n}.a{j});
        %reshape(net.layers{n}.a{j}, sa(1) * sa(2), sa(3)) 
        %就是把最后一层对应的特征图谱按照样本拉成列向量
        %然后，由于；，循环下去，就是把每个样本输出的所有特征拉成了一个列向量net.fv
        net.fv = [net.fv; reshape(net.layers{n}.a{j}, sa(1) * sa(2), sa(3))];
    end
    %feedforward into output perceptrons，最后一层的perceptrons，数据识别的结果
    %输出乘以权值加上对应的偏置，再经过一个sigmoid成为了网络最后的输出 o,也就是数据识别的结果
    %net.o = sigm(net.ffW * net.fv + repmat(net.ffb, 1, size(net.fv, 2)));%计算输出
    %上面这个代码的效率还是不如下面的高，所以修改了一下。
    net.o = sigm(bsxfun(@plus,net.ffW * net.fv,net.ffb));
end

　　cnnbp.m（计算CNN的bp，CNN反向传播的难点都在这，不过这代码里面池化层没有参数，所以简化了很多）

function net = cnnbp(net, y)
    %net为网络的整体参数，y为数据集的标签
    %获取网络的层数，n=5
    n = numel(net.layers);
    %误差，输出值和期望值之差，net.e尺寸为[10,50],50为样本数
    net.e = net.o - y;
    %  loss function，这就是基本的损失函数，均方差
    net.L = 1/2* sum(net.e(:) .^ 2) / size(net.e, 2);

    %%  backprop deltas
    %从最后一层的error倒推回来deltas ，和神经网络的bp有些类似  
    %output delta 输出层的残差，由于是最后一层，所以误差是这样单独计算的，这层和bp完全一样
    %由于最后一层为一个简单的全连接的sigmoid，素以乘上了sigmoid的导数
    %变量命名规则，带有d的都为deltas
    %od:output deltas输出的残差
    %fvd:feature vector delta最后特征向量残差
    %其余就是对应层的残差，直接在结构体net对应层中增加单元数组d
    
    %net.od尺寸为[10,50]
    net.od = net.e .* (net.o .* (1 - net.o));
    %  feature vector delta,特征向量误差size=192×50，
    %net.fvd尺寸为[192,50]，net.ffW尺寸为[10,192]
    net.fvd = (net.ffW' * net.od);    
    %  only conv layers has sigm function 
    %这个网络从函数cnnff.m可以看出，只有卷积层才有sigmoid处理
    %池化层，z就是a，直接没有经过sigmoid激活
    %所以加入了下面一个激活，但是由于这个网络的结构最后一层为下采样层
    %所以这段代码，应该是作者加入为了方便规划化后面的代码写的
    if strcmp(net.layers{n}.type, 'c')         
        net.fvd = net.fvd .* (net.fv .* (1 - net.fv));%卷积层的误差需要进行求导
    end
    
    %这是算delta的步骤  
    %这部分的计算参看Notes on Convolutional Neural Networks，其中的变化有些复杂  
    %和这篇文章里稍微有些不一样的是这个toolbox在subsampling(也就是pooling层)没有加sigmoid激活函数  
    %所以这地方还需仔细辨别  
    %这个toolbox里的subsampling是不用计算gradient的，而在上面那篇note里是计算了的  
    
    %net.layers{n}.a{1}为最后一层，激活的数据的尺寸
    %专业一点说，就是最后一层特征map的大小。这里的最后一层都是指输出层的前一层  
    %由于最后一层为池化层，而这个代码，池化的特征没有经过sigmoid
    %由于这个网络，最后一层为12层的池化层，所以这里面选择的是12个数据中的其中一个
    %由于小批次尺寸为50，所以这个sa尺寸为[4,4,50]
    sa = size(net.layers{n}.a{1});
    %把最后一层特征map拉成一条向量，对于单个样本来说，特征维数是这样  
    fvnum = sa(1) * sa(2);%fvnum =16
    
    % reshape feature vector deltas into output map style
    %遍历最后一层的所有特征图谱，numel(net.layers{n}.a)为最后一层特征图谱的层数
    %本网络最后一层为12层的池化层，所以 numel(net.layers{n}.a)=12
    for j = 1 : numel(net.layers{n}.a)
        %net.fvd为最后一层残差的反向累加，如果最后一层为池化层，由于没有经过sigmoid，所以直接导入
        %如果最后一层为卷积层，所以要乘以sigmoid的导数
        %net.fvd尺寸为[192,50]，sa(1)=4, sa(2)=4, sa(3)=50,192=12x16，fvnum=16
        %一开始为了计算方便，所以反向传输的参数被整成向量的形式，但是对于不同层的特征图谱
        %反向传输计算的残差都是不一样的，所以把矩阵按照对应的层分割开来，这样就按照12层，每层都是4x4=16的特征图谱来reshape
        net.layers{n}.d{j} = reshape(net.fvd(((j - 1) * fvnum + 1) : j * fvnum, :), sa(1), sa(2), sa(3));
    end
    
    %对应的特征图谱的残差和特征图谱的尺寸是一样的
    %由于最后一层涉及到，向量化形式的特征的拆分问题，所以单独处理
    %下面就是残差的逐层反向传播
    for l = (n - 1) : -1 : 1
        %这判断是卷积还是池化层，分开处理
        if strcmp(net.layers{l}.type, 'c')%参见paper，注意这里只计算了'c'层的gradient，因为只有这层有参数
            %如果是卷积层，那么后面是池化层，只要对于池化层的残差进行扩展即可
            %而由于这个网络的设计，池化层不会改变特征图谱的层数，所以直接遍历卷积层的层数就可以
            for j = 1 : numel(net.layers{l}.a)
                %由于残差和激活值都是3维数组（前两维为特征图谱的维度，最后一维为每批次样本个数）
                %所以缩放池化层的前两层的尺寸和卷积层一样（而最后的样本层不变），然后除以一个缩放系数，使得这层整体的残差不变。
                %这样也符合池化的原理，不过这只是对于平均池化的，最大化池化是缩放到相同的尺寸，但是残差保留在对应的位置上
                %由于这个池化层没有激活，所以是这层残差比较简单
                %不知道 这个expand为util文件夹内，作者自己编写的函数，为对应维度的缩放
                net.layers{l}.d{j} = net.layers{l}.a{j} .* (1 - net.layers{l}.a{j}) .* (expand(net.layers{l + 1}.d{j}, [net.layers{l + 1}.scale net.layers{l + 1}.scale 1]) / net.layers{l + 1}.scale ^ 2);
            end
        elseif strcmp(net.layers{l}.type, 's')
            %如果这层为池化层，那么后面一层为卷积层，卷积层特征图谱的层数会发生变化，而且一般的变化趋势是层数增加
            %先遍历当前层特征图谱的层数
            for i = 1 : numel(net.layers{l}.a)
                %定义z为当前层（池化层）特征图谱中一层的尺寸，比如第3层位池化层，尺寸为[12,12,50]
                z = zeros(size(net.layers{l}.a{1}));
                %然后遍历后一层特征图谱的层数，潜在的意思，就是卷积过程，后面的每一层都是遍历前一层的所有特征图谱
                %所以bp传输，残差传输也是从后面所有的层传给前面某一层
                for j = 1 : numel(net.layers{l + 1}.a)
                    %卷积层的反向传输就是这样，卷积核先翻转180度，然后convn默认会翻转卷积核180度，这样就是一个相关操作
                    %从计算上，能够理解这样计算结果是正确的，但是还是不能够理解里面的数学原理，不懂反卷积呀。
                     z = z + convn(net.layers{l + 1}.d{j}, rot180(net.layers{l + 1}.k{i}{j}), 'full');
                end
                net.layers{l}.d{i} = z;
            end
        end
    end

    %%  calc gradients
    %上面计算残差，下面计算梯度
    %参见paper，注意这里只计算了'c'层的gradient，因为只有这层有参数  
    % 这里与 Notes on Convolutional Neural Networks 中不同，这里的 子采样 层没有参数，也没有激活函数，所以在子采样层是没有需要求解的参数的
    for l = 2 : n
        if strcmp(net.layers{l}.type, 'c')
            for j = 1 : numel(net.layers{l}.a)
                %计算卷积核的导数，卷积层对于前面层的每一个特征图谱都有一个对应的卷积核
                %所以遍历前面层的每一个特征图谱
                for i = 1 : numel(net.layers{l - 1}.a)
                    % dk 保存的是 误差对卷积核 的导数
                    %size(net.layers{l}.d{j}, 3)为每批的样本数
                    %convn(flipall(net.layers{l - 1}.a{i}), net.layers{l}.d{j}, 'valid')
                    %为对两个三维的数组卷积，得到了二维的结果，感觉对于第三维进行了累加。所以除以一个样本个数，得到均值
                    net.layers{l}.dk{i}{j} = convn(flipall(net.layers{l - 1}.a{i}), net.layers{l}.d{j}, 'valid') / size(net.layers{l}.d{j}, 3);
                end
                % db 保存的是 误差对于bias基 的导数
                %对于所有样本的所有偏差进行累加，然后除以样本个数得到偏差
                net.layers{l}.db{j} = sum(net.layers{l}.d{j}(:)) / size(net.layers{l}.d{j}, 3);
            end
        end
    end
    %计算尾部单层感知器的参数，最后一层perceptron的gradient的计算
    %net.od尺寸为[10,50],net.fv尺寸为[192,50]
    %net.dffW尺寸为[10,192]为计算的最后全连接层权系数的偏差
    net.dffW = net.od * (net.fv)' / size(net.od, 2);%size（net.0d)=50,修改量，求和/50
    %net.dffb尺寸为[10,1]，就是样本整体的残差，不过这没有取均值
    net.dffb = mean(net.od, 2);%第二维取均值

    function X = rot180(X)
        X = flipdim(flipdim(X, 1), 2);
    end
end

　　cnnapplygrads.m

function net = cnnapplygrads(net, opts)
    for l = 2 : numel(net.layers)%从第二层开始
        if strcmp(net.layers{l}.type, 'c')%对于每个卷积层，
            for j = 1 : numel(net.layers{l}.a)%枚举改层的每个输出%枚举所有卷积核的net.layers{l}.k{ii}{j}
                for ii = 1 : numel(net.layers{l - 1}.a)%枚举上层的每个输出
                    % 这里没什么好说的，就是普通的权值更新的公式：W_new = W_old - alpha * de/dW（误差对权值导数）  
                    net.layers{l}.k{ii}{j} = net.layers{l}.k{ii}{j} - opts.alpha * net.layers{l}.dk{ii}{j};
                end
                %修改偏置
                net.layers{l}.b{j} = net.layers{l}.b{j} - opts.alpha * net.layers{l}.db{j};
            end
        end
    end
    %单层感知器的更新
    net.ffW = net.ffW - opts.alpha * net.dffW;
    net.ffb = net.ffb - opts.alpha * net.dffb;
end

　　cnntest.m

function [er, bad] = cnntest(net, x, y)
    %输出错误率，错误的索引；输入 训练好的网络，测试样本，测试样本的标签
    %  feedforward
    net = cnnff(net, x);%前向传播
    [~, h] = max(net.o);%找到输出的最大值
    [~, a] = max(y);%找到真实的标签
    bad = find(h ~= a);%找到标签不等的索引

    er = numel(bad) / size(y, 2);%计算错误率。其中y的第二维是测试样本的数量
end