Fashion-MNIST 分类

Fashion-MNIST 分类

构建和训练神经网络。 您将使用Fashion-MNIST数据集，它是MNIST数据集的替代品。 MNIST实际上对于神经网络来说是微不足道的，您可以轻松地获得优于97％的精度。 Fashion-MNIST是一组28x28灰度的衣服图像。 它比MNIST更复杂，因此可以更好地表示神经网络的实际性能，并且可以更好地表示您将在现实世界中使用的数据集。

在这里，您将构建自己的神经网络。

首先，让我们通过torchvision加载数据集。

import torch
from torchvision import datasets, transforms
import helper

# Define a transform to normalize the data
transform = transforms.Compose([transforms.ToTensor(),
                                transforms.Normalize((0.5,), (0.5,))])
# Download and load the training data
trainset = datasets.FashionMNIST('~/.pytorch/F_MNIST_data/', download=True, train=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)

# Download and load the test data
testset = datasets.FashionMNIST('~/.pytorch/F_MNIST_data/', download=True, train=False, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=True)

这是数据集中的一张图片。

image, label = next(iter(trainloader))
helper.imshow(image[0,:]);

建立神经网络

在这里，你需要定义神经网络。 与MNIST一样，每个图像均为28x28，共784个像素，共有10个类别。 您应该至少包括一个隐藏层。 我们建议你对层使用ReLU激活函数，并从正向传播中返回logits或log-softmax。 由你自己决定要添加多少层以及这些层的大小。

# TODO: Define your network architecture here
from torch import nn

model = nn.Sequential(nn.Linear(784,256),
                      nn.ReLU(),
                      nn.Linear(256,128),
                      nn.ReLU(),
                      nn.Linear(128,64),
                      nn.ReLU(),
                      nn.Linear(64,10),
                      nn.LogSoftmax(dim=1))
model

Sequential(
  (0): Linear(in_features=784, out_features=256, bias=True)
  (1): ReLU()
  (2): Linear(in_features=256, out_features=128, bias=True)
  (3): ReLU()
  (4): Linear(in_features=128, out_features=64, bias=True)
  (5): ReLU()
  (6): Linear(in_features=64, out_features=10, bias=True)
  (7): LogSoftmax()
)

训练神经网络

现在，您应该创建网络并对其进行训练。 首先，您需要定义损失函数（例如nn.CrossEntropyLoss）和优化（通常是optim.SGD或optim.Adam）。

然后编写训练的代码。 请记住，训练是一个相当简单的过程：

• 通过网络进行正向传播传递
• 使用网络输出来计算损失
• 使用loss.backward（）通过网络进行反向传播以计算梯度
• 使用优化器（Adam算法）更新权重

通过调整超参数（隐藏单位，学习率等），你可以通过训练，使损失低于0.3。

# TODO: Create the network, define the criterion and optimizer
from torch import optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(),lr=0.003)

# TODO: Train the network here
epochs = 50
for e in range(epochs):
    running_loss = 0
    for images,labels in trainloader:
        images = images.view(images.shape[0],-1)
        optimizer.zero_grad()
        output = model(images)
        loss = criterion(output,labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    else:
        print("Training loss: ",running_loss/len(trainloader))
        

Training loss:  0.513488266831522
Training loss:  0.39072016170665397
Training loss:  0.3529979697486231
''''''
Training loss:  0.14091059736617562
Training loss:  0.1484583015186287
Training loss:  0.13801704757987882

%matplotlib inline
%config InlineBackend.figure_format = 'retina'

import helper

# Test out your network!

dataiter = iter(testloader)
images, labels = dataiter.next()
img = images[0]
# Convert 2D image to 1D vector
img = img.resize_(1, 784)

# TODO: Calculate the class probabilities (softmax) for img
ps = torch.exp(model(img))

# Plot the image and probabilities
helper.view_classify(img.resize_(1, 28, 28), ps, version='Fashion')