文章最前： 我是Octopus，這個名字來源于我的中文名–章魚；我熱愛編程、熱愛算法、熱愛開源。所有源碼在我的個人github ；這博客是記錄我學習的點點滴滴，如果您對 Python、Java、AI、算法有興趣，可以關注我的動態，一起學習，共同進步。

一般來說，監督學習的目標函數由損失函數和正則化項組成。(Objective = Loss + Regularization)

Pytorch中的損失函數一般在訓練模型時候指定。

注意Pytorch中內置的損失函數的參數和tensorflow不同，是y_pred在前，y_true在后，而Tensorflow是y_true在前，y_pred在后。

對于回歸模型，通常使用的內置損失函數是均方損失函數nn.MSELoss 。

對于二分類模型，通常使用的是二元交叉熵損失函數nn.BCELoss (輸入已經是sigmoid激活函數之后的結果)
或者 nn.BCEWithLogitsLoss (輸入尚未經過nn.Sigmoid激活函數) 。

對于多分類模型，一般推薦使用交叉熵損失函數 nn.CrossEntropyLoss。
(y_true需要是一維的，是類別編碼。y_pred未經過nn.Softmax激活。)

此外，如果多分類的y_pred經過了nn.LogSoftmax激活，可以使用nn.NLLLoss損失函數(The negative log likelihood loss)。
這種方法和直接使用nn.CrossEntropyLoss等價。

如果有需要，也可以自定義損失函數，自定義損失函數需要接收兩個張量y_pred，y_true作為輸入參數，并輸出一個標量作為損失函數值。

Pytorch中的正則化項一般通過自定義的方式和損失函數一起添加作為目標函數。

如果僅僅使用L2正則化，也可以利用優化器的weight_decay參數來實現相同的效果。

一，內置損失函數

內置的損失函數一般有類的實現和函數的實現兩種形式。

如：nn.BCE 和 F.binary_cross_entropy 都是二元交叉熵損失函數，前者是類的實現形式，后者是函數的實現形式。

實際上類的實現形式通常是調用函數的實現形式并用nn.Module封裝后得到的。

一般我們常用的是類的實現形式。它們封裝在torch.nn模塊下，并且類名以Loss結尾。

常用的一些內置損失函數說明如下。

• nn.MSELoss（均方誤差損失，也叫做L2損失，用于回歸）

• nn.L1Loss （L1損失，也叫做絕對值誤差損失，用于回歸）

• nn.SmoothL1Loss (平滑L1損失，當輸入在-1到1之間時，平滑為L2損失，用于回歸)

• nn.BCELoss (二元交叉熵，用于二分類，輸入已經過nn.Sigmoid激活，對不平衡數據集可以用weigths參數調整類別權重)

• nn.BCEWithLogitsLoss (二元交叉熵，用于二分類，輸入未經過nn.Sigmoid激活)

• nn.CrossEntropyLoss (交叉熵，用于多分類，要求label為稀疏編碼，輸入未經過nn.Softmax激活，對不平衡數據集可以用weigths參數調整類別權重)

• nn.NLLLoss (負對數似然損失，用于多分類，要求label為稀疏編碼，輸入經過nn.LogSoftmax激活)

• nn.KLDivLoss (KL散度損失，也叫相對熵，等于交叉熵減去信息熵，用于標簽為概率值的多分類，要求輸入經過nn.LogSoftmax激活)

• nn.CosineSimilarity(余弦相似度，可用于多分類)

• nn.AdaptiveLogSoftmaxWithLoss (一種適合非常多類別且類別分布很不均衡的損失函數，會自適應地將多個小類別合成一個cluster)

重點介紹一下 二元交叉熵、多元交叉熵、對數損失LogLoss、負對數似然損失NLLLoss、KL散度之間的區別和聯系。

1，二分類的交叉熵的計算公式是什么？為什么是這樣一種形式？

$$BinaryCrossEntropyLoss(Y,\hat{Y})=?\frac{1}{N}\sum _{i=0}^{N?1}(y_{i}log\widehat{y_i}+(1?y_i)log(1?\widehat{y_i}))$$

該公式由極大似然原理推導得來。由于 $\widehat{y_i}$表示的是樣本標簽為1的概率， $1?\widehat{y_i}$表示的是樣本標簽為0的概率，
那么訓練集中的全部樣本取得對應標簽的概率即似然函數可以寫成如下形式

$$L(Y,\hat{Y})=\prod _{i=0}^{N?1}{\widehat{y_i}}^{y_i}(1?\widehat{y_i}{)}^{(1?y_i)}$$

注意當$y_i=1$為時，連乘中的項為 $\widehat{y_i}$，當$y_i=0$為時，連乘中的項為 $(1?\widehat{y_i})$、

轉換成對數似然函數，得到

$$lnL(Y,\hat{Y})=\sum _{i=0}^{N?1}{y}_{i}ln\widehat{y_i}+(1?y_i)ln(1?\widehat{y_i})$$

對數似然函數求極大值，等價于對對數似然函數的負數求極小值，考慮樣本數量維度歸一化，于是得到了二元交叉熵損失函數的形式。

2，多元交叉熵的計算公式是什么？和二元交叉熵有什么聯系?

$$\begin{gathered} CrossEntropyLoss(Y,\hat{Y})=?\frac{1}{N}\sum _{i=0}^{N?1}\sum _{k=0}^{K?1}I(y_i==k)log\widehat{y_{i,k}} \\ \text{where}I(x)\text{?is?the?Indicator?function} \\ I(True)=1\text{?and?}I(False)=0 \end{gathered}$$

多元交叉熵是二元交叉熵的自然拓展，其中$y_i$取0~K-1其中的一個類別編碼序號，$\widehat{y_i}$ 是一個長度為K的概率向量。多元交叉熵的類別數K取2時即可得到二元交叉熵對應的公式。

3，sklearn，catboost等庫中常常看到logloss對數損失函數，這個損失函數如何計算，和交叉熵有什么關系？

$$LogLoss(Y,\hat{Y})=?\frac{1}{N}\sum _{i=0}^{N?1}log(\widehat{y_i}[y_i])$$

公式中的方括號和Python中的索引的用法一致，表示取$\widehat{y_i}$ 的第$y_i$個元素。

容易證明，對數損失函數與交叉熵函數完全等價，是交叉熵的另外一種視角: 即每個樣本對其標簽對應類別的預測概率值求對數，求平均再取負數即可。

4，pytorch中的 nn.NLLLoss 和 nn.CrossEntropyLoss有什么區別和聯系？

NLLoss 全稱是 Negative Log Likelihood Loss，即 負對數似然損失。其計算公式如下

$$NLLoss(Y,\hat{Z})=?\frac{1}{N}\sum _{i=0}^{N?1}{z}_i[y_i]$$

公式中的方括號和Python中的索引的用法一致，表示取$\widehat{z_i}$ 的第$y_i$個元素。

注意的是這里的$\hat{Z}$實際上不是概率值，而是概率值取了對數，所以，和LogLoss一對比，很容易發現，LogSoftmax+NLLLoss 等價于 Softmax+LogLoss,等價于 Softmax+CrossEntropyLoss。為了數值精度考慮，pytorch中的nn.CrossEntropyLoss要求輸入未經過Softmax激活，所以有 nn.LogSoftmax+nn.NLLLoss 等價于 nn.CrossEntropyLoss.

5，KL散度的計算公式是什么？有什么現實含義？和交叉熵有什么關系？

KL散度也叫相對熵，可以衡量兩個概率分布之間的差異。

KL散度的計算公式是交叉熵減去信息熵。注意KL散度是不對稱的, 即$KL(P,Q)\ne KL(Q,P)$, 所以不能夠叫做KL距離。

兩個隨機變量P和Q之間的KL散度定義如下：
$$KL(P,Q)=\sum _{k=0}^{K?1}{p}_{k}ln(\frac{p_k}{q_k})=\sum _{k=0}^{K?1}{p}_k(ln{p}_k?ln{q}_k)$$

對二分類情況下，有：

$$KL(Y,\hat{Y})=?\frac{1}{N}\sum _{i=0}^{N?1}(y_{i}log\widehat{y_i}+(1?y_i)log(1?\widehat{y_i}))+\frac{1}{N}\sum _{i=0}^{N?1}(y_{i}log{y}_i+(1?y_i)log(1?y_i))$$

在$y_i$取0或1的情況下，信息熵部分為0，所以KL散度就等于交叉熵，但是在一些情況下，例如使用標簽平滑處理技術后，$y_i$的取值不是0或1，這時候，KL散度相當于在交叉熵的基礎上減去了一個常數，KL散度作為損失函數去優化模型的效果和交叉熵是完全一樣的，但是在這種情況下當模型完美擬合標簽的情況下KL散度的最小值可取到0，而此時交叉熵能夠取到的最小值是信息熵不為0，所以這種情況下使用KL散度更符合我們對Loss的一般認識。

import numpy as np
import pandas as pd
import torch 
from torch import nn 
import torch.nn.functional as F # nn.BCELoss() 和 nn.BCEWithLogitsLoss() 關系y_pred = torch.tensor([5.0,3,10,-5,-3,-10.0])
y_true = torch.tensor([1.0,1,1,0,0,0])bce = nn.BCELoss()(torch.sigmoid(y_pred),y_true)
print(bce)bce_logits = nn.BCEWithLogitsLoss()(y_pred,y_true)
print(bce_logits)

tensor(0.0184)
tensor(0.0184)

# nn.CrossEntropyLoss() 和  nn.NLLLoss() 關系y_pred = torch.tensor([[10.0,0.0,-10.0],[8.0,8.0,8.0]])
y_true = torch.tensor([0,2])# 直接調用交叉熵損失
ce = nn.CrossEntropyLoss()(y_pred,y_true)
print(ce)# 等價于先計算nn.LogSoftmax激活，再調用nn.NLLLoss
y_pred_logsoftmax = nn.LogSoftmax(dim = 1)(y_pred)
nll = nn.NLLLoss()(y_pred_logsoftmax,y_true)
print(nll)

tensor(0.5493)
tensor(0.5493)

# nn.CrossEntropyLoss() 和  KLDivLoss 關系
import torch.nn.functional as F y_pred = torch.tensor([[10.0,0.0,-10.0],[8.0,8.0,8.0]],requires_grad=True)
y_true = torch.tensor([0,2])ce = nn.CrossEntropyLoss(reduction="mean")(y_pred,y_true)
print(ce)#KLDivLoss要求target為向量形式編碼且preds經過LogSoftmax激活
pred = F.log_softmax(y_pred,dim=1)
target = F.one_hot(y_true).float()
kl = nn.KLDivLoss(reduction="batchmean")(pred,target)
print(kl)

tensor(0.5493, grad_fn=<NllLossBackward0>)
tensor(0.5493, grad_fn=<DivBackward0>)

二，自定義損失函數

自定義損失函數接收兩個張量y_pred,y_true作為輸入參數，并輸出一個標量作為損失函數值。

也可以對nn.Module進行子類化，重寫forward方法實現損失的計算邏輯，從而得到損失函數的類的實現。

下面演示兩個比較著名的范例。

1，自定義損失函數之FocalLoss范例

下面是一個Focal Loss的自定義實現示范。Focal Loss是一種對binary_crossentropy的改進損失函數形式。

它在樣本不均衡和存在較多易分類的樣本時相比binary_crossentropy具有明顯的優勢。

它有兩個可調參數，alpha參數和gamma參數。其中alpha參數主要用于衰減負樣本的權重，gamma參數主要用于衰減容易訓練樣本的權重。

從而讓模型更加聚焦在正樣本和困難樣本上。這就是為什么這個損失函數叫做Focal Loss。

詳見《5分鐘理解Focal Loss與GHM——解決樣本不平衡利器》

https://zhuanlan.zhihu.com/p/80594704

$$focal\_loss(y,p)=\{\begin{array}{ll}?\alpha (1?p{)}^{\gamma }\log (p)& \text{if?y?=?1}\\ ?(1?\alpha )p^{\gamma }\log (1?p)& \text{if?y?=?0}\end{array}$$

import torch 
from torch import nn 
class FocalLoss(nn.Module):def __init__(self,gamma=2.0,alpha=0.75):super().__init__()self.gamma = gammaself.alpha = alphadef forward(self,y_pred,y_true):bce = torch.nn.BCELoss(reduction = "none")(y_pred,y_true)p_t = (y_true * y_pred) + ((1 - y_true) * (1 - y_pred))alpha_factor = y_true * self.alpha + (1 - y_true) * (1 - self.alpha)modulating_factor = torch.pow(1.0 - p_t, self.gamma)loss = torch.mean(alpha_factor * modulating_factor * bce)return loss

#困難樣本
y_pred_hard = torch.tensor([[0.5],[0.5]])
y_true_hard = torch.tensor([[1.0],[0.0]])#容易樣本
y_pred_easy = torch.tensor([[0.9],[0.1]])
y_true_easy = torch.tensor([[1.0],[0.0]])focal_loss = FocalLoss()
bce_loss = nn.BCELoss()print("focal_loss(easy samples):", focal_loss(y_pred_easy,y_true_easy))
print("bce_loss(easy samples):", bce_loss(y_pred_easy,y_true_easy))print("focal_loss(hard samples):", focal_loss(y_pred_hard,y_true_hard))
print("bce_loss(hard samples):", bce_loss(y_pred_hard,y_true_hard))#可見 focal_loss讓容易樣本的權重衰減到原來的 0.0005/0.1054 = 0.00474
#而讓困難樣本的權重只衰減到原來的 0.0866/0.6931=0.12496# 因此相對而言，focal_loss可以衰減容易樣本的權重。

focal_loss(easy samples): tensor(0.0005)
bce_loss(easy samples): tensor(0.1054)
focal_loss(hard samples): tensor(0.0866)
bce_loss(hard samples): tensor(0.6931)

FocalLoss的使用完整范例可以參考下面中自定義L1和L2正則化項中的范例，該范例既演示了自定義正則化項的方法，也演示了FocalLoss的使用方法。

2，SCELoss

Symmetric Cross Entropy Loss 也是一種對交叉熵損失的改進損失，主要用在標簽中存在明顯噪聲的場景。

$$\begin{gathered} sce\_loss(y,p)=\alpha ce\_loss(y,p)+\beta rce\_loss(y,p) \\ ce\_loss(y,p)=?ylog(p)?(1?y)log(1?p) \\ rce\_loss(y,p)=ce\_loss(p,y) \\ rce\_loss(y,p)=?plog(y)?(1?p)log(1?y) \end{gathered}$$

其基本思想可以簡單描述如下：

當 y是正常標簽的時候，y和p較容易取得一致【例如 y=1時，p取到0.8】，這時候 rce與ce的比值相對較大，引入rce可以增加正常標簽樣本在總Loss中的貢獻。

當y時噪聲標簽的時候，y和p很難取得一致，相當于困難樣本 【例如 y=0時，p取到0.8】，這時候rce與ce的比值相對較小，引入rce可以減小噪聲標簽樣本在總Loss中的貢獻。

參考文章

《SCE 損失》 https://zhuanlan.zhihu.com/p/420827592

《噪聲損失 》https://zhuanlan.zhihu.com/p/420913134

def ce(y,p):p = torch.clamp(p,min=1e-4,max=1-1e-4)y = torch.clamp(y,min=1e-4,max=1-1e-4)return -y*torch.log(p) - (1-y)*torch.log(1-p)def rce(y,p):return ce(p,y)#正常標簽
y = torch.tensor(1.0)
p = torch.tensor(0.8)
print(rce(y,p)/ce(y,p))#噪聲標簽
y = torch.tensor(0.0)
p = torch.tensor(0.8)
print(rce(y,p)/ce(y,p))

tensor(8.2502)
tensor(4.5786)

import torch 
from torch import nn
import  torch.nn.functional as F class SCELoss(nn.Module):def __init__(self, num_classes=10, a=1, b=1):super(SCELoss, self).__init__()self.num_classes = num_classesself.a = a #兩個超參數self.b = bself.cross_entropy = nn.CrossEntropyLoss()def forward(self, pred, labels):# CE 部分，正常的交叉熵損失ce = self.cross_entropy(pred, labels)# RCEpred = F.softmax(pred, dim=1)pred = torch.clamp(pred, min=1e-4, max=1.0)label_one_hot = F.one_hot(labels, self.num_classes).float().to(pred.device)label_one_hot = torch.clamp(label_one_hot, min=1e-4, max=1.0) #最小設為 1e-4，即 A 取 -4rce = (-1 * torch.sum(pred * torch.log(label_one_hot), dim=1))loss = self.a * ce + self.b * rce.mean()return loss

## 三，L1和L2正則化項L1正則、L2正則、Dropout、Early_stopping是神經網絡常用的正則化方法。1，L1正則和L2正則的效果有什么差異?為什么？通常認為L1 正則化可以產生稀疏權值矩陣，即產生一個參數稀疏的模型。而L2 正則化可以讓模型的參數取絕對值較小的數。考慮兩種正則化函數的等值面與原始Loss函數的等值面的關系。以二維情況為例，L1正則化函數的等值面是個菱形，L2正則化函數的等值面是個圓形。最優參數必定取在正則化函數的某條等值面和原始Loss函數的某條等值面的切點處。從求導角度考慮，最優參數是個極值點，要求該處 正則化函數的梯度等于 原始Loss函數的梯度的負數。而梯度方向必定垂直于等值面的切線方向，所以可以推斷必定極值點必定在正則化函數某條等值面和原始Loss函數的某條等值面的切點處。從數值角度考慮，如果該極值點不在兩個等值面的切點，那么沿著原始函數Loss的等值面(原始Loss不變)，一定可以找到一個點正則化函數取值更小。這樣就用反證法證明了最優參數必定取在正則化函數的某條等值面和原始Loss函數的某條等值面的切點處。由于L1正則化函數的等值面是個菱形，更容易和凸的Loss函數的等值面相切在坐標軸上，所以傾向于取得參數稀疏的模型，而L2正則化則更傾向于使得極小點到坐標原點的距離更近，但不會導致參數稀疏。![](https://tva1.sinaimg.cn/large/e6c9d24egy1h5q2vhkvz9j20pa0ctjsg.jpg)參考文章《L1正則化與L2正則化》：https://zhuanlan.zhihu.com/p/35356992 ```python
import torch 
# L2正則化
def L2Loss(model,alpha):l2_loss = torch.tensor(0.0, requires_grad=True)for name, param in model.named_parameters():if 'bias' not in name: #一般不對偏置項使用正則l2_loss = l2_loss + (0.5 * alpha * torch.sum(torch.pow(param, 2)))return l2_loss# L1正則化
def L1Loss(model,beta):l1_loss = torch.tensor(0.0, requires_grad=True)for name, param in model.named_parameters():if 'bias' not in name:l1_loss = l1_loss +  beta * torch.sum(torch.abs(param))return l1_loss

四，L1L2正則項使用完整范例

下面以一個二分類問題為例，演示給模型的目標函數添加自定義L1和L2正則化項的方法。

這個范例同時演示了以下FocalLoss的使用。

1，準備數據

import numpy as np 
import pandas as pd 
from matplotlib import pyplot as plt
import torch
from torch import nn
import torch.nn.functional as F
from torch.utils.data import Dataset,DataLoader,TensorDataset
import torchkeras 
%matplotlib inline
%config InlineBackend.figure_format = 'svg'#正負樣本數量
n_positive,n_negative = 1000,6000#生成正樣本, 小圓環分布
r_p = 5.0 + torch.normal(0.0,1.0,size = [n_positive,1]) 
theta_p = 2*np.pi*torch.rand([n_positive,1])
Xp = torch.cat([r_p*torch.cos(theta_p),r_p*torch.sin(theta_p)],axis = 1)
Yp = torch.ones_like(r_p)#生成負樣本, 大圓環分布
r_n = 8.0 + torch.normal(0.0,1.0,size = [n_negative,1]) 
theta_n = 2*np.pi*torch.rand([n_negative,1])
Xn = torch.cat([r_n*torch.cos(theta_n),r_n*torch.sin(theta_n)],axis = 1)
Yn = torch.zeros_like(r_n)#匯總樣本
X = torch.cat([Xp,Xn],axis = 0)
Y = torch.cat([Yp,Yn],axis = 0)#可視化
plt.figure(figsize = (6,6))
plt.scatter(Xp[:,0],Xp[:,1],c = "r")
plt.scatter(Xn[:,0],Xn[:,1],c = "g")
plt.legend(["positive","negative"]);

ds = TensorDataset(X,Y)ds_train,ds_val = torch.utils.data.random_split(ds,[int(len(ds)*0.7),len(ds)-int(len(ds)*0.7)])
dl_train = DataLoader(ds_train,batch_size = 100,shuffle=True,num_workers=2)
dl_val = DataLoader(ds_val,batch_size = 100,num_workers=2)features,labels = next(iter(dl_train))

2，定義模型

class Net(nn.Module):def __init__(self):super().__init__()self.fc1 = nn.Linear(2,4)self.fc2 = nn.Linear(4,8) self.fc3 = nn.Linear(8,1)def forward(self,x):x = F.relu(self.fc1(x))x = F.relu(self.fc2(x))y = self.fc3(x)return ynet = Net() from torchkeras import summarysummary(net,features);

--------------------------------------------------------------------------
Layer (type)                            Output Shape              Param #
==========================================================================
Linear-1                                     [-1, 4]                   12
Linear-2                                     [-1, 8]                   40
Linear-3                                     [-1, 1]                    9
==========================================================================
Total params: 61
Trainable params: 61
Non-trainable params: 0
--------------------------------------------------------------------------
Input size (MB): 0.000069
Forward/backward pass size (MB): 0.000099
Params size (MB): 0.000233
Estimated Total Size (MB): 0.000401
--------------------------------------------------------------------------

3，訓練模型

# L2正則化
def L2Loss(model,alpha):l2_loss = torch.tensor(0.0, requires_grad=True)for name, param in model.named_parameters():if 'bias' not in name: #一般不對偏置項使用正則l2_loss = l2_loss + (0.5 * alpha * torch.sum(torch.pow(param, 2)))return l2_loss# L1正則化
def L1Loss(model,beta):l1_loss = torch.tensor(0.0, requires_grad=True)for name, param in model.named_parameters():if 'bias' not in name:l1_loss = l1_loss +  beta * torch.sum(torch.abs(param))return l1_loss

from torchkeras import KerasModel
from torchkeras.metrics import AUCnet = Net()# 將L2正則和L1正則添加到FocalLoss損失，一起作為目標函數
def focal_loss_with_regularization(y_pred,y_true):y_probs = torch.sigmoid(y_pred)focal = FocalLoss()(y_probs,y_true) l2_loss = L2Loss(net,0.001) #注意設置正則化項系數l1_loss = L1Loss(net,0.001)total_loss = focal + l2_loss + l1_lossreturn total_lossoptimizer = torch.optim.Adam(net.parameters(),lr = 0.002)
model = KerasModel(net=net,loss_fn = focal_loss_with_regularization ,metrics_dict = {"auc":AUC()},optimizer= optimizer )dfhistory = model.fit(train_data=dl_train,val_data=dl_val,epochs=20,ckpt_path='checkpoint',patience=3,monitor='val_auc',mode='max',plot=True,cpu=True)

[0;31m<<<<<< 🐌 cpu is used >>>>>>[0m

# 結果可視化
fig, (ax1,ax2) = plt.subplots(nrows=1,ncols=2,figsize = (12,5))
ax1.scatter(Xp[:,0],Xp[:,1], c="r")
ax1.scatter(Xn[:,0],Xn[:,1],c = "g")
ax1.legend(["positive","negative"]);
ax1.set_title("y_true");Xp_pred = X[torch.squeeze(torch.sigmoid(net.forward(X))>=0.5)]
Xn_pred = X[torch.squeeze(torch.sigmoid(net.forward(X))<0.5)]ax2.scatter(Xp_pred[:,0],Xp_pred[:,1],c = "r")
ax2.scatter(Xn_pred[:,0],Xn_pred[:,1],c = "g")
ax2.legend(["positive","negative"]);
ax2.set_title("y_pred");

五，通過優化器實現L2正則化

如果僅僅需要使用L2正則化，那么也可以利用優化器的weight_decay參數來實現。

weight_decay參數可以設置參數在訓練過程中的衰減，這和L2正則化的作用效果等價。

before L2 regularization:gradient descent: w = w - lr * dloss_dw after L2 regularization:gradient descent: w = w - lr * (dloss_dw+beta*w) = (1-lr*beta)*w - lr*dloss_dwso （1-lr*beta）is the weight decay ratio.

Pytorch的優化器支持一種稱之為Per-parameter options的操作，就是對每一個參數進行特定的學習率，權重衰減率指定，以滿足更為細致的要求。

weight_params = [param for name, param in model.named_parameters() if "bias" not in name]
bias_params = [param for name, param in model.named_parameters() if "bias" in name]optimizer = torch.optim.SGD([{'params': weight_params, 'weight_decay':1e-5},{'params': bias_params, 'weight_decay':0}],lr=1e-2, momentum=0.9)