Phương pháp đầu tiên
Sử dụng phương thức .cuda() cho mô hình mạng, dữ liệu (đầu vào và nhãn) cùng hàm mất mát
Mã nguồn minh họa
import torch
import torchvision
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
from torch.utils.tensorboard import SummaryWriter
from model import *
# Khởi tạo tập huấn luyện
from torch.utils.data import DataLoader
training_dataset = torchvision.datasets.CIFAR10("./data_folder", train=True, download=True,
transform=torchvision.transforms.ToTensor())
validation_dataset = torchvision.datasets.CIFAR10("./data_folder", train=False, download=True,
transform=torchvision.transforms.ToTensor())
# Xác định kích thước dữ liệu
training_length = len(training_dataset)
validation_length = len(validation_dataset)
print(f"Kích thước tập huấn luyện: {training_length}")
print(f"Kích thước tập kiểm tra: {validation_length}")
# Tải dữ liệu thông qua DataLoader
training_loader = DataLoader(training_dataset, batch_size=64)
validation_loader = DataLoader(validation_dataset, batch_size=64)
# Xây dựng mô hình mạng nơ-ron
class NetworkModel(nn.Module):
def __init__(self):
super().__init__()
self.feature_extractor = Sequential(
Conv2d(3, 32, 5, 1, 2),
MaxPool2d(2),
Conv2d(32, 32, 5, padding=2),
MaxPool2d(2),
Conv2d(32, 64, 5, padding=2),
MaxPool2d(2),
Flatten(),
Linear(1024, 64),
Linear(64, 10)
)
def forward(self, inputs):
outputs = self.feature_extractor(inputs)
return outputs
# Khởi tạo mô hình
model_instance = NetworkModel()
if torch.cuda.is_available():
model_instance = model_instance.cuda()
# Thiết lập hàm tính toán lỗi
criterion = nn.CrossEntropyLoss()
if torch.cuda.is_available():
criterion = criterion.cuda()
# Thiết lập bộ tối ưu hóa
learning_rate = 1e-2
optimizer = torch.optim.SGD(model_instance.parameters(), lr=learning_rate)
# Cấu hình các tham số huấn luyện
current_training_step = 0
current_validation_step = 0
epochs_count = 10
tensorboard_writer = SummaryWriter("./logs")
for epoch_index in range(epochs_count):
print(f"--------Bắt đầu vòng huấn luyện thứ {epoch_index+1}--------")
# Giai đoạn huấn luyện
for batch_data in training_loader:
input_images, expected_labels = batch_data
if torch.cuda.is_available():
input_images = input_images.cuda()
expected_labels = expected_labels.cuda()
predictions = model_instance(input_images)
error = criterion(predictions, expected_labels)
# Cập nhật trọng số mô hình
optimizer.zero_grad()
error.backward()
optimizer.step()
current_training_step += 1
if current_training_step % 100 == 0:
print(f"Bước huấn luyện: {current_training_step}, lỗi: {error.item()}")
tensorboard_writer.add_scalar("training_error", error.item(), current_training_step)
# Giai đoạn kiểm tra
accumulated_validation_error = 0
correct_predictions_total = 0
with torch.no_grad():
for validation_batch in validation_loader:
val_images, val_targets = validation_batch
if torch.cuda.is_available():
val_images = val_images.cuda()
val_targets = val_targets.cuda()
val_outputs = model_instance(val_images)
val_error = criterion(val_outputs, val_targets)
accumulated_validation_error += val_error.item()
correct_predictions = (val_outputs.argmax(1) == val_targets).sum()
correct_predictions_total += correct_predictions
print(f"Tổng lỗi trên tập kiểm tra: {accumulated_validation_error}")
print(f"Độ chính xác trên tập kiểm tra: {correct_predictions_total/validation_length}")
tensorboard_writer.add_scalar("validation_error", accumulated_validation_error, current_validation_step)
tensorboard_writer.add_scalar("accuracy_score", correct_predictions_total/validation_length, current_validation_step)
current_validation_step += 1
torch.save(model_instance, f"model_epoch_{epoch_index}.pth")
print("Mô hình đã được lưu trữ")
tensorboard_writer.close()
Phương pháp thứ hai
Sử dụng thiết bị cụ thể: device = torch.device("cuda")
Áp dụng phương thức .to(device) cho mô hình mạng, dữ liệu (đầu vào và nhãn) cùng hàm mất mát
Mã nguồn minh họa
import torch
import torchvision
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
from torch.utils.tensorboard import SummaryWriter
from torch.utils.data import DataLoader
from model import *
compute_device = torch.device("cuda")
# Khởi tạo tập dữ liệu huấn luyện
training_dataset = torchvision.datasets.CIFAR10("./data_folder", train=True, download=True,
transform=torchvision.transforms.ToTensor())
validation_dataset = torchvision.datasets.CIFAR10("./data_folder", train=False, download=True,
transform=torchvision.transforms.ToTensor())
# Xác định kích thước tập dữ liệu
training_length = len(training_dataset)
validation_length = len(validation_dataset)
print(f"Kích thước tập huấn luyện: {training_length}")
print(f"Kích thước tập kiểm tra: {validation_length}")
# Tải dữ liệu thông qua DataLoader
training_loader = DataLoader(training_dataset, batch_size=64)
validation_loader = DataLoader(validation_dataset, batch_size=64)
# Xây dựng kiến trúc mạng
class NetworkModel(nn.Module):
def __init__(self):
super().__init__()
self.feature_extractor = Sequential(
Conv2d(3, 32, 5, 1, 2),
MaxPool2d(2),
Conv2d(32, 32, 5, padding=2),
MaxPool2d(2),
Conv2d(32, 64, 5, padding=2),
MaxPool2d(2),
Flatten(),
Linear(1024, 64),
Linear(64, 10)
)
def forward(self, inputs):
outputs = self.feature_extractor(inputs)
return outputs
# Khởi tạo mô hình
model_instance = NetworkModel()
model_instance = model_instance.to(compute_device)
# Thiết lập hàm tính toán lỗi
criterion = nn.CrossEntropyLoss()
criterion = criterion.to(compute_device)
# Thiết lập bộ tối ưu hóa
learning_rate = 1e-2
optimizer = torch.optim.SGD(model_instance.parameters(), lr=learning_rate)
# Cấu hình các tham số huấn luyện
current_training_step = 0
current_validation_step = 0
epochs_count = 10
tensorboard_writer = SummaryWriter("./logs")
for epoch_index in range(epochs_count):
print(f"--------Bắt đầu vòng huấn luyện thứ {epoch_index+1}--------")
# Giai đoạn huấn luyện
for batch_data in training_loader:
input_images, expected_labels = batch_data
input_images = input_images.to(compute_device)
expected_labels = expected_labels.to(compute_device)
predictions = model_instance(input_images)
error = criterion(predictions, expected_labels)
# Cập nhật trọng số mô hình
optimizer.zero_grad()
error.backward()
optimizer.step()
current_training_step += 1
if current_training_step % 100 == 0:
print(f"Bước huấn luyện: {current_training_step}, lỗi: {error.item()}")
tensorboard_writer.add_scalar("training_error", error.item(), current_training_step)
# Giai đoạn kiểm tra
accumulated_validation_error = 0
correct_predictions_total = 0
with torch.no_grad():
for validation_batch in validation_loader:
val_images, val_targets = validation_batch
val_images = val_images.to(compute_device)
val_targets = val_targets.to(compute_device)
val_outputs = model_instance(val_images)
val_error = criterion(val_outputs, val_targets)
accumulated_validation_error += val_error.item()
correct_predictions = (val_outputs.argmax(1) == val_targets).sum()
correct_predictions_total += correct_predictions
print(f"Tổng lỗi trên tập kiểm tra: {accumulated_validation_error}")
print(f"Độ chính xác trên tập kiểm tra: {correct_predictions_total/validation_length}")
tensorboard_writer.add_scalar("validation_error", accumulated_validation_error, current_validation_step)
tensorboard_writer.add_scalar("accuracy_score", correct_predictions_total/validation_length, current_validation_step)
current_validation_step += 1
torch.save(model_instance, f"model_epoch_{epoch_index}.pth")
print("Mô hình đã được lưu trữ")
tensorboard_writer.close()