Jayden Yang

Attentive Low-Rank Filter Adaptation for Structure-Aware Cross-Domain Personalized Gaze Estimation

2026-03-02T00:00:00.000Z

0. Backgrounds

0.1 Model-Agnostic Meta-Learning (MAML)

Model-Agnostic Meta-Learning for Fast Adaptation of Deep Networks

Meta-learning은 여러 task에서의 학습 과정을 관찰하여, 새로운 task에 대해 적은 데이터로도 빠르게 적응할 수 있는 모델 파라미터를 학습하는 방식이다.

MAML은 모델 구조와 무관하게 적용 가능한 gradient-based meta-learning 방법으로, 각 데이터 샘플 마다 최적의 파라미터 $θ_{i}$ 가 존재한다는 가정하에, few-shot 학습 이후의 성능이 좋아지도록 공통 초기 파라미터 $θ$ 를 학습한다.

이때 $θ$ 는 각 혹은 전체 데이터 샘플의 최적 파라미터가 아니라, 소수의 gradient update만으로 각 $θ_{i}$ 에 빠르게 도달할 수 있는 출발점이다.

MAML 논문에서는 reinforcement learning 에서도 용례도 함께 설명하지만 few-shot supervised learning 을 중심으로 설명한다.

먼저 일반적인 supervised learning 에서의 최적화의 대상은 다음과 같다:

J (θ) = \frac{1}{N} \sum_{i = 1}^{N} ℒ (f_{θ} (x_{i}), y_{i})

$x$ 와 그에 대응하는 $y$ 가 있고, $f_{θ} (x)$ 가 $y$ 와 제일 적은 loss 를 가지도록 하는 것이 목표이다. 하지만 Meta Learning 은 다음을 최적화 한다. 전체 Task 를 $𝒯$ 라고 하고, 그 중 샘플링한 $i$ 번째 데이터가 $𝒯_{i}$ 라고 하자.

J_{meta} (θ) = \sum_{𝒯_{i} \sim p (𝒯)} ℒ_{𝒯_{i}} (f_{θ - α \nabla_{θ} ℒ_{𝒯_{i}} (f_{θ})})

식을 풀어서 설명하자면,

먼저 전체 Task 에서 일부가 샘플링 된다. ( $𝒯_{i} \sim p (𝒯)$ )
그 후 각 샘플 데이터 $𝒯_{i}$ 에 대한 경사 하강을 수행한다. ( $f_{θ - α \nabla_{θ} ℒ_{𝒯 i} (f θ)} = f_{θ_{i}}$ )
샘플 데이터 $𝒯_{i}$ 에 대한 모델 $θ_{i}$ 을 해당 샘플 데이터의 다른 데이터로 평가한다 ( $ℒ_{𝒯_{i}} (f_{θ_{i}})$ )
1~3 의 과정을 모든 샘플들에 대해 수행한 뒤 결과를 합한다.

즉 MAML 은 task 안에서 $M$ 개 데이터를 샘플링 하여, base model $θ$ 에서 각 샘플 데이터로 경사 하강 한 모델 $θ_{i}$ 의 성능을 최적화 한다. 이것이 어떤 의미를 가지는지는 논문에 있는 알고리즘을 참고하면 알 수 있다.

각 샘플 데이터로 훈련된 $θ_{i}$ 들의 gradient 로 base model $θ$ 를 업데이트 한다. 곧 이는 $θ$ 가 특정 Task 샘플 $𝒯_{𝒾}$ 에 대한 최적화를 하는게 아니라, 샘플링 된 $𝒯_{i} \sim p (𝒯)$ 의 데이터들에서 각각의 몇 step 의 경사하강만 수행 한 모델 $θ_{i}$ 의 test data loss 에 대한 gradient 들로 업데이트 되는 것을 의미한다.

여기서 각 $i$ 번째 Task 샘플에 대한 업데이트의 결과인 $θ_{i}$ 를 만드는 과정을 Inner Loop 라 하고, 각 $θ_{i}$ 의 Loss 를 합쳐 base model 을 업데이트 하는 과정을 Outer Loop 라고 한다.

중요한 것은 $i$ 번째 Task 샘플에 대한 Loss 에 들어가는 데이터가 Inner Loop 와 Outer Loop 가 다르다는 점이다.

$𝒯_{i}$ 는 $𝒟_{i}^{train}$ 와 $𝒟_{i}^{test}$ 로 나누어진다. 즉 $θ_{i}$ 를 만드는 loss 에 들어가는 데이터는 $K$ 개 샘플한 $𝒟_{i}^{train}$ 이며, Outer Loop 에서 사용되는 것은 또 다르게 샘플된 $𝒟_{i}^{test}$ 이다. 이는 $θ_{i}$ 의 일반화 성능을 향상하기 위함이다.

Gaze Estimation 문제를 예시로 들어보자. 10명에 대한 전체 데이터 $𝒯$ 가 있을 때, $𝒯_{i}$ 는 각 사람의 데이터셋이다. Inner Loop 에서 사용되는 $𝒟_{i}^{train}$ 는 $𝒯_{i}$ 의 일부이며, $𝒟_{i}^{test}$ 는 또 다른 일부이다. 즉 한 사람에 대해 few-shot learning 을 진행한 $θ_{i}$ 는, 동일한 사람의 또 다른 데이터 $𝒟_{i}^{test}$ 로 평가되어 overfitting 을 방지한다.

Outer Loop 에서는 $θ \leftarrow θ - β \nabla_{θ} \sum_{𝒯 \sim p (𝒯)} ℒ_{𝒯_{i}} (f_{θ_{i}} (𝒟_{i}^{test}))$ 로 업데이트 하는데, $θ_{i}$ 에 대한 loss 의 미분 결과를 base model $θ$ 에 적용하는게 직관적이지 않을 수도 있지만 $θ_{i} = θ - α \nabla_{θ} ℒ_{𝒯_{i}} (f_{θ} (𝒟_{i}^{train}))$ 이므로 , $θ$ 에서부터 미분 가능하다.

미분 과정에서 $θ_{i} = θ - α \nabla_{θ} ℒ_{𝒯_{i}} (f_{θ} (𝒟_{i}^{train}))$ 이므로 outer loss 를 $θ$ 에 대해 미분 할 때 $\frac{\partial}{\partial θ} (\nabla_{θ} ℒ_{𝒯_{i}} (𝒟_{i}^{train}))$ 를 구해야 하므로, 2차 미분이 필요하다. 즉 Scalar 인 Loss 의 결과를 미분한 결과는 벡터이고,각 벡터 요소마다 미분을 수행하므로 2차 미분의 결과는 행렬이 된다.

이 행렬의 크기는 파라미터 갯수의 제곱에 비례하므로 계산 비용 측면에서 굉장히 까다로우나, 논문에서는 이 항을 제거하여 근사하는 1차 미분으로도 유사한 성능을 달성하였다.

\frac{\partial θ_{i}}{\partial θ} \approx I

\nabla_{θ} ℒ_{t e s t} (f_{θ_{i}}) \approx \nabla_{θ_{i}} ℒ_{t e s t} (f_{θ_{i}})

즉, 메타 러닝은 pre-train 시점에서의 task 의 최적 $θ$ 가 아닌 few-shot 으로의 fine-tune 이 몇 스텝만으로 이루어질 수 있도록 파라미터를 초기화 하는 것이 목표인 방법론이다.

θ^{*} = \arg \min_{θ} 𝔼_{𝒯_{i} \sim p (𝒯)} [ℒ_{𝒯_{i}} (θ - α \nabla_{θ} ℒ_{𝒯_{i}} (θ; 𝒟_{i}^{t r a i n}); 𝒟_{i}^{t e s t})]

0.2 Few-shot Adaptive Gaze Estimation

Few-Shot Adaptive Gaze Estimation

Appearance-based Gaze Estimation 문제에서 person-specific accuracy 를 위한 Test-time personalization 방법론 중 하나로, DT-ED 아키텍쳐와 MAML 전략을 사용한 AdaGEN 을 제안한다.

이미지 기반 시선추적 문제에서 개인 간의 해부학적 차이 등의 문제를 해결하기 위해 고전적인 vision software 기반 모델에서 소수의 샘플로 personalization 하는 방법론들이 제안되었지만, 통제되지 않은 환경에서의 이미지 변동에 강건하지 못하는 한계가 있었고, CNN 기반의 모델에서는 few shot 으로 personalization 을 하는 것이 과적합으로 이어졌다.

저자가 제안하는 FAZE 프레임워크에서는 rotation-aware latent representation 을 학습하고, 이 feature 들로 meta learning 을 이용해 few-shot adaptable 한 gaze estimator 를 학습한다.

등변성 (Equivarience) 는 input 이 바뀌면 output 도 동일하게 바뀌는 성질을 말한다. 최근 연구들은 입력, 잠재 특징, 레이블 공간 등의 equivariant mapping 학습을 강제함으로써 개선이 이루어짐을 보여주었다. Interpretable transformations with encoder-decoder networks 논문에서는 encoder-decoder 구조를 통해 합성 광원 방향과 같은 복잡한 현상을 학습하였고, Unsupervised geometry-aware representation for 3d human pose estimation 에서는 multi-view 환경에서 이 방법을 적용해 pose estimation 성능을 향상시켰다.

저자는 이 아이디어를 확장하여 gaze estimation task 에서 사용하는데, CNN 으로 부터 얻은 feature 는 그 자체로는 인간이 해석할 수 없는 벡터일 것이다. 하지만 만약 실제로 의미가 있는 representation 을 학습 시킬 수 있다면 큰 이점을 가질 수 있다.

먼저 어떤 image 가 있는데, 여기엔 사람이 정면을 응시하고 있다고 가정한다. 정면이 $0 °$ 라고 설정하고, 이 이미지를 $I_{0 °}$ 라고 하자. 또 다른 이미지는 같은 사람이 얼굴을 $30 °$ 회전한 이미지이고, $I_{30 °}$ 라고 표기한다.

head rotation equivariance 가 보장된 모델 $f (\cdot)$ 가 있다고 하면:

\begin{matrix} z_{1} = f (I_{0 °}) \\ z_{2} = f (I_{30 °}) \end{matrix}

에서 head rotation equivariance 가 보장되었으므로

z_{2} = [\begin{matrix} \cos 30 ° & 0 & \sin 30 ° \\ 0 & 1 & 0 \\ - \sin 30 ° & 0 & \cos 30 ° \end{matrix}] z_{1}

이다. 이것은 모델이 서로 다른 두 이미지에서 얼굴 자세만 분리 (distengling) 했다는 것을 의미한다. 서로 다른 이미지이니 조명, appearance 등 전혀 다른 이미지임에도 불구하고 시선 추정에 중요하게 작용하는 head pose 만을 정확히 모델링 해냈으며, 다르게 이야기하면 시선 추정에 필요 없는 노이즈에 대해 강건하다는 의미로 해석된다.

0.2.2 DT-ED

Disentangling Transforming Encoder-Decoder (DT-ED) 는 사람의 외형에 대한 잠재 표현이 실제로 머리, 눈의 회전을 반영하도록 하는데에 그 목적이 있다.

우선 눈과 머리 회전에 대한 표기를 정리한다. 눈의 회전은 $θ$ , 머리의 회전은 $ϕ$ 로 쓰고, 다음 회전 행렬로 변환된다.

R^{(θ, ϕ)} = [\begin{matrix} \cos ϕ & 0 & \sin ϕ \\ 0 & 1 & 0 \\ - \sin ϕ & 0 & \cos ϕ \end{matrix}] [\begin{matrix} 1 & 0 & 0 \\ 0 & \cos θ & - \sin θ \\ 0 & \sin θ & \cos θ \end{matrix}]

DT-ED 의 학습 과정에서 같은 사람의 두 이미지 $x_{a}$ , $x_{b}$ 를 입력한다고 하자. 샘플 $a$ 에서 $b$ 로 갈때의 시선 방향의 변화를 표현하기 위해 $R_{b a}^{g} = R_{b}^{g} {(R_{a}^{g})}^{- 1}$ 를 게산할 수 있다. 이는 $a$ 의 회전을 무마 (역행렬) 하고, 회전이 없는 상태에서 $R_{b}^{g}$ 만큼 회전한다고 해석한다. 즉 $a$ 에서 $b$ 로 가는 회전의 정도이다. 마찬가지로 머리의 회전 $R_{b a}^{h}$ 도 구할 수 있을 것이다.

여기서 실제로 두 샘플이 서로 어떻게 회전했는지에 대한 정답 데이터 $(g_{a}, g_{b})$ , $(h_{a}, h_{b})$ 를 구할 수 있을것이다. 그렇다면 latent code $z_{a}^{g}$ 의 회전은 ${\hat{z}}_{b}^{g} = R_{a b}^{g} z_{a}^{g}$ 로 표현될 수 있다. 학습 시에 $z_{b}^{g}$ 가 ${\hat{z}}_{b}^{g}$ 로 학습되도록 손실 함수를 설계하여 이를 달성할 수 있다.

DT-ED 에는 인코더 $ℰ : x \to z$ 와 디코더 $𝒟 : z \to \hat{x}$ 가 있으며, Latent embedding $z$ 는 아래와 같이 정의된다.

외형 임베딩: $z^{a}$
안구 회전 임베딩: $z^{g}$
머리 회전 임베딩: $z^{h}$

3가지 특징을 가지며, 단일 열을 만들기 위해 flatten 하여 $z = {z^{a}; z^{g}; z^{h}}$ 로 정의한다.

\begin{matrix} F \in ℕ \\ z^{g} \in ℝ^{3 \times F^{g}} \\ z^{h} \in ℝ^{3 \times F^{h}} \end{matrix}

디코더는 이 시선 잠재 표현 $z^{g}$ 에 어떤 Rotation Matrix 를 적용했을 때 $(R^{g} z^{g})$ , 이를 바탕으로 디코더의 출력 $\hat{x}$ 이 같은 사람의 이미지이되 ground-truth gaze/head rotation이 반영된 이미지가 만들어지도록 하는게 목표이며 이는 훈련 데이터셋에 있는 실제로 안구만 $R^{g}$ 만큼 회전한 이미지와 픽셀 단위의 비교 Loss 를 이용하여 달성한다. 이는 $z^{h}$ 에 대해서도 적용된다.

ℒ_{recon} (x_{b}, {\hat{x}}_{b}) = \frac{1}{| x_{b} |} \sum_{u \in x_{b}, \hat{u} \in {\hat{x}}_{b}} | \hat{u} - u |

위 사진은 각 임베딩을 임의로 회전시켜 만든 디코더의 출력 예시이다.

또다른 loss 의 항은 임베딩의 일관성을 위해 존재하는데, 아래와 같다.

ℒ_{EC} = \frac{1}{B} \sum_{i = 1}^{B} \max_{} d (f (z_{i}^{g}), f (z_{j}^{g}))

$B$ 는 배치 크기 이고 $f (z^{g}) = {(R^{g})}^{- 1} z^{g}$ 이다. 즉 latent representation 이 frontalized 된 형태이다. $d$ 는 벡터간 거리를 뜻하며, $i d (i)$ 는 $i$ 번째 샘플의 person-identity 이다.

즉 이 손실은 동일 인물간 최대 특징 차이를 최소화한다. 어떤 사람에 대해, 시선 방향이 $- 30 °$ 인 $z_{1}$ 과 시선 방향이 $48 °$ 인 $z_{2}$ 가 있을 때, 둘을 각각 frontalization 한 벡터의 거리가 샘플 중 최대라면, 그것을 최소화 하도록 하는 것이다. 이상적인 상황은 어떤 사람의 모든 frontalized latent representation 간 거리가 0인 상태일 것이다.

만약 이를 모든 사람에게 똑같이 적용해 버리면 시선 추정에 필수적인 개인 간의 해부학적 차이 마저 무시되어 성능이 심각하게 저하된다.

마지막으로 agular errro 항이다. gaze latent 에서 MLP $𝒢 : z^{g} \to \hat{g}$ 로 출력된 $\hat{g}$ 에 대한 손실이다.

ℒ_{gaze} (\hat{g}, g) = arccos (\frac{\hat{g} \cdot g}{‖ \hat{g} ‖ ‖ g ‖})

3가지의 항이 모여 모델의 full loss 가 정의된다.

ℒ_{full} = λ_{recon} ℒ_{recon} + λ_{EC} ℒ_{EC} + λ_{gaze} ℒ_{gaze}

0.2.3 AdaGEN, iPS-GEN

CNN 같이 구조가 복잡하고 over-parameterized 된 모델은 Few-shot 으로만 person-specific 모델을 만들어야 할 때 overfitting 의 위험이 있다. few-shot 에 너무 의존적으로 학습하여, 자칫하면 노이즈를 학습할 수 있기 때문이며 모델 복잡도 때문에 최적화의 어려움도 있다.

때문에 저자는 CNN 을 personalization 하지 않고, DT-ED 는 그대로 유지한 채 gaze feature $z^{g}$ 로 부터 시선 방향을 추론하는 MLP 모델만 personalization 의 대상으로 본다. 여기서 DT-ED 가 출력한 $z^{g}$ 로 부터 $\hat{g} \in R^{3}$ 을 추론하는 MLP 네트워크를 AdaGEN 이라고 한다.

또한 few-shot 상황에서 몇번의 경사 하강 만으로 성능을 끌어내기 위해 Meta Learning 방법론을 제안하며, AdaGEN 으로 부터 개인화된 네트워크를 PS-GEN 이라고 한다.

AdaGEN 을 few-shot adaptive 하게 meta-learning 하는 방법에 대해서 설명한다. 전체 사람 집합 $𝒮$ 을 중복되지 않는 피험자들로 구성된 $S^{train}$ 과 meta test $S^{test}$ 으로 나눈다. $n$ 번째 메타 학습에서 $S^{train}$ 내 한명을 무작위로 선택한다 → $𝒫^{train}$ . 해당 인물에 대해 데이터를 $k$ 개 샘플링한다. 샘플된 $k$ 개 데이터를 제외하고, $l$ 개를 더 샘플링한다.

\begin{matrix} 𝒫^{train} = {𝒟_{c}^{train}, 𝒟_{v}^{train}} \\ 𝒟_{c}^{train} = {(z_{i}^{g}, g_{i}) | i = 1 \dots k} \\ 𝒟_{v}^{train} = {(z_{j}^{g}, g_{j}) | j = 1 \dots l} \end{matrix}

여기서 $k, l$ 은 일반적으로 작으며, $k$ 는 few-shot 학습에서 사용되는 샷 갯수를 의미한다.

θ_{n}^{'} = θ_{n} - α \nabla ℒ_{𝒫^{train}}^{c} (f_{θ_{n}} (𝒟_{c}^{train}))

먼저 위와같이 모델의 파리미터가 $θ_{n}$ 일 때, $𝒟_{c}^{train} = {(z_{i}^{g}, g_{i}) | i = 1 \dots k}$ 의 대한 Loss 에 대해 경사하강을 수행하여 $θ_{n}^{'}$ 을 구한다.

이후 업데이트된 가중치 $θ_{n}^{'}$ 에서 $𝒟_{v}^{train} = {(z_{j}^{g}, g_{j}) | j = 1 \dots l}$ 평가된 Loss 를 계산하고, 해당 Loss 에 대한 경사하강을 $θ_{n}$ 에서 수행한다.

θ_{n + 1} = θ_{n} - η \nabla ℒ_{𝒫^{train}}^{v} (f_{θ_{n}^{'}} (𝒟_{v}^{train}))

수렴할 때 까지 학습을 반복하여 $θ^{*}$ 를 얻는다. 이제 DT-ED 와 AdaGEN 이 완성된 FAZE 모델 $ℳ_{θ^{*}}$ 이 만들어졌다.

Personalization 시점에서는 $S^{test}$ 로 부터 각 새로운 사람 $𝒫^{test}$ 에 대해 개인별 모델 $ℳ_{θ_{𝒫^{test}}}$ 를 학습한다.

\begin{matrix} 𝒫^{test} = {𝒟_{c}^{test}, 𝒟_{v}^{test}} \\ 𝒟_{c}^{test} = {(z_{i}^{g}, g_{i}) | i = 1 \dots k} \\ 𝒟_{v}^{test} = {(z_{j}^{g}, g_{j}) | j = 1 \dots l} \end{matrix}

θ_{𝒫^{test}} = θ^{*} - α \nabla ℒ_{𝓅^{test}}^{c} (f_{θ^{*}} (𝒟_{c}^{test}))

이제 $θ_{𝒫^{test}}$ 를 $𝒟_{v}^{test}$ 로 테스트한다.

0.2.4 Result

DT-ED 를 그대로 사용하고, MLP 에 대해 Meta learning 혹은 fine-tune 사용 간 결과를 볼 수 있다. shot 이 적을 때 심한 overfitting 이 발생하는 것에 비해 MAML trained 모델은 적은 샘플에서도 안정적으로 학습하는 것을 알 수 있다.

Auto Encoder (AE) + MAML 과 DT-ED + MAML 간 차이도 알 수 있는데, 두 모델 간 유일한 차이는 DT-ED 에서는 디코딩 하기 전에 latent 가 회전된다는 것이며, 저자는 더 어려운 작업임에도 불구하고 rotation-aware representation 이 최종 시선 추적 문제에 대해 더 유리한 것을 보여주며, 시선, 머리 자세, 외형을 분리하는 것이 시선 추정에 중요한 요소임을 주장한다.

0.3 TPGaze

Test-Time Personalization with Meta Prompt for Gaze Estimation

TPGaze 는 Gaze Estimation 모델의 Fine-tune 을 하는 방법론으로, NLP 분야의 프롬프트 튜닝에서 영감을 받았다. CNN 에서의 Padding 을 Zero Padding 하지 않고 Tunable Padding 으로 대체하여 일종의 프롬프트로써 사용한다.

패딩 값을 변경하면 Convolution 이후 feature map 이 달라지므로, 이를 통해 네트워크의 동작을 특정 사용자에게 맞게 유도할 수 있다. 이는 모델 아키텍쳐를 그대로 가져갈 수 있다는 장점을 가지며, 전체 파라미터의 1% 미만을 업데이트 하므로 계산 비용이 매우 적다.

즉 몇개의 unlabled data 만으로 Test time personalization 하는것이 목적이며, source domain 에서의 backbone 학습은 다음과 같다:

θ = arg \min_{θ} (ℒ_{1} (f_{θ} (ı_{S}), y_{S}) + ℒ_{u n} (f_{θ} (ı_{S}), ı_{s}))

$ℒ_{1}$ 은 supervised-loss, $ℒ_{u n}$ 은 unsupervised loss 를 의미한다.

Backbone 에 train 시 $ℒ_{𝓊 𝓃}$ 를 사용하는 이유는 이후 test-time에 unsupervised loss로만 적응해야 하니, 그 loss를 미리 모델에 학습시켜 두는 것으로 이해할 수 있다. 이는 많은 UDA 연구들에서 사용되는 기법이며, TPGaze 저자는 후술할 $ℒ_{p e r}$ 를 사용한다.

이제 Convolution Padding 을 Prompt 로 취급하고, Prompt 만 Meta-Learning 한다. 학습된 모델 $f_{θ}$ 가 주어졌을 때 프롬프트 $p$ 를 도입하여 모델을 수정하고 새로운 모델 $f_{{θ, p}}$ 를 얻는다.

ℒ_{s y m} (f_{θ} (x_{i}^{s}), f_{θ} (T (x_{i}^{s}))) = \frac{1}{2} {‖ f_{θ} (x_{i}^{s}) - [\begin{matrix} 1 & 0 \\ 0 & - 1 \end{matrix}] f_{θ} (T (x_{i}^{s})) ‖}_{1}

ℒ_{p e r} (f_{θ} (x_{i}^{s}), x_{i}^{s}) = ℒ_{s y m} (f_{θ} (x_{i}^{s}), f_{θ} (T (x_{i}^{s})))

$ℒ_{p e r}$ 는 사람의 얼굴이 좌우 대칭이라는 점을 이용한 left-right symmetry loss 이다. 어떤 이미지에 대한 모델의 출력과, 그 이미지를 좌우 반전 시킨 이미지의 출력이 yaw 만 뒤집힌 형태로 나오도록 유도한다.

참고:

left-right symmetry loss 가 아닌 rotation consistency loss 도 선택지 중 하나였지만, 원본 이미지의 여러 회전 버전에 대한 네트워크 출력을 요구하여 모델 train 시 큰 비용이 필요해 선택되지 못했다.

아래 알고리즘을 따라 메타 학습이 진행된다.

source domain data 셋인 ${ℐ_{S}, 𝒴_{S}}$ 에서 mini-batch 를 샘플링 하고, mini-batch 의 각 입력 $x_{i}$ 에 대한 프롬프트 $\hat{p}$ 을 구한다. (Inner loop) 이후 $\hat{p}$ 들에 대한 loss 로 $p$ 가 업데이트된다. (Outer loop)

여기서 중요한 것은 Inner loop 과 Outer loop 의 Loss 가 다른데, 이는 test-time 에 unsupervised learning 을 해야하기 떄문에 각 샘플에서 $ℒ_{p e r}$ 에 대한 경사하강 결과인 $\hat{p}$ 을 구하긴 하지만 결국에 모델 자체의 의 성능을 유지시켜야 하기 때문에 $p$ 는 $ℒ_{1}$ 의 최적화 결과이다.

이후 사람 $j$ 에 대한 Test-time personalization 은 아래 식으로 진행된다:

p_{j} = \arg \min_{p} ℒ_{p e r} (f_{{θ, p}} (𝒜_{𝒿}), 𝒜_{j})

시험에 따르면, ResNet-18의 17개 Convolutional layer 전체에 프롬프트를 적용하면 오히려 성능이 크게 하락한다. 이는 모델의 가장 깊은 층이 변경되면, 고정되어 있는 마지막 Linear layer와의 매핑이 어긋나기 때문이며 첫 9개의 Convolutional layer에만 프롬프트를 추가하는 것이 성능과 효율 면에서 가장 이상적이라고 제안한다.

Alfa 는 이 TPGaze 논문에서 설계한 실험을 거의 그대로 수행하여 TPGaze 대비 성능 우위를 주장한다.

0.4 Singular Value Decomposition

먼저 SVD 를 설명하기 전에 eigenvalue 와 egienvector 를 알아야한다.

어떤 정방 행렬 $A \in ℝ^{n \times n}$ 를 선형변환으로 봤을 때, $A$ 에 의한 변환 결과가 자기 자신의 상수배가 되는 벡터를 eigenvector 라고 하고, 그 상수를 eigenvalue 라고 한다.

\begin{matrix} A v = λ v \\ v = eigenvector of A \\ λ = eigenvalue of A v \end{matrix}

eigenvalue 와 eigenvector 는 행렬에 따라 아예 존재하지 않을 수도 있고, 1개에서 $n$ 개 까지 존재할 수 있다.

이는 기하학적으로 보았을 때 선형 변환 $A$ 에 의해 방향은 보존되고 scale 만 변화되는 방향 벡터를 나타내는 것으로, 이때 eigenvector 변환의 축, eigenvalue 는 변환의 scale 정도 라고 표현할 수 있다.

이러한 성질을 이용하여 $A$ 를 eigendecomposition 할 수 있는데, 정방 행렬 $A$ 가 $n$ 개의 eigenvalue/vector 를 가진다고 하면 아래와 같이 표현할 수 있다.

\begin{matrix} A v_{1} = λ_{1} v_{1} \\ A v_{2} = λ_{2} v_{2} \\ ⋮ \\ A v_{n} = λ_{n} v_{n} \end{matrix}

\begin{matrix} A [\begin{matrix} | & | & | & | \\ v_{1} & v_{2} & v_{3} & \dots & v_{n} \\ | & | & | & | \end{matrix}] = [\begin{matrix} | & | & | & | \\ λ_{1} v_{1} & λ_{2} v_{2} & λ_{3} v_{3} & \dots & λ_{n} v_{n} \\ | & | & | & | \end{matrix}] \\ = [\begin{matrix} | & | & | & | \\ v_{1} & v_{2} & v_{3} & \dots & v_{n} \\ | & | & | & | \end{matrix}] [\begin{matrix} λ_{1} & 0 & 0 & \dots & 0 \\ 0 & λ_{2} & 0 & \dots & 0 \\ 0 & 0 & λ_{3} & \dots & 0 \\ ⋮ & ⋮ & ⋮ & ⋱ \\ 0 & 0 & 0 & λ_{n} \end{matrix}] \end{matrix}

에서, 행렬 $A$ 의 eigenvector 를 열벡터로 하는 행렬을 $P$ , eigenvalue 를 대각원소로 하는 대각 행렬을 $Λ$ 라고 하면:

\begin{matrix} A P = P Λ \\ A = P Λ P^{- 1} \end{matrix}

이처럼 임의의 정방 행렬 $A \in ℝ^{n \times n}$ 이 $n$ 개의 일차 독립 eigenvector 를 가지면 대각화 분해 할 수 있다. 즉 벡터 $v_{1}, v_{2}, v_{3}$ 에 대해, $a_{1} v_{1} + a_{2} v_{2}$ $(a_{i} \in ℝ)$ 로 $v_{3}$ 을 만들 수 없다면 $v_{3}$ 은 $v_{1}, v_{2}$ 에 대해 일차 독립하며, 모든 eigenvector 가 서로에게 일차 독립하면 eigendecomposition 을 할 수 있다.

여기서 eigenvalue 는 행렬에 대해 유일하게 결정되지만 eigenvector 는 그렇지 않기 때문에, $‖ v ‖ = 1$ 을 만족하는 벡터를 사용하는 것이 일반적이다.

이제 정방 행렬이 아닌 임의의 행렬 $A \in ℝ^{m \times n}$ 를 선형 변환으로 보고 행렬을 분해해보자.

먼저 대칭 행렬은 eigendecomposition 이 항상 가능하다. 그렇기 때문에 $A^{⊤} A$ 과 $A A^{⊤}$ 도 이를 수행할 수 있다. 이제 행렬 $A$ 를 분해하면 다음과 같다:

A = U Σ V^{⊤}

$U$ 는 $A A^{⊤}$ 의 eigenvector 들을 열벡터로 가지는 직교 행렬, $V$ 는 $A^{⊤} A$ 의 eigenvector 를 열벡터로 가지는 직교 행렬이다.

$Σ$ 는 $A A^{⊤}$ , $A^{⊤} A$ 의 eigenvalue 의 제곱근을 대각 원소로 가지는 대각 행렬인데, 두 행렬의 eigenvalue 는 서로 같다.

$A^{⊤} A v = λ v$ 에서 양 변에 $A$ 를 곱하면 $A (A^{⊤} A) v = λ A v$ , 즉 $A A^{⊤} (A v) = λ (A v)$ 이다. 곧 $v$ 는 $A^{⊤} A$ 의 eigenvector 이고, $A v$ 는 $A A^{⊤}$ 의 eigenvector 임을 알 수 있고, eigenvalue 는 $λ$ 로 같다.

Σ = [\begin{matrix} \sqrt{λ_{1}} = σ_{1} & 0 & 0 & \dots & 0 \\ 0 & \sqrt{λ_{2}} = σ_{2} & 0 & \dots & 0 \\ 0 & 0 & \sqrt{λ_{3}} = σ_{3} & \dots & 0 \\ ⋮ & ⋮ & ⋮ & ⋱ \\ 0 & 0 & 0 & \sqrt{λ_{n}} = σ_{n} \end{matrix}]

선형 변환에서 변환의 각 축을 의미하는 eigenvector 를 열벡터로 가지는 $U, V$ 는 모두 직교 행렬이고, $R^{⊤} = R^{- 1}$ 가 성립한다. 모든 열벡터 에 대해 $‖ v ‖ = 1$ 이므로, $\det (R R^{⊤}) = \det (R^{2}) \to \det (R) = \pm 1$ 이다.

곧 $U, V$ 는 회전(회전 + 반사) 행렬이고, $Σ$ 는 대각행렬 이므로 $A x$ 는 $x$ 를 $V^{⊤}$ 에 의해 회전시킨 후 $Σ$ 로 Scaling 을 한 뒤 다시 $U$ 로 회전시키는 것으로 해석할 수 있다.

그럼 왜 $A = U Σ V^{⊤}$ 가 성립할까?

각 $v_{i}$ 에 대해 $A^{⊤} A v_{i} = λ v_{i}$ 에서, 양 변에 $v_{i}^{⊤}$ 을 곱하면:

v_{i}^{⊤} A^{⊤} A v_{i} = λ v_{i}^{⊤} v_{i} \to ‖ A v_{i} ‖^{2} = λ ‖ v_{i} ‖^{2}

에서 $v_{i}$ 가 단위 벡터 이므로 , $‖ A v_{i} ‖ = σ_{i}$ 이다. 이제 $u_{i} : = \frac{A v_{i}}{σ_{i}}$ 로 정의한다. $u_{i}$ 도 마찬가지로 단위 벡터이다.

정의로부터 $A v_{i} = σ_{i} u_{i}$ 이다. 이때 아까의 $A A^{⊤} (A v_{i}) = λ_{i} (A v_{i})$ 에서 양변을 $σ_{i}$ 로 나누면 $A A^{⊤} u_{i} = λ_{i} u_{i}$ 이다. 즉 $\frac{A v_{i}}{σ_{i}}$ 는 $A A^{⊤}$ 의 고유벡터이다.

이제 $v_{i}$ 가 아닌 모든 $A^{⊤} A$ 의 정규 직교 고유벡터들을 모은 $V$ 로 풀어서 써보자:

A V = A [v_{1} v_{2} \dots v_{n}] = [A v_{1} A v_{2} \dots A v_{n}] = [σ_{1} u_{1} σ_{2} u_{2} \dots] = U Σ

에서, $V V^{⊤} = I$ 이므로,

A V V^{⊤} = U Σ V^{⊤} = A

즉 $A$ 는 $A^{⊤} A$ 의 정규 고유 벡터 집합, $A A^{⊤}$ 의 정규 고유 벡터 집합, 두 행렬의 특이값의 대각 행렬로 완벽히 복원된다.

truncated SVD는 SVD에서 특이값( $Σ$ )이 큰 것부터 $d$ 개만 남기고 나머지를 버리는 것이다. 이렇게 하면 원래 행렬을 가장 비슷하게 유지하면서도 더 단순한(낮은 rank의) 행렬로 압축할 수 있다.

이는 머신러닝의 가중치 관점에서 보면, 가중치가 가장 강하게 작용하는 $d$ 개의 방향만 남기고, 영향이 작은 방향은 제거하는 것이라고 볼 수 있다. 즉, 모델이 주로 사용하고 있는 큰 변화 방향을 보존하는 방법이라고 해석할 수 있다.

0.5 Low-Rank Adaptation

자연어 처리 문제에서 중요한 문제중 하나는 일반 도메인 데이터에 대한 pretrained 모델에서 특정 작업 또는 도메인으로 adaptation 하는 것이다. 일반적으로 base model 의 크기가 커질 수록 모든 파라미터를 재학습 하는 full fine-tuning 은 현실적으로 어려워진다.

GPT-3 175B 의 경우 각각 175B 파라미터를 가진 fine-tuned 모델을 배포하는 것은 터무니없는 비용이 들것이다. 논문 저자는 pretrained 모델의 가중치를 고정하고 Transformer 아키텍쳐의 각 계층에 learnable low-rank matrix를 주입하여 학습가능한 파라미터 수를 획기적으로 줄이는 LoRA 를 제안한다.

LLM 연구들은 폭발적으로 증가했으며 이에 따라 모델 크기도 더욱 커졌다. GPT-2 수준의 크기에서는 대두되지 않았으나 175B 정도 사이즈인 GPT-3 에서는 언급했듯 fine-tuned 모델을 배포하는 것이 엄청난 부담이 되었다.

기존 Fine-tune 방법론들은 일부 파라미터들만 adaptation 하거나 새로운 작업을 위해 Adapter 같은 모듈을 학습 시키는 방식으로 이 문제를 해결하려고 했으며 pretrained 모델에 더해 소량의 파리미터만을 저장/로딩하면 되어 배포 시 효율성이 크게 향상되었다.

그러나 기존 방법론들은 모델 깊이를 확장해 Inference Latency 를 증가시키거나 모델의 시퀀스 길이를 줄이는 경우도 있었다. 제일 중요한것은 이런 방법들이 종종 fine-tune 기준 성능에 미치지 못해 효율성과 모델 퀄리티 사이에 trade-off 를 발생시킨다는 점이다.

LoRA 는 over-parameterized 모델이 실제로 낮은 low intrinsic demension 에 존재한다는 것을 보여준 Chunyuan Li et al 의 “MEASURING THE INTRINSIC DIMENSION OF OBJECTIVE LANDSCAPES” 논문에서 아이디어를 얻는다.

해당 논문에서는 최근 모델들이 방대한 수의 파라미터를 사용하며, 훈련 과정에서 데이터셋과 네트워크 아키텍쳐가 결정되는 순간 objective landscape 의 전체 구조가 고정되며, Loss 를 최소화하기 위해 이 다차원 landscape 를 탐색하며 최적의 경로를 찾는 과정이라는 것을 전제로, 문제를 기 위해 필요한 파라미터의 수를 파악하기 위해 진행된 연구이다. 즉 어떤 문제가 있을때, 실제로 문제를 푸는데 필요한 최소한의 파라미터는 몇개인가? 에 대한 답을 하기 위한 논문이다.

Chunyuan Li et al 의 가설은 네트워크를 원래의 방대한 $D$ 차원 공간에서 최적화 하지 않고, 훨씬 더 작은 $d$ 차원을 가진 무작위 방향의 부분 공간으로 훈련을 제한하더라도 문제를 해결할 수 있을 것이라는 것이다. 곧 이 $d$ 를 점진적으로 늘려가며 유효한 solution 이 등장하는 시점을 intrinsic dimension $d_{i n t}$ 로 정의하고, 목적 함수 landsacpe 의 실질적인 복잡도 및 어려움을 나타는 척도가 된다고 설명한다. 저자는 $d$ 시점의 모델을 무작위 projection matrix $P$ 를 통해 $D$ 차원으로 사상하여 테스트를 진행한다.

θ = θ_{0} + P z P \in ℝ^{D \times d} z \in ℝ^{d}

해당 실험으로 많은 문제들이 예상보다 훨씬 적은수의 차원 만으로도 해결 가능했으며, 네트워크의 Depth 나 Width 를 늘리더라도 측정된 $d_{i n t}$ 는 거의 변하지 않았음을 실험적 결과로 보였다. 즉 모델 규모가 증가하더라도 intrinsic dimension은 크게 변하지 않았으며, 이는 많은 추가 파라미터가 표현 redundancy를 제공하고 있음을 시사한다.

다시 LoRA 로 돌아와서, LoRA는 full fine-tuning에서 발생하는 weight update $Δ W$ 또한 low-rank 구조를 가진다고 가정하며, 이를 rank- $r$ factorization으로 parameterize 한다.

$W \in ℝ^{d \times k}$ 를 fine-tune 할 때, $W \leftarrow W + Δ W$ 에서 $Δ W$ 를 $B A$ 로 정의한다.

Δ W = B A, B \in ℝ^{d \times r} A \in ℝ^{r \times k}, r ≪ \min (d, k)

차원을 $r$ 로 제한하면 $rank (B A) \leq \min (rank (B), rank (A))$ 이므로, 업데이트 가중치는 반드시 low-rank 업데이트로 강제된다.

$A$ 는 무작위 Gaussian initialziation 을 하고, $B$ 는 영행렬로 초기화된다. 즉 초기 상태는 $Δ W = B A = O$ 이므로, 학습의 처음 상태는 base model 과 동일하다. 또한 어떤 입력 $x$ 로 부터 forward pass 는 다음과 같은데:

h = W_{0} x + Δ W x = W_{0} x + B A x

여기서 $Δ W x$ 의 분산은 $r$ 에 비례한다. 이는 $Δ W$ 가 $r$ 개의 independent 한 rank-1 update 의 합으로 표현되기 때문이다. 따라서 $r$ 이 증가할수록 update 의 scale 이 커질 수 있으므로, $Δ W x$ 에 $\frac{α}{r}$ 를 곱해 magnitude 를 보정한다. 여기서 $α$ 는 하이퍼파라미터이다.

FT 모델 전체를 fine-tune 한다.
BitFit 모델의 Bias 항 만 업데이트한다.
${Adapter}^{H}$ Houlsby et al. (2019) 이 제안한 오리지널 어댑터이다. Self-attention 모듈과 MLP 모듈 뒤에 각각 삽입된다. $h_{l}^{'} = h_{l} + W_{u p} σ (W_{d o w n} h_{l})$
${Adapter}^{D}$ 모델의 레이어들에서 출력 레이어로 갈 수록 task-specific representation 담당한다는 전제에서 상위 layer 의 adapter 를 제외하고 drop 시키는 방법론이다.
${Adapter}^{P}$ MLP 모듈과 LayerNorm 이 끝난 직후에 단 하나만 적용되는 Adapter이다.

Table 2는 자연어 이해 성능을 평가하는 대표적인 벤치마크인 GLUE를 사용하여, 세 가지 서로 다른 규모의 언어 모델(RoBERTa base, RoBERTa large, DeBERTa XXL)에 다양한 adaptation 방법을 적용했을 때의 성능을 비교한 결과를 보여준다.

LoRA가 전체 파라미터를 모두 업데이트하는 전통적인 Fine-Tuning 방식과 비교했을 때, 학습해야 하는 파라미터 수를 극단적으로 줄이면서도 성능은 동등하거나 오히려 더 높은 결과를 달성한다. 예를 들어 RoBERTa base 모델에서는 전체 Fine-Tuning이 약 1억 2,500만 개의 파라미터를 학습하여 평균 86.4의 성능을 기록한 반면, LoRA는 단 30만 개의 파라미터만 학습하면서도 평균 87.2의 성능을 달성하였다.

RoBERTa large에서도 동일한 경향이 나타나는데, 전체 Fine-Tuning이 3억 5,500만 개의 파라미터로 평균 88.9를 기록한 반면 LoRA는 약 80만 개의 파라미터만으로 89.0을 기록하였다. 이러한 결과는 훨씬 더 큰 모델에서도 유지된다. 약 15억 개의 파라미터를 가진 DeBERTa XXL 모델에서도 전체 Fine-Tuning이 평균 91.1을 기록할 때 LoRA는 단 470만 개의 파라미터만을 사용하여 91.3의 성능을 달성하였다. 이는 LoRA가 큰 모델에서도 매우 높은 파라미터 효율성을 유지하면서 성능을 유지하거나 향상시킬 수 있음을 보여준다.

또한 자연어 모델에서의 학습 관례 중 하나는 pre-trained 모델이 있을 때 MNLI 데이터셋으로 먼저 intermediate task training 를 진행 한 다음 하위 task 로 fine-tune 하는 것이다. 이는 pre-trained model 에서 바로 하위 task 로 fine-tune 하는것이 불안정하기 때문인데, Table 2의 실험에서 일부 데이터셋(MRPC, RTE, STS-B)에 대해서는 일반적인 fine-tune에서 사용하는 MNLI 을 사용한 초기화를 허용하지 않고 순수한 사전학습 모델에서 바로 학습하도록 제한하였다.

이러한 조건은 LoRA에게 불리한 설정이지만, 그럼에도 불구하고 LoRA는 여전히 다른 Adapter 기반 방법들을 능가하는 성능을 보였다. 예를 들어 약 80만 개의 파라미터를 사용하는 LoRA는 평균 88.6을 기록하여, 300만 개의 파라미터를 사용하는 AdapterP(평균 88.4)와 600만 개의 파라미터를 사용하는 AdapterH(평균 87.8)보다 더 높은 성능을 달성하였다.

또한 저자는 Table 6 에서 전제한 “fine-tune 하여 찾을 수 있는 최적 가중치 업데이트 $Δ W$ 는 low-rank matrix $B A B \in ℝ^{n \times r} A \in ℝ^{r \times m}$ 로 근사할 수 있을 것이다” 라는 전제에 대한 실험적 결과를 보여준다.

낮은 rank $r \in {1,2,4,8}$ 에서도 충분한 성능을 확인할 수 있었고, low-rank update 의 효용을 증명하였다.

LoRA 는 기존 가중치에 흡수시킬 수 있는 형태의 learnable parameter 를 가지므로 배포에 용이하다는 장점과, Adapter 같은 방법론과 달리 흡수시킨 이후에는 추가적인 추론 비용 증가가 없다는 장점이 있다. 또한 $r$ 을 키울수록 full fine-tune 과 똑같아지기 때문에, 원래 모델을 학습하는 것에 수렴한다는 장점 등으로 인해 많은 개인화 문제에서 채택되고있다.

1. Introduction

Appearance-based Gaze Estimation 은 얼굴 이미지나 눈 영역의 이미지로부터 사람이 바라보는 방향을 추론하는 기술이다. 이 기술은 인간-컴퓨터 간 상호작용 등 다양한 분야에서 이용되고 있으며 시선 기반 응사소통 시스템에서는 이 기술이 필수적이다.

Gaze Estimation 기술은 통제된 환경에서는 우수한 성능을 보이지만 실제 환경에서는 그렇지 않을 수 있다. 사용자 간 차이, 카메라 세팅, 조명, 머리 자세 등의 환경적 요인이 Train 과 Test(배포) 간 불일치를 야기한다. 이런 도메인 변화는 모델이 Train 조건을 벗어난 상황에 대해 모델이 Robust 하지 못하게 한다.

Test-Time Personalization 은 Unsupervised Domain Adaption 의 한 변형이다. 이는 Test 상황에서 새로운 사용자에 대한 unlabeled 데이터로 모델을 적응시키는 방법론이다. 이는 Few-shot 환경에서 on-device adaptation 을 가능하게 하며 labeled 데이터가 필요하지 않는 점이 이점으로 작용한다.

사람의 얼굴은 공간적으로 일관된 패턴(눈, 얼굴의 기하학적 구조)을 보일 수 있고, 충분한 학습을 거치면 모델은 이런 패턴에 대응하는 일반적 특정을 포착하고 가중치 내부의 공간적 구조로 인코딩한다. (feature extraction) 그너라 이런 패턴의 대한 작은 변화만으로도 예측 정확도는 크게 떨어질 수 있다. fine-tune 은 이 문제를 완화하는데에 도움이 될 수 있지만, 사전 학습된 모델로부터 더 많은 정보를 활용한다면 성능을 더욱 향상시킬 수 있다.

저자는 완전히 새로운 feature 를 학습하는 대신 기존 feature 를 활용하는 것이 Gaze Estimation Task 에서 데이터가 제한된 상황 (few-shot) 에서 효과적임을 확인했다.

본 논문에서는 사전 학습된 filter (CNN kernel) 에 인코딩된 공간적 구조를 reweighting 하므로써 Gaze Estimation 모델을 적응시키는 Attentive Low-Rank Filter Adaptation (Alfa) 을 제안한다.

Alfa 는 사전학습된 Weight 에 대해 SVD 를 수행하여 공통적인 패턴에 대응되는 지배적인 공간 구조를 추출한다. 즉 새로운 filter 를 학습하거나 새로운 가중치를 초기화 하는 대신 대상 사용자로부터 얻은 few-shot unlabeled 샘플을 이용하여 지배적 패턴들의 영향력을 조절한다. 이를 통해 원래 학습된 representation 과 alignment 는 유지하면서도 최소한의 few-shot 데이터만으로 personalized prediction 이 가능해진다.

이후 서술할 시각화 결과는 Alfa 가 사용자마다의 특징인 눈꺼풀과 같은 직관적이고 국소적인 공통 영역을 추가 가중하는 것을 확인할 수 있다.

Main Contribution

Attentive Low-Rank Filter Adaptation(Alfa)은 가중치를 비구조적인 텐서로 취급하는 대신, SVD로부터 도출된 구조화된 공간 패턴에 주의를 기울이는 방식으로 시선 추정 모델을 적응시킨다.
Alfa 내의 멀티헤드 Low-Rank 적응 모듈은 미세 조정 시 확장 가능한 개인화 용량을 제공한다. 사전 학습된 가중치를 truncated SVD 형태로 저장함으로써 모델 크기를 줄일 수 있으며, 배포 시 모델 크기를 증가시키지 않고도 Alfa의 업데이트를 완전히 병합 가능하게 한다.
소수의 비라벨 테스트 시점 샘플만을 사용하여 네 개의 교차 도메인 시선 추정 벤치마크에서 Alfa가 기존 방법들을 능가함을 실증적으로 보인다.
Alfa의 구조화된 적응 기법을 확산 기반 대규모 언어 모델(LLM)로 확장하여, 여러 벤치마크 전반에서 제로샷 추론 성능이 향상됨을 보인다.

2.1 Test-Time Personalization (TTP)

도메인 변화에 대한 일반화를 하기 위해 Gaze estimation 모델들은 Unsupervised Domain Adaptation 을 채택했다. 표준적인 UDA 설정에서는 labeled source-domain 데이터, unlabeled target-domain 데이터를 함께 사용한다.

PnP-GA 는 소수의 source-domain 데이터와 unlabeled target-domain 데이터를 사용하며 특정 모델이 타겟 도메인의 노이즈에 과적합될 수 있다는 불안정성을 다수 모델의 통계적 합의로 해결하려 한다. 이 아키텍처는 소스 데이터로 사전 학습된 여러 개의 모델을 하나의 앙상블 그룹으로 묶고, 이들이 타겟 데이터를 바라볼 때 내놓는 예측값들의 분포를 분석한다.

outlier-guided loss 는 batch 단위에서, 시선 예측값 $g_{k}$ 가 얼마나 평균으로 부터 떨어져있는지를 임계점 기준으로 판단하여 loss 에 패널티를 주는 방법론이며, annotation 자체가 정확하지 않을 수 있는 gaze estimation task 에서 효과를 어느정도 입증했다.

반면 RUDA는 통계적 합의 대신, 3차원 공간에서 시선 벡터가 가져야 하는 ‘물리적 불변성’에 집중한다. 사람의 얼굴 이미지를 특정 각도 $R$ 만큼 회전시킨다면, 그 내부의 시선 방향 역시 동일한 기하학적 회전을 따라야 한다는 법칙을 이용하는 것이다.

RUDA는 타겟 도메인의 unlabeled 이미지를 인위적으로 회전시켜 증강 집합을 만들고, 원본 이미지의 예측값과 회전된 이미지의 예측값 사이의 상대적 차이가 가해진 회전량과 일치하는지를 검증한다. 이를 Rotation Consistency 이라 정의하며, 역회전 모듈을 통해 복원된 시선 벡터들이 하나의 일관된 방향으로 수렴하도록 Distribution Loss를 적용한다. 예측값들의 표준편차를 최소화함으로써, 모델이 이미지의 회전이나 왜곡에 상관없이 안구의 기하학적 특징만을 추론하도록 강제한다.

Few-shot Adaptive Gaze Estimation 은 소수의 개인별 labeled 데이터를 이용해 fine-tune 하지만, labeled data 를 얻는 과정이 강제되며 비현실적인 경우가 많다.

TTP 는 추론 단계에서 소수의 unlabeled 개인 샘플만을 이용하여 각 사용자에 맞게 모델을 적응시킴으로써 이러한 문제를 해결한다. TPP 는 사용자 외형이 다양하고 전체 모델을 업데이트 하기에는 자원 부담이 큰 온디바이스 환경에 특히 적합하다. 이러한 제약들은 labeled 데이터나 source-domain 접근 없이도 personalization 을 지원할 수 있는 효율적이고 경량화된 adaptation 방법론이다.

저자가 이 논문에서 제안하는 Alfa 는 추가적인 추론 비용 없이 TTP 를 지원하며, fine-tune 단계에서 multi-head adaptation 을 통해 확장하고 SVD 를 이용해 사중치의 핵심적인 성분을 선택함으로써 효율적인 모델을 구현한다.

2.2 Low-Rank Adaptation

LoRA: Low-Rank Adaptation of Large Language Models

Low-Rank Adaptation 은 사전 학습된 모델의 원래 가중치를 변경하지 않고, 학습 가능한 작응 행렬을 삽입 ( $W + Δ W$ ) 하여 fine-tune 하는 기법이다. LoRA 는 기존 층에 rank 가 제한된 업데이트를 추가하며, 다양한 task 에서 우수한 성능을 보인다.

기존 fine-tune 방법론 중 하나인 Adapter 에서는 모델에 adaptation 을 위한 레이어를 추가해 inference latency 가 큰 단점이었고, 얼마나 큰 Adapter Layer 를 두냐에 따라 파라미터 크기가 크게 늘어날 수 있었다.

LoRA 의 목적은 성능은 유지하면서 Task 별로 저장해야하는 파라미터와 학습 시 메모리를 크게 줄이고, inference latency 도 유지하는 방향으로 연구되었다.

LoRA 의 핵심 아이디어는 업데이트 될 가중치 $Δ W$ 가 low-rank 일 수 있다는 가정이다. 그래서 전체 $W$ 를 직접 학습하는게 아닌 업데이트될 low-rank 가중치만 학습한다.

만약 Linear Layer 의 가중치 $W \in ℝ^{d \times k}$ 를 fine-tune 할 때, $W \leftarrow W + Δ W$ 에서 $Δ W$ 를 $B A$ 로 정의한다.

Δ W = B A, B \in ℝ^{d \times r} A \in ℝ^{r \times k}, r ≪ \min (d, k)

h = W x + B A x

$r$ 은 하이퍼 파라미터로, 몇 rank 까지 fine-tune 할건지를 의미한다. $B A x$ 에서 $A x$ 는 입력 $x$ 를 $r$ 차원 latent subspace 로 압축하고, $B$ 에서는 출력 공간에서 $r$ 개의 방향이 선택되는 구조이다. 일종의 bottleneck 구조라고 할 수 있다.

LoRA 는 inference 시에 $W + B A$ 를 합쳐서 저장할 수 있기 때문에 Adapter 와 다르게 fine-tune 했다고 해서 추가적인 연산이 필요해지지 않는다.

Transformer 에서는 self-attention 에서 attention factor 를 만들기 위한 projection weights ( $W_{Q}, W_{K}, W_{V}$ ) 등에 사용된다.

LoRA 는 $r$ rank 만 fine-tune 해도 full fine tune 을 근사할 것이라는 전제 하에 연구되었는데, 실제로 GPT-3 같은 모델에서도 $r = 1,2,4$ 같이 매우 작은 값에서도 유의미한 성능을 관측했으며 오히려 $r$ 이 크면 노이즈로 동작할 수 있음도 관측되었다.

본 논문에서 Related Work 로 제시하는 LoRA 를 차용한 선행 연구들은 다음과 같다:

MiLoRA: SVD 로 부터 얻은 상위 주성분은 학습이 모두 진행되었다고 간주하고, Minor 한 성분들에서 finetune 을 시도한다.
PiSSA: LoRA 의 기본 아이디어를 사용하되 상위 $Σ$ 성분을을 기존 파라미터에서 추출하여 초기화 해 수렴 속도를 개선한다.

$A = U_{[:, : r]} Σ_{[: r, : r]}^{1 / 2} B = Σ_{[: r, : r]}^{1 / 2} V_{[:, : r]}^{T}$
MoSLoRA: 표현 능력을 향상시키기 위해 LoRA 모듈 사이에 Mixer Matrix 를 배치한다. $x A W B$
Spectral Adapter $^{A}$ $Σ$ 의, 즉 singular value 의 새로운 coefficient 만 학습한다. 이는 기존에 가중치가 가지고있던 기저 방향을 유지 한 채로 특정 기저의 energy 만 업데이트한다고 볼 수 있다. $Δ Σ = U^{T} Δ W V ⊙ I_{m \times n}$
DoRA: 고차원의 두꺼운 단일 LoRA 레이어를 구조화된 다수의 단일 랭크(Single-rank) 미니 전문가 구성요소들로 잘게 쪼개 앙상블한다.
FLoRA: Shared Low-Rank core 를 통해 파라미터의 변화를 포착하기 위해 Tucker 분해를 적용한다. 터커 분해는 임의의 N차원 고차원 텐서 $𝒳$ 를 데이터의 본질적 기하학 관계를 압축하고 있는 다차원 핵심 Core Tensor 하나와, 각 모드(차원 축)별 표상을 변환하는 직교 투영 행렬(Factor Matrices)들의 다중 모드 곱으로 분해하는 알고리즘이다.

LoRA 기반의 다양한 Adaptation 전략에도 불구하고 이러한 방법론들은 가중치를 비구조적인 텐서로 취급하며 filter 에 인코딩 되어있는 공간적 구조를 간과한다.

Alfa 는 가중치의 공간적 구조에 주의를 기울이고 personlization 과정에서 이를 reweighting 아여 구조 인지적 adaptation 을 가능하게 한다.

3. Alfa

3.1 Problem Definition and Preliminary

저자는 Gaze estimation 을 위한 TTP 를 완전히 새로운 Task 로 정의하지 않고, UDA 계열 Task 로 재해석한다. UDA 의 목적과 마찬가지로 Alfa 의 목적도 source 도메인 $𝒟_{S}$ 에서 학습된 모델을 새로운 사용자에 해당하는소수의 unlabeled 데이터 만으로 target 도메인 $𝒟_{T}$ 로 적응시키는 것이다.

각 RGB 입력 이미지를 $I$ 로, 그리고 매핑되는 시선 방향을 2차원 벡터 $g \in ℝ^{2}$ (yaw와 pitch)로 표기한다. 소스 도메인은 ${(I_{i}^{S}, g_{i}^{S})}_{i = 1}^{N_{S}}$ 로 구성된 라벨된 데이터를 제공하며, target 도메인은 일반적으로 $N_{T} = 5$ 인 소수의 비라벨 데이터 ${I_{j}^{T}}_{j = 1}^{N_{T}}$ 를 사용한다.

Gaze estimation 모델에서 입력 및 출력 feature 는 각각 CNN 레이어 또는 Linear 레이어의 입력과 출력에 해당하며, $X \in ℝ^{n \times h \times w}, F \in ℝ^{m \times h^{'} \times w^{'}}$ 로 표기한다. 여기서 $n, h, w$ 와 $m, h^{'}, w^{'}$ 는 각각 입력 및 출력 특징의 채널 수와 해상도의 높이 및 너비를 의미한다. 이러한 특징들은 사전 학습된 가중치 행렬 $W \in ℝ^{m \times n}$ 을 통해 연결된다.

소수의 비라벨 샘플로부터 효율적인 adaptation 을 가능하게 하기 위해, 저자는 LoRA 를 기반으로 한 학습 가능한 Low-Rank 업데이트를 주입한다.

LoRA 는 학습 가능한 $Δ W = A B$ 를 주입하는데, $A \in ℝ^{m \times r}, B \in ℝ^{r \times n}$ 이며 $r ≪ \min (m, n)$ 이다. LoRA 에서는 일반적으로 $A \sim 𝒩 (0, σ^{2}), B = 0$ 으로 초기화된다. 그러나 이러한 초기화는 사전 학습된 가중치에 내재된 공간적, 기하학적 구조, 즉 사용자 전반에 걸친 중요한 공간적 패턴을 포착하는 구조를 간과한다.

Alfa는 사전 학습된 가중치로부터 추출된 의미적 필터를 구조적으로 reweighting 함으로써 이러한 한계를 해결하고 시선 모델의 개인화를 수행한다. 후술할 SVD 기반의 분해를 도입하여 의미적 basis dictionary 를 추출하고, personalization 을 위해 의미적 성분을 선택적으로 적응시키는 구조적 reweighting 매커니즘을 도입한다.

3.2 Structured Decomposition of Gaze Filters

Gaze estimation 은 눈과 그 주변 얼굴 영역의 해부학적 구조에 의해 형성된 구조화된 시각적 패턴에 의존한다. 개인마다 시각적 패턴의 차이가 존재하지만, 시선 위치의 변화나 주변 얼굴 근육의 작은 변화와 같이 소수의 일관된 공간적 변화 양상을 따르는 경향이 있다.

이러한 일관성은 사전 학습된 가중치가 사용자 전반에 걸쳐 널리 공유되는 반복적인 공간 구조를 인코딩하고 있음을 시사한다.

즉 사람마다 모두 패턴의 차이는 존재하나 모델 내부에서는 변형이 어느정도 정형화 되어있으며, 반복적으로 등장하는 공간 구조가 weight 에 인코딩 되어있다. 직관적 비유를 들자면 어떤 filter 는 눈동자 중심 패턴, 어떤 필터는 눈꺼풀 경계 등을 인코딩 할 것이며 사람마다 다른 것은 “활성화 정도” 이지 아예 새로운 패턴이 아니라는 의미이다.

이 강력한 전제를 바탕으로 Alfa 는 pre-trained 모델이 가지고있는 가중치의 구조에 집중한다. 이 구조를 명시적으로 드러내기 위해 가중치 행렬에 대해 Singular Value Decomposition (SVD) 를 적용한다. $W \in ℝ^{m \times n}$ 이 CNN 또는 Linear 층의 가중치 행렬이라고 할 때 SVD 는 다음과 같이 계산된다.

W \approx W_{d} = U_{d} S_{d} V_{d}^{⊤}

여기서 $S$ 는 가중치 내부 기저에서 각 고유 벡터에 대한 scale factor 이고, 아래와 같은 형태이다.

S = [\begin{matrix} σ_{1} & 0 & 0 & \dots & 0 \\ 0 & σ_{2} & 0 & \dots & 0 \\ 0 & 0 & σ_{3} & \dots & 0 \\ ⋮ & ⋮ & ⋮ & ⋱ & 0 \\ 0 & 0 & 0 & 0 & σ_{n} \\ ⋮ & ⋮ & ⋮ & ⋮ & ⋮ \\ 0 & 0 & 0 & 0 & 0 \end{matrix}] \in ℝ^{m \times n}

여기서 어떤 두 scale factor $σ_{i}, σ_{j}$ 에서 $i < j$ 라면 $σ_{i} > σ_{j}$ 이다. 즉 내림차순 정렬되어있다. 이는 singular value를 대응되는 고유값의 크기 순으로 정렬하기로 한 관례에 따른 것이다.

$V$ 는 $W^{⊤} W$ 의 고유벡터들로 이루어진 행렬이며, 고유벡터의 순서는 본질적으로 임의적이므로 각 고유벡터에 대응되는 고유값 $λ_{i} = σ_{i}^{2}$ 의 크기 순에 맞춰 정렬할 수 있다.

각 행렬의 $d$ rank truncated 표기의 정의는 다음과 같다.

$U_{[:, 1 : d]} = U_{d} \in ℝ^{m \times d}$ 출력 projection matrix
$S_{[1 : d, 1 : d]} = S_{d} \in ℝ^{d \times d}$ 각 direction (가중치 내부 기저 고유 벡터의 importances/energies)
$V_{[1 : d, :]}^{⊤} = V_{d}^{⊤} \in ℝ^{d \times n}$ 입력 공간에서의 고유 벡터 집합

즉 하이퍼파라미터 $d$ 는 가중치의 basis 중 제일 [energy | importance | strength] 가 높은 $d$ 개의 rank 를 취한다는 의미이다.

이는 큰 의미에서는 기존 가중치 $W$ 가 소실된다고 볼 수 있으나, 언급했듯 Gaze estitmation task 에서는 사람의 얼굴이 공간적으로 일관된 패턴에 대응하는 일반적 특정을 포착하고 가중치 내부의 공간적 구조로 인코딩되어 있음을 전제로 하므로, 가중치의 내부 basis 중 몇개의 rank 만 취해도 기존 $W$ 를 $W_{d}$ 가 잘 근사한다는 것을 전제한다.

오히려 상위 $d$ 개의 rank만 유지함으로써 파라미터 수를 줄이는 동시에, pretraining 동안 중요도가 낮았던 방향에 모델이 의존하지 않도록 암묵적으로 제한하는 효과를 가진다.

또한 가중치의 truncated SVD 는 아래와 같이 표현 할 수 있다.

W_{d} = U_{d} S_{d} V_{d}^{⊤} = \sum_{i = 1}^{d} u_{i} σ_{i} v_{i}^{⊤}

$u_{i} σ_{i} v_{i}^{⊤}$ 는 가중치 행렬의 한 성분이 아니라, 하나의 rank-1 행렬 성분이며, 이를 $i$ 번째 rank-slice라 부른다. 이는 $W^{⊤} W$ 의 $i$ 번째 고유벡터에 대응하는 공간 방향을 의미하며, Gaze Estimation을 위해 학습된 얼굴의 주요 기하학적 패턴을 인코딩한다. 논문에서 시각화하는 slice는 바로 이 singular component 하나를 선택한 것이다.

저자는 $V_{base} : = S_{d} V_{d}^{⊤} \in ℝ^{d \times n}$ 을 정의하는데, 이를 “semantic basis dictionary” 라고 한다. 여기서 $V_{base}$ 를 dictionary 라고 하는 이유는 후술할 self-attention 부분에서 Key / Value 로 사용되기 때문이다. 즉 가중치 내부 기저 방향으로 rotation, reflection ( $V_{d}^{⊤}$ ) 및 스케일링 ( $S_{d}$ ) 한 행렬은 가중치 내부에서 어떤 벡터가 중요하게 작용되는지를 확인할 수 있는 lookup table 과 같은 개념이므로, Query 로 부터 탐색될 대상이 된다.

$V_{base}$ 의 성분들은 시선 행동과 관련된 핵심적인 공간 패턴(예: 홍채 및 안와 주변 단서 등)을 포착한다. 사전 학습 동안 시선 손실을 줄이는 데 가장 자주 사용된 성분일수록 가장 높은 에너지를 갖는다. SVD는 가중치 공간의 패턴을 에너지 기준으로 순위화하므로, 이러한 주요 성분들로 절단하면 시선과 관련된 지배적인 구조를 보존할 수 있으며, 개인화를 위한 컴팩트하고 구조 인지적인 basis를 제공한다. Alfa에서는 이러한 의미적 구조가 이후 단계에서 효율적이고 개인화된 업데이트 학습을 가능하게 한다.

3.3 Personalizing the Semantic Basis Dictionary

SVD를 통해 추출된 $V_{base}$ 은 시선 추정에서 개인 전반에 걸쳐 잘 일반화되는 공간 패턴들의 컴팩트한 집합을 제공한다. 그러나 이러한 패턴들이 각 사용자의 고유한 외형적 특성을 완전히 포착하지는 못할 수 있다. Alfa는 사전 학습 과정에서 학습된 공유 구조를 유지하면서, 의미적 기저 사전의 성분들을 reweighting 하는 LoRA를 도입한다. 이 접근법은 사전 학습된 필터에 인코딩된 시선 관련 정보를 보존하면서도, 개인별 차이에 맞게 모델을 적응시킬 수 있게 한다. 모델을 개인화하기 위해, 저자는 사전 학습된 가중치 $W_{d}$ 위에 Low-Rank 업데이트 $Δ W$ 를 추가한다. 적응된 가중치는 다음과 같이 정의된다:

\hat{W} = W_{d} + Δ W

여기서 $Δ W \in ℝ^{m \times n}$ 는 Low-Rank 개인화 항으로, $Δ W = U_{d} V_{alfa}$ 로 계산되며, $V_{alfa}$ 는 Alfa 모듈에 의해 학습되는 행렬이다.

3.3.1 Attending to Semantic Basis Dictionary

Alfa 는 $V_{base} \in ℝ^{d \times n}$ 에 멀티헤드 어텐션 메커니즘을 적용하여 personalization 을 수행한다. 이 $V_{base}$ 는 사전 학습으로부터 공유된 공간 패턴을 포착하며, Alfa 는 어텐션을 사용해 target 사용자와 가장 관련성이 높은 슬라이스들을 reweighting 한다.

$H$ 를 어텐션 헤드 갯수라고 할 때, 서로 다른 헤드들은 서로 다른 rank 슬라이스에 주의를 기울여 개인 샘플이 적을 때 상호 보완적인 단서를 결합하고 드리프트(개인 샘플이 너무 적을 때, 모델 파라미터가 우연히 관측된 단서 하나에 끌려가 pre-trained 의미 구조에서 벗어나는 현상)를 줄인다.

각 어텐션 헤드 $h \in {1, \dots, H}$ 에 대해, 쿼리 projection을 위한 Low-Rank 행렬 쌍 $A_{h}^{Q} \in ℝ^{r \times d}$ 와 쿼리 back-projection 을 위한 $B_{h}^{Q} \in ℝ^{d \times r}$ 를 정의한다. 쿼리 projection은 다음과 같이 초기화된다:

A_{h}^{Q} \sim 𝒩 (0, σ^{2}), B_{h}^{Q} = 0

각 헤드는 다음과 같이 쿼리 행렬을 계산한다:

𝒬_{h} = B_{h}^{Q} A_{h}^{Q} V_{base} \in ℝ^{d \times n}

키와 값 행렬은 $V_{base}$ 로부터 직접 도출되며, 모든 어텐션 헤드 간에 공유된다. 키 행렬은 $𝒦 = V_{base} \in ℝ^{d \times n}$ 로 정의되며, 값 행렬은 그 전치로서 $𝒱 = V_{base}^{⊤} \in ℝ^{n \times d}$ 이다. 각 헤드에 대해, 자신의 쿼리 $𝒬_{h}$ 를ㅈ 사용하여 Scaled dot product 을 계산한다:

{Attn}_{h} = softmax (\frac{𝒬_{h} 𝒦^{⊤}}{\sqrt{n}}) \in ℝ^{d \times d}

Z_{h} = 𝒱 {Attn}_{h}^{⊤} \in ℝ^{n \times d}

각 출력 $Z_{h}$ 는 전치된 후 모든 헤드에 대해 스택되어 다음을 이룬다:

Z = [Z_{1}^{⊤}, \dots, Z_{H}^{⊤}] \in ℝ^{H d \times n}

3.3.2 Integrating Multi-Head Adaptation

멀티헤드 출력을 집계하여 $Z \in ℝ^{H d \times n}$ 를 얻은 후, 두 개의 Low-Rank 행렬 $A^{𝒫} \in ℝ^{r H \times H d}$ 와 $B^{P} \in ℝ^{d \times r H}$ 를 사용해 이를 의미 공간으로 다시 투영한다. 이들은 다음과 같이 초기화된다:

A^{P} \sim 𝒩 (0, σ^{2}), B^{P} = 0

개인화된 업데이트는 다음과 같이 계산된다:

V_{Alfa} = B^{𝒫} A^{𝒫} Z + V_{base} \in ℝ^{d \times n}

이로써 적응 과정이 완료되며, 최종적으로 Low-Rank 업데이트 $Δ W = U_{d} V_{Alfa}$ 가 생성된다.

3.3.3 Jayden - Why Attention?

언급했듯 $V_{base}$ 는 가중치 내부의 SVD basis를 singular value로 스케일한 형태로, 가중치가 학습 과정에서 어떤 방향들을 얼마나 중요하게 사용해 왔는지를 정리해 놓은 dictionary라고 볼 수 있다.

그렇다면 저자는 왜 이 $V_{base}$ 위에서 attention 메커니즘을 사용했을까? Alfa에서 attention의 목적은 새로운 의미적 방향을 학습하는 것이 아니라, 새롭게 들어온 target 사용자의 데이터가 기존 basis들 중 어떤 방향을 더 쓰고, 어떤 방향을 덜 써야 하는지를 결정하기 위함이다.

이를 위해 각 head $h$ 에 대해 다음과 같은 query를 정의한다:

𝒬_{h} = B_{h}^{𝒬} A_{h}^{𝒬} V_{base}

이때 $𝒬_{h}$ 는 특정 rank slice 하나를 가리키는 것이 아니라, 여러 rank slice들에 대해 “이 방향들을 이런 비율로 써라”라고 요청하는 쿼리로 이해하는 것이 정확하다. Attention score를 전개하면 다음과 같다:

\begin{matrix} 𝒬_{h} K^{⊤} & = (B_{h}^{𝒬} A_{h}^{𝒬} S_{d} V_{d}^{⊤}) (V_{d} S_{d}) \\ = B_{h}^{𝒬} A_{h}^{𝒬} S_{d}^{2} \end{matrix}

여기서 중요한 점은 역할의 분리이다. $B_{h}^{𝒬} A_{h}^{𝒬}$ 는 target 사용자의 데이터로부터 만들어진 가중치 조합으로, 어떤 rank slice들을 상대적으로 더 강조할지에 대한 제안(proposal)에 해당한다.

Attention is All You Need 에서 Attention 의 대상은 시퀀스 내 단어 임베딩 간 서로의 관계라면, Alfa 에서는 Test-time 에서 personalization 의 대상이 되는 사람의 데이터가 만들어내는 loss 로 학습되는 $M_{h}$ 와 base model 의 prior 와의 관계를 인코딩한다.

$S_{d}^{2}$ 는 기존 가중치 $W$ 가 pre-training 동안 각 rank slice를 얼마나 강하게 사용해 왔는지를 나타내는 값으로, 기존 모델이 어떤 방향을 더 신뢰해 왔는지에 대한 사전 정보라고 볼 수 있다. 따라서 $𝒬_{h} 𝒦^{⊤} = B_{h}^{𝒬} A_{h}^{𝒬} S_{d}^{2}$ 는 새 사용자 데이터가 제안한 변화 방향을, 기존 가중치가 중요하게 사용해 온 방향에 따라 가중해서 평가한 결과라고 해석할 수 있다.

이후 softmax를 적용하고 value인 $V_{base}^{⊤}$ 와 결합하면 다음과 같은 출력이 얻어진다:

Z_{h} = V_{base}^{⊤} \cdot softmax {(\frac{B_{h}^{𝒬} A_{h}^{𝒬} S_{d}^{2}}{\sqrt{n}})}^{⊤}

이때 $Z_{h}$ 는 새로운 feature를 만들어내는 것이 아니라, 기존 가중치가 가지고 있던 semantic basis들을 target 사용자에 맞게 다시 섞어 놓은 결과이다. 즉, $Z_{h}$ 는 target 사용자의 데이터가 기존 가중치가 중요하게 여겨 온 방향들을 어떤 비율로 재사용해야 하는지를 반영한 표현이라 볼 수 있다.

정리하자면 $𝒬 𝒦^{⊤}$ 는 타겟 사용자의 데이터로부터 만들어진 변화 방향 $B^{𝒬} A^{𝒬}$ 를 기존 가중치의 각 basis별 strength와 곱해봄으로써, 이 변화가 기존 basis들에 대해 어떤 가중 분포를 갖는지를 평가한다. 이를 통해 $B^{𝒬} A^{𝒬}$ 의 조합에 따라 기존 basis들을 어떤 비율로 재가중해야 하는지를 $V_{base}$ 를 통해 결정한다.

추상적인 비유도 들어보자. 만약 fine-tune 단계에서 사용되는 Loss 에 의해 $M_{h} = B_{h}^{𝒬} A_{h}^{𝒬}$ 의 22번 성분이 작아졌다고 가정해보자. 이 22번은 사람 얼굴의 눈썹과 눈꺼풀에 대한 패턴을 인식한다고 가정한다. 즉 22번 성분이 작아졌다는 것은, 현재 target user 에게 22번 rank slice 가 베이스 모델에서 보다 낮아야 fine-tune loss 가 줄어드는 것을 의미한다. fine-tune loss에 의해 $M_{h}$ 의 22번 계수가 감소하면, $softmax (M_{h} S_{d}^{2})$ 에서 22번의 attention weight가 감소한다. 그 결과 최종 $Z = V_{base}^{⊤} α$ 에서 slice 22의 기여도가 줄어들고, 정규화 특성 때문에 다른 slice들의 상대적 비율이 증가한다.

즉 기존 가중치가 가지고있던 기하학적 구조를 어느정도 유지하면서, 눈썹과 눈꺼풀이 시선 추적에 덜 중요한 특정 사용자에게 맞춰 reweighting 되는 것이다.

하지만 가중치의 기하학적 구조를 완벽히 유지하고 scaling 만 하는것은 아니다. 만약 strength 만 조정한다면

V_{adapt} = diag (1.1, 0.9, 1.01, \dots) V_{base}

와 같은 형태여도 충분할 것이다. Attention 의 사용 이유는 slice 간의 상호작용 가능성 때문이다. 단순히 특정 rank slice 이 flip-consistency 에 좋지 않은 영향을 끼쳤을 때 단순히 해당 slice 의 strength 를 낮추는 것은 rank slice 간 관계를 간과하는 것이다. rank-slice 가 얼굴의 특정 부분을 인코딩 한다는 것은 어디까지나 추상적인 비유일 뿐이고, 실제로는 여러 slice 가 복합적으로 기하학적 구조를 인코딩 하므로 엄밀히 말하면 personalization 을 위해 특정 사람에게 특별히 더 반응하는 slice 를 찾아 strength 를 올리는 것이 아닌, 특정 사람에게 유리한 slice 들의 조합을 찾기 위함이다.

이후 $H$ 개의 각 $Z_{h}$ 를 projection 해서 최종적인 $V_{adapt}$ 를 만들어내는데, 이는 각 헤드별로 다른 slice 조합을 학습할 수 있게 한다.

3.4 Fine-tuning and Inference with Alfa

3.4.1 Fine-Tuning

사람의 얼굴은 일반적으로 좌우 대칭성을 가지며, 시선 행동은 수평 반전에 대해서도 일관성을 유지해야 한다. 이 특성을 활용하기 위해 다섯 개의 비라벨 개인 샘플 ${I_{k}^{T}}_{k = 1}^{N_{T}}$ (여기서 $N_{T} = 5$ )을 사용하여 대칭 손실을 적용한다. $f_{θ} (\cdot)$ 를 시선 모델이라 하자.

각 이미지에 대해 수평 반전된 버전 $I_{k}^{T, flip}$ 을 생성하고 다음과 같은 예측을 얻는다:

{\hat{g}}_{k}^{T} = f_{θ} (I_{k}^{T}), {\hat{g}}_{k}^{T, flip} = f_{θ} (I_{k}^{T, flip})

여기서 $\hat{g} = [{\hat{g}}_{yaw}, {\hat{g}}_{pitch}] \in ℝ^{2}$ 이다. 대칭 손실은 다음과 같이 계산된다:

ℒ_{fine-tune} = \frac{1}{N_{T}} \sum_{k = 1}^{N_{T}} {‖ {\hat{g}}_{k}^{T} - FlipYaw ({\hat{g}}_{k}^{T, flip}) ‖}_{1}

3.4.2 Inference

적응 과정은 사전 학습된 가중치 $W_{d}$ 로부터 좌측 기저 $U_{d}$ 를 재사용하여 원래의 모델 구조를 보존한다. 이는 추론 시 효율적인 업데이트 병합을 가능하게 한다. 전체 적응된 가중치는 다음과 같다:

\hat{W} = W_{d} + Δ W = U_{d} V_{base} + U_{d} V_{Alfa} = U_{d} (V_{base} + V_{Alfa})

괄호 안의 합을 $V_{adapt}$ 라는 인자로 정의하면 다음을 얻는다:

\hat{W} = U_{d} V_{adapt}, where V_{adapt} = V_{base} + V_{Alfa}

적응된 가중치는 Low-Rank 형태를 유지하여, 원래의 압축된 모델과 동일한 구조를 갖는다. 따라서 전체 가중치 행렬을 먼저 재구성하지 않고도, 우측 기저만을 갱신하여 $\hat{W} = U_{d} V_{adapt}$ 을 얻을 수 있다. 반면 표준 LoRA 변형들은 Low-Rank 항 $A B$ 를 전체 행렬에 추가한다:

\hat{W} = W_{d} + A B = U_{d} S_{d} V_{d}^{⊤} + A B .

$A B$ 를 병합하려면 $W_{d}$ 를 $ℝ^{m \times n}$ 의 전체 크기로 확장해야 하며, 이는 파라미터 압축의 이점을 무효화한다(예: 모델 크기가 약 200만 개에서 1,100만 개의 파라미터로 증가). $W_{d}$ 를 truncated SVD 형태 $U_{d} S_{d} V_{d}^{⊤}$ 로 저장할 경우, Low-Rank 항 $A B$ 를 직접 병합하는 것이 불가능하다. Alfa는 SVD의 우측 인자 $S_{d} V_{d}^{⊤}$ 만을 업데이트하고 $U_{d}$ 는 고정된 상태로 유지함으로써, 적응 과정에서 Low-Rank 를 유지하고 직접 병합 가능하도록 보장한다.

4. Experiments

4.1 Datasets

시선 추정을 위해, 저자는 cross-domain 설정을 사용한다. 소스 도메인으로는 ETH-XGaze( $D_{E}$ ) 또는 Gaze360( $D_{G}$ )에서 학습된 모델을 사용하고, 타깃 도메인으로는 MPIIGaze( $D_{M}$ )와 EyeDiap( $D_{D}$ )에서 평가한다. 모든 전처리는 TPGaze 를 따른다. LLM 실험의 경우, s1K 추론 데이터셋으로 미세 조정하고, GSM8K, MATH500, Countdown, Sudoku(Arel 2025)에서 제로샷 성능을 평가한다.

4.2 Experiment Setup

시선 추정 실험에는 NVIDIA RTX 4090 한 대를 사용하고, LLM 실험에는 NVIDIA A40 GPU 두 대를 사용한다. TTP 사전 학습과 개인화 과정에서 학습률은 $10^{- 4}$ 로 설정한다. LLM 적응의 경우, 기본 모델로 LLaDA-8B-Instruct 를 사용하여 d1 기반 미세 조정을 따른다. 아래에서는 TTP에 대한 세부 설정을 설명한다.

4.2.1 Pre-training

소스 도메인 $D_{E}$ 와 $D_{G}$ 에서 배치 크기 120으로 Adam 을 사용해 50 epochs 동안 학습한다. truncated SVD를 적용한 이후, 정보 손실을 완화하기 위해 동일한 데이터에서 모든 파라미터를 추가로 25 epochs 동안 fine-tune 하여, truncated 사전 학습 가중치 $W_{d}$ 를 얻는다.

즉 $W$ 가 $W_{d}$ 로 $d$ 개의 상위 에너지의 basis 만 남겨버리면 하위 $n - d$ 개의 rank slice 가 없어지므로, $W_{d}$ 로 truncated 시킨 이후에 25 epochs 동안 추가로 train 을 하여 truncated 모델이 source domain 에서 계속 잘 동작호도록 유도한다.

4.2.2 Personalization

TPGaze 를 따라 각 사용자당 처음 5장의 이미지를 사용한다. 각 이미지는 한 번씩 반복되며 ColorJitter, GaussianBlur, RandomAffine로 증강된다. ResNet-18의 layer3와 layer4에는 학습률을 10배로 설정한 AdamW을 사용하고, 공정한 비교를 위해 모든 LoRA 변형에 동일한 미세 조정 방식을 적용한다.

여기서 layer3, 4 에 learning-rate 를 강하게 주는 이유는 TTP 의 상황에서 데이터가 극도로 적고, overfitting 위험이 있으므로 공통 구조는 유지하고, 사용자 특이적 high-level mapping만 조정하기 위해 gaze 와 더 직접적으로 연결된 고수준 표현 레이어를 더 적극적으로 훈련한다.

또한 pre-training 시에 Adam 을 사용하는 것과 다르게 Presonalization 시 AdamW 를 사용한다.

먼저 Adam 의 식은 다음과 같다:

\begin{matrix} m_{t} = β_{1} m_{t - 1} + (1 - β_{1}) g_{t} \\ v_{t} = β_{2} v_{t - 1} + (1 - β_{2}) g_{t}^{2} \end{matrix}

{\hat{m}}_{t} = \frac{m_{t}}{1 - β_{1}^{t}} {\hat{v}}_{t} = \frac{v_{t}}{1 - β_{2}^{t}}

θ_{t + 1} = θ_{t} - η \frac{{\hat{m}}_{t}}{\sqrt{{\hat{v}}_{t}} + ϵ}

파라미터가 업데이트 되는 과정에서 평균과 분산을 지속적으로 추적하여 다음 업데이트에 반영하는 방법인데, 만약 Alfa 의 상황처럼 데이터가 너무 적어 overfitting 을 걱정해야하는 경우 L2 regularization 을 시도할 수 있는데, 이때 Adam 은 문제가 된다.

먼저 Adam 을 행렬로 바꿔서 쓰면:

\begin{matrix} θ_{t + 1} = θ_{t} - η D_{t}^{- 1} g_{t} \\ D_{t} = diag (\sqrt{{\hat{v}}_{t}} + ϵ) \end{matrix}

즉, 각 파라미터마다 다른 스케일이 붙는다. 이는 자주 흔들리는 업데이트가 있었던 파라미터에겐 작은 기울기를 주고 비교적 흔들림이 없던 업데이트가 있었던 파라미터에게 상대적으로 큰 기울기를 주기 위함이다. → 수렴하고 있는 방향을 계속 진행하도록 유도한다.

여기서 L2 term 을 넣으면:

\begin{matrix} g_{t}^{'} = g_{t} + λ θ_{t} \\ θ_{t + 1} = θ_{t} - η D_{t}^{- 1} (g_{t} + λ θ_{t}) = θ_{t} - η D_{t}^{- 1} g_{t} - η D_{t}^{- 1} λ θ_{t} \end{matrix}

여기서 파라미터의 L2 term 과 분산 행렬 $D_{t}$ 가 곱해지며 파라미터 weight decay 가 모든 파라미터에 대해 동일하게 적용해야 하는데 그것이 깨져버린다.

그래서 AdamW는:

θ_{t + 1} = θ_{t} - η D_{t}^{- 1} g_{t} - η λ θ_{t}

L2 를 별개의 항으로 두어 $D_{t}$ 행렬과 무관하게 regularization 한다.

4.2.3 Evaluation Metric

저자는 예측된 시선 방향과 실제 시선 방향 사이의 각도를 측정하는 각도 시선 오차를 보고한다. 기존 연구들을 따라, 모델 출력인 2차원 yaw와 pitch를 3차원 벡터로 변환하여 오차를 계산한다.

4.3 Comparison with SOTA Methods

Table 1은 네 개의 교차 도메인 시선 추정 벤치마크에서 Alfa를 최신 TTP 방법들과 비교한 결과를 보여준다. 저자는 ETH-XGaze 또는 Gaze360에서 MPIIGaze와 EyeDiap으로의 Domain Adaptation 을 평가한다. 기준선은 fine-tune 을 수행하지 않은 ResNet-18 모델이다. 공정한 비교를 위해 backbone으로 역시 ResNet-18을 사용한다. Alfa는 모든 벤치마크에서 가장 낮은 평균 각도 시선 오차를 달성하면서도, 다른 방법들에 비해 모델 크기가 약 5배 작게 유지된다.

4.4 Comparison with LoRA-based Methods

Table 2에서는 Alfa를 다른 LoRA 기반 방법들과 비교하고, Figure 3에서는 이들의 구조적 차이를 설명한다. 모든 방법은 동일한 truncated 사전 학습 가중치 $W_{d} = U_{d} S_{d} V_{d}^{⊤}$ 위에서 동작한다. 그러나 모든 LoRA 기반 변형이 추론 시 이러한 분해된 형태의 $W_{d}$ 에 업데이트를 병합하는 것을 지원하지는 않는다. 반면 Alfa는 사전 학습된 가중치의 공간적 구조를 활용하고, 의미적으로 중요한 패턴을 재가중한다. Alfa의 개인화된 업데이트는 truncated SVD 형태와 완전히 호환되며, 다른 방법들에 비해 추론 시 추가적인 비용을 발생시키지 않는다. 이러한 시선 특화 구조적 사전 지식은 사전 학습된 시맨틱을 훼손하지 않으면서 의미 있는 필터 재가중 방향으로 적응을 유도하며, 그 결과 네 개의 교차 도메인 벤치마크 전반에서 가장 낮은 평균 시선 오차를 달성한다.

4.5 Ablation Studies

저자는 어텐션 헤드 수와 LoRA 랭크가 Alfa의 성능에 미치는 영향을 평가하기 위해 제거 실험을 수행한다. 모든 설정에서 SVD 랭크는 64로 고정한다. Table 4에 나타난 바와 같이, 어텐션 헤드 수를 증가시키면 일반적으로 개인화 성능이 향상되며, 시선 오차가 1개 헤드에서는 6.20에서 16개 헤드에서는 5.72로 감소한다. Alfa는 사전 학습된 $W_{d}$ 로부터 동일한 좌측 기저 $U_{d}$ 를 재사용하므로, 모든 적응은 추론 시 기본 가중치에 병합되며 헤드 수와 무관하게 추가적인 계산 비용이 발생하지 않는다.

4.6 Visualization of Pre-trained Spatial Patterns

Figure 4는 ETH-XGaze로 학습된 ResNet-18 모델의 SVD 분해 가중치에서 개별 랭크 슬라이스를 시각화함으로써 사전학습 동안 인코딩된 일부 공간 패턴을 보여준다. $s$ 번째 SVD 슬라이스는 다음과 같이 계산된다:

U_{d} [:, s] S_{d} [s] V_{d}^{T} [s]

여기서 $s$ 는 분해의 랭크 구성요소를 인덱싱한다. 왼쪽 열은 해당 슬라이스에 의해 인코딩된 공간 구조를 나타내며, 가운데와 오른쪽 열은 서로 다른 두 피험자(피험자 0과 피험자 16)에 대한 활성화를 보여준다. 예를 들어, 22번째 슬라이스는 눈썹, 아래 눈꺼풀, 그리고 아래 입 부분을 강조하는 반면, 24번째 슬라이스는 코 옆 부분, 눈 옆 영역, 그리고 입 주변의 얼굴 근육 부위에서 활성화된다. 개인 간에 일관된 패턴은 사전학습이 시선과 관련된 얼굴 기하 구조에 정렬된 재사용 가능한 공간 구조를 포착함을 보여준다.

4.7 Visualization of Adaptation Behavior

Figure 5에서는 MPIIGaze 데이터셋의 세 명 사용자에 대해 Low-Rank 업데이트 $Δ W$ 를 시각화한다. Alfa의 업데이트는 눈과 그 주변 근육과 같은 시선과 관련된 얼굴 영역에 일관되게 집중한다. 이러한 패턴은 사용자마다 약간씩 차이를 보이는데, 이는 모델의 원래 공간적 sementic 과의 정합성을 유지하면서도 개인화된 조정을 반영한 결과이다.

반면 LoRA는 동일한 백본 계층을 사용해 개인화를 수행하더라도, 분산되고 일관되지 않은 업데이트를 생성한다. 이는 LoRA가 핵심 영역을 명시적으로 회피하지 않기 때문이며, 목표 지향적인 semantic 가이드를 결여한 채 다른 영역의 시선 관련 신호(예: pose cues)에 의존할 수 있다.

이러한 시각화 결과는 $V_{base} = S_{d} V_{d}^{⊤}$ 으로부터 유용한 성분을 식별하는 Alfa의 능력을 강조한다. 이 성분들은 사전 학습된 소스 모델과 타깃 사용자 간의 도메인 특화 불일치를 반영하므로, 효과적인 사용자별 적응을 위해서는 이들을 재가중하는 것만으로 충분하다.

4.8 Applying Alfa to Diffusion-Based LLMs

LLaDA-8B-Instruct 모델에 Alfa를 적용했을 때의 성능을, 네 가지 제로샷 추론 벤치마크(GSM8K, MATH500, Countdown, Sudoku)에서 LoRA 및 DoRA와 비교한 결과를 보여준다. 적응에는 1,000개의 샘플을 사용한다. LLM 실험을 포함한 이유는 추론 과제가 토큰 상호작용 패턴(예: 포맷, 단계 표시)을 재사용하며, 데이터가 제한된 경우 이러한 패턴을 재가중하는 것이 유리함이 알려져 있기 때문이다. LoRA 결과는 d1에서 가져왔으며, DoRA는 HuggingFace PEFT 라이브러리를 사용해 재구현하였다.

LoRA와 DoRA는 LoRA 랭크 128을 사용하는 반면, Alfa는 더 낮은 랭크인 64를 사용하며 전체 모델 파라미터의 0.85%만을 튜닝한다. 표 3의 모든 실험에서는 SVD 절단 없이 전체 사전 학습 가중치 행렬 W를 유지한다. Alfa는 저랭크 업데이트 $Δ W$ 를 계산하기 위해 SVD 랭크 128과 8개의 어텐션 헤드를 사용한다. 이러한 더 작은 파라미터 규모에도 불구하고, Alfa는 전반적인 벤치마크에서 동등하거나 더 우수한 정확도를 달성한다. 이는 언어 모델의 추론 패턴 역시 사전 학습 과정에서 인코딩된 일반화 가능한 성분으로 표현될 수 있음을 시사하며, 향후 연구를 위한 흥미로운 가능성을 제시한다.

5. Conclusion

본 논문에서는 시선 추정 모델의 테스트 시점 개인화를 위한 구조 인지형 방법인 Alfa를 제안하였다. Alfa는 SVD를 통해 추출된 공간 패턴에 어텐션을 적용함으로써, 사전 학습된 필터에 내재된 의미 있는 성분을 재사용하고 멀티헤드 Low-Rank 설계를 통해 효율적인 도메인 적응을 가능하게 한다. 이 접근법은 미세 조정 과정에서 확장 가능한 개인화를 지원하는 동시에, 추론 비용을 증가시키지 않으면서 컴팩트한 모델을 유지한다. 네 개의 교차 도메인 시선 추정 벤치마크 실험을 통해, 소수의 비라벨 샘플만으로도 최신 수준의 성능을 달성함을 입증하였다. 더 나아가, Alfa의 구조화된 적응 기법은 확산 기반 언어 모델의 제로샷 추론 과제와 같은 다른 응용 분야에서도 잠재력을 보인다.

6. Limitation

6.1 Fine-tuning in on-device environment

on-device 환경에서의 fine-tuning은 여전히 도전적인 문제이다. 특히 Alfa는 truncated SVD와 $U_{d}$ 재사용을 통해 저장해야 하는 파라미터 수를 줄이지만, 이는 compute efficiency를 직접적으로 보장하지는 않는다. 실제로 factorized parameterization은 추가적인 projection 연산 및 decomposition 과정으로 인해 training-time computational overhead를 유발할 가능성이 있다.

Experiments의 Table에서도 확인되듯이, parameter efficiency와 training-time compute efficiency 사이에는 trade-off가 존재하는 것으로 보인다. 특히 truncated SVD의 rank $d$ , LoRA rank $r$ , 그리고 attention head 수 $H$ 가 증가할수록 fine-tuning 단계에서 요구되는 연산량 또한 증가할 수 있다.

따라서 inference 단계에서는 backbone과 유사한 compute cost를 유지할 가능성이 있으나, on-device 환경에서 fine-tuning 자체의 실용성은 추가적인 분석이 필요해 보인다.

6.2 Flip-consistency ≠ Gaze estimation Accuracy

Alfa는 개인화 단계에서 다음과 같은 loss를 사용한다:

ℒ_{fine-tune} = \frac{1}{N_{T}} \sum_{k = 1}^{N_{T}} {‖ {\hat{g}}_{k}^{T} - FlipYaw ({\hat{g}}_{k}^{T, flip}) ‖}_{1}

즉, 원본 이미지와 수평 반전 이미지의 예측이 좌우 대칭적으로 일관되도록 만드는 것이 목표이다. 그러나 실제 성능 평가는 ground-truth 3D gaze vector와의 angular error이다. 이 둘은 동일한 목적이 아니다. 모델이 자기 자신과 일관되다고 해서, 정답에 가까워진다는 보장은 없다.

모델이 특정 사용자에 대해 yaw를 항상 +5° 만큼 예측한다고 가정하자.

원본 예측: +15° (실제는 +10°)
flip 이미지 예측: -15° (실제는 -10°)

FlipYaw 처리 후 비교하면 perfectly consistent하며 loss 는 거의 0이 된다. 즉 bias는 줄지 않으면서 flip-consistency만 만족하는 해가 존재한다.

또한 Alfa는 인간 얼굴의 좌우 대칭성을 전제하나 이 전제가 틀릴 가능성이 있다. 조명 비대칭, 안경/머리카락 등의 방해 요인, 얼굴 자체의 비대칭, 사시 등의 경우, flip-consistency를 강제하면 오히려 잘 학습된 비대칭 정보를 제거할 위험이 있다.

6.3 The main contributor to accuracy improvement

논문에서 보고된 성능 향상은 multi-head attention, SVD 기반 structured basis reuse, low-rank constraint, 그리고 flip-consistency loss가 결합된 결과이다. 그러나 실험 설계 상 이 네 요소의 기여도가 명확히 분리되어 있지 않으며, 어떤 요인이 실제 성능 향상의 핵심 동인인지 인과적으로 검증되지 않았다.

Alfa는 기존 LoRA 기반 방법들과의 차별점으로 “semantic basis 위에서의 attention 기반 재가중”을 강조한다. 하지만 제시된 비교 실험은 전체 시스템 단위의 비교에 머물러 있으며, attention 모듈의 필수성을 직접적으로 입증하지는 않는다. 예를 들어, attention을 제거하고 단순한 선형 재가중 또는 diagonal gating만 적용했을 때의 성능, 혹은 softmax를 제거한 단순 저랭크 변환과의 비교는 제시되지 않는다. 따라서 현재 결과만으로는 attention이 구조적으로 필요한 요소였는지, 아니면 단지 표현력 증가에 따른 일반적 성능 향상인지 구분하기 어렵다.

성능 개선이 attention 때문이 아니라 SVD truncation 자체의 regularization 효과, low-rank 제약에 따른 안정성 향상, 또는 flip-consistency loss의 self-supervised alignment 효과에서 비롯되었을 가능성도 배제되지 않는다.

또한 multi-head 구조는 rank 증가 효과와 표현력 증가를 동반한다. 그러나 이 증가가 attention 메커니즘의 질적 장점 때문인지, 단순히 파라미터 재배치에 따른 양적 효과인지 분리되지 않았다. attention이라는 연산적으로 복잡한 구조가 정말 필요했는가? 혹은 단순한 저랭크 재가중 방식으로도 동일한 성능을 달성할 수 있었던 것은 아닌가?

결과적으로, Alfa의 성능 향상은 여러 설계 요소가 결합된 종합 효과로 보이지만, 각 구성 요소의 인과적 기여는 충분히 분해되지 않았다. 따라서 “attentive structured reweighting이 핵심이다”라는 해석은 현재 제시된 실험만으로는 강하게 뒷받침되기 어렵다. 설계의 설득력을 강화하기 위해서는 attention 제거 ablation, flip-consistency 제거 실험, SVD 없이 동일 구조 적용 실험 등 구성 요소별 분리 검증이 필요하다. 이러한 분석 없이는 attention 기반 구조가 필연적인 선택이었는지, 아니면 여러 가능한 설계 중 하나였는지 판단하기 어렵다.

Attention is All You Need

2026-01-14T00:00:00.000Z

Backgrounds

Layer Normalization

Layer Normalization (LayerNorm)은 한 샘플 내부에서 feature 차원 기준으로 정규화하는 기법이다. 배치 크기와 무관하게 동작하도록 설계되었다.

μ = \frac{1}{d} \sum_{i = 1}^{d} x_{i}, σ^{2} = \frac{1}{d} \sum_{i = 1}^{d} {(x_{i} - μ)}^{2}

\begin{matrix} {\hat{x}}_{i} = \frac{x_{i} - μ}{\sqrt{σ^{2} + ϵ}} \\ y_{i} = γ_{i} {\hat{x}}_{i} + β_{i} \end{matrix}

Transformer에서 한 토큰의 representation은 보통 $x \in ℝ^{d_{model}}$ 이고, LayerNorm은 각 토큰마다 independently 적용된다. 이는 attention 출력의 scale 폭주를 방지하여 학습 안정성이 증가한다.

Recurrent Neural Network

RNN 은 단일 입력이 아닌 여러개의 입력 (시퀀스) 에서, 이전 상태와 현재 입력으로 새로운 상태를 만드는 순환 연산 블록이다.

길이가 $T$ 인 시퀀스 $x$ 가 있을 때, RNN 의 연산을 아래와 같이 정의된다.

\begin{matrix} x = [x_{1}, x_{2}, x_{3} \dots x_{T}] \\ h_{t} = g (W_{x} x_{t} + W_{h} h_{t - 1} + b) \\ h_{1} = g (W_{x} x_{1} + W_{h} h_{0} + b) \\ h_{2} = g (W_{x} x_{2} + W_{h} h_{1} + b) \\ ⋮ \\ h_{T} = g (W_{x} x_{T} + W_{h} h_{T - 1} + b) \end{matrix}

여기서 같은 시간 스텝 $t$ 에서는 같은 파리미터 ( $W_{x}, W_{h}, b$ ) 를 공유한다.

hidden state $h$ 를 굳이 만드는 이유는 $t$ 에서 $0$ ~ $t - 1$ 범위의 데이터를 모두 참조하려면 계산 비용과 메모리를 많이 요구하기 때문이며 길이가 가변인 시퀀스를 고정 차원으로 처리하기 위한 구조적 장치로 사용하기 위함이다. 즉 이전의 상태를 하나의 벡터 $h$ 로 표현하는 것이다.

P (x_{t} | x_{1}, \dots, x_{t - 1}) \approx P (x_{t} | h_{t - 1})

각 시퀀스에서 계산된 $h_{t}$ 를 사용하여 출력을 만들 수도 있다. 최종 상태 $h_{T}$ 는 시퀀스 전체를 표현하는 벡터이며, 이를 이용해 출력을 하나만 만들 수도 있고, 중간 $h_{t}$ 를 이용하여 출력을 시퀀스로 만들 수도 있다.

이러한 RNN 구조는 입력과 출력 시퀀스의 길이가 동일한 문제에는 자연스럽게 적용되지만, 기계 번역과 같이 입력 시퀀스의 길이 $T_{x}$ 와 출력 시퀀스의 길이 $T_{y}$ 가 다른 문제에는 직접 적용하기 어렵다. 이를 해결하기 위해 이후 Encoder–Decoder 구조가 제안되었다.

Encoder-Decoder

Encoder-Decoder 는 기계 번역, 요약, 질의 응답 등의 $T_{x} \neq T_{y}$ 인 Task에서 단일 RNN 의 구조적 한계를 극복하기 위해 고안된 구조이다.

기본적으로 RNN 을 두개 사용하며, 입력 시퀀스를 하나의 표현 ( $h_{T_{x}}$ ) 으로 인코딩하는 Encoder 와 그 표현을 조건으로 새로운 시퀀스를 디코딩하는 Decoder 로 나뉜다.

첫번쨰 RNN 이 모든 시퀀스를 전부 연산하였을 때, 해당 시퀀스는 $h_{T_{x}}$ 로 요약된다.

디코더는 이 $h_{T_{x}}$ 를 $s_{0}$ 로 사용하여 다음 출력의 확률을 생성한다.

$e_{t}$ 는 해당 출력 토큰의 embedding 값을 의미한다:

\begin{matrix} e_{t} = Embed (y_{t}) e_{t} \in ℝ^{d_{e}} \\ s_{0} = h_{T_{x}} \\ y_{0} = ⟨ SOS ⟩ \\ s_{t} = g (W_{y} e_{t - 1} + W_{s} s_{t - 1} + b) \\ W_{o} \in ℝ^{| V | \times d_{s}} \\ o_{t} = W_{o} s_{t} + b_{o} \\ P (y_{t} | y_{< t}, x) = softmax (o_{t}) \end{matrix}

즉 디코더는 인코더가 요약한 정보 $s_{0}$ 를 바탕으로 출력을 생성하는데, 언어 모델에서 출력 $y_{t}$ 은 어휘 테이블 $V$ 에서의 정수 토큰 인덱스를 의미한다.

$s_{t}$ 는 또 다른 파라미터 $W_{o}$ 와 곱해져 logit 을 만드는데, 이 logit 을 softmax 함수에 통과시키면 모든 토큰에 대한 확률 분포를 구할 수 있다. 추론 시에는 이 분포로부터 확률이 가장 높은 토큰을 선택하여 출력 $y_{t}$ 를 결정한다.

Encoder–Decoder 구조는 Seq2Seq 문제를 가능하게 한 아키텍처이지만, 입력 시퀀스 $x$ 를 단일 벡터 $s_{0}$ 로 요약함으로써 과도한 정보 압축이 발생하는 한계를 가진다.

\begin{matrix} x = FC Bayern is the best club in the world. \\ y = You’re right. Germany International is the best. \end{matrix}

위 예시와 같이 입력 시퀀스 초반에 등장한 핵심 토큰에 대한 정보는 최종 hidden state $h_{T_{x}}$ 에 충분히 보존되기 어렵고, 이로 인해 디코더가 입력의 일부 의미를 제대로 반영하지 못한 출력을 생성할 수 있다.

이러한 한계를 해결하기 위해 Attention 메커니즘이 제안되었다.

Attention Mechanisms

Neural Machine Translation by Jointly Learning to Align and Translate

우선 “Neural Machine Translation by Jointly Learning to Align and Translate” 에서의 RNN 은 Bi-directional 구조이다. 양방향 RNN 이라는 뜻으로, 두개의 RNN 이 서로 다른 방향으로 진행한다:

\begin{matrix} {\vec{h}}_{t} = f ({\vec{h}}_{t - 1}, x_{t}) \\ {\overset{\leftarrow}{h}}_{t} = f ({\overset{\leftarrow}{h}}_{t + 1}, x_{t}) \end{matrix}

즉 왼쪽 → 오른쪽은 과거의 context, 오른쪽 → 왼쪽은 미래의 문맥을 담당한다. 이는 입력 시퀀스를 서로 다른 방향으로 읽어 토큰별로 더 풍부한 표현이 가능하게 한다. 출력을 미리 예측할 수 없는 Encoder-Decoder 의 구조 상, 인코더에만 두개의 RNN 이 각 방향을 담당하며, 두 방향의 hidden states 를 concatenation 한 벡터를 annotation $h_{t}$ 으로 정의한다.

h_{t} = [{\vec{h}}_{t} : {\overset{\leftarrow}{h}}_{t}]

Attention 메커니즘은 Encoder-Decoder 의 입력 시퀀스가 단일 벡터로 요약된다는 단점을 보완하기 위해 고안되었으며, 핵심 아이디어는 출력 시점 $t$ 마다 입력 시퀀스 전체를 다시 참조하는 것이다. 즉 디코더의 입력이 하나의 벡터에서, annotation 들의 집합이 된다.

Encoder RNN 이 만든 annotation 의 셋은 아래와 같이 정의된다.

H = (h_{1}, h_{2}, \dots, h_{T_{x}}) h_{i} \in ℝ^{d_{h}}

디코더는 각 출력을 생성할 때 아래와 같은 과정을 거친다.

\begin{matrix} j = 1 \dots T_{x} \\ a (s, h) = v_{a}^{⊤} tanh (W_{a} s + U_{a} h) \\ e_{t, j} = a (s_{t - 1}, h_{j}) \\ α_{t, j} = \frac{\exp (e_{t, j})}{\sum_{k = 1}^{T_{x}} \exp (e_{t, k})} \end{matrix}

$a (s, h)$ 라는 작은 신경망을 사용하여, 현재 출력 시점 $t$ 에 입력 annotation들에 대한 중요도를 확률 분포 형태 $α_{t, j}$ 로 계산한다.

c_{t} = \sum_{j = 1}^{T_{x}} α_{t, j} h_{j}

각 annotation을 attention weight로 가중합하여 context vector $c_{t}$ 를 만든다. 이 식을 풀어서 설명하면, $α_{t, j}$ $t$ 에서 는 $j$ 번째 토큰의 annotation 이 얼마나 중요한지를 의미하고, 이 값은 상수이다. $h_{j}$ 는 $d_{h}$ 차원 벡터이며, $a_{t, j} h_{j}$ 는 $(a_{t, j} h_{j, 1}, a_{t, j} h_{j, 2}, a_{t, j} h_{j, 3}, \dots, a_{t, j} h_{j, d_{h}})$ 이다.

이렇게 각 $a_{t}$ 가 곱해진 벡터를 전부 $j$ 방향으로 합한다.

s_{t} = g (s_{t - 1}, Embed (y_{t - 1}), c_{t})

이후 이전 시점의 디코더 출력 $y_{t - 1}$ , 디코더 상태 $s_{t - 1}$ , 그리고 입력 시퀀스 전체에 대한 attention 정보가 담긴 $c_{t}$ 를 이용해 다음 시점의 디코더 상태를 계산한다.

즉, 모든 출력 시점 $t$ 마다 입력 시퀀스를 요약하는 $c_{t}$ 를 새로 만들어서, 출력 시 사용하게 된다.

Adam Optimizer

Adam(Adaptive Moment Estimation)은 loss를 감소시키는 gradient의 방향을 1차 모멘트 추정을 통해 관성적으로 유지하고, 동시에 gradient 크기의 변동성을 2차 모멘트 추정을 통해 추적함으로써, 파라미터별로 신뢰도에 기반한 업데이트 크기를 조절하는 최적화 알고리즘이다.

모든 파라미터에 대해 동일한 learning rate를 적용하여 $θ_{t + 1} = θ_{t} - α g_{t}$ 와 같이 업데이트가 이루어진다. 이는 파라미터별 gradient scale이나 변동성을 고려하지 않기 때문에, gradient noise가 크거나 파라미터 간 스케일 차이가 큰 경우 학습이 불안정해질 수 있다.

Adam에서는 시점 $t$ 에서의 파라미터와 gradient를 다음과 같이 정의한다.

\begin{matrix} parameters = θ_{t} \\ g_{t} = \nabla_{θ} L (θ_{t}) \\ m_{t} = β_{1} m_{t - 1} + (1 - β_{1}) g_{t} \end{matrix}

지수 가중 평균을 이용하여 기울기의 방향을 누적시킨다. 이는 gradient의 평균 방향을 누적하여 추정하는 항으로, noise를 완화하고 일관된 하강 방향을 유지하는 역할을 한다. $β_{1}$ 이 0.9 일 경우 약 10개의 최근 $m_{t}$ 값들의 평균을 근사한다.

v_{t} = β_{2} v_{t - 1} + (1 - β_{2}) g_{t}^{2}

여기서 $g_{t}^{2}$ 는 element-wise square이다.

$v_{t}$ 는 gradient 크기의 변동성을 추적하는 항으로, gradient가 얼마나 크게 흔들리는지를 나타내는 지표이며, 해당 방향에 대한 업데이트 크기를 조절하는 데 사용된다. 이는 gradient 방향의 옳고 그름을 판단하기보다는, 해당 방향의 신뢰도를 스케일링하기 위한 정보이다.

{\hat{m}}_{t} = \frac{m_{t}}{1 - β_{1}^{t}} {\hat{v}}_{t} = \frac{v_{t}}{1 - β_{2}^{t}}

$m_{t}$ 와 $v_{t}$ 모두 지수가중 평균을 사용하므로 $t$ 가 0에 가까우면 0에 대한 편향이 생긴다. $β$ 의 $t$ 승을 사용하여 학습 초반에는 거의 $m_{t},$ $v_{t}$ 의 값이 사용되다가, 학습이 진행되며 편향에 대한 보정이 자연스럽게 사라지게 된다.

최종적으로 Adam의 파라미터 업데이트는 다음과 같이 이루어진다:

θ_{t + 1} = θ_{t} - α \frac{{\hat{m}}_{t}}{\sqrt{{\hat{v}}_{t}} + ϵ}

방향은 평균적으로 이쪽인 것 같긴 한데 step마다 너무 요동친다 → 진짜 경사인지 확신 못 하겠다 → 그러면 조금만 움직이자

Introduction

RNN은 언어 모델링과 기계 번역과 같은 시퀀스 모델링 및 변환 문제에서 효과적인 방법론으로 자리를 잡아왔고, Recurrent 언어 모델과 Encoder-Decoder 구조의 한계를 확장하려는 연구들이 이루어지고 있다.

Recurrent 모델은 일반적으로 시퀀스의 입력 순서에 따라 계산을 나눈다. 위치를 계산 시점으로 간주하므로써, 이전 입력에 대한 hidden state $h_{t - 1}$ 와 현재 입력 시점 $t$ 의 입력을 받는 $h_{t}$ 를 생성한다. → $h_{t} = f (h_{t - 1}, x_{t})$

더 나아가 Attention 메커니즘이 등장하고 시퀀스 모델의 핵심 구성요소가 되었다. 이는 기존 순환 모델이 가지고 있던 long-term dependency 표현력 문제를 어느정도 해결했으며, RNN 과 함께 사용되어 성과를 냈다.

하지만 RNN 은 본질적으로 순차적인 특성을 가지며, 이는 내부에서 연산을 병렬화할 수 없음을 의미한다. 또한 역전파 시 시퀀스 전체의 hidden state $h_{0} \dots h_{n}$ 을 모두 저장해야 하므로 메모리 사용량은 시퀀스 길이에 비례하게 되고, GPU 의 메모리는 한정되어 있으므로 무작정 배치 크기를 키울 수 없다.

저자는 이를 해결하기 위해 Recurrence 를 완전히 버리고, Attention 만으로 입-출력 간 관계, 모든 포지션의 관계, 거리에 상관 없는 연결 표현하는 새로운 모델 Transformer 를 제안한다.

Transformer 는 recurrence 기반 sequence modeling 이 아니므로 모든 포지션을 동시에 계산할 수 있어 sequence 내부 병렬화가 가능하고 GPU 친화적으로 연산이 최적화 된다고 주장한다.

또한 Transformer 는 BLEU 기준 SOTA 를 달성하였으며 타 모델에 비해 학습시간을 획기적으로 단축한다.

CNN Based Sequence Models

Recurrent 계산을 줄이려는 목표는 Transformer 만의 것이 아니다. CNN 을 기본 블럭으로 사용한 Extended Neural GPU, ByteNet, ConvS2S 와 같은 연구들이 있었고, 1D convolution 연산을 통해 RNN 의 순차성을 제거하고 sequence 내부 병렬화를 목표로 했다.

[x_{1}, x_{2}, x_{3} \dots x_{n}] x_{t} \in ℝ^{d} d = Embedding Dimension

위와 같은 입력 시퀀스에서 kernel size가 3인 1d convolution 연산은 (경계 처리를 단순화하여 표현하였다):

y_{t} = W_{1} x_{t - 1} + W_{2} x_{t} + W_{3} x_{t + 1}

이고, 의미적으로 현재 토큰 $x_{t}$ 은 주변 토큰들과 context 를 형성하여 $y_{t}$ 를 만들게 되고, 레이어를 쌓으며 한 토큰의 표현이 점점 더 넓은 범위의 시퀀스 정보에 의존하게 된다.

y_{t}^{(l)} = W_{1}^{(l)} y_{t - 1}^{(l - 1)} + W_{2}^{(l)} y_{t}^{(l - 1)} + W_{3}^{(l)} y_{t + 1}^{(l - 1)}

하지만 CNN 기반 모델의 한계는 두 포지션 $i$ 와 $j$ 사이의 정보가 서로 영향을 주려면 여러개의 레이어를 필수적으로 거쳐야 하며, 거리가 멀수록 연산 단계 수(computational path length)가 증가한다는 점이다.

두 포지션 간 정보 전달에 필요한 연산 단계 수를 $O (\cdot)$ 으로 표기한다면, ConvS2S 에서는 $O (| i - j |)$ 이고, ByteNet 은 Dilated 1D convolution 사용, dilation 을 지수적으로 증가시켜 $O (\log | i - j |)$ 이 된다.

이처럼 정보 간의 연결이 거리에 따라 비례하게 되는 단점이 있고, 이는 장거리 의존성 학습을 어렵게 만들며, 모델의 최적화 난이도를 증가시킨다. Transformer 에서는 두 포지션간 정보를 연결하는데 필요한 연산 단계 수는 상수로 줄이는 것을 목표로 한다.

Self-attention

Self-attention(=intra-attention) 은 하나의 시퀀스 내부에서 서로 다른 포지션들 간 관계를 계산해 그 결과로 토큰별 representation 을 만드는 attention 매커니즘이다. 즉 encoder–decoder attention처럼 입력–출력 간 hidden state 참조를 모델링하는 것이 아니라, 시퀀스 내부에서 각 토큰의 관계를 표현하는 방식이다.

Self-Attention 은 Transformer 이전에도 다양한 NLP 태스크에서 성공적으로 사용되어 왔으며, reading comprehension, textual entailment, sentence representation 처럼 문장 내 내부 관계가 중요하고 토큰 간 전역적 상호작용이 중요한 문제에서 특히 좋은 성능을 보였다.

그러나 대부분 입력 시퀀스로부터 하나의 표현을 얻거나 분류를 수행하는 데에 초점이 맞추어져 있었고, 입력 시퀀스를 출력 시퀀스로 변환하는 일반적인 Seq2Seq(transduction) 문제를 직접적으로 다루지는 못했다. 특히 출력이 가변 길이의 시퀀스이며 이전 출력이 이후 출력에 영향을 미치는 생성 구조를 포함하지 않았다는 점에서, 기계 번역과 같은 문제에 일반적으로 적용하기에는 한계가 있었다.

End-to-end Memory Networks

End-to-end 메모리 네트워크는 시퀀스 위치에 맞춰 반복되는 recurrent 가 아니라 attention 을 반복 적용하는 구조를 기반으로 한다. 즉 입력을 순서대로 읽지 않고, 같은 입력 전체에 대해 attention 만 여러번 적용한다.

이런 구조는 단순한 언어 Q/A, 언어 모델링에서는 좋은 성능을 낸다는 것이 증명되었다.

하지만 이러한 모델들은 attention을 여러 번 적용하는 추론 구조를 사용함에도 불구하고, 입력과 출력 시퀀스 간의 일반적인 변환을 수행하는 완전한 Seq2Seq 프레임워크로 확장되지는 않았다. 또한 attention 반복 횟수(hop 수)가 하이퍼파라미터로 고정되어 있으며, 입력과 출력 간의 명시적인 위치 정렬이나 출력 시점별 조건부 생성 구조가 부족하다는 점에서, 복잡한 시퀀스 변환 문제를 해결하는 데에는 제약이 있었다.

Transformer Architecture

현재 성능이 잘 나오는 Seq2Seq 모델들은 대부분 Encoder–Decoder 구조를 사용한다. 여기서 Encoder 는 입력 시퀀스 $x = (x_{1}, x_{2}, x_{3} \dots x_{n})$ 에 대한 annotation $z = (z_{1}, z_{2}, z_{3} \dots z_{n})$ 으로 매핑한다. Decoder 는 주어진 $z$ 에 대해 출력 시퀀스 $y = (y_{1}, y_{2}, y_{3} \dots y_{m})$ 를 한번에 하나씩 생성한다. 각 단계에서 모델은 auto-regressive 하며, 다음 기호 생성할 때 이전에 생성된 기호들을 추가 입력을 사용한다.

Transformer 는 이 전체적인 구조를 따르며, Encoder 와 Decoder 모두에서 여러 층으로 쌓인 self-attention 과 point-wise, FC 레이어들을 사용한다.

Encoder and Decoder

Encoder

Encoder는 $N = 6$ 개의 동일한 레이어를 쌓아올린 구조로 구성되며, 각 레이어는 두개의 서브 레이어를 가진다.

첫번째 서브 레이어는 Multi head self-attention 매커니즘이고, 두번째는 간단한 position-wise fully connected feed-forward 네트워크이다.

두 서브 레이어 각각에 대해 residual connection 을 적용하고 layer nomalization 을 적용한다. 즉 각 서브 레이어의 출력은 아래와 같다.

LayerNorm(x+SubLayer(x))

residual connection 을 가능하게 하기 위해 모델 내 모든 서브레이어와 임베딩 레이어는 $d_{m o d e l} = 512$ 의 출력을 생성한다.

Decoder

Decoder 는 Encoder 와 마찬가지로 $N = 6$ 개의 동일한 레이어를 쌓은 구조로 구성된다. Encoder 의 한 레이어 출력에 대해 multi-head attention 을 수행하는 세번째 서브 레이어가 존재한다.

마찬가지로 각 서브레이어는 residual connection 을 사용하고 그 뒤에 Layer Normalization 을 적용한다.

또한 Encoder 와는 다르게 첫번째 서브 레이어는 Masked Multi-Head Attention 을 수행하는데, 이는 학습 시 각 위치가 자기보다 이후의 위치를 참조할 수 없도록 Masking 하는 것을 뜻한다. ****즉 위치 $i$ 에 대한 예측이 오직 $i$ 보다 작은 위치의 이미 알려진 출력들에만 의존하도록 보장한다.

Attention

attention 함수는 하나의 Query 와 Key-Value 쌍들의 집합을 입력으로 받아 하나의 출력 벡터로 매핑하는 함수로 설명할 수 있고, Query, Key, Value, 그리고 출력은 모두 벡터이다.

출력은 Value 들의 Weighted sum 으로 계산되며 각 Value 에 할당되는 가중치는 해당 Value 에 대응되는 Key 와 Query 사이의 compatibility function 에 의해 계산된다.

Scaled Dot-Product Attention

저자는 제안하는 attention 메커니즘을 Scaled Dot-Product Attention 이라고 부른다.

입력은 차원이 $d_{k}$ 인 Query와 Key, 그리고 차원이 $d_{v}$ 인 Value 로 구성된다. 즉, $d_{k} \neq d_{v}$ 일 수 있다. 저자는 Query 와 모든 Key 의 내적을 계산한 뒤 각각 $\sqrt{d_{k}}$ 로 나누고 softmax 함수로 각 Value 들에 대한 가중치를 얻는다.

실제로는 여러개의 Query 에 대해 Attention 을 동시에 계산하며, 전체 쿼리를 행렬 $Q$ 로 묶는다. Key 와 Value 도 마찬가지로 행렬 $K$ 와 $V$ 로 묶는다.

\begin{matrix} Q \in ℝ^{n_{q} \times d_{k}} \\ K \in ℝ^{n_{k} \times d_{k}} \\ V \in ℝ^{n_{k} \times d_{v}} \\ Attention (Q, K, V) = softmax (\frac{Q K^{⊤}}{\sqrt{d_{k}}}) V \end{matrix}

Attention Mechanisms 에서의 구조로 비유하자면, 현재 디코더의 상태 $s_{t - 1}$ 에서, 인코더의 모든 annotation 에 대한 중요도를 알기 위해 $j = 1 \dots T_{x}$ 범위에서 $a (s_{t - 1}, h_{j})$ 를 수행했고, 확률 분포로 변환되어 가중합을 계산하였다.

즉 찾고자 하는 것 ( $Q$ ) 은 $s_{t - 1}$ 이고, 그것과 비교할 대상( $K$ ) 은 $h_{j}$ 이 된다. 기존 Attentio n 메커니즘 에서는 비교할 대상과 가지고 오는 값이 같았다면 ( $K = V = h$ ), Transformer는 $Q$ 와 $K$ 의 유사도를 기반으로 $V$ 들을 가중합하여 관련 정보를 추출한다.

위 식에서 $Q K^{⊤}$ 는 각 query 벡터와 모든 key 벡터 간의 내적을 계산한 것으로, 벡터들이 서로 얼마나 유사한 방향을 가리키는지를 나타낸다. query와 방향이 유사한 key일수록 더 큰 값을 가지며, 이를 softmax 함수에 통과시켜 각 key에 대한 중요도 분포를 얻는다. 이후 이 가중치를 value 벡터들에 적용해 가중합을 계산함으로써, query에 가장 관련된 정보를 효과적으로 추출한다.

저자는 여기에서 softmax 함수에 넣기 전에 내적 값을 $\sqrt{d_{k}}$ 로 나누어 정규화 하는데, 이는 $d_{k}$ 가 커질수록 내적값의 분산이 증가하여 softmax 출력이 지나치게 뾰족해지기 때문이다. $d_{k}$ 가 작은 경우에는 두 어텐션 메커니즘이 유사한 성능을 보이지만 $d_{k}$ 가 커질수록 스케일링이 없는 dot-product attention 은 additive attention 보다 성능이 떨어진다고 주장하며, $d_{k}$ 가 클 때 내적 값의 크기가 커져서 softmax 함수가 그래디언트가 극도로 작은 영역으로 밀려난다고 추측한다.

Multi-head Attention

저자는 $d_{model}$ 차원의 key, value, query 로 하나의 어텐션만 수행하는 대신, 서로 다른 학습된 선형 변환으로 $h$ 번 투영하여 각각 $d_{k}, d_{k}, d_{v}$ 차원으로 만드는 것이 더 효과적이라고 주장한다.

투영된 각 query, key, value 쌍에 대해 병렬로 attention 을 여러번 수행하여 $d_{v}$ 차원의 출력을 얻는 것이다. 이 출력들을 concat 한 후 다시 한번 선형 변환하여 최종 출력을 얻는다. 이런 방법을 Multi-Head Attention 이라고 한다.

저자가 주장하는 기존 방법론 (single head-attention) 의 문제점은, 중요도의 관계가 평균화 된다는 것이다.

\begin{matrix} x = FC Bayern München, stern des südens \\ y = FC Bayern Munich, star of the south \end{matrix}

위와같은 번역 입/출력 시퀀스가 있을 때, 출력 시점을 stern 을 star 로 번역해야 하는 타이밍으로 가정한다. single head attention 같은 경우, 중요도 분포는 아래와 비슷할 것이다.

$j$	$α_{t, j}$	$x_{j}$
1	0.10	FC
2	0.10	Bayern
3	0.20	München
4	0.05	,
5	0.25	stern
6	0.05	des
7	0.15	südens

그리고 이걸 가중합 해서 하나의 context 벡터를 만들게 되는데, 이때 서로 다른 역할의 단어들이 하나의 attention 분포로 평균된다는 것이다. 즉, 주어, 동사, 부사, 목적어 등의 정보를 하나로 묶어서 요약하게 된다.

Multi-head Attention에서는 이 과정을 $h$ 개의 head에 대해 병렬로 수행함으로써, 모델이 서로 다른 선형 투영 공간에서 다양한 관계를 분리해 학습할 수 있도록 한다. 즉 head 는 서로 다른 선형 투영을 통해 관계를 분리해 학습할 수 있는 독립적인 attention 공간을 의미한다. 이렇게 $h$ 개의 head 출력을 concatenate한 뒤, 다시 선형 변환을 적용하여 최종 출력 표현을 만든다.

\begin{matrix} MultiHead (Q, K, V) = Concat ({head}_{1}, \dots, {head}_{h}) W^{O} \\ where {head}_{i} = Attention (Q W_{i}^{Q}, K W_{i}^{K}, V W_{i}^{V}) \end{matrix}

W_{i}^{Q} \in ℝ^{d_{model} \times d_{k}}, W_{i}^{K} \in ℝ^{d_{model} \times d_{k}}, W_{i}^{V} \in ℝ^{d_{model} \times d_{v}}

입력 표현은 항상 $d_{model}$ 차원이며, 각 head 는 더 작은 $d_{k}, d_{v}$ 차원으로 투영한다. $Q, K, V$ 가 head 별로 각각 다른 가중치를 통해 선형 투영되기 때문에, 서로 다른 subspace 를 가지게 된다.

W^{O} \in ℝ^{h d_{v} \times d_{model}}

$h$ 개의 $d_{v}$ 차원을 concat 하면 $h d_{v}$ 차원이므로, $W^{O}$ 의 입력 차원은 $h d_{v}$ 이고 출력 차원을 $d_{model}$ 로 하여 다시 기존 차원을 복구한다. 이는 언급했던 Residual Connection 을 위해서이다.

저자는 $h = 8$ 로, $d_{k} = d_{v} = \frac{d_{m o d e l}}{h} = 64$ 로 설정하였다. 이렇게 하면 head 수는 1에서 $h$ 로 증가하였지만, head 의 차원을 $h$ 로 나눔으로써 어텐션을 여러번 해도 연산량이 single-head attention 과 유사하다고 설명한다.

Applications of Attention in Transformer

Transformer 는 아래 3가지의 서로 다른 방식으로 multi-head attention 을 사용한다.

encoder–decoder attention 층에서는, query는 이전 디코더 레이어의 출력에서 나오고, key와 value는 인코더의 출력에서 나온다. 이를 통해 디코더의 각 위치는 입력 시퀀스의 모든 위치에 대해 attention을 수행할 수 있다. 이는 Seq2Seq 모델에서 사용되던 전형적인 encoder–decoder attention 메커니즘을 모방한 것이다.
인코더는 self-attention 레이어를 포함한다. self-attention 레이어에서는 key, value, query가 모두 동일한 출처에서 나오며, 여기서는 인코더의 이전 레이어 출력이다. 인코더의 각 위치는 이전 인코더 레이어의 모든 위치에 대해 attention을 수행할 수 있다. 즉 Encoder self-attention에서는 입력 시퀀스의 각 위치가 동일한 시퀀스 내 모든 다른 위치와의 관계를 모델링함으로써, 전역적인 문맥 표현을 학습한다.
마찬가지로, 디코더의 self-attention 레이어는 디코더의 각 위치가 자기 자신을 포함하여 그 위치까지의 모든 위치에 대해 attention을 수행할 수 있도록 한다. auto-regressive 특성을 유지하기 위해, 디코더에서는 미래 방향(왼쪽이 아닌 오른쪽)으로부터의 정보 흐름을 차단해야 한다. 저자는 이를 scaled dot-product attention 내부에서 구현하는데, softmax의 입력 중 허용되지 않는 연결에 해당하는 값들을 $- \infty$ 로 설정하여 마스킹한다.

Q K^{⊤} \in ℝ^{T \times T} {(Q K^{⊤})}_{i, j} = {\begin{matrix} {(Q K^{⊤})}_{i, j} & j \leq i \\ - \infty & j > i \end{matrix}

\begin{matrix} {FC}_{1} & {Bayern}_{2} & {Munich}_{3} & {star}_{4} & {of}_{5} & {south}_{6} \\ {FC}_{1} & {(Q K^{⊤})}_{1,1} & - \infty & - \infty & - \infty & - \infty & - \infty \\ {Bayern}_{2} & {(Q K^{⊤})}_{2,1} & {(Q K^{⊤})}_{2,2} & - \infty & - \infty & - \infty & - \infty \\ {Munich}_{3} & {(Q K^{⊤})}_{3,1} & {(Q K^{⊤})}_{3,2} & {(Q K^{⊤})}_{3,3} & - \infty & - \infty & - \infty \\ {star}_{4} & {(Q K^{⊤})}_{4,1} & {(Q K^{⊤})}_{4,2} & {(Q K^{⊤})}_{4,3} & {(Q K^{⊤})}_{4,4} & - \infty & - \infty \\ {of}_{5} & {(Q K^{⊤})}_{5,1} & {(Q K^{⊤})}_{5,2} & {(Q K^{⊤})}_{5,3} & {(Q K^{⊤})}_{5,4} & {(Q K^{⊤})}_{5,5} & - \infty \\ {south}_{6} & {(Q K^{⊤})}_{6,1} & {(Q K^{⊤})}_{6,2} & {(Q K^{⊤})}_{6,3} & {(Q K^{⊤})}_{6,4} & {(Q K^{⊤})}_{6,5} & {(Q K^{⊤})}_{6,6} \end{matrix}

$\exp (- \infty) = 0$ 이므로, 내적값이 softmax 를 지나면 0으로 처리되어 마스킹된다.

Position-wise Feed-forward

Attention 서브레이어에 더해, 인코더와 디코더의 각 레이어는 feed-forward 네트워크를 포함한다. 이 네트워크는 각 위치에 대해 독립적으로, 그리고 동일하게 적용된다.

\begin{matrix} x \in ℝ^{d_{model}} \\ W_{1} \in ℝ^{d_{model} \times d_{ff}} \\ W_{2} \in ℝ^{d_{ff} \times d_{model}} \end{matrix}

FFN (x) = \max (0, x W_{1} + b_{1}) W_{2} + b_{2}

선형 변환은 서로 다른 위치들에 대해 동일하게 적용되지만, 레이어가 바뀔 때마다 서로 다른 파라미터를 사용한다. 이를 다른 방식으로 표현하면, 커널 크기가 1인 두 개의 convolution 연산으로 볼 수 있다.

입력과 출력의 차원은 $d_{model} = 512$ 이며, 내부 레이어의 차원은 $d_{f f} = 2048$ 이다.

Position-wise FFN은 각 토큰 위치에 대해 동일한 비선형 변환을 독립적으로 적용함으로써, attention을 통해 수집된 정보를 토큰 단위에서 재해석하고 정제하는 역할을 한다. 이 과정에서 입력 차원 $d_{model}$ 을 더 큰 중간 차원 $d_{f f}$ 로 확장한 뒤 다시 원래 차원으로 축소함으로써, 모델은 더 높은 표현력을 가진 비선형 변환을 학습할 수 있다. 이는 토큰 간 상호작용을 담당하는 attention과 달리, 토큰 내부 표현을 깊게 만드는 역할을 수행한다.

Embedding and Softmax

Transformer는 다른 시퀀스 변환 모델들과 마찬가지로, 입력 토큰과 출력 토큰을 $d_{model}$ 차원의 벡터로 변환하기 위해 임베딩 레이어의 파라미터 $E$ 를 학습한다.

또한 디코더의 출력을 다음 토큰의 확률 분포로 변환하기 위해 선형 변환과 softmax 함수를 적용한다. 저자는 Transformer 에서 입력 임베딩, 출력 임베딩, 그리고 softmax 이전 선형 변환이 동일한 가중치 행렬 $E$ 을 공유하도록 설계하였으며, 이는 기존 연구와 유사한 방식이다.

이때 임베딩 레이어에서는 해당 가중치 $E$ 에 $\sqrt{d_{m o d e l}}$ 스케일링을 적용한다. embedding 은 값의 분산이 작으므로 크기를 키워 attention 출력과 스케일을 맞춘다.

E \in ℝ^{| V | \times d_{model}}

입력 토큰 시퀀스에 대한 $E$ 사용:

$x_{t} \in ℝ^{| V |}, {(x_{t})}_{i} = {\begin{matrix} 1 & if i = index (x_{t}) \\ 0 & otherwise \end{matrix}$

e_{t}^{(enc)} = \sqrt{d_{model}} x_{t}^{⊤} E

출력 임베딩에 대한 $E$ 사용:

e_{t - 1}^{(dec)} = \sqrt{d_{model}} y_{t - 1}^{⊤} E

Softmax 이전 선형 변환에서의 $E$ 사용:

\begin{matrix} o_{t} = E^{⊤} s_{t} \in ℝ^{| V |} \\ P (y_{t} | y_{< t}, x) = softmax (o_{t}) \end{matrix}

Transformer는 모델 정의 상 입력 임베딩, 출력 임베딩, 그리고 softmax 이전 선형 변환에서 동일한 가중치 행렬 $E$ 를 공유하며, 이 공유된 파라미터는 학습 과정 전반에 걸쳐 업데이트된다.

Positional Encoding

Transformer 는 순환 구조도 없고, convolution 연산도 없기 때문에 모델이 시퀀스의 순서 정보를 활용할 수 있도록 토큰들의 상대적 혹은 절대적 위치에 대한 정보를 주입하여야 한다. 이를 위해 입력 입베딩 시 Positional Encoding 을 더한다.

Positional Encoding 은 임베딩과 동일한 $d_{model}$ 차원이며, 두 벡터를 덧셈으로 결합할 수 있다.

저자는 인코딩에 두가지 방법론이 있다고 설명하는데, 학습 가능한 방식과 고정된 방식이 있다. 본 논문에서는 서로 다른 주파수를 갖는 sine, cosine 함수를 사용한다.

\begin{matrix} P E (p o s, 2 i) & = \sin (\frac{p o s}{10000^{2 i / d_{model}}}) \\ P E (p o s, 2 i + 1) & = \cos (\frac{p o s}{10000^{2 i / d_{model}}}) \end{matrix}

$p o s$ 는 토큰이 문장에서 몇번째 위치인지, $i$ 는 벡터 안에서 몇번째 차원인지를 의미한다. 포지셔널 인코딩의 각 차원은 하나의 사인/코사인 파형에 해당한다.

식에서 삼각함수의 파장은 $2 π$ 부터 $10000 \times 2 π$ 까지 지수적으로 증가한다.

positional encoding 벡터는 여러 주파수 성분으로 구성되어 있으며, 저차원에서는 짧은 파장, 고차원에서는 긴 파장의 신호가 사용된다.

저자는 이 함수를 선택하게 된 것이 모델이 상대적 위치에 기반한 attention 을 쉽게 학습할 것이라고 가정했기 때문이라고 설명하며, 실제로 positional embedding 을 학습시켜보았으나 성능은 거의 같았다고 주장한다. 또한 학습시키는 positional embedding 을 사용할 때 보다 삼각함수로 구현할 때의 이점은 학습 때보다 더 긴 문장에도 적용될 가능성이 있기 때문이다.

어떤 고정된 거리 $k$ (position 상 거리를 의미한다.) 에 대해, $P E (p o s + k)$ 는 $P E (p o s)$ 의 선형 함수로 표현할 수 있다. 이것을 증명하기 위해 512 차원이 아니라 2 차원의 경우를 예로 들어 보자면:

P E (p o s) = [\begin{matrix} \sin (ω p o s) \\ \cos (ω p o s) \end{matrix}]

이고, $p o s + k$ 의 Positional Encoding 은:

P E (p o s + k) = [\begin{matrix} \sin (ω (p o s + k)) \\ \cos (ω (p o s + k)) \end{matrix}]

에서, 삼각함수 덧셈 공식에 의해:

\begin{matrix} \sin (ω (p o s + k)) & = \sin (ω p o s) \cos (ω k) + \cos (ω p o s) \sin (ω k) \\ \cos (ω (p o s + k)) & = \cos (ω p o s) \cos (ω k) - \sin (ω p o s) \sin (ω k) \end{matrix}

[\begin{matrix} \sin (ω (p o s + k)) \\ \cos (ω (p o s + k)) \end{matrix}] = [\begin{matrix} \cos (ω k) & \sin (ω k) \\ - \sin (ω k) & \cos (ω k) \end{matrix}] [\begin{matrix} \sin (ω p o s) \\ \cos (ω p o s) \end{matrix}]

이다. 즉 $P E (p o s + k) = M_{k} \cdot P E (p o s)$ 이고, $M_{k}$ 는 오직 offset $k$ 와 주파수 $ω$ 에만 의존한다. 곧 이 성질로 인해 self-attention과 같은 선형 연산 기반 구조에서 상대적 위치 관계를 쉽게 학습할 수 있다.

Model Formula

주의:

수식의 가독성을 위해 인코더와 디코더의 각 레이어 $l$ 에 대해 $W_{enc}^{O, (l)}, W^{Q, (l)}_{dec}$ 와 같이 표기하지 않고 통일하여 $W^{O}, W^{Q}, W^{K}, W^{V}$ 등으로 표기한다. 그러나 실제 모델에서는 인코더/디코더의 각 레이어 및 각 서브 레이어 (Self-Attention, Cross-Attention, FFN)의 파라미터는 모두 서로 독립적이며, 임베딩 파라미터 $E$ 만이 공유된다.

또한 수식은 학습용 수식을 전제로 작성했고, 학습 시에는 고정된 길이의 타깃 시퀀스를 병렬 처리하므로 미래 토큰을 차단하기 위한 causal mask가 필요하다. 반면 추론 시에는 디코더 입력이 현재까지 생성된 토큰만 포함하므로 마스크는 전부 0이거나 생략될 수 있다.

Set-up

\begin{matrix} N = 6 \\ d_{model} = 512 \\ h = 8 \\ d_{k} = d_{v} = \frac{d_{model}}{h} = 64 \\ d_{f f} = 2048 \\ E \in ℝ^{| V | \times d_{model}} \end{matrix}

Input Embedding

\begin{matrix} x = [x_{1}, x_{2}, \dots, x_{T_{x}}], x_{i} \in ℝ^{| V |} \\ e^{(enc)} = \sqrt{d_{model}} [\begin{matrix} x_{1}^{⊤} E \\ x_{2}^{⊤} E \\ ⋮ \\ x_{T_{x}}^{⊤} E \end{matrix}] \in ℝ^{T_{x} \times d_{model}} \end{matrix}

Positional Encoding

H_{e n c}^{(0)} = e_{PE}^{(enc)} = e^{(enc)} + [\begin{matrix} P E (0) \\ P E (1) \\ ⋮ \\ P E (T_{x} - 1) \end{matrix}]

Encoder Self-Attention

i = 1 \dots h

W_{i}^{Q} \in ℝ^{d_{model} \times d_{k}} W_{i}^{K} \in ℝ^{d_{model} \times d_{k}} W_{i}^{V} \in ℝ^{d_{model} \times d_{v}}

\begin{matrix} Q_{i} = H_{e n c}^{(0)} W_{i}^{Q} \in ℝ^{T_{x} \times d_{k}} \\ K_{i} = H_{e n c}^{(0)} W_{i}^{K} \in ℝ^{T_{x} \times d_{k}} \\ V_{i} = H_{e n c}^{(0)} W_{i}^{V} \in ℝ^{T_{x} \times d_{v}} \end{matrix}

{head}_{i} = Attention (Q_{i}, K_{i}, V_{i}) = softmax (\frac{Q_{i} K_{i}^{⊤}}{\sqrt{d_{k}}}) V_{i}

W^{O} \in ℝ^{h d_{v} \times d_{model}}

SA = MultiHead (H_{e n c}^{(0)}, H_{e n c}^{(0)}, H_{e n c}^{(0)}) = Concat ({head}_{1}, \dots, {head}_{h}) W^{O}

SA \in ℝ^{T_{x} \times d_{model}}

Residual Connection + LayerNorm

{SA}_{out} = LayerNorm (e_{PE}^{(enc)} + SA)

Position Wise Feed-Forward Network

i = 1 \dots T_{x}

\begin{matrix} {({SA}_{o u t})}_{i} \in ℝ^{d_{model}} \\ W_{1} \in ℝ^{d_{model} \times d_{ff}} \\ W_{2} \in ℝ^{d_{ff} \times d_{model}} \end{matrix}

\begin{matrix} FFN (x) = \max (0, x W_{1} + b_{1}) W_{2} + b_{2} \\ {FFN}_{r a w} = [\begin{matrix} FFN ({({SA}_{out})}_{1}) \\ ⋮ \\ FFN ({({SA}_{out})}_{T_{x}}) \end{matrix}] \in ℝ^{T_{x} \times d_{model}} \end{matrix}

Residual Connection + LayerNorm

H^{(1)} = {FFN}_{o u t} = LayerNorm ({SA}_{o u t} + {FFN}_{r a w})

repeat $N = 6$ times

EncoderLayer (X) = \begin{matrix} Y & = LayerNorm (X + MultiHead (X, X, X)) \\ Z & = LayerNorm (Y + FFN (Y)) \end{matrix}

H_{e n c}^{(l)} = EncoderLayer (H_{e n c}^{(l - 1)}), l = 1, \dots, N

H_{e n c}^{(N)} \in ℝ^{T_{x} \times d_{model}}

Output Embedding

\begin{matrix} y = [⟨ SOS ⟩, y_{1}, y_{2}, \dots, y_{T_{y} - 1}], y_{i} \in ℝ^{| V |} \\ e^{(dec)} = \sqrt{d_{model}} [\begin{matrix} {⟨ SOS ⟩}^{⊤} E \\ y_{1}^{⊤} E \\ y_{2}^{⊤} E \\ ⋮ \\ y_{T_{y} - 1}^{⊤} E \end{matrix}] \in ℝ^{T_{y} \times d_{model}} \end{matrix}

Positional Encoding

H_{d e c}^{(0)} = e_{PE}^{(dec)} = e^{(dec)} + [\begin{matrix} P E (0) \\ P E (1) \\ ⋮ \\ P E (T_{y} - 1) \end{matrix}]

Masked Self-Attention

i = 1 \dots h

W_{i}^{Q} \in ℝ^{d_{model} \times d_{k}} W_{i}^{K} \in ℝ^{d_{model} \times d_{k}} W_{i}^{V} \in ℝ^{d_{model} \times d_{v}}

\begin{matrix} Q_{i} = H_{d e c}^{(0)} W_{i}^{Q} \in ℝ^{T_{y} \times d_{k}} \\ K_{i} = H_{d e c}^{(0)} W_{i}^{K} \in ℝ^{T_{y} \times d_{k}} \\ V_{i} = H_{d e c}^{(0)} W_{i}^{V} \in ℝ^{T_{y} \times d_{v}} \end{matrix}

\begin{matrix} M_{t, j} = {\begin{matrix} 0 & if j \leq t \\ - \infty & if j > t \end{matrix} \in ℝ^{T_{y} \times T_{y}} \\ {head}_{i} = MaskedAttention (Q_{i}, K_{i}, V_{i}, M) = softmax (\frac{Q_{i} K_{i}^{⊤}}{\sqrt{d_{k}}} + M) V_{i} \end{matrix}

W^{O} \in ℝ^{h d_{v} \times d_{model}}

MSA = MultiHead (H_{d e c}^{(0)}, H_{d e c}^{(0)}, H_{d e c}^{(0)}) = Concat ({head}_{1}, \dots, {head}_{h}) W^{O}

MSA \in ℝ^{T_{y} \times d_{model}}

Residual Connection + LayerNorm

{MSA}_{out} = LayerNorm (H_{d e c}^{(0)} + MSA)

Cross Attention

i = 1 \dots h

\begin{matrix} Q_{i} = {MSA}_{o u t} W_{i}^{Q} \in ℝ^{T_{y} \times d_{k}} \\ K_{i} = H_{e n c}^{(N)} W_{i}^{K} \in ℝ^{T_{x} \times d_{k}} \\ V_{i} = H_{e n c}^{(N)} W_{i}^{V} \in ℝ^{T_{x} \times d_{v}} \end{matrix}

{head}_{i} = Attention (Q_{i}, K_{i}, V_{i}) = softmax (\frac{Q_{i} K_{i}^{⊤}}{\sqrt{d_{k}}}) V_{i}

W^{O} \in ℝ^{h d_{v} \times d_{model}}

CA = MultiHead ({MSA}_{o u t}, H_{e n c}^{(N)}, H_{e n c}^{(N)}) = Concat ({head}_{1}, \dots, {head}_{h}) W^{O}

CA \in ℝ^{T_{y} \times d_{model}}

Residual Connection + LayerNorm

{CA}_{out} = LayerNorm ({MSA}_{o u t} + CA)

Position Wise Feed-Forward Network

i = 1 \dots T_{y}

\begin{matrix} {({CA}_{o u t})}_{i} \in ℝ^{d_{model}} \\ W_{1} \in ℝ^{d_{model} \times d_{ff}} \\ W_{2} \in ℝ^{d_{ff} \times d_{model}} \end{matrix}

\begin{matrix} FFN (x) = \max (0, x W_{1} + b_{1}) W_{2} + b_{2} \\ {FFN}_{r a w} = [\begin{matrix} FFN ({({CA}_{out})}_{1}) \\ ⋮ \\ FFN ({({CA}_{out})}_{T_{y}}) \end{matrix}] \in ℝ^{T_{y} \times d_{model}} \end{matrix}

Residual Connection + LayerNorm

H_{d e c}^{(1)} = {FFN}_{o u t} = LayerNorm ({CA}_{o u t} + {FFN}_{r a w})

repeat $N = 6$ times

H_{dec}^{(0)} = e_{PE}^{(dec)}

\begin{matrix} l = 1, \dots, N \\ \begin{matrix} \tilde{H} & = LayerNorm (H_{dec}^{(l - 1)} + MaskedAttention (H_{d e c}^{(l - 1)}, H_{d e c}^{(l - 1)}, H_{d e c}^{(l - 1)}, M)) \\ \hat{H} & = LayerNorm (\tilde{H} + CrossAttention (\tilde{H}, H_{enc}^{(N)}, H_{enc}^{(N)})) \\ H_{dec}^{(l)} & = LayerNorm (\hat{H} + FFN (\hat{H})) \end{matrix} \end{matrix}

H_{d e c}^{(N)} \in ℝ^{T_{y} \times d_{model}}

Embedding and softmax

\begin{matrix} o_{t} = {(H_{dec}^{(N)})}_{t} E^{⊤} \in ℝ^{| V |} \\ P (y_{t} | y_{< t}, x) = softmax (o_{t}) \end{matrix}

Why Self-Attention

저자는 이 절에서 시퀀스 $(x_{1}, \dots, x_{n})$ 를 동일한 길이의 또 다른 시퀀스 $(z_{1}, \dots, z_{n})$ 로 변환하는 데 일반적으로 사용되는 순환(recurrent) 레이어와 합성곱(convolutional) 레이어를 self-attention 레이어의 여러 측면과 비교한다. (여기서, $x_{i}, z_{i} \in ℝ^{d}$ )

Self-Attention 이 다른 방법론과 비교하여 크게 세가지 이점이 있는데, 하나는 레이어 당 연산 복잡도의 우위이고, 또 하나는 병렬화 될 수 있는 계산의 양으로, 이는 필요한 최소 순차 연산의 개수로 측정한다. 즉 선행되어야하는 연산이 얼마나 있는가가 병렬화 가능성을 의미한다.

마지막 세번째는 장거리 의존성을 연결하는 경로의 길이이다. 장거리 의존성을 학습하는 것은 많은 시퀀스 변환 문제에서 핵심적인 어려움이며, 순전파 및 역전파 신호가 네트워크를 통해 이동해야 하는 경로의 길이를 의미하기 때문이다. 입력과 출력 시퀀스의 어떤 위치 쌍에 대해서든, 이 경로가 짧을수록 장거리 의존성을 학습하기가 더 쉬워진다.

따라서 저자는 서로 다른 레이어 타입(RNN, CNN, self-attention)으로 구성된 네트워크에서, 임의의 두 입력/출력 위치 사이의 최대 경로 길이를 비교한다.

vs. RNN

self-attention 레이어는 모든 위치를 상수 개수의 순차 연산으로 연결하는 반면, recurrent 레이어는 $O (n)$ 개의 순차 연산이 필요하다. 계산 복잡도 측면에서 보면, 시퀀스 길이 $n$ 이 표현 차원 $d$ 보다 작을 때 self-attention 레이어는 recurrent 레이어보다 빠르다.

RNN 에서 hidden state 를 계산하기 위해 $W_{h} h_{t - 1}$ 를 계산하는데, 여기서 $W_{h} \in ℝ^{d \times d}$ 이므로, 계산 복잡도는 $O (d^{2})$ 이며, $n$ 스텝을 계산해야하므로 RNN 의 계산 복잡도는 $O (n \cdot d^{2})$ 이다.

Self-Attention 은 $Q K^{⊤}$ 에서 $Q, K \in ℝ^{n \times d}$ 이다. 즉 행렬 곱에서 각 원소 계산 비용은 $d$ 이고 원소는 $n^{2}$ 이므로 $O (n^{2} \cdot d)$ 이다. 곧:

\begin{matrix} n < d \\ RNN \to O (n \cdot d^{2}) \\ SelfAttention \to O (n^{2} \cdot d) \\ n^{2} d < n d^{2} \end{matrix}

이기 때문에, $n < d$ 에서 Self-Attention 이 RNN 보다 계산 복잡도가 낮다.

아주 긴 시퀀스를 다루는 작업의 계산 성능을 개선하기 위해 self-attention을 출력 위치를 중심으로 한 크기 $r$ 의 이웃 영역만 고려하도록 제한할 수도 있다. 이렇게 하면 최대 경로 길이는 $O (n / r)$ 로 증가하는데, 이 접근법은 본 논문에서는 더 연구되지는 않는다.

vs. CNN

커널 폭이 $k < n$ 인 단일 convolution 레이어는 입력과 출력 위치의 모든 쌍을 연결하지 못한다. 이를 달성하려면 연속된 커널을 사용하는 경우 $O (n / k$ )개의 합성곱 레이어를 쌓아야 한다. 혹은 dilated convolution의 경우에는 $O (\log_{k} n)$ 개의 레이어가 필요하다. 또한 동일한 표현 차원에서, 커널 폭이 $k$ 인 convolution은 한 시점당 $k$ 개의 입력을 처리하므로 순환 레이어보다 일반적으로 $k$ 배 많은 연산을 요구한다.

하지만 separable convolution 로 계산 복잡도를 상당히 줄일 수 있는데, 먼저 각 채널을 독립적으로 $k$ 로 convolution 한다. 이는 $X \in ℝ^{n \times d}$ 에서 각 채널 $c$ 에 대해 $X_{i, c}$ 에 대해서만 convolution 하는 것을 의미한다. 즉 요소 갯수 $n \times d$ 개 에서, 각 요소마다 곱셈 $k$ 회 이므로 $O (n \cdot k \cdot d)$ ),

이후 kernel size 1의 point wise convolution을 적용하여 채널 방향으로 선형 결합한다. 선형 결합은 $X W$ 를 의미하는데, $X \in ℝ^{n \times d}, W \in ℝ^{d \times d}$ 이므로, 원소 갯수 $d^{2}$ , 원소 당 연산 $n$ 개이므로, $O (n \cdot d^{2})$ .

결론적으로 separable convolution 의 계산 복잡도는 $O (k \cdot n \cdot d + n \cdot d^{2})$ . 그러나 $k = n$ 인 경우에 분리 합성곱의 계산 복잡도는 self-attention 레이어와 point wise feed-forward 레이어를 결합한 것과 동일하다.

즉 CNN 으로 Self-Attention 의 path length 에 도달하려면 $k = n$ 이어야 하며, 이 경우 계산 복잡도는 self-attention + point-wise feed forward 와 동일하다는 것이다.

Side Benefit

부수적인 이점으로, self-attention은 더 해석하기 쉽다. 저자는 모델에서 나온 attention 분포를 분석하였고, 개별 attention head 들이 서로 다른 역할을 학습한다는 점을 시각화를 통해 관찰하였고 많은 head들이 문장의 syntactic 및 semantic 구조와 관련된 행동이 보인다고 주장한다.

즉 Self-attention은 단순히 성능이 좋은 구조일 뿐 아니라, attention weight를 통해 모델이 무엇을 보고 판단하는지 비교적 명확하게 해석할 수 있는 구조다.

Training

Tokenizers

Byte-Pair Encodoing

BPE는 단어를 문자 단위에서 시작해, 가장 자주 함께 등장하는 문자(또는 서브워드) 쌍을 반복적으로 병합하여 서브워드 어휘를 만드는 빈도 기반 토크나이징 기법이다.

학습 과정은 단순히 말뭉치에서 가장 빈번한 쌍을 찾고 이를 하나의 토큰으로 합치는 작업을 정해진 횟수만큼 반복하는 방식이며, 이로써 어휘 크기를 제한하면서도 희귀 단어를 여러 서브워드의 조합으로 표현할 수 있다. BPE는 계산이 간단하고 데이터 규모가 크지 않아도 안정적으로 동작하기 때문에, WMT 영어–독일어 번역과 같이 비교적 중간 규모 데이터에서 표준적으로 사용되어 왔다.

playing, played, player, plays

의 예시에서, p + l, pl + a, pla + y 같이 자주 같이 등장하는 문자쌍 위주로 병합하는 방식이다.

WordPiece

WordPiece는 단어를 서브워드 단위로 분해한다는 점에서는 BPE와 유사하지만, 병합 기준으로 단순 빈도가 아니라 언어 모델의 확률( $\log$ likelihood)을 가장 크게 개선하는 쌍을 선택하는 확률 기반 토크나이징 기법이다.

즉, 두 토큰을 합쳤을 때 문장 전체의 생성 확률이 얼마나 좋아지는지를 기준으로 병합을 결정한다. 이 때문에 WordPiece는 이론적으로 더 정교한 기준을 사용하지만, 충분한 데이터가 있을 때 효과적이며 학습 비용은 BPE보다 다소 높다.

playing, played, player, plays

의 예시에서, play + (ing, ed, er) 일 때 모델이 likelihood 를 최대로 만드므로, play라는 서브워드를 만들었을 때 전체 문장 확률이 올라가면, 그 병합을 채택한다.

Training Data and Batching

WMT 2014 번역 벤치마크에서 저자는 두 가지 데이터셋으로 Transformer를 학습했다. 영어-독일어는 약 450만 개의 문장 쌍으로 구성된 표준 WMT14 데이터를 사용했고, 영어-프랑스어는 훨씬 규모가 큰 3,600만 문장 쌍의 WMT14 데이터를 사용했다. 두 실험 모두 단어를 그대로 쓰지 않고, 희귀 단어를 더 작은 단위로 쪼개는 서브워드 토크나이징을 적용했다. 영어-독일어에서는 Byte-Pair Encoding(BPE)을 사용해 소스와 타깃이 공유하는 약 37,000개 토큰 어휘를 만들었고, 영어-프랑스어에서는 word-piece 방식으로 약 32,000개 토큰 어휘를 사용했다. 이런 서브워드 기반 어휘를 쓰면 OOV(어휘 밖 단어) 문제가 줄고, 언어 간 형태 변화가 큰 단어도 조합적으로 표현할 수 있다.

BPE 는 빈도 기반이므로, 데이터가 아주 크지 않아도 안정적으로 동작한다. 병합 기준이 단순하기 때문이다. 반면 WordPiece 는 확률 기반이므로, 충분히 큰 말뭉치가 있어야 병합 판단이 의미있다. 즉 데이터가 적으면 불안정 할 수 있다. 그래서 불어에 비해 데이터가 적은 독일어 쪽에 BPE 를 사용했다고 해석된다.

저자는 배치 구성 방식도 Transformer 특성에 맞춰 설계했다. 문장 수를 고정해서 배치를 만드는 대신, 문장 쌍을 대략 비슷한 길이끼리 묶은 뒤 한 배치가 포함하는 토큰 수를 거의 일정하게 맞췄다. 구체적으로는 한 배치가 대략 소스 토큰 25,000개와 타깃 토큰 25,000개를 포함하도록 문장 쌍을 모았다. 이렇게 하면 길이가 제각각인 문장을 무작정 섞었을 때 발생하는 과도한 padding 낭비가 줄어들고, 특히 시퀀스 길이에 따라 비용이 커지는 self-attention(대략 $O (n^{2})$ )을 더 효율적으로 학습할 수 있다.

Hardware and Schedule

저자는 8개의 P100 GPU 환경에서 Transformer를 학습했으며, base 모델은 약 12시간, big 모델은 약 3.5일이 소요되었다. 이는 Transformer가 병렬화에는 유리하지만, 대규모 연산 자원을 전제로 한 모델임을 보여준다.

Optimizer

저자는 Adam 옵티마이저를 사용했으며, 1차 모멘트 계수는 $β_{1} = 0.9$ , 2차 모멘트 계수는 $β_{2} = 0.98$ , 수치 안정화를 위한 상수는 $ϵ = 10^{- 9}$ 로 설정했다.

보편적으로 사용하는 $β_{2} = 0.999$ 를 사용하지 않은 것이 포인트인데, $0.98$ 은 훨씬 빠른 분산 반응을 보인다. 이는 Transformer 에서 attention score 분포가 step 마다 크게 변하기 때문이며, 특정 head, token 에 몰렸다가 사라져 과거의 분산 정보가 금방 쓸모없어지기 때문이다.

또한 학습 과정 전체에 걸쳐 학습률을 변화시켰다.

lrate = d_{model}^{- 0.5} \cdot \min ({step}^{- 0.5}, step \cdot {warmup_steps}^{- 1.5})

Transformer는 학습 초반 불안정을 막기 위해 처음 4000 step 동안 학습률을 step에 비례해 선형적으로 증가시키고, 이후에는 step 수의 역제곱근에 비례하도록 감소시키는 learning rate schedule을 사용한다.

Regularization

Residual Dropout

Transformer에서는 각 서브레이어의 출력에 dropout을 적용한 뒤 residual connection과 layer normalization을 수행하는 residual dropout을 사용한다. 이는 identity path의 안정성을 유지하면서 서브레이어 출력에만 정규화를 가하기 위함이다.

LayerNorm (x + Dropout (Sublayer (x)))

또한 입력 단계에서 token embedding과 positional encoding의 합에도 dropout을 적용하여 위치 정보에 대한 과도한 의존을 방지한다. Base 모델에서는 dropout 비율로 0.1을 사용한다.

H^{(0)} = Dropout (E (x) + P E (x))

Label Smoothing

퍼플렉시티(perplexity)는 언어 모델이 정답 토큰을 얼마나 “확신하지 못하는지”를 나타내는 지표로, 각 시점에서 정답 단어에 할당한 로그 확률의 평균을 지수화한 값이다. 직관적으로는 모델이 다음 단어를 예측할 때 평균적으로 몇 개의 후보 앞에서 망설이고 있는지를 의미하며, 값이 낮을수록 모델이 정답에 높은 확률을 부여하고 있음을 뜻한다.

라벨 스무딩(label smoothing)은 학습 시 정답 레이블을 one-hot 벡터로 두지 않고, 정답 클래스의 확률을 1보다 작게 낮추고 나머지 확률을 다른 클래스들에 소량 분산시키는 정규화 기법이다. 이로 인해 모델은 특정 토큰에 대해 100% 확신을 갖도록 강제되지 않으며, 출력 분포가 지나치게 뾰족해지는 것을 방지한다. 결과적으로 모델은 “정답일 가능성이 가장 높다”는 정보는 유지하되, 대안 토큰들에 대해서도 일정 수준의 확률을 할당하도록 학습된다. 이는 over-confidence를 줄이고, softmax 출력의 포화를 방지하는 역할을 하며, 출력 분포 자체에 작용하는 regularization으로 볼 수 있다.

저자는 학습 과정에서 라벨 스무딩( $ϵ_{l s} = 0.1$ )을 적용하였으며, 이로 인해 퍼플렉시티는 오히려 악화되지만 정확도와 BLEU 점수는 향상된다고 보고한다. 이는 라벨 스무딩이 정답 토큰의 확률을 의도적으로 낮추기 때문에 퍼플렉시티 기준에서는 손해처럼 보이지만, 번역 과제에서 중요한 것은 단일 토큰의 확률 최대화가 아니라 문장 전체의 상대적 품질이기 때문이다.

Results

Machine Translation

저자는 Transformer 논문에서 저자들은 WMT 2014 영어–독일어와 영어–프랑스어 번역 과제를 통해 모델의 성능과 효율성을 평가하였다. 영어–독일어 번역에서는 약 450만 문장 쌍으로 구성된 데이터셋을 사용했으며, Transformer(big) 모델은 BLEU 28.4를 기록해 기존 최고 성능 모델들(앙상블 포함)을 2 BLEU 이상 앞지르며 새로운 최고 성능을 달성했다. 영어–프랑스어 번역에서는 3,600만 문장으로 이루어진 훨씬 더 큰 데이터셋을 사용했으며, Transformer(big)은 BLEU 41.0을 기록해 기존 모든 단일 모델을 능가했고, 이전 최고 성능 모델 대비 훈련 비용은 1/4 이하에 불과했다. 심지어 base 모델조차도 기존의 모든 단일 모델과 앙상블을 뛰어넘는 성능을 훨씬 적은 계산 비용으로 달성했다.

base 모델과 대부분의 실험에서는 dropout 비율 0.1을 적용했다. 반면 Transformer(big)은 기본적으로 파라미터 수가 많아 과적합 위험이 크기 때문에 dropout 0.3을 사용했지만, 데이터 규모가 매우 큰 영어–프랑스어 번역 실험에서는 과도한 정규화를 피하기 위해 dropout을 0.1로 낮췄다. 이는 모델 크기뿐 아니라 데이터 규모에 따라 적절한 정규화 강도가 달라져야 함을 보여준다.

Model Variations

저자는 Transformer의 각 구성 요소가 성능에 미치는 영향을 분석하기 위해, base 모델을 다양한 방식으로 변형하는 테스트를 수행하였다. 평가는 영어–독일어 번역 개발셋(newstest2013)에서 이루어졌으며, beam search는 사용하되 checkpoint averaging은 적용하지 않았다.

multi-head attention의 중요성이 확인되었다. 단일 head attention은 최적 설정 대비 약 0.9 BLEU 낮은 성능을 보였으며, 이는 여러 head를 통해 서로 다른 관계를 병렬적으로 학습하는 구조가 번역 성능에 실질적으로 기여함을 의미한다. 다만 head 수를 지나치게 늘릴 경우 각 head의 차원이 너무 작아져 성능이 다시 저하되었다.
attention key 차원 $d_{k}$ 은 모델 성능에 중요한 요소였다. $d_{k}$ 를 줄이면 번역 품질이 감소했는데, 이는 query–key 간의 유사도를 판단하는 문제가 단순하지 않으며 충분한 표현 공간이 필요함을 시사한다.
모델 크기와 정규화의 효과도 명확히 나타났다. 모델을 크게 만들수록 성능은 향상되었고, dropout은 과적합을 방지하는 데 매우 중요한 역할을 했다. 특히 Transformer처럼 파라미터 수가 많은 모델에서는 dropout이 없을 경우 성능이 크게 악화되었다.
positional encoding 방식에 대한 실험에서는 사인-코사인 기반 고정 positional encoding과 학습 가능한 positional embedding 사이에 성능 차이가 거의 없었다. 이는 Transformer가 고정된 위치 인코딩만으로도 충분히 위치 정보를 활용할 수 있음을 보여준다.

English Constituency Parsing

저자는 Transformer가 기계 번역을 넘어 다른 시퀀스 변환 문제에도 일반화될 수 있는지를 검증하기 위해 영어 구문 분석(constituency parsing) 실험을 수행하였다. 구문 분석은 출력이 강한 구조적 제약을 따르고 출력 시퀀스가 입력보다 훨씬 길어지는 어려운 과제로, 모델의 장거리 의존성 처리 능력과 구조적 표현력을 평가하기에 적합하다.

실험 결과, Transformer는 과제 특화된 구조나 복잡한 튜닝 없이도 매우 우수한 성능을 보였으며, 기존 RNN 기반 sequence-to-sequence 모델들을 모두 능가하였다. 특히 데이터 규모가 작은 환경에서도 전통적인 구문 분석 모델인 Berkeley Parser보다 더 나은 성능을 기록하였다. 이는 self-attention 기반 Transformer가 장거리 의존성과 전역적 구조를 효과적으로 모델링할 수 있음을 보여주며, Transformer가 번역을 넘어 다양한 구조적 시퀀스 변환 문제에서도 강한 일반화 성능을 갖는다는 점을 입증한다.

Conclusion

저자는 본 논문에서 Transformer를 제안하였다. Transformer는 기존 encoder–decoder 구조에서 널리 사용되던 순환(recurrent) 레이어를 완전히 제거하고, multi-head self-attention만으로 구성된 최초의 시퀀스 변환 모델이다.

기계 번역 실험에서 Transformer는 RNN이나 CNN 기반 모델들에 비해 훨씬 빠르게 학습될 수 있었으며, WMT 2014 영어–독일어 및 영어–프랑스어 번역 과제 모두에서 SOTA를 달성하였다. 특히 영어–독일어 번역에서는 기존의 모든 앙상블 모델들까지도 능가하는 성능을 기록하였다.

저자들은 이러한 결과를 바탕으로 attention 기반 모델의 잠재력에 큰 기대를 표하며, 향후 Transformer를 텍스트를 넘어 이미지, 오디오, 비디오와 같은 다양한 입력·출력 모달리티로 확장할 계획임을 밝힌다. 또한 매우 큰 입력과 출력을 효율적으로 처리하기 위해 국소적(local) 또는 제한된 attention 메커니즘을 연구하고, 생성 과정의 순차성을 더욱 줄이는 방향도 중요한 향후 연구 과제로 제시한다.

Deep Residual Learning for Image Recognition

2025-12-31T00:00:00.000Z

https://arxiv.org/abs/1512.03385

Backgrounds

Batch Normalization

https://arxiv.org/abs/1502.03167

Batch Normalization(이하 BN) 은 활성함수에 입력되기 직전의 선형 출력을 미니배치 단위로 평균 0, 분산 1로 정규화 하는 기법이며, 기울기 소실/폭발 현상을 완화할 수 있는 방법이다.

레이어의 forward 연산은 $z = W x, a = f (z)$ 이고 (바이어스 생략), 역전파는:

\frac{d L}{d x} = W^{T} (\frac{d L}{d a} ⊙ f^{'} (z))

이다.

$f^{'}$ 는 활성함수의 도함수이므로:

{sigmoid}^{'} (z) \in (0, 1) \tanh^{'} (z) \in (0, 1) {ReLU}^{'} (z) \in {0, 1}

이다. 즉 활성함수의 도함수는 기울기를 증폭시키지 못하므로, 역전파에서 기울기 폭발의 주요 원인은 가중치 행렬 $W^{T}$ 의 스케일이다.

또, $W$ 의 스케일이 큰 경우, 작은 $x$ 의 변화에도 $z$ 의 값이 크게 변화하게 된다. 즉 $z$ 의 분산이 커지며, $z$ 분포의 상당 부분이 활성함수의 포화 영역에 위치하게 된다.

사진처럼 활성함수가 $tanh$ 인 경우, $z$ 의 분포가 1 이상일 때 $f^{'} (z)$ 는 극단적으로 작아지게 된다. 곧 역전파에서 $\frac{d L}{d a} ⊙ f^{'} (z)$ 의 값이 작아지므로, 기울기가 소실된다.

그래서 BN 은 $z$ 가 활성함수로 들어가기 전에 미니배치( $_{B}$ ) 단위로 정규화 하여 활성함수의 중앙 부분에 $z$ 가 분포하도록 강제한다.

\hat{z} = \frac{z - μ_{B}}{\sqrt{σ_{B}^{2} + ϵ}} y = γ \hat{z} + β

단순히 스케일을 정규화하는 것이 아니라, 학습 파라미터 $γ, β$ 를 사용하여 입력 분포를 스케일 하거나 이동시킬 수 있게 한다. 즉 $γ, β$ 는 정규화로 사라진 스케일과 자유도를 복원하여 네트워크가 필요한 경우 선형 변환을 다시 학습할 수 있도록 한다.

VGG

https://arxiv.org/abs/1409.1556

VGG는 작은 3×3 convolution을 반복적으로 쌓아 깊이를 늘리면 성능이 좋아진다는 것을 처음으로 명확히 보여준 CNN이다. 공간 해상도는 pooling으로 줄이고 채널 수를 늘리며, 저수준 특징에서 고수준 개념으로 가는 계층적 표현을 형성한다는 점에서 다양한 CNN 설계의 레퍼런스가 되었다.

반면 한계도 분명하다. fully connected 레이어로 인해 파라미터 수와 연산량이 과도하게 크고, BN이나 residual connection이 없어 더 깊은 구조로 확장하기 어렵다. 또한 pooling 중심의 downsampling은 위치 정보 손실을 초래한다.

Faster R-CNN

https://arxiv.org/abs/1506.01497

R-CNN은 객체 검출을 “영역 제안 + CNN 분류”로 분해한 최초의 실용적 방법이다. 먼저 Selective Search로 이미지당 약 2천 개의 region proposal을 만들고, 각 영역을 개별적으로 CNN에 통과시켜 feature를 뽑은 뒤 분류하고 bounding box regression으로 위치를 보정한다.

이 방식은 CNN의 강력한 표현력을 detection에 처음 성공적으로 도입했다는 점에서 의미가 크지만, 모든 proposal을 독립적으로 CNN에 넣는 구조 때문에 계산량과 저장 비용이 비현실적으로 크고, 학습 파이프라인도 여러 단계로 분리돼 있다.

Faster R-CNN은 R-CNN 계열의 병목이던 region proposal 자체를 신경망 안으로 흡수했다. Selective Search를 제거하고, convolution feature map 위에서 RPN(Region Proposal Network)이 proposal을 생성한다. 이 proposal들은 RoI(Region of Interest) Pooling을 통해 고정 크기 feature로 변환되어, 하나의 CNN backbone을 proposal 생성과 분류가 공유한다.

결과적으로 Faster R-CNN은 정확도를 유지하면서도 속도를 획기적으로 개선했다.

Introduction

깊은 합성공 신경망(CNN) 은 이미지 분류 분야에서 엄청난 돌파구를 만들어냈다. 전통적인 이미지 인색 파이프라인은 가장자리, 곡선 등을 검출하는 Low-level 단계, part, pattern 을 검출하는 Mid-level, 얼굴, 사물 등을 인식하는 High-level, 그리고 classifier 까지, 명시적으로 구분된 단계가 있었으며 이를 사람이 단계별로 설계했고, 각 단계는 따로 최적화 되었다.

CNN 은 Image 로 부터 classifier 까지 전 과정을 하나의 네트워크가 알아서 학습하도록 하며, 계층적 표현 + 분류기가 하나의 깊은 함수로 묶여 있어 end-to-end 모델을 구성할 수 있었다.

CNN 에서 이러한 특징의 Level 은 레이어를 더 깊이 쌓을 수록 더욱 풍부해질 수 있다. 이는 네트워크의 깊이가 늘어날 수록 표현력이 증가함을 의미하고, 관련 연구들이 네트워크의 깊이가 결정적으로 중요하다는 것을 보여준다. 난이도가 높은 ImageNet 데이터셋에서 최고 성능을 낸 모델들은 모두 매우 깊은 모델을 사용한다. (VGG-16, VGG-19, GoogLeNet 등)

detection, segmentation, pose estimation 같은 고난도의 시각 인식 문제들에서도 깊은 모델은 효과가 있었다. 이는 깊은 네트워크가 classification 뿐만 아니라 범용적인 이점으로 작용함을 의미한다.

이처럼 깊은 네트워크의 중요성이 커지면서 의문이 생긴다.

단순히 레이어만 더 쌓는 것만으로 더 좋은 네트워크를 학습할 수 있는가?

이 질문에 대한 답은 gradient vanishing/exploding 에 의해 가로막힌다. 이 문제는 학습 초반부터 모델 최적화를 방해한다. 이 문제는 normalized initialization, batch normalization 에 의해 상당 부분 해결되었고, 이로 인해 깊은 네트워크에서도 SGD + 역전파로 학습을 시작할 수 있게 되었다.

그러나 학습을 시작할 수 있는 것과 얼마나 최적화할 수 있는지는 별개의 문제이다. 저자는 실험 결과를 통해 깊은 네트워크에서 얇은 네트워크보다 training/test error 가 높게 나타나는 현상(degradation)에 주목한다.

degradation은 적절히 깊은 모델에 더 많은 레이어를 추가했을 때 관측되며, 이는 training accuracy 자체가 떨어지기 때문에 과적합에 의한 문제가 아니다.

이는 표현력 관점에서 말이 되지 않는다. 만약 적당한 깊이의 네트워크가 있을 때, 여기서 레이어를 더 추가한 깊은 네트워크를 생각해보자.

더 깊은 네트워크를 만들기 위해 기존 네트워크 위에 새로운 레이어들을 추가하고, 기존 Original Network의 가중치와 바이어스를 그대로 복사한다고 가정하자.

이때 새로 추가된 레이어들이 모두 항등함수(identity mapping)를 구현한다면, 확장된 깊은 네트워크는 깊어지기 전의 Original Network와 동일한 training/test error를 갖는 해(solution)를 표현할 수 있다.

즉, 더 깊은 네트워크는 얕은 네트워크를 포함하는 함수 공간을 가지며, 추가된 레이어가 항등함수를 구현할 수 있다면 얕은 네트워크에서 얻어진 해는 깊은 네트워크에서도 그대로 재현 가능하다. 따라서 깊은 네트워크의 최소 training error는 얕은 네트워크보다 클 수 없다.

그럼에도 불구하고 실제 학습 과정에서 SGD가 이러한 해를 찾지 못한다는 사실은 관측되는 degradation 현상이 overfitting과 무관하며, 모델 구조 자체가 최적화 관점에서 어려움을 가지고 있음을 시사한다.

이에 저자는 identity mapping 을 모델이 구조적으로 쉽게 표현할 수 있도록 residual function을 도입한 ResNet 구조를 제안한다. 이는 단순히 더 깊은 네트워크를 가능하게 한 것이 아니라, 존재하지만 SGD가 찾기 어려웠던 해를 구조적으로 쉽게 최적화할 수 있도록 만든 설계이다.

Residual Block

저자는 degradation 문제를 해결하기 위해 여러 개의 레이어를 단순히 쌓아서 원하는 함수를 직접 근사하길 기대하는 대신, 레이어들이 Residual 함수를 학습하도록 명시적으로 설계한다.

학습되길 원하는 목표 함수를 $H (x)$ 라고 할 때, 비선형 레이어들이

F (x) : = H (x) - x

라는 또 다른 함수를 학습하도록 한다.

즉 네트워크가 직접 $H (x)$ 를 학습하는 것이 아니라, 입력 $x$ 에서 얼마나 변화해야 하는지, 즉 변화량을 의미하는 $F (x)$ 만을 학습하게 하는 것이다. 이를 이항하면 목표 함수는

H (x) = F (x) + x

로 다시 표현된다.

저자는 참조 없이 처음부터 학습해야 하는 기존의 $H (x)$ 보다, Residual 함수 $F (x)$ 를 최적화하는 것이 더 쉽다고 주장한다. 특히 최적의 $H (x)$ 가 항등 함수인 경우, 여러 비선형 레이어를 통해 $H (x) = x$ 를 학습하는 것보다 $F (x) = 0$ 을 만드는 것이 훨씬 쉽기 때문이다.

즉, Plain Network에서는 모델이 항등함수를 스스로 만들어야 하므로 최적화가 어렵지만, ResNet에서는 $F (x)$ 가 0이 되기만 하면 되므로 최적화가 훨씬 수월해진다는 것이 핵심 주장이다.

저자는 Residual block이

y = F (x) + x

형태를 가질 때, 입력 $x$ 가 조금 변하더라도 출력은 항상 입력 변화가 그대로 전달되는 경로를 포함하게 되므로 여러 residual block을 깊게 쌓더라도 기울기가 레이어를 지나며 급격히 줄어들거나 커지지 않고 안정적으로 전달되며 결과적으로 깊은 네트워크에서도 기울기 소실이나 폭발을 완화할 수 있다고 주장한다.

이러한 $F (x) + x$ 구조는 shortcut connection을 가진 forward 신경망으로 구현할 수 있으며, 곱셈이 아닌 덧셈 연산만을 사용하므로 추가적인 파라미터나 계산 복잡도를 요구하지 않는다. 전체 네트워크는 기존과 동일하게 SGD와 역전파를 통해 end-to-end로 학습할 수 있다.

저자는 CIFAR-10 데이터셋에서도 plain network에서 degradation 현상이 관측됨을 보이고, 이를 residual network로 해결함으로써 제안한 방법이 특정 데이터셋에 국한된 현상이 아니라 깊은 네트워크의 최적화 문제 전반에 적용 가능한 일반적인 방법임을 주장한다.

또한 기존 네트워크보다 훨씬 더 깊은 구조에서도 모델을 안정적으로 학습시켰으며, 1000개 이상의 레이어를 가진 네트워크까지 탐구함으로써 제안한 구조가 깊이에 따른 최적화 한계를 실질적으로 극복함을 보였다.

Residual Representations

VLAD

이미지 분류/검색 문제에서는 이미지의 수천개의 로컬 특징들을 하나의 고정길이 벡터로 요약하여야 하는데, 고전적인 BoVW 기법에서는 “어떤 패턴이 몇번 나왔나” 만 카운팅한다. 곧 평균적인 정보만 남고 세부 구조는 소실되는데, VLAD는 각 로컬 특징 $x$ 에 대해 가장 가까운 대표 벡터 $c$ 를 찾아 residual $(x - c)$ 을 누적한다. 즉 특징 자체가 아니라 기준점에서의 잔차를 표현으로 사용한다.

residual 은 평균이 0 근처이며 분포가 단순하여 shallow 구조에서도 높은 성능을 냈다. 즉 VLAD 는 네트워크가 깊지 않아도 residual 표현 만으로 높은 성능을 기록했으며, 이는 residual learning 으로 문제를 해결한 연구 중 하나이다.

Multigrid

편미분방정식을 직접 풀면 변수가 많고 수렴이 매우 느리다. multigrid 는 해를 한번에 정확하게 구하는 것이 아닌 Coarse grid 에서 근사값을 찾고, 그 결과를 finer grid 로 가져와 남은 오차(residual) 을 보정한다.

solution = coarse solution + residual correction

즉, 전채 해가 아니라 이미 있는 근사에서 residual 을 품으로써 수렴 속도가 빨라진다.

저자는 VLAD와 Multigrid에서 residual representation을 도입함으로써 문제를 직접 해결하는 대신 기준 해로부터의 차이만을 다루도록 재정식화하면 최적화가 단순해지고 수렴이 빨라진다는 점을 보여준다.

이러한 관찰을 바탕으로, 신경망에서도 전체 함수를 직접 학습하는 대신 입력에 대한 residual function을 학습하도록 문제를 재정식화한 것이 논문의 residual learning이며, 이는 구조적 트릭이 아니라 정당한 최적화 전략임을 주장한다.

Shortcuts Connections

Shortcut used researches

shortcut / skip connection 개념은 ResNet 논문의 저자가 처음 주장한 기법이 아니고 아이디어 자체는 오래되었다. shortcut 을 사용한 대표적인 사례 중 하나는 초기 MLP 에서 입력을 그대로 출력 그대로 보내는 선형 경로는 추가하는 것이었다. 하지만 이는 residual learning 의 목적은 아니었고, 학습 초기에 출력이 완전히 엉뚱해지는 것을 방지하기 위함이었다.

또 다른 사례는 auxiliary classifiers 로, deep network 에서 기울기 소실을 막기 위해 도입되었다. 중간 레이어에 보조 분류기를 추가하므로써 loss 를 중간에서 직접 걸어준다. 즉 gradient 를 강제로 중간까지 끌어오는 아이디어이다. 하지만 이는 학습 과정에서만 gradient를 보조적으로 공급하는 장치이며, inference 시의 함수 형태에는 아무런 제약도 가하지 않기 때문에 학습 타이밍의 테크닉에 그친다.

Centering layer responses 는 BN 과 유사한 방법론으로, activation 의 평균을 0 근처로 유지해 gradient 의 스케일을 안정화한다. 하지만 BN과 마찬가지로 통계적 안정화가 목적이기 때문에, 네트워크가 근사해야 할 함수 공간 자체는 변하지 않았으며, 단지 activation과 gradient의 분포만을 안정화하는 역할에 그친다.

Inception network 에서도 비슷한 개념이 사용되었는데, 이전 레이어의 출력에서 1x1 conv, 3x3 conv, 5x5 conv, 3x3 max pool 의 누적 값을 연산에서 사용하는데, 이때 3x3 max pool 을 identity mapping 과 유사한 값으로 볼 수 있다. 하지만 3개 커널의 conv 결과와 pool 의 결과를 concatenation 한다는 점에서 완전한 shortcut 으로 볼 수 없고, pool 이 기본 해가 아니기 때문에 residual 만 학습한다는 제약은 없다.

Highway Network

highway network 는 깊은 네트워크에서의 vanishing gradient 문제를 해결하기 위해 연구된 주제로, ResNet 의 등장 배경과 가장 유사하다. 기본적인 접근은 vanishing gradient 문제를 정보 흐름을 제어하는 gate 로 해결하는 방식이다.

\begin{matrix} T (x) = σ (W_{T} x + b_{T}) \\ y = T (x) H (x) + (1 - T (x)) x \end{matrix}

$W_{T}, b_{T}$ 는 추가되는 파라미터로, 레이어를 항등함수로 사용할건지 (즉, 레이어를 건너뛸지) 혹은 레이어에서 값을 transfrom (레이어를 사용할지) 할건지 결정하게 된다.

$σ (x) \in (0, 1)$ 이고, $T (x) \approx 1$ 이면 레이어를 사용, $T (x) \approx 0$ 이면 레이어를 건너뛰게 된다. 즉, 필요한 레이어인지 아닌지 모델이 판단하게 하여 gradient 의 흐름을 유지한다.

하지만 ResNet 논문의 저자는 $T (x)$ 가 학습되는 값이라는 점에서 Highway Network는 항상 residual function을 학습하도록 구조적으로 보장하지 못한다고 지적한다. 또한 gating을 위한 추가 파라미터가 레이어마다 도입되므로, 네트워크 깊이가 증가할수록 파라미터 수와 연산량, 그리고 최적화 복잡도가 함께 증가한다.

Deep Residual Learning

Residual Learning

깊은 비선형 네트워크가 복잡한 함수 $H (x)$ 를 근사할 수 있다면, $H (x) - x$ 도 근사할 수 있어야한다. 즉 표현력의 관점에서 두 함수는 동일한 표현력 안에서 근사될 수 있다.

Introduce 에서 언급되었 듯 Residual Learning 은 레이어가 출력 전체를 만들지 않고, 입력에서 얼마나 바뀌는 지만 학습하게 하고, ( $y = x + F (x)$ ) 레이어가 항등함수로 학습되어야 한다면 여러 비선형 레이어가 정교하게 상쇄되어야 하는 것에 비해 $F (x)$ 의 가중치가 0이 되면 되므로 난이도가 훨씬 쉽다.

이러한 재정식화는 최적 함수가 항등함수 자체일 필요는 없지만, 항등함수에 가까운 경우 특히 효과적이다. 만약 최적 함수가 plain network의 기준점인 zero mapping보다 항등함수 $(H (x) \approx x)$ 에 가깝다면, Residual Learning 이 최적화에 유리할 것 이다. 저자는 이후의 실험을 통해 실제로 학습된 residual function의 출력이 작다는 점을 보이며, 많은 경우 최적 함수가 identity mapping 근처에 위치함을 경험적으로 확인한다.

즉, 저자는 표현력은 동일하더라도 학습해야 할 함수를 어떻게 정의하느냐에 따라 최적화 난이도가 달라질 수 있으며, 특히 항등함수를 기준점으로 삼는 residual learning이 깊은 네트워크의 최적화를 크게 용이하게 만든다고 주장한다.

Identity Mapping by Shortcuts

Residual 은 네트워크 전체에 한번만 사용되는 것이 아니며 여러 레이어를 묶은 블록 단위로 반복 적용된다. 즉 $H (x)$ 는 몇개의 레이어가 학습해야할 목표 함수이며, 여기서 말하는 레이어는 전체 네트워크가 아니라 일부 블록을 의미한다.

y = F (x, {W_{i}}) + x

에서, $x$ 는 블록의 입력, $y$ 는 블록의 출력, $F (x, {W_{i}})$ 은 모델이 학습해야할 residual mapping, $+ x$ 은 항상 통과되는 identity shortcut 을 의미한다.

$F$ 는 보통 2~3개의 레이어로 이루어진 작은 서브 네트워크이며, 레이어가 2개라고 가정하면:

\begin{matrix} σ (x) = max (0, x) \\ F = W_{2} σ (W_{1} x) \\ y = σ (F (x) + x) \end{matrix}

이다. $F + x$ 이후 한번의 활성함수를 거친 $σ (F + x)$ 가 블럭의 출력이 된다. (second nonlinearity after the addition**)**

이 식의 shortcut connection 은 계산 복잡도를 올리지 않는다. 이는 실용적일 뿐만 아니라 Plain Network 와 Residual Network 를 비교하는 데 있어서도 중요하다. 무시할 수 있을 정도의 원소별 덧셈을 제외하고, 파라미터 수, 깊이, 너비, 계산 비용이 동일한 공정한 비교가 가능해진다.

$F + x$ 가 원소별 덧셈이기 때문에 두 값의 차원은 동일해야 한다. 만약 그렇지 않을 경우 선형 투영 $W_{s}$ 를 수행하여 차원을 맞출 수 있다.

y = σ (F (x, {W_{i}}) + W_{s} x)

실험을 통해 $F$ 와 $x$ 의 차원을 같게 만들어도 충분히 효과적임이 확인되었으므로 $W_{s}$ 는 차원을 맞춰야 하는 경우에만 사용한다. residual 함수 $F$ 의 형태는 유연하다. 본 논문의 실험에서는 두 개 또는 세 개의 층을 갖는 함수 $F$ 만을 사용하지만 그보다 많은 층을 사용하는 것도 가능하다.

하지만 만약 레이어 하나로만 구성하는 경우 Plain Network 와 유사해진다. $(y = σ (W_{1} x) + x)$ 이 경우 특별한 이점을 관측할 수 없다.

위 식들은 표기의 단순함을 위해 FC 층을 기준으로 설명되었지만 Convolution 층에도 그대로 적용될 수 있다. $F (x, {W_{i}})$ 는 여러개의 Convolution 층으로 나타낼 수 있고, 원소별 덧셈 $(+ x)$ 은 두 개의 feature map 에 대해 채널별로 수행된다.

VGG, Plain Network and Residual Network

저자는 여러 종류의 plain 네트워크와 residual 네트워크를 실험했고, 깊어질수록 plain 네트워크는 training error 자체가 증가하는 반면 residual 네트워크는 안정적으로 최적화된다는 일관된 현상을 관찰했다.

이러한 차이가 다른 요인 때문이라는 반박을 차단하기 위해, “Residual Network는 깊은 네트워크에서도 학습에 유리하다”는 주장을 검증하기에 충분히 강한 Plain Network를 의도적으로 설계하였다.

VGG 의 철학을 따른다. → 이미 검증된 깊이의 CNN 구조를 유지한다.
모든 Conv 레이어에서 커널 차원을 3x3 로 고정한다. → 레이어의 깊이만이 핵심 변수로 남도록 한다.
feature map 해상도가 내려가면 채널 수를 올린다. → 레이어 간 연산양(FLOPs)을 일관되도록 유지한다.
다운샘플링은 pooling 대신 stride conv 로 한다 → 사람이 네트워크의 구조에 개입하지 않는다.

즉 저자는 ResNet 의 효용을 regularization도, 파라미터 수도, 연산량도 아니라 최적화 가능한 구조 때문임을 증명하려고 한다.

구성한 Plain Network 에 Shortcut 을 추가한 Residual Network 도 구성한다. 이 때 Block 의 입력과 출력의 채널 수가 다를 때 두가지 옵션을 테스트한다.

Option A - 채널 증가 시 shortcut은 identity를 유지하고, 부족한 채널만 0으로 padding

$x \to [x, 0]$
Option B - 차원을 맞추기 위해 1x1 conv 를 통해 선형 투영을 수행한다.

$x \to W_{s}^{1 \times 1} (x)$

두 옵션 모두, shortcut 이 해상도를 건너뛰어야 할 때는 stride of 2 로 구현한다.

즉, 동일한 해상도 간 연결:

\begin{matrix} x \in ℝ^{H \times W \times C} \\ F (x) \in ℝ^{H \times W \times C} \\ y = F (x) + x \end{matrix}

해상도가 바뀌는 지점 ( $\frac{1}{2}$ ):

\begin{matrix} x \in ℝ^{H \times W \times C} \\ F (x) \in ℝ^{\frac{H}{2} \times \frac{W}{2} \times 2 C} \\ \tilde{x} = {\begin{matrix} [{stride}_{2} (x), 0] & (Option A) \\ W_{s}^{1 \times 1, stride = 2} (x) & (Option B) \end{matrix} \\ \tilde{x} \in ℝ^{\frac{H}{2} \times \frac{W}{2} \times 2 C} \\ y = F (x) + \tilde{x} \end{matrix}

Implementation Details

저자는 구성한 네트워크를 ImageNet 으로 실험하기 위해 다음과 같이 셋업하였다:

| Data Augmentation | 1. Scale Augmentation

이미지의 짧은 변을 256 ~ 480 사이에서 랜덤하게 resize

Random crop + flip

resized 이미지에서 224x224 를 랜덤 crop 하고 mean subtraction

Color Augmentation

항목	세부 내용
Color Augmentation	AlexNet 계열에서 도입된 색상 노이즈 적용
Batch Normalization	각 convolution 뒤, activation 앞에 BN 적용
Weight Initialization	ReLU 친화적 He initialization 사용
Optimization & Batch Size	mini-batch 256의 SGD 사용, learning rate 0.1에서 시작, 성능 정체 시 1/10로 감소, momentum 0.9 적용
Training Length	최대 600k iteration까지 학습
Regularization	weight decay 1e-4

10-crop testing: CNN 기반 이미지 분류에서 테스트 시점에 입력을 여러 번 변형해서 추론하고, 그 결과를 평균(또는 투표)하는 기법

Experiments

ImageNet Classification

Plain Networks

저자는 residual 연결이 없는 plain 네트워크에서 깊이만 증가시켰을 때 어떤 현상이 발생하는지를 확인하기 위해, 구조는 거의 동일하고 깊이만 다른 18-layer와 34-layer plain 네트워크를 비교하였다. 실험 결과, 더 깊은 34-layer plain 네트워크가 오히려 18-layer 네트워크보다 validation error가 더 높게 나타났다. 이 차이가 과적합 때문인지 확인하기 위해 학습 과정 전반의 training/validation error를 분석한 결과, 34-layer 모델은 학습 초기부터 종료까지 training error 자체가 더 높게 유지되는 degradation 문제를 보였다.

저자는 깊은 plain 네트워크에서 나타나는 최적화 어려움이 단순히 gradient vanishing 때문이라고 보기는 어렵다고 주장한다. 네트워크는 모두 Batch Normalization을 사용해 학습되었으며, BN은 순전파 과정에서 활성값의 분산을 안정적으로 유지해 신호가 사라지는 현상을 완화한다. 더 나아가 저자는 BN을 사용한 상태에서 역전파되는 gradient의 크기를 실제로 관측해 보았고, 그 값들이 정상적인 범위에 있음을 확인하였다.

따라서 gradient가 소실되어 학습이 실패하는 상황은 아니라는 결론에 이른다. 실제로 34-layer plain 네트워크는 비록 얕은 모델보다 성능이 낮지만 완전히 학습이 붕괴된 것은 아니며, 이는 최적화가 어느 정도는 작동하고 있음을 보여준다. 저자는 대신 깊은 plain 네트워크가 깊이에 따라 수렴 속도가 급격히 느려지는 문제를 겪고 있을 가능성을 제기하며, 이러한 최적화 난이도의 근본 원인은 향후 연구 과제로 남긴다.

Residual Network

저자는 이제 residual network 를 평가한다. 기본 아키텍쳐는 이미 언급하였듯 plain 네트워크와 동일하며, shortcut 의 사용 여부만 다르다. 해상도나 채널 수가 증가하는 지점에서는 Option A 를 사용하여 테스트한다. Option A 를 사용할 경우, plain network 와 residual network 의 파라미터 수는 완벽히 동일하게 된다. (Option B 사용 시 $W_{s}$ 가 추가됨)

실험 결과는 plain 네트워크와는 달리 상황이 완전히 뒤집혀, 34-layer ResNet이 18-layer ResNet보다 더 좋은 성능을 보인다(약 2.8% 향상). 둘째이자 더 중요한 점은 34-layer ResNet이 training error 자체가 크게 낮아졌고, 그 성능이 validation 데이터에도 잘 일반화된다는 것이다. 이는 앞서 plain 네트워크에서 관찰되었던 degradation 문제가 residual learning을 통해 효과적으로 해결되었음을 의미한다.

34-layer 기준에서 residual 구조를 적용한 ResNet은 plain 네트워크보다 training error를 효과적으로 낮추며, 그 결과 top-1 error를 크게 개선한다. 이는 residual learning이 깊은 네트워크에서도 최적화를 가능하게 만들어 깊이 증가가 실제 성능 향상으로 이어질 수 있음을 보여준다. 반면 18-layer처럼 상대적으로 얕은 네트워크에서는 plain과 residual의 최종 정확도 차이는 거의 없지만, ResNet은 학습 초반 수렴 속도를 개선해 최적화를 더 빠르고 안정적으로 만드는 역할을 한다.

Identity vs Projection Shortcuts

저자는 identity shortcut만으로도 깊은 네트워크의 학습이 충분히 개선된다는 점을 보인 뒤, projection shortcut의 필요성을 추가로 검증한다. zero-padding 기반 identity shortcut(Option A), 해상도 변경 지점에서만 projection을 쓰는 방식(Option B), 모든 shortcut을 projection으로 사용하는 방식(Option C)을 비교한 결과, 세 옵션 모두 plain 네트워크보다 크게 우수했으며, 성능 차이는 매우 작았다. B와 C가 A보다 약간 나은 성능을 보이긴 했지만, 이는 zero-padding된 채널이 residual 학습을 하지 못하는 점이나 projection으로 인한 추가 파라미터 효과로 설명 가능하다.

저자는 메모리 사용량과 연산량, 모델 크기를 줄이기 위해 이후의 실험에서는 Option C를 사용하지 않는다. 특히 identity shortcut은 이후에 도입될 bottleneck 구조에서도 모델 복잡도를 증가시키지 않는다는 점에서 중요하다.

Bottleneck Architectures

더 깊은 ResNet을 효율적으로 학습하기 위해 저자는 bottleneck 구조를 도입했으며, 이는 1×1–3×3–1×1 convolution으로 구성되어 비싼 3×3 연산을 저차원 공간에서만 수행하도록 만든 설계다. 이 구조는 레이어 수를 늘리면서도 연산량을 기존 설계와 비슷하게 유지할 수 있게 해준다. 이러한 bottleneck 구조에서는 shortcut이 고차원 feature에 직접 연결되므로, projection shortcut을 사용하면 연산량과 파라미터 수가 크게 증가한다. 따라서 파라미터와 연산 비용이 없는 identity shortcut (Option A) 이 bottleneck 구조에서 특히 중요하며, 이를 통해 매우 깊으면서도 효율적인 ResNet 모델을 구성할 수 있다.

또한 bottleneck 구조를 도입해 50, 101, 152-layer ResNet을 구성한 결과, 네트워크 깊이를 크게 늘렸음에도 연산량은 VGG보다 낮은 수준으로 유지되었고, degradation 문제 없이 깊이 증가가 곧바로 정확도 향상으로 이어졌다.

ResNet은 단일 모델만으로도 기존 최고 성능의 앙상블 모델을 뛰어넘는 결과를 달성했으며, 특히 152-layer ResNet은 단일 모델 기준 top-5 error 4.49%로 당시 state-of-the-art를 갱신했다. 서로 다른 깊이의 ResNet들을 앙상블로 결합하면 top-5 error를 3.57%까지 낮출 수 있었고, 이 결과로 ResNet은 ILSVRC 2015 이미지 분류 대회에서 우승을 차지했다.

CIFAR-10

저자는 CIFAR-10 데이터셋에서 추가 실험을 수행하며, 이 실험의 목적은 최고 성능을 달성하는 것이 아니라 매우 깊은 네트워크가 어떻게 학습되는지를 관찰하는 데 있다. 이를 위해 의도적으로 단순한 plain 및 residual 아키텍처를 사용하고, 입력은 32×32 이미지에 대해 mean subtraction 만 수행한다. 네트워크는 3x3 convolution을 기본으로 하여 feature map 크기 32, 16, 8의 세 단계로 구성되며, 각 단계마다 $2 n$ 개의 레이어를 쌓아 전체 깊이를 $6 n + 2$ 로 조절한다. 다운샘플링은 stride 2 convolution으로 수행되고, 마지막에는 global average pooling과 10-class 분류기를 둔다. 이 설정을 통해 저자는 구조적 트릭의 영향을 최소화한 상태에서, 네트워크 깊이가 증가할 때 plain 네트워크와 residual 네트워크의 추이를 직접 비교한다.

네트워크 깊이는 $n = 3,5,7,9$ 로 조절해 20층부터 56층까지 확장한다. 실험 결과, plain 네트워크는 깊이가 증가할수록 training error가 오히려 커지는 degradation 현상을 보였으며, 이는 ImageNet이나 MNIST에서도 관찰된 것과 동일한 근본적인 최적화 문제임을 시사한다. 반면 ResNet은 깊이가 깊어질수록 이러한 최적화 어려움을 극복하고, 일관된 정확도 향상을 보인다. 즉, CIFAR-10에서도 residual 구조는 깊은 네트워크의 학습을 가능하게 하며, 깊이 증가의 이점을 안정적으로 실현시킨다는 점이 확인된다.

저자는 $n = 18$ 까지 확장하여 테스트한다. 아주 깊은 110-layer 네트워크에서도 residual 구조는 간단한 warm-up만으로 안정적인 학습을 가능하게 하며, 적은 파라미터로도 최고 수준의 성능을 달성한다.

Analysis of Layer Response

저자는 각 3x3 convolution 레이어의 출력값 std 을 분석한다. 여기서 말하는 레이어 응답은 BN 이후, ReLU나 shortcut 덧셈 이전의 값으로, ResNet에서는 곧 residual function $F (x)$ 의 크기를 의미한다.

레이어 응답의 std 라고 하면 레이어 유닛들의 응답값에 대한 분포를 의미하지만:

σ = \sqrt{\frac{1}{N} \sum_{i = 1}^{N} {(F {(x)}_{i} - μ)}^{2}}

에서, BN에 의해 $μ \approx 0$ 이므로, $σ \approx \sqrt{\frac{1}{N} \sum_{i = 1}^{N} F {(x)}_{i}^{2}}$ 이 되므로 레이어 응답의 strength 로 볼 수도 있다.

분석 결과, ResNet의 레이어 응답은 대응되는 plain 네트워크보다 전반적으로 더 작은 값을 가지며, 이는 residual 함수가 원래의 non-residual function 에 비해 0에 더 가까운 값을 학습한다는 저자의 가정을 뒷받침한다. 또한 ResNet-20, 56, 110을 비교해 보면, 네트워크가 더 깊어질수록 각 레이어의 응답 크기가 더 작아지는 경향이 관찰된다. 이는 ResNet이 깊어질수록 개별 레이어가 입력 신호를 크게 변형하기보다는, 아주 작은 수정만을 점진적으로 누적하는 방식으로 동작한다는 것을 의미한다.

즉, 저자가 의도한 최적화 경로로 실제로 SGD가 움직였다.

Over 1000 ResNet Layers

저자는 CIFAR-10에서 residual 구조의 한계를 시험하기 위해 $n = 200$ , 즉 1202-layer에 달하는 초심층 ResNet까지 실험을 확장한다. 이 모델은 학습 과정에서 최적화 문제를 전혀 보이지 않으며, training error를 0.1% 이하로 낮출 수 있을 정도로 안정적으로 수렴한다. 이는 residual 구조가 깊이가 1000층을 넘어가더라도 최적화 자체에는 본질적인 한계가 없음을 보여준다. 다만 테스트 성능에서는 1202-layer 모델이 110-layer 모델보다 오히려 나쁜 결과를 보이는데, 두 모델의 training error가 비슷하다는 점에서 이를 과적합 문제로 해석한다.

10x Faster C++ String Split

2025-08-09T00:00:00.000Z

지난 포스트들에서 SIMD 인스트럭션과 SIMD 를 string 에 활용하는 법에 대해 포스팅을 했었는데요, 오늘은 @ashvardanian의 splitting-strings-cpp 포스팅을 리뷰하면서 split 함수를 구현해보려고 합니다.

특히 저의 경우 Python 에서 제일 많이 사용하는 함수 중 하나가 split 입니다.

이 포스트에서는 문자열을 나누는 여러 방법을 살펴보고, 그 중 가장 빠른 방법과 그 구현, 장단점을 살펴보려고 합니다.

Problem Definition

문제를 정의 해봅시다. split 은 바이트 시퀀스와 delimiter 문자 집합이 주어졌을 때, 이 delimiter 를 기준으로 문자열을 나누는 함수입니다.

일반적으로 공백을 기준으로 문자열을 나누죠. C언어의 로케일에서는 "\f", "\r", "\n", "\t", "\v", " " 의 6개 문자가 공백 문자로 정의되어 있습니다.

보통 " " 하나만을 delimiter 로 사용하는 경우가 많습니다. 하지만 파싱을 하다 보면 XML 의 <, >, JSON 의 {, }, [, ] 등의 2개 이상 문자들을 delimiter 로 사용해야 하는 경우가 있습니다.

Solution 1: using `std::string_view::find_first_of`

template <typename callback_type_>
void split(std::string_view str, std::string_view delimiters,
           callback_type_ && callback) {
    std::size_t pos = 0;
    while (pos < str.size()) {
        auto const next_pos = str.find_first_of(delimiters, pos);
        callback(str.substr(pos, next_pos - pos));
        pos = next_pos == std::string_view::npos ? str.size()
                                                 : next_pos + 1;
    }
}

std::string_view::find_first_of 는 문자열에서 주어진 문자 집합에 포함된 문자가 처음으로 나타나는 위치를 찾아줍니다.

내부적으로 순차 탐색을 하는데, delimiters 의 길이가 늘어나면 성능이 확 떨어지죠.

굳이 시간 복잡도로 보면 O(n * len(delimiters)) 라고 볼 수 있습니다.

Solution 2: using `std::find_if` and lambda

만약 delimiter 를 판단하는 커스텀 람다 함수를 전달하면, O(n) 으로 해결할 수 있겠습니다.

template <typename callback_type_, typename predicate_type_>
void split_with_predicate(std::string_view str, predicate_type_ && is_delimiter, callback_type_ && callback) {
    std::size_t pos = 0;
    while (pos < str.size()) {
        auto const next_pos = std::find_if(str.begin() + pos, str.end(), is_delimiter) - str.begin();
        callback(str.substr(pos, next_pos - pos));
        pos = next_pos == str.size() ? str.size() : next_pos + 1;
    }
}

Benchmark: solution 1 vs solution 2

inline bool is_delimiter(char c) {
    return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f' || c == '\v';
}

static void BM_Split(benchmark::State& state) {
    std::string text = "This is a sample text to be split using delimiters.";
    for (auto _ : state) {
        split(text, " \t\n\r\f\v", [](std::string_view) {
            benchmark::DoNotOptimize(1);
        });
    }
}

static void BM_SplitWithPredicate(benchmark::State& state) {
    std::string text = "This is a sample text to be split using delimiters.";
    for (auto _ : state) {
        split_with_predicate(text, is_delimiter, [](std::string_view) {
            benchmark::DoNotOptimize(1);
        });

    }
}

BENCHMARK(BM_Split);
BENCHMARK(BM_SplitWithPredicate);

BENCHMARK_MAIN();

-O0 Benchmark	Time	CPU	Iterations
BM_Split	1678 ns	1678 ns	416055
BM_SplitWithPredicate	569 ns	568 ns	1226564

-O3 Benchmark	Time	CPU	Iterations
BM_Split	41.8 ns	41.8 ns	16705647
BM_SplitWithPredicate	37.2 ns	37.2 ns	18774709

컴파일러 최적화 옵션에 따라 성능 차이가 있지만, BM_SplitWithPredicate 가 BM_Split 보다 빠르다는 것을 확인할 수 있습니다.

Solution 3: using character bit-set

결국 문자열을 나누는 로직의 첫번쨰 과정은 문자열 내부의 delimiter 위치를 찾는 것이고, 문제를 더 잘게 쪼개면 문자열 내부의 문자가 delimiter 인지 아닌지를 판단하는 것입니다.

문자가 delimiter 인지 아닌지를 판단하는 것을 비트 연산으로 접근해보곘습니다.

char set[32] = {0};

const char* delimiters = " \t\n\r\f\v";

for (char c : std::string_view(delimiters)) {
    set[c >> 3] |= 1 << (c & 7);
}

bool is_delimiter(char c) {
    return set[c >> 3] & (1 << (c & 7));
}

set 은 문자 집합을 비트 플래그로 표현한 집합입니다. 8비트 자료형인 char 가 32개 있으니, 총 256비트의 비트 플래그를 사용할 수 있습니다.

즉 만약 A 가 delimiter 라면, 정수로 해석한 값은 65이므로 set 의 65 >> 3 인덱스의 65 & 7 번째 비트가 1이 됩니다.

set[0]  = 0b00000000;
set[1]  = 0b00000000;
...
set[8]  = 0b00000010; // 'A' 의 비트 플래그가 켜짐
...
set[31] = 0b00000000;

is_delimiter 함수는 문자를 정수로 해석한 값을 8로 나눈(c / 8 == c >> 3) 몫을 인덱스로 사용합니다. 그리고 나머지(c & 7 == c % 8) 를 비트 마스크로 사용합니다.

여기서 모듈러연산이 비트 연산으로 대체되는데, c % n 에서 n 이 2의 거듭제곱이라면 c & (n - 1) 로 대체할 수 있습니다.

두 연산이 본질적으로 “c의 하위 k 비트를 분리해내는” 동일한 작업을 수행하기 때문입니다.

n 이 2의 거듭제곱 (2^k) 이라면, 2진수로 표현했을 때 단 하나의 비트만 1이고, n - 1 의 경우 하위 k 개 비트가 1이 됩니다.

0b10000000 -> 2^7
0b01111111 -> 2^7 - 1

c & 0b01111111 == c & 0b11111111

즉 k 번째 비트까지 마스킹하는 것은 본질적으로 c % 2^k 와 동일합니다.

다시 문자열 비교로 돌아와서, set 은 메모리 지역성이 좋은 배열이므로, 캐시 히트율이 높을 것이고 정수 연산이 아닌 비트 연산을 사용하므로 더 빠를 것입니다. L1 캐시에 상주할 가능성이 매우 높죠.

이제 == 연산자를 반복적으로 사용하는 이전의 방법 대신 방금 구현한 비트연산 기반 함수를 사용하여 벤치마크 해보겠습니다.

inline bool is_delimiter(char c) {
    return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f' || c == '\v';
}

static void BM_SplitWithPredicate(benchmark::State& state) {
    std::string text = "This is a sample text to be split using delimiters.";
    for (auto _ : state) {
        split_with_predicate(text, is_delimiter, [](std::string_view) {
            benchmark::DoNotOptimize(1);
        });

    }
}

static void BM_SplitWithPredicate_CharSet(benchmark::State& state) {
    char set[32] = {0};
    const char* delimiters = " \t\n\r\f\v";

    for (char c : std::string_view(delimiters)) {
        set[c >> 3] |= 1 << (c & 7);
    }

    auto is_delimiter_char_set = [&](char c) {
        return set[c >> 3] & (1 << (c & 7));
    };

    std::string text = "This is a sample text to be split using delimiters.";
    for (auto _ : state) {
        split_with_predicate(text, is_delimiter_char_set, [](std::string_view) {
            benchmark::DoNotOptimize(1);
        });
    }

}

Benchmark	Time	CPU	Iterations
BM_SplitWithPredicate	44.8 ns	44.8 ns	15622768
BM_SplitWithPredicate_CharSet	32.0 ns	32.0 ns	21921995

확실히 빠른 것을 알 수 있습니다. 28% 정도 빠르네요.

Solution 4: using SIMD

지금까지 solution 3 의 아이디어에 SIMD 를 적용해보겠습니다.

비트 마스크 기반 비교 로직을 동시에 여러 문자에 대해 적용하면 더 빨라지겠죠? ARM NEON 기반으로 구현해보겠습니다.

이 사진처럼 원리 자체는 똑같지만, 16개의 문자를 한번에 처리한다는 것이 포인트입니다.

16개씩 쭉 진행하다가 자투리 부분은 스칼라로 처리하는 구현입니다.

#include <arm_neon.h>
#include <string_view>

typedef union u128_vec_t {
  uint8x16_t u8x16;
  uint16x8_t u16x8;
  uint32x4_t u32x4;
  uint64x2_t u64x2;
  std::uint64_t u64s[2];
  std::uint32_t u32s[4];
  std::uint16_t u16s[8];
  std::uint8_t u8s[16];
} u128_vec_t;

std::uint64_t _find_charset_neon_register(u128_vec_t haystack,
                                          uint8x16_t set_top,
                                          uint8x16_t set_bottom) {
  /* haystack 은 "ABCDEFGHIJKLMNOP" 라고 가정 */

  uint8x16_t byte_index_vec = vshrq_n_u8(haystack.u8x16, 3);
  /* c >> 3 을 8비트 데이터 16개에 대해 동시에 수행
     즉, 각 바이트의 인덱스가 계산된다.
     - byte_index_vec 는 [65 >> 3, 66 >> 3, 67 >> 3, ... ] 이 된다. */

  uint8x16_t byte_mask_vec =
      vshlq_u8(vdupq_n_u8(1),
               vreinterpretq_s8_u8(vandq_u8(haystack.u8x16, vdupq_n_u8(7))));
  /* 1 << (c & 7) 을 8비트 데이터 16개에 대해 동시에 수행 */

  uint8x16_t matches_top_vec = vqtbl1q_u8(set_top, byte_index_vec);
  /* set_top 에서 바이트 단위 인덱싱
     - matches_top_vec 는
       [set_top[65 >> 3], set_top[66 >> 3], set_top[67 >> 3], ... ] 이 된다.
     - 즉, byte_index_vec 에 대응하는 set_top 의 값을 가져온다. */

  uint8x16_t matches_bottom_vec =
      vqtbl1q_u8(set_bottom, vsubq_u8(byte_index_vec, vdupq_n_u8(16)));
  /* - set_bottom 에 대해서도 바이트 단위 인덱싱 수행
     - 16을 빼는 이유는 set_bottom 의 바이트 인덱스가 0부터 시작하기 때문이다.
     - 똑같이 matches_bottom_vec 는
       [set_bottom[(65 >> 3) - 16], set_bottom[(66 >> 3) - 16], ... ] 이 된다.
     - vqtbl1q_u8 은 범위를 넘어가면 0을 반환한다. (65 >> 3) - 16 은 범위를
       넘어가므로 (underflow), matches_bottom_vec 는 모두 0이 된다. */

  uint8x16_t matches_vec = vorrq_u8(matches_top_vec, matches_bottom_vec);
  /* set_top 과 set_bottom 의 결과를 합친다. */

  matches_vec = vtstq_u8(matches_vec, byte_mask_vec);
  /* matches_vec 와 byte_mask_vec 를 비교한다. */

  return vget_lane_u64(vreinterpret_u64_u8(
                           vshrn_n_u16(vreinterpretq_u16_u8(matches_vec), 4)),
                       0) &
         0x8888888888888888ull;
  /* 1. vreinterpretq_u16_u8 로 matches_vec 를 16비트 데이터 8개로 재해석한다.
     2. 비트를 오른쪽으로 4비트 시프트 후, 하위 8비트만 취한다.
        (예시: static_cast<uint8_t>(n >> 4))
     3. vreinterpret_u64_u8 로 64비트 데이터 1개로 재해석한다.
     4. vget_lane_u64 으로 그 값을 스칼라로 가져온다.
     5. 마스킹 연산으로, 4비트 마다의 최상위 비트만 남긴다. */
}

template <typename callback_type_>
void split_neon(std::string_view str, std::string_view delimiters,
                callback_type_ &&callback) {
  std::uint8_t charset[32] = {0};
  for (char c : delimiters) {
    charset[c >> 3] |= 1 << (c & 7);
  }
  const uint8x16_t set_top_vec_u8x16 = vld1q_u8(charset);
  const uint8x16_t set_bottom_vec_u8x16 = vld1q_u8(charset + 16);

  std::uint64_t matches = 0;
  std::uint64_t bit_pos = 0;
  std::uint64_t char_pos = 0;
  u128_vec_t haystack_vec;

  const std::size_t length = str.length();
  std::size_t last_pos = 0;

  /* 16바이트 청크 단위로 처리한다. */
  for (std::size_t i = 0; i < length; i += 16) {
    haystack_vec.u8x16 =
        vld1q_u8(reinterpret_cast<const unsigned char *>(str.data() + i));

    matches = _find_charset_neon_register(haystack_vec, set_top_vec_u8x16,
                                          set_bottom_vec_u8x16);

    while (matches) {
      bit_pos = __builtin_ctzll(matches);
      char_pos = i + bit_pos / 4;
      callback(str.substr(last_pos, char_pos - last_pos));
      last_pos = char_pos + 1;
      matches &= ~(1ull << bit_pos);
    }
  }

  /* 16바이트 청크 단위로 처리하지 못한 나머지 부분은 스칼라로 처리한다. */
  if (length & 15) {
    std::size_t pos = length - (length & 15);
    while (pos < length) {
      if (charset[str[pos] >> 3] & (1 << (str[pos] & 7)) || pos == length - 1) {
        callback(str.substr(last_pos, pos - last_pos));
        last_pos = pos + 1;
      }
      pos++;
    }
  }
}

코드에 최대한 주석을 달아봤습니다. 꼼꼼히 읽어보시면 이해가 어렵지 않을 것 같습니다.

Benchmark

std::string generate_random_string(std::size_t length) {
    srand(0xcafe);
    std::string str(length, ' ');
    for (std::size_t i = 0; i < length; i++) {
        str[i] = 'a' + rand() % 26;
        i += rand() % 2;
    }
    return str;
}

이 코드로 문자 1000개 정도의 문자열을 생성하여 벤치마크를 진행했습니다. (std::mt19937 를 쓸 걸 그랬네요.)

최적화 결과가 매우 좋아서 Y 축은 log scale 로 표시했습니다.

-O0 에서는 모두 고만고만 하지만, Solution 2 와 3의 경우 최적화 레벨 1~3 에서 큰 차이가 없었던 반면 SIMD 구현은 -O1 에서도 좋은 성능을 보여주었습니다.

결과적으로 -O1 에서 solution 1 의 방식을 10배 이상 빠르게 만들 수 있었습니다.

마치며

항상 그렇진 않겠지만 최적화 수준과 가독성은 trade-off 관계에 있는 것 같습니다.

주석을 달아야 이해할 수 있는 코드를 그렇게 좋아하지는 않지만 어쩔 수 없는 경우도 있는 것 같네요.

현업에서 이런 최적화 테크닉을 적용할 때는, 여러가지를 고려해야겠습니다.

What’s Wrong with std::string

2025-08-02T00:00:00.000Z

C/C++ 의 문자열 표준은 정말 오랫동안 사용되어 왔습니다. <string>, <string_view>, <string.h> 등 여러 헤더파일이 있고 유용한 메서드들이 많이 있는데요, 유용하게 사용해왔던건 맞지만 타 언어에 비해 지원하는 메서드나 기능이 부족한 것은 사실입니다.

이번 포수트에서는 std::string 의 문제점과 이를 해결하기 위한 다양한 기법들을 @ashvardanian 의 포스트 를 참고하여 살펴보겠습니다.

모호한 오버로딩

std::string 의 replace 메서드의 프로토타입은 14가지나 있습니다.

아래 코드를 보고 결과를 바로 알 수 있나요?

std::string("FC Bayern Munich").replace(1, 2, "123");
std::string("FC Bayern Munich").replace(1, 2, std::string("123"), 1);
std::string("FC Bayern Munich").replace(1, 2, "123", 1);
std::string("FC Bayern Munich").replace(1, 2, "123", 1, 1);
std::string("FC Bayern Munich").replace(1, 2, std::string("123"), 1, 1);
std::string("FC Bayern Munich").replace(1, 2, 3, 'a');
std::string("FC Bayern Munich").replace(1, 2, {'a', 'b'});

// and more..

아무리 경력이 많은 개발자라도 전부 알기는 힘들겠죠.

아래는 결과입니다.

std::string("FC Bayern Munich").replace(1, 2, "123");
// F123Bayern Munich
std::string("FC Bayern Munich").replace(1, 2, std::string("123"), 1);
// F23Bayern Munich
std::string("FC Bayern Munich").replace(1, 2, "123", 1);
// F1Bayern Munich
std::string("FC Bayern Munich").replace(1, 2, "123", 1, 1);
// F2Bayern Munich
std::string("FC Bayern Munich").replace(1, 2, std::string("123"), 1, 1);
// F2Bayern Munich
std::string("FC Bayern Munich").replace(1, 2, 3, 'a');
// FaaaBayern Munich
std::string("FC Bayern Munich").replace(1, 2, {'a', 'b'});
// FabBayern Munich

오랜시간 표준이 업데이트 되면서 이런 오버라이딩이 쌓여왔죠. 메서드 뿐만 아니라 std::string 을 위한 서브클래스들도 추가되어왔습니다.

std::string_view
std::span

이 두 클래스는 문자열의 일부분을 참조하여 데이터 인스턴스가 중복되는 것을 방지하죠.

이렇게 문자열의 일부를 표현할 수 있는 클래스들이 있음에도, 왜 여전히 std::string 의 메서드들은 정수기반 range 를 받는 것만 지원하는 걸까요?

또, iterator 는 왜 사용하지 않을까요?

정수도 나쁜건 아닙니다만, 중요한 것은 정수 인자들에 대한 메서드의 처리입니다.

Out of bounds 처리

std::string 의 문자열의 특정 문자를 가져오는 메서드는 at 과 operator[] 가 있습니다.

std::string str = "FC Bayern Munich";
std::cout << str[0] << std::endl;
std::cout << str.at(1) << std::endl;
``
```txt
F
C

두 메서드의 기능은 같아보이지만, 예외 처리에서 차이가 있습니다.

std::string str = "FC Bayern Munich";
std::cout << "str[2013] = " << str[2013] << std::endl;

str[2013] = // 실제로는 보이지 않지만 '\x00' 이 있음. 상황에 따라 '\x00' 이 아닌 다른 값이 있을 수 있음.

operator[] 는 인덱스가 범위를 벗어나면 undefined behavior 를 발생시킵니다. 즉 지시된 인덱스에 있는 메모리의 값을 반환합니다. 예외 처리가 없는거죠. 그렇기 때문에 빠르게 동작합니다.

std::string str = "FC Bayern Munich";
std::cout << "str.at(2013) = " << str.at(2013) << std::endl;

libc++abi: terminating due to uncaught exception of type std::out_of_range: basic_string

at 메서드는 인덱스가 범위를 벗어나면 std::out_of_range 예외를 던집니다. 그렇기 떄문에 느리죠.

내부적으로 try-catch 를 사용하여 예외 처리를 하고 있습니다.

벤치마크를 돌려보면…

BM_StringOperatorBracket     714988 ns       714933 ns          980
BM_StringAt                 1489270 ns      1489178 ns          467

operator[] 가 더 빠른 것을 확인할 수 있습니다.

at 과 operator[] 의 차이가 예외 처리 여부라는 것을 알 수 있었습니다. 그럼 다른 함수는 어떨까요?

std::string("Jamal Musiala").substr(6);
std::string("Jamal Musiala").substr(6, 100);
std::string("Jamal Musiala").substr(100);
std::string("Jamal Musiala").substr(20, 5);
std::string("Jamal Musiala").substr(-1, 5);
std::string("Jamal Musiala").substr(0, -1);

std::string::substr 은 해당 범위의 슬라이드를 반환합니다.

각 프로토타입이 예외처리를 어떻게 하는지 알 수 있나요?

std::string("Jamal Musiala").substr(6)           = Musiala
std::string("Jamal Musiala").substr(6, 100)      = Musiala
std::string("Jamal Musiala").substr(100)         = std::out_of_range
std::string("Jamal Musiala").substr(20, 5)       = std::out_of_range
std::string("Jamal Musiala").substr(-1, 5)       = std::out_of_range
std::string("Jamal Musiala").substr(0, -1)       = Jamal Musiala

그다지 일관성이 없죠. 심지어는 첫번째 인자에만 경계 체크를 하고 두번째 인자에는 경계 체크를 하지 않습니다.

또한 substr(-1, 5) 의 경우 -1이 unsigned 로 변환되기까지 하는데 컴파일 옵션을 따로 두지 않는 한 경고도 없습니다.

저도 C++ 을 주력으로 삼는 개발자이지만, 사람들이 C++ 이 복잡하다고 생각하는 이유가 이런 것들 아닐까 싶습니다.

복잡한 템플릿, 모던 기법들까지 가기도 전에 이런 일관성 없고 오버로딩이 난무하는 것 부터 개발자에게 혼란을 주는 포인트가 되는 것 같습니다.

@ashvardanian 은 이 경우 Python 의 슬라이스 문법이 직관적이라고 주장하는데요, 저도 어느정도 동의합니다. Python 에서는 아래와 같은 표현이 가능하거든요.

>>> "FC Bayern Munich"[1:3]
'C '
>>> "Jamal Musiala"[-5:]
'siala'
>>> "Jamal Musiala"[-4:-2]
'ia'

C++ 로 이 문법을 흉내 내자면 이렇게 할 수 있습니다.

#include <iostream>
#include <string>

namespace jayden {

class string {
public:
    string(const char* str) {
        this->_str = std::string(str);
    }

    std::string operator[](std::initializer_list<int> range) const {
        auto it = range.begin();
        int first = *it++;
        int second = *it;

        int len = static_cast<int>(_str.length());
        if (first < 0) first += len;
        if (second < 0) second += len;
        if (first > second) return "";

        std::string result;
        for (int index = first; index < second; index++) {
            result += _str[index];
        }
        return result;
    }

private:
    std::string _str;
};

string operator "" _jayden(const char* str, unsigned long)
{
    return string(str);
}

} // namespace jayden

int main() {
    using namespace jayden;
    std::cout << "Jamal Musiala"_jayden[{-4, -2}] << std::endl;
}

ia

여러 예외 처리가 빠진 미완 코드지만, C++ 에서 literal operator, std::initializer_list 를 사용하여 파이썬을 어느정도 흉내낼 수 있었습니다.

다른 기능도 살펴보겠습니다.

split

>>> "FC Bayern Munich".split()
['FC', 'Bayern', 'Munich']
>>> "FC Bayern Munich".split("B")
['F', 'ayern Munich']

split 은 delimiter 를 기준으로 문자열을 분리하는 기능입니다. Python 으로 코드를 작성하다보면 반드시 사용하게되는 유용한 함수인데요, C/C++ 에서는 어떨까요?

C 표준에 strtok 함수가 있긴 하지만, thread-safe 하지 않습니다. 내부적으로 static 변수를 사용하기 떄문입니다.

const char* str = "FC Bayern Munich";
char* token = strtok(str, " ");
while (token != NULL) {
    printf("%s\n", token);
    token = strtok(NULL, " ");
}

C++ 에서는 std::stringstream 과 std::getline 을 사용하는 방법이 있습니다.

std::stringstream ss("FC Bayern Munich");
std::string token;
while (std::getline(ss, token, ' ')) {
    std::cout << token << std::endl;
}

하지만 너무 번거롭고 복사도 발생해서 굉장히 느립니다.

C++23 에서는 std::ranges::views::split 이 추가되어 복사 없는 문자열 분리가 가능해졌습니다.

std::string text = "one,two,three,four";
for (const char& ch : text) {
    std::cout
        << ch
        << " -> "
        << std::hex << static_cast<const void*>(&ch)
        << std::endl;
}

for (auto part : std::ranges::views::split(text, ',')) {
    std::cout 
        << std::hex << static_cast<const void*>(&*part.begin()) 
        << " -> "
        << *part.begin()
        << std::endl;
}

o -> 0x16f6d2850
n -> 0x16f6d2851
e -> 0x16f6d2852
, -> 0x16f6d2853
t -> 0x16f6d2854
w -> 0x16f6d2855
o -> 0x16f6d2856
, -> 0x16f6d2857
t -> 0x16f6d2858
h -> 0x16f6d2859
r -> 0x16f6d285a
e -> 0x16f6d285b
e -> 0x16f6d285c
, -> 0x16f6d285d
f -> 0x16f6d285e
o -> 0x16f6d285f
u -> 0x16f6d2860
r -> 0x16f6d2861
0x16f6d2850 -> o
0x16f6d2854 -> t
0x16f6d2858 -> t
0x16f6d285e -> f

text 변수의 데이터가 복사되지 않고 참조 기반 split 이 이루어져 빨리 동작하게 되었고, 코드도 훨씬 직관적으로 작성할 수 있게 되었습니다.

특수한 케이스에서 더 빠르게 동작 시킬 수 있는데, 바로 lazy_split 을 사용하는 겁니다.

lazy_split 은 문자열을 한번에 분리하지 않고 필요할 때마다 분리하는 방식입니다.

for (auto part : std::ranges::views::lazy_split(text, ',')) {
    ...
    if (some_condition) {
        break;
    }
    ...
}

이걸 사용하면 loop 중간에 탈출해야할 때 나머지 부분을 split 하지 않으므로 더 빠르게 동작할 수 있습니다.

그럼 이제 여러 기능들에 대한 벤치마크를 해봅시다.

#include <benchmark/benchmark.h>
#include <sstream>
#include <string>
#include <vector>
#include <cstring>
#include <boost/algorithm/string.hpp>
#include <ranges>

// Helper: stringstream split
std::vector<std::string> split_stringstream(const std::string& s, char delim) {
    std::vector<std::string> result;
    std::stringstream ss(s);
    std::string item;
    while (std::getline(ss, item, delim)) {
        result.push_back(item);
    }
    return result;
}

// Helper: strtok split
std::vector<std::string> split_strtok(const std::string& s, char delim) {
    std::vector<std::string> result;
    char* cstr = new char[s.size() + 1];
    std::strcpy(cstr, s.c_str());
    char delim_str[2] = {delim, 0};
    char* token = std::strtok(cstr, delim_str);
    while (token) {
        result.push_back(token);
        token = std::strtok(nullptr, delim_str);
    }
    delete[] cstr;
    return result;
}

// Helper: boost::algorithm::split
std::vector<std::string> split_boost(const std::string& s, char delim) {
    std::vector<std::string> result;
    boost::split(result, s, boost::is_any_of(std::string(1, delim)));
    return result;
}

std::vector<std::string> split_ranges(const std::string& s, char delim) {
    std::vector<std::string> result;
    auto split_view = std::ranges::views::split(s, delim);
    for (auto&& part : split_view) {
        result.emplace_back(std::string(part.begin(), part.end()));
    }
    return result;
}

static void BM_StringStream(benchmark::State& state) {
    std::string text = "one,two,three,four,five,six,seven,eight,nine,ten";
    for (auto _ : state) {
        auto v = split_stringstream(text, ',');
        benchmark::DoNotOptimize(v);
    }
}
BENCHMARK(BM_StringStream);

static void BM_Strtok(benchmark::State& state) {
    std::string text = "one,two,three,four,five,six,seven,eight,nine,ten";
    for (auto _ : state) {
        auto v = split_strtok(text, ',');
        benchmark::DoNotOptimize(v);
    }
}
BENCHMARK(BM_Strtok);

static void BM_Boost(benchmark::State& state) {
    std::string text = "one,two,three,four,five,six,seven,eight,nine,ten";
    for (auto _ : state) {
        auto v = split_boost(text, ',');
        benchmark::DoNotOptimize(v);
    }
}
BENCHMARK(BM_Boost);

static void BM_RangesSplit(benchmark::State& state) {
    std::string text = "one,two,three,four,five,six,seven,eight,nine,ten";
    for (auto _ : state) {
        auto v = split_ranges(text, ',');
        benchmark::DoNotOptimize(v);
    }
}
BENCHMARK(BM_RangesSplit);

BENCHMARK_MAIN();

Benchmark	Time (ns)	Time (ns)	Iterations
BM_StringStream	478	478	1,476,828
BM_Strtok	388	388	1,793,534
BM_Boost	537	537	1,251,385
BM_RangesSplit	297	297	2,401,372

역시 참조 기반 split 이 가장 빠르고 직관적인 코드를 작성할 수 있었습니다.

정리

이처럼 C++ 표준 기능에는 유용한 것도 있고, 문제가 있는 것도 있습니다. 대형 회사들은 거의 모두 직접 해시테이블을 짜거나, 대안 오픈소스를 사용합니다.

std::string 도 예외가 아니죠.

일부 연산은 LibC를 호출하는데, LibC는 전반적으로 훨씬 최적화되어 있지만 하드웨어 성능을 완전히 뽑지 못하고, C++ 클래스가 요구하는 기능도 다 커버하지 못합니다.

STL 과 C++ 표준을 맹신하지 말고, 필요한 경우 대안 오픈소스를 사용하는 거나 직접 구현하는 것도 좋은 방법이라는 것을 알 수 있었습니다.

Vector Cosine Distance in JavaScript

2025-07-19T00:00:00.000Z

Various methods to calculate cosine distance in JavaScript

String utilities with SIMD

2025-07-12T00:00:00.000Z

지난 SIMD 포스트 에서는 SIMD Instruction 의 간단한 예제를 배웠습니다.

이번에는 @ashvardanian 의 StringZilla 프로젝트에서 사용된 문자열 관련 함수들을 살펴보고 SIMD 가 어떻게 활용되었는지 알아보겠습니다.

Find substring

어떤 문자열이 다른 문자열에 포함되어 있는지 확인하는 함수는 문자열 처리에서 가장 기본적인 함수 중 하나입니다.

스칼라 변수에 대한 처리는 간단하게 구현할 수 있습니다.

bool contains(const char* haystack, std::size_t haystack_len, const char* needle, std::size_t needle_len) {
    for (size_t i = 0; i <= haystack_len - needle_len; i++) {
        bool match = true;
        for (size_t j = 0; j < needle_len; j++) {
            if (haystack[i + j] != needle[j]) {
                match = false;
                break;
            }
        }
        if (match) {
            return true;
        }
    }
    return false;
}

contains 함수는 나름 합리적인 구현체입니다.

하지만 SIMD 최적화의 여지가 있습니다.

@ashvardanian 는 contains 를 SIMD 로 구현하기 위해 한가지를 전제했는데요, 바로 needle 의 첫 4글자만 먼저 검색한 후 매치되는 부분이 없으면 더 이상 검색을 진행하지 않는 방식이 대부분의 경우 빠를 것이라는 겁니다.

SIMD 로 이 방식을 구현하면 아래와 같습니다.

uint32_t prefix_val;
memcpy(&prefix_val, needle, 4);
uint32x4_t prefix = vdupq_n_u32(prefix_val);

uint32x4_t block0 = vld1q_u32(reinterpret_cast<const uint32_t*>(haystack + 0));
uint32x4_t block1 = vld1q_u32(reinterpret_cast<const uint32_t*>(haystack + 1));
uint32x4_t block2 = vld1q_u32(reinterpret_cast<const uint32_t*>(haystack + 2));
uint32x4_t block3 = vld1q_u32(reinterpret_cast<const uint32_t*>(haystack + 3));

uint32x4_t matches0 = vceqq_u32(block0, prefix);
uint32x4_t matches1 = vceqq_u32(block1, prefix);
uint32x4_t matches2 = vceqq_u32(block2, prefix);
uint32x4_t matches3 = vceqq_u32(block3, prefix);

uint32x4_t matches = vorrq_u32(vorrq_u32(matches0, matches1), vorrq_u32(matches2, matches3));
uint64x2_t reduced = vreinterpretq_u64_u32(matches);

bool has_match = vgetq_lane_u64(reduced, 0) | vgetq_lane_u64(reduced, 1);

haystack 이 “FC BAYERN MUNICH FOREVER NO. 1” 이고, 여기서 needle 인 “FOREVER” 이 substring 으로 존재하는지를 확인하려 합니다.

1. `needle` 의 첫 4글자를 `uint32_t` 로 복사

uint32_t prefix_val;
memcpy(&prefix_val, needle, 4);
uint32x4_t prefix = vdupq_n_u32(prefix_val);

코드의 처음 부분에서 needle 의 첫 4글자를 uint32_t 로 복사합니다.

이제 prefix_val 은 0x464f5245 가 됩니다. (char 로 보면 F O R E 가 됩니다.)

이 값을 vdupq_n_u32 를 사용해 32비트 값 4개를 가진 총 128비트 벡터 레지스터로 확장합니다.

prefix 벡터 레지스터는 이제 [ 0x464f5245, 0x464f5245, 0x464f5245, 0x464f5245 ] 가 됩니다.

실제로는 byte order 에 따라 벡터 레지스터에 로드되는 값 설명과 다를 수 있지만, 편의상 ["FORE", "FORE", "FORE", "FORE"] 로 표현하겠습니다.

2. `haystack` 를 벡터 레지스터에 로드

uint32x4_t block0 = vld1q_u32(reinterpret_cast<const uint32_t*>(haystack + i + 0));
uint32x4_t block1 = vld1q_u32(reinterpret_cast<const uint32_t*>(haystack + i + 1));
uint32x4_t block2 = vld1q_u32(reinterpret_cast<const uint32_t*>(haystack + i + 2));
uint32x4_t block3 = vld1q_u32(reinterpret_cast<const uint32_t*>(haystack + i + 3));

이제 haystack 의 첫 4글자를 벡터 레지스터에 로드합니다.

vld1q_u32 는 벡터 레지스터에 32비트 값 4개를 로드시키므로, block0 의 경우 haystack 의 첫 16글자를 4등분한 각 4글자를 벡터 레지스터에 로드합니다.

즉 block0 은 ["FC B", "AYER", "N MU", "NICH"] 가 됩니다.

block1 부터는 haystack 의 1번째 인덱스부터 로드하므로 ["C BA", "YERN", " MUN", "NICH"] 가 됩니다.

block3 까지 모두 로드하면 아래와 같은 벡터 레지스터가 생성됩니다.

haystack: "FC BAYERN MUNICH FOREVER NO. 1"
block0: ["FC B", "AYER", "N MU", "NICH"]
block1: ["C BA", "YERN", " MUN", "ICH "]
block2: [" BAY", "ERN ", "MUNI", "CH F"]
block3: ["BAYE", "RN M", "UNIC", "H FO"]

3. `block0` 부터 `block3` 까지 `prefix` 와 비교

uint32x4_t matches0 = vceqq_u32(block0, prefix);
uint32x4_t matches1 = vceqq_u32(block1, prefix);
uint32x4_t matches2 = vceqq_u32(block2, prefix);
uint32x4_t matches3 = vceqq_u32(block3, prefix);

vceqq_u32 는 벡터 레지스터의 각 요소를 비교하여 결과를 벡터 레지스터로 반환합니다.

예시: vceqq_u32(
    [0x12345678, 0x56789abc, 0xcafebabe, 0xdeadbeef],
    [0x464f5245, 0x464f5245, 0xcafebabe, 0x464f5245]
)

결과: [0x00000000, 0x00000000, 0xFFFFFFFF, 0x00000000]

이제 matches0 부터 matches3 까지 모두 prefix 벡터와 비교하면 아래와 같은 결과가 나옵니다.

block0:   ["FC B", "AYER", "N MU", "NICH"]
prefix:   ["FORE", "FORE", "FORE", "FORE"]
matches0: [0,       0,      0,     0]

block1:   ["C BA", "YERN", " MUN", "ICH "]
prefix:   ["FORE", "FORE", "FORE", "FORE"]
matches1: [0,       0,      0,     0]

block2:   [" BAY", "ERN ", "MUNI", "CH F"]
prefix:   ["FORE", "FORE", "FORE", "FORE"]
matches2: [0,       0,      0,     0]

block3:   ["BAYE", "RN M", "UNIC", "H FO"]
prefix:   ["FORE", "FORE", "FORE", "FORE"]
matches3: [0,       0,      0,     0]

4. `matches0` 부터 `matches3` 까지의 비교 결과 수합

uint32x4_t matches = vorrq_u32(vorrq_u32(matches0, matches1), vorrq_u32(matches2, matches3));
uint64x2_t reduced = vreinterpretq_u64_u32(matches);
bool has_match = vgetq_lane_u64(reduced, 0) | vgetq_lane_u64(reduced, 1);

벡터 간 연산 결과는 항상 벡터이므로, matchesN 에서 바로 matchesN != 0 와 같이 스칼라 기반 비교는 할 수 없습니다.

따라서 vreinterpretq_u64_u32 를 사용해 32비트 값 4개를 가진 총 128비트 벡터 레지스터를 or 연산 하여 64비트 값 2개를 가진 총 128비트 벡터 레지스터로 변환합니다.

이제 reduced 벡터 레지스터는 [0, 0] 이 됩니다.

마지막으로 vgetq_lane_u64 를 사용해 64비트 값 2개를 가진 총 128비트 벡터 레지스터에서 64bit 씩 두개의 스칼라 값을 가져옵니다.

이제 has_match 는 false 가 됩니다.

5. 반복

첫번째 시도에서 has_match 가 false 이므로, haystack 의 4번째 인덱스부터 다시 같은 방식을 끝날 때 까지 반복합니다.

haystack += 4

반복하는 과정에서 has_match 가 true 이면, 그 위치부터 스칼라 구현처럼 문자열을 비교하면 됩니다.

6. 벤치마크

#include <arm_neon.h>
#include <cstring>
#include <cstdio>
#include <cstdint>
#include <benchmark/benchmark.h>

bool contains_scalar(
    const char* haystack,
    std::size_t haystack_len,
    const char* needle,
    std::size_t needle_len) {

    if (needle_len < 4 || haystack_len < 4) {
        return false;
    }

    for (std::size_t i = 0; i <= haystack_len - needle_len; i++) {
        bool match = true;
        for (std::size_t j = 0; j < needle_len; j++) {
            if (haystack[i + j] != needle[j]) {
                match = false;
                break;
            }
        }
        if (match) {
            return true;
        }
    }
    return false;
}

bool contains_simd(
    const char* haystack,
    std::size_t haystack_len,
    const char* needle,
    std::size_t needle_len) {

    if (needle_len < 4 || haystack_len < 4) {
        return contains_scalar(haystack, haystack_len, needle, needle_len);
    }

    uint32_t prefix_val;
    memcpy(&prefix_val, needle, 4);
    uint32x4_t prefix = vdupq_n_u32(prefix_val);

    for (std::size_t i = 0; i <= haystack_len - 4 - 3; i += 4) {
        uint32x4_t block0 = vld1q_u32(reinterpret_cast<const uint32_t*>(haystack + i + 0));
        uint32x4_t block1 = vld1q_u32(reinterpret_cast<const uint32_t*>(haystack + i + 1));
        uint32x4_t block2 = vld1q_u32(reinterpret_cast<const uint32_t*>(haystack + i + 2));
        uint32x4_t block3 = vld1q_u32(reinterpret_cast<const uint32_t*>(haystack + i + 3));

        uint32x4_t matches0 = vceqq_u32(block0, prefix);
        uint32x4_t matches1 = vceqq_u32(block1, prefix);
        uint32x4_t matches2 = vceqq_u32(block2, prefix);
        uint32x4_t matches3 = vceqq_u32(block3, prefix);

        uint32x4_t matches = vorrq_u32(vorrq_u32(matches0, matches1), vorrq_u32(matches2, matches3));
        uint64x2_t reduced = vreinterpretq_u64_u32(matches);

        if (vgetq_lane_u64(reduced, 0) || vgetq_lane_u64(reduced, 1)) {
            return contains_scalar(haystack + i, haystack_len - i, needle, needle_len);
        }
    }

    return false;
}

constexpr std::size_t TEXT_SIZE = 1000000;
constexpr const char SUBSTRING[] = "WXYZ";
constexpr std::size_t SUBSTRING_LEN = sizeof(SUBSTRING) - 1;

static void BM_ContainsScalar(benchmark::State& state) {
    std::string text(TEXT_SIZE, 'A');
    text.replace(TEXT_SIZE - SUBSTRING_LEN, SUBSTRING_LEN, SUBSTRING);
    for (auto _ : state) {
        benchmark::DoNotOptimize(contains_scalar(text.c_str(), TEXT_SIZE, SUBSTRING, SUBSTRING_LEN));
    }
}

static void BM_ContainsSimd(benchmark::State& state) {
    std::string text(TEXT_SIZE, 'A');
    text.replace(TEXT_SIZE - SUBSTRING_LEN, SUBSTRING_LEN, SUBSTRING);
    for (auto _ : state) {
        benchmark::DoNotOptimize(contains_simd(text.c_str(), TEXT_SIZE, SUBSTRING, SUBSTRING_LEN));
    }
}

BENCHMARK(BM_ContainsScalar);
BENCHMARK(BM_ContainsSimd);

BENCHMARK_MAIN();

아래는 벤치마크 결과입니다.

Benchmark	Time (ns)	CPU (ns)	Iterations
BM_ContainsScalar	327339	326595	2124
BM_ContainsSimd	243883	243700	2836

SIMD 구현이 스칼라 구현보다 빠른 것을 알 수 있습니다.

이처럼 SIMD 연산 뿐만 아니라 어떤 데이터 내에서 데이터를 찾아내는 것에 유용한 기능입니다.

응용하면 더 복잡한 문제에도 적용할 수 있습니다.

strlen -> 0 으로 초기화된 벡터 레지스터를 슬라이딩 윈도우로 사용하여 옮겨가며 비교
tolower, toupper -> ‘A’ ~ ‘Z’ 범위해 대해 벡터 기반 +32 적용 (소문자화)

Pseudo-SIMD

SIMD 는 유용하지만, 최대 단점은 하드웨어에 종속되는 기능이라는 것입니다.

같은 기능을 여러 하드웨어에서 구동시키려면 여러 하드웨어가 제공하는 API 로 모두 구현해야 하니까요.

지금 소개할 Pseudo-SIMD 는 하드웨어에 종속되지 않는 기능으로, SIMD 는 아니지만 SIMD 를 흉내내는 기능입니다.

문자열에서 특정 문자 n의 위치를 찾아내는 코드를 살펴보겠습니다.

이번 haystack 은 “MANUEL NEUER” 이고, 여기서 n 은 ‘U’ 라고 해보겠습니다.

uint64_t nnnnnnnn = n;
nnnnnnnn |= nnnnnnnn << 8;  // broadcast `n` into `nnnnnnnn`
nnnnnnnn |= nnnnnnnn << 16; // broadcast `n` into `nnnnnnnn`
nnnnnnnn |= nnnnnnnn << 32; // broadcast `n` into `nnnnnnnn`
for (; haystack + 8 <= end; haystack += 8) {
    uint64_t haystack_part = *(uint64_t const *)haystack;
    uint64_t match_indicators = ~(haystack_part ^ nnnnnnnn);
    match_indicators &= match_indicators >> 1;
    match_indicators &= match_indicators >> 2;
    match_indicators &= match_indicators >> 4;
    match_indicators &= 0x0101010101010101;

    if (match_indicators != 0)
        return haystack - begin + ctz64(match_indicators) / 8;
}

1. `n` 을 broadcast

uint64_t nnnnnnnn = n;
nnnnnnnn |= nnnnnnnn << 8;
nnnnnnnn |= nnnnnnnn << 16;
nnnnnnnn |= nnnnnnnn << 32;

n을 8비트씩 오른쪽으로 시프트하면서 비트를 채워넣습니다.

n = 0x55 // ('U')
nnnnnnnn = n;
// nnnnnnnn = 0x55
nnnnnnnn |= nnnnnnnn << 8;
// nnnnnnnn = 0x5555
nnnnnnnn |= nnnnnnnn << 16;
// nnnnnnnn = 0x55555555
nnnnnnnn |= nnnnnnnn << 32;
// nnnnnnnn = 0x5555555555555555

2. `haystack` 에서 8바이트씩 추출

uint64_t haystack_part = *(uint64_t const *)haystack;

haystack 에서 첫 8글자가 64비트 값으로 추출됩니다.

3. `haystack_part` 와 `nnnnnnnn` 의 XOR + NOT 을 통한 비교

uint64_t match_indicators = ~(haystack_part ^ nnnnnnnn);

haystack_part 와 nnnnnnnn 의 XOR 연산 결과를 NOT 연산 하여 비교 결과를 얻습니다.

그럼 데이터는 아래와 같을겁니다

haystack_part:    4e204c45554e414d
nnnnnnnn:         5555555555555555
match_indicators: e48ae6efffe4ebe7

XOR 연산은 서로 같으면 0, 다르면 1 이 되기 때문에, XOR 이후 NOT 연산을 하면 동일한 부분의 바이트는 0xff 가 되는 것을 알 수 있습니다.

4. `match_indicators` 에서 결과 추출

match_indicators &= match_indicators >> 1;
match_indicators &= match_indicators >> 2;
match_indicators &= match_indicators >> 4;
match_indicators &= 0x0101010101010101;

if (match_indicators != 0)
    return haystack - begin + ctz64(match_indicators) / 8;

이제 비교 결과를 알 수 있도록 쉬프트와 AND 연산을 사용하는데요, 쉽게 설명하기 위해 2바이트만 예시로 살펴보겠습니다.

>> 1, AND, >> 2, AND, >> 4 를 통해 각 바이트에 0이 포함되어있으면 해당 0이 인접 비트까지 0으로 만들어버려 결과적으로 0이 하나라도 포함된 바이트는 0이 되고, 오직 0xFF 만 최하위 비트가 1 이 되는 것을 알 수 있습니다.

이후 match_indicators 가 0이 아니라면 haystack_part 에 n 이 포함되어있다는 뜻이고, ctz64 를 통해 1 이 몇번째 비트에 있는지 알 수 있습니다.

이 값을 8로 나누면 문자열 속 n 의 위치를 알 수 있습니다.

ctz64 는 표준은 아니지만, __builtin_ctzll 처럼 컴파일러 내장 함수로 제공되기도 합니다.

C++20 부터는 표준으로 지원하기도 합니다. std::countr_zero 를 참고하세요.

마치며

이번 포스트에서는 SIMD 를 이용한 문자열 검색 방법과, 하드웨어에 종속되지 않는 Pseudo-SIMD 를 살펴보았습니다.
SIMD 를 활용하는 방식은 연산에 한정되어있지 않고, 데이터를 찾아내는 것에도 유용하다는 것을 알 수 있었습니다.
Pseudo-SIMD 는 하드웨어에 종속되어 있지 않으니 도입이 쉬워 많은 곳에서 활용할 수 있겠습니다.

SIMD Instruction

2025-07-05T00:00:00.000Z

Python 에서 사용되는 대표적인 라이브러리로 numpy 를 꼽을 수 있습니다. numpy 는 벡터화된 연산을 지원합니다. 배열/행렬 끼리의 덧셈, 곱셈 등의 연산을 아주 빠르게 수행할 수 있습니다.

numpy 는 C/C++ 로 구현되어 있습니다. 그래서 느린 Python 을 극복하고 빠르게 동작할 수 있죠.

그럼 C++ 로 numpy 처럼 행렬 연산을 직접 구현해보겠습니다.

void matrix_multiply(const float* a, const float* b, float* c, int n) {
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            c[i * n + j] = 0;
            for (int k = 0; k < n; ++k) {
                c[i * n + j] += a[i * n + k] * b[k * n + j];
            }
        }
    }
}

직관적으로 위와같은 코드를 생각해볼 수 있습니다.

이 코드는 작은 행렬에 대해서는 Python 이나 Javascript 같은 스크립트 언어들보다 훨씬 빠르게 동작합니다.

하지만 큰 행렬에 대해서는 어떨까요? 두 행렬의 크기를 1024x1024 로 설정하고 numpy 와 비교해보겠습니다.

def matrix_multiply(a: np.ndarray, b: np.ndarray) -> np.ndarray
    return np.dot(a, b)

❯ g++ -O3 matmul.cpp -std=c++17 -o matmul
❯ ./matmul
Time taken: 1.3178 seconds

❯ python3 matmul.py
Time taken: 0.0216 seconds

동일한 행렬곱 연산을 수행하는데 -O3 최적화 레벨을 적용한 C++ 코드보다 numpy 의 Python 구현이 더 훨씬 더 빠릅니다. 어떻게 이게 가능할까요?

Single Instruction Multiple Data, SIMD

numpy가 빠른 이유는 C/C++ 구현체 이기 때문이 아니라, 백엔드에서 SIMD와 같은 최적화를 활용하기 때문입니다.

SIMD 는 Single Instruction Multiple Data 의 약자로, 하나의 명령어로 여러 개의 데이터를 동시에 처리하는 CPU 명령어 집합을 말합니다.

변수 여러개를 하나의 레지스터에 저장한 뒤, 하나의 CPU 명령어로 레지스터에 대한 연산을 수행하는 방식이죠.

즉 이 SIMD은 CPU 차원에서 지원하는 기능이며, CPU 의 종류별로 지원 여부가 갈리며 지원하는 범위, 사용하는 방법이 모두 다릅니다.

우리가 흔히 아는 x86 아키텍처에서는 SSE, AVX, AVX2, AVX512 등의 SIMD 명령어가 있으며, ARM 아키텍처에서는 NEON 이라는 SIMD 명령어가 있습니다.

#include <arm_neon.h>

void matmul4x4_neon(const float* A, const float* B, float* C) {
    for (int i = 0; i < 4; ++i) {
        float32x4_t a_row = vld1q_f32(&A[i * 4]);
        for (int j = 0; j < 4; ++j) {
            float32x4_t b_col = {
                B[j], B[4 + j], B[8 + j], B[12 + j]
            };
            float32x4_t prod = vmulq_f32(a_row, b_col);
            float result = vaddvq_f32(prod);
            C[i * 4 + j] = result;
        }
    }
}

위 코드는 NEON 명령어를 사용하여 4x4 행렬곱을 수행하는 코드입니다.

A의 i번째 행 4개의 원소를 하나의 레지스터에 저장하고, B의 j번째 열 4개의 원소를 하나의 레지스터에 저장합니다.

그 뒤 두 레지스터에 대한 곱셈을 수행하고, 결과를 더합니다.

이렇게 하면 SIMD 를 사용하여 4x4 행렬곱을 수행할 수 있습니다.

하지만 아직도 numpy 의 구현을 따라가기는 어렵습니다. 우리가 구현한 코드는 4x4 행렬곱만 수행할 수 있습니다. SIMD 레지스터의 크기가 정해져있기 때문입니다. numpy 에는 지원하는 SIMD 레지스터의 크기를 고려하여 SIMD 를 사용하는 더 복잡한 로직이 구현되어 있는거죠.

이처럼 SIMD 는 사용하기에 제약조건이 많습니다.

CPU 에 따라 지원하는 SIMD 명령어가 다르고,
레지스터의 크기가 정해져있고,
메모리가 정렬되어 있어야 하고,
복잡한 분기가 필요한 경우 사용하기 어렵습니다.

이런 제약조건이 있음에도 실시간 데이터 처리, 머신러닝 등의 분야에서 여전히 강력한 기능이며 더 빠르게 동작하는 코드를 작성하기 위해 계속 사용되고 있습니다.

또한 어떤 컴파일러들은 최적화를 위해 자동으로 SIMD 명령어를 사용하는 기능을 제공하기도 합니다. 이런 경우 개발자가 명시적으로 SIMD 명령어를 사용하지 않아도 최적화된 코드를 실행할 수 있습니다.

void sum_arrays(float* dst, const float* a, const float* b, std::size_t n) {
    for (std::size_t i = 0; i < n; ++i) {
        dst[i] = a[i] + b[i];
    }
}

이 코드를 -O3 최적화 레벨을 사용하여 어셈블리 코드로 변환해보겠습니다.

❯ g++ -O3 -S -o output.s sum_arrays.cpp
❯ cat output.s

...
	fadd.4s	v0, v0, v4
	fadd.4s	v1, v1, v5
	fadd.4s	v2, v2, v6
	fadd.4s	v3, v3, v7
...

단순히 두 배열을 서로 더하는 코드를 for loop 로 구현했는데, 어셈블리 코드를 보면 ARM NEON 의 FADD 명령어가 사용됨을 알 수 있습니다.

어셈블리 코드에 SIMD 명령어가 있다고 해서 SIMD 명령어가 무조건 사용되는 것은 아니고, 컴파일러는 SIMD 가 사용될 수 있는지 검사하는 코드도 추가합니다. 모든 조건이 맞으면 SIMD 명령어가 사용됩니다. -> 참고

1% 의 소프트웨어 만이 SIMD 의 장점을 활용한다.

SIMD 가 무엇인지 간단히 알아보았으니 @ashvardanian 의 포스팅 을 리뷰해보겠습니다.

x86 에는 지난 20년동안 계속해서 새로운 SIMD 명령어를 추가되어 왔습니다.

년도	확장	추가된 명령어
1997	MMX	+ 46
1999	SSE	+ 62
2001	SSE2	+ 70
2004	SSE3	+ 10
2006	SSSE3	+ 16
2006	SSE4.1/2	+ 54
2008	AVX	+ 89
2011	FMA	+ 20
2013	AVX2	+ 135
2015	AVX-512	+ 347

SIMD 가 활용되고 있긴 한걸까?

문자열 검색을 AVX2 기반으로 구현하면, 일반적인 libc나 STL 함수보다 4×에서 많게는 12×까지 빠른 처리 속도를 기록합니다. SIMD 는 빠르다는 것과 그 이유는 설명 했지만, 실제로 얼마나 많은 소프트웨어가 SIMD 를 활용하고 있을까요?

@ashvardanian 은 리눅스에서 사용되는 대표적인 바이너리들을 분석하여 SIMD 를 활용하고 있는 비율을 조사했습니다.

def yield_instructions_from_binary(path: str) -> Generator[InstructionSpecs, None, None]:
    with open(path, mode='rb') as file:
        code = file.read()
        md = Cs(CS_ARCH_X86, CS_MODE_64)
        md.detail = True
        md.skipdata = True
        for instruction in md.disasm(code, 0):
            yield parse_instruction(instruction)

Capstone 라이브러리를 사용하여 바이너리 파일에서 실행되는 명령어를 추출합니다.

registers_512b = set(['zmm' + str(i) for i in range(0, 32)])
registers_256b = set(['ymm' + str(i) for i in range(0, 32)])
registers_128b = set(['xmm' + str(i) for i in range(0, 32)])
registers_64b = set(['rax', 'rbx', 'rcx', 'rdx', 'rsp', 'rbp', 'rsi', 'rdi', 'rip'] +
                    ['r' + str(i) for i in range(8, 16)])
registers_32b = set(['eax', 'ebx', 'ecx', 'edx',
                     'esp', 'ebp', 'esi', 'edi', 'eip', 'eflags'])
registers_16b = set(['ax', 'bx', 'cx', 'dx', 'sp', 'bp',
                     'si', 'di', 'cs', 'ss', 'es', 'ds', 'ip', 'flags'])
registers_8b = set(['ah', 'al', 'bh', 'bl', 'ch', 'cl', 'dh', 'dl'])

x86 에서 사용되는 SIMD 명령어를 레지스터 크기별로 분류합니다.

이렇게 실제 프로그램들에서 SIMD 가 사용되는 비율을 조사해보면 흥미로운 결과를 확인할 수 있습니다.

Binary	Instructions	All SIMD	128-bit SIMD	256-bit SIMD	512-bit SIMD
/usr/bin/dockerd	43M	0.478%	0.469%	0.009%	0.000%
/usr/bin/docker	26M	0.582%	0.568%	0.014%	0.000%
/usr/bin/containerd	21M	0.560%	0.543%	0.017%	0.000%
/usr/local/bin/gitlab-runner	19M	0.851%	0.828%	0.022%	0.001%
/usr/bin/mongod	16M	0.547%	0.545%	0.002%	0.000%
/usr/bin/mongoperf	15M	0.544%	0.542%	0.002%	0.000%
/usr/bin/kubectl	15M	1.002%	0.978%	0.024%	0.000%
/usr/bin/helm	14M	1.040%	1.015%	0.025%	0.000%
/usr/bin/ctr	12M	0.564%	0.533%	0.030%	0.000%
/usr/bin/containerd-stress	10M	0.551%	0.516%	0.035%	0.000%
/usr/bin/mongos	9M	0.602%	0.600%	0.002%	0.000%
/usr/bin/mongo	9M	0.566%	0.564%	0.002%	0.000%
/usr/bin/snap	8M	0.679%	0.635%	0.044%	0.000%

프로그램에서 SIMD 명령어가 사용되는 비율이 대부분 1% 미만이라는 것을 확인할 수 있습니다.

MacOS 라고 해도 이 현상은 크게 다르지 않습니다.

Binary	Instructions	All SIMD	128-bit SIMD	256-bit SIMD	512-bit SIMD
/usr/local/bin/mongod	26M	0.636%	0.635%	0.001%	0.000%
/usr/local/bin/libHalide.dylib	25M	0.289%	0.288%	0.001%	0.000%
/usr/local/bin/influxd	23M	0.714%	0.694%	0.020%	0.000%
/usr/local/bin/influx	19M	0.662%	0.638%	0.023%	0.000%
/usr/local/bin/hugo	18M	0.760%	0.740%	0.019%	0.001%
/usr/local/bin/mongo	17M	0.614%	0.613%	0.002%	0.000%
/usr/local/bin/bazel-real	16M	0.141%	0.120%	0.020%	0.000%
/usr/local/bin/node	14M	0.779%	0.737%	0.042%	0.000%
/usr/local/bin/lto-dump-10	12M	0.037%	0.035%	0.000%	0.002%
/usr/local/bin/gs-X11	8M	1.168%	1.167%	0.000%	0.001%

SIMD 명령어 셋은 지속적으로 업데이트 되어가고 있고 점점 레지스터의 크기는 커지고 있으나 대부분의 프로그램에서 SIMD 명령어가 거의 사용되지 않는다.

이 결과를 여러가지 방향으로 해석해볼 수 있습니다.

가설:
- 컴파일러의 자동 SIMD 최적화 기능이 부족하다.
- 개발자가 컴파일러의 자동 SIMD 최적화 기능을 사용할 수 없는 코드를 작성하고 있다.
- SIMD 가 없어도 상용 프로그램을 만드는 것에 문제가 없다.

결과를 어떻게 받아드릴지는 개인의 몫이지만, 3가지의 가설 모두 참일 가능성이 높습니다.

SIMD 라는 기술 특성 상 적용할 수 있는 경우가 한정되어있기에 컴파일러가 이런 경우를 캐치하기 쉽지 않을 것이며, 아주 특화된 도메인이 아닌 이상 개발자가 이정도의 최적화 수준을 고려해서 코드를 작성하지도 않을 것이고, 대부분의 프로그램이 SIMD 없이도 충분히 빠르게 동작하고 있는 것도 사실입니다.

@ashvardanian 는 SIMD 사용을 고려하기 전에 다른 최적화 기법을 먼저 적용해보라고 조언합니다.

분기 줄이기 (if, switch, loop)
메모리 점프, 힙 할당 최소화 (space locality, dynamic allocation)
런타임 다형성 회피 (virtual function, dynamic dispatch)
함수 인라인 가능성 최대화
컴파일 및 링킹 설정 조정
I/O 병목에 비동기 처리 적용
병렬 컴퓨팅에서 lock free data 구조 사용 (CAS, atomic operation)

마치며

SIMD 명령어와 간단한 용례, 그리고 실제 프로그램에서 SIMD 명령어가 사용되는 비율을 알아보았습니다.
SIMD 는 아주 강력한 기능이지만 그 사용처가 한정되어있고 최적화가 필요할 때 후순위가 되는 경우가 많다는 것도 알 수 있었습니다.
사용하기 어렵고 제약이 따르는 기능인 만큼 현업에서는 프로젝트의 목적과 크기, 팀의 규모 등 여러 요소를 고려하여 사용 여부를 결정하는게 중요합니다.

Compiler — The code you write doesn’t run exactly as is.

2024-10-13T00:00:00.000Z

Trust compiler.

Vrew—웹 기반 영상 편집 앱 분석, 그리고 더 빠르게 만들기

2024-02-14T00:00:00.000Z

웹에서 동영상을 어떻게 편집하는거야?

Jayden Yang

Attentive Low-Rank Filter Adaptation for Structure-Aware Cross-Domain Personalized Gaze Estimation

0. Backgrounds

1. Introduction

2. Related Work

3. Alfa

4. Experiments

5. Conclusion

6. Limitation

Attention is All You Need

Backgrounds

Introduction

Related Works

Transformer Architecture

Model Formula

Why Self-Attention

Training

Results

Conclusion

Deep Residual Learning for Image Recognition

Backgrounds

Introduction

Related Works

Deep Residual Learning

Experiments

10x Faster C++ String Split

What’s Wrong with std::string

Vector Cosine Distance in JavaScript

String utilities with SIMD

SIMD Instruction

Compiler — The code you write doesn’t run exactly as is.

Vrew—웹 기반 영상 편집 앱 분석, 그리고 더 빠르게 만들기