pytorch学习笔记

已于 2024-09-06 21:10:46 修改
阅读量627 收藏 6
点赞数 11
分类专栏： deep learning 文章标签： python pytorch
于 2024-07-01 10:38:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45689940/article/details/140094330
版权

学习工具：
dir()：打开，看见
help():官方的解释文档

加载数据

dir(torch.cuda.is_available) -----------注意，不是is_available()
输出前后带_ _，表明.is_available不是分割区，是函数在这里插入图片描述
————————————————————————————————————————————

三种写代码的不同
在这里插入图片描述
———————————————————————————————————————————————————————

windows里用\表示转译
在这里插入图片描述

———————————————————————————————————————————————————————
1.os.path.join() 拼接地址

2.os.listdir() 方法用于返回指定的文件夹包含的文件或文件夹的名字的列表。

它不包括 . 和 … 即使它在文件夹中。

只支持在 Unix, Windows 下使用。

加载数据代码

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

class MyData(Dataset):

    def __init__(self,root_dir, label_dir):
    # 为整个class提供全局变量
    # 为一些方法提供一些量
        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.img_path
        return img,label

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

root_dir=r"data/dataset/train"
ants_label_dir="ants_image"
bees_label_dir="bees_image"
ants_dataset=MyData(root_dir,ants_label_dir)
bees_dataset=MyData(root_dir,bees_label_dir)

#合并
train_dataset = ants_dataset + bees_dataset

#img,label = ants_dataset[0]
#img.show()
#会展现出第0张蚂蚁的图片


ants_jpgname=ants_dataset.img_path
bees_jpgname=bees_dataset.img_path

for i in ants_jpgname:
    ants_lebelname=i.split('.jpg')[0]+'.txt'

    with open(r"D:\shenduxuexi\data\dataset\train\ants_label\{}".format(ants_lebelname),'w') as f:
        pass
        #这里是写入每张照片的信息


for i in bees_jpgname:
    bees_lebelname=i.split('.jpg')[0]+'.txt'

    with open(r"D:\shenduxuexi\data\dataset\train\bees_label\{}".format(bees_lebelname),'w') as f:
        pass
        #这里是写入每张照片的信息

Tenserboard

是TensorFlow提供的一个强大的可视化工具，也是一个Web应用程序套件，通过运行本地服务器，在浏览器中显示训练过程中记录的数据。
探究模型不同阶段是怎么输出的

from torch.utils.tensorboard import SummaryWriter
#创建实例
writer = SummaryWriter(logs)
#两种方法
writer.add_image()
writer.add_scalar()


writer.close()

writer.add_scalar()：

 def add_scalar(
        self,
        tag,#标题
        scalar_value,#y轴
        global_step=None,#x轴
        walltime=None,
        new_style=False,
        double_precision=False,
    ):

在Terminal激活环境： conda cativate 环境名
打开端口：

tensorboard --logdir=logs
#logdir=事件文件所在文件夹名

#默认打开端口是6006
#指定端口防止与别人冲突：
tensorboard --logdir=logs --port=6007

在这里插入图片描述

writer.add_image()

  1. 利用Opencv读取图片，获得numpy类型图片数据

先pip install opencv-python

import cv2
cv_img = cv2.imread(img_path)

在这里插入图片描述

  1. 用numpy.array()，对PIL图片进行转换。 用Image.open()打开的图像文件是PIL型
img=Image.open(image_path)
import numpy as np
img_array=np.array(img)

type(img_array)#数据类型
img_array.shape#数据维度

*PyCharm 错误：Empty suite：py文件不要以test开头 *

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

#创建实例
writer = SummaryWriter('logs')
image_path=r"D:\shenduxuexi\data\dataset\train\ants_image\0013035.jpg"
img_PIL=Image.open(image_path)
img_array=np.array(img_PIL)

print(type(img_array))
print(img_array.shape)

writer.add_image("test",img_array,1,dataformats='HWC')
#不改变tag，只改变step和图片地址，出来的图会在一个框内，可以看每一步是什么图片
#dataformats是看add_image文档得的

#y=x
for i  in range(100):
    writer.add_scalar("y=2x",2*i,i)
#多了logs文件夹，里面是tensorboard的事件文件

writer.close()

transform

主要是对图形进行变化、处理

transforms结构及用法
拿一定格式的图片，经过transforms.py的工具，得到想要的图片的结果or图片的变化

from torch.utils.tensorboard import SummaryWriter
from torchvision import transforms
from PIL import Image
# python 用法
#   tensor数据类型
#   通过transforms.ToTensor去解决两个问题
#   1.transforms要怎么使用
#   2.why 需要Tensor数据类型
#       tensor数据类型包装了进行深度学习的时候需要的一些数据


img_path = r"D:\shenduxuexi\data\dataset\train\ants_image\0013035.jpg"
img = Image.open(img_path)
writer = SummaryWriter("logs1")

#1.transforms要怎么使用
#   实例化ToTensor,将图片转化为tensor类型
tensor_trans = transforms.ToTensor()
tensor_img = tensor_trans(img)

#print(tensor_trans)
#   2.why 需要Tensor数据类型
#       tensor数据类型包装了进行深度学习的时候需要的一些数据

writer.add_image("Tensor_img",tensor_img)
writer.close()

常见的Transforms

在这里插入图片描述

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

writer = SummaryWriter("logs2")
img = Image.open(r'D:\shenduxuexi\images\0013035.jpg')


#ToTensor
trans_totensor=transforms.ToTensor()
img_tensor=trans_totensor(img)
writer.add_image("ToTensor",img_tensor)

#Normalize
#三个0表示 第一个通道 第一行 第一列
print(img_tensor[0][0][0])
trans_norm = transforms.Normalize([1,2,3],[2,4,5])
img_norm = trans_norm(img_tensor)
print(img_norm[0][0][0])
writer.add_image("Normlize",img_norm,1)

#Resize
print(img.size)
trans_resize=transforms.Resize((512,512))
img_resize=trans_resize(img)
#img 经过resize，PIL->PIL
print(img_resize)

#输出的是PIL类型，若想在tensorboard上显示，用ToTensor转化为tensor类型
img_resize=trans_totensor(img_resize)
writer.add_image("Resize",img_resize,0)

#Compose - resize
#   输入的是一个序列，不改变高和宽的比例，只改变最小边
trans_resize_2 = transforms.Resize(512)
#它包含了两个变换操作：首先是trans_resize_2，负责调整图像大小；其次是trans_totensor，将调整大小后的图像从PIL格式转换为PyTorch张量。
trans_compose = transforms.Compose([trans_resize_2,trans_totensor])
#应用了这个组合变换到原始图像img上。
img_resize_2 = trans_compose(img)
writer.add_image("Resize",img_resize_2,1)

#RandomCrop 随机裁剪，裁剪的结果是原图片的一部分
#如果RandomCrop中的数字大于图片大小就会报错
trans_random = transforms.RandomCrop(200)
trans_compose_2 = transforms.Compose([trans_random,trans_totensor])
for i in range(1,10):
    img_crop = trans_compose_2(img)
    writer.add_image("RandomCrop",img_crop,i)


writer.close()

主要看输入什么类型，输出什么类型
多看官方文档（阅读源码）
关注方法需要什么参数
不知道返回值是什么的时候，多print()，print(type))

torchvision数据集的使用

torchvision
torchvision.models提供了多种预训练模型
torchvision.datasets提供了数据集
torchvision.transforms提供了图像预处理功能

import torchvision
from torch.utils.tensorboard import SummaryWriter

#对图片进行一些操作
dataset_transform = torchvision.transforms.Compose([
    torchvision.transforms.ToTensor()
])

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

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

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

writer.close()

DataLoader的使用

DataLoader是PyTorch中用于数据预处理和批处理的核心工具。它可以按需加载数据并将其分批送入神经网络进行训练。DataLoader不仅支持数据的批量加载，还可以对数据进行打乱（shuffle）、多进程加载（multiprocessing loading）等操作，以提高数据处理的效率和模型训练的性能。

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

#准备的测试数据集
test_data = torchvision.datasets.CIFAR10("./dataset",train=False,transform=torchvision.transforms.ToTensor())

test_loader = DataLoader(dataset=test_data,batch_size=4,shuffle=True,num_workers=0,drop_last=False)
#这种配置适合于测试阶段，因为测试通常不需要像训练那样频繁地更新模型权重，而且保持数据顺序可能有助于评估模型在特定数据顺序下的表现。

#测试数据集中第一张图片和target
img,target=test_data[0]
print(img.shape)
print(target)
for data in test_loader:
    imgs,targets = data
    print(imgs.shape)
    print(targets)

在这里插入图片描述

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

#准备的测试数据集
test_data = torchvision.datasets.CIFAR10("./dataset",train=True,transform=torchvision.transforms.ToTensor())

test_loader = DataLoader(dataset=test_data,batch_size=4,shuffle=True,num_workers=0,drop_last=False)
#这种配置适合于测试阶段，因为测试通常不需要像训练那样频繁地更新模型权重，而且保持数据顺序可能有助于评估模型在特定数据顺序下的表现。

#测试数据集中第一张图片和target
img,target=test_data[0]
print(img.shape)
print(target)

writer=SummaryWriter("dataloader")

#epoch，多次对这一批数据进行抓取，shuffle应该设置为True
for epoch in range(2):
    step = 0
    for data in test_loader:
        imgs,targets = data
        # print(imgs.shape)
        # print(targets)
        writer.add_images("epoch = {}".format(epoch), imgs, step)
        step=step+1

#不用epoch时：
# step = 0
# for data in test_loader:
#     imgs,targets = data
#     # print(imgs.shape)
#     # print(targets)
#     writer.add_images("test_data", imgs, step)
#     step=step+1


writer.close()

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

要创建一个自定义的神经网络模型，需要继承 nn.Module 类并重写其 init 和 forward 方法。在 init 方法中定义模型的层和参数，forward 方法定义模型的前向传播逻辑。

import torch
from torch import nn


class mod(nn.Module):
    def __init__(self):
        super().__init__()


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

MOD=mod()
x=torch.tensor(1.0)
output=mod(x)
print(output)

卷积操作

stride (int or tuple, optional): 卷积步长，可以是单个整数或包含两个整数的元组 (stride_height, stride_width)，默认为 1。
padding (int or tuple, optional): 输入张量两侧的零填充大小，可以是单个整数或包含两个整数的元组 (padding_height, padding_width)，默认为 0。

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]])

#torch.reshape函数在PyTorch中用于改变张量的形状，而不改变其数据。
input = torch.reshape(input,(1,1,5,5))
                 #   (batchsize,channal,5,5)

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

print(input.shape)
print(kernel.shape)

output1 = F.conv2d(input,kernel,stride=1)

print("output1 = \n",output1)

output2 = F.conv2d(input,kernel,stride=2)
print("output2 = \n",output2)

output3 = F.conv2d(input,kernel,stride=1,padding=1)
print("output3 = \n",output3)

在这里插入图片描述

卷积层

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(R"D:\shenduxuexi\dataset",train=False,transform=torchvision.transforms.ToTensor(),
                                       download=True)

dataloader= DataLoader(dataset,batch_size=64)

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

ycb=Ycb()
print(ycb)
writer = SummaryWriter("nn_conv2")
step=0
for data in dataloader:
    imgs,targets=data
    output = ycb(imgs)
    # print(imgs.shape)
    # print(output.shape)

    #torch.Size([64, 3, 32, 32])
    writer.add_images("input",imgs,step)
#输出卷积后数据先看对应数据是否符合输出要求!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'''
    #output：torch.Size([64, 6, 30, 30])
    #    直接add_image（soutput）会报错，add_images函数要求通道数为3
    #    用torch.reshape改变通道数，其中第一个不知道写啥写-1，会自动计算
    output=torch.reshape(output, (-1, 3, 30, 30))
#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!！！！！！！！！！！！！！！！！！！！！！'''
    writer.add_images("output", output, step)
    step=step+1
writer.close()

池化层

最大池化层——下采样

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(r"D:\shenduxuexi\dataset",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]])
#
# input = torch.reshape(input,(-1,1,5,5))
# class Ycb()
# ....
# output = ycb(input)
# print(output)
class Ycb(nn.Module):
    def __init__(self):
        super().__init__()
        #ceil_mode:ceil  floor
        self.maxpool1 = MaxPool2d(kernel_size=3,ceil_mode=True)

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

ycb=Ycb()
writer=SummaryWriter("nn_maxpool")
step=0
for data in dataloader:
    imgs,targets=data
    writer.add_images("input",imgs,step)
    output=ycb(imgs)
    #池化不会改变通道数，不用跟卷积一样改变
    writer.add_images("output",output,step)
    step=step+1

writer.close()

在这里插入图片描述

非线性激活

ReLU()
Sigmoid()

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

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

dataset = torchvision.datasets.CIFAR10(r"D:\shenduxuexi\dataset",train=False,download=True,transform=torchvision.transforms.ToTensor())

dataloader = DataLoader(dataset,batch_size=64)

class Ycb(nn.Module):
    def __init__(self):
        super().__init__()
        self.relu1=ReLU()
        self.sigmoid1=Sigmoid()

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

ycb=Ycb()

writer = SummaryWriter("relu")

step=0

for data in dataloader:
    imgs,targets = data
    writer.add_images("input",imgs,step)
    output=ycb(imgs)
    writer.add_images("output",output,step)

    step+=1
writer.close()

在这里插入图片描述

正则化层：对输入进行正则化，可以加快训练速度

线性层

先看弄成线性后的in_f是多少

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

dataset = torchvision.datasets.CIFAR10("D:\shenduxuexi\dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)

dataloader = DataLoader(dataset,batch_size=64)



for data in dataloader:
    imgs,targets = data
    print(imgs.shape)
    output=torch.reshape(imgs,(1,1,1,-1))
    print(output.shape)

在这里插入图片描述

torch.flatten 是 PyTorch 库中的一个函数，用于将张量展平为一维张量。

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

dataset = torchvision.datasets.CIFAR10("D:\shenduxuexi\dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)

dataloader = DataLoader(dataset,batch_size=64)

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

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

ycb=Ycb()
for data in dataloader:
    imgs,targets = data
    print(imgs.shape)
    output = torch.flatten(imgs)
    print(output.shape)

在这里插入图片描述

搭建实战，Sequential使用

Sequential写法！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
复刻
在这里插入图片描述

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

# class Ycb(nn.Module):
#     def __init__(self):
#         super().__init__()
#         self.conv1 = Conv2d(3, 32,5,padding=2)#padding是根据公式算的
#         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

#若用Sequential,代码会更简洁
class Ycb(nn.Module):
    def __init__(self):
        super().__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


ycb = Ycb()
print(ycb)


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


writer=SummaryWriter("seq")

#add_graph函数通常用于将模型的计算图添加到TensorBoard中
writer.add_graph(ycb,input)
writer.close()

损失函数

1. 计算了实际输出与目标的差距
2. 为更新输出提供了一定的依据（反向传播） grad

nn_loss.py

import torch
from torch.nn import L1Loss
from torch import nn
inputs = torch.tensor([1,2,3.])
targets = torch.tensor([1,2,5.])

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

targets=torch.reshape(targets,(1,1,1,3))
#MAE  平均绝对误差
loss=L1Loss()
result = loss(inputs,targets)


#MSE  均方误差
loss_mse=nn.MSELoss()
result_mse = loss_mse(inputs,targets)

#交叉熵
x=torch.tensor([0.1,0.2,0.3])
y=torch.tensor([1])
x=torch.reshape(x,(1,3))
loss_cross=nn.CrossEntropyLoss()
result_cross=loss_cross(x,y)
print(result_cross)

nn_loss_network.py

import torch
import torchvision.datasets
from torch import nn
from torch.nn import ReLU, Sigmoid, Linear, Conv2d, MaxPool2d, Flatten, Sequential
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10("D:\shenduxuexi\dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)

dataloader = DataLoader(dataset,batch_size=64)

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

loss = nn.CrossEntropyLoss()
ycb = Ycb()
for data in dataloader:
    imgs,targets=data
    outputs=ycb(imgs)
    # #输出outputs和targets，看看选哪个损失函数,这里选的交叉熵
    # print(outputs)
    # print(targets)
    result_loss=loss(outputs,targets)
    print(result_loss)
    #一定是经过了loss的变量进行反向传播
    result_loss.backward()
#print(ycb)

优化器

import torch
import torchvision.datasets
from torch import nn
from torch.nn import ReLU, Sigmoid, Linear, Conv2d, MaxPool2d, Flatten, Sequential
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10("D:\shenduxuexi\dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)

dataloader = DataLoader(dataset,batch_size=64)

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

loss = nn.CrossEntropyLoss()
ycb = Ycb()
optim=torch.optim.SGD(ycb.parameters(),lr=0.01)#刚开始学习速率用大一点的，后来用小一点的

for epoch in range(20):
    #看每一轮loss是多少
    running_loss=0.0
    for data in dataloader:
        imgs,targets=data
        outputs=ycb(imgs)

        result_loss=loss(outputs,targets)
        #把优化器的参数设置为0
        optim.zero_grad()

        result_loss.backward()
        optim.step()

        running_loss=running_loss+result_loss
    print(running_loss)
    #会发现loss会慢慢变小

在这里插入图片描述

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

import torchvision
import torch
import torchvision.datasets
from torch import nn
from torch.nn import ReLU, Sigmoid, Linear, Conv2d, MaxPool2d, Flatten, Sequential
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
vgg16_false = torchvision.models.vgg16(weights=None)
vgg16_true = torchvision.models.vgg16(weights='DEFAULT')
print(vgg16_true)

vgg16_true的classifier结果：

  (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)

1. 对vgg16_true加一层线性层

import torchvision
import torch
import torchvision.datasets
from torch import nn
from torch.nn import ReLU, Sigmoid, Linear, Conv2d, MaxPool2d, Flatten, Sequential
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
vgg16_false = torchvision.models.vgg16(weights=None)
vgg16_true = torchvision.models.vgg16(weights='DEFAULT')

train_data = torchvision.datasets.CIFAR10("D:\shenduxuexi\dataset",train=True,transform=torchvision.transforms.ToTensor(),download=True)

#如何利用现有的网络，去改变他的结构  迁移学习
#以vgg16为前置网络
vgg16_true.classifier.add_module('add_linear',nn.Linear(1000,10))
print(vgg16_true)

结果会是

(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)#多了这个
  )

2. 修改最后的线性层

import torchvision
import torch
import torchvision.datasets
from torch import nn
from torch.nn import ReLU, Sigmoid, Linear, Conv2d, MaxPool2d, Flatten, Sequential
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
vgg16_false = torchvision.models.vgg16(weights=None)
vgg16_true = torchvision.models.vgg16(weights='DEFAULT')

train_data = torchvision.datasets.CIFAR10("D:\shenduxuexi\dataset",train=True,transform=torchvision.transforms.ToTensor(),download=True)

#如何利用现有的网络，去改变他的结构  迁移学习

# #以vgg16为前置网络，加层
# vgg16_true.classifier.add_module('add_linear',nn.Linear(1000,10))
# print(vgg16_true)

#2. 修改网络
print(vgg16_false)
vgg16_false.classifier[6] = nn.Linear(4096,10,True)
print(vgg16_false)

修改前
在这里插入图片描述
修改后
在这里插入图片描述

网络模型的保存与读取

一般保存和读取会在不同的文件里
方式1

import torchvision
import torch
import torchvision.datasets
from torch import nn
from torch.nn import ReLU, Sigmoid, Linear, Conv2d, MaxPool2d, Flatten, Sequential
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
vgg16=torchvision.models.vgg16(pretrain=False)

#保存方式1     不仅保存了网络结构，也保存了一些网络参数
torch.save(vgg16,"vgg16_method1.pdh")#推荐后缀为pdh
#加载方式1  对应保存方式1
model = torch.load(("vgg16_method1.pdh"))

#陷阱
class Ycb(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1=nn.Conv2d(3,64,kernel_size=3)

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

ycb=Ycb()
#保存
torch.save(ycb,"ycb_mothod1.pth")

#在另一个文件里加载
model=torch.load("ycb_mothod1.pth")

#会报错，需要把保存的文件在加载的文件里import   from model_save import *

方式2

import torchvision
import torch
import torchvision.datasets
from torch import nn
from torch.nn import ReLU, Sigmoid, Linear, Conv2d, MaxPool2d, Flatten, Sequential
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
vgg16=torchvision.models.vgg16(pretrain=False)

#保存方式2（官方推荐）   把vgg16的参数保存成字典,只保存了模型参数
torch.save(vgg16.state_dict(),"vgg16_method2.pdh")
#加载方式2
#   因为保存方式2只保存了字典，所以要先载入模型
vgg16 = torchvision.models.vgg16(pretrained = False)
#   再把参数填充进去
vgg16.load_state_dict(torch.load(("vgg16_method1.pdh")))
我睁开双眼看着空白
关注
  • 11
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Pytorch学习笔记总结
专注大数据与人工智能技术分享，欢迎私信加群互相学习！
11-10 8050
PyTorch学习笔记整理，内容参考多个多个优秀Pytorch学习资源，适合深度学习pytorch学习者学习。(开篇词)PyTorch 学习笔记 - PyTorch 学习笔记；动手学CV-Pytorch:动手学CV-Pytorch；Pytorch 中文文档：主页 - PyTorch中文文档；Pytorch Tutorials...
PyTorch学习笔记
weixin_45596153的博客
05-25 793
PyTorch学习笔记
Pytorch学习笔记（1）
qq_43649937的博客
07-17 1208
pytorch python
Pytorch学习笔记
m0_47042905的博客
05-01 272
首先安装Anaconda,包含了大量的工具包。不必下载最新版本，防止出现问题。https://repo.anaconda.com/ 安装3.6版本。记住安装路径，跳过安装VScode.打开anaconda promote.出现base即可。
pytorch 学习笔记
06-27
pytorch 学习笔记
笔记pytorch学习笔记
07-20
【PyTorch学习笔记概述】 PyTorch是Facebook开源的一款深度学习框架，它以其灵活性、易用性和强大的计算能力在学术界和工业界都受到了广泛的欢迎。本笔记将基于B站牛二大人的讲解，深入探讨PyTorch的核心概念、基本...
pytorch学习笔记（一）
01-06
此为小弟pytorch的学习笔记，希望自己可以坚持下去。（2020/2/17） pytorch官方文档 pytorch中文教程 tensor tensor是pytorch的最基本数据类型，相当于numpy中的ndarray，并且属性和numpy相似，tensor可在GPU上进行...
【python】—— Python爬虫实战：爬取珠海市2011-2023年天气数据并保存为CSV文件
weixin_63106307的博客
09-05 1009
本文将介绍如何使用Python编写一个简单的爬虫程序，以爬取珠海市2011年至2023年的天气数据，并将这些数据保存为CSV文件。
JS都有哪些操作数组的方法
ggq53219的博客
09-04 602
JavaScript 中操作数组的方法非常丰富，这些方法大致可以分为几类：创建和初始化数组、添加元素、删除元素、遍历数组、搜索元素、数组排序、数组映射和过滤等。
[Python]生成器和yield关键字
weixin_57336987的博客
09-07 370
概述:​ 它指的是 generator, 类似于以前学过的: 列表推导式, 集合推导式, 字典推导式…作用:​ 降低资源消耗, 快速(批量)生成数据.实现方式:​ 1.推导式写法.​ 2.yield写法.yield i # yield会记录每个生成的数据, 然后逐个的放到生成器对象中, 最终返回生成器对象.问题: 如何从生成器对象中获取数据?​ 答案:​ 1.for循环遍历​ 2.next()函数, 逐个获取.
基于人工智能的音乐情感分类系统
stm32d1219的博客
09-06 925
音乐作为一种强烈的情感表达方式，不同的音调、节奏和和声传递着不同的情感信息。通过人工智能技术，能够自动识别音乐中的情感，为用户提供个性化的音乐推荐或情感分析服务。通过使用MFCC特征提取与神经网络分类算法，音乐情感分类系统可以有效地分析音乐中的情感信息，并根据不同情感对音乐进行分类。随着深度学习技术的进一步发展，音乐情感分类系统的准确性和应用范围将得到进一步提升。音乐情感分类是通过对音乐音频信号进行分析，识别出音乐传递的情感，如“愉快”、“悲伤”、“愤怒”等。问题讨论，人工智能的资料领取可以私信！
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 500
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
数模原理精解【8】
最新发布
基础数学与物理学
09-10 720
假设有一个nnn维随机向量XX1X2XnTXX1​X2​Xn​T，它服从均值为μμ1μ2μnTμμ1​μ2​μn​T和协方差矩阵为ΣΣfXx12πn2∣Σ∣12exp⁡−12x−μTΣ−1x−μfX​x2πn/2∣Σ∣1/21​exp−21​x−μTΣ−1x−μxx1x2xnTxx1​x。
访问数组索引时超出边界引发 ArrayIndexOutOfBoundsException
Itmastergo的博客
09-05 1117
在 Java 中，数组是一种数据结构，用于存储固定数量的同类型元素。数组中的元素可以是基本数据类型（如intcharfloat等）或引用类型（如String、自定义类等）。数组是一种线性表数据结构，也就是说，数组中的元素可以通过一个整数索引来访问。数组的索引从0开始，这意味着对于长度为n的数组，合法的索引范围是从0到n-1。// 创建一个长度为 5 的整型数组在上面的例子中，numbers是一个包含 5 个整型元素的数组，索引从0到4。数组的大小在创建时就已经固定，因此无法动态扩展。
程序的格式框架与缩进
qq_57335683的博客
09-08 336
在上一课时中，我们介绍了 Python 的基本概念，并成功运行了第一个 Python 程序。本课时将深入探讨 Python 程序的基本结构、缩进的重要性，以及如何正确使用注释。通过本课时的学习，你将更好地理解 Python 代码的组织方式，并能够避免一些常见的编程错误。通过本课时的学习，你了解了 Python 程序的基本结构，认识到缩进在 Python 中的重要性，并学会了如何避免常见的缩进错误。缩进不仅是 Python 代码风格的一部分，而且是语法的一部分。这意味着如果缩进不正确，程序将无法正常运行。
可视化编程 制作在线点名程序，人工和随机生成两种模式
lfsysc的博客
09-06 813
"第一排第1位置","第一排第2位置","第一排第3位置","第一排第4位置","第一排第5位置","第一排第6位置",],["第四排第1位置","第四排第2位置","第四排第3位置","第四排第4位置","第四排第5位置","第四排第6位置",],["第五排第1位置","第五排第2位置","第五排第3位置","第五排第4位置","第五排第5位置","第五排第6位置",],["第六排第1位置","第六排第2位置","第六排第3位置","第六排第4位置","第六排第5位置","第六排第6位置",],
Python基础
flash的博客
09-06 1487
newline=''是一个重要的参数，用于防止在写入文件时在不同的操作系统上产生不必要的空行。将 json 转化为 python 对象，存放在内存中。python 文件名 参数1 参数2。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值