感知机

​ 给定输入$x$，权重$w$，和偏移$b$,感知机输出：
KaTeX parse error: Unknown column alignment: o at position 16: \begin{array} o̲ =\sigma(<w,x>+…

或者是二分类：-1或1
Expected node of symbol group type, but got node of type cr

伪代码

​ $y_i$表示真实类，与预测类相乘小于等于0，则说明不相等，预测错了，则更新模型。

​ 等价于使用批量大小为1的梯度下降

使用的损失函数

$$l(y,x,w)=max(0,-y<w,x>)$$

​ 如果分类正确，则$-y<w,x>$小于0，则损失为0，即if语句不成立。

​ 如果分类错误，则有梯度，需要计算梯度，这里的$w,x$是增广过的，含有b，未增广应该为$<w,x>+b$。

​ 每出现一只狗(红色)，则朝下推一些，每出现一只猫(蓝色)，则朝上推一些

收敛定理

​ 感知机是一个很简单的

假设

• 数据在半径$r$内

• 存在余量$\rho$分类两类

  ​ $y(x^{T}w+b)\ge \rho$

对于$||w|{|}^2+b^2\le 1,$感知机保证在$\frac{r^2+1}{{\rho }^2}$步后收敛

XOR问题

​ 感知机不能拟合XOR函数，它只能产生线性分割面，导致第一次AI寒冬

多层感知机

XOR问题

​ 使用两个感知机，做两次，则变为了多层

单隐藏层

单分类

输入$x\in {\mathbb{R}}^n$

隐藏层$W_1\in {\mathbb{R}}^{m\times n},b_1\in {\mathbb{R}}^m$

输出层$w_2\in {\mathbb{R}}^m,b_2\in \mathbb{R}$（单分类，只输出一个)

假设有m个隐藏层，
$$\begin{gathered} h=\sigma (W_{1}x+b_1) \\ o=w_2^{T}h+b_2 \end{gathered}$$
$\sigma$是按元素的激活函数(非线性的)

如果激活函数是线性的,假设是本身，即$\sigma (x)=x$

则
$$\begin{gathered} h=W_{1}x+b_1 \\ o=w_2^T{W}_{1}x+b^{\prime } \end{gathered}$$
输出仍然是一个线性函数，依旧等价于一个单层的感知机

Sigmoid激活函数

将输入投影到(0,1)，速率变化比较好，非零中心化的输出会使得其后一层的神经元的输入发生偏置偏移（BiasShift，并进一步使得梯度下降的收敛速度变慢．
$$sigmoid(x)=\frac{1}{1+exp(-x)}$$

Tanh激活函数

将输入投影到(-1,1)，
$$tanh(x)=\frac{e^x-e^{-x}}{e^x+e^{-x}}=2\times sigmoid(2x)-1$$

ReLU激活函数

ReLU：rectified linear unit
$$ReLU(x)=max(x,0)$$

多类分类

​
$$y_1,y_2,\cdots ,y_k=softmax(o_1,o_2,\cdots ,o_k)$$
输入$x\in {\mathbb{R}}^n$

隐藏层$W_1\in {\mathbb{R}}^{m\times n},b_1\in {\mathbb{R}}^m$

输出层$w_2\in {\mathbb{R}}^{m\times k},b_2\in {\mathbb{R}}^k$（k分类，输出k个)

假设有m个隐藏层，
$$\begin{gathered} h=\sigma (W_{1}x+b_1) \\ o=w_2^{T}h+b_2 \\ y=softmax(o) \end{gathered}$$
$\sigma$是按元素的激活函数(非线性的)

多隐藏层

$$\begin{gathered} h_1=\sigma (W_{1}x+b_1) \\ {h}_2=\sigma (W_{2}x+b_2) \\ {h}_3=\sigma (W_{3}x+b_3) \\ o=W_4{h}_3+b_4 \end{gathered}$$

超参数：

• 隐藏层数
• 每层隐藏层的大小

代码实现

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

d2l.use_svg_display()  # 使用svg来显示图片
batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

# 输入的维度，输出的维度，隐藏层的个数在输入和输出的维度之间
num_inputs, num_outputs, num_hiddens = 784, 10, 256

# randn初始为随机的(输入维度，输出维度，需要更新，则需要梯度)
W1 = nn.Parameter(torch.randn(num_inputs, num_hiddens, requires_grad=True))
b1 = nn.Parameter(torch.zeros(num_hiddens, requires_grad=True))

W2 = nn.Parameter(torch.randn(num_hiddens, num_outputs, requires_grad=True))
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()

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

'''简洁实现'''
net = nn.Sequential(nn.Flatten(), nn.Linear(num_inputs, 256), nn.ReLU(), nn.Linear(256, num_outputs))


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()
trainer = torch.optim.SGD(net.parameters(), lr=lr)

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