(프로젝트 진행 중)

RAG(Retrieval-Augmented Generation) 는 외부 지식소스를 검색해서 생성 모델의 입력으로 활용하는 방식으로, 제한된 파라미터 수만으로는 기억할 수 없는 정보를 외부 문서에서 보완하는 방법입니다.

CRUD란 “Create, Read, Update, Delete”의 약어로 데이터베이스와 같은 시스템에서 기본적인 데이터 관리 기능을 의미

RAG

구성요소

• Retriever - 질문과 유사한 문서들을 벡터 기반으로 검색(e.g. FAISS,Weaviate)
• Generator - 검색한 문서를 바탕으로 LLM이 자연어 응답 생성

  장점

  LLM이 최신 문서나 사내 문서를 바탕으로 정교한 응답 가능

DB

• 형태 - MySQL, PostgerSQL 등 SQL 문으로 작업
• 주요 작업 - Create, Read, Update, Delete(CRUD)
• 장점 - 빠르고 정확한 정형 데이터 검색 및 보관

추후 RAG 추가 예정

25년 5월에 Data 없이 AI에게 자기 합습 시키는 방법이 나와 다루어 보려고합니다.

Absolute Zero 패러다임은 외부 데이터 없이 모델이 스스로 학습할 작업을 생성하고 해결하는 자기 주도 학습 방식입니다. 즉, 사람이 설계한 데이터셋 없이도 모델이 문제를 만들고 풀면서 추론 능력을 향상시키는 새로운 접근입니다.

핵심 개념: Absolute Zero 패러다임

Absolute Zero는 모델이 학습 가능한 작업을 스스로 생성하고 해결하는 자기 주도 학습 방식입니다.

• 외부의 라벨링된 데이터가 없어도 성능이 향상됩니다.
• 모델이 직접 문제를 만들고 풀면서 추론 능력을 키웁니다.

AZR의 구조: Proposer, Solver, Verifier

학습되는 작업 유형

1. Deduction (연역)
   : 프로그램 + 입력 → 출력을 추론
2. Abduction (가추)
   : 프로그램 + 출력 → 가능한 입력을 추론
3. Induction (귀납)
   : 여러 입력-출력 쌍 → 프로그램을 합성

학습 전략: 강화 학습 기반 보상

AZR은 다중 작업 학습을 위해 TRR++ (Task-Relative REINFORCE++)라는 보상 추정기를 사용합니다.

$A_{\text{norm}}^{\text{task,role}} = \frac{r - \mu_{\text{task,role}}}{\sigma_{\text{task,role}}}$

• r: 해당 step 또는 episode에서 받은 실제 보상값
• $\mu_{task,role}$ : 특정 작업(task)과 역할(role)에 대한 보상의 평균값
• $\sigma_{task,role}$ : 해당 task-role 조합의 보상 표준편차
• $𝐴_{norm}$ : 정규화된 advantage (보상 이득)

Proposer 보상 설계

너무 쉽거나 너무 어려운 문제는 보상이 없습니다. Solver가 적당히 성공하는 문제를 만들면 보상을 많이 받습니다.

$r_{\text{propose}} = \begin{cases} 0, & \text{if } \bar{r}{\text{solve}} = 0 \text{ or } \bar{r}{\text{solve}} = 1 \ 1 - \bar{r}_{\text{solve}}, & \text{otherwise}\end{cases}$

• $𝑟_{propose}$ : Proposer가 받는 보상
• $\bar r_{solve}$ : 해당 문제가 Solver에 의해 해결된 평균 비율 (즉, 여러 시도 중 Solver가 얼마나 자주 성공했는지를 나타냄)

동작 원리:

• Solver가 항상 틀리면 : $\bar r_{solve} = 0 -> 𝑟_ {propose} = 0$
• Solver가 항상 맞히면 : $\bar r_{solve} = 1 -> 𝑟_ {propose} = 0$
• Solver가 약 50% 확률로 맞히면 : $\bar r_{solve} = 0.5 -> 𝑟_ {propose} = 0.5 -> 최대 보상$

작업 유효성 검증

• 무결성: 코드 실행 여부
• 안전성: 무한 루프/치명적 오류 여부
• 결정론적 실행: 동일한 입력 → 항상 동일한 출력 비결정론적 프로그램은 실행 결과가 매번 달라질 수 있으므로 배제 $ \forall p \in P_{\text{deterministic}}, \forall i \in I, (\lim_{j \to \infty} p(i)^{(1)} = p(i)^{(2)} = \dots = p(i)^{(j)})$

• 𝑝 : 생성된 프로그램
• $𝑃_{deterministic}$ : 결정론적 프로그램의 집합
• 𝑖∈𝐼: 입력 집합
• $p(i)^{(i)}$ : 동일 입력 𝑖에 대해 프로그램 𝑝를 𝑗번째 실행한 결과

실험 결과 및 특징

• 외부 데이터 없이도 성능 향상이 가능함을 입증
• 기존 제로샷 모델보다 추론 능력 우위
• 다양한 LLM 구조와 호환 가능 (예: Mistral)
• 모델 크기 증가 시 선형 성능 향상
• 제안자가 난이도 조절을 자동으로 학습

요약

• 인간의 레이블이 없어도 AI가 스스로 문제를 만들고 풀며 학습
• 추론 능력 향상 중심의 새로운 학습 프레임워크
• 향후 코드 생성, 수학 추론 등 고난이도 작업에 확장성 기대

1. Latent이란?

Latent Variable은 데이터에서 직접 관측되지 않지만, 모델이 학습 과정에서 유용한 특징(feature)으로 활용하는 변수입니다.

e.g.

• 사람의 감정을 예측하는 모델에서, "행복도" 같은 값은 직접 측정할 수 없지만(관측 불가능), 얼굴 표정이나 음성 톤 등의 데이터를 이용해 추론할 수 있습니다.

• NLP에서는 단어 자체보다 문장의 "의도(intention)" 같은 것을 Latent Variable로 간주할 수 있습니다.

2. DeepSeek의 MLA (Multi-Head Latent Attention)

DeepSeek의 MLA는 기존의 Self-Attention 메커니즘을 확장한 개념입니다. 기존 Transformer의 Self-Attention은 입력 토큰 간의 관계를 직접 학습하는 방식입니다. 하지만 MLA는 Latent Variable을 추가로 활용하여 좀 더 풍부한 표현 학습을 가능하게 합니다.

기존 Self-Attention

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

• $Q - W_QX$
• $K - W_KX$
• $V - W_VX$ 즉, 입력 𝑋 를 선형 변환하여 Q, K, V를 생성한 후, Query-Key 유사도를 기반으로 가중치를 계산하고 Value에 적용하는 방식입니다. 여기서 Query (Q), Key (K), Value (V) 는 주어진 입력 토큰에서 계산됩니다.

Multi-Head Latent Attention (MLA)

MLA는 Latent Variable $L$을 추가하여 기존 Self-Attention보다 효율적인 정보를 학습하도록 합니다.

(1) Latent Variable 생성

입력 𝑋 를 Latent Space로 변환하는 과정을 추가합니다.

$L = f(W_L X)$

즉, $W_L$을 통해 입력 𝑋를 압축하여 중요한 특징만을 포함하는 잠재 변수 𝐿을 생성합니다.

(2) Latent Variable을 활용한 Attention 연산 기존 Attention 연산에서 Key 𝐾 대신 𝐿을 사용합니다.

$Attention(Q, K, L) = \text{softmax} \left( \frac{QL^T}{\sqrt{d_k}} \right) L$

• 직접적인 토큰 간의 관계가 아닌 Latent Variable을 통해 학습하여 더 좋은 일반화 성능을 보입니다.
• 계산량을 줄이면서도 중요한 정보만 추출하는 역할을 합니다.

3. PyTorch 코드 구현

단일

import torch
import torch.nn as nn

class HeadLatentAttention(nn.Module):
    def __init__(self, embed_dim, num_heads, latent_dim):
        super().__init__()
        self.num_heads = num_heads
        self.embed_dim = embed_dim
        self.latent_dim = latent_dim

        # Query, Key, Value 변환을 위한 선형 레이어
        self.W_q = nn.Linear(embed_dim, latent_dim)  # embed_dim -> latent_dim으로 변경
        self.W_k = nn.Linear(embed_dim, embed_dim)
        self.W_v = nn.Linear(embed_dim, embed_dim)

        # Latent Variable 생성
        self.latent_proj = nn.Linear(embed_dim, latent_dim)

        # 최종 출력 변환
        self.out_proj = nn.Linear(embed_dim, embed_dim)

    def forward(self, x):
        batch_size, seq_len, embed_dim = x.shape

        # Query를 latent_dim으로 투영하도록 변경
        Q = self.W_q(x)  # (batch_size, seq_len, latent_dim)
        K = self.W_k(x)  # (batch_size, seq_len, embed_dim)
        V = self.W_v(x)  # (batch_size, seq_len, embed_dim)

        # Latent Variable 생성
        L = self.latent_proj(x).mean(dim=1, keepdim=True)  # (batch_size, 1, latent_dim)

        # Latent Variable과 Query 간의 Attention 계산 (이제 차원이 맞습니다)
        attn_scores = torch.matmul(Q, L.transpose(-2, -1)) / (self.latent_dim ** 0.5)  # (batch_size, seq_len, 1)
        attn_weights = torch.softmax(attn_scores, dim=1)  # (batch_size, seq_len, 1)

        # Value와 attention weights를 곱합
        output = attn_weights.transpose(-2, -1) @ V  # (batch_size, 1, embed_dim)

        # 최종 출력 변환
        output = self.out_proj(output)  # (batch_size, 1, embed_dim)

        return output


# 테스트 실행
batch_size = 2
seq_len = 5
embed_dim = 32
latent_dim = 16
num_heads = 4

x = torch.randn(batch_size, seq_len, embed_dim)  # 입력

mla = MultiHeadLatentAttention(embed_dim, num_heads, latent_dim)
output = mla(x)

print(output.shape)  # (batch_size, 1, embed_dim)

코드 설명

1. Query, Key, Value를 계산

• 입력 𝑋를 선형 변환하여 Q, K, V를 생성

2. Latent Variable 𝐿생성

• 입력 𝑋를 latent_proj를 통해 변환 후, 평균 연산을 적용하여 잠재 변수 𝐿을 만듦

3. Latent Variable을 이용한 Attention 계산

• 와 𝐿 이의 유사도(attention score) 계산
• Softmax를 적용하여 가중치(attention weight) 생성

4. Latent Variable을 활용한 최종 출력 생성

• V와 Attention Weight를 곱해 Latent Context를 계산
• 기존 입력의 평균과 결합하여 최종 출력을 만듦

멀티 헤드

import torch
import torch.nn as nn

class MultiHeadLatentAttention(nn.Module):
    def __init__(self, embed_dim, num_heads, latent_dim):
        super().__init__()
        self.num_heads = num_heads
        self.embed_dim = embed_dim
        self.latent_dim = latent_dim
        self.head_dim = latent_dim // num_heads

        # Query, Key 투영
        self.q_proj = nn.Linear(embed_dim, latent_dim)
        self.k_proj = nn.Linear(embed_dim, latent_dim)
        self.v_proj = nn.Linear(embed_dim, embed_dim)

        # Latent Variable 생성
        self.latent_proj = nn.Linear(embed_dim, latent_dim)

        # 출력 투영
        self.out_proj = nn.Linear(embed_dim, embed_dim)

    def forward(self, x):
        batch_size, seq_len, _ = x.shape

        # Query, Key, Value 투영
        q = self.q_proj(x).view(batch_size, seq_len, self.num_heads, self.head_dim)
        k = self.k_proj(x).view(batch_size, seq_len, self.num_heads, self.head_dim)
        v = self.v_proj(x)

        # Latent Variable 생성 (시퀀스 차원에서 평균)
        latent = self.latent_proj(x).mean(dim=1, keepdim=True)  # [batch_size, 1, latent_dim]
        latent = latent.view(batch_size, 1, self.num_heads, self.head_dim)

        # 차원 재배열 (multi-head attention 계산을 위해)
        q = q.transpose(1, 2)  # [batch_size, num_heads, seq_len, head_dim]
        k = latent.transpose(1, 2)  # [batch_size, num_heads, 1, head_dim]

        # Scaled Dot-Product Attention
        attn_scores = torch.matmul(q, k.transpose(2, 3)) / (self.head_dim ** 0.5)  # [batch_size, num_heads, seq_len, 1]
        attn_weights = torch.softmax(attn_scores, dim=2)  # [batch_size, num_heads, seq_len, 1]

        # 원래 시퀀스 차원으로 재배열
        attn_weights = attn_weights.transpose(1, 2).mean(dim=2, keepdim=True)  # [batch_size, seq_len, 1, 1]
        attn_weights = attn_weights.squeeze(-1)  # [batch_size, seq_len, 1]

        # Weighted sum
        output = torch.bmm(attn_weights.transpose(1, 2), v)  # [batch_size, 1, embed_dim]

        # 출력 투영
        output = self.out_proj(output)  # [batch_size, 1, embed_dim]

        return output


# 테스트 실행
batch_size = 2
seq_len = 5
embed_dim = 32
latent_dim = 16
num_heads = 4

x = torch.randn(batch_size, seq_len, embed_dim)
mla = MultiHeadLatentAttention(embed_dim, num_heads, latent_dim)
output = mla(x)

print(output.shape)  # 예상 출력: torch.Size([2, 1, 32])

결과

이 방식은 기존 Transformer보다 계산량이 줄어들면서도, Latent Variable을 활용하여 더 강력한 표현 학습이 가능하도록 설계되었습니다. DeepSeek-V3에서 사용한 MLA의 개념을 단순화한 구현이며, 실제 모델에서는 Multi-Head 방식이 더 복잡하게 적용될 수 있습니다.

MoE

MoE (Mixture of Experts)란

MoE(Mixture of Experts)는 여러 개의 전문가(Experts) 모델을 두고, 입력에 따라 적절한 전문가를 선택해 학습과 예측을 수행하는 모델 구조입니다. -> 큰 모델을 효율적으로 사용하면서 연산량을 줄일 수 있음

MoE의 핵심 개념

여러 개의 전문가(Experts) 신경망이 존재 입력 데이터를 보고 Gating Network가 가장 적절한 전문가를 선택 선택된 전문가만 활성화되어 예측 수행 (모든 전문가가 활성화되는 것이 아님) 특정 데이터 유형에 특화된 전문가를 선택하므로 효율적

MoE 구조

Experts (전문가 네트워크)

각각 특정한 데이터 패턴을 학습하는 전문가 네트워크들 예를 들어, 자연어 처리 모델에서

• Expert A: 문법적 분석
• Expert B: 감정 분석
• Expert C: 요약

• 입력 데이터에 따라 적절한 전문가를 선택해서 사용

Gating Network (게이팅 네트워크)

입력 데이터를 보고 어떤 전문가를 선택할지 결정 하는 네트워크 Softmax를 이용해 각 전문가에 대한 가중치 계산 일부 전문가만 활성화되도록 하여 연산량 감소

Sparse Activation (희소 활성화)

모든 전문가를 사용하는 것이 아니라 소수의 전문가만 활성화 예를 들어, 총 16개의 전문가 중 2~4개만 사용 모델이 크더라도 연산량이 줄어듦

MoE 장단점

MoE의 장점

• 효율적인 연산: 일부 전문가만 활성화되므로 계산량이 줄어듦
• 특정 태스크에 특화된 학습 가능: 각 전문가가 특정 데이터 패턴을 더 잘 학습
• 대규모 모델 확장 가능: 전문가 수를 늘려도 일부만 사용하므로 메모리 사용 절약

MoE의 단점

• Gating Network가 잘못 동작하면 비효율 발생
• 일부 전문가만 자주 선택되면 학습 불균형 문제 발생
• 일반적인 Dense 모델보다 구현이 복잡

구현 방법

import torch
import torch.nn as nn
import torch.nn.functional as F

# Expert 정의
class ExpertMLP(nn.Module):
    def __init__(self, input_dim, output_dim):
        super(ExpertMLP, self).__init__()
        self.fc = nn.Linear(input_dim, output_dim)

    def forward(self, x):
        return F.relu(self.fc(x))

# GateNetwork 정의
class GateNet(nn.Module):
    def __init__(self, input_dim, num_experts):
        super(GateNet, self).__init__()
        self.fc = nn.Linear(input_dim, num_experts)

    def forward(self, x):
        return F.softmax(self.fc(x), dim=-1)

# MoE 모델 정의
class MoE(nn.Module):
    def __init__(self, input_dim, output_dim, num_experts):
        super(MoE, self).__init__()
        self.experts = nn.ModuleList([Expert(input_dim, output_dim) for _ in range(num_experts)])
        self.gate = GateNetwork(input_dim, num_experts)

    def forward(self, x):
        gate_weights = self.gate(x)  # 게이트 네트워크를 통해 전문가별 가중치 계산
        expert_outputs = torch.stack([expert(x) for expert in self.experts], dim=1)
        output = torch.sum(gate_weights.unsqueeze(-1) * expert_outputs, dim=1)  # 전문가 출력에 가중치를 곱해 최종 출력 계산
        return output

# 모델 생성
model = MoE(input_dim=128, output_dim=10, num_experts=4)
x = torch.randn(32, 128)  # Batch size = 32
output = model(x)

결론

• MoE는 여러 전문가 네트워크를 활용하여 효율적이고 확장 가능한 모델 구조
• Sparse Activation을 통해 연산량 절감
• Gating Network가 중요 → 잘못 학습되면 성능 저하 가능
• DeepSeek-V3 같은 최신 모델에서도 MoE를 활용하여 빠르고 정확한 예측 가능

Multi-Token Prediction (MTP)

Multi-Token Prediction (MTP)란

기존의 Autoregressive 방식(한 번에 한 토큰씩 예측)과 달리, MTP는 한 번에 여러 개의 토큰을 동시에 예측하는 방법입니다. -> 한 번의 Forward Pass에서 여러 토큰을 예측하여 속도를 향상

MTP의 구조 및 개념

기존 Autoregressive 방식 vs. MTP

MTP 방식의 동작 원리

• 예측할 토큰 수(k)를 설정
• 모델이 한 번의 Forward Pass에서 k개의 토큰을 동시에 예측
• 각 토큰의 위치에 대해 병렬적으로 Loss를 계산하고 업데이트

• 즉, 예측 속도를 높이기 위한 방법으로 사용됨

MTP의 장점

• 속도 향상: 한 번에 여러 개의 토큰을 예측하므로 텍스트 생성 속도가 증가
• 더 나은 병렬 처리: GPU 활용도가 증가하여 연산 효율성이 높아짐
• 디코딩 과정의 연산 감소: Autoregressive 방식보다 예측 과정이 최적화됨

MTP의 단점

정확도 저하 가능성 *여러 토큰을 동시에 예측하면 문맥을 정확하게 반영하기 어려움

• 특히, 긴 문장에서 문맥 오류 발생 가능 -> Beam Search 등과 결합하기 어려움
• 기존 Greedy Decoding, Beam Search 같은 기법과 자연스럽게 통합하기 어려움 -> 모델 학습이 더 복잡함
• 기존 방식보다 학습 과정이 더 정교하게 조정되어야 함

MTP 구현 방법

기존 Autoregressive 방식 (GPT-Style)

import torch
import torch.nn as nn

class AutoRegressiveModel(nn.Module):
    def __init__(self, vocab_size, hidden_dim):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, hidden_dim)
        self.rnn = nn.GRU(hidden_dim, hidden_dim, batch_first=True)
        self.fc = nn.Linear(hidden_dim, vocab_size)

    def forward(self, x):
        x = self.embedding(x)
        output, _ = self.rnn(x)
        output = self.fc(output[:, -1, :])  # 마지막 토큰만 예측
        return output  # (batch_size, vocab_size)

# 모델 생성
model = AutoRegressiveModel(vocab_size=5000, hidden_dim=256)

MTP 방식 (Multi-Token Prediction)

class MultiTokenPredictionModel(nn.Module):
    def __init__(self, vocab_size, hidden_dim, k=5):  # k: 동시에 예측할 토큰 수
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, hidden_dim)
        self.rnn = nn.GRU(hidden_dim, hidden_dim, batch_first=True)
        self.fc = nn.Linear(hidden_dim, vocab_size * k)  # k개의 토큰을 예측

    def forward(self, x):
        x = self.embedding(x)
        output, _ = self.rnn(x)
        output = self.fc(output[:, -1, :])  # (batch_size, vocab_size * k)
        output = output.view(output.size(0), -1, vocab_size)  # (batch_size, k, vocab_size)
        return output  # k개의 토큰을 예측하는 형태

# 모델 생성
model = MultiTokenPredictionModel(vocab_size=5000, hidden_dim=256, k=5)

기존 Autoregressive 모델과 차이점으로는

• 기존 모델은 한 번에 1개의 토큰을 예측
• MTP 모델은 한 번에 k개의 토큰을 예측

결론

• MTP는 기존 Autoregressive 방식보다 텍스트 생성 속도를 증가시킴
• 여러 토큰을 병렬 예측하여 디코딩 속도를 높일 수 있음
• 하지만 정확도 저하 가능성이 있고 Beam Search 같은 방식과 결합이 어려움
• 최신 대규모 모델에서도 효율적인 디코딩 방식으로 연구 중

Greedy Decoding

한 번에 가장 확률이 높은 단어만 선택하는 방식

• 매 단계에서 가장 확률이 높은 단어를 선택
• 선택한 단어를 기반으로 다음 단어를 예측

• 장점*
• 연산이 간단하고 빠름
• 구현이 쉬움

• 단점*
• 항상 최적의 문장을 생성하는 것이 아님 (전역 최적 해를 찾지 못할 수도 있음)
• 초반에 잘못된 단어를 선택하면 수정 불가능

  Beam Search

  매 단계에서 확률이 높은 여러 개의 후보를 유지하면서 탐색하는 방식
• 한 번에 하나의 최적 경로만 따르는 Greedy Decoding과 달리, Beam Search는 여러 개의 후보(Beam)를 유지하면서 가장 좋은 문장을 탐색
• Beam Width 𝑘를 설정하여, 각 단계에서 확률이 높은 𝑘개의 문장을 유지

• 장점*
• Greedy Decoding보다 더 좋은 문장을 생성할 확률이 높음
• 전역 최적 해를 찾을 가능성이 증가

• 단점*
• 연산량이 많음 (Beam Width가 클수록 계산 비용 증가)
• 완전한 최적 해를 보장하지는 않음

DeepSeek-V3는 총 671억 개의 매개변수를 가진 Mix-of-Experts(MoE) 기반의 대규모 Transformer 언어 모델입니다. 이 모델은 DeepSeek-R1의 지식을 전수받아 질문 응답, 코드 생성, 수학 문제 해결 등 다양한 작업에 최적화될 수 있도록 설계되었습니다.

아키텍처 개요 (Transformer with MHLA & MoE)

DeepSeek-V3는 기존 Transformer 구조를 기반으로 하지만, 보다 효율적인 추론 및 학습을 위해 새로운 기법을 도입했습니다.

• MHLA(Multi-Head Latent Attention): 기존 Self-Attention보다 계산량을 줄이고 강력한 문맥 이해를 가능하게 함
• DeepSeekMoE(Mixture of Experts): MoE를 개선하여 전문가의 부하 균형을 최적화하고 학습 효율성 증가
• 부하 균형 전략 (Load Balancing without Auxiliary Loss): 부하 불균형 문제를 해결하는 혁신적인 기법 적용

이러한 개선 덕분에 DeepSeek-V3는 더 빠른 연산 속도와 높은 학습 효율성을 갖추게 되었습니다.

기존 Attention과 차이점 (MHLA 적용)

기존 Transformer는 Multi-Head Self-Attention(MHSA) 방식으로 토큰 간 관계를 직접 계산합니다. 하지만 이 방식은 계산량이 O(N²)으로 커지는 단점이 있습니다.

MHLA(Multi-Head Latent Attention) 는 이를 개선하여 잠재 공간(latent space)에서 추가적인 추론을 수행하는 방식으로 최적화되었습니다.

• O(N²) -> O(N log N) 수준으로 연산량 감소 -> 대용량 데이터에서도 안정적 학습 가능 -> 강력한 문맥 이해 및 추론 능력 확보

결과적으로, DeepSeek-V3는 기존 MHSA보다 빠르면서도 더 정교한 추론이 가능한 모델입니다.

기존 FFN과의 차이점: DeepSeekMoE(Mixture of Experts)

1) 기존 MoE 모델과의 차이점: DeepSeekMoE(Mixture of Experts) FFN 블럭은 종래 MoE(Mixture of Experts)에서 개량된 DeepSeekMoE(Mixture of Experts) 아키텍처를 기반으로 작동합니다. 기존 MoE보다 더 정밀한 전문가(Finer-grained Experts) 를 사용하며, 일부 전문가를 공유(Shared Experts) 로 설정하여 일관된 성능을 유지합니다. 입력에 따른 전문가 선택 gating은 토큰과 전문가 간 연관도를 시그모이드 함수로 계산하고, 정규화를 적용하여 최적의 전문가를 선택합니다. 이러한 개선 덕분에 추론 및 학습 효율성이 증가하고, MoE 아키텍처의 단점(불균형 로드, 성능 저하)을 완화합니다.

MoE(Mixture of Experts)란 MoE는 필요한 전문가(Expert)만 선택해서 계산하는 방식입니다. 즉, 모든 계산을 한 번에 하지 않고, 가장 적절한 전문가들만 골라서 사용합니다. 기존 MoE는 전문가 간 부하 불균형 문제(일부 전문가가 너무 많이 사용됨)가 있었습니다. DeepSeek-V3의 MoE 개선점

• 더 정교한 전문가(Finer-Grained Experts) 사용
• 일부 전문가를 공유(Shared Experts)해서 성능 유지
• 부하를 자동으로 조절하는 로드 밸런싱 기법 도입
• 토큰을 절대 버리지 않음 (No Token Dropping)
• 이런 개선 덕분에 학습 속도가 빠르면서도 성능이 뛰어난 모델

2) Auxiliary-Loss-Free Load Balancing (보조 손실 없는 부하 균형 조정)

• 기존 MoE 모델은 전문가 간 부하 불균형을 해결하기 위해 보조 손실(Auxiliary Loss)을 사용했지만, DeepSeek-V3는 보조 손실 없이도 부하를 동적으로 균형 맞추는 기법을 도입했습니다.
• 각 전문가에 편향 값을 추가하여 토큰-전문가 매칭을 조정하고, 과부하된 전문가의 편향을 줄이며 저부하 전문가의 편향을 증가시켜 자동으로 부하를 균형 있게 조정합니다.

3) Sequence-Wise Auxiliary Loss(시퀀스 단위 부하 균형)

• 부하 균형을 더욱 정교하게 유지하기 위해, 각 시퀀스 내에서 전문가 간의 부하가 특정 전문가에 집중되지 않도록 보완적인 부하 균형 손실을 적용했습니다.
• 기존 Auxiliary Loss처럼 성능을 저하시키지 않으면서도, 필요한 범위 내에서 최소한의 손실만 추가하여 균형을 조절합니다.

4) 노드 제한 라우팅 (Node-Limited Routing)

• 토큰이 특정 전문가에게 과도하게 몰리는 것을 방지하고, 통신 비용을 줄이기 위해 토큰을 제한된 개수의 노드에만 할당하는 기법을 도입했습니다.
• 이를 통해 연산-통신 병목을 최소화하여 모델 학습 속도를 최적화할 수 있습니다.

5) 토큰 드롭 방지 (No Token-Dropping)

• 기존 MoE 모델에서는 부하 불균형 문제로 인해 일부 토큰이 학습 과정에서 제거되었지만, DeepSeek-V3는 모든 토큰을 유지하여 정보 손실 없이 안정적인 학습이 가능하도록 설계되었습니다.
• 추론(Inference) 과정에서도 토큰 드롭 없이 균형을 유지하는 배포 전략을 적용하여 성능 저하를 방지합니다.

요약

1) DeepSeekMoE: FFN을 대체하는 새로운 MoE 구조 MoE(Mixture of Experts)는 FFN(Feed Forward Network)을 여러 개의 전문가(Experts)로 대체하는 방식입니다. 하지만 기존 MoE에는 부하 불균형 문제 및 성능 저하라는 단점이 있었습니다.

DeepSeekMoE 개선 사항

1-1) Finer-Grained Experts → 더 정밀한 전문가 사용으로 모델 성능 향상 1-2) Shared Experts 도입 → 일부 전문가를 공유하여 일관된 성능 유지 1-3) Sigmoid 기반 Gating → 토큰과 전문가의 연관도를 정규화하여 최적의 전문가 선택

이러한 개선을 통해 MoE의 단점을 보완하면서도 학습 및 추론 효율성을 높였습니다.

2) 부하 균형 (Load Balancing without Auxiliary Loss) 기존 MoE 모델에서는 전문가 간 부하 불균형을 해결하기 위해 Auxiliary Loss를 사용했습니다. 하지만 DeepSeek-V3는 보조 손실 없이도 부하를 자동으로 균형 조정하는 기법을 도입했습니다.

• Bias 값 추가 → 토큰-전문가 매칭을 조정하여 균형 유지
• Sequence-Wise Auxiliary Loss → 시퀀스 내에서 전문가 부하를 분산
• Node-Limited Routing → 특정 전문가에 토큰이 몰리는 현상을 방지
• No Token-Dropping → 정보 손실 없이 모든 토큰을 유지하며 안정적인 학습 가능

이러한 전략 덕분에 부하 균형을 유지하면서도 성능 저하 없이 MoE를 효과적으로 활용할 수 있습니다.

다중 토큰 예측 (Multi-Token Prediction, MTP)

DeepSeek-V3는 기존의 단일 토큰 예측 방식을 확장하여 여러 개의 토큰을 동시에 예측하는 Multi-Token Prediction(MTP) 기법을 도입했습니다.

• 학습 신호 밀도 증가 -> 데이터 효율성 극대화
• Transformer 블록 공유 -> 추가적인 학습 비용 없이 성능 향상
• Causal Chain 유지 -> 논리적인 문맥 이해 강화

MTP는 교차 엔트로피 손실(Cross-Entropy Loss)과 결합하여 최적화되며, 추론 과정에서는 Speculative Decoding을 활용해 생성 속도를 최적화할 수 있습니다. 결과적으로, 더 빠르고 정교한 예측이 가능해졌습니다.

다중 토큰 예측 (Multi-Token Prediction, MTP)란 일반적인 AI 모델은 한 번에 하나의 단어(토큰)만 예측합니다. 반면 DeepSeek-V3는 한 번에 여러 개의 단어를 동시에 예측하는 Multi-Token Prediction (MTP) 기술을 사용합니다. MTP의 장점

• 한 번에 여러 단어를 예측하니 학습 속도가 빠름
• 문맥을 더 잘 이해해서 더 자연스러운 문장을 생성할 수 있음
• Speculative Decoding 기법을 사용해 추론 속도도 최적화

결론

DeepSeek-V3는 기존 Transformer 기반 모델의 한계를 극복하기 위해 MHLA, DeepSeekMoE, 부하 균형 전략, MTP 기법 등을 적용하여 더 강력하고 효율적인 AI 모델로 발전하였습니다.

• 기존 Attention보다 효율적인 MHLA 적용
• MoE의 단점을 개선한 DeepSeekMoE 구조
• 부하 균형 최적화를 통한 안정적인 전문가 선택
• MTP 기법을 활용한 빠르고 정교한 예측 능력

이러한 특징 덕분에 DeepSeek-V3는 자연어 처리(NLP), 코드 생성, 문제 해결 등 다양한 AI 작업에서 최적의 성능을 발휘할 것으로 기대됩니다.

성능 차이

GPU|A4000|RTX 3060 * 2 ---|---| 딥러닝 (PyTorch, TensorFlow)|더 나은 메모리 관리, 대형 모델 처리 가능|두 개의 GPU를 활용한 병렬 처리 가능하지만 VRAM 제한 영상/3D 렌더링 (Blender, Octane, Redshift)|GPU 하나에서 고용량 씬 처리 가능, 안정적|두 개의 GPU를 활용할 수 있으나 NVLink 미지원으로 메모리 공유 불가능 게임 (4K, 레이 트레이싱)|게임 성능은 다소 낮음|2개를 활용하는 SLI 미지원으로 사실상 단일 3060과 큰 차이 없음 코딩/과학 연산 (CUDA, MATLAB)|단일 카드로 고성능 제공|두 개의 GPU를 활용하는 코드는 성능 향상 가능

주의사항

단일 GPU(A4000, 16GB)

• 하나의 GPU가 전체 16GB VRAM을 사용 가능
• 큰 모델이나 대용량 데이터 처리가 가능

RTX 3060 * 2 (멀티 GPU, 각각 12GB)

• VRAM이 합쳐지지 않음 → 각 GPU는 독립적으로 12GB씩 사용
• 모델이나 데이터가 단일 GPU의 VRAM(12GB)을 초과하면 오류 발생
• 멀티 GPU 학습 시 데이터가 두 개의 GPU에 동일하게 올라가야 하므로 VRAM이 두 배가 되지 않음

NVLink

NVLink는 NVIDIA의 고속 GPU 간 통신 기술로, 두 개 이상의 GPU가 더 빠르게 데이터를 주고받을 수 있도록 해줍니다. 일반적인 PCIe 인터페이스보다 더 높은 대역폭을 제공하여, VRAM 공유 및 연산 속도 향상이 가능합니다.

NVLink 주요특징

GPU 간 초고속 데이터 전송

• 일반적으로 GPU 간 통신은 PCIe(PCI Express) 를 사용하지만, 속도가 제한적
• NVLink는 PCIe보다 더 빠른 전송 속도를 제공하여 데이터 병목을 줄임

VRAM 공유 가능 (메모리 풀링)

• 일반적으로 멀티 GPU 환경에서는 각 GPU가 개별적인 VRAM을 사용
• NVLink를 사용하면, VRAM을 마치 하나처럼 공유하여 사용할 수 있음

e.g.) 2개 GPU(각 24GB) → 총 48GB로 동작 가능

• 주의 - 소프트웨어(e.g.: CUDA, PyTorch)가 이를 지원해야 함

NVLink가 필요한 경우 vs. 필요 없는 경우

결론

A4000

• VRAM이 중요한 대형 딥러닝 모델 훈련
• 3D 렌더링 작업에서 대형 씬을 처리해야 하는 경우
• 전력 소모를 줄이고 싶은 경우 (140W)

RTX 3060 * 2

• 병렬 연산이 가능한 작업 (분산 가능한 AI inference, CUDA 연산)
• 두 개의 GPU를 독립적으로 사용할 수 있는 경우 (예: 하나는 학습, 하나는 추론)
• 예산이 한정적이며 A4000보다 CUDA 코어 수를 늘리고 싶은 경우

3060 * 2가 A4000보다 CUDA 코어 개수는 많지만, 메모리 제한과 통신 문제 (NVLink 없음) 때문에 고해상도 AI 모델 훈련이나 복잡한 3D 렌더링에서는 A4000이 훨씬 유리

DeepSeek의 기술 발전 과정을 살펴보면, 단순한 성능 개선을 넘어 실용적이고 현실적인 문제 해결에 집중한 접근 방식이 돋보입니다. V3 기술 보고서와 R1 발표 논문을 읽다 보면, 기존 연구들을 기반으로 효과적인 최적화를 수행하며, 실제 AI 시스템에 적용할 수 있는 방법론을 정교하게 발전시켜 왔음을 알 수 있습니다.

구현 방식

DeepSeek이 공개한 코드는 놀라울 정도로 단순하게 구현되었습니다.

• 복잡한 이론은 기존 연구를 활용하면서도, Hugging Face 모듈을 적극적으로 활용.
  • 논문에서 다루지 않았지만, 실용적인 최적화 아이디어를 적용하여 더욱 효과적인 모델을 구축.

소규모 자금, 지원, 인재로도 충분히 가능 하다는 것과 DeepSeek의 접근 방식은 누구나 생각해볼 수 있는 아이디어들이지만, 결국 그 아이디어들을 제대로 구현하고 실용화한 것이 차별점입니다.

요약

DeepSeek-V3

이 모델은 671 억 개의 총 매개 변수(parameter)로 구성된 MOE (Mix-of-Experts) 아키텍처를 사용하며 토큰 당 370 억 개가 활성화됩니다. 14.8 조 개의 다양하고 고품질 토큰으로 사전 학습(pre-training)되었습니다. 이 모델에 지도 미세 조정(SFT) 및 강화 학습(RL)된 DeepSeek-R1로 부터 지식 증류(Knowledge Distillation)하여 사후 학습(post-training)을 대신할 수 있습니다.

특히 DeepSeek-V3은 H800 칩에서 2.788 백만 GPU 시간으로 성능을 달성하여 학습 효율성을 강조했습니다. 평가에 따르면 다른 오픈 소스 모델보다 성능이 우수하고 주요 폐쇄 소스 (Closed Source) 모델의 기능과 일치합니다.

DeepSeek-V3 기술 보고서

지식 증류는 큰 모델(Teacher)에서 작은 모델(Student)로 학습된 정보를 전이하는 기법

• 경량화: 작은 모델이 더 적은 연산량으로 유사한 성능을 내도록 함.
• 추론 속도 개선: 모바일이나 임베디드 환경에서 빠른 추론을 가능하게 함.
• 일반화 능력 향상: Teacher 모델의 학습된 분포를 따라가면서 과적합을 줄일 수 있음.
• 사후 학습*은 모델이 기본 훈련을 마친 후, 추가적인 도메인 적응이나 정제 과정을 수행하는 것
• 도메인 적응(Domain Adaptation): 사전 훈련된 모델을 특정 도메인 데이터로 추가 학습하여 성능을 최적화함.
• 미세 조정(Fine-Tuning): 기존 학습된 모델의 가중치를 일부 고정하거나, 새로운 데이터로 추가 학습하여 성능을 향상함.
• RLHF (Reinforcement Learning with Human Feedback): GPT와 같은 대규모 언어 모델에서, 인간 피드백을 활용하여 모델 출력을 개선하는 기법.
• 퀀타이제이션 후 훈련 (Post-Training Quantization, PTQ): 모델의 가중치를 저비트 형식으로 변환하여 추론 속도를 높이고 메모리 사용을 줄이는 과정.

DeepSeek-R1

이 모델은 DeepSeek-V3을 기반으로 사전 지도 학습 된 미세 조정(SFT)없이 대규모 강화 학습(RL)을 통해 추론 기능을 향상시키는 데 중점을 둡니다. 이 모델의 중간모델 인 DeepSeek-R1-Zero는 강화 학습을 통해 자연스럽게 강력한 추론 행동을 개발했습니다.

그러나 가독성과 언어 혼합에 문제점을 드러냈습니다. 이러한 문제를 해결하기 위해 지도 미세 조정(SFT)이 적용된 DeepSeek-R1을 개발하여 실제 응용 프로그램에 적합한 개선 된 추론 기능을 제공하게 되었습니다.

DeepSeek-R1 기술 보고서

모델과 토크나이저 로딩

AutoTokenizer와 AutoModelForCausalLM을 사용하여 베이스 모델을 불러옵니다. 두가지를 사용하여 모델을 메모리와 계산 비용을 줄이면서 로딩할 수 있습니다.

BASE_MODEL = {파인튜닝 할 모델}
tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL)
model = AutoModelForCausalLM.from_pretrained(
    BASE_MODEL, 
    load_in_8bit=True,  # 메모리 절약
    device_map="auto"
)

• AutoTokenizer.from_pretrained(BASE_MODEL)은 사전 훈련된 모델의 토크나이저를 불러오는 함수입니다.

• load_in_8bit=True는 모델의 가중치를 8-bit 정밀도로 로딩하여 메모리 사용량을 절약합니다. 8-bit로 로딩된 모델은 계산 속도는 느리지만, 메모리 소비가 크게 줄어듭니다.

• device_map="auto"는 모델을 자동으로 GPU에 분배하여, 여러 개의 GPU를 사용할 경우 효율적으로 분산 처리할 수 있게 합니다.

  device_map를 통해 원하는 GPU 또는 CPU에 넣어 학습 시킬 수 있습니다.

LoRA (Low-Rank Adaptation)

LoRA는 모델의 가중치를 저차원 형태로 근사하여 파라미터의 수를 줄이는 방법입니다. 이를 통해 훈련 속도는 빠르고 메모리 효율성은 높여주면서 성능 저하를 최소화할 수 있습니다.

LoRA는 특정 레이어에만 적용할 수 있는데, 이를 통해 모델을 최적화할 수 있습니다. LoRA의 핵심 아이디어는 모델의 weight matrix를 두 개의 작은 행렬 곱으로 근사하는 것입니다. 이렇게 하면 매개변수 수가 줄어듭니다.

lora_config = LoraConfig(
    r=8,  # Rank 값 (작을수록 가볍지만 성능 저하 가능)
    lora_alpha=32,
    target_modules=["q_proj", "o_proj", "k_proj", "v_proj", "gate_proj", "up_proj", "down_proj"],  # 가중치 적용할 레이어
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

• r=8은 LoRA의 rank 값을 설정하는 파라미터입니다. r 값이 낮을수록 모델이 가벼워지지만, 너무 낮으면 성능이 저하될 수 있습니다. 일반적으로 r 값은 실험을 통해 최적화됩니다.

• lora_alpha=32는 LoRA의 학습률을 설정합니다. 이 값은 모델 학습 과정에서의 가중치 업데이트 크기를 조절합니다.

• target_modules는 LoRA를 적용할 레이어들의 목록입니다. 주로 Transformer 모델에서 중요한 역할을 하는 q_proj, o_proj, k_proj, v_proj 등과 같은 레이어를 선택합니다.

• lora_dropout=0.05는 LoRA 모델의 드롭아웃 비율입니다. 드롭아웃은 과적합을 방지하고, 모델의 일반화 능력을 높이는 데 도움이 됩니다.

• bias="none"는 LoRA가 적용되는 레이어에서 bias 항목을 사용하지 않겠다는 설정입니다.

4-bit 양자화 (Quantization)

모델의 크기와 계산 비용을 절감하려면, 모델 가중치의 비트 수를 줄이는 양자화(quantization) 기법을 사용할 수 있습니다. 4-bit 양자화는 32-bit 부동 소수점 대신 4-bit로 모델의 가중치를 압축하여 메모리 사용량을 대폭 줄이고, 속도를 개선하는 방법입니다.

bnb_config = BitsAndBytesConfig( 
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",  # Normalized Float 4
    bnb_4bit_use_double_quant=True,  # 2중 양자화 적용
    bnb_4bit_compute_dtype=torch.bfloat16  # bfloat16 사용 (일반적으로 안정적)
)

• load_in_4bit=True는 모델을 4-bit 양자화하여 로딩하는 설정입니다. 4-bit 양자화는 모델의 메모리 크기를 크게 줄여주며, GPU나 TPU와 같은 하드웨어에서 효율적으로 동작합니다.

• bnb_4bit_quant_type="nf4"는 4-bit 양자화를 위한 방식으로, Normalized Float 4 방식을 사용합니다. 이 방식은 더 높은 정밀도를 유지하면서 메모리를 절약할 수 있게 도와줍니다.

• bnb_4bit_use_double_quant=True는 2중 양자화(double quantization)를 적용하여 성능을 향상시키는 방법입니다. 양자화의 정확도를 높여주지만, 추가적인 계산 비용이 들 수 있습니다.

• bnb_4bit_compute_dtype=torch.bfloat16는 계산을 bfloat16 데이터 타입으로 설정하여, 양자화된 모델을 보다 안정적으로 처리합니다.

LoRA와 4-bit 양자화 결합

LoRA와 4-bit 양자화를 결합하여 모델을 최적화하면, 메모리 사용량을 절감하고 계산 성능을 크게 향상시킬 수 있습니다. 두 가지 최적화 기법을 동시에 적용하면, 대형 모델을 상대적으로 적은 리소스로 효과적으로 실행할 수 있게 됩니다.

model = AutoModelForCausalLM.from_pretrained(
    BASE_MODEL, 
    quantization_config=bnb_config,  # 4-bit 양자화 적용
    device_map="auto"
)

lora_config = LoraConfig(
    r=8,  # Low-rank 차원
    lora_alpha=32,
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],  # LoRA 적용할 레이어 추가
    lora_dropout=0.1,
    bias="none",
    task_type="CAUSAL_LM"
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

이 코드에서 모델은 먼저 4-bit 양자화가 적용된 상태로 로딩됩니다. 그 후, LoRA 설정을 적용하여 최적화가 완료된 모델을 만듭니다. 이렇게 하면 메모리 절약은 물론, 모델 훈련 속도와 추론 속도도 향상됩니다.

주의사항

양자화 모델과 LoRA 동시 적용 시 주의 사항

1. AutoAWQ 기반의 4-bit 양자화 모델을 사용하면 LoRA 적용 시 호환성이 중요합니다.

2. bitsandbytes (bnb)의 4-bit 양자화와 LoRA (peft)를 함께 사용할 경우 bnb.nn.Linear4bit를 지원하는지 확인해야 합니다.

   # 모델의 특정 레이어가 bnb.nn.Linear4bit 인지 확인방법
   import torch
   import bitsandbytes as bnb
   for name, module in model.named_modules():
    if isinstance(module, bnb.nn.Linear4bit):
        print(f"{name} is a 4-bit quantized layer: {type(module)}")

   출력 예시 model.layers.0.self_attn.q_proj is a 4-bit quantized layer: <class 'bitsandbytes.nn.Linear4bit'>

3. target_modules이 올바른 레이어에 적용되었는지 확인 필요 (q_proj, v_proj, k_proj, o_proj 외에도 gate_proj 등이 있을 수 있음).

   # 모델의 모든 모듈 이름 출력
   for name, module in model.named_modules():
    print(name)
   ############################################    
   # 학습 가능한 파라미터만 출력
   for name, param in model.named_parameters():
    if param.requires_grad:
        print(f"Trainable Parameter: {name}, Shape: {param.shape}")

   출력 예시 model.embed_tokens model.layers.0.self_attn.q_proj model.layers.0.self_attn.k_proj model.layers.0.self_attn.v_proj

GPU 할당 최적화

1. device_map="auto"로 자동 할당하지만, 직접 model.half().cuda() 혹은 bfloat16을 적용해 확실히 GPU를 사용하도록 할 수 있습니다.
2. torch_dtype=torch.bfloat16을 사용 중이라면, 지원하지 않는 경우 float16으로 변경 (A100, H100 등 GPU는 bfloat16 지원).

데이터셋 배치 전처리 최적화

dataset 로드 후 tokenizer를 적용하여 map()을 활용해 미리 토큰화된 데이터셋을 만들면 학습 속도를 개선할 수 있습니다.

TraniningArguments 및 Trainer(파라미터 설정 및 학습)

training_args = TrainingArguments(
    output_dir="./deepseek-lora",
    per_device_train_batch_size=4,
    per_device_eval_batch_size=4,
    gradient_checkpointing=True,  # GPU 메모리 절약
    gradient_accumulation_steps=8,  # 작은 배치 크기 보완
    num_train_epochs=3,
    save_strategy="epoch",
    evaluation_strategy="epoch",
    logging_dir="./logs",
    fp16=True,  # 16-bit 연산
    optim="adamw_torch"
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_datasets["train"],
    eval_dataset=tokenized_datasets["validation"]
)

trainer.train()

output_dir="{디렉토리}", # 체크포인트 및 모델 가중치를 저장할 디렉토리 per_device_train_batch_size=4, # GPU 한 장당 학습 배치 크기 (4개 샘플씩 처리) per_device_eval_batch_size=4, # 평가 시 한 번에 처리할 배치 크기 (4개 샘플씩) gradient_checkpointing=True, # 메모리 절약을 위한 gradient checkpointing 활성화 gradient_accumulation_steps=8, # 작은 배치 크기를 보완하기 위해 8개 스텝마다 가중치 업데이트 num_train_epochs=3, # 학습을 3번 반복 (Epoch 수) save_strategy="epoch", # 매 Epoch가 끝날 때 모델 저장 evaluation_strategy="epoch", # 매 Epoch가 끝날 때 검증 수행 logging_dir="./logs", # 로그 저장 디렉토리 fp16=True, # 16-bit 연산 활성화 (GPU 메모리 절약 및 속도 향상) optim="adamw_torch" # AdamW 옵티마이저 사용 (PyTorch 기본 구현)

결론

LoRA와 4-bit 양자화는 대규모 NLP 모델을 보다 효율적으로 다루기 위한 두 가지 강력한 기법입니다. LoRA는 모델의 파라미터 수를 줄여서 훈련 속도와 메모리 효율성을 높이고, 4-bit 양자화는 모델 크기를 줄여 계산 비용을 절감하는 데 유용합니다.

이 두 가지 기법을 결합하여 모델을 최적화하면, 제한된 리소스에서도 대규모 모델을 효과적으로 사용할 수 있습니다. 다음 시간에는 DeepSeek리뷰로 찾아 오도록 하겠습니다.

연구의 목적

기존 연구는 지도학습(SFT)에 의존해 대규모 언어 모델(LLMs)의 성능을 개선하였으나, 지도 학습 데이터는 수집과 라벨링에 많이 시간과 비용을 소요되어 이것을 개선하기 위해 연구

목표

• 지도학습 없이 강화학습(RL)만으로 LLM이 추론 능력을 학습하고 발전 할 수 있음을 입증
• 새로운 학습 파이프라인(Cold-Start 데이터 및 다단계 학습)을 통해 추론성능과 사용자 친화성을 강화
• 대형 모델에서 학습한 추론 능엵을 소형 모델로 지식 증류(Distillation)하여 성능과 효율성을 확보

주요 모델

DeepSeek-R1-Zero

특징

• 지도학습 없이 순수 강화학습만으로 학습
• 모델이 강화학습 환경에서 스스로 진화(Self-Evolution)하여 복잡한 문제를 해결하기 위한 추론 능력을 개발
• GRPO(Group Relative Policy Optimization) 알고리즘을 사용하여 강화학습 비용을 절감

결과

• AIME 2024 벤치마크 Pass@1에서 점수 15.6% -> 71.0% 상승
• 다수결 투표(Majority Voting)로 성능 86.7%까지 향상(OpenAi o1-0912와 비슷)
• 모델은 자기 검증(Self-Verification), 자기 반성(Reflection), 긴 Chain-of-Thought(CoT)를 생성하는 능력 학습

한계점

• 생성된 응답에서 가독성(Readability)저하
• 언어 혼합(Language Mixing)문제 확인

해당 논문을 요약하자면 32-bit가 아닌 16-bit로 표현하여 배치 사이즈를 늘리고, 그에 따라 학습 속도를 빠르게 할 수 있는 Mixed Precision Training이라는 기술을 다룹니다. 해당 과정에서 발생할 수 있는 문제를 Adaptive 방식으로 해결하는 과정과 나아가 Automatic Mixed Precision이하 AMP를 다루고 있습니다.

Mixed Precision

Single Precision(Floating Point32, FP32)가 딥러닝에서 가장 적합한 파라미터인가를 연구하다 Half Precision(Floating Point16, FP16)을 활용한다면 모델 성능을 비교 했을 때 크게 차이 나지 상태에서 모델 학습에 필요한 메모리를 줄이고, 연산 속도 또한 가속 시킬 수 있지 않을까라는 관점에서 생겨 났습니다. 모델 파라미터를 32-bit에서 16-bit로 줄인 것에 대한 장단점입니다.

Single Precision - 4bytes (32bits) Double Precision - 8bytes (64bits)

FP32와 FP16의 차이점

• FP32는 23비트의 가수를 가지고 있어 높은 정밀도를 가지며, 작은 값의 변화까지도 정확하게 표현 할 수 있습니다.
• FP16은 10비트의 가수만을 가지므로, 큰 범위의 값만을 표현하기 적합하며 작은 값의 정밀도는 떨어질 수 있습니다.
• 두 이유로 인해 Gradient Vanishing 문제가 발생할 수 있으며, Mixed Precision Training이 이것을 해결하기 위해 사용 됩니다.

장점

1. 같은 모델이라도 더욱 빠른 학습을 통해 빠르게 결과를 얻음
2. 빠른 학습, 그에 따른 적은 GPU 사용량
3. 모델 구조에 구애 받지 않고 모든 모델에 적용 가능 -> FP16연산은 GPU의 Tensor Core에서 최적화되어 제공되며, 대부ㅜㄴ의 딥러닝 모델 연산은 텐서 고셈(MatMul)을 포함하고 있어 이를 활용할 수 있음

2번과 3번은 현재 점점 커다란 AI모델들이 나오면서 더욱 이득을 볼 수 있는 장점이 되었습니다.

단점

NVIDIA Technical Blog에서 실험한 Object Detection에서 SSD(Single Shot Multibox Detector)모델의 파라미터가 가진 Gradient 분포 표입니다. 빨간선 기준으로 왼쪽은 FP16으로는 표현 할 수 없는 범위이고 오른쪽은 가능한 범위입니다. 절반 이상의 gradient가 FP16으로는 표현할 수 없기 때문에 FP16으로 학습을 한다면 많은 정보가 소실될 것으로 유추가 가능합니다. 표현이 불가능한 이유는 bit수에 따라 표현 숫자가 크게 차이가 나기 때문인데, 위의 FP의 bit수(bit Depth)에 따른 표현 값의 최대 - 최소 정밀도 표를 확인하면 32-bit와 16-bit의 표현 할 수 있는 범위의 차이가 크다는 것을 알 수 있습니다. 그렇기 때문에 8-bit와 4-bit를 활용 하는 방식은 장점에 비해 단점이 커 사용하지 않는 것을 추천합니다. FP16을 활용해서 메모리와 속도의 이점을 가져가고 싶지만, Fully Designed to FP16모델은 위와 같은 문제가 있고, 해당 문제를 통한 성능 저하를 막기 위해 나온 방식이 Mixed Precision입니다.

• 주의 : FP16은 C에서 지원하지 않기 때문에 CPython 기반인 Numpy를 활용해도 16-bit 와 32-bit 속도 차이는 없다는 내용의 보고가 많습니다.
  Gradient Clipping의 이유 : FP16의 표현 범위를 벗어난 Gradient는 소실되거나 왜곡되며, 학스 ㅂ과정에서 잘못된 업데이트가 생길 수 있음 Adaptive Scaliiung Factor를 통해 이러한 문제를 완화하며, PyTorch의 AMP는 이를 자동으로 처리함

방법

Mixed라는 이름철럼 파라미터를 FP32와 FP16을 적절히 섞어 학습하는 것이며,

Mixed-Precision Training Iteration Version1

1. FP32로 표현된 FP32 Master weights를 복사하여 FP16 weights를 만듭니다.
2. FP16으로 Forward Propagation 진행합니다 (주의 : gradient는 FP16일 것)
3. Loss 값을 Scale factor S로 곱합니다.
4. 얻은 FP16 gradient를 Backpropagtion 합니다.
5. 3번에서 S를 곱하였기 때문에, BackProp해서 얻은 weight gradient에 S를 나누어 줍니다.
6. Gradient Clipping, wieght decay등을 적용합니다.
7. FP32 Master weights를 업데이트합니다.

해당 방법은 문제는 Scaling factor S가 너무 크거나 작으면 곱하고 나누는 과정에서 Inf 도는 NaN이 발생할 수 있습니다. 방지는 방법으로는 gradient의 최댓값이 65,504(FP16 Max값)을 넘지 않도록 설계하는 방법이 있습니다. 초기 S를 크게 설정하되 iteration이 지나서 학습에 문제가 발생하면 S를 키우거나 줄이는 방법인 Adaptive를 사용합니다.

Mixed-Precision Training Iteration Version2

1. FP32로 표현된 FP32 Master weights를 저장합니다.
2. S의 초기값을 큰 수로 설정합니다.
3. 매 iteration마다 아래 방법을 수행합니다. A. FP16으로 Forward Propagation 진행합니다 (주의 : gradient는 FP16일 것) B. Loss 값을 Scale factor S로 곱합니다. C. 얻은 FP16 gradient를 Backpropagtion 합니다. D. 만약 모델 전체 weight의 gradient 중에서 하나라도 inf 또는 NaN이 발생한다면

• S값을 줄인다.
• wieght update를 하지 않고 다음 iteration로 넘어값니다. (f,g,h 건너뜀) E. BackProp해서 얻은 weight gradient에 S를 나누어 줍니다. F. Gradient Clipping, wieght decay등을 적용합니다. G. FP32 Master weights를 업데이트합니다.

S값을 키우는 이유 S를 곱한다는 의미는 위의 해당 그림에 있는 모든 막대기를 오른쪽으로 이동시킨다는 의미입니다. 빨간색 선 오른쪽으로는 16-bit로 표현할 수 있는 범위라고 했으므로, 최대한 많은 파라미터를 빨간색 오른쪽으로 이동시키는 것이 이 방법의 학심입니다. 참고로 PyTorch에서는 GradScaler S의 초기값이 65536.0으로 설정

NaN/Inf 추가 설명 NaN 또는 Inf 문제에서 Scaling Factor S를 조정하는 이유

• S가 너무 크면 Loss를 곱할 때 FP16의 표현 범위를 넘어 NaN/Inf가 발생, S가 너무 작으면 Gradient가 소수점 아래로 줄어들어 Vanishing(소실)될 가능성이 높음

요약하자면 Mixed Precision을 이용해서 학습할 경우 성능의 저하는 적고, throughput은 1~5배 증가한 것을 표에서 확인 할 수 있습니다.

주의

AllowList, DenyList, InterList DenyList를 두 분류로 나눠보면

• Linear operation: Large reductions, L1 Loss
• Non-linear operation: Cross entropy loss, Exponential

Non-linear는 log 또는 e등의 지수연산이 들어가기 때문에 쉽게 FP16의 표현 범위가 넘어갈 것으로 예상되어, Mixed Precision적용 시 형변환을 하면서 성능 저하가 발생할 것을 알 수 있습니다. Linear 또한 단순 사칙연산이라 괜찮을 수 있지만 L1 Loss는 mean 또는 sum연산이 옵션으로 존재하여, Large mini-batch를 가정했을 때 성능 저하를 일으킬 수 있습니다.

[AMP]Automatic Mixed Precision

What is Automatic Mixed Precision AMP and how can it help with training my model?

• Automatic Mixed Precision AMP makes all the required adjustments to train models using mixed precision, providing two benefits over manual operations:

1. Developers need not modify network model code, reducing development and maintenance effort.
2. Using AMP maintains forward and backward compatibility with all the APIs for defining and running models.

요약하자면 Mixed Precision을 쉽게 적용할 수 있게 프레임워크 차원에서 제공하는 것을 의미합니다.

사용방법 예시

scaler = torch.cuda.amp.GradScaler()
for inputs, labels in data_loader:
    with torch.cuda.amp.autocast():
        outputs = model(inputs)
        loss = loss_fn(outputs, labels)

    scaler.scale(loss).backward()
    scaler.step(optimizer)
    scaler.update()

주의 사항

• 모든 연산이 FP16에 적합하지 않으므로 프레임워크가 AllowList, DenyList를 사용해 연산 타입을 관리
• 모델의 특정 연산이 AllowList/DenyList에 적합하지 않을 경우 성능 최적화 제한
• 초대형 모델에서는 여전히 메모리 부족 문제 발생

Unconditional LDM의 hyper-parameter 관련 표입니다.

해당 표는 $256^2$크기의 CelebA-HQ, FFHQ, LSUN-Churches, LSUN-Bedrooms로 학습한 모델의 FID, Precision, Recall 결과표입니다.

요약

1. Latent Diffusion Model(LDM)

• 기존 Diffusion Model은 고해상도 이미지를 직접 처리하려 할 때 계산 비용이 매우 높음
• LDM은 고차원 이미지 데이터를 직접 처리하는 대신 저차원 잠재 공간(Latent Space)으로 변환해 효율성을 높임
• 잠재 공간은 이미지의 중요한 특성만 보존된 압축 표현으로, Diffusion 과정을 수행한 후 다시 고해상도로 복원

Diffusion Model의 작동 방식

• Diffusion Model은 데이터를 점진적으로 노이즈(noise)를 추가하는 전방 과정(forward process)과, 노이즈를 제거하며 원본 데이터를 복원하는 역방향 과정(reverse process)으로 이루어져 있음
• Latent Diffusion에서는 해당 과정을 잠재 공간에서 수행함으로써 계산비용과 메모리 요구량을 크게 줄임

LDM의 장점

• 효율성 : 고차원 공간에서의 연산을 피함으로써 Diffusion Model의 계싼 비용을 줄이고 훈련 속도를 높임
• 확장성 : 저차원 잠재 공간을 사용함으로써 더 큰 모델이나 데이터셋에 대해 쉽게 확장이 가능
• 품질 향상 : LDM은 이미지의 주요 특징을 잠재 공간에서 학습함으로써 고품질의 샘플을 생성가능

LDM의 구조

• LDM은 오토인코더를 사용해 이미지 데이터를 잠재 공간으로 변환

1. 인코더 : 고차원 이미지 데이터를 잠재 공간으로 압축
2. 디코더 : 잠재 공간에서 데이터를 다시 고차원 이미지로 복원

• Diffusion 과정은 잠재 공간에서만 이루어지며, 이를 통해 계산 비용과 메모리를 대폭 절감

기존 접근법과 비교

• Pixel Space Diffusion : 기존의 Diffusion Model은 픽셀 공간에서 노이즈를 추가하고 제거함으로써 계산 비용이 LDM에 비해 매우 높음
• Latent Space Diffusion : LDM은 계산량이 큰 잡업을 압축된 잠재 공간에서 수행하여 효율적
• 해당 차이로 인해 LDM은 동일한 자원으로 더 큰 해상도와 복잡한 데이터를 처리 가능

Experiments

학습 및 inference 모두에서 픽셀 기반 diffusion model과 비교 및 장점 분석입니다. VQ-regularized latent space에서 학습된 LDM이 때때로 더 나은 샘플 품질을 생성합니다. LDM 학습에 대한 정규화 체계의 효과와 $256^2$보다 큰 해상도에 대한 재구성 능력 사이의 시작적 비교 결과물 입니다.

On Perceptual ession Tradeoffs

해당 논문에서 데이터 압축은 단순히 수학적 재구성 오류를 최소화하는 문제를 넘어, 인간의 지각(Perception)과의 관계를 고려해야 한다고 합니다. 해당 섹션에서는 압축 알고리즘 설계와 평가에서 지각적 품질과 비 지각적 품질 간의 균형점을 다룹니다.

1. 압축과 지각적 품질의 관계

• 데이터 압축은 손실 압축(Lossy Compression)과정에서 데이터를 축소하면서 필연적으로 정보를 버립니다.
• 기존 압축 기술은 주로 수학적 오차(e.g. MSE, PSNR)를 최소화하는 것에 중점을 두지만, 해당 지표들은 항상 인간의 지각 품질과는 일치하지는 않습니다.
• 지각적으로 좋은 압축은 인간이 실제로 이미지나 동영상을 볼 때 품질이 좋게 느껴지는 방향으로 설계 됩니다.

2. 지각적 품질(Perceptual Quality)과 비지각적 품질(Distortion)의 Tradeoffs

• 지각적 품질을 개선하려면, 왜곡(Distortion)을 일부 허용해야 하는 경우가 많습니다.
• 이는 비지각적 오류(e.g. 픽셀 기반 손실)가 높아지더라도, 결과물이 인간 관점에서 더 자연스로운것으로 보일 수 있음을 말합니다.
• 해당 논문에서는 이러한 트레이드오프를 정량화하고 모델링하는 방법을 연구합니다.

3. Rate-Distortion-Perception (RDP) 이론

• 해당 논문은 압축 효율성(Rate), 왜곡(Distortion), 지각적 품질(Perception) 사이의 관계를 RDP 트레이드 오프로 설명합니다.
• 최적의 압축은 세 가지 요소 사이에서 균형을 찾아야 합니다.

1. Rate: 데이터 전송률 또는 저장 공간
2. Distorition: 압축된 데이터와 원본 데이터 간의 차이
3. Perception: 인간이 지각하는 데이터 품질

4. 요약 및 분석

• 지각적 품질과 왜곡의 상호작용을 수학적 분석
• 최적의 압축 설계는 지각적 품질과 왜곡의 상반된 목표를 가지는 경우에도, 특정 목표에 따라 압축 방식의 우선순위를 조정할 수 있어야 함
• 기술적 지표(e.g. MSE, PSNR)의 기존 방식에서 새로운 지표를 제시

해당 표는 이 섹션에서 비교한 LDM에 사용된 First stage model의 hyper-parmaeter 및 재구성 성능 표입니다.

해당 그래프는 ImageNet으로 클래스 조건부 모델을 200만 Step 학습할 때 Step에 대한 샘플 품질 (FID,IS)를 보여줍니다.

해당 결과를 통해 2가지를 확인 할 수 있는데,

1. 작은 Downsampling factor는 학습을 느리게 합니다.(LDM-1, LDM-2)
2. 지나치게 큰 f 값은 비교적 적은 Step에서 샘플 품질의 정체를 유발합니다.(LDM-32) LDM-4부터 LDM-16까지는 효율성과 Perceptual하게 적절한 균형을 유지합니다.

해당 그래프는 CelebA-HQ와 ImageNet으로 학습한 LDM의 샘플링 속도와 FID를 비교한 결과입니다. CelebA-HQ는 50만 step, ImageNet은 200만 step동안 학습되었으며 각 마커는 10, 20, 50, 100, 200 DDIM step으로 샘플링하였습니다.

결과적으로 LDM-4와 LDM-8의 성능이 제일 좋다는 것을 확인 할 수 있습니다.

다른 유형의 생성 모델과 마찬가지로 diffusion model은 원칙적으로 $P(z|y)$ 형식의 조건부 분포를 모델링 할 수 있습니다. 조건부 denoision autoencoder $\epsilon_\theta (z_t, t, y)$로 구현되며, 입력 $y$를 통해 텍스트, sematic map, image-to-image 변환과 같은 합성 프로세스를 제어할 수 있습니다.

이미지 합성 측면에서 diffusion model의 생성 능력을 입력 이미지의 클래스 레이블이나 이미지를 흐릿하게 변형하는 것을 넘어선 다른 유형의 컨디셔닝과 결합하는 것이 이전 연구들과의 차이점입니다.

다양한 입력 양식의 attention 기반 모델을 학습하는 데 효과적인 cross-attention 메커니즘으로 기본 UNet backbone을 보강하여 diffusion model을 보다 유연한 조건부 이미지 생성기로 만듭니다. 다양한 종류의 $y$를 전처리하기 위해 $y$를 중간 representation(표현)으로 $\tau \epsilon (y) \in \mathbb R^{M \times d_r}$로 보내는 도메인별 인코더 $\tau _\epsilon$를 도입합니다. 이후 cross-attention layer를 통해 UNet의 중간 layer에 매핑되며, Cross-attention layer 공식은 다음과 같습니다. $$Ateention(Q, K, V) = softmax(\frac{QK^T}{\sqrt d})\cdot V$$ $$Q = W^{(i)}{Q} \cdot \phi (z_t), K = W^{(i)}_K \cdot \tau_\theta(y), V = W^{(i)}_V \cdot \tau_\epsilon(y)$$

$\phi_i(z_t) \in \mathbb R^{N \times d^{i}\epsilon}$ 는 $\epsilon_\theta$를 구현하는 UNet의 중간 표현이고, $W^{(i)}_V \in \mathbb{R}^{d \times d{\epsilon}}, W^{(i)}Q \in \mathbb{R}^{d \times d{\tau}}, W^{(i)}K \in \mathbb{R}^{d \times d{\tau}}$ 는 학습 가능한 projection matrix입니다. 해당 모델의 아키텍처는 아래와 같습니다. 이미지와 conditioning(조건화, 학습되는 과정) 쌍을 기반으로 다음 식을 통해 조건부 LDM을 학습합니다.

$$L_{LDM} := \mathbb{E}{\varepsilon{(x)}, y, \epsilon \sim \mathcal{N}(0, 1), t}\left[| \epsilon - \epsilon_\theta(z_t, t, \tau_\theta(y)) |_2^2\right]$$

$\tau_\theta 와 \epsilon_\theta$는 위 식으로 동시에 최적화 되며, 각 도메인별 기존 모델들에 의해 $\tau_\theta$가 파라미터화 할 수 있기 때문에 이 메커니즘은 유연하게 작동함을 알 수 있습니다.

요약하자면, Cross-Attention 메커니즘은 다양한 입력 양식에 대해 강력한 조건부 이미지를 생성하도록 모델을 확장하며, 이를 통해 Diffusion 모델이 보다 유연하고 강력해집니다.

$\tau_\epsilon (y) \in \mathbb R^{M \times d_r}$

• 조건부 입력 $y$를 중간 표현 $\tau_\epsilon(y)$으로 변환하기 위해 도메인별 인코더 $\tau_\epsilon$를 사용
• $M$: 중간 표현의 길이
• $d_r$: 중간 표현의 차원

Query, Key, Value 정의 $Q$: Query, $K$: Ke,y $V$: Value $Q = W^{(i)}_{Q} \cdot \phi (z_t), K = W^{(i)}_K \cdot \tau_\theta(y), V = W^{(i)}_V \cdot \tau_\epsilon(y)$

• $\phi(z_t)$: UNet의 중간 표현
• $\tau_\epsilon(y)$: 도메인별 인코더를 통해 변환된 입력 $y$

UNet 중간 표현 $\phi_i(z_t) \in \mathbb R^{N \times d^{i}_\epsilon}$

• $N$: UNet 중간 표현의 길이
• $d_\epsilon^i$: 각 레이어별 중간 표현의 차원

Weight 정의 $W^{(i)}V \in \mathbb{R}^{d \times d\epsilon}$ $W^{(i)}Q \in \mathbb{R}^{d \times d\tau}$ $W^{(i)}K \in \mathbb{R}^{d \times d\tau}$

• $d$: 차원의 기준 값
• $d_\epsilon$: $\tau_\epsilon(y)$의 표현 차원
• $d_\tau$: Query와 Key의 차원

$L_{LDM} := \mathbb{E}{\varepsilon{(x)}, y, \epsilon \sim \mathcal{N}(0, 1), t}\left[| \epsilon - \epsilon_\theta(z_t, t, \tau_\theta(y)) |_2^2\right]$

• $L_{LDM}$: Latent Diffusion Model (LDM)의 손실 함수
• $\mathbb{E}$: 기대값
• $x$: 데이터 샘플
• $y$: 조건부 입력
• $\epsilon \sim \mathcal{N}(0, 1)$: 평균이 0이고 분산이 1인 정규분포에서 샘플링된 노이즈
• $t$: 시간 단계
• $\epsilon_\theta$: 모델이 예측한 노이즈
• $\tau_\theta(y)$: 조건부 입력 $y$를 중간 표현으로 변환하는 도메인별 인코더 $\tau_\theta$
• $| \cdot |_2^2$: L2 노름의 제곱

위의 학습내용은 저의 주관적인 내용이 포함되어 잘못 된 정보가 있을 수 있습니다. 참고용으로 읽어주시기 바랍니다.

Diffusers 학습 코드

Github

Latent Diffusion Models

Diffusion model은 정규 분포 변수의 noise를 점진적으로 제거하여 데이터 분포 $p(x)$를 학습하도록 설계된 확률 모델입니다. 구체적으로는 길이가 $T$로 고정된 *Markov chain(마코프 체인)의 *reverse process를 학습하는 것입니다. 이미지 합성의 경우 가장 성능이 좋은 모델들은 denoising score-matching을 미러링하는 $p(x)$에 대한 variational lower bound를 재가중한 변형을 사용합니다. 이러한 모델은 입력 $x_t$의 noise가 제거된 변형을 예측하도록 학습된 denoising autoencoder $\epsilon_\theta(x_t,t)(t=1,...,T)$의 동등하게 가중된 시퀀스로 해석할 수 있습니다. 여기서 $x_t$는 입력 $x$에 noise가 추가된 버전입니다.

• 목적 함수 단순화 공식 $$L_{DM} = \mathbb E_{x,\epsilon ~N(0,1),t}[||\epsilon - \epsilon_\theta(x_t, t)|_2^2]$$

$t$는 1,...,$T$에서 uniform하게 샘플링 됩니다. $\mathcal{E} 와 \mathcal{D}$로 학습된 perceptual compression 모델을 사용하여 Generative Modeling of Latent Representations을 통해 high-frequency(고주파)의 감지할 수 없는 디테일이 추상화되는 효율적이고 낮은 차원의 latent space에 접근 할 수 있습니다. 이 Latent space는 고차원 픽셀 space와 비교할 때 2가지 이유로 likelihood 기반 생성 모델에 더 적합합니다.

1. 데이터의 중요한 semantic bit에 집중 가능
2. 계산적으로 훨씬 더 효율적인 더 낮은 차원에서 학습 가능

이전 모델들은 압축된 discrete latent space에서 autoregressive attention 기반 transformer 모델에 의존했지만, LDM은 이미지별 inductive bias를 활용 할 수 있으며, 2D convolutional layer들로 UNet을 구성이 가능합니다. reweighted bound를 사용하여 perceptual하게 가장 관련성이 높은 비트에 목적 함수를 더 집중시키는 것도 포합됩니다.

$$L_{LDM} := \mathbb E_{E(x),\epsilon ~ N(0,1),t}[||\epsilon - \epsilon_\theta(Z_t, t)|_2^2]$$

LDM의 Backbone $\epsilon_\theta(\degree,t)$는 time-conditional Unet으로 구현됩니다. Forward process가 고정되어 있으므로 학습 중에 $Z_t를 E$에서 효율적으로 얻을 수 있고 $P(Z)의 샘플을 D$에 한 번 통과시켜 이미지 Space로 디코딩할 수 있습니다.

변수 설명

• x: 원본 데이터 (e.g. 이미지)
• ϵ∼N(0,1): 평균이 0이고 분산이 1인 정규 분포에서 샘플링된 랜덤 노이즈
• t: 시간 스텝으로,주어진 $t$에서 데이터 $x_t$가 얼마나 "노이즈화" 되었는지 나타냄
• $x_t : t$ 시점에서 노이즈가 추가된 데이터.
• $\epsilon_\theta(x_t,t)$: 모델이 예측한 노이즈
• $|\epsilon - \epsilon_\theta(x_t, t)|_2^2$

• Markov Chain 여러 상태들 $(X_1,X_2,... X_n)$이 있고, $X_i$에서 $X_j$로 이동할 조건부 환률 분포 $Trasition distribution T(X_j|X_i)$가 주어져 있어서 매턴마다 이 확률 값에 따라 상태들 사이를 이동한 것 즉, 상태들의 방문횟수의 비율이 특정 확률분포로 수렴하게 되고 이 분포를 Stationary distribution이라합니다. 마르코프 체인은 '마르코프 성질'을 가진 '이산시간 확률과정' 입니다.
• reverse process noise로부터 원래의 샘플 이미지를 생성하는 과정

해당 방법의 장점으로는

• 고차원 이미지 공간을 남겨두어 저차원 공간에서 샘플링이 수행되기 때문에 계산적으로 효율적
• Unet 아키텍처에서 상송된 Diffusion Model의 inductive bias를 활용하여 공간 구조가 있는 데이터에 효과적
• Latent Space가 여러 생성 모델을 학습시키는 데 사용할 수 있고 downstream task(e.g., CLIP-guided synthesis)에도 활용 가능한 범용 압축 모델을 얻을 수 있음

1. Perceptual Image Compression

Perceptual loss와 patch-based adversarial objective의 조합으로 학습 되는 autoencoder로 구성됩니다. local realism이 적영되어 재구성 image manifold에 국한되고 $$L_2 또는 L_1$$ objective와 같은 pixel space loss에만 의존하여 발생하는 노이즈(흐릿함)을 방지할 수 있습니다.

1-1) 해당 관련 수식

1. RGB 이미지 $x$ $\epsilon$ $\mathbb R^{3HW}$에 대하여 인코더 $\mathcal{E}$ 가 $x$를 latent representation $\mathcal{Z} = \varepsilon(x)$로 인코딩합니다.
2. 디코더 $\mathcal{D}$가 latent $z \epsilon \mathbb R^{hwc}$로 부터 이미지를 재구성하여 $\tilde{x} = \mathcal{D}(z) = \mathcal{D}(\mathcal{E}(x))$를 만들어 줍니다.
3. 인코더는 이미지를 factor $f - H/h = W/w$로 downsampling 하고 $m \epsilon \mathbb N$에 대하여 fator를 $f = 2^m$으로 둔다.

Latent space의 분산이 커지는 것을 방지 하기 위해 두 가지 종류로 정규화를 진행 방법1) KL 정규화는 VAE와 유사하게 학습된 latent에서 표준 정규분포에 대해 약간의 KL 패널티를 부과합니다. 방법2) VQ 정규화는 디코더 내에서 벡터 양자화 layer를 사용합니다. 이 모델은 VQGAN으로 해석 될 수 있지만 양자화 layer가 디코더에 의해 흡수 됩니다. LDM은 학습된 latent sapce $\mathcal{Z} = \mathbb E(x)$의 2차원 구조와 함께 작동하도록 설계되었기 때문에 상대적으로 약한 압축률을 사용하고도 매우 우수한 재구성이 가능합니다. 결과적으로 LDM의 압축 모델은 $x$의 detail들을 더 잘 보존합니다.

Perceptual Image Compression 해당 논문에서 말하는 Perceptual Image Compression는 Autoencoder에서 Latent Space를 학습하는 것을 뜻하며, 이 때 Latent Space의 분산이 크면 Latent Space가 가지고 있는 정보가 이질적이므로 작은 분산을 가지도록 Regularization을 가지고 실험을 진행 Regulariztion 종류

• KL-reg : 학습된 Latent에 약간의 KL-penalty를 줌
• VQ-reg : Decoder안에 Vector Quantiztion을 사용 2차원 구조의 Latent Space를 설계하여 1차원 모델인 Compression과 Reconstruction 성능이 좋음.

결과표

Autoencoder는 patch-based discriminator $\mathcal{D}_\Psi$로 adversarial 방식으로 학습하며, 높은 수준의 재구성을 위해 매우 작은 크기의 정규화를 사용합니다. 예를 들어, KL항에 대한 가중치를 $10^{-6}$으로 작게 두거나 코드북 차원 $|Z|$을 높게 설정합니다.

Autoencoding model $(\mathcal{E}, \mathcal{D})$의 전체 목적 함수 수식

$$\mathcal{L}{\text{Autoencoder}} = \min{\mathcal{E},\mathcal{D}} \max_{\psi} \left( \mathcal{L}{\text{rec}}(x, \mathcal{D}(\mathcal{E}(x))) - \mathcal{L}{\text{adv}}(\mathcal{D}(\mathcal{E}(x))) + \log \mathcal{D}\psi(x) + \mathcal{L}{\text{reg}}(x; \mathcal{E}, \mathcal{D}) \right)$$

• $\min_{\mathcal{E},\mathcal{D}}$

  • Encoder $\mathcal{E}$와 Decoder $\mathcal{D}$의 파라미터를 최적화하여 손실 함수 $L_Autoencoder$를 최소화하려는 과정
  • $\mathcal{E}$와 $\mathcal{D}$는 Autoencoder의 주요 구성 요소로, $\mathcal{E}$는 입력 $x$를 latent space으로 변환하고, $\mathcal{D}$는 잠재 공간에서 다시 원래의 $x$로 복원

• $\max_{\Psi}$

  • $\mathcal{D}_\Psi$의 파라미터를 최적화하여 손실 함수의 일부를 최대화하는 과정
  • 판별자가 생성자(즉, $\mathcal{E},\mathcal{D}$)가 생성한 샘플과 실제 데이터를 더 잘 구별하도록 학습하는 adversarial(적대적)훈련의 핵심

• 전체 구조

  • $min_{\mathcal{E},\mathcal{D}}$, $max_ψ$ : Autoencoder $(\mathcal{E}, \mathcal{D})$는 Reconstruction Loss와 Regularization Term을 최소화하면서, $\mathcal{D}_\Psi$는 Adversarial Loss를 최대화 하려고 서로 경쟁
  • 이 구조는 Adversarial Training의 원리따름
  • $E, \mathcal{D}$와 $\Psi$간의 상호작용으로 모델은 더 강력한 reconstruction(재구성)능력과 현실감 있는 샘플을 생성

• 나머지 수식 의미

  • $\mathcal{L}_{\text{rec}}(x, \mathcal{D}(\mathcal{E}(x)))$ - 입력 $x$와 Autoencoder가 복원한 $\mathcal{D}(\mathcal{E}(x)))$간의 재구성 손실
  • $\mathcal{L}_{\text{adv}}(\mathcal{D}(\mathcal{E}(x)))$ - Adversarial Loss, $\mathcal{D}_\psi(x)$가 $\mathcal{D}(\mathcal{E}(x)))$를 진짜와 구분하려는 손실
  • $\log \mathcal{D}_\psi(x)$ - Discriminator가 실제 데이터 $x$를 진짜로 분류하는 데 성공했는지를 측정
  • $\mathcal{L}_{\text{reg}}(x; \mathcal{E}, \mathcal{D})$ - Regularization Loss로, 모델의 일반화 성능을 향상시키기 위해 추가된 항목

• 결론

  • $\min_{\mathcal{E},\mathcal{D}}$ - Autoencoder가 자신의 성능(재구성 및 현실감)을 최대화하려고 노력
  • $\max_{\Psi}$ - Discriminator가 샘플 구별 능력을 강화하려고 노력
  • Autoencoder와 Discriminator가 경쟁하면서 동시에 학습하는 Adversarial Training의 핵심 개념

수학 기호 의미 $\varepsilon$ - 임의의 작은 양수 $\mathbb N$ - 자연수 $\mathbb R$ - 실수 $\mathbb E$ - 기댓값 (Expected Value) $\epsilon$ - 오른쪽에 속함 $\mathcal{D}_\Psi$ - Discriminator($\mathcal{D}$) : 판별자 $\Psi$ : 파라미터

다음에는 Latent Diffusion Models에 대한 해석을 준비하도록 하겠습니다.

Diffusion model은 이미지 합성과 해상도 품질을 올리는 분야에서 좋은 성능을 보였지만, 데이터의 감지할 수 없는 세부 정보를 모델링 하는데 과도한 자원을 소비하는 경향이 있습니다. DDPM의 재가중된 목적 함수는 초기 노이즈 제거 단계에서 적게 샘플링하여 자원 소비를 줄이고자 하지만 해당 모델을 학습시키고 평가 하려면 RGB 이미지의 고차원 공간에서 반복적 기울기 계신이 필요하여 계산에 소요가 많습니다. 이러한 이유로 커다란 컴퓨팅 리소스가 필요하며, 동일한 모델 아키텍처를 여러 단계를 순차적으로 실행하여 시간과 메모리 또한 많이 사용합니다. 이것을 해결하는 것이 Diffusion model의 최종 목표입니다.

Rate-Distortion Trade-Off 그래프

• *Perceptual compression(지각 기반 압축) - high-frequency detail를 제거하지만 의미(semantic)는 학습 하지 않는 단계

• *Semantic compression(의미 압축) - 실제 생성 모델이 데이터의 의미론적(semantic)구성 및 개념적(conceptual)구성을 학습하는 단계

-> Perceptual하게 동등하지만 계산적으로 더 적합한 space를 찾는 것을 목표로 고해상도 이미지 합성을 위한 diffusion model을 학습

Perceptual compression Perceptual Compression은 인간의 지각적 특징을 활용하여 데이터를 압축하는 기법, 인간의 눈이나 귀가 잘 감지하지 못하는 정보를 줄이거나 제거함으로써 압축 효율을 높임

• 비디오 압축에서 고주파 영역의 세부사항을 제거
• 오디오 압축에서 사람이 들을 수 없는 고주파 대역 제거(MP3 형식)
• JPEG 이미지 압축에서 눈에 덜 띄는 색상 정보 축소

Semantic compression 데이터의 저차원 표현을 줄이는 대신, 데이터의 의미나 고수준 정보를 유지하면서 불필요한 세부 정보를 제거하는 압축 기법

• 이미지 데이터에서 구체적인 픽셀 값 대신 "사람", "나무"와 같은 객체 정보를 중심으로 데이터를 표현하는 방식
• e.g. 자연어 처리에서 단어의 의미적 유사성을 이용해 단어 벡터 크기를 줄이는 방식(Word2Vec, GPT 모델 등)

학습과정

데이터 Space와 Perceptual하게 동일한 저차원 *representational space(표현공간)로 보내는 *autoencoder를 학습, 해당 과정에서 학습된 잠재 공간에서 diffusion model을 학습시키므로 이전 모델과 달리 과도한 space 압축에 의존할 필요가 없어집니다. 또한 감소된 복잡성으로 인해 네트워크를 한 번만 통과하여 latent space에서 효율적인 이미지가 생성되고 이 모델을 LDM(Latent Diffusion Models)라고 합니다.

장점

• 범용 autoencoding 단계를 한 번만 학습하면 되어 diffusion model 학습에 재사용하거나 완전히 다른 task를 탐색 가능
• image-to-image 및 text-to image task를 위한 여러 diffusion model을 효율적 탐색
• e.g. 트랜스포머를 diffusion model의 UNet backbone에 연결하여 임의의 유형의 토큰으로 조건을 주는 아키텍처 설계

representational space (표현공간) 데이터를 추상적으로 표현하는 공간을 의미합니다. 이는 주로 데이터의 복잡한 특성을 저차원에서 간결하게 표현하거나 분석하기 위해 사용

• 원 데이터를 저차원 공간으로 매핑: 이미지의 모든 픽셀 데이터를 고차원의 공간에서 특정 패턴(e.g.고양이, 개 등)을 나타내는 저차원 공간으로 변환
• 터 특징을 보존: 원래 데이터의 중요한 특징(특성 벡터)을 유지하면서 불필요한 정보를 줄임

autoencoder 인공 신경망을 활용해 데이터를 효율적으로 압축(인코딩)하고 다시 원래 형태로 복원(디코딩)하는 신경망 아키텍처

• 구성 요소:

1. Encoder (인코더): 입력 데이터를 저차원의 잠재 공간(latent space) 또는 표현 공간으로 압축
2. Latent Space: 데이터를 간결하게 표현한 저차원 벡터가 위치한 공간
3. Decoder (디코더): 압축된 벡터를 원래 데이터와 유사한 출력으로 복원

• 주요 목적:

1. 차원 축소: PCA와 유사하게 고차원 데이터를 저차원으로 변환하면서 데이터의 중요한 특성을 유지
2. 잡음 제거: 손상된 데이터를 입력으로 받아 원래의 깨끗한 데이터를 복원 (Denoising Autoencoder)
3. 생성 모델: Variational Autoencoder(VAE)는 새로운 데이터를 생성하는 데 사용

• 동작 방식:

1. 입력 데이터 → 인코더 → 표현 공간(잠재 공간)으로 압축
2. 표현 공간 → 디코더 → 원본과 유사한 출력 생성

우선 학습을 시작할 논문은 LDM 입니다. 선택한 이유는 두 모델 특징과, 장단점을 보며 선택하였습니다.

DDPM

특징

• 이미지 합성에서의 확률적 모델로, 농이즈를 점진적으로 제거하면서 고해상도 이미지를 생성
• 노이즈를 추가하는 "점진 과정"과 노이즈를 제거하며 원본 이미지를 재구성하는 "역 과정"으로 구성
• 노이즈 레벨이 높은 이미지를 순차적으로 복원하여 고품질의 이미지를 생성

장점

• 노이즈 제거를 통한 이미지 합성으로 높은 품질의 이미지를 생성
• 생성 과정이 안정적이며, 세밀한 부분까지 잘 복원

단점

• 이미지 합성 속도가 느림, 역 과정 중 수백 단계의 연산이 필요하기 때문에 실시간에 적합하지 않음
• 대규모 연산 자원이 필요

LDM

특징

• DDPM과 비슷한 원리로 작동하지만 픽셀이아닌 Latent Space(잠재공간)에서의 확산 과정을 활용하여 연산 효율이 높음
• 사전 학습된 오토인코더를 사용해 Latent Space를 얻으며, 이 공간에서 노이즈 제거 작업을 수행함으로써 학습 및 합성 속도가 높음

장점

• DDPM 대비 연산량이 적음
• Latent Space에서의 학습으로 DDPM보다 빠르게 고해상도 이미지를 생성

단점

• Latent Space 사용으로 인해 DDPM보다 세밀한 복원이 어려움
• 오토인코더 성능에 따라 성능 영향이 있음

정리

이와 같은 특징으로 인해 좀 더 적은 자원으로 사용할 수 있는 LDM을 학습하기로 결정하였습니다.

주에 하나씩 학습한 내용을 정리하는 방식으로 글을 작성하려 합니다.

😁 power through to the end 😁

데이터가 방향성을 가지고 움직일 때, 이동하면서 구해지는 평균을 뜻합니다.

동적으로 변화하는 것에는 어디든 이동평균을 적용할 수 있으며, 또한 1차원적인 방향성을 가지고 이동하기에 이동편균을 적용 가능합니다

단순이동평균(Simple Moving Average, SMA)

가정 m일의 평균(m = Window)

n번째 데이터의 단순 이동평균 = 1번째 데이터를 포함하여 나머지 m개의 데이터의 산술평균

e.g.

• Data = [1, 1, 5, 11, 6, 7]
• n = 1, m = 3

1. 첫 번째 SMA (n=1부터 시작): 데이터: [1, 1, 5] SMA = (1 + 1 + 5) / 3 = 7 / 3 ≈ 2.33
2. 두 번째 SMA: 데이터: [1, 5, 11] SMA = (1 + 5 + 11) / 3 = 17 / 3 ≈ 5.67
3. 세 번째 SMA: 데이터: [5, 11, 6] SMA = (5 + 11 + 6) / 3 = 22 / 3 ≈ 7.33
4. 네 번째 SMA: 데이터: [11, 6, 7] SMA = (11 + 6 + 7) / 3 = 24 / 3 = 8

결과: [2.33, 5.67, 7.33, 8]

• 실제 계산 방법
  • (이전의 이동평균) + (들어온 가장 최신의 값 - 나간 가장 오래된 값)/m

누적이동 평균(Cumulative moving average, CMA)

단순이동 평균과 같이 산술평균을 구하는 방법이지만 window(m값)을 고정하지 않습니다. (모든 데이터를 고려하고 싶을 때 사용)

새로운 값이 들어올때마다 전체 평균을 새롭게 구하는 것과 동일

• n 번 째 데이터의 누적이동평균 = n번째 데이터를 포함한, 이전 모든 데이터의 평균

e.g.

• Data = [1, 1, 5, 11, 6, 7]
• n = 1
  • 1
• n = 2
  • (1 + 1) / 2

계산식

n + 1 번째 이동평균 = (n번째 누적이동평균 * n + 새로운 데이터 값) / (n + 1)

• 최신 데이터가 현재 상황을 더 잘 반영해 준다면 해당 방식을 차용

(선형)가중이동평균(Weighted moving average, WMA)

데이터의 위치에 따라 서로 다른 가중치를 부여한 후 이동평균을 계산방식 입니다.

• 계산 방식

A = dot product([m, m-1, m-2, …. , 1], [ n번째 데이터, n - 1번째 데이터ㅡ, … , n-m+1번째 데이터])

B = m + (m -1) + … + 1

n번째 데이터의 선형가중이동평균 = A / B

• 오래된 데이터로 갈 수록 곱해지는 값이 선형적으로 감소합니다

지수가중이동평균(Exponentially weighted moving average, EWMA)

선형가중이동평균 지수적으로 감소하는 가중치를 곱해 주는 것

• 계산 방식

A = dot product( [ 1 , (1 - α) , (1 - α)^2 , ... , (1 - α)^(m-1) ],  [n번째 데이터, n-1번째 데이터, ... , n-m+1번째 데이터] )

B = 1 + (1 - α) + (1 - α)^2+ ... + (1 - α)^(m-1)

n번째 데이터의 지수가중이동평균 = A / B

현재의 지수가중이동평균은 바로 이전의 데이터의 지수가중이동평균을 이용하여 구할 수 있습니다.

1번째 지수가중이동평균 = 1번째 데이터 값

n번째 지수가중이동평균 = (1 - α ) * (n-1번째 지수가중평균) + α * 현재 데이터값

가장 오래된 데이터부터 시작해서 재귀적으로 가장 최근의 데이터까지 지수가중이동평균을 구할 수 있으며, 새로운 데이터가 추가되어도 재귀적을 바로 구할 수 있다.

이 때, α 값은 세가지 방식 중 하나로 구해집니다.

작성 진행 중