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に入力するのだ。論文タイトル自体がこれを直感的に説明している——**1枚の画像は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分野に一種のパラダイムシフトを引き起こした。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タスクで成功できた根本的な理由は、2つの**Inductive Bias（帰納的バイアス）**にある。

**第一に、Locality（局所性）。** Convolutionフィルタは入力の局所的な領域のみを処理する。画像において隣接するピクセルが強い相関を持つという事実をアーキテクチャレベルで内蔵している。

**第二に、Translation Equivariance（並進等変性）。** 同じフィルタが画像のすべての位置で共有して適用されるため、物体が画像内のどこに位置しても同じ特徴を抽出できる。

この2つのバイアスのおかげで、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**：シーケンス内の任意の2位置間で直接的な相互作用が可能

- **優れた並列処理**：RNNと異なり、シーケンスのすべての位置を同時に処理可能

- **卓越したスケーラビリティ**：モデルサイズとデータを増やすほど性能が着実に向上する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の解法はエレガントかつ直感的である。画像を固定サイズのパッチに分割し、各パッチを1つのトークンとして扱う。

224x224の画像を16x16サイズのパッチに分割すると、パッチ数は以下の通りである。

$$

N = \frac{H \times W}{P^2} = \frac{224 \times 224}{16 \times 16} = 196

$$

50,176個のピクセルの代わりに196個のパッチトークンのみを処理すればよい。Self-Attentionの複雑度は $196^2 = 38,416$ となり、ピクセル単位比で約**65,000倍**減少する。

この変換の核心的前提は以下の通りである：**1つの16x16パッチは、NLPにおける1つの単語（word）と同等の意味単位として機能し得る。** 自然言語が単語という離散的トークンのシーケンスであるように、画像もパッチという視覚的トークンのシーケンスとして表現できるということである。

3.3 NLPとの対応関係

| NLP | Vision (ViT) |

| ------------------- | ----------------------------------- |

| 文（Sentence） | 画像（Image） |

| 単語（Word/Token） | 画像パッチ（Patch） |

| 語彙（Vocabulary） | 可能なパッチパターンの空間 |

| Token Embedding | Patch Embedding (Linear Projection) |

| Position Embedding | Position Embedding (1D Learnable) |

| [CLS] Token | [CLS] Token |

| Transformer Encoder | Transformer Encoder（同一） |

この対応関係が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空間にマッピングする。

$$

\mathbf{z}_0^i = \mathbf{x}_p^i \mathbf{E}, \quad i = 1, 2, \ldots, N

$$

ここで $D$ はTransformerのHidden Dimensionである。ViT-Baseの場合 $D = 768$ であるため、Linear Projectionは768x768の行列となる。

興味深い点は、このLinear Projectionが実質的に**strideがpatch sizeと同じConvolution演算**と等価であることだ。つまり、`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シーケンスの先頭に追加する。

$$

\mathbf{z}_0 = [\mathbf{x}_{\text{class}}; \, \mathbf{z}_0^1; \, \mathbf{z}_0^2; \, \ldots; \, \mathbf{z}_0^N]

$$

この[CLS]トークンはTransformerのSelf-Attentionを通じてすべてのパッチトークンと相互作用しながら、**画像全体のグローバル表現（global representation）**を学習する。Transformer Encoderの最終レイヤーにおけるこの[CLS]トークンの出力 $\mathbf{z}_L^0$ が画像全体を代表するベクトルとして使用される。

4.3.2 Classification Head

事前学習段階では[CLS]トークン出力に1つのHidden Layerを持つMLP Headを接続する。ファインチューニング段階では単一のLinear Layerのみ使用する。

$$

\hat{y} = \text{Linear}(\text{LN}(\mathbf{z}_L^0))

$$

論文では[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]トークンを含む全シーケンス長である。

$$

\mathbf{z}_0 = [\mathbf{x}_{\text{class}}; \, \mathbf{x}_p^1\mathbf{E}; \, \mathbf{x}_p^2\mathbf{E}; \, \ldots; \, \mathbf{x}_p^N\mathbf{E}] + \mathbf{E}_{pos}

$$

論文では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をそのまま使用する。各ブロックは以下の構造を持つ。

$$

\mathbf{z}_\ell' = \text{MSA}(\text{LN}(\mathbf{z}_{\ell-1})) + \mathbf{z}_{\ell-1}, \quad \ell = 1, \ldots, L

$$

$$

\mathbf{z}_\ell = \text{MLP}(\text{LN}(\mathbf{z}_\ell')) + \mathbf{z}_\ell', \quad \ell = 1, \ldots, L

$$

ここで：

- **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を実行した後結合する。

$$

\text{MSA}(\mathbf{z}) = [\text{head}_1; \, \text{head}_2; \, \ldots; \, \text{head}_h] \mathbf{W}^O

$$

$$

\text{head}_i = \text{Attention}(\mathbf{z}\mathbf{W}_i^Q, \, \mathbf{z}\mathbf{W}_i^K, \, \mathbf{z}\mathbf{W}_i^V)

$$

$$

\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V

$$

各Headの次元は $d_k = D / h$ である。ViT-Baseでは $D = 768$、$h = 12$ なので $d_k = 64$ である。

4.5.3 MLP（Feed-Forward Network）

MLPは2つのLinear LayerとGELU活性化関数で構成される。

$$

\text{MLP}(\mathbf{z}) = \text{GELU}(\mathbf{z}\mathbf{W}_1 + \mathbf{b}_1)\mathbf{W}_2 + \mathbf{b}_2

$$

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.** パッチ分割および平坦化：

$$

[\mathbf{x}_p^1, \mathbf{x}_p^2, \ldots, \mathbf{x}_p^N], \quad \mathbf{x}_p^i \in \mathbb{R}^{P^2 C}, \quad N = \frac{HW}{P^2}

$$

**Step 2.** Patch Embedding + [CLS] Token + Position Embedding：

$$

\mathbf{z}_0 = [\mathbf{x}_{\text{class}}; \, \mathbf{x}_p^1\mathbf{E}; \, \ldots; \, \mathbf{x}_p^N\mathbf{E}] + \mathbf{E}_{pos}

$$

ここで $\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ブロックを繰り返す：

$$

\mathbf{z}_\ell' = \text{MSA}(\text{LN}(\mathbf{z}_{\ell-1})) + \mathbf{z}_{\ell-1}

$$

$$

\mathbf{z}_\ell = \text{MLP}(\text{LN}(\mathbf{z}_\ell')) + \mathbf{z}_\ell'

$$

5.3 出力

**Step 4.** [CLS]トークン出力で分類：

$$

\mathbf{y} = \text{LN}(\mathbf{z}_L^0)

$$

$$

\hat{y} = \text{Softmax}(\mathbf{y}\mathbf{W}_{\text{head}} + \mathbf{b}_{\text{head}})

$$

5.4 計算複雑度分析

シーケンス長 $N$、Embedding次元 $D$ に対する主要演算の複雑度は以下の通りである。

| 演算 | 複雑度 |

| ------------------------------- | ------------------------------ |

| Patch Embedding | $O(N \cdot P^2C \cdot D)$ |

| Self-Attention（QKV生成） | $O(N \cdot D^2)$ |

| Self-Attention（Attention計算） | $O(N^2 \cdot D)$ |

| MLP | $O(N \cdot D^2)$ |

| Transformer Block全体 | $O(N^2 \cdot D + N \cdot D^2)$ |

シーケンス長 $N$ に対する $O(N^2)$ の複雑度がViTの解像度スケーラビリティを制限する核心的ボトルネックである。これが以降のSwin TransformerなどがWindowed Attentionを導入した動機である。

6. モデル変形：ViT-Base、Large、Huge

ViTはBERTの設計規約に従い、3つのサイズのモデルを定義した。モデル名のスラッシュ後の数字はパッチサイズを示す（例：ViT-B/16は16x16パッチ使用）。

| 仕様 | ViT-Base (ViT-B) | ViT-Large (ViT-L) | ViT-Huge (ViT-H) |

| -------------------------- | ---------------- | ----------------- | ---------------- |

| **Layers ($L$)** | 12 | 24 | 32 |

| **Hidden Dim ($D$)** | 768 | 1024 | 1280 |

| **MLP Dim** | 3072 | 4096 | 5120 |

| **Attention Heads ($h$)** | 12 | 16 | 16 |

| **Parameters** | ~86M | ~307M | ~632M |

| **Head Dim ($d_k = D/h$)** | 64 | 64 | 80 |

6.1 パッチサイズによる変形

同じアーキテクチャでもパッチサイズによって性能と計算量が大きく異なる。

| モデル | パッチサイズ | シーケンス長 (224x224) | シーケンス長 (384x384) |

| -------- | ------------ | ---------------------- | ---------------------- |

| ViT-B/32 | 32x32 | 49 | 144 |

| ViT-B/16 | 16x16 | 196 | 576 |

| ViT-L/16 | 16x16 | 196 | 576 |

| ViT-H/14 | 14x14 | 256 | 784 |

パッチサイズが小さいほどより細粒度（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に入力する。

$$

\mathbf{z}_0^i = \text{ResNet\_feature\_map}_{(i)} \mathbf{E}_{\text{hybrid}} + \mathbf{E}_{pos}^i

$$

実験結果、事前学習データが少ないときは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 学習コスト

| モデル | Pre-trainデータ | TPUv3-core-days |

| ------------------------------- | ------------------- | --------------- |

| ViT-B/16 | JFT-300M | 未提供 |

| ViT-L/16 | JFT-300M | 未提供 |

| ViT-H/14 | JFT-300M | **2,500** |

| BiT-L (ResNet152x4) | JFT-300M | 9,900 |

| Noisy Student (EfficientNet-L2) | JFT-300M + ImageNet | 12,300 |

ViT-H/14はBiT-L比で約**1/4**、Noisy Student比で約**1/5**の学習コストでより高い性能を達成した。これはTransformerの優れたスケーリング効率を示す結果である。

8. 実験結果

8.1 主要ベンチマーク結果

論文Table 2で報告された核心結果を整理すると以下の通りである。

| モデル | Pre-train | ImageNet | ImageNet-ReaL | CIFAR-10 | CIFAR-100 | Oxford Pets | Oxford Flowers |

| ------------------- | ------------ | --------- | ------------- | --------- | --------- | ----------- | -------------- |

| **ViT-H/14** | JFT-300M | **88.55** | **90.72** | **99.50** | **94.55** | 97.56 | 99.68 |

| ViT-L/16 | JFT-300M | 87.76 | 90.54 | 99.42 | 93.90 | 97.32 | 99.74 |

| ViT-L/16 | ImageNet-21K | 85.30 | 88.62 | 99.15 | 93.25 | 94.67 | 99.61 |

| BiT-L (ResNet152x4) | JFT-300M | 87.54 | 90.54 | 99.37 | 93.51 | 96.62 | 99.63 |

| Noisy Student | JFT-300M | 88.4 | 90.55 | - | - | - | - |

8.2 VTABベンチマーク

VTAB（Visual Task Adaptation Benchmark）は19の多様なVisionタスクをNatural、Specialized、Structuredの3カテゴリに分類する。各タスクあたり1,000個の学習サンプルのみを使用してモデルの汎化能力を評価する。

| モデル | Natural | Specialized | Structured | 全体 |

| -------------- | --------- | ----------- | ---------- | --------- |

| ViT-H/14 (JFT) | **79.39** | 84.23 | **69.27** | **77.63** |

| ViT-L/16 (JFT) | 76.28 | 83.36 | 64.72 | 74.78 |

| BiT-L (JFT) | 76.29 | **84.92** | 66.51 | 75.90 |

ViT-H/14はNaturalとStructuredカテゴリで最高性能を示し、SpecializedカテゴリではBiT-Lとほぼ同等であった。全体VTABスコア77.63は当時の最高記録であった。

8.3 事前学習データ規模と性能の関係

論文の最も重要な実験の一つは、事前学習データ規模に伴う性能変化を分析したものである（Figure 3、4）。

| 事前学習データ | ViT-L/16 ImageNet Acc | BiT-L ImageNet Acc | 勝者 |

| ------------------- | --------------------- | ------------------ | ------------- |

| ImageNet-1K (~1.3M) | ~76.5% (scratch) | ~80% (scratch) | **BiT (CNN)** |

| ImageNet-21K (~14M) | 85.30% | 84.02% | **ViT** |

| JFT-300M (~303M) | 87.76% | 87.54% | **ViT** |

この結果は明確なパターンを示している：

- **小規模データ**：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パッチ間の平均ピクセル距離である。

核心的発見：

- **下位レイヤー**：一部のHeadは隣接パッチに、一部のHeadは遠いパッチに注意を向ける——CNNの初期レイヤーと類似したLocalパターンとGlobalパターンが共存

- **上位レイヤー**：大部分のHeadが**広い範囲に注意を分散**——Global情報の統合

これはViTが最初のレイヤーからすでにGlobal情報を活用できるという点で、CNNと根本的に異なることを示している。CNNではReceptive Fieldがレイヤーを経て徐々に拡大するが、ViTでは最初のレイヤーから画像全体へのAttentionが可能である。

9.3 表現品質分析

Linear Probing（凍結Feature上にLinear Classifierのみ学習）実験で、ViTはCNNに比べて相対的に低い性能を示したが、Fine-tuningではより高い性能を達成した。これはViTが**異なる種類のFeature表現**を学習することを示唆しており、ViTのFeatureはFine-tuningを通じて活性化されるより豊富な情報を含んでいる可能性がある。

10. PyTorch核心実装

ViTの核心構造をPyTorchで実装すると以下の通りである。論文の実装を最大限忠実に反映しつつ、理解しやすく記述した。

10.1 Patch Embedding

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の2つの根本的限界——$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）し、解像度を半分に縮小しチャネルを2倍に増加。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の語彙に相当

- 2つの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%）よりはるかに高い。画像の高い情報冗長性のため

- **非対称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%**

- 性能だけでなく**スループットでもSwin Transformerと同等かそれ以上**

12. ViT vs CNN vs Hybrid比較

12.1 総合比較表

| 特性 | CNN（ResNet系列） | ViT（純粋Transformer） | Hybrid（CNN + Transformer） |

| --------------------------- | ------------------------------------------ | ---------------------- | --------------------------- |

| **Inductive Bias** | 強い（Locality、Translation Equivariance） | ほぼなし | 中程度（CNNから一部借用） |

| **小規模データ性能** | 優秀 | 劣勢 | 優秀 |

| **大規模データ性能** | 良好 | 最高 | 非常に良好 |

| **計算複雑度（解像度比）** | $O(N)$ | $O(N^2)$ | $O(N) \sim O(N^2)$ |

| **Multi-scale Feature** | 自然（Feature Pyramid） | なし（Single-scale） | 多様 |

| **Global Receptive Field** | レイヤーを重ねて確保 | 最初のレイヤーから可能 | CNN以降に可能 |

| **Dense Prediction適合性** | 高い | 低い（後処理必要） | 中〜高 |

| **学習効率（FLOPs比性能）** | 良好 | 大規模で最高 | 良好 |

| **実装・最適化成熟度** | 非常に高い | 急速に成熟中 | 中程度 |

| **代表モデル** | ResNet、EfficientNet、ConvNeXt | ViT、DeiT、BEiT | Swin Transformer、CoAtNet |

12.2 タスク別推奨アーキテクチャ（2026年基準）

| タスク | 推奨アーキテクチャ | 根拠 |

| ------------------------------ | ---------------------------------- | ---------------------------- |

| Image Classification（大規模） | ViT + MAE/DINO pre-training | 大規模データで最高性能 |

| Image Classification（小規模） | DeiT（Distillation）またはConvNeXt | データ効率性 |

| Object Detection | Swin Transformer + FPN系列 | Multi-scale Feature必須 |

| Semantic Segmentation | Swin / SegFormer / DINOv2 | Dense Predictionに適合 |

| Vision-Language | ViT + CLIP-style pre-training | Language-aligned Feature |

| Edge/Mobileデプロイ | EfficientNet / MobileViT | 軽量化必須 |

| Self-supervised Pre-training | MAE / DINOv2 | ラベル不要、スケーラビリティ |

13. Computer Visionの未来：Foundation Models

13.1 Vision Foundation Modelの登場

ViTが引き起こしたパラダイムシフトの究極的結果は**Vision Foundation Model**の登場である。NLPでGPT-3、GPT-4のようなFoundation Modelが多様なタスクを1つのモデルで処理するように、Visionでも同じ流れが進行中である。

**主要なVision Foundation Models：**

- **SAM（Segment Anything Model）**：ViT-Hベース、あらゆる種類のSegmentationを1つのモデルで

- **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）**である。1つのアーキテクチャ（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](https://arxiv.org/abs/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](https://arxiv.org/abs/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](https://arxiv.org/abs/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](https://arxiv.org/abs/2103.14030)

5. Bao, H., Dong, L., Piao, S., & Wei, F. (2021). **BEiT: BERT Pre-Training of Image Transformers.** ICLR 2022. [arXiv:2106.08254](https://arxiv.org/abs/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](https://arxiv.org/abs/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](https://arxiv.org/abs/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](https://arxiv.org/abs/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](https://arxiv.org/abs/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](https://arxiv.org/abs/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](https://arxiv.org/abs/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](https://arxiv.org/abs/1810.04805)

13. He, K., Zhang, X., Ren, S., & Sun, J. (2016). **Deep Residual Learning for Image Recognition (ResNet).** CVPR 2016. [arXiv:1512.03385](https://arxiv.org/abs/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](https://arxiv.org/abs/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](https://arxiv.org/abs/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](https://arxiv.org/abs/2304.02643)