pytorch —— 正則化之weight_decay

1、正則化與偏差-方差分解

1.1 Regularization

Regularization:減小方差的策略;

誤差可分解爲偏差,方差與噪聲之和,即誤差=偏差+方差+噪聲之和;

偏差度量了學習算法的期望預測與真實結果的偏離程度,即刻畫了學習算法本身的擬合能力;

方差度量了同樣大小的訓練集的變動所導致的學習性能的變化,即刻畫了數據擾動所造成的影響;

噪聲則表達了在當前任務上任何學習算法所能達到的期望泛化誤差的下界;

在這裏插入圖片描述
下面通過一個線性迴歸的例子理解方差和偏差的概念:
在這裏插入圖片描述
假如現在有一個一元線性迴歸,如圖,訓練集是藍色的點,測試集是紅色的點,假如有一個模型能夠很好地擬合訓練集,如下如所示:
在這裏插入圖片描述
但是該模型在測試集的效果比較差,這就是一個典型的高方差,也就是過擬合現象。正則化策略的目的就是降低方差,減小過擬合的發生。

下面瞭解一下降低過擬合的正則化策略,這裏主要學習L1和L2正則化策略。

1.2 損失函數

損失函數:衡量模型輸出與真實標籤的差異

損失函數:Loss=f(y^,y)Loss = f(\hat{y},y)代價函數:Cost=1NiNf(y^i,yi)Cost=\frac{1}{N}\sum_{i}^Nf(\hat{y}_i,y_i)目標函數:Obj=Cost+Regularization  TermObj=Cost + Regularization \space\space Term
在這裏插入圖片描述
L1 Regularization Term:iNwi\sum_i^N|w_i|L2 Regularization Term:iNwi2\sum_i^N|w_i^2|

在分析L!和L2正則化的時候,經常看到下面這個圖:
在這裏插入圖片描述
左圖爲L1正則化,右圖爲L2正則化,圖中的彩色圓圈是損失函數的等高線,也就是公式中的cost,這裏假設模型是一個二元模型,有兩個參數w1w_1w2w_2。左圖中的黑色矩陣表示正則化的等高線,右圖和左圖的圖形意義一樣。

1.3 L2 Regularization

L2 Regularization = weight decay(權重衰減)

目標函數(Objective Function):Obj=Cost+Regularization  TermObj=Cost + Regularization \space\space Term假設目標函數爲Obj=Loss+λ2iNwi2Obj = Loss + \frac{\lambda}{2}*\sum_i^Nw_i^2權重更新公式爲wi+1=wiObjwi=wiLosswiw_{i+1}=w_i - \frac{\partial Obj}{\partial w_i}=w_i-\frac{\partial Loss}{\partial w_i}可以得到L2正則化的權重更新爲wi+1=wiObjwi=wi(Losswi+λwi)w_{i+1}=w_i - \frac{\partial Obj}{\partial w_i}=w_i-(\frac{\partial Loss}{\partial w_i}+\lambda*w_i)公式化簡爲wi+1=wi(1λ)Losswiw_{i+1}=w_i*(1-\lambda) - \frac{\partial Loss}{\partial w_i}因爲公式中存在wi(1λ)w_i*(1-\lambda),因此L2正則化也稱爲權重衰減。

現在通過代碼看一下在一元線性模型上weight decay(L2正則化)的具體作用:

import torch
import torch.nn as nn
import matplotlib.pyplot as plt
from common_tools import set_seed
from torch.utils.tensorboard import SummaryWriter

set_seed(1)  # 設置隨機種子
n_hidden = 200
max_iter = 2000
disp_interval = 200
lr_init = 0.01


# ============================ step 1/5 數據 ============================
def gen_data(num_data=10, x_range=(-1, 1)):

    w = 1.5
    train_x = torch.linspace(*x_range, num_data).unsqueeze_(1)
    train_y = w*train_x + torch.normal(0, 0.5, size=train_x.size())
    test_x = torch.linspace(*x_range, num_data).unsqueeze_(1)
    test_y = w*test_x + torch.normal(0, 0.3, size=test_x.size())

    return train_x, train_y, test_x, test_y


train_x, train_y, test_x, test_y = gen_data(x_range=(-1, 1))


# ============================ step 2/5 模型 ============================
class MLP(nn.Module):
    def __init__(self, neural_num):
        super(MLP, self).__init__()
        self.linears = nn.Sequential(
            nn.Linear(1, neural_num),
            nn.ReLU(inplace=True),
            nn.Linear(neural_num, neural_num),
            nn.ReLU(inplace=True),
            nn.Linear(neural_num, neural_num),
            nn.ReLU(inplace=True),
            nn.Linear(neural_num, 1),
        )

    def forward(self, x):
        return self.linears(x)


net_normal = MLP(neural_num=n_hidden)
net_weight_decay = MLP(neural_num=n_hidden)

# ============================ step 3/5 優化器 ============================
optim_normal = torch.optim.SGD(net_normal.parameters(), lr=lr_init, momentum=0.9)
optim_wdecay = torch.optim.SGD(net_weight_decay.parameters(), lr=lr_init, momentum=0.9, weight_decay=1e-2)

# ============================ step 4/5 損失函數 ============================
loss_func = torch.nn.MSELoss()

# ============================ step 5/5 迭代訓練 ============================

writer = SummaryWriter(comment='_test_tensorboard', filename_suffix="12345678")
for epoch in range(max_iter):

    # forward
    pred_normal, pred_wdecay = net_normal(train_x), net_weight_decay(train_x)
    loss_normal, loss_wdecay = loss_func(pred_normal, train_y), loss_func(pred_wdecay, train_y)

    optim_normal.zero_grad()
    optim_wdecay.zero_grad()

    loss_normal.backward()
    loss_wdecay.backward()

    optim_normal.step()
    optim_wdecay.step()

    if (epoch+1) % disp_interval == 0:

        # 可視化
        for name, layer in net_normal.named_parameters():
            writer.add_histogram(name + '_grad_normal', layer.grad, epoch)
            writer.add_histogram(name + '_data_normal', layer, epoch)

        for name, layer in net_weight_decay.named_parameters():
            writer.add_histogram(name + '_grad_weight_decay', layer.grad, epoch)
            writer.add_histogram(name + '_data_weight_decay', layer, epoch)

        test_pred_normal, test_pred_wdecay = net_normal(test_x), net_weight_decay(test_x)

        # 繪圖
        plt.scatter(train_x.data.numpy(), train_y.data.numpy(), c='blue', s=50, alpha=0.3, label='train')
        plt.scatter(test_x.data.numpy(), test_y.data.numpy(), c='red', s=50, alpha=0.3, label='test')
        plt.plot(test_x.data.numpy(), test_pred_normal.data.numpy(), 'r-', lw=3, label='no weight decay')
        plt.plot(test_x.data.numpy(), test_pred_wdecay.data.numpy(), 'b--', lw=3, label='weight decay')
        plt.text(-0.25, -1.5, 'no weight decay loss={:.6f}'.format(loss_normal.item()), fontdict={'size': 15, 'color': 'red'})
        plt.text(-0.25, -2, 'weight decay loss={:.6f}'.format(loss_wdecay.item()), fontdict={'size': 15, 'color': 'red'})

        plt.ylim((-2.5, 2.5))
        plt.legend(loc='upper left')
        plt.title("Epoch: {}".format(epoch+1))
        plt.show()
        plt.close()

在Pytorch中,weight_decay是在優化器中實現的,在代碼中構建了兩個優化器,一個優化器不帶有正則化,一個優化器帶有正則化。

代碼輸出的結果如下所示:
在這裏插入圖片描述

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章