PyTorch實現L1，L2正則化以及Dropout

PyTorch實現L1，L2正則化以及Dropout

模型訓練中經常出現的兩類典型問題：

• 一類是模型無法得到較低的訓練誤差，我們將這一現象稱作欠擬合（underfitting）；
• 另一類是模型的訓練誤差遠小於它在測試數據集上的誤差，我們稱該現象爲過擬合（overfitting）。

在實踐中，我們要儘可能同時應對欠擬合和過擬合。

過擬合現象，即模型的訓練誤差遠小於它在測試集上的誤差。雖然增大訓練數據集可能會減輕過擬合，但是獲取額外的訓練數據往往代價高昂。

爲此我們可以使用兩種方法權重衰減（weight decay）、丟棄法（dropout）。

權重衰減（weight decay）

可以使用L1，L2正則化

正則化通過爲模型損失函數添加懲罰項使學出的模型參數值較小，是應對過擬合的常用手段。

$L_1$範數懲罰項指的是模型權重參數每個元素的絕對值和與一個正的常數的乘積

$L_2$範數懲罰項指的是模型權重參數每個元素的平方和與一個正的常數的乘積。
舉線性迴歸損失函數
$\ell(w_1, w_2, b) = \frac{1}{n} \sum_{i=1}^n \frac{1}{2}\left(x_1^{(i)} w_1 + x_2^{(i)} w_2 + b - y^{(i)}\right)^2$
爲例，其中$w_1, w_2$是權重參數，$b$是偏差參數，樣本$i$的輸入爲$x_1^{(i)}, x_2^{(i)}$，標籤爲$y^{(i)}$，樣本數爲$n$。將權重參數用向量$\boldsymbol{w} = [w_1, w_2]$表示，

帶有$L_1$範數懲罰項的新損失函數爲

$\ell(w_1, w_2, b) + \frac{\lambda}{n} |\boldsymbol{w}|,$

帶有$L_2$範數懲罰項的新損失函數爲

$\ell(w_1, w_2, b) + \frac{\lambda}{2n} \|\boldsymbol{w}\|^2,$

其中超參數$\lambda > 0$。當權重參數均爲0時，懲罰項最小。當$\lambda$較大時，懲罰項在損失函數中的比重較大，這通常會使學到的權重參數的元素較接近0。當$\lambda$設爲0時，懲罰項完全不起作用。
初始化模型參數

首先，定義隨機初始化模型參數的函數。該函數爲每個參數都附上梯度。

def init_params():
    w = torch.randn((num_inputs, 1), requires_grad=True)
    b = torch.zeros(1, requires_grad=True)
    return [w, b]

定義$L_1$範數懲罰項

下面定義$L_1$範數懲罰項。這裏只懲罰模型的權重參數。

def l1_penalty(w):
    return (torch.abs(w)).sum()

定義$L_2$範數懲罰項

def l2_penalty(w):
    return (w**2).sum() / 2

定義訓練和測試

下面定義如何在訓練數據集和測試數據集上分別訓練和測試模型。這裏在計算最終的損失函數時添加了$L_2$範數懲罰項。

batch_size, num_epochs, lr = 1, 100, 0.003
net, loss = d2l.linreg, d2l.squared_loss

dataset = torch.utils.data.TensorDataset(train_features, train_labels)
train_iter = torch.utils.data.DataLoader(dataset, batch_size, shuffle=True)

def fit_and_plot(lambd):
    w, b = init_params()
    train_ls, test_ls = [], []
    for _ in range(num_epochs):
        for X, y in train_iter:
            # # 添加了L1範數懲罰項
            # l = loss(net(X, w, b), y) + lambd * l1_penalty(w)
            # 添加了L2範數懲罰項
            l = loss(net(X, w, b), y) + lambd * l2_penalty(w)
            l = l.sum()
            
            if w.grad is not None:
                w.grad.data.zero_()
                b.grad.data.zero_()
            l.backward()
            d2l.sgd([w, b], lr, batch_size)
        train_ls.append(loss(net(train_features, w, b), train_labels).mean().item())
        test_ls.append(loss(net(test_features, w, b), test_labels).mean().item())
    d2l.semilogy(range(1, num_epochs + 1), train_ls, 'epochs', 'loss',
                 range(1, num_epochs + 1), test_ls, ['train', 'test'])
    print('L2 norm of w:', w.norm().item())
       
# 觀察過擬合
fit_and_plot(lambd=0)

# 使用權重衰減
fit_and_plot(lambd=3)

• 權重衰減可以通過優化器中的weight_decay超參數來指定。

丟棄法 (Dropout)

丟棄法簡單理解爲以一定概率丟棄一些神經元。

設隨機變量$\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$
由此可得丟棄法不改變其輸入的期望值。下面的dropout函數將以drop_prob的概率丟棄X中的元素。

%matplotlib inline
import torch
import torch.nn as nn
import numpy as np

def dropout(X, drop_prob):
    X = X.float()
    keep_prob = 1 - drop_prob
    # 這種情況下把全部元素都丟棄
    if keep_prob == 0:
        return torch.zeros_like(X)
    mask = (torch.randn(X.shape) < keep_prob).float()
    
    return mask * X / keep_prob

我們運行幾個例子來測試一下dropout函數。其中丟棄概率分別爲0、0.5和1。

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

dropout(X, 0.5)

dropout(X, 1.0)

簡潔實現

在PyTorch中，我們只需要在全連接層後添加Dropout層並指定丟棄概率。在訓練模型時，Dropout層將以指定的丟棄概率隨機丟棄上一層的輸出元素；在測試模型時（即model.eval()後），Dropout層並不發揮作用。

net = nn.Sequential(
        d2l.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)
        )

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

下面訓練並測試模型。

optimizer = torch.optim.SGD(net.parameters(), lr=0.5)
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size, None, None, optimizer)