感知机
给定输入
x
x
x,权重
w
w
w,和偏移
b
b
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 y_i yi表示真实类,与预测类相乘小于等于0,则说明不相等,预测错了,则更新模型。
等价于使用批量大小为1的梯度下降
使用的损失函数
l ( y , x , w ) = m a x ( 0 , − y < w , x > ) l(y,x,w)=max(0,-y<w,x>) l(y,x,w)=max(0,−y<w,x>)
如果分类正确,则 − y < w , x > -y<w,x> −y<w,x>小于0,则损失为0,即if语句不成立。
如果分类错误,则有梯度,需要计算梯度,这里的 w , x w,x w,x是增广过的,含有b,未增广应该为 < w , x > + b <w,x>+b <w,x>+b。
每出现一只狗(红色),则朝下推一些,每出现一只猫(蓝色),则朝上推一些
收敛定理
感知机是一个很简单的
假设
-
数据在半径 r r r内
-
存在余量 ρ \rho ρ分类两类
y ( x T w + b ) ≥ ρ y(x^Tw+b)\ge\rho y(xTw+b)≥ρ
对于 ∣ ∣ w ∣ ∣ 2 + b 2 ≤ 1 , ||w||^2+b^2\le 1, ∣∣w∣∣2+b2≤1,感知机保证在 r 2 + 1 ρ 2 \frac{r^2+1}{\rho^2} ρ2r2+1步后收敛
XOR问题
感知机不能拟合XOR函数,它只能产生线性分割面,导致第一次AI寒冬
多层感知机
XOR问题
使用两个感知机,做两次,则变为了多层
单隐藏层
单分类
输入 x ∈ R n x\in \R^n x∈Rn
隐藏层 W 1 ∈ R m × n , b 1 ∈ R m W_1\in \R^{m\times n},b_1\in\R ^m W1∈Rm×n,b1∈Rm
输出层 w 2 ∈ R m , b 2 ∈ R w_2\in \R^m,b_2\in \R w2∈Rm,b2∈R(单分类,只输出一个)
假设有m个隐藏层,
h
=
σ
(
W
1
x
+
b
1
)
o
=
w
2
T
h
+
b
2
h=\sigma(W_1x+b_1)\\ o=w_2^Th+b_2
h=σ(W1x+b1)o=w2Th+b2
σ
\sigma
σ是按元素的激活函数(非线性的)
如果激活函数是线性的,假设是本身,即 σ ( x ) = x \sigma(x)=x σ(x)=x
则
h
=
W
1
x
+
b
1
o
=
w
2
T
W
1
x
+
b
′
h=W_1x+b_1\\ o=w_2^TW_1x+b'
h=W1x+b1o=w2TW1x+b′
输出仍然是一个线性函数,依旧等价于一个单层的感知机
Sigmoid激活函数
将输入投影到(0,1),速率变化比较好,非零中心化的输出会使得其后一层的神经元的输入发生偏置偏移(BiasShift,并进一步使得梯度下降的收敛速度变慢.
s
i
g
m
o
i
d
(
x
)
=
1
1
+
e
x
p
(
−
x
)
sigmoid(x)=\frac{1}{1+exp(-x)}
sigmoid(x)=1+exp(−x)1
Tanh激活函数
将输入投影到(-1,1),
t
a
n
h
(
x
)
=
e
x
−
e
−
x
e
x
+
e
−
x
=
2
×
s
i
g
m
o
i
d
(
2
x
)
−
1
tanh(x)=\frac{e^x-e^{-x}}{e^x+e^{-x}}=2\times sigmoid(2x)-1
tanh(x)=ex+e−xex−e−x=2×sigmoid(2x)−1
ReLU激活函数
ReLU:rectified linear unit
R
e
L
U
(
x
)
=
m
a
x
(
x
,
0
)
ReLU(x)=max(x,0)
ReLU(x)=max(x,0)
多类分类
y
1
,
y
2
,
⋯
,
y
k
=
s
o
f
t
m
a
x
(
o
1
,
o
2
,
⋯
,
o
k
)
y_1,y_2,\cdots,y_k=softmax(o_1,o_2,\cdots,o_k)
y1,y2,⋯,yk=softmax(o1,o2,⋯,ok)
输入
x
∈
R
n
x\in \R^n
x∈Rn
隐藏层 W 1 ∈ R m × n , b 1 ∈ R m W_1\in \R^{m\times n},b_1\in\R ^m W1∈Rm×n,b1∈Rm
输出层 w 2 ∈ R m × k , b 2 ∈ R k w_2\in \R^{m\times k},b_2\in \R^k w2∈Rm×k,b2∈Rk(k分类,输出k个)
假设有m个隐藏层,
h
=
σ
(
W
1
x
+
b
1
)
o
=
w
2
T
h
+
b
2
y
=
s
o
f
t
m
a
x
(
o
)
h=\sigma(W_1x+b_1)\\ o=w_2^Th+b_2\\ y=softmax(o)
h=σ(W1x+b1)o=w2Th+b2y=softmax(o)
σ
\sigma
σ是按元素的激活函数(非线性的)
多隐藏层
h 1 = σ ( W 1 x + b 1 ) h 2 = σ ( W 2 x + b 2 ) h 3 = σ ( W 3 x + b 3 ) o = W 4 h 3 + b 4 h_1=\sigma(W_1x+b_1)\\ h_2=\sigma(W_2x+b_2)\\ h_3=\sigma(W_3x+b_3)\\ o = W_4h_3+b_4 h1=σ(W1x+b1)h2=σ(W2x+b2)h3=σ(W3x+b3)o=W4h3+b4
超参数:
- 隐藏层数
- 每层隐藏层的大小
代码实现
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)