一文解释nn、nn.Module与nn.functional的用法与区别

🌈个人主页：十二月的猫-CSDN博客

🔥 系列专栏： 🏀零基础入门PyTorch框架_十二月的猫的博客-CSDN博客

💪🏻 十二月的寒冬阻挡不了春天的脚步，十二点的黑夜遮蔽不住黎明的曙光

目录

[1. 前言](#1. 前言)

[2. Torch.nn库](#2. Torch.nn库)

[3. nn.Module](#3. nn.Module)

[4. nn.functional](#4. nn.functional)

[4.1 基本用法](#4.1 基本用法)

[4.2 常用的functional中的函数](#4.2 常用的functional中的函数)

[4.2.1 激活函数](#4.2.1 激活函数)

[4.2.2 损失函数](#4.2.2 损失函数)

[4.2.3 非线性操作](#4.2.3 非线性操作)

[5. 小例子](#5. 小例子)

[6. 总结](#6. 总结)

---

1. 前言

• 👑《零基础入门PyTorch》专栏持续更新中，未来最少文章数量为60篇。由于专栏刚刚建立，促销价为9.9。后续将慢慢恢复原价至99.9🍉【在校大学生】评论区留言并私信我免费订阅
• 👑《零基础入门PyTorch》专栏主要针对零基础入门的小伙伴。不需要Python基础，不需要深度学习基础，只要你愿意学，这一个专栏将真正让你做到零基础入门。
• 🔥每例项目都包括理论讲解、数据集、源代码。

正在更新中💹💹

🚨项目运行环境：

• 平台：Window11
• 语言环境：Python3.8
• 运行环境1：PyCharm 2021.3
• 运行环境2：Jupyter Notebook 7.3.2
• 框架：PyTorch 2.5.1（CUDA11.8）

2. Torch.nn库

简单介绍一下nn库中有那些接口：

一、神经网络类

1. nn.Module
   nn.Module是所有神经网络类的基类。你可以将其视为一个容器，用于管理神经网络中的其他层。创建自定义的网络类时，你需要从nn.Module继承并实现前向传播方法。
2. nn.Linear (全连接层)
   nn.Linear实现了一个全连接层，用于将输入张量与权重和偏差相加，然后应用激活函数。它需要指定输入特征的数量和输出特征的数量。
3. nn.Conv2d (二维卷积层)
   nn.Conv2d实现了一个二维卷积层，用于图像处理任务。它可以指定输入通道数、输出通道数、卷积核大小和步长等参数。

二、特殊函数类（模型建构定义中使用）

1. nn.MSELoss, nn.CrossEntropyLoss等 (损失函数)
   这些类实现了常见的损失函数，如均方误差损失、交叉熵损失等。它们用于计算模型预测与真实值之间的差异。
2. nn.ReLU, nn.Tanh, nn.Sigmoid等 (激活函数)
   这些类实现了常见的激活函数，如ReLU、Tanh和Sigmoid等。你可以将它们作为层的输出或添加到自定义层中。

三、固定参数函数类（训练循环中快速使用）

1. nn.functional (函数)
   nn.functional模块包含了许多实用的函数，用于执行常见的神经网络操作，如前向传播、激活函数计算等。这些函数与nn.Module中的类方法相对应，但更加灵活，因为它们不强制使用nn.Module作为容器。

• **nn：**Module容器、Linear等各种层、不可学习函数、functional容器
• nn.Module容器，里面放置Linear、Conv2d等层。
• nn.functional：函数综合，里面有固定参数的各类函数（损失函数、激活函数等）
• 重点区别 ：functional容器中的函数 与 不可学习函数

3. nn.Module

nn.Module 类扮演着核心角色，它是构建任何自定义神经网络层、复杂模块或完整神经网络架构的基础构建块。类似于一个网络容器，我们可以往容器中放入各种层结构。

这里，猫猫基于nn.Module创建一个简单的神经网络模型，实现代码如下：

class Net(nn.Module):
    def __init__(self, input_feature, num_hidden, output_feature):
        super(Net,self).__init__()
        self.hidden = nn.Linear(input_feature, num_hidden) #num_hidden隐含层神经元数，也就是输出特征数
        self.out = nn.Linear(num_hidden,output_feature)
    def forward(self, x): #net_name(x)：自动调用forward函数
        x = F.relu(self.hidden(x))
        x = self.out(x) #用激活函数引入非线性成分再经过输出层输出
        return x

Module：网络容器。定义网络模型、网络功能（前向传播与反向传播）

4. nn.functional

nn.functional 是PyTorch中一个重要的模块，包含了许多用于构建神经网络的函数（损失函数、激活函数等）。类似于一个函数容器，我们可以从容器中拿出各种神经网络构建使用的函数。与 nn.Module 不同（Module中的Linear、Conv2d等层本质也就是函数，只不过可以学习参数），nn.functional 中的函数不具有可学习的参数。

4.1 基本用法

在PyTorch中，你只需将输入数据传递给这些函数，并将它们作为网络功能的一部分（记住是网络功能的一部分，不是网络模型的一部分），就可以使用。

网络分为：网络模型（在init中定义就是各种层结构）、网络功能（forward、backward等功能，就是在forward函数中定义）

这里，猫猫有一个简单的示例，演示如何在一个全连接神经网络中使用ReLU激活函数：

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

class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.fc1 = nn.Linear(64, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

nn.functional的主要优势是它的计算效率和灵活性，因为它允许你以函数的方式直接调用这些操作，而不需要创建额外的层。

4.2 常用的functional中的函数

nn.functional中的函数都是参数不可学习的函数

4.2.1 激活函数

激活函数是神经网络中的关键组件，它们引入非线性成分，使网络能够拟合复杂的数据。以下是一些常见的激活函数：

• ReLU
  ReLU是一种简单而有效的激活函数，它将输入值小于零的部分设为零，大于零的部分保持不变。它的数学表达式如下：

output = F.relu(input)

• Sigmoid
  Sigmoid函数将输入值映射到0和1之间，常用于二分类问题的输出层。它的数学表达式如下：

output = F.sigmoid(input)

• Tanh（双曲正切）
  Tanh函数将输入值映射到-1和1之间，它具有零中心化的特性，通常在循环神经网络中使用。它的数学表达式如下：

output = F.tanh(input)

4.2.2 损失函数

• 交叉熵损失（Cross-Entropy Loss）
  交叉熵损失通常用于多分类问题，计算模型的预测分布与真实分布之间的差异。它的数学表达式如下：

loss = F.cross_entropy(input, target)

• 均方误差损失（Mean Squared Error Loss）
  均方误差损失通常用于回归问题，度量模型的预测值与真实值之间的平方差。它的数学表达式如下：

loss = F.mse_loss(input, target)

4.2.3 非线性操作

nn.functional 模块还包含了许多非线性操作，如池化、归一化等。

• 最大池化（Max Pooling）
  最大池化是一种用于减小特征图尺寸的操作，通常用于卷积神经网络中。它的数学表达式如下：

output = F.max_pool2d(input, kernel_size)

• 批量归一化（Batch Normalization）
  批量归一化是一种用于提高训练稳定性和加速收敛的技术。它的数学表达式如下：

output = F.batch_norm(input, mean, std, weight, bias)

5. 小例子

nn.ReLU() 和 F.relu()两种方法都是使用relu激活，只是使用的场景不一样，F.relu()是函数调用，一般使用在foreward函数里。而nn.ReLU()是模块调用，一般在定义网络层的时候使用。

import torch
import torch.nn as nn

class NET1(nn.Module):
    def __init__(self):
        super(NET1, self).__init__()
        self.conv = nn.Conv2d(3, 16, 3, 1, 1)  # 卷积层，输入3个通道，输出16个通道，卷积核大小3x3，步长1，填充1
        self.bn = nn.BatchNorm2d(16)  # 批量归一化，处理16个通道
        self.relu = nn.ReLU()  # ReLU激活函数

    def forward(self, x):
        out = self.conv(x)  # 卷积操作
        out = self.bn(out)  # 批量归一化
        out = self.relu(out)  # ReLU激活函数
        return out

class NET2(nn.Module):
    def __init__(self):
        super(NET2, self).__init__()
        self.conv = nn.Conv2d(3, 16, 3, 1, 1)
        self.bn = nn.BatchNorm2d(16)

    def forward(self, x):
        x = self.conv(x)
        x = self.bn(x)
        out = F.relu(x)  # 函数的激活函数
        return out

6. 总结

如果想要学习更多pyTorch的知识，大家可以点个关注并订阅，持续学习、天天进步

你的点赞就是我更新的动力，如果觉得对你有帮助，辛苦友友点个赞，收个藏呀~~~

【在校大学生评论区留言，然后私信我，免费订阅】