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

    2018-06-30 19:59:01
    dropout 的过程好像很奇怪,为什么说它可以解决过拟合呢?(正则化)取平均的作用: 先回到正常的模型(没有dropout),我们用相同的训练数据去训练5个不同的神经网络,一般会得到5个不同的结果,此时我们可以采用 ...

    dropout 的过程好像很奇怪,为什么说它可以解决过拟合呢?(正则化)

    • 取平均的作用: 先回到正常的模型(没有dropout),我们用相同的训练数据去训练5个不同的神经网络,一般会得到5个不同的结果,此时我们可以采用 “5个结果取均值”或者“多数取胜的投票策略”去决定最终结果。(例如 3个网络判断结果为数字9,那么很有可能真正的结果就是数字9,其它两个网络给出了错误结果)。这种“综合起来取平均”的策略通常可以有效防止过拟合问题。因为不同的网络可能产生不同的过拟合,取平均则有可能让一些“相反的”拟合互相抵消。dropout掉不同的隐藏神经元就类似在训练不同的网络(随机删掉一半隐藏神经元导致网络结构已经不同),整个dropout过程就相当于 对很多个不同的神经网络取平均。而不同的网络产生不同的过拟合,一些互为“反向”的拟合相互抵消就可以达到整体上减少过拟合。
    • 减少神经元之间复杂的共适应关系: 因为dropout程序导致两个神经元不一定每次都在一个dropout网络中出现。(这样权值的更新不再依赖于有固定关系的隐含节点的共同作用,阻止了某些特征仅仅在其它特定特征下才有效果的情况)。 迫使网络去学习更加鲁棒的特征 (这些特征在其它的神经元的随机子集中也存在)。换句话说假如我们的神经网络是在做出某种预测,它不应该对一些特定的线索片段太过敏感,即使丢失特定的线索,它也应该可以从众多其它线索中学习一些共同的模式(鲁棒性)。(这个角度看 dropout就有点像L1,L2正则,减少权重使得网络对丢失特定神经元连接的鲁棒性提高)
    展开全文
  • pytorch Dropout过拟合

    千次阅读 2017-07-14 09:24:04
    --', lw=3, label='dropout(50%)') plt.text( 0 , - 1.2 , 'overfitting loss=% .4 f' % loss_func(test_pred_ofit, test_y). data [0], fontdict= {' size' : 20, ' color' : ' red' } ) plt.text( 0 , - 1.5 ,...

    image.png

    简书地址

    import torch
    from torch.autograd import Variable
    import matplotlib.pyplot as plt
    
    torch.manual_seed(1)
    
    N_SAMPLES = 20
    N_HIDDEN = 300
    
    # training data
    x = torch.unsqueeze(torch.linspace(-1, 1, N_SAMPLES), 1)
    y = x + 0.3 * torch.normal(torch.zeros(N_SAMPLES, 1), torch.ones(N_SAMPLES, 1))
    x, y = Variable(x), Variable(y)
    
    # test data
    test_x = torch.unsqueeze(torch.linspace(-1, 1, N_SAMPLES), 1)
    test_y = test_x + 0.3 * torch.normal(torch.zeros(N_SAMPLES, 1), torch.ones(N_SAMPLES, 1))
    test_x = Variable(test_x, volatile=True)
    test_y = Variable(test_y, volatile=True)
    
    # show data
    # plt.scatter(x.data.numpy(), y.data.numpy(), c='magenta', s=50, alpha=0.5, label='train')
    # plt.scatter(test_x.data.numpy(), test_y.data.numpy(), c='cyan', s=50, alpha=0.5, label='test')
    # plt.legend(loc='upper left')
    # plt.ylim((-2.5, 2.5))
    # plt.show()
    
    net_overfitting = torch.nn.Sequential(
        torch.nn.Linear(1, N_HIDDEN),
        torch.nn.ReLU(),
        torch.nn.Linear(N_HIDDEN, N_HIDDEN),
        torch.nn.ReLU(),
        torch.nn.Linear(N_HIDDEN, 1),
    )
    
    net_dropped = torch.nn.Sequential(
        torch.nn.Linear(1, N_HIDDEN),
        torch.nn.Dropout(0.5),
        torch.nn.ReLU(),
        torch.nn.Linear(N_HIDDEN, N_HIDDEN),
        torch.nn.Dropout(0.5),
        torch.nn.ReLU(),
        torch.nn.Linear(N_HIDDEN, 1),
    )
    
    print(net_overfitting)
    print(net_dropped)
    
    optimizer_ofit = torch.optim.Adam(
        net_overfitting.parameters(),
        lr = 0.01,
    )
    optimizer_drop = torch.optim.Adam(
        net_dropped.parameters(),
        lr = 0.01,
    )
    loss_func = torch.nn.MSELoss()
    
    plt.ion()
    
    for t in range(500):
        pred_ofit = net_overfitting(x)
        pred_drop = net_dropped(x)
        loss_ofit = loss_func(pred_ofit, y)
        loss_drop = loss_func(pred_drop, y)
    
        optimizer_ofit.zero_grad()
        optimizer_drop.zero_grad()
        loss_ofit.backward()
        loss_drop.backward()
        optimizer_ofit.step()
        optimizer_drop.step()
    
        if t % 10 == 0:
            net_overfitting.eval()
            net_dropped.eval()
    
            plt.cla()
            test_pred_ofit = net_overfitting(test_x)
            test_pred_drop = net_dropped(test_x)
            plt.scatter(x.data.numpy(), y.data.numpy(), c='magenta', s=50, alpha=0.3, label='train')
            plt.scatter(test_x.data.numpy(), test_y.data.numpy(), c='cyan', s=50, alpha=0.3, label='test')
            plt.plot(test_x.data.numpy(), test_pred_ofit.data.numpy(), 'r-', lw=3, label='overfitting')
            plt.plot(test_x.data.numpy(), test_pred_drop.data.numpy(), 'b--', lw=3, label='dropout(50%)')
            plt.text(0, -1.2, 'overfitting loss=%.4f' % loss_func(test_pred_ofit, test_y).data[0], fontdict={'size': 20, 'color':  'red'})
            plt.text(0, -1.5, 'dropout loss=%.4f' % loss_func(test_pred_drop, test_y).data[0], fontdict={'size': 20, 'color': 'blue'})
            plt.legend(loc='upper left'); plt.ylim((-2.5, 2.5));plt.pause(0.1)
    
            net_overfitting.train()
            net_dropped.train()
    
    plt.ioff()
    plt.show()
    
    展开全文
  • 本文是利用Dropout方法解决过拟合问题。 过拟合问题的影响因素最主要的因素是数据集的大小,以及模型的复杂程度。当一个数据集数据越小,模型越复杂的时候就越容易产生过拟合问题。而Dropout就是一个把复杂的模型...
    import tensorflow as tf
    from tensorflow.examples.tutorials.mnist import input_data
    
    #载入数据
    mnist=input_data.read_data_sets("E:\MNIST_data",one_hot=True) 
    #每个批次的大小
    batch_size=100
    #计算一共有多少个批次
    n_batch=mnist.train.num_examples//batch_size
    
    
    #定义两个placeholder
    x=tf.placeholder(tf.float32,[None,784])
    y=tf.placeholder(tf.float32,[None,10])
    keep_prob=tf.placeholder(tf.float32)
    
    
    #创建一个简单的神经网络
    W1=tf.Variable(tf.truncated_normal([784,2000],stddev=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)
                   
    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)
                 
    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)          
                   
    W4=tf.Variable(tf.truncated_normal([1000,10],stddev=0.1))
    b4=tf.Variable(tf.zeros([10])+0.1)
    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()
    
    
    #结果存放在一个布尔型列表中
    correct_prediction=tf.equal(tf.argmax(y,1),tf.argmax(prediction,1))#//返回同一维张量中最大的值所在的位子
    accuracy=tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
    
    
    with tf.Session() as sess:
        sess.run(init)
        for epoch in range(31):
            for batch in range(n_batch):
                batch_xs,batch_ys=mnist.train.next_batch(batch_size)
                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("Tter"+str(epoch)+",Testing Accuracy"+str(test_acc)+"training Accuracy"+str(train_acc))

    展开全文
  • Dropout 缓解过拟合

    2020-02-24 11:11:33
    文章目录Dropout 缓解过拟合 Dropout 缓解过拟合 搭建两个神经网络, 一个没有 dropout, 一个有 dropout. 没有 dropout 的容易出现 过拟合, 那我们就命名为 net_overfitting, 另一个就是 ...

    Dropout 缓解过拟合

    搭建两个神经网络, 一个没有 dropout, 一个有 dropout. 没有 dropout 的容易出现 过拟合, 那我们就命名为 net_overfitting,
    另一个就是 net_dropped. torch.nn.Dropout(0.5) 这里的 0.5 指的是随机有 50% 的神经元会被关闭/丢弃.
    这两个神经网络分开训练. 训练的环境都一样.

    import torch
    import matplotlib.pyplot as plt
    
    torch.manual_seed(1)    # reproducible
    
    N_SAMPLES = 20#数据量20
    N_HIDDEN = 300#300个神经元拟合它
    
    # training data
    x = torch.unsqueeze(torch.linspace(-1, 1, N_SAMPLES), 1)
    y = x + 0.3*torch.normal(torch.zeros(N_SAMPLES, 1), torch.ones(N_SAMPLES, 1))
    
    # test data
    test_x = torch.unsqueeze(torch.linspace(-1, 1, N_SAMPLES), 1)
    test_y = test_x + 0.3*torch.normal(torch.zeros(N_SAMPLES, 1), torch.ones(N_SAMPLES, 1))
    
    # show data
    # plt.scatter(x.data.numpy(), y.data.numpy(), c='magenta', s=50, alpha=0.5, label='train')
    # plt.scatter(test_x.data.numpy(), test_y.data.numpy(), c='cyan', s=50, alpha=0.5, label='test')
    # plt.legend(loc='upper left')
    # plt.ylim((-2.5, 2.5))
    # plt.show()
    #搭建两个神经网络, 一个没有 dropout, 一个有 dropout. 没有 dropout 的容易出现 过拟合
    net_overfitting = torch.nn.Sequential(
        torch.nn.Linear(1, N_HIDDEN),
        torch.nn.ReLU(),
        torch.nn.Linear(N_HIDDEN, N_HIDDEN),
        torch.nn.ReLU(),
        torch.nn.Linear(N_HIDDEN, 1),
    )
    
    net_dropped = torch.nn.Sequential(
        torch.nn.Linear(1, N_HIDDEN),
        torch.nn.Dropout(0.5),  # 随机抽取50%节点数连接屏蔽掉
        torch.nn.ReLU(),
        torch.nn.Linear(N_HIDDEN, N_HIDDEN),
        torch.nn.Dropout(0.5),  #同上
        torch.nn.ReLU(),
        torch.nn.Linear(N_HIDDEN, 1),
    )
    #训练
    optimizer_ofit = torch.optim.Adam(net_overfitting.parameters(), lr=0.01)
    optimizer_drop = torch.optim.Adam(net_dropped.parameters(), lr=0.01)
    loss_func = torch.nn.MSELoss()
    
    for t in range(500):
        pred_ofit = net_overfitting(x)
        pred_drop = net_dropped(x)
    
        loss_ofit = loss_func(pred_ofit, y)
        loss_drop = loss_func(pred_drop, y)
    
        optimizer_ofit.zero_grad()
        optimizer_drop.zero_grad()
        loss_ofit.backward()
        loss_drop.backward()
        optimizer_ofit.step()
        optimizer_drop.step()
        #预测的时候不需要屏蔽50% 训练的时候屏蔽50%
        if t % 10 == 0:  # 每 10 步画一次图
            # 将神经网络转换成预测形式, 画好图之后改回 训练形式
            net_overfitting.eval()#先进行预测
            net_dropped.eval()  # 因为 drop 网络在 train 的时候和 test 的时候参数不一样.
    
            # plotting
    
            plt.cla()
    
    
            test_pred_ofit = net_overfitting(test_x)#预测结果
            test_pred_drop = net_dropped(test_x)#训练结果
    
            plt.scatter(x.data.numpy(), y.data.numpy(), c='magenta', s=50, alpha=0.3, label='train')
    
            plt.scatter(test_x.data.numpy(), test_y.data.numpy(), c='cyan', s=50, alpha=0.3, label='test')
    
            plt.plot(test_x.data.numpy(), test_pred_ofit.data.numpy(), 'r-', lw=3, label='overfitting')
    
            plt.plot(test_x.data.numpy(), test_pred_drop.data.numpy(), 'b--', lw=3, label='dropout(50%)')
    
            plt.text(0, -1.2, 'overfitting loss=%.4f' % loss_func(test_pred_ofit, test_y).data.numpy(),
                     fontdict={'size': 20, 'color': 'red'})
    
            plt.text(0, -1.5, 'dropout loss=%.4f' % loss_func(test_pred_drop, test_y).data.numpy(),
                     fontdict={'size': 20, 'color': 'blue'})
    
            plt.legend(loc='upper left');
            plt.ylim((-2.5, 2.5));
            plt.pause(0.1)
    
            # 将两个网络改回 训练形式
            net_overfitting.train()
            net_dropped.train()
    
    plt.ioff()
    
    plt.show()

    在这里插入图片描述

    展开全文
  • Tensorflow 实现dropout解决过拟合
  • Pytorch 实现dropout解决过拟合
  • dropout防止过拟合

    千次阅读 2017-08-30 15:39:18
    dropout防止过拟合
  • tensorflow的dropout 防止过拟合
  • Dropout抑制过拟合

    2021-03-17 10:16:47
    Dropout解决过拟合的原因 (1)取平均的作用 (2)减少神经元之间复杂的共适应关系: 因为dropout程序导致两个神经元不一定每次都在一个dropout网络中出现。这样权值的更新不再依赖于有固定关系的隐含节点的共同作用...
  • 拟合-->回归问题、分类问题 ...过拟合 解决方法: 1.增加数据集 2.正则化方法-->在代价函数后增加正则项 3.Dropout-->神经元随机失活 import tensorflow as tf from tensorflow.ex...
  • dropout过拟合

    2017-10-08 14:00:38
    1.防止过拟合的方法:提前终止(当验证集上的效果变差的时候),early stopping L1和L2正则化加权 soft weight sharing dropout 2.dropout率的选择经过交叉验证,隐含节点dropout率等于0.5的时候效果最好,原因是0.5...
  • Dropout解决过拟合代码

    2020-03-01 18:51:15
    过拟合指的是只能拟合训练数据,但不能很好地拟合不包含在训练数据中的其他数据的状态。 发生过拟合的原因,主要有以下两个。 模型拥有大量参数、表现力强。 训练数据少 权值衰减是一直以来经常被使用的一种抑制...
  • 这里用dropout来处理过拟合。只要在神经网络中加入dropout层就可以了。 首先来做一些数据 import torch import matplotlib.pyplot as plt torch.manual_seed(1) # reproducible N_SAMPLES = 20 #定义20个数据点 N_...
  • Dropout抑制过拟合原理 简单来说:即随机丢弃一些隐藏神经元,然后就会加强未丢弃神经元的训练。(类似随机森林,用一部分的特征来建立一个决策树,又用另一部分特征来建立另一个决策树) 详细原理 为什么Dropout...
  • Dropout解决过拟合问题

    千次阅读 2017-05-02 15:15:55
    Dropout解决过拟合问题 晓雷 6 个月前 这篇也属于 《神经网络与深度学习总结系列》,最近看论文对Dropout这个知识点有点疑惑,就先总结以下。(没有一些基础可能看不懂,以后还会继续按照正常进度写总结) 是...
  • Dropout过拟合抑制

    2020-10-02 15:47:37
    Dropout过拟合抑制 【1】 model=tf.keras.Sequential()#建模 model.add(tf.keras.layers.Flatten(input_shape=(28,28)))#28*28的向量 model.add(tf.keras.layers.Dropout(0.5))#丢弃50% model.add(tf.keras.layers...
  • dropout过拟合详解

    2020-09-09 09:03:49
    过拟合的定义: 在训练集上表现效果好,在交叉验证集上表现较差,也就是说在未知的样本上表现一般,泛化能力较差。 常常存在于数据少,数据网络深度长或者复杂(也就是参数多)的情况,导致过拟合问题。 出现...
  • Dropout过拟合

    2020-05-21 11:35:02
    使用dropout之后过程变成: 首先随机(临时)删掉网络中一半的隐藏神经元,输入输出神经元保持不变(下图中虚线为部分临时被删除的神经元) 然后把输入x通过修改后的网络前向传播,然后把得到的损失结果通过修改...
  • pytorch使用dropout防止过拟合

    千次阅读 2020-04-07 10:33:16
    推测与验证 现在您已经学会了训练网络,可以将其用于进行预测。 这通常称为推测,是从统计信息中借用的术语。... 我们在训练过程中监控验证效果时,通过正则化(例如dropout)来避免过拟合。我将向您展示如何在PyTor...
  • 在TensorFlow训练样本的数据中,有时会出现过拟合(overfiting)的问题,可以采取dropout的方法来解决,即随机丢弃部分样本。 下面是示例代码,通过tensorboard对结果进行了可视化: import tensorflow as tf from...
  • dropout解决过拟合问题

    千次阅读 2019-08-25 12:13:15
    过度拟合是机器学习中常见的问题,为了解决这个问题,可以使用dropout方法。 当不用dropout处理时的效果:模型对训练数据的适应性优于测试数据,存在overfitting 当使用dropout时,测试效果得以改善了: from __...
  • 过拟合指的是只能拟合训练数据,但不能很好地拟合不包含在训练数据中的其他数据的状态。机 器学习的目标是提高泛化能力,即便是没有包含在训练数据里的未观测数据,也希望模型可以进行正确的识别。我们可以制作复杂...
  • 关于 Dropout 可以防止过拟合,出处:深度学习领域大神 Hinton,在2012年文献:《Improving neural networks by preventing co-adaptation of feature detectors》提出的。  【Dropout 可以防止过拟合】  运用了...
  • dropout防止过拟合的原因

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

    千次阅读 2017-09-03 17:25:36
    在深度学习中,dropout通常用于解决过拟合问题,本文是dropout在tensorflow的一种实现

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 30,166
精华内容 12,066
关键字:

dropout过拟合