[深度學習] pytorch學習筆記（3）(visdom可視化、正則化、動量、學習率衰減、BN)

一、visdom可視化工具

安裝：pip install visdom

啟動：命令行直接運行visdom

打開WEB：在瀏覽器使用http://localhost:8097打開visdom界面

 

二、使用visdom

# 導入Visdom類
from visdom import Visdom
# 定義一個env叫Mnist的board，如果不指定，則默認歸於main
viz = Visdom(env='Mnist')

# 在window Accuracy中畫train acc和test acc,x坐標都是epoch
viz.line(Y=np.column_stack((acc, test_acc)),
         X=np.column_stack((epoch, epoch)),
         win='Accuracy',
         update='append',
         opts=dict(markers=False, legend=['Acc', 'Test Acc']))
# 在window Loss中畫train loss和test loss,x坐標都是epoch
viz.line(Y=np.column_stack((loss.cpu().item(), test_loss.cpu().item())),
         X=np.column_stack((epoch, epoch)),
         win='Loss',
         update='append',
         opts=dict(markers=False, legend=['Loss', 'Test Loss']))

 

三、使用正則化

正則化也叫權重衰減（Weight Decay）

L1和L2正則化可以參考：https://blog.csdn.net/red_stone1/article/details/80755144

在代碼中，我們只需要在優化器中使用weight_decay參數就可以啟用L2正則化

# 選擇一個優化器，指定需要優化的參數，學習率，以及正則化參數
optimizer = torch.optim.SGD(net.parameters(), lr=learning_rate, weight_decay=0.01)

由於在Pytorch中沒有納入L1正則化，我們可以通過手工實現：

# 正則化超參數lambda
lambd = 0.01
# 所有參數的絕對值的和
regularization_loss = 0

for param in model.parameters():
　　regularization_loss += torch.sum(torch.abs(param))

# 自己手動在loss函數后添加L1正則項 lambda * sum(abs)
loss = F.cross_entropy(z, target) + lambd * regularization_loss
optimizer.zero_grad()
loss.backward()

四、使用Momentum動量

使用Momentum,即在使用SGD時指定momentum參數，如果不指定，默認為0，即不開啟動量優化模式。

# 選擇一個優化器，指定需要優化的參數，學習率，以及正則化參數,是否使用momentum
optimizer = torch.optim.SGD(net.parameters(), lr=learning_rate, momentum=0.9, weight_decay=0.01)

使用Adam時，由於Adam包含了Monmentum，所以他自己指定了Momentum參數的大小，無需我們指定。

五、學習率衰減 Learning rate decay

當學習率太小時，梯度下降很慢。當學習率太大時，可以在某個狹窄區間震盪，難以收斂。

學習率衰減就是為了解決學習率多大這種情況。

當我們在訓練一個模型時，發現Loss在某個時間不發生變化（在一個平坦區），則我們要考慮是否是在一個狹窄區間震盪，導致的難以收斂。

 

我們在pytorch中可以使用ReducelROnPlateau(optimizer,'min')來監控loss的值：

from torch.optim.lr_scheduler import ReduceLROnPlateau

# 選擇一個優化器，指定需要優化的參數，學習率，以及正則化參數,是否使用momentum
optimizer = torch.optim.SGD(net.parameters(), lr=learning_rate, momentum=0.9, weight_decay=0.01)

# 使用一個高原監控器，將optimizer交給他管理,LR衰減參數默認0.1即一次縮小10倍，patience是監控10次loss看是否變化
scheduler = ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=10)

# 后面的optimizer.step()使用scheduler.step(loss)來代替，每次step都會監控一下loss
# 當loss在10次（可以設置）都未變化，則會使LR衰減一定的比例

另外，除了上述使用ReducelROnPlateau，還可以使用更為粗暴的StepLR函數，我們可以直接指定在多少step后下降一次LR的值：

from torch.optim.lr_scheduler import StepLR

# 選擇一個優化器，指定需要優化的參數，學習率，以及正則化參數,是否使用momentum
optimizer = torch.optim.SGD(net.parameters(), lr=learning_rate, momentum=0.9, weight_decay=0.01)

# 使用StepLR,指定step_size即每多少步衰減一次，gamma為衰減率，0.1代表除以10
scheduler = StepLR(optimizer, step_size = 10000, gamma=0.1)

# 后面的optimizer.step()使用scheduler.step()

六、在全連接層使用batchnorm

# -*- coding:utf-8 -*-
__author__ = 'Leo.Z'

import torch
from visdom import Visdom
import numpy as np

import torch.nn.functional as F
from torch.nn import Module, Sequential, Linear, LeakyReLU, BatchNorm1d
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

batch_size = 200
learning_rate = 0.001
epochs = 100

train_data = datasets.MNIST('../data', train=True, download=True,
                            transform=transforms.Compose([
                                transforms.ToTensor(),
                                transforms.Normalize((0.1307,), (0.3081,))
                            ]))

test_data = datasets.MNIST('../data', train=False,
                           transform=transforms.Compose([
                               transforms.ToTensor(),
                               transforms.Normalize((0.1307,), (0.3081,))
                           ]))

train_db, val_db = torch.utils.data.random_split(train_data, [50000, 10000])

train_loader = DataLoader(train_db,
                          batch_size=100, shuffle=True)
val_loader = DataLoader(val_db,
                        batch_size=10000, shuffle=True)
test_loader = DataLoader(test_data,
                         batch_size=10000, shuffle=True)


# 網絡結構
class MLP(Module):
    def __init__(self):
        super(MLP, self).__init__()

        self.model = Sequential(
            Linear(784, 200),
            #===================== BN-start ======================
            # 這里對第一層全連接層使用BN1d,在多個樣本上對每一個神經元做歸一化
            BatchNorm1d(200, eps=1e-8),
            # ===================== BN-end =======================
            LeakyReLU(inplace=True),
            Linear(200, 200),
            #===================== BN-start ======================
            # 這里對第二層全連接層使用BN1d,在多個樣本上對每一個神經元做歸一化
            BatchNorm1d(200, eps=1e-8),
            # ===================== BN-end =======================
            LeakyReLU(inplace=True),
            Linear(200, 10),
            LeakyReLU(inplace=True)
        )

    def forward(self, x):
        x = self.model(x)
        return x


# 定義一個env叫Mnist的board，如果不指定，則默認歸於main
viz = Visdom(env='TestBN')

# 定義GPU設備
device = torch.device('cuda')
# model放到GPU
net = MLP().to(device)

# 選擇一個優化器，指定需要優化的參數，學習率，以及正則化參數,是否使用momentum
optimizer = torch.optim.SGD(net.parameters(), lr=learning_rate, momentum=0.9, weight_decay=0.01)

for idx, (val_data, val_target) in enumerate(val_loader):
    val_data = val_data.view(-1, 28 * 28)
    val_data, val_target = val_data.to(device), val_target.to(device)

for epoch in range(epochs):

    for batch_idx, (data, target) in enumerate(train_loader):
        # data轉換維度為[200,784],target的維度為[200]
        data = data.view(-1, 28 * 28)
        # 將data和target放到GPU
        data, target = data.to(device), target.to(device)
        # data為輸入，net()直接執行forward
        # 跑一次網絡，得到z,維度為[200,10],200是batch_size,10是類別
        # 由於net在GPU，data也在GPU，計算出的z就在GPU
        # 調用net(data)的時候相當於調用Module類的__call__方法
        z = net(data).to(device)

        # 將loss放到GPU
        loss = F.cross_entropy(z, target).to(device)
        # 每次迭代前將梯度置0
        optimizer.zero_grad()
        # 反向傳播，計算梯度
        loss.backward()
        # 相當於執行w = w - dw，也就是更新權值
        optimizer.step()

    ### 每一輪epoch，以下代碼是使用分割出的val dataset來做測試
    # 先計算在train dataset上的准確率
    eq_mat = torch.eq(z.argmax(dim=1), target)
    acc = torch.sum(eq_mat).float().item() / eq_mat.size()[0]
    print('Loss:', loss)
    print('Accuracy:', acc)

    # 用val跑一遍網絡，並計算在val dataset上的准確率
    # ===================== BN-start =====================
    # 跑網絡之前，先將BN層設置為validation模式
    # BN層會自動使用在訓練時累計的running_mean和running_var
    net.eval()
    #net.model[1].eval()
    #net.model[4].eval()
    # ===================== BN-end =======================

    val_z = net(val_data).to(device)
    val_loss = F.cross_entropy(val_z, val_target).to(device)
    val_eq_mat = torch.eq(val_z.argmax(dim=1), val_target)
    val_acc = torch.sum(val_eq_mat).float().item() / val_eq_mat.size()[0]
    print('Val Loss:', val_loss)
    print('Val Accuracy:', val_acc)

    # 將loss和acc畫到visdom中
    viz.line(Y=np.column_stack((acc, val_acc)),
             X=np.column_stack((epoch, epoch)),
             win='Accuracy',
             update='append',
             opts=dict(markers=False, legend=['Acc', 'Val Acc']))
    # 將val loss和val acc畫到visdom中
    viz.line(Y=np.column_stack((loss.cpu().item(), val_loss.cpu().item())),
             X=np.column_stack((epoch, epoch)),
             win='Loss',
             update='append',
             opts=dict(markers=False, legend=['Loss', 'Val Loss']))

使用BN時的ACC和LOSS：

未使用BN時的ACC和LOSS：

 從上述結果可以看出，使用BN后，收斂速度變快。