Các kiểu dữ liệu trong C ( int - float - double - char ...) 
Thuật toán tìm ước chung lớn nhất trong C/C++ 
Cấu trúc lệnh switch case trong C++ (có bài tập thực hành) 
ComboBox - ListBox trong lập trình C# winforms 
Random trong Python: Tạo số random ngẫu nhiên 
Lệnh cin và cout trong C++ 
Cách khai báo biến trong PHP, các loại biến thường gặp 
Download và cài đặt Vertrigo Server 
Thẻ li trong HTML 
Thẻ article trong HTML5 
Cấu trúc HTML5: Cách tạo template HTML5 đầu tiên 
Cách dùng thẻ img trong HTML và các thuộc tính của img 
Thẻ a trong HTML và các thuộc tính của thẻ a thường dùng Thông báo: Download 4 khóa học Python từ cơ bản đến nâng cao tại đây.
Training Pipeline trong PyTorch Beginner
Trong phần này, chúng ta sẽ cải thiện mã nguồn từ phần trước để xây dựng một training pipeline hoàn chỉnh trong PyTorch. Chúng ta sẽ thay thế việc tính toán thủ công cho hàm lỗi và cập nhật trọng số bằng các hàm hỗ trợ sẵn từ PyTorch, như hàm mất mát (loss) và trình tối ưu hóa (optimizer). Đồng thời, chúng ta cũng tìm hiểu cách định nghĩa một mô hình PyTorch và sử dụng nó để thực hiện quá trình huấn luyện tự động, bao gồm các bước: forward pass, backward pass, và cập nhật trọng số.
Training Pipeline trong PyTorch
.jpg)
Pipeline gồm ba bước chính:
- Thiết kế mô hình (Design Model): Xác định input, output và hàm dự đoán (forward pass).
- Định nghĩa hàm lỗi (Loss) và trình tối ưu hóa (Optimizer).
- Vòng lặp huấn luyện (Training Loop): Thực hiện dự đoán, tính toán mất mát, gradient và cập nhật trọng số.
Mã nguồn: Giới thiệu hàm Loss và Optimizer
import torch
import torch.nn as nn
# Hồi quy tuyến tính (Linear Regression)
# Hàm: f = w * x, với f = 2 * x
# 0) Dữ liệu huấn luyện
X = torch.tensor([1, 2, 3, 4], dtype=torch.float32)
Y = torch.tensor([2, 4, 6, 8], dtype=torch.float32)
# 1) Thiết kế mô hình: Khởi tạo trọng số và hàm dự đoán
w = torch.tensor(0.0, dtype=torch.float32, requires_grad=True)
def forward(x):
return w * x
print(f'Dự đoán trước khi huấn luyện: f(5) = {forward(5).item():.3f}')
# 2) Định nghĩa hàm lỗi và trình tối ưu hóa
learning_rate = 0.01
n_iters = 100
loss = nn.MSELoss() # Hàm lỗi Mean Squared Error (MSE)
optimizer = torch.optim.SGD([w], lr=learning_rate) # Stochastic Gradient Descent (SGD)
# 3) Vòng lặp huấn luyện
for epoch in range(n_iters):
# Dự đoán (forward pass)
y_predicted = forward(X)
# Tính toán lỗi
l = loss(Y, y_predicted)
# Gradient (backward pass)
l.backward()
# Cập nhật trọng số
optimizer.step()
# Reset gradient về 0
optimizer.zero_grad()
if epoch % 10 == 0:
print(f'epoch {epoch+1}: w = {w.item():.3f}, loss = {l.item():.6f}')
print(f'Dự đoán sau khi huấn luyện: f(5) = {forward(5).item():.3f}')
Giới thiệu class mô hình trong PyTorch
Trong ví dụ này, thay vì viết hàm dự đoán thủ công, chúng ta sẽ sử dụng model class của PyTorch để định nghĩa một mô hình hồi quy tuyến tính.
Mã nguồn:
import torch
import torch.nn as nn
# Hồi quy tuyến tính (Linear Regression)
# Hàm: f = w * x, với f = 2 * x
# 0) Dữ liệu huấn luyện
X = torch.tensor([[1], [2], [3], [4]], dtype=torch.float32)
Y = torch.tensor([[2], [4], [6], [8]], dtype=torch.float32)
n_samples, n_features = X.shape
print(f'#samples: {n_samples}, #features: {n_features}')
# Tạo dữ liệu kiểm tra
X_test = torch.tensor([[5]], dtype=torch.float32)
# 1) Thiết kế mô hình: Sử dụng lớp Linear của PyTorch
input_size = n_features
output_size = n_features
model = nn.Linear(input_size, output_size)
# Hoặc tự định nghĩa lớp LinearRegression:
'''
class LinearRegression(nn.Module):
def __init__(self, input_dim, output_dim):
super(LinearRegression, self).__init__()
self.lin = nn.Linear(input_dim, output_dim)
def forward(self, x):
return self.lin(x)
model = LinearRegression(input_size, output_size)
'''
print(f'Dự đoán trước khi huấn luyện: f(5) = {model(X_test).item():.3f}')
# 2) Định nghĩa hàm lỗi và trình tối ưu hóa
learning_rate = 0.01
n_iters = 100
loss = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
# 3) Vòng lặp huấn luyện
for epoch in range(n_iters):
# Dự đoán (forward pass) bằng mô hình
y_predicted = model(X)
# Tính toán lỗi
l = loss(Y, y_predicted)
# Gradient (backward pass)
l.backward()
# Cập nhật trọng số
optimizer.step()
# Reset gradient về 0
optimizer.zero_grad()
if epoch % 10 == 0:
[w, b] = model.parameters() # Lấy giá trị trọng số và bias
print(f'epoch {epoch+1}: w = {w[0][0].item():.3f}, loss = {l.item():.6f}')
print(f'Dự đoán sau khi huấn luyện: f(5) = {model(X_test).item():.3f}')
Giải thích chi tiết
Thiết kế mô hình:
Bài viết này được đăng tại [free tuts .net]
- Lớp
nn.Linear: Đây là lớp được định nghĩa sẵn trong PyTorch, đại diện cho mô hình hồi quy tuyến tính. - Thay vì tự quản lý trọng số và hàm forward, PyTorch quản lý chúng giúp chúng ta.
Hàm lỗi (nn.MSELoss): Tự động tính toán lỗi giữa giá trị dự đoán và giá trị thực tế.
Trình tối ưu hóa (torch.optim.SGD): Tự động cập nhật các tham số của mô hình dựa trên gradient được tính.
Cách dùng class model:
- Xây dựng mô hình dễ tái sử dụng hơn, có thể thêm nhiều lớp phức tạp hơn cho các mô hình sau này.
Kết quả mong đợi
- Sau quá trình huấn luyện, giá trị trọng số sẽ tiến gần đến 2.0, giúp mô hình dự đoán chính xác.
- Quá trình huấn luyện được tự động hóa và ngắn gọn hơn nhờ PyTorch.
Kết bài
Bằng cách sử dụng nn.Module, nn.MSELoss, và torch.optim, việc xây dựng mô hình, tính toán lỗi, và tối ưu hóa đã trở nên rất dễ dàng trong PyTorch. Đây là nền tảng quan trọng để bạn xây dựng các mô hình học sâu phức tạp sau này.
