softmax回归的从零开始实现

一、创建数据集

从Fashion-MNIST数据集中引入创建数据,并设置数据迭代器的批量大小为256

import torch
from IPython import display
from d2l import torch as d2l
#batch_size=256,表明随机读取256张图片
batch_size = 256

# 返回训练集和测试集的迭代器
# load_data_fashion_mnist函数是在图像分类数据集中定义的一个函数,可以返回batch_size大小的训练数据集和测试数据集
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

  

二、初始化模型参数

1、原始数据集中的每个样本都是28*28的图像

2、在本书中,我们将展平每个图像,把它们看作长度为784的向量

3、在softmax回归中,我们输出与类别一样多。(因为我们的数据集有10个类别,所以网络输出的维度为10)

4、权重将构成一个 784×10 的矩阵,偏置将构成一个 1×10 的行向量。与线性回归一样,我们将使用正态分布初始化我们的权重 W,偏置初始化为0

num_inputs = 784 # 样本的长和宽都是28,将其展平为空间向量,长度变为784
num_outputs = 10 # 数据集类别,也是输出数


#size=(num_inputs, num_outputs);行数等于输入的个数,列数等于输出的个数
#requires_grad=True表明要计算梯度
#权重
#在这里W被定义为一个784*10的矩阵
W = torch.normal(0, 0.01, size=(num_inputs, num_outputs), requires_grad=True)

#偏离
b = torch.zeros(num_outputs, requires_grad=True)

  

三、定义softmax操作

# 定义softmax()函数

def softmax(X):
    #torch.exp()对每个元素做指数计算
    X_exp = torch.exp(X)
    
    #对矩阵的每一行求和,重新生成新的矩阵
    partition = X_exp.sum(1, keepdim=True)
    
    
    # X_exp / partition:每一行代表一个样本,行中的每个数据代表在该类别的概率
    return X_exp / partition  # 这里应用了广播机制

可以发现,每个元素都变成了一个非负数。此外,依据概率原理,每行总和为1。

如下,是个小测试

#创建一个随机的均值为0,方差为1的两行五列的矩阵
X = torch.normal(0, 1, (2, 5))

#对矩阵进行softmax计算
X_prob = softmax(X)

X_prob, X_prob.sum(1)
#通过输出可以发现在softmax之后,每个元素都是正的,且行之和为1

#输出结果

(tensor([[0.0474, 0.0313, 0.8646, 0.0317, 0.0250],
         [0.1736, 0.4575, 0.2832, 0.0618, 0.0239]]),
 tensor([1.0000, 1.0000]))

  

四、定义模型

1、利用之前实现的softmax操作,可以实现softmax回归模型

2、在将数据传递到模型之前,需要使用reshape函数将每张原始图像展平为向量

def net(X):
    #matmul是矩阵乘法
    #W.shape[0]=784
    
    # W是一个784*10的矩阵,W.shape就是[784,10]的列表,可以通过W.shape[0]来访问784
    return softmax(torch.matmul(X.reshape((-1, W.shape[0])), W) + b)

  

五、定义损失函数

y = torch.tensor([0, 2])

# y_hat为预测值,此次是对两个样本做预测值
y_hat = torch.tensor([[0.1, 0.3, 0.6], [0.3, 0.2, 0.5]])

# 对第零个样本,拿出y0的数据=0.1;对第一个样本,拿出y1的书籍,y1=2,就是拿出第三个数据=0.5
# 第一个参数[0,1]表示样本号,第二个参数y表示在第一个参数确定的样本中取数的序号
y_hat[[0, 1], y]

#输出结果

tensor([0.1000, 0.5000])

上诉可以帮助我们理解“交叉”的含义。接下来,我们只需要添加一行代码实现损失函数

# 给定我的y_hat预测和真实标号y
def cross_entropy(y_hat, y):
    #对于每一行range(len(y_hat)):生成一个从零开始一直到len(y_hat)的向量
    
    return -torch.log(y_hat[range(len(y_hat)), y])

print(cross_entropy(y_hat, y))
-torch.log(y_hat[[0, 1], y])
#输出:2.3026样本零的损失,0.6931样本1的损失


#输出结果

tensor([2.3026, 0.6931])
tensor([2.3026, 0.6931])

  

六、分类准确度

1、分类准确率即正确预测数量与总预测数量之比。

2、y_hat 是矩阵,假定第二个维度存储每个类的预测分数。

3、使用 argmax 获得每行中最大元素的索引来获得预测类别

4、将预测类别与真实 y 元素进行比较

# 计算分类准确率,正确预测数量与总预测数量之比
# y_hat是预测值,y是真实值

# 计算预测正确的样本数
def accuracy(y_hat, y):  #@save
    """计算预测正确的数量。"""
    # len是查看矩阵的行数
    # y_hat.shape[1]就是去列数,y_hat.
    if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
        #每一行中元素最大的那个下标存在y_hat里面
        #最大的元素就可以算为预测分类的类别
        y_hat = y_hat.argmax(axis=1)
        
    #将y_hat转换为y的数据类型然后作比较
    #使用cmp函数存储bool类型
    cmp = y_hat.type(y.dtype) == y
    
    #将cmp转化为y的数据类型再求和——得到找出来预测正确的类别数
    return float(cmp.type(y.dtype).sum())

5、按照之前定义的变量y_hat和y,我们预测准确率(第一个样本的预测类别是2(该行的最大元素为0.6,索引为2),这与实际标签0不一致。第二个样本的预测类别是2(该行的最大元素为0.5,索引为 2),这与实际标签2一致)

#除以整个y的长度(样本数),就是预测正确的概率
accuracy(y_hat, y) / len(y)

#输出结果

0.5

 6、泛化,对于任意数据迭代器data_iter 可访问的数据集,我们可以评估在任意模型 net 的准确率。

# 评估任意模型的准确率

def evaluate_accuracy(net, data_iter):  #@save
    """计算在指定数据集上模型的精度。"""
    
    
    # isinstance():判断一个对象是否是一个已知的类型
    # 判断输入的net模型是否是torch.nn.Module类型
    if isinstance(net, torch.nn.Module):
        net.eval()  # 将模型设置为评估模式(不用计算梯度)
        
    metric = Accumulator(2)  # 存储正确预测数、预测总数
    
    # 每次从迭代器中拿出一个x和y
    for X, y in data_iter:
        
        # 1、net(X):X放在net模型中进行softmax操作
        # 2、accuracy(net(X), y):再计算所有预算正确的样本数
        # numel()函数:返回数组中元素的个数,在此可以求得样本数
        metric.add(accuracy(net(X), y), y.numel())
        
    #metric[0]:分类正确的样本数,metric[1]:总的样本数
    return metric[0] / metric[1]

evaluate_accuracy(net, test_iter)

#输出结果
0.1001

  

七、训练

1、首先,我们定义一个函数来训练一个迭代周期

2、注意,updater是更新模型参数的常用函数,接受批量大小作为参数

def train_epoch_ch3(net, train_iter, loss, updater):  #@save
"""训练模型一个迭代周期(定义见第3章)。"""
# 将模型设置为训练模式 if isinstance(net, torch.nn.Module): net.train()#告诉pytorch我要计算梯度 # 训练损失总和、训练准确度总和、样本数 # Accumulator 是一个实用程序类,用于对多个变量进行累加 #在此创建了一个长度为三的迭代器,用于累加信息 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出来就是向量,我们先做求和,再求梯度 l.sum().backward() updater(X.shape[0]) metric.add(float(l.sum()), accuracy(y_hat, y), y.numel()) # 返回训练损失和训练准确率 # metric[0]就是损失样本数目;metric[1]是训练正确的样本数;metric[2]是总的样本数 return metric[0] / metric[2], metric[1] / metric[2]

3、实现一个训练函数,它会在train_iter 访问到的训练数据集上训练一个模型net

4、该训练函数将会运行多个迭代周期(由num_epochs指定)

def train_ch3(net, train_iter, test_iter, loss, num_epochs, updater):  #@save
    """训练模型(定义见第3章)。"""
    animator = Animator(xlabel='epoch', xlim=[1, num_epochs], ylim=[0.3, 0.9],
                        legend=['train loss', 'train acc', 'test acc'])
    
    
    # num_epochs:训练次数
    for epoch in range(num_epochs):
        #train_epoch_ch3:训练模型,返回准确度和错误度
        train_metrics = train_epoch_ch3(net, train_iter, loss, updater)
        #在测试数据集上评估精度
        test_acc = evaluate_accuracy(net, test_iter)
        
        animator.add(epoch + 1, train_metrics + (test_acc,))
    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

5、作为一个从零开始的实现,我们使用 小批量随机梯度下降来优化模型的损失函数,设置学习率为0.1

lr = 0.1

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

6、现在,训练模型10个迭代周期。请注意,迭代周期(num_epochs)和学习率(lr)都是可调节的超参数。通过更改它们的值,我们可以提高模型的分类准确率。

#开始训练
num_epochs = 10
train_ch3(net, train_iter, test_iter, cross_entropy, num_epochs, updater)

  

八、预测

给定一系列图像,比较它们的实际标签(文本输出的第一行)和模型预测(文本输出的第二行)

def predict_ch3(net, test_iter, n=6):  #@save
    """预测标签(定义见第3章)。"""
    for X, y in test_iter:
        break
    #真实标号
    trues = d2l.get_fashion_mnist_labels(y)
    #预测标号
    preds = d2l.get_fashion_mnist_labels(net(X).argmax(axis=1))
    titles = [true + '\n' + pred for true, pred in zip(trues, preds)]
    d2l.show_images(X[0:n].reshape((n, 28, 28)), 1, n, titles=titles[0:n])

predict_ch3(net, test_iter)
上一篇:四大域对象作用范围


下一篇:JAVA WEB_DAY23:tomcat目录说明,项目部署,idea关联tomcat,jsp介绍,脚本