Mạng Neural Network

I. Giới thiệu

Cùng với sự bùng nổ dữ liệu và cải tiến về hiệu suất tính toán, mô hình Neural Network ngày càng trở nên thịnh hành và đạt được nhiều thành công trong lĩnh vực máy học, tiêu biểu là trong việc giải quyết các bài toán phân lớp. Nói đến bài toán phân lớp, chúng ta nhớ đến hai thuật toán nổi tiếng đã làm quen trước đó là Logistic Regression và Softmax Regression.

Vậy tại sao chúng ta lại cần Neural Network trong khi đã có các thuật toán trước, cũng như nhờ đâu mà Neural Network tạo nên được sức mạnh lớn và đóng vai trò quan trọng đến thế?

Tại sao cần Neural Network?

Tất nhiên chúng ta đều biết không có thuật toán nào là tốt nhất cho tất cả các bài toán. Tuy nhiên cùng xem ví dụ dưới đây để rõ hơn về vấn đề mà Logistic Regression và Softmax Regression đang gặp phải cũng như Neural Network giải quyết bài toán đó như thế nào.

Hãy lấy ví dụ là một bài toán phân lớp nhị phân (hình trái) và sử dụng Logistic Regression để giải bài toán đó (hình phải):

Có thể thấy, đối với dữ liệu phi tuyến, Logistic Regression khá bối rối và đưa ra kết quả dự đoán kém chính xác. Đối với dạng dữ liệu này, ta không chỉ thuần thuý sử dụng một đường thẳng để phân chia 2 loại dữ liệu mà cần một đường cong có hình dạng phức tạp để có được mô hình chính xác hơn. Và khi sử dụng đường cong, đạo hàm sẽ liên tục đổi dấu - tương đương với số bậc của hàm số, theo đó là yêu cầu các trọng số tương ứng với mỗi thành phần trong đa thức. Với ví dụ trên ta thấy có hai feature, nếu đường cong đơn giản, đạo hàm chỉ đổi dấu một lần thì ta cần hàm bậc hai gồm $x_1 ^{2}$, $x_2 ^{2}$, $x_1x_2$; nếu là hàm bậc ba sẽ gồm $x_1^{3}$, $x_2^{3}$, $x_1^{2}x_2$, $x_1x_2^{2}$;... Tương tự, dữ liệu càng phức tạp, số feature càng nhiều thì số lượng trọng số càng lớn và điều này vượt ngoài khả năng của một mô hình Logistic Regression truyền thống. Đặc biệt điều này càng thể hiện rõ ràng hơn với dữ liệu đầu vào là dạng hình ảnh.

Lấy ví dụ dữ liệu đầu vào là một bức ảnh như trên với kích thước, ví dụ là 224 x 224 pixels. Mắt người dễ dàng nhận biết đây là hình ảnh một con mèo, nhưng máy tính chỉ nhận dưới dạng các con số:

Mỗi pixel lưu trữ 3 kênh màu với mỗi kênh màu là một giá trị từ 0 - 255. Tương ứng cho 224 x 224 pixels. Và khi đó số lượng feature cũng như trọng số cần học sẽ rất lớn và mô hình Logistic Regression truyền thống với cấu trúc đơn giản sẽ không xử lý được. Để đáp ứng nhu cầu phân lớp cho các bài toán có dữ liệu phức tạp như trên, đòi hỏi phải có một mô hình mạnh mẽ, phức tạp và hiệu quả hơn.

Quay lại với ví dụ đầu tiên, hãy thử sử dụng Neural Network để giải:

Có thể thấy mô hình Neural Network cho lại kết quả phân lớp có độ chính xác cao. Lý do là vì Neural Network có thể lưu trữ một số lượng các tham số tự do (bao gồm trọng số và bias) rất lớn. Điều này mang lại cho mô hình sự linh hoạt và phù hợp đối với các dạng dữ liệu phức tạp mà các mô hình khác lại quá đơn giản để phù hợp.

Trên đây là những lý do khiến Neural Network trở nên đặc biệt quan trọng. Ở phần sau, bài viết sẽ cung cấp đến các bạn cái nhìn chi tiết hơn về Neural Network và cách triển khai các mô hình Neural Network.

2.Phương pháp

2.1. Mô hình Neural Network

Về nguồn gốc ra đời, những mô hình neural network đầu tiên được lấy cảm hứng từ mạng lưới tế bào thần kinh của não bộ con người cũng như cách tổ chức hoạt động của nó. Cụ thể, mạng lưới này có khoảng 10 triệu nơ-ron, mỗi nơ-ron trong đó liên kết với khoảng 10.000 nơ-ron khác qua các sợi nhánh. Về nguyên lí hoạt động, ta có thể hiểu đơn giản rằng mỗi nơ-ron sẽ nhận dữ liệu đầu vào qua sợi nhánh và truyền dữ liệu đầu ra qua sợi trục đến các sợi nhánh nối với các nơ ron khác Dựa trên ý tưởng này, con người đã xây dựng nên những mô hình neural network đầu tiên với kiến trúc gồm các layer liên kết với nhau, mỗi layer gồm các node thành phần đóng vai trò như các đơn vị xử lý cơ bản (unit)

Cụ thể, mỗi unit trong mạng có cách hoạt động tương tự như thuật toán logistic regression với quy trình như sau:

Theo đó, quy trình tính toán trên sẽ gồm 2 bước:

• Tính tổng z = $w_0$ 1 + $w_1$ $x_1$ + $w_2$ * $x_2$
• Đưa z vào hàm kích hoạt sigmoid để có được kết quả output: $\widehat{y}$ = σ(z)

Khác với logistic regression chỉ sử dụng hàm kích hoạt mặc định là sigmoid, các unit trong mạng có thể có các hàm kích hoạt khác nhau để phù hợp cho quá trình xử lý và tính toán. Một số hàm kích hoạt được sử dụng phổ biến là: sigmoid, tanh, ReLU. Trong đó:

• Sigmoid và Tanh là 2 hàm phi tuyến có chức năng đưa kết quả về miền giá trị thu hẹp, cụ thể sigmoid có miền giá trị là (0,1) và tanh có miền giá trị là (-1,1)

  

• Khác với 2 hàm phi tuyến trên, ReLU mang bản chất là 1 hàm tuyến tính có miền giá trị từ 0 và tăng tuyến tính đến dương vô cùng

  

• Các hàm kích hoạt này sẽ được lựa chọn để sử dụng phù hợp tùy theo tính chất và chức năng của các layer trong mô hình neural network

Quay trở lại với mô hình tổng quát của neural network, về mặt cấu trúc mô hình này gồm 3 tầng lần lượt là input layer, hidden layers, output layer. Trong đó:

• Input layer: là tầng đầu tiên của mô hình có nhiệm vụ nhận dữ liệu đầu vào

• Hidden layers: là tầng nằm giữa input layer và output layer, gồm 1 hoặc nhiều layer thể hiện cho quá trình suy luận logic của mô hình

• Output layer: là tầng cuối cùng thể hiện kết quả đầu ra của mô hình 
  

Về quá trình huấn luyện mô hình, neural network sử dụng 2 cơ chế lan truyền là lan truyền xuôi (forward propagation) và lan truyền ngược (backpropagation). Cụ thể:

• Lan truyền xuôi là quá trình tính toán của mạng theo một chiều duy nhất từ input layer đến output layer, theo đó mỗi unit trong mạng sẽ nhận đầu vào là tất cả các unit thuộc layer trước đó, sau đó trải qua quá trình tính toán và gửi kết quả đến các unit thuộc layer sau. 
• Lan truyền ngược là quá trình ngược lại so với lan truyền xuôi, phương thức này sẽ duyệt neural network theo chiều từ output layer đến input layer và sử dụng phương pháp gradient descent để cập nhật trọng số cho các unit thuộc từng layer

2 cơ chế này được sử dụng kết hợp với nhau trong quá trình huấn luyện neural network. Cụ thể trong mỗi lần lặp, dữ liệu sẽ được đưa vào mô hình và trải qua quá trình lan truyền xuôi để đưa ra kết quả dự đoán (prediction), sau đó sử dụng lan truyền ngược để tính toán gradient của hàm mất mát, từ đó cập nhật trọng số cho từng layer lần lượt từ output layer ngược lại cho đến input layer

Đến đây, ta đã nắm được khái quát về ý tưởng của neural network cũng như cách hoạt động của mô hình này. Ta sẽ đến với phần tiếp theo để có thể hiểu rõ hơn về những điểm giống và khác nhau của neural network so với 2 thuật toán trước đó là logistic regression và softmax regression

2.2. So sánh với Logistic Regression & Softmax Regression

Về bản chất, ta có thể thiết kế logistic regression hoặc softmax regression dưới dạng mô hình neural network đơn giản nhất với chỉ 3 lớp là input layer, 1 hidden layer và output layer, theo đó dữ liệu được đưa vào để tính toán và sử dụng hàm kích hoạt để cho ra kết quả cần tìm. Trong đó, logistic regression sử dụng hàm kích hoạt là sigmoid, còn softmax regression sử dụng hàm kích hoạt là softmax (như hình dưới đây)

Nhờ có lợi thế trong việc phân loại đối tượng vào nhiều lớp, hàm softmax thường được sử dụng làm output layer trong mô hình neural network

Qua đó, ta có thể thấy mô hình neural network có cấu trúc phức tạp hơn nhiều so với 2 thuật toán trên, từ đó có thể phục vụ cho các bài toán phân loại cần rút trích một số lượng feature lớn và phức tạp, giúp mang lại hiệu quả cũng như độ chính xác tốt hơn. Tuy nhiên, để neural network có thể hoạt động tốt cần phải có lượng dữ liệu huấn luyện lớn (vì mô hình có số lượng tham số lớn tùy thuộc vào số layer và số unit mỗi layer), theo đó thời gian sử dụng cho quá trình huấn luyện cũng tiêu tốn hơn rất nhiều.

Nếu tính chất của bài toán đơn giản và lượng dữ liệu huấn luyện ít, ta có thể cân nhắc sử dụng logistic regression (cho bài toán phân loại nhị phân) hoặc softmax regression (cho bài toán phân loại đa lớp). Còn nếu bài toán có tính chất phức tạp và lượng dữ liệu huấn luyện đủ lớn, neural network sẽ là lựa chọn ưu tiên để giải quyết vấn đề.

3. Cài đặt chương trình

Để minh họa cách áp dụng Neural Network, chúng ta sẽ tiến hành cài đặt một mạng Neural Network đơn giản cho bài toán phân loại trên tập dữ liệu MNIST. Đây là bộ dữ liệu chữ số viết tay gồm 70,000 ảnh đen trắng và mỗi ảnh có kích thước là $28 \times 28$.

Khởi tạo môi trường

Ở trong bài hướng dẫn lần này, chúng ta sẽ sử dụng thư viện Pytoch để tải dữ liệu; cài đặt, huấn luyện và đánh giá mô hình. Bên cạnh đó, để phục vụ cho việc trực quan hóa chúng ta cũng sẽ cần dùng đến thư viện Matplotlib.

import torch
import torchvision
import matplotlib.pyplot as plt

import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim

Một số siêu tham số cần phải thiết lập

n_epochs = 3             # Số epoch huấn luyện
batch_size_train = 64    # Kích thước batch_size khi huấn luyện
batch_size_test = 64     # Kích thước batch_size khi kiểm tra
learning_rate = 0.01     # Learning_rate
momentum = 0.5           # Giá trị momentum cho thuật toán tối ưu
log_interval = 10        # In giá trị loss sau bao nhiêu iter khi huấn luyện

Đọc và xử lí dữ liệu

Bước tiếp theo chúng ta cần phải đọc dữ liệu và tiền xử lí trước khi đưa vào huấn luyện mô hình.

Ở bước chuẩn hóa dữ liệu gồm 2 phần chính:

• Chuyển ảnh về dạng tensor
• Chuẩn hóa dữ liệu về miền giá trị có giá trị trung bình là 0 và độ lệch chuẩn 1. Mục đích của việc này là làm cho quá trình hội tụ dễ hơn

# Chuẩn hóa dữ liệu: 
transform = torchvision.transforms.Compose([
                torchvision.transforms.ToTensor(), # Chuyển ảnh về dạng tensor
                torchvision.transforms.Normalize((0.1307,),(0.3081,)) #Chuẩn hóa dữ liệu
                                            ])

Tiếp đến chúng ta sẽ lấy dữ liệu từ Pytorch và tiền xử lí dữ liệu bằng hàm xử lí vừa được thiết kế ở trên

# Tải dữ liệu
train = torchvision.datasets.MNIST('/data/', train=True, download=True, transform=transform)
test = torchvision.datasets.MNIST('/data/', train=False, download=True, transform=transform)

Với Pytorch để có thể lấy dữ liệu và đưa vào mô hình thì chúng ta cần đến các Dataloader

train_loader = torch.utils.data.DataLoader(train, batch_size=batch_size_train, shuffle=True)
test_loader = torch.utils.data.DataLoader(test, batch_size=batch_size_test, shuffle=True)

Trực quan hóa dữ liệu

Trước khi đi vào các bước tiếp theo, chúng ta cùng trực quan hóa và phân tích dữ liệu.

Chúng ta có thể lấy một mẫu dữ liệu và kiểm tra một số thông tin như sau:

examples = enumerate(test_loader)
batch_idx, (example_data, example_targets) = next(examples)

#In kích thước dữ liệu ra màn hình
print(example_data.shape)       # example_data là ảnh 
print(example_targets.shape)    # example_targets là nhãn của ảnh

Kết quả xuất ra màn hình:

torch.Size([64, 1, 28, 28])
torch.Size([64])

Ta thấy được mỗi batch có $64$ ảnh do đã batchsize đã được cài đặt bằng $64$ ở trước đó. Mỗi ảnh có kích thước $1 \times 28 \times 28$

Chúng ta trực quan hóa dữ liệu bằng những dòng lệnh sau

fig = plt.figure()
for i in range(6):
    plt.subplot(2,3,i+1)
    plt.tight_layout()
    plt.imshow(example_data[i][0], cmap='gray', interpolation='none') #Hiển thị ảnh 
    plt.title("Ground Truth: {}".format(example_targets[i])) # Hiển thị nhãn
    plt.xticks([])
    plt.yticks([])

Kết quả là một số ảnh có trong bộ dữ liệu và nhãn tương ứng của chúng.

Cài đặt một Neural Network đơn giản

Ở bước này chúng ta cùng thiết kế một Neural Network có thể phân loại chữ viết tay. Ảnh đầu vào có kích thước là $1 \times 28 \times 28$, trước khi được đưa vào mạng thì sẽ được duỗi ra thành một vector có kích thước $1 \times 784$. Mạng có 2 lớp ẩn gồm 128 và 64 nút tương ứng. Đầu ra sẽ là số loại nhãn mà chúng ta cần phân loại, cụ thể trong ví dụ này là 10. Với Pytorch các mô hình thường được thiết kế dưới dạng là một lớp gồm 2 phương thức chính là __init__() có nhiệm vụ khởi tạo mô hình và forward() để đưa dữ liệu qua mạng

class NeuralNet(nn.Module):
    def __init__(self):
        super(NeuralNet, self).__init__()
        self.Net = nn.Sequential(nn.Linear(784, 128),
                      nn.ReLU(),
                      nn.Linear(128, 64),
                      nn.ReLU(),
                      nn.Linear(64, 10),
                      nn.LogSoftmax(dim=1)
                      )

    def forward(self, x):
        x = x.view(-1, 784) # Duỗi ảnh thành vector
        x = self.Net(x)     # Đưa ảnh qua mạng
        return x

* Lưu ý: Tác giả khuyến khích bạn đọc thử tự thiết kế nhiều mạng Neural Network khác nhau.

Chuẩn bị hàm độ lỗi và các hàm tối ưu

Hàm độ lỗi giúp so sánh sự khác biệt giữa nhãn dự đoán từ mô hình được học và nhãn thật của con người. Trong phân loại ảnh thì có nhiều hàm độ lỗi có thể được sử dụng như như Mean Absolute Error (MAE), Mean Square Error (MSE) hay Cross-Entropy (CE).

Tùy dữ liệu và mô hình sử dụng trong bài toán mà sử dụng hàm độ lỗi phù hợp. Trong bài toán này chúng ta sẽ sử dụng hàm Cross-Entropy (CE)

#Khởi tạo hàm mất mát
loss_fuction = nn.NLLLoss()

Tiếp đến chúng ta cần khởi tạo thuật toán tối ưu. Chúng ta thường sử dụng một số thuật toán tối ưu như SGD, RMSProp, Adam.

#Khởi tạo thuật toán tối ưu 
optimizer = optim.SGD(network.parameters(), lr=learning_rate, momentum=momentum)

Cài đặt hàm huấn luyện

Khác với Tensorflow, với Pytorch chúng ta cần phải cài đặt hàm huấn luyện. Trong hàm huấn luyện chúng ta cần thực hiện một số công việc sau: Lặp qua các batch dữ liệu, truyền dữ liệu vào Neural Network, tính mất mát, đạo hàm và lan truyền ngược để cập nhật trọng số cho Neural Network.

def train(epoch, model, optimizer):     
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader): # Lặp qua các batch dữ liệu
        optimizer.zero_grad()
        output = model(data)                    # Đưa dữ liệu vào model
        loss = loss_fuction(output, target)     # So sánh kết quả dữ đoán model với nhãn
        loss.backward()                         # Thực hiện quá trình backpropogation
        optimizer.step()                        # Cập nhật tham số
        if batch_idx % log_interval == 0:
            print('Epoch: {} \t iter {} \t Loss: {:.6f}'.format(
                epoch, batch_idx, loss.item()))
            train_losses.append(loss.item())
    return model

Cài đặt hàm kiểm tra

Cũng như hàm huấn luyện, chúng ta cũng cần phải cài đặt hàm kiểm tra. Với hàm kiểm tra chúng ta chỉ cần đưa dữ liệu vào Neural Network và lấy ra nhãn dữ đoán. Để đánh giá xem Neural Network của chúng ta vừa huấn luyện tốt chưa thì ta cần dùng đến thang đo độ chính xác (Accuracy)

$$\text{Accuracy} = \frac{\text{\#Correct image}}{\text{\# Testing image}}$$

Trong đó:

• Accuracy là độ chính xác của mô hình
• #Correct imagel là số lượng ảnh mà mô hình dự đoán chính xác
• #Testing image là số lượng ảnh có trong tập test

def test(model):
    test_loss = 0   
    correct = 0
    num_test_image = len(test_loader.dataset) #Lấy số lượng ảnh test
    with torch.no_grad():
        for data, target in test_loader:     #Lặp qua các batch ảnh
            output = network(data)            # Đưa ảnh qua Neural Network
            test_loss = loss_fuction(output, target).item() #Tính loss
            
            pred = output.data.max(1, keepdim=True)[1]
            #Đếm số ảnh dự đoán chính xác
            correct += pred.eq(target.data.view_as(pred)).sum()  
            
        test_loss /= num_test_image
        test_losses.append(test_loss)
        print('\nTest set: Avg. loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
        test_loss, correct, num_test_image, 100. * correct / num_test_image))

Dòng lệnh pred = output.data.max(1, keepdim=True)[1] được dùng để lấy nhãn dự đoạn của ảnh. Do đầu ra của Neural Network là một vector 10 chiều mỗi phần tử thể hiện xác suất của lớp tương ứng mà ảnh đó thuộc về, vì vậy để lấy nhãn thì ta sẽ chọn nhãn có xác suất cao nhất.

Huấn luyện và đánh giá kết quả

Kết hợp hàm đánh giá và hàm huấn luyện mà chúng ta vừa thực hiện ở trên ta tiến hành huấn luyện như sau:

for epoch in range(1, n_epochs + 1):
    train(epoch, network, optimizer) # Huấn luyện 1 epoch
    test(network)                    # Đánh giá mô hình

Kết quả in ra màn hình:

Epoch: 1     iter 0      Loss: 2.276048
....
Test set: Avg. loss: 0.0000, Accuracy: 9176/10000 (92%)

Epoch: 2     iter 0      Loss: 0.269493
...
Test set: Avg. loss: 0.0000, Accuracy: 9401/10000 (94%)

Epoch: 3     iter 0      Loss: 0.073931
...
Test set: Avg. loss: 0.0000, Accuracy: 9565/10000 (96%)

Ta có thể thấy được độ chính xác của Neural Network sau khi huấn luyện 3 epoch là 95%.

Để trực quan hóa kết quả ta có thể dùng đoạn lệnh sau:

with torch.no_grad():
    output = network(example_data)  # Đưa dữ liệu test vào mô hình
    
fig = plt.figure()
for i in range(6):
    plt.subplot(2,3,i+1)
    plt.tight_layout()
    plt.imshow(example_data[i][0], cmap='gray', interpolation='none') #Hiển thị ảnh
    plt.title("Prediction: {} \n Ground truth: {}".format(
        output.data.max(1, keepdim=True)[1][i].item(),example_targets[i]))
    # Lấy nhãn dự đoán và nhãn chính xác
    
    plt.xticks([])
    plt.yticks([])

Ta có được kết quả như sau. Neural Network đã có thể nhận biết đúng hầu như các ảnh.

So sánh với các phương pháp trước đó

Như đã trình bày ở phần trước các mô hình trước đây như logistic regression, softmax regression gặp vấn đề ......

Softmax regression có thể cài đặt như sau

class SoftmaxRegression(torch.nn.Module):
    def __init__(self, input_dim = 784, output_dim = 10):
        super(SoftmaxRegression, self).__init__()
        self.linear = torch.nn.Linear(input_dim, output_dim)
        self.sofmax = nn.LogSoftmax(dim=1)

    def forward(self, x):
        x = x.view(-1, 784)
        outputs = self.linear(x)
        return self.sofmax(outputs)

Tương tự với Neural Network, ta tiến hành huấn luyện Softmax Regression thông qua các hàm train() và test() đã được cài đặt trước đó

#Khởi tạo SoftmaxRegression
SofmaxReg = SoftmaxRegression()

#Khởi tạo optimizer 
optimizer = optim.SGD(SofmaxReg.parameters(), lr=learning_rate, momentum=momentum)

#Khởi tạo hàm mất mát
loss_fuction = nn.NLLLoss()

for epoch in range(1, n_epochs + 1):
    train(epoch, SofmaxReg, optimizer)
    test(SofmaxReg)

Softmax Regression mặc dù có độ chính xác tương đối cao là 92% nhưng vẫn thấp hơn so với Neural Network với 96%

Test set: Avg. loss: 0.0000, Accuracy: 9179/10000 (92%)

Bài tập

Cung cấp code và giải thích cho từng bài. Nên dưa ra các yêu cầu về một kiến trúc mạng khác, bộ dữ liệu khác và chạy thử nghiệm, đánh giá, so sánh với các phương pháp khác.

Bài tập 1: Thiết kế kiến trúc

Trong bài viết, tác giả đã thiết kế một Neural Network có kiến trúc
Input (784) --> Lớp ẩn (128) --> ReLU --> Lớp ẩn (64) -- > ReLU --> Output (10) --> Softmax

Bạn đọc hãy thử thiết kế một Neural Network khác có kiến trúc như sau: Input (784) --> Lớp ẩn (1024) --> ReLU --> Lớp ẩn (512) --> ReLU --> Lớp ẩn (128) --> ReLU --> Lớp ẩn (64) --> ReLU --> Output (10) --> Softmax

Huấn luyện và đánh giá kết quả so với kiến trúc trước đó ? Thử tự mình thiết kế một kiến trúc khác và đánh giá.

ĐÁP ÁN:

class NeuralNet(nn.Module):
    def __init__(self):
        super(NeuralNet, self).__init__()
        self.Net = nn.Sequential(nn.Linear(784, 1024),
                      nn.ReLU(),
                      nn.Linear(1024, 512),
                      nn.ReLU(),
                      nn.Linear(512, 128),
                      nn.ReLU(),
                      nn.Linear(128, 64),
                      nn.ReLU(),
                      nn.Linear(64, 10),
                      nn.LogSoftmax(dim=1)
                      )

    def forward(self, x):
        x = x.view(-1, 784)
        x = self.Net(x)
        return x

Bài tập 2:

Trong bài viết, tác giả sử dụng dữ liệu chữ số viết tay MNIST để làm ví dụ. Bên cạnh MNIST, Pytorch cũng cung cấp nhiều bộ dữ liệu khác nhau cho bài toán phận loại, bạn đọc hãy tìm hiểu một số bộ dữ liệu đó, sau đó thử cài đặt một Neural Network trên một trong các bộ dữ liệu. Nhận xét về độ chính xác và giải thích lí do ?

ĐÁP ÁN:

• Fashion-MNIST: Bộ dữ liệu gồm 70,000 ảnh đen trắng về 10 loại áo quần khác nhau (T-Shirt, Trouser, Pullover, ...). Mỗi ảnh có kích thước $28 \times 28$
• CIFAR10: Bộ dữ liệu gồm 60000 ảnh màu về 10 vật thể ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck'). Mỗi ảnh có kích thước $32 \times 32$

Tải bộ dữ liệu CIFAR10:

# Tải dữ liệu
train = torchvision.datasets.CIFAR10('/data/', train=True, download=True, transform=torchvision.transforms.ToTensor())
test = torchvision.datasets.CIFAR10('/data/', train=False, download=True, transform=torchvision.transforms.ToTensor())

Thiết kế kiến trúc

class CIFAR10_NET(nn.Module):
    def __init__(self):
        super(CIFAR10_NET, self).__init__()
        self.Net = nn.Sequential(nn.Linear(3072, 1024),
                      nn.ReLU(),
                      nn.Linear(1024, 512),
                      nn.ReLU(),
                      nn.Linear(512, 128),
                      nn.ReLU(),
                      nn.Linear(128, 64),
                      nn.ReLU(),
                      nn.Linear(64, 10),
                      nn.LogSoftmax(dim=1)
                      )

    def forward(self, x):
        x = x.view(x.size(0), -1)
        x = self.Net(x)
        return x

Độ chính xác: 52 % (20 epoch)

Nhận xét: Độ chính xác thấp hơn nhiều so với tập MNIST. Thời gian huấn luyện nhiều hơn. Giải thích: Do dữ liệu tập CIFAR10 phức tạp hơn. Cụ thể, kích thước ảnh lớn hơn $32 \times 32$ so với $28 \times 28$ của tập MNIST. Đối tượng trong ảnh phức tạp và có nhiều chi tiết hơn, đồng thời là ảnh màu nên kích thước ảnh đầu vào cũng lớn gây khó khăn cho quá trình hội tụ. Mặt khác, do kích thước ảnh đầu vào lớn nên thời gian huấn luyện cũng lâu hơn.

Kết luận

Trên đây bài viết đã trình bày được động lực và phương pháp của mô hình Neural Network, đồng thời so sánh được với những phương pháp khác cũng như hướng dẫn triển khai các mô hình Neural Network. Thông qua bài viết, nhóm chúng tôi hy vọng có thể cung cấp cho bạn đọc cái nhìn rõ hơn về mô hình vô cùng quan trọng này. Có thể thấy mô hình Neural Network đã mang lại kết quả dự đoán cao cho nhiều bài toán phân lớp. Xong để có khả năng tự đánh giá và cải tiến các phương pháp của bản thân, bạn đọc cần tìm hiểu kỹ hơn về mô hình và ứng dụng vào các bài toán của bản thân. Bài viết đến đây là kết thúc, cảm ơn mọi người đã dành thời gian đọc.

Tài liệu tham khảo

[1] Understanding Neural Network P1 - Flinters https://labs.flinters.vn/technote/ml-07-understanding-neural-network-p1/

[2] Tổng quan về Neural Network(mạng Nơ Ron nhân tạo) là gì? - ITNavi https://itnavi.com.vn/blog/neural-network-la-gi

Tác giả

- Ngô Hữu Mạnh Khanh
- Nguyễn Văn Chính
- Nguyễn Phương Bảo Ngọc