常用激活函数和归一化函数

0rangeStar

已于 2024-04-28 17:20:46 修改

阅读量2.1k

点赞数 36

文章标签：深度学习 python

于 2024-04-28 16:57:19 首次发布

本文链接：https://blog.csdn.net/xingloving/article/details/138280528

版权

一、激活函數的作用

激活函数在神经网络和深度学习中起着至关重要的作用，它决定了神经元输出的非线性特性和传播方式。其主要作用包括以下几个方面：

引入非线性：

激活函数将神经元的输出从线性映射转换为非线性映射，这对于深度学习至关重要。如果没有非线性，神经网络仅仅是简单的线性变换，无论增加多少层，整体效果依然是线性的。引入非线性使得神经网络能够处理复杂的、非线性的关系，从而在不同任务中表现出强大的学习能力。
代码验证如下：

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.font_manager import FontManager
# 生成一个线性的输入
x = np.linspace(-10, 10, 100)

# 激活函数
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def tanh(x):
    return np.tanh(x)

def relu(x):
    return np.maximum(0, x)

def leaky_relu(x, alpha=0.01):
    return np.where(x > 0, x, alpha * x)

# 应用激活函数
y_sigmoid = sigmoid(x)
y_tanh = tanh(x)
y_relu = relu(x)
y_leaky_relu = leaky_relu(x)

# 绘制不同激活函数的效果
plt.figure(figsize=(10, 6))
plt.plot(x, y_sigmoid, label='Sigmoid', color='b')
plt.plot(x, y_tanh, label='Tanh', color='g')
plt.plot(x, y_relu, label='ReLU', color='r')
plt.plot(x, y_leaky_relu, label='Leaky ReLU', color='y')
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
plt.title("激活函数的非线性映射")
plt.xlabel("输入值")
plt.ylabel("输出值")
plt.legend()
plt.grid(True)
plt.show()

实现分类和预测：

激活函数的非线性特性使神经网络能够在多种任务中有效地工作，如图像分类、语音识别、文本生成等。通过激活函数，网络可以将输入数据映射到所需的输出空间，以实现分类、回归等多种任务。
实例1：猫狗分类
在这个任务中，使用卷积神经网络（CNN）来区分猫和狗的图片。中间层使用ReLU激活函数，最后一层使用Softmax，以获得每个类别的概率：

from tensorflow import keras
from tensorflow.keras import layers

# 简单的卷积神经网络
model = keras.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(150, 150, 3)),
    layers.MaxPooling2D(2, 2),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D(2, 2),
    layers.Conv2D(128, (3, 3), activation='relu'),
    layers.MaxPooling2D(2, 2),
    layers.Flatten(),
    layers.Dense(512, activation='relu'),
    layers.Dense(2, activation='softmax')  # Softmax激活函数，用于多分类
])

# 编译和训练模型
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

实例2：语音到文本
语音识别任务中，激活函数用于神经网络的多层间引入非线性。Recurrent Neural Networks（RNNs）和Long Short-Term Memory（LSTM）模型常用于处理序列数据，如语音。在语音到文本的任务中，RNN或LSTM常用于处理音频数据。这些模型使用激活函数（如Tanh）来处理时间序列特征，最后一层可能使用Softmax以输出预测的字符或单词概率。

# 简单的LSTM网络
model = keras.Sequential([
    layers.LSTM(128, activation='tanh', return_sequences=True, input_shape=(100, 13)),  # Tanh激活函数
    layers.Dropout(0.2),
    layers.LSTM(128, activation='tanh'),
    layers.Dropout(0.2),
    layers.Dense(26, activation='softmax')  # Softmax用于输出字符概率
])

# 编译和训练模型
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

实例3：文本生成
在文本生成任务中，激活函数可以帮助网络生成新文本或预测接下来的字符/单词。LSTM或Gated Recurrent Unit（GRU）在这种任务中常用。

# 使用GRU的简单文本生成模型
model = keras.Sequential([
    layers.GRU(256, activation='tanh', return_sequences=True, input_shape=(100, 26)),  # Tanh激活函数
    layers.Dropout(0.2),
    layers.Dense(26, activation='softmax')  # Softmax用于输出字符概率
])

# 编译和训练模型
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

提供决策界限：
激活函数有助于定义决策界限。在分类任务中，激活函数能够在输入之间形成非线性的决策界限，以区分不同的类别。这种特性在多分类和二分类任务中尤为重要。

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import accuracy_score

# 创建一个合成的二分类数据集
X, y = make_moons(n_samples=300, noise=0.2, random_state=42)

# 拆分数据集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 创建一个简单的多层感知机（MLP）模型，使用ReLU激活函数
model = MLPClassifier(hidden_layer_sizes=(10, 10), activation='relu', max_iter=1000, random_state=42)

# 训练模型
model.fit(X_train, y_train)

# 评估模型
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print("测试集准确度:", accuracy)

# 可视化决策界限
x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5
y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5
xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100), np.linspace(y_min, y_max, 100))
Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral, alpha=0.8)
plt.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=plt.cm.Spectral, edgecolors='k', label="训练集")
plt.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=plt.cm.Spectral, edgecolors='w', label="测试集")
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
plt.title("激活函数在分类任务中的决策界限")
plt.xlabel("Feature 1")
plt.ylabel("Feature 2")
plt.legend()
plt.show()

在这里插入图片描述
3. 防止梯度消失和爆炸：
一些激活函数（如ReLU及其变体）在深度神经网络中有助于缓解梯度消失和爆炸的问题。它们可以让梯度在网络的不同层间更容易地传播，帮助深度网络更有效地训练。

什么是梯度消失和爆炸？

梯度消失：在深度神经网络中，随着梯度从输出层向输入层反向传播，梯度可能会逐渐缩小。如果梯度变得非常小，网络中的参数更新就会变得极为缓慢，导致训练停滞。这在Sigmoid和Tanh等激活函数中较常见，因为它们在较大和较小的输入值上趋于饱和，导致梯度趋近于零。
梯度爆炸：与梯度消失相反，梯度爆炸是指梯度在反向传播过程中变得非常大，可能导致参数过度更新，进而导致训练不稳定。这可能在权重初始化不当或网络太深时发生。

激活函数在防止梯度消失和爆炸中的作用

ReLU（Rectified Linear Unit）：ReLU在输入值大于0时输出原值，而在小于或等于0时输出0。这种特性使梯度在大多数情况下不会饱和，并且在网络的不同层间更容易传播。
Leaky ReLU：Leaky ReLU在ReLU的基础上，允许在输入小于0时仍然产生小的梯度，这有助于缓解“神经元死亡”和梯度消失。
ELU（Exponential Linear Unit）：ELU在ReLU的基础上，在负值区域提供更平滑的输出，帮助梯度在负值区域传播。

from tensorflow import keras
from tensorflow.keras import layers
import numpy as np

# 创建一个简单的深度网络，使用ReLU激活函数
model = keras.Sequential([
    layers.Dense(256, activation='relu', input_shape=(100,)),  # 第一层使用ReLU
    layers.Dense(256, activation='relu'),  # 第二层
    layers.Dense(256, activation='relu'),  # 第三层
    layers.Dense(1, activation='sigmoid')  # 输出层，二分类问题
])

# 编译模型
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# 创建随机数据来训练模型
data = np.random.rand(1000, 100)  # 1000个样本，每个样本有100个特征
labels = np.random.randint(2, size=(1000,))  # 随机二分类标签

# 训练模型
model.fit(data, labels, epochs=10, batch_size=32)

# 检查训练是否稳定，是否达到较好的准确率

提升训练效率：
适当的激活函数可以提高模型的训练效率。激活函数的选择影响模型的学习速度、收敛性和最终性能。ReLU等激活函数因其计算效率高，广泛用于各种深度学习任务。

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

# 创建一个简单的卷积神经网络
model = keras.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),  # 卷积层
    layers.MaxPooling2D((2, 2)),  # 池化层
    layers.Conv2D(64, (3, 3), activation='relu'),  # 另一个卷积层
    layers.MaxPooling2D((2, 2)),  # 另一个池化层
    layers.Flatten(),  # 展平层
    layers.Dense(128, activation='relu'),  # 全连接层
    layers.Dense(10, activation='softmax')  # 输出层
])

# 编译和训练模型
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

支持概率分布：
某些激活函数（如Softmax）用于将输出转换为概率分布，这在多分类问题中非常有用。通过Softmax，可以从网络的输出中得到每个类别的概率，从而实现概率上的解释和决策。

总体而言，激活函数在神经网络中起着关键作用，确保模型能够以非线性的方式处理信息，并在不同任务中发挥作用。

二、常用的激活函数

1. Sigmoid

函数定义： $\frac{1}{1 + \exp(-x)}$
输出范围：0 到 1
用途：常用于二分类问题的输出层。
优点：输出值限定在 0 到 1 之间，适合概率表示。
缺点：容易在极端输入下饱和，导致梯度消失。
导数： $\cdot (1 - f(x))$

2. Tanh

函数定义： $\tanh(x) = \frac{\exp(x) - \exp(-x)}{\exp(x) + \exp(-x)}$
输出范围：-1 到 1
用途：常用于循环神经网络（RNN）等需要归一化的情境。
优点：中心在 0，有助于梯度更平稳传播。
缺点：与 Sigmoid 类似，容易在极端输入下饱和。
导数： $f'(x) = 1 - \tanh(x)^2$

3. ReLU（Rectified Linear Unit）

函数定义： $\max(0, x)$
输出范围：0 到正无穷
用途：广泛用于深度学习中的卷积神经网络和多层感知器。
优点：计算效率高，避免了梯度消失问题。
缺点：当输入小于或等于 0 时，导数为 0，可能导致“神经元死亡”。
导数： $f^{'} (x) = 1$ （x > 0）， $f^{'} (x) = 0$ （x ≤ 0）

4. Leaky ReLU

函数定义： $\max(ax, x)$ ，其中 a 通常是一个小的常数（例如 0.01）。
输出范围：负无穷到正无穷
用途：解决 ReLU 的“神经元死亡”问题。
优点：允许负值区域的梯度传播，缓解“神经元死亡”。
导数： $f^{'} (x) = 1$ （x > 0）， $f^{'} (x) = a$ （x ≤ 0）

5. ELU（Exponential Linear Unit）

函数定义： $f (x) = x$ （x > 0），否则 $\alpha (\exp(x) - 1)$ 。
输出范围：负无穷到正无穷
用途：类似于 Leaky ReLU，但更平滑。
优点：在负值区域提供更平滑的输出，允许负值区域的梯度传播。
导数： $f^{'} (x) = 1$ （x > 0），否则 $\alpha \exp(x)$

6. Softmax

函数定义： $f(x_i) = \frac{\exp(x_i)}{\sum_{j=1}^{n} \exp(x_j)}$
用途：通常用于多分类问题的输出层。
优点：将输出转换为概率分布。
导数：Softmax 的导数相对复杂，但在一般情况下，Softmax 的导数涉及到输出概率与 Kronecker delta 的关系，通常用来计算多类交叉熵的梯度。

import numpy as np
import matplotlib.pyplot as plt

# 定义激活函数及其导数
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
    s = sigmoid(x)
    return s * (1 - s)

def tanh(x):
    return np.tanh(x)

def tanh_derivative(x):
    return 1 - np.tanh(x) ** 2

def relu(x):
    return np.maximum(0, x)

def relu_derivative(x):
    return (x > 0).astype(float)

def leaky_relu(x, alpha=0.01):
    return np.where(x > 0, x, alpha * x)

def leaky_relu_derivative(x, alpha=0.01):
    return np.where(x > 0, 1, alpha)

# 创建x轴上的范围
x = np.linspace(-5, 5, 100)

# 创建子图，用于绘制激活函数及其导数
fig, axs = plt.subplots(3, 2, figsize=(12, 10))
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
# 绘制Sigmoid函数及其导数
axs[0, 0].plot(x, sigmoid(x), label='Sigmoid', color='b')
axs[0, 0].set_title("Sigmoid函数")
axs[0, 0].grid(True)

axs[0, 1].plot(x, sigmoid_derivative(x), label='Sigmoid Derivative', color='b')
axs[0, 1].set_title("Sigmoid导数")
axs[0, 1].grid(True)

# 绘制Tanh函数及其导数
axs[1, 0].plot(x, tanh(x), label='Tanh', color='g')
axs[1, 0].set_title("Tanh函数")
axs[1, 0].grid(True)

axs[1, 1].plot(x, tanh_derivative(x), label='Tanh Derivative', color='g')
axs[1, 1].set_title("Tanh导数")
axs[1, 1].grid(True)

# 绘制ReLU函数及其导数
axs[2, 0].plot(x, relu(x), label='ReLU', color='r')
axs[2, 0].set_title("ReLU函数")
axs[2, 0].grid(True)

axs[2, 1].plot(x, relu_derivative(x), label='ReLU Derivative', color='r')
axs[2, 1].set_title("ReLU导数")
axs[2, 1].grid(True)

# 为每个子图设置标签
for ax in axs.flat:
    ax.legend()
    ax.set_xlabel("x 轴")
    ax.set_ylabel("y 轴")

# 调整布局
plt.tight_layout()
plt.show()

三、归一化函数

1.归一化函数的作用

归一化函数在机器学习和深度学习中用于将数据缩放到特定的范围或标准化成一定的分布。归一化可以帮助模型更好地训练和泛化，尤其是在特征范围差异很大或数据不均匀时。归一化的主要目标是确保输入数据在模型中保持一致的尺度。
归一化函数在机器学习和深度学习中用于将数据缩放到特定的范围或标准化成一定的分布。归一化可以帮助模型更好地训练和泛化，尤其是在特征范围差异很大或数据不均匀时。归一化的主要目标是确保输入数据在模型中保持一致的尺度。

为什么需要归一化？

提高模型的训练效率：归一化可以加速模型的收敛，使得梯度更新更加稳定。
防止数值不稳定：当特征值的尺度相差很大时，可能导致模型训练过程中的数值不稳定。归一化可以缓解这种问题。
增强模型的泛化能力：归一化可以帮助模型更好地泛化到未见过的数据。

常见的归一化函数

以下是一些常用的归一化函数及其应用场景：

1. Min-Max 归一化

Min-Max 归一化将数据缩放到特定范围（通常是 0 到 1）。该方法确保所有特征的值都在相同范围内。

公式：[ y = \frac{x - \min(x)}{\max(x) - \min(x)} ]
应用场景：适用于特征值范围已知且稳定的情况，如图像数据。

import numpy as np

# 示例数据
data = np.array([10, 20, 30, 40, 50])

# Min-Max 归一化
min_val = data.min()
max_val = data.max()
normalized_data = (data - min_val) / (max_val - min_val)

print("归一化后的数据:", normalized_data)

2. Z-Score 归一化（标准化）

Z-Score 归一化将数据调整到均值为 0，标准差为 1。它用于将不同分布的数据转换为标准正态分布。

公式：[ y = \frac{x - \mu}{\sigma} ]
应用场景：适用于特征分布可能变化的情况，如自然语言处理或时间序列数据。

import numpy as np

# 示例数据
data = np.array([10, 20, 30, 40, 50])

# Z-Score 归一化
mean = data.mean()
std_dev = data.std()
standardized_data = (data - mean) / std_dev

print("标准化后的数据:", standardized_data)