[논문리뷰] DeepSeek-V3 Technical Report

최근 LLM 분야에서 가장 핫한 주제인 DeepSeek를 V3부터 R1까지, DeepSeek에서 발표한 논문을 기반으로 파헤쳐 보려합니다.

https://github.com/deepseek-ai/DeepSeek-V3?tab=readme-ov-file

GitHub - deepseek-ai/DeepSeek-V3

그럼 V3부터 바로 리뷰해보도록 할게요!

오늘도 파란 글씨는 제 사견입니다.

Abstract

DeepSeek-V3는 총 671B, 각 토큰당 37B 개의 파라미터가 활성화되는 강력한 Mixture-of-Experts (MoE) 언어모델인 DeepSeek-V3를 소개합니다. 효율적인 추론과 학습을 위해, DeepSeek-V3는 Multi-head Latent Attention (MLA)와 DeepSeekMoE Architecture를 채택했고, 이 기술들은 DeepSeek-V2에서 검증된 기술들이라고 하네요. DeepSeek-V3는 auxiliary loss (부가 손실) 없이 로드 밸런싱을 달성하는 혁신적인 전략을 개척하고, Multi-Token Prediction (멀티 토큰 예측) 훈련 목표를 설정하여 성능을 강화했습니다. DeepSeek-V3는 14.9T개의 다양한 고품질 토큰으로 pretrain되었고, 이후 Supervised Fine-tuning (SFT)와 Reinforcement Learning (RL)을 단계를 거쳐 최적화 되었어요. 종합적인 평가 결과, DeepSeek-V3는 다른 오픈 소스 모델을 능가하는 성능을 보였고, closed-source models (GPT-4o, Sonnet, ..)와도 비교 가능한 성능을 보였습니다. DeepSeek-V3는 학습에 2.788M H800 GPU 시간만 소요됐다고 합니다. (H800은 H100보다는 성능이 많이 떨어지지만, A100보다는 좋은 성능을 지녔더군요..) 또, 훈련 과정은 안정적이었고, 전체 학습 과정 동안 회복 불가능한 손실 스파이크나, 롤백 현상이 발생하지 않았다고 합니다.

DeepSeek-V3와 다른 모델 간의 성능 비교 그래프

1. Introduction

최근 LLMs의 빠른 발전으로, Artificial General Intelligence (AGI)에 점점 가까워 지고 있죠. Closed-source models 뿐만 아니라, DeepSeek, LLaMA, Qwen, Mistral 같은 open-source models도 큰 성과를 내고 있어요. DeepSeek에서는 이런 open-source 흐름을 더 발전시키기위해 671B 파라미터를 가진 대규모 Mixture-of-Experts (MoE) 모델인 DeepSeek-V3를 도입했어요. 각 토큰 당 활성화되는 파라미터는 37B개라고 하네요.

DeepSeek-V3는 효율성과 비용 절감을 위해 이전 버전인 DeepSeek-V2에서 검증된 Multi-head Latent Attetion (MLA)와 DeepSeekMoE를 그대로 유지하면서, 2가지의 주요 혁신적인 사항을 추가했다고 합니다.

1) 부가 손실 없는 로드 밸런싱: Auxiliary loss를 사용하지 않고도 로드 밸런싱을 유지하는 새로운 전략을 도입하여 성능 저하를 방지.

2) 멀티 토큰 예측 (MTP) 훈련 목표: 단일 토큰 예측 대신 여러 개의 토큰을 동시에 예측하도록 훈련해 평가 벤치마크에서 전반적인 성능 향상.

또한, DeepSeek-V3는 FP8 mixed precision 훈련을 지원하여 훈련 속도는 가속화하고 메모리 사용량은 줄였어요. DualPipe 알고리즘을 설계해 파이프라인 병렬 처리를 최적화하여 통신 오베헤드 없이 모델의 확장이 가능하도록 했다고 합니다.

 

Pre-training: DeepSeek-V3는 14.8T 개의 고품질 토큰으로 사전학습 되었으며, context의 길이를 두 단계에 걸쳐 32K에서 128K까지 확장했다고 합니다. 훈련 과정은 안정적이었고, 손실 스파이크나 롤백 없이 순조롭게 진행되었다고 하네요.

Post-training: 사전 학습된 모델은 Supervised Fine-Tuning (SFT)와 Reinforcement Learning (RL)을 통해 인간의 선호도에 맞게 최적화 되었고, DeepSeek-R1 모델로부터 추론 능력을 증류 (Distillation)하여 더 뛰어난 성능을 발휘하도록 했다고 합니다.

 

성과 및 비용 측면에서는, 수학 및 코드 분야에서 특히 뛰어난 성능을 보였고, 여러 벤치마크에서 closed-source models 와 경쟁할 수 있는 수준을 달성했다고 합니다. 전체 훈련에는 2.788M GPU hour가 소요되었고, 총 비용은 약 $\$$5.576M 정도(H800 GPU rental 시간 당 $\$$2로 계산 시)로 제한되었다고 해요.

 

저자들이 이야기하는 주요 기여는 다음과 같아요:

1) Architecture
- Auxiliary-loss-free strategy for load balancing, 로드 밸런싱을 유도하는 과정에서 발생하는 성능저하를 최소화.
- Multi-Token Prediction, MTP의 도입을 통해 모델의 전반적인 성능을 개선. 또한, 추론 속도 가속화를 위한 예측적 디코딩 (Speculative decoding)에도 사용 가능.

2) Pre-training
- FP8 mixed-precision 훈련 프레임워크를 설게, 이를 초대형 모델에서 검증하여 효율적이고 안정적인 훈련.
- 알고리즘, 프레임워크, 하드웨어의 공동 설계를 통해 cross-node MoE 훈련에서 통신 병목현상을 극복하고, 계산-통신의 완전한 중첩을 달성하여 훈련 비용 대폭 감소.
- 14.8T 개의 토큰을 단지 2.664 H800 GPU hours로 사전학습을 완료하여, 현재까지 가장 강력한 open-source base model 구축.

3) Post-training

DeepSeek-R1 시리즈의 Chain-of-Thought (CoT) 모델로부터 추론 능력을 증류하여, DeepSeek-V3의 논리적 추론 성능을 개선. 이 과정에서 출력 스타일과 길이도 정교하게 제어.

2. Architecture

DeepSeek-V3의 기본 아키텍쳐는 transformer 구조를 기반으로 하며, 효율적인 추론과 비용 절감형 훈련을 위해 MLA와 DeepSeekMoE를 활용해요. 각각의 개념을 수식을 통해 차근차근 풀어가보아요...

2.1. Basic Architecture

DeepSeek-V3의 기본적인 아키텍쳐는 위의 그림과 같아요..ㅎ 여기서는 주요 요소인 MLA와 DeepSeekMoE만 확인하면 돼요. 이 방법론들이 기존의 transformer 구조에서 효율적인 추론과 비용절감형 훈련을 가능하게 하는 핵심적인 기술이에요. 이제 MLA와 DeepSeekMoE에 대해서 자세히 알아보도록 할게요.

2.1.1. Multi-Head Latent Attention

DeepSeek-V3에서 차용하는 MLA 구조는 기본 transformer 구조의 attention 매커니즘을 최적화하여 key-value 캐시를 줄여서 더 빠르고 메모리 효율적인 추론이 가능하게 해요. 논문에 나와있는 수식과 해석을 통해 살펴 볼게요.

임베딩 및 차원 관련

$d$: 임베딩 차원.
$n^t$: attention heads 개수.
$d_h$: head 당 dimension.

$d_c (\ll d_h n_h)$: key-value 벡터의 압축 차원. 기존 입력차원보다 훨씬 작음.

${d_c}' (\ll d_h n_h)$: query 벡터의 압축 차원.
$h_t \in \mathbb{R}^d$: t번째 토큰의 입력 벡터.

 

Key, Value, Query vector

$c^{KV}_t \in \mathbb{R}^{d_c}$: 압축된 key-value vector.

$c^Q_t \in {\mathbb{R}^{d_c}}'$: 압축된 query vector.

$k^C_t \in \mathbb{R}^{n_h \times d_h}$: 각 어텐션 헤드의 압축된 key vector.

$v^C_t \in \mathbb{R}^{n_h \times d_h} $: 각 어텐션 헤드의 압축된 value vector.

$q^C_t \in \mathbb{R}^{n_h \times d_h} $: 각 어텐션 헤드의 압축된 query vector.

 

변환 가중치 행렬

$W^{DKV} \in \mathbb{R}^{d_c \times d}$: 입력 벡터 $h_t$를 압축된 key-vlaue vector로 변환 (down-projection)하는 가중치.

$W^{UK}, W^{UV} \in \mathbb{R}^{d_h n_h \times {d_c}}$: 압축된 key, value 벡터를 확장하는 (up-projection) 가중치.

$W^{DQ} \in \mathbb{R}^{{d_c}' \times d}$: 입력 벡터를 압축된 query 벡터로 변환하는 가중치.

$W^{UQ} \in \mathbb{R}^{d_h n_h \times {d_c}'}$: 압축된 query 벡터를 확장하는 가중치.

 

RoPE 및 위치 인코딩

- ROtary Positional Encoding (RoPE): 상대적 위치정보를 key, query에 반영.

$W^{KR}, W{QR} \in \mathbb{R}^{d^R_h \times d_c}$: RoPE 적용을 위한 가중치 행렬.

 

최종 출력 및 어텐션 연산

$o_{t,i}$: i번째 어텐션 헤드의 출력.

$u_t$: 모든 어텐션 헤드의 최종 결합된 출력.

$W^O \in \mathbb{R}^{d \times (d_h n_h)}$: 최종 출력을 위한 변환 가중치.

 

이제 논문에 나와있는 수식을 한줄씩 볼게요.

 

Key 및 Value 벡터 생성

$$c^{KV}_t=W^{DKV}h_t$$

입력 벡터를 down-projection하는 Key-value 압축 과정. 이를 통해 메모리 효율을 높임.

$$[k^{C}_{t,1} ; k^{C}_{t,2};...;k^{C}_{t,n_h}]=k^C_t=W^{UK}c^{KV}_t$$

key vectors는 각 어텐션 헤드별로 확장 (up-projection)됨.

$$k^R_t = \text{RoPE}(W^{KR}h_t)$$

RoPE를 적용하여 각 key 벡터에 위치 정보를 포함.

$$k_{t,i}=[k^C_{t,i};k^R_t]$$

압축된 key vector와 RoPE 변환된 key 벡터를 결합하여 최종 key 벡터 생성.

$$[v^C_{t,1};v^C_{t,2};...;v^C_{t,n_h}]=v^C_t=W^{UV} c^{KV}_t$$

Value 벡터도 key와 유사하게 각 어텐션 헤드별로 확장.

 

Query 벡터 생성

$$c^Q_t =W^{DQ} h_t$$

입력 벡터 $h_t$를 down projection을 통해 query 벡터로 변환.

$$[q^C_{t,1};q^C_{t,2};...;q^C_{t,n_h}]=q^C_t=W^{UQ} c^Q_t$$

각 어텐션 헤드에서 연산될 query 벡터 생성.

$$[q^R_{t,1};q^R_{t,2};...;q^R_{t,n_h}]=q^R_t=\text{RoPE}(W^{QR} c^Q_t)$$

Query 벡터에 RoPE를 통해 상대적 위치정보 반영.

$$q_{t,i}=[q^C_{t,i};q^R_{t,i}]$$

압축된 query 벡터와 RoPE 변환된 벡터가 결합하여 최종 query 벡터 생성.

 

Attention 값 연산

$$o_{t,i}=\sum^{t}_{j=1}\text{Softmax}_j (\frac {q^T_{t,i}k_{j,i}}{\sqrt{d_h + d^R_h}})v^C_{j,i}$$

각 query 벡터 $q_{t,i}$와 key 벡터 $k_{j,i}$ 간의 유사도를 계산하여 Softmax를 통해 가중치를 구함.
value 벡터 $v^C_{j,i}$에 가중치를 적용해 가중합.

$$u_t=W^o [o_{t,1};o_{t,2};...;o_{t,n_h}]$$

모든 어텐션 헤드에서 계산된 출력을 결합하고 $W^O$를 적용하여 최종 출력 벡터 $u_t$를 생성.

 

Latent 벡터를 통해 key, value, query 를 효율적으로 변환하여 메모리 최적화를 이루는 과정이에요. RoPE를 사용해서 위치 정보를 반영하며, 어텐션 연산은 Softmax 기반의 가중합으로 이루어지죠. 최종 출력에서는 여러 어텐션 헤드를 결합해 모델의 추론능력을 극대화하는 과정을 지금까지 수식을 통해 설명했어요.

 

이런 매커니즘을 통해 큰 규모의 언어모델에서도 효율적인 메모리 사용과 빠른 추론을 가능하게 해요.

2.1.2. DeepSeekMoE with Auxiliary-Loss-Free Load Balancing

여기도 변수 먼저 확인하고 수식 해석 해볼게요.

 

기초 변수 및 벡터

$u_t$: 입력 벡터 (t번째 토큰의 입력)

${h}'_t$: MoE 레이어를 통과한 후의 출력 벡터

 

전문가 (Experts) 및 개수

$N_s$: 공유형 전문가 (shared experts)의 수

$N_r$: 라우팅된 전문가 (routed experts)의 수

 

게이트 관련

$g_{i,t}$: i번째 라우팅된 전문가에 대한 게이트 값

$g'_{i,t}$: 비정규화된 게이트 값

$b_i$: 전문가 $i$에 대해 부하 균형을 위해 추가된 편향 값

$s_{i,t}$: $i$번째 전문가에 대한 affinity 점수 (토큰과 전문가 간의 유사도)

 

손실 및 부하 균형 관련

$L_\text{Bal}$: 부하 균형을 위한 손실 함수

$f_i$: 각 전문가가 시퀀스에서 처리한 개수

$P_i$: 시퀀스에서 각 전문가의 평균 부하

$\alpha$: 부하 균형 손실의 조정 계수

$\gamma$: 동적 편향 업데이트 속도를 제어하는 하이퍼파라미터

 

Feed-Forward Network (FFN)

$\text{FFN}^{(s)}_i$: i번째 공유 전문가의 FFN

$\text{FFN}^{(r)}_i$: i번째 라우팅된 전문가의 FFN

 

Basic Architecture of DeepSeekMoE

Mixture of Experts (MoE)는 입력 데이터 (토큰 벡터)를 각 전문가 네트워크 중 일부에만 라우팅해서 처리하는 구조에요. 모든 전문가 네트워크가 아니라 소수의 전문가 네트워크만 활성화하기 때문에 대규모 모델에서도 계산 효율이 극대화되는 장점이 있어요.

DeepSeek-V3가 기존 MoE 방식 다른 차별화된 특징은 아래와 같아요.
1) 전문가 유형
- Shared Experts: 모든 입력에 대해 항상 활성화되는 전문가에요. 주요 패턴을 학습해서 모든 입력에 공통적으로 적용되는 피드백을 제공해요.

- Routed Experts: 특정 입력에만 활성화되는 전문가에요. 각 입력 토큰은 affinity 점수에 따라 소수의 라우팅된 전문가에게 전달돼요.

2) FFN 구조

각 전문가 $i$는 자체 FFN 레이어를 가지고 있어요. 공유형 전문가와 라우팅된 전문가의 출력을 합산해서 최종 결과를 생성해요.

 

이제 수식을 살펴볼게요.

 

$$h'_t=u_t + \sum^{N_s}_{i=1}\text{FFN}^{(s)}_i (u_t)+\sum^{N_r}_{i=1}g_{i,t} \text{FFN}^{(r)}_i (u_t)$$

입력 벡터 $u_t$는 공유형 전문가 $\text{FFN}^{(s)}_i$와 라우팅된 전문가 $\text{FFN}^{(r)}_i$의 출력을 가중합하여 최종 출력 벡터 $h'_t$를 생성.
공유형 전문가는 항상 활성화되고, 라우팅된 전문가의 활성화는 게이트 값 $g_{i,t}$에 따라 결정.

$$g{i,t}=\frac{g'_{i,t}}{\sum^{N_r}_{j=1}g'_{j,t}}$$

비정규화된 게이트 값 $g'_{i,t}$를 모든 라우팅된 전문가의 비정규화된 게이트 값의 합으로 나누어 정규화. 이 과정을 통해 전문가 간의 균형잡힌 기여를 보장.

$$g'_{i,t}=\begin{cases} s_{i,t}, & s_{i,t} \in \text{TopK}(\{s_{j,k} | 1 \leqslant j \leqslant N_r\}, K_r) \\ 0, & \text{otherwise} \end{cases}$$

각 전문가 $i$의 affinity 점수 $s_{i,t}$가 상위 $K_r$에 포함되면 $g'_{i,t}=s_{i,t}$로 설정하고, 그렇지 않으면 0으로 설정.

이 과정을 통해 각 토큰에 대해 적절한 전문가를 선택.

$$s_{i,t}=\text{Sigmoid}(u_t^T e_i)$$

Affinity 점수 $S_{i,t}$는 입력벡터 $u_t$와 전문가 가중치 벡터 $e_i$ 간의 내적을 계산하고 Sigmoid 활성화 함수를 적용해 계산.

Sigmoid 점수는 [0,1] 범위로 제한되고 전문가와 입력간의 상관성을 나타내게 됨.

 

Auxiliary-Loss-Free Load Balancing

일부 전문가 FFN이 지나치게 많은 토큰을 처리하고, 나머지 전문가 FFN은 거의 선택되지 않는 상황 즉, 부하 불균형 상황은 계산자원이 비효율적으로 사용되고, 모델의 병렬처리 성능을 감소시켜요. 기존에는 부하 불균형의 해결을 위해 auxiliary loss를 적용해서 학습을 진행했어요. 하지만 보조 손실의 크기를 지나치게 크게 설정하면 주요 작업의 성능이 저하되는 문제가 있었기 때문에 DeepSeep-V3에서는 보조손실을 적용하지 않는 학습 방법을 고안했어요.

이제 수식으로 볼게요.

 

$$g'_{i,t}=\begin{cases} s_{i,t} & s_{i,t}+b_i \in \text{TopK}(\{s_{j,k} + b_j | 1 \leqslant j \leqslant N_r \}, K_r) \\ 0 & \text{otherwise} \end{cases}$$

Affinity 점수 $s_{i,t}$에 편향 $b_i$를 더한 후, 상위 $K_r$에 포함되는지 판단. 상위 $K_r$에 포함되면 비정규화 게이트 $g'_{i,t}$는 $s_{i,t}$로 설정되고, 그렇지 않으면 0이 됨. 편향 $b_i$는 훈련 과정 중 동적으로 업데이트되어 부하 균형을 유지하는데 중요한 역할을 함.

훈련 각 스텝에서 전문가의 부하 상태를 모니터링해서 편향 $b_i$를 동적으로 조정하는 과정이에요. 전문가가 과부하 상태면 $b_i$를 감소시켜 해당 전문가가 덜 선택되도록 하고, 전문가가 과소 부하 상태라면 $b_i$를 증가시켜 더 자주 선택되도록 하는거에요. 따라서 훈련이 될 수록 부하 불균형이 자동적으로 해소될 수 있도록 도와요.

 

Complementary Sequence-Wise Auxiliary Loss

위 auxiliary-loss-free load balancing은 전반적인 전문가 부하 균형을 유지하는데에 효과적이에요. 하지만, 개별 시퀀스 내에서 극단적인 부하 불균형이 발생될 수도 있어요. 특정 시퀀스에서는 소수의 전문가만 선택되어 부하가 한쪽으로 치우치는 현상처럼요. 이를 해결하기 위해 DeepSeek-V3에서는 보완적 보조 손실 (complementary sequence-wise auxiliary loss)를 추가로 도입해요.
보조 손실은 시퀀스 내에서 전문가 간의 부하가 균형을 이루도록 유도해요. 각 시퀀스에서 전문가가 처리한 토큰 수와 평균 부하를 기반으로 부하 균형 손실을 계산해서 전문가의 balancing을 해주는 거죠.

 

$$\mathcal{L}_{\text{Bal}}=\alpha \sum^{N_r}_{i=1} f_i P_i$$

부하 균형 손실 $\mathcal{L}_{\text{Bal}}$은 전문가 부하 $f_i$와 평균 부하 $P_i$를 기반으로 계산. 손실함수는 전문가가 불균형하게 선택되는 것을 방지하여 균형있게 분산. $\alpha$는 손실의 크기를 조정하는 하이퍼파라미터.

$$f_i=\frac{N_r}{K_t T} \sum^{T}_{t=1}\mathbb{1} (s_{i,t} \in \text{TopK}(\{s_{j,t} | 1 \leqslant j \leqslant N_r\}, K_r))$$

$f_i$는 전문가 $i$가 처리한 토큰의 총 개수이며, $T$는 시퀀스 길이. $\mathbb{1}$ 는 조건이 참일 경우 1, 거짓일 경우 0을 반환하는 인디케이터 함수임. 시퀀스에서 각 토큰 $t$에 대해 전문가 $i$가 상위 $K_r$ 전문가로 선택된 횟수를 합산하여 해당 전문가가 처리한 토큰 수 $f_i$를 측정. 이를 통해 각 전문가가 얼마나 자주 선택되었는지 알 수 있음.

$$s_{i,t}=\frac{s_{i,t}}{\sum^{N_r}_{j=1} s_{j,t}}$$

Affinity 점수 $s_{i,t}$를 모든 전문가의 affinity 점수 합으로 나누어 정규화. 정규화된 점수는 각 전문가가 토큰을 처리하는 비율을 공정하게 반영.

$$P_i = \frac{1}{T} \sum^{T}_{t=1}s'_{i,t}$$

각 토큰에 대해 정규화된 affinity 점수 $s'_{i,t}$의 평균을 계산하여 시퀀스 전체에서 전문가 $i$가 평균적으로 처리한 부하를 나타냄. 이는 부하 균형 손실을 계산하는데에 사용됨.

 

이 과정을 통해 편향과 부하 균형 손실을 결합하여 모델이 불균형한 전문가 선택을 피하고 계산 효율성과 성능을 동시에 유지하도록 하는 것이에요.

 

Node-Limited Routing

DeepSeek-V2에서 사용된 Device-Limited Routing 개념을 확장해서 V3에서는 Node-Limited Routing 매커니즘을 도입했어요. 이 매커니즘은 훈련 중 통신 비용을 줄이기 위해 각 토큰이 최대 $M$개의 노드로만 라우팅될 수 있도록 제한해요.

각 토큰 $u_t$는 라우팅될 때, 각 노드에 분산된 전문가들의 affinity 점수를 기반으로 각 입력 토큰이 라우팅될 상위 전문가의 수 $K_r$, 라우팅 가능한 최대 노드 수 $M$에 대해 상위 $\frac{K_r}{M}$의 affinity 점수를 가진 전문가들이 포함된 노드를 선택해요.
이 제한을 통해 통신 비용 절감과 함께 모델이 계산-통신 간의 거의 완전한 오버랩을 달성할 수 있도록해요. 즉, 계산과 통신 작업이 효율적인 병렬 처리로 수행되어 전체 훈련시간이 단축돼요.

 

No Token-Dropping

MoE 모델에서 부하 불균형이 심하거나 계산 자원이 부족하면, 일부 토큰이 처리되지 않고 drop 되는 문제가 발생할 수 있어요. 하지만 DeepSeek-V3에서는 위에서 설명한 부하 균형 메커니즘을 통해 이 문제를 해결해서 훈련이나 추론 중 토큰이 드랍되지 않아요. 따라서 훈련과 추론 모두에서 안정적이고 효율적인 성능을 유지할 수 있죠.

Multi-Token Prediction (MTP)

Multi-Token Prediction (MTP)는 DeepSeek-V3의 주요 학습 목표 중 하나로, 각 위치에서 여러 미래 토큰을 예측하도록 확장해요.
기존의 단일 토큰 예측을 넘어 여러 후속 토큰을 한번에 예측함으로써 훈련신호를 밀집시켜 데이터 효율성을 향상시키고, 모델이 미래 토큰 예측을 위한 전반적인 표현을 사전 계획할 수 있도록 해요.

기존 방식은 병렬로 $D$개의 추가 토큰을 독립된 출력헤드로 예측하는 방식이에요.
DeepSeek-V3에서는 순차적으로 추가 토큰을 예측하고, 각 예측 깊이에서 인과적 연결 (causal chain)을 유지해요. 이로 인해 예측이 이전 결과에 의존을 할 수 있기 때문에 학습에 더 유리해요.

 

MTP Modules

MTP는 $D$개의 순차적인 모듈을 사용해 $D$개의 추가 토큰을 예측해요.

각 $k$번째 MTP 모듈은 다음 구성 요소로 이루어져요.
$\text{Emb}$: 공유된 임베딩 레이어

$\text{OutHead}$: 공유된 출력 헤드, 로짓으로 매핑하고 Softmax를 적용하여 확률 계산.

$\text{TRM}_k$: k번째 깊이의 transformer block

$M_k \in \mathbb{R}^{d \times 2d}$: 선형 투영 행렬 (projection matrix)

 

$${h'}^{k}_i=M_k[\text{RMSNorm}(h^{k-1}_1); \text{RMSNorm}(\text{Emb}(t_{i+k}))]$$

이전 깊이에서의 입력 토큰 표현$h^{k-1}_{i}$, $(i+k)$번째 토큰 임베딩 $\text{Emb}(t_{i+k})$.

각 $i$번째 입력 토큰은 이전 깊이에서의 표현 $h^{k-1}_{i}$와 $(i+k)$번째 토큰의 임베딩을 결합하여 선형 투영 행렬 $M_k$에 입력돼요. 이 투영은 각 깊이에서 필요한 새로운 예측 표현을 생성해요.

$$h^{k}_{1:T-k} = \text{TRM}_k (h'^{k}_{1:T-k})$$

투영된 표현은 transformer 블록에 입력되어 최종적으로 $k$번째 깊이에서의 출력 $h^k_{1:T-k}$를 생성해요. 이 표현은 현재 깊이에서 추가 토큰을 예측하는데 사용돼요.

$$P^k_{i+k+1}=\text{OutHead}(h^k_i)$$

$P^k_{i+k+1}$은 $k$번째 깊이에서의 추가토큰 $t_{i+k+1}$에 대한 예측확률이에요. transformer 블록에서 생성된 표현 $h^k_i$는 출력 헤드에 입력되어 로짓으로 변환되고, Softmax를 적용하여 예측 토큰의 확률 분포를 계산해요.

 

MTP Training Objective

$\mathcal{L}^k_{\text{MTP}}$: $k$번째 깊이에서의 MTP 손실

$T$: 입력 시퀀스 길이

$t_{i}$: $i$번째 위치의 정답 토큰

$P^k_i [t_i]$: $k$번째 MTP 모듈이 예측한 $t_i$ 토큰의 확률

$$\mathcal{L}^k_\text{MTP} = \text{CrossEntropy}(P^k_{2 + k : T+1}, t_{2+k:T+1}) = -\frac{1}{T} \sum^{T+1}_{i=2+k} \text{log} P^k_i [t_i]$$

$k$번째 깊이에서 각 토큰 위치 $i$에 대해 예측된 확률 분포 $P^k_i$와 정답토큰 $t_i$ 간의 차이를 측정해요. Cross-Entropy 손실은 모델이 정답에 가까운 높은 확률을 할당할 수록 값이 작아지고, 정답 예측 정확도를 최적화하는데에 사용돼요.

 

$\mathcal{L}_{\text{MTP}}$: 전체 MTP 손실

$D$: 예측할 추가 토큰의 수 (MTP 깊이)

$\lambda$: 가중치 파라미터 (MTP 손실의 비중을 조절)

$$\mathcal{L}_{\text{MTP}}=\frac{\lambda}{D} \sum^{D}_{k=1} \mathcal{L}^k_{\text{MTP}}$$

각 깊이에서의 손실 $\mathcal{L}^k_{\text{MTP}}$를 평균내고 가중치 $\lambda$를 곱하여 전체 MTP 손실을 계산해요. 이 손실은 DeepSeek-V3의 추가적인 학습 목표로 작용하며, 모델이 미래 토큰의 예측 능력을 개선하도록 도와요.

 

이러한 training objective를 통해 모델의 전반적인 표현 능력과 미래 예측 능력이 향상돼요.

 

MTP in Inference

MTP 모듈은 훈련중에만 사용되고 추론시에는 MTP 모듈이 제거되어, 추론 비용을 증가시키지 않으면서 훈련 할 때 모델의 표현력과 성능을 향상시킬 수 있어요. 또한, speculative decoding과 같은 기술에 재활용하여 생성 지연 시간을 추가로 단축할 수도 있어요.

3. Infrastructures

3.1. Compute Clusters

2,048개의 NVIDIA H800 GPU로 구성된 클러스터에서 학습. 효율적인 데이터 분산 및 통신 최적화를 통해 학습할 수 있도록 설계되었다고 합니다.

각 노드는 8개의 H800 GPU로 구성되어 있으며, NVLink 및 NVSwitch로 연결되어 노드 내 GPU 간의 고속 통신을 보장한다고 해요. 또한 노드 내 GPU 간 통신 병목을 제거하고 빠른 메모리 엑세스와 데이터 공유가 가능하다고 해요.

노드 간 통신은 InfiniBand (IB)를 통해 이루어져 GPU 간 데이터 전송 속도를 극대화해요. 이를 통해 병렬 처리 작업에 필수적인 통신 비용을 줄였다고 합니다.

 

이러한 컴퓨팅 자원을 활용해 고효율 및 비용 절감형 훈련을 진행했는데, 1T 토큰 당 180,000 H800 GPU hour만을 소모하였는데 이는 유사한 크기의 다른 모델 대비 상당한 비용 절감을 보여요.

3.2. Training Framework

DeepSeek-V3의 훈련 프레임워크는 HAI-LLM 프레임워크를 기반으로 동작해요. Pipeline Parallelism (PP), Expert Parallelism (EP), Data Parallelism (DP)를 조합하여 대규모 모델을 효율적으로 훈련했어요.

3.2.1. DualPipe and Computation-Communication Overlap

대규모 MoE 모델에서는 전문가 노드 간 통신으로 인해 계산-통신이 비효율적일 수 있어요. 이러한 상황은 pipeline bubble 현상을 유발하여 GPU 자원이 비효율적으로 사용돼요. pipeline bubble은 한 레이어가 계산을 마칠 때까지 다른 레이어가 대기하게 되는 문제로 인해 GPU 자원이 낭비되는 문제에요.

 

DualPipe 알고리즘은 forward, backward 계산과 통신을 동시에 overlap 하여 pipeline bubble을 최소화해요. 각 chunks는 네 개의 구성요소 (Attention, all-to-all dispatch, MLP, all-to-all combine)으로 나누어지고, backward 계산을 다시 입력과 가중치 업데이트로 세분화돼요. 또한 GPU Streaming Multiprocessors (SMs)를 통해 자원을 동적으로 재분배하여 통신이 필요한 동안 계산 작업이 멈추지 않도록 하여, 통신 병목을 줄이고 자원 활용률을 극대화해요.

3.2.2. Efficient Implementation of Cross-Node All-to-All Communication

모델의 각 전문가 간의 노드 간에는 많은 양의 데이터 전송이 필요해요. 특히, 노드 간 통신이 병목이 될 수 있어요. 따라서 네트워크 자원을 최적으로 활용해 이 문제를 해결하려 했어요. 노드 간 통신은 InfiniBand(50 GB/s)로 처리하고, 노드 내부 통신은 NVLink(160 GB/s)를 사용했어요. 각 토큰의 데이터를 최대 4개의 노드로 제한하여 IB 트래픽을 줄이고, 각 노드의 전문가에게 데이터를 즉각 전달해요. 또한 GPU 의 20개의 SM만으로 통신자원을 관리하며, Warp Specialization 기술을 통해 IB와 NVLink의 상이한 대역폭을 동적으로 활용했다고 해요. 이를 통해 IB와 NVLink 간의 데이터 전송은 동시에 중첩되어 효율적으로 이루어져요.

이 전략을 통해 각 토큰이 평균적으로 노드당 3.2개의 전문가를 선택하게 하고, 최대 13개의 전문가로 확장할 수 있어도 통신 비용은 일정하게 유지돼요.

3.2.3. Extremely Memory Saving with Minimal Overhead

메모리 소모를 줄이기 위해 다음과 같은 기술들을 사용했어요:

1) Recomputation of RMSNorm and MLA Up-projection: 중간 활성화 값을 저장하는 대신 필요할 때 재계산을 통해 메모리를 절약했어요. 캐싱을 감소시켜서 연산을 조금 더 해도 메모리를 절약했다는 뜻!

2) Exponential Moving Average in CPU: 모델 파라미터의 지수이동평균 (EMA) 값을 GPU 대신 CPU 메모리에 저장하고 비동기적으로 업데이트하여 GPU 메모리 부담을 줄여요.

3) Shared Embedding and Output Head for Multi-Token Prediction: MTP 모듈과 메인 모델 간에 임베딩 및 출력 헤드를 공유하여 메모리 사용을 최적화했어요.

 

이러한 메모리 절약 기법을 통해 GPU 메모리 소모를 최소화하여 더 큰 배치 크기와 효율적인 훈련을 가능하게 했어요.

3.3. FP8 Training

DeepSeek-V3는 FP8(Floating Point 8-bit) 훈련을 통해 효율성과 수치적 안정성을 균형있게 유지하면서, 메모리 소모와 통신 비용을 절약했어요. FP8은 낮은 비트 정밀도를 활용해 훈련 속도를 대폭 향상시키면서 양자화 (quantization) 오류를 최소화하는데에 중점을 둬요.

3.3.1. Mixed Precision Framework

Mixed precision framework는 FP8, BF16, FP32의 다양한 정밀도를 상황에 맞게 결합하여 사용하는 프레임워크에요. General Matrix Multiplication (GEMM) 연산은 FP8 정밀도로 수행되며, BF16 대비 2배의 속도 향상을 제공해요.

Fprop (Forward pass), Dgrad (Activation backward pass), Wgrad (weight backward pass)에서 FP8을 사용해요.

BF16/FP32의 경우 embedding module, output head, MoE gating modules, normalization operators, attention operators와 같은 민감한 연산에서 수치적 안정성 확보를 위해 그대로 사용되었어요.

3.3.2. Improved Precision from Quantization and Multiplication

여기서는 FP8 훈련에서 발생할 수 있는 저정밀 문제를 해결하고 정확도를 개선하기 위해 핵심적인 전략을 설명해요.

 

Fine-Grained Quantization

FP8 형식은 지수 비트가 제한되어 있어 dynamic range가 축소되는데, 이는 overflow or underflow 문제가 발생하기 쉬운 상황을 만들어요.

FP8에서는 입력 텐서의 최대 절대값을 기준으로 전체 텐서에 대한 단일 스케일링이 적용되는데, 이는 활성화 값이 이상치에 매우 민감하기 때문에 양자화 오류를 유발할 수 있어요.

따라서, 더 세분화된 수준에서의 fine-grained quantization method를 제안해요. 각 요소를 더 적은 단위로 나눠서 세밀하게 scaling 하는거에요.

활성화 값은 1*128 타일 단위로 그룹화해서 각 타일마다 별도의 스케일링을 적용해요 (토큰당 128채널).

가중치는 128*128 블록 단위로 그룹화하여 가중치 양자화 시 작은 그룹별로 적응형 스케일링을 적용해요.

이 방식은 이상치에 적응할 수 있도록 더 세밀하게 조정해서 양자화 오류를 줄이고, 훈련 안정성을 보장해 줄 수 있다고 합니다.

추가적으로 General Matrix Multiplication (GEMM) 연산의 내부 차원 (K)에 따라 그룹별 스케일링 팩터를 도입해요.

표즌 FP8 GEMM에서는 지원하지 않지만, FP32 누적합 전략과 결합해서 효과적으로 구현했다고 합니다.

 

Increasing Accumulation Precision

FP8 연산은 자주 underflow와 정밀도 저하 문제가 발생하고 대규모 모델 훈련에서는 gradient와 활성화 계산이 정확도에 중요한 영향을 미쳐요.

NVIDIA H800 GPU에서 FP8 GEMM 연산의 누적 정밀도는 약 14bit로 제한되어 있기 때문에 FP32 누적합 (23-bit) 대비 낮아요.

4,096차원 행렬 곱 연산에서 상대 오차가 약 2%에 달하는 것으로 관찰됐다고 해요.

이를 해결하기 위해 Matrix Multiply-Accumulate (MMA) 실행 중 간헐적으로 부분 결과를 FP32 레지스터로 승격하여 높은 정밀도로 누적해요. 128요소 마다 이 부분 결과를 CUDA 코어의 FP32 레지스터로 전송해서 정확한 결과를 누적해요.

Warpgroupt-Level MMA (WGMMA): 하나의 워프그룹은 승격 누적을 수행하고, 동시에 다른 워프그룹은 GEMM 연산을 진행하여 계산과 누적합을 중첩해요. 128 요소 당 4개의 WGMMA 실행이 이상적으로, 정밀도를 크게 향상시키면서 추가적인 오버헤드는 감소시켜요.

 

Mentissa over Exponents

기존 FP8 방식에서는 hybrid FP8 포맷을 사용하여 다양한 연산 상황에 맞게 E4M3 (4-bit 지수, 3-bit mantissa / Fprop에서 사용) 또는 E5M2 (5-bit 지수, 2-bit mantissa / Dgrad, Wgrad 에서 사용) 를 선택적으로 적용해요. 하지만, DeepSeek-V3에서는 모든 텐서에 대해 E4M3 방식을 사용하는 FP8 형식에서 제한된 지수 비트를 보완하기 위해 E4M3 (4-bit exponent and 3-bit mantiss) 사용하는 방식을 채택해 더 높은 정밀도를 제공해요.
즉, 유효숫자 비트를 늘려 정밀도를 확보하고, 블록 기반 스케일링 전략을 통해 동적 범위의 한계를 보완하는 식이에요.

 

Online Quantization

기존의 텐서단위 양자화는 delayed quantization 방식을 사용해요. 이전 iteration에서 계산된 maximum absolute value의 히스토리를 유지해서 현재 iter의 값을 추정해요. 하지만, DeepSeek-V3는 더 정확한 스케일링과 프레임워크 단순화를 위해 온라인 양자화 방식을 도입해요.

1*128 활성화 타일 또는 128*128 가중치 블록에 대해 현재 최대 절댓값을 실시간으로 계산하고, 이 값을 기반으로 scaling factor를 도출해요. 이를 통해 활성화 값과 가중치를 FP8 포맷으로 실시간 양자화해요.

각 타일이나 블록마다 스케일링 팩터를 실시간으로 적용하기 때문에 양자화 오류를 최소화 하고 활성화 값과 가중치의 동적 범위 문제를 효과적으로 처리했어요.

 

여기까지 보고 Pretraining으로 넘어갈게요. hardware에 대한 이야기가 너무 많아서요 ㅎ...

4. Pre-Training

4.1. Data Construction

DeepSeek-V3의 사전 훈련 데이터는 DeepSeek-V2 보다 확장 및 개선되었어요. 주요 요소는 아래와 같아요.

- 수학 및 프로그래밍 샘플의 비율을 증가, 영어와 중국어 외의 다국어 데이터를 확장.
- 데이터 처리 파이프라인은 중복을 최소화, 데이터 다양성을 유지하도록 최적화.

- 문서의 데이터 무결성 보장을 위해 document packing 방식 적용

- DeepSeekCoder-V2에서 사용된 Fill-in-Middle (FIM) 전략을 채택하여 중간 텍스트 예측 능력 강화

--> Prefix-Suffix-Middle(PSM) 프레임워크를 사용하여 데이터를 구성. FIM 전략 적용 비율은 0.1로 설정.

$<|\text{fim_begin}|> f_{pre} <|\text{fim_hole}|> f_{suf} <|\text{fim_end}|> f_{middle} <\text{|eos_token}|>$

- 토크나이저는 128K의 확장된 vocabulary size를 지원, Byte-level BPE (Byte Pair Encoding)을 사용. 구두점과 줄 바꿈을 결합한 토큰을 포함하는 새로운 preprocessor를 통해 다양한 문장 구조에 대응.

4.2. Hyper-Parameters

Model Hyper-Parameters
Transformer layers: 61개
Hidden dimension: 7168
Attention heads: 128개
Per-head dimension: 128
KV compression dimension: 512
Query compression dimension: 1536

Training Hyper-Parameters
Optimizer: AdamW

$\beta_1$: 0.9

$\beta_2$: 0.95

Weight decay: 0.1

Max sequence length: 4K

Learning rate scheduler: linearly increase -> constant -> cosine decay curve
Training tokens: 14.8T

4.3. Long Context Extension

2단계의 확장 훈련을 통해 점진적으로 max sequence 길이 증가를 설계했어요.

Pretrain 이후 YaRN (Yet Another Rotary Network) 기법을 적용해 문맥 확장 훈련을 두 단계에 걸쳐 수행했어요.

1단계에서 4K -> 32K, 2단계에서 32K -> 128K로 확장했다고 합니다.

각 단계마다 1000 step 학습을 통해 시퀀스 길이를 점진적으로 늘려갔다고 해요.

YaRN은 decoupled shared key $K^R_t$에 적용되며, 각 단계에서 동일한 하이퍼파라미터 설정을 유지했어요.

Scale $s$: 40, $\alpha$: 1, $\beta$: 32, scaling factor: $\sqrt{t}=0.1 \text{ln} s+1$, lr: $7.3 \times 10^{-6}$

batch size만 1단계에서 1920, 2단계에서 메모리 효율성을 위해 480으로 감소했다고 해요.

 

Needle in a Haystack (NIAH) 테스트를 통해 긴 문맥에서의 성능을 측정했고, 128K 길이의 문맥에서도 일관된 성능을 보였고 긴 시퀀스에서도 모델의 성능이 감소하지 않는 것을 검증했어요.

4.4. Evaluations

이 부분은 빠르게 넘어갈게요 ㅎㅎ...

Open-source models와의 비교

Auxiliary-loss-free balancing에 대한 ablation study

5. Post-Training

5.1. Supervised Fine-Tuning

데이터는 1.5M의 다양한 도메인에 걸친 instruction-tuning 데이터셋을 사용했고, 도메인 별로 도메인에 맞는 데이터 생성 방법이 사용되었다고 해요.

 

Reasoning Data

수학, 코드 문제, 논리 퍼즐 등 추론 중심의 데이터셋은 DeepSeek-R1(논란의 그 모델..)의 CoT 추론능력을 활용해서 다단계 논리적 문제 해결과정을 포함하도록 생성했다고 해요. 정답 뿐 아니라 문제 해결 과정에서의 각 단계별 추론을 포함하여 학습에 사용했다고 합니다.

하지만 DeepSeek-R1이 생성한 일부 데이터셋은 불필요하게 길어 효율성이 떨어지거나, 일관된 구조가 없거나, 명확하지 않는 경우가 있었다고 해요.

R1 모델이 제공하는 높은 정확성과 응답의 명확성, 간결성의 균형을 유지하는 데이터셋의 생성을 목표로 했어요. 각 도메인 (코드, 수학, 일반 추론)에 특화된 전문가 모델을 개발하여 데이터 생성에 활용했고, 두 가지 형태의 SFT sample을 생성하도록 했어요.

1) <problem, original response>
2) <system prompt, problem, R1 response>

모델이 응답을 생성할 때 reflection and verification 을 포함하도록 system prompt를 가이드했어요. 이를 통해 R1의 패턴을 학습하면서 명확한 출력과 성능 향상을 목표로 했어요.

 

Non-Reasoning Data

창의적인 글쓰기, 역할극, 단순한 질의응답과 같은 일반적 task를 위한 데이터셋이에요. DeepSeek-V2.5를 활용해 데이터를 생성하고, 사람이 정확성과 데이터의 신뢰성을 검증했어요.

추론이 필요하지 않은 태스크에서 정확성과 자연스러움을 극대화하고, 창의적 텍스트 생성과 사용자 instruction prompt 처리를 위한 데이터로 사용했어요.

 

SFT Settings

DeepSeek-V3-Base에 2 epochs 지도학습을 수행했어요.

Cosine decay lr을 적용해서 학습 초기에서 최종까지 학습률을 점진적으로 낮췄어요 ($5 \times 10^{-6}$ -> $1 \times 10^{-6}$)

여러 샘플로부터 하나의 시퀀스를 구성했는데, 샘플 마스킹 전략을 통해 개별 샘플들이 독립적으로 처리되고, 상호 영향을 미치지 않도록 설정했다고 해요.

5.2. Reinforcement Learning

5.2.1. Reward Model

RL process에서 rule-based reward model과 model-based RM을 활용했어요.

 

Rule-Based RM

수학 문제 같은 명확한 규칙 기반 검증이 가능한 문제에 적용.

수학 문제에서 정답은 지정된 포맷을 요구, 이를 통해 결과의 정확성 검증.

LeetCode 문제의 경우 컴파일러를 사용해 test case 기반으로 피드백 제공

이는 조작이나 잘못된 해석에 강하고 신뢰성이 높음.

 

Model-Based RM

자유 형식의 답변을 요구하는 질문에 적용

명확한 기준이 없는 질문 (i.e. 창의적 글쓰기)에 대해 모델은 질문과 응답을 입력으로 받아 피드백 제공.

RM은 DeepSeek-V3의 SFT 체크포인트에서 훈련, 선호 데이터를 활용해 피드백을 강화.

Reward Hacking을 방지하기 위해 보상의 결과 뿐 아니라, Chain-of-Thought 과정도 고려하도록 설계.

5.2.2. Group Relative Policy Optimization

GRPO 방식은 기존의 critic model을 사용하지 않고, 그룹 점수로 기준선을 추정해서 최적화하는 방식이에요. DeepSeek-V2에서 확장된 방식으로 질문 $q$에 대해 그룹 샘플링과 상대적 보상 평가를 기반으로 작동해요.

$$J_{\text{GRPO}}(\theta) = \mathbb{E}[q \sim P(Q), \{o_i\}_{i=1}^{G} \sim \pi_{\theta_{\text{old}}}(O|q)] $$

각 질문 $q$에 대해 이전 정책 모델 $\pi_{\theta_{old}}$에서 여러 출력 그룹 $\{o_1, o_2, \dots , o_G\}$를 샘플링. 이러한 출력들은 서로 다른 보상 값 $\{r_1, r_2, \dots , r_G\}$를 가질 수 있음.

$$\frac{1}{G} \sum_{i=1}^{G} \Big(\text{min} \Big( \frac{\pi_{\theta}(o_i|q)}{\pi_{\theta_{\text{old}}}(o_i|q)} A_i, \text{clip} \Big( \frac{\pi_{\theta}(o_i|q)}{\pi_{\theta_{\text{old}}}(o_i|q)}, 1 - \epsilon, 1 + \epsilon \Big) A_i \Big) - \beta \mathbb{D}_{\text{KL}}(\pi_{\theta} || \pi_{\text{ref}}) \Big)$$

각 출력 $o_i$에 대해 현재 정책 모델과 이전 정책 모델 간의 비율 $\frac{\pi_{\theta}(o_i|q)}{\pi_{\theta_{\text{old}}}(o_i|q)}$가 계산됨. 이 비율은 출력이 얼마나 중요하게 다뤄져야 하는지 나타내며, 이를 advantage $A_i$와 곱하여 정책을 업데이트. 또한, 업데이트 비율 $\frac{\pi_{\theta}(o_i|q)}{\pi_{\theta_{\text{old}}}(o_i|q)}$이 급격히 변하는 것을 방지하기 위해 clip 함수를 도입. 이 클립 범위 $[1-\epsilon , 1+\epsilon ]$는 지나치게 큰 변화나 급격한 업데이트를 제한하여 학습 안정성 확보.

$$A_i = \frac{r_i - \text{mean}(\{r_1, r_2, \cdots, r_G\})}{\text{std}(\{r_1, r_2, \cdots, r_G\})}$$

Advantage $A_i$는 그룹 내 각 출력의 상대적 중요성을 나타냄. 평균 보상보다 높은 보상을 받을 경우 $A_i$가 커지며, 반대로 낮은 보상을 받을 경우 $A_i$는 음수가 됨.

$$D_{\text{KL}}(\pi_{\theta} || \pi_{\text{ref}}) = \frac{ \pi_{\text{ref}}(o_i|q)}{\pi_\theta (o_i | q)} - \log \frac{\pi_{\text{ref}}(o_i|q)}{\pi_{\theta}(o_i|q)} -1$$

KL Divergence 패널티를 이용해 현재 정책 모델 $\pi_\theta$가 기준모델 $\pi_{\text{ref}}$와 크게 벗어나지 않도록 규제.

 

이렇게 현재 정책 모델 $\pi_{\theta}$의 업데이트는 출력의 상대적 중요성과 KL divergence penalty를 고려하여 최적화 함수 $J_{\text{GRPO}}(\theta)$를 최대화하는 방향으로 진행됨.

 

GRPO는 critic model을 사용하지 않으므로, 계산 효율성이 높고 그룹 내 보상 값에 기반하여 업데이트 되기 때문에 안정성과 최적화 속도가 향상돼요.

특히 수학, 코딩, 역할극, QA 등 다양한 도메인에서 벤치마크 성능 향상에 도움을 줄 수 있어요.

5.3. Evaluations

이 부분도 빠르게 지나가 볼게요 하하...

다양한 Chat models와 benchmark 비교

벤치마크 비교 2

Reward bench와 Distil model 성능평가

 

Evaluation은 역시 매우 메모리 효율적으로 학습했음에도, 성능이 매우 좋다!! 입니다.

 

우선은 주요 기술들에 초점을 맞춰서 리뷰를 해보았는데요...

DeepSeek-ai 대단한 것 같네요..ㅠ

사실 OpenAI GPT를 잡았다는 것만 해도 대단한데 학습 효율이 엄청난 걸 보니 진짜 computer science 같은 느낌이에요. AI 소프트웨어만 개발하는게 아니라 하드웨어를 최대한 효율적으로 사용하기 위한 최적화, 하드웨어 이해도가 대단하네요.. 너무 어렵ㄷ....

 

그럼 R1도.. 곧.. 리뷰해보도록 할게요.. 그럼 이만!