动手学深度学习3.6-手动实现softmax回归

1,191 阅读3分钟

这是我参与11月更文挑战的第5天,活动详情查看:2021最后一次更文挑战

import torch
from IPython import display
from d2l import torch as d2l
batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

设定mini-batch的大小为256,读取数据集的迭代器。

num_inputs = 784
num_outputs = 10
#初始化为均值为0,方差为0.1的张量
W = torch.normal(0, 0.01, size=(num_inputs, num_outputs), requires_grad=True)
b = torch.zeros(num_outputs, requires_grad=True)
  • num_inputs数据集中图片28*28,通道数为1,将其转换为输入向量就是784
  • num_outputs输出是十个分类,输出向量为10
def softmax(X):
    X_exp = torch.exp(X)
    partition = X_exp.sum(1, keepdim=True) # 按照每行求和,保持维度不变
    return X_exp / partition  # 这里用到了广播机制

定义softmax

softmax(X)ij=exp(Xij)kexp(Xik).\mathrm{softmax}(\mathbf{X})_{ij} = \frac{\exp(\mathbf{X}_{ij})}{\sum_k \exp(\mathbf{X}_{ik})}.
def net(X):
    return softmax(torch.matmul(X.reshape((-1, W.shape[0])), W) + b)

定义模型。


def cross_entropy(y_hat, y):
    return - torch.log(y_hat[range(len(y_hat)), y])

定义交叉熵损失

l(y,y^)=j=1qyjlogy^j.l(\mathbf{y}, \hat{\mathbf{y}}) = - \sum_{j=1}^q y_j \log \hat{y}_j.
def accuracy(y_hat, y): 
    # y_hat维度>1并且多余一行
    if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
        y_hat = y_hat.argmax(axis=1) 
    cmp = y_hat.type(y.dtype) == y  
    return float(cmp.type(y.dtype).sum())

该函数用于计算并返回预测正确的数量。

  • argmax()取出最大元素对应的索引值,此时已经将y_hat转换成为最大元素索引值的向量
  • cmp是bool值,比较此时的y_hat和y,看预测的准确率
  • 最后将cmp的数据类型转换为y的数据类型,即将bool的true false转换为1 0,再求和计算出预测正确的总数并返回。
  • accuracy(y_hat, y) / len(y)除以y总数即可即求出准确率
class Accumulator:  
    """在`n`个变量上累加。"""
    def __init__(self, n):
        self.data = [0.0] * n # 初始化列表,长度为n

    def add(self, *args):
        self.data = [a + float(b) for a, b in zip(self.data, args)]

    def reset(self):
        self.data = [0.0] * len(self.data)

    def __getitem__(self, idx):
        return self.data[idx]

Accumulator类是实现一个累加器。每次叠加传入的数据。

  • *args的用法:当传入的参数个数未知,且不需要知道参数名称时
    • 因为不确定初始化长度为几,所以add的参数长度也不确定
    • 但是执行add的时候要保证传入参数的个数和n一样
def evaluate_accuracy(net, data_iter):
    if isinstance(net, torch.nn.Module):# 判断类型
        net.eval()  
    metric = Accumulator(2)  # 正确预测数、预测总数 共两个
    for X, y in data_iter:
        metric.add(accuracy(net(X), y), y.numel())
    return metric[0] / metric[1]

计算在指定数据集上模型的精度。

  • net.eval()将模型设置为评估模式
  • accuracy(net(X), y)计算正确的样本数
  • y.numel()样本总数

对每个batch评估并叠加,求整个的和。

def updater(batch_size):
    return d2l.sgd([W, b], lr, batch_size)

这个sgd是3.2里边手动实现的更新权重和参数的函数

def train_epoch_ch3(net, train_iter, loss, updater):  #@save
    """训练模型一个迭代周期(定义见第3章)。"""
    # 将模型设置为训练模式
    if isinstance(net, torch.nn.Module):
        net.train()
    # 训练损失总和、训练准确度总和、样本数
    metric = Accumulator(3)
    for X, y in train_iter:
        # 计算梯度并更新参数
        y_hat = net(X)
        l = loss(y_hat, y)
        if isinstance(updater, torch.optim.Optimizer):
            # 使用PyTorch内置的优化器和损失函数
            updater.zero_grad()
            l.backward()
            updater.step()
            metric.add(float(l) * len(y), accuracy(y_hat, y),
                       y.size().numel())
        else:
            # 使用定制的优化器和损失函数
            l.sum().backward()
            updater(X.shape[0])
            metric.add(float(l.sum()), accuracy(y_hat, y), y.numel())
    # 返回训练损失和训练准确率
    return metric[0] / metric[2], metric[1] / metric[2]

# ch3即第三章的训练函数
def train_ch3(net, train_iter, test_iter, loss, num_epochs, updater):  #@save
    """训练模型。"""
    for epoch in range(num_epochs):
        train_metrics = train_epoch_ch3(net, train_iter, loss, updater)
        test_acc = evaluate_accuracy(net, test_iter)
    train_loss, train_acc = train_metrics
    assert train_loss < 0.5, train_loss
    assert train_acc <= 1 and train_acc > 0.7, train_acc
    assert test_acc <= 1 and test_acc > 0.7, test_acc
  • assert :用于判断一个表达式,在表达式条件为 false 的时候触发异常
lr = 0.1
    
num_epochs = 10 
train_ch3(net, train_iter, test_iter, cross_entropy, num_epochs, updater)

里边本来有可视化结果,但是被我删掉了。