我正在用张量流求解这个方程组：

f1 = y - x*x = 0
f2 = x - (y - 2)*(y - 2) + 1.1 = 0

如果我选择错误的起点 (x,y)=(-1.3,2)，那么我会使用以下代码进入局部最小值优化 f1^2+f2^2：

f1 = y - x*x
f2 = x - (y - 2)*(y - 2) + 1.1
sq=f1*f1+f2*f2
o = tf.train.AdamOptimizer(1e-1).minimize(sq)
with tf.Session() as sess:
    init = tf.global_variables_initializer()
    sess.run([init])
    for i in range(50):
        sess.run([o])
        r=sess.run([x,y,f1,f2])
        print("x",r)

如何使用内置张量流工具摆脱这个局部最小值？可能还有其他 TF 方法可以用来从这个坏点开始求解这个方程吗？

我知道可以使用梯度下降训练神经网络，并且我了解它是如何工作的。

最近，我偶然发现了其他训练算法：共轭梯度和拟牛顿算法。我试图了解它们是如何工作的，但我能得到的唯一好的直觉是它们使用了高阶导数。

我的问题如下：我提到的那些替代算法与使用损失函数梯度调整权重的反向传播过程有根本的不同吗？如果没有，是否有一种算法可以训练一个与反向传播机制根本不同的神经网络？

谢谢

我在 Eager Execution 中使用 TensorFlow 1.12，我想在训练期间检查不同点的梯度值和权重以进行调试。这个答案使用 TensorBoard 来获得很好的权重和梯度分布图，这正是我想要的。但是，当我使用Keras 的 TensorBoard callback 时，我得到了这个：

WARNING:tensorflow:Weight and gradient histograms not supported for eagerexecution, setting `histogram_freq` to `0`.

换句话说，这与急切执行不兼容。有没有其他方法可以打印渐变和/或权重？大多数非 TensorBoard 答案似乎依赖于基于图的执行。

如果我提供整个数据并且不指定批量大小，pytorch SGD 会做什么？在这种情况下，我看不到任何“随机”或“随机性”。例如，在下面的简单代码中，我将整个数据(x,y)输入到一个模型中。

optimizer = torch.optim.SGD(model.parameters(), lr=0.1)  
for epoch in range(5):
    y_pred = model(x_data)
    loss = criterion(y_pred, y_data)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

假设有100个数据对(x,y)，即，x_data和y_data每个都具有100个元素。

问题：在我看来，所有 100 个梯度都是在一次参数更新之前计算出来的。“mini_batch”的大小是 100，而不是 1。所以没有随机性，对吗？起初，我认为 SGD 意味着随机选择 1 个数据点并计算其梯度，这将用作所有数据中真实梯度的近似值。

在处理更复杂的事情之前，我知道我必须实现自己的backward通行证，我想尝试一些简单而美好的事情。因此，我尝试使用 PyTorch 进行均方误差损失的线性回归。当我定义自己的backward方法时出错了（参见下面的第三个实现选项），我怀疑这是因为我没有很清楚地考虑我需要将 PyTorch 作为渐变发送什么。所以，我怀疑我需要的是关于 PyTorch 希望我在这里以何种形式提供的一些解释/澄清/建议。

我正在使用 PyTorch 1.7.0，因此一堆旧示例不再有效（使用文档中描述的用户定义的 autograd 函数的不同方式）。

第一种方法（标准 PyTorch MSE 损失函数）

让我们首先在没有自定义损失函数的情况下使用标准方法：

import torch
import torch.nn as nn
import torch.nn.functional as F

# Let's generate some fake data
torch.manual_seed(42)
resid = torch.rand(100)    
inputs = torch.tensor([ [ xx ] for xx in range(100)] , dtype=torch.float32)
labels = torch.tensor([ (2 + 0.5*yy + resid[yy]) for yy in range(100)], dtype=torch.float32)

# Now we define a linear regression model
class linearRegression(torch.nn.Module):
    def __init__(self, …

我正在尝试通过实施本文中描述的加权损失方法来改进我制作的 CNN 。为此，我研究了这个笔记本，它实现了论文中描述的方法的伪代码。

RuntimeError: One of the differentiated Tensors appears to not have been used in the graph. Set allow_unused=True if this is the desired behavior当将他们的代码转换为我的模型时，我在使用时遇到了错误torch.autograd.grad()。

我的代码和错误位于倒数第二行：

for epoch in range(1): #tqdm(range(params['epochs'])):
  model.train()
  text_t, labels_t = next(iter(train_iterator))
  text_t = to_var(text_t, requires_grad=False)
  labels_t = to_var(labels_t, requires_grad=False)
  dummy = L2RWCNN(INPUT_DIM, EMBEDDING_DIM, N_FILTERS, FILTER_SIZES, OUTPUT_DIM, 
                DROPOUT, PAD_IDX)
  dummy.state_dict(model.state_dict())
  dummy.cuda()
  y_f_hat = dummy(text_t)
  cost = F.binary_cross_entropy_with_logits(y_f_hat.squeeze(), labels_t, reduce = False)
  eps = to_var(torch.zeros(cost.size()))
  l_f_meta = torch.sum(cost * eps) …

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] …

我正在尝试比较神经网络的 SGD 和 GD 算法的收敛速度。在 PyTorch 中，我们经常使用 SGD 优化器，如下所示。

train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)
optimizer = torch.optim.SGD(model.parameters(), lr=0.001)

for epoch in range(epochs):
    running_loss = 0

    for input_batch, labels_batch in train_dataloader:

        input = input_batch

        y_hat = model(input)
        y = labels_batch
        L = loss(y_hat, y)
        
        optimizer.zero_grad()
        L.backward()
        
        optimizer.step()
        
        running_loss += L.item()

我对优化器的理解是，SGD 优化器实际上执行小批量梯度下降算法，因为我们一次向优化器提供一批数据。因此，如果我们将batch_size参数设置为所有数据的大小，代码实际上会对神经网络进行梯度下降。

我的理解正确吗？

我想使用 PyTorch 实现非负矩阵分解。这是我最初的实现：

def nmf(X, k, lr, epochs):
    # X: input matrix of size (m, n)
    # k: number of latent factors
    # lr: learning rate
    # epochs: number of training epochs
    m, n = X.shape
    W = torch.rand(m, k, requires_grad=True)  # initialize W randomly
    H = torch.rand(k, n, requires_grad=True)  # initialize H randomly
    # training loop
    for i in range(epochs):
        # compute reconstruction error
        loss = torch.norm(X - torch.matmul(W, H), p='fro')
        # compute gradients
        loss.backward()
        # update parameters using …

我正在尝试使用R中的随机递减梯度对逻辑回归进行编程.例如,我按照Andrew Ng的例子命名:"ex2data1.txt".

关键是算法运行正常,但是估计并不完全符合我的预期.所以我试图改变整个算法以解决这个问题.但是,对我来说几乎是不可能的.我无法检测到导致此问题的错误.因此,如果有人可以检查示例并告诉我为什么没有正确计算这将是非常有用的.对此,我真的非常感激.

关于编程,我没有使用 R 或矩阵计算中实现的任何函数.我只是在循环中使用求和和减法,因为我想在hadoop中使用代码而我不能使用矩阵演算甚至是已经在R中编程的函数,例如"sum","sqrt"等等

随机梯度下降是:

Loop {
   for i = 1 to m, {
     ?j := ?j + ?(y(i) - h?(x(i)))(xj)(i)
  }
}`

和逻辑回归:

我的代码是:

data1 <- read.table("~/ex2data1.txt", sep = ",")
names(data1) <- c("Exam1", "Exam2", "Admit")

# Sample the data for stochastic gradient decent 

ss<-data1[sample(nrow(data1),size=nrow(data1),replace=FALSE),]

x <- with(ss, matrix(cbind(1, Exam1), nrow = nrow(ss)))
y <- c(ss$Admit)
m <- nrow(x)

# startup parameters

iterations<-1
j<-vector()
alpha<-0.05
theta<-c(0,0)



#My loop

while(iterations<=10){

    coste<-c(0,0)
    suma<-0

    for(i in 1:m){

        # …