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

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

"""Support for manipulating tensors.

See the @{$python/array_ops} guide.

@@string_to_number

@@to_double

@@to_float

@@to_bfloat16

@@to_int32

@@to_int64

@@cast

@@bitcast

@@saturate_cast

@@broadcast_dynamic_shape

@@broadcast_static_shape

@@shape

@@shape_n

@@size

@@rank

@@reshape

@@squeeze

@@expand_dims

@@meshgrid

@@slice

@@strided_slice

@@split

@@tile

@@pad

@@concat

@@stack

@@parallel_stack

@@unstack

@@reverse_sequence

@@reverse

@@reverse_v2

@@transpose

@@extract_image_patches

@@space_to_batch_nd

@@space_to_batch

@@required_space_to_batch_paddings

@@batch_to_space_nd

@@batch_to_space

@@space_to_depth

@@depth_to_space

@@gather

@@gather_nd

@@unique_with_counts

@@scatter_nd

@@dynamic_partition

@@dynamic_stitch

@@boolean_mask

@@one_hot

@@sequence_mask

@@dequantize

@@quantize_v2

@@quantized_concat

@@setdiff1d

@@fake_quant_with_min_max_args

@@fake_quant_with_min_max_args_gradient

@@fake_quant_with_min_max_vars

@@fake_quant_with_min_max_vars_gradient

@@fake_quant_with_min_max_vars_per_channel

@@fake_quant_with_min_max_vars_per_channel_gradient

"""

from __future__ import absolute_import

from __future__ import division

from __future__ import print_function

import sys

import numpy as np

from tensorflow.python.eager import context

from tensorflow.python.framework import common_shapes

from tensorflow.python.framework import constant_op

from tensorflow.python.framework import dtypes

from tensorflow.python.framework import ops

from tensorflow.python.framework import sparse_tensor

from tensorflow.python.framework import tensor_shape

from tensorflow.python.framework import tensor_util

# 'Constant' gets imported in the module 'array_ops'.

from tensorflow.python.framework.constant_op import constant

from tensorflow.python.ops import gen_array_ops

from tensorflow.python.ops import gen_math_ops

# go/tf-wildcard-import

# pylint: disable=wildcard-import

from tensorflow.python.ops.gen_array_ops import *

from tensorflow.python.util import deprecation

# pylint: enable=wildcard-import

# Used for slicing to specify a new 1 size dimension

newaxis = None

# We override the 'slice' for the "slice" op, so we keep python's

# existing 'slice' for later use in this module.

_baseslice = slice

def identity(input, name=None): # pylint: disable=redefined-builtin

r"""Return a tensor with the same shape and contents as input.

Args:

input: A `Tensor`.

name: A name for the operation (optional).

Returns:

A `Tensor`. Has the same type as `input`.

"""

if context.in_graph_mode():

return gen_array_ops.identity(input, name=name)

else:

if context.context().device_name != input.device:

return input._copy() # pylint: disable=protected-access

return input

# pylint: disable=redefined-builtin,protected-access

def expand_dims(input, axis=None, name=None, dim=None):

"""Inserts a dimension of 1 into a tensor's shape.

Given a tensor `input`, this operation inserts a dimension of 1 at the

dimension index `axis` of `input`'s shape. The dimension index `axis` starts

at zero; if you specify a negative number for `axis` it is counted backward

from the end.

This operation is useful if you want to add a batch dimension to a single

element. For example, if you have a single image of shape `[height, width,

channels]`, you can make it a batch of 1 image with `expand_dims(image, 0)`,

which will make the shape `[1, height, width, channels]`.

Other examples:

```python

# 't' is a tensor of shape [2]

tf.shape(tf.expand_dims(t, 0)) # [1, 2]

tf.shape(tf.expand_dims(t, 1)) # [2, 1]

tf.shape(tf.expand_dims(t, -1)) # [2, 1]

# 't2' is a tensor of shape [2, 3, 5]

tf.shape(tf.expand_dims(t2, 0)) # [1, 2, 3, 5]

tf.shape(tf.expand_dims(t2, 2)) # [2, 3, 1, 5]

tf.shape(tf.expand_dims(t2, 3)) # [2, 3, 5, 1]

```

This operation requires that:

`-1-input.dims() <= dim <= input.dims()`

This operation is related to `squeeze()`, which removes dimensions of

size 1.

Args:

input: A `Tensor`.

axis: 0-D (scalar). Specifies the dimension index at which to

expand the shape of `input`. Must be in the range

`[-rank(input) - 1, rank(input)]`.

name: The name of the output `Tensor`.

dim: 0-D (scalar). Equivalent to `axis`, to be deprecated.

Returns:

A `Tensor` with the same data as `input`, but its shape has an additional

dimension of size 1 added.

Raises:

ValueError: if both `dim` and `axis` are specified.

"""

# TODO(aselle): Remove argument dim

if dim is not None:

if axis is not None:

raise ValueError("can't specify both 'dim' and 'axis'")

axis = dim

return gen_array_ops._expand_dims(input, axis, name)

# pylint: enable=redefined-builtin,protected-access

# Aliases for some automatically-generated names.

# pylint: disable=protected-access

@deprecation.deprecated(

"2016-11-30",

"This op will be removed after the deprecation date. "

"Please switch to tf.setdiff1d().")

def listdiff(x, y, out_idx=None, name=None):

return gen_array_ops._list_diff(x, y, out_idx, name)

listdiff.__doc__ = gen_array_ops._list_diff.__doc__ + "\n" + listdiff.__doc__

# pylint: enable=protected-access

# pylint: disable=undefined-variable,protected-access

def setdiff1d(x, y, index_dtype=dtypes.int32, name=None):

return gen_array_ops._list_diff(x, y, index_dtype, name)

setdiff1d.__doc__ = gen_array_ops._list_diff.__doc__

# pylint: enable=protected-access

def broadcast_dynamic_shape(shape_x, shape_y):

# pylint: disable=protected-access

"""Returns the broadcasted dynamic shape between `shape_x` and `shape_y`.

Args:

shape_x: A rank 1 integer `Tensor`, representing the shape of x.

shape_y: A rank 1 integer `Tensor`, representing the shape of y.

Returns:

A rank 1 integer `Tensor` representing the broadcasted shape.

"""

return gen_array_ops._broadcast_args(shape_x, shape_y)

# pylint: enable=protected-access

def broadcast_static_shape(shape_x, shape_y):

"""Returns the broadcasted static shape between `shape_x` and `shape_y`.

Args:

shape_x: A `TensorShape`

shape_y: A `TensorShape`

Returns:

A `TensorShape` representing the broadcasted shape.

Raises:

ValueError: If the two shapes can not be broadcasted.

"""

return common_shapes.broadcast_shape(shape_x, shape_y)

def shape(input, name=None, out_type=dtypes.int32):

# pylint: disable=redefined-builtin

"""Returns the shape of a tensor.

This operation returns a 1-D integer tensor representing the shape of `input`.

For example:

```python

t = tf.constant([[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]])

tf.shape(t) # [2, 2, 3]

```

Args:

input: A `Tensor` or `SparseTensor`.

name: A name for the operation (optional).

out_type: (Optional) The specified output type of the operation

(`int32` or `int64`). Defaults to `tf.int32`.

Returns:

A `Tensor` of type `out_type`.

"""

return shape_internal(input, name, optimize=True, out_type=out_type)

def shape_internal(input, name=None, optimize=True, out_type=dtypes.int32):

# pylint: disable=redefined-builtin

"""Returns the shape of a tensor.

Args:

input: A `Tensor` or `SparseTensor`.

name: A name for the operation (optional).

optimize: if true, encode the shape as a constant when possible.

out_type: (Optional) The specified output type of the operation

(`int32` or `int64`). Defaults to tf.int32.

Returns:

A `Tensor` of type `out_type`.

"""

with ops.name_scope(name, "Shape", [input]) as name:

if isinstance(input, (sparse_tensor.SparseTensor,

sparse_tensor.SparseTensorValue)):

return gen_math_ops.cast(input.dense_shape, out_type)

else:

if context.in_graph_mode():

input_tensor = ops.convert_to_tensor(input)

input_shape = input_tensor.get_shape()

if optimize and input_shape.is_fully_defined():

return constant(input_shape.as_list(), out_type, name=name)

return gen_array_ops.shape(input, name=name, out_type=out_type)

def size(input, name=None, out_type=dtypes.int32):

# pylint: disable=redefined-builtin

"""Returns the size of a tensor.

This operation returns an integer representing the number of elements in

`input`.

For example:

```python

t = tf.constant([[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]])

tf.size(t) # 12

```

Args:

input: A `Tensor` or `SparseTensor`.

name: A name for the operation (optional).

out_type: (Optional) The specified output type of the operation

(`int32` or `int64`). Defaults to tf.int32.

Returns:

A `Tensor` of type `out_type`. Defaults to tf.int32.

"""

return size_internal(input, name, optimize=True, out_type=out_type)

def size_internal(input, name=None, optimize=True, out_type=dtypes.int32):

# pylint: disable=redefined-builtin,protected-access

"""Returns the size of a tensor.

Args:

input: A `Tensor` or `SparseTensor`.

name: A name for the operation (optional).

optimize: if true, encode the size as a constant when possible.

out_type: (Optional) The specified output type of the operation

(`int32` or `int64`). Defaults to tf.int32.

Returns:

A `Tensor` of type `out_type`.

"""

with ops.name_scope(name, "Size", [input]) as name:

if isinstance(input, (sparse_tensor.SparseTensor,

sparse_tensor.SparseTensorValue)):

return gen_math_ops._prod(

gen_math_ops.cast(input.dense_shape, out_type), 0, name=name)

else:

input_tensor = ops.convert_to_tensor(input)

input_shape = input_tensor.get_shape()

if optimize and input_shape.is_fully_defined():

return constant(input_shape.num_elements(), out_type, name=name)

return gen_array_ops.size(input, name=name, out_type=out_type)

def rank(input, name=None):

# pylint: disable=redefined-builtin

"""Returns the rank of a tensor.

Returns a 0-D `int32` `Tensor` representing the rank of `input`.

For example:

```python

# shape of tensor 't' is [2, 2, 3]

t = tf.constant([[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]])

tf.rank(t) # 3

```

**Note**: The rank of a tensor is not the same as the rank of a matrix. The

rank of a tensor is the number of indices required to uniquely select each

element of the tensor. Rank is also known as "order", "degree", or "ndims."

Args:

input: A `Tensor` or `SparseTensor`.

name: A name for the operation (optional).

Returns:

A `Tensor` of type `int32`.

@compatibility(numpy)

Equivalent to np.ndim

@end_compatibility

"""

return rank_internal(input, name, optimize=True)

def rank_internal(input, name=None, optimize=True):

# pylint: disable=redefined-builtin

"""Returns the rank of a tensor.

Args:

input: A `Tensor` or `SparseTensor`.

name: A name for the operation (optional).

optimize: if true, encode the rank as a constant when possible.

Returns:

A `Tensor` of type `int32`.

"""

with ops.name_scope(name, "Rank", [input]) as name:

if isinstance(input, (sparse_tensor.SparseTensor,

sparse_tensor.SparseTensorValue)):

return gen_array_ops.size(input.dense_shape, name=name)

else:

input_tensor = ops.convert_to_tensor(input)

input_shape = input_tensor.get_shape()

if optimize and input_shape.ndims is not None:

return constant(input_shape.ndims, dtypes.int32, name=name)

return gen_array_ops.rank(input, name=name)

def _SliceHelper(tensor, slice_spec, var=None):

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

```python

# 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()) # => [[[1,2,3], [4,5,6], [7,8,9]]]

print(foo[:, tf.newaxis, :].eval()) # => [[[1,2,3]], [[4,5,6]], [[7,8,9]]]

print(foo[:, :, tf.newaxis].eval()) # => [[[1],[2],[3]], [[4],[5],[6]],

[[7],[8],[9]]]

# Ellipses (3 equivalent operations)

foo = tf.constant([[1,2,3], [4,5,6], [7,8,9]])

print(foo[tf.newaxis, :, :].eval()) # [[[1,2,3], [4,5,6], [7,8,9]]]

print(foo[tf.newaxis, ...].eval()) # [[[1,2,3], [4,5,6], [7,8,9]]]

print(foo[tf.newaxis].eval()) # [[[1,2,3], [4,5,6], [7,8,9]]]

```

Notes:

- `tf.newaxis` is `None` 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 read-only 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.

"""

if not isinstance(slice_spec, (list, tuple)):

slice_spec = [slice_spec]

begin, end, strides = [], [], []

index = 0

new_axis_mask, shrink_axis_mask = 0, 0

begin_mask, end_mask = 0, 0

ellipsis_mask = 0

for s in slice_spec:

if isinstance(s, _baseslice):

# python doesn't always use None when constructing ranges

# for example a[:] gives slice(None,sys.maxsize,None)

# whereas a[::1] gives slice(None,None,None)

if s.start is not None and s.start is not sys.maxsize:

begin.append(s.start)

else:

begin.append(0)

begin_mask |= (1 << index)

if s.stop is not None and s.stop != sys.maxsize:

end.append(s.stop)

else:

end.append(0)

end_mask |= (1 << index)

if s.step is not None:

strides.append(s.step)

else:

strides.append(1)

elif s is Ellipsis:

begin.append(0)

end.append(0)

strides.append(1)

ellipsis_mask |= (1 << index)

elif s is newaxis:

begin.append(0)

end.append(0)

strides.append(1)

new_axis_mask |= (1 << index)

else:

begin.append(s)

end.append(s + 1)

strides.append(1)

shrink_axis_mask |= (1 << index)

index += 1

# stack possibly involves no tensors, so we must use op_scope correct graph.

with ops.name_scope(None, "strided_slice",

[tensor] + begin + end + strides) as name:

if begin:

packed_begin, packed_end, packed_strides = (stack(begin), stack(end),

stack(strides))

if (packed_begin.dtype == dtypes.int64 or

packed_end.dtype == dtypes.int64 or

packed_strides.dtype == dtypes.int64):

if packed_begin.dtype != dtypes.int64:

packed_begin = gen_math_ops.cast(packed_begin, dtypes.int64)

if packed_end.dtype != dtypes.int64:

packed_end = gen_math_ops.cast(packed_end, dtypes.int64)

if packed_strides.dtype != dtypes.int64:

packed_strides = gen_math_ops.cast(packed_strides, dtypes.int64)

else:

var_empty = constant([], dtype=dtypes.int32)

packed_begin = packed_end = packed_strides = var_empty

return strided_slice(

tensor,

packed_begin,

packed_end,

packed_strides,

begin_mask=begin_mask,

end_mask=end_mask,

shrink_axis_mask=shrink_axis_mask,

new_axis_mask=new_axis_mask,

ellipsis_mask=ellipsis_mask,

var=var,

name=name)

# pylint: disable=undefined-variable,protected-access

def slice(input_, begin, size, name=None):

# pylint: disable=redefined-builtin

"""Extracts a slice from a tensor.

This operation extracts a slice of size `size` from a tensor `input` starting

at the location specified by `begin`. The slice `size` is represented as a

tensor shape, where `size[i]` is the number of elements of the 'i'th dimension

of `input` that you want to slice. The starting location (`begin`) for the

slice is represented as an offset in each dimension of `input`. In other

words, `begin[i]` is the offset into the 'i'th dimension of `input` that you

want to slice from.

Note that @{tf.Tensor.__getitem__} is typically a more pythonic way to

perform slices, as it allows you to write `foo[3:7, :-2]` instead of

`tf.slice([3, 0], [4, foo.get_shape()[1]-2])`.

`begin` is zero-based; `size` is one-based. If `size[i]` is -1,

all remaining elements in dimension i are included in the

slice. In other words, this is equivalent to setting:

`size[i] = input.dim_size(i) - begin[i]`

This operation requires that:

`0 <= begin[i] <= begin[i] + size[i] <= Di for i in [0, n]`

For example:

```python

t = tf.constant([[[1, 1, 1], [2, 2, 2]],

[[3, 3, 3], [4, 4, 4]],

[[5, 5, 5], [6, 6, 6]]])

tf.slice(t, [1, 0, 0], [1, 1, 3]) # [[[3, 3, 3]]]

tf.slice(t, [1, 0, 0], [1, 2, 3]) # [[[3, 3, 3],

# [4, 4, 4]]]

tf.slice(t, [1, 0, 0], [2, 1, 3]) # [[[3, 3, 3]],

# [[5, 5, 5]]]

```

Args:

input_: A `Tensor`.

begin: An `int32` or `int64` `Tensor`.

size: An `int32` or `int64` `Tensor`.

name: A name for the operation (optional).

Returns:

A `Tensor` the same type as `input`.

"""

return gen_array_ops._slice(input_, begin, size, name=name)

# pylint: disable=invalid-name

def strided_slice(input_,

begin,

end,

strides=None,

begin_mask=0,

end_mask=0,

ellipsis_mask=0,

new_axis_mask=0,

shrink_axis_mask=0,

var=None,

name=None):

"""Extracts a strided slice of a tensor (generalized python array indexing).

**Most users will want to use @{tf.Tensor.__getitem__} and

@{tf.Variable.__getitem__}.** That allows NumPy style slicing syntax (i.e.

`tensor[..., 3:4:-1, tf.newaxis, 3]`).

This op is the low-level interface that are used to implement operators.

Those interfaces are much more friendly, and highly recommended.

To a first order, this operation extracts a slice of size `end - begin`

from a tensor `input`

starting at the location specified by `begin`. The slice continues by adding

`stride` to the `begin` index until all dimensions are not less than `end`.

Note that components of stride can be negative, which causes a reverse

slice.

This operation can be thought of an encoding of a numpy style sliced

range. Given a python slice input[<spec0>, <spec1>, ..., <specn>]

this function will be called as follows.

`begin`, `end`, and `strides` will be all length n. n is in general

not the same dimensionality as `input`.

For the ith spec,

`begin_mask`, `end_mask`, `ellipsis_mask`, `new_axis_mask`,

and `shrink_axis_mask` will have the ith bit corresponding to

the ith spec.

If the ith bit of `begin_mask` is non-zero, `begin[i]` is ignored and

the fullest possible range in that dimension is used instead.

`end_mask` works analogously, except with the end range.

`foo[5:,:,:3]` on a 7x8x9 tensor is equivalent to `foo[5:7,0:8,0:3]`.

`foo[::-1]` reverses a tensor with shape 8.

If the ith bit of `ellipsis_mask` is non-zero, as many unspecified dimensions

as needed will be inserted between other dimensions. Only one

non-zero bit is allowed in `ellipsis_mask`.

For example `foo[3:5,...,4:5]` on a shape 10x3x3x10 tensor is

equivalent to `foo[3:5,:,:,4:5]` and

`foo[3:5,...]` is equivalent to `foo[3:5,:,:,:]`.

If the ith bit of `new_axis_mask` is one, then `begin`,

`end`, and `stride` are ignored and a new length 1 dimension is

added at this point in the output tensor.

For example `foo[3:5,4]` on a 10x8 tensor produces a shape 2 tensor

whereas `foo[3:5,4:5]` produces a shape 2x1 tensor with shrink_mask

being 1<<1 == 2.

If the ith bit of `shrink_axis_mask` is one, then `begin`,

`end[i]`, and `stride[i]` are used to do a slice in the appropriate

dimension, but the output tensor will be reduced in dimensionality

by one. This is only valid if the ith entry of slice[i]==1.

NOTE: `begin` and `end` are zero-indexed`.

`strides` entries must be non-zero.

```python

t = tf.constant([[[1, 1, 1], [2, 2, 2]],

[[3, 3, 3], [4, 4, 4]],

[[5, 5, 5], [6, 6, 6]]])

tf.strided_slice(t, [1, 0, 0], [2, 1, 3], [1, 1, 1]) # [[[3, 3, 3]]]

tf.strided_slice(t, [1, 0, 0], [2, 2, 3], [1, 1, 1]) # [[[3, 3, 3],

# [4, 4, 4]]]

tf.strided_slice(t, [1, -1, 0], [2, -3, 3], [1, -1, 1]) # [[[4, 4, 4],

# [3, 3, 3]]]

```

Args:

input_: A `Tensor`.

begin: An `int32` or `int64` `Tensor`.

end: An `int32` or `int64` `Tensor`.

strides: An `int32` or `int64` `Tensor`.

begin_mask: An `int32` mask.

end_mask: An `int32` mask.

ellipsis_mask: An `int32` mask.

new_axis_mask: An `int32` mask.

shrink_axis_mask: An `int32` mask.

var: The variable corresponding to `input_` or None

name: A name for the operation (optional).

Returns:

A `Tensor` the same type as `input`.

"""

if strides is None:

strides = ones_like(begin)

op = gen_array_ops.strided_slice(

input=input_,

begin=begin,

end=end,

strides=strides,

name=name,

begin_mask=begin_mask,

end_mask=end_mask,

ellipsis_mask=ellipsis_mask,

new_axis_mask=new_axis_mask,

shrink_axis_mask=shrink_axis_mask)

parent_name = name

def assign(val, name=None):

"""Closure that holds all the arguments to create an assignment."""

if var is None:

raise ValueError("Sliced assignment is only supported for variables")

if name is None:

name = parent_name + "_assign"

return var._strided_slice_assign(

begin=begin,

end=end,

strides=strides,

value=val,

name=name,

begin_mask=begin_mask,

end_mask=end_mask,

ellipsis_mask=ellipsis_mask,

new_axis_mask=new_axis_mask,

shrink_axis_mask=shrink_axis_mask)

if context.in_graph_mode():

# TODO(apassos) In eager mode assignment will be done by overriding

# __setitem__ instead.

op.assign = assign

return op

def _SliceHelperVar(var, slice_spec):

"""Creates a slice helper object given a variable.

This allows creating a sub-tensor from part of the current contents

of a variable. See ${tf.Tensor$`Tensor.__getitem__`}

for detailed examples of slicing.

This function in addition also allows assignment to a sliced range.

This is similar to `__setitem__` functionality in Python. However,

the syntax is different so that the user can capture the assignment

operation for grouping or passing to `sess.run()`.

For example,

```python

import tensorflow as tf

A = tf.Variable([[1,2,3], [4,5,6], [7,8,9]], dtype=tf.float32)

with tf.Session() as sess:

sess.run(tf.global_variables_initializer())

print(sess.run(A[:2, :2])) # => [[1,2], [4,5]]

op = A[:2,:2].assign(22. * tf.ones((2, 2)))

print(sess.run(op)) # => [[22, 22, 3], [22, 22, 6], [7,8,9]]

```

Note that assignments currently do not support NumPy broadcasting

semantics.

Args:

var: An `ops.Variable` object.

slice_spec: The arguments to `Tensor.__getitem__`.

Returns:

The appropriate slice of "tensor", based on "slice_spec".

As an operator. The operator also has a `assign()` method

that can be used to generate an assignment operator.

Raises:

ValueError: If a slice range is negative size.

TypeError: If the slice indices aren't int, slice, or Ellipsis.

"""

return _SliceHelper(var._AsTensor(), slice_spec, var)

ops.Tensor._override_operator("__getitem__", _SliceHelper)

def parallel_stack(values, name="parallel_stack"):

"""Stacks a list of rank-`R` tensors into one rank-`(R+1)` tensor in parallel.

Requires that the shape of inputs be known at graph construction time.

Packs the list of tensors in `values` into a tensor with rank one higher than

each tensor in `values`, by packing them along the first dimension.

Given a list of length `N` of tensors of shape `(A, B, C)`; the `output`

tensor will have the shape `(N, A, B, C)`.

For example:

```python

x = tf.constant([1, 4])

y = tf.constant([2, 5])

z = tf.constant([3, 6])

tf.parallel_stack([x, y, z]) # [[1, 4], [2, 5], [3, 6]]

```

The difference between `stack` and `parallel_stack` is that `stack` requires

all the inputs be computed before the operation will begin but doesn't require

that the input shapes be known during graph construction.

`parallel_stack` will copy pieces of the input into the output as they become

available, in some situations this can provide a performance benefit.

Unlike `stack`, `parallel_stack` does NOT support backpropagation.

This is the opposite of unstack. The numpy equivalent is

tf.parallel_stack([x, y, z]) = np.asarray([x, y, z])

Args:

values: A list of `Tensor` objects with the same shape and type.

name: A name for this operation (optional).

Returns:

output: A stacked `Tensor` with the same type as `values`.

"""

with ops.name_scope(name):

value_t = ops.convert_to_tensor(values[0])

value_shape = ops.convert_to_tensor(value_t).get_shape()

output_shape = tensor_shape.TensorShape([len(values)])

output_shape = output_shape.concatenate(value_shape)

# expand_dims converts concat to stack.

return gen_array_ops._parallel_concat(

[expand_dims(value, 0) for value in values], shape=output_shape)

def stack(values, axis=0, name="stack"):

"""Stacks a list of rank-`R` tensors into one rank-`(R+1)` tensor.

Packs the list of tensors in `values` into a tensor with rank one higher than

each tensor in `values`, by packing them along the `axis` dimension.

Given a list of length `N` of tensors of shape `(A, B, C)`;

if `axis == 0` then the `output` tensor will have the shape `(N, A, B, C)`.

if `axis == 1` then the `output` tensor will have the shape `(A, N, B, C)`.

Etc.

For example:

```python

x = tf.constant([1, 4])

y = tf.constant([2, 5])

z = tf.constant([3, 6])

tf.stack([x, y, z]) # [[1, 4], [2, 5], [3, 6]] (Pack along first dim.)

tf.stack([x, y, z], axis=1) # [[1, 2, 3], [4, 5, 6]]

```

This is the opposite of unstack. The numpy equivalent is

```python

tf.stack([x, y, z]) = np.asarray([x, y, z])

```

Args:

values: A list of `Tensor` objects with the same shape and type.

axis: An `int`. The axis to stack along. Defaults to the first dimension.

Negative values wrap around, so the valid range is `[-(R+1), R+1)`.

name: A name for this operation (optional).

Returns:

output: A stacked `Tensor` with the same type as `values`.

Raises:

ValueError: If `axis` is out of the range [-(R+1), R+1).

"""

if axis == 0:

try:

# If the input is a constant list, it can be converted to a constant op

return ops.convert_to_tensor(values, name=name)

except (TypeError, ValueError):

pass # Input list contains non-constant tensors

value_shape = ops.convert_to_tensor(values[0], name=name).get_shape()

if value_shape.ndims is not None:

expanded_num_dims = value_shape.ndims + 1

if axis < -expanded_num_dims or axis >= expanded_num_dims:

raise ValueError("axis = %d not in [%d, %d)" % (axis, -expanded_num_dims,

expanded_num_dims))

return gen_array_ops._pack(values, axis=axis, name=name)

# pylint: disable=invalid-name

def _autopacking_helper(list_or_tuple, dtype, name):

"""Converts the given list or tuple to a tensor by packing.

Args:

list_or_tuple: A (possibly nested) list or tuple containing a tensor.

dtype: The element type of the returned tensor.

name: A name for the returned tensor.

Returns:

A `tf.Tensor` with value equivalent to `list_or_tuple`.

"""

must_pack = False

converted_elems = []

with ops.name_scope(name) as scope:

for i, elem in enumerate(list_or_tuple):

if ops.is_dense_tensor_like(elem):

if dtype is not None and elem.dtype.base_dtype != dtype:

raise TypeError("Cannot convert a list containing a tensor of dtype "

"%s to %s (Tensor is: %r)" % (elem.dtype, dtype,

elem))

converted_elems.append(elem)

must_pack = True

elif isinstance(elem, (list, tuple)):

converted_elem = _autopacking_helper(elem, dtype, str(i))

if ops.is_dense_tensor_like(converted_elem):

must_pack = True

converted_elems.append(converted_elem)

else:

converted_elems.append(elem)

if must_pack:

elems_as_tensors = []

for i, elem in enumerate(converted_elems):

if ops.is_dense_tensor_like(elem):

elems_as_tensors.append(elem)

else:

# NOTE(mrry): This is inefficient, but it enables us to

# handle the case where the list arguments are other

# convertible-to-tensor types, such as numpy arrays.

elems_as_tensors.append(

constant_op.constant(elem, dtype=dtype, name=str(i)))

return gen_array_ops._pack(elems_as_tensors, name=scope)

else:

return converted_elems

def _get_dtype_from_nested_lists(list_or_tuple):

"""Returns the dtype of any tensor-like object in `list_or_tuple`, if found.

Args:

list_or_tuple: A list or tuple representing an object that can be

converted to a `tf.Tensor`.

Returns:

The dtype of any tensor-like object in `list_or_tuple`, or `None` if no

such object exists.

"""

for elem in list_or_tuple:

if ops.is_dense_tensor_like(elem):

return elem.dtype.base_dtype

elif isinstance(elem, (list, tuple)):

maybe_dtype = _get_dtype_from_nested_lists(elem)

if maybe_dtype is not None:

return maybe_dtype

return None

def _autopacking_conversion_function(v, dtype=None, name=None, as_ref=False):

"""Tensor conversion function that automatically packs arguments."""

if as_ref:

return NotImplemented

inferred_dtype = _get_dtype_from_nested_lists(v)

if inferred_dtype is None:

# We did not find any tensor-like objects in the nested lists, so defer to

# other conversion functions.

return NotImplemented

if dtype is not None and dtype != inferred_dtype:

return NotImplemented

return _autopacking_helper(v, inferred_dtype, name or "packed")

# pylint: enable=invalid-name

# NOTE: Register this conversion function to run *before* one that

# assumes every element is a value.

ops.register_tensor_conversion_function((list, tuple),

_autopacking_conversion_function, 99)

def unstack(value, num=None, axis=0, name="unstack"):

"""Unpacks the given dimension of a rank-`R` tensor into rank-`(R-1)` tensors.

Unpacks `num` tensors from `value` by chipping it along the `axis` dimension.

If `num` is not specified (the default), it is inferred from `value`'s shape.

If `value.shape[axis]` is not known, `ValueError` is raised.

For example, given a tensor of shape `(A, B, C, D)`;

If `axis == 0` then the i'th tensor in `output` is the slice

`value[i, :, :, :]` and each tensor in `output` will have shape `(B, C, D)`.

(Note that the dimension unpacked along is gone, unlike `split`).

If `axis == 1` then the i'th tensor in `output` is the slice

`value[:, i, :, :]` and each tensor in `output` will have shape `(A, C, D)`.

Etc.

This is the opposite of stack. The numpy equivalent is

tf.unstack(x, n) = list(x)