文章目录
- 建立神经网络模型
- 获取用于训练的设备
- 定义神经网络类
- 调用模型处理数据
- 模型拆解
- torch.flatten
- nn.Linear
- nn.ReLU
- nn.Sequential
- nn.Softmax
- 模型参数
建立神经网络模型
神经网络由处理数据的层/模块组成。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
