Thông báo: Download 4 khóa học Python từ cơ bản đến nâng cao tại đây.
Mạng Nơ-Ron truyền thẳng (Feed Forward Neural Network) trong PyTorch
Trong bài này, mình sẽ triển khai mạng nơ-ron nhiều lớp đầu tiên (multilayer neural network) để thực hiện phân loại chữ số trên tập dữ liệu nổi tiếng MNIST. Đây là bài toán cơ bản trong lĩnh vực học sâu, nơi mô hình cần nhận diện chữ số viết tay từ hình ảnh đầu vào.


Triển khai mạng nơ-ron trong PyTorch
Cấu hình thiết bị (Device Configuration)
Xác định xem chúng ta sẽ sử dụng GPU hay CPU.
import torch
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
Cài đặt siêu tham số (Hyperparameters)
input_size: Số đặc trưng đầu vào (28x28 = 784).hidden_size: Số nơ-ron trong lớp ẩn (500).num_classes: Số lớp cần phân loại (10 chữ số: 0–9).num_epochs: Số lần duyệt qua toàn bộ dữ liệu.batch_size: Số lượng mẫu trong mỗi batch.learning_rate: Tốc độ học của mô hình.
input_size = 784 # 28x28 hidden_size = 500 num_classes = 10 num_epochs = 2 batch_size = 100 learning_rate = 0.001
Tải và chuyển đổi dữ liệu MNIST
import torchvision
import torchvision.transforms as transforms
# Tải tập dữ liệu huấn luyện và kiểm tra
train_dataset = torchvision.datasets.MNIST(root='./data',
train=True,
transform=transforms.ToTensor(),
download=True)
test_dataset = torchvision.datasets.MNIST(root='./data',
train=False,
transform=transforms.ToTensor())
Tạo DataLoader để tải dữ liệu theo batch
from torch.utils.data import DataLoader train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True) test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)
Hiển thị một vài hình ảnh trong tập dữ liệu
import matplotlib.pyplot as plt
examples = iter(test_loader)
example_data, example_targets = examples.next()
for i in range(6):
plt.subplot(2, 3, i + 1)
plt.imshow(example_data[i][0], cmap='gray')
plt.show()
Xây dựng mạng nơ-ron (Neural Network)
Định nghĩa kiến trúc mạng
Mạng gồm ba lớp:
- Lớp đầu vào (input layer).
- Lớp ẩn (hidden layer).
- Lớp đầu ra (output layer).
import torch.nn as nn
class NeuralNet(nn.Module):
def __init__(self, input_size, hidden_size, num_classes):
super(NeuralNet, self).__init__()
self.l1 = nn.Linear(input_size, hidden_size) # Lớp đầu vào
self.relu = nn.ReLU() # Hàm kích hoạt
self.l2 = nn.Linear(hidden_size, num_classes) # Lớp đầu ra
def forward(self, x):
out = self.l1(x) # Truyền dữ liệu qua lớp đầu vào
out = self.relu(out) # Áp dụng hàm kích hoạt
out = self.l2(out) # Truyền dữ liệu qua lớp đầu ra
return out
Khởi tạo mô hình và chuyển sang thiết bị
model = NeuralNet(input_size, hidden_size, num_classes).to(device)
Thiết lập hàm mất mát và bộ tối ưu
- Hàm mất mát:
CrossEntropyLoss - Bộ tối ưu:
Adam
criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
Vòng lặp huấn luyện (Training Loop) trong PyTorch
- Chuyển đổi đầu vào từ ma trận 28x28 thành vector 784.
- Tính toán dự đoán, mất mát, và thực hiện quá trình tối ưu hóa.
n_total_steps = len(train_loader)
for epoch in range(num_epochs):
for i, (images, labels) in enumerate(train_loader):
images = images.reshape(-1, 28*28).to(device)
labels = labels.to(device)
# Forward pass
outputs = model(images)
loss = criterion(outputs, labels)
# Backward pass và tối ưu
optimizer.zero_grad()
loss.backward()
optimizer.step()
if (i + 1) % 100 == 0:
print(f'Epoch [{epoch+1}/{num_epochs}], Step [{i+1}/{n_total_steps}], Loss: {loss.item():.4f}')
Kiểm tra mô hình (Testing the Model)
- Đánh giá mô hình trên tập dữ liệu kiểm tra.
- Tính toán độ chính xác dựa trên dự đoán và nhãn thực tế.
with torch.no_grad():
n_correct = 0
n_samples = 0
for images, labels in test_loader:
images = images.reshape(-1, 28*28).to(device)
labels = labels.to(device)
outputs = model(images)
_, predicted = torch.max(outputs.data, 1)
n_samples += labels.size(0)
n_correct += (predicted == labels).sum().item()
acc = 100.0 * n_correct / n_samples
print(f'Dộ chính xác của mạng trên 10,000 hình kiểm tra: {acc} %')
Kết bài
Mình vừa triển khai thành công mạng nơ-ron truyền thẳng (Feed Forward Neural Network) trong PyTorch để giải bài toán phân loại chữ số viết tay. Mạng này bao gồm đầy đủ các bước từ chuẩn bị dữ liệu, xây dựng mạng nơ-ron, huấn luyện, và đánh giá mô hình. Đây là một ví dụ cơ bản và quan trọng để bắt đầu với học sâu trong PyTorch.
Bài viết này được đăng tại [free tuts .net]

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