- Nhóm thực hiện: Nhóm 4 Môn học

- Tên sinh viên: Trí Tuệ nhân tạo

Vũ Nguyễn Mạnh Hùng 21146472 BÁO CÁO TUẦN 10

Bài 8: Pytorch

- Thư viện sử dụng:

from scipy.io import loadmat
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
import torch
from torch.utils.data import TensorDataset, DataLoader
import torch.nn as nn
import torch.optim as optim
from keras.utils import to_categorical

- Đọc dữ liệu từ file ex7data.mat :

data = loadmat('/content/drive/MyDrive/ex7data.mat')
X = data['X']
y = data['y'].ravel()

- Biến X, y được gán bằng giá trị tương ứng với key 'X' và key 'y' trong biến data.
- Hàm ravel() được sử dụng để biến đổi ma trận thành một mảng một chiều (1D array),
giúp tiện lợi cho việc xử lý dữ liệu trong các bước tiếp theo.

- Reshape một số ảnh về kích thước 20x20 và show ra màn hình

num_img = [0,500,1000,1500, 2000]
fig, axes = plt.subplots(1, len(num_img), figsize=(10, 2))
for i, idx in enumerate(num_img):
axes[i].imshow(X[idx].reshape(20, 20).T, cmap='gray')
axes[i].axis('off')
plt.show()

- num_img :danh sách chứa các chỉ số của các ảnh muốn hiển thị.
fig, axes = plt.subplots(1, len(num_img), figsize=(10, 2)): tạo ra một hình vẽ với một
hàng và số lượng cột bằng với độ dài của danh sách num_img. Kích thước của hình vẽ
là 10x2 inches.
- Trong vòng lặp for: enumerate(num_img) được sử dụng để lặp qua từng chỉ số và
giá trị của num_img. Biến idx chứa chỉ số của ảnh trong tập dữ liệu X, từ đó bạn truy
cập vào ảnh tương ứng trong X[idx].

- Chia dữ liệu thành 70% train, 30% test (train_test_split) đảm bảo tính ngẫu nhiên
và đồng đều về nhãn.
 - Chia dữ liệu train thành 90% train, 10% val (train_test_split) đảm bảo tính ngẫu
nhiên và đồng đều về nhãn.

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,

random_state = 0, stratify=y)
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train,
test_size=0.1, random_state = 0, stratify=y_train)

- Chuyển đổi nhãn thành dạng one-hot encoding

y_train_encoded = to_categorical(np.where(y_train == 10, 0, y_train))
y_test_encoded = to_categorical(np.where(y_test == 10, 0, y_test))
y_val_encoded = to_categorical(np.where(y_val == 10, 0, y_val))

- np.where(y_train == 10, 0, y_train): Đây là một cách để chuyển nhãn của lớp 10
thành 0, để đảm bảo rằng nhãn đầu ra các số không bị lộn nhãn với nhau .
- to_categorical: Hàm chuyển đổi một vector nhãn thành ma trận one-hot encoding.

- Format dữ liệu để có thể sử dụng được DataLoader

X_train_tensor = torch.Tensor(X_train)
y_train_tensor = torch.LongTensor(y_train_encoded)
X_val_tensor = torch.Tensor(X_val)
y_val_tensor = torch.LongTensor(y_val_encoded)
X_test_tensor = torch.Tensor(X_test)
y_test_tensor = torch.LongTensor(y_test_encoded)

train_dataset = TensorDataset(X_train_tensor, y_train_tensor)

val_dataset = TensorDataset(X_val_tensor, y_val_tensor)
test_dataset = TensorDataset(X_test_tensor, y_test_tensor)

train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)

val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

1. Chuyển đổi dữ liệu từ numpy array thành Tensor của PyTorch:

 torch.Tensor(X_train): Chuyển đổi ma trận đầu vào X_train thành
Tensor.
 torch.LongTensor(y_train_encoded): Chuyển đổi vectơ nhãn
y_train_encoded thành Tensor với kiểu dữ liệu là LongTensor. Điều này thường được
thực hiện với dữ liệu nhãn.
 Tương tự cho X_val, y_val_encoded, X_test, và y_test_encoded.
2. Tạo các đối tượng Dataset:
 train_dataset, val_dataset, và test_dataset được tạo bằng
TensorDataset trong PyTorch. Đối tượng này là một tập hợp của dữ liệu và nhãn tương
ứng của chúng. Mỗi mẫu dữ liệu trong tập hợp sẽ được lưu trữ dưới dạng một cặp (dữ
liệu, nhãn).
3. Tạo các đối tượng DataLoader:
 train_loader, val_loader, và test_loader là các DataLoader của
PyTorch, được tạo ra từ các đối tượng Dataset tương ứng. DataLoader giúp tải dữ liệu
theo batch (một nhóm các mẫu dữ liệu) trong quá trình huấn luyện mô hình. Batch_size
được đặt là 32, tức là mỗi lần DataLoader sẽ trả về 32 mẫu dữ liệu (và nhãn tương ứng)
từ tập dữ liệu. Các dữ liệu không cần được trộn lại (shuffle=False) khi kiểm tra hoặc
đánh giá mô hình.
- Khai báo mạng nơ ron
# Define the neural network architecture
class NeuralNetwork(nn.Module):
def __init__(self):
super(NeuralNetwork, self).__init__()
self.fc1 = nn.Linear(400, 100)
self.fc2 = nn.Linear(100, 50)
self.fc3 = nn.Linear(50, 10)
self.sigmoid = nn.Sigmoid()

def forward(self, x):

x = self.sigmoid(self.fc1(x))
x = self.sigmoid(self.fc2(x))
x = self.fc3(x)
return x

model = NeuralNetwork()
criterion = nn.BCELoss()
optimizer = optim.SGD(model.parameters(), lr=1)

NeuralNetwork(nn.Module): Định nghĩa một lớp mới là NeuralNetwork kế thừa từ

lớp nn.Module của PyTorch, cho phép chúng ta tạo ra một mạng nơ ron.
__init__(self): Phương thức khởi tạo của lớp NeuralNetwork, trong đó chúng ta định
nghĩa các lớp (hoặc tầng) của mạng neural và các chức năng kích hoạt (trong trường
hợp này là sigmoid).
self.fc1 = nn.Linear(400, 100): Lớp linear (fully connected) đầu tiên với 400 đầu vào
(tương ứng ảnh 20x20) và 100 đầu ra.
self.fc2 = nn.Linear(100, 50): Lớp linear thứ hai với 100 đầu vào và 50 đầu ra.
self.fc3 = nn.Linear(50, 10): Lớp linear thứ ba với 50 đầu vào và 10 đầu ra (tương
ứng từ 0 - 9).
self.sigmoid = nn.Sigmoid(): Hàm kích hoạt sigmoid được sử dụng để biến đổi đầu ra
của các lớp ẩn.
biến model là mạng neural với cấu trúc được định nghĩa trong lớp NeuralNetwork
Hàm mất mát (Loss Function): phương pháp BCE (Binary Cross Entropy Loss)
Phương pháp tối ưu hóa: SGD (Stochastic Gradient Descent) với learning rate là 1.

- Chương trình học:

inter = 1000
train_losses = []
val_losses = []
for i in range(inter):
# Training
model.train()
running_train_loss = 0.0
for inputs, labels in train_loader:
optimizer.zero_grad()
outputs = model(inputs)
outputs = torch.sigmoid(outputs)
loss = criterion(outputs, labels.float()) # Chuyển đổi kiểu dữ
liệu của nhãn sang float
loss.backward()
optimizer.step()
running_train_loss += loss.item() * inputs.size(0)
train_loss = running_train_loss / len(train_loader.dataset)
train_losses.append(train_loss)

# Validation
model.eval()
running_val_loss = 0.0
with torch.no_grad():
for inputs, labels in val_loader:
outputs = model(inputs)
outputs = torch.sigmoid(outputs)
loss = criterion(outputs, labels.float())
running_val_loss += loss.item() * inputs.size(0)
val_loss = running_val_loss / len(val_loader.dataset)
val_losses.append(val_loss)
- Biểu đồ loss của train và validation

- Kiểm tra độ chính xác:

# Evaluate the model on test data
model.eval()
correct = 0
total = 0
with torch.no_grad():
for inputs, labels in test_loader:
outputs = model(inputs)
_, predicted = torch.max(outputs, 1)
total += labels.size(0)
correct += (predicted == labels.argmax(dim=1)).sum().item() #
Sử dụng argmax để lấy chỉ số của nhãn cao nhất

accuracy = correct / total

print(f'Accuracy on test set: {accuracy:.2%}')