【深度学习】二、多层感知机（MLP）

神经元的数学模型：每个神经元可以被看作一个非线性函数。它接收来自上一层神经元的输入，并使用一组权重和一个偏置进行计算，然后通过一个激活函数将计算结果转换为输出。常见的激活函数包括sigmoid函数、ReLU函数等。
前向传播：多层感知机通过前向传播来将输入数据从输入层通过隐藏层传递到输出层。在前向传播过程中，每个神经元根据上一层传递过来的输入，使用权重和偏置进行计算，并通过激活函数产生输出。
反向传播：在训练多层感知机时，需要使用反向传播算法来计算预测输出和实际输出之间的误差，并将误差反向传播到每个神经元，从而更新权重和偏置。反向传播算法使用梯度下降的方法来最小化误差函数，从而优化神经网络的参数。
损失函数：损失函数用于衡量预测输出和实际输出之间的差异。常用的损失函数包括均方误差（Mean Squared Error, MSE）和交叉熵（Cross Entropy）等。
权重和偏置：每个神经元都有与之关联的权重和偏置。权重用于调节输入的重要性，偏置用于调节神经元的激活阈值。在训练过程中，通过反向传播算法来更新权重和偏置，从而使神经网络能够更好地拟合训练数据。

综上所述，多层感知机的数学概念涉及神经元的数学模型、前向传播、反向传播、损失函数以及权重和偏置的调节。这些概念共同构成了多层感知机的基本数学框架，使得它能够完成复杂的非线性映射任务。

2 多层感知机的结构

多层感知机（Multilayer Perceptron, MLP）是一种前馈神经网络，它由输入层、若干隐藏层和输出层组成。每一层都由多个神经元（或称为节点）组成。

输入层（Input Layer）：输入层接收外部输入的数据，将其传递到下一层。每个输入特征都对应一个神经元。
隐藏层（Hidden Layer）：隐藏层是位于输入层和输出层之间的一层或多层神经元。每个隐藏层的神经元接收上一层传来的输入，并通过权重和激活函数进行计算，然后将结果传递到下一层。隐藏层的存在可以使多层感知机具备更强的非线性拟合能力。
输出层（Output Layer）：输出层接收隐藏层的输出，并产生最终的输出结果。输出层的神经元数目通常与任务的输出类别数目一致。对于分类任务，输出层通常使用softmax激活函数来计算每个类别的概率分布；对于回归任务，输出层可以使用线性激活函数。

多层感知机的各层之间是全连接的，也就是说，每个神经元都与上一层的每个神经元相连。每个连接都有一个与之相关的权重和一个偏置。

多层感知机的结构可以根据任务的需求进行灵活设计，包括隐藏层数目、每层的神经元数目、激活函数的选择等。通过调整网络结构和参数，多层感知机可以适应不同的问题，并提供高精度的预测和决策能力。

3 多层感知机的应用

多层感知机（Multilayer Perceptron, MLP）在机器学习和人工智能领域有广泛的应用。以下是其中一些应用领域：

图像识别：多层感知机在图像识别任务中被广泛使用，例如物体识别、人脸识别、手写数字识别等。通过多个隐藏层和神经元的组合，多层感知机可以学习到更复杂的特征表示，从而提高图像分类的准确性。
自然语言处理：多层感知机在自然语言处理任务中也有应用，如情感分析、文本分类、机器翻译等。通过将文本数据转换为向量表示，并通过多层感知机进行学习和预测，可以实现对文本的语义理解和情感分析。
推荐系统：多层感知机可以用于构建推荐系统，通过学习用户的历史行为和偏好，预测用户可能感兴趣的产品或内容。通过多层感知机的学习能力，可以提高推荐系统的个性化程度，提高用户满意度。
金融预测：多层感知机可以用于金融市场的预测和分析，例如股票价格预测、货币汇率预测等。通过学习历史数据和相关因素，多层感知机可以捕捉到金融市场的复杂动态，并进行预测和决策。
医学诊断：多层感知机在医学领域也有应用，例如医学图像分析、疾病诊断等。通过多层感知机的学习和推理能力，可以帮助医生提高诊断准确性和效率，提供更好的医疗服务。

这些只是多层感知机应用的一些例子，实际上，由于多层感知机的强大学习能力和灵活性，它在各种领域都有广泛应用。

4 代码实现

4.1 代码

4.1.1 手动实现

import torch
from torch import nn
from d2l import torch as d2l

batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

#初始化模型参数
num_inputs, num_outputs, num_hiddens = 784, 10, 256
#num_inputs:输入特征的数量，对于28x28的图像，特征为784
#num_outputs:输出的类别
#num_hiddens:隐藏层256
W1 = nn.Parameter(torch.randn( #w是随机的
    num_inputs, num_hiddens, requires_grad=True) * 0.01) #行数是784，列数是256，获取梯度
#形状(num_inputs, num_hiddens)：784，256
b1 = nn.Parameter(torch.zeros(num_hiddens, requires_grad=True))
#形状(num_hiddens,)：256行
W2 = nn.Parameter(torch.randn(
    num_hiddens, num_outputs, requires_grad=True) * 0.01)
#形状(num_hiddens, num_outputs)：256行，10列
b2 = nn.Parameter(torch.zeros(num_outputs, requires_grad=True))
#形状(num_ouputs,)：10行

params = [W1, b1, W2, b2]

#激活函数
def relu(X):
    a = torch.zeros_like(X)
    return torch.max(X, a)

#模型
def net(X):
    #X是4维张量，X的形状是(batch_size, 1, 28, 28)
    #1表示单通道，28x28
    #重塑为2维张量（批量大小，num_inputs）：（256，784）
    X = X.reshape((-1, num_inputs))
    #x变为256行，784列的矩阵
    #与权重w1（矩阵）相乘，加上偏置，进行relu方法，小于0为0
    H = relu(X@W1 + b1)  # 这里“@”代表矩阵乘法
    #H变成了256行，256列的矩阵
    return (H@W2 + b2)
    #H变成了256行，10列的矩阵

#计算每个图像的损失
loss = nn.CrossEntropyLoss(reduction='none')
#训练
num_epochs, lr = 10, 0.1
#使用sgd作为优化器，采用随机梯度下降算法，随时更新模型参数
updater = torch.optim.SGD(params, lr=lr)
#迭代地执行前向传播、计算损失、执行反向传播，并使用优化器更新模型参数
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, updater)
d2l.plt.show()
#输出每个样本的预测结果
d2l.predict_ch3(net, test_iter)
d2l.plt.show()

4.1.2 运行结果

4.2 简洁实现

4.2.1 代码

import torch
from torch import nn
from d2l import torch as d2l

batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)
# 创建了一个顺序容器
net = nn.Sequential(nn.Flatten(), # 将输入数据展平为一维
                    nn.Linear(784, 256), # 隐藏层/线性层：将输入从784维映射到256维
                    nn.ReLU(), # 激活函数层
                    #nn.Tanh(),
                    #nn.Sigmoid(),
                    nn.Linear(256, 10)) # 隐藏层/先行曾：将输入从256维映射到10维

#如果net中的模块m为nn.Linear类型，使用标准正态分布初始化线性层的权重，标准差为0.01
def init_weights(m):
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, std=0.01)

#将init_weights函数应用于模型net的每个模块，初始化权重
net.apply(init_weights)
#计算每个图像的损失
loss = nn.CrossEntropyLoss(reduction='none')
#模型参数
num_epochs,lr = 10, 0.1
updater = torch.optim.SGD(net.parameters(), lr=lr)
#迭代地执行前向传播、计算损失、执行反向传播，并使用优化器更新模型参数
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, updater)
d2l.plt.show()
#输出每个样本的预测结果
d2l.predict_ch3(net, test_iter)
d2l.plt.show()

4.2.2 运行结果

4.3 面向对象

4.3.1 代码

import torch
from torch import nn
from d2l import torch as d2l
import matplotlib.pyplot as plt

class Net(nn.Module):
    def __init__(self, num_inputs, num_hiddens, num_outputs):
        super(Net, self).__init__()
        self.num_inputs = num_inputs
        self.num_hiddens = num_hiddens
        self.num_outputs = num_outputs
        # 初始化权重和偏置
        self.W1 = nn.Parameter(torch.randn(num_inputs, num_hiddens) * 0.01)
        self.b1 = nn.Parameter(torch.zeros(num_hiddens))
        self.W2 = nn.Parameter(torch.randn(num_hiddens, num_outputs) * 0.01)
        self.b2 = nn.Parameter(torch.zeros(num_outputs))

    # 定义前向传播
    def forward(self, X):
        X = X.reshape((-1, self.num_inputs))
        H = self.relu(X @ self.W1 + self.b1)
        return H @ self.W2 + self.b2

    # 定义ReLU激活函数
    def relu(self, X):
        return torch.max(X, torch.zeros_like(X))

if __name__ == '__main__':
    # 设置超参数
    batch_size = 256
    num_inputs, num_hiddens, num_outputs = 784, 256, 10

    # 加载数据
    train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

    # 实例
    net = Net(num_inputs, num_hiddens, num_outputs)

    # 定义损失函数
    loss = nn.CrossEntropyLoss(reduction='none')

    # 设置训练参数
    num_epochs, lr = 10, 0.1
    optimizer = torch.optim.SGD(net.parameters(), lr=lr)

    # 训练模型
    d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, optimizer)
    plt.show()

    # 预测并显示测试集的预测结果
    d2l.predict_ch3(net, test_iter)
    plt.show()

4.3.2 运行结果

参考资料

标签：nn,torch,多层,感知机,MLP,num,神经元
From： https://blog.csdn.net/zxqq_/article/details/143780974