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

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

# Tests for this file live in python/kernel_tests/array_ops_test.py

"""Support for manipulating tensors."""

import numbers

import numpy as np

from tensorflow.core.config import flags

from tensorflow.dtensor.python import api as d_api

from tensorflow.python.eager import context

from tensorflow.python.eager import record

from tensorflow.python.framework import common_shapes

from tensorflow.python.framework import composite_tensor

from tensorflow.python.framework import constant_op

from tensorflow.python.framework import constant_tensor_conversion # pylint: disable=unused-import

from tensorflow.python.framework import dtypes

from tensorflow.python.framework import errors

from tensorflow.python.framework import indexed_slices

from tensorflow.python.framework import ops

from tensorflow.python.framework import sparse_tensor

from tensorflow.python.framework import tensor as tensor_lib

from tensorflow.python.framework import tensor_conversion_registry

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 array_ops_stack

from tensorflow.python.ops import gen_array_ops

from tensorflow.python.ops import gen_math_ops

from tensorflow.python.ops import shape_util

from tensorflow.python.ops import tensor_getitem_override # pylint: disable=unused-import

# go/tf-wildcard-import

# pylint: disable=wildcard-import

from tensorflow.python.ops.gen_array_ops import *

from tensorflow.python.ops.gen_array_ops import reverse_v2 as reverse # pylint: disable=unused-import

from tensorflow.python.types import core

from tensorflow.python.util import _pywrap_utils

from tensorflow.python.util import deprecation

from tensorflow.python.util import dispatch

from tensorflow.python.util import nest

from tensorflow.python.util import tf_decorator

from tensorflow.python.util.tf_export import tf_export

# pylint: enable=wildcard-import

# Used for slicing to specify a new 1 size dimension

newaxis = None

tf_export("newaxis").export_constant(__name__, "newaxis")

@tf_export("reshape", v1=["reshape", "manip.reshape"])

@dispatch.add_dispatch_support

def reshape(tensor, shape, name=None): # pylint: disable=redefined-outer-name

r"""Reshapes a tensor.

Given `tensor`, this operation returns a new `tf.Tensor` that has the same

values as `tensor` in the same order, except with a new shape given by

`shape`.

>>> t1 = [[1, 2, 3],

... [4, 5, 6]]

>>> print(tf.shape(t1).numpy())

[2 3]

>>> t2 = tf.reshape(t1, [6])

>>> t2

<tf.Tensor: shape=(6,), dtype=int32,

numpy=array([1, 2, 3, 4, 5, 6], dtype=int32)>

>>> tf.reshape(t2, [3, 2])

<tf.Tensor: shape=(3, 2), dtype=int32, numpy=

array([[1, 2],

[3, 4],

[5, 6]], dtype=int32)>

The `tf.reshape` does not change the order of or the total number of elements

in the tensor, and so it can reuse the underlying data buffer. This makes it

a fast operation independent of how big of a tensor it is operating on.

>>> tf.reshape([1, 2, 3], [2, 2])

Traceback (most recent call last):

...

InvalidArgumentError: Input to reshape is a tensor with 3 values, but the

requested shape has 4

To instead reorder the data to rearrange the dimensions of a tensor, see

`tf.transpose`.

>>> t = [[1, 2, 3],

... [4, 5, 6]]

>>> tf.reshape(t, [3, 2]).numpy()

array([[1, 2],

[3, 4],

[5, 6]], dtype=int32)

>>> tf.transpose(t, perm=[1, 0]).numpy()

array([[1, 4],

[2, 5],

[3, 6]], dtype=int32)

If one component of `shape` is the special value -1, the size of that

dimension is computed so that the total size remains constant. In particular,

a `shape` of `[-1]` flattens into 1-D. At most one component of `shape` can

be -1.

>>> t = [[1, 2, 3],

... [4, 5, 6]]

>>> tf.reshape(t, [-1])

<tf.Tensor: shape=(6,), dtype=int32,

numpy=array([1, 2, 3, 4, 5, 6], dtype=int32)>

>>> tf.reshape(t, [3, -1])

<tf.Tensor: shape=(3, 2), dtype=int32, numpy=

array([[1, 2],

[3, 4],

[5, 6]], dtype=int32)>

>>> tf.reshape(t, [-1, 2])

<tf.Tensor: shape=(3, 2), dtype=int32, numpy=

array([[1, 2],

[3, 4],

[5, 6]], dtype=int32)>

`tf.reshape(t, [])` reshapes a tensor `t` with one element to a scalar.

>>> tf.reshape([7], []).numpy()

7

More examples:

>>> t = [1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> print(tf.shape(t).numpy())

[9]

>>> tf.reshape(t, [3, 3])

<tf.Tensor: shape=(3, 3), dtype=int32, numpy=

array([[1, 2, 3],

[4, 5, 6],

[7, 8, 9]], dtype=int32)>

>>> t = [[[1, 1], [2, 2]],

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

>>> print(tf.shape(t).numpy())

[2 2 2]

>>> tf.reshape(t, [2, 4])

<tf.Tensor: shape=(2, 4), dtype=int32, numpy=

array([[1, 1, 2, 2],

[3, 3, 4, 4]], dtype=int32)>

>>> t = [[[1, 1, 1],

... [2, 2, 2]],

... [[3, 3, 3],

... [4, 4, 4]],

... [[5, 5, 5],

... [6, 6, 6]]]

>>> print(tf.shape(t).numpy())

[3 2 3]

>>> # Pass '[-1]' to flatten 't'.

>>> tf.reshape(t, [-1])

<tf.Tensor: shape=(18,), dtype=int32,

numpy=array([1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6],

dtype=int32)>

>>> # -- Using -1 to infer the shape --

>>> # Here -1 is inferred to be 9:

>>> tf.reshape(t, [2, -1])

<tf.Tensor: shape=(2, 9), dtype=int32, numpy=

array([[1, 1, 1, 2, 2, 2, 3, 3, 3],

[4, 4, 4, 5, 5, 5, 6, 6, 6]], dtype=int32)>

>>> # -1 is inferred to be 2:

>>> tf.reshape(t, [-1, 9])

<tf.Tensor: shape=(2, 9), dtype=int32, numpy=

array([[1, 1, 1, 2, 2, 2, 3, 3, 3],

[4, 4, 4, 5, 5, 5, 6, 6, 6]], dtype=int32)>

>>> # -1 is inferred to be 3:

>>> tf.reshape(t, [ 2, -1, 3])

<tf.Tensor: shape=(2, 3, 3), dtype=int32, numpy=

array([[[1, 1, 1],

[2, 2, 2],

[3, 3, 3]],

[[4, 4, 4],

[5, 5, 5],

[6, 6, 6]]], dtype=int32)>

Args:

tensor: A `Tensor`.

shape: A `Tensor`. Must be one of the following types: `int32`, `int64`.

Defines the shape of the output tensor.

name: Optional string. A name for the operation.

Returns:

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

"""

result = gen_array_ops.reshape(tensor, shape, name)

shape_util.maybe_set_static_shape(result, shape)

return result

@tf_export("fill")

@dispatch.add_dispatch_support

def fill(dims, value, name=None, layout=None):

r"""Creates a tensor filled with a scalar value.

See also `tf.ones`, `tf.zeros`, `tf.one_hot`, `tf.eye`.

This operation creates a tensor of shape `dims` and fills it with `value`.

For example:

>>> tf.fill([2, 3], 9)

<tf.Tensor: shape=(2, 3), dtype=int32, numpy=

array([[9, 9, 9],

[9, 9, 9]], dtype=int32)>

`tf.fill` evaluates at graph runtime and supports dynamic shapes based on

other runtime `tf.Tensors`, unlike `tf.constant(value, shape=dims)`, which

embeds the value as a `Const` node.

Args:

dims: A 1-D sequence of non-negative numbers. Represents the shape of the

output `tf.Tensor`. Entries should be of type: `int32`, `int64`.

value: A value to fill the returned `tf.Tensor`.

name: Optional string. The name of the output `tf.Tensor`.

layout: Optional, `tf.experimental.dtensor.Layout`. If provided, the result

is a [DTensor](https://www.tensorflow.org/guide/dtensor_overview) with the

provided layout.

Returns:

A `tf.Tensor` with shape `dims` and the same dtype as `value`.

Raises:

InvalidArgumentError: `dims` contains negative entries.

NotFoundError: `dims` contains non-integer entries.

@compatibility(numpy)

Similar to `np.full`. In `numpy`, more parameters are supported. Passing a

number argument as the shape (`np.full(5, value)`) is valid in `numpy` for

specifying a 1-D shaped result, while TensorFlow does not support this syntax.

@end_compatibility

"""

result = d_api.call_with_layout(

gen_array_ops.fill, layout=layout, dims=dims, value=value, name=name

)

shape_util.maybe_set_static_shape(result, dims)

return result

@tf_export("identity")

@dispatch.add_dispatch_support

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

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

The return value is not the same Tensor as the original, but contains the same

values. This operation is fast when used on the same device.

For example:

>>> a = tf.constant([0.78])

>>> a_identity = tf.identity(a)

>>> a.numpy()

array([0.78], dtype=float32)

>>> a_identity.numpy()

array([0.78], dtype=float32)

Calling `tf.identity` on a variable will make a Tensor that represents the

value of that variable at the time it is called. This is equivalent to calling

`<variable>.read_value()`.

>>> a = tf.Variable(5)

>>> a_identity = tf.identity(a)

>>> a.assign_add(1)

<tf.Variable ... shape=() dtype=int32, numpy=6>

>>> a.numpy()

6

>>> a_identity.numpy()

5

This function can also be used to explicitly transfer tensors between devices.

For example, to transfer a tensor in GPU memory back to host memory, one can

use:

>>> with tf.device("/gpu:0"):

... x_on_gpu = tf.constant(1)

>>> with tf.device("/cpu:0"):

... x_on_cpu = tf.identity(x_on_gpu)

>>> x_on_cpu.device

'/job:localhost/replica:0/task:0/device:CPU:0'

Args:

input: A `Tensor`, a `Variable`, a `CompositeTensor` or anything that can be

converted to a tensor using `tf.convert_to_tensor`.

name: A name for the operation (optional).

Returns:

A `Tensor` or CompositeTensor. Has the same type and contents as `input`.

"""

# Don't expand ResourceVariables, so identity(variable) will return a Tensor.

if (isinstance(input, composite_tensor.CompositeTensor) and

not _pywrap_utils.IsResourceVariable(input)):

return nest.map_structure(identity, input, expand_composites=True)

if context.executing_eagerly() and not hasattr(input, "graph"):

# Make sure we get an input with handle data attached from resource

# variables. Variables have correct handle data when graph building.

input = ops.convert_to_tensor(input)

ret = gen_array_ops.identity(input, name=name)

# Propagate handle data for happier shape inference for resource variables.

if hasattr(input, "_handle_data"):

ret._handle_data = input._handle_data # pylint: disable=protected-access

return ret

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

@tf_export(v1=["expand_dims"])

@dispatch.add_dispatch_support

@deprecation.deprecated_args(None, "Use the `axis` argument instead", "dim")

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

"""Returns a tensor with a length 1 axis inserted at index `axis`.

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

dimension index `axis` of `input`'s shape. The dimension index follows Python

indexing rules: It's zero-based, a negative index it is counted backward

from the end.

This operation is useful to:

* Add an outer "batch" dimension to a single element.

* Align axes for broadcasting.

* To add an inner vector length axis to a tensor of scalars.

For example:

If you have a single image of shape `[height, width, channels]`:

>>> image = tf.zeros([10,10,3])

You can add an outer `batch` axis by passing `axis=0`:

>>> tf.expand_dims(image, axis=0).shape.as_list()

[1, 10, 10, 3]

The new axis location matches Python `list.insert(axis, 1)`:

>>> tf.expand_dims(image, axis=1).shape.as_list()

[10, 1, 10, 3]

Following standard Python indexing rules, a negative `axis` counts from the

end so `axis=-1` adds an inner most dimension:

>>> tf.expand_dims(image, -1).shape.as_list()

[10, 10, 3, 1]

This operation requires that `axis` is a valid index for `input.shape`,

following Python indexing rules:

```

-1-tf.rank(input) <= axis <= tf.rank(input)

```

This operation is related to:

* `tf.squeeze`, which removes dimensions of size 1.

* `tf.reshape`, which provides more flexible reshaping capability.

* `tf.sparse.expand_dims`, which provides this functionality for

`tf.SparseTensor`

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` (optional).

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 either both or neither of `dim` and `axis` are specified.

"""

axis = deprecation.deprecated_argument_lookup("axis", axis, "dim", dim)

if axis is None:

raise ValueError("Must specify an axis argument to tf.expand_dims()")

return expand_dims_v2(input, axis, name)

@tf_export("expand_dims", v1=[])

@dispatch.add_dispatch_support

def expand_dims_v2(input, axis, name=None):

"""Returns a tensor with a length 1 axis inserted at index `axis`.

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

dimension index `axis` of `input`'s shape. The dimension index follows Python

indexing rules: It's zero-based, a negative index it is counted backward

from the end.

This operation is useful to:

* Add an outer "batch" dimension to a single element.

* Align axes for broadcasting.

* To add an inner vector length axis to a tensor of scalars.

For example:

If you have a single image of shape `[height, width, channels]`:

>>> image = tf.zeros([10,10,3])

You can add an outer `batch` axis by passing `axis=0`:

>>> tf.expand_dims(image, axis=0).shape.as_list()

[1, 10, 10, 3]

The new axis location matches Python `list.insert(axis, 1)`:

>>> tf.expand_dims(image, axis=1).shape.as_list()

[10, 1, 10, 3]

Following standard Python indexing rules, a negative `axis` counts from the

end so `axis=-1` adds an inner most dimension:

>>> tf.expand_dims(image, -1).shape.as_list()

[10, 10, 3, 1]

This operation requires that `axis` is a valid index for `input.shape`,

following Python indexing rules:

```

-1-tf.rank(input) <= axis <= tf.rank(input)

```

This operation is related to:

* `tf.squeeze`, which removes dimensions of size 1.

* `tf.reshape`, which provides more flexible reshaping capability.

* `tf.sparse.expand_dims`, which provides this functionality for

`tf.SparseTensor`

Args:

input: A `Tensor`.

axis: Integer specifying the dimension index at which to expand the

shape of `input`. Given an input of D dimensions, `axis` must be in range

`[-(D+1), D]` (inclusive).

name: Optional string. The name of the output `Tensor`.

Returns:

A tensor with the same data as `input`, with an additional dimension

inserted at the index specified by `axis`.

Raises:

TypeError: If `axis` is not specified.

InvalidArgumentError: If `axis` is out of range `[-(D+1), D]`.

"""

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

@deprecation.deprecated("2018-11-30",

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

"Please switch to tf.sets.difference().")

@tf_export(v1=["setdiff1d"])

@dispatch.add_dispatch_support

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

"""Computes the difference between two lists of numbers or strings.

Given a list x and a list y, this operation returns a list out that

represents all values that are in x but not in y. The returned list

out is sorted in the same order that the numbers appear in x

(duplicates are preserved). This operation also returns a list idx

that represents the position of each out element in x.

In other words:

```python

out[i] = x[idx[i]] for i in [0, 1, ..., len(out) - 1]

```

Example usage:

>>> x = [1, 2, 3, 4, 5, 6]

>>> y = [1, 3, 5]

>>> setdiff1d(x,y)

ListDiff(out=<tf.Tensor: id=2, shape=(3,), dtype=int32,

numpy=array([2, 4, 6], dtype=int32)>, idx=<tf.Tensor: id=3,

shape=(3,), dtype=int32, numpy=array([1, 3, 5], dtype=int32)>)

Args:

x: A Tensor. 1-D. Values to keep.

y: A Tensor. Must have the same type as x. 1-D. Values to remove.

out_idx: An optional tf.DType from: tf.int32, tf.int64. Defaults to

tf.int32.

name: A name for the operation (optional).

Returns:

A tuple of Tensor objects (out, idx).

out: A Tensor. Has the same type as x.

idx: A Tensor of type out_idx.

"""

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

setdiff1d.__doc__ = gen_array_ops.list_diff.__doc__

@tf_export("broadcast_dynamic_shape")

@dispatch.add_dispatch_support

def broadcast_dynamic_shape(shape_x, shape_y):

"""Computes the shape of a broadcast given symbolic shapes.

When `shape_x` and `shape_y` are Tensors representing shapes (i.e. the result

of calling tf.shape on another Tensor) this computes a Tensor which is the

shape of the result of a broadcasting op applied in tensors of shapes

`shape_x` and `shape_y`.

This is useful when validating the result of a broadcasting operation when the

tensors do not have statically known shapes.

Example:

>>> shape_x = (1, 2, 3)

>>> shape_y = (5, 1, 3)

>>> tf.broadcast_dynamic_shape(shape_x, shape_y)

<tf.Tensor: shape=(3,), dtype=int32, numpy=array([5, 2, 3], ...>

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.

Raises:

InvalidArgumentError: If the two shapes are incompatible for

broadcasting.

"""

return gen_array_ops.broadcast_args(shape_x, shape_y)

@tf_export("broadcast_static_shape")

@dispatch.add_dispatch_support

def broadcast_static_shape(shape_x, shape_y):

"""Computes the shape of a broadcast given known shapes.

When `shape_x` and `shape_y` are fully known `TensorShape`s this computes a

`TensorShape` which is the shape of the result of a broadcasting op applied in

tensors of shapes `shape_x` and `shape_y`.

For example, if shape_x is `TensorShape([1, 2, 3])` and shape_y is

`TensorShape([5, 1, 3])`, the result is a TensorShape whose value is

`TensorShape([5, 2, 3])`.

This is useful when validating the result of a broadcasting operation when the

tensors have statically known shapes.

Example:

>>> shape_x = tf.TensorShape([1, 2, 3])

>>> shape_y = tf.TensorShape([5, 1 ,3])

>>> tf.broadcast_static_shape(shape_x, shape_y)

TensorShape([5, 2, 3])

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)

@tf_export("shape", v1=[])

@dispatch.add_dispatch_support

def shape_v2(input, out_type=None, name=None):

# pylint: disable=redefined-builtin

# TODO(b/274626120) Update `tf_shape_default_int64` comment when it is better

# supported.

"""Returns a tensor containing the shape of the input tensor.

See also `tf.size`, `tf.rank`.

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

For a scalar input, the tensor returned has a shape of (0,) and its value is

the empty vector (i.e. []).

For example:

>>> tf.shape(1.)

<tf.Tensor: shape=(0,), dtype=int32, numpy=array([], dtype=int32)>

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

>>> tf.shape(t)

<tf.Tensor: shape=(3,), dtype=int32, numpy=array([2, 2, 3], dtype=int32)>

Note: When using symbolic tensors, such as when using the Keras API,

tf.shape() will return the shape of the symbolic tensor.

>>> a = tf.keras.layers.Input((None, 10))

>>> tf.shape(a)

<... shape=(3,) dtype=int32...>

In these cases, using `tf.Tensor.shape` will return more informative results.

>>> a.shape

TensorShape([None, None, 10])

(The first `None` represents the as yet unknown batch size.)

`tf.shape` and `Tensor.shape` should be identical in eager mode. Within

`tf.function` or within a `compat.v1` context, not all dimensions may be

known until execution time. Hence, when defining custom layers and models

for graph mode, prefer the dynamic `tf.shape(x)` over the static `x.shape`.

Args:

input: A `Tensor` or `SparseTensor`.

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

`int64`). Defaults to `tf.int32`. (Note: there is an experimental

flag, `tf_shape_default_int64` that changes the default to `tf.int64`.

This is an unsupported, experimental setting that causes known breakages.)

name: A name for the operation (optional).

Returns:

A `Tensor` of type `out_type`.

"""

if out_type is None:

if flags.config().tf_shape_default_int64.value():

out_type = dtypes.int64

else:

out_type = dtypes.int32

return shape(input, name, out_type)

@tf_export(v1=["shape"])

@dispatch.add_dispatch_support

def shape(input, name=None, out_type=None):

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

"""

if out_type is None:

if flags.config().tf_shape_default_int64.value():

out_type = dtypes.int64

else:

out_type = dtypes.int32

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

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

# pylint: disable=redefined-builtin

"""Returns the shape of a tensor.

If `out_type` is not specified and the shape is fully known, then we look at

the dimension values to determine whether to return an int32 or int64 tensor.

If the shape is not fully known, we default to int32.

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

if not out_type:

out_type = dtypes.int32

return gen_math_ops.cast(input.dense_shape, out_type)

else:

if not context.executing_eagerly():

input = ops.convert_to_tensor(input)

input_shape = input.get_shape()

if optimize and input_shape.is_fully_defined():

# For fully defined shapes, if the out_type is not specified, we pick

# int32 / int64 based on the actual values.

if not out_type:

return constant_op._tensor_shape_tensor_conversion_function( # pylint: disable=protected-access

input_shape)

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

if not out_type:

out_type = dtypes.int32

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

@tf_export("shape_n")

@dispatch.add_dispatch_support

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

# pylint: disable=redefined-builtin

"""Returns shape of a list of tensors.

Given a list of tensors, `tf.shape_n` is much faster than applying `tf.shape`

to each tensor individually.

>>> a = tf.ones([1, 2])

>>> b = tf.ones([2, 3])

>>> c = tf.ones([3, 4])

>>> tf.shape_n([a, b, c])

[<tf.Tensor: shape=(2,), dtype=int32, numpy=array([1, 2], dtype=int32)>,

<tf.Tensor: shape=(2,), dtype=int32, numpy=array([2, 3], dtype=int32)>,

<tf.Tensor: shape=(2,), dtype=int32, numpy=array([3, 4], dtype=int32)>]

Args:

input: A list of at least 1 `Tensor` object with the same dtype.

out_type: The specified output type of the operation (`int32` or `int64`).

Defaults to `tf.int32`(optional).

name: A name for the operation (optional).

Returns:

A list of `Tensor` specifying the shape of each input tensor with type of

`out_type`.

"""

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

@tf_export("size", v1=[])

@dispatch.add_dispatch_support

def size_v2(input, out_type=None, name=None):

# pylint: disable=redefined-builtin

"""Returns the size of a tensor.

See also `tf.shape`.

Returns a 0-D `Tensor` representing the number of elements in `input`

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

For example:

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

>>> tf.size(t)

<tf.Tensor: shape=(), dtype=int32, numpy=12>

Args:

input: A `Tensor` or `SparseTensor`.

out_type: (Optional) The specified non-quantized numeric output type of the

operation. Defaults to `tf.int32`. (Note: there is an experimental

flag, `tf_shape_default_int64` that changes the default to `tf.int64`.

This is an unsupported, experimental setting that causes known breakages.)

name: A name for the operation (optional).

Returns:

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

@compatibility(numpy)

Equivalent to np.size()

@end_compatibility

"""

if out_type is None:

if flags.config().tf_shape_default_int64.value():

out_type = dtypes.int64

else:

out_type = dtypes.int32

return size(input, name, out_type)

@tf_export(v1=["size"])

@dispatch.add_dispatch_support

def size(input, name=None, out_type=None):

# pylint: disable=redefined-builtin

"""Returns the size of a tensor.

Returns a 0-D `Tensor` representing the number of elements in `input`

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

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 non-quantized numeric output type of the

operation. Defaults to `tf.int32`. (Note: there is an experimental

flag, `tf_shape_default_int64` that changes the default to `tf.int64`.

This is an unsupported, experimental setting that causes known breakages.)

Returns:

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

@compatibility(numpy)

Equivalent to np.size()

@end_compatibility

"""

if out_type is None:

if flags.config().tf_shape_default_int64.value():

out_type = dtypes.int64

else:

out_type = dtypes.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 non-quantized numeric output type of the

operation. Defaults to `tf.int32`.

Returns:

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

"""

if (context.executing_eagerly() and not hasattr(input, "graph") and

not isinstance(

input,

(sparse_tensor.SparseTensor, sparse_tensor.SparseTensorValue))):

input = ops.convert_to_tensor(input)

np_out_type = out_type.as_numpy_dtype

num_elements = np.prod(input._shape_tuple(), dtype=np_out_type) # pylint: disable=protected-access

return ops.convert_to_tensor(num_elements, dtype=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 = ops.convert_to_tensor(input)

input_shape = input.get_shape()

if optimize:

if input_shape.is_fully_defined():

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

if input_shape.dims and any(dim == 0 for dim in input_shape.dims):

return constant(0, out_type, name=name)

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

@tf_export("rank")

@dispatch.add_dispatch_support

def rank(input, name=None):

# pylint: disable=redefined-builtin

"""Returns the rank of a tensor.

See also `tf.shape`.

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 = ops.convert_to_tensor(input)

input_shape = input.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)

# pylint: disable=undefined-variable,protected-access,redefined-outer-name

@tf_export("slice")

@dispatch.add_dispatch_support

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

# pylint: disable=redefined-builtin

"""Extracts a slice from a tensor.

See also `tf.strided_slice`.

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(foo, [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

@tf_export("strided_slice")

@dispatch.add_dispatch_support

def strided_slice(input_,

begin,

end,

strides=None,

begin_mask=0,