多层感知机模型（PyTorch）

该例子具有单隐藏层结构，实际是添加了激活函数，引入了非线性变换

完整代码实现

import torch
from torch import nn
from torch.utils import data
from d2l import torch as d2l
import torchvision
from torchvision import transforms

# 导入数据
trains = transforms.ToTensor()
train_data = torchvision.datasets.FashionMNIST(root='D:\\PZL\\vscode\\python', train=True, transform=trains, download=False)
test_data = torchvision.datasets.FashionMNIST(root='D:\\PZL\\vscode\\python', train=False, transform=trains, download=False)

# 读数据
train_iter = data.DataLoader(train_data, batch_size=256, shuffle=True)
test_iter = data.DataLoader(test_data, batch_size=256, shuffle=True)

# 定义神经网络模型
net = nn.Sequential(nn.Flatten(), nn.Linear(784,256), nn.ReLU(), nn.Linear(256,10))# 这里加入了单隐藏层，该隐藏层的神经元个数为256个，激活函数采用ReLU
# 初始化参数
def init_weights(m):
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, std=0.01)
net.apply(init_weights)

# 定义损失函数
loss = nn.CrossEntropyLoss()

# 定义优化方法——随机梯度下降算法
trainer = torch.optim.SGD(net.parameters(), lr=0.1)

#训练
num_epochs = 10
for epoch in range(num_epochs):
    for data,target in train_iter:
        l = loss(torch.softmax(net(data),dim=1), target)
        trainer.zero_grad()
        l.backward()
        trainer.step()
    test_input = torch.tensor([x[0].tolist() for x in test_data])
    test_output = torch.tensor([x[1] for x in test_data])
    print('epoch:%d    loss:%f'%(epoch, loss(torch.softmax(net(test_input),dim=1),test_output)))


'''
epoch:0    loss:2.170353
epoch:1    loss:1.877583
epoch:2    loss:1.807206
epoch:3    loss:1.772729
epoch:4    loss:1.739437
epoch:5    loss:1.717637
epoch:6    loss:1.704781
epoch:7    loss:1.696982
epoch:8    loss:1.690583
epoch:9    loss:1.686729
'''