Nhập môn Deep Learning với Python
BasicSkill Level
4 giờ
264.8K learners
Trong hướng dẫn PyTorch này, chúng ta sẽ tìm hiểu các hàm cốt lõi vận hành mạng nơ-ron và tự xây dựng một mạng từ con số 0. Mục tiêu chính của bài viết là minh họa những điều cơ bản về PyTorch, một thư viện tensor học sâu được tối ưu hóa, đồng thời cung cấp cho bạn nền tảng chi tiết về cách mạng nơ-ron hoạt động.
Lưu ý: Hãy xem workspace này của DataCamp để theo dõi mã nguồn trong bài viết.
Mạng nơ-ron là gì?
Mạng nơ-ron còn được gọi là mạng nơ-ron nhân tạo (ANN). Kiến trúc này là nền tảng của học sâu, một phân nhánh của học máy quan tâm đến các thuật toán lấy cảm hứng từ cấu trúc và chức năng của não người. Nói ngắn gọn, mạng nơ-ron là cơ sở của các kiến trúc mô phỏng cách các nơ-ron sinh học truyền tín hiệu cho nhau.
Vì vậy, bạn sẽ thường thấy các tài liệu dành vài phút đầu tiên để phác họa cấu trúc nơ-ron của não người nhằm giúp bạn hình dung trực quan cách một mạng nơ-ron hoạt động. Nhưng khi bạn không có vài phút rảnh rỗi, cách dễ hơn là định nghĩa mạng nơ-ron như một hàm ánh xạ các đầu vào tới các đầu ra mong muốn.
Kiến trúc mạng nơ-ron tổng quát bao gồm những phần sau:
- Tầng đầu vào: Dữ liệu được đưa vào mạng qua tầng đầu vào. Số lượng nơ-ron ở tầng đầu vào tương ứng với số đặc trưng trong dữ liệu. Về mặt kỹ thuật, tầng đầu vào không được coi là một tầng của mạng vì chưa có phép tính nào diễn ra ở đây.
- Tầng ẩn: Các tầng nằm giữa tầng đầu vào và đầu ra được gọi là tầng ẩn. Một mạng có thể có số lượng tầng ẩn tùy ý - càng nhiều tầng ẩn, mạng càng phức tạp.
- Tầng đầu ra: Tầng đầu ra dùng để đưa ra dự đoán.
- Nơ-ron: Mỗi tầng có một tập hợp nơ-ron tương tác với các nơ-ron ở tầng khác.
- Hàm kích hoạt: Thực hiện các phép biến đổi phi tuyến để giúp mô hình học các mẫu phức tạp từ dữ liệu.
Lưu ý mạng nơ-ron hiển thị trong hình trên sẽ được coi là mạng nơ-ron ba tầng chứ không phải bốn - vì chúng ta không tính tầng đầu vào là một tầng. Do đó, số tầng của mạng là số tầng ẩn cộng với tầng đầu ra.
Mạng nơ-ron hoạt động như thế nào?
Hãy chia nhỏ thuật toán thành các thành phần để hiểu rõ hơn cách mạng nơ-ron hoạt động.
Khởi tạo trọng số
Khởi tạo trọng số là thành phần đầu tiên trong kiến trúc mạng nơ-ron. Các trọng số ban đầu chúng ta đặt ra xác định điểm bắt đầu cho quá trình tối ưu hóa của mô hình mạng nơ-ron.
Cách chúng ta đặt trọng số rất quan trọng, đặc biệt khi xây dựng các mạng sâu. Bởi lẽ các mạng sâu dễ gặp vấn đề gradient bùng nổ hoặc tiêu biến. Hai vấn đề này vượt ra ngoài phạm vi bài viết, nhưng cả hai đều mô tả tình huống thuật toán không học được.
Mặc dù khởi tạo trọng số không hoàn toàn giải quyết được vấn đề gradient tiêu biến hay bùng nổ, nhưng chắc chắn góp phần ngăn ngừa.
Dưới đây là một vài cách khởi tạo trọng số phổ biến:
Khởi tạo bằng 0
Khởi tạo bằng 0 nghĩa là các trọng số được đặt bằng không. Đây không phải giải pháp tốt vì mạng nơ-ron sẽ không phá vỡ được tính đối xứng - tức là sẽ không học được.
Bất cứ khi nào dùng một hằng số để khởi tạo trọng số mạng nơ-ron, chúng ta có thể kỳ vọng hiệu năng kém vì tất cả các tầng sẽ học cùng một thứ. Nếu mọi đầu ra của các nút ẩn có cùng ảnh hưởng lên hàm chi phí, thì các gradient sẽ giống hệt nhau.
Khởi tạo ngẫu nhiên
Khởi tạo ngẫu nhiên phá vỡ tính đối xứng, tức là tốt hơn khởi tạo bằng 0, nhưng một số yếu tố có thể quyết định chất lượng tổng thể của mô hình.
Ví dụ, nếu các trọng số được khởi tạo ngẫu nhiên với giá trị lớn, mỗi phép nhân ma trận có thể cho ra giá trị lớn hơn đáng kể. Khi áp dụng hàm sigmoid trong các trường hợp như vậy, kết quả sẽ gần một, làm chậm tốc độ học.
Một tình huống khác khi khởi tạo ngẫu nhiên có thể gây vấn đề là khi các trọng số được khởi tạo ngẫu nhiên với giá trị nhỏ. Lúc này, mỗi phép nhân ma trận sẽ cho ra giá trị nhỏ hơn đáng kể, và áp dụng sigmoid sẽ cho giá trị gần 0, điều này cũng làm chậm tốc độ học.
Khởi tạo Xavier/Glorot
Khởi tạo Xavier hay Glorot - đều là một - là cách tiếp cận heuristic dùng để khởi tạo trọng số. Cách này thường thấy khi áp dụng hàm kích hoạt tanh hoặc sigmoid cho trung bình có trọng số. Phương pháp được đề xuất lần đầu năm 2010 trong bài báo Understanding the difficulty of training deep feedforward neural networks của Xavier Glorot và Yoshua Bengio. Kỹ thuật này nhằm giữ phương sai đồng đều trên toàn mạng để ngăn gradient bùng nổ hoặc tiêu biến.
Khởi tạo He/Kaiming
Khởi tạo He hay Kaiming là một cách tiếp cận heuristic khác. Khác biệt giữa He và Xavier là He dùng hệ số tỉ lệ khác cho trọng số để tính đến tính phi tuyến của các hàm kích hoạt.
Vì vậy, khi dùng hàm kích hoạt ReLU ở các tầng, khởi tạo He là lựa chọn được khuyến nghị. Bạn có thể tìm hiểu thêm trong bài Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification của He và cộng sự.
Lan truyền thuận
Mạng nơ-ron hoạt động bằng cách lấy trung bình có trọng số cộng với một hạng bias và áp dụng hàm kích hoạt để thêm phép biến đổi phi tuyến. Trong công thức trung bình có trọng số, mỗi trọng số xác định mức độ quan trọng của từng đặc trưng (tức nó đóng góp bao nhiêu vào dự đoán đầu ra).
Công thức trên là trung bình có trọng số cộng với một hạng bias, trong đó
- z là tổng có trọng số của đầu vào một nơ-ron
- Wn là các trọng số
- Xn là các biến độc lập, và
- b là hạng bias.
Nếu công thức trông quen thuộc, đó là vì nó chính là hồi quy tuyến tính. Nếu không đưa phi tuyến vào các nơ-ron, chúng ta chỉ có hồi quy tuyến tính, một mô hình đơn giản. Phép biến đổi phi tuyến cho phép mạng nơ-ron học các mẫu phức tạp.
Hàm kích hoạt
Chúng ta đã nhắc tới một vài hàm kích hoạt trong phần khởi tạo trọng số, và giờ bạn đã biết tầm quan trọng của chúng trong kiến trúc mạng nơ-ron.
Hãy đi sâu hơn vào một số hàm kích hoạt phổ biến mà bạn có thể gặp khi đọc các bài báo nghiên cứu và mã của người khác.
Sigmoid
Hàm sigmoid có đường cong hình chữ “S” với giá trị bị chặn trong khoảng từ 0 đến 1. Đây là hàm khả vi, nghĩa là có thể tìm được độ dốc của đường cong tại bất kỳ hai điểm nào, và là đơn điệu, tức không hoàn toàn tăng cũng không hoàn toàn giảm. Bạn thường dùng sigmoid cho các bài toán phân loại nhị phân.
Đây là cách bạn có thể trực quan hóa hàm sigmoid bằng Python:
# Sigmoid function in Python
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-5, 5, 50)
z = 1/(1 + np.exp(-x))
plt.subplots(figsize=(8, 5))
plt.plot(x, z)
plt.grid()
plt.show()
Tanh
Hàm hyperbolic tangent (tanh) có đường cong hình “S” giống sigmoid, ngoại trừ giá trị bị chặn trong khoảng từ -1 đến 1. Do đó, đầu vào nhỏ được ánh xạ gần -1, còn đầu vào lớn được ánh xạ gần 1.
Ví dụ trực quan hóa hàm tanh bằng Python:
# tanh function in Python
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-5, 5, 50)
z = np.tanh(x)
plt.subplots(figsize=(8, 5))
plt.plot(x, z)
plt.grid()
plt.show()
Softmax
Hàm softmax thường được dùng làm hàm kích hoạt ở tầng đầu ra. Đây là sự tổng quát hóa của sigmoid cho nhiều chiều. Vì vậy, nó được dùng trong mạng nơ-ron để dự đoán thuộc tính lớp với nhiều hơn hai nhãn.
Hàm tuyến tính chỉnh lưu (ReLU)
Dùng sigmoid hoặc tanh để xây dựng mạng nơ-ron sâu tiềm ẩn rủi ro vì chúng dễ gặp vấn đề gradient tiêu biến. Hàm kích hoạt ReLU ra đời như một giải pháp cho vấn đề này và thường là mặc định cho nhiều mạng nơ-ron.
Dưới đây là ví dụ trực quan về hàm ReLU bằng Python:
# ReLU in Python
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-5, 5, 50)
z = [max(0, i) for i in x]
plt.subplots(figsize=(8, 5))
plt.plot(x, z)
plt.grid()
plt.show()
ReLU bị chặn trong khoảng từ 0 đến vô cực: lưu ý rằng với các giá trị đầu vào nhỏ hơn hoặc bằng 0, hàm trả về 0, và với các giá trị lớn hơn 0, hàm trả về chính giá trị đầu vào (ví dụ, nếu bạn nhập hai thì trả về hai). Xét cho cùng, ReLU cư xử rất giống một hàm tuyến tính, giúp việc tối ưu hóa và triển khai dễ dàng hơn nhiều.
Quá trình từ tầng đầu vào đến tầng đầu ra được gọi là lượt truyền thuận hay lan truyền thuận. Trong giai đoạn này, các đầu ra do mô hình sinh ra được dùng để tính hàm chi phí nhằm xác định hiệu năng của mạng sau mỗi vòng lặp. Thông tin này sau đó được truyền ngược qua mô hình để điều chỉnh trọng số, giúp mô hình đưa ra dự đoán tốt hơn trong một quy trình gọi là lan truyền ngược.
Lan truyền ngược
Cuối lượt truyền thuận đầu tiên, mạng đưa ra dự đoán bằng các trọng số đã khởi tạo, chưa được tinh chỉnh. Do đó, rất có khả năng dự đoán chưa chính xác. Dựa trên mất mát (loss) tính từ lan truyền thuận, chúng ta truyền thông tin ngược qua mạng để tinh chỉnh trọng số trong quy trình gọi là lan truyền ngược.
Suy cho cùng, chúng ta dùng hàm tối ưu hóa để giúp xác định các trọng số có thể giảm tỷ lệ lỗi, khiến mô hình đáng tin cậy hơn và tăng khả năng tổng quát hóa cho dữ liệu mới. Toán học phía sau vượt quá phạm vi bài viết này, nhưng bạn đọc quan tâm có thể tìm hiểu thêm về lan truyền ngược trong khóa học Introduction to Deep Learning in Python của chúng tôi.
Hướng dẫn PyTorch: Từng bước xây dựng mạng nơ-ron từ con số 0
Ở phần này, chúng ta sẽ xây dựng một mô hình mạng nơ-ron nhân tạo đơn giản bằng thư viện PyTorch. Xem workspace của DataCamp để theo dõi mã nguồn
PyTorch là một trong những thư viện phổ biến nhất cho học sâu. Nó mang lại trải nghiệm gỡ lỗi trực tiếp hơn TensorFlow. PyTorch còn có nhiều ưu điểm khác như huấn luyện phân tán, hệ sinh thái mạnh, hỗ trợ đám mây, cho phép bạn viết mã sẵn sàng cho sản xuất, v.v. Bạn có thể tìm hiểu thêm về PyTorch trong lộ trình kỹ năng Introduction to Deep Learning with PyTorch.
Hãy bắt đầu vào phần hướng dẫn.
Định nghĩa & chuẩn bị dữ liệu
Tập dữ liệu chúng ta sẽ dùng là make_circles từ scikit-learn - xem tài liệu. Đây là tập dữ liệu thử nghiệm gồm một hình tròn lớn với một hình tròn nhỏ trên mặt phẳng hai chiều và hai đặc trưng. Trong minh họa này, chúng tôi dùng 10.000 mẫu và thêm nhiễu Gaussian với độ lệch chuẩn 0,05 vào dữ liệu.
Trước khi xây dựng mạng nơ-ron, nên tách dữ liệu thành tập huấn luyện và kiểm tra để đánh giá hiệu năng mô hình trên dữ liệu chưa từng thấy.
import matplotlib.pyplot as plt
from sklearn.datasets import make_circles
from sklearn.model_selection import train_test_split
# Create a dataset with 10,000 samples.
X, y = make_circles(n_samples = 10000,
noise= 0.05,
random_state=26)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.33, random_state=26)
# Visualize the data.
fig, (train_ax, test_ax) = plt.subplots(ncols=2, sharex=True, sharey=True, figsize=(10, 5))
train_ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=plt.cm.Spectral)
train_ax.set_title("Training Data")
train_ax.set_xlabel("Feature #0")
train_ax.set_ylabel("Feature #1")
test_ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test)
test_ax.set_xlabel("Feature #0")
test_ax.set_title("Testing data")
plt.show()
Bước tiếp theo là chuyển dữ liệu huấn luyện và kiểm tra từ mảng NumPy sang tensor PyTorch. Để làm điều này, chúng ta sẽ tạo một tập dữ liệu tùy chỉnh cho các tệp huấn luyện và kiểm tra. Chúng ta cũng sẽ tận dụng mô-đun Dataloader của PyTorch để huấn luyện theo lô. Mã như sau:
import warnings
warnings.filterwarnings("ignore")
!pip install torch -q
import torch
import numpy as np
from torch.utils.data import Dataset, DataLoader
# Convert data to torch tensors
class Data(Dataset):
def __init__(self, X, y):
self.X = torch.from_numpy(X.astype(np.float32))
self.y = torch.from_numpy(y.astype(np.float32))
self.len = self.X.shape[0]
def __getitem__(self, index):
return self.X[index], self.y[index]
def __len__(self):
return self.len
batch_size = 64
# Instantiate training and test data
train_data = Data(X_train, y_train)
train_dataloader = DataLoader(dataset=train_data, batch_size=batch_size, shuffle=True)
test_data = Data(X_test, y_test)
test_dataloader = DataLoader(dataset=test_data, batch_size=batch_size, shuffle=True)
# Check it's working
for batch, (X, y) in enumerate(train_dataloader):
print(f"Batch: {batch+1}")
print(f"X shape: {X.shape}")
print(f"y shape: {y.shape}")
break
"""
Batch: 1
X shape: torch.Size([64, 2])
y shape: torch.Size([64])
"""Bây giờ hãy chuyển sang triển khai và huấn luyện mạng nơ-ron.
Triển khai mạng nơ-ron & huấn luyện mô hình
Chúng ta sẽ triển khai một mạng nơ-ron hai tầng đơn giản sử dụng hàm kích hoạt ReLU (torch.nn.functional.relu). Để làm điều này, chúng ta sẽ tạo một lớp tên là NeuralNetwork kế thừa từ nn.Module, lớp cơ sở cho mọi mô-đun mạng nơ-ron trong PyTorch.
Mã như sau:
import torch
from torch import nn
from torch import optim
input_dim = 2
hidden_dim = 10
output_dim = 1
class NeuralNetwork(nn.Module):
def __init__(self, input_dim, hidden_dim, output_dim):
super(NeuralNetwork, self).__init__()
self.layer_1 = nn.Linear(input_dim, hidden_dim)
nn.init.kaiming_uniform_(self.layer_1.weight, nonlinearity="relu")
self.layer_2 = nn.Linear(hidden_dim, output_dim)
def forward(self, x):
x = torch.nn.functional.relu(self.layer_1(x))
x = torch.nn.functional.sigmoid(self.layer_2(x))
return x
model = NeuralNetwork(input_dim, hidden_dim, output_dim)
print(model)
"""
NeuralNetwork(
(layer_1): Linear(in_features=2, out_features=10, bias=True)
(layer_2): Linear(in_features=10, out_features=1, bias=True)
)
"""Và chỉ có vậy.
Để huấn luyện mô hình, chúng ta phải định nghĩa một hàm mất mát để tính gradient và một bộ tối ưu để cập nhật tham số. Trong minh họa, chúng ta sẽ dùng binary crossentropy và stochastic gradient descent với tốc độ học 0,1.
learning_rate = 0.1
loss_fn = nn.BCELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=leaHãy huấn luyện mô hình
num_epochs = 100
loss_values = []
for epoch in range(num_epochs):
for X, y in train_dataloader:
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
pred = model(X)
loss = loss_fn(pred, y.unsqueeze(-1))
loss_values.append(loss.item())
loss.backward()
optimizer.step()
print("Training Complete")
"""
Training Complete
"""Vì chúng ta đã theo dõi các giá trị loss, ta có thể trực quan hóa độ mất mát của mô hình theo thời gian.
step = range(len(loss_values))
fig, ax = plt.subplots(figsize=(8,5))
plt.plot(step, np.array(loss_values))
plt.title("Step-wise Loss")
plt.xlabel("Epochs")
plt.ylabel("Loss")
plt.show()
Biểu đồ trên cho thấy loss của mô hình qua 100 epoch. Ban đầu, loss ở mức 0,7 và giảm dần - điều này cho biết mô hình cải thiện dự đoán theo thời gian. Tuy nhiên, có vẻ mô hình chững lại quanh mốc 60 epoch, có thể vì nhiều lý do, chẳng hạn mô hình đang ở vùng cực tiểu cục bộ hoặc toàn cục của hàm mất mát.
Dẫu vậy, mô hình đã được huấn luyện và sẵn sàng dự đoán cho các mẫu mới - hãy xem cách thực hiện trong phần tiếp theo.
Dự đoán & đánh giá mô hình
Thực hiện dự đoán với mạng nơ-ron PyTorch của chúng ta khá đơn giản.
import itertools # Import this at the top of your script
# Initialize required variables
y_pred = []
y_test = []
correct = 0
total = 0
"""
We're not training so we don't need to calculate the gradients for our outputs
"""
with torch.no_grad():
for X, y in test_dataloader:
outputs = model(X) # Get model outputs
predicted = np.where(outputs.numpy() < 0.5, 0, 1) # Convert to NumPy and apply threshold
predicted = list(itertools.chain(*predicted)) # Flatten predictions
y_pred.append(predicted) # Append predictions
y_test.append(y.numpy()) # Append true labels as NumPy
total += y.size(0) # Increment total count
correct += (predicted == y.numpy()).sum().item() # Count correct predictions
print(f'Accuracy of the network on the 3300 test instances: {100 * correct // total}%')
"""
Accuracy of the network on the 3300 test instances: 97%
"""
Lưu ý: Mỗi lần chạy mã sẽ cho ra kết quả khác nhau nên bạn có thể không nhận được cùng kết quả.
Đoạn mã trên lặp qua các lô kiểm tra, được lưu trong biến test_dataloader, mà không tính gradient. Sau đó, chúng ta dự đoán cho các mẫu trong lô và lưu kết quả vào biến outputs. Tiếp theo, chúng ta đặt tất cả giá trị nhỏ hơn 0,5 thành 0 và các giá trị bằng hoặc lớn hơn 0,5 thành 1. Các giá trị này được thêm vào danh sách dự đoán.
Sau đó, chúng ta cộng thêm số lượng mẫu thực tế trong lô vào biến total. Rồi tính số dự đoán đúng bằng cách xác định số dự đoán trùng với nhãn thực và tổng lại. Tổng số dự đoán đúng cho mỗi lô được cộng dồn và lưu trong biến correct.
Để tính độ chính xác chung của mô hình, chúng ta nhân số dự đoán đúng với 100 (để ra phần trăm) rồi chia cho số lượng mẫu trong tập kiểm tra. Mô hình của chúng ta đạt độ chính xác 97%. Chúng ta đi sâu hơn bằng ma trận nhầm lẫn và classification_report của scikit-learn để hiểu rõ hơn hiệu năng mô hình.
from sklearn.metrics import classification_report
from sklearn.metrics import confusion_matrix
import seaborn as sns
y_pred = list(itertools.chain(*y_pred))
y_test = list(itertools.chain(*y_test))
print(classification_report(y_test, y_pred))
"""
precision recall f1-score support
0.0 0.98 0.97 0.98 1635
1.0 0.98 0.98 0.98 1665
accuracy 0.98 3300
macro avg 0.98 0.98 0.98 3300
weighted avg 0.98 0.98 0.98 3300
"""
cf_matrix = confusion_matrix(y_test, y_pred)
plt.subplots(figsize=(8, 5))
sns.heatmap(cf_matrix, annot=True, cbar=False, fmt="g")
plt.show()
Mô hình của chúng ta hoạt động khá tốt. Tôi khuyến khích bạn khám phá mã và thực hiện một số thay đổi để củng cố những gì đã trình bày trong bài viết này.
Trong hướng dẫn PyTorch này, chúng ta đã bao quát các kiến thức nền tảng về mạng nơ-ron và dùng PyTorch, một thư viện Python cho học sâu, để triển khai mạng. Chúng ta đã dùng tập dữ liệu hình tròn của scikit-learn để huấn luyện một mạng nơ-ron hai tầng cho bài toán phân loại. Sau đó, chúng ta thực hiện dự đoán trên dữ liệu và đánh giá kết quả bằng chỉ số độ chính xác.
Chủ đề
