Gradient Clipping: Cách ngăn chặn hiện tượng gradient bùng nổ

Bạn đã bao nhiêu lần thấy giá trị loss là NaN trong khi huấn luyện một mạng nơ-ron sâu?

Sau hàng giờ huấn luyện, đường cong loss trông ổn, rồi bất chợt vọt lên vô cực. Lý do thường là gradient bùng nổ - các giá trị gradient tăng quá lớn trong quá trình lan truyền ngược khiến cập nhật tham số trở nên không ổn định và mô hình hỏng. Vấn đề này ảnh hưởng nặng nhất tới các mạng hồi quy (recurrent), nhưng cũng xuất hiện ở transformers và các mạng feedforward sâu.

Gradient clipping khắc phục bằng cách giới hạn độ lớn của gradient trước khi chúng tới bộ tối ưu. Chỉ cần thêm một dòng vào vòng lặp huấn luyện để giữ các cập nhật trong giới hạn mà không cần thay đổi mô hình.

Trong bài viết này, tôi sẽ trình bày trực giác đằng sau gradient clipping, hai phương pháp chính, cách chọn ngưỡng, và cách triển khai trong PyTorch và TensorFlow.

Nhưng chính xác thì loss trong khoa học dữ liệu là gì? Hãy đọc Bài viết về Hàm Loss trong Machine Learning của chúng tôi để tìm hiểu.

Gradient Clipping là gì?

Gradient clipping là kỹ thuật giới hạn độ lớn của gradient trong quá trình huấn luyện để ngăn cập nhật tham số trở nên không ổn định.

Khi gradient quá lớn, bộ tối ưu sẽ bước một bước khổng lồ trong không gian tham số và đẩy trọng số vào vùng mà loss bùng nổ. Clipping giúp bạn bằng cách chặn kích thước bước đó trước khi nó gây hại.

Lưu ý quan trọng là gradient clipping không ảnh hưởng kiến trúc mô hình. Bạn không thêm tầng hay thay đổi hàm kích hoạt. Nó chỉ sửa quy trình huấn luyện bằng cách chặn gradient giữa lan truyền ngược và bước tối ưu.

Điều này khiến nó rẻ để thử và dễ bỏ. Như bạn sẽ thấy, chỉ cần một dòng mã.

Gradient Clipping hoạt động thế nào

Cơ chế rất đơn giản. Phép clipping được đặt giữa bước lan truyền ngược và bước tối ưu, và mỗi vòng lặp đều theo bốn bước giống nhau.

1. Tính gradient: Chạy lan truyền xuôi, tính loss, và chạy lan truyền ngược. Không có gì thay đổi ở đây, gradient chảy qua mạng như bình thường.
2. Kiểm tra độ lớn gradient: Đo xem gradient lớn đến mức nào. Tùy phương pháp, có thể xem từng giá trị riêng lẻ hoặc tính chuẩn tổng thể trên tất cả tham số.
3. Giảm gradient nếu vượt ngưỡng: Nếu độ lớn vượt giới hạn bạn đặt, hãy thu nhỏ gradient. Nếu không, giữ nguyên.
4. Cập nhật tham số mô hình: Truyền gradient đã clip cho bộ tối ưu và áp dụng cập nhật trọng số.

Hầu hết thời gian, gradient của bạn ở dưới ngưỡng và quá trình huấn luyện diễn ra như không có clipping. Khi có đột biến, clipping sẽ chặn trước khi bộ tối ưu phản ứng.

Vậy thôi.

Các phương pháp Gradient Clipping phổ biến

Có hai cách để clip gradient, khác nhau ở chỗ bạn đo lường và thu nhỏ cái gì.

Clip theo giá trị (clip by value)

Clip theo giá trị sẽ chặn riêng từng phần tử gradient.

Bạn chọn một khoảng, ví dụ [-1.0, 1.0], và mọi giá trị gradient ngoài khoảng đó sẽ được làm tròn về biên gần nhất. Gradient 2.5 thành 1.0. Gradient -2.5 thành -1.0. Các giá trị đã nằm trong khoảng thì giữ nguyên.

Ví dụ clip theo giá trị

Điểm hấp dẫn là sự đơn giản. Không có toán gì ngoài phép min/max, và chạy rất nhanh.

Nhưng cách này có nhược điểm. Việc clip từng giá trị thay đổi hướng của vector gradient. Nếu một thành phần bị clip còn các thành phần khác thì không, vector cập nhật không còn chỉ đúng hướng mà lan truyền ngược đã chỉ ra. Bộ tối ưu sẽ đi lệch một chút.

Đó là lý do clip theo giá trị ít được dùng hơn trong thực tế.

Clip theo chuẩn (clip by norm)

Clip theo chuẩn sẽ thu nhỏ toàn bộ vector gradient khi độ lớn tổng thể vượt ngưỡng.

Thay vì nhìn từng giá trị, nó tính chuẩn của tất cả gradient cùng nhau (thường là chuẩn L2) và so với một giá trị tối đa. Nếu chuẩn dưới ngưỡng, không làm gì. Nếu trên, mọi gradient sẽ được nhân với cùng một hệ số để đưa chuẩn về lại giới hạn.

Ví dụ clip theo chuẩn

Ưu điểm là giữ được hướng. Vì mọi thành phần đều co lại theo cùng một hệ số, vector gradient vẫn chỉ đúng hướng ban đầu. Bạn chỉ rút ngắn bước đi, không đổi hướng.

Đây là lý do clip theo chuẩn trở thành tiêu chuẩn. clip_grad_norm_ của PyTorch và clipnorm của TensorFlow đều triển khai phương pháp này, và hầu hết pipeline huấn luyện hiện đại dùng mặc định.

Gradient bùng nổ vs Gradient tiêu biến

Gradient bùng nổ và gradient tiêu biến đều là vấn đề phổ biến trong học sâu, nhưng gradient clipping chỉ giải quyết một trong số đó.

Gradient bùng nổ

Gradient bùng nổ xảy ra khi giá trị gradient tăng quá lớn trong quá trình lan truyền ngược.

Điều này thường xuất hiện ở các mạng sâu hoặc kiến trúc hồi quy, nơi gradient bị nhân qua nhiều tầng hoặc bước thời gian. Nếu các phép nhân đó cộng hưởng theo hướng xấu, độ lớn gradient sẽ phình to. Bộ tối ưu sau đó thực hiện cập nhật tham số rất lớn, trọng số nhảy tới các giá trị cực đoan và loss thường thành NaN hoặc Inf.

Bạn sẽ thấy nó dưới dạng các đột biến loss đột ngột hoặc mô hình tự nhiên bị phân kỳ.

Gradient tiêu biến

Gradient tiêu biến là vấn đề ngược lại. Giá trị gradient co dần về 0 khi lan truyền ngược qua mạng.

Khi gradient quá nhỏ, cập nhật trọng số trở nên tí hon. Các tầng đầu ngừng học, các tầng sâu học chậm, và việc huấn luyện gần như dừng lại. Đường cong loss phẳng và không cải thiện dù qua nhiều epoch.

Đây từng là lý do chính khiến RNN gặp khó với chuỗi dài trước khi LSTM và GRU ra đời.

Vị trí của gradient clipping

Gradient clipping giải quyết gradient bùng nổ, không phải gradient tiêu biến.

Clipping thu nhỏ gradient quá lớn, nhưng không làm gì khi gradient quá nhỏ. Với gradient tiêu biến, bạn cần khởi tạo trọng số tốt hơn, kết nối dư (residual), chuẩn hóa theo batch, hoặc các kiến trúc được thiết kế để giữ dòng chảy gradient.

Giải thích Clip theo chuẩn (by norm)

Clip theo chuẩn là phương pháp mà hầu hết độc giả muốn khi tìm về gradient clipping.

Quy trình có ba bước. Thứ nhất, tính chuẩn của tất cả gradient gộp lại. Thứ hai, so chuẩn đó với ngưỡng bạn chọn. Thứ ba, tái tỷ lệ gradient nếu chuẩn quá lớn.

Chuẩn thường là L2, nghĩa là bình phương từng giá trị gradient, cộng lại, rồi lấy căn bậc hai. Nếu bạn có các gradient g_1, g_2, ..., g_n trên toàn bộ tham số mô hình, chuẩn L2 là:

Công thức clip theo chuẩn

Khi có chuẩn, bạn so với ngưỡng c. Nếu ||g|| <= c, gradient đi qua không đổi. Nếu ||g|| > c, mọi gradient được nhân với hệ số c / ||g||. Điều này đưa chuẩn mới về đúng c.

Điều quan trọng là mọi thành phần thu nhỏ theo cùng một hệ số. Tỷ lệ tương đối giữa các giá trị gradient không đổi, nghĩa là vector vẫn chỉ đúng hướng ban đầu. Bạn đang rút ngắn bước đi của bộ tối ưu, không thay đổi nơi nó hướng tới.

Tính chất giữ hướng đó khiến clipping theo chuẩn là lựa chọn mặc định. Clip theo giá trị có thể vặn hướng vector gradient. Clip theo chuẩn chỉ thay đổi độ dài.

clip_grad_norm_ của PyTorch và clipnorm của TensorFlow đều làm đúng như vậy. Khi ai đó nói "tôi dùng gradient clipping", gần như luôn là clip theo chuẩn.

Chọn ngưỡng Gradient Clipping

Ngưỡng là một siêu tham số, nghĩa là không có giá trị chung cho mọi mô hình.

Nếu đặt quá cao, clipping hầu như không bao giờ kích hoạt. Gradient gần như luôn ở dưới giới hạn, nên lưới an toàn không bắt được gì. Quá trình huấn luyện diễn ra như thể không có clipping, và bạn vẫn sẽ thấy loss bùng nổ khi gradient bùng nổ.

Nếu đặt quá thấp, bạn clip quá gắt. Mỗi batch đều bị thu nhỏ gradient, khiến cập nhật trọng số nhỏ hơn mức cần thiết. Việc học chậm lại và mô hình hội tụ lâu hơn, đôi khi lâu hơn rất nhiều.

Điểm khởi đầu phổ biến là 1.0, khá hiệu quả cho nhiều kiến trúc. Các giá trị giữa 0.5 và 5.0 bao phủ hầu hết trường hợp thực tế.

Cách tốt hơn là theo dõi chuẩn gradient trong quá trình huấn luyện. Ghi log chuẩn chưa clip ở mỗi bước và xem phân phối. Nếu đa số chuẩn quanh 0.3 nhưng đôi khi vọt lên 50, hãy đặt ngưỡng cao hơn dải điển hình nhưng thấp hơn nhiều so với đột biến - 2.0 hoặc 3.0 là hợp lý ở đây.

Hãy coi nó như các siêu tham số khác. Bắt đầu với 1.0, quan sát, và điều chỉnh dựa trên hành vi huấn luyện.

Gradient Clipping trong Mạng Nơ-ron Hồi quy

RNN là nơi gradient clipping trở thành kỹ thuật tiêu chuẩn đầu tiên.

Nguyên nhân là cách RNN lan truyền gradient theo thời gian. Lan truyền ngược theo thời gian nhân cùng một ma trận trọng số qua nhiều bước, và các phép nhân lặp lại đó có thể cộng hưởng thành các giá trị khổng lồ. Chuỗi dài làm vấn đề trầm trọng hơn.

LSTM và GRU giảm bớt nhờ cơ chế cổng, nhưng không loại bỏ hoàn toàn. Cả hai kiến trúc vẫn hưởng lợi từ clipping, đặc biệt khi huấn luyện trên chuỗi dài hoặc với learning rate cao.

Với huấn luyện RNN, clip theo chuẩn với ngưỡng giữa 1.0 và 5.0 là mặc định thường gặp. Nếu bạn dùng nn.LSTM hoặc nn.GRU của PyTorch và loss bùng nổ trong quá trình huấn luyện, thêm clip_grad_norm_ thường là điều nên thử đầu tiên.

Gradient Clipping trong Học sâu hiện đại

Khi transformers thay thế RNN, gradient clipping vẫn không biến mất.

Các mô hình ngôn ngữ lớn như GPT và BERT dùng clipping trong tiền huấn luyện và tinh chỉnh. Điều tương tự áp dụng cho vision transformer, mô hình diffusion, và hầu hết kiến trúc sâu với hàng trăm tầng. Bộ tối ưu Adam và AdamW, vốn chiếm ưu thế hiện nay, thường được ghép với clip theo chuẩn ở ngưỡng khoảng 1.0.

Lý do vẫn như với RNN. Mạng sâu nhân gradient qua nhiều tầng, và kích thước batch lớn cộng với learning rate cao có thể tạo các đột biến gradient. Clipping xử lý các đột biến đó mà không ảnh hưởng tới các bước huấn luyện bình thường.

Hầu hết bản triển khai tham chiếu đều bao gồm clipping theo mặc định. Trainer của Hugging Face, PyTorch Lightning và DeepSpeed đều cung cấp clipping như một tùy chọn cấu hình chuẩn. Nếu bạn đang huấn luyện thứ gì lớn hơn mô hình đồ chơi nhỏ, clipping gần như chắc chắn là một phần của pipeline.

Chỉ cần một dòng bổ sung với chi phí gần như không đáng kể và ngăn việc huấn luyện sập sau hàng giờ tính toán. Đó là lý do nó tồn tại đến giờ.

Gradient Clipping trong PyTorch

PyTorch xử lý gradient clipping bằng một hàm tiện ích duy nhất: torch.nn.utils.clip_grad_norm_.

Lệnh clipping đặt giữa loss.backward() và optimizer.step(). Lan truyền ngược cần điền gradient trước, sau đó clipping thu nhỏ nếu cần, rồi bộ tối ưu áp dụng cập nhật. Đặt ở nơi khác sẽ không hiệu quả.

Dưới đây là đoạn script huấn luyện đầy đủ, có thể chạy, huấn luyện một MLP nhỏ trên dữ liệu hồi quy tổng hợp với gradient clipping bật:

import torch
import torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset

torch.manual_seed(42)

# Synthetic regression data
n_samples = 1000
n_features = 20
inputs = torch.randn(n_samples, n_features)
targets = (inputs.sum(dim=1, keepdim=True) * 2.0 + torch.randn(n_samples, 1) * 0.1)

dataset = TensorDataset(inputs, targets)
dataloader = DataLoader(dataset, batch_size=32, shuffle=True)

# Small feedforward network
model = nn.Sequential(
    nn.Linear(n_features, 64),
    nn.ReLU(),
    nn.Linear(64, 64),
    nn.ReLU(),
    nn.Linear(64, 1),
)

optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
loss_fn = nn.MSELoss()

# Training loop with gradient clipping
n_epochs = 5
max_grad_norm = 1.0

for epoch in range(n_epochs):
    epoch_loss = 0.0
    for batch_inputs, batch_targets in dataloader:
        optimizer.zero_grad()

        predictions = model(batch_inputs)
        loss = loss_fn(predictions, batch_targets)
        loss.backward()

        # Gradient clipping
        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=max_grad_norm)

        optimizer.step()
        epoch_loss += loss.item()

    print(f"Epoch {epoch + 1}: loss = {epoch_loss / len(dataloader):.4f}")

Đầu ra PyTorch

Hàm clip_grad_norm_ nhận hai đối số chính:

• parameters: các tham số mô hình có gradient bạn muốn clip. Truyền model.parameters() để bao phủ toàn bộ mô hình.

• max_norm: ngưỡng cho chuẩn gradient. Giá trị 1.0 là điểm khởi đầu phổ biến.

Có đối số tùy chọn norm_type mặc định là 2.0 cho chuẩn L2. Bạn hiếm khi cần đổi.

Dấu gạch dưới ở cuối clip_grad_norm_ cho biết thao tác in-place. Hàm này sửa gradient trực tiếp trong thuộc tính .grad của từng tham số, nên bạn không cần quan tâm giá trị trả về. Nó có trả về tổng chuẩn của gradient trước khi clip, hữu ích nếu bạn muốn log.

Để clip theo giá trị thay vì theo chuẩn, PyTorch có torch.nn.utils.clip_grad_value_:

torch.nn.utils.clip_grad_value_(model.parameters(), clip_value=0.5)

Nhưng như đã nói, bạn hiếm khi (nếu có) dùng triển khai này.

Toàn bộ thiết lập chỉ thêm hai dòng vào vòng lặp huấn luyện.

Gradient Clipping trong TensorFlow

TensorFlow xử lý clipping ở cấp độ bộ tối ưu thay vì là một lời gọi hàm riêng.

Khi bạn tạo một bộ tối ưu, bạn truyền clipnorm hoặc clipvalue làm đối số. Bộ tối ưu áp dụng clipping nội bộ ở mỗi bước, nên bạn không cần sửa vòng lặp huấn luyện.

Dưới đây là ví dụ đầy đủ dùng Keras API trên dữ liệu hồi quy tổng hợp:

import numpy as np
import tensorflow as tf

tf.random.set_seed(42)
np.random.seed(42)

# Synthetic regression data
n_samples = 1000
n_features = 20
x_train = np.random.randn(n_samples, n_features).astype(np.float32)
y_train = (x_train.sum(axis=1, keepdims=True) * 2.0
           + np.random.randn(n_samples, 1).astype(np.float32) * 0.1)

# Small feedforward network
model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation="relu", input_shape=(n_features,)),
    tf.keras.layers.Dense(64, activation="relu"),
    tf.keras.layers.Dense(1),
])

# Optimizer with gradient clipping by norm
optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3, clipnorm=1.0)

model.compile(optimizer=optimizer, loss="mse")
model.fit(x_train, y_train, epochs=5, batch_size=32)

Đầu ra TensorFlow

Hai đối số này làm những việc khác nhau:

• clipnorm clip theo chuẩn L2 của từng tensor gradient. Nếu chuẩn vượt ngưỡng, tensor được thu nhỏ tỷ lệ tương ứng.

• clipvalue clip riêng từng phần tử gradient. Mọi giá trị vượt ngưỡng sẽ bị kẹp về ngưỡng, và mọi giá trị nhỏ hơn âm của ngưỡng sẽ bị kẹp về âm của ngưỡng.

Để chuyển từ clip theo chuẩn sang clip theo giá trị, chỉ cần đổi đối số:

optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3, clipvalue=0.5)

Cả hai đối số hoạt động với mọi bộ tối ưu Keras: Adam, SGD, RMSprop, AdamW, và các bộ khác. Cũng có đối số global_clipnorm clip dựa trên chuẩn tính trên toàn bộ gradient gộp lại, thay vì theo từng tensor. Cách này gần với hành vi mặc định của PyTorch hơn.

Nếu bạn viết vòng lặp huấn luyện tùy chỉnh với tf.GradientTape, bộ tối ưu vẫn xử lý clipping khi bạn gọi apply_gradients:

for epoch in range(5):
    for batch_x, batch_y in zip(np.array_split(x_train, 32), np.array_split(y_train, 32)):
        with tf.GradientTape() as tape:
            predictions = model(batch_x, training=True)
            loss = tf.reduce_mean(tf.square(predictions - batch_y))

        gradients = tape.gradient(loss, model.trainable_variables)
        optimizer.apply_gradients(zip(gradients, model.trainable_variables))

Đó là khác biệt giữa hai framework. PyTorch để clipping trong tay bạn ngay trong vòng lặp. TensorFlow đẩy nó vào chính bộ tối ưu. Logic nền tảng thì giống hệt.

Gradient Clipping so với các kỹ thuật ổn định khác

Gradient clipping không phải là cách duy nhất để ổn định huấn luyện, và không phải lúc nào cũng là công cụ phù hợp.

Các kỹ thuật khác xử lý các vấn đề liên quan nhưng khác nhau. Một số ngăn gradient lớn ngay từ đầu, số khác ngăn chúng tiêu biến, và số khác làm bề mặt loss dễ tối ưu hơn. Hãy cùng xem vài kỹ thuật khác.

Chuẩn hóa theo batch (Batch normalization)

Batch normalization chuẩn hóa kích hoạt trong mỗi mini-batch khi huấn luyện.

Nó giữ đầu ra các tầng trong một khoảng ổn định, giúp độ lớn gradient dễ dự đoán hơn. Mạng được huấn luyện với batch norm chịu được learning rate cao hơn và hội tụ nhanh hơn, đồng thời ít nhạy với cách khởi tạo trọng số.

Nhưng batch norm không trực tiếp chặn gradient bùng nổ. Nó giảm tần suất xảy ra, không xử lý khi đã xảy ra. Nhiều mô hình vẫn ghép batch norm với gradient clipping vì lý do đó.

Kết nối dư (Residual connections)

Kết nối dư thêm các đường tắt bỏ qua một hoặc nhiều tầng, cho phép gradient chảy trực tiếp từ các tầng sau về các tầng trước.

Điều này giải quyết vấn đề gradient tiêu biến trong mạng sâu. Không có kết nối dư, việc huấn luyện các mạng trên 20-30 tầng trở nên khó vì gradient co dần về 0 khi lan truyền ngược. Với chúng, các mạng hàng trăm tầng huấn luyện không vấn đề.

Kết nối dư nhắm vào đầu kia của vấn đề so với clipping. Clipping xử lý gradient quá lớn. Kết nối dư xử lý gradient quá nhỏ.

Khởi tạo trọng số cẩn thận

Giá trị khởi tạo của trọng số đặt độ lớn khởi đầu của kích hoạt và gradient. Khởi tạo tệ có thể khiến gradient bùng nổ hoặc tiêu biến ngay từ bước đầu tiên.

Các phương pháp như Xavier và He scale trọng số ban đầu theo kích thước tầng. Điều này giữ phương sai kích hoạt ổn định qua các tầng vào lúc bắt đầu huấn luyện, ngăn nhiều vấn đề về gradient trước khi xảy ra.

Khởi tạo tốt giảm khả năng bạn cần clipping, nhưng không loại bỏ hoàn toàn. Đột biến gradient vẫn có thể xuất hiện về sau, đặc biệt với learning rate cao hoặc các batch bất thường.

Cách chúng kết hợp

Những kỹ thuật trên không phải lựa chọn thay thế. Chúng là các công cụ bổ trợ giải quyết các phần khác nhau của cùng một vấn đề tổng thể.

Thiết lập huấn luyện hiện đại điển hình dùng khởi tạo cẩn thận lúc đầu, kết nối dư trong kiến trúc, chuẩn hóa theo batch (hoặc layer normalization) bên trong mạng, và gradient clipping như tấm lưới an toàn trong tối ưu hóa. Mỗi cái xử lý một chế độ lỗi cụ thể, và cùng nhau làm cho mạng sâu có thể huấn luyện được.

Kết luận

Gradient clipping là một trong những cách sửa đơn giản nhất trong học sâu, và nó giải quyết một vấn đề có thể làm hỏng hàng giờ huấn luyện chỉ trong một bước.

Tin tốt là bạn không cần thay đổi kiến trúc mô hình hay viết lại mã huấn luyện. Một dòng trong PyTorch hoặc một đối số trong TensorFlow là đủ để triển khai gradient clipping.

Nó hoạt động tốt nhất khi là một phần của thiết lập lớn hơn. Kết hợp với khởi tạo trọng số cẩn thận, kết nối dư, và chuẩn hóa theo batch hoặc layer, bạn sẽ có một pipeline huấn luyện xử lý bất ổn từ nhiều phía.

Nếu loss của bạn bùng nổ, hãy bắt đầu bằng clipping. Nếu tiêu biến, hãy tìm giải pháp khác. Và nếu bạn đang huấn luyện thứ gì lớn hơn mô hình nhỏ, hãy thêm clipping vào pipeline mặc định và quên nó đi.

Gradient clipping chỉ là một trong nhiều thuật ngữ mà mọi kỹ sư machine learning cần biết. Nếu bạn muốn học những cái còn lại và sẵn sàng cho công việc vào năm 2026, hãy đăng ký lộ trình Machine Learning Engineer ngay hôm nay.