ad-3.1.2: Automatic Differentiation

Portability GHC only experimental ekmett@gmail.com None

Numeric.AD.Mode.Chain

Contents

Description

Reverse Automatic Differentiation using Data.Reflection

Synopsis

# Gradient

grad :: (Traversable f, Num a) => (forall s. Mode s => f (AD s a) -> AD s a) -> f a -> f aSource

The `grad` function calculates the gradient of a non-scalar-to-scalar function with reverse-mode AD in a single pass.

````>>> ````grad (\[x,y,z] -> x*y+z) [1,2,3]
```[2,1,1]
```

grad' :: (Traversable f, Num a) => (forall s. Mode s => f (AD s a) -> AD s a) -> f a -> (a, f a)Source

The `grad'` function calculates the result and gradient of a non-scalar-to-scalar function with reverse-mode AD in a single pass.

````>>> ````grad' (\[x,y,z] -> x*y+z) [1,2,3]
```(5,[2,1,1])
```

gradWith :: (Traversable f, Num a) => (a -> a -> b) -> (forall s. Mode s => f (AD s a) -> AD s a) -> f a -> f bSource

`grad g f` function calculates the gradient of a non-scalar-to-scalar function `f` with reverse-mode AD in a single pass. The gradient is combined element-wise with the argument using the function `g`.

``` `grad` == `gradWith` (_ dx -> dx)
`id` == `gradWith` `const`
```

gradWith' :: (Traversable f, Num a) => (a -> a -> b) -> (forall s. Mode s => f (AD s a) -> AD s a) -> f a -> (a, f b)Source

`grad' g f` calculates the result and gradient of a non-scalar-to-scalar function `f` with reverse-mode AD in a single pass the gradient is combined element-wise with the argument using the function `g`.

``` `grad'` == `gradWith'` (_ dx -> dx)
```

# Jacobian

jacobian :: (Traversable f, Functor g, Num a) => (forall s. Mode s => f (AD s a) -> g (AD s a)) -> f a -> g (f a)Source

The `jacobian` function calculates the jacobian of a non-scalar-to-non-scalar function with reverse AD lazily in `m` passes for `m` outputs.

````>>> ````jacobian (\[x,y] -> [y,x,x*y]) [2,1]
```[[0,1],[1,0],[1,2]]
```

jacobian' :: (Traversable f, Functor g, Num a) => (forall s. Mode s => f (AD s a) -> g (AD s a)) -> f a -> g (a, f a)Source

The `jacobian'` function calculates both the result and the Jacobian of a nonscalar-to-nonscalar function, using `m` invocations of reverse AD, where `m` is the output dimensionality. Applying `fmap snd` to the result will recover the result of `jacobian` | An alias for `gradF'`

````>>> ````jacobian' (\[x,y] -> [y,x,x*y]) [2,1]
```[(1,[0,1]),(2,[1,0]),(2,[1,2])]
```

jacobianWith :: (Traversable f, Functor g, Num a) => (a -> a -> b) -> (forall s. Mode s => f (AD s a) -> g (AD s a)) -> f a -> g (f b)Source

'jacobianWith g f' calculates the Jacobian of a non-scalar-to-non-scalar function `f` with reverse AD lazily in `m` passes for `m` outputs.

Instead of returning the Jacobian matrix, the elements of the matrix are combined with the input using the `g`.

``` `jacobian` == `jacobianWith` (_ dx -> dx)
`jacobianWith` `const` == (f x -> `const` x `<\$>` f x)
```

jacobianWith' :: (Traversable f, Functor g, Num a) => (a -> a -> b) -> (forall s. Mode s => f (AD s a) -> g (AD s a)) -> f a -> g (a, f b)Source

`jacobianWith` g f' calculates both the result and the Jacobian of a nonscalar-to-nonscalar function `f`, using `m` invocations of reverse AD, where `m` is the output dimensionality. Applying `fmap snd` to the result will recover the result of `jacobianWith`

Instead of returning the Jacobian matrix, the elements of the matrix are combined with the input using the `g`.

``jacobian'` == `jacobianWith'` (_ dx -> dx)`

# Hessian

hessian :: (Traversable f, Num a) => (forall s. Mode s => f (AD s a) -> AD s a) -> f a -> f (f a)Source

Compute the hessian via the jacobian of the gradient. gradient is computed in reverse mode and then the jacobian is computed in reverse mode.

However, since the `grad f :: f a -> f a` is square this is not as fast as using the forward-mode Jacobian of a reverse mode gradient provided by `hessian`.

````>>> ````hessian (\[x,y] -> x*y) [1,2]
```[[0,1],[1,0]]
```

hessianF :: (Traversable f, Functor g, Num a) => (forall s. Mode s => f (AD s a) -> g (AD s a)) -> f a -> g (f (f a))Source

Compute the order 3 Hessian tensor on a non-scalar-to-non-scalar function via the reverse-mode Jacobian of the reverse-mode Jacobian of the function.

Less efficient than `hessianF`.

````>>> ````hessianF (\[x,y] -> [x*y,x+y,exp x*cos y]) [1,2]
```[[[0.0,1.0],[1.0,0.0]],[[0.0,0.0],[0.0,0.0]],[[-1.1312043837568135,-2.4717266720048188],[-2.4717266720048188,1.1312043837568135]]]
```

# Derivatives

diff :: Num a => (forall s. Mode s => AD s a -> AD s a) -> a -> aSource

Compute the derivative of a function.

````>>> ````diff sin 0
```1.0
```

diff' :: Num a => (forall s. Mode s => AD s a -> AD s a) -> a -> (a, a)Source

The `diff'` function calculates the result and derivative, as a pair, of a scalar-to-scalar function.

````>>> ````diff' sin 0
```(0.0,1.0)
```
````>>> ````diff' exp 0
```(1.0,1.0)
```

diffF :: (Functor f, Num a) => (forall s. Mode s => AD s a -> f (AD s a)) -> a -> f aSource

Compute the derivatives of each result of a scalar-to-vector function with regards to its input.

````>>> ````diffF (\a -> [sin a, cos a]) 0
```[1.0,0.0]
```

diffF' :: (Functor f, Num a) => (forall s. Mode s => AD s a -> f (AD s a)) -> a -> f (a, a)Source

Compute the derivatives of each result of a scalar-to-vector function with regards to its input along with the answer.

````>>> ````diffF' (\a -> [sin a, cos a]) 0
```[(0.0,1.0),(1.0,0.0)]
```
{"ft_lang_label":"__label__en","ft_lang_prob":0.7004879,"math_prob":0.99493366,"size":5767,"snap":"2019-35-2019-39","text_gpt3_token_len":2038,"char_repetition_ratio":0.22002429,"word_repetition_ratio":0.6205468,"special_character_ratio":0.4161609,"punctuation_ratio":0.17073171,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.99935955,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2019-08-18T18:29:47Z\",\"WARC-Record-ID\":\"<urn:uuid:bbe6ba52-d466-485d-9e8a-6dda0f7c60ae>\",\"Content-Length\":\"25885\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:554fab69-3a95-4e0f-9b30-491e7937a4ae>\",\"WARC-Concurrent-To\":\"<urn:uuid:4190f39d-f9b5-4428-aecb-0c5ecf04530f>\",\"WARC-IP-Address\":\"151.101.200.68\",\"WARC-Target-URI\":\"http://hackage.haskell.org/package/ad-3.1.2/docs/Numeric-AD-Mode-Chain.html\",\"WARC-Payload-Digest\":\"sha1:VNGUWGDFPJ2W3R6VEJB3JXM5NTSIYY4P\",\"WARC-Block-Digest\":\"sha1:3GJMNJIGFAITKY62WLH6T3B2MZS5B7EY\",\"WARC-Identified-Payload-Type\":\"application/xhtml+xml\",\"warc_filename\":\"/cc_download/warc_2019/CC-MAIN-2019-35/CC-MAIN-2019-35_segments_1566027313987.32_warc_CC-MAIN-20190818165510-20190818191510-00236.warc.gz\"}"}