PyTorch 激活函数及非线性变换详解

fydw_7152024-09-21 12:03

激活函数是深度学习模型的重要组成部分，它们引入非线性，从而使模型能够更好地拟合复杂的数据模式。本文将详细介绍激活函数的作用、常见类型、经典应用示例，并比较它们的优缺点。

激活函数的作用

激活函数的主要作用是引入非线性变换，使神经网络能够拟合复杂的数据模式。为了理解这句话的含义，我们需要详细探讨以下几个方面：

  1. 线性变换的局限性
  2. 非线性变换的必要性
  3. 激活函数的作用
  4. 实际应用中的激活函数
1. 线性变换的局限性

线性变换是指一种保持向量加法和标量乘法的运算。在几何上，线性变换通常包括旋转、缩放、平移等操作。线性变换可以用矩阵乘法来表示。对于一个输入向量 x \mathbf{x} x 和一个线性变换矩阵 A \mathbf{A} A，线性变换的输出 y \mathbf{y} y 可以表示为：

y = A x + b \mathbf{y} = \mathbf{A} \mathbf{x} + \mathbf{b} y=Ax+b

其中， A \mathbf{A} A 是一个矩阵， b \mathbf{b} b 是一个偏置向量。

特性：

  • 线性变换的输出是输入的线性组合。
  • 线性变换不会改变输入数据的线性关系。
  • 线性变换的图形表示通常是直线或平面。

示例 ：

假设我们有一个向量 x = [ x 1 , x 2 ] T \mathbf{x} = [x_1, x_2]^T x=[x1,x2]T，一个线性变换矩阵 A = [ a 11 a 12 a 21 a 22 ] \mathbf{A} = \begin{bmatrix} a_{11} & a_{12} \\ a_{21} & a_{22} \end{bmatrix} A=[a11a21a12a22] 和一个偏置向量 b = [ b 1 , b 2 ] T \mathbf{b} = [b_1, b_2]^T b=[b1,b2]T，线性变换的结果是：

y = A x + b = [ a 11 a 12 a 21 a 22 ] [ x 1 x 2 ] + [ b 1 b 2 ] \mathbf{y} = \mathbf{A} \mathbf{x} + \mathbf{b} = \begin{bmatrix} a_{11} & a_{12} \\ a_{21} & a_{22} \end{bmatrix} \begin{bmatrix} x_1 \\ x_2 \end{bmatrix} + \begin{bmatrix} b_1 \\ b_2 \end{bmatrix} y=Ax+b=[a11a21a12a22][x1x2]+[b1b2]

2. 非线性变换的必要性

现实世界中的数据往往具有复杂的非线性关系。例如，图像中的物体识别、语音识别和自然语言处理等任务，数据的模式通常是高度非线性的。为了捕捉这些复杂的关系，我们需要引入非线性变换。

非线性变换是指一种不保持向量加法和标量乘法的运算。非线性变换可以引入复杂的关系，使得模型能够拟合复杂的数据模式。在神经网络中，非线性变换通常由激活函数实现。

特性：

  • 非线性变换的输出不是输入的线性组合。
  • 非线性变换可以改变输入数据的线性关系，捕捉到更复杂的模式。
  • 非线性变换的图形表示通常是曲线或复杂的几何形状。

示例 ：

假设我们有一个输入向量 x = [ x 1 , x 2 ] T \mathbf{x} = [x_1, x_2]^T x=[x1,x2]T 和一个非线性变换函数 f f f，非线性变换的结果是：

y = f ( x ) \mathbf{y} = f(\mathbf{x}) y=f(x)

如果 f f f 是 ReLU 激活函数，那么非线性变换可以表示为：

y = max ⁡ ( 0 , x ) \mathbf{y} = \max(0, \mathbf{x}) y=max(0,x)

3. 激活函数的作用

激活函数的主要作用是引入非线性变换，从而使神经网络能够拟合复杂的数据模式。激活函数在每个神经元的输出上进行非线性变换，使得整个网络能够学习和表示复杂的非线性关系。

在没有激活函数的情况下，神经网络的每一层都只是对上一层的线性变换。无论网络有多少层，这种线性组合的结果仍然是线性的。因此，没有激活函数的深度网络实际上等价于一个线性模型，无法有效地处理复杂的非线性关系。

通过在每一层之间引入激活函数，神经网络能够在每一层进行非线性变换，使得整个网络可以表示高度复杂的非线性函数。这种非线性变换赋予了神经网络强大的表达能力，使其能够拟合复杂的数据模式。

常见的激活函数
1. ReLU（Rectified Linear Unit）

数学表达式 ：
ReLU ( x ) = max ⁡ ( 0 , x ) \text{ReLU}(x) = \max(0, x) ReLU(x)=max(0,x)

优点：

  • 计算简单，速度快。
  • 缓解梯度消失问题，尤其在深层网络中表现良好。
  • 稀疏激活：大部分神经元的输出为零，有助于网络的稀疏性。

缺点：

  • "神经元死亡"问题：在训练过程中，如果神经元的输出一直为零，那么这个神经元将永远不会激活。
  • 负值部分梯度为零，可能导致部分神经元无法更新。

适用场景：

  • 广泛应用于各种深度学习模型，尤其是卷积神经网络（CNN）。

代码示例：

python 复制代码 
import torch
import torch.nn as nn

# 定义 ReLU 激活函数
relu = nn.ReLU()

# 示例输入张量
input_tensor = torch.tensor([-1.0, 0.0, 1.0, 2.0])

# 应用 ReLU 激活函数
output_tensor = relu(input_tensor)
print(output_tensor)
2. Sigmoid

数学表达式 ：
Sigmoid ( x ) = 1 1 + e − x \text{Sigmoid}(x) = \frac{1}{1 + e^{-x}} Sigmoid(x)=1+e−x1

优点：

  • 输出范围在 (0, 1) 之间，适用于输出概率的场景。
  • 平滑且连续，适用于某些需要概率输出的任务。

缺点：

  • 容易导致梯度消失问题，尤其在深层网络中。
  • 输出不以零为中心，可能导致训练过程中的梯度不平衡。

适用场景：

  • 适用于二分类问题的输出层。

代码示例：

python 复制代码 
import torch
import torch.nn as nn

# 定义 Sigmoid 激活函数
sigmoid = nn.Sigmoid()

# 示例输入张量
input_tensor = torch.tensor([-1.0, 0.0, 1.0, 2.0])

# 应用 Sigmoid 激活函数
output_tensor = sigmoid(input_tensor)
print(output_tensor)
3. Tanh（Hyperbolic Tangent）

数学表达式 ：
Tanh ( x ) = e x − e − x e x + e − x \text{Tanh}(x) = \frac{e^x - e^{-x}}{e^x + e^{-x}} Tanh(x)=ex+e−xex−e−x

优点：

  • 输出范围在 (-1, 1) 之间，输出以零为中心，有助于梯度的平衡。
  • 平滑且连续，能够捕捉到输入的细微变化。

缺点：

  • 容易导致梯度消失问题，尤其在深层网络中。

适用场景：

  • 适用于需要对称输出的场景，如生成对抗网络（GAN）中的生成器。

代码示例：

python 复制代码 
import torch
import torch.nn as nn

# 定义 Tanh 激活函数
tanh = nn.Tanh()

# 示例输入张量
input_tensor = torch.tensor([-1.0, 0.0, 1.0, 2.0])

# 应用 Tanh 激活函数
output_tensor = tanh(input_tensor)
print(output_tensor)
4. LeakyReLU

数学表达式 ：
LeakyReLU ( x ) = { x if x ≥ 0 α x if x < 0 \text{LeakyReLU}(x) = \begin{cases} x & \text{if } x \geq 0 \\ \alpha x & \text{if } x < 0 \end{cases} LeakyReLU(x)={xαxif x≥0if x<0

其中， α \alpha α 是一个小的常数，通常取值为 0.01。

优点：

  • 缓解了 ReLU 的"神经元死亡"问题。
  • 保持了 ReLU 的大部分优点，如计算简单和稀疏激活。

缺点：

  • 需要额外的超参数 α \alpha α，可能需要进行调优。

适用场景：

  • 适用于需要避免"神经元死亡"问题的场景。

代码示例：

python 复制代码 
import torch
import torch.nn as nn

# 定义 LeakyReLU 激活函数，负斜率为 0.01
leaky_relu = nn.LeakyReLU(negative_slope=0.01)

# 示例输入张量
input_tensor = torch.tensor([-1.0, 0.0, 1.0, 2.0])

# 应用 LeakyReLU 激活函数
output_tensor = leaky_relu(input_tensor)
print(output_tensor)
激活函数的比较
特性 ReLU Sigmoid Tanh LeakyReLU
数学表达式 max ⁡ ( 0 , x ) \max(0, x) max(0,x) 1 1 + e − x \frac{1}{1 + e^{-x}} 1+e−x1 e x − e − x e x + e − x \frac{e^x - e^{-x}}{e^x + e^{-x}} ex+e−xex−e−x { x if x ≥ 0 α x if x < 0 \begin{cases} x & \text{if } x \geq 0 \\ \alpha x & \text{if } x < 0 \end{cases} {xαxif x≥0if x<0
输出范围 [ 0 , ∞ ) [0, \infty) [0,∞) ( 0 , 1 ) (0, 1) (0,1) ( − 1 , 1 ) (-1, 1) (−1,1) ( − ∞ , ∞ ) (-\infty, \infty) (−∞,∞)
优点 计算简单，缓解梯度消失问题 输出范围固定，适合概率输出 输出以零为中心，梯度平衡 缓解"神经元死亡"问题
缺点 "神经元死亡"问题 梯度消失，输出不以零为中心 梯度消失 需要调优超参数 α \alpha α
适用场景 广泛应用于各种模型 二分类问题的输出层 对称输出的场景 避免"神经元死亡"的场景
激活函数的经典应用示例

激活函数在深度学习中的应用非常广泛。下面介绍几个经典的应用示例，包括卷积神经网络（CNN）、循环神经网络（RNN）、生成对抗网络（GAN）和全连接神经网络（FCNN）中的激活函数应用。

1. 卷积神经网络（CNN）

卷积神经网络广泛应用于图像分类、目标检测等任务中。ReLU 激活函数是 CNN 中最常用的激活函数。

示例：使用 ReLU 激活函数的简单 CNN：

python 复制代码 
import torch
import torch.nn as nn
import torch.nn.functional as F

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=1, out_channels=32, kernel_size=3, stride=1, padding=1)
        self.conv2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=1, padding=1)
        self.fc1 = nn.Linear(in_features=64*7*7, out_features=128)
        self.fc2 = nn.Linear(in_features=128, out_features=10)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = F.max_pool2d(x, 2)
        x = F.relu(self.conv2(x))
        x = F.max_pool2d(x, 2)
        x = x.view(-1, 64*7*7)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# 创建模型实例
model = SimpleCNN()
print(model)
2. 循环神经网络（RNN）

循环神经网络广泛应用于序列数据，如自然语言处理和时间序列预测。Tanh 和 Sigmoid 激活函数常用于 RNN 的隐藏层和输出层。

示例：使用 Tanh 和 Sigmoid 激活函数的简单 RNN：

python 复制代码 
import torch
import torch.nn as nn

class SimpleRNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(SimpleRNN, self).__init__()
        self.hidden_size = hidden_size
        self.i2h = nn.Linear(input_size + hidden_size, hidden_size)
        self.i2o = nn.Linear(input_size + hidden_size, output_size)
        self.sigmoid = nn.Sigmoid()
        self.tanh = nn.Tanh()

    def forward(self, input, hidden):
        combined = torch.cat((input, hidden), 1)
        hidden = self.tanh(self.i2h(combined))
        output = self.sigmoid(self.i2o(combined))
        return output, hidden

    def init_hidden(self):
        return torch.zeros(1, self.hidden_size)

# 创建模型实例
input_size = 10
hidden_size = 20
output_size = 1
model = SimpleRNN(input_size, hidden_size, output_size)
print(model)
3. 生成对抗网络（GAN）

生成对抗网络由生成器和判别器组成，用于生成高质量的图像。生成器通常使用 Tanh 激活函数，而判别器使用 LeakyReLU 激活函数。

示例：使用 Tanh 和 LeakyReLU 激活函数的简单 GAN：

python 复制代码 
import torch
import torch.nn as nn

class Generator(nn.Module):
    def __init__(self, input_size, output_size):
        super(Generator, self).__init__()
        self.fc1 = nn.Linear(input_size, 128)
        self.fc2 = nn.Linear(128, 256)
        self.fc3 = nn.Linear(256, output_size)
        self.tanh = nn.Tanh()

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

class Discriminator(nn.Module):
    def __init__(self, input_size):
        super(Discriminator, self).__init__()
        self.fc1 = nn.Linear(input_size, 256)
        self.fc2 = nn.Linear(256, 128)
        self.fc3 = nn.Linear(128, 1)
        self.leaky_relu = nn.LeakyReLU(0.2)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        x = self.leaky_relu(self.fc1(x))
        x = self.leaky_relu(self.fc2(x))
        x = self.sigmoid(self.fc3(x))
        return x

# 创建生成器和判别器实例
input_size = 100
output_size = 28*28
generator = Generator(input_size, output_size)
discriminator = Discriminator(output_size)
print(generator)
print(discriminator)
4. 全连接神经网络（FCNN）

全连接神经网络广泛应用于各种分类和回归任务中。不同的激活函数可以在不同的层中使用，具体取决于任务的需求。

示例：使用 ReLU 和 Sigmoid 激活函数的简单 FCNN：

python 复制代码 
import torch
import torch.nn as nn

class SimpleFCNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(SimpleFCNN, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.fc2 = nn.Linear(hidden_size, hidden_size)
        self.fc3 = nn.Linear(hidden_size, output_size)
        self.relu = nn.ReLU()
        self.sigmoid = nn.Sigmoid()

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

# 创建模型实例
input_size = 784  # 28x28 图像展平后的尺寸
hidden_size = 128
output_size = 10  # 10 个类别
model = SimpleFCNN(input_size, hidden_size, output_size)
print(model)

线性变换与非线性变换在神经网络中的应用

线性变换在神经网络中的应用

线性变换在神经网络中的应用主要体现在每一层的加权求和操作。对于一个输入向量 x \mathbf{x} x 和权重矩阵 W \mathbf{W} W，线性变换的输出 z \mathbf{z} z 可以表示为：

z = W x + b \mathbf{z} = \mathbf{W} \mathbf{x} + \mathbf{b} z=Wx+b

非线性变换在神经网络中的应用

非线性变换在神经网络中的应用主要体现在激活函数的使用。激活函数对每一个神经元的输出进行非线性变换，使得整个网络能够表示复杂的非线性关系。

示例 ：

假设我们有一个简单的前馈神经网络，包含一个输入层、一个隐藏层和一个输出层。隐藏层的输出 h \mathbf{h} h 可以表示为：

h = f ( W 1 x + b 1 ) \mathbf{h} = f(\mathbf{W}_1 \mathbf{x} + \mathbf{b}_1) h=f(W1x+b1)

其中， W 1 \mathbf{W}_1 W1 是输入层到隐藏层的权重矩阵， b 1 \mathbf{b}_1 b1 是偏置向量， f f f 是激活函数（如 ReLU）。

输出层的输出 y \mathbf{y} y 可以表示为：

y = g ( W 2 h + b 2 ) \mathbf{y} = g(\mathbf{W}_2 \mathbf{h} + \mathbf{b}_2) y=g(W2h+b2)

其中， W 2 \mathbf{W}_2 W2 是隐藏层到输出层的权重矩阵， b 2 \mathbf{b}_2 b2 是偏置向量， g g g 是激活函数（如 Sigmoid）。

多次函数与神经网络中的非线性变换

多次函数（多项式函数）确实是非线性的，它们可以表示为变量的多次幂及其线性组合的形式。例如，一个二次函数可以表示为：

y = a x 2 + b x + c y = ax^2 + bx + c y=ax2+bx+c

尽管多次函数是非线性的，但在神经网络中并不常用来实现非线性变换。下面我们详细讨论为什么在神经网络中更常用激活函数（如 ReLU、Sigmoid、Tanh 等）来实现非线性，而不是多次函数。

多次函数的局限性

  1. 计算复杂度 ：

    多次函数的计算复杂度较高，尤其是高次多项式。每个神经元需要计算输入的多次幂，这在计算上会非常耗时，尤其是对于大规模神经网络。

  2. 梯度爆炸和梯度消失 ：

    多次函数的导数是幂函数的形式，高次幂函数的导数在输入较大或较小时会导致梯度爆炸或梯度消失。这使得训练深度神经网络变得非常困难。

  3. 参数量和过拟合 ：

    多次函数需要更多的参数来表示复杂的非线性关系。这增加了模型的复杂度，容易导致过拟合，尤其是在训练数据量较少的情况下。

  4. 表达能力有限 ：

    尽管多次函数可以表示某些非线性关系，但它们的表达能力在高维空间中受到限制。激活函数如 ReLU、Sigmoid 和 Tanh 可以通过简单的非线性变换实现更强的表达能力，适用于更广泛的非线性模式。

为什么选择常用的激活函数

  1. 计算简单 ：

    常用的激活函数（如 ReLU、Sigmoid、Tanh）计算简单，计算开销较低，适合大规模神经网络的训练和推理。

  2. 缓解梯度消失和梯度爆炸 ：

    激活函数如 ReLU 在输入大于 0 时的导数恒为 1，有效缓解了梯度消失问题。LeakyReLU 等变种激活函数通过在负值区域引入小斜率，进一步缓解了梯度消失问题。

  3. 通用性强 ：

    常用的激活函数在各种任务和网络结构中表现良好，具有广泛的适用性。它们能够通过简单的非线性变换实现复杂的非线性关系，增强神经网络的表达能力。

  4. 经验验证 ：

    大量的研究和实践表明，常用的激活函数在训练深度神经网络时表现出色，能够有效提升模型的性能和稳定性。

结论

激活函数在深度学习模型中起着关键作用，通过引入非线性，使得模型能够更好地拟合复杂的数据模式。不同的激活函数适用于不同的任务和网络结构，选择合适的激活函数可以显著提升模型的性能。本文详细介绍了 ReLU、Sigmoid、Tanh 和 LeakyReLU 激活函数的作用、优缺点及其经典应用示例，希望能帮助读者更好地理解和应用这些激活函数。

线性变换和非线性变换在神经网络中扮演着不同但互补的角色。线性变换通过权重矩阵和偏置向量实现输入的加权求和，而非线性变换通过激活函数引入非线性，使得神经网络能够拟合复杂的数据模式。理解这两种变换的区别和应用，对于构建和优化神经网络至关重要。

尽管多次函数是非线性的，但由于其计算复杂度高、容易导致梯度爆炸或梯度消失、参数量大且容易过拟合等问题，它们在神经网络中并不常用。相反，常用的激活函数如 ReLU、Sigmoid 和 Tanh 计算简单、能够有效缓解梯度问题且具有强大的表达能力，因此在深度学习中得到了广泛应用。理解这些激活函数的优缺点和适用场景，有助于构建和优化高效的深度学习模型。

PyTorch概述
Pytorch ：张量（Tensor）详解
PyTorch 卷积层详解
PyTorch 全连接层（Fully Connected Layer）详解
PyTorch 池化层详解
PyTorch 激活函数及非线性变换详解

相关推荐
诚威_lol_中大努力中几秒前
关于pytorch3d的安装
人工智能·pytorch·python
GISer_Jing6 分钟前
神经网络、深度学习、卷积神经网络
python
herogus丶22 分钟前
【Spring AI】Spring AI Alibaba的简单使用
java·人工智能·spring·ai
小王子102439 分钟前
数据结构与算法Python版 二叉查找树
数据结构·python·算法·二叉查找树
编程阿布1 小时前
Python基础——多线程编程
java·数据库·python
又蓝1 小时前
使用 Python 操作 MySQL 数据库的实用工具类：MySQLHandler
数据库·python·mysql
dundunmm1 小时前
机器学习之pandas
人工智能·python·机器学习·数据挖掘·pandas
好学近乎知o1 小时前
常用的Django模板语言
python·django·sqlite
小火炉Q1 小时前
16 循环语句——for循环
人工智能·python·网络安全
segwyang1 小时前
Maven 项目模板
java·python·maven
热门推荐
01大模型国产化适配7-华为昇腾LLM落地可选解决方案（MindFormers、ModelLink、MindIE）02Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO03玄机平台应急响应—webshell查杀04电赛2024年H题智能小车基于MSPM0G3507主控MCU（利用8路灰度加上MPU6050的解决方式）具体项目报告05组基轨迹建模 GBTM的介绍与实现（Stata 或 R）06支付宝短视频平台创作分成激励项目07怎么找小红书美食探店博主合作？08【一文读懂】NTN（非地面网络）技术介绍09优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间10校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站