Vision Transformer(ViT) 논문 완벽 분석: 이미지 한 장은 16x16 단어의 가치가 있다

• 1. 논문 개요
• 2. 배경: CNN이 지배하던 Computer Vision
  • 2.1 Convolutional Neural Network의 황금기
  • 2.2 NLP에서의 Transformer 혁명
  • 2.3 Vision에 Transformer를 적용하려는 시도들
• 3. 핵심 아이디어: 이미지를 패치 시퀀스로 변환하기
  • 3.1 왜 이미지를 직접 Transformer에 넣을 수 없는가
  • 3.2 패치로 분할하여 시퀀스 길이 줄이기
  • 3.3 NLP와의 대응 관계
• 4. 아키텍처 상세 분석
  • 4.1 전체 파이프라인 개요
  • 4.2 Patch Embedding: 이미지를 토큰으로
    • 4.2.1 패치 분할과 평탄화
    • 4.2.2 Linear Projection
  • 4.3 [CLS] Token과 Classification Head
    • 4.3.1 [CLS] Token
    • 4.3.2 Classification Head
  • 4.4 Position Embedding: 위치 정보 주입
    • 4.4.1 왜 Position Embedding이 필요한가
    • 4.4.2 1D Learnable Position Embedding
  • 4.5 Transformer Encoder
    • 4.5.1 구조
    • 4.5.2 Multi-head Self-Attention (MSA)
    • 4.5.3 MLP (Feed-Forward Network)
• 5. 수학적 분석: 패치에서 예측까지
  • 5.1 입력 처리
  • 5.2 Transformer Encoder
  • 5.3 출력
  • 5.4 계산 복잡도 분석
• 6. 모델 변형: ViT-Base, Large, Huge
  • 6.1 패치 크기에 따른 변형
  • 6.2 Hybrid 모델
• 7. 학습 전략
  • 7.1 사전 학습 (Pre-training)
  • 7.2 미세 조정 (Fine-tuning)
  • 7.3 학습 비용
• 8. 실험 결과
  • 8.1 주요 벤치마크 결과
  • 8.2 VTAB 벤치마크
  • 8.3 사전 학습 데이터 규모와 성능의 관계
• 9. 핵심 발견과 통찰
  • 9.1 Inductive Bias의 양날의 검
  • 9.2 Attention Map 시각화
    • 9.2.1 Position Embedding 유사도
    • 9.2.2 Attention Distance
  • 9.3 Representation 품질 분석
• 10. PyTorch 핵심 구현
  • 10.1 Patch Embedding
  • 10.2 Multi-head Self-Attention
  • 10.3 Transformer Encoder Block
  • 10.4 전체 ViT 모델
  • 10.5 사용 예시
• 11. 후속 연구 총정리
  • 11.1 DeiT: Data-efficient Image Transformers (2020.12)
  • 11.2 Swin Transformer (2021.03)
  • 11.3 BEiT: BERT Pre-Training of Image Transformers (2021.06)
  • 11.4 MAE: Masked Autoencoders (2021.11)
  • 11.5 DINO / DINOv2 (2021.04 / 2023.04)
  • 11.6 EVA / EVA-02 (2022 / 2023)
  • 11.7 ConvNeXt: CNN의 반격 (2022.01)
• 12. ViT vs CNN vs Hybrid 비교
  • 12.1 종합 비교 표
  • 12.2 태스크별 권장 아키텍처 (2026년 기준)
• 13. Computer Vision의 미래: Foundation Models
  • 13.1 Vision Foundation Model의 등장
  • 13.2 앞으로의 연구 방향
  • 13.3 ViT의 역사적 의의
• 14. References

1. 논문 개요

"An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale"은 2020년 10월 Google Research의 Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov 등이 발표하고, ICLR 2021에서 공식 채택된 논문이다. 이 논문은 NLP에서 압도적 성공을 거둔 Transformer 아키텍처를 거의 수정 없이 Computer Vision의 이미지 분류 태스크에 직접 적용할 수 있음을 증명했다.

핵심 아이디어는 놀라울 정도로 단순하다. 이미지를 고정 크기의 패치(patch)로 분할하고, 각 패치를 NLP에서의 토큰(token)처럼 취급하여 표준 Transformer Encoder에 입력하는 것이다. 논문 제목 자체가 이를 직관적으로 설명한다 -- 이미지 한 장은 16x16 크기의 단어들로 이루어져 있다.

결과는 파괴적이었다. JFT-300M이라는 대규모 데이터셋에서 사전 학습한 ViT-H/14 모델은 ImageNet에서 88.55% top-1 accuracy를 달성하며, 기존 CNN 기반 SOTA(State-of-the-Art)인 BiT(Big Transfer)와 Noisy Student를 능가했다. 더 중요한 것은, 이를 달성하는 데 필요한 학습 비용이 기존 방법 대비 크게 적었다는 점이다.

이 논문은 Computer Vision 분야에 일종의 패러다임 전환(paradigm shift)을 촉발했다. ViT 이후 DeiT, Swin Transformer, BEiT, MAE, DINO 등 무수히 많은 후속 연구가 쏟아졌고, "Vision Transformer"라는 새로운 연구 분야가 탄생했다.

2. 배경: CNN이 지배하던 Computer Vision

2.1 Convolutional Neural Network의 황금기

2012년 AlexNet의 ImageNet Challenge 우승 이후, CNN은 Computer Vision의 사실상 유일한 아키텍처였다. VGGNet(2014), GoogLeNet/Inception(2014), ResNet(2015), DenseNet(2017), EfficientNet(2019)으로 이어지는 계보는 모두 Convolution 연산을 핵심으로 공유한다.

CNN이 Vision 태스크에서 성공할 수 있었던 근본적인 이유는 두 가지 **Inductive Bias(귀납적 편향)**에 있다.

첫째, Locality(지역성). Convolution Filter는 입력의 국소적 영역만을 처리한다. 이미지에서 인접한 픽셀들이 강한 상관관계를 갖는다는 사실을 아키텍처 수준에서 내장한 것이다.

둘째, Translation Equivariance(이동 등변성). 동일한 필터가 이미지의 모든 위치에 공유되어 적용되므로, 객체가 이미지 내 어디에 위치하든 동일한 특징을 추출할 수 있다.

이 두 가지 편향 덕분에 CNN은 상대적으로 적은 데이터로도 효과적으로 시각적 패턴을 학습할 수 있었다.

2.2 NLP에서의 Transformer 혁명

2017년 "Attention Is All You Need" 논문이 발표된 이후, NLP 분야는 완전히 바뀌었다. BERT(2018), GPT-2(2019), T5(2019), GPT-3(2020)로 이어지는 Transformer 기반 모델들은 거의 모든 NLP 벤치마크를 석권했다.

Transformer의 핵심 강점은 다음과 같다.

• Self-Attention을 통한 Global Receptive Field: 시퀀스 내 임의의 두 위치 간 직접적인 상호작용이 가능하다
• 뛰어난 병렬 처리: RNN과 달리 시퀀스의 모든 위치를 동시에 처리할 수 있다
• 탁월한 확장성(Scalability): 모델 크기와 데이터를 늘릴수록 성능이 꾸준히 향상되는 Scaling Law를 보인다

2.3 Vision에 Transformer를 적용하려는 시도들

ViT 이전에도 Vision에 Attention 메커니즘을 도입하려는 시도는 있었다. 대표적으로 다음과 같다.

• Non-local Neural Networks (Wang et al., 2018): CNN 내부에 Self-Attention 블록을 삽입하여 Long-range Dependency를 포착
• Stand-Alone Self-Attention (Ramachandran et al., 2019): Convolution을 Local Self-Attention으로 대체
• DETR (Carion et al., 2020): Object Detection에서 Transformer Decoder를 활용

하지만 이들은 모두 CNN과 Attention을 **혼합(hybrid)**하거나, 특수하게 설계된 Attention을 사용했다. ViT의 혁신은 이런 타협 없이, 표준 Transformer를 최소한의 수정으로 Vision에 직접 적용했다는 데 있다.

3. 핵심 아이디어: 이미지를 패치 시퀀스로 변환하기

3.1 왜 이미지를 직접 Transformer에 넣을 수 없는가

표준 Transformer는 1D 토큰 시퀀스를 입력으로 받는다. 이미지를 픽셀 단위로 Transformer에 입력한다고 가정해보자. 224x224 해상도의 이미지는 50,176개의 픽셀을 갖는다. Self-Attention의 계산 복잡도는 시퀀스 길이 $N$에 대해 $O(N^2)$이므로, 50,176개의 토큰에 대한 Self-Attention은 약 25억 번의 연산을 요구한다. 이는 현실적으로 불가능하다.

3.2 패치로 분할하여 시퀀스 길이 줄이기

ViT의 해법은 우아하면서도 직관적이다. 이미지를 고정 크기의 패치(patch)로 분할하고, 각 패치를 하나의 토큰으로 취급하는 것이다.

224x224 이미지를 16x16 크기의 패치로 분할하면, 패치의 수는 다음과 같다.

50,176개의 픽셀 대신 196개의 패치 토큰만 처리하면 된다. Self-Attention 복잡도는 $196^2 = 38,416$으로, 픽셀 단위 대비 약 65,000배 감소한다.

이 변환의 핵심 전제는 다음과 같다: 하나의 16x16 패치는 NLP에서의 하나의 단어(word)와 동등한 의미 단위로 기능할 수 있다. 마치 자연어가 단어라는 이산적 토큰의 시퀀스인 것처럼, 이미지도 패치라는 시각적 토큰의 시퀀스로 표현할 수 있다는 것이다.

3.3 NLP와의 대응 관계

이 대응 관계가 ViT의 전부라 해도 과언이 아니다. NLP Transformer의 검증된 구조를 최소한의 변경으로 그대로 가져온 것이 ViT의 본질이다.

4. 아키텍처 상세 분석

4.1 전체 파이프라인 개요

ViT의 전체 처리 과정은 다음과 같다.

1. 입력 이미지를 고정 크기 패치로 분할
2. 각 패치를 1D 벡터로 평탄화(flatten)
3. Linear Projection으로 패치 벡터를 D차원 Embedding으로 변환
4. 학습 가능한 [CLS] 토큰을 시퀀스 앞에 추가
5. Position Embedding을 더해 위치 정보 주입
6. 표준 Transformer Encoder에 입력
7. [CLS] 토큰의 최종 출력으로 분류 수행

입력 이미지 (224x224x3)
     |
     v
패치 분할 (196개의 16x16x3 패치)
     |
     v
Flatten (196개의 768차원 벡터)
     |
     v
Linear Projection (196개의 D차원 Embedding)
     |
     v
[CLS] Token Prepend (197개의 D차원 벡터)
     |
     v
Position Embedding 더하기 (197개의 D차원 벡터)
     |
     v
Transformer Encoder (L개의 블록)
     |
     v
[CLS] Token 출력 추출
     |
     v
Classification Head (MLP) → 클래스 예측

4.2 Patch Embedding: 이미지를 토큰으로

4.2.1 패치 분할과 평탄화

입력 이미지 $\mathbf{x} \in \mathbb{R}^{H \times W \times C}$를 $P \times P$ 크기의 패치로 분할한다. 각 패치는 $\mathbf{x}_p^i \in \mathbb{R}^{P^2 \cdot C}$로 평탄화된다.

예를 들어, 224x224x3(RGB) 이미지를 16x16 패치로 분할하면:

• 패치 개수: $N = 224^2 / 16^2 = 196$
• 각 패치의 평탄화 벡터 차원: $P^2 \cdot C = 16 \times 16 \times 3 = 768$

4.2.2 Linear Projection

평탄화된 각 패치 벡터에 학습 가능한 Linear Projection $\mathbf{E} \in \mathbb{R}^{(P^2 \cdot C) \times D}$를 적용하여 D차원 Embedding 공간으로 매핑한다.

여기서 $D$는 Transformer의 Hidden Dimension이다. ViT-Base의 경우 $D = 768$이므로, 이 경우 Linear Projection은 768x768 행렬이 된다.

흥미로운 점은 이 Linear Projection이 사실상 stride가 patch size와 같은 Convolution 연산과 동치(equivalent)라는 것이다. 즉, Conv2d(in_channels=3, out_channels=D, kernel_size=P, stride=P)와 수학적으로 동일하다. 실제 구현에서도 이 방식이 더 효율적이므로 Convolution으로 구현하는 것이 일반적이다.

4.3 [CLS] Token과 Classification Head

4.3.1 [CLS] Token

BERT에서 차용한 개념으로, 학습 가능한 특수 토큰 $\mathbf{z}_0^0 = \mathbf{x}_{\text{class}}$를 패치 Embedding 시퀀스의 맨 앞에 추가한다.

이 [CLS] 토큰은 Transformer의 Self-Attention을 통해 모든 패치 토큰과 상호작용하면서, **전체 이미지의 글로벌 표현(global representation)**을 학습하게 된다. Transformer Encoder의 최종 레이어에서 이 [CLS] 토큰의 출력 $\mathbf{z}_L^0$이 이미지 전체를 대표하는 벡터로 사용된다.

4.3.2 Classification Head

사전 학습(pre-training) 단계에서는 [CLS] 토큰 출력에 1개의 Hidden Layer가 있는 MLP Head를 연결한다. 미세 조정(fine-tuning) 단계에서는 단일 Linear Layer만 사용한다.

논문에서는 [CLS] 토큰 대신 패치 토큰들의 **Global Average Pooling(GAP)**을 사용하는 방법도 실험했으나, [CLS] 토큰과 유사한 성능을 보였다고 보고했다. [CLS] 토큰을 기본으로 채택한 이유는 NLP Transformer와의 일관성을 유지하기 위해서다.

4.4 Position Embedding: 위치 정보 주입

4.4.1 왜 Position Embedding이 필요한가

Self-Attention은 본질적으로 **순서 불변(permutation invariant)**하다. 입력 토큰의 순서를 바꿔도 출력이 동일하게 재배열될 뿐이다. 하지만 이미지에서 패치의 공간적 위치는 중요한 정보다. 이미지 왼쪽 상단의 패치와 오른쪽 하단의 패치는 서로 다른 공간적 의미를 가진다.

4.4.2 1D Learnable Position Embedding

ViT는 학습 가능한 1D Position Embedding $\mathbf{E}_{pos} \in \mathbb{R}^{(N+1) \times D}$를 사용한다. 여기서 $N+1$은 [CLS] 토큰을 포함한 전체 시퀀스 길이다.

논문에서 2D Position Embedding(패치의 행/열 위치를 개별적으로 인코딩)과의 비교 실험을 수행했는데, 1D와 2D Position Embedding 사이에 유의미한 성능 차이가 없었다. 이는 ViT가 1D Position Embedding으로부터 2D 공간 구조를 스스로 학습할 수 있음을 시사한다.

실제로 학습된 Position Embedding을 시각화하면(논문 Figure 7), 공간적으로 가까운 패치들의 Position Embedding이 높은 코사인 유사도를 보이며, 행과 열 구조가 자연스럽게 나타난다. 이는 모델이 데이터로부터 2D 위치 관계를 자동으로 학습했음을 보여주는 인상적인 결과다.

4.5 Transformer Encoder

4.5.1 구조

ViT는 표준 Transformer Encoder를 그대로 사용한다. 각 블록은 다음과 같은 구조를 갖는다.

여기서:

• LN: Layer Normalization (Pre-norm 방식, 원래 Transformer의 Post-norm과 다름)
• MSA: Multi-head Self-Attention
• MLP: Feed-Forward Network
• Residual Connection: 각 하위 블록의 출력에 입력을 더함

ViT가 원래 Transformer와 다른 점은 Pre-norm을 채택했다는 것이다. 원래 "Attention Is All You Need"에서는 Layer Normalization이 Sub-layer 출력 이후에 적용되었지만(Post-norm), ViT는 Sub-layer 입력 전에 적용한다(Pre-norm). Pre-norm은 학습 안정성이 더 높은 것으로 알려져 있다.

4.5.2 Multi-head Self-Attention (MSA)

MSA는 입력을 $h$개의 Head로 분할하여 독립적으로 Self-Attention을 수행한 후 결합한다.

각 Head의 차원은 $d_k = D / h$이다. ViT-Base에서 $D = 768$, $h = 12$이므로 $d_k = 64$이다.

4.5.3 MLP (Feed-Forward Network)

MLP는 두 개의 Linear Layer와 GELU 활성화 함수로 구성된다.

Hidden Dimension은 일반적으로 Embedding Dimension $D$의 4배($4D$)로 설정된다. ViT-Base의 경우 $768 \times 4 = 3072$이다.

원래 Transformer에서 사용한 ReLU 대신 GELU(Gaussian Error Linear Unit)를 사용한 것은 BERT의 설계를 따른 것이다.

5. 수학적 분석: 패치에서 예측까지

전체 과정을 수학적으로 정리하면 다음과 같다.

5.1 입력 처리

이미지 $\mathbf{x} \in \mathbb{R}^{H \times W \times C}$가 주어지면:

Step 1. 패치 분할 및 평탄화:

Step 2. Patch Embedding + [CLS] Token + Position Embedding:

여기서 $\mathbf{E} \in \mathbb{R}^{(P^2 C) \times D}$, $\mathbf{E}_{pos} \in \mathbb{R}^{(N+1) \times D}$

5.2 Transformer Encoder

Step 3. $L$개의 Transformer 블록 반복:

5.3 출력

Step 4. [CLS] 토큰 출력으로 분류:

5.4 계산 복잡도 분석

시퀀스 길이 $N$, Embedding 차원 $D$에 대한 주요 연산의 복잡도는 다음과 같다.

시퀀스 길이 $N$에 대한 $O(N^2)$ 복잡도가 ViT의 해상도 확장성을 제한하는 핵심 병목이다. 이것이 이후 Swin Transformer 등이 Windowed Attention을 도입한 동기다.

6. 모델 변형: ViT-Base, Large, Huge

ViT는 BERT의 설계 규약을 따라 세 가지 크기의 모델을 정의했다. 모델 이름의 슬래시 뒤 숫자는 패치 크기를 나타낸다 (예: ViT-B/16은 16x16 패치 사용).

6.1 패치 크기에 따른 변형

동일한 아키텍처라도 패치 크기에 따라 성능과 계산량이 크게 달라진다.

패치 크기가 작을수록 더 세밀한(fine-grained) 시각적 정보를 포착할 수 있지만, 시퀀스 길이가 증가하여 계산 비용이 $O(N^2)$으로 급증한다. ViT-H/14의 14x14 패치가 ViT-B/32의 32x32 패치보다 약 27배 긴 시퀀스를 생성한다.

6.2 Hybrid 모델

논문에서는 CNN과 Transformer를 결합한 Hybrid 모델도 실험했다. ResNet의 중간 Feature Map을 패치 Embedding 대신 사용하는 방식이다. 예를 들어, ResNet-50의 stage 4 출력(14x14 Feature Map)을 1x1 패치로 취급하여 Transformer에 입력한다.

실험 결과, 사전 학습 데이터가 적을 때는 Hybrid 모델이 순수 ViT보다 우수했지만, 데이터 규모가 충분히 커지면 순수 ViT가 Hybrid를 따라잡았다.

7. 학습 전략

7.1 사전 학습 (Pre-training)

ViT의 학습 전략은 NLP의 "사전 학습 + 미세 조정" 패러다임을 따른다.

데이터셋:

• ImageNet-1K: 약 130만 장, 1,000 클래스
• ImageNet-21K: 약 1,400만 장, 21,843 클래스
• JFT-300M: Google 내부 데이터셋, 약 3억 장, 18,291 클래스

사전 학습 설정:

• Optimizer: Adam ($\beta_1 = 0.9$, $\beta_2 = 0.999$)
• Batch Size: 4,096
• Weight Decay: 0.1
• Linear Learning Rate Warmup + Cosine Decay
• 해상도: 224x224

논문의 핵심 발견 중 하나는 사전 학습 데이터의 규모가 ViT 성능에 결정적이라는 것이다. ImageNet-1K만으로는 CNN에 밀리지만, JFT-300M 규모에서는 CNN을 능가한다.

7.2 미세 조정 (Fine-tuning)

미세 조정 시 사전 학습된 Classification Head를 제거하고, 타겟 태스크에 맞는 새로운 Linear Layer를 부착한다.

고해상도 미세 조정의 핵심 기법:

사전 학습(224x224)보다 높은 해상도(384x384 또는 512x512)에서 미세 조정하면 성능이 향상된다. 하지만 해상도가 변경되면 패치 수(시퀀스 길이)가 달라지므로, 사전 학습된 Position Embedding이 그대로 사용될 수 없다.

이 문제를 해결하기 위해 2D Interpolation을 적용한다. 사전 학습된 Position Embedding을 원래의 2D 그리드 형태로 재구성한 후, 새로운 해상도에 맞게 Bicubic Interpolation으로 리사이징한다.

예시: 224x224 사전 학습 (14x14 그리드) → 384x384 미세 조정 (24x24 그리드)

사전 학습 Position Embedding (14x14 = 196개)
     |
     v
2D 그리드로 재구성 (14 x 14)
     |
     v
Bicubic Interpolation → (24 x 24)
     |
     v
1D로 다시 평탄화 (24x24 = 576개)

이 Position Embedding Interpolation은 ViT 이후 거의 모든 Vision Transformer에서 표준 기법으로 채택되었다.

7.3 학습 비용

ViT-H/14는 BiT-L 대비 약 1/4, Noisy Student 대비 약 1/5 수준의 학습 비용으로 더 높은 성능을 달성했다. 이는 Transformer의 뛰어난 확장 효율성을 보여주는 결과다.

8. 실험 결과

8.1 주요 벤치마크 결과

논문 Table 2에서 보고된 핵심 결과를 정리하면 다음과 같다.

8.2 VTAB 벤치마크

VTAB(Visual Task Adaptation Benchmark)은 19개의 다양한 Vision 태스크를 Natural, Specialized, Structured 세 카테고리로 분류한다. 각 태스크당 1,000개의 학습 샘플만 사용하여 모델의 일반화 능력을 평가한다.

ViT-H/14는 Natural과 Structured 카테고리에서 최고 성능을 보였으며, Specialized 카테고리에서는 BiT-L과 거의 동등했다. 전체 VTAB 점수 77.63은 당시 최고 기록이었다.

8.3 사전 학습 데이터 규모와 성능의 관계

논문의 가장 중요한 실험 중 하나는 사전 학습 데이터 규모에 따른 성능 변화를 분석한 것이다 (Figure 3, 4).

이 결과는 명확한 패턴을 보여준다:

• 소규모 데이터: CNN의 Inductive Bias(Locality, Translation Equivariance)가 유리하게 작용하여 CNN이 승리
• 대규모 데이터: Transformer가 데이터로부터 이러한 패턴을 직접 학습하여 CNN을 능가

9. 핵심 발견과 통찰

9.1 Inductive Bias의 양날의 검

CNN의 Inductive Bias -- Locality와 Translation Equivariance -- 는 소규모 데이터에서는 효과적인 정규화(regularization) 역할을 한다. 적은 데이터로도 올바른 특징을 학습하게 유도하기 때문이다.

하지만 데이터가 충분히 많아지면, 이 Inductive Bias는 오히려 모델의 표현력을 제한하는 족쇄가 된다. Transformer는 특별한 구조적 가정 없이, Self-Attention을 통해 데이터로부터 Locality와 Translation Equivariance를 포함한 더 일반적이고 유연한 패턴을 학습할 수 있다.

이것은 AI 분야의 오래된 교훈을 재확인한다: 충분한 데이터가 있으면, 더 일반적인(less biased) 모델이 더 특수화된(more biased) 모델을 능가한다.

9.2 Attention Map 시각화

9.2.1 Position Embedding 유사도

학습된 Position Embedding의 코사인 유사도를 시각화하면(논문 Figure 7 좌측), 각 패치 위치의 Embedding이 공간적으로 가까운 패치들과 높은 유사도를 보인다. 더 나아가, 같은 행이나 열에 있는 패치들 사이에 뚜렷한 유사도 패턴이 나타난다.

이는 1D Position Embedding만 사용했음에도 불구하고, 모델이 2D 공간 구조를 자동으로 학습했음을 증명한다.

9.2.2 Attention Distance

논문 Figure 7 우측에서는 각 Transformer 레이어에서 Attention Head별 평균 Attention Distance를 분석했다. Attention Distance는 Attention Weight으로 가중된 Query-Key 패치 간 평균 픽셀 거리이다.

핵심 발견:

• 하위 레이어(Lower Layers): 일부 Head는 인접 패치에, 일부 Head는 먼 패치에 주의를 기울임 -- CNN의 초기 레이어와 유사한 Local 패턴과 Global 패턴이 공존
• 상위 레이어(Higher Layers): 대부분의 Head가 넓은 범위에 걸쳐 주의를 분산 -- Global 정보 통합

이는 ViT가 첫 번째 레이어부터 이미 Global 정보를 활용할 수 있다는 점에서 CNN과 근본적으로 다르다는 것을 보여준다. CNN에서는 Receptive Field가 레이어를 거치면서 점진적으로 확대되지만, ViT에서는 첫 번째 레이어에서부터 이미지 전체에 대한 Attention이 가능하다.

9.3 Representation 품질 분석

Linear Probing(Frozen Feature에 Linear Classifier만 학습) 실험에서, ViT는 CNN에 비해 상대적으로 낮은 성능을 보였지만, Fine-tuning에서는 더 높은 성능을 달성했다. 이는 ViT가 다른 종류의 Feature 표현을 학습함을 시사한다 -- ViT의 Feature는 Fine-tuning을 통해 활성화되는 더 풍부한 정보를 담고 있을 수 있다.

10. PyTorch 핵심 구현

ViT의 핵심 구조를 PyTorch로 구현하면 다음과 같다. 실제 논문의 구현을 최대한 충실히 반영하되, 이해하기 쉽게 작성했다.

10.1 Patch Embedding

import torch
import torch.nn as nn


class PatchEmbedding(nn.Module):
    """이미지를 패치로 분할하고 Linear Projection으로 Embedding한다."""

    def __init__(
        self,
        img_size: int = 224,
        patch_size: int = 16,
        in_channels: int = 3,
        embed_dim: int = 768,
    ):
        super().__init__()
        self.img_size = img_size
        self.patch_size = patch_size
        self.num_patches = (img_size // patch_size) ** 2

        # Conv2d를 사용한 Patch Embedding
        # stride = patch_size로 설정하면 Linear Projection과 동치
        self.projection = nn.Conv2d(
            in_channels,
            embed_dim,
            kernel_size=patch_size,
            stride=patch_size,
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        # x: (B, C, H, W)
        # projection output: (B, embed_dim, H/P, W/P)
        x = self.projection(x)
        # flatten spatial dims and transpose: (B, num_patches, embed_dim)
        x = x.flatten(2).transpose(1, 2)
        return x

10.2 Multi-head Self-Attention

class MultiHeadSelfAttention(nn.Module):
    """Multi-Head Self-Attention 모듈."""

    def __init__(self, embed_dim: int = 768, num_heads: int = 12, dropout: float = 0.0):
        super().__init__()
        self.num_heads = num_heads
        self.head_dim = embed_dim // num_heads
        self.scale = self.head_dim ** -0.5  # 1/sqrt(d_k)

        # Q, K, V를 한 번에 생성
        self.qkv = nn.Linear(embed_dim, embed_dim * 3)
        self.proj = nn.Linear(embed_dim, embed_dim)
        self.attn_dropout = nn.Dropout(dropout)
        self.proj_dropout = nn.Dropout(dropout)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        B, N, D = x.shape

        # QKV 생성: (B, N, 3*D) -> (B, N, 3, num_heads, head_dim)
        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, self.head_dim)
        qkv = qkv.permute(2, 0, 3, 1, 4)  # (3, B, num_heads, N, head_dim)
        q, k, v = qkv.unbind(0)  # 각각 (B, num_heads, N, head_dim)

        # Scaled Dot-Product Attention
        attn = (q @ k.transpose(-2, -1)) * self.scale  # (B, num_heads, N, N)
        attn = attn.softmax(dim=-1)
        attn = self.attn_dropout(attn)

        # Value와의 가중합
        x = (attn @ v).transpose(1, 2).reshape(B, N, D)  # (B, N, D)
        x = self.proj(x)
        x = self.proj_dropout(x)
        return x

10.3 Transformer Encoder Block

class TransformerBlock(nn.Module):
    """ViT Transformer Encoder Block (Pre-norm)."""

    def __init__(
        self,
        embed_dim: int = 768,
        num_heads: int = 12,
        mlp_ratio: float = 4.0,
        dropout: float = 0.0,
    ):
        super().__init__()
        self.norm1 = nn.LayerNorm(embed_dim)
        self.attn = MultiHeadSelfAttention(embed_dim, num_heads, dropout)
        self.norm2 = nn.LayerNorm(embed_dim)
        self.mlp = nn.Sequential(
            nn.Linear(embed_dim, int(embed_dim * mlp_ratio)),
            nn.GELU(),
            nn.Dropout(dropout),
            nn.Linear(int(embed_dim * mlp_ratio), embed_dim),
            nn.Dropout(dropout),
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        # Pre-norm + MSA + Residual
        x = x + self.attn(self.norm1(x))
        # Pre-norm + MLP + Residual
        x = x + self.mlp(self.norm2(x))
        return x

10.4 전체 ViT 모델

class VisionTransformer(nn.Module):
    """Vision Transformer (ViT) 전체 모델."""

    def __init__(
        self,
        img_size: int = 224,
        patch_size: int = 16,
        in_channels: int = 3,
        num_classes: int = 1000,
        embed_dim: int = 768,
        depth: int = 12,
        num_heads: int = 12,
        mlp_ratio: float = 4.0,
        dropout: float = 0.0,
    ):
        super().__init__()
        self.patch_embed = PatchEmbedding(img_size, patch_size, in_channels, embed_dim)
        num_patches = self.patch_embed.num_patches

        # 학습 가능한 [CLS] Token
        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
        # 학습 가능한 Position Embedding ([CLS] + patches)
        self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + 1, embed_dim))
        self.pos_dropout = nn.Dropout(dropout)

        # Transformer Encoder
        self.blocks = nn.Sequential(
            *[
                TransformerBlock(embed_dim, num_heads, mlp_ratio, dropout)
                for _ in range(depth)
            ]
        )
        self.norm = nn.LayerNorm(embed_dim)

        # Classification Head
        self.head = nn.Linear(embed_dim, num_classes)

        # 초기화
        nn.init.trunc_normal_(self.pos_embed, std=0.02)
        nn.init.trunc_normal_(self.cls_token, std=0.02)
        self.apply(self._init_weights)

    def _init_weights(self, m: nn.Module):
        if isinstance(m, nn.Linear):
            nn.init.trunc_normal_(m.weight, std=0.02)
            if m.bias is not None:
                nn.init.zeros_(m.bias)
        elif isinstance(m, nn.LayerNorm):
            nn.init.ones_(m.weight)
            nn.init.zeros_(m.bias)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        B = x.shape[0]

        # Step 1: Patch Embedding
        x = self.patch_embed(x)  # (B, num_patches, embed_dim)

        # Step 2: [CLS] Token Prepend
        cls_tokens = self.cls_token.expand(B, -1, -1)  # (B, 1, embed_dim)
        x = torch.cat([cls_tokens, x], dim=1)  # (B, num_patches + 1, embed_dim)

        # Step 3: Position Embedding
        x = x + self.pos_embed
        x = self.pos_dropout(x)

        # Step 4: Transformer Encoder
        x = self.blocks(x)
        x = self.norm(x)

        # Step 5: [CLS] Token으로 분류
        cls_output = x[:, 0]  # (B, embed_dim)
        logits = self.head(cls_output)  # (B, num_classes)
        return logits


# 모델 변형 생성 함수
def vit_base_patch16_224(**kwargs):
    return VisionTransformer(
        img_size=224, patch_size=16, embed_dim=768,
        depth=12, num_heads=12, **kwargs,
    )

def vit_large_patch16_224(**kwargs):
    return VisionTransformer(
        img_size=224, patch_size=16, embed_dim=1024,
        depth=24, num_heads=16, **kwargs,
    )

def vit_huge_patch14_224(**kwargs):
    return VisionTransformer(
        img_size=224, patch_size=14, embed_dim=1280,
        depth=32, num_heads=16, **kwargs,
    )

10.5 사용 예시

# ViT-Base/16 모델 생성
model = vit_base_patch16_224(num_classes=1000)

# 파라미터 수 확인
total_params = sum(p.numel() for p in model.parameters())
print(f"Total parameters: {total_params:,}")
# 출력: Total parameters: 86,567,656

# 추론
dummy_input = torch.randn(1, 3, 224, 224)
output = model(dummy_input)
print(f"Output shape: {output.shape}")
# 출력: Output shape: torch.Size([1, 1000])

11. 후속 연구 총정리

ViT는 Vision Transformer라는 거대한 연구 흐름의 시발점이 되었다. 이후 등장한 주요 후속 연구들을 시간순으로 정리한다.

11.1 DeiT: Data-efficient Image Transformers (2020.12)

논문: "Training data-efficient image transformers & distillation through attention" (Touvron et al., Facebook AI)

핵심 기여: ViT의 가장 큰 한계 -- 대규모 데이터 의존성 -- 를 극복했다. ImageNet-1K만으로 ViT를 효과적으로 학습하는 방법을 제시했다.

주요 기법:

• Knowledge Distillation Token: [CLS] 토큰 외에 별도의 Distillation Token을 추가하여, Teacher 모델(CNN)의 지식을 효과적으로 전달
• Hard Distillation: Teacher의 Hard Label(argmax 예측)을 사용하여 Student를 학습
• 흥미롭게도 CNN Teacher가 Transformer Teacher보다 효과적 -- CNN의 Inductive Bias가 Distillation을 통해 Transformer에 전달됨

결과:

• DeiT-B: ImageNet-1K에서 83.1% top-1 accuracy (외부 데이터 없이)
• DeiT-B distilled: 85.2% (RegNetY-16GF Teacher 사용)
• ViT-B/16 JFT-300M pre-trained의 84.15%를 외부 데이터 없이 능가

11.2 Swin Transformer (2021.03)

논문: "Swin Transformer: Hierarchical Vision Transformer using Shifted Windows" (Liu et al., Microsoft Research)

핵심 기여: ViT의 두 가지 근본적 한계 -- $O(N^2)$ 복잡도와 Single-scale Feature -- 를 동시에 해결했다.

주요 기법:

• Window-based Self-Attention: 이미지를 고정 크기 윈도우(7x7 패치)로 분할하여, 윈도우 내부에서만 Self-Attention을 수행. 복잡도가 $O(N^2)$에서 $O(N)$(이미지 크기에 대해 선형)으로 감소
• Shifted Window: 연속된 레이어에서 윈도우를 이동시켜 윈도우 간 정보 교환을 가능하게 함
• Hierarchical Feature Map: 레이어가 깊어질수록 패치를 병합(Patch Merging)하여 해상도를 절반으로 줄이고 채널을 두 배로 늘림. CNN의 Feature Pyramid와 유사한 multi-scale feature 제공

결과:

• Swin-L: ImageNet-1K에서 87.3% top-1 accuracy (ImageNet-22K 사전 학습)
• COCO Object Detection: 58.7 box AP, 51.1 mask AP
• ADE20K Semantic Segmentation: 53.5 mIoU

Swin Transformer는 Object Detection, Semantic Segmentation 등 Dense Prediction 태스크에서 ViT보다 범용적으로 사용할 수 있는 Backbone이 되었다.

11.3 BEiT: BERT Pre-Training of Image Transformers (2021.06)

논문: "BEiT: BERT Pre-Training of Image Transformers" (Bao et al., Microsoft Research)

핵심 기여: NLP에서의 BERT-style Masked Language Modeling을 Vision에 최초로 성공적으로 적용했다.

주요 기법:

• Masked Image Modeling (MIM): 이미지 패치의 일부(약 40%)를 마스킹하고, 마스킹된 패치의 Visual Token을 예측
• Visual Tokenizer: dVAE(discrete Variational Autoencoder)를 사용하여 이미지를 이산적 Visual Token으로 변환 -- NLP의 어휘(vocabulary)에 해당
• 두 가지 뷰(View): 원본 이미지 패치(입력)와 Visual Token(예측 대상)

결과:

• BEiT-B: ImageNet-1K에서 83.2% (Self-supervised pre-training + Fine-tuning)
• BEiT-L: ImageNet-1K에서 86.3% (ImageNet-1K 데이터만 사용)
• DeiT-B의 81.8% 대비 +1.4% 향상 (같은 Base 모델 크기)

11.4 MAE: Masked Autoencoders (2021.11)

논문: "Masked Autoencoders Are Scalable Vision Learners" (He et al., Facebook AI Research)

핵심 기여: Self-supervised Vision Pre-training의 효율성과 확장성을 극대화했다. 단순하면서도 강력한 사전 학습 프레임워크를 제시했다.

주요 기법:

• 높은 마스킹 비율: 입력 패치의 **75%**를 마스킹 -- NLP(15%)보다 훨씬 높음. 이미지의 높은 정보 중복성(redundancy) 때문
• 비대칭 Encoder-Decoder: Encoder는 마스킹되지 않은 패치만 처리 (전체의 25%)하여 효율성 극대화. 가벼운 Decoder로 마스킹된 픽셀 재구성
• 픽셀 단위 재구성: BEiT와 달리 Visual Tokenizer 없이, 마스킹된 패치의 원시 픽셀값을 직접 재구성

결과:

• MAE(ViT-H): ImageNet-1K에서 87.8% (ImageNet-1K 데이터만 사용)
• 학습 효율성: Encoder가 전체 패치의 25%만 처리하므로 학습 시간 3배 이상 단축
• 사전 학습 없이 ViT를 처음부터 학습하는 것보다 훨씬 우수

11.5 DINO / DINOv2 (2021.04 / 2023.04)

DINO 논문: "Emerging Properties in Self-Supervised Vision Transformers" (Caron et al., Facebook AI Research)

DINOv2 논문: "DINOv2: Learning Robust Visual Features without Supervision" (Oquab et al., Meta AI)

DINO 핵심 기법:

• Self-Distillation: Teacher와 Student가 동일한 네트워크 구조를 가지며, Teacher는 Student의 Exponential Moving Average(EMA)
• Multi-crop 전략: Global View(전체 이미지)와 Local View(작은 크롭)를 교차 입력
• 발견: Self-supervised ViT의 Self-Attention Map이 명시적 학습 없이도 Object Segmentation 능력을 획득

DINOv2 핵심 기법:

• 대규모 Curated Dataset (LVD-142M) 자동 구축 파이프라인
• 1B 파라미터 Teacher 모델을 학습한 후, 작은 Student 모델로 Knowledge Distillation
• 텍스트 없이, 레이블 없이 범용적 시각 표현(Universal Visual Feature) 학습

결과:

• DINO(ViT-B): ImageNet Linear Probing에서 80.1%
• DINOv2: 대부분의 벤치마크에서 OpenCLIP을 능가하는 범용 Visual Feature

11.6 EVA / EVA-02 (2022 / 2023)

EVA 논문: "EVA: Exploring the Limits of Masked Visual Representation Learning at Scale" (Fang et al., BAAI)

EVA-02 논문: "EVA-02: A Visual Representation for Neon Genesis" (Fang et al., BAAI)

핵심 기법:

• Masked Image Modeling + CLIP Feature를 재구성 대상으로 사용
• Language-aligned Visual Feature를 학습하여, Vision-Language 태스크에도 강함
• 대규모 ViT를 효율적으로 학습하는 기법 제시

결과:

• EVA(ViT-g): ImageNet에서 89.6% (336x336)
• EVA-02: 304M 파라미터로 ImageNet 90.0% 달성 (공개 데이터만 사용)
• EVA-02-CLIP: Zero-shot ImageNet 80.4% (이전 최고 CLIP 대비 파라미터 1/6)

11.7 ConvNeXt: CNN의 반격 (2022.01)

논문: "A ConvNet for the 2020s" (Liu et al., Facebook AI Research / UC Berkeley)

핵심 기여: Transformer의 설계 원칙들을 순수 CNN에 체계적으로 적용하면, CNN도 Transformer와 대등한 성능을 낼 수 있음을 증명했다. "CNN이 정말 열등한가?"에 대한 통렬한 반론이다.

ResNet에 적용한 Transformer 설계 요소들:

1. Macro Design: Stage Ratio 조정 (ResNet의 3:4:6:3 → Swin-T의 1:1:3:1)
2. Stem을 Patchify(4x4 Conv, stride 4)로 교체
3. ResNeXt-style Grouped Convolution → Depthwise Convolution
4. Inverted Bottleneck (MobileNetV2 스타일)
5. 7x7 Large Kernel (Swin Transformer의 7x7 Window에 대응)
6. BN → LayerNorm, ReLU → GELU 등 활성화/정규화 변경

결과:

• ConvNeXt-B: ImageNet-1K에서 85.1% (Swin-B의 84.5% 대비 +0.6%, 12.5% 더 빠른 추론)
• ConvNeXt-L: ImageNet-22K 사전 학습 후 87.8%
• 성능뿐 아니라 처리량(throughput)에서도 Swin Transformer와 대등하거나 우수

12. ViT vs CNN vs Hybrid 비교

12.1 종합 비교 표

12.2 태스크별 권장 아키텍처 (2026년 기준)

13. Computer Vision의 미래: Foundation Models

13.1 Vision Foundation Model의 등장

ViT가 촉발한 패러다임 전환의 궁극적 결과는 Vision Foundation Model의 등장이다. NLP에서 GPT-3, GPT-4 같은 Foundation Model이 다양한 태스크를 하나의 모델로 처리하듯, Vision에서도 동일한 흐름이 진행 중이다.

주요 Vision Foundation Models:

• SAM (Segment Anything Model): ViT-H 기반, 모든 종류의 Segmentation을 하나의 모델로
• DINOv2: Self-supervised ViT, 범용 Visual Feature Extractor
• CLIP/SigLIP: Vision-Language 정렬, Zero-shot Classification과 Retrieval
• Florence/Intern: 대규모 멀티태스크 Vision-Language 모델

13.2 앞으로의 연구 방향

효율성 개선:

• FlashAttention, Linear Attention 등 $O(N^2)$ 병목 극복
• Token Pruning/Merging으로 불필요한 패치 제거
• Knowledge Distillation으로 경량 모델 생성

학습 패러다임:

• Self-supervised Pre-training의 확산 (MAE, DINO 계열)
• Vision-Language Alignment (CLIP 계열)
• 강화학습 기반 시각 의사결정 (VLM + RL)

아키텍처 혁신:

• Mamba / State Space Model의 Vision 적용 (Vision Mamba, VMamba)
• Mixture of Experts (MoE)를 활용한 효율적 스케일링
• CNN과 Transformer의 장점을 결합한 Hybrid 아키텍처 지속 연구

13.3 ViT의 역사적 의의

ViT가 남긴 가장 중요한 교훈은 **아키텍처의 범용성(universality)**이다. 하나의 아키텍처(Transformer)가 텍스트, 이미지, 음성, 비디오, 코드 등 모든 모달리티에 적용될 수 있다는 것은 AI 역사에서 매우 특별한 사건이다.

ViT 이전에 NLP와 Vision은 완전히 다른 아키텍처 생태계를 가지고 있었다. ViT 이후, Transformer는 진정한 Universal Architecture로 자리 잡았고, 이는 현재의 Multimodal Foundation Model(GPT-4V, Gemini, Claude 등)이 가능해진 기술적 토대다.

"An Image is Worth 16x16 Words" -- 이 제목은 단순한 비유가 아니라, Vision과 Language가 동일한 프레임워크 안에서 통합될 수 있다는 심오한 선언이었다.

14. References

1. Dosovitskiy, A., Beyer, L., Kolesnikov, A., Weissenborn, D., Zhai, X., Unterthiner, T., ... & Houlsby, N. (2020). An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale. ICLR 2021. arXiv:2010.11929

2. Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., ... & Polosukhin, I. (2017). Attention Is All You Need. NeurIPS 2017. arXiv:1706.03762

3. Touvron, H., Cord, M., Douze, M., Massa, F., Sablayrolles, A., & Jegou, H. (2021). Training data-efficient image transformers & distillation through attention (DeiT). ICML 2021. arXiv:2012.12877

4. Liu, Z., Lin, Y., Cao, Y., Hu, H., Wei, Y., Zhang, Z., ... & Guo, B. (2021). Swin Transformer: Hierarchical Vision Transformer using Shifted Windows. ICCV 2021. arXiv:2103.14030

5. Bao, H., Dong, L., Piao, S., & Wei, F. (2021). BEiT: BERT Pre-Training of Image Transformers. ICLR 2022. arXiv:2106.08254

6. He, K., Chen, X., Xie, S., Li, Y., Dollar, P., & Girshick, R. (2022). Masked Autoencoders Are Scalable Vision Learners (MAE). CVPR 2022. arXiv:2111.06377

7. Caron, M., Touvron, H., Misra, I., Jegou, H., Mairal, J., Bojanowski, P., & Joulin, A. (2021). Emerging Properties in Self-Supervised Vision Transformers (DINO). ICCV 2021. arXiv:2104.14294

8. Oquab, M., Darcet, T., Moutakanni, T., Vo, H., Szafraniec, M., Khalidov, V., ... & Bojanowski, P. (2023). DINOv2: Learning Robust Visual Features without Supervision. arXiv:2304.07193

9. Fang, Y., Wang, W., Xie, B., Sun, Q., Wu, L., Wang, X., ... & Cao, Y. (2023). EVA: Exploring the Limits of Masked Visual Representation Learning at Scale. CVPR 2023. arXiv:2211.07636

10. Fang, Y., Sun, Q., Wang, X., Huang, T., Wang, X., & Cao, Y. (2023). EVA-02: A Visual Representation for Neon Genesis. arXiv:2303.11331

11. Liu, Z., Mao, H., Wu, C. Y., Feichtenhofer, C., Darrell, T., & Xie, S. (2022). A ConvNet for the 2020s (ConvNeXt). CVPR 2022. arXiv:2201.03545

12. Devlin, J., Chang, M. W., Lee, K., & Toutanova, K. (2018). BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. NAACL 2019. arXiv:1810.04805

13. He, K., Zhang, X., Ren, S., & Sun, J. (2016). Deep Residual Learning for Image Recognition (ResNet). CVPR 2016. arXiv:1512.03385

14. Kolesnikov, A., Beyer, L., Zhai, X., Puigcerver, J., Yung, J., Gelly, S., & Houlsby, N. (2020). Big Transfer (BiT): General Visual Representation Learning. ECCV 2020. arXiv:1912.11370

15. Radford, A., Kim, J. W., Hallacy, C., Ramesh, A., Goh, G., Agarwal, S., ... & Sutskever, I. (2021). Learning Transferable Visual Models From Natural Language Supervision (CLIP). ICML 2021. arXiv:2103.00020

16. Kirillov, A., Mintun, E., Ravi, N., Mao, H., Rolland, C., Gustafson, L., ... & Girshick, R. (2023). Segment Anything (SAM). ICCV 2023. arXiv:2304.02643