《动手学深度学习+PyTorch》3.6softmax回归的从零开始实现 学习笔记

---

前言

Softmax回归也称多项或多类的Logistic回归，是Logistic回归在多分类问题上的推广。

---

一、训练集和测试集

使用上一节获取得到的数据集Fashion-MNIST。

二、步骤

1.引入库

import torch
import torchvision
import numpy as np
import sys
sys.path.append("..") # 为了导入上层目录的d2lzh_pytorch
from d2lzh_pytorch import *
import d2lzh_pytorch as d2l

2.读取数据

batch_size =256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

d2l.load_data_fashion_mnist(batch_size)

该函数相当于把上一讲所作任务集成在一个函数中。
本函数已保存在d2lzh包中

def load_data_fashion_mnist(batch_size, resize=None, root='~/Datasets/FashionMNIST')
    trans = []
    if resize:
        trans.append(torchvision.transforms.Resize(size=resize))	#因为resize=None所以不会执行这一步
    trans.append(torchvision.transforms.ToTensor())	#转化为tensor形式
    
    transform = torchvision.transforms.Compose(trans)	#读取图像
    mnist_train = torchvision.datasets.FashionMNIST(root=root, train=True, download=True, transform=transform)	#上一讲有说，下载训练集数据
    mnist_test = torchvision.datasets.FashionMNIST(root=root, train=False, download=True, transform=transform)	#上一讲有说，下载测试集数据
    
    if sys.platform.startswith('win'):
        num_workers = 0  # 0表示不用额外的进程来加速读取数据
    else:
        num_workers = 4	#设置4个进程读取数据
    train_iter = torch.utils.data.DataLoader(mnist_train, batch_size=batch_size, shuffle=True, num_workers=num_workers)
    test_iter = torch.utils.data.DataLoader(mnist_test, batch_size=batch_size, shuffle=False, num_workers=num_workers)

    return train_iter, test_iter  

以下是对第二个if语句的解释：
我们将在训练数据集上训练模型，并将训练好的模型在测试数据集上评价模型的表现。前面说过，mnist_train是torch.utils.data.Dataset的子类，所以我们可以将其传入torch.utils.data.DataLoader来创建一个读取小批量数据样本的DataLoader实例。
在实践中，数据读取经常是训练的性能瓶颈，特别当模型较简单或者计算硬件性能较高时。PyTorch的DataLoader中一个很方便的功能是允许使用多进程来加速数据读取。这里我们通过参数num_workers来设置4个进程读取数据。

3.初始化模型参数

num_inputs =784
num_outputs = 10

W = torch.tensor(np.random.normal(0, 0.01, (num_inputs,num_outputs)),
                 dtype=torch.float)
b = torch.zeros(num_outputs, dtype=torch.float)

W.requires_grad_(requires_grad=True)
b.requires_grad_(requires_grad=True)

4.定义模型

def softmax(X):
    X_exp = X.exp()
    partition = X_exp.sum(dim=1, keepdim=True)
    return X_exp / partition

def net(X):
    return softmax(torch.mm(X.view((-1, num_inputs)),W) + b)

X.exp()

返回e的X次方

X_exp.sum(dim=1, keepdim=True)

torch.sum()对输入的tensor数据的某一维度求和，一共两种用法
对其中同一列（dim=0）或同一行（dim=1）的元素求和，并在结果中保留行和列这两个维度（keepdim=True）。

.mm(）矩阵乘法 .view()重新定义矩阵的形状

5.定义损失函数

y_hat = torch.tensor([[0.1, 0.3, 0.6], [0.3, 0.2, 0.5]])
y = torch.LongTensor([0, 2])
y_hat.gather(1, y.view(-1, 1))

def cross_entropy(y_hat,y):
    return - torch.log(y_hat.gather(1, y.view(-1,1)))

.LongTensor()

转成longtensor类型

torch.gather(input, dim, index, out=None) → Tensor

返回的tensor的size与index的size一致。
dim用于指明index的元素值代表的维数。这个函数可以用来很方便地提取指定位置的元素。（提取房方阵，不是提取单个元素）

6.计算分类准确率

def accuracy(y_hat,y):
    return (y_hat.argmax(dim=1) == y).float().mean().item()

print(accuracy(y_hat, y))

.argmax(dim=1)

返回的是最大数的索引

.item()

python import torch x = torch.randn(2, 2) 
print(x) 
print(x[1,1])
print(x[1,1].item())

tensor([[ 0.4702,  0.5145],
        [-0.0682, -1.4450]]) 
tensor(-1.4450)
-1.445029854774475 

可以看出是显示精度的区别，item()返回的是一个浮点型数据，所以我们在求loss或者accuracy时，一般使用item()，而不是直接取它对应的元素x[1,1]。

# 本函数已保存在d2lzh_pytorch包中方便以后使用。该函数将被逐步改进：它的完整实现将在“图像增广”一节中描述
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

7.训练模型

num_epochs, lr = 4, 0.1
train_ch3(net, train_iter, test_iter, cross_entropy, num_epochs, batch_size, [W, b], lr)

train_ch3()已保存在d2lzh包中

def train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size, params=None, lr=None, optimizer=None):
    for epoch in range(num_epochs):
        train_l_sum, train_acc_sum, n = 0.0, 0.0, 0
        for X, y in train_iter:
            y_hat = net(X)
            l = loss(y_hat, y).sum()
            
            # 梯度清零
            if optimizer is not None:
                optimizer.zero_grad()
            elif params is not None and params[0].grad is not None:
                for param in params:
                    param.grad.data.zero_()
                    
            l.backward()
            if optimizer is None:
                sgd(params, lr, batch_size)
            else:
                optimizer.step()  # “softmax回归的简洁实现”一节将用到
                
            train_l_sum += l.item()
            train_acc_sum += (y_hat.argmax(dim=1) == y).sum().item()
            n += y.shape[0]
        test_acc = evaluate_accuracy(test_iter, net)
        print('epoch %d, loss %.4f, train acc %.3f, test acc %.3f'
              % (epoch + 1, train_l_sum / n, train_acc_sum / n, test_acc)) 
         

train_ch3(net, train_iter, test_iter, cross_entropy, num_epochs, batch_size, [W, b], lr)

net 模型
train_iter 训练数据
test_iter 测试数据
loss 损失值
num_epochs 训练循环次数
batch_size 批量大小
params=[W, b] 模型参数
lr 步长
optimizer=None

8.预测

X ,y = iter(test_iter).next()

true_labels = d2l.get_fashion_mnist_labels(y.numpy())
pred_labels = d2l.get_fashion_mnist_labels(net(X).argmax(dim=1).numpy())
titles = [true +'\n' + pred for true, pred in zip(true_labels, pred_labels)]

d2l.show_fashion_mnist(X[0:9], titles[0:9])

---

总结

《动手学深度学习+PyTorch》3.6softmax回归的从零开始实现 学习笔记