Learning rate scheduling
Learning Rate Scheduling: Chiến lược tối ưu quá trình huấn luyện
Giới thiệu
Learning rate (tốc độ học) là một trong những hyperparameter quan trọng nhất khi huấn luyện mô hình deep learning. Nó quyết định kích thước bước di chuyển trong không gian tham số khi cập nhật trọng số. Một learning rate quá lớn có thể khiến mô hình không hội tụ, còn một learning rate quá nhỏ có thể khiến quá trình huấn luyện mất nhiều thời gian hoặc bị mắc kẹt ở cực tiểu cục bộ.
Learning Rate Scheduling (Lập lịch tốc độ học) là một chiến lược thay đổi learning rate trong suốt quá trình huấn luyện để cải thiện hiệu suất và tốc độ hội tụ của mô hình. Bài viết này sẽ giới thiệu về các phương pháp lập lịch learning rate phổ biến và hiệu quả.
Tại sao cần Learning Rate Scheduling?
Trong quá trình tối ưu hóa, learning rate thích hợp thường thay đổi theo thời gian:
Giai đoạn đầu: Learning rate lớn giúp tăng tốc quá trình học và thoát khỏi các cực tiểu cục bộ
Giai đoạn sau: Learning rate nhỏ giúp tinh chỉnh và hội tụ đến điểm tối ưu chính xác hơn
Việc điều chỉnh learning rate theo thời gian mang lại nhiều lợi ích:
Tăng tốc hội tụ: Kết hợp tốc độ của learning rate cao và độ chính xác của learning rate thấp
Tránh dao động: Giảm dao động của quá trình tối ưu hóa khi gần đến điểm hội tụ
Thoát khỏi plateau: Giúp mô hình vượt qua các vùng bằng phẳng trong bề mặt mất mát
Cải thiện hiệu suất: Thường dẫn đến mô hình có độ chính xác cao hơn
Các phương pháp Learning Rate Scheduling
1. Step Decay
Nguyên lý: Giảm learning rate theo hệ số nhất định sau một số epoch cố định.
Công thức:
lr = initial_lr * drop_factor^(floor(epoch / epochs_drop))Triển khai với Keras:
from tensorflow.keras.callbacks import LearningRateScheduler
def step_decay(epoch):
initial_lr = 0.1
drop_factor = 0.5
epochs_drop = 10
lr = initial_lr * math.pow(drop_factor, math.floor(epoch/epochs_drop))
return lr
lr_scheduler = LearningRateScheduler(step_decay)
model.fit(X_train, y_train, epochs=100, callbacks=[lr_scheduler])Ưu điểm:
Đơn giản, dễ triển khai
Hiệu quả cho nhiều loại bài toán
Nhược điểm:
Sự thay đổi đột ngột có thể làm gián đoạn quá trình học
Cần điều chỉnh nhiều hyperparameters (epochs_drop, drop_factor)
2. Exponential Decay
Nguyên lý: Giảm learning rate theo hàm mũ liên tục.
Công thức:
lr = initial_lr * exp(-k * epoch)Triển khai với TensorFlow:
import tensorflow as tf
initial_lr = 0.1
decay_rate = 0.96
decay_steps = 100
lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay(
initial_lr,
decay_steps=decay_steps,
decay_rate=decay_rate,
staircase=False
)
optimizer = tf.keras.optimizers.Adam(learning_rate=lr_schedule)Ưu điểm:
Giảm dần liên tục, tránh thay đổi đột ngột
Đơn giản, chỉ cần điều chỉnh ít hyperparameters
Nhược điểm:
Tốc độ giảm cố định có thể không phù hợp với mọi giai đoạn huấn luyện
Có thể giảm quá nhanh trong một số trường hợp
3. Cosine Annealing
Nguyên lý: Giảm learning rate theo hàm cosine, tạo ra đường cong mượt mà từ giá trị cao xuống thấp.
Công thức:
lr = min_lr + 0.5 * (max_lr - min_lr) * (1 + cos(π * epoch / max_epochs))Triển khai với PyTorch:
from torch.optim.lr_scheduler import CosineAnnealingLR
optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
scheduler = CosineAnnealingLR(optimizer, T_max=100, eta_min=1e-6)
# Trong vòng lặp huấn luyện
for epoch in range(100):
train(...)
scheduler.step()Ưu điểm:
Giảm mượt mà, tránh dao động lớn
Hiệu quả cao cho nhiều loại mô hình
Tận dụng learning rate lớn ở giữa mỗi chu kỳ
Nhược điểm:
Có thể phức tạp hơn các phương pháp đơn giản khác
4. Cyclical Learning Rates
Nguyên lý: Dao động learning rate giữa các giá trị cao và thấp theo chu kỳ, giúp thoát khỏi các cực tiểu cục bộ.
Công thức (Triangular policy):
cycle = floor(1 + epoch / (2 * step_size))
x = abs(epoch / step_size - 2 * cycle + 1)
lr = min_lr + (max_lr - min_lr) * max(0, 1 - x)Triển khai với Keras:
from tensorflow.keras.callbacks import Callback
class CyclicLR(Callback):
def __init__(self, base_lr=0.001, max_lr=0.006, step_size=2000., mode='triangular'):
super(CyclicLR, self).__init__()
self.base_lr = base_lr
self.max_lr = max_lr
self.step_size = step_size
self.mode = mode
self.cycle = 0
self.batch_counter = 0
def on_batch_begin(self, batch, logs=None):
cycle = np.floor(1 + self.batch_counter / (2 * self.step_size))
x = np.abs(self.batch_counter / self.step_size - 2 * cycle + 1)
lr = self.base_lr + (self.max_lr - self.base_lr) * np.maximum(0, (1-x))
K.set_value(self.model.optimizer.lr, lr)
self.batch_counter += 1Ưu điểm:
Giúp thoát khỏi cực tiểu cục bộ và điểm yên ngựa
Thường đạt độ chính xác cao hơn với ít epochs hơn
Giảm nhu cầu điều chỉnh learning rate ban đầu
Nhược điểm:
Cần điều chỉnh nhiều hyperparameters (chu kỳ, biên độ)
Có thể phức tạp hơn để triển khai
5. One Cycle Policy
Nguyên lý: Phương pháp do Leslie Smith đề xuất, gồm một chu kỳ tăng-giảm learning rate, kết hợp với chiến lược ngược lại cho momentum.
Triển khai với Fastai/PyTorch:
from fastai.torch_core import *
from fastai.callback.schedule import one_cycle_scheduler
learn = Learner(data, model, opt_func=opt_func)
learn.fit_one_cycle(n_epochs, max_lr)Ưu điểm:
Cho phép sử dụng learning rate cao mà không gây ra sự phân kỳ
Hội tụ nhanh hơn nhiều phương pháp khác
Thường đạt được kết quả tốt hơn
Nhược điểm:
Cần điều chỉnh learning rate tối đa cẩn thận
Có thể không phù hợp với mọi kiến trúc mô hình
6. Reduce On Plateau
Nguyên lý: Giảm learning rate khi metric không cải thiện sau một số epoch nhất định.
Triển khai với Keras:
from tensorflow.keras.callbacks import ReduceLROnPlateau
reduce_lr = ReduceLROnPlateau(
monitor='val_loss',
factor=0.2,
patience=5,
min_lr=1e-6,
verbose=1
)
model.fit(X_train, y_train, epochs=100, callbacks=[reduce_lr])Ưu điểm:
Thích nghi với quá trình huấn luyện cụ thể
Hữu ích khi không biết trước lịch trình tối ưu
Giúp vượt qua các plateau trong quá trình học
Nhược điểm:
Phản ứng chậm, chỉ giảm sau khi phát hiện plateau
Có thể bỏ lỡ cơ hội học với tốc độ cao hơn
Learning Rate Warmup
Nguyên lý: Bắt đầu với learning rate rất nhỏ và tăng dần trong vài epoch đầu tiên, trước khi áp dụng lịch giảm chính.
Công thức:
if epoch < warmup_epochs:
lr = initial_lr * (epoch / warmup_epochs)
else:
# Áp dụng lịch giảm learning rateTriển khai với TensorFlow:
class WarmUpCosineDecay(tf.keras.callbacks.Callback):
def __init__(self, total_epochs, warmup_epochs, initial_lr, min_lr):
super(WarmUpCosineDecay, self).__init__()
self.total_epochs = total_epochs
self.warmup_epochs = warmup_epochs
self.initial_lr = initial_lr
self.min_lr = min_lr
def on_epoch_begin(self, epoch, logs=None):
if epoch < self.warmup_epochs:
lr = self.initial_lr * (epoch / self.warmup_epochs)
else:
progress = (epoch - self.warmup_epochs) / (self.total_epochs - self.warmup_epochs)
lr = self.min_lr + 0.5 * (self.initial_lr - self.min_lr) * (1 + np.cos(np.pi * progress))
tf.keras.backend.set_value(self.model.optimizer.lr, lr)Ưu điểm:
Tăng tính ổn định trong giai đoạn đầu huấn luyện
Đặc biệt hữu ích cho mô hình lớn với batch size lớn
Giảm sự dao động ban đầu
Tìm Learning Rate tối ưu với Learning Rate Finder
Trước khi áp dụng các phương pháp scheduling, chúng ta cần tìm learning rate khởi đầu phù hợp. Learning Rate Finder là một kỹ thuật được phổ biến bởi Leslie Smith và Jeremy Howard:
Bắt đầu với learning rate rất nhỏ (ví dụ: 1e-7)
Tăng dần learning rate theo cấp số nhân sau mỗi mini-batch
Vẽ đồ thị loss theo learning rate
Chọn learning rate tại điểm loss giảm nhanh nhất (hoặc trước khi loss bắt đầu tăng)
Triển khai với fastai:
from fastai.vision.all import *
learn = vision_learner(dls, resnet50, metrics=accuracy)
learn.lr_find()So sánh các phương pháp
Step Decay
Khi muốn phương pháp đơn giản, hiệu quả
Đơn giản, ổn định
Thay đổi đột ngột
Exponential Decay
Khi cần giảm mượt mà, liên tục
Đơn giản, mượt mà
Tốc độ giảm cố định
Cosine Annealing
Khi muốn hiệu suất cao, tránh dao động
Hội tụ mượt mà, hiệu quả cao
Phức tạp hơn để triển khai
Cyclical Learning Rates
Khi cần thoát khỏi cực tiểu cục bộ
Thoát khỏi cực tiểu cục bộ, huấn luyện nhanh
Khó tinh chỉnh tham số
One Cycle Policy
Khi cần huấn luyện nhanh với kết quả tốt
Huấn luyện nhanh, kết quả tốt
Cần tìm max_lr phù hợp
Reduce On Plateau
Khi không biết lịch trình tối ưu
Thích nghi với quá trình huấn luyện
Phản ứng chậm
Hướng dẫn thực hành
Quy trình tối ưu Learning Rate
Bước 1: Sử dụng Learning Rate Finder để xác định learning rate ban đầu phù hợp
Bước 2: Chọn phương pháp scheduling phù hợp với bài toán
Bước 3: Kết hợp với warmup nếu cần thiết
Bước 4: Theo dõi quá trình huấn luyện và điều chỉnh nếu cần
Ví dụ hoàn chỉnh với PyTorch
import torch
import torch.nn as nn
import torch.optim as optim
from torch.optim.lr_scheduler import OneCycleLR
# Tạo mô hình
model = YourModel()
# Định nghĩa optimizer
optimizer = optim.Adam(model.parameters(), lr=0.001)
# Định nghĩa scheduler
scheduler = OneCycleLR(
optimizer,
max_lr=0.01,
steps_per_epoch=len(train_loader),
epochs=30,
pct_start=0.3, # 30% đầu tiên là tăng lr, 70% còn lại là giảm
div_factor=25, # lr ban đầu = max_lr/div_factor
final_div_factor=1000 # lr cuối cùng = lr ban đầu/final_div_factor
)
# Vòng lặp huấn luyện
for epoch in range(30):
for batch in train_loader:
# Forward pass
outputs = model(batch[0])
loss = criterion(outputs, batch[1])
# Backward pass
optimizer.zero_grad()
loss.backward()
optimizer.step()
# Cập nhật learning rate sau mỗi batch
scheduler.step()
# In learning rate hiện tại
current_lr = optimizer.param_groups[0]['lr']
print(f"Epoch {epoch}, Learning rate: {current_lr:.6f}")Kết luận
Learning Rate Scheduling là một kỹ thuật cần thiết để đạt được hiệu suất tối ưu trong huấn luyện mô hình deep learning. Lựa chọn phương pháp scheduling phù hợp có thể giúp:
Tăng tốc quá trình hội tụ
Cải thiện độ chính xác của mô hình
Tránh bị mắc kẹt ở cực tiểu cục bộ
Giảm thời gian huấn luyện
Không có một phương pháp scheduling nào phù hợp với mọi bài toán. Việc thử nghiệm và so sánh các phương pháp khác nhau là cần thiết để tìm ra chiến lược tối ưu cho mô hình cụ thể của bạn.
Một số xu hướng hiện đại còn kết hợp các phương pháp khác nhau, như Warmup + Cosine Annealing hoặc One Cycle Policy với các chiến lược thích nghi. Hãy thử nghiệm và khám phá cách tiếp cận phù hợp nhất với bài toán của bạn.
Last updated