Skip to content

Transformation & ReLU activation function

Phần 1: Hàm kích hoạt ReLU

Đây là một trong những phần minh họa hay nhất về sức mạnh của hàm kích hoạt ReLU, một khái niệm nền tảng của mạng neural hiện đại.

Mục tiêu chính của chương này là trả lời câu hỏi: "Làm thế nào một hàm đơn giản như ReLU, vốn chỉ là một đường thẳng bị 'bẻ gãy' tại điểm 0, lại có thể giúp mạng neural học được các mối quan hệ phi tuyến vô cùng phức tạp (như hình sin)?"

Hãy cùng mổ xẻ nó từng bước một.

Tóm Tắt Ý Tưởng Lớn (The Big Idea)

Hãy tưởng tượng bạn chỉ có các viên gạch LEGO thẳng. Làm thế nào để dùng chúng xây một bức tường cong?

Câu trả lời là: Bạn không thể tạo ra một đường cong mượt mà, nhưng bạn có thể xấp xỉ (approximate) nó bằng cách ghép rất nhiều viên gạch thẳng ngắn lại với nhau. Càng nhiều viên gạch ngắn, bức tường của bạn trông sẽ càng cong và mượt.

Trong mạng neural:

  • Hàm ReLU chính là viên gạch thẳng của chúng ta.
  • Mỗi neuron (hoặc cặp neuron) là một người thợ xây, có nhiệm vụ đặt một viên gạch.
  • Mạng neural là cả công trình, ghép các viên gạch này lại để tạo ra hình dạng phức tạp cuối cùng (như đường cong hình sin).

Giờ hãy đi vào chi tiết cách "người thợ" neuron làm việc.

Khối Xây Dựng Cơ Bản - Một Neuron ReLU

Một neuron nhận đầu vào (input), nhân với trọng số (weight), cộng với thiên vị (bias), rồi cho qua hàm kích hoạt ReLU.

Công thức: output = ReLU(weight * input + bias) Hàm ReLU: ReLU(x) = max(0, x). Nghĩa là: * Nếu x <= 0, kết quả là 0. * Nếu x > 0, kết quả là x.

Nó giống như một cái cổng: * Input tính toán ra âm -> Cổng đóng -> Output = 0. * Input tính toán ra dương -> Cổng mở -> Output = giá trị tính được.

Vai trò của Trọng số (Weight) và Thiên vị (Bias):

  1. Trọng số (Weight): Thay đổi độ dốc.

    • Weight lớn -> Đường dốc lên nhanh hơn.
    • Weight nhỏ -> Đường dốc lên thoải hơn.
    • Weight âm -> Đường bị lật ngược, dốc xuống.

  2. Thiên vị (Bias): Dịch chuyển điểm "bẻ gãy".

    • Bias quyết định tại giá trị input nào thì neuron bắt đầu "kích hoạt" (tức là cho ra output > 0). Nó dịch chuyển đồ thị sang trái hoặc phải.

Minh họa ASCII:

Hãy xem đồ thị của một neuron ReLU. Trục hoành là input, trục tung là output.

Text Only
        Cơ bản (w=1, b=0)          Tăng Weight (w=2)           Thêm Bias (w=1, b= -1)
           /                          //                              /
          /                          / /                             /
         /                          / /                             /
        +------- (input)          +------- (input)                +------- (input)
                                                                 |
                                                               (điểm bẻ gãy dịch sang phải)

Tóm lại: Với một neuron, chúng ta có thể tạo ra một "đoạn dốc" bắt đầu từ một điểm tùy ý và có độ dốc tùy ý. Nhưng nó vẫn chỉ là một đường thẳng.

Phép Màu Bắt Đầu - Kết Hợp Hai Neuron

Đây là phần cốt lõi và kỳ diệu nhất. Sách minh họa bằng cách dùng một cặp neuron (một ở lớp ẩn 1, một ở lớp ẩn 2). Khi kết hợp chúng lại, chúng ta có thể tạo ra một thứ gọi là "vùng ảnh hưởng" (area of effect).

Hãy tưởng tượng thế này:

  1. Neuron 1 (Neuron "Kích hoạt"): Tạo ra một đường dốc lên.

    • Ví dụ: y1 = ReLU(1.0 * x - 0.2)
    • Nó sẽ tạo ra một đường dốc lên, bắt đầu từ x = 0.2.

  2. Neuron 2 (Neuron "Vô hiệu hóa"): Tạo ra một đường dốc xuống.

    • Ví dụ: y2 = ReLU(-1.0 * x + 0.8)
    • Nó sẽ tạo ra một đường dốc xuống, bắt đầu từ x = 0.8.

Khi bạn cộng kết quả của hai neuron này lại (đây là điều xảy ra ở lớp tiếp theo), điều thú vị sẽ xảy ra:

  • Khi x < 0.2: Cả hai neuron đều cho output là 0. Tổng là 0.
  • Khi 0.2 < x < 0.8: Neuron 1 hoạt động (dốc lên), Neuron 2 vẫn là 0. Tổng là một đường dốc lên.
  • Khi x > 0.8: Cả hai neuron đều hoạt động. Đường dốc lên của Neuron 1 sẽ bị triệt tiêu bởi đường dốc xuống của Neuron 2. Tổng là một đường nằm ngang.

Kết quả là một hình "cái lều" hoặc "cái nón"!

Minh họa ASCII:

Text Only
   Đầu ra của Neuron 1        +    Đầu ra của Neuron 2        =       Kết quả cuối cùng
  (dốc lên từ x=0.2)               (dốc xuống từ x=0.8)                 (hình cái lều)
            /                                 |                               /\
           /                                  |                              /  \
          /                                   |                             /    \
---------+---------- (input)    --------------+---------- (input)   ---------+----+------ (input)
       0.2                                  0.8                             0.2  0.8
                                              \
                                               \

Đây chính là "viên gạch LEGO" hình tam giác của chúng ta! Bằng cách điều chỉnh weight và bias của cặp neuron này, chúng ta có thể kiểm soát: * Vị trí của cái lều (dịch trái/phải). * Chiều cao của cái lều. * Độ dốc của hai bên sườn lều.

Xây Dựng Sóng Sin - Ghép Nhiều "Viên Gạch"

Bây giờ bạn đã có những "viên gạch hình lều". Việc xấp xỉ một đường cong hình sin trở nên đơn giản:

Bạn chỉ cần dùng nhiều cặp neuron, mỗi cặp tạo ra một "cái lều" để mô phỏng một đoạn của sóng sin.

  • Cặp neuron 1: Tạo ra đoạn dốc lên đầu tiên của sóng sin.
  • Cặp neuron 2: Tạo ra đoạn dốc xuống tiếp theo.
  • Cặp neuron 3: Tạo ra đoạn dốc lên của phần âm.
  • ... và cứ thế.

Quá trình "hand-tuning" (chỉnh tay) trong sách (từ Fig 4.20 đến 4.33) chỉ là để minh họa cho bạn thấy: * "À, nếu tôi chỉnh weight này, cái dốc này sẽ cao hơn." * "Nếu tôi chỉnh bias kia, cái lều này sẽ dịch sang phải." * "Nếu tôi dùng weight âm ở đầu ra, cái lều sẽ bị lật ngược xuống dưới (tạo ra đáy của sóng sin)."

Minh họa trừu tượng bằng ASCII:

Text Only
   Sóng sin mục tiêu:
       __/ \__
      /     \
     /       \
            / \
    _______/   \______

   Mạng neural xấp xỉ bằng cách cộng các "cái lều":

     Lều 1      Lều 2 (lật ngược)     Lều 3...
       /\               _                /\
      /  \             / \              /  \
     /    \           /   \            /    \
    -------  +      \/     +  ...   =   Kết quả gần giống sóng sin

Tổng Kết

  1. Sức mạnh của ReLU: Bản thân ReLU rất đơn giản, nhưng khi được kết hợp trong một mạng lưới nhiều lớp, chúng có khả năng tạo ra các hàm tuyến tính từng đoạn (piecewise linear) vô cùng phức tạp. Những hàm này có thể xấp xỉ bất kỳ hàm liên tục nào (đây là ý tưởng của Định lý Xấp xỉ Phổ quát - Universal Approximation Theorem).

  2. Tại sao cần nhiều lớp ẩn? Lớp ẩn đầu tiên tạo ra các "đoạn dốc". Lớp ẩn thứ hai kết hợp các "đoạn dốc" đó để tạo thành các "cái lều". Các lớp sau có thể kết hợp các "cái lều" này thành những hình dạng còn phức tạp hơn nữa.

  3. Từ "Chỉnh Tay" đến "Tự Học": Việc chỉnh tay các thông số trong sách rất tốn công và chỉ mang tính minh họa. Trong thực tế, quá trình huấn luyện (training) mạng neural chính là quá trình máy tính tự động tìm ra các giá trị weight và bias tốt nhất cho tất cả các neuron, để kết quả đầu ra của mạng khớp với dữ liệu mục tiêu nhất có thể. Bộ tối ưu hóa (optimizer) như Gradient Descent chính là "kiến trúc sư trưởng" làm công việc này.

  4. Nhiều Neuron Hơn = Tốt Hơn: khi tăng số neuron lên, ví dụ: 64, mạng có nhiều "viên gạch" hơn để xây dựng. Kết quả là đường cong xấp xỉ trông mượt mà và chính xác hơn rất nhiều.

ReLU, dù đơn giản, lại là nền tảng cho sức mạnh phi thường của mạng neural hiện đại.

Phần 2: Đi sâu vào quá trình biến đổi một điểm dữ liệu duy nhất.

Giả sử chúng ta có:

  • Một điểm dữ liệu đầu vào O có tọa độ (0.5, 1.0).
  • Một lớp Layer_Dense có 2 đầu vào và 3 neuron.

1. Khởi Tạo (Initialization)

Lớp dense1 được khởi tạo với weights và biases. Giả sử sau khi khởi tạo ngẫu nhiên, chúng ta có các giá trị cụ thể như sau:

Ma trận Trọng số W (self.weights) - Kích thước (2, 3)

  • Hàng 0: Trọng số cho đầu vào thứ nhất (i1 = 0.5).
  • Hàng 1: Trọng số cho đầu vào thứ hai (i2 = 1.0).
  • Cột 0, 1, 2: Tương ứng với Neuron 0, 1, 2.
Text Only
          Neuron 0   Neuron 1   Neuron 2
         +----------+----------+----------+
Input 0  |   0.2    |   0.8    |  -0.5    |
(i1=0.5) +----------+----------+----------+
Input 1  |  -0.9    |   0.2    |   0.4    |
(i2=1.0) +----------+----------+----------+

Vector Bias b (self.biases) - Kích thước (1, 3)

  • Mỗi giá trị tương ứng với thiên kiến của một neuron.
Text Only
         +----------+----------+----------+
         |   2.0    |   3.0    |   0.5    |
         +----------+----------+----------+
           Neuron 0   Neuron 1   Neuron 2

2. Quá trình Biến đổi (Transformation) - dense1.forward(O)

Chúng ta thực hiện phép toán: v' = v · W + b

Bước 2.1: Phép nhân ma trận (Dot Product) v · W

  • v là vector đầu vào: [0.5, 1.0] (Kích thước 1x2)
  • W là ma trận trọng số (Kích thước 2x3)
  • Kết quả sẽ là một vector kích thước 1x3.
Text Only
                                       +-------+-------+-------+
                                       |  0.2  |  0.8  | -0.5  |
                                       | -0.9  |  0.2  |  0.4  |
                                       +-------+-------+-------+
                                                 ^
                                                 |
                                                 · (Dot Product)
+-------+-------+
|  0.5  |  1.0  |
+-------+-------+
      |
      +-------------------------------------------------------------+
      |                                                             |
      v                                                             v
    Tính toán cho Neuron 0:                                       Tính toán cho Neuron 1:
    (0.5 * 0.2) + (1.0 * -0.9)                                    (0.5 * 0.8) + (1.0 * 0.2)
    = 0.1 - 0.9                                                   = 0.4 + 0.2
    = -0.8                                                        = 0.6

                                                                     Tính toán cho Neuron 2:
                                                                     (0.5 * -0.5) + (1.0 * 0.4)
                                                                     = -0.25 + 0.4
                                                                     = 0.15

Kết quả của phép nhân ma trận là vector [-0.8, 0.6, 0.15].

Bước 2.2: Cộng Vector Bias + b

Bây giờ, chúng ta lấy kết quả ở trên và cộng với vector bias.

Text Only
      Kết quả từ v · W                  Vector Bias b                Vector đầu ra v'
+--------+-------+--------+     +     +-------+-------+-------+     =     +-------+-------+-------+
|  -0.8  |  0.6  |  0.15  |           |  2.0  |  3.0  |  0.5  |           |  1.2  |  3.6  |  0.65 |
+--------+-------+--------+           +-------+-------+-------+           +-------+-------+-------+
     |        |        |                 |        |        |                 |        |        |
     |        |        +-----------------|--------|--------|-----------------+        |
     |        +--------------------------|--------|--------+--------------------------+
     +-----------------------------------|--------+-----------------------------------+

     -0.8 + 2.0 = 1.2
           0.6 + 3.0 = 3.6
                 0.15 + 0.5 = 0.65

Kết quả: Vector v' (đầu ra của dense1) là [1.2, 3.6, 0.65]. Đây chính là tọa độ của điểm O trong không gian 3 chiều mới sau phép biến đổi tuyến tính.

3. Kích Hoạt ReLU - activation1.forward(v')

Bây giờ, chúng ta đưa vector v' qua hàm ReLU. Hàm này hoạt động trên từng phần tử (element-wise).

Text Only
     Vector đầu vào v' cho ReLU           Hành động của ReLU           Vector cuối cùng v''
+-------+-------+-------+        max(0, x)       +-------+-------+-------+
|  1.2  |  3.6  |  0.65 |  ---------------->     |  1.2  |  3.6  |  0.65 |
+-------+-------+-------+                        +-------+-------+-------+
     |        |        |
     |        |        +-----> max(0, 0.65) = 0.65
     |        +--------------> max(0, 3.6)  = 3.6
     +-----------------------> max(0, 1.2)  = 1.2

Trong ví dụ này, vì tất cả các thành phần của v' đều là số dương, nên đầu ra của ReLU v'' giống hệt v'.

Nếu v' là [-0.8, 0.6, 0.15] (trước khi cộng bias), thì kết quả sẽ khác:

Text Only
     Vector đầu vào v' cho ReLU           Hành động của ReLU           Vector cuối cùng v''
+--------+-------+--------+        max(0, x)       +-------+-------+--------+
|  -0.8  |  0.6  |  0.15  |  ---------------->     |  0.0  |  0.6  |  0.15  |
+--------+-------+--------+                        +-------+-------+--------+
     |        |        |
     |        |        +-----> max(0, 0.15) = 0.15
     |        +--------------> max(0, 0.6)  = 0.6
     +-----------------------> max(0, -0.8) = 0.0

Sơ đồ này đã mô tả toàn bộ quá trình toán học từ một vector đầu vào v đến vector cuối cùng v'' sau khi qua một lớp dày đặc và một lớp kích hoạt ReLU.

Trừu tượng hóa

Mỗi neuron đóng góp vào việc tạo ra "chữ ký" cuối cùng như thế nào?

Phân Tích

  1. Neural 1 đóng góp một phần vào việc tạo ra chữ ký cuối cùng.
    Nó giống như một nhạc công trong dàn nhạc. Nhạc công violin không "mang" bản giao hưởng, anh ta chỉ chơi phần violin của mình. Bản giao hưởng (chữ ký) là sự kết hợp của tất cả các nhạc công.
    Cách diễn đạt chính xác hơn: "Neuron 1 có một bộ tiêu chí riêng (weights và bias của nó)."

  2. "biến đổi O(x,y) → O'(x,y,z)": Toàn bộ lớp (gồm cả 3 neuron) cùng nhau thực hiện phép biến đổi này.

Diễn Giải

  1. Mỗi Neuron là một "Máy Đo Đặc Trưng":

    • Neuron 1 được trang bị một bộ tiêu chí (w1, b1). Nó đo xem điểm O(x,y) phù hợp với tiêu chí này đến đâu và cho ra một điểm số là x'.
    • Neuron 2 được trang bị một bộ tiêu chí (w2, b2). Nó đo xem điểm O(x,y) phù hợp với tiêu chí này đến đâu và cho ra một điểm số là y'.
    • Neuron 3 được trang bị một bộ tiêu chí (w3, b3). Nó đo xem điểm O(x,y) phù hợp với tiêu chí này đến đâu và cho ra một điểm số là z'.

  2. Tạo Ra "Chữ Ký":

    • "Chữ ký" của điểm O không phải là do một neuron tạo ra. "Chữ ký" chính là vector kết quả O'(x', y', z'). Nó là tập hợp các điểm số mà tất cả các "máy đo" đã đưa ra.

  3. Mục Tiêu Huấn Luyện (Training):

    • Quá trình huấn luyện sẽ điều chỉnh các bộ tiêu chí (w, b) của từng neuron sao cho:
      • Tất cả các điểm O thuộc lớp "Xanh" khi đi qua 3 "máy đo" này sẽ tạo ra các vector O' (các chữ ký) nằm gần nhau trong một vùng không gian.
      • Tất cả các điểm O thuộc lớp "Đỏ" sẽ tạo ra các chữ ký nằm gần nhau trong một vùng không gian khác.
      • Và tương tự cho lớp "Lá".

Sơ Đồ ASCII Phản Ánh Ý Tưởng Này

Text Only
  Điểm Đầu Vào O(x,y)
          |
          |
+---------+---------+
|                   |
v                   v
Máy Đo 1            Máy Đo 2            Máy Đo 3
(Tiêu chí w1, b1)   (Tiêu chí w2, b2)   (Tiêu chí w3, b3)
|                   |                   |
v                   v                   v
Điểm số x'          Điểm số y'          Điểm số z'
|                   |                   |
+---------+---------+-------------------+
          |
          v
"Chữ Ký" = O'(x', y', z')
(Vector kết quả trong không gian mới)

Ví dụ: Sau khi huấn luyện, có thể xảy ra trường hợp:

  • Tiêu chí 1 (của Neuron 1) trở thành "phát hiện đường cong hướng lên".
  • Tiêu chí 2 (của Neuron 2) trở thành "phát hiện vị trí gần gốc tọa độ".
  • Một điểm O thuộc lớp "Xanh" có thể vừa cong lên, vừa gần gốc tọa độ. Chữ ký của nó sẽ là O'(CAO, CAO, ...).
  • Một điểm O thuộc lớp "Đỏ" có thể cong lên nhưng xa gốc tọa độ. Chữ ký của nó sẽ là O'(CAO, THẤP, ...).

Kết luận: Mỗi neuron có một vai trò riêng. Vai trò đó là "đo lường một đặc trưng". "Chữ ký" cuối cùng của một điểm dữ liệu là tổ hợp kết quả từ tất cả các phép đo đặc trưng đó.