上一篇講了防止過擬合的一種方式,權重衰減,也即在loss上加上一部分\(\frac{\lambda}{2n} \|\boldsymbol{w}\|^2\),從而使得w不至於過大,即不過分偏向某個特徵.

這一篇介紹另一種防止過擬合的方法,dropout,即丟棄某些神經元的輸出.由於每次訓練的過程裡,丟棄掉哪些神經元的輸出都是隨機的,從而可以使得模型不過分依賴於某些神經元的輸出,從而達到防止過擬合的目的．

需要注意的一點是:並不是簡單地丟棄掉某些神經元的輸出,對留下的輸出,我們要改變他們的值,以保證丟棄前後的輸出的期望不變

比如,對如下神經網路:輸入個數為4，隱藏單元個數為5，且隱藏單元\(h_i\)（\(i=1, \ldots, 5\)）的計算表示式為

\[ h_i = \phi\left(x_1 w_{1i} + x_2 w_{2i} + x_3 w_{3i} + x_4 w_{4i} + b_i\right) \]

這裡\(\phi\)是啟用函式，\(x_1, \ldots, x_4\)是輸入，隱藏單元\(i\)的權重引數為\(w_{1i}, \ldots, w_{4i}\)，偏差引數為\(b_i\)。當對該隱藏層使用丟棄法時，該層的隱藏單元將有一定概率被丟棄掉。設丟棄概率為\(p\)，那麼有\(p\)的概率\(h_i\)會被清零，有\(1-p\)的概率\(h_i\)會除以\(1-p\)做拉伸。丟棄概率是丟棄法的超引數。具體來說，設隨機變數\(\xi_i\)為0和1的概率分別為\(p\)和\(1-p\)。使用丟棄法時我們計算新的隱藏單元\(h_i'\)

\[ h_i' = \frac{\xi_i}{1-p} h_i \]

由於\(E(\xi_i) = 1-p\)，因此

\[ E(h_i') = \frac{E(\xi_i)}{1-p}h_i = h_i \]

從零開始實現

以一個三層的多層感知機為例.兩個隱藏層的輸出個數都是256．

匯入必要的包

import torch
import torch.nn as nn
import numpy as np
import sys
import utils

utils.py中包含了常用的一些實現,比如資料集載入,sgd實現之類的函式都實現在了這個檔案裡.

實現dropout

def dropout(X,drop_prob):
    X = X.float()
    keep_prob = 1 - drop_prob

    if keep_prob == 0:
        return torch.zeros_like(X)
    mask = (torch.rand(X.shape) < keep_prob).float()
    #print("mask:\n",mask)

    return mask * X/keep_prob

X=torch.arange(16).view(2,8)
 

drop_prob是丟棄的概率.其中我們用torch.rand(X.shape) < keep_prob去生成一組bool數,表明要丟棄哪些,保留哪些.

關於torch中幾種分佈的用法,參考https://zhuanlan.zhihu.com/p/31231210

• 均勻分佈
  torch.rand(*sizes, out=None) → Tensor
  返回一個張量，包含了從區間[0, 1)的均勻分佈中抽取的一組隨機數。張量的形狀由引數sizes定義。

• 標準正態分佈
  torch.randn(*sizes, out=None) → Tensor
  返回一個張量，包含了從標準正態分佈（均值為0，方差為1，即高斯白噪聲）中抽取的一組隨機數。張量的形狀由引數sizes定義。

• 離散正態分佈
  torch.normal(means, std, out=None) → → Tensor
  返回一個張量，包含了從指定均值means和標準差std的離散正態分佈中抽取的一組隨機數。
  標準差std是一個張量，包含每個輸出元素相關的正態分佈標準差。

• 線性間距向量
  torch.linspace(start, end, steps=100, out=None) → Tensor
  返回一個1維張量，包含在區間start和end上均勻間隔的step個點。
  輸出張量的長度由steps決定。

載入資料

batch_size,num_workers = 256,4
train_iter,test_iter = utils.load_data(batch_size,num_workers)

utils.py中

def load_data(batch_size,num_workers):
    mnist_train = torchvision.datasets.FashionMNIST(root='/home/sc/disk/keepgoing/learn_pytorch/Datasets/FashionMNIST',
                                                    train=True, download=True,
                                                    transform=transforms.ToTensor())
    mnist_test = torchvision.datasets.FashionMNIST(root='/home/sc/disk/keepgoing/learn_pytorch/Datasets/FashionMNIST',
                                                train=False, download=True,
                                                transform=transforms.ToTensor())

    train_iter = torch.utils.data.DataLoader(
        mnist_train, batch_size=batch_size, shuffle=True, num_workers=num_workers)
    test_iter = torch.utils.data.DataLoader(
        mnist_test, batch_size=batch_size, shuffle=False, num_workers=num_workers)
    
    return train_iter,test_iter

定義模型引數

num_inputs, num_outputs, num_hiddens1, num_hiddens2 = 784, 10, 256, 256

W1 = torch.tensor(np.random.normal(0, 0.01, size=(num_inputs, num_hiddens1)), dtype=torch.float, requires_grad=True)
b1 = torch.zeros(num_hiddens1, requires_grad=True)
W2 = torch.tensor(np.random.normal(0, 0.01, size=(num_hiddens1, num_hiddens2)), dtype=torch.float, requires_grad=True)
b2 = torch.zeros(num_hiddens2, requires_grad=True)
W3 = torch.tensor(np.random.normal(0, 0.01, size=(num_hiddens2, num_outputs)), dtype=torch.float, 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

通常,傾向於在更靠近原始輸入的層,drop概率更低．

精度評估函式定義

def evaluate_accuracy(data_iter, net):
    acc_sum, n = 0.0, 0
    for X, y in data_iter:
        if isinstance(net, torch.nn.Module):
            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這個引數
                # 將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

損失函式

loss = nn.CrossEntropyLoss()

優化演算法

def sgd(params, lr, batch_size):
    for param in params:
        param.data -= lr * param.grad / batch_size # 注意這裡更改param時用的param.data

訓練

注意一點:這裡的loss我們是直接用的torch的nn.CrossEntropyLoss(),這個loss已經是除了batch_size,是求了均值的.所以l很小,相應的梯度也很小．
而更新引數的時候用的是手寫的sgd,又除了一次batch_size.所以為了快速收斂,lr要設定大一點.

def train(train_iter,test_iter,num_epochs,net,loss,params,sgd,batch_size,lr):
    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)   #前向傳播
            """
            這裡的loss我們是直接用的torch的nn.CrossEntropyLoss(),這個loss是求了均值的.l很小,相應的梯度也很小．
            更新引數的時候用的是手寫的sgd. lr要設定大一點.
            """
            l = loss(y_hat,y).sum()#計算loss
            
            #清空梯度
            if params is not None and params[0].grad is not None:
                for param in params:
                    param.grad.data.zero_()

            l.backward()#反向傳播
            sgd(params, lr, batch_size) #更新引數

            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))

num_epochs,lr=5,100
train(train_iter,test_iter,num_epochs,net,loss,params,sgd,batch_size,lr)

輸出如下:

epoch 1, loss 0.0045, train_acc 0.558，test_acc 0.736
epoch 2, loss 0.0023, train_acc 0.786，test_acc 0.792
epoch 3, loss 0.0019, train_acc 0.825，test_acc 0.796
epoch 4, loss 0.0017, train_acc 0.839，test_acc 0.845
epoch 5, loss 0.0016, train_acc 0.850，test_acc 0.823

簡潔實現

資料載入

同前

模型定義及模型引數初始化

net = nn.Sequential(
    utils.FlattenLayer(),
    nn.Linear(num_inputs,num_hiddens1),
    nn.ReLU(),
    nn.Dropout(drop_prob1),
    nn.Linear(num_hiddens1,num_hiddens2),
    nn.ReLU(),
    nn.Dropout(drop_prob2),
    nn.Linear(num_hiddens2,10)
)

直接使用nn.Dropout()類.

for param in net.parameters():
    nn.init.normal_(param,mean=0,std=0.01)

精度評估函式定義

同前. 要注意的是在測試模式下,我們不想做dropout．要net.eval()關閉dropout.

def evaluate_accuracy(data_iter, net):
    acc_sum, n = 0.0, 0
    for X, y in data_iter:
        if isinstance(net, torch.nn.Module):
            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這個引數
                # 將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

損失函式

loss = nn.CrossEntropyLoss()

優化演算法

optimizer = torch.optim.SGD(net.parameters(),lr=0.5)

用torch.optim.SGD(net.parameters(),lr=0.5)表明用隨機梯度下降法去計算net.parameters()的梯度．

　訓練

• 前向傳播,計算輸出
• 計算loss
• 反向傳播,計算梯度
• 根據梯度,更新引數
• 迴圈往復,輸入下一個batch的資料

def train_use_torch(train_iter,test_iter,num_epochs,net,loss,params,optimizer,batch_size,lr):
    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()#計算loss
            optimizer.zero_grad()#梯度清空

            l.backward()#反向傳播,計算梯度

            optimizer.step()#根據梯度,更新引數
            
            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))

num_epochs,lr=5,0.5
train_use_torch(train_iter,test_iter,num_epochs,net,loss,params,optimizer,batch_size,lr)

輸出

epoch 1, loss 0.0045, train_acc 0.556，test_acc 0.745
epoch 2, loss 0.0023, train_acc 0.787，test_acc 0.817
epoch 3, loss 0.0019, train_acc 0.821，test_acc 0.803
epoch 4, loss 0.0017, train_acc 0.837，test_acc 0.809
epoch 5, loss 0.0016, train_acc 0.847，test_acc 0.840 
 

            
  
           

              
              
            
            
相關推薦
			   
            
            
            
 

    

    
    
從頭學pytorch(七):dropout防止過擬合
     
 上一篇講了防止過擬合的一種方式,權重衰減,也即在loss上加上一部分\(\frac{\lambda}{2n} \|\boldsymbol{w}\|^2\),從而使得w不至於過大,即不過分偏向某個特徵.
這一篇介紹另一種防止過擬合的方法,dropout,即丟棄某些神經元的輸出.由於每次訓練的過程裡,丟棄掉哪些神 

  
 

    

    
    
TensorFlow學習---tf.nn.dropout防止過擬合
     
 
                
一、 Dropout原理簡述：
tf.nn.dropout是TensorFlow裡面為了防止或減輕過擬合而使用的函式，它一般用在全連線層。
Dropout就是在不同的訓練過程中隨機扔掉一部分神經元。也就是讓某個神經元的啟用值以一定的概率p，讓其停止工作，這次訓練過程中不更新 

  
 

    

    
    
TensorFlow中的Dropout防止過擬合overfiting
     
 
                
關於Dropout的詳細內容可參考論文 "Dropout: A Simple Way to Prevent Neural Networks from Overfitting"論文
Dropout 是一個降低過擬合的正則化技術。他在網路中丟棄一部分神經單元，以及與它們的前後續 

  
 

    

    
    
【轉載】TensorFlow學習---tf.nn.dropout防止過擬合
     
 
轉載自：http://blog.csdn.net/huahuazhu/article/details/73649389   尊重原創
遇到tf.nn.dropout問題時，在網上看到這篇博文，覺得不錯，所以轉載方便自己以後學習，如侵犯版權，請告知博主刪除
一、 Dropout原理簡述：
tf.nn.drop 

  
 

    

    
    
防止過擬合、dropout理解
     
  
 
 轉自：https://blog.csdn.net/stdcoutzyx/article/details/49022443、https://blog.csdn.net/leo_xu06/article/details/71320727 
 開篇明義，dropout是指在深度學習網路的訓練過程中，對於神 

  
 

    

    
    
深度學習框架tensorflow學習與應用6（防止過擬合dropout，keep_prob =tf.placeholder(tf.float32)）
     
  
 
 import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

# In[3]:

# 載入資料集
mnist = input_data.read_data_sets("MNIST_data",  

  
 

    

    
    
正則化方法/防止過擬合提高泛化能力的方法：L1和L2 regularization、資料集擴增、dropout
     
 
                





正則化方法：防止過擬合，提高泛化能力
在訓練資料不夠多時，或者overtraining時，常常會導致overfitting（過擬合）。其直觀的表現如下圖所示，隨著訓練過程的進行，模型複雜度增加，在training data上的error漸漸減小，但是在驗證集上的e 

  
 

    

    
    
機器學習的防止過擬合方法
     
 alt   int   變化   http   處理   提高   pro   無法   structure   過擬合
??我們都知道，在進行數據挖掘或者機器學習模型建立的時候，因為在統計學習中，假設數據滿足獨立同分布（i.i.d，independently and identically distribu 

  
 

    

    
    
機器學習中防止過擬合方法
     
 從數據   tro   輸出   效果   沒有   imagenet   neu   效率   公式   過擬合
??在進行數據挖掘或者機器學習模型建立的時候，因為在統計學習中，假設數據滿足獨立同分布，即當前已產生的數據可以對未來的數據進行推測與模擬，因此都是使用歷史數據建立模型，即使用已經產生的數據去訓練 

  
 

    

    
    
drop out為什麽能夠防止過擬合
     
 正則   復雜   訓練數據   它的   一個   解決   過程   drop   投票    
來源知乎：
dropout 的過程好像很奇怪，為什麽說它可以解決過擬合呢？（正則化）

取平均的作用： 先回到正常的模型（沒有dropout），我們用相同的訓練數據去訓練5個不同的神經網絡，一般會得到 

  
 

    

    
    
斯坦福大學公開課機器學習： advice for applying machine learning - evaluatin a phpothesis（怎麽評估學習算法得到的假設以及如何防止過擬合或欠擬合）
     
 class   中一   技術分享   cnblogs   訓練數據   是否   多個   期望   部分   怎樣評價我們的學習算法得到的假設以及如何防止過擬合和欠擬合的問題。
當我們確定學習算法的參數時，我們考慮的是選擇參數來使訓練誤差最小化。有人認為，得到一個很小的訓練誤差一定是一件好事。但其實，僅 

  
 

    

    
    
深度學習常見策略總結(優化器選擇，防止過擬合策略）
     
  
 
 
 1. 優化器的選擇 
  關於深度學習各種優化器的介紹和對比在網上有很多圖文並茂的講解，比如我上一篇博文轉載的文章：深度學習——優化器演算法Optimizer詳解（BGD、SGD、MBGD、Momentum、NAG、Adagrad、Adadelta、RMSprop、Adam）。有需要的 

  
 

    

    
    
L2正則化項為什麼能防止過擬合學習筆記
     
  
 
 https://www.cnblogs.com/alexanderkun/p/6922428.html 
 L2 regularization（權重衰減） 
 L2正則化就是在代價函式後面再加上一個正則化項： 
  
 C0代表原始的代價函式，後面那一項就是L2正則化項，它是這樣來的：所有引數w的平 

  
 

    

    
    
防止過擬合的方法 預測鸞鳳花(sklearn)
     
 1. 防止過擬合的方法有哪些？ 
過擬合（overfitting）是指在模型引數擬合過程中的問題，由於訓練資料包含抽樣誤差，訓練時，複雜的模型將抽樣誤差也考慮在內，將抽樣誤差也進行了很好的擬合。 
產生過擬合問題的原因大體有兩個：訓練樣本太少或者模型太複雜。  
防止過擬合問題的方法： 
（1）增加 

  
 

    

    
    
防止過擬合的方法       預測鸞鳳花(sklearn)
     
 ogr   mod   sep   類模型   for   包含   一輪   com   stop   1. 防止過擬合的方法有哪些？
過擬合（overfitting）是指在模型參數擬合過程中的問題，由於訓練數據包含抽樣誤差，訓練時，復雜的模型將抽樣誤差也考慮在內，將抽樣誤差也進行了很好的擬合。
產生過擬合 

  
 

    

    
    
(轉)正則化為什麼能防止過擬合 正則化為什麼能防止過擬合（重點地方標紅了）
     
 正則化為什麼能防止過擬合（重點地方標紅了） 
 
  
  正則化方法：防止過擬合，提高泛化能力 
  在訓練資料不夠多時，或者overtraining時，常常會導致overfitting（過擬合）。其直觀的表現如下圖所示，隨著訓練過程的進行，模型複雜度增加，在training data上的error漸漸減小 

  
 

    

    
    
Bobo老師機器學習筆記第八課-如何防止過擬合和欠擬合？
     
  
 
 問題一、什麼是過擬合和欠擬合？ 
 首先擬合是一個統計學概念，它表示所求函式逼近目標函式的遠近程度。應用的機器學習中，就是我們所求的函式與未知的對映函式之間的相似度。如何求得函式引數與潛在的函式引數越逼近，說明效果越好。  
 假設我們用上篇部落格中的資料，原始碼可以見上文： 
  
 通 

  
 

    

    
    
dropout解決過擬合
     
  
 
 原理就是在第一次學習的過程中，隨即忽略一些神經元和神經的連結。使得神經網路變得不完整。一次一次。。。。。每一次得出的結果不依賴某一個引數。這樣就解決了過擬合問題。 
 import tensorflow as tf
from sklearn.datasets import load_digits
f 

  
 

    

    
    
防止過擬合的方法？
     
  
 
 防止過擬合的方法？ 
 答：過擬合的原因是演算法的學習能力過強；一些假設條件（如樣本獨立同分布）可能是不成立的；訓練樣本過少不能對整個空間進行分佈估計。  
 處理方法： 
 1 早停止：如在訓練中多次迭代後發現模型效能沒有顯著提高就停止訓練 
 2 資料集擴增：原有資料增加、原有資料加隨機噪聲、重 

  
 

    

    
    
深度學習防止過擬合的方法
     
 
								
								            
							
							
							過擬合即在訓練誤差很小,而泛化誤差很大,因為模型可能過於的複雜,使其”記住”了訓練樣本,然而其泛化誤差卻很高,在傳統的機器學習方法中有很大防止過擬合的方法,同樣這些方法很多也適合用於深度學習中,同時深度