WHCSRL 技术网

pytorch提供的网络模型(预测图片类别)

vgg16

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

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

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

  1. from torch import nn
  2. vgg16_false = torchvision.models.vgg16(pretrained=False)
  3. vgg16_true = torchvision.models.vgg16(pretrained=True)
  4. print(vgg16_true)
  5. # 在原有的模型中添加操作
  6. vgg16_true.classfier.add_module("add_linear",nn.Linear(1000,10)) # 名字,操作
  7. print(vgg16_true) # classfier为模型中的一个分类,也就是把线性层加在classfier下
  8. #在原模型中更改操作
  9. print(vgg_false)
  10. vgg16_false.classfier[7] = nn.Linear(4096,10) # 更改classfier下的第7个
  11. print(vgg16_false)

在第二三四行代码中进行运行,下载了vgg16的模型(0.5G)

模型的保存和加载

保存方式1:

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

保存模型结构和模型参数 

对应保存方式1加载模型:

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

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

# 或者把class粘贴进来

保存方式2:

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

保存模型参数(官方推荐)(空间小)

对应保存方式2加载模型

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

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

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

# 打印出模型和参数

完整的训练模型套路

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

# 构建神经网络 命名为 module

  1. import torch
  2. from torch import nn
  3. class Didi(nn.Module):
  4. def __init__(self):
  5. super(Didi, self).__init__()
  6. self.model = nn.Sequential(
  7. nn.Conv2d(3, 32, 5, 1, 2),
  8. nn.MaxPool2d(2),
  9. nn.Conv2d(32, 32, 5, 1, 2),
  10. nn.MaxPool2d(2),
  11. nn.Conv2d(32, 64, 5, 1, 2),
  12. nn.MaxPool2d(2),
  13. nn.Flatten(),
  14. nn.Linear(64 * 4 * 4, 64),
  15. nn.Linear(64, 10)
  16. )
  17. def forward(self,x):
  18. x = self.model(x)
  19. return x
  20. if __name__ == '__main__': # 设置为主方法
  21. didi = Didi()
  22. input = torch.ones((64,3,32,32)) # 检查是否正确
  23. output = didi(input)
  24. print(output.shape)

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

from module import *

  1. import torchvision
  2. from torch import nn
  3. from torch.utils.data import DataLoader
  4. from module import *
  5. train_data = torchvision.datasets.CIFAR10(root="./dataset",train=True,transform=torchvision.transforms.ToTensor())
  6. test_data = torchvision.datasets.CIFAR10(root="./dataset",train=False,transform=torchvision.transforms.ToTensor())
  7. train_data_size = len(train_data) # 看数据集长度(图片的个数)
  8. test_data_size = len(test_data)
  9. print("训练数据集的长度为:{}".format(train_data_size))
  10. print("测试数据集的长度为:{}".format(test_data_size)) # 字符串格式化
  11. # 利用DataLoader加载数据集
  12. train_dataloader = DataLoader(train_data,batch_size=64)
  13. test_dataloader = DataLoader(test_data,batch_size=64)
  14. # 创建网络模型
  15. didi = Didi()
  16. # 损失函数
  17. loss_fn = nn.CrossEntropyLoss()
  18. # 优化器
  19. learning_rate = 0.01
  20. optimizer = torch.optim.SGD(didi.parameters(),lr=learning_rate)
  21. # 设置训练网络的一些参数
  22. # 记录训练次数
  23. total_train_step = 0
  24. # 记录测试次数
  25. total_test_step = 0
  26. # 训练的轮数
  27. epoch= 10
  28. for i in range(epoch):
  29. print(f"-----第{i}轮训练开始-----")
  30. # 训练步骤开始
  31. for data in train_dataloader:
  32. imgs, targets = data
  33. outputs = didi(imgs)
  34. loss = loss_fn(outputs,targets)
  35. # 优化器优化模型
  36. optimizer.zero_grad() # 先梯度清零,然后反向传播求梯度,然后优化数据
  37. loss.backward()
  38. optimizer.step() # 是对数据data进行优化
  39. total_train_step = total_train_step + 1
  40. print(f"训练次数{total_train_step}loss:{loss}")

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

  1. # 测试步骤开始
  2. total_test_loss = 0
  3. with torch.no_grad(): # 保证不会对测试的代码进行调优
  4. for data in test_dataloader:
  5. imgs ,targets = data
  6. outputs = didi(imgs)
  7. loss = loss_fn(outputs,targets)
  8. total_test_loss = total_test_loss + loss.item()
  9. # 什么.item 就是把各种类型的数比如说tensor类型的数转换成一个纯粹的数
  10. 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

  1. import torch
  2. outputs = torch.tensor([[0.1,0.2],
  3. [0.05,0.4]])
  4. print(outputs.argmax(1)) # 1 横向比较 0 纵向比较
  5. preds = outputs.argmax(1)
  6. targets = torch.tensor([0,1])
  7. print((preds == targets).sum())

优化模型(完整代码)

  1. import torchvision
  2. from torch import nn
  3. from torch.utils.data import DataLoader
  4. from torch.utils.tensorboard import SummaryWriter
  5. from module import *
  6. train_data = torchvision.datasets.CIFAR10(root="./dataset",train=True,transform=torchvision.transforms.ToTensor())
  7. test_data = torchvision.datasets.CIFAR10(root="./dataset",train=False,transform=torchvision.transforms.ToTensor())
  8. train_data_size = len(train_data) # 看数据集长度(图片的个数)
  9. test_data_size = len(test_data)
  10. print("训练数据集的长度为:{}".format(train_data_size))
  11. print("测试数据集的长度为:{}".format(test_data_size)) # 字符串格式化
  12. # 利用DataLoader加载数据集
  13. train_dataloader = DataLoader(train_data,batch_size=64)
  14. test_dataloader = DataLoader(test_data,batch_size=64)
  15. # 创建网络模型
  16. didi = Didi()
  17. # 损失函数
  18. loss_fn = nn.CrossEntropyLoss()
  19. # 优化器
  20. learning_rate = 0.01
  21. optimizer = torch.optim.SGD(didi.parameters(),lr=learning_rate)
  22. # 设置训练网络的一些参数
  23. # 记录训练次数
  24. total_train_step = 0
  25. # 记录测试次数
  26. total_test_step = 0
  27. # 训练的轮数
  28. epoch= 10
  29. # 添加tensorboard
  30. writer = SummaryWriter("./ceshi")
  31. for i in range(epoch):
  32. print(f"-----第{i}轮训练开始-----")
  33. # 训练步骤开始
  34. didi.train() # 只对特定的层进行调用(本示例中无可调用的层)
  35. for data in train_dataloader:
  36. imgs, targets = data
  37. outputs = didi(imgs)
  38. loss = loss_fn(outputs,targets)
  39. # 优化器优化模型
  40. optimizer.zero_grad() # 先梯度清零,然后反向传播求梯度,然后优化梯度
  41. loss.backward()
  42. optimizer.step()
  43. total_train_step = total_train_step + 1
  44. if total_train_step %%%% 100 == 0:
  45. print(f"训练次数{total_train_step}loss:{loss}")
  46. writer.add_scalar("train_loss",loss.item(),total_train_step)
  47. # 测试步骤开始
  48. didi.eval() # 只对特定的层进行调用(本示例中无可调用的层)
  49. total_test_loss = 0
  50. total_accuracy = 0
  51. with torch.no_grad(): # 保证不会对测试的代码进行调优
  52. for data in test_dataloader:
  53. imgs ,targets = data
  54. outputs = didi(imgs)
  55. loss = loss_fn(outputs,targets)
  56. total_test_loss = total_test_loss + loss.item()
  57. # 什么.item 就是把各种类型的数比如说tensor类型的数转换成一个纯粹的数
  58. accuracy = (outputs.argmax(1) == targets).sum()
  59. total_accuracy = total_accuracy + accuracy
  60. print(f"整体测试集的loss:{total_test_loss}")
  61. print(f"整体测试集上的正确率 {total_accuracy/test_data_size}")
  62. writer.add_scalar("test_loss",total_test_loss,total_test_step)
  63. writer.add_scalar("test_accuracy",total_accuracy/test_data_size,total_test_step)
  64. total_test_step = total_test_step + 1
  65. torch.save(didi,"didi_{}.pth".format(i)) # 保存每一轮训练的模型
  66. # torch.save(didi.state_dict(),"didi_{}.pth".format(i))
  67. print("模型已保存")
  68. writer.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_accuracy = 0
    with torch.no_grad():                           # 保证不会对测试的代码进行调优
        for data in test_dataloader:
            imgs ,targets = data
            imgs = imgs.cuda()
            targets = targets.cuda()
           …………
    …………
writer.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

   屏幕截图

  1. import torch
  2. import torchvision
  3. from PIL import Image
  4. from module import *
  5. image_path = "屏幕截图 2021-10-27 185044.png"
  6. image = Image.open(image_path)
  7. print(image)
  8. image = image.convert('RGB')
  9. # png格式是4通道,除了RGB三通道外,还有一个透明通道。所以调用该函数,保留其颜色通道。该操作可适应任何png jpg各种格式的图片
  10. transform =torchvision.transforms.Compose([torchvision.transforms.Resize((32,32)),torchvision.transforms.ToTensor()])
  11. image = transform(image)
  12. image = image.cuda()
  13. print(image.shape)
  14. # 加载网络模型
  15. model = torch.load("didi_0.pth")
  16. # model = torch.load("didi_0.pth",map_location=torch.device("cpu")) 不增加.cuda()而使用cpu的方法
  17. print(model)
  18. image = torch.reshape(image,(1,3,32,32))
  19. image = image.cuda()
  20. model.eval()
  21. with torch.no_grad():
  22. output = model(image)
  23. print(output)
  24. print(output.argmax(1))

输出

  1. <PIL.PngImagePlugin.PngImageFile image mode=RGBA size=383x221 at 0x23F271B3D00>
  2. torch.Size([3, 32, 32])
  3. Didi(
  4. (model): Sequential(
  5. (0): Conv2d(3, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
  6. (1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  7. (2): Conv2d(32, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
  8. (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  9. (4): Conv2d(32, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
  10. (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  11. (6): Flatten(start_dim=1, end_dim=-1)
  12. (7): Linear(in_features=1024, out_features=64, bias=True)
  13. (8): Linear(in_features=64, out_features=10, bias=True)
  14. )
  15. )
  16. tensor([[-1.1313, -0.1298, 0.3228, 0.6047, 0.4514, 0.7824, 0.5668, 0.1615,
  17. -1.5708, -1.0045]], device='cuda:0')
  18. tensor([5], device='cuda:0') # 预测为第六个

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

推荐阅读