标签: gradient-descent

我正试图在朱莉娅的Coursera做Logistic回归,但它不起作用.

用于计算渐变的Julia代码:

sigmoid(z) = 1 / (1 + e ^ -z)

hypotesis(theta, x) = sigmoid(scalar(theta' * x))

function gradient(theta, x, y)
    (m, n) = size(x)
    h = [hypotesis(theta, x[i,:]') for i in 1:m]
    g = Array(Float64, n, 1)
    for j in 1:n
        g[j] = sum([(h[i] - y[i]) * x[i, j] for i in 1:m])
    end
    g
end

如果使用此梯度,则会产生错误的结果.无法弄清楚原因,代码似乎是正确的.

该全朱莉娅脚本.在此脚本中,使用我的Gradient Descent实现和使用内置Optim包计算出最佳Theta,结果不同.

我正在使用最速下降法来找出具有5x5希尔伯特矩阵的线性系统的解.我相信代码很好,因为它给了我正确的答案.

我的问题是:

1. 我认为这需要太多的迭代才能得到正确的答案.我相信我可能错过了算法中的一些东西,但我不知道此时是什么.

2. 我不确定这是否是实现算法的最有效方法,另外,选择"tol"有点令人困惑.

任何有关这些的见解将不胜感激(尤其是1.).谢谢!

% Method of Steepest Descent with tol 10^-6
h = hilb(5);                            %Hilbert 5x5 matrix
b = [1;1;1;1;1];                        %solution matrix
solution = zeros(d,1);                  %Initialization 
residual = h*solution - b;
tol = 10^(-6)
count = 0; 

while residual'*residual > tol;
    roe = (residual'*residual)/(residual'*h*residual);
    solution = solution - roe*residual;
    residual = h*solution - b;
    count = count + 1;
end

count 
solution 


%Method of Steepest Descent with tol 10^-12
solution = zeros(d,1);
residual = h*solution - …

我想在 Tensorflow 中实现直接反馈对齐。

参考论文：https ://arxiv.org/pdf/1609.01596v5.pdf，Nøkland (2016)

我实现了一个简单的网络，它在纯 Python 中执行 DFA，明确反向传播，我只是将 BP 的反向传递与 DFA 之一切换。

其中 B1 和 B2 是两个具有适当维度的随机矩阵。

Tensorflow 训练显然默认进行反向传播。为了获得这种训练行为，我应该在 Tensorflow 代码中的什么地方进行修改？

我正在使用一些递归神经网络结构进行多标签分类。我的问题是关于损失函数的：我的输出将是true / false（1/0）值的向量，以指示每个标签的类。许多资源表示，汉明损失是适当的目标。但是，汉明损耗在梯度计算中存在问题： H =平均值（y_true XOR y_pred），XOR无法得出损耗的梯度。那么，还有其他损失函数可用于训练多标签分类吗？我已经尝试过使用单独的S型输入进行MSE和二进制交叉熵。

我有一个使用 Keras 函数式 API 解决的监督学习问题。

由于这个模型预测物理系统的状态，我知道监督模型应该遵循额外的约束。

我想补充一点，作为一个额外的损失项，它会惩罚模型做出不遵循这些约束的预测。不幸的是，监督学习问题的训练示例数量 >> 约束示例数量。

基本上，我正在尝试这样做：

最小化监督学习误差和作为辅助损失的约束误差。

我不相信在每个数据集上交替训练批次会成功，因为梯度一次只能捕获一个问题的错误，当我真的希望物理约束作为监督学习任务的正则化时。（如果我的解释不正确，请告诉我）。

我知道这可以在纯 Tensorflow 或 Theano 中实现，但我对离开 Keras 生态系统犹豫不决，因为它使其他一切变得如此方便。如果有人知道如何训练批量大小因输入而异的模型，我将非常感谢您的帮助。

我正在训练一个具有多重损失的网络，并且使用生成器创建数据并将数据馈送到我的网络中。

我已经检查了数据的结构，它总体上看起来不错，并且在大多数情况下也几乎按照预期进行了训练，但是在几乎每次随机时期，每个预测的训练损失突然从

# End of epoch 3
loss: 2.8845 

到

# Beginning of epoch 4
loss: 1.1921e-07

我认为这可能是数据，但是，据我所知，数据通常很好，而且更加可疑，因为这将发生在随机时期（可能是因为在 SGD 期间选择了随机数据点？）但会持续存在在剩下的训练中。就像在 epoch 3 时，训练损失减少到1.1921e-07那么它将在 epoch 4、epoch 5 等中继续这样。

但是，有时它到达 epoch 5 并且还没有这样做，然后可能会在 epoch 6 或 7 进行。

在数据之外是否有任何可行的原因可能导致这种情况？一些模糊的数据点会导致如此快吗？

谢谢

编辑：

结果：

300/300 [==============================] - 339s - loss: 3.2912 - loss_1: 1.8683 - loss_2: 9.1352 - loss_3: 5.9845 - 
val_loss: 1.1921e-07 - val_loss_1: 1.1921e-07 - val_loss_2: 1.1921e-07 - val_loss_3: 1.1921e-07

此后的下一个时期都有训练损失 1.1921e-07

https://www.tensorflow.org/versions/r1.6/api_docs/python/tf/gradients

在 tf.gradients(ys, xs) 的文档中，它指出

构造 ys wrt x in xs 的符号导数

我对求和部分感到困惑，我在其他地方读到过，它对批次中的每个 x 的批次中的导数 dy/dx 求和。但是，每当我使用它时，我都看不到这种情况发生。举个简单的例子：

x_dims = 3
batch_size = 4

x = tf.placeholder(tf.float32, (None, x_dims))

y = 2*(x**2)

grads = tf.gradients(y,x)

sess = tf.Session()

x_val = np.random.randint(0, 10, (batch_size, x_dims))
y_val, grads_val = sess.run([y, grads], {x:x_val})

print('x = \n', x_val)
print('y = \n', y_val)
print('dy/dx = \n', grads_val[0])

这给出了以下输出：

x = 
 [[5 3 7]
 [2 2 5]
 [7 5 0]
 [3 7 6]]
y = 
 [[50. 18. …

我正在尝试实现一个版本的差异私有随机梯度下降（例如this），如下所示：

计算大小为 L 的批次中每个点的梯度，然后分别裁剪 L 个梯度中的每一个，然后将它们平均在一起，最后执行（噪声）梯度下降步骤。

在 pytorch 中执行此操作的最佳方法是什么？

最好有一种方法可以同时计算批处理中每个点的梯度：

x # inputs with batch size L
y #true labels
y_output = model(x)
loss = loss_func(y_output,y) #vector of length L
loss.backward() #stores L distinct gradients in each param.grad, magically

但是失败了，分别计算每个梯度，然后在累积之前裁剪范数，但是

x # inputs with batch size L
y #true labels
y_output = model(x)
loss = loss_func(y_output,y) #vector of length L   
for i in range(loss.size()[0]):
    loss[i].backward(retain_graph=True)
    torch.nn.utils.clip_grad_norm(model.parameters(), clip_size)

累积第 i 个梯度，然后剪辑，而不是先剪辑再累积到梯度中。解决此问题的最佳方法是什么？

我正在尝试用Python创建一个简单的线性模型,不使用库(除了numpy).这就是我所拥有的

import numpy as np

import pandas

np.random.seed(1)

alpha = 0.1

def h(x, w):
  return np.dot(w.T, x)

def cost(X, W, Y):
  totalCost = 0
  for i in range(47):
    diff = h(X[i], W) - Y[i]
    squared = diff * diff
    totalCost += squared

  return totalCost / 2

housing_data = np.loadtxt('Housing.csv', delimiter=',')

x1 = housing_data[:,0]
x2 = housing_data[:,1]
y = housing_data[:,2]

avgX1 = np.mean(x1)
stdX1 = np.std(x1)
normX1 = (x1 - avgX1) / stdX1
print('avgX1', avgX1)
print('stdX1', stdX1)

avgX2 = …

我试图使用 SGD 最小化损失，但是当我使用 SGD 时它抛出错误，我试图在 tensorflow 2.0 中做到这一点，导致问题的一个附加参数是 var_list

import tensorflow as tf
import numpy
import matplotlib.pyplot as plt
rng = numpy.random
print(rng)

# Parameters
learning_rate = 0.01
training_epochs = 1000
display_step = 50

# Training Data
train_X = numpy.asarray([3.3,4.4,5.5,6.71,6.93,4.168,9.779,6.182,7.59,2.167,
                         7.042,10.791,5.313,7.997,5.654,9.27,3.1])
train_Y = numpy.asarray([1.7,2.76,2.09,3.19,1.694,1.573,3.366,2.596,2.53,1.221,
                         2.827,3.465,1.65,2.904,2.42,2.94,1.3])
n_samples = train_X.shape
print(n_samples)

X = tf.Variable(train_X, name = 'X' ,dtype = 'float32')
Y = tf.Variable(train_Y, name = 'Y' ,dtype = 'float32')
print(X)

# Set model weights
W = tf.Variable(rng.randn(), name="weight")
b = tf.Variable(rng.randn(), name="bias") …