- Vị thế dẫn đầu của PyTorch: Framework học sâu hàng đầu thế giới, ban đầu do Meta AI phát triển và nay thuộc PyTorch Foundation (Linux Foundation), là công cụ nghiên cứu và sản xuất tiêu chuẩn cho hầu hết các mô hình ngôn ngữ lớn (LLM) và thị giác máy tính hiện nay.
- Cấu trúc Tensor: Mảng đa chiều tương tự NumPy ndarray nhưng được trang bị khả năng tính toán gia tốc phần cứng trên GPU thông qua CUDA và quản lý bộ nhớ tối ưu.
- Cơ chế Autograd đồ thị động (Define-by-Run): Tự động ghi lại các phép toán đã thực thi trong luồng lan truyền xuôi để dựng đồ thị tính toán trực tiếp, cho phép gọi hàm
loss.backward()tính toán gradient theo quy tắc chuỗi giải tích. - Khối xây dựng nn.Module: Lớp trừu tượng hướng đối tượng giúp đóng gói tham số trọng số học được, các phép biến đổi tầng mạng và định nghĩa hàm lan truyền xuôi
forward(). - Vòng lặp huấn luyện chuẩn 5 bước: Quy trình bắt buộc gồm
optimizer.zero_grad(),outputs = model(inputs),loss = criterion(outputs, labels),loss.backward(), vàoptimizer.step().
Trong kỷ nguyên bùng nổ của Trí tuệ Nhân tạo hiện đại, PyTorch đã trở thành "ngôn ngữ chung" của các nhà nghiên cứu và kỹ sư học máy trên toàn cầu. Nhiều mô hình đột phá gần đây - từ LLaMA, Stable Diffusion đến Whisper - đều được công bố mã nguồn gốc bằng PyTorch (riêng Transformer năm 2017 và GPT, GPT-2 bản gốc được viết bằng TensorFlow). Điều làm cho PyTorch vượt trội hơn các framework khác chính là triết lý thiết kế Pythonic: mã nguồn PyTorch trông giống hệt code Python thuần túy, tương thích hoàn hảo với hệ sinh thái khoa học dữ liệu, và cho phép người lập trình đặt các điểm dừng debug (pdb hoặc print) ngay giữa các tầng mạng nơ-ron đang hoạt động.
Bài viết này cung cấp lộ trình hướng dẫn học PyTorch từ con số 0 dành cho lập trình viên: làm chủ bản chất cấu trúc Tensor, giải phẫu cơ chế tự động tính đạo hàm Autograd, xây dựng mạng nơ-ron tùy biến với nn.Module, và nắm vững vòng lặp huấn luyện chuẩn 5 bước không thể thiếu trong mọi dự án học sâu.
1. Cấu trúc Tensor và tăng tốc phần cứng GPU
Tensor là gì? So sánh Tensor và NumPy ndarray
Ở tầng sâu nhất, mọi thuật toán học sâu đều thao tác trên dữ liệu số nhiều chiều: ảnh màu là tensor 3 chiều (chiều cao, chiều rộng, kênh màu), chuỗi video là tensor 4 chiều (thời gian, chiều cao, chiều rộng, kênh màu), và một lô dữ liệu huấn luyện (batch) là tensor có thêm chiều batch size.
Một Tensor trong PyTorch là một mảng đa chiều chứa các phần tử có cùng kiểu dữ liệu số (như số thực 32-bit torch.float32, số nguyên torch.int64). Về mặt toán học và cú pháp, Tensor có tính chất gần như tương đồng với mảng ndarray của thư viện NumPy:
- Hỗ trợ đầy đủ các phép toán đại số tuyến tính: cộng, trừ, nhân từng phần tử (element-wise multiplication), nhân ma trận (
torch.matmulhoặc toán tử@), và biến đổi hình dạng (view,reshape). - Có thể chuyển đổi qua lại giữa PyTorch Tensor và NumPy ndarray với chi phí bộ nhớ bằng 0 (Zero-copy memory sharing) thông qua hàm
torch.from_numpy()và phương thức.numpy().
Tuy nhiên, Tensor trong PyTorch sở hữu hai siêu năng lực vượt trội mà NumPy không có:
- Khả năng chạy trên phần cứng tăng tốc: Tensor có thể được tải thẳng vào bộ nhớ VRAM của GPU (NVIDIA CUDA, Apple Silicon MPS, hoặc AMD ROCm) để thực hiện hàng tỷ phép tính song song mỗi giây.
- Khả năng tự động theo dõi đồ thị tính toán (Autograd): Từng phép tính tác động lên Tensor đều có thể được ghi lại để tự động tính đạo hàm phục vụ giải thuật lan truyền ngược.
Các thuộc tính cơ bản của Tensor
Mỗi đối tượng Tensor trong PyTorch được định nghĩa bởi ba thuộc tính sống còn:
shape(kích thước): Bộ số nguyên mô tả số lượng chiều và số phần tử trong mỗi chiều (ví dụtorch.Size([64, 3, 224, 224])).dtype(kiểu dữ liệu): Xác định độ chính xác số học của phần tử. Trong huấn luyện học sâu thông thường, kiểu mặc định làtorch.float32(Single Precision). Khi huấn luyện mô hình ngôn ngữ lớn hoặc mô hình thị giác khổng lồ, kỹ sư thường dùng kỹ thuật Mixed Precision vớitorch.float16hoặctorch.bfloat16để tiết kiệm một nửa dung lượng VRAM và tăng gấp đôi tốc độ xử lý trên Tensor Cores.device(thiết bị lưu trữ): Cho biết Tensor đang nằm trên bộ nhớ RAM của CPU (device='cpu') hay bộ nhớ VRAM của card đồ họa (device='cuda:0').
Thao tác chuyển đổi thiết bị (Device Agnostic Code)
Trong lập trình PyTorch thực chiến, mã nguồn cần phải chạy được một cách trong suốt trên mọi máy tính: máy có GPU rời NVIDIA, máy Mac chip Apple Silicon, hoặc máy tính thông thường chỉ có CPU. Đoạn mã mẫu chuẩn được viết như sau:
import torch
# Tự động chọn thiết bị tối ưu nhất hiện có
if torch.cuda.is_available():
device = torch.device("cuda")
elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
device = torch.device("mps") # Apple Silicon GPU
else:
device = torch.device("cpu")
# Khởi tạo tensor và đẩy trực tiếp lên thiết bị
x = torch.randn(3, 3, device=device)
print(f"Tensor đang nằm trên: {x.device}")
Lưu ý quan trọng: Hai tensor chỉ có thể thực hiện phép tính với nhau khi chúng cùng nằm trên cùng một thiết bị (device). Nếu bạn lấy một tensor trên CPU nhân với một tensor trên GPU, PyTorch sẽ lập tức ném ra lỗi ngoại lệ RuntimeError: Expected all tensors to be on the same device.
2. Cơ chế Autograd: Tự động tính đạo hàm và đồ thị động
Đồ thị tính toán tĩnh vs Đồ thị tính toán động (Define-by-Run)
Để hiểu tại sao PyTorch lại được cộng đồng đón nhận nồng nhiệt, chúng ta cần nhìn lại lịch sử. Các framework đời đầu như TensorFlow 1.x hay Theano sử dụng cơ chế Đồ thị tĩnh (Static Graph): lập trình viên phải định nghĩa toàn bộ cấu trúc đồ thị tính toán bằng code trước, sau đó "biên dịch" đồ thị này, rồi mới đẩy dữ liệu vào chạy thông qua một phiên làm việc (Session). Nhược điểm lớn của đồ thị tĩnh là cực kỳ khó gỡ lỗi: nếu xảy ra lỗi chia cho 0 hay lỗi shape bên trong mạng, dấu vết báo lỗi (stack trace) của Python chỉ trỏ tới hàm biên dịch chứ không chỉ ra dòng code nào đang chạy sai.
PyTorch áp dụng và phổ biến rộng rãi cơ chế Đồ thị động (Dynamic Computation Graph) với triết lý Define-by-Run (thiết kế do Chainer và DyNet đi trước):
- Đồ thị tính toán không tồn tại tĩnh từ trước. Thay vào đó, mỗi khi bạn thực hiện một phép tính bằng toán tử Python thông thường (như
c = a + b), PyTorch sẽ ghi lại phép tính đó vào một đồ thị có hướng không chu trình (Directed Acyclic Graph - DAG) trong bộ nhớ. - Khi luồng code rẽ nhánh bằng câu lệnh
if/elsehoặc lặp qua vòngforvới số bước thay đổi tùy ý theo độ dài câu văn, đồ thị tính toán sẽ tự động thích ứng và biến đổi linh hoạt theo thời gian thực. - Việc debug trở nên tự nhiên và dễ dàng: bạn có thể đặt lệnh
print(tensor.shape)hoặc dùng debugger của VS Code để kiểm tra từng giá trị trung gian ngay tại dòng lệnh đang thực thi.
Thuộc tính requires_grad và phương thức .backward()
Khi bạn muốn PyTorch tính đạo hàm riêng của một hàm mất mát đối với một tensor tham số (ví dụ trọng số \(W\) hoặc độ lệch \(b\)), bạn chỉ cần đặt cờ:
w = torch.tensor([2.0], requires_grad=True)
b = torch.tensor([1.0], requires_grad=True)
x = torch.tensor([3.0]) # Dữ liệu đầu vào không cần tính đạo hàm
y_true = torch.tensor([10.0])
# Lan truyền xuôi: PyTorch tự động dựng đồ thị tính toán
y_pred = w * x + b # y_pred = 2.0 * 3.0 + 1.0 = 7.0
loss = (y_pred - y_true)**2 # loss = (7.0 - 10.0)^2 = 9.0
# Lan truyền ngược: Tự động tính gradient theo quy tắc chuỗi
loss.backward()
# Truy xuất gradient đã tính:
print(f"dL/dw: {w.grad.item()}") # 2 * (y_pred - y_true) * x = 2 * (-3.0) * 3.0 = -18.0
print(f"dL/db: {b.grad.item()}") # 2 * (y_pred - y_true) = 2 * (-3.0) = -6.0
Khi phương thức loss.backward() được gọi, engine Autograd sẽ duyệt ngược từ nút gốc loss theo các cạnh của đồ thị tới các nút lá (leaf nodes) có requires_grad=True. Tại mỗi nút, nó áp dụng đạo hàm cục bộ và nhân dồn theo Quy tắc chuỗi (Chain Rule), sau đó lưu kết quả vào thuộc tính .grad của từng biến.
Ngắt đồ thị Autograd với torch.no_grad()
Trong giai đoạn kiểm thử mô hình (Inference / Evaluation), chúng ta không cần huấn luyện, không cập nhật trọng số, và không cần tính đạo hàm. Nếu vẫn để Autograd theo dõi các phép tính, PyTorch sẽ phải cấp phát thêm bộ nhớ để lưu trữ các giá trị kích hoạt phục vụ việc tính gradient, gây lãng phí từ \(30\%\) đến \(50\%\) dung lượng VRAM và làm chậm tốc độ suy luận.
Do đó, đoạn mã suy luận hoặc đánh giá mô hình bắt buộc phải được bao bọc trong khối ngữ cảnh:
model.eval() # Chuyển các tầng như Dropout, BatchNorm sang chế độ suy luận
with torch.no_grad():
predictions = model(test_inputs)
3. Thiết kế kiến trúc mạng nơ-ron với nn.Module
Trong PyTorch, mọi khối kiến trúc mạng - từ một tầng tuyến tính đơn giản, một khối Residual Block, một lớp Transformer Attention đến toàn bộ một mạng nơ-ron khổng lồ - đều được kế thừa từ lớp cơ sở torch.nn.Module.
Một lớp kế thừa nn.Module chuẩn mực có cấu trúc gồm hai phần:
- Phương thức khởi tạo
__init__(self, ...): Nơi chúng ta khai báo và khởi tạo tất cả các tầng mạng (layers) có chứa tham số học được (nhưnn.Linear,nn.Conv2d,nn.Embedding). - Phương thức lan truyền xuôi
forward(self, x): Nơi định nghĩa luồng dữ liệu đi qua các tầng mạng và các hàm kích hoạt phi tuyến (nhưtorch.relu,torch.sigmoid,F.gelu).
Dưới đây là một mô hình mạng nơ-ron đa tầng (Multi-Layer Perceptron - MLP) hoàn chỉnh giải quyết bài toán phân loại nhị phân:
import torch
import torch.nn as nn
import torch.nn.functional as F
class BinaryClassifier(nn.Module):
def __init__(self, input_dim, hidden_dim):
super(BinaryClassifier, self).__init__()
# Định nghĩa tầng ẩn và tầng đầu ra
self.fc1 = nn.Linear(input_dim, hidden_dim)
self.dropout = nn.Dropout(p=0.2)
self.fc2 = nn.Linear(hidden_dim, 1)
def forward(self, x):
# Dữ liệu đi qua tầng tuyến tính 1 -> hàm kích hoạt ReLU -> Dropout
h = F.relu(self.fc1(x))
h = self.dropout(h)
# Đi qua tầng tuyến tính 2 xuất ra logits
logits = self.fc2(h)
return logits
Lưu ý: Không bao giờ gọi trực tiếp model.forward(x). Thay vào đó, hãy gọi đối tượng mô hình như một hàm: outputs = model(x). Khi gọi trực tiếp mô hình, PyTorch không chỉ thực thi phương thức forward mà còn tự động kích hoạt các cơ chế gắn kèm (hooks) cần thiết cho việc profiling và lưu vết tensor.
Chủ đề này nằm trong Lecture 14 - Neural Networks của Khóa AI. Xem đề cương
4. Quản lý dữ liệu với Dataset và DataLoader
Một trong những sai lầm phổ biến nhất của người mới học là tải toàn bộ tập dữ liệu ảnh hoặc văn bản vào một mảng duy nhất trong RAM. Khi tập dữ liệu lên đến hàng trăm nghìn mẫu (hàng chục GB), chương trình sẽ ngay lập tức bị hệ điều hành tắt do lỗi tràn bộ nhớ (Out of Memory - OOM).
PyTorch giải quyết triệt để bài toán này thông qua hai lớp trừu tượng:
torch.utils.data.Dataset: Đại diện cho tập dữ liệu. Bạn có thể tự viết lớp Dataset tùy biến bằng cách ghi đè hai phương thức bắt buộc:__len__(self): Trả về tổng số lượng mẫu trong tập dữ liệu.__getitem__(self, idx): Đọc và trả về mẫu dữ liệu thứidxtừ ổ đĩa (kèm tiền xử lý dữ liệu theo thời gian thực). Nhờ đó, dữ liệu chỉ được nạp vào RAM đúng lúc cần thiết.
torch.utils.data.DataLoader: Một bộ lặp (iterator) bọc bên ngoàiDataset, tự động đảm nhiệm các công việc phức tạp:- Gom các mẫu đơn lẻ thành từng mẻ dữ liệu (Mini-batch) kích thước
batch_size. - Xáo trộn ngẫu nhiên dữ liệu (
shuffle=True) sau mỗi epoch để tránh mô hình học vẹt thứ tự mẫu. - Sử dụng đa tiến trình (
num_workers > 0) để nạp trước (prefetch) dữ liệu song song trong lúc GPU đang tính toán batch hiện tại, loại bỏ thời gian chết của phần cứng.
- Gom các mẫu đơn lẻ thành từng mẻ dữ liệu (Mini-batch) kích thước
from torch.utils.data import TensorDataset, DataLoader
# Tạo dữ liệu giả lập
features = torch.randn(1000, 10)
labels = torch.randint(0, 2, (1000, 1)).float()
dataset = TensorDataset(features, labels)
dataloader = DataLoader(dataset, batch_size=32, shuffle=True, num_workers=2)
for batch_features, batch_labels in dataloader:
print(f"Batch shape: {batch_features.shape}, Labels shape: {batch_labels.shape}")
break
5. Vòng lặp huấn luyện chuẩn 5 bước (The Standard Training Loop)
Toàn bộ quá trình huấn luyện bất kỳ mô hình học sâu nào trong PyTorch đều xoay quanh một vòng lặp tuần tự gồm 5 bước kinh điển. Việc hiểu sâu sắc cơ chế hoạt động của từng bước là chìa khóa để làm chủ PyTorch.
- Bước 1:
optimizer.zero_grad(): Trong PyTorch, mặc định các gradient.gradsẽ được cộng dồn (accumulate) sau mỗi lần gọi.backward(), chứ không tự động bị ghi đè. Lý do thiết kế này là để hỗ trợ kỹ thuật Gradient Accumulation (chia nhỏ batch lớn thành nhiều micro-batch khi VRAM bị giới hạn). Tuy nhiên, trong huấn luyện thông thường, nếu bạn quên gọioptimizer.zero_grad(), gradient của batch hiện tại sẽ bị cộng đè lên gradient của các batch trước, khiến giá trị đạo hàm tăng vọt và làm mô hình phát nổ trọng số. - Bước 2:
outputs = model(inputs)(Forward Pass): Đưa batch dữ liệu qua mạng để tính toán dự đoán đầu ra. Đồ thị tính toán động được tự động thiết lập cho batch này. - Bước 3:
loss = criterion(outputs, labels)(Compute Loss): Sử dụng hàm mất mát thích hợp (nhưnn.CrossEntropyLosscho phân loại hoặcnn.MSELosscho hồi quy) để đo lường sai khác giữa kết quả dự đoán và nhãn thực tế. - Bước 4:
loss.backward()(Backward Pass): Duyệt ngược đồ thị tính toán theo quy tắc chuỗi, tính toán đạo hàm riêng củalossđối với tất cả các tham số córequires_grad=Truevà lưu vào thuộc tính.grad. - Bước 5:
optimizer.step()(Update Parameters): Thuật toán tối ưu hóa (như Stochastic Gradient Descent - SGD, Adam, AdamW) đọc các giá trị đạo hàm.gradvà cập nhật lại trọng số của mô hình theo công thức tối ưu hóa: \[W_{\text{new}} = W_{\text{old}} - \eta \cdot \nabla_W L\]
6. Cài đặt thuật toán mô phỏng Autograd và một bước tối ưu SGD
Dưới đây là mã nguồn cài đặt độc lập mô phỏng cơ chế tính toán lan truyền xuôi, tự động tính gradient lan truyền ngược (Autograd engine mini) và thực hiện bước tối ưu hóa tham số SGD cho mô hình hồi quy tuyến tính \(y = w \cdot x + b\), được triển khai song song bằng Python và C++17.
#include <vector>
#include <cmath>
#include <tuple>
inline double round4(double val) {
return std::round(val * 10000.0) / 10000.0;
}
std::tuple<double, double, double, double, double> pytorch_linear_step(
const std::vector<double>& xs,
const std::vector<double>& ys,
double w,
double b,
double lr
) {
int n = xs.size();
if (n == 0) return {0.0, 0.0, 0.0, 0.0, 0.0};
double total_loss = 0.0;
double grad_w = 0.0;
double grad_b = 0.0;
for (int i = 0; i < n; ++i) {
double pred = w * xs[i] + b;
double diff = pred - ys[i];
total_loss += diff * diff;
grad_w += 2.0 * xs[i] * diff;
grad_b += 2.0 * diff;
}
double loss = total_loss / n;
grad_w /= n;
grad_b /= n;
double w_new = w - lr * grad_w;
double b_new = b - lr * grad_b;
return {round4(loss), round4(grad_w), round4(grad_b), round4(w_new), round4(b_new)};
}
def pytorch_linear_step(xs, ys, w, b, lr):
n = len(xs)
if n == 0:
return 0.0, 0.0, 0.0, 0.0, 0.0
# 1. Forward pass: compute predictions and MSE loss
preds = [w * x + b for x in xs]
diffs = [p - y for p, y in zip(preds, ys)]
loss = sum(d ** 2 for d in diffs) / n
# 2. Backward pass (Autograd): compute gradients dL/dw and dL/db
grad_w = sum(2.0 * x * d for x, d in zip(xs, diffs)) / n
grad_b = sum(2.0 * d for d in diffs) / n
# 3. Optimizer step (SGD)
w_new = w - lr * grad_w
b_new = b - lr * grad_b
return round(loss, 4), round(grad_w, 4), round(grad_b, 4), round(w_new, 4), round(b_new, 4)
7. Các lỗi hay gặp khi lập trình PyTorch và cách khắc phục
- Quên gọi
optimizer.zero_grad(): Như đã phân tích, nếu bạn không gọi hàm xóa gradient ở đầu mỗi bước lặp, gradient của batch hiện tại sẽ cộng dồn vào các batch trước. Hậu quả là bước nhảy tham số trở nên khổng lồ, khiến hàm mất mát không thể giảm mà sẽ dao động hỗn loạn hoặc phát nổ thành giá trịNaN(Not a Number). - Không chuyển mô hình sang
eval()khi đánh giá: Các tầng mạng nhưnn.Dropout(ngắt ngẫu nhiên nơ-ron) vànn.BatchNorm(chuẩn hóa dữ liệu theo thống kê trung bình của batch hiện tại) có hành vi hoàn toàn khác biệt giữa lúc huấn luyện và lúc suy luận. Nếu quên gọimodel.eval(), kết quả suy luận của bạn sẽ có tính ngẫu nhiên và không ổn định do Dropout vẫn đang hoạt động. Ngược lại, khi quay lại vòng huấn luyện, bạn bắt buộc phải gọi lạimodel.train(). - Giữ lại đồ thị Autograd trong các biến theo dõi (Memory Leak do Loss):
Khi muốn tính tổng hàm mất mát qua các batch để in ra màn hình, nhiều lập trình viên viết:
Vì biếntotal_loss += loss # LỖI TRÀN BỘ NHỚ VRAM!losslà một Tensor gắn liền với toàn bộ đồ thị tính toán Autograd của batch đó, việc cộng dồnlosssẽ giữ cho toàn bộ đồ thị của các batch trước không thể được giải phóng khỏi bộ nhớ VRAM, dẫn tới sập ứng dụng vì lỗi Out of Memory. Cách viết đúng chuẩn là:total_loss += loss.item() # Trích xuất số thực thuần túy của Python - Sử dụng sai hàm mất mát cho bài toán phân loại:
Trong PyTorch, hàm
nn.CrossEntropyLoss()đã tích hợp sẵn bên trong cả hàm kích hoạtLogSoftmaxlẫn hàm mất mátNLLLoss. Nếu ở tầng cuối cùng của mạng bạn đã thêm một lớpnn.Softmax(), sau đó lại truyền kết quả này vàonn.CrossEntropyLoss(), mô hình sẽ bị áp dụng Softmax hai lần liên tiếp, làm méo mó xác suất dự đoán và làm suy yếu nghiêm trọng gradient. Tầng cuối cùng của mô hình phân loại luôn phải xuất ra các giá trị Logits thô.
8. Câu hỏi thường gặp về PyTorch (FAQ)
Nên chọn PyTorch hay TensorFlow / Keras khi bắt đầu học AI?
Trong giai đoạn từ năm 2024 đến 2026, PyTorch là sự lựa chọn áp đảo trong giới học thuật và nghiên cứu công nghiệp. Phần lớn bài báo có dùng framework tại các hội nghị như CVPR, ICLR chọn PyTorch (thống kê năm 2019 của The Gradient: khoảng 69% ở CVPR, trên 50% ở ICLR). Hệ sinh thái mã nguồn mở hàng đầu như Hugging Face Transformers, vLLM, DeepSpeed đều ưu tiên tối ưu hóa tốt nhất trên nền tảng PyTorch. TensorFlow (kết hợp Keras) vẫn có chỗ đứng vững chắc trong các hệ thống doanh nghiệp cũ và thiết bị nhúng di động (TF Lite), nhưng nếu bạn muốn tiếp cận những kiến trúc AI hiện đại nhất (LLM, Vision Transformers), PyTorch là công cụ bắt buộc phải biết.
Sự khác nhau giữa view() và reshape() trong PyTorch là gì?
Cả hai phương thức đều dùng để thay đổi kích thước các chiều của Tensor. Tuy nhiên:
view()yêu cầu tensor phải nằm liên tục trong bộ nhớ (contiguous memory). Nếu bạn vừa thực hiện các phép biến đổi ma trận như chuyển vị (transposehaypermute), các phần tử không còn nằm liên tiếp trong RAM, khiếnview()báo lỗi.reshape()linh hoạt hơn: nếu tensor liên tục, nó hoạt động tương tựview(); nếu tensor không liên tục, nó sẽ tự động tạo một bản sao liên tục mới trong bộ nhớ rồi mới đổi shape (tương đương gọitensor.contiguous().view()).
Làm thế nào để lưu và tải mô hình PyTorch chuẩn kỹ thuật?
PyTorch khuyến nghị lưu lại trạng thái tham số trọng số (State Dict) thay vì lưu toàn bộ đối tượng lớp mô hình bằng pickle:
# Lưu trọng số của mô hình
torch.save(model.state_dict(), "model_weights.pth")
# Tải lại trọng số vào kiến trúc mạng
model = BinaryClassifier(input_dim=10, hidden_dim=32)
model.load_state_dict(torch.load("model_weights.pth"))
model.eval()
Cách lưu này giúp tệp mô hình có dung lượng nhẹ nhất, không phụ thuộc vào cấu trúc thư mục code khi triển khai lên máy chủ khác, và tránh được các lỗ hổng bảo mật liên quan đến việc deserialize mã độc.
9. Bài tập tự luyện kèm lời giải chi tiết
Bài tập 1: Xây dựng hàm kích hoạt tùy biến (Custom Activation)
Hãy viết một lớp kế thừa từ nn.Module cài đặt hàm kích hoạt LeakyReLU tùy biến theo công thức:
\[f(x) = \begin{cases} x & \text{nếu } x \ge 0 \\ \alpha \cdot x & \text{nếu } x \lt 0 \end{cases}\]
với tham số độ dốc \(\alpha = 0,01\). Kiểm tra giá trị đầu ra với tensor đầu vào \(x = [-2.0, 0.0, 3.0]\).
Lời giải chi tiết:
import torch
import torch.nn as nn
class CustomLeakyReLU(nn.Module):
def __init__(self, alpha=0.01):
super(CustomLeakyReLU, self).__init__()
self.alpha = alpha
def forward(self, x):
return torch.where(x >= 0, x, self.alpha * x)
# Kiểm tra thực tế
leaky_relu = CustomLeakyReLU(alpha=0.01)
input_tensor = torch.tensor([-2.0, 0.0, 3.0])
output_tensor = leaky_relu(input_tensor)
print("Kết quả:", output_tensor)
# Kết quả in ra: tensor([-0.0200, 0.0000, 3.0000])
Bài tập 2: Tính toán thủ công một bước lan truyền ngược của tầng Linear
Cho một tầng mạng nơ-ron tuyến tính đơn giản không có bias \(y = W \cdot x\) với một trọng số vô hướng \(W = 3,0\), đầu vào \(x = 2,0\), và nhãn thực tế \(y_{\text{true}} = 8,0\). Hàm mất mát là \(L = \frac{1}{2}(y - y_{\text{true}})^2\). Tốc độ học \(\eta = 0,1\).
- Tính giá trị dự đoán \(y\) và hàm mất mát \(L\).
- Tính gradient \(\frac{\partial L}{\partial W}\).
- Tính giá trị trọng số mới \(W_{\text{new}}\) sau một bước cập nhật SGD.
Lời giải chi tiết:
- Giá trị dự đoán: \(y = W \cdot x = 3,0 \times 2,0 = 6,0\). Hàm mất mát: \(L = \frac{1}{2}(6,0 - 8,0)^2 = \frac{1}{2}(-2,0)^2 = 2,0\).
- Đạo hàm riêng theo quy tắc chuỗi: \[\frac{\partial L}{\partial W} = \frac{\partial L}{\partial y} \cdot \frac{\partial y}{\partial W} = (y - y_{\text{true}}) \cdot x = (6,0 - 8,0) \times 2,0 = -4,0\]
- Cập nhật trọng số theo thuật toán SGD: \[W_{\text{new}} = W - \eta \cdot \frac{\partial L}{\partial W} = 3,0 - 0,1 \times (-4,0) = 3,0 + 0,4 = 3,4\] Sau một bước học, trọng số \(W\) tăng từ \(3,0\) lên \(3,4\), kéo giá trị dự đoán ở bước tiếp theo (\(3,4 \times 2 = 6,8\)) tiến gần hơn về phía nhãn mục tiêu \(8,0\).
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í.


