BP神经网络激活函数：从Sigmoid到ReLU的演进与实战避坑指南

1次阅读

没有评论

共计 5611 个字符，预计需要花费 15 分钟才能阅读完成。

在神经网络中，激活函数就像一个个微小的决策单元，决定着一个神经元是否应该被激活。它的存在让神经网络具备了非线性表达能力，能够拟合复杂的函数关系。

想象一下，如果没有激活函数，神经网络就只是一堆线性变换的叠加，无论叠加多少层，最终的效果仍然等同于一个单层线性网络。这显然无法胜任复杂的任务，比如图像分类或语音识别。

线性 vs 非线性：激活函数引入了非线性因素，让网络可以学习更复杂的模式。
决定神经元输出：它决定了神经元的输出值，通常将输入映射到某个特定范围内。

数学表达式：
$$
\sigma(x) = \frac{1}{1 + e^{-x}}
$$

导数：
$$
\sigma'(x) = \sigma(x)(1 – \sigma(x))
$$

特点：
– 输出范围在 (0,1) 之间
– 容易导致梯度消失问题（当输入值较大或较小时，导数趋近于 0）

数学表达式：
$$
\tanh(x) = \frac{e^x – e^{-x}}{e^x + e^{-x}}
$$

导数：
$$
\tanh'(x) = 1 – \tanh^2(x)
$$

特点：
– 输出范围在 (-1,1) 之间
– 比 Sigmoid 函数有更强的梯度（因为均值在 0 附近）
– 但仍然存在梯度消失问题

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

导数：
$$
\text{ReLU}'(x) = \begin{cases}
1 & \text{如果} x > 0 \
0 & \text{如果} x \leq 0
\end{cases}
$$

特点：
– 计算简单高效
– 解决了梯度消失问题（在正区间）
– 可能导致 ”Dead ReLU” 问题（神经元永远不被激活）

数学表达式：
$$
\text{LeakyReLU}(x) = \begin{cases}
x & \text{如果} x > 0 \
\alpha x & \text{如果} x \leq 0
\end{cases}
$$

其中 α 是一个小的正数（如 0.01）。

特点：
– 解决了 ReLU 的 Dead 问题
– 在负区间也有小的梯度

下面我们用 PyTorch 实现一个简单的全连接网络，在 MNIST 数据集上测试不同激活函数的表现。

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt

# 1. 准备数据
transform = transforms.Compose([transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)

testset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False)

# 2. 定义网络
class Net(nn.Module):
    def __init__(self, activation='relu'):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(28*28, 512)
        self.fc2 = nn.Linear(512, 256)
        self.fc3 = nn.Linear(256, 128)
        self.fc4 = nn.Linear(128, 10)

        # 初始化权重
        for m in self.modules():
            if isinstance(m, nn.Linear):
                # 根据激活函数选择不同的初始化方法
                if activation == 'relu' or activation == 'leaky_relu':
                    nn.init.kaiming_normal_(m.weight, mode='fan_in', nonlinearity='relu')
                elif activation == 'sigmoid' or activation == 'tanh':
                    nn.init.xavier_normal_(m.weight, gain=nn.init.calculate_gain(activation))
                nn.init.constant_(m.bias, 0.1)

        # 选择激活函数
        if activation == 'sigmoid':
            self.activation = nn.Sigmoid()
        elif activation == 'tanh':
            self.activation = nn.Tanh()
        elif activation == 'leaky_relu':
            self.activation = nn.LeakyReLU(0.01)
        else:  # 默认使用 ReLU
            self.activation = nn.ReLU()

    def forward(self, x):
        x = x.view(-1, 28*28)  # 展平输入
        x = self.activation(self.fc1(x))
        x = self.activation(self.fc2(x))
        x = self.activation(self.fc3(x))
        x = self.fc4(x)  # 最后一层不使用激活函数
        return x

# 3. 训练函数
def train_model(activation='relu', lr=0.01, epochs=10):
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    model = Net(activation=activation).to(device)
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.SGD(model.parameters(), lr=lr, momentum=0.9)

    # 学习率衰减
    scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.1)

    train_losses = []
    train_accs = []

    for epoch in range(epochs):
        model.train()
        running_loss = 0.0
        correct = 0
        total = 0

        for i, (inputs, labels) in enumerate(trainloader, 0):
            inputs, labels = inputs.to(device), labels.to(device)

            optimizer.zero_grad()

            outputs = model(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()

            running_loss += loss.item()
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()

            if i % 200 == 199:
                print(f'[{epoch+1}, {i+1}] loss: {running_loss/200:.3f}')
                running_loss = 0.0

        scheduler.step()

        train_loss = running_loss / len(trainloader)
        train_acc = 100 * correct / total
        train_losses.append(train_loss)
        train_accs.append(train_acc)

        print(f'Epoch {epoch+1}, Loss: {train_loss:.4f}, Accuracy: {train_acc:.2f}%')

    # 测试
    model.eval()
    test_correct = 0
    test_total = 0
    with torch.no_grad():
        for inputs, labels in testloader:
            inputs, labels = inputs.to(device), labels.to(device)
            outputs = model(inputs)
            _, predicted = torch.max(outputs.data, 1)
            test_total += labels.size(0)
            test_correct += (predicted == labels).sum().item()

    test_acc = 100 * test_correct / test_total
    print(f'Test Accuracy: {test_acc:.2f}%')

    return train_losses, train_accs, test_acc

# 4. 训练不同激活函数的模型
activations = ['sigmoid', 'tanh', 'relu', 'leaky_relu']
results = {}

for act in activations:
    print(f'\nTraining with {act} activation function...')
    losses, accs, test_acc = train_model(activation=act, epochs=15)
    results[act] = {'losses': losses, 'accs': accs, 'test_acc': test_acc}

# 5. 可视化结果
plt.figure(figsize=(12, 5))

# 准确率曲线
plt.subplot(1, 2, 1)
for act in activations:
    plt.plot(results[act]['accs'], label=act)
plt.title('Training Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy (%)')
plt.legend()

# 损失曲线
plt.subplot(1, 2, 2)
for act in activations:
    plt.plot(results[act]['losses'], label=act)
plt.title('Training Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()

plt.tight_layout()
plt.show()

# 打印测试准确率
print('\nTest Accuracy Comparison:')
for act in activations:
    print(f'{act}: {results[act]["test_acc"]:.2f}%')

通过上述实验，我们可以观察到：