PyTorch 介紹 | BUILD THE NEURAL NETWORK-有解無憂

神經網路由對資料進行操作的layers/modules組成，torch.nn 命名空間提供了所有你需要的構建塊，用于構建你自己的神經網路，PyTorch的每一個module都繼承自nn.Module，神經網路本身也是包含其它module（layer）的module，這種嵌套結構允許輕松構建和管理復雜的架構，

下面，我們將構建一個神經網路分類FashionMNIST資料集的圖片

import os
import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

為訓練獲取設備

如果可以的話，我們想要能夠在一個類似于GPU的硬體加速器上訓練模型，檢查torch.cuda，否則繼續使用CPU，

device = 'cuda' if torch.cuda.is_available() else 'cpu'
print(f"Using {device} device")

輸出：

Using cuda device

定義類

通過繼承 nn.Module 定義我們的神經網路，利用 __init__ 初始化神經網路的layers，每個 nn.Module 的子類利用 forward 方法對輸入資料進行操作，

class NeuralNetwork(nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()
        self.flatten = nn.Flatten()
        self.linear_relu_stack = nn.Sequential(
            nn.Linear(28*28, 512),
            nn.ReLU(),
            nn.Linear(512, 512),
            nn.ReLU(),
            nn.Linear(512, 10),
        )
    
    def forward(self, x):
        x = self.flatten(x)
        logits = self.linear_relu_stack(x)
        return logits

創建 NeuralNetwork 實體，并將其轉移到 device，并列印它的結構

model = NeuralNetwork().to(device)
print(model)

輸出：

NeuralNetwork(
  (flatten): Flatten(start_dim=1, end_dim=-1)
  (linear_relu_stack): Sequential(
    (0): Linear(in_features=784, out_features=512, bias=True)
    (1): ReLU()
    (2): Linear(in_features=512, out_features=512, bias=True)
    (3): ReLU()
    (4): Linear(in_features=512, out_features=10, bias=True)
  )
)

為使用模型，我們傳入input data，這將沿著一些background operations執行模型的 forward，不要直接呼叫 model.forward()

將input輸入模型回傳維度大小為10的tensor，包含對每個類的原始預測值，我們通過將其傳入 nn.Softmax module的實體獲取預測概率值，

X = torch.rand(1, 28, 28, device=device)
logits = model(X)
pred_probab = nn.Softmax(dim=1)(logits)
y_pred = pred_probab.argmax(1)
print(f"Predicted class: {y_pred}")

輸出：

Predicted class: tensor([1], device='cuda:0')

Model Layers

讓我們來分解一下FashionMNIST模型的layers，為了說明，我們構建了一個具有3個28x28圖片樣本的minibatch，觀察將其輸入網路后發生了什么，

input_image = torch.rand(3, 28, 28)
print(input_image.size())

輸出：

torch.size([3, 28, 28])

nn.Flatten

初始化 nn.Flatten 層，將每一個2D 28x28圖片轉換為一個連續的具有784像素值的陣列（保留minibatch維度（dim=0）），

flatten = nn.Flatten()
flat_image = flatten(input_image)
print(flat_image.size())

輸出：

torch.Size([3, 784])

nn.Linear

linear layer也是一個module，它是對input使用保存的權重和偏置進行線性變換，

layer1 = nn.Linear(in_features=28*28, out_features=20)
hidden1 = layer1(flat_image)
print(hidden1.size())

輸出：

torch.Size([3, 20])

nn.ReLU

非線性激活函式在模型的輸入和輸出之間創建了復雜的映射關系，它們在線性轉換后用以引入非線性，幫助網路學習到各種各樣的現象，

在此模型中，我們在線性層之間使用nn.ReLU，但也可以在你的模型中使用其它激活函式引入非線性，

print(f"Before ReLU: {hidden1}\n\n")
hidden1 = nn.ReLU()(hidden1)
print(f"After ReLU: {hidden1}")

輸出：

點擊查看代碼

Before ReLU: tensor([[-0.2541, -0.1397,  0.2342,  0.1364, -0.0437,  0.3759,  0.2808, -0.0619,
          0.2780,  0.2830, -0.4725,  0.4298,  0.2717, -0.1618, -0.0604,  0.3242,
         -0.5874, -0.5922, -0.2481, -0.4181],
        [-0.1339, -0.1163,  0.1688,  0.1112,  0.1179,  0.3560,  0.0990, -0.1398,
          0.2619, -0.1023, -0.7150, -0.1186,  0.3338, -0.0817,  0.1983, -0.2084,
         -0.3889, -0.2361, -0.0752, -0.2144],
        [-0.1284,  0.0683,  0.0707,  0.0997, -0.2274,  0.4379,  0.1461,  0.0949,
          0.2710, -0.0563, -0.6621, -0.3552,  0.4966,  0.2304,  0.0020, -0.0470,
         -0.6260, -0.2077, -0.0790, -0.4635]], grad_fn=<AddmmBackward0>)


After ReLU: tensor([[0.0000, 0.0000, 0.2342, 0.1364, 0.0000, 0.3759, 0.2808, 0.0000, 0.2780,
         0.2830, 0.0000, 0.4298, 0.2717, 0.0000, 0.0000, 0.3242, 0.0000, 0.0000,
         0.0000, 0.0000],
        [0.0000, 0.0000, 0.1688, 0.1112, 0.1179, 0.3560, 0.0990, 0.0000, 0.2619,
         0.0000, 0.0000, 0.0000, 0.3338, 0.0000, 0.1983, 0.0000, 0.0000, 0.0000,
         0.0000, 0.0000],
        [0.0000, 0.0683, 0.0707, 0.0997, 0.0000, 0.4379, 0.1461, 0.0949, 0.2710,
         0.0000, 0.0000, 0.0000, 0.4966, 0.2304, 0.0020, 0.0000, 0.0000, 0.0000,
         0.0000, 0.0000]], grad_fn=<ReluBackward0>)

nn.Sequential

nn.Sequential是modules的排序容器，輸入資料根據所定義的，按照相同的順序依次通過所有module，你可以使用順序容器快速組建一個網路，如 seq_modules，

seq_modules = nn.Sequential(
    flatten,
    layer1,
    nn.ReLU(),
    nn.Linear(20, 10)
)
input_image = torch.rand(3, 28, 28)
logits = seq_modules(input_image)

nn.Softmax

神經網路的最后一個線性層回傳logits - 原始數值，范圍是[-infty, infty] - 傳入nn.Softmax module，logits被縮放到[0, 1]，表示了模型對每個類別的預測概率值，dim 引數指定了元素的和為1的維度，

softmax = nn.Softmax(dim=1)
pred_probab = softmax(logits)

模型引數

許多神經網路中的層都是引數化的，即具有訓練程序中可被優化的相關權重和偏置，繼承nn.Module自動跟蹤模型物件定義的所有區域，并使得所有引數都可通過模型的 parameters() 或 named_parameters()方法訪問，

print("Model structure: ", model, '\n\n')

for name, param in model.named_parameters():
    print(f:"Layer: {} | Size: {param.size()} | Values: {param[:2]} \n")

輸出：