패치 임베딩

작성자

익명

작성일

2026.07.10

조회수

버전

패치 임베딩 (Patch Embedding)

1. 개요

패치 임베딩(Patch Embedding)은 2차원 이미지 데이터를 트랜스포머(Transformer) 모델이 처리할 수 있는 1차원 시퀀스(Sequence) 형태의 벡터로 변환하는 전처리 과정이다.

본래 트랜스포머 아키텍처는 자연어 처리(NLP)를 위해 설계되어 텍스트 토큰의 시퀀스를 입력으로 받는다. 하지만 이미지는 픽셀 단위로 처리할 경우 데이터의 차원이 너무 커져 연산 비용이 기하급수적으로 증가한다. 따라서 이미지를 격자 형태의 작은 조각인 '패치(Patch)'로 나누고, 각 패치를 하나의 토큰으로 간주하여 임베딩함으로써 이미지 데이터를 효율적으로 처리할 수 있게 한다. 이는 Vision Transformer(ViT)의 핵심적인 입력 메커니즘이다.

2. 작동 원리 및 프로세스

패치 임베딩은 크게 분할 $\rightarrow$ 평탄화 $\rightarrow$ 선형 투영의 3단계 과정을 거친다.

이미지 분할 (Patch Partitioning): 입력 이미지 $I \in \mathbb{R}^{H \times W \times C}$를 고정된 크기의 패치 $P \times P$로 나눈다. 이때 생성되는 패치의 총 개수는 $N = (H \times W) / P^2$가 된다.
평탄화 (Flattening): 개별 패치는 $\mathbb{R}^{P \times P \times C}$의 형태를 가진다. 패치의 공간 차원($P \times P$)을 평탄화하여 채널 수($C$)와 곱해진 $P^2 \cdot C$ 차원의 벡터로 변환한다.
선형 투영 (Linear Projection): 평탄화된 벡터에 학습 가능한 가중치 행렬 $E$를 곱하여, 모델이 정의한 임베딩 차원 $D$로 매핑한다. 결과적으로 각 패치는 $D$ 차원의 벡터가 된다.

[표 1] 입력 이미지와 임베딩 차원 간의 관계

항목	기호	설명	예시 값
입력 이미지 크기	$H, W, C$	높이, 너비, 채널(RGB)	$224 \times 224 \times 3$
패치 크기	$P$	한 변의 픽셀 수	$16$
패치 개수	$N$	$N = (H \times W) / P^2$	$14 \times 14 = 196$
평탄화 차원	$P^2 \cdot C$	패치 하나를 펼친 크기	$16^2 \times 3 = 768$
임베딩 차원	$D$	투영 후 최종 벡터 차원	$768$ (ViT-Base 기준)

3. 구현 방식

실제 딥러닝 프레임워크에서는 효율성을 위해 두 가지 방식으로 구현한다.

3.1. Flatten 후 선형 투영(Linear Projection) 적용

가장 직관적인 방법으로, 이미지를 물리적으로 자른 뒤 nn.Linear 층을 통과시키는 방식이다. 개념적 이해는 쉬우나, 대량의 패치를 개별적으로 처리할 때 메모리 오버헤드가 발생할 수 있다. - 텐서 흐름: (Batch, N, P*P*C) $\rightarrow$ Linear Layer $\rightarrow$ (Batch, N, D)

3.2. Strided Convolution 적용

실제 구현에서 가장 많이 쓰이는 방식으로, 스트라이드(Stride)와 커널 크기(Kernel Size)를 패치 크기 $P$와 동일하게 설정한 2D 합성곱 층을 사용하는 방법이다. 이는 연산 효율성이 매우 높으며, 하드웨어 가속기(GPU)에 최적화되어 있다.

[Conv2d 연산 과정 도식화] Input Image [B, C, H, W] $\xrightarrow{\text{Conv2d(K=P, S=P, Out=D)}}$ Feature Map [B, D, H/P, W/P] $\xrightarrow{\text{Flatten}}$ [B, D, N] $\xrightarrow{\text{Transpose}}$ [B, N, D]

[코드 예제] PyTorch 기반 Conv2d 패치 임베딩 구현

import torch
import torch.nn as nn

class PatchEmbedding(nn.Module):
    def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768):
        super().__init__()
        self.patch_size = patch_size
        # Conv2d를 사용하여 패치 분할과 선형 투영을 동시에 수행
        # kernel_size와 stride를 patch_size로 설정하여 겹치지 않게 추출
        self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size)

    def forward(self, x):
        # x: [Batch, Channel, H, W]
        x = self.proj(x)  # [Batch, embed_dim, H/P, W/P]
        x = x.flatten(2)   # [Batch, embed_dim, N] (N = H/P * W/P)
        x = x.transpose(1, 2) # [Batch, N, embed_dim]
        return x

# 테스트
img = torch.randn(1, 3, 224, 224)
model = PatchEmbedding()
output = model(img)
print(output.shape) # torch.Size([1, 196, 768])

4. 추가 구성 요소 (ViT 입력 파이프라인)

패치 임베딩만으로는 트랜스포머가 이미지의 전체적인 맥락과 위치 정보를 파악하기 어렵다. 따라서 다음과 같은 단계가 추가된다.

4.1. 클래스 토큰 (CLS Token) 추가

트랜스포머의 출력값 중 어떤 벡터를 사용하여 이미지 전체를 분류할지 결정하기 위해, 학습 가능한 특수 벡터인 $\text{CLS Token}$을 시퀀스의 맨 앞에 추가한다. - 과정: $[N, D]$ 크기의 패치 임베딩 시퀀스 앞에 $[1, D]$ 크기의 CLS 토큰을 결합하여 $[N+1, D]$ 크기로 만든다. - 목적: 모든 패치 간의 Self-Attention을 통해 이미지 전체의 전역적 정보(Global Information)를 응축하는 역할을 한다.

4.2. 포지셔널 임베딩 (Positional Embedding) 결합

트랜스포머는 입력 순서에 무관한(Permutation Invariant) 구조이므로, 패치들이 이미지의 어느 위치에 있었는지에 대한 정보가 없다. 이를 해결하기 위해 포지셔널 임베딩을 더해준다. - 과정: 각 토큰의 위치에 대응하는 학습 가능한 벡터(또는 사인/코사인 함수 기반 벡터)를 생성하여 패치 임베딩에 요소별 덧셈(Element-wise Addition)을 수행한다. - 결과: 모델은 각 패치의 상대적/절대적 위치를 인식하여 공간적 구조를 학습할 수 있게 된다. 최종적으로 $\text{Embedding} = \text{Patch Embedding} + \text{Positional Embedding}$의 형태로 입력값이 결정된다.

5. 주요 특징 및 하이퍼파라미터

패치 크기($P$)는 모델의 성능과 자원 소모량 사이의 트레이드-오프(Trade-off)를 결정하는 핵심 하이퍼파라미터이다.

패치 크기가 작을 때 ($P \downarrow$):
- 장점: 더 세밀한 해상도 인식이 가능하며, 세부 특징(Fine-grained details)을 잘 포착하여 일반적으로 정확도가 향상된다.
- 단점: 패치 개수 $N$이 제곱에 비례하여 증가하며, 트랜스포머의 Self-Attention 연산 복잡도가 $O(N^2)$이므로 메모리 사용량과 연산 시간이 급격히 증가한다.
패치 크기가 클 때 ($P \uparrow$):
- 장점: 패치 개수 $N$이 감소하여 연산 속도가 빠르고 메모리 효율적이다.
- 단점: 이미지의 세부 정보가 손실되어 작은 객체 인식 능력이 저하되며, 전반적인 모델 성능(Accuracy)이 하락할 가능성이 높다.

6. 한계점 및 발전 방향

6.1. 한계점

고정된 크기의 패치 임베딩은 '강성(Rigidity)' 문제를 가진다. 이미지의 모든 영역을 동일한 크기로 나누기 때문에, 중요한 세부 영역은 너무 뭉뚱그려지고 불필요한 배경 영역에는 과도한 연산이 할당되는 비효율성이 발생한다.

6.2. 발전 방향 및 적용 사례

이러한 한계를 극복하기 위해 다양한 변형 구조가 등장했다.

계층적 구조 (Hierarchical Structure): Swin Transformer와 같이 초기에는 작은 패치로 시작하여 층이 깊어질수록 패치를 병합(Merging)하는 방식을 통해, CNN처럼 다양한 스케일의 특징을 추출한다.
가변 패치 및 오버랩 패치: 패치 간에 약간의 겹침(Overlap)을 허용하여 경계 부분의 정보 손실을 줄이는 방식이 도입되었다.
MAE (Masked Autoencoders): 패치 임베딩의 특성을 활용하여, 이미지 패치의 상당 부분(예: 75%)을 무작위로 제거(Masking)하고 남은 패치들만 임베딩하여 복원하는 자기지도학습(Self-supervised Learning) 방식으로 확장되었다. 이는 데이터 효율성을 극대화하는 방향으로 발전하고 있다.

📝 마크다운 원본

이 문서의 마크다운 원본 내용입니다.

# 패치 임베딩 (Patch Embedding)

## 1. 개요
**패치 임베딩(Patch Embedding)**은 2차원 이미지 데이터를 트랜스포머(Transformer) 모델이 처리할 수 있는 1차원 시퀀스(Sequence) 형태의 벡터로 변환하는 전처리 과정이다.

본래 트랜스포머 아키텍처는 자연어 처리(NLP)를 위해 설계되어 텍스트 토큰의 시퀀스를 입력으로 받는다. 하지만 이미지는 픽셀 단위로 처리할 경우 데이터의 차원이 너무 커져 연산 비용이 기하급수적으로 증가한다. 따라서 이미지를 격자 형태의 작은 조각인 '패치(Patch)'로 나누고, 각 패치를 하나의 토큰으로 간주하여 임베딩함으로써 이미지 데이터를 효율적으로 처리할 수 있게 한다. 이는 Vision Transformer(ViT)의 핵심적인 입력 메커니즘이다.

## 2. 작동 원리 및 프로세스

패치 임베딩은 크게 **분할 $\rightarrow$ 평탄화 $\rightarrow$ 선형 투영**의 3단계 과정을 거친다.

1.  **이미지 분할 (Patch Partitioning):** 입력 이미지 $I \in \mathbb{R}^{H \times W \times C}$를 고정된 크기의 패치 $P \times P$로 나눈다. 이때 생성되는 패치의 총 개수는 $N = (H \times W) / P^2$가 된다.
2.  **평탄화 (Flattening):** 개별 패치는 $\mathbb{R}^{P \times P \times C}$의 형태를 가진다. 패치의 공간 차원($P \times P$)을 평탄화하여 채널 수($C$)와 곱해진 $P^2 \cdot C$ 차원의 벡터로 변환한다.
3.  **선형 투영 (Linear Projection):** 평탄화된 벡터에 학습 가능한 가중치 행렬 $E$를 곱하여, 모델이 정의한 임베딩 차원 $D$로 매핑한다. 결과적으로 각 패치는 $D$ 차원의 벡터가 된다.

### [표 1] 입력 이미지와 임베딩 차원 간의 관계

| 항목 | 기호 | 설명 | 예시 값 |
| :--- | :---: | :--- | :--- |
| 입력 이미지 크기 | $H, W, C$ | 높이, 너비, 채널(RGB) | $224 \times 224 \times 3$ |
| 패치 크기 | $P$ | 한 변의 픽셀 수 | $16$ |
| 패치 개수 | $N$ | $N = (H \times W) / P^2$ | $14 \times 14 = 196$ |
| 평탄화 차원 | $P^2 \cdot C$ | 패치 하나를 펼친 크기 | $16^2 \times 3 = 768$ |
| 임베딩 차원 | $D$ | 투영 후 최종 벡터 차원 | $768$ (ViT-Base 기준) |

## 3. 구현 방식

실제 딥러닝 프레임워크에서는 효율성을 위해 두 가지 방식으로 구현한다.

### 3.1. Flatten 후 선형 투영(Linear Projection) 적용
가장 직관적인 방법으로, 이미지를 물리적으로 자른 뒤 `nn.Linear` 층을 통과시키는 방식이다. 개념적 이해는 쉬우나, 대량의 패치를 개별적으로 처리할 때 메모리 오버헤드가 발생할 수 있다.
- **텐서 흐름:** `(Batch, N, P*P*C)` $\rightarrow$ Linear Layer $\rightarrow$ `(Batch, N, D)`

### 3.2. Strided Convolution 적용
실제 구현에서 가장 많이 쓰이는 방식으로, **스트라이드(Stride)**와 **커널 크기(Kernel Size)**를 패치 크기 $P$와 동일하게 설정한 2D 합성곱 층을 사용하는 방법이다. 이는 연산 효율성이 매우 높으며, 하드웨어 가속기(GPU)에 최적화되어 있다.

**[Conv2d 연산 과정 도식화]**
`Input Image [B, C, H, W]` $\xrightarrow{\text{Conv2d(K=P, S=P, Out=D)}}$ `Feature Map [B, D, H/P, W/P]` $\xrightarrow{\text{Flatten}}$ `[B, D, N]` $\xrightarrow{\text{Transpose}}$ `[B, N, D]`

### [코드 예제] PyTorch 기반 Conv2d 패치 임베딩 구현

```python
import torch
import torch.nn as nn

class PatchEmbedding(nn.Module):
    def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768):
        super().__init__()
        self.patch_size = patch_size
        # Conv2d를 사용하여 패치 분할과 선형 투영을 동시에 수행
        # kernel_size와 stride를 patch_size로 설정하여 겹치지 않게 추출
        self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size)

    def forward(self, x):
        # x: [Batch, Channel, H, W]
        x = self.proj(x)  # [Batch, embed_dim, H/P, W/P]
        x = x.flatten(2)   # [Batch, embed_dim, N] (N = H/P * W/P)
        x = x.transpose(1, 2) # [Batch, N, embed_dim]
        return x

# 테스트
img = torch.randn(1, 3, 224, 224)
model = PatchEmbedding()
output = model(img)
print(output.shape) # torch.Size([1, 196, 768])
```

## 4. 추가 구성 요소 (ViT 입력 파이프라인)

패치 임베딩만으로는 트랜스포머가 이미지의 전체적인 맥락과 위치 정보를 파악하기 어렵다. 따라서 다음과 같은 단계가 추가된다.

### 4.1. 클래스 토큰 (CLS Token) 추가
트랜스포머의 출력값 중 어떤 벡터를 사용하여 이미지 전체를 분류할지 결정하기 위해, 학습 가능한 특수 벡터인 **$\text{CLS Token}$**을 시퀀스의 맨 앞에 추가한다.
- **과정:** $[N, D]$ 크기의 패치 임베딩 시퀀스 앞에 $[1, D]$ 크기의 CLS 토큰을 결합하여 $[N+1, D]$ 크기로 만든다.
- **목적:** 모든 패치 간의 Self-Attention을 통해 이미지 전체의 전역적 정보(Global Information)를 응축하는 역할을 한다.

### 4.2. 포지셔널 임베딩 (Positional Embedding) 결합
트랜스포머는 입력 순서에 무관한(Permutation Invariant) 구조이므로, 패치들이 이미지의 어느 위치에 있었는지에 대한 정보가 없다. 이를 해결하기 위해 **포지셔널 임베딩**을 더해준다.
- **과정:** 각 토큰의 위치에 대응하는 학습 가능한 벡터(또는 사인/코사인 함수 기반 벡터)를 생성하여 패치 임베딩에 요소별 덧셈(Element-wise Addition)을 수행한다.
- **결과:** 모델은 각 패치의 상대적/절대적 위치를 인식하여 공간적 구조를 학습할 수 있게 된다. 최종적으로 $\text{Embedding} = \text{Patch Embedding} + \text{Positional Embedding}$의 형태로 입력값이 결정된다.

## 5. 주요 특징 및 하이퍼파라미터

패치 크기($P$)는 모델의 성능과 자원 소모량 사이의 트레이드-오프(Trade-off)를 결정하는 핵심 하이퍼파라미터이다.

- **패치 크기가 작을 때 ($P \downarrow$):**
    - **장점:** 더 세밀한 해상도 인식이 가능하며, 세부 특징(Fine-grained details)을 잘 포착하여 일반적으로 정확도가 향상된다.
    - **단점:** 패치 개수 $N$이 제곱에 비례하여 증가하며, 트랜스포머의 Self-Attention 연산 복잡도가 $O(N^2)$이므로 메모리 사용량과 연산 시간이 급격히 증가한다.
- **패치 크기가 클 때 ($P \uparrow$):**
    - **장점:** 패치 개수 $N$이 감소하여 연산 속도가 빠르고 메모리 효율적이다.
    - **단점:** 이미지의 세부 정보가 손실되어 작은 객체 인식 능력이 저하되며, 전반적인 모델 성능(Accuracy)이 하락할 가능성이 높다.

## 6. 한계점 및 발전 방향

### 6.1. 한계점
고정된 크기의 패치 임베딩은 **'강성(Rigidity)'** 문제를 가진다. 이미지의 모든 영역을 동일한 크기로 나누기 때문에, 중요한 세부 영역은 너무 뭉뚱그려지고 불필요한 배경 영역에는 과도한 연산이 할당되는 비효율성이 발생한다.

### 6.2. 발전 방향 및 적용 사례
이러한 한계를 극복하기 위해 다양한 변형 구조가 등장했다.

- **계층적 구조 (Hierarchical Structure):** **Swin Transformer**와 같이 초기에는 작은 패치로 시작하여 층이 깊어질수록 패치를 병합(Merging)하는 방식을 통해, CNN처럼 다양한 스케일의 특징을 추출한다.
- **가변 패치 및 오버랩 패치:** 패치 간에 약간의 겹침(Overlap)을 허용하여 경계 부분의 정보 손실을 줄이는 방식이 도입되었다.
- **MAE (Masked Autoencoders):** 패치 임베딩의 특성을 활용하여, 이미지 패치의 상당 부분(예: 75%)을 무작위로 제거(Masking)하고 남은 패치들만 임베딩하여 복원하는 자기지도학습(Self-supervised Learning) 방식으로 확장되었다. 이는 데이터 효율성을 극대화하는 방향으로 발전하고 있다.

AI 생성 콘텐츠 안내

이 문서는 AI 모델(gemma-4-31b)에 의해 생성된 콘텐츠입니다.

주의사항: AI가 생성한 내용은 부정확하거나 편향된 정보를 포함할 수 있습니다. 중요한 결정을 내리기 전에 반드시 신뢰할 수 있는 출처를 통해 정보를 확인하시기 바랍니다.

위키너와나