![]() |
![]() |
A TensorFlow computation, represented as a dataflow graph.
tf.Graph()
Used in the notebooks
Used in the guide | Used in the tutorials |
---|---|
Graphs are used by tf.function
s to represent the function's computations.
Each graph contains a set of tf.Operation
objects, which represent units of
computation; and tf.Tensor
objects, which represent the units of data that
flow between operations.
Using graphs directly (deprecated)
A tf.Graph
can be constructed and used directly without a tf.function
, as
was required in TensorFlow 1, but this is deprecated and it is recommended to
use a tf.function
instead. If a graph is directly used, other deprecated
TensorFlow 1 classes are also required to execute the graph, such as a
tf.compat.v1.Session
.
A default graph can be registered with the tf.Graph.as_default
context
manager. Then, operations will be added to the graph instead of being executed
eagerly. For example:
g = tf.Graph()
with g.as_default():
# Define operations and tensors in `g`.
c = tf.constant(30.0)
assert c.graph is g
tf.compat.v1.get_default_graph()
can be used to obtain the default graph.
Important note: This class is not thread-safe 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 thread-safe.
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.GLOBAL_VARIABLES
) for
all variables that are created during the construction of a graph. The caller
may define additional collections by specifying a new name.
Attributes | |
---|---|
building_function
|
Returns True iff this graph represents a function. |
collections
|
Returns the names of the collections known to this graph. |
finalized
|
True if this graph has been finalized. |
graph_def_versions
|
The GraphDef version information of this graph.
For details on the meaning of each version, see
|
seed
|
The graph-level random seed of this graph. |
version
|
Returns a version number that increases as ops are added to the graph.
Note that this is unrelated to the
|
Methods
add_to_collection
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. The GraphKeys class contains many
standard names for collections.
|
value
|
The value to add to the collection. |
add_to_collections
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 pre-existing 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. The GraphKeys class
contains many standard names for collections.
|
value
|
The value to add to the collections. |
as_default
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. In this case, once
the scope of the with
is exited, the previous default graph is set again
as default. There is a stack, so it's ok to have multiple nested levels
of as_default
calls.
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
If eager execution is enabled ops created under this context manager will be added to the graph instead of executed eagerly.
Returns | |
---|---|
A context manager for using this graph as the default graph. |
as_graph_def
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 tf.import_graph_def
) or used with the
C++ Session API.
This method is thread-safe.
Args | |
---|---|
from_version
|
Optional. If this is set, returns a GraphDef containing
only the nodes that were added to this graph since its version
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 the graph_def would be too large.
|
as_graph_element
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
|
A Tensor , an Operation , 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. Note: _as_graph_element will be called
inside the graph's lock and so may not modify the graph.
|
allow_tensor
|
If true, obj may refer to a Tensor .
|
allow_operation
|
If true, obj may refer to an Operation .
|
Returns | |
---|---|
The Tensor or Operation in the Graph corresponding to obj .
|
Raises | |
---|---|
TypeError
|
If obj is not a type we support attempting to convert
to types.
|
ValueError
|
If obj is of an appropriate type but invalid. For
example, an invalid string.
|
KeyError
|
If obj is not an object in the graph.
|
clear_collection
clear_collection(
name
)
Clears all values in a collection.
Args | |
---|---|
name
|
The key for the collection. The GraphKeys class contains many
standard names for collections.
|
colocate_with
@tf_contextlib.contextmanager
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.
If op
is None
then ignore_existing
must be True
and the new
scope resets all colocation and device constraints.
Args | |
---|---|
op
|
The op to colocate all created ops with, or None .
|
ignore_existing
|
If true, only applies colocation of this op within the
context, rather than applying all colocation properties on the stack.
If op is None , this value must be True .
|
Raises | |
---|---|
ValueError
|
if op is None but ignore_existing is False. |
Yields | |
---|---|
A context manager that specifies the op with which to colocate newly created ops. |
container
@tf_contextlib.contextmanager
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.queue.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.queue.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.queue.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. |
control_dependencies
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.con