Skip to content

Caffe Tutorial : 5.Layer Catalogue (Kor)

Jump to bottom
HanJiHoon edited this page Jan 24, 2017 · 7 revisions

계층 (Layers)

Caffe 모델을 생성하기 위해, Protocol Buffer Definition file (prototxt)에서 모델의 설계를 정의해야할 필요가 있다. Caffe 계층들과 파라미터는 caffe.proto속 프로젝트에 대하여 protocol buffer definitions(prototxt)에 정의되어 있다.

1. 데이터 계층 (Data Layer)

데이터는 데이터 계틍을 통하여 Caffe로 들어간다: 이들은 망의 최하위에 놓여있다. 데이터는 효율적인 데이터 베이스(LevelDB 혹은 LMDB)에서 불러오며, 혹은 효율성이 별로 중대한 사항이 아니라면, HDF5내의 디스크 상 파일이나 일반 이미지 형태로 메모리로부터 바로 불러와 사용한다.

일반 입력 처리(평균연산, 스케일링, 무작위 크롭핑, 미러링)은 계층들중 일부를 사용해 TransformationParameters를 명시해줌으로써 사용이 가능하다. 편중치, 스케일, 그리고 크롭 레이어는 TransformationParameter를 사용할 수 없다면 입력을 변형하는데있어 도움을 줄 것이다.

  • 계층:

  • 이미지 데이터(Image Data) - 정제되지 않은 날 것의 데이터를 읽는다.

  • 데이터베이스(Database) - (LEVELDB 혹은 LMDB)에서 데이터를 받아 읽는다.

  • HDF5입력(HDF5 Input) - read HDF5데이터를 읽고 임시 차원의 데이터를 허용한다.

  • HDF5 출력(HDF5 Output) - HDF5형태로 데이터를 기록한다.

  • 입력(Input) - 효율적으로 사용되어진 네트워들에 대하여 전형적으로 사용이 되어진다.

  • 윈도우 데이터(Window Data) - 윈도우 데이터 파일을 읽어온다.

  • 메모리 데이터(Memory Data) - 메모리로부터 바로 데이터를 불러온다.

  • 쓰래기 데이터(Dummy Data) - 정적 데이터나 디버깅을 위한 것.

파이썬 계층은 사용자정의 데이터 계층을 생성하는데 효과적일 수도 있다.

#------------------------- W I P ------------------------ #------------------------- W I P ------------------------ #------------------------- W I P ------------------------ #------------------------- W I P ------------------------ #------------------------- W I P ------------------------

2. 시각 계층 (Vision Layers)

  • Header : ./include/caffe/vision_layers.hpp

시각 계층들은 보통 입력으로 이미지를 받아들여서 출력으로 다른 이미지를 생산한다. 현실세계에서 전형적인 "이미지"는 아마 흑백 이미지로써 단일 색 채널 (c=1) 이나, RGB (red, green, blue) 이미지로써 세개의 색 채널 (c = 3)을 가진다. 하지만 이 글 맥락에서, 이미지의 특성을 구별하는 것은 이미지의 공간적 구조이다. : 보통 이미지는 약간의 사소하지 않은 높이 h>1 그리고 너비 w>1를 가진다. 이러한 2D 기하학 구조는 자연스럽게 그자체를 입력을 어떻게 처리할지에 대한 확실한 결정을 내린다. 실제로 대부분의 시각 계층들은 출력의 지역과 일치하는 것을 생산하기 위해 입력의 몇몇 지역에 특정한 작용을 적용시킴에 의해 활동한다. 반대로, 다른 계층들은 (몇몇의 예외를 포함해) 입력의 공간적 구조를 무시한다. 이는 효율적으로 chw 차원에 "하나의 큰 벡터" 로써 그것을 다루기 때문이다.

Convolution

  • Layer type: Convolution
  • CPU implementation: ./src/caffe/layers/convolution_layer.cpp
  • CUDA GPU implementation: ./src/caffe/layers/convolution_layer.cu
  • Parameters (ConvolutionParameter convolution_param)
  • 요구사항.
  • num_output (c_o): the number of filters
  • kernel_size (or kernel_h and kernel_w): 각 필터의 너비와 높이를 명시한다.
  • 강력한 권고사항.
  • weight_filler [default type: 'constant' value: 0]
  • 추가 옵션.
  1. bias_term [default true]: 필터 출력에 추가적인 편향의 집단을 적용할 것인지 학습시킬 것인지 명시한다.
  2. pad (or pad_h and pad_w) [default 0]: (암묵적으로) 입력의 각각 사이드에 추가할 픽셀의 수를 명시한다.
  3. stride (or stride_h and stride_w) [default 1]: 출력에 필터를 적용할 간격들 위치을 명시한다
  4. group (g) [default 1]: 만약 g>1 면, 입력의 부분 집합에 각각 필터의 연결을 제한한다. 특히 입력과 출력 채널이 g 그룹들로 나누어지고, i번째 출력 그룹 채널은 오직 i번째 입력 그룹 채널과 연결될 것이다.
  • Input
  • n * c_i * h_i * w_i
  • Output
  • n * c_o * h_o * w_o, where h_o = (h_i + 2 * pad_h - kernel_h) / stride_h + 1 and w_o likewise.
  • Sample (as seen in ./models/bvlc_reference_caffenet/train_val.prototxt)
layer {
  name: "conv1"
  type: "Convolution"
  bottom: "data"
  top: "conv1"
  # learning rate and decay multipliers for the filters
  param { lr_mult: 1 decay_mult: 1 }
  # learning rate and decay multipliers for the biases
  param { lr_mult: 2 decay_mult: 0 }
  convolution_param {
    num_output: 96     # learn 96 filters
    kernel_size: 11    # each filter is 11x11
    stride: 4          # step 4 pixels between each filter application
    weight_filler {
      type: "gaussian" # initialize the filters from a Gaussian
      std: 0.01        # distribution with stdev 0.01 (default mean: 0)
    }
    bias_filler {
      type: "constant" # initialize the biases to zero (0)
      value: 0
    }
  }
}

컨볼루션 계층은 출력이미지에서 각각 하나의 특징 맵을 생산하면서 배울수 있는 필터들의 집단으로 입력 이미지를 감아놓는다.

Pooling

  • Layer type: Pooling
  • CPU implementation: ./src/caffe/layers/pooling_layer.cpp
  • CUDA GPU implementation: ./src/caffe/layers/pooling_layer.cu
  • Parameters (PoolingParameter pooling_param)
  • 요구 사항
  • kernel_size (or kernel_h and kernel_w): 각각의 필터의 높이와 너비를 명시한다.
  • 추가 사항
  • pool [default MAX]: pooling 메소드. 현재의 MAX, AVE나 STOHASTIC 명시
  • pad (or pad_h and pad_w) [default 0]: (암묵적으로) 입력의 각 사이드에 추가할 픽셀수를 명시한다.
  • stride (or stride_h and stride_w) [default 1]: 입력에 필터를 적용할 간격을 명시한다.
  • Input
  • n * c * h_i * w_i
  • Output
  • n * c * h_o * w_o, where h_o and w_o are computed in the same way as convolution.
  • Sample (as seen in ./models/bvlc_reference_caffenet/train_val.prototxt)
layer {
  name: "pool1"
  type: "Pooling"
  bottom: "conv1"
  top: "pool1"
  pooling_param {
    pool: MAX
    kernel_size: 3 # pool over a 3x3 region
    stride: 2      # step two pixels (in the bottom blob) between pooling regions
  }
}

Local Response Normalization (LRN)

  • Layer type: LRN
  • CPU Implementation: ./src/caffe/layers/lrn_layer.cpp
  • CUDA GPU Implementation: ./src/caffe/layers/lrn_layer.cu
  • Parameters (LRNParameter lrn_param)
  • 추가 사항
  • local_size [default 5]: (LRN 채널안에 대하여) 모두 더할 사각형 지역의 사이드 길이나 (cross channel LRN에 대하여) 모두 더할 채널의 수
  • alpha [default 1]: 파라미터 크기 설정 (아래 참고)
  • beta [default 5]: 지수 (아래 참고)
  • norm_region [default ACROSS_CHANNELS]: (WITHIN_CHANNEL) 공간적 위치 근처와 (ACROSS_CHANNELS) 인접한 채널중 어떤 것을 모두 더할지

공간 반응 표준화 계층은 로컬 입력 지역 전체를 표준화 함에 의해 "측면 억제"의 한 종류를 수행한다. ACROSS_CHANNELS 모드에서, 로컬 지역은 근처 채널들을 넘어 확장되지만, 공간적 확장은 없다. (예를들면 local_size x 1 x 1 같이 모양을 가질뿐이다.) WITHIN_CHANNEL에서는, 로컬 지역이 공간적으로 확장되지만, 분리된 채널들에서는 그렇지 못한다. (예를들어 그들은 1 x local_size x local_size와 같은 모양을 가질 뿐이다.) 각각의 입력값은 (1+(α/n)∑ix2i)β에 의해 나누어 지며, 여기서 n은 각각 로컬 지역의 크기이며, 합은 그 값으로 중심이 된 지역에 의해 점유된다. (zero padding이 필요한 곳에 추가된다.)

im2col

Im2col이란 아마 자세히 알아야 할 필요가 필요가 없는 이미지에서 열로 (image to column) 전환을 조력자이다. 행렬 속에 모든 패치를 펼침으로써 행렬 곱셈을 하는 Caffe의 원조 컨볼루션에서 사용했다.

3. 손실 계층 (Loss Layers)

손실은 최소화해야하는 비용을 등록함과 목료로 삼아야하는 출력을 비교함에의해 손실을 학습으로 대려간다. 손실 그자체는 정방향과정에 의해 계산되어 지고 손실에서의 그래디언트 w.r.t.는 역방향과정에 의해 계산되어진다.

소프트맥스 (Softmax)

  • Layer type: SoftmaxWithLoss

소프트맥스 손실 계층은 계층의 입력의 소프트맥스의 다항식의 로지스틱 손실(multinomial logistic loss)을 연산한다. 다항식 로지스틱 손실 계층에 의해 나타나는 소프트맥스 계층을 개념적으로는 동일하나, 더 계수적이로 안정된 그래디언트를 제공한다.

제곱합 / 유클리디언 (Sum-of-Squares / Euclidean)

  • Layer type: EuclideanLoss

유클리디안 손실 계층은 두 개의 서로다른 입력의 제곱 합을 연산한다.

\frac 1 {2N} \sum_{i=1}^N \| x^1_i - x^2_i \|_2^2

힌지와 마진 (Hinge / Margin)

  • Layer type: HingeLoss
  • CPU implementation: ./src/caffe/layers/hinge_loss_layer.cpp
  • CUDA GPU implementation: none yet
  • Parameters (HingeLossParameter hinge_loss_param)
  • Optional
  • norm [default L1]: the norm used. Currently L1, L2
  • Inputs
  • n * c * h * w Predictions
  • n * 1 * 1 * 1 Labels
  • Output
  • 1 * 1 * 1 * 1 Computed Loss
  • Samples
# L1 Norm
layer {
  name: "loss"
  type: "HingeLoss"
  bottom: "pred"
  bottom: "label"
}

# L2 Norm
layer {
  name: "loss"
  type: "HingeLoss"
  bottom: "pred"
  bottom: "label"
  top: "loss"
  hinge_loss_param {
    norm: L2
  }
}

힌지 손실 계층은 제곱된 힌지 손실이나 모든 힌지에 대항하는 하나를 계산한다.

시그모이드 크로스-엔트로피 (Sigmoid Cross-Entropy)

  • SigmoidCrossEntropyLoss

정보습득 (Infogain)

  • InfogainLoss

정확도와 K 최상위(Accuracy and Top-k)

정확도는 목표에 대하여 출력의 정확도로써 점수를 낸다. - 이것은 실제로 손실이 아니라 역방향과정이 없는 것이다.

4. 활성화 / 뉴런 계층 (Activation / Neuron Layers)

일반적으로 활성화 / 뉴런 계층은 하나의 bottom blob를 취해서 같은 사이즈의 하나의 top blob를 생성하는 원소에 관한 작동기이다. 아래의 계층들에서, 우리는 입력과 출력의 사이즈가 동일하기 때문에 무시할 것이다.

  • Input
  • n * c * h * w
  • Output
  • n * c * h * w

ReLU / 정류된-선형 그리고 새는-ReLU (ReLU / Rectified-Linear and Leaky-ReLU)

  • Layer type: ReLU
  • CPU implementation: ./src/caffe/layers/relu_layer.cpp
  • CUDA GPU implementation: ./src/caffe/layers/relu_layer.cu
  • Parameters (ReLUParameter relu_param)
  • 추가 옵션
  • negative_slope [default 0]: 네거티브 부분을 0으로 설정하기보다는 기울기 값으로 곱셈하는 것으로 누출 시킬지 아닐지를 명시한다.
  • Sample (as seen in ./models/bvlc_reference_caffenet/train_val.prototxt)
layer {
  name: "relu1"
  type: "ReLU"
  bottom: "conv1"
  top: "conv1"
}

입력값 x를 고려하여, ReLU 계층은 만약 x > 0이면 출력으로 x를 그리고 x <= 0 이면 negative_slope * x를 출력으로 계산한다. 네거티브 기울기 파라미터가 설정되어있지 않을 때, max(x, 0)을 취하는 것의 표준 ReLU 함수와 동등한다. 또한 bottom 과 top blob가 보존 매모리 장치 소비와 같게 될 수 있다는 것을 의미하며 제자리 연산 (In-place Computation)을 지원한다.

시그모이드 (Sigmoid)

  • Layer type: Sigmoid
  • CPU implementation: ./src/caffe/layers/sigmoid_layer.cpp
  • CUDA GPU implementation: ./src/caffe/layers/sigmoid_layer.cu
  • Sample (as seen in ./examples/mnist/mnist_autoencoder.prototxt)
layer {
  name: "encode1neuron"
  bottom: "encode1"
  top: "encode1neuron"
  type: "Sigmoid"
}

시그모이드 계층은 각 입력 원소 x에 대하여 sigmoid(x)로 출력을 계산한다.

하이퍼블릭 탄젠트 (TanH / Hyperbolic Tangent)

  • Layer type: TanH
  • CPU implementation: ./src/caffe/layers/tanh_layer.cpp
  • CUDA GPU implementation: ./src/caffe/layers/tanh_layer.cu
  • Sample
layer {
  name: "layer"
  bottom: "in"
  top: "out"
  type: "TanH"
}

하이퍼블릭 탄젠트 (TanH) 계층은 각 입력 원소 x에 대하여 tanh(x)로서 출력을 연산한다.

절댓값 (Absolute Value)

  • Layer type: AbsVal
  • CPU implementation: ./src/caffe/layers/absval_layer.cpp
  • CUDA GPU implementation: ./src/caffe/layers/absval_layer.cu
  • Sample
layer {
  name: "layer"
  bottom: "in"
  top: "out"
  type: "AbsVal"
}

AbsVal 계층은 각 입력 원소 x에 대하여 abs(x)로서 출력은 연산한다.

파워 (Power)

  • Layer type: Power
  • CPU implementation: ./src/caffe/layers/power_layer.cpp
  • CUDA GPU implementation: ./src/caffe/layers/power_layer.cu
  • Parameters (PowerParameter power_param)
  • 추가 옵션
  • power [default 1]
  • scale [default 1]
  • shift [default 0]
  • Sample
layer {
  name: "layer"
  bottom: "in"
  top: "out"
  type: "Power"
  power_param {
    power: 1
    scale: 1
    shift: 0
  }
}

파워 계층은 각 입력 원소 x에 대하여 (shift + scale * x) ^ power 로서 출력을 연산한다.

이진 일반 로그 유사성 (BNLL)

  • Layer type: BNLL
  • CPU implementation: ./src/caffe/layers/bnll_layer.cpp
  • CUDA GPU implementation: ./src/caffe/layers/bnll_layer.cu
  • Sample
layer {
  name: "layer"
  bottom: "in"
  top: "out"
  type: BNLL
}

BNLL (binomial normal log likelihood) 계층은 각 입력 원소 x에 대하여 log(1 + exp(x))로서 출력은 연산한다.

In-Memory

  • Layer type: MemoryData
  • Parameters
  • 요구 사항
  • batch_size, channels, height, width: 메모리로 부터 읽어오는 입력 량의 사이즈를 명시한다.

메모리 데이터 계층은 복사 없이 메모리로부터 직접 데이터를 읽어온다. 이를 사용하기 위해 (C++ 기반) "MemoryDataLayer::Reset"이나 (Python 기반)"Net.set_input_arrays"를 불러와야만 한다. (4D 행 우선 배열로써) 연속적 데이터의 소스를 명시하기위함이며 이는 한번에 일회 처리량 크기의 덩어리를 읽는다.

5. 일반 계층 (Common Layers)

내부 생산 (Inner Product)

  • ayer type: InnerProduct
  • CPU implementation: ./src/caffe/layers/inner_product_layer.cpp
  • CUDA GPU implementation: ./src/caffe/layers/inner_product_layer.cu
  • Parameters (InnerProductParameter inner_product_param)
  • 요구 사항
  • num_output (c_o): 필터의 수
  • 강력한 권고사항
  • weight_filler [default type: 'constant' value: 0]
  • 추가 옵션
  • bias_filler [default type: 'constant' value: 0]
  • bias_term [default true]: 필터 출력에 추가적 편향의 세트를 적용하고 학습할지 명시한다.
  • Input
  • n * c_i * h_i * w_i
  • Output
  • n * c_o * 1 * 1
  • Sample
layer {
  name: "fc8"
  type: "InnerProduct"
  # 가중치에대한 학습율과 감소 제곱
  param { lr_mult: 1 decay_mult: 1 }
  # 편향치에 대한 학습율과 감소 제곱
  param { lr_mult: 2 decay_mult: 0 }
  inner_product_param {
    num_output: 1000
    weight_filler {
      type: "gaussian"
      std: 0.01
    }
    bias_filler {
      type: "constant"
      value: 0
    }
  }
  bottom: "fc7"
  top: "fc8"
}

"InnerProduct" 계층은 (완전 연결 계층으로써 보통 언급됨) 샘플 벡터로써 입력을 다루고 (1로 blob의 높이와 너비를 설정하면서)단일 벡터의 형태에서 출력을 생산한다.

분열 (Splitting)

"Split" 계층은 다중 출력 blob에 입력 blob을 나누는 도구 계층이다. 이는 blob가 다중 출력 계층으로 적용됬을 때 사용된다.

편율, 타원율 (Flattening)

"Flatten" 계층은 n * (chw)모양의 간단한 백터 출력에 n * c * h * w 모양의 입력을 납작하게 만드는 도구 계층이다.

재구성 (Reshape)

  • Layer type: Reshape
  • Implementation: ./src/caffe/layers/reshape_layer.cpp
  • Parameters (ReshapeParameter reshape_param)
  • 추가 옵션: (아래 자세한 설명을 참고)
  • shape
  • 입력
  • 임의적인 차원들로 이루어진 단일 blob
  • 출력
  • "reshape_param"로써 명시된, 수정된 차원들로 이루어진 같은 blob reshape_param
  • Sample
  layer {
    name: "reshape"
    type: "Reshape"
    bottom: "input"
    top: "output"
    reshape_param {
      shape {
        dim: 0  # bottom 계층의 각각 차원을 복사한다.
        dim: 2
        dim: 3
        dim: -1 # 다른 차원으로 부터 추론한다.
      }
    }
  }

"Reshape" 계층은 데이터의 변화 없이 입역의 차원을 변화시키는데 사용된다. 타원율 계층 (Flatten layer)처럼, 차원만 바뀐다. 과정중에 어떤 데이터도 복사되지 않는다. 출력 차원은 "ReshapeParam"proto에 의해 명시된다. 출력 blob 차원에 해당하게 설정하면서 양수는 바로 사용된다. 추가로, 두 개의 특별한 값은 어떤 목표 차원 값에 대하여 받아들인다 :

  • 0 은 "bottom 계층의 각각 차원을 복사한다."를 의미한다. 즉, 첫 차원에서 bottom이 2를 가지고 있으면, 첫번째 목표 차원으로써 "dim:0"을 주면서, top 또한 이의 첫번째 계층으로써 2를 가진다.
  • -1 “다른 차원으로 부터 추론한다.”를 뜻한다. 이 행동은 MATLAB의 재구성에 대하여 numpy's나 []에서 -1에 대한 것과 비슷하다. : 이 차원은 bottom 계층에서와 같이 전체 원소 카운트를 계산한다. 대부분의 것에서 -1은 재구성 작동으로 사용될 수 있다.

다른 예로써 "reshape_param { shape { dim: 0 dim: -1 } }"를 명시하는 것은 타원율 계층에서 처럼 정확히 같은 방법으로 행동하는 계층을 생성한다.

연속 (Concatenation)

  • Layer type: Concat
  • CPU implementation: ./src/caffe/layers/concat_layer.cpp
  • CUDA GPU implementation: ./src/caffe/layers/concat_layer.cu
  • Parameters (ConcatParameter concat_param)
  • 추가사항
  • axis [default 1]: 0은 num에 따른 연속, 1은 channel에 따른 연속.
  • Input
  • n_i * c_i * h * w for each input blob i from 1 to K.
  • Output
  • if axis = 0: (n_1 + n_2 + ... + n_K) * c_1 * h * w, and all input c_i should be the same.
  • if axis = 1: n_1 * (c_1 + c_2 + ... + c_K) * h * w, and all input n_i should be the same.
  • Sample
layer {
  name: "concat"
  bottom: "in1"
  bottom: "in2"
  top: "out"
  type: "Concat"
  concat_param {
    axis: 1
  }
}

"Concat" 계층은 단일 출력 blob에 다중 입력 blob를 연속시키는 도구 계층이다.

슬라이싱 (Slicing)

"Slice"계층은 주어진 슬라이스 지표에 따라서 (현재 num 이나 channel 만) 주어진 차원을 따라 다중 출력 계층에 입력 계층을 썰어주는 도구 계층이다.

  • Sample
layer {
  name: "slicer_label"
  type: "Slice"
  bottom: "label"
  ## Example of label with a shape N x 3 x 1 x 1
  top: "label1"
  top: "label2"
  top: "label3"
  slice_param {
    axis: 1
    slice_point: 1
    slice_point: 2
  }
}

"axis"는 목표축을 나타낸다. ; "slice_point"는 선택된 차원에서 지표를 나타낸다. (지표들의 수는 top blob의 마이너스 1의 수와 동등해야만한다.)

Elementwise Operations

Eltwise

Argmax

ArgMax

Softmax

Softmax

Mean-Variance Normalization

MVN

Clone this wiki locally