this.code();

[What is CNN ?]

CNN, Convolutional Neural Network은 기존 딥러닝 신경망이었던 Fully-Connected Layer를 대체하기 위해 나왔다.

CNN은 Locally-Connected Layer로 Fully-Connected Layer에 비해 정보손실이 발생할 수 있다.

하지만 CNN은 이런 정보손실에 대해 channel을 많이 줌을 통해 정보손실을 방지할 수 있다.

또한 CNN은 FC보다 훨씬 weight수 즉, param#이 더 줄어든다

weight의 개수 = input_channel수 x kernel개수 x kernel개수 x output_channel
(단, padding='same')

filter를 weight로 하며, 이때 model은 weight를 조정하여 filter를 모델이 '알아서' 만들도록 한다.

(filtering을 모델에게 맡겨 상황에 따라 필요한 filter를 자체적으로 만들 수 있게 하는 것이다.)

[Auto-Encoder]

[본 목적] 

input의 압축 => 스스로 압축 알고리즘을 학습할 수 있는, input에 근사한 압축값을 뽑아낼 수 있음.
- 특정 분야에서 정상적으로 동작한다. 

(글자->강아지로 클래스가 변하게 된다면? 특징을 못뽑을 수도 있는, 특정 dataset에서만 가능한 비범용적 방법이다.)

- 주로 언어모델, segmentation 등등에서 사용됨.)

Encoding

- 코드화 시키는 것 = 어떠한 코드로 1:1 매칭시키는 것 
- 암호화 즉, 용량 압축의 효과 및 일반화도 가능하다.

bottleneck

- 정보가 embedding되어 있음(= 필요 정보만 모여있는 것)

Decoding

- decoding은 사람이 이해하도록 바꿔주는 것으로 encoding과 반대 개념이다.
- 이때, input image에 비해 손실이 발생한다.

[Curse of Dimensionality., 차원의 저주]

- 차원이 늘어날수록 문제를 풀기 쉬워지는것은 어느 정도까지이다!
- 즉, 역효과가 발생가능하다. → 도리어 학습이 안될 수 있다는 것!

[ERF (Effective Receptive Field)]

 - 학습이 되면서 점점 receptive field가 Gaussian distribution 형태에 가까워지는데, 이를 effective receptive field라 한다. 
 - (가장 최외각의 patch는 뒤로 갈수록 영향력이 줄고, 가운데 patch의 영향력이 커져 뒤로갈수록 정규분포와 비슷해져버림)
 - 이러한 문제로 인해 CNN이 깊게 쌓을 수 없게 된다. → attention을 이용한 transformer, ViT가 나오게 된 배경이 되어 버림!

 😶 실습 _ by tensorflow

[What is Deep Learning ?]

Deep Learning = 주어진 input에 대해 최적의 답을 구하는 함수를 찾기 위한 알고리즘 과정

XOR Problem과 같이 사람이 구하기 어려운 함수식을 가장 근사한 함수값으로 도달하게 해주는것, 그것이 바로 딥러닝이다.

이때, Deep Learning으로 구해진 해는 Universal Approximation 즉, 보편적인 근사치이다.

Deep Learning은 perceptron으로 이뤄진 Neural Net을 기반으로 하는 Machine Learning기법이다.

DeepLearning을 나누는 방법

 - Supervised: label이 있음
 - Unsupervised: label이 없음
 - Reinforce: 데이터의 개수가 가변적이고 observe game(현상을 관찰, 관찰해 나온 값과 바뀐 값에 대해 어떻게 학습할 것인지, 라벨이 없어서 unsupervised랑 가까우며, 실시간적이라 simulation과 엮임)

[Deep Learning의 가장 핵심이 되는 기술 → non-linearity]
non-linearity function: non-linearity한 information을 파악하는데 매우 특화된 함수

# 정보이론

information, 자연적 정보를 수학적으로 표현 가능하다

= 여러 정보를 value 즉, data로 나타낼 수 있다는 것으로 이때, data는 패턴으로 바뀐다.

즉, data+pattern => information을 설명가능하다.

 😶 실습 _ by tensorflow

Sharpening

blurring의 반대개념으로 image 흐릿한 것을 뚜렷하게 만드는 방법

[실습] 

sharpening

Noise

흐름에 맞지않는, Abnormal한 data를 의미

Noise 생성

😶 초록 (Abstract)

- 심층신경망은 "over-parameterized"되거나 "weight_decay. &. dropout"같은 엄청난 양의 noise와 regularize로 훈련될 때, 종종 잘 작동하곤한다.
비록 Dropout이 FC.layer층에서 매우 포괄적으로 사용되는 regularization기법이지만, conv.layer에서 종종 덜 효과적이다.
이런 Conv.layer에서의 Dropout기법의 성공의 결핍은 conv.layer의 activation unit이 "dropout에도 불구하고 공간적 상관관계"가 있기에 정보가 여전히 conv.layer를 통해 흐를 수 있다는 점이다.
∴ CNN의 정규화를 위해 구조화된 형태의 dropout기법이 필요하다!

- 이 구조화된 형태의 dropout기법을 본 논문에서 소개하는데, 바로 Dropout이다.
Dropout기법은 특징맵의 인접영역에 있는 units를 함께 Drop시키는 방법을 채택한다.
우린 "skip-connection"에 DropBlock을 적용함으로써 정확도의 향상을 이룩했다.
또한, training시 Drop의 수를 점차 늘리면서 2가지 이점을 얻었다.
  i) 더 나은 accuracy
  ii) hyperparameter의 선택의 확고성(robust)

- 수많은 실험에서 DropBlock은 CNN을 규제화하는 데 Dropout보다 더 잘 작동한다.
ImageNet에서 DropBlock을 사용하는 ResNet-50 아키텍처는 78.13%의 정확도를 달성하여 기존보다 1.6% 이상 향상되었다. COCO Detection에서 DropBlock은 RetinaNet의 평균 정밀도를 36.8%에서 38.4%로 향상시킨다.

1. 서론 (Introduction)

- 심층신경망은 "over-parameterized(= parameter수가 많은)"되거나 "weight_decay. &. dropout"같은 엄청난 양의 noise와 regularize로 훈련될 때, 종종 잘 작동하곤한다.
CNN에서 dropout의 첫등장으로 막대한 성공에도 불구하고, 최근 연구에서 convolutional architectures에서 dropout이 사용되는 경우는 극히 드물다. [BN, ResNet,...등 논문]
대부분의 경우, dropout은 CNN에서 주로 "Fully-Connected layer"에서 메인으로 사용된다.

- 우린 Dropout의 핵심결점이 "drops out feature randomly"라고 주장한다.
특징을 무작위로 제거하는 것이 FC.layer에서는 좋을 수는 있으나, "공간적 상관관계"가 존재하는 Conv.layer에서는 덜 효과적이다.
dropout에도 불구하고, 특징간의 상관관계가 존재한다는 것은 "input정보가 다음층에도 전달된다는 것"이며 이는 신경망의 "overfitting"을 야기할 수 있다.
이런 직관은 CNN의 규제화를 위해 더 구조화된 dropout이 필요하다는 것을 시사한다.

- 본 논문에서, (dropout을 구조화하여 CNN규제화에 부분적으로 효과가 있는) DropBlock에 대해 소개한다. 
DropBlock에서 block내의 특징, 즉 특징맵의 인접영역이 함께 drop된다.
DropBlock은 상관영역의 특징을 폐기(discard)하므로 신경망은 data에 적합한 증거를 다른 곳에서 찾아야한다. (그림 1 참조).

- 우리 실험에서, DropBlock은 다양한 모델과 dataset에서 dropout보다 훨씬 낫다.
ResNet-50 에 DropBlock을 추가하면 ImageNet의 Image Classification의 정확도가 76.51%에서 78.13%로 향상된다.
COCO detection에서 DropBlock은 RetinaNet의 AP를 36.8%에서 38.4%로 향상된다.

2. Related work

- 서론에서 말했듯, Dropout은 DropConnect, maxout, StochasticDepth, DropPath, ScheduledDropPath, shake-shake regularization, ShakeDrop regularization같은 신경망에 대한 여러 정규화 방법에서 영감을 받었다.
이런 방법들의 기본 원칙은 training data에 overfitting되지 않기위해 신경망에 noise를 추가한다.
CNN의 경우, 전술한 대부분의 성공적 방법은 noise가 구조화되어야 한다는 것이다.
예를 들어, DropPath에서 신경망의 전체 계층은 특정 단위뿐만 아니라 훈련에서 제외된다.
이러한 dropping out layer의 전략은 입출력 branch가 많은 계층에 잘 적용될 수 있지만 branch가 없는 계층에는 사용할 수 없다.
cf) "block"을 conv.layer내의 인접한 특징맵의 집합으로 정의하고
"branch"를 동일한 공간 해상도를 공유하는 연속된 block의 집합으로 정의한다.

우리의 방법인 DropBlock은 CNN의 모든 곳에 적용할 수 있다는 점에서 더 일반적이다.
우리의 방법은 전체 channel이 특징맵에서 drop되는 SpatialDropout과 밀접한 관련이 있기에 우리의 실험은 DropBlock이 SpatialDropout보다 더 효과적이라는 것을 보여준다.

- Architecture에 특정된 이런 noise주입 기술의 개발은 CNN에만 국한되지 않는다.
실제로 CNN과 유사하게 RNN은 자체적인 noise의 주입방식을 필요로 한다.
현재, Recurrent Connections에 noise를 주입하는 데 가장 일반적으로 사용되는 방법 중 두 가지가 있는데, 
바로 Variational Dropout과 ZoneOut이다.

- 우리의 방법은 입력 예제의 일부가 영점 처리(zeroed out)되는 데이터 증강 방법인 Cutout에서 영감을 얻었다.
DropBlock은 CNN의 모든 특징맵에서 Cutout을 적용하여 Cutout을 일반화한다.
우리의 실험에서, training 중 DropBlock에 대해 고정된 zero out비율을 갖는 것은 훈련 중 zero out비율이 증가하는 schedule을 갖는 것만큼 강력하지 않다.
즉, 교육 중에는 초기에 DropBlock 비율을 작게 설정하고, 교육 중에는 시간이 지남에 따라 선형적으로 증가시키는 것이 좋으며, 이 scheduling 체계는 ScheduledDropPath와 관련이 있다. 

3. DropBlock

- DropBlock은 dropout과 비슷한 간단한 방법이지만, dropout과의 주된 차이점은 
Dropout: dropping out independent random unit
DropBlock: drops contiguous regions from a feature map of a layer

DropBlock은 2가지의 주요 parameter가 있다.
  i) block_size : drop할 block의 크기 
  ii) 𝛾 :얼마나 많은 activation units를 drop할 것인지
우리는 서로 다른 feature channel에 걸쳐 공유된 DropBlock mask를 실험하거나 각 feature channel에 DropBlock 마스크를 지니게 한다. Algorithm 1은 후자에 해당하며, 이는 우리의 실험에서 더 잘 작동하는 경향이 있다.

Dropout과 유사하게 우리는 추론시간중 DropBlock을 적용하지 않는데, 이는 기하급수적으로 크기가 큰 하위신경망의 앙상블에 걸쳐 평균예측을 평가하는 것으로 해석된다.
이런 하위신경망은 각 신경망이 각 특징맵의 인접한 부분을 보지 못하는 Dropout으로 커버되는 특별한 하위신경망의 하위집합을 포함한다.



• Setting the value of block_size



•Setting the value of  𝛾

 •Scheduled DropBlock

4. Experiments

다음 Section에서는 Image Classification, Object Detection 및 Semantic Segmentation에 대한 DropBlock의 효과를 경험적조사를 진행한다.
Image Classification을 위한 광범위한 실험을 통해 ResNet-50에 DropBlock을 적용한다.
결과가 다른 아키텍처로 전송가능여부의 확인을 위해 최첨단 모델인 AmoebaNet에서 DropBlock을 수행하고 개선 사항을 보여준다.
Image classification 외에도, 우리는 DropBlock이 Object Detection 및 Semantic Segmentation을 위한 RetinaNet을 훈련하는 데 도움이 된다는 것을 보여준다.

4.1  ImageNet Classification

ILSVRC 2012 classification dataset
- train: 1.2M , valid: 5만 , test: 15만, 1000-class label
이미지에는 1,000개의 범주가 레이블로 지정됩니다.
[GoogLeNet, DenseNet]처럼 training하기 위해 horizontal flip, scale, 종횡비율확대를 사용했다.
evaluation에서 multiple crop대신, single crop을 적용했다.
일반적 관행에 따라 검증 세트에 대한 분류 정확도를 보고한다.

 • Implementation Details
우리는 텐서 처리 장치(TPU)에 대한 모델을 교육하고 공개된 ResNet-50 및 AmebaNet에 대해 tensorflow로 구현을 사용했다. [https://github.com/tensorflow/tpu/tree/master/models/official/resnet //  https://github.com/tensorflow/tpu/tree/master/models/experimental/amoeba_net ]

우리는 모든 모델에 대해
 - 기본 image size (ResNet-50의 경우 224 x 224, AmebaNet의 경우 331 x 331)
 - batch size (ResNet-50의 경우 1024, AmebaNet의 경우 2048)
  - 및 하이퍼 파라미터 설정을 적용했다.
우린 단지 ResNet-50 아키텍처에 대한 training epoch을 90개에서 270개로 늘렸을 뿐이다.
학습률은 125, 200, 250 epoch마다 0.1배 감소했다.

AmebaNet 모델은 340epoch 동안 훈련되었으며 학습률스케줄링을위해 지수decay체계가 사용되었다.
기존의 모델은 일반적으로 더 긴 training scheme으로 인해 overfitting되어서 훈련이 종료되면 validation accuracy가 낮다.
따라서 공정한 비교를 위해 전체 training과정에 걸쳐 가장 높은 validation accuracy를 보고한다

 4.1.1  DropBlock in ResNet-50

ResNet-50은 이미지 인식을 위해 널리 사용되는 CNN아키텍처이다.
다음 실험에서, 우리는 ResNet-50에 다른 규제화 기술을 적용하고 결과를 DropBlock과 비교한다.
결과는 표 1에 요약되어 있다.

 • Where to apply DropBlock
ResNet에서 building block은 몇 개의 conv.layer와 identity mapping을 수행하는 별도의 skip-connection으로 구성된다.
모든 conv.layer는 Batch Normalizatoin layer 및 ReLU activation에 따른다.
building block의 출력은 convolution building block의 출력은 convolution branch의 출력과 skip connection 출력의 합이다.

ResNet은 활성화함수의 공간적 해상도에 기초하여 그룹을 구축하여 나타낼 수 있는데, building group은 여러 building block으로 구성된다.
우리는 그룹 4를 사용해 ResNet의 마지막 group(즉, conv5_x의 모든 layer)을 나타낸다.

다음 실험에서는 ResNet에서 DropBlock을 적용할 위치를 연구한다.
  ① conv.layer이후에만 DropBlock을 적용하거나
  ② conv.layer와 skip-connection 둘 모두 뒷부분에 DropBlock을 적용하는 실험을 했다.
다양한 특징 그룹에 적용되는 DropBlock의 성능을 연구하기 위해 그룹 4 또는 그룹 3과 그룹 4 모두에 DropBlock을 적용하는 실험을 했다.

 • DropBlock. vs. dropout
원래 ResNet 아키텍처는 모델의 Dropout을 적용하지 않는다. 다만 논의의 용이성을 위해 기존 ResNet의 Dropout을 convolution branch에만 dropout을 적용하는 것으로 정의한다.
기본적으로 block_size = 7로 그룹 3과 4 모두에 DropBlock을 적용한다.
우리는 모든 실험에서 그룹 3에 대해 parameter 𝛾를 4만큼 감소시켰다.
그림 3-(a)에서, 우리는 top-1 accuracy에서 DropBlock이 1.3%로 Dropout을 능가한다는 것을 보여준다.
reserved keep_prob는 DropBlock을 keep_prob의 변경에 더 강력하게 만들고 keep_prob(3-(b))의 가장 많은 값에 대한 개선을 추가한다.

그림 3에서 최고의 keep_prob를 통해 발결한 점은 바로  block_size가 1에서 전체 특징맵을 포함하는 block_size로 바뀌었다는 것이다.
그림 4는 일반적으로 1의 block_size를 적용하는 것보다 큰 block_size를 적용하는 것이 더 낫다는 것을 보여주며 최상의 DropBlock 구성은 block_size = 7을 그룹 3과 4에 모두 적용하는 것입니다.

모든 구성에서 DropBlock과 Dropout은 유사한 추세를 공유하며 DropBlock은 최상의 Dropout 결과에 비해 큰 이득을 보입니다.
이것은 DropBlock이 Dropout에 비해 더 효과적인 규제화 도구라는 증거를 보여준다.


 •DropBlock. vs. SpatialDropout
기존의 Dropout과 유사하게, 우리는 기존의 SpatialDropout기법이 convolution branch에만 적용하는 것으로 정의한다.
SpatialDropout기법은 Dropout기법보다는 낫지만 DropBlock다는 떨어진다.
(즉, DropBlock > SpatialDropout > Dropout)
그림 4에서 그룹 3의 고해상도 특징맵에 적용할 때, SpatialDropout기법이 너무 가혹할 수 있음을 발견했다.
DropBlock은 그룹 3과 그룹 4 모두에서 일정한 크기의 Block을 Drop하여 최상의 결과를 달성합니다.


 • Comparision with DropPath
Scheduled DropPath기법에서 "skip-connection"을 제외한 모든 연결에 Scheduled DropPath를 적용했습니다.
우리는 keep_prob 매개 변수에 대해 다른 값으로 모델을 훈련시켰으며, 모든 그룹에서 DropPath를 적용하고 그룹 4 또는 그룹 3과 그룹 4에서만 다른 실험과 유사한 모델을 훈련시켰다.
keep_prob = 0.9인 그룹 4에만 적용했을 때 77.10%로 최상의 validation accuracy를 달성했다.


 • Comparision with Cutout
또한 데이터 증강 방법 중 하나인 Cutout기법과 비교하여 입력 이미지에서 고정 크기 블록을 무작위로 떨어뜨렸다.
Cutout기법은 Cutout논문에서 제안한 대로 CIFAR-10 dataset의 정확도향상을 되지만, 우리 실험에서 ImageNet dataset의 정확도를 향상시키지는 않는다.


 • Comparision with other regularization techniques
우리는 DropBlock을 일반적으로 사용되는 2가지 regularization기술(data augmentation, label smoothing)과 비교한다.
표 1에서 DropBlock은 data augmentation, label smoothing에 비해 성능이 우수하다.
DropBlock과 label smoothing 및 290epoch training을 결합하면 성능이 향상되어 규제화 기술이 더 오래 훈련할 때, 보강이 될 수 있음을 보여준다.

 4.1.2  DropBlock in AmoebaNet

- 또한 진화적구조의 search를 사용하여 발견된 최신 architecture는 AmoebaNet-B architecture에서 DropBlock의 효과를 보여준다. 이 모델은 0.5의 keep probability로 dropout하지만 최종 softmax층에서만 dropout된다.

- 우린 모든 Batch Normalization층 후에 DropBlock을 적용하고 또한 마지막 셀의 50%에 Skip-Connection에도 적용한다. 이러한 셀에서 특징맵의 해상도는 331x331 크기의 입력 이미지에 대해 21x21 또는 11x11이다.
마지막 Section의 실험을 기반으로, 우리는 0.9의 keep_prob를 사용하고 마지막 특징맵의 width인 block_size = 11을 설정했다.
DropBlock은 AmoebaNet-B의 top-1 accuracy를 82.25%에서 82.52%로 향상시킨다(표 2).

4.2  Experimental Analysis

DropBlock은 드롭아웃에 비해 ImageNet classification 정확도를 향상시키는 강력한 경험적 결과를 보여준다.

우리는 conv.layer의 인접 영역이 강하게 상관되어 있기 때문에 Dropout이 충분하지 않다고 가정한다.
unit을 임의로 떨어뜨려도 인접 unit을 통해 정보가 흐를 수 있기 때문이다.

이 Section에서는 DropBlock이 semantic정보를 삭제하는 데 더 효과적이라는 것을 보여주기 위해 분석을 수행한다.

 결과적으로, DropBlock에 의해 규제화된 모델은 Dropout에 의해 규제화된 모델에 비해 더 강력하다.

우리는 추론 중, block_size가 1과 7인 DropBlock을 적용하고 성능의 차이를 관찰하여 문제를 연구한다.

 • DropBlock drops more semantic information

먼저 규제화 없는 훈련된 모델을 가져와서 block_size = 1 및 block_size = 7을 사용하여 DropBlock으로 테스트했다.
그림 5의 녹색 곡선은 추론 중에 keep_prob가 감소함에 따라 validation accuracy가 빠르게 감소함을 보여준다.

이것은 DropBlock이 semantic정보를 제거하고 분류를 더 어렵게 한다는 것을 시사한다.

정확도는 DropBlock이 dropout보다 semantic정보를 제거하는 데 더 효과적이라는 것을 시사하는 block_size = 7과 비교하여 block_size = 1에 대해 keep_prob가 감소할수록 더 빠르게 떨어진다.

 • Model trained with DropBlock is more robust

다음으로 우리는 더 많은 의미 정보를 제거하는 큰 블록 크기로 훈련된 모델이 더 강력한 정규화를 초래한다는 것을 보여준다.

우리는 추론 중에 block_size = 7과 적용된 block_size = 1로 훈련된 모델을 취함으로써 그 사실을 입증하고 그 반대도 마찬가지이다.

그림 5에서 block_size = 1과 block_size = 7로 훈련된 모델은 모두 추론 중에 block_size = 1이 적용된 상태에서 견고하다. 그러나 block_size = 1로 훈련된 모델의 성능은 추론 중에 block_size = 7을 적용할 때 keep_prob가 감소함에 따라 더 빠르게 감소했다.

결과는 block_size = 7이 더 강력하고 block_size = 1의 이점이 있지만 그 반대는 아님을 시사한다.

 

• DropBlock learns spatially distributed representations

DropBlock으로 훈련된 모델은 DropBlock이 인접한 영역에서 semantic정보를 제거하는 데 효과적이다.
따라서 공간적으로 분산된 표현을 학습해야 한다고 가정한다.

DropBlock에 의해 규제화된 모델은 하나의 독자적 영역에만 초점을 맞추는 대신 여러 독자적 영역을 학습해야 한다.

우리는 ImageNet validation set에서 ResNet-50의 conv5_3 클래스 activation을 시각화하기 위해 클래스 활성화 맵(CAM)을 사용한다.

그림 6은 block_size = 1 및 block_size = 7인 DropBlock으로 훈련된 기존모델과 모델의 클래스 activation을 보여준다.

일반적으로 DropBlock으로 훈련된 모델은 여러 영역에서 높은 클래스 activation을 유도하는 공간적으로 분산된 표현을 학습하는 반면, 규제화가 없는 모델은 하나 또는 매우적은 수의 영역에 초점을 맞추는 경향이 있다.

4.3  Object Detection in COCO

DropBlock은 CNN을 위한 일반적인 regularization 모듈이다.
이 Section에서는 DropBlock이 COCO dataset의 training object detector에도 적용될 수 있음을 보여준다.
우리는 실험에 RetinaNet을 사용하며, image에 대한 single label을 예측하는 image classification과 달리, RetinaNet은 multi-scale Feature Pyramid network(FPN)에서 convolution으로 실행되어 다양한 스케일과 위치에서 object를 localizatoin하고 분류한다. [Focal loss for dense object detection]의 모델 아키텍처와 anchor 정의를 따라 FPN과 classifier/regressor의 branch들을 구축했다.


 • Where to apply DropBlock to RetinaNet model
 RetinaNet 모델은 ResNet-FPN을 백본 모델로 사용한다.
단순성을 위해 ResNet-FPN의 ResNet에 DropBlock을 적용하고 ImageNet classification 훈련에 대해 찾은 최상의 keep_prob를 사용한다.
DropBlock은 지역 제안(region proposal)의 특징에 구조화된 패턴을 drop하는 방법을 배우는 최근 연구[A-Fast-RCNN]과는 다르다.

• Training object detector from random initialization
 무작위 초기화에서 object detector를 훈련하는 것은 어려운 작업으로 간주되어 왔다.
최근, 몇몇 논문들은 새로운 모델 아키텍처, 큰 mini-batch size 및 더 나은 normalization layer를 사용하여 이 문제를 해결하려고 시도했다.
우리의 실험에서, 우리는 모델의 규제화 관점에서 문제를 살펴본다.
training image classification model과 동일한 hyper parameter인 keep_prob = 0.9로 DropBlock을 시도하고 다른 block_size로 실험했다.
표 3에서 무작위 초기화에서 훈련된 모델이 ImageNet으로 사전 훈련된 모델을 능가한다는 것을 보여준다.
DropBlock을 추가하면 1.6%의 AP가 추가되는데, 그 결과는 모델 규제화가 Object Detector를 처음부터 훈련시키는 중요한 요소이며 DropBlock은 물체 감지를 위한 효과적인 규제화 접근법임을 시사한다.

• Implementation details
 우리는 실험을 위해 RetinaNet3의 오픈 소스 구현을 사용한다.
모델은 64개의 이미지를 한 batch동안 처리하여 TPU에 대해 훈련되었다.
교육 중에 multi-scale jittering을 적용해 scale간의 image sizewhwjd gn ekdma image를 최대차수 640으로 padding/crop을 진행.
테스트하는 동안 최대 차수는 640의 singel-scale image만 사용되었다.
Batch Normalization층은 classifier/regressor branch를 포함한 모든 conv.layer 이후에 적용되었다.

모델은 150 epoch(280k training step)을 사용해 훈련되었다.
초기 학습률 0.08은 처음 120 epoch에 적용되었고 120 epoch과 140epoch에 0.1씩 감소했다.
ImageNet 초기화를 사용한 모델은 16 및 22 epoch에서 learning decay와 함께 28 epoch에 대해 훈련되었다.
초점 손실에는 α = 0.25와 𝛾 = 1.5를 사용했다.
weight_decay = 0.0001. &. 0.9의 momentum = 0.9
이 모델은 COCO train 2017에서 훈련되었고 COCO val 2017에서 평가되었다.

4.4 Semantic Segmentation in PASCAL VOC

- 우리는 DropBlock이 semantic segmentation모델도 개선한다는 것을 보여준다.
PASCAL VOC 2012 데이터 세트를 실험에 사용하고 일반적인 관행을 따라 증강된 10,582개의 training이미지로 훈련하고 1,449개의 testset 이미지에 대한 mIOU를 보고한다.
우리는 semantic segmentation를 위해 오픈 소스 RetinaNet 구현을 채택한다.
구현은 ResNet-FPN backborn 모델을 사용하여 multi-scale feature를 추출하고 segmentation을 예측하기 위해 Fully-Convolution Network를 상단에 부착한다.
우리는 훈련을 위해 오픈 소스 코드의 default hyper-parameter를 사용한다.

- Object Detection실험에 이어 random initialization에서 훈련 모델에 대한 DropBlock의 효과를 연구한다.
우리는 45개의 epoch에 대해 pre-trained ImageNet 모델로 시작한 모델과 500개의 epoch에 대해 무작위 초기화된 모델을 훈련시켰다.
ResNet-FPN backborn 모델과 Fully-Convolution Network에 DropBlock을 적용하는 실험을 수행했으며 Fully-Convolution Network에 DropBlock을 적용하는 것이 더 효과적이라는 것을 발견했다.
DropBlock을 적용하면 처음부터 교육 모델에 대한 mIOU가 크게 향상되고 ImageNet 사전 교육 모델과 무작위로 초기화된 모델의 교육 간 성능 격차가 줄어든다.

5. Discussion

- 이 논문에서, CNN의 training regularize기법인 DropBlock을 소개한다.
DropBlock은 공간적으로 연관된 정보를 drop하는 구조화된 dropout기법이다.
ImageNet, COCO detection에 dropout과 DropBlock을 비교함으로써 더욱 효과적인 규제화기법임을 증명하였다.
DropBlock은 광범위한 실험 설정에서 지속적으로 드롭아웃을 능가한다.
우리는 DropBlock으로 훈련된 모델이 더 강력하고 드롭아웃으로 훈련된 모델의 이점을 가지고 있음을 보여주기 위해 분석을 수행하였으며, class activation mapping은 모델이 DropBlock에 의해 정규화된 더 많은 공간적으로 분산된 표현을 학습할 수 있음을 시사한다.

- 우리의 실험은 conv.layer외에 "skip-connection"에 DropBlock을 적용하면 정확도가 증가한다는 것을 보여준다.
또한 훈련 중에 삭제된 unit의 수를 점진적으로 증가시키면 정확도가 향상되고 hyper-parameter선택에 더욱 강력해진다.

🧐 논문 감상_중요개념 핵심 요약

"DropBlock: A regularization method for convolutional networks"

[핵심 개념]

1. Dropout은 딥러닝에서 널리 사용되는 regularization방법이지만 구조적 특성으로 인해 CNN에서는 제대로 작동하지 않을 수 있다.
   
   
2. DropBlock은 CNN용으로 특별히 설계된 정규화 방법이다.
   개별 단위 대신 교육 중에 기능 맵의 전체 연속 블록을 무작위로 삭제하여 작동합니다.
   
   
3. DropBlock 방법은 개별 픽셀 대신 인접한 블록을 드롭(contiguous block drop)하는 공간적 드롭아웃 방법의 일반화로 볼 수 있다.
   
   
4. DropBlock은 CIFAR-10, CIFAR-100 및 ImageNet을 포함한 여러 dataset에서 CNN의 일반화 성능을 향상시켰다.
   
   
5. DropBlock은 기존 CNN구조에 쉽게 통합될 수 있으며 "weight_decay" 및 "data augmentation"같은 다른 "regularization"방법과 함께 사용할 수 있다.
   
   
6. 또한 학습 중 신경망에서 연결의 전체 경로를 무작위로 drop하는 유사한 정규화 방법인 "drop-path"의 개념을 도입했다.

전반적으로 DropBlock 방법은 CNN을 위해 특별히 설계된 강력하고 효과적인 정규화 기술로 여러 벤치마크dataset에서 네트워크의 일반화 성능을 개선하는 것으로 나타났으며 기존 아키텍처에 쉽게 통합할 수 있다.

🧐  논문을 읽고 Architecture 생성 (with tensorflow)

import tensorflow as tf

def drop_block(x, block_size, keep_prob, is_training):
    def dropblock(inputs):
        input_shape = tf.shape(inputs)
        _, height, width, channels = inputs.get_shape().as_list()

        # Calculate the gamma value
        gamma = (1.0 - keep_prob) * tf.cast(tf.size(inputs), tf.float32) / (
            block_size ** 2 * (height - block_size + 1) * (width - block_size + 1))

        # Create a random mask with block_size * block_size blocks
        mask = tf.random.uniform((input_shape[0], height - block_size + 1, width - block_size + 1, channels)) < gamma

        # Calculate the block mask and apply it to the input
        block_mask = tf.reduce_max(tf.cast(mask, inputs.dtype), axis=(1, 2, 3), keepdims=True)
        block_mask = tf.pad(block_mask, [[0, 0], [block_size // 2, block_size // 2], [block_size // 2, block_size // 2], [0, 0]])
        block_mask = tf.image.extract_patches(block_mask, sizes=[1, block_size, block_size, 1], strides=[1, 1, 1, 1], rates=[1, 1, 1, 1], padding='VALID')
        block_mask = 1 - tf.reshape(block_mask, input_shape)
        inputs = inputs * block_mask / tf.reduce_mean(block_mask)

        return inputs

    return tf.keras.layers.Lambda(dropblock, arguments={'is_training': is_training})(x)

😶 초록 (Abstract)

- ResNet은 는 설득력 있는 정확도와 멋진 수렴동작을 보여주는 매우 심층적인 아키텍처군으로 부상했다.

본 논문에서는 "Identity Mapping"을 "Skip Connection" 및 "After-addition Activation"로 사용할 때
순전파/후전파 signal이 한 블록에서 다른 블록으로 직접 전파될 수 있음을 제안하는 residual building block 이후의 propagation공식을 분석한다.

일련의 제거(ablation)실험은 이런 identity mapping의 중요성을 뒷받침한다.
이는 새로운 residual unit을 제안하도록 동기부여하여 훈련을 더 쉽게 하고 일반화를 개선한다.

CIFAR-10(4.62% 오류) 및 CIFAR-100의 1001층 ResNet과 ImageNet의 200-layer ResNet을 사용하여 개선된 결과를 적으며 이에 대한 코드는 https://github.com/KaimingHe/resnet-1k-layers 에서 확인할 수 있다.

1. 서론 (Introduction)

2. Analysis of Deep Residual Networks

• Discussions

3. On the Importance of Identity Skip Connections

3.1  Experiments on Skip Connections  

 • Constant scaling

 • Exclusive gating

이는 Highway  Network논문의 지침에 따라(people.idsia.ch/~rupesh/very_deep_learning/)

 • Shortcut-only gating

 



• 1x1 convolutional shortcut

 • Dropout Shortcut

3.2   Discussions

4. On the Usage of Activation Functions

4.1  Experiments on Activation

이 Section에서는 ResNet-110과 164층의 Bottleneck Architecture(ResNet-164라고도 함)으로 실험한다.

Bottleneck Residual Unit은 다음과 같이 구성된다.
차원축소를 위한 1×1 및 3×3 layer
차원복원을 위한 1×1 layer 
이는 [ResNet논문]에서의 설계방식처럼 계산복잡도는 2개의 3×3 Residual Unit과 유사하다. (자세한 내용은 부록에 기재)
또한, 기존의 ResNet-164는 CIFAR-10에서 5.93%의 결과를 보였다.(표2)


 •BN after addition



 • ReLU before addition

 • Post-activation or Pre-activation ?
 

4.2  Analysis

 •Ease of optimization

- 이 효과는 ResNet-1001을 훈련할 때 매우 두드러진다. (그림 1의 곡선.)
[ResNet논문]의 기존 설계방식으로 훈련을 시작하면 training Loss가 매우 느리게 감소한다.
f = ReLU가 음의 값을 경우, 신호에 영향을 미치는데 이는 Residual Unit이 많으면 이 효과가 두드러진다.
즉, Eqn.(3)(따라서 Eqn.(5))은 좋은 근사치가 아니게 된다.
반면, f가 identity mapping인 경우, 신호는 임의의 두 Unit 사이에 직접 전파될 수 있다.
1001층이나 되는 신경망의 training Loss값을 매우 빠르게 감소시킨다(그림 1).
또한 우리가 조사한 모든 모델 중 가장 낮은 Loss를 달성하여 최적화의 성공을 보여준다.


- 또한 ResNet이 더 적은 층을 가질 때 f = ReLU의 영향이 심각하지 않다는 것을 발견했다(예: 그림 6(오른쪽)).
훈련 초반, training곡선이 조금 힘들어 보이지만 곧 좋은 상태로 된다.

그러나 단절(truncation)은 1000개의 레이어가 있을 때 더 빈번히 일어난다.

 • Reducing Overfitting
 제안된 "pre-activation" unit을 사용하는 것이 Regualarizatoin에 미치는 또 다른 영향은 그림 6(오른쪽)과 같다.

"pre-activation" 버전은 수렴 시 training Loss값이 약간 더 높지만 "test Error"는 더 낮다.

이 현상은 CIFAR-10과 100 모두에서 ResNet-110, ResNet-110(1-layer) 및 ResNet-164에서 관찰된다.
이때, 우리는 이것이 BN의 "regularization" 효과에 의해 발생한 것으로 추정된다.

원래 Residual Unit(그림 4(a)에서 BN이 신호를 정규화(normalize)하지만, 이는 곧 shortcut에 추가되므로 병합된 신호는 정규화(normalize)되지 않습니다.

이 정규화되지 않은 신호는 그다음 weight-layer의 입력값으로 사용된다.

대조적으로, 우리의 "pre-activation"버전에서, 모든 weight-layer의 입력값이 정규화되었다.

5. Results

 • Comparisons on CIFAR-10/100
  - 표 4는 CIFAR-10/100에 대한 최첨단 방법을 비교하여 경쟁력 있는 결과를 얻는다.
   우린 신경망 폭이나 filter크기를 특별히 조정하거나 작은 dataset에 매우 효과적인 정규화 기술(예: Dropout)을 사용하지 않는다는 점에 주목한다.
  우리는 단순하지만 필수적인 개념을 통해 더 깊이 들어가 이러한 결과를 얻어서 깊이의 한계를 밀어내는 잠재력을 보여준다.



 •Comparisons on ImageNet
  - 다음으로 1000-class ImageNet dataset에 대한 실험 결과이다.
ResNet-101을 사용해 ImageNet의 그림 2와 3에서 연구한 skip connection을 사용하여 예비 실험을 수행했을 때, 유사한 최적화 어려움을 관찰했다.
이러한 non-idntity shortcut network의 training오류는 첫 learning rate(그림 3과 유사)에서 기존 ResNet보다 분명히 높으며, 자원이 제한되어 훈련을 중단하기로 결정했다.
그러나 우리는 ImageNet에서 ResNet-101의 "BN after addition" 버전(그림 4(b)을 마쳤고 더 높은 training Loss와 validation error오류를 관찰했다.
이 모델의 단일 크롭(224×224)의 validation error는 24.6%/7.5%이며 기존ResNet-101의 23.6%/7.1%이다.
이는 그림 6(왼쪽)의 CIFAR 결과와 일치합니다.

- 표 5는 모두 처음부터 훈련된 ResNet-152와 ResNet-200의 결과를 보여준다.
우리는 기존 ResNet 논문이 더 짧은 측면 s∈ [256, 480]을 갖는 scale-jittering을 사용하여 모델을 훈련시켰기 때문에 s = 256 ([ResNet논문]에서와 같이)에서 224×224crop의 test는 negative쪽으로 편향되어 있었다.

대신, 모든 기존 및 ResNets에 대해 s = 320에서 단일 320x320 crop을 test한다.
ResNets는 더 작은 결과물에 대해 훈련받았지만, ResNets는 설계상 Fully-Convolution이기 때문에 더 큰 결과물에서 쉽게 테스트할 수 있다.
이 크기는 Inception v3에서 사용한 299×299에 가깝기 때문에 보다 공정한 비교가 가능하다.


- 기존 ResNet-152는 320x320 crop에서 top-1 error가 21.3%이며, "pre-activation"은 21.1%이다.
ResNet-152에서는 이 모델이 심각한 일반화(generalization) 어려움을 보이지 않았기 때문에 이득이 크지 않다.
그러나 기존 ResNet-200의 오류율은 21.8%로 기존 ResNet-152보다 높다.
그러나 기존 ResNet-200은 ResNet-152보다 training error가 낮은데, 이는 overfitting으로 어려움을 겪고 있음을 시사한다.

"pre-activation" ResNet-200의 오류율은 20.7%로 기존 ResNet-200보다 1.1% 낮고 ResNet-152의 두 버전보다 낮다. GoogLeNet과 InceptionV3의 scale 및 종횡(aspect)의 비율의 확대를 사용할 때, ResNet-200은 Inception v3보다 더 나은 결과를 보인다(표 5).
우리의 연구가 진행될 때와 동시에, Inception-ResNet-v2 모델은 19.9%/4.9%의 single crop 결과를 달성하였다.

 • Computational Cost
  - 우리 모델의 계산 복잡도는 깊이에 따라 선형적이다(따라서 1001-layer net은 100-layer net보다 10배 복잡하다).
CIFAR에서 ResNet-1001은 2개의 GPU에서 훈련하는 데 약 27시간이 걸리고,
ImageNet에서 ResNet-200은 8개의 GPU에서 훈련하는 데 약 3주가 걸린다(VGGNet논문과 동등).

6. Conclusions

이 논문은 ResNet의 connection메커니즘 뒤에서 작동하는 전파 공식을 조사한다.
우리의 결과물은 identity shortcut connection 및 identity after-addition activation이 정보의 전파를 원활하게 하기 위해 필수적이라는 것을 시시한다.
이런 변인통제실험(Ablation Experimanet)은 우리의 결과물과 일치하는 현상을 보여준다.
우리는 또한 쉽게 훈련되고 정확도를 향상시킬 수 있는 1000층 심층신경망을 제시한다

 •Appendix: Implementation Details

🧐 논문 감상_중요개념 핵심 요약

"Identity Mappings in Deep Residual Networks"
Kaiming He, Xiangyu Zhang, Shaoqing Ren 및 Jian Sun이 2016년에 발표한 연구 논문으로 이 논문은 심층 신경망의 성능 저하 문제를 해결하는 새로운 잔차 네트워크 아키텍처를 제안한다.

[핵심 개념]

1. 기존 ResNet과의 차이점
1. Shortcut Connections
이 논문은 기존의 ResNet에서 layer간의 shortcut connection에서 "Identity Mapping"을 사용한다는 것이다.
  - 기존 ResNet: 다음층의 출력차원과 일치하도록 입력을 변환하는 Residual Mapping을 사용
  - ResNet V2: transformation을 우회하고 입력을 다음층으로 직접전파하는 "Identity Mapping"을 사용


2. Pre-activation
이 논문은 ResNet을 응용한 ResNetV2로 사전 활성화(pre-activation)에 대한 개념을 도입했다.
  - BatchNormalization 및 ReLU를 각 conv.layer이후가 아닌, 이전에 적용한다.
  - 이를 통해training performance를 개선하고 매우 깊은 신경망에서의 overfitting을 줄여주었다.

[장점 ①_ Easy to Optimization]
  - 이 효과는 깊은 신경망(1001-layer ResNet)을 학습시킬 때 분명하게 나타난다.
기존 ResNet은 Skip connetion을 거쳐서 입력값과 출력값이 더해지고, ReLU 함수를 거친다.
더해진 값이 음수이면 ReLU 함수를 거쳐서 0이 되는데, 이는 만약, 층이 깊다면 이 증상의 영향이 더 커지게 되어 더 많은 값이 0이 되어 초기 학습시에 불안정성으로 인한 수렴이 되지 않는 문제가 발생할 수 있다.
실제로 아래 학습 곡선을 보면 초기에 Loss가 수렴되지 않는 모습을 볼 수 있다.

 하지만 pre-activation 구조는 더해진 값이 ReLU 함수를 거치지 않아, 음수 값도 그대로 이용할 수 있게 된다.
실제로 학습 곡선을 살펴보면 제안된 구조가 초기 학습시에 loss를 더 빠르게 감소시킴을 볼 수 있다.

[장점 ②_ Reduce Overfitting]
  - 위 그림을 보면 수렴지점에서 pre-activation 구조의 training loss가 original보다 높다.
  - 반면, test error가 낮다는 것은 overfitting을 방지하는 효과가 있다는 것을 의미합니다.
  - 이 논문에서 이 효과에 대해 Batch Normalization 효과 때문에 발생한다고 추측하는데, Original Residual unit은 BN을 거치고 값이 shortcut에 더해지며, 더해진 값은 정규화되지 않는다.
이 정규화되지 않은 값이 다음 conv. layer의 입력값으로 전달된다.

  Pre-activation Residual unit은 더해진 값이 BN을 거쳐서 정규화 된 뒤에 convolution layer에 입력되서 overfitting을 방지한다고 저자는 추측한다.

3. Recommendation
이 논문에서는 ResNet V2 설계 및 훈련을 위해 소개된 실용적인 권장사항을 제안하는데,  아래와 같다.
 ① Initialization
   - 표준편차 = sqrt(2/n) 인 Gaussian분포를 사용해 Conv.layer weight초기화를 권장
      (이때, n은 input channel수) 

 ② Batch Normalization 
   - pre-activation을 이용한 Batch Normalization을 권장한다.
   - mini-batch의 statistics 영향을 줄이기 위해 training/test중에는 statistics이동평균을 사용한다.

 ③ Learning Rate Schedule
   - 초기 수렴의 가속화를 위해 warming up구간에서 상대적으로 큰 학습률 사용
   - 미세조정을 위해 decay구간에서 더 작은 학습률 사용

 ④ Weight Decay
   - overfitting 방지를 위해 weight_decay = 1e-4 (0.0001)를 사용

 ⑤ Data Augmentation
   - random cropping
   - horizontal flipping

🧐  논문을 읽고 Architecture 생성 (with tensorflow)

import tensorflow as tf
from tensorflow.keras.layers import Input, Conv2D, BatchNormalization, ReLU, Add, GlobalAveragePooling2D, Dense
from tensorflow.keras.models import Model

def conv2d_bn(x, filters, kernel_size, strides=1, padding='same'):
    x = Conv2D(filters=filters,
               kernel_size=kernel_size,
               strides=strides,
               padding=padding)(x)
    x = BatchNormalization()(x)
    return x

def residual_block(x, filters, kernel_size, strides=1):
    shortcut = x
    x = conv2d_bn(x, filters, kernel_size, strides)
    x = ReLU()(x)
    x = conv2d_bn(x, filters, kernel_size, 1)
    
    if x.shape != shortcut.shape:
        shortcut = Conv2D(filters=filters,
                          kernel_size=1,
                          strides=strides,
                          padding='same')(shortcut)
    x = Add()([x, shortcut])
    x = ReLU()(x)
    return x

def resnetv2(input_shape, num_classes, num_layers, use_bottleneck=False):
    num_blocks = (num_layers - 2) // 9
    filters = 16

    inputs = Input(shape=input_shape)

    x = conv2d_bn(inputs, filters, 3)

    for i in range(num_blocks):
        for j in range(3):
            strides = 1
            if j == 0:
                strides = 2
            x = residual_block(x, filters, 3, strides)
        filters *= 2

    x = GlobalAveragePooling2D()(x)
    x = Dense(num_classes, activation='softmax')(x)

    model = Model(inputs=inputs, outputs=x)

    return model
    
    
model = resnetv2(input_shape=(224,224,3),  num_classes=200, num_layers=152, use_bottleneck=True)
model.summary()

😶 초록 (Abstract)

- 심층신경망은 학습시키기 더욱 어렵다.
- "residual learning framework"로 이전과 달리 상당히 깊은 신경망의 training을 쉽게하는 방법을 소개하고자 한다.
unreferenced함수 대신 layer input을 참조해 "learning residual function"으로 layer를 명시적으로 재구성하였다.
이런 잔차신경망(residual network)이 최적화하기 더욱 쉽고 상당히 증가된 깊이에서 정확도를 얻을 수 있다는 것을 보여주는 포괄적인(comprehensive) 경험적 증거를 제공한다.
- ImageNet dataset에서 VGGNet보다 8배 더 깊지만 복잡성은 낮은 152층의 잔차신경망에 대해 평가한다.
이런 잔차신경망의 앙상블은 ImageNet testset에서 3.57%의 오류를 달성했는데, 이는 ILSVRC-2015에서 1위를 차지했다.
또한 100층과 1000층을 갖는 CIFAR-10에 대한 분석도 제시한다.

- 깊이에 대한 표현은 많은 시각적인지작업에서 매우 중요하다.
우리의 매우깊은묘사는 COCO Object Detection dataset에서 상대적으로 28% 향상된 결과를 얻었다.
심층잔차신경망(Deep residual net)은 ILSVRC. &. COCO 2015 대회1에 제출한 자료의 기반으로 ImageNet감지, ImageNet Localization, COCO 감지, COCO segmentation 작업에서도 1위를 차지했다.

1. 서론 (Introduction)

• Deep CNN은 image classification의 돌파구로 이어졌다.
심층신경망은 당연하게도 저·중·고수준의 특징을 통합하고, 분류기는 다층을 처음부터 끝까지 분류하며 feature의 "level"은 깊이가 깊어지면서 층이 쌓일수록 풍부해진다. (현재 신경망의 깊이는 아주 중요하다는 것이 정론이다.)

- Depth의 중요성에 대해 다음과 같은 질문이 발생한다: 더 많은 층을 쌓은 것 만큼 신경망을 학습시키기 더 쉬울까?
[Is learning better networks as easy as stacking more layers?]
- 이 질문의 답을 위한 큰 장애물은 악명높은 gradient vanishing/exploding문제로 시작부터 수렴을 방해하는 것이다.
다만, 이 문제는 초기화를 정규화하거나 중간에 정규화층을 넣어 수십개(tens)의 층의 신경망이 역전파를 통해 SGD를 위한 수렴을 시작하는 방법과 같이 대부분 다뤄졌다.

[Degradation Problem]
- 더 깊은 신경망이 수렴을 시작할 때, 성능저하(degradation)문제가 노출되었다 : 신경망깊이가 증가하면 정확도가 포화상태가 되고, 그 다음에 빠르게 저하된다. 
- 이 문제의 예상치 못한 문제점은 바로 overfitting이 이 문제를 야기하지 않는다는 점인데, 적절한 심층모델에 더 많은 층을 추가하면 (우리의 연구결과처럼) 더 높은 training error가 발생한다.
위의 그림은 대표적인 예시이다.

- training 정확도의 성능저하는 모든 시스템이 optimize를 비슷한 수준으로 쉽게 할 수 없다는 것을 시사한다.
이를 위해 더 얕은 구조와 더 많은 층을 추가하는 더 깊은 구조를 고려해보자.

[Shallow Architecture. vs. Deeper Architecture]
더 깊은 모델에 대한 구성에 의한 해결책이 존재한다
 - 추가된 layer는 identity mapping이다.
 - 다른층은 학습된 얕은모델에서 복사된다.
이런 구조의 해결책은 심층모델이 얕은모델보다 더 높은 training error를 생성하지 않아야 함을 나타낸다.
하지만, 실험은 현재의 해결책은 이런구조의 해결책보다 비교적 좋거나 더 나은 해결책을 찾을 수 없었다.

cf. [Identity. &. Identity Mapping]
ResNet구조에서 Residual Block은 identity(= identity mapping) 을 말한다.
- 입력에서 출력으로의 전체 매핑을 학습하는 대신 입력을 약간 조정하는 방법을 학습을 진행한다.
- Identity Block은 Skip Connection이 Identity mapping을 수행하는 residual block의 일종이다.
- 즉, 변환없이 입력이 block의 출력에 직접 추가되는 것으로 Identity Block은 input의 차원을 유지시킨다.
- Identity Block은 Residual Networks에서 입력의 차원을 유지하면서 비선형성을 도입하는 데 사용된다.
이는 신경망이 더 복잡한 특징을 학습하도록 돕고 매우 깊은 신경망에서 발생할 수 있는 기울기 소실 문제를 방지한다.

이 논문에서, Degradation Problem을 "deep residual learning framework"를 이용해 다룰 것이다.
- 각 몇 개의 적층(stacked layer)이 원하는 기본적 맵핑에 직접 맞추기(fit)를 바라는 대신, 이러한 layer가 잔차맵핑에 적합하도록 명시적으로 허용한다.

- 우린 성능저하문제(Degradation Problem)를 보여주고 우리의 해결법을 평가하기 위해 ImageNet으로 포괄적인 실험을 진행하여 다음 2가지를 확인하였다.
 ① 극도로 깊은 잔차신경망은 최적화 하기 쉽다.
   - 단순히 층만 쌓는 상대적으로 "평범한(plain)" 신경망은 깊이가 증가하면 더 높은 training error를 보여준다.
 ② 우리의 심층잔차신경망은 깊이가 크게 증가하여 정확도를 쉽게 높였다.
이는 optimization의 어려움과 우리의 방법의 효과가 특정 dataset와 유사하지 않음을 시사한다.


- ImageNet Classification dataset에서 우리는 극도로 심층적인 잔차신경망에의해 우수한 결과를 얻었다.
우리의 "152-layer residual net"은 ImageNet에 제출된 가장 깊은 신경망이지만 VGG보다도 복잡성이 낮다.
앙상블은 ImageNet testset에서 3.57%의 top-5 error를 기록했으며 ILSVRC 2015 classification대회에서 1위를 차지했다.
극도로 깊은신경망은 서로다른 인식작업에서도 우수한 일반화(generalization)성능을 발휘해 다음같은 ILSVRC 및 COCO 2015에서 1위를 추가로 달성했다 : ImageNet detection, ImageNet localization, COCO detection, and COCO segmentation in ILSVRC & COCO 2015 competitions

2. Related Work

• Residual Representations.
- image recognition에서, VLAD(Vector of Locally Aggregated Descriptors)는 dictionary에 관하여 잔차벡터에 의해 encoding되는 표현이며, Fisher Vector는 VLAD의 확률론적인 버전의 공식으로 만들어진다.
두가지 모두 image 회복 및 분류를 위한 강력한 shallow representation이다.
Vector 양자화(quantization)의 경우, 잔차벡터의 인코딩이 기존벡터 인코딩보다 더 효과적으로 나타났다.

cf) VLAD는 feature encoding을 위한 이미지처리기술로 Local Image feature를 고정길이벡터표현(fixed-length vector representation)으로 인코딩하는 것이다.
ResNet을 사용하는 일부과제에서 VLAD는 분류를 위해 최종 softmax층을 사용하는 대신, ResNet의 중간층에서 추출한 특징을 인코딩하는데 사용하여 더욱 세분화된 특징표현이 가능하다.

- 저수준의 비전에서 편미분방정식(PDE.,Partial Differential Equations)을 해결하기 위해 널리 사용되는 Mulit-Grid방법은 시스템을 여러척도(multiple scale)에서 하위문제(subproblem)로 재구성(reformulate)한다. 이때, 각 하위문제는 더 거친 척도와 미세한 척도사이에서 잔차해결(residual solution)을 담당한다.
Multi-Grid의 대안은 계층적 기본 딕셔너리의 조건화(hierarchical basis pre-conditioning)이다.
이는 두 척도 사이의 잔차벡터를 나타내는 변수에 의존하며 이런 해결법은 해결책의 잔차특성(residual nature)을 모르는 기존의 해결책보다 훨씬 빠르게 수렴하는 것으로 나타났으며 이런 방법은 좋은 재구성(reformulation)이나 전제조건(preconditioning)이 최적화를 단순화 한다는 것을 시사한다.



• Shorcut Connections
- Shorcut Connection을 유도하는 이론 및 실습은 오래 연구해왔다.
MLP training의 초기실습은 신경망 입력에서 출력으로 연결된 선형층(linear layer)를 추가하는 것이다.
몇몇의 중간층이 gradient vanishing/exploding을 다루기 위해 보조분류기(auxiliary classifier)에 "직접연결"된다.
GoogLeNet(https://chan4im.tistory.com/149)에서, "Inception"층은 shortcut 분기와 몇개의 더 깊은 분기로 구성된다.

- 우리의 연구가 진행될 때 동시에, "highway networks"는 gating function이 있는 shortcut연결을 제시하였다.
이 gate는 parameter가 없는 identity shortcut과 달리 data에 의존하고 parameter를 갖고 있다.
gate shortcut이 "closed"(= 0에 접근할 수록) "hightway networks"의 layer는 non-residual function을 나타낸다.
 대조적으로, 우리의 공식은 항상 잔차함수를 학습한다.
우리의 identity shortcut은 결코 "closed"되지 않고 학습해야할 추가 잔차함수와 모든 정보가 항상 통과한다.
게다가 highway network는 깊이가 극도로 증가(100개 이상의 층)하여도 정확도의 향상을 보여주지 않았다.

3. Deep Residual Learning

3.1. Residual Learning

3.2. Identity Mapping by Shortcuts

3.3. Network Architectures

•Plain Network
  - plain 신경망의 토대는 주로 VGGNet의 철학에서 영감을 받았다. (Fig.3, 왼쪽)
  - conv.layer는 대부분 3x3 filter를 사용하며, 2가지의 간단한 설계방식을 따른다.
    ① 동일한 크기의 특징맵출력에 대하 layer는 동일한 수의 filter를 갖는다.
    ② 특징맵 크기가 1/2(절반으로 줄)이면, layer당 시간복잡성을 유지해야 하기에 filter수가 2배가 된다.
  - 우린 stride=2인 conv.layer에 의해 직접 downsampling을 수행한다. 
  - 신경망은 Global AveragePooling과 Softmax가 있는 1000-way Fully-Connected로 종료된다.
  - weight-layer의 총 개수는 그림3의 중간과 같은 34개이다.

• Residual Network
  - 위의 plain신경망을 기반으로, 우리는 신경망을 counterpart residual 버전으로 바꾸는 Shortcut Connection(그림 3, 오른쪽)을 삽입한다.
  - Identity shortcuts(Eqn. (1))은 입력과 출력이 동일한 치수일 때 직접 사용할 수 있다(그림 3의 실선 shortcuts).

  - 차수가 증가하면(그림 3의 점선 shortcuts), 우리는 두 가지 옵션을 고려한다:
    ① shortcut은 차원을 늘리기 위해 추가적으로 0개의 항목이 패딩된 상태에서 Identity mapping을 계속 수행합니다.
        이때, 추가적인 매개 변수를 도입하지 않습니다;
    ② Eqn. (2)의 Projection shortcut은 차원을 일치시키는 데 사용된다(1×1 convolutions로 수행).

  - 두 옵션 모두에서 shortcut은 두 가지 크기의 특징맵 통과 시, stride=2로 수행된다.

3.4. Implementation

- [AlexNet, VGGNet]의 실험을 따라서 구현을 진행하였다. [https://chan4im.tistory.com/145, https://chan4im.tistory.com/146]
- scale augmentation[VGGNet]을 위해 [256, 480]로 random하게 샘플링, resize를 진행하였다.
- 224x224 crop은 랜덤하게 image에서 샘플링되거나 [AlexNet]처럼 픽셀 당 평균값의 차를 이용한 horizontal flip을 진행하였으며 정석적인 color augmentation은 [Alexnet]방식을 이용했다.

- Batch Normalization을 채택하여 BN논문[https://chan4im.tistory.com/147]에서 나온 것 처럼 Conv.layer 직후, activation이전에 사용을 해주었다.
- ReLU논문[https://chan4im.tistory.com/150]에서 처럼 weight를 초기화하고 모든 기본/잔차신경망을 처음부터 training한다.

- mini-batch size가 256인 SGD(weight decay=0.0001. &. momentum=0.9)를 사용하며, learning rate는 초기값이 0.1로 시작해 학습정체현상 즉, error plateaus(SGD는 Plateau에 취약함)가 발생하면 10씩 학습률을 나누어 준다.
모델은 최대 60 x 10^4 iteration으로 training된다.
- [Batch Normalization]논문에 근거하여 Dropout은 배제하고 실험을 진행한다.


- 실험시, 비교분석을 위해 standard 10-crop testing을 채택하며[AlexNet], 최상의 결과를 위해 [VGG, Delving Deep into Rectifiers]논문처럼 Fully-Convolutional형태를 채택한다.
또한, 여러 척도에서의 score를 평균(average)하는데, 이때 image의 크기는 짧은쪽이 {224, 256, 384, 480, 640}에 오도록 조정된다.

4. Experiments

4.1. ImageNet Classification

• Plain Networks.
  - 먼저 18층, 34층 plain신경망을 평가한다. [34-layer plain net (Fig.3.중간), 자세한 구조는 아래 표1을 참조.]

 - 표 2의 결과는 더 깊은 34-layer plain net이 더 얕은 18-layer plain net보다 더 높은 val_Error값을 갖음을 보인다.

이유를 밝히기 위해 그림 4(왼쪽)에서 training과정 중 발생한 training/validation error를 비교한다

위 그림에서 우리는 성능저하문제(Degradation Problem)을 발견했다.
18-layer plain net의 solution space가 34-layer plain net을 대체함에도 불구하고 34-layer plain net은 전체적인 training절차에 걸쳐 높은 training error를 갖는다.


- 우린 이런 최적화 어려움이 gradient vanishing으로 인한 가능성은 낮다고 주장한다.
이런 plain신경망은 순전파신호가 0이 아닌 분산값을 갖도록 보장하는 Batch Normalization으로 훈련된다.
우린 또한 역전파된 기울기가 BN과 함께 healthy norm을 나타내는 것을 확인했다.
그래서 순전파와 역전파의 신호들이 사라지지 않는다.
(실제로 34-layer plain net은 표 3에서 보이듯 여전히 경쟁력있는 정확도를 달성하기에 solver가 어느정도 작동하는 것을 보여준다.)
우린 deep plain신경망이 기하급수적으로 낮은 수렴률을 가질  수 있어서 training error감소에 영향을 미친다고 추측한다.





• Residual Networks.
다음으로 18 및 34-layer residual nets (ResNets)을 평가한다.
근간이 되는 구조는 위의 plain신경망과 동일하며 그림 3(우측)처럼 3x3 filter의 각 쌍에 shortcut connection을 추가한다.
첫 비교(표2와 그림4,오른쪽)에선 모든 Shortcut에 identity mapping을 사용하고 차수를 늘리기 위해 zero-padding을 하기에 [option A], plain에 비해 추가적인 parameter가 없다.

[표 2와 그림 4에서 얻은 3가지 주요 관찰결과]
① 먼저, 잔차학습으로 상황이 역전된다.
  - 34-layer ResNet은 18-layer ResNet보다 2.8%낫다.
  - 더 중요한 점은, 34-layer ResNet이 상당히 낮은 training error를 나타내기에 validation dataset으로 generalization, 즉 일반화가 가능하다는 점인데, 이는 성능저하문제가 이 설정에서 잘 해결되었기에 깊이증가를 이용해 정확성의 이득을 얻을 수 있다는 점을 시사한다.

② 둘째로, plain신경망과 비교해 34-layer ResNet은 표 2처럼 top-1 error rate를 3.5% 감소시키며 성공적으로 감소된 training error를 보여준다. (그림 4에서 오른쪽  vs. 왼쪽)
이 비교는 극도로 심층적인 신경망에 대한 잔차학습의 효과를 검증해준다.

③ 마지막으로, 18-layer plain/ResNet이 비교적 정확하지만 (표 2), 18-layer ResNet은 더 빨리 수렴한다는 것에 주목하자.(그림 4에서 오른쪽  vs. 왼쪽)
  - 여기서 18-layer처럼 신경망이 "지나치게 깊지 않은" 경우, 현재의 SGD solver는 여전히 plain신경망에 대해 좋은 해결책을 찾는다.
  - 이 경우, ResNet은 초기단계에서 더 빠른 수렴을 제공해 최적화를 완화해준다.

• Identity. vs. Projection Shortcuts.

  - parameter가 없는 identity shorcut은 training에 도움이 된다는 것을 보여주었으므로 다음으로는 projection shortcut(Eqn. (2))에 대해 조사한다.
표 3에서는 3가지 옵션을 비교한다.
(A) zero-padding shortcut은 차수를 늘리기 위해 사용된다.
  - 이때, 모든 shortcut은 parameter가 없다(표 2 및 그림 4의 오른쪽)

(B) projection shortcut은 차수를 늘리기 위해 사용된다.
  - 이때, 다른 shortcut은 identity이다.

(C) 모든 shortcut은 projection이다.

- 표 3은 3가지 옵션 모두 plain보다 낫다는 것을 보여준다. 이때, B가 A보다 약간 더 낫고 C가 B보다 약간 낫다. (C > B > A)
우린 이에 대해 A의 zero-padding차원이 실제로 잔차학습을 갖지 않기 때문이며 (B > A인 이유)
13개의 많은 projection shortcut에 의해 도입된 추가적 매개변수 때문이라 본다. (C > B인 이유)
그러나 A/B/C사이 작은 차이는 성능저하문제해결을 위해 Projection Shortcut이 필수적이지는 않다는 것을 시사한다.
∴ 메모리/시간복잡성과 모델크기를 줄이기 위해 이 논문의 나머지 파트에서는 C를 사용하지 않는다.
identity shortcut은 아래에 소개된 Residual Architecture의 복잡성을 증가시키지 않기에 더욱 중요하다.




• Deeper Bottleneck Architectures.

 [50-layer ResNet]
  - 우리는 34-layer net의 각 2층 block을 3-layer bottleneck block으로 대체하여 50-layer ResNet(표 1)을 생성한다.
  - 우리는 차수를 늘리기 위해 option B를 사용한다.
  - 이 모델에는 38억 개의 FLOPS가 있습니다.

 [101-layer ResNet. &. 152-layer ResNet]
  - 우리는 더 많은 3-layer blocks(표 1)을 사용하여 101층 및 152층 ResNets를 구성한다.
  - 놀랍게도 깊이가 크게 증가했지만 152층 ResNet(113억 FLOP)은 여전히 VGG-16/19(153억/196억 FLOP)보다 복잡성이 낮다.
  - 50/101/152-layer ResNets는 34-layer보다 상당히 정확하다(표 3 및 4). 
  - 우리는 성능저하를 관찰하지 않기에 상당히 증가된 깊이에서 상당한 정확도 향상을 이뤘다.
  - 깊이의 이점은 모든 평가 지표(evaluation metric)에서 확인할 수 있다(표 3 및 4).

cf. FLOPs
컴퓨터의 성능을 수치로 나타낼 때 주로 사용되는 단위이다. 초당 부동소수점 연산이라는 의미로 컴퓨터가 1초동안 수행할 수 있는 부동소수점 연산의 횟수를 기준으로 삼는다.






•Comparision with  State-of-the-art  Method.
  - 표 4에서 이전의 최고의 단일 모델 결과와 비교하였는데, 우리의 근-본 34층 ResNets는 매우 경쟁력 있는 정확도를 달성했다.
  - 152층 ResNet은 단일 모델에서 top-5 error rate에서 4.49%를 갖는다.
  - 이 단일 모델 결과는 이전까지의 모든 앙상블 결과를 능가한다 (표 5).

  - 깊이가 다른 6개의 모델을 결합하여 앙상블을 형성하였는데, testset에서 top-5 error가 3.57% 였다(표 5).
  (제출 당시, 앙상블 기법은 152층 모델 두 개만 포함하였으며 ILSVRC 2015에서 1위를 차지했다.)

4.2. CIFAR-10  and  Analysis

- 우리는 10개의 클래스에서 5만개의 traininset과 1만개의 test image로 구성된 CIFAR-10 dataset에 대해 더 많은 연구를 수행했다.
우리는 training set에 대해 훈련되고 testset에 대해 평가된 실험을 결과로 제시한다.
우리는 극도로 심층적인 신경망의 동작에 초점을 맞춘다.
최첨단 결과를 추진하는 것에는 초점을 맞추지 않기에 다음과 같이 단순한 구조를 의도적으로 사용한다.

- plain/residual architecture는 그림 3(가운데/오른쪽)의 형태를 따른다.
신경망의 입력은 픽셀당 평균의 차(per-pixel mean subtracted)의 32x32 이미지이다.
첫 번째 층은 3×3 convolution이며
그 후 크기가 각각 {32, 16, 8}인 특징맵에서 3×3 convolution을 가진 6n layers의 적층 후 각 특징맵 크기에 대해 2n layer를 사용한다. 이때, filter수는 각각 {16, 32, 64}개이다.
sub-sampling은 stride=2인 convolution에 의해 수행된다.

신경망은 Global AveragePooling, 10-way FC.layer 및 softmax로 종료되며 총 6n+2개의 적층된 weight 층이 있다.
다음 표는 Architecture를 요약한 것이다:

Shortcut Connection 사용시, 한 쌍의 3x3 layer(총 3n개의 shortcut)에 연결된다.
이 dataset에서 (option A을 포함한)모든 경우에 identity shortcut을 사용한다.
따라서 Residual Model은  Plain Model과 depth, width. &. parameter수가 정확하게 동일하다.


- weight decay=0.0001과 momentum=0.9을 사용하고 가중치 초기화 및 Batch Normalization을 사용하지만 Dropout은 사용하지 않는다. (이때, 가중치 초기화는 https://chan4im.tistory.com/150를 따른다.)
이 모델들은 2개의 GPU에서 128의 mini-batch로 훈련된다.
learning rate=0.1의 학습 속도로 시작해 32000과 48000 iteration에서 10으로 나눈다.
64000번의 iteration에서 45k/5k로 나뉜 train/validation의 값이 결정되기에 training을 종료한다.

training을 위해 [Supervised Net.,https://arxiv.org/abs/1409.5185]에 소개된 간단한 Data Augmentation을 따른다.
각 면에 4개의 pixel이 padding되며
32x32 crop은 padding된 이미지 혹은 horizontal flip 중 무작위로 샘플링된다.
test를 위해 원본 32x32 이미지의 single view만 평가합니다.



- 20, 32, 44 및 56 층 신경망으로 이어지는 n = {3, 5, 7, 9}을 비교한다.
그림 6(왼쪽)은 Plain 신경망의 작동을 보여준다.
깊은 Plain 신경망은 깊이가 증가하면서 어려움을 겪고, 더 깊이 들어갈 때 더 높은 train error를 보인다.
이런 현상은 ImageNet(그림 4, 왼쪽) 및 MNIST([42] 참조)에서의 현상과 유사하여 이러한 최적화의 어려움이 근본적인 문제임을 시사한다.

그림 6(가운데)은 ResNets의 동작을 보여준다.
또한 ImageNet 사례(그림 4, 오른쪽)와 유사하게 ResNets는 최적화 어려움을 극복하고 깊이가 증가할 때 정확도가 향상됨을 보여준다.


- 110층 ResNet으로 이어지는 n = 18을 추가로 탐구한다.
이 경우, 우리는 초기의 learning rate=0.1이 "수렴을 시작하기"에 약간 너무 크다는 것을 발견했다.
따라서 training error가 80%미만이 될 때까지 낮은 학습률인 0.01로 사전 training을 진행한 후(약 400 iteration) 0.1로 다시training을 계속한다.
나머지 training schedule은 이전과 동일하며, 이 110층 신경망은 잘 수렴된다(그림 6, 중간).
FitNet[https://arxiv.org/abs/1412.6550] 및 Highway[https://arxiv.org/abs/1505.00387](표 6)와 같은 깊고 및 얇은 신경망보다 parameter수가 적지만, 최첨단 결과(6.43%, 표 6) 중 하나를 얻었다.

• Analysis of Layer Response.
  - 그림 7은 layer response의 표준 편차(std)를 보여준다.
이때, response는 BN 이후 및 기타 비선형성(ReLU/추가) 이전의 각 3x3 layer의 출력이다.
ResNets의 경우, 이 분석은 잔차 함수의 response강도를 나타낸다.

- 그림 7은 ResNet이 일반적인 응답보다 일반적으로 더 작은 응답을 가지고 있음을 보여준다.
이런 결과는 잔차 함수가 비잔차 함수보다 일반적으로 0에 가까울 수 있다는 기본 가정(3.1절)을 뒷받침한다.

- 또한 그림 7의 ResNet-20, 56 및 110의 비교에서 입증된 바와 같이 더 깊은 ResNet이 응답의 크기가 더 작다는 것을 주목하자.
즉, 더 많은 층이 있을 때, ResNets의 각각의 층은 신호를 덜 수정하는 경향이 있다.



• Exploring Over 1000 layers.
  - 공격적으로 1000개 이상의 층을 쌓는 깊은 모델을 탐구한다.
위에서처럼 훈련된 1202층 신경망으로 이어지는 n = 200을 설정한다.
우리의 방법은 최적화 어려움을 보이지 않고, 이 103층 신경망은 training error < 0.1%를 달성할 수 있다(그림 6, 오른쪽).
test error는 여전히 상당히 양호합니다(7.93%, 표 6).

- 그러나 그러한 공격적 심층모델은 여전히 미해결 문제가 있다.
이 1202층 신경망 test 결과는 우리의 110층 신경망 결과보다 나쁘지만, 둘 다 비슷한 training error를 갖는다.
우린 이런 현상이 "Overfitting"때문이라 주장한다.

- 1202층 신경망은 이 작은 dataset에 대해서는 불필요하게 클 수 있다(19.4M).
이 dataset에서 최상의 결과를 얻기 위해 maxout / dropout 같은 강력한 정규화가 적용된다.

본 논문에서는, 최적화의 어려움에 초점을 맞추지 않기에 maxout/dropout을 사용하지 않는다. 
설계에 따라 깊고 얇은 구조를 통해 정규화를 적용하지만 더 강력한 정규화와 결합하면 결과가 개선될 수 있다.

4.3. Object Detection on  PASCAL  and  MS COCO

- 우리의 방법은 다른 인식과제에서도 일반화 성능이 좋다.
- 표 7과 8은 PASCAL VOC 2007과 2012 [5] 및 COCO에 대한 Object Detection의 기준결과를 보여준다.
- 우리는 Detection방법은 Faster R-CNN을 사용한다.
이때, VGG-16을 ResNet-101로 대체하는 개선 사항에 관심을 두고 주목한다.
두 모델을 사용하는 Detection의 구현(부록 참조)은 동일., 결과물은 더 나은 신경망에 귀속된다.

- 가장 주목할 만한 것은 까다로운 COCO dataset에서 COCO의 표준 metric인 (mAP@[.5, .95])이 6.0% 증가하여 28%의 상대적 개선을 얻었는데, 이는 오직 learned representation 때문이다.
- 심층 ResNet을 기반으로 ILSVRC 및 COCO 2015 대회에서 여러 트랙에서 1위를 차지했습니다:
ImageNet Detection, ImageNet Localization, COCO Detection 및 COCO Segmentation.

- 자세한 내용은 부록에 기재.

😶 부록 (Appendix)

A. Object Detection. Baselines

• PASCAL VOC
  -
• MS COCO
  -

B. Object Detection Improvements

• MS COCO
  -

• PASCAL VOC
  -

• ImageNet Detection
  - 

C. ImageNet Localization

  -

  -

🧐 논문 감상_중요개념 핵심 요약

"Deep Residual Learning for Image Recognition"
심층 신경망에서 gradient vanishing problem을 해결하는 심층 ConvNet을 위한 새로운 구조를 소개하는 연구 논문으로 이 논문은 ResNet이라는 심층 합성곱 신경망을 위한 새로운 아키텍처를 제안한다.

[핵심 개념]

1. Problem
- 이 논문은 네트워크 깊이가 증가함에 따라 신경망의 정확도가 포화되거나 저하될 수 있는 기울기 소실 문제로 인해 매우 깊은 신경망을 훈련하는 것이 어렵다는 점을 강조했다.
  [Degradation Problem]
 - 더 깊은 신경망이 수렴을 시작할 때, 신경망깊이가 증가하면 정확도가 포화상태가 되고, 그 다음에 빠르게 저하된다. 
 - 이 문제의 예상치 못한 문제점은 바로 overfitting이 이 문제를 야기하지 않는다는 점인데, 적절한 심층모델에 더 많은 층을 추가하면 더 높은 training error가 발생한다.

2. Solution
이 논문은 기본 맵핑을 직접 학습하는 대신 잔차 함수(residual functions)를 학습하는 잔차 학습(residual learning)이라는 새로운 접근 방식을 제안했다.
이 접근 방식은 신경망이 identity mapping을 학습할 수 있도록 skip connection을 사용하는 residual block을 통해 구현된다.

cf. [Identity. &. Identity Mapping]
ResNet구조에서 Residual Block은 identity(= identity mapping) 을 말한다.
- 입력에서 출력으로의 전체 매핑을 학습하는 대신 입력을 약간 조정하는 방법을 학습을 진행한다.
- Identity Block은 Skip Connection이 Identity mapping을 수행하는 residual block의 일종이다.
- 즉, 변환없이 입력이 block의 출력에 직접 추가되는 것으로 Identity Block은 input의 차원을 유지시킨다.
- Identity Block은 Residual Networks에서 입력의 차원을 유지하면서 비선형성을 도입하는 데 사용된다.
이는 신경망이 더 복잡한 특징을 학습하도록 돕고 매우 깊은 신경망에서 발생할 수 있는 기울기 소실 문제를 방지한다.

[Shortcut Connection]
- skip connection이라고도 불린다.
- 층의 입력과 이후 층의 출력 사이에 추가함으로써 ResNet은 층을 우회하고 입력을 이후 계층으로 "직접 전달"할 수 있습니다.
- 이를 통해 네트워크는 잔차 함수를 학습할 수 있으므로 매우 깊은 신경망의 훈련이 가능하다.
- 또한 여러 conv.layer와 기존의 입력을 블록의 출력에 추가하여 신경망이 identity mapping을 학습할 수 있게 해준다.
이를 통해 training의 정확성 및 속도를 향상시킬 수 있다.

[Residual learning]
이 논문은 원하는 기본 매핑을 직접 학습하는 대신 레이어 입력을 참조하여 잔차 함수를 학습하는 잔차 학습의 개념을 도입했다.
이 접근 방식은 gradient vanishing을 피할 수 있어서 심층신경망훈련을 허용한다.

[Residual blocks]
ResNet은 여러 conv.layer와 기존의 입력을 블록의 출력에 추가하는 skip connection으로 구성된 잔차 블록(residual block)을 사용하여 구축된다.
이를 통해 신경망은 잔차 함수를 학습할 수 있으므로 매우 깊은 신경망의 훈련이 가능합니다.



3. Bottleneck Architecture
- ResNet 구조는 매우 깊은 잔여 블록 스택(예: 152개 층)으로 구성되며 정확도를 유지하면서 계산을 줄이는 bottleneck설계를 사용한다.
- 논문에서는 세 개의 층으로 구성된 병목 구조를 소개했으며 이 세 층을 Add를 이용해 더한다.
① channel수를 줄이기 위한 1x1 conv.layer
② feature 학습을 위한 3x3 conv.layer
③ channel수를 다시 늘리기 위한 또 다른 1x1 conv.layer


cf. Pre-activation
이 논문을 응용한 ResNetV2는 사전 활성화(pre-activation)에 대한 개념을  도입했다.
 - BatchNormalization 및 ReLU를 각 conv.layer 이후가 아닌 이전에 적용한다.
 - 이를 통해 training performance를 개선하고 매우 깊은 신경망에서의 overfitting을 줄여주었다.



5. Results
- ResNet은 훨씬 더 깊은 신경망으로 이전 방법을 능가해 ImageNet dataset의 classification작업에서 최첨단 성능을 달성했다.
- 또한 ResNet은 Objcet Detection 및 Semantic Segmentation과 같은 다양한 dataset 및 작업에서 더 나은 일반화 성능(generalization performance)을 달성했다.

- 이때, 초기의 learning rate=0.1이 "수렴을 시작하기"에 약간 너무 크다는 것을 발견하였기에
 training error가 80%미만이 될 때까지 낮은 학습률인 0.01로 사전 training을 진행한 후(약 400 iteration) 0.1로 다시training을 진행하였다.

전반적으로 ResNet 논문은 딥러닝과 특히 컴퓨터 비전 영역에서 많은 최신 모델의 핵심 구성 요소가 된 매우 깊은 ConvNet의 훈련을 가능하게 하는 새로운 구조를 제안하는 혁신적인 성과를 이룩하였다.

🧐  논문을 읽고 Architecture 생성 (with tensorflow)

import tensorflow as tf
from tensorflow.keras.layers import Input, Conv2D, MaxPooling2D, GlobalAveragePooling2D, Dense, ReLU, BatchNormalization, ZeroPadding2D, Activation, Add

def conv_bn_relu(x, filters, kernel_size, strides=1, padding='same'):
    x = Conv2D(filters, kernel_size, strides=strides, padding=padding)(x)
    x = BatchNormalization()(x)
    x = ReLU()(x)
    return x

def identity_block(x, filters):
    shortcut = x
    x = conv_bn_relu(x, filters, 1)
    x = conv_bn_relu(x, filters, 3)
    x = conv_bn_relu(x, filters * 4, 1)
    x = Add()([x, shortcut])
    x = ReLU()(x)
    return x

def projection_block(x, filters, strides):
    shortcut = conv_bn_relu(x, filters * 4, 1, strides)
    x = conv_bn_relu(x, filters, 1, strides)
    x = conv_bn_relu(x, filters, 3)
    x = conv_bn_relu(x, filters * 4, 1)
    x = Add()([x, shortcut])
    x = ReLU()(x)
    return x

def resnet(input_shape, num_classes, num_layers):
    if num_layers == 50:
        num_blocks = [3, 4, 6, 3]   
    elif num_layers == 101:
        num_blocks = [3, 4, 23, 3]   
    elif num_layers == 152:
        num_blocks = [3, 8, 36, 3]

    conv2_x, conv3_x, conv4_x, conv5_x = num_blocks

    inputs = Input(shape=input_shape)
    x = ZeroPadding2D(padding=(3, 3))(inputs)
    x = conv_bn_relu(x, 64, 7, strides=2)
    x = MaxPooling2D(pool_size=(3, 3), strides=2, padding='same')(x)

    x = projection_block(x, 64, strides=1)
    for _ in range(conv2_x - 1):
        x = identity_block(x, 64)

    x = projection_block(x, 128, strides=2)
    for _ in range(conv3_x - 1):
        x = identity_block(x, 128)

    x = projection_block(x, 256, strides=2)
    for _ in range(conv4_x - 1):
        x = identity_block(x, 256)

    x = projection_block(x, 512, strides=2)
    for _ in range(conv5_x - 1):
        x = identity_block(x, 512)

    x = GlobalAveragePooling2D()(x)
    outputs = Dense(num_classes, activation='softmax')(x)

    model = tf.keras.Model(inputs, outputs)
    return model




model = resnet(input_shape=(224,224,3),  num_classes=200, num_layers=152)
model.summary()

Model: "ResNet152"
__________________________________________________________________________________________________
 Layer (type)                   Output Shape         Param #     Connected to                     
==================================================================================================
 input_24 (InputLayer)          [(None, 224, 224, 3  0           []                               
                                )]                                                                
                                                                                                  
 zero_padding2d_10 (ZeroPadding  (None, 230, 230, 3)  0          ['input_24[0][0]']               
 2D)                                                                                              
                                                                                                  
 conv2d_4159 (Conv2D)           (None, 115, 115, 64  9472        ['zero_padding2d_10[0][0]']      
                                )                                                                 
                                                                                                  
 batch_normalization_4158 (Batc  (None, 115, 115, 64  256        ['conv2d_4159[0][0]']            
 hNormalization)                )                                                                 
                                                                                                  
 re_lu_540 (ReLU)               (None, 115, 115, 64  0           ['batch_normalization_4158[0][0]'
                                )                                ]                                
                                                                                                  
 max_pooling2d_23 (MaxPooling2D  (None, 58, 58, 64)  0           ['re_lu_540[0][0]']              
 )                                                                                                
                                                                                                  
 conv2d_4161 (Conv2D)           (None, 58, 58, 64)   4160        ['max_pooling2d_23[0][0]']       
                                                                                                  
 batch_normalization_4160 (Batc  (None, 58, 58, 64)  256         ['conv2d_4161[0][0]']            
 hNormalization)                                                                                  
                                                                                                  
 re_lu_542 (ReLU)               (None, 58, 58, 64)   0           ['batch_normalization_4160[0][0]'
                                                                 ]                                
                                                                                                  
 conv2d_4162 (Conv2D)           (None, 58, 58, 64)   36928       ['re_lu_542[0][0]']              
                                                                                                  
 batch_normalization_4161 (Batc  (None, 58, 58, 64)  256         ['conv2d_4162[0][0]']            
 hNormalization)                                                                                  
                                                                                                  
 re_lu_543 (ReLU)               (None, 58, 58, 64)   0           ['batch_normalization_4161[0][0]'
                                                                 ]                                
                                                                                                  
 conv2d_4163 (Conv2D)           (None, 58, 58, 256)  16640       ['re_lu_543[0][0]']              
                                                                                                  
 conv2d_4160 (Conv2D)           (None, 58, 58, 256)  16640       ['max_pooling2d_23[0][0]']       
                                                                                                  
 batch_normalization_4162 (Batc  (None, 58, 58, 256)  1024       ['conv2d_4163[0][0]']            
 hNormalization)                                                                                  
                                                                                                  
 batch_normalization_4159 (Batc  (None, 58, 58, 256)  1024       ['conv2d_4160[0][0]']            
 hNormalization)                                                                                  
                                                                                                  
 re_lu_544 (ReLU)               (None, 58, 58, 256)  0           ['batch_normalization_4162[0][0]'
                                                                 ]                                
                                                                                                  
 re_lu_541 (ReLU)               (None, 58, 58, 256)  0           ['batch_normalization_4159[0][0]'
                                                                 ]                                
                                                                                                  
 add_1150 (Add)                 (None, 58, 58, 256)  0           ['re_lu_544[0][0]',              
                                                                  're_lu_541[0][0]']              
                                                                                                  
 re_lu_545 (ReLU)               (None, 58, 58, 256)  0           ['add_1150[0][0]']               
                                                                                                  
 conv2d_4164 (Conv2D)           (None, 58, 58, 64)   16448       ['re_lu_545[0][0]']  



...


conv2d_4312 (Conv2D)           (None, 8, 8, 512)    2359808     ['re_lu_741[0][0]']              
                                                                                                  
 batch_normalization_4311 (Batc  (None, 8, 8, 512)   2048        ['conv2d_4312[0][0]']            
 hNormalization)                                                                                  
                                                                                                  
 re_lu_742 (ReLU)               (None, 8, 8, 512)    0           ['batch_normalization_4311[0][0]'
                                                                 ]                                
                                                                                                  
 conv2d_4313 (Conv2D)           (None, 8, 8, 2048)   1050624     ['re_lu_742[0][0]']              
                                                                                                  
 batch_normalization_4312 (Batc  (None, 8, 8, 2048)  8192        ['conv2d_4313[0][0]']            
 hNormalization)                                                                                  
                                                                                                  
 re_lu_743 (ReLU)               (None, 8, 8, 2048)   0           ['batch_normalization_4312[0][0]'
                                                                 ]                                
                                                                                                  
 add_1199 (Add)                 (None, 8, 8, 2048)   0           ['re_lu_743[0][0]',              
                                                                  're_lu_740[0][0]']              
                                                                                                  
 re_lu_744 (ReLU)               (None, 8, 8, 2048)   0           ['add_1199[0][0]']               
                                                                                                  
 global_average_pooling2d_6 (Gl  (None, 2048)        0           ['re_lu_744[0][0]']              
 obalAveragePooling2D)                                                                            
                                                                                                  
 dense_6 (Dense)                (None, 200)          409800      ['global_average_pooling2d_6[0][0
                                                                 ]']                              
                                                                                                  
==================================================================================================
Total params: 58,780,744
Trainable params: 58,629,320
Non-trainable params: 151,424
__________________________________________________________________________________________________

😶 초록 (Abstract)

- 최첨단성능을 달성하기 위해 Rectified activation units (rectifiers)는 필수적이다.
2가지 관점에서 image classification에 rectifier신경망을 도입한다.

① Parametric Rectified Linear Unit (PReLU)
  - overfitting의 적은 위험. &. 거의 계산적비용이 0에 수렴
  - Leaky ReLU처럼 작은 음의 기울기를 도입
  - 다만 차이점은 Leaky ReLU처럼 고정된 기울기가 아닌, 기울기의 학습이 가능하다.
  - 이는 신경망이 각 뉴런에 대해 최적의 음의 기울기를 학습할 수 있음을 의미

② Rectifier non-linearity를 특히나 고려하는 강력한 초기화방법의 도출
  - 이런 방법들을 통해 더 깊고 넓은 신경망과 매우 깊은 rectified model을 가능하게 한다.

PReLU에 기초하여 매우 높은 결과들을 달성하며 인간수준의 성능을 능가하는 성과를 얻었다.

1. 서론 (Introduction)

• CNN은 다양한 시각적 인식작업에서 효과적임을 증명하였다.
인식분류에 대해 성능향상의 엄청난 증거에 대해 강력한 모델에 대한 전략을 위해, 2가지 기술적 가이드라인을 제시한다.

① 증가된 복잡성, 확대된 width, 더 작은 stride, 새로운 non-linear activation, 정교한 층 설계로 training data를 fit한다.
② 반대로 효과적인 정규화(regularization), 공격적인 데이터강화 및 대규모 data로 더 나은 일반화(generalization)이 달성된다.

- 이런 발전과정에서, rectifier neuron, 예를 들어 ReLU는 최근 심층신경망 성공의 핵심 중 하나이다.
이는 training에서 수렴을 가속화하고 기존의 "S자 unit"보다 더 나은 결과를 보여준다.

- 본 논문에서는 특히 정류기(rectifier)에 의해 구동되는 2가지 측면에서 신경망을 조사한다.
① PReLU: ReLU의 새로운 generalization
  - 이 활성화 함수는 정류기의 매개변수를 적응력있게 학습하고 무시할 수도 있는 추가적인 계산으로 정확도를 향상시킨다.

② 매우깊은 rectified모델 훈련의 어려움
  - 정류기의 비선형성(ReLU / PReLU)를 명시적으로 모델링, 이론적 초기화방법을 도출.
  - 처음부터 직접 훈련된 심층신경망의 수렴을 도와 강력한 신경망구조의 탐색이 가능한 유연성확보가 가능.


- 우린 지금까지 보고된 바에 의하면, 처음으로 인간수준의 인식(5.1%)을 넘어서는 결과를 만들어냈다.

2. Approach

2.1. Parametric Rectifiers. (PReLU)

• Definition
- 공식분석을 하면, activation function을 다음과 같이 정의한다.

이때, yi는 i번째 channel의 비선형활성화함수 f의 입력값이다.
ai의 i는 다양한 channel에 걸쳐 비선형활성화함수(nonlinear activation)를 허용한다는 것을 나타낸다.

ai = 0일 때, 이것은 ReLU가 된다.
이때, ai가 학습가능한 파라미터라면, Eqn.(1)에서 언급한 바와 같이 Parametric ReLU가 된다.

또한 위의 식은 아래의 식과 동치이다.

만약 ai가 작고 고정된 값이라면, PReLU는 LReLU, 즉 Leaky ReLU가 된다. (ai = 0.01)
- LReLU는 zero gradient 즉, 기울기가 0이 되는 것을 피하기 위해 사용된다.
다만, LReLU가 ReLU에 비해 정확도에 미치는 영향이 미미하다는 것을 보여준다.[Rectifier nonlinearities improve neural network acoustic models. In ICML, 2013.]

[PReLU]
- LReLU와 달리, 우리가 사용하는 PReLU의 경우, 매우 작은 extra parameter를 사용한다.
- 이때, extra parameter수 = channel의 전체 수이기에 총 가중치 수를 고려하면 무시할만하다.

[channel-shared variant]
- 위의 activation function공식에서 계수는 한층의 모든 channel과 공유된다.
- 이런 변형은 각 층에 하나의 extra parameter만 도입한다.

• Optimization 
- PReLU는 역전파로 훈련되고, 다른 층과 동등하게 최적화된다.
- {ai} 공식의 update은 chain-rule을 기반으로 하며 하나의 층에 해당하는 ai의 기울기 공식은 아래와 같다.

- Ɛ은 목적함수(objective function)을 의미하며한다.

- 위의 식은 심층으로부터의 기울기전파 (gradient propagate)를 나타내는데, 활성화함수의 기울기를 의미 식이다.

• Comparision Experiments
 - 우리는 14개의 가중치 레이어를 사용하여 깊지만 효율적인 모델에 대해 비교를 수행했다.(표 1)
이 모델이 실험을 실현 가능하게 할 뿐만 아니라 매우 심층적인 모델의 범주를 나타내기에 충분하기에 선택한다.

- 기본적으로, 컨볼루션(convolutional) 계층과 처음 두 개의 FC.layer에 적용된 ReLU로 이 모델을 훈련시킨다.
10-view testing을 사용해 ImageNet 2012에서 top-1 and top-5 error는 33.82% 및 13.34%이다(표 2).

- 그후 모든 ReLU를 PReLU로 대체하여 동일한 아키텍처를 처음부터 training한다(표 2).
top-1 error는 32.64%로 감소하며 이는 기존의 ReLU에 비해 1.2% 증가한 것이다.
표 2는 channel-wise / channel-shared PReLU가 서로 비슷한 성능을 발휘함을 보여준다.
channel-shared PReLU의 경우 ReLU와 비교하여 13개의 추가적인 extra parameter만 도입한다.
그러나 이 작은 수의 extra-parameter는 기존에 비해 1.1%만큼 뛰어넘음을 입증되는 중요한 역할을 한다.
이는 활성화 함수의 꼴을 적응력있게 학습하는 것의 중요성을 의미한다.

- 표 1은 또한 각 계층에 대한 PReLU의 학습된 계수를 보여준다.
표 1에는 두 가지 흥미로운 현상이 있다.

① 첫째, conv1의 계수는 0보다 생각보다 큰 (0.681 및 0.596)값을 갖는다.
  - conv1의 filter는 edge 및 texture detector 같은 Gabor 유사 필터가 대부분이다
  - 즉, 학습된 결과는 filter의 positive / negative response가 모두 반영됨을 보여준다.
  - 제한된 수의 filter(예: 64)를 고려할 때, 이는 저수준의 정보를 활용하는 더 경제적인 방법이라고 생각한다.

② 둘째, channel-wise의 경우, 일반적으로 deeper conv.layer는 더 작은 계수를 갖는다.
  - 이는 activation이 점점 더 깊은 곳에서 점진적으로 "더 비선형적"이 된다는 것을 의미한다.
  - 즉, 학습된 모델은 초기 단계에서 더 많은 정보를 유지하는 경향이 있고 더 깊은 단계에서 더 차별화된다.

2.2. Initialization of Filter Weights for Rectifiers. (deep rectifier net)

• Foward Propagation Case

• Back Propagation Case

• Discussions
 

• Comparision with "Xavier" Initialization

2.3. Architectures

위의 조사는 다음의 Architecture에 대한 설계지침을 제공한다. 

- 우리의 baseline은 (표 3)의 19층 모델(A)이다. 더 나은 비교를 위해, 또한 VGG-19을 나열한다.
우리의 모델 A는 VGG-19에서 다음과 같이 수정된다.
  i) 첫 번째 층에서 filter size = 7×7와 strides = 2를 사용.
  ii) 가장 큰 2개의 특징맵(224, 112)의 다른 3개의 conv.layer를 더 작은 특징맵(56, 28, 14)으로 이동
      이때, 시간 복잡도(표 3, 마지막 행)는 더 깊은층이 더 많은 filter를 갖기에 거의 변하지 않는다.
  iii) 첫 FC.layer 이전에 공간 피라미드 풀링, (SPP)을 사용한다.
      이때, 피라미드는 총 63개의 bins에 대해 bin의 수가 7×7, 3×3, 2×2, 1×1인 4개의 level을 갖는다.

- 우리의 모델 A가 VGG에 보고한 VGG-19의 결과보다 더 나은 결과를 가지고 있다.
다만, 우리의 모델 A가 VGG-19보다 더 나은 아키텍처라는 증거는 없다는 것을 주목할 필요가 있다.
더 적은 규모의 확대를 사용한 이전 실험에서, 우리는 모델 A와 (SPP 및 초기화와) 재현된 VGG-19가 비교 가능하다는 것을 관찰했다.
A 모델을 사용하는 주된 목적은 더 빠른 실행속도를 위한 것이다.
시간 복잡도가 동일할 때, 큰 특징맵의 conv.layer의 실제 실행 시간은 작은 특징맵의 conv.layer보다 느리다.
4 GPU의 구현에서 모델 A는 mini-batch당 2.6초(128),
재현된 VGG-19는 4개의 Nvidia K20 GPU에서 3.0초 걸렸다.

- 표 3에서, 모델 B는 A의 더 깊은 버전으로 세 개의 extra conv.layer를 갖는다.
우리의 모델 C는 B의 더 넓은 버전(filter가 더 많음)으로 width는 복잡성을 상당히 증가시킨다.
이때, 시간 복잡도는 B의 약 2.3배이다(표 3, 마지막 행).
4개의 K20 GPU에서 A/B를 교육하거나 8개의 K40 GPU에서 C를 교육하는 데 약 3-4주가 걸린다.

- 깊이가 더 깊어진 모델은 정확도가 감소하거나 심지어 저하(degradation)되기 때문에 깊이 대신 모델의 폭(width)을 늘린다.
소규모 모델에 대한 최근 실험에서, 깊이를 공격적으로 증가시키면 포화되거나 정확도가 저하된다는 것이 밝혀졌다.
VGG 논문에서, 16, 19층 모델은 비교적 성능이 좋지만 
[M.D.Zeiler, M.Ranzato, R.Monga et. al]의 음성 인식 연구에서, 딥 모델은 8개 이상의 숨겨진 레이어(모두 fc)를 사용할 때 성능이 저하되었는데, 우리는 ImageNet의 더 큰 모델에서도 유사한 저하가 발생할 수 있다고 추측한다.

일부의 극도로 심층적인 모델의 training에서(표 3의 B에 3~9개의 레이어가 추가됨) training 및 test error rate가 처음 20epoch에서 모두 저하되었음을 발견했다
(다만, 제한된 시간으로 끝까지 실행되지 않았기에 이런 크고 지나치게 심층적인 모델이 궁극적으로 저하될 것이라는 확실한 증거는 아직은 없다).
이런 성능 저하의 가능성으로 대형 모델의 깊이를 더 이상 증가시키지 않기로 선택했다.

- 반면, 소규모 dataset에 대한 최근의 연구는 conv.layer의 parameter수가 증가함에 따라 정확도가 향상되어야 한다고 제안하는데, 이 숫자는 깊이와 너비에 따라 달라진다.
그래서 우리는 더 높은 용량의 모델을 얻기 위해 conv.layer의 width를 늘렸다.

- 표 3의 모든 모델은 매우 크지만, 심각한 overfitting은 관찰되지 않았는데, 아래에서 말할 것 처럼 전체 training에 걸쳐 사용되는 공격적인 data augmentation 덕분이라 생각한다..

3. Implementation Details

•  Training
 - 우리의 훈련 알고리즘은 대부분 [AlexNet, VGGNet 등]을 따른다.
 resize된 image(shorter side is s, 픽셀당 평균의 차가 진행된 224x224 crop이 무작위로 샘플링됨) 
 scale은 VGG에 나오는 [256, 512] 범위에서 무작위로 jittering 된다.
 표본의 절반이 무작위로 horizontal flip이 진행되고 색상도 변경된다.


 - 미세 조정(fine-tuning) 중에만 scale jittering을 적용하는 VGG와 달리 training의 시작부터 적용한다.
또한, 얕은 모델을 사용하여 더 깊은 모델을 초기화하는 VGG와 달리, 
2.2절에 설명된 초기화 방법을 사용하여 매우 깊은 모델을 직접 훈련한다(Eqn.(14) 방정식을 사용).
training의 시작부터 끝까지 poor local optima를 피할 수 있어서 정확도를 향상시키는 데 도움이 될 수 있었다.


[중요한 나머지 hyper parameter 설정]
weight decay = 5e-4 (= 0.0005)
momentum = 0.9이다.
Dropout(0.5)는 처음 두 개의 FC.layer에서만 사용.
mini-batch size = 128로 고정.
learning rate = 1e-2, 1e-3 및 1e-4으로 오류가 발생할 때 전환.
모델 별 총 epoch수는 약 80.

• Testing
 - 우리는 SPP-net 논문에서 사용된 "특징맵에 대한 multi-view test" 전략을 사용한다.
VGG처럼 고밀도의 sliding window 방식을 사용해 이 전략을 추가로 개선한다.

① 먼저 resize된 전체 image에 conv.layer를 적용, 최종 conv.특징맵을 얻는다.
  - 특징맵에서 각 14x14 window는 SPP-layer를 사용해 Pooling한다. 
② 그 후, FC.layer가 Pooling된 특징에 적용되어 score를 계산한다.
  - 이는 horizontal flip image에서도 수행된다.
  - 모든 고밀도의 sliding window score는 평균화되며 그 후 여러 scale로 결과를 추가로 결합한다.


• Multi-GPU Implementation
 - 우리는 여러 GPU에 대한 병렬 훈련을 위해 AlexNet방식의 간단한 변형을 채택한다.
conv.layer에 "데이터 병렬화 (data parallelism)"를 채택한다.
GPU들은 제1 FC층 이전에 동기화된되며, FC층의 순전파, 역전파가 단일 GPU에서 수행됩니다.
즉, FC층의 계산을 병렬화하지 않습니다. (FC층의 시간적 비용이 낮기에 병렬화가 필요가 없다.)
이는 AlexNet의 "모델 병렬화"보다 더 간단한 구현으로 이어진다.
게다가, 모델 병렬화는 필터 응답의 통신으로 인해 일부 오버헤드를 초래하며, 단일 GPU에서 FC층을 계산하는 것보다 빠르지 않다.

 - 우리는 카페 라이브러리의 수정에 대해 위의 알고리즘을 구현하며 정확도가 떨어질 수 있기에 mini-batch size(128)를 늘리지 않는다.
본 논문에서는 대형 모델의 경우, 4개의 GPU를 사용하여 3.8배의 속도 향상과 8개의 GPU를 사용하여 6.0배의 속도 향상을 관찰했다.

4.Experiments on ImageNet

• Comparision between ReLU. &. PReLU
 - 표 4는 대형 모델 A에서 ReLU와 PReLU를 비교한다. 이때, channel-wise버전에 PReLU를 사용한다.
공정한 비교를 위해 ReLU/PReLU 모델은 동일한 총 epoch 수를 사용해 training되며 learning rate도 동일한 epoch수를 실행한 후 전환된다.

 - 표 4는 세 가지 scale와 multi-scale간의 조합의 결과를 보여준다.
 jittering range[256, 512]에 있을 수 있기 때문에 최고의 single scale은 384이다.
multi-scale 조합의 경우, PReLU는 ReLU에 비해 top-1 오류를 1.05%, top-5 오류를 0.23% 감소시킨다.
이는 표 2와 표 4의 결과는 일관되게 PReLU가 소형 및 대형 모델을 모두 향상시킴을 보여준다.
이때, 이러한 향상은 계산 비용이 거의 없이 얻어진다.




• Comparision of Single-model Results
 - 다음으로 단일 모델 결과를 비교한다.
먼저 표 5에서 10-view test result를 보여주는데, 여기서 각 view는 224-crop이다.
VGG-16의 10-view result는 test를 기반으로 최고의 결과는 7.38%이다(표 5). 

 - 표 6은 multi-scale and multi-view나 dense test를 사용해 얻은 Single-model 결과의 비교를 보여준다.
결과는 MSRA로 표시되며 기본 모델(A+ReLU, 6.51%)은 VGG-19에 대해 보고된 최고의 기존 단일 모델 결과인 7.1%보다 이미 상당히 좋으며 이러한 이득이 주로 얕은 모델을 사전 훈련할 필요가 없는 종단 간 훈련 때문이라고 생각한다.

 - 또한, 우리의 최고 단일 모델(C, PReLU)은 5.71%의 top-5 error를 갖는데, 이 결과는 이전의 모든 다중 모델 결과보다 훨씬 더 우수하다(표 7).
A+PReLU와 B+PReLU를  비교하면, 우리는 19층 모델과 22층 모델이 비교적 성능이 좋다는 것을 알 수 있다.
반면에 폭을 늘리면(C vs. B, 표 6) 정확도가 향상될 수 있는데, 이는 모델이 충분히 깊으면 폭이 정확도의 필수 요소가 된다는 것을 시사한다.




• Comparision of Multi-model Results
 - 우리는 표 6의 모델을 포함하여 6개의 모델을 결합한다.
당분간 우리는 Architecture C만으로 모델을 훈련했으며 다른 모델들은 C보다 상당한 격차의 낮은 정확도를 가지고 있다.
우리는 더 적은 수의 강력한 모델을 사용함으로써 더 나은 결과를 얻을 수 있다고 추측한다.

 - 다중 모델 결과는 표 7에 나와 있는데, 우리의 결과는  testset에서 4.94%의 top-5 error를 갖는다.
testset의 label이 게시되지 않아서 ILSVRC 서버에 의해 평가된다.
우리의 결과는 ~26%의 상대적 개선을 나타내는 ILSVRC 2014 우승작(GoogLeNet, 6.66%)보다 1.7% 더 좋다.
이는 또한 최근 결과에 비해 상대적으로 최대 17%의 개선되었다(Baidu, 5.98%).




• Analysis of Results
 - 그림 4는 우리의 방법으로 성공적으로 분류된 몇 가지 validation image의 예를 보여준다.
정확하게 예측된 label 외에도 top-5 결과의 다른 네 가지 예측에도 주의를 기울인다.
이 네 개의 label 중 일부는 다른 object의 multi-object image이다.
예를 들어, "말-카트" 이미지(그림 4, 행 1, 콜 1)는 "mini-bus"를 포함하고 알고리즘에 의해 인식된다.
이 네 가지 label 중 일부는 유사한 class 사이의 불확실성 때문이다.
예를 들어, "coucal" 이미지(그림 4, 행 2, 콜 1)는 다른 조류 종의 라벨을 예측했다.

 - 그림 6은 testset의 결과(평균 4.94%)의 클래스당 top-5 error를 오름차순으로 표시한다.
우리의 결과는 113개 클래스에서 top-5 error가 0개로 이 클래스의 이미지는 모두 올바르게 분류된다.
top-5 error 가장 높은 3개 계층은 'letter opener'(49%), 'spotlight'(38%), 'restaurant'(36%)이다.
이 오류는 multiple/small object나 large class내의 분산(variance)으로 인해 발생한다.
그림 5는 이 세 클래스에서 우리의 방법에 의해 잘못 분류된 일부 예시 이미지를 보여준다.
단, 예측된 레이블 중 일부는 여전히 의미가 있다.

 - 그림 7에서, 우리는 우리의 결과(평균 4.94%)와 ILSVRC 2014(평균 8.06%)에서 우리의 경쟁 결과(평균 8.06%) 사이의 top-5 error rate의 class 당 차이를 보여준다. error rate은 824개 클래스에서 감소하고 127개 클래스에서 변경되지 않으며 49개 클래스에서 증가한다.




• Comparision with Human Performance from [https://arxiv.org/abs/1409.0575]
 - Russakovsky의 연구는 인간의 성능이 ImageNet에서 5.1%의 top-5 error를 달성한다했다.
이는 관련 클래스의 존재를 더 잘 알기 위해 validation image에 대해 잘 알고있는 인간에 의해 달성된다.
test image에 주석을 달 때 인간에게 특별한 인터페이스가 제공되며, 각 클래스 제목에는 13개의 extra train image row가 함께 제공된다.

 - 우리의 결과(4.94%)는 보고된 인간 수준의 성과를 초과한다.
우리가 아는 한, 우리의 결과는 이 시각적 인식 과제에서 인간을 능가하는 최초의 발표된 사례이다.
fine-grained recognition 및 class uwareness은 인간의 오류의 2가지 주요 유형이다.
Russakovsky의 연구에 따르면, 알고리즘은 fine-grained recognition(예: 데이터 세트에서 120종의 개)에서 더 나은 작업을 수행할 수 있다.
그림 4의 두 번째 행은 "coucal", "komondor" 및 "yellow lady's slipper"와 같이 우리의 방법으로 성공적으로 인식된 몇 가지 세밀한(fine-grained) 물체의 예를 보여준다.
인간은 이 물체들을 새, 개, 꽃으로 쉽게 인식할 수 있지만, 대부분의 인간이 그들의 종을 말하는 것은 사소한 일이 아니다.
부정적인 측면에서, 우리의 알고리즘은 특히 문맥 이해 또는 높은 수준의 지식이 필요한 경우(예: 그림 5의 "spotlight" 이미지)에 여전히 인간에게는 어렵지 않은 경우에도 실수를 한다.

- 우리의 알고리즘은 이 특정 dataset에서 우수한 결과를 산출하지만, 이것이 일반적으로 물체 인식에서 인간의 비전을 능가한다는 것을 나타내지 않는다.
Pascal VOC 과제 같은 기본적인 Object category(즉, 일상 생활에서 일반적인 객체 또는 개념)를 인식할 때, 기계는 여전히 인간에게 사소한 경우에도 명백한 오류를 가지고 있다.
그럼에도 불구하고, 우리는 우리의 결과가 시각적 인식에서 인간 수준의 성능과 일치하는 기계 알고리듬의 엄청난 잠재력을 보여준다고 믿는다

🧐 논문 감상_중요개념 핵심 요약

"Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification"
Rectified Linear Unit, 일명 ReLU에 대해 심층적으로 탐구한 후 ReLU를 소개하는 연구 논문으로 이 논문은 ReLU와 그 변형 함수들 즉, 비포화 비선형성(non-saturating non-linearity)의 함수들의 사용을 제안한다.

[핵심 개념]

1. 이 논문에서는 Sigmoid나 tanh 같은 다른 포화 비선형성(saturating non-linearity) 활성화 함수에 비해 심층 신경망 훈련을 개선하는 것으로 밝혀진 ReLU(Rectified Linear Unit) 활성화 함수를 소개했다.

2. 이 논문은 ReLU를 사용하면 다른 활성화 함수를 사용하는 신경망에 비해 교육 중에 더 빠른 수렴, ImageNet classification 작업에서 더 나은 일반화(generalization) 성능, 더 낮은 오류율로 이어질 수 있음을 보여주었다

3. 드롭아웃 정규화 및 배치 정규화를 포함하여 훈련 프로세스에 대한 몇 가지 수정 사항을 제안하여 심층 신경망의 성능을 더욱 향상시켰다.

4. ReLU, Dropout 및 Batch Normalization의 조합은 심층 신경망을 구축하기 위한 일반적인 방법이 되었으며 이후 많은 작업에서 사용되었다.

5. 이 논문은 보다 강력하고 효율적인 딥러닝 모델의 구축하기 위한 로드맵을 제공하여 심층 신경망 훈련을 위한 활성화 함수 및 기타 기술의 중요성을 보여주었다.

전반적으로 "Delving Deep into Rectifiers" 논문은 딥 러닝의 최신 기술을 발전시키는 데 중요한 역할을 했으며 이 분야에 지속적인 영향을 미쳤다.

😶 초록 (Abstract)

- ILSVRC14의 classification과 detection에서 최신기량을 보여주는 새로운 심층신경망구조, 일명 "Inception"을 제안한다.
- 이 모델의 가장 큰 좋은 특징은 바로 "계산리소스의 이용면에서의 향상"이다.
- 계산리소스를 일정하게 유지하면서 depth와 width를 키웠다는 점에서 주목할만하다.
- 이런 특성의 최적화를 위해 구조적인 결정은 Hebbian원리와 multi-scale processing의 직관(intuition)에 기초했다.

cf. [Hebbian Principle]

- Hebbian 원리는 뉴런 간의 연결 강도가 시간이 지남에 따라 어떻게 변할 수 있는지를 설명하는 신경 과학의 개념으로 이 원리는 두 개의 뉴런이 함께 활성화될 때 그들 사이의 연결이 강화된다는 생각에 기반을 둔다. 이것은 학습과 기억의 기초가 되는 신경 경로의 형성으로 이어질 수 있다.

- 이 논문에서는 CNN의 성능을 개선하는 데 도움이 되는 "Local Response Normalization"(LRN)이라는 Hebbian 원리의 변칙을 사용하는 방법에 대해 설명한다.

1. 서론 (Introduction)

• 지난 3년간 심층신경망의 엄청난 발전으로 classification과 detection에서 극적인 변화가 있었다.
이에 대한 호재(好材)는 단지 hardware의 발전이나 model이 커지거나 dataset의 많아짐의 덕도 있지만, 더 주요한 것은 새로운 생각과 알고리즘, 향상된 신경망구조의 결과라는 것에 있다.
우리의 GoogLeNet은 불과 2년전의 AlexNet보다 실제 사용하는 parameter 12배 적음에도 더 높은 정확도를 갖는다.

Object Detection의 가장 큰 이점은 심층신경망 단독이나 더 큰 모델의 활용이 아닌 R-CNN algorithm(Girshick et al)과 같은 심층 구조와 고전적 컴퓨터비전의 시너지에서 얻었다.


• 다른 주목할 특징은 모바일 및 임베디드의 지속으로 알고리즘의 효율성(특히 전력 및 메모리사용)이 중요해진다는 것이다.
우리의 알고리즘에서 두드러지는(noteworthy) 점은 본 논문에서 제시된 심층신경망 구조의 설계(design)로 이어지는 고려사항이 정확도의 숫자에 대한 순수한 고정관(sheer fixation)보다 위의 요소를 포함했다는 점이다.
대부분의 실험에서 모델은 추론단계(inference)에서 15억배 증가한 계산예산에 유지하게 설계되었기에 순수한 학문적호기심으로 끝나지 않는데, 심지어는 대규모 dataset에서도 합리적인 비용으로 실제로 사용가능하다.


• 본논문에서는 컴퓨터비전을 위한 효율적 심층신경망구조인 "Inception"에 초점을 맞춘다. 
("we need to go deeper"라는 인터넷 밈에서 파생)
이때, "deep"이라는 단어를 2가지 의미로 사용하였다.
  - "Inception module"의 형태로 새로운 수준의 조직을 도입한다는 의미
  - 신경망의 깊이를 증가시킨다는 직접적인 의미

2. Related Work

• LeNet-5에서 시작해서 CNN은 전형적인 표준구조를 갖는데, stacked conv.layer(보통 선택적으로 정규화 및 maxpooling이 따른다.)는 하나 이상의 FC.layer가 뒤따른다. 
이 기본적인 설계를 변형하는 것은 image classification 문헌에 널리 퍼져있다.
ImageNet같은 대규모 dataset은 layer크기를 늘리는 동시에 overfitting을 해결하기 위해 Dropout과 같은 방법을 사용한다.

• Max-Pooling이 정확한 공간정보의 손실한다는 우려에도 불구하고 conv.layer의 localization, object detection 등 여러 사례에 활용되는데, 영장류의 시각피질의 신경과학모델에서 영감을 받았다. (Hebbian principle)
이때, Inception layer는 많이 반복되며 Inception model의 모든 filter는 학습되는데, GoogLeNet 모델의 경우, 22개의 layer의 심층모델로 이어진다.

• Network-in-Network는 신경망의 표현력을 높이기 위해 제안된 접근법으로 conv.layer에 적용할 때, 이 방법은 일반적인 rectified linear activation이 뒤따르는 추가적인 1x1 conv.layer로 간주된다.
이를 통해 CNN pipline에 쉽게 통합할 수 있었는데, 본 논문의 구조에서 이 접근방식을 많이 사용한다.

다만 우리의 구조설정에서는 1x1 convolution은 이중적인 목적을 갖는다.
- 가장 중요한 목적: 신경망의 크기를 제한하는 계산병목현상(computational bottleneck)의 제거를 위한 차원축소모듈(dimension reduction module).  →  성능의 저하 없이 depth, width를 늘릴 수 있음
(∵ 1x1 convolution은 더 큰 convolution에 비해 상대적으로 적은 수의 parameter를 포함하기 때문에 계산에 효율적.)
- 부가적인 목적: 신경망의 표현력을 높임


• Object Detection을 위한 가장 최신 접근법은 Girshick 등(et al)이 제안한 R-CNN이다. 
R-CNN은 전반적인 object detection을 2가지의 하위문제로 나눈다.
- category에 구애받지않는 방식으로 잠재적 물체제안을 위한 색상 및 super-pixe의 일관성 같은 저수준의 단서를 먼저 활용한다.
- 그 후 CNN classification을 활용해 물의 해당 위치 및 category를 식별한다.

이러한 2단계 접근방식은 저수준의 단서를 갖는 boundaing box segmentation의 정확성 및 최첨단 CNN의 매우 강력한 classifciation 능력을 활용한다.
이때, bounding box의 더 나은 제안 및 classification을 위한 앙상블 접근법과 같은 2단계 모두에서 향상된 기능을 얻어내었다.

3. Motivation and High Level Considerations

- 심층 신경망의 성능을 향상시키는 가장 간단한 방법은 크기를 늘리는 것이다.
(이때, 신경망의 깊이(depth), 폭(depth의 unit수)의 증가 또한 모두 포함된다.)
다만 이 해결법은 2가지의 주요 단점이 존재한다.

① 더 큰 크기는 보통 parameter가 많음을 의미하며, 이는 training set이 제한된 경우, overfitting 발생가능성을 높인다.
특히, 아래 그림처럼 더 자세한 구분을 위해 인간이 필요한 경우, 고품질의 training set을 만들기 힘들기에 주요병목현상(major bottleneck)이 될 수 있다.

② 신경망 크기가 균일하게 증가하는 또 다른 단점은 계산 자원의 사용이 극적으로 증가한다는 것이다.
예를 들어 deep vision network에서 2개의 conv.layer의 연결의 경우, filter 수가 균일하게 증가하면 계산이 제곱으로 증가한다.
만약, 추가된 용량이 가중치가 0에 가까울 때처럼 비효율적으로 사용되면 많은 계산자원이 낭비된다.


- 이런 두 문제의 해결에 대한 근본적 방법은 궁극적으로 conv.layer 내부에서 fully-connected한 구조에서 덜 연결된 구조로 이동하는 것이다.
Dataset의 확률분포(probability distribution)가 크고 매우 희박한 심층신경망의 경우, 마지막층의 activation과 상관관계가 높은 출력을 갖는 clustering neurons의 상관통계를 분석해 최적의 신경망 topology를 층별로 구성할 수 있다고 하는데,
비록 엄밀한 수학적증명이 매우 강한 조건을 요구하지만, 위의 글은 잘 알려진 Hebbian principle와 공명한다는 사실이다.
즉, 근본적 아이디어가 덜 엄밀한 조건에서도 실제로 잘 적용할 수 있다는 점을 시사한다 할 수 있다.

- 부정적인 면에서는 오늘날의 computing infra.는 불균일한 희소자료구조에 대한 수치적계산과 관련해 매우 비효율적이라는 사실이다.
산술연산수가 100배(100x) 줄어든다해도 lookups과 cache 손실의 overhead가 너무나도 지배적이기에 희소행렬(sparse matrices)로의 전환은 효과가 없을 것이다.
또한, 균일하지 않은 희소모델(sparse model)은 더 정교한 공학 및 계산인프라가 필요하다.
현재 대부분의 vision지향 기계학습방식은 convolution을 사용한다는 장점만으로 공간영역의 희소성(sparsity in the spatial domain)을 활용한다.
하지만, convolution은 이전층의 patch의 밀집된 연결모음으로 구성되는데, ConvNet은 전통적으로 특징맵에서 무작위 및 희소연결(random and sparse connection tables)을 사용해 비대칭적으로 학습을 향상시켰다.
이런 추세는 병렬컴퓨팅을 더욱 잘 최적화하기 위해 전체연결로 다시 변경되었는데, 이를 통해 구조의 균일성 및 많은 filter와 더 큰 batch size는 효율적인 dense computation을 사용할 수 있게 하였다.

- 이는 다음의 중간단계에 대한 희망이 있는지에 대한 의문을 제기한다.
이론에서 제안된 것처럼 filter에서조차도 여분의 희소성을 활용하지만 고밀도의 행렬계산을 활용해 현재 하드웨어를 활용하는 구조이다.
희소행렬계산에 대한 방대한자료는 희소행렬을 비교적 고밀도의 submatrices로 clustering하는 것이 희소행렬곱에 대한 최첨단성능을 제공한다는것을 시사한다.

- Inception구조는 vision신경망에서 암시하는 희소구조(sparse structure)를 근사화하고 고밀도로 쉽게사용가능한 구성요소에 의해 가정된 결과를 다루는 정교한신경망 topology구성 알고리즘의 가상출력을 평가하기위한 첫 저자의 사례연구로 시작되었다.
매우 이론적인 방법이었음에도 불구하고 정확한 topology의 선택에 대해 2번 반복 후 이득을 볼 수 있었는데, 
learning-rate, hyper-parameter 및 개선된 training 방법론(methodology)을 추가하여 결과적으로 Inception구조가 기본 신경망으로서의 localization 및 object detection의 맥락에서 특히낭 유용하다는 것을 알았다.
흥미로운 점은 대부분의 기존구조의 선택에 대한 철저한 의문을 제기하였고 test에도 불구하고 적어도 locally optimal이라는 점이다.

- 제안된 구조가 컴퓨터비전의 성공적 사례가 되었지만, 컴퓨터비전의 구축을 이끈 guiding 원리에 기여할 지는 의문이다.
예를 들어, 아래에 설명된 원칙에 기초한 자동화 툴이 vision신경망에 대해 유사하지만 더 나은 topology를 찾을 수 있는지 확인하려면 훨씬 더 철저한 분석과 검증이 필요하다.
가장 설득력있는 증거는 자동화된 시스템이 동일한 알고리즘을 사용하나 매우 다르게 보이는 global 구조를 사용해 다른 영역에서 유사한 이득을 얻는 network topology를 생성하는 경우인데, 적어도 Inception구조의 초기성공은 이 방향으로의 흥미로운 작업에 대한 확고한 motivation을 제공한다.

4. Architectural Details

[Inception구조의 주요 아이디어., main idea for inception architecture]
- 기반: convolution의 optimal local sparse structure가 어떻게 근사화되고 쉽게사용가능한 조밀한 구성요소로 커버되는지를 찾기 위한 것.
- translation 불변성(invariance)를 가정하는 것은 우리가 신경망의 conv.block을 구축한다는 의미이다.
- 따라서 우리가 필요한 것은 최적의 국소구조(optimal local construction)를 찾고 공간적으로 반복하는 것이다.

cf) sparse structure: 고수준의 정확도를 유지하면서 계산적으로도 효율적이기 위해 설계된 신경망구조
이 논문에서는 높은 정확도를 위해 효율적인 합성곱연산과 희소성의 조합을 사용하도록 신경망이 설계된 방식을 설명한다.


- Arora et al.은 layer-by-layer 구조를 제안한다.
(layer-by-layer구조는 하나가 마지막 layer의 통계적 상호관련성과 그들을 높은 연관성으로 군집(cluster)하는 것이다.)
이 군집들 형태는 다음층의 unit과 이전층의 unit간의 연결이 되어있다.

- 우린 이전층의 각 unit이 input image의 일부영역이고, 이런 unit은 filter bank로 그룹화된다 가정한다.
입력층과 가까운 하위층일 수록 상호연관된 unit은 국소영역(local region)에 집중 될 것이다.
이는 즉, 많은 cluster들이 단일영역에 집중되고 다음층에서 1x1 conv.layer로 커버될 수 있음을 의미한다.

- 하지만, 더 큰 patch에 대한 합성곱으로 커버되는 더 적은 수의 공간적으로 분산된 군집(spatially spread out clusters)이 있을 것이며, 더욱 큰 영역에 대한 patch수 감소가 있을 수 있다.

- 이런 patch할당문제를 피하기 위해서, 현재 Inception구조는 filter 크기를 1x1, 3x3, 5x5로 강요하고 있다.
다만, 이런 결정은 필요성이라기 보다는 편리성이라는 점에 더욱 기반을 두고 있다.
이는 Inception구조가 다음층의 입력을 형성하는 단일출력벡터에 연결된 output filter bank와 함께 모든 계층의 조합방식이라는 것을 의미한다.
게다가, pooling은 최신 ConvNet에서 성공을 위해서는 필수적인데, 이는 각 단계에 대안적인 병렬풀링(parallel pooling)을 하는 것이 추가적인 이득을 주는 효과라는 것을 제안한다.


- 이런 "Inception Module"이 서로 겹쳐쌓이기에 출력상관통계(output correlation statistics)는 아래처럼 다양하다.
더 높은 추상화특징이 더 높은층에 의해 포착된다.
이로 인해 더 높은 추상화특징의 공간집중도는 감소할 것이다.
이는 우리가 더 높은층으로 갈수록 3x3과 5x5 convolution 비율이 증가할 것임을 시사한다.


- "Inception Module"의 가장 큰 문제(적어도 단순(naive)한 형태에서)는 적은 수의 5x5 convolution들도 많은 수의  filter가 있는 conv.layer에서 매우 비용이 많이든다는 점이다.
이 문제는 pooling unit을 추가하면 더욱 두드러지는데, output filter수는 이전단계의 filter수와 같다.
즉, pooling.layer output. &. conv.layer output 간의 병합(merge)은 단계간의 output 수를 불가피하게 증가시킨다.

- 이 구조는 최적의 희소구조(optimal sparse structure)를 포함한다.
다만, 매우 비효율적인 수행으로 몇단계가 안지나 computational blowup(폭발)로 이어질 수 있다.
이는 Inception Module에 대한 2번째 아이디어를 이끌어 주었다.

[Inception Module에 대한 2번째 아이디어]
- 2번째 아이디어로 이어진 이유는 그렇지 않으면 계산요구량이 많이 증가하기에 차원축소(dimension reduction) 및 차원투영(dimension projection)를 현명하게 적용했는데, 이는 embedding의 성공에 기반했다.
저차원임베딩에서도 상대적으로 큰 image patch에 대해 많은 정보를 포함될 수 있기 때문이다.

- 하지만, 임베딩은 조밀하고 압축된 형태로 정보를 나타낸다. (압축된 정보는 모델링하기 어렵다.)
우린 대부분의 상황에서 희박한 표현력을 유지하고, 신호를 일관적으로 집계해야할 때 압축하고 싶다.
이말인 즉슨, 1x1 convolution은  expensive한 3x3, 5x5 convolution의 이전에서의 reduction을 계산하는데 사용한다는 것이다.
게다가 reduction의 사용은 2가지 목적을 갖는 ReLU의 사용도 포함된다.


[일반적인 Inception 신경망]
- grid해상도를 절반으로 줄이기 위해 이따금씩 MaxPooling(with stride=2)이 서로 적층된 inception module로 구성된 신경망이다.

training시 효율적인 memory사용을 위한 기술의 이유로, 다음과 같은 방식을 사용하고자한다.
- higher layer: Inception module 사용.
- lower layer: 전형적인 convolution방식
이는 너무 엄격하게 필수다!라고는 하지 않으며, 단순히 현재구현된 일부 인프라적 비효율성을 반영하는 것이다.



[Inception 구조의 주요이점]
① 제어되지않는 계산복잡성의 폭발없이, 각 단계에서 unit수를 크게 늘릴 수 있다는 것이다.
  - 차원축소의 ubiquitous(어디에서나)적 사용은 마지막단계에서 input filter를 다음층으로 차폐(shielding)할 수 있게한다.
  - 또한 큰 patch로 convolving하기 전에 차원을 줄인다.

② 이 설계방식의 또다른 실용적측면은 시각정보가 다양한규모에서 진행 및 집합하여 동시에 다른 규모로부터의 추상적특징에 대한 직관을 할당한다는 것이다.

5. GoogLeNet

- Yann LeCuns의 LeNet-5 신경망에 대한 경의를 표해 GoogLeNet이라는 이름을 지었는데, ILSVRC14에 제출하는데 사용된 Inception구조의 특정화신을 GoogLeNet을 사용해 언급하였다.

- 또한, 더 깊고 넓은 Inception신경망을 사용했을 때, 품질은 떨어져도 앙상블을 곁들이면 결과가 약간 개선되었다.
실험결과, 정확한 구조의 파라미터의 영향이 상대적으로 작음을 보여주었기에 신경망의 세부사항을 생략한다.
우린 앙상블 7개모델 중 6개에 대해 정확히 동일한 topology(다른 샘플링방법으로 훈련됨)가 사용되었다.

[Inception Module의 내부구조]
- 모든 convolution은 ReLU의 activation을 사용한다.
- 신경망에서 수용필드(receptive field)의 크기는 평균감법(mean subtraction)으로 224x224의 RGB channel을 취한다. 
- "#3x3 reduce" 와 "#5x5 reduce"는  3x3 및 5x5 convolution이전에 사용된  축소층(reduction layer)에서의 1x1 filter수를 나타낸다.
- Pool proj column에 내장된 MaxPooling 이후의 translation layer에서 1x1 filter의 수를 볼 수 있다.
이런 모든 reduction/projection layer는 ReLU를 사용하며 총 22개의 parameter가 있는 층으로 구성되어 있다. (전체는 풀링포함 27층)

cf) [Projection layer] 
- 입력 데이터의 차원을 맞춰 다양한 크기의 필터에 대해 연산을 수행할 수 있도록 하는 역할을 하는 입력 데이터의 차원을 조정하는 일반적인 convolutional layer이다.
일반적으로 pooling layer는 데이터의 공간적 크기를 줄이기 위해 사용되며, Inception module에서도 pooling layer가 사용될 수 있지만, projection layer와는 별개로 동시에 사용될 수 있다.
예를 들어, 5x5 필터를 적용할 때 입력 데이터의 깊이가 192이고, 출력 특징 맵의 깊이를 32로 설정한다면, 1x1 컨볼루션 연산을 수행하는 projection layer를 사용하여 입력 데이터의 깊이를 32로 줄일 수 있다. 이렇게 차원을 맞춘 입력 데이터를 다양한 크기의 필터에 대해 컨볼루션 연산을 수행하면서 다양한 종류의 특징 맵을 추출한다.


- 분류기(classifier) 이전 Average Pooling의 사용은
[Min Lin, Qiang Chen, and Shuicheng Yan. Network in network. CoRR, abs/1312.4400, 2013.]를 기반으로 한다.
다만, 우리의 구현은 추가적인 linear layer를 사용한다는 점에서 다르다.
이를 통해 다른 label set에 대한 신경망을 쉽게 적용하고 미세조정할 수 있다.

FC.layer에서 Average Pooling으로 이동하면, 상위 1개의 정확도가 약 0.6% 향상된다.
Dropout의 사용은 하지만, FC.layer를 제거함에도 필수적인 것으로 나타났다.



[우려사항]
- 신경망의 상대적으로 깊은 깊이 고려시, 모든층에 효과적인 방식으로 gradient를 역전파하는 방식이 우려되었다.
- 한가지 흥미로운점은 이때, 상대적으로 얕은 신경망의 강력한 성능이 신경망 중간층에 의해 생성된 특징이 매우 두드러져야만(discriminative) 한다는 점을 시사했다는 것이다.
- 이런 중간층에 연결된 보조분류기(auxiliary classifier)를 추가함으로써 classifier가 하위단계에서 매우 두드러지는 특징을 보여준다.
이때, 역전파되는 gradient 신호를 증가시켜 추가적인 규제화(regularization)을 할 수 있을 것이다.

- 이런 classifier는 Inception (4a) 및 Inception (4d) 모듈의 출력위치에 배치된 더 작은 ConvNet의 형태를 취한다.
training과정에서, 그들의 Loss는 discount weight인데, 이는 신경망의 전체 Loss에 추가된다.
(보조분류기(auxiliary classifier)의 Loss는 0.3의 weight를 부여.)

- 추론(inference)시, auxiliary classifier는 제거되는데, auxiliary classifier를 포함한 부가적인 신경망(extra network on the side)의 정확한 구조는 아래와 같다.
• 5×5 filter와 stride=3을 갖는 Avg.pooling layer, (4a)의 경우 4×4×512 output, (4d) 단계의 경우 4×4×528 output.
• 차원 축소 및 ReLU를 위한  1×1 convolution(128개 filter존재).
• 1024개 unit과 ReLU를 갖는 FC.layer.
• Dropout(0.7)의 layer (Drop ratio = 70%)
• softmax Loss를 classifier로 linear layer(main classifier와 동일한 1000개 클래스를 예측하지만 추론 시간에 제거됨).


cf) Inference time
추론 시간은 학습된 기계 학습 모델이 이미 학습된 후 새로운 입력에 대해 예측 또는 추론을 수행하는 데 걸리는 시간이다.
학습된 모델을 새로운 데이터에 적용하고 출력 예측을 생성하는 데 걸리는 시간으로 즉, 모델의 레이어를 통해 입력 데이터의 순전파(foward pass)를 수행하고 예측된 출력을 생성하는 데 걸리는 시간이다.


결과 네트워크의 개략도는 그림 3, 아래와 같다.

6. Training Methodology

- 우리의 신경망은 DistBelief를 training으로 사용했다.
(DistBelief는 대규모 분산 기계학습 시스템으로서 구글 클라우드 플랫폼에서 실행되는 클라우드 서비스이다. DistBelief의 단점으로는 구글 내부 인프라와 너무 단단히 연결되어 있다는 점, 뉴럴 네트워크만 지원한다는 점을 들 수있다.) 


- 우린 training에서 Asynchronous SGD(with 0.9 momentum)을 사용했으며, learning rate를 8epoch마다 4%감소하도록 수정하도록 하였다.


- 우리의 image sampling방법은 대회를 거치면서 몇달동안 크게 변화했다.
이미 통합된모델은 다른방법으로 (decay, learning rate같은 hyper-parameter의 변경으로) training을 진행하였기 때문에 이런 신경망을 training하는 가장효과적인 하나의 방법을 결정내리기 어렵다.

- 더욱 방법을 복잡하게 하기위해, 관련결과를 작게하거나 크게하는 등의 학습을 진행하였다.
- 그러나 대회 후 효과가 좋다고 확인한 한가지 규칙(prescription)은 크기가 image면적의 8~100%사이에 고르게 분포하고 가로/세로가 3/4 ~ 4/3 사이에서 무작위선택되는 image의 다양한 크기 patch의 sampling을 포함한다는 것이다.
- 또한, 광도왜곡(photometric distortion)이 overfitting 극복에 어느정도 유용하다는 것을 알아냈다.

- 게다가, 다른 hyper-parameter의 변화와 함께 크기조정을 위해 (bilinear, area, nearest neighbor and cubic, with equal probability 같은) 무작위보간방법(random interpolation methods)을 상대적으로 늦게 사용했다.
따라서 최종결과가 위의 방법의 사용으로 긍정적영향을 받았는지의 여부를 절대적으로 확신할 수 없다.

Adam versus SGD

7. ILSVRC-2014  Classification. Challenge. Setup  and Result

- ILSVRC 2014 classification에는 1.2백만의 training dataset. //. 각각 5만, 10만개의 validation, test dataset이 있다.
top-1 accuracy rate: predict class와 ground truth를 비교
top-5 accuracy rate: ground truth자료를 처음 5개의 predict class와 비교 (ground truth자료가 top-5안에 있으면 image가 옳게 분류된 것으로 간주) 


- 대회참가에서 training에는 외부데이터를 사용하지 않았다.
- training 기술은 이 논문에서 전술(aforemention)한 것과 같으며, testing에서는 고성능을 얻기 위해 아래와 같은 정교한 기술을 사용했다.
① 동일한 GoogLeNet모델의 7개 버전을 독립적으로 training하고 ensemble prediction을 수행했다.
  - 이 모델은 동일한 초기화 및 learning rate방식으로 훈련했고, sampling방법과 input image는 단지 순서만 무작위로 다르다.
     (이때, 초기화는 주로 동일한 초기화가중치를 사용했는데, 간과(oversight)의 이유 때문이었다.) 
  
② testing방식에서, AlexNet보다 더 공격적인(aggressive) cropping 접근법을 채택했다.
- 구체적으로, (256, 288, 320, 352로 제각각인 4개의) 더 짧은 치수(height or width)의 사용으로 image크기를 조정한다.
이때, resize된 이미지의 크기는 좌측, 중앙 및 우측 방형(square)을 취한다(초상화의 경우에는 상단, 중앙 및 하단 방형을 취한다).
- 각 방형에 대해 resize된 224x224 방형image 뿐만 아니라 4개의 모서리와 중앙이 crop된 224x224도 있는그대로의 버전을 반영한다(mirrored version).
- 결과적으로, 이는 image 하나 당  4×3×6×2 = 144개의 결과물이 생긴다.
- 이후 나오는 내용에서 알 수 있듯, 상당수의 결과물이 존재하면 많은 결과물의 이점이 미미해지기에 실제로 적용시에는 이러한 공격적인 crop은 필요하지 않을 수 있다는 점을 주의해야한다.

③ softmax 확률(probability)는 최종적인 예측값을 얻기 위해 여러 결과물 및 모든 개별분류기(individual classifiers)에 걸쳐 평균화된다.
- 우리의 실험에서 결과물에 대한 MaxPooling과 classifier에 대한 평균같은 validation data에 대해 접근방법의 대안을 분석했으나 이들은 단순평균(simple averaging)보다 성능이 떨어진다.
 

[최종제출의 전반적인 성과요인 분석]
- 성과: 대회에서 최종 제출은 validation, test data에서 6.67%의 top-5 error로 1위를 차지했다. 
이는 2012년 SuperVision방식에 비해 56.5% 낮은 수치이다.
classifier training에서 외부데이터를 사용한 전년도의 최고접근법인 Clarifai에 비해 약 40% 감소한 수치이다.
위의 표는 최고성능접근법에 대한 통계의 일부를 보여준다.

- 성과요인 분석: 위의 표에서 image prediction 시 모델 수와 사용되는 Crop의 수를 변경해 여러 test선택의 성능을 분석할 것이다.
하나의 모델만을 사용시 validation data에서 top-1 error rate인 모델을 선택
모든 숫자는 test data 통계에 overfitting되지 않도록 validation set을 이용한다.

8. ILSVRC-2014  Detection. Challenge. Setup. and. Result

9. Conclusions

- 본 논문의 결과는 쉽게 사용가능한 고밀도의 building block들에 의해 예상되는 최적의 빈약한 구조를 근사화하는 것이 컴퓨터비전을 위해 실현가능한 신경망 개선방법이라는 것을 알 수 있다.
- 이 방법의 주요 이점은 얕고 덜 넓은 신경망에 비해 계산요구량이 약간 증가하게 될 때의 상당한 품질의 향상을 얻는다는 것이다.
또한, context의 활용이나 bounding box regression을 하지 않아도 우리의 detection은 경쟁력이 있었으며 이 사실은 Inception 구조의 강점에 대한 추가적 증거라는 점을 제공해준다.

- 비록 유사한 깊이와 폭을 갖는 더 expensive한 신경망에 의해 유사한 결과를 얻을 수 있을 수도 있지만 우리의 접근방식은 희소적인 구조로의 이동이라는 점이 일반적으로 실현가능하고 유용한 생각이라는 확실한 증거를 제공한다.

🧐 논문 감상_중요개념 핵심 요약

"Going deeper with convolutions"
CNN의 개념과 이미지 분류 작업에서의 효율성을 소개하는 연구 논문으로 이 논문은 filter 크기가 다른 여러 병렬 convolution을 사용해 CNN을 효율적으로 훈련하는 "Inception Module"이라는 모듈을 제안한다.

[핵심 개념]

1. Inception Module
- GoogLeNet 아키텍처는 커널 크기(1x1, 3x3 및 5x5)가 다른 여러 병렬 컨벌루션 경로로 구성된 Inception 모듈을 사용한다.
이를 통해 네트워크는 다양한 규모의 기능을 캡처할 수 있고 네트워크 훈련의 계산 비용을 줄일 수 있다.

- 또한 Inception 모듈에는 입력의 차원을 줄이고 계산 속도를 높이기 위해 1x1 컨볼루션이 포함되어 있다.

- GoogLeNet 구조는 여러 Inception 모듈을 쌓고 보조 분류기를 사용하여 신경망이 서로 다른 층에서 구별되는 특징을 학습하도록 한다.
이 논문은 GoogLeNet 아키텍처가 AlexNet 및 VGG를 포함한 다른 CNN 아키텍처보다 더 적은 매개변수와 계산으로 ImageNet 데이터 세트에서 최첨단 성능을 달성한다는 것을 보여준다.

cf) depth는 깊이와 관련, width는 filter의 unit과 관련


2. 1x1 convolution
- GoogLeNet 구조는 또한 1x1 convolution을 사용하여 특징 변환 및 차원 축소를 수행하는 "네트워크 내 네트워크"(Network-in-Network) layer의 개념을 도입한다.

- Network-in-Network layer는 Inception module과 함께 사용되어 네트워크의 계산 비용을 더욱 줄인다.

cf) 3x3, 5x5은 1x1보다 expensive하다.


3. Normalization
각 층에 대한 입력을 정규화하고 내부 공변량 이동(internal covariance shift)을 줄이는 배치 정규화(Batch Normalization)의 사용으로 신경망이 더 빠르게 수렴하고 과적합을 줄이는 데 도움이 되게한다.


전반적으로 이 논문은 커널 크기가 다른 여러 병렬 합성곱 경로(multiple parallel convolutional pathways)를 사용해 깊은 CNN을 효율적으로 training하는 Inception 모듈을 소개한다.
이 논문은 GoogLeNet 구조가 ImageNet에서 최첨단 성능을 달성하고 심층 CNN trainig의 계산 비용(computational cost)을 줄인다는 것을 보여준다.

🧐  논문을 읽고 Architecture 생성 (with tensorflow)

import tensorflow as tf
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Dropout, Dense, Flatten, AveragePooling2D, concatenate

def inception_module(x, filters):
  # Filters is a tuple that contains the number of filters for each branch
    f1, f2, f3, f4 = filters
  
  # Branch 1
    branch1 = Conv2D(f1, (1, 1), padding='same', activation='relu')(x)
    
  # Branch 2
    branch2 = Conv2D(f2, (1, 1), padding='same', activation='relu')(x)
    branch2 = Conv2D(f2, (3, 3), padding='same', activation='relu')(branch2)
  
  # Branch 3
    branch3 = Conv2D(f3, (1, 1), padding='same', activation='relu')(x)
    branch3 = Conv2D(f3, (5, 5), padding='same', activation='relu')(branch3)
  
  # Branch 4
    branch4 = MaxPooling2D((3, 3), strides=(1, 1), padding='same')(x)
    branch4 = Conv2D(f4, (1, 1), padding='same', activation='relu')(branch4)
  
  # Concatenate the outputs of the branches
    output = concatenate([branch1, branch2, branch3, branch4], axis=-1)
  
    return output
  
def GoogLeNet(input_shape, num_classes):
    input = tf.keras.layers.Input(shape=input_shape)

  # First Convolutional layer
    x = Conv2D(64, (7, 7), strides=(2, 2), padding='same', activation='relu')(input)
    x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
  
  # Second Convolutional layer
    x = Conv2D(64, (1, 1), padding='same', activation='relu')(x)
    x = Conv2D(192, (3, 3), padding='same', activation='relu')(x)
    x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
  
  # Inception 3a
    x = inception_module(x, filters=(64, 96, 128, 16))
  # Inception 3b
    x = inception_module(x, filters=(128, 128, 192, 32))
   
  # Max pooling with stride 2
    x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
  
  # Inception 4a
    x = inception_module(x, filters=(192, 96, 208, 16))
  # Inception 4b
    x = inception_module(x, filters=(160, 112, 224, 24))
  # Inception 4c
    x = inception_module(x, filters=(128, 128, 256, 24))
  # Inception 4d
    x = inception_module(x, filters=(112, 144, 288, 32))
  # Inception 4e
    x = inception_module(x, filters=(256, 160, 320, 32))
  
  # Max pooling with stride 
    x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
    
  # Inception 5a
    x = inception_module(x, filters=(256, 160, 320, 32))
  # Inception 5b
    x = inception_module(x, filters=(384, 192, 384, 48))
    
  # global average pooling layer
    x = AveragePooling2D((7, 7), padding='same')(x)
    x = Flatten()(x)
    
  # Fully Connected layer with linear. and. Dropout
    x = Dropout(0.4)(x)
    x = Dense(1024, activation='relu')(x)
    
    
  # softmax
    output_layer = Dense(num_classes, activation='softmax')(x)
    
  # define the model with input and output layers  
    model = tf.keras.Model(inputs=input, outputs=output_layer)
    
    return model
    
    
    
model = GoogLeNet(input_shape=(224,224,3), num_classes=1000)
model.summary()

Model: "model"
__________________________________________________________________________________________________
 Layer (type)                   Output Shape         Param #     Connected to                     
==================================================================================================
 input_2 (InputLayer)           [(None, 224, 224, 3  0           []                               
                                )]                                                                
                                                                                                  
 conv2d_57 (Conv2D)             (None, 112, 112, 64  9472        ['input_2[0][0]']                
                                )                                                                 
                                                                                                  
 max_pooling2d_13 (MaxPooling2D  (None, 56, 56, 64)  0           ['conv2d_57[0][0]']              
 )                                                                                                
                                                                                                  
 conv2d_58 (Conv2D)             (None, 56, 56, 64)   4160        ['max_pooling2d_13[0][0]']       
                                                                                                  
 conv2d_59 (Conv2D)             (None, 56, 56, 192)  110784      ['conv2d_58[0][0]']              
                                                                                                  
 max_pooling2d_14 (MaxPooling2D  (None, 28, 28, 192)  0          ['conv2d_59[0][0]']              
 )                                                                                                
                                                                                                  
 
 ...
 
 
 conv2d_108 (Conv2D)            (None, 7, 7, 384)    295296      ['concatenate_16[0][0]']         
                                                                                                  
 conv2d_110 (Conv2D)            (None, 7, 7, 192)    331968      ['conv2d_109[0][0]']             
                                                                                                  
 conv2d_112 (Conv2D)            (None, 7, 7, 384)    3686784     ['conv2d_111[0][0]']             
                                                                                                  
 conv2d_113 (Conv2D)            (None, 7, 7, 48)     36912       ['max_pooling2d_25[0][0]']       
                                                                                                  
 concatenate_17 (Concatenate)   (None, 7, 7, 1008)   0           ['conv2d_108[0][0]',             
                                                                  'conv2d_110[0][0]',             
                                                                  'conv2d_112[0][0]',             
                                                                  'conv2d_113[0][0]']             
                                                                                                  
 average_pooling2d_1 (AveragePo  (None, 1, 1, 1008)  0           ['concatenate_17[0][0]']         
 oling2D)                                                                                         
                                                                                                  
 flatten_1 (Flatten)            (None, 1008)         0           ['average_pooling2d_1[0][0]']    
                                                                                                  
 dropout_1 (Dropout)            (None, 1008)         0           ['flatten_1[0][0]']              
                                                                                                  
 dense_2 (Dense)                (None, 1024)         1033216     ['dropout_1[0][0]']              
                                                                                                  
 dense_3 (Dense)                (None, 1000)         1025000     ['dense_2[0][0]']                
                                                                                                  
==================================================================================================
Total params: 23,040,216
Trainable params: 23,040,216
Non-trainable params: 0
__________________________________________________________________________________________________

😶 초록 (Abstract)

- Deep Neural Net의 training은 "각  층의 input과 parameter가 변한다" 는 점에서 매우 복잡하다는 것이 정론이다.
- 낮은 학습율, 조심스런 parameter 초기화로 인해 training을 느리게 만들고 포화 비선형성(saturating nonlinearity)으로 인해 model train을 악명높게 만든다.
- 우리는 위와 같은 현상을 internal covariate shift라 부르며, 이런 문제를 input layer를 normalizing을 통해 다룬다.

- 우리의 방법은 model 구조의 일부의 normalization과 for each training mini-batch에 normalization을 적용함을 통한 Batch-Normalization을 통해 더 높은 learning rates와 초기화에 대해 덜 신경 쓸 수 있도록 하는 그런 강점을 이끌어 내었다.
- Batch-Normalization은 또한 regularizer의 역할도 할 수 있는데, 어떠한 경우에는 Dropout의 필요성을 없애주었다.

- BN(Batch Normalization)의 앙상블의 사용으로 ILSVRC에서 최상의 결과를 얻었으며 더 조금의 training step으로 같은 결과에 도달할 수 있었다.

1. 서론 (Introduction)

- 딥러닝에서 SGD는 매우 효과적인 훈련방법으로 증명되었는데, SGD의 변형(momentum, Adagrad)들은 예술의 경지라 할 만하다.
- SGD는 loss를 최소화하기 위해 x1..N의 training data set에서 신경망의 parameter Θ를 최적화 한다.

- SGD의 이용시 training의 과정 및 각 step의 과정에서 크기 m의 mini-batch x1...m에 대해 생각해보자.
mini-batch는 parameter의 계산에 관한 loss function의 gradient값을 추정하곤 한다.

• mini-batch의 사용은 몇몇 장점이 있다.
  ①mini-batch에 대한 loss의 기울기(gradient) = 배치가 증가하면서 품질이 향상되는 training set에 대한 기울기의 추정치이다.
  ②둘째, 현대 컴퓨팅 플랫폼이 제공하는 병렬 처리로 인해 배치를 통한 계산은 개별 예제에 대한 m값 계산보다 훨씬 더 효율적일 수 있다.


- 이런 SGD는 간단하면서 효율적이지만 hyper-parameter, 특히 learning rate와 관련하여 세밀한 조정이 필요하다.
작은 변화라 해도 깊이가 깊어질수록 그런 변화들이 증대되기(amplify) 때문이다.

- layer들이 새로운 분포에 지속적으로 적응할 필요가 있어서 layer의 input의 분포(distribution)변화는 문제를 제시한다.
학습입력분포의 변화는 covariate shift(공변량 이동)을 경험하는데, 이는 보통 domain adaptation으로 해결한다.
다만, covariate shift의 개념은 sub-network(하위 신경망)나 layer가 동일한 부분에 적용해야 한다.
이로 인해 learning system이 전체를 넘어서 확장될 수 있다.

F1과 F2가 임의의 transformation이고, Loss를 최소화하기 위해 parameter Φ1, Φ2가 학습되는 신경망의 계산을 생각해보자. 학습 Φ2는 입력 x = F1(u, Φ1)이 sub-network에 공급되는 것(fed into)처럼 볼 수 있다.

예를 들어 경사하강단계에서 (batch size m  .&.  learning rate α) input x가 있는 독립실행형 신경망 F2의 경우와 정확하게 동등다.

따라서 train과 test data간의 동일한 분포를 갖는 것처럼 train을 더 효율적으로 만드는 input 분포의 속성(property)은 sub-network training에도 적용된다.
그래서 x의 분포는 시간이 지나게 되면 고정된 상태를 유지하는 것이 유리하다.
그러므로 Φ2는 x의 분포 변화를 보상하기 위해 재조정할 필요가 없다.

• z = g(Wu + b) ( g(x)는 sigmoid 1 / 1+exp(-x)함수, u는 input, b는 bias )에 대해 g'(x) = exp(x) / (exp(x)+1)^2으로 x의 절대값이 증가할 수록 0으로 수렴하는데, 이로 인해 gradient vanishing이 발생해 train이 느려진다.
이때, x=Wu + b에서 x는 아래층 parameter에 영향을 많이 받아 train중 parameter의 변경은 x의 많은 차원을 "비선형성의 포화상태(saturated regime of the nonlinearity)"로 만들고 수렴을 느리게 만든다.
이런 영향은 depth가 깊어질수록 증대되는데, 실제로 포화문제와 gradient소실문제를 다루기 위해 Rectified Linear Units(ReLU(x) = max(x,0))과 신중한 초기화, 작은 learning rates를 이용한다.

- 다만 입력값의 비선형성의 분배(non-linearity distribution)는 신경망의 훈련을 더 안정적으로 할 것이며 optimizer가 포화될 가능성이 적게 하고 훈련을 가속화 할 것을 확신할 수 있다. (Rectified Linear Unit (ReLU) activation이 신경망의 비선형성(non-linearity)을 만들 수 있다!)


• Internal Covariate Shift (내부 공변량 이동)
  - training과정에서 심층신경망의 내부 노드 분포의 변화를 내부 공변량 이동이라 하며 이를 제거하면 training을 빠르게 할 가능성이 있다.
  - 이를 위한 새로운 기술을 도입하는데, 이것이 바로 BN, Batch-Normalization으로 내부공변량이동을 줄여줘 심층신경망에서 매우 극적으로 training을 가속화시킬 수 있다.
 
  - layer의 입력값의 평균(means)과 분산(variance)을 고정함으로 이를 달성한다.
  - Batch Normalization의 추가적인 이점은 바로 신경망에서의 gradient flow이다.
  - 이는 발산(divergence)의 위험성없이 더 높은 learning rate의 사용을 허용하게 한다.
  - 또한, BN은 model을 규제화(regularize)하고 Dropout의 필요성을 줄여준다.
 즉, 신경망의 포화상태에 고착되는 것을 막아줌으로 포화 비선형성(saturating nonlinearity)을 가능하게 해준다.

cf.

non-linearity는 선형이 아닌 수학적연산을 말하며 이는 출력이 입력에 비례하지 않음을 의미. (선형적이면 입력에 비례하기 때문)

이는 출력에 적용되는 활성화함수를 통해 도입된다.

[Saturation]

- input이 증가해도 함수의 output이 포화되거나 특정값에 "고정"되는 현상

- 활성화함수 입장에서 포화는 일반적으로 input이 극단적으로 크거나 작을 때 발생한다.

 - 이로 인해 input과 관계없이 일정한 값을 출력하게 하여 기울기가 매우 작아지는(gradient vanishing) 문제가 발생한다.

 - 결과적으로 신경망에서 학습속도를 늦추거나 방해할 수 있다.

[Saturating non-linearity]

- 포화를 나타내는 활성화함수로 sigmoid, tanh함수가 대표적인 포화 비선형성(saturating non-linearity)예시이다.

- ReLU 및 그 변형 활성화함수는 포화를 나타내지 않아 비포화 비선형성(non-saturating non-linearity)라 부른다.

[linearity]의 종류

1. Identity Function: f(x) = x
2. Constant Function: f(x) = c (c는 상수., 상수함수)
3. Polynomial Function: f(x) = an x^n + a{n-1} x^{n-1} + ... + a1 x + a0 (an, a{n-1}, ..., a0가 모두 상수값)
4. Linear Regression: y = b1 x + b0 (b0과  b1가 상수값)
5. Affine Function: f(x) = a x + b      (a 와 b 가 상수값)

2. Towards Reducing Internal Covariate Shift

- Internal Covariate Shift는 training시 신경망의 parameter를 바꿀 때 발생한다.
- 따라서 training의 향상을 위해서는 내부공변량이동을 줄여야 한다.

• Whitening

 - layer의 input feature를 조정하고 평균(means)과 단위분산(unit variance)가 0이 되게 하는 정규화(normalization) 기술로 training수렴이 빨라진다.
- input을 whitening함으로써 BN은 각 계층에 대한 입력 분포(input distribution)를 안정화하는 데 도움이 될 수 있으므로 신경망이 입력 분포의 변화에 ​​덜 민감해지고 더 빠르고 안정적으로 수렴할 수 있다.
- 또한 다른 뉴런과 activation 사이의 공분산을 줄여 신경망을 정규화(regularize)하는 데 도움이 되고 일반화 성능을 향상시킬 수 있다.
- 이런 whitening은 신경망을 즉시 수정하거나 optimization algorithm의 parameter를 바꾸는 것으로 고려될 수 있다.

하지만 이런 수정이 optimization단계와 같이 분산되면 경사하강 시 update할 normalization을 선택해 gradient의 효과를 줄이는데, 다음 예시를 통해 설명한다.

따라서 b로의 update와 그에 따른 noramlization의 변화의 조합은 layer의 output의 변화, loss를 초래하지 않았다.
training이 계속될수록 b는 loss값이 고정된 상태에서 무한히(indefinitely) 커질 것이다.
이 문제는 정규화가 activation의 중심일 뿐만아니라 scale조정 시 더 악화될 수 있다는 점이다.
normalization parameter가 경사하강단계시 외부에서 계산되면 모델이 터져버린다.

이 문제의 해결을 위해 모든 parameter값에 신경망이 항상 원하는 분포로 activation을 생성하려 하는데, 이는 모델의 parameter 변수에 대한 loss 기울기(gradient)가 normalization을 설명하고 모델 parameter Θ에 대한 의존성을 설명할 수 있다.

x = layer input
X = training data에 대한 이런 input 집합
이에 대해 Normalization은 다음과 같이 작성된다.

이때, 정규화식은 training 예제인 x 뿐만 아니라 모든 예제인 X에 의존하게 되며
x가 다른층에 의해 생성될 때, 각각의 예제는 Θ에 의존하게 된다.
역전파를 위해 Jacobians를 계산해야 하며 이는 아래와 같다.

이때, 후자(X에 대한 편미분함수)를 무시하면 위에서 설명한 것처럼 exploding을 초래한다.
여기서 layer input을 whitening하려면 공분산 행렬 

와 그 역 제곱근을 계산해 다음과 같은 whitening activation

과 역전파를 위한 transform의 미분값을 생성해야하기 때문에 비용이 많이 든다.

- 이는 다른 대안을 찾게 만드는데, input normalization의 성능은 전체 training set의 모든 parameter update이후에 대한 분석을 필요로 하지 않는데, 이는 우리로 하여금 전체 training data에 대해 trianing과정 중 activation의 normalization을 통한 신경망정보의 보존을 하도록 하였다.