Dropout丢弃法是为了防止模型过拟合，它会每个批次随机的将部分数据置为0，在网络传递的过程不起任何作用，经过多个批次的dropout的作用形成最终的模型参数
失活一定的权重就不会造成过拟合，缺少部分权重的影响导致模型的容量变小，进而本次学习的任务不会过多，不会学习到个别的噪音
我们假设有一个向量为X=[x1,x2,x3,x4,x5]
丢弃法虽然会将一部分数据置为0，但是它不会改变数据的期望
我们假设丢弃的概率为p
现在的期望就变成了E(x1)=0*p+(1-p)*x1/(1-p)=x1
可以看到并不会发生改变
而且有一个地方，经常有的图会标记，dropout就是让每个隐藏层的部分节点失活不发生作用，我感觉应该是不对的，dropout是将部分数据进行置为0，那么说明失活的应该是层与层之间的权重连线，应该是部分权重不起作用了，而不是整个神经元全部失活
因为每次的传播都会选择性失活一定的权重，如果第一次某个权重不起作用，它可能在第二次的传播中进行更新权重，经过多个epoch即不同批次的迭代，每个权重都会被训练到
import torch
import torch.nn as nn
import torchvision
from torchvision import transforms
from torch.utils import data
# 将图片数据转化成张量
data_transform=transforms.ToTensor()
# 加载图片数据集
train_dataset=torchvision.datasets.FashionMNIST(root='./data',train=True,download=False,transform=data_transform)
val_dataset=torchvision.datasets.FashionMNIST(root='./data',train=False,download=False,transform=data_transform)
batch_size=128
# 加载批次数据
train_loader=data.DataLoader(train_dataset,batch_size,shuffle=True)
val_loader=data.DataLoader(val_dataset,batch_size,shuffle=False)
从零实现Dropout
这里定义dropout函数
如果是0，说明不丢弃任何数据，返回原数据
如果为1，则说明全部丢弃，返回同样形状的0矩阵
否则随机生成一个符合标准正态分布的随机张量，然后按位置进行判断和概率p的大小
然后将布尔张量转化成浮点，即1.0或0.0
之后将每个位置的值进行相应的改变，丢弃的就变为0，否则将其放大（除以1-p）
def dropout(x,p):
if p==0:
return x
if p==1:
return torch.zeors_like(x)
mask=torch.randn_like(x).gt(p).float()
return mask*x/(1-p)
定义模型需要指定是否使用dropout，在forward传播函数中进行判断
class Net(nn.Module):
def __init__(self,is_train):
super(Net,self).__init__()
self.is_train=is_train
self.layer1=nn.Linear(784,256)
self.layer2=nn.Linear(256,256)
self.layer3=nn.Linear(256,10)
self.relu=nn.ReLU()
def forward(self,x):
x=x.reshape(-1,784)
out=self.layer1(x)
out=self.relu(out)
if self.is_train:
out=dropout(out,0.3)
out=self.layer2(out)
out=self.relu(out)
if self.is_train:
out=dropout(out,0.5)
out=self.layer3(out)
return out
定义损失函数为交叉熵
优化器为SGD，且学习率为0.03
然后扫描整个数据集3次
net=Net(True)
loss_function=nn.CrossEntropyLoss()
optimizer=torch.optim.SGD(net.parameters(),lr=0.03)
epochs=3
for epoch in range(epochs):
net.train()
for x,y in train_loader:
y_hat=net(x)
loss=loss_function(y_hat,y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
accuracy=0.0
with torch.no_grad():
net.eval（)
for x,y in val_loader:
y_hat=net(x)
y_pred=torch.argmax(y_hat,dim=1)
accuracy+=torch.eq(y_pred,y).sum().item()
accuracy=accuracy/len(val_dataset)
print('epoch {},accuracy {:.4f},loss {:.4f}'.format(epoch+1,accuracy,loss.item()))
epoch 1,accuracy 0.8254,loss 0.2865
epoch 2,accuracy 0.8447,loss 0.4892
epoch 3,accuracy 0.8438,loss 0.2258
简洁实现
简洁实现较为方便，利用Sequential将各个层与层之间的操作容纳起来
这里在两个隐藏层定义了两个dropout函数
dropout1=0.3
dropout2=0.5
net=nn.Sequential(nn.Flatten(),
nn.Linear(784,256),
nn.ReLU(),
nn.Dropout(dropout1),
nn.Linear(256,256),
nn.ReLU(),
nn.Dropout(dropout2),
nn.Linear(256,10))
loss_function=nn.CrossEntropyLoss()
optimizer=torch.optim.SGD(net.parameters(),lr=0.03)
epochs=3
for epoch in range(epochs):
net.train()
for x,y in train_loader:
y_hat=net(x)
loss=loss_function(y_hat,y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
accuracy=0.0
with torch.no_grad():
net.eval（)
for x,y in val_loader:
y_hat=net(x)
y_pred=torch.argmax(y_hat,dim=1)
accuracy+=torch.eq(y_pred,y).sum().item()
accuracy=accuracy/len(val_dataset)
print('epoch {},accuracy {:.4f},loss {:.4f}'.format(epoch+1,accuracy,loss.item()))
epoch 1,accuracy 0.7176,loss 0.7700
epoch 2,accuracy 0.7732,loss 0.6294
epoch 3,accuracy 0.8057,loss 0.5933
