标签: gradient-descent

我试图在java中实现线性回归.我的假设是theta0 + theta1*x [i].我试图找出theta0和theta1的值,以便成本函数最小.我使用渐变下降来找出价值 -

在里面

while(repeat until convergence)
{
   calculate theta0 and theta1 simultaneously.
}

什么是重复直到收敛？我知道它是局部最小值,但是我应该在while循环中放入什么样的代码？

我是机器学习的新手,刚开始编写基本的算法以便更好地理解.任何帮助将不胜感激.

因此，我尝试在 CUDA 中实现随机梯度下降，我的想法是对其进行并行化，类似于使用小批量的最佳分布式在线预测论文中描述的方式

该实现针对的是 MapReduce 分布式环境，因此我不确定它在使用 GPU 时是否是最佳选择。

简而言之，其想法是：在每次迭代时，计算批次（映射）中每个数据点的误差梯度，通过求和/减少梯度来取平均值，最后执行梯度步骤，根据平均梯度更新权重。下一次迭代从更新的权重开始。

推力库允许我对向量执行约简，例如允许我对向量中的所有元素求和。

我的问题是：如何求和/减少 CUDA/thrust 中的向量数组？输入将是一个向量数组，输出将是一个向量，该向量是数组中所有向量的总和（或者理想情况下是它们的平均值）。

我知道这两个功能是火炬的向后传播和界面如下 updateGradInput(input, gradOutput) accGradParameters(input, gradOutput, scale) 我感到困惑的是什么gradInput,并gradOutput真正在层意思.假设网络的成本是C一层L.难道gradInput和gradOutput层的L意思是d_C/d_input_L和d_C/d_output_L？

如果是这样,如何计算gradInput符合gradOutput？

而且,是否accGradParameters意味着积累d_C/d_Weight_L和d_C/d_bias_L？如果是这样,如何计算这些值？

我正在阅读 Sutton & Barto 的Reinforcement Learning: An Introduction 的第 2 章第 7 节，其中涉及多臂老虎机问题中的梯度方法。（我意识到第 2 版是草稿，似乎各节移动了一点，但我的文件有 2.7 节标题为“梯度强盗”。）我设法使用 2.3-2.5 节中的方法没有问题，但我一直使用令人费解的梯度方法获得结果。我将遍历我的代码并展示一个示例。

只是在这里初始化一切：

import random
import math
import numpy as np, numpy.random

# number of arms (k) and step-size (alpha)
k = 10
alpha = 0.1

# initialize preference function (H), and reward distribution (R)
H = {i: 0 for i in range(k)}
R = {i: [random.uniform(-100,100), 1] for i in range(k)}

我使用固定奖励分布，我使用字典来表示这些分布。我假设每个奖励都由高斯描述，因此我使用以下函数将操作映射到奖励：

def getReward(action, rewardDistribution):
  return random.gauss(rewardDistribution[action][0], rewardDistribution[action][1])

所谓的“偏好函数” H …

我正在尝试使用张量流拟合一个非常简单的线性回归模型。然而，损失（均方误差）并没有减少到零，而是急剧增加。

首先，我生成数据：

x_data = np.random.uniform(high=10,low=0,size=100)
y_data = 3.5 * x_data -4 + np.random.normal(loc=0, scale=2,size=100)

然后，我定义计算图：

X = tf.placeholder(dtype=tf.float32, shape=100)
Y = tf.placeholder(dtype=tf.float32, shape=100)
m = tf.Variable(1.0)
c = tf.Variable(1.0)
Ypred = m*X + c
loss = tf.reduce_mean(tf.square(Ypred - Y))
optimizer = tf.train.GradientDescentOptimizer(learning_rate=.1)
train = optimizer.minimize(loss)

最后，运行 100 个 epoch：

steps = {}
steps['m'] = []
steps['c'] = []

losses=[]

for k in range(100):
    _m = session.run(m)
    _c = session.run(c)
    _l = session.run(loss, feed_dict={X: x_data, Y:y_data})
    session.run(train, feed_dict={X: x_data, Y:y_data})
    steps['m'].append(_m) …

我正在尝试设计一个简单的神经网络，但我面临一些问题。当我使用 ReLU 时，我的输出一直收敛到 0.5，当我使用 sigmoid 函数时，我的输出一直收敛到 0.7。请建议我：

1. 还有其他初始化权重和偏差的方法吗？我正在随机初始化它。

2. 我是否需要在每次前向传递后执行反向传播，或者我应该采用平均操作错误并在 epoch 结束时对其进行更新？

3. 我需要在输入层使用偏差吗？

我是神经网络的新手。请帮忙。

下面的代码读取 csv（Andrew NG ML 课程 ex1 多元线性回归练习数据文件），然后尝试使用学习率 alpha = 0.01 将线性模型拟合到数据集。梯度下降是将参数（theta 向量）递减 400 次（alpha 和 num_of_iterations 值在问题陈述中给出）。我尝试了矢量化实现来获得参数的最佳值，但下降并未收敛 - 误差不断增加。

# Imports


```python
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
```

# Model Preparation

## Gradient descent


```python
def gradient_descent(m, theta, alpha, num_of_iterations, X, Y):
#     print(m, theta, alpha, num_of_iterations)
    for i in range(num_of_iterations):
        htheta_vector = np.dot(X,theta)
#         print(X.shape, theta.shape, htheta_vector.shape)
        error_vector = htheta_vector - Y
        gradient_vector = (1/m) * (np.dot(X.T, error_vector)) # each element in …

我是 Pytorch 的新手，我正在尝试在嵌入上实现一种“训练后”程序。

我有一个包含一组项目的词汇表，并且我已经为每个项目学习了一个向量。我将学习到的向量保存在 nn.Embedding 对象中。我现在想做的是将新项目添加到词汇表中，而不更新已经学习的向量。新项目的嵌入将被随机初始化，然后在保持所有其他嵌入冻结的同时进行训练。

我知道为了防止 nn.Embedding 被训练，我需要设置False它的requires_grad变量。我还发现了与我类似的另一个问题。最佳答案建议

1. 要么存储冻结向量和要在不同的 nn.Embedding 对象中训练的向量，前者使用requires_grad = False，后者使用requires_grad = True

2. 或者将冻结的向量和新的向量存储在同一个 nn.Embedding 对象中，计算所有向量的梯度，但仅在新项的向量的维度上进行降序。然而，这会导致性能的相关下降（当然，我想避免这种情况）。

我的问题是，我确实需要将新项目的向量存储在与旧项目的冻结向量相同的 nn.Embedding 对象中。这个约束的原因如下：当使用项目（旧的和新的）的嵌入构建我的损失函数时，我需要根据项目的 id 查找向量，出于性能原因，我需要使用 Python 切片。换句话说，给定一个项目 ids 列表item_ids，我需要做类似的事情vecs = embedding[item_ids]。如果我对旧项目和新项目使用两个不同的 nn.Embedding 项目，我将需要使用带有 if-else 条件的显式 for 循环，这会导致性能更差。

我有什么办法可以做到这一点吗？

import torch
import torchvision.models as models
model = models.resnet18()
optimizer = torch.optim.SGD(model.parameters(), lr=1e-3)
x = torch.randn(1, 3, 224, 224)
y = torch.randn(1, 3, 224, 224)

#第一种方法

loss1 = model(x).mean()
loss2 = model(y).mean()
(loss1+loss2).backward()
optimizer.step()

我想转发两个数据集，它们的总损失将用于向后和更新一个模型。这种做法正确吗？

#第二种方法

loss1 = model(x).mean()
loss1.backward()
loss2 = model(y).mean()
loss2.backward()
optimizer.step()

第一种方法和第二种方法有什么区别？

我有一组数据,每个条目有9个"功能"(正数从1e-3到9e3),我需要使用每个条目的功能为条目选择5个可能的标签之一.

我知道我需要定义一个评分函数,它接收特征,对它们进行加权,并返回一个数字,反映每个标签被赋予这些特征和权重的可能性.损失函数将在输入上凸出:它将返回评分函数的输出与人工提供的标签之间的差异.评分函数的权重矩阵将通过梯度下降来优化,使得损失最小化.

具体来说,我有一些看起来像这样的东西:

entry 1> (ground-truth label), [0.9, 0.2, 1e-2, 6.853, 0.882 ... 1]
    *prediction: label 3* *actually: label 4* *loss = some number, update weights*
entry 2> (ground-truth label), [features 1...9]
    *prediction: label 1* *actually: label 1* *loss = 0, don't update weights*
...
entry 80,000> (etc...)

如何选择将这些特征映射到五个可能标签之一的可能性的评分函数？

看起来像是这样的:

for (loop through all data)
    [features] <dot product> [weights] = prediction
    if(prediction near (number))
        assign label 1
    else if (prediction near (number 2)
        assign label 2
    else (etc...)

    hinge_loss_function(prediction) = …