PyTorch基礎(part6)--Dropout

學習筆記，僅供參考，有錯必糾

文章目錄

• ​​Dropout​​
• ​​代碼​​

• ​​初始設定​​
• ​​導包​​
• ​​載入資料​​
• ​​模型​​

Dropout

Dropout可以抵抗過拟合的狀态，但是不是在所有情況下使用Dropout，模型精度都會提高，一般而言在更為複雜的模型中Dropout會發揮更大的作用.

代碼

初始設定

# 支援多行輸出
from IPython.core.interactiveshell import InteractiveShell
InteractiveShell.ast_node_interactivity = 'all' #預設為'last'      

導包

# 導入常用的包
import numpy as np
from torch import nn,optim
from torch.autograd import Variable
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
import torch      

載入資料

# 載入資料
train_dataset = datasets.MNIST(root = './data/', # 載入的資料存放的位置
                               train = True, # 載入訓練集資料
                               transform = transforms.ToTensor(), # 将載入進來的資料變成Tensor
                               download = True) # 是否下載下傳資料
test_dataset = datasets.MNIST(root = './data/', # 載入的資料存放的位置
                               train = False, # 載入測試集資料
                               transform = transforms.ToTensor(), # 将載入進來的資料變成Tensor
                               download = True) # 是否下載下傳資料      

# 批次大小
batch_size = 64

# 裝載訓練集
train_loader = DataLoader(dataset=train_dataset,
                         batch_size=batch_size,
                         shuffle=True)

# 裝載訓練集
test_loader = DataLoader(dataset=test_dataset,
                         batch_size=batch_size,
                         shuffle=True)      

模型

# 定義網絡結構
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        # 建構次序結構，首先定義一個隐藏層，并使50%的神經元不工作(針對隐藏層神經元)，最後增加一個激活函數
        self.layer1 = nn.Sequential(nn.Linear(784,500), nn.Dropout(p = 0.5), nn.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):
        # ([64, 1, 28, 28])->(64,784)
        x = x.view(x.size()[0], -1)
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        return x      

LR = 0.5
# 定義模型
model = Net()
# 定義代價函數為交叉熵代價函數
mse_loss = nn.CrossEntropyLoss()
# 定義優化器
optimizer = optim.SGD(model.parameters(), LR)      

def train():
    model.train()
    for i,data in enumerate(train_loader):
        # 獲得一個批次的資料和标簽
        inputs, labels = data
        # 獲得模型預測結果（64,10）
        out = model(inputs)
        # 計算loss,交叉熵代價函數out(batch,C), labels(batch)
        loss = mse_loss(out, labels)
        # 梯度清0
        optimizer.zero_grad()
        # 計算梯度
        loss.backward()
        # 修改權值
        optimizer.step()

def test():
    model.eval()
    
    # 計算訓練集準确率
    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_dataset)))
    
    # 計算測試集準确率
    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_dataset)))      

for epoch in range(15):
    print('epoch:',epoch)
    train()
    test()      

epoch: 0
Train acc:0.9074333333333333
Test acc:0.9102
epoch: 1
Train acc:0.9326166666666666
Test acc:0.9317
epoch: 2
Train acc:0.9373
Test acc:0.937
epoch: 3
Train acc:0.9478333333333333
Test acc:0.9457
epoch: 4