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

Kết nối tắt

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

Đường tắt cho gradient đi qua, cho phép huấn luyện mạng rất sâu mà không bị gradient biến mất

lesson90 minKiến trúcAI Engineer

Dự đoán

Mạng 20 lớp đạt accuracy 90%. Bạn thêm thành mạng 56 lớp và kỳ vọng accuracy tăng. Kết quả thực tế trong thí nghiệm của He và cộng sự (2015) là gì?

Đây là hệ quả trực tiếp của vanishing gradient. Residual connection là giải pháp then chốt cho mạng rất sâu và là một trong những ý tưởng có ảnh hưởng lớn nhất trong lịch sử deep learning hiện đại.

Ẩn dụ — tin nhắn truyền miệng

Hãy tưởng tượng bạn gửi một tin nhắn bằng miệng qua 20 người. Qua mỗi người, tin bị méo thêm một chút. Đến người thứ 20, tin gốc đã biến thành “tam sao thất bản”.

Skip connection giống như gửi thêm một bản sao của tin gốc bằng giấy, đi thẳng tới người cuối cùng. Người cuối học cách sửa tin miệng bằng tin gốc, thay vì dựng lại toàn bộ nội dung từ đầu. Nhiệm vụ dễ hơn rất nhiều.

Trong deep learning, “truyền miệng” là các lớp trung gian học đặc trưng, còn “bản sao giấy” là chính input x đi qua đường skip. Mạng chỉ cần học phần dư F(x) = H(x) − x. Nếu không có gì cần thay đổi, F(x) chỉ cần bằng 0.

Khám phá — bật và tắt skip connection

Bật skip để thấy đường tắt x chạy song song với nhánh chính F(x) = Conv → BN → ReLU → Conv → BN, rồi cộng lại và qua ReLU cuối. Tắt skip để thấy mạng plain: gradient sẽ biến mất khi backprop.

Cấu hìnhTraining loss (depth 20)Gradient ở các lớp đầu
Không skip (plain)Dao động mạnh, có xu hướng tăng (diverge)Nhân với tích dF/dx nhỏ hơn 1 qua nhiều lớp → rất nhỏ
Có skip (residual)Giảm trơn xuống gần 0Đường tắt đóng góp thành phần 1 → gradient luôn có độ lớn ít nhất khoảng 1

Ví dụ tính: mỗi block có dF/dx khoảng 0,85, backprop về lớp đầu của mạng plain 20 lớp cho gradient khoảng 0,85²⁰ ≈ 0,039 — rất nhỏ, trọng số gần như không được cập nhật. Với skip, mỗi block giữ lại thành phần bằng 1 qua đường tắt.

Khoảnh khắc Aha

output = F(x) + x. Mạng không cần học toàn bộ ánh xạ H(x), chỉ cần học phần dư F(x) = H(x) − x. Nếu lớp tối ưu là identity, F(x) chỉ cần bằng 0 — dễ hơn nhiều so với học lại identity từ một đống Conv, BN và ReLU.

Gradient của x + F(x) theo x bằng 1 + dF/dx. Dù dF/dx nhỏ cỡ nào, gradient vẫn có thành phần bằng 1. Không vanishing. Mạng có thể sâu 100, 152, thậm chí 1000 lớp.

Thử thách

Residual connection là thành phần cốt lõi của Transformer, được dùng quanh cả attention và FFN.

Transformer có hai residual connection mỗi lớp. Chúng bao quanh gì?
Bạn có một mạng plain 56 lớp và một ResNet 56 lớp cùng số tham số, cùng optimizer và cùng learning rate. Training loss sau 100 epoch kỳ vọng là bao nhiêu?

Độ sâu và accuracy

Số liệu minh hoạ theo nguồn bài, không phải số liệu gốc của He và cộng sự (2015):

Số lớpKhông skipCó skip
890%92%
5672%97%
15240%97,8%

Giải thích chi tiết

Residual connection (He và cộng sự, 2015, “Deep Residual Learning for Image Recognition”) là cơ chế trong đó input của một khối được cộng trực tiếp vào output của khối qua một đường tắt. Thay vì buộc khối học ánh xạ H(x), ta cho khối học phần dư F(x) = H(x) − x. Công thức tổng quát của một residual block:

y=F(x,{Wi})+xy = F(x, \{W_i\}) + x

F là hàm residual do các trọng số W₁, W₂, … biểu diễn (thường là 2 hoặc 3 lớp Conv, BN và ReLU). Khi kích thước của x và F(x) khác nhau (đổi số kênh hoặc downsample bằng stride), dùng projection shortcut:

y=F(x,{Wi})+Ws xy = F(x, \{W_i\}) + W_s \, x

W_s là một lớp 1×1 convolution chỉ để đồng bộ kích thước. Gradient của loss theo input của block:

∂L∂x=∂L∂y⋅(1+∂F∂x)\frac{\partial \mathcal{L}}{\partial x} = \frac{\partial \mathcal{L}}{\partial y} \cdot \left( 1 + \frac{\partial F}{\partial x} \right)

Gradient luôn có thành phần 1 từ skip cộng với dF/dx. Tổng gradient qua N block xếp chồng là tích của (1 + dFᵢ/dx), không phải tích của dFᵢ/dx. Đó là lý do ResNet không bị vanishing gradient dù sâu bao nhiêu lớp.

residual_block.py

import torch
import torch.nn as nn
import torch.nn.functional as F

class BasicResidualBlock(nn.Module):
    """
    ResNet basic block: Conv → BN → ReLU → Conv → BN → (+input) → ReLU

    Nếu số kênh đầu vào và ra khác nhau hoặc stride > 1,
    dùng projection shortcut (1x1 conv) để khớp dimension.
    """

    expansion = 1

    def __init__(self, in_ch: int, out_ch: int, stride: int = 1):
        super().__init__()
        self.conv1 = nn.Conv2d(in_ch, out_ch, kernel_size=3,
                               stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(out_ch)
        self.conv2 = nn.Conv2d(out_ch, out_ch, kernel_size=3,
                               stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_ch)

        # Skip connection: identity nếu dimension khớp,
        # còn không thì dùng 1x1 conv (projection shortcut).
        if stride != 1 or in_ch != out_ch * self.expansion:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_ch, out_ch * self.expansion,
                          kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(out_ch * self.expansion),
            )
        else:
            self.shortcut = nn.Identity()

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        identity = self.shortcut(x)

        # Nhánh chính F(x): Conv → BN → ReLU → Conv → BN
        out = self.conv1(x)
        out = self.bn1(out)
        out = F.relu(out, inplace=True)
        out = self.conv2(out)
        out = self.bn2(out)

        # Cộng với skip TRƯỚC khi qua ReLU cuối
        out = out + identity
        out = F.relu(out, inplace=True)
        return out


# Ví dụ: xếp chồng 3 block tạo thành một stage của ResNet
layers = nn.Sequential(
    BasicResidualBlock(in_ch=64, out_ch=64),
    BasicResidualBlock(in_ch=64, out_ch=64),
    BasicResidualBlock(in_ch=64, out_ch=128, stride=2),  # downsample
)
x = torch.randn(8, 64, 56, 56)
y = layers(x)
print(y.shape)  # torch.Size([8, 128, 28, 28])

Vì sao identity mapping giữ gradient không biến mất

Trong bài báo tiếp theo, Identity Mappings in Deep Residual Networks (He và cộng sự, 2016), nếu skip path là identity thuần (không có BN, ReLU hay conv chặn ở giữa), thì với N block xếp chồng:

xL=xℓ+∑i=ℓL−1F(xi,Wi)x_L = x_{\ell} + \sum_{i=\ell}^{L-1} F(x_i, W_i)

Activation ở lớp sâu L là tổng của activation ở lớp nông ℓ cộng toàn bộ phần dư. Khi backprop, gradient theo x_ℓ là:

∂L∂xℓ=∂L∂xL(1+∂∂xℓ∑i=ℓL−1F)\frac{\partial \mathcal{L}}{\partial x_\ell} = \frac{\partial \mathcal{L}}{\partial x_L} \left( 1 + \frac{\partial}{\partial x_\ell} \sum_{i=\ell}^{L-1} F \right)

Thành phần 1 đảm bảo gradient luôn chảy ngược về lớp ℓ dù các F có gradient nhỏ. Đây là chứng minh lý thuyết cho việc ResNet huấn luyện được hơn 1000 lớp.

transformer_block_pre_norm.py

import torch
import torch.nn as nn

class PreNormTransformerBlock(nn.Module):
    """
    Một block Transformer kiểu Pre-Norm (GPT-2, LLaMA, Mistral).

    2 residual connections mỗi block:
      1) x = x + MultiHeadAttention(LayerNorm(x))
      2) x = x + FFN(LayerNorm(x))

    Gradient chảy thẳng qua 2 đường skip không bị LayerNorm chặn.
    """

    def __init__(self, d_model: int, n_heads: int, d_ff: int,
                 dropout: float = 0.1):
        super().__init__()
        self.norm1 = nn.LayerNorm(d_model)
        self.attn = nn.MultiheadAttention(
            d_model, n_heads, dropout=dropout, batch_first=True
        )
        self.norm2 = nn.LayerNorm(d_model)
        self.ffn = nn.Sequential(
            nn.Linear(d_model, d_ff),
            nn.GELU(),
            nn.Dropout(dropout),
            nn.Linear(d_ff, d_model),
        )
        self.drop = nn.Dropout(dropout)

    def forward(self, x: torch.Tensor,
                attn_mask: torch.Tensor | None = None) -> torch.Tensor:
        # Residual 1: quanh self-attention
        a = self.norm1(x)
        attn_out, _ = self.attn(a, a, a, attn_mask=attn_mask,
                                need_weights=False)
        x = x + self.drop(attn_out)

        # Residual 2: quanh FFN
        x = x + self.drop(self.ffn(self.norm2(x)))
        return x


# Xếp chồng 48 block như GPT-2 Medium
blocks = nn.Sequential(*[
    PreNormTransformerBlock(d_model=1024, n_heads=16, d_ff=4096)
    for _ in range(48)
])
x = torch.randn(2, 256, 1024)
y = blocks(x)
print(y.shape)  # torch.Size([2, 256, 1024])

Vì sao học phần dư dễ hơn học toàn bộ?

  • Nếu ánh xạ tối ưu H(x) gần identity, F(x) = H*(x) − x ≈ 0 — gần gốc toạ độ.
  • Hàm gần 0 có độ lớn nhỏ; SGD dễ hội tụ hơn vì khởi tạo ngẫu nhiên (trung bình 0) đã gần lời giải.
  • Để mạng plain học identity từ đầu, các trọng số phải phối hợp chính xác (Conv khử hiệu ứng BN, BN khử hiệu ứng ReLU…). Lời giải nằm trong một hẻm núi hẹp.
  • Li và cộng sự (2018) cho thấy ResNet có loss surface trơn hơn hẳn plain network cùng độ sâu: thung lũng rộng và ít local minima xấu.

Ứng dụng thực tế

  • Computer Vision: ResNet-50, 101, 152 là backbone chuẩn cho object detection (Faster R-CNN), segmentation (Mask R-CNN, DeepLab) và pose estimation. Hầu hết CNN từ 2016 trở đi đều có skip.
  • NLP và LLM: mọi Transformer (BERT, GPT, T5, LLaMA) đều có hai residual connection mỗi block. Theo nguồn bài, GPT-3 có 96 lớp và GPT-4 ước tính trên 120 lớp (số liệu GPT-4 không công bố chính thức, cần kiểm chứng).
  • Generative models: U-Net backbone của Stable Diffusion có skip từ encoder sang decoder ở mọi resolution. DDPM, Flow Matching và Rectified Flow đều dùng.
  • Reinforcement learning: AlphaGo, AlphaZero và MuZero dùng ResNet làm mạng policy và value.
  • Speech: Whisper và wav2vec 2.0 có skip connection trong cả bộ trích xuất đặc trưng convolution và Transformer encoder.

Những lỗi thường gặp

  • Đặt ReLU trước phép cộng: một số implementation làm vậy, cắt toàn bộ giá trị âm của F(x). Đặt ReLU sau phép cộng F(x) + x.
  • Không xử lý dimension mismatch: khi stride lớn hơn 1 hoặc đổi số kênh, quên projection shortcut sẽ lỗi shape. Luôn kiểm tra x.shape bằng F(x).shape trước khi cộng.
  • Khởi tạo F(x) quá lớn: nếu trọng số của F lớn, F(x) át hẳn x và skip mất tác dụng. Dùng zero-init cho lớp cuối của F hoặc gamma = 0 cho BN cuối.
  • BN hoặc dropout trên skip path: làm skip không còn là identity hoặc ngắt gradient ngẫu nhiên. Chỉ đặt chúng trong nhánh F(x).

Gần như mọi kiến trúc sâu hiện đại đều có skip connection ở một dạng nào đó. Khi thiết kế mạng trên 10 lớp, thêm skip gần như không bao giờ gây hại. Đây là một trong những lựa chọn mặc định an toàn nhất trong deep learning.

Tóm tắt

  • Công thức: output = F(x) + x. Mạng chỉ học phần dư F(x) = H(x) − x thay vì toàn bộ H(x).
  • Gradient = 1 + dF/dx → luôn có thành phần 1 → không vanishing, huấn luyện được mạng hơn 100 lớp.
  • Trường hợp xấu nhất: F(x) = 0 → output = x (identity). Thêm block không làm mạng tệ hơn.
  • Thứ tự chuẩn trong basic block: Conv → BN → ReLU → Conv → BN → cộng x → ReLU. ReLU cuối đặt sau phép cộng.
  • Khi kích thước không khớp, dùng projection shortcut (1×1 conv với stride phù hợp).
  • Skip connection có trong Transformer (hai mỗi block), U-Net, DenseNet, Diffusion U-Net và cả LSTM/GRU.

Continue the module

Lesson 8 of 12