모델을 학습하다 보면 꽤 이상한 장면을 자주 보게 된다.

Model architecture는 며칠씩 고민하고, Dataset은 중복률과 품질까지 분석하며, GPU 설정은 소수점 단위로 최적화한다. 그러다가 Optimizer를 고르는 순간이 오면 대개 다음과 같이 끝난다.

optimizer = torch.optim.AdamW(model.parameters(), lr=3e-4)

왜 AdamW인지는 잘 모르겠지만 어제도 잘됐고, Hugging Face example에도 있었으며, 무엇보다 지금 새 Optimizer를 공부하기에는 이미 GPU가 놀고 있다. 충분히 합리적인 결정이다. 나 역시 이런 식으로 수많은 학습을 시작했다.

그런데 Optimizer의 역사를 따라가 보면 이름만 달라진 비슷한 알고리즘의 전시회는 아니다. 각각은 이전 방법이 부딪힌 꽤 구체적인 문제에 대한 답이었다.

• Gradient가 너무 시끄럽다 → 과거 방향을 기억하는 Momentum
• Parameter마다 Gradient scale이 다르다 → 좌표별 보폭을 조절하는 AdaGrad, RMSProp
• 방향과 scale을 모두 보고 싶다 → Adam
• 거대한 Matrix의 상태값이 너무 비싸다 → Adafactor
• Layer마다 체급이 다르다 → LARS, LAMB
• 좌표 하나가 아니라 Matrix의 행·열 관계를 보고 싶다 → Shampoo, SOAP
• Gradient 크기보다 방향만 믿고 싶다 → Lion
• 곡률을 싸게 보고 싶다 → Sophia
• 학습률 Schedule 자체를 없애고 싶다 → Schedule-Free
• Matrix update의 찌그러진 방향을 펴고 싶다 → Muon

이 글에서는 2026년 8월까지 등장한 모든 Optimizer의 이름을 사전처럼 나열하지 않는다. 이름이 붙은 변형만 해도 이미 셀 수 없이 많고, 논문 한 편에서만 쓰인 방법까지 모두 넣으면 글이 아니라 전화번호부가 된다. 대신 현재의 딥러닝 Optimizer를 이해하는 데 필요한 대표 계보를 따라가고, 2025~2026년에 제안된 방법은 널리 검증된 기본값과 구분해 살펴보려고 한다.

Preliminary: Optimizer는 무엇을 결정하는가?

Model parameter를 $\theta$, Step $t$에서 Mini-batch $B_t$로 계산한 Loss를 $\mathcal{L}_{B_t}$라고 하자. Gradient는 다음과 같다.

$$g_t = \nabla_\theta \mathcal{L}_{B_t}(\theta_t).$$

Gradient는 현재 위치에서 Loss가 가장 빠르게 증가하는 방향을 가리킨다. 따라서 Loss를 줄이려면 반대 방향으로 움직여야 한다.

$$\theta_{t+1} = \theta_t-\eta g_t.$$

여기서 $\eta$는 Learning rate다. 이 식만 보면 Optimizer는 Gradient 앞에 숫자 하나를 곱하는 일처럼 보인다. 하지만 실제 문제에서는 다음 질문들이 한꺼번에 생긴다.

1. 이번 Gradient가 우연히 뽑힌 Batch 때문에 흔들린 것은 아닐까?
2. 과거에도 계속 같은 방향이었다면 조금 더 세게 가도 되지 않을까?
3. 어떤 Parameter의 Gradient는 $10^{-1}$이고 다른 Parameter는 $10^{-6}$이라면 같은 보폭이 맞을까?
4. 좁고 비스듬한 골짜기라면 좌표축별 보정만으로 충분할까?
5. 더 좋은 방향을 계산하느라 한 Step이 세 배 느려지면 정말 더 빠른 학습일까?

Optimizer는 “어디로 갈지”와 함께 현재 Gradient를 얼마나 믿을지, 과거를 얼마나 기억할지, 좌표와 Layer와 Matrix를 어떤 단위로 볼지, 그리고 그 판단을 위해 얼마의 Memory와 연산을 지불할지 결정한다.

이 글에서는 특별한 언급이 없으면 $\odot$와 제곱, 나눗셈, 제곱근을 Element-wise 연산으로 사용한다. 또한 구현마다 Momentum에 $(1-\beta)$를 포함하는지, Learning rate를 Velocity에 넣는지 등의 표기 차이가 있으므로 모든 식은 한 가지 일관된 Convention으로 적는다. 상수배는 Learning rate에 흡수될 수 있지만 핵심 동작은 같다.

1. GD와 SGD: 회의를 몇 명과 할 것인가?

Batch Gradient Descent

전체 Dataset이 $N$개의 Sample로 구성되어 있다면 Batch Gradient Descent는 매 Step 모든 Sample의 Gradient를 평균낸다.

$$g_t = \frac{1}{N} \sum_{i=1}^{N} \nabla_\theta \ell_i(\theta_t),$$ $$\theta_{t+1} = \theta_t-\eta g_t.$$

전체 직원에게 설문한 뒤 회사 점심 메뉴를 바꾸는 것과 비슷하다. 의견은 안정적이지만, 전 직원 회의가 끝날 무렵에는 점심시간도 끝나 있을 수 있다. Dataset이 거대해진 딥러닝에서는 매 Update마다 전체 데이터를 읽는 비용이 너무 크다.

Stochastic Gradient Descent

엄밀한 SGD는 매 Step 하나의 Sample $i_t$만 뽑는다.

$$g_t = \nabla_\theta \ell_{i_t}(\theta_t).$$

이 Gradient는 전체 Gradient의 noisy estimate다. 평균적으로는 올바른 방향을 가리킬 수 있지만, 개별 Step은 꽤 흔들린다. 길을 묻기 위해 시민 한 명을 붙잡았는데 하필 그분도 길을 잃은 관광객일 수 있는 셈이다.

Mini-batch SGD

실무에서 흔히 SGD라고 부르는 것은 대부분 Mini-batch SGD다.

$$g_t = \frac{1}{|B_t|} \sum_{i\in B_t} \nabla_\theta \ell_i(\theta_t).$$

한 명보다 여러 명의 의견을 모으므로 Noise가 줄고, GPU가 Matrix 연산을 병렬로 처리하기에도 좋다. Batch size를 키우면 Gradient estimate는 안정되지만 Memory 사용량이 늘며, 일정 규모 이후에는 같은 Data를 처리할 때 Update 횟수가 줄어드는 문제도 생긴다.

SGD의 흔들림이 무조건 나쁜 것은 아니다. Noise가 날카로운 골짜기나 Saddle point를 빠져나오는 데 도움을 줄 수 있고, 때로는 Generalization에도 유리하게 작용한다. 정확한 나침반이 언제나 더 좋은 여행을 보장하지는 않는다. 특히 나침반을 읽는 데 하루가 걸린다면 더욱 그렇다.

2. Momentum과 NAG: 장바구니에 관성을 달다

SGD가 좁은 골짜기를 내려간다고 생각해보자. 아래쪽으로는 꾸준히 내려가야 하지만 좌우 경사는 번갈아 바뀐다. 현재 Gradient만 따르면 Parameter는 좌우 벽을 계속 튕기며 지그재그로 이동한다.

Heavy-ball Momentum

Momentum은 과거 Gradient의 지수이동평균을 Velocity처럼 사용한다.

$$m_t = \beta m_{t-1} + (1-\beta)g_t,$$ $$\theta_{t+1} = \theta_t-\eta m_t.$$

같은 방향의 Gradient는 $m_t$에 계속 쌓여 속도가 붙는다. 반대로 좌우로 부호가 자주 바뀌는 성분은 서로 상쇄된다. 쇼핑카트를 밀면 손을 잠깐 떼어도 계속 굴러가는 것과 같다.

문제는 쇼핑카트가 목적지를 알아서 알아보지는 못한다는 점이다. Minimum을 지나쳤는데도 과거의 기세가 남아 Overshooting할 수 있다. 마트에서도 그렇지만 관성은 계산대 앞에서 특히 위험하다.

Nesterov Accelerated Gradient

NAG는 현재 위치가 아니라 Momentum으로 곧 도착할 Lookahead 위치에서 Gradient를 확인한다.

$$\widetilde\theta_t = \theta_t-\eta\beta m_{t-1},$$ $$m_t = \beta m_{t-1} + (1-\beta) \nabla_\theta \mathcal{L}(\widetilde\theta_t),$$ $$\theta_{t+1} = \theta_t-\eta m_t.$$

Momentum이 “일단 달리고 본다”면 NAG는 카트가 굴러갈 예정인 곳에 인턴 한 명을 먼저 보내 경사를 확인한다. 예상 위치에서 이미 오르막이 시작되었다면 미리 감속할 수 있다.

Momentum은 과거 방향을 기억하고, NAG는 그 기억으로 갈 미래 위치에서 다시 방향을 묻는다. 이 Lookahead 아이디어는 이후 NAdam처럼 Adam과 결합되기도 한다.

3. AdaGrad, RMSProp, AdaDelta: Parameter마다 신발 크기를 바꾸다

Momentum은 방향을 부드럽게 만들지만 모든 좌표에 같은 Learning rate를 사용한다. 그런데 현실의 Parameter들은 같은 단위를 쓰지 않는다. 어떤 좌표는 매번 큰 Gradient를 받고, Sparse feature에 연결된 좌표는 아주 가끔만 신호를 받는다.

AdaGrad

AdaGrad는 좌표마다 지금까지의 제곱 Gradient를 누적한다.

$$s_t = s_{t-1}+g_t\odot g_t,$$ $$\theta_{t+1} = \theta_t - \eta \frac{g_t}{\sqrt{s_t}+\epsilon}.$$

자주 큰 Gradient를 받은 좌표는 $s_t$가 빠르게 커져 다음 보폭이 작아진다. 반대로 드물게 Update되는 좌표는 상대적으로 큰 보폭을 유지한다. Sparse feature가 많은 문제에서 유용한 이유다.

하지만 $s_t$는 절대 줄어들지 않는다. AdaGrad는 신입사원 시절의 실수까지 평생 기억하는 상사와 같다. 학습이 길어질수록 분모가 계속 커지고, 결국 모든 Step이 지나치게 작아질 수 있다.

RMSProp

RMSProp은 누적합 대신 제곱 Gradient의 지수이동평균을 사용한다.

$$s_t = \rho s_{t-1} + (1-\rho)g_t\odot g_t,$$ $$\theta_{t+1} = \theta_t - \eta \frac{g_t}{\sqrt{s_t}+\epsilon}.$$

오래된 Gradient의 영향은 $\rho$의 거듭제곱만큼 서서히 사라진다. AdaGrad의 양동이가 한 번 들어간 물을 영원히 보관한다면, RMSProp의 양동이는 바닥에 작은 구멍이 있다.

역사적으로 RMSProp은 정식 논문보다 Geoffrey Hinton의 2012년 Coursera 강의 자료를 통해 널리 알려졌다. 논문 검색창에서 원 논문이 잘 나오지 않는다고 인터넷이 고장 난 것은 아니다.

AdaDelta

AdaDelta는 Gradient의 RMS뿐 아니라 과거 Parameter update의 RMS도 추적한다.

$$E[g^2]_t = \rho E[g^2]_{t-1} + (1-\rho)g_t^2,$$ $$\Delta\theta_t = - \frac{ \operatorname{RMS}[\Delta\theta]_{t-1} }{ \operatorname{RMS}[g]_t } g_t,$$ $$E[\Delta\theta^2]_t = \rho E[\Delta\theta^2]_{t-1} + (1-\rho)\Delta\theta_t^2.$$

여기서 $\operatorname{RMS}[x]_t=\sqrt{E[x^2]_t+\epsilon}$이다. 쉽게 말하면 Gradient의 단위를 과거 Update의 단위로 환전한다. AdaGrad의 끝없이 줄어드는 Step을 막으면서 전역 Learning rate 의존성도 줄이려는 방법이다.

세 방법의 공통점은 좌표별 scale을 조절한다는 것이다. 다만 좌표축 자체가 Loss의 자연스러운 방향과 비스듬히 놓여 있다면, 좌표 하나씩만 조절하는 것으로는 충분하지 않을 수 있다. 이 문제는 뒤에서 Shampoo와 Muon을 볼 때 다시 등장한다.

4. Adam과 AdamW: 방향계와 노면계를 함께 달다

Adam은 Momentum과 RMSProp의 아이디어를 결합한다. Adam 원 논문의 핵심 상태는 두 개다.

$$m_t = \beta_1m_{t-1} + (1-\beta_1)g_t,$$ $$v_t = \beta_2v_{t-1} + (1-\beta_2)g_t^2.$$

$m_t$는 Gradient의 First moment, $v_t$는 제곱 Gradient의 Second raw moment를 추정한다. 흔히 $v_t$를 “분산”이라고 부르지만 평균을 빼지 않았으므로 엄밀한 통계적 Variance는 아니다.

초기값 $m_0=v_0=0$ 때문에 학습 초반의 추정치는 0 쪽으로 치우친다. 이를 보정한다.

$$\widehat m_t = \frac{m_t}{1-\beta_1^t}, \qquad \widehat v_t = \frac{v_t}{1-\beta_2^t}.$$

최종 Update는 다음과 같다.

$$\theta_{t+1} = \theta_t - \eta \frac{\widehat m_t} {\sqrt{\widehat v_t}+\epsilon}.$$

$m_t$는 “최근에 어느 방향으로 계속 가고 있었는가”를 기억하고, $v_t$는 “이 좌표의 Gradient 제곱 크기가 최근에 얼마나 컸는가”를 측정한다. 자동차에 방향계와 노면에서 받은 충격의 크기를 재는 계기를 함께 단 셈이다.

Adam이 편리한 이유는 Parameter마다 자동으로 보폭을 조절하고, noisy Gradient에서도 비교적 안정적으로 시작하기 때문이다. 반면 Parameter 크기만 한 $m_t$와 $v_t$를 모두 저장해야 한다. Optimizer state만 Parameter당 FP32 두 개가 추가되므로 거대한 Model에서는 이 편리함이 상당히 비싸다.

AdamW: Weight decay를 별도 업무로 분리한다

Adam에 L2 regularization을 적용하기 위해 Gradient에 $\lambda\theta_t$를 더하면 이 항도 Adam의 좌표별 전처리를 통과한다.

$$g_t \leftarrow g_t+\lambda\theta_t.$$

Plain SGD에서는 적절한 상수 관계 아래 L2 regularization과 Weight decay가 동등하지만, Adam처럼 좌표별로 나누는 Optimizer에서는 이 동등성이 깨진다.

AdamW는 Weight decay를 Adaptive gradient update와 분리한다.

$$\theta_{t+1} = (1-\eta\lambda)\theta_t - \eta \frac{\widehat m_t} {\sqrt{\widehat v_t}+\epsilon}.$$

Adam이 운전을 담당하는 동안 별도의 관리인이 Parameter 크기를 조금씩 줄인다. 이름 뒤의 W는 Decay를 Gradient preconditioning 밖으로 꺼낸 방식을 뜻한다. Weight decay 옵션을 켰다는 장식으로 붙은 글자가 아니다.

Adam 친척들은 무엇을 바꾸었는가?

이름이 많다고 모두 AdamW보다 무조건 좋은 것은 아니다. AMSGrad는 중요한 수렴 문제를 고쳤지만 모든 실제 Task에서 더 빠르다는 뜻은 아니며, RAdam과 AdaBelief도 Dataset, Model, Schedule에 따라 결과가 달라진다. Optimizer 논문의 이름에는 대개 장점이 들어가고 영수증에는 조건이 들어간다.

5. Layer의 체급과 Optimizer Memory를 다루는 방법

LARS와 LAMB: Layer마다 별도의 볼륨 손잡이

Batch size가 매우 커지면 전역 Learning rate를 키워 Throughput을 활용하고 싶어진다. 그러나 모든 Layer에 같은 절대 Step을 적용하면 Parameter norm이 작은 Layer에는 너무 큰 변화가 되고, 큰 Layer에는 거의 느껴지지 않는 변화가 될 수 있다.

LARS는 Layer $l$마다 Weight와 Gradient의 norm을 비교한다.

$$r_l = \frac{ \lVert w_l\rVert }{ \lVert g_l\rVert + \lambda\lVert w_l\rVert + \epsilon },$$ $$w_l \leftarrow w_l-\eta r_l(g_l+\lambda w_l).$$

즉 절대 Update가 아니라 현재 Layer 크기에 대한 상대 변화량을 맞춘다.

LAMB는 먼저 Adam식 방향 $u_l$을 만들고, 그 방향에 Layer-wise trust ratio를 적용한다.

$$u_l = \frac{\widehat m_l} {\sqrt{\widehat v_l}+\epsilon} + \lambda w_l,$$ $$r_l = \frac{\phi(\lVert w_l\rVert)} {\lVert u_l\rVert+\epsilon}, \qquad w_l \leftarrow w_l-\eta r_lu_l.$$

모든 사람에게 똑같이 1kg을 나눠주면 어린이에게는 운동이고 건물에게는 먼지다. LARS와 LAMB는 Layer마다 체급계를 달아 상대적인 Update 크기를 조절한다. 주된 목적은 Large-batch training의 안정화이며, 작은 Batch에서도 자동으로 최고의 결과를 주는 만능 버튼은 아니다.

Adafactor: 거대한 장부를 행·열 영수증으로 압축한다

행렬 Parameter $W\in\mathbb{R}^{m\times n}$에 Adam의 Second moment를 그대로 저장하면 $mn$개의 값이 추가로 필요하다. Adafactor는 제곱 Gradient 행렬의 행 통계 $r_t$와 열 통계 $c_t$만 저장하고 전체 Matrix를 근사한다.

$$V_t \approx \frac{r_tc_t^\top} {\operatorname{mean}(r_t)}.$$

Optimizer state가 $O(mn)$에서 $O(m+n)$으로 줄어든다. 거대한 가계부 원본을 버리고 “행별 합계 영수증”과 “열별 합계 영수증”만 보관하는 셈이다.

다만 Factorization은 Matrix Parameter에만 자연스럽게 적용된다. Vector Parameter는 별도 상태가 필요하고, Relative step size, Update clipping, Momentum 사용 여부에 따라 실제 Adafactor의 동작도 달라진다.

2025년의 Adam-mini는 Parameter를 Hessian 구조에 맞춘 Block으로 나누고 Block 안에서 Scalar Second moment를 공유해 상태를 줄이는 다른 접근이다. 8-bit Adam은 상태값을 저정밀도로 저장하고, GaLore나 APOLLO는 Gradient를 낮은 차원으로 Projection한다. 이들은 모두 Memory를 줄이지만 Update rule 자체를 바꾸는 방법과 상태의 표현·정밀도를 줄이는 방법은 구분할 필요가 있다.

6. 좌표가 아니라 Matrix와 곡률을 본다면

Newton, L-BFGS, K-FAC, Sophia

Gradient는 현재 위치의 기울기만 알려준다. 바닥이 완만한지, 바로 앞에서 급격히 휘는지는 알려주지 않는다. 곡률을 나타내는 Hessian을 사용하면 Local quadratic model에서 다음과 같은 Newton step을 얻는다.

$$\theta_{t+1} = \theta_t - \eta H_t^{-1}g_t, \qquad H_t = \nabla_\theta^2\mathcal{L}(\theta_t).$$

기울어진 타원형 골짜기에서 $H_t^{-1}$는 방향별 곡률을 보정해 Minimum 쪽으로 더 직접적인 Step을 만들 수 있다. 문제는 Parameter가 수십억 개라면 Hessian도 수십억 곱하기 수십억이라는 점이다. 지형 안경은 훌륭하지만 안경값이 GPU Cluster 한 채다.

L-BFGS는 Full Hessian 대신 최근 Parameter 차이 $s_t=\theta_{t+1}-\theta_t$와 Gradient 차이 $y_t=g_{t+1}-g_t$ 몇 쌍으로 Inverse Hessian의 작용을 근사한다. 작은 Full-batch 문제에는 강력할 수 있지만, noisy Mini-batch와 거대한 신경망에서는 여러 번의 Function evaluation, History, Line search 조건이 부담스럽다.

K-FAC은 각 Layer의 Fisher block을 두 개의 작은 Kronecker factor로 근사한다.

$$F_l \approx A_l\otimes G_l, \qquad F_l^{-1} \approx A_l^{-1}\otimes G_l^{-1}.$$

Natural Gradient의 기하학을 훨씬 저렴하게 흉내 내지만, Factor 추정과 Matrix inverse, Damping, 분산 학습 통신 비용은 여전히 추가된다.

Sophia는 Full Hessian 대신 가벼운 Diagonal Hessian estimate $h_t$를 주기적으로 갱신한다.

$$m_t = \beta_1m_{t-1} + (1-\beta_1)g_t,$$ $$\theta_{t+1} = (1-\eta\lambda)\theta_t - \eta\, \operatorname{clip} \left( \frac{m_t}{\max(\gamma h_t,\epsilon)}, 1 \right).$$

곡률이 큰 좌표의 Step은 줄이고, 비볼록 영역이나 급격히 변하는 Hessian 때문에 Update가 지나치게 커지는 경우 Element-wise clipping으로 막는다. Sophia는 “Full 2차 Optimizer”가 아니라 Diagonal curvature estimate를 가끔 계산하는 Stochastic second-order method에 가깝다.

Shampoo와 SOAP: 방이 기울었다면 좌표계를 돌려본다

Adam은 각 좌표의 Scale은 조절하지만 좌표 사이의 상관관계는 직접 보지 않는다. 행렬 Gradient $G_t\in\mathbb{R}^{m\times n}$에 대해 Shampoo는 행과 열 방향의 통계를 각각 누적한다.

$$L_t = \epsilon I + \sum_{\tau=1}^{t} G_\tau G_\tau^\top,$$ $$R_t = \epsilon I + \sum_{\tau=1}^{t} G_\tau^\top G_\tau,$$ $$\Delta W_t = -\eta L_t^{-1/4} G_t R_t^{-1/4}.$$

좌우에서 Matrix를 Precondition하여 행과 열의 뒤틀린 Scale을 함께 편다. 엉킨 머리카락의 가로·세로 방향을 빗으로 정리하는 그림에 가깝지만, 정확한 Hessian을 계산하는 Newton법은 아니다. Gradient covariance나 Fisher와 연결된 구조적 Preconditioning으로 보는 편이 맞다.

단점은 Matrix state와 Inverse matrix power 계산이다. 실용 구현은 Block 단위로 나누고, Preconditioner를 매 Step이 아니라 일정 주기마다 갱신해 비용을 줄인다.

SOAP은 Shampoo의 Eigenbasis 안에서 Adam식 Update를 수행한다.

$$\widetilde G_t = U_L^\top G_tU_R.$$

회전된 $\widetilde G_t$ 공간에서 Adam의 Second moment를 추적하고 Update를 만든 뒤, 다시 원래 좌표로 돌려보낸다. 방이 기울어져 있다면 청소 로봇을 계속 벽에 부딪치게 하는 대신 방을 똑바로 돌리고 Adam에게 청소를 시킨 뒤 원위치로 돌리는 셈이다.

Adafactor는 상태를 행·열로 압축하고, Shampoo는 행·열 Preconditioner로 Update를 펴며, SOAP은 그 Preconditioner의 Eigenbasis에서 Adam을 실행한다. 셋 모두 Matrix를 본다는 이유로 같은 방법은 아니다.

7. signSGD와 Lion: 얼마나 센지는 버리고 어느 쪽인지만 본다

가장 과감한 단순화 중 하나는 Gradient의 크기를 버리고 부호만 사용하는 것이다.

$$\theta_{t+1} = \theta_t - \eta\operatorname{sign}(g_t).$$

signSGD는 각 좌표에서 양수인지 음수인지만 본다. 2차원에서 두 성분이 0이 아니라면 Update 방향은 네 개의 대각 방향 중 하나가 된다. 크기가 열 배 다른 두 Gradient도 같은 부호라면 같은 좌표별 Step을 만든다.

Lion은 Program search로 발견된 Sign momentum Optimizer다.

$$c_t = \beta_1m_{t-1} + (1-\beta_1)g_t,$$ $$\theta_{t+1} = \theta_t - \eta \left( \operatorname{sign}(c_t) + \lambda\theta_t \right),$$ $$m_t = \beta_2m_{t-1} + (1-\beta_2)g_t.$$

현재 Gradient와 과거 Momentum을 섞어 방향을 정한 뒤 Sign을 취한다. Adam의 $v_t$가 없으므로 Parameter 크기의 Momentum buffer 하나만 필요하다.

쉽게 말하면 Lion은 “얼마나 화났는가”는 버리고 “어느 쪽에 화났는가”만 기억한다. 다만 모든 좌표가 일정한 크기로 움직여 Update norm이 커질 수 있으므로 AdamW보다 훨씬 작은 Learning rate와 다른 Weight decay가 필요한 경우가 많다. 상태가 작고 식이 짧다고 Hyperparameter까지 자동으로 간단해지는 것은 아니다.

8. Optimizer를 감싸거나 Step 정책을 바꾸는 장치

이 절의 방법들은 모두 같은 층위에 있지 않다. Lookahead와 SAM은 Base Optimizer를 감싸는 Wrapper에 가깝고, D-Adaptation과 Prodigy는 Step scale을 적응적으로 정하는 Optimizer다. Schedule-Free는 Gradient를 측정하는 위치와 Parameter sequence를 바꾸는 Optimizer 변환이다. 하지만 모두 “Gradient에 무엇을 곱할까”를 넘어 탐색점, Step 크기, Iterate를 어떻게 운영할지를 다룬다는 공통점이 있다.

Lookahead

Lookahead는 Fast weight $\theta$와 Slow weight $\phi$를 따로 둔다. Base Optimizer로 Fast weight를 $k$번 Update한 뒤 Slow weight를 그쪽으로 조금 이동시킨다.

$$\theta_{t,i+1} = \operatorname{BaseOpt}(\theta_{t,i}), \qquad i=0,\ldots,k-1,$$ $$\phi_{t+1} = \phi_t + \alpha(\theta_{t,k}-\phi_t), \qquad \theta_{t+1,0}=\phi_{t+1}.$$

Fast weight가 이곳저곳 답사하고 Slow weight는 그 결과를 보고 신중하게 따라간다. 탐험대와 본대를 분리하여 Base Optimizer의 흔들림을 완화한다.

SAM

SAM은 현재 위치에서 Loss만 낮은 점보다 주변을 조금 움직여도 Loss가 낮은 넓은 Minimum을 찾으려 한다.

L2 perturbation을 사용한 단순한 형태는 다음과 같다.

$$\epsilon_t^* = \rho \frac{g_t}{\lVert g_t\rVert_2+\epsilon},$$ $$g_t^{\mathrm{SAM}} = \nabla_\theta \mathcal{L}(\theta_t+\epsilon_t^*),$$ $$\theta_{t+1} = \operatorname{BaseOpt} (\theta_t,g_t^{\mathrm{SAM}}).$$

주황색 Perturbation은 실제 이사가 아니라 옆집 소음을 확인하러 가는 임시 방문이다. 그 위치에서 다시 구한 Gradient로 본 Update를 수행한다. 일반적으로 Gradient evaluation이 한 번 더 필요해 Step당 비용이 커진다.

D-Adaptation과 Prodigy

Optimizer의 Learning rate를 고르기 위해서는 초기 위치와 Solution 사이의 거리 같은 문제 Scale을 알아야 한다. D-Adaptation은 이 미지의 거리 $D$에 대한 추정치를 학습 중에 키워가며 Step size를 조절한다. Prodigy는 이 추정을 더 빠르게 적응시키려는 계열이다.

자동 줄자로 목적지까지의 거리를 재면서 보폭을 정하는 셈이다. 다만 “Learning rate가 아예 없다”는 뜻은 아니고, Base scale이나 Scheduler, Weight decay 등 다른 설정의 영향도 남는다. 특히 특정 생성 모델 Fine-tuning에서 잘 알려졌다고 모든 Pre-training 문제의 기본값이 되는 것은 아니다.

Schedule-Free

Cosine decay나 Linear decay는 보통 총 Training step $T$를 미리 알아야 한다. 그런데 학습을 언제 멈출지 모른다면 Schedule을 어디에 맞춰 끝내야 할까?

Schedule-Free는 탐색점 $z_t$, 평균점 $x_t$, Gradient 측정점 $y_t$를 분리한다. Schedule-Free SGD의 핵심 형태는 다음과 같다.

$$y_t = (1-\beta)z_t + \beta x_t,$$ $$z_{t+1} = z_t - \gamma\nabla f(y_t,\zeta_t),$$ $$x_{t+1} = (1-c_{t+1})x_t + c_{t+1}z_{t+1}.$$

$c_{t+1}$은 새 탐색점을 평균에 얼마나 반영할지 정하는 Weight이며, Equal averaging에서는 $c_{t+1}=1/(t+1)$을 사용한다.

$z_t$는 앞에서 뛰어다니는 탐험가, $x_t$는 지금까지의 경로를 평균내는 지도 제작자, $y_t$는 둘이 만나 다음 Gradient를 측정하는 위치다. Iterate averaging과 Momentum의 역할로 명시적인 decay Schedule을 대신한다.

이름 때문에 오해하기 쉽지만 Schedule-Free는 Learning rate-free가 아니다. Base learning rate와 Warmup은 여전히 필요할 수 있다. 구현에서는 Train mode와 Eval mode에서 어떤 Parameter sequence를 사용할지도 구분해야 하며, BatchNorm running statistics도 주의해야 한다.

2025~2026년의 Update 보조 모듈

MARS는 같은 Sample에서 현재와 직전 위치의 Gradient 차이를 이용해 Variance를 줄이는 보정 Gradient $c_t$를 만든다.

$$c_t = g(\theta_t,\xi_t) + \gamma_t \frac{\beta_1}{1-\beta_1} \left[ g(\theta_t,\xi_t) - g(\theta_{t-1},\xi_t) \right].$$

이 $c_t$를 AdamW, Lion, Shampoo 같은 Base Optimizer에 넣는다. Noise-canceling headphone에 가깝지만 Exact version은 두 위치의 Gradient를 요구한다. 저렴한 Approximation과 이론상의 Exact method를 같은 것으로 보면 안 된다.

Cautious Optimizers는 Base Optimizer가 만든, Parameter에서 빼기 전의 Preconditioned direction $u_t$와 현재 Gradient가 같은 방향인 좌표만 통과시킨다.

$$\phi_t = \mathbf{1}[u_t\odot g_t>0],$$ $$\widetilde u_t = \frac{\phi_t\odot u_t} {\operatorname{mean}(\phi_t)+\epsilon}.$$

Momentum과 현재 Gradient가 합의한 손님만 들여보내는 경비원이다. AdamW, Lion, Muon 등에 붙일 수 있지만, 과거 Momentum이 현재 Gradient와 잠시 반대여도 장기적으로 유용한 경우까지 버릴 수 있다는 Trade-off가 있다.

9. Muon과 2026년의 Matrix-native Optimizer

Adam은 Matrix Parameter도 결국 좌표의 모음으로 본다. 하지만 Linear layer의 Weight는 단순한 긴 Vector가 아니라 입력 방향과 출력 방향이 만나는 Matrix다. 그렇다면 Update도 Matrix geometry에 맞춰 다루는 것이 낫지 않을까?

Muon: Momentum matrix를 다림질한다

Muon은 MomentUm Orthogonalized by Newton-Schulz의 약자다. 이름 그대로 2차원 Weight matrix의 Momentum을 만든 뒤, Newton-Schulz iteration으로 그 Update를 근사 Orthogonalization한다.

Gradient matrix를 $G_t$, Momentum을 $M_t$라고 하자.

$$M_t = \beta M_{t-1} + (1-\beta)G_t.$$

Nesterov-style로 조합한 Update matrix를 $U_t$라고 하고 SVD를 생각해보자.

$$U_t = \beta M_t + (1-\beta)G_t,$$ $$U_t = P\Sigma Q^\top.$$

개념적으로 지향하는 Matrix sign, 즉 Polar factor는 다음과 같다.

$$\operatorname{msign}(U_t) = PQ^\top.$$

서로 크기가 달랐던 Singular value를 같은 크기로 만들어 방향마다 한 표씩 주는 셈이다. 실제 구현은 매 Step SVD를 계산하지 않고 Matrix multiplication만으로 구성된 Newton–Schulz 다항식을 몇 차례 적용한다. 다만 공식 Muon의 기본 5-step quintic 설정은 정확한 $PQ^\top$에 수렴하는 고전적 iteration이 아니다. Polar 방향을 지향하면서도 출력 Singular value를 대략 $0.5\sim1.5$ 범위에 놓는 계산·품질 Trade-off로 이해하는 편이 정확하다.

$$W_{t+1} = (1-\eta\lambda)W_t - \eta s_t \operatorname{NS}(U_t).$$

$s_t$는 Matrix shape에 맞춘 Update scale이다. 직사각 Matrix의 결과는 모든 행과 열이 동시에 Orthogonal인 정사각 행렬이 아니라 Semi-orthogonal polar factor다.

중요한 점이 두 가지 있다.

첫째, Muon은 Weight 자체를 Orthogonalization하는 것이 아니라 Momentum update를 Orthogonalization한다. 둘째, 모든 Parameter에 적용하는 것도 아니다. 일반적으로 Hidden layer의 2D Weight matrix에는 Muon을 사용하고, Embedding, Output head, Bias, Norm gain처럼 Vector이거나 특성이 다른 Parameter에는 AdamW를 함께 사용한다.

2025년 대규모 Muon 연구는 Weight decay와 Parameter별 Update scale이 확장에 중요하다고 보고했다. 그러나 Newton-Schulz Matrix multiplication의 비용, 분산 학습 통신, Parameter group 분리와 재튜닝이 필요하다. AdamW를 Muon으로 한 단어만 바꾸면 모든 Model이 빨라지는 Drop-in magic은 아니다.

Scion: Layer마다 다른 모양의 운동장을 준다

Scion은 Layer 구조에 맞는 Norm ball을 정의하고, Momentum direction에 대해 Linear Minimization Oracle을 푼다.

$$d_t = \alpha_tg_t + (1-\alpha_t)d_{t-1},$$ $$\operatorname{LMO}(d_t) = \arg\min_{\lVert v\rVert\leq 1} \langle d_t,v\rangle,$$

Radius $\rho$의 Norm ball 안에 Parameter를 유지하는 제약형 Scion은 현재 Parameter와 Oracle이 선택한 경계점을 보간한다.

$$\theta_{t+1} = (1-\gamma_t)\theta_t + \gamma_t\rho \operatorname{LMO}(d_t).$$

반면 Norm constraint를 명시적으로 유지하지 않는 Unconstrained Scion, 즉 uSCG는 다음과 같이 쓴다.

$$\theta_{t+1} = \theta_t + \gamma_t\rho \operatorname{LMO}(d_t).$$

Matrix layer에는 Spectral norm ball, Vector와 Embedding에는 다른 Norm을 선택할 수 있다. Spectral norm geometry에서는 이 방향이 Muon의 Polar update와 연결된다. Muon의 아이디어를 “모든 Layer에는 그 구조에 맞는 운동장이 필요하다”는 더 넓은 틀로 확장한 셈이다.

대신 어떤 Norm과 Radius를 Layer별로 선택할지가 새로운 설계 문제가 된다. 현재 증거도 거대한 상용 규모 전반보다 비교적 제한된 Language model 실험에 더 가깝다.

AdaMuon과 NorMuon

AdaMuon은 Orthogonalized direction에 Element-wise Second moment adaptation을 결합한다. Orthogonalization이 방향 간 Scale을 펴는 장점과 Adam식 좌표별 적응을 함께 얻으려는 접근이다.

NorMuon은 Muon update 이후 Neuron, 즉 Row 단위 Second moment normalization을 사용한다. Muon이 Condition number를 개선해도 일부 Row의 norm이 지나치게 커져 특정 Neuron이 Update를 지배할 수 있다는 문제를 겨냥한다.

둘 다 “Adaptive Muon”처럼 보이지만 단위가 다르다. AdaMuon은 Cell-wise adaptation에 가깝고, NorMuon은 Row-wise balance를 맞춘다.

2026년 관찰대: 흥미롭지만 아직 기본값은 아니다

2026년에는 Muon 이후의 Matrix geometry를 확장하려는 제안이 빠르게 나오고 있다.

• FISMO는 Muon의 균일한 Singular-value geometry에 Fisher 구조의 Anisotropic curvature를 다시 넣으려 한다.
• Newton-Muon은 입력 $Z$의 Covariance로 먼저 Gradient를 오른쪽 Preconditioning한 뒤 Matrix sign을 적용한다.

$$W \leftarrow W - \eta\, \operatorname{msign} \left( G(ZZ^\top)^{-1} \right).$$

• Hyperball은 Matrix weight의 Frobenius norm을 초기 Radius $R$에 고정하고, Update 후 다시 Sphere 표면에 Projection한다.

$$\widehat u_t = \frac{u_t}{\lVert u_t\rVert_F}, \qquad \widetilde W_t = W_t-\eta_tR\widehat u_t,$$ $$W_{t+1} = R \frac{\widetilde W_t} {\lVert\widetilde W_t\rVert_F}.$$

Learning rate를 Weight norm 대비 각운동처럼 해석할 수 있지만, Radial learning을 제거해도 되는 Scale-invariant Matrix라는 가정이 중요하다. 발표 직후 그 이득의 상당 부분이 Implicit learning-rate schedule에서 올 수 있다는 후속 분석도 나왔다.

또한 2026년 8월의 한 수렴 분석은 특정 Stochastic setting에서 원래 Muon이 거의 모든 Mini-batch size에 대해 수렴하지 않을 수 있는 반례를 제시했다. 이것은 Muon이 쓸모없다는 결론도, AdamW가 영원히 정답이라는 결론도 아니다. 다만 최신 Optimizer를 “Adam의 종말”이라고 부르기에는 장례 일정이 지나치게 빠르다는 뜻이다.

Optimizer를 한눈에 비교하면

아래 State 수는 Weight와 Gradient를 제외한 대략적인 Optimizer state다. Mixed precision, Master weight, Sharding, Quantization, Momentum 옵션과 구현에 따라 실제 Memory는 달라진다.

여기서 $P$는 해당 Parameter group의 원소 수다. 예를 들어 AdamW의 $2P$는 FP32 $m,v$만 세어도 Parameter당 8 Bytes다. ¹Schedule-Free는 기존 Momentum state를 탐색 sequence $z$로 대체할 수 있어 SF-SGD with Momentum은 약 $1P$, SF-AdamW는 약 $2P$로 Base Optimizer와 대체로 같다. 전체 학습 Memory에는 Weight, Gradient, Activation, Master weight, Communication buffer가 추가된다. 따라서 “Optimizer state 50% 절감”과 “전체 VRAM 50% 절감”은 전혀 다른 문장이다.

그래서 실전에서는 무엇을 고르면 되는가?

Optimizer 선택에는 우승자 표보다 문제의 병목이 먼저 필요하다.

일단 안정적인 Baseline이 필요하다

Transformer와 대부분의 Fine-tuning에서는 여전히 AdamW가 좋은 출발점이다. 구현이 널리 검증되었고 Scheduler, Weight decay, Mixed precision과 관련된 경험치가 많이 쌓여 있다. 새 Optimizer의 효과를 주장하려면 먼저 잘 튜닝된 AdamW를 이겨야 한다.

Vision model을 전통적인 Recipe로 학습한다

CNN이나 일부 Vision task에서는 Momentum SGD가 여전히 강한 Baseline이다. Training loss가 조금 느리게 내려가도 최종 Generalization이 좋을 수 있다. 단, 이 차이를 Optimizer 하나의 성질로만 설명하기보다 Learning-rate schedule, Augmentation, Weight decay를 함께 봐야 한다.

Batch를 매우 크게 키운다

Layer별 상대 Update가 무너지면 LARS나 LAMB를 고려할 수 있다. Large batch가 실제 Throughput을 높이는지, Communication과 Data efficiency까지 포함해 확인해야 한다.

Optimizer state가 Model을 밀어낸다

Adafactor, Adam-mini, 8-bit state, State sharding을 비교할 수 있다. 이때 Optimizer update를 바꾸는 효과와 단지 상태를 압축하는 효과를 분리해서 측정하는 것이 좋다.

Matrix-aware Optimizer를 연구하고 싶다

Muon, Shampoo, SOAP은 흥미로운 선택이다. 다만 같은 Token에서의 Loss뿐 아니라 Newton-Schulz나 Eigendecomposition을 포함한 실제 wall-clock, 분산 통신, 적용하지 못한 Parameter group의 AdamW state까지 측정해야 한다.

총 Step을 미리 정하기 어렵다

Schedule-Free가 좋은 후보가 될 수 있다. 그러나 “아무 Schedule도 아무 설정도 필요 없다”가 아니라, 종료 시점에 맞춘 Decay를 Iterate averaging 구조로 대체한다는 의미로 이해해야 한다.

개인적으로는 다음 순서가 가장 안전하다고 생각한다.

1. 잘 알려진 Baseline과 Recipe로 시작한다.
2. 현재 병목이 Step 수인지, wall-clock인지, VRAM인지, 튜닝 시간인지 구분한다.
3. 그 병목을 직접 겨냥하는 Optimizer를 하나만 바꾼다.
4. Learning rate와 Weight decay를 새 Optimizer에 맞게 다시 튜닝한다.
5. 같은 Token, 같은 FLOPs, 같은 wall-clock 중 무엇을 맞춘 비교인지 명시한다.

새 Optimizer를 넣고 기존 AdamW의 Learning rate를 그대로 사용한 뒤 성능이 떨어졌다고 결론내리는 것은, 운동화를 갈아 신고 끈은 묶지 않은 채 신발이 나쁘다고 말하는 것과 비슷하다.

자주 생기는 오해

Second moment는 Variance인가?

Adam의 $v_t$는 $g_t^2$의 이동평균인 Uncentered second moment다. $(g_t-m_t)^2$처럼 평균을 뺀 통계적 Variance와는 다르다.

Weight decay는 L2 regularization과 항상 같은가?

Plain SGD에서는 적절한 Scale 관계 아래 같게 볼 수 있다. Adaptive preconditioner가 들어가면 Gradient에 $\lambda\theta$를 더하는 것과 AdamW처럼 Parameter를 직접 줄이는 것은 다르다.

2차 Optimizer는 항상 더 빠른가?

Iteration 수는 줄어도 한 Step의 연산과 통신이 훨씬 비쌀 수 있다. Wall-clock과 Memory까지 포함하기 전에는 “빠르다”는 문장이 완성되지 않는다.

Muon은 AdamW를 완전히 대체하는가?

보통 아니다. Muon은 Hidden 2D matrix에 적용하고 Vector, Bias, Embedding, Output head에는 AdamW를 함께 쓴다. Model 전체 Optimizer state와 통신 비용은 이 혼합 구성을 기준으로 계산해야 한다.

논문에서 2배 빨랐으면 내 학습도 2배 빨라지는가?

논문의 2배가 Step 수인지, FLOPs인지, 같은 Token에서의 Loss인지, 실제 wall-clock인지 먼저 확인해야 한다. 2025년의 대규모 비교인 Fantastic Pretraining Optimizers and Where to Find Them은 Matrix-aware Optimizer의 이점이 Model scale, Token 수, Decay 구간에 따라 달라지고 Scale이 커질수록 격차가 줄어들 수 있음을 보여준다.

논문의 Optimizer 성능은 알고리즘 하나의 성적표가 아니라, Learning rate·Schedule·Weight decay·Model scale·Kernel·분산 구현이 함께 치른 단체 시험에 가깝다.

핵심 요약

• SGD는 현재 Mini-batch Gradient를 그대로 따라간다.
• Momentum은 과거 방향을 기억하고, NAG는 예상 위치에서 Gradient를 미리 본다.
• AdaGrad, RMSProp, AdaDelta는 좌표별 Gradient scale로 보폭을 조절한다.
• Adam은 First moment와 Second raw moment를 결합하고, AdamW는 Weight decay를 Adaptive update와 분리한다.
• LARS와 LAMB는 Layer별 상대 Update를 맞추고, Adafactor는 Matrix의 Second moment를 행·열 통계로 압축한다.
• Shampoo는 Matrix를 좌우에서 Preconditioning하고, SOAP은 그 Eigenbasis에서 Adam식 Update를 수행한다.
• Lion은 Momentum과 Gradient를 섞은 뒤 Coordinate-wise sign만 사용한다.
• Sophia는 Diagonal Hessian estimate와 clipping으로 저렴한 2차 정보를 사용한다.
• Lookahead과 SAM은 Base Optimizer를 감싸 탐색점과 Sharpness를 다룬다. Prodigy는 Step scale을 적응적으로 정하고, Schedule-Free는 Gradient 측정점과 Parameter average를 운영한다.
• Muon은 2D Weight의 Momentum update를 Newton-Schulz로 근사 Orthogonalization한다.
• Scion과 2025~2026년의 여러 제안은 Layer와 Matrix geometry를 더 직접적으로 반영하려 하지만 아직 검증 범위를 함께 봐야 한다.

결론

Optimizer의 역사는 “더 복잡한 식이 더 좋은 식”이 된 과정이 아니다. Gradient의 Noise, Coordinate scale, Layer norm, Curvature, Memory, Matrix geometry처럼 무엇을 문제라고 보았는가가 달라진 과정에 가깝다.

SGD는 현재 경사를 믿었고, Momentum은 과거를 기억했다. AdaGrad와 Adam은 좌표마다 다른 사정을 인정했다. Shampoo와 SOAP은 좌표축 자체가 잘못 놓였을 가능성을 보았고, Muon과 Scion은 Parameter가 Matrix와 Layer라는 구조를 더 직접적으로 받아들이기 시작했다.

그렇다고 최신 방법이 언제나 오래된 방법을 밀어내는 것은 아니다. 더 많은 정보를 쓰면 더 좋은 Update를 만들 수 있지만, 그 정보를 계산하고 저장하고 통신하는 비용도 함께 온다. 결국 좋은 Optimizer는 가장 영리한 공식을 가진 방법이 아니라, 내가 가진 Model과 Data와 Hardware에서 가장 적은 비용으로 원하는 성능에 도달하게 하는 방법이다.

어쩌면 Optimizer를 고르는 일 자체도 하나의 Optimization 문제다. 차이가 있다면 이번에는 Gradient를 계산해주는 Autograd가 없다는 것뿐이다.