Caffe : Layer Catalogue(2)

时间:2021-01-31 10:27:30

TanH / Hyperbolic Tangent

  • 类型(type):TanH
  • CPU 实现: ./src/caffe/layers/tanh_layer.cpp
  • CUDA、GPU实现: ./src/caffe/layers/tanh_layer.cu

  • 例子

    layer {
    name: "layer"
    bottom: "in"
    top: "out"
    type: "TanH"
    }

    对于每一个输入值x,TanH layer的输出为tanh(x)。

  • Absolute Value

    • 类型(type):AbsVal
    • CPU 实现: ./src/caffe/layers/absval_layer.cpp
    • CUDA、GPU实现: ./src/caffe/layers/absval_layer.cu

    • 例子

    • layer {
      name: "layer"
      bottom: "in"
      top: "out"
      type: "AbsVal"
      }

      对于每一个输入值x,AbsVal layer的输出为abs(x)。

      Power

        • 类型(type):Power
        • CPU 实现: ./src/caffe/layers/power_layer.cpp
        • CUDA、GPU实现: ./src/caffe/layers/power_layer.cu
        • 参数 (power_param):

          • 可选:
            • power [default 1](指数,默认为1)
            • scale [default 1](比例,默认为1)
            • shift [default 0](偏移,默认为0)
        • 例子

      layer {
      name: "layer"
      bottom: "in"
      top: "out"
      type: "Power"
      power_param {
      power:
      scale:
      shift:
      }
      }

      对于每一个输入值x,Power layer的输出为(shift + scale * x) ^ power。

      BNLL

      • 类型(type):BNLL(二项正态对数似然,binomial normal log likelihood)
      • CPU 实现: ./src/caffe/layers/bnll_layer.cpp
      • CUDA、GPU实现: ./src/caffe/layers/bnll_layer.cu
      • 例子
      • layer {
        name: "layer"
        bottom: "in"
        top: "out"
        type: BNLL
        }

        对于每一个输入值x,BNLL layer的输出为log(1 + exp(x))。

      • --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
      • Data Layers

        Data 通过Data Layers进入Caffe,Data Layers位于Net的底部。
        Data 可以来自:1、高效的数据库(LevelDB 或 LMDB);2、内存;3、HDF5或image文件(效率低)。
        基本的输入预处理(例如:减去均值,缩放,随机裁剪,镜像处理)可以通过指定TransformationParameter达到。

        Database

        • 类型(type):Data(数据库)
        • 参数:
          • 必要:
            • source: the name of the directory containing the database(数据库名称)
            • batch_size: the number of inputs to process at one time(每次处理的输入的数据量)
          • 可选:
            • rand_skip: skip up to this number of inputs at the beginning; useful for asynchronous sgd(在开始的时候跳过这个数值量的输入;这对于异步随机梯度下降是非常有用的)
            • backend [default LEVELDB]: choose whether to use a LEVELDB or LMDB(选择使用LEVELDB 数据库还是LMDB数据库,默认为LEVELDB)

        In-Memory

        • 类型(type):MemoryData
        • 参数:
          • 必要:
            • batch_size, channels, height, width: specify the size of input chunks to read from memory(4个值,确定每次读取输入数据量的大小)

        Memory Data Layer从内存直接读取数据(而不是复制数据)。使用Memory Data Layer之前,必须先调用,MemoryDataLayer::Reset(C++方法)或Net.set_input_arrays(Python方法)以指定一个source来读取一个连续的数据块(4D,按行排列),每次读取大小由batch_size决定。

        HDF5 Input

        • 类型(type):HDF5Data
        • 参数:
          • 必要:
            • source: the name of the file to read from(读取的文件的名称)
            • batch_size(每次处理的输入的数据量)

        HDF5 Output

        • 类型(type):HDF5Output
        • 参数:

          • 必要:
            • file_name: name of file to write to(写入的文件的名称)

          HDF5 output layer与这部分的其他layer的功能正好相反,不是读取而是写入。

        Images

        • 类型(type):ImageData
        • 参数:
          • 必要:
            • source: name of a text file, with each line giving an image filename and label(一个text文件的名称,每一行指定一个image文件名和label)
            • batch_size: number of images to batch together(每次处理的image的数据)
          • 可选:
            • rand_skip: (在开始的时候跳过这个数值量的输入)
            • shuffle [default false](是否随机乱序,默认为否)
              -new_height, new_width: if provided, resize all images to this size(缩放所有的image到新的大小)

        Windows

        • 类型(type):WindowData
        • (没有详解)

        Dummy

        • 类型(type):DummyData

        DummyData 用于开发和测试,详见DummyDataParameter(没有给出链接)。

      • --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
      • Common Layers

        Inner Product

          • 类型(type):Inner Product(全连接层)
          • CPU 实现: ./src/caffe/layers/inner_product_layer.cpp
          • CUDA、GPU实现: ./src/caffe/layers/inner_product_layer.cu
          • 参数 (inner_product_param):

            • 必要:
              • num_output (c_o): the number of filters(滤波器数目)
            • 强烈推荐:
              • weight_filler [default type: ‘constant’ value: 0](滤波器权重;默认类型为constant,默认值为0)
            • 可选:
              • bias_filler [default type: ‘constant’ value: 0](bias-偏置项的值,默认类型为constant,默认值为0)
              • bias_term [default true]: specifies whether to learn and apply a set
                of additive biases to the filter outputs(是否添加bias-偏置项,默认为True)
          • 输入(Input)

            • n * c_i * h_i * w_i
          • 输出(Output)

            • n * c_o * 1 * 1
          • 例子

        layer {
        name: "fc8" # 名称:fc8
        type: "InnerProduct" # 类型:全连接层
        # 权重(weights)的学习速率因子和衰减因子
        param { lr_mult: decay_mult: }
        # 偏置项(biases)的学习速率因子和衰减因子
        param { lr_mult: decay_mult: }
        inner_product_param {
        num_output: # 1000个滤波器(filters)
        weight_filler {
        type: "gaussian" # 初始化高斯滤波器(Gaussian)
        std: 0.01 # 标准差为0., 均值默认为0
        }
        bias_filler {
        type: "constant" # 初始化偏置项(bias)为零
        value:
        }
        }
        bottom: "fc7" # 输入层:fc7
        top: "fc8" # 输出层:fc8
        }

      InnerProduct layer(常被称为全连接层)将输入视为一个vector,输出也是一个vector(height和width被设为1)

      Splitting

      • 类型(type):Split

      Split layer用于将一个输入的blob分离成多个输出的blob。这用于当需要将一个blob输入至多个输出layer时。

      Flattening

      • 类型(type):Flatten

      Flatten layer用于把一个维度为n * c * h * w的输入转化为一个维度为 n * (c*h*w)的向量输出。

      Reshape

        • 类型(type):Reshape
        • CPU 实现: ./src/caffe/layers/reshape_layer.cpp
        • CUDA、GPU实现: 尚无
        • 参数 (reshape_param):

          • 可选:
            • shape(改变后的维度,详见下面解释)
        • 输入(Input)

          • a single blob with arbitrary dimensions(一个任意维度的blob)
        • 输出(Output)

          • the same blob, with modified dimensions, as specified by reshape_param(相同内容的blob,但维度根据reshape_param改变)
        • 例子

       layer {
      name: "reshape" # 名称:reshape
      type: "Reshape" # 类型:Reshape
      bottom: "input" # 输入层名称:input
      top: "output" # 输出层名称:output
      reshape_param {
      shape {
      dim: # 这个维度与输入相同
      dim:
      dim:
      dim: - # 根据其他维度自动推测
      }
      }
      }

      Reshape layer只改变输入数据的维度,但内容不变,也没有数据复制的过程,与Flatten layer类似。

      输出维度由reshape_param 指定,正整数直接指定维度大小,下面两个特殊的值:

      • 0 => 表示copy the respective dimension of the bottom layer,复制输入相应维度的值。
      • -1 => 表示infer this from the other dimensions,根据其他维度自动推测维度大小。reshape_param中至多只能有一个-1。

      再举一个例子:如果指定reshape_param参数为:{ shape { dim: 0 dim: -1 } } ,那么输出和Flattening layer的输出是完全一样的。

      Concatenation

        • 类型(type):Concat(连结层)
        • CPU 实现: ./src/caffe/layers/concat_layer.cpp
        • CUDA、GPU实现: ./src/caffe/layers/concat_layer.cu
        • 参数 (concat_param):

          • 可选:
            • axis [default 1]: 0 for concatenation along num and 1 for channels.(0代表连结num,1代表连结channel)
        • 输入(Input)
          -n_i * c_i * h * w for each input blob i from 1 to K.(第i个blob的维度是n_i * c_i * h * w,共K个)

        • 输出(Output)

          • if axis = 0: (n_1 + n_2 + … + n_K) * c_1 * h * w, and all input
            c_i should be the same.(axis = 0时,输出 blob的维度为(n_1 + n_2 + … + n_K) * c_1
            * h * w,要求所有的input的channel相同)
          • if axis = 1: n_1 * (c_1 + c_2 + … + c_K) * h * w, and all input n_i
            should be the same.(axis = 0时,输出 blob的维度为n_1 * (c_1 + c_2 + … + c_K) * h
            * w,要求所有的input的num相同)
        • 例子

          layer {
          name: "concat"
          bottom: "in1"
          bottom: "in2"
          top: "out"
          type: "Concat"
          concat_param {
          axis:
          }
          }

          Concat layer用于把多个输入blob连结成一个输出blob。

          Slicing

          Slice layer用于将一个input layer分割成多个output layers,根据给定的维度(目前只能指定num或者channel)。

          • 类型(type):Slice
          • 例子
          • layer {
            name: "slicer_label"
            type: "Slice"
            bottom: "label"
            ## 假设label的维度是:N x x x
            top: "label1"
            top: "label2"
            top: "label3"
            slice_param {
            axis: # 指定维度为channel
            slice_point: # 将label[~][][~][~]赋给label1
            slice_point: # 将label[~][][~][~]赋给label2
            # 将label[~][][~][~]赋给label3
            }
            }

            axis表明是哪一个维度,slice_point是该维度的索引,slice_point的数量必须是top blobs的数量减1.

            Elementwise Operations

            • 类型(type): Eltwise
            • (没有详解)

            Argmax

            • 类型(type):ArgMax
            • (没有详解)

            Softmax

            • 类型(type):Softmax
            • (没有详解)

            Mean-Variance Normalization

            • 类型(type):MVN
            • (没有详解)