Giới thiệu tổng quan về Mạng Nơ-ron Nhân tạo (ANN)
Mạng nơ-ron nhân tạo hiện nay đóng vai trò nền tảng trong nhiều lĩnh vực ứng dụng trí tuệ nhân tạo, từ dự báo chuỗi thời gian đến nhận diện hình ảnh và xử lý giọng nói. Mặc dù các thuật toán này đã tồn tại lâu năm, nhưng việc hiểu rõ cơ chế nội tại của chúng—đặc biệt là quy trình lan truyền ngược (Backpropagation)—thường gặp khó khăn do tài liệu giảng dạy phân tán hoặc thiếu thống nhất về ký hiệu toán học.
Cốt lõi của phương pháp mạng nơ-ron mô phỏng cấu trúc sinh học của não bộ. Dữ liệu đầu vào được xử lý qua các lớp trung gian nhờ sự kết hợp của hai tham số chính: Trọng số (Weight - w) và Độ lệch (Bias - b). Quá trình tính toán tuân theo một hàm chuyển đổi phi tuyến gọi là Hàm kích hoạt (Activation Function), quyết định tín hiệu nào sẽ được truyền tới nơ-ron tiếp theo.
Mục tiêu tối thượng của mô hình là tìm ra một hàm ánh xạ $f(x)$ sao cho sai số giữa giá trị dự đoán $\hat{y}$ và giá trị thực tế $y$ là nhỏ nhất. Ví dụ điển hình bao gồm phân loại nhãn động vật dựa trên pixel ảnh hoặc dự báo nhu cầu thị trường từ dữ liệu lịch sử.
- BP Neural Network: Tên gọi tắt của mạng dùng thuật toán lan truyền ngược để cập nhật trọng số.
- Feedforward Network: Chỉ hướng đi xuôi của thông tin, thường đi kèm với quá trình điều chỉnh sai số ngược lại.
1. Cơ chế toán học của mạng nơ-ron
Tư tưởng cốt lõi tương đồng với bài toán hồi quy trong thống kê: Sử dụng phương pháp bình phương tối thiểu để tìm tham số tối ưu. Cụ thể, bài toán tối ưu hóa chọn tập trọng số $\{w_i\}$ nhằm cực tiểu hóa tổng bình phương sai số giữa đầu ra dự báo và dữ liệu gốc.
Về mặt kiến trúc, một mạng có thể đơn giản chỉ gồm lớp đầu vào và lớp đầu ra, nhưng cũng có thể phức tạp với nhiều lớp ẩn (hidden layers). Quá trình huấn luyện diễn ra theo hai pha:
- Lan truyền thuận: Tính toán giá trị đầu ra dựa trên trạng thái hiện tại của trọng số.
- Lan truyền nghịch: Tính gradient của hàm mất mát theo từng tham số để điều chỉnh lại hệ thống, giúp giảm thiểu sai số dần dần.
2. Các hàm kích hoạt phổ biến
Hàm kích hoạt đưa tính phi tuyến vào mạng, giúp mạng học được các mối quan hệ phức tạp. Dưới đây là những dạng hàm thường gặp nhất:
2.1. Hàm Sigmoid (Logistic)
Có công thức: $f(x) = \frac{1}{1 + e^{-x}}$. Đạo hàm là $f'(x) = f(x)(1 - f(x))$.
- Tiện ích: Đầu ra nằm trong khoảng (0, 1), thích hợp để biểu diễn xác suất.
- Hạn chế: Dễ gây ra hiện tượng "tiêu biến gradient" (vanishing gradient) khi đầu vào quá lớn hoặc quá nhỏ, làm chậm quá trình hội tụ.
2.2. Hàm Tanh
Công thức: $f(x) = \tanh(x) = \frac{e^x - e^{-x}}{e^x + e^{-x}}$. Dao động quanh 0.
- Tiềm năng: Vì đầu ra là (-1, 1), trung bình đầu ra gần 0 hơn so với Sigmoid, giúp mạng hội tụ nhanh hơn trong các tầng ẩn.
- Hạn chế: Vẫn gặp vấn đề về đạo hàm ở phần đuôi vùng bão hòa.
2.3. Hàm ReLU (Rectified Linear Unit)
Công thức: $f(x) = \max(0, x)$.
- Ưu điểm: Tính toán rất nhẹ, không bị bão hòa gradient ở miền dương ($x > 0$).
- Nhược điểm: Vấn đề "Neuron chết" (Dead ReLU): Nếu đầu vào âm liên tục, gradient sẽ bằng 0 và trọng số không được cập nhật nữa.
2.4. Các biến thể khác
Bao gồm Leaky ReLU (khắc phục neuron chết bằng cách cho phép đầu vào âm đi qua với một độ dốc nhỏ), ELU (mượt mà hơn ở vùng âm), và Softmax (chuyên dùng cho lớp đầu ra đa lớp để chuẩn hóa thành phân phối xác suất tổng bằng 1).
2.5. Swish
Công thức: $f(x) = x \cdot \sigma(x)$. Đây là hàm được Google đề xuất, có khả năng mượt mà vượt trội so với ReLU, đặc biệt tốt trong các mạng sâu.
3. Hàm mất mát và Tối ưu hóa
Để đánh giá chất lượng mô hình, ta sử dụng các hàm lỗi:
- MSE (Mean Squared Error): Thích hợp cho bài toán hồi quy.
$$ E = \frac{1}{N}\sum (\hat{y}_i - y_i)^2 $$ - MAE (Mean Absolute Error): Ít nhạy cảm với ngoại lai hơn MSE.
- Cross Entropy: Tiêu chuẩn vàng cho bài toán phân loại (classification).
Sau khi tính được lỗi, cần điều chỉnh tham số bằng thuật toán Stochastic Gradient Descent (SGD). Nguyên tắc là di chuyển trọng số theo hướng ngược lại với gradient của hàm mất mát.
3.1. Công thức Lan truyền ngược (Backpropagation)
Gọi $\delta_j$ là sai số tích lũy tại nơ-ron $j$, công thức chung để tính gradient dựa trên quy tắc chuỗi (Chain Rule):
- Tầng đầu ra: $\delta_{out} = (\hat{y} - y) \cdot f'(z)$
- Tầng ẩn: $\delta_j = f'(z_j) \sum_k (\delta_k \cdot w_{kj})$
- Cập nhật trọng số: $w_{new} = w_{old} - \eta \cdot \delta_j \cdot o_{input}$
Trong đó $\eta$ là tốc độ học (Learning rate).
3.2. Thuật toán ADAM
SGD đôi khi bị dao động hoặc hội tụ chậm. ADAM (Adaptive Moment Estimation) cải thiện điều này bằng cách ước lượng cả momen bậc 1 (trung bình gradient) và momen bậc 2 (vô trung bình bình phương gradient), tự động điều chỉnh tốc độ học cho từng tham số riêng lẻ. Tham số thường dùng cho ADAM: $\beta_1=0.9, \beta_2=0.999$.
4. Minh họa triển khai bằng C++
Dưới đây là ví dụ về việc xây dựng một mạng nơ-ron đơn giản để giải quyết bài toán hồi quy đa biến bằng ngôn ngữ lập trình C++. Mã nguồn này tách biệt rõ ràng phần tiền xử lý, tính toán truyền thuận và lan truyền ngược.
/**
* File: regression_nn.cpp
* Description: Implementing a simple Feedforward Neural Network
* for regression task using C++17. Focuses on manual implementation
* of Forward Pass and Backpropagation without external libraries.
*/
#include <iostream>
#include <vector>
#include <cmath>
#include <random>
#include <algorithm>
#include <numeric>
// Cấu trúc lưu trữ trọng số và độ lệch cho một lớp
struct Layer {
std::vector weights; // weights[row][col]
std::vector<double> biases;
void init(int in_size, int out_size, double scale) {
weights.resize(out_size, std::vector<double>(in_size));
biases.resize(out_size);
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_real_distribution<> distr(-scale, scale);
for (auto& row : weights) {
std::generate(row.begin(), row.end(), [&]() { return distr(gen); });
}
std::generate(biases.begin(), biases.end(), [&]() { return distr(gen); });
}
};
class SimpleNN {
private:
std::vector<Layer> layers;
size_t num_layers;
double learning_rate;
public:
SimpleNN(std::vector<int> architecture, double lr)
: learning_rate(lr), num_layers(architecture.size() - 1) {
layers.reserve(num_layers);
for (size_t i = 0; i < num_layers; ++i) {
layers.emplace_back();
layers.back().init(architecture[i], architecture[i+1], 0.5);
}
}
// Hàm kích hoạt Sigmoid
double sigmoid(double x) { return 1.0 / (1.0 + exp(-x)); }
// Đạo hàm Sigmoid
double d_sigmoid(double y) { return y * (1.0 - y); }
// Lan truyền thuận (Forward Pass)
std::vector<double> forward(const std::vector<double>& input) {
std::vector<double> current_layer(input);
for (int l = 0; l < num_layers; ++l) {
std::vector<double> next_layer(layers[l].biases.size());
// Tính tổng z = w*x + b
std::vector<double> z_values(next_layer.size());
for (size_t j = 0; j < next_layer.size(); ++j) {
double sum = layers[l].biases[j];
for (size_t k = 0; k < current_layer.size(); ++k) {
sum += layers[l].weights[j][k] * current_layer[k];
}
z_values[j] = sum;
}
// Áp dụng kích hoạt
for (size_t j = 0; j < next_layer.size(); ++j) {
next_layer[j] = sigmoid(z_values[j]);
}
current_layer = next_layer;
}
return current_layer;
}
// Huấn luyện trên một mẫu dữ liệu
double train_step(const std::vector<double>& input, const std::vector<double>& target) {
// Bước 1: Forward pass và lưu các kích hoạt trung gian
std::vector activations;
activations.push_back(input);
std::vector net_inputs;
for (int l = 0; l < num_layers; ++l) {
// Tính z trước khi kích hoạt để dùng cho backprop sau
std::vector<double> z_list(layers[l].biases.size());
for (size_t j = 0; j < layers[l].biases.size(); ++j) {
double sum = layers[l].biases[j];
for (size_t k = 0; k < activations.back().size(); ++k) {
sum += layers[l].weights[j][k] * activations.back()[k];
}
z_list[j] = sum;
}
net_inputs.push_back(z_list);
std::vector<double> out_list;
for (double val : z_list) {
out_list.push_back(sigmoid(val));
}
activations.push_back(out_list);
}
double total_loss = 0.0;
// Bước 2: Tính gradient ngược (Backpropagation)
// Bắt đầu từ đầu ra
std::vector<double> deltas;
std::vector<double> last_activation = activations[activations.size()-1];
std::vector<double> last_net = net_inputs.back();
for (size_t k = 0; k < last_activation.size(); ++k) {
double err = target[k] - last_activation[k];
double grad = err * d_sigmoid(last_activation[k]);
deltas.push_back(grad);
total_loss += 0.5 * err * err;
}
// Quay ngược lại các lớp ẩn
for (int l = num_layers - 2; l >= 0; --l) {
std::vector<double> layer_delta(layers[l].biases.size());
for (size_t j = 0; j < layer_delta.size(); ++j) {
double sum = 0.0;
for (size_t k = 0; k < deltas.size(); ++k) {
sum += deltas[k] * layers[l+1].weights[k][j];
}
layer_delta[j] = sum * d_sigmoid(net_inputs[l][j]);
}
deltas = layer_delta;
// Cập nhật trọng số và bias của lớp l
for (size_t j = 0; j < layers[l].biases.size(); ++j) {
layers[l].weights[j] = layers[l].weights[j]; // Copy cũ
// Cập nhật W
for (size_t k = 0; k < activations[l].size(); ++k) {
layers[l].weights[j][k] += learning_rate * deltas[j] * activations[l][k];
}
layers[l].biases[j] += learning_rate * deltas[j];
}
}
return total_loss;
}
};
int main() {
// Giả lập dữ liệu hồi quy: y = 2x + 1 + noise
std::vector inputs;
std::vector targets;
srand(42);
for (int i = 0; i < 100; ++i) {
double x = static_cast<double>(rand()) / RAND_MAX;
double true_y = 2.0 * x + 1.0 + (static_cast<double>(rand()) - RAND_MAX/2.0) * 0.1;
inputs.push_back({x});
targets.push_back({true_y});
}
// Kiến trúc: 1 Input -> 5 Hidden -> 1 Output
SimpleNN network({1, 5, 1}, 0.1);
for (int epoch = 0; epoch < 2000; ++epoch) {
double avg_loss = 0.0;
for (size_t i = 0; i < inputs.size(); ++i) {
avg_loss += network.train_step(inputs[i], targets[i]);
}
if (epoch % 500 == 0) {
std::cout << "Epoch " << epoch << ", Avg Loss: " << (avg_loss / inputs.size()) << std::endl;
}
}
// Kiểm tra kết quả trên dữ liệu mới
double test_x = 0.7;
std::vector<double> pred = network.forward({test_x});
std::cout << "\nPrediction for x=" << test_x << ": " << pred[0] << " (Expected ~2.4)" << std::endl;
return 0;
} 5. Triển khai thực tế với Python (Scikit-learn)
Trong môi trường phát triển phần mềm chuyên nghiệp, thay vì viết thuật toán từ đầu, người ta thường sử dụng các thư viện tối ưu hóa cao. Thư viện Scikit-learn cung cấp lớp `MLPClassifier` hỗ trợ các thuật toán tiên tiến như Adam, Batch Normalization, và Regularization.
Đoạn mã sau minh họa cách áp dụng mạng nơ-ron để phân loại dữ liệu Yếu tố Ung thư vú (Breast Cancer Dataset) có sẵn, bao gồm cả tiền xử lý chuẩn hóa dữ liệu.
"""
Script: breast_cancer_nn.py
Description: Classification of breast cancer data using MLP Classifier from sklearn.
Includes data scaling and performance evaluation.
"""
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import classification_report, accuracy_score
from sklearn.preprocessing import StandardScaler
def main():
# 1. Load dataset
cancer = load_breast_cancer()
X, y = cancer.data, cancer.target
print(f"Dữ liệu đầu vào: {X.shape}")
print(f"Mã lớp mục tiêu: {sorted(list(set(y)))}")
# 2. Chia tập Train/Test (80% Train, 20% Test)
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42, stratify=y
)
# 3. Chuẩn hóa dữ liệu (Rất quan trọng đối với NN)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
# 4. Xây dựng mô hình
# hidden_layer_sizes: [(n_neurons_l1), (n_neurons_l2)]
# solver: 'adam' là lựa chọn mặc định mạnh mẽ và ổn định
model = MLPClassifier(
hidden_layer_sizes=(100, 50),
activation='relu',
solver='adam',
max_iter=1000,
alpha=0.001,
learning_rate_init=0.001,
verbose=True
)
# 5. Huấn luyện
model.fit(X_train_scaled, y_train)
# 6. Đánh giá
y_pred = model.predict(X_test_scaled)
accuracy = accuracy_score(y_test, y_pred)
print("\n--- Kết quả Mô hình ---")
print(f"Accuracy: {accuracy:.4f}")
print("Chi tiết phân loại:")
print(classification_report(y_test, y_pred, digits=4))
if __name__ == "__main__":
main()Việc chuẩn hóa dữ liệu giúp các trọng số khởi tạo hoạt động hiệu quả hơn, tránh tình trạng hội tụ chậm do chênh lệch thang đo giữa các đặc trưng. Với cấu trúc tối ưu, độ chính xác trên tập kiểm thử thường đạt từ 96% trở lên cho bài toán chuẩn này.