pytorch入门（3）

卷积层的使用

conv2d参数

in_channel:输入图像的通道数，RGB彩色图像为3

out_channel:卷积核数

kernel_size:卷积核尺寸

stride:步长

padding:padding=0不补零，padding=1在图像四周补0

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

datasets=torchvision.datasets.CIFAR10("D:\yw_app\pycharm\Pycharm_project\pytorch\datasets",train=False,transform=torchvision.transforms.ToTensor(),
                                      download=False)
dataloader=DataLoader(datasets,batch_size=64)#每64张图一打包
class Tudui(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.conv1=Conv2d(in_channels=3,out_channels=6,kernel_size=3,stride=1,padding=0)
    def forward(self,x):
        x=self.conv1(x)
        return x
tudui=Tudui()

#查看dataloader里每一张图像
writer=SummaryWriter('conv')
step=0
for data in dataloader:
    imgs,targets=data
    output=tudui(imgs)
    print(output.shape)
    print(imgs.shape)
    #torch.Size([64, 3, 32, 32])
    writer.add_images('input',imgs,step)
    # torch.Size([64, 6, 30, 30])
    output= torch.reshape(output,(-1,3,30,30))#'-1'意思是让计算机根据通道数和图片格式，自动调整batch_size
    writer.add_images('output',output,step)


    step+=1

writer.close()

torch.tensor（）与torch.ToTensor（）区别：

前者是将数据类型转换成tensor，输入可为list，tuple，矩阵

后者将PIL图片或者numpy.ndarray图片，格式为（HxWxC）转为tensor(CxHxW)

池化层的使用：

maxpool2d参数：

kernel_size:池化核大小

stride：步长

padding：padding=0不补零，padding=1在图像四周补0

ceil_mode：是否保留不能被池化核完全覆盖的部分，True保留，False丢弃

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

datasets=torchvision.datasets.CIFAR10('D:\yw_app\pycharm\Pycharm_project\pytorch\datasets',train=False,transform=torchvision.transforms.ToTensor(),download=False)
dataloader=DataLoader(datasets,batch_size=64)
#
class Tudui(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.maxpool1=MaxPool2d(kernel_size=3,ceil_mode=True)#保留不能被池化核完全覆盖的部分
    def forward(self,x):
        x=self.maxpool1(x)
        return x
tudui=Tudui()
step=0
writer=SummaryWriter('maxpool')
for data in dataloader:
    imgs,targets=data
    writer.add_images('input',imgs,step)
    output=tudui(imgs)
    writer.add_images('output',output,step)
    step+=1
writer.close()

sequential：

class Tudui(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        # self.conv1=Conv2d(3,32,5,padding=2)
        # self.maxpool1=MaxPool2d(2)
        # self.conv2=Conv2d(32,32,5,padding=2)
        # self.maxpool2=MaxPool2d(2)
        # self.conv3=Conv2d(32,64,5,padding=2)
        # self.maxpool3=MaxPool2d(2)
        # self.flatten=Flatten()
        # self.linear1=Linear(1024,64)
        # self.linear2=Linear(64,10)
        self.mode1=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.conv1(x)
        # x=self.maxpool1(x)
        # x=self.conv2(x)
        # x=self.maxpool2(x)
        # x=self.conv3(x)
        # x=self.maxpool3(x)
        # x=self.flatten(x)
        # x=self.linear1(x)
        # x=self.linear2(x)
        x=self.mode1(x)
        return x

Loss Function：

计算实际输出和目标之间的差距

为更新输出（反向传播）提供一定的依据。

loss=nn.CrossEntropyLoss()#损失函数
tudui=Tudui()
optim=torch.optim.SGD(tudui.parameters(),lr=0.01)#优化器
for epoch in range(20):
    running_loss=0.0
    for data in dataloader:
        imgs,targets=data
        outputs=tudui(imgs)
        result_loss=loss(outputs,targets)#计算预测值与实际值的差
        optim.zero_grad()#把上一次的梯度清零
        result_loss.backward()#反向传播
        optim.step()#优化器对每个参数调优
        running_loss=running_loss+result_loss#计算每次次迭代的损失和
    print(running_loss)

修改模型：

VGG16_false=torchvision.models.vgg16(pretrained=False)#加载网络架构
VGG16_True=torchvision.models.vgg16(pretrained=True)#下载好的训练参数
print(VGG16_True)
train_data=torchvision.datasets.CIFAR10('D:\yw_app\pycharm\Pycharm_project\pytorch\datasets',train=False,transform=torchvision.transforms.ToTensor(),download=False)
VGG16_True.add_module('add_linear',nn.Linear(1000,10))#将vgg16当作一个前置网络
VGG16_True.classifier.add_module('add_linear',nn.Linear(1000,10))
VGG16_True.classifier[6]=nn.Linear(4096,10)#直接修改线性层输出类别为10

保存与下载模型：

#保存方式1
    torch.save(vgg16,'vgg16_method1.pth')#保存网络模型和参数

#保存方式2 官方推荐
    torch.save(vgg16.state_dict(),'vgg16_method2.pth')#只将参数保存成字典

#保存方式1——>加载模型
    model=torch.load('vgg16_method1.pth')
    print(model)
#保存方式2，加载模型
    vgg16=torchvision.models.vgg16(pretrained=False)#加载网络架构
    vgg16.load_state_dict(torch.load('vgg16_method2.pth'))#把模型参数放入网络结构
    model=torch.load('vgg16_method2.pth')
    print(vgg16)

在使用方式一下载时，要注意确保load能访问到模型，尤其是在自己定义模型的情况下，要在开头将模型文件import进来

#保存自己定义的模型
class Tudui(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.conv1=Conv2d(3,64,kernel_size=3)
    def forward(self,x):
        x=self.conv1(x)
        return x
tudui=Tudui()
torch.save(tudui,'tudui_method.pth')

from model_save import *

#加载自己定义的模型
model=torch.load('tudui_method.pth')
print(model)