Machine Learning Academy · Pelajaran

Kadar Pembelajaran: Hiperparameter Paling Penting

Pelajar akan menjalankan ujian julat kadar pembelajaran, memplot kehilangan berbanding LR, mengenal pasti julat optimum, dan menggunakan jadual CosineAnnealingLR untuk mengelakkan keadaan mendatar.

Pelajaran 1 daripada 413 langkah

Kadar Pembelajaran: Hiperparameter Paling Penting ialah pelajaran Machine Learning Academy percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Machine Learning Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Machine Learning Academy merangkumi sejumlah 4 pelajaran.

Mengapa Kadar Pembelajaran Paling Penting

Kadar pembelajaran (LR) ialah hiperparameter tunggal yang paling mempengaruhi kejayaan latihan rangkaian neural. Kadar ini mengawal saiz langkah yang diambil oleh pengoptimum mengikut arah kecerunan negatif. Jika terlalu besar, model akan menyimpang; jika terlalu kecil, latihan mengambil masa terlalu lama atau tersekat. Berbeza daripada pilihan seni bina, LR mesti dilaraskan hampir setiap kali anda mengubah set data, saiz model atau saiz kelompok.

import torch
import torch.nn as nn
import torch.optim as optim

model = nn.Linear(1, 1)

# Too large: diverges
optimizer_big = optim.SGD(model.parameters(), lr=10.0)

# Too small: barely moves
optimizer_small = optim.SGD(model.parameters(), lr=1e-6)

# Good: converges steadily
optimizer_good = optim.SGD(model.parameters(), lr=0.01)

print('LR comparison: 10.0, 1e-6, 0.01')

Kesan LR terhadap Lengkung Kerugian

Kadar pembelajaran yang berbeza menghasilkan corak yang mudah dikenal pasti pada lengkung kerugian. Terlalu tinggi: kerugian berayun dengan ketara atau meningkat selepas beberapa langkah. Terlalu rendah: kerugian menurun dengan amat perlahan dan hampir mendatar. Tepat: kerugian menurun dengan lancar dan konsisten. Memplotkan kerugian berbanding kelompok/epoch untuk beberapa nilai LR yang mewakili (contohnya, 1e-4, 1e-3, 1e-2, 1e-1) sebelum memulakan latihan yang panjang ialah amalan standard.

import torch
import torch.nn as nn
import torch.optim as optim

def train_one_lr(lr, steps=50):
    model = nn.Linear(1, 1)
    opt = optim.SGD(model.parameters(), lr=lr)
    X = torch.randn(100, 1)
    y = 2 * X + 1
    losses = []
    for _ in range(steps):
        opt.zero_grad()
        loss = nn.MSELoss()(model(X), y)
        loss.backward(); opt.step()
        losses.append(loss.item())
    return losses[-1]

for lr in [1e-4, 1e-2, 0.1, 1.0]:
    final = train_one_lr(lr)
    print(f'LR={lr:.4f}: final_loss={final:.4f}')

Ujian Julat Kadar Pembelajaran

Ujian julat LR (dipopularkan oleh Leslie Smith) mencari LR yang baik secara automatik. Mulakan dengan LR yang sangat kecil dan tingkatkannya secara eksponen merentasi banyak kelompok mini sambil merekodkan kerugian. Kerugian mula-mula menurun, kemudian meningkat dengan mendadak apabila LR terlalu besar. LR optimum kira-kira 10 kali lebih kecil daripada titik kerugian mula meningkat. Ujian ini hanya mengambil masa beberapa minit dan menghapuskan keperluan untuk carian grid LR yang mahal.

import torch
import torch.nn as nn
import torch.optim as optim
import math

def lr_range_test(model, loader, criterion, start_lr=1e-7, end_lr=10, num_iter=100):
    optimizer = optim.SGD(model.parameters(), lr=start_lr)
    lrs, losses = [], []
    mult = (end_lr / start_lr) ** (1 / num_iter)
    lr = start_lr
    for i, (X, y) in enumerate(loader):
        if i >= num_iter: break
        optimizer.zero_grad()
        loss = criterion(model(X), y)
        loss.backward(); optimizer.step()
        lrs.append(lr)
        losses.append(loss.item())
        lr *= mult
        for pg in optimizer.param_groups:
            pg['lr'] = lr
    return lrs, losses

Pemanasan Awal: Bermula Kecil dan Meningkat

Pemanasan awal kadar pembelajaran memulakan latihan dengan LR yang sangat kecil dan meningkatkannya secara beransur-ansur kepada LR sasaran sepanjang beberapa ratus langkah atau epoch pertama. Ini menghalang kemas kini besar yang tidak stabil pada permulaan, ketika pemberat dimulakan secara rawak dan kecerunan bising. Pemanasan awal amat penting untuk Pengubah dan latihan dengan kelompok besar, kerana langkah awal yang besar boleh menghantar model ke kawasan landskap kerugian yang kurang baik dan sukar ditinggalkan.

import torch.optim as optim
import torch.nn as nn

model = nn.Linear(4, 2)
optimizer = optim.Adam(model.parameters(), lr=1e-3)

def warmup_lambda(current_step, warmup_steps=100):
    if current_step < warmup_steps:
        return current_step / warmup_steps
    return 1.0

scheduler = optim.lr_scheduler.LambdaLR(
    optimizer, lr_lambda=warmup_lambda
)

for step in range(5):
    scheduler.step()
    print(f'Step {step}: LR={optimizer.param_groups[0]["lr"]:.6f}')

Penjadualan Susutan Langkah dengan StepLR

StepLR mengurangkan kadar pembelajaran mengikut faktor pendaraban gamma setiap step_size epoch. Sebagai contoh, mengurangkan LR separuh setiap 10 epoch (gamma=0.5, step_size=10) ialah jadual lazim untuk pengelasan imej. Susutan langkah mudah difahami dan berfungsi dengan baik apabila anda mengetahui secara kasar bilangan epoch yang diperlukan oleh model untuk stabil. Penjadual mesti dipanggil selepas langkah pengoptimum pada setiap epoch.

import torch.optim as optim
import torch.nn as nn

model = nn.Linear(4, 2)
optimizer = optim.SGD(model.parameters(), lr=0.1)
scheduler = optim.lr_scheduler.StepLR(
    optimizer, step_size=3, gamma=0.5
)

for epoch in range(9):
    # (training happens here)
    scheduler.step()
    print(f'After epoch {epoch}: LR={optimizer.param_groups[0]["lr"]:.4f}')
# 0.1 -> 0.1 -> 0.1 -> 0.05 -> 0.05 -> 0.05 -> 0.025 ...

Penyepuhan Kosinus: Susutan Lancar ke Sifar

CosineAnnealingLR menyusutkan LR mengikut lengkung kosinus daripada LR awal kepada minimum (eta_min, lalai 0) sepanjang T_max langkah. Bentuk kosinus memberikan penurunan awal yang pantas dengan pendaratan lembut berhampiran sifar. CosineAnnealingWarmRestarts menambah permulaan semula berkala yang membantu melarikan diri daripada minimum setempat, lalu menghasilkan corak LR gigi gergaji yang tersendiri. Jadual kosinus merupakan antara jadual yang paling banyak digunakan dalam pembelajaran mendalam moden.

import torch.optim as optim
import torch.nn as nn

model = nn.Linear(4, 2)
optimizer = optim.SGD(model.parameters(), lr=0.1)
scheduler = optim.lr_scheduler.CosineAnnealingLR(
    optimizer, T_max=10, eta_min=1e-4
)

for epoch in range(10):
    scheduler.step()
    lr = optimizer.param_groups[0]['lr']
    print(f'Epoch {epoch}: LR={lr:.5f}')
# Smoothly decays from 0.1 to 0.0001 over 10 epochs

ReduceLROnPlateau: Penjadualan Adaptif

ReduceLROnPlateau memantau metrik (biasanya kerugian pengesahan) dan mengurangkan LR mengikut faktor tertentu apabila metrik itu berhenti bertambah baik selama bilangan epoch yang ditetapkan (patience). Ini ialah penjadual paling adaptif kerana ia bertindak balas terhadap dinamik latihan sebenar, bukannya jadual yang telah ditentukan terlebih dahulu. Ia amat berkesan apabila anda tidak pasti berapa banyak epoch yang diperlukan atau apabila kemajuan latihan tidak sekata.

import torch.optim as optim
import torch.nn as nn

model = nn.Linear(4, 2)
optimizer = optim.Adam(model.parameters(), lr=0.01)
scheduler = optim.lr_scheduler.ReduceLROnPlateau(
    optimizer,
    mode='min',       # reduce when metric stops going down
    factor=0.5,       # multiply LR by 0.5
    patience=3,       # wait 3 epochs before reducing
    min_lr=1e-6
)

# Each epoch, pass the validation loss
for epoch in range(10):
    val_loss = 1.0 / (epoch + 1)   # simulated decreasing loss
    scheduler.step(val_loss)
    print(f'Epoch {epoch}: LR={optimizer.param_groups[0]["lr"]}')

Saiz Kelompok dan Hubungannya dengan LR

Saiz kelompok dan kadar pembelajaran saling berkait rapat. Apabila anda menggandakan saiz kelompok, kecerunan dipuratakan merentasi dua kali ganda bilangan sampel — maka kecerunan itu kurang bising. Heuristik yang lazim digunakan ialah peraturan penskalaan linear: darabkan LR dengan faktor yang sama seperti peningkatan saiz kelompok. Sebagai contoh, menggandakan saiz kelompok daripada 64 kepada 128 mencadangkan supaya LR turut digandakan. Peraturan ini berfungsi dengan baik dalam julat sederhana, tetapi tidak lagi sesuai untuk kelompok yang sangat besar.

# Linear scaling rule: if base LR=0.01 with batch_size=64
# and you change to batch_size=256 (4x larger):

base_lr = 0.01
base_batch = 64
new_batch = 256

scaled_lr = base_lr * (new_batch / base_batch)
print(f'Scaled LR: {scaled_lr}')   # 0.04

# But use warm-up when scaling to very large batches
# to avoid instability at the start of training

Pemotongan Kecerunan: Mencegah Kecerunan Meletup

Apabila LR sedikit terlalu tinggi atau kecerunan sememangnya besar (lazim dalam RNN), pemotongan kecerunan menghalang kemas kini parameter daripada menjadi terlalu besar dan memudaratkan. torch.nn.utils.clip_grad_norm_ menskala semula vektor kecerunan supaya mempunyai norma L2 maksimum. Pemotongan berlaku selepas memanggil .backward() tetapi sebelum optimizer.step(). Norma maksimum 1.0 ialah nilai lalai yang lazim untuk rangkaian berulang.

import torch
import torch.nn as nn
import torch.optim as optim

model = nn.LSTM(4, 8, batch_first=True)
optimizer = optim.Adam(model.parameters(), lr=0.001)

x = torch.randn(16, 10, 4)   # batch=16, seq=10, features=4
out, _ = model(x)
loss = out.sum()
loss.backward()

# Clip gradients before optimizer step
total_norm = nn.utils.clip_grad_norm_(
    model.parameters(), max_norm=1.0
)
print(f'Gradient norm before clip: {total_norm:.4f}')
optimizer.step()

Mencari LR dengan PyTorch Lightning atau Gelung Manual

Ramai pengamal menggunakan pencari LR terbina dalam PyTorch Lightning, yang mengautomatikkan ujian julat LR. Jika anda menggunakan PyTorch mentah, laksanakan ujian julat secara manual dengan meningkatkan LR secara eksponen merentasi 100 kelompok mini dan memplotkan kerugian berbanding LR pada skala logaritma. Titik terbaik ialah apabila kerugian menurun paling curam. Alat seperti pakej torch-lr-finder membungkus proses ini dalam satu panggilan fungsi untuk kemudahan.

# Manual LR finder sketch (pseudocode)
import math

# 1. Save initial model state
# torch.save(model.state_dict(), 'init.pt')

# 2. Sweep LR exponentially from 1e-7 to 1
start, end, steps = 1e-7, 1.0, 100
mult = (end / start) ** (1 / steps)
lr = start
for i, (X, y) in enumerate(train_loader):
    if i >= steps: break
    # train one step with current lr...
    lr *= mult

# 3. Plot lrs vs losses on log-linear scale
# 4. Pick LR where loss drops fastest
# 5. Restore initial model state

Ringkasan LR dan Peraturan Praktikal

Peraturan praktikal paling penting untuk kadar pembelajaran: mulakan dengan 1e-3 untuk Adam dan 0.01 untuk SGD sebagai nilai lalai. Sentiasa jalankan ujian julat LR ringkas apabila menggunakan set data atau seni bina baharu. Gunakan penyepuhan kosinus atau ReduceLROnPlateau berbanding LR tetap untuk penumpuan terbaik. Skalakan LR secara linear mengikut saiz kelompok. Sentiasa gunakan pemotongan kecerunan untuk RNN. Usaha yang diluangkan untuk melaraskan LR memberikan manfaat yang lebih besar berbanding hampir mana-mana pengoptimuman lain.

# Quick reference for default starting points
defaults = {
    'SGD':   {'lr': 0.01, 'momentum': 0.9},
    'Adam':  {'lr': 1e-3, 'betas': (0.9, 0.999)},
    'AdamW': {'lr': 1e-3, 'weight_decay': 0.01},
    'RMSprop': {'lr': 1e-4}
}

print('Default LR starting points:')
for opt, params in defaults.items():
    print(f'  {opt}: {params}')

Semakan Pantas

Uji pemahaman anda tentang konsep Pembelajaran Mesin dengan Python daripada pelajaran ini.

Jawab dalam pelajaran interaktif

Ulang Kaji Pelajaran

Dalam pelajaran ini, anda mempelajari bahawa kadar pembelajaran ialah hiperparameter paling kritikal yang mengawal kelajuan dan kestabilan penumpuan, ujian julat LR mencari LR yang baik dengan cepat dengan mengimbas daripada kecil kepada besar dan mencari penurunan kerugian paling curam, serta penjadual seperti CosineAnnealingLR dan ReduceLROnPlateau melaraskan LR secara automatik semasa latihan untuk prestasi akhir yang lebih baik. Seterusnya, kita akan meneroka penormalan kelompok untuk latihan yang lebih pantas dan stabil.

Percuma untuk bermula

Pelajari Python dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 30
Pelajaran: 120

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Kadar Pembelajaran: Hiperparameter Paling Penting” percuma?

Ya — teks penuh “Kadar Pembelajaran: Hiperparameter Paling Penting” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Machine Learning Academy, tingkat taraf kepada CoddyKit PRO. Kursus Machine Learning Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Kadar Pembelajaran: Hiperparameter Paling Penting”?

Pelajar akan menjalankan ujian julat kadar pembelajaran, memplot kehilangan berbanding LR, mengenal pasti julat optimum, dan menggunakan jadual CosineAnnealingLR untuk mengelakkan keadaan mendatar. Anda berlatih Machine Learning Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Machine Learning Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Machine Learning Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Kadar Pembelajaran: Hiperparameter Paling Penting” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Machine Learning Academy ini?

Ya. Setiap pelajaran Machine Learning Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Kadar Pembelajaran: Hiperparameter Paling Penting
Normalisasi Kelompok: Latihan Stabil dan Lebih Pantas
Pelarasan Regularisasi Dropout untuk Mencegah Terlebih Suai
Pemulaan Pemberat: Pemulaan Xavier dan He

← Kembali ke Machine Learning Academy