花书学习Day 3:实现多层感知机

在前一篇文章中，已经介绍了多层感知机，这篇文章我们来学习实现多层感知机，由于仍使用Fashion-MNIST数据集，其中隐藏层设置为256个隐藏单元（由于内存在硬件中的储存和寻址方式，一般选择2的n次幂为层的宽度），因此输入层为784256，隐藏层为25610，输出为10类。
其中，隐藏层的激活函数设置为ReLu函数。以下为未使用高级API的代码实现。

import torch
import torch.optim as optim
from torch import nn
if __name__ == "__main__":
    batch_size = 256
    train_iter, test_iter = load_data_fashion_mnist(batch_size)
    num_inputs = 784
    num_hidden = 256
    num_outputs = 10
    W1 = nn.Parameter(torch.randn(num_inputs, num_hidden, requires_grad=True) * 0.01)
    b1 = nn.Parameter(torch.zeros(num_hidden, requires_grad=True))
    W2 = nn.Parameter(torch.randn(num_hidden, num_outputs, requires_grad=True) * 0.01)
    b2 = nn.Parameter(torch.zeros(num_outputs, requires_grad=True))
    params = [W1, b1, W2, b2]
 
 
    def ReLu(X):
        a = torch.zeros_like(X)
        return torch.max(X, a)
 
    def net(X):
        X = X.reshape(-1, num_inputs)
        H = ReLu(torch.matmul(X, W1) + b1)
        return torch.matmul(H, W2) + b2
 
 
    loss = nn.CrossEntropyLoss()
    num_epochs = 10
    lr = 0.01
    updater = optim.SGD(params, lr)
    for num_epoch in range(num_epochs):
        for X, y in train_iter:
            y_hat = net(X)
            l = loss(y_hat, y)
            if isinstance(updater, torch.optim.Optimizer):
                updater.zero_grad()
                l.backward()
                updater.step()
            else:
                l.sum().backward()
                updater(X.shape[0])
    predict_ch3(net, test_iter, n=6)
    plt.show()

其中，读取数据集函数和测试函数如下所示：

def predict_ch3(net, test_iter, n=6):
    for X, y in test_iter:
        break
    trues = get_fashion_mnist_labels(y)
    preds = get_fashion_mnist_labels(net(X).argmax(axis=1))
    titles = [true + '\n' + pred for true, pred in zip(trues, preds)]
    show_images(X[0:n].reshape((n, 28, 28)),1, n, titles=titles[0:n])
 
def load_data_fashion_mnist(batch_size, resize=False): #@save
    trans=[transforms.ToTensor()]
    if resize:
        trans.insert(0, transforms.Resize(resize))
    trans = transforms.Compose(trans)
    mnist_train = torchvision.datasets.FashionMNIST(root='../data', train=True, transform=trans, download=True)
    mnist_test = torchvision.datasets.FashionMNIST(root='../data', train=False, transform=trans, download=True)
    return (data.DataLoader(mnist_train, batch_size, shuffle=True, num_workers=get_dataloader_workers()),
            data.DataLoader(mnist_test, batch_size, shuffle=False, num_workers=get_dataloader_workers()))
 
def show_images(imgs, numrows, num_cols, titles=None, scale=1.5): #@save
    figsize=(numrows * scale, num_cols * scale)
    _, axes = plt.subplots(numrows, num_cols, figsize=figsize)
    axes = axes.flatten()
    for i, (ax, img) in enumerate(zip(axes, imgs)):
        if torch.is_tensor(img):
            ax.imshow(img.numpy())
        else:
            ax.imshow(img)
        ax.axes.get_xaxis().set_visible(False)
        ax.axes.get_yaxis().set_visible(False)
        if titles:
            ax.set_title(titles[i])
    return axes

结果可视化：

接下来是调用高级API，并使用gpu加速。

import torch
from torch import nn
import torch.optim as optim
if __name__ == '__main__':
    batch_size = 256
    train_iter, test_iter = load_data_fashion_mnist(batch_size)
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    num_epochs = 10
    num_inputs = 784
    num_hidden = 256
    num_outputs = 10
    net = nn.Sequential(nn.Flatten(), nn.Linear(num_inputs, num_hidden), nn.ReLU(), nn.Linear(num_hidden, num_outputs))
    def init_weights(m):
        if type(m) == nn.Linear:
            nn.init.normal_(m.weight, std=0.01)
    net.apply(init_weights)
    net = net.to(device)
    loss = nn.CrossEntropyLoss()
    loss.to(device)
    updater = optim.SGD(net.parameters(), lr=0.01)
    for epoch in range(num_epochs):
        for X, y in train_iter:
            X = X.to(device)
            y = y.to(device)
            y_hat = net(X)
            l = loss(y_hat, y)
            updater.zero_grad()
            l.backward()
            updater.step()
    X_test, y_test = next(iter(test_iter))
    X_test = X_test.to(device)
    y_test = y_test.to(device)
    trues = get_fashion_mnist_labels(y_test)
    preds = get_fashion_mnist_labels(net(X_test).argmax(axis=1))
    titles = [true + '\n' + pred for true, pred in zip(trues, preds)]
    X_test = X_test.to(device='cpu')
    show_images(X_test[0:6].reshape((6, 28, 28)), 1, 6, titles=titles[0:6])
    plt.show()