这是在的情况下自动微分 -什么会这样的系统做像一个函数map，或者filter-或者甚至一个SKI组合子？
示例：我具有以下功能：
def func(x):
return sum(map(lambda a: a**x, range(20)))
它的派生词是什么？结果是AD系统会产生什么结果？（此函数在实数输入上定义良好）。
language-agnostic programming-languages automatic-differentiation
我几乎没有成功地绕着包装中涉及的类型的基本管道ad包裹.例如,以下工作完美:
import Numeric.AD
ex :: Num a => [a] -> a
ex [x, y] = x + 2*y
> grad ex [1.0, 1.0]
[1.0, 2.0]
哪里grad有类型:
grad
:: (Num a, Traversable f) =>
(forall (s :: * -> *). Mode s => f (AD s a) -> AD s a)
-> f a -> f a
如果我改变的类型签名ex来[Double] -> Double,并尝试同样的事情,我得到
Couldn't match expected type `AD s a0' with actual type `Double'
Expected type: …在R中,当您仅提供优化问题的目标函数和约束时,是否可以分析地找到雅可比/ Hessian /稀疏模式？
AMPL这样做,从我听到的甚至MATLAB都可以做到这一点,但我不知道你是否需要Knitro.
然而,R的所有优化工具(例如nloptr)似乎都要求我自己输入渐变和Hessian,这是非常困难的,因为我正在使用复杂的模型.
Sooooo ......因为事实证明从伪矩阵到hmatrix数据类型变得非常重要:)
序言部分供参考:
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ParallelListComp #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE FlexibleContexts #-}
import Numeric.LinearAlgebra.HMatrix
import Numeric.AD
reconstruct :: (Container Vector a, Num (Vector a))
=> [a] -> [Matrix a] -> Matrix a
reconstruct as ?s = sum [ a `scale` ? | a <- as | ? <- ?s ]
preserveInfo :: (Container Vector a, Num (Vector a))
=> Matrix a -> [a] -> [Matrix …假设我有一个有5个隐藏层的人工神经网络.目前,忘记神经网络模型的细节,如偏差,使用的激活函数,数据类型等等.当然,激活功能是可区分的.
通过符号区分,以下计算目标函数相对于图层权重的渐变:
w1_grad = T.grad(lost, [w1])
w2_grad = T.grad(lost, [w2])
w3_grad = T.grad(lost, [w3])
w4_grad = T.grad(lost, [w4])
w5_grad = T.grad(lost, [w5])
w_output_grad = T.grad(lost, [w_output])
通过这种方式,计算梯度WRT W1梯度WRT W2,W3,W4和W5必须先计算.类似于计算梯度wrt w2,梯度wrt w3,必须首先计算w4和w5.
但是,我可以使用以下代码计算每个权重矩阵的渐变:
w1_grad, w2_grad, w3_grad, w4_grad, w5_grad, w_output_grad = T.grad(lost, [w1, w2, w3, w4, w5, w_output])
我想知道,这两种方法在性能方面有什么区别吗？Theano是否足够智能以避免使用第二种方法重新计算渐变？智能我的意思是计算w3_grad,Theano应该[最好]使用w_output_grad,w5_grad和w4_grad的预先计算的梯度,而不是再次计算它们.
gradient automatic-differentiation neural-network python-2.7 theano
我正在尝试使用行为类似于NumPy数组的类来实现自动微分.它不是子类numpy.ndarray,但包含两个数组属性.一个用于值,一个用于雅可比矩阵.每个操作都被重载以对值和雅可比行为进行操作.但是,我无法使NumPy ufuncs(例如np.log)在我的自定义"数组"上工作.
我创建了以下最小示例,说明了该问题.Two应该是NumPy数组的辐射加固版本,它可以计算两次,并确保结果相同.
它必须是支持索引,元素对数和长度.就像平常一样ndarray.当使用调用时,元素对数工作正常x.cos(),但在调用时会执行意外操作np.cos(x).
from __future__ import print_function
import numpy as np
class Two(object):
def __init__(self, val1, val2):
print("init with", val1, val2)
assert np.array_equal(val1, val2)
self.val1 = val1
self.val2 = val2
def __getitem__(self, s):
print("getitem", s, "got", Two(self.val1[s], self.val2[s]))
return Two(self.val1[s], self.val2[s])
def __repr__(self):
return "<<{}, {}>>".format(self.val1, self.val2)
def log(self):
print("log", self)
return Two(np.log(self.val1), np.log(self.val2))
def __len__(self):
print("len", self, "=", self.val1.shape[0])
return self.val1.shape[0]
x …我想在Eigen线性代数中使用CppAD提供的自动微分机制.示例类型是Eigen :: Matrix <CppAD :: AD,-1,-1>.由于CppAD :: AD是自定义数字类型,因此必须提供此类型的NumTraits.CppAD提供文件cppad/example/cppad_eigen.hpp中的那些.这使得以下最小的示例编译:
#include <cppad/cppad.hpp>
#include <cppad/example/cppad_eigen.hpp>
int main() {
typedef double Scalar;
typedef CppAD::AD<Scalar> AD;
// independent variable vector
Eigen::Matrix<AD,Eigen::Dynamic,1> x(4);
CppAD::Independent(x);
// dependent variable vector
Eigen::Matrix<AD,Eigen::Dynamic,1> y(4);
Eigen::Matrix<double,Eigen::Dynamic,Eigen::Dynamic> m(4,4);
m.setIdentity();
y = 1. * x;
// THIS DOES NOT WORK
// y = m * x;
CppAD::ADFun<Scalar> fun(x, y);
}
一旦使用一些更复杂的表达,例如所提到的
y = m * x;
代码无法编译:
PATH/Eigen/latest/include/Eigen/src/Core/Product.h:29:116: error:
no type named 'ReturnType' in 'Eigen::ScalarBinaryOpTraits<double, CppAD::AD<double>,
Eigen::internal::scalar_product_op<double, CppAD::AD<double> > >'
...typename …我了解自动微分的概念，但找不到任何解释，例如，tf.where在我的损失函数或tf.cond图形中，tensorflow如何计算不可微函数的误差梯度。它工作得很好，但是我想了解张量流如何通过这样的节点反向传播错误，因为没有公式可以根据它们计算梯度。
看代码片段：
import torch
x = torch.tensor([-1.], requires_grad=True)
y = torch.where(x > 0., x, torch.tensor([2.], requires_grad=True))
y.backward()
print(x.grad)
输出是tensor([0.])，但是
import torch
x = torch.tensor([-1.], requires_grad=True)
if x > 0.:
y = x
else:
y = torch.tensor([2.], requires_grad=True)
y.backward()
print(x.grad)
输出是None.
我很困惑为什么输出torch.where是tensor([0.])？
import torch
a = torch.tensor([[1,2.], [3., 4]])
b = torch.tensor([-1., -1], requires_grad=True)
a[:,0] = b
(a[0, 0] * a[0, 1]).backward()
print(b.grad)
输出是tensor([2., 0.]). (a[0, 0] * a[0, 1])与 …
Julia 有一个有点庞大的 AD 生态系统，据我所知，现在可能有十多个不同的包，正向模式（ForwardDiff.jl，ForwardDiff2.jl ），反向模式（ReverseDiff.jl，Nabla 。 jl、AutoGrad.jl）和源到源（Zygote.jl、Yota.jl、Enzyme.jl，可能还有即将推出的 Diffractor.jl）在编译管道的几个不同步骤，以及更奇特的东西像NiLang.jl。
在这些包之间，对不同语言结构（控制流、变异等）的支持是什么，是否有关于如何为给定任务选择给定 AD 的经验法则？我相信在某个时候在 Julia Slack 上有一个比较和对比表，但我似乎无法在相关的话语线索或其他可能的地方 ( 1 , 2 ) 中找到为后代复制的任何内容