多层感知机分类matlab 多层感知机实现

多层感知机

第一篇【人工智能学习】【一】线性回归当中，输入和输出之间包含一个$W$和$b$参数，可以看做是一个单层的模型。多层感知机(MLP,MultilayerPerceptron)，顾名思义是多个层，有多个$W$参数矩阵和多个$b$。这里介绍的是单隐含层的感知机（单隐含层意味着有2层）。接下来对比一下单层线性结构和多层结构的区别，注意这里没有说多层线性结构。但是我们还是要看一下多层线性结构的问题。

图中黑色的线叫做连接，输入层的每个蓝色的神经元和隐含层的神经元都有连接，这种方式叫做全连接。（有种优化网络的方式叫dropout，随机去除一些连接）。隐含层左侧的连接是一个$W$矩阵，右侧也是一个$W$矩阵。所以单隐含层有两个$W$参数矩阵。

我们设输入为$X$，绿色节点左侧的$W_h$和$b_h$，右侧为$W_o$和$b_o$，隐藏层的输出（也称为隐藏层变量或隐藏变量）为$H$（也是个矩阵），输出为$O$，那么会得到如下

$H=XW_h+b_h$

$O=HW_o+b_o$

将上面两个式子进行联立，得到

$O=(XW_h+b_h)W_o+b_o$

$O=XW_hW_o+b_hW_o+b_o$

把参数矩阵进行抽象合并，得到

$O=XW+b$

是不是有些熟悉，这个就是【人工智能学习】【一】线性回归中那么公式。可见这样做只是形式上分成了两层，单从数学上依然是一个单层的线性结构。在线性空间内，两个$W$矩阵相乘只是做了一次线性变化，具体来说叫仿射变换，这种变换没有改变函数的线性结构。（如何理解仿射变换）要解决这个问题，就引入了非线性函数，在隐含层节点上做一些事情。

$H=XW_h+b_h$

$H_{out}=f(H)$

这里用一个函数来处理了一下原来的$H$，这个$f(x)$就是激活函数（Activation Function）。接下来的问题是激活函数有哪些，如何选择激活函数。

激活函数

ReLU

这个函数只保留正数，用数学表达

$max(0,x)$

值域是$[0,+\infty)$

梯度

特点是相比其他激活函数运算速度快，深度学习当中常用。（这么简单的函数…我一度怀疑引入非线性结构是不是也可以随机对点进行丢弃）

Sigmoid函数

公式

$y=\frac{1}{1+e^{-x}}$

值域$(0,1)$

梯度

梯度在$x=0$时最大，为0.25，在x轴两遍迅速趋近于0

tanh函数

$y=\frac{1-e^{-2x}}{1+e^{-2x}}$

tanh双曲正切函数。和sigmod比较像，区别就在函数图像上，比如这里取$x=2$时，sigmod更为平缓，tanh更为陡峭，梯度变化的快。但方向上都差不多，感觉没那么大差别啊，这里还需要在细节深入了解一下。

和sigmod关系

$1-2*sigmod=-tanh(\frac{x}{2})$

梯度

梯度在$x=0$时最大为1

激活函数的选择

ReLu函数是一个通用的激活函数，目前在大多数情况下使用。但是，ReLU函数只能在隐藏层中使用。
用于分类器时，sigmoid函数及其组合通常效果更好。由于梯度消失问题，有时要避免使用sigmoid和tanh函数。
在神经网络层数较多的时候，最好使用ReLu函数，ReLu函数比较简单计算量少，而sigmoid和tanh函数计算量大很多。
在选择激活函数的时候可以先选用ReLu函数如果效果不理想可以尝试其他激活函数。

多层感知机表达式

$H=f(XW_h+b_h)$
$O=HW_o+b_o$

代码实现

手写

包导入

import torch
import numpy as np
import sys
sys.path.append("/home/kesci/input")
import d2lzh as d2l

数据集获取

# 读取数据训练集和测试集
batch_size = 256
num_workers = 4
train_iter = torch.utils.data.DataLoader(mnist_train, batch_size=batch_size, shuffle=True, num_workers=num_workers)
test_iter = torch.utils.data.DataLoader(mnist_test, batch_size=batch_size, shuffle=False, num_workers=num_workers)

定义模型参数

num_inputs, num_outputs, num_hiddens = 784, 10, 256
w1 = torch.tensor(torch.random.normal(0, 0.01, (num_inputs, num_hiddens)), dtype=torch.float))
b1 = torch.tensor(torch.random.normal(num_hiddens, dtype=torch.float))
w2 = torch.tensor(torch.random.normal(0, 0.01, (num_hiddens,num_outputs)), dtype=torch.float))
b2 = torch.tensor(torch.random.normal(num_outputs, dtype=torch.float))
# 赋予梯度
params = [W1, b1, W2, b2]
for param in params:
    param.requires_grad_(requires_grad=True)

定义激活函数

def relu(X):
	return torch.max(input = X, other = torch.tensor(0.0))

定义网络

def net(X):
    X = X.view((-1, num_inputs))
    H = relu(torch.matmul(X, W1) + b1)
    return torch.matmul(H, W2) + b2

定义损失函数，这里使用交叉熵，在【人工智能学习】【二】Softmax与分类模型中有介绍

loss = torch.nn.CrossEntropyLoss()

训练

num_epochs, lr = 5, 100.0
def train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size,
               params=None, lr=None, optimizer=None):
     for epoch in range(num_epochs):
         train_l_sum, train_acc_sum, n = 0.0, 0.0, 0
         for X, y in train_iter:
             # 得到预测值
             y_hat = net(X)
             l = loss(y_hat, y).sum()
             
             # 梯度清零
             if optimizer is not None:
                 optimizer.zero_grad()
             elif params is not None and params[0].grad is not None:
                 for param in params:
                     param.grad.data.zero_()
            
             l.backward()
             if optimizer is None:
                 d2l.sgd(params, lr, batch_size)
             else:
                 optimizer.step()  # “softmax回归的简洁实现”一节将用到
             
             train_l_sum += l.item()
             train_acc_sum += (y_hat.argmax(dim=1) == y).sum().item()
             n += y.shape[0]
         test_acc = evaluate_accuracy(test_iter, net)
         print('epoch %d, loss %.4f, train acc %.3f, test acc %.3f'
               % (epoch + 1, train_l_sum / n, train_acc_sum / n, test_acc))

d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size, params, lr)

torch实现

包导入

import torch
from torch import nn
from torch.nn import init
import numpy as np
import sys
sys.path.append("/home/kesci/input")
import d2lzh as d2l

初始化模型和各个参数

num_inputs, num_outputs, num_hiddens = 784, 10, 256
    
net = nn.Sequential(
        d2l.FlattenLayer(),
        nn.Linear(num_inputs, num_hiddens),
        nn.ReLU(),
        nn.Linear(num_hiddens, num_outputs), 
        )
    
for params in net.parameters():
    init.normal_(params, mean=0, std=0.01)

训练

batch_size = 256

train_iter = torch.utils.data.DataLoader(mnist_train, batch_size=batch_size, shuffle=True, num_workers=num_workers)
test_iter = torch.utils.data.DataLoader(mnist_test, batch_size=batch_size, shuffle=False, num_workers=num_workers)

loss = torch.nn.CrossEntropyLoss()

optimizer = torch.optim.SGD(net.parameters(), lr=0.5)

num_epochs = 5
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size, None, None, optimizer)

参考文章

1. nn.Sequential讲解