小土堆Pytorch笔记P30、31

编程基础很弱，需要机器学习，学习记录，按自己理解写的，希望以后能学懂吧，要是有大神看到还请赐教。

利用GPU训练（一）

在原来代码的基础上修改一部分就可以了，具有两种方式让代码在GPU上进行训练。

方式1：

在代码中找到”网络模型“、”数据（输入，标注）“、”损失函数“；使用.cuda()然后再返回。

import torch.optim
import torchvision.datasets
from torch.utils.tensorboard import SummaryWriter

# from modelCIFAR10 import *
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear
from torch.utils.data import DataLoader

# 准备数据集
train_data = torchvision.datasets.CIFAR10(root='./dataset', train=True, transform=torchvision.transforms.ToTensor(),
                                          download=True)
test_data = torchvision.datasets.CIFAR10(root='./dataset', train=False, transform=torchvision.transforms.ToTensor(),
                                         download=True)
# 看看数据集多大
train_data_size = len(train_data)
test_data_size = len(test_data)
print(train_data_size)
print(test_data_size)

# 加载数据集
train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)


# 创建网络模型
class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()
        self.model1 = nn.Sequential(
            nn.Conv2d(3, 32, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 32, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Flatten(),
            nn.Linear(64 * 4 * 4, 64),
            nn.Linear(64, 10)
        )

    def forward(self, x):
        x = self.model1(x)
        return x


tudui = Tudui()
#######################################################################
# 调用GPU
if torch.cuda.is_available():
    tudui = tudui.cuda()

# 创建损失函数
loss_function = nn.CrossEntropyLoss()
#######################################################################
# 调用GPU
if torch.cuda.is_available():
    loss_function = loss_function.cuda()

# 创建优化器
learning_rate = 0.01
optimizer = torch.optim.SGD(tudui.parameters(), lr=learning_rate)

# 设置训练网络的一些参数
total_train_step = 0  # 用这个变量记录训练的次数
total_test_step = 0  # 用这个变量记录测试的次数
# 设置训练的轮数
epoch = 100

# 添加tensorboard
writer = SummaryWriter("logs")
# 开始写循环
for i in range(epoch):
    print("第{}轮训练开始".format(i + 1))
    # 训练步骤开始
    for data in train_dataloader:
        imgs, targets = data
        #######################################################################
        # 调用GPU
        if torch.cuda.is_available():
            imgs = imgs.cuda()
            targets = targets.cuda()
        output = tudui(imgs)
        loss = loss_function(output, targets)

        # 优化器优化模型
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        # 记录训练次数
        total_train_step = total_train_step + 1
        # 不让它每次训练都打印
        if total_train_step % 100 == 0:
            print("训练次数{},损失值{}".format(total_train_step, loss.item()))
            writer.add_scalar("Train Loss", loss.item(), total_train_step)
    # 每轮训练完后在测试集上跑一遍，以评估是否训练好
    '''在测试过程中不需要对模型调优，因为是想测试这个当前模型效果，因此不需要调优'''
    # 测试步骤开始
    total_test_loss = 0
    total_accuracy = 0  #
    with torch.no_grad():  # 在with内的代码没有梯度,保证不会进行调优
        for data in test_dataloader:
            imgs, targets = data
            #######################################################################
            # 调用GPU
            if torch.cuda.is_available():
                imgs = imgs.cuda()
                targets = targets.cuda()
            outputs = tudui(imgs)
            loss = loss_function(outputs, targets)
            total_test_loss = total_test_loss + loss.item()
            total_test_step = total_test_step + 1
            accuracy = (outputs.argmax(1) == targets).sum()  # 这里没太明白，回头再仔细研究一下
            total_accuracy = total_accuracy + accuracy  #
    print("整体测试集loss{}".format(total_test_loss))
    print("整体测试集上的正确率：{}".format(total_accuracy / test_data_size))
    writer.add_scalar("Test Loss", total_test_loss, total_test_step)
    writer.add_scalar("Test accuracy", total_accuracy / test_data_size, total_test_step)
    # 保存每轮训练模型
    torch.save(tudui, "tudui_{}.pth".format(i + 1))
    print("模型已保存")
writer.close()

使用time进行计时

import time
#在训练开始前
start_time =time.time()
#在第一次打印前
end_time=time.time()
print(end_time-start_time)

方式2：

.to(device)

#第二种调用GPU的方式
import torch.optim
import torchvision.datasets
from torch.utils.tensorboard import SummaryWriter

# from modelCIFAR10 import *
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear
from torch.utils.data import DataLoader

# 准备数据集
train_data = torchvision.datasets.CIFAR10(root='./dataset', train=True, transform=torchvision.transforms.ToTensor(),
                                          download=True)
test_data = torchvision.datasets.CIFAR10(root='./dataset', train=False, transform=torchvision.transforms.ToTensor(),
                                         download=True)
#定义训练的设备
device=torch.device("cuda:0")
# 看看数据集多大
train_data_size = len(train_data)
test_data_size = len(test_data)
print(train_data_size)
print(test_data_size)

# 加载数据集
train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)


# 创建网络模型
class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()
        self.model1 = nn.Sequential(
            nn.Conv2d(3, 32, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 32, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Flatten(),
            nn.Linear(64 * 4 * 4, 64),
            nn.Linear(64, 10)
        )

    def forward(self, x):
        x = self.model1(x)
        return x


tudui = Tudui()
#######################################################################
# 调用GPU
tudui = tudui.to(device)

# 创建损失函数
loss_function = nn.CrossEntropyLoss()
#######################################################################
# 调用GPU
loss_function = loss_function.to(device)

# 创建优化器
learning_rate = 0.01
optimizer = torch.optim.SGD(tudui.parameters(), lr=learning_rate)

# 设置训练网络的一些参数
total_train_step = 0  # 用这个变量记录训练的次数
total_test_step = 0  # 用这个变量记录测试的次数
# 设置训练的轮数
epoch = 100

import time
# 添加tensorboard
writer = SummaryWriter("logs")
start_time=time.time()
# 开始写循环
for i in range(epoch):
    print("第{}轮训练开始".format(i + 1))
    # 训练步骤开始
    for data in train_dataloader:
        imgs, targets = data
        #######################################################################
        # 调用GPU
        imgs = imgs.to(device)
        targets = targets.to(device)
        output = tudui(imgs)
        loss = loss_function(output, targets)

        # 优化器优化模型
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        # 记录训练次数
        total_train_step = total_train_step + 1
        # 不让它每次训练都打印
        if total_train_step % 100 == 0:
            end_time=time.time()
            print(end_time-start_time)
            print("训练次数{},损失值{}".format(total_train_step, loss.item()))
            writer.add_scalar("Train Loss", loss.item(), total_train_step)
    # 每轮训练完后在测试集上跑一遍，以评估是否训练好
    '''在测试过程中不需要对模型调优，因为是想测试这个当前模型效果，因此不需要调优'''
    # 测试步骤开始
    total_test_loss = 0
    total_accuracy = 0  #
    with torch.no_grad():  # 在with内的代码没有梯度,保证不会进行调优
        for data in test_dataloader:
            imgs, targets = data
            #######################################################################
            # 调用GPU
            imgs = imgs.to(device)
            targets = targets.to(device)
            outputs = tudui(imgs)
            loss = loss_function(outputs, targets)
            total_test_loss = total_test_loss + loss.item()
            total_test_step = total_test_step + 1
            accuracy = (outputs.argmax(1) == targets).sum()  # 这里没太明白，回头再仔细研究一下
            total_accuracy = total_accuracy + accuracy  #
    print("整体测试集loss{}".format(total_test_loss))
    print("整体测试集上的正确率：{}".format(total_accuracy / test_data_size))
    writer.add_scalar("Test Loss", total_test_loss, total_test_step)
    writer.add_scalar("Test accuracy", total_accuracy / test_data_size, total_test_step)
    # 保存每轮训练模型
    torch.save(tudui, "tudui_{}.pth".format(i + 1))
    print("模型已保存")
writer.close()

常见写法：

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")