ONE is preparing: 01 / INITIALIZING MODEL ROUTER. Evaluating routing across providers.
Current state
01 / INITIALIZING MODEL ROUTER.

Evaluating routing across providers.

Start learning
← Kiến trúc

AI Builder

Chuẩn hóa theo lô

Vietnamese onlyThe learning content is available in Vietnamese only. The surrounding interface follows your language.

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.

lesson90 minKiến trúcAI Engineer

Dự đoán

Lớp 1 chấm thang 100, lớp 2 thang 10, lớp 3 dùng chữ A–F. Muốn so sánh điểm công bằng, bạn làm gì?

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.

Khám phá — ba bước của BN

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ướcViệc làmGhi chú
1. Thống kê batchTí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à shiftNhân γ, cộng βHai tham số học được, cho phép mạng tự chọn mức chuẩn hoá

Batch size quan trọng

Batch quá nhỏ làm ước lượng μ và σ² quá ồn, và BN có thể phản tác dụng.

Batch sizeNhậ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ế.
32Sweet spot cho hầu hết CNN: đủ mẫu để μ và σ² ổn định, vẫn đủ nhiễu để regularization.
128Thống kê rất ổn định. Với GPU lớn là lựa chọn tốt, nhưng ít regularization hơn.

Training có và không có BN

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.

Khoảnh khắc A-ha

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.

Thử thách nhanh

Bạn huấn luyện CNN với batch size 4 trên GPU nhỏ. Training bị diverge khi thêm BatchNorm2d. Lý do khả năng cao nhất là gì?
Tại inference bạn gửi từng ảnh một (batch = 1). Nếu BN dùng thống kê của batch lúc này, chuyện gì xảy ra?

Công thức và code

Ý 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 β.

μB=1m∑i=1mxi\mu_{\mathcal{B}} = \frac{1}{m} \sum_{i=1}^{m} x_i
σB2=1m∑i=1m(xi−μB)2\sigma^2_{\mathcal{B}} = \frac{1}{m} \sum_{i=1}^{m} (x_i - \mu_{\mathcal{B}})^2
x^i=xi−μBσB2+ε\hat{x}_i = \frac{x_i - \mu_{\mathcal{B}}}{\sqrt{\sigma^2_{\mathcal{B}} + \varepsilon}}
yi=γx^i+βy_i = \gamma \hat{x}_i + \beta
μrun←(1−ρ)μrun+ρ μB\mu_{\text{run}} \leftarrow (1 - \rho)\mu_{\text{run}} + \rho\,\mu_{\mathcal{B}}
σrun2←(1−ρ)σrun2+ρ σB2\sigma^2_{\text{run}} \leftarrow (1 - \rho)\sigma^2_{\text{run}} + \rho\,\sigma^2_{\mathcal{B}}

Khi gọi model.eval(), BN chuyển sang dùng μ_run và σ²_run.

pytorch_batchnorm2d.py

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 = False

Phiên bản viết tay để hiểu bên trong:

custom_batchnorm.py

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]
        )

So sánh BN, LayerNorm, GroupNorm và InstanceNorm

Các biến thể khác nhau ở chỗ chọn chiều nào để tính μ và σ²:

Biến thểTính quaDùng khi
BatchNormBatch N và không gian H, W cho mỗi channel CCNN, batch đủ lớn
LayerNormToàn bộ feature của từng mẫu; không phụ thuộc batchTransformer, RNN
GroupNormChia C thành G nhóm rồi chuẩn hoá trong mỗi nhómCNN với batch nhỏ
InstanceNormH, 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.

Tại sao “internal covariate shift” có thể không phải lý do thật?

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.

Running stats qua các epoch

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().

Tóm tắt

  • BN chuẩn hoá mỗi mini-batch về μ ≈ 0, σ ≈ 1 rồi scale bằng γ và shift bằng β học được.
  • Hiệu ứng: ổn định gradient, cho phép learning rate lớn hơn, hội tụ nhanh hơn, regularization nhẹ.
  • Khi inference BN dùng running mean và variance (EMA). Nhớ gọi model.eval() trước khi predict.
  • Batch quá nhỏ làm μ và σ² ồn, model dễ diverge. Chuyển sang GroupNorm hoặc tăng effective batch.
  • BN cho CNN; LayerNorm cho Transformer và RNN; GroupNorm cho batch nhỏ; InstanceNorm cho style transfer.
  • γ = σ và β = μ sẽ triệt tiêu BN — BN không hy sinh khả năng biểu diễn, chỉ mở thêm lựa chọn.

Continue the module

Lesson 10 of 12