Copyright  (c) Justin Le 2018 

License  BSD3 
Maintainer  justin@jle.im 
Stability  experimental 
Portability  nonportable 
Safe Haskell  None 
Language  Haskell2010 
Provides "explicit" versions of all of the functions in
Numeric.Backprop. Instead of relying on a Backprop
instance, allows
you to manually provide zero
, add
, and one
on a pervalue basis.
It is recommended you use Numeric.Backprop or Numeric.Backprop.Num
instead, unless your type has no Num
instance, or you else you want to
avoid defining orphan Backprop
instances for external types. Can also
be useful if mixing and matching styles.
See Numeric.Backprop for fuller documentation on using these functions.
WARNING: API of this module can be considered only "semistable"; while the API of Numeric.Backprop and Numeric.Backprop.Num are kept consistent, some argument order changes might happen in this module to reflect changes in underlying implementation.
Since: backprop0.2.0.0
Synopsis
 data BVar s a
 data W
 class Backprop a where
 newtype ABP f a = ABP {
 runABP :: f a
 newtype NumBP a = NumBP {
 runNumBP :: a
 newtype ZeroFunc a = ZF {
 runZF :: a > a
 zfNum :: Num a => ZeroFunc a
 zfNums :: RPureConstrained Num as => Rec ZeroFunc as
 zeroFunc :: Backprop a => ZeroFunc a
 zeroFuncs :: RPureConstrained Backprop as => Rec ZeroFunc as
 zfFunctor :: (Backprop a, Functor f) => ZeroFunc (f a)
 newtype AddFunc a = AF {
 runAF :: a > a > a
 afNum :: Num a => AddFunc a
 afNums :: RPureConstrained Num as => Rec AddFunc as
 addFunc :: Backprop a => AddFunc a
 addFuncs :: RPureConstrained Backprop as => Rec AddFunc as
 newtype OneFunc a = OF {
 runOF :: a > a
 ofNum :: Num a => OneFunc a
 ofNums :: RPureConstrained Num as => Rec OneFunc as
 oneFunc :: Backprop a => OneFunc a
 oneFuncs :: RPureConstrained Backprop as => Rec OneFunc as
 ofFunctor :: (Backprop a, Functor f) => OneFunc (f a)
 backprop :: ZeroFunc a > OneFunc b > (forall s. Reifies s W => BVar s a > BVar s b) > a > (b, a)
 evalBP :: (forall s. Reifies s W => BVar s a > BVar s b) > a > b
 gradBP :: ZeroFunc a > OneFunc b > (forall s. Reifies s W => BVar s a > BVar s b) > a > a
 backpropWith :: ZeroFunc a > (forall s. Reifies s W => BVar s a > BVar s b) > a > (b, b > a)
 evalBP0 :: (forall s. Reifies s W => BVar s a) > a
 backprop2 :: ZeroFunc a > ZeroFunc b > OneFunc c > (forall s. Reifies s W => BVar s a > BVar s b > BVar s c) > a > b > (c, (a, b))
 evalBP2 :: (forall s. Reifies s W => BVar s a > BVar s b > BVar s c) > a > b > c
 gradBP2 :: ZeroFunc a > ZeroFunc b > OneFunc c > (forall s. Reifies s W => BVar s a > BVar s b > BVar s c) > a > b > (a, b)
 backpropWith2 :: ZeroFunc a > ZeroFunc b > (forall s. Reifies s W => BVar s a > BVar s b > BVar s c) > a > b > (c, c > (a, b))
 backpropN :: forall as b. Rec ZeroFunc as > OneFunc b > (forall s. Reifies s W => Rec (BVar s) as > BVar s b) > Rec Identity as > (b, Rec Identity as)
 evalBPN :: forall as b. (forall s. Reifies s W => Rec (BVar s) as > BVar s b) > Rec Identity as > b
 gradBPN :: Rec ZeroFunc as > OneFunc b > (forall s. Reifies s W => Rec (BVar s) as > BVar s b) > Rec Identity as > Rec Identity as
 backpropWithN :: forall as b. Rec ZeroFunc as > (forall s. Reifies s W => Rec (BVar s) as > BVar s b) > Rec Identity as > (b, b > Rec Identity as)
 class RPureConstrained (c :: u > Constraint) (ts :: [u])
 constVar :: a > BVar s a
 auto :: a > BVar s a
 coerceVar :: Coercible a b => BVar s a > BVar s b
 viewVar :: forall a b s. Reifies s W => AddFunc a > ZeroFunc b > Lens' b a > BVar s b > BVar s a
 setVar :: forall a b s. Reifies s W => AddFunc a > AddFunc b > ZeroFunc a > Lens' b a > BVar s a > BVar s b > BVar s b
 overVar :: Reifies s W => AddFunc a > AddFunc b > ZeroFunc a > ZeroFunc b > Lens' b a > (BVar s a > BVar s a) > BVar s b > BVar s b
 sequenceVar :: forall t a s. (Reifies s W, Traversable t) => AddFunc a > ZeroFunc a > BVar s (t a) > t (BVar s a)
 collectVar :: forall t a s. (Reifies s W, Foldable t, Functor t) => AddFunc a > ZeroFunc a > t (BVar s a) > BVar s (t a)
 previewVar :: forall b a s. Reifies s W => AddFunc a > ZeroFunc b > Traversal' b a > BVar s b > Maybe (BVar s a)
 toListOfVar :: forall b a s. Reifies s W => AddFunc a > ZeroFunc b > Traversal' b a > BVar s b > [BVar s a]
 isoVar :: Reifies s W => AddFunc a > (a > b) > (b > a) > BVar s a > BVar s b
 isoVar2 :: Reifies s W => AddFunc a > AddFunc b > (a > b > c) > (c > (a, b)) > BVar s a > BVar s b > BVar s c
 isoVar3 :: Reifies s W => AddFunc a > AddFunc b > AddFunc c > (a > b > c > d) > (d > (a, b, c)) > BVar s a > BVar s b > BVar s c > BVar s d
 isoVarN :: Reifies s W => Rec AddFunc as > (Rec Identity as > b) > (b > Rec Identity as) > Rec (BVar s) as > BVar s b
 liftOp :: forall as b s. Reifies s W => Rec AddFunc as > Op as b > Rec (BVar s) as > BVar s b
 liftOp1 :: forall a b s. Reifies s W => AddFunc a > Op '[a] b > BVar s a > BVar s b
 liftOp2 :: forall a b c s. Reifies s W => AddFunc a > AddFunc b > Op '[a, b] c > BVar s a > BVar s b > BVar s c
 liftOp3 :: forall a b c d s. Reifies s W => AddFunc a > AddFunc b > AddFunc c > Op '[a, b, c] d > BVar s a > BVar s b > BVar s c > BVar s d
 splitBV :: forall z f s as. (Generic (z f), Generic (z (BVar s)), BVGroup s as (Rep (z f)) (Rep (z (BVar s))), Reifies s W) => AddFunc (Rep (z f) ()) > Rec AddFunc as > ZeroFunc (z f) > Rec ZeroFunc as > BVar s (z f) > z (BVar s)
 joinBV :: forall z f s as. (Generic (z f), Generic (z (BVar s)), BVGroup s as (Rep (z f)) (Rep (z (BVar s))), Reifies s W) => AddFunc (z f) > Rec AddFunc as > ZeroFunc (Rep (z f) ()) > Rec ZeroFunc as > z (BVar s) > BVar s (z f)
 class BVGroup s as i o  o > i, i > as
 newtype Op as a = Op {}
 op0 :: a > Op '[] a
 opConst :: forall as a. RPureConstrained Num as => a > Op as a
 idOp :: Op '[a] a
 bpOp :: Rec ZeroFunc as > (forall s. Reifies s W => Rec (BVar s) as > BVar s b) > Op as b
 op1 :: (a > (b, b > a)) > Op '[a] b
 op2 :: (a > b > (c, c > (a, b))) > Op '[a, b] c
 op3 :: (a > b > c > (d, d > (a, b, c))) > Op '[a, b, c] d
 opCoerce :: Coercible a b => Op '[a] b
 opTup :: Op as (Rec Identity as)
 opIso :: (a > b) > (b > a) > Op '[a] b
 opIsoN :: (Rec Identity as > b) > (b > Rec Identity as) > Op as b
 opLens :: Num a => Lens' a b > Op '[a] b
 noGrad1 :: (a > b) > Op '[a] b
 noGrad :: (Rec Identity as > b) > Op as b
 class Reifies (s :: k) a  s > a
Types
A
is a value of type BVar
s aa
that can be "backpropagated".
Functions referring to BVar
s are tracked by the library and can be
automatically differentiated to get their gradients and results.
For simple numeric values, you can use its Num
, Fractional
, and
Floating
instances to manipulate them as if they were the numbers they
represent.
If a
contains items, the items can be accessed and extracted using
lenses. A
can be used to access an Lens'
b aa
inside a b
, using
^^.
(viewVar
):
(^.
) :: a >Lens'
a b > b (^^.
) ::BVar
s a >Lens'
a b >BVar
s b
There is also ^^?
(previewVar
), to use a Prism'
or Traversal'
to extract a target that may or may not be present
(which can implement pattern matching), ^^..
(toListOfVar
) to use a Traversal'
to extract all
targets inside a BVar
, and .~~
(setVar
) to set and update values
inside a BVar
.
If you have control over your data type definitions, you can also use
splitBV
and joinBV
to manipulate
data types by easily extracting fields out of a BVar
of data types and
creating BVar
s of data types out of BVar
s of their fields. See
Numeric.Backprop for a tutorial on this use pattern.
For more complex operations, libraries can provide functions on BVar
s
using liftOp
and related functions. This is how you
can create primitive functions that users can use to manipulate your
library's values. See
https://backprop.jle.im/08equippingyourlibrary.html for a detailed
guide.
For example, the hmatrix library has a matrixvector multiplication
function, #> :: L m n > R n > L m
.
A library could instead provide a function #> ::
, which the user can then use to manipulate their
BVar
(L m n) > BVar
(R n) > BVar (R m)BVar
s of L m n
s and R n
s, etc.
See Numeric.Backprop and documentation for
liftOp
for more information.
Instances
BVGroup s ([] :: [*]) (K1 i a :: * > *) (K1 i (BVar s a) :: * > *) Source #  
Eq a => Eq (BVar s a) Source #  Compares the values inside the Since: backprop0.1.5.0 
(Floating a, Reifies s W) => Floating (BVar s a) Source #  
Defined in Numeric.Backprop.Internal sqrt :: BVar s a > BVar s a # (**) :: BVar s a > BVar s a > BVar s a # logBase :: BVar s a > BVar s a > BVar s a # asin :: BVar s a > BVar s a # acos :: BVar s a > BVar s a # atan :: BVar s a > BVar s a # sinh :: BVar s a > BVar s a # cosh :: BVar s a > BVar s a # tanh :: BVar s a > BVar s a # asinh :: BVar s a > BVar s a # acosh :: BVar s a > BVar s a # atanh :: BVar s a > BVar s a # log1p :: BVar s a > BVar s a # expm1 :: BVar s a > BVar s a #  
(Fractional a, Reifies s W) => Fractional (BVar s a) Source #  
(Num a, Reifies s W) => Num (BVar s a) Source #  
Ord a => Ord (BVar s a) Source #  Compares the values inside the Since: backprop0.1.5.0 
Defined in Numeric.Backprop.Internal  
NFData a => NFData (BVar s a) Source #  This will force the value inside, as well. 
Defined in Numeric.Backprop.Internal  
(Backprop a, Reifies s W) => Backprop (BVar s a) Source #  Since: backprop0.2.2.0 
class Backprop a where Source #
Class of values that can be backpropagated in general.
For instances of Num
, these methods can be given by zeroNum
,
addNum
, and oneNum
. There are also generic options given in
Numeric.Backprop.Class for functors, IsList
instances, and Generic
instances.
instanceBackprop
Double
wherezero
=zeroNum
add
=addNum
one
=oneNum
If you leave the body of an instance declaration blank, GHC Generics
will be used to derive instances if the type has a single constructor
and each field is an instance of Backprop
.
To ensure that backpropagation works in a sound way, should obey the laws:
 identity
Also implies preservation of information, making
an
illegal implementation for lists and vectors.zipWith
(+
)
This is only expected to be true up to potential "extra zeroes" in x
and y
in the result.
 commutativity
 associativity
 idempotence
 unital
Note that not all values in the backpropagation process needs all of
these methods: Only the "final result" needs one
, for example. These
are all grouped under one typeclass for convenience in defining
instances, and also to talk about sensible laws. For finegrained
control, use the "explicit" versions of library functions (for example,
in Numeric.Backprop.Explicit) instead of Backprop
based ones.
This typeclass replaces the reliance on Num
of the previous API
(v0.1). Num
is strictly more powerful than Backprop
, and is
a stronger constraint on types than is necessary for proper
backpropagating. In particular, fromInteger
is a problem for many
types, preventing useful backpropagation for lists, variablelength
vectors (like Data.Vector) and variablesize matrices from linear
algebra libraries like hmatrix and accelerate.
Since: backprop0.2.0.0
"Zero out" all components of a value. For scalar values, this
should just be
. For vectors and matrices, this should
set all components to zero, the additive identity.const
0
Should be idempotent:
Should be as lazy as possible. This behavior is observed for all instances provided by this library.
See zeroNum
for a prebuilt definition for instances of Num
and
zeroFunctor
for a definition for instances of Functor
. If left
blank, will automatically be genericZero
, a prebuilt definition
for instances of Generic
whose fields are all themselves
instances of Backprop
.
Add together two values of a type. To combine contributions of gradients, so should be informationpreserving:
Should be as strict as possible. This behavior is observed for all instances provided by this library.
See addNum
for a prebuilt definition for instances of Num
and
addIsList
for a definition for instances of IsList
. If left
blank, will automatically be genericAdd
, a prebuilt definition
for instances of Generic
with one constructor whose fields are
all themselves instances of Backprop
.
One all components of a value. For scalar values, this should
just be
. For vectors and matrices, this should set all
components to one, the multiplicative identity.const
1
As the library uses it, the most important law is:
That is,
is the gradient of the identity function with
respect to its input.one
x
Ideally should be idempotent:
Should be as lazy as possible. This behavior is observed for all instances provided by this library.
See oneNum
for a prebuilt definition for instances of Num
and
oneFunctor
for a definition for instances of Functor
. If left
blank, will automatically be genericOne
, a prebuilt definition
for instances of Generic
whose fields are all themselves
instances of Backprop
.
zero :: (Generic a, GZero (Rep a)) => a > a Source #
"Zero out" all components of a value. For scalar values, this
should just be
. For vectors and matrices, this should
set all components to zero, the additive identity.const
0
Should be idempotent:
Should be as lazy as possible. This behavior is observed for all instances provided by this library.
See zeroNum
for a prebuilt definition for instances of Num
and
zeroFunctor
for a definition for instances of Functor
. If left
blank, will automatically be genericZero
, a prebuilt definition
for instances of Generic
whose fields are all themselves
instances of Backprop
.
add :: (Generic a, GAdd (Rep a)) => a > a > a Source #
Add together two values of a type. To combine contributions of gradients, so should be informationpreserving:
Should be as strict as possible. This behavior is observed for all instances provided by this library.
See addNum
for a prebuilt definition for instances of Num
and
addIsList
for a definition for instances of IsList
. If left
blank, will automatically be genericAdd
, a prebuilt definition
for instances of Generic
with one constructor whose fields are
all themselves instances of Backprop
.
one :: (Generic a, GOne (Rep a)) => a > a Source #
One all components of a value. For scalar values, this should
just be
. For vectors and matrices, this should set all
components to one, the multiplicative identity.const
1
As the library uses it, the most important law is:
That is,
is the gradient of the identity function with
respect to its input.one
x
Ideally should be idempotent:
Should be as lazy as possible. This behavior is observed for all instances provided by this library.
See oneNum
for a prebuilt definition for instances of Num
and
oneFunctor
for a definition for instances of Functor
. If left
blank, will automatically be genericOne
, a prebuilt definition
for instances of Generic
whose fields are all themselves
instances of Backprop
.
Instances
Backprop Double Source #  
Backprop Float Source #  
Backprop Int Source #  
Backprop Integer Source #  
Backprop Natural Source #  Since: backprop0.2.1.0 
Backprop Word Source #  Since: backprop0.2.2.0 
Backprop Word8 Source #  Since: backprop0.2.2.0 
Backprop Word16 Source #  Since: backprop0.2.2.0 
Backprop Word32 Source #  Since: backprop0.2.2.0 
Backprop Word64 Source #  Since: backprop0.2.2.0 
Backprop () Source # 

Backprop Void Source #  
Backprop a => Backprop [a] Source # 

Backprop a => Backprop (Maybe a) Source # 

Integral a => Backprop (Ratio a) Source #  
RealFloat a => Backprop (Complex a) Source #  
Backprop a => Backprop (First a) Source #  Since: backprop0.2.2.0 
Backprop a => Backprop (Last a) Source #  Since: backprop0.2.2.0 
Backprop a => Backprop (Option a) Source #  Since: backprop0.2.2.0 
Backprop a => Backprop (Identity a) Source #  
Backprop a => Backprop (First a) Source #  Since: backprop0.2.2.0 
Backprop a => Backprop (Last a) Source #  Since: backprop0.2.2.0 
Backprop a => Backprop (Dual a) Source #  Since: backprop0.2.2.0 
Backprop a => Backprop (Sum a) Source #  Since: backprop0.2.2.0 
Backprop a => Backprop (Product a) Source #  Since: backprop0.2.2.0 
Backprop a => Backprop (NonEmpty a) Source # 

Backprop a => Backprop (IntMap a) Source # 

Backprop a => Backprop (Seq a) Source # 

(Unbox a, Backprop a) => Backprop (Vector a) Source #  
(Storable a, Backprop a) => Backprop (Vector a) Source #  
(Prim a, Backprop a) => Backprop (Vector a) Source #  
Backprop a => Backprop (Vector a) Source #  
Num a => Backprop (NumBP a) Source #  
Backprop a => Backprop (r > a) Source # 
Since: backprop0.2.2.0 
Backprop (V1 p) Source #  Since: backprop0.2.2.0 
Backprop (U1 p) Source #  Since: backprop0.2.2.0 
(Backprop a, Backprop b) => Backprop (a, b) Source # 

(Backprop a, Backprop b) => Backprop (Arg a b) Source #  Since: backprop0.2.2.0 
Backprop (Proxy a) Source #  
(Backprop a, Ord k) => Backprop (Map k a) Source # 

(Applicative f, Backprop a) => Backprop (ABP f a) Source #  
(Vector v a, Num a) => Backprop (NumVec v a) Source #  
(Backprop a, Reifies s W) => Backprop (BVar s a) Source #  Since: backprop0.2.2.0 
(Backprop a, Backprop b, Backprop c) => Backprop (a, b, c) Source # 

(Backprop a, Applicative m) => Backprop (Kleisli m r a) Source #  Since: backprop0.2.2.0 
Backprop w => Backprop (Const w a) Source #  Since: backprop0.2.2.0 
Backprop a => Backprop (K1 i a p) Source #  Since: backprop0.2.2.0 
(Backprop (f p), Backprop (g p)) => Backprop ((f :*: g) p) Source #  Since: backprop0.2.2.0 
(Backprop a, Backprop b, Backprop c, Backprop d) => Backprop (a, b, c, d) Source # 

(Backprop (f a), Backprop (g a)) => Backprop (Product f g a) Source #  Since: backprop0.2.2.0 
Backprop (f p) => Backprop (M1 i c f p) Source #  Since: backprop0.2.2.0 
(Backprop a, Backprop b, Backprop c, Backprop d, Backprop e) => Backprop (a, b, c, d, e) Source # 

Backprop (f (g a)) => Backprop (Compose f g a) Source #  Since: backprop0.2.2.0 
A newtype wrapper over an f a
for
that gives
a free Applicative
fBackprop
instance (as well as Num
etc. instances).
Useful for performing backpropagation over functions that require some
monadic context (like IO
) to perform.
Since: backprop0.2.1.0
Instances
Monad f => Monad (ABP f) Source #  
Functor f => Functor (ABP f) Source #  
Applicative f => Applicative (ABP f) Source #  
Foldable f => Foldable (ABP f) Source #  
Defined in Numeric.Backprop.Class fold :: Monoid m => ABP f m > m # foldMap :: Monoid m => (a > m) > ABP f a > m # foldr :: (a > b > b) > b > ABP f a > b # foldr' :: (a > b > b) > b > ABP f a > b # foldl :: (b > a > b) > b > ABP f a > b # foldl' :: (b > a > b) > b > ABP f a > b # foldr1 :: (a > a > a) > ABP f a > a # foldl1 :: (a > a > a) > ABP f a > a # elem :: Eq a => a > ABP f a > Bool # maximum :: Ord a => ABP f a > a # minimum :: Ord a => ABP f a > a #  
Traversable f => Traversable (ABP f) Source #  
Alternative f => Alternative (ABP f) Source #  
MonadPlus f => MonadPlus (ABP f) Source #  
Eq (f a) => Eq (ABP f a) Source #  
(Applicative f, Floating a) => Floating (ABP f a) Source #  
(Applicative f, Fractional a) => Fractional (ABP f a) Source #  
(Typeable f, Typeable a, Data (f a)) => Data (ABP f a) Source #  
Defined in Numeric.Backprop.Class gfoldl :: (forall d b. Data d => c (d > b) > d > c b) > (forall g. g > c g) > ABP f a > c (ABP f a) # gunfold :: (forall b r. Data b => c (b > r) > c r) > (forall r. r > c r) > Constr > c (ABP f a) # toConstr :: ABP f a > Constr # dataTypeOf :: ABP f a > DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) > Maybe (c (ABP f a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) > Maybe (c (ABP f a)) # gmapT :: (forall b. Data b => b > b) > ABP f a > ABP f a # gmapQl :: (r > r' > r) > r > (forall d. Data d => d > r') > ABP f a > r # gmapQr :: (r' > r > r) > r > (forall d. Data d => d > r') > ABP f a > r # gmapQ :: (forall d. Data d => d > u) > ABP f a > [u] # gmapQi :: Int > (forall d. Data d => d > u) > ABP f a > u # gmapM :: Monad m => (forall d. Data d => d > m d) > ABP f a > m (ABP f a) # gmapMp :: MonadPlus m => (forall d. Data d => d > m d) > ABP f a > m (ABP f a) # gmapMo :: MonadPlus m => (forall d. Data d => d > m d) > ABP f a > m (ABP f a) #  
(Applicative f, Num a) => Num (ABP f a) Source #  
Ord (f a) => Ord (ABP f a) Source #  
Read (f a) => Read (ABP f a) Source #  
Show (f a) => Show (ABP f a) Source #  
Generic (ABP f a) Source #  
NFData (f a) => NFData (ABP f a) Source #  
Defined in Numeric.Backprop.Class  
(Applicative f, Backprop a) => Backprop (ABP f a) Source #  
type Rep (ABP f a) Source #  
Defined in Numeric.Backprop.Class 
A newtype wrapper over an instance of Num
that gives a free
Backprop
instance.
Useful for things like DerivingVia, or for avoiding orphan instances.
Since: backprop0.2.1.0
Instances
Monad NumBP Source #  
Functor NumBP Source #  
Applicative NumBP Source #  
Foldable NumBP Source #  
Defined in Numeric.Backprop.Class fold :: Monoid m => NumBP m > m # foldMap :: Monoid m => (a > m) > NumBP a > m # foldr :: (a > b > b) > b > NumBP a > b # foldr' :: (a > b > b) > b > NumBP a > b # foldl :: (b > a > b) > b > NumBP a > b # foldl' :: (b > a > b) > b > NumBP a > b # foldr1 :: (a > a > a) > NumBP a > a # foldl1 :: (a > a > a) > NumBP a > a # elem :: Eq a => a > NumBP a > Bool # maximum :: Ord a => NumBP a > a # minimum :: Ord a => NumBP a > a #  
Traversable NumBP Source #  
Eq a => Eq (NumBP a) Source #  
Floating a => Floating (NumBP a) Source #  
Fractional a => Fractional (NumBP a) Source #  
Data a => Data (NumBP a) Source #  
Defined in Numeric.Backprop.Class gfoldl :: (forall d b. Data d => c (d > b) > d > c b) > (forall g. g > c g) > NumBP a > c (NumBP a) # gunfold :: (forall b r. Data b => c (b > r) > c r) > (forall r. r > c r) > Constr > c (NumBP a) # toConstr :: NumBP a > Constr # dataTypeOf :: NumBP a > DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) > Maybe (c (NumBP a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) > Maybe (c (NumBP a)) # gmapT :: (forall b. Data b => b > b) > NumBP a > NumBP a # gmapQl :: (r > r' > r) > r > (forall d. Data d => d > r') > NumBP a > r # gmapQr :: (r' > r > r) > r > (forall d. Data d => d > r') > NumBP a > r # gmapQ :: (forall d. Data d => d > u) > NumBP a > [u] # gmapQi :: Int > (forall d. Data d => d > u) > NumBP a > u # gmapM :: Monad m => (forall d. Data d => d > m d) > NumBP a > m (NumBP a) # gmapMp :: MonadPlus m => (forall d. Data d => d > m d) > NumBP a > m (NumBP a) # gmapMo :: MonadPlus m => (forall d. Data d => d > m d) > NumBP a > m (NumBP a) #  
Num a => Num (NumBP a) Source #  
Ord a => Ord (NumBP a) Source #  
Read a => Read (NumBP a) Source #  
Show a => Show (NumBP a) Source #  
Generic (NumBP a) Source #  
NFData a => NFData (NumBP a) Source #  
Defined in Numeric.Backprop.Class  
Num a => Backprop (NumBP a) Source #  
type Rep (NumBP a) Source #  
Defined in Numeric.Backprop.Class 
Explicit
zero
, add
, and one
"Zero out" all components of a value. For scalar values, this should
just be
. For vectors and matrices, this should set all
components to zero, the additive identity.const
0
Should be idempotent: Applying the function twice is the same as applying it just once.
Each type should ideally only have one ZeroFunc
. This coherence
constraint is given by the typeclass Backprop
.
Since: backprop0.2.0.0
Add together two values of a type. To combine contributions of gradients, so should ideally be informationpreserving.
See laws for Backprop
for the laws this should be expected to
preserve. Namely, it should be commutative and associative, with an
identity for a valid ZeroFunc
.
Each type should ideally only have one AddFunc
. This coherence
constraint is given by the typeclass Backprop
.
Since: backprop0.2.0.0
One all components of a value. For scalar values, this should
just be
. For vectors and matrices, this should set all
components to one, the multiplicative identity.const
1
Should be idempotent: Applying the function twice is the same as applying it just once.
Each type should ideally only have one OneFunc
. This coherence
constraint is given by the typeclass Backprop
.
Since: backprop0.2.0.0
Running
backprop :: ZeroFunc a > OneFunc b > (forall s. Reifies s W => BVar s a > BVar s b) > a > (b, a) Source #
gradBP :: ZeroFunc a > OneFunc b > (forall s. Reifies s W => BVar s a > BVar s b) > a > a Source #
backpropWith :: ZeroFunc a > (forall s. Reifies s W => BVar s a > BVar s b) > a > (b, b > a) Source #
backpropWith
, but with explicit zero
.
Note that argument order changed in v0.2.4.
Multiple inputs
backprop2 :: ZeroFunc a > ZeroFunc b > OneFunc c > (forall s. Reifies s W => BVar s a > BVar s b > BVar s c) > a > b > (c, (a, b)) Source #
gradBP2 :: ZeroFunc a > ZeroFunc b > OneFunc c > (forall s. Reifies s W => BVar s a > BVar s b > BVar s c) > a > b > (a, b) Source #
backpropWith2 :: ZeroFunc a > ZeroFunc b > (forall s. Reifies s W => BVar s a > BVar s b > BVar s c) > a > b > (c, c > (a, b)) Source #
backpropWith2
, but with explicit zero
.
Note that argument order changed in v0.2.4.
Since: backprop0.2.0.0
backpropN :: forall as b. Rec ZeroFunc as > OneFunc b > (forall s. Reifies s W => Rec (BVar s) as > BVar s b) > Rec Identity as > (b, Rec Identity as) Source #
evalBPN :: forall as b. (forall s. Reifies s W => Rec (BVar s) as > BVar s b) > Rec Identity as > b Source #
evalBP
generalized to multiple inputs of different types. See
documentation for backpropN
for more details.
gradBPN :: Rec ZeroFunc as > OneFunc b > (forall s. Reifies s W => Rec (BVar s) as > BVar s b) > Rec Identity as > Rec Identity as Source #
backpropWithN :: forall as b. Rec ZeroFunc as > (forall s. Reifies s W => Rec (BVar s) as > BVar s b) > Rec Identity as > (b, b > Rec Identity as) Source #
backpropWithN
, but with explicit zero
and one
.
Note that argument order changed in v0.2.4.
Since: backprop0.2.0.0
class RPureConstrained (c :: u > Constraint) (ts :: [u]) #
Build a record whose elements are derived solely from a constraint satisfied by each.
Instances
RPureConstrained (c :: u > Constraint) ([] :: [u])  
Defined in Data.Vinyl.Core rpureConstrained :: (forall (a :: u0). c a => f a) > Rec f [] #  
(c x, RPureConstrained c xs) => RPureConstrained (c :: a > Constraint) (x ': xs :: [a])  
Defined in Data.Vinyl.Core rpureConstrained :: (forall (a0 :: u). c a0 => f a0) > Rec f (x ': xs) # 
Manipulating
BVar
constVar :: a > BVar s a Source #
Lift a value into a BVar
representing a constant value.
This value will not be considered an input, and its gradients will not be backpropagated.
auto :: a > BVar s a Source #
Shorter alias for constVar
, inspired by the ad library.
Since: backprop0.2.0.0
coerceVar :: Coercible a b => BVar s a > BVar s b Source #
Coerce a BVar
contents. Useful for things like newtype wrappers.
Since: backprop0.1.5.2
viewVar :: forall a b s. Reifies s W => AddFunc a > ZeroFunc b > Lens' b a > BVar s b > BVar s a Source #
setVar :: forall a b s. Reifies s W => AddFunc a > AddFunc b > ZeroFunc a > Lens' b a > BVar s a > BVar s b > BVar s b Source #
overVar :: Reifies s W => AddFunc a > AddFunc b > ZeroFunc a > ZeroFunc b > Lens' b a > (BVar s a > BVar s a) > BVar s b > BVar s b Source #
sequenceVar :: forall t a s. (Reifies s W, Traversable t) => AddFunc a > ZeroFunc a > BVar s (t a) > t (BVar s a) Source #
sequenceVar
, but with explicit add
and zero
.
collectVar :: forall t a s. (Reifies s W, Foldable t, Functor t) => AddFunc a > ZeroFunc a > t (BVar s a) > BVar s (t a) Source #
collectVar
, but with explicit add
and zero
.
previewVar :: forall b a s. Reifies s W => AddFunc a > ZeroFunc b > Traversal' b a > BVar s b > Maybe (BVar s a) Source #
previewVar
, but with explicit add
and zero
.
toListOfVar :: forall b a s. Reifies s W => AddFunc a > ZeroFunc b > Traversal' b a > BVar s b > [BVar s a] Source #
toListOfVar
, but with explicit add
and zero
.
With Isomorphisms
isoVar2 :: Reifies s W => AddFunc a > AddFunc b > (a > b > c) > (c > (a, b)) > BVar s a > BVar s b > BVar s c Source #
isoVar3 :: Reifies s W => AddFunc a > AddFunc b > AddFunc c > (a > b > c > d) > (d > (a, b, c)) > BVar s a > BVar s b > BVar s c > BVar s d Source #
isoVarN :: Reifies s W => Rec AddFunc as > (Rec Identity as > b) > (b > Rec Identity as) > Rec (BVar s) as > BVar s b Source #
With
Op
s
liftOp :: forall as b s. Reifies s W => Rec AddFunc as > Op as b > Rec (BVar s) as > BVar s b Source #
liftOp2 :: forall a b c s. Reifies s W => AddFunc a > AddFunc b > Op '[a, b] c > BVar s a > BVar s b > BVar s c Source #
liftOp3 :: forall a b c d s. Reifies s W => AddFunc a > AddFunc b > AddFunc c > Op '[a, b, c] d > BVar s a > BVar s b > BVar s c > BVar s d Source #
Generics
class BVGroup s as i o  o > i, i > as Source #
Helper class for generically "splitting" and "joining" BVar
s into
constructors. See splitBV
and
joinBV
.
See Numeric.Backprop for a tutorial on how to use this.
Instances should be available for types made with one constructor whose
fields are all instances of Backprop
, with a Generic
instance.
Since: backprop0.2.2.0
gsplitBV, gjoinBV
Instances
BVGroup s as i o => BVGroup s as (M1 p c i) (M1 p c o) Source #  
BVGroup s ([] :: [*]) (U1 :: * > *) (U1 :: * > *) Source #  
BVGroup s ([] :: [*]) (V1 :: * > *) (V1 :: * > *) Source #  
BVGroup s ([] :: [*]) (K1 i a :: * > *) (K1 i (BVar s a) :: * > *) Source #  
(Reifies s W, BVGroup s as i1 o1, BVGroup s bs i2 o2, cs ~ (as ++ bs), RecApplicative as) => BVGroup s (i1 () ': (i2 () ': cs)) (i1 :+: i2) (o1 :+: o2) Source #  This instance is possible but it is not clear when it would be useful 
Defined in Numeric.Backprop.Explicit  
(Reifies s W, BVGroup s as i1 o1, BVGroup s bs i2 o2, cs ~ (as ++ bs), RecApplicative as) => BVGroup s (i1 () ': (i2 () ': cs)) (i1 :*: i2) (o1 :*: o2) Source #  
Defined in Numeric.Backprop.Explicit 
Op
An
describes a differentiable function from Op
as aas
to a
.
For example, a value of type
Op
'[Int, Bool] Double
is a function from an Int
and a Bool
, returning a Double
. It can
be differentiated to give a gradient of an Int
and a Bool
if given
a total derivative for the Double
. If we call Bool
\(2\), then,
mathematically, it is akin to a:
\[ f : \mathbb{Z} \times 2 \rightarrow \mathbb{R} \]
See runOp
, gradOp
, and gradOpWith
for examples on how to run it,
and Op
for instructions on creating it.
It is simpler to not use this type constructor directly, and instead use
the op2
, op1
, op2
, and op3
helper smart constructors.
See Numeric.Backprop.Op for a minitutorial on using Rec
and
'Rec Identity'.
To use an Op
with the backprop library, see liftOp
, liftOp1
,
liftOp2
, and liftOp3
.
Op  Construct an See the module documentation for Numeric.Backprop.Op for more
details on the function that this constructor and 
Instances
(RPureConstrained Num as, Floating a) => Floating (Op as a) Source #  
(RPureConstrained Num as, Fractional a) => Fractional (Op as a) Source #  
(RPureConstrained Num as, Num a) => Num (Op as a) Source #  
Creation
Create an Op
that takes no inputs and always returns the given
value.
There is no gradient, of course (using gradOp
will give you an empty
tuple), because there is no input to have a gradient of.
>>>
runOp (op0 10) RNil
(10, RNil)
For a constant Op
that takes input and ignores it, see opConst
and
opConst'
.
opConst :: forall as a. RPureConstrained Num as => a > Op as a Source #
An Op
that ignores all of its inputs and returns a given constant
value.
>>>
gradOp' (opConst 10) (1 :& 2 :& 3 :& RNil)
(10, 0 :& 0 :& 0 :& RNil)
bpOp :: Rec ZeroFunc as > (forall s. Reifies s W => Rec (BVar s) as > BVar s b) > Op as b Source #
Giving gradients directly
op1 :: (a > (b, b > a)) > Op '[a] b Source #
Create an Op
of a function taking one input, by giving its explicit
derivative. The function should return a tuple containing the result of
the function, and also a function taking the derivative of the result
and return the derivative of the input.
If we have
\[ \eqalign{ f &: \mathbb{R} \rightarrow \mathbb{R}\cr y &= f(x)\cr z &= g(y) } \]
Then the derivative \( \frac{dz}{dx} \), it would be:
\[ \frac{dz}{dx} = \frac{dz}{dy} \frac{dy}{dx} \]
If our Op
represents \(f\), then the second item in the resulting
tuple should be a function that takes \(\frac{dz}{dy}\) and returns
\(\frac{dz}{dx}\).
As an example, here is an Op
that squares its input:
square :: Num a =>Op
'[a] a square =op1
$ \x > (x*x, \d > 2 * d * x )
Remember that, generally, end users shouldn't directly construct Op
s;
they should be provided by libraries or generated automatically.
op2 :: (a > b > (c, c > (a, b))) > Op '[a, b] c Source #
Create an Op
of a function taking two inputs, by giving its explicit
gradient. The function should return a tuple containing the result of
the function, and also a function taking the derivative of the result
and return the derivative of the input.
If we have
\[ \eqalign{ f &: \mathbb{R}^2 \rightarrow \mathbb{R}\cr z &= f(x, y)\cr k &= g(z) } \]
Then the gradient \( \left< \frac{\partial k}{\partial x}, \frac{\partial k}{\partial y} \right> \) would be:
\[ \left< \frac{\partial k}{\partial x}, \frac{\partial k}{\partial y} \right> = \left< \frac{dk}{dz} \frac{\partial z}{dx}, \frac{dk}{dz} \frac{\partial z}{dy} \right> \]
If our Op
represents \(f\), then the second item in the resulting
tuple should be a function that takes \(\frac{dk}{dz}\) and returns
\( \left< \frac{\partial k}{dx}, \frac{\partial k}{dx} \right> \).
As an example, here is an Op
that multiplies its inputs:
mul :: Num a =>Op
'[a, a] a mul =op2'
$ \x y > (x*y, \d > (d*y, x*d) )
Remember that, generally, end users shouldn't directly construct Op
s;
they should be provided by libraries or generated automatically.
From Isomorphisms
opTup :: Op as (Rec Identity as) Source #
An Op
that takes as
and returns exactly the input tuple.
>>>
gradOp' opTup (1 :& 2 :& 3 :& RNil)
(1 :& 2 :& 3 :& RNil, 1 :& 1 :& 1 :& RNil)
opIsoN :: (Rec Identity as > b) > (b > Rec Identity as) > Op as b Source #
An Op
that runs the input value through an isomorphism between
a tuple of values and a value. See opIso
for caveats.
In Numeric.Backprop.Op since version 0.1.2.0, but only exported from Numeric.Backprop since version 0.1.3.0.
Since: backprop0.1.2.0
No gradients
noGrad1 :: (a > b) > Op '[a] b Source #
Create an Op
with no gradient. Can be evaluated with evalOp
, but
will throw a runtime exception when asked for the gradient.
Can be used with BVar
with liftOp1
, and evalBP
will work fine.
gradBP
and backprop
will also work fine if the result is never used
in the final answer, but will throw a runtime exception if the final
answer depends on the result of this operation.
Useful if your only API is exposed through backprop. Just be sure to tell your users that this will explode when finding the gradient if the result is used in the final result.
Since: backprop0.1.3.0
noGrad :: (Rec Identity as > b) > Op as b Source #
Create an Op
with no gradient. Can be evaluated with evalOp
, but
will throw a runtime exception when asked for the gradient.
Can be used with BVar
with liftOp
, and evalBP
will work fine.
gradBP
and backprop
will also work fine if the result is never used
in the final answer, but will throw a runtime exception if the final
answer depends on the result of this operation.
Useful if your only API is exposed through backprop. Just be sure to tell your users that this will explode when finding the gradient if the result is used in the final result.
Since: backprop0.1.3.0
Utility
class Reifies (s :: k) a  s > a #
Instances
KnownNat n => Reifies (n :: Nat) Integer  
Defined in Data.Reflection  
KnownSymbol n => Reifies (n :: Symbol) String  
Defined in Data.Reflection  
Reifies Z Int  
Defined in Data.Reflection  
Reifies n Int => Reifies (D n :: *) Int  
Defined in Data.Reflection  
Reifies n Int => Reifies (SD n :: *) Int  
Defined in Data.Reflection  
Reifies n Int => Reifies (PD n :: *) Int  
Defined in Data.Reflection  
(B b0, B b1, B b2, B b3, B b4, B b5, B b6, B b7, w0 ~ W b0 b1 b2 b3, w1 ~ W b4 b5 b6 b7) => Reifies (Stable w0 w1 a :: *) a  
Defined in Data.Reflection 