Customization for session. Use the lenses to update: sessionTarget, sessionTracer, sessionConfig.

Uses the specified config for the created session.

Target can be: "local", ip:port, host:port. The set of supported factories depends on the linked in libraries.

Uses the given logger to monitor session progress.

Run Session actions in a new TensorFlow session.

Run Session actions in a new TensorFlow session created with the given option setter actions (sessionTarget, sessionConfig).

Lift a Build action into a monad, including any explicit op renderings.

Types that tensor representations (e.g. Tensor, ControlNode) can be fetched into.

Includes collections of tensors (e.g. tuples).

Types that contain ops which can be run.

Run a subgraph t, rendering any dependent nodes that aren't already rendered, and fetch the corresponding values for a.

Run a subgraph t, rendering and extending any dependent nodes that aren't already rendered. This behaves like run except that it doesn't do any fetches.

A pair of a Tensor and some data that should be fed into that Tensor when running the graph.

Create a Feed for feeding the given data into a Tensor when running the graph.

Note that if a Tensor is rendered, its identity may change; so feeding the rendered Tensor may be different than feeding the original Tensor.

Run a subgraph t, rendering any dependent nodes that aren't already rendered, feed the given input values, and fetch the corresponding result values for a.

Run a subgraph t, rendering any dependent nodes that aren't already rendered, feed the given input values, and fetch the corresponding result values for a. This behaves like runWithFeeds except that it doesn't do any fetches.

Starts a concurrent thread which evaluates the given Nodes forever until runSession exits or an exception occurs. Graph extension happens synchronously, but the resultant run proceeds as a separate thread.

An action for building nodes in a TensorFlow graph.

An action for building nodes in a TensorFlow graph. Used to manage build state internally as part of the Session monad.

Render a Tensor, fixing its name, scope, device and control inputs from the MonadBuild context. Also renders any dependencies of the Tensor that weren't already rendered.

This operation is idempotent; calling render on the same input in the same context will produce the same result. However, rendering the same Tensor Build in two different contexts may result in two different Tensor Values.

Produce a GraphDef proto representation of the nodes that are rendered in the given Build action.

A type of graph node which has no outputs. These nodes are valuable for causing side effects when they are run.

A named output of a TensorFlow operation.

The type parameter a is the type of the elements in the Tensor. The parameter v is either:

• Build: An unrendered, immutable value.
• Value: A rendered, immutable value.
• Ref: A rendered stateful handle (e.g., a variable).

Note that expr, value, render and renderValue can help convert between the different types of Tensor.

Cast a 'Tensor Ref' into a 'Tensor Value'. This behaves like a no-op.

Create a Tensor for a given name. This can be used to reference nodes in a GraphDef that was loaded via addGraphDef. TODO(judahjacobson): add more safety checks here.

The class of scalar types supported by tensorflow.

Tensor data with the correct memory layout for tensorflow.

Types that can be converted to and from TensorData.

Vector is the most efficient to encode/decode for most element types.

Shape (dimensions) of a tensor.

A Constraint specifying the possible choices of a TensorType.

We implement a Constraint like OneOf '[Double, Float] a by turning the natural representation as a conjunction, i.e.,

   a == Double || a == Float

into a disjunction like

    a /= Int32 && a /= Int64 && a /= ByteString && ...

using an enumeration of all the possible TensorTypes.

A constraint checking that two types are different.

Places all nodes rendered in the given Build action on the same device as the given Tensor (see also withDevice). Make sure that the action has side effects of rendering the desired tensors. A pure return would not have the desired effect.

A device that a node can be assigned to. There's a naming convention where the device names are constructed from job and replica names.

Set a device for all nodes rendered in the given Build action (unless further overridden by another use of withDevice).

Prepend a scope to all nodes rendered in the given Build action.

Modify a Build action, such that all new ops rendered in it will depend on the nodes in the first argument.

Create an op that groups multiple operations.

When this op finishes, all ops in the input n have finished. This op has no output.

Does nothing. Only useful as a placeholder for control edges.