程序员经验分享-hwhale

pytorch 自学笔记@_@

2023-11-16

课程

dataset 类

from torch.utils.data import Dataset
from PIL import Image
import os


class MyData(Dataset):
    def __init__(self,root_dir,label_dir):
        self.root_dir=root_dir
        self.label_dir=label_dir
        self.path=os.path.join(self.root_dir,self.label_dir)
        self.img_path=os.listdir(self.path)

    def __getitem__(self, idx):
        img_name=self.img_path[idx]
        img_item_path=os.path.join(self.root_dir,self.label_dir,img_name)
        img=Image.open(img_item_path)
        label=self.label_dir
        return img,label

    def __len__(self):
        return len(self.img_path)


root_dir="hymenoptera_data/train"

ants_label_dir="ants"
ant_dataset= MyData(root_dir,ants_label_dir)

bees_label_dir="bees"
bee_dataset=MyData(root_dir,bees_label_dir)

train_dataset=ant_dataset+bee_dataset

在这里插入图片描述

生成txt 文件

在这里插入图片描述

TensorBoard

writer.add_scalar


from torch.utils.tensorboard import SummaryWriter
writer = SummaryWriter("log")
# writer.add_image()
for i in range(100):

    writer.add_scalar("y=x",i,i)

writer.close()


(mypytorch) D:\pytorch_project\pythonProject>tensorboard --logdir=log
TensorFlow installation not found - running with reduced feature set.
Serving TensorBoard on localhost; to expose to the network, use a proxy or pass --bind_all
TensorBoard 2.8.0 at http://localhost:6006/ (Press CTRL+C to quit)

指定端口 防止撞车
在这里插入图片描述

img->array
在这里插入图片描述

add_image

在这里插入图片描述
在这里插入图片描述


from torch.utils.tensorboard import SummaryWriter
from PIL import  Image
import numpy as np


writer = SummaryWriter("log")
img_path="data/train/bees_image/39747887_42df2855ee.jpg"
img_PIL=Image.open(img_path)
img_array=np.array(img_PIL)
print(type(img_array))
print(img_array.shape)

# <class 'numpy.ndarray'>
# (512, 768, 3)

writer.add_image("test",img_array,2,dataformats='HWC')

# for i in range(100):
#
#     writer.add_scalar("y=3x",3*i,i)

writer.close()

在这里插入图片描述


from torch.utils.tensorboard import SummaryWriter
from PIL import  Image
import numpy as np


writer = SummaryWriter("log")
img_path="data/train/bees_image/85112639_6e860b0469.jpg"
img_PIL=Image.open(img_path)
img_array=np.array(img_PIL)
print(type(img_array))
print(img_array.shape)

# <class 'numpy.ndarray'>
# (512, 768, 3)

writer.add_image("train",img_array,2,dataformats='HWC')

# for i in range(100):
#
#     writer.add_scalar("y=3x",3*i,i)

writer.close()

在这里插入图片描述

Transforms

from PIL import Image
from torchvision import transforms


img_path="data/train/ants_image/7759525_1363d24e88.jpg"
img=Image.open(img_path)
print(img)

tensor_trans=transforms.ToTensor()
tensor_img=tensor_trans(img)

print(tensor_img)

在这里插入图片描述
在这里插入图片描述

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


img_path="data/train/ants_image/7759525_1363d24e88.jpg"
img=Image.open(img_path)
print(img)

writer=SummaryWriter("logs")


tensor_trans=transforms.ToTensor()
tensor_img=tensor_trans(img)

print(tensor_img)

writer.add_image("Tensor_img",tensor_img)

writer.close()

torchvision 中数据集的使用

ctrl+p 了解参数

import torchvision
train_set=torchvision.datasets.CIFAR10(root="./dataset",train=True,download=True)
test_set=torchvision.datasets.CIFAR10(root="./dataset",train=False,download=True)
print(train_set[0])
print(train_set.classes)
img,target=train_set[0]
img.show()
print(train_set.classes[target])

在这里插入图片描述

 
import torchvision
from torch.utils.tensorboard import SummaryWriter

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

train_set=torchvision.datasets.CIFAR10(root="./dataset",train=True,transform=dataset_transform,download=True)
test_set=torchvision.datasets.CIFAR10(root="./dataset",train=False,transform=dataset_transform,download=True)
# print(train_set[0])
# print(train_set.classes)
# img,target=train_set[0]
# img.show()
# print(train_set.classes[target])
print(test_set[0])

writer=SummaryWriter("dataset_trans")
for i in range(10):
    img,target=train_set[i]
    writer.add_image("train",img,i)

writer.close()

在这里插入图片描述

DataLoader



import torchvision

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

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

test_loader=DataLoader(dataset=test_dataset,batch_size=4,shuffle=True,num_workers=0,drop_last=False)

#测试数据集中的第一张图片
img,target=test_dataset[0]

print(img.shape)
print(target)


for data in test_loader:
    imgs,targets=data
    print(imgs.shape)
    print(targets.shape)
    print(targets)
# torch.Size([4, 3, 32, 32])
# torch.Size([4])
# tensor([7, 4, 0, 2])

test_loader 对img 和 target 进行分别打包处理

import torchvision

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

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

test_loader=DataLoader(dataset=test_dataset,batch_size=64,shuffle=True,num_workers=0,drop_last=False)

#测试数据集中的第一张图片
img,target=test_dataset[0]

print(img.shape)
print(target)

writer=SummaryWriter("dataloader")
step=0
for data in test_loader:
    imgs,targets=data
    writer.add_images("test",imgs,step)
    step=step+1
writer.close()

在这里插入图片描述

测试shuffle为true时 两次取的样本不一样



import torchvision

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

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

test_loader=DataLoader(dataset=test_dataset,batch_size=64,shuffle=True,num_workers=0,drop_last=False)

#测试数据集中的第一张图片
img,target=test_dataset[0]

print(img.shape)
print(target)

writer=SummaryWriter("dataloader_shuffle")

for epoch in range(2):
    step = 0
    for data in test_loader:
        imgs,targets=data
        writer.add_images("epoch{}".format(epoch),imgs,step)
        step=step+1

writer.close()

在这里插入图片描述

神经网络的基本骨架 nn.Module

import torch
from torch import nn


class Model(nn.Module):
    def __init__(self) -> None:
        super().__init__()

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

model=Model()
x=torch.tensor(20.4)
y=model(x)
print(y)

卷积conv – torch.nn.functional


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]])
print(input.shape)
print(kernel.shape)

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)

output3=F.conv2d(input,kernel,stride=1,padding=1)

print(output3)






D:\anaconda\envs\mypytorch\python.exe D:/pytorch_project/pythonProject/nn_conv.py
torch.Size([5, 5])
torch.Size([3, 3])
torch.Size([1, 1, 5, 5])
torch.Size([1, 1, 3, 3])
tensor([[[[10, 12, 12],
          [18, 16, 16],
          [13,  9,  3]]]])
tensor([[[[10, 12],
          [13,  3]]]])
tensor([[[[ 1,  3,  4, 10,  8],
          [ 5, 10, 12, 12,  6],
          [ 7, 18, 16, 16,  8],
          [11, 13,  9,  3,  4],
          [14, 13,  9,  7,  4]]]])

Process finished with exit code 0

卷积 Conv2d – torch.nn

在这里插入图片描述

# -*- coding: utf-8 -*-
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(root="./dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)
dataloader=DataLoader(dataset,batch_size=64)

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

model=Model()
writer =SummaryWriter("conv2d")
step=0
for data  in dataloader:
    imgs,targets=data
    output = model(imgs)
    print(imgs.shape)
    print(output.shape)
    writer.add_images("in",imgs,step)

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

    step=step+1

writer.close()

output=torch.reshape(output,(-1,3,30,30))只有三通道才能够正常显示 所以要进行reshape 将通道数 6->3

在这里插入图片描述
在这里插入图片描述

最大池化层

在这里插入图片描述


# @File : nn_maxpool.py
import torch
from torch import nn
from torch.nn import MaxPool2d

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 Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.maxpool1=MaxPool2d(kernel_size=3,ceil_mode=True)

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

model=Model()
output=model(input)
print(output)




torch.Size([1, 1, 5, 5])
tensor([[[[2., 3.],
          [5., 1.]]]])

在这里插入图片描述

非线性激活 RELU Sigmoid

inplace

在这里插入图片描述

import torch
from torch import nn
from torch.nn import ReLU

input=torch.tensor([[1,-0.5],
                    [-1,3]])
input=torch.reshape(input,(-1,1,2,2))

print(input.shape)

class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.relu1=ReLU()#inplace 默认为false

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


model=Model()

output=model(input)
print(output)

D:\anaconda\envs\mypytorch\python.exe D:/pytorch_project/pythonProject/nn_relu.py
torch.Size([1, 1, 2, 2])
tensor([[[[1., 0.],
          [0., 3.]]]])


# -*- coding: utf-8 -*-
# @File : nn_relu.py
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("./dataset",train=False,download=True,transform=torchvision.transforms.ToTensor())
dataloader=DataLoader(dataset,batch_size=64)

class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        #self.relu1=ReLU()#inplace 默认为false
        self.sigmoid1=Sigmoid()

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


model=Model()

writer=SummaryWriter("logs_sig")

step =0
for data in dataloader:
    imgs,targets=data
    writer.add_images("input",imgs,step)
    output=model(imgs)
    writer.add_images("output",output,step)
    step=step+1

writer.close()

在这里插入图片描述
在这里插入图片描述

线性层和其他层

Normalization Layers 正则化层
Recurrent Layers 循环层 【文字识别】
Linear Layers 线性层
Dropout Layers 随机失活 防止过拟合


# @File : nn_liner.py
import torch
import torchvision
from torch import nn
from torch.nn import Linear
from torch.utils.data import DataLoader

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

class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.linear1=Linear(196608,10)

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

model=Model()
for data in dataloader:
    imgs,targets=data
    print(imgs.shape)
    output=torch.reshape(imgs,(1,1,1,-1))
    print(output.shape)
    output=model(output)
    print(output.shape)
# torch.Size([64, 3, 32, 32])
# torch.Size([1, 1, 1, 196608])
# model返回torch.Size([1, 1, 1, 10])

或者使用torch.flatten
在这里插入图片描述

Sequential

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

# @File : nn_seq.py
import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear


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

    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)
        return x

model =Model()
print(model)
input=torch.ones((64,3,32,32))
output=model(input)
print(output.shape)

D:\anaconda\envs\mypytorch\python.exe D:/pytorch_project/pythonProject/nn_seq.py
Model(
  (conv1): Conv2d(3, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
  (maxpool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(32, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
  (maxpool2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv3): Conv2d(32, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
  (maxpool3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (flatten): Flatten(start_dim=1, end_dim=-1)
  (linear1): Linear(in_features=1024, out_features=64, bias=True)
  (linear2): Linear(in_features=64, out_features=10, bias=True)
)
torch.Size([64, 10])

Process finished with exit code 0

用sequential 简化

# @File : nn_seq.py
import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
from torch.utils.tensorboard import SummaryWriter


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

model =Model()
print(model)
input=torch.ones((64,3,32,32))
output=model(input)
print(output.shape)

writer=SummaryWriter("logs_seq")
writer.add_graph(model,input)
writer.close()

在这里插入图片描述

损失函数与反向传播

在这里插入图片描述
Loss

  1. 计算实际输出和目标之间的差距
  2. 为更新输出提供了依据 – 反向传播 grad

L1Loss

# @File : nn_loss.py
import torch
from torch.nn import L1Loss

inputs = torch.tensor([1,2,5],dtype=torch.float32)
targets = torch.tensor([1,2,3],dtype=torch.float32)

inputs=torch.reshape(inputs,(1,1,1,3))
targets=torch.reshape(targets,(1,1,1,3))

loss=L1Loss()

res=loss(inputs,targets)
print(res)

#tensor(0.6667)


# @File : nn_loss.py
import torch
from torch.nn import L1Loss

inputs = torch.tensor([1,2,5],dtype=torch.float32)
targets = torch.tensor([1,2,3],dtype=torch.float32)



loss=L1Loss(reduction='sum')

res=loss(inputs,targets)
print(res)

tensor(2.)

MSELoss

# @File : nn_loss.py
import torch
from torch.nn import L1Loss, MSELoss

inputs = torch.tensor([1,2,5],dtype=torch.float32)
targets = torch.tensor([1,2,3],dtype=torch.float32)



loss=L1Loss()

res=loss(inputs,targets)
print(res)

loss_mse=MSELoss()
res_mse=loss_mse(inputs,targets)
print(res_mse)

tensor(0.6667)
tensor(1.3333)

CrossEntropyLoss 交叉熵

在这里插入图片描述
在这里插入图片描述

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(root="./dataset",train=False,transform=torchvision.transforms.ToTensor()
                                     ,download=True)
dataloader=DataLoader(dataset,batch_size=64)

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

model =Model()
loss_cross=nn.CrossEntropyLoss()
for data in dataloader:
    imgs,targets=data
    output=model(imgs)
    print(output.shape)
    loss=loss_cross(output,targets)

    print(loss)
    loss.backward()
    print("ok")

优化器

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(root="./dataset",train=False,transform=torchvision.transforms.ToTensor()
                                     ,download=True)
dataloader=DataLoader(dataset,batch_size=64)

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

model =Model()
loss_cross=nn.CrossEntropyLoss()
optim=torch.optim.SGD(model.parameters(),lr=0.01)

for epoch in range(20):
    run_loss=0
    for data in dataloader:
        imgs,targets=data
        output=model(imgs)
        loss=loss_cross(output,targets)
        optim.zero_grad()
        loss.backward()
        optim.step()
        run_loss=run_loss+loss
    print(run_loss)

在这里插入图片描述

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

方法一 相当于增加模块

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

Files already downloaded and verified
VGG(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU(inplace=True)
    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU(inplace=True)
    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (6): ReLU(inplace=True)
    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (8): ReLU(inplace=True)
    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace=True)
    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (13): ReLU(inplace=True)
    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (15): ReLU(inplace=True)
    (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (18): ReLU(inplace=True)
    (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (20): ReLU(inplace=True)
    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (22): ReLU(inplace=True)
    (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (25): ReLU(inplace=True)
    (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (27): ReLU(inplace=True)
    (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (29): ReLU(inplace=True)
    (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))
  (classifier): Sequential(
    (0): Linear(in_features=25088, out_features=4096, bias=True)
    (1): ReLU(inplace=True)
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=4096, out_features=4096, bias=True)
    (4): ReLU(inplace=True)
    (5): Dropout(p=0.5, inplace=False)
    (6): Linear(in_features=4096, out_features=1000, bias=True)
  )
  (add_linear): Linear(in_features=1000, out_features=10, bias=True)
)

方法二 在模块内部添加

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

在这里插入图片描述
方法三 修改

#方法三 修改最后一层
vgg16_true.classifier[6]=nn.Linear(4096,10)

在这里插入图片描述修改方法 汇总
在这里插入图片描述

模型的保存与读取

import torchvision
import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
# from nn_loss_network import *

vgg16_true=torchvision.models.vgg16(pretrained=True)
# 方式一
torch.save(vgg16_true,"vgg_model.pth") #模型结构 + 参数
#对应方式一 加载模型
model=torch.load("vgg_model.pth")
# print(model)

# 方式二
torch.save(vgg16_true.state_dict(),"vgg_model2.pth")#只有模型参数 字典形式
model2=torch.load("vgg_model2.pth")
# print(model2)#没有网络模型
vgg=torchvision.models.vgg16(pretrained=True)#将参数加载到模型中去
vgg.load_state_dict(model2)
# print(vgg)

#陷阱一 自己创建的网络无法直接显示 需要将网络的定义引入才可以显示
#1 from nn_loss_network import * 要么引入相应文件
#2 要么将网络的结构写入代码 如下所示

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

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

完整模型训练套路

model_tp.py 存储网络

#存储网络
import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential


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


if __name__ == '__main__':
    model=Model()
    input=torch.ones((64,3,32,32))
    output=model(input)
    print(output.shape)

正确率计算 argmax
在这里插入图片描述

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

from model_tp import *


#准备数据集
train_dataset=torchvision.datasets.CIFAR10(root="./dataset",train=True,
                                           transform=torchvision.transforms.ToTensor(),download=True)
test_dataset=torchvision.datasets.CIFAR10(root="./dataset",train=False,
                                           transform=torchvision.transforms.ToTensor(),download=True)
train_dataset_size=len(train_dataset)
test_dataset_size=len(test_dataset)
print("训练数据集长度{}".format(train_dataset_size))
print("测试数据集长度{}".format(test_dataset_size))
# 训练数据集长度50000
# 测试数据集长度10000

#利用DataLoader进行加载数据集
train_dataloader=DataLoader(train_dataset,batch_size=64)
test_dataloader=DataLoader(test_dataset,batch_size=64)

#搭建神经网络 model_tp.py

#创建网络模型
model=Model()

#损失函数
loss_fn=nn.CrossEntropyLoss()

#优化器定义
learning_rate=1e-2
optimizer=torch.optim.SGD(model.parameters(),lr=learning_rate)

#设置训练网络的参数
#记录训练次数
total_train_step=0
#记录测试次数
total_test_step=0
#训练轮数
epoch=10

# 添加tensorboard
writer=SummaryWriter("log_train")

for i in range(epoch):
    print("=========第{}轮训练========".format(i+1))

    #训练步骤开始
    for data in train_dataloader:
        imgs,targets=data
        output=model(imgs)
        loss=loss_fn(output,targets)
        #优化器优化模型
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        total_train_step=total_train_step+1
        if(total_train_step%100==0):
            print("训练次数:{}，Loss:{}".format(total_train_step,loss.item()))
            writer.add_scalar("train_loss",loss.item(),total_train_step)
    #测试步骤
    total_test_loss=0
    total_accuracy=0
    with torch.no_grad():
        for data in test_dataloader:
            imgs,targets=data
            output=model(imgs)
            loss=loss_fn(output,targets)
            total_test_loss=total_test_loss+loss.item()
            accuracy=(output.argmax(1)==targets).sum()
            total_accuracy=total_accuracy+accuracy
    print("整体测试集上的Loss{}".format(total_test_loss))
    print("整体测试集上的Accuracy{}".format(total_accuracy/test_dataset_size))
    writer.add_scalar("test_loss",total_test_loss,total_test_step)
    writer.add_scalar("test_acc",total_accuracy/test_dataset_size,total_test_step)
    total_test_step=total_test_step+1
    torch.save(model,"model_{}.pth".format(i))
    print("模型已保存~")
writer.close()

在这里插入图片描述

在这里插入图片描述

train() 对于有特定层（Dropout,BatchNorm etc…）的网络有作用

在这里插入图片描述

eval() 对于有特定层的网络有作用

在这里插入图片描述

在这里插入图片描述

GPU训练

nvidia-smi 显示GPU信息

.cuda()

在这里插入图片描述

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

from model_tp import *
import time

#准备数据集
train_dataset=torchvision.datasets.CIFAR10(root="./dataset",train=True,
                                           transform=torchvision.transforms.ToTensor(),download=True)
test_dataset=torchvision.datasets.CIFAR10(root="./dataset",train=False,
                                           transform=torchvision.transforms.ToTensor(),download=True)
train_dataset_size=len(train_dataset)
test_dataset_size=len(test_dataset)
print("训练数据集长度{}".format(train_dataset_size))
print("测试数据集长度{}".format(test_dataset_size))
# 训练数据集长度50000
# 测试数据集长度10000

#利用DataLoader进行加载数据集
train_dataloader=DataLoader(train_dataset,batch_size=64)
test_dataloader=DataLoader(test_dataset,batch_size=64)

#搭建神经网络 model_tp.py

#创建网络模型
model=Model()
if torch.cuda.is_available():
    model=model.cuda()#@@
    print("cuda is available!")
#损失函数
loss_fn=nn.CrossEntropyLoss()
if torch.cuda.is_available():
    loss_fn = loss_fn.cuda() #@@
#优化器定义
learning_rate=1e-2
optimizer=torch.optim.SGD(model.parameters(),lr=learning_rate)

#设置训练网络的参数
#记录训练次数
total_train_step=0
#记录测试次数
total_test_step=0
#训练轮数
epoch=10

# 添加tensorboard
writer=SummaryWriter("log_train_gpu")

start_time=time.time()
for i in range(epoch):
    print("=========第{}轮训练========".format(i+1))

    #训练步骤开始
    for data in train_dataloader:
        imgs,targets=data
        if torch.cuda.is_available():
            imgs = imgs.cuda()#@@
            targets = targets.cuda()#@@

        output=model(imgs)
        loss=loss_fn(output,targets)
        #优化器优化模型
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        total_train_step=total_train_step+1
        if(total_train_step%100==0):
            print("训练次数:{}，Loss:{}".format(total_train_step,loss.item()))
            writer.add_scalar("train_loss",loss.item(),total_train_step)
    #测试步骤
    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()  # @@
            output=model(imgs)
            loss=loss_fn(output,targets)
            total_test_loss=total_test_loss+loss.item()
            accuracy=(output.argmax(1)==targets).sum()
            total_accuracy=total_accuracy+accuracy
    print("整体测试集上的Loss{}".format(total_test_loss))
    print("整体测试集上的Accuracy{}".format(total_accuracy/test_dataset_size))
    writer.add_scalar("test_loss",total_test_loss,total_test_step)
    writer.add_scalar("test_acc",total_accuracy/test_dataset_size,total_test_step)
    total_test_step=total_test_step+1
    torch.save(model,"model_{}.pth".format(i))
    print("模型已保存~")
writer.close()


model=model.cuda()

在这里插入图片描述在这里插入图片描述

.to(device)

在这里插入图片描述

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

from model_tp import *
import time
#定义训练的设备
device=torch.device("cuda")

#准备数据集
train_dataset=torchvision.datasets.CIFAR10(root="./dataset",train=True,
                                           transform=torchvision.transforms.ToTensor(),download=True)
test_dataset=torchvision.datasets.CIFAR10(root="./dataset",train=False,
                                           transform=torchvision.transforms.ToTensor(),download=True)
train_dataset_size=len(train_dataset)
test_dataset_size=len(test_dataset)
print("训练数据集长度{}".format(train_dataset_size))
print("测试数据集长度{}".format(test_dataset_size))
# 训练数据集长度50000
# 测试数据集长度10000

#利用DataLoader进行加载数据集
train_dataloader=DataLoader(train_dataset,batch_size=64)
test_dataloader=DataLoader(test_dataset,batch_size=64)

#搭建神经网络 model_tp.py

#创建网络模型
model=Model()
model=model.to(device)

#损失函数
loss_fn=nn.CrossEntropyLoss()
loss_fn = loss_fn.to(device)
#优化器定义
learning_rate=1e-2
optimizer=torch.optim.SGD(model.parameters(),lr=learning_rate)

#设置训练网络的参数
#记录训练次数
total_train_step=0
#记录测试次数
total_test_step=0
#训练轮数
epoch=10

# 添加tensorboard
writer=SummaryWriter("log_train_gpu_2")

start_time=time.time()
for i in range(epoch):
    print("=========第{}轮训练========".format(i+1))

    #训练步骤开始
    for data in train_dataloader:
        imgs,targets=data
        imgs = imgs.to(device)#@@
        targets = targets.to(device)#@@

        output=model(imgs)
        loss=loss_fn(output,targets)
        #优化器优化模型
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        total_train_step=total_train_step+1
        if(total_train_step%100==0):
            print("训练次数:{}，Loss:{}".format(total_train_step,loss.item()))
            writer.add_scalar("train_loss",loss.item(),total_train_step)
    #测试步骤
    total_test_loss=0
    total_accuracy=0
    with torch.no_grad():
        for data in test_dataloader:
            imgs,targets=data
            imgs = imgs.to(device)  # @@
            targets = targets.to(device)  # @@
            output=model(imgs)
            loss=loss_fn(output,targets)
            total_test_loss=total_test_loss+loss.item()
            accuracy=(output.argmax(1)==targets).sum()
            total_accuracy=total_accuracy+accuracy
    print("整体测试集上的Loss{}".format(total_test_loss))
    print("整体测试集上的Accuracy{}".format(total_accuracy/test_dataset_size))
    writer.add_scalar("test_loss",total_test_loss,total_test_step)
    writer.add_scalar("test_acc",total_accuracy/test_dataset_size,total_test_step)
    total_test_step=total_test_step+1
    # torch.save(model,"model_{}.pth".format(i))
    # print("模型已保存~")
writer.close()


model=model.cuda()

device 选择
在这里插入图片描述

模型验证套路

test.py

import torchvision
from PIL import Image
from torchvision.transforms.functional import to_pil_image

from model_tp import *
from torchvision.transforms import ToPILImage
img_path="./img/feiji.png"
image=Image.open(img_path)
print(image)
# image.show()
# <PIL.PngImagePlugin.PngImageFile image mode=RGBA size=250x292 at 0x1F9B411D4F0>
image=image.convert('RGB')
print(image)
#<PIL.Image.Image image mode=RGB size=250x292 at 0x18EA75F9400>

transform=torchvision.transforms.Compose([torchvision.transforms.Resize((32,32)),
                                          torchvision.transforms.ToTensor()])
image=transform(image)
print(image.shape)
# to_pil_image(image).show()

#注意要转换到gpu上~~
image = torch.reshape(image, (1, 3, 32, 32)).to('cuda')#需要的是四维
print(image.shape)
# model=torch.load("model_9.pth").to('cuda')
model=torch.load("model_29_gpu.pth").to('cuda')
print(model)
model.eval()
with torch.no_grad():
    output=model(image)
print(output)
# tensor([[-0.6509, -0.1051,  2.3188, -0.1962,  1.3352,  1.7444,  1.3944, -1.1408,
#          -2.6695, -0.3176]], device='cuda:0')
print(output.argmax(1))
ind=output.argmax(1).item()
map=['airplane', 'automobile','bird','cat','deer','dog','frog','horse', 'ship','truck']
print(map[ind])
# {'airplane': 0, 'automobile': 1, 'bird': 2,
#  'cat': 3, 'deer': 4, 'dog': 5, 'frog': 6,
#  'horse': 7, 'ship': 8, 'truck': 9}

在这里插入图片描述

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

深度学习

python

Pytorch

pytorch 自学笔记@_@ 的相关文章

随机推荐

  • mvvm框架是什么

    MVVM是Model View ViewModel的简写 它本质上就是MVC Model View Controller 的改进版 在开发过程中 由于需求的变更或添加 项目的复杂度越来越高 代码量越来越大 此时我们会发现MVC维护起来有些吃

  • mysql表操作-约束删除、用户填加、授权和撤权

    目录 一 表的约束删除 1 查看所有表的约束条件 2 删除主键 3 删除唯一键 4 删除check键值 5 删除check键值 6 删除not null键值并删除check键值 7 删除键外值 8 检查表的约束条件是否存在 二 设置数据库密

  • 数据通信介绍

    数据通信方式有两种 串行通信与并行通信 一 串行通信 串行通信是指数据的各位在同一根数据线上逐位发送和接收 如下图所示 它可以按照数据传送方向和通信方式来划分 如果按照数据传送方向分类 则分为以下方式 单工 数据传输只支持数据在一个方向上传

  • 链接库的时候，提示load shared libraries error，xxx file too short

    该问题主要是提示 load shared libraries error xxx file too short 软连接链接问题 原因 程序链接的动态库中有软连接 但是软连接没有 l 标识 被识别成了实际的动态库文件 软连接文件又太小 所以就

  • 使用 vue-router 切换页面时怎么设置过渡动画

    如何实现切换页面时的过渡动画 背景 今天在编写页面时 看到页面没有任何效果就只是直入直出 完全没有一点逼格 所以想要实现类似于原生app的那种切换页面时的特效 遂开始google 发现网上各种方案都是各有优缺点 于是整理了自认为优雅的方案并

  • warning: ‘gets’ is deprecated (declared at /usr/include/stdio.h:638) [-Wdeprecated-declarations]

    warning gets is deprecated declared at usr include stdio h 638 Wdeprecated declarations 5 c In function getinfo 5 c 20 2

  • Mac Jenkins+fastlane 简单几步实现iOS自动化打包发布 + jenkins节点设置

    最近在使用jenkins 实现ios自动化打包发布蒲公英过程实践遇到了一些坑 特意记录下来方便有需要的人 进入正题 一 安装Jenkins 1 Mac上安装Jenkins 遇到到坑 因为 Jenkins 的pkg安装包默认安装位置为shar

  • 学习Python：探索无限可能

    Python是一种简洁而强大的编程语言 广泛应用于各个领域 从Web开发到数据分析 人工智能和科学计算 学习Python不仅可以提高编程技能 还能为你打开无限的创造力和发展机会 在本文中 我将介绍一些学习Python的重要用途 并提供相应的

  • 链家网页爬虫_爬虫实战1-----链家二手房信息爬取

    经过一段机器学习之后 发现实在是太枯燥了 为了增添一些趣味性以及熟练爬虫 在之后会不定时的爬取一些网站 旨在熟悉网页结构 尤其是HTML的元素 ajax存储 json 熟练使用pyspider scrapy两大框架 掌握基本的request

  • Java-向下转型-instanceof 关键词

    Java 向下转型 instanceof 关键词 1 父类对象转型为子类 package com lmwei p10 public class PersonTest public static void main String args 多

  • [刷题记录]牛客面试笔刷TOP101(二)

    一 传送门 刷题记录 牛客面试笔刷TOP101 一 HY PIGIE的博客 CSDN博客 目录 1 合并二叉树 2 二叉树的镜像 3 判断是否为二叉搜索树 4 判断是不是完全二叉树 1 合并二叉树 合并二叉树 牛客题霸 牛客网 nowcod

  • cpolar 内网穿透FTP Server

    由于FTP协议是个多端口协议 它需要侦听本地TCP 21端口和一个数据传输端口段 1024 65535 所以通常难以穿透 以下为cpolar给出的解决方案 1 创建FTP隧道 在本地安装配置cpolar内网穿透后 创建隧道 cpolar f

  • 关于32单片机IO口8种状态的理解

    最近接触了32单片机 关于对于IO口的学习想记录下来 有什么不对的地方 希望能指出来 进行改正 32单片机IO口共有八种状态 分别是 输入 1 输入浮空 2 输入上拉 3 输入下拉 4 模拟输入 输出 1 开漏输出 2 推挽输出 3 推挽复

  • ElasticSearch第十二讲 ES 集群脑裂问题

    ES集群出现脑裂 脑裂这个词 我们肯定不会陌生 在zk集群 mq集群搭建就考虑过这个问题 为保证部署在不同机房的集群始终保证任何时候只会有一个Leader来协调处理问题 当集群其他机器或者主节点出现故障时 保证重新选举出主节点不影响整个系统

  • vue三种常用获取input值写法

    1 v model 表单输入绑定 使用v model创建双向数据绑定 用来监听用户的输入事件以更新数据 并对一些极端场景进行一些特殊处理

  • 【数据处理】 python 常用操作整理

    python 数据分析常用操作 这是本人在数据分析中 记不住 反复查询的一些命令汇总 在此做个归纳汇总 并不定期更新 Dataframe import pandas as pd 合并DF 需求 有的时候需要将多个列相同的数据集 如别人的训练

  • Python调用OpenAI接口的简单封装

    1 注册OpenAI账号 获取OpenAI API key 网上有很多资料 这里就不再叙述了 科学上网 懂得都懂 一个小坑 在生成API key之后需立刻复制下来 否则将无法再次打开 当然如果错过复制了 也可以再重新生成一个key 2 安装

  • FinalShell 介绍

    官网 http www hostbuf com FinalShell是一体化的的服务器 网络管理软件 不仅是ssh客户端 还是功能强大的开发 运维工具 充分满足开发 运维需求 特色功能 免费海外服务器远程桌面加速 ssh加速 双边tcp加速

  • 设置linux ip命令

    设置linux ip命令 http hi baidu com BD F1 C8 D5 C8 C8 B5 E3 blog item 0b7256308902e19da9018e11 html ifconfig eth0 192 168 168

  • pytorch 自学笔记@_@

    课程 dataset 类 from torch utils data import Dataset from PIL import Image import os class MyData Dataset def init self roo

热门标签