Pytorch框架学习

Yenny�Marx?

已于 2022-05-06 17:35:12 修改

阅读量254

点赞数

文章标签： pytorch 人工智能 python

于 2022-04-23 01:41:04 首次发布

本文链接：https://blog.csdn.net/YennyMarx/article/details/124003831

版权

Pycharm、console、jupyter运行区别

介绍：
Pycharm：代码是以块为一个整体运行的话，python文件的块是所有行的代码。
Console：以每一行为块运行。
Jupyter：以任意行为块运行的。
优点：
Pycharm：通用，传播方便，适用于大型项目。
Console：显示每个变量的属性。
Jupyter：利于代码的阅读及修改。
缺点：
Pycharm：需要从头运行。
Console：不利于代码的阅读及修改。
Jupyter：环境需要配置。

Pytorch加载数据

Dataset
提供一种方式去获取数据及其label。其主要实现以下两个功能：
1.如何获取每一个数据及其label。
2.告诉我们总共有多少的数据。
Dataloader
为后面的网络提供不同的数据形式。

Dataset代码实战

from PIL import Image  #导入Image包
img_path="C:\\Users\\myn\\Pytorch_Learning\\datasets\\train\\ants\\0013035.jpg"   #图片路径
img=Image.open(img_path)  #读取图片，在变量中可以看到图片的属性
img.size  #获取图片的大小
img.show()
dir_path="datasets/train/ants"
import os   #python中的一个系统库
img_path_list=os.listdir(dir_path)  #文件名列表
img_path_list[0]

root_dir="datasets/train"
label_dir="ants"
path=os.path.join(root_dir,label_dir) #将路径拼接

Tensorboard的使用

Tensorborad是一种很好的可视化工具，可以绘制函数、显示图像等功能。
控制台连接Tensorboard：

(base)C:\Users\myn\Pytorch_Learning>tensorboard --logdir=logs --port=6007

# Tensorboard使用
from torch.utils.tensorboard import SummaryWriter       #导入Tensorboard相应的库
import numpy as np
from PIL import Image

writer = SummaryWriter("logs")
image_path="data/train/ants_image/0013035.jpg"
img_PIL = Image.open(image_path)
img_array = np.array(img_PIL)
writer.add_image("test", img_array, 1, dataformats='HWC')
print(img_array.shape)
for i in range(100):
   writer.add_scalar("y=2x", 2*i, i)

writer.close()

Transforms使用

from PIL import Image
from torchvision import transforms

# python的用法-》tensor数据类型
# 通过 transforms.ToTensor去看两个问题
# 1.transforms该如何使用（python）
# 2.Tensor数据类型与普通的数据类型有什么区别，也就是为什么需要转换为Tensor类型
# 绝对路径：C:\Users\myn\Pytorch_Learning\data\train\ants_image\0013035.jpg
# 相对路径：data/train/ants_image/0013035.jpg
img_path = "data/train/ants_image/0013035.jpg"
img = Image.open(img_path) # 打开是RGB模式
tensor_trans = transforms.ToTensor()
tensor_img = tensor_trans(img)

print(tensor_img)

在这里插入图片描述

常见的Transforms使用

代码实例：

from PIL import Image
from torch.utils.tensorboard import SummaryWriter
from torchvision import transforms

writer = SummaryWriter("logs")
img = Image.open("data/train/ants_image/0013035.jpg")

# ToTensor使用：将PIL或numpy格式的图片转换成tensor格式
trans_totensor = transforms.ToTensor()
img_tensor = trans_totensor(img)
writer.add_image("ToTensor", img_tensor)

#Normalize归一化使用：将每一个信道当中的输入进行归一化
print(img_tensor[0][0][0])
tran_norm = transforms.Normalize([0.5,0.5,0.5],[0.5,0.5,0.5])
img_norm = tran_norm(img_tensor)
print(img_norm[0][0][0])
writer.add_image("img_normalize",img_norm)

# Resize使用：重新调整尺寸
print(img.size)
trans_resize = transforms.Resize((512,512))
# img PIL -> resize -> img_resize PIL
img_resize = trans_resize(img)
# img_resize PIL -> totensor -> img_resize tensor
img_resize = trans_totensor(img_resize)
writer.add_image("resize", img_resize)

# Compose - resize - 2：组合各种transforms操作，输入为PIL
trans_resize_2 = transforms.Resize(512)
# PIL -> PIL -> tensor
trans_compose = transforms.Compose([trans_resize_2, trans_totensor]) # resize和totensor可交换，视频里是可能版本不同（视频里是resize的输入只能是PIL）
img_resize_2 = trans_compose(img)
writer.add_image("img_resize_2", img_resize_2)

# RandomCrop
trans_random = transforms.RandomCrop(500,1000)
trans_compose_2 = transforms.Compose([trans_random,trans_totensor])
for i in range(10):
    img_crop = trans_compose_2(img)
    writer.add_image("img_cropHW", img_crop, i) # step(也就是i)作用：可以通过tensorboard滑动滑块，方便看到相同图像文件名下的不同子图。
writer.close()

注意：
1.关注输入和输出类型
2.多看官方文档
3.关注方法需要什么参数（特别是没有默认值的时候）
不知道返回值的时候：
1.print
2.print(type())
3.debug

torchvision使用

import torchvision
from torch.utils.tensorboard import SummaryWriter

dataset_transform = torchvision.transforms.Compose([
    torchvision.transforms.ToTensor()
])

train_set = torchvision.datasets.CIFAR10(root="./datasets", train=True, transform=dataset_transform, download=True)
test_set = torchvision.datasets.CIFAR10(root="./datasets", train=False, transform=dataset_transform, download=True)

'''
print(test_set[0])
print(test_set.classes)

img, target = test_set[0]
print(img)
print(target)
print(test_set.classes[target])
img.show()
'''

writer = SummaryWriter("p10")
for i in range(10):
    img, target = test_set[i]
    writer.add_image("test_set", img, i)
writer.close()

DataLoader使用

DataLoader：数据打包

import torchvision
from  torch.utils.data import DataLoader
# 准备测试数据集
from torch.utils.tensorboard import SummaryWriter

test_data = torchvision.datasets.CIFAR10("./datasets", train=False, transform=torchvision.transforms.ToTensor())
# 加载测试集 batch_size表示64个一组打包,shuffle表示图片是否打乱（True表示打乱，False表示不打乱）drop_last表示当最后一组不足batch_size个数的时候，最后一组要不要省去（True表示要省去，False表示不用）
test_loader = DataLoader(dataset=test_data, batch_size=64, shuffle=True, num_workers=0, drop_last=False)

# 测试数据集中的第一张图片及target
img, target = test_data[0]
print(img.shape)
print(target)
step =0
writer = SummaryWriter("dataloader")
for data in test_loader:
    imgs, targets = data
    print(imgs.shape)
    print(targets)
    writer.add_images("test_data_drop_last", imgs, step)
    step = step + 1
writer.close()

神经网络nn.module使用

import torch
from torch import nn


class Tudui(nn.module):
    def __init__(self):
        super().__init__()

    def forward(self,input):
        output = input + 1
        return output


tudui = Tudui()
x = torch.tensor(1.0)
output = tudui(x)
print(output)

卷积操作(conv2函数)

import torch
import torch.nn.functional as F
input = torch.tensor([[1,2,0,3,1],
                      [0,1,2,3,1],
                      [1,2,1,0,0],
                      [5,2,3,1,1],
                      [2,1,0,1,1]])

kernel = torch.tensor([[1,2,1],
                      [0,1,0],
                      [2,1,0]])
input = torch.reshape(input,[1,1,5,5])
kernel = torch.reshape(kernel,(1,1,3,3))
print(input.shape)
print(kernel.shape)

output = F.conv2d(input,kernel,stride=1)
print(output)
output2 = F.conv2d(input,kernel,stride=2)
print(output2)

# padding表示扩展多宽，卷积后的尺寸为（a+2d-b）/c+1,其中a为原图尺寸，b为卷积核尺寸，c为步幅stride，d为填充padding
output3 = F.conv2d(input,kernel,stride=1,padding=0)
print(output3)

神经网络卷积层

in_channels：输入图像的的通道数（彩色图像一般三个通道）
out_channels：输出图像的通道数
kernel_size：卷积核大小
stride：步幅
padding：边缘填充
padding_mode：边缘填充的方式，一般情况下选择zeros
dilation：空洞卷积
bias：偏置，一般设置为true

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

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

class Tudui(nn.Module):
    def __init__(self):
        super(Tudui,self).__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

writer = SummaryWriter("logs")
tudui = Tudui()
step = 0
for data in dataloader:
    imgs, target = data
    output = tudui(imgs)
    print(imgs.shape)  # size:[64,3,32,32]
    writer.add_images("input", imgs, step)
    print(output.shape) # size:[64,6,30,30]

    output = torch.reshape(output,(-1, 3, 30, 30))
    writer.add_images("output",output,step)
    step = step + 1

writer.close()

最大池化

作用：保留特征，减少数据量，提高网络训练速度。
参数：
kernel_size：核大小
stride：步幅
padding：填充
dilation：空洞
ceil_mode：cell模式(向上取整，不足的话就保留)，Floor模式(向下取整，不足的话就不算)
在这里插入图片描述

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

dataset = torchvision.datasets.CIFAR10("./datasets", train=False, download=True, transform=torchvision.transforms.ToTensor())
dataloader = DataLoader(dataset,batch_size=64)
input = torch.tensor([[1,2,0,3,1],
                     [0,1,2,3,1],
                     [1,2,1,0,0],
                     [5,2,3,1,1],
                     [2,1,0,1,1]], dtype=torch.float32)

input = torch.reshape(input,(-1,1,5,5))
print(input.shape)

class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()
        self.maxpool1 = MaxPool2d(kernel_size=3, ceil_mode=True)

    def forward(self, input):
        output = self.maxpool1(input)
        return output

tudui = Tudui()

writer = SummaryWriter("logs")
step = 0
for data in dataloader:
    imgs, target = data
    writer.add_images("input",imgs,step)
    output = tudui(imgs)
    writer.add_images("output",output,step)

    step = step+1
writer.close()

在这里插入图片描述

非线性激活

ReLU：
在这里插入图片描述
Sigmoid：

import torch
import torchvision
from torch import nn
from torch.nn import ReLU, Sigmoid
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10("./datasets", train=False, download=True, transform=torchvision.transforms.ToTensor())
dataloader = DataLoader(dataset,batch_size=64)
input = torch.tensor([[1, -0.5],
                      [-1, 3]])

input = torch.reshape(input,(-1,1,2,2))
print(input)
class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()
        self.relu1 = ReLU(inplace=False) # inplace表示是否进行替换，True表示替换
        self.sigmoid1 = Sigmoid()

    def forward(self,input):
        output = self.sigmoid1(input)
        return output

tudui = Tudui()
writer = SummaryWriter("logs")
step = 0
for data in dataloader:
    imgs, target = data
    writer.add_images("input",imgs,step)
    output = tudui(imgs)
    writer.add_images("output",output,step)

    step = step+1
writer.close()

线性层及其他层介绍

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

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

dataloader = DataLoader(dataset, batch_size=64)
class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()
        self.linear1 = Linear(196688, 10)

    def forward(self,input):
        output = self.linear1(input)
        return output

tudui = Tudui()

for data in dataloader:
    imgs, target = data
    print(imgs.shape)
    # output = torch.reshape(imgs,(1,1,1,-1))
    output = torch.flatten(imgs)  # 展成一行和reshape差不多
    print(output.shape)
    output = tudui(output)
    print(output.shape)

神经网络Sequential使用

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


class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__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.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.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.model1(x)
        return x

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

writer = SummaryWriter("logs")
writer.add_graph(tudui, input)
writer.close()

损失函数与反向传播

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("./datasets",train=False,transform=torchvision.transforms.ToTensor())

dataloader = DataLoader(dataset, batch_size=1)

class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__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.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.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.model1(x)
        return x

loss = nn.CrossEntropyLoss()
tudui = Tudui()
for data in dataloader:
    imgs, targets = data
    outputs = tudui(imgs)
    result_loss = loss(outputs, targets)
    result_loss.backward()
    print(result_loss )

优化器

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("./datasets",train=False,transform=torchvision.transforms.ToTensor())

dataloader = DataLoader(dataset, batch_size=1)

class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__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.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.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.model1(x)
        return x

loss = nn.CrossEntropyLoss()
tudui = Tudui()
optim = torch.optim.SGD(tudui.parameters(), lr=0.01)
for epoch in range(20):
    result_loss = 0
    for data in dataloader:
        imgs, targets = data
        outputs = tudui(imgs)
        result_loss = loss(outputs, targets)
        optim.zero_grad()
        result_loss.backward()
        optim.step()
    print(result_loss)

现有模型修改和使用

import torchvision
from torch import nn

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

vgg16_false = torchvision.models.vgg16(pretrained=False)
vgg16_true = torchvision.models.vgg16(pretrained=True)  # True表示采用预训练的模型参数

vgg16_true.add_module('add_linear', nn.Linear(1000, 10))
print(vgg16_true)
vgg16_true.classifier.add_module('add_linear', nn.Linear(1000, 10))

模型保存与加载

import torch
import torchvision
vgg16 = torchvision.models.vgg16(pretrained=False)
# 保存方式1，模型结构+模型参数
torch.save(vgg16, "vgg16_method1.pth")
# 保存方式2，模型参数（官方推荐）
torch.save(vgg16.state_dict(), "vgg16_method2.pth")

import torch
import torchvision

# 方式1加载
model = torch.load("vgg16_method1.pth")

# 方式2加载
vgg16 = torchvision.models.vgg16(pretrained=False)
vgg16.load_state_dict(torch.load("vgg16_method2.pth"))

print(vgg16)

# 陷阱1:用方式1的时候，要把网络模型重新复制一份，或者把网络模型发在一个新的文件里面，引入即可
model = torch.load('tudui_method1.pth')

模型训练（cuda）

import torchvision

# 准备数据集
from torch import nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

from P27_model import *
import time

device = torch.device("cuda")
train_data = torchvision.datasets.CIFAR10("./datasets", train=True, transform=torchvision.transforms.ToTensor(), download=True)

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

# length 长度
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)

class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, 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(1024, 64),
            nn.Linear(64, 10)
        )

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

# 创建网络模型
tudui = Tudui()
# 网络模型、数据、损失函数可以加cuda
if torch.cuda.is_available():
    tudui = tudui.cuda()

# 损失函数
loss_fn = nn.CrossEntropyLoss()
# tudui = tudui.to(device)
if torch.cuda.is_available():
    loss_fn = loss_fn.cuda()
# 优化器
learning_rate = 0.01
optimizer = torch.optim.SGD(tudui.parameters(), lr = learning_rate)

# 设置训练网络的一些参数
# 记录测试的次数
total_train_step = 0
# 记录测试的次数
total_test_step = 0
# 训练的轮数
epoch = 10
writer = SummaryWriter("logs")
start_time = time.time()
for i in range(epoch):
    # 训练步骤开始
    tudui.train()
    for data in train_dataloader:
        imgs, targets =data
        if torch.cuda.is_available():
            imgs = imgs.cuda()
            targets = targets.cuda()
        outputs = tudui(imgs)
        loss = loss_fn(outputs, targets)

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

        total_train_step = total_train_step + 1
        if total_train_step % 100 == 0:
            end_time = time.time()
            print(end_time-start_time)
            print("训练次数：{},loss：{}".format(total_train_step, loss))
            writer.add_scalar("train_loss", loss.item(), total_train_step)

    # 测试步骤开始
    tudui.eval()
    total_test_loss = 0
    total_accuracy = 0
    with torch.no_grad():
        for data in test_dataloader:
            imgs. targets = data
            if torch.cuda.is_available():
                imgs = imgs.cuda()
                targets = targets.cuda()
            outputs = tudui(imgs)
            loss = loss_fn(outputs, targets)
            total_test_loss = total_test_loss + loss.item()
            accuracy = (outputs.argmax(1) == targets).sum() # outputs.argmax(1)：横向比较
            total_accuracy = total_accuracy + accuracy
        print("整体测试集上的loss：{}".format(total_test_loss))
        print("整体测试集上的正确率：{}".format(total_accuracy/test_data_size))
        writer.add_scalar("test_loss", total_test_loss, total_test_step)
        writer.add_scalar("test_accuracy", total_accuracy/test_data_size, total_test_step)
        total_test_step = total_test_step + 1

        torch.save(tudui, "tudui_{}.pth".format(i))
        print("模型已保存")
writer.close()