this.code();

[사전조사 배경지식 정리]

1. 용어정리

DAOD: Domain Adaptation Object Detection

leverage: 영향, 활용

Cross Domain: 2개간의 Domain간의 연결 or 관련성, 결합 등을 의미

Domain Discrepancy: domain간의 distribution이 불일치하는 것, 이로인해 일반화가 쉽지 않음.

Domain Shift: Cross Domain에서 발생하는 문제점.
Imbalance와 Consistency없는 Domain shift의 경우, Tgt이 적으면 DA가 어려움.
이를 해결하기 위해 여러가지 방법들을 다양한 level에서 활용.
ex) img-level, instance-level, pixel-level, category-level, ...

Domain Invariance: Domain불변성을 결과적으로 학습하는것이 목표인 논문들이 많음.

Domain Alignment: 두 Domain에 대해 일치(정렬)시키는 것.
이때, 보통 두 Domain간의 feature distribution alignment를 통해 이루어진다.

Unsupervised Learning Object Detection: Label 혹은 Annotation이 없는 Target Domain문제에 대한 학습
Semi-supervised Learning Object Detection: Label을 teacher모델이 생성(이를 pseudo labeling이라 함), 이를 이용.

2. 발전현황:

[2018]:

∙ Supervised Learning기반. Domain Shift에 초점, Domain discrepancy(불일치)감소에 초점.

∙ 특히 DANN 이후로 Adversarial Training방식이 주를 이룸.

[2020]:

∙ 중간에 도메인을 하나 더 넣거나 등의 Tgt Imbalance 문제해결방법.

∙ Domain의 Class Imbalance문제 완화를 위한 방법

∙ 특히 이때부터 Unsupervised DAOD가 각광받음❗️

∙ Domain-Invariance 학습을 위해 다양한 시도들이 이루어짐.

∙ SSD를 이용, 단지 하나의 Tgt Sample만 필요한 one-shot기법도 나옴.

[2021]:

∙ Domin불변성 + 식별력 유지 둘을 동시에 잡기위해 Faster R-CNN에 다른 기능들을 추가시킴.

∙ 또한, 저차원의 Src, Tgt feature Domain을 맞추는 것에 대한 중대성강조로 저/고차원 특징을 결합하는 등의 시도도 발생.

∙ semi-supervised learning에서 pseudo-label noise극복을 하려함.

∙ Src, Tgt모두 없이도 DAOD를 가능하게하려고 여러방법들을 도입한 논문발표(이번 review논문)

∙ 또한, Data Augmentation방법들도 여럿 도입됨.

[2022]:

∙ Domain Adversarial Training, Data Augmentation은 약간 국룰화?처럼 되는 뉘앙스

∙ pseudo label을 다루기 위해 여러 시도들 발생

Abstract

🧐 저자의 제안:

UnLabeled Src Data →Tgt에 최적화가 주목
이를 위해 저자는 SFOD프레임워크를 제안

[SFOD] (Source Data-Free Domain Adaptive Object Detection):
Src Data없이도 DA탐지를 가능하게 하며,
이는 Noise있는 Label로 학습하는 것으로 모델링한다.

일반적으로 Src에서 pretrained모델을 활용, Tgt의 가짜라벨생성을 한다.
하지만 Tgt Domain라벨이 없으면, 이런 가짜라벨생성에 대한 평가가 어렵다.

→ SED(Self-Entropy Descent)라는 평가지표 도입!
SED: 가짜라벨에 대해 적절한 신뢰임계값결정을 위해 도입한 metric

다만, 완전히 깨끗한 라벨을 얻는 것은 여전히 어려움을 겪고 있는데, 실험결과 생성된 노이즈가 있는 라벨에서 FN이 지배적임을 발견.
개선을 위해 FN mining이 도움이 되며, Mosaic와 같은 데이터 증강을 통해 FN시뮬레이션을 용이하게 한다.

---

🧐 개인 생각 정리:

핵심:

Src Domain에서 pretrained만 사용, supervision signal을 제공
→ 즉, Tgt으로 pseudo labeling되어 noise가 발생할 수 밖에 없는 구조.

문제점 1:
Src, Tgt에 대한 label이 모두 없기에 pseudo label에 대한 평가가 어려움
→ SED라는 평가지표 도입❗️

문제점 2:
다만, clean label얻기는 어려움---noise에서 FN, FP가 지배적
→ FN Mining, Data Augmentation(e.g. Mosaic)으로 이를 개선❗️

Introduction & Main contribution

Object Detection의 발전은 단지 수동라벨링된 Train data에 의존해서 향상되어 왔다.
이는 새로운 환경이나 Data 분포가 다른 경우(e.g. 물체외관, 배경타입, 날씨 등 다양한 요인) 일반화가 쉽지 않다는 한계점이 존재.

그렇다면, 어떻게 pre-trained model을 supervision 없이 label-rich Src Domain → unlabeled Tgt Domain...?
이 UDA를 위해 많은 방법들이 고안됨
 ∙ Domain-invariant features를 alignment 하는 방식
 ∙ Domain distribution 근접화 방식
 ∙ 두 domain간 similarity를 측정해 pseudo labeling 하는 방식
이는 두 Domain이 관련되었지만 다름을 의미
→ 따라서 두 Domain간 접근이 자유로울 필요성이 존재하지만 challegeable함.

---

이미 Classification에서는 Src-data free한 방식이 좋았으나 Detection에서는 여전히 시도되지 않았었음.
본 논문에서는 전술한 문제 해결을 위해 SFOD(Source data-Free domain adaptive Object Detection)라는 간단하지만 효과적인 접근방법을 소개함.

∙ SFOD : pre-trained Src모델을 활용, DA과정을 분리.

🔑  Idea :

신뢰가능한 pseudo label을 활용해 Tgt모델을 self-learning방법으로 training.

❓ 자연스러운 의문점:

이제 남은 자연스러운 질문은 2가지이다.
 ∙ 어떻게 pseudo label의 품질을 평가할 것인가
 ∙ 어떻게 Noisy Label로 학습할 것인가?

 

---

Classification의 경우, 고정된 sample수였지만
Detection의 경우, Negative sample이 무수하기에 매우 도전적인 과업이다.
(많은 positive가 box로 둘러쌓여있어서 negative와 섞여있기 때문.)

그렇기에 신뢰가능한 소수의 sample로는 좋은성능을 달성할 수 없음
(One-Shot Unsupervised Domain Adaptation for Object Detection (IEEE 2020))에 정면으로 반박하는 느낌.

Sol) 적절한 신뢰도임계값으로 Bbox를 직접 P/N을 부분 filtering하는 것이다.
물론, Detection에서는 FP,FN같은 noisy labels는 무조건 존재하고, Tgt모델은 여전히 "집단지성의 원칙"을 따라 최적화 가능하다.
("집단지성의 원칙": 여러 모델이나 다수의 예측을 종합하거나, 다수의 샘플의 정보를 활용하여 모델을 최적화할 수 있다는 것을 의미)

하지만 supervision metric이 없어 적절한 신뢰도임계값 찾기란 어렵다.
noisy label로 신뢰도임계값이 너무 높거나 낮을 수 있기때문에 적절한 신뢰도임계값 탐색이 필요하다.

∙SED :Search Confidence threshold

이를 위해 등장한 Self-Entropy Descent는 전술한 신뢰도임계값을 찾기위해 제안된다.

예측 불확실성은 Self-Entropy로 계산된다.
이 문장은 다음과 같이 해석될 수 있다: "자가 엔트로피가 낮을수록 더 예측이 확실하다."
신뢰도 임계값을 탐색함과 동시에, 생성된 가상 라벨을 사용해
pre-trained model을 fine-tuning하고
그 후 훈련 이후 데이터셋의 Self-Entropy를 평가한다.

"라벨이 더 지저분할수록 더욱 라벨을 맞추기가 어려워진다." (사실 당연한 소리다.)
∴ 신뢰도임계값↓ → 평균 Self-Entropy↓ → 첫 local-minimum에 도달 시, 
이를 신뢰가능한 pseudo label생성을 위한 적절한 신뢰도임계값으로 선택.

이 솔루션의 타당성을 입증하기 위해 장난감 실험을 설계.
구체적으로, 생성된 pseudo label은 FP와 FN.
실험 분석을 통해 FN이 작고 가려진 객체와 같은 noisy label에서 주를 이루는 것을 발견.

∙FN Mining & Mosaic :FN의 영향 완화

또한 Mosaic(Bochkovskiy, Wang, and Liao 2020)와 같은 데이터 증강을 통해
거짓 음성을 시뮬레이션할 수 있도록 이 솔루션을 FN시뮬레이션으로 완화.

---

🧐 Main Contribution

i) Src data-free인 UDA-OD의 첫번째 시도.
ii) Src data-free인 UDA를 noisy label학습을 통해 혁신적으로 모델링, 해결.
iii) Src data사용을 안하고도 매우 좋은 성능, 다른 Src data based를 능가.

---

🧐 개인 생각 정리:

핵심: SFOD,  SED,  FN Mining

SFOD 배경: pre-trained model을 supervision 없이 label-rich Src Domain → unlabeled Tgt Domain
SFOD 역할: pre-trained Src모델을 활용, DA과정을 분리.

 

SED배경: 적절한 신뢰도임계값으로 Bbox를 직접 P/N을 부분 filtering해야하고,
이를 위해 신뢰도 임계값 평가를 위한 supervision metric이 필요.
SED역할: 예측 불확실성을 Self-Entropy로 계산, 신뢰도임계값 탐색 및 생성된 가상 라벨을 사용해
pre-trained model을 fine-tuning하고 훈련 이후 데이터셋의 Self-Entropy를 평가


FN Mining배경: 생성된 pseudo label은 FP와 FN이 noisy label이 주를 이룸.
FN Mining역할: Mosaic와 같은 데이터 증강으로 FN완화.


[요약]:
Step 1. pseudo Label 생성
신뢰도가 높은 소수의 sample(= Tgt)으로는 좋은 성능을 달성할 수 없다. 
Sol) 적절한 신뢰도임계값으로 Bbox를 직접 P/N을 부분 filtering하는 것

이를 위해 적절한 supervision metric이 필요 → SED: Self-Entropy Descent❗️
이렇게 평가된 예측불확실성으로 신뢰도임계값 탐색 → pseudo label 생성에 도입.

Labeled Src Data로 Faster R-CNN을 pre-train시킨 이후
이를 Unlabeled Tgt Data에 fine-tuning시켜 pseudo label생성에 동시에 도입.

Step 2. 생성된 pseudo Label의 FN완화
생성된 pseudo label은 FP, FN등이 noisy label이 주를 이룬다.
이를 해결하기위해 FN Mining, Mosaic Augmentation을 이용.

Related Works

∙ DAOD

DA-Faster(Chen et al. 2018)이라는 논문이 UDA Object Detection 진보를 이끌어낸 효시가 되는 논문.

생성된 노이즈가 있는 라벨에서 FN이 지배적임을 발견.

그 이후 초록색표시한 방법들이 많이 나왔음:
 - Labeled Src Data
 - Unlabeled Tgt Data 
2개가 필히 필요함.

우리는 Src data 없어도 되서 실제적용에 실용적.

---

∙ DA without Src Data

Classification을 위한 Src data-free DA방법은 이미 제안되었음(Li et al. 2020; Kim, hong, and Cho 2020)
Detection분야에 대한 적용은 여전히 공백인 상황.

---

∙ Learning with Noisy Labels

noisy label학습을 위해 많은 방법들이 classification에서 이루어져 왔었다.
∙ 초기: instance-독립의 Noise model 사용: 각 클래스가 다른 클래스와 혼동되는 문제 발생
∙ 최근: Label noise 예측에 초점

하지만 위 연구들의 noisy label 설정방식은 이상적:
noisy label과 true label을 수동 설정.

추가적으로 noisy label학습을 위해 여러 방식들이 제시됨:
object경계지정이 명확하지 않은경우, 문제해결이 불가능

Source free Domain Adaptive Object Detection

[UDA-OD가정]
Src와 Tgt이 training과정에서 자유롭게 사용되어 Src-Tgt, 두 Domain간의 차이(discrepancy)를 최소화 하는것.

[Src data-free UDA의 목표]
신경망 최적화를 위해 Dt만 사용하는 것
이때, 유일한 supervision 신호는 Ds의 data를 직접사용하는 대신,
Ds에서 pre-trained model θs에서 제공된다.

---

∙ Pseudo Lables Optimization via SED

🤔 A toy example: How to evaluate the quality of pseudo labels?

Toy example이란?
MNIST를 2개의 범주(positive, negative)로 구분; 이를 MNIST-2라 지칭함.
이를 기반으로 다양한 Dataset을 구축.
ex) positive sample을 negative에 서로다른비율로 섞거나
negative sample을 positive에 서로다른비율로 섞어 이를 LeNet에 훈련.
즉, 혼합 비율 = 노이즈 정도.

훈련 후 전체 데이터셋의 예측 불확실성을 잡기 위해 'mean self-entropy'개념을 도입:

nc : class 수
pc(xti): class c의 예측확률

---

위 그림에서 보이듯, noise정도는 mean self-entropy와 양의 상관관계를 가짐은 자명하다.

∙ 위 그림) 더 noisy label → label 맞추기가 어려움 = mean self-entropy⇧
∙ 이상적 상황) 가장 깨끗한 라벨 할당 → 가장 낮은 mean self-entropy

즉, 두 상황을 고려해보면?
❗️mean self-entropy가 감소→ local-minima에 도달 = reliable한 label할당.

---

🤔 SED: how to generate reliable pseudo labels in Object Detection

Detection에서 Negative samples는 진~~짜 많다.(진짜 강조 많이한 말.)
앞단의 설명처럼, training을 위해 P/N sample분리가 필요
→ 이는 저점~고점까지 적절한 confidence threshold를 찾아야함을 의미.

[SED: Self Entropy Descent]

❗️mean self-entropy가 감소해 첫 local-minimum에 도달할 때, 훈련을 멈춘다.
(→ 가장 낮은 entropy값=가장 깨끗한 = 신뢰할만한 라벨할당 가능.)

Dt 와 Ds에서 pre-train된 model θs는 자유롭게 활용가능하므로 
pseudo label y(xt)와 그에 해당하는 신뢰도 p(xt)는 아래와 같이 유도된다.

h: pseudo label생성을 위한 confidence threshold
F: Faster R-CNN Detector: 
Faster R-CNN:
  - Anchor기반의 효시
  - Detector가 feature extractor로써의 encoder를 갖고있음.
  - encoder에는 RPN, RoI classifier를 갖고있음.

---

confidence p(xt): classification분기에서 softmax output.
pseudo label y(xt): foreground클래스 확률의 argmax값.

if p(x_t) > h:    
    box = y(x_t)  # 일치하는 박스에 클래스라벨 max_score 할당
else:
    box = background

 

 

---

📌 Loss function: pseudo label을 사용해 tgt data train

Region Proposal Bbox Regression: 
Src domain에서 pretrained model training으로 예측된 Bbox를 ground_truth로 바로 사용가능.
Detection오류는 Classification오류보다 훨씬 약하다 (Borji and Iranmanesh 2019).

---

이 Fine-Tuning작업 이후, pre-trained과 confidence threshold로 생성된 pseudo label들은
update된 모델 θt를 사용해 Tgt Dataset의 평균 self-entropy, H(Dt)로 평가한다.

 

---

∙ False Negative Simulation

적절한 confidence threshold값을 SED를 통해서 찾았지만, 여전히 문제점 존재: pseudo labels는 여전히 noisy
Detection에서의 noisy label: FP, FN

여러 공개된 데이터셋에서 각 confidence구간에서 TP와 FP를 계산.
아래 그림처럼 FP는 비교적 작은 비율만을 차지합니다.

놀랍게도, 저자가 신뢰 임계값을 거의 0에 가깝게 설정해도 반이상의 positive sample은 box하기를 어려워한다.
결과적으로 training 중 positive sample이 FN으로 작용하게 된다!

---

그렇기에 본 논문에서는 Label Denoising을 위한 FN mining에 초점을 맞춘다.
아래 시각화된 자료에서 알 수 있듯, 대부분의 FN은 작고 가려진 객체로
TN과 섞여서 positive로 다시 mining하기가 어렵다.
→ Domain discrepancy가 심화되는 이유.


Solution) TP를 이용한 FN Simulation: Data Augmentation
detect된 positive를 어렵게 만듬 → detect하기 힘든 작고 가려지는 객체를 모방, 이를 simulate함.
추가적으로 FN의 악영향을 억제

이를 위해 저자는 Mosaic Augmentation(YOLOv4)을 FN Simulation에 선택.
TP를 활용해 작거나 가려진 객체생성 시, TN에 영향을 주지 않기 때문.

CutMix(2019)를 개선한 방식, 4개의 train_img를 혼합, 일반상식내의 객체도 감지가능.


[Mosaic의 Main 2-step]
Step 1: Random Scaling
  - Tgt Domain에서 detect된 단순객체를 사용→다양한 크기의 어려운 객체 모방

Step 2: Random Cutting
  - 일부 구조만 보이는 객체를 어느수준까지 모방가능

---

Mosaic data: {(x ̃, y ̃)}는 아래 식에 따라
Tgt domain data {(xA,yA),(xB,yB),(xC,yC),(xD,yD)}로 구성될 수 있다:

train_img: H×W.
(u, v): 2차원 이동.
{MA,MB,MC,MD} ∈ {0,1}s(W)×s(H): binary mask그룹
s(·)와 λ: Random Scaling & Cutting 인자.

---

FN Simulation이 SED와 함께 pseudo labeling생성을 위한 적절한 신뢰 임계값을 찾는과정을 위의 SFOD의 전체 파이프라인에서 볼 수 있다.

---

🧐 개인 생각 정리:

핵심:
∙ How to evaluate the quality of pseudo labels?

noisy label = label맞추기 어려움 = mean self-entropy⇧
→ 깨끗한(= 신뢰할만한) 라벨을 얻으려면 entropy값이 낮아야함.
→ 즉, mean self entropy-noise degree그래프상에서 극솟값에 도달하면 라벨할당!

∙ How to generatethe quality of pseudo labels?
training을 위해 P/N sample분리가 필요한데, 이를 위해 적절한 threshold값이 필요.

if p(x_t) > h:    
    box = y(x_t)  # 일치하는 박스에 클래스라벨 max_score 할당
else:
    box = background

 

pre-trained과 confidence threshold로 생성된 pseudo label들은
update된 모델 θt를 사용해 Tgt Dataset의 평균 self-entropy, H(Dt)로 평가

∙ False Negatives Simulation
신뢰 임계값을 거의 0에 가깝게 설정해도 반이상의 positive sample은 box하기를 어려워한다. (작거나 가려지는 물체때문!)
결과적으로 training 중 positive sample이 FN으로 작용하게 된다!
→  Label Denoising을 위한 FN mining에 초점

FN Mining은 FN Simulation으로 이루어지며, FN Simulation에 Mosaic방식을 선택
FN Simulation이 SED와 함께 pseudo labeling생성을 위한 적절한 신뢰 임계값을 찾는다.

---

요약: 아무래도 과정이 제법 복잡하여 한번 요약을 해야할 것 같았다.

1. 기존과 달리 Src data-free를 위해서는 Labeled Src Data로 Faster R-CNN을 pre-trained시킴.

2. Src의 data를 직접 사용하는 대신, Src로 pre-train된 model에서 유일한 supervision signal을 학습 시 제공
(for. 신경망 최적화를 위해 Tgt Domain만 사용.)

3. FN Simulation과 SED를 같이 사용해 pseudo labeling 생성을 위한 적절한 confidence threshold, h를 찾는다.
(SED: training을 위해 P/N분리가 필요하고, 이를 위해서는 신뢰할만한 pseudo label이 생성되어야하고,
이를 위해 신뢰할만한confidence threshold가 필요 = 낮은 entropy,
따라서 mean self-entropy를 이용, 저점~고점을 탐색하다
Self-Entropy가 첫 극솟값을 만나면 멈춘다. 이 전략을 SED라 부른다.
즉, confidence threshold로 생성된 pseudo label들을 update된 pretrained모델로
Tgt Dataset의 mean self-entropy를 평가한다: hopt = argmin H(Dt)이다.)

(FN Simulation: SED로 찾은 pseudo label은 여전히 noisy(FP, FN)label인데, 특히나 positive가 작거나 가려지는 물체로 인해 FN으로 작용하는 현상이 발생하여 이를 방지하기 위함이다.)


4. h와 pre-trained model parameter를 이용해 Faster R-CNN은 아래 두 값을 출력한다.
cf) pseudo label y(x)= foreground클래스확률의 argmax값
cf) confidence p(x)= classification분기에서의 softmax값

Experiments

∙ Experimental Setup

   ‣ Datasets

5개의 open dataset이 사용됨:

---

   ‣ Implementation Details

공정한 비교를 위해 [Xu 2020]과 동일한 실험적 setting.
☞ [img pixel]: train-test모두 600 pixel로 resize
☞ [batch_size]: 1
☞ [Model]:
       - (pre-trained): VGG16 with ImageNet & Src. Domain data 여기서만 사용.
       - (backbone): Faster R-CNN
         - (Detector): SGD(lr=0.001)

---

∙ Comaparison Results

[그림 7]:
저자의 실험은 4가지 Adaptation task에 대해 진행된다.
위 그림은 다양한 confidence threshold값 하에
Detection precision과 mean self-entropy의 곡선을 보여준다.

 "Source only"와 "Oracle"은 각각 Labeled Src, Tgt Domain trainset으로 훈련되었지만,
Target Domain validation set에서 test되었다.

    ‣ Adaptation to A New Sense

Real World는 다양한 현상이 존재: 각도, 해상도, 품질 및 유형 등
→ Domain Shift 유발가능; 본실험에서는 두 real dataset 간의 새로운 Detection task Adaptation을 고려.
  ∙ [Src Domain]: KITTI
  ∙ [Tgt Domain]: Cityscapes 

[Model 비교군]:
SFOD(본논문), DA-Faster, SW-Faster, Noise Labeling ,
DA-Detection, AT-Faster

[표 1]: 유일한 공통 객체: 자동차 카테고리, 이에 대한 AP를 비교진행.
∙only SED:  labeled Tgt validation set에서 찾은 이상적인 confidence threshold값이 없음에도 AP가 매우 이상적인 값에 근접.
자동차 Detection Acc측면에서도 많은 기존방법보다 좋음.
∙SED+Mosaic: AP: 43.6% →44.6% (DA-Detection을 0.7%만큼 넘어섬)
FN Simulation이 FN noise label에 의한 악영향 완화.

---

   ‣ Adaptation from Synthetic to Real Images

자율 주행을 위한 annotating train data부족으로 synthetic dataset을 사용.
  ∙[Src Domain]: Sim10k
  ∙[Tgt Domain]: Cityscapes 

여기선 Sim10k와 Cityscapes 양쪽에서 유일한 객체 카테고리인 주석이 달린 자동차의 성능만을 평가.

[표 2]:  DA-Faster, Noise Labeling, AT-Faster과 비교,
SFOD방법이 우수, 기존을 능가.
(다만, 저자방식은 기존의 Src based보다 어려운 도전이 될 것.)

---

   ‣ Adaptation to Large-Scale Dataset

∙[smaller Src Domain]: Cityscapes 
∙[large unlabeled Tgt Domain]:  BDD100k

Cityscapes: only daytime
BDD100k: 3개의 시간대의 labeled daytime data를 tgt domain으로 함.

[표 3]: 
Baseline과 Oracle에서 보이듯, Src과 Tgt간의 Domain divergence해결은 매우 복잡.

특히 더 많은 Src Data가 필요하지 않은 경우, DA-Faste, SW-Faster, CR-DA-DET 같은
소수의 접근 방식만이 이 적응 작업에 도전한다는 점에서 더욱 어렵다.

Domain Gap이 넓음에도 도메인 갭의 이렇게 넓은 범위에도 불구하고, 그림 7(그래프 그림)에서 볼 수 있듯,
SOTA들이 다양한 confidence threshold에서 개선되는데, 특히 SED 또는 SED+Mosaic을 사용할 때 CR-DA-DET의 26.9%에서 mAP를 27.6% 및 29.0%로 개선할 수 있다.

---

   ‣ Adaptation from Normal to Foggy Weather

Real-World적용에서 Detector는 다양한 날씨조건에서 사용될 수 있지만, 일일히 날씨조건에 맞는 많은 양의 data를 수집하고 label로 지정하는 것은 매우 어려운 일이다.
  ∙[Src Domain]: Cityscapes
  ∙[Tgt Domain]: Foggy Cityscapes

[표 4]:
SFOD와 다른 UDA-OD방법들(DA-Faster, SW-Faster, DA-Detection, CR-DA-DET, AT-Faster) 간의 비교
기준인(Src only) 22.3%의 mAP에 비해, label noise로 훈련된 SED+Mosaic는 pseudo label이더라도 33.5%로 향상될 수 있다.

더 나아가 DA-Detection과 같은 Defogging방법을 사용으로 Tgt Domain img품질개선 후,
여기서 SFOD성능열 연구했는데, 아래 표에서 볼 수 있듯, 안개 제거 후에 SFOD 약 3%정도 성능향상이 이뤄졌다..
즉, 안개가 가짜 라벨의 라벨 노이즈를 악화시켜 감지 성능에 영향을 미침을 알 수 있다.

---

   ‣ Discussion and Annalysis

SFOD에서는 Src Domain의 pre-trained model로 얻은 Tgt Domain pseudo label로
training과정 중 noisy label로 인해 방해받을 수 있는데, 아래 그림을 보자.

SED를 직접 사용해 pseudo label 생성을 위한 confidence threshold를 찾거나
추가적으로 FN-Simulation에 결합 시, noisy label로 인한 악효과억제로 더 많은 객체탐지가 가능하다.

---

🧐 개인 생각 정리:

핵심:
5개의 Dataset이 활용됨:
KITTI, Sim10k, Cityscapes, BDD100k, Foggy Cityscapes

        [Src → Tgt]
 ①       KITTI     → Cityscapes : for 새로운 Domain 
 ②     Sim10k   → Cityscapes: for train data부족상황 가정.
 ③ Cityscapes→ BDD10k: for data양의 차이(매우적음 to 매우많음)
 ④ Cityscapes→ FoggyCityscapes: for noisy Tgt Domain

Conclusion

UDA-OD를 위한 새로운 학습 패러다임인 SFOD를 제안.
이는 Src Data를 직접사용하는 대신,
Src Domain에서 사전훈련된 모델만을 활용,
Supervision signal을 제공하는 것이 핵심이다.

이는 noise가 있는 Label로 학습하는 관점에서 해결가능하다 보는데, 많은 Src data기반방법을 넘기도 하지만
Noise Label(FP,FN)을 완전히 제거하는 것에 대해 Unsupervised 방식이 매우 어렵다는점을 인정해야한다.

📌 InternImage [CVPR 2023]

InternImage: Exploring Large-Scale Vision Foundation Models with Deformable Convolutions

Paperswithcode 홈페이지에서 Detection, Segmentation 등 많은 Benchmark Dataset에서 최고의 성능(SOTA)를 달성한 (무친성능의) 모델이다.

🤔 Brief

Architecture

Basic block: transformer와 같이 Layer Norm, FFN으로 구성
Stem과 Downsampling layer: 기존 CNN의 설계(s2, p1은 각각 stride=2, padding=1)

목적

ViT, EfficientNet처럼 새로운 backbone모델로 Computer Vision분야에서도 GPT같은 foundation model을 만들겠다!!
(By. Deformable Convolutions)

1.  태생적인 CNN의 문제점과 극복

🤔 Why? Transformer > CNN

최근, ViT와 같은 Attention-base 모델들이 CNN보다 널리 사용되고 좋은 성능을 낸다.

Reason 1)

∙ CNN은 3x3처럼 고려 
∙ Transformer(MSA)는 모든 input을 고려.
→ CNN은 Receptive field가 너무 작아 상대적으로 멀리보지 못함(= Long-Range Dependency 차이)

Reason 2)

CNN은 layer가 쌓이면서 이런 단점을 극복되는 것이 철학.
항상 모든 input을 고려, 학습하는 ViT와 비교해 넓은 공간적 통합이 부족함

Ex) ERF의 경우
  ∙ ViT의 경우, layer는 항상 input에 적절한 영향을 받는다.
  ∙ CNN은 filter_size의 크기에 따라 커진다.
(ERF: 출력층의 하나의 뉴런에 영향을 미치는 input_pixel들의 공간 크기를 나타내는 것.)

Sol) DCN (Deformable Convolution)

1. ERF

• Convolution filter가 고정되지 않고 알아서 퍼지기에 넓은 범위를 볼 수 있다!!
• 이에 대한 증명으로 ERF를 사용 (ERF 확인 시, 넓게 퍼짐을 통해 증명)

2. ViT & Main Contribution

따라서 이 논문에서는 SOTA ViT에서 MSA 대신, 

"DCN(Deformable Convolution)을 잘 끼워 넣는다는 것"이 주요 내용이다.

→ 정확도∙연산량 등 transformer SOTA보다 더 좋다는 것이 main contribution

3. DCN v1 / DCN v2

[등장이유]

• 크기, 포즈, 시점 등의 이유로 SIFT, Affine transform 등의 전처리가 필요한 경우가 존재.
• CNN내에서, 알아서 conv연산이 필요한 경우, conv연산이 이루어지도록 학습해보자!라는 취지

[기존 CNN 연산]

3x3 filter의 경우, 하나의 output feature element를 만들기 위해 다음과 같은 연산을 진행한다.

• Feature vector의 3x3크기만큼 conv연산 진행, 그 값을 모두 더함 → 하나의 element로 만드는 작업을 반복

[DCN V1의 주장]

• 이때, p_n을 학습하게 하는 것이 DCN 이다!

📌 이때, p_n이 3x3상수가 아닌, learnable param인 ∆p_n이 된다면?

→ 이상적으로 알아서 학습이 필요한 위치에서 convolution이 진행될 것.

🚩 위치 학습 방법

1. 기존 convolution과 별개로 p_n을 학습할 수 있는 convolution(∆p_n)을 하나 더 붙임
2. p 를 weight처럼 학습
3. 그 p 를 feature x를 통해 convolution을 진행.
4. 이를 통해 위치정보가 반영된 convolution을 할 수 있게 됨.

[DCN V2의 주장]

위치 + 중요도∙영향력도 고려.

• filter의 위치에 따른 영향력, m_n(modulation변수)를 고려해보자! 

🚩 영향력 학습 방법

1. 앞과 같이 단순히 convolution을 하나 추가
2. 같은 방법으로 영향을 받는 정도까지 학습

4. DCN V3

<기존 DCN V1, V2의 문제점>

위의 DCN V2를 그대로 ViT에 넣으려고 하니 다음과 같은 문제가 발생

문제점

Prob 1) ViT SOTA에 끼워넣을 때, Convolution 개수에 따라 linear하게 parameter와 memory복잡성이 증가

Prob 2) DCN V2의 modulation이 불안정

ERF의 경우
  ∙ modulation filter의 sigmoid: 어떨 때는 평균이 1에 가깝고 어떨 때는 0에 가까움
  ∙ 이는 output에서 어느 것이 중요한지 판단이 안됨 (= 불안정)

<DCN V3의  3가지 Solution>

1. MobileNet에서 사용되는 "Depthwise Convolution"을 도입, weight를 합침
(= 경량화; 최종 결과를 토대로 볼 때, 성능보다는 연산량, 경량화를 우선)
weight를 합쳐 경량화를 하기 위해
   i) group을 나눠 group별로 하나의 weight만 학습하게 함
   ii) 그 group안에서 Depth-Wise Convolution을 진행, position과 modulation 학습
   iii) 이때, modulation factor는 softmax로 계산

2. Self-Attention처럼 MHA의 느낌이 나도록 "Group Convolution"을 도입


3. Sigmoid대신 Softmax를 사용 (→ 불안정성을 3x3 filter로 해결)

🤔 Appendix와 마무리...

ViT에서 benefit을 가져오고, EfficientNet처럼 쌓는다.(Scaling규칙)

Appendix

Appendix 내용을 볼 때, Stage별 ERF를 보면, 
∙ Stage 1,2에서는 작은 부분을 보고
∙ Stage 3,4에서는 ERF가 크게 커지는 것을 알 수 있다.

추가적으로, ResNet은 ERF가 학습이 되든 말든 Local하게 존재하지만
InternImage는 ERF가 Stage 3, 4가 넘어가게 되면, ERF가 많이 커짐을 알 수 있다. 

Limitation

높은 속도를 요구하는 경우, 그렇게 좋지는 않다.
(MobileNet에서 사용되는 "Depthwise Convolution"을 도입해 weight를 합침을 통해 경량화를 진행했음에도 불구하고)
But, 자신들이 처음이어서 봐달라는 식으로 마무리되었다.

🧐 논문 해석 및 요약

😶 초록 (Abstract)

- NLP분야에서 transformer가 사실상 standard하였지만, vision에서는 매우 드물게 사용되었다.
Vision에서는 attention 사용 시, CNN과 혼합해 사용하거나 전체구조에서 몇개의 구성요소만 대체되는 방식으로 사용되어 왔다.
본 연구는 CNN에 의존하는 것이 불필요하며 오직 transformer만으로 image patch들의 sequence를 적용해 image classification task에 매우 잘 동작함을 실험적으로 증명하였다.
많은 dataset을 pre-train한 후 small~midsize의 이미지 인식 bench mark dataset에 전이학습 시, 여타 CNN보다 ViT가 요구계산량은 적으면서도 S.O.T.A를 보여준다.

1. 서론 (Introduction)

- "Self-Attention"기반 구조 특히나 Transformer[Vaswani2017]는 NLP task에서 널리 사용되며 가장 지배적이고 널리 사용되는 방식은 매우 긴 text에 대한 pre-train 이후 작고 구체적인 task의 dataset에 fine-tuning하는 것이다.
transformer의 특징 중 하나인 계산의 효율성과 확장성 덕분에 전례없는 크기(100억개 이상의 parameter)의 model을 학습할 수 있다는 점이다. (model과 dataset 크기의 증가에도 성능이 saturating되지 않음)

- 다만 computer vision에서는 CNN방식이 지배적으로 남아있어서 NLP의 성공에 영감을 얻어 CNN에 "Self-Attention"을 합치려는 실험, Conv.layer를 모두 self-attention으로 대체하는 등이 이루어졌다. 
후자의 경우, 이론적으로는 효율적이지만 attention의 독특한 계산메커니즘으로 효율적사용이 어렵다.
(∵ image 전체를 한번에 넣는 연산 >>> 단어 vector에 대한 연산)
그렇기에 ResNet같은 모델들이 Large-Scale image에서 S.O.T.A로 남아있다.

- 본 연구는 NLP성공에 영감을 받아 standard transformer architecture의 구조를 조금 수정 후, image에 직접 적용하는 실험을 진행하였다.
이를 위해 image를 patch로 나누고, 이 patch들의 linear embedding의 sequence를 transformer의 input으로 집어 넣는다.
(patch는 NLP의 transformer에서 token(word)과 동일하게 다루어 짐을 의미한다.)

- 훈련 시, ImageNet과 같은 중간크기의 dataset에 대해 강한 규제화(regularization)없이는 비슷한 크기의 ResNet과 같은 구조의 모델들에 비해 정확도가 떨어졌다. 
이에 대해 CNN은 내재된 inductive biases가 있으나 Transformer는 내재된 inductive biases의 부족으로 충분하지 못한 양의 dataset에 대한 훈련은 모델의 일반화성능이 좋지 않을 것이라 예측 하였다.

- 다만, 14M~300M정도의 대규모의 dataset의 경우, inductive biases를 찍어눌러버릴 수 있음을 연구진은 확인했다.
ViT가 충분히 큰 dataset에 pre-train된 후 더 작은 dataset에 대해 transfer learning이 이루어지게 될 때, 기존의 S.O.T.A모델들의 성능과 비슷하거나 더 능가하는 결과를 보여준다.
cf) the best model reaches the accuracy of 88.55% on ImageNet, 90.72% on ImageNet-ReaL, 94.55% on CIFAR-100, and 77.63% on the VTAB suite of 19 tasks.

2. Related Work

- Transformer[Vaswani2017]는 NLP분야의 기계번역에서 S.O.T.A방법이 되었으며, Large Transformer기반 모델들은 매우 큰 말뭉치(corpora)에 pre-train한 후 task의 목전에 전이학습(fine-tuning)을 진행한다 : BERT[Devlin2019]는 "Denoising Self-Supervised pre-training task"로 사용하고 GPT[Radford2018, 2019, Brown2020]는 "Language modeling pre-train task"로 활용한다. 

- image에 대한 Naive한 "Self-Attention" 적용은 각 pixel이 다른 모든 pixel에 주목(attend)할 것을 요구한다.
(= 하나의 pixel을 embedding 시, 다른 pixel도 embedding에 참여할 것이 요구된다는 의미)
pixel수에서 2차적인 계산복잡도를 야기하며 이로 인해 다양한 input size로 확장되는 것이 어렵다.
즉, image processing에 transformer를 적용하려면 몇가지 근사(approximation)가 필요하다.
∙ local self-attention 
∙ sparse attention
∙ 다양한 크기의 block에 scale attention 적용
이런 specialized attention구조들은 computer vision 분야에서 괜찮은 결과를 보여주지만 효율적 구현을 위해서는 복잡한 engineering이 필요하다.

- self-attention을 이용해 feature map을 augmentation하거나 CNN의 output에 attention을 추가적으로 사용하는 등 CNN과 self-attention을 융합하려는 많은 연구도 이루어 졌다.

- 본 연구와 가장 관련있는 모델은 Cordonnier2020논문에서 소개된 모델로 input image에서 2×2 크기의 patch를 추출하여 top에 full self-attention을 적용한다.  ViT와 비슷하지만 ViT는 더 추가적인 증명을 진행하는데, 대규모 pre-training은 평범한 transformer가 S.O.T.A와 경쟁력 있게 한다.
추가적으로 Cordonnier2020논문의 모델은 2×2 piexl이라는 작은 크기의 patch를 사용하는데, 이는 small-resolution image에만 적용가능하다는 단점이 존재한다. (우리는 medium-resolution image를 다루지만...)

- 최근의 또다른 관련있는 모델은 iGPT[Chen2020]로 iGPT는 image의 resolution과 color space를 줄인 후 pixel들에 transformer를 적용한 생성모델로써 "Unsupervised"방식으로 훈련되었고 이를 통해 얻어진 representation은 classification을 위해 전이학습이나 선형적으로 탐색될 수 있으며, 이를 예시로 활용 시 ImageNet에서 최대 정확도 72%로 나타난다.

- 본 연구는 추가적으로 기존 ImageNet보다 더 많은 image를 보유한 인식데이터셋을 활용한 연구의 연장선으로 CNN의 성능이 dataset size에 따라 어떻게 달라지는 지에 대한 연구와 대규모 dataset(ImageNet-21K, JFT-300M)에 대한 CNN의 전이학습에 대해 경험적탐구도 진행한다. (이전 연구와 달리 ResNet이 아닌 Transformer를 사용하여.)

3. Method

- model 설계에서 기존 Transformer[Vaswani2017]를 가능한 근접하게 구성했으며, 이는 쉽게 확장가능한 NLP transformer 구조에 대한 이점과 효율적인 구현이 가능하다는 이점이 되어 별도의 설정없이 바로 사용할 수 있게 된다.

3.1  Vision Transformer (ViT)
- 기존의 Transformer는 token embedding의 1D sequence를 input으로 받는다.

- BERT의 [CLS]token처럼 embedding된 patch들의 가장 앞에 하나의 learnable한 class token embedding vector를 추가한다.

- Position Embedding은 image의 위치정보를 유지하기 위해 patch embedding 시 trainable한 position embeddings가 더해진다.
image를 위해 개선된 2D-aware position embedding을 사용해 보았지만 1D Position Embedding과의 유의미한 성능향상이 없어서 "1D Position Embedding"을 사용한다. (Appendix D.4)
이렇게 embedding된 벡터들의 sequence를 encoder의 입력에 넣는다.

- Transformer의 Encoder부분은 Multi-Head Attention(식 2,3)층들과 MLP가 교차로 구성되는데, 이는 하나의 image이더라도 차원을 쪼갠 뒤 multi-head를 관찰하는 현상을 볼 수 있다.

3.2  Fine-tuning. &. Higher Resolution

 

4. Experiments

연구진들은 ResNet, ViT, 그리고 하이브리드 모델의 representation learning capabilities를 평가했다. 각 모델이 요구하는 데이터의 양상을 파악하기 위해 다양한 사이즈의 데이터셋으로 사전훈련을 진행했고 많은 벤치마크 테스크에 대해 평가 실시했다.
ViT가 모델의 사전훈련 연산 대비 성능 부분에서 다른 모델들보다 더 낮은 pre-training 비용으로 가장 높은 성능을 달성했다. 마지막으로 self-supervised를 이용한 작은 실험을 수행해 ViT가 self-supervised에서도 가능성이 있음을 보였다.

4.1  Setup
∙Datasets
- 모델 확장성(scalability)을 조사하기 위해
1,000개 class와 1.3M image가 있는 ILSVRC-2012 ImageNet dataset,
21,000 class와 14M image가 있는 superset ImageNet-21k(Deng2009),
18,000 class와 303M의 고해상도 image의 JFT(Sun2017)를 사용.

[Kolesnikov2020]에 이어 downstream task의 testset을 통해 pre-training dataset을 중복 제거.
이 dataset에 대해 훈련된 모델을 다음과 같은 여러 benchmark에 전이학습을 진행한다:
원본 유효성 검사 라벨과 정리된 ReaL 라벨의 ImageNet(Beyer2020), CIFAR-10/100(Krizhevsky2009), Oxford-IIIT Pets(Parkhi2012) 및 Oxford Flowers-102(Nilsback & Ziserman, 2008).
이때, dataset의 전처리과정은 [Kolesnikov2020]를 따른다.

- 또한 19개 작업 VTAB classification suite(Zhai 2019)에 대해서도 평가한다.
VTAB는 task당 1,000개의 training example들을 사용해 다양한 task에 대해 낮은 data transfer를 평가한다.
task는 3가지로 분류된다: Natural(Pets, CIFAR), Specialized(의료, 위성사진), Structured(localization같은 기하학적 이해가 필요한 작업)

∙Model Variants
- 표 1에 요약된 것처럼 BERT(Devlin 2019)에 사용된 ViT 구조를 기반으로 BERT에서 "Base" 및 "Large" 모델을 직접 채택하고 더 큰 "Huge" 모델을 추가한다. 후술에서는 모델의 크기와 입력 patch크기를 나타내기 위해 간략한 표기법을 사용.
ex) ViT-L/16은 16 × 16의 input patch size를 갖는 "Large" variant를 의미.
Transformer의 시퀀스 길이는 패치 크기의 제곱에 반비례하므로 패치 크기가 작은 모델은 계산 비용이 더 많이 든다.

- 기본 CNN의 경우 ResNet을 사용한다.
다만, Batch Normalization(Ioffe & Szegedy, 2015)대신 Group Normalization(Wu & He, 2018)으로 바꾸고 표준화된 Convolution(Qiao 2019)을 사용한다.
이 수정은 transfer를 개선하며[Kolesnikov2020], 이를 "ResNet(BiT)라 부른다.

hybrid 시, 우리는 중간 feature map을 하나의 "pixel"의 patch 크기로 ViT에 전달한다. 다른 시퀀스 길이를 실험하기 위해
(i) 일반 ResNet50의 4단계 output을 가져오거나
(ii) 4단계 제거, 3단계에 동일한 수의 레이어(총 레이어 수 유지)를 배치하고 이 확장된 3단계 출력을 가져온다.
이때, (ii)를 사용하면 sequence 길이가 4배 더 길어지고 ViT 모델의 비용이 더 많아진다.


∙Training. &. Fine-tuning
- ResNet을 포함, 모든 모델은 Adam(Kingma & Ba, 2015)을 사용한다. (β1 = 0.9, β2 = 0.999)
batch=4096으로 훈련하고 모든 모델의 transfer에 유용한 0.1이라는 높은 weight_decay를 적용한다.
(Appendix D.1은 일반적인 관행과 달리 Adam이 ResNets용 SGD보다 약간 더 잘 작동함을 보여준다).

linear Learning rate warmup과 decay를 사용한다. (detail은 Appendix B.1을 참조)
전이학습 시, 운동량이 있는 SGD, batch=512를 모든 모델에 대해 Appendix B.1.1에 소개된 것처럼 사용한다.
표 2의 ImageNet 결과의 경우 ViT-L/16의 경우 512, ViT-H/14의 경우 518로 미세 조정했으며 평균 계수 0.9999999로 [Polyak & Juditsky 1992]를 사용한다(Ramachan 2019, 2020).


∙Metric
- few-shot이나 전이학습 정확도를 통해 downstream dataset에 대한 결과에 대해 설명한다.
전이학습 정확도는 각 dataset서 전이학습한 이후 각 모델의 성능을 capture한다.
few-shot의 정확도는 train image의 표현을 {-1,1}K 표적 벡터에 매핑한 정규화된 최소 제곱 회귀(MLE) 문제를 해결하여 얻을 수 있다. 이 공식을 사용하면 폐쇄형(closed form)으로 정확한 솔루션을 복구할 수 있습니다.
주로 전이학습의 성능에 중점을 두지만, 전이학습비용이 너무 많이들어서 신속한 평가를 위해 선형 퓨샷 정확도를 사용하기도 한다.



4.2 Comparision to S.O.T.A 
- 먼저 가장 큰 모델인 ViT-H/14 및 ViT-L/16을 최신 CNN과 비교한다.
첫 번째 비교할 점은 대규모 ResNets로 감독된 전송 학습을 수행하는 Big Transfer(BiT)이다.
두 번째는 Noisy Student(Xie 2020)으로, 레이블이 제거된 상태에서 ImageNet 및 JFT-300M에서 준지도 학습을 사용하여 훈련된 대규모 EfficientNet이다.

- 표 2의 결과는 JFT-300M에서 pre-train된 작은 ViT-L/16 모델은 모든 작업에서 BiT-L을 능가하는 동시에 훈련에 훨씬 적은 계산 리소스를 필요로 함을 보여준다.
대형 모델인 ViT-H/14는 특히 ImageNet, CIFAR-100 및 VTAB suite 등 까다로운 dataset에서 성능을 더욱 향상시킨다.

흥미로운 점은, 이 모델은 이전기술보다 pre-train에 훨씬 적은 시간이 소요되었다.
하지만 pre-train의 효율성은 architecture의 선택뿐만 아니라 training schedule, optimizer, weight_decay 등 같은 다른 parameter에도 영향을 받을 수 있다는 점에 주목한다.
Section 4.4에서는 다양한 architecture에 대한 성능과 computing에 대해 제어된 연구를 제공한다.

- 마지막으로, ImageNet-21k dataset으로 pre-train된 ViT-L/16 모델은 대부분의 dataset에서도 우수한 성능을 발휘하면서 pre-train에 필요한 리소스는 더 적습니다. 약 30일 내에 8개의 코어가 있는 표준 클라우드 TPUv3를 사용하여 교육될 수 있다.

- 그림 2는 VTAB task를 각 그룹으로 분해하고, 이 benchmark의 이전 S.O.T.A 방법인 BiT, VIVI - ImageNet 및 Youtube에서 공동 교육된 ResNet(Tschannen 2020) 및 S4L - ImageNet에서 supervised 및 semi-supervised 학습(Zhai 2019)과 비교한다. ViT-H/14는 Natural 및 Structure task에서 BiT-R152x4 및 기타 방법을 능가하는데, Specialized에서 상위 두 모델의 성능은 유사하다.



4.3 Pre-training Data Requirements
- ViT는 대규모 JFT-300M dataset에서 pre-train 시 성능이 우수하며 ResNet보다 Inductive bias가 적다.
그렇다면 dataset의 크기는 얼마나 중요할까? 에 대해 2가지 실험을 진행한다.

 ① 크기가 증가하는 dataset에 대해 ViT 모델을 pre-train한다: ImageNet, ImageNet-21k 및 JFT-300M.
소규모 dataset의 성능을 향상시키기 위해 weight_decay, dropout, label-smoothing이라는 3가지 기본적인 Regularization parameter들을 최적화한다. 그림 3은 ImageNet을 pre-train된 결과를 보여준다
cf. (다른 dataset에 대한 결과는 표 5에 나와 있다).
ImageNet pre-train모델도 전이학습되어있으나 ImageNet에서는 다시 전이학습이 진행된다. (전이학습 시 해상도가 높아지면 성능이 향상되기 때문).
가장 작은 dataset인 ImageNet에서 pre-train 시, ViT-Large 모델은 (moderate) regularization에도 불구하고 ViT-Base 모델에 비해 성능이 떨어진다. JFT-300M만 있으면 더 큰 모델의 이점을 최대한 누릴 수 있는데, 그림 3은 또한 다양한 크기의 BiT 모델이 차지하는 성능 영역을 보여준다. BiT CNN은 ImageNet에서 ViT를 능가하지만 dataset이 클수록 ViT가 앞서는 것을 알 수 있다.

 
 ② 9M, 30M 및 90M의 랜덤 하위 집합과 전체 JFT-300M dataset에 대한 모델을 교육한다.
이때, 더 작은 하위 집합에 대해 추가적인 정규화를 수행하지 않고 모든 설정에 대해 동일한 hyper-parameter를 사용한다.
이 방식으로, regularization의 효과가 아니라 본질적인 모델 특성을 평가합니다.
하지만, Early Stop을 사용하고, training 중 달성한 최고의 validation accuracy를 알려준다.
계산을 절약하기 위해 전체의 전이학습 정확도 대신 few-shot linear accuracy를 알려주며, 이는 그림 4에는 결과가 나와 있다. ViT는 소규모 dataset에서 비슷한 계산 비용으로 ResNet보다 더 적합하다.
ex) ViT-B/32는 ResNet50보다 약간 빠르다.

9M 하위 집합에서는 성능이 훨씬 떨어지지만 90M+ 하위 집합에서는 성능이 더 우수한데, ResNet152x2 및 ViT-L/16에 대해서도 마찬가지이다. 이 결과는 Convolution의 Inductive Bias가 작은 dataset에 유용하다는 직관을 강화한다.
하지만, 큰 dataset의 경우 관련 패턴을 데이터에서 직접 학습하는 것만으로도 충분하고, 심지어 유용하다.




4.4. Scaling Study
- JFT-300M의 transfer 성능을 평가하여 다양한 모델에 대해 제어된 scaling 연구를 진행한다.
이 설정에서 데이터 크기는 모델의 성능에 병목 현상을 일으키지 않으며, 각 모델의 accuracy/pre-train cost를 평가한다.
model set은 다음과 같다.
- 7 epochs에 대해 사전훈련된 ResNets(R50x1, R50x2 R101x1, R152x1, R152x2, R152x2)
- 7 epochs에 대해 사전 훈련된 R16 및 R1450
- 14 epochs에 대해 사전 훈련된 R152x2 및 R200x3
- 14 epochs에 대해 사전 훈련된 ViT-B/32, B/16, L/32, L/16
- 14 epochs에 대해 사전 훈련된 R50+ViT-L/16
(hybrid의 경우 모델 이름 끝 숫자는 patch size가 아닌, ResNet 백본의 총 downsampling비율을 나타낸다).

- 그림 5에는 총 사전 교육 계산 대비 이전 성능이 나와 있다(compute detail: Appendix D.5 ; model별 detail: Appendix의 표 6).
이에 대해 몇 가지 패턴을 관찰할 수 있다:
i) ViT는 accuracy/computing 절충에서 ResNets를 압도한다. ViT는 동일한 성능을 얻기 위해 약 2~4배 적은 컴퓨팅을 사용한다(평균 5개 이상의 dataset).
ii) hybrid는 적은 computing으로 ViT를 약간 능가하나, 더 큰 모델에서는 그 차이가 사라진다.
이 결과는 Convolution의 local feature processing이 모든 크기에서 ViT를 지원할 것으로 예상할 수 있기 때문에 다소 놀라운 결과라 할 수 있다.
iii) ViT는 시도한 범위 내에서 포화되지 않는 것으로 나타나 향후 확장 노력에 동기를 준다.



4.5. Inspecting Vision Transformer
- ViT는 image data처리방법이해를 위해 internal-representation을 분석한다.
ViT의 첫층은 flattened patch를 낮은 차원의 공간(Eq.1)으로 linearly project한다.
그림 7(왼쪽)은 학습된 embedding filter의 주요 구성요소를 보여준다. 구성요소는 각 patch내 fine-structure를 낮은 차원으로 표현하기 위한 그럴듯한 기본함수와 유사하다.

- 투영한 후, 학습된 position embedding이 patch의 representation에 추가된다.
그림 7(가운데)은 모델이 position embedding의 유사성에서 image내 distance를 encoding하는 방법을 학습하는 것을 보여준다.
즉, 더 가까운 patch는 더 유사한 position embedding을 갖는 경향이 있다.

- 또한 행-열(row-column) 구조가 나타난다. 동일한 행/열에 있는 패치는 유사한 임베딩을 갖는다.

- 마지막으로, sin파의 구조는 때때로 더 큰 grid(Appendix D)에 apparent한데, position embedding이 2D-image topology를 표현하는 방법을 배운다는 것은 직접 설계된 2D-aware embedding이 개선되지 않는 이유를 설명한다.(Appendix D.4)

- Self-Attention을 통해 ViT는 전체적으로 정보를 통합할 수 있는데, 가장 낮은 층에서도 이미지를 생성할 수 있다. 연구자들은 신경망이 이 수용력을 어느정도까지 사용하는지 조사한다.
특히 attention weight를 기반으로 정보가 통합되는 image space의 average distance를 계산한다(그림 7, 오른쪽).
이 "attention distance"는 CNN의 receptive field size와 비슷하다.

- 연구자들은 일부 head가 이미 낮은 층에 있는 대부분의 image에 주목을 하는것을 발견, 정보를 global하게 통합하는 특징이 모델에 실제로 사용되는것을 보여준다. 다른 attention heads는 낮은 층에서 일관되게 attention distance가 작다. 이렇게 고도로 local하게 된 attention은 transformer(그림 7, 오른쪽)이전에 ResNet을 적용하는 hybrid 모델에서 덜 두드러지며, 이는 CNN의 초기 convolution층과 유사한 기능을 수행할 수 있음을 보여준다.
또한 신경망의 깊이에 따라 attention distance가 증가하는데, Global하게 모델이 clasification과 의미론적(semantically)으로 관련이 있는 image의 영역에 주목함을 발견할 수 있다. (그림 6).



4.6. Self-Supervision
- Transformer는 NLP 작업에서 인상적인 성능을 보여주지만, 그들의 성공의 대부분은 뛰어난 확장성뿐만 아니라 대규모 self-supervised pretraining(Devlin 2019; Radford 2018)에서 비롯됩니다. 또한 BERT에서 사용되는 masked language modeling task를 모방해 self-supervision을 위한 masked patch prediction에 대한 예비 탐색을 수행한다.
"Self-supervised pre-training"을 통해, 우리의 작은 ViT-B/16 모델은 ImageNet에서 79.9%의 정확도를 달성하고, 처음부터 교육에 대해 2%의 상당한 개선을 이루나, 여전히 supervised pre-training에 비해 4% 뒤떨어져 있습니다. Appendix B.1.2에는 추가 detail이 존재한다.

5. Conclusion

- 연구진들은 image 인식에 대한 transformer의 직접적인 적용을 탐구하며 이전의 연구들에서 computer vision에 "self-attention"을 사용한 것과 달리 초기 patch생성을 제외하고 image별 inductive biases를 architecture에 도입하지 않는다.
대신, image를 일련의 patch로 해석해 기본 Transformer의 Encoder로 처리한다.
이는 단순하지만 확장가능하기에 대규모 dataset에 대한 pre-train과 결합하게 되면 매우 잘 작동한다.
따라서 ViT는 많은 S.O.T.A모델과 비슷하거나 능가하지만 pre-train에 상대적으로 cheap하게 작동한다.

- 본 연구의 이런 시초적인 결과는 고무적이라 할 수 있으나 많은 과제가 여전히 남아있는데,
① Detection, Segmentation 등의 Computer Vision에 적용하는 것과
② "Self-Supervised pre-training"에 대한 방법을 찾는 것이다.
우리의 이 초기실험은 "Self-Supervised pre-training"에 개선을 보여주긴 하지만 대규모 "Supervised pre-training"보다는 여전히 큰 격차가 존재하기에 ViT의 추가적인 확장은 성능향상의 여지를 보여준다. 

😶 부록 (Appendix)

[A] Multi-Head Self Attention

[B] Experiment Details

이를 위해, training set의 작은 부분을 validation set으로 설정한다. (CIFAR은 2%, ImageNet은 1%)ResNet의 경우, [Kolesnikov2020]을 따르며 모든 fine-tuning 실험은 384 resolution에서 실행된다.
[Kolesnikov2020]에 따르면, training과 다른 resolution으로 fine-tuning을 하는 것이 일반적이다.

 

[C] Additional Results

 논문에 제시된 수치에 해당하는 세부 결과로 표 5는 논문의 그림 3에 해당하며 크기가 증가하는 dataset에서 사전 훈련된 다양한 ViT 모델의 전이학습 성능을 보여준다: ImageNet, ImageNet-21k 및 JFT-300M.
표 6은 논문의 그림 5에 해당하며 다양한 크기의 ViT, ResNet 및 하이브리드 모델의 전송 성능과 사전 교육의 예상 계산 비용을 보여준다.

[D] Additional Analyses

🤔 Transformer의 특성

📌 Long-Term Dependency (장기의존성)
- Convolution의 경우, 이웃 pixel과의 정보를 교환한다.
- 주로 3×3, 5×5의 작은 kernel을 사용하기에 영상 내 멀리 떨어진 물체간의 상호작용을 하려면 "Deep layer"가 필요하다.
예를 들어, 3×3kernel은 10만큼 떨어진 pixel의 경우, 4개의 층을 거쳐야 비로소 상호작용이 일어날 수 있다.

- Recurrent의 경우, 시간축을 따라 상호작용이 일어난다.
Convolution과 Recurrent는 모두 깊은 신경망으로 상호작용이 일어난다.
하지만 층이 깊어지면서 여러 요소간에 발생한 정보가 혼합되어 중요한 정보가 흐릿해진다.

- Transformer는 start-end까지 "Self-Attention"을 이용해 explicit하게 "Long-term dependency"를 처리한다.
즉, CNN과 RNN은 어느 순간의 이웃 요소만 교류하는 "Locality"를 벗어나지 못한다.
하지만 Transformer는 "Global"정보를 명시적으로 표현, 처리함과 동시에 "Locality Extraction"에도 능숙하다.
[Cordonnier2020; https://arxiv.org/abs/1911.03584]
ViT의 경우, "Self-Attention"을 통해 patch를 주목하게 하여 해결한다.

위의 예시를 보면, 16개의 head를 갖는 6개의 encoder block에 대해
"가운데의 pixel을 query로 사용해 각 head가 어디가 주목하는지" 표시한 그림이다.
- 왼쪽의 얕은 층에서는 query근처에 주목해 "Local 정보"를 추출
- 오른쪽(깊은 층)으로 갈수록 먼 곳까지 주목하는 현상을 확인할 수 있다.
 특히나 Layer 6에서는 head가 주목하는 곳을 달리해 image전체를 살피는 좋은현상이 나타난다.




📌 Scalability (뛰어난 확장성)
- model 및 dataset의 크기면에서 확장성(scalability)가 뛰어나다.
[Kaplan2020; https://arxiv.org/abs/2001.08361]의 연구는 큰 모델을 사용하는 것이 유리하다는 근거를 제시한다.
즉, model크기가 작으면 dataset을 확장하거나 학습시간을 늘려도 성능향상에 한계가 존재한다.

- 다만, NLP의 이런 분석이 CV에 그대로 적용되지는 않는다. 컴퓨터비전은 자율지도학습보다는 "지도학습"에 의존하는 경향이 크다. 따라서 사람이 labeling한 dataset에 영향을 더 많이 받는다.

- ViT의 경우, 모델크기를 다음과 같은 방식으로 키울 수 있다.
encoder block↑ , patch_size ↓ , head ↑, patch_encoding_dimension인 d_model을 늘리는 등의 방식으로 키울 수 있다.



📌 Explainability (뛰어난 설명가능성)
- 사람의 의사결정에 대한 이유를 설명해야 할 때, 이를 설명하는 능력이 뛰어나다.
transformer는 영상을 구성하는 pixel간의 "Self-Attention"을 명시적으로 표현하기에 설명가능한 능력을 구현하기 매우 유리하다. 예를 들어, Object Detection에 적용가능한 Transformer인 DETR의 경우, 박스를 지정할 때 Object Boundary에 "Attention"을 집중하는 것을 알 수 있다.

- 또한 CUB-200과 같은 미세분류 dataset에 대해 미세분류를 수행하는 TransFG라는 transformer model은 전체적인 모양이 비슷한 미세분류 dataset에 대해 "특정한 곳에 집중해 구별"하는 경우에 매우 잘 수행함을 알 수 있다.



📌 Multi-Modal (뛰어난 확장성)
- 모든 기계학습모델은 귀납편향(inductive bias)이 존재한다.
예를들어, CNN의 경우 이웃한 pixel과 비슷한 특성을 갖는다는 "locality"와 물체가 이동하면 이동한 위치에 동일한 특징이 추출된다는 "translation-equivalent" 등이 대표적이다. 
CNN의 경우 이런 귀납편향이 강한 편으로 이를 만족하지 못하는 자연어와 같은 다른 modality-data에 적용은 부자연스러운 결과가 나온다. (물론, RNN도 시간축과 관련된 강한 귀납편향을 갖는다.)
cf) 귀납편향: 기계학습모델이 학습단계에 보지않았던 새로운 sample로 옳게 추론하기 위해 사용하는 가정

- 하지만 transformer의 경우, 귀납편향이 약한 편으로 가장 중요하게 활용되는 "Self-Attention"은 image, text를 포함해 대부분의 signal에서 나타나서 여러 input형태 (multi-modal data)에 적용할 여지가 존재한다.
예를 들어 자연어->그림의 DALL-E 등등 vision과 NLP를 동시에 처리하는 여러 응용에서 backbone으로 활용할 수 있다.




📌 Foundation Model (토대 모델)
- 귀납편향이 강해 응용이 한정적인 CNN, RNN과 달리 귀납편향이 약한 transformer는 multi-modal dataset에 두루 적용가능하며 확장성과 성능이 뛰어나다는 점으로 토대 모델이 될 수 있었다.
최근에는 Florence라는 computer vision분야의 토대모델이 발표되었다.

[ViT : Vision Transformer] 

🧐  Computer Vision with Transformer
오랫동안 Convolution Neural Network는 Computer Vision에서 가장 성공한 model로 군림했다.
2017년, transformer의 공개 이후 이 둘을 접목하려는 시도가 이루어졌었다.
- 초기에는 CNN을 backbone으로 두고 transformer로 추출한 self-attention 정보를 보조로 사용하는 방식을 택하였다. ex) Attention augmented convolutional network [Bello2019; https://arxiv.org/abs/1904.09925]
구조는 다음과 같다.  기존 CNN: feature map을 생성, 다음 층으로 전달하는데 이때, self-attention으로 증강시킨 신경망에서는 feature map과 transformer의 MHA로 만든 feature map을 결합해 다음층으로 전달한다.

이후로도 여러 시도가 있었는데, Transformer를 backbone으로 하거나 Convolution을 아예 없애고 Attention만으로 구성하는 등 여러 시도가 있었는데, 그 시도의 대표적인 예시들이 아래 예시들이다.
∙ ViT [Dosovitskiy2021; https://arxiv.org/abs/2010.11929]
∙ DETR [Carion2020; https://arxiv.org/abs/2005.12872]
∙ SETR [Zheng2021; https://arxiv.org/abs/2012.15840]
∙ MOTR, TransTrack, TrackFormer [Zeng2021; https://arxiv.org/abs/2105.03247 , Sun2021; https://arxiv.org/abs/2012.15460 , Meinhardt2021; https://arxiv.org/abs/2101.02702]

최근에는 classification, detection, segmentation, tracking문제를 "하나의 모델"로 모두 해결하는 방식으로 진화했는데  Swin Transformer가 대표적이다. [Liu2021a; https://arxiv.org/abs/2103.14030]

cf. 최신연구결과를 정리한 survey paper
- [Han2022; https://arxiv.org/abs/2012.12556  ,  Khan2022; https://arxiv.org/abs/2101.01169]

앞서 언급한 것들처럼 computer vision에 적용된 transformer model을 통칭해 Vision Transformer라 부른다.


🧐  ViT : Transformer for classification 
ViT는 [Vaswani2017; https://arxiv.org/abs/1706.03762]에서 소개된 transformer구조를 최대한 그대로 따라 실험한다.
다만, 기존 transformer는 언어 번역 등의 목적을 위해 개발되었기에 문장은 단어가 순서대로 배열된 1차원 구조의 data이다.
따라서 ViT는 image의 pixel이 2차원 구조로 배열된 data이기에 transformer에 조금의 변형을 가미한다.

Classification Task에서는 image를 입력받아 class의 probability vector를 출력하는데, 이는 즉 [Vaswani]의 Transformer구조에서 Encoder부분만 있으면 된다.
- Encoder는 Decoder로 tensor를 전달하는 대신, 추출한 feature map을 class probability vector로 변환, output layer를 통해 출력하면 되기 때문이다.
- 따라서 전체적인 ViT의 구조는 아래와 같다.

위의 사진에서 알 수 있듯, encoder에 input tensor를 입력시의 과정은 다음과 같다.

<Encoder에 image를 입력하는 과정>
① image를 p×p개의 patch로 나눈다. 

② p²개의 patch를 일렬로 배치, 이어붙인다. 
ex) h×w×3라면 ①과 ②를 통해 p²×(h/p * w/p * 3)으로 변환된다.

③ pixel을 일렬로 이어 붙인 후 embedding진행 
ex) 3hw / p²차원의 벡터로 만든다.
또한 이 벡터를 embedding층으로 d_model차원으로 변환한다.
이 벡터(d_model)를 행에 쌓으면 p²×d_model크기의 행렬이 된다.

④ 위치 인코딩(Position Encoding)을 더해, Encoder로 입력한다.
ex) X = P+S라는 식을 적용할 수 있는데, 여기서 S는 p²×d_model의 행렬이고 P는 위치 인코딩 행렬이다.

지금까지 설명한 vision transformer는 class probability vector만 출력하면 되기에 가장 단순한 편에 속하며, DETR의 경우, 출력이 가변개수인 box이기에 Encoder와 Decoder를 모두 사용해야 한다.
또한 작은 dataset에 대해서는 transformer가 열등한 경향이 있기에 주의해서 사용해야한다.

😶 실습 _ by tensorflow

import os
import cv2
import math
import wandb
import shutil
import random
import numpy as np
import pandas as pd
import tensorflow as tf
import matplotlib.pyplot as plt

from tensorflow import keras
from tensorflow.keras.preprocessing.image import load_img
from tensorflow.keras.preprocessing.image import ImageDataGenerator

from tensorflow.keras.models import *
from tensorflow.keras.layers import *
from tensorflow.keras.losses import *
from tensorflow.keras.metrics import *
from tensorflow.keras.optimizers import *
from tensorflow.keras.activations import *

from tensorflow.keras.regularizers import *

from tensorflow.keras.callbacks import *
from tensorflow.keras.preprocessing import *

(x_train,y_train),(x_test,y_test)=keras.datasets.cifar10.load_data()

n_class=10                  			# 부류 수
img_siz=(32,32,3)
img_expanded_siz=(72,72,3)

patch_siz=6                 			# 패치 크기
p2=(img_expanded_siz[0]//patch_siz)**2 # 패치 개수
d_model=64                  			# 임베딩 벡터 차원
h=8                         			# 헤드 개수
N=6                         			# 인코더 블록의 개수

class Patches(Layer):
    def __init__(self, patch_size):
        super(Patches, self).__init__()
        self.p_siz = patch_size

    def call(self, img):
        batch_size = tf.shape(img)[0]
        patches = tf.image.extract_patches(images=img, sizes=[1,self.p_siz,self.p_siz,1], strides=[1,self.p_siz,self.p_siz,1], rates=[1,1,1,1], padding="VALID")
        patch_dims = patches.shape[-1]
        patches = tf.reshape(patches,[batch_size, -1, patch_dims])
        return patches

class PatchEncoder(Layer):
    def __init__(self, p2, d_model): # p2: 패치 개수(p^2)
        super(PatchEncoder, self).__init__()
        self.p2 = p2
        self.projection = Dense(units=d_model)
        self.position_embedding = Embedding(input_dim=p2, output_dim=d_model)

    def call(self,patch):
        positions = tf.range(start=0, limit=self.p2, delta=1)
        encoded = self.projection(patch) + self.position_embedding(positions)
        return encoded

def ViT_classifier():
    input = Input(shape=(img_siz))
    norm = Normalization()(input)
    exp = Resizing(img_expanded_siz[0],img_expanded_siz[1])(norm)
    
    x = RandomFlip('horizontal')(exp)
    x = RandomRotation(factor=0.02)(x)
    x = RandomZoom(height_factor=0.2, width_factor=0.2)(x)
    
    patches = Patches(patch_siz)(x)		# 패치 생성
    x = PatchEncoder(p2,d_model)(patches)	# 패치 인코딩

    for _ in range(N):			# 다중 인코더 블록
        x1 = LayerNormalization(epsilon=1e-6)(x)		# 층 정규화
        x2 = MultiHeadAttention(num_heads=h,key_dim=d_model//h,dropout=0.1)(x1,x1)			# MHA
        x3 = Add()([x2,x])		# 지름길 연결
        x4 = LayerNormalization(epsilon=1e-6)(x3)	# 층 정규화
        x5 = Dense(d_model*2,activation='relu')(x4)
        x6 = Dropout(0.1)(x5)
        x7 = Dense(d_model,activation='relu')(x6)   
        x8 = Dropout(0.1)(x7)        
        x = Add()([x8,x3])		# 지름길 연결
    
        x = LayerNormalization(epsilon=1e-6)(x)
        x = Flatten()(x)
        x = Dropout(0.5)(x)   
        x = Dense(2048,activation=tf.nn.gelu)(x)    
        x = Dropout(0.5)(x)
        x = Dense(1024,activation=tf.nn.gelu)(x)    
        x = Dropout(0.5)(x)    
        output = Dense(n_class,activation='softmax')(x)
        
        model = Model(inputs=input,outputs=output)
        return model 

    
model=ViT_classifier()
model.layers[1].adapt(x_train)
model.summary()


Model: "model_1"
__________________________________________________________________________________________________
 Layer (type)                   Output Shape         Param #     Connected to                     
==================================================================================================
 input_2 (InputLayer)           [(None, 32, 32, 3)]  0           []                               
                                                                                                  
 normalization_1 (Normalization  (None, 32, 32, 3)   7           ['input_2[0][0]']                
 )                                                                                                
                                                                                                  
 resizing_1 (Resizing)          (None, 72, 72, 3)    0           ['normalization_1[0][0]']        
                                                                                                  
 random_flip_1 (RandomFlip)     (None, 72, 72, 3)    0           ['resizing_1[0][0]']             
                                                                                                  
 random_rotation_1 (RandomRotat  (None, 72, 72, 3)   0           ['random_flip_1[0][0]']          
 ion)                                                                                             
                                                                                                  
 random_zoom_1 (RandomZoom)     (None, 72, 72, 3)    0           ['random_rotation_1[0][0]']      
                                                                                                  
 patches_1 (Patches)            (None, None, 108)    0           ['random_zoom_1[0][0]']          
                                                                                                  
 patch_encoder_1 (PatchEncoder)  (None, 144, 64)     16192       ['patches_1[0][0]']              
                                                                                                  
 layer_normalization_3 (LayerNo  (None, 144, 64)     128         ['patch_encoder_1[0][0]']        
 rmalization)                                                                                     
                                                                                                  
 multi_head_attention_1 (MultiH  (None, 144, 64)     16640       ['layer_normalization_3[0][0]',  
 eadAttention)                                                    'layer_normalization_3[0][0]']  
                                                                                                  
 add_2 (Add)                    (None, 144, 64)      0           ['multi_head_attention_1[0][0]', 
                                                                  'patch_encoder_1[0][0]']        
                                                                                                  
 layer_normalization_4 (LayerNo  (None, 144, 64)     128         ['add_2[0][0]']                  
 rmalization)                                                                                     
                                                                                                  
 dense_7 (Dense)                (None, 144, 128)     8320        ['layer_normalization_4[0][0]']  
                                                                                                  
 dropout_5 (Dropout)            (None, 144, 128)     0           ['dense_7[0][0]']                
                                                                                                  
 dense_8 (Dense)                (None, 144, 64)      8256        ['dropout_5[0][0]']              
                                                                                                  
 dropout_6 (Dropout)            (None, 144, 64)      0           ['dense_8[0][0]']                
                                                                                                  
 add_3 (Add)                    (None, 144, 64)      0           ['dropout_6[0][0]',              
                                                                  'add_2[0][0]']                  
                                                                                                  
 layer_normalization_5 (LayerNo  (None, 144, 64)     128         ['add_3[0][0]']                  
 rmalization)                                                                                     
                                                                                                  
 flatten_1 (Flatten)            (None, 9216)         0           ['layer_normalization_5[0][0]']  
                                                                                                  
 dropout_7 (Dropout)            (None, 9216)         0           ['flatten_1[0][0]']              
                                                                                                  
 dense_9 (Dense)                (None, 2048)         18876416    ['dropout_7[0][0]']              
                                                                                                  
 dropout_8 (Dropout)            (None, 2048)         0           ['dense_9[0][0]']                
                                                                                                  
 dense_10 (Dense)               (None, 1024)         2098176     ['dropout_8[0][0]']              
                                                                                                  
 dropout_9 (Dropout)            (None, 1024)         0           ['dense_10[0][0]']               
                                                                                                  
 dense_11 (Dense)               (None, 10)           10250       ['dropout_9[0][0]']              
                                                                                                  
==================================================================================================
Total params: 21,034,641
Trainable params: 21,034,634
Non-trainable params: 7
__________________________________________________________________________________________________

model.compile(optimizer=Adam(),loss='sparse_categorical_crossentropy',metrics=['accuracy'])

hist=model.fit(x_train,y_train,batch_size=128,epochs=100,validation_data=(x_test,y_test),verbose=1)

Epoch 93/100
391/391 [==============================] - 711s 2s/step - loss: 0.2404 - accuracy: 0.9194 - val_loss: 0.7578 - val_accuracy: 0.7829
Epoch 94/100
391/391 [==============================] - 710s 2s/step - loss: 0.2437 - accuracy: 0.9194 - val_loss: 0.7725 - val_accuracy: 0.7860
Epoch 95/100
391/391 [==============================] - 709s 2s/step - loss: 0.2327 - accuracy: 0.9227 - val_loss: 0.7490 - val_accuracy: 0.7898
Epoch 96/100
391/391 [==============================] - 711s 2s/step - loss: 0.2296 - accuracy: 0.9238 - val_loss: 0.7564 - val_accuracy: 0.7744
Epoch 97/100
391/391 [==============================] - 712s 2s/step - loss: 0.2274 - accuracy: 0.9245 - val_loss: 0.8361 - val_accuracy: 0.7784
Epoch 98/100
391/391 [==============================] - 709s 2s/step - loss: 0.2267 - accuracy: 0.9238 - val_loss: 0.7484 - val_accuracy: 0.7818
Epoch 99/100
391/391 [==============================] - 711s 2s/step - loss: 0.2237 - accuracy: 0.9265 - val_loss: 0.7732 - val_accuracy: 0.7809

result = model.evaluate(x_test, y_test)
print('정확률 =', result[1] * 100)


epoch = np.arange(1,101)
train_accuracy, val_accuracy = hist.history['accuracy'], hist.history['val_accuracy']
train_loss, val_loss = hist.history['loss'], hist.history['val_loss']


plt.subplot(121)
plt.plot(epoch, train_accuracy, 'b', marker='.', label='train_accuracy')
plt.plot(epoch, val_accuracy, 'r--', marker='.', label='valid_accuracy')
plt.title('Accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.grid()
plt.legend()


plt.subplot(122)
plt.plot(epoch, train_loss, 'b', marker='.', label='train_accuracy')
plt.plot(epoch, val_loss, 'r--', marker='.', label='valid_accuracy')
plt.title('Loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.grid()
plt.legend()

plt.show()




313/313 [==============================] - 2s 8ms/step - loss: 0.7732 - accuracy: 0.7809
정확률 : 78.09000015258789

[Transformer]

Attention is all you need[Vaswani2017; https://arxiv.org/abs/1706.03762]

위의 논문에서는 Convolution, Recurrent 등의 신경망의 구성요소를 모두 제거하고

"오로지 Attention만으로 신경망을 구현한다."

transformer가 한번에 처리하기에 이로 인해 순환신경망이 갖는 bottleneck문제를 해결할 수 있다.

🧐  기본적인 Architecture

<Encoder>
단어는 embedding을 통해 d차원의 embedding벡터로 표현된다. (논문에서는d= 512를 사용)
Inputs라는 부분에 입력이 되며, 이때 Sequential 구조가 아님을 알 수 있다.
즉, transformer는 모든 단어를 "한번에 입력"한다.
이렇게 "한번에 입력"받는 방식은 "Self-Attention"을 가능하게 한다.

{Positional Encoding}
단어의 위치정보를 보완하기 위해 positional encoding을 통해 "embedding벡터에 위치정보를 더한다".

{MHA : Multi-head Attention}
Encoder에 MHA(Multi-Head Attention)층과 FF(Feed Foward)층이 존재.
이때, MHA층은 "Self-Attention"을 수행한다!
- multi-head라는 말처럼 h개 head가 독립적으로 self-attention을 수행, 결과를 결합한다.
- MHA층의 출력은 FF층의 입력이 된다. (MHA->FF)
- 또한, FF(Feed Forward)층은 FC(Fully-Connected) layer로 이루어진다.

MHA층과 FF층 모두 Add&Norm을 적용한다.
- Add는 Shortcut Connection을
- Norm은 layer Normalization을 의미한다.
- Nx는 Encoder block이 N개 연결되었다는 것을 의미한다. (논문에서는 N=6을 사용)



<Decoder>
Encoder처럼 단어 embedding과 Positional Encoding을 통해 변환된 단어들이 "한번에 입력"된다.
예를들어, 한국어문장은 Inputs에, 영어문장은 Outputs에 입력된다.

- Decoder에는 ②~③에 표시된 2개의 MHA층과 FF층이 존재하며 출력에 Add&Norm을 적용한다.
- 이후 출력층은 "softmax"를 통해 확률벡터를 출력하며, 이런 Decoder block이 N개 연결되어 있다.

①~③은 3개의 MHA층으로 Attention을 담당하는 핵심요소이다.
- ①은 Encoder에서 입력문장을 구성하는 단어간의 Attention을 처리한다.
같은 문장을 구성하는 단어간의 Attention이기에 이를 "Self-Attention"이라 부른다.

- ② Masked MHA의 의미는 다음과 같다.
Decoder는 i일 때, 1, 2, ..., i-1까지만 관찰해야한다.
그렇기에 Mask를 사용해 i+1, i+2, ... 등을 감추어야(masked) 한다.

- ③은 Encoder가 처리한 입력과 Decoder가 처리하고있는 출력사이의 Attention을 다룬다.
따라서 ③은 "Self-Attention이 아니다!!"
이때, Encoder의 state벡터는 key와 value이고
Decoder의 state는 query로 작용하며 Encoder와 Decoder는 ③의 MHA를 통해 정보를 교환한다.


①과 ②로 표시한 MHA(Multi-Head Attention)층의 "Self-Attention"은 transformer의 main idea이다.

이제 전반적인 Transformer의 Architecture를 보았으니 좀 더 세부적으로 Encoder와 Decoder의 동작에 대해 설명하겠다.

[Encoder의 동작과정]

🧐  Input Embedding. &. Positional Encoding

encoder는 입력문장의 단어를 임베딩 후 d_model차원의 벡터로 변환한다. (논문에서는 d=512로 설정)
또한, 모든 단어를 "한번에 입력"하기 위해 문장을 T×d_model 크기의 S 행렬로 표현한다. (이때, T는 단어의 개수이다.)

행렬 S의 모든 행이 동시에 처리되서 순서정보를 신경망이 얻지 못할 가능성을 배제하기 위해 위치정보를 표현한 행렬 P를 S행렬에 더해 X행렬을 만들고 X를 신경망에 입력한다. 이때, 3가지 행렬 모두 같은 size를 갖는다.
이 과정을 "Positional Encoding"이라 한다.

위치행렬 P를 생성하는 여러 방법 중, 아래 식과 같은 sin, cos함수를 사용한다.

🧐  Self-Attention

X행렬에 대해 ①의 MHA로 "Self-Attention"을 수행한다.

"Self-Attention의 본질"

이때, query는 확장이 필요한데, 하나의 벡터 q로 표현하는 Bahdanau attention과 달리 Self-Attention에서는 query가 T개의 행을 갖는 행렬 Q가 되기에 확장된 query행렬은 다음과 같이 나타내며, 이때 Q, K, V는 모두 T×d_model크기의 행렬이고 이 식의 결과인 C도 T×d_model행렬이다.

"Self-Attention 구현의 가장 단순한 방법"은 바로 Q, K, V를 모두 X로 설정하고 위의 식을 적용하는 것이다.
하지만 transformer는 이런 단순한 방법이 아닌 query, key, value를 가중치 행렬 WQ, WK, WV를 이용해 X를 변환해 사용하며, 이때, QKT는 √d_key로 나누어 정규화를 거친다. 
이를 식으로 나타내면 아래와 같다.

X:  T × d_model 행렬
WQ:  d_model × d_key 행렬
WV:  d_model × d_value 행렬
Q, K: T × d_key 행렬
V:  T × d_value 행렬
(보통 d_model > d_value, d_key 로 설정한다.)

🧐  Multi-Head Attention

Architecture에서 ①로 표시한 MHA에는 여러 head가 있으며 각 head는 고유한 transform matrix WQ, WK, WV를 갖고 softmax식을 이용해 "Self-Attention"을 독립적으로 수행해 상호보완한다.
즉, 여러 head로 self-attention을 진행, 결과를 결합해 성능향상을 진행시킨다.

따라서 MHA의 동작을 아래와 같은 식으로 정의한다.

예를 들어보자.

이후 MHA를 통과한 C행렬은 Add&Norm층을 통과하는데, Skip connection과 Layer Normalization을 진행한다.
- Skip-connection: MHA층의 출력특징맵 C와 입력특징맵 X를 더하는 연산
- Layer Normalization: mini-batch를 구성하는 sample별로 특징맵의 분포가 N(0,1)이 되게하는 방법이다.

🧐 position-wise FeedForward layer

MHA에서 사용된 아래 식에 따라 출력한 X'을 입력으로 받아 X''을 출력한다.
아래 X''을 구하는 식을 보면 MLP를 구하는 방법처럼 linear transformation을 사용하는 것을 알 수 있다.

X와 X''은 모두 encoder의 최초 입력 X와 같이 Txd의 행렬이다.
이는 transformer가 신경망을 흐르는 tensor의 모양이 유지시켜 행렬연산이 원활히 이루어짐을 알 수 있다.


position-wise FF라 부르는 이유??

[Decoder의 동작과정]

encoder와 거의 비슷하게 동작하기에 다른 부분에 주안점을 두어 설명을 진행한다.

🧐  Masked Multi-Head Attention 층

Decoder에 ②로 표시된 Masked MHA층은 행렬일부를 마스크로 가린다는 점을 제외하면 ①의 MHA층과 같다. 
i = 1일 때, <SOS>를 입력하면 모델은 'That'을 예측하고
i = 2일 때, 'That'을 보고 'can't'를 예측하는 이런 방식을 재귀적으로 수행하는 자귀회귀방식을 적용해 언어번역을 진행한다.

다만, 학습단계는 추론단계와 상황이 다른데,
- 예측단계는 출력문장을 모른채 동작하지만
- 학습단계는 입출력문장이 모두 주어지고 자귀회귀방식을 사용가능하다.
(다만 교사강요; teacher forcing방식을 주로 사용한다.)
이는 잘못 예측했을 경우, 이후 단어는 계속 틀릴 가능성이 높기 때문이다.
교사강요에서는 '<SOS> That can't turn red by itself <EOS>'를 decoder에 한꺼번에 입력한다.


transformer도 교사강요로 학습을 수행하는데, 예측단계의 자기회귀를 모사한 "Masking"을 사용한다.

Masked MHA층은 이 행렬의 대각윗행렬의 모든 원소를 무한대에 가까운 음수로 설정하면, 이전에 나온 단어들에만 주목할 수 있게 되는데, 예를 들어보면 아래와 같다.

🧐 Encoder와 연결된 Multi-Head Attention 층 (Not Self-Attention)

위의 그림에서 ③으로 표시된 MHA층은 encoder와 decoder가 상호작용한다.
①: 이 MHA층은 입력문장내의 단어간의 Attention을 처리하는 "Self-Attention"이다.
②: 이 MHA층은 출력문장내의 단어간의 Attention을 처리하는 "Self-Attention"이다.
③: 이 MHA층은 Decoder로 입력된 문장의 단어가 Encoder로 입력된 문장의 단어에 주목할 정보를 처리한다.
"Self-Attention"이라는 점만 제외하고 모든 연산은 ①과 ②의 MHA층과 동일하다.

①에서의 식은 "Self-Attention"을 처리하기에 같은 문장에서 구한 행렬 X만 존재한다.
∴ query와 key, value 계산 시 모두 X를 사용한다.

하지만 ③의 MHA층은 encoder의 X와 decoder의 X가 존재한다.
이를 구별하기 위해 X_enc, X_dec라 할 때,  key와 value는 X_enc를 사용하고 query는 X_dec를 사용한다.
이를 통해 query가 key와 value에 주목하는 정도를 계산할 수 있으며 아래와 같이 나타낼 수 있다.

여기서 MHA층의 출력 행렬은 Architecture에서 볼 수 있듯 Add&Norm층, FC층, Add&Norm층을 거친 후 Linear와 softmax로 구성된 출력층으로 전달된다.

[구현을 통한 예시 증명과정]

import scipy.special as sp

# Self-Attention(single_head)
def self_attention(X, Wq, Wk, Wv, d_key):
    Q = np.matmul(X, Wq)
    K = np.matmul(X, Wk)
    V = np.matmul(X, Wv)
    
    QK = np.matmul(Q, np.transpose(K))
    a = sp.softmax(QK / np.sqrt(d_key), axis=1) # attention vector
    c = np.matmul(a, V) # context vector
    
    return Q, K, V, a, c
    
    
    X = [[0.0, 0.6, 0.3, 0.0],
     [0.1, 0.9, 0.0, 0.0],
     [0.0, 0.1, 0.8, 0.1],
     [0.3, 0.0, 0.6, 0.0],
     [0.0, 0.1, 0.0, 0.9]]
     

d_key = 2

Wq_1 = [[1,0],
      [1,0],
      [0,1],
      [0,3]]

Wk_1 = [[0,1],
      [1,0],
      [1,0],
      [0,2]]

Wv_1 = [[1,2],
      [0,1],
      [1,0],
      [0,0]]
      
Wq_2 = [[0,1],
      [0,3],
      [1,0],
      [1,0]]

Wk_2 = [[1,0],
      [1,2],
      [1,0],
      [0,1]]

Wv_2 = [[1,1],
      [0,0],
      [1,1],
      [1,0]]

Q1,K1,V1,A1,C1 = self_attention(X, Wq_1, Wk_1, Wv_1, d_key)
Q2,K2,V2,A2,C2 = self_attention(X, Wq_2, Wk_2, Wv_2, d_key)
C_concat = np.concatenate([C1, C2], axis=1)
Wo = [[0.1, 0.3, 0.5, 0.2],
      [0.1, 0.1, 0.0, 0.2],
      [0.2, 0.1, 0.6, 0.3],
      [0.5, 0.3, 0.1, 0.0]]
      
      
C = np.round(np.matmul(C_concat, Wo), 4)
C
array([[0.2738, 0.2756, 0.452 , 0.2934],
       [0.2362, 0.2629, 0.4152, 0.2847],
       [0.3769, 0.3007, 0.5142, 0.295 ],
       [0.3909, 0.3305, 0.5584, 0.3299],
       [0.3374, 0.2203, 0.412 , 0.216 ]])

[Attention의 배경]

🧐 고전적인 Attention Algorithm

1. Feature Selection
- feature selection은 유용한 특징을 남기고 나머지는 제거하는 방법이다.
여기서 유용한 특징이란 예를 들어 분별력이 강한 특징 등을 말한다.

- 즉, feature selection은 분별력이 높은 특징에 "주목(attention)"한다 해석할 수 있다.
매우 원시적인, primitive한 attention이라 생각할 수 있다.


2. Saliency map
- 사람이 feature를 설계하는 방식(color, 명암, 방향 등등으로 saliency map 즉, 돌출맵을 설계)
- 사람이 눈으로 바라보는 곳을 추적하는 장치를 사용해 saliency map dataset을 구축하고 모델을 학습시켰다.

🧐  Attention Algorithm with Deep Learning

0. Computer Vision에서 Attention의 발전과정

cf. SENet  (Squeeze-and-Excite Network)
Classification, Detection, Segmentation, Tracking 등의 신경망에 두루두루 적용할 수 있는데, 이는 dataset의 의도에 따라 attention이 적용되어 그에 맞게끔 학습이 되기 때문이다.

SENet은 feature map의 어떤 channel에 주목(Attention)할 지 알아낸다.
- Attention이 없는 기존의 신경망은 mxnxk feature map에 convolution을 적용해 X로 표기된 m'xn'xk' feature map을 만들어 다음 층에 전달한다.

- SENet은 Squeeze와 Excite, Scale연산을 추가로 적용해 X를 X'으로 변환해 다음 층에 전달한다.
이때, X'은 더 중요한 channel이 강조된 feature map이다.

<Squeeze>
- GAP을 적용해 각 channel의 pixel평균을 계산, z 벡터의 해당 원소에 저장한다.
- z는 k'개 원소를 갖는 벡터가 된다.

<Excite>
- 2개의 Fully-Connected layer를 이용해 z를 적당한 크기로 줄이고 기존 크기의 s벡터로 복원한다.
이때, 줄이는 층에는 U1, 늘리는 층에는 U2 이라는 "학습으로 알아낸" 가중치를 사용한다.

<Scale>
- s를 channel별로 중요한 정도를 나타내는 벡터로 여긴다.
즉, n번원소가 0.2이고 m번원소가 0.4라면 m이 2배 더 중요하다 여긴다.

📌 Self-Attention

- 앞선 attention은 image의 중요부분에 더 큰 weight를 줘서 성능을 개선한다.
즉, convolution층을 흐르는 feature map에 attention weight를 적용해 feature를 강조하거나 약화하는 것이다.

- Self-Attention은 image를 구성하는 element 상호 간의 attention을 결정한다.

위의 그림은 self-attention을 개념적으로 설명한다.
- Attention의 경우, a~c는 큰 가중치, d~e는 낮은 가중치로 feature를 강조,약화시켜 성능향상을 하지만
- Self_Attention의 경우, 원반이 다른 위치에 주목하는 정도에 대한 선의 굵기로 표현되어있는데, 이는 원반에 해당하는 영역이 원반을 잡으려하는 개와 사람에 많이 주목하고 하늘이나 땅에는 별로 주목(attention)하지 않는다.


cf. Non-local Network
Non-local Network는 self-attention을 computer vision에 처음 도입한 모델이다. [Wang2018; https://arxiv.org/abs/1711.07971]

- 이 신경망은 아래 식으로 self-attention을 계산한다.

- output feature map y은 input feature map x와 같은 크기이다.
- yi는 x의 모든 위치의 값인 g(xj)의 가중치의 합이다.
- weight f(xi, xj)는 xi가 xj에 얼마나 주목해야하는지 나타내는 값이다.
즉, 위의 그림에서 빨간색 선의 굵기가 가중치에 해당한다.

- 보통 위의 식은 연산량이 많아서 convolution이 여러번 거친 후 7x7처럼 작아진 feature map에 적용한다.

이후 Transformer의 등장으로 아래와 같이 다양한 transformer model들이 등장한다.

∙Classification을 위한 ViT

∙Detection을 위한 DETR

∙Segmentation을 위한 SETR

∙Tracking을 위한 MOTR

📌 같은 구조의 Transformer로 위의 task들을 한번에 푸는 Swin

자연어의 경우, 단어가 나타나는 순서가 중요해서 시간개념이 중요하다.

[RNN과 LSTM] _ NLP

🧐  RNN (Recurrent Neural Network)

일반적으로 i의 단어는 그 이전에 발생한 i-1개 단어와 상호작용한다.

🧐  Long Term Dependency과  LSTM(Long Short-Term-Memory)

Long Range Dependency : RNN은 시간을 처리할 수 있는 능력을 갖추지만 길이가 긴 sample에는 한계가 있다.
hi는 1, 2, ..., i 순간에 발생하는 단어의 정보가 혼합되기에 오래된 단어의 정보는 희미해진다.
즉, 앞쪽단어와 멀리있는 단어가 밀접하게 상호작용하는 long-range dependency를 제대로 처리하지 못하는 문제가 발생한다.

LSTM : RNN을 개조해 long-term dependency를 처리하는 능력을 강화한다.
input과 output을 열거나 막는 gate를 두어 선별적으로 기억하는 기능으로 여닫는 정도를 조절한다.
이때, 여닫는 정도는 학습으로 알아낸 가중치로 결정된다.

[seq2seq ] _ NLP

🧐  seq2seq

seq2seq : Sequence to Sequence[Sutskever2014; https://arxiv.org/abs/1409.3215]의 혁신성은 "가변길이의 문장을 가변길이의 문장으로 변환"할 수 있다는 것이다.

ex) 한국어→영어로 번역 시, 둘의 문장길이가 달라 seq2seq model이 필요하다.

- 학습 시 Decoder의 input부분과 output부분이 모두 동작한다. 
즉, 정답에 해당하는 출력을 알려주는 교사강요(teacher forcing)방법을 사용한다.

- 예측 시 정답을 모르기 때문에  위의 회색표시한 input 부분을 제외하고 자기회귀(auto-regressive) 방식으로 동작한다.
자기회귀에서 <SOS>가 입력되면 첫 단어 'That'을 출력하고 'That'을 보고 그 다음 둘째 단어 'can't'를 출력한다.
즉, 이전에 출력된 단어를 보고 현재단어를 출력하는 일을 반복하며, 문장끝을 나타내는 <EOS>가 발생하면 멈춘다.


- 한계 : 가장 큰 문제는 encoder의 마지막 hidden state만 decoder에 전달한다는 점이다.
그림에서 보면 h5만 decoder로 전달된다.
따라서 encoder는 마지막 hidden state에 모든 정보를 압축해야하는 부담이 존재한다.

[query-key-value로 계산하는 attention] _ NLP

🧐  query-key-value

QKV : attention을 계산하는 방법을 여러가지인데, 최근에는 query가 key와 유사한 정도를 측정하고 유사성 정보를 가중치로 사용해 value를 가중합하는 방법을 주로 사용한다.

ex) f(xi, xj)의 xi와 xj가 query와 key에 해당하고, g(xj)가 value에 해당한다.

query와 key의 유사도 벡터 s는 벡터의 내적으로 계산한다 가정하며
attention 벡터 a는 유사도벡터 s에 softmax를 적용한 벡터이다.
이때, s = (s1, s2, s3, s4)이고 a = (0.1895, 0.1843, 0.4419, 0.1843)이 된다.

이제 a를 가중치로 사용해 value의 가중합을 구하면 context 벡터 c는
c = 0.1895*(1 2 5) + 0.1843*(1 1 5) + 0.4419*(3 2 4) + 0.1843*(6 1 2)
   = (2.8053  1.6314  4.0052).

벡터의 차원을 d라 하면, q는 1xd행렬이고 K와 V는 nxd행렬이다.
이때, n은 key와 value가 갖는 벡터의 개수이다.

[seq2seq  with Attention] _ NLP

seq2seq는 입력문장의 모든 정보를 encoder의 마지막 hidden state h5에 압축해 넣어야하는 부담이 있다.
Bahdanau는 아래 식의 attention을 이용해 decoder가 encoder의 모든 state(h1, h2, ... , h5)에 접근할 수 있게 허용하여 성능을 향상한다.[Bahdanau2014; https://arxiv.org/abs/1409.0473]

🧐 Bahdanau Attention

위의 seq2seq의 경우, decoder는 i=6일 때, encoder가 i=2일 때, 단어 '저절로'에 주목해야 'itself'라는 단어를 제대로 생성할 수 있다.
decoder가 i=6일 때, (.01  .9  .02  .03  .04)처럼 2번째 원소값이 큰 attention vector a를 생성하면 encoder의 두번째 단어 '저절로'에 더 주목할 수 있어 성능이 향상될 수 있다.

- 이에 대해 query, key, value가 무엇이 되어야 위와 같이 될 수 있는지 살펴보자.

Contents

1. Introduction

2. Convolution Arithmetic

3. Pooling Arithmetic

4. Transposed(Atrous) Convolution Arithmetic

5. Miscellaneous Convolutions

😶 초록 (Abstract)

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

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

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

1. 서론 (Introduction)

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

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

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

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

2. Related work

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

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

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

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

3. DropBlock

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

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

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



• Setting the value of block_size



•Setting the value of  𝛾

 •Scheduled DropBlock

4. Experiments

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

4.1  ImageNet Classification

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

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

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

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

 4.1.1  DropBlock in ResNet-50

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

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

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

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

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

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

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


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


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


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


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

 4.1.2  DropBlock in AmoebaNet

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

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

4.2  Experimental Analysis

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

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

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

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

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

 • DropBlock drops more semantic information

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

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

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

 • Model trained with DropBlock is more robust

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

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

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

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

 

• DropBlock learns spatially distributed representations

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

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

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

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

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

4.3  Object Detection in COCO

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


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

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

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

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

4.4 Semantic Segmentation in PASCAL VOC

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

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

5. Discussion

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

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

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

"DropBlock: A regularization method for convolutional networks"

[핵심 개념]

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

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

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

import tensorflow as tf

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

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

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

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

        return inputs

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

😶 초록 (Abstract)

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

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

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

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

1. 서론 (Introduction)

2. Analysis of Deep Residual Networks

• Discussions

3. On the Importance of Identity Skip Connections

3.1  Experiments on Skip Connections  

 • Constant scaling

 • Exclusive gating

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

 • Shortcut-only gating

 



• 1x1 convolutional shortcut

 • Dropout Shortcut

3.2   Discussions

4. On the Usage of Activation Functions

4.1  Experiments on Activation

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

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


 •BN after addition



 • ReLU before addition

 • Post-activation or Pre-activation ?