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 激活函数及非线性变换详解

相关推荐
Python大数据分析@8 分钟前
python操作CSV和excel,如何来做?
开发语言·python·excel
黑叶白树9 分钟前
简单的签到程序 python笔记
笔记·python
北京搜维尔科技有限公司9 分钟前
搜维尔科技：【应用】Xsens在荷兰车辆管理局人体工程学评估中的应用
人工智能·安全
说私域13 分钟前
基于开源 AI 智能名片 S2B2C 商城小程序的视频号交易小程序优化研究
人工智能·小程序·零售
YRr YRr13 分钟前
深度学习：Transformer Decoder详解
人工智能·深度学习·transformer
知来者逆18 分钟前
研究大语言模型在心理保健智能顾问的有效性和挑战
人工智能·神经网络·机器学习·语言模型·自然语言处理
Shy96041822 分钟前
Bert完形填空
python·深度学习·bert
云起无垠27 分钟前
技术分享 | 大语言模型赋能软件测试：开启智能软件安全新时代
人工智能·安全·语言模型
上海_彭彭33 分钟前
【提效工具开发】Python功能模块执行和 SQL 执行 需求整理
开发语言·python·sql·测试工具·element
老艾的AI世界40 分钟前
新一代AI换脸更自然，DeepLiveCam下载介绍（可直播）
图像处理·人工智能·深度学习·神经网络·目标检测·机器学习·ai换脸·视频换脸·直播换脸·图片换脸
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10【TC3xx芯片】TC3xx芯片电源管理系统PMS详解