李沐pytorch学习-多层感知机及其实现

兰宵宫

已于 2023-08-20 15:48:22 修改

阅读量1k

点赞数 1

分类专栏：深度学习基础知识文章标签： pytorch 学习人工智能

于 2023-08-16 00:01:03 首次发布

本文链接：https://blog.csdn.net/qq_26545507/article/details/132306358

版权

深度学习基础知识专栏收录该内容

9 篇文章 0 订阅

订阅专栏

一、多层感知机的定义

多层感知机就是全连接层神经网络，如图1所示，其中隐含层可以有多层

图1. 多层感知机结构（隐含层与输出层之间为全连接，图中少了几根连接线）

“层”定义为输入权重（weight）与偏差（bias）的组合，如图2所示。

图2. “层”的定义

二、运行原理

2.1 数据输入

Input层输入向量 $\mathbf{X}=\begin{bmatrix} x_0\\ x_1\\ ...\\ x_{n-1} \end{bmatrix}$ ，为每个输入层节点的数值，即 $\left\{\begin{matrix} I_0=x_0\\ I_1=x_2\\ ...\\ I_{n-1}=x_{n-1} \end{matrix}\right.$ ，如图3所示。

图3. 多层感知机数据的输入（图中以输入层3个神经元，一个4神经元的隐含层，两个输出神经元为例，可包含多个隐含层，每层神经元个数不固定）

2.2 从输入层前向传播到隐含层

先看隐含层单个神经元 $H_0$ 的数据传输情况，如图4所示，每根连线都有一个权重（weight， $w_{0,0},w_{1,0},w_{2,0}$ ），隐含层每个神经元都有一个偏置（bias， $b_0$ ），sigmoid为激活函数，此时有

$H_0=sigmoid\left ( w_{0,0}\cdot I_0+w_{1,0}\cdot I_1+w_{2,0}\cdot I_2+b_0=\left [ w_{0,0},w_{1,0},w_{2,0} \right ]\cdot \begin{bmatrix} I_0\\ I_1\\ I_2 \end{bmatrix}+b_0 \right )$

图4. 单个神经元数据传输情况

同理有

$H_1=sigmoid\left ( w_{0,1}\cdot I_0+w_{1,1}\cdot I_1+w_{2,1}\cdot I_2+b_1=\left [ w_{0,1},w_{1,1},w_{2,1} \right ]\cdot \begin{bmatrix} I_0\\ I_1\\ I_2 \end{bmatrix}+b_1 \right )\\H_2=sigmoid\left ( w_{0,2}\cdot I_0+w_{1,2}\cdot I_1+w_{2,2}\cdot I_2+b_2=\left [ w_{0,2},w_{1,2},w_{2,2} \right ]\cdot \begin{bmatrix} I_0\\ I_1\\ I_2 \end{bmatrix}+b_2 \right )$

将隐含层数值拼成列向量有：

$\begin{bmatrix} H_0\\ H_1\\ H_2\\H_3 \end{bmatrix}=sigmoid\left ( \begin{bmatrix} w_{0,0},w_{1,0},w_{2,0}\\ w_{0,1},w_{1,1},w_{2,1}\\ w_{0,2},w_{1,2},w_{2,2}\\ w_{0,3},w_{1,3},w_{2,3} \end{bmatrix}\cdot \begin{bmatrix} I_0\\ I_1\\ I_2 \end{bmatrix}+\begin{bmatrix} b_0\\ b_1\\ b_2\\ b_3 \end{bmatrix} \right )$

隐含层传播到下一隐含层，隐含层传播到输出层同理。

三、多层感知机的代码实现

3.1 从零开始实现

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

# 一个batch更新一次参数，例如训练集有100个数据
# batch_size = 10，则遍历训练集更新10次参数，训练集完整跑一遍称为一个 epoch
batch_size = 256

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

# 输入层神经元数，输出层神经元数，第一层隐含层神经元数
num_inputs, num_outputs, num_hiddens = 784, 10, 256

# 从输入层到第一隐含层的权重矩阵
W1 = nn.Parameter(torch.randn(
num_inputs, num_hiddens, requires_grad=True) * 0.01)

# 第一隐含层的 bias 矩阵
b1 = nn.Parameter(torch.zeros(num_hiddens, requires_grad=True))

# 从第一隐含层到输出层的权重矩阵
W2 = nn.Parameter(torch.randn(
num_hiddens, num_outputs, requires_grad=True) * 0.01)

# 输出层的bias矩阵
b2 = nn.Parameter(torch.zeros(num_outputs, requires_grad=True))

# 所有需要更新的参数
params = [W1, b1, W2, b2]

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

# 网络
def net(X):
    # 将输入整理成列向量
    X = X.reshape((-1, num_inputs))

    # 从输入层到隐含层的计算过程
    H = relu(X@W1 + b1) # 这里“@”代表矩阵乘法

    # 返回从隐含层到输出层的计算结果
    return (H@W2 + b2)

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

# epoch 数和学习率
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)

3.2 简洁实现

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

net = nn.Sequential(nn.Flatten(),
    nn.Linear(784, 256),
    nn.ReLU(),
    nn.Linear(256, 10))

def init_weights(m):
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, std=0.01)

net.apply(init_weights);

batch_size, lr, num_epochs = 256, 0.1, 10
loss = nn.CrossEntropyLoss(reduction='none')
trainer = torch.optim.SGD(net.parameters(), lr=lr)

train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)