快速学会一个算法，MLP

大家好，我是小寒

今天给大家分享一个超强的算法模型，MLP

多层感知器（MLP）是一种前馈神经网络，是最基础且广泛使用的神经网络类型之一。

它由一个输入层、一个或多个隐藏层以及一个输出层组成，每一层都是由若干个神经元构成的。

MLP 能够学习输入数据与输出目标之间的非线性关系，是监督学习任务中常用的模型，尤其是在回归和分类问题中表现优异。

MLP的结构

MLP 由三种类型的层组成。

• 输入层，接收输入特征向量，每个节点代表一个输入特征。

• 隐藏层，由一个或多个隐藏层构成，每个隐藏层由多个神经元组成，这些神经元将前一层的输出通过激活函数进行非线性变换后传递到下一层。

• 输出层，输出最终的预测结果。输出层的神经元数量取决于具体任务，例如分类任务中的类别数。

前向传播

在 MLP 中，数据通过层与层之间的连接传递，具体如下：

1. 输入层到隐藏层

• 对于第 l 层，输入为 ，权重矩阵为 ，偏置为 。
• 线性组合：
• 激活函数：
• 其中，激活函数 f 常见的有 ReLU、Sigmoid、Tanh 等。

隐藏层到输出层

最后一层通常连接到输出层，根据任务的不同选择适当的激活函数。

例如，回归问题中使用线性激活函数，二分类问题中使用 Sigmoid，多分类问题中使用 Softmax。

反向传播

MLP 的训练过程通过反向传播算法进行，目的是最小化损失函数。

反向传播通过计算损失函数对每个参数（权重和偏置）的梯度来调整参数。

1. 损失函数

   损失函数用于衡量预测值和真实值之间的差距，常见的损失函数有均方误差（MSE）和交叉熵损失（Cross-Entropy Loss）。

• 对于均方误差：
• 对于交叉熵损失：

反向传播步骤

• 计算损失函数对输出的梯度。
• 利用链式法则，从输出层到输入层逐层计算梯度。
• 使用梯度下降算法（如随机梯度下降、Adam等）更新每一层的参数

  其中， 是学习率。

案例代码

下面是一个使用 PyTorch 来实现一个多层感知机来解决二分类问题的示例代码。

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

# 生成一些简单的二分类数据
torch.manual_seed(0)
X = torch.rand(1000, 20)  # 1000 个样本，每个样本 20 个特征
y = (X.sum(dim=1) > 10).float().unsqueeze(1)  # 如果特征之和大于10，标签为1，否则为0

# 将数据分割成训练集和测试集
train_X, test_X = X[:800], X[800:]
train_y, test_y = y[:800], y[800:]

# 创建 DataLoader
train_data = TensorDataset(train_X, train_y)
train_loader = DataLoader(train_data, batch_size=32, shuffle=True)

# 定义 MLP 模型
class MLP(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(MLP, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size, output_size)
        self.sigmoid = nn.Sigmoid()
    
    def forward(self, x):
        out = self.fc1(x)
        out = self.relu(out)
        out = self.fc2(out)
        out = self.sigmoid(out)
        return out

# 模型实例化
model = MLP(input_size=20, hidden_size=10, output_size=1)

# 定义损失函数和优化器
criterion = nn.BCELoss()  # 二分类交叉熵损失
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练模型
num_epochs = 20
for epoch in range(num_epochs):
    for inputs, labels in train_loader:
        # 前向传播
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        
        # 反向传播及优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    
    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

# 测试模型
with torch.no_grad():
    test_outputs = model(test_X)
    predicted = (test_outputs > 0.5).float()
    accuracy = (predicted == test_y).float().mean()
    print(f'Accuracy: {accuracy:.4f}')

最后

—

今天的分享就到这里。如果觉得近期的文章不错，请点赞，转发安排起来。‍‍欢迎大家进高质量 python 学习群

「进群方式：加我微信，备注 “python”」

往期回顾

    

如果对本文有疑问可以加作者微信直接交流。