李沐深度学习记录2：10多层感知机

一.简要知识记录

x.numel()：看向量或矩阵里元素个数
A.sum()：向量或矩阵求和，axis参数可对某维度求和，keepdims参数设置是否保持维度不变
A.cumsum：axis参数设置沿某一维度计算矩阵累计和

x*y:向量的按元素乘法
torch.dot(x,y):向量的点乘（点积or内积），结果是标量。公式，向量a点积向量b=|a||b|cos两向量夹角。向量点积即x的转置与向量y相乘，即对应元素相乘相加得数值。
torch.sum(x*y):计算向量点积的另一方式，执行向量的按元素乘法得向量，再对向量求和。

torch.mul(A,x):两个变量对应元素相乘。A为矩阵时，x可以是一个数，也可以是向量(支持广播机制)。若A(m,n)，x为向量时，x只能(1,n)或(m,1)即选择与矩阵A每行向量对应元素想乘或者与矩阵A每列向量对应元素想乘，显然(n,1)或(1,m)维度不符合形式。
torch.mv(A,X):矩阵向量积，矩阵乘以向量。

A*B:矩阵的按元素乘法，称为Hadamard积。
torch.mm(A,B):矩阵乘法。但是注意，高维矩阵（二维以上）不可以使用mm(),应当使用matmul().

torch.abs(x).sum():计算向量的L1范数，即先计算各项绝对值，再求和。
torch.norm(x):计算向量的L2范数。L2范数是向量元素平方和的平方根
torch.norm(A):类似于向量的L2范数，矩阵A的Frobenius范数是矩阵元素平方和的平方根。

梯度和等高线正交，梯度指向值变化最大的方向


1.线性回归：估计一个连续值
公式(对于单个样本,向量内积)，y=<w,x>+b  (<w,x>向量内积得标量) ；
公式（对于多个样本,矩阵乘法），y=w*x+b    x维度[batchsize,m], w维度[m,1], b维度[1]是个标量，输出维度[batchsize,1]
损失函数，平方损失 ；
输出：输出只有一个连续值表预测 

2.softmax回归：预测一个离散类别；设类别数n
公式（对多个样本）：1）y=w*x+b；x维度[batchsize,m], w维度[m,n] ,b维度[1,n], 输出维度[batchsize,n]
                                 2）y=softmax(o)；o是1）的输出值，通过softmax将其转化为概率输出，即n个值和为1
损失函数；交叉熵( H(p,q)=求和-pi*log(qi) )常用于衡量两个概率的区别，一个是正确类别进行的一位有效编码，一个是2）的预测概率输出
输出：输出n个类别的概率预测
另，逻辑斯蒂回归是softmax回归二分类的一种特殊形式

3.单层感知机：二分类
公式（对于单个样本）：o=硬sigmoid(<w,x>+b)  硬sigmoid(x)=1(x>0) or -1(otherwise) 
损失函数：等价于使用批量大小为1的梯度下降，具体如下
l=max(0,-y<w,x>)  当预测值<w,x>与真实值y符号相同即均大于0或均小于0，该样本预测正确，此时-y<w,x>小于0，损失函数l=0
                               当预测值<w,x>与真实值y符号不同，该样本预测错误，此时-y<w,x>大于0，损失函数l=-y<w,x>
存在问题，无法解决XOR二分类问题
 
多层感知机-单分类即二分类
公式（对多个样本）：h=sigmoid(w1*x+b1)  输入x维度(batchsize,n)，隐藏层w1维度(n,m), b1维度(1,m), 隐藏层输出维度(batchsize,m)
                                 o=w2*h+b2  输入h维度(batchsize,m)，输出层w2维度(m,1), b2维度(1)标量，输出o维度(batchsize,1) 
关于激活函数：sigmoid：[0,1]     Tanh: [-1,1]     ReLU: max(x,0)  常用ReLU，因为它没有指数运算，而指数计算很贵

多层感知机-多分类
公式（对多个样本）：h=sigmoid(w1*x+b1)  输入x维度(batchsize,n)，隐藏层w1维度(n,m), b1维度(1,m), 隐藏层输出维度(batchsize,m)
                                 o=w2*h+b2   输入h维度(batchsize,m)，输出层w2维度(m,k), b2维度(k,1)，输出o维度(batchsize,k) 
                                 y=softmax(o)  通过softmax将k个值转化为概率
损失函数：交叉熵
超参数：隐藏层数；每个隐藏层的大小
另，多层感知机多分类与softmax回归多分类区别只是多了隐藏层部分
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

2.多层感知机从零开始实现

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)

实现一个具有单隐藏层的多层感知机
#初始化模型参数
#注意对于隐藏层的宽度，常选择2的若干次幂作为层的宽度，可以使得计算更高效
num_inputs,num_outputs,num_hiddens=784,10,256

#nn.Parameter()是pytorch一个类，用于创建可训练的参数（权重和偏置），这些参数会在模型训练过程中自动更新
# w1=nn.Parameter(torch.normal(0,0.01,(num_inputs,num_hiddens),requires_grad=True)*0.01)
w1=nn.Parameter(torch.randn(num_inputs,num_hiddens,requires_grad=True)*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) #torch.zeros_like生成和括号内变量维度一致的全是0的内容
    return torch.max(X,a)

#模型
#忽略空间结构，需要使用reshape将每个二维图像转换为一个长度为num_inputs的向量
def net(X):
    X=X.reshape((-1,num_inputs)) #(batchsize,1,28,28)->(batchsize,784)
    H=relu(X@w1+b1) #X矩阵(batchsize,784),w1矩阵(784,256),@则为矩阵乘法得(batchsize,256),b1(1,256)
    return (H@w2+b2) #H矩阵(batchsize,256),w1矩阵(256,10),@则为矩阵乘法得(batchsize,10),b2(1,10)

#损失函数
#计算softmax和交叉熵
loss=nn.CrossEntropyLoss(reduction='none') #不对损失求和或求平均，得到一个向量包含batchsize份损失，即每个样本的损失

#训练
#由于多层感知机训练过程与softmax回归完全相同，因此可以直接调用d2l包的train_ch3函数
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)

#在一些数据上应用模型
d2l.predict_ch3(net,test_iter)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

三.多层感知机简介实现

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)

#模型
#与softmax回归的简洁实现，唯一区别是添加了2个全连接层
#第一层隐藏层，包含256个隐藏单元，并使用ReLU激活函数。第二层是输出层
#nn.Flatten()除了第0维度batchsize保留，其余维度全部展平为一维向量
net=nn.Sequential(nn.Flatten(),
                  nn.Linear(784,256),
                  nn.ReLU(),
                  nn.Linear(256,10))
#参数初始化
#nn.Linear的weight和bias会自动初始化，这里使用init_weight只是不希望采用对weight的默认初始化，对bias采用默认初始化就可以
def init_weights(m):
    if type(m)==nn.Linear:
        nn.init.normal_(m.weight,std=0.01)

net.apply(init_weights);

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

#优化算法
trainer=torch.optim.SGD(net.parameters(),lr=lr)

#训练
num_epochs,lr=10,0.1
d2l.train_ch3(net,train_iter,test_iter,loss,num_epochs,trainer)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33