标签: gradient-descent

我正在Matlab上实现批量梯度下降.我的更新步骤有问题theta. theta是两个组件(两行)的向量. X是包含m行(训练样本数)和n=2列(特征数)的矩阵.Y是m行向量.

在更新步骤中,我需要将每个设置theta(i)为

theta(i) = theta(i) - (alpha/m)*sum((X*theta-y).*X(:,i))

这可以通过for循环完成,但我无法弄清楚如何对其进行矢量化(因为该X(:,i)术语).

有什么建议吗？

我使用scipy.optimize.fmin_l_bfgs_b来解决高斯混合问题.混合分布的均值通过回归建模,其权重必须使用EM算法进行优化.

sigma_sp_new, func_val, info_dict = fmin_l_bfgs_b(func_to_minimize, self.sigma_vector[si][pj], 
                       args=(self.w_vectors[si][pj], Y, X, E_step_results[si][pj]),
                       approx_grad=True, bounds=[(1e-8, 0.5)], factr=1e02, pgtol=1e-05, epsilon=1e-08)

但有时我在信息词典中收到警告"ABNORMAL_TERMINATION_IN_LNSRCH":

func_to_minimize value = 1.14462324063e-07
information dictionary: {'task': b'ABNORMAL_TERMINATION_IN_LNSRCH', 'funcalls': 147, 'grad': array([  1.77635684e-05,   2.87769808e-05,   3.51718654e-05,
         6.75015599e-06,  -4.97379915e-06,  -1.06581410e-06]), 'nit': 0, 'warnflag': 2}

RUNNING THE L-BFGS-B CODE

           * * *

Machine precision = 2.220D-16
 N =            6     M =           10
 This problem is unconstrained.

At X0         0 variables are exactly at the bounds

At iterate    0    f=  1.14462D-07    |proj g|=  3.51719D-05

           * * …

我正在努力训练一个非常大的模型.因此,我只能将非常小的批量大小放入GPU内存中.使用小批量大小会产生非常嘈杂的梯度估计.
我该怎么做才能避免这个问题？

当在训练期间遇到困难时(nans,损失不会收敛等),通过debug_info: true在'solver.prototxt'文件中设置来查看更详细的训练日志有时是有用的.

然后训练日志看起来像:

I1109 ...]     [Forward] Layer data, top blob data data: 0.343971    
I1109 ...]     [Forward] Layer conv1, top blob conv1 data: 0.0645037
I1109 ...]     [Forward] Layer conv1, param blob 0 data: 0.00899114
I1109 ...]     [Forward] Layer conv1, param blob 1 data: 0
I1109 ...]     [Forward] Layer relu1, top blob conv1 data: 0.0337982
I1109 ...]     [Forward] Layer conv2, top blob conv2 data: 0.0249297
I1109 ...]     [Forward] Layer conv2, param blob 0 …

Run Code Online (Sandbox Code Playgroud)

哪个optimizer与loss？之间有明确的联系？

优化器如何知道在没有通话的情况下从哪里获得损失的梯度optimizer.step(loss)？

- 更多背景 -

当我最小化损失时,我没有必要将渐变传递给优化器.

loss.backward() # Back Propagation
optimizer.step() # Gardient Descent

我试图理解PyTorch. 我的问题与这两个有些相关：

为什么我们需要在 PyTorch 中调用 zero_grad()？

为什么我们需要显式调用 zero_grad()？

对第二个问题的已接受答案的评论表明，如果小批量太大而无法在单个前向传递中执行梯度更新，因此必须将其拆分为多个子批次，则可以使用累积梯度。

考虑以下玩具示例：

import numpy as np
import torch


class ExampleLinear(torch.nn.Module):

    def __init__(self):
        super().__init__()
        # Initialize the weight at 1
        self.weight = torch.nn.Parameter(torch.Tensor([1]).float(),
                                         requires_grad=True)

    def forward(self, x):
        return self.weight * x


if __name__ == "__main__":
    # Example 1
    model = ExampleLinear()

    # Generate some data
    x = torch.from_numpy(np.array([4, 2])).float()
    y = 2 * x

    optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

    y_hat = model(x)          # forward pass

    loss = (y - y_hat) ** 2 …

短格式:

如何通过R中的梯度下降实现多类Logistic回归分类算法？可optim()当有两个以上的标签可以用吗？

MatLab代码是:

function [J, grad] = cost(theta, X, y, lambda)
    m = length(y);
    J = 0;
    grad = zeros(size(theta));
    h_theta = sigmoid(X * theta);
    J = (-1/m)*sum(y.*log(h_theta) + (1-y).*log(1-h_theta)) +...
    (lambda/(2*m))*sum(theta(2:length(theta)).^2);
    trans = X';
    grad(1) = (1/m)*(trans(1,:))*(h_theta - y);
    grad(2:size(theta, 1)) = 1/m * (trans(2:size(trans,1),:)*(h_theta - y) +...
    lambda * theta(2:size(theta,1),:));
    grad = grad(:);
end

和...

function [all_theta] = oneVsAll(X, y, num_labels, lambda)
    m = size(X, 1);
    n = size(X, 2);
    all_theta = zeros(num_labels, n + 1); …

我在 PyTorch 中训练模型的程序的收敛性比 TensorFlow 实现的要差。当我改用 SGD 而不是 Adam 时，损失是相同的。对于 Adam，损失从第一个时期开始就不同了。我相信我在两个程序中使用相同的设置。关于如何调试这个的任何想法都会有帮助！

使用 SGD 计算的损失

火炬

0.1504615843296051
0.10858417302370071
0.08603279292583466

TensorFlow

0.15046157
0.108584
0.08603277

使用 Adam 的损失

火炬

0.0031117501202970743
0.0020642257295548916
0.0019268309697508812
0.0016333406092599034
0.0017334128497168422
0.0014430736191570759
0.0010424457723274827
0.0012145100627094507
0.0011195113183930516
0.0009501167223788798
0.0009987876983359456
0.0007953296881169081
0.00075263757025823
0.0008374055614694953
0.000735406531020999

张力流：

0.0036667113
0.0032563617
0.0021536187
0.0015266595
0.0013580231
0.0013878695
0.0011856346
0.0011136091
0.00091276
0.000890126
0.00088381825
0.0007283067
0.00081382995
0.0006670901
0.00046282331

Adam 优化器设置

TF 1.15.3：

adam_optimizer = tf.train.AdamOptimizer(learning_rate=5e-5)

# default parameters from the documentation at https://github.com/tensorflow/tensorflow/blob/v1.15.0/tensorflow/python/training/adam.py#L32-L235:
# learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-8, use_locking=False, name="Adam")

火炬

torch.optim.Adam(params=model.parameters(), …

假设我有自定义损失函数，并且我想在神经网络的帮助下拟合某些微分方程的解。因此，在每次前向传递中，我都会计算神经网络的输出，然后通过采用 MSE 和我想要拟合感知器的预期方程来计算损失。

现在我的疑问是：我应该使用grad(loss)反向loss.backward()传播来计算和更新我的梯度吗？

我知道，在使用 loss.backward() 时，我必须用 Variable 包装我的张量，并且必须为我想要获取损失梯度的变量设置 require_grad = True 。

所以我的问题是：

• 是否grad(loss)还需要任何此类显式参数来识别梯度计算的变量？
• 它实际上是如何计算梯度的？
• 哪种方法更好？
• 在实际场景中两者的主要区别是什么？

如果您能解释这两种方法的实际含义，那就更好了，因为每当我试图在网上找到它时，我都会被很多与我的项目不太相关的东西轰炸。

在pytorch中执行梯度剪切的正确方法是什么？

我有一个爆炸性的渐变问题，我需要解决这个问题。