精华内容
下载资源
问答
  • softmax分类器
    千次阅读
    2021-10-23 20:48:59
    #-*- coding: utf-8 -*-
    import numpy as np
    
    def softmax_loss_naive(W, X, y, reg):
        """
        使用显式循环版本计算Softmax损失函数
        N表示:数据个数,D表示:数据维度,C:表示数据类别个数。
        Inputs:
        - W: 形状(D, C) numpy数组,表示分类器权重(参数).
        - X: 形状(N, D) numpy数组,表示训练数据.
        - y: 形状(N,) numpy数组,表示数据类标。
            其中 y[i] = c 意味着X[i]为第c类数据,c取值为[0,c)
        - reg: 正则化惩罚系数
        Returns  二元组(tuple):
        - loss,数据损失值
        - dW,权重W所对应的梯度,其形状和W相同
        """
        # 初始化损失值与梯度.
        loss = 0.0  
        dW = np.zeros_like(W)
        #############################################################################        
        #  任务:使用显式循环实现softmax损失值loss及相应的梯度dW 。                 #
        #  温馨提示: 如果不慎,将很容易造成数值上溢。别忘了正则化哟。               #
        #############################################################################
        # =============================================================================
        # 第一种
        # =============================================================================
        # num_train = X.shape[0]  # 获取训练样本数
        # num_class = W.shape[1]  # 获取分类总数
        # for i in range(num_train):  
        #     s = X[i].dot(W)  # (1, C) 每类的可能性
        #     scores = s - max(s)  # 关注最高分
        #     #使用指数函数,在不影响单调性的情况下,使相对得分更明显
        #     scores_E = np.exp(scores)  
        #     # 计算总得分
        #     Z = np.sum(scores_E)
        #     # 找到目标值
        #     score_target = scores_E[y[i]]
        #     # 计算出损失值
        #     loss += -np.log(score_target/Z)
        #     # 计算梯度值
        #     for j in range(num_class):
        #         if j == y[i]:
        #             dW[:, j] += -(1-scores_E[j]/Z)*X[i]
        #         else:
        #             dW[:, j] += X[i]*scores_E[j]/Z
        # # 使用平均损失,再引入正则化
        # loss = loss/num_train+0.5*reg*np.sum(W*W)
        # # 使用平均梯度,再引入正则化
        # dW = dW/num_train+reg*W
    
        # =============================================================================
        # 第二种
        # =============================================================================
        N = X.shape[0]  # 获取训练样本数
        C = W.shape[1]  # 获取分类总数
    
        result = X.dot(W)
        result -= np.max(result,axis=1,keepdims=True)#避免指数太大,导致计算太大,内存不够
    
        for i in range(N):
            # 计算函数值
            soft_max = np.exp(result[i][y[i]])/np.sum(np.exp(result[i]))
            # 计算出损失值
            loss += -np.log(soft_max)
    
            for j in range(C):
                
                if j==y[i]:
                    dW[:,j] += -X[i].T
                dW[:,j] += (X[i].T * np.exp(result[i][j])) / (np.sum(np.exp(result[i])))
    
        loss/= N
        loss += reg*np.sum(W*W)
        dW /= N
        dW += reg*2*W
        #############################################################################
        #                           结束编码                                        #
        #############################################################################
        return loss, dW
    
    
    def softmax_loss_vectorized(W, X, y, reg):
        """
        Softmax损失函数,使用矢量计算版本.
        输入,输出格式与softmax_loss_naive相同
        """
        # 初始化损失值与梯度
        loss = 0.0
        dW = np.zeros_like(W)
        #############################################################################
        # 任务: 不使用显式循环计算softmax的损失值loss及其梯度dW.                    #
        # 温馨提示: 如果不慎,将很容易造成数值上溢。别忘了正则化哟。                #
        #############################################################################
        # 训练样本数
        num_train = X.shape[0]
        # 计算函数值
        s = np.dot(X, W)
        # 关注最高分
        scores = s-np.max(s, axis=1, keepdims=True)
        # 使用指数函数来扩大相对比
        scores_E = np.exp(scores)
        # 求和得到总值
        Z = np.sum(scores_E, axis=1, keepdims=True)
        # 计算每一类的可能性
        prob = scores_E/Z
        # 真实标签标记
        y_trueClass = np.zeros_like(prob)
        y_trueClass[range(num_train), y] = 1.0
        # 计算损失值
        loss += -np.sum(y_trueClass*np.log(prob))/num_train+0.5*reg*np.sum(W*W)
        # 计算梯度
        dW += -np.dot(X.T, y_trueClass-prob)/num_train+reg*W
        #############################################################################
        #                          结束编码                                         #
        #############################################################################
        return loss, dW
    
    

    softmax.py

    #-*- coding: utf-8 -*-
    
    import numpy as np
    from random import shuffle
    from softmax_loss import *
    
    class Softmax(object):
        
        def __init__(self):
            self.W = None
            
        def train(self, X, y, learning_rate=1e-3, reg=1e-5, num_iters=100,
                batch_size=200, verbose=False):
            '''
            使用最小批量梯度下降算法训练Softmax分类器
    
            Parameters
            ----------
            X : TYPE
                数据
            y : TYPE
                数据类标
            learning_rate : TYPE, optional
                学习率. The default is 1e-3.
            reg : TYPE, optional
                权重衰减因子. The default is 1e-5.
            num_iters : TYPE, optional
                迭代次数. The default is 100.
            batch_size : TYPE, optional
                批大小. The default is 200.
            verbose : TYPE, optional
                是否显示中间过程. The default is False.
    
            Returns
            -------
            loss_history : TYPE
                DESCRIPTION.
    
            '''
            # 获得训练数据及维度
            num_train, dim = X.shape
            # 我们的计数是从0开始,因此10分类任务其y的最大值为9
            num_classes = np.max(y) + 1
            # 如果没有权重
            if self.W is None:
                # 随机初始化 W
                self.W = 0.001 * np.random.randn(dim, num_classes)
            # 储存每一轮的损失结果 W
            loss_history = []
            for it in range(num_iters):
                X_batch = None
                y_batch = None
                #########################################################################
                #                             任务:                                     #
                #     从训练数据 X 中采样大小为batch_size的数据及其类标,               #
                #     并将采样数据及其类标分别存储在X_batch,y_batch中                  #
                #        X_batch的形状为  (dim,batch_size)                              #
                #        y_batch的形状为  (batch_size)                                  #
                #     提示: 可以使用np.random.choice函数生成indices.                    #
                #            重复采样要比非重复采样快许多                               #
                #########################################################################
                # False表示不可以取相同数字
                indices = np.random.choice(num_train, batch_size, False)
                X_batch = X[indices, :]
                y_batch = y[indices]
                #########################################################################
                #                       结束编码                                        #
                #########################################################################
                # 计算损失及梯度
                loss, grad = self.loss(X_batch, y_batch, reg)
                loss_history.append(loss)
                # 更新参数
                #########################################################################
                #                       任务:                                           #
                #               使用梯度及学习率更新权重                                #
                #########################################################################
                self.W = self.W - learning_rate*grad 
                #########################################################################
                #                      结束编码                                         #
                #########################################################################
                if verbose and it % 500 == 0:
                    print('迭代次数 %d / %d: loss %f' % (it, num_iters, loss))
            return loss_history
        
        
        def predict(self, X):
            """
            使用已训练好的权重预测数据类标
            Inputs:
            - X:数据形状 (N,D) .表示N条数据,每条数据有D维
            Returns:
            - y_pred:形状为(N,) 数据X的预测类标,y_pred是一个长度维N的一维数组,
            每一个元素是预测的类标整数
            """
            y_pred = np.zeros(X.shape[0])
            ###########################################################################
            #                         任务:                                           #
            #              执行预测类标任务,将结果储存在y_pred                       #
            ###########################################################################
            # 找到可能性最高的类别作为预测分类
            y_pred = np.argmax(X.dot(self.W), axis=1)	
            ###########################################################################
            #                           结束编码                                      #
            ###########################################################################
            return y_pred
        
        
        def loss(self, X_batch, y_batch, reg):
            """
            Compute the loss function and its derivative. 
            Subclasses will override this.
    
            Inputs:
            - X_batch: A numpy array of shape (N, D) containing a minibatch of N
              data points; each point has dimension D.
            - y_batch: A numpy array of shape (N,) containing labels for the minibatch.
            - reg: (float) regularization strength.
    
            Returns: A tuple containing:
            - loss as a single float
            - gradient with respect to self.W; an array of the same shape as W
            """
            return softmax_loss_vectorized(self.W, X_batch, y_batch, reg)
        
    
    
    更多相关内容
  • Softmax分类器

    2021-01-20 02:18:33
    Softmax 函数用于多分类,他将多个神经元的输出的值映射到(0,1)区间内的一个值,,并且映射的所有值相加为1,这些值可以理解为输出的概率,输出概率较大的一般作为预测的值 计算公式 分子:fyi 表示第i个类别指数...
  • softmax分类器matlab代码3D 形状上独特区域的无监督检测 由 、 、 和 。 介绍 该存储库用于我们的 ACM 图形交易 (TOG) 2020 论文“”。 在本文中,我们提出了一种新的方法来学习和检测 3D 形状上的独特区域。 与以前...
  • softmax分类器简介

    2018-05-14 15:47:12
    softmax分类器简单的介绍,适合初学者快速了解softmax分类器的基本原理。
  • 使用keras架构基于多层感知的二分类softmax分类
  • softmax 分类器

    千次阅读 2018-07-17 21:45:10
    没有时间总结,先记下来。...(1)CS231n课程笔记翻译:线性分类笔记(下) https://zhuanlan.zhihu.com/p/21102293?refer=intelligentunit (2)cs231n-assignment1-SVM/Softmax/two-layer-nets梯度求解 ...

    1.从两个角度理解

    (1)信息论中交叉熵

    H ( p , q ) = − ∑ x p ( x ) l o g ( q ( x ) ) = H ( p ) + D K L ( p ∣ ∣ q ) H(p,q)=-\sum_xp(x)log(q(x))=H(p)+D_{KL}(p||q) H(p,q)=xp(x)log(q(x))=H(p)+DKL(pq)
    p是指真实的分布,q是估计的分布。式中 H ( p ) H(p) H(p)是真实分布的熵,当给定分布,熵就确定; D K L ( p ∣ ∣ q ) D_{KL}(p||q) DKL(pq)是相对熵。
    softmax分类器就是要最小化估计分类概率和真实分布之间的交叉熵。
    交叉熵用于评估两个分布的相似度。

    (2)概率的角度

    softmax函数 P ( y i ∣ x i , w ) = e f y i ∑ j e f j P(y_i|x_i,w)=\frac{e^{f_{y_i}}}{\sum_je^{f_j}} P(yixi,w)=jefjefyi
    给定输入 x i {x_i} xi和参数w,分配给正确分类标签的归一化概率。

    2. softmax在实际应用中的问题

    softmax函数中分子和分母都做指数运算,当数值很大的时候,会出现指数爆炸等问题。
    常用的处理方法是分子分母同时乘以一个常数C,
    e f y i ∑ j e f j = C e f y i C ∑ j e f j = e f y i + l o g C ∑ j e f j + l o g C \frac{e^{f_{y_i}}}{\sum_je^{f_j}}=\frac{Ce^{f_{y_i}}}{C\sum_je^{f_j}} = \frac{e^{f_{y_i}+logC}}{\sum_je^{f_j+logC}} jefjefyi=CjefjCefyi=jefj+logCefyi+logC
    C通常取值为 − m a x ( f j ) -max(f_j) max(fj),使最大的值为0.

    # python实现
     f -= np.max(f)
     p = np.exp(f)/np.sum(np.exp(f))
    

    3. 一个简单的示例

    pic1

    这里需要强调的是:最后的输出直接由权重上一层的输出+偏置求得,并没有经过sigmoid函数,所以上图输出结果是 [ − 2.85 , 0.86 , 0.28 ] [-2.85,0.86,0.28] [2.85,0.86,0.28]
    (1) 先求 e f j e^{f_j} efj,
    [ e − 0.285 , e 0.86 , e 0.28 ] = [ 0.058 , 2.36 , 1.32 ] [e^{-0.285},e^{0.86},e^{0.28}] = [0.058, 2.36, 1.32] [e0.285,e0.86,e0.28]=[0.058,2.36,1.32]
    (2) 求 ∑ j e f j \sum_je^{f_j} jefj
    e − 0.285 + e 0.86 + e 0.28 = 0.058 + 2.36 + 1.32 = 3.738 e^{-0.285}+e^{0.86}+e^{0.28} = 0.058+2.36+1.32=3.738 e0.285+e0.86+e0.28=0.058+2.36+1.32=3.738
    (3) 求输出概率
    P ( y 1 ∣ x 1 , w ) = e f y 1 ∑ j e f j = 0.058 3.738 = 0.016 P(y_1|x_1,w)=\frac{e^{f_{y_1}}}{\sum_je^{f_j}}=\frac{0.058}{3.738}=0.016 P(y1x1,w)=jefjefy1=3.7380.058=0.016
    P ( y 2 ∣ x 1 , w ) = e f y 2 ∑ j e f j = 2.36 3.738 = 0.631 P(y_2|x_1,w)=\frac{e^{f_{y_2}}}{\sum_je^{f_j}}=\frac{2.36}{3.738}=0.631 P(y2x1,w)=jefjefy2=3.7382.36=0.631
    P ( y 3 ∣ x 1 , w ) = e f y 3 ∑ j e f j = 1.32 3.738 = 0.0353 P(y_3|x_1,w)=\frac{e^{f_{y_3}}}{\sum_je^{f_j}}=\frac{1.32}{3.738}=0.0353 P(y3x1,w)=jefjefy3=3.7381.32=0.0353

    给一个类别的打分为 [ 1 , − 2 , 0 ] [1,-2,0] [1,2,0],softmax通过上述的计算,得到概率输出 [ 0.7 , 0.04 , 0.26 ] [0.7,0.04,0.26] [0.7,0.04,0.26]
    进一步考虑正则项的影响,假设惩罚使得得分的输出变为原来的 1 2 \frac{1}{2} 21,即 [ 1 , − 2 , 0 ] [1,-2,0] [1,2,0]=> [ 0.5 , − 1 , 0 ] [0.5,-1,0] [0.5,1,0]时,最终得到的输出为 [ 0.55 , 0.12 , 0.33 ] [0.55,0.12,0.33] [0.55,0.12,0.33]
    softmax分类器会使正确的分类获得更大的概率,使错误的分类得到更小的概率。

    (1)CS231n课程笔记翻译:线性分类笔记(下)
    https://zhuanlan.zhihu.com/p/21102293?refer=intelligentunit
    (2)cs231n-assignment1-SVM/Softmax/two-layer-nets梯度求解
    https://blog.csdn.net/pjia_1008/article/details/66972060
    (3)CS231n课程学习笔记(三)——Softmax分类器的实现
    https://blog.csdn.net/stalbo/article/details/79379078
    (4)斯坦福大学深度学习公开课cs231n学习笔记(9)softmax分类和神经网络分类代码实现
    https://blog.csdn.net/piaoxuezhong/article/details/78818572

    展开全文
  • Softmax深入理解[译] - AIUAI​www.aiuai.cnPytorch的交叉熵nn.CrossEntropyLoss在训练阶段,里面是内置...Softmax 是非线性函数,主要用于 multi-class classification 任务中分类器的输出端.import 2.Softmax 的数...
    Softmax深入理解[译] - AIUAI​www.aiuai.cn
    e57574de7def42e43416658fe5841ddd.png

    Pytorch的交叉熵nn.CrossEntropyLoss在训练阶段,里面是内置了softmax操作的,因此只需要喂入原始的数据结果即可,不需要在之前再添加softmax层。

    Softmax 是非线性函数,主要用于 multi-class classification 任务中分类器的输出端.

    ce20146e6eac8e09d75984f34e4b374c.png

    f2f1dbfbe26ecb4171120544bb94998b.png
    import numpy as np
    
    def softmax(x):
        exp_x = np.exp(x) # ps 下面结果中的e+01 是科学计数法  e+01 = 10
        #print(exp_x) # [2.20264658e+04 7.38905610e+00 2.35385267e+17 5.45981500e+01]
        sum_exp_x = np.sum(exp_x)
        sm_x = exp_x/sum_exp_x
        return sm_x
    
    x = np.array([10, 2, 40, 4])
    print(np.exp(1)) # 2.718281828459045
    print(softmax(x))
    # [9.35762297e-14 3.13913279e-17 1.00000000e+00 2.31952283e-16]

    2.Softmax 的数值稳定性

    #softmax 的概率值可以看出,当元素值范围非常大时,容易出现数值不稳定性.
    # 比如,修改上面向量的第三个元素值为 10000,并重新计算 softmax
    
    x = np.array([10, 2, 10000, 4])
    print(softmax(x))
    #[0.0,  0.0, nan,  0.0]
    
    #nan 表示 not-a-number,往往出现在过拟合(overflow) 和 欠拟和(underflow) 中. 
    #但是,Softmax 为什么会输出这样的结果呢?是不能得到向量的概率分布吗?
    # 答案: 一个非常大的数值的指数会是非常、非常大的值,如 , 导致过拟合.

    425df9a2aebacfe3aa965249632b0e49.png
    def softmax(x):
        max_x = np.max(x) # 最大值
        exp_x = np.exp(x - max_x)
        sum_exp_x = np.sum(exp_x)
        sm_x = exp_x/sum_exp_x
        return sm_x
    
    
    x = np.array([10, 2, 10000, 4])
    print(softmax(x)) #[0., 0., 1., 0.]
    # 可以看出,nan 问题解决了

    3. Log Softmax

    Softmax 计算的一个关键评估显示了指数计算和除法计算的模式. 是否可以简化这些计算呢?
    可以通过优化 log softmax 来代替. 其具有如下更优的特点:
      [1] - 数值稳定性
      [2] - log softmax 的梯度计算为加法计算,因为log(a/b)=log(a)-log(b)
      [3] - 除法和乘法计算被转换成加法,更少的计算量和计算成本
      [4] - log 函数是单调递增函数,可以更好的利用该特点.
    
    softmax 和 log softmax 的计算:
    x = np.array([10, 2, 10000, 4])
    print(softmax(x)) #[0., 0., 1., 0.]
    
    print(np.log(softmax(x))) #[-inf, -inf,   0., -inf]
    #回到数值稳定性问题,实际上,log softmax 数值欠拟合
    问题: 为什么会这样?  ---> 在对每个元素计算 log 计算时, log(0)是未定义的.

    4. Log-Softmax 变形

    a4302419917828202f0f2aaba2272d72.png
    import numpy as np
    
    def logsoftmax(x, recover_probs=True):
        # LogSoftMax Implementation
        max_x = np.max(x)
        exp_x = np.exp(x - max_x)
        sum_exp_x = np.sum(exp_x)
        log_sum_exp_x = np.log(sum_exp_x)
        max_plus_log_sum_exp_x = max_x + log_sum_exp_x
        log_probs = x - max_plus_log_sum_exp_x # 避免了数值不稳定,减少了计算量
    
        # Recover probs
        if recover_probs:
            exp_log_probs = np.exp(log_probs)
            sum_log_probs = np.sum(exp_log_probs)
            probs = exp_log_probs / sum_log_probs
            return probs
    
        return log_probs
    
    x = np.array([10, 2, 10000, 4])
    print(logsoftmax(x,recover_probs=False)) # [-9990. -9998.  0. -9996.]
    print(logsoftmax(x, recover_probs=True)) # [0. 0. 1. 0.]
    展开全文
  • 基于pytorch的softmax分类器

    千次阅读 2021-05-27 23:52:09
    本文在pytorch的框架下,基于softmax分类器的原理,给出softmax分类器的源码,实现图像的分类。结合代码阐述神经网络的搭建过程,用测试集检验神经网络的训练结果,最后在本文末给出全部代码。 二、softmax分类器的...

    一、概述
    本文在pytorch的框架下,基于softmax分类器的原理,给出softmax分类器的源码,实现图像的分类。结合代码阐述神经网络的搭建过程,用测试集检验神经网络的训练结果,最后在本文末给出全部代码。
    二、softmax分类器的搭建
    1、下载数据集

    import numpy as np
    import torch
    from torch.utils.data import DataLoader,Dataset
    from torchvision import transforms
    import gzip
    import os
    import torchvision
    import matplotlib.pyplot as plt
    import random
    #下载数据集
    mnist_train =torchvision.datasets.FashionMNIST(root='~/Datasets/FashionMNIST',train=True, download=True,transform=transforms.ToTensor())
    mnist_test =torchvision.datasets.FashionMNIST(root='~/Datasets/FashionMNIST',train=False, download=True, transform=transforms.ToTensor())
    

    2、导出数据
    导出训练集与测试集的数据

    #导出数据
    def load_data(data_folder, data_name, label_name):
        with gzip.open(os.path.join(data_folder,label_name), 'rb') as lbpath: # rb表示的是读取二进制数据
            y_train = np.frombuffer(lbpath.read(), np.uint8, offset=8)
    
        with gzip.open(os.path.join(data_folder,data_name), 'rb') as imgpath:
            x_train = np.frombuffer(imgpath.read(), np.uint8, offset=16).reshape(len(y_train), 28, 28)
        return (x_train, y_train)
    
    folder='D:/jupyter_data/FashionMNIST/raw'
    train_data_name="train-images-idx3-ubyte.gz"
    train_label_name="train-labels-idx1-ubyte.gz"
    test_data_name="t10k-images-idx3-ubyte.gz"
    test_label_name="t10k-labels-idx1-ubyte.gz"
    
    train_data, train_labels = load_data(folder, train_data_name, train_label_name)
    test_data, test_labels = load_data(folder, train_data_name, train_label_name)
    

    3、定义筛选小批量数据集的函数

    #筛选小批量数据集
    def Data_Iter(Data,Label,Batch_Size):
        index=list(range(len(Data)))
        random.shuffle(index)
        for i in range(0,len(index),Batch_Size):
            j=index[i:min(i+Batch_Size,len(Data))]
            yield torch.tensor(Data[j],dtype=torch.float),torch.tensor(Label[j])
    

    4、定义softmax分类函数

    #定义softmax分类函数
    def SoftMax(X):
        X_exp=X.exp()
        partition=X_exp.sum(dim=1,keepdims=True)
        return X_exp/partition
    

    5、定义样本标签

    #定义样本标签
    def Target_Function(num_outputs,batch_size,Label):
        Y=torch.zeros(batch_size,num_outputs,dtype=torch.float)
        for i in range(batch_size):
            Y[i,Label[i]]=1
        return Y
    

    6、定义交叉熵损失函数

    #定义交叉熵损失函数
    def cross_entropy(Y,Y_hat,Batch_Size):
        return -(Y*Y_hat.log()).sum()/Batch_Size
    

    7、初始化训练参数

    #初始化训练参数
    batch_size=200
    num_inputs=784
    num_outputs=10
    lr=0.03
    num_epochs=5
    w = torch.tensor(np.random.normal(0, 0.01, ((num_inputs,num_outputs))), dtype=torch.float,requires_grad=True)
    b = torch.tensor(np.zeros((batch_size,1)), dtype=torch.float,requires_grad=True)
    

    8、开始训练

    #开始训练
    for epoch in range(num_epochs):
        for data,label in Data_Iter(train_data,train_labels,batch_size):
            train_loss,train_acc,n=0.0,0.0,0
            #归一化图像数据
            x=data.reshape(batch_size,-1)/255
            #计算样本估计值
            y_hat=SoftMax(torch.mm(x, w) + b)
            #实际样本标签
            y=Target_Function(num_outputs, batch_size, np.array(label))
            #计算损失函数
            loss=cross_entropy(y,y_hat,batch_size)
            #求梯度
            loss.backward()
            #更新训练参数
            w.data-=lr*w.grad
            b.data-=lr*b.grad
            #梯度清零
            w.grad.data.zero_()
            b.grad.data.zero_()
            #计算小批量训练集误差
            l=cross_entropy(y,SoftMax(torch.mm(x, w) + b),batch_size)
            #计算训练集误差
            train_loss+=l
            #计算训练准确率
            val,indices=y_hat.max(dim=1)
            acc=(indices==label).float().sum()
            train_acc+=acc
            
            n+=batch_size
        print('loss= %.4f' % (train_loss/n),' ','accuracy= %.4f' % (train_acc/n))
    

    训练结果如下图所示:
    在这里插入图片描述
    9、预测
    利用测试集检验神经网络训练效果

    #预测
    text_labels = ['t-shirt', 'trouser', 'pullover', 'dress', 'coat', 'sandal', 'shirt', 'sneaker', 'bag', 'ankle boot']
    #定义图像显示函数
    def Show_Img(Img,True_Label,Pred_Label,Num):    
        for i in range(Num):
            plt.figure(figsize=(30,30))
            plt.subplot(1,Num,i+1)
            plt.imshow(Img[i])
            #消除每张图片自己单独的横纵坐标
            plt.xticks([])
            plt.yticks([])
            #添加label
            plt.title(text_labels[True_Label[i]]+'\n'+text_labels[Pred_Label[i]])
        plt.show()
    
    show_num=10
    for Img,true_l in Data_Iter(test_data,test_labels,batch_size):
        img=Img.reshape(batch_size,-1)/255
        #计算样本估计值
        l_hat=SoftMax(torch.mm(img, w) + b)
        value,pred_l=l_hat.max(dim=1)   
        Show_Img(Img,true_l,pred_l,show_num)
        break
    

    训练效果如下图所示:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    显然,softmax分类器的识别准确率较高,基本都能正确识别出来
    三、全部代码

    import numpy as np
    import torch
    from torch.utils.data import DataLoader,Dataset
    from torchvision import transforms
    import gzip
    import os
    import torchvision
    import matplotlib.pyplot as plt
    import random
    # #下载数据集
    # mnist_train =torchvision.datasets.FashionMNIST(root='~/Datasets/FashionMNIST',train=True, download=True,transform=transforms.ToTensor())
    # mnist_test =torchvision.datasets.FashionMNIST(root='~/Datasets/FashionMNIST',
    # train=False, download=True, transform=transforms.ToTensor())
    #导出数据
    def load_data(data_folder, data_name, label_name):
        with gzip.open(os.path.join(data_folder,label_name), 'rb') as lbpath: # rb表示的是读取二进制数据
            y_train = np.frombuffer(lbpath.read(), np.uint8, offset=8)
    
        with gzip.open(os.path.join(data_folder,data_name), 'rb') as imgpath:
            x_train = np.frombuffer(imgpath.read(), np.uint8, offset=16).reshape(len(y_train), 28, 28)
        return (x_train, y_train)
    
    folder='D:/jupyter_data/FashionMNIST/raw'
    train_data_name="train-images-idx3-ubyte.gz"
    train_label_name="train-labels-idx1-ubyte.gz"
    test_data_name="t10k-images-idx3-ubyte.gz"
    test_label_name="t10k-labels-idx1-ubyte.gz"
    
    train_data, train_labels = load_data(folder, train_data_name, train_label_name)
    test_data, test_labels = load_data(folder, train_data_name, train_label_name)
    #筛选小批量数据集
    def Data_Iter(Data,Label,Batch_Size):
        index=list(range(len(Data)))
        random.shuffle(index)
        for i in range(0,len(index),Batch_Size):
            j=index[i:min(i+Batch_Size,len(Data))]
            yield torch.tensor(Data[j],dtype=torch.float),torch.tensor(Label[j])
    #定义softmax分类函数
    def SoftMax(X):
        X_exp=X.exp()
        partition=X_exp.sum(dim=1,keepdims=True)
        return X_exp/partition
    #定义样本标签
    def Target_Function(num_outputs,batch_size,Label):
        Y=torch.zeros(batch_size,num_outputs,dtype=torch.float)
        for i in range(batch_size):
            Y[i,Label[i]]=1
        return Y
    #定义交叉熵损失函数
    def cross_entropy(Y,Y_hat,Batch_Size):
        return -(Y*Y_hat.log()).sum()/Batch_Size
    #初始化训练参数
    batch_size=200
    num_inputs=784
    num_outputs=10
    lr=0.03
    num_epochs=5
    w = torch.tensor(np.random.normal(0, 0.01, ((num_inputs,num_outputs))), dtype=torch.float,requires_grad=True)
    b = torch.tensor(np.zeros((batch_size,1)), dtype=torch.float,requires_grad=True)
    #开始训练
    for epoch in range(num_epochs):
        for data,label in Data_Iter(train_data,train_labels,batch_size):
            train_loss,train_acc,n=0.0,0.0,0
            #归一化图像数据
            x=data.reshape(batch_size,-1)/255
            #计算样本估计值
            y_hat=SoftMax(torch.mm(x, w) + b)
            #实际样本标签
            y=Target_Function(num_outputs, batch_size, np.array(label))
            #计算损失函数
            loss=cross_entropy(y,y_hat,batch_size)
            #求梯度
            loss.backward()
            #更新训练参数
            w.data-=lr*w.grad
            b.data-=lr*b.grad
            #梯度清零
            w.grad.data.zero_()
            b.grad.data.zero_()
            #计算小批量训练集误差
            l=cross_entropy(y,SoftMax(torch.mm(x, w) + b),batch_size)
            #计算训练集误差
            train_loss+=l
            #计算训练准确率
            val,indices=y_hat.max(dim=1)
            acc=(indices==label).float().sum()
            train_acc+=acc
            
            n+=batch_size
        print('loss= %.4f' % (train_loss/n),' ','accuracy= %.4f' % (train_acc/n))
    
    #预测
    text_labels = ['t-shirt', 'trouser', 'pullover', 'dress', 'coat', 'sandal', 'shirt', 'sneaker', 'bag', 'ankle boot']
    #定义图像显示函数
    def Show_Img(Img,True_Label,Pred_Label,Num):    
        for i in range(Num):
            plt.figure(figsize=(30,30))
            plt.subplot(1,Num,i+1)
            plt.imshow(Img[i])
            #消除每张图片自己单独的横纵坐标
            plt.xticks([])
            plt.yticks([])
            #添加label
            plt.title(text_labels[True_Label[i]]+'\n'+text_labels[Pred_Label[i]])
        plt.show()
    
    show_num=10
    for Img,true_l in Data_Iter(test_data,test_labels,batch_size):
        img=Img.reshape(batch_size,-1)/255
        #计算样本估计值
        l_hat=SoftMax(torch.mm(img, w) + b)
        value,pred_l=l_hat.max(dim=1)   
        Show_Img(Img,true_l,pred_l,show_num)
        break
    
    展开全文
  • softmax分类器

    2018-03-24 11:33:44
    softmax的输出(归一化的分类概率)损失函数:交叉熵损失(cross-entropy loss)其输入值是一个向量,向量中元素为任意实数的评分值输出一个向量,其中每个元素值在0到1之间,且所有元素之和为1...
  • 04 Softmax分类器

    2020-10-27 11:22:14
    Softmax分类器   我们处理多分类问题时,使用 SVM 输出的是一个得分值,但是得分值最后比来比去不是很直观。那么我们能不能将得分值进行转换,转换成一个概率值,如果一个新数据样本到达,如果属于某一个类别的...
  • 目前解决图像分类问题,比较流行的方法是卷积神经网络上。这种方法主要有两部分组成:一个是评分函数(score function),它是原始图像数据到类别分值的映射。...1.线性分类器1.线性分类器 2.理解线性分类...
  • 使用 Softmax 作为分类器解决 " 多分类(classification)" 问题;并对Logistic与Softmax比较进行简单的比较,概述了CrossEntropyLoss()函数,最后使用经典数据集:MNIST DataSet 利用PyTorch进行构建网络,相关资料...
  • 分类问题的输出应该是一个分布:即需要满足单个样本点概率≥0且样本点概率之和=1 softmax layer: 损失函数:Cross Entropy Exercise9-1:CrossEntropyLoss和NLLLoss的区别 CrossEntropyLoss的输入不要求进行Log...
  • 使用SOFTMAX分类器对已有的数据集进行分类
  • 多分类问题-MNIST数据集 Revision: Diabetes dataset ...多分类问题用SoftMax分类器要求输出的分类概率都大于0且总和为1,把输出经过sigmoid运算就可以。 Softmax Layer 定义 Example Loss
  • softmax分类器视频教程,希望能够学习者提供帮助,实现对softmax分类器知识的掌握与理解,为后续学习做好铺垫,实现softmax分类器的灵活运用
  • 简单的说,softmax函数会将输出结果缩小到0到1的一个值,并且所有值相加为1,cross-entropy一般再softmax函数求得结果后再用,
  • 参考链接: 上图可以很明显看出SVM和softmax(其实就是CE)损失函数的...2、对于sotamax分类器,先将每一输出值通过softmax函数归一化后转化成0和1之间的概率值,因为log函数在(0,1)之间时值为负,所以需要在损失函
  • 一. Softmax分类器        用SVM损失函数得出的只是一个个的分数,还要通过对比分数来分类。那么,如果直接输出结果为分类的概率,岂不是更好?        这里,给出了...
  • SVM和Softmax分类器比较

    千次阅读 2019-06-02 17:16:52
    ####参考: 作者:啊噗不是阿婆主 来源:CSDN ...1. SVM和Softmax分类器是最常用的两个分类器,Softmax...对于学习过二元逻辑回归分类器的读者来说,Softmax分类器就可以理解为逻辑回归分类器面对多个分类的一般化归纳...
  • 理论知识softmax函数如下:一个样本在C个类别的评分为z,可以看出z为一个向量。softmax函数对 进行压缩,输出一个向量,其中每个元素值在0到1之间,且所有元素之和为1。交叉熵定义如下: 为真实的分布, 为估计分布...
  • 训练一个 Softmax 分类器(Training a Softmax classifier)上一个笔记中我们学习了Softmax层和Softmax激活函数,在这个笔记中,你将更深入地了解Softmax分类,并学习如何训练一个使用了Softmax层的模型。回忆一下我们...
  • 本代码包括kmeans提取特征,词袋模型提取特征,并利用softmax训练分类器
  • 1.线性分类如果我们使用一个线性分类器去进行图像分类该怎么做呢?假设现在我们有一张$2\times2\times1$的图像(即图像大小为$2\times 2$,通道数为1),像素值见下:\[\begin{bmatrix} 56 & 231 \\ 24 &...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 50,444
精华内容 20,177
关键字:

softmax分类器

友情链接: TestHuangTu.zip