Neural Network学习笔记3

目录

损失函数和反向传播网络

优化器

现有网络模型的使用及修改

网络模型的保存与读取

---

损失函数和反向传播网络

在进行损失函数计算后，再进行.backward()反向传播。

import torch
import torchvision
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10("dataset_transform",train=False, transform=torchvision.transforms.ToTensor(), download=True)
dataloader = DataLoader(dataset, batch_size=1)


class Zrf(nn.Module):
    def __init__(self):
        super(Zrf, self).__init__()
        self.model1 = Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

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

# 分类问题适合用交叉熵
loss = nn.CrossEntropyLoss()
zrf = Zrf()
for data in dataloader:
    imgs, targets = data
    outputs = zrf(imgs)
    # print(outputs)
    # print(targets)
    result_loss = loss(outputs, targets)
    result_loss.backward()

优化器

  以Adadelta为例，torch.optim.Adadelta(params, lr=1.0, rho=0.9, eps=1e-06, weight_decay=0)

params: 模型的参数，让优化器知道我们的模型长什么样子。

lr: Learning rate, 学习率

其他的参数可以采用默认，并且优化算法不同，参数也会有很大不同。

import torch
import torchvision
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10("dataset_transform",train=False, transform=torchvision.transforms.ToTensor(), download=True)
dataloader = DataLoader(dataset, batch_size=1)


class Zrf(nn.Module):
    def __init__(self):
        super(Zrf, self).__init__()
        self.model1 = Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

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

# 分类问题适合用交叉熵
loss = nn.CrossEntropyLoss()
zrf = Zrf()
# 设置优化器
# SGD 随机梯度下降
# lr的设不可以太大也不可以太小，一般情况下我们采用训练开始时lr大，之后的训练中lr小的方式
optim = torch.optim.SGD(zrf.parameters(), lr=0.01)
for epoch in range(20) :
    running_loss = 0.0
    for data in dataloader:
        imgs, targets = data
        outputs = zrf(imgs)
        result_loss = loss(outputs, targets)
        # 在进行反向传播来计算梯度时，要先将梯度置为0，防止之前计算出来的梯度的影响
        optim.zero_grad()
        result_loss.backward()
        # 根据梯度对卷积核参数进行调优
        optim.step()
        running_loss = running_loss + result_loss
    print(running_loss)

现有网络模型的使用及修改

torchvision.modles中的VGG为例。VGG常用VGG16和VGG19。

weights: 可选，要使用的预训练权重。默认情况下，不使用预先训练的权重。

progress: true时，会展示一个进度条

此外，pytorch在下载模型时会把模型下载到C盘，下面语句可以修改下载位置：

os.environ['TORCH_HOME'] = '/path/to/torch_home'

import torchvision
from torch import nn
from torchvision.models import VGG16_Weights
import os


# train_data = torchvision.datasets.ImageNet(root="data_image_net", split="train", download=True,
#                                            transform=torchvision.transforms.ToTensor())

# 最新版本默认是没有预训练的，需要使用预训练设置weights='DEFAULT'

os.environ['TORCH_HOME'] = '/path/to/torch_home'

vgg16_noPre = torchvision.models.vgg16()
vgg16_pre = torchvision.models.vgg16(weights=VGG16_Weights.DEFAULT)
print(vgg16_pre)

# 微调网络模型
train_data = torchvision.datasets.CIFAR10("dataset_transform",train=False, transform=torchvision.transforms.ToTensor(), download=True)
# 添加一层
# 在vgg整体层面上加
vgg16_pre.add_module('add_linear', nn.Linear(1000, 10))
print(vgg16_pre)
# 只在某一部分加（classifier部分）
vgg16_pre.classifier.add_module('add_linear', nn.Linear(1000, 10))
print(vgg16_pre)

# 修改
vgg16_noPre.classifier[6] = nn.Linear(4096, 10)
print(vgg16_noPre)

网络模型的保存与读取

保存方法演示：model_save.py

import torch
import torchvision
from torch import nn

# 使用未经过训练的，初始化的参数
vgg16 = torchvision.models.vgg16()
# 保存方式1
# 这样不仅保存了网络模型的结构，也保存了网络模型的参数
torch.save(vgg16, "vgg16_method1.pth")

# 保存方式2
# 不保存网络的结构，只是把网络的参数保存成数据字典，也就是保存了网络的状态
# (官方推荐！！！)占用空间更小
torch.save(vgg16.state_dict(), "vgg16_method2.pth")

# 陷阱1
class Zrf(nn.Module):
    def __init__(self):
        super(Zrf, self).__init__()
        self.conv1 = nn.Conv2d(3, 64, kernel_size=3)

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

zrf = Zrf()
torch.save(zrf, "zrf_method1.pth")

读取方法演示：model_load.py

import torch
import torchvision
from torch import nn

# 方式1 ----> 对应保存方式1，来加载模型
model = torch.load("vgg16_method1.pth")
# print(model)

# 方式2 ---> 对应保存方式2
vgg16 = torchvision.models.vgg16() # 新建网络模型结构
model = torch.load("vgg16_method2.pth")
# print(model)
vgg16.load_state_dict(model) # 加载网络模型的状态
print(vgg16)

# 陷阱1
# 在使用自己创建的网络时，注意要有网络的这个类在本文件（程序可以访问到网络），只是不需要zrf = Zrf()再创建网络了
# 方法1
# class Zrf(nn.Module):
#     def __init__(self):
#         super(Zrf, self).__init__()
#         self.conv1 = nn.Conv2d(3, 64, kernel_size=3)
#
#     def forward(self, x):
#         x = self.conv1(x)
#         return x
# 方法2
from model_save import *

model = torch.load("zrf_method1.pth")
print(model)