PyTorchの基本-ドロップアウトと正則化-05

ドロップアウトは過剰適合を抑制します

import numpy as np
import torch
from torch import nn,optim
from torch.autograd import Variable
from torchvision import datasets,transforms
from torch.utils.data import DataLoader

# 训练集
train_data = datasets.MNIST(root="./", # 存放位置
                            train = True, # 载入训练集
                            transform=transforms.ToTensor(), # 把数据变成tensor类型
                            download = True # 下载
                           )
# 测试集
test_data = datasets.MNIST(root="./",
                            train = False,
                            transform=transforms.ToTensor(),
                            download = True
                           )

# 批次大小
batch_size = 64
# 装载训练集
train_loader = DataLoader(dataset=train_data,batch_size=batch_size,shuffle=True)
# 装载测试集
test_loader = DataLoader(dataset=test_data,batch_size=batch_size,shuffle=True)

for i,data in enumerate(train_loader):
    inputs,labels = data
    print(inputs.shape)
    print(labels.shape)
    break

# 定义网络结构
class Net(nn.Module):
    def __init__(self):
        super(Net,self).__init__()# 初始化
        self.layer1 = nn.Sequential(nn.Linear(784,500),nn.Dropout(p=0.5),nn.Tanh()) # 一个有序的容器，神经网络模块将按照在传入构造器的顺序依次被添加到计算图中执行,Dropout 抑制过拟合0.5丢去百分之50数据，激活函数Tanh
        self.layer2 = nn.Sequential(nn.Linear(500,300),nn.Dropout(p=0.5),nn.Tanh())
        self.layer3 = nn.Sequential(nn.Linear(300,10),nn.Softmax(dim=1))
        
    def forward(self,x):
        # torch.Size([64, 1, 28, 28]) -> (64,784)
        x = x.view(x.size()[0],-1) # 4维变2维 （在全连接层做计算只能2维）
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        return x

# 定义模型
model = Net()
# 定义代价函数
mse_loss = nn.CrossEntropyLoss()# 交叉熵
# 定义优化器
optimizer = optim.SGD(model.parameters(),lr=0.5)# 随机梯度下降

# 定义模型训练和测试的方法
def train():
    # 模型的训练状态
    model.train()
    for i,data in enumerate(train_loader):
        # 获得一个批次的数据和标签
        inputs,labels = data
        # 获得模型预测结果（64，10)
        out = model(inputs)
        # 交叉熵代价函数out（batch，C：类别的数量），labels（batch）
        loss = mse_loss(out,labels)
        # 梯度清零
        optimizer.zero_grad()
        # 计算梯度
        loss.backward()
        # 修改权值
        optimizer.step()
        
def test():
    # 模型的测试状态
    model.eval()
    correct = 0 # 测试集准确率
    for i,data in enumerate(test_loader):
        # 获得一个批次的数据和标签
        inputs,labels = data
        # 获得模型预测结果（64，10)
        out = model(inputs)
        # 获得最大值，以及最大值所在的位置
        _,predicted = torch.max(out,1)
        # 预测正确的数量
        correct += (predicted==labels).sum()
    print("Test acc:{0}".format(correct.item()/len(test_data)))
    
    correct = 0
    for i,data in enumerate(train_loader): # 训练集准确率
        # 获得一个批次的数据和标签
        inputs,labels = data
        # 获得模型预测结果（64，10)
        out = model(inputs)
        # 获得最大值，以及最大值所在的位置
        _,predicted = torch.max(out,1)
        # 预测正确的数量
        correct += (predicted==labels).sum()
    print("Train acc:{0}".format(correct.item()/len(train_data)))

# 训练
for epoch in range(11):
    print("epoch:",epoch)
    train()
    test()

正則化

import numpy as np
import torch
from torch import nn,optim
from torch.autograd import Variable
from torchvision import datasets,transforms
from torch.utils.data import DataLoader

# 训练集
train_data = datasets.MNIST(root="./", # 存放位置
                            train = True, # 载入训练集
                            transform=transforms.ToTensor(), # 把数据变成tensor类型
                            download = True # 下载
                           )
# 测试集
test_data = datasets.MNIST(root="./",
                            train = False,
                            transform=transforms.ToTensor(),
                            download = True
                           )

# 批次大小
batch_size = 64
# 装载训练集
train_loader = DataLoader(dataset=train_data,batch_size=batch_size,shuffle=True)
# 装载测试集
test_loader = DataLoader(dataset=test_data,batch_size=batch_size,shuffle=True)

for i,data in enumerate(train_loader):
    inputs,labels = data
    print(inputs.shape)
    print(labels.shape)
    break

# 定义网络结构
class Net(nn.Module):
    def __init__(self):
        super(Net,self).__init__()# 初始化
        self.layer1 = nn.Sequential(nn.Linear(784,500),nn.Dropout(p=0),nn.Tanh()) 
        self.layer2 = nn.Sequential(nn.Linear(500,300),nn.Dropout(p=0),nn.Tanh())
        self.layer3 = nn.Sequential(nn.Linear(300,10),nn.Softmax(dim=1))
        
    def forward(self,x):
        # torch.Size([64, 1, 28, 28]) -> (64,784)
        x = x.view(x.size()[0],-1) # 4维变2维 （在全连接层做计算只能2维）
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        return x

# 定义模型
model = Net()
# 定义代价函数
mse_loss = nn.CrossEntropyLoss()# 交叉熵
# 定义优化器,设置L2正则化
optimizer = optim.SGD(model.parameters(),lr=0.5,weight_decay=0.001)# 随机梯度下降

# 定义模型训练和测试的方法
def train():
    # 模型的训练状态
    model.train()
    for i,data in enumerate(train_loader):
        # 获得一个批次的数据和标签
        inputs,labels = data
        # 获得模型预测结果（64，10)
        out = model(inputs)
        # 交叉熵代价函数out（batch，C：类别的数量），labels（batch）
        loss = mse_loss(out,labels)
        # 梯度清零
        optimizer.zero_grad()
        # 计算梯度
        loss.backward()
        # 修改权值
        optimizer.step()
        
def test():
    # 模型的测试状态
    model.eval()
    correct = 0 # 测试集准确率
    for i,data in enumerate(test_loader):
        # 获得一个批次的数据和标签
        inputs,labels = data
        # 获得模型预测结果（64，10)
        out = model(inputs)
        # 获得最大值，以及最大值所在的位置
        _,predicted = torch.max(out,1)
        # 预测正确的数量
        correct += (predicted==labels).sum()
    print("Test acc:{0}".format(correct.item()/len(test_data)))
    
    correct = 0
    for i,data in enumerate(train_loader): # 训练集准确率
        # 获得一个批次的数据和标签
        inputs,labels = data
        # 获得模型预测结果（64，10)
        out = model(inputs)
        # 获得最大值，以及最大值所在的位置
        _,predicted = torch.max(out,1)
        # 预测正确的数量
        correct += (predicted==labels).sum()
    print("Train acc:{0}".format(correct.item()/len(train_data)))

# 训练
for epoch in range(11):
    print("epoch:",epoch)
    train()
    test()