"我是土堆"视频+【我是土堆 - 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))