标签: gradient-descent

在反向传播训练中，在沿着误差面进行梯度下降期间，隐藏层中具有大量神经元的网络可能会陷入局部最小值。我读过，在所有情况下将权重重新初始化为随机数最终将避免此问题。这意味着总是存在一组“正确的”初始重量值。（这个假设安全吗？）

我需要找到或制定一个算法来找到它们。

我尝试过谷歌搜索该算法，尝试自己设计它，但没有成功。任何人都可以提出解决方案吗？也许我可以搜索算法的名称？

注意：这是一个常规的前馈 3 层墨西哥卷饼:)

注意：我知道已经尝试使用 GA 来达到此目的，但这需要在每次迭代中重新训练网络，当网络变得足够大时，这会耗费大量时间。

提前致谢。

我一直在关注关于深度学习的在线教程。它有一个关于梯度下降和成本计算的实际问题，一旦将其转换为 python 代码，我就一直在努力获得给定的答案。希望你能帮助我得到正确的答案

请参阅以下链接以了解所使用的方程式 单击此处查看用于计算的方程式

以下是计算梯度下降、成本等的函数。需要在不使用 for 循环但使用矩阵操作操作的情况下找到这些值

import numpy as np

def propagate(w, b, X, Y):
"""
Arguments:
w -- weights, a numpy array of size (num_px * num_px * 3, 1)
b -- bias, a scalar
X -- data of size (num_px * num_px * 3, number of examples)
Y -- true "label" vector (containing 0 if non-cat, 1 if cat) of size
  (1, number of examples)

Return:
cost -- negative log-likelihood cost for logistic regression
dw -- …

我正在阅读python深度学习书。在阅读了第4章，克服过度拟合之后，我有两个问题。

1. 为什么增加时期数会导致过度拟合？我知道增加历元数会涉及到更多的梯度下降尝试，这会导致过度拟合吗？

2. 在对抗过度拟合的过程中，精度会降低吗？

我正在训练一个模型。为了克服过度拟合，我做了优化、数据增强等。我有一个更新的 LR（我尝试了 SGD 和 Adam），当出现平台期（也尝试过步骤）时，学习率会降低一个因子，直到达到达到 LR 1e-08 但不会低于该值，并且我的模型的验证在此之后陷入困境。我尝试将 epsilon 参数传递给 Adam 以建议较小的值，但它仍然卡在 LR 1e-08。我也经历了体重衰减，但这并没有改变情况。将 amsgrad 设置为 true 也没有。

我做了一些研究，人们认为 Adam 优化器存在固有的问题，但没有提到学习率 - 每次讨论都补充说，使用 SGD 就没有问题。

为什么是这样？这是一个错误还是因为作者认为它是一个毫无意义的小值而设计的？似乎对我的数据集设置较小的学习率确实有帮助，因为在学习率降至 LR 1e-08 之前一切似乎都很好。

我正在尝试使用 SLSQP 来优化机翼的迎角，以将驻点放置在所需的位置。这纯粹是作为一个测试用例，以检查我计算停滞位置的部分的方法是否有效。

当使用 COBYLA 运行时，优化在 47 次迭代后收敛到正确的 alpha (6.04144912)。当使用 SLSQP 运行时，它完成一次迭代，然后挂起很长时间（10、20 分钟或更长时间，我没有准确计时），并以错误值退出。输出是：

Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|0
--------------------------------------------------------------
Design Vars
{'alpha': array([0.5])}
Nonlinear constraints
None
Linear constraints
None
Objectives
{'obj_cmp.obj': array([0.00023868])}
Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|1
--------------------------------------------------------------
Design Vars
{'alpha': array([0.5])}
Nonlinear constraints
None
Linear constraints
None
Objectives
{'obj_cmp.obj': array([0.00023868])}
Optimization terminated successfully.    (Exit mode 0)
            Current function value: 0.0002386835700364719
            Iterations: 1
            Function evaluations: 1
            Gradient evaluations: 1
Optimization Complete
-----------------------------------
Finished optimisation …

我正在尝试使用 pytorch 实现线性回归的简单梯度下降，如文档中的此示例所示：

import torch
from torch.autograd import Variable

learning_rate = 0.01
y = 5
x = torch.tensor([3., 0., 1.])
w = torch.tensor([2., 3., 9.], requires_grad=True)
b = torch.tensor(1., requires_grad=True)

for z in range(100):
    y_pred = b + torch.sum(w * x)
    loss = (y_pred - y).pow(2)
    loss = Variable(loss, requires_grad = True)
    # loss.requires_grad = True
    loss.backward()
    
    with torch.no_grad():
        w = w - learning_rate * w.grad
        b = b - learning_rate * b.grad
        
        w.grad = None
        b.grad = None …

代码来自：https : //github.com/torch/nn/blob/master/lib/THNN/generic/LogSoftMax.c

我没有看到这段代码如何计算模块 LogSoftMax 输入的梯度。我感到困惑的是两个 for 循环在做什么。

for (t = 0; t < nframe; t++)
{
sum = 0;
gradInput_data = gradInput_data0 + dim*t;
output_data = output_data0 + dim*t;
gradOutput_data = gradOutput_data0 + dim*t;

for (d = 0; d < dim; d++)
  sum += gradOutput_data[d];

for (d = 0; d < dim; d++)
  gradInput_data[d] = gradOutput_data[d] - exp(output_data[d])*sum;
 }
}

对于在第一个转换层之后的转换层,Tensorflow梯度始终为零.我已经尝试了不同的方法来检查,但渐变总是为零!这是可以运行以检查的小型可重现代码.

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import tensorflow as tf
import numpy as np
import math
import os
import random
import tflearn
batch_size = 100
start = 0
end = batch_size
learning_rate = 0.000001
num_classes = 4
time_steps = 4
embedding = 2
step = 1
_units = 500
num_of_filters = 1000

train_set_x = [[[1,2],[3,4],[5,6],[7,8]],[[1,2],[3,4],[5,6],[7,8]]]
train_set_y = [0,1]

X = tf.placeholder(tf.float32, [None,time_steps,embedding])
Y = tf.placeholder(tf.int32, [None])


x = tf.expand_dims(X,3)

filter_shape = [1, embedding, …

因此，我使用 Tensorflow 后端在 Keras 中定义了这个自定义损失函数，以最小化背景提取自动编码器。它应该确保预测 x_hat 不会偏离批次 B0 的预测中值太远。

def ben_loss(x, x_hat):

    B0 = tf_median(tf.transpose(x_hat))
    sigma = tf.reduce_mean(tf.sqrt(tf.abs(x_hat - B0) / 0.4), axis=0)
    # I divide by sigma in the next step. So I add a small float32 to sigma
    # so as to prevent background_term from becoming a nan.
    sigma += 1e-22 
    background_term = tf.reduce_mean(tf.abs(x_hat - B0) / sigma, axis=-1)
    bce = binary_crossentropy(x, x_hat)
    loss = bce + background_term

    return loss

当我尝试使用此损失函数最小化网络时，损失几乎立即变为 NaN。有谁知道为什么会发生这种情况？您可以通过克隆我的存储库并运行此脚本来重现该错误。

当我们训练神经网络时，我们通常使用梯度下降，这依赖于连续的，可微分的实值成本函数。最终成本函数可能会产生均方误差。或者换种说法，梯度下降隐式地认为最终目标是回归 -最大限度地减少实值误差度量。

有时，我们希望神经网络要做的就是执行分类 -给定输入，将其分类为两个或多个离散类别。在这种情况下，用户关心的最终目标是分类准确性-正确分类的案例的百分比。

但是，当我们使用神经网络进行分类时，尽管我们的目标是分类准确度，但这并不是神经网络试图优化的目标。神经网络仍在尝试优化实值成本函数。有时这些指向同一方向，但有时却不同。特别是，我一直在遇到这样的情况：经过训练以正确最小化成本函数的神经网络具有比简单的手工编码阈值比较差的分类精度。

我已经使用TensorFlow将其简化为一个最小的测试用例。它建立一个感知器（无隐藏层的神经网络），在绝对最小的数据集（一个输入变量，一个二进制输出变量）上训练它，评估结果的分类精度，然后将其与简单手的分类精度进行比较编码的阈值比较；结果分别是60％和80％。直观地讲，这是因为具有大输入值的单个离群值会产生相应的大输出值，因此，将成本函数最小化的方法是，在对两种以上普通情况进行错误分类的过程中，要尽最大努力适应这种情况。感知器正确地执行了被告知要执行的操作；只是这与我们实际想要的分类器不符。

我们如何训练神经网络，使其最终最大化分类精度？

import numpy as np
import tensorflow as tf
sess = tf.InteractiveSession()
tf.set_random_seed(1)

# Parameters
epochs = 10000
learning_rate = 0.01

# Data
train_X = [
    [0],
    [0],
    [2],
    [2],
    [9],
]
train_Y = [
    0,
    0,
    1,
    1,
    0,
]

rows = np.shape(train_X)[0]
cols = np.shape(train_X)[1]

# Inputs and outputs
X = tf.placeholder(tf.float32)
Y = tf.placeholder(tf.float32)

# Weights
W = tf.Variable(tf.random_normal([cols]))
b = tf.Variable(tf.random_normal([]))

# Model
pred …

作为 pytorch 框架（0.4.1）中的练习，我尝试在简单的线性层（Z = XW + B）中显示 X（gX 或 dSdX）的梯度。为了简化我的玩具示例，我从 Z 之和（不是损失）向后（）。

综上所述，我想要 S=sum(XW+B) 的 gX(dSdX)。

问题是 Z (dSdZ) 的梯度为 None。结果，gX 当然也是错误的。

import torch
X = torch.tensor([[0.5, 0.3, 2.1], [0.2, 0.1, 1.1]], requires_grad=True)
W = torch.tensor([[2.1, 1.5], [-1.4, 0.5], [0.2, 1.1]])
B = torch.tensor([1.1, -0.3])
Z = torch.nn.functional.linear(X, weight=W.t(), bias=B)
S = torch.sum(Z)
S.backward()
print("Z:\n", Z)
print("gZ:\n", Z.grad)
print("gX:\n", X.grad)

结果：

Z:
 tensor([[2.1500, 2.9100],
        [1.6000, 1.2600]], grad_fn=<ThAddmmBackward>)
gZ:
 None
gX:
 tensor([[ 3.6000, -0.9000,  1.3000],
        [ 3.6000, -0.9000,  1.3000]])

如果我使用 …