动手学习机器学习（Day5多层感知机）

多层感知机

相较于单层感知机，多层感知机解决了异或问题，对于其原理，对于n维数据，单层感知机是通过一个线性直线/面（2/3维）将数据进行二分类。而在多层感知机，它通过m个感知机，生成了m个函数，通过这m个函数对原n维数据操作时，将生成m个结果，再将这m个结果通过激活函数映射到1和-1
（或0），这样相当于执行了m步的单层感知机操作，相当于制定了多个分类标准，每一个数据点在每个标准下都有一个1或-1的值，最后再通过输出层，利用每个数据点在m个标准下的值，映射到最终的结果（1/-1）

单隐藏层-单分类

• 输入$\mathbf{x}\in R^n$（有n个特征）
• 隐藏层${\mathbf{W}}_1\in R^{m\ast n},{\mathbf{b}}_1\in R^m$（有m个感知机，每个感知机${\mathbf{w}}_i$对数据的n维特征进行计算，得到一个数值再加偏置，而一共有m个感知机，因此有m个偏置）
• 输出层${\mathbf{w}}_2\in R^m,b_2\in R$
• $\sigma$是激活函数，将每个感知机的结果进行映射，激活函数必须是非线性的，如果激活函数是线性的，那么$o={\mathbf{w}}_2^{\top }{\mathbf{W}}_1\mathbf{x}+b^{‘}={\mathbf{w}}^{‘}\mathbf{x}+b$，可以看到，最后的结果$o$就是一个线性函数，结果还是一个线性模型，等价于一个单层的感知机
  $$\mathbf{h}=\sigma ({\mathbf{W}}_1\mathbf{x}+{\mathbf{b}}_1)$$
  结果维度：
  $$\dim (h)=m\ast 1$$
  $$o={\mathbf{w}}_2^{\top }\mathbf{h}+b_2$$

Sigmoid激活函数

sigmoid函数将输入变换为区间(0, 1)上的输出。 因此，sigmoid通常称为挤压函数（squashing function）： 它将范围（-inf, inf）中的任意输入压缩到区间（0, 1）中的某个值：

$$sigmoid(x)=\frac{1}{1+\exp (-x)}$$
采用e的方式是为了得到软的曲线，如果是硬的版本，在上升沿处无法求导

Tanh激活函数

将输入投影到（-1，1）
$$tanh(x)=\frac{1-\exp (-2x)}{1+\exp (-2x)}$$

ReLU激活函数

$$ReLU(x)=\max (x,0)$$

主要的好处：算起来快，不要做指数运算

多类分类

• 输入$\mathbf{x}\in R^n$（有n个特征）
• 隐藏层${\mathbf{W}}_1\in R^{m\ast n},{\mathbf{b}}_1\in R^m$（有m个感知机，每个感知机${\mathbf{w}}_i$对数据的n维特征进行计算，得到一个数值再加偏置，而一共有m个感知机，因此有m个偏置）
• 输出层${\mathbf{w}}_2\in R^{m\ast k},b_2\in R^k$（增加了维度k）

$$\mathbf{h}=\sigma ({\mathbf{W}}_1\mathbf{x}+{\mathbf{b}}_1)$$
$$\mathbf{o}={\mathbf{W}}_2^{\top }\mathbf{h}+{\mathbf{b}}_2$$
$$\mathbf{y}=softmax(\mathbf{o})$$

一般激活层的设置逐层压缩，第一层的维度可以比数据维度大

总结

• 多层感知机使用隐藏层和激活函数来得到非线性模型
• 常用激活函数是Sigmoid，Tanh，ReLU
• 使用Softmax来处理多类分类
• 超参数为隐藏层数，和各个隐藏层大小

从零开始实现

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

W1 = nn.Parameter(torch.randn(
    num_inputs, num_hiddens, requires_grad=True) * 0.01) #randn是(0,1)正态分布，x0.01就变成（0，0.01）正态
b1 = nn.Parameter(torch.zeros(num_hiddens, requires_grad=True))
W2 = nn.Parameter(torch.randn(
    num_hiddens, num_outputs, requires_grad=True) * 0.01)
b2 = nn.Parameter(torch.zeros(num_outputs, requires_grad=True))

params = [W1, b1, W2, b2]

实现ReLU激活函数

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') #损失

num_epochs, lr = 10, 0.1
updater = torch.optim.SGD(params, lr=lr)
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, updater)

简洁实现

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)