Mục tiêu bài học
- Hiểu cấu trúc một nơ-ron nhân tạo hoạt động như thế nào
- Hiểu cách mạng nơ-ron nhiều lớp truyền dữ liệu và học từ lỗi
- Nắm được cách tính đạo hàm để cập nhật trọng số qua Backpropagation
- Có thể tự viết một mạng nơ-ron đơn giản bằng Python
1. Nơ-ron nhân tạo là gì?
Trực giác
Hãy tưởng tượng bạn là một giáo viên đang chấm điểm học sinh. Bạn dựa vào các yếu tố như điểm thi, sự chăm chỉ, mức độ tham gia lớp học. Bạn tổng hợp tất cả rồi đưa ra một quyết định: Giỏi hay Trung bình.
Mỗi yếu tố đầu vào (ví dụ điểm thi) được bạn gán một mức độ quan trọng (trọng số). Bạn cộng các yếu tố này lại, rồi áp dụng một quy tắc đánh giá (ví dụ: nếu trên 70 thì là Giỏi). Đó chính là cách một nơ-ron nhân tạo hoạt động.
Biểu thức toán học
Một nơ-ron có thể được mô tả như sau:
- x=[x1,x2,…,xn]x=[x1,x2,…,xn]: đầu vào (input)
- w=[w1,w2,…,wn]w=[w1,w2,…,wn]: trọng số
- bb: hệ số điều chỉnh (bias)
- z=wTx+bz=wTx+b: tổng có trọng số
- a=ϕ(z)a=ϕ(z): đầu ra sau khi đưa qua hàm kích hoạt
Ví dụ:
- x=[2,3]x=[2,3]
- w=[0.4,0.6]w=[0.4,0.6]
- b=1b=1
- ϕϕ: ReLU (trả về số dương hoặc 0)
Khi đó:z=0.4×2+0.6×3+1=3.4a=ReLU(z)=3.4z=0.4×2+0.6×3+1=3.4a=ReLU(z)=3.4
2. Mạng nơ-ron nhiều lớp
Một mạng nơ-ron học sâu (deep neural network) gồm nhiều lớp nơ-ron:
- Lớp đầu vào (input layer): nhận dữ liệu đầu vào
- Lớp ẩn (hidden layers): trích xuất đặc trưng
- Lớp đầu ra (output layer): trả về kết quả dự đoán
Ví dụ: Nhận diện ảnh chữ số viết tay (MNIST)
- Đầu vào: 784 pixel
- Mạng có thể có: 784 → 128 → 64 → 10 (ứng với 10 chữ số)
Mỗi lớp hoạt động theo công thức:z[l]=W[l]a[l−1]+b[l]a[l]=ϕ(z[l])z[l]=W[l]a[l−1]+b[l]a[l]=ϕ(z[l])
Trong đó:
- W[l]W[l]: ma trận trọng số tại lớp thứ ll
- b[l]b[l]: vector bias
- a[l]a[l]: đầu ra lớp thứ ll
- ϕϕ: hàm kích hoạt
3. Hàm mất mát và mục tiêu học
Mạng học bằng cách đo sai số giữa đầu ra dự đoán y^y^ và nhãn thực tế yy. Hàm đo sai số được gọi là hàm mất mát (loss function).
Ví dụ: Dự đoán phân loại nhị phân (như ảnh có mèo hay không)
Hàm mất mát phổ biến: Cross-EntropyL=−ylog(y^)−(1−y)log(1−y^)L=−ylog(y^)−(1−y)log(1−y^)
Mục tiêu của học máy là tìm các giá trị W,bW,b sao cho tổng mất mát trên toàn bộ dữ liệu huấn luyện là nhỏ nhất.
4. Học như thế nào? – Lan truyền ngược (Backpropagation)
Để mạng tự học, ta cần tính xem nếu thay đổi một trọng số ww, thì hàm mất mát thay đổi bao nhiêu – đó là đạo hàm.
Sử dụng quy tắc chuỗi (chain rule):
- Bắt đầu từ đầu ra
- Lan truyền lỗi ngược lại từng lớp
- Cập nhật từng trọng số
Ví dụ:
- δ[l]δ[l]: lỗi tại lớp thứ ll
- ∂L∂W[l]=δ[l]⋅a[l−1]T∂W[l]∂L=δ[l]⋅a[l−1]T
- δ[l]=(W[l+1]T⋅δ[l+1])⊙ϕ′(z[l])δ[l]=(W[l+1]T⋅δ[l+1])⊙ϕ′(z[l])
Sau khi có gradient, cập nhật:W:=W−η⋅∇WW:=W−η⋅∇Wb:=b−η⋅∇bb:=b−η⋅∇b
Với ηη: tốc độ học (learning rate)
5. Viết một mạng nơ-ron đơn giản bằng Python
import numpy as np
def sigmoid(z):
return 1 / (1 + np.exp(-z))
def sigmoid_derivative(z):
s = sigmoid(z)
return s * (1 - s)
# Dữ liệu đầu vào
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]]) # Bài toán XOR
Y = np.array([[0], [1], [1], [0]])
# Khởi tạo trọng số
np.random.seed(0)
W1 = np.random.randn(2, 2)
b1 = np.zeros((1, 2))
W2 = np.random.randn(2, 1)
b2 = np.zeros((1, 1))
# Huấn luyện đơn giản (số epoch nhỏ)
for i in range(10000):
# Forward
Z1 = np.dot(X, W1) + b1
A1 = sigmoid(Z1)
Z2 = np.dot(A1, W2) + b2
A2 = sigmoid(Z2)
# Loss (MSE)
loss = np.mean((A2 - Y) ** 2)
# Backprop
dZ2 = A2 - Y
dW2 = np.dot(A1.T, dZ2)
db2 = np.sum(dZ2, axis=0, keepdims=True)
dA1 = np.dot(dZ2, W2.T)
dZ1 = dA1 * sigmoid_derivative(Z1)
dW1 = np.dot(X.T, dZ1)
db1 = np.sum(dZ1, axis=0, keepdims=True)
# Update
lr = 0.1
W2 -= lr * dW2
b2 -= lr * db2
W1 -= lr * dW1
b1 -= lr * db1
if i % 1000 == 0:
print(f"Epoch {i}, loss: {loss:.4f}")
6. Tổng kết
- Mỗi nơ-ron là một phép tính tuyến tính cộng phi tuyến
- Nhiều nơ-ron xếp lớp tạo thành mạng học sâu
- Mạng học bằng cách đo lỗi và cập nhật trọng số theo gradient
- Người học có thể tự viết mạng đơn giản chỉ với NumPy
Sign up