Bài 2: Perceptron — đơn vị tính toán cơ bản nhất

Perceptron là đơn vị tính toán cơ bản nhất của neural network. Mỗi perceptron nhận một vector input, nhân với một vector weight, cộng bias, rồi đưa qua một hàm activation để ra output. Toàn bộ một mạng nơ-ron sâu — dù là MLP, CNN, hay Transformer — đều xếp chồng và kết nối các perceptron theo cấu trúc khác nhau.

Cảm hứng đến từ neuron sinh học: dendrite nhận tín hiệu từ nhiều neuron khác, soma tổng hợp tín hiệu có trọng số, nếu vượt ngưỡng thì axon phát một xung. Mô hình toán không mô phỏng chính xác sinh học (neuron thật phức tạp hơn rất nhiều), nó chỉ vay mượn ý tưởng "tổng có trọng số + ngưỡng kích hoạt".

Bài này dựng perceptron từ đầu: lịch sử, công thức, hình học, luật học, giới hạn, và code. Đây là nền để hiểu mọi layer của mọi kiến trúc trong các module tiếp theo.

Ba mốc cần biết:

• 1957 — Frank Rosenblatt: giới thiệu single perceptron tại Cornell Aeronautical Laboratory, kèm thuật toán học (Perceptron Learning Rule) và bài báo gốc "The Perceptron: A Probabilistic Model for Information Storage and Organization in the Brain" (1958). Mark I Perceptron là máy phần cứng dùng potentiometer làm weight, nhận ảnh 20×20 pixel từ một camera đơn sắc.
• 1969 — Marvin Minsky & Seymour Papert: xuất bản cuốn "Perceptrons", chứng minh chính thức rằng single perceptron không phân loại được hàm XOR vì XOR không linearly separable. Cuốn sách bị diễn giải rộng hơn ý định gốc — nhiều người hiểu là "neural network không có tương lai". Tài trợ cho NN giảm mạnh, mở ra giai đoạn AI winter đầu tiên.
• 1986 — Rumelhart, Hinton & Williams: bài báo "Learning representations by back-propagating errors" (Nature) phổ biến lại thuật toán backpropagation cho multi-layer perceptron. Chồng nhiều perceptron + hàm activation phi tuyến + chain rule đã giải được XOR và nhiều bài toán phi tuyến khác. Đây là khởi đầu của giai đoạn neural network thứ hai, dẫn tới deep learning hiện đại.

Hiểu mốc 1969 quan trọng vì sau bài này (mục 8) chúng ta sẽ tái dựng đúng phép chứng minh XOR và thấy vì sao đa lớp giải được vấn đề.

Một perceptron gồm 4 thành phần:

• Input — vector \( \mathbf{x} = (x_1, x_2, \ldots, x_n) \in \mathbb{R}^n \). Mỗi \( x_i \) là một feature của sample.
• Weight — vector \( \mathbf{w} = (w_1, w_2, \ldots, w_n) \in \mathbb{R}^n \). Mỗi \( w_i \) cho biết feature \( x_i \) "đóng góp" nhiều ít vào quyết định cuối; có thể dương (đẩy output lên) hoặc âm (đẩy output xuống).
• Bias — số thực \( b \in \mathbb{R} \). Bias cho phép dịch ngưỡng kích hoạt: cùng một \( \mathbf{x} \) và \( \mathbf{w} \), bias khác nhau cho ra output khác nhau. Về mặt hình học, bias dịch decision boundary khỏi gốc toạ độ.
• Activation function — hàm \( f: \mathbb{R} \to \mathbb{R} \) áp lên tổ hợp tuyến tính. Hàm này quyết định perceptron output ra giá trị gì (0/1, probability, real number).

Sơ đồ luồng: \( \mathbf{x} \to \) nhân với \( \mathbf{w} \to \) cộng bias \( b \to \) đưa qua activation \( f \to \) output \( \hat{y} \).

Tính toán chia thành hai bước. Bước 1 — tổ hợp tuyến tính (linear combination, còn gọi là pre-activation):

\[ z = \sum_{i=1}^n w_i x_i + b = \mathbf{w}^T \mathbf{x} + b \]

Bước 2 — đưa qua activation:

\[ \hat{y} = f(z) = f(\mathbf{w}^T \mathbf{x} + b) \]

Hai biểu diễn quan trọng cho cùng một phép tính:

• Dạng tổng \( \sum w_i x_i + b \) — dễ hình dung từng feature đóng góp riêng.
• Dạng tích vô hướng \( \mathbf{w}^T \mathbf{x} + b \) — gọn, vector hoá được bằng NumPy/PyTorch.

Mẹo nhỏ: nhiều tài liệu gộp bias vào weight bằng cách thêm feature giả \( x_0 = 1 \) và \( w_0 = b \). Khi đó \( z = \tilde{\mathbf{w}}^T \tilde{\mathbf{x}} \) gọn hơn. Trong bài này giữ \( b \) tách riêng cho rõ — đa số framework (PyTorch, TensorFlow) cũng làm vậy.

Activation \( f \) làm hai việc cùng lúc: đưa output về dạng cần (0/1, probability, real number) và phá tuyến tính. Nếu \( f \) là hàm đồng nhất \( f(z) = z \) thì xếp chồng bao nhiêu layer cũng chỉ thành một biến đổi tuyến tính — không tận dụng được sức mạnh của mạng sâu (chứng minh chi tiết ở Bài 3).

Bài này chỉ cần biết hai hàm:

• Step function (Heaviside) — activation gốc Rosenblatt dùng: \[ f(z) = \begin{cases} 1 & \text{nếu } z \geq 0 \\ 0 & \text{nếu } z < 0 \end{cases} \] Ưu điểm: trực giác đúng với neuron sinh học (fire/no fire). Nhược điểm: không khả vi tại \( z = 0 \), đạo hàm bằng 0 khắp nơi → không train bằng gradient descent được. Đây là lý do classic perceptron dùng Perceptron Learning Rule riêng thay vì backprop.
• Sigmoid: \[ \sigma(z) = \frac{1}{1 + e^{-z}} \] Output \( (0, 1) \), khả vi mọi nơi, đạo hàm gọn \( \sigma'(z) = \sigma(z)(1 - \sigma(z)) \). Thay step bằng sigmoid là bước chuyển từ classic perceptron sang neural network train được bằng gradient.

Các activation hiện đại — ReLU, LeakyReLU, Tanh, Softmax — sẽ học chi tiết ở Bài 5–8.

Single perceptron với step activation là một linear classifier. Sample được phân loại class 1 khi \( z \geq 0 \), class 0 khi \( z < 0 \). Ranh giới giữa hai vùng — decision boundary — chính là tập hợp các điểm \( \mathbf{x} \) sao cho:

\[ \mathbf{w}^T \mathbf{x} + b = 0 \]

Phương trình này định nghĩa một hyperplane (siêu phẳng) trong không gian feature:

• \( n = 1 \) — boundary là một điểm trên trục số.
• \( n = 2 \) — boundary là một đường thẳng trong mặt phẳng \( (x_1, x_2) \). Phương trình \( w_1 x_1 + w_2 x_2 + b = 0 \) ⇔ \( x_2 = -\frac{w_1}{w_2} x_1 - \frac{b}{w_2} \).
• \( n = 3 \) — boundary là một mặt phẳng.
• \( n \) bất kỳ — boundary là một hyperplane \( (n-1) \) chiều.

Hai ý nghĩa cần nhớ:

• Vector \( \mathbf{w} \) là pháp tuyến của hyperplane — vuông góc với boundary, chỉ hướng "tăng \( z \)".
• Bias \( b \) điều khiển khoảng cách từ gốc toạ độ tới hyperplane. Không có bias, hyperplane luôn đi qua gốc — bài toán bị giới hạn không cần thiết.

Hệ quả: single perceptron chỉ phân biệt tốt khi hai class linearly separable. Đây chính là điểm Minsky & Papert tấn công.

Rosenblatt đề xuất một luật học không cần đạo hàm, hợp với step activation. Cho dataset \( \{(\mathbf{x}^{(i)}, y^{(i)})\}_{i=1}^N \) với \( y^{(i)} \in \{0, 1\} \). Khởi tạo \( \mathbf{w} = \mathbf{0} \), \( b = 0 \), chọn learning rate \( \eta > 0 \). Lặp qua dataset:

• Bước 1 — Predict: \( \hat{y}^{(i)} = f(\mathbf{w}^T \mathbf{x}^{(i)} + b) \) với \( f \) là step function.
• Bước 2 — Update: \[ \mathbf{w} \leftarrow \mathbf{w} + \eta \, (y^{(i)} - \hat{y}^{(i)}) \, \mathbf{x}^{(i)} \] \[ b \leftarrow b + \eta \, (y^{(i)} - \hat{y}^{(i)}) \]

Đọc luật:

• Nếu predict đúng (\( y - \hat{y} = 0 \)) → không đổi gì.
• Nếu predict 0 nhưng truth 1 (\( y - \hat{y} = 1 \)) → cộng thêm \( \eta \mathbf{x} \) vào \( \mathbf{w} \) → lần sau \( z \) lớn hơn cho sample này, dễ predict 1 hơn.
• Nếu predict 1 nhưng truth 0 (\( y - \hat{y} = -1 \)) → trừ \( \eta \mathbf{x} \) khỏi \( \mathbf{w} \) → lần sau \( z \) nhỏ hơn.

Lặp đi lặp lại qua dataset cho tới khi tất cả sample được phân loại đúng (hoặc đạt số epoch tối đa).

Định lý hội tụ perceptron (Rosenblatt 1958, Novikoff 1962): nếu data linearly separable, Perceptron Learning Rule đảm bảo hội tụ về một bộ \( (\mathbf{w}, b) \) phân loại đúng toàn bộ tập train sau hữu hạn bước. Cận trên cho số update phụ thuộc margin giữa hai class và bán kính dataset. Nếu data không linearly separable, thuật toán dao động vô hạn — đây chính là cái bẫy của XOR.

XOR (exclusive OR) là hàm hai bit:

• \( (0, 0) \to 0 \)
• \( (0, 1) \to 1 \)
• \( (1, 0) \to 1 \)
• \( (1, 1) \to 0 \)

Bốn điểm trên mặt phẳng \( (x_1, x_2) \): hai điểm class 1 nằm ở \( (0,1) \) và \( (1,0) \) (hai góc đối chéo), hai điểm class 0 nằm ở \( (0,0) \) và \( (1,1) \) (hai góc còn lại). Không tồn tại đường thẳng nào tách bốn điểm này thành hai nhóm đúng — XOR không linearly separable.

Chứng minh nhanh bằng phản chứng. Giả sử có \( w_1, w_2, b \) phân loại đúng cả bốn sample. Áp công thức cho step \( z \geq 0 \to 1 \):

• \( (0,0) \to 0 \): \( b < 0 \).
• \( (1,1) \to 0 \): \( w_1 + w_2 + b < 0 \) → \( w_1 + w_2 < -b \).
• \( (0,1) \to 1 \): \( w_2 + b \geq 0 \) → \( w_2 \geq -b \).
• \( (1,0) \to 1 \): \( w_1 + b \geq 0 \) → \( w_1 \geq -b \).

Cộng hai bất đẳng thức cuối: \( w_1 + w_2 \geq -2b \). Vì \( b < 0 \) nên \( -b > 0 \), do đó \( -2b > -b \), suy ra \( w_1 + w_2 \geq -2b > -b \) → mâu thuẫn với \( w_1 + w_2 < -b \). Không tồn tại perceptron đơn giải được XOR.

Cách thoát: chồng nhiều perceptron với activation phi tuyến. Một mạng 2 layer (2 perceptron ở hidden layer + 1 perceptron output) giải XOR dễ dàng — đây chính là Multi-Layer Perceptron (MLP) mà Bài 3 sẽ dựng từ đầu.

Logistic Regression (Series 2 Bài 22) thực ra là một perceptron — chỉ khác ở activation và cách train. Bảng so sánh:

• Cấu trúc: cả hai đều \( z = \mathbf{w}^T \mathbf{x} + b \), rồi áp activation.
• Activation: classic perceptron dùng step (output 0/1). Logistic Regression dùng sigmoid (output probability trong \( (0, 1) \)).
• Loss / luật học: classic perceptron dùng Perceptron Learning Rule không cần đạo hàm, chỉ cập nhật khi predict sai. Logistic Regression dùng binary cross-entropy + gradient descent, cập nhật theo gradient mỗi sample (kể cả khi đã đúng).
• Tính chất: classic perceptron đảm bảo hội tụ nếu linearly separable, nhưng dao động nếu không. Logistic Regression luôn hội tụ (loss convex), kể cả khi không separable — nó tìm boundary tối ưu theo nghĩa xác suất.
• Output diễn giải: perceptron ra class trực tiếp. Logistic Regression ra probability, có thể threshold ở bất kỳ ngưỡng nào.

Deep learning hiện đại đi tiếp một bước: thay sigmoid bằng ReLU/Tanh ở hidden layer, dùng softmax ở output cho multi-class, dùng cross-entropy + gradient descent. Mọi layer fully-connected trong PyTorch (nn.Linear) là một tập perceptron song song với activation lựa chọn được.

Một perceptron đơn output ra một số. Cần \( K \) output (ví dụ multi-class \( K \) class, hoặc một layer hidden có \( K \) neuron) thì xếp \( K \) perceptron song song, cùng nhận input \( \mathbf{x} \).

Perceptron thứ \( k \) có weight riêng \( \mathbf{w}_k \in \mathbb{R}^n \) và bias \( b_k \in \mathbb{R} \):

\[ z_k = \mathbf{w}_k^T \mathbf{x} + b_k, \quad k = 1, 2, \ldots, K \]

Gộp lại dưới dạng ma trận. Đặt \( W \in \mathbb{R}^{K \times n} \) với hàng thứ \( k \) là \( \mathbf{w}_k^T \), và \( \mathbf{b} \in \mathbb{R}^K \) là vector bias:

\[ \mathbf{z} = W \mathbf{x} + \mathbf{b}, \quad \hat{\mathbf{y}} = f(\mathbf{z}) \]

Với \( f \) là activation áp theo từng phần tử (element-wise). Đây chính là công thức của một fully-connected layer — viên gạch xây MLP.

Trong PyTorch:

import torch.nn as nn
layer = nn.Linear(in_features=n, out_features=K)
# layer.weight có shape (K, n) — chính là W
# layer.bias có shape (K,)    — chính là b

Hiểu một perceptron → hiểu một layer → hiểu một mạng.

Implement classic perceptron với NumPy. Class có hai phương thức: fit (train bằng Perceptron Learning Rule) và predict.

import numpy as np


class Perceptron:
    def __init__(self, lr=0.1, n_epochs=20):
        self.lr = lr
        self.n_epochs = n_epochs
        self.w = None
        self.b = None

    @staticmethod
    def _step(z):
        return np.where(z >= 0, 1, 0)

    def fit(self, X, y):
        n_samples, n_features = X.shape
        self.w = np.zeros(n_features)
        self.b = 0.0
        for epoch in range(self.n_epochs):
            errors = 0
            for xi, yi in zip(X, y):
                z = np.dot(self.w, xi) + self.b
                y_hat = self._step(z)
                update = self.lr * (yi - y_hat)
                self.w += update * xi
                self.b += update
                errors += int(update != 0.0)
            if errors == 0:
                break  # hoi tu — tat ca sample dung
        return self

    def predict(self, X):
        z = X @ self.w + self.b
        return self._step(z)

Train cho ba hàm logic kinh điển:

X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y_and = np.array([0, 0, 0, 1])
y_or  = np.array([0, 1, 1, 1])
y_xor = np.array([0, 1, 1, 0])

for name, y in [("AND", y_and), ("OR", y_or), ("XOR", y_xor)]:
    model = Perceptron(lr=0.1, n_epochs=50).fit(X, y)
    y_hat = model.predict(X)
    acc = (y_hat == y).mean()
    print(f"{name}: w={model.w}, b={model.b:.2f}, accuracy={acc:.2f}")

Kết quả điển hình:

• AND — hội tụ sau vài epoch, accuracy 1.0. Boundary là một đường thẳng tách \( (1,1) \) khỏi ba điểm còn lại.
• OR — hội tụ, accuracy 1.0. Boundary tách \( (0,0) \) khỏi ba điểm còn lại.
• XOR — không hội tụ, accuracy chỉ đạt 0.5 hoặc 0.75 tuỳ epoch và lr. Tăng epoch không cứu được — đây là minh chứng thực nghiệm cho chứng minh ở mục 8.

Verify decision boundary cho AND:

model = Perceptron(lr=0.1, n_epochs=50).fit(X, y_and)
# Phuong trinh boundary: w1*x1 + w2*x2 + b = 0
w1, w2 = model.w
b = model.b
print(f"boundary: {w1:.2f}*x1 + {w2:.2f}*x2 + {b:.2f} = 0")
# vi du: 0.20*x1 + 0.20*x2 - 0.30 = 0  =>  x1 + x2 = 1.5

Đường \( x_1 + x_2 = 1.5 \) đi giữa \( (1,1) \) và ba điểm còn lại — đúng như kỳ vọng.

Perceptron không còn được dùng nguyên bản trong production — step activation và Perceptron Learning Rule đã được thay. Nhưng nó vẫn là building block khái niệm của mọi kiến trúc:

• Fully-connected layer (Dense / Linear) — \( K \) perceptron song song với cùng activation. Đây là layer cơ bản của MLP và cũng xuất hiện ở cuối CNN, Transformer.
• Convolutional layer — mỗi vị trí trên feature map là một perceptron với weight được chia sẻ trên toàn ảnh (kernel). Cùng công thức \( \mathbf{w}^T \mathbf{x} + b \), chỉ khác cách chọn \( \mathbf{x} \) (patch cục bộ).
• Attention head — query, key, value mỗi cái là output của một fully-connected layer; bản thân fully-connected layer là tập perceptron.
• Output layer — softmax cho classification, linear cho regression — vẫn là perceptron với activation tương ứng.

Một mạng deep với hàng tỷ parameter (GPT, LLaMA) về bản chất là hàng tỷ phép \( w x + b \) qua activation, được tổ chức theo cấu trúc khéo léo. Hiểu chắc một perceptron là điều kiện đủ để đọc mọi paper kiến trúc sau này.

Bài 1 — Train perceptron cho AND gate. Dùng class Perceptron ở mục 11 (hoặc tự viết lại), train trên 4 sample của AND. Sau khi train, in w, b, viết phương trình decision boundary dạng \( x_2 = a x_1 + c \) và vẽ kèm 4 điểm input bằng matplotlib. Boundary có tách đúng \( (1,1) \) khỏi ba điểm còn lại không?

Bài 2 — Verify XOR không train được. Train perceptron trên XOR với n_epochs lần lượt 10, 100, 1000. Theo dõi số errors (sample bị sai) ở cuối mỗi epoch — số này có giảm dần về 0 không? Plot accuracy theo epoch để thấy thuật toán dao động chứ không hội tụ.

Bài 3 — Compute output thủ công. Cho perceptron với \( \mathbf{w} = (0.5, -0.3, 0.8) \), \( b = -0.2 \), activation là step. Tính \( \hat{y} \) cho ba input:

• \( \mathbf{x} = (1, 0, 1) \).
• \( \mathbf{x} = (0, 2, 0) \).
• \( \mathbf{x} = (1, 1, 1) \).

Làm bằng giấy bút trước, rồi verify bằng NumPy.

Bài 4 — Sigmoid thay cho step. Sửa class Perceptron: thay _step bằng sigmoid, đổi update rule thành gradient descent cho binary cross-entropy. Train lại trên AND, OR, XOR. AND và OR vẫn hội tụ tốt; XOR có hội tụ không? Vì sao sigmoid vẫn không cứu được XOR (gợi ý: decision boundary vẫn là hyperplane)?

Bài 5 — So sánh với sklearn. Sklearn có sklearn.linear_model.Perceptron (classic perceptron) và LogisticRegression (sigmoid + cross-entropy). Train cả hai trên cùng dữ liệu sinh từ make_classification(n_samples=200, n_features=2, n_classes=2, random_state=42). So sánh: (a) accuracy test, (b) coef_ và intercept_, (c) thời gian fit. Model nào ổn định hơn?

Bài 3: Multi-Layer Perceptron (MLP) — chồng nhiều perceptron thành nhiều layer, thêm activation phi tuyến giữa các layer, dựng mạng giải được XOR và mọi hàm liên tục (theo Universal Approximation Theorem). Đây là bước chuyển từ một neuron sang một mạng nơ-ron đúng nghĩa.