搭建卷积网络的基本函数（Pytorch框架入门篇）

已于 2022-07-27 20:59:39 修改
阅读量1.9k 收藏 3
点赞数 2
分类专栏： 深度学习 文章标签： python
于 2022-03-27 15:23:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47397155/article/details/123720495
版权

在这里插入图片描述

1、网络骨架
import torch.nn as nn
import torch
import torch.nn.functional as Function

class rgd_Net(nn.Module):
    def __init__(self):
        super().__init__()
        # self.conv1=nn.Conv2d(1,20,5)#用20个卷积核（5x5x1）去卷积一维的图(FxFx1)，输出为（w*w*20），w=(F-2*P+1)/S
        # self.conv2=nn.Conv2d(20,20,5)#用20个卷积核（5x5x20）去卷积一维的图(FxFx20)，输出为（w*w*20），w=(F-2*P+1)/S

    def forward(self,input):
        output=input+1
        return output
        # x1=Function.relu(self.conv1(x))
        # x2=Function.relu(self.conv2(x1))
        # return x2

rgd1=rgd_Net()
x=torch.tensor(1.0)
output=rgd1(x)
print(output)
2.1网络骨架需要添加的单元（一） 卷积操作

-例子1

# 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)
#
# # 卷积操作==stride
# output=F.conv2d(input,kernel,stride=1)# W=(F-2P+1)/S
# print(output)
# output2=F.conv2d(input,kernel,stride=2)
# print(output2)
#
# #卷积操作==padding
# output3=F.conv2d(input,kernel,padding=1)#stride默认为1
# print(output3)
  • 例子2
import torch
import torchvision
from torch.nn import Conv2d
from torch.utils.data import DataLoader
from torch import nn
from torch.utils.tensorboard import SummaryWriter

dataset=torchvision.datasets.CIFAR10("D:\cv_box\pytorch_learning",
                                     train=True,transform=torchvision.transforms.ToTensor(),
                                     download=True)
dataloader=DataLoader(dataset,batch_size=64)

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

rgd=Rgd()
print(rgd)#查看这个网络的样子

writer=SummaryWriter("nn.conv2d.logs")#使用tensorboard可视化显示
step=0
# 查看数据的每一个样子
for data in dataloader:#一批64张图片，每个data为64张图片
    imgs,targets=data
    output=rgd(imgs)
    print(imgs.shape)#torch.Size([64, 3, 32, 32])
    print(output.shape)#torch.Size([64, 6, 30, 30])
    writer.add_images("input",imgs,step)

    output_reshape=torch.reshape(output,(-1,3,30,30))   #[64, 6, 30, 30] >>> [64*2,3,30,30]
    writer.add_images("outputs",output_reshape,step)
    step+=1

在这里插入图片描述

2.2网络骨架需要添加的单元（二） 最大池化操作

参考链接
在这里插入图片描述

  • 我们经常使用maxpooling2d最大池化（下采样）===减少采样
    在这里插入图片描述
  • 这里需要说明一下池化层的 卷积核的尺寸=遍历移动的步长stride，假设kernel_size=3x3，则stride=3
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("D:\cv_box\pytorch_learning",
                                     train=False,
                                     transform=torchvision.transforms.ToTensor(),
                                     download=True)
dataloader=DataLoader(dataset,batch_size=64)

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

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

rgd=RGD()

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

writer.close()

在这里插入图片描述

2.3网络骨架需要添加的单元（三） 非线性激活操作
  • 给网络引入更多的非线性特征，符合更多的特征的模型，可以使得模型有更强的泛化的能力
  • 一个特别的例子，如果一个全是FC的网络没有非线性会导致，一个网络的所有层数变成一个层y=kx+b这种情况
    参考链接

在这里插入图片描述
参考链接
在这里插入图片描述

  • 例子1：relu
import torch

from torch import nn
from torch.nn import ReLU

input=torch.tensor([[1,-0.5],
                    [-1,3]])
print(input.shape)

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

class RGD(nn.Module):
    def __init__(self):
        super(RGD, self).__init__()
        self.relu1=ReLU()

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

rgd=RGD()
output=rgd(input_tensor)
print(output)

结果
在这里插入图片描述

  • 例子2 sigmoid
import torch
import torchvision
from torch import nn
from torch.nn import ReLU, Sigmoid
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

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

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


dataset=torchvision.datasets.CIFAR10("D:\cv_box\pytorch_learning",train=False,
                                     transform=torchvision.transforms.ToTensor(),
                                     download=True)
dataloader=DataLoader(dataset,batch_size=64)

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

writer.close()

在这里插入图片描述

2.4 网络骨架需要添加的单元（四） 正则化层操作
  • 正则化是一种为了减小测试误差的行为。
  • 当利用复杂的模型拟合数据，过拟合现象的出现导致模型的泛化能力下降时，使用正则化的适用可以降低模型的复杂度。
  • 正则化其实就是对原函数添加一个惩罚函数，即损失函数，每次为函数赋值数据集中数据点的时候，通过对原函数的相关参数加一定的惩罚函数（惩罚参数），来使得函数逐渐逼近于我们想要的最优解，并且在不同的情况可以相应改变这个惩罚参数，使得模型训练出来的数据会更加稀疏，更加合理，不会使得模型逼近于某一块区域

参考链接
在这里插入图片描述
参考链接

  • 作为正则化的一种形式
  • BN（批量归一化）解决梯度消失或者梯度爆炸
  • BN的本质原理：在网络的每一层输入的时候，又插入了一个归一化层，也就是先做一个归一化处理（归一化至：均值0、方差为1），然后再进入网络的下一层。不过文献归一化层，可不像我们想象的那么简单，它是一个可学习、有参数（γ、β）的网络层。
    在这里插入图片描述
2.5 网络骨架需要添加的单元（五） 线性层

参考链接

  • 就是我们常说的FC层（机器学习里就是MLP）
    在这里插入图片描述

在这里插入图片描述

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

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

dataloader=DataLoader(dataset,batch_size=64)


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

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

rgd=RGD()

for data in dataloader:
    imgs,targets=data
    print(imgs.shape)
    output_flatten=torch.flatten(imgs)
    print(output_flatten.shape)
    output_linear=rgd(output_flatten)
    print(output_linear.shape)

在这里插入图片描述

3.实战演练

构建以下模型
在这里插入图片描述

import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential


class RGD(nn.Module):
    def __init__(self):
        super(RGD, self).__init__()
        self.conv1=Conv2d(3,32,5,padding=2)# N=(W-F+2P)/S+1
        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)#结果为64*4*4

        self.flatten1=Flatten()#结果为1024

        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.flatten1(x)

        x=self.linear1(x)
        x=self.linear2(x)
        return x

rgd=RGD()
print(rgd)
input=torch.ones((64,3,32,32))
output=rgd(input)
print(output.shape)
  • 加入Sequential后,在forward里面代码简介很多
import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential


class RGD(nn.Module):
    def __init__(self):
        super(RGD, self).__init__()
        # self.conv1=Conv2d(3,32,5,padding=2)# N=(W-F+2P)/S+1
        # 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)#结果为64*4*4
        #
        # self.flatten1=Flatten()#结果为1024
        #
        # self.linear1=Linear(1024,64)
        # self.linear2=Linear(64,10)
        self.model1 = Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

    def forward(self,x):
        # x=self.conv1(x)
        # x=self.maxpool1(x)
        # x=self.conv2(x)
        # x=self.maxpool2(x)
        # x=self.conv3(x)
        # x=self.maxpool3(x)
        #
        # x=self.flatten1(x)
        #
        # x=self.linear1(x)
        # x=self.linear2(x)
        x=self.model1(x)
        return x

rgd=RGD()
print(rgd)
input=torch.ones((64,3,32,32))
output=rgd(input)
print(output.shape)
  • 可视化网络结构
import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
from torch.utils.tensorboard import SummaryWriter


class RGD(nn.Module):
    def __init__(self):
        super(RGD, self).__init__()
        # self.conv1=Conv2d(3,32,5,padding=2)# N=(W-F+2P)/S+1
        # 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)#结果为64*4*4
        #
        # self.flatten1=Flatten()#结果为1024
        #
        # self.linear1=Linear(1024,64)
        # self.linear2=Linear(64,10)
        self.model1 = Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

    def forward(self,x):
        # x=self.conv1(x)
        # x=self.maxpool1(x)
        # x=self.conv2(x)
        # x=self.maxpool2(x)
        # x=self.conv3(x)
        # x=self.maxpool3(x)
        #
        # x=self.flatten1(x)
        #
        # x=self.linear1(x)
        # x=self.linear2(x)
        x=self.model1(x)
        return x
        
writer=SummaryWriter("seq_logs")
step=0
input=torch.ones((64,3,32,32))
rgd=RGD()
writer.add_graph(rgd,input)
writer.close()

在这里插入图片描述

参考链接
参考链接

栋哥爱做饭
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
＜从零开始pytorch＞:04-torch卷积神经网络搭建(巨详细总结)
DDxuexi的博客
04-10 834
构建卷积神经网络 卷积神经网络中的输入层与传统的神经网络有些区别,需要重新设计,训练模块基本一致 1.读取数据 1.dataset --> DataLoader构建batch数据 - 既然是构建batch数据,故需要batch_size参数 2.搭建模型 - 1.是个类 - 2.定义__init__()函数 - 1.继承父类 - 2.定义用到的层 self.XXX = XXX 格式 - 3.forward(self,x)函数中调用__init__()函数中定义好
torch 卷积神经网络构建（3）
monk96的博客
11-12 294
(h - ksize + 2* padding）/stride + 1(28 - 5 + 4)/1 + 1 = 28 * 28 * 16 池化层（MaxPool）输出大小计算 O = (I - P) / S +1 数据读取
PyTorch基础（四）搭建简单卷积神经网络
zhiguo98的博客
05-26 3061
前一阶段一直在准备毕业论文和软设的考试，终于忙完了，接着学习PyTorch，这篇博客主要讲述，如何利用PyTorch搭建简单的CNN网络来识别mnist数据集。 搭建CNN网络的主要步骤如下： 1、导入库文件 2、数据处理 3、下载数据集 4、构建DataLoader 5、构建模型 6、构建损失 7、构建优化器 8、训练模型 9、测试模型 这也是我这一篇文章的目录，这也是pytorch搭建模型的一个基本流程。 1、导入库文件 import torch import numpy .
torch.nn神经网络（1）--卷积函数使用与卷积层
CYHR_2489的博客
10-04 685
torch.nn神经网络 1.nn.Module神经网络的使用 首先导入所需的模板： import torch from torch import nn 定义一个类，使其继承于nn.Module类： ①定义初始化函数时需要先完成其父类的初始化操作。 ②同时定义一个forward函数，进行神经网络正向传播的作用。 class ChenYu(nn.Module): def __init__(self): super().__init__() #首先要完成父类的初始化
pytorch 搭建网络步骤
前进！前进！！
03-16 1419
pytorch 搭建网络步骤 准备数据 定义网络结构model 定义损失函数 定义优化算法 optimizer （有是还要定义更新学习率：scheduler=StepLR() ) 训练 　　5.1 准备好tensor形式的输入数据和标签(可选) 　　5.2 前向传播计算网络输出output 和 计算损失函数loss 　　5.3 反向传播更新参数 　　　　以下三句话一句也不能少： 　　　　5.3.1 optimizer.zero_grad() 将上次迭代计算的梯度值清0 　　　　5.3.2 loss.ba
卷积神经网络基础 pytorch
02-17
卷积神经网络基础 本节我们介绍卷积神经网络的基础概念，主要是卷积层和池化层，并解释填充、步幅、输入通道和输出通道的含义。
pytorch_pytorch_卷积神经网络_
09-29
这个项目展示了如何在PyTorch中搭建和训练一个简单的卷积神经网络，用于解决MNIST手写数字识别问题。通过调整网络结构、参数设置和训练策略，可以进一步提升模型的性能。同时，PyTorch的动态计算图特性使其在模型...
深度学习实战6-卷积神经网络(Pytorch)+聚类分析实现空气质量与天气预测，数据集+代码，可直接运行
02-23
资源给大家带来一个利用卷积神经网络(pytorch版)实现空气质量的识别分类与预测。 我们知道雾霾天气是一种大气污染状态，PM2.5被认为是造成雾霾天气的“元凶”，PM2.5日均值越小，空气质量越好． 空气质量评价的主要...
通过CNN卷积神经网络-pytorch框架对猫的类别识别-含图片数据集.zip
最新发布
06-14
本代码是基于python pytorch环境安装的。 下载本代码后，有个requirement.txt文本，里面介绍了如何安装环境，环境需要自行配置。 或可直接参考下面博文进行环境安装。 ...如果实在不会安装的，可以直接下载免安装环境包...
利用pytorch搭建卷积神经网络（CNN）训练简单手写数字数据集（MNIST）
10-25
卷积神经网络（CNN，Convolutional Neural Network）是一种在图像处理领域广泛应用的深度学习模型。在本项目中，我们将使用PyTorch框架构建一个简单的CNN来识别MNIST数据集中的手写数字。MNIST是机器学习领域的一个...
pytorch快速搭建神经网络--函数自动求导（automatic differentiation）
weixin_43821216的博客
06-17 947
pytorch自动求导、求偏导数、实现终止对计算图的回溯。采用代码块的方式with torch.no_grad():, 这种方式非常适用于对模型进行预测的时候, 因为预测阶段不再需要对梯度进行计算.
使用 PyTorch 搭建网络 - model_py2篇
qq_43369406的博客
10-24 456
AlexNet model_py
Pytorch 搭建神经网络详细注释
百般回首曾经的相遇，留下的只是一缕残忆
07-14 848
在有一定神经网络的理论基础上，进行搭建神经网络的入门实践。
基于Pytorch搭建的神经网络资源汇总
chensen99的博客
05-18 527
2、AlexNet网络结构
动手学深度学习—卷积神经网络LeNet（代码详解）
qq_38473254的博客
08-15 1959
该模型去掉了最后一层的高斯激活，下面将一个大小为28×28的单通道（黑白）图像通过LeNet，打印每一层输出的形状。
神经网络来啦
Angeliaaa的博客
11-11 1219
本文以下面这个图为例，来实战演示神经网络中的卷积层、池化层、线性层的具体用法，使得由原来输入3@32x32（3渠道，宽32，高32）的数据，最终转化为了10的线性数据。并且采用两种方式去写，一种没有用Sequential，一种用了Sequential。发现，当神经网络需要很多层的变换的时候，往往使用Sequential会会更加的方便。 1.卷积层 由3@32X32（3渠道，宽32，高32）的数据转换成32@32X32（32渠道，宽32，高32）的代码实现是怎么样的呢？ 代码如下...
卷积神经网络（CNN）（中）
mez_Blog的博客
09-03 429
4.GoogleNet GoogleNet（也可称作Inception）是在2014年由Google DeepMind公式的研究员提出的一种全新的深度学习结构，并取得了ILSVRC2014比赛项目的第一名。GooleNet共有22层，并且没用全连接层，所以使用了更少的参数，在GooleNet前的AlexNet、VGG等结构，均通过增大网络的层数来获得更好的训练结果，但更深的层数同时会带来较多的负面效果，如过拟合、梯度消失、梯度爆炸等问题。 GoogleNet则是保证算力的情况下增大网络的深度和宽度，尤其
Python PyTorch6：卷积神经网络
Amzmks的博客
08-14 3301
例：使用卷积神经网络修改MNIST案例。 import torch import torch.nn as nn import torch.optim as optim from torchvision import datasets, transforms from torch.utils.data import DataLoader # 下载训练集 train_dataset = datasets.MNIST(root='./', tra
Pytorch 搭建卷积神经网络基础
bairw_Bella的博客
09-18 964
Pytorch搭建卷积神经网络基础 一，卷积层构建 1,1D卷积层构建 torch.nn.Conv1d(in_channels, out_channels, kernel_size, stride:= 1, padding= 0, dilation= 1, groups1, bias= True, padding_mode = 'zeros') 对输入信号上应用一维卷积。输入信号尺寸，卷积后的输出信号尺寸。N 是batch size,C表示通道数，L信号的序列长度。 卷积运算过程： ..
写一个卷积神经网络Python，pytorch框架
03-14
好的，以下是一个简单的卷积神经网络的 Python 代码，使用 PyTorch 框架： ```python import torch import torch.nn as nn import torch.nn.functional as F class ConvNet(nn.Module): def __init__(self): ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

栋哥爱做饭

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值