建立神经网络模型

神经网络由处理数据的层/模块组成。PyTorch的torch.nn 命名空间为我们提供了构建神经网络所需的模块。这些模块都是 nn.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__模块中初始化神经网络层。每一个nn.Module子类在forward方法中实现对输入数据的操作。

class NeuralNetwork(nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()

        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 = torch.flatten(x,1)
        logits = self.linear_relu_stack(x)
        return logits

下面我们创建一个NeuralNetwork实例，将其移动到device上，并打印其结构。

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

输出：

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

调用模型处理数据

为了使用这个模型，我们将输入数据X传递给它：model(X)。这将执行模型的forward以及一些其他操作。注意，不是调用 model.forward()！

模型返回一个10维张量，是每个类别的原始预测值。我们通过一个nn.Softmax实例来获得预测概率。

X = torch.rand(2, 28, 28, device=device) # 输入2幅大小为28x28的图像
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([0, 3], device='cuda:0')

模型拆解

让我们把模型拆解一下。下面，我们将选取一个由3幅大小为28x28的图像组成的小样本，看看输入网络后会变成什么。

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

输出：

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

torch.flatten

​输入网络之前，我们使用torch.flatten将每个 28x28二维图像转换为784像素值的一维数组。

flat_image = torch.flatten(input_image,1)
print(flat_image.size())

输出：

torch.Size([3, 784])

nn.Linear

线性层是一个模块，它使用权重和偏差对输入应用线性变换。

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.0786,  0.0687, -0.0630,  0.1599,  0.2955,  0.3943,  0.3418, -0.1234,
         -0.3633, -0.2781, -0.0601, -0.3149,  0.4653,  0.1786,  0.0593, -0.0398,
          0.2831, -0.0338, -0.3874, -0.1746],
        [ 0.1276,  0.0592, -0.2942, -0.1965,  0.5646,  0.2647,  0.2659,  0.0756,
         -0.2048, -0.2383,  0.1239, -0.5666,  0.5695,  0.2491,  0.0350, -0.0903,
          0.6653, -0.1691, -0.4787, -0.1862],
        [ 0.3620, -0.0493, -0.0328,  0.1019,  0.3734,  0.2581,  0.1769,  0.0283,
         -0.0955,  0.1093, -0.1116, -0.3937,  0.2430,  0.2329,  0.3018,  0.0101,
          0.4585, -0.4458, -0.4265, -0.1632]], grad_fn=<AddmmBackward0>)


After ReLU: tensor([[0.0000, 0.0687, 0.0000, 0.1599, 0.2955, 0.3943, 0.3418, 0.0000, 0.0000,
         0.0000, 0.0000, 0.0000, 0.4653, 0.1786, 0.0593, 0.0000, 0.2831, 0.0000,
         0.0000, 0.0000],
        [0.1276, 0.0592, 0.0000, 0.0000, 0.5646, 0.2647, 0.2659, 0.0756, 0.0000,
         0.0000, 0.1239, 0.0000, 0.5695, 0.2491, 0.0350, 0.0000, 0.6653, 0.0000,
         0.0000, 0.0000],
        [0.3620, 0.0000, 0.0000, 0.1019, 0.3734, 0.2581, 0.1769, 0.0283, 0.0000,
         0.1093, 0.0000, 0.0000, 0.2430, 0.2329, 0.3018, 0.0101, 0.4585, 0.0000,
         0.0000, 0.0000]], grad_fn=<ReluBackward0>)

nn.Sequential

nn.Sequential是模块的有序容器。数据以定义的顺序通过所有模块。你可以使用顺序容器来组合一个像seq_modules这样的快速网络。

model= nn.Sequential(
    layer1,
    nn.ReLU(),
    nn.Linear(20, 10)
)
input_image = torch.rand(3, 28, 28)
flat_image = torch.flatten(input_image, 1)
logits = model(flat_image)
print(logits.size())

输出：

torch.Size([3, 10])

nn.Softmax

神经网络的最后一个线性层返回logits，即[-infty，infty]中的原始值。传递给nn.Softmax模块后Logit被缩放到[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: {name} | Size: {param.size()} | Values : {param[:2]} \n")

输出：

Model structure:  Sequential(
  (0): Linear(in_features=784, out_features=20, bias=True)
  (1): ReLU()
  (2): Linear(in_features=20, out_features=10, bias=True)
) 
Layer: 0.weight | Size: torch.Size([20, 784]) | Values : tensor([[-0.0051,  0.0191, -0.0078,  ...,  0.0297,  0.0003,  0.0119],
        [ 0.0199, -0.0015,  0.0123,  ...,  0.0246, -0.0186, -0.0233]],
       grad_fn=<SliceBackward>) 

Layer: 0.bias | Size: torch.Size([20]) | Values : tensor([-0.0164, -0.0271], grad_fn=<SliceBackward>) 

Layer: 2.weight | Size: torch.Size([10, 20]) | Values : tensor([[-0.0638,  0.1755, -0.1997,  0.2175, -0.1600,  0.1962, -0.1402,  0.1929,
          0.1777, -0.1201, -0.0058, -0.1411, -0.1511, -0.2150, -0.0510,  0.0787,
          0.1748, -0.1490,  0.0845,  0.1699],
        [-0.1805,  0.1027, -0.0136,  0.1523,  0.0340,  0.1504,  0.1901,  0.0319,
         -0.0958,  0.1084, -0.0722,  0.1249,  0.0636, -0.0300,  0.0080, -0.2206,
         -0.1310,  0.1211,  0.1141,  0.0883]], grad_fn=<SliceBackward>) 

Layer: 2.bias | Size: torch.Size([10]) | Values : tensor([-0.0429,  0.2105], grad_fn=<SliceBackward>) 

参考：
[1]https://pytorch.org/tutorials/beginner/basics/buildmodel_tutorial.html