精华内容
下载资源
问答
  • dropout防止过拟合

    千次阅读 2017-08-30 15:39:18
    dropout防止过拟合

    Dropout

    L1、L2正则化是通过修改代价函数来实现的,而Dropout则是通过修改神经网络本身来实现的,它是在训练网络时用的一种技巧(trike)。它的流程如下:

    技术分享

    假设我们要训练上图这个网络,在训练开始时,我们随机地“删除”一半的隐层单元,视它们为不存在,得到如下的网络:

    技术分享

    保持输入输出层不变,按照BP算法更新上图神经网络中的权值(虚线连接的单元不更新,因为它们被“临时删除”了)。

    以上就是一次迭代的过程,在第二次迭代中,也用同样的方法,只不过这次删除的那一半隐层单元,跟上一次删除掉的肯定是不一样的,因为我们每一次迭代都是“随机”地去删掉一半。第三次、第四次……都是这样,直至训练结束。

    以上就是Dropout,它为什么有助于防止过拟合呢?可以简单地这样解释,运用了dropout的训练过程,相当于训练了很多个只有半数隐层单元的神经网络(后面简称为“半数网络”),每一个这样的半数网络,都可以给出一个分类结果,这些结果有的是正确的,有的是错误的。随着训练的进行,大部分半数网络都可以给出正确的分类结果,那么少数的错误分类结果就不会对最终结果造成大的影响。

    更加深入地理解,可以看看Hinton和Alex两牛2012的论文《ImageNet Classification with Deep Convolutional Neural Networks》

    展开全文
  • tensorflow的dropout 防止过拟合

    tensorflow的dropout 防止过拟合

    原文链接:https://github.com/MorvanZhou/Tensorflow-Tutorial
    训练前自己的数据
    在这里插入图片描述
    训练之后得到的图形
    在这里插入图片描述

    代码如下:

    """
    Know more, visit my Python tutorial page: https://morvanzhou.github.io/tutorials/
    My Youtube Channel: https://www.youtube.com/user/MorvanZhou
    Dependencies:
    tensorflow: 1.1.0
    matplotlib
    numpy
    """
    import tensorflow as tf
    import numpy as np
    import matplotlib.pyplot as plt
    
    tf.set_random_seed(1)
    np.random.seed(1)
    
    # Hyper parameters
    N_SAMPLES = 20
    N_HIDDEN = 300
    LR = 0.01
    
    # training data
    x = np.linspace(-1, 1, N_SAMPLES)[:, np.newaxis]
    y = x + 0.3*np.random.randn(N_SAMPLES)[:, np.newaxis]
    
    # test data
    test_x = x.copy()
    test_y = test_x + 0.3*np.random.randn(N_SAMPLES)[:, np.newaxis]
    
    # show data
    plt.scatter(x, y, c='magenta', s=50, alpha=0.5, label='train')
    plt.scatter(test_x, test_y, c='cyan', s=50, alpha=0.5, label='test')
    plt.legend(loc='upper left')
    plt.ylim((-2.5, 2.5))
    plt.show()
    
    # tf placeholders
    tf_x = tf.placeholder(tf.float32, [None, 1])
    tf_y = tf.placeholder(tf.float32, [None, 1])
    tf_is_training = tf.placeholder(tf.bool, None)  # to control dropout when training and testing
    
    # overfitting net
    o1 = tf.layers.dense(tf_x, N_HIDDEN, tf.nn.relu)
    o2 = tf.layers.dense(o1, N_HIDDEN, tf.nn.relu)
    o_out = tf.layers.dense(o2, 1)
    o_loss = tf.losses.mean_squared_error(tf_y, o_out)
    o_train = tf.train.AdamOptimizer(LR).minimize(o_loss)
    
    # dropout net
    d1 = tf.layers.dense(tf_x, N_HIDDEN, tf.nn.relu)
    d1 = tf.layers.dropout(d1, rate=0.5, training=tf_is_training)   # drop out 50% of inputs
    d2 = tf.layers.dense(d1, N_HIDDEN, tf.nn.relu)
    d2 = tf.layers.dropout(d2, rate=0.5, training=tf_is_training)   # drop out 50% of inputs
    d_out = tf.layers.dense(d2, 1)
    d_loss = tf.losses.mean_squared_error(tf_y, d_out)
    d_train = tf.train.AdamOptimizer(LR).minimize(d_loss)
    
    sess = tf.Session()
    sess.run(tf.global_variables_initializer())
    
    plt.ion()   # something about plotting
    
    for t in range(500):
        sess.run([o_train, d_train], {tf_x: x, tf_y: y, tf_is_training: True})  # train, set is_training=True
    
        if t % 10 == 0:
            # plotting
            plt.cla()
            o_loss_, d_loss_, o_out_, d_out_ = sess.run(
                [o_loss, d_loss, o_out, d_out], {tf_x: test_x, tf_y: test_y, tf_is_training: False} # test, set is_training=False
            )
            plt.scatter(x, y, c='magenta', s=50, alpha=0.3, label='train'); plt.scatter(test_x, test_y, c='cyan', s=50, alpha=0.3, label='test')
            plt.plot(test_x, o_out_, 'r-', lw=3, label='overfitting'); plt.plot(test_x, d_out_, 'b--', lw=3, label='dropout(50%)')
            plt.text(0, -1.2, 'overfitting loss=%.4f' % o_loss_, fontdict={'size': 20, 'color':  'red'}); plt.text(0, -1.5, 'dropout loss=%.4f' % d_loss_, fontdict={'size': 20, 'color': 'blue'})
            plt.legend(loc='upper left'); plt.ylim((-2.5, 2.5)); plt.pause(0.1)
    
    plt.ioff()
    plt.show()
    
    展开全文
  • 拟合-->回归问题、分类问题 ...过拟合 解决方法: 1.增加数据集 2.正则化方法-->在代价函数后增加正则项 3.Dropout-->神经元随机失活 import tensorflow as tf from tensorflow.ex...

    拟合-->回归问题、分类问题
        1.欠拟合
        2.正确拟合
        3.过拟合
            解决方法:
                1.增加数据集
                2.正则化方法-->在代价函数后增加正则项
                3.Dropout-->神经元随机失活 

    import tensorflow as tf
    from tensorflow.examples.tutorials.mnist import input_data
    
    #载入数据集,one_hot:将标签转换为只有一位为1,其它为0,会自动从网上下载数据集到当前目录
    mnist=input_data.read_data_sets("MNIST_data",one_hot=True)
    
    #每个批次的大小
    batch_size=100
    #计算一共有多少个批次(整除)
    n_batch=mnist.train.num_examples//batch_size
    
    #该神经网络包含输入层、中间层、输出层,输入层包含784个神经元,输出层包含10个神经元
    #定义两个placeholder,将28*28数字图片偏平为规格为784的向量
    x=tf.placeholder(tf.float32,[None,784])
    #标签结果
    y=tf.placeholder(tf.float32,[None,10])
    #设置神经元保活概率-->Dropout防止过拟合
    keep_prob=tf.placeholder(tf.float32)
    
    #创建一个简单的神经网络
    #一般权值初始化不能为0,  784x10,输入层784个神经元
    W1=tf.Variable(tf.truncated_normal([784,2000],stddev=0.1))
    #偏置值初始化为0.1
    b1=tf.Variable(tf.zeros([2000])+0.1)
    L1=tf.nn.tanh(tf.matmul(x,W1)+b1)
    L1_drop=tf.nn.dropout(L1,keep_prob)
    
    #2000个神经元
    W2=tf.Variable(tf.truncated_normal([2000,2000],stddev=0.1))
    b2=tf.Variable(tf.zeros([2000])+0.1)
    L2=tf.nn.tanh(tf.matmul(L1_drop,W2)+b2)
    L2_drop=tf.nn.dropout(L2,keep_prob)
    
    #1000个神经元
    W3=tf.Variable(tf.truncated_normal([2000,1000],stddev=0.1))
    b3=tf.Variable(tf.zeros([1000])+0.1)
    L3=tf.nn.tanh(tf.matmul(L2_drop,W3)+b3)
    L3_drop=tf.nn.dropout(L3,keep_prob)
    
    #输出层10个神经元
    W4=tf.Variable(tf.truncated_normal([1000,10],stddev=0.1))
    b4=tf.Variable(tf.zeros([10])+0.1)
    #softmax将输出转化为概率值
    prediction=tf.nn.softmax(tf.matmul(L3_drop,W4)+b4)
    
    
    #二次代价函数,差的平方的平均值
    #loss=tf.reduce_mean(tf.square(y-prediction))
    #交叉熵代价函数的平均值
    loss=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y,logits=prediction))
    
    #梯度下降法
    train_step=tf.train.GradientDescentOptimizer(0.2).minimize(loss)
    
    #初始化变量
    init=tf.global_variables_initializer()
    
    #tf.argmax(y,1)返回1的位置(真实值),tf.argmax(prediction,1)(预测值)返回概率值最大的位置,比较位置是否相等,若想等返回true,不等返回false,存放在布尔列表中
    correct_prediction=tf.equal(tf.argmax(y,1),tf.argmax(prediction,1))#tf.argmax()返回一维张量中最大值的位置
    #求准确率
    accuracy=tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
    
    with tf.Session() as sess:
        sess.run(init)
        # 对所有图片迭代31次
        for epoch in range(31):
            #对所有图片分批训练一次
            for batch in range(n_batch):
                #获取一批(100个)样本图片,batch_xs:图片信息,batch_ys:图片标签
                batch_xs,batch_ys=mnist.train.next_batch(batch_size)
                #利用训练图片信息及对应标签,梯度下降法训练模型,得到权重W及b,keep_prob=1.0代表训练时神经元不随机失活
                sess.run(train_step,feed_dict={x:batch_xs,y:batch_ys,keep_prob:1.0})
    
            #利用测试集进行测试该迭代时模型的准确率
            test_acc=sess.run(accuracy,feed_dict={x:mnist.test.images,y:mnist.test.labels,keep_prob:1.0})#利用测试集测试模型
            train_acc = sess.run(accuracy, feed_dict={x: mnist.train.images, y: mnist.train.labels,keep_prob:1.0})#利用训练集测试模型,准确率一定很高
            #打印迭代次数及对应准确率
            print("Iter "+str(epoch)+",Testing Accuracy "+str(test_acc)+",Training Accuracy "+str(train_acc))
    
    
    
    
    

    运行结果:时间真的太长了,没运行完毕,主要是keep_drop=1.0时,训练集模型产生过拟合,导致在测试集上准确率与训练集上准确率偏差较大,而正确拟合应该是测试集与训练集准确率接近

    展开全文
  • 关于 Dropout 可以防止过拟合,出处:深度学习领域大神 Hinton,在2012年文献:《Improving neural networks by preventing co-adaptation of feature detectors》提出的。  【Dropout 可以防止过拟合】  运用了...

     

      关于 Dropout 可以防止过拟合,出处:深度学习领域大神 Hinton,在2012年文献:《Improving neural networks by preventing co-adaptation of feature detectors》提出的。

      【Dropout 可以防止过拟合】

      运用了dropout的训练过程,相当于训练了很多个只有半数隐层单元的神经网络(后面简称为“半数网络”),每一个这样的半数网络,都可以给出一个分类结果,这些结果有的是正确的,有的是错误的。随着训练的进行,大部分半数网络都可以给出正确的分类结果,那么少数的错误分类结果就不会对最终结果造成大的影响。

     

      在每次训练的时候,让一半的特征检测器停过工作,这样可以提高网络的泛化能力,Hinton把它称之为dropout。

      Hinton认为:过拟合,可以通过阻止某些特征的协同作用来缓解。在每次训练的时候,每个神经元有百分之50的几率被移除,这样可以让一个神经元的出现不应该依赖于另外一个神经元。

      每次将一个神经网络进行dropout之后就是对这个网络进行了瘦身处理,有一些参数被dropout掉,得到了一个更加简单的网络。

     

      【迭代过程】

      1. 在训练开始时,我们随机地“删除”一半的隐层单元,视它们为不存在;

      2. 保持输入输出层不变,按照BP算法更新神经网络中的权值(虚线连接的单元不更新,因为它们被“临时删除”了)。

      以上就是一次迭代的过程,在第二次迭代中,也用同样的方法,只不过这次删除的那一半隐层单元,跟上一次删除掉的肯定是不一样的,因为我们每一次迭代都是“随机”地去删掉一半。第三次、第四次……都是这样,直至训练结束。

     

      另外一个可以防止过拟合的原因是:我们可以把dropout理解为模型平均。 假设我们要实现一个图片分类任务,我们设计出了1000个网络,这1000个网络,我们可以设计得各不相同,然后我们对这1000个网络进行训练,训练完后我们采用平均的方法,进行预测,这样肯定可以提高网络的泛化能力,或者说可以防止过拟合,因为这1000个网络,它们各不相同,可以提高网络的稳定性。而所谓的dropout我们可以这么理解,这 n 个网络,它们权值共享,并且具有相同的网络层数(这样可以大大减小计算量)。我们每次dropout后,网络模型都可以看成是整个网络的子网络。(需要注意的是如果采用dropout,训练时间大大延长,但是对测试阶段没影响)。

          根据个人实际经验,dropout在数据量比较小的时候,不建议使用,效果并没有特别好,dropout的值一般来说取值为0.5效果会比较好。

     

     

     

     

    【Reference】

    1、dropout为什么能够防止过拟合

    2、浅谈 Dropout防止过拟合

    转载于:https://www.cnblogs.com/shenxiaolin/p/9841824.html

    展开全文
  • pytorch使用dropout防止过拟合

    千次阅读 2020-04-07 10:33:16
    推测与验证 现在您已经学会了训练网络,可以将其用于进行预测。 这通常称为推测,是从统计信息中借用的术语。... 我们在训练过程中监控验证效果时,通过正则化(例如dropout)来避免过拟合。我将向您展示如何在PyTor...
  • 前言: 大家都知道,当我们对着一些数据使劲训练时,如果训练次数过多就会导致过拟合过拟合时只能认出...为什么丢掉一部分神经元就可以有防止过拟合的魔力? 首先,在处于过拟合状态时,如果输入数据失去某些和训
  • dropout防止过拟合的原因

    千次阅读 2019-04-09 15:38:22
    常见的减小过拟合的方法有:正则化 、Early Stop、 增加数据、 dropout【1】。其中,drop out主要用在神经网络模型中,其避免过拟合的原因,参考【2】内内容,理解如下: 1.类似取平均值的作用。 普通的模型(没有...
  • 浅谈 Dropout防止过拟合

    千次阅读 2017-11-28 08:43:17
    发生过拟合的主要原因可以有以下三点: (1)数据有噪声 (2)训练数据不足,有限的训练数据 (3)训练模型过度导致模型非常复杂 Dropout是通过修改神经网络本身来实现的,它是在训练网络时用的一种...
  • 了解dropout那得先了解什么是overfitting(过拟合),underfitting(欠拟合) overfitting就是指Ein(在训练集上的错误率)变小,Eout(在整个数据集上的错误率)变大的过程 underfitting是指Ein和Eout都变大的过程 ...
  • 这一篇介绍另一种防止过拟合的方法,dropout,即丢弃某些神经元的输出.由于每次训练的过程里,丢弃掉哪些神经元的输出都是随机的,从而可以使得模型不过分依赖于某些神经元的输出,从而达到防止过拟合的...
  • tf.nn.dropout是TensorFlow里面为了防止或减轻过拟合而使用的函数,它一般用在全连接层。 Dropout就是在不同的训练过程中随机扔掉一部分神经元。也就是让某个神经元的激活值以一定的概率p,让其停止工作,这次训练...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,424
精华内容 5,769
关键字:

dropout防止过拟合