CNN卷積神經網絡學習筆記4：代碼學習

代碼來自github上的一個DeepLearning Toolbox，地址：https://github.com/rasmusbergpalm/DeepLearnToolbox

主要參考這篇博客中的代碼註釋：
http://blog.csdn.net/zouxy09/article/details/9993743

CNN原理和公式推導見前文：
背景
網絡結構
公式推導

單步調試後自己添加了一部分註釋
如下：

test_example_CNN

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.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

};

% learning rate 學習率，決定收斂的速度
opts.alpha = 1;
% 把樣本split爲每50個一份，每用batchsize個樣本訓練一次，調整一次權值
opts.batchsize = 50;
% split次數
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);
assert(er<0.12, 'Too big error');

cnnsetup

function net = cnnsetup(net, x, y)
    inputmaps = 1;
    % B=squeeze(A) 返回和矩陣A相同元素但所有單一維都移除的矩陣B，單一維是滿足size(A,dim)=1的維。
    % train_x中圖像的存放方式是三維的reshape(train_x',28,28,60000)，前面兩維表示圖像的行與列，
    % 第三維就表示有多少個圖像。這樣squeeze(x(:, :, 1))就相當於取第一個圖像樣本後，再把第三維
    % 移除，就變成了28x28的矩陣，也就是得到一幅圖像，再通過size函數就得到了訓練樣本圖像的行數與列數
    mapsize = size(squeeze(x(:, :, 1)));

    % 下面通過傳入net這個結構體來逐層構建CNN網絡
    % n = numel(A)返回數組A中元素個數
    % net.layers中有五個struct類型的元素，實際上就表示CNN共有五層，這裏的範圍是5
    for l = 1 : numel(net.layers)   %  layer
        if strcmp(net.layers{l}.type, 's') % 如果這層是 子採樣層
            % subsampling層的mapsize，最開始mapsize是每張圖的大小28*28
            % 這裏除以scale=2，就是pooling之後圖的大小，pooling域之間沒有重疊，所以pooling後的圖像爲14*14
            % 注意這裏的右邊的mapsize保存的都是上一層每張特徵map的大小，它會隨着循環進行不斷更新
            mapsize = floor(mapsize / net.layers{l}.scale);
            for j = 1 : inputmaps % inputmap就是上一層有多少張特徵圖
                net.layers{l}.b{j} = 0; % 將偏置初始化爲0
            end
        end
        if strcmp(net.layers{l}.type, 'c') % 如果這層是 卷積層
            % 舊的mapsize保存的是上一層的特徵map的大小，那麼如果卷積核的移動步長是1，那用
            % kernelsize*kernelsize大小的卷積核卷積上一層的特徵map後，得到的新的map的大小就是下面這樣
            mapsize = mapsize - net.layers{l}.kernelsize + 1;
            % 該層需要學習的參數個數。每張特徵map是一個(後層特徵圖數量)*(用來卷積的patch圖的大小)
            % 因爲是通過用一個卷積核在上一個特徵map層中移動（核窗口每次移動1個像素），遍歷上一個特徵map
            % 層的每個神經元。卷積核由kernelsize*kernelsize個元素組成，每個元素是一個獨立的權值，所以
            % 就有kernelsize*kernelsize個需要學習的權值，再加一個偏置值。另外，由於是權值共享，也就是
            % 說同一個特徵map層是用同一個具有相同權值元素的kernelsize*kernelsize的核窗口去感受輸入上一
            % 個特徵map層的每個神經元得到的，所以同一個特徵map，它的權值是一樣的，共享的，權值只取決於
            % 核窗口。然後，不同的特徵map提取輸入上一個特徵map層不同的特徵，所以採用的核窗口不一樣，也
            % 就是權值不一樣，所以outputmaps個特徵map就有（kernelsize*kernelsize+1）* outputmaps那麼多的權值了
            % 但這裏fan_out只保存卷積核的權值W，偏置b在下面獨立保存
            fan_out = net.layers{l}.outputmaps * net.layers{l}.kernelsize ^ 2;
            for j = 1 : net.layers{l}.outputmaps  %  output map
                % fan_out保存的是對於上一層的一張特徵map，我在這一層需要對這一張特徵map提取outputmaps種特徵，
                % 提取每種特徵用到的卷積核不同，所以fan_out保存的是這一層輸出新的特徵需要學習的參數個數
                % 而，fan_in保存的是，我在這一層，要連接到上一層中所有的特徵map，然後用fan_out保存的提取特徵
                % 的權值來提取他們的特徵。也即是對於每一個當前層特徵圖，有多少個參數鏈到前層
                fan_in = inputmaps * net.layers{l}.kernelsize ^ 2;
                for i = 1 : inputmaps  %  input map
                    % 隨機初始化權值，也就是共有outputmaps個卷積核，對上層的每個特徵map，都需要用這麼多個卷積核
                    % 去卷積提取特徵。
                    % rand(n)是產生n×n的 0-1之間均勻取值的數值的矩陣，再減去0.5就相當於產生-0.5到0.5之間的隨機數
                    % 再 *2 就放大到 [-1, 1].
                    % 反正就是將卷積核每個元素初始化爲[-sqrt(6 / (fan_in + fan_out)), sqrt(6 / (fan_in + fan_out))]
                    % 之間的隨機數。因爲這裏是權值共享的，也就是對於一張特徵map，所有感受野位置的卷積核都是一樣的
                    % 所以只需要保存的是 inputmaps * outputmaps 個卷積核。
                    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
            % 只有在卷積層的時候纔會改變特徵map的個數，pooling的時候不會改變個數。這層輸出的特徵map個數就是
            % 輸入到下一層的特徵map個數
            inputmaps = net.layers{l}.outputmaps; 
        end
    end

    % fvnum 是輸出層的前面一層的神經元個數。
    % 這一層的上一層是經過pooling後的層，包含有inputmaps個特徵map。每個特徵map的大小是mapsize。
    % 所以，該層的神經元個數是 inputmaps * （每個特徵map的大小）
    % prod: Product of elements.
    % For vectors, prod(X) is the product of the elements of X
    % 在這裏 mapsize = [特徵map的行數 特徵map的列數]，所以prod後就是 特徵map的行*列
    fvnum = prod(mapsize) * inputmaps;
    % onum 是標籤的個數，也就是輸出層神經元的個數。要分多少個，就有多少個輸出神經元
    onum = size(y, 1);

    % 這裏是最後一層神經網絡的設定
    % ffb 是輸出層每個神經元對應的基biases
    net.ffb = zeros(onum, 1);
    % ffW 輸出層前一層 與 輸出層 連接的權值，這兩層之間是全連接的
    net.ffW = (rand(onum, fvnum) - 0.5) * 2 * sqrt(6 / (onum + fvnum));
end

cnntrain

function net = cnntrain(net, x, y, opts)
    m = size(x, 3); % m 保存的是 訓練樣本個數
    numbatches = m / opts.batchsize;
    % rem: Remainder after division. rem(x,y) is x - n.*y 相當於求餘
    % rem(numbatches, 1) 就相當於取其小數部分，如果爲0，就是整數
    if rem(numbatches, 1) ~= 0
        error('numbatches not integer');
    end

    net.rL = [];
    for i = 1 : opts.numepochs
        % disp(X) 打印數組元素。如果X是個字符串，那就打印這個字符串
        disp(['epoch ' num2str(i) '/' num2str(opts.numepochs)]);
        % tic 和 toc 是用來計時的，計算這兩條語句之間所耗的時間
        tic;
        % P = randperm(N) 返回[1, N]之間所有整數的一個隨機的序列，例如
        % randperm(6) 可能會返回 [2 4 5 6 1 3]
        % 這樣就相當於把原來的樣本排列打亂，再挑出一些樣本來訓練
        kk = randperm(m);
        for l = 1 : numbatches
            % 取出打亂順序後的batchsize個樣本和對應的標籤
            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); % Feedforward
            % 得到上面的網絡輸出後，通過對應的樣本標籤用bp算法來得到誤差對網絡權值
            %（也就是那些卷積核的元素）的導數
            net = cnnbp(net, batch_y); % Backpropagation
            % 得到誤差對權值的導數後，就通過權值更新方法去更新權值
            net = cnnapplygrads(net, opts);
            if isempty(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

function net = cnnff(net, x)
    n = numel(net.layers); % 層數
    net.layers{1}.a{1} = x; % 網絡的第一層就是輸入，但這裏的輸入包含了多個訓練圖像
    % 輸入層只有一個特徵圖，也就是原始的輸入圖像，注意這裏所說的特徵圖，並不是指一張圖片，而是指一類圖片，這一類圖片是包含同種特徵信息的。
    % 即使這裏是50張圖片，也算作是一個特徵圖。 
    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
            % 對每一個輸入map，或者說我們需要用outputmaps個不同的卷積核去卷積圖像
            for j = 1 : net.layers{l}.outputmaps   %  for each output map
                %  create temp output map
                % 對上一層的每一張特徵map，卷積後的特徵map的大小就是 
                % （輸入map寬 - 卷積核的寬 + 1）* （輸入map高 - 卷積核高 + 1）
                % 對於這裏的層，因爲每層都包含多張特徵map，對應的索引保存在每層map的第三維
                % 所以，這裏的z保存的就是該層中所有的特徵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
                    % 用當前層的每一個卷積核去卷積輸入的所有的inputmaps張特徵圖，然後把這些卷積結果加起來，得到一張輸出特徵圖
                    % 輸出特徵圖的個數就是卷積核個數，也就是outputmaps， 
                    % 一個特徵圖是指含有同一類特徵的圖集合，我們對這一類圖片用同一種卷積核做卷積，提取出同一種特徵。
                    % 另外，有些論文或者實際應用中，並不是與全部的特徵map鏈接的，有可能只與其中的某幾個連接
                    z = z + convn(net.layers{l - 1}.a{i}, net.layers{l}.k{i}{j}, 'valid');
                end
                %  add bias, pass through nonlinearity
                % 加上對應位置的基b，然後再用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
            inputmaps = net.layers{l}.outputmaps;
        elseif strcmp(net.layers{l}.type, 's') % 下采樣層
            %  downsample
            for j = 1 : inputmaps
                %  !! replace with variable
                % 例如我們要在scale=2的域上面執行mean pooling，那麼可以卷積大小爲2*2，每個元素都是1/4的卷積核
                z = convn(net.layers{l - 1}.a{j}, ones(net.layers{l}.scale) / (net.layers{l}.scale ^ 2), 'valid'); 
                % 因爲convn函數的默認卷積步長爲1，而pooling操作的域是沒有重疊的，所以對於上面的卷積結果
                % 最終pooling的結果需要從上面得到的卷積結果中以scale=2爲步長，跳着把mean pooling的值讀出來
                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 = [];
    for j = 1 : numel(net.layers{n}.a) % 最後一層的特徵map的個數
        sa = size(net.layers{n}.a{j}); % 第j個特徵map的大小
        % 將所有的特徵圖拉成一條列向量。還有一維就是對應的樣本索引。每個樣本一列，每列爲對應的特徵向量
        net.fv = [net.fv; reshape(net.layers{n}.a{j}, sa(1) * sa(2), sa(3))];
    end
    %  feedforward into output perceptrons
    % 計算網絡的最終輸出值。sigmoid(W*X + b)，注意是同時計算了batchsize個樣本的輸出值
    net.o = sigm(net.ffW * net.fv + repmat(net.ffb, 1, size(net.fv, 2)));

end

cnnbp

function net = cnnbp(net, y)
    n = numel(net.layers); % 網絡層數

    %  error
    %  net.o 是label的預測值，y是真實值
    net.e = net.o - y; 
    %  loss function
    % 代價函數是 均方誤差
    net.L = 1/2* sum(net.e(:) .^ 2) / size(net.e, 2);

    %%  backprop deltas
    % 這裏可以參考 UFLDL 的 反向傳導算法 的說明
    % 輸出層的 靈敏度 或者 殘差
    % 這裏對應的就是前文公式推導的靈敏度計算公式 sigma^l = (y - t)* f'(u^l), 這個f是sigmoid函數
    % net.e 是 (y - t)；(net.o .* (1 - net.o))是f'(u).
    net.od = net.e .* (net.o .* (1 - net.o));   %  output delta
    % 靈敏度 反向傳播回 前一層
    % 對應公式：sigma^l = (W^(l+1))' * sigma^(l+1) * f'(u^l)
    % net.ffW'是(W^(l+1))'，因爲最後一層是全連接層；sigma^(l+1)是這裏的net.od
    % 這裏的下采樣層沒有sigmoid函數，只有卷積層有
    net.fvd = (net.ffW' * net.od);              %  feature vector delta
    if strcmp(net.layers{n}.type, 'c')         %  only conv layers has sigmoid function
        net.fvd = net.fvd .* (net.fv .* (1 - net.fv));
    end

    %  reshape feature vector deltas into output map style
    sa = size(net.layers{n}.a{1}); % 最後一層特徵map的大小。這裏的最後一層都是指輸出層的前一層
    fvnum = sa(1) * sa(2); % 因爲是將最後一層特徵map拉成一條向量，所以對於一個樣本來說，特徵維數是這樣
    for j = 1 : numel(net.layers{n}.a) % 最後一層的特徵map的組數
        % 在fvd裏面保存的是所有樣本的特徵向量（在cnnff.m函數中用特徵map拉成的），所以這裏需要重新
        % 變換回來矩陣的形式。d 保存的是 delta，也就是 靈敏度
        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')
            for j = 1 : numel(net.layers{l}.a) % 該層特徵map的組數
                % net.layers{l}.d{j} 保存的是 第l層 的 第j個 map 的 靈敏度map。 也就是每個神經元節點的delta的值
                % expand的操作相當於對l+1層的靈敏度map進行上採樣。然後前面的操作相當於對該層的輸入a進行sigmoid求導
                % 這裏對應的公式是：sigma^l(j) = f'(u^l(j)) * up(sigma^(l+1)(j))
                % net.layers{l}.a{j} .* (1 - net.layers{l}.a{j})就是f'(u^l(j))
                % 後面的expand就是up
                % 前文的公式推到中，還多乘了一個beta，這個beta是下采樣時map的權值，此處沒有設置這個權值。
                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) % 第l層特徵map的個數
                z = zeros(size(net.layers{l}.a{1}));
                for j = 1 : numel(net.layers{l + 1}.a) % 第l+1層特徵map的個數
                    % 這裏特徵map組合就是全部相加
                     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
    % 這裏與 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 保存的是 誤差對卷積核 的導數
                    % 如果l=2，那麼每個a{i}是一種特徵圖，是28*28*50，d{j}是靈敏度矩陣，大小是24*24*50，這裏50是指輸入了50張圖
                    % flipall是將每個28*28旋轉180度，並且50張圖的前後順序會顛倒，逆序。
                    % convn是將每個28*28和24*24做卷積，得到的結果大小是5*5，就是卷積核k的大小，然後把50個5*5的矩陣對應位置相加，所以後面這裏要除以50，也就是size
                    % 也就是說這裏計算的梯度是對50個圖的平均
                    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基 的導數，也是對50個圖的平均
                net.layers{l}.db{j} = sum(net.layers{l}.d{j}(:)) / size(net.layers{l}.d{j}, 3);
            end
        end
    end
    % 計算全連接層的參數的梯度
    net.dffW = net.od * (net.fv)' / size(net.od, 2);
    net.dffb = mean(net.od, 2);

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

cnntest

function [er, bad] = cnntest(net, x, y)
    %  feedforward
    net = cnnff(net, x); % 前向傳播得到輸出
    % [Y,I] = max(X) returns the indices of the maximum values in vector I
    [~, h] = max(net.o); % 找到最大的輸出對應的標籤
    [~, a] = max(y);    % 找到最大的期望輸出對應的索引
    bad = find(h ~= a);  % 找到他們不相同的個數，也就是錯誤的次數

    er = numel(bad) / size(y, 2); % 計算錯誤率
end