幫助文檔

時間 2020-05-09

標籤幫助文檔简体版

原文原文鏈接

VisualPytorch發佈域名+雙服務器以下：
http://nag.visualpytorch.top/static/ (對應114.115.148.27)
http://visualpytorch.top/static/ (對應39.97.209.22)html

1、快速入門

1. 界面介紹

首先打開網址，進入網站的首頁。網站有遊客遊覽模式和用戶登陸模式，建議先註冊登陸一個帳號，也是十分簡便的啦，由於這樣可使用更多的功能。python

頁面頭部有三個選項，分別爲VisualPytorch, 幫助和聯繫咱們，VisualPytorch就是主頁面，能夠進行模型的搭建，幫助頁面是本網站的簡單教程以及相關知識的講解，在聯繫咱們界面，能夠給咱們反饋你在使用過程當中的遇到的問題，幫助咱們進步呀。git

2. 組件框

在VisualPytorch界面左側有可選擇的網絡層，這些層就是用來搭建神經網絡模型的基本組件，在網絡層的下面還有訓練參數配置，主要用於肯定模型的全局訓練參數。下面給你們簡單展現一下如何拖拽和刪除這些組件框，以及組件框參數的位置。github

3. 生成和下載代碼

在VisualPytorch界面左上角有生成代碼按鈕，當你搭建好本身的神經網絡模型以後，就能夠點擊這個按鈕，而後會跳轉到代碼頁面，你也就能夠看到生成的代碼啦，而後再點擊下載代碼，就能夠把代碼下載到本地，暢快的玩耍一番啦。算法

4. 保存模型

考慮到也許後續還要用本身搭建過的模型，因此咱們實現了保存模型這一功能（貼心的團隊，有木有），當你搭建好一個模型以後，能夠直接選擇保存，而後模型就會保存到你的帳號啦，下次你登陸還能夠查看本身以前的模型。json

2、使用說明

1. 概述

咱們的網站旨在利用清晰的可視化模型來幫助熱愛deep learning的你快速搭建想搭建的模型。canvas

目前支持的神經網絡層有：reshape層，全鏈接層，一維卷積層，二維卷積層；這些層及其涉及的參數的具體含義都與pytorch官方文檔裏一致。數組

2. 搭建模型

模型的搭建經過將左側的各種層模塊拖入右側畫布並連線來完成。服務器

首先要將左側的開始按鈕拖到右側畫布開始模型的搭建，而後一次將你想加入的層模塊拖入到右側畫布中，以後點擊模塊四周的黑點並拖動至其餘模塊的黑點位置便可完成層模塊的鏈接，支持層模塊的並聯。
在各個層模塊中，其中一些層須要填入相應參數，須要參數的層模塊在點擊以後會彈出該層須要的具體參數，填寫以後點擊確認便可保存該層參數。參數均有輸入限制，若存在不合規範的參數輸入在點擊確認時會顯示錯誤提示，詳細的參數要求及層的功能介紹會在下文中介紹。
在確認已經完成模型的搭建並填寫完畢相應參數以後，能夠點擊生成代碼按鈕轉到生成模型代碼頁面，若模型搭建中出現錯誤則沒法正常生成代碼並彈出錯誤提示。同時在完成模型搭建以後，點擊保存按鈕能夠將搭建的模型保存在用戶的帳戶中，須要注意的是，只有註冊用戶擁有權限保存本身搭建的模型，遊客不具備保存模型的權限。

3. 生成的代碼介紹

main.py裏的代碼主要是涉及全局的參數以及訓練部分，目前該部分還有待完善。網絡

model.py裏則主要是搭建的模型代碼，整個模型咱們封裝成了一個類，類名是 NET。

4. 模型管理

註冊用戶擁有保存本身搭建的模型並管理的權限，用戶能夠經過點擊頁面上顯示的用戶名，彈出模型查看和登出選項，點擊模型查看便可進入模型管理的頁面，該頁面會顯示用戶曾搭建並保存的全部模型，每一個模型都有對應的查看和刪除按鈕。點擊查看便可進入模型搭建的頁面並恢復用戶曾保存的模型，用戶能夠對該模型進行從新編輯。點擊刪除便可刪除相應的模型。

5. 相關的注意事項

搭建神經網絡模塊須要有顯示的開始於結束節點。
reshape層裏若是有多個維度的話，不一樣維度之間須要以英文的逗號分開。

3、經典模型

1. VGG_16_layers

VGG卷積神經網絡是牛津大學在2014年提出來的模型，它在圖像分類和目標檢測任務中都表現出很是好的結果。同時，VGG16模型的權重由ImageNet訓練而來。

點擊在VisualPytorch中查看

2. AlexNet

AlexNet是2012年ImageNet項目的大規模視覺識別挑戰中的勝出者，該項目一種巧妙的手法打破了舊觀念，開創了計算機視覺的新局面。

點擊在VisualPytorch中查看

3. Network in Network(NIN)

一種新型的深度網絡結構，它能夠加強模型在感覺野內對局部區域的辨別能力。

點擊在VisualPytorch中查看

4、網絡層及參數

1. 簡單網絡層

reshape層

返回一個有相同數據但大小不一樣的tenser。返回的tenser必須有與原tenser相同的數據和相同數目的元素，但能夠有不一樣的大小。一個tenser必須是連續的contiguous()才能被查看。

簡單來看，view的參數就比如一個矩陣的行和列的值，當爲一個數n的時候，則將數據大小變爲1xn。

參數：

shape <非負整數及-1序列，包括全部非負整數和-1(只有-1是例外),同維度數字之間以英文的「,」分開，例如1,2,3,4,5> 無默認值

全鏈接層(linear_layer)

class torch.nn.Linear(in_features, out_features, bias=True)

對輸入數據作線性變換：y*=*Ax+b

參數：

in_features<正整數> - 輸入通道數 無默認值
out_features<正整數> - 輸入通道數 無默認值

形狀：

輸入: （N, in_features)
輸出： (N, out_features)

變量：

weight -形狀爲(out_features x in_features)的模塊中可學習的權值
bias -形狀爲(out_features)的模塊中可學習的偏置

例子：

>>> m = nn.Linear(20, 30)
>>> input = autograd.Variable(torch.randn(128, 20))
>>> output = m(input)
>>> print(output.size())

元素級相加層(element_wise_add_layer)

該層不須要參數，做爲幾個層之間的銜接，須要注意的是，該函數的輸入能夠爲多個向量。

channel維度拼接層(concatenate_layer)

torch.cat(inputs, dimension=0) → Tensor

在給定維度上對輸入的張量序列seq 進行鏈接操做。

torch.cat()能夠看作 torch.split() 和 torch.chunk()的反操做。 cat() 函數能夠經過下面例子更好的理解。

參數:

dim<非負整數> - 拼接維度 默認值爲0

例子：

>>> x = torch.randn(2, 3)
>>> x

 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
[torch.FloatTensor of size 2x3]

>>> torch.cat((x, x, x), 0)

 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
[torch.FloatTensor of size 6x3]

>>> torch.cat((x, x, x), 1)

 0.5983 -0.0341  2.4918  0.5983 -0.0341  2.4918  0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735  1.5981 -0.5265 -0.8735  1.5981 -0.5265 -0.8735
[torch.FloatTensor of size 2x9]

softmax層(softmax_layer)

class torch.nn.Softmax(dim=None)

將Softmax函數應用於n維輸入Tensor，對它們進行從新縮放，使得n維輸出Tensor的元素位於[0,1]範圍內而且總和爲1。

函數表達式：

Softmax(xi)=exi∑jexjSoftmax(xi)=exi∑jexj

返回：

一個和輸入相同尺寸和形狀的張量，其值在[0,1]範圍內

參數：

dim<正整數> - 計算維度 無默認值

例子:

>>> m = nn.Softmax()
>>> input = torch.randn(2, 3)
>>> output = m(input)

dropout層(dropout_layer)

torch.nn.Dropout(p=0.5, inplace=False)

在訓練期間，使用伯努利分佈的樣本以機率p將輸入張量的某些元素隨機置零。在每次前向傳播時，每一個通道將獨立清零。事實證實，這是一種有效的技術，可用於規範化和防止神經元的協同適應。

type<下拉框，包括1d/2d/3d> 默認值爲2d
p<0-1間實數>:置0機率 默認值爲0.5

例子:

a = torch.randn(10,1)
>>> tensor([[ 0.0684],
        [-0.2395],
        [ 0.0785],
        [-0.3815],
        [-0.6080],
        [-0.1690],
        [ 1.0285],
        [ 1.1213],
        [ 0.5261],
        [ 1.1664]])
torch.nn.Dropout(0.5)(a)
>>> tensor([[ 0.0000],  
        [-0.0000],  
        [ 0.0000],  
        [-0.7631],  
        [-0.0000],  
        [-0.0000],  
        [ 0.0000],  
        [ 0.0000],  
        [ 1.0521],  
        [ 2.3328]])

2. 卷積層(conv_layer)

class torch.nn.Conv1d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)

卷積神經網絡中每層卷積層（Convolutional layer）由若干卷積單元組成，每一個卷積單元的參數都是經過反向傳播算法最佳化獲得的。卷積運算的目的是提取輸入的不一樣特徵，第一層卷積層可能只能提取一些低級的特徵如邊緣、線條和角等層級，更多層的網路能從低級特徵中迭代提取更復雜的特徵。

以一維卷積層爲例，輸入的尺度是(N, C_in,L)，輸出尺度（ N,C_out,L_out）的計算方式：

\[out(N i ,C out j )=bias(C out j )+ k=0 ∑ C in −1 weight(C out j ,k)⋆input(N i ,k) \]

layer_type<下拉框二選一，conv/conv_transpose> - 分別表示卷積與反捲積 默認值爲conv

conv和conv_transpose參數相同

type:下拉框三選一，選項包括1d/2d/3d 默認值爲2d
in_channels<正整數> - 輸入通道數 無默認值
out_channels<正整數> - 輸出通道數 無默認值
kernel_size <正整數> - 卷積核的尺寸 默認值爲3
stride<正整數> - 卷積步長 默認值爲1
dilation<正整數>– 卷積核元素之間的間距，詳細描述在這裏 默認值爲0
padding<非負整數> - 輸入的每一條邊補充0的層數 默認值爲0

形狀:

輸入: (N,Cin,Lin)(N,Cin,Lin)
輸出: (N,Cout,Lout)(N,Cout,Lout)
輸入輸出的計算方式： Lout=floor(Lin+2p−d∗(k−1)−1s+1)Lout=floor(Lin+2p−d∗(k−1)−1s+1)

變量:

weight(tensor) - 卷積的權重，大小是(out_channels, in_channels, kernel_size)
bias(tensor) - 卷積的偏置係數，大小是（out_channel）

例子:

>>> m = nn.Conv1d(16, 33, 3, stride=2)
>>> input = autograd.Variable(torch.randn(20, 16, 50))
>>> output = m(input)

3. 池化層(pool_layer)

在神經網絡中，池化函數(Pooling Function)通常將上一層卷積函數的結果做爲本身的輸入。通過卷積層提取過特徵以後，咱們獲得的通道數可能會增大不少，也就是說數據的維度會變得更高，這個時候就須要對數據進行池化操做，也就是降維操做。

池化操做是用每一個矩陣的最大值或是平均值來表明這個矩陣，從而實現元素個數的減小，而且最大值和平均值操做可使得特徵提取具備「平移不變性」。

layer_type<下拉框三選一，選項包括max_pool, avg_pool, max_unpool > 默認值爲max_pool

max_pool

torch.nn.functional.max_pool1d(input, kernel_size, stride=None, padding=0, dilation=1, ceil_mode=False, return_indices=False)

對由幾個輸入平面組成的輸入信號進行最大池化。通常狀況下咱們只須要用到type, kernel_size, stride=None, padding=0這些參數。

參數:

type:下拉框三選一，選項包括1d/2d/3d 默認值爲2d
kernel_size <正整數> : 卷積核的尺寸 默認值爲2
stride <正整數> : 卷積步長默認值爲2
padding <非負整數> : 補充0的層數 默認值爲0

例子:

>>> # pool of square window of size=3, stride=2
>>> m = nn.MaxPool3d(3, stride=2)
>>> # pool of non-square window
>>> m = nn.MaxPool3d((3, 2, 2), stride=(2, 1, 2))
>>> input = torch.randn(20, 16, 50,44, 31)
>>> output = m(input)

avg_pool

torch.nn.functional.avg_pool1d(input, kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True)

對由幾個輸入平面組成的輸入信號進行平均池化。通常狀況下咱們只須要用到type, kernel_size, stride=None, padding=0這些參數。

參數:

type:下拉框三選一，選項包括1d/2d/3d 默認值爲2d
kernel_size<正整數> : 卷積核的尺寸 默認值爲2
stride<正整數> : 卷積步長 默認值爲2
padding <非負整數> : 補充0的層數 默認值爲0
ceil_mode:下拉框二選一，ceil/floor 默認值爲floor
count_include_pad(勾選框，默認爲勾選，在json中爲True,不然爲False)：平均計算中包括零填充 默認值爲true

例子:

>>> # pool of square window of size=3, stride=2
>>> input = Variable(torch.Tensor([[[1,2,3,4,5,6,7]]]))
>>> F.avg_pool1d(input, kernel_size=3, stride=2)
Variable containing:
(0 ,.,.) =
  2  4  6
[torch.FloatTensor of size 1x1x3]

max_unpool

torch.nn.MaxUnpool1d(kernel_size, stride=None, padding=0)

參數:

type(下拉框三選一，選項包括1d/2d/3d) : 卷積形式 默認值爲2d
kernel_size <正整數> : 卷積核的尺寸 默認值爲2
stride<正整數> : 卷積步長 默認值爲2
padding<非負整數> : 補充0的層數 默認值爲0

例子:

>>> pool = nn.MaxPool1d(2, stride=2, return_indices=True)
>>> unpool = nn.MaxUnpool1d(2, stride=2)
>>> input = torch.tensor([[[1., 2, 3, 4, 5, 6, 7, 8]]])
>>> output, indices = pool(input)
>>> unpool(output, indices)
tensor([[[ 0.,  2.,  0.,  4.,  0.,  6.,  0., 8.]]])

>>> # Example showcasing the use of output_size
>>> input = torch.tensor([[[1., 2, 3, 4, 5, 6, 7, 8, 9]]])
>>> output, indices = pool(input)
>>> unpool(output, indices, output_size=input.size())
tensor([[[ 0.,  2.,  0.,  4.,  0.,  6.,  0., 8.,  0.]]])

>>> unpool(output, indices)
tensor([[[ 0.,  2.,  0.,  4.,  0.,  6.,  0., 8.]]])

4. 激活層(activation_layer)

激活函數做用在人工神經網絡上，負責將神經元的輸入映射到輸出端。增長了神經網絡的非線性，使得神經網絡能夠任意逼近任意非線性函數，從而使神經網絡應用到衆多的非線性模型中。

layer_type<下拉框，包括relu/sigmoid/tanh/leaky relu/PRelu/RRelu> 默認值爲relu

relu

函數表達式：

\(relu(x)=max(0,x)\)

對應圖像：

leaky relu

函數表達式：

\(LeakyRelu(x)=max(x,0) + negative\_slope*min(0,x)\)

參數：

negative_slope<正數> - 控制負斜率的角度 **默認值爲0.01

對應圖像：

sigmoid

函數表達式：

\(sigmoid(x)=\frac{1}{1+e^{-x}}\)

函數圖像：

tanh

函數表達式：

\(tanh(x)=\frac{e^x-e^{-x}}{e^x+e^-x}\)

函數圖像：

PRelu

torch.nn.PReLU(num_parameters=1, init=0.25)

函數表達式:PReLU(x)=max(0,x)+a∗min(0,x)

函數圖像:

相似leaky relu, 可是負數部分斜率可學習

參數：

weight<正數> - 權重初始化 非0正實數 默認值爲0.25

RRelu

torch.nn.RReLU(lower=0.125, upper=0.3333333333333333, inplace=False)

函數表達式:

相似leaky relu, 可是負數部分斜率爲隨機均勻分佈

參數：

lower<正數> - 均勻分佈下限 默認值爲0.125
upper<正數> - 均勻分佈上限 默認值爲0.333

5. 遞歸神經網絡(RNN_layer)

torch.nn.RNN(*args, **kwargs)

RNN（Recurrent Neural Networks,循環神經網絡）不只會學習當前時刻的信息，也會依賴以前的序列信息。因爲其特殊的網絡模型結構解決了信息保存的問題。因此RNN對處理時間序列和語言文本序列問題有獨特的優點。遞歸神經網絡都具備一連串重複神經網絡模塊的形式。在標準的RNNs中，這種重複模塊有一種很是簡單的結構。

計算公式:

\[h t =tanh(W ih x t +b ih +W hh h (t−1) +b hh ) \]

具體參數含義:h_t是隱藏層在時間t時的狀態，x_t是時間t時的輸入,h_(t-1)是隱藏層在t-1時的狀態。若是非線性激活函數爲relu，那麼tanh將用ReLU代替。

參數：

input_size<正整數> - 輸入特徵數 無默認值
hidden_size<正整數> - 隱藏層個數 無默認值
num_layers<正整數> - 遞歸層層數 默認值爲1
nonlinearity<二選一,tanh/relu> - 非線性激活 默認爲tanh

6. 長週期神經網絡(LSTM_layer)

torch.nn.LSTM(*args, **kwargs)

Long Short Term Memory networks（如下簡稱LSTMs），一種特殊的RNN網絡，該網絡設計出來是爲了解決長依賴問題。該網絡由 [Hochreiter & Schmidhuber (1997)引入，並有許多人對其進行了改進和普及。他們的工做被用來解決了各類各樣的問題，直到目前還被普遍應用。

LSTM的計算公式較爲複雜，下圖截取了pytorch官方文檔中的部份內容:

參數：

input_size<正整數> - 輸入特徵數 無默認值
hidden_size<正整數> - 隱藏層個數 無默認值
num_layers<正整數> - 遞歸層層數 默認值爲1

7. 標準化層(norm_layer)

layer_type<下拉框,選項包括batch_norm/group_norm/instance_norm> 默認值爲batch_norm

咱們在對數據訓練以前會對數據集進行歸一化，歸一化的目的歸一化的目的就是使得預處理的數據被限定在必定的範圍內（好比[0,1]或者[-1,1]），從而消除奇異樣本數據致使的不良影響，同時便於加快訓練速度。

batch_norm

torch.nn.BatchNorm1d(num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)

計算公式:

\[y= Var[x]+ϵ x−E[x] ∗γ+β \]

參數:

type<下拉框，包括1d/2d/3d> 默認值爲2d
num_features<正整數>:輸入特徵數 無默認值

例子:

>>> m = nn.BatchNorm1d(100)
>>> # Without Learnable Parameters
>>> m = nn.BatchNorm1d(100, affine=False)
>>> input = torch.randn(20, 100)
>>> output = m(input)

group_norm

torch.nn.GroupNorm(num_groups, num_channels, eps=1e-05, affine=True)

計算公式:

\[y= Var[x]+ϵ x−E[x] ∗γ+β \]

參數:

num_groups<正整數> - input_channel分組數 無默認值
num_channel<正整數> - input_channel個數無默認值

例子:

>>> # Separate 6 channels into 3 groups
>>> m = nn.GroupNorm(3, 6)
>>> # Separate 6 channels into 6 groups (equivalent with InstanceNorm)
>>> m = nn.GroupNorm(6, 6)
>>> # Put all 6 channels into a single group (equivalent with LayerNorm)
>>> m = nn.GroupNorm(1, 6)
>>> # Activating the module
>>> output = m(input)

instance_norm

torch.nn.InstanceNorm1d(num_features, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)

計算公式:

\[y= Var[x]+ϵ x−E[x] ∗γ+β \]

參數:

type<下拉框，包括1d/2d/3d> 默認值爲2d
num_features<正整數> - 輸入特徵數 無默認值

例子:

>>> # Without Learnable Parameters
>>> m = nn.InstanceNorm1d(100)
>>> # With Learnable Parameters
>>> m = nn.InstanceNorm1d(100, affine=True)
>>> input = torch.randn(20, 100, 40)
>>> output = m(input)

1. 簡單參數

epoch<正整數> - 全數據集訓練次數 默認值爲10

當一個完整的數據集經過了神經網絡一次而且返回了一次，這個過程稱爲一次>epoch。（也就是說，全部訓練樣本在神經網絡中都進行了一次正向傳播 和一次反向傳播 ）
再通俗一點，一個Epoch就是將全部訓練樣本訓練一次的過程。

learning_rate<0-1內實數> - 學習率 默認值爲0.01

學習率(Learning rate)做爲監督學習以及深度學習中重要的超參，其決定着目標函數可否收斂到局部最小值以及什麼時候收斂到最小值。合適的學習率可以使目標函數在合適的時間內收斂到局部最小值。

batch_size<正整數> - 每次訓練個數 默認值爲1

當一個Epoch的樣本（也就是全部的訓練樣本）數量可能太過龐大（對於計算機而言），就須要把它分紅多個小塊，也就是就是分紅多個Batch 來進行訓練。batch_size爲每批樣本的大小。

dataset<下拉框，共包含mnist,cifar10,stl10,svhn> - 訓練數據集 默認值爲mnist

mnist:該數據集包含60,000個用於訓練的示例和10,000個用於測試的示例。這些數字已通過尺寸標準化並位於圖像中心，圖像是固定大小(28x28像素)，其值爲0到1。爲簡單起見，每一個圖像都被平展並轉換爲784(28 * 28)個特徵的一維numpy數組。

下載連接:http://yann.lecun.com/exdb/mnist/

cifar10:該數據集共有60000張彩色圖像，這些圖像是32*32，分爲10個類，每類6000張圖。這裏面有50000張用於訓練，構成了5個訓練批，每一批10000張圖；另外10000用於測試，單獨構成一批。測試批的數據裏，取自10類中的每一類，每一類隨機取1000張。抽剩下的就隨機排列組成了訓練批。注意一個訓練批中的各種圖像並不必定數量相同，總的來看訓練批，每一類都有5000張圖。

下載連接:http://www.cs.toronto.edu/~kriz/cifar-10-binary.tar.gz

stl10:STL-10 是一個圖像數據集，包含 10 類物體的圖片，每類 1300 張圖片，500 張訓練，800 張測試，每張圖片分辨率爲 96x96。除了具備類別標籤的圖片以外，還有 100000 張無類別信息的圖片。

下載連接:https://cs.stanford.edu/~acoates/stl10/

svhn:SVHN（Street View House Number）Dateset 來源於谷歌街景門牌號碼，原生的數據集1也就是官網的 Format 1 是一些原始的未經處理的彩色圖片，以下圖所示（不含有藍色的邊框），下載的數據集含有 PNG 的圖像和 digitStruct.mat 的文件，其中包含了邊框的位置信息，這個數據集每張圖片上有好幾個數字，適用於 OCR 相關方向。
下載連接:http://ufldl.stanford.edu/housenumbers/

ifshuffle<勾選框，默認爲勾選，在json中爲True,不然爲False> - 是否打亂數據集 默認爲true

platform<下拉框，共包含CPU,GPU> - 運行平臺 默認CPU

2. 學習率降低(learning_rate_scheduler)

下拉框，共包括StepLR, MultiStepLR, ExponentialLR, CosineAnnealingLR,ReduceLROnPleateau,None 默認值爲None

pytorch提供了幾種根據epoch調整學習率的方法。

使用方法:learning_rate_scheduler應在優化器方向傳播後進行應用，以下例所示:

>>> scheduler = ...
>>> for epoch in range(100):
>>>     train(...)
>>>     validate(...)
>>>     scheduler.step()

stepLR

在每一個step_size時期，經過gamma下降每一個參數組的學習率。這種衰減可能與此調度程序外部的學習速率的其餘更改同時發生。當last_epoch = -1時，將初始lr設置爲lr。

step_size<正整數> - 衰減週期 默認值爲50
gamma<0-1內實數> - 衰減幅度 默認值0.1

例子:

>>> # Assuming optimizer uses lr = 0.05 for all groups
>>> # lr = 0.05     if epoch < 30
>>> # lr = 0.005    if 30 <= epoch < 60
>>> # lr = 0.0005   if 60 <= epoch < 90
>>> # ...
>>> scheduler = StepLR(optimizer, step_size=30, gamma=0.1)
>>> for epoch in range(100):
>>>     train(...)
>>>     validate(...)
>>>     scheduler.step()

MultiStepLR

當epoch到達milestone後，經過gamma衰減每一個參數組的學習率。這種衰減可能與此調度程序外部的學習速率的其餘更改同時發生。當last_epoch = -1時，將初始lr設置爲lr。

milestones<非負整數序列,同維度數字之間以英文的「,」分開，例如1,2,3,4,5> - 衰減時間點 默認值爲50
gamma<0-1內實數> - 衰減幅度 默認值0.1

例子:

>>> # Assuming optimizer uses lr = 0.05 for all groups
>>> # lr = 0.05     if epoch < 30
>>> # lr = 0.005    if 30 <= epoch < 80
>>> # lr = 0.0005   if epoch >= 80
>>> scheduler = MultiStepLR(optimizer, milestones=[30,80], gamma=0.1)
>>> for epoch in range(100):
>>>     train(...)
>>>     validate(...)
>>>     scheduler.step()

ExponentialLR

在每一個epoch以gamma衰減每一個參數組的學習率。當last_epoch = -1時，將初始lr設置爲lr。

gamma<0-1內實數> - 衰減幅度 默認值爲0.95

CosineAnnealingLR

此函數較爲複雜，下圖爲pytorch文檔中對其計算方法的相關說明：

T_max<正整數> - 降低週期（變化的半週期）默認值爲50
eta_min<正數> - 最小學習率 默認值爲0

ReduceLROnPleateau

當指標中止改善時，下降學習率。一旦學習停滯，模型一般會受益於將學習率下降2-10倍。該調度程序讀取一個指標數量，若是在patience時期沒有看到改善，則學習速度會下降。

factor<0-1內實數> - 調整係數 默認值爲0.1
patience<正整數> -「耐心」，接受幾回不變化 默認值爲10
cooldown<正整數> - 「冷卻時間」，中止監控一段時間 默認值爲10
verbose<勾選框> - 打印日誌 默認勾選
min_lr<0-1內實數> - 學習率下限 默認值爲0.0001

例子:

>>> optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9)
>>> scheduler = ReduceLROnPlateau(optimizer, 'min')
>>> for epoch in range(10):
>>>     train(...)
>>>     val_loss = validate(...)
>>>     # Note that step should be called after validate()
>>>     scheduler.step(val_loss)

3. optimizer:優化器

下拉框，共包含SGD,RMSprop,Adam,Adamax,ASGD 默認值爲Adam

優化器是用來計算和更新影響模型訓練和輸出的網絡參數（w和b），從而最小化(或最大化)損失函數Loss。

優化器是求解最優解的過程，能夠變相理解爲求損失函數極值的問題，因變量爲Loss，自變量（優化變量）爲w和b，所以須要用到一階導數（梯度），極值處其方程梯度（一階導數）爲零。有些時候會對優化變量進行約束，包括等式約束和不等式約束，定義了優化變量的可行域，如L1正則化和L2正則化。

SGD

Stochastic Gradient Descent

實現隨機梯度降低（可選帶動量）。

momentum <0-1間實數> - 動量 默認值爲0
weight_decay <0-1間實數> - L2正則項係數 默認值爲0
dampening <正數> – 動量衰減 默認值爲0
nesterov (勾選框，默認爲勾選，在json中爲True,不然爲False) – 使用Nesterov梯度加速 默認值爲false

例子:

>>> optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9)
>>> optimizer.zero_grad()
>>> loss_fn(model(input), target).backward()
>>> optimizer.step()

ASGD

Averaged Stochastic Gradient Descent

實現平均隨機梯度降低。

lambd <0-1間實數> - 衰減項 默認值爲0.0001
alpha <0-1間實數> - eta更新冪 默認值爲0.75
t0 <正整數> – 開始平均的點 默認值爲1000000
weight_decay<0-1間實數> - L2正則項係數 默認值爲0

Adam

實現Adam算法進行梯度降低。

Adam算法介紹:https://arxiv.org/abs/1412.6980

beta1<0-1內實數> - 梯度移動平均值的係數 默認值爲0.9
beta2<0-1內實數> - 梯度平方移動平均值的係數 默認值爲0.999
eps <0-1內實數>- 分母穩定項 默認值爲0.00000001
weight_decay<0-1間實數> - L2正則項係數 默認值爲0
amsgrad(勾選框，默認爲勾選，在json中爲True,不然爲False) - 使用AMSGrad變體 默認值爲false

RMSprop

實現RMSprop 算法進行梯度降低。

RMSprop 算法介紹：https://arxiv.org/pdf/1308.0850v5.pdf

momentum<0-1間實數>- 動量 默認值爲0
alpha<0-1間實數> - 平滑常數 默認值爲0.99
eps<0-1內實數> - 分母穩定項 默認值爲0.00000001
centered (勾選框，默認爲勾選，在json中爲True,不然爲False)– 梯度經過方差歸一化 默認值爲flase
weight_decay<0-1間實數> - L2正則項係數 默認值爲0

Adammax

實現Adamax算法（基於無窮範數的Adam的變體）。

Adamax算法介紹：https://arxiv.org/abs/1412.6980

beta1<0-1內實數>- 梯度移動平均值的係數 默認值爲0.9
beta2<0-1內實數>- 梯度平方移動平均值的係數 默認值爲0.999
eps<0-1內實數>- 分母穩定項 默認值爲0.00000001
weight_decay<0-1間實數> - L2正則項係數 默認值爲0

4. loss_func:損失函數

下拉框，共包含MSELoss,CrossEntropyLoss,L1Loss,NLLLoss,BCELoss 默認值爲MSELoss

損失函數（loss function）是用來估量你模型的預測值f(x)與真實值Y的不一致程度，它是一個非負實值函數,一般使用L(Y, f(x))來表示，損失函數越小，模型的魯棒性就越好。

MSELoss

均方偏差

pytorch文檔中計算函數：

reduction (下拉框，共包含none,mean,sum)- 輸出的縮減 默認值爲mean

例子：

>>> loss = nn.MSELoss()
>>> input = torch.randn(3, 5, requires_grad=True)
>>> target = torch.randn(3, 5)
>>> output = loss(input, target)
>>> output.backward()

CrossEntropyLoss

交叉熵損失

pytorch文檔中計算函數：

weight (optional, <正數序列>)- 每一個分類損失的權重 默認值爲None
ignore_index (optional, <整數>)- 忽略的目標 默認值爲None
reduction (下拉框，共包含none,mean,sum)- 輸出的縮減 默認值爲mean

例子：

>>> loss = nn.CrossEntropyLoss()
>>> input = torch.randn(3, 5, requires_grad=True)
>>> target = torch.empty(3, dtype=torch.long).random_(5)
>>> output = loss(input, target)
>>> output.backward()

L1Loss

mean absolute error(MAE)

pytorch文檔中計算函數：

reduction (下拉框，共包含none,mean,sum)- 輸出的縮減 默認值爲mean

例子：

>>> loss = nn.L1Loss()
>>> input = torch.randn(3, 5, requires_grad=True)
>>> target = torch.randn(3, 5)
>>> output = loss(input, target)
>>> output.backward()

NLLLoss

negative log likelihood loss

pytorch文檔中計算函數：

weight (optional, <正數序列>)- 每一個分類損失的權重 默認值爲None
ignore_index (optional, <整數>)- 忽略的目標 默認值爲None
reduction (下拉框，共包含none,mean,sum)- 輸出的縮減 默認值爲mean

例子：

>>> m = nn.LogSoftmax(dim=1)
>>> loss = nn.NLLLoss()
>>> # input is of size N x C = 3 x 5
>>> input = torch.randn(3, 5, requires_grad=True)
>>> # each element in target has to have 0 <= value < C
>>> target = torch.tensor([1, 0, 4])
>>> output = loss(m(input), target)
>>> output.backward()
>>>
>>>
>>> # 2D loss example (used, for example, with image inputs)
>>> N, C = 5, 4
>>> loss = nn.NLLLoss()
>>> # input is of size N x C x height x width
>>> data = torch.randn(N, 16, 10, 10)
>>> conv = nn.Conv2d(16, C, (3, 3))
>>> m = nn.LogSoftmax(dim=1)
>>> # each element in target has to have 0 <= value < C
>>> target = torch.empty(N, 8, 8, dtype=torch.long).random_(0, C)
>>> output = loss(m(conv(data)), target)
>>> output.backward()

BCELoss

Binary Cross Entropy between the target and the output

pytorch文檔計算函數：

weight (optional, <正數序列>)- 每批損失的權重 默認值爲None
reduction (下拉框，共包含none,mean,sum)- 輸出的縮減 默認值爲mean

例子：

>>> m = nn.Sigmoid()
>>> loss = nn.BCELoss()
>>> input = torch.randn(3, requires_grad=True)
>>> target = torch.empty(3).random_(2)
>>> output = loss(m(input), target)
>>> output.backward()