标签: gradient-descent

我将把我的第一个相对较大的CUDA项目编码为Gradient Descent Optimization,用于机器学习目的.我希望从群众智慧中获益,了解CUDA的一些有用的本机功能,这些功能可能是项目中使用的捷径.有什么想法/建议吗？

我已经通过一些在线资源教自己机器学习,但我有一个关于梯度下降的问题,我无法弄清楚.

梯度下降的公式由以下物流回归给出:

Repeat {
    ?j = ?j??/m?(h?(x)?y)xj
}

?j变量j的系数在哪里; ?是学习率; h?(x)是假设; y是实数值,xj是变量j的值.m是训练集的数量.h?(x),y适用于每个训练集(即总和符号的用途).

这是我感到困惑的地方.

我不清楚总和是代表我的整个训练集还是我已经完成了多少次迭代.

例如,假设我有10个训练样例.如果我在每个训练样例之后执行梯度下降,那么我的系数将会非常不同,如果我在所有10个训练样例之后执行梯度下降.

请参阅下文第一种方式与第二种方式的不同之处:

第一种方式

• 步骤1:由于系数初始化为0,因此hθ(x)= 0
• 步骤2:在第一个训练示例中执行梯度下降. 求和项仅包括1个训练示例
• 步骤3:现在使用新系数训练示例1和2 ... 求和项包括前2个训练样例
• 第4步:再次执行梯度下降.
• 步骤5:现在使用新系数训练示例1,2和3 ... 求和项包括前3个训练样例
• 继续直到收敛或使用所有训练示例.

第二种方式

• 步骤1:由于系数初始化为0,因此对于所有10个训练样例,hθ(x)= 0
• 步骤2:使用所有10个训练样例执行梯度下降的1个步骤.系数将与第一种方式不同,因为求和项包括所有10个训练样例
• 步骤3:再次对所有10个训练样例使用新系数.求和项包括所有10个训练样例
• 步骤4:执行梯度下降并继续使用所有示例上的系数直到收敛

我希望这能解释我的困惑.有谁知道哪种方法是正确的？

编辑:添加成本函数和假设函数

cost function = ?1/m?[ylog(h?(x))+(1?y)log(1?h?(x))]
h?(x) = 1/(1+ e^-z) 
and z= ?o + ?1X1+?2X2 +?3X3...?nXn

我通过在线资源(即在课程中学习机器学习)学习了梯度下降.然而,所提供的信息仅表示重复梯度下降直到它收敛.

他们对收敛的定义是使用成本函数相对于迭代次数的图表,并在图表变平时观察.因此我假设我会做以下事情:

if (change_in_costfunction > precisionvalue) {
          repeat gradient_descent
} 

或者,我想知道确定收敛的另一种方法是观察系数方法它的真实价值:

if (change_in_coefficient_j > precisionvalue) {
          repeat gradient_descent_for_j
} 
...repeat for all coefficients

基于成本函数或系数的收敛也是如此？我们如何确定精度值？它应该是系数或总成本函数的百分比吗？

我正在阅读Theano文档主页上提供的本教程

我不确定梯度下降部分给出的代码.

我对for循环有疑问.

如果将' param_update '变量初始化为零.

param_update = theano.shared(param.get_value()*0., broadcastable=param.broadcastable)

然后在剩下的两行中更新其值.

updates.append((param, param - learning_rate*param_update))
updates.append((param_update, momentum*param_update + (1. - momentum)*T.grad(cost, param)))

我们为什么需要它？

我想我在这里弄错了.你们能帮助我吗!

如何在套索的背景下轻松解释坐标下降和次梯度解决方案.

一个直观的解释后面的证明将是有帮助的.

我是机器学习的新手，我正在尝试分析我的一个项目的分类算法。我SGDClassifier在sklearn图书馆遇到的。但是很多论文都将 SGD 称为一种优化技术。有人可以解释一下是如何SGDClassifier实施的吗？

这可能是Tensorflow的重复:如何在批处理中获得每个实例的渐变？.无论如何,我问它,因为没有一个令人满意的答案,这里的目标有点不同.

我有一个非常大的网络,我可以放在我的GPU上,但我可以提供的最大批量大小是32.任何大于此的东西都会导致GPU耗尽内存.我想使用更大的批次以获得更精确的渐变近似值.

具体来说,假设我想通过依次喂3批32个来计算大批量96的梯度.我所知道的最好方法是使用Optimizer.compute_gradients()和Optimizer.apply_gradients().这是一个小例子,它是如何工作的

import tensorflow as tf
import numpy as np

learn_rate = 0.1

W_init = np.array([ [1,2,3], [4,5,6], [7,8,9] ], dtype=np.float32)
x_init = np.array([ [11,12,13], [14,15,16], [17,18,19] ], dtype=np.float32)

X = tf.placeholder(dtype=np.float32, name="x")
W = tf.Variable(W_init, dtype=np.float32, name="w")
y = tf.matmul(X, W, name="y")
loss = tf.reduce_mean(y, name="loss")

opt = tf.train.GradientDescentOptimizer(learn_rate)
grad_vars_op = opt.compute_gradients(loss)

sess = tf.Session()
sess.run(tf.global_variables_initializer())

# Compute the gradients for each batch
grads_vars1 = sess.run(grad_vars_op, feed_dict = {X: x_init[None,0]}) …

我正在按照本教程实现Backpropagation算法.但是,我坚持实施此算法的动力.

没有Momentum,这是权重更新方法的代码:

def update_weights(network, row, l_rate):
    for i in range(len(network)):
        inputs = row[:-1]
        if i != 0:
            inputs = [neuron['output'] for neuron in network[i - 1]]
        for neuron in network[i]:
            for j in range(len(inputs)):
                neuron['weights'][j] += l_rate * neuron['delta'] * inputs[j]
            neuron['weights'][-1] += l_rate * neuron['delta']

以下是我的实施:

def updateWeights(network, row, l_rate, momentum=0.5):
    for i in range(len(network)):
        inputs = row[:-1]
        if i != 0:
            inputs = [neuron['output'] for neuron in network[i-1]]
        for neuron in network[i]:
            for j in range(len(inputs)): …

给定简单的或门问题：

or_input = np.array([[0,0], [0,1], [1,0], [1,1]])
or_output = np.array([[0,1,1,1]]).T

如果我们训练一个简单的单层感知器（不进行反向传播），则可以执行以下操作：

import numpy as np
np.random.seed(0)

def sigmoid(x): # Returns values that sums to one.
    return 1 / (1 + np.exp(-x))

def cost(predicted, truth):
    return (truth - predicted)**2

or_input = np.array([[0,0], [0,1], [1,0], [1,1]])
or_output = np.array([[0,1,1,1]]).T

# Define the shape of the weight vector.
num_data, input_dim = or_input.shape
# Define the shape of the output vector. 
output_dim = len(or_output.T)

num_epochs = 50 # No. of times to iterate.
learning_rate …

from math import exp
import numpy as np
from sklearn.linear_model import LogisticRegression

我使用了下面的代码来自 How To Implement Logistic Regression From Scratch in Python

def predict(row, coefficients):
    yhat = coefficients[0]
    for i in range(len(row)-1):
        yhat += coefficients[i + 1] * row[i]
    return 1.0 / (1.0 + exp(-yhat))

def coefficients_sgd(train, l_rate, n_epoch):
    coef = [0.0 for i in range(len(train[0]))]
    for epoch in range(n_epoch):
        sum_error = 0
        for row in train:
            yhat = predict(row, coef)
            error = row[-1] - yhat
            sum_error += error**2
            coef[0] …