PyTorch零基礎入門之構建模型基礎

# -*- coding: utf-8 -*-
"""
Created on Sat Oct 16 09:43:21 2021

@author: 86493
"""
import torch
from torch import nn

class MLP(nn.Module):
    # 聲明帶有模型參數的層，此處聲明瞭2個全連接層
    def __init__(self, **kwargs):
        # 調用MLP父類Block的構造函數來進行必要的初始化
        # 這樣在構造實例時還可以指定其他函數
        super(MLP, self).__init__(**kwargs)
        self.hidden = nn.Linear(784, 256)
        self.act = nn.ReLU()
        self.output = nn.Linear(256, 10)
        
    # 定義模型的前向計算
    # 即如何根據輸入x計算返回所需要的模型輸出
    def forward(self, x):
        o = self.act(self.hidden(x))
        return self.output(o)
    
X = torch.rand(2, 784)
net = MLP()
print(net)
print('-' * 60)
print(net(X))

# -*- coding: utf-8 -*-
"""
Created on Sat Oct 16 10:19:59 2021

@author: 86493
"""
import torch
from torch import nn

class MyLayer(nn.Module):
    def __init__(self, **kwargs):
        # 調用父類的方法
        super(MyLayer, self).__init__(**kwargs)
    def forward(self, x):
        return x - x.mean()
 
    
# 測試，實例化該層，做前向計算
layer = MyLayer()
layer1 = layer(torch.tensor([1, 2, 3, 4, 5],
                   dtype = torch.float))
print(layer1)

# -*- coding: utf-8 -*-
"""
Created on Sat Oct 16 10:56:03 2021

@author: 86493
"""
import torch
a = torch.randn(2, 3)
b = torch.randn(3, 2)
print(torch.mm(a, b))
# 效果相同
print(torch.matmul(a, b))
#tensor([[1.8368, 0.4065],
#        [2.7972, 2.3096]])
#tensor([[1.8368, 0.4065],
#        [2.7972, 2.3096]])

# -*- coding: utf-8 -*-
"""
Created on Sat Oct 16 10:33:04 2021

@author: 86493
"""
import torch
from torch import nn

class MyListDense(nn.Module):
    def __init__(self):
        super(MyListDense, self).__init__()
        # 3個randn的意思
        self.params = nn.ParameterList([nn.Parameter(torch.randn(4, 4)) for i in range(3)]) 
        self.params.append(nn.Parameter(torch.randn(4, 1)))
        
    def forward(self, x):
        for i in range(len(self.params)):
            # mm是指矩陣相乘
            x = torch.mm(x, self.params[i])
        return x
    
net = MyListDense()
print(net)

# -*- coding: utf-8 -*-
"""
Created on Sat Oct 16 11:03:29 2021

@author: 86493
"""
import torch
from torch import nn

class MyDictDense(nn.Module):
    def __init__(self):
        super(MyDictDense, self).__init__()
        self.params = nn.ParameterDict({
            'linear1': nn.Parameter(torch.randn(4, 4)),
            'linear2': nn.Parameter(torch.randn(4, 1))
            })
        # 新增
        self.params.update({'linear3':
                            nn.Parameter(torch.randn(4, 2))})
        
    def forward(self, x, choice = 'linear1'):
        return torch.mm(x, self.params[choice])
    

net = MyDictDense()
print(net)     

# -*- coding: utf-8 -*-
"""
Created on Sat Oct 16 11:20:57 2021

@author: 86493
"""
import torch
from torch import nn

# 卷積運算(二維互相關)
def corr2d(X, K):
    h, w = K.shape 
    X, K = X.float(), K.float()
    Y = torch.zeros((X.shape[0] - h + 1, X.shape[1] - w + 1))
    for i in range(Y.shape[0]):
        for j in range(Y.shape[1]):
            Y[i, j] = (x[i: i + h, j: j + w] * K).sum()
    return Y
    
# 二維卷積層
class Conv2D(nn.Module):
    def __init__(self, kernel_size):
        super(Conv2D, self).__init__()
        self.weight = nn.Parameter(torch.randn(kernel_size))
        self.bias = nn.Parameter(torch.randn(1))
    
    def forward(self, x):
        return corr2d(x, self.weight) + self.bias 

conv2d = nn.Conv2d(in_channels = 1, 
                   out_channels = 1,
                   kernel_size = 3,
                   padding = 1)

print(conv2d)

Conv2d(1, 1, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))

# -*- coding: utf-8 -*-
"""
Created on Sat Oct 16 11:54:29 2021

@author: 86493
"""
import torch  
from torch import nn

# 定義一個函數計算卷積層
# 對輸入和輸出左對應的升維和降維
def comp_conv2d(conv2d, X):
    # (1, 1)代表批量大小和通道數
    X = X.view((1, 1) + X.shape)
    Y = conv2d(X)
    # 排除不關心的前2維：批量和通道
    return Y.view(Y.shape[2:])

# 註意這裡是兩側分別填充1行或列，所以在兩側共填充2行或列
conv2d = nn.Conv2d(in_channels = 1,
                   out_channels = 1,
                   kernel_size = 3,
                   padding = 1)
X = torch.rand(8, 8)
endshape = comp_conv2d(conv2d, X).shape
print(endshape)

# 使用高為5，寬為3的卷積核，在高和寬兩側填充數為2和1
conv2d = nn.Conv2d(in_channels = 1,
                   out_channels = 1,
                   kernel_size = (5, 3),
                   padding = (2, 1))
endshape2 = comp_conv2d(conv2d, X).shape
print(endshape2)

# 步幅stride
conv2d = nn.Conv2d(in_channels = 1,
                   out_channels = 1,
                   kernel_size = (3, 5),
                   padding = (0, 1),
                   stride = (3, 4))
endshape3 = comp_conv2d(conv2d, X).shape
print(endshape3)
# torch.Size([2, 2])

# -*- coding: utf-8 -*-
"""
Created on Sat Oct 16 18:49:27 2021

@author: 86493
"""
import torch
from torch import nn

def pool2d(x, pool_size, mode = 'max'):
    p_h, p_w = pool_size
    Y = torch.zeros((X.shape[0] - p_h + 1, X.shape[1] - p_w + 1))
    for i in range(Y.shape[0]):
        for j in range(Y.shape[1]):
            if mode == 'max':
                Y[i, j] = X[i: i + p_h, j: j + p_w].max()
            elif mode == 'avg':
                Y[i, j] = X[i: i + p_h, j: j + p_w].mean()
    return Y

X = torch.Tensor([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
end = pool2d(X, (2, 2)) # 默認是最大池化
# end = pool2d(X, (2, 2), mode = 'avg')
print(end)

tensor([[4., 5.],
        [7., 8.]])

# -*- coding: utf-8 -*-
"""
Created on Sat Oct 16 18:49:27 2021

@author: 86493
"""
import torch
from torch import nn

def pool2d(x, pool_size, mode = 'max'):
    p_h, p_w = pool_size
    Y = torch.zeros((X.shape[0] - p_h + 1, X.shape[1] - p_w + 1))
    for i in range(Y.shape[0]):
        for j in range(Y.shape[1]):
            if mode == 'max':
                Y[i, j] = X[i: i + p_h, j: j + p_w].max()
            elif mode == 'avg':
                Y[i, j] = X[i: i + p_h, j: j + p_w].mean()
    return Y

X = torch.FloatTensor([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
# end = pool2d(X, (2, 2)) # 默認是最大池化
end = pool2d(X, (2, 2), mode = 'avg')
print(end)

# -*- coding: utf-8 -*-
"""
Created on Sat Oct 16 19:21:19 2021

@author: 86493
"""
import torch
import torch.nn as nn
import torch.nn.functional as F

class LeNet(nn.Module):
    # 需要把網絡中具有可學習參數的層放在構造函數__init__
    def __init__(self):
        super(LeNet, self).__init__()
        # 輸入圖像channel：1；輸出channel：6
        # 5*5卷積核
        self.conv1 = nn.Conv2d(1, 6, 5)
        self.conv2 = nn.Conv2d(6, 16, 5)
        # an affine operation:y = Wx + b
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)
    
    def forward(self, x):
        # 2 * 2 最大池化
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
        # 如果是方陣，則可以隻使用一個數字進行定義
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        # 做一次flatten
        x = x.view(-1, self.num_flat_features(x))
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x 

    def num_flat_features(self, x):
        # 除去批處理維度,得到其他所有維度
        size = x.size()[1:]
        num_features = 1
        # 將剛才得到的維度之間相乘起來
        for s in size:
            num_features *= s
        return num_features

net = LeNet()
print(net)    

# 一個模型的可學習參數可以通過`net.parameters()`返回
params = list(net.parameters())
print("params的len:", len(params))
# print("params:\n", params)
print(params[0].size()) # conv1的權重
print('-' * 60)

# 隨機一個32×32的input
input = torch.randn(1, 1, 32, 32)
out = net(input)
print("網絡的output為：", out)
print('-' * 60)

# 隨機梯度的反向傳播
net.zero_grad() # 清零所有參數的梯度緩存
end = out.backward(torch.randn(1, 10))
print(end)  # None       

# -*- coding: utf-8 -*-
"""
Created on Sat Oct 16 21:00:39 2021

@author: 86493
"""
import torch
from torch import nn

class AlexNet(nn.Module):
    def __init__(self):
        super(AlexNet, self).__init__()
        self.conv = nn.Sequential(
            # in_channels,out_channels,kernel_size,stride,padding
            nn.Conv2d(1, 96, 11, 4),
            nn.ReLU(),
            # kernel_size, stride
            nn.MaxPool2d(3, 2),        
            # 見笑卷積窗口，但使用padding=2來使輸入和輸出的高寬相同
            # 且增大輸出通道數
            nn.Conv2d(96, 256, 5, 1, 2),
            nn.ReLU(),
            nn.MaxPool2d(3, 2),
            # 連續3個卷積層，且後面使用更小的卷積窗口
            # 除瞭最後的卷積層外，進一步增大瞭輸出
        
            # 註:前2個卷積層後不使用池化層來減少輸入的高和寬
            nn.Conv2d(256, 384, 3, 1, 1),
            nn.ReLU(),
            nn.Conv2d(384, 383, 3, 1, 1),
            nn.ReLU(),
            nn.Conv2d(384, 256, 3, 1, 1),
            nn.ReLU(),
            nn.MaxPool2d(3, 2)
        )
    # 這裡的全連接層的輸出個數比LeNet中的大數倍。
    # 使用丟棄層來緩解過擬合
        self.fc = nn.Sequential(
            nn.Linear(256 *5 * 5, 4096),
            nn.ReLU(),
            nn.Dropout(0.5),
            nn.Linear(4096, 4086),
            nn.ReLU(),
            nn.Dropout(0.5),
            # 輸出層，下次會用到Fash-MNIST，所以此處類別設為10,
            # 而非論文中的1000
            nn.Linear(4096, 10),
        )
    
    
    def forward(self, img):
        feature = self.conv(img)
        output = self.fc(feature.view(img.shape[0], -1))
        return output
    
net = AlexNet()
print(net)

AlexNet(
  (conv): Sequential(
    (0): Conv2d(1, 96, kernel_size=(11, 11), stride=(4, 4))
    (1): ReLU()
    (2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
    (3): Conv2d(96, 256, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (4): ReLU()
    (5): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
    (6): Conv2d(256, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (7): ReLU()
    (8): Conv2d(384, 383, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (9): ReLU()
    (10): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU()
    (12): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (fc): Sequential(
    (0): Linear(in_features=6400, out_features=4096, bias=True)
    (1): ReLU()
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=4096, out_features=4086, bias=True)
    (4): ReLU()
    (5): Dropout(p=0.5, inplace=False)
    (6): Linear(in_features=4096, out_features=10, bias=True)
  )
)