AI & Machine Learning

Batch Normalization và Layer Normalization: Nguyên lý và So sánh Chi tiết

Batch Normalization và Layer Normalization là hai kỹ thuật chuẩn hóa tầng mạng cách mạng trong học sâu, giúp ổn định phân phối tín hiệu ẩn, triệt tiêu bùng nổ gradient và cho phép huấn luyện mô hình sâu với tốc độ học cao.

Ý chính
  • Khắc phục Internal Covariate Shift: Giữ cho phân phối tín hiệu đầu vào qua từng tầng ổn định với trung bình bằng 0 và phương sai bằng 1.
  • Batch Normalization (BatchNorm): Chuẩn hóa qua toàn bộ các mẫu trong một mini-batch theo từng kênh đặc trưng, là lựa chọn số 1 cho các mạng thị giác máy tính CNN.
  • Layer Normalization (LayerNorm): Chuẩn hóa độc lập trên từng mẫu dữ liệu qua toàn bộ các kênh đặc trưng, không phụ thuộc vào kích thước batch, là chuẩn mực cho Transformer và NLP.
  • Tham số tự học \(\gamma\) và \(\beta\): Khôi phục khả năng biểu diễn của mạng bằng hai tham số tỉ lệ (Scale) và dịch chuyển (Shift) tối ưu hóa qua lan truyền ngược.

Trong những năm đầu của kỷ nguyên Deep Learning, việc huấn luyện một mạng nơ-ron có trên 15 tầng là một thử thách toán học vô cùng cam go. Các kỹ sư phải mất hàng tuần căn chỉnh tỉ mỉ từng bước khởi tạo trọng số và tốc độ học siêu nhỏ để ngăn mô hình bị nổ gradient. Tất cả đã thay đổi hoàn toàn vào năm 2015 khi Sergey Ioffe và Christian Szegedy (Google) giới thiệu kỹ thuật Batch Normalization (BatchNorm), mở đường cho sự bùng nổ của ResNet với độ sâu hàng trăm tầng. Sau đó, Layer Normalization (LayerNorm) ra đời và trở thành thành phần cốt lõi không thể thay thế trong các kiến trúc Transformer và mô hình ngôn ngữ lớn (LLM).

Batch Norm vs Layer Norm Hai hướng chuẩn hóa tensor giúp ổn định và tăng tốc huấn luyện mạng sâu Batch Normalization (BN) Batch Chuẩn hóa theo CỘT Qua toàn bộ mini-batch Phù hợp: Mạng CNN Phụ thuộc kích cỡ batch Layer Normalization (LN) Feature Chuẩn hóa theo HÀNG Trong từng mẫu độc lập Phù hợp: Transformer, RNN Không phụ thuộc batch Đưa giá trị về mean = 0, std = 1 kèm hai hệ số học gamma và beta
Batch Norm vs Layer Norm 1. Batch Normalization: Chuẩn hóa theo cột qua mini-batch Rất hiệu quả cho thị giác máy CNN Cần batch đủ lớn để ước lượng tốt 2. Layer Normalization: Chuẩn hóa theo hàng từng mẫu riêng Tiêu chuẩn trong Transformer & LLM Hoạt động ổn định cả với batch size = 1
Hình 1. So sánh chiều không gian chuẩn hóa giữa Batch Normalization và Layer Normalization.

1. Vấn đề gốc rễ: Hiện tượng Dịch chuyển Phân phối Nội bộ (Internal Covariate Shift)

Khi dữ liệu truyền qua từng tầng của một mạng nơ-ron sâu:

  • Ở tầng thứ \(k\), đầu ra \(a_k\) phụ thuộc vào trọng số của tất cả các tầng trước đó \(W_1, W_2, \dots, W_{k-1}\).
  • Trong mỗi bước cập nhật Gradient Descent, tất cả các trọng số \(W_1, \dots, W_k\) đều đồng thời thay đổi giá trị.
  • Kết quả là phân phối xác suất của tín hiệu đầu vào tầng \(k\) liên tục bị dịch chuyển, biến động không ngừng qua từng epoch huấn luyện. Tầng sau luôn phải "rượt đuổi" thích nghi với một phân phối đầu vào hoàn toàn mới từ tầng trước. Hiện tượng này được gọi là Internal Covariate Shift.

Hậu quả là:

  • Kỹ sư bắt buộc phải dùng tốc độ học cực nhỏ (\(\alpha \le 10^{-4}\)) để trọng số thay đổi rất chậm, khiến quá trình huấn luyện kéo dài lê thê.
  • Tín hiệu kích hoạt dễ bị trôi dạt vào các vùng bão hòa của hàm Sigmoid hay Tanh, gây triệt tiêu gradient nghiêm trọng.

2. Batch Normalization (BatchNorm): Chuẩn hóa dọc theo Mini-Batch

Ý tưởng của Batch Normalization rất tự nhiên: Thay vì chỉ chuẩn hóa dữ liệu đầu vào của toàn mạng (bằng StandardScaler), tại sao chúng ta không chuẩn hóa đầu vào của mọi tầng nơ-ron ẩn ngay trong từng mini-batch?

Xét một mini-batch gồm \(N\) mẫu, mỗi mẫu có \(D\) đặc trưng: \(\mathcal{B} = \{\mathbf{x}_1, \dots, \mathbf{x}_N\}\). Với mỗi chiều đặc trưng thứ \(j \in \{1, \dots, D\}\), BatchNorm thực hiện 4 bước:

  1. Tính giá trị trung bình trên toàn bộ mini-batch: \[\mu_j = \frac{1}{N} \sum_{i=1}^N x_{i,j}\]
  2. Tính phương sai trên mini-batch: \[\sigma_j^2 = \frac{1}{N} \sum_{i=1}^N (x_{i,j} - \mu_j)^2\]
  3. Chuẩn hóa giá trị về mean = 0, std = 1 (với \(\epsilon = 10^{-5}\) chống chia cho 0): \[\hat{x}_{i,j} = \frac{x_{i,j} - \mu_j}{\sqrt{\sigma_j^2 + \epsilon}}\]
  4. Phục hồi năng lực biểu diễn với Scale (\(\gamma\)) và Shift (\(\beta\)): Nếu ép buộc mọi tầng luôn có trung bình bằng 0 và phương sai bằng 1, mạng sẽ mất đi khả năng tạo ra các giá trị kích hoạt nằm ngoài khoảng tuyến tính (ví dụ như Sigmoid sẽ bị bó hẹp quanh vùng thẳng gần 0). Vì vậy, BatchNorm đưa vào 2 tham số tự học \(\gamma_j\) và \(\beta_j\): \[y_{i,j} = \gamma_j \hat{x}_{i,j} + \beta_j\] Nếu mạng cảm thấy phân phối gốc tốt hơn, thuật toán tối ưu có thể tự động học lại \(\gamma_j = \sigma_j\) và \(\beta_j = \mu_j\) để đảo ngược hoàn toàn phép chuẩn hóa!

BatchNorm trong quá trình Inference (Suy luận)

Khi chạy thực tế trên sản phẩm, mô hình chỉ nhận 1 mẫu đơn lẻ (\(N = 1\)), không thể tính mean và variance theo batch. Trong lúc huấn luyện, BatchNorm âm thầm tính toán trung bình động tích lũy (Running Mean và Running Variance): \[\mu_{\text{running}} = (1 - m) \cdot \mu_{\text{running}} + m \cdot \mu_{\text{batch}}\] Khi dự đoán suy luận, mô hình sử dụng các hằng số tích lũy này để chuẩn hóa mẫu đơn một cách ổn định tuyệt đối.

3. Layer Normalization (LayerNorm): Chuẩn hóa ngang theo từng Mẫu độc lập

Mặc dù BatchNorm cực kỳ thành công trên mạng CNN, nó lại bộc lộ những điểm yếu chí mạng khi áp dụng cho dữ liệu văn bản và mô hình ngôn ngữ:

  • Phụ thuộc vào Batch Size: Khi batch size nhỏ (\(N = 2\) hoặc \(4\)), thống kê \(\mu, \sigma\) của batch bị nhiễu rất nặng, làm giảm sút độ chính xác của mô hình.
  • Bất lực trước dữ liệu chuỗi có độ dài thay đổi: Mỗi câu văn có số lượng từ khác nhau, việc tính mean dọc theo các câu văn tại từng vị trí từ trở nên vô cùng gượng ép và phức tạp.

Năm 2016, Jimmy Lei Ba, Jamie Ryan Kiros và Geoffrey Hinton đã phát minh ra Layer Normalization (LayerNorm): Thay vì tính trung bình dọc theo chiều Batch \(N\), LayerNorm tính toán giá trị trung bình \(\mu\) và phương sai \(\sigma^2\) ngang qua toàn bộ các đặc trưng \(D\) của chính mẫu đó:

Với mẫu dữ liệu thứ \(i\): \[\mu_i = \frac{1}{D} \sum_{j=1}^D x_{i,j}\] \[\sigma_i^2 = \frac{1}{D} \sum_{j=1}^D (x_{i,j} - \mu_i)^2\] \[\tilde{x}_{i,j} = \frac{x_{i,j} - \mu_i}{\sqrt{\sigma_i^2 + \epsilon}}\] \[y_{i,j} = \gamma_j \tilde{x}_{i,j} + \beta_j\]

Điểm đột phá của LayerNorm

  1. Hoàn toàn độc lập với Batch Size: Quá trình tính toán trên mỗi mẫu được tách biệt độc lập \(100\%\). Kể cả khi batch size bằng 1, LayerNorm vẫn tính toán mượt mà và chính xác.
  2. Hành vi thống nhất giữa Train và Test: LayerNorm không cần duy trì biến trung bình động running_mean, công thức áp dụng trong lúc huấn luyện và khi suy luận thực tế là hoàn toàn giống nhau!
  3. Chuẩn mực của Transformer: Trong các khối Multi-Head Attention và Feed-Forward Network của Transformer, LayerNorm có mặt ở mọi lớp: Transformer gốc và BERT đặt nó sau phép cộng phần dư (Post-LN), còn GPT-2 và LLaMA chuẩn hóa đầu vào của mỗi phân lớp (Pre-LN; LLaMA dùng RMSNorm) để huấn luyện ổn định hơn.

4. Ví dụ chạy tay so sánh BatchNorm và LayerNorm

Xét một mini-batch gồm \(N = 3\) mẫu, mỗi mẫu có \(D = 4\) đặc trưng: \[\mathbf{X} = \begin{bmatrix} 1.0 & 2.0 & 3.0 & 4.0 \\ 2.0 & 3.0 & 5.0 & 7.0 \\ 10.0 & 20.0 & 30.0 & 40.0 \end{bmatrix}\]

Giả sử \(\gamma = 1.0, \beta = 0.0, \epsilon = 10^{-5}\).

Tính toán Batch Normalization (Theo từng Cột)

  • Cột 1 (\(j=0\)): \(\{1.0, 2.0, 10.0\}\)

    • \(\mu_0 = \frac{1 + 2 + 10}{3} = \frac{13}{3} \approx 4.3333\).
    • \(\sigma_0^2 = \frac{(1-4.3333)^2 + (2-4.3333)^2 + (10-4.3333)^2}{3} = \frac{11.111 + 5.444 + 32.111}{3} \approx 16.2222 \implies \sigma_0 \approx 4.0277\).
    • Giá trị mẫu 1 sau BN: \(\frac{1.0 - 4.3333}{4.0277} \approx -0.8276\).
  • Cột 2 (\(j=1\)): \(\{2.0, 3.0, 20.0\}\)

    • \(\mu_1 = \frac{2 + 3 + 20}{3} = \frac{25}{3} \approx 8.3333\).
    • \(\sigma_1^2 = \frac{(2-8.3333)^2 + (3-8.3333)^2 + (20-8.3333)^2}{3} = \frac{40.111 + 28.444 + 136.111}{3} \approx 68.2222 \implies \sigma_1 \approx 8.2597\).
    • Giá trị mẫu 1 sau BN: \(\frac{2.0 - 8.3333}{8.2597} \approx -0.7668\).

Tính toán Layer Normalization (Theo từng Dòng)

  • Xét Mẫu 1 (\(i=0\)): Hàng gồm 4 phần tử \(\{1.0, 2.0, 3.0, 4.0\}\)
    • \(\mu_{\text{row}} = \frac{1.0 + 2.0 + 3.0 + 4.0}{4} = \frac{10.0}{4} = 2.5000\).
    • \(\sigma_{\text{row}}^2 = \frac{(1-2.5)^2 + (2-2.5)^2 + (3-2.5)^2 + (4-2.5)^2}{4} = \frac{2.25 + 0.25 + 0.25 + 2.25}{4} = \frac{5.0}{4} = 1.2500\).
    • \(\sigma_{\text{row}} = \sqrt{1.25} \approx 1.1180\).
    • Chuẩn hóa từng phần tử của Mẫu 1:
      • \(\tilde{x}_{0,0} = \frac{1.0 - 2.5}{1.1180} \approx -1.3416\).
      • \(\tilde{x}_{0,1} = \frac{2.0 - 2.5}{1.1180} \approx -0.4472\).
      • \(\tilde{x}_{0,2} = \frac{3.0 - 2.5}{1.1180} \approx 0.4472\).
      • \(\tilde{x}_{0,3} = \frac{4.0 - 2.5}{1.1180} \approx 1.3416\).

Bảng tính cho thấy sự khác biệt trực quan: BatchNorm so sánh mẫu 1 với các mẫu khác trong batch, còn LayerNorm chỉ tự cân bằng các đặc trưng nội tại bên trong mẫu 1!

Học cùng giảng viên

Chủ đề này nằm trong Lecture 14 - Neural Networks của Khóa AI. Xem đề cương

5. Cài đặt BatchNorm và LayerNorm bằng Python và C++

import math

def norm_forward(X, eps=1e-5):
    # X: N x D
    N = len(X)
    D = len(X[0])
    
    # 1. Batch Normalization: normalize across batch dimension (columns)
    bn_out = [[0.0] * D for _ in range(N)]
    for j in range(D):
        col = [X[i][j] for i in range(N)]
        mu_b = sum(col) / N
        var_b = sum((x - mu_b) ** 2 for x in col) / N
        std_b = math.sqrt(var_b + eps)
        for i in range(N):
            bn_out[i][j] = (X[i][j] - mu_b) / std_b
            
    # 2. Layer Normalization: normalize across feature dimension (rows)
    ln_out = [[0.0] * D for _ in range(N)]
    for i in range(N):
        row = X[i]
        mu_l = sum(row) / D
        var_l = sum((x - mu_l) ** 2 for x in row) / D
        std_l = math.sqrt(var_l + eps)
        for j in range(D):
            ln_out[i][j] = (X[i][j] - mu_l) / std_l
            
    # Flatten BN[0] and LN[0] for verification
    res = [round(x, 4) for x in bn_out[0]] + [round(x, 4) for x in ln_out[0]]
    return res

def solve(case):
    return norm_forward(case)

6. Các biến thể chuẩn hóa chuyên biệt khác

Ngoài BatchNorm và LayerNorm, cộng đồng Deep Learning đã phát triển thêm hai biến thể quan trọng cho các bài toán đặc thù:

  1. Instance Normalization (InstanceNorm): Chuẩn hóa độc lập cho từng kênh (Channel) của từng mẫu ảnh đơn lẻ, không phụ thuộc vào cả batch và các kênh khác. Rất nổi tiếng trong các bài toán chuyển đổi phong cách hình ảnh (Style Transfer, GANs).
  2. Group Normalization (GroupNorm): Chia các kênh đặc trưng thành \(G\) nhóm nhỏ và chuẩn hóa bên trong từng nhóm. GroupNorm giải quyết bài toán thị giác máy tính với batch size siêu nhỏ (\(N = 1\) hoặc \(2\) khi huấn luyện phát hiện vật thể độ phân giải cao).
  3. RMSNorm (Root Mean Square Normalization): Biến thể tối giản của LayerNorm được áp dụng trong LLaMA và Mistral: bỏ qua bước trừ giá trị trung bình \(\mu\), chỉ chia cho căn bậc hai của bình phương trung bình \(\sqrt{\frac{1}{D}\sum x^2 + \epsilon}\). Bài báo gốc (Zhang và Sennrich, 2019) đo được thời gian chạy giảm 7%–64% tùy mô hình, với chất lượng tương đương LayerNorm.

7. Bảng so sánh toàn diện BatchNorm và LayerNorm

Tiêu chí kỹ thuật Batch Normalization (BatchNorm) Layer Normalization (LayerNorm)
Chiều chuẩn hóa Dọc theo chiều Batch \(N\) cho từng đặc trưng Ngang qua chiều Đặc trưng \(D\) cho từng mẫu
Phụ thuộc Batch Size Phụ thuộc rất nặng, cần batch size lớn Hoàn toàn độc lập, hoạt động tốt cả với \(N = 1\)
Hành vi khi Suy luận Phải dùng biến tích lũy running_mean/var Hoàn toàn đồng nhất với lúc huấn luyện
Hiệu ứng phụ Hoạt động như Regularization nhẹ (giảm Dropout) Không có hiệu ứng điều chuẩn ngẫu nhiên
Kiến trúc áp dụng tối ưu Mạng tích chập CNN (ResNet) Mạng chuỗi RNN, Transformer, LLMs và CNN mới như ConvNeXt

8. Câu hỏi thường gặp

Tại sao BatchNorm nên đặt trước hàm kích hoạt ReLU?

Trong bài báo gốc của Ioffe và Szegedy, BatchNorm được khuyến nghị đặt ngay sau phép biến đổi tuyến tính \(\mathbf{z} = \mathbf{W}\mathbf{x} + \mathbf{b}\) và ngay trước hàm kích hoạt phi tuyến: \(\mathbf{a} = \text{ReLU}(\text{BN}(\mathbf{z}))\). Lý do là phân phối của \(\mathbf{z}\) trước kích hoạt thường đối xứng hình chuông hơn, giúp phép chuẩn hóa Z-score đạt hiệu quả cao nhất và ngăn chặn hiện tượng bão hòa hoặc chết nơ-ron trước khi đi vào hàm phi tuyến.

Khi sử dụng BatchNorm, vì sao vector bias \(\mathbf{b}\) của lớp trước có thể bỏ qua?

Bởi vì bước đầu tiên của BatchNorm là trừ đi giá trị trung bình của batch: \(x_{i} - \mu\). Nếu lớp tuyến tính trước đó có cộng thêm hằng số bias \(b\), hằng số này sẽ xuất hiện ở cả \(x_i\) và trong giá trị trung bình \(\mu\), do đó phép trừ \((x_i + b) - (\mu + b) = x_i - \mu\) sẽ triệt tiêu bias hoàn toàn! Thay vào đó, tham số dịch chuyển \(\beta\) của chính lớp BatchNorm sẽ đảm nhiệm vai trò của bias.

9. Bốn Biến thể Chuẩn hóa Không gian: BatchNorm, LayerNorm, InstanceNorm và GroupNorm

Trong tài liệu nghiên cứu kinh điển về Group Normalization xuất bản năm 2018, hai tác giả Yuxin Wu và Kaiming He đã khái quát hóa toàn bộ các kỹ thuật chuẩn hóa trong thị giác máy tính dưới dạng các phép cắt lát tensor 4 chiều có kích thước Batch, Channel, Height và Width:

Thứ nhất là Batch Normalization: Cắt lát dọc theo chiều Channel. Kỹ thuật này tính toán giá trị trung bình và phương sai trên toàn bộ các mẫu dữ liệu trong mini-batch và trên toàn bộ các điểm ảnh không gian cho từng kênh đặc trưng độc lập. Đây là sự lựa chọn số một cho các mô hình mạng nơ-ron tích chập CNN khi kích thước batch đủ lớn từ 32 mẫu trở lên.

Thứ hai là Layer Normalization: Cắt lát ngang theo chiều từng mẫu dữ liệu. Kỹ thuật này chuẩn hóa trên toàn bộ các kênh đặc trưng và điểm ảnh cho mỗi bức ảnh hoặc mỗi vector từ ngữ riêng biệt. Vì không có sự phụ thuộc chéo giữa các mẫu dữ liệu khác nhau trong batch, LayerNorm vận hành ổn định tuyệt đối trong các bài toán xử lý chuỗi và mô hình ngôn ngữ Transformer.

Thứ ba là Instance Normalization: Chuẩn hóa độc lập cho từng kênh đặc trưng trên từng mẫu ảnh riêng biệt. Kỹ thuật này được thiết kế chuyên biệt cho các bài toán chuyển đổi phong cách hội họa (Style Transfer) và các mô hình tạo ảnh GAN, nơi mà sự tương phản về màu sắc và ánh sáng của từng bức ảnh cần được loại bỏ để tập trung học nội dung hình học trừu tượng.

Thứ tư là Group Normalization: Giải pháp hoàn hảo dung hòa giữa LayerNorm và InstanceNorm. Kỹ thuật này chia các kênh đặc trưng thành các nhóm nhỏ (thường là 32 nhóm) và thực hiện chuẩn hóa nội bộ trong từng nhóm cho mỗi mẫu ảnh. GroupNorm giải quyết triệt để sự suy giảm hiệu năng của BatchNorm trong các bài toán phát hiện vật thể và phân đoạn ảnh độ phân giải cao, nơi mà do giới hạn bộ nhớ GPU của máy tính, kỹ sư chỉ có thể huấn luyện với kích thước batch siêu nhỏ gồm 1 hoặc 2 bức ảnh.

10. Sự Khác biệt Sống còn giữa Chế độ Huấn luyện và Suy diễn trong BatchNorm

Một cạm bẫy kỹ thuật nguy hiểm bậc nhất khiến nhiều kỹ sư AI gặp thất bại khó hiểu khi triển khai mô hình vào thực tế liên quan đến cơ chế hoạt động kép của Batch Normalization:

Trong pha huấn luyện (Training Mode): Giá trị trung bình và phương sai được tính toán trực tiếp từ mini-batch hiện tại để chuẩn hóa tín hiệu. Đồng thời, mô hình liên tục cập nhật hai biến thống kê toàn cục tích lũy là Running Mean và Running Variance thông qua cơ chế trung bình trượt có trọng số với hệ số động lượng Momentum (mặc định là 0.1 trong PyTorch).

Trong pha suy diễn (Inference Mode): Khi đưa mô hình vào phục vụ người dùng thực tế, hệ thống thường chỉ tiếp nhận một mẫu dữ liệu đơn lẻ tại một thời điểm (kích thước batch bằng 1). Tại thời điểm này, khái niệm phương sai của batch hoàn toàn không tồn tại (phương sai của một điểm bằng 0). Nếu tiếp tục dùng công thức của pha huấn luyện thì nhờ có \(\epsilon\) nên không chia cho 0, nhưng \(x - \mu = 0\) nên mọi giá trị sau chuẩn hóa đều bằng 0 và dự đoán trở nên vô nghĩa. Thay vào đó, BatchNorm bắt buộc phải đóng băng và sử dụng cố định hai giá trị thống kê Running Mean và Running Variance đã tích lũy trong suốt quá trình huấn luyện để chuẩn hóa dữ liệu mới.

Nếu lập trình viên vô tình quên gọi hàm chuyển đổi chế độ suy diễn trước khi dự đoán dữ liệu kiểm thử, BatchNorm vẫn sẽ tự động tính toán thống kê trên tập kiểm thử, dẫn đến hiện tượng rò rỉ dữ liệu hoặc làm sai lệch hoàn toàn kết quả đánh giá mô hình.

Muốn học bài bản cùng giảng viên?

Khóa AI – Introduction to Machine Learning: nền tảng Máy học từ thuật toán cơ bản đến Neural Networks và LLM, học bằng Python. Học thử buổi 1 miễn phí.

Xem Khóa AI

Nguồn tham khảo

Chia sẻ: Facebook LinkedIn
Nhắn Zalo tư vấnZalo Gọi 0937 401 483