zoukankan      html  css  js  c++  java
  • 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 + '
    ' + 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)
  • 相关阅读:
    GPS坐标转化距离(短距离模型公式)
    jquery ajax 同步异步的执行
    视频播放的基本原理
    [css或js控制图片自适应]
    asp.net中js和jquery调用ashx的不同方法分享,需要的朋友可以参考一下
    [转载]在网页中插入media,RealPlayer等控件
    数组的几种排序算法的实现(3)
    -- HTML标记大全参考手册[推荐]
    数组的几种排序算法的实现(2)
    数组的几种排序算法的实现(1)
  • 原文地址:https://www.cnblogs.com/xiaoqing-ing/p/15067636.html
Copyright © 2011-2022 走看看