Perceptron: "Bộ não" nhỏ nhất bạn có thể xây dựng bằng Python

Perceptron là "bộ não" nhỏ nhất mà bạn có thể xây dựng. Bạn đưa vào một con số, và nhận lại một câu trả lời Có hoặc Không. Đó là tất cả.

Nghe có vẻ quá đơn giản để trở nên quan trọng. Nhưng ý tưởng nhỏ bé này chính là hạt giống của mọi mạng nơ-ron đang vận hành thế giới ngày nay. Trong bài viết này, chúng ta sẽ cùng xây dựng một Perceptron từ con số 0 bằng Python và quan sát quá trình nó học hỏi ngay trước mắt. Không cần toán học phức tạp, không cần thư viện nặng nề. Chỉ có trọng số (weight), độ lệch (bias) và một vòng lặp.

Perceptron là gì?

Năm 1958, một nhà nghiên cứu tên là Frank Rosenblatt đã xây dựng một cỗ máy mà ông gọi là Perceptron. Cỗ máy này được lấy cảm hứng từ một tế bào não đơn giản, một nơ-ron. Một nơ-ron nhận tín hiệu, và nếu tín hiệu đó đủ mạnh, nó sẽ kích hoạt. Rosenblatt đã sao chép ý tưởng đó bằng toán học:

output = 1 nếu (w · x + b) > 0 0 trong các trường hợp còn lại

Ở đây, x là đầu vào, w là trọng số (weight), và b là độ lệch (bias). Đừng quá lo lắng về các thuật ngữ này ngay lập tức. Chúng ta sẽ làm quen từng cái thông qua việc xây dựng một thứ thực tế.

Tư duy như một con người trước

Trước khi máy móc đưa ra quyết định, hãy xem con người quyết định như thế nào. Hãy gặp John Doe. Anh ấy có một lời mời làm việc và phải trả lời một câu hỏi: Anh ấy có nên nhận nó không?

John không tung đồng xu. Anh ấy cân nhắc. Một số yếu tố quan trọng với anh ấy hơn những yếu tố khác.

• Yếu tố (đầu vào): Lương thêm, Có ở lại thành phố không.
• Mức độ quan tâm (trọng số): Lương thêm là quan trọng, việc phải chuyển nhà là rào cản lớn.

John nhân từng yếu tố với mức độ anh ấy quan tâm đến nó, sau đó cộng tất cả lại. Nếu tổng số đủ cao, anh ấy nói Có. Nếu không, anh ấy nói Không.

Đó chính là một Perceptron. Các yếu tố là đầu vào. Mức độ quan tâm là trọng số. Và "đủ cao" là ngưỡng mà anh ấy giữ trong đầu. Hãy nhớ kỹ ngưỡng này. Sau này chúng ta sẽ đặt tên cho nó: bias (độ lệch).

Quyết định đơn giản nhất: Số này có dương không?

Hãy thu nhỏ vấn đề cho đến khi gần như không còn gì. Một đầu vào. Một câu hỏi: Số này có dương không?

Đưa cho máy một con số. Nó nên trả lời True (Đúng) nếu số dương và False (Sai) nếu số âm.

Máy đưa ra dự đoán như sau:

prediction = (weight * value + bias) > 0

Nhân đầu vào với trọng số, thêm độ lệch, và kiểm tra xem kết quả có lớn hơn 0 không. Nếu có, nó dự đoán True. Nếu không, nó dự đoán False. Công thức nhỏ này được gọi là bộ phân loại (classifier), hay còn gọi là hàm quyết định.

Ban đầu, trọng số và độ lệch chỉ là các số ngẫu nhiên. Vì vậy, máy đoán sai. Bây giờ đến phần duy nhất thông minh: nó học từ sai lầm của mình.

if prediction != result: error = result - prediction weight += learning_rate * error * value bias += learning_rate * error

Khi đoán sai, chúng ta điều chỉnh trọng số và độ lệch theo đúng hướng. Sai số (error) cho chúng ta biết nên điều chỉnh theo hướng nào. Tốc độ học (learning rate) quyết định mức độ điều chỉnh lớn đến đâu. Chúng ta làm điều này cho mọi ví dụ, sau đó lặp lại toàn bộ quá trình. Một lần lặp qua toàn bộ dữ liệu được gọi là một kỷ nguyên (epoch). Lặp lại các kỷ nguyên chính là quá trình huấn luyện (training).

Tại sao chúng ta cần Bias? Ví dụ về sinh viên qua môn

Đường màu xanh trong các mô phỏng trên có một cái tên: ranh giới quyết định (decision boundary). Đây là điểm chính xác mà máy chuyển từ nói False sang nói True.

Chúng ta có thể tính toán nó. Ranh giới nằm ở vị trí w · x + b = 0. Giải cho x: decision_boundary = -bias / weight.

Với câu hỏi "số này có dương không", ranh giới nên nằm ở 0. Và nó đúng như vậy. Bây giờ hãy xem điều gì xảy ra khi đáp án đúng không nằm ở 0.

Vấn đề mới: Chúng ta đưa cho máy điểm thi từ 0 đến 100 và hỏi: Sinh viên có qua môn không?

Quy tắc很简单: Điểm 50 hoặc cao hơn là qua. Vì vậy, ranh giới quyết định nên nằm ở 50, không phải 0.

Nếu chúng ta cố giải quyết vấn đề này chỉ bằng trọng số (tắt Bias đi), máy sẽ bị kẹt. Công thức trở thành weight * score. Mọi điểm thi đều là số dương. Nếu trọng số dương, máy gọi mọi sinh viên là qua. Nếu trọng số âm, mọi người đều trượt. Ranh giới bị dính chặt vào 0 và không thể di chuyển. Một đường bị ép đi qua 0 không thể tách "dưới 50" và "50 trở lên".

Bây giờ hãy bật Bias lên. Độ chính xác sẽ tăng lên 100% và ranh giới sẽ trượt đến vị trí 50.

Đó chính là công việc của Bias. Trọng số thiết lập độ dốc. Bias di chuyển ranh giới sang trái hoặc phải để nó có thể nằm ở nơi đáp án thực sự nằm. Khi đầu vào của bạn nằm xa số 0, bạn cần một Bias để kéo đường ranh giới đến gần chúng.

Perceptron học như thế nào? Kỷ nguyên và Tốc độ học

Bạn đã thấy hai nút điều khiển khi huấn luyện: Epochs và Learning rate.

• Epoch (Kỷ nguyên): Một lượt chạy qua toàn bộ dữ liệu. Máy hiếm khi làm đúng mọi thứ ngay lần chạy đầu tiên, nên chúng ta lặp đi lặp lại. Nhiều epoch nghĩa là nhiều cơ hội để sửa sai.
• Learning rate (Tốc độ học): Kích thước của từng lần sửa lỗi. Các bước nhỏ thì cẩn thận nhưng chậm. Các bước lớn thì nhanh nhưng có thể vượt quá mục tiêu và dao động lộn xộn.

Tại sao phải Chuẩn hóa dữ liệu (Normalize)?

Có một vấn đề tiềm ẩn trong ví dụ điểm thi. Hãy xem lại dòng cập nhật trọng số:

weight += learning_rate * error * value

Lần sửa lỗi được nhân với value (giá trị đầu vào). Với điểm thi, value có thể lớn tới 100. Vì vậy, một lần đoán sai có thể ném trọng số đi một khoảng rất xa. Máy vẫn học được, nhưng nó sẽ giật cục thay vì ổn định.

Giải pháp là chuẩn hóa (normalization): thu nhỏ đầu vào về một phạm vi nhỏ gọn trước khi huấn luyện. Cách đơn giản nhất là chia mọi điểm thi cho điểm tối đa có thể, biến 0-100 thành 0-1.

Khi dữ liệu đầu vào có các thang đo rất khác nhau (ví dụ: lương tính bằng hàng nghìn đô la nhưng "cùng thành phố" chỉ là 0 hoặc 1), việc không chuẩn hóa sẽ khiến lương lấn át các yếu tố khác. Chuẩn hóa giúp mọi yếu tố có tiếng nói công bằng.

Toàn bộ mã nguồn Perceptron trong Python

Dưới đây là chương trình hoàn chỉnh để phát hiện "số này có dương không", không có gì được giấu đi.

import random

learning_rate = 0.1
EPOCHS = 100

weight = random.uniform(-1, 1)
bias   = random.uniform(-1, 1)

# Các số dương là True, số âm là False
data  = [(i * 0.1, True)  for i in range(1, 501)]
data += [(i * 0.1, False) for i in range(-500, 0)]
random.shuffle(data)

for epoch in range(EPOCHS):
    for value, result in data:
        prediction = (weight * value + bias) > 0
        
        if prediction != result:
            error = result - prediction  # +1 hoặc -1
            weight += learning_rate * error * value
            bias   += learning_rate * error

decision_boundary = -bias / weight
print(f"weight = {weight:.3f}")
print(f"bias   = {bias:.3f}")
print(f"decision boundary = {decision_boundary:.3f}")

Để biến máy này thành máy "qua môn", bạn chỉ cần thay đổi dữ liệu thành điểm thi với kết quả là score >= 50. Mọi thứ khác vẫn giữ nguyên.

Kết luận

Bạn vừa xây dựng xong một Perceptron hoạt động thực sự. Nó nhận đầu vào, cân nhắc trọng số, thêm độ lệch và đưa ra quyết định. Nó học từ chính sai lầm của mình, từng epoch một.

Một nơ-ron đơn lẻ chỉ có thể vẽ một đường thẳng. Nhưng phép màu bắt đầu khi bạn xếp chồng chúng lên nhau: đầu ra của nơ-ron này trở thành đầu vào của nơ-ron tiếp theo. Xếp đủ nhiều nơ-ron lại với nhau, bạn sẽ có một mạng nơ-ron (neural network) có thể học được những hình dạng phức tạp hơn nhiều so với một đường thẳng đơn giản. Nhưng mỗi nơ-ron trong số đó đều đang làm chính xác những gì bạn vừa thấy. Một trọng số, một độ lệch, một quyết định.