小土堆-pytorch

冯-诺依曼

已于 2024-01-17 11:03:12 修改

阅读量1.2k

点赞数 26

分类专栏：人工智能框架文章标签： pytorch 人工智能 python

于 2023-12-15 23:20:13 首次发布

本文链接：https://blog.csdn.net/2301_77824555/article/details/135022816

版权

人工智能框架专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一、pytroch环境

conda

查看环境下包

pip list
conda list

创建环境

conda create -n name python=3.6

激活

conda activate name

退出

conda deavtivate

pytorch

查看gpu信息

nvidia-smi
// 保持driver version版本大于396.26

pytroch可以官网执行命令，也可以下载好包在执行
包要放在pkgs在执行conda install --use -local 包名字

测试安装成功

import torch
// gpu是否可以用
print(torch.cuda.is_available())

mac验证

import torch
print(torch.backends.mps.is_available())
print(torch.backends.mps.is_built())

编译器

pycharm

官网安装
配置环境选择env中的python.exe
使用console控制台可以查看变量信息

jupyter

配置环境可以在自己环境安装Jupyter

conda install nb_conda

打开

jupyter notebook

帮助函数

dir(包)
help(函数)

二、处理数据

加载数据

torchvision数据集

import torchvision
from torchvision import transforms
trans = transforms.Compose([
    transforms.ToTensor()
])
train_set = torchvision.datasets.CIFAR10(root="./dataset",train=True,transform=trans,download=True)
test_set = torchvision.datasets.CIFAR10(root="./dataset",train=False,transform=trans,download=True)
img,target = test_set[0]
print(img) 
print(target)
print(test_set.classes[target])

Dataset

提供一种方式获取数据及label并且编号
获取每一个数据及label
告知总共多少个数据
在这里插入图片描述

from torch.utils.data import Dataset
import cv2
from PIL import Image
import os
# help(Dataset)
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,self.img_path)
        img = Image.open(img_item_path)
        label = self.label_dir
        return img,label
    def __len__(self):
        return len(self.img_path)
    
ants_dataset = mydata(root_dir,label_dir)
img, label = ants_dataset[0]
img.show()
bees_dataset = mydata(root_dir,label_dir)
all_train = ants_dataset+bees_dataset //拼接数据集
len(all_train)

Dataloader

为后面网络提供不同数据形式

import torchvision
from torchvision import transforms
from torch.utils.data.dataloader import DataLoader
trans = transforms.Compose([
    transforms.ToTensor()
])
train_set = torchvision.datasets.CIFAR10(root="./dataset",train=True,transform=trans,download=True)
test_set = torchvision.datasets.CIFAR10(root="./dataset",train=False,transform=trans,download=True)
print(type(test_set))
loader = DataLoader(dataset=test_set,batch_size=64,shuffle=True,num_workers=0,drop_last=False)

img,target = test_set[0]
# torch.Size([3, 32, 32])
# 3
print(img.shape)
print(target)

for data in loader:
    imgs,targets =data
    # torch.Size([64, 3, 32, 32])
    # torch.Size([64])
    print(imgs.shape)
    print(targets.shape)
    break

tensorboard

tensorboard --logdir=logs

在这里插入图片描述

from torch.utils.tensorboard import SummaryWriter
writer = SummaryWriter("logs")
# writer.add_image() 
for i in range(100):
    writer.add_scalar("y=2x",2*i,i)
writer.close()

在这里插入图片描述

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


img_path = 'path'
img_pil = Image.open(img_path)
img_array = np.array(img_pil) # （h。w。3）
print(type(img_array))

writer = SummaryWriter("logs")
# 需要输入tensor或者numpy型
# 通道（3，h，w）
# 1代表step
writer.add_image("test",img_array,1,dataformats='HWC') 

writer.close()

transforms

对图片进行变换

from torchvision import transforms
from PIL import Image
from tensorboardX import SummaryWriter
img_path ='path'
img = Image.open(img_path)
trans = transforms.ToTensor()
img_tensor = trans(img)

writer = SummaryWriter('logs')
writer.add_image("tensor_img",img_tensor)

from torchvision import transforms
from PIL import Image
img_path ='image/a.png'
img = Image.open(img_path)
trans = transforms.Compose([
    transforms.ToTensor(),
    # 归一化，标准差。。。(x-0.5)/0.5
    transforms.Normalize([0.5,0.5,0.5,0.5],[0.5,0.5,0.5,0.5]),
    transforms.Resize((512,512)),
    # 随机裁剪
    transforms.RandomCrop((100,30))
    ]
)

img_com = trans(img)
print(img_com) # tensor

trans = transforms.ToPILImage()
trans(img_com).show()

图片操作

opencv

import cv2
img_path ='path'
cv_img = cv2.imread(img_path)

PIL

from PIL import Image
img_path = '...'
img = Image.open(img_path)
img.size //图片大小
img.show()// 显示图片

三、网络搭建

nn.Module

from torch import nn 
import torch 
class mymodel(nn.Module):
    def __init__(self) :
        super(mymodel,self).__init__()

    def forward(self,x):
        y = x+1
        return y
    
a = mymodel()
x = torch.tensor([10,20,30])
print(a(x))

import torch 
import torch.nn.functional as F
input = torch.ones([5,5])
kernel = torch.randn([3,3])

input = torch.reshape(input,(1,1,5,5))
kernel = torch.reshape(kernel,(1,1,3,3))

output = F.conv2d(input,kernel,stride=1)
print(output)
# padding会在左右都填充一个
output = F.conv2d(input,kernel,stride=2,padding=1)
print(output)

import torch 
import torchvision
import torch.nn as nn 
from torch.nn import Conv2d
from torch.nn import MaxPool2d
from torch.nn import ReLU
from torch.nn import Flatten
from torch.nn import Linear
from torch.nn import Sigmoid
from torch.utils.data.dataloader import DataLoader
dataset = torchvision.datasets.CIFAR10("./dataset",train=False,transform=torchvision.transforms.ToTensor(),
                                       download=True)
dataloader  = DataLoader(dataset,batch_size=64)

class mod(nn.Module):
    def __init__(self):
        super(mod,self).__init__()
        # 卷机
        self.conv1 = Conv2d(in_channels= 3,out_channels= 6,kernel_size= 3,stride=1,padding=0)
        # 最大池话，下采样,减少数据量减少计算量
        # ceil——model如果到边缘哟啊不要保留，true保留
        self.maxpool1 = MaxPool2d(kernel_size=3,ceil_mode=True)
        # inplace是否原地变化，默认false
        self.relu = ReLU(inplace=False)
        self.sigmoid = Sigmoid()
        self.flatten = Flatten()
        self.Linear = Linear(600,10)

    def forward(self,x):
        x=self.conv1(x)
        x = self.maxpool1(x)
        x = self.relu(x)
        x = self.sigmoid(x)
        x = self.flatten(x) 
        x = self.Linear(x)
        return x

modshi = mod()
print(modshi)

for data in dataloader:
    imgs,targers = data
    out = modshi(imgs)
    print(out.shape)
    break

# mod(
#   (conv1): Conv2d(3, 6, kernel_size=(3, 3), stride=(1, 1))
#   (maxpool1): MaxPool2d(kernel_size=3, stride=3, padding=0, dilation=1, ceil_mode=True)
#   (relu): ReLU()
#   (sigmoid): Sigmoid()
#   (flatten): Flatten(start_dim=1, end_dim=-1)
#   (Linear): Linear(in_features=600, out_features=10, bias=True)
# )
# torch.Size([64, 10])

import torch 
import torchvision
import torch.nn as nn 
from torch.nn import Conv2d
from torch.nn import MaxPool2d
from torch.nn import ReLU
from torch.nn import Flatten
from torch.nn import Linear
from torch.nn import Sigmoid
from torch.nn import Sequential
from torch.utils.data.dataloader import DataLoader
from tensorboardX import SummaryWriter
dataset = torchvision.datasets.CIFAR10("./dataset",train=False,transform=torchvision.transforms.ToTensor(),
                                       download=True)
dataloader  = DataLoader(dataset,batch_size=64)

class mod(nn.Module):
    def __init__(self):
        super(mod,self).__init__()
        self.conv1 = Conv2d(3,32,5,stride=1,padding=2)
        self.max_pool2d = MaxPool2d(2)
        self.conv2 = Conv2d(32,32,5,padding=2)
        self.max_pool2d2 = MaxPool2d(2)
        self.conv3 = Conv2d(32,64,5,padding=2)
        self.max_pool2d3 = MaxPool2d(2)
        self.flatten = Flatten()
        self.Linear = Linear(1024,64)
        self.Linear2 = Linear(64,10)

        self.model1 = Sequential(
            Conv2d(3,32,5,stride=1,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.max_pool2d(x)
        # x=self.conv2(x)
        # x=self.max_pool2d2(x)
        # x=self.conv3(x)
        # x=self.max_pool2d3(x)
        # x=self.flatten(x)
        # x=self.Linear(x)
        # x=self.Linear2(x)
        x = self.model1(x)

        return x

modshi = mod()
print(modshi)

x = torch.ones((64,3,32,32))
out = modshi(x)


for data in dataloader:
    imgs,targers = data
    out = modshi(imgs)
    print(out.shape)
    break
# 可视化网络
writer = SummaryWriter("logs")
writer.add_graph(modshi,x)
writer.close()

# mod(
#   (conv1): Conv2d(3, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
#   (max_pool2d): 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))
#   (max_pool2d2): 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))
#   (max_pool2d3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#   (flatten): Flatten(start_dim=1, end_dim=-1)
#   (Linear): Linear(in_features=1024, out_features=64, bias=True)
#   (Linear2): Linear(in_features=64, out_features=10, bias=True)
#   (model1): Sequential(
#     (0): Conv2d(3, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
#     (1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#     (2): Conv2d(32, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
#     (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#     (4): Conv2d(32, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
#     (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#     (6): Flatten(start_dim=1, end_dim=-1)
#     (7): Linear(in_features=1024, out_features=64, bias=True)
#     (8): Linear(in_features=64, out_features=10, bias=True)
#   )
# )
# torch.Size([64, 10])

损失函数

import torch
from torch.nn import L1Loss
from torch.nn import MSELoss
from torch.nn import CrossEntropyLoss
x = torch.tensor([1,2,3],dtype=torch.float32)
y = torch.tensor([1,2,5],dtype=torch.float32)

x = torch.reshape(x,(1,1,1,3))
y = torch.reshape(y,(1,1,1,3))

loss = L1Loss(reduce='sum')
result = loss(x,y)
print(result)

loss = MSELoss()
result = loss(x,y)
print(result)

x = torch.tensor([0.1,0.2,0.3])
y = torch.tensor([1])
x = torch.reshape(x,(1,3))
loss = CrossEntropyLoss()
result = loss(x,y)
print(result)

优化器

import torch 
import torchvision
import torch.nn as nn 
from torch.nn import Conv2d
from torch.nn import MaxPool2d
from torch.nn import ReLU
from torch.nn import Flatten
from torch.nn import Linear
from torch.nn import Sigmoid
from torch.nn import Sequential
from torch.utils.data.dataloader import DataLoader
from torch.nn import CrossEntropyLoss
from torch.optim import SGD
dataset = torchvision.datasets.CIFAR10("./dataset",train=False,transform=torchvision.transforms.ToTensor(),
                                       download=True)
dataloader  = DataLoader(dataset,batch_size=64)

class mod(nn.Module):
    def __init__(self):
        super(mod,self).__init__()
        self.model1 = Sequential(
            Conv2d(3,32,5,stride=1,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

modshi = mod()
loss = CrossEntropyLoss()
optim = SGD(modshi.parameters(),lr=0.01)

for epoch in range(20):
    runing_loss = 0.0
    for data in dataloader:
        imgs,targers = data
        out = modshi(imgs)
        loss1 = loss(out,targers)
        optim.zero_grad()
        loss1.backward()
        optim.step()
        runing_loss = runing_loss+loss1
    print(runing_loss)

gpu的使用

fff = model.cuda()
loss_fn = loss.cuda()
imgs = imgs.cuda()
targets = targets.cuda()

device = torch.device("cuda")
model = model.to(device)
imgs = imgs.to(device)

现有模型使用

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

dataset = torchvision.datasets.CIFAR10("./dataset",train=False,transform=torchvision.transforms.ToTensor(),
                                       download=True)
dataloader  = DataLoader(dataset,batch_size=64)
# 在最后一层加先行层从1000-》10
vgg16_true.add_module('add',nn.Linear(1000,10))
# 修改vgg最后一层
vgg16_false.classifier[6] = nn.Linear(4096,10)

保存读取网络

import torch
import torchvision

vgg16 = torchvision.models.vgg16(pretrained=True)
# 保存1,模型结构和参数,需要模型定义的代码
torch.save(vgg16,'vgg16.pth')

# 加载1
model = torch.load('vgg16.pth')
print(model)

# 保存2，保存参数字典形式
torch.save(vgg16.state_dict(),"vgg.pth")
# 加载2
model = torchvision.models.vgg16()
model.load_state_dict(torch.load('vgg.pth'))

四、完整训练验证网络

# model.py
import torch
from torch import nn
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linear



class fff(nn.Module):
    def __init__(self):
        super(fff, self).__init__()
        self.model1 = Sequential(
            Conv2d(3, 32, 5, stride=1, 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 = fff()
    x = torch.ones(64,3,32,32)
    y = model(x)
    print(y.shape)

# main.py
import torch
from torch import nn
from torch.utils.data import DataLoader
import torchvision
from model import fff
from tensorboardX import SummaryWriter
train_data = torchvision.datasets.CIFAR10(root='dataset', train=True, transform=torchvision.transforms.ToTensor(),
                                          download=True)
test_data = torchvision.datasets.CIFAR10(root='dataset', train=False, transform=torchvision.transforms.ToTensor(),
                                         download=True)

print("训练数据集长度为{}".format(len(train_data)))
print("测试数据集长度为{}".format(len(test_data)))

train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)

model = fff()

loss = nn.CrossEntropyLoss()
learn = 1e-2
optim = torch.optim.SGD(model.parameters(),lr=learn)
# 记录训练次数
total_train_step = 0
# 记录测试次数
total_test_step = 0
#训练轮数
epoch = 10
writer = SummaryWriter("logs")

for i in range(epoch):
    model.train()
    print('-------------------------{}轮开始-------------------'.format(i))
    for data in train_dataloader:
        imgs,targets = data
        y = model(imgs)
        loss1 = loss(y, targets)
        optim.zero_grad()
        loss1.backward()
        optim.step()
        total_train_step+=1
        if total_train_step % 300 == 0:
            print("第{}次,损失为{}".format(total_train_step, loss1.item()))
            writer.add_scalar("train_loss",loss1.item(),total_train_step)
    model.eval()
    total_test_loss = 0
    total_accuracy = 0
    with torch.no_grad():
        for data in test_dataloader:
            imgs ,targets = data
            y = model(imgs)
            loss1 = loss(y,targets)
            total_test_loss +=loss1
            accuracy = (y.argmax(1)==targets).sum()
            total_accuracy+=accuracy
    print("整体测试集上loss{}".format(total_test_loss))
    print("整体测试集上accuracy{}".format(total_accuracy/len(test_data)))
    writer.add_scalar("test_loss", total_test_loss, total_test_step)
    writer.add_scalar("test_accuracy", total_accuracy/len(test_data), total_test_step)
    total_test_step += 1

    torch.save(model,"cif{}.pth".format(i))
    print("save over")

writer.close()

# test.py
import torch
from torch import nn
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linear
import torchvision
from PIL import Image

img_path = "image/下载.jpeg"
img = Image.open(img_path)
trans = torchvision.transforms.Compose([
    torchvision.transforms.Resize((32, 32)),
    torchvision.transforms.ToTensor()
])
img = trans(img)
img = torch.reshape(img, (1, 3, 32, 32))


class fff(nn.Module):
    def __init__(self):
        super(fff, self).__init__()
        self.model1 = Sequential(
            Conv2d(3, 32, 5, stride=1, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(64*4*4, 64),
            Linear(64, 10),
        )

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

        return x

device = torch.device("mps")
model = torch.load("./cif9.pth").to(device)
model.eval()
with torch.no_grad():
    img = img.to(device)
    y = model(img)
    y = y.argmax(1)
    print(y)