1. Giới Thiệu PyTorch

PyTorch là một thư viện mã nguồn mở cho học sâu (Deep Learning), được phát triển bởi Facebook AI Research (FAIR). Điểm mạnh cốt lõi của PyTorch bao gồm:

• API trực quan: Cú pháp lập trình mang phong cách Python (Pythonic), dễ đọc và dễ học.
• Đồ thị động (Dynamic Computation Graph): Cho phép thay đổi kiến trúc mạng ngay trong quá trình chạy (runtime), giúp việc debug (sửa lỗi) cực kỳ dễ dàng.
• Hệ thống Autograd: Tự động tính đạo hàm phục vụ cho việc cập nhật trọng số trong mạng nơ-ron.

So sánh nhanh: PyTorch và TensorFlow

Ghi nhớ nhanh:

PyTorch giống như "NumPy chạy trên GPU". Nó phù hợp cho người mới bắt đầu và các nhà nghiên cứu muốn thử nghiệm ý tưởng mới một cách linh hoạt.

2. Những Ứng Dụng Chính Của PyTorch

PyTorch là nền tảng đứng sau nhiều công nghệ AI đột phá hiện nay:

• Thị giác máy tính (Computer Vision): Nhận diện khuôn mặt, phân loại ảnh y tế, xe tự lái (YOLO, ResNet, Vision Transformers).
• Xử lý ngôn ngữ tự nhiên (NLP): Chatbot, dịch máy, tóm tắt văn bản (BERT, GPT, LLMs).
• Generative AI: Vẽ tranh từ văn bản, sáng tác nhạc (Stable Diffusion, GANs).
• Dự báo chuỗi thời gian: Dự đoán giá chứng khoán, thời tiết (LSTM, Transformer).

3. Kiến Thức Nền Tảng – Tensor

3.1. Tensor Là Gì?

Tensor là cấu trúc dữ liệu cơ bản nhất trong PyTorch. Nó là một mảng nhiều chiều (multi-dimensional array).
- Về mặt toán học: Giống ma trận (Matrix).
- Về mặt lập trình: Giống numpy.array, nhưng có thể chạy trên GPU để tính toán song song cực nhanh.

Code minh họa:

import torch

# 1. Tạo tensor từ list
x = torch.tensor([1, 2, 3])             # Vector 1 chiều
print(f"Tensor x: {x}")

# 2. Tạo ma trận toàn số 0 và số ngẫu nhiên
y = torch.zeros(2, 3)                   # Ma trận 2x3 toàn số 0
z = torch.rand(3, 2)                    # Ma trận 3x2 số ngẫu nhiên (0->1)

# 3. Truy xuất và thay đổi kích thước (Reshape)
print(f"Phần tử đầu tiên của x: {x[0]}")
print(f"Cột thứ 2 của y: {y[:, 1]}")
print(f"Chuyển z thành ma trận 2x3: \n{z.view(2, 3)}")

3.2. Cơ chế Autograd (Tự động tính đạo hàm)

Trong Deep Learning, để huấn luyện mạng, ta cần tính đạo hàm (Gradient) của hàm mất mát theo các trọng số. PyTorch làm việc này tự động.

Công thức ví dụ: $y = x^2 + 3x$. Đạo hàm $y' = 2x + 3$.

# requires_grad=True báo cho PyTorch biết cần theo dõi biến này
x = torch.tensor([2.0], requires_grad=True)

# Định nghĩa hàm số: y = x^2 + 3x
y = x**2 + 3*x

# Tính đạo hàm (Backward pass)
y.backward()

# In ra đạo hàm tại x = 2.0
# Kết quả mong đợi: 2*2 + 3 = 7
print(f"Đạo hàm của y tại x=2 là: {x.grad}")

4. Chi Tiết Quy Trình Huấn Luyện Mô Hình (Deep Dive)

Đây là phần quan trọng nhất. Để huấn luyện một mạng nơ-ron, chúng ta luôn tuân theo quy trình 5 bước chuẩn dưới đây.

Bước 1: Chuẩn Bị Dữ Liệu (Dataset & DataLoader)

Dữ liệu thô cần được chuyển thành Tensor và chia nhỏ để máy tính xử lý được.

• Dataset: Class chứa dữ liệu và nhãn (Input $X$ và Output $Y$).
• DataLoader: Công cụ giúp chia dữ liệu thành các gói nhỏ (mini-batch), hỗ trợ xáo trộn (shuffle) ngẫu nhiên để mô hình học tốt hơn.

import torch
from torch.utils.data import DataLoader, TensorDataset

# Giả sử dữ liệu: 100 mẫu, mỗi mẫu có 3 đặc trưng (features)
X = torch.randn(100, 3) 
# Nhãn tương ứng cho 100 mẫu (1 giá trị dự đoán)
Y = torch.randn(100, 1)

# Đóng gói vào Dataset
dataset = TensorDataset(X, Y)

# Tạo DataLoader: Lấy mỗi lần 10 mẫu, có xáo trộn
loader = DataLoader(dataset, batch_size=10, shuffle=True)

# Kiểm tra thử một batch
data_batch, label_batch = next(iter(loader))
print(f"Kích thước Input batch: {data_batch.shape}") # [10, 3]

Bước 2: Định Nghĩa Kiến Trúc Mô Hình (nn.Module)

Mọi mô hình trong PyTorch đều kế thừa từ lớp nn.Module. Cần định nghĩa 2 hàm:

1. __init__: Khai báo các lớp (Layer) sử dụng.
2. forward: Sắp xếp thứ tự các lớp (Dữ liệu đi như thế nào).

Ví dụ mạng đơn giản: Input (3) $\rightarrow$ Lớp ẩn (5) $\rightarrow$ Hàm kích hoạt ReLU $\rightarrow$ Output (1).

import torch.nn as nn

class SimpleNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.layer1 = nn.Linear(3, 5)  # Từ 3 đặc trưng lên 5 nơ-ron
        self.relu = nn.ReLU()          # Hàm phi tuyến
        self.layer2 = nn.Linear(5, 1)  # Từ 5 nơ-ron ra 1 kết quả

    def forward(self, x):
        # Dòng chảy dữ liệu
        out = self.layer1(x)
        out = self.relu(out)
        out = self.layer2(out)
        return out

model = SimpleNet()

Bước 3: Hàm Mất Mát (Loss) & Bộ Tối Ưu (Optimizer)

• Loss Function ($L$): Đo độ sai lệch giữa giá trị dự đoán ($\hat{y}$) và giá trị thực tế ($y$).
  • Bài toán hồi quy (số thực): Dùng MSELoss (Mean Squared Error). Công thức: $L = \frac{1}{n}\sum(y - \hat{y})^2$
  • Bài toán phân loại: Dùng CrossEntropyLoss.
• Optimizer: Thuật toán cập nhật trọng số để giảm Loss (ví dụ: SGD, Adam).

import torch.optim as optim

# Định nghĩa Loss: Trung bình bình phương sai số
criterion = nn.MSELoss()

# Định nghĩa Optimizer: Stochastic Gradient Descent (SGD)
# lr (learning rate) = 0.01: Tốc độ học
optimizer = optim.SGD(model.parameters(), lr=0.01)

Bước 4: Vòng Lặp Huấn Luyện (Training Loop)

Đây là nơi mô hình thực sự "học". Quy trình trong 1 vòng lặp (cho 1 batch) gồm 5 bước nhỏ bất di bất dịch:

1. Forward: Đưa dữ liệu qua mô hình $\rightarrow$ có kết quả dự đoán.
2. Loss Calculation: Tính sai số.
3. Zero Grad: Xóa gradient cũ (để không bị cộng dồn).
4. Backward: Tính gradient (đạo hàm ngược) từ Loss về các trọng số.
5. Step: Cập nhật trọng số mới dựa trên gradient.

# Giả lập chạy 1 Epoch (duyệt qua hết dữ liệu 1 lần)
for batch_x, batch_y in loader:

    # 1. Forward
    y_pred = model(batch_x)

    # 2. Tính Loss
    loss = criterion(y_pred, batch_y)

    # 3. Xóa gradient cũ
    optimizer.zero_grad()

    # 4. Tính gradient mới (Lan truyền ngược)
    loss.backward()

    # 5. Cập nhật trọng số
    optimizer.step()

print(f"Loss cuối cùng: {loss.item():.4f}")

Bước 5: Kiểm Tra Kết Quả (Evaluation)

Khi kiểm tra hoặc dùng thực tế, ta không cần tính gradient (để tiết kiệm bộ nhớ và chạy nhanh hơn).

model.eval() # Chuyển model sang chế độ đánh giá (tắt Dropout, Batchnorm...)

with torch.no_grad(): # Tắt Autograd
    test_input = torch.randn(1, 3)
    prediction = model(test_input)
    print(f"Dự đoán mẫu mới: {prediction.item()}")

5. Hướng Dẫn Nhanh (Step-by-Step Cheat Sheet)

Dưới đây là tóm tắt quy trình để bạn tra cứu nhanh:

B1: Cài Đặt

pip install torch torchvision

B2: Chọn thiết bị (GPU/CPU)

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# model.to(device)
# data.to(device)

B3: Code khung sườn (Skeleton)

# 1. Model
model = nn.Linear(10, 1).to(device)
# 2. Loss & Opt
loss_fn = nn.MSELoss()
opt = optim.Adam(model.parameters(), lr=0.001)
# 3. Loop
for x, y in dataloader:
    x, y = x.to(device), y.to(device)
    pred = model(x)
    loss = loss_fn(pred, y)
    opt.zero_grad()
    loss.backward()
    opt.step()

6. Ôn Tập – Câu Hỏi Nhanh

1. PyTorch Tensor khác gì NumPy array?
   • Đáp án: Tensor chạy được trên GPU và hỗ trợ Autograd (tính đạo hàm tự động).
2. Tại sao phải dùng optimizer.zero_grad()?
   • Đáp án: PyTorch mặc định cộng dồn gradient. Nếu không reset về 0, gradient vòng lặp sau sẽ bị cộng vào vòng trước, dẫn đến tính toán sai.
3. Hàm forward() dùng để làm gì?
   • Đáp án: Định nghĩa cách dữ liệu đi qua các lớp của mạng để tạo ra kết quả dự đoán.
4. Dataset và DataLoader khác nhau thế nào?
   • Đáp án: Dataset lưu trữ dữ liệu. DataLoader lấy dữ liệu từ Dataset, chia thành batch và đưa vào mô hình.

7. Các Khái Niệm Cốt Lõi Cần Nhớ

8. Kết Luận

PyTorch là một công cụ mạnh mẽ nhưng lại rất thân thiện nhờ tư duy lập trình hướng đối tượng rõ ràng.

Để làm chủ PyTorch, bạn chỉ cần nắm vững: Tensor $\rightarrow$ Autograd $\rightarrow$ nn.Module $\rightarrow$ Training Loop. Khi hiểu rõ luồng dữ liệu đi qua 4 thành phần này, bạn có thể xây dựng bất kỳ mô hình AI hiện đại nào.

Tài liệu tham khảo

1. PyTorch Official Tutorials
2. PyTorch Basics Intro
3. PyTorch Tutorial for Deep Learning Researchers (Github)
4. Markdown Guide