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

"""Converts a stack extracted using _extract_stack() to a traceback stack.

ret = []

for filename, lineno, name, frame_globals in stack:

linecache.checkcache(filename)

line = linecache.getline(filename, lineno, frame_globals)

if line:

line = line.strip()

else:

line = None

ret.append((filename, lineno, name, line))

"""A lightweight re-implementation of traceback.extract_stack.

# pylint: enable=line-too-long

try:

raise ZeroDivisionError

except ZeroDivisionError:

f = sys.exc_info()[2].tb_frame.f_back

ret = []

while f is not None:

lineno = f.f_lineno

co = f.f_code

filename = co.co_filename

name = co.co_name

frame_globals = f.f_globals

ret.append((filename, lineno, name, frame_globals))

f = f.f_back

ret.reverse()

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

}

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.

self._handle_shape = tensor_shape_pb2.TensorShapeProto()

self._handle_dtype = types_pb2.DT_INVALID

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

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

dtype=None,

name=None,

preferred_dtype=None):

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

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

error_prefix = "" if name is None else "%s: " % name

if dtype is not None:

dtype = dtypes.as_dtype(dtype)

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

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

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

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

if not isinstance(values, collections.Sequence):

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

ret = []

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

dtype=None,

name=None,

preferred_dtype=None):

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

return internal_convert_n_to_tensor(values=values,

dtype=dtype,

name=name,

preferred_dtype=preferred_dtype,

"""Converts the given object to a `Tensor` or an `IndexedSlices`.

return internal_convert_to_tensor_or_indexed_slices(

as_ref=False):

"""Converts the given object to an `Tensor` or an `IndexedSlices`.

if isinstance(value, _TensorLike):

if dtype and not dtypes.as_dtype(dtype).is_compatible_with(value.dtype):

raise ValueError(

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

% (dtypes.as_dtype(dtype).name, value.dtype.name, str(value)))

return value

else:

return internal_convert_to_tensor(value,

dtype=dtype,

name=name,

name=None, as_ref=False):

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

if not isinstance(values, collections.Sequence):

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

ret = []

for i, value in enumerate(values):

if value is None:

ret.append(value)

else:

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

ret.append(

internal_convert_to_tensor_or_indexed_slices(

value, dtype=dtype, name=n, as_ref=as_ref))

"""Converts `values` to a list of `Output` or `IndexedSlices` objects.

return internal_convert_n_to_tensor_or_indexed_slices(

priority=100):

"""Registers a function for converting objects of `base_type` to `Tensor`.

if not (isinstance(base_type, type) or

(isinstance(base_type, tuple)

and all(isinstance(x, type) for x in base_type))):

raise TypeError("base_type must be a type or a tuple of types.")

if not callable(conversion_func):

raise TypeError("conversion_func must be callable.")

try:

funcs_at_priority = _tensor_conversion_func_registry[priority]

except KeyError:

funcs_at_priority = []

_tensor_conversion_func_registry[priority] = funcs_at_priority

"""A sparse representation of a set of tensor slices at given indices.