TypedFlow.TF

This module provides direct access to the most commonly used TensorFlow functions. Higher-level functions are not defined here.

Variables, Parameters

Parameters

parameter' :: forall shape t. (KnownTyp t, KnownShape shape) => String -> T shape t -> Gen (T shape t)

Declare a parameter to optimize. The shape of parameter should not depend on dimensions which can change between runs, such as the batch size.

parameter :: forall p. KnownTensors p => String -> p -> Gen p

Create a parameter.

parameterDefault :: forall p. ParamWithDefault p => String -> Gen p

Create a parameter and initialize it with a suitable default for its type. Control the exact initializer using parameter.

class KnownTensors p => ParamWithDefault p where

Minimal complete definition

defaultInitializer

Methods

defaultInitializer :: p

Instances

(KnownNat numObjects, KnownBits NBits b, KnownNat embeddingSize) => ParamWithDefault (EmbeddingP numObjects embeddingSize b)

Methods

defaultInitializer :: EmbeddingP numObjects embeddingSize b

(KnownNat n, KnownNat m, KnownBits NBits b) => ParamWithDefault (DenseP b n m)

Methods

defaultInitializer :: DenseP b n m

(KnownNat n, KnownNat x, KnownBits NBits t) => ParamWithDefault (GRUP t n x)

Methods

defaultInitializer :: GRUP t n x

(KnownNat n, KnownNat x, KnownBits NBits t) => ParamWithDefault (LSTMP t n x)

Methods

defaultInitializer :: LSTMP t n x

(KnownNat outChannels, KnownNat inChannels, KnownShape filterSpatialShape, KnownBits NBits t) => ParamWithDefault (ConvP t outChannels inChannels filterSpatialShape)

Methods

defaultInitializer :: ConvP t outChannels inChannels filterSpatialShape

(KnownNat n, KnownNat k, KnownNat v, KnownBits NBits t) => ParamWithDefault (AdditiveScoringP k v n t)

Methods

defaultInitializer :: AdditiveScoringP k v n t

getParameters :: Gen UntypedExpression

Return a list of parameters.

Persistent variables

persistent :: forall shape t. (KnownTyp t, KnownShape shape) => Bool -> String -> T shape t -> Gen (T shape t)

Declare variable which persists between calls to session.run.

modifyPersistent :: T s t -> T s t -> T s t

Modify a mutable tensor. Attention: for the assignment to happen, the resulting tensor must be evaluated!

Placeholders and outputs

placeholder :: forall t s. (KnownShape s, KnownTyp t) => String -> Gen (T s t)

Placeholder (to fill)

peekAt :: String -> Tensor s t -> Gen ()

Name a tensor so that it is made available for session.run.

peekAtMany :: String -> HTV t xs -> Gen ()

Operations

Constants

zeros :: forall t shape. KnownShape shape => KnownTyp t => T shape t

Zeros

ones :: forall t shape. KnownShape shape => KnownTyp t => T shape t

Ones

constant :: forall s w. KnownShape s => KnownBits w => Float -> T s (Typ Float w)

Constant

indexwise unary operators

round :: forall s t. Tensor s (Typ Float t) -> Tensor s (Typ Float t)

sigmoid :: forall s t. Tensor s (Typ Float t) -> Tensor s (Typ Float t)

tanh :: forall s t. Tensor s (Typ Float t) -> Tensor s (Typ Float t)

log :: forall s t. Tensor s (Typ Float t) -> Tensor s (Typ Float t)

relu :: forall s t. Tensor s (Typ Float t) -> Tensor s (Typ Float t)

floor :: forall s t. Tensor s (Typ Float t) -> Tensor s (Typ Float t)

negate :: forall s t. T s t -> T s t

Indexwise binary operators

add :: forall s d t. Tensor (d ++ s) t -> Tensor d t -> Tensor (d ++ s) t

Add two tensors, broacasting along shape s

(+) :: forall d s t. Tensor (d ++ s) t -> Tensor d t -> Tensor (d ++ s) t infixl 6

Add two tensors, broacasting along shape s

(⊕) :: forall s t. Tensor s t -> Tensor s t -> Tensor s t infixl 6

Indexwise operator

(⊝) :: forall s t. Tensor s t -> Tensor s t -> Tensor s t infixl 6

Indexwise operator

(⊙) :: forall s t. Tensor s t -> Tensor s t -> Tensor s t infixl 7

Indexwise operator

(⊘) :: forall s t. Tensor s t -> Tensor s t -> Tensor s t infixl 7

Indexwise operator

equal :: Tensor d t -> Tensor d t -> Tensor d TFBool

Indexwise equality test.

Products

(∙) :: Tensor '[cols, rows] t -> Tensor '[cols, batchSize] t -> Tensor '[rows, batchSize] t infixl 7

Product of a matrix of weight with a (batched) vector .

· :: forall cols batchSize t. Tensor '[cols, batchSize] t -> Tensor '[cols, batchSize] t -> Tensor '[batchSize] t infixl 7

Dot product between two batched vectors.

matmul :: Tensor (o ': (n ': s)) t -> Tensor (m ': (o ': s)) t -> Tensor (m ': (n ': s)) t

Matrix multiplication (note that shape s is preserved)

Reducers

reduceMeanAll :: forall s t. Tensor s t -> Tensor '[] t

Mean value of the input tensor.

reduceSumAll :: forall s t. Tensor s t -> Tensor '[] t

Mean value of the input tensor.

reduceSum :: forall n s t. (KnownLen s, KnownPeano n) => T s t -> T (Take n s ++ Drop (Succ n) s) t

Sum along a given dimension

reduceMean :: forall n s t. (KnownLen s, KnownPeano n) => T s t -> T (Take n s ++ Drop (Succ n) s) t

Sum along a given dimension

argmax :: forall n u m s t. (KnownLen s, KnownPeano n, KnownBits u) => Tensor (Take n s ++ (m ': Drop n s)) t -> Tensor s (Typ Int u)

Argmax along dimension n

argmax0 :: forall u n s t. (KnownLen s, KnownBits u) => T (n ': s) t -> T s (Typ Int u)

Argmax along the first dimension

argmax1 :: forall u m n s t. (KnownLen s, KnownBits u) => T (m ': (n ': s)) t -> T (m ': s) (Typ Int u)

Argmax along the second dimension

softmax0 :: T (n ': s) (Typ Float w) -> T (n ': s) (Typ Float w)

Softmax along the first dimension

softmax1 :: forall n m s w. KnownLen s => T (m ': (n ': s)) (Typ Float w) -> T (m ': (n ': s)) (Typ Float w)

Softmax along the second dimension

Gradients

grad :: T s Float32 -> UntypedExpression -> UntypedExpression

Gradient of wrt. given parameters.

clipByGlobalNorm :: Float -> UntypedExpression -> UntypedExpression

Clip a gradient

clipByValue :: Float -> Float -> T s (Flt t) -> T s (Flt t)

Clip a tensor

Indexing

last0 :: forall n s t. KnownNat n => KnownLen s => T (n ': s) t -> Tensor s t

Access the last element in a tensor (in the 0th dimension)

nth0 :: forall n s t. KnownLen s => Integer -> T (n ': s) t -> Tensor s t

Access the nth element in a tensor (in the 0th dimension)

nth0' :: forall n m s t. KnownNat n => KnownLen s => n < m => T (m ': s) t -> Tensor s t

Access the nth element in a tensor (in the 0th dimension), with a static index

gather :: forall s n indexShape t. T (s ++ '[n]) t -> T indexShape Int32 -> T (s ++ indexShape) t

(gather x ix)[k] = x[ix[k]]. See https://www.tensorflow.org/api_docs/python/tf/gather

Split and concatenate

split0 :: forall n m batchShape t. (KnownNat n, KnownNat m, KnownLen batchShape) => Tensor ((n + m) ': batchShape) t -> Gen (Tensor (n ': batchShape) t, Tensor (m ': batchShape) t)

Split a tensor on the first dimension

slice :: forall n i j s t. KnownNat j => KnownNat i => (i < j, j <= At n s, KnownPeano n, KnownLen s) => Tensor s t -> Tensor (Take n s ++ ((j - i) ': Drop (Succ n) s)) t

Take a slice at dimension n from i to j.

slice1 :: forall i j m n s t. KnownNat j => KnownNat i => (i < j, j <= m, KnownLen s) => Tensor (n ': (m ': s)) t -> Tensor (n ': ((j - i) ': s)) t

stack0 :: forall s n t. KnownLen s => V n (T s t) -> Tensor (n ': s) t

Concatenate n tensors along the first dimension

unstack0 :: forall s n t. (KnownLen s, KnownNat n) => Tensor (n ': s) t -> Gen (V n (T s t))

Split a tensors into n tensors along the first dimension

stackN :: forall s n t. V n (T s t) -> Tensor (s ++ '[n]) t

Concatenate n tensors along the last dimension

stack1 :: forall s n m t. KnownLen s => V n (T (m ': s) t) -> Tensor (m ': (n ': s)) t

Concatenate n tensors along the first dimension

concatT :: forall n d1 d2 s t. (KnownPeano n, KnownLen s, (d1 + d2) ~ At n s) => T (Take n s ++ (d1 ': Drop (Succ n) s)) t -> T (Take n s ++ (d2 ': Drop (Succ n) s)) t -> T s t

Concatenate tensors on dimension n

concat0 :: forall ys d1 d2 t. KnownLen ys => T (d1 ': ys) t -> T (d2 ': ys) t -> T ((d1 + d2) ': ys) t

Concatenate tensors on the first dimension

concat1 :: forall n ys d1 d2 t. KnownLen ys => T (n ': (d1 ': ys)) t -> T (n ': (d2 ': ys)) t -> T (n ': ((d1 + d2) ': ys)) t

Concatenate tensors on the second dimension

Reshaping

expandDim :: forall n s t. (KnownLen s, KnownPeano n) => Tensor s t -> Tensor (Take n s ++ (1 ': Drop n s)) t

Add an extra dimension at axis (n) of size 1.

expandDim0 :: forall s t. KnownLen s => Tensor s t -> Tensor (1 ': s) t

Add an extra dimension at axis (0) of size 1.

squeeze0 :: forall s t. KnownLen s => Tensor (1 ': s) t -> Tensor s t

Remove the first dimension if its size is 1.

expandDim1 :: forall n s t. KnownShape s => Tensor (n ': s) t -> Tensor (n ': (1 ': s)) t

Add an extra dimension at axis (1) of size 1.

squeeze1 :: forall n s t. KnownLen s => Tensor (n ': (1 ': s)) t -> Tensor (n ': s) t

Remove the second dimension if its size is 1.

flatten2 :: forall m n s t. (KnownNat m, KnownNat n, KnownShape s) => Tensor (m ': (n ': s)) t -> Tensor ((m * n) ': s) t

Reshape a tensor so that the first two dimensions are collapsed

inflate2 :: forall m n s t. (KnownNat m, KnownNat n, KnownShape s) => Tensor ((m * n) ': s) t -> Tensor (m ': (n ': s)) t

Reshape a tensor so that the first dimension is expanded into two.

flattenN2 :: forall s m n t. (KnownNat m, KnownNat n, KnownShape s) => Tensor (s ++ '[m, n]) t -> Tensor (s ++ '[m * n]) t

Reshape a tensor so that the last two dimensions are collapsed

flatten3 :: forall m n o s t. (KnownNat m, KnownNat n, KnownNat o, KnownShape s) => Tensor (m ': (n ': (o ': s))) t -> Tensor (((m * n) * o) ': s) t

Reshape a tensor so that the first three dimensions are collapsed

inflate3 :: forall m n o s t. (KnownNat m, KnownNat n, KnownNat o, KnownShape s) => Tensor (((m * n) * o) ': s) t -> Tensor (m ': (n ': (o ': s))) t

Reshape a tensor so that the first dimension is expanded into three.

reshape :: forall s2 s1 t. KnownShape s2 => Product s1 ~ Product s2 => Tensor s1 t -> Tensor s2 t

flattenAll :: forall s t. KnownShape s => Tensor s t -> Tensor '[Product s] t

Flatten all the dimensions of the tensor

inflateAll :: forall s t. KnownShape s => Tensor '[Product s] t -> Tensor s t

Transposition

transpose :: forall s t. T (Reverse s) t -> T s t

Transposition. See the type for the permutation of dimensions.

transposeN :: forall s n t. KnownLen s => T (n ': s) t -> T (s ++ '[n]) t

Transposition. See the type for the permutation of dimensions.

transposeN' :: forall s n t. KnownLen s => T (s ++ '[n]) t -> T (n ': s) t

Transposition. See the type for the permutation of dimensions.

transpose01 :: forall s m n t. KnownLen s => T (m ': (n ': s)) t -> T (n ': (m ': s)) t

Transposition. See the type for the permutation of dimensions.

transposeN01 :: forall s m n t. T (s ++ '[m, n]) t -> T (s ++ '[n, m]) t

Transposition. See the type for the permutation of dimensions.

Sequences

reverseSequences :: forall bs n x t. KnownLen x => LastEqual bs x => T '[bs] Int32 -> T (n ': x) t -> T (n ': x) t

Reverse sequences. See https://www.tensorflow.org/api_docs/python/tf/reverse_sequence

sequenceMask :: forall maxlen bs. KnownNat maxlen => Tensor '[bs] Int32 -> Tensor '[maxlen, bs] TFBool

Generate a mask of given length for each sequence.

Misc

cast :: forall u s t. KnownTyp u => T s t -> T s u

Cast the element type.

convolution

Arguments

:: KnownLen filterSpatialShape

=> Length filterSpatialShape <= 3

=> (1 + Length filterSpatialShape) ~ Length s

=> T ('[inChannels] ++ s) t

input tensor (batched)

-> T ('[outputChannels, inChannels] ++ filterSpatialShape) t

filters

-> T ('[outputChannels] ++ s) t

Size-preserving convolution operation.

oneHot :: forall n numClasses s w t. KnownNat numClasses => KnownBits t => (KnownLen s, KnownPeano n) => Tensor s (Typ Int w) -> Tensor (Take n s ++ (numClasses ': Drop n s)) (Flt t)

One hot vector along axis n

oneHot0 :: forall numClasses w batchSize t. KnownNat numClasses => KnownBits t => Tensor '[batchSize] (Typ Int w) -> Tensor '[numClasses, batchSize] (Flt t)

One hot vector along axis 0

oneHot1 :: forall numClasses w batchSize m t. KnownNat numClasses => KnownBits t => Tensor '[m, batchSize] (Typ Int w) -> Tensor '[m, numClasses, batchSize] (Flt t)

One hot vector along axis 1

Testing conditions

if_ :: Scalar TFBool -> T s t -> T s t -> T s t

Selection of a tensor (note: this is a strict operation)

where_ :: T s TFBool -> T s t -> T s t -> T s t

(where_ c x y)[i] = if c[i] then x[i] else y[i]

Contrib

Mapping

mapT :: forall s t r u n. KnownTyp u => KnownLen r => KnownLen s => (T s t -> T r u) -> T (n ': s) t -> Gen (T (n ': r) u)

Map a function along the first dimension of a tensor

mapTN :: forall n s t r u. KnownTyp u => (T s t -> T r u) -> T (s ++ '[n]) t -> Gen (T (r ++ '[n]) u)

Map a function along the last dimension of a tensor

zipWithT :: forall s t s1 t1 s2 n t2. KnownNat n => (KnownLen s, KnownLen s2, KnownLen s1) => KnownTyp t2 => (T s t -> T s1 t1 -> T s2 t2) -> Tensor (n ': s) t -> Tensor (n ': s1) t1 -> Gen (Tensor (n ': s2) t2)

zipWithTN :: forall n s t s1 t1 s2 t2. KnownTyp t2 => (T s t -> T s1 t1 -> T s2 t2) -> Tensor (s ++ '[n]) t -> Tensor (s1 ++ '[n]) t1 -> Gen (Tensor (s2 ++ '[n]) t2)

Losses

sigmoidCrossEntropyWithLogits

Arguments

:: Tensor s (Flt w)

labels

-> Tensor s (Flt w)

logits

-> Tensor s (Flt w)

Computes sigmoid cross entropy given logits. Measures the probability error in discrete classification tasks in which each class is independent and not mutually exclusive. For instance, one could perform multilabel classification where a picture can contain both an elephant and a dog at the same time. See https://www.tensorflow.org/api_docs/python/tf/nn/sigmoid_cross_entropy_with_logits

softmaxCrossEntropyWithLogits

Arguments

:: Tensor '[numClasses, batchSize] Float32

labels

-> Tensor '[numClasses, batchSize] Float32

logits

-> Tensor '[batchSize] Float32

(dense) softmax cross entropy with logits.

sparseSoftmaxCrossEntropyWithLogits

Arguments

:: Tensor s Int32

desired labels

-> Tensor (numClasses ': s) (Flt t)

predictions

-> Tensor s (Flt t)

sparse softmax cross entropy with logits.

Initializers

truncatedNormal :: forall s w. KnownShape s => KnownBits w => Float -> T s (Typ Float w)

Generate a random tensor where each individual element is picked in a normal distribution with given standard deviation.

randomUniform :: forall s t. (KnownShape s, KnownTyp t) => Float -> Float -> T s t

Generate a random tensor where each individual element is picked in a uniform distribution with given bounds.

randomOrthogonal :: forall n s t. (KnownBits t, KnownNat n, KnownShape s) => T (n ': s) (Typ Float t)

Generate an orthorgonal matrix. If the output has more dimensions than 2 the matrix is reshaped.

varianceScaling :: forall inDim outDim t. KnownNat inDim => (KnownNat outDim, KnownBits t) => Float -> VarianceScaleMode -> Distrib -> Tensor '[inDim, outDim] (Typ Float t)

Random tensor with variance scaling according to deeplearning lore.

glorotUniform :: forall inDim outDim t. KnownNat inDim => (KnownNat outDim, KnownBits t) => Tensor '[inDim, outDim] (Typ Float t)

Heterogeneous vectors

repeatT :: forall ss t. All KnownShape ss => KnownLen ss => (forall s. KnownShape s => T s t) -> HTV t ss

Repeat a flexible-shape constant vector to form a heterogeneous tensor vector.

flattenHTV :: KnownTyp t => All KnownShape xs => HTV t xs -> Tensor '[Sum (Ap (FMap CProduct) xs)] t

inflateHTV :: forall xs s t. (All KnownShape xs, KnownLen s, KnownLen xs) => Tensor '[Sum (Ap (FMap CProduct) xs)] t -> Gen (HTV t xs)

class KnownTensors p where

Minimal complete definition

travTensor

Methods

travTensor :: (forall s t. (KnownTyp t, KnownShape s) => String -> T s t -> Gen (T s t)) -> String -> p -> Gen p

traverse all the tensors over tuples of tensors

Instances

(KnownTensors p, KnownTensors q) => KnownTensors (p, q)

Methods

travTensor :: (forall s t. (KnownTyp Typ t, KnownShape s) => String -> T s t -> Gen (T s t)) -> String -> (p, q) -> Gen (p, q)

(KnownTyp Typ t, KnownShape shape) => KnownTensors (T shape t)

Methods

travTensor :: (forall s a. (KnownTyp Typ a, KnownShape s) => String -> T s a -> Gen (T s a)) -> String -> T shape t -> Gen (T shape t)

(KnownTyp Typ t, All [Nat] KnownShape ys) => KnownTensors (HTV t ys)

Methods

travTensor :: (forall s a. (KnownTyp Typ a, KnownShape s) => String -> T s a -> Gen (T s a)) -> String -> HTV t ys -> Gen (HTV t ys)

(KnownTensors p1, KnownTensors p2, KnownTensors p3) => KnownTensors (p1, p2, p3)

Methods

travTensor :: (forall s t. (KnownTyp Typ t, KnownShape s) => String -> T s t -> Gen (T s t)) -> String -> (p1, p2, p3) -> Gen (p1, p2, p3)

(KnownNat numObjects, KnownBits NBits b, KnownNat embeddingSize) => KnownTensors (EmbeddingP numObjects embeddingSize b)

Methods

travTensor :: (forall s t. (KnownTyp Typ t, KnownShape s) => String -> T s t -> Gen (T s t)) -> String -> EmbeddingP numObjects embeddingSize b -> Gen (EmbeddingP numObjects embeddingSize b)

(KnownNat a, KnownNat b, KnownBits NBits t) => KnownTensors (DenseP t a b)

Methods

travTensor :: (forall s c. (KnownTyp Typ c, KnownShape s) => String -> T s c -> Gen (T s c)) -> String -> DenseP t a b -> Gen (DenseP t a b)

(KnownNat n, KnownNat x, KnownBits NBits t) => KnownTensors (GRUP t n x)

Methods

travTensor :: (forall s a. (KnownTyp Typ a, KnownShape s) => String -> T s a -> Gen (T s a)) -> String -> GRUP t n x -> Gen (GRUP t n x)

(KnownNat n, KnownNat x, KnownBits NBits t) => KnownTensors (LSTMP t n x)

Methods

travTensor :: (forall s a. (KnownTyp Typ a, KnownShape s) => String -> T s a -> Gen (T s a)) -> String -> LSTMP t n x -> Gen (LSTMP t n x)

(KnownTensors p1, KnownTensors p2, KnownTensors p3, KnownTensors p4) => KnownTensors (p1, p2, p3, p4)

Methods

travTensor :: (forall s t. (KnownTyp Typ t, KnownShape s) => String -> T s t -> Gen (T s t)) -> String -> (p1, p2, p3, p4) -> Gen (p1, p2, p3, p4)

(KnownNat outChannels, KnownNat inChannels, KnownShape filterSpatialShape, KnownBits NBits t) => KnownTensors (ConvP t outChannels inChannels filterSpatialShape)

Methods

travTensor :: (forall s a. (KnownTyp Typ a, KnownShape s) => String -> T s a -> Gen (T s a)) -> String -> ConvP t outChannels inChannels filterSpatialShape -> Gen (ConvP t outChannels inChannels filterSpatialShape)

(KnownNat n, KnownNat k, KnownNat v, KnownBits NBits t) => KnownTensors (AdditiveScoringP k v n t)

Methods

travTensor :: (forall s a. (KnownTyp Typ a, KnownShape s) => String -> T s a -> Gen (T s a)) -> String -> AdditiveScoringP k v n t -> Gen (AdditiveScoringP k v n t)

class LastEqual x xs

Instances

LastEqual [a] k x ((:) a y2 xs) => LastEqual [a] k x ((:) a y ((:) a y2 xs))

LastEqual [a] a x ((:) a x ([] a))