PyTorch学习第六天

已于 2024-02-06 23:54:08 修改
阅读量803 收藏 21
点赞数 9
分类专栏： pytorch 文章标签： pytorch 学习 深度学习
于 2024-02-06 23:53:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Theresahu49/article/details/136055603
版权

        卷积的stride默认为1，而池化默认为kernel_size(卷积核的大小） 

        Floor向下取整，ceiling向上取整

一、卷积(conv2d的应用)

        224*224*3 -> 224*224*64   输出通道为64（可以理解为64种结果），说明需要64个卷积核。

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("../data", 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


tudui = Tudui()
print(tudui)

writer = SummaryWriter("logs")

step = 0
for data in dataloader:
    imgs, targrts = data
    output = tudui(imgs)
    print(imgs.shape)
    print(output.shape)
    # torch.Size([64, 3, 32, 32])
    writer.add_images("input", imgs, step)
    # torch.Size([64, 6, 30, 30]) -> 令batch_size变多，channel就会变少  [xxx, 3, 30, 30]
    #  AssertionError：assert I.ndim == 4 and I.shape[1] == 3 即6个channel不知道怎么显示
    # -1的意思是可以根据后面的3、30、30自动计算这个batch_size
    output = torch.reshape(output, (-1, 3, 30, 30))
    writer.add_images("output", output, step)
    step = step + 1

writer.close()

二、最大池化的使用

        使用：最大池化是取9宫格里的最大值，减少数据量，使少数据量也能保留所需信息

        ceil_mode：False = Floor向下取整（不保留），True = ceiling向上取整（保留）

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

dataloader = DataLoader(dataset, batch_size=64)

#  "max_pool2d" not implemented for 'Long' 解决：变为浮点数
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)

# batch_size,channel,w,h
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()
# output = tudui(input)
# print(output)

# ../表示返回上级目录
writer = SummaryWriter("logs_maxpool")
step = 0
for data in dataloader:
    imgs, targets = data
    writer.add_images("input", imgs, step)
    output = tudui(imgs)
    writer.add_images("output",output,step)
    step = step + 1

writer.close()

三、非线性激活（如ReLU、Sigmoid）

        作用：引入非线性特征

        ReLU：input>0就取input自身的值，input<0就取0; inplace为True，就是对原来位置的值进行替换，为False，则不替换原来位置的值

        Sigmoid：1/(1+exp(-x))

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

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

dataset = torchvision.datasets.CIFAR10("../data",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.relu1 = ReLU()
        self.sigmoid1 = Sigmoid()

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

tudui = Tudui()

writer = SummaryWriter("logs_relu")
step = 0

for data in dataloader:
    imgs, targets = data
    writer.add_images("input",imgs,step)
    output = tudui(imgs)
    writer.add_images("output", output, step)
    step = step + 1
# output = tudui(input)
# print(output)
writer.close()

四、线性层及其他层介绍

（1）正则化层（Normalization layer）

        作用：加快训练速度

        参数：

  • num_features – C from an expected input of size (N,C,H,W) channe

（2）线性层（Linear layer） 

import torch
import torchvision.datasets
from torch import nn
from torch.nn import Linear
from torch.utils.data import DataLoader

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

dataloader = DataLoader(dataset, batch_size=64, drop_last=True)    #丢弃无法整除的数据

class Tudui(nn.Module):
    def __init__(self):
        super(Tudui,self).__init__()
        self.linear1 = Linear(196608, 10)  #input_feature对应于reshape得到的-1，output_feature设置为10

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


tudui = Tudui()

for data in dataloader:
    imgs, targets = data
    print(imgs.shape)
    # output = torch.reshape(imgs, (1,1,1,-1))   #变成一行数据，-1为自动计算  等价于torch.flatten(imgs)
    output = torch.flatten(imgs)
    print(output.shape)
    output = tudui(output)
    print(output.shape)

五、Sequential的使用及搭建小实战

        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)   # kernel_size为2
        # self.conv2 = Conv2d(32, 32, 5, padding=2)  # 图片保持不变 padding=（kernel_size - 1）/2
        # self.maxpool2 = MaxPool2d(2)
        # self.conv3 = Conv2d(32, 32, 5, padding=2)
        # self.maxpool3 = MaxPool2d(2)
        # self.flatten = Flatten()
        # # 测试前 self.linear1 = Linear(1024, 64)
        # self.linear1 = Linear(512, 64)
        # self.linear2 = Linear(64, 10)

        # 使用Sequential
        self.model1 = Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(512, 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)
        # # 假设未知flatten的结果是1024   得到torch.Size([64, 512]) ，batch_size有64张图片  ,每张图片都展成1*512
        # x = self.linear1(x)
        # x = self.linear2(x)

        # 使用Sequential
        x = self.model1(x)
        return x


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


writer = SummaryWriter("../logs_seq")
writer.add_graph(tudui, input)   #第一个参数是模型名
writer.close()

   六、损失函数（loss）与反向传播    

        loss函数的作用：

                1、计算实际输出和目标之间的差距；

                2、用来指导output去接近target，是训练的依据，为我们更新输出提供了一定的依据（反向传播）  grad（梯度，weight根据梯度的方向下降改变以降低loss）：反向传播计算梯度，根据梯度来更新参数，实现loss最小化

        （1）常用函数

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

dataset = torchvision.datasets.CIFAR10("../data", train=False, transform= torchvision.transforms.ToTensor(),
                                       download=True)
dataloader = DataLoader(dataset, batch_size=1)
class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()
        self.model1 = Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(512, 64),
            Linear(64, 10)
        )

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

loss = nn.CrossEntropyLoss()
tudui = Tudui()
for data in dataloader:
    imgs, targets = data
    outputs = tudui(imgs)
    # print(outputs)
    # print(targets)
    result_loss = loss(outputs, targets)   # 是对result_loss这个变量进行反向传播
    result_loss.backward()   # 反向传播
    print(result_loss)

        （2）引入反向传播

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

dataset = torchvision.datasets.CIFAR10("../data", train=False, transform= torchvision.transforms.ToTensor(),
                                       download=True)
dataloader = DataLoader(dataset, batch_size=1)
class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()
        self.model1 = Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(512, 64),
            Linear(64, 10)
        )

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

loss = nn.CrossEntropyLoss()
tudui = Tudui()
for data in dataloader:
    imgs, targets = data
    outputs = tudui(imgs)
    # print(outputs)
    # print(targets)
    result_loss = loss(outputs, targets)   # 是对result_loss这个变量进行反向传播
    result_loss.backward()   # 反向传播
    print(result_loss)

七、优化器（torch.optim）

import torch.optim
import torchvision.datasets
from torch import nn
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linear
from torch.utils.data import DataLoader

dataset = torchvision.datasets.CIFAR10("../data", train=False, transform= torchvision.transforms.ToTensor(),
                                       download=True)
dataloader = DataLoader(dataset, batch_size=1)
# 网络模型：土堆
class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()
        self.model1 = Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(512, 64),
            Linear(64, 10)
        )

    def forward(self, 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):
    running_loss = 0.0   #这一轮loss的总和
    # 这只是一次学习
    for data in dataloader:
        imgs, targets = data
        outputs = tudui(imgs)
        result_loss = loss(outputs, targets)   # 是对result_loss这个变量进行反向传播
        # 1、网络中每一个可以调节的参数的梯度设置为0
        optim.zero_grad()
        # 2、反向传播计算梯度
        result_loss.backward()
        # 3、对每一个参数调优
        optim.step()
        running_loss = running_loss +result_loss
    print(running_loss)

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

import torchvision.datasets
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)   # 需要训练，网络参数是训练好的

print('ok')

# 可以打印出训练好的参数
print(vgg16_true)

train_data = torchvision.datasets.CIFAR10('../data', train=True,transform=torchvision.transforms.ToTensor(),
                                          download=True)

# 1、修改网络模型，使in_features为1000，out_features为10
# modele是指Conv2d、Linear这种
vgg16_true.add_module('add_linear', nn.Linear(1000, 10))
print(vgg16_true)

# 2、修改网络模型，将增加的module放到classifier中
vgg16_true.classifier.add_module('add_linear', nn.Linear(1000, 10))
print(vgg16_true)

# 3、在未预训练的模型中修改
print(vgg16_false)
vgg16_false.classifier[6] = nn.Linear(4096, 10)
print(vgg16_false)

九、网络模型的保存与读取

（1）保存方式

import torch
import torchvision
from torch import nn

vgg16 = torchvision.models.vgg16(pretrained = False)
# 保存方式1  保存了模型结构 + 模型参数
torch.save(vgg16, "vgg16_method1.pth")

# 保存方式2  将vgg16模型中的参数保存为字典[[[],[]],[]]（官方推荐）
torch.save(vgg16.state_dict(), "vgg16_method2.pth")

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

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


tudui = Tudui()
torch.save(tudui, "tudui_method1.pth")

（2）读取方式

import torch
import torchvision.models
from module_save import *

# 方式1-》保存方式1.加载模型
model = torch.load("vgg16_method1.pth")
print(model)

# 方式2-》保存方式2.加载模型
vgg16 = torchvision.models.vgg16(pretrained=False)
vgg16.load_state_dict(torch.load("vgg16_method2.pth"))
print(vgg16)

# 陷阱1 Can't get attribute 'Tudui' on <module '__main__' from 'G:\\learn_pytorch\\module_load.py'>
# model = torch.load("tudui_method1.pth")
# print(model)

# 解决陷阱1  无需创建模型tudui = Tudui()，但是要定义模型
class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()
        self.conv1 = nn.Conv2d(3, 64, kernel_size=3)

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


model2 = torch.load("tudui_method1.pth")
print(model2)

# 解决陷阱1  或者from module_save import *

LittleBLUE12
关注
  • 9
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Pytorch实用教程：Pytorch中tensor.size()用法 | .squeeze()方法 | .unsqueeze()方法
惊鸿若梦一书生
04-07 1152
在 PyTorch 中，`tensor.size(0)` 是用来获取张量（Tensor）第一个维度的大小的一种方法。这里的“0”指的是第一个维度的索引，因为在 Python 和 PyTorch 中索引是从 0 开始的。换句话说，`size(0)` 返回的是张量在其第一个维度上的元素个数。
pytorch中的size()和shape()
明德zhuang
03-27 6419
pytorch中的size()和shape()的使用 示例： import torch from torch import tensor a = torch.tensor([[[0,1,2,3],[10,11,12,13]],[[20,21,22,23],[30,31,32,33]]]) print(a.shape) print(a.size())
PyTorch基础学习
qq_42504905的博客
04-19 1748
1.tensor tensor中最常使用的就是FloatTensor和LongTensor，分别代表了浮点数和整型 注意：定义一个张量tensor时，T可以大写可以小写，代表的是同样的意思，但定义整型和浮点数的时候F和T一类的必须要大写 Tensor是类，是FloatTensor的别名。 tensor是函数，可根据 detype指定类别。 两者在生成0维变量时有区别。 一般情况下用tensor即可。 1.1tensor的分类 张量tensor分为0维张量1维张量二维张量和多维张量 0维张量就是标量 a =
PyTorch基础知识学习
YKbsmn的博客
08-16 1589
Pytorch基础知识（Tensor的创建和操作、自动求导
积跬步至千里 || PyTorch 中 shape 和 size 属性的区别
weixin_40234309的博客
07-03 1381
ok
PyTorch学习笔记-3.PyTorch模型搭建
ruoqi23的博客
08-03 1231
3.PyTorch模型搭建 3.1.卷积层 3.1.1.卷积-1d/2d/3d 卷积运算：卷积核在输入信号（图像）上滑动，相应位置上进行乘加 卷积核：又称为滤波器，过滤器，可认为是某种模式，某种特征。 卷积过程类似于用一个模版去图像上寻找与它相似的区域，与卷积核模式越相似，激活值越高，从而实现特征提取 例如： AlexNet卷积核可视化，发现卷积核学习到的是边缘，条纹，色彩这一些细节模式 卷积维度：一般情况下，卷积核在几个维度上滑动，就是几维卷积 下面分别为一维、二维、三维卷积示意图 .
B站刘二大人Pytorch课程学习笔记及课后作业
09-09
第六讲 逻辑斯蒂回归模型 第七讲 处理多维特征的输入 第八讲 加载数据集 第九讲 多分类问题--softmax classifier 第十讲 卷积神经网络（基础篇） 第十一讲 卷积神经网络（高级篇） 学完刘二大人的课程和此学习笔记，...
PytorchTraining:使用Pytorch进行深度学习的练习文件
04-24
CNN架构卷积和池化辍学CNN分类转移学习第二天单元6递归神经网络（RNN） 什么是RNN？ RNN架构长期依赖LSTM和GRU RNN分类RNN回归单元7强化学习（RL） 什么是强化学习？ Q学习OpenAI体育馆深度Q网络（DQN） 单元8自然...
三天循序渐进掌握PyTorch教程（附带完整源码及数据集）
06-09
第六章结合Kaggle中一个经典的比赛，实现一个深度学习中比较简单的图像二分类问题。 第七章为读者讲解了当前最火爆的生成对抗网络（GAN），带领读者从头实现一个动漫头像生成器，能够利用GAN生成风格多变的动漫头像...
bilibili_回归问题实战（第六课） 深度学习与PyTorch入门实战_龙良曲 .rar
06-20
深度学习与PyTorch入门实战_龙良曲 bilibili_回归问题实战（第六课） 1 data.csv 用于回归的数据数据 2 gd.py 回归实战运行代码 3 lesseon4.pdf 课件
torch.size()
热门推荐
Suzerk的博客
02-26 2万+
torch.size()查看tensor的尺寸； 1-6行：两个[]两个数字，第一层[]中以,分割包含两个[],所以2；其中每一个[]中又有3个数，所以torch.Size的第二个数是三。 8-9行：在1-6基础上再加一个[]，所以第一个数字是1。 ...
【PyTorch】获取Tensor大小，size与shape的区别
算法与编程之美
08-20 6778
Tensor是PyTorch的重要概念之一，获取Tensor的大小的方法主要有两种，其一是size，其二是shape，那么两种方法的区别是什么呢？
PyTorch深度学习快速入门教程（绝对通俗易懂！！！）
qq_44428997的博客
10-07 1万+
Pytorch快速入门
torch里的分组卷积
baoxin1100的博客
03-11 782
普通卷积 如果输入特征的通道是 32，希望输出特征的通道是 64，对于 3*3 的普通卷积来说，卷积层设置为： conv = torch.nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3) 我们查看卷积核的参数量 print(conv.weight.shape) # torch.size([64,32,3,3]) 所以普通卷积的参数量是 64 ×\times× 32 ×\times× 3 ×\times× 3 = 18432 个参数 分组卷
Python 中 numpy 和 pytorch 的size、shape 分析
bigbigvegetable的博客
03-17 1130
numpy array 类型 # -*- coding: utf-8 -*- import torch import numpy as np a = np.array([[1, 2, 3, 4], [1, 2, 3, 4]]) print(len(a)) print(a.size) print(a.shape) 输出为： 2 8 (2, 4) 对于 numpy array 来说，shape、size 都是 array 的属性； pytorch tensor 类型 tensor = torch.rand
Pytorch张量操作
FFTang的博客
11-30 177
Pytorch张量操作，包括：数据操作，运算符，广播，索引切片，转换类型，张量运算
Python pytorch的一个简单封装(最简调参,自适应Size)
qq_39935495的博客
07-24 1116
PyTorch是一个开源的Python机器学习库，基于Torch，用于自然语言处理等应用程序。2017年1月，由Facebook人工智能研究院（FAIR）基于Torch推出了PyTorch。它是一个基于Python的可续计算包，提供两个高级功能1、具有强大的GPU加速的张量计算（如NumPy）。2、包含自动求导系统的深度神经网络。这是一个基于Pytorch的框架。...
【Pytorch】常用层的说明(4)
littlemichelle
06-28 271
目录 一、卷积层 二、最大池化层 三、非线性激活 四、线性层及其他层介绍 五、搭建一个小网络 六、Sequential的使用 一、卷积层 https://pytorch.org/docs/stable/generated/torch.nn.Conv2d.html#torch.nn.Conv2d https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md torch.nn.Conv2d(in_channels, #
小土堆pytorch教程学习笔记P21
快乐卷心菜的博客
04-02 256
P21.神经网络-线性层及其他层介绍 Pytorch官网 -> Docs -> Pytorch -> torch.nn -> Linear Layers class torch.nn.Linear(in_features, out_features, bias=True, device=None, dtype=None) Parameters in_features – size of each input sample out_features –
pytorch学习指南
最新发布
09-19
了解如何创建、操作和处理张量是学习 PyTorch 的第一步。 3. 模型构建：PyTorch 提供了灵活的 API，用于构建深度神经网络模型。你可以通过定义网络的结构和层来创建自己的模型，也可以使用预训练的模型。 4. 数据...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值