pytorch提供的网络模型（预测图片类别）

vgg16

因为vgg16太大了（100多个G）所以没有下载

pretrained = False         模型中所有的参数为默认参数

pretrained = True          模型中所的参数为训练好的参数

from torch import nn

vgg16_false = torchvision.models.vgg16(pretrained=False)
vgg16_true = torchvision.models.vgg16(pretrained=True)
print(vgg16_true)

# 在原有的模型中添加操作
vgg16_true.classfier.add_module("add_linear",nn.Linear(1000,10))   # 名字，操作
print(vgg16_true)     # classfier为模型中的一个分类，也就是把线性层加在classfier下

#在原模型中更改操作
print(vgg_false)
vgg16_false.classfier[7] = nn.Linear(4096,10)   # 更改classfier下的第7个
print(vgg16_false)

 

在第二三四行代码中进行运行，下载了vgg16的模型（0.5G）

模型的保存和加载

保存方式1

import torch
import torchvision
vgg16 = torchvision.model.vgg16(pretrained=False)
torch.save(vgg16,"vgg16_method1.pth")

保存模型结构和模型参数 

对应保存方式1加载模型

import torch
model = torch.load("vgg16_method1.pth")    # 模型所在位置 
print(model)

# 加载自己定义的模型时需要引入   from 文件名 import

# 或者把class粘贴进来

保存方式2

import torch
import torchvision
torch.save(vgg16.state_dict(),"vgg16_method2.pth")   # 把vgg16中的模型参数保存到字典

保存模型参数（官方推荐）（空间小）

对应保存方式2加载模型

import torch
mmodel = torch.load("vgg16_method2.pth")
print(model)

# 打印出来是在字典中的模型参数 

import torch
vgg16 = torchvision.models.vgg16(pretrained=False)
vgg16.load_state_dict(torch.load("vgg16_method2.pth")))
print(model)

# 打印出模型和参数

完整的训练模型套路

在同一个文件夹底下建立两个python文件

# 构建神经网络 命名为 module

import torch
from torch import nn

class Didi(nn.Module):
 def __init__(self):
  super(Didi, self).__init__()
  self.model = 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 forard(self,x):
  x = self.model(x)
  return x

if __name__ == '__main__':       # 设置为主方法
 didi = Didi()
 input = torch.ones((64,3,32,32))   # 检查是否正确
 output = didi(input)
 print(output.shape)

在另一个文件中引入该模型

from module import

import torchvision
from torch import nn
from torch.utils.data import DataLoader
from module import 

train_data = torchvision.datasets.CIFAR10(root="./dataset",train=True,transform=torchvision.transforms.ToTensor())
test_data = torchvision.datasets.CIFAR10(root="./dataset",train=False,transform=torchvision.transforms.ToTensor())

train_data_size = len(train_data)   # 看数据集长度（图片的个数）
test_data_size = len(test_data)
print("训练数据集的长度为{}".format(train_data_size))
print("测试数据集的长度为{}".format(test_data_size))  # 字符串格式化

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

# 创建网络模型
didi = Didi()

# 损失函数
loss_fn = nn.CrossEntropyLoss()

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

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

for i in range(epoch):
 print(f"-----第{i}轮训练开始-----")
 # 训练步骤开始
 for data in train_dataloader:
  imgs, targets = data
  outputs = didi(imgs)
  loss = loss_fn(outputs,targets)
  # 优化器优化模型
  optimizer.zero_grad()   # 先梯度清零，然后反向传播求梯度，然后优化数据
  loss.backard()
  optimizer.step()     # 是对数据data进行优化
  total_train_step = total_train_step + 1
  print(f"训练次数{total_train_step}loss:{loss}")

如何知道模型在训练时是否训练好或者达到想要的需求 

 # 测试步骤开始
 total_test_loss = 0
 ith torch.no_grad():         # 保证不会对测试的代码进行调优
  for data in test_dataloader:
   imgs ,targets = data
   outputs = didi(imgs)
   loss = loss_fn(outputs,targets)
   total_test_loss = total_test_loss + loss.item()
   # 什么.item 就是把各种类型的数比如说tensor类型的数转换成一个纯粹的数
 print(f"整体测试集的loss{total_test_loss}")

 对于分类问题可以用正确率来表示

2个输入

放入model（二分类）

输出[0.1,0.2]                   属于1类别

       [0.05,0.4]                 属于1类别 

类别  0      1

利用Argmax

预测=[1]

         [1]

真实target = [0][1]

预测==真实target

[false,true].sum = 1

import torch

outputs = torch.tensor([[0.1,0.2],
        [0.05,0.4]])
print(outputs.argmax(1))    # 1 横向比较 0 纵向比较
preds = outputs.argmax(1)
targets = torch.tensor([0,1])
print((preds == targets).sum())

优化模型(完整代码)

import torchvision
from torch import nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from module import 

train_data = torchvision.datasets.CIFAR10(root="./dataset",train=True,transform=torchvision.transforms.ToTensor())
test_data = torchvision.datasets.CIFAR10(root="./dataset",train=False,transform=torchvision.transforms.ToTensor())

train_data_size = len(train_data)   # 看数据集长度（图片的个数）
test_data_size = len(test_data)
print("训练数据集的长度为{}".format(train_data_size))
print("测试数据集的长度为{}".format(test_data_size))  # 字符串格式化

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

# 创建网络模型
didi = Didi()

# 损失函数
loss_fn = nn.CrossEntropyLoss()

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

# 设置训练网络的一些参数
# 记录训练次数
total_train_step = 0
# 记录测试次数
total_test_step = 0
# 训练的轮数
epoch= 10
# 添加tensorboard
riter = SummaryWriter("./ceshi")

for i in range(epoch):
 print(f"-----第{i}轮训练开始-----")
 # 训练步骤开始
 didi.train()       # 只对特定的层进行调用（本示例中无可调用的层）
 for data in train_dataloader:
  imgs, targets = data
  outputs = didi(imgs)
  loss = loss_fn(outputs,targets)
  # 优化器优化模型
  optimizer.zero_grad()   # 先梯度清零，然后反向传播求梯度，然后优化梯度
  loss.backard()
  optimizer.step()
  total_train_step = total_train_step + 1
  if total_train_step % 100 == 0:
   print(f"训练次数{total_train_step}loss:{loss}")
   riter.add_scalar("train_loss",loss.item(),total_train_step)
 # 测试步骤开始
 didi.eval()        # 只对特定的层进行调用（本示例中无可调用的层）
 total_test_loss = 0
 total_auracy = 0
 ith torch.no_grad():         # 保证不会对测试的代码进行调优
  for data in test_dataloader:
   imgs ,targets = data
   outputs = didi(imgs)
   loss = loss_fn(outputs,targets)
   total_test_loss = total_test_loss + loss.item()
   # 什么.item 就是把各种类型的数比如说tensor类型的数转换成一个纯粹的数
   auracy = (outputs.argmax(1) == targets).sum()
   total_auracy = total_auracy + auracy

 print(f"整体测试集的loss{total_test_loss}")
 print(f"整体测试集上的正确率 {total_auracy/test_data_size}")
 riter.add_scalar("test_loss",total_test_loss,total_test_step)
 riter.add_scalar("test_auracy",total_auracy/test_data_size,total_test_step)
 total_test_step = total_test_step + 1

 torch.save(didi,"didi_{}.pth".format(i))   # 保存每一轮训练的模型
 # torch.save(didi.state_dict(),"didi_{}.pth".format(i))
 print("模型已保存")

riter.close()

步骤准备数据集，准备dataloader，创建网络模型，创建损失函数，优化器，设置训练参                        数，设置训练轮数epoch，开始训练算出误差放入优化器优化，进行测试（不需要梯                        度）计算误差，保存模型。

利用GPU训练

1. 可在 网络模型, 数据（输入，标注） ,损失函数 中使用

   .cuda()

简略代码

…………
import time
…………
didi = Didi()
if torch.cuda.is_available():
 didi = didi.cuda()
# 损失函数
loss_fn = nn.CrossEntropyLoss()
loss_fn = loss_fn.cuda()
…………
# 开始时间
start_time = time.time()
for i in range(epoch):
 print(f"-----第{i}轮训练开始-----")
 # 训练步骤开始
 didi.train()       # 只对特定的层进行调用（本示例中无可调用的层）
 for data in train_dataloader:
  imgs, targets = data
  imgs = imgs.cuda()
  targets = targets.cuda()
  …………
  if total_train_step % 100 == 0:
   end_time = time.time()
   print(end_time - start_time)
   …………
 # 测试步骤开始
 didi.eval()        # 只对特定的层进行调用（本示例中无可调用的层）
 total_test_loss = 0
 total_auracy = 0
 ith torch.no_grad():         # 保证不会对测试的代码进行调优
  for data in test_dataloader:
   imgs ,targets = data
   imgs = imgs.cuda()
   targets = targets.cuda()
     …………
 …………
riter.close()

2. 可在 网络模型, 数据（输入，标注） ,损失函数 中使用

.to(device)

Device = torch.device("cpu")

Torch.device("cuda")  或者 Torch.device("cuda:0")   # 电脑中有多个显卡使用第一个

简略代码

# 定义训练设备 
device = torch.device("cuda" if torch.cuda.is_availiable() else"cpu")
# 替换上面红色代码
didi = didi.to(device)
loss_fn = loss_fn.to(device)
imgs = imgs.to(device)
targets = targets.to(device)
imgs = imgs.to(device)
targets = targets.to(device)

完整的模型验证（测试，demo）套路 

利用已经训练好的模型，然后给他提供输入

因为我上一个保存的模型是用GPU保存的，所以这次输入也要用GPU

   屏幕截图

import torch
import torchvision
from PIL import Image
from module import 

image_path = "屏幕截图 2021-10-27 185044.png"
image = Image.open(image_path)
print(image)
image = image.convert('RGB')
# png格式是4通道，除了RGB三通道外，还有一个透明通道。所以调用该函数，保留其颜色通道。该操作可适应任何png jpg各种格式的图片

transform =torchvision.transforms.Compose([torchvision.transforms.Resize((32,32)),torchvision.transforms.ToTensor()])
image = transform(image)
image = image.cuda()
print(image.shape)
# 加载网络模型
model = torch.load("didi_0.pth")
# model = torch.load("didi_0.pth",map_location=torch.device("cpu"))   不增加.cuda()而使用cpu的方法
print(model)
image = torch.reshape(image,(1,3,32,32))
image = image.cuda()
model.eval()
ith torch.no_grad():
 output = model(image)
print(output)
print(output.argmax(1))

输出

torch.Size([3, 32, 32])
Didi(
  (model): Sequential(
 (0): Conv2d(3, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
 (1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
 (2): Conv2d(32, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
 (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
 (4): Conv2d(32, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
 (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
 (6): Flatten(start_dim=1, end_dim=-1)
 (7): Linear(in_features=1024, out_features=64, bias=True)
 (8): Linear(in_features=64, out_features=10, bias=True)
  )
)
tensor([[-1.1313, -0.1298,  0.3228,  0.6047,  0.4514,  0.7824,  0.5668,  0.1615,
   -1.5708, -1.0045]], device='cuda:0')
tensor([5], device='cuda:0')  # 预测为第六个

 可以看出输出5对应dog   预测成功