[PyTorch 學習筆記] 3.3 池化層、線性層和啟用函式層

張賢同學發表於2020-08-31

本章程式碼:https://github.com/zhangxiann/PyTorch_Practice/blob/master/lesson3/nn_layers_others.py

這篇文章主要介紹了 PyTorch 中的池化層、線性層和啟用函式層。

池化層

池化的作用則體現在降取樣:保留顯著特徵、降低特徵維度,增大 kernel 的感受野。 另外一點值得注意:pooling 也可以提供一些旋轉不變性。 池化層可對提取到的特徵資訊進行降維,一方面使特徵圖變小,簡化網路計算複雜度並在一定程度上避免過擬合的出現;一方面進行特徵壓縮,提取主要特徵。

有最大池化和平均池化兩張方式。

最大池化:nn.MaxPool2d()

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

這個函式的功能是進行 2 維的最大池化,主要引數如下:

  • kernel_size:池化核尺寸
  • stride:步長,通常與 kernel_size 一致
  • padding:填充寬度,主要是為了調整輸出的特徵圖大小,一般把 padding 設定合適的值後,保持輸入和輸出的影像尺寸不變。
  • dilation:池化間隔大小,預設為 1。常用於影像分割任務中,主要是為了提升感受野
  • ceil_mode:預設為 False,尺寸向下取整。為 True 時,尺寸向上取整
  • return_indices:為 True 時,返回最大池化所使用的畫素的索引,這些記錄的索引通常在反最大池化時使用,把小的特徵圖反池化到大的特徵圖時,每一個畫素放在哪個位置。

下圖 (a) 表示反池化,(b) 表示上取樣,(c) 表示反摺積。

[PyTorch 學習筆記] 3.3 池化層、線性層和啟用函式層

下面是最大池化的程式碼:
import os
import torch
import torch.nn as nn
from torchvision import transforms
from matplotlib import pyplot as plt
from PIL import Image
from common_tools import transform_invert, set_seed

set_seed(1)  # 設定隨機種子

# ================================= load img ==================================
path_img = os.path.join(os.path.dirname(os.path.abspath(__file__)), "imgs/lena.png")
img = Image.open(path_img).convert('RGB')  # 0~255

# convert to tensor
img_transform = transforms.Compose([transforms.ToTensor()])
img_tensor = img_transform(img)
img_tensor.unsqueeze_(dim=0)    # C*H*W to B*C*H*W

# ================================= create convolution layer ==================================

# ================ maxpool
flag = 1
# flag = 0
if flag:
    maxpool_layer = nn.MaxPool2d((2, 2), stride=(2, 2))   # input:(i, o, size) weights:(o, i , h, w)
    img_pool = maxpool_layer(img_tensor)

print("池化前尺寸:{}\n池化後尺寸:{}".format(img_tensor.shape, img_pool.shape))
img_pool = transform_invert(img_pool[0, 0:3, ...], img_transform)
img_raw = transform_invert(img_tensor.squeeze(), img_transform)
plt.subplot(122).imshow(img_pool)
plt.subplot(121).imshow(img_raw)
plt.show()

結果和展示的圖片如下:

池化前尺寸:torch.Size([1, 3, 512, 512])
池化後尺寸:torch.Size([1, 3, 256, 256])
[PyTorch 學習筆記] 3.3 池化層、線性層和啟用函式層

nn.AvgPool2d()

torch.nn.AvgPool2d(kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True, divisor_override=None)

這個函式的功能是進行 2 維的平均池化,主要引數如下:

  • kernel_size:池化核尺寸
  • stride:步長,通常與 kernel_size 一致
  • padding:填充寬度,主要是為了調整輸出的特徵圖大小,一般把 padding 設定合適的值後,保持輸入和輸出的影像尺寸不變。
  • dilation:池化間隔大小,預設為 1。常用於影像分割任務中,主要是為了提升感受野
  • ceil_mode:預設為 False,尺寸向下取整。為 True 時,尺寸向上取整
  • count_include_pad:在計算平均值時,是否把填充值考慮在內計算
  • divisor_override:除法因子。在計算平均值時,分子是畫素值的總和,分母預設是畫素值的個數。如果設定了 divisor_override,把分母改為 divisor_override。
img_tensor = torch.ones((1, 1, 4, 4))
avgpool_layer = nn.AvgPool2d((2, 2), stride=(2, 2))
img_pool = avgpool_layer(img_tensor)
print("raw_img:\n{}\npooling_img:\n{}".format(img_tensor, img_pool))

輸出如下:

raw_img:
tensor([[[[1., 1., 1., 1.],
          [1., 1., 1., 1.],
          [1., 1., 1., 1.],
          [1., 1., 1., 1.]]]])
pooling_img:
tensor([[[[1., 1.],
          [1., 1.]]]])

加上divisor_override=3後,輸出如下:

raw_img:
tensor([[[[1., 1., 1., 1.],
          [1., 1., 1., 1.],
          [1., 1., 1., 1.],
          [1., 1., 1., 1.]]]])
pooling_img:
tensor([[[[1.3333, 1.3333],
          [1.3333, 1.3333]]]])

nn.MaxUnpool2d()

nn.MaxUnpool2d(kernel_size, stride=None, padding=0)

功能是對二維訊號(影像)進行最大值反池化,主要引數如下:

  • kernel_size:池化核尺寸
  • stride:步長,通常與 kernel_size 一致
  • padding:填充寬度

程式碼如下:

# pooling
img_tensor = torch.randint(high=5, size=(1, 1, 4, 4), dtype=torch.float)
maxpool_layer = nn.MaxPool2d((2, 2), stride=(2, 2), return_indices=True)
img_pool, indices = maxpool_layer(img_tensor)

# unpooling
img_reconstruct = torch.randn_like(img_pool, dtype=torch.float)
maxunpool_layer = nn.MaxUnpool2d((2, 2), stride=(2, 2))
img_unpool = maxunpool_layer(img_reconstruct, indices)

print("raw_img:\n{}\nimg_pool:\n{}".format(img_tensor, img_pool))
print("img_reconstruct:\n{}\nimg_unpool:\n{}".format(img_reconstruct, img_unpool))

輸出如下:

# pooling
img_tensor = torch.randint(high=5, size=(1, 1, 4, 4), dtype=torch.float)
maxpool_layer = nn.MaxPool2d((2, 2), stride=(2, 2), return_indices=True)
img_pool, indices = maxpool_layer(img_tensor)

# unpooling
img_reconstruct = torch.randn_like(img_pool, dtype=torch.float)
maxunpool_layer = nn.MaxUnpool2d((2, 2), stride=(2, 2))
img_unpool = maxunpool_layer(img_reconstruct, indices)

print("raw_img:\n{}\nimg_pool:\n{}".format(img_tensor, img_pool))
print("img_reconstruct:\n{}\nimg_unpool:\n{}".format(img_reconstruct, img_unpool))

線性層

線性層又稱為全連線層,其每個神經元與上一個層所有神經元相連,實現對前一層的線性組合或線性變換。

程式碼如下:

inputs = torch.tensor([[1., 2, 3]])
linear_layer = nn.Linear(3, 4)
linear_layer.weight.data = torch.tensor([[1., 1., 1.],
[2., 2., 2.],
[3., 3., 3.],
[4., 4., 4.]])

linear_layer.bias.data.fill_(0.5)
output = linear_layer(inputs)
print(inputs, inputs.shape)
print(linear_layer.weight.data, linear_layer.weight.data.shape)
print(output, output.shape)

輸出為:

tensor([[1., 2., 3.]]) torch.Size([1, 3])
tensor([[1., 1., 1.],
        [2., 2., 2.],
        [3., 3., 3.],
        [4., 4., 4.]]) torch.Size([4, 3])
tensor([[ 6.5000, 12.5000, 18.5000, 24.5000]], grad_fn=<AddmmBackward>) torch.Size([1, 4])

啟用函式層

假設第一個隱藏層為:$H_{1}=X \times W_{1}$,第二個隱藏層為:$H_{2}=H_{1} \times W_{2}$,輸出層為:

$$ \begin{aligned} \text { Out } \boldsymbol{p} \boldsymbol{u} \boldsymbol{t} &=\boldsymbol{H}{2} * \boldsymbol{W}{3} \ &=\boldsymbol{H}{1} * \boldsymbol{W}{2} * \boldsymbol{W}{3} \ &=\boldsymbol{X} * (\boldsymbol{W}{1} *\boldsymbol{W}{2} * \boldsymbol{W}{3}) \ &=\boldsymbol{X} * {W} \end{aligned} $$

如果沒有非線性變換,由於矩陣乘法的結合性,多個線性層的組合等價於一個線性層。

啟用函式對特徵進行非線性變換,賦予了多層神經網路具有深度的意義。下面介紹一些啟用函式層。

nn.Sigmoid

  • 計算公式:$y=\frac{1}{1+e^{-x}}$
  • 梯度公式:$y^{\prime}=y *(1-y)$
  • 特性:
    • 輸出值在(0,1),符合概率
    • 導數範圍是 [0, 0.25],容易導致梯度消失
    • 輸出為非 0 均值,破壞資料分佈
[PyTorch 學習筆記] 3.3 池化層、線性層和啟用函式層

nn.tanh

  • 計算公式:$y=\frac{\sin x}{\cos x}=\frac{e{x}-e{-x}}{e{-}+e{-x}}=\frac{2}{1+e^{-2 x}}+1$
  • 梯度公式:$y{\prime}=1-y{2}$
  • 特性:
    • 輸出值在(-1, 1),資料符合 0 均值
    • 導數範圍是 (0,1),容易導致梯度消失
[PyTorch 學習筆記] 3.3 池化層、線性層和啟用函式層

nn.ReLU(修正線性單元)

  • 計算公式:$y=max(0, x)$
  • 梯度公式:$y^{\prime}=\left{\begin{array}{ll}1, & x>0 \ u n d \text { ef ined, } & x=0 \ 0, & x<0\end{array}\right.$
  • 特性:
    • 輸出值均為正數,負半軸的導數為 0,容易導致死神經元
    • 導數是 1,緩解梯度消失,但容易引發梯度爆炸
[PyTorch 學習筆記] 3.3 池化層、線性層和啟用函式層

針對 RuLU 會導致死神經元的缺點,出現了下面 3 種改進的啟用函式。
[PyTorch 學習筆記] 3.3 池化層、線性層和啟用函式層

nn.LeakyReLU

  • 有一個引數negative_slope:設定負半軸斜率

nn.PReLU

  • 有一個引數init:設定初始斜率,這個斜率是可學習的

nn.RReLU

R 是 random 的意思,負半軸每次斜率都是隨機取 [lower, upper] 之間的一個數

  • lower:均勻分佈下限
  • upper:均勻分佈上限

參考資料


如果你覺得這篇文章對你有幫助,不妨點個贊,讓我有更多動力寫出好文章。

相關文章