Machine Learning Academy · Pelajaran

Normalisasi Kelompok: Latihan Stabil dan Lebih Pantas

Pelajar akan menyisipkan nn.BatchNorm1d antara lapisan, memerhatikan penumpuan yang lebih pantas pada rangkaian dalam, dan memahami cara BatchNorm menormalkan pengaktifan dalam setiap kelompok mini.

Pelajaran 2 daripada 413 langkah

Normalisasi Kelompok: Latihan Stabil dan Lebih Pantas ialah pelajaran Machine Learning Academy percuma di CoddyKit. Ini ialah pelajaran 2 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.

Masalah yang Diselesaikan oleh Batch Norm

Rangkaian neural mendalam mengalami peralihan kovariat dalaman — taburan input bagi setiap lapisan berubah semasa latihan apabila pemberat lapisan sebelumnya dikemas kini. Hal ini memaksa setiap lapisan menyesuaikan diri secara berterusan dengan taburan input yang berubah-ubah, lalu memperlahankan latihan. Normalisasi Kelompok (Batch Norm), yang diperkenalkan oleh Ioffe dan Szegedy pada tahun 2015, menangani masalah ini dengan menormalkan input lapisan dalam setiap kelompok mini, sekali gus mempercepatkan latihan dengan ketara dan mengurangkan kebergantungan pada pengawalan awal pemberat.

# Without batch norm: deep networks train slowly and
# require very careful weight init and LR tuning.

# With batch norm: can use higher learning rates,
# less sensitive to initialisation, acts as regulariser.

# Batch norm normalises each feature to:
# mean=0, std=1 within the batch, then
# applies learnable scale (gamma) and shift (beta).
print('Batch Norm: normalize -> scale -> shift')

Cara Batch Norm Berfungsi dari Segi Matematik

Bagi setiap dimensi ciri, Batch Norm mengira min dan varians merentasi kelompok mini semasa, kemudian menormalkan setiap nilai. Selepas normalisasi, ia menggunakan dua parameter yang boleh dipelajari: gamma (skala) dan beta (anjakan). Hal ini membolehkan rangkaian membatalkan normalisasi jika perlu — transformasi identiti boleh diperoleh semula. Pemalar kecil epsilon ditambahkan pada varians untuk mengelakkan pembahagian dengan sifar.

import torch

def batch_norm_manual(x, gamma, beta, eps=1e-5):
    # x shape: (batch_size, features)
    mu = x.mean(dim=0)           # mean per feature
    var = x.var(dim=0, unbiased=False)  # var per feature
    x_norm = (x - mu) / (var + eps).sqrt()
    return gamma * x_norm + beta  # scale and shift

x = torch.randn(32, 8)  # batch=32, 8 features
gamma = torch.ones(8)
beta = torch.zeros(8)

out = batch_norm_manual(x, gamma, beta)
print('Mean near 0:', out.mean(dim=0).abs().max().item() < 0.01)
print('Std near 1:', (out.std(dim=0) - 1).abs().max().item() < 0.01)

nn.BatchNorm1d untuk Lapisan Bersambung Penuh

nn.BatchNorm1d digunakan selepas lapisan linear dalam rangkaian suap hadapan. Ia menerima num_features (saiz output lapisan sebelumnya) sebagai argumennya. Batch Norm biasanya diletakkan selepas lapisan linear tetapi sebelum fungsi pengaktifan, walaupun masih terdapat perbincangan tentang sama ada kedudukan sebelum atau selepas pengaktifan lebih baik. Modul ini mengekalkan min dan varians bergerak untuk digunakan semasa inferens.

import torch
import torch.nn as nn

model = nn.Sequential(
    nn.Linear(16, 64),
    nn.BatchNorm1d(64),   # after linear, before activation
    nn.ReLU(),
    nn.Linear(64, 32),
    nn.BatchNorm1d(32),
    nn.ReLU(),
    nn.Linear(32, 10)
)

x = torch.randn(32, 16)   # batch of 32
out = model(x)
print(out.shape)           # torch.Size([32, 10])

Tingkah Laku Semasa Latihan berbanding Inferens

Batch Norm berkelakuan secara berbeza semasa latihan dan inferens. Semasa latihan, ia menggunakan statistik kelompok mini (min dan varians kelompok semasa). Semasa inferens, ia menggunakan statistik bergerak (purata bergerak eksponen yang dikumpulkan semasa latihan) supaya ramalan bersifat tentu dan tidak bergantung pada saiz kelompok. Oleh itu, anda mesti memanggil model.eval() semasa inferens — tindakan ini menukar BatchNorm supaya menggunakan statistik bergerak.

import torch
import torch.nn as nn

bn = nn.BatchNorm1d(4)

# Training mode: uses batch statistics, updates running stats
bn.train()
x = torch.randn(8, 4)
out_train = bn(x)

# After training, running_mean and running_var are populated
print('Running mean:', bn.running_mean)

# Eval mode: uses running statistics (deterministic)
bn.eval()
x_new = torch.randn(1, 4)   # single sample -- works!
out_eval = bn(x_new)
print(out_eval.shape)         # torch.Size([1, 4])

Parameter yang Boleh Dipelajari: gamma dan beta

Batch Norm mempunyai dua parameter yang boleh dipelajari bagi setiap ciri: weight (gamma, dimulakan dengan nilai 1) dan bias (beta, dimulakan dengan nilai 0). Parameter ini membolehkan rangkaian belajar menskala semula dan mengubah anjakan nilai yang dinormalkan jika hal itu meningkatkan prestasi tugas. Parameter tersebut dikemas kini oleh pengoptimum sama seperti matriks pemberat biasa. Jika anda mahu membekukan lapisan Batch Norm semasa penalaan halus, tetapkan requires_grad=False pada parameter ini.

import torch.nn as nn

bn = nn.BatchNorm1d(8)
print('gamma (weight):', bn.weight.data)   # all 1s
print('beta (bias):', bn.bias.data)         # all 0s
print('gamma requires_grad:', bn.weight.requires_grad)  # True
print('beta requires_grad:', bn.bias.requires_grad)     # True

# Total trainable params in this BN layer:
# 2 * 8 = 16 (gamma and beta for 8 features)
params = sum(p.numel() for p in bn.parameters())
print('Params:', params)   # 16

Memerhatikan Penumpuan yang Lebih Pantas

Salah satu manfaat Batch Norm yang paling jelas ialah penumpuan yang lebih pantas. Rangkaian dengan Batch Norm biasanya mencapai ketepatan pengesahan yang sama dalam epoch yang lebih sedikit dan boleh menggunakan kadar pembelajaran yang lebih besar tanpa ketidakstabilan. Normalisasi mengekalkan pengaktifan dalam julat yang sihat sepanjang latihan, lalu menghalang ketepuan yang memperlahankan pembelajaran dalam rangkaian yang menggunakan pengaktifan sigmoid atau tanh. Kesan ini paling ketara dalam rangkaian mendalam yang mempunyai banyak lapisan.

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

def make_model(use_bn):
    layers = [nn.Linear(16, 64)]
    if use_bn: layers.append(nn.BatchNorm1d(64))
    layers.append(nn.ReLU())
    layers.append(nn.Linear(64, 2))
    return nn.Sequential(*layers)

X = torch.randn(200, 16)
y = torch.randint(0, 2, (200,))

for use_bn in [False, True]:
    model = make_model(use_bn)
    opt = optim.SGD(model.parameters(), lr=0.1)
    crit = nn.CrossEntropyLoss()
    for _ in range(20):
        opt.zero_grad(); loss = crit(model(X), y)
        loss.backward(); opt.step()
    print(f'BN={use_bn}: final_loss={loss.item():.4f}')

Batch Norm sebagai Pengawal Selia

Batch Norm bertindak sebagai pengawal selia ringan kerana setiap sampel latihan dinormalkan berbanding sampel lain dalam kelompok mini — lalu memperkenalkan ke rawakan yang serupa dengan Dropout. Oleh itu, rangkaian dengan Batch Norm selalunya memerlukan kurang Dropout. Kesan pengawalan selia berkurang apabila saiz kelompok bertambah kerana statistik kelompok menjadi lebih tentu, menghampiri statistik populasi sebenar dan menghapuskan unsur ke rawakan.

# Key insight: batch norm introduces noise proportional to
# 1/sqrt(batch_size) because batch statistics are noisy
# estimates of population statistics.

# Small batch (e.g., 8): high noise -> more regularisation
# Large batch (e.g., 512): low noise -> less regularisation

# Common pattern: use batch norm AND a small dropout
# for strong regularisation in deep networks
model = __import__('torch').nn.Sequential(
    __import__('torch').nn.Linear(32, 128),
    __import__('torch').nn.BatchNorm1d(128),
    __import__('torch').nn.ReLU(),
    __import__('torch').nn.Dropout(0.2)  # mild dropout
)
print('BN + light Dropout: balanced regularisation')

nn.BatchNorm2d untuk Rangkaian Konvolusi

Dalam rangkaian konvolusi, nn.BatchNorm2d menormalkan merentasi dimensi kelompok dan ruang bagi setiap saluran secara berasingan. Ia menerima num_channels sebagai argumen (sepadan dengan bilangan saluran output daripada lapisan Conv2d sebelumnya). Corak piawai ialah Conv2d -> BatchNorm2d -> ReLU, yang digunakan dalam hampir semua seni bina CNN moden termasuk ResNet, VGG dan EfficientNet.

import torch
import torch.nn as nn

# Standard CNN block: Conv -> BN -> ReLU
conv_block = nn.Sequential(
    nn.Conv2d(3, 64, kernel_size=3, padding=1),
    nn.BatchNorm2d(64),    # 64 = number of output channels
    nn.ReLU(inplace=True)
)

# Input: batch of 8 RGB images, 32x32 pixels
x = torch.randn(8, 3, 32, 32)
out = conv_block(x)
print(out.shape)   # torch.Size([8, 64, 32, 32])

Layer Norm berbanding Batch Norm

Normalisasi Lapisan (digunakan dalam Transformer) menormalkan merentasi ciri dalam satu sampel, bukannya merentasi kelompok. Hal ini menjadikannya tidak bergantung pada saiz kelompok, yang penting untuk jujukan dengan panjang berubah-ubah dan kelompok kecil. Batch Norm menormalkan merentasi kelompok bagi setiap ciri — sesuai untuk CNN dan latihan dengan kelompok besar. Pilihan yang salah boleh menjejaskan prestasi: menggunakan Batch Norm dalam Transformer atau Layer Norm dalam CNN ialah kesilapan seni bina yang biasa.

import torch
import torch.nn as nn

x = torch.randn(4, 8)  # batch=4, features=8

# Batch Norm: normalise across batch for each feature
bn = nn.BatchNorm1d(8)
bn_out = bn(x)   # statistics computed over 4 samples

# Layer Norm: normalise across features for each sample
ln = nn.LayerNorm(8)
ln_out = ln(x)   # statistics computed over 8 features

print('BN output shape:', bn_out.shape)   # (4, 8)
print('LN output shape:', ln_out.shape)   # (4, 8)
# Same shape, different normalisation axes

Membekukan Batch Norm Semasa Penalaan Halus

Apabila menala halus model pralatih pada set data kecil, statistik bergerak dalam lapisan Batch Norm dianggarkan menggunakan set data asal yang besar. Membiarkan statistik tersebut dikemas kini berdasarkan kelompok penalaan halus yang kecil boleh merosakkannya dan menjejaskan prestasi. Strategi yang biasa digunakan ialah membekukan lapisan Batch Norm dengan menetapkannya secara kekal dalam mod penilaian. Dalam PyTorch, hal ini dilakukan dengan memanggil model.apply bersama fungsi tersuai yang membekukan setiap lapisan BN.

import torch.nn as nn

def freeze_bn(module):
    '''Keep BN in eval mode during fine-tuning.'''
    if isinstance(module, (nn.BatchNorm1d,
                           nn.BatchNorm2d,
                           nn.BatchNorm3d)):
        module.eval()  # use running stats, not batch stats
        module.weight.requires_grad_(False)
        module.bias.requires_grad_(False)

model = nn.Sequential(
    nn.Linear(4, 8),
    nn.BatchNorm1d(8),
    nn.ReLU()
)
model.apply(freeze_bn)
print('BN frozen for fine-tuning')

Batasan Batch Norm dan Alternatifnya

Batch Norm mempunyai beberapa batasan yang diketahui: ia memerlukan saiz kelompok minimum (biasanya 16 atau lebih) untuk mendapatkan statistik yang boleh dipercayai; ia tidak berkesan atau boleh memudaratkan pada kelompok yang sangat kecil; dan ia memperkenalkan kebergantungan data antara sampel dalam satu kelompok, lalu merumitkan pemprosesan selari. Alternatifnya termasuk Group Norm (membahagikan saluran kepada beberapa kumpulan), Instance Norm (menormalkan bagi setiap sampel dan saluran, digunakan dalam pemindahan gaya), serta Layer Norm (digunakan dalam Transformer). Pemilihan normalisasi yang tepat bergantung pada seni bina.

import torch
import torch.nn as nn

x = torch.randn(4, 16, 10)  # (batch, channels, seq_len)

# GroupNorm: 4 groups of 4 channels each
gn = nn.GroupNorm(num_groups=4, num_channels=16)
print('GroupNorm:', gn(x).shape)

# InstanceNorm: normalise each sample+channel independently
ins = nn.InstanceNorm1d(16)
print('InstanceNorm:', ins(x).shape)

# LayerNorm: normalise across last N dimensions
ln = nn.LayerNorm([16, 10])
print('LayerNorm:', ln(x).shape)

Semakan Ringkas

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

Jawab dalam pelajaran interaktif

Imbas Kembali Pelajaran

Dalam pelajaran ini, anda telah mempelajari bahawa Normalisasi Kelompok menormalkan input lapisan dalam setiap kelompok mini untuk menstabilkan dan mempercepatkan latihan, nn.BatchNorm1d dan nn.BatchNorm2d digunakan masing-masing dalam lapisan bersambung penuh dan lapisan konvolusi, serta model.eval() menukar BN supaya menggunakan statistik bergerak yang dikumpulkan semasa latihan bagi menghasilkan inferens tentu. Seterusnya, kita akan menambahkan pengawalan selia Dropout untuk mengelakkan terlebih suaian.

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 “Normalisasi Kelompok: Latihan Stabil dan Lebih Pantas” percuma?

Ya — teks penuh “Normalisasi Kelompok: Latihan Stabil dan Lebih Pantas” 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 “Normalisasi Kelompok: Latihan Stabil dan Lebih Pantas”?

Pelajar akan menyisipkan nn.BatchNorm1d antara lapisan, memerhatikan penumpuan yang lebih pantas pada rangkaian dalam, dan memahami cara BatchNorm menormalkan pengaktifan dalam setiap kelompok mini. 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 2 daripada 4.

Berapa lamakah pelajaran “Normalisasi Kelompok: Latihan Stabil dan Lebih Pantas” 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