Lesson 15.2 學習率調度在PyTorch中的實現方法

??學習率調度作為模型優化的重要方法，也集成在了PyTorch的optim模塊中。我們可以通過下述代碼將學習率調度模塊進行導入。

from torch.optim import lr_scheduler

??接下來，我們從較為基礎的學習率調度方法入手，熟悉PyTorch中實現學習率調度的基本思路與流程。

一、優化器與狀態字典（state_dict）

??在此前的模型訓練過程中，我們已經基本了解了PyTorch中的模型優化器的基本使用方法。模型優化器是求解損失函數的函數，其中包含了模型訓練的諸多關鍵信息，包括模型參數、模型學習率等，同時在進行模型訓練時，我們也是通過優化器調整模型參數、歸零模型梯度。而在學習率調度過程中，由于我們需要動態調整學習率，而學習率又是通過傳入優化器進而影響模型訓練的，因此在利用PyTorch進行學習率調度的時候，核心需要考慮的問題是如何讓優化器內的學習率隨著迭代次數增加而不斷變化。
??為做到這一點，首先我們需要補充關于優化器狀態字典內容。

# 設置隨機數種子 torch.manual_seed(420) # 創建最高項為2的多項式回歸數據集 features, labels = tensorGenReg(w=[2, -1, 3, 1, 2], bias=False, deg=2)# 進行數據集切分與加載 train_loader, test_loader = split_loader(features, labels, batch_size=50)# 設置隨機數種子 torch.manual_seed(24) # 實例化模型 tanh_model1 = net_class2(act_fun= torch.tanh, in_features=5, BN_model='pre')# 創建優化器 optimizer = torch.optim.SGD(tanh_model1.parameters(), lr=0.01)

在優化器創建完成之后，我們可以使用.state_dict()方法查看優化器狀態。

optimizer.state_dict() #{'state': {}, # 'param_groups': [{'lr': 0.01, # 'momentum': 0, # 'dampening': 0, # 'weight_decay': 0, # 'nesterov': False, # 'params': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}]}

該方法會返回一個包含優化器核心信息的字典，目前為止該字典包含兩個元素，第一個是優化器狀態（state），第二個是優化器相關參數簇（param_groups），其中，目前為止核心需要關注的是參數簇中的lr對象，該對象代表著下一次模型訓練的時候所帶入的學習率。當然，我們可以通過如下方法提取lr對應的value

optimizer.state_dict()['param_groups'] #[{'lr': 0.01, # 'momentum': 0, # 'dampening': 0, # 'weight_decay': 0, # 'nesterov': False, # 'params': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}] optimizer.state_dict()['param_groups'][0] #{'lr': 0.01, # 'momentum': 0, # 'dampening': 0, # 'weight_decay': 0, # 'nesterov': False, # 'params': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]} optimizer.state_dict()['param_groups'][0]['lr'] #0.01

參數簇中其他參數包括動量系數、特征權重、是否采用牛頓法及待訓練參數索引。

另外，params表示訓練參數個數（其中一個矩陣算作一個參數），可以通過如下方式進行簡單驗證。

list(tanh_model1.parameters()) # [Parameter containing: # tensor([[ 0.2365, -0.1118, -0.3801, 0.0275, 0.4168], # [-0.1995, -0.1456, 0.3497, -0.0622, -0.1708], # [-0.0901, 0.0164, -0.3643, -0.1278, 0.4336], # [-0.0959, 0.4073, -0.1746, -0.1799, -0.1333]], requires_grad=True), # Parameter containing: # tensor([-0.3999, -0.2694, 0.2703, -0.3355], requires_grad=True), # Parameter containing: # tensor([1., 1., 1., 1.], requires_grad=True), # Parameter containing: # tensor([0., 0., 0., 0.], requires_grad=True), # Parameter containing: # tensor([[ 0.1708, 0.4704, -0.0635, 0.2187], # [ 0.2336, -0.3569, -0.1928, -0.1566], # [ 0.4825, -0.4463, 0.3027, 0.4696], # [ 0.3953, 0.2131, 0.2226, -0.0267]], requires_grad=True), # Parameter containing: # tensor([ 0.2516, 0.4558, -0.1608, 0.4831], requires_grad=True), # Parameter containing: # tensor([1., 1., 1., 1.], requires_grad=True), # Parameter containing: # tensor([0., 0., 0., 0.], requires_grad=True), # Parameter containing: # tensor([[ 0.0795, -0.3507, -0.3589, 0.1764]], requires_grad=True), # Parameter containing: # tensor([-0.0705], requires_grad=True)]# 驗證帶訓練參數個數 len(list(tanh_model1.parameters())) #10tanh_model2 = net_class3(act_fun= torch.tanh, in_features=5, BN_model='pre')optimizer1 = torch.optim.SGD(tanh_model2.parameters(), lr=0.05) optimizer1.state_dict() #{'state': {}, # 'param_groups': [{'lr': 0.05, # 'momentum': 0, # 'dampening': 0, # 'weight_decay': 0, # 'nesterov': False, # 'params': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]}]}len(list(tanh_model2.parameters())) #14

模型本地保存與讀取方法

??同時，借助state_dict()方法，我們可以實現模型或優化器的本地保存與讀取。此處以模型為例，優化器的本地保存相關操作類似。
??對于模型而言，其實也有state_dict()方法。通過該方法的調用，可以查看模型全部參數信息。

值得注意的是，模型的訓練和保存，本質上都是針對模型的參數。而模型的state_dict()則包含了模型當前全部的參數信息。因此，保存了模型的state_dict()就相當于是保存了模型。

# 設置隨機數種子 torch.manual_seed(24) # 實例化模型 tanh_model1 = net_class2(act_fun= torch.tanh, in_features=5, BN_model='pre')tanh_model1.state_dict() # OrderedDict([('linear1.weight', # tensor([[ 0.2365, -0.1118, -0.3801, 0.0275, 0.4168], # [-0.1995, -0.1456, 0.3497, -0.0622, -0.1708], # [-0.0901, 0.0164, -0.3643, -0.1278, 0.4336], # [-0.0959, 0.4073, -0.1746, -0.1799, -0.1333]])), # ('linear1.bias', tensor([-0.3999, -0.2694, 0.2703, -0.3355])), # ('normalize1.weight', tensor([1., 1., 1., 1.])), # ('normalize1.bias', tensor([0., 0., 0., 0.])), # ('normalize1.running_mean', tensor([0., 0., 0., 0.])), # ('normalize1.running_var', tensor([1., 1., 1., 1.])), # ('normalize1.num_batches_tracked', tensor(0)), # ('linear2.weight', # tensor([[ 0.1708, 0.4704, -0.0635, 0.2187], # [ 0.2336, -0.3569, -0.1928, -0.1566], # [ 0.4825, -0.4463, 0.3027, 0.4696], # [ 0.3953, 0.2131, 0.2226, -0.0267]])), # ('linear2.bias', tensor([ 0.2516, 0.4558, -0.1608, 0.4831])), # ('normalize2.weight', tensor([1., 1., 1., 1.])), # ('normalize2.bias', tensor([0., 0., 0., 0.])), # ('normalize2.running_mean', tensor([0., 0., 0., 0.])), # ('normalize2.running_var', tensor([1., 1., 1., 1.])), # ('normalize2.num_batches_tracked', tensor(0)), # ('linear3.weight', # tensor([[ 0.0795, -0.3507, -0.3589, 0.1764]])), # ('linear3.bias', tensor([-0.0705]))])

首先，我們可以將該存有模型全部參數信息的字典對象賦給某個變量。

t1 = tanh_model1.state_dict() t1 # OrderedDict([('linear1.weight', # tensor([[ 0.2365, -0.1118, -0.3801, 0.0275, 0.4168], # [-0.1995, -0.1456, 0.3497, -0.0622, -0.1708], # [-0.0901, 0.0164, -0.3643, -0.1278, 0.4336], # [-0.0959, 0.4073, -0.1746, -0.1799, -0.1333]])), # ('linear1.bias', tensor([-0.3999, -0.2694, 0.2703, -0.3355])), # ('normalize1.weight', tensor([1., 1., 1., 1.])), # ('normalize1.bias', tensor([0., 0., 0., 0.])), # ('normalize1.running_mean', tensor([0., 0., 0., 0.])), # ('normalize1.running_var', tensor([1., 1., 1., 1.])), # ('normalize1.num_batches_tracked', tensor(0)), # ('linear2.weight', # tensor([[ 0.1708, 0.4704, -0.0635, 0.2187], # [ 0.2336, -0.3569, -0.1928, -0.1566], # [ 0.4825, -0.4463, 0.3027, 0.4696], # [ 0.3953, 0.2131, 0.2226, -0.0267]])), # ('linear2.bias', tensor([ 0.2516, 0.4558, -0.1608, 0.4831])), # ('normalize2.weight', tensor([1., 1., 1., 1.])), # ('normalize2.bias', tensor([0., 0., 0., 0.])), # ('normalize2.running_mean', tensor([0., 0., 0., 0.])), # ('normalize2.running_var', tensor([1., 1., 1., 1.])), # ('normalize2.num_batches_tracked', tensor(0)), # ('linear3.weight', # tensor([[ 0.0795, -0.3507, -0.3589, 0.1764]])), # ('linear3.bias', tensor([-0.0705]))])

其次，我們也可以通過torch.save來將該參數保存至本地。

torch.save(tanh_model1.state_dict(), 'tanh1.pt')

??對于torch.save函數來說，第一個參數是需要保存的模型參數，而第二個參數則是保存到本地的文件名。一般來說可以令其后綴為.pt或.pth。而當我們需要讀取保存的參數結果時，則可以直接使用load_state_dict方法w。該方法的使用我們稍后就會談到。
??接下來進行模型訓練，也就是模型參數調整。回顧此前學習內容，當我們進行模型訓練時，實際上就是借助損失函數和反向傳播機制進行梯度求解，然后利用優化器根據梯度值去更新各線性層參數。

criterion = nn.MSELoss() optimizer = torch.optim.SGD(tanh_model1.parameters(), lr=0.05) for X, y in train_loader:yhat = tanh_model1.forward(X)loss = criterion(yhat, y)optimizer.zero_grad()loss.backward()optimizer.step()

訓練完一輪之后，我們可以查看模型狀態：

tanh_model1.state_dict() # OrderedDict([('linear1.weight', # tensor([[ 0.0436, -0.3587, -0.3227, 0.0310, 0.4388], # [-0.0870, -0.1146, 0.4255, -0.0052, -0.3548], # [-0.0154, 0.1517, -0.4181, -0.0605, 0.4350], # [-0.0627, 0.5445, 0.0345, -0.1221, 0.1262]])), # ('linear1.bias', tensor([-0.3999, -0.2694, 0.2703, -0.3355])), # ('normalize1.weight', tensor([1.0497, 0.9741, 1.0267, 1.0508])), # ('normalize1.bias', tensor([ 0.0358, -0.1734, -0.1451, 0.0043])), # ('normalize1.running_mean', # tensor([-0.3789, -0.2839, 0.2689, -0.3484])), # ('normalize1.running_var', # tensor([0.3839, 0.2907, 0.3761, 0.2507])), # ('normalize1.num_batches_tracked', tensor(42)), # ('linear2.weight', # tensor([[ 0.1514, 0.5047, -0.0870, 0.1669], # [ 0.2090, 0.0034, -0.3558, -0.4330], # [ 0.4056, -0.3937, 0.3199, 0.5734], # [ 0.3083, 0.3801, -0.0587, -0.2878]])), # ('linear2.bias', tensor([ 0.2516, 0.4558, -0.1608, 0.4831])), # ('normalize2.weight', tensor([1.0229, 0.4936, 0.2831, 0.7715])), # ('normalize2.bias', tensor([-0.0817, -1.2150, -1.1698, 0.8213])), # ('normalize2.running_mean', # tensor([ 0.2384, 0.4661, -0.1415, 0.4703])), # ('normalize2.running_var', # tensor([0.0720, 0.1388, 0.6376, 0.0972])), # ('normalize2.num_batches_tracked', tensor(42)), # ('linear3.weight', # tensor([[-0.3395, -1.3164, -1.1326, 0.8836]])), # ('linear3.bias', tensor([4.8350]))])

我們發現模型的參數已經發生了變化。當然，此時t1也隨之發生了變化

t1 # OrderedDict([('linear1.weight', # tensor([[ 0.0436, -0.3587, -0.3227, 0.0310, 0.4388], # [-0.0870, -0.1146, 0.4255, -0.0052, -0.3548], # [-0.0154, 0.1517, -0.4181, -0.0605, 0.4350], # [-0.0627, 0.5445, 0.0345, -0.1221, 0.1262]])), # ('linear1.bias', tensor([-0.3999, -0.2694, 0.2703, -0.3355])), # ('normalize1.weight', tensor([1.0497, 0.9741, 1.0267, 1.0508])), # ('normalize1.bias', tensor([ 0.0358, -0.1734, -0.1451, 0.0043])), # ('normalize1.running_mean', # tensor([-0.3789, -0.2839, 0.2689, -0.3484])), # ('normalize1.running_var', # tensor([0.3839, 0.2907, 0.3761, 0.2507])), # ('normalize1.num_batches_tracked', tensor(0)), # ('linear2.weight', # tensor([[ 0.1514, 0.5047, -0.0870, 0.1669], # [ 0.2090, 0.0034, -0.3558, -0.4330], # [ 0.4056, -0.3937, 0.3199, 0.5734], # [ 0.3083, 0.3801, -0.0587, -0.2878]])), # ('linear2.bias', tensor([ 0.2516, 0.4558, -0.1608, 0.4831])), # ('normalize2.weight', tensor([1.0229, 0.4936, 0.2831, 0.7715])), # ('normalize2.bias', tensor([-0.0817, -1.2150, -1.1698, 0.8213])), # ('normalize2.running_mean', # tensor([ 0.2384, 0.4661, -0.1415, 0.4703])), # ('normalize2.running_var', # tensor([0.0720, 0.1388, 0.6376, 0.0972])), # ('normalize2.num_batches_tracked', tensor(0)), # ('linear3.weight', # tensor([[-0.3395, -1.3164, -1.1326, 0.8836]])), # ('linear3.bias', tensor([4.8350]))])

此時，如果我們想還原tanh_model1中原始參數，我們只能考慮通過使用load_state_dict方法，將本次保存的原模型參數替換當前的tanh_model1中參數，具體方法如下：

torch.load('tanh1.pt') # OrderedDict([('linear1.weight', # tensor([[ 0.2365, -0.1118, -0.3801, 0.0275, 0.4168], # [-0.1995, -0.1456, 0.3497, -0.0622, -0.1708], # [-0.0901, 0.0164, -0.3643, -0.1278, 0.4336], # [-0.0959, 0.4073, -0.1746, -0.1799, -0.1333]])), # ('linear1.bias', tensor([-0.3999, -0.2694, 0.2703, -0.3355])), # ('normalize1.weight', tensor([1., 1., 1., 1.])), # ('normalize1.bias', tensor([0., 0., 0., 0.])), # ('normalize1.running_mean', tensor([0., 0., 0., 0.])), # ('normalize1.running_var', tensor([1., 1., 1., 1.])), # ('normalize1.num_batches_tracked', tensor(0)), # ('linear2.weight', # tensor([[ 0.1708, 0.4704, -0.0635, 0.2187], # [ 0.2336, -0.3569, -0.1928, -0.1566], # [ 0.4825, -0.4463, 0.3027, 0.4696], # [ 0.3953, 0.2131, 0.2226, -0.0267]])), # ('linear2.bias', tensor([ 0.2516, 0.4558, -0.1608, 0.4831])), # ('normalize2.weight', tensor([1., 1., 1., 1.])), # ('normalize2.bias', tensor([0., 0., 0., 0.])), # ('normalize2.running_mean', tensor([0., 0., 0., 0.])), # ('normalize2.running_var', tensor([1., 1., 1., 1.])), # ('normalize2.num_batches_tracked', tensor(0)), # ('linear3.weight', # tensor([[ 0.0795, -0.3507, -0.3589, 0.1764]])), # ('linear3.bias', tensor([-0.0705]))]) tanh_model1.load_state_dict(torch.load('tanh1.pt')) #<All keys matched successfully> tanh_model1.state_dict() # OrderedDict([('linear1.weight', # tensor([[ 0.2365, -0.1118, -0.3801, 0.0275, 0.4168], # [-0.1995, -0.1456, 0.3497, -0.0622, -0.1708], # [-0.0901, 0.0164, -0.3643, -0.1278, 0.4336], # [-0.0959, 0.4073, -0.1746, -0.1799, -0.1333]])), # ('linear1.bias', tensor([-0.3999, -0.2694, 0.2703, -0.3355])), # ('normalize1.weight', tensor([1., 1., 1., 1.])), # ('normalize1.bias', tensor([0., 0., 0., 0.])), # ('normalize1.running_mean', tensor([0., 0., 0., 0.])), # ('normalize1.running_var', tensor([1., 1., 1., 1.])), # ('normalize1.num_batches_tracked', tensor(0)), # ('linear2.weight', # tensor([[ 0.1708, 0.4704, -0.0635, 0.2187], # [ 0.2336, -0.3569, -0.1928, -0.1566], # [ 0.4825, -0.4463, 0.3027, 0.4696], # [ 0.3953, 0.2131, 0.2226, -0.0267]])), # ('linear2.bias', tensor([ 0.2516, 0.4558, -0.1608, 0.4831])), # ('normalize2.weight', tensor([1., 1., 1., 1.])), # ('normalize2.bias', tensor([0., 0., 0., 0.])), # ('normalize2.running_mean', tensor([0., 0., 0., 0.])), # ('normalize2.running_var', tensor([1., 1., 1., 1.])), # ('normalize2.num_batches_tracked', tensor(0)), # ('linear3.weight', # tensor([[ 0.0795, -0.3507, -0.3589, 0.1764]])), # ('linear3.bias', tensor([-0.0705]))])

至此，我們就完成了模型訓練與保存的基本過程。當然，除了模型可以按照上述方法保存外，優化器也可以類似進行本地存儲。

當然，結合此前介紹的深拷貝的相關概念，此處我們能否通過深拷貝的方式將模型參數保存在當前操作空間內然后再替換訓練后的模型參數呢？同學們可以自行嘗試

接下來，我們通過調用optim模塊中lr_scheduler相關函數，來實現優化器中學習率的動態調整。

二、LambdaLR基本使用方法

??讓優化器動態調整學習率的類，也被我們稱為學習率調度器類，該類實例化的對象也被稱為學習率調度器。在所有的學習率調度器中，LambdaLR類是實現學習率調度最簡單靈活、同時也是最通用的一種方法。
??要使用LambdaLR來完成學習率調度，首先需要準備一個lambda匿名函數，例如：

lr_lambda = lambda epoch: 0.5 ** epoch

此處我們通過lambda創建了一個匿名函數。該函數需要輸入一個參數，一般來說我們會將該參數視作模型迭代次數。當然上述匿名函數是個非常簡單的匿名函數，輸出結果就是0.5的epoch次方。

# 第一輪迭代時 lr_lambda(0) #1.0 # 第二輪迭代時 lr_lambda(1) #0.5

此處需要注意，一般來說epoch取值從0開始，并且用于學習率調度的匿名函數參數取值為0時，輸出結果不能為0。

??在準備好一個匿名函數之后，接下來我們需要實例化一個LambdaLR學習率調度器。同時，由于所有的學習率調度器都是通過修改某個優化器來完成學習率調度，因此我們還需要創建一個對應的優化器（當然為了模型訓練，也是要創建優化器的）。優化器的創建無須其他設置，該優化器和學習率調度器的關聯主要是通過學習率調度器來體現。

# 設置隨機數種子 torch.manual_seed(24) # 實例化模型 tanh_model1 = net_class2(act_fun= torch.tanh, in_features=5, BN_model='pre')# 創建優化器 optimizer = torch.optim.SGD(tanh_model1.parameters(), lr=0.05)# 查看優化器信息 optimizer.state_dict() #{'state': {}, # 'param_groups': [{'lr': 0.05, # 'momentum': 0, # 'dampening': 0, # 'weight_decay': 0, # 'nesterov': False, # 'params': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}]} # 創建學習率調度器 scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda)

注意，LambdaLR學習率調度器的創建必須要輸入一個lambda函數和與之關聯的優化器。一旦優化器創建完成，我們即可繼續觀察優化器optimizer的狀態。

optimizer.state_dict() #{'state': {}, # 'param_groups': [{'lr': 0.05, # 'momentum': 0, # 'dampening': 0, # 'weight_decay': 0, # 'nesterov': False, # 'initial_lr': 0.05, # 'params': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}]}

??此時優化器的參數簇中多了’initial_lr’元素。該元素代表初始學習率，也就是我們在實例化優化器時輸入的學習率。而優化器中的lr，則仍然表示下一次迭代時的學習率。

對于LambdaLR學習調度來說，優化器中的lr伴隨模型迭代相應調整的方法如下：
$$lr=lr\_lambda(epoch)?initial\_lr$$
??并且，第一次實例化LambdaLR時epoch取值為0時，因此此時優化器的lr計算結果如下：$$l{r}_0=0.5^0?0.05=0.05$$而在后續計算過程中，每當我們調用一次scheduler.step()，epoch數值就會+1。我們可以進行下述實驗，即當一輪訓練完成時，我們可通過scheduler.step()來更新下一輪迭代時的學習率。

for X, y in train_loader:yhat = tanh_model1.forward(X)loss = criterion(yhat, y)optimizer.zero_grad()loss.backward()optimizer.step() scheduler.step()

需要注意，在上述模型訓練的代碼中，之所以將學習率調度器放在模型小批量梯度下降循環的外側，也是因為一般來說遍歷一次完整訓練集（一個epoch）才會對學習率進行一次更新，而不是每次計算完一個小批數據就對模型學習率進行更新。

optimizer.state_dict() #{'state': {}, # 'param_groups': [{'lr': 0.025, # 'momentum': 0, # 'dampening': 0, # 'weight_decay': 0, # 'nesterov': False, # 'initial_lr': 0.05, # 'params': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}]}

而此時lr的取值0.025，則是由lr_lambda當epoch取值為1時的輸出結果和initial_lr相乘之后的結果。也就是$$lr=0.5^1?0.05=0.025$$而如果把上述過程封裝為一個循環（也就是此前定義的fit函數），則下次模型訓練時學習率就調整為了0.025。
??至此，我們也就知道了scheduler.step()的真實作用——令匿名函數的自變量+1，然后令匿名函數的輸出結果與initial_lr相乘，并把計算結果傳給優化器，作為下一次優化器計算時的學習率。
??當然，我們也能簡單的重復optimizer.step()與scheduler.step()，即可一次次完成計算新學習率、并將新學習率傳輸給優化器的過程。

optimizer.zero_grad() optimizer.step() scheduler.step()lr_lambda = lambda epoch: 0.5 ** epoch lr_lambda(2) * 0.05 #0.0125 optimizer.state_dict() #{'state': {}, # 'param_groups': [{'lr': 0.0125, # 'momentum': 0, # 'dampening': 0, # 'weight_decay': 0, # 'nesterov': False, # 'initial_lr': 0.05, # 'params': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}]} ss = scheduler.state_dict() ss #{'base_lrs': [0.05], # 'last_epoch': 2, # '_step_count': 3, # 'verbose': False, # '_get_lr_called_within_step': False, # '_last_lr': [0.0125], # 'lr_lambdas': [None]}

不出意外，在第三次scheduler.step()時，匿名函數輸出結果為$0.5^2$，再與initial_lr相乘之后結果為0.0125。

此處需要注意，PyTorch中要求先進行優化器的step，再進行學習率調度的step，此處需要注意先后順序。另外，上述過程之所以提前將優化器內保存的模型參數清零，也是為了防止上述實驗過程最終導致模型參數被修改（梯度為0時模型無法修改參數）。

當然，每一輪epoch都讓模型學習率衰減50%其實是非常激進的。我們可以通過繪制圖像觀察學習率衰減情況。

# 創建優化器 optimizer = torch.optim.SGD(tanh_model1.parameters(), lr=0.05) # 創建學習率調度器 scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda) optimizer.state_dict()['param_groups'][0]['lr'] #0.05 lr_l = [0.05] for i in range(10):optimizer.step()scheduler.step()lr = optimizer.state_dict()['param_groups'][0]['lr']lr_l.append(lr) plt.plot(lr_l) plt.xlabel('epoch') plt.ylabel('Learning rate')

接下來，我們放緩學習率衰減速率，進行學習率調度建模實驗。

三、LambdaLR學習率調度實驗

1.前期準備與匿名函數定義

??在實驗開始前，我們需要將之前定義的fit_rec函數再次進行改寫，新函數需要包含學習率調度相關方法。

def fit_rec_sc(net, criterion, optimizer, train_data,test_data,scheduler,epochs = 3, cla = False, eva = mse_cal):"""加入學習率調度后的模型訓練函數（記錄每一次遍歷后模型評估指標）:param net：待訓練的模型 :param criterion: 損失函數:param optimizer：優化算法:param train_data：訓練數據:param test_data: 測試數據 :param scheduler: 學習率調度器:param epochs: 遍歷數據次數:param cla: 是否是分類問題:param eva: 模型評估方法:return：模型評估結果"""train_l = []test_l = []for epoch in range(epochs):net.train()for X, y in train_data:if cla == True:y = y.flatten().long() # 如果是分類問題，需要對y進行整數轉化yhat = net.forward(X)loss = criterion(yhat, y)optimizer.zero_grad()loss.backward()optimizer.step()scheduler.step()net.eval()train_l.append(eva(train_data, net).detach())test_l.append(eva(test_data, net).detach())return train_l, test_l

同樣，該函數需要寫入torchLearning.py文件中。接下來，我們定義一個衰減速度更加緩慢的學習率調度器。

lr_lambda = lambda epoch: 0.95 ** epoch # 第一輪迭代時 lr_lambda(0) #1.0 # 第二輪迭代時 lr_lambda(1) #0.95 lr_lambda(100) #0.0059205292203339975

相當于每迭代一輪學習率衰減5%。

# 設置隨機數種子 torch.manual_seed(24) # 實例化模型 tanh_model1 = net_class2(act_fun=torch.tanh, in_features=5, BN_model='pre') # 創建優化器 optimizer = torch.optim.SGD(tanh_model1.parameters(), lr=0.05) # 創建學習率調度器 scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda)

3.模型訓練與結果比較

# 進行模型訓練 train_l, test_l = fit_rec_sc(net = tanh_model1, criterion = nn.MSELoss(), optimizer = optimizer, train_data = train_loader,test_data = test_loader,scheduler = scheduler,epochs = 60, cla = False, eva = mse_cal) plt.plot(train_l, label='train_mse') plt.xlabel('epochs') plt.ylabel('MSE') plt.legend(loc = 1)

簡單驗證學習率最終調整結果。

optimizer.state_dict() #{'state': {}, # 'param_groups': [{'lr': 0.002303489949347597, # 'momentum': 0, # 'dampening': 0, # 'weight_decay': 0, # 'nesterov': False, # 'initial_lr': 0.05, # 'params': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}]} lr_lambda(60) * 0.05 #0.002303489949347597

當然，我們也可以繼續進行實驗，對比恒定學習率時計算結果

• 對比恒定學習率為0.03時模型訓練結果

# 設置隨機數種子 torch.manual_seed(24) # 實例化模型 tanh_model1 = net_class2(act_fun= torch.tanh, in_features=5, BN_model='pre')train_l3, test_l3 = fit_rec(net = tanh_model1, criterion = nn.MSELoss(), optimizer = optim.SGD(tanh_model1.parameters(), lr = 0.03), train_data = train_loader,test_data = test_loader,epochs = 60, cla = False, eva = mse_cal) plt.plot(train_l, label='train_l') plt.plot(train_l3, label='train_l3') plt.xlabel('epochs') plt.ylabel('MSE') plt.legend(loc = 1)

我們發現，相比恒定學習為0.03的模型，加入學習率調度策略的模型，模型收斂效果更好、迭代更加平穩，且收斂速度較快。

• 對比恒定學習率為0.01時模型訓練結果

# 設置隨機數種子 torch.manual_seed(24) # 實例化模型 tanh_model1 = net_class2(act_fun= torch.tanh, in_features=5, BN_model='pre')train_l1, test_l1 = fit_rec(net = tanh_model1, criterion = nn.MSELoss(), optimizer = optim.SGD(tanh_model1.parameters(), lr = 0.01), train_data = train_loader,test_data = test_loader,epochs = 60, cla = False, eva = mse_cal) plt.plot(train_l, label='train_l') plt.plot(train_l3, label='train_l3') plt.plot(train_l1, label='train_l1') plt.xlabel('epochs') plt.ylabel('MSE') plt.legend(loc = 1)

我們發現，相比恒定學習率為0.01的模型，擁有學習率調度的模型結果更優秀。

• 對比Lesson 15.1節中學習率調度模型

# 設置隨機數種子 torch.manual_seed(24) # 實例化模型 tanh_model = net_class2(act_fun=torch.tanh, in_features=5, BN_model='pre')# 創建用于保存記錄結果的空列表容器 train_mse = [] test_mse = []# 創建可以捕捉手動輸入數據的模型訓練流程 while input("Do you want to continue the iteration? [y/n]") == "y": # 詢問是否繼續迭代epochs = int(input("Number of epochs:")) # 下一輪迭代遍歷幾次數據lr = float(input("Update learning rate：")) # 設置下一輪迭代的學習率train_l0, test_l0 = fit_rec(net = tanh_model, criterion = nn.MSELoss(), optimizer = optim.SGD(tanh_model.parameters(), lr = lr), train_data = train_loader,test_data = test_loader,epochs = epochs, cla = False, eva = mse_cal)train_mse.extend(train_l0)test_mse.extend(test_l0) #Do you want to continue the iteration? [y/n] y #Number of epochs: 30 #Update learning rate： 0.03 #Do you want to continue the iteration? [y/n] y #Number of epochs: 30 #Update learning rate： 0.01 #Do you want to continue the iteration? [y/n] n plt.plot(train_l, label='train_l') plt.plot(train_mse, label='train_mse') plt.xlabel('epochs') plt.ylabel('MSE') plt.legend(loc = 1)

很明顯，由于上一節的模型是0.03學習率模型和0.01學習率模型簡單疊加結果，在恒定學習率模型效果均不如本節模型的情況下，上一節課中的模型學習率調度策略也無法有更好的表現。
??但是，令人驚訝的是，在訓練了60輪之后，LambdaLR模型最終學習率在0.002附近，相比上述0.01學習率模型而言學習率更小。但從上述的實驗中我們發現，恒定學習率時從恒定0.03到恒定0.01的過程，模型準確率已經發生了明顯的下降，但在如果是采用動態調整學習率的策略，則可以在一個最終更小的學習率取值的情況下取得一個更好的模型結果。

lr_lambda(60) * 0.05 #0.002303489949347597

??這其實說明損失函數在超平面空間的圖像比一般的想象要復雜的多，很多時候并不是越靠近全域最小值點附近的通道就越窄，會導致迭代過程落入局部最小值陷阱的學習率大小取值也只是絕對概念。正是由于損失函數的復雜性，才導致很多時候我們認為神經網絡的內部訓練是個“黑箱”，才進一步導致神經網絡的模型訓練往往以模型結果為最終依據，這也是神經網絡優化算法會誕生諸多基本原理層面比較扎實，但卻找不到具體能夠證明優化效果的理論依據的方法。
??不過，針對此類方法，和此前介紹的Batch Normalization一樣，盡管理論層面無法具體整體優化效果，但對于使用者來說仍然需要在了解其底層原理基礎上積累使用經驗或者調參經驗。因此在后續的課程中，我們將在繼續介紹其他學習率優化方法的同時，通過大量的實踐來快速積累使用經驗，并且在更多事實的基礎上找到解釋和理解的角度。

總結

以上是生活随笔為你收集整理的Lesson 15.2 学习率调度在PyTorch中的实现方法的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。