Safe Haskell | Safe-Inferred |
---|---|
Language | Haskell2010 |
Synopsis
- data Expr a v where
- data Term a v where
- Term :: (v -> VecBuilder u) -> Expr a u -> Term a v
- class Monoid (VecBuilder v) => BasicVector v where
- type VecBuilder v :: Type
- sumBuilder :: VecBuilder v -> v
- class (BasicVector v, VectorSpace v) => FullVector v where
- identityBuilder :: v -> VecBuilder v
- negateBuilder :: v -> VecBuilder v
- scaleBuilder :: Scalar v -> v -> VecBuilder v
- newtype SparseVector v = SparseVector {
- unSparseVector :: VecBuilder v
- newtype DenseVector v = DenseVector v
- newtype DenseBuilder v = DenseBuilder (Maybe v)
- toDenseBuilder :: v -> DenseBuilder v
- maybeToMonoid :: Monoid m => Maybe m -> m
Expression
Expr a v
represents a linear expression of type v
, containing some free variables of type a
.
Instances
FullVector dv => VectorSpace (Expr da dv) Source # | |
FullVector v => AdditiveGroup (Expr a v) Source # | |
type Scalar (Expr da dv) Source # | |
Defined in Downhill.Linear.Expr |
Argument f
in Term f x
must be linear function. That's a law.
Term :: (v -> VecBuilder u) -> Expr a u -> Term a v |
Vectors
class Monoid (VecBuilder v) => BasicVector v where Source #
type VecBuilder v :: Type Source #
VecBuilder v
is a sparse representation of vector v
. Edges of a computational graph
produce builders, which are then summed into vectors in nodes. Monoid operation <>
means addition of vectors, but it doesn't need to compute the sum immediately - it
might defer computation until sumBuilder
is evaluated.
sumBuilder mempty = zeroV sumBuilder (x <> y) = sumBuilder x ^+^ sumBuilder y
sumBuilder :: VecBuilder v -> v Source #
Instances
class (BasicVector v, VectorSpace v) => FullVector v where Source #
Full-featured vector.
Gradients are linear functions and form a vector space.
FullVector
class provides functionality that is needed to
make VectorSpace
instances.
identityBuilder :: v -> VecBuilder v Source #
negateBuilder :: v -> VecBuilder v Source #
scaleBuilder :: Scalar v -> v -> VecBuilder v Source #
Instances
newtype SparseVector v Source #
Normally graph node would compute the sum of gradients and then
propagate it to ancestor nodes. That's the best strategy when
some computation needs to be performed for backpropagation.
Some operations, like constructing/deconstructing tuples or
wrapping/unwrapping, don't need to compute the sum. Doing so only
destroys sparsity. A node of type SparseVector v
won't sum
the gradients, it will simply forward builders to its parents.
Instances
Semigroup (VecBuilder v) => Semigroup (SparseVector v) Source # | |
Defined in Downhill.Linear.Expr (<>) :: SparseVector v -> SparseVector v -> SparseVector v # sconcat :: NonEmpty (SparseVector v) -> SparseVector v # stimes :: Integral b => b -> SparseVector v -> SparseVector v # | |
Monoid (VecBuilder v) => BasicVector (SparseVector v) Source # | |
Defined in Downhill.Linear.Expr type VecBuilder (SparseVector v) Source # sumBuilder :: VecBuilder (SparseVector v) -> SparseVector v Source # | |
type VecBuilder (SparseVector v) Source # | |
Defined in Downhill.Linear.Expr |
newtype DenseVector v Source #
When sparsity is not needed, we can use vector v
as a builder of itself.
DenseVector
takes care of that.
Instances
newtype DenseBuilder v Source #
DenseBuilder (Maybe v) |
Instances
AdditiveGroup v => Semigroup (DenseBuilder v) Source # | |
Defined in Downhill.Linear.Expr (<>) :: DenseBuilder v -> DenseBuilder v -> DenseBuilder v # sconcat :: NonEmpty (DenseBuilder v) -> DenseBuilder v # stimes :: Integral b => b -> DenseBuilder v -> DenseBuilder v # | |
AdditiveGroup v => Monoid (DenseBuilder v) Source # | |
Defined in Downhill.Linear.Expr mempty :: DenseBuilder v # mappend :: DenseBuilder v -> DenseBuilder v -> DenseBuilder v # mconcat :: [DenseBuilder v] -> DenseBuilder v # |
toDenseBuilder :: v -> DenseBuilder v Source #
Misc
maybeToMonoid :: Monoid m => Maybe m -> m Source #