TypedFlow.Layers.RNN

Contents

• Types
• Combinators
• RNN Cells
• RNN unfolding functions
• Attention mechanisms
  • Scoring functions
  • Attention functions
  • Attention combinators

Description

Synopsis

• type RnnCell t states input output = (HTV (Flt t) states, input) -> Gen (HTV (Flt t) states, output)
• type RnnLayer b n state input t output u = HTV (Flt b) state -> Tensor (n ': input) t -> Gen (HTV (Flt b) state, Tensor (n ': output) u)
• stackRnnCells :: forall s0 s1 a b c t. KnownLen s0 => RnnCell t s0 a b -> RnnCell t s1 b c -> RnnCell t (s0 ++ s1) a c
• (.-.) :: forall s0 s1 a b c t. KnownLen s0 => RnnCell t s0 a b -> RnnCell t s1 b c -> RnnCell t (s0 ++ s1) a c
• stackRnnLayers :: forall s1 s2 a t b u c v n bits. KnownLen s1 => RnnLayer bits n s1 a t b u -> RnnLayer bits n s2 b u c v -> RnnLayer bits n (s1 ++ s2) a t c v
• (.--.) :: forall s1 s2 a t b u c v n bits. KnownLen s1 => RnnLayer bits n s1 a t b u -> RnnLayer bits n s2 b u c v -> RnnLayer bits n (s1 ++ s2) a t c v
• bothRnnLayers :: forall s1 s2 a t b u c n bs bits. KnownLen s1 => RnnLayer bits n s1 a t '[b, bs] u -> RnnLayer bits n s2 a t '[c, bs] u -> RnnLayer bits n (s1 ++ s2) a t '[b + c, bs] u
• (.++.) :: forall s1 s2 a t b u c n bs bits. KnownLen s1 => RnnLayer bits n s1 a t '[b, bs] u -> RnnLayer bits n s2 a t '[c, bs] u -> RnnLayer bits n (s1 ++ s2) a t '[b + c, bs] u
• withBypass :: RnnCell b s0 (T '[x, bs] t) (T '[y, bs] t) -> RnnCell b s0 (T '[x, bs] t) (T '[x + y, bs] t)
• onStates :: (HTV (Flt t) xs -> HTV (Flt t) xs) -> RnnCell t xs a b -> RnnCell t xs a b
• timeDistribute :: (a -> b) -> RnnCell t '[] a b
• timeDistribute' :: (a -> Gen b) -> RnnCell t '[] a b
• cellInitializerBit :: forall n x t. (KnownNat n, KnownNat x, KnownBits t) => DenseP t (n + x) n
• data LSTMP t n x = LSTMP (DenseP t (n + x) n) (DenseP t (n + x) n) (DenseP t (n + x) n) (DenseP t (n + x) n)
• lstm :: forall n x bs t. LSTMP t n x -> RnnCell t '['[n, bs], '[n, bs]] (Tensor '[x, bs] (Flt t)) (Tensor '[n, bs] (Flt t))
• data GRUP t n x = GRUP (T '[n + x, n] (Typ Float t)) (T '[n + x, n] (Typ Float t)) (T '[n + x, n] (Typ Float t))
• gru :: forall n x bs t. (KnownNat bs, KnownNat n, KnownBits t) => GRUP t n x -> RnnCell t '['[n, bs]] (Tensor '[x, bs] (Flt t)) (Tensor '[n, bs] (Flt t))
• rnn :: forall n state input output t u b. (KnownNat n, KnownShape input, KnownShape output) => RnnCell b state (T input t) (T output u) -> RnnLayer b n state input t output u
• rnnBackward :: forall n state input output t u b. (KnownNat n, KnownShape input, KnownShape output) => RnnCell b state (T input t) (T output u) -> RnnLayer b n state input t output u
• rnnBackwardsWithCull :: forall n bs x y t u ls b. KnownLen ls => KnownNat n => KnownLen x => KnownLen y => All KnownLen ls => All (LastEqual bs) ls => LastEqual bs x => LastEqual bs y => T '[bs] Int32 -> RnnCell b ls (T x t) (T y u) -> RnnLayer b n ls x t y u
• rnnWithCull :: forall n bs x y t u ls b. KnownLen ls => KnownNat n => KnownLen x => KnownLen y => All KnownLen ls => All (LastEqual bs) ls => T '[bs] Int32 -> RnnCell b ls (T x t) (T y u) -> RnnLayer b n ls x t y u
• type AttentionScoring t batchSize keySize valueSize nValues = Tensor '[keySize, batchSize] (Typ Float t) -> Tensor '[nValues, valueSize, batchSize] (Typ Float t) -> Tensor '[nValues, batchSize] (Typ Float t)
• multiplicativeScoring :: forall valueSize keySize batchSize nValues t. KnownNat batchSize => T '[keySize, valueSize] (Typ Float t) -> AttentionScoring t batchSize keySize valueSize nValues
• data AdditiveScoringP sz keySize valueSize t = AdditiveScoringP (Tensor '[sz, 1] (Typ Float t)) (Tensor '[keySize, sz] (Typ Float t)) (Tensor '[valueSize, sz] (Typ Float t))
• additiveScoring :: forall sz keySize valueSize t nValues batchSize. KnownNat sz => KnownNat keySize => (KnownNat nValues, KnownNat batchSize) => AdditiveScoringP sz keySize valueSize t -> AttentionScoring t batchSize valueSize keySize nValues
• type AttentionFunction t batchSize keySize valueSize = T '[keySize, batchSize] (Flt t) -> Gen (T '[valueSize, batchSize] (Flt t))
• uniformAttn :: forall valueSize m keySize batchSize t. KnownNat m => KnownBits t => AttentionScoring t batchSize keySize valueSize m -> T '[batchSize] Int32 -> T '[m, valueSize, batchSize] (Flt t) -> AttentionFunction t batchSize keySize valueSize
• luongAttention :: forall attnSize d m e batchSize w. KnownNat m => KnownBits w => Tensor '[d + e, attnSize] (Flt w) -> AttentionScoring w batchSize e d m -> Tensor '[batchSize] Int32 -> T '[m, d, batchSize] (Flt w) -> AttentionFunction w batchSize e attnSize
• attentiveWithFeedback :: forall attSize cellSize inputSize bs w ss. AttentionFunction w bs cellSize attSize -> RnnCell w ss (T '[inputSize + attSize, bs] (Flt w)) (T '[cellSize, bs] (Flt w)) -> RnnCell w ('[attSize, bs] ': ss) (T '[inputSize, bs] (Flt w)) (T '[attSize, bs] (Flt w))

Types

Combinators

RNN Cells

RNN unfolding functions

Attention mechanisms

Scoring functions

Attention functions

Attention combinators