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

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)

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

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

if conv_fn and callable(conv_fn):

return conv_fn()

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

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

try:

if not isinstance(tensor_type.name, property):

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

except AttributeError:

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

try:

if not isinstance(tensor_type.dtype, property):

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

except AttributeError:

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

# 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

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

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

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)

self._shape = tensor_shape.unknown_shape()

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

# to easily navigate a computation graph.

self._consumers = []

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

return self._shape

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 get_shape(self):

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

return self.shape

def set_shape(self, shape):

"""Updates the shape of this tensor.

self._shape = self._shape.merge_with(shape)

@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.

return self._consumers

def _add_consumer(self, consumer):

"""Add a consumer to this tensor.

if not isinstance(consumer, Operation):

raise TypeError("Consumer must be an Operation: %s" % consumer)

self._consumers.append(consumer)

def _as_node_def_input(self):

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

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

assert self.op._c_op # pylint: disable=protected-access

tf_output = c_api.TF_Output()

tf_output.oper = self.op._c_op # pylint: disable=protected-access

tf_output.index = self.value_index

return tf_output

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)

# 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 __iter__(self):

"""Dummy method to prevent iteration. Do not call.

raise TypeError("'Tensor' object is not iterable.")

def __bool__(self):

"""Dummy method to prevent a tensor from being used as a Python `bool`.

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

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

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

def _dup(self):

ret = copy.copy(self)

ret._id = uid() # pylint: disable=protected-access

"""Base class for EagerTensor."""

@staticmethod

def _delete_trace(tid):

"""Helper function to be called by __del__ of the subclass."""

tape.delete_trace(tid)

@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_text(self, is_repr=False):

if self.dtype.is_numpy_compatible:

numpy_text = repr(self.numpy()) if is_repr else str(self.numpy())

else:

numpy_text = "<unprintable>"

if "\n" in numpy_text:

numpy_text = "\n" + numpy_text

return numpy_text

def numpy(self):

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

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

def _numpy(self):

raise NotImplementedError()

def _datatype_enum(self):

raise NotImplementedError()

def _shape_tuple(self):

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

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)" % (self._numpy_text(),

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, self._numpy_text(is_repr=True))

@staticmethod

def _override_operator(name, func):

setattr(_EagerTensorBase, name, func)

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

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

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

if core.active_trace() is not None:

core.active_trace().record_tensor("COPY",

tensor_id(new_tensor),

new_tensor.device,

new_tensor.shape.num_elements())

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

if not context.in_graph_mode():

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

def _dup(self):

return self._copy(device_name=self.device)

@property

def shape(self):

return tensor_shape.TensorShape(self._shape_tuple())

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

def as_cpu_tensor(self):

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

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

def as_gpu_tensor(self, gpu_index=0):

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

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.as_cpu_tensor().numpy())

def __nonzero__(self):

return self.__bool__()

# Methods not supported / implemented for Eager Tensors.

@property

def op(self):

raise NotImplementedError("op not supported for Eager Tensors.")

@property

def graph(self):

raise NotImplementedError("graph not supported for Eager Tensors.")

@property

def name(self):

raise NotImplementedError("name not supported for Eager Tensors.")

def set_shape(self, shape):

raise NotImplementedError("set_shape not supported for Eager Tensors.")

@property

def value_index(self):

raise NotImplementedError("value_index not supported for Eager Tensors.")

def consumers(self):

raise NotImplementedError("consumers not supported for Eager Tensors.")

def _add_consumer(self, consumer):

raise NotImplementedError("_add_consumer not supported for Eager Tensors.")

def _as_node_def_input(self):

raise NotImplementedError(

"_as_node_def_input not supported for Eager Tensors.")

def _as_tf_output(self):

raise NotImplementedError("_as_tf_output not supported for Eager Tensors.")

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

_ = 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)))

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

return internal_convert_to_tensor(

value=value,

dtype=dtype,

name=name,

preferred_dtype=preferred_dtype,

dtype=None,

name=None,

as_ref=False,

preferred_dtype=None,

ctx=None):

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

if ctx is None: ctx = context.context()

if ctx.in_eager_mode():

# Fast path for EagerTensors that don't need any conversion.

if isinstance(value, EagerTensor):

# Note that we don't check that value's dtype matches the dtype

# argument. We exepct that the C runtime will do that checking

# when we execute the kernel.

return value

if dtype is not None:

dtype = dtypes.as_dtype(dtype)

unwrapped_type = type(value)

conversion_func_list = _tensor_conversion_func_cache.get(unwrapped_type, None)

if conversion_func_list is None:

with _tensor_conversion_func_lock:

conversion_func_list = []

for _, funcs_at_priority in sorted(

_tensor_conversion_func_registry.items()):

for base_type, conversion_func in funcs_at_priority:

if isinstance(value, base_type):

conversion_func_list.append((base_type, conversion_func))

_tensor_conversion_func_cache[unwrapped_type] = conversion_func_list

for base_type, conversion_func in conversion_func_list:

# If dtype is None but preferred_dtype is not None, we try to

# cast to preferred_dtype first.

ret = None

if dtype is None and preferred_dtype is not None:

try:

ret = conversion_func(

value, dtype=preferred_dtype, name=name, as_ref=as_ref)

except (TypeError, ValueError, errors.UnimplementedError,

errors.InvalidArgumentError):

# Could not coerce the conversion to use the preferred dtype.

ret = None

if ret is not None and ret is not NotImplemented:

if (ret.dtype.base_dtype !=

dtypes.as_dtype(preferred_dtype).base_dtype):

raise TypeError("convert_to_tensor did not convert to "

"the preferred dtype: %s vs %s " %

(ret.dtype.base_dtype,

dtypes.as_dtype(preferred_dtype).base_dtype))

if ret is None:

ret = conversion_func(value, dtype=dtype, name=name, as_ref=as_ref)

if ret is NotImplemented:

continue

if not isinstance(ret, Tensor):

raise RuntimeError(

"%sConversion function %r for type %s returned non-Tensor: %r" %

(_error_prefix(name), conversion_func, base_type, ret))

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

raise RuntimeError(

"%sConversion function %r for type %s returned incompatible "

"dtype: requested = %s, actual = %s" %

(_error_prefix(name), conversion_func, base_type, dtype.name,

ret.dtype.name))

return ret

raise TypeError("%sCannot convert %r with type %s to Tensor: "

"no conversion function registered." %

dtype=None,

name=None,

as_ref=False,

preferred_dtype=None,

ctx=None):

"""Converts `values` to a list of `Tensor` objects.

if not isinstance(values, collections.Sequence):

raise TypeError("values must be a list.")

ret = []

if ctx is None: ctx = context.context()

for i, value in enumerate(values):

n = None if name is None else "%s_%d" % (name, i)

ret.append(

internal_convert_to_tensor(

value,

dtype=dtype,

name=n,

as_ref=as_ref,

preferred_dtype=preferred_dtype,

ctx=ctx))

"""Converts `values` to a list of `Tensor` objects.