pytorch中文文檔-torch.nn常用函數-待添加

 https://pytorch.org/docs/stable/nn.html

 

1）卷積層

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

二維卷積層, 輸入的尺度是(N, C_in,H,W)，輸出尺度（N,C_out,H_out,W_out）的計算方式： 

說明

• stride: 控制相關系數的計算步長 
• dilation: 用於控制內核點之間的距離；可見pytorch的函數中的dilation參數的作用
  
• groups: 控制輸入和輸出之間的連接：可見pytorch的函數中的group參數的作用

1. group=1，輸出是所有的輸入的卷積；
2. group=2，此時相當於有並排的兩個卷積層，每個卷積層計算輸入通道的一半，並且產生的輸出是輸出通道的一半，隨后將這兩個輸出連接起來得到結果；
   
3. group=in_channels,每一個輸入通道和它對應的卷積核進行卷積，該對應的卷積核大小為

• 參數kernel_size，stride,padding，dilation：

1. 也可以是一個int的數據，此時卷積height和width值相同;
2. 也可以是一個tuple數組，tuple的第一維度表示height的數值，tuple的第二維度表示width的數值，當是數組時，計算時height使用索引為0的值，width使用索引為1的值

 

Parameters：

• in_channels(int) – 輸入信號的通道
• out_channels(int) – 卷積產生的通道
• kerner_size(int or tuple) - 卷積核的尺寸
• stride(int or tuple, optional) - 卷積步長，默認為1
• padding(int or tuple, optional) - 輸入的每一條邊補充0的層數，默認為0
• dilation(int or tuple, optional) – 卷積核元素之間的間距,默認為1
• groups(int, optional) – 從輸入通道到輸出通道的阻塞連接數。默認為1
• bias(bool, optional) - 如果bias=True，添加可學習的偏置到輸出中

 

shape輸出的height和width的計算式子:

 

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

 

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

對由多個輸入平面組成的輸入圖像應用二維轉置卷積操作。

這個模塊可以看作是Conv2d相對於其輸入的梯度。它也被稱為微步卷積(fractionally-strided convolutions)或解卷積(deconvolutions,盡管它不是一個實際的解卷積操作)。

說明

stride: 控制相關系數的計算步長 
dilation: 用於控制內核點之間的距離
groups: 控制輸入和輸出之間的連接： 

• group=1，輸出是所有的輸入的卷積；
• group=2，此時相當於有並排的兩個卷積層，每個卷積層計算輸入通道的一半，並且產生的輸出是輸出通道的一半，隨后將這兩個輸出連接起來。 

參數kernel_size，stride，padding，dilation數據類型：

• 可以是一個int類型的數據，此時卷積height和width值相同;
• 也可以是一個tuple數組（包含來兩個int類型的數據），第一個int數據表示height的數值，第二個int類型的數據表示width的數值

注意
由於內核的大小，輸入的最后的一些列的數據可能會丟失。因為輸入和輸出不是完全的互相關。因此，用戶可以進行適當的填充（padding操作）。

padding參數有效地將 (kernel_size - 1)/2 數量的零添加到輸入大小。這樣設置這個參數是為了使Conv2d和ConvTranspose2d在初始化時具有相同的參數，而在輸入和輸出形狀方面互為倒數。然而，當stride > 1時，Conv2d將多個輸入形狀映射到相同的輸出形狀。output_padding通過在一邊有效地增加計算出的輸出形狀來解決這種模糊性。

注意，output_padding只用於查找輸出形狀，但實際上並不向輸出添加零填充。

output_padding的作用：可見nn.ConvTranspose2d的參數output_padding的作用

 

在某些情況下，當使用CUDA后端與CuDNN，該操作可能選擇一個不確定性算法，以提高性能。如果不希望出現這種情況，可以通過設置torch.backends.cudnn.deterministic = True使操作具有確定性(可能要付出性能代價)。有關背景資料，請參閱有關 Reproducibility的說明。

參數：

• in_channels(int) – 輸入信號的通道數
• out_channels(int) – 卷積產生的通道數
• kerner_size(int or tuple) - 卷積核的大小
• stride(int or tuple,optional) - 卷積步長
• padding(int or tuple, optional) - 輸入的每一條邊補充padding= kernel - 1 - padding,即(kernel_size - 1)/2個0的層數，所以補充完高寬都增加(kernel_size - 1)
• output_padding(int or tuple, optional) - 在輸出的每一個維度的一邊補充0的層數，所以補充完高寬都增加padding，而不是2*padding，因為只補一邊
• dilation(int or tuple, optional) – 卷積核元素之間的間距
• groups(int, optional) – 從輸入通道到輸出通道的阻塞連接數
• bias(bool, optional) - 如果bias=True，添加偏置

shape: 
輸入: (N,C_in,H_in，W_in)  
輸出: (N,C_out,H_out,W_out)  

 

變量: 
- weight(tensor) - 卷積的權重，大小是(in_channels, in_channels,kernel_size)  ,從，中進行采樣
- bias(tensor) - 卷積的偏置系數，大小是（out_channel） ,從，中進行采樣

 ⚠️deconv只能做到還原輸出大小到和卷積輸入大小一樣大，輸出值和卷積輸入有那么一點聯系

 詳細可見逆卷積的詳細解釋ConvTranspose2d（fractionally-strided convolutions)

 

舉例：

import torch
from torch import nn
input = torch.randn(1,16,12,12)
downsample = nn.Conv2d(16,16,3,stride=2,padding=1)
upsample = nn.ConvTranspose2d(16,16,3,stride=2,padding=1)
h = downsample(input)
h.size()

返回：

torch.Size([1, 16, 6, 6])

 

output = upsample(h, output_size=input.size())
output.size()

返回：

torch.Size([1, 16, 12, 12])

如果沒有指定：

output = upsample(h)
output.size()

返回將是：

torch.Size([1, 16, 12, 12])

使用output_padding也能解決這個問題：

upsample = nn.ConvTranspose2d(16,16,3,stride=2,padding=1,output_padding=1)

 

2）標准化層

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

對小批量(mini-batch)3d數據組成的4d輸入進行批標准化(Batch Normalization)操作

進行了兩步操作：可見Batch Normalization的解釋

• 先對輸入進行歸一化，E(x)為計算的均值，Var(x)為計算的方差
• 然后對歸一化的結果進行縮放和平移，設置affine=True，即意味着weight(γ)和bias(β)將被使用

在每一個小批量（mini-batch）數據中，計算輸入各個維度的均值和標准差。γ與β是可學習的大小為C的參數向量（C為輸入大小)。默認γ取值為U(0,1)，β設置為0

同樣，默認情況下，在訓練期間，該層將運行其計算的平均值和方差的估計值，然后在驗證期間使用這些估計值（即訓練求得的均值/方差）進行標准化。運行估計(running statistics)時保持默認momentum為0.1。

如果track_running_stats被設置為False，那么這個層就不會繼續運行驗證，並且在驗證期間也會使用批處理統計信息。

 

⚠️這個momentum參數不同於優化器optimizer類中使用的momentum參數和momentum的傳統概念。從數學上講，這里運行統計數據的更新規則是 :

• x是估計的數據
• x_t是新的觀察到的數據

x_new = (1-momentum) * x + momentum * x_t

 

因為批處理規范化是在C維(channel通道維度)上完成的，計算(N,H,W)片上的統計信息，所以通常將其稱為空間批處理規范化。

參數：

• num_features： C來自期待的輸入大小(N,C,H,W)
  
• eps： 即上面式子中分母的ε ，為保證數值穩定性（分母不能趨近或取0）,給分母加上的值。默認為1e-5。
• momentum： 動態均值和動態方差所使用的動量。默認為0.1。
• affine： 一個布爾值，當設為true，給該層添加可學習的仿射變換參數，即γ與β。
• track_running_stats：一個布爾值，當設置為True時，該模塊跟蹤運行的平均值和方差，當設置為False時，該模塊不跟蹤此類統計數據，並且始終在train和eval模式中使用批處理統計數據。默認值:True

Shape： 

輸入：（N, C，H, W)

輸出：（N, C, H, W）（輸入輸出相同）

 

舉例：

當affine=True時

import torch
from torch import nn

m = nn.BatchNorm2d(2,affine=True)
print(m.weight)
print(m.bias)

input = torch.randn(1,2,3,4)
print(input)
output = m(input)
print(output)
print(output.size())

返回：

Parameter containing:
tensor([0.5247, 0.4397], requires_grad=True)
Parameter containing:
tensor([0., 0.], requires_grad=True)
tensor([[[[ 0.8316, -1.6250,  0.9072,  0.2746],
          [ 0.4579, -0.2228,  0.4685,  1.2020],
          [ 0.8648, -1.2116,  1.0224,  0.7295]],

         [[ 0.4387, -0.8889, -0.8999, -0.2775],
          [ 2.4837, -0.4111, -0.6032, -2.3912],
          [ 0.5622, -0.0770, -0.0107, -0.6245]]]])
tensor([[[[ 0.3205, -1.1840,  0.3668, -0.0206],
          [ 0.0916, -0.3252,  0.0982,  0.5474],
          [ 0.3409, -0.9308,  0.4373,  0.2580]],

         [[ 0.2664, -0.2666, -0.2710, -0.0211],
          [ 1.0874, -0.0747, -0.1518, -0.8697],
          [ 0.3160,  0.0594,  0.0860, -0.1604]]]],
       grad_fn=<NativeBatchNormBackward>)
torch.Size([1, 2, 3, 4])

 

當affine=False時

import torch
from torch import nn

m = nn.BatchNorm2d(2,affine=False)
print(m.weight)
print(m.bias)

input = torch.randn(1,2,3,4)
print(input)
output = m(input)
print(output)
print(output.size())

返回：

None
None
tensor([[[[-1.5365,  0.2642,  1.0482,  2.0938],
          [-0.0906,  1.8446,  0.7762,  1.2987],
          [-2.4138, -0.5368, -1.2173,  0.2574]],

         [[ 0.2518, -1.9633, -0.0487, -0.0317],
          [-0.9511,  0.2488,  0.3887,  1.4182],
          [-0.1422,  0.4096,  1.4740,  0.5241]]]])
tensor([[[[-1.2739,  0.0870,  0.6795,  1.4698],
          [-0.1811,  1.2814,  0.4740,  0.8689],
          [-1.9368, -0.5183, -1.0326,  0.0819]],

         [[ 0.1353, -2.3571, -0.2028, -0.1837],
          [-1.2182,  0.1320,  0.2894,  1.4478],
          [-0.3080,  0.3129,  1.5106,  0.4417]]]])
torch.Size([1, 2, 3, 4])

 

3）池化層

class torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)

對於輸入信號的輸入通道，提供2維最大池化（max pooling）操作

如果輸入的大小是(N,C,H,W)，那么輸出的大小是(N,C,H_out,W_out)和池化窗口大小kernel_size(kH,kW)的關系是： 

如果padding不是0，會在輸入的每一邊添加相應數目0 
dilation用於控制內核點之間的距離

參數kernel_size，stride, padding，dilation數據類型：

• 可以是一個int類型的數據，此時卷積height和width值相同;
• 也可以是一個tuple數組（包含來兩個int類型的數據），第一個int數據表示height的數值，tuple的第二個int類型的數據表示width的數值

參數：

• kernel_size(int or tuple) - max pooling的窗口大小
• stride(int or tuple, optional) - max pooling的窗口移動的步長。默認值是kernel_size
• padding(int or tuple, optional) - 輸入的每一條邊補充0的層數
• dilation(int or tuple, optional) – 一個控制窗口中元素步幅的參數
• return_indices - 如果等於True，會返回輸出最大值的序號，對於上采樣操作torch.nn.MaxUnpool2d會有幫助
• ceil_mode - 如果等於True，計算輸出信號大小的時候，會使用向上取整ceil，代替默認的向下取整floor的操作

shape: 
輸入: (N,C,H_in,W_in)  
輸出: (N,C,H_out,W_out)  

 

class torch.nn.AdaptiveAvgPool2d(output_size)

對輸入信號，提供2維的自適應平均池化操作

Adaptive Pooling特殊性在於：

輸出張量的大小都是給定的output_size。

例如輸入張量大小為(1, 64, 8, 9)，設定輸出大小為(5,7)，通過Adaptive Pooling層，可以得到大小為(1, 64, 5, 7)的張量

對於任何輸入大小的輸入，可以將輸出尺寸指定為H*W，但是輸入和輸出特征的數目不會變化。

參數：

• output_size: 輸出信號的尺寸,可以用(H,W)表示H*W的輸出，也可以使用單個數字H表示H*H大小的輸出

舉例：

input = torch.randn(1,64,8,9)
m = nn.AdaptiveAvgPool2d((5,7))
output = m(input)
output.shape

返回：

torch.Size([1, 64, 5, 7])

 

input = torch.randn(1,64,8,9)
m = nn.AdaptiveAvgPool2d(7)
output = m(input)
output.shape

返回：

torch.Size([1, 64, 7, 7])

 

4)非線形激活函數

class torch.nn.ReLU(inplace=False)

對輸入運用修正線性單元函數：

{ReLU}(x)= max(0, x)

圖為：

參數： inplace-選擇是否進行原位運算，即x= x+1

 

shape：

• 輸入：(N,*), *代表任意數目附加維度
• 輸出：(N,*)，與輸入擁有同樣的形狀

 舉例：

import torch
from torch import nn
m = nn.ReLU()
input = torch.randn(2)
output = m(input)
input, output

返回：

(tensor([-0.0468,  0.2225]), tensor([0.0000, 0.2225]))

 

class torch.nn.LeakyReLU(negative_slope=0.01, inplace=False)

是ReLU的變形，Leaky  ReLU是給所有負值賦予一個非零斜率

對輸入的每一個元素運用：

 

參數：

• negative_slope：控制負斜率的角度，默認等於0.01
• inplace-選擇是否進行原位運算，即x= x+1，默認為False

形狀：

• 輸入：(N,*), *代表任意數目附加維度
• 輸出：(N,*)，與輸入擁有同樣的形狀

圖為：

 

舉例：

m = nn.LeakyReLU(0.1)
input = torch.randn(2)
output = m(input)
input,output

返回：

(tensor([-1.3222,  0.8163]), tensor([-0.1322,  0.8163]))

 

class torch.nn.Sigmoid

輸出值的范圍為[0,1]

提供元素方式函數：

形狀：

• 輸入：(N,*), *代表任意數目附加維度
• 輸出：(N,*)，與輸入擁有同樣的形狀

圖為：

舉例：

m = nn.Sigmoid()
input = torch.randn(2)
output = m(input)
input, output

返回：

(tensor([-0.8425,  0.7383]), tensor([0.3010, 0.6766]))

 

class torch.nn.Tanh

輸出值的范圍為[-1,1]

提供元素方式函數：

形狀：

• 輸入：(N,*), *代表任意數目附加維度
• 輸出：(N,*)，與輸入擁有同樣的形狀

 圖為：

舉例：

m = nn.Tanh()
input = torch.randn(2)
output = m(input)
input, output

返回：

(tensor([-0.6246,  0.1523]), tensor([-0.5543,  0.1512]))

 

5）損失函數

class torch.nn.BCELoss(weight=None, size_average=True, reduce=None, reduction='mean')

計算 target 與 output 之間的二進制交叉熵。

損失函數能被描述為：

N是批處理大小。如果reduce=True,則：

即默認情況下，loss會基於element求平均值，如果size_average=False的話，loss會被累加。

這是用來測量誤差error的重建，例如一個自動編碼器。注意 0<=target[i]<=1。

 

參數：

• weight (Tensor,可選) – a manual rescaling weight given to the loss of each batch element. If given, has to be a Tensor of size “nbatch”.每批元素損失的手工重標權重。如果給定，則必須是一個大小為“nbatch”的張量。
• size_average (bool, 可選) – 棄用(見reduction參數)。默認情況下，設置為True，即對批處理中的每個損失元素進行平均。注意，對於某些損失，每個樣本有多個元素。如果字段size_average設置為False，則對每個小批的損失求和。當reduce為False時，該參數被忽略。默認值:True
• reduce (bool,可選) – 棄用(見reduction參數)。默認情況下，設置為True，即根據size_average參數的值決定對每個小批的觀察值是進行平均或求和。如果reduce為False，則返回每個批處理元素的損失，不進行平均和求和操作，即忽略size_average參數。默認值:True
• reduction (string,可選) – 指定要應用於輸出的reduction操作:' none ' | 'mean' | ' sum '。“none”:表示不進行任何reduction，“mean”:輸出的和除以輸出中的元素數，即求平均值，“sum”:輸出求和。注意:size_average和reduce正在被棄用，與此同時，指定這兩個arg中的任何一個都將覆蓋reduction參數。默認值:“mean”

 形狀：

• 輸入：(N,*), *代表任意數目附加維度
• 目標：(N,*)，與輸入擁有同樣的形狀
• 輸出:標量scalar，即輸出一個值。如果reduce為False,即不進行任何處理，則(N,*)，形狀與輸入相同。

 舉例：

 

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()

 

input,target,output

返回：

(tensor([-0.8728,  0.3632, -0.0547], requires_grad=True),
 tensor([1., 0., 0.]),
 tensor(0.9264, grad_fn=<BinaryCrossEntropyBackward>))

 

input.grad

返回：

tensor([-0.2351,  0.1966,  0.1621])