标签: automatic-differentiation

我们需要微分算子的两个矩阵[B]和[C]如：

B = sympy.Matrix([[ D(x), D(y) ],
                  [ D(y), D(x) ]])

C = sympy.Matrix([[ D(x), D(y) ]])

ans = B * sympy.Matrix([[x*y**2],
                        [x**2*y]])
print ans
[x**2 + y**2]
[      4*x*y]

ans2 = ans * C
print ans2
[2*x, 2*y]
[4*y, 4*x]

这也可以用于计算矢量场的卷曲，例如：

culr  = sympy.Matrix([[ D(x), D(y), D(z) ]])
field = sympy.Matrix([[ x**2*y, x*y*z, -x**2*y**2 ]])

要使用 Sympy 解决这个问题，必须创建以下 Python 类：

import sympy

class D( sympy.Derivative ):
    def __init__( self, var ):
        super( D, self ).__init__() …

我对Theano的实施有疑问.theano如何通过以下函数(T.grad)获得每个损失函数的梯度？谢谢您的帮助.

 gparams = T.grad(cost, self.params) 

给出一个基于Vector的非常简单的Matrix定义:

import Numeric.AD
import qualified Data.Vector as V

newtype Mat a = Mat { unMat :: V.Vector a }

scale' f = Mat . V.map (*f) . unMat
add' a b = Mat $ V.zipWith (+) (unMat a) (unMat b)
sub' a b = Mat $ V.zipWith (-) (unMat a) (unMat b)
mul' a b = Mat $ V.zipWith (*) (unMat a) (unMat b)
pow' a e = Mat $ V.map (^e) (unMat a)

sumElems' :: Num a => Mat …

我在 Julia 中正确使用 ForwardDiff 包时遇到了一些问题。我设法在以下代码块中隔离了我的问题。

简而言之，我定义了函数：

using ForwardDiff

function likelihood(mu,X)

  N = size(X,2)

  # Calculate likelihood
  aux = zeros(N)
  for nn=1:N
    aux[nn] = exp(-0.5 * (X[:,nn]-mu)' *  (X[:,nn]-mu))[1]
  end

  # return log-likelihood
  return sum(log(aux))

end

然后我检查该功能是否有效：

# Check if function works at all
X = randn(2,3) # some random data
mu = [1.0;2.0] # arbitrary mean
@show likelihood(mu,X) # works fine for me

然后我尝试使用以下方法获得梯度：

ForwardDiff.gradient( ARG -> likelihood(ARG, X), mu)

不幸的是，这失败了，我在屏幕上看到：

错误: MethodError: converthas no method matching convert(::Type{Float64}, ::ForwardDiff.Dual{2,Float64}) …

TensorFlow使用反向模式自动区分（反向模式AD），如https://github.com/tensorflow/tensorflow/issues/675中所示。

反向模式AD需要一个称为Wengert列表的数据结构-请参阅https://en.wikipedia.org/wiki/Automatic_differentiation#Reverse_accumulation。

但是，使用关键字“ Wengert List”搜索TensorFlow存储库，但没有任何结果。

他们是否使用其他名称，还是摆脱了Wengert List？如果是这样，怎么办？

我试图深入了解 Pytorch autograd；我想通过如下所示的 sigmoid 函数观察简单张量的梯度：

import torch
from torch import autograd 

D = torch.arange(-8, 8, 0.1, requires_grad=True)

with autograd.set_grad_enabled(True):
    S = D.sigmoid()
S.backward()

我的目标是获得 D.grad() 但即使在调用它之前我也收到运行时错误：

RuntimeError: grad can be implicitly created only for scalar outputs

我看到另一篇有类似问题的帖子，但那里的答案不适用于我的问题。谢谢

以下程序类型检查:

{-# LANGUAGE RankNTypes #-}

import Numeric.AD (grad)

newtype Fun = Fun (forall a. Num a => [a] -> a)

test1 [u, v] = (v - (u * u * u))
test2 [u, v] = ((u * u) + (v * v) - 1)

main = print $ fmap (\(Fun f) -> grad f [1,1]) [Fun test1, Fun test2]

但是这个程序失败了:

main = print $ fmap (\f -> grad f [1,1]) [test1, test2]

带有类型错误:

Grad.hs:13:33: error:
    • Couldn't match type ‘Integer’ …

我有一个接受多变量参数 x 的函数。这里 x = [x1,x2,x3]。假设我的函数如下所示： f(x,T) = np.dot(x,T) + np.exp(np.dot(x,T) 其中 T 是一个常数。

我对查找 df/dx1、df/dx2 和 df/dx3 函数很感兴趣。

我使用 scipy diff 取得了一些成功，但我有点怀疑，因为它使用了数值差异。昨天，我的同事指给我 Autograd (github)。由于它似乎是一个流行的包，我希望这里有人知道如何使用这个包来获得偏微分。我对这个库的初步测试表明 grad 函数只对第一个参数进行微分。我不确定如何将其扩展到其他参数。任何帮助将不胜感激。

谢谢。

我有一个将向量映射到向量的函数

我想计算它的雅可比行列式

,

其中雅可比行列式定义为

。

因为我可以使用numpy.linalg.det, 来计算行列式，所以我只需要雅可比矩阵。我知道numdifftools.Jacobian，但这使用数值微分，而我追求自动微分。输入Autograd/ （我现在JAX会坚持使用，它有一个方法，但只要我得到我想要的，我就很乐意使用）。如何与向量值函数一起正确使用此函数？Autogradautograd.jacobian()JAXautograd.jacobian()

作为一个简单的例子，我们来看一下这个函数

 2C%20x_1%5E2%29 )

其中有雅可比行列式

![J_f = diag(2 x_0, 2 x_1)]( https://chart.googleapis.com/chart?cht=tx&chl=J_f%20%3D%20%5合作者名称%7Bdiag%7D(2x_0%2C%202x_1% 29）

产生雅可比行列式

>>> import autograd.numpy as np
>>> import autograd as ag
>>> x = np.array([[3],[11]])
>>> result = 4*x[0]*x[1]
array([132])
>>> jac = ag.jacobian(f)(x)
array([[[[ 6],
         [ 0]]],


       [[[ 0],
         [22]]]])
>>> jac.shape
(2, 1, 2, 1)
>>> np.linalg.det(jac)
Traceback …

我正在尝试用 Haskell 编写一个简单的自动微分包。

在 Haskell 中表示类型安全（有向）计算图的有效方法是什么？我知道广告包使用“data-reify”方法，但我不太熟悉它。谁能为我提供一些见解？谢谢！

我只想使用该ForwardDiff.jl功能来定义一个函数并绘制其梯度（使用 评估ForwardDiff.gradient）。它似乎不起作用，因为 的输出ForwardDiff.gradient是这种奇怪的Dual类型，并且不容易转换为所需的类型（在我的情况下，是 Float32s 的一维数组）。

using Plots
using ForwardDiff

my_func(x::Array{Float32,1}) = 1f0. / (1f0 .+ exp(3f0 .* x)) # doesn't matter what this is, just a sigmoid function here

grad_f(x::Array{Float32,1}) = ForwardDiff.gradient(my_func, x)

x_values = collect(Float32,0:0.01:10)

plot(x_values,my_func(x_values)); # this works fine

plot!(x_values,grad_f(x_values)); # this throws an error

这是我得到的错误：

ERROR: MethodError: no method matching Float64(::ForwardDiff.Dual{ForwardDiff.Tag{typeof(g),Float32},Float64,12})

当我检查 的类型时grad_f(x_values)，我得到了这个：

Array{Array{ForwardDiff.Dual{ForwardDiff.Tag{typeof(g),Float32},Float32,12},1},1}

例如，为什么在 ForwardDiff 文档的示例中不会发生这种情况？见这里：https : //github.com/JuliaDiff/ForwardDiff.jl

提前致谢。

编辑：在 Kristoffer Carlsson 发表评论后：我试过这个，但它仍然不起作用。我不明白我在这里尝试的与他建议的有什么不同：

function g(x::Float32) …

我试图了解argnumsJAX 梯度函数的行为。假设我有以下函数：

def make_mse(x, t):  
  def mse(w,b): 
    return np.sum(jnp.power(x.dot(w) + b - t, 2))/2
  return mse 

我通过以下方式获取渐变：

w_gradient, b_gradient = grad(make_mse(train_data, y), (0,1))(w,b)

argnums= (0,1)在这种情况下，但这意味着什么呢？梯度是针对哪些变量计算的？如果我改用的话会有什么区别argnums=0？另外，我可以使用相同的函数来获取 Hessian 矩阵吗？

我查看了JAX 帮助部分，但无法弄清楚

我有以下代码,不编译:

  import Numeric.AD

  data Trainable a b = forall n . Floating n =>  Trainable ([n] -> a -> b) (a -> b -> [n] -> n) 

  trainSgdFull :: (Floating n, Ord n) => Trainable a b -> [n] -> a -> b -> [[n]]
  trainSgdFull (Trainable _ cost) init input target =  gradientDescent (cost input target) init

我想使用Trainable类型来表示可通过梯度下降训练的机器学习系统.第一个算法是传递函数,sencond是成本函数,a是输入类型,b是输出/目标类型,列表包含可学习参数.编译器抱怨这个:

 src/MachineLearning/Training.hs:12:73:
Could not deduce (n1 ~ ad-3.3.1.1:Numeric.AD.Internal.Types.AD s n)
from the context (Floating n, Ord n)
  bound by the type signature …