PyTorch学习笔记(三) ---- 神经网络

最新推荐文章于 2023-07-17 23:42:46 发布
最新推荐文章于 2023-07-17 23:42:46 发布
阅读量2k 收藏 16
点赞数 6
分类专栏： PyTorch 文章标签： Pytorch pytorch 实现神经网络 pytorch 损失函数 更新网络的参数 Pytorch 反向传播
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/john_bh/article/details/106297164
版权

转载请注明作者和出处： http://blog.csdn.net/john_bh/

文章目录


PyTorch搭建神经网络可以通过 torch.nn 包来构建。一个 nn.Module 包括层和一个方法 forward(input) 它会返回输出(output)。例如，看一下数字图片识别的网络：

在这里插入图片描述
这是一个简单的前馈神经网络，它接收输入，让输入一个接着一个的通过一些层，最后给出输出。

一个典型的神经网络训练过程包括以下几点：
1.定义一个包含可训练参数的神经网络
2.迭代整个输入
3.通过神经网络处理输入
4.计算损失(loss)
5.反向传播梯度到神经网络的参数
6.更新网络的参数，典型的用一个简单的更新方法：weight = weight - learning_rate *gradient

1.定义神经网络

# -*- coding:utf-8 -*-
import torch
import torch.nn as nn
import torch.nn.functional as F

# 1.定义神经网络

class Net(nn.Module):
    def __init__(self):
        super(Net,self).__init__() #对继承自父类的属性进行初始化
        
        self.conv1 = nn.Conv2d(1,6,5) # 1 input image channel, 6 output channels, 5x5 square convolution
        self.conv2 = nn.Conv2d(6,16,5)
        
        self.fc1 = nn.Linear(16*5*5,120)
        self.fc2 = nn.Linear(120,84)
        self.fc3 = nn.Linear(84,10)
        
    def forward(self,x):
        x = F.max_pool2d(F.relu(self.conv1(x)),(2,2)) # Max pooling over a (2, 2) window
        x = F.max_pool2d(F.relu(self.conv2(x)),2)  # If the size is a square you can only specify a single number
        x =x.view(-1,self.num_flat_features(x))#view函数将张量x变形成一维的向量形式，总特征数并不改变，为接下来的全连接作准备。
        x=F.relu(self.fc1(x))
        x=F.relu(self.fc2(x))
        x=self.fc3(x)
        
        return x
    
    def num_flat_features(self,x):
        size=x.size()[1:]
        num_features=1
        for s in size:
            num_features *=s
        
        return num_features
    
net=Net()
print(net)

输出：

Net(
(conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))
(conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
(fc1): Linear(in_features=400, out_features=120, bias=True)
(fc2): Linear(in_features=120, out_features=84, bias=True)
(fc3): Linear(in_features=84, out_features=10, bias=True)
)

# 一个模型可训练的参数可以通过调用 net.parameters() 返回
params=list(net.parameters())
print(len(params))
print(params[0].size())

输出：

10
torch.Size([6, 1, 5, 5])

2.迭代整个输入

随机生成一个 32x32 的输入。注意：期望的输入维度是 32x32 。为了使用这个网络在 MNIST 数据及上，你需要把数据集中的图片维度修改为 32x32。

# -*- coding:utf-8 -*-
import torch
import torch.nn as nn
import torch.nn.functional as F

# 1.定义神经网络

class Net(nn.Module):
    def __init__(self):
        super(Net,self).__init__() #对继承自父类的属性进行初始化
        
        self.conv1 = nn.Conv2d(1,6,5) # 1 input image channel, 6 output channels, 5x5 square convolution
        self.conv2 = nn.Conv2d(6,16,5)
        
        self.fc1 = nn.Linear(16*5*5,120)
        self.fc2 = nn.Linear(120,84)
        self.fc3 = nn.Linear(84,10)
        
    def forward(self,x):
        x = F.max_pool2d(F.relu(self.conv1(x)),(2,2)) # Max pooling over a (2, 2) window
        x = F.max_pool2d(F.relu(self.conv2(x)),2)  # If the size is a square you can only specify a single number
        x =x.view(-1,self.num_flat_features(x))#view函数将张量x变形成一维的向量形式，总特征数并不改变，为接下来的全连接作准备。
        x=F.relu(self.fc1(x))
        x=F.relu(self.fc2(x))
        x=self.fc3(x)
        
        return x
    
    def num_flat_features(self,x):
        size=x.size()[1:]
        num_features=1
        for s in size:
            num_features *=s
        
        return num_features
    
net=Net()
#2.迭代整个输入
input = torch.randn(1, 1, 32, 32)
out = net(input)
print(out)

输出：

tensor([[-0.0142, -0.1713, -0.0990, 0.0307, 0.2069, -0.0126, 0.1045, 0.0479,
0.0644, -0.1227]], grad_fn=)

3.通过神经网络处理输入

# -*- coding:utf-8 -*-
import torch
import torch.nn as nn
import torch.nn.functional as F

# 1.定义神经网络

class Net(nn.Module):
    def __init__(self):
        super(Net,self).__init__() #对继承自父类的属性进行初始化
        
        self.conv1 = nn.Conv2d(1,6,5) # 1 input image channel, 6 output channels, 5x5 square convolution
        self.conv2 = nn.Conv2d(6,16,5)
        
        self.fc1 = nn.Linear(16*5*5,120)
        self.fc2 = nn.Linear(120,84)
        self.fc3 = nn.Linear(84,10)
        
    def forward(self,x):
        x = F.max_pool2d(F.relu(self.conv1(x)),(2,2)) # Max pooling over a (2, 2) window
        x = F.max_pool2d(F.relu(self.conv2(x)),2)  # If the size is a square you can only specify a single number
        x =x.view(-1,self.num_flat_features(x))#view函数将张量x变形成一维的向量形式，总特征数并不改变，为接下来的全连接作准备。
        x=F.relu(self.fc1(x))
        x=F.relu(self.fc2(x))
        x=self.fc3(x)
        
        return x
    
    def num_flat_features(self,x):
        size=x.size()[1:]
        num_features=1
        for s in size:
            num_features *=s
        
        return num_features
    
net=Net()
#2.迭代整个输入
input = torch.randn(1, 1, 32, 32)
out = net(input)

#3.通过神经网络处理输入
#把所有参数梯度缓存器置零，用随机的梯度来反向传播
net.zero_grad()
out.backward(torch.randn(1,10))

4.计算损失(loss)

一个损失函数需要一对输入：模型输出和目标，然后计算一个值来评估输出距离目标有多远。有一些不同的损失函数在 nn 包中。一个简单的损失函数就是 nn.MSELoss ，这计算了均方误差。

例如：

# -*- coding:utf-8 -*-
import torch
import torch.nn as nn
import torch.nn.functional as F

# 1.定义神经网络

class Net(nn.Module):
    def __init__(self):
        super(Net,self).__init__() #对继承自父类的属性进行初始化
        
        self.conv1 = nn.Conv2d(1,6,5) # 1 input image channel, 6 output channels, 5x5 square convolution
        self.conv2 = nn.Conv2d(6,16,5)
        
        self.fc1 = nn.Linear(16*5*5,120)
        self.fc2 = nn.Linear(120,84)
        self.fc3 = nn.Linear(84,10)
        
    def forward(self,x):
        x = F.max_pool2d(F.relu(self.conv1(x)),(2,2)) # Max pooling over a (2, 2) window
        x = F.max_pool2d(F.relu(self.conv2(x)),2)  # If the size is a square you can only specify a single number
        x =x.view(-1,self.num_flat_features(x))#view函数将张量x变形成一维的向量形式，总特征数并不改变，为接下来的全连接作准备。
        x=F.relu(self.fc1(x))
        x=F.relu(self.fc2(x))
        x=self.fc3(x)
        
        return x
    
    def num_flat_features(self,x):
        size=x.size()[1:]
        num_features=1
        for s in size:
            num_features *=s
        
        return num_features
    
net=Net()
#2.迭代整个输入
input = torch.randn(1, 1, 32, 32)
out = net(input)

# 4.计算损失值
# 一个损失函数需要一对输入：模型输出和目标，然后计算一个值来评估输出距离目标有多远。有一些不同的损失函数在 nn 包中。
# 一个简单的损失函数就是 nn.MSELoss ，这计算了均方误差。
target=torch.randn(10)
target=target.view(1,-1)
criterion=nn.MSELoss()

loss=criterion(out,target)
print(loss)

输出：

tensor(1.2788, grad_fn=<MseLossBackward>)

现在，如果你跟随损失到反向传播路径，可以使用它的 .grad_fn 属性，你将会看到一个这样的计算图：

input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d
-> view -> linear -> relu -> linear -> relu -> linear
-> MSELoss
-> loss

所以，当我们调用 loss.backward()，整个图都会微分，而且所有的在图中的requires_grad=True 的张量将会让他们的 grad 张量累计梯度。

为了演示，我们将跟随以下步骤来反向传播。

print(loss.grad_fn)  # MSELoss
print(loss.grad_fn.next_functions[0][0])  # Linear
print(loss.grad_fn.next_functions[0][0].next_functions[0][0])  # ReLU

输出：

<MseLossBackward object at 0x0000023E639F6400>
<AddmmBackward object at 0x0000023E639F6400>
<AccumulateGrad object at 0x0000023E637EF978>

5.反向传播梯度到神经网络的参数

为了实现反向传播损失，我们所有需要做的事情仅仅是使用 loss.backward()。你需要清空现存的梯度，要不然梯度将会和现存的梯度累计到一起。

现在我们调用 loss.backward() ，然后看一下 con1 的偏置项在反向传播之前和之后的变化。

# -*- coding:utf-8 -*-

import torch
import torch.nn as nn
import torch.nn.functional as F

# 1.定义神经网络

class Net(nn.Module):
    def __init__(self):
        super(Net,self).__init__() #对继承自父类的属性进行初始化
        
        self.conv1 = nn.Conv2d(1,6,5) # 1 input image channel, 6 output channels, 5x5 square convolution
        self.conv2 = nn.Conv2d(6,16,5)
        
        self.fc1 = nn.Linear(16*5*5,120)
        self.fc2 = nn.Linear(120,84)
        self.fc3 = nn.Linear(84,10)
        
    def forward(self,x):
        x = F.max_pool2d(F.relu(self.conv1(x)),(2,2)) # Max pooling over a (2, 2) window
        x = F.max_pool2d(F.relu(self.conv2(x)),2)  # If the size is a square you can only specify a single number
        x =x.view(-1,self.num_flat_features(x))#view函数将张量x变形成一维的向量形式，总特征数并不改变，为接下来的全连接作准备。
        x=F.relu(self.fc1(x))
        x=F.relu(self.fc2(x))
        x=self.fc3(x)
        
        return x
    
    def num_flat_features(self,x):
        size=x.size()[1:]
        num_features=1
        for s in size:
            num_features *=s
        
        return num_features
    
net=Net()
#2.迭代整个输入
input = torch.randn(1, 1, 32, 32)
out = net(input)
out.backward(torch.randn(1,10))
out=net(input)

target=torch.randn(10)
target=target.view(1,-1)
criterion=nn.MSELoss()

loss=criterion(out,target)
# print(loss)

# 5.反向传播梯度到神经网络的参数
# 为了实现反向传播损失，我们所有需要做的事情仅仅是使用 loss.backward()。你需要清空现存的梯度，要不然梯度将会和现存的梯度累计到一起。
# 现在我们调用 loss.backward() ，然后看一下 con1 的偏置项在反向传播之前和之后的变化。
net.zero_grad()

print('conv1.bias.grad before backward')
print(net.conv1.bias.grad)

loss.backward()

print('conv1.bias.grad after backward')
print(net.conv1.bias.grad)

输出：

conv1.bias.grad before backward tensor([0., 0., 0., 0., 0., 0.])
conv1.bias.grad after backward tensor([ 9.7322e-03, -6.5905e-05,
2.7879e-03, -2.1420e-03, 2.8334e-03,
1.1446e-02])

6.更新网络的参数

更新神经网络参数：最简单的更新规则就是随机梯度下降

weight = weight - learning_rate * gradient

在神经网络中，可以使用torch.optim 调用常用的方法： SGD, Nesterov-SGD, Adam, RMSProp等

# -*- coding:utf-8 -*-

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim

# 1.定义神经网络
class Net(nn.Module):
    def __init__(self):
        super(Net,self).__init__() #对继承自父类的属性进行初始化
        
        self.conv1 = nn.Conv2d(1,6,5) # 1 input image channel, 6 output channels, 5x5 square convolution
        self.conv2 = nn.Conv2d(6,16,5)
        
        self.fc1 = nn.Linear(16*5*5,120)
        self.fc2 = nn.Linear(120,84)
        self.fc3 = nn.Linear(84,10)
        
    def forward(self,x):
        x = F.max_pool2d(F.relu(self.conv1(x)),(2,2)) # Max pooling over a (2, 2) window
        x = F.max_pool2d(F.relu(self.conv2(x)),2)  # If the size is a square you can only specify a single number
        x =x.view(-1,self.num_flat_features(x))#view函数将张量x变形成一维的向量形式，总特征数并不改变，为接下来的全连接作准备。
        x=F.relu(self.fc1(x))
        x=F.relu(self.fc2(x))
        x=self.fc3(x)
        
        return x
    
    def num_flat_features(self,x):
        size=x.size()[1:]
        num_features=1
        for s in size:
            num_features *=s
        
        return num_features
    
net=Net()
#2.迭代整个输入
input = torch.randn(1, 1, 32, 32)
target=torch.randn(10)
target=target.view(1,-1)

criterion=nn.MSELoss()
net.zero_grad() #清空现存的梯度

#6.使用优化函数，更新神经网络参数
optimizer=optim.SGD(net.parameters(),lr=0.01)
optimizer.zero_grad()# zero the gradient buffers

output=net(input) #网络处理输入
loss=criterion(output,target) #计算losss
loss.backward() #调用反向传播

optimizer.step() # Does the update
john_bh
关注
  • 6
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ElitesAI·动手学深度学习PyTorch版学习笔记-卷积神经网络基础；leNet；卷积神经网络进阶
01-20
宅家中看到Datawhale的学习号召，在大牛云集的群上找到了一个很佛系的小组，战战兢兢地开始了小白的深度学习之旅。感谢Datawhale、伯禹教育、和鲸科技，感谢课程制作者、组织者、各位助教以及其他志愿者！ 1 卷积神经网络基础 1.1 二维卷积 本小节介绍了二维卷积，主要用于图像数据（刚好是二维的数据）处理。 二维卷积通过输入二维数据和二维核数据的运算（卷积），得到一个小于输入数据的二维输出数据，但是该输出数据依然部分保存了输入数据的信息。输出的二维数据可以看作输入数据的一个缩略图，也叫特征图。对输出有影响的所有可能的输入区域叫做输出数据的感受野（感受域？） 1.2 步幅和填充 卷积
pytorch 学习笔记 part8 卷积神经网络基础
01-20
卷积层的实现 主要参数： 1.in_channels (python:int) – Number of channels in the input imag 2.out_channels (python:int) – Number of channels produced by the convolution 3.kernel_size (python:int or ...
深度学习之pytorch（三）
wzw的博客
08-17 237
神经网络的结构 最常见的神经网络是全连接神经网络，其中两个相邻层中每一个层的所有神经元和另外一个层的所有神经元都是相连的，每个层内部的神经元不相连。 N层神经网络是不会把输入层算进去的，因此一个一层的神经网络是指没有隐藏层，只有输入和输出层的神经网络，就像logistic回归就是一个一层的神经网络。 模型的表示能力与容量 这里出现了一个名词叫做：过拟合：在忽略了潜在的数据关系的前提之下，将噪音的干扰放大了。 深度学习的基石：反向传播算法 它是一个有效地求解梯度的算法，本质上其实就是一个链式求导法则的应用。
pytorch学习11之参数管理
tyutwuxuan的博客
07-17 138
深度学习框架没有提供需要的初始化方法。 几种方法访问、初始化和绑定模型参数。 使用自定义初始化方法。
Pytorch基本使用—参数初始化
weixin_51691064的博客
07-11 2861
在深度学习中，零初始化（Zero Initialization）：将所有权重和偏置初始化为0。然而，这种方法会导致所有神经元具有相同的输出，无法破坏对称性，因此不常用。随机初始化（Random Initialization）：将权重和偏置随机初始化为较小的随机值。这种方法可以打破对称性，但并不能保证初始化的权重和偏置能够适应网络的输入和输出分布。Xavier初始化（Xavier Initialization）：根据每一层的输入维度和输出维度的大小来进行初始化。
Pytorch学习之神经网络参数管理
ting_qifengl的博客
05-25 2437
这里记录一下pytorch神经网络参数管理方法(参数访问、参数初始化、参数绑定)，方便自己和需要的朋友学习、查阅。 一、参数访问 1.1 访问指定层的指定参数 首先构建一个多层感知机。 import torch from torch import nn net = nn.Sequential(nn.Linear(2, 4), nn.ReLU(), nn.Linear(4, 1)) X = torch.rand(size=(2, 2)) 当通过nn.Sequential定义模型时， 我们可以通过
PyTorch —— 神经网络权重初始化
你的思想出了问题的博客
05-16 5928
权重初始化 神经网络从错误中学习，但是错误要能够被定位到。如果不能定位到错误那么就无法改正。 对于神经网络中的参数来说，如果所有参数全部一样（比如初始化为全0），那么就面临一个问题：梯度往哪里下降是最快呢？？ 看一个例子 神经网络很难判断哪些权重需要更改，因为每个层级的神经元输出是一样的。为了避免神经元具有相同的输出，我们使用独特权重。我们还可以随机选择权重，避免每个周期后的损失都陷于局部最低点...
Pytorch学习笔记（二）---- 神经网络搭建
weixin_30731287的博客
03-28 241
记录如何用Pytorch搭建LeNet-5，大体步骤包括：网络的搭建->前向传播->定义Loss和Optimizer->训练 # -*- coding: utf-8 -*- # All codes and comments from <<深度学习框架Pytorch入门与实践>> # Code url : https://github.com/zh...
pytorch学习笔记（二）
qq_35700335的博客
08-13 3439
pytorch学习笔记（二） 1.前言 在之前我们已经粗略看了看autograd函数，现在我们要用到的toech.nn是基于autograd来定义和区分各种模型。 一个简单的典型神经网络训练过程通常包含以下过程： 定义一个有一些可学习参数的神经网络 循环训练数据集 处理网络中的输入 计算损失（输出与正确结果间的差别） 回传梯度给神经网络中的参数 更新网络的权重，典型的简单更新规则： ...
pytorch入门学习——构建简单cnn关于num_flat_features、x.size()[1:]的作用
xyzxyzxyz1999的博客
07-23 5604
pytorch入门学习——构建简单cnn关于num_flat_features、x.size()[1:]的作用 初次学习官方入门教程 初次学习，好多不懂，上网找到了这篇文章，解释得很好： 添加链接描述 torch.nn只接受mini-batch的输入，也就是说我们输入的时候是必须是好几张图片同时输入。 例如：nn. Conv2d 允许输入4维的Tensor：n个样本 x n个色彩频道 x 高度 x 宽度。 #coding=utf-8 import torch import torch.nn as nn im
卷积神经网络
没有笔记本用了
12-14 645
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、基础层 1.全连接层 2.卷积层 3.池化层 4.批规范化层. 三、 总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、BP神经网络 示例：pandas 是基于Nu...
pytorch-lr-explorer:Jupyter笔记本探索用于训练深度神经网络的复杂学习率策略
05-14
Jupyter笔记本探索了用于在深度神经网络中提高学习率的各种复杂技术，其中包括： 一种用于估计最佳学习率设置的系统方法，其中在短期训练中不断提高学习率，然后针对训练损失或准确性进行绘制。 莱斯利·N·史密斯...
pytorch实现手写数字识别 - MNIST数据集（全连接神经网络）.html
05-23
关于神经网络处理过程 softmax函数 关于MNIST数据集的处理举例 代码流程 关于transforms.ToTensor 关于transforms.Normalize 9.代码中transform的对应关系 关于x.view 设计模型 batch size设置技巧 谈谈batchsize...
【PyTorch学习笔记1】MNIST手写数字识别之MLP实现
01-07
在本笔记中，我们将以多层感知机（multilayer perceptron，MLP）为例，介绍多层神经网络的相关概念，并将其运用到最基础的MNIST数据集分类任务中，同时展示相关代码。本笔记主要从下面四个方面展开： 文章目录1 ...
PyTorch环境搭建
热门推荐
不忘初心~
05-16 3万+
PyTorch环境搭建
PyTorch固定随机数种子
不忘初心~
08-01 3万+
在神经网络中，参数默认是进行随机初始化的。不同的初始化参数往往会导致不同的结果。当得到比较好的结果时我们通常希望这个结果是可以复现的，在PyTorch中，通过设置全局随机数种子可以实现这个目的。本文总结了PyTorch中固定随机种子的方法。
Ubuntu18.04 配置 LibTorch
不忘初心~
08-29 8537
Ubuntu18.04 配置LibTorch
PyTorch 使用DataParallel()实现多GPU训练
不忘初心~
08-22 8528
PyTorch 使用DataParallel()实现多GPU训练
pytorch 修改预训练模型
不忘初心~
08-22 7116
pytorch 修改预训练模型
pytorch学习笔记
最新发布
07-27
- *2* *3* [Pytorch学习笔记](https://blog.csdn.net/pizm123/article/details/126748381)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值