Học Mạng Nơ-ron với Equinox và Optics

Bảng mục lục:

1. Giới thiệu
2. Chuẩn bị
3. Xây dựng mô hình mạng nơ-ron đơn giản
4. Định nghĩa hàm mất mát và gradient
5. Tối ưu hóa tham số mô hình
6. Lặp lại và hiệu chỉnh
7. Phân tích kết quả
8. Kết luận

Giới thiệu

Trong video này, chúng ta sẽ sử dụng framework deep learning Equinox kết hợp với gradient processing framework Optics trong Python để học một mạng nơ-ron đơn giản mô phỏng hàm sine. Đầu tiên, chúng ta sẽ tạo ra một số dữ liệu nhân tạo có dạng giống hàm sine. Tiếp theo, chúng ta sẽ định nghĩa kiến trúc mạng nơ-ron bằng cách kế thừa một module từ Package Equinox. Sau đó, chúng ta sẽ sử dụng engine differentiation tự động và p2 dot jacks để tạo ra các hàm cho chúng ta dự đoán độ dốc của trọng số. Cuối cùng, chúng ta sẽ triển khai một vòng lặp huấn luyện đơn giản để cập nhật tất cả các tham số sao cho mạng nơ-ron cuối cùng dự đoán tương đối giống như hàm sine.

Chuẩn bị

Trước tiên, chúng ta cần import các gói cần thiết. Chúng ta sẽ sử dụng gói Jacks, gói Equinox, gói Optics, gói matplotlib và gói typing. Hãy chắc chắn rằng bạn đã cài đặt các gói này trước khi tiếp tục.

import jax
import jax.numpy as jnp
import equinox as eqx
import optics
import matplotlib.pyplot as plt
from typing import List

Tiếp theo, chúng ta sẽ định nghĩa các siêu tham số cho việc huấn luyện. Chúng ta sẽ sử dụng 200 mẫu dữ liệu như một tập dữ liệu đồ chơi và mạng nơ-ron sẽ được huấn luyện trong 30,000 epoch.

num_samples = 200
num_epochs = 30000
learning_rate = 0.1

Xây dựng mô hình mạng nơ-ron đơn giản

Để xây dựng mô hình mạng nơ-ron, chúng ta sẽ tạo một lớp đơn giản kế thừa từ module trong gói Equinox. Lớp này sẽ định nghĩa kiến trúc của mạng nơ-ron, trong trường hợp này là một mạng nơ-ron truyền thẳng với một lớp input, Hai lớp ẩn và một lớp output.

class SimpleMLP(eqx.Module):
    def __init__(self, layer_sizes: List[int], random_key: jax.random.PRNGKey):
        super().__init__()
        self.layers = []
        key, *subkeys = jax.random.split(random_key, len(layer_sizes))
        for fan_in, fan_out in zip(layer_sizes[:-1], layer_sizes[1:]):
            self.layers.append(eqx.neural_network.LinearTransformation(
                fan_in=fan_in, fan_out=fan_out, use_bias=True, key=key))
            key = subkeys.pop(0)

    def __call__(self, x):
        a = x
        for layer in self.layers:
            a = eqx.neural_network.sigmoid(layer(a))
        return a

Trong hàm tạo, chúng ta sẽ khởi tạo các lớp truyền thẳng và lưu trữ chúng trong attribute layers. Mỗi lớp truyền thẳng sẽ là một phép nhân ma trận-vector cộng với một giá trị bias. Chúng ta sẽ định nghĩa số chiều đầu vào và số chiều đầu ra cho mỗi lớp truyền thẳng, sử dụng các subkey từ việc chia key ban đầu.

Trong phương thức __call__, chúng ta sẽ lặp qua từng lớp và áp dụng phép biến đổi tuyến tính cộng với bias. Sau đó, chúng ta sẽ áp dụng hàm kích hoạt sigmoid để tạo thành một mạng nơ-ron hoàn chỉnh.

Định nghĩa hàm mất mát và gradient

Để đánh giá hiệu suất của mạng nơ-ron, chúng ta sẽ định nghĩa hàm mất mát. Trong trường hợp này, chúng ta sẽ sử dụng hàm bình phương sai giữa giá trị dự đoán và giá trị thực tế.

def model_to_loss(model, x, y):
    predictions = jax.vmap(model)(x)
    loss = jnp.mean((predictions - y) ** 2)
    return loss

Chúng ta cũng cần tính đạo hàm của hàm mất mát theo các tham số của mô hình. Để làm điều này, chúng ta sẽ sử dụng hàm jax.value_and_grad từ gói Jacks, kết hợp với hàm eqx.filter_values_and_gradients để tạo ra gradient của từng tham số.

def model_to_loss_and_gradient(model, x, y):
    loss, gradients = eqx.filter_values_and_gradients(jax.value_and_grad(model_to_loss))(model, x, y)
    return loss, gradients

Tối ưu hóa tham số mô hình

Trước khi chúng ta bắt đầu quá trình huấn luyện, chúng ta cần tạo ra một trạng thái tối ưu hóa ban đầu bằng cách sử dụng hàm opt.init từ gói Optics. Chúng ta cũng cần truy cập các tham số của mô hình và sử dụng chúng làm input cho trạng thái tối ưu hóa.

def initialize_optimizer_state(model):
    parameters = eqx.filter_values(model)
    optimizer = optics.SGD(learning_rate)
    optimizer_state = optimizer.init(parameters)
    return optimizer_state

Sau đó, chúng ta có thể sử dụng trạng thái tối ưu hóa này để cập nhật các tham số của mô hình. Chúng ta sẽ sử dụng hàm opt.update từ gói Optics, truyền vào gradient, trạng thái tối ưu hóa hiện tại và mô hình để nhận lại các cập nhật và trạng thái tối ưu hóa mới.

def make_step(model, optimizer_state, x, y):
    loss, gradients = model_to_loss_and_gradient(model, x, y)
    updates, optimizer_state = optimizer.update(gradients, optimizer_state, model)
    model = eqx.apply_updates(model, updates)
    return model, optimizer_state, loss

Lặp lại và hiệu chỉnh

Bây giờ chúng ta đã chuẩn bị đầy đủ, chúng ta có thể bắt đầu vòng lặp huấn luyện. Chúng ta lặp lại các epoch và trong mỗi epoch, chúng ta cập nhật các tham số của mô hình bằng cách sử dụng hàm make_step. Chúng ta cũng lưu trữ các giá trị mất mát vào một danh sách để sau này có thể hiển thị biểu đồ.

loss_history = []
for epoch in range(num_epochs):
    model, optimizer_state, loss = make_step(model, optimizer_state, x_train, y_train)
    loss_history.append(loss)
    if epoch % 100 == 0:
        print(f"Epoch {epoch}: loss = {loss}")

Phân tích kết quả

Sau khi hoàn thành quá trình huấn luyện, chúng ta có thể phân tích kết quả bằng cách trực quan hóa các điểm dữ liệu thực tế và dự đoán của mô hình.

plt.scatter(x_train, y_train, label="Ground Truth")
plt.scatter(x_train, model(x_train), label="Prediction")
plt.legend()
plt.show()

Kết quả cuối cùng là mô hình đã học cách dự đoán một hàm tương tự hàm sine với một số sai số nhỏ.

Kết luận

Trong video này, chúng ta đã sử dụng framework Equinox và Optics để huấn luyện một mạng nơ-ron đơn giản nhằm mô phỏng hàm sine. Chúng ta đã tạo ra dữ liệu nhân tạo giống hàm sine, xây dựng mô hình mạng nơ-ron, định nghĩa hàm mất mát và gradient, tối ưu hóa các tham số của mô hình và lặp lại quá trình huấn luyện. Kết quả cuối cùng là mô hình đã học cách dự đoán một hàm gần giống hàm sine trên tập dữ liệu nhân tạo.