Dự đoán
Khi phân phối đầu vào của mỗi lớp thay đổi liên tục (internal covariate shift), mạng phải liên tục thích nghi lại thay vì học điều mới. BN giải quyết bằng cách chuẩn hoá tại mỗi lớp, đồng thời giảm nhẹ vấn đề vanishing và exploding gradient.
Evaluating routing across providers.
AI Builder
Kỹ thuật chuẩn hóa đầu vào mỗi lớp theo thống kê mini-batch để ổn định gradient, tăng tốc hội tụ, và giảm internal covariate shift.
Khi phân phối đầu vào của mỗi lớp thay đổi liên tục (internal covariate shift), mạng phải liên tục thích nghi lại thay vì học điều mới. BN giải quyết bằng cách chuẩn hoá tại mỗi lớp, đồng thời giảm nhẹ vấn đề vanishing và exploding gradient.
BN gồm ba bước: (1) tính μ và σ² của batch, (2) chuẩn hoá về (0, 1), (3) scale bằng γ rồi shift bằng β. Hai tham số γ và β được học.
| Bước | Việc làm | Ghi chú |
|---|---|---|
| 1. Thống kê batch | Tính μ và σ² của mini-batch | Ước lượng ồn khi batch nhỏ |
| 2. Chuẩn hoá | Trừ μ, chia căn (σ² + ε) | Đưa về (0, 1) |
| 3. Scale và shift | Nhân γ, cộng β | Hai tham số học được, cho phép mạng tự chọn mức chuẩn hoá |
Batch quá nhỏ làm ước lượng μ và σ² quá ồn, và BN có thể phản tác dụng.
| Batch size | Nhận xét |
|---|---|
| 2 | μ và σ² ước lượng từ 2 mẫu rất ồn. BN có thể làm training diverge. Dùng GroupNorm thay thế. |
| 32 | Sweet spot cho hầu hết CNN: đủ mẫu để μ và σ² ổn định, vẫn đủ nhiễu để regularization. |
| 128 | Thống kê rất ổn định. Với GPU lớn là lựa chọn tốt, nhưng ít regularization hơn. |
So sánh loss trên cùng một kiến trúc: BN giúp hội tụ nhanh hơn và loss mượt hơn. Có BN thì có thể dùng learning rate cao hơn mà không diverge. Không có BN thì hội tụ chậm hơn, loss dao động mạnh hơn và nhạy cảm với khởi tạo.
Batch Normalization không chỉ là phép trừ trung bình rồi chia độ lệch — nó còn có γ và β học được. Nếu chuẩn hoá là tối ưu, mạng giữ γ = 1, β = 0. Nếu không, mạng có thể học γ = σ và β = μ để triệt tiêu BN. Nghĩa là BN không bao giờ hạn chế khả năng biểu diễn — nó chỉ mở thêm lựa chọn dễ học hơn.
Đó là lý do BN (và các biến thể LN, GN, IN) gần như luôn có mặt trong kiến trúc hiện đại: lợi ích rõ ràng, chi phí nhỏ, và không hy sinh khả năng biểu diễn.
Ý tưởng cốt lõi: trong mini-batch B = {x₁, …, xₘ}, tính thống kê của chính batch và dùng chúng để chuẩn hoá mỗi activation. Sau đó scale bằng γ và shift bằng β.
Khi gọi model.eval(), BN chuyển sang dùng μ_run và σ²_run.
import torch
import torch.nn as nn
class ConvBlock(nn.Module):
"""Conv2d -> BatchNorm2d -> ReLU: khối chuẩn của CNN hiện đại."""
def __init__(self, in_ch: int, out_ch: int, kernel_size: int = 3):
super().__init__()
self.conv = nn.Conv2d(
in_ch, out_ch, kernel_size,
padding=kernel_size // 2,
bias=False, # BN có beta => bias của conv thừa
)
# BatchNorm2d: tính thống kê trên (N, H, W) cho từng channel C.
# num_features = out_ch => có out_ch cặp (gamma, beta),
# (running_mean, running_var).
self.bn = nn.BatchNorm2d(
num_features=out_ch,
eps=1e-5,
momentum=0.1, # EMA cho running stats
affine=True, # bật gamma, beta học được
track_running_stats=True,
)
self.act = nn.ReLU(inplace=True)
def forward(self, x: torch.Tensor) -> torch.Tensor:
return self.act(self.bn(self.conv(x)))
# Ví dụ sử dụng
model = nn.Sequential(
ConvBlock(3, 64),
ConvBlock(64, 128),
nn.AdaptiveAvgPool2d(1),
nn.Flatten(),
nn.Linear(128, 10),
)
# Training mode: BN dùng batch stats và update running stats.
model.train()
x = torch.randn(32, 3, 32, 32) # batch 32, giống CIFAR
out = model(x)
print("train output:", out.shape)
# Inference: BN dùng running_mean, running_var.
model.eval()
with torch.no_grad():
single = torch.randn(1, 3, 32, 32)
pred = model(single)
print("eval output:", pred.shape)
# Freeze BN (khi fine-tune)
for m in model.modules():
if isinstance(m, nn.BatchNorm2d):
m.eval() # đóng băng running stats
for p in m.parameters():
p.requires_grad = FalsePhiên bản viết tay để hiểu bên trong:
class MyBatchNorm2d(nn.Module):
"""Viết tay BatchNorm2d để hiểu kĩ bên trong."""
def __init__(self, num_features: int, momentum: float = 0.1,
eps: float = 1e-5):
super().__init__()
self.num_features = num_features
self.momentum = momentum
self.eps = eps
# Học được
self.gamma = nn.Parameter(torch.ones(num_features))
self.beta = nn.Parameter(torch.zeros(num_features))
# Buffer: không học, nhưng lưu cùng state_dict
self.register_buffer("running_mean", torch.zeros(num_features))
self.register_buffer("running_var", torch.ones(num_features))
def forward(self, x: torch.Tensor) -> torch.Tensor:
# x shape: (N, C, H, W)
if self.training:
dims = (0, 2, 3)
mu = x.mean(dim=dims)
var = x.var(dim=dims, unbiased=False)
# update running stats
with torch.no_grad():
self.running_mean.mul_(1 - self.momentum).add_(
mu, alpha=self.momentum
)
self.running_var.mul_(1 - self.momentum).add_(
var, alpha=self.momentum
)
else:
mu = self.running_mean
var = self.running_var
x_hat = (x - mu[None, :, None, None]) / torch.sqrt(
var[None, :, None, None] + self.eps
)
return (
self.gamma[None, :, None, None] * x_hat
+ self.beta[None, :, None, None]
)Các biến thể khác nhau ở chỗ chọn chiều nào để tính μ và σ²:
| Biến thể | Tính qua | Dùng khi |
|---|---|---|
| BatchNorm | Batch N và không gian H, W cho mỗi channel C | CNN, batch đủ lớn |
| LayerNorm | Toàn bộ feature của từng mẫu; không phụ thuộc batch | Transformer, RNN |
| GroupNorm | Chia C thành G nhóm rồi chuẩn hoá trong mỗi nhóm | CNN với batch nhỏ |
| InstanceNorm | H, W cho mỗi (mẫu, channel) | Style transfer, generative |
Quy tắc ngón tay: CNN với batch lớn hơn 16 dùng BN; CNN với batch nhỏ dùng GN; RNN và Transformer dùng LN; generative và style transfer dùng IN.
Bài báo gốc (Ioffe và Szegedy, 2015) giải thích BN hiệu quả nhờ giảm internal covariate shift. Santurkar và cộng sự (2018, “How Does Batch Normalization Help Optimization?”) chỉ ra giả thuyết này có thể không phải lý do thật. Họ cho thấy BN làm mượt landscape của hàm loss: gradient ổn định hơn, dùng được learning rate lớn hơn và bước đi ít hỗn loạn.
Dù lý do chính thống là gì, hiệu quả thực nghiệm của BN vẫn rất rõ, và đó là điều các kỹ sư quan tâm.
Với momentum 0,1, sau vài epoch running stats đã hội tụ về gần thống kê thực tế của batch. Đây là con số BN dùng khi model.eval().