torch.nn 和 torch.functional 的区别

原文地址 : https://blog.csdn.net/teeyohuang/article/details/79211798
Pytorch打怪路(一)pytorch进行CIFAR-10分类(2)定义卷积神经网络

注:官方文档地址–  http://pytorch.org/docs/0.3.0/index.html

我的系列博文

Pytorch打怪路(一)pytorch进行CIFAR-10分类(1)CIFAR-10数据加载和处理

Pytorch打怪路(一)pytorch进行CIFAR-10分类(2)定义卷积神经网络(本文)

Pytorch打怪路(一)pytorch进行CIFAR-10分类(3)定义损失函数和优化器

Pytorch打怪路(一)pytorch进行CIFAR-10分类(4)训练

Pytorch打怪路(一)pytorch进行CIFAR-10分类(5)测试

1、简述

官网tutorial中显示图片的那部分我就直接省略了,因为跟训练网络无关,只是for fun
这一步骤虽然代码量很少,但是却包含很多难点和重点,执行这一步的代码需要包含以及神经网络工具箱torch.nn、以及神经网络函数torch.nn.functional,如果有兴趣的同学去看一下官网的Docs,会发现这俩模块所占的篇幅是相当相当的长啊,不知道一下午能不能看完….
所以我在这里也就简要地、根据此例所给的代码,来讲解一下即可,更多的内容还是参考官方文档更实在,虽然更费时……


注意:虽然官网给的程序有这么一句 from torch.autograd import Variable,但是此步中确实没有显式地用到variable只能说网络里运行的数据确实要以variable的形式存在,在后面我们会讲解这个内容
所以这节先不讨论,当然代码写在那里是没问题的,反正后面会用

2.代码

  1. # 首先是调用Variable、 torch.nn、torch.nn.functional  
  2. from torch.autograd import Variable   # 这一步还没有显式用到variable,但是现在写在这里也没问题,后面会用到  
  3. import torch.nn as nn  
  4. import torch.nn.functional as F  
  5.   
  6.   
  7. class Net(nn.Module):                 # 我们定义网络时一般是继承的torch.nn.Module创建新的子类  
  8.     def __init__(self):      
  9.         super(Net, self).__init__()   # 第二、三行都是python类继承的基本操作,此写法应该是python2.7的继承格式,但python3里写这个好像也可以  
  10.         self.conv1 = nn.Conv2d(365)       # 添加第一个卷积层,调用了nn里面的Conv2d()  
  11.         self.pool = nn.MaxPool2d(22)        # 最大池化层  
  12.         self.conv2 = nn.Conv2d(6165)      # 同样是卷积层  
  13.         self.fc1 = nn.Linear(16 * 5 * 5120# 接着三个全连接层  
  14.         self.fc2 = nn.Linear(12084)  
  15.         self.fc3 = nn.Linear(8410)  
  16.   
  17.     def forward(self, x):                  # 这里定义前向传播的方法,为什么没有定义反向传播的方法呢?这其实就涉及到torch.autograd模块了,  
  18.                                            # 但说实话这部分网络定义的部分还没有用到autograd的知识,所以后面遇到了再讲  
  19.         x = self.pool(F.relu(self.conv1(x)))  # F是torch.nn.functional的别名,这里调用了relu函数 F.relu()  
  20.         x = self.pool(F.relu(self.conv2(x)))  
  21.         x = x.view(-116 * 5 * 5)  # .view( )是一个tensor的方法,使得tensor改变size但是元素的总数是不变的。  
  22.                                     #  第一个参数-1是说这个参数由另一个参数确定, 比如矩阵在元素总数一定的情况下,确定列数就能确定行数。  
  23.                                     #  那么为什么这里只关心列数不关心行数呢,因为马上就要进入全连接层了,而全连接层说白了就是矩阵乘法,  
  24.                                     #  你会发现第一个全连接层的首参数是16*5*5,所以要保证能够相乘,在矩阵乘法之前就要把x调到正确的size  
  25.                                     # 更多的Tensor方法参考Tensor: http://pytorch.org/docs/0.3.0/tensors.html  
  26.         x = F.relu(self.fc1(x))  
  27.         x = F.relu(self.fc2(x))  
  28.         x = self.fc3(x)  
  29.         return x  
  30.   
  31.  # 和python中一样,类定义完之后实例化就很简单了,我们这里就实例化了一个net  
  32. net = Net()  
# 首先是调用Variable、 torch.nn、torch.nn.functional
from torch.autograd import Variable   # 这一步还没有显式用到variable,但是现在写在这里也没问题,后面会用到
import torch.nn as nn
import torch.nn.functional as F


class Net(nn.Module):                 # 我们定义网络时一般是继承的torch.nn.Module创建新的子类
    def __init__(self):    
        super(Net, self).__init__()   # 第二、三行都是python类继承的基本操作,此写法应该是python2.7的继承格式,但python3里写这个好像也可以
        self.conv1 = nn.Conv2d(3, 6, 5)       # 添加第一个卷积层,调用了nn里面的Conv2d()
        self.pool = nn.MaxPool2d(2, 2)        # 最大池化层
        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):                  # 这里定义前向传播的方法,为什么没有定义反向传播的方法呢?这其实就涉及到torch.autograd模块了,
                                           # 但说实话这部分网络定义的部分还没有用到autograd的知识,所以后面遇到了再讲
        x = self.pool(F.relu(self.conv1(x)))  # F是torch.nn.functional的别名,这里调用了relu函数 F.relu()
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)  # .view( )是一个tensor的方法,使得tensor改变size但是元素的总数是不变的。
                                    #  第一个参数-1是说这个参数由另一个参数确定, 比如矩阵在元素总数一定的情况下,确定列数就能确定行数。
                                    #  那么为什么这里只关心列数不关心行数呢,因为马上就要进入全连接层了,而全连接层说白了就是矩阵乘法,
                                    #  你会发现第一个全连接层的首参数是16*5*5,所以要保证能够相乘,在矩阵乘法之前就要把x调到正确的size
                                    # 更多的Tensor方法参考Tensor: http://pytorch.org/docs/0.3.0/tensors.html
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

 # 和python中一样,类定义完之后实例化就很简单了,我们这里就实例化了一个net
net = Net()

3.涉及知识点

①神经网络工具箱 torch.nn

这是一个转为深度学习设计的模块,我们来看一下官方文档中它的目录



可以看到,nn模块中有很多很多的子模块,其中较为重要的,也是在咱们上面的程序中出现过的一些内容包括:

a.  Container中的Module,也即nn.Module


看一下nn.Module的详细介绍

可知,nn.Module是所有神经网络的基类,我们自己定义任何神经网络,都要继承nn.Module!class Net(nn.Module):

b.  convolution layers


我们在上面的代码块中用到了Conv2d: self.conv1 = nn.Conv2d(3, 6, 5)    self.conv2 = nn.Conv2d(6, 16, 5)

例如Conv2d(1,20,5)的意思就是说,输入是1通道的图像,输出是20通道,也就是20个卷积核,卷积核是5*5,其余参数都是用的默认值

c.  pooling layers


可以看到有很多的池化方式,我们上面的代码采用的是Maxpool2d: self.pool = nn.MaxPool2d(2, 2)

d.  Linear layer


我们代码中用的是线性层Linear: self.fc1 = nn.Linear(16 * 5 * 5, 120)      self.fc2 = nn.Linear(120, 84)        self.fc3 = nn.Linear(84, 10)

e.   Non-linear Activations

要注意,其实这个例子中的非线性激活函数用的并不是torch.nn模块中的这个部分,但是torch.nn模块中有这个部分,所以我还是提一下。
此例中的激活函数用的其实是torch.nn.functional 模块中的函数。它们是有区别的,区别下文继续讲。现在先浏览一下这个部分的内容即可:

可以看出,torch.nn 模块中其实也有很多激活函数的,只不过我们此例用的不是这里的激活函数!!!

②torch.nn.functional


这个模块包含的内容如图所示
torch.nn中大多数layer在torch.nn.funtional中都有一个与之对应的函数。二者的区别在于:
torch.nn.Module中实现layer的都是一个特殊的类,可以去查阅,他们都是以class xxxx来定义的,会自动提取可学习的参数
nn.functional中的函数,更像是纯函数,由def function( )定义,只是进行简单的数学运算而已。
说到这里你可能就明白二者的区别了,functional中的函数是一个确定的不变的运算公式,输入数据产生输出就ok,
而深度学习中会有很多权重是在不断更新的,不可能每进行一次forward就用新的权重重新来定义一遍函数来进行计算,所以说就会采用类的方式,以确保能在参数发生变化时仍能使用我们之前定好的运算步骤。
所以从这个分析就可以看出什么时候改用nn.Module中的layer了:
如果模型有可学习的参数,最好使用nn.Module对应的相关layer,否则二者都可以使用,没有什么区别。
比如此例中的Relu其实没有可学习的参数,只是进行一个运算而已,所以使用的就是functional中的relu函数,
而卷积层和全连接层都有可学习的参数,所以用的是nn.Module中的类。
不具备可学习参数的层,将它们用函数代替,这样可以不用放在构造函数中进行初始化。

定义网络模型,主要会用到的就是torch.nn 和torch.nn.funtional这两个模块,这两个模块值得去细细品味一番,希望大家可以去读一下官方文档



        </div>
            </div>
发布了11 篇原创文章 · 获赞 14 · 访问量 2万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览