PyTorch - 04 - 使用PyTorch簡潔實現softmax分類器

我的這篇博客：

softmax手動實現

是從零實現softmax回歸，以熟悉PyTorch和相關函數的定義。

現在利用PyTorch來實現softmax分類器， 加深印象。

import torch
from torch import nn
from torchvision.datasets import FashionMNIST
from torchvision.transforms import transforms
from torch.utils.data.dataloader import DataLoader

數據加載

FashionMNIST數據集的使用可以參考我的上一篇博客

batch_size = 256

root_dir = "./torchvision/data/"
train_set = FashionMNIST(root_dir, train=True, transform=transforms.ToTensor(), download=False)
test_set = FashionMNIST(root_dir, train=False, transform=transforms.ToTensor(), download=False)

train_iter = DataLoader(train_set, batch_size=batch_size, shuffle=True, num_workers=0)
test_iter = DataLoader(test_set, batch_size=batch_size, shuffle=False, num_workers=0)

得到的 train_iter, test_iter 形狀為\({R^{n*height*width*channel}=R^{256*28*28*1}}\)，n代表batch_size。

定義網絡

直接繼承 torch.nn.Module

num_inputs, num_outputs = 1*28*28, 10   # 輸入：一通道28*28的灰度圖像, 輸出：10個分類對應十個輸出
class linearNet(nn.Module):
    def __init__(self, num_inputs, num_outputs):
        super(linearNet, self).__init__()
        self.linear = nn.Linear(num_inputs, num_outputs)
    def forward(self, x):
        y = self.linear(x.view(x.shape[0], -1))
        return y

net = linearNet(num_inputs, num_outputs)

nn.init.normal_(net.linear.weight, 0, 0.01)  #初始化網絡參數權值
nn.init.constant_(net.linear.bias, 0.0)

loss = nn.CrossEntropyLoss()    #定義交叉熵損失函數,  這個方法集成了softmax計算
optimizer = torch.optim.SGD(net.parameters(), lr=0.1)   #優化器

訓練以及測試模型

# 測試集數據評估
def evaluate_accuracy(data_iter, net):
    acc_sum, n = 0.0, 0
    for X, y in data_iter:
        acc_sum += (net(X).argmax(dim=1) == y).float().sum().item()
        n += y.shape[0]
    return acc_sum / n


epochs = 5
def train_model(optimizer):
    for epoch in range(epochs):
        train_loss_sum, train_acc_sum, n = 0.0, 0.0, 0
        for inputs, y in train_iter:
            y_hat = net(inputs)
            cost = loss(y_hat, y).sum()

            optimizer.zero_grad()
            cost.backward()
            optimizer.step()

            train_loss_sum += cost.item()
            train_acc_sum += (torch.argmax(y_hat, dim=1) == y).float().sum().item()
            n += y.shape[0]
        test_acc = evaluate_accuracy(test_iter, net)
        print('epoch %d, loss %.4f, train acc %.4f, test acc %.4f' % (epoch + 1, train_loss_sum / n, train_acc_sum / n, test_acc))
train_model(optimizer)

epoch 1, loss 0.0031, train acc 0.7466, test acc 0.7916
epoch 2, loss 0.0022, train acc 0.8134, test acc 0.8001
epoch 3, loss 0.0021, train acc 0.8257, test acc 0.8193
epoch 4, loss 0.0020, train acc 0.8332, test acc 0.8049
epoch 5, loss 0.0019, train acc 0.8364, test acc 0.8254