精华内容
下载资源
问答
  • 如何简单计算同期上升下降的百分比?
    千次阅读
    2020-12-19 20:16:11

    如何简单计算同期上升下降的百分比?

    234游戏网友 提出于 2019-07-24 01:19:36

    我的数学一直以来不太好,所以都有些不好意思提这个问了,但现在工作中有些要用到才行,所以,我想知道如何简单计算同期上升和下降的百分比?(因为我常常把同期上升与下降搞成占%多少...

    假设原来的数是a,现在的数是b,

    如果b>a,上升的百分数=[(b-a)/a]*100%;

    如果a>b,下降的百分数=[(a-b)/a]*100%.

    计算公式是:(现值-原值)/原值 x 100%

    这是变化率的计算,跟占多少不同,占多少是现值与总数的比值.如本月产量为1000,全年产量为20000,那么本月产量占全年的1000/20000=5%

    今年收入35000,去年28000,那么今年较去年上涨(35000-28000)/28000=25%

    本月收入2600,上月3400,那么本月较上月变化(2600-3400)/3400=-23.5%,也就是下降了23.5%

    计算公式是:(现值-原值)/原值 x 100%

    这是变化率的计算,跟占多少不同,占多少是现值与总数的比值。如本月产量为1000,全年产量为2

    (当年数-以前数)÷以前数×100%

    今年我收入了35000元,去年收入了28000,今年较去年上升了25%

    (35000-28000)/28000=25%

    又如这个月我收入了2600元,上个月我收入了3400元,这个月较上个月下降了23.5%

    (2600-3400)/3400=23.5%

    更多相关内容
  • 2019Q2公募基金计算机板块持仓跟踪:持仓比例环比下降1.2个百分点略超配,头部公司仓位稳固.pdf
  • 关于同比与环比,如果同期数为负数,或为0,如何计算同比增长?以及百分点pp的概念。

    关于同比与环比

    同比增长率=(本期数-同期数)/同期数*100%

    如果同期数为负数,如去年5月利润为-50,今年5月为100,如何计算同比增长?

    (100-(-50))/|-50| × 100% = 300%

    注:如果去年同期为负值,则除数取绝对值;如果除数为零,则同比表示出无效,一般用“-”表示。

    环比增长率=(本期数-上期数)/上期数*100%

    1、环比一般是用在月、日很少用在年上,主要是对比很短时间内涨幅程度,不过由于行业差异,比如旅游,会受到淡旺季影响;

    2、同比一般用在相邻两年,相同时间段内,查看涨幅程度,一般用在两年相同月份,很少用在两月相同日期。

    百分点

    增减百分比,是表述某一指标报告期水平比基期水平增加或减少的相对程度,是以百分比(%)表示的,其计算公式为: 增(减)速度(%)=某指标报告期数值-该指标基期数值该指标基期数值×100% 或 = 某指标报告期数值该指标基期数值×100%-100% 百分点则是百分比中相当于1%的单位,它是一个量词

    例如,工业总产值今年的增长速度为19%,去年的增长速度为6%,今年比去年的增长幅度提高了3个百分点(19%-16%)而不是说提高了3%。一般用3pp表示。

    展开全文
  • 课程作业原地址:CS231n Assignment 1 作业及整理:@林凡莉 && @Molly && @寒小阳 时间:2018年1月。 ... 1 任务 在这个练习里,我们将实现一个完全连接的神经网络分类器,然后用CIFAR-10数据集进行测试。...2 知识

    课程作业原地址:CS231n Assignment 1
    作业及整理:@林凡莉 && @Molly && @寒小阳
    时间:2018年1月。
    出处:http://blog.csdn.net/han_xiaoyang/article/details/79139395

    1 任务

    在这个练习里,我们将实现一个完全连接的神经网络分类器,然后用CIFAR-10数据集进行测试。

    2 知识点

    2.1 神经元

    要讲神经网络就得先从神经元开始说起,神经元是神经网络的基本单位,它的结构如下图所示:


    Neuron

    神经元不管它的名字有多逼格,它本质上不过是一个函数。就像每个函数都有输入和输出一样,神经元的输入是一个向量,里面包含了很多个 xi (图左边),输出的是一个值(图右边)。神经元在这个过程中只做了两件事:一是对输入向量做一次仿射变换(线性变化+平移, scaling+shift),用公式表示就是

    iwixi+b
    二是对仿射变换的结果做一次非线性变换,即
    f(iwixi+b)
    这里的f就叫做激活函数。权值 wi 和偏置项 b 是神经元特有的属性,事实上,不同神经元之间的差别主要就三点:权重值,偏置项,激活函数。总的来说,神经元的工作就是把所有的输入项xi与其对应的权值相乘求和,然后加上偏置项 b ,之后通过一个激活函数求得最终的值,即这个神经元的输出。

    激活函数有很多种,下面介绍一个叫sigmoid的激活函数:

    σ(x)=1/(1+ex)

    这个函数很有意思,它把任何一个属于值域R的实数转换成0到1之间的数,这使得概率的诠释变得可能。但是在训练神经网络的时候,它有两个问题,一是当输入的仿射变换值太大或者太小的时候,那f关于x的梯度值就为0,这不利于后面提到的反向传播算法中梯度的计算。第二个问题在于它的值不是中心对称的,这也导致梯度更新过程中的不稳定。Sigmoid的函数图像大概长下面这样:
    Sigmoid

    如果现在我们把实数1也放进输入的向量中得到 x⃗  ,把偏置项放进权值向量中得到 w⃗  ,那么包含sigmoid激活函数神经元的工作就可以简洁地表示为:

    y=sigmoid(w⃗ Tx⃗ )

    聪明的你或许已经看出来:既然sigmoid函数的输出可以诠释为在0到1间的概率值大小,那么,单个神经元其实就可以当作一个二类线性分类器来使用。也就是说,假设我们输入的是一个图像向量,将它乘以权重向量之后再通过sigmoid函数,如果得到的值如果大于0.5,那这幅图片就属于这个类别,否则就不是。

    实践中比较常用的是这个叫ReLU的激活函数:

    f(x)=max(0,x)

    这个函数把输入的x与0做比较,取两者中更大的那个作为函数的输出值。它的图像表示如下:
    ReLu
    ReLu在实践中被证明的优点是它在随机梯度下降法中收敛效果非常好,此外它的梯度值非常简单。但它的缺点也非常明显,就是当它的梯度为0的时候,这个神经元就相当于把从后面传过来的梯度值都变成了0,使得某些变量在梯度下降法法中不再变化。cs231n官网笔记里有关于不同激活函数的详细介绍,大家有兴趣可以看一下: http://cs231n.github.io/neural-networks-1/

    2.2 神经网络

    当我们把很多个神经元按照一定规则排列和连接起来,便得到了一个神经网络。如果网络中每层之间的神经元是两两连接的,这样的神经网络就叫做全连接神经网络(Fully-connected Neural Network)。下图展示了两个不同层数的全连接神经网络:
    Neural Networks

    图中的神经网络包含一个输入层(Input Layer)和输出层(Output Layer),中间的层叫隐藏层(Hidden Layer)。需要注意的是,输入层包含的并不是神经元,而是输入向量 x⃗  ,上图输入层中圆圈的表示方法其实有些误导。输出层在最后起的作用相当于一个多类分类器,实践中经常采用Softmax分类器。而中间的隐藏层,无论有多少层,隐藏层们在一起做的事情相当于输入向量特征的提取。

    现在我们从计算的角度来分析下一层神经网络到底在做什么。我们知道一个神经元做的事情是把一个向量变成一个标量,那当我们把很多个神经元排列起来变成一个神经网络层的时候,这个层输出的结果应该是跟层里神经元数目相当的很多个标量,把这些标量排列起来就成了向量。也就是说,一个神经网络层做的事情是把一个向量变成了另一个向量,这中间的计算过程无非就是矩阵运算再加一个激活函数。假设输入向量为 x⃗  ,矩阵和向量的乘法运算可以表示为 Wx⃗  ,这里的矩阵 W 是将层中的每一个神经元的转置权重向量wiT由上到下排列得到,就像这样:

    W=w⃗ T1w⃗ T2w⃗ T3w⃗ T4

    现在我们拿一个简单的例子来感受一下一个神经网络层在做的事情(图片来源于台湾李宏毅教授深度学习的课件):

    Screen Shot 2017-08-27 at 20.44.39.png-89.9kB

    图中的网络一共有四层,两个隐藏层,一个输入层和一个输出层,每个隐藏层中又包含两个神经元。假设输入为向量 [11] , 将隐藏层中每个神经元的权重都作为一行,那么第一个隐藏层的权重矩阵就是一个大小为2x2的矩阵(如图中黄色字体显示),权重矩阵与输入向量相乘再加上偏置向量得到的向量 [42] 是每个神经元对输入向量做仿射变换的结果,之后通过激活函数 σ 得到第一个隐藏层的输出 [0.980.12] 。输出向量里的0.98代表输入向量经过第一个神经元变换后得到的值,0.12输入向量通过第二个神经元后得到的值。之后隐藏层的运算可以以此类推。

    所以,把整个神经网络看出是一个函数,这个函数本质上就是一连串的矩阵运算再加上激活函数的非线性变换,下图很好地给出了多层神经网络的计算过程:
    Neural Network

    图中的 wi 是第i个隐藏层的权重矩阵, bi 该层的权重向量, ai 是该层的输出向量。输入向量x经过第一个隐藏层的变换得到 a1 ,经过第二个隐藏层得到 a2 ,直到最后一层得到输出向量y。

    值得一提的是,神经网络的层数以及每一层神经元个数的设计是一门艺术,更多的还是依靠不断地尝试和经验。目前人们发现,对于全连接网络,三层神经网络训练效果往往比较好。但是在使用卷积神经网络解决图像相关的问题时,层数越多,能对图片这种复杂的数据表示得更充分,往往训练效果会越好。

    2.3 反向传播算法

    训练神经网络的步骤跟我们之前训练SVM以及Softmax分类器一样:首先我们有很多个训练样本以及每个样本对应的分类标签,在确定一个模型之后(你可以使用SVM,Softmax或者神经网络),我们可以得到用模型参数表示的损失函数,之后的目标是使损失函数值最小的一组模型参数,参数的训练用的一般是梯度下降法。下图很好地总结了梯度下降法的步骤(同样来自于台湾李宏毅教授深度学习的课件):


    Gradient Descent

    第一步是随便确定一组参数值,神经网络里的参数是每个神经元的权重和偏置值,用向量 θ0 表示;第二步,计算损失函数在每一个参数上的偏导数,用梯度 L(θ0) 来表示; 第三步,用学习率和刚刚计算出来的梯度值更新第一组参数。之后重复这个步骤,直到参数值收敛。但神经网络中的参数量往往非常庞大,用这样的方法一个一个地去计算它们的梯度值效率很低,所以在这里我们的反向传播算法就登场了。

    反向传播算法是一个非常高效获得函数梯度的算法。我们首先来看一个简单的例子:


    bp

    上图右上角的计算图表示函数 f=(x+y)z 的计算过程,每一个节点表示一个运算,节点左边线上的数字为一个节点的输入值,节点右边线上的数字为通过节点运算之后的输出值。梯度的计算分为两个步骤:先是用正向传播从左向右计算出每个节点的输出值,接着用反向传播从右到左计算出函数输出值关于每个变量的导数。从图中可以看到,当给出x=-2,y=5,z=-4的时候,计算图输出的结果为-12。而图中线下的值表示的是导数,最右边的1是f对自己的导数,所以是1。而之后的-4是f对q的导数,也就是z值-4。想要求f对x的导数,需要用到链式法则。具体的公式在下图中可以看到:


    local gradient

    所以例子中f关于x的导数就是:

    fx=fqqx

    因为后者为1,所以 fx=fq=4

    这种计算梯度的方法其实是非常优雅的,因为你发现计算图中的每一个节点之间都是相互独立的,只要给一个节点输入,它就会独立地计算出输出值以及输出值关于输入值的梯度(local gradient),所以当你把很多个相互独立的节点组织成一张计算图,然后给它一个起始值,计算图就会在自动得出梯度值。

    理解了反向传播算法,我们回到神经网络的训练上。正如上面 f=(x+y)z 函数的计算图,我们的神经网络也是一个超大型的计算图,比如给出下图中的两层神经网络


    Neural Network

    我们可以画出该网络的计算图,如下图所示。需要注意的是,计算图里的原点并不表示一个神经元,它只是一种运算节点。为了保持跟神经网络的一致性,我将输入层也画了进去,但输入层里并没有任何运算,它的作用只是为下一层神经网络提供数据而已。因为一个神经网络层有很多个神经元,所以一层里会有很多个计算节点。图中下面的公式表示该层节点进行的运算。输出层之后的节点是softmax,这里需要把所有节点的输出值放进一个向量里作为softmax节点的输入,最终得到网络的损失值。


    cg

    有了计算图,我们现在就可以开始求梯度了。从右到左,损失函数是一个标量,所以,标量关于自身的导数是1;之后的softmax函数的梯度是:

    Lifk=pk?(yi=k)

    也就是说,在将输出向量归一化之后得到的概率值,除了正确类别对应的概率值要减去1,其他的都保持不变,得到的向量就会是损失值关于输出向量的梯度。之后根据链式法则,求得y关于w2,b2以及a的导数,再将它们分别乘以softmax的梯度就得到损失值关于w2,b2以及a的梯度了。这个做法跟我们上面在函数计算图中的求梯度方法是一样的,就是一步一步求回去。在具体训练的时候,我们往往会有很多个图像样本,它们是以矩阵的形式排列的,反向传播算法同样也适用这种情况,下图提供了一个总结:


    CP

    3 代码解析

    3.1 初始化代码

    
    # 导入模块和库
    import numpy as np
    import matplotlib.pyplot as plt
    
    from cs231n.classifiers.neural_net import TwoLayerNet
    
    from __future__ import print_function
    
    %matplotlib inline
    plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots 设置图表的默认大小
    plt.rcParams['image.interpolation'] = 'nearest'
    plt.rcParams['image.cmap'] = 'gray'
    
    
    # 自动加载外部的模块
    # see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython
    %load_ext autoreload
    %autoreload 2
    
    def rel_error(x, y):
        """ returns relative error """
        return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))

    3.2 加载测试数据

    我们将使用文件cs231n / classifiers / neural_net.py中的类TwoLayerNet来表示神经网络中的实例。网络参数存储在实例变量self.params中,其中关键字是字符串参数名称,值是numpy数组。下面,我们将初始化一个的测试数据和测试模型用来帮助神经网络的实现。

    
    #  创建一个小的网络和测试数据来检查你的实现。注意我们用了随机种子来帮助实现实验的可重复性
    
    input_size = 4
    hidden_size = 10
    num_classes = 3
    num_inputs = 5
    
    def init_toy_model():
        np.random.seed(0)
        return TwoLayerNet(input_size, hidden_size, num_classes, std=1e-1)
    
    def init_toy_data():
        np.random.seed(1)
        X = 10 * np.random.randn(num_inputs, input_size)
        y = np.array([0, 1, 2, 2, 1])
        return X, y
    
    net = init_toy_model()
    X, y = init_toy_data()

    3.3 前向传播:计算分值

    打开文件cs231n/classifiers/neural_net.py,找到你们的TwoLayerNet.loss这个方法。它的函数跟你在SVM和Softmax练习中写的损失函数非常相似:它需要数据和权重来计算分值和损失值以及参数的梯度。实现第一部分的向前传播算法。使用权重和偏置项来计算所有输入数据的分值。

    #插播neural.net.py文件中的第一部分代码
     z1 = X.dot(W1) + b1
     a1 = np.maximum(0, z1) 
     scores = a1.dot(W2) + b2
    #插播结束
    scores = net.loss(X)
    print('Your scores:')
    print(scores)
    print()
    print('correct scores:')
    correct_scores = np.asarray([
      [-0.81233741, -1.27654624, -0.70335995],
      [-0.17129677, -1.18803311, -0.47310444],
      [-0.51590475, -1.01354314, -0.8504215 ],
      [-0.15419291, -0.48629638, -0.52901952],
      [-0.00618733, -0.12435261, -0.15226949]])
    print(correct_scores)
    print()
    
    
    # 差值应该非常小,小于1e-7
    print('Difference between your scores and correct scores:')
    print(np.sum(np.abs(scores - correct_scores)))
    

    输出结果:

    Your scores:
    [[-0.81233741 -1.27654624 -0.70335995]
    [-0.17129677 -1.18803311 -0.47310444]
    [-0.51590475 -1.01354314 -0.8504215 ]
    [-0.15419291 -0.48629638 -0.52901952]
    [-0.00618733 -0.12435261 -0.15226949]]
    correct scores:
    [[-0.81233741 -1.27654624 -0.70335995]
    [-0.17129677 -1.18803311 -0.47310444]
    [-0.51590475 -1.01354314 -0.8504215 ]
    [-0.15419291 -0.48629638 -0.52901952]
    [-0.00618733 -0.12435261 -0.15226949]]
    Difference between your scores and correct scores:3.68027207459e-08

    3. 前向传播:计算损失值

    在同一个函数中,实现第二部分中的数据和正则化损失值

    #插播neural.net.py文件中的第二部分代码
    exp_scores = np.exp(scores)
    probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True)
    #插播结束
    loss, _ = net.loss(X, y, reg=0.05)
    correct_loss = 1.30378789133
    
    
    # 应该非常小,小于1e-12
    print('Difference between your loss and correct loss:')
    print(np.sum(np.abs(loss - correct_loss)))

    输出结果:

    Difference between your loss and correct loss:
    0.0189654196061

    3.4 反向传播

    实现函数中剩下的部分,计算关于变量W1,b1,W2和b2的损失梯度。如果你已经正确实现了前向传播,那么你现在就可以通过数值梯度检查的方法来调试你的反向传播。

    # 插播neural.net.py文件中的第三部分代码
    # 计算分值的梯度
    dscores = probs
    dscores[range(N),y] -= 1
    dscores /= N
    
    # W2 和 b2
    grads['W2'] = np.dot(a1.T, dscores)
    grads['b2'] = np.sum(dscores, axis=0)
    
    # 反向传播里第二个隐藏层
    dhidden = np.dot(dscores, W2.T)
    
    # 激活函数ReLu的梯度
    dhidden[a1 <= 0] = 0
    
    # 关于W1和b1的梯度
    grads['W1'] = np.dot(X.T, dhidden)
    grads['b1'] = np.sum(dhidden, axis=0)
    
    # 加上正则化梯度的部分
    grads['W2'] += reg * W2
    grads['W1'] += reg * W1
    #插播结束
    from cs231n.gradient_check import eval_numerical_gradient
    
    
    # 使用数值梯度法检查反向传播的实现。如果你的实现正确的话,每一个W1,W2,b1和b2的分析梯度和数值梯度之间的差值应该小于1e-8
    loss, grads = net.loss(X, y, reg=0.05)
    
    
    # 这些都应该小于1e-8
    for param_name in grads:
        f = lambda W: net.loss(X, y, reg=0.05)[0]
        param_grad_num = eval_numerical_gradient(f, net.params[param_name], verbose=False)
        print('%s max relative error: %e' % (param_name, rel_error(param_grad_num, grads[param_name])))
    

    输出结果:

    W1 max relative error: 4.090896e-09
    W2 max relative error: 3.440708e-09
    b2 max relative error: 4.447646e-11
    b1 max relative error: 2.738421e-09

    3.5 训练神经网络

    跟SVM和Softmax分类器类似,我们将使用随机梯度下降法训练我们的神经网络。查看TwoLayerNet里的train函数,在相应的地方补充训练过程的代码。这个跟你在训练SVM和Softmax分类器的时候应该很相似。然后你还需要完成predict这个函数,这样在训练过程中,可以记录下预测正确率。

    完成了这个代码之后,用下面的代码在你的测试数据上训练两层神经网络。你应该会得到一个小于0.2的损失值。

    #下面插播neural.net.py文件里train函数的缺失代码
    sample_indices = np.random.choice(np.arange(num_train), batch_size)
    X_batch = X[sample_indices]
    y_batch = y[sample_indices]
    ##########################################
    self.params['W1'] += -learning_rate * grads['W1']
    self.params['b1'] += -learning_rate * grads['b1']
    self.params['W2'] += -learning_rate * grads['W2']
    self.params['b2'] += -learning_rate * grads['b2']
    
    #下面是neural.net.py文件里predic函数的代码
    z1 = X.dot(self.params['W1']) + self.params['b1']
    a1 = np.maximum(0, z1) # pass through ReLU activation function
    scores = a1.dot(self.params['W2']) + self.params['b2']
    y_pred = np.argmax(scores, axis=1)
    #插播结束
    net = init_toy_model()
    stats = net.train(X, y, X, y,
    learning_rate=1e-1, reg=5e-6,
    num_iters=100, verbose=False)
    
    print('Final training loss: ', stats['loss_history'][-1])
    
    
    # 画出迭代过程的损失值变化图像
    plt.plot(stats['loss_history'])
    plt.xlabel('iteration')
    plt.ylabel('training loss')
    plt.title('Training Loss history')
    plt.show()

    输出结果:
    Loss

    3.6 加载CIFAR-10图像数据

    现在你已经成功实现了一个通过梯度检查并在测试数据集上工作的两层神经网络,现在是时候在我们最受欢迎的CIFAR-10数据集上训练模型了。

    from cs231n.data_utils import load_CIFAR10
    
    def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000):
        """
        Load the CIFAR-10 dataset from disk and perform preprocessing to prepare
        it for the two-layer neural net classifier. These are the same steps as
        we used for the SVM, but condensed to a single function.  
        """
    
        # 加载CIFAR-10数据
        cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'
        X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)
    
    
        # 从数据集中取数据子集用于后面的练习
        mask = list(range(num_training, num_training + num_validation))
        X_val = X_train[mask]
        y_val = y_train[mask]
        mask = list(range(num_training))
        X_train = X_train[mask]
        y_train = y_train[mask]
        mask = list(range(num_test))
        X_test = X_test[mask]
        y_test = y_test[mask]
    
    
        # 标准化数据:先求平均图像,再将每个图像都减去其平均图像
        mean_image = np.mean(X_train, axis=0)
        X_train -= mean_image
        X_val -= mean_image
        X_test -= mean_image
    
    
        # 将所有的图像数据都变成行的形式
        X_train = X_train.reshape(num_training, -1)
        X_val = X_val.reshape(num_validation, -1)
        X_test = X_test.reshape(num_test, -1)
    
        return X_train, y_train, X_val, y_val, X_test, y_test
    
    
    # 调用该函数以获取我们需要的数据,查看数据集的大小
    X_train, y_train, X_val, y_val, X_test, y_test = get_CIFAR10_data()
    print('Train data shape: ', X_train.shape)
    print('Train labels shape: ', y_train.shape)
    print('Validation data shape: ', X_val.shape)
    print('Validation labels shape: ', y_val.shape)
    print('Test data shape: ', X_test.shape)
    print('Test labels shape: ', y_test.shape)
    

    输出结果:

    Train data shape: (49000, 3072)
    Train labels shape: (49000,)
    Validation data shape: (1000, 3072)
    Validation labels shape: (1000,)
    Test data shape: (1000, 3072)
    Test labels shape: (1000,)

    3.7 训练神经网络

    我们将使用包含momentum的随机梯度下降法来训练我们的神经网络。此外,每一次迭代之后,我们都学习率乘以递减率,所以我们的学习率会在优化的进程中成指数化递减。

    input_size = 32 * 32 * 3
    hidden_size = 50
    num_classes = 10
    net = TwoLayerNet(input_size, hidden_size, num_classes)
    
    
    # 训练网络
    stats = net.train(X_train, y_train, X_val, y_val,
                num_iters=1000, batch_size=200,
                learning_rate=1e-4, learning_rate_decay=0.95,
                reg=0.25, verbose=True)
    
    
    # 在验证集上进行预测
    val_acc = (net.predict(X_val) == y_val).mean()
    print('Validation accuracy: ', val_acc)

    输出结果:

    iteration 0 / 1000: loss 2.302762
    iteration 100 / 1000: loss 2.302358
    iteration 200 / 1000: loss 2.297404
    iteration 300 / 1000: loss 2.258897
    iteration 400 / 1000: loss 2.202975
    iteration 500 / 1000: loss 2.116816
    iteration 600 / 1000: loss 2.049789
    iteration 700 / 1000: loss 1.985711
    iteration 800 / 1000: loss 2.003726
    iteration 900 / 1000: loss 1.948076
    Validation accuracy: 0.287

    3.8 调试训练结果

    用我们提供的默认参数,你将在验证集上获得0.29的验证准确率。这还不够好。
    了解错误的一个策略是绘制损失函数值以及在优化过程中训练集和验证集之间的准确性。
    另一个策略是可视化在第一层神经网络中学到的权重。在大多数用视觉数据训练得到的神经网络中,第一层网络的权重通常会在可视化时显示出一些可见结构。

    
    # 绘制损失值
    plt.subplot(2, 1, 1)
    plt.plot(stats['loss_history'])
    plt.title('Loss history')
    plt.xlabel('Iteration')
    plt.ylabel('Loss')
    
    plt.subplot(2, 1, 2)
    plt.plot(stats['train_acc_history'], label='train')
    plt.plot(stats['val_acc_history'], label='val')
    plt.title('Classification accuracy history')
    plt.xlabel('Epoch')
    plt.ylabel('Clasification accuracy')
    plt.show()

    输出结果:
    loss fu nc

    from cs231n.vis_utils import visualize_grid
    
    
    # 可视化网络的权重
    def show_net_weights(net):
        W1 = net.params['W1']
        W1 = W1.reshape(32, 32, 3, -1).transpose(3, 0, 1, 2)
        plt.imshow(visualize_grid(W1, padding=3).astype('uint8'))
        plt.gca().axis('off')
        plt.show()
    show_net_weights(net)

    输出结果:
    Result

    3.9 调试你的超参数

    哪里出错了?仔细看上面可视化的结果,我们看到损失值几乎是线性减少,这意味着我们的学习率可能设定得太低了。

    此外,训练和验证准确率之间没有差距,表明我们使用的模型容量低,我们需要增加它的容量。另一方面,模型如果非常大的话,我们也将会看到更多的过拟合,这将在训练和验证准确率之间表现出很大的差距。

    调参。调整超参数并且培养超参数是如何影响最终结果的直觉是训练神经网络的重要组成部分,因此我们希望你多尝试多实践。接下来,你将试验超参数的不同的值,包括隐藏层大小,学习率,训练次数和正则化强度。你也可以考虑调整学习率衰减参数,但你用默认值应该也能获得非常好的性能。
    大概的结果。你的目标应该是在验证集上取得超过48%的分类准确度。我们最好的网络在验证集上的准确率超过了52%。

    实验:你在本练习中的目标是使用全连接神经网络,尽可能地在CIFAR-10数据集中获得最好的分类结果。对于任何在测试集上获得超过52%结果的,每超出1%就会得到一分额外的奖励。大胆去实践你的技术吧(例如用PCA以降低维度,或添加dropout或向分类器添加其它feature等)。

    best_net = None # store the best model into this 
    #将最好的模型放进这里
    
    
    # 使用验证集调整超参数。在best_net变量中存储最好模型的模型参数。为了帮助调试你的网络,使用类似于上面用过的可视化方法可能会有帮助; 这里的可视化结果与上面调试较差的网络中得到的可视化结果会有显著的质的差异。
    手动调整超参数可能很有趣,但你可能会发现编写代码自动扫描可能的超参数组合会更有用,就像我们在之前的练习中做的一样。
    best_val = -1
    best_stats = None
    learning_rates = [1e-2, 1e-3]
    regularization_strengths = [0.4, 0.5, 0.6]
    results = {} 
    iters = 2000 #100
    for lr in learning_rates:
        for rs in regularization_strengths:
            net = TwoLayerNet(input_size, hidden_size, num_classes)
    
            # Train the network
            stats = net.train(X_train, y_train, X_val, y_val,
                        num_iters=iters, batch_size=200,
                        learning_rate=lr, learning_rate_decay=0.95,
                        reg=rs)
    
            y_train_pred = net.predict(X_train)
            acc_train = np.mean(y_train == y_train_pred)
            y_val_pred = net.predict(X_val)
            acc_val = np.mean(y_val == y_val_pred)
    
            results[(lr, rs)] = (acc_train, acc_val)
    
            if best_val < acc_val:
                best_stats = stats
                best_val = acc_val
                best_net = net
    
    # Print out results.
    for lr, reg in sorted(results):
        train_accuracy, val_accuracy = results[(lr, reg)]
        print ("lr ",lr, "reg ", reg, "train accuracy: ", train_accuracy, "val accuracy: ", val_accuracy)
    
    print ("best validation accuracy achieved during cross-validation: ", best_val)
    #################################################################################
    #                               END OF YOUR CODE                                #
    #################################################################################

    输出结果:

    lr 0.001 reg 0.4 train accuracy: 0.516408163265 val accuracy: 0.48
    lr 0.001 reg 0.5 train accuracy: 0.53006122449 val accuracy: 0.479
    lr 0.001 reg 0.6 train accuracy: 0.520591836735 val accuracy: 0.497
    lr 0.01 reg 0.4 train accuracy: 0.100265306122 val accuracy: 0.087
    lr 0.01 reg 0.5 train accuracy: 0.100265306122 val accuracy: 0.087
    lr 0.01 reg 0.6 train accuracy: 0.100265306122 val accuracy: 0.087
    best validation accuracy achieved during cross-validation: 0.497

    
    # 可视化最好的神经网络的权重
    show_net_weights(best_net)

    输出结果:
    Screen Shot 2017-08-17 at 01.03.53.png-257.1kB

    3.10 在测试集上测试

    在调试完你的参数之后,你应该在测试集上测试你训练出的神经网络。你应该得到超过48%的准确率。每高于52%一个百分点,我们都将给予一分额外的分数奖励。

    test_acc = (best_net.predict(X_test) == y_test).mean()
    print('Test accuracy: ', test_acc)

    输出结果:

    Test accuracy: 0.474

    展开全文
  • 为什么扩大数据集可能导致分类效果下降

    千次阅读 多人点赞 2020-08-09 23:31:53
    本文目录0. 说明1. 问题背景2. 原因分析2.1 有没有可能是因为新数据的...最近在做一个文本分类任务,遇到一个现象:在扩大了数据集之后,模型的分类准确率反而下降了,比较严重一个模型是下降了7个百分点左右。 这很违

    0. 说明

    • 由于是商业项目,一些数据不方便公开,但不影响文中列出的结果&结论,请谅解;
    • 若发现问题,或者有任何问题想交流,欢迎留言哦~

    1. 问题背景

    最近在做一个文本分类任务,遇到一个现象:在扩大了数据集之后,模型的分类准确率反而下降了,比较严重一个模型是下降了7个百分点左右。

    这很违反直觉,因为在保证数据质量的前提下,正常来说,数据集变大,模型应该能对噪声越不敏感,泛化性能更佳。

    2. 原因分析

    2.1 有没有可能是因为新数据的标签不够准确?

    这是我第一个冒出来的念头。但是,其一,数据扩增的方法,是依赖于原始数据中存在的某中唯一性映射关系,对某些缺少标签的数据进行自动标注;其二,人工观察新增的case,与原始数据在标签准确度上并无明显区别。那可能是什么原因呢?

    2.2 是不是因为数据分布发生了变化?

    为了验证这个想法,我统计了原始数据A、新增数据B、以及合并后总体数据C的标签分布,然后用余弦相似度计算两两分布之间的相似程度。由于项目需要,同时存在多个数据集(基于此训练了多个分类器),因此我可以对比多个数据集之间的情况。

    结果表明,分类效果下降越厉害的数据集,其数据扩增前后的分布的相似程度也越低(即原始数据A和合并后总体数据C间的余弦相似度越低),并且总体数据分布C总是比原始数据分布A更加均衡。

    这似乎说明了数据分布的变化,是导致模型准确率下降的主要原因。但是,数据分布变化为什么会导致模型性能下降?数据量变大不能抵消这种下降吗?

    3. 举个栗子

    我们来玩一个游戏:假设有一个不透明的箱子,其中装有红绿蓝三种球,红 绿 蓝 球数分别为 98:1:1,这三种球唯一去区别是重量区间不一样。在开始游戏之前,给了几分钟时间,可以随意拿球掂量体验一下。现在游戏开始,让你从中摸一个球,并且猜是红绿蓝哪个颜色,你会怎么猜?我想,只要不傻,直接盲猜红色,至少也有98%的准确率。似乎,你已经摸透了三种球在手中的分量,已经找到了规律。

    实际上,三种球的真正规律可能是,红色球重量克数在 [100, 105) 区间,绿色球和蓝色球的重量克数分别在[95, 100), [90, 95) 区间,但是这个规律你并不知道。

    后来游戏升级了,我们往箱子中加入了 2 个红色球,以及绿色、蓝色球各 99 个,这样,箱子中就有了红绿蓝三种球各 100 个了。这时候,又给你几分钟时间,可以拿些新加入的球体验一下,然后继续游戏:让你从中摸一个球,并且猜是红绿蓝哪个颜色,你会怎么猜?

    也许,你已经发现了规律并且总是能区分出红色球和蓝色球之间较大的重量差距,但是在红色球和绿色球之间(100克上下)、以及绿色球和蓝色球之间(95克上下),似乎有点难区分。因此,假设你摸到一个球之后,总是能排除掉它是红色球(或蓝色球)的可能,然后在剩下的两个颜色里随机选一个,这样,你的准确率大概就是 50%。

    这个游戏只是一个理想化的假设,计算出来的准确率是在假设下得到的,但这不妨碍我们理解。正常情况下,红绿蓝三种球各 100 个时的游戏难度是更高的,没有经过足够训练的玩家,猜测准确率应该会下降。

    4. (强行)理论解释

    相信我,以下的解释可能都是错的。。。

    有一天,我失眠了。然后无聊之中我就在想,数据分布变化如果会导致模型性能下降,那么背后的原理是什么?可否量化地进行解释?

    突然间,脑海里蹦出一个念头,信息熵?!一切似乎都说得通了。

    4.1 一种解释

    最直接的解释是,模型进行预测,需要解决一些不确定性,而这个不确定性,很大一部分就体现在模型的输出空间 Y 的分布上(另一部分体现在输入空间 X)。这种不确定性,可以用信息熵来量化。

    根据信息熵的含义,我们知道,输出空间 Y 的分布的信息熵越大,则为了消除这个不确定性,模型需要学到更多的信息/规律,也就是该分类任务的固有难度越大。

    因此,问题变成了:如果能确认数据集扩大后,输出 Y 的分布的熵增加了,那么就可以说分类难度增加了,算是在某种程度上解释了为何模型性能会下降。

    直接上结果:经统计发现,分类准确率下降较严重的数据集,在数据扩增后,输出 Y 的分布的熵确实增加幅度较大。

    对上文游戏中的例子也进行一下计算吧!

    初始游戏:红 绿 蓝 球数分别为 98:1:1,此时的熵为: ( − 0.98 l o g 2 0.98 ) + ( − 0.01 l o g 2 0.01 ) × 2 = 0.1614 (-0.98 \rm{log}_2 {0.98}) + (-0.01 \rm{log}_2 {0.01} ) \times 2 = 0.1614 (0.98log20.98)+(0.01log20.01)×2=0.1614 (对数底为2,单位为比特)

    升级游戏:红 绿 蓝 球数比值为 1:1:1,此时的熵为: ( − 1 3 l o g 2 1 3 ) × 3 = − l o g 2 1 3 = 1.585 (- \frac13 \rm{log}_2 {\frac13}) \times 3 = - \rm{log}_2 {\frac13} = 1.585 (31log231)×3=log231=1.585 (对数底为2,单位为比特)

    可以看出二者的熵具有较大的差距,后者为前者的近十倍。

    4.2 另一种解释

    以下尝试进行更深度的解释,但可能也都是错的。。。

    机器学习模型学习的是什么?理论上,目标是让模型学到从输入X到输出Y的映射,可以是条件概率 P(Y|X)、联合概率 P(X, Y),或者 Y = f ( X ) Y=f(X) Y=f(X)

    然而,这或许只是我们的一厢情愿,模型或许主要学到了 P(Y),然后在数据不均衡的情况下,显示出了具有欺骗性的准确率。

    为了便于公式拆解,我们假设模型学习的目标是联合概率分布 P(X, Y),假设使用的统计学习方法是朴素贝叶斯法。

    那么,模型主要学习两点:①先验分布 P(Y);②条件概率 P(X|Y)。

    然后,预测的方法是: y = a r g    m a x c k P ( Y = c k ) P ( X ∣ Y = c k ) y = \rm{arg} \; \rm{max}_{c_k} P(Y=c_k) P(X|Y=c_k) y=argmaxckP(Y=ck)P(XY=ck) (严格的写法中,这里的条件概率需要用条件独立性假设展开为连乘的形式,但这里为了便于理解,就不引入太多细节了)

    当数据量比较少的时候,我们学到的 P(X|Y) 可能不太准确,而且,倘若这时数据分布较为不均衡,那么模型可能主要就学到了 P(Y),可能其中的某个类别概率很大。在这种情况下, P(X|Y) 学得差,而 P(Y) 学得好,P(Y) 将会主导模型最后的预测结果。就像我们一开始举例的游戏中那样,直接猜红色也能有 98% 准确率。但,这或许并不是我们想要的结果。

    后续的数据量增加,数据分布更加平衡,让 P(Y) 不再“误导”分类结果,虽然模型准确率大概率会下降,但实际上学到了更多东西(P(X|Y))。

    5. 结论

    在数据量较少、且样本分布不均衡的情况下,数据集扩大使得样本标签更加均衡后(熵增),分类难度增加,可能会导致模型性能下降。

    当然,如果数据量增大的特别多,比如扩大到原来的十倍、百倍,那么,大量的数据或许可以弥补这一下降。但一切都不能一概而论,毕竟,影响最终效果的因素很多,比如输入 X 本身的可区分性(问题本身的固有难度)、噪声/错误标签的多少、模型的学习能力、优化算法是否足够有效等等。

    展开全文
  • 使用“随机梯度下降”,与标准梯度下降精确计算梯度不一样,随机梯度下降法在计算梯度时加入随机的因素,于是即便其陷入到局部的极小值,他计算的梯度仍可能不为0,这样就有可能跳出局部的极小值而继续进行搜索。...
  • 线性回归之梯度下降详解

    千次阅读 2019-03-12 08:42:51
    在了解梯度下降(Gradient Descent)之前,我们先要知道有关线性回归的基本知识,这样可以进一步的加深对梯度下降的理解,当然梯度下降(Gradient Descent)并不单单只能进行回归预测,它还可以进行诸如分类等操作。...
  • 分地区看,东部地区不良贷 款率略有下降,较年初下降0.15个百分点;东北地 区加大不良风险处置力度,金融风险趋于收敛, 不良率较年初下降0.05个百分点;中部地区金融资 产质量向好,不良率较年初下降0.26个百分点;...
  • 在前一节当中我们讨论了神经网络静态的部分:包括神经网络结构、神经元类型、数据部分、...这个部分我们集中讲讲动态的部分,主要是训练的事情,集中在实际工程实践训练过程中要注意的一些,如何找到最合适的参数。
  • 5、优化方法:随机梯度下降

    千次阅读 2018-07-12 17:22:05
    5、优化方法:随机梯度下降法 5.1 介绍 在上衣章,我们介绍了图像分类任务中的两个关键部分: 一个参数化的评分函数将原始图像像素映射到类得分(例如线性函数) 一个损失函数,它测量预测的分类得分与实际的...
  • 计算机组成原理知识

    万次阅读 多人点赞 2017-09-25 11:17:08
    计算机体系结构(Computer Architecture)主要研究硬件和...在确定且分配了硬件子系统的概念结构和功能特性的基础上,设计计算机各部件的具体组成,以及它们之间的连接关系,实现机器指令级的各种功能和特性,这上说
  • 中国现在计算机水平现状是怎样的

    千次阅读 2021-07-05 06:42:11
    匿名用户1级2016-12-12 回答参考前瞻产业研究院发布的《2015-2020年 中国计算机整机制造行业市场需求与投资...长期来看,计算机作为未来核心计算设备的功能不会改变,随着新技术的突破,计算机行业将迎来新的发展...
  • Q1:上涨比例怎么算公式?比如昨天收盘价为9.5元,则9.5元的10%...ST和*ST股涨跌幅为5%Q2:股票上涨百分比的计算方式怎么算?上涨百分比 = ((当前股票成交价格 - 前一个交易日收盘价)÷前一个交易日收盘价)×100...
  • 计算机视觉——YOLO(v1,v2,v3)

    千次阅读 2022-03-18 18:00:04
    为了改善这种情况,作者用了另外一种方法: 假设将anchor设置在每一个grid cell左上角的话,假设他的中心坐标是(Cx,Cy) 假设预测的bounding box prior的宽高是(Pw,Ph) 在YOLO v2中作者给出了如下计算公式 ...
  • 在过去的几年里,由于微控制器、CPU、DSP等数字电路的几何结构尺寸不断缩小,电子元器件的电源电压一直持续下降。在测量领域也有一些需要低电源电压的应用。 本篇博文将分享使用标准稳压器产生只有几毫伏微型直流...
  • 彩电方面,2019 年 市场规模同比下降 10.6%至 1282 亿元,在家电全品类中降幅最大,但彩电向更大尺寸进化 的趋势十分明显,55 英寸电视市场份额下降 4.30 个百分点,65 英寸和 75 英寸市场份额分 别上升 4.80 个百分...
  • 梅老师,计算模型的psi一般用等频还是等距?一般几份? 答:通常都是等频,个人一般十箱 33. 我lgb在不平衡分类上训练了一个模型,训练集上输出概率分布呈偏态分布(偏向0,好样本),但在测试集上呈近似...
  •  IDC在对42个国家进行了调查后发表报告称,如果每一个被调查国家在未来4年内将盗版率下降10个百分点,那就会新增60万个就业机会,使这些国家的收 入增加1410亿美元,并推动全球税收增长240亿美元.IDC IT市场研究主管...
  • 机器学习基础知识

    千次阅读 2021-10-24 14:38:12
    文章目录机器学习基础知识监督学习回归线性回归岭回归lasso回归分类k最近邻分类朴素贝叶斯分类logistic回归支持向量机其他随机梯度下降线性判别分析决策树无监督学习聚类k均值层次聚类谱聚类高斯混合模型降维PCA...
  • 坡度怎么计算

    千次阅读 2020-12-23 03:50:22
    展开全部表示坡度最为常用的方法,即两的高程差与其路程的e69da5e6ba9062616964757a686964616f31333431356636比,其计算公式如下:坡度 = (高程差/路程)x100%。坡度的表示方法有百分比法、度数法、密位法和...
  • 模型训练时loss不收敛、不下降原因和解决办法

    万次阅读 多人点赞 2020-08-01 23:59:15
    总结 训练网络的时候loss一直居高不下或者准确度时高时低,震荡趋势,一会到11,一会又0.1,不收敛 首先你要保证训练的次数够多,不要以为一次就会一直loss下降或者准确率一直提高,会有一点震荡的。...
  • 梯度下降算法

    千次阅读 2016-08-28 20:56:13
    梯度下降法(gradient descent)是一种最优化算法,通常也称为最速下降法,在机器学习中...梯度,即导数,对一元函数来说,某处的导数就是该处的切线斜率。看一个示例,凸函数在区间[-12,12]之间的图像如下图所示:
  • 行代码实现排名Top 5%的图像分类比赛作者:七月在线彭老师责编:翟惠良 JulyGithub: https://github.com/pengpaiSH/Kaggle_NCFM前言 根据我个人的经验,学好AI,有五个必修:数学、数据结构、Python数据分析、ML...
  • 滤波器的实现很简单,但是以下几设计者必须注意: 1. 滤波器的拐点(中心)频率 2. 滤波器电路的增益 3. 带通滤波器和带阻滤波器的的Q值 4. 低通和高通滤波器的类型(Butterworth 、Chebyshev、Bessell) 不幸的是要...
  • 销量下降,到底应该怎么分析?!

    千次阅读 2020-05-31 21:37:00
    具体数字是最近2年从约80%~90%减至50%~60%,降低了30~40个百分点。可见,拥有本品牌产品但需要再次购买车辆的人中,这2年期间有近30%被其他公司夺走了。 d.汇总对比分析结果 我们将前面的比较结果,填到下面的...
  • 原因很简单,作为一个资历尚浅的研究生,是没有资格对计算广告这样一个伟大的行业、领域和学科来评头论足的。之所以这么做,一是总结自己已掌握的知识,二是降低同学们的学习成本。本人能力有限,更缺乏实践经验,...
  • 易懂的神经网络Python实战:单个神经元+随机梯度下降学习逻辑与规则 目录 逻辑与(AND) 破除神经元的认知障碍 实践:用程序表示一个手工设置权重weight和偏置bias的神经元 那么怎么让计算机自己确定神经元的...
  • 计算广告小窥[下]要啥自行车!

    千次阅读 2016-08-26 22:58:18
    一是总结自己已掌握的知识,二是降低同学们的学习成本。本人能力有限,更缺乏实践经验,文章内容多为书籍和论文的读后感,若有不当或者...在此,向编写《计算广告》的刘鹏和王超两位老师致谢,向各位paper作者致谢。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 52,063
精华内容 20,825
关键字:

下降百分点怎么计算