获取Pytorch autograd用于计算梯度的精确公式
PyTorch是一个开源的机器学习框架，它提供了自动求导（autograd）的功能，用于计算梯度。在PyTorch中，autograd模块是实现自动求导的核心部分。
autograd模块使用动态计算图来跟踪和记录所有的操作，从而实现自动求导。它能够根据输入和前向传播过程自动构建计算图，并在反向传播过程中自动计算梯度。这使得开发者可以方便地定义和训练复杂的神经网络模型。
PyTorch的autograd模块具有以下特点和优势：
- 动态计算图：PyTorch的计算图是动态的，可以根据实际情况进行构建和修改，而不需要预先定义静态计算图。这使得模型的构建更加灵活和易于调试。
- 自动求导：autograd模块能够自动计算张量的梯度，无需手动编写反向传播的代码。只需要将张量设置为需要求导的状态，即可自动追踪和计算梯度。
- 高效性能：PyTorch的autograd模块使用了基于动态计算图的优化技术，能够高效地计算梯度，并且支持GPU加速，提供了快速的训练和推理能力。
- 灵活的扩展性：autograd模块提供了丰富的函数和操作，可以支持各种数学运算和神经网络层的自动求导。同时，开发者也可以自定义函数和操作，并利用autograd模块的功能进行自动求导。
PyTorch autograd的应用场景非常广泛，包括但不限于：
- 深度学习模型训练：autograd模块可以用于训练各种类型的神经网络模型，包括卷积神经网络、循环神经网络、生成对抗网络等。它能够自动计算模型参数的梯度，从而实现模型的优化和更新。
- 梯度下降算法：autograd模块可以用于实现各种梯度下降算法，如随机梯度下降（SGD）、Adam、Adagrad等。通过计算梯度，可以更新模型参数以最小化损失函数。
- 强化学习：autograd模块可以用于实现强化学习算法，如深度Q网络（DQN）、策略梯度等。通过计算梯度，可以优化智能体的策略，使其在环境中获得更好的表现。
- 自然语言处理：autograd模块可以用于训练和优化各种自然语言处理模型，如循环神经网络语言模型（RNNLM）、Transformer等。通过计算梯度，可以提高模型在文本生成、机器翻译等任务中的性能。
对于PyTorch autograd的详细介绍和使用方法，可以参考腾讯云的相关产品和文档：
- 腾讯云PyTorch产品介绍：https://cloud.tencent.com/product/pytorch
- PyTorch官方文档：https://pytorch.org/docs/stable/autograd.html
总结：PyTorch的autograd模块是一个强大的自动求导工具，能够帮助开发者快速构建和训练各种机器学习模型。它具有动态计算图、自动求导、高效性能和灵活扩展性等优势，适用于深度学习、梯度下降算法、强化学习、自然语言处理等多个领域的应用场景。
相关·内容
1回答
什么是以磁带为基础的自修课程？
、、、、
我知道autograd是用来暗示自动区分的。但是，究竟什么是tape-based autograd in Pytorch，以及为什么会有这么多的讨论来肯定或否认它。
例如：
在火把中，没有传统意义上的磁带。
和
我们并不是真正建立梯度磁带本身。但是图表。
但不是
Autograd现在是自动区分的核心火炬包。它使用磁带为基础的系统，以自动区分。
为进一步参考，请将其与GradientTape在Tensorflow中进行比较。
浏览 0提问于2020-11-16得票数 12
回答已采纳
我有一个受过训练的网络。我想要计算输出的梯度。输入。通过查询torch.autograd.grad文档，PyTorch可能很有用。因此，我使用以下代码：
x_test = torch.randn(D_in,requires_grad=True)
y_test = model(x_test)
d = torch.autograd.grad(y_test, x_test)[0]
model是神经网络。x_test是D_in大小的输入，y_test是标量输出。我想将计算结果与scipy.misc.derivative的数值差分进行比较。因此，我通过设置一个索引来计算部分导数。
浏览 1提问于2018-08-03得票数 7
这段代码是这样构建的:我的机器人拍了一张照片，一些tf计算机视觉模型计算出目标物体在图片中的开始位置。该信息(x1和x2坐标)被传递给pytorch模型。它应该学会预测正确的运动激活，以便更接近目标。执行移动后，机器人再次拍照，tf cv模型应计算电机激活是否使机器人更接近所需状态( 10处的x1，at31处的x2坐标)
但是，每次我运行代码pytorch都不能计算渐变。
我想知道这是不是一个数据类型的问题，或者是一个更一般的问题:如果不是直接从pytorch网络的输出计算损失，是否不可能计算梯度？
我们将非常感谢您的帮助和建议。
#define policy model (model to
浏览 0提问于2020-05-15得票数 6
我想复制损失的梯度，相对于重量，对于不同的数据样本使用pytorch。在下面的代码中，我每次从数据加载器(批处理大小= 1)迭代一个样本，并收集第一个完全连接(fc1)层的梯度。不同样本的梯度应该是不同的。打印函数显示正确的梯度，不同样本的梯度是不同的。但是当我把它们存储在一个列表中时，我会反复得到相同的梯度。如有任何建议，将不胜感激。提前感谢！
grad_list = [ ]
for data in test_loader:
inputs, labels = data[0], data[1]
inputs = torch.autograd.Variable(inputs)
浏览 5提问于2022-01-12得票数 0
回答已采纳
我正在尝试将使用Theano编写的代码复制到PyTorch。在代码中，作者使用以下命令计算梯度 import theano.tensor as T
gparams = T.grad(cost, params) gparams的形状是(256, 240) 我试过使用backward()，但它似乎没有返回任何东西。在PyTorch中有没有等同于grad的东西？ 假设这是我的输入， import torch
from torch.autograd import Variable
cost = torch.tensor(1.6019)
params = Variable(torch.ran
浏览 26提问于2019-10-17得票数 0
1回答
我是数据科学的初学者。我试图理解这个使用自定义自动梯度函数进行梯度计算的PyTorch代码：
class MyReLU(torch.autograd.Function):
@staticmethod
def forward(ctx, x):
ctx.save_for_backward(x)
return x.clamp(min=0)
def backward(ctx, grad_output):
x, = ctx.saved_tensors
grad_x = grad_output.clone()
grad_x[x < 0] = 0
浏览 0提问于2018-09-17得票数 2
回答已采纳
2回答
我正在尝试了解pytorch autograd是如何工作的。如果我有函数y= 2x和z= y**2，如果我做正常微分，我得到x=1的dz/dx =8 (dz/dx = dz/dy * dy/dx = 2y*2 = 2(2x)*2 = 8x)。或者，z= (2x)**2 = 4x^2，dz/dx = 8x，所以当x= 1时，它是8。 如果我对pytorch autograd执行同样的操作，我会得到4 x = torch.ones(1,requires_grad=True)
y = 2*x
z = y**2
x.backward(z)
print(x.grad) 哪种打印 tensor([4.]
浏览 38提问于2020-01-27得票数 2
回答已采纳
下面的代码计算实对称矩阵的特征值分解。然后，计算第一特征值相对于矩阵的梯度。这是三次完成的: 1)使用解析公式，2)使用TensorFlow，3)使用PyTorch。这会产生三种不同的结果。有人能给我解释一下这种行为吗？
import numpy as np
import torch
import tensorflow as tf
np.set_printoptions(precision=3)
np.random.seed(123)
# random matrix
matrix_np = np.random.randn(4, 4)
# make symmetric
matrix_np
浏览 4提问于2019-11-14得票数 3
pytorch中F.normalize的梯度几乎为零。
python3和pytorch==1.3.0中的代码：
import torch
import torch.nn.functional as F
x = torch.autograd.Variable(torch.Tensor([[1, 0]]), requires_grad=True)
x_norm = F.normalize(x, dim=-1)
z = x_norm.mm(x_norm.t())
print('x_norm', x_norm)
print('z', z)
x.register_ho
浏览 0提问于2020-07-10得票数 1
1回答
我只是想知道，PyTorch如何跟踪张量上的操作(在.requires_grad被设置为True之后)，以及以后如何自动计算梯度。请帮助我理解autograd背后的想法。谢谢。
浏览 0提问于2018-06-27得票数 5
回答已采纳
2回答
(注:这不是一个反向传播问题。)我试图用PyTorch张量来代替Numpy数组来解决GPU上的非线性PDE问题。我要计算任意张量的偏导数，类似于中心有限差分函数的作用。我还有其他解决这个问题的方法，但是由于我已经在使用PyTorch，我想知道是否可以使用autograd模块(或者，一般情况下，任何其他的自动分化模块)来执行这个操作。
我已经创建了一个与张量兼容的numpy.gradient函数版本，运行速度要快得多。但也许有一种更优雅的方式来做到这一点。我找不到解决这个问题的任何其他来源，也无法证明这是可能的或不可能的；也许这反映了我对自微分算法的无知。
浏览 1提问于2019-07-29得票数 5
回答已采纳
我使用torch.autograd.grad()函数来计算两个损失函数的梯度(用于平衡这两个损失的权重)，
loss1_grads = torch.autograd.grad(loss1, model.parameters(), retain_graph=True)
loss2_grads = torch.autograd.grad(loss2, model.parameters(), retain_graph=True)
.....
loss = loss1+alpha*loss2#alpha related to loss1_grads and loss2_grads
loss.back
浏览 4提问于2022-10-25得票数 -1
我正在使用Pytorch实现一个具有(比方说)5个输入和2个输出的神经网络
class myNetwork(nn.Module):
def __init__(self):
super(myNetwork,self).__init__()
self.layer1 = nn.Linear(5,32)
self.layer2 = nn.Linear(32,2)
def forward(self,x):
x = torch.relu(self.layer1(x))
x = self.layer2(x)
return x
浏览 3提问于2020-06-19得票数 0
我想知道我是否可以在Pytorch中构建一个图像调整模块，它接受3*H*W的torch.tensor作为输入，并返回一个张量作为调整后的图像。
我知道可以将张量转换为PIL图像并使用torchvision，但我也希望将梯度从调整大小的图像反向传播到原始图像，下面的示例将返回此类错误(在Windows10上的PyTorch 0.4.0中)：
import numpy as np
from torchvision import transforms
t2i = transforms.ToPILImage()
i2t = transforms.ToTensor()
trans = transfo
浏览 5提问于2018-05-18得票数 9
我是个新手，开始使用这 github代码。我不理解代码"because weights have requires_grad=True, but we don't need to track this in autograd"中第60-61行中的注释。我知道我们提到的变量是requires_grad=True，我们需要这些变量来计算使用自梯度的梯度，但是成为"tracked by autograd"意味着什么呢？
浏览 0提问于2018-06-05得票数 67
回答已采纳
我一直在尝试实现一个定制的Conv2d模块，其中grad_input (dx)和grad_weight (dw)是通过使用不同的grad_output (dy)值来计算的。我通过扩展torch.autograd来实现这一点，就像Pytorch教程中的那样。
然而，我对信息感到困惑。
扩展autograd.Function还不够吗？
在Python C++中编写一个新的自动梯度函数有什么区别？
在/torch/nn/blob/master/lib/THNN/generic/SpatialConvolutionMM.c中计算dx和dw的CUDA实现如何？我也要换吗？
以下是我的
浏览 1提问于2021-06-17得票数 2
回答已采纳
我已经使用Pytorch有一段时间了。我对backprop的一个问题是： 假设我们有一个神经网络的损失函数。对于backprop，我已经看到了两个不同的版本。一个类似于： optimizer.zero_grad()
autograd.backward(loss)
optimizer.step() 另一个是这样的： optimizer.zero_grad()
loss.backward()
optimizer.step() 我应该使用哪一个？这两个版本有什么区别吗？ 作为最后一个问题，我们是否需要为网络的每一层参数指定requires_grad=True，以确保它们的梯度是在backprop中
浏览 26提问于2019-03-13得票数 1
回答已采纳
2回答
我不是分布式系统和数据自动化系统的专家。但是有一个非常有趣的特性是PyTorch支持的，那就是nn.DataParallel和nn.DistributedDataParallel。它们是如何实际实现的？它们如何分离公共嵌入和同步数据？
下面是DataParallel的一个基本示例。
import torch.nn as nn
from torch.autograd.variable import Variable
import numpy as np
class Model(nn.Module):
def __init__(self):
super().__init_
浏览 0提问于2018-11-19得票数 48
在运行代码片段(PyTorch 1.7.1；Python3.8)时，
import numpy as np
import torch
def batch_matrix(vector_pairs, factor=2):
baselen = len(vector_pairs[0]) // factor
split_batch = []
for j in range(factor):
for i in range(factor):
start_j = j * baselen
end_j = (j+1) * b
浏览 3提问于2021-09-26得票数 1
1回答
我试图在PyTorch中区分一个梯度。我找到了链接，但无法让它工作。
我的代码如下：
import torch
from torch.autograd import grad
import torch.nn as nn
import torch.optim as optim
class net_x(nn.Module):
def __init__(self):
super(net_x, self).__init__()
self.fc1=nn.Linear(2, 20)
self.fc2=nn.Lin
浏览 1提问于2021-04-06得票数 0
回答已采纳
我正在尝试用pytorch复制代码。然而，我在自动评分功能上遇到了一些问题。我遇到了以下运行时错误。 RuntimeError:尝试第二次向后遍历图形 代码如下： for epoch in range(num_epochs):
# Assuming the number of examples can be divided by the batch size, all
# the examples in the training data set are used once in one epoch
# iteration. The features and tags
浏览 19提问于2019-10-02得票数 0
1回答
我最近读了一段Pytorch代码，遇到了loss.backward()和optimizer.step()函数，有没有类似于使用tensorflow/keras的函数呢？
浏览 2提问于2020-05-05得票数 6
1回答
割炬中矢量函数梯度的求取
、、、
我是PyTorch的新手，我想做一些我认为很简单的事情，但是有很多困难。
我有一个函数sin(x) * cos(x) + x^2，我想得到函数的导数。
如果我用一点来做这件事，它就会完美地运作
x = torch.autograd.Variable(torch.Tensor([4]),requires_grad=True)
y = torch.sin(x)*torch.cos(x)+torch.pow(x,2)
y.backward()
print(x.grad) # outputs tensor([7.8545])
然而，我希望能够把向量传递为x，然后用它来求导数元素。例如：
Input:
浏览 2提问于2019-04-18得票数 4
回答已采纳
2回答
另一位PyTorch新手试图理解他们的计算图形和自动图。
我正在学习以下关于势能和相应力的模型。
model = nn.Sequential(
nn.Linear(1, 32),
nn.Linear(32, 32), nn.Tanh(),
nn.Linear(32, 32), nn.Tanh(),
nn.Linear(32, 1)
)
optimizer = torch.optim.Adam(model.parameters())
loss = nn.MSELoss()
# generate data
r = torch.linspace(0.95, 3, 5
浏览 5提问于2022-08-08得票数 2
我正在尝试使用torch.autograd.grad在PyTorch中计算矩阵导数，但是我遇到了一些问题。下面是一个重现错误的最小工作示例。 theta = torch.tensor(np.random.uniform(low=-np.pi, high=np.pi), requires_grad=True)
rot_mat = torch.tensor([[torch.cos(theta), torch.sin(theta), 0],
[-torch.sin(theta), torch.cos(theta), 0]],
浏览 57提问于2020-08-16得票数 2
回答已采纳
2回答
我想手动传送火炬梯度。在我真正的问题中，我有我自己的不使用张量的伴随函数。有任何方法，我可以定义我自己的梯度函数，以便在优化过程中使用？
import numpy as np
import torch
# define rosenbrock function and gradient
x0 = np.array([0.1, 0.1])
a = 1
b = 5
def f(x):
return (a - x[0]) ** 2 + b * (x[1] - x[0] ** 2) ** 2
def jac(x):
dx1 = -2 * a + 4 * b * x[0] ** 3 - 4
浏览 7提问于2022-08-29得票数 3
我知道如果渐变停止，torch.autograd.grad()将不返回，但是，我想知道下面的片段有什么问题吗？
x = torch.rand(6, requires_grad=True)
y = x.pow(2).sum()
z = torch.cat([x])
grad1 = torch.autograd.grad(y, x, allow_unused=True)
grad2 = torch.autograd.grad(y, z, allow_unused=True)
print(f'grad1 = {grad1}, grad = {grad2}')
输出为
浏览 1提问于2021-10-05得票数 0
回答已采纳
我正在尝试使用MXNet的图形结构来加速一些计算，并且我目前正在尝试模仿我已经在PyTorch中实现的行为。然而，我对如何正确地做这件事感到困惑，无论是使用还是其他方法。
为了用一个例子来解释，我在PyTorch中所做的工作如下(为了给出最简单的例子，我做了一些修改)，我想把它翻译成MXNet。
import torch.optim
def unconstrained_fit(objective, data, pdf, init_pars, tolerance):
init_pars.requires_grad = True
optimizer = torch.optim.
浏览 0提问于2018-04-23得票数 1
我在试着让d(loss)/d(input)。我知道我有两个选择。 第一个选项： loss.backward()
dlossdx = x.grad.data 第二个选项： # criterion = nn.CrossEntropyLoss(reduce=False)
# loss = criterion(y_hat, labels)
# No need to call backward.
dlossdx = torch.autograd.grad(outputs = loss,
浏览 196提问于2019-01-13得票数 5
回答已采纳
我想使用Python2.7(木星笔记本)中的HIPS自动梯度()来寻找参数x。我的前向模型(给定时间点t的观测值作为参数x的函数)是t的分段函数，因此我选择使用autograd.numpy.piecewise函数。我的损失(或目标)函数是一个直进均方误差.我在使用autograd.grad计算自动梯度时遇到了问题。
下面是简单的代码示例：
import autograd.numpy as anp
from autograd import grad
def forward_model(x, t): # it's a rectangular box of width x and heig
浏览 1提问于2018-04-08得票数 0
1回答
autograd在原则上能在python包装的C函数上工作吗？
--我希望区分使用数据类型的参数，并且可以通过提供float或np.float64参数来成功地实现。
通过使用我的调试器进行更仔细的检查，我发现当自动梯度将float或np.float64更改为对象时，当它试图计算梯度时，就会得到一个。
在这种情况下有允许自动毕业的方法吗？
还有其他更适合我情况的策略吗？
有什么原语我可以编码来解决这个问题吗？
背景：
Bilby是一个更新的python库，它封装了用C编写的旧代码(LALSIMULATION)，它提供了广泛的预编码引力波模型，我想在我的研究中使用这些预编码模型。我的第一个任务是
浏览 2提问于2019-07-20得票数 0
在使用PyTorch的SHAP值的示例中，我找不到多少。我使用了两种技术来生成SHAP值，但是，它们的结果似乎并不一致。
SHAP KernelExplainer与PyTorch
import torch
from torch.autograd import Variable
import shap
import numpy
import pandas
torch.set_grad_enabled(False)
# Get features
train_features_df = ... # pandas dataframe
test_features_df = ... # pandas
浏览 14提问于2021-12-28得票数 6
1回答
我对pytorch的反向函数有一些疑问，我不认为我得到了正确的输出：
import numpy as np
import torch
from torch.autograd import Variable
a = Variable(torch.FloatTensor([[1,2,3],[4,5,6]]), requires_grad=True)
out = a * a
out.backward(a)
print(a.grad)
输出为
tensor([[ 2., 8., 18.],
[32., 50., 72.]])
也许是2*a*a
但我认为输出应该是
tensor([[
浏览 0提问于2019-07-29得票数 19
回答已采纳
2回答
我正在使用Pytorch中实现的autogrid来训练神经网络，我需要计算整个算法的计算复杂度。我在哪里可以找到完整的autograd计算复杂度的计算？我在Pytorch文档中进行了搜索，但没有找到任何答案。谢谢
浏览 17提问于2019-01-10得票数 0
在我以前的中，我发现了如何使用PyTorch的自动梯度和张量：
import torch
from torch.autograd import grad
import torch.nn as nn
import torch.optim as optim
class net_x(nn.Module):
def __init__(self):
super(net_x, self).__init__()
self.fc1=nn.Linear(1, 20)
self.fc2=nn.Linear(20, 20)
浏览 5提问于2021-05-10得票数 6
回答已采纳
我正试图使用visual在windows上构建Pytorch，但它似乎面临一些内部编译器错误，而我还无法找出其原因。在46个目标中，有35个被成功地构建，直到它最终因以下错误而失败。在我列出错误之前，我就是这样构建它的：
git clone --branch v1.6.0 https://github.com/pytorch/pytorch.git pytorch-1.6.0
cd pytorch-1.6.0
git submodule update --init --recursive
set CUDAHOSTCXX=
set DISTUTILS_USE_SDK=1
for /f "
浏览 1提问于2020-10-05得票数 1
回答已采纳
1回答
我想用PyTorch得到输出和输入之间的偏导数。假设我有一个函数Y = 5*x1^4 + 3*x2^3 + 7*x1^2 + 9*x2 - 5，并且我训练一个网络来替换这个函数，那么我使用自动梯度来计算dYdx1, dYdx2。
net = torch.load('net_723.pkl')
x = torch.tensor([[1,-1]],requires_grad=True).type(torch.FloatTensor)
y = net(x)
grad_c = torch.autograd.grad(y,x,create_graph=True,retain_graph=
浏览 0提问于2018-07-24得票数 2
1回答
在移相器中创建自定义渐变下降
、、、、
我试图使用PyTorch自动梯度来实现我自己的批处理梯度下降算法。我想要创建一个简单的单层神经网络，其线性激活函数和均方误差作为损失函数。我似乎无法理解在反向传递中到底发生了什么，以及PyTorch如何理解我的输出。我编写了一个类，指定前通过中的线性函数，在反向传递中，我计算了每个变量的梯度。我还为MSE函数编写了一个类，并在向后传递中指定了与其变量相关的梯度。当我运行一个简单的梯度下降算法时，我没有错误，但是MSE只在第一次迭代中下降，然后，它继续上升。这使我相信，我犯了一个错误，但我不确定，在哪里。有人在我的代码中看到错误了吗？而且，如果有人能向我解释grad_output到底代表什么，那
浏览 0提问于2021-08-02得票数 1
回答已采纳
我正在尝试实现名为“不变风险最小化”的技术，它为训练机器学习模型中的损失函数增加了一个惩罚项。新的惩罚项的技术定义是关于常数分类器的平方梯度范数，用PyTorch 实现了这个“惩罚”函数。
我想知道如何在Tensorflow 2中实现这个功能。
更具体地说，我想实现下面的函数，它也在我共享它的链接的代码中。
def penalty(logits, y):
scale = torch.tensor(1.).cuda().requires_grad_()
loss = mean_nll(logits * scale, y)
grad = autograd.grad(lo
浏览 3提问于2021-01-04得票数 2
关于backward()的pytorch问题。在下面复制和粘贴的pytorch 中，它们将向量[0.1, 1.0, 0.0001]传递给backward()。我可以直观地猜测为什么传入的向量[0.1, 1.0, 0.0001]形状是3，但我不明白值0.1，1.0，0.0001从哪里来。我看过的另一个教程中的向后向量传递是这样完成的：L.backward(torch.ones(L.shape))
# copied from blitz tutorial
Now in this case y is no longer a scalar. torch.autograd could not compu
浏览 8提问于2019-10-29得票数 0
回答已采纳
1回答
考虑以下代码：
x = torch.tensor(2.0, requires_grad=True)
y = torch.square(x)
grad = autograd.grad(y, x)
x = x + grad[0]
y = torch.square(x)
grad2 = autograd.grad(y, x)
首先，我们有那个∇(x^2)=2x。据我所知，grad2=∇((x + ∇(x^2))^2)=∇((x+2x)^2)=∇((3x)^2)=9∇x^2=18x。不出所料，grad=4.0=2x，但是grad2=12.0=6x，我不明白它是从哪里来的。似乎3来自于我所拥有的表
浏览 12提问于2022-08-01得票数 0
回答已采纳
1回答
我使用pytorch来评估前馈网络的梯度，但只用于与前两层相关的参数子集。由于反向传播是逐层进行的，我想知道:为什么计算速度快于计算整个网络的梯度？
浏览 5提问于2022-08-23得票数 1
我在使用pytorch实现GRU网络时遇到了一个问题： 我的代码如下： import torch
class GRU_model(torch.nn.Module):
def __init__(self, device):
super(GRU_model, self).__init__()
self.h = torch.randn((1,1,5), device=device, dtype=torch.float)
self.GRU_1 = torch.nn.GRU(input_size=5, hidden_size=5)
浏览 129提问于2021-04-06得票数 0
1回答
我期望x收敛到0，这是x*x的最小值，但这不会发生。在这个小示例代码中，我做错了什么：
import torch
from torch.autograd import Variable
tns = torch.FloatTensor([3])
x = Variable(tns, requires_grad=True)
z = x*x
opt = torch.optim.Adam([x], lr=.01, betas=(0.5, 0.999))
for i in range(3000):
z.backward(retain_graph=True) # Calculate gradient
浏览 1提问于2018-05-29得票数 2
回答已采纳
2回答
在“ of torch.autograd.grad”中指出，对于参数，
参数：
输出(张量序列)-差异化函数的输出。
输入(张量序列)-输入w.r.t.其中的梯度将被返回(而不是累积到.grad中)。
我尝试以下几点：
a = torch.rand(2, requires_grad=True)
b = torch.rand(2, requires_grad=True)
c = a+b
d = a-b
torch.autograd.grad([c, d], [a, b]) #ValueError: only one element tensors can be converted to
浏览 2提问于2019-09-23得票数 5
回答已采纳
假设我想计算两个张量之间的元素商。如果其中一个张量包含NaN，则生成的商也将包含NaN，这一点我是理解的。但是为什么在整个操作中梯度变得不存在呢？如何为非NaN条目保留渐变？
例如：
>>> x = torch.tensor([1.0, np.NaN])
>>> y = torch.tensor([2.0, 3.0])
>>> z = torch.div(y, x)
>>> z
tensor([2., nan])
>>> z.backward()
Traceback (most recent call l
浏览 71提问于2019-06-26得票数 -1
回答已采纳
我试图在不重新定义a= f(x，y)的情况下做这样的事情：
a = f(x,y)
find gradient of a with respect to x
change x
find gradient of a with respect to x
find gradient of a with respect to y
我尝试了下面的部分示例，但它只是给了我一个错误。有人知道我如何做到这一点而不需要每次都重新定义原始函数吗？
>>> x = torch.tensor([2.], requires_grad=True)
>>> y = 10*x**2
>
浏览 0提问于2021-04-29得票数 1
我的损失看起来像
e1, v1 = torch.eig(A)
e2, v2 = torch.eig(B)
sim = torch.matmul(v1, v2.permute(0, 2, 1))
loss_sim = torch.sum(sim)
loss_sim.backward()
其中A和B是shape SEQUENCE_LENGH * SEQUENCE_LENGTH的中间张量
我的代码遇到了这个错误：
File "/usr/local/Anaconda3/lib/python3.8/site-packages/torch/tensor.py", line 185, in
浏览 5提问于2021-04-12得票数 0
我有三个高斯的混合物，并想要计算的梯度，日志密度，使用毕火炬或Tensorflow。我怎么能这么做？
from numpy import eye, log
from scipy.stats import multivariate_normal as MVN
μs = [[0, 0], [2, 0], [0, 2]] # Means
Σs = [eye(2), eye(2), eye(2)] # Covariance Matrices
cs = [1 / 3] * 3 # Mi
浏览 6提问于2022-01-28得票数 0
1回答
我是Pytorch和RNN的新手。我正在学习如何使用RNN预测数字，作为视频中的教程：
在他的代码中，他使用python 3并进行如下解码：
out_unembedded = out.view(-1, hidden_size) @ embedding.weight.transpose(0,1)
我正在使用Python 2，并尝试以下代码：
out_unembedded = out.view(-1, hidden_size).dot( embedding.weight.transpose(0,1))
但它似乎不正确，然后我尝试这样解码：
import torch
import torch.nn
浏览 0提问于2018-01-02得票数 1
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
云直播活动推荐
腾讯云开发者
