this.code();

😶 초록 (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을 통한 신경망정보의 보존을 하도록 하였다.

3. Normalization via Mini-Batch Statistics

각 layer입력부의 full whitening은 비용이 많이들고 모든곳에서 구별할 수 있는 것이 아니기 때문에 2가지 중요한 단순성을 만들었다.
① layer의 input과 output을 긴밀하게 하기위해 feature를 whitening하는 대신, N(0, 1)의 normalization을 각 scalar feature에 독립적으로 정규화시킨다.
  - d차원의 input x = (x1 . . . xd)에 대해 각 차원을 정규화(normalize)하면 다음과 같다.
(이때, E는 Expectation,  Var는 Variance로 training dataset에 대해 계산된 값)

- LeNet(LeCun et al., 1998b)에서 보였듯 normalization은 수렴속도를 높여준다.
이때, 간단한 정규화는 각 층의 입력부가 바뀔 수 있는데, 예를 들면 sigmoid input의 정규화(normalization)의 경우, 비선형성의 상황을 linear하게 만들 수도 있다.
이를 다루기 위해 우린 "신경망에 삽입된 transformation이 transform의 성질을 나타낼 수 있다(

the transformation inserted in the network can represent the identity transform

)"라는 것을 확신할 수 있다.
- 이를 위해 각 activation을 x(k), parameter쌍을 γ(k), β(k)라 할 때, 정규화된 값의 scale과 shift는 다음과 같다.
이 parameter들은 기존모델parameters와 함께 학습되며 신경망의 표현력을 회복시킨다.

- batch 설정에서 전체를 정규화한 activation으로 할 때, SGD의 사용은 비현실적(impractical)이어서 두번째 단순화를 만들었다. 


② training에서 SGD를 이용해 mini-batch의 사용으로 각 mini-batch는 각 activation의 평균과 분산의 추정치를 생성한다.
이런 통계로 normalization의 사용은 gradient 역전파에 전체적으로 관여한다.
- 주목할 점은 mini-batch의 사용은 공동의(joint) covariance보다 차원별 분산의 계산을 통해 가능하다는 점이다.
in the joint case, (singular covariance행렬들의 결과에서) whiten된 activation의 수보다 mini-batch size가 더 작기 때문에 regularization이 필요하다. 

- 크기가 m인 mini-batch 𝛣에 대해 생각해보자.
각 activation은 독립적으로 normalization이 적용되며 부분activation x(k)에 집중해보자.
(이때, 명확성(clarity)을 위해 k는 생략한다.)

[Batch Normalizing Transform의 Algorithm]
ⲉ는 수치적안정성(numerical stability)를 위해 mini-batch의 분산에 도입된 상수이다.

• numerical stability   - training시, loss함수의 기울기는 Back propagation으로 계산된다. (부분도함수의 다중연결계산이 포함됨)   - 이 계산은 많은 수를 포함하기에 gradient vanishing/exploding같은 수치적 불안정성으로 optimization이 어렵거나 불가능할 수 있다. (소수점 이하와 같은 수치계산시의 오차, 부정확성을 최소화 하기 위한 개념)   - Batch Normalization은 중간층의 activation을 normalize하여 training중의 수치적 안정성을 향상시키는 기술로 도입되었다. (이 논문에서는 SGD를 사용해 신경망을 훈련시키는 부분에서의 수치적 안정성의 중요성을 말한다.)   - Activation scale을 줄여 BN은 gradient vanishing, exploding을 방지해 더 안전하고 효율적인 training이 가능해졌다.   - 또한 bias를 사용하지 않음을 통해 수치계산의 오차를 최소화 할 수도 있다. (다만, 성능저하의 우려로 인해 성능과 수치적 안정성간의 적절한 균형이 필요하다.)   [numerical instability  with. overfitting] - 수치적 불안정성은 overfitting으로 이어질 수 있는데, 예를들어 기울기가 매우 커지거나 작아지면 optimization이 불안정해지고 overfitting이 발생할 수 있다. - 또한 수치적 불안정성으로 수치계산이 부정확해지면 최적의 값으로의 수렴이 되지 않아 overfitting발생이 가능하다. - 다만 model의 복잡도, train data의 불충분 및 노이즈로 overfitting이 수치적불안정성이 없어도 발생가능하다.

- BN transform은 activation을 조정하기 위해 도입될 수 있다.

이런 값의 분포는 Expectation 0과 1의 분산값을 갖는것 뿐만 아니라 각각의 mini-batch의 원소들이 우리가 ⲉ를 무시한다면 같은 분포로 부터 표본이 나오는데, 이는 아래와 같은 expectation 즉, 기댓값에서 관찰가능하다.

training에서 transformation과정을 통해 나온 loss의 기울기 ℓ에 대해 backpropagation을 진행하고 BN transformation의 parameter에 대한 gradient(기울기)를 계산할 필요가 있다.
이때, chain rule을 사용해 아래와 같이 단순화 한다.

즉, BN transformation은 정규화된 activation을 신경망에 전하는 차별화된(differentiable) tranformation이다. 
이는 model training에서 layer가 internal covariate shift가 적은 입력분포로 학습을 계속함을 통해 학습을 가속화한다는 것을 확신하게 해준다.
또한 이런 정규화된 activation에 적용되어 학습(learn)된 affine transformation은 BN transformation이 identity transformation을 나타내게 하며 신경망의 수용력을 보존한다.

3.1 Training and Inference with Batch-Normalized Networks

- Batch Normalization 신경망을 위해 우린 activation의 부분집합을 특정해야하고 그 각각에 대해 BN transform을 Algorithm. 1.을 이용해 집어넣어야 한다.
- 일전에 x를 입력으로 받은 모든층은 이제 BN(x)로 표기한다.
- BN을 사용하는 모델은 [ BGD  ||  mini-batch size m > 1인 SGD  ||  Adagrad(Duchi et al., 2011)]같은 변형(variants)을 사용해 훈련할 수 있다. 
- mini-batch에 의존하는 activation의 정규화는 효과적인 training을 허용하지만, 추론(inference)에서 필요하지도, 바람직하지도 않는데 우리의 output이 결과적으로 input값에만 의존하기를 원하기 때문이다.

3.2 Batch-Normalized Convolutional Networks

- Batch Normalization은 신경망의 모든 activation집합에 적용할 수 있기에 우리는 요소별(element-wise) 비선형성을 따르는 affine transformation으로 구성된 transform에 초점을 맞춘다.

W 와 b는 학습된 매개변수이고 g(.)는 (sigmoid, ReLU같은) 비선형성함수(saturating nonlinearity)이다.
이 식은 FC층과 convolution층 모두 적용되는데, 비선형성 전에 x = Wu + b를 정규화 함을 통해 바로 BN transform을 추가해줬다.
더불어 input u도 정규화할 수 있었지만 u는 다른 비선형성의 출력일 가능성이 높아 분포가 training과정에서 바뀔 수 있기에 첫번째와 두번째 moment를 제한하는 것만으로는 공변량이동을 제거하지 않을 것이다.

- 그와는 대조적으로 Wu + b는 대칭적이고 희소하지않은 분포를 가질 가능성이 더 높으며, 이는 "more Gaussian (Hyva ̈rinen & Oja, 2000)"으로; 이 분포를 정규화하면 안정적인 분포의 activation이 될 가능성이 높다.

- 따라서 이에대해 주목할 점은, 우리가 Wu + b를 정규화하기에 bias b의 효과는 후속 평균의 차에 의해 취소될 것이기에 무시될 수 있다.
이때, bias의 역할은 Algorithm. 1.의 β에 의해 가정된다.
따라서 z = g(Wu + b)는 다음과 같이 BN transformation이 x = Wu의 각 차원에 독립적으로 적용되는 방식으로 아래와 같이대체된다. (이때, 각 차원에는 학습된 매개 변수 γ(k), β(k)라는 별도의 쌍이 존재한다.)

- conv.layer에서 우린 convolution의 속성을 복종시키기 위해 normalization을 사용하는데, 그래서 동일한 특징맵의 다른위치에 있는 다른 원소들이 동일한 방식으로 정규화된다.
이를 달성하기 위해 우린 모든 위치의 mini-batch의 activation을 긴밀하게 연결한다.

- Algorithm.1.에서, 우린 𝜝가 mini-batch의 요소와 공간위치 모두에 걸쳐 특징맵의 모든 요소의 집합이 되게 한다. - 따라서 크기가 m인 mini-batch와 pxq크기의 특징맵의 경우, 크기가 m' = |𝜝| = m · pq인 효과적인 mini-batch를 사용한다.

- 우린 activation당이 아닌, feature map당 parmeter변수 쌍인 γ(k)와 β(k)를 학습한다.
- Algorithm.2.가 비슷하게 수정되었는데, 추론하는동안 BN transform은 주어진 특징맵의 각 activation에 동일한 linear transformation을 적용한다.

3.3 Batch Normalization enables higher learning rates

- 전통적인 심층신경망에서, 너무 높은 학습율은 poor local minima에 갇히는 것 뿐만 아니라 기울기 소실/폭발을 야기했다. 
- Batch Normalization은 이런 문제를 다루는 것을 도와준다.
- 신경망을 거친 activation을 정규화함으로써 parameter에 대한 작은 변경이 activation의 기울기를 더 크고 최적의 변화로 증폭되는 것을 방지하는데, training이 비선형성의 포화상태에 갇히는 것을 방지하는것이 바로 그 예시이다.

- 또한 BN은 training에서 parameter부근을 더 회복력 있게 만드는데, 보통 large learning rate는 parameter의 규모를 증가시켜 gradient 역전파에서 model의 폭발을 초래한다.
하지만 Batch Normalization과 함께라면 layer에서의 Back Propagation은 parameter의 규모면의 영향을 받지 않는다.

이때, Scale은 Jacobian layer나 결과적으로 gradient 전파에 영향을 미치지 않는다.
게다가 가중치가 클수록 기울기가 작아지고 BN은 parameter의 성장(growth)을 안정화한다.
또한 Batch Normalization이 layer Jacobian이 training에 유리한 것으로 알려진 1에 가까운 단수값(singular value)을 갖도록 할 수 있다고 추측한다.(Saxe et al., 2013)

실제로 transformation은 선형적이지 않고 정규화된 값이 Gaussian분포이거나 독립적이라는 보장은 없다.
하지만, 그럼에도 불구하고 Batch Normalization이 gradient propagation을 더 잘 작동시킬 것이라 믿는다.

- gradient propagation(기울기 전파)에 대한 Batch Normalization의 정확한 영향은 추가적인 연구로 남아있다.

3.4 Batch Normalization regularizes the model

- Batch Normalization으로 training할 때, training예제는 mini-batch의 다른 예시들과 함께(conjunct) 표시되며, training 신경망은 더 이상 주어진 training 예제에 대한 결정적인 값을 생성하지 않는다.
이 효과는 신경망의 일반화(generalization)에 매우 이점을 갖는다(advantageous).

- Dropout(Srivastava et al., 2014)이 overfitting을 줄이기 위해 일반적으로 사용되는 방식인 반면에 Batch Normalization이 적용된 신경망은 Dropout이 감소되거나 제거될 수 있음을 발견했다.

4. Experiments

4.1 Activations over time

-  training에서 internal covariateshift와 이에 대항하는 Batch Normalization의 능력을 증명하기 위해 MNIST dataset을 사용. (이때, 28x28의 작은 image를 input으로 3개의 FC-layer와 100개의 activation을 각각 갖는 단순한 신경망을 사용)
- 각 층은 sigmoid함수 y = g(Wu + b)를 통해 계산되며, 이때 W는 작은 무작위 Gaussian값으로 초기화된다.
- 마지막 층은 FC-layer를 이용해 10개의 activation이며 cross-entropy loss를 사용한다.
- Section 3.1에서처럼 신경망의 각 은닉층에 Batch Normalization을 사용한다.
- 우리의 주 관심사는 model의 성능보다는 baseline과 BN간의 비교에 중점을 둔다.

(a)를 보면, BN을 사용한 것이 더 높은 정확도를 갖는데, 그 이유를 조사하기위해 training과정중의 신경망의 sigmoid에 대해 연구하였다.
(b,c)에서 original network(b)는 전반적으로 평균과 분산이 많이 변화하는 반면, BN을 사용한 network(c)의 경우, 분포(distribution)가 안정적임을 볼 수 있는데, 이를 통해 training에 도움을 주는 것을 알 수 있다. 

4.2 ImageNet Classification

- 2014년의 Inception network에 Batch Normalization을 적용, 더 자세한 사항은 부록(Appendix)에 기재.
- (Sutskever et al.,2013)에 기재된 momentum계수와 32 mini-batch size를 사용
- 이때, 기존의 Inception에 Batch Normalization을 추가한 수정된 모델을 사용하여 evaluate를 진행하였다.
- 특히, Normalization은 Conv.layer의 비선형성(non-linearity., ReLU)이 입력부분에 적용하였다.

• 4.2.1 Accerlerating BN Networks

단순히 Batch Normalization을 신경망에 추가한다고 완전한 이점을 주는 것은 아니다.
완전한 이점을 위해 신경망 및 training parameter에 대해 다음과 같은 변형이 필요하다.  
Increase learning rate.
  - training speed를 높임
Remove Dropout.
  - Batch Normalization은 Dropout과 동일한 목표를 이행하기 때문
Reduce the L2 weight regularization.
  - L2 가중치를 줄여서 정확도를 높였음
Accerlerate the learning rate decay.
  - learning rate의 감쇠율을 기하급수적으로 진행(for train faster)
Remove Local Response Normalization.
  - BN의 사용으로 LRN의 필요가 없어짐
Shuffle training examples more thoroughly.
  - 철저하게 train예시를 섞음으로 mini-batch에서 동일한 예제가 나오는 것을 방지
- Reduce the photometric distortions.
  - 광도측정의 왜곡을 줄여 real image에 집중하게함 (∵ BN신경망은 train faster. &. observe fewer time이기 때문)

• 4.2.2 Single-Network Classification

Inception.
  - 처음 learning rate는 0.0015로 초기화하여 train
BN-Baseline.
  - non-linearity이전, Batch Normalization을 적용한 Inception과 동일
BN-x5.
  - 위의 모델에 Section 4.2.1을 적용
  - 초기 학습률은 0.0075로 5배 증가시켰으며 동일한 학습률로 기존 Inception의 매개변수가 무한대에 도달하게함
BN-x30.
  - BN-x5와 동일하지만, 초기학습률은 0.045로 Inception의 30배이다.
BN-x5-Sigmoid.
  - BN-x5와 동일하지만, ReLU대신 sigmoid non-linearity를 사용했다.

여기서 흥미로운 점은 BN-x30이 다소 초기에는 느렸지만 더 높은 최종 accuracy에 도달했다는 점이다.
internal covariance shift의 감소로 sigmoid를 비선형성으로 사용할 때, Batch Normalization을 훈련할 수 있다는 것을 증명하였다. (흔히들 그런 신경망 train이 어렵다고 알려진 것에도 불구하고.)

• 4.2.3 Ensemble Classification

BN-x30을 기반을 둔 6개의 신경망을 이용해 다음과 같은 사항에 집중해 수정하였으며 결과는 5. Conclusion의 표를 참고한다.
- Conv.layer의 초기 weight를 증가시킴
- Dropout의 사용 (Inception에서 사용하는 40%에 비해 5~10%정도만 수행)
- model의 마지막 은닉층과 함께 non-convolution, activation 당 Batch Normalization을 사용

5. Conclusion

- 기계학습의 training을 복잡하게 만드는 것으로 알려진 Covariate Shift(공변량 이동)은 sub-network와 layer에도 적용되며
network의 내부 활성화에서 이를 제거하면 training에 도움이 된다는 전제(premise)를 기반으로 한다.

- Normalization은 network를 train에 사용되고 있는 optimization method를 적절하게 다룰 수 있다.
각각의 mini-batch에 Normalization을 적용하고 normalization parameter를 통한 기울기의 역전파를 위해 SGD를 사용한다.

- network의 결과는 포화비선형(saturating nonlinearity)로 훈련될 수 있고, training rate의 증가에 더욱 관대(tolerant)하며 정규화(regularization)를 위한 Dropout이 필요하지 않은 경우가 많다.

- 최첨단 image classification model에 Batch-Normalization을 추가하는 것 만으로도 training속도를 크게 향상시킬 수 있다.

- learining rate를 높이고 Dropout을 제거하고 Batch-Normalization에 의해 제공되는 기타 수정사항을 적용함으로
우리는 적은 training step으로 이전의 첨단기술에 도달하며 이후의 single-network image classification을 능가한다.
또한, Batch-Normalization으로 훈련된 여러 모델들의 결합으로 ImageNet에서 가장 잘 알려진 방법보다 훨씬 우수한 성능을 발휘할 수 있다.

[Batch-Normalization의 목표]

- 훈련 전반에 걸쳐 activation값의 안정적인 분포(distribution)의 달성
- experiments에서 출력분포의 1차 모멘트와 2차 모멘트를 일치시키면 안정적 분포를 얻을 가능성이 높다.
∴ 비선형성 전에 Batch-Normalization을 적용시킨다.

- BN의 또다른 주목할 점은 Batch Normalization transform이 동일성(표준화 layer는 개념적으로 필요한 scale과 shift를 흡수하는 learned linear transform이 뒤따르기에 필요하지 않았음)을 나타내도록하는 learned scale과 shift, conv.layer의 처리, mini-batch에 의존하지 않는 결정론적 추론, 신경망의 각 conv.layer의 BN이 포함된다.

- 즉, Batch Normalization이 conv.layer를 처리할 수 있고 미니 배치에 의존하지 않는 결정론적 추론을 가지고 있다는 뜻이며 추가적으로 신경망의 각 conv.layer를 정규화한다는 의미이다.

[이번 연구의 문제점 및 향후 목표]
BN가 잠재적으로 가능케하는 모든 범위의 가능성을 탐구하지 "않았다."
- 따라서 internal covariate shift와 gradient vanishing, exploding가 특히나 심각할 수 있다.
- normalization이 gradient propagation을 향상시킨다는 가설을 철저하게 검증하는 방법은 당연히도 말이다.
- 우리는 전통적인 의미에서 적용의 부분에 도움이 될 지 [신경망에 의해 수행되는 normalization이 모집단의 평균과 분산의 재계산만으로 새 데이터분포보다 쉽게 일반화 가능한지의 여부]를 조사할 계획이다.

😶 부록 (Appendix)

Variant of the Inception Model Used

위의 Figure 5는 GoogleNet구조와 관련해 비교한 것으로 표의 해석은 GoogleNet(Szegedy et al., 2014)을 참조.
GoogLeNet과 비교했을 때, 주목할만한 구조는 다음과 같다.
• 5x5 conv.layer는 2개의 연속된(consecutive) 3x3 conv.layer로 대체된다.
  - 이는 network의 최대깊이를 9개의 weight layer로 증가시킨다.
  - 또한, parameter수를 25% 증가시키고 계산비용(computational cost)를 30%정도 증가시킨다.

• 28x28 inception module은 2개에서 3개로 증가시킨다.
• module내부에서는 maxpooling과 average pooling이 사용된다.
• 두 inception module사이에서 pooling layer는 없지만 module 3c, 4e에서 filter 연결 전에 stride=2의 conv/pooling layer가 사용된다.

우리의 model은 첫번째 conv.layer에서 8배의 깊이를 사용하는 분리가능한 convolution을 사용했다.
이는 training시의 Memory소비를 증가시키고 computational cost를 감소시킨다.

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

"Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift"
Sergey Ioffe와 Christian Szegedy가 2015년에 발표한 연구 논문으로 이 논문은 심층 신경망의 훈련을 크게 향상시킬 수 있는 Batch Normalization이라는 기술을 제안한다.

[핵심 개념]

1. Internal Covariate Shift
이 논문은 내부 공변량 이동(Internal Covariate Shift) 문제에 대해 설명하는데, 이 문제는 training시 레이어에 대한 입력 값이나 parameter 분포의 변화를 의미한다.
이것은 후속 계층학습의 학습속도를 늦추는 것으로 학습과정을 어렵게 만들 수 있다.

2. Batch Normalization
이 논문은 내부 공변량 이동 문제에 대한 해결책으로 Batch-Normalization을 제안한다.
배치 정규화는 배치 평균(mean)을 빼고 배치 표준편차(standard deviation)로 나누어 계층에 대한 입력을 정규화하는 것입니다

3. Learnable Scale and Shift
입력을 정규화(normalization)하는 것 외에도 배치 정규화는 두 가지 학습 가능한 매개변수인 scale parameter와 shift parameter를 도입한다.
이러한 parameters를 통해 신경망은 정규화된 입력에 대한 optimal scale 및 shift를 학습할 수 있다.

4. Improved Training
이 논문은 배치 정규화가 내부 공변량 이동의 영향을 줄임으로써 심층 신경망의 교육을 크게 개선할 수 있음을 보여준다.
이것은 더 빠른 수렴, 더 나은 일반화 및 다양한 작업에서 향상된 성능으로 이어진다.

5. Compatibility
이 논문은 배치 정규화가 다양한 신경망 아키텍처 및 활성화 기능과 함께 사용될 수 있음을 보여준다.

전반적으로 이 논문은 심층 신경망 훈련을 개선하기 위한 중요한 기술을 소개하고 다양한 작업에 대한 효과에 대한 증거를 제공한다.

사실 VGGNet은 14년에 발표되었으나 GoogLeNet이후 발전된 형태에 대한 내용이 모두 담긴 15년 논문을 기반으로 작성.

😶 초록 (Abstract)

- "Large-Scale image 인식에서의 정확도에 대한 ConvNet(Convolutional Network)의 깊이의 효과에 대해 조사한 결과에 대한 내용"
- 매우 작은 conv filter(3x3)를 사용하여 깊이를 늘린 architecture은 선행구성(prior-art configurations), 즉 VGG도입 이전의 network architecture를 매우 향상된 성능을 16~19의 깊이를 pushing함을 통해 이룩할 수 있다.

- 이를 통한 결과로 ILSVRC에서 Localisation와 Classification 각각의(respectively) 분야에서 1, 2위를 확보하였다.

1. 서론 (Introduction)

- ConvNet이 vision분야에서 유용해지게 되면서 여러 시도들(attempts)이 기존의 "Krizhevsky의 architecture(2012)" 즉, AlexNet를 향상되게 하였다.
예를 들어, ILSVRC-2013의 제출물(Zeiler.&.Fergus, 2013; Sermanet et al., 2014)은 첫번째 Conv layer에 작은 window크기 및 stride를 사용하였다.

- 이 논문에서는 ConvNet architecture의 다른 중요한 측면을 다룬다(address). - 특히 깊이에 대해(its depths)

- 이를 위해(To this end), architecture의 다른 parameters를 고정시키고(fix) Conv. layer를 추가하며 깊이를 점진적으로 늘리는데, 이때 모든 layer에서 Conv filter가 3x3의 작은 크기이기 때문에 가능(feasibly)하다!
이때, parameter를 fix한다는 점을 주의해서 읽어야 한다. parameter를 고정시키고 layer 수를 변경한다는 의미로 이를 통해 filter수나 pooling layer의 크기와 같은 것들은 변경하지 않는다는 것을 유추할 수 있다는 점을 유의하자!
즉, 3x3 크기의 매우 작은(very small) conv filter를 사용하면 매개변수의 수를 너무 많이 늘리지 않고도 네트워크의 깊이를 늘릴 수 있다는 것이 핵심이다!

- 결과적으로 ILSVRC에서 classification과 localisation task에서 예술의 경지의 정확도(state-of-the-art) 뿐만 아니라 다른 dataset에도 적용가능할 정도였는데, fine-tuning(미세조정)없이 linear SVM을 이용한 분류와 같은 간단한 pipline까지 적용가능하다.

- 이후에 소개할 Section은 다음과 같다.
• Section 2. 우리들의 ConvNet의 구성(configurations)에 대한 서술
• Section 3. image classification training과 evaluation에 대한 세부사항
• Section 4. ILSVRC의 classification 작업에 대한 구성
• Section 5. 이 논문의 결론
• Completeness.
     - Appendix A. ILSVRC-2014 object localisation system에 대한 설명 및 평가
     - Appendix B. 다른 datasets의 very deep feature의 generalisation에 대한 논의
     - Appendix C. 개정된(revision) major paper의 list

2. ConvNet Configurations

2.1 Architecture

- training에서 ConvNet의 input은 224x224 크기의 RGB image로 setting되었다.
- preprocessing에는 딱 하나의 방법을 사용했는데, 바로 subtracting mean RGB value이다.
 평균 RGB값을 빼는 것은 network 통과 전, input image에 적용되는 전처리 단계인데, training set의 평균 RGB값을 계산하고 input image의 각 pixel에서 빼는데, 이를 통해 data를 중앙(center)에 놓고 input image의 잠재적 편향(potential bias)을 제거하기 위함이다. mean-RGB 값은 training set의 평균 색상(average color)을 나타내며 이를 빼면 데이터가 더 "zero-centered"되어 네트워크 훈련에 도움이 되고 더 나은 성능으로 이어질 수 있다.

- 그 후 Conv.layer stack을 통과하는데, 이때 상하좌우, 중앙의 개념을 포착가능한 최소크기인 3x3의 filter를 이용한다.
이때, stride는 1 pixel로 고정된다.
- configurations의 또 다른 하나는 1x1의 Conv filter를 사용한 것이다.
이는 input channel의 linear transformation(선형 변환; 비선형성)으로 볼 수 있다.

- Conv. layer input의 spatial padding은 convolution 후 공간해상도(spatial resolution)가 유지되는 것으로 padding은 3x3 Conv.layer에 대해 1pixel인 것이다.
- Spatial pooling은 5개의 Max-pooling을 갖는데, 이는 Conv.layer의 일부를 갖는다.
즉, 모든 Conv.layer가 Max-pooling을 갖는 것은 아니며 Max-Pooling은 2x2의 pixel window, strides=2이다.

- Conv.layer이후 3개의 FC(Fully-Connected layer)가 뒤따른다.
1, 2번째 layer는 4096의 channels를 가지며 3번째 layer는 1000개의 ILSVRC classification을 위한 1000개의 channels를 가지며 soft-max layer이다.

- 모든 은닉층들(hidden-layers)은 rectification non-linearity(Krizhevsky et al., 2012 (=AlexNet)), 일명 ReLU를 갖춘 형태이다.

- Section 4.에서 알 수 있듯, 이 논문에서는 하나를 제외하고 network중 어느것도 LRN(Local Response Normalization)을 포함하지 않는다. 이런 정규화는 ILSRVC dataset의 성능을 향상시키지 않고 메모리소비 및 계산시간을 늘리기 때문이다.

2.2 Configurations

- 표 1에 하나의 열당 하나씩(one per column) 본 논문에서 평가한 ConvNet configurations가  요약되어 있다.
표에서는 A부터 E까지 각각의 nets의 이름을 언급하며 일반적인 design은 section 2.1에서 말한것과 동일하며 단지 depth만 다르다(11-weight layers ~ 19-weight layers).
 width는 다소 작은 64의 first-layer로 시작하며 각 Max-Pooling-layer를 거친 후에 512에 도달하기 전까지 2의 배수(factor of 2)만큼씩 증가한다.

- 표 2는 각 configuration의 parameters의 수에 관한 것으로 large depth에도 불구하고(In spite of) 우리의 net의 weight 수는 더 큰 Conv.layer width와 receptive field를 가진 더 얕은(shallow) net의 weight수보다 크지 않다.(Serman et al., 2014)

2.3 Discussion

- 우리의 ConvNet은 지금까지 사용된 ILSVRC-2012(Krizhevsky et al., 2012)와 ILSVRC-2013(Zeiler & Fergus, 2013; Sermanet et al., 2014)와는 꽤 다른데, 상대적으로 큰 크기의 receptive field(11x11 with stride 4 in Krizhevsky et al., 2012. ||. 7x7 with stride 2 in Zeiler & Fergus, 2013; Sermanet et al., 2014)를 사용하기보다는 오히려 3x3의 작은 크기의 receptive field with stride 1을 전체의 net에 사용하였다.

- 2개의 3x3 conv.layer의 stack이 효과적인 5x5의 receptive field를 갖는 것을 쉽게 볼 수 있는데, 이런 3개의 layers는 7x7의 effective receptive field를 갖는다.

그렇다면, 단일 7x7 layer대신 3x3 Conv.layer의 stack의 사용을 통해 무엇을 얻었는가?
① single layer대신 3개의 ReLU layer를 통합(incorporate)하여 결정함수(decision function)을 차별화(discriminative)한다.
Decision function은 input features를 가져와 예측된 출력이나 결정을 생성하는 함수로 보통 supervised learning에서 사용되며 train data에서 학습된 mapping을 기반으로 새로운 input에 대한 예측을 만드는데 사용된다.

② parameter의 수를 줄인다.
- 3개의 3x3 conv stack layer가 C개의 channel이 있다고 가정
- stack은 3(3^2 C^2) = 27C^2개의 weights에 의해 매개변수화(parametrised)된다.
- 동시에 single 7x7 conv. layer는 7^2 C^2 = 49C^2개의 매개변수를 갖는다.
- 즉, 81%나 더 많은 weight를 가지는 것을 알 수 있다.
∴ 이는 7x7 conv.filters에 정규화(regularization)를 부과하는 것으로 볼 수 있으며 3x3 filter를 통해 강제로 분해(forcing, decomposition)된다. (그 사이에 비선형성이 주입된다; non-linearity is injected)


- 표 1에서의 Configuration C(VGG-16)의 1x1 conv.layer의 통합(incorporation)은 conv.layer의 receptive field에 영향을 미치지 않고 ReLU함수에 의해 추가적인 비선형성이 도입되기에 decision function의 비선형성(non-linearity)를 증가시키는 방법이다.

- depth를 늘림으로 더 나은 결과를 얻는 것을 알 수 있었는데, 우리의 연구와는 독립적으로 연구된 GoogLeNet 또한 매우 깊은 ConvNet(22-weight layers)와 작은 conv.filters(3x3, 1x1, 5x5)에 기반을 뒀다는 점에서 비슷하다는 것을 알 수 있다.

3.Classification Framework

이전 section에서 network configurations의 detail을 알아봤다면, 이번 section에서는 classification ConvNet training .&. evaluation의 detail에 대해 알아볼 것이다.

3.1 Training

- ConvNet training 과정은 전반적으로 AlexNet을 따라간다. (이후 설명하는 multi-scale traininig image에서 input값을 sampling하는 것은 제외된다.)
즉, training은 momentum을 가진 역전파 기반의  mini-batch GD(Gradient Descent)를 사용해 multinomial logistic regression 목표를 최적화함으로써 수행된다.(LeCun et al., 1989)
이때, batch size는 256, momentum은 0.9이다.

- training은 다음과 같은 사항들로 규제화(regularized)되었다.
L2 규제화(5*10^-4)
1, 2 FC.layer에 Dropout(0.5)

- learning-rate는 다음과 같이 조정되었다.
처음 초기화 당시에는 10^-2로 조정되었으나 validation set accuracy가 향상이 되지 않을 때마다 10의 배수만큼 감소하도록 하였다.
그렇게 총 3번의 학습률 감소가 발생하였으며 370K의 iterations(74 epochs) 이후 완전히 멈추었다.
1, 2 FC.layer에 Dropout(0.5)

- AlexNet과 비교해 매우 많은 parameter와 깊은 depth에도  불구하고 우리는 nets가 
(a) 더 깊은 depth와 더 작은 conv.filter size에 의해 부과되는(impose) 암시적 정규화(implicit regularization)와
(b) 특정 layer의 사전 초기화(pre-initialization)로 인해 수렴(coverage)하는데 더 작은 epoch이 필요했다고 추측(conjecture)하였다.


- network의 weight는 depp nets의 gradient instability로 인해 학습을 지연(stall)시킬 수 있어서 중요하다.
- 이 문제를 피하기 위해 random initialization으로 훈련할 수 있을 정도로 얕은 VGG-11(표 1-A) training부터 시작하였다.
- 그 후 더 깊은 구조로 훈련할 때, 처음 4개의 Conv.layer와 마지막 3개의 FC.layer를 net A의 layer로 초기화 하였다. (중간 layers는 무작위로 초기화)
- 사전 초기화된 layer에 대한 학습률을 줄이지 않았기에 학습중에 learning 변경가능하였다.
- random initialization에 해당하는 경우, zero-mean과 variance가 10^-2인 정규분포에서 weight를 표본으로 추출하였으며 - bias는 0으로 초기화되었다.

- 고정된 크기의 224x224 ConvNet input image를 얻기 위해 resized된 train imaged에서 random하게 crop을 하였다.
이때, SGD iteration이 한번 일어날 때마다 image 하나당 한번의 crop을 진행
- 더 추가적인 training set에 대한 Data Augmentation은 random하게 horizontal flip, RGB shift를 진행하였다.(AlexNet과 동일)
아래에서 training image rescaling에 대해 설명

Training image size
S를 ConvNet input이 잘리는 등방성으로 scale된(isotropically-rescaled) training image의 가장 작은 면(side)이라 하자.
(이때, S를 training scale이라도 한다.)
crop크기는 224x224로 고정이지만 S는 224이상의 값을 취할 수도 있으며 S=224의 경우, crop은 training image의 가장 작은 면에 걸쳐 전체 image의 statistics(통계)를 capture한다.
S에 대해 >> 224의 경우 crop은 작은 물체나 물체 부분을 포함하는 image의 작은 부분(part)에 해당한다.

우리는 training scale S를 설정하기 위해 2가지의 접근법을 고려한다.
① single-scale training에 해당하는 S를 수정하는 것(sampling된 결과물내의 image 내용은 여전히 multi-scale image 통계를 나타낸다)
- 이 실험에서 우리는 S=256와 S=384의 2가지 고정된 척도로 training된 model을 평가(evaluate)한다.
- ConvNet configuration을 고려하면,
   i) 먼저 S=256을 사용해 network의 training을 진행
   ii) S=384 network의 training 속도를 높이기 위해 S=256으로 pre-trained된 weight로 초기화
   iii) 10^-3의 더 작은 초기 학습률의 사용

② Multi-scale training으로 각 train-image는 특정범위[S_min, S_max]에서 무작위로 S를 sampling하여 개별적으로 rescale한다. (이 실험에서는 S_min = 256 .&. S_max = 512를 사용).
객체의 image가 다른 크기를 가질 수 있기(can be of) 때문에 training을 하면서 이를 고려하는 것이 좋다.
이는 single-model이 광범위한 scale에 걸쳐 물체를 인식하도록 training하도록 스케일을 조금씩 움직이는 것(scale-jittering)에 의해 training augmentation로도 볼 수 있다.
속도상의 이유로 S=384로 고정되어 pre-trained된 동일한 구조(same-configuration)의 single-scale model의 모든 layer를 미세조정(fine-tuning)하여 multi-scale model을 훈련시켰다.

3.2 Testing

- test시 훈련된 ConvNet과 input image가 주어지면, 다음과 같이 분류된다.
① 사전 정의된 가장 작은 이미지 면을 Q라 하면, Q로 등방적 스케일링(isotropically rescaled)이 된다.
이때, Q가 반드시 training scale S와 같지는 않다는 점을 알아야 한다.
section 4에서 알 수 있듯 각 S에 대해 몇가지 Q값을 사용하면 성능이 향상된다.

② network는 (Serman et al., 2014)와 유사한 방식으로 rescaled된 test image 위에 촘촘히(densely) 적용된다.
즉, FC.layer은 먼저 Conv.layer(첫 번째 FC는 7 × 7 Conv, 마지막 두 FC layer는 1 × 1 Conv)로 변환된다.

③ 결과적으로 fully-convolutional network가 전체 image(uncropped)에 적용된다.
그 결과, channel 수가 class수와 동일한 class 점수 map, input size에 따라 가변 공간 해상도(variable spatial resolution)이 생성된다.

④ 최종적으로 image에 대한 class점수의 고정크기벡터(fixed-size vector)를 얻기 위해 class 점수 map은 공간적으로 평균화(spatially averaged)된다. (sum-pooled)
또한, horizontal flip을 통해 test set을 증가시키는데, 원본과 flip된 image에 뒤이어 나오는 softmax-class는 image에 대한 최종값을 얻기 위해 averaged된다.


- Fully-Convolutional network가 전체 image에 적용되기에 test에서 여러 결과를 sampling할 필요가 없으며 각 결과에 대한 network의 재계산이 필요하기에 효율성이 떨어지게 된다. 동시에 Szegedy 등(2014)이 수행한 것처럼 대규모 결과셋을 사용하면 Fully-Convolutional network에 비해 input image를 더 미세하게 샘플링할 수 있기 때문에 정확도가 향상될 수 있다.
- 또한 multi-crop evaluation은 convolution boundary가 다르기에 dense evaluation을 보완한다.
ConvNet을 crop에 적용할 때, Convolution feature map은 zero-padding된다.
하지만 dense evaluation의 경우, 동일한 crop에 대한 padding은 image의 인접부분(neighbouring part)에서 자연스레 발생하며 이는 전체 network receptive field를 상당히 증가시키기에 더 많은 context가 captured된다.
- 실제로 여러 결과의 계산시간증가가 잠재적 정확도 향상을 정당화하지는 않는다고 믿는다.
다만 우리는 scale당 50개의 crops(5x5의 regular grid와 2 flips)을 사용해 network를 평가하는데, 이는 Szegedy(2014)등이 사용한 4개 이상의 scale의 144개의 결과물과 비교할 수 있다.

3.3 Implementation Details

- 우리의 구현은 공개적 소스인 C++ Caffe toolbox(Jia, 2013)에서 파생되었으나 많은 중요한 수정사항을 포함하기에 single system에 설치된 여러 GPU에서 train 및 평가를 수행할 수 있을 뿐만 아니라 여러 규모의 crop되지 않은 전체 크기 image에 대한 train과 평가를 수행할 수 있다. (위에서 설명했듯.)
- Multi-GPU training은 data parallelism(데이터 병렬화)를 활용하며 train image의 각 batch로 분할하여 각 GPU에 병렬로 처리함으로 수행된다.
- GPU batch gradient가 계산된 이후 전체 batch의 gradient를 얻기 위해 평균화(averaged)된다.
- Gradient computation은 GPU에서 동기화(synchronous)되기에 결과는 single GPU에서 훈련될 때와 "정확하게 동일"하다.

- network의 다른 layer의 model과 데이터 병렬화를 사용하는 ConvNet의 훈련속도를 높이는 정교한 방법이 2014년, Krizhevsky에 의해 제안되었다.
- 하지만 우리는 개념적으로 훨씬 간단한 scheme(방식)이 single GPU를 사용하는 것에 비해 기성품인(off-the-shelf) 4-GPU system에서 이미 3.75배의 속도를 제공하는 것을 알았다.

- 4개의 NVIDIA Titan Black GPU가 장착된 시스템에서 single net을 training하는 데는 architecture에 따라 2-3주가 소요되었다.

🤔 여기서 잠깐! Scale-Jittering이란?

Jittering: 조금씩 움직임
• image classification을 위한 CNN의 성능을 개선하는데 도움이 되도록 VGGNet 논문에서 도입된 data augmentation 기술
  - scale jittering의 기본 아이디어는 훈련 중 input image scale을 무작위로 재조정하여 네트워크가 다른 스케일에서 객체를 인식하는 방법을 학습하도록 하는 것.

  - 이는 특정 범위(예: 256~512 픽셀) 내에서 input image size를 rescaled한 다음 무작위로 다시 원래 크기로 잘라서 얻게 되는데, 예를 들어 훈련 중에 지정된 입력 이미지의 크기를 320 x 320 픽셀, 384 x 384 픽셀 또는 448 x 448 픽셀로 임의로 조정한 다음 원래 크기인 224 x 224 픽셀로 임의로 자를 수 있다.

  - 이 기술을 적용함으로써 신경망은 다양한 크기와 방향에서 물체를 인식하는 법을 배우게 되어 다양한 이미지에서 성능을 향상시키는 데 도움이 될 수 있다.

  - scale jittering은 특히 광범위한 스케일과 종횡비가 있는 이미지를 처리할 때 CNN의 견고성(robustness)과 일반화 능력을 향상시키는 간단하고 효과적인 방법이다.

- 이것은 많은 computer vision에서 data augmentation의 표준이 되었으며 random crop, vertical flipping 및 color jittering과 같은 다른 기술과 함께 자주 사용된다.

4. Classification Experiments

Dataset
이번 section에서는 ILSVRC 2012-2014 과제에 사용된 ILSVRC-2012 dataset에서 설명된 ConvNet architecture에 의해 달성된 image classification 결과를 제시한다.
data set은 1000개의 image class의 image로 train(130만개), validation(5만개), test(10만개)로 3개의 set으로 나눈다.

분류성능(classification performace)은 top-1 오류와 top-5 오류의 두 가지 측정을 사용하여 평가한다.
top-1 error: mutli-class classification error (잘못 분류된 image의 비율)
top-5 error: ILSVRC에 사용되는 주요 평가 기준 (ground-truth category가 top-5 predicted category를 벗어나는지)

대부분의 실험(majority of experiments)에서 validation set를 test set으로 사용하였으며 test sest에도 특정 실험을 수행하여 ILSCRC-2014대회의 "VGG"팀 entry로 공식 ILSVRC 서버에 제출하였다.(Russakovsky et al., 2014)

4.1 Single Scale Evaluation

- Sect. 2.2에서 설명한 것처럼 layer configuration에 single scale을 적용된 각각의 ConvNet model에 대해 성능(performance)를 측정(evaluate)했으며 test size는 다음과 같이 적용하였다.
test image size는 고정된 S의 경우, Q = S이고  jittering S ∈ [S_min, S_max]의 경우 Q = 0.5(S_min + S_max)로 설정하였다.
이것의 결과는 표 3에 나와있다. (The results of are shown in Table 3)

① 먼저, 어떠한 정규화 layers도 없는 경우, local response normalization (A-LRN network)는 model A에 아무런 증진을 하지 못한다는 것을 알았다.
∴ 따라서 더 깊은 구조들인 B-E는 normalization을 사용하지 않았다!

② 둘째, ConvNet의 깊이를 증가시킬수록 classification error가 감소하는 것을 관찰할 수 있었다: VGG-11에서 19까지(A-E)
주목할 점은 동일한 깊이에도 불구하고 configuration C(1x1 conv.layers가 3개)가 configuration D(3x3 conv.layers)보다 훨씬 나쁜 성능을 보여주었다는 점인데, 이는 아래를 시사한다는 점을 알 수 있다.
추가적인 non-linearity는 도움이 되는데(C > B), 더 중요한 점은 사소하지 않은 receptive field(neural net의 복잡성과 표현력을 늘린다)와 함께 conv.filters를 사용하는 것으로 공간적인 내용을 포착한다는 것이다.
우리의 architecture의 error rate는 깊이가 19층이 되었을 때 포화되었지만, 더 깊은 model은 더 큰 datasets에 효과적일 지도 모르겠다.
 또한, net B에서 파생된 network(3x3conv.layer를 shallow filter인 5x5 conv.layer로 각각 모두 바꾼 network)와 B를 비교해 보았다. top-1 error rate는(center crop에서) B의 오차보다 7% 더 높게 측정되었다.
이를 토대로 작은 filter가 있는 net이 더 큰 filter가 있는 shallow net보다 성능이 우수함을 확인할 수 있었다.

③ 마지막으로, training때의 scale jittering(S ∈ [256; 512])을 하는 것은 single scale이 test time에 사용됨에도 불구하고 고정된 최소 측면(fixed smallest side)인 S = 256 or S = 384의 image로 training하는 것 보다 더욱더 좋은 결과를 도출한다.
이는 scale jittering에 의한 training set augmentation이 multi-scale image의 통계를 포착하는데 실제로 도움이 된다는 것을 보여준다.

4.2 Multi-Scale Evaluation

- single scale의 ConvNet model을 측정할 때, 이제 우리는 test시의 scale jittering의 효과를 평가할 수 있다. 이는 Q의 다른값에 해당하는 test image의 여러 rescaled된 버전에서 모델을 실행한 후 결과class의 뒷부분을 평균화(averaging)하는 것으로 구성된다.
- training과 testing scale의 큰 차이(discrepancy)가 성능을 떨어뜨리는 것을 초래한다는 점을 고려하면, 고정된 S로 훈련된 model은 train image에 가까운 3개의 test image size에 걸쳐 평가되었다: Q = {S − 32, S, S + 32}.
동시에, training시 scale jittering을 하는 것은 network가 test시 더 넓은 범위의 scales를 적용할 수 있다는 것을 허용하는데, 따라서 변수 S ∈ [Smin; Smax]로 훈련된 model은 Q = {Smin, 0.5(Smin + Smax), Smax}의 더 넓은 범위에서 측정된다.
- 그 결과로 표 4에서 알 수 있듯, test시의 scale jittering은 (표 3에서 single scale을 적용한 동일한 model의 결과와 비교해 보았을 때) 좋은 성능을 내는 것을 알 수 있다. 
전과 같이 가장 깊은 configuration인 D와 E가 가장 성능이 최상이었으며 scale jittering은 고정된 최소면(smallest side)인 S보다 더욱 잘 training되는 것을 알 수 있다.
- validation set에서 top-1/top-5 error의 최고의 single-network성능은 (표 4에서 강조처리된)24.8%, 7.5%이다.
test set에서 configuration E는 7.3%의 top-5 error를 달성하였다.

4.3 Multi-Crop Evaluation

- 표 5에서는 ConvNet dense의 결과와 multi-crop의 결과를 비교할 것이다.(Sect. 3.2에 세부사항을 볼 수 있다.)
- 또한 두 결과(evaluation)의 technique의 보완성을 softmax한 결과의 평균을 통해 평가(assess)할 것이다.
- 보이다싶이 multiple crops가 dense보다 쪼오오금 더 나으며 두 접근들은 실제로 보완이 필요했는데, 둘의 조합이 그 둘 각각을 능가하기 때문이었다.
위에서 적었듯, 이는 convolution boundary 조건의 다른 처리(treatment) 때문이라고 가설을 세웠다.

4.4 ConvNet Fusion

- 지금까지 우리는 각각의 ConvNet model들의 성능을 측정(evaluate)했다.
이런 일련의 실험에서 우리는 몇몇의 model들의 결과에 대해 softmax class의 후위를 평균화하면서(averaging) 결합했는데, 이는 models의 보완성에 기인하는 성능을 향상시킨다.

- 결과는 표 6에서 볼 수 있다.
ILSVRC 제출때까지 우린 단지 multi-scale model인 D(모든 층을 하기보단 FC에만 fine-tuning을 진행한 model)뿐만 아니라  single-scale network만 train하였는데, 7개의 network의 앙상블에대한 결과로 7.3%의 ILSVRC test error를 얻었다.
제출 이후, 우린 단지 multi-scale model에서 최고성능을 기록한 2개의 configuration인 D와 E를 앙상블(emsemble)하였는데, 이는 test error를 7.0%(using dense evaluation)와 6.8%(using combined dense .&. multi-crop evaluation)까지 줄여주었다. 
- 우리가 도출한 최고의 성능은 7.1% error이다. (표 5, model E)

4.5 Comparison with the State of the Art

- 최종적으로, 우리의 결과를 표 7에서 최첨단 결과와 비교한다. ILSVRC-2014 challenge의 classification과제에서 우리 "VGG"팀은 7개의 model로 구성된 앙상블(emsemble)을 이용해 7.3%의 test error로 2위를 차지했으며 제출 이후 두 model의 앙상블을 사용해 error를 6.8%까지 낮췄다.

- 표 7에서 알 수 있듯, 우리의 "very deep ConvNets"은 이전 세대의 model과 비교해서 현저하게 뛰어남(significantly outperform)을 알 수 있다.
우리의 결과는 또한 classification 과제에 관하여 우승자인 GoogLeNet(6.7% error)에 견줄만하며 ILSVRC-2013의 우승제출물인 Clarifai(외부training data로 11.2% 달성)보다 상당히 크게 능가하였다.

- 이 점은 우리의 최상의 결과가 단지 2개의 model을 결합하여 이룩한 점(다른 제출물에 비해 매우 낮은 점)을 고려하면 괄목할만 하다.
- single-net 성능의 측면에서(in terms of), 우리가 이룩한 구조의 최상의 결과는 7.0%test error로 0.9%의 차이로 single GoogLeNet을 압도하는데, 이는 괄목할만한게 1989년의 전통적인 ConvNet 구조와 크게 다르지 않지만 상당히 깊이를 증가시켰기 때문이다.

5. Conclusion

- 이 작업에서 우린 very deep ConvNet(19 weight layer까지)를 large-scale image classification에 대해 평가했다(evaluated).
- 이는 classification accuracy에 유익한(beneficial) depth를 통해 증명할 수 있으며 conventional ConvNet 구조를 사용함으로 성취(achived)할 수 있다.

- Appendix에서는 model이 다른 광범위한 dataset에서 잘 일반화가 된 것에 대한 글을 적었으며 우리의 결과는 또다시(yet again) depth의 중요성을 확인할 수 있었다.



Acknowledgements (논문 사사)
- This work was supported by ERC grant VisRec no. 228180. We gratefully acknowledge the support of NVIDIA Corporation with the donation of the GPUs used for this research.

😶 부록 (Appendix)

A. Localisation

A.1 Localisation ConvNet

• Training
  -
• Testing
  -

A.2 Localisation Experiments

• Settings comparison
  -
• Localisation eror for different modifications
  -

B. Generalisation of Very Deep Features

• 
  -

  -

C. Paper Revisions

• 
  -

  -

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

"Very Deep Convolutional Networks for Large-Scale Image Recognition"
Karen Simonyan과 Andrew Zisserman이 2015년에 발표한 연구 논문으로 이 논문은 2014년 ILSVRC(ImageNet Large Scale Visual Recognition Challenge)에서 최첨단 성능을 달성한 VGGNet이라는 심층 합성곱 신경망 아키텍처를 제안한다.

[핵심 개념]

1. Deep Convolutional Neural Networks
이 논문은 Convolution 및 Pooling 층의 여러 layer로 구성된 Deep CNN Architecture를 제안했으며 그 뒤에 여러 개의 Fully-Connected layer가 있다.

2. Small filter size
이 논문은 이전 layer에서 더 큰 filter의 사용 대신 전체 신경망에 걸쳐 3x3 conv.filter를 사용할 것을 제안했는데,
이것은 더 적은 매개변수와 더 효율적인 모델로 이어진다.

3. Stacking Layers
이 논문은 더 깊은 신경망의 형성을 위해 전체의 신경망에 걸쳐 3x3 filter가 있는 여러 개의 conv.layer를 쌓을 것을 제안했습니다.
이렇게 하면 parameter 수를 너무 많이 늘리지 않고도 성능이 향상된다.

4. Max Pooling
이 논문은 2x2 filter와 stride=2인 MaxPooling Layer를 사용해 feature map의 공간 차원(spatial dimension)을 줄이고 변환 불변성(translation invariance)을 제공했다.

5. State-of-the-Art Performance
이 논문은 ILSVRC 2014 분류 작업에서 최신 성능을 달성하여 이전 방법보다 훨씬 뛰어난 성능을 보여준다.

전반적으로 이 논문은 작은 conv.filter의 사용 및 multi-layer stack 같은 딥 러닝의 몇 가지 중요한 개념을 소개하고 까다로운 컴퓨터 비전 작업에서 최첨단 성능을 달성하는 데 있어 그 효과를 입증했다.

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

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


def vgg_block(inputs, filters, num_convs):
    x = Conv2D(filters, (3,3), padding='same', activation='relu')(inputs)
    for i in range(num_convs-1):
        x = Conv2D(filters, (3,3), padding='same', activation='relu')(x)
    x = MaxPool2D((2,2), strides=2)(x)
    return x



def vgg_A(input_shape, num_classes):
    inputs = tf.keras.layers.Input(shape=input_shape)
    
    x = vgg_block(inputs, 64, 1)
    x = vgg_block(x, 128, 1)
    x = vgg_block(x, 256, 2)
    x = vgg_block(x, 512, 2)
    x = vgg_block(x, 512, 2)
    
    x = Flatten()(x)
    x = Dense(4096, activation='relu')(x)
    x = Dropout(0.5)(x)
    x = Dense(4096, activation='relu')(x)
    x = Dropout(0.5)(x)
    outputs = Dense(num_classes, activation='softmax')(x)
    
    model = tf.keras.models.Model(inputs=inputs, outputs=outputs)
    return model



def vgg_A_LRN(input_shape, num_classes):
    inputs = tf.keras.layers.Input(shape=input_shape)
    
    x = vgg_block(inputs, 64, 1)
    x = vgg_block(x, 128, 1)
    x = vgg_block(x, 256, 2)
    x = vgg_block(x, 512, 2)
    x = vgg_block(x, 512, 2)
    
    x = Flatten()(x)
    x = Dense(4096, activation='relu')(x)
    x = Dropout(0.5)(x)
    x = Dense(4096, activation='relu')(x)
    x = Dropout(0.5)(x)
    outputs = Dense(units=num_classes, activation='softmax')(x)
    
    model = tf.keras.models.Model(inputs=inputs, outputs=outputs)
    return model



def vgg_B(input_shape, num_classes):
    inputs = tf.keras.layers.Input(shape=input_shape)
    
    x = vgg_block(inputs, 64, 2)
    x = vgg_block(x, 128, 2)
    x = vgg_block(x, 256, 2)
    x = vgg_block(x, 512, 2)
    x = vgg_block(x, 512, 2)
    
    x = Flatten()(x)
    x = Dense(4096, activation='relu')(x)
    x = Dropout(0.5)(x)
    x = Dense(4096, activation='relu')(x)
    x = Dropout(0.5)(x)
    outputs = Dense(units=num_classes, activation='softmax')(x)
    
    model = tf.keras.models.Model(inputs=inputs, outputs=outputs)
    return model



def vgg_C(input_shape, num_classes):
    inputs = tf.keras.layers.Input(shape=input_shape)
    
    x = vgg_block(inputs, 64, 2)
    x = vgg_block(x, 128, 2)
    x = vgg_block(x, 256, 3)
    x = vgg_block(x, 512, 3)
    x = vgg_block(x, 512, 3)
    
    x = Flatten()(x)
    x = Dense(4096, activation='relu')(x)
    x = Dropout(0.5)(x)
    x = Dense(4096, activation='relu')(x)
    x = Dropout(0.5)(x)
    outputs = Dense(units=num_classes, activation='softmax')(x)
    
    model = tf.keras.models.Model(inputs=inputs, outputs=outputs)
    return model




def vgg_D(input_shape, num_classes):
    inputs = tf.keras.layers.Input(shape=input_shape)
    
    x = vgg_block(inputs, 64, 2)
    x = vgg_block(x, 128, 2)
    x = vgg_block(x, 256, 3)
    x = vgg_block(x, 512, 3)
    x = vgg_block(x, 512, 3)
    
    x = Flatten()(x)
    x = Dense(4096, activation='relu')(x)
    x = Dropout(0.5)(x)
    x = Dense(4096, activation='relu')(x)
    x = Dropout(0.5)(x)
    outputs = Dense(units=num_classes, activation='softmax')(x)
    
    model = tf.keras.models.Model(inputs=inputs, outputs=outputs)
    return model



def vgg_E(input_shape, num_classes):
    inputs = tf.keras.layers.Input(shape=input_shape)
    
    x = vgg_block(inputs, 64, 2)
    x = vgg_block(x, 128, 2)
    x = vgg_block(x, 256, 4)
    x = vgg_block(x, 512, 4)
    x = vgg_block(x, 512, 4)
    
    x = Flatten()(x)
    x = Dense(4096, activation='relu')(x)
    x = Dropout(0.5)(x)
    x = Dense(4096, activation='relu')(x)
    x = Dropout(0.5)(x)
    outputs = Dense(units=num_classes, activation='softmax')(x)
    
    model = tf.keras.models.Model(inputs=inputs, outputs=outputs)
    return model

# VGG-19의 예시
model = vgg_E(input_shape=(224,224,3), num_classes=1000)
model.summary()

Model: "model"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 input_10 (InputLayer)       [(None, 224, 224, 3)]     0         
                                                                 
 conv2d_260 (Conv2D)         (None, 224, 224, 64)      1792      
                                                                 
 conv2d_261 (Conv2D)         (None, 224, 224, 64)      36928     
                                                                 
 max_pooling2d_51 (MaxPoolin  (None, 112, 112, 64)     0         
 g2D)                                                            
                                                                 
 conv2d_262 (Conv2D)         (None, 112, 112, 128)     73856     
                                                                 
 conv2d_263 (Conv2D)         (None, 112, 112, 128)     147584    
                                                                 
 max_pooling2d_52 (MaxPoolin  (None, 56, 56, 128)      0         
 g2D)                                                            
                                                                 
 conv2d_264 (Conv2D)         (None, 56, 56, 256)       295168    
                                                                 
 conv2d_265 (Conv2D)         (None, 56, 56, 256)       590080    
                                                                 
 conv2d_266 (Conv2D)         (None, 56, 56, 256)       590080    
                                                                 
 conv2d_267 (Conv2D)         (None, 56, 56, 256)       590080    
                                                                 
 max_pooling2d_53 (MaxPoolin  (None, 28, 28, 256)      0         
 g2D)                                                            
                                                                 
 conv2d_268 (Conv2D)         (None, 28, 28, 512)       1180160   
                                                                 
 conv2d_269 (Conv2D)         (None, 28, 28, 512)       2359808   
                                                                 
 conv2d_270 (Conv2D)         (None, 28, 28, 512)       2359808   
                                                                 
 conv2d_271 (Conv2D)         (None, 28, 28, 512)       2359808   
                                                                 
 max_pooling2d_54 (MaxPoolin  (None, 14, 14, 512)      0         
 g2D)                                                            
                                                                 
 conv2d_272 (Conv2D)         (None, 14, 14, 512)       2359808   
                                                                 
 conv2d_273 (Conv2D)         (None, 14, 14, 512)       2359808   
                                                                 
 conv2d_274 (Conv2D)         (None, 14, 14, 512)       2359808   
                                                                 
 conv2d_275 (Conv2D)         (None, 14, 14, 512)       2359808   
                                                                 
 max_pooling2d_55 (MaxPoolin  (None, 7, 7, 512)        0         
 g2D)                                                            
                                                                 
 flatten_7 (Flatten)         (None, 25088)             0         
                                                                 
 dense_19 (Dense)            (None, 4096)              102764544 
                                                                 
 dropout_12 (Dropout)        (None, 4096)              0         
                                                                 
 dense_20 (Dense)            (None, 4096)              16781312  
                                                                 
 dropout_13 (Dropout)        (None, 4096)              0         
                                                                 
 dense_21 (Dense)            (None, 10)                40970     
                                                                 
=================================================================
Total params: 139,611,210
Trainable params: 139,611,210
Non-trainable params: 0
_________________________________________________________________

😶 초록 (Abstract)

- ImageNet에서 120만개의 고해상도 image를 대상으로 1000개의 클래스를 분류하는 문제에 대해 좋은 결과를 내었음

- 6000만개의 parameter와 650,000여개의 뉴런 [5개의 CONV 층(maxpool), 3개의 FullyConnected 층(마지막은 1000개 클래스를 구분하는 softmax층)]으로 구성
- training을 빨리 하기 위해 포화되지 않은(non-saturating) 뉴런들과 효과적인 GPU를 사용
- overfitting을 줄이기(reduce)위해 dropout(매우 효과적으로 증명된 regularized method)을 사용

- ILSVRC-2012 대회에서 2등인 26.2%에 비해 15.3%의 error rate를 성취하였음
(Imagenet Large-scale Visual Recognition Challenge)

1. 서론 (Introduction)

- 현재 사물인식에서 기계학습(machine learning)방식의 사용은 필수적이다.
- 이를 위해 다음과 같은 방법으로 향상을 시키는데, 더 많은 데이터셋, 강력한 모델 및 더 좋은 과적합을 막는 기술등이 있다.
과거, MNIST와 같은 데이터들은 적은 양으로도 가능하였지만 현실에서는 상당히 다양하며(considerable variablility) 따라서 더 많은 training set을 필요로 하는 것은 필수불가결한 사항이 되어버렸다.

- 수많은 사물을 구분하려면 많은 학습능력을 지녀야 한다.
하지만, 사물인식의 거대한 복잡도의 문제는 ImageNet같은 거대한 dataset에서 명시될 수 없다는 점이다.

- 학습능력은 depth와 breadth를 다양화하면서 조정할 수 있는데, feedforward neural network와 비교했을 때, CNN은 더 적은 연결과 parameter를 갖기에 train하기 쉽고 이론적으로 최상의 효과를 약간의 단점만으로 낼 수 있다.

2. The Dataset

- ImageNet을 이용했는데, ImageNet은 22,000개의 카테고리, 1500만개의 라벨링된 고해상도의 사진으로 이루어져 있다.
- 따라서 image를 down-sample하여 해상도를 256X256으로 맞춰 image를 rescale하였다.
- raw RGB의 pixel로 train을 진행하였다.

3. The Architecture

3.1 ReLU Nonlinearity

- Deep CNN에서 tanh unit의 사용보다 ReLU의 사용이 훨씬 빠르다는 것을 알 수 있다.
이런 빠른 학습은 큰 데이터셋을 갖는 large한 모델에 매우 훌륭한 영향을 준다.

위 그림에 대한 설명이다.
- 실선: 4개의 Conv층 (with relu), 6배 더 빠르다.
- 점선: 4개의 Conv층 (with tanh)
- ReLu는 지속적인 학습의 진행으로 saturating neuron보다 더 빠르게 학습한다.
우리는 여기서 미리 포화된(large neural net)뉴런 모델을 굳이 경험할 필요가 없음을 알 수 있다.

3.2 Training on Multiple GPUs

- single GTX 580 GPU 코어는 메모리가 3GB이기에 훈련가능한 신경망의 최대크기가 제한된다.
- 따라서 2개의 GPU에 신경망을 흩어뜨리는 GPU병렬화(parallelization scheme)를 이용한다.
- 이때, 2개의 GPU net이 1개의 GPU net보다 훈련에 더 적은 시간이 걸리고 오류율도 1.2~1.7%정도 감소시켰다.

3.3 Local Response Normalization

- ReLU는 포화(saturating)방지를 위한 입력 정규화를 필요로 하지 않는 바람직한 특성을 갖는다.
- ReLU는 local 정규화 일반화에 도움이 된다.

- 위의 식은 다음과 같이 해석된다.

 
kernel i의 위치 (x,y)를 적용해 계산된 뉴런의 activity이다.
여기에 ReLU의 비선형성을 적용한다.
 
이때, 합은 동일한 공간위치에서 n개의 '인접한(adjecent)' kernel map에 걸쳐 실행된다. (N은 layer의 총 kernel수)
kernel map의 순서는 training이 시작하기 전에 임의로(arbitrary) 결정된다.
이런 반응정규화(response normalization)의 종류는 영감을 받은(inspired) 측면억제(lateral inhibition)형태를 구현,
이를 통한 다른 커널의 사용으로 계산된 뉴런 출력간의 large activity에 대한 경쟁(competition)을 생성한다.

상수 k, n, α, β는 validation set을 사용하여 값이 결정되는 hyper-parameter로 각각 k = 2, n = 5, α = 10-4, β = 0.75를 사용하며 특정 layer에서 ReLU의 비선형성을 적용한 후 이 정규화를 적용했다(3.5 참조).

Jarrett의 local contrast normalization과 비슷하지만 mean activity를 빼지(subtract)않았기에
우리의 이 정규화를 'brightness normalization'이라 더 장확하게 부를 것이다. 

3.4 Overlapping Pooling

CNN에서의 pooling layer는 동일한 kernel map에서 '인접한(adjacent)' 뉴런 그룹의 output을 summarize한다.
보편적으로 adjacent pooling으로 요약되면 unit들이 겹치지 않는다.
즉, pooling layer는 픽셀들 사이에 s만큼의 간격을 둔 pooling unit들의 grid로 구성되며, 각각은 pooling unit의 위치를 중심으로 한 크기(zxz)의 neighbor를 요약한다.
만약 위에서의 s를 s = z로 설정하면 CNN에서 일반적으로 사용되는 보편적인 local pooling을 얻을 수 있으며, s < z를 설정하면 overlapping pooling을 얻을 수 있다.

이때문에 전반적인 신경망에서 s=2나 s=3으로 사용하는 것이다.
또한 일반적인 training에서는 overlapping pooling이 있는 모델이 모델을 과적합하기가 약간 더 어렵다는 것을 알 수 있다

3.5 Overall Architecture

총 8개의 weight를 갖는 layer로 구성되어 있다.
- 5개의 CONV (convolution layer)
- 3개의 FC (Fully-connected layer) + 마지막은 1000개의 클래스를 구분하는 softmax층

이 모델은 다항식 logistic regression 분석목표를 최대화 하는데, 이는 예측분포(prediction distribution)하에서 올바른 label의 log확률(log-probability)의 training cases에 대한 평균(average)을 최대화하는 것과 같다.

2, 4, 5번째의 CONV의 kernel은 동일한 GPU에 있는 이전 layer의 kernel map에만 연결된다. (아래그림 참조)
3번째 CONV는 2번째 CONV의 모든 kernel map들과 연결되며 완전히 연결된 층의 뉴런은 이전 층의 모든뉴런들과 연결된다.

response-normalization층들은 1, 2번째 CONV를 따르며 3.4절에 기술된 종류의 MaxPooling은 response-normalization layer와 5번째 CONV layer를 모두 따른다.

ReLU의 비선형성은 모든 CONV와 FC의 출력에 적용되며 첫 번째 CONV은 11×11×3의 96개의 kernel을 가지며
224×224×3(150,528 차원)의 input image를  stride=4로 filtering을 진행한다.
(신경망의 뉴런수는 다음과 같다. 150,528-253,440–186,624–64,896–64,896–43,264–4096–1000)

2번째 CONV는 첫번째 CONV의 출력을 입력으로 받아 5×5×48의 256개의 kernel로 filtering을 진행하며
3번째 CONV는 3×3×256의 384개의 kernel을 두번째 CONV output과 연결하고
4번째 CONV는 3×3×192의 384개의 kernel로,
5번째 CONV는 3×3×192의 256개의 kernel로 filtering하며
3, 4, 5번째 CONV는 어떠한 간섭(intervening)pooling과 normalization layer없이 서로 연결된다.

또한 FC (Fully-Connected layer)는 각각 4096개의 뉴런을 갖는다.

4. Reducing Overfitting

4.1 Data Augmentation

① image translation. &. horizontal reflection
- image translation: 한 도메인의 입력 이미지를 다른 도메인의 해당 이미지로 변환하는 것
- 이 방법을 통해 train에 상호의존적일 수 있고 이런 scheme이 없었다면 overfitting의 어려움을 겪었을 것이다.

② altering intensities of the RGB channels
- ImageNet의 training set 전체의 RGB픽셀값에 PCA를 수행
- 각 train image에 해당 eigenvalues(고유값)에 비례하는 크기와 평균 0, 표준편차 0.1을 갖는 zero-mean Gaussian 분포(정규분포)에서 도출된 random변수를 곱해 나온 주요 구성요소의 배수를 추가한다.
- 따라서 RGB 픽셀 Ixy =[IR , IG , IB ]T에 아래 값을 추가한다. 

- 이때, pi와 yi는 각각 RGB pixel의 3x3 covariance(공분산)행렬의 i번째 eigenvector와 eigenvalue이며 αi는 이전에 설명한  random 변수이다. 각 αi는 해당 이미지가 다시 훈련에 사용될 때까지 특정 훈련 이미지의 모든 픽셀에 대해 한 번만 그려지며, 이 시점에서 다시 그려진다.

4.2 Dropout

- Dropout은 전진의 기여도를 없애고 역전파를 관여하지 못하게 하는 방식으로 많고 다른 뉴런들의 부분집합을 random하게 결합시키는데 유용하다.
- 0.5의 비율로 FC의 처음 2개의 layer에 적용하였으며 dropout이 없으면 상당한 과적합을 보여주었다.

5. Details of Learning

- Optimizer: SGD (Stochastic  Gradient  Descent), momentum = 0.9,  weight decay = 0.0005
- Batch size: 128

i는 반복횟수, v는 momentum변수, ε은 Learning rate(학습율),

<-- wi에서 평가된 w의 미분(derivative)의 i번째 batch Di의 평균으로 Loss function의 기울기을 의미한다.

<초기화>
표준편차가 0.01인 zero-mean Gaussian 분포로 각 층의 weight를 초기화
2,4,5 CONV층과 FC층은 상수 1로 , 나머지 층은 0으로 bias를 초기화
validation error가 개선되지 않으면 학습율을 10으로 나눔 (0.01로 초기화 하였으며 종료전에 3배정도 감소하였음)

6. Results

- ILSVRC-2010에 대한 결과의 요약은 다음과 같다.

신경망은 37.5%와 17.0%5의 상위 1위와 상위 5위의 테스트 세트 오류율을 달성하는 것을 볼 수 있다.

ILSVRC-2010 경쟁에서 달성된 최고의 성능은 서로 다른 기능에 대해 훈련된 6개의 spase coding 모델에서 생성된 예측을 평균화하는 접근 방식으로 47.1%와 28.2%였다.
그 이후 가장 잘 발표된 결과는 Fisher Vectors (FVS)에 대해 훈련된 두 분류기의 예측을 평균화하는 접근 방식으로 45.7%와 25.7%였으며 두 가지 유형의 조밀하게 샘플링된 특징으로부터 계산되었다.

- 또한  ILSVRC-2012 대회에서의 결과는 다음과 같다.

단락(paragraph)의 나머지 부분에서는 검증 및 테스트 오류율이 0.1% 이상 차이가 나지 않기 때문에 서로 교환하여 사용한다.


이 논문에서 설명한 CNN은 다음과 같은 성과를 거두었다
상위 5위 이내의 오류율 18.2%. 5개의 유사한 CNN의 예측을 평균하면 16.4%의 오류율을 얻었다.

- 마지막 pooling layer에서 추가적으로 6차 컨볼루션 레이어가 있는 CNN 하나를 교육하여 ImageNet Fall 2011 release (15M images, 22K categories)를 분류한 다음 ILSVRC-2012에서 "미세 조정(fine-tuning)"하면 16.6%의 오류율을 얻을 수 있다. 앞서 언급한 5개의 CNN으로 2011년 가을 전체 릴리스에서 사전 훈련된 2개의 CNN의 예측을 평균하면 15.3%의 오류율을 얻을 수 있다. 두 번째로 우수한 콘테스트 항목은 다양한 유형의 조밀하게 샘플링된 기능에서 계산된 FV에 대해 훈련된 여러 분류기의 예측을 평균화하는 접근 방식으로 26.2%의 오류율을 달성했다.

- 마지막으로, 우리는 또한 10,184개의 범주를 가진 Fall 2009 version of ImageNet에 대한 오류율을 보고한다
그리고 890만 장의 이미지가 있는데, 이 dataset에서 우리는 학습을 위해 이미지의 절반을 사용하고 테스트를 위해 이미지의 절반을 사용하는 문헌의 관례를 따른다.
확립된 testset이 없기 때문에, 우리의 분할은 반드시 이전 저자들이 사용한 분할과 다르지만, 이것은 결과에 크게 영향을 미치지 않으며 이 dataset에서 상위 1위와 상위 5위의 오류율은 67.4%와 40.9%이며, 위에서 설명한 순으로 달성되나 마지막 pooling layer에 비해 6번째 컨볼루션 계층이 추가된다. 이 데이터 세트에 대한 가장 잘 알려진 결과는 78.1%와 60.9%이다.

6.1 Qualitative Evaluations

이 그림은 신경망의 두 data-connected layer에 의해 학습된 Convolution kernel을 보여준다.
신경망은 다양한 frequency 및 orientation-selective kernels 뿐만 아니라 다양한 색상 blob들을 사용한 것 또한 알 수 있다.

3.5에서 설명한 제한된 연결의 결과로 두 GPU가 보여주는 전문화에 주목한다. GPU 1의 커널은 대부분 색상에 구애받지 않는 반면 GPU 2의 커널은 대부분 색상에 따라 다르기에 이러한 종류의 전문화는 모든 실행 중에 발생하며 특정 random weight 초기화(GPU의 모듈로 번호 변경)와 무관하다.

위 사진의 왼쪽은 다음과 같다.
- 8개의 테스트 이미지에 대한 상위 5개 예측을 계산하여 신경망이 무엇을 배웠는지 정성적으로 평가(qualitatively assess)한다.
- 이때, 진드기(mite)같이 중심을 벗어난 물체도 net로 인식할 수 있다는 점을 유의해야 한다.
(상위 5개의 label은 대부분 합리적인 것으로 보인다.)

위 사진의 오른쪽은 첫 번째 열에 5개의 ILSVRC-2010 테스트 영상으로 나머지 열은 테스트 이미지의 특징 벡터로부터 유클리드 거리(Euclidean distance)가 가장 작은 마지막 숨겨진 레이어에서 특징 벡터를 생성하는 6개의 훈련 이미지를 보여준다.

- 두 이미지가 작은 Euclidean separation으로 특징 활성화 벡터(feature activation vectors)를 생성할 때, 신경망의 고수준이 유사하다 간주한다고 할 수 있다.

- 그림은 testset의 5개 이미지와 이 측정에 따라 각 이미지와 가장 유사한 training set의 6개 이미지를 보여주는데, 픽셀 수준에서 검색된 교육 이미지는 일반적으로 첫 번째 열의 query image의 L2에서 가깝지 않다.
예를 들어, 회수된 개들과 코끼리들은 다양한 포즈로 나타나며 우리는 보충 자료에서 더 많은 train image에 대한 결과를 제시한다.

- 두 개의 4096차원 실제 값 벡터 사이의 Euclidean distance 사용하여 유사성을 계산하는 것은 비효율적이지만, 이러한 벡터를 짧은 이진 코드로 압축하도록 auto-encoder를 훈련시킴으로써 효율적으로 만들 수 있다.
이는 image label을 사용하지 않기에 의미적으로(semantically) 유사한지 여부에 관계없이 edge들과의 유사한 패턴을 가진 이미지를 검색하는 경향이 있는 raw-pixel에 auto-encoder를 적용하는 것보다 훨씬 나은 이미지 검색 방법을 생성해야 한다.

7. Discussion

- 크고 깊은 CNN이 기록을 깨는 좋은 결과를 내는 것을 알 수 있다.
- 또한 중간층을 일부 삭제하더라도 성능이 떨어지는 것을 알 수 있듯, 깊이가 정말로 우리의 결과를 이룩하는데 중요하다는 것을 알 수 있다.

- 실험을 단순화하기 위해, 특히 label이 지정된 데이터의 양에서 그에 상응하는 증가를 얻지 않고 신경망의 크기를 크게 늘릴 수 있는 충분한 계산 능력을 얻는 경우에 도움이 될 것으로 예상했음에도 불구하고 unsupervised pre-training을 사용하지 않았다.

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

"ImageNet Classification with Deep Convolutional Neural Networks"
Alex Krizhevsky, Ilya Sutskever 및 Geoffrey Hinton이 2012년에 발표한 연구 논문으로 이 논문은 2012년 ILSVRC(ImageNet Large Scale Visual Recognition Challenge)에서 최첨단 성능을 달성한 AlexNet이라는 심층 합성곱 신경망을 제안한다.

[핵심 개념]

1. Convolutional Neural Networks
Convolutional 및 Subsampling 층의 여러 layer로 구성된 Deep CNN Architecture와 Fully-Connected layer를 제안한다.

2. Rectified Linear Units(ReLU)
이 논문은 Sigmoid 및 tanh와 같은 기존 활성화 함수보다 더 간단하고 효율적인 ReLU 활성화 함수의 소개 및 활용을 진행한 최초의 논문이기에 더욱 중요하다고 볼 수 있다.

3. Local Response Normalization(LRN)
이 논문은 일종의 측면 억제(lateral inhibition)를 제공하여 일반화 성능을 개선하는 데 도움이 되는 LRN이라는 정규화 유형을 제안한다.

4. Dropout
이 논문은 과적합을 방지하기 위해 훈련 중에 일부 뉴런을 무작위로 제거하는 드롭아웃이라는 정규화 기술을 소개하였다.

5. Data Augmentation
이 논문은 training set의 크기를 늘리고 model의 견고성을 늘ㄹ리기 위해 random crop, vertical flip같은 기술을 사용했다.

6. State-of-the-Art Performance (최신 성능)
이 논문은 ILSVRC 2012 분류 작업에서 최신 성능을 달성하여 이전 방법보다 훨씬 뛰어난 성능을 보여준다.

전반적으로 이 논문은 Convolution신경망, ReLU 활성화 함수 및 데이터 증강의 사용과 같은 딥 러닝의 몇 가지 중요한 개념을 소개하고 까다로운 컴퓨터 비전 작업에서 최첨단 성능을 달성하는 데 있어 그 효과를 입증했다.

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

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

def AlexNet(input_shape, num_classes):
    input_layer = Input(shape=input_shape)
    
    # first convolutional layer
    x = Conv2D(96, kernel_size=(11,11), strides=(4,4), padding='valid', activation='relu')(input_layer)
    x = MaxPooling2D(pool_size=(3,3), strides=(2,2))(x)
    x = Dropout(0.25)(x)
    
    # second convolutional layer
    x = Conv2D(256, kernel_size=(5,5), strides=(1,1), padding='same', activation='relu')(x)
    x = MaxPooling2D(pool_size=(3,3), strides=(2,2))(x)
    x = Dropout(0.25)(x)
    
    # third convolutional layer
    x = Conv2D(384, kernel_size=(3,3), strides=(1,1), padding='same', activation='relu')(x)
    x = Dropout(0.25)(x)
    
    # fourth convolutional layer
    x = Conv2D(384, kernel_size=(3,3), strides=(1,1), padding='same', activation='relu')(x)
    x = Dropout(0.25)(x)
    
    # fifth convolutional layer
    x = Conv2D(256, kernel_size=(3,3), strides=(1,1), padding='same', activation='relu')(x)
    x = MaxPooling2D(pool_size=(3,3), strides=(2,2))(x)
    x = Dropout(0.25)(x)
    
    # flatten the output from the convolutional layers
    x = Flatten()(x)
    
    # first fully connected layer
    x = Dense(4096, activation='relu')(x)
    x = Dropout(0.5)(x)
    
    # second fully connected layer
    x = Dense(4096, activation='relu')(x)
    x = Dropout(0.5)(x)
    
    # output layer
    output_layer = Dense(num_classes, activation='softmax')(x)
    
    # define the model with input and output layers
    model = tf.keras.Model(inputs=input_layer, outputs=output_layer)
    
    return model

model = AlexNet(input_shape=(224,224,3), num_classes=1000)
model.summary()

Model: "model"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 input_12 (InputLayer)       [(None, 224, 224, 3)]     0         
                                                                 
 conv2d_281 (Conv2D)         (None, 54, 54, 96)        34944     
                                                                 
 max_pooling2d_59 (MaxPoolin  (None, 26, 26, 96)       0         
 g2D)                                                            
                                                                 
 dropout_21 (Dropout)        (None, 26, 26, 96)        0         
                                                                 
 conv2d_282 (Conv2D)         (None, 26, 26, 256)       614656    
                                                                 
 max_pooling2d_60 (MaxPoolin  (None, 12, 12, 256)      0         
 g2D)                                                            
                                                                 
 dropout_22 (Dropout)        (None, 12, 12, 256)       0         
                                                                 
 conv2d_283 (Conv2D)         (None, 12, 12, 384)       885120    
                                                                 
 dropout_23 (Dropout)        (None, 12, 12, 384)       0         
                                                                 
 conv2d_284 (Conv2D)         (None, 12, 12, 384)       1327488   
                                                                 
 dropout_24 (Dropout)        (None, 12, 12, 384)       0         
                                                                 
 conv2d_285 (Conv2D)         (None, 12, 12, 256)       884992    
                                                                 
 max_pooling2d_61 (MaxPoolin  (None, 5, 5, 256)        0         
 g2D)                                                            
                                                                 
 dropout_25 (Dropout)        (None, 5, 5, 256)         0         
                                                                 
 flatten_9 (Flatten)         (None, 6400)              0         
                                                                 
 dense_25 (Dense)            (None, 4096)              26218496  
                                                                 
 dropout_26 (Dropout)        (None, 4096)              0         
                                                                 
 dense_26 (Dense)            (None, 4096)              16781312  
                                                                 
 dropout_27 (Dropout)        (None, 4096)              0         
                                                                 
 dense_27 (Dense)            (None, 1000)              4097000   
                                                                 
=================================================================
Total params: 50,844,008
Trainable params: 50,844,008
Non-trainable params: 0
_________________________________________________________________