pytorch基础学习6

"我是土堆"视频+【我是土堆 - PyTorch教程】学习随手记
利用GPU训练
方式1:
在网络模型,数据(输入和标注),损失函数部分,调用**.cuda()**

#train_gpu1
#gpu训练方式
import time
import torch
import torchvision
from torch import nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

#准备数据集
train_data=torchvision.datasets.CIFAR10("./datasets",train=True,transform=torchvision.transforms.ToTensor(),
                                        download=True)
test_data=torchvision.datasets.CIFAR10("./datasets",train=False,transform=torchvision.transforms.ToTensor(),
                                       download=True)

#length 长度(获得数据集的长度)
train_data_size=len(train_data)
test_data_size=len(test_data)
print("训练数据集的长度:{}".format(train_data_size))
print("测试数据集的长度:{}".format(test_data_size))

#利用dataloader来加载数据集
train_data_loader=DataLoader(train_data,batch_size=64)
test_data_loader=DataLoader(test_data,batch_size=64)

#创建网络模型
#搭建神经网络
class Module(nn.Module):
    def __init__(self):
        super(Module,self).__init__()
        self.module=nn.Sequential(
            nn.Conv2d(3,32,5,stride=1,padding=2),
            nn.MaxPool2d(2),
            nn.Conv2d(32,32,5,stride=1,padding=2),
            nn.MaxPool2d(2),
            nn.Conv2d(32,64,5,stride=1,padding=2),
            nn.MaxPool2d(2),
            nn.Flatten(),#展平
            nn.Linear(64*4*4,64),
            nn.Linear(64,10)
        )
    def forward(self,x):
        x=self.module(x)
        return x

snow=Module()
if(torch.cuda.is_available()):
    snow=snow.cuda() #网络模型转移到cuda上

#创建损失函数
loss_function=nn.CrossEntropyLoss()
loss_function=loss_function.cuda() #损失函数转移到cuda上

#优化器 SGD随机梯度下降
learning_rate=0.01 #或者 1e-2=1*(10)^(-2)=1/100=0.01
optimizer=torch.optim.SGD(snow.parameters(),lr=learning_rate)

#设置训练网络的一些参数
total_train_step=0 #记录训练的次数
total_test_step=0 #记录测试的次数
epoch =10 #训练的轮次

#添加tensorboard
writer=SummaryWriter("./logs")
time_start=time.time() #记录时间
for i in range(epoch):
    print("------第{}轮训练开始------".format(i+1))

    #训练步骤开始
    snow.train() #只对特定的层有作用,看官网说明
    for data in train_data_loader:
        imgs,targets=data  # 从训练的dataloader中取数据
        if torch.cuda.is_available():
            imgs=imgs.cuda()  #数据转移到cuda上
            targets=targets.cuda()
        output=snow(imgs)
        loss=loss_function(output,targets) #计算损失

        #优化器优化模型
        optimizer.zero_grad() #梯度清零
        loss.backward() #反向传播(反向传播得到每一个参数节点的梯度)
        optimizer.step() #参数调优

        total_train_step+=1
        if(total_train_step%100==0):
            time_end=time.time() #记录时间
            print(time_end-time_start)
            print("训练次数:{},Loss:{}".format(total_train_step,loss))
            writer.add_scalar("train_loss",loss.item(),total_train_step)
            #add_scalar:将标量数据添加到摘要

    #评估模型是否训练好,训练完一轮,进行测试
    snow.eval() #只对特定的层有作用
    total_loss=0
    total_acccury=0
    with torch.no_grad():  #没有梯度,不进行修改
        for data in test_data_loader:
            imgs,targets=data
            if torch.cuda.is_available():
                imgs = imgs.cuda() #数据转移到cuda上
                targets = targets.cuda()
            output=snow(imgs)
            loss=loss_function(output,targets)
            total_loss=total_loss+loss.item()
            accuray=(output.argmax(1)==targets).sum()   #正确率
            total_acccury=total_acccury+accuray

    print("整体测试集上的Loss:{}".format(total_loss))
    print("整体测试集上的正确率:{}".format(total_acccury/test_data_size))
    writer.add_scalar("tset_loss",total_loss,total_test_step)
    writer.add_scalar("test_accuracy",total_acccury/test_data_size,total_test_step)
    total_test_step+=1

    # 保存模型1
    #torch.save(snow,"snow_{}.pth".format(i))
    #保存模型方式2 官网推荐
    torch.save(snow.state_dict(),"snow_{}.pth".format(i))
    print("模型已保存")

writer.close()

查看GPU信息 ,在 Terminal 里输入

nvidia-smi

方式2(常用):
网络模型、损失函数都不需要另外赋值，直接 .to(device) 就可以
但是数据（图片、标注）需要另外转移之后再重新赋值给变量

#train_gpu2
#gpu训练方式
import time
import torch
import torchvision
from torch import nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

#定义训练的设备
# device=torch.device("cuda")
device=torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(device)
#准备数据集
train_data=torchvision.datasets.CIFAR10("./datasets",train=True,transform=torchvision.transforms.ToTensor(),
                                        download=True)
test_data=torchvision.datasets.CIFAR10("./datasets",train=False,transform=torchvision.transforms.ToTensor(),
                                       download=True)

#length 长度(获得数据集的长度)
train_data_size=len(train_data)
test_data_size=len(test_data)
print("训练数据集的长度:{}".format(train_data_size))
print("测试数据集的长度:{}".format(test_data_size))

#利用dataloader来加载数据集
train_data_loader=DataLoader(train_data,batch_size=64)
test_data_loader=DataLoader(test_data,batch_size=64)

#创建网络模型
#搭建神经网络
class Module(nn.Module):
    def __init__(self):
        super(Module,self).__init__()
        self.module=nn.Sequential(
            nn.Conv2d(3,32,5,stride=1,padding=2),
            nn.MaxPool2d(2),
            nn.Conv2d(32,32,5,stride=1,padding=2),
            nn.MaxPool2d(2),
            nn.Conv2d(32,64,5,stride=1,padding=2),
            nn.MaxPool2d(2),
            nn.Flatten(),#展平
            nn.Linear(64*4*4,64),
            nn.Linear(64,10)
        )
    def forward(self,x):
        x=self.module(x)
        return x

snow=Module()
#网络模型转移到cuda上
snow.to(device)

#创建损失函数
loss_function=nn.CrossEntropyLoss()
loss_function=loss_function.to(device) #损失函数转移到cuda上

#优化器 SGD随机梯度下降
learning_rate=0.01 #或者 1e-2=1*(10)^(-2)=1/100=0.01
optimizer=torch.optim.SGD(snow.parameters(),lr=learning_rate)

#设置训练网络的一些参数
total_train_step=0 #记录训练的次数
total_test_step=0 #记录测试的次数
epoch =10 #训练的轮次

#添加tensorboard
writer=SummaryWriter("./logs")
time_start=time.time() #记录时间
for i in range(epoch):
    print("------第{}轮训练开始------".format(i+1))

    #训练步骤开始
    snow.train() #只对特定的层有作用,看官网说明
    for data in train_data_loader:
        imgs,targets=data  # 从训练的dataloader中取数据
         #数据转移到cuda上
        imgs=imgs.to(device)
        targets=targets.to(device)
        output=snow(imgs)
        loss=loss_function(output,targets) #计算损失

        #优化器优化模型
        optimizer.zero_grad() #梯度清零
        loss.backward() #反向传播(反向传播得到每一个参数节点的梯度)
        optimizer.step() #参数调优

        total_train_step+=1
        if(total_train_step%100==0):
            time_end=time.time() #记录时间
            print(time_end-time_start)
            print("训练次数:{},Loss:{}".format(total_train_step,loss))
            writer.add_scalar("train_loss",loss.item(),total_train_step)
            #add_scalar:将标量数据添加到摘要

    #评估模型是否训练好,训练完一轮,进行测试
    snow.eval() #只对特定的层有作用
    total_loss=0
    total_acccury=0
    with torch.no_grad():  #没有梯度,不进行修改
        for data in test_data_loader:
            imgs,targets=data
             #数据转移到cuda上
            imgs = imgs.to(device)
            targets = targets.to(device)
            output=snow(imgs)
            loss=loss_function(output,targets)
            total_loss=total_loss+loss.item()
            accuray=(output.argmax(1)==targets).sum()   #正确率
            total_acccury=total_acccury+accuray

    print("整体测试集上的Loss:{}".format(total_loss))
    print("整体测试集上的正确率:{}".format(total_acccury/test_data_size))
    writer.add_scalar("tset_loss",total_loss,total_test_step)
    writer.add_scalar("test_accuracy",total_acccury/test_data_size,total_test_step)
    total_test_step+=1

    # 保存模型1
    #torch.save(snow,"snow_{}.pth".format(i))
    #保存模型方式2 官网推荐
    torch.save(snow.state_dict(),"snow_{}.pth".format(i))
    print("模型已保存")

writer.close()

3.完整的模型验证
利用已经训练好的模型,然后给它提供输入进行测试

出错: 译（五十四）-RuntimeError Input type (torch.FloatTensor) and weight type (torch.cuda.FloatTensor) should b

原因:保存了用gpu训练的模型,但是在读取模型时,需要加上.cuda(),让其用gpu训练,且数据也要传送到gpu中,即下面这一步,必须保证是在tensor类型前提下


或者:

#在不同环境中加载已经训练好的模型，需要经过映射）
module=torch.load("snow_6.pth",map_location=torch.device('cpu')) # gpu映射到cpu

import torch
import torchvision
from PIL import Image
from torch import nn

image_path="./hymenoptera_data/img.png"
image=Image.open(image_path)  #打开文件
print(image) #输出:<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=500x375 at 0x1F7D91AB5D0>
image=image.convert('RGB')  #image.convert('RGB'),此方法保留rgb三个通道
#png格式的图片有四个通道,还有一个透明度通道,而我们定义的网络模型要求是三个通道
#当然，如果图片本来就是三颜色通道，经过此操作，不变
# 加上这一步后，可以适应 png jpg 各种格式的图片
transformer=torchvision.transforms.Compose([torchvision.transforms.Resize((32,32)),
                                            torchvision.transforms.ToTensor()])
#Resize 裁剪;ToTensor 转成tensor类型
image=transformer(image)
# image=image.cuda()
print(image.shape) #输出:torch.Size([3, 32, 32]

#搭建神经网络
class Module(nn.Module):
    def __init__(self):
        super(Module,self).__init__()
        self.module=nn.Sequential(
            nn.Conv2d(3,32,5,stride=1,padding=2),
            nn.MaxPool2d(2),
            nn.Conv2d(32,32,5,stride=1,padding=2),
            nn.MaxPool2d(2),
            nn.Conv2d(32,64,5,stride=1,padding=2),
            nn.MaxPool2d(2),
            nn.Flatten(),#展平
            nn.Linear(64*4*4,64),
            nn.Linear(64,10)
        )
    def forward(self,x):
        x=self.module(x)
        return x

# module=torch.load("snow_0.pth")
# module=module.cuda()
# 或者
module=torch.load("snow_29__test.pth",map_location=torch.device('cpu')) # gpu映射到cpu
print(module)
image=torch.reshape(image,[1,3,32,32]) #网络训练过程中需要batch_size属性
module.eval()#展开测试阶段
with torch.no_grad():
    output=module(image)
print(output)

print(output.argmax(1))