[人工智能]基于卷积神经网络的数据方阵化处理及网络模型设计

目 录
摘 要 I
ABSTRACT II
目 录 III
1 绪论 1
1.1 深度学习的发展和现状 1
1.2 研究意义 2
2 人工神经网络和卷积神经网络的结构及算法 4
2.1 人工神经网络 4
2.1.1 神经元 4
2.1.2 多层前馈网络 4
2.1.3 BP算法 5
2.2 卷积神经网络 6
2.2.1 局部连接与权值共享 7
2.2.2 网络结构 7
2.2.3 卷积层 8
2.2.4 采样层 8
3 CUDA平台介绍 10
3.1 CUDA简介 10
3.2 CUDA编程 10
3.2.1 CUDA的执行模型 10
3.2.2 常用函数及用法 11
3.3 CUDA开发环境搭建 11
4 数据方阵化处理及网络模型设计 13
4.1 数据方阵化 13
4.1.1 手写数字数据库MNIST介绍 13
4.1.1 手写数字数据库MNIST的数据方阵化 14
4.2 网络模型设计 15
4.2.1 网络结构 15
4.2.2 权重初始化方式 17
4.2.3 激活函数的选择 19
4.2.4 实验总结 20
5 卷积神经网络并行化设计及实现 21
5.1 基于CUDA的卷积神经网络的训练过程 21
5.1.1 网络初始化 22
5.1.2 网络前向传播过程 24
5.1.3 网络的反向传播过程 24
5.1.4 网络的权值和偏置更新过程 24
5.1.5 保存训练结果 24
5.2 并行化分析及实现 24
5.2.1 并行化分析 24
5.2.2梯度下降算法的实现 25
5.2.3 全连接层的前馈和反馈实现 27
5.2.4 Softmax回归算法的实现 27
5.3 对比实验 29
6 结论 31
致 谢 32
参 考 文 献 33
在球技术突飞猛进，人们在日常生活中获取信息越来越方便，同时也产生出了海量的数据信息。在这样的大背景下，人们利用计算机对我们现有的数据通过一些处理得到一定的规律，处理之后我们可以利用学到的规律能够得到数据背后有意义的东西，不仅仅是眼前所见的数据，而是数据包含的真正的意义，这一过程就被称为机器学习。其主要用途就是通过对提供数据的处理，然后找到这个数据的分类，或是对数据进行回归，进行数值的预测。
生活中随处可见机器学习的用途：搜索引擎对搜索结果的排序问题，人们使用搜索人们使用搜索引擎的时候，搜索引擎会记录下人们的搜索习惯，以及人们在搜索结果中点击的内容，经过长时间的累积，搜索引擎就会根据你的日常运用搜索引擎的习惯猜测你所从事的行业，根据这些内容重新排序搜索的结果，将适合你的搜索结果推送给你，这就用到了机器学习; 生活中这样的应用有人脸识别、手写识别、垃圾邮件过滤、购买商品推荐、购买行为预测等等，因此，机器学习对于对于科学来说具有重要意义，是人们必不可少的，对机器学习的研究有深远的意义。
卷积神经网络是目前机器学习领域的热点，因为其网络结构与视觉神经系统中的感受野相似，因此尤为适合处理图像方面的任务。虽然卷积神经网络在准确度等方面有着不错的表现，但在实际运用时不可避免会遇到输入数据量过大，网络层数过大，导致运算速度慢的问题，即使是当前最先进的CPU，其消耗的时间也都是不可接受的。近几年GPU通用并行技术得到了飞速的发展，本文转载自http://www.biyezuopin.vip/onews.asp?id=14528因为其计算核心的数量远远多于CPU，在高度并行的计算问题上，GPU的计算效率要远高于CPU。CUDA是由英伟达公司推出的GPU通用并行计算平台，不仅提供了一系列API使得开发人员能够绕过GPU的图形API来直接访问GPU的硬件，还提供了一个C语言编译器，使得开发人员能够使用C语言来进行快速的开发。基于CUDA的代码就可以运行在GPU上，使得卷积神经网络算法在GPU上的开发成为可能。
对于深度学习来说，在输入的数量较大时，运行速度慢。堆砌硬件的方式是有尽头的，出路只有软件方式。GPU的主频没有CPU快，但擅长浮点线性代数处理。需要研究CPU和GPU怎么配合，才能尽可能地提高神经网络的训练速度。
本文将实现基于CUDA的卷积神经网络算法，加快网络的训练和识别速度，这在现阶段互联网飞速发展，需要处理海量数据的情况下具有重要的意义。

#ifndef SOLVER_H_
#define SOLVER_H_

#include "net.h"

using namespace fecnn;

namespace fecnn {
//
// Solver
//

class Solver{
    bool singleGPU;
public:
    Phase phase;
    std::vector<Net* > nets;

    std::string path;
    int iter;
    int current_step;
    int train_iter; // 每步train向前forword几次。

    std::vector<int> GPU;
    int GPU_solver;

    // machine learning paramters
    SolverAlgorithm solver;
    Regularizer regularizer;
    ComputeT momentum;
    ComputeT momentum2;
    ComputeT delta;
    ComputeT rms_decay;

    ComputeT weight_decay;

    ComputeT base_lr;
    LRPolicy lr_policy;
    ComputeT lr_gamma;
    ComputeT lr_power;
    int lr_stepsize;
    std::vector<int> stepvalue;

    int max_iter;           // 最大的迭代数（每次迭代一个forward，处理一个batch_size的数据）
    int snapshot_iter;      // 多少次迭代产生一个快照
    int display_iter;       // 多少次迭代在控制台中显示一次计算结果
    int test_iter;          // 每步test向前forword几次。
    int test_interval;      // 每多少次forward执行一次test
    bool debug_mode;


    Solver(std::string filename=std::string()){

        // 通过json文件构造神经网络
        JSON* train_obj = new JSON;
        JSON* architecture_obj = new JSON;
        parseNetworkJSON(filename, train_obj, NULL, architecture_obj);

        // 如果json文件中没有设置，就使用第三次参数作为默认值
        SetValue(train_obj, solver,         SGD)
        SetValue(train_obj, regularizer,    L2)
        SetValue(train_obj, momentum,       0.9)
        SetValue(train_obj, momentum2,      0.999)
        SetValue(train_obj, delta,          0.00000001)
        SetValue(train_obj, rms_decay,      0.98)

        SetValue(train_obj, weight_decay,   0.0005)
        SetValue(train_obj, base_lr,        0.01)
        SetValue(train_obj, lr_policy,      LR_inv)
        SetValue(train_obj, lr_gamma,       0.0001)
        SetValue(train_obj, lr_power,       0.75)
        SetValue(train_obj, lr_stepsize,    100000)
        SetValue(train_obj, train_iter,     1)
        SetValue(train_obj, max_iter,       10000)
        SetValue(train_obj, snapshot_iter,  5000)
        SetValue(train_obj, display_iter,   100)
        SetValue(train_obj, test_iter,      100)
        SetValue(train_obj, test_interval,  500)
        SetValue(train_obj, debug_mode,     false)
        SetValue(train_obj, GPU,            veci(1,0))
        SetOrDie(train_obj, path            )
        SetValue(train_obj, GPU_solver,     -1)

        if (GPU_solver==-1) GPU_solver=GPU[0];

        singleGPU = GPU.size()==1 && GPU_solver==GPU[0];
        
        int nGPUs = 0;
        checkCUDA(__FILE__,__LINE__, cudaGetDeviceCount(&nGPUs));
        if (nGPUs==0){
            std::cerr<<"There is no NVIDIA GPU available in this machine."<<std::endl;
            FatalError(__LINE__);
        }else if (nGPUs==1){
            std::cout<<"There is 1 NVIDIA GPU available in this machine."<<std::endl;
        }else{
            std::cout<<"There are "<< nGPUs<< " NVIDIA GPUs available in this machine."<<std::endl;
        }

        nets.resize(GPU.size());
        for (int n=0;n<nets.size();++n){
            nets[n] = new Net(architecture_obj, GPU[n]);
            nets[n]->debug_mode = debug_mode;
            nets[n]->train_iter = train_iter;
            nets[n]->test_iter  = test_iter;
        }

        // JOSN对象的数据已经全部分配到相应的对象中了，可以放心地删除指针
        delete train_obj; 
        delete architecture_obj;

    };

    // 参见 http://stackoverflow.com/questions/30033096/what-is-lr-policy-in-caffe
    ComputeT learning_rate(){
        ComputeT rate;
        switch(lr_policy){
            case LR_fixed:
                rate = base_lr;
                break;
            case LR_step:
                current_step = iter / lr_stepsize;
                rate = base_lr * pow(lr_gamma, current_step);
                break;
            case LR_exp:
                rate = base_lr * pow(lr_gamma, iter);
                break;
            case LR_inv:
                rate = base_lr * pow(ComputeT(1) + lr_gamma * iter, - lr_power);
                break;
            case LR_multistep:
                if (current_step < stepvalue.size() && iter >= stepvalue[current_step] ) {
                    current_step++;
                    std::cout << "MultiStep Status: Iteration " << iter << ", step = " << current_step << std::endl;
                }
                rate = base_lr * pow(lr_gamma, current_step);
                break;
            case LR_poly:
                rate = base_lr * pow(ComputeT(1) - (ComputeT(iter) / ComputeT(max_iter)), lr_power);
                break;
            case LR_sigmoid:
                rate = base_lr * (ComputeT(1) /  (ComputeT(1) + exp(-lr_gamma * (ComputeT(iter) - ComputeT(lr_stepsize)))));
                break;
        }
        return rate;
    };

    size_t Malloc(Phase phase_ = Training){
        phase = phase_;

        int nGPUs = 0;
        checkCUDA(__FILE__,__LINE__, cudaGetDeviceCount(&nGPUs));
        std::vector<size_t> memoryBytes(nGPUs,0);

        for (int n=0;n<nets.size();++n){
            memoryBytes[GPU[n]] += nets[n]->Malloc(phase);
        }


        if (phase == Training || phase == TrainingTesting){
            checkCUDA(__FILE__,__LINE__,cudaSetDevice(GPU_solver));

            for (int l=0; l<nets[0]->layers.size(); ++l){
                if (nets[0]->layers[l]->train_me){ // 选择有权重需要训练的层。第一层没有权重，需要过滤掉。
                    size_t weight_numel = nets[0]->layers[l]->weight_numel;
                    size_t   bias_numel = nets[0]->layers[l]->bias_numel;
                    if (weight_numel>0){
                        size_t weight_bytes = (1 + nets.size()) * weight_numel * sizeofStorageT;
                        checkCUDA(__FILE__,__LINE__, cudaMalloc(&(nets[0]->layers[l]->weight_histGPU), weight_bytes));
                        checkCUDA(__FILE__,__LINE__, cudaMemset(nets[0]->layers[l]->weight_histGPU, 0, weight_bytes));
                        memoryBytes[GPU_solver] += weight_bytes;
                        for (int n=0;n<nets.size();++n){
                            nets[n]->layers[l]->weight_histGPU = nets[0]->layers[l]->weight_histGPU;
                            nets[n]->layers[l]->weight_diffGPU = nets[0]->layers[l]->weight_histGPU + weight_numel * (n+1);
                        }
                    }
                    if (bias_numel>0){
                        size_t bias_bytes = (1 + nets.size()) * bias_numel * sizeofStorageT;
                        checkCUDA(__FILE__,__LINE__, cudaMalloc(&(nets[0]->layers[l]->bias_histGPU), bias_bytes));
                        checkCUDA(__FILE__,__LINE__, cudaMemset(nets[0]->layers[l]->bias_histGPU, 0, bias_bytes));
                        memoryBytes[GPU_solver] += bias_bytes;
                        for (int n=0;n<nets.size();++n){
                            nets[n]->layers[l]->bias_histGPU = nets[0]->layers[l]->bias_histGPU;
                            nets[n]->layers[l]->bias_diffGPU = nets[0]->layers[l]->bias_histGPU + bias_numel * (n+1);
                        }
                    }

                }
            }
        }

        std::cout<< "====================================================================================================================================="<<std::endl;
        for (int n=0;n<nGPUs;++n){
            if (memoryBytes[n]>0){
                std::cout<< "[Solver] GPU " << n << ": Total GPU memory: ";  memorySizePrint(memoryBytes[n]);    std::cout<<std::endl;
            }
        }

        size_t totalMemory = memoryBytes[0];
        for (int n=1;n<nGPUs;++n){
            totalMemory += memoryBytes[n];
        }

        std::cout<< "All GPUs: Total GPU memory: "; memorySizePrint(totalMemory);   std::cout<<std::endl;

        return totalMemory;
    };

    ~Solver(){
        checkCUDA(__FILE__,__LINE__,cudaSetDevice(GPU_solver));
        for (int l=0; l<nets[0]->layers.size(); ++l){
            if (nets[0]->layers[l]->train_me){
                if (nets[0]->layers[l]->weight_numel>0){
                    if (nets[0]->layers[l]->weight_histGPU!=NULL) checkCUDA(__FILE__,__LINE__, cudaFree(nets[0]->layers[l]->weight_histGPU));
                }
                if (nets[0]->layers[l]->bias_numel>0){
                    if (nets[0]->layers[l]->bias_histGPU!=NULL) checkCUDA(__FILE__,__LINE__, cudaFree(nets[0]->layers[l]->bias_histGPU));
                }
            }
        }
    };

    void randInit(){
        nets[0]->randInit();
    };

    void solve(ComputeT learning_rate){
        checkCUDA(__FILE__,__LINE__,cudaSetDevice(GPU_solver));

        for (int l=0; l<nets[0]->layers.size(); ++l){
            if (nets[0]->layers[l]->train_me){
                if (nets[0]->layers[l]->weight_numel>0){
                    update_solver(solver, regularizer,
                    	nets[0]->layers[l]->weight_numel, 
                    	nets.size(), 
                    	weight_decay * nets[0]->layers[l]->weight_decay_mult, // 各层的weight_decay_mult默认为1
                    	momentum, 
                    	learning_rate * nets[0]->layers[l]->weight_lr_mult,  // 各层的weight_lr_mult默认为1
                    	nets[0]->layers[l]->weight_dataGPU, 
                    	nets[0]->layers[l]->weight_histGPU);
                }
                if (nets[0]->layers[l]->bias_numel>0){
                    update_solver(solver, regularizer,
                    	nets[0]->layers[l]->bias_numel, 
                    	nets.size(), 
                    	weight_decay * nets[0]->layers[l]->bias_decay_mult, 
                    	momentum, 
                    	learning_rate * nets[0]->layers[l]->bias_lr_mult, 
                    	nets[0]->layers[l]->bias_dataGPU, 
                    	nets[0]->layers[l]->bias_histGPU);
                }
            }
        }
    };

    void loadWeights(std::string filename, bool diff=false){

        std::cout<< "====================================================================================================================================="<<std::endl;

        std::vector<Tensor<StorageT>*> weights = readTensors<StorageT>(filename);

        for (int i=0;i<nets.size();++i){
            nets[i]->loadWeights(weights, diff);
        }

        for (int i=0; i<weights.size();++i){
            delete weights[i];
        }
    };

    void saveWeights(std::string filename, bool diff=false){
        nets[0]->saveWeights(filename, diff);
    };

    void train(int iter_begin = 0){

        checkCUDA(__FILE__,__LINE__,cudaSetDevice(GPU_solver));
        
        phase = Training;
        current_step = 0;

        // 找到网络中的用于Train的dataLayer，为了获取当前的迭代周期（epoch）
        DataLayer* pDataLayer = NULL;
        for (int l=0; l<nets[0]->layers.size();++l){
            if (nets[0]->layers[l]->phase == phase){
                if (nets[0]->layers[l]->isDataLayer()){
                    pDataLayer = (DataLayer*) nets[0]->layers[l];
                    break;
                }
            }
        }
        if (pDataLayer==NULL) { std::cerr<<"No data layer for Train."<<std::endl; FatalError(__LINE__);};
        int epoch = pDataLayer->epoch;

        std::cout<< "==========================================================================================================================================="<<std::endl;
        std::cout<< "  Training:                                                                            Testing:                                            "<<std::endl;
        std::cout<< "==========================================================================================================================================="<<std::endl;

        if(debug_mode){
            tic(); // 开始计时
        }
        for (iter=iter_begin;iter<=max_iter;++iter){
            epoch = pDataLayer->epoch;

            if (iter % test_interval==0 && test_iter > 0){
                std::cout<< "                                                                                        ";
                std::cout << "Epoch " << epoch << "  ";
                std::cout << "Iteration " << iter;

                if (singleGPU){
                    nets[0]->phase = Testing;
                    nets[0]->stepTest(false);
                    nets[0]->phase = Training;
                }

                for (int l=0; l<nets[0]->loss_layers.size();++l){
                    if (nets[0]->loss_layers[l]->phase == phase || nets[0]->loss_layers[l]->phase == TrainingTesting){
                        for (int t=1;t<nets.size(); ++t){
                            nets[0]->loss_layers[l]->result += nets[t]->loss_layers[l]->result;
                            nets[0]->loss_layers[l]->loss += nets[t]->loss_layers[l]->loss;
                        }
                        nets[0]->loss_layers[l]->result /= nets.size();
                        nets[0]->loss_layers[l]->loss   /= nets.size();
                        nets[0]->loss_layers[l]->display();
                    }
                }
                std::cout << std::endl;
            }

            if (singleGPU){
                nets[0]->stepTrain(false); // 每次训练一个batch_size的数据
            }

            ComputeT lrate = learning_rate();
            solve(lrate);
            checkCUDA(__FILE__,__LINE__,cudaDeviceSynchronize());

            if (iter!=iter_begin && iter % snapshot_iter==0){
                saveWeights(path+"_snapshot_"+std::to_string(iter)+".fecnn",false);
            }
            if (iter % display_iter==0){
                std::cout << "Epoch " << epoch << "  ";
                std::cout << "Iteration " << iter << "  ";
                std::cout << "learning_rate = "<< lrate;


                if (singleGPU){
                    nets[0]->eval(false);
                }

                for (int l=0; l<nets[0]->loss_layers.size();++l){
                    if (nets[0]->loss_layers[l]->phase == phase || nets[0]->loss_layers[l]->phase == TrainingTesting){
                        nets[0]->loss_layers[l]->display();
                    }
                }
                std::cout << std::endl;
            }
        }
        if(debug_mode){
            std::cout<<"After Train "<<iter-1<<" Iterations "<<"Needs Time: ";
            toc(); // 计时结束
        }
    };
};

}// namespace fecnn

#endif  // SOLVER_H_