Trình tối ưu hóa Adagrad giải thích: Cách hoạt động, Triển khai & So sánh

Hãy tưởng tượng bạn đang đi xuống một ngọn đồi, nhưng mặt đất thay đổi liên tục—có chỗ dốc, có chỗ bằng phẳng. Nếu lúc nào bạn cũng bước những bước bằng nhau, bạn có thể vất vả hoặc mất quá nhiều thời gian để xuống tới chân đồi. Trong học máy, một thách thức tương tự xảy ra với gradient descent, khi dùng cùng một tốc độ học cho mọi tham số có thể làm chậm quá trình học.

Đây là lúc Adagrad phát huy tác dụng. Nó điều chỉnh kích thước bước cho từng tham số dựa trên mức độ thay đổi của tham số đó trong quá trình huấn luyện, giúp mô hình học nhanh và hiệu quả hơn, đặc biệt khi các đặc trưng có thang đo khác nhau. Trong bài viết này, chúng ta sẽ khám phá cách Adagrad hoạt động và phân tích phần toán học đằng sau nó. Ngoài ra, chúng tôi sẽ chỉ bạn cách triển khai bằng PyTorch và so sánh với các trình tối ưu hóa khác để bạn có thể chọn phương án tốt nhất cho dự án của mình.

Adagrad là gì?

Adagrad (Adaptive Gradient) là một thuật toán tối ưu hóa được dùng trong học máy, cụ thể là để huấn luyện mạng nơ-ron sâu. Nó được thiết kế để thích ứng tốc độ học cho từng tham số dựa trên lịch sử gradient của tham số đó. Cách tiếp cận này giúp Adagrad nâng cao hiệu quả của các mô hình học máy, đặc biệt trong các tình huống dữ liệu thưa hoặc khi các tham số có tốc độ hội tụ khác nhau.

Adagrad cung cấp tốc độ học cao hơn cho các đặc trưng ít xuất hiện và thấp hơn cho các đặc trưng xuất hiện thường xuyên, điều này rất phù hợp khi làm việc với dữ liệu thưa. Thêm vào đó, nó còn giảm nhu cầu phải điều chỉnh thủ công tốc độ học!

Giải thích thuật toán Adagrad

Hãy cùng phân tích thuật toán Adagrad:

Bước 1: Khởi tạo tham số

Đầu tiên, bắt đầu với:

• Giá trị ban đầu của các tham số,0, mà bạn muốn tối ưu.
• Một hằng số nhỏ ϵ để tránh chia cho 0 (thường là một số rất nhỏ, như 10^-8.
• Tốc độ học ban đầu η, quyết định độ lớn cập nhật tham số lúc khởi đầu.

Bước 2: Tính gradient

Với mỗi tham số 0_t​ tại bước thời gian _t, bạn tính gradient của hàm mất mát theo tham số đó. Gradient cho biết mức độ và hướng cập nhật tham số để giảm mất mát. Gọi gradient này là g_t, trong đó _t là bước thời gian hiện tại.

Bước 3: Tích lũy bình phương gradient

Thay vì cập nhật trực tiếp các tham số, Adagrad theo dõi tổng bình phương gradient cho từng tham số. Với mỗi tham số i, bạn tính và tích lũy bình phương gradient ở mọi bước thời gian. Gradient tích lũy này được ký hiệu là G_t.

G_t =G_t-1 + g_t²

Trong đó:

• G_t-1 là tổng bình phương gradient đến bước thời gian trước đó.
• g_t² là bình phương gradient hiện tại của tham số.

Gradient tích lũy này giúp Adagrad điều chỉnh tốc độ học khác nhau cho từng tham số dựa trên mức độ đã được cập nhật.

Bước 4: Cập nhật tham số

Giờ bạn đã có bình phương gradient tích lũy G_t​, ta có thể cập nhật từng tham số 0_t​. Quy tắc cập nhật của Adagrad như sau:

Ý nghĩa của các thành phần:

• η là tốc độ học ban đầu
• G_t là bình phương gradient tích lũy đến bước thời gian t.
• ϵ là một giá trị nhỏ để tránh chia cho 0.
• g_t​ là gradient tại bước thời gian hiện tại.

Hạng tử:

​

giảm hiệu quả tốc độ học đối với các tham số có gradient tích lũy lớn. Ngược lại, các tham số có gradient tích lũy nhỏ sẽ có tốc độ học lớn hơn.

Công thức của Adagrad tự động thích ứng tốc độ học, cụ thể:

• Cập nhật thường xuyên (gradient tích lũy lớn): Với các tham số được cập nhật thường xuyên, G_t trở nên lớn, khiến tốc độ học nhỏ lại. Điều này ngăn tham số thay đổi quá đột ngột và ổn định việc học.
• Cập nhật không thường xuyên (gradient tích lũy nhỏ): Với các tham số ít được cập nhật, G_t giữ ở mức nhỏ, giúp tốc độ học lớn hơn. Nhờ đó có thể cập nhật đáng kể khi cần.

Triển khai Adagrad trong PyTorch

PyTorch cung cấp sẵn một triển khai Adagrad trong mô-đun torch.optim. Trước hết, cài đặt PyTorch bằng pip:

pip install torch torchvisionĐược hỗ trợ bởi

Học cách xây dựng mạng nơ-ron đầu tiên của bạn với khóa học miễn phí Introduction to Deep Learning with PyTorch.

Dưới đây là hướng dẫn từng bước để triển khai trình tối ưu hóa Adagrad trong PyTorch:

Bước 1: Import các thư viện cần thiết

import torchimport torch.nn as nnimport torch.optim as optimĐược hỗ trợ bởi

Bước 2: Định nghĩa một mạng nơ-ron đơn giản

class SimpleNN(nn.Module):    def __init__(self):        super(SimpleNN, self).__init__()        self.fc1 = nn.Linear(10, 5)        self.fc2 = nn.Linear(5, 2)        def forward(self, x):        x = torch.relu(self.fc1(x))        x = self.fc2(x)        return xĐược hỗ trợ bởi

Bước 3: Khởi tạo mô hình và trình tối ưu hóa

model = SimpleNN()criterion = nn.CrossEntropyLoss()optimizer = optim.Adagrad(model.parameters(), lr=0.01)Được hỗ trợ bởi

Bước 4: Vòng lặp huấn luyện

for epoch in range(10):  # loop over the dataset multiple times    inputs = torch.randn(1, 10)  # random input tensor    labels = torch.tensor([1])   # target labels    # Zero the parameter gradients    optimizer.zero_grad()    # Forward pass    outputs = model(inputs)    loss = criterion(outputs, labels)    # Backward pass and optimize    loss.backward()    optimizer.step()    print(f'Epoch {epoch+1}, Loss: {loss.item()}')Được hỗ trợ bởi

Trong đoạn mã này, một mô hình tuyến tính đơn giản được huấn luyện bằng trình tối ưu hóa AdaGrad. Tốc độ học được đặt là 0.01, nhưng AdaGrad sẽ điều chỉnh cho từng tham số dựa trên bình phương gradient tích lũy.

Chạy mã và bạn sẽ thấy đầu ra tương tự như sau:

Đầu ra hiển thị mất mát sau mỗi epoch, phản ánh mức độ mô hình học tốt đến đâu. Ban đầu, mất mát cao hơn, nhưng khi quá trình huấn luyện tiếp diễn, mất mát thường giảm, nghĩa là mô hình đang cải thiện. Một vài dao động là bình thường, nhất là với đầu vào ngẫu nhiên, nhưng tổng thể, mô hình dần học để đưa ra dự đoán tốt hơn.

Nếu bạn muốn khám phá học sâu và tìm hiểu cách nhánh này của học máy đang thay đổi thế giới, hãy xem khóa học Deep Learning in Python của chúng tôi.

Adagrad so với các trình tối ưu hóa khác

Hãy so sánh Adagrad với các trình tối ưu hóa khác như Adam, SGD và RMSProp.

Adagard so với Adam

Thích ứng tốc độ học

Cả Adagrad và Adam đều thích ứng tốc độ học cho từng tham số, nhưng theo những cách khác nhau. Adagrad co giãn tốc độ học dựa trên tổng bình phương gradient, có thể dẫn tới tốc độ học giảm dần theo thời gian. Ngược lại, Adam dùng cả moment bậc nhất và bậc hai của gradient, cho phép duy trì tốc độ học ổn định hơn trong suốt quá trình huấn luyện.

Xử lý dữ liệu thưa: 

Adagrad đặc biệt phù hợp để xử lý dữ liệu thưa nhờ khả năng gán tốc độ học lớn hơn cho các đặc trưng ít xuất hiện. Điều này khiến nó là lựa chọn tốt cho các ứng dụng như xử lý ngôn ngữ tự nhiên, nơi gradient thưa xuất hiện phổ biến. Adam, dù cũng có thể xử lý dữ liệu thưa, nhìn chung được ưa chuộng hơn nhờ tính vững và hiệu quả trên phạm vi ứng dụng rộng hơn.

Hội tụ và hiệu năng

Adam thường được ưu tiên nhờ hội tụ nhanh hơn và hiệu năng vượt trội trên thực tế, đặc biệt trong các mô hình học sâu với dữ liệu lớn. Việc sử dụng momentum và hiệu chỉnh độ lệch giúp Adam tránh bị kẹt tại các điểm cực tiểu cục bộ và điểm yên, vốn có thể là hạn chế của Adagrad.

Tìm hiểu về các kiến trúc học sâu nền tảng như CNN, RNN, LSTM và GRU để mô hình hóa dữ liệu ảnh và chuỗi. Xem khóa học Intermediate Deep Learning with PyTorch.

Adagrad so với các thuật toán gradient descent khác

Hãy so sánh Adagrad với SGD và RMSProp

AdaGrad so với Stochastic Gradient Descent (SGD)

Stochastic Gradient Descent là một thuật toán tối ưu hóa cơ bản cập nhật tham số mô hình dựa trên gradient của hàm mất mát theo các tham số. Nó nổi tiếng vì sự đơn giản và dễ triển khai. Tuy nhiên, SGD có tốc độ học cố định, điều này có thể là hạn chế khi xử lý dữ liệu thưa hoặc các đặc trưng có thang đo khác nhau.

AdaGrad so với RMSProp

RMSProp là một phần mở rộng của AdaGrad nhằm giải quyết vấn đề tốc độ học giảm dần bằng cách đưa vào một hệ số suy giảm. Hệ số này giúp RMSProp duy trì tốc độ học ổn định hơn trong suốt quá trình huấn luyện.

Hãy tóm tắt ưu và nhược điểm của Adagrad, SGD và RMSProp:

Các trường hợp sử dụng phổ biến và hạn chế

Hãy khám phá các trường hợp sử dụng và hạn chế của AdaGrad trong nhiều bối cảnh.

Trường hợp sử dụng của Adagrad

Khả năng độc đáo của Adagrad trong việc thích ứng tốc độ học cho từng tham số khiến nó lý tưởng cho một số tình huống:

1. Xử lý ngôn ngữ tự nhiên (NLP): Một trong những ứng dụng quan trọng nhất của Adagrad là trong NLP. Trong NLP, word embeddings là thành phần then chốt, và Adagrad được dùng để tối ưu các embedding này bằng cách thích ứng tốc độ học của từng tham số.
2. Hệ thống gợi ý: Trong các hệ thống gợi ý, Adagrad được dùng để tối ưu trọng số của mô hình gợi ý. Điều này quan trọng để dự đoán khả năng người dùng yêu thích một sản phẩm cụ thể.
3. Nhận dạng ảnh: Trong nhận dạng ảnh, Adagrad được dùng để tối ưu trọng số của các mạng nơ-ron sâu. Bằng cách thích ứng tốc độ học cho từng tham số, Adagrad đảm bảo các trọng số được cập nhật phù hợp với bài toán, cải thiện độ chính xác của mô hình nhận dạng ảnh

Hạn chế của Adagrad

Mặc dù Adagrad mạnh mẽ trong một số trường hợp, nó cũng có một số hạn chế:

1. Tốc độ học suy giảm: Một hạn chế chính của Adagrad là xu hướng giảm tốc độ học quá mạnh theo thời gian. Khi thuật toán tích lũy bình phương gradient từ đầu quá trình huấn luyện, tốc độ học hiệu dụng có thể trở nên rất nhỏ, dẫn tới hội tụ chậm hoặc thậm chí khiến mô hình ngừng học.
2. Yêu cầu bộ nhớ: Adagrad cần nhiều bộ nhớ hơn để lưu trữ lịch sử gradient cho từng tham số, khiến nó kém hiệu quả với các tập dữ liệu lớn. Đây có thể là nhược điểm đáng kể khi làm việc với các mô hình học máy quy mô lớn, nơi hiệu quả bộ nhớ là tối quan trọng.

Chiến lược giảm thiểu hạn chế

Có một số chiến lược bạn có thể dùng để khắc phục các hạn chế của Adagrad:

1. Sử dụng AdaDelta và RMSProp: Để giải quyết vấn đề tốc độ học giảm dần, các biến thể của AdaGrad như AdaDelta và RMSProp đã được phát triển.
2. Kết hợp với momentum: Một chiến lược khác là kết hợp với các phương pháp dựa trên momentum. Trình tối ưu Adam, chẳng hạn, kết hợp tốc độ học thích ứng của AdaGrad với khái niệm momentum, giúp tăng tốc hội tụ và cải thiện hiệu năng thực tế.
3. Tinh chỉnh siêu tham số: Việc tinh chỉnh cẩn thận siêu tham số, như tốc độ học ban đầu và giá trị epsilon dùng để tránh chia cho 0, cũng có thể giúp giảm bớt một số hạn chế của Adagrad.

Bài tập thực hành: Tối ưu hóa mô hình với Adagrad

Hãy xây dựng một mạng nơ-ron đơn giản, huấn luyện nó bằng trình tối ưu hóa Adagrad và so sánh hiệu năng với các trình tối ưu phổ biến khác.

Nếu bạn muốn tìm hiểu thêm về PyTorch, hãy xem hướng dẫn PyTorch Tutorial: Building a Simple Neural Network From Scratch.

Bắt đầu bằng cách tạo một mô hình mạng nơ-ron cơ bản trong PyTorch. Chúng ta sẽ thiết kế một mạng phù hợp cho phân loại nhị phân trên dữ liệu thưa, nơi Adagrad hoạt động nổi bật.

import torchimport torch.nn as nnclass SparseNN(nn.Module):    def __init__(self, input_size):        super(SparseNN, self).__init__()        self.fc1 = nn.Linear(input_size, 50)        self.fc2 = nn.Linear(50, 1)        self.activation = nn.ReLU()        self.output_activation = nn.Sigmoid()    def forward(self, x):        x = self.activation(self.fc1(x))        x = self.output_activation(self.fc2(x))        return xĐược hỗ trợ bởi

Mạng nơ-ron này có một lớp đầu vào, một lớp ẩn với 50 nơ-ron và một lớp đầu ra với một nơ-ron. Chúng ta dùng kích hoạt ReLU cho lớp ẩn và Sigmoid cho lớp đầu ra, phù hợp với phân loại nhị phân.

Giờ hãy thiết lập quá trình huấn luyện bằng trình tối ưu hóa Adagrad. Chúng ta sẽ tạo một hàm để xử lý huấn luyện:

import torch.optim as optimfrom torch.utils.data import DataLoader, TensorDataset# Function to train the modeldef train_model(model, optimizer, criterion, train_loader, num_epochs=100):    losses = []    for epoch in range(num_epochs):  # loop for each training epoch        for inputs, targets in train_loader:            # Clear gradients before each batch to avoid accumulation            optimizer.zero_grad() # Reset gradients to zero            # Forward pass - get model predictions            outputs = model(inputs)            # Calculate loss based on predictions and targets            loss = criterion(outputs, targets)            # Backward pass - calculate gradients for parameter updates based on the loss            loss.backward()            # Update model parameters based on calculated gradients            optimizer.step()        # Track loss for monitoring training progress        losses.append(loss.item())    return losses# Setup for trainingX, y = generate_sparse_data()  # This function generates our sparse datasetinput_size = X.shape[1]train_size = int(0.8 * len(X))X_train, X_test = X[:train_size], X[train_size:]y_train, y_test = y[:train_size], y[train_size:]train_dataset = TensorDataset(X_train, y_train)train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)model = SparseNN(input_size)criterion = nn.BCELoss()  # Assuming binary classification with BCE lossoptimizer = optim.Adagrad(model.parameters(), lr=0.01)# Train the modellosses = train_model(model, optimizer, criterion, train_loader)Được hỗ trợ bởi

Trong thiết lập này, chúng ta:

1. Tạo mô hình SparseNN.
2. Định nghĩa hàm mất mát (Binary Cross Entropy).
3. Khởi tạo trình tối ưu Adagrad với tốc độ học 0.01.
4. Huấn luyện mô hình trong 100 epoch, ghi nhận mất mát ở mỗi epoch.

Tiếp theo, để đánh giá hiệu năng mô hình, chúng ta tạo một hàm đánh giá:

def evaluate_model(model, test_loader):    model.eval()    correct = 0    total = 0    with torch.no_grad():        for inputs, targets in test_loader:            outputs = model(inputs)            predicted = (outputs > 0.5).float()            total += targets.size(0)            correct += (predicted == targets).sum().item()    accuracy = correct / total    return accuracy# Evaluate the modeltest_dataset = TensorDataset(X_test, y_test)test_loader = DataLoader(test_dataset, batch_size=32)accuracy = evaluate_model(model, test_loader)print(f"Adagrad Accuracy: {accuracy:.4f}")Được hỗ trợ bởi

Hàm này tính độ chính xác của mô hình trên tập kiểm tra.

Tiếp đến, hãy so sánh với các trình tối ưu phổ biến khác: SGD, Adam và RMSprop. Chúng ta sẽ tạo một hàm để chạy thí nghiệm cho từng trình tối ưu:

def run_experiment(optimizer_class, lr=0.01):    model = SparseNN(input_size)    criterion = nn.BCELoss()        if optimizer_class == optim.SGD:        optimizer = optimizer_class(model.parameters(), lr=lr, momentum=0.9)    elif optimizer_class == optim.RMSprop:        optimizer = optimizer_class(model.parameters(), lr=lr, alpha=0.99)    else:        optimizer = optimizer_class(model.parameters(), lr=lr)    losses = train_model(model, optimizer, criterion, train_loader)    accuracy = evaluate_model(model, test_loader)    return losses, accuracy# Compare optimizersoptimizers = {    'Adagrad': optim.Adagrad,    'SGD': optim.SGD,    'Adam': optim.Adam,    'RMSprop': optim.RMSprop}results = {}for name, opt_class in optimizers.items():    losses, accuracy = run_experiment(opt_class)    results[name] = {'losses': losses, 'accuracy': accuracy}print("Final accuracies:")for name, data in results.items():    print(f"{name}: {data['accuracy']:.4f}")Được hỗ trợ bởi

Sau khi chạy đoạn mã này, chúng ta nhận được kết quả sau:

Final accuracies:Adagrad: 0.9350SGD: 0.8950Adam: 0.9300RMSprop: 0.8600Được hỗ trợ bởi

Các kết quả cho thấy Adagrad hoạt động tốt nhất trên bài toán dữ liệu thưa của chúng ta, đạt độ chính xác cao nhất 95.00%. Điều này cho thấy Adagrad rất phù hợp với các kịch bản dữ liệu thưa. Adam đứng thứ hai sát nút, trong khi SGD và RMSprop có hiệu năng thấp hơn trong trường hợp cụ thể này.

Để trực quan hóa quá trình huấn luyện, chúng ta có thể vẽ các đường cong mất mát:

import matplotlib.pyplot as pltplt.figure(figsize=(12, 6))for name, data in results.items():    plt.plot(data['losses'], label=f"{name} (Accuracy: {data['accuracy']:.4f})")plt.xlabel('Epochs')plt.ylabel('Loss')plt.title('Training Loss Comparison (Sparse Data)')plt.legend()plt.show()Được hỗ trợ bởi

Hãy gộp tất cả các đoạn mã lại, dưới đây là mã hoàn chỉnh.

import torchimport torch.nn as nnimport torch.optim as optimfrom torch.utils.data import DataLoader, TensorDatasetimport matplotlib.pyplot as plt# Step 1: Generate sparse synthetic datadef generate_sparse_data(n_samples=1000, n_features=100, sparsity=0.95):    X = torch.randn(n_samples, n_features)    mask = torch.rand(n_samples, n_features) < sparsity    X[mask] = 0    weights = torch.randn(n_features)    y = (torch.matmul(X, weights) > 0).float().view(-1, 1)    return X, y# Step 2: Define the neural networkclass SparseNN(nn.Module):    def __init__(self, input_size):        super(SparseNN, self).__init__()        self.fc1 = nn.Linear(input_size, 50)        self.fc2 = nn.Linear(50, 1)        self.activation = nn.ReLU()        self.output_activation = nn.Sigmoid()    def forward(self, x):        x = self.activation(self.fc1(x))        x = self.output_activation(self.fc2(x))        return x# Step 3: Train the modeldef train_model(model, optimizer, criterion, train_loader, num_epochs=100):    losses = []    for epoch in range(num_epochs):        for inputs, targets in train_loader:            optimizer.zero_grad()            outputs = model(inputs)            loss = criterion(outputs, targets)            loss.backward()            optimizer.step()        losses.append(loss.item())    return losses# Step 4: Evaluate the modeldef evaluate_model(model, test_loader):    model.eval()    correct = 0    total = 0    with torch.no_grad():        for inputs, targets in test_loader:            outputs = model(inputs)            predicted = (outputs > 0.5).float()            total += targets.size(0)            correct += (predicted == targets).sum().item()    accuracy = correct / total    return accuracy# Step 5: Main function to run the experimentdef run_experiment(optimizer_class, lr=0.01):    # Generate sparse data    X, y = generate_sparse_data()    input_size = X.shape[1]    train_size = int(0.8 * len(X))    X_train, X_test = X[:train_size], X[train_size:]    y_train, y_test = y[:train_size], y[train_size:]    # Create data loaders    train_dataset = TensorDataset(X_train, y_train)    test_dataset = TensorDataset(X_test, y_test)    train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)    test_loader = DataLoader(test_dataset, batch_size=32)    # Initialize model and training components    model = SparseNN(input_size)    criterion = nn.BCELoss()        # Use default hyperparameters for each optimizer    if optimizer_class == optim.SGD:        optimizer = optimizer_class(model.parameters(), lr=lr, momentum=0.9)    elif optimizer_class == optim.RMSprop:        optimizer = optimizer_class(model.parameters(), lr=lr, alpha=0.99)    else:        optimizer = optimizer_class(model.parameters(), lr=lr)    # Train the model    losses = train_model(model, optimizer, criterion, train_loader)    # Evaluate the model    accuracy = evaluate_model(model, test_loader)    return losses, accuracy# Step 6: Compare Adagrad with other optimizersoptimizers = {    'Adagrad': optim.Adagrad,    'SGD': optim.SGD,    'Adam': optim.Adam,    'RMSprop': optim.RMSprop}results = {}for name, opt_class in optimizers.items():    losses, accuracy = run_experiment(opt_class)    results[name] = {'losses': losses, 'accuracy': accuracy}# Step 7: Plot resultsplt.figure(figsize=(12, 6))for name, data in results.items():    plt.plot(data['losses'], label=f"{name} (Accuracy: {data['accuracy']:.4f})")plt.xlabel('Epochs')plt.ylabel('Loss')plt.title('Training Loss Comparison (Sparse Data)')plt.legend()plt.show()print("Final accuracies:")for name, data in results.items():    print(f"{name}: {data['accuracy']:.4f}")Được hỗ trợ bởi

Kết quả như sau:

Kết luận

Adagrad hữu ích khi làm việc với dữ liệu thưa nhờ tốc độ học thích ứng. Chúng ta đã xây dựng một mạng nơ-ron cơ bản và huấn luyện bằng Adagrad, sau đó so sánh hiệu năng với các thuật toán tối ưu nổi tiếng khác. Kết quả nghiêng hẳn về Adagrad, cho thấy nó xử lý dữ liệu thưa tốt hơn.

Chúng tôi cũng đã chọn lọc một số tài nguyên hay nhất về PyTorch, học sâu và các thuật toán tối ưu hóa khác. Hãy xem để tìm hiểu chuyên sâu hơn:

• PyTorch Tutorial: Building a Simple Neural Network From Scratch
• Adam Optimizer Tutorial: Intuition and Implementation in Python
• Stochastic Gradient Descent in Python: A Complete Guide for ML Optimization
• Introduction to Deep Learning with PyTorch
• Intermediate Deep Learning with PyTorch
• Deep Learning for Images with PyTorch