Adam: inersiya, masshtab va siljishni tuzatish

Adam nima uchun kerak

Neyron tarmoqda millionlab vazn bor va ularning gradiyentlari juda turli masshtablarda yashaydi: kam uchraydigan tokenlar embeddinglari kamdan-kam katta turtki oladi, oxirgi qatlamlar — doimiy kichiklarini, normallashtirish qatlamlari — yana boshqacha. Oddiy SGD $\eta g$ qadam tashlaydi va barcha uchun bitta $\eta$ tezlik bir vaqtda ba’zi vaznlar uchun juda katta, boshqalari uchun juda kichik. Bundan tashqari, mini-batch gradiyenti shovqinli, yo‘qotish sirti esa cho‘ziq jarliklar va platolarga to‘la.

Adam (adaptive moment estimation, Kingma va Ba, 2014; ICLR 2015) ikkala masalani bitta formula bilan hal qiladi:

• birinchi moment $m_t$ — gradiyentlarning eksponensial o‘rtachasi: shovqin va zigzaglarni so‘ndiradigan inersiya (Momentum kabi);
• ikkinchi moment $v_t$ — gradiyent kvadratlarining eksponensial o‘rtachasi: har bir vazn gradiyentining odatiy kattaligi, qadam unga bo‘linadi (RMSProp kabi);
• siljishni tuzatish — $1-\beta^t$ ga bo‘lish, u dastlabki qadamlarda momentlarning tizimli kam baholanishini yo‘qotadi.

Natija: har bir vazn qadami gradiyent masshtabidan qat’i nazar $\eta$ tartibida, har bir qatlam uchun qo‘lda sozlashsiz. Shuning uchun Adam ko‘pchilik masalalarda standart optimizator, uning AdamW varianti esa transformerlar va katta til modellarini o‘qitadi.

Intuitsiya: kompas va spidometr

Yo‘lsiz joyda titrab turgan kompas ko‘rsatkichi bo‘yicha mashina haydayotganingizni tasavvur qiling. Uning har bir siltanishida rulni burish ahmoqlik — o‘rtachalangan yo‘nalishni kuzatish oqilonaroq. Bu $m_t$. Tezlikni esa siltanishlar odatda qanchalik kuchli ekaniga qarab tanlash kerak: tekis yo‘lda ishonch bilan, o‘nqir-cho‘nqirda ehtiyotkorlik bilan. Bu $\sqrt{v_t}$: Adam qadami — turtkilar odatiy kuchiga bo‘lingan yo‘nalish.

Rasmda — bitta vazn gradiyentlari oqimi: 100-qadamgacha o‘rtacha $+0{,}5$, keyin $-0{,}5$, ustiga shovqin. To‘q sariq chiziq — silliqlangan gradiyent $\hat m_t$, firuza rangdagilar — $\pm\sqrt{\hat v_t}$ yo‘lak, pastda — $\eta$ birliklarida yakuniy qadam.

Formula mayda detallarigacha

$g_t$

$t$-qadamdagi mini-batch gradiyenti (qadamlar 1 dan raqamlanadi);

$m_t$

birinchi moment: gradiyentning eksponensial sirpanuvchi o‘rtachasi (EMA), $m_0=0$;

$v_t$

ikkinchi moment: gradiyent elementma-element kvadratining EMA’si, $v_0=0$; har bir vaznning o‘z $m$ va $v$ si bor;

$\beta_1,\ \beta_2$

so‘nish koeffitsiyentlari, standart $0{,}9$ va $0{,}999$: xotira taxminan $1/(1-\beta)$ qadam — 10 va 1000;

$1-\beta^t$

siljishni tuzatish: momentlarning noldan boshlanishini qoplaydi;

$\eta$

o‘qitish tezligi (learning rate), standart $10^{-3}$; bu yerda u vazn birliklarida odatiy qadam uzunligini belgilaydi;

$\epsilon$

nolga bo‘lishdan saqlovchi kichik qo‘shimcha ($10^{-8}$).

Standart $\beta_1=0{,}9$, $\beta_2=0{,}999$ da $0{,}5$, $-0{,}2$, $0{,}4$ gradiyentlar uchun uchta qadamni qo‘lda bajaramiz. Oxirgi ustun — siljishni tuzatishsiz qadam qanday bo‘lardi.

Uchinchi qadamga e’tibor bering: gradiyentlar ishorasini almashtirdi, shuning uchun $\hat m_3=0{,}23$ gradiyentning odatiy kattaligi $\sqrt{\hat v_3}=0{,}39$ dan sezilarli kichik va Adam atigi $0{,}6\eta$ qadam tashlaydi. Gradiyentlar qanchalik mos bo‘lsa, qadam $\eta$ ga shunchalik yaqin.

Siljishni tuzatish: 1 − βᵗ qayerdan

Momentlar noldan boshlanadi va dastlabki qadamlar shu nolni «eslab qoladi». $m_t$ uchun rekursiyani ochamiz:

Bu gradiyentlarning vaznli yig‘indisi, lekin vaznlar yig‘indisi 1 emas, $(1-\beta_1)(1+\beta_1+\dots+\beta_1^{t-1})=1-\beta_1^t$ ga teng. Yetishmayotgan $\beta_1^t$ ulush boshlang‘ich nolga tegdi. Tuzatish shundan.

Qadam xossalari

Masshtab invariantligi

Vaznning barcha gradiyentlarini $c>0$ ga ko‘paytiramiz. U holda $m_t$ $c$ ga, $v_t$ $c^2$ ga, $\sqrt{v_t}$ $c$ ga ko‘payadi va $\hat m_t/\sqrt{\hat v_t}$ nisbat o‘zgarmaydi. Adam qadami gradiyentlarning nolinchi darajali bir jinsli funksiyasi ($\sqrt{\hat v_t}\gg\epsilon$ ekan). Har bir vaznning samarali tezligi $\eta/(\sqrt{\hat v_t}+\epsilon)$ o‘zi moslashadi: kichik gradiyentli vaznlarda katta, katta gradiyentlilarda kichik.

Qadam va signal/shovqin nisbati

Vazn gradiyenti $\mu$ o‘rtacha va $\sigma$ standart chetlanish bilan statsionar bo‘lsin. U holda $\hat m_t\approx\mu$, $\hat v_t\approx\mu^2+\sigma^2$ (ikkinchi moment — o‘rtacha kvadrati plyus dispersiya) va o‘rtacha qadam

Toza signalda ($\sigma\ll|\mu|$) qadam $\approx\eta$, kuchli shovqinda ($\sigma\gg|\mu|$) u signal/shovqin nisbatiga proporsional. Bu avtomatik «tormoz»: minimum yonida o‘rtacha gradiyent nolga intiladi, shovqin esa qoladi — va Adam qadamlarni o‘zi qisqartiradi.

Xususiy holatlar

• $\beta_1=\beta_2=0$: $\hat m_t=g_t$, $\sqrt{\hat v_t}=|g_t|$, qadam $\eta\operatorname{sign}(g_t)$ — ishorali gradiyentli tushish (signSGD).
• $\beta_1=0$: siljishni tuzatishli RMSProp.
• $\epsilon\gg\sqrt{\hat v_t}$: qadam $\approx(\eta/\epsilon)\,\hat m_t$ — $\eta/\epsilon$ tezlikli inersiyali SGD.
• Adam — diagonal oldindan shartlovchi: u har bir koordinatani alohida masshtablaydi va o‘qlarni bura olmaydi (SGD sahifasidagi 6-rasmga qarang).

Formula ortidagi matematika

To‘rt qator ortida yashiringan narsalarni jamlaymiz.

• Vaznli o‘rtacha sifatida EMA. $\hat m_t=\sum_i w_i g_i$, vaznlar $w_i=(1-\beta_1)\beta_1^{t-i}/(1-\beta_1^t)$ musbat va yig‘indisi 1 ga teng. Vazn taxminan har $\ln2/(1-\beta)$ qadamda ikki marta kamayadi: $\beta_1=0{,}9$ uchun 7 va $\beta_2=0{,}999$ uchun 693.
• Samarali oyna $1/(1-\beta)$: $m$ taxminan oxirgi 10 ta gradiyentni, $v$ — taxminan 1000 tasini o‘rtachalaydi. Yo‘nalish tez, masshtab esa sekin va shuning uchun barqaror javob beradi.
• Ikkinchi moment — dispersiya emas. $v$ $\mathbb E[g^2]=\mu^2+\sigma^2$ ni, ya’ni gradiyentning «markazlashtirilmagan» kattaligini baholaydi. Shuning uchun toza signalda qadam cheksiz emas, $\approx\eta$.
• Nyuton usuli bilan bog‘liqlik. Ba’zan $\sqrt v$ egrilikni yaqinlashtiradi deyishadi. Bu faqat qisman to‘g‘ri: $v$ — empirik Fisher matritsasi diagonalining bahosi (mini-batch gradiyentlari bo‘yicha), ba’zi yo‘qotishlar uchun u minimum yonida gessianga yaqin, lekin Adam undan kvadrat ildiz oladi. Adam’ni Nyuton yaqinlashuvi emas, qadamni normallashtirish deb tushunish ishonchliroq.

3D’da optimizatorlar poygasi

Beshta usulni ikkita sirtda solishtiramiz. Birinchisi — chuqurli plato: $f=1-e^{-q(x,y)}$, $q=0{,}2(x-1)^2+1{,}2(y-0{,}5)^2$. Chuqurlikdan uzoqda $f\approx1$, gradiyent juda kichik, chuqurlikning o‘zi esa cho‘ziq. Ikkinchisi — Rozenbrok banani.

AdamW: vaznlarning to‘g‘ri so‘nishi

Klassik $L_2$-regulyarizatsiya yo‘qotishga $\tfrac\lambda2\|\theta\|^2$, ya’ni gradiyentga $\lambda\theta$ qo‘shadi. SGD uchun bu har qadamda vaznlarni $1-\eta\lambda$ ga ko‘paytirish bilan bir xil (vaznlar so‘nishi, weight decay). Adam uchun — yo‘q: $\lambda\theta$ qo‘shiluvchi $m$ va $v$ ga tushadi va $\sqrt{\hat v_t}$ ga bo‘linadi. Loshchilov va Xatter (2017; ICLR 2019) so‘nishni gradiyentdan ajratishni taklif qilishdi:

AdamW’da momentlar faqat yo‘qotish gradiyenti bo‘yicha hisoblanadi, barcha vaznlar esa qadam boshiga bir xil $\eta\lambda$ tezlikda so‘nadi. $L_2$ li Adam’da har bir vazn so‘nishi uning $\sqrt{\hat v_t}$ siga bo‘linadi: katta gradiyentli vaznlar deyarli regulyarizatsiya qilinmaydi, yo‘qotish gradiyenti yo‘q vaznlar esa $\lambda$ dan qat’i nazar qadam boshiga $\approx\eta$ o‘zgarmas tezlikda qisqaradi.

O‘qitishda Adam: qizdirish va jadval

Hatto adaptiv usulga ham tezlik jadvali kerak. Transformerlar uchun eng keng tarqalgan sxema — dastlabki yuzlab yoki minglab qadamlarda noldan $\eta_{\max}$ gacha chiziqli qizdirish (warmup), keyin $\eta_{\min}$ gacha kosinusli pasaytirish:

Nega pasaytirish yordam beradi: xossalar bo‘limidan ma’lumki, minimum yonida Adam qadami signal/shovqin nisbatiga ko‘paytirilgan $\eta$ ga proporsional. $\eta$ qanchalik kichik bo‘lsa, vaznlar minimum atrofida titraydigan bulut shunchalik kichik.

Nega qizdirish kerak: dastlabki qadamlarda $\hat v_t$ bir nechta gradiyent bo‘yicha baholangan va kuchli shovqinli, vaznlar esa endigina initsializatsiya qilingan va gradiyentlar ayniqsa katta. Lyu va hammualliflar (RAdam, 2019) o‘qitish boshida $\eta/\sqrt{\hat v_t}$ samarali tezlik dispersiyasi katta ekanini ko‘rsatishdi va uni analitik to‘g‘rilashni taklif qilishdi; qizdirish o‘sha muammoni soddaroq hal qiladi.

Kodda: noldan va PyTorch’da

Noldan amalga oshirish — yigirma qator. decoupled bayrog‘i vaznlar so‘nishini AdamW va gradiyent ichidagi $L_2$ orasida almashtiradi.

pythonimport numpy as np

class Adam:
    """Adam; weight_decay > 0 va decoupled=True bo‘lsa — AdamW. torch.optim’dagidek."""
    def __init__(self, lr=1e-3, betas=(0.9, 0.999), eps=1e-8, weight_decay=0.0, decoupled=True):
        self.lr, (self.b1, self.b2), self.eps = lr, betas, eps
        self.wd, self.decoupled = weight_decay, decoupled
        self.m = self.v = None
        self.t = 0

    def step(self, theta, g):
        if self.m is None:
            self.m, self.v = np.zeros_like(theta), np.zeros_like(theta)
        if self.wd and not self.decoupled:
            g = g + self.wd * theta                        # gradiyent ichidagi L2 (Adam)
        self.t += 1
        self.m = self.b1 * self.m + (1 - self.b1) * g      # inersiya
        self.v = self.b2 * self.v + (1 - self.b2) * g * g  # masshtab
        m_hat = self.m / (1 - self.b1 ** self.t)           # siljishni tuzatish
        v_hat = self.v / (1 - self.b2 ** self.t)
        if self.wd and self.decoupled:
            theta = theta - self.lr * self.wd * theta      # AdamW: so‘nish alohida
        return theta - self.lr * m_hat / (np.sqrt(v_hat) + self.eps)

# Jadvaldagi uchta qadam: g = 0.5, −0.2, 0.4 (qadam η birliklarida bo‘lishi uchun lr = 1)
opt, th = Adam(lr=1.0), np.zeros(1)
for g in [0.5, -0.2, 0.4]:
    new = opt.step(th, np.array([g]))
    print(f"t={opt.t}: m̂={opt.m[0] / (1 - 0.9 ** opt.t):.4f}  qadam/η={th[0] - new[0]:.4f}")
    th = new
# t=1: m̂=0.5000  qadam/η=1.0000
# t=2: m̂=0.1316  qadam/η=0.3456
# t=3: m̂=0.2306  qadam/η=0.5955

# Masshtab invariantligi: ×1000 gradiyentlar o‘sha qadamlarni beradi
rng = np.random.default_rng(0)
a, b, x, y = Adam(lr=0.01), Adam(lr=0.01), np.zeros(1), np.zeros(1)
for t in range(100):
    g = rng.normal(1.0, 0.5, size=1)
    x, y = a.step(x, g), b.step(y, 1000 * g)
print(x, y, abs(x - y))   # [-0.95081564] [-0.95081565] [8.64890637e-09] — farq faqat ε tufayli

Natija «Formula mayda detallarigacha» bo‘limidagi jadval bilan mos keladi, torch.optim.Adam esa o‘sha birinchi qadamda vaznni aynan $\eta$ ga siljitadi. AdamW, alohida so‘nish guruhlari, qizdirish va kosinus bilan odatiy o‘qitish sikli:

pythonimport math
import torch
import torch.nn.functional as F

decay = [p for p in model.parameters() if p.ndim >= 2]     # vazn matritsalari
no_decay = [p for p in model.parameters() if p.ndim < 2]   # siljishlar va normallashtirishlar
opt = torch.optim.AdamW([{"params": decay, "weight_decay": 0.1},
                         {"params": no_decay, "weight_decay": 0.0}],
                        lr=3e-4, betas=(0.9, 0.95), eps=1e-8)

total, warmup = 10_000, 500
def lr_factor(step):                       # lr ko‘paytuvchisi: qizdirish, keyin 10% gacha kosinus
    if step < warmup:
        return (step + 1) / warmup
    p = (step - warmup) / (total - warmup)
    return 0.1 + 0.9 * 0.5 * (1 + math.cos(math.pi * p))
sched = torch.optim.lr_scheduler.LambdaLR(opt, lr_factor)

for step, (x, y) in zip(range(total), loader):
    loss = F.mse_loss(model(x), y)
    opt.zero_grad(set_to_none=True)
    loss.backward()
    torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)  # gradiyentni kesish
    opt.step()
    sched.step()                          # jadval — har bir qadamdan keyin

Giperparametrlar va amaliyot

• Standart qiymatlardan boshlang. $\eta=10^{-3}$ (transformerlar uchun $3\cdot10^{-4}$), $\beta=(0{,}9;\,0{,}999)$, $\lambda=0{,}01$ li AdamW. Avval $\eta$, keyin $\lambda$ va jadvalni tanlash kerak.
• Norma bo‘yicha ($1{,}0$) gradiyentni kesish deyarli tekin va kamdan-kam chetga chiqishlardan qutqaradi.
• Vaznlar bilan birga optimizator holatini saqlang (opt.state_dict()): nol $m$ va $v$ bilan o‘qitishni davom ettirganda dastlabki qadamlar yana «sovuq» bo‘ladi.
• SGD qachon yaxshiroq. Kompyuter ko‘rishi masalalarida yaxshi sozlangan inersiyali SGD ko‘pincha yaxshiroq umumlashtiradi (Uilson va boshq., 2017). Transformerlar, embeddingli tavsiya tizimlari va siyrak gradiyentli masalalarda Adam yutadi.

Ko‘p uchraydigan xatolar

1. AdamW o‘rniga Adam(weight_decay=…). Bu gradiyent ichidagi $L_2$: so‘nish $\sqrt{\hat v_t}$ ga bo‘linadi va notekis ishlaydi (6-rasm).
2. SGD’dan olingan tezlik. $\eta=0{,}1$ inersiyali SGD uchun yaxshi, lekin Adam uchun bu har qadamda vazn birliklarida taxminan $0{,}1$ qadam — o‘qitish deyarli albatta uzoqlashadi.
3. Barcha parametrlarga so‘nish. Siljishlar va LayerNorm/BatchNorm vaznlari odatda weight decay’dan chiqariladi: ularni nolga qisish regulyarizatsiya qilmaydi, zarar keltiradi.
4. Noto‘g‘ri $\epsilon$. Juda kichigi float16 da nolgacha yaxlitlanadi, juda kattasi ($\gtrsim\sqrt{\hat v}$) moslashuvni jimgina o‘chiradi — qadam $(\eta/\epsilon)\hat m$ ga aylanadi.
5. Transformerda qizdirishsiz. Shovqinli $\hat v_t$ bahosi bilan birinchi qadamlardanoq katta $\eta$ ko‘pincha o‘qitish boshida yo‘qotish portlashiga olib keladi.
6. Jadval noto‘g‘ri qadamda. Jadval qadamlar uchun mo‘ljallangan joyda scheduler.step() ni davrda bir marta chaqirish (yoki aksincha) qizdirishni yuzlab marta cho‘zadi yoki qisqartiradi.

Boshqa formulalar bilan bog‘liqlik

• SGD, Momentum va RMSProp: Adam surati — EMA-inersiya, maxraji — RMSProp’dan $\sqrt v$; o‘sha yerda barqarorlik sharti va shartlanganlik soni.
• Kross-entropiya va softmax: til modellarida AdamW minimallashtiradigan yo‘qotish; uning logitlar bo‘yicha $s-y$ gradiyenti oxirgi qatlamning $g_t$ sidir.
• MSE va Huber: maqsad o‘zgaruvchi masshtabi gradiyent masshtabini belgilaydi — Adam unga befarq, SGD esa yo‘q.
• GELU va SiLU: AdamW bilan o‘qitiladigan transformerlar aktivatsiyalari.

Xulosa

O‘zingizni tekshiring