技術標籤：pytorch學習筆記

池化層&線性層

• 1.池化層-Pooling Layer
• • 1.1 nn.MaxPool2d
  • 1.2 nn.AvgPool2d
  • 1.3 nn.MaxUnpool2d
• 2.線性層-Linear Layer

1.池化層-Pooling Layer

池化可實現冗餘資訊的剔除以及減小後續計算量。
下采樣：將大尺寸影象變換為小尺寸的影象
上取樣：將小尺寸影象變換為大尺寸的影象
MaxPool2d和AvgPool2d屬於下采樣

準備：將圖片轉為Tensor：

img_transform = transforms.Compose([transforms.
 
ToTensor()])
img_tensor = img_transform(img)
img_tensor.unsqueeze_(dim=0)   

1.1 nn.MaxPool2d

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

功能：最大值池化
主要引數：
• kernel_size：池化核尺寸
• stride：步長
• padding ：填充個數
• dilation：池化核間隔大小

maxpool_layer = nn.MaxPool2d((2, 2), stride=(2, 2))   img_pool = maxpool_layer(img_tensor)

1.2 nn.AvgPool2d

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

功能：平均值池化
主要引數：
• kernel_size：池化核尺寸
• stride：步長
• padding ：填充個數
• ceil_mode：尺寸向上取整
• count_include_pad：填充值用於計算
• divisor_override ：除法因子。可以在計算畫素平均值時分母變為所設定的引數

avgpoollayer = nn.AvgPool2d((2, 2), stride=(2, 2))   
img_pool = avgpoollayer(img_tensor)

divisor_override 引數的使用：

#不使用divisor_override引數：
img_tensor = torch.ones((1, 1, 4, 4))#初始化4*4的影象
avgpool_layer = nn.AvgPool2d((2, 2), stride=(2, 2), divisor_override=3)
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
img_tensor = torch.ones((1, 1, 4, 4))#初始化4*4的影象
avgpool_layer = nn.AvgPool2d((2, 2), stride=(2, 2), divisor_override=3)
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.3333, 1.3333],
         [1.3333, 1.3333]]]])

1.3 nn.MaxUnpool2d

nn.MaxUnpool2d(kernel_size,
			   stride=None,
			   padding=0
			   )
#forward()中需要傳入indices，即索引
forward(self, input, indices, output_size=None)

功能：最大值池化上取樣
主要引數：
• kernel_size：池化核尺寸
• stride：步長
• 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)#構造和img_pool同樣大小的tensor
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))

#執行結果：
raw_img:
tensor([[[[0., 4., 4., 3.],
          [3., 3., 1., 1.],
          [4., 2., 3., 4.],
          [1., 3., 3., 0.]]]])
img_pool:
tensor([[[[4., 4.],
          [4., 4.]]]])
img_reconstruct:
tensor([[[[-1.0276, -0.5631],
          [-0.8923, -0.0583]]]])
img_unpool:
tensor([[[[ 0.0000, -1.0276, -0.5631,  0.0000],
          [ 0.0000,  0.0000,  0.0000,  0.0000],
          [-0.8923,  0.0000,  0.0000, -0.0583],
          [ 0.0000,  0.0000,  0.0000,  0.0000]]]])

2.線性層-Linear Layer

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

主要引數：
• in_features：輸入結點數
• out_features：輸出結點數
• bias ：是否需要偏置

計算公式：
y = x W T + b i a s y = xW^T+bias y=xWT+bias

inputs = torch.tensor([[1., 2, 3]])
linear_layer = nn.Linear(3, 4)#輸入節點是3，輸出節點是4
linear_layer.weight.data = torch.tensor([[1., 1., 1.],  #權值初始化即W^T,所以是4*3，每個數代表前一個神經元和後一個神經元連線的權值
                                             [2., 2., 2.],
                                             [3., 3., 3.],
                                             [4., 4., 4.]])

linear_layer.bias.data.fill_(1)#偏置bias
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([[ 7., 13., 19., 25.]], grad_fn=<AddmmBackward>) torch.Size([1, 4])