Thông báo: Download 4 khóa học Python từ cơ bản đến nâng cao tại đây.
Hồi quy Logistic trong PyTorch Beginner
Trong phần này, mình sẽ triển khai thuật toán Logistic Regression (hồi quy logistic) bằng PyTorch và áp dụng các khái niệm đã học. Mục tiêu chính là phân loại nhị phân một cách hiệu quả bằng việc sử dụng mạng nơ-ron đơn giản kết hợp hàm kích hoạt sigmoid.

Logistic Regression (hồi quy logistic) bằng PyTorch
Pipeline này bao gồm các bước:
- Chuẩn bị dữ liệu từ tập Breast Cancer trong
sklearn. - Chuẩn hóa dữ liệu (feature scaling) để đảm bảo tốc độ hội tụ nhanh hơn.
- Thiết kế mô hình hồi quy logistic với một lớp tuyến tính kèm hàm sigmoid để đưa ra xác suất.
- Định nghĩa hàm mất mát (Binary Cross-Entropy) và trình tối ưu hóa (SGD).
- Vòng lặp huấn luyện, kiểm tra hiệu năng của mô hình trên dữ liệu kiểm tra (Accuracy).
import torch
import torch.nn as nn
import numpy as np
from sklearn import datasets
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
# 0) Chuẩn bị dữ liệu
bc = datasets.load_breast_cancer()
X, y = bc.data, bc.target # Đặc trưng (features) và nhãn (labels)
n_samples, n_features = X.shape # Số mẫu và số đặc trưng
# Tách dữ liệu thành tập huấn luyện và kiểm tra (80% huấn luyện, 20% kiểm tra)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1234)
# Chuẩn hóa dữ liệu bằng StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)
# Chuyển dữ liệu thành Tensor của PyTorch
X_train = torch.from_numpy(X_train.astype(np.float32))
X_test = torch.from_numpy(X_test.astype(np.float32))
y_train = torch.from_numpy(y_train.astype(np.float32))
y_test = torch.from_numpy(y_test.astype(np.float32))
# Điều chỉnh y thành vector cột
y_train = y_train.view(y_train.shape[0], 1)
y_test = y_test.view(y_test.shape[0], 1)
# 1) Mô hình
# Thiết kế hồi quy logistic f(x) = sigmoid(wx + b)
class Model(nn.Module):
def __init__(self, n_input_features):
super(Model, self).__init__()
self.linear = nn.Linear(n_input_features, 1) # Lớp tuyến tính wx + b
def forward(self, x):
y_pred = torch.sigmoid(self.linear(x)) # Thêm sigmoid để xuất ra xác suất
return y_pred
model = Model(n_features)
# 2) Định nghĩa hàm mất mát và trình tối ưu hóa
num_epochs = 100
learning_rate = 0.01
# Hàm mất mát: Binary Cross Entropy (mất mát cho phân loại nhị phân)
criterion = nn.BCELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
# 3) Vòng lặp huấn luyện
for epoch in range(num_epochs):
# Tính toán (forward pass) và mất mát
y_pred = model(X_train)
loss = criterion(y_pred, y_train)
# Lan truyền ngược (backward pass) và cập nhật tham số
loss.backward()
optimizer.step()
# Xóa gradient trước khi bước lặp mới
optimizer.zero_grad()
if (epoch + 1) % 10 == 0:
print(f'Epoch: {epoch+1}, Loss = {loss.item():.4f}')
# Đánh giá trên tập kiểm tra
with torch.no_grad():
y_predicted = model(X_test) # Dự đoán xác suất
y_predicted_cls = y_predicted.round() # Làm tròn để phân loại (0 hoặc 1)
acc = y_predicted_cls.eq(y_test).sum() / float(y_test.shape[0]) # Tính độ chính xác
print(f'Dộ chính xác: {acc.item():.4f}')
Giải thích từng phần
Bước 0: Chuẩn bị dữ liệu
- Dữ liệu Breast Cancer có 569 mẫu và 30 đặc trưng.
- Các đặc trưng được chuẩn hóa bằng
StandardScalerđể đảm bảo mọi giá trị đầu vào có cùng quy mô. - Dữ liệu được chia thành:
- Tập huấn luyện (80% dữ liệu) để dạy mô hình.
- Tập kiểm tra (20% dữ liệu) để đánh giá hiệu năng sau khi mô hình đã học.
Bước 1: Thiết kế mô hình
- Mô hình hồi quy logistic sử dụng lớp tuyến tính để tính toán giá trị dự đoán.
- Hàm kích hoạt sigmoid được thêm vào đầu ra của mô hình, chuyển giá trị dự đoán thành xác suất trong khoảng .
Bước 2: Định nghĩa hàm mất mát và trình tối ưu hóa
- Hàm mất mát (BCELoss):
Binary Cross-Entropy Loss xử lý bài toán phân loại nhị phân, tính toán mức độ "khớp" giữa xác suất dự đoán và nhãn thực tế. - Trình tối ưu hóa (SGD):
Sử dụng thuật toán gradient descent ngẫu nhiên để cập nhật trọng số dựa trên gradient của hàm mất mát.
Bước 3: Huấn luyện mô hình
- Trong mỗi epoch:
- Forward pass: Dự đoán xác suất với tập huấn luyện.
- Backward pass: Tính gradient của lỗi theo các tham số.
- Cập nhật tham số: Trình tối ưu hóa điều chỉnh trọng số và bias .
- Xóa gradient: Đặt lại gradient trước khi bước lặp tiếp theo.
Bước 4: Kiểm tra độ chính xác
- Với dữ liệu kiểm tra, mô hình dự đoán xác suất, sau đó làm tròn về 0 hoặc 1.
- Đo lường độ chính xác dựa trên tỷ lệ dự đoán đúng so với tổng mẫu.
Kết quả mong đợi
- Quá trình huấn luyện:
Mất mát giảm dần sau mỗi epoch, ví dụ:
Epoch: 10, Loss = 0.5432 Epoch: 20, Loss = 0.4321 ... Epoch: 100, Loss = 0.2134
- Độ chính xác:
Ví dụ, mô hình có thể đạt được độ chính xác trên tập kiểm tra.
Kết bài
Mô hình hồi quy logistic đơn giản này minh họa quy trình cơ bản của học sâu với PyTorch. Từ đây, bạn có thể mở rộng sang các bài toán phức tạp hơn như:
- Phân loại đa nhãn (multi-class classification).
- Kết hợp với các kỹ thuật tăng cường hiệu năng như điều chỉnh tham số (hyperparameter tuning).
Hồi quy logistic không chỉ mạnh mẽ mà còn dễ hiểu, là bước đệm quan trọng để đi sâu vào học sâu (deep learning).
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