1. 首页
  2. 服务端开发
  3. Caffe : Layer Catalogue，2

Caffe : Layer Catalogue，2

•服务端开发•阅读 3399

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: 1
    scale: 1
    shift: 0
  }
}

      对于每一个输入值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 通过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: 1 decay_mult: 1 }
  # 偏置项（biases）的学习速率因子和衰减因子
  param { lr_mult: 2 decay_mult: 0 }
  inner_product_param {
    num_output: 1000                       # 1000个滤波器（filters）
    weight_filler {
      type: "gaussian"                     # 初始化高斯滤波器（Gaussian）
      std: 0.01                            # 标准差为0.01， 均值默认为0
    }
    bias_filler {
      type: "constant"                     # 初始化偏置项（bias）为零
      value: 0
    }
  }
  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: 0  # 这个维度与输入相同
        dim: 2
        dim: 3
        dim: -1 # 根据其他维度自动推测
      }
    }
  }

      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: 1
  }
}

          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 3 x 1 x 1
  top: "label1"
  top: "label2"
  top: "label3"
  slice_param {
    axis: 1                        # 指定维度为channel
    slice_point: 1                 # 将label[~][1][~][~]赋给label1
    slice_point: 2                 # 将label[~][2][~][~]赋给label2
                                   # 将label[~][3][~][~]赋给label3
  }
}

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

            Elementwise Operations

            • 类型（type）： Eltwise
            • （没有详解）

            Argmax

            • 类型（type）：ArgMax
            • （没有详解）

            Softmax

            • 类型（type）：Softmax
            • （没有详解）

            Mean-Variance Normalization

            • 类型（type）：MVN
            • （没有详解）

相关推荐

Copyright © 2008-2024渝ICP备2022006305号-5.

本站所有数据收集于网络如有侵犯到您的权益请联系，进行下架处理。