class tf.Graph
A TensorFlow computation, represented as a dataflow graph.
A Graph
contains a set of
Operation
objects,
which represent units of computation; and
Tensor
objects, which represent
the units of data that flow between operations.
A default Graph
is always registered, and accessible by calling
tf.get_default_graph()
.
To add an operation to the default graph, simply call one of the functions
that defines a new Operation
:
c = tf.constant(4.0)
assert c.graph is tf.get_default_graph()
Another typical usage involves the
Graph.as_default()
context manager, which overrides the current default graph for the
lifetime of the context:
g = tf.Graph()
with g.as_default():
# Define operations and tensors in `g`.
c = tf.constant(30.0)
assert c.graph is g
Important note: This class is not threadsafe for graph construction. All operations should be created from a single thread, or external synchronization must be provided. Unless otherwise specified, all methods are not threadsafe.
tf.Graph.__init__()
{:#Graph.init}
Creates a new, empty Graph.
tf.Graph.as_default()
Returns a context manager that makes this Graph
the default graph.
This method should be used if you want to create multiple graphs
in the same process. For convenience, a global default graph is
provided, and all ops will be added to this graph if you do not
create a new graph explicitly. Use this method with the with
keyword
to specify that ops created within the scope of a block should be
added to this graph.
The default graph is a property of the current thread. If you
create a new thread, and wish to use the default graph in that
thread, you must explicitly add a with g.as_default():
in that
thread's function.
The following code examples are equivalent:
# 1. Using Graph.as_default():
g = tf.Graph()
with g.as_default():
c = tf.constant(5.0)
assert c.graph is g
# 2. Constructing and making default:
with tf.Graph().as_default() as g:
c = tf.constant(5.0)
assert c.graph is g
Returns:
A context manager for using this graph as the default graph.
tf.Graph.as_graph_def(from_version=None, add_shapes=False)
Returns a serialized GraphDef
representation of this graph.
The serialized GraphDef
can be imported into another Graph
(using import_graph_def()
) or used with the
C++ Session API.
This method is threadsafe.
Args:
from_version
: Optional. If this is set, returns aGraphDef
containing only the nodes that were added to this graph since itsversion
property had the given value.add_shapes
: If true, adds an "_output_shapes" list attr to each node with the inferred shapes of each of its outputs.
Returns:
A GraphDef
protocol buffer.
Raises:
ValueError
: If thegraph_def
would be too large.
tf.Graph.finalize()
Finalizes this graph, making it readonly.
After calling g.finalize()
, no new operations can be added to
g
. This method is used to ensure that no operations are added
to a graph when it is shared between multiple threads, for example
when using a QueueRunner
.
tf.Graph.finalized
True if this graph has been finalized.
tf.Graph.control_dependencies(control_inputs)
Returns a context manager that specifies control dependencies.
Use with the with
keyword to specify that all operations constructed
within the context should have control dependencies on
control_inputs
. For example:
with g.control_dependencies([a, b, c]):
# `d` and `e` will only run after `a`, `b`, and `c` have executed.
d = ...
e = ...
Multiple calls to control_dependencies()
can be nested, and in
that case a new Operation
will have control dependencies on the union
of control_inputs
from all active contexts.
with g.control_dependencies([a, b]):
# Ops constructed here run after `a` and `b`.
with g.control_dependencies([c, d]):
# Ops constructed here run after `a`, `b`, `c`, and `d`.
You can pass None to clear the control dependencies:
with g.control_dependencies([a, b]):
# Ops constructed here run after `a` and `b`.
with g.control_dependencies(None):
# Ops constructed here run normally, not waiting for either `a` or `b`.
with g.control_dependencies([c, d]):
# Ops constructed here run after `c` and `d`, also not waiting
# for either `a` or `b`.
N.B. The control dependencies context applies only to ops that are constructed within the context. Merely using an op or tensor in the context does not add a control dependency. The following example illustrates this point:
# WRONG
def my_func(pred, tensor):
t = tf.matmul(tensor, tensor)
with tf.control_dependencies([pred]):
# The matmul op is created outside the context, so no control
# dependency will be added.
return t
# RIGHT
def my_func(pred, tensor):
with tf.control_dependencies([pred]):
# The matmul op is created in the context, so a control dependency
# will be added.
return tf.matmul(tensor, tensor)
Args:
control_inputs
: A list ofOperation
orTensor
objects which must be executed or computed before running the operations defined in the context. Can also beNone
to clear the control dependencies.
Returns:
A context manager that specifies control dependencies for all operations constructed within the context.
Raises:
TypeError
: Ifcontrol_inputs
is not a list ofOperation
orTensor
objects.
tf.Graph.device(device_name_or_function)
Returns a context manager that specifies the default device to use.
The device_name_or_function
argument may either be a device name
string, a device function, or None:
 If it is a device name string, all operations constructed in
this context will be assigned to the device with that name, unless
overridden by a nested
device()
context.  If it is a function, it will be treated as a function from Operation objects to device name strings, and invoked each time a new Operation is created. The Operation will be assigned to the device with the returned name.
 If it is None, all
device()
invocations from the enclosing context will be ignored.
For information about the valid syntax of device name strings, see
the documentation in
DeviceNameUtils
.
For example:
with g.device('/gpu:0'):
# All operations constructed in this context will be placed
# on GPU 0.
with g.device(None):
# All operations constructed in this context will have no
# assigned device.
# Defines a function from `Operation` to device string.
def matmul_on_gpu(n):
if n.type == "MatMul":
return "/gpu:0"
else:
return "/cpu:0"
with g.device(matmul_on_gpu):
# All operations of type "MatMul" constructed in this context
# will be placed on GPU 0; all other operations will be placed
# on CPU 0.
N.B. The device scope may be overridden by op wrappers or
other library code. For example, a variable assignment op
v.assign()
must be colocated with the tf.Variable
v
, and
incompatible device scopes will be ignored.
Args:
device_name_or_function
: The device name or function to use in the context.
Returns:
A context manager that specifies the default device to use for newly created ops.
tf.Graph.name_scope(name)
Returns a context manager that creates hierarchical names for operations.
A graph maintains a stack of name scopes. A with name_scope(...):
statement pushes a new name onto the stack for the lifetime of the context.
The name
argument will be interpreted as follows:
 A string (not ending with '/') will create a new name scope, in which
name
is appended to the prefix of all operations created in the context. Ifname
has been used before, it will be made unique by callingself.unique_name(name)
.  A scope previously captured from a
with g.name_scope(...) as scope:
statement will be treated as an "absolute" name scope, which makes it possible to reenter existing scopes.  A value of
None
or the empty string will reset the current name scope to the toplevel (empty) name scope.
For example:
with tf.Graph().as_default() as g:
c = tf.constant(5.0, name="c")
assert c.op.name == "c"
c_1 = tf.constant(6.0, name="c")
assert c_1.op.name == "c_1"
# Creates a scope called "nested"
with g.name_scope("nested") as scope:
nested_c = tf.constant(10.0, name="c")
assert nested_c.op.name == "nested/c"
# Creates a nested scope called "inner".
with g.name_scope("inner"):
nested_inner_c = tf.constant(20.0, name="c")
assert nested_inner_c.op.name == "nested/inner/c"
# Create a nested scope called "inner_1".
with g.name_scope("inner"):
nested_inner_1_c = tf.constant(30.0, name="c")
assert nested_inner_1_c.op.name == "nested/inner_1/c"
# Treats `scope` as an absolute name scope, and
# switches to the "nested/" scope.
with g.name_scope(scope):
nested_d = tf.constant(40.0, name="d")
assert nested_d.op.name == "nested/d"
with g.name_scope(""):
e = tf.constant(50.0, name="e")
assert e.op.name == "e"
The name of the scope itself can be captured by with
g.name_scope(...) as scope:
, which stores the name of the scope
in the variable scope
. This value can be used to name an
operation that represents the overall result of executing the ops
in a scope. For example:
inputs = tf.constant(...)
with g.name_scope('my_layer') as scope:
weights = tf.Variable(..., name="weights")
biases = tf.Variable(..., name="biases")
affine = tf.matmul(inputs, weights) + biases
output = tf.nn.relu(affine, name=scope)
NOTE: This constructor validates the given name
. Valid scope
names match one of the following regular expressions:
[AZaz09.][AZaz09_.\\/]* (for scopes at the root)
[AZaz09_.\\/]* (for other scopes)
Args:
name
: A name for the scope.
Returns:
A context manager that installs name
as a new name scope.
Raises:
ValueError
: Ifname
is not a valid scope name. The rules are the
A Graph
instance supports an arbitrary number of "collections"
that are identified by name. For convenience when building a large
graph, collections can store groups of related objects: for
example, the tf.Variable
uses a collection (named
tf.GraphKeys.VARIABLES
) for
all variables that are created during the construction of a graph. The caller
may define additional collections by specifying a new name.
tf.Graph.add_to_collection(name, value)
Stores value
in the collection with the given name
.
Note that collections are not sets, so it is possible to add a value to a collection several times.
Args:
name
: The key for the collection. TheGraphKeys
class contains many standard names for collections.value
: The value to add to the collection.
tf.Graph.add_to_collections(names, value)
Stores value
in the collections given by names
.
Note that collections are not sets, so it is possible to add a value to
a collection several times. This function makes sure that duplicates in
names
are ignored, but it will not check for preexisting membership of
value
in any of the collections in names
.
names
can be any iterable, but if names
is a string, it is treated as a
single collection name.
Args:
names
: The keys for the collections to add to. TheGraphKeys
class contains many standard names for collections.value
: The value to add to the collections.
tf.Graph.get_collection(name, scope=None)
Returns a list of values in the collection with the given name
.
This is different from get_collection_ref()
which always returns the
actual collection list if it exists in that it returns a new list each time
it is called.
Args:
name
: The key for the collection. For example, theGraphKeys
class contains many standard names for collections.scope
: (Optional.) If supplied, the resulting list is filtered to include only items whosename
attribute matches usingre.match
. Items without aname
attribute are never returned if a scope is supplied and the choice orre.match
means that ascope
without special tokens filters by prefix.
Returns:
The list of values in the collection with the given name
, or
an empty list if no value has been added to that collection. The
list contains the values in the order under which they were
collected.
tf.Graph.get_collection_ref(name)
Returns a list of values in the collection with the given name
.
If the collection exists, this returns the list itself, which can be modified in place to change the collection. If the collection does not exist, it is created as an empty list and the list is returned.
This is different from get_collection()
which always returns a copy of
the collection list if it exists and never creates an empty collection.
Args:
name
: The key for the collection. For example, theGraphKeys
class contains many standard names for collections.
Returns:
The list of values in the collection with the given name
, or an empty
list if no value has been added to that collection.
tf.Graph.as_graph_element(obj, allow_tensor=True, allow_operation=True)
Returns the object referred to by obj
, as an Operation
or Tensor
.
This function validates that obj
represents an element of this
graph, and gives an informative error message if it is not.
This function is the canonical way to get/validate an object of one of the allowed types from an external argument reference in the Session API.
This method may be called concurrently from multiple threads.
Args:
obj
: ATensor
, anOperation
, or the name of a tensor or operation. Can also be any object with an_as_graph_element()
method that returns a value of one of these types.allow_tensor
: If true,obj
may refer to aTensor
.allow_operation
: If true,obj
may refer to anOperation
.
Returns:
The Tensor
or Operation
in the Graph corresponding to obj
.
Raises:
TypeError
: Ifobj
is not a type we support attempting to convert to types.ValueError
: Ifobj
is of an appropriate type but invalid. For example, an invalid string.KeyError
: Ifobj
is not an object in the graph.
tf.Graph.get_operation_by_name(name)
Returns the Operation
with the given name
.
This method may be called concurrently from multiple threads.
Args:
name
: The name of theOperation
to return.
Returns:
The Operation
with the given name
.
Raises:
TypeError
: Ifname
is not a string.KeyError
: Ifname
does not correspond to an operation in this graph.
tf.Graph.get_tensor_by_name(name)
Returns the Tensor
with the given name
.
This method may be called concurrently from multiple threads.
Args:
name
: The name of theTensor
to return.
Returns:
The Tensor
with the given name
.
Raises:
TypeError
: Ifname
is not a string.KeyError
: Ifname
does not correspond to a tensor in this graph.
tf.Graph.get_operations()
Return the list of operations in the graph.
You can modify the operations in place, but modifications to the list such as inserts/delete have no effect on the list of operations known to the graph.
This method may be called concurrently from multiple threads.
Returns:
A list of Operations.
tf.Graph.seed
The graphlevel random seed of this graph.
tf.Graph.unique_name(name, mark_as_used=True)
Return a unique operation name for name
.
unique_name
is used to generate structured names, separated by
"/"
, to help identify operations when debugging a graph.
Operation names are displayed in error messages reported by the
TensorFlow runtime, and in various visualization tools such as
TensorBoard.
If mark_as_used
is set to True
, which is the default, a new
unique name is created and marked as in use. If it's set to False
,
the unique name is returned without actually being marked as used.
This is useful when the caller simply wants to know what the name
to be created will be.
Args:
name
: The name for an operation.mark_as_used
: Whether to mark this name as being used.
Returns:
A string to be passed to create_op()
that will be used
to name the operation being created.
tf.Graph.version
Returns a version number that increases as ops are added to the graph.
Note that this is unrelated to the GraphDef version.
tf.Graph.graph_def_versions
The GraphDef version information of this graph.
For details on the meaning of each version, see [GraphDef
]
(https://www.tensorflow.org/code/tensorflow/core/framework/graph.proto).
Returns:
A VersionDef
.
tf.Graph.create_op(op_type, inputs, dtypes, input_types=None, name=None, attrs=None, op_def=None, compute_shapes=True, compute_device=True)
Creates an Operation
in this graph.
This is a lowlevel interface for creating an Operation
. Most
programs will not call this method directly, and instead use the
Python op constructors, such as tf.constant()
, which add ops to
the default graph.
Args:
op_type
: TheOperation
type to create. This corresponds to theOpDef.name
field for the proto that defines the operation.inputs
: A list ofTensor
objects that will be inputs to theOperation
.dtypes
: A list ofDType
objects that will be the types of the tensors that the operation produces.input_types
: (Optional.) A list ofDType
s that will be the types of the tensors that the operation consumes. By default, uses the baseDType
of each input ininputs
. Operations that expect referencetyped inputs must specifyinput_types
explicitly.name
: (Optional.) A string name for the operation. If not specified, a name is generated based onop_type
.attrs
: (Optional.) A dictionary where the key is the attribute name (a string) and the value is the respectiveattr
attribute of theNodeDef
proto that will represent the operation (anAttrValue
proto).op_def
: (Optional.) TheOpDef
proto that describes theop_type
that the operation will have.compute_shapes
: (Optional.) If True, shape inference will be performed to compute the shapes of the outputs.compute_device
: (Optional.) If True, device functions will be executed to compute the device property of the Operation.
Raises:
TypeError
: if any of the inputs is not aTensor
.ValueError
: if colocation conflicts with existing device assignment.
Returns:
An Operation
object.
tf.Graph.gradient_override_map(op_type_map)
EXPERIMENTAL: A context manager for overriding gradient functions.
This context manager can be used to override the gradient function that will be used for ops within the scope of the context.
For example:
@tf.RegisterGradient("CustomSquare")
def _custom_square_grad(op, grad):
# ...
with tf.Graph().as_default() as g:
c = tf.constant(5.0)
s_1 = tf.square(c) # Uses the default gradient for tf.square.
with g.gradient_override_map({"Square": "CustomSquare"}):
s_2 = tf.square(s_2) # Uses _custom_square_grad to compute the
# gradient of s_2.
Args:
op_type_map
: A dictionary mapping op type strings to alternative op type strings.
Returns:
A context manager that sets the alternative op type to be used for one or more ops created in that context.
Raises:
TypeError
: Ifop_type_map
is not a dictionary mapping strings to strings.
Other Methods
tf.Graph.colocate_with(op, ignore_existing=False)
Returns a context manager that specifies an op to colocate with.
For example:
a = tf.Variable([1.0])
with g.colocate_with(a):
b = tf.constant(1.0)
c = tf.add(a, b)
b
and c
will always be colocated with a
, no matter where a
is eventually placed.
Args:
op
: The op to colocate all created ops with.ignore_existing
: If true, only applies colocation of this op within the context, rather than applying all colocation properties on the stack.
Raises:
ValueError
: if op is None.
Yields:
A context manager that specifies the op with which to colocate newly created ops.
tf.Graph.container(container_name)
Returns a context manager that specifies the resource container to use.
Stateful operations, such as variables and queues, can maintain their
states on devices so that they can be shared by multiple processes.
A resource container is a string name under which these stateful
operations are tracked. These resources can be released or cleared
with tf.Session.reset()
.
For example:
with g.container('experiment0'):
# All stateful Operations constructed in this context will be placed
# in resource container "experiment0".
v1 = tf.Variable([1.0])
v2 = tf.Variable([2.0])
with g.container("experiment1"):
# All stateful Operations constructed in this context will be
# placed in resource container "experiment1".
v3 = tf.Variable([3.0])
q1 = tf.FIFOQueue(10, tf.float32)
# All stateful Operations constructed in this context will be
# be created in the "experiment0".
v4 = tf.Variable([4.0])
q1 = tf.FIFOQueue(20, tf.float32)
with g.container(""):
# All stateful Operations constructed in this context will be
# be placed in the default resource container.
v5 = tf.Variable([5.0])
q3 = tf.FIFOQueue(30, tf.float32)
# Resets container "experiment0", after which the state of v1, v2, v4, q1
# will become undefined (such as uninitialized).
tf.Session.reset(target, ["experiment0"])
Args:
container_name
: container name string.
Returns:
A context manager for defining resource containers for stateful ops, yields the container name.
tf.Graph.get_all_collection_keys()
Returns a list of collections used in this graph.
tf.Graph.is_feedable(tensor)
Returns True
if and only if tensor
is feedable.
tf.Graph.is_fetchable(tensor_or_op)
Returns True
if and only if tensor_or_op
is fetchable.
tf.Graph.prevent_feeding(tensor)
Marks the given tensor
as unfeedable in this graph.
tf.Graph.prevent_fetching(op)
Marks the given op
as unfetchable in this graph.
class tf.Operation
Represents a graph node that performs computation on tensors.
An Operation
is a node in a TensorFlow Graph
that takes zero or
more Tensor
objects as input, and produces zero or more Tensor
objects as output. Objects of type Operation
are created by
calling a Python op constructor (such as
tf.matmul()
)
or Graph.create_op()
.
For example c = tf.matmul(a, b)
creates an Operation
of type
"MatMul" that takes tensors a
and b
as input, and produces c
as output.
After the graph has been launched in a session, an Operation
can
be executed by passing it to
Session.run()
.
op.run()
is a shortcut for calling tf.get_default_session().run(op)
.
tf.Operation.name
The full name of this operation.
tf.Operation.type
The type of the op (e.g. "MatMul"
).
tf.Operation.inputs
The list of Tensor
objects representing the data inputs of this op.
tf.Operation.control_inputs
The Operation
objects on which this op has a control dependency.
Before this op is executed, TensorFlow will ensure that the
operations in self.control_inputs
have finished executing. This
mechanism can be used to run ops sequentially for performance
reasons, or to ensure that the side effects of an op are observed
in the correct order.
Returns:
A list of Operation
objects.
tf.Operation.outputs
The list of Tensor
objects representing the outputs of this op.
tf.Operation.device
The name of the device to which this op has been assigned, if any.
Returns:
The string name of the device to which this op has been assigned, or an empty string if it has not been assigned to a device.
tf.Operation.graph
The Graph
that contains this operation.
tf.Operation.run(feed_dict=None, session=None)
Runs this operation in a Session
.
Calling this method will execute all preceding operations that produce the inputs needed for this operation.
N.B. Before invoking Operation.run()
, its graph must have been
launched in a session, and either a default session must be
available, or session
must be specified explicitly.
Args:
feed_dict
: A dictionary that mapsTensor
objects to feed values. SeeSession.run()
for a description of the valid feed values.session
: (Optional.) TheSession
to be used to run to this operation. If none, the default session will be used.
tf.Operation.get_attr(name)
Returns the value of the attr of this op with the given name
.
Args:
name
: The name of the attr to fetch.
Returns:
The value of the attr, as a Python object.
Raises:
ValueError
: If this op does not have an attr with the givenname
.
tf.Operation.traceback
Returns the call stack from when this operation was constructed.
Other Methods
tf.Operation.__init__(node_def, g, inputs=None, output_types=None, control_inputs=None, input_types=None, original_op=None, op_def=None)
{:#Operation.init}
Creates an Operation
.
NOTE: This constructor validates the name of the Operation
(passed
as node_def.name
). Valid Operation
names match the following
regular expression:
[AZaz09.][AZaz09_.\/]*
Args:
node_def
:node_def_pb2.NodeDef
.NodeDef
for theOperation
. Used for attributes ofnode_def_pb2.NodeDef
, typicallyname
,op
, anddevice
. Theinput
attribute is irrelevant here as it will be computed when generating the model.g
:Graph
. The parent graph.inputs
: list ofTensor
objects. The inputs to thisOperation
.output_types
: list ofDType
objects. List of the types of theTensors
computed by this operation. The length of this list indicates the number of output endpoints of theOperation
.control_inputs
: list of operations or tensors from which to have a control dependency.input_types
: List ofDType
objects representing the types of the tensors accepted by theOperation
. By default uses[x.dtype.base_dtype for x in inputs]
. Operations that expect referencetyped inputs must specify these explicitly.original_op
: Optional. Used to associate the newOperation
with an existingOperation
(for example, a replica with the op that was replicated).op_def
: Optional. Theop_def_pb2.OpDef
proto that describes the op type that thisOperation
represents.
Raises:
TypeError
: if control inputs are not Operations or Tensors, or ifnode_def
is not aNodeDef
, or ifg
is not aGraph
, or ifinputs
are not tensors, or ifinputs
andinput_types
are incompatible.ValueError
: if thenode_def
name is not valid.
tf.Operation.__str__()
{:#Operation.str}
tf.Operation.colocation_groups()
Returns the list of colocation groups of the op.
tf.Operation.node_def
Returns a serialized NodeDef
representation of this operation.
Returns:
A
NodeDef
protocol buffer.
tf.Operation.op_def
Returns the OpDef
proto that represents the type of this op.
Returns:
An
OpDef
protocol buffer.
tf.Operation.values()
DEPRECATED: Use outputs.
class tf.Tensor
Represents one of the outputs of an Operation
.
Note: the Tensor
class will be replaced by Output
in the future.
Currently these two are aliases for each other.
A Tensor
is a symbolic handle to one of the outputs of an
Operation
. It does not hold the values of that operation's output,
but instead provides a means of computing those values in a
TensorFlow Session
.
This class has two primary purposes:

A
Tensor
can be passed as an input to anotherOperation
. This builds a dataflow connection between operations, which enables TensorFlow to execute an entireGraph
that represents a large, multistep computation. 
After the graph has been launched in a session, the value of the
Tensor
can be computed by passing it toSession.run()
.t.eval()
is a shortcut for callingtf.get_default_session().run(t)
.
In the following example, c
, d
, and e
are symbolic Tensor
objects, whereas result
is a numpy array that stores a concrete
value:
# Build a dataflow graph.
c = tf.constant([[1.0, 2.0], [3.0, 4.0]])
d = tf.constant([[1.0, 1.0], [0.0, 1.0]])
e = tf.matmul(c, d)
# Construct a `Session` to execute the graph.
sess = tf.Session()
# Execute the graph and store the value that `e` represents in `result`.
result = sess.run(e)
tf.Tensor.dtype
The DType
of elements in this tensor.
tf.Tensor.name
The string name of this tensor.
tf.Tensor.value_index
The index of this tensor in the outputs of its Operation
.
tf.Tensor.graph
The Graph
that contains this tensor.
tf.Tensor.op
The Operation
that produces this tensor as an output.
tf.Tensor.consumers()
Returns a list of Operation
s that consume this tensor.
Returns:
A list of Operation
s.
tf.Tensor.eval(feed_dict=None, session=None)
Evaluates this tensor in a Session
.
Calling this method will execute all preceding operations that produce the inputs needed for the operation that produces this tensor.
N.B. Before invoking Tensor.eval()
, its graph must have been
launched in a session, and either a default session must be
available, or session
must be specified explicitly.
Args:
feed_dict
: A dictionary that mapsTensor
objects to feed values. SeeSession.run()
for a description of the valid feed values.session
: (Optional.) TheSession
to be used to evaluate this tensor. If none, the default session will be used.
Returns:
A numpy array corresponding to the value of this tensor.
tf.Tensor.get_shape()
Returns the TensorShape
that represents the shape of this tensor.
The shape is computed using shape inference functions that are
registered for each Operation
type using tf.RegisterShape
.
See TensorShape
for more
details of what a shape represents.
The inferred shape of a tensor is used to provide shape information without having to launch the graph in a session. This can be used for debugging, and providing early error messages. For example:
c = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
print(c.get_shape())
==> TensorShape([Dimension(2), Dimension(3)])
d = tf.constant([[1.0, 0.0], [0.0, 1.0], [1.0, 0.0], [0.0, 1.0]])
print(d.get_shape())
==> TensorShape([Dimension(4), Dimension(2)])
# Raises a ValueError, because `c` and `d` do not have compatible
# inner dimensions.
e = tf.matmul(c, d)
f = tf.matmul(c, d, transpose_a=True, transpose_b=True)
print(f.get_shape())
==> TensorShape([Dimension(3), Dimension(4)])
In some cases, the inferred shape may have unknown dimensions. If
the caller has additional information about the values of these
dimensions, Tensor.set_shape()
can be used to augment the
inferred shape.
Returns:
A TensorShape
representing the shape of this tensor.
tf.Tensor.set_shape(shape)
Updates the shape of this tensor.
This method can be called multiple times, and will merge the given
shape
with the current shape of this tensor. It can be used to
provide additional information about the shape of this tensor that
cannot be inferred from the graph alone. For example, this can be used
to provide additional information about the shapes of images:
_, image_data = tf.TFRecordReader(...).read(...)
image = tf.image.decode_png(image_data, channels=3)
# The height and width dimensions of `image` are data dependent, and
# cannot be computed without executing the op.
print(image.get_shape())
==> TensorShape([Dimension(None), Dimension(None), Dimension(3)])
# We know that each image in this dataset is 28 x 28 pixels.
image.set_shape([28, 28, 3])
print(image.get_shape())
==> TensorShape([Dimension(28), Dimension(28), Dimension(3)])
Args:
shape
: ATensorShape
representing the shape of this tensor.
Raises:
ValueError
: Ifshape
is not compatible with the current shape of this tensor.
Other Methods
tf.Tensor.__abs__(x, name=None)
{:#Tensor.abs}
Computes the absolute value of a tensor.
Given a tensor of real numbers 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\).
See tf.complex_abs()
to compute the absolute value of a complex
number.
Args:
x
: ATensor
orSparseTensor
of typefloat32
,float64
,int32
, orint64
.name
: A name for the operation (optional).
Returns:
A Tensor
or SparseTensor
the same size and type as x
with absolute
values.
tf.Tensor.__add__(x, y)
{:#Tensor.add}
Returns x + y elementwise.
NOTE: Add
supports broadcasting. AddN
does not. More about broadcasting
here
Args:
x
: ATensor
. Must be one of the following types:half
,float32
,float64
,uint8
,int8
,int16
,int32
,int64
,complex64
,complex128
,string
.y
: ATensor
. Must have the same type asx
.name
: A name for the operation (optional).
Returns:
A Tensor
. Has the same type as x
.
tf.Tensor.__and__(x, y)
{:#Tensor.and}
Returns the truth value of x AND y elementwise.
NOTE: LogicalAnd
supports broadcasting. More about broadcasting
here
Args:
x
: ATensor
of typebool
.y
: ATensor
of typebool
.name
: A name for the operation (optional).
Returns:
A Tensor
of type bool
.
tf.Tensor.__bool__()
{:#Tensor.bool}
Dummy method to prevent a tensor from being used as a Python bool
.
This overload raises a TypeError
when the user inadvertently
treats a Tensor
as a boolean (e.g. in an if
statement). For
example:
if tf.constant(True): # Will raise.
# ...
if tf.constant(5) < tf.constant(7): # Will raise.
# ...
Raises:
TypeError
.
tf.Tensor.__div__(x, y)
{:#Tensor.div}
Returns x / y elementwise.
NOTE: Div
supports broadcasting. More about broadcasting
here
Args:
x
: ATensor
. Must be one of the following types:half
,float32
,float64
,uint8
,int8
,uint16
,int16
,int32
,int64
,complex64
,complex128
.y
: ATensor
. Must have the same type asx
.name
: A name for the operation (optional).
Returns:
A Tensor
. Has the same type as x
.
tf.Tensor.__eq__(other)
{:#Tensor.eq}
tf.Tensor.__floordiv__(x, y)
{:#Tensor.floordiv}
Divides x / y
elementwise, rounding down for floating point.
The same as tf.div(x,y)
for integers, but uses tf.floor(tf.div(x,y))
for
floating point arguments so that the result is always an integer (though
possibly an integer represented as floating point). This op is generated by
x // y
floor division in Python 3 and in Python 2.7 with
from __future__ import division
.
Note that for efficiency, floordiv
uses C semantics for negative numbers
(unlike Python and Numpy).
x
and y
must have the same type, and the result will have the same type
as well.
Args:
x
:Tensor
numerator of real numeric type.y
:Tensor
denominator of real numeric type.name
: A name for the operation (optional).
Returns:
x / y
rounded down (except possibly towards zero for negative integers).
Raises:
TypeError
: If the inputs are complex.
tf.Tensor.__ge__(x, y, name=None)
{:#Tensor.ge}
Returns the truth value of (x >= y) elementwise.
NOTE: GreaterEqual
supports broadcasting. More about broadcasting
here
Args:
x
: ATensor
. Must be one of the following types:float32
,float64
,int32
,int64
,uint8
,int16
,int8
,uint16
,half
.y
: ATensor
. Must have the same type asx
.name
: A name for the operation (optional).
Returns:
A Tensor
of type bool
.
tf.Tensor.__getitem__(tensor, slice_spec, var=None)
{:#Tensor.getitem}
Overload for Tensor.getitem.
This operation extracts the specified region from the tensor. The notation is similar to NumPy with the restriction that currently only support basic indexing. That means that using a tensor as input is not currently allowed
Some useful examples:
# strip leading and trailing 2 elements
foo = tf.constant([1,2,3,4,5,6])
print(foo[2:2].eval()) # => [3,4]
# skip every row and reverse every column
foo = tf.constant([[1,2,3], [4,5,6], [7,8,9]])
print(foo[::2,::1].eval()) # => [[3,2,1], [9,8,7]]
# Insert another dimension
foo = tf.constant([[1,2,3], [4,5,6], [7,8,9]])
print(foo[tf.newaxis, :, :].eval()) # => [[[3,2,1], [9,8,7]]]
print(foo[:, tf.newaxis, :].eval()) # => [[[3,2,1]], [[9,8,7]]]
print(foo[:, :, tf.newaxis].eval()) # => [[[3],[2],[1]], [[9],[8],[7]]]
# Ellipses (3 equivalent operations)
print(foo[tf.newaxis, :, :].eval()) # => [[[3,2,1], [9,8,7]]]
print(foo[tf.newaxis, ...].eval()) # => [[[3,2,1], [9,8,7]]]
print(foo[tf.newaxis].eval()) # => [[[3,2,1], [9,8,7]]]
Notes:
tf.newaxis
isNone
as in NumPy. An implicit ellipsis is placed at the end of the
slice_spec
 NumPy advanced indexing is currently not supported.
Args:
tensor
: An ops.Tensor object.slice_spec
: The arguments to Tensor.getitem.var
: In the case of variable slice assignment, the Variable object to slice (i.e. tensor is the readonly view of this variable).
Returns:
The appropriate slice of "tensor", based on "slice_spec".
Raises:
ValueError
: If a slice range is negative size.TypeError
: If the slice indices aren't int, slice, or Ellipsis.
tf.Tensor.__gt__(x, y, name=None)
{:#Tensor.gt}
Returns the truth value of (x > y) elementwise.
NOTE: Greater
supports broadcasting. More about broadcasting
here
Args:
x
: ATensor
. Must be one of the following types:float32
,float64
,int32
,int64
,uint8
,int16
,int8
,uint16
,half
.y
: ATensor
. Must have the same type asx
.name
: A name for the operation (optional).
Returns:
A Tensor
of type bool
.
tf.Tensor.__hash__()
{:#Tensor.hash}
tf.Tensor.__init__(op, value_index, dtype)
{:#Tensor.init}
Creates a new Tensor
.
Args:
op
: AnOperation
.Operation
that computes this tensor.value_index
: Anint
. Index of the operation's endpoint that produces this tensor.dtype
: ADType
. Type of elements stored in this tensor.
Raises:
TypeError
: If the op is not anOperation
.
tf.Tensor.__invert__(x, name=None)
{:#Tensor.invert}
Returns the truth value of NOT x elementwise.
Args:
x
: ATensor
of typebool
.name
: A name for the operation (optional).
Returns:
A Tensor
of type bool
.
tf.Tensor.__iter__()
{:#Tensor.iter}
Dummy method to prevent iteration. Do not call.
NOTE(mrry): If we register getitem as an overloaded operator, Python will valiantly attempt to iterate over the Tensor from 0 to infinity. Declaring this method prevents this unintended behavior.
Raises:
TypeError
: when invoked.
tf.Tensor.__le__(x, y, name=None)
{:#Tensor.le}
Returns the truth value of (x <= y) elementwise.
NOTE: LessEqual
supports broadcasting. More about broadcasting
here
Args:
x
: ATensor
. Must be one of the following types:float32
,float64
,int32
,int64
,uint8
,int16
,int8
,uint16
,half
.y
: ATensor
. Must have the same type asx
.name
: A name for the operation (optional).
Returns:
A Tensor
of type bool
.
tf.Tensor.__lt__(x, y, name=None)
{:#Tensor.lt}
Returns the truth value of (x < y) elementwise.
NOTE: Less
supports broadcasting. More about broadcasting
here
Args:
x
: ATensor
. Must be one of the following types:float32
,float64
,int32
,int64
,uint8
,int16
,int8
,uint16
,half
.y
: ATensor
. Must have the same type asx
.name
: A name for the operation (optional).
Returns:
A Tensor
of type bool
.
tf.Tensor.__mod__(x, y)
{:#Tensor.mod}
Returns elementwise remainder of division.
NOTE: Mod
supports broadcasting. More about broadcasting
here
Args:
x
: ATensor
. Must be one of the following types:int32
,int64
,float32
,float64
.y
: ATensor
. Must have the same type asx
.name
: A name for the operation (optional).
Returns:
A Tensor
. Has the same type as x
.
tf.Tensor.__mul__(x, y)
{:#Tensor.mul}
Dispatches cwise mul for "DenseDense" and "DenseSparse".
tf.Tensor.__neg__(x, name=None)
{:#Tensor.neg}
Computes numerical negative value elementwise.
I.e., \(y = x\).
Args:
x
: ATensor
. Must be one of the following types:half
,float32
,float64
,int32
,int64
,complex64
,complex128
.name
: A name for the operation (optional).
Returns:
A Tensor
. Has the same type as x
.
tf.Tensor.__nonzero__()
{:#Tensor.nonzero}
Dummy method to prevent a tensor from being used as a Python bool
.
This is the Python 2.x counterpart to __bool__()
above.
Raises:
TypeError
.
tf.Tensor.__or__(x, y)
{:#Tensor.or}
Returns the truth value of x OR y elementwise.
NOTE: LogicalOr
supports broadcasting. More about broadcasting
here
Args:
x
: ATensor
of typebool
.y
: ATensor
of typebool
.name
: A name for the operation (optional).
Returns:
A Tensor
of type bool
.
tf.Tensor.__pow__(x, y)
{:#Tensor.pow}
Computes the power of one value to another.
Given a tensor x
and a tensor y
, this operation computes \(x^y\) for
corresponding elements in x
and y
. For example:
# tensor 'x' is [[2, 2], [3, 3]]
# tensor 'y' is [[8, 16], [2, 3]]
tf.pow(x, y) ==> [[256, 65536], [9, 27]]
Args:
x
: ATensor
of typefloat32
,float64
,int32
,int64
,complex64
, orcomplex128
.y
: ATensor
of typefloat32
,float64
,int32
,int64
,complex64
, orcomplex128
.name
: A name for the operation (optional).
Returns:
A Tensor
.
tf.Tensor.__radd__(y, x)
{:#Tensor.radd}
Returns x + y elementwise.
NOTE: Add
supports broadcasting. AddN
does not. More about broadcasting
here
Args:
x
: ATensor
. Must be one of the following types:half
,float32
,float64
,uint8
,int8
,int16
,int32
,int64
,complex64
,complex128
,string
.y
: ATensor
. Must have the same type asx
.name
: A name for the operation (optional).
Returns:
A Tensor
. Has the same type as x
.
tf.Tensor.__rand__(y, x)
{:#Tensor.rand}
Returns the truth value of x AND y elementwise.
NOTE: LogicalAnd
supports broadcasting. More about broadcasting
here
Args:
x
: ATensor
of typebool
.y
: ATensor
of typebool
.name
: A name for the operation (optional).
Returns:
A Tensor
of type bool
.
tf.Tensor.__rdiv__(y, x)
{:#Tensor.rdiv}
Returns x / y elementwise.
NOTE: Div
supports broadcasting. More about broadcasting
here
Args:
x
: ATensor
. Must be one of the following types:half
,float32
,float64
,uint8
,int8
,uint16
,int16
,int32
,int64
,complex64
,complex128
.y
: ATensor
. Must have the same type asx
.name
: A name for the operation (optional).
Returns:
A Tensor
. Has the same type as x
.
tf.Tensor.__repr__()
{:#Tensor.repr}
tf.Tensor.__rfloordiv__(y, x)
{:#Tensor.rfloordiv}
Divides x / y
elementwise, rounding down for floating point.
The same as tf.div(x,y)
for integers, but uses tf.floor(tf.div(x,y))
for
floating point arguments so that the result is always an integer (though
possibly an integer represented as floating point). This op is generated by
x // y
floor division in Python 3 and in Python 2.7 with
from __future__ import division
.
Note that for efficiency, floordiv
uses C semantics for negative numbers
(unlike Python and Numpy).
x
and y
must have the same type, and the result will have the same type
as well.
Args:
x
:Tensor
numerator of real numeric type.y
:Tensor
denominator of real numeric type.name
: A name for the operation (optional).
Returns:
x / y
rounded down (except possibly towards zero for negative integers).
Raises:
TypeError
: If the inputs are complex.
tf.Tensor.__rmod__(y, x)
{:#Tensor.rmod}
Returns elementwise remainder of division.
NOTE: Mod
supports broadcasting. More about broadcasting
here
Args:
x
: ATensor
. Must be one of the following types:int32
,int64
,float32
,float64
.y
: ATensor
. Must have the same type asx
.name
: A name for the operation (optional).
Returns:
A Tensor
. Has the same type as x
.
tf.Tensor.__rmul__(y, x)
{:#Tensor.rmul}
Dispatches cwise mul for "DenseDense" and "DenseSparse".
tf.Tensor.__ror__(y, x)
{:#Tensor.ror}
Returns the truth value of x OR y elementwise.
NOTE: LogicalOr
supports broadcasting. More about broadcasting
here
Args:
x
: ATensor
of typebool
.y
: ATensor
of typebool
.name
: A name for the operation (optional).
Returns:
A Tensor
of type bool
.
tf.Tensor.__rpow__(y, x)
{:#Tensor.rpow}
Computes the power of one value to another.
Given a tensor x
and a tensor y
, this operation computes \(x^y\) for
corresponding elements in x
and y
. For example:
# tensor 'x' is [[2, 2], [3, 3]]
# tensor 'y' is [[8, 16], [2, 3]]
tf.pow(x, y) ==> [[256, 65536], [9, 27]]
Args:
x
: ATensor
of typefloat32
,float64
,int32
,int64
,complex64
, orcomplex128
.y
: ATensor
of typefloat32
,float64
,int32
,int64
,complex64
, orcomplex128
.name
: A name for the operation (optional).
Returns:
A Tensor
.
tf.Tensor.__rsub__(y, x)
{:#Tensor.rsub}
Returns x  y elementwise.
NOTE: Sub
supports broadcasting. More about broadcasting
here
Args:
x
: ATensor
. Must be one of the following types:half
,float32
,float64
,int32
,int64
,complex64
,complex128
.y
: ATensor
. Must have the same type asx
.name
: A name for the operation (optional).
Returns:
A Tensor
. Has the same type as x
.
tf.Tensor.__rtruediv__(y, x)
{:#Tensor.rtruediv}
Divides x / y elementwise, always producing floating point results.
The same as tf.div
for floating point arguments, but casts integer arguments
to floating point before dividing so that the result is always floating point.
This op is generated by normal x / y
division in Python 3 and in Python 2.7
with from __future__ import division
. If you want integer division that
rounds down, use x // y
or tf.floordiv
.
x
and y
must have the same numeric type. If the inputs are floating
point, the output will have the same type. If the inputs are integral, the
inputs are cast to float32
for int8
and int16
and float64
for int32
and int64
(matching the behavior of Numpy).
Args:
x
:Tensor
numerator of numeric type.y
:Tensor
denominator of numeric type.name
: A name for the operation (optional).
Returns:
x / y
evaluated in floating point.
Raises:
TypeError
: Ifx
andy
have different dtypes.
tf.Tensor.__rxor__(y, x)
{:#Tensor.rxor}
x ^ y = (x  y) & ~(x & y).
tf.Tensor.__str__()
{:#Tensor.str}
tf.Tensor.__sub__(x, y)
{:#Tensor.sub}
Returns x  y elementwise.
NOTE: Sub
supports broadcasting. More about broadcasting
here
Args:
x
: ATensor
. Must be one of the following types:half
,float32
,float64
,int32
,int64
,complex64
,complex128
.y
: ATensor
. Must have the same type asx
.name
: A name for the operation (optional).
Returns:
A Tensor
. Has the same type as x
.
tf.Tensor.__truediv__(x, y)
{:#Tensor.truediv}
Divides x / y elementwise, always producing floating point results.
The same as tf.div
for floating point arguments, but casts integer arguments
to floating point before dividing so that the result is always floating point.
This op is generated by normal x / y
division in Python 3 and in Python 2.7
with from __future__ import division
. If you want integer division that
rounds down, use x // y
or tf.floordiv
.
x
and y
must have the same numeric type. If the inputs are floating
point, the output will have the same type. If the inputs are integral, the
inputs are cast to float32
for int8
and int16
and float64
for int32
and int64
(matching the behavior of Numpy).
Args:
x
:Tensor
numerator of numeric type.y
:Tensor
denominator of numeric type.name
: A name for the operation (optional).
Returns:
x / y
evaluated in floating point.
Raises:
TypeError
: Ifx
andy
have different dtypes.
tf.Tensor.__xor__(x, y)
{:#Tensor.xor}
x ^ y = (x  y) & ~(x & y).
tf.Tensor.device
The name of the device on which this tensor will be produced, or None.