动手深度学习14- pytorch Dropout 实现与原理
针对深度学习中的过拟合问题,通常使用丢弃法(dropout),丢弃法有很多的变体,本文提高的丢弃法特指倒置丢弃法(inverted dorpout)。
方法
在会议多层感知机的图3.3描述了一个单隐藏层的多层感知机。其中输入个数为4,隐藏单元个数为5,且隐藏单元\(h_{i}(1,2,3,4,5)\)的计算表达式为
\(h_{i} = \varphi(x_{1}w_{1i}+x_{2}w_{2i}+x_{1}w_{3i}+x_{1}w_{4i}+b_{i})\)
这个里的\(\varphi\)是激活函数,\(x_{1},x_{2},x_{3},x_{4}是输入,隐层单元i的权重参数为w_{1i},w_{2i},w_{3i},w_{4i},偏置参数为b_{i}\),当对该隐藏层使用丢弃法是,该层的隐藏单元将有一定概率的被丢弃掉。设丢弃的概率为P,那么有p的概率hi会被清零,有1-p的概率hi会除以1-p做拉伸。丢弃概率是丢弃法的超参数。具体来说,设随机变量\(\xi为0和1的概率分别是p和1-p。使用丢弃法时,我们使用计算新的隐藏单元h_{i}^{'}\)
\(h_{i}^{'} = \frac{\xi_{i}}{1-p}h_{i}\)
由于$E(\xi_{i}) = 1-p $,因此
\(E(\xi_{i}^{'}) = \frac{E(\xi_{i})}{1-p}h_{i} = h_{i}\)
丢弃法不改变其输入的期望值。
如图3.5所示,其中,h2和h5被清零,这时输出值的计算不再依赖h2和h5,在反向传播时,与这两个隐藏单元相关的权重的梯度均为0。由于训练汇总隐藏层的神经元丢弃是随机的,即h1,h2,h3,h4,h5都可能被清零,输出层计算无法过度依赖h1,h2,h3..h5中的任一个,从而在训练模型时起到的正则化的作用,可以用来应付过拟合。在测试模型时,我们为了拿到更加确定的结果,一般不适用丢弃法。
从零开始实现
%matplotlib inline
import torch
import torch.nn as nn
import numpy as np
import sys
sys.path.append('..')
import d2lzh_pytorch as d2l
def dropout(X,drop_prob):
X = X.float()
assert 0<=drop_prob<=1
keep_prob = 1-drop_prob
if keep_prob==0:
return torch.torch.zeros_like(X)
mask = (torch.rand(X.shape)<keep_prob).float()
# 均匀分布的的张量,torch.rand(*sizes,out=None) → Tensor
# 返回一个张量,包含了从区间(0,1)的均匀分布中随机抽取的一组随机数。
#print(mask)
return mask * X / keep_prob
X = torch.arange(16).view(2,8)
dropout(X,0)
tensor([[ 0., 1., 2., 3., 4., 5., 6., 7.],
[ 8., 9., 10., 11., 12., 13., 14., 15.]])
dropout(X,0.5)
tensor([[ 0., 0., 0., 0., 0., 10., 0., 14.],
[16., 18., 0., 0., 0., 26., 28., 30.]])
dropout(X,1)
tensor([[0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0.]])
定义模型参数
num_inputs,num_outputs, num_hidden1,num_hidden2 = 784,10,256,256
W1 = torch.tensor(np.random.normal(0,0.01,size=(num_inputs,num_hidden1)),dtype =torch.float32,requires_grad=True )
b1 = torch.zeros(num_hidden1,requires_grad=True)
W2 = torch.tensor(np.random.normal(0,0.01,size=(num_hidden1,num_hidden2)),dtype =torch.float32,requires_grad=True )
b2 = torch.zeros(num_hidden2,requires_grad=True)
W3 = torch.tensor(np.random.normal(0,0.01,size=(num_hidden2,num_outputs)),dtype =torch.float32,requires_grad=True )
b3 = torch.zeros(num_outputs,requires_grad=True)
params = [W1,b1,W2,b2,W3,b3]
网络
drop_prob1,drop_prob2 = 0.2,0.5
def net(X,is_training=True):
X = X.view(-1,num_inputs)
H1 = (torch.matmul(X,W1)+b1).relu()
if is_training:
H1 = dropout(H1,drop_prob1)
H2 = (torch.matmul(H1,W2)+b2).relu()
if is_training:
H2 = dropout(H2,drop_prob2)
return torch.matmul(H2,W3)+b3
评估函数
def evaluate_accuracy(data_iter,net):
acc_sum ,n = 0.0,0
for X,y in data_iter:
if isinstance(net,torch.nn.Module): #如果是torch.nn里简洁的实现的模型
net.eval() # 评估模式,这时会关闭Dropout
acc_sum+=(net(X).argmax(dim=1)==y).float().sum().item()
net.train() # 改回训练模式
else: # 自己定义的模型
if ('is_training' in net.__code__.co_varnames): # 如果有训练这个参数
# 将is_training 设置为False
acc_sum +=(net(X,is_training=False).argmax(dim=1)==y).float().sum().item()
else:
acc_sum+=(net(X),argmax(dim=1)==y).float().sum().item()
n+= y.shape[0]
return acc_sum/n
优化方法
def sgd(params,lr,batch_size):
for param in params:
# param.data -=lr* param.grad/batch_size
param.data-= lr* param.grad # 计算loss使用的是pytorch的交叉熵
# 这个梯度可以不用除以batch_size,pytorch 在计算loss的时候已经除过一次了,
定义损失函数
loss = torch.nn.CrossEntropyLoss()
数据提取与训练评估
num_epochs,lr,batch_size=15,0.3,256
batch_size = 256
train_iter,test_iter = d2l.get_fahsion_mnist(batch_size)
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:
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))
train_ch3(net,train_iter,test_iter,loss,num_epochs,batch_size,params,lr)
epoch 1, loss 0.0049, train acc 0.513, test acc 0.693
epoch 2, loss 0.0024, train acc 0.776, test acc 0.781
epoch 3, loss 0.0020, train acc 0.818, test acc 0.780
epoch 4, loss 0.0018, train acc 0.835, test acc 0.846
epoch 5, loss 0.0017, train acc 0.846, test acc 0.843
epoch 6, loss 0.0016, train acc 0.855, test acc 0.843
epoch 7, loss 0.0015, train acc 0.861, test acc 0.843
epoch 8, loss 0.0015, train acc 0.863, test acc 0.855
epoch 9, loss 0.0014, train acc 0.870, test acc 0.861
epoch 10, loss 0.0014, train acc 0.872, test acc 0.845
epoch 11, loss 0.0013, train acc 0.874, test acc 0.853
epoch 12, loss 0.0013, train acc 0.878, test acc 0.848
epoch 13, loss 0.0013, train acc 0.880, test acc 0.859
epoch 14, loss 0.0013, train acc 0.882, test acc 0.858
epoch 15, loss 0.0012, train acc 0.885, test acc 0.863
pytorch简洁实现
net = nn.Sequential(
d2l.FlattenLayer(),
nn.Linear(num_inputs,num_hidden1),
nn.ReLU(),
nn.Dropout(drop_prob1),
nn.Linear(num_hidden1,num_hidden2),
nn.ReLU(),
nn.Dropout(drop_prob2),
nn.Linear(num_hidden2,num_outputs)
)
for param in net.parameters():
nn.init.normal_(param,mean=0,std=0.01)
optimizer = torch.optim.SGD(net.parameters(),lr=0.3)
train_ch3(net,train_iter,test_iter,loss,num_epochs,batch_size,None,None,optimizer)
epoch 1, loss 0.0048, train acc 0.525, test acc 0.725
epoch 2, loss 0.0024, train acc 0.779, test acc 0.787
epoch 3, loss 0.0020, train acc 0.818, test acc 0.771
epoch 4, loss 0.0018, train acc 0.836, test acc 0.834
epoch 5, loss 0.0017, train acc 0.847, test acc 0.848
epoch 6, loss 0.0016, train acc 0.855, test acc 0.855
epoch 7, loss 0.0015, train acc 0.859, test acc 0.850
epoch 8, loss 0.0014, train acc 0.863, test acc 0.853
epoch 9, loss 0.0014, train acc 0.868, test acc 0.848
epoch 10, loss 0.0014, train acc 0.872, test acc 0.837
epoch 11, loss 0.0013, train acc 0.876, test acc 0.849
epoch 12, loss 0.0013, train acc 0.879, test acc 0.872
epoch 13, loss 0.0013, train acc 0.880, test acc 0.847
epoch 14, loss 0.0013, train acc 0.883, test acc 0.862
epoch 15, loss 0.0012, train acc 0.886, test acc 0.865
小结
- 可以使用Dropout应对过拟合
- 丢弃法只能在训练模型时使用
原文地址:https://www.cnblogs.com/onemorepoint/p/11867896.html
- 用优雅的配色来缔造图表专业主义~
- python文件名与包名冲突
- python3 Zabbix监控-api的使用-python
- 安装python虚拟环境
- 各种排序算法的分析及java&python实现
- python3elk相关---根据Elasticsearch(es)日志处理,生成excel并定时邮箱发送附件
- python数据科学-数据预处理
- python3 邮箱相关邮箱的服务
- 谈一谈Python中str()和repr()的区别
- TensorFlow从0到1 - 15 - 重新思考神经网络初始化
- python2.7搬运--->TensorFlow - 深度学习破解验证码
- 来学习几个简单的Hive函数啦
- 推荐系统实战-基于用户的协同过滤
- 素数的筛法
- JavaScript 教程
- JavaScript 编辑工具
- JavaScript 与HTML
- JavaScript 与Java
- JavaScript 数据结构
- JavaScript 基本数据类型
- JavaScript 特殊数据类型
- JavaScript 运算符
- JavaScript typeof 运算符
- JavaScript 表达式
- JavaScript 类型转换
- JavaScript 基本语法
- JavaScript 注释
- Javascript 基本处理流程
- Javascript 选择结构
- Javascript if 语句
- Javascript if 语句的嵌套
- Javascript switch 语句
- Javascript 循环结构
- Javascript 循环结构实例
- Javascript 跳转语句
- Javascript 控制语句总结
- Javascript 函数介绍
- Javascript 函数的定义
- Javascript 函数调用
- Javascript 几种特殊的函数
- JavaScript 内置函数简介
- Javascript eval() 函数
- Javascript isFinite() 函数
- Javascript isNaN() 函数
- parseInt() 与 parseFloat()
- escape() 与 unescape()
- Javascript 字符串介绍
- Javascript length属性
- javascript 字符串函数
- Javascript 日期对象简介
- Javascript 日期对象用途
- Date 对象属性和方法
- Javascript 数组是什么
- Javascript 创建数组
- Javascript 数组赋值与取值
- Javascript 数组属性和方法
- Windows下Scoop安装、配置与使用
- Flutter免费iOS真机调试 AndroidStudio iPhone真机运行教程
- Flutter GridView 网格控件
- Flutter ListView 下拉刷新,上拉加载更多
- Flutter问题:import 'package:english_words/english_words.dart'失败
- 第17天:NLP实战(一)——爬取语料及其简单分析
- 搞懂 Redis 缓存穿透、击穿、雪崩
- win10_opencv4.2_cuda11_vs2019 编译
- (Demo分享)利用JavaScript(JS)做一个可输入分钟的倒计时钟功能
- Flutter ListView 列表控件
- 第18天:NLP实战(二)——用DNN实现手势识别
- 「0821更新」Flutter入门系列教程汇总
- (Demo分享)利用JavaScript(JS)实现一个九宫格拖拽功能
- 第19天:NLP实战(三)——用CNN实现微博谣言检测
- (Demo分享)利用原生JavaScript-ScrollLeft-实现做轮播广告通知