Machine Learning Academy · Pelajaran

Inisialisasi Bobot: Inisialisasi Xavier dan He

Peserta akan menerapkan inisialisasi uniform Xavier dan normal He, serta mengamati cara keduanya mencegah gradien menghilang atau meledak pada jaringan dalam dibandingkan inisialisasi acak bawaan.

Pelajaran 4 dari 413 langkah

Inisialisasi Bobot: Inisialisasi Xavier dan He adalah pelajaran Machine Learning Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Machine Learning Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Machine Learning Academy mencakup 4 pelajaran total.

Mengapa Inisialisasi Penting

Bobot jaringan saraf harus diinisialisasi ke nilai bukan nol sebelum pelatihan — tetapi pilihan cara menginisialisasinya sangat memengaruhi dinamika pelatihan. Inisialisasi yang buruk menyebabkan gradien menghilang (bobot menyusut hingga mendekati nol dan gradien menjadi tidak berarti) atau gradien meledak (bobot tumbuh tanpa batas dan gradien menjadi NaN). Inisialisasi yang baik menjaga aktivasi dan gradien dalam rentang yang sehat sejak batch pertama, sehingga pelatihan berlangsung stabil dan cepat.

import torch
import torch.nn as nn

# All-zeros init: disaster! All neurons compute the same
# gradient (symmetry breaking fails)
model_bad = nn.Linear(4, 4)
nn.init.zeros_(model_bad.weight)
print('All-zero gradients:', model_bad.weight.grad)

# Constant init: same problem
# Random init from N(0,1): works for shallow, fails deep
# Xavier / He: designed for deep networks

Masalah Pemecahan Simetri

Jika semua bobot diinisialisasi ke nilai yang sama (termasuk nol), setiap neuron dalam suatu lapisan menghitung keluaran yang persis sama dan menerima gradien yang persis sama. Semua neuron mempelajari fitur yang sama — secara praktis, lapisan tersembunyi menyusut menjadi satu neuron. Masalah simetri inilah yang membuat inisialisasi acak diperlukan: setiap neuron harus dimulai dengan bobot acak yang berbeda untuk memecahkan simetri dan mempelajari representasi yang berbeda.

import torch
import torch.nn as nn

# Demonstrate symmetry breaking failure
model = nn.Linear(3, 4, bias=False)
nn.init.constant_(model.weight, 0.1)  # all same

x = torch.randn(5, 3)
y = model(x)

# All 4 neurons produce identical outputs!
print('All neurons identical:', torch.allclose(y[:, 0], y[:, 1]))
# True -- the 4 output neurons are indistinguishable

Kegagalan Inisialisasi Normal Naif

Menginisialisasi bobot dari distribusi normal standar N(0, 1) tampak masuk akal, tetapi menimbulkan masalah dalam jaringan yang dalam. Untuk lapisan dengan fan-in (jumlah koneksi masukan) sebesar 1000, jumlah berbobot dari 1000 nilai yang terdistribusi normal memiliki varians 1000 — sehingga menyebabkan aktivasi meledak dalam jaringan yang dalam. Sebaliknya, nilai acak yang sangat kecil (misalnya, N(0, 0.001)) menyebabkan aktivasi menghilang. Kedua kondisi ekstrem ini tidak memungkinkan gradien mengalir melalui banyak lapisan.

import torch
import torch.nn as nn

# Track activation variance through 10 deep layers
def test_deep_init(std):
    x = torch.randn(1, 256)
    for i in range(10):
        W = torch.randn(256, 256) * std
        x = torch.tanh(x @ W)
    return x.std().item()

print(f'std=1.0:   activation_std={test_deep_init(1.0):.6f}')
# Huge -> saturation
print(f'std=0.01:  activation_std={test_deep_init(0.01):.6f}')
# Near zero -> vanishing

Inisialisasi Xavier Glorot

Inisialisasi Xavier (Glorot dan Bengio, 2010) dirancang untuk jaringan yang menggunakan aktivasi tanh atau sigmoid. Gagasannya adalah memilih bobot sedemikian rupa sehingga varians aktivasi dan gradien tetap kurang lebih konstan di seluruh lapisan. Bobot diambil dari distribusi seragam atau normal dengan varians 2 / (fan_in + fan_out). Ini adalah inisialisasi bawaan untuk nn.Linear (varian seragam) dalam PyTorch.

import torch
import torch.nn as nn

layer = nn.Linear(256, 128)

# Xavier uniform: default for nn.Linear
nn.init.xavier_uniform_(layer.weight)
print('Xavier uniform std:', layer.weight.std().item())
# Approximately sqrt(2 / (256 + 128)) = 0.081

# Xavier normal: Gaussian version
nn.init.xavier_normal_(layer.weight)
print('Xavier normal std:', layer.weight.std().item())

Inisialisasi He (Kaiming) untuk ReLU

Inisialisasi He (He dkk., 2015) dirancang khusus untuk jaringan yang menggunakan aktivasi ReLU. Karena ReLU mengubah setengah masukannya menjadi nol (nilai negatif), varians efektif setelah aktivasi menjadi setengahnya. Inisialisasi He mengimbanginya dengan menggunakan varians 2 / fan_in — dua kali lipat dari yang digunakan Xavier. Menggunakan Xavier dengan ReLU menyebabkan gradien menghilang dalam jaringan yang dalam; menggunakan inisialisasi He memungkinkan pelatihan jaringan dengan lebih dari 100 lapisan.

import torch
import torch.nn as nn

layer = nn.Linear(512, 256)

# He (Kaiming) uniform: designed for ReLU
nn.init.kaiming_uniform_(layer.weight,
                          nonlinearity='relu')
print('Kaiming uniform std:', layer.weight.std().item())
# Approximately sqrt(2/512) * sqrt(3) = 0.108

# He (Kaiming) normal: Gaussian variant
nn.init.kaiming_normal_(layer.weight,
                         nonlinearity='relu')
print('Kaiming normal std:', layer.weight.std().item())

Membandingkan Metode Inisialisasi pada Jaringan yang Dalam

Pengaruh inisialisasi terlihat saat Anda melacak statistik aktivasi di seluruh lapisan jaringan yang dalam. Dengan inisialisasi Xavier dan tanh, varians aktivasi tetap mendekati 1 di semua lapisan. Dengan inisialisasi He dan ReLU, hal yang sama berlaku untuk jaringan ReLU. Menggunakan kombinasi yang salah (Xavier + ReLU atau He + sigmoid) menyebabkan aktivasi runtuh atau meledak secara sistematis, yang menegaskan bahwa pilihan inisialisasi harus disesuaikan dengan fungsi aktivasi.

import torch
import torch.nn as nn

def track_activation_std(init_fn, activation, n_layers=10):
    x = torch.randn(64, 256)
    stds = []
    for _ in range(n_layers):
        W = torch.empty(256, 256)
        init_fn(W)
        x = activation(x @ W.T)
        stds.append(x.std().item())
    return stds

xavier = lambda W: nn.init.xavier_uniform_(W)
he     = lambda W: nn.init.kaiming_uniform_(W, nonlinearity='relu')

xavier_stds = track_activation_std(xavier, torch.tanh)
he_stds     = track_activation_std(he, torch.relu)

print('Xavier+tanh layer stds:', [f'{s:.2f}' for s in xavier_stds])
print('He+ReLU layer stds:', [f'{s:.2f}' for s in he_stds])

Menerapkan Inisialisasi Kustom pada Seluruh Model

Anda dapat menerapkan inisialisasi kustom pada seluruh model menggunakan model.apply(init_fn), yang mengunjungi setiap modul secara rekursif. Fungsi tersebut menerima setiap modul dan dapat menerapkan inisialisasi yang berbeda berdasarkan jenis lapisan. Pola yang umum adalah menerapkan inisialisasi He pada lapisan Linear dan Conv2d, inisialisasi Xavier pada lapisan embedding, serta menetapkan bias ke nol. Satu pemanggilan ini menggantikan nilai bawaan PyTorch di seluruh jaringan.

import torch.nn as nn

def init_weights(module):
    if isinstance(module, nn.Linear):
        nn.init.kaiming_normal_(module.weight,
                                nonlinearity='relu')
        if module.bias is not None:
            nn.init.zeros_(module.bias)
    elif isinstance(module, nn.Conv2d):
        nn.init.kaiming_normal_(module.weight,
                                nonlinearity='relu')

model = nn.Sequential(
    nn.Linear(64, 128), nn.ReLU(),
    nn.Linear(128, 64), nn.ReLU(),
    nn.Linear(64, 10)
)
model.apply(init_weights)
print('Custom He init applied to all layers')

Inisialisasi Ortogonal untuk RNN

Inisialisasi ortogonal menetapkan matriks bobot agar ortogonal (Q dari dekomposisi QR), sehingga mempertahankan norma gradien selama propagasi balik melalui waktu. Ini sangat berguna terutama untuk jaringan berulang, karena matriks bobot yang sama dikalikan berulang kali (sekali untuk setiap langkah waktu). Bobot ortogonal mencegah gradien meledak atau menghilang saat dipropagasikan kembali melalui banyak langkah waktu dalam urutan panjang.

import torch
import torch.nn as nn

# Orthogonal init: columns are orthonormal
layer = nn.Linear(64, 64)
nn.init.orthogonal_(layer.weight)

# Verify: W @ W.T should be identity (approx)
I_approx = layer.weight @ layer.weight.T
print('Close to identity:', torch.allclose(
    I_approx,
    torch.eye(64),
    atol=1e-5
))
# True -- orthogonal matrices preserve vector norms

Inisialisasi Bawaan PyTorch

PyTorch secara otomatis menerapkan nilai bawaan yang sesuai: nn.Linear menggunakan seragam Kaiming untuk bobot dan distribusi seragam untuk bias. nn.Conv2d juga menggunakan seragam Kaiming. nn.Embedding menggunakan normal standar N(0, 1). nn.LSTM menggunakan distribusi seragam dalam [-1/sqrt(hidden), 1/sqrt(hidden)]. Dalam banyak kasus, nilai bawaan ini bekerja dengan baik, tetapi untuk jaringan yang sangat dalam atau aktivasi nonstandar, inisialisasi eksplisit menggunakan rumus di atas memberikan hasil yang lebih baik.

import torch.nn as nn

# Check PyTorch defaults
linear = nn.Linear(256, 128)
print('Linear weight std:', linear.weight.std().item())
# ~0.088 = Kaiming uniform for fan_in=256

conv = nn.Conv2d(3, 64, kernel_size=3)
print('Conv2d weight std:', conv.weight.std().item())
# Kaiming uniform based on receptive field size

emb = nn.Embedding(1000, 128)
print('Embedding weight std:', emb.weight.std().item())
# ~1.0 = N(0, 1) default

Panduan Praktis Inisialisasi

Panduan praktis untuk memilih inisialisasi: gunakan normal atau seragam He (Kaiming) untuk jaringan apa pun yang menggunakan ReLU atau variannya (LeakyReLU, ELU, GELU). Gunakan normal atau seragam Xavier untuk aktivasi tanh atau sigmoid. Gunakan ortogonal untuk bobot berulang. Tetapkan bias ke nol dalam semua kasus. Untuk Transformer dengan GELU, N(0, 0.02) adalah standar empiris yang digunakan dalam GPT-2 dan model-model berikutnya. Andalkan nilai bawaan PyTorch untuk arsitektur standar; lakukan penggantian hanya jika pelatihan tidak stabil.

# Quick reference table
init_guide = {
    'ReLU (Linear, Conv)': 'kaiming_normal_ / kaiming_uniform_',
    'Tanh / Sigmoid':       'xavier_normal_ / xavier_uniform_',
    'RNN hidden matrix':    'orthogonal_',
    'Transformer (GELU)':   'normal_(mean=0, std=0.02)',
    'Embedding':            'normal_(mean=0, std=1)',
    'Biases':               'zeros_()'
}
for activation, method in init_guide.items():
    print(f'{activation}: {method}')

Memverifikasi Kualitas Inisialisasi

Setelah menerapkan inisialisasi, verifikasi hasilnya dengan memeriksa statistik aktivasi pada lintasan maju pertama. Jaringan yang sehat seharusnya memiliki simpangan baku aktivasi yang mendekati 1,0 di semua lapisan dan norma gradien dengan besaran yang serupa di seluruh lapisan. Perbedaan besar (misalnya, std=10 pada satu lapisan dan std=0.001 pada lapisan lain) menunjukkan ketidaksesuaian inisialisasi. Pemeriksaan kewajaran singkat ini hanya memerlukan beberapa detik dan dapat menghemat waktu berjam-jam untuk men-debug dinamika pelatihan yang buruk.

import torch
import torch.nn as nn

model = nn.Sequential(
    nn.Linear(64, 256), nn.ReLU(),
    nn.Linear(256, 256), nn.ReLU(),
    nn.Linear(256, 64),  nn.ReLU(),
    nn.Linear(64, 10)
)
model.apply(lambda m: nn.init.kaiming_normal_(m.weight)
            if isinstance(m, nn.Linear) else None)

# Check activation std through the network
x = torch.randn(32, 64)
hooks = []
stds = []
for layer in model:
    x = layer(x)
    if hasattr(x, 'std'):
        stds.append(x.std().item())
print('Activation stds:', [f'{s:.2f}' for s in stds])

Pemeriksaan Singkat

Uji pemahaman Anda tentang konsep Pembelajaran Mesin dengan Python dari pelajaran ini.

Jawab di pelajaran interaktif

Ringkasan Pelajaran

Dalam pelajaran ini, Anda telah mempelajari: inisialisasi Xavier dirancang untuk aktivasi tanh/sigmoid dengan varians 2/(fan_in + fan_out), inisialisasi He (Kaiming) dirancang untuk ReLU dengan varians 2/fan_in guna mengimbangi ReLU yang mengubah setengah masukannya menjadi nol, dan model.apply(init_fn) menerapkan inisialisasi kustom pada setiap lapisan dalam jaringan. Selanjutnya, kita akan mendalami jaringan saraf konvolusional, dimulai dengan operasi konvolusi dan filter.

Gratis untuk memulai

Belajar Python dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 30
Pelajaran: 120

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Inisialisasi Bobot: Inisialisasi Xavier dan He” gratis?

Ya — teks lengkap “Inisialisasi Bobot: Inisialisasi Xavier dan He” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Machine Learning Academy, upgrade ke CoddyKit PRO. Kursus Machine Learning Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Inisialisasi Bobot: Inisialisasi Xavier dan He”?

Peserta akan menerapkan inisialisasi uniform Xavier dan normal He, serta mengamati cara keduanya mencegah gradien menghilang atau meledak pada jaringan dalam dibandingkan inisialisasi acak bawaan. Kamu berlatih Machine Learning Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Machine Learning Academy?

Tidak diperlukan pengalaman sebelumnya. Machine Learning Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Inisialisasi Bobot: Inisialisasi Xavier dan He” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Machine Learning Academy ini?

Ya. Setiap pelajaran Machine Learning Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Laju Pembelajaran: Hyperparameter Terpenting
Normalisasi Batch: Pelatihan yang Stabil dan Lebih Cepat
Regularisasi Dropout untuk Mencegah Overfitting
Inisialisasi Bobot: Inisialisasi Xavier dan He

← Kembali ke Machine Learning Academy