pytorch基础入门

pytorch官方手册：https://pytorch.org/docs/stable/index.html

1.基础的网络模型框架

import torch.nn as nn
import torch.nn.functional as F

class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        # 搭建自己的网络结构，其中不包括输入层与输出层
        self.covn1 = nn.Conv2d(1,10,5)
        self.covn2 = nn.Conv2d(20,20,5)

    def forward(self,input):   #前向传播
        x = F.relu(self.covn1(input))  # 将输入的数据先进行卷积操作，然后进行一个非线性变化
        return F.relu(self.covn2(x))

2.CIFAR10与DataLoader的使用

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

#获得数据 train=False：创建的是一个训练集   download=True：自己会下载数据集到本地文件
# torchvision.transforms.ToTensor()：将数据类型转化为tensor类型
dataset = torchvision.datasets.CIFAR10("./data", train=False,transform=torchvision.transforms.ToTensor(), download=True)
#加载器   shuffle：是否打乱顺序     drop_last：是否删除掉除最后不尽的样本
dataloader = DataLoader(dataset, batch_size=64, shuffle=False,drop_last=False)

class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()
        # 输入通道3，因为图片为彩色的，输出通道为6，卷积核是6个，卷积核的大小为3*3的，步长为1   ，不进行卷积填充
        self.conv1 = Conv2d(in_channels=3, out_channels=6, kernel_size=3, stride=1, padding=0)

    def forward(self,input):
        #将输入数据进行卷积操作
        x = self.conv1(input)
        return x

#初始化网络
tudui = Tudui()
#输出网络结构
# print(tudui)
for data in dataloader:
    imgs, targets = data
    output = tudui(imgs)
    print(imgs.shape)
    print(output.shape)

#./ 表示当前目录下的
#../ 表示当前文件的上一级目录所在的目录

3.TensorBoard

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

"""
writer = SummaryWriter("./logs")
for i in range(100):
    #tag 图像的标题   scalar_value  表示y轴的数据    global_step 表示x轴的数据
    writer.add_scalar("y=2x",2*i,i)
"""

#获得数据 train=False 创建的是一个训练集   download=True  自己会下载数据集到本地文件
dataset = torchvision.datasets.CIFAR10("./data",train=False,transform=torchvision.transforms.ToTensor(),download=True)
#加载器   shuffle 是否打乱顺序     drop_last  是否删除掉除最后不尽的样本
dataloader = DataLoader(dataset,batch_size=64,shuffle=False,drop_last=False)
writer = SummaryWriter("./logs")  # 实例化一个类，文件存放在logs文件夹下
step = 0
for data in dataloader:
    imgs, targets = data
    print(imgs.shape)
    # torch.Size([64,3,32,32])     imgs 为tensor类型
    writer.add_images("input", imgs, step)  # 将图片存入writer类中
    step = step + 1
writer.close()   # 最后关闭writer类

"""
tensorboard --logdir=logs    启动文件查看
每次运行之前如果图像有问题可删除logs文件夹下的文件再启动
指定查看的端口号 tensorboard --logdir=logs --port=6007
"""

4. Sequential的作用

定义一个有序的容器，神经网络将根据定义的层顺序执行，并且也有效简化代码

import torch
from torch import nn
from torch.nn import Sequential

"""
class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=32, kernel_size=5,padding=2)
        self.maxpool1 = nn.MaxPool2d(kernel_size=2)
        self.conv2 = nn.Conv2d(in_channels=32, out_channels=32, kernel_size=5, padding=2)
        self.maxpool2 = nn.MaxPool2d(kernel_size=2)
        self.conv3 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=5, padding=2)
        self.maxpool3 = nn.MaxPool2d(kernel_size=2)
        self.flatter = nn.Flatten()
        self.linear1 = nn.Linear(in_features=1024, out_features=64)
        self.linear2 = nn.Linear(in_features=64, out_features=10)
    def forward(self,input):
        x = self.conv1(input)
        x = self.maxpool1(x)
        x = self.conv2(x)
        x = self.maxpool2(x)
        x = self.conv3(x)
        x = self.maxpool3(x)
        x = self.flatter(x)
        x = self.linear1(x)
        x = self.linear2(x)
        return x
"""
class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()
        self.model = Sequential(
            nn.Conv2d(in_channels=3, out_channels=32, kernel_size=5, padding=2),
            nn.MaxPool2d(kernel_size=2),
            nn.Conv2d(in_channels=32, out_channels=32, kernel_size=5, padding=2),
            nn.MaxPool2d(kernel_size=2),
            nn.Conv2d(in_channels=32, out_channels=64, kernel_size=5, padding=2),
            nn.MaxPool2d(kernel_size=2),
            nn.Flatten(),
            nn.Linear(in_features=1024, out_features=64),
            nn.Linear(in_features=64, out_features=10),
        )
    def forward(self,input):
        x = self.model(input)
        return x

tudui = Tudui()
input = torch.ones((64,3,32,32))
output = tudui(input)
print(output)

5.损失函数loss

# 交叉熵损失函数
loss = nn.CrossEntropyLoss()
tudui = Tudui()
for data in dataloader:
    imgs,target = data
    output = tudui(imgs)  #output.shape = [64,10]    target.shape = [64]
    result_loss = loss(output,target)
    result_loss.backward()  #反向传播  （只是进行反向传播  并没有进行梯度的优化）

6.优化器 optimizer进行参数优化

#交叉熵损失函数
loss = nn.CrossEntropyLoss()
tudui = Tudui()
# 采用随机梯度下降算法
optim = torch.optim.SGD(tudui.parameters(), lr=0.01)  # 第一个参数为优化的对象   第二个为学习率
for _ in range(20):
    loss_sum = 0.0
    for data in dataloader:
        imgs, target = data
        output = tudui(imgs)
        result_loss = loss(output, target)
        loss_sum = loss_sum + result_loss
        
        optim.zero_grad()   # 将优化器中的梯度全部重置为0
        result_loss.backward()  # 反向传播
        optim.step()       # 进行梯度更新
        
    print(loss_sum)

7.模型的保存与加载

import torch
import torchvision
# pretrained=False 表示不使用vgg16训练imgesNet数据集训练好的参数，只是一个vgg16的网络架构
vgg16 = torchvision.models.vgg16(pretrained=False)

# 保存方式1
torch.save(vgg16, "./model/vgg16_1.pth")  # 不仅保存了网络模型的结构 也保存了内部的参数

# 加载方式1  加载模型
model1 = torch.load("./model/vgg16_1.pth")
print(model1)



# 保存方式2  （官方推荐的方式）
torch.save(vgg16.state_dict(),"./model/vgg16_2.pth")  #只保存vgg16里面的参数 保存在一个字典的形式

# 加载方式2  加载模型（此方式需要先获得一个网路架构，然后再将参数加载进去）
vgg16 = torchvision.models.vgg16(pretrained=False)
vgg16.load_state_dict(torch.load("./model/vgg16_2.pth"))   # 将参数加载入模型中
print(vgg16)

8.修改定义好的模型架构

拿vgg16网络模型架构为例

方法1

import torchvision
from torch import nn

vgg16_false = torchvision.models.vgg16(pretrained=False) 

#在原有的vgg16模型结构中添加一层网络结构    add_linear1：新加的网络层的名字
vgg16_false.add_module("add_linear1", nn.Linear(in_features=1000, out_features=10))

运行结果：
······

in_features 为上层输出 out_features 为输出 bias=True表示需要一个偏置变量

方法2

加入到名为classifier层的网络结构内部
vgg16_false.classifier.add_module("add_linear2", nn.Linear(in_features=1000, out_features=10))

输出结果：

修改vgg16网络架构的参数

# 修改的是classifier[name]的第六层网络的参数
vgg16_false.classifier[6] = nn.Linear(in_features=1000, out_features=9) 

输出结果：

9.完整的训练步骤

from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

from  model import *
from torch import nn
import torch
import torchvision

# 加载数据集
train_data = torchvision.datasets.CIFAR10("../data", train=True, transform=torchvision.transforms.ToTensor(), download=True)
test_data = torchvision.datasets.CIFAR10("../data", train=False, transform=torchvision.transforms.ToTensor(), download=True)

# 使用dataloader加载数据
train = DataLoader(train_data, batch_size=64)
test = DataLoader(test_data, batch_size=64)

# 初始化模型
tudui = Tudui()
loss_function = nn.CrossEntropyLoss()  # 损失函数

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

# tensorboard
writer = SummaryWriter("./logs")

epochs = 10
train_step = 0
test_step = 0

for i in range(epochs):
    print("第{}轮训练开始".format(i+1))

    tudui.train()  # 把网络设置为训练状态
    for data in train:
        imgs, targets = data
        output = tudui(imgs)
        loss = loss_function(output, targets)

        # 优化器优化模型
        optim.zero_grad()
        loss.backward()
        optim.step()

        # 写入tensorboard
        train_step = train_step + 1
        if train_step %100 == 0:
            print("训练{}次，loss为{}".format(train_step, loss.item()))
            writer.add_scalar("train", loss.item(), train_step)

    # 进行模型的测试
    tudui.eval()  # 把网络设置为测试状态
    total_test_loss = 0
    total_accuracy = 0
    with torch.no_grad():   # 使梯度不再发生变化
        for data in test:
            imgs, targets = data
            output = tudui(imgs)
            loss = loss_function(output, targets)
            total_test_loss = total_test_loss + loss.item()
            # argmax(axis=1) 跨列找最大值 并返回下标
            accuracy = (output.argmax(axis=1) == targets).sum()   # 预测正确的个数和
            total_accuracy = total_accuracy + accuracy

        print("整体的正确率为{}".format(total_accuracy/len(test_data)))
        print("整体测试集上的loss为{}".format(total_test_loss))
        writer.add_scalar("test", total_test_loss, test_step)
        test_step = test_step + 1

    # 进行每epochs参数保存
    torch.save(tudui.state_dict(), "./model/tudui_{}.pth".format(i))
    print("tudui_{}.pth模型已保存".format(i))
writer.close()

10. 使用训练好的参数进行验证

import torch
from PIL import Image
from torch import nn

class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()
        self.model = nn.Sequential(
            nn.Conv2d(in_channels=3, out_channels=32, kernel_size=5, padding=2),
            nn.MaxPool2d(kernel_size=2),
            nn.Conv2d(in_channels=32, out_channels=32, kernel_size=5, padding=2),
            nn.MaxPool2d(kernel_size=2),
            nn.Conv2d(in_channels=32, out_channels=64, kernel_size=5, padding=2),
            nn.MaxPool2d(kernel_size=2),
            nn.Flatten(),
            nn.Linear(in_features=1024, out_features=64),
            nn.Linear(in_features=64, out_features=10)
        )
    def forward(self, input):
        x = self.model(input)
        return x

tudui = Tudui()

image_path = "imgs/bird.png"
img = Image.open(image_path)

# 将图片转换为32*32的,然后转化为tensor类型
Compose函数是依次执行列表中操作并返回
transform = torchvision.transforms.Compose([torchvision.transforms.Resize((32,32)),
                                            torchvision.transforms.ToTensor()])
image = transform(img)
# 将图片转化为Tensor型
image = torch.reshape(image, (1, 3 ,32, 32))
# print(image.shape)

# 加载训练好的模型  然后告诉程序用gpu训练好的数据在cpu上运行
tudui.load_state_dict(torch.load("./model/tudui_29.pth", map_location=torch.device("cpu")))
print(tudui)
tudui.eval()
with torch.no_grad():
    output = tudui(image)
target = output.argmax(axis=1)
print(target)

11.使用gpu进行训练模型

方法1

"""
调用gpu要用电脑显卡对应的版本的cuda
1.网络模型  tudui.cuda()
2.数据（输入，标注） imgs.cuda()   target.cuda()
3.损失函数  loss.cuda()

为提高代码的健壮性，可以加上判断
if torch.cuda.is_available():   //如果显卡可用
    tudui.cuda()
    imgs.cuda
    target.cuda()
    loss.cuda()

可以使用Google colab实验室环境进行跑实验
"""
# 加载数据集

# 使用dataloader加载数据

# 创建模型

# 初始化模型

loss_function = nn.CrossEntropyLoss() 
loss.cuda()    # 新加

# tensorboard

tudui.train()
for data in train:
    imgs, targets = data
    imgs = imgs.cuda()   # 新加
    targets = targets.cuda()   # 新加

......

tudui.eval()  
with torch.no_grad():  
    for data in test:
        imgs, targets = data
        imgs = imgs.cuda()    # 新加
    	targets = targets.cuda()   # 新加

方法2

"""
常用的方法： 开头加入
device = torch.device("cuda")   # 表示使用gpu运行实验

调用gpu要用电脑显卡对应的版本的cuda
1.网络模型  tudui.to(device)
2.数据（输入，标注） imgs = imgs.to(device)     targets = targets.to(device)
3.损失函数  loss.to(device)

可以使用Google colab实验室环境进行跑实验
"""
# device = torch.device("cpu")  # 表示使用cpu运行实验
device = torch.device("cuda")   # 表示使用gpu运行实验
# 加载数据集

# 使用dataloader加载数据

# 创建模型

# 初始化模型
......
tudui.to(device)   # 新加

loss_function = nn.CrossEntropyLoss() 
loss_function.to(device)  # 新加

# tensorboard
......

    tudui.train() 
    for data in train:
        imgs, targets = data
        imgs = imgs.to(device)     # 新加
        targets = targets.to(device)  # 新加
.....

    tudui.eval()  
    with torch.no_grad(): 
        for data in test:
            imgs, targets = data
            imgs = imgs.to(device)     # 新加
        	targets = targets.to(device)  # 新加
......