Operators in MXNet-Convolution

       本篇文章将对mxnet的Convolution操作进行详细说明, 源码见src/operator/convolution-inl.h. 现将源码convolution-inl.h.及注释贴上. 源码的注释都是笔者自己写的, 有分析不对的地方网各位读者加以指正. 只把层的参数部分, 前向传播和反向传播部分贴上.

/*! * Copyright (c) 2015 by Contributors * \file convolution-inl.h * \brief * \author*/#ifndef MXNET_OPERATOR_CONVOLUTION_INL_H_#define MXNET_OPERATOR_CONVOLUTION_INL_H_ // 宏 #include <mxnet/io.h> // include/mxnet下, 声明了输入和输出数据结构和数据迭代器. #include <mxnet/base.h> // include/mxnet下, 声明mxnet的配置信息以及基本数据结构./*如是否支持OpenCV, CUDA, CUDNN, VS以及声明了mxnet命名空间下的变量的定义, 如cpu, gpu, index_t以及Save, Load等. */ #include <mxnet/ndarray.h> // include/mxnet下, #include <mxnet/operator.h> // 在include/mxnet下, 定义操作基类(operator), 操作属性类, 方法等. 对OP或Prop的函数进行声明. #include <dmlc/logging.h> // mxnet的日志头文件. 在dmlc-core/include/dmlc下,#include <dmlc/optional.h> // 在dmlc-core/include/dmlc下, 声明了class optional.  #include <algorithm> // 标准C++算法库. #include <map> // C++ map容器头文件. #include <vector> // 向量容器. #include <string> // 字符串. #include <utility> // utility头文件定义重载的关系运算符, 简化关系运算符的写入, 还定义了pair类型,// pair类型是一种模板类型, 可以存储一对值.#include "./operator_common.h" // src/operator下, mxnet的层一些常用的属性.#include<iostream>#include <fstream>#include <stdio.h>#include <stdlib.h>using namespace std;namespace mxnet {namespace op {namespace conv {enum ConvolutionOpInputs {kData, kWeight, kBias}; // 卷积层的输入索引, 包括前一层的输出数据data, 本层的权重wmat和偏置. enum ConvolutionOpOutputs {kOut}; // 卷积层的输出索引. enum ConvolutionOpResource {kTempSpace}; // 卷积层的资源配置, 设置一个临时空间, 这个空间可以是任意大小的. /*有些操作需要额外的内存作为工作空间进行计算, 比如说cudnnConvolutionForward. 这种情况下, 系统最好可以对这部分内存进行管理, 这样系统可以做一些优化, 比如说内存的重复利用.struct ResourceRequest {  enum Type {    kRandom,  // get an mshadow::Random<xpu> object    kTempSpace,  // request temporay space  };  Type type;};*/enum ConvolutionOpCudnnTune {kOff, kLimited, kFastest}; // 利用GPU完成卷积操作时, 有三个索引. 没有使用, 因此convolution-inl.h// 是cpu版的. }/*卷积层输出的特征图的大小, 输出特征图尺寸 = [(输入特征图尺寸 + 2 * pad - 卷积核尺寸)/步长](向下取整) + 1.Matlab中的应用函数-conv2:二维卷积, 一维对应conv. 0.8版本的convolution-inl.h只能做2D卷积, 0.9版本的convolution-inl.h可以做3D卷积, 而且将2D卷积核3D卷积结合在一起了.卷积操作类型, 这和MATLAB的卷积函数conv和conv2是类似的, conv做向量间的卷积, 即一维卷积; conv2做二维卷积, 即矩阵卷积. w = conv(A, B,'shape')回卷积的一部分. 这一部分由shape参数指定:full 返回全部卷积值(缺省). kFull,  为1.same 返回卷积的中心部分, 与A有相同的大小. valid 仅返回卷积中的那些被计算而没有补零的部分, 不补零.. kValid, 为0. 卷积的计算步骤:(1)卷积核绕自己的核心元素顺时针旋转180度, 是顺时针旋转180, 不是做转置! (2)移动卷积核的中心元素，使它位于输入图像待处理像素的正上方. 根据shape的不同会选择不同的卷积方式.(3)在旋转后的卷积核中，将输入图像的像素值作为权重相乘. (4)第三步各结果的和做为该输入像素对应的输出像素.A=[1 2 3;4 5 6;7 8 9];B=[1 2;3 4];conv2(A, B, 'full'), 是做全卷积, 首先对B进行180度顺时针旋转, 然后对A进行补0操作. 补零的时候在A的外围进行补零. 补零的行数 = 2 *(Nh - 1), 补零的列数 = 2 * (Nw - 1). 卷积核B大小为Nh * Nw. 操作时的A为:   操作时B为: . 然后再对应元素相乘在相加即是卷积后的结果. 0 0 0 0 0        4 3       0 1 2 3 0        2 1 0 4 5 6 00 7 8 9 0 0 0 0 0 0conv2(A, B, 'valid'), 返回卷积计算中没有补零部分的计算结果, 即是CNN中的卷积操作, 让卷积核对齐A即可. 不补零. conv2(A,B, 'same'), 返回和A同样大小的卷积后的结果, 利用full操作可以得到same操作的结果. 不在左上 */struct ConvolutionParam : public dmlc::Parameter<ConvolutionParam> { // 卷积层的参数结构ConvolutionParam.   TShape kernel; // 卷积核, TShape: 一个shape类, 该类可以表示一个Tensor的形状. 利用TShape来表示Tensor的大小.   /*卷积核是二维的(h, w)或三维的(d, h, w). 即实现二维卷积或三维卷积, 对应到图像中可以是灰度图像(2维张量), RGB图像(3维张量).  这和输入的数据是2维的还是3维的有关. (channel K不一定是图像的通道数了, 或者为前一层特征图的数量.)   TShape定义: http://mxnet.io/doxygen/classmxnet_1_1TShape.html*/    TShape stride; // 卷积核滑动步长, 二维的(h, w)或三维的(d, h, w).    TShape dilate;  /*  卷积核膨胀是将卷积核扩张到膨胀尺度约束的尺度中, 并将原卷积核没有占用的区域填充零. 例如:  1 2 3      1 0 2 0 3  4 5 6 ---->0 0 0 0 0        7 8 9      4 0 5 0 6             0 0 0 0 0             7 0 8 0 9  卷积核由3*3膨胀到了5*5. 膨胀后的卷积核中填充了一些0. 膨胀系数与卷积核膨胀的关系, 首先回到卷积核膨胀公式:  膨胀的卷积核尺寸 = 膨胀系数 * (原始卷积核尺寸 - 1) + 1.  由于卷积的操作特性, 卷积核尺寸是奇数, 卷积核的膨胀系数刻画了卷积核高和宽方向的扩张倍数,   膨胀系数保证了膨胀的卷积核尺寸为奇数.   */  TShape pad; // 原始数据的高度或宽度方向上补上0值的圈数, 二维的(h, w)或三维的(d, h, w).  uint32_t num_filter; // 卷积核的个数. 经过卷积后一共有多少个特征图.   /*  uint8_t，uint16_t，uint32_t: 使用typedef给类型起的别名.  typedef unsigned char uint8_t; 1字节   typedef unsigned int uint16_t; 2字节   typedef unsigned long uint32_t; 4字节   typedef unsigned long long uint64_t; 8字节   */  uint32_t num_group;  /*  将输入数据切割成num_group个partitions, 然后在每个partition上使用卷积操作, 再将卷积的结果连接起来. 有点并行的意思.   */  uint64_t workspace; // 卷积操作最大的临时工作空间, 以MB计算.   bool no_bias; // 卷积层是否使用偏置, 默认使用偏置.   dmlc::optional<int> cudnn_tune;  /*  template<typename T>  class dmlc::optional< T >  C++17的可选类, 实例化对象cudnn_tune, cudnn_tune描述如下:   cudnn_tune决定是否通过测试性能来选择卷积算法, 由于要测试性能, 因此启动时间可能会变长, 但是操作的速度却会变快.   cudnn_tune有三个可选参数:  off: 不调整  limited_workspace: 在不超过工作区限制的情况下, 运行测试性能, 并选择最快的算法.  fastest: 忽略工作区限制, 选择最快的算法.   */  bool cudnn_off; // 该卷积层是否使用cudnn, 默认使用．   dmlc::optional<int> layout;  /*  layout与cudnn_tune类型一致. 设置输入, 输出和权重的layout(布局).    */   DMLC_DECLARE_PARAMETER(ConvolutionParam) { // #define DMLC_DECLARE_PARAMETER(PType), 使用宏来描述卷积层的参数.     /*    宏DMLC_DECLARE_PARAMETER, DMLC_DECLARE_FIELD的定义以及函数describe, set_default, set_range, add_enum均在    #include <dmlc/parameter.h>下.     */    DMLC_DECLARE_FIELD(kernel).describe("convolution kernel size: (h, w) or (d, h, w)");    /*#define DMLC_DECLARE_FIELD(FieldName)使用宏#define DMLC_DECLARE_FIELD(FieldName)来对卷积层的参数进行描述, 利用函数    describe(const std::string &description)对参数FieldName进行描述. 卷积核的大小, 二维卷积或三维卷积.*/    DMLC_DECLARE_FIELD(stride).set_default(TShape())    .describe("convolution stride: (h, w) or (d, h, w)");    /*    卷积核滑动步长, 二维滑动或三维滑动. 利用函数set_default(const DType &default_value)设置参数FieldName的默认值, 默认值是    TShape(), 即mxnet::TShape::TShape( ), 调用TShape的默然构造函数, NONE; 利用函数describe(const std::string &description)    对参数FieldName进行描述.      */    /*    TShape a = TShape();    cout<<"TShape()[0]: "<<a[0]<<endl; 0    cout<<"TShape()[1]: "<<a[1]<<endl; 0    cout<<"TShape()[2]: "<<a[2]<<endl; 0    即TShape的默然构造函数TShape()构造的 shape对象, 其值均是0.     但是stride的默认值是(1, 1), 不可能是(0, 0). dliate和pad的默认值均值1.    conv1 = mx.symbol.Convolution(data=data, kernel=(5,5), stride=(2,2), num_filter=20), 指定stride=(2, 2).    conv1 = mx.symbol.Convolution(data=data, kernel=(5,5), num_filter=20), 不指定stride=(1, 1).     */    DMLC_DECLARE_FIELD(dilate).set_default(TShape())    .describe("convolution dilate: (h, w) or (d, h, w)"); // 膨胀系数.      DMLC_DECLARE_FIELD(pad).set_default(TShape())    .describe("pad for convolution: (h, w) or (d, h, w)"); // 始数据的高度或宽度方向上补上0值的圈数.    DMLC_DECLARE_FIELD(num_filter).set_range(1, 100000)    .describe("convolution filter(channel) number");    /*    卷积核的个数. 调用函数set_range(DType begin, DType end)设置num_filter的范围, 1-100000.     */    DMLC_DECLARE_FIELD(num_group).set_default(1)    .describe("Number of group partitions. Equivalent to slicing input into num_group\n    "              "partitions, apply convolution on each, then concatenate the results"); // 将输入数据切割成num_group个partitions    // 默然不切割输入.     DMLC_DECLARE_FIELD(workspace).set_default(1024).set_range(0, 8192)    .describe("Maximum tmp workspace allowed for convolution (MB).");    /*卷积操作最大的临时工作空间, 默认是1024M, 范围是0M - 8192M.*/    DMLC_DECLARE_FIELD(no_bias).set_default(false)    .describe("Whether to disable bias parameter."); // 卷积操作是否使用偏置.     DMLC_DECLARE_FIELD(cudnn_tune)    .add_enum("off", conv::kOff)    .add_enum("limited_workspace", conv::kLimited)    .add_enum("fastest", conv::kFastest)    .set_default(dmlc::optional<int>())    .describe("Whether to pick convolution algo by running performance test.\n    "              "Leads to higher startup time but may give faster speed. Options are:\n    "              "\'off\': no tuning\n    "              "\'limited_workspace\': run test and pick the fastest algorithm "              "that doesn't exceed workspace limit.\n    "              "\'fastest\': pick the fastest algorithm and ignore workspace limit.\n    "              "If set to None (default), behavior is determined by environment\n    "              "variable MXNET_CUDNN_AUTOTUNE_DEFAULT: 0 for off,\n    "              "1 for limited workspace (default), 2 for fastest.");    /*    利用可选类cudnn_tune来选择卷积算法. 利用函数add_enum(const std::string &key, int value)来为cudnn_tune添加参数. 添加一对    键值key和value, conv::kOff为0, conv::kLimited为1, conv::kFastest为2. 默认值是dmlc::optional<int>(), 即类optional的默认    构造函数, 没有值为空.       */    DMLC_DECLARE_FIELD(cudnn_off).set_default(false)    .describe("Turn off cudnn for this layer."); // 是否使用cudnn, 默认是false. 即使用.     DMLC_DECLARE_FIELD(layout)    .add_enum("NCHW", mshadow::kNCHW)    .add_enum("NHWC", mshadow::kNHWC)    .add_enum("NCDHW", mshadow::kNCDHW)    .add_enum("NDHWC", mshadow::kNDHWC)    .set_default(dmlc::optional<int>())    .describe("Set layout for input, output and weight. Empty for\n    "              "default layout: NCHW for 2d and NCDHW for 3d.");    /*    设置输入, 输出和权重的layout(布局), 定义本层输入data, 输出和权重的布局, 因为输入和输出均是4D的数据, 因此要设定在内存存储,    是以行为主函数列为主. Blob memory is row-major in layout, so the last / rightmost dimension changes fastest.     默认2d使用NCHW, 3d使用NCDHW.   kNCHW = 0, kNHWC, kCHWN, kNCDHW = 1 << 5, kNDHWC,    kCDHWN是枚举变量. 定义在mshadow/mshadow/base.h下.      */  }};template<typename xpu, typename DType>class ConvolutionOp : public Operator { // 卷积操作类, 前向操作和反向操作.  public:  explicit ConvolutionOp(ConvolutionParam p) {    // explicit关键字只能用于修饰只有一个参数的类构造函数, 它的作用是表明该构造函数是显示的, 而非隐式的. 参数是卷积参数p.     this->param_ = p;    // p是ConvolutionParam卷积层参数类的对象, 将p赋值给param_. 这和单纯的赋值不一样, param_就是p, 可以看做是指向p的指针.     // convert MBytes first to Bytes and then to elements.    param_.workspace = (param_.workspace << 20) / sizeof(DType);    // param_.workspace赋值, 首先令param_.workspace为20, 再除以sizeof(DType). 例如sizeof(float).     CHECK(param_.layout.value() == mshadow::kNCHW ||          param_.layout.value() == mshadow::kNCDHW)      << "Only support NCHW and NCDHW layout";    // 卷积层的layout只支持NCHW and NCDHW, 判断卷积层的layout.value()(layout的值, 返回一个int的数)是否是mshadow::kNCHW或    // mshadow::kNCDHW. 如果不相等, 输出断言.   }  virtual void Forward(const OpContext &ctx,                       const std::vector<TBlob> &in_data,                       const std::vector<OpReqType> &req,                       const std::vector<TBlob> &out_data,                       const std::vector<TBlob> &aux_args) {    /*前向传播, 虚函数. 函数的实现在类中定义. 不需要返回值. 本层为第 l 层.     in_data: 本层输入data, 本层的权重wmat和偏置(卷积层可能有偏置, 可能没有).    req: 数据操作模式.     out_data: 本层输出, out.     */    using namespace mshadow;    using namespace mshadow::expr;    CHECK_EQ(req[conv::kOut], kWriteTo);    /*    判断卷积层前向传播的数据模式是不是kWriteTo, 如果不是, 断言. 一般情况下, 所有的out_data的类型应该是kWriteTo,     表示out_data代表的tensor是可以直接写入的原始的内存块 .      */    size_t expected = param_.no_bias ? 2 : 3;    /*    size_t是标准C库中定义的, 应为unsigned int, 在64位系统中为 long unsigned int. 定义expected, param_.no_bias为真, 则expected    为2, 否则为3. 即expected是用来定义前向传播中的参数的个数的, 是只有kData, KWeight, 还是kData, KWeight,, kBias.     */    CHECK_EQ(in_data.size(), expected); // 检查输出in_data(向量数组)的大小是否和expected相等, 不相等, 断言.     CHECK_EQ(out_data.size(), 1); // 前向操作只有一个输出out, 因此前向操作中的out_data的大小应该是1.    Stream<xpu> *s = ctx.get_stream<xpu>(); // XPU流. CPU或GPU.     if (param_.kernel.ndim() > 2) {      LOG(FATAL) << "Volume convolution is not implmented in mshadow";    }    /*    param_就代表了卷积层的参数实例, 利用param_可以调用卷积层的任意一个参数. kernel.ndim()即TShape对象的维数, mshadow只做了二维    卷积. convolution-inl.h(0.9版本的)做了3D卷积, 基于NNVM.     log的级别:    error是错误; fatal是致命; silence: 显示最简练的日志信息; verbose：显示最详细的日志信息.    */    Tensor<xpu, 4, DType> data = in_data[conv::kData].get<xpu, 4, DType>(s);    /*    将本层(第l层)的输入数据in_data[kData]拉成4维的张量. 这使用get函数:    mshadow::Tensor<Device, dim, DType> mxnet::TBlob::get(mshadow::Stream<Device> *stream = NULL)const. 4维的张量, 这里就和    blob比较类似了, 即number N x channel K x height H x width W, (N, K, H, W). Blob memory is row-major in layout.     这的channel K不一定是图像的通道数了, 或者为前一层特征图的数量.      */    Shape<3> wmat_shape =        Shape3(param_.num_group,               param_.num_filter / param_.num_group,               data.shape_[1] / param_.num_group * param_.kernel[0] * param_.kernel[1]);    /*    在https://raw.githubusercontent.com/jdeng/gomxnet/master/mxnet.cc可以找到Shape1, Shape2, Shape3, Shape4的定义:    Shape3定义如下:    MSHADOW_XINLINE Shape<3> Shape3(index_t s0, index_t s1, index_t s2) {        Shape<3> s;        s[0] = s0; s[1] = s1; s[2] = s2;        return s;    }    定义wmat_shape, 为定义本层(第l层)的权重wmat做准备. 即卷积层权重矩阵的shape.     s0 = param_.num_group, 即num_group(输入数据切割成num_group个partitions), 默认为1;    s1 = param_.num_filter / param_.num_group. num_filter为卷积核的个数, 在使用COnvolution时指定, num_filter的范围, 1-100000.    s2 = data.shape_[1] / param_.num_group * param_.kernel[0] * param_.kernel[1];    data.shape_[1]是data shape的第二个分量的值, 即channel K. 这里为卷积层前一层特征图的数量.      param_.kernel[0]即kernel[0], 只是使用param_来调用kernel. 在使用卷积层的时候: kernel = (5,5).      param_.kernel[1]即kernel[1].     */    Tensor<xpu, 3, DType> wmat =        in_data[conv::kWeight].get_with_shape<xpu, 3, DType>(wmat_shape, s);    /*    将卷积层权重in_data[conv::kWeight]即in_data[1]拉成3维的张量. 这利用了get_with_shape. 定义如下:    mshadow::Tensor<Device, dim, DType> mxnet::TBlob::get_with_shape(const mshadow::Shape<dim> & shape,     mshadow::Stream< Device > *stream = NULL)const, 其中Shape<dim> & shape 就是wmat_shape.     卷积层的权重wmat是3D的张量. 权重的大小是: wmat_shape. 一般的, 卷积层的卷积核(weight)的个数为:    num_filter * (kernel[0] * kernel[1]). 由于mxnet做卷积时, 用到了 num_group 机制, 因此将wmat设置成3D的, 其中第一个维度是    num_group的数目. 假设要将卷积层的输入数据data分成num_group个partitions, 那么每个partitions的卷积核个数就是:    param_.num_filter / param_.num_group个.       */    Tensor<xpu, 4, DType> out = out_data[conv::kOut].get<xpu, 4, DType>(s);    /*定义本层(第l层)的输出数据out_data[kOut]即out_data[0], 为4维的张量.*/#if defined(__CUDACC__)    CHECK_EQ(s->blas_handle_ownership_, Stream<xpu>::OwnHandle)        << "Must init CuBLAS handle in stream";#endif // __CUDACC__ // 是否定义了__CUDA__宏.     const index_t nbatch = data.size(0);    /*    index_t的定义在mshadow/mshadow/base.h下.    typedef unsigned index_t;     unsigned a; 与unsigned int a; 是同样的. 这里省略了int, 只能和unsigned int等价.     Tensor<xpu, 4, DType> data; data是4维的张量, 张量的大小是(N, C, H, W), 第一维是数据子集的个数, 可以看做是批训练中一批数据    个数; C是图像的通道数, 即数据是二维的还是三维的数据(这的channel K不一定是图像的通道数了, 或者为前一层特征图的数量. );     H是数据的高度; W是数据的宽度. 因此, data.size(0)即N, data.size(1)即C, data.size(2)即H, data.size(3)即W.     nbatch是索引类型(unsigned int)的变量, 代表了批量大小.     */    Tensor<xpu, 1, DType> workspace =        ctx.requested[conv::kTempSpace].get_space_typed<xpu, 1, DType>(            Shape1(this->InitTemp(data.shape_, out.shape_)), s);    /*    get requested temp space. 获取所需的临时空间.     有些操作需要额外的内存作为工作空间进行计算, 比如说cudnnConvolutionForward. 这种情况下, 系统最好可以对这部分内存进行管理,     这样系统可以做一些优化, 比如说内存的重复利用. 因此BN有kTempSpace. 即BN的反向操作会申请一个临时的资源空间, 这个空间任意.     */                /*    workspace是一维的张量(向量).     OpContext: 结构体, 定义在include/mxnet/operator.h中, 该结构体可以记录操作在前向和后向传播中的信息. ctx是结构体OpContext定    义的对象, requested是OPContext结构体下的函数:    // brief Resources requested by the operator    std::vector<Resource> requested; // 用来返回卷积操作所需的资源.     ctx.requested返回的是一个向量容器, 我们需要的只是kTempSpace即卷积层的资源配置, 即一个临时的操作空间.     ctx.requested[conv::kTempSpace]就是一个Resource的对象, 再调用get_space_typed函数, 将这个卷积的操作空间拉成一个一维的张量.    Resource结构体定义: http://mxnet.io/doxygen/structmxnet_1_1Resource.html. 定义了mxnet操作所需的资源.    get_space_typed函数:    mshadow::Tensor<xpu, ndim, DType> mxnet::Resource::get_space_typed (mshadow::Shape<ndim> shape, mshadow::Stream<xpu>*     stream )const 返回指定类型的Tensor.     其中, shape是返回的Tensor的Shape, stream是所需的流.     MSHADOW_XINLINE Shape<1> Shape1(index_t s0) {        Shape<1> s; s[0] = s0;        return s;    }     这里第一个变量的定义用到了InitTemp函数, 该函数也是定义在类COnvolutionOP下:    inline index_t InitTemp(const mshadow::Shape<4> &ishape, const mshadow::Shape<4> &oshape) {...}     data.shape_, out.shape_ 返回输入和输出的shape, 由于data和out均是4维的张量, 所以data.shape_, out.shape_均是4维的. 类型是    Shape<4>, InitTemp函数返回值类型是index_t, 正和Shape1的参数类型一致. Shape1(this->InitTemp(data.shape_, out.shape_))返回    的就是Tensor的shape.     */            for (index_t i = 0; i < nbatch; i += nstep_) {      const index_t step = std::min(nstep_, nbatch - i);      // cout<<"step: "<<step<<endl;  // 64, ji batch_size.       /*      step是索引类型(unsigned int), index_t nstep_ 即nstep_是类ConvolutionOp下的一个数据成员, 在运行时会指定nsetp_的大小.       nstep_是batch_size. 因此for循环只执行一次, 即 i == 0.        step取nstep_ 和 nbatch_ - i 的最小值. 由于nstep_是batch_size, 因此step为batch_size.       */      Tensor<xpu, 2, DType> temp_col = Tensor<xpu, 2, DType>(workspace.dptr_,                                               Shape2(shape_colunit_[0],                                                      shape_colunit_[1] * step), s);      Tensor<xpu, 3, DType> temp_dst = Tensor<xpu, 3, DType>(                                               workspace.dptr_ + temp_col.shape_.Size(),                                               Shape3(shape_dstunit_[0],                                                      shape_dstunit_[1],                                                      shape_dstunit_[2] * step), s);      /*      lenet网执行时的特征图大小:      28*28 --> 12*12(conv1) --> 6*6(pool1) --> 2*2(conv2) --> 1*1(pool2) -->...       */      /*      这三个量shape_colunit_, shape_dstunit_, nstep_.       是在运行时指定的, 是在ConvolutionOp类的私有函数InitTemp中指定的, 最新版本的convolution-inl.h中也有一个私有函数      LayerSetUp, 用来指定一些值. 根据ishape(本层输入shape)和oshape(本层输出shape)即, data.shape_, out.shape_      可以确定OP中用到的一些变量的值.       */      // cout<<"forward_nstep_: "<<nstep_<<endl; // nstep_是batch_size.        /*cout<<"shape_colunit_[0]: "<<shape_colunit_[0]<<endl;       // conv1 = mx.symbol.Convolution(data=data, kernel=(5,5), stride=(2,2), num_filter=10)时, 为25.       // shape_colunit_[0]是: 卷积层前一层特征图个数 * kernel[0] * kernel[1]. ishape[1] * ksize_y * ksize_x.      cout<<"shape_colunit_[1]: "<<shape_colunit_[1]<<endl;      // 为144, 4. 是 卷积层输出特征图的高度 * 宽度 之积. oshape[2] * oshape[3].      cout<<"shape_dstunit_[0]: "<<shape_dstunit_[0]<<endl;      //  shape_dstunit_[0]是1. param_.num_group.        cout<<"shape_dstunit_[1]: "<<shape_dstunit_[1]<<endl;      // shape_dstunit_[1]是卷积层卷积核的个数. 为10, 50. param_.num_filter / param_.num_group.      cout<<"shape_dstunit_[2]: "<<shape_dstunit_[2]<<endl;      // 是 卷积层输出特征图的高度 * 宽度 之积.  oshape[2] * oshape[3].*/       /*      这是利用了Tensor类的构造函数来创建xpu, ndim == 2, 3, DType下的对象temp_col和temp_dst. 需要Tensor类(结构体)的定义, 见:      mshadow/mshadow/tensor.h 363行.       根据375和378的Tensor构造函数的形式, 确定375和378所使用的构造函数为:      template<typename Device, int dimension, typename DType MSHADOW_DEFAULT_DTYPE>      MSHADOW_XINLINE Tensor(DType *dptr, const Shape<dimension> &shape, Stream<Device> *stream) : dptr_(dptr), shape_(shape),      stride_(shape[kSubdim]), stream_(stream) {}. 依据data pointer and shape, without stride来构造Tensor的对象.       Device会在make mxnet的指定, cpu或gpu. dimension会在定义卷积层操作的时候指定, 如2, 3.       DType *dptr: 即float* 型的指针dptr;      Shape<dimension> &shape: 是一个shape, 可用Shape2或者Shape3定义(Shape2和Shape3定义如下). 即定义的Tensor对象的shape.        Stream<Device> *stream: 是Stream对象.       *dptr传入的实参一个是workspace.dptr_, 一个是workspace.dptr_ + temp_col.shape_.Size().      workspace定义: Tensor<xpu, 1, DType> workspace, 即是1维Tensor的对象, 引用 struct Tensor<Device, 1, DType> 结构体下的      成员: DType *dptr_; 514行. 是指向数据的指针.       temp_col.shape_.Size()是 temp_col.shape_各个分量的乘积, 即 shape_colunit_[0] * shape_colunit_[1] * step, 是一个数.       用了Tensor类的构造函数来创建 xpu, ndim == 2, 3, DType下的Tensor对象temp_col和temp_dst, 在创建的时候会指定      temp_col和temp_dst的shape. temp_col和temp_dst是两个临时的Tensor, 利用tmp_col和tmp_dst来计算最终卷积层的输出Tensor      Tensor<xpu, 4, DType> out.        Shape3定义如下:      MSHADOW_XINLINE Shape<3> Shape3(index_t s0, index_t s1, index_t s2) {        Shape<3> s;        s[0] = s0; s[1] = s1; s[2] = s2;        return s;      }      Shape2定义如下:      MSHADOW_XINLINE Shape<2> Shape2(index_t s0, index_t s1) {        Shape<2> s;        s[0] = s0; s[1] = s1;        return s;      }      // MSHADOW_XINLINE is used for inlining template code for both CUDA and CPU code. MSHADOW_XINLINE是一个宏.       #ifdef MSHADOW_XINLINE          #error "MSHADOW_XINLINE must not be defined"      #endif      */      if (param_.pad[0] == 0 && param_.pad[1] == 0) { // 0.8的卷积操作只能实现2D卷积, 因此kernel, stride, dilate, pad均是2D的.        // param_指向结构体ConvolutionParam对象p的指针, 用来访问成员pad. 即pad[0], pad[1].         // 做2D卷积时, 不对卷积核补零, temp_col是:        /*// data是卷积层的输入数据! data是 64 * 1 * 28 * 28的. 手写数字体识别数据.                        cout<<"data.shape_[0]: "<<data.shape_[0]<<endl; // 64         cout<<"data.shape_[1]: "<<data.shape_[1]<<endl; // 1, 通道数. channel K. 单通道(灰度图像), RGB图像(彩色图像).         cout<<"data.shape_[2]: "<<data.shape_[2]<<endl; // 28         cout<<"data.shape_[3]: "<<data.shape_[3]<<endl; // 28 */         /*        // 输出卷积层输入数据 data(4D tensor)的数据指针.         cout<<"data[0]: "<<data[0].dptr_<<endl; // data[0]: 0x7f98600008c0         cout<<"data[1]: "<<data[1].dptr_<<endl; // data[1]: 0x7f9860001500         cout<<"data[2]: "<<data[2].dptr_<<endl; // data[2]: 0x7f9860002140         cout<<"data[3]: "<<data[3].dptr_<<endl; // data[3]: 0x7f9860002d80         */        /*        // 写入数据, 将data数据保存到.txt中. 因为cout输出一个tensor会出错,         // 所以只操作单个值.         // std::ofstream fdata("/home/ly/MXNet/fdata.txt");        for(int i = 0; i < data.shape_[0]; ++i){                for(int j = 0; j < data.shape_[2]; ++j){                        for(int k = 0; k < data.shape_[3]; ++k){                                 fdata << data[i][0][j][k] <<" ";                         }                }        }        fdata<<flush;        // fdata.close();        // data的类型是mshadow::Tensor<mshadow::cpu, 4, float>&        // data[0]的类型是mshadow::Tensor<mshadow::cpu, 3, float>        // data[0][0]的类型是mshadow::Tensor<mshadow::cpu, 2, float>        // data[0][0][0]的类型是mshadow::Tensor<mshadow::cpu, 1, float>        // data[0][0][0][0]的类型是float&.         */        temp_col = unpack_patch2col(data.Slice(i, i + step),                                    param_.kernel[0],                                    param_.kernel[1],                                    param_.stride[0],                                    param_.stride[1],                                    param_.dilate[0],                                    param_.dilate[1]);        /*        data.Slice(i, i + step), 用到了Slice函数, 切片函数, 将一个Tensor数据切片, 根据data.Slice(i, i + step)的调用格式, Slice        应该是Tensor结构体的成员, slice函数和Slice函数是不一样的, Slice定义见:        mshadow/mshadow/tensor.h 481行:        MSHADOW_XINLINE Tensor<Device, dimension, DType> Slice(index_t begin, index_t end) const {...}. Slice是结构体Tensor下        成员函数, 因此Tensor的对象data可以调用Slice函数.        slice the tensor in highest dimension [begin,end)        param begin: begin position of slice        param end: end position of slice        return tensor after slice. 返回切片后的Tensor.         */        /*        // cout<<"i: "<<i<<endl; // 0, i一直是0, 循环仅执行1次.         // 输入iamge后面就是卷积层.         auto a = data.Slice(i, i + step); // c++11类型推断.        cout<<"a.shape_[0]: "<<a.shape_[0]<<endl; // step, 因为step是batch_size, 所以为64. 或者a.size(0).         cout<<"a.shape_[1]: "<<a.shape_[1]<<endl; // 1.         cout<<"a.shape_[2]: "<<a.shape_[2]<<endl; // 28.        cout<<"a.shape_[3]: "<<a.shape_[3]<<endl; // 28.        */        /*        由于Tensor型的变量不能直接用cout输出, 所以利用mshadow/mshadow/tensor.h 363行, Tensor结构体的成员来访问Tensor的内容:        Tensor结构体的成员变量:        pointer to the data         DType *dptr_; // 指向Tensor数据的指针 dptr_.          shape of the tensor        Shape<dimension> shape_; // 利用 shape_ 来访问Tensor的shape.         storing the stride information in x dimension        this is used to deal with pitch allocation in gpu or sse(align x dimension to 64bit) for efficiency        index_t stride_;        stream where the computation lies        stream is a device dependency concept where each computation        Stream<Device> *stream_;         */        /*        // 因此输出tensor时用dptr_试试.        cout<<"a[0]: "<<a[0].dptr_<<endl; // a[0]: 0x7f98600008c0        cout<<"a[1]: "<<a[1].dptr_<<endl; // a[1]: 0x7f9860001500         cout<<"a[2]: "<<a[2].dptr_<<endl; // a[2]: 0x7f9860002140         cout<<"a[3]: "<<a[3].dptr_<<endl; // a[3]: 0x7f9860002d80         */        /*        实验下, 由于step = batch_size, 输出tensor的dptr_. 一个用data, 一个用data.Slice(i, i + step). 比较差异.        根据 data 和 data.Slice(i, i + step)的大小比较 + dptr_ 比较, 由于step是batch_size, 认为卷积层的输入数据没有发生改变.         data.Slice(i, i + step)是对data这个tensor进行切片, 取data的一部分(i, i + step).         */        /*计算temp_col:         利用函数unpack_patch2col: 定义见mshadow/mshadow/extension/unpack_patch2col.h 91和104行. 输入参数不同, 根据445使用的        unpack_patch2col, 函数定义为:        template<typename SrcExp, typename DType, int etype>        inline UnpackPatchToColXExp<SrcExp, DType, ExpInfo<SrcExp>::kDim> unpack_patch2col(        const Exp<SrcExp, DType, etype> &img, index_t psize_y, index_t psize_x, index_t pstride_y_, index_t pstride_x_,        index_t pdilate_y_, index_t pdilate_x_) {...}.         将图像块(patches of image)unpack(解压)成一个矩阵的一列, 在利用unpack_patch2col得到mat后, 可以实现卷积.        img: source image, img可以是3D Tensor或者4D Tensor(多幅图像). 这里是4DTensor, batch_size * 1 * 28 * 28.         psize_y: 每个patch的高度. 这里是kernl[0], 即卷积核的高度.         psize_x: 每个patch的宽度. 这里是kernel[1], 即卷积核的宽度.         pstride_y_: 每个patch在y方向上的滑动步长. 这里是stride[0], 即卷积核在y方向上的滑动步长.         pstride_x_: 每个patch在x方向上的滑动步长.  这里是stride[1], 即卷积核在x方向上的滑动步长.         pdilate_y_: 每个patch在y方向上的膨胀系数. 这里是dilate[0], 即卷积核的膨胀系数, y方向.         pdilate_x_: 每个patch在x方向上的膨胀系数. 这里是dilate[1], 即卷积核的膨胀系数, x方向.         利用unpack_patch2col得的mat, 得到output: output = dot(weight, mat). output即是卷积层的输出特征图.         out_height = [(in_height - psize_y)] / pstride + 1,        out_width  = [(in_width - psize_x)] / pstride + 1.         */        /*        cout<<"temp_col.shape_[0]: "<<temp_col.shape_[0]<<endl; // 25, param_.kernel[0] * param_.kernel[1]         // 这个大小是 shape_colunit_[0]是: 卷积层前一层特征图个数 * kernel[0] * kernel[1].         cout<<"temp_col.shape_[1]: "<<temp_col.shape_[1]<<endl; // 9216, batch_size * [ out.size(2) * out.size(3) ], out是        // 卷积层输出特征图.  这个大小是 shape_colunit_[1] * step, 是 step * 卷积层输出特征图的高度 * 宽度 之积.        // 在定义张量temp_col时, 已将其大小定义好.         cout<<"temp_col.shape_.Size(): "<<temp_col.shape_.Size()<<endl; // 230400 = 25 * 9216.        将图像块(patches of image) 28 * 28的patch, unpack(解压)成一个矩阵的一列,         利用unpack_patch2col得到mat后, 可以实现卷积.        */      } else {        temp_col = unpack_patch2col(pad(data.Slice(i, i + step),                                    param_.pad[0], param_.pad[1]),                                    param_.kernel[0],                                    param_.kernel[1],                                    param_.stride[0],                                    param_.stride[1],                                    param_.dilate[0],                                    param_.dilate[1]);        /*        如果pad[0]或pad[1]不是0, 先利用 pad函数 对 data.Slice(i, i + step) 进行补零操作, 然后再做unpack_patch2col操作.        pad函数也是定义下mshadow::expr命名空间下, 因此要using namespace mshadow::expr; 定义见mshadow/mshadow/extension/pad.h.         由于241行使用的pad有三个参数, 因此:        template<typename SrcExp, typename DType, int etype>        pad(const Exp<SrcExp, DType, etype> &src, index_t pad_y, index_t pad_x)        对一张图片进行补零操作, 在图片的四周补零. src原图像; pad_y: padding size in y, 即在y方向上补零的行数; pad_x:         padding size in x, 在x方向上补零的列数. 返回补零的结果, 即返回补完零之后的矩阵.          */                                  }       // temp_col 是做完 unpack_patch2col 后的tensor, 大小是 shape_colunit_[0] * [shape_colunit_[1] * step].       const index_t gstride = temp_col.size(0) / param_.num_group;       // gstride类型是index_t, 即unsigned int型的. 其值为 temp_col.size(0) / param_.num_group.      // 即 shape_colunit_[0](卷积层前一层特征图个数 * kernel[0] * kernel[1].) / num_group(默认为1,       // 将输入数据切割成num_group个partitions. num_group貌似只能是1).       for (uint32_t gid = 0; gid < param_.num_group; ++gid) {         /*        使用typedef给类型起的别名. 1字节:uint8_t; 2字节: uint16_t; 4字节: uint32_t; 8字节: uint64_t.        typedef unsigned char uint8_t;        typedef unsigned int uint16_t;         typedef unsigned long uint32_t;        typedef unsigned long long uint64_t;        param_是ConvolutionParam结构体的对象, 调用成员num_group. 因为num_group默认为1, 因此 gid == 0. 即只做一次for循环.        这个for循环做的就是: 将输入数据切割成num_group个partitions. 有点并行的意思.         */        mshadow::Tensor<xpu, 2, DType> tmpc = temp_col.Slice(gstride * gid,                                       gstride * (gid + 1));        /*        temp_col是做完unpack_patch2col之后的Tensor, 在pad默认为0的情况下, 其大小为:         shape_colunit_[0] * [shape_colunit_[1] * step]. 再次调用Slice, tensor切片函数:        Slice函数, 调用格式: data.Slice(i, i + step)的调用格式.         gid的总数是 num_group - 1. 即gid起的作用就是, 将一个tensor(输入数据切割成num_group个partitions), gid就代表每个        partitions的索引, 即第 gid 个partitions. 这里是利用Slice函数切割temp_col, 切割的范围是 gid-gid+1, 即将temp_col切割成        1个partitions. 每个partitions(也是一个tensor)的大小是 gstride.          */        /*        // 输出tmpc的大小, 是一个2维的张量.        cout<<"tmpc.shape_[0]: "<<tmpc.shape_[0]<<endl; // 25         cout<<"tmpc.shape_[1]: "<<tmpc.shape_[1]<<endl; // 9216         在默认 num_group == 1的情况下, gid == 0. gstride == temp_col.size(0).         因此, 为temp_col.Slice(0, gstride). 故, tmpc 和 temp_col是一样的. 这里因为没有做 输入数据切割成num_group个partitions        这个操作, 因此 tmpc 和 temp_col是一样的.         */        temp_dst[gid] = dot(wmat[gid], tmpc);        /*        temp_dst是3D的tensor. gid == 0, 因此是给 temp_dst[0]赋值, 根据 unpack_patch2col 函数的说明,         output: output = dot(weight, mat)即可以看做是卷积后的结果(离散卷积即, 卷积核元素和对应位置的元素相乘在相加, 即点乘dot        . 不过dot现在是矩阵之间的点乘了).         因此, temp_dst就是做完卷积的结果.         1)num_group == 1的情况下, tmpc和tmp_col是一样大小的, 代表做完unpack_patch2col后的tensor. 即tmpc是卷积层的输入数据.         tmpc有两种情况, pad[0] == pad[1] == 0 或不全为0. 总之, 就是卷积层的输入数据.         2)wmat[0]就是卷积层全部的卷积核的权重值(由于权值共享, 因此一个特征图需要一个卷积核).        wmat是卷积层的权重, 即卷积核的权重. wmat定义如下:        Shape<3> wmat_shape =        Shape3(param_.num_group,               param_.num_filter / param_.num_group,               data.shape_[1] / param_.num_group * param_.kernel[0] * param_.kernel[1]);       Tensor<xpu, 3, DType> wmat;         wmat是3Dtensor, 因此wmat[0]就是2D的tensor. 因此, 默认num_group == 1, 因此wmat的第一维最大就是0. 故wmat[0]的维数是:       { param_.num_filter / param_.num_group } * { data.shape_[1] / param_.num_group * param_.kernel[0] * param_.kernel[1] }        即: 卷积核的个数 * channel K * kernel[0] * kernel[1]. channel K == 1是做2D卷积. 因此, num_group == 1的情况下,        wmat[0]就是卷积层全部的卷积核的权重值(由于权值共享, 因此一个特征图需要一个卷积核).        批处理中, 对于一个样本来说, 卷积层的权重是相同的.        3)temp_dst[0] 即是对卷积层输入数据 tmpc 做完卷积(仅weight)后的 输出数据(批处理的).       根据unpack_patch2col 函数的说明, dot(weight, tmpc)就是做完卷积后的结果.        temp_dst[0]就是做完卷积后的结果, 这里仅仅和卷积核发生了作用. 还没有涉及偏置.       tem_dst定义如下:       Tensor<xpu, 3, DType> temp_dst; 大小为: shape_dstunit_[0] * shape_dstunit_[1] * { shape_dstunit_[2] * step), s) };       shape_dstunit_[0]是1, 即channel K; shape_dstunit_[1]是卷积层卷积核的个数; shape_dstunit_[2]是 积层输出特征图的       高度 * 宽度 之积. 因此, temp_dst的第一维最大值为0.        即num_group == 1的情况下, temp_dst[0]是2D的tensor, 大小是:       卷积核的个数(卷积层输出的特征图个数) * { 特征图大小 * batch_size }. 批处理中, 一个样本经过卷积层后的输出数据大小是:       卷积核的个数(卷积层输出的特征图个数) * 特征图大小; 对于不同的样本, 这个大小相同, 只是值不同.        因此, temp_dst[0] 即是对卷积层输入数据 tmpc 做完卷积(仅weight)后的 输出数据(批处理的).           */      }      // 以上的有些参数的值的结果是在 num_group == 1和 step == batch_size的情况下, 推出来的. 如wmat的大小, wmat[gid]的大小,       //tmpc的大小, tmp_col的大小, tmp_dst的大小等等. 這下tensor在 num_group != 1時, 均要發生变化. 这里不再细研究了.         out.Slice(i, i + step) = swapaxis<1, 0>(reshape(temp_dst,                                              mshadow::Shape4(param_.num_filter,                                                  step,                                                  out.size(2),                                                  out.size(3))));      /*      num_group == 1的情况下, gid == 0. temp_dst[0] 即是对卷积层输入数据 tmpc 做完卷积(仅weight)后的输出数据(批处理的). 大小是:      卷积核的个数(卷积层输出的特征图个数) * { 特征图大小 * batch_size }.      // cout<<"i: "<<i<<endl; // 0, i一直是0, 循环仅执行1次.       // 输入iamge后面就是卷积层.       auto a = data.Slice(i, i + step); // c++11类型推断.      cout<<"a.shape_[0]: "<<a.shape_[0]<<endl; // step, 因为step是batch_size, 所以为64. 或者a.size(0). 和index_t nstep_;相关.       cout<<"a.shape_[1]: "<<a.shape_[1]<<endl; // 1.       cout<<"a.shape_[2]: "<<a.shape_[2]<<endl; // 28.      cout<<"a.shape_[3]: "<<a.shape_[3]<<endl; // 28.      data是卷积层的输入数据, 还未做 unpack_patch2col操作. data.Slice(i, i + step)即将data切片成 [nbatcb/nstep_]份, 并行处理.      如果卷积层的输入数据data别切成了 [nbatcb/nstep_]份, 做并行处理, 那么 tmp_col 也是 [nbatcb/nstep_]份, tmp_dst也是      [nbatcb/nstep_]份. 因此, temp_dst[gid] = dot(wmat[gid], tmpc)(假设gid==0)就是做的是一份data的卷积后的结果.       out是卷积层的输入tensor, 是4D的. 如果 tmp_dst也是[nbatcb/nstep_]份的, 那么out也别切成了 [nbatcb/nstep_]份. 因此要一份份      的赋值, 最终的输出是out.       即 out.Slice(i, i + step), 这是对卷积层的输出out(一份, 即大小为step)的赋值操作. 将[nbatcb/nstep_]份out赋值完毕才算是得到      了卷积层的真正输出. 再将一份 temp_dst[0] 赋给一份的 out时, 要改变大小. 因为out是4D的, temp_dst[0]是2D的tensor.      1)reshape函数, 重新定义输入的大小. 这个reshape不是python numpy中的reshape, reshape输入接收的第一个参数是tmp_dst, 类型是      Tensor. 定义见: mshadow/mshadow/extension/reshape.h 48行. 在mshadow::exprc命名空间下.       template<typename SrcExp, typename DType, int etype, int dimdst>      inline ReshapeExp<SrcExp, DType, dimdst, ExpInfo<SrcExp>::kDim> reshape(const Exp<SrcExp, DType, etype> &src,       Shape<dimdst> oshape) {...}. reshape a tensor to another shape.      src: Tensor<Device, dimsrc>, dimsrc是src的维数, 如3.      oshape: target shape. 是Shape<dimdst> oshape, dimdst是输出tensor的维数, 如4.      return a expresion with type Tensor<Device, dimdst>.       因此reshape(temp_dst, *)就是重新temp_dst这个3D Tensor的shape, 但是数据的总个数是不变的. temp_dst[0]是2D的tensor, 大小是:      卷积核的个数(卷积层输出的特征图个数) * { 特征图大小 * batch_size }. 因此, temp_dst的大小为:      channel K * 卷积核的个数(卷积层输出的特征图个数) * { 特征图大小 * batch_size }.      reshape函数输出的shape为: num_filter * step * out.size(2) * out.size(3). 即:      卷积核个数 * step(batch_size) * 卷积层输出特征图高度 * 宽度(4D). 这样正好对上卷积层输出out tensor的维数.      reshape(temp_dst, *)就返回 卷积核个数 * step(batch_size) * 卷积层输出特征图高度 * 宽度(4D)的一个4Dtensor.      2)swapaxis函数, 函数定义见mshadow/mshadow/extension/swapaxis.h 52行. 在mshadow::exprc命名空间下.       template<int a1, int a2, typename SrcExp, typename DType, int etype>      inline SwapAxisExp<SrcExp, DType, ExpInfo<SrcExp>::kDim, ExpInfo<SrcExp>::kDim - a1, a2> swapaxis(      const Exp<SrcExp, DType, etype> &src) {...}. reshapes a tensor to another shape.      src: Tensor<Device, dimsrc>, dimsrc是src的维数, 如4.       return a expresion with type Tensor<Device,dimdst>. dimdst是输出tensor的维数, 如4.      模板参数a1: higher dimension to be swapped, assert a1 > a2. assert宏的原型定义在<assert.h>中,       其作用是如果它的条件返回错误, 则终止程序执行.      模板参数a2: lower dimension to be swapped.       swapaxis<1, 0>(...)就是对 reshape(temp_dst, *)的返回结果再重新reshape一下(..). 1, 0即指定模板参数:      int a1, int a2. 模板类, 模板函数的模板参数可以这样指定: swapaxis<1, 0>(...).        最后将reshape的结果(一份temp_dst)赋给一份 out. 一共[nbatcb/nstep_]份.       */    }    if (!param_.no_bias) { // no_bias默认为false, 这个if即使用bias. 卷积层默认不使用bias(偏置).       // add bias, broadcast bias to dim 1: channel      Tensor<xpu, 1, DType> bias = in_data[conv::kBias].get<xpu, 1, DType>(s);      // 利用get函数将in_data[2]拉成1维的张量, 即向量. 即卷积层的如果有bias, 其是向量. bias是一个1D的tensor.       // cout<<"bias.size(0): "<<bias.size(0)<<endl; // 输出卷积层bias的大小, 1D的tensor的大小. 为卷积层卷积核的个数.      // 即一个卷积核对应一个bias, 也是共享的.       out += broadcast<1>(bias, out.shape_);      /*      broadcast见: mshadow/mshadow/extension/broadcast.h 69行:      template<int dimcast, typename SrcExp, typename DType, int etype, int dimdst>      inline Broadcast1DExp<SrcExp, DType, dimdst, dimdst - dimcast> broadcast(const expr::Exp<SrcExp, DType, etype> &src,       Shape<dimdst> shape) {..}.       src Tensor<Device,1>; shape: shape of output; 返回 a expresion with type Tensor<Device, dimdst>, dimdst为4,       返回的Tensor的维数为4, 和shape的个数是有关的.      * input: Tensor<Device,1>: ishape[0]      * output: Tensor<Device,dimdst> : oshape[dimcast] = ishape[0].      模板参数tparam dimcast: target dimension where the 1D tensor will be broadcasted       将一个1维的 Tensor 扩充成 dimdst 维的 Tensor. 为了正确计算!!       out.shape_是卷积层输出out的shape, 是一个Shape<4>的变量, 大小为 卷积核数 * batch_size * 特征图高度 * 宽度.      broadcast<1>(bias, out.shape_)就是将bias这个1D张量扩展成和卷积层输出 out, 具有一样大小的tensor. 方便做加法.      即为out的每一个数据点都加上一个bias, 所以要将bias扩展成和out一样大小的tensor才可以做加法. bias的大小是卷积核的个数, 即      一个卷积核对应一个bias. 也就是卷积层的一个输出特征图对应于一个bias.       */    }  }  virtual void Backward(const OpContext &ctx,                        const std::vector<TBlob> &out_grad,                        const std::vector<TBlob> &in_data,                        const std::vector<TBlob> &out_data,                        const std::vector<OpReqType> &req,                        const std::vector<TBlob> &in_grad,                        const std::vector<TBlob> &aux_args) {    /*卷积层(第l层)有参数weight和bias(可能使用偏置, 可能不适应. 如果使用偏置, 每个卷积核配备一个),     因此要计算的是损失J关在BN层(第l层)的残差, weight的梯度和bias的梯度.     !!!!!!!!!!!!!!!!梯度可以看做是损失J关于层参数的导数, 残差可以看做是损失J关于层输入的导数!!!!!!!!!!!!!!!!!!!!!!!!!!!!     in_grad输出残差/梯度参数, 向量容器, 每个元素的类型是TBlob. 卷积层层(第l层)的.    out_grad输入残差/梯度参数, 向量容器, 每个元素的类型是TBlob. 上一层(第l + 1层)的残差/梯度, 计算本层的残差/梯度.     利用上一层的残差来计算出损失关于本层输入的残差, 从而再计算出损失关于本层参数的梯度, 再进行sgd更新. 用到的一般均是上一层的    残差.    in_data输入参数, 向量容器, 每个元素的类型是TBlob. 本层(第l层)的输入.      out_data输出参数, 向量容器, 每个元素的类型是TBlob. 本层(第l层)的输出.      req: 数据操作模式, 向量数组. 元素类型是OpReqType.    aux_args: 表示的是为了方便计算而需要的附加的 tensor. 附加的Tensor有两个: kMovingMean, kMovingVar. 以前看的操作均没使用    aux_args来辅助计算.    */    using namespace mshadow;    using namespace mshadow::expr; // 一些表达式所在的命名空间. mshadow::expr.      // TODO(bing): check the BLAS Handle, be careful    if (param_.kernel.ndim() > 2) {      LOG(FATAL) << "Volume convolution is not implmented in mshadow";    } // 0.8版本的mxnet只能做2D卷积, 因此kernel的维数如果 > 2, 就输出一个log信息; 0.9版本的mxnet可以做3D卷积了.      CHECK_EQ(out_grad.size(), 1); // 卷积层的上一层(第l + 1层)传递给卷积层的只有残差, 因此out_grad容器的大小为1.     size_t expected = param_.no_bias == 0 ? 3 : 2; //  定义expected, 如果卷积层没有偏置就是2, 否则为3. 即用expected来控制卷积    // 的in_data和in_grad容器的大小.     CHECK(in_data.size() == expected && in_grad.size() == expected); // 卷积层输入in_data和in_grad容器的大小为expected.    // 如果卷积层有偏置, 那么in_data容器大小就是3, 包含输入kData, 卷积核权重kWeight, 偏置kBias.    // in_grad容器的大小也是3, 包括损失关于卷积层输入的残差out, 损失关于卷积核权重的梯度, 损失关于偏置的梯度.     CHECK_EQ(req.size(), expected); // rep容器的大小是expected. 即, 对于:    // 损失关于卷积层输入的残差out, 损失关于卷积核权重的梯度, 损失关于偏置的梯度, 采用不同的数据操作模式.     CHECK_EQ(in_data[conv::kWeight].CheckContiguous(), true);    /*    in_data[1].CheckContiguous(), 利用CheckContiguous函数, 定义见: include/mxnet／tensor_blob.h 136行:    inline bool CheckContiguous(void) const {        return shape_[shape_.ndim() - 1] == stride_;    } CheckContiguous函数是TBlob类下的成员函数, 因此可以利用TBlob的对象调用. return whether the tensor's memory is continuous    用来检查一个tensor的内存是不是连续的. 如是是返回true, 不是返回false.    in_data[conv::kWeight]即in_data[1], 是TBlob的对象, 因此可以调用CheckContiguous函数. 用来检查in_data[1]这个tensor的内存    是不是连续的.     */    // get data    Stream<xpu> *s = ctx.get_stream<xpu>();    Tensor<xpu, 4, DType> data = in_data[conv::kData].get<xpu, 4, DType>(s);    // 利用get函数将卷积层的输入in_data[0]拉成4D的tensor, data. 代表卷积层的输入. batch_size * channel K * 高度 * 宽度.     Shape<3> wmat_shape =        Shape3(param_.num_group,               param_.num_filter / param_.num_group,               data.shape_[1] / param_.num_group * param_.kernel[0] * param_.kernel[1]);    /*    定义wmat_shape, 为定义本层(第l层)的权重wmat做准备. 即卷积层权重矩阵的shape.     s0 = param_.num_group, 即num_group(输入数据切割成num_group个partitions), 默认为1;    s1 = param_.num_filter / param_.num_group. num_filter为卷积核的个数, 在使用COnvolution时指定, num_filter的范围, 1-100000.    s2 = data.shape_[1] / param_.num_group * param_.kernel[0] * param_.kernel[1];    data.shape_[1]是data shape的第二个分量的值, 即channel K. 这里为卷积层前一层特征图的数量.      param_.kernel[0]即kernel[0], 只是使用param_来调用kernel. 在使用卷积层的时候: kernel = (5,5).      param_.kernel[1]即kernel[1].     */               Tensor<xpu, 3, DType> wmat =        in_data[conv::kWeight].get_with_shape<xpu, 3, DType>(wmat_shape, s);    /*    将卷积层权重in_data[conv::kWeight]即in_data[1]拉成3维的张量. 这利用了get_with_shape. 定义如下:    mshadow::Tensor<Device, dim, DType> mxnet::TBlob::get_with_shape(const mshadow::Shape<dim> & shape,     mshadow::Stream< Device > *stream = NULL)const, 其中Shape<dim> & shape 就是wmat_shape.     卷积层的权重wmat是3D的张量. 权重的大小是: wmat_shape. 一般的, 卷积层的卷积核(weight)的个数为:    num_filter * (kernel[0] * kernel[1]). 由于mxnet做卷积时, 用到了 num_group 机制, 因此将wmat设置成3D的, 其中第一个维度是    num_group的数目. 假设要将卷积层的输入数据data分成num_group个partitions, 那么每个partitions的卷积核个数就是:    param_.num_filter / param_.num_group个.       */        Tensor<xpu, 4, DType> grad = out_grad[conv::kOut].get<xpu, 4, DType>(s);    Tensor<xpu, 4, DType> gdata = in_grad[conv::kData].get<xpu, 4, DType>(s);    Tensor<xpu, 3, DType> gwmat =        in_grad[conv::kWeight].get_with_shape<xpu, 3, DType>(wmat_shape, s);    /*    利用get函数定义卷积层:    上一层(第l + 1层)的残差out_grad[conv::kOut]即out_grad[0], 拉成4D张量.      定义损失关于卷积层输入的残差gdata, 将in_grad[conv::kData]即in_grad[0]拉成4D的张量. mxnet在进行层的计算时, 会事先分配好内存,     即in_grad是卷积层的残差/梯度的容器, 要事先分配好这些内存.    定义损失关于卷积层权重weight的梯度gwmat, 利用get_with_shape将in_grad[conv::kWeight]即in_grad[1]拉成3D张量.     其中gwmat的shape和卷积层的卷积核的权重wmat的shape是一样的.      在使用函数get或get_with_shape时, 一并将模板参数传入.     */#if defined(__CUDACC__)    CHECK_EQ(s->blas_handle_ownership_, Stream<xpu>::OwnHandle)        << "Must init CuBLAS handle in stream";#endif // __CUDACC__宏.     const index_t nbatch = data.size(0); // nbatch即batch_size. data.size(0)即data的第一维的大小.     Tensor<xpu, 1, DType> workspace =        ctx.requested[conv::kTempSpace].get_space_typed<xpu, 1, DType>(            Shape1(this->InitTemp(data.shape_, grad.shape_)), s);    /*    与卷积层前向传播中的处理是一样的. 定义一个临时内存空间workspace, 是1D的tensor. 操作需要额外的内存作为工作空间进行计算.    InitTemp输入参数, 一个是data.shape_, 一个是grad.shape_.     */    for (index_t i = 0; i < nbatch; i += nstep_) {      const index_t step = std::min(nstep_, nbatch - i);      // 在实际运行过程中, nbatch == batch_size, nstep_ == batch_size. 因此step == batch_size. 这个和卷积层前向传播是一样的      // 设置, 即在前向传播的过程中, 根据输入数据data, weight来计算输出out. 是一份一份的进行计算的(当nstep_ < nbatch时).       // 因此, 反向传播时, 在计算残差和梯度的时候也是一份一份的计算的. 也有点并行的意思.         Tensor<xpu, 2, DType> temp_col = Tensor<xpu, 2, DType>(workspace.dptr_,                                               Shape2(shape_colunit_[0],                                                      shape_colunit_[1] * step), s);      Tensor<xpu, 3, DType> temp_dst = Tensor<xpu, 3, DType>(                                               workspace.dptr_ + temp_col.shape_.Size(),                                               Shape3(shape_dstunit_[0],                                                      shape_dstunit_[1],                                                      shape_dstunit_[2] * step), s);      /*      这三个量shape_colunit_, shape_dstunit_, nstep_.       是在运行时指定的, 是在ConvolutionOp类的私有函数InitTemp中指定的, 最新版本的convolution-inl.h中也有一个私有函数      LayerSetUp, 用来指定一些值. 根据ishape(本层输入shape)和oshape(本层输出shape)即, data.shape_, out.shape_      可以确定OP中用到的一些变量的值.       */      // cout<<"forward_nstep_: "<<nstep_<<endl; // nstep_是batch_size.        /*cout<<"shape_colunit_[0]: "<<shape_colunit_[0]<<endl;       // conv1 = mx.symbol.Convolution(data=data, kernel=(5,5), stride=(2,2), num_filter=10)时, 为25.       // shape_colunit_[0]是: 卷积层前一层特征图个数 * kernel[0] * kernel[1]. ishape[1] * ksize_y * ksize_x.      cout<<"shape_colunit_[1]: "<<shape_colunit_[1]<<endl;      // 为144, 4. 是 卷积层输出特征图的高度 * 宽度 之积. oshape[2] * oshape[3].      cout<<"shape_dstunit_[0]: "<<shape_dstunit_[0]<<endl;      //  shape_dstunit_[0]是1. param_.num_group.        cout<<"shape_dstunit_[1]: "<<shape_dstunit_[1]<<endl;      // shape_dstunit_[1]是卷积层卷积核的个数. 为10, 50. param_.num_filter / param_.num_group.      cout<<"shape_dstunit_[2]: "<<shape_dstunit_[2]<<endl;      // 是 卷积层输出特征图的高度 * 宽度 之积.  oshape[2] * oshape[3].*/       /*      和卷积层前行传播的变量一样, 利用Tensor结构体的构造函数: Tensor<xpu, 2/3, DType>(..)来创建Tensor对象temp_col和temp_dst.      temp_col是2D的张量, temp_dst是3D的张量.       在num_group == 1的情况下:       temp_col的大小为: shape_colunit_[0] * (shape_colunit_[1] * step), 即:       { 卷积层前一层特征图个数 * kernel[0] * kernel[1] } * { 卷积层输出特征图的高度 * 宽度 * step }.       temp_dst大小为: shape_dstunit_[0] * shape_dstunit_[1] * (shape_dstunit_[2] * step), 即:      { channel K } * { 卷积层卷积核的个数 } * { 卷积层输出特征图的高度 * 宽度 之积 }.      */      temp_dst = reshape(swapaxis<1, 0>(grad.Slice(i, i + step)), temp_dst.shape_);      /*      temp_dst是3D的tensor, shape上文已经定义了. grad是上一层(第l + 1层)的残差, 是4D的tensor.        利用上一层(第l + 1层)的残差定义temp_dst, 即temp_dst就代表上一层的残差. 只是在赋值的时候需要reshape.      1)reshape函数. 定义见: mshadow/mshadow/extension/reshape.h 48行. 在mshadow::exprc命名空间下.       template<typename SrcExp, typename DType, int etype, int dimdst>      inline ReshapeExp<SrcExp, DType, dimdst, ExpInfo<SrcExp>::kDim> reshape(const Exp<SrcExp, DType, etype> &src,       Shape<dimdst> oshape) {...}. reshape a tensor to another shape.      src: Tensor<Device, dimsrc>, dimsrc是src的维数, 如4.      oshape: target shape. 是Shape<dimdst> oshape, dimdst是输出tensor的维数, 如3.      return a expresion with type Tensor<Device, dimdst>.        2)swapaxis函数. 函数定义见mshadow/mshadow/extension/swapaxis.h 52行. 在mshadow::exprc命名空间下.       template<int a1, int a2, typename SrcExp, typename DType, int etype>      inline SwapAxisExp<SrcExp, DType, ExpInfo<SrcExp>::kDim, ExpInfo<SrcExp>::kDim - a1, a2> swapaxis(      const Exp<SrcExp, DType, etype> &src) {...}. reshapes a tensor to another shape.      src: Tensor<Device, dimsrc>, dimsrc是src的维数, 如4.       return a expresion with type Tensor<Device,dimdst>. dimdst是输出tensor的维数, 如4.      模板参数a1: higher dimension to be swapped, assert a1 > a2. assert宏的原型定义在<assert.h>中,       其作用是如果它的条件返回错误, 则终止程序执行.      模板参数a2: lower dimension to be swapped.       reshape的操作src相当于是: grad.Slice(i, i + step). 即对上一层的残差进行切片, 一份一份的来做. 一次for循环, 取一份(一共      [nbatch/nstep_]份)上层的残差, 来计算卷积层的残差, 权重梯度, 偏置梯度.      由于nbatch == nstep_, 因此 grad.Slice(i, i + step) 和 grad是相同的. i始终为0. 即拿上一层全部的残差grad来计算卷积层的      损失关于卷积层输入的残差, 损失关于卷积层卷积核weight的梯度, 损失关于卷积核偏置的梯度.       */      if (param_.pad[0] == 0 && param_.pad[1] == 0) { // pad[0] == pad[1] == 0, 即不对数据进行补零操作.         temp_col = unpack_patch2col(data.Slice(i, i + step),                                     param_.kernel[0],                                     param_.kernel[1],                                     param_.stride[0],                                     param_.stride[1],                                     param_.dilate[0],                                     param_.dilate[1]);        // 定义temp_col, temp_col是2D的tensor. 还是利用unpack_patch2col来定义的.         // 由于i == 0, step == batch_size, 因此data和 data.Slice(i, i + step)是相同的.         // 将图像块(patches of image)unpack(解压)成一个矩阵的一列, 在利用unpack_patch2col得到mat后, 可以实现卷积前向和反向.       } else {        temp_col = unpack_patch2col(pad(data.Slice(i, i + step), param_.pad[0], param_.pad[1]),                                     param_.kernel[0],                                     param_.kernel[1],                                     param_.stride[0],                                     param_.stride[1],                                     param_.dilate[0],                                     param_.dilate[1]);        // pad[0]或pad[1]有一个不是0, 就先利用pad函数对data.Slice(i, i + step)进行补零操作, 然后再使用unpack_patch2col函数.       } // 这和前向操作的处理是一样的. data是卷积层的输入数据, 利用unpack_patch2col函数将数据数据进行unpack, 得到temp_col,      // 再来实现卷积层的前向和反向操作.      const index_t gstride = temp_col.size(0) / param_.num_group;      // gstride类型是index_t, 即unsigned int型的. 其值为 temp_col.size(0) / param_.num_group.      // 即 shape_colunit_[0](卷积层前一层特征图个数 * kernel[0] * kernel[1].) / num_group(默认为1,       // 将输入数据切割成num_group个partitions. num_group貌似只能是1).      for (uint32_t gid = 0; gid < param_.num_group; ++gid) { // 与前向的操作是一样的. gid == 0, 开始循环. 一直到num_group.        // 一个一个partitions的操作. num_group默认为1, 即不切割数据.         Tensor<xpu, 2, DType> tmpc = temp_col.Slice(gstride * gid, gstride * (gid + 1));        /*        定义tmpc, 和前向传播一样. 是一个临时的tensor, 如果num_group != 1, 那么就将temp_col切割.         在默认 num_group == 1的情况下, gid == 0. gstride == temp_col.size(0).         因此, 为temp_col.Slice(0, gstride). 故, tmpc 和 temp_col是一样的. 这里因为没有做 输入数据切割成num_group个partitions        这个操作, 因此 tmpc 和 temp_col是一样的.         gid起的作用就是, 将一个tensor(输入数据切割成num_group个partitions), gid就代表每个        partitions的索引, 即第 gid 个partitions. 这里是利用Slice函数切割temp_col, 切割的范围是 gid-gid+1, 即将temp_col切割成        1个partitions. 每个partitions(也是一个tensor)的大小是 gstride.        */        if (i == 0) { // 因为 nbatch == nstep_, 因此 i == 0, 始终为0.           // cout<<"backward_i: "<<i<<endl; // 0           Tensor<xpu, 2, DType> tmp_gwmat = gwmat[gid]; // 可以看做是深拷贝.           /*          在默认num_group == 1的情况下, gid是0. gwmat[gid]即gwmat[0], gid就是gwmat这个tensor第一维.          gwmat是损失关于卷积层权重weight的梯度, 是3D的tensor, 其shape和wmat(卷积层的卷积核的权重)shape一样:          { param_.num_group } * { param_.num_filter / param_.num_group }           * { data.shape_[1] / param_.num_group * param_.kernel[0] * param_.kernel[1] }.          在默认num_group == 1的情况下, gwmat这个3D的tensor, 其第一维的最大值是0. gwmat[gid]是一个2D的tensor, 在0.8版本的mxnet          中, 只能实现2D卷积, 因此特征图的channel K == 1. 故 tmp_gwmat这个2D tensor的大小就是:          num_filter * { kernel[0] * kernel[1] }. 即正好是卷积层卷积核的参数的个数. 也是损失关于卷积层卷积核参数weight的梯度          的个数.          这里是定义tmp_gwmat, 即损失关于卷积层卷积核参数weight的梯度.           */          Assign(tmp_gwmat, req[conv::kWeight], dot(temp_dst[gid], tmpc.T()));          /*          Assign赋值操作. 输出是tmp_gwmat, 即给tmp_gwmat赋值; 数据操作模式是req[conv::kWeight], 即卷积层权重的数据操作模式;          exp是 dot(temp_dst[gid], tmpc.T()).          根据 unpack_patch2col 函数的说明, output: output = dot(weight, mat)即可以看做是卷积后的结果          (离散卷积即, 卷积核元素和对应位置的元素相乘在相加, 即点乘dot. 不过dot现在是矩阵之间的点乘了).           dot(temp_dst[gid], tmpc.T())即取了转置(即: A'*B 和 B'*A正好差了一个转置).           其中temp_dst[gid], 在默认num_group == 1的情况下, 其为temp_dst[0]. temp_dst是3D的tensor, 其值是上一层的残差(经过了          reshape操作). temp_dst这个3D的tensor, 其第一维的大小是channel K. 在0.8版本的为1, 因此最大即temp_dst[0].           temp_dst[0]是一个2D的tensor, 由于 i == 0, grad.Slice(i, i + step) 和 grad是相同的,           因此这个2D的tensor就是上一层全部的残差.          tmpc: 在默认 num_group == 1的情况下, gid == 0. gstride == temp_col.size(0).           因此, 为temp_col.Slice(0, gstride). 故, tmpc 和 temp_col是一样的. 这里因为没有做 输入数据切割成num_group个partitions          这个操作, 因此 tmpc 和 temp_col是一样的. tmpc即输卷积层的输入data经过unpack_patch2col操作后的结果, 即可以看做是卷积          层的真正输入数据!          tmp_gwmat就是损失关于卷积层卷积核的参数weight的梯度:          其值为: 卷积层的输入 * 上一层的残差.              */        } else { // 如果i != 0, 那么就累加即可. 每次累加的值是: dot(temp_dst[gid], tmpc.T()).           gwmat[gid] += dot(temp_dst[gid], tmpc.T());        }      }      for (uint32_t gid = 0; gid < param_.num_group; ++gid) { // gid循环, gid == 0. 只做一次for循环.         Tensor<xpu, 2, DType> tmpc = temp_col.Slice(gstride * gid, gstride * (gid + 1));        tmpc = dot(wmat[gid].T(), temp_dst[gid]);        /*        定义一个2D的tensor, tmpc. 定义的时候和上面的tmpc定义一样, 但是其值发生改变.        tmpc这个2D的tensor的值为: dot(wmat[gid].T(), temp_dst[gid]). 即矩阵做点乘. tmpc在上面定义时, 是看做卷积层真正的输入.         num_group == 1的情况下, gid == 0.         1)wmat[0]就是卷积层全部的卷积核的权重值(由于权值共享, 因此一个特征图需要一个卷积核).         wmat是3Dtensor, 因此wmat[0]就是2D的tensor. 因此, 默认num_group == 1, 因此wmat的第一维最大就是0. num_group == 1的情况下,         wmat[0]就是 卷积层全部的卷积核的权重值(由于权值共享, 因此一个特征图需要一个卷积核).         批处理中, 对于一个样本来说, 卷积层的权重是相同的.         wmat[gid].T()取转置, T是Tensor结构体下的成员函数, 用来取一个tensor的转置.           2)其中temp_dst[gid], 在默认num_group == 1的情况下, 其为temp_dst[0]. temp_dst是3D的tensor, 其值是上一层的残差(经过了        reshape操作). temp_dst这个3D的tensor, 其第一维的大小是channel K. 在0.8版本的为1, 因此最大即temp_dst[0].         temp_dst[0]是一个2D的tensor, 由于 i == 0, grad.Slice(i, i + step) 和 grad是相同的,         因此这个2D的tensor就是上一层全部的残差.         tmpc就是: 卷积层卷积核的全部weight * 上一层的残差.         */      }      // 计算损失关于卷积层的输入的残差, gdata. 分两种情况, pad[0]==pad[1]==0和不全为0.       if (param_.pad[0] == 0 && param_.pad[1] == 0) {        Assign(gdata.Slice(i, i + step), req[conv::kData],               pack_col2patch(temp_col,                              data.Slice(i, i + step).shape_,                              param_.kernel[0],                              param_.kernel[1],                              param_.stride[0],                              param_.stride[1],                              param_.dilate[0],                              param_.dilate[1]));        /*        计算损失关于卷积层的输入的残差, gdata. pad[0]==pad[1]==0的情况下.        Assign赋值操作, 赋值的对象是: gdata.Slice(i, i + step), 这和卷积的前向操作是类似的. 如果卷积层的输入数据data别切成了        [nbatcb/nstep_]份. 因此要一份份的赋值; 数据操作模式是req[conv::kData], 即卷积层输入数据的操作模式; exp为:        pack_col2patch(...)的返回值. unpack_patch2col函数是将卷积层的输入data进行unpack, 以便进行卷积操作; 而pack_col2patch正        好相反, 为了得到残差服务.        pack_col2patch函数见: mshadow/mshadow/extension/pack_col2patch.h 72行和88行. 有不同的参数. 根据所选参数:        template<typename SrcExp, typename DType, int dstdim, int etype>        inline PackColToPatchXExp<SrcExp, DType, dstdim> pack_col2patch(const expr::Exp<SrcExp, DType, etype> &src,        Shape<dstdim> imshape, index_t psize_y, index_t psize_x, index_t pstride_y, index_t pstride_x,        index_t pdilate_y, index_t pdilate_x) {..}. pack_col2patch是反向操作, 可以用来做反卷积(deconvolution)(mxnet也将反卷积        deconvolution做成了单独的一层). Deconvolution是将Convolution的方向反过来--前向变后向, 后向变前向.         返回pack 的图像. 可以这样来看, unpack_patch2col函数是将特征图变成tensor; pack_col2patch是将tensor变成特征图.          mat: source matrix; 源矩阵为 temp_col, 即对卷积层的输入data进行unpack_patch2col后的结果, 可以看做是卷积层真正的输入.          imshape: 目标img的shape; data.Slice(i, i + step).shape_, 即一份data的shape, 因为i == 0, step == batch_size, 所以就是        data.shape_, 即卷积层输入data的shape.         psize_y: 每个patch的高度;        psize_x: 每个patch的宽度;        pstride_y: 每个patch在y方向上的滑动步长;        pstride_x: 每个patch在x方向上的滑动步长;            pdilate_y_: 每个patch在y方向上的膨胀系数. 这里是dilate[0], 即卷积核的膨胀系数, y方向.         pdilate_x_: 每个patch在x方向上的膨胀系数. 这里是dilate[1], 即卷积核的膨胀系数, x方向.         !!!!!!!不知道在干什么!!!!!!!         */        // cout<<"gdata[0][0].shape_[0]: "<<gdata[0][0].shape_[0]<<endl; // 第l - 1层特征图的大小.         // cout<<"gdata[0][0].shape_[1]: "<<gdata[0][0].shape_[1]<<endl;      } else {        Shape<4> pshape = data.Slice(i, i + step).shape_;        pshape[2] += 2 * param_.pad[0];        pshape[3] += 2 * param_.pad[1];        Assign(gdata.Slice(i, i + step), req[conv::kData],               crop(pack_col2patch(temp_col,                                   pshape,                                   param_.kernel[0],                                   param_.kernel[1],                                   param_.stride[0],                                   param_.stride[1],                                   param_.dilate[0],                                   param_.dilate[1]),                    gdata[i][0].shape_));        /*        pad[0]或pad[1]有一个不是0. 要先定义 imshape: 目标img的shape.         首先定义pshape, 其为: data.Slice(i, i + step).shape_. 由于pad[0]或pad[1]不为0, 因此对pshape[2]和pshape[3]进行加和:        pshape[2] += 2 * param_.pad[0];        pshape[3] += 2 * param_.pad[1]; // 即将pshape[2]加上 2 * pad[0]. 这样定义完的pshape就是 imshape: 目标img的shape.        然后再次利用pack_col2patch函数, 操作temp_col, imshape: 目标img的shape为pshape(已经将pad信息包含在里面了).        在对pack_col2patch(...)使用crop函数, 进行裁剪. 裁剪成和 gdata[i][0].shape_即gdata[0][0].shape_一样大小的tensor.        gdata是4D的tensor, 因此gdata[0][0]就是2D的tensor, gdata[0][0].shape_就是损失关于卷积层输入的残差的shape.         是第l - 1层特征图的大小.          */        // cout<<"gdata[0][0].shape_[0]: "<<gdata[0][0].shape_[0]<<endl; // 第l - 1层特征图的大小.         // cout<<"gdata[0][0].shape_[1]: "<<gdata[0][0].shape_[1]<<endl;       }    }    /*    cout<<"grad.size(0): "<<grad.size(0)<<endl; // 64, batch_size     cout<<"grad.size(1): "<<grad.size(1)<<endl; // 10, 卷积核个数.     cout<<"grad.size(2): "<<grad.size(2)<<endl; // 12, 卷积层输入特征图高度.     cout<<"grad.size(3): "<<grad.size(3)<<endl; // 12, 卷积层输出特征图宽度.    即网络某层的残差要和该层的输入大小一致!! 以前也是这么做的. grad是上一层(第l + 1层)的残差.     */     if (!param_.no_bias) { // 卷积层使用偏置, 要求损失关于卷积层偏置的梯度.          Tensor<xpu, 1, DType> gbias = in_grad[conv::kBias].get<xpu, 1, DType>(s);      // 因为偏置是1D的tensor, 所以其梯度也是1D的. 利用get函数将卷积层的in_grad[2]拉成1D的tensor, gbias.      Assign(gbias, req[conv::kBias], sumall_except_dim<1>(grad));      /*      Assign赋值操作, 赋值对象时gbias, 即损失关于卷积层的偏置bias的梯度; 数目草书模式是kBias的; exp是sumall_except_dim<1>(grad).      即除了第1维度的, 对上一层(第l + 1层)的残差进行求和.       grad是4D的tensor. 上一层(第l + 1层)的损失关于输入的残差!        这个gbias和理论是可以对上的.       */    }  } private:  inline index_t InitTemp(const mshadow::Shape<4> &ishape,                          const mshadow::Shape<4> &oshape) {    const int ksize_y = param_.kernel[0];    const int ksize_x = param_.kernel[1]; // 定义ksize_y和ksize_x, 分别是kernel[0]和kernel[1].     shape_colunit_ = mshadow::Shape2(ishape[1] * ksize_y * ksize_x,                                     oshape[2] * oshape[3]); // 利用ishape和oshape, 对shape_colunit_赋值. 定义temp_col.     shape_dstunit_ = mshadow::Shape3(param_.num_group,                                     param_.num_filter / param_.num_group,                                     oshape[2] * oshape[3]); // 利用oshape, 对shape_dstunit_赋值. 定义temp_dst.     // param_.workspace is in elements of sizeof(DType)    // if param_.workspace is set to zero the nstep_ equals ishape[0] (batch)    nstep_ = std::max(        std::min(            static_cast<index_t>(                param_.workspace / (shape_colunit_.Size() + shape_dstunit_.Size())),            ishape[0]),        1U); // 对nstep_赋值. 做for循环.     // cout<<"nstep_: "<<nstep_<<endl; // batch_size.     mshadow::Shape<2> scol = mshadow::Shape2(shape_colunit_[0],                                             shape_colunit_[1] * nstep_); // 定义一个2D的shape, 其大小是:    // { shape_colunit_[0] } * { shape_colunit_[1] * nstep_ }.     mshadow::Shape<3> sdst = mshadow::Shape3(shape_dstunit_[0],                                             shape_dstunit_[1],                                             shape_dstunit_[2] * nstep_); // 定义一个3D的shape, 其大小为:    // { shape_dstunit_[0] } * { shape_dstunit_[1] } * {shape_dstunit_[2] * nstep_}     index_t required_size = scol.Size() + sdst.Size();    CHECK_GE(param_.workspace, required_size)      << "\nMinimum workspace size: " << required_size * sizeof(DType) << " Bytes\n"      << "Given: " << param_.workspace * sizeof(DType) << " Bytes";    return required_size; // required_size就是 scol.Size() + sdst.Size(); 即上述shape2的大小(各个维数的大小相乘) + shape3的    // 大小.   }  ConvolutionParam param_;  mshadow::Shape<2> shape_colunit_;  mshadow::Shape<3> shape_dstunit_;  index_t nstep_;  /*  shape_colunit_ , shape_dstunit_, nstep_是定义在类ConvolutionOp中的三个变量, 运行时输出一下.   shape_colunit_是Shape<2>定义的, 因此只有shape_colunit_[0]和shape_colunit_[1], 即是一个二维的shape;  shape_dstunit_是Shape<3>定义的, 因此有shape_dstunit_[0], shape_dstunit_[1], shape_dstunit_[2].  这三个量shape_colunit_, shape_dstunit_, nstep_.   是在运行时指定的, 是在ConvolutionOp类的私有函数InitTemp中指定的, 最新版本的convolution-inl.h中也有一个私有函数  LayerSetUp, 用来指定一些值. 根据ishape(本层输入shape)和oshape(本层输出shape)可以确定OP中用到的一些变量的值.   */};  // class ConvolutionOp