[PyTorch 學習筆記] 6.1 weight decay 和 dropout
本章程式碼：
這篇文章主要介紹了正則化與偏差-方差分解，以及 PyTorch 中的 L2 正則項--weight decay
Regularization
Regularization 中文是正則化，可以理解為一種減少方差的策略。
在機器學習中，誤差可以分解為：偏差，方差與噪聲之和。即誤差=偏差+方差+噪聲
偏差度量了學習演算法的期望預測與真實結果的偏離程度，即刻畫了學習演算法本身的擬合能力。
方差度量了同樣大小的訓練集的變動所導致的學習效能的變化，即刻畫了資料擾動所造成的影響。
噪聲則表達了在當前任務上學習任何演算法所能達到的期望泛化誤差的下界。
正則化方式有 L1 和 L2 正則項兩種。其中 L2 正則項又被稱為權值衰減(weight decay)。
當沒有正則項時：$\boldsymbol{O} \boldsymbol{b} \boldsymbol{j}=\boldsymbol{L} \boldsymbol{o} \boldsymbol{s} \boldsymbol{s}$，$w_{i+1}=w_{i}-\frac{\partial o b j}{\partial w_{i}}=w_{i}-\frac{\partial L o s s}{\partial w_{i}}$。
當使用 L2 正則項時，$\boldsymbol{O} \boldsymbol{b} \boldsymbol{j}=\boldsymbol{L} \boldsymbol{o} \boldsymbol{s} \boldsymbol{s}+\frac{\lambda}{2} * \sum_{i}^{N} \boldsymbol{w}{i}^{2}$，$\begin{aligned} w{i+1}=w_{i}-\frac{\partial o b j}{\partial w_{i}} &=w_{i}-\left(\frac{\partial L o s s}{\partial w_{i}}+\lambda * w_{i}\right) =w_{i}(1-\lambda)-\frac{\partial L o s s}{\partial w_{i}} \end{aligned}$，其中 $0 < \lambda < 1$，所以具有權值衰減的作用。
在 PyTorch 中，L2 正則項是在優化器中實現的，在構造優化器時可以傳入 weight decay 引數，對應的是公式中的 $\lambda $。
下面程式碼對比了沒有 weight decay 的優化器和 weight decay 為 0.01 的優化器的訓練情況，線上性迴歸的資料集上進行實驗，模型使用 3 層的全連線網路，並使用 TensorBoard 視覺化每層權值的變化情況。程式碼如下：
import torch
import torch.nn as nn
import matplotlib.pyplot as plt
from common_tools import set_seed
from tensorboardX 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()
訓練 2000 個 epoch 後，模型如下：
可以看到使用了 weight decay 的模型雖然在訓練集的 loss 更高，但是更加平滑，泛化能力更強。
下面是使用 Tensorboard 視覺化的分析。首先檢視不帶 weight decay 的權值變化過程，第一層權值變化如下：
可以看到從開始到結束，權值的分佈都沒有什麼變化。
然後檢視帶 weight decay 的權值變化過程，第一層權值變化如下：
可以看到，加上了 weight decay 後，隨便訓練次數的增加，權值的分佈逐漸靠近 0 均值附近，這就是 L2 正則化的作用，約束權值儘量靠近 0。
第二層不帶 weight decay 的權值變化如下：
第二層帶 weight decay 的權值變化如下：
weight decay 在 優化器中的實現
由於 weight decay 在優化器的一個引數，因此在執行optim_wdecay.step()時，會計算 weight decay 後的梯度，具體程式碼如下：
def step(self, closure=None):
"""Performs a single optimization step.
Arguments:
closure (callable, optional): A closure that reevaluates the model
and returns the loss.
"""
loss = None
if closure is not None:
loss = closure()
for group in self.param_groups:
weight_decay = group['weight_decay']
momentum = group['momentum']
dampening = group['dampening']
nesterov = group['nesterov']
for p in group['params']:
if p.grad is None:
continue
d_p = p.grad.data
if weight_decay != 0:
d_p.add_(weight_decay, p.data)
...
...
...
p.data.add_(-group['lr'], d_p)
可以看到：dp 是計算得到的梯度，如果 weight decay 不為 0，那麼更新 $d_p=dp+weight_decay \times p.data$，對應公式：$\left(\frac{\partial L o s s}{\partial w{i}}+\lambda * w_{i}\right)$。最後一行是根據梯度更新權值。
Dropout
Dropout 是另一種抑制過擬合的方法。在使用 dropout 時，資料尺度會發生變化，如果設定 dropout_prob =0.3，那麼在訓練時，資料尺度會變為原來的 70%；而在測試時，執行了 model.eval() 後，dropout 是關閉的，因此所有權重需要乘以 (1-dropout_prob)，把資料尺度也縮放到 70%。
PyTorch 中 Dropout 層如下，通常放在每個網路層的最前面：
torch.nn.Dropout(p=0.5, inplace=False)
引數：
- p：主力需要注意的是，p 是被捨棄的概率，也叫失活概率
下面實驗使用的依然是線性迴歸的例子，兩個網路均是 3 層的全連線層，每層前面都設定 dropout，一個網路的 dropout 設定為 0，另一個網路的 dropout 設定為 0.5，並使用 TensorBoard 視覺化每層權值的變化情況。程式碼如下：
import torch
import torch.nn as nn
import matplotlib.pyplot as plt
from common_tools import set_seed
from tensorboardX import SummaryWriter
set_seed(1) # 設定隨機種子
n_hidden = 200
max_iter = 2000
disp_interval = 400
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, d_prob=0.5):
super(MLP, self).__init__()
self.linears = nn.Sequential(
nn.Linear(1, neural_num),
nn.ReLU(inplace=True),
nn.Dropout(d_prob),
nn.Linear(neural_num, neural_num),
nn.ReLU(inplace=True),
nn.Dropout(d_prob),
nn.Linear(neural_num, neural_num),
nn.ReLU(inplace=True),
nn.Dropout(d_prob),
nn.Linear(neural_num, 1),
)
def forward(self, x):
return self.linears(x)
net_prob_0 = MLP(neural_num=n_hidden, d_prob=0.)
net_prob_05 = MLP(neural_num=n_hidden, d_prob=0.5)
# ============================ step 3/5 優化器 ============================
optim_normal = torch.optim.SGD(net_prob_0.parameters(), lr=lr_init, momentum=0.9)
optim_reglar = torch.optim.SGD(net_prob_05.parameters(), lr=lr_init, momentum=0.9)
# ============================ 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):
pred_normal, pred_wdecay = net_prob_0(train_x), net_prob_05(train_x)
loss_normal, loss_wdecay = loss_func(pred_normal, train_y), loss_func(pred_wdecay, train_y)
optim_normal.zero_grad()
optim_reglar.zero_grad()
loss_normal.backward()
loss_wdecay.backward()
optim_normal.step()
optim_reglar.step()
if (epoch+1) % disp_interval == 0:
net_prob_0.eval()
net_prob_05.eval()
# 視覺化
for name, layer in net_prob_0.named_parameters():
writer.add_histogram(name + '_grad_normal', layer.grad, epoch)
writer.add_histogram(name + '_data_normal', layer, epoch)
for name, layer in net_prob_05.named_parameters():
writer.add_histogram(name + '_grad_regularization', layer.grad, epoch)
writer.add_histogram(name + '_data_regularization', layer, epoch)
test_pred_prob_0, test_pred_prob_05 = net_prob_0(test_x), net_prob_05(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_prob_0.data.numpy(), 'r-', lw=3, label='d_prob_0')
plt.plot(test_x.data.numpy(), test_pred_prob_05.data.numpy(), 'b--', lw=3, label='d_prob_05')
plt.text(-0.25, -1.5, 'd_prob_0 loss={:.8f}'.format(loss_normal.item()), fontdict={'size': 15, 'color': 'red'})
plt.text(-0.25, -2, 'd_prob_05 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()
net_prob_0.train()
net_prob_05.train()
訓練 2000 次後，模型的曲線如下：
我們使用 TensorBoard 檢視第三層網路的權值變化情況。
dropout =0 的權值變化如下：
dropout =0.5 的權值變化如下：
可以看到，加了 dropout 之後，權值更加集中在 0 附近，使得神經元之間的依賴性不至於過大。
model.eval() 和 model.trian()
有些網路層在訓練狀態和測試狀態是不一樣的，如 dropout 層，在訓練時 dropout 層是有效的，但是資料尺度會縮放，為了保持資料尺度不變，所有的權重需要除以 1-p。而在測試時 dropout 層是關閉的。因此在測試時需要先呼叫model.eval()設定各個網路層的的training屬性為 False，在訓練時需要先呼叫model.train()設定各個網路層的的training屬性為 True。
下面是對比 dropout 層的在 eval 和 train 模式下的輸出值。
首先構造一層全連線網路，輸入是 10000 個神經元，輸出是 1 個神經元，權值全設為 1，dropout 設定為 0.5。輸入是全為 1 的向量。分別測試網路在 train 模式和 eval 模式下的輸出，程式碼如下：
import torch
import torch.nn as nn
class Net(nn.Module):
def __init__(self, neural_num, d_prob=0.5):
super(Net, self).__init__()
self.linears = nn.Sequential(
nn.Dropout(d_prob),
nn.Linear(neural_num, 1, bias=False),
nn.ReLU(inplace=True)
)
def forward(self, x):
return self.linears(x)
input_num = 10000
x = torch.ones((input_num, ), dtype=torch.float32)
net = Net(input_num, d_prob=0.5)
net.linears[1].weight.detach().fill_(1.)
net.train()
y = net(x)
print("output in training mode", y)
net.eval()
y = net(x)
print("output in eval mode", y)
輸出如下：
output in training mode tensor([9868.], grad_fn=<ReluBackward1>)
output in eval mode tensor([10000.], grad_fn=<ReluBackward1>)
在訓練時，由於 dropout 為 0.5，因此理論上輸出值是 5000，而由於在訓練時，dropout 層會把權值除以 1-p=0.5，也就是乘以 2，因此在 train 模式的輸出是 10000 附近的數(上下隨機浮動是由於概率的不確定性引起的) 。而在 eval 模式下，關閉了 dropout，因此輸出值是 10000。這種方式在訓練時對權值進行縮放，在測試時就不用對權值進行縮放，加快了測試的速度。
參考資料
如果你覺得這篇文章對你有幫助，不妨點個贊，讓我有更多動力寫出好文章。