# Copyright 2015 The TensorFlow Authors. All Rights Reserved.

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

# http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

# ==============================================================================

"""Classes and functions used to construct graphs."""

# pylint: disable=g-bad-name

from __future__ import absolute_import

from __future__ import division

from __future__ import print_function

import collections

import copy

import os

import re

import sys

import threading

import numpy as np

import six

from six.moves import xrange # pylint: disable=redefined-builtin

from tensorflow.core.framework import attr_value_pb2

from tensorflow.core.framework import function_pb2

from tensorflow.core.framework import graph_pb2

from tensorflow.core.framework import node_def_pb2

from tensorflow.core.framework import op_def_pb2

from tensorflow.core.framework import versions_pb2

from tensorflow.core.protobuf import config_pb2

from tensorflow.python import pywrap_tensorflow as c_api

from tensorflow.python.eager import context

from tensorflow.python.eager import core

from tensorflow.python.eager import tape

from tensorflow.python.framework import c_api_util

from tensorflow.python.framework import cpp_shape_inference_pb2

from tensorflow.python.framework import device as pydev

from tensorflow.python.framework import dtypes

from tensorflow.python.framework import error_interpolation

from tensorflow.python.framework import errors

from tensorflow.python.framework import op_def_registry

from tensorflow.python.framework import registry

from tensorflow.python.framework import tensor_shape

from tensorflow.python.framework import traceable_stack

from tensorflow.python.framework import versions

from tensorflow.python.ops import control_flow_util

from tensorflow.python.platform import app

from tensorflow.python.platform import tf_logging as logging

from tensorflow.python.util import compat

from tensorflow.python.util import decorator_utils

from tensorflow.python.util import function_utils

from tensorflow.python.util import lock_util

from tensorflow.python.util import tf_contextlib

from tensorflow.python.util import tf_stack

from tensorflow.python.util.deprecation import deprecated_args

from tensorflow.python.util.tf_export import tf_export

# Temporary global switches determining if we should enable the work-in-progress

# calls to the C API. These will be removed once all functionality is supported.

_USE_C_API = True

_USE_C_SHAPES = os.getenv("TF_C_API_GRAPH_CONSTRUCTION_SHAPES", "1") != "0"

def tensor_id(tensor):

"""Returns a unique identifier for this Tensor."""

return tensor._id # pylint: disable=protected-access

class _UserDeviceSpec(object):

"""Store user-specified device and provide computation of merged device."""

def __init__(self, device_name_or_function):

self._device_name_or_function = device_name_or_function

self.display_name = str(self._device_name_or_function)

if callable(self._device_name_or_function):

dev_func = self._device_name_or_function

func_name = function_utils.get_func_name(dev_func)

func_code = function_utils.get_func_code(dev_func)

if func_code:

fname = func_code.co_filename

lineno = func_code.co_firstlineno

else:

fname = "unknown"

lineno = -1

self.display_name = "%s<%s, %d>" % (func_name, fname, lineno)

self.function = self._device_name_or_function

if not (self._device_name_or_function is None or

callable(self._device_name_or_function)):

self.function = pydev.merge_device(self._device_name_or_function)

class _NullContextmanager(object):

def __enter__(self):

pass

def __exit__(self, type_arg, value_arg, traceback_arg):

return False # False values do not suppress exceptions

def _override_helper(clazz_object, operator, func):

"""Overrides (string) operator on Tensors to call func.

Args:

clazz_object: the class to override for; either Tensor or SparseTensor.

operator: the string name of the operator to override.

func: the function that replaces the overridden operator.

Raises:

ValueError: If operator has already been overwritten,

or if operator is not allowed to be overwritten.

"""

existing = getattr(clazz_object, operator, None)

if existing is not None:

# Check to see if this is a default method-wrapper or slot wrapper which

# will be true for the comparison operators.

if not isinstance(existing, type(object.__lt__)):

raise ValueError("operator %s cannot be overwritten again on class %s." %

(operator, clazz_object))

if operator not in Tensor.OVERLOADABLE_OPERATORS:

raise ValueError("Overriding %s is disallowed" % operator)

setattr(clazz_object, operator, func)

def _as_graph_element(obj):

"""Convert `obj` to a graph element if possible, otherwise return `None`.

Args:

obj: Object to convert.

Returns:

The result of `obj._as_graph_element()` if that method is available;

otherwise `None`.

"""

conv_fn = getattr(obj, "_as_graph_element", None)

if conv_fn and callable(conv_fn):

return conv_fn()

return None

_TENSOR_LIKE_TYPES = tuple()

def is_dense_tensor_like(t):

"""EXPERIMENTAL: Returns true if `t` implements the tensor interface.

See `register_dense_tensor_like_type()` for the current definition of a

"tensor-like type".

Args:

t: An object.

Returns:

True iff `t` is an instance of one of the registered "tensor-like" types.

"""

return isinstance(t, _TENSOR_LIKE_TYPES)

def register_dense_tensor_like_type(tensor_type):

"""EXPERIMENTAL: Registers `tensor_type` as implementing the tensor interface.

A "tensor-like type" can represent a single dense tensor, and implements

the `name` and `dtype` properties.

Args:

tensor_type: A type implementing the tensor interface.

Raises:

TypeError: If `tensor_type` does not implement the tensor interface.

"""

try:

if not isinstance(tensor_type.name, property):

raise TypeError("Type %s does not define a `name` property" %

tensor_type.__name__)

except AttributeError:

raise TypeError("Type %s does not define a `name` property" %

tensor_type.__name__)

try:

if not isinstance(tensor_type.dtype, property):

raise TypeError("Type %s does not define a `dtype` property" %

tensor_type.__name__)

except AttributeError:

raise TypeError("Type %s does not define a `dtype` property" %

tensor_type.__name__)

# We expect this list to be small, so choose quadratic complexity

# for registration, so that we have a tuple that can be used for

# more efficient `isinstance` checks later.

global _TENSOR_LIKE_TYPES

_TENSOR_LIKE_TYPES = tuple(list(_TENSOR_LIKE_TYPES) + [tensor_type])

def uid():

"""A unique (within this program execution) integer."""

return c_api.TFE_Py_UID()

def numpy_text(tensor, is_repr=False):

"""Human readable representation of a tensor's numpy value."""

if tensor.dtype.is_numpy_compatible:

text = repr(tensor.numpy()) if is_repr else str(tensor.numpy())

else:

text = "<unprintable>"

if "\n" in text:

text = "\n" + text

return text

# NOTE(ebrevdo): Do not subclass this. If you do, I will break you on purpose.

class _TensorLike(object):

"""Internal cls for grouping Tensor, SparseTensor, ..., for is_instance."""

pass

@tf_export("Tensor")

class Tensor(_TensorLike):

"""Represents one of the outputs of an `Operation`.

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 @{tf.Session}.

This class has two primary purposes:

1. A `Tensor` can be passed as an input to another `Operation`.

This builds a dataflow connection between operations, which

enables TensorFlow to execute an entire `Graph` that represents a

large, multi-step computation.

2. After the graph has been launched in a session, the value of the

`Tensor` can be computed by passing it to

@{tf.Session.run}.

`t.eval()` is a shortcut for calling

`tf.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:

```python

# 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)

```

"""

# List of Python operators that we allow to override.

OVERLOADABLE_OPERATORS = {

# Binary.

"__add__",

"__radd__",

"__sub__",

"__rsub__",

"__mul__",

"__rmul__",

"__div__",

"__rdiv__",

"__truediv__",

"__rtruediv__",

"__floordiv__",

"__rfloordiv__",

"__mod__",

"__rmod__",

"__lt__",

"__le__",

"__gt__",

"__ge__",

"__and__",

"__rand__",

"__or__",

"__ror__",

"__xor__",

"__rxor__",

"__getitem__",

"__pow__",

"__rpow__",

# Unary.

"__invert__",

"__neg__",

"__abs__",

"__matmul__",

"__rmatmul__"

}

def __init__(self, op, value_index, dtype):

"""Creates a new `Tensor`.

Args:

op: An `Operation`. `Operation` that computes this tensor.

value_index: An `int`. Index of the operation's endpoint that produces

this tensor.

dtype: A `DType`. Type of elements stored in this tensor.

Raises:

TypeError: If the op is not an `Operation`.

"""

if not isinstance(op, Operation):

raise TypeError("op needs to be an Operation: %s" % op)

self._op = op

self._value_index = value_index

self._dtype = dtypes.as_dtype(dtype)

# This will be set by self.shape().

self._shape_val = None

# List of operations that use this Tensor as input. We maintain this list

# to easily navigate a computation graph.

self._consumers = []

if not _USE_C_SHAPES:

# Attributes used for C++ shape inference. Not inspected, only forwarded.

# If set, will be a HandleData object from cpp_shape_inference.proto.

self._handle_data = None

self._id = uid()

@property

def op(self):

"""The `Operation` that produces this tensor as an output."""

return self._op

@property

def dtype(self):

"""The `DType` of elements in this tensor."""

return self._dtype

@property

def graph(self):

"""The `Graph` that contains this tensor."""

return self._op.graph

@property

def name(self):

"""The string name of this tensor."""

if not self._op.name:

raise ValueError("Operation was not named: %s" % self._op)

return "%s:%d" % (self._op.name, self._value_index)

@property

def device(self):

"""The name of the device on which this tensor will be produced, or None."""

return self._op.device

@property

def shape(self):

"""Returns the `TensorShape` that represents the shape of this tensor.

The shape is computed using shape inference functions that are

registered in the Op for each `Operation`. See

@{tf.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:

```python

c = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])

print(c.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.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.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.

"""

if self._shape_val is None:

if _USE_C_SHAPES:

self._shape_val = self._c_api_shape()

else:

# Call set_shape_and_handle_data_for_outputs in topological order on all

# ops that are needed to compute self.op's shape. We do this instead of

# having set_shape_and_handle_data_for_outputs recursively call

# Operation.shape on self.op.inputs to overflowing the call stack.

need_shapes = self._get_input_ops_without_shapes(self.op)

need_shapes.sort(key=lambda op: op._id)

for op in need_shapes:

set_shape_and_handle_data_for_outputs(op)

return self._shape_val

def _get_input_ops_without_shapes(self, target_op):

"""Returns ops needing shape inference to compute target_op's shape."""

result = []

stack = [self._op]

visited = set()

while stack:

op = stack.pop()

if op in visited: continue

result.append(op)

stack.extend(t.op for t in op.inputs if t._shape_val is None)

visited.add(op)

return result

def _c_api_shape(self):

"""Returns the TensorShape of this tensor according to the C API."""

c_graph = self._op._graph._c_graph # pylint: disable=protected-access

shape_vector, unknown_shape = c_api.TF_GraphGetTensorShapeHelper(

c_graph, self._as_tf_output())

if unknown_shape:

return tensor_shape.unknown_shape()

else:

shape_vector = [None if d == -1 else d for d in shape_vector]

return tensor_shape.TensorShape(shape_vector)

@property

def _shape(self):

logging.warning("Tensor._shape is private, use Tensor.shape "

"instead. Tensor._shape will eventually be removed.")

return self.shape

@_shape.setter

def _shape(self, value):

raise ValueError(

"Tensor._shape cannot be assigned, use Tensor.set_shape instead.")

def __iter__(self):

if not context.executing_eagerly():

raise TypeError(

"Tensor objects are only iterable when eager execution is "

"enabled. To iterate over this tensor use tf.map_fn.")

shape = self._shape_tuple()

if shape is None:

raise TypeError("Cannot iterate over a tensor with unknown shape.")

if not shape:

raise TypeError("Cannot iterate over a scalar tensor.")

if shape[0] is None:

raise TypeError(

"Cannot iterate over a tensor with unknown first dimension.")

for i in xrange(shape[0]):

yield self[i]

def _shape_as_list(self):

if self.shape.ndims is not None:

return [dim.value for dim in self.shape.dims]

else:

return None

def _shape_tuple(self):

shape = self._shape_as_list()

if shape is None:

return None

return tuple(shape)

def _rank(self):

"""Integer rank of this Tensor, if known, else None.

Returns:

Integer rank or None

"""

return self.shape.ndims

def get_shape(self):

"""Alias of Tensor.shape."""

return self.shape

def set_shape(self, 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:

```python

_, 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.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.shape)

==> TensorShape([Dimension(28), Dimension(28), Dimension(3)])

```

Args:

shape: A `TensorShape` representing the shape of this tensor, a

`TensorShapeProto`, a list, a tuple, or None.

Raises:

ValueError: If `shape` is not compatible with the current shape of

this tensor.

"""

if _USE_C_SHAPES: # pylint: disable=protected-access

# Reset cached shape.

self._shape_val = None

else:

self._shape_val = self.shape.merge_with(shape)

# Update C shape even if _USE_C_SHAPES = False, since we still want

# set_shape to be reflected in the C API graph for when we run it.

if not isinstance(shape, tensor_shape.TensorShape):

shape = tensor_shape.TensorShape(shape)

dim_list = []

if shape.dims is None:

unknown_shape = True

else:

unknown_shape = False

for dim in shape.dims:

if dim.value is None:

dim_list.append(-1)

else:

dim_list.append(dim.value)

try:

c_api.TF_GraphSetTensorShape_wrapper(

self._op._graph._c_graph, # pylint: disable=protected-access

self._as_tf_output(),

dim_list,

unknown_shape)

except errors.InvalidArgumentError as e:

# Convert to ValueError for backwards compatibility.

raise ValueError(str(e))

@property

def value_index(self):

"""The index of this tensor in the outputs of its `Operation`."""

return self._value_index

def consumers(self):

"""Returns a list of `Operation`s that consume this tensor.

Returns:

A list of `Operation`s.

"""

consumer_names = c_api.TF_OperationOutputConsumers_wrapper(

self._as_tf_output())

# pylint: disable=protected-access

return [

self.graph._get_operation_by_name_unsafe(name)

for name in consumer_names

]

# pylint: enable=protected-access

def _as_node_def_input(self):

"""Return a value to use for the NodeDef "input" attribute.

The returned string can be used in a NodeDef "input" attribute

to indicate that the NodeDef uses this Tensor as input.

Raises:

ValueError: if this Tensor's Operation does not have a name.

Returns:

a string.

"""

if not self._op.name:

raise ValueError("Operation was not named: %s" % self._op)

if self._value_index == 0:

return self._op.name

else:

return "%s:%d" % (self._op.name, self._value_index)

def _as_tf_output(self):

# pylint: disable=protected-access

return c_api_util.tf_output(self.op._c_op, self.value_index)

# pylint: enable=protected-access

def __str__(self):

return "Tensor(\"%s\"%s%s%s)" % (

self.name, (", shape=%s" % self.get_shape())

if self.get_shape().ndims is not None else "",

(", dtype=%s" % self._dtype.name)

if self._dtype else "", (", device=%s" % self.device)

if self.device else "")

def __repr__(self):

return "<tf.Tensor '%s' shape=%s dtype=%s>" % (self.name, self.get_shape(),

self._dtype.name)

def __hash__(self):

# Necessary to support Python's collection membership operators

return id(self)

def __eq__(self, other):

# Necessary to support Python's collection membership operators

return id(self) == id(other)

def __copy__(self):

# Make sure _shape_val is computed before we copy.

# TODO(b/77597810): get rid of Tensor copies.

if self._shape_val is None:

set_shape_and_handle_data_for_outputs(self.op)

cls = self.__class__

result = cls.__new__(cls)

result.__dict__.update(self.__dict__)

return result

# NOTE(mrry): This enables the Tensor's overloaded "right" binary

# operators to run when the left operand is an ndarray, because it

# accords the Tensor class higher priority than an ndarray, or a

# numpy matrix.

# TODO(mrry): Convert this to using numpy's __numpy_ufunc__

# mechanism, which allows more control over how Tensors interact

# with ndarrays.

__array_priority__ = 100

@staticmethod

def _override_operator(operator, func):

_override_helper(Tensor, operator, func)

def __bool__(self):

"""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:

```python

if tf.constant(True): # Will raise.

# ...

if tf.constant(5) < tf.constant(7): # Will raise.

# ...

```

This disallows ambiguities between testing the Python value vs testing the

dynamic condition of the `Tensor`.

Raises:

`TypeError`.

"""

raise TypeError("Using a `tf.Tensor` as a Python `bool` is not allowed. "

"Use `if t is not None:` instead of `if t:` to test if a "

"tensor is defined, and use TensorFlow ops such as "

"tf.cond to execute subgraphs conditioned on the value of "

"a tensor.")

def __nonzero__(self):

"""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`.

"""

raise TypeError("Using a `tf.Tensor` as a Python `bool` is not allowed. "

"Use `if t is not None:` instead of `if t:` to test if a "

"tensor is defined, and use TensorFlow ops such as "

"tf.cond to execute subgraphs conditioned on the value of "

"a tensor.")

def eval(self, 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 maps `Tensor` objects to feed values.

See @{tf.Session.run} for a

description of the valid feed values.

session: (Optional.) The `Session` 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.

"""

return _eval_using_default_session(self, feed_dict, self.graph, session)

# TODO(agarwal): consider getting rid of this.

class _EagerTensorBase(Tensor):

"""Base class for EagerTensor."""

@property

def dtype(self):

# Note: using the intern table directly here as this is

# performance-sensitive in some models.

return dtypes._INTERN_TABLE[self._datatype_enum()] # pylint: disable=protected-access

def numpy(self):

"""Returns a numpy array or a scalar with the same contents as the Tensor.

TODO(ashankar,agarwal): Perhaps this should NOT reference the underlying

buffer but instead always explicitly copy? Note that currently it may or may

not copy based on whether the numpy data is properly aligned or not.

Returns:

A numpy array or a scalar. Numpy array may share memory with the

Tensor object. Any changes to one may be reflected in the other. A scalar

value is returned when self has rank 0.

Raises:

ValueError: if the type of this Tensor is not representable in numpy.

"""

if self.dtype == dtypes.resource:

raise ValueError("Resource handles are not convertible to numpy.")

return self._cpu_nograd()._numpy() # pylint: disable=protected-access

# __int__, __float__ and __index__ may copy the tensor to CPU and

# only work for scalars; values are cast as per numpy.

def __int__(self):

return int(self.numpy())

def __float__(self):

return float(self.numpy())

def __index__(self):

return int(self.numpy())

def __array__(self, dtype=None):

return np.array(self.numpy(), dtype=dtype)

def __format__(self, format_spec):

return self.numpy().__format__(format_spec)

def _numpy(self):

raise NotImplementedError()

def __copy__(self):

# Eager Tensors are immutable so it's safe to return themselves as a copy.

return self

def __deepcopy__(self, memo):

# Eager Tensors are immutable so it's safe to return themselves as a copy.

del memo

return self

def _datatype_enum(self):

raise NotImplementedError()

def _shape_tuple(self):

"""The shape of this Tensor, as a tuple.

This is more performant than tuple(shape().as_list()) as it avoids

two list and one object creation. Marked private for now as from an API

perspective, it would be better to have a single performant way of

getting a shape rather than exposing shape() and shape_tuple()

(and heaven forbid, shape_list() etc. as well!). Punting on that for now,

but ideally one would work things out and remove the need for this method.

Returns:

tuple with the shape.

"""

raise NotImplementedError()

def _rank(self):

"""Integer rank of this Tensor.

Unlike regular Tensors, the rank is always known for EagerTensors.

This is more performant than len(self._shape_tuple())

Returns:

Integer rank

"""

raise NotImplementedError()

def _copy_to_device(self, context, device): # pylint: disable=redefined-outer-name

raise NotImplementedError()

def __str__(self):

return "tf.Tensor(%s, shape=%s, dtype=%s)" % (numpy_text(self),

self.shape,

self.dtype.name)

def __repr__(self):

return "<tf.Tensor: id=%s, shape=%s, dtype=%s, numpy=%s>" % (

self._id, self.shape, self.dtype.name, numpy_text(self, is_repr=True))

@staticmethod

def _override_operator(name, func):

setattr(_EagerTensorBase, name, func)

def _copy_nograd(self, ctx=None, device_name=None):

"""Copies tensor to dest device, but doesn't record the operation."""

# pylint: disable=protected-access

# Creates a new tensor on the dest device.

if ctx is None:

ctx = context.context()

if device_name is None:

device_name = ctx.device_name

# pylint: disable=protected-access

try:

new_tensor = self._copy_to_device(context=ctx._handle, device=device_name)

except core._NotOkStatusException as e:

six.raise_from(core._status_to_exception(e.code, e.message), None)

return new_tensor

def _copy(self, ctx=None, device_name=None):

"""Copies tensor to dest device."""

new_tensor = self._copy_nograd(ctx, device_name)

# Record the copy on tape and define backprop copy as well.

if context.executing_eagerly():

self_device = self.device

def grad_fun(dresult):

return [dresult._copy(device_name=self_device)]

tape.record_operation("_copy", [new_tensor], [self], grad_fun)

return new_tensor

# pylint: enable=protected-access

@property

def shape(self):

if self._tensor_shape is None: # pylint: disable=access-member-before-definition

# `_tensor_shape` is declared and defined in the definition of

# `EagerTensor`, in C.

self._tensor_shape = tensor_shape.TensorShape(self._shape_tuple())

return self._tensor_shape

def get_shape(self):

"""Alias of Tensor.shape."""

return self.shape

def _shape_as_list(self):

"""The shape of the tensor as a list."""

return list(self._shape_tuple())

@property

def ndim(self):

"""Returns the number of Tensor dimensions."""

return self.shape.ndims

def _cpu_nograd(self):

"""A copy of this Tensor with contents backed by host memory.

The copy cannot be differentiated through.

Returns:

A CPU-memory backed Tensor object with the same contents as this Tensor.

"""

return self._copy_nograd(context.context(), "CPU:0")

def cpu(self):

"""A copy of this Tensor with contents backed by host memory."""

return self._copy(context.context(), "CPU:0")

def gpu(self, gpu_index=0):

"""A copy of this Tensor with contents backed by memory on the GPU.

Arguments:

gpu_index: Identifies which GPU to place the contents on the returned

Tensor in.

Returns:

A GPU-memory backed Tensor object initialized with the same contents

as this Tensor.

"""

return self._copy(context.context(), "GPU:" + str(gpu_index))

def __bool__(self):

if self._shape_tuple() != (): # pylint: disable=g-explicit-bool-comparison

raise ValueError(

"Non-scalar tensor %s cannot be converted to boolean." % repr(self))

if self.dtype != dtypes.bool:

raise ValueError(

"Non-boolean tensor %s cannot be converted to boolean." % repr(self))

return bool(self.cpu().numpy())

def __nonzero__(self):

return self.__bool__()

def set_shape(self, shape):

if not self.shape.is_compatible_with(shape):

raise ValueError(

"Tensor's shape %s is not compatible with supplied shape %s" %

(self.shape, shape))

# Methods not supported / implemented for Eager Tensors.

@property

def op(self):

raise AttributeError(

"Tensor.op is meaningless when eager execution is enabled.")

@property

def graph(self):

raise AttributeError(

"Tensor.graph is meaningless when eager execution is enabled.")

@property

def name(self):

raise AttributeError(

"Tensor.name is meaningless when eager execution is enabled.")

@property

def value_index(self):

raise AttributeError(

"Tensor.value_index is meaningless when eager execution is enabled.")

def consumers(self):

raise NotImplementedError(

"Tensor.consumers is meaningless when eager execution is enabled.")

def _add_consumer(self, consumer):

raise NotImplementedError(

"_add_consumer not supported when eager execution is enabled.")

def _as_node_def_input(self):

raise NotImplementedError(

"_as_node_def_input not supported when eager execution is enabled.")

def _as_tf_output(self):

raise NotImplementedError(

"_as_tf_output not supported when eager execution is enabled.")

def eval(self, feed_dict=None, session=None):

raise NotImplementedError(

"eval is not supported when eager execution is enabled, "

"is .numpy() what you're looking for?"

)

# This call creates an EagerTensor class, as a subclass of _EagerTensorBase, and

# registers it with the current module.

EagerTensor = c_api.TFE_Py_InitEagerTensor(_EagerTensorBase)

def _TensorTensorConversionFunction(t, dtype=None, name=None, as_ref=False):

_ = name, as_ref

if dtype and not dtype.is_compatible_with(t.dtype):

raise ValueError(

"Tensor conversion requested dtype %s for Tensor with dtype %s: %r" %

(dtype.name, t.dtype.name, str(t)))

return t

_tensor_conversion_func_registry = {

0: [(Tensor, _TensorTensorConversionFunction)]

}

_tensor_conversion_func_cache = {}

_tensor_conversion_func_lock = threading.Lock()

register_dense_tensor_like_type(Tensor)

@tf_export("convert_to_tensor")

def convert_to_tensor(value, dtype=None, name=None, preferred_dtype=None):

"""Converts the given `value` to a `Tensor`.

This function converts Python objects of various types to `Tensor`

objects. It accepts `Tensor` objects, numpy arrays, Python lists,

and Python scalars. For example:

```python

import numpy as np

def my_func(arg):

arg = tf.convert_to_tensor(arg, dtype=tf.float32)

return tf.matmul(arg, arg) + arg

# The following calls are equivalent.

value_1 = my_func(tf.constant([[1.0, 2.0], [3.0, 4.0]]))

value_2 = my_func([[1.0, 2.0], [3.0, 4.0]])

value_3 = my_func(np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32))

```

This function can be useful when composing a new operation in Python

(such as `my_func` in the example above). All standard Python op

constructors apply this function to each of their Tensor-valued

inputs, which allows those ops to accept numpy arrays, Python lists,

and scalars in addition to `Tensor` objects.

Note: This function diverges from default Numpy behavior for `float` and