tensorflow-ops-0.1.0.0: Friendly layer around TensorFlow bindings.

Safe HaskellNone
LanguageHaskell2010

TensorFlow.Ops

Description

This module contains definitions for some built-in TensorFlow operations.

Note that certain, "stateful" ops like variable and assign return a Build action (e.g., Build (Tensor Ref a) instead of a pure value; the returned Tensors are always rendered in the current Build context. This approach helps us avoid problems with inlining or common subexpression elimination, by writing

do
    v <- variable []
    w <- assign v 3
    render $ w * w

instead of

let
   v = variable []
   w = assign v 3
in w * w

since the latter could be reasonably transformed by the compiler into (or vice versa)

let
   v = variable []
   w = assign v 3
   w' = assign v 3
in w * w'

Ops should return a Build action if their original OpDef marks them as stateful, or if they take any Refs as input. (This mirrors the rules that TensorFlow uses to avoid common subexpression elimination.)

Synopsis

Documentation

add

Arguments

:: (TensorType t, OneOf ((:) * (Complex Double) ((:) * (Complex Float) ((:) * ByteString ((:) * Int16 ((:) * Int32 ((:) * Int64 ((:) * Int8 ((:) * Word16 ((:) * Word8 ((:) * Double ((:) * Float ([] *)))))))))))) t) 
=> Tensor v1 t

x

-> Tensor v2 t

y

-> Tensor Value t

z

Returns x + y element-wise.

  • NOTE*: Add supports broadcasting. AddN does not. More about broadcasting here

abs

Arguments

:: (TensorType t, OneOf ((:) * Int32 ((:) * Int64 ((:) * Word16 ((:) * Double ((:) * Float ([] *)))))) t) 
=> Tensor v1 t

x

-> Tensor Value t

y

Computes the absolute value of a tensor.

Given a tensor x, this operation returns a tensor containing the absolute value of each element in x. For example, if x is an input element and y is an output element, this operation computes \(y = |x|\).

addN

Arguments

:: (TensorType t, OneOf ((:) * (Complex Double) ((:) * (Complex Float) ((:) * Int16 ((:) * Int32 ((:) * Int64 ((:) * Int8 ((:) * Word16 ((:) * Word8 ((:) * Double ((:) * Float ([] *))))))))))) t) 
=> [Tensor v1 t]

inputs: Must all be the same size and shape.

-> Tensor Value t

sum

Add all input tensors element wise.

argMax

Arguments

:: (TensorType t, OneOf ((:) * (Complex Double) ((:) * (Complex Float) ((:) * Int16 ((:) * Int32 ((:) * Int64 ((:) * Int8 ((:) * Word16 ((:) * Word8 ((:) * Double ((:) * Float ([] *))))))))))) t, TensorType tidx, OneOf ((:) * Int32 ((:) * Int64 ([] *))) tidx) 
=> Tensor v1 t

input

-> Tensor v2 tidx

dimension: int32, 0 <= dimension < rank(input). Describes which dimension of the input Tensor to reduce across. For vectors, use dimension = 0.

-> Tensor Value Int64

output

Returns the index with the largest value across dimensions of a tensor.

assign :: forall a v. TensorType a => Tensor Ref a -> Tensor v a -> Build (Tensor Ref a)

broadcastGradientArgs

Arguments

:: (TensorType t, OneOf ((:) * Int32 ((:) * Int64 ([] *))) t) 
=> Tensor v1 t

s0

-> Tensor v2 t

s1

-> (Tensor Value t, Tensor Value t)

(r0, r1)

  • r0
  • r1

Return the reduction indices for computing gradients of s0 op s1 with broadcast.

This is typically used by gradient computations for a broadcasting operation.

cast

Arguments

:: (TensorType dstT, TensorType srcT) 
=> Tensor v1 srcT

x

-> Tensor Value dstT

y

Cast x of type SrcT to y of DstT.

concat

Arguments

:: TensorType t 
=> Tensor v1 Int32

concat_dim: 0-D. The dimension along which to concatenate. Must be in the range [0, rank(values)).

-> [Tensor v2 t]

values: The N Tensors to concatenate. Their ranks and types must match, and their sizes must match in all dimensions except concat_dim.

-> Tensor Value t

output: A Tensor with the concatenation of values stacked along the concat_dim dimension. This tensor's shape matches that of values except in concat_dim where it has the sum of the sizes.

Concatenates tensors along one dimension.

constant :: forall a. TensorType a => Shape -> [a] -> Tensor Value a

Create a constant tensor.

The values should be in row major order, e.g.,

element 0: index (0, ..., 0) element 1: index (0, ..., 1) ...

equal

Arguments

:: (TensorType t, OneOf ((:) * (Complex Double) ((:) * (Complex Float) ((:) * Bool ((:) * ByteString ((:) * Int16 ((:) * Int32 ((:) * Int64 ((:) * Int8 ((:) * Word16 ((:) * Word8 ((:) * Double ((:) * Float ([] *))))))))))))) t) 
=> Tensor v1 t

x

-> Tensor v2 t

y

-> Tensor Value Bool

z

Returns the truth value of (x == y) element-wise.

  • NOTE*: Equal supports broadcasting. More about broadcasting here

initializedVariable :: forall a. TensorType a => Tensor Value a -> Build (Tensor Ref a)

Creates a variable initialized to the given value. Initialization happens next time session runs.

zeroInitializedVariable :: (TensorType a, Num a) => Shape -> Build (Tensor Ref a)

Creates a zero-initialized variable with the given shape.

fill

Arguments

:: TensorType t 
=> Tensor v1 Int32

dims: 1-D. Represents the shape of the output tensor.

-> Tensor v2 t

value: 0-D (scalar). Value to fill the returned tensor.

-> Tensor Value t

output

Creates a tensor filled with a scalar value.

This operation creates a tensor of shape dims and fills it with value.

For example:

```prettyprint # Output tensor has shape [2, 3]. fill([2, 3], 9) ==> [[9, 9, 9] [9, 9, 9]] ```

oneHot

Arguments

:: (TensorType t, TensorType tI, OneOf ((:) * Int32 ((:) * Int64 ((:) * Word8 ([] *)))) tI) 
=> Tensor v1 tI

indices: A tensor of indices.

-> Tensor v2 Int32

depth: A scalar defining the depth of the one hot dimension.

-> Tensor v3 t

on_value: A scalar defining the value to fill in output when `indices[j] = i`.

-> Tensor v4 t

off_value: A scalar defining the value to fill in output when `indices[j] != i`.

-> Tensor Value t

output: The one-hot tensor.

Returns a one-hot tensor.

The locations represented by indices in indices take value on_value, while all other locations take value off_value.

If the input indices is rank N, the output will have rank `N+1`, The new axis is created at dimension axis (default: the new axis is appended at the end).

If indices is a scalar the output shape will be a vector of length depth.

If indices is a vector of length features, the output shape will be: ``` features x depth if axis == -1 depth x features if axis == 0 ```

If indices is a matrix (batch) with shape `[batch, features]`, the output shape will be: ``` batch x features x depth if axis == -1 batch x depth x features if axis == 1 depth x batch x features if axis == 0 ```

Examples =========

Suppose that

``` indices = [0, 2, -1, 1] depth = 3 on_value = 5.0 off_value = 0.0 axis = -1 ```

Then output is `[4 x 3]`:

```output = [5.0 0.0 0.0] // one_hot(0) [0.0 0.0 5.0] // one_hot(2) [0.0 0.0 0.0] // one_hot(-1) [0.0 5.0 0.0] // one_hot(1) ```

Suppose that

``` indices = [0, 2, -1, 1] depth = 3 on_value = 0.0 off_value = 3.0 axis = 0 ```

Then output is `[3 x 4]`:

```output = [0.0 3.0 3.0 3.0] [3.0 3.0 3.0 0.0] [3.0 3.0 3.0 3.0] [3.0 0.0 3.0 3.0] // ^ one_hot(0) // ^ one_hot(2) // ^ one_hot(-1) // ^ one_hot(1) ``` Suppose that

``` indices = [[0, 2], [1, -1]] depth = 3 on_value = 1.0 off_value = 0.0 axis = -1 ```

Then output is `[2 x 2 x 3]`:

```output = [ [1.0, 0.0, 0.0] // one_hot(0) [0.0, 0.0, 1.0] // one_hot(2) ][ [0.0, 1.0, 0.0] // one_hot(1) [0.0, 0.0, 0.0] // one_hot(-1) ]```

matMul

Arguments

:: (TensorType t, OneOf ((:) * (Complex Double) ((:) * (Complex Float) ((:) * Int32 ((:) * Word16 ((:) * Double ((:) * Float ([] *))))))) t) 
=> Tensor v1 t

a

-> Tensor v2 t

b

-> Tensor Value t

product

Multiply the matrix "a" by the matrix "b".

The inputs must be two-dimensional matrices and the inner dimension of "a" (after being transposed if transpose_a is true) must match the outer dimension of "b" (after being transposed if transposed_b is true).

  • Note*: The default kernel implementation for MatMul on GPUs uses cublas.

matTranspose :: forall a v. TensorType a => Tensor v a -> Tensor Value a

mean

Arguments

:: (TensorType t, OneOf ((:) * (Complex Double) ((:) * (Complex Float) ((:) * Int16 ((:) * Int32 ((:) * Int64 ((:) * Int8 ((:) * Word16 ((:) * Word8 ((:) * Double ((:) * Float ([] *))))))))))) t, TensorType tidx, OneOf ((:) * Int32 ((:) * Int64 ([] *))) tidx) 
=> Tensor v1 t

input: The tensor to reduce.

-> Tensor v2 tidx

reduction_indices: The dimensions to reduce.

-> Tensor Value t

output: The reduced tensor.

Computes the mean of elements across dimensions of a tensor.

Reduces input along the dimensions given in reduction_indices. Unless keep_dims is true, the rank of the tensor is reduced by 1 for each entry in reduction_indices. If keep_dims is true, the reduced dimensions are retained with length 1.

mul

Arguments

:: (TensorType t, OneOf ((:) * (Complex Double) ((:) * (Complex Float) ((:) * Int16 ((:) * Int32 ((:) * Int64 ((:) * Int8 ((:) * Word16 ((:) * Word8 ((:) * Double ((:) * Float ([] *))))))))))) t) 
=> Tensor v1 t

x

-> Tensor v2 t

y

-> Tensor Value t

z

Returns x * y element-wise.

  • NOTE*: Mul supports broadcasting. More about broadcasting here

neg

Arguments

:: (TensorType t, OneOf ((:) * (Complex Double) ((:) * (Complex Float) ((:) * Int32 ((:) * Int64 ((:) * Word16 ((:) * Double ((:) * Float ([] *)))))))) t) 
=> Tensor v1 t

x

-> Tensor Value t

y

Computes numerical negative value element-wise.

I.e., \(y = -x\).

pack

Arguments

:: TensorType t 
=> [Tensor v1 t]

values: Must be of same shape and type.

-> Tensor Value t

output: The packed tensor.

Packs a list of N rank-R tensors into one rank-`(R+1)` tensor.

Packs the N tensors in values into a tensor with rank one higher than each tensor in values, by packing them along the axis dimension. Given a list of tensors of shape `(A, B, C)`;

if `axis == 0` then the output tensor will have the shape `(N, A, B, C)`. if `axis == 1` then the output tensor will have the shape `(A, N, B, C)`. Etc.

For example:

```prettyprint # x is [1, 4] # y is [2, 5] # z is [3, 6] pack([x, y, z]) => [[1, 4], [2, 5], [3, 6]] # Pack along first dim. pack([x, y, z], axis=1) => [[1, 2, 3], [4, 5, 6]] ```

This is the opposite of unpack.

placeholder :: forall a. TensorType a => Shape -> Build (Tensor Value a)

range

Arguments

:: (TensorType tidx, OneOf ((:) * Int32 ((:) * Int64 ([] *))) tidx) 
=> Tensor v1 tidx

start: 0-D (scalar). First entry in the sequence.

-> Tensor v2 tidx

limit: 0-D (scalar). Upper limit of sequence, exclusive.

-> Tensor v3 tidx

delta: 0-D (scalar). Optional. Default is 1. Number that increments start.

-> Tensor Value tidx

output: 1-D.

Creates a sequence of integers.

This operation creates a sequence of integers that begins at start and extends by increments of delta up to but not including limit.

For example:

``` # start is 3 # limit is 18 # delta is 3 tf.range(start, limit, delta) ==> [3, 6, 9, 12, 15] ```

reducedShape :: (OneOf `[Int32, Int64]` t1, OneOf `[Int32, Int64]` t2) => Tensor v1 t1 -> Tensor v2 t2 -> Tensor Value Int32

Helper function for reduction ops (translation of math_ops.reduced_shape).

relu

Arguments

:: (TensorType t, OneOf ((:) * Int16 ((:) * Int32 ((:) * Int64 ((:) * Int8 ((:) * Word16 ((:) * Word8 ((:) * Double ((:) * Float ([] *))))))))) t) 
=> Tensor v1 t

features

-> Tensor Value t

activations

Computes rectified linear: `max(features, 0)`.

reluGrad

Arguments

:: (TensorType t, OneOf ((:) * Int16 ((:) * Int32 ((:) * Int64 ((:) * Int8 ((:) * Word16 ((:) * Word8 ((:) * Double ((:) * Float ([] *))))))))) t) 
=> Tensor v1 t

gradients: The backpropagated gradients to the corresponding Relu operation.

-> Tensor v2 t

features: The features passed as input to the corresponding Relu operation, OR the outputs of that operation (both work equivalently).

-> Tensor Value t

backprops: `gradients * (features > 0)`.

Computes rectified linear gradients for a Relu operation.

reshape

Arguments

:: (TensorType t, TensorType tshape, OneOf ((:) * Int32 ((:) * Int64 ([] *))) tshape) 
=> Tensor v1 t

tensor

-> Tensor v2 tshape

shape: Defines the shape of the output tensor.

-> Tensor Value t

output

Reshapes a tensor.

Given tensor, this operation returns a tensor that has the same values as tensor with shape shape.

If one component of shape is the special value -1, the size of that dimension is computed so that the total size remains constant. In particular, a shape of `[-1]` flattens into 1-D. At most one component of shape can be -1.

If shape is 1-D or higher, then the operation returns a tensor with shape shape filled with the values of tensor. In this case, the number of elements implied by shape must be the same as the number of elements in tensor.

For example:

```prettyprint # tensor t is [1, 2, 3, 4, 5, 6, 7, 8, 9] # tensor t has shape [9] reshape(t, [3, 3]) ==> [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# tensor t is [[[1, 1], [2, 2]], # [[3, 3], [4, 4]]] # tensor t has shape [2, 2, 2] reshape(t, [2, 4]) ==> [[1, 1, 2, 2], [3, 3, 4, 4]]

# tensor t is [[[1, 1, 1], # [2, 2, 2]], # [[3, 3, 3], # [4, 4, 4]], # [[5, 5, 5], # [6, 6, 6]]] # tensor t has shape [3, 2, 3] # pass '[-1]' to flatten t reshape(t, [-1]) ==> [1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6]

# -1 can also be used to infer the shape

# -1 is inferred to be 9: reshape(t, [2, -1]) ==> [[1, 1, 1, 2, 2, 2, 3, 3, 3], [4, 4, 4, 5, 5, 5, 6, 6, 6]] # -1 is inferred to be 2: reshape(t, [-1, 9]) ==> [[1, 1, 1, 2, 2, 2, 3, 3, 3], [4, 4, 4, 5, 5, 5, 6, 6, 6]] # -1 is inferred to be 3: reshape(t, [ 2, -1, 3]) ==> [[[1, 1, 1], [2, 2, 2], [3, 3, 3]], [[4, 4, 4], [5, 5, 5], [6, 6, 6]]]

# tensor t is [7] # shape `[]` reshapes to a scalar reshape(t, []) ==> 7 ```

restore

Arguments

:: TensorType a 
=> ByteString

File path.

-> Tensor Ref a

Tensor to restore.

-> Build ControlNode 

Restore a tensor's value from a checkpoint file.

restoreFromName

Arguments

:: TensorType a 
=> ByteString

File path.

-> ByteString

Tensor name override.

-> Tensor Ref a

Tensor to restore.

-> Build ControlNode 

Restore a tensor's value from a checkpoint file.

This version allows restoring from a checkpoint file that uses a different tensor name than the variable.

save

Arguments

:: TensorType a 
=> ByteString

File path.

-> [Tensor v a]

Tensors to save.

-> Build ControlNode 

scalar :: forall a. TensorType a => a -> Tensor Value a

Create a constant scalar.

sign

Arguments

:: (TensorType t, OneOf ((:) * (Complex Double) ((:) * (Complex Float) ((:) * Int32 ((:) * Int64 ((:) * Word16 ((:) * Double ((:) * Float ([] *)))))))) t) 
=> Tensor v1 t

x

-> Tensor Value t

y

Returns an element-wise indication of the sign of a number.

`y = sign(x) = -1` if `x 0 if `x == 0`; 1 if `x 0`.

For complex numbers, `y = sign(x) = x / |x|` if `x != 0`, otherwise `y = 0`.

size

Arguments

:: (TensorType t, TensorType out_type, OneOf ((:) * Int32 ((:) * Int64 ([] *))) out_type) 
=> Tensor v1 t

input

-> Tensor Value out_type

output

Returns the size of a tensor.

This operation returns an integer representing the number of elements in input.

For example:

```prettyprint # t is [[[1, 1,, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]] size(t) ==> 12 ```

softmax

Arguments

:: (TensorType t, OneOf ((:) * Word16 ((:) * Double ((:) * Float ([] *)))) t) 
=> Tensor v1 t

logits: 2-D with shape `[batch_size, num_classes]`.

-> Tensor Value t

softmax: Same shape as logits.

Computes softmax activations.

For each batch i and class j we have

softmax[i, j] = exp(logits[i, j]) / sum_j(exp(logits[i, j]))

softmaxCrossEntropyWithLogits

Arguments

:: (TensorType t, OneOf ((:) * Word16 ((:) * Double ((:) * Float ([] *)))) t) 
=> Tensor v1 t

features: batch_size x num_classes matrix

-> Tensor v2 t

labels: batch_size x num_classes matrix The caller must ensure that each batch of labels represents a valid probability distribution.

-> (Tensor Value t, Tensor Value t)

(loss, backprop)

  • loss: Per example loss (batch_size vector).
  • backprop: backpropagated gradients (batch_size x num_classes matrix).

Computes softmax cross entropy cost and gradients to backpropagate.

Inputs are the logits, not probabilities.

sparseToDense

Arguments

:: (TensorType t, TensorType tindices, OneOf ((:) * Int32 ((:) * Int64 ([] *))) tindices) 
=> Tensor v1 tindices

sparse_indices: 0-D, 1-D, or 2-D. `sparse_indices[i]` contains the complete index where `sparse_values[i]` will be placed.

-> Tensor v2 tindices

output_shape: 1-D. Shape of the dense output tensor.

-> Tensor v3 t

sparse_values: 1-D. Values corresponding to each row of sparse_indices, or a scalar value to be used for all sparse indices.

-> Tensor v4 t

default_value: Scalar value to set for indices not specified in sparse_indices.

-> Tensor Value t

dense: Dense output tensor of shape output_shape.

Converts a sparse representation into a dense tensor.

Builds an array dense with shape output_shape such that

```prettyprint # If sparse_indices is scalar dense[i] = (i == sparse_indices ? sparse_values : default_value)

# If sparse_indices is a vector, then for each i dense[sparse_indices[i]] = sparse_values[i]

# If sparse_indices is an n by d matrix, then for each i in [0, n) dense[sparse_indices[i][0], ..., sparse_indices[i][d-1]] = sparse_values[i] ```

All other values in dense are set to default_value. If sparse_values is a scalar, all sparse indices are set to this single value.

Indices should be sorted in lexicographic order, and indices must not contain any repeats. If validate_indices is true, these properties are checked during execution.

sub

Arguments

:: (TensorType t, OneOf ((:) * (Complex Double) ((:) * (Complex Float) ((:) * Int32 ((:) * Int64 ((:) * Word16 ((:) * Double ((:) * Float ([] *)))))))) t) 
=> Tensor v1 t

x

-> Tensor v2 t

y

-> Tensor Value t

z

Returns x - y element-wise.

  • NOTE*: Sub supports broadcasting. More about broadcasting here

sum

Arguments

:: (TensorType t, OneOf ((:) * (Complex Double) ((:) * (Complex Float) ((:) * Int16 ((:) * Int32 ((:) * Int64 ((:) * Int8 ((:) * Word16 ((:) * Word8 ((:) * Double ((:) * Float ([] *))))))))))) t, TensorType tidx, OneOf ((:) * Int32 ((:) * Int64 ([] *))) tidx) 
=> Tensor v1 t

input: The tensor to reduce.

-> Tensor v2 tidx

reduction_indices: The dimensions to reduce.

-> Tensor Value t

output: The reduced tensor.

Computes the sum of elements across dimensions of a tensor.

Reduces input along the dimensions given in reduction_indices. Unless keep_dims is true, the rank of the tensor is reduced by 1 for each entry in reduction_indices. If keep_dims is true, the reduced dimensions are retained with length 1.

topK

Arguments

:: (TensorType t, OneOf ((:) * Int16 ((:) * Int32 ((:) * Int64 ((:) * Int8 ((:) * Word16 ((:) * Word8 ((:) * Double ((:) * Float ([] *))))))))) t) 
=> Int64

k: Number of top elements to look for along the last dimension (along each row for matrices).

-> Tensor v1 t

input: 1-D or higher with last dimension at least k.

-> (Tensor Value t, Tensor Value Int32)

(values, indices)

  • values: The k largest elements along each last dimensional slice.
  • indices: The indices of values within the last dimension of input.

Finds values and indices of the k largest elements for the last dimension.

If the input is a vector (rank-1), finds the k largest entries in the vector and outputs their values and indices as vectors. Thus `values[j]` is the j-th largest entry in input, and its index is `indices[j]`.

For matrices (resp. higher rank input), computes the top k entries in each row (resp. vector along the last dimension). Thus,

values.shape = indices.shape = input.shape[:-1] + [k]

If two elements are equal, the lower-index element appears first.

If k varies dynamically, use TopKV2 below.

transpose

Arguments

:: (TensorType t, TensorType tperm, OneOf ((:) * Int32 ((:) * Int64 ([] *))) tperm) 
=> Tensor v1 t

x

-> Tensor v2 tperm

perm

-> Tensor Value t

y

Shuffle dimensions of x according to a permutation.

The output y has the same rank as x. The shapes of x and y satisfy: `y.shape[i] == x.shape[perm[i]] for i in [0, 1, ..., rank(x) - 1]`

truncatedNormal

Arguments

:: TensorType a 
=> Tensor v Int64

Shape.

-> Build (Tensor Value a) 

variable :: forall a. TensorType a => Shape -> Build (Tensor Ref a)

Create a new, uninitialized stateful Tensor of the given shape.

vector :: TensorType a => [a] -> Tensor Value a

Create a constant vector.

zeros :: forall a. (Num a, TensorType a) => Shape -> Tensor Value a

zerosLike

Arguments

:: TensorType t 
=> Tensor v1 t

x: a tensor of type T.

-> Tensor Value t

y: a tensor of the same shape and type as x but filled with zeros.

Returns a tensor of zeros with the same shape and type as x.