Neural Network Overview

Neural Network là mô hình gồm nhiều layers neurons kết nối, học bằng cách điều chỉnh weights để giảm loss. Đơn vị cơ bản nhất là perceptron; xếp chồng nhiều lớp tạo thành MLP.

Forward pass (1 neuron):

Forward pass (ma trận cho cả lớp):

Training loop:

Quá trình tính gradient được thực hiện bởi backpropagation, kết hợp với học có giám sát để điều chỉnh weights từ dữ liệu có nhãn.

Các kiến trúc phổ biến:

• MLP: Fully connected. Tốt cho tabular data.
• CNN: Convolution + pooling. Tốt cho ảnh, video, âm thanh (spectrogram).
• RNN/LSTM/GRU: Recurrence. Tốt cho sequence (trước khi Transformer lên ngôi).
• Transformer: Self-attention. Tốt cho text, multimodal — kiến trúc chủ đạo hiện nay.
• GNN: Graph neural network. Tốt cho dữ liệu cấu trúc đồ thị (mạng xã hội, phân tử).

import torch
import torch.nn as nn
import torch.nn.functional as F

class SimpleNN(nn.Module):
    """MLP 3 lớp cho bài toán phân loại."""

    def __init__(self, input_size: int = 10, hidden: int = 100, output: int = 2) -> None:
        super().__init__()
        self.fc1 = nn.Linear(input_size, hidden)
        self.fc2 = nn.Linear(hidden, hidden)
        self.fc3 = nn.Linear(hidden, output)
        self.dropout = nn.Dropout(p=0.2)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        # x: (batch, input_size)
        h1 = F.relu(self.fc1(x))          # Layer 1 + ReLU
        h1 = self.dropout(h1)              # Regularization
        h2 = F.relu(self.fc2(h1))          # Layer 2 + ReLU
        logits = self.fc3(h2)              # Output (chưa softmax)
        return logits


model = SimpleNN()
num_params = sum(p.numel() for p in model.parameters())
print(f"Tổng parameters: {num_params:,}")  # 11,302

# Hàm loss và optimizer
criterion = nn.CrossEntropyLoss()           # softmax + NLL
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)

# Vòng lặp huấn luyện
for epoch in range(100):
    # ─── Forward pass ───
    logits = model(X_train)
    loss = criterion(logits, y_train)

    # ─── Backward pass (backpropagation) ───
    optimizer.zero_grad()
    loss.backward()

    # ─── Cập nhật weights ───
    optimizer.step()

    if epoch % 10 == 0:
        acc = (logits.argmax(dim=1) == y_train).float().mean()
        print(f"epoch={epoch:3d} loss={loss.item():.4f} acc={acc.item():.3f}")

import numpy as np

# ─── Ma trận trọng số và bias ───
# Input 3 → Hidden 4 → Output 2
rng = np.random.default_rng(seed=42)
W1 = rng.standard_normal((4, 3)) * np.sqrt(2 / 3)   # Kaiming init
b1 = np.zeros(4)
W2 = rng.standard_normal((2, 4)) * np.sqrt(2 / 4)
b2 = np.zeros(2)


def relu(z: np.ndarray) -> np.ndarray:
    return np.maximum(0, z)


def softmax(z: np.ndarray) -> np.ndarray:
    shift = z - z.max(axis=-1, keepdims=True)  # chống overflow
    exps = np.exp(shift)
    return exps / exps.sum(axis=-1, keepdims=True)


def forward(x: np.ndarray) -> dict:
    """Forward pass cho 1 mẫu hoặc batch."""
    z1 = x @ W1.T + b1              # (batch, 4)
    a1 = relu(z1)                    # (batch, 4)
    z2 = a1 @ W2.T + b2              # (batch, 2)
    p = softmax(z2)                  # (batch, 2)
    return {"z1": z1, "a1": a1, "z2": z2, "p": p}


# Demo
x = np.array([[0.5, -0.3, 0.8]])
out = forward(x)
print("Hidden activations:", out["a1"])
print("Probabilities:    ", out["p"])
print("Predicted class:  ", out["p"].argmax(axis=-1))

Từ 1 neuron đến một mạng:một perceptron đơn lẻ chỉ vẽ được 1 đường thẳng trong không gian đặc trưng — tương đương với mô hình logistic regression. Ghép nhiều perceptron song song trong 1 lớp, ta được một bộ các đường thẳng đồng thời. Đi qua activation phi tuyến, các đường đó được "uốn cong" lại. Xếp chồng thêm lớp nữa, các vùng cong đó được tái tổ hợp thành các vùng quyết định bất kỳ. Đây là trực giác hình học của deep learning.

Biểu diễn bằng đồ thị tính toán: mỗi node trong đồ thị là một phép toán (cộng, nhân, kích hoạt), mỗi cạnh là một tensor. PyTorch và JAX xây đồ thị này một cách động khi bạn chạy forward; autograd đi ngược lại chính đồ thị đó để tính gradient. Điều kỳ diệu là bạn chỉ cần định nghĩa forward, framework tự lo backward.

Regularization — chống overfitting:

• L2 (weight decay): thêm $\lambda \lVert W \rVert^2$ vào loss, kéo weights về 0 → model mượt hơn, ít nhạy nhiễu.
• Dropout:mỗi bước training, tắt ngẫu nhiên một tỷ lệ neurons. Mạng buộc phải phân tán "kiến thức" → giảm co-adaptation.
• Early stopping: theo dõi validation loss, dừng khi bắt đầu tăng.
• Data augmentation: xoay, cắt, flip ảnh để mở rộng tập huấn luyện ảo → model khái quát hoá tốt hơn.

Optimizer phổ biến:

• SGD + momentum: gradient descent chuẩn, thêm momentum để giảm dao động.
• Adam:kết hợp momentum và adaptive learning rate — mặc định "an toàn" cho đa số bài toán.
• AdamW: Adam tách rời weight decay, được dùng rộng rãi trong Transformer.
• Lion: optimizer mới từ Google (2023), chỉ dùng dấu của gradient — ít bộ nhớ hơn Adam.

Các loại bài toán và output layer tương ứng:

• Phân loại nhị phân: 1 neuron output + sigmoid + binary cross-entropy.
• Phân loại nhiều lớp (loại trừ): K neurons + softmax + cross-entropy.
• Phân loại nhiều nhãn (không loại trừ): K neurons + sigmoid từng phần + BCE.
• Hồi quy: 1 hoặc nhiều neurons + không activation + MSE / Huber loss.
• Sinh dữ liệu: phụ thuộc mô hình (VAE, GAN, diffusion, LM) — có riêng output head đặc thù.