Numeric.Neural.Normalization

This modules provides utilities for data normalization.

Documentation

encode1ofN :: (Enum a, Num b, KnownNat n) => a -> Vector n b

Provides "1 of n" encoding for enumerable types.

>>> :set -XDataKinds
>>> encode1ofN LT :: Vector 3 Int
[1,0,0]

>>> encode1ofN EQ :: Vector 3 Int
[0,1,0]

>>> encode1ofN GT :: Vector 3 Int
[0,0,1]

decode1ofN :: (Enum a, Num b, Ord b, Foldable f) => f b -> a

Provides "1 of n" decoding for enumerable types.

>>> decode1ofN [0.9, 0.3, 0.1 :: Double] :: Ordering
LT

>>> decode1ofN [0.7, 0.8, 0.6 :: Double] :: Ordering
EQ

>>> decode1ofN [0.2, 0.3, 0.8 :: Double] :: Ordering
GT

encodeEquiDist :: forall a b n. (Enum a, Floating b, KnownNat n) => a -> Vector n b

Provides equidistant encoding for enumerable types.

>>> :set -XDataKinds
>>> encodeEquiDist LT :: Vector 2 Float
[1.0,0.0]

>>> encodeEquiDist EQ :: Vector 2 Float
[-0.5,-0.86602545]

>>> encodeEquiDist GT :: Vector 2 Float
[-0.5,0.86602545]

decodeEquiDist :: forall a b n. (Enum a, Ord b, Floating b, KnownNat n) => Vector n b -> a

Provides equidistant decoding for enumerable types.

>>> :set -XDataKinds
>>> let u = fromJust (fromList [0.9, 0.2]) :: Vector 2 Double
>>> decodeEquiDist u :: Ordering
LT

>>> :set -XDataKinds
>>> let v = fromJust (fromList [-0.4, -0.5]) :: Vector 2 Double
>>> decodeEquiDist v :: Ordering
EQ

>>> :set -XDataKinds
>>> let w = fromJust (fromList [0.1, 0.8]) :: Vector 2 Double
>>> decodeEquiDist w :: Ordering
GT

crossEntropyError :: (Enum a, Floating b, KnownNat n) => a -> Vector n b -> b

Computes the cross entropy error (assuming "1 of n" encoding).

>>> crossEntropyError LT (cons 0.8 (cons 0.1 (cons 0.1 nil))) :: Float
0.22314353

>>> crossEntropyError EQ (cons 0.8 (cons 0.1 (cons 0.1 nil))) :: Float
2.3025851 

white :: (Applicative f, Traversable t, Eq a, Floating a) => t (f a) -> f a -> f a

Function white takes a batch of values (of a specific shape) and computes a normalization function which whitens values of that shape, so that each component has zero mean and unit variance.

>>> :set -XDataKinds
>>> let xss = [cons 1 (cons 1 nil), cons 1 (cons 2 nil), cons 1 (cons 3 nil)] :: [Vector 2 Float]
>>> let f   = white xss
>>> f <$> xss
[[0.0,-1.224745],[0.0,0.0],[0.0,1.224745]]

whiten

Arguments

:: (Applicative f, Traversable t)

=> Model f g a b c

original model

-> t b

batch of input data

-> Model f g a b c

Modifies a Model by whitening the input before feeding it into the embedded component.