[SSL] Stanford CS231N - Deep Learning for Computer Vision

"Deep Learning for Computer Vision"

[Introduction]

· Edge Image : 물체의 경계나 밝기가 급격하게 변하는 부분만 추출한 이미지

· 2½D Sketch : 관찰자 기준의 표면 정보(깊이, 방향, 거리)를 표현한 중간 단계의 3차원 표현

▣ Neural Network

· 앞쪽 Layer : Simple Function / 뒤쪽 Layer : Complex Function

· Backpropagation을 통해 Parameter Tuning

▣ CNN(Convolutional Neural Network)

· 이미지와 같이 공간적 구조를 가진 데이터를 처리하기 위한 신경망

· Fully Connected Network는 모든 Pixel을 연결 → Parameter↑

· 작은 Filter(Kernel)를 이미지 위로 이동하며 계산하여 중요한 Feature만 추출

· 응용 분야 : 이미지 분류, 객체 검출, 얼굴 인식, 의료 영상 분석, 자율주행 등

▣ RNN(Recurrent Neural Network)

· 시간 순서를 가진 데이터를 처리하기 위한 신경망

· Fully Connected Network는 순서 고려 X (Ex. I love you & you love I)

· 이전 단어 정보를 계속 기억하며 처리

· 긴 문장에서는 초기 정보를 잊어버리는 Vanishing Gradient 문제 존재

    → LSTM(Long Short Term Memory) / GRU(Gated Recurrent Unit) : Gate를 사용하여 중요한 정보를 오래 기억

· 응용 분야 : 기계 번역, 음성 인식, 자연어 처리, 시계열 예측, 주가 예측 등

▣ Attention-Based Framework

· 입력 전체를 동일하게 보지 않고, Weight를 이용하여 현재 필요한 정보를 선택적으로 활용

** Transformer : Self-Attention을 기반으로 하여 Recurrent 구조 없이 Sequence 데이터를 병렬 처리

▣ Parallelism

▣ Diffusion Model

· 데이터에 점점 Noise를 추가한 후, Noise를 제거하는 과정을 학습하여 새로운 데이터 생성

> Forward Process : 데이터에 Noise를 점진적으로 추가

> Reverse Process : 이번 단계에서 추가된 Noise를 추정 후 제거하는 과정을 반복

▣ VLM(Vision Language Model)

· 이미지와 텍스트를 동시에 이해하고 처리하는 Multi-Modal Model

[Image Classification]

· Data-Driven Approach : Model이 데이터를 보고 스스로 Feature를 학습

  △ 사람이 설계한 규칙보다 복잡한 Pattern을 학습 가능

  ▼ 많은 데이터가 필요 → 학습 비용↑

· RGB : 각 Pixel을 Red/Green/Blue의 3 Channel로 표현하며 각각 8-bit로 저장 → 24-bit Color 이미지

▣ Nearest Neighbor Classifier

· 가장 차이가 작은 것을 정답으로 예측

· 학습 과정 : 별도의 Model Parameter를 학습하지 않고 훈련 데이터를 그냥 저장하여 그대로 기억 → O(1)

· 추론 과정 : 모든 훈련 데이터와의 거리를 계산 → O(N)

∴ 학습 : 빠름 / 추론 : 느림

▣ K-Nearest Neighbor Classifier

· 새로운 데이터가 들어오면 모든 훈련 데이터와의 거리를 계산한 후, 가장 가까운 K개의 Neighbor를 찾아서 그들의 다수결로 분류

> Distance

· L1 : d = |x| + |y| → 다른 Feature를 선택하면 축이 Rotate 되며 변화

· L2 : d = √(x² + y²) → 다른 Feature를 선택하면 축이 Rotate 되지만 변화 X

> Setting Hyperparameter

· K가 너무 작은 경우 : Noise에 민감 & Overfitting / K가 너무 큰 경우 : 경계가 흐려짐 & Underfitting

Idea #1)

· 훈련 데이터에서 성능이 제일 좋은 K 선택 → K = 1 (∵ 자기 자신과 가장 가까운 점은 자기 자신)

▼ Overfitting

Idea #2)

· Test 데이터에서 성능이 제일 좋은 K 선택

▼ Test Data는 마지막에 딱 1번만 평가 → 다른 새로운 데이터가 들어오면 정확도↓

Idea #3)

· 여러 K로 실험 후 Validation 성능이 가장 좋은 K 선택

Idea #4)

· 데이터가 적은 경우 Validation Set 하나만 분리하면 훈련 데이터가 감소하므로 훈련 데이터를 여러 Fold로 분리

· 각 K 값마다 5번 성능을 구하고 Validation 평균을 구하여 제일 좋은 K 선택

** K-Nearest Neighbor Classifier 성능↓ (∵ Pixel Distance는 유익 X)

· 같은 객체인데 거리가 먼 경우 (Ex. 고양이 A & 1 Pixel 이동한 고양이 B)

· 다른 객체인데 거리가 가까운 경우 (Ex. 갈색 고양이 & 갈색 강아지)

▣ Linear Classifier

· 각 Class마다 점수를 계산하고 가장 큰 점수를 가진 Class를 선택

> Algebraic Viewpoint

· 현재 정답인 Cat Class의 점수가 낮으므로 좋지 않은 Model

> Visual Viewpoint

· Weight가 어떤 Pattern을 학습했는지 시각화

> Geometric Viewpoint

> Hard Case

<XOR / Ring / Three Modes>

· Weight가 공간을 어떻게 나누는지 표현

· Linear Classifier는 데이터를 직선(또는 초평면)으로만 분리할 수 있으므로 복잡한 결정 경계 표현 불가

▣ Softmax Classifier

· Linear Classifier가 계산한 Class 점수를 Softmax 함수로 확률 분포로 변환한 후, 가장 높은 확률을 갖는 Class로 분류

· Loss Function이 작아지는 방향으로 학습 (0 ≤ L_i ＜ ∞)

> KL Divergence

· 두 확률 분포 Q(정답 Label 확률)와 P(예측 확률) 사이의 차이를 측정하는 지표로, Q를 P로 근사할 때의 정보 손실량을 의미

> Cross Entropy

· 실제 분포와 예측 분포 사이의 차이를 측정하는 손실 함수

[Regularization & Optimization]

▣ Regularization

<Training Data / Test Data>

· f₁ : Training Data에 Overfitting → Test Data 입력 시 성능↓

· Overfitting을 방지하여 일반화 성능을 향상 시키기 위한 기법

· λ : Regularization Strength(Hyperparameter)

· L2 : 큰 Weight에 Penalty를 크게 부여하여 특정 Feature 하나에 과도하게 의존 X → 새로운 데이터에서도 안정적으로 동작

· L1 : 불필요한 Weight를 0으로 만드는 Feature Selection 역할

· Elastic Net : L1과 L2 모두 사용

▣ Optimization

· Loss를 가장 작게 만드는 Weight와 Bias를 찾는 과정

> Gradient

· Weight를 조금 바꾸면 Loss가 얼마나 변하는지 확인

· Numerical Gradient : Weight를 조금씩 바꾸면서 Loss가 얼마나 변하는지 계산

  △ 구현이 쉬움

  ▼ Weight가 많은 경우 속도↓

· Analytic Gradient : 미분 공식을 이용하여 직접 Gradient 계산

  △ 빠르고 정확

  ▼ 구현이 어려움 (∵ 미분을 유도해야 하고, Backpropagation 구현 필요)

> SGD(Stochastic Gradient Descent)

· 전체 데이터를 사용하지 않고, 일부 데이터만 사용해서 Gradient를 계산(Ex. N개의 데이터 중 32/64/128개만 사용)

  △ Batch Size가 작기 때문에 속도↑

  △ Memory 사용량↓

  ▼ Gradient를 일부 데이터만 보고 계산하기 때문에 Loss가 진동 = 근사 Gradient

  ▼ Saddle Point에서 정체 가능

> SGD Momentum

· 이전까지의 이동 방향(관성)을 기억해서 더 빠르고 안정적으로 학습

  △ 수렴 속도↑

  △ 진동↓

  △ Saddle Point에서 관성으로 통과 가능

  ▼ 관성에 의해 최적점 지나칠 수 있음

  ▼ Weight만 저장하는 SGD와 달리 Velocity도 저장해야 해서 Memory 사용량↑

> RMSProp

· 모든 Weight를 같은 Learning Rate로 Update하지 않고, 각 Weight마다 적절한 Learning Rate를 자동으로 조절

  △ SGD에 비해 수렴 속도↑

  △ 진동↓

  ▼ Gradient의 크기를 이용해 Learning Rate를 조절하는 방법으로, 방향을 누적하는 Momentum의 장점 보유 X

> Adam

· Momentum + RMSProp

  △ 수렴 속도↑(Momentum 효과)

  △ Weight마다 Learning Rate 조절(RMSProp 효과)

  ▼ Memory 사용량↑(Weight, Momentum, Velocity)

> AdamW

· λW_t를 Gradient에 포함시키지 않고, 별도의 Weight Decay 단계로 적용

> Learning Rate

> First-Order Optimization

· 1차 미분(Gradient)만 이용 → 현재 위치에서 어느 방향으로 내려가야 하는지만 보고 이동

  △ 계산량↓ (# of Parameter = N → # of Gradient = N)

  △ Memory 사용량↓

  ▼ Gradient만 보기 때문에 Learning Rate 선택 중요

  ▼ Saddle Point에서 속도↓ (∵ Saddle Point의 Gradient = 0)

> Second-Order Optimization

· 2차 미분(Hessian Matrix)까지 사용 → 방향과 함께 곡률을 고려하여 효율적으로 이동

  ▼ 계산량↑ (# of Parameter = N → Hessian Matrix = N x N)
  ▼ Memory 사용량↑

∴ 대규모 CNN 또는 Vision Transformer를 학습할 때는 Parameter 수가 너무 많기 때문에 First-Order 사용

[Neural Network & Backpropagation]

▣ Neural Network

· 선형 연산을 여러 번 쌓아도 결국 하나의 선형 연산 → 표현력이 부족하여 직선 하나로 구분 불가

∴ 비선형 함수를 사용하면 더 복잡한 함수를 표현 가능

> Activation Function

> Fully-Connected Layer

· Hidden Layer가 많아질수록 표현력이 증가하여 복잡한 결정 경계 생성 가능

  ▼ Hidden Layer가 너무 많은 경우 Overfitting 발생 가능

· λ가 작을수록 Regularization이 약화되어 Weight 제한↓ → 복잡한 결정 경계 생성 가능

  ▼ λ가 매우 작은 경우 Overfitting 발생 가능

> Loss Function

· Non-Linear Score Function

  ① Input Data(x)가 들어오면 1번째 Layer에서 W₁ · x 계산 후 ReLU 적용

  ② ReLU 적용한 값에 2번째 Weight를 곱하여 최종적으로 Class별 Score 출력

· Hinge Loss On Predictions : 정답 Score가 다른 Score보다 충분히 커지도록 만드는 Loss

· Regularization : Overfitting을 방지하여 일반화 성능↑
· Total Loss = 평균 Classification Loss + 1번째 Layer의 Weight Penalty + 2번째 Layer의 Weight Penalty

** Loss Function을 직접 전개해서 손으로 유도하는 것은 비효율적

· 행렬 미분을 계속 진행

· Loss를 바꾸는 경우(Hinge Loss → Softmax Loss) 모든 미분을 다시 진행

· 복잡한 Model에서는 불가능

∴ Backpropagation 필요

▣ Backpropagation

· Chain Rule을 이용해 Loss를 각 Weight에 대해 미분하여, Weight를 Update할 수 있도록 Gradient를 구하는 Algorithm

> Scalar Backpropagation

> Simple Example

· ∂f / ∂z = q = 3

· ∂f / ∂y = z · 1 = - 4

· ∂f / ∂x = z · 1 = - 4

> Another Example

· Sigmoid Function σ(x) = 1 / (1 + e^-x)
· Sigmoid Local Gradient = (1 - σ(x)) · σ(x)

> Gradient Pattern

 - Add Gate (x + y = z)
· ∂z / ∂x = 1 & ∂z / ∂y = 1

→ ∂L / ∂x = (∂L / ∂z) · 1 & ∂L / ∂y = (∂L / ∂z) · 1

∴ 출력 Gradient가 그대로 양쪽으로 복사 → Gradient Distributor

 - Mul Gate (xy = z)

· ∂z / ∂x = y & ∂z / ∂y = x

→ ∂L / ∂x = (∂L / ∂z) · y & ∂L / ∂y = (∂L / ∂z) · x

∴ 자신이 아닌 상대방 값을 곱함 → Swap Multiplier

 - Copy Gate (y₁, y₂)

· ∂L / ∂x = (∂L / ∂y₁) + (∂L / ∂y₂)

→ Gradient Adder

 - Max Gate

· Max 입력 값만 선택되어 Max 입력으로만 Gradient 전달

→ Gradient Router

> Vector Backpropagation

> Example

> Matrix Backpropagation

** 입력이 Vector/Matrix에 상관 없이 각 Layer는 자신의 Local Gradient(Jacobian)를 이용해 upstream Gradient를 Downstream Gradient로 변환하며, 결과 Gradient는 항상 입력과 동일한 Shape

· Backpropagation이 저장하는 것 : Activation, Weight, 계산 중인 Gradient

· Backpropagation이 저장하지 않는 것 : Jacobian 전체, 전체 미분식

[Image Classification With CNN]

▣ CNN(Convolutional Neural Network)

· 작은 Filter를 Image 위에서 이동시키며 Convolution 연산을 수행하여 중요한 Feature(Edge, Corner, Texture, Object 등)을 자동으로 추출하는 신경망

· CNN의 앞부분은 간단한 Feature 학습, 뒷부분은 복잡한 Feature 학습

① Convolution : Feature를 추출

② ReLU : 비선형성 추가

③ Polling : Feature Map 크기를 줄임

④ ①~③ 반복 후 마지막에 Fully Connected로 분류 수행

> Convolution Layer

· RGB Channel 3개를 모두 포함하는 5x5 크기의 Filter 6개

· 1x28x28 Feature Map : 해당 Filter가 Image의 각 위치에서 해당 Feature가 얼마나 강하게 존재하는지를 나타낸 출력

△ Filter만 학습하여 Parameter ↓

△ Flatten하여 공간적 구조를 활용하지 못하는 Fully-Connected와 달리 인접한 Pixel들의 관계를 유지하며 공간적 관계 활용↑

· Padding을 추가하여 가장자리 정보도 충분히 학습

> Stride Convolution

· Stride만큼 건너뛰며 이동시키는 Convolution

  △ Feature Map 크기↓ = Down-Sampling

  △ 계산량↓

 - Example (Input Volume : 3 x 32 x 32 & 10 5x5 Filter with Stride 1, Pad 2)

· Output Volume Size : 10 x 32 x 32 ← 32 = (32 - 5 + 2 x 2) / 1 + 1

· # of Learnable Parameter : 10 x 76 ← 76 = 3 x 5 x 5 + 1(For Bias)

· # of Multiply-Add Operation : 75 x 10240 ← 75 = 3 x 5 x 5 & 10240 = 10 x 32 x 32

> Pooling Layer

· Feature Map의 크기를 줄이면서 중요한 특징만 남기는 Layer = Down-Sampling

    ∵ CNN에서 여러 Feature를 학습하기 위해 여러 Filter를 사용하면 Feature Map 크기↑

** Stride Convolution의 Down-Sampling과 다른 점 : 이미 추출된 Feature를 요약하는 연산으로 학습하지 않는 고정된 연산

· Max Pooling(비선형성 연산) : 최댓값을 선택하여 강한 Feature를 유지하므로 Edge, Corner 같은 Feature 보존에 유리

· Average Pooling(선형성 연산) : 평균값을 계산하여 전체 정보를 유지하므로 전체적인 분포를 반영

** Max Pooling은 비선형성 연산이지만 모든 위치에서 활성화를 결정하여 신경망의 표현력을 증가시키는 ReLU 함수 필요

→ ReLU가 없는 경우 Convolution은 선형 연산이고 Max Pooling만 비선형 연산이여서 Pooling이 있는 위치에서만 비선형성 발생

[Training CNN & CNN Architecture]

▣ Layer Normalization

· 입력 데이터를 정규화한 후, 학습 가능한 Parameter(γ, β)로 다시 Scale & Shift

  - 입력 데이터 : N = Batch Size(Sample 개수) / D = Feature 개수

  - Normalize : 각 Sample마다 평균과 표준편차 계산(평균 = 0 / 표준편차 = 1)

  - μ, σ : N x 1 → Sample 하나당 평균 하나, 표준편차 하나

  - γ, β : 1 x D → Feature마다 하나씩 존재

  - y : 최종 출력

** 정규화 진행 시 항상 평균 = 0, 표준편차 = 1 X

∴ Feature를 Scale & Shift 하기 위해 γ, β를 학습

> Normalization Layers

· Batch Norm : 같은 Channel에 대해 Batch 전체를 이용해서 평균과 분산을 계산

    → Batch 영향↑

· Layer Norm : 1개의 Sample 안에서 모든 Channel을 이용하여 평균과 분산을 계산

    → Batch가 몇 개인지 상관 없으며 Transformer에서 많이 사용

· Instance Norm : 한 Image의 한 Channel만 이용해서 평균과 분산을 계산

    → Batch와 상관 없으며 이미지 스타일 변환에 많이 사용

· Group Norm : Channel을 여러 개 묶어서 평균을 계산

    → Batch와 상관 X

** Transformer에서는 입력이 이미지가 아니라 Token의 Feature Vector

→ 각 Token은 독립적인 Feature Vector를 가지므로, 각 Token 내부의 Feature들만 이용해 정규화하는 LayerNorm이 가장 좋음

▣ Regularization - Dropout

· 학습할 때 일부 Neuron을 Random하게 사용하지 않고, 남은 Neuron만으로 학습하여 일반화 성능↑(Overfitting 방지)

· 학습 시에만 적용되며, 추론 시에는 모든 Neuron을 사용

▣ Activation Function

> Sigmoid

· 입력을 0~1 사이의 값으로 변환

  ▼ 절대값이 큰 값이 들어오면 Gradient가 거의 0

  ▼ Backpropagation에서는 기울기를 계속 곱하면서 전달 → 맨 앞층은 Gradient가 소실되어 거의 학습 불가

> ReLU

· 입력이 0보다 작은 경우 0 출력 / 0보다 큰 경우 그대로 출력

  △ Gradient Vanishing X → 깊은 신경망에서도 학습 용이

  △ 계산 쉬움

  ▼ Dead ReLU(Neuron의 입력이 항상 음수라면 ReLU 출력은 항상 0 → Weight가 더 이상 Update X)

> GELU(Gaussian Error Linear Unit)

· 입력을 확률적으로 부드럽게 반영하는 함수

  △ Backpropagation 시 Gradient 변화가 부드러워 학습이 안정적

  ▼ Φ(x) 정규분포 함수 계산으로 인해 계산량↑

  ▼ 아주 큰 음수는 Gradient가 0

▣ Filter

· 3x3 Convolution Filter의 성능과 계산량의 균형이 가장 좋음

  △ 중심 Pixel 주변 8개의 Pixel을 함께 볼 수 있어 Feature를 잘 추출 가능

  △ 계산량↓

  △ 3x3 Filter를 여러 층 쌓으면 5x5, 7x7과 같은 효과

        → 비선형성이 훨씬 많아져 더 복잡한 Feature 학습 가능 & Parameter 수↓

▣ Residual Block in ResNet

· 일반적인 CNN : 직접 학습 → Network가 깊어질수록 Gradient Vanishing & 학습 어려움 & 성능↓

· Residual Block : 원하는 출력 H(x)를 직접 학습하지 않고, 입력과 출력의 차이(Residual)만 학습하고 마지막에 입력을 더함

  △ Network가 깊어져도 안정적

  △ Gradient Vanishing이 발생하지 않아 Gradient 전달 쉬움

▣ Weight Initialization

· Weight를 너무 작게 초기화하는 경우 : 층이 깊어질수록 출력과 Gradient가 0에 수렴하여 제대로 된 학습 불가

· Weight를 너무 크게 초기화하는 경우 : 층이 깊어질수록 출력과 Gradient가 매우 커져 제대로 된 학습 불가

· Kaiming/MSRA Initialization : Weight를 평균 0, 표준편차 √(2 / D_in)을 갖도록 초기화

    → 층이 깊어져도 각 Layer의 Activation 크기가 일정하게 유지되어 신호와 Gradient가 지나치게 작아지거나 커지는 것을 방지

▣ Data Preprocessing

· Channel마다 값의 크기가 다르고 평균도 다르고 분산도 달라 학습이 불안정

∴ RGB 각 Channel 별 평균을 구하여 빼고 표준편차로 나누어 전처리 진행

→ 입력 데이터의 분포가 일정해져 학습이 더 빠르고 안정적

▣ Data Augmentation

· 기존 데이터를 변형(Flip/Rotation/Resize/Cut Out/Color Jitter 등)해서 새로운 학습 데이터를 만들어 Overfitting 방지

** Dropout : 신경망 구조를 일시적으로 변경 / Data Augmentation : 입력 데이터 변경

    → 모두 Training에서만 적용

▣ Transfer Learning

· 이미 학습된 Model을 새로운 문제에 재사용

· Feature Extraction : 앞부분은 고정하여 학습하지 않고, 마지막 FC Layer만 학습

· Fine-Tuning : 데이터를 조금 더 가지고 있는 경우 Convolution을 조금씩 다시 학습

△ 적은 데이터로도 학습 가능

△ 학습 속도↑

△ 성능↑

▣ Hyperparameter Selection

· Step 1 : 초기 Loss가 정상인지 확인

· Step 2 : 적은 데이터로 Overfit 되는지(= 학습이 완벽한지) 확인

· Step 3 : 적절한 Learning Rate 찾기

· Step 4 : 큰 범위에서 Hyperparameter 탐색

· Step 5 : 좋은 구간에서 세밀하게 탐색

· Step 6 : Loss와 Accuracy 곡선을 보고 Underfitting/Overfitting 여부 판단하며 조정

[Recurrent Neural Network]

▣ RNN

· 이전 정보를 Hidden State에 저장한 후, 다음 데이터 처리에 사용하여 순서가 있는 데이터를 처리

· 과거 정보와 현재 정보를 합친 후, tanh를 적용하여 새로운 Hidden State 생성

· tanh를 사용하는 이유 : Hidden State가 너무 커지는 것을 방지

> Many to Many

· 모든 RNN Cell은 같은 Weight를 공유

· 각 시간마다 Loss를 계산하고 이를 모두 더해 최종 Loss 계산

· 시간축을 따라 Backpropagation을 수행하며, 모든 시간에서 계산된 Gradient를 합쳐 하나의 Weight를 Update

> Many to One

· 모든 RNN Cell에서 같은 Weight를 공유

· 모든 Hidden State를 함께 활용하여 문장 초반의 중요한 정보가 마지막까지 전달되지 못하는 문제 방지

> One to Many

· 1번째 입력만 실제 입력을 사용하고 이후의 단계에서는 0 또는 이전 단계에서 생성한 출력을 사용

▣ BPTT(Backpropagation Through Time)

· 전체 Loss는 모든 시점의 Loss를 합한 값

· Backpropagation은 최종 Loss로부터 시간 축을 거꾸로 따라 모든 Hidden State를 역전파

    → 각 시점에서 계산된 Gradient를 합쳐 공유된 Weight를 Update

△ 정확한 Gradient 계산

▼ 계산량과 Memory 사용량↑

▼ 긴 Sequence에서는 비효율적

> Truncated BPTT

· Forward는 전체 Sequence를 따라 계속 진행 → Hidden State도 계속 전달

· Gradient는 일부 구간에서만 수행하여 Weight를 Update

** 다음 Forward 계산은 이전 구간에서 Update 된 Weight를 사용

△ 계산량과 Memory 사용량↓

△ 긴 Sequence 학습에 실용적

▼ 근사 Gradient 계산

> Truncated BPTT - Single Output

· 마지막 출력만 Loss에 연결하여 마지막에만 Loss 계산

· Gradient는 마지막 Loss에서 시작하지만 Chain Rule로 모든 Hidden State에 전달

    → 회색 박스 구간만 Gradient를 계산하여 Weight를 Update하여 다음 Forward는 Update 된 Weight 사용

    → Hidden State는 계속 전달

▣ RNN Tradeoff

△ 입력 길이 제한 X → CNN처럼 입력 크기를 미리 정해둘 필요 X

△ 현재 계산은 과거 정보를 사용 가능

△ 입력이 길어져도 Model 크기는 변화 X (∵ 모든 입력이 같은 Weight를 사용하여 Parameter 수 변화 X)

△ 모든 시간에서 같은 Weight 사용

▼ 속도↓ (∵ 순차적 계산)

▼ 오래된 정보 기억 X (∵ Gradient Vanishing)

▣ LSTM(Long Short Term Memory)

· Vanilla RNN : Step이 많아질수록 곱셈이 반복되면서 Gradient Vanishing / Gradient Exploding 발생

· LSTM : Cell State라는 별도의 Memory 경로를 두고, Forget/Input/Output Gate로 정보를 조절

→ 직선에 가까운 Gradient 전달 경로를 만들어 장기 의존성을 학습 가능

[Attention & Transformer]

▣ Sequence to Sequence with RNN

① Encoder : 입력 문장이 순서대로 RNN에 입력

② Context Vector(c) : 전체 문장의 의미 압축

③ Initial Decoder State : Encoder의 마지막 Hidden State를 이용해서 Decoder의 1번째 Hidden State를 생성
④ Decoder : 번역 시작

** Context Vector에 모든 정보를 압축하여 긴 문장은 정보 손실 가능

▣ Sequence to Sequence with RNN & Attention

· 마지막 Hidden State 하나만 보지 않고, 필요한 순간마다 Encoder의 모든 Hidden State를 사용

① Encoder : Hidden State 생성

② Alignment Score 계산(e) : Decoder의 현재 상태와 Encoder의 각 Hidden State가 얼마나 관련 있는지 점수를 계산

③ Softmax 계산(a) : 점수를 확률처럼 변형 후 Attention Weight로 사용

④ Context Vector 계산(c) : Attention Weight를 이용해서 Context Vector 생성 → Hidden State들의 Weight 평균

⑤ Decoder : 이전 출력(y), 이전 Hidden(s), Attention Context(c)를 사용하여 새로운 Hidden State 생성

** 출력 단어를 생성할 때마다 새로운 Context Vector를 계산 (∵ 참고해야 하는 입력이 달라 다시 Attention 계산)

· vediamo : "we", "see"에 집중한 c₁ 사용

· il : "the"에 집중한 c₂ 사용

· cielo : "sky"에 집중한 c₃ 사용

▣ Attention Layer(Cross-Attention Layer)

· Key(K) : Query와의 유사도를 계산하여 어떤 정보가 중요한지 결정하는 역할 → 검색용 주소

· Value(V) : 계산된 Attention Weight를 이용해 실제로 가져오는 정보를 담는 역할 → 실제 내용

→ Similarity를 계산하는 정보와 실제로 가져올 정보가 꼭 같을 필요는 없기 때문에 Data를 둘로 분리

① Similarity 계산 : 모든 Query와 모든 Key를 비교하여 점수(E) 생성

    · Similarity를 Query와 Key의 내적으로 계산

        → 내적 값이 너무 큰 경우 Softmax 값이 극단적으로 0과 1이 되어 Gradient가 사라지는 문제를 방지하기 위해 √(D_Q)로 나눔

② Softmax 계산 : 점수(E)를 확률로 변환(A)하여 Attention Weight 계산

③ Attention Weight와 Value를 곱하여 Output 생성

> Cross-Attention Layer

· Q = Decoder에서 생성 / K, V = Encoder에서 생성

· 입력 문장과 출력 문장의 관계를 학습

▣ Self-Attention Layer

· Q, K, V 모두 같은 입력 X에서 생성

· 같은 문장 내부의 관계를 학습(한 문장 안의 각 단어가 같은 문장의 다른 단어들을 참고하여 자신의 표현을 Update)

· 단어들끼리만 비교하기 때문에 순서를 모름 → 입력에 위치 정보를 더하여 사용

> Masked Self-Attention Layer

· Language Model은 현재 단어로 다음 단어를 예측해야 하므로 미래 단어를 참고하지 못하도록 Masking

· Similarity Matrix의 미래 위치를 - ∞로 Masking → Softmax를 적용하면 해당 위치의 Attention Weight = 0

> Multiheaded Self-Attention Layer

· 여러 개의 Self-Attention을 병렬로 수행한 후 결과를 합쳐서 더 풍부한 정보를 얻음

· 각 Head는 Weight를 다르게 하여 각각 다른 Feature를 학습

· 각 Head의 출력을 Stack한 결과에 Output Projection을 적용하여 최종 출력 생성

** Output Projection을 통해 각 Head들의 정보를 섞음

▣ 4 Matrix Multiply

① QKV Projection : 입력 X 하나를 한 번의 행렬곱으로 Q, K, V를 동시에 생성 ([WQ | WK | WV])

② QK Similarity : 각 Head마다 N x N Similarity Matrix 생성

③ V-Weighting : Attention Weight와 Value를 곱한 후, Head마다 나온 출력을 이어 붙여 Reshape

④ Output Projection : Stacking한 결과에 Output Weight를 곱하여 Transformer Block의 최종 출력 생성

→ 4단계의 행렬 연산으로 효율적으로 구현

▣ Processing Sequences

> RNN
△ Hidden State가 계속 전달되므로 긴 문장을 처리 가능

▼ 순차적으로만 계산 가능 → 병렬 계산 불가

> CNN

△ 병렬 계산 가능

▼ CNN은 근처만 보기 때문에 멀리 있는 정보를 보려면 Convolution을 계석 쌓아야 함 → 긴 문장에 비효율적

> Self-Attention

△ Attention은 여러 단계를 거쳐야 정보가 전달되는 RNN과 달리 정보가 바로 연결되므로 긴 문장 처리에 용이

△ 행렬곱 계산을 통해 병렬 처리 가능

▼ 모든 Query가 모든 Key를 비교하여 계산량↑

▣ Transformer Block

① Self-Attention : Vector들끼리 서로 정보를 교환

② Residual Connection : 입력을 출력에 더해 깊은 Network에서도 안정적으로 학습

③ Layer Normalization : Residual을 더한 후 정규화하여 Activation의 크기를 일정하게 만들어 안정적으로 학습

④ MLP : 각 Token을 독립적으로 비선형 변환하여 표현력↑

→ 이 Transformer Block을 여러 개 쌓아 Transformer 구성

** 6번의 행렬곱으로 구현 (4 : Self-Attention / 2 : MLP)

[Generative Model]

▣ Supervised Learning

· 입력과 정답이 함께 주어진 데이터를 이용해 학습 (x : Data / y : 정답 Label)

    → 입력을 넣으면 정답을 출력하는 함수를 배우는 것이 목표

· Classification, Regression, Object Detection, Semantic Segmentation, Image Captioning 등

▣ Unsupervised Learning

· 입력 데이터만 존재하고 정답 Label 존재 X

    → 정답 없이 데이터 속에 숨어 있는 구조를 스스로 찾아내는 것이 목표

· Clustering, Demensionality Reduction, Density Estimation, 

▣ Discriminative Model

· 입력을 보고 정답 예측

· p(y | x) : x가 주어졌을 때 y가 나올 확률

** 학습한 Class 외의 데이터가 들어오거나 Noise가 많은 데이터가 입력되는 경우 반드시 학습한 Class 중 하나를 선택

▣ Generative Model

· 데이터의 분포를 학습하여 새로운 데이터 생성

· p(x) : 데이터 자체가 나타날 확률

** 세상에 존재할 수 있는 모든 데이터의 확률 분포를 학습해야 함

    → 자연스러운 데이터에는 높은 확률, Noise 또는 비현실적인 데이터에는 낮은 확률을 부여

▣ Conditional Generative Model

· 조건을 만족하는 데이터를 생성

· p(x | y) : y가 주어졌을 때 x를 생성

** 하나의 입력에 대해 가능한 출력이 여러 개(Ambiguity)인 경우 Generative Model은 P(x | y)를 학습하여, 하나의 입력으로부터 여러 개의 자연스러운 출력을 생성 가능

** GPT : 입력 Prompt를 조건으로 하여 확률적으로 다음 Token을 하나씩 생성하면서 문장을 완성

▣ Generative Model 분류

> Explicit Density
· Model이 확률 P(x)를 계산 가능

  - Tractable Density

· 정확하게 P(x)를 계산

· 대표적인 Model : Autoregressive Model(GPT, PixelCNN, WaveNet)

** GPT는 문장을 한 단어씩 생성하여 문장 전체의 확률을 정확하게 계산 가능

  - Approximate Density

· 근사 P(x)를 계산

· 대표적인 Model : VAE(Variational Autoencoder)

> Implicit Density
· Model이 확률 P(x)를 계산 불가 → 해당 분포에서 새로운 데이터를 생성하는 것은 가능

  - Direct

· 바로 생성

· 대표적인 Model : GAN

  - Indirect

· 반복하여 데이터 생성

· 대표적인 Model : Diffusion

▣ MLE(Maximum Likelihood Estimation)

· 학습 데이터가 가장 잘 나올 수 있도록 Model의 Parameter W를 찾는 것이 목표

① 모든 학습 데이터가 나올 확률을 곱한 값을 최대로 만드는 W를 찾기

    → 각 데이터가 나올 확률을 곱하는 이유 : 데이터들이 서로 독립이라고 가정하면 전체 데이터가 동시에 나올 확률은 P(x⁽¹⁾, …, x^(N)) = ∏P(x⁽ⁱ⁾)

② 곱하면 엄청 작은 수가 되어 계산하기 어려우므로 Log를 취하여 합으로 바꿈 = Log-Likelihood

③ P(x) = f(x, W)로 정의

▣ Autoregressive Model

· 데이터 전체의 확률 P(x)를 계산하는 함수를 생성

· 데이터를 순서가 있는 것으로 가정 → 확률의 연쇄 법칙을 사용하여 계산(이전에 생성한 결과를 이용해서 다음 결과를 계속 생성)

· 이미지를 생성할 때도 이미지를 하나의 긴 순서로 바꿔 한 Pixel씩 생성

  ▼ 1024 x 1024 이미지의 Pixel 수는 RGB를 고려하면 약 300만 개의 Subpixel이 생겨 300만 번을 순서대로 생성

∴ Pixel을 하나씩 생성하지 않고 Tile 단위로 압축하여 Block 단위로 생성하여 순서대로 기다리며 생성해야 하는 횟수를 줄임

▣ AE(Autoencoder)

· 정답 Label 없이 입력으로부터 중요한 Feature를 학습하는 Unsupervised Learning Model

① Encoder : 입력 x를 Feature Learning을 통해 중요한 정보만 남겨 Feature Vector(z)로 압축

② Decoder : 압축된 Feature Vector(z)를 이용해 입력 복원

③ Loss Function : 원본과 복원을 비교하여 차이를 최소화

④ 학습이 끝난 후에는 Decoder는 버리고, Encoder만 사용하여 Feature를 추출한 후 Classifer를 추가하여 다른 작업에 활용

    ∵ 복원이 목적이 아니라, 좋은 Encoder(= 좋은 Feature)를 얻는 것이 목적

** 같은 입력을 다시 복원하므로 정답 Label이 자기 자신 → Unsupervised Learning

· Decoder는 학습 과정에서 Encoder가 출력한 z만 입력 받아 학습

· z는 특정한 확률 분포를 따르도록 제약되지 않기 때문에 흩어져 있음 → 새로운 z를 넣으면 Decoder가 이상한 이미지를 생성

∴ 모든 z가 표준정규분포를 따르도록 강제하여, 학습 후에는 정규분포에서 z를 Sampling하여 새로운 이미지 생성 = VAE

▣ VAE(Variational Autoencoder)

· AE는 단순히 이미지를 압축하고 복원하지만, VAE는 "이미지는 Latent Feature(z)로부터 생성된다"는 확률 Model을 가정

· Feature Learning & Generate New Data가 목표

· 어떤 z가 해당 이미지를 생성했는지 모르기 때문에 가능한 모든 z를 고려하기 위해 적분

· z가 고차원일 수 있으므로 적분 계산 어려움 = Intractable Density

· P(z | x) : 이미지 x가 주어졌을 때 어떤 z일 확률

· 이미지를 만들 수 있는 z는 엄청 많아 계산하기 어려움

· Encoder를 하나의 신경망으로 사용하여 q(z | x)를 학습하여 근사

· Encoder : 입력 x로부터 잠재변수의 근사 Posterior q_Φ(z | x) = N(μ_z|x, ∑_z|x)를 출력

· Decoder : 잠재변수 z로부터 데이터의 생성 분포 p_θ(x | z)를 출력

→ Encoder와 Decoder를 동시에 학습하여 새로운 데이터를 생성할 수 있는 생성 Model을 만듦

> ELBO(Evidence Lower Bound)

· 데이터가 생성될 확률인 log p_θ(x)를 최대화하는 것이 목표

① Bayes' Rule 적용

② KL Divergence 형태를 만들기 위해 q(z | x) 추가

③ log의 성질을 이용하여 3개의 항으로 분리

    · Reconstruction Term : Decoder가 복원을 얼마나 잘하는지

    · KL Divergence : Encoder가 만든 분포가 Prior와 얼마나 다른지

    · KL Divergence : Encoder가 만든 분포가 Prior와 얼마나 다른지

④ Expectation (∵ Encoder가 만든 분포에서 z를 Sampling)

⑤ 2번째 항과 3번째 항은 KL Divergence 정의 사용

⑥ 3번째 항은 항상 양수이므로 제외하여 Lower Bound 생성

  - Reconstruction Loss

· 입력을 정확히 복원하는 것이 목표

→ 각 입력마다 고유한 평균 μ를 갖고, 분산 ∑은 작아지도록 만드는 경향

  - KL(Prior) Loss

· 잠재분포 q(z | x)가 표준정규분포 N(0, I)에 가까워지는 것이 목표

→ 평균 μ는 0에 가까워지고, 분산 ∑은 1에 가까워지도록 만드는 경향

** 두 목적은 서로 상반되므로, VAE는 복원 성능과 규칙적인 잠재공간 사이에서 균형을 찾도록 학습

▣ GAN(Generative Adversarial Network)

· 진짜 데이터와 같은 분포에서 새로운 데이터를 만들어내는 것이 목표

· Generator : Random Noise(z)를 입력 받아 가짜 데이터를 생성하며, Discriminator가 진짜라고 판단하도록 학습

· Discriminator : 진짜와 가짜를 구분하도록 학습(0 : 가짜 / 1 : 진짜)

· Generator Distribution : Generator가 만든 이미지들을 p_G(x)라는 새로운 분포를 구성

① 표준 정규분포 p(z)에서 Random Noise(z)를 Sampling

② Generator가 z를 입력 받아 가짜 이미지 G(z)를 생성

③ Discriminator는 진짜 이미지와 생성된 가짜 이미지를 입력 받아 진짜/가짜 판별

④ Discriminator는 진짜와 가짜를 더 잘 구분하도록, Generator는 Discriminator를 잘 속이도록 학습

⑤ 두 Network를 반복적으로 학습하여 최종적으로 p_G(x)가 p_data에 수렴하는 것이 목표

> Discriminator 학습

· Generator의 Parameter는 Update하지 않고 Discriminator만 Update

· 1번째 항 : 진짜 데이터를 넣었을 때 D(x) = 1이 되도록 함

· 2번째 항 : Generator가 만든 가짜 이미지는 D(G(z)) = 0이 되도록 함

> Generator 학습

· Discriminator의 Parameter는 Update하지 않고 Generator만 Update

· 1번째 항 : Generator를 Update할 때는 1번째 항이 상수이므로 무시 가능

· 2번째 항 : D(G(z)) = 1이 되도록 이미지 생성

> 전체 목적 함

  - Discriminator
· V(G, D)를 최대화하는 것이 목표 → Gradient Ascent를 사용하여 Update

  - Generator

· V(G, D)를 최소화하는 것이 목표 → Gradient Descent를 사용하여 Update

** 둘을 동시에 Update하지 않고 번갈아 가며 Update

** Loss가 계속 감소하는 CNN과 달리, GAN은 Generator는 Loss를 줄이려고 하고, Discriminator는 같은 목적 함수를 늘리려고 하기 때문에 하나의 Loss가 지속적으로 감소하는 형태 X

∴ Loss 그래프만 보고 학습이 잘 되는지 판단하기 어려움 → 생성된 데이터의 품질로 판단

· 원래 GAN의 Generator Loss : 학습 초기에 D(G(z)) ≒ 0 → log(1) = 0 → Gradient가 매우 작아 학습 속도↓
· Non-Saturating Loss : 학습 초기에 D(G(z)) ≒ 0 → - log(0) ≒ ∞ → Gradient가 매우 커서 학습 속도↑

> DC-GAN(Deep Convolutional GAN)

· CNN을 이용하여 만든 GAN 구조 → Generator/Discriminator가 모두 CNN으로 구성

    (기존 GAN에서는 Generator/Discriminator가 단순한 FC Network)

> StyleGAN

· DC-GAN은 Noise z를 한 번만 입력하지만, StyleGAN은 각 Layer마다 Style을 조절

· Mapping Network를 통해 Random한 입력 z를 바로 Generator에 넣지 않고 FC를 통과시켜 Style Vector w로 변환

· AdaIN(Adaptive Instance Normalization)을 이용하여 각 Layer마다 Feature의 Scale과 Shift를 조절하여 Style을 독립적으로 제어

· 각 Layer에 Noise를 추가하여 세부 Detail을 표현

> Latent Space Interpolation

· 두 잠재 Vector z₀, z₁ 사이를 z_t = tz₀ + (1 - t)z₁로 Interpolation

→ x_t = G(z_t)를 통해 생성되는 이미지도 자연스럽고 연속적으로 변화

> GAN Pros & Cons

△ Generator와 Discriminator만 있으면 되고 수식이 비교적 간단

△ 높은 품질의 이미지 생성 가능

▼ Loss가 지속적으로 감소하지 않기 때문에 Loss만 보고 판단하기 어려움

▼ 학습이 매우 불안정

▼ Model을 크게 만들수록 학습이 더욱 어려움

▣ Diffusion Model

> Intuition

<Reverse Diffusion>

· Noise를 조금씩 제거해서 이미지 생성

① Noise z를 정규분포에서 Random하게 선택

② Forward Diffusion을 통해 Noise를 조금씩 추가

③ Noise가 섞인 이미지와 현재 Noise 단계를 입력 받아 Noise를 조금 제거한 결과를 출력하며 조금씩 학습

④ 학습이 끝나면 완전한 Noise로부터 새로운 이미지를 생성 = Reverse Diffusion

▣ Rectified Flow

· Noise를 조금씩 제거하는 대신 어느 방향으로 움직여야 하는지(Velocity)를 학습

① 실제 데이터 분포인 p_data와 Noise 분포(보통 Gaussian)인 p_noise를 준비

② 매 학습마다 실제 이미지(x) 하나, Random Noise(z) 하나, Random한 시간(t)을 선택

③ 실제 이미지와 Noise를 Linear Interpolation하여 중간 상태 x_t를 생성

④ 실제 이미지에서 Noise 방향으로 향하는 Velocity를 계산(데이터 x에서 Noise z까지 이동하는 방향 Vector)

⑤ 신경망 f_θ(x_t, t)가 입력된 중간 상태 x_t에서 이동해야 할 Velocity를 예측 하도록 학습

    → 예측한 Velocity와 실제 Velocity의 차이를 최소화 하도록 학습

> Sampling

① 생성에 사용할 이동 횟수 T를 결정(한 번에 이미지를 생성하지 않고 여러 번 이동하여 생성)

② Noise 분포에서 하나를 선택

③ 현재 위치 x_t에서 어느 방향으로 이동해야 하는지를 신경망이 예측 후, Velocity의 반대 방향으로 1/T만큼 이동

> Conditional Rectified Flow

· Rectified Flow에 조건(y)을 추가하여 원하는 데이터를 생성

· 전체 데이터 분포가 아니라 조건에 해당하는 부분 분포 p_data(x | y)를 학습

· 학습 과정 : Model의 입력으로 현재 상태(x_t), 조건(y), 시간(t)를 함께 사용하여 Velocity를 예측

· 생성 과정 : 사용자로부터 조건(y)을 입력 받아 해당 조건에 맞는 이미지를 생성

** CFG(Classifier-Free Guidance)

· 조건을 얼마나 강하게 반영할지 조절

· 학습 과정 : 일정 확률로 조건(y)을 제거하여 Conditional과 Unconditional을 동시에 학습

· 생성 과정 : 조건 없는 Velocity(v⁰), 조건 있는 Velocity(v^y)를 결합하여 v^cfg = (1 + w)v^y - wv⁰를 계산

    → Guidance Scale(w)를 조절하여 조건을 반영하는 정도를 제어

> Generalized Diffusion

· Rectified Flow를 일반화한 Diffusion Framework

▣ LDM(Latent Diffusion Model)

· 큰 이미지에서 Diffusion을 수행하지 않고, 압축된 Latent 공간에서 Diffusion을 수행

① Encoder + Decoder 학습 : Encoder는 이미지를 작은 Feature(Latent)로 압축, Decoder는 latent를 원본 이미지로 복원

② Latent에서 Diffusion 학습 : Encoder로 얻은 Latent에 Noise를 추가한 후 Diffusion Model이 Noise를 제거하도록 학습

    → Encoder는 학습이 끝났으므로 Encoder의 Weight는 더 이상 Update하지 않고 고정

③ Sampling : Random Latent를 하나 생성 후 Diffusion Model을 반복 적용하여 Noise 제거

    → 생성된 깨끗한 Latent를 Decoder에 입력하여 최종 이미지 생성

△ 연산량 & Memory 사용량↓

△ 학습 속도 & 생성 속도↑

** VAE + GAN + Diffusion 모두 사용

· VAE : Encoder와 Decoder는 VAE로 학습하여 이미지를 Latent로 압축하고 복원

    → Latent 공간이 Gaussian 분포를 따르도록 KL Loss를 사용하지만, 복원 품질을 유지하기 위해 KL Weight는 매우 작게 설정

    → VAE Decoder는 복원 이미지가 흐려지는 경향 존재

· GAN : GAN의 Discriminator를 추가하여 Decoder가 더 선명하고 현실적인 이미지를 생성하도록 학습

· Diffusion : 학습이 완료되면 Encoder를 고정하고, Latent 공간에서 Diffusion Model을 학습

▣ DiT(Diffusion Transformer)

· U-Net(= CNN 기반의 Encoder + Decoder 구조) 대신 Transformer를 사용하는 Diffusion Model

① 입력된 Noisy Latent를 Patch 단위 Token으로 변환한 후 Transformer가 사용할 수 있는Embedding으로 변환

② Transformer(DiT Block)을 여러 번 반복하고 마지막에 Linear Layer를 거쳐 Noise를 예측

** Condition 정보를 Transformer에 입력하는 방법

· Predict Scale/Shift(AdaLN) : Condition을 이용하여 LayerNorm의 Scale과 Shift를 조절

· Cross Attention : 이미지 Token이 Text Token을 참조하도록 Cross Attention 수행

· Joint Attention : 이미지 Token과 Text Token을 하나의 Sequence로 결합한 후 Self-Attention 수행

▣ Diffusion Distillation

· Teacher Model의 여러 단계를 Student Model이 적은 단계로 모방하도록 학습

    ∵ Diffusion Model은 Sampling 시 Diffusion Model을 여러 번 반복 수행해야 하므로 생성 속도↓

→ Sampling Step 수를 크게 줄여 생성 속도↑

△ Sampling 횟수↓

△ 생성 속도↑

△ 연산량↓

▼ Step 수를 너무 줄이면 생성 품질 저하 가능

▣ Score Function

· 데이터 분포의 log 확률을 x에 대해 미분한 값으로 확률 밀도가 높은 영역을 향하는 방향을 나타냄

  - Diffusion Model

· 신경망을 이용하여 데이터 분포 p_data의 Score Function을 근사하도록 학습

· Sampling 시 Score Function을 따라 Noise를 점진적으로 데이터 분포 방향으로 이동시켜 이미지를 생성

▣ SDE(Stochastic Differential Equation)

· Diffusion의 연속적인 Noise 추가 과정을 SDE(확률 미분방정식)로 표현 가능

· Forward Process : SDE를 따라 점진적으로 Noise를 추가하는 과정

· Reverse Process : SDE를 반대로 풀어 Noise를 제거하는 과정

※ f(x, t)dt : 데이터의 결정적인 변화

※ g(t)dw : Brownian Motion에 의한 확률적인 Noise

** Diffusion model은 신경망을 이용하여 Reverse SDE를 근사적으로 해결하도록 학습

[3D Vision]

▣ Explicit Representation

> Point Cloud

· 수많은 점들의 집합으로 3D 물체를 표현

· 저장 정보는 기본적으로 (x, y, z)좌표이며, 필요하면 법선 Vector도 함께 저장

· 점들 사이의 연결 정보는 없음

· 하나의 Scan으로는 전체 물체를 얻기 어려워 여러 방향에서 Scan한 후 결과를 하나로 맞추고 합침 = Registration

△ 구조가 매우 단순

△ 3D Scanner가 바로 생성 가능

△ 저장이 쉬움

△ 취득 속도↑

▼ 점들 사이의 연결 정보 X

▼ 표면 정의 불가

▼ 편집이나 물리 Simulation이 어려움

▼ Rendering 품질↓

> Polygonal Mesh

· 점들을 연결하여 면(Polygon)을 만들어 3D 객체의 표면을 표현

※ Triangle Mesh : 삼각형만 사용하는 Mesh

    △ GPU는 Triagnle을 기본 단위로 Rendering하므로 효율↑

    ▼ 복잡한 곡면을 표현하려면 많은 삼각형이 필요하여 Memory와 계산량↑

  - Mesh Upsampling - Subdivision

  - Mesh Downsampling - Simplification

  - Mesh Regularization

> Parametric Representation

· 점이나 삼각형을 저장하지 않고, 수학 함수로 3D 표면을 표현

  - Parametric Curve

· 하나의 매개변수 t를 이용하여 곡선을 표현

  - Parametric Surface

· 2차원 좌표를 입력하면 3차원 좌표가 출력되는 함수

  - Subdivision

> Explicit Representation Pros & Cons

△ 표면을 직접 표현

▼ 임의의 점이 내부인지 외부인지 판별하기 어려움

▣ Implicit Representation

· 공간 속의 모든 점을 분류하여 물체를 표현

** Parametric은 함수를 사용하지만 표면 위의 점을 직접 계산 = Explicit Representation

    → Implicit Representation은 함수가 점의 내부/외부 또는 표면 여부를 판정할 뿐, 표면의 좌표를 직접 생성 X

△ 내부/외부 판단 쉬움

△ 매끄러운 곡면 표현 가능

▼ 표면 추출 어려움

▼ 계산량↑

> Algebraic Surface

· f(x, y, z) = 0인 점들의 집합으로 표면 정의
▼ 복잡한 자연물은 적절한 수식을 만들기 어려움

> CSG(Constructive Solid Geometry)

· 여러 기본 도형을 Boolean 연산으로 결합

> SDF(Signed Distance Function)

· 각 점에서 표면까지의 부호 있는 거리를 저장

> Level Set Method

· 수식 대신 격자에 함수값을 저장하고, Interpolation을 통해 함수 값이 0이 되는 위치를 표면으로 지정
△ 복잡한 형상 표현 가능

△ 형태가 변하는 물체 표현이 쉬움

> Voxel

· 3D 공간을 작은 정육면체로 나누어 물체를 표현

▣ AI + Geometry

> Generative Model

· P(S), P(S | c)

· 새로운 Shape을 생성하는 Model

> Discriminative Model

· P(c | S)

· 입력 Shape을 분석하여 Label이나 속성을 예측하는 Model

> Joint Modeling

· 2D 이미지와 3D 데이터를 함께 학습하는 Model

· 이미지 또는 3D 형상 같은 시각 데이터뿐만 아니라, Text와 같은 다른 형태의 데이터도 함께 학습하는 Multi-Modal Model

▣ Multi-View Representation

· 여러 방향에서 찍은 2D 이미지를 이용해서 3D를 표현

△ 기존 2D CNN 사용 가능

△ 구현 쉬움

△ 정확도↑

▼ 진짜 3D 구조 X

▼ 시점 개수가 많아질수록 계산량↑

▣ Visual Object Network

· Geometry와 Rendering을 분리하여 따로 학습

▣ Octree Representation

· 모든 공간을 저장해야 하는 Voxel과 달리 필요한 곳만 잘게 나눔

▣ Eulerian vs Lagrangian

· Eulerian : 공간을 기준으로 관찰

· Lagrangian : 입자 또는 점을 저장하고, 각 점이 움직이는 것을 추적

▣ PointNet

· 3D 공간상의 점들의 집합인 Point Cloud를 그대로 입력 받아 결과 생성

· 모든 점에 동일한 MLP(Weight Sharing)를 적용 후 Feature를 모두 모아 Max Pooling을 수행하여 Global Feature 생성

> Invariance

· 입력이 조금 달라져도 결과는 동일해야 함

  - Point Permutation Invariance

· 점의 순서가 바뀌어도 결과 동일

· PointNet은 공유 MLP와 Global Max Pooling을 이용하여 이를 만족

    (∵ Point Cloud에는 순서가 없으므로 Network는 입력 순서가 바뀌어도 같은 결과를 내야 함 → Max 값 사용)

  - Sampling Invariance

· 점의 개수/밀도가 달라도 결과 동일

· 다양한 Sampling으로 학습

▣ Graph NN on Point Cloud

· PointNet은 각 점을 독립적으로 처리 → 가까운 점을 연결하여(이웃 관계를 학습) Point Cloud를 Graph로 변경

▣ Distance Metrics for Point Cloud

> Chamfer Distance

· 각 점이 가장 가까운 점까지의 거리를 계산(반대 방향도 계산해서 더함)

> Earth Mover's Distance

· 모든 점을 1:1 대응시킨 후 최소 이동 거리를 계산

▣ Parametric Decoder - AtlasNet

· 여러 개의 2D Patch를 합쳐서 3D Surface로 변환

▣ Implicit Functions for Geometry + Rendering(NeRF)

· 공간을 Voxel 또는 Mesh처럼 저장하지 않고, MLP가 3D 공간을 함수로 표현

· 입력 = 3D 공간상의 위치 + 시점 / 출력 = RGB + 밀도

· 여러 이미지에서 얻은 광선을 이용해 하나의 연속적인 3D Density & Radiance Field를 학습

· 학습된 Field를 이용해 임의의 시점의 이미지를 생성 가능

· Volume Rendering을 통해 최종 Pixel 색상을 계산

※ Density Field : 물체의 형태(Geometry)를 표현하는 정보

※ Radiance Field : 위치와 시점에 따른 색과 밝기를 표현하는 정보

> Volume Rendering

· 최종 Pixel 색은 모든 Sample의 색을 단순히 평균내는 것이 아니라 앞에서 가려지는 효과를 고려한 가중합으로 계산

· 덧셈과 곱셈으로만 구성되어 미분 가능하므로, 실제 이미지와의 오차를 이용해 Backpropagation으로 NeRF 신경망 학습 가능

※ c_i : Ray 위 i번째 점의 색

※ α_i : i번째 점의 불투명도 또는 그 점이 최종 색에 기여하는 정도

※ T_i : i번째 점까지 빛이 도달할 확률로, 앞선 점들의 투명도를 모두 곱한 값

▣ Generative Modeling with Implicit Geometry + Rendering

① 3D 물체를 표현하는 Shape Code(잠재 Vector)를 입력 받음

② Shape Network가 Shape Code를 이용해 Implicit 3D Geometry(Density Field)와 Appearance(Radiance Field)를 생성

③ 생성된 Field에 대해 Volume Rendering을 통해 새로운 3D 객체와 다양한 시점의 이미지를 생성

④ Shape Code를 변경하면 서로 다른 얼굴, 자동차, 고양이 등 다양한 3D 객체를 생성 가능

▣ Gaussian Splatting

· 장면 전체 공간을 다 표현하지 않고, 물체가 있는 부분만 Gaussian Blob으로 표현

· σ = 0 : 빈 공간이므로 저장할 필요 X

** NeRF : 공간의 모든 위치에 대해 MLP가 값을 예측 → 빈 공간까지 포함해서 Dense하게 표현

▣ Structure-Aware Representation

· 객체를 Structure와 Geometry로 분리하여 표현

· Structure를 먼저 학습한 후 각 부품의 Geometry를 학습(Like 의자를 조립)

▣ Element Structure 표현 방법

> Segmented Geometry

· 객체를 부품으로만 구분(Ex. 등받이, 다리, 좌판 등) → 어떻게 연결되어 있는지 모름

> Part Sets

· 부품들의 집합으로 표현(Ex. 다리 전체, 등받이 전체 등) → 어떻게 연결되어 있는지 모름

> Relationship Graphs

· 부품 간 관계를 그래프로 표현 → 연결 관계 표현 가능

> Hierarchies

· 계층 구조로 표현

> Hierarchical Graphs

· 계층과 부품 관계를 동시에 표현

> Program

· 객체를 Program으로 표현

[Vision & Language]

▣ Multi-Modal Foundation Model

> SimClr
· 같은 이미지의 다른 버전끼리는 가깝게, 다른 이미지들은 멀어지도록 학습하며 이미지끼리만 비교

· 두 Encoder는 Weight Sharing

· 1장의 원본 이미지를 2번 다르게 변형하여 두 Feature를 얻은 후, 다른 이미지를 통해 얻은 Feature와 비교

> CLIP

· Image → Text Loss와 Text → Image Loss를 합친(양방향) Symmetric Contrastive Loss를 사용하여 이미지와 텍스트를 같은 Embedding 공간으로 정렬

· 하나의 Embedding 공간 안에 정답인 이미지-Text 쌍은 가깝게 만들고, 나머지 조합은 멀어지도록 학습

▣ CLIP

> Pretraining

· Contrastive Learning을 통해 Image Encoder와 Text Encoder를 학습

    → 이미지와 Text를 같은 Embedding 공간으로 정렬(정답인 이미지-Text 쌍은 가깝게, 정답이 아닌 쌍은 멀어지도록 학습)

· Transfer Learning : 학습이 완료된 Encoder를 가져와 새로운 작업(Downstream Task)에 활용

· CLIP은 Zero-Shot Clssification 가능

※ Zero-Shot : 추가 학습 없이 Text Prompt만 이용하여 분류

** 학습된 Encoder는 그대로 사용하지만, 마지막 FC Layer는 새로운 Task마다 학습 필요

> Language Model

· Pretraining을 Next Token Prediction으로 수행한 후, Prompt만 변경하여 다양한 작업을 Zero-Shot으로 수행 가능

> Prompt Ensembling

· Class를 표현할 때 한 문장만 사용하면 해당 문장이 가진 표현에만 의존 = 표현이 편향됨

∴ 여러 Prompt를 사용해서 평균을 내어 Class를 대표하는 하나의 Text Embedding을 생성 = Prompt Ensembling

▣ CoCa(Contrastive Captioner)

· CLIP에 Text Decoder를 추가하여 이미지-Text 정렬뿐만 아니라 이미지 Caption 생성도 함께 학습한 Model
    (CLIP : 이미지를 검색하고 Zero-Shot Classification은 가능하지만 문장 생성 불가)

· Contrastive Loss : 이미지와 Text를 같은 Embedding 공간에 정렬하는 능력을 유지

· Captioning Loss : 이미지에 대한 자연어 설명을 생성하도록 학습

▣ CLIP Style Model Pros & Cons

△ Dot Product : 이미지와 Text의 내적만으로 Similarity를 계산하여 단순하고 학습과 추론이 빠름

△ Open Vocabulary : 새로운 Class를 다시 학습할 필요 없이, Text Prompt만 작성하면 새로운 Class도 Zero-Shot으로 분류 가능

△ 다른 Model과 결합 : 다른 Model과 쉽게 결합하여 성능 향상 가능

▼ CLIP은 개념을 학습하는 데 Batch Size에 너무 많이 의존(Batch가 클수록 더 세밀한 개념 학습 가능)

    → Batch 안에서 Negative를 비교하면서 배우는데, 매우 미세한 차이를 가진 문장이 같은 Batch 안에 동시에 들어올 확률↓

▼ 이미지 Level Caption의 한계 : 이미지 전체 Caption만으로는 충분한 Supervision X

    (Ex. 위치, 영역 정보 등 세밀한 시각 정보 학습 불가)

▼ Dataset 한계 : 아무리 많은 데이터를 사용해도 모든 개념과 상황을 포함 불가

▣ VLM(Vision Language Model) - LLaVA

· Text만 입력 받는 LLM과 달리 이미지와 Text를 함께 입력 받고, Text를 출력하는 Model

> Penultimate Layer

· Penultimate Layer의 Patch Token은 공간 정보와 의미 정보를 모두 잘 보존하고 있음

· Final Layer의 Patch Token은 CLS Token으로 정보가 집중되면서 공간 정보가 많이 손실됨

∴ LLaVA는 Penultimate Layer의 Patch Token을 사용하여 LLM이 이미지의 세부 위치와 객체 정보를 더 잘 이해하도록 함

> Overall Architecture

① 이미 학습된 Pretrained Model을 사용(Vision Encoder : CLIP / LLM : LLaMA)

② CLIP의 이미지 Feature를 LLM 입력 공간으로 변환하기 위해 새로운 Linear Layer 학습

③ Linear Layer와 LLM을 함께 Fine-Tuning(CLIP은 보통 고정)

▣ Flamingo

· Vision Encoder가 추출한 이미지 Feature를 LLM 내부의 여러 Transformer Layer에서 Cross-Attention을 통해 지속적으로 활용

· 입력 = Interleaved Input : 이미지 + Text(번갈아 입력 가능)

· Vision Encoder와 LLM은 고정하고, 새로운 연결 Module을 학습

> Overall Architecture

· Vision Encoder는 이미지 크기에 따라 Patch Token의 개수가 달라질 수 있음

    → LLM은 항상 일정한 개수의 이미지 Token을 받는 것이 효율적이므로 Perceiver Resampler가 항상 일정한 개수로 압축

> Gated Cross-Attention

· Self-Attention만 있어 Text끼리만 참고하는 일반 LLM과 달리 Cross-Attention을 추가하여 Text가 이미지를 참고
· Gate를 통해 이미지 정보를 얼마나 반영할지를 조절

> Training

· 학습 데이터인 이미지와 Text를 하나의 긴 Sequence로 만들어 LLM처럼 Next Token Prediction을 수행

· <image> : 새로운 이미지가 시작됨을 의미 / <EOC> : 문장이 끝남을 의미

> Masked Attention

· 각 Text는 자신가 대응되는 이미지 Feature에만 Cross-Attention

· 다른 이미지에는 Attention하지 않도록 Mask를 적용

> Result

· 단순한 Classification이 아니라 이미지 이해, OCR, 추론, 질의응답 등을 수행 가능

> In-Context Learning

· 추가 학습 없이 Prompt 안에 있는 몇 개의 예시를 참고하여 새로운 문제를 해결

▣ Molmo

· Multi-Modal LLM으로 GPT와 Gemini와 비슷한 목적을 가지지만, 완전한 Open Source Model

· 고품질 Dataset을 기반으로 학습되어, 상대적으로 작은 Model도 경쟁력 있는 성능 보유

▼ GPT, Gemini처럼 매우 큰 Closed Source와 비교하면, 일부 복잡한 추론이나 광범위한 세계 지식에서 차이 발생

▼ 이미지 생성 기능은 없으며, 입력된 이미지를 이해하고 Text를 생성하는 인식 중심 Model

▼ Pointing과 Grounding은 학습 데이터와 해상도에 영향을 받으므로 매우 작은 객체 또는 복잡한 장면에서는 정확도 감소 가능

▣ SAM(Segment Anything Model)

· 특정 Class에 제한되지 않고 다양한 객체를 분할 가능

· Prompt를 입력 받아 원하는 객체의 Mask를 생성하며 학습하지 않은 새로운 객체에도 비교적 높은 일반화 성능 보유

※ Segmentation : 이미지에서 객체의 Pixel 단위 영역(Mask)을 찾는 작업

> Basic Architecture

· Image Encoder : 입력 이미지를 Image Embedding으로 변환

· Prompt Encoder : Prompt를 Embedding으로 변환

· Mask Decoder : 이미지 Embedding과 Prompt Embedding을 결합하여 최종 Segmentation Mask를 생성

· 여러 개의 후보 Mask와 각 Mask의 Confidence Score를 출력

· 학습 시에는 Ground Truth와 가장 일치하는 Mask 하나에 대해서만 Loss를 계산하고, 각 후보 Mask의 Confidence Score도 함께 학습

▣ CuPL(Customized Prompts via Language Model)

· LLM을 이용하여 각 Class에 대한 Prompt를 생성하여 객체의 특징을 포함한 상세한 설명을 Prompt로 사용

    (∵ 짧은 Prompt를 사용하면 CLIP은 단어만으로 객체의 특징을 충분히 이해하기 어려움)

· 생성된 Prompt를 CLIP의 Text Encoder에 입력하여 풍부한 Text Feature를 얻고, 이미지 Feature와의 Matching 성능 향상

▣ VisProg(Visual Programming)

· LLM이 자연어 질문을 여러 개의 작은 Vision Task로 분해하여 Program 형태로 생성

· 각 단계마다 Object Detection, SAM, OCR 등 적절한 Vision Model을 호출하여 실행

· 각 단계의 결과를 순차적으로 결합하여 최종 답을 생성

> Example 1

· 왼쪽과 오른쪽 이미지를 합치면 사람 6명, Boat 2척인지 판단 필요

→ GPT가 Program을 생성하여 결과 판단

> Example 2

· 사막을 푸른 잔디로 바꿔야 함

· GPT가 Program을 생성하여 최종 답을 생성
    ① SAM을 이용해 이미지 속 모든 객체를 분할

    ② Segmentation된 객체 중에서 사막만 선택

    ③ 사막 부분만 Replace

[Thinking]

▣ Transformer

· 입력 문장을 Token으로 나눈 후, Self-Attention을 이용해 Token 간의 관계를 학습하고, 이를 반복적으로 변환하여 문맥을 이해하는 Model

① Tokenization : 입력 문장을 작은 단위인 Token으로 나눔

② Embedding : 각 Token을 숫자 Vector로 변환

③ Positional Encoding / Position Embedding : RNN처럼 순서대로 읽지 않으므로, 각 Token의 위치 정보를 따로 입력

④ Transformer Block 반복

▣ Attention 연산

· 한 Token이 다른 Token들을 얼마나 참고해야 하는지 계산하는 연산

① Embedding된 입력 Vector X → X = [x1, x2, x3]

② Token마다 Q, K, V 생성 → Q = XW_Q, K = XW_K, V = XW_V

    (Q : 찾고 싶은 정보, K : 어떤 정보를 갖고 있는지 나타내는 표식, V : 실제로 전달할 정보)

③ 각 Token이 다른 Token과 얼마나 관련 있는지 Score를 계산하여 Score Matrix 생성 → Score = QK^T

④ 값이 너무 커지지 않도록 Scaling → QK^T / √(d)

⑤ Masking

⑥ Softmax를 적용하여 관련도 점수를 확률로 변환

⑦ Softmax를 적용하여 얻은 Attention Weight와 V를 곱하여 관련도가 높은 Token의 정보를 더 많이 가져옴

▣ LLM Inference(Prefill vs Decode)

> Prefill 단계

· 입력 Prompt 전체를 한 번에 처리하는 단계(병렬성↑)

· 입력 길이가 N인 경우, Model은 N개의 Token에 대해 Attention을 계산(Prompt 전체에 대해 Q, K, V를 생성 → KV Cache에 저장)

· Prompt 안의 모든 Token이 자기 자신과 이전 Token들을 참고 → 연산량 = O(N²) → Prompt 길이가 길수록 무거움

** Masking을 이용해 이전 Token을 참고하는 효과 적용

> Decode 단계

· 새 Token을 하나씩 생성하는 단계를 반복(병렬성↓)

· Prefill 후 답변 Token을 생성한 경우, 그 다음 Token은 자기 자신과 이전 Token을 참고해 생성

    → Model은 전체 문장을 다시 처음부터 계산 X(∵ 이미 Prompt의 K, V의 Cache에 저장되어 있음)

        ∴ 새 Token의 Q, K, V만 계산하고, 기존 K, V는 KV Cache를 재사용

▣ KV Cache

· 이전 Token들의 Key와 Value를 저장해두는 Memory로 Layer 별로 존재

· LLM은 다음 Token을 만들 때 이전 모든 Token을 참고(Cache가 없는 경우 매번 이전 Token들의 K, V를 다시 계산)

· Decode 단계에 의해 생성된 Token의 K, V를 Cache에 추가 → Decode가 진행될수록 KV Cache 크기↑

** Attention Output을 계산할 때 현재 Token의 Query 하나만 필요하므로 KV Cache에 저장할 필요 X

△ Decode 속도↑(∵ KV Cache에 의해 재계산 X)

▼ Sequence가 길어질수록 Cache Memory 사용량↑

[Reference]

· Stanford CS231N