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

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

"""## Casting

TensorFlow provides several operations that you can use to cast tensor data

types in your graph.

@@string_to_number

@@to_double

@@to_float

@@to_bfloat16

@@to_int32

@@to_int64

@@cast

@@saturate_cast

## Shapes and Shaping

TensorFlow provides several operations that you can use to determine the shape

of a tensor and change the shape of a tensor.

@@shape

@@size

@@rank

@@reshape

@@squeeze

@@expand_dims

## Slicing and Joining

TensorFlow provides several operations to slice or extract parts of a tensor,

or join multiple tensors together.

@@slice

@@split

@@tile

@@pad

@@concat

@@pack

@@unpack

@@reverse_sequence

@@reverse

@@transpose

@@extract_image_patches

@@space_to_batch

@@batch_to_space

@@space_to_depth

@@depth_to_space

@@gather

@@gather_nd

@@dynamic_partition

@@dynamic_stitch

@@boolean_mask

@@one_hot

"""

from __future__ import absolute_import

from __future__ import division

from __future__ import print_function

import sys

import numpy as np

from tensorflow.python.framework import dtypes

from tensorflow.python.framework import ops

from tensorflow.python.framework import tensor_shape

from tensorflow.python.framework import tensor_util

from tensorflow.python.ops import common_shapes

from tensorflow.python.ops import constant_op

from tensorflow.python.ops import gen_array_ops

from tensorflow.python.ops import gen_math_ops

from tensorflow.python.ops import logging_ops

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

from tensorflow.python.ops.constant_op import constant

# go/tf-wildcard-import

# pylint: disable=wildcard-import

from tensorflow.python.ops.gen_array_ops import *

# pylint: enable=wildcard-import

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

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

_baseslice = slice

# Aliases for some automatically-generated names.

listdiff = gen_array_ops.list_diff

def rank(input, name=None):

"""Returns the rank of a tensor.

This operation returns an integer representing the rank of `input`.

For example:

```python

# 't' is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]

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

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

"""

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

if isinstance(input, ops.SparseTensor):

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

else:

return gen_array_ops.rank(input, name=name)

# DEPRECATED use init_ops.zeros_initializer

# TODO(irving) Move it to init_ops.py

def zeros_initializer(shape, dtype=dtypes.float32):

"""An adaptor for zeros() to match the Initializer spec."""

return zeros(shape, dtype)

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

def _SliceHelper(tensor, slice_spec):

"""Overload for Tensor.__getitem__.

Currently the size of the slice must be statically known in each dimension,

i.e. the "stop" of the slice must not be omitted.

TODO(mrry): Support slices where the sizes are not specified.

TODO(mrry): Support negative indices in slices with numpy/Python semantics.

Args:

tensor: An ops.Tensor object.

slice_spec: The arguments to Tensor.__getitem__.

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]

indices = []

sizes = []

squeeze_dims = []

for dim, s in enumerate(slice_spec):

if isinstance(s, _baseslice):

if s.step not in (None, 1):

raise NotImplementedError(

"Steps other than 1 are not currently supported")

start = s.start if s.start is not None else 0

if start < 0:

raise NotImplementedError(

"Negative start indices are not currently supported")

indices.append(start)

if s.stop is not None and s.stop < 0:

raise NotImplementedError(

"Negative stop indices are not currently supported")

# NOTE(mrry): If the stop is not specified, Python substitutes

# sys.maxsize, which is typically (2 ** 63) - 1. Since Slice currently

# supports signed DT_INT32 arguments, we use -1 to specify that all

# elements should be captured.

if s.stop is None or s.stop == sys.maxsize:

sizes.append(-1)

else:

if start > s.stop:

raise ValueError("Stop must be at least start")

sizes.append(s.stop - start)

elif s is Ellipsis:

raise NotImplementedError("Ellipsis is not currently supported")

else:

try:

s = int(s)

except TypeError:

raise TypeError("Bad slice index %s of type %s" % (s, type(s)))

if s < 0:

raise NotImplementedError("Negative indices are currently unsupported")

indices.append(s)

sizes.append(1)

squeeze_dims.append(dim)

sliced = slice(tensor, indices, sizes)

if squeeze_dims:

return squeeze(sliced, squeeze_dims=squeeze_dims)

else:

return sliced

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

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

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

```

# 'input' is [[[1, 1, 1], [2, 2, 2]],

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

# [[5, 5, 5], [6, 6, 6]]]

tf.slice(input, [1, 0, 0], [1, 1, 3]) ==> [[[3, 3, 3]]]

tf.slice(input, [1, 0, 0], [1, 2, 3]) ==> [[[3, 3, 3],

[4, 4, 4]]]

tf.slice(input, [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)

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

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

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

Packs tensors in `values` into a tensor with rank one higher than each tensor

in `values` and shape `[len(values)] + values[0].shape`. The output satisfies

`output[i, ...] = values[i][...]`.

This is the opposite of unpack. The numpy equivalent is

tf.pack([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 packed `Tensor` with the same type as `values`.

"""

try:

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

return ops.convert_to_tensor(values, name=name)

except (TypeError, ValueError):

# Input list contains non-constant tensors

return gen_array_ops._pack(values, 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 unpack(value, num=None, name="unpack"):

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

Unpacks `num` tensors from `value` along the first dimension.

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

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

The ith tensor in `output` is the slice `value[i, ...]`. Each tensor in

`output` has shape `value.shape[1:]`.

This is the opposite of pack. The numpy equivalent is

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

Args:

value: A rank `R > 0` `Tensor` to be unpacked.

num: An `int`. The first dimension of value. Automatically inferred if

`None` (the default).

name: A name for the operation (optional).

Returns:

The list of `Tensor` objects unpacked from `value`.

Raises:

ValueError: If `num` is unspecified and cannot be inferred.

"""

if num is None:

value = ops.convert_to_tensor(value)

shape = value.get_shape()

num = shape[0].value

if num is None:

raise ValueError("Cannot infer num from shape %s" % shape)

return gen_array_ops._unpack(value, num=num, name=name)

def concat(concat_dim, values, name="concat"):

"""Concatenates tensors along one dimension.

Concatenates the list of tensors `values` along dimension `concat_dim`. If

`values[i].shape = [D0, D1, ... Dconcat_dim(i), ...Dn]`, the concatenated

result has shape

[D0, D1, ... Rconcat_dim, ...Dn]

where

Rconcat_dim = sum(Dconcat_dim(i))

That is, the data from the input tensors is joined along the `concat_dim`

dimension.

The number of dimensions of the input tensors must match, and all dimensions

except `concat_dim` must be equal.

For example:

```python

t1 = [[1, 2, 3], [4, 5, 6]]

t2 = [[7, 8, 9], [10, 11, 12]]

tf.concat(0, [t1, t2]) ==> [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]

tf.concat(1, [t1, t2]) ==> [[1, 2, 3, 7, 8, 9], [4, 5, 6, 10, 11, 12]]

# tensor t3 with shape [2, 3]

# tensor t4 with shape [2, 3]

tf.shape(tf.concat(0, [t3, t4])) ==> [4, 3]

tf.shape(tf.concat(1, [t3, t4])) ==> [2, 6]

```

Args:

concat_dim: 0-D `int32` `Tensor`. Dimension along which to concatenate.

values: A list of `Tensor` objects or a single `Tensor`.

name: A name for the operation (optional).

Returns:

A `Tensor` resulting from concatenation of the input tensors.

"""

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

values = [values]

# TODO(mrry): Change to return values?

if len(values) == 1: # Degenerate case of one tensor.

# Make a throwaway call to convert_to_tensor to make sure

# that concat_dim is of the correct type, and make sure that

# the returned tensor is a scalar.

# TODO(keveman): Implement a standalone type and shape checker.

with ops.name_scope(name) as scope:

ops.convert_to_tensor(concat_dim,

name="concat_dim",

dtype=dtypes.int32).get_shape(

).assert_is_compatible_with(tensor_shape.scalar())

return identity(values[0], name=scope)

return gen_array_ops._concat(concat_dim=concat_dim,

values=values,

name=name)

@ops.RegisterShape("Pack")

def _PackShape(op):

input_shape = op.inputs[0].get_shape()

for inp in op.inputs[1:]:

input_shape = input_shape.merge_with(inp.get_shape())

return [tensor_shape.TensorShape([len(op.inputs)]).concatenate(input_shape)]

@ops.RegisterShape("Unpack")

def _UnpackShape(op):

input_shape = op.inputs[0].get_shape()

return [input_shape[1:]] * op.get_attr("num")

@ops.RegisterShape("Concat")

def _ConcatShape(op):

concat_dim = tensor_util.constant_value(op.inputs[0])

if concat_dim is None:

# Return an unknown shape with the same rank as the inputs, or an

# unknown rank if no input's rank is known.

rank = None

for value in op.inputs[1:]:

if rank is not None:

value.get_shape().assert_has_rank(rank)

else:

rank = value.get_shape().ndims

if rank == 0:

raise ValueError("Can't concatenate scalars (use tf.pack instead)")

return [tensor_shape.unknown_shape(ndims=rank)]

else:

# Merge all the non-concat dims, and sum the concat dim to make an

# output shape.

concat_dim = int(concat_dim)

output_shape = op.inputs[1].get_shape()

for value in op.inputs[2:]:

value_shape = value.get_shape()

if value_shape.ndims is not None and concat_dim >= value_shape.ndims:

raise ValueError("concat_dim is out of range (values rank = %d)" %

value_shape.ndims)

before = output_shape[:concat_dim].merge_with(value_shape[:concat_dim])

at = output_shape[concat_dim] + value_shape[concat_dim]

after = output_shape[

concat_dim + 1:].merge_with(value_shape[concat_dim + 1:])

output_shape = before.concatenate(at).concatenate(after)

return [output_shape]

@ops.RegisterShape("ConcatOffset")

def _ConcatOffsetShape(op):

return [x.get_shape() for x in op.inputs[1:]]

def boolean_mask(tensor, mask, name="boolean_mask"):

"""Apply boolean mask to tensor. Numpy equivalent is `tensor[mask]`.

```python

# 1-D example

tensor = [0, 1, 2, 3]

mask = [True, False, True, False]

boolean_mask(tensor, mask) ==> [0, 2]

```

In general, `0 < dim(mask) = K <= dim(tensor)`, and `mask`'s shape must match

the first K dimensions of `tensor`'s shape. We then have:

`boolean_mask(tensor, mask)[i, j1,...,jd] = tensor[i1,...,iK,j1,...,jd]`

where `(i1,...,iK)` is the ith `True` entry of `mask` (row-major order).

Args:

tensor: N-D tensor.

mask: K-D boolean tensor, K <= N and K must be known statically.

name: A name for this operation (optional).

Returns:

Tensor populated by entries in `tensor` corresponding to `True` values in

`mask`.

Raises:

ValueError: If shapes do not conform.

Examples:

```python

# 2-D example

tensor = [[1, 2], [3, 4], [5, 6]]

mask = [True, False, True]

boolean_mask(tensor, mask) ==> [[1, 2], [5, 6]]

```

"""

def _apply_mask_1d(reshaped_tensor, mask):

"""Mask tensor along dimension 0 with a 1-D mask."""

indices = squeeze(where(mask), squeeze_dims=[1])

return gather(reshaped_tensor, indices)

with ops.op_scope([tensor, mask], name):

tensor = ops.convert_to_tensor(tensor, name="tensor")

mask = ops.convert_to_tensor(mask, name="mask")

shape_mask = mask.get_shape()

ndims_mask = shape_mask.ndims

shape_tensor = tensor.get_shape()

if ndims_mask == 0:

raise ValueError("mask cannot be scalar.")

if ndims_mask is None:

raise ValueError(

"mask dimensions must be specified, even if some dimensions are None"

". E.g. shape=[None] is ok, but shape=None is not.")

shape_tensor[:ndims_mask].assert_is_compatible_with(shape_mask)

tensor = reshape(tensor, concat(0, [[-1], shape(tensor)[ndims_mask:]]))

first_dim = shape_tensor[:ndims_mask].num_elements()

tensor.set_shape(

tensor_shape.as_shape([first_dim])

.concatenate(shape_tensor[ndims_mask:]))

mask = reshape(mask, [-1])

return _apply_mask_1d(tensor, mask)

def sparse_mask(a, mask_indices, name=None):

"""Masks elements of `IndexedSlices`.

Given an `IndexedSlices` instance `a`, returns another `IndexedSlices` that

contains a subset of the slices of `a`. Only the slices at indices specified

in `mask_indices` are returned.

This is useful when you need to extract a subset of slices in an

`IndexedSlices` object.

For example:

```python

# `a` contains slices at indices [12, 26, 37, 45] from a large tensor

# with shape [1000, 10]

a.indices => [12, 26, 37, 45]

tf.shape(a.values) => [4, 10]

# `b` will be the subset of `a` slices at its second and third indices, so

# we want to mask of its first and last indices (which are at absolute

# indices 12, 45)

b = tf.sparse_mask(a, [12, 45])

b.indices => [26, 37]

tf.shape(b.values) => [2, 10]

```

Args:

* `a`: An `IndexedSlices` instance.

* `mask_indices`: Indices of elements to mask.

* `name`: A name for the operation (optional).

Returns:

The masked `IndexedSlices` instance.

"""

with ops.op_scope([a, mask_indices], name, "sparse_mask") as name:

indices = a.indices

out_indices, to_gather = listdiff(indices, mask_indices)

out_values = gather(a.values, to_gather, name=name)

return ops.IndexedSlices(out_values, out_indices, a.dense_shape)

def split(split_dim, num_split, value, name="split"):

"""Splits a tensor into `num_split` tensors along one dimension.

Splits `value` along dimension `split_dim` into `num_split` smaller tensors.

Requires that `num_split` evenly divide `value.shape[split_dim]`.

For example:

```python

# 'value' is a tensor with shape [5, 30]

# Split 'value' into 3 tensors along dimension 1

split0, split1, split2 = tf.split(1, 3, value)

tf.shape(split0) ==> [5, 10]

```

Args:

split_dim: A 0-D `int32` `Tensor`. The dimension along which to split.

Must be in the range `[0, rank(value))`.

num_split: A Python integer. The number of ways to split.

value: The `Tensor` to split.

name: A name for the operation (optional).

Returns:

`num_split` `Tensor` objects resulting from splitting `value`.

"""

return gen_array_ops._split(split_dim=split_dim,

num_split=num_split,

value=value,

name=name)

@ops.RegisterShape("Reverse")

def _ReverseShape(op):

dims_shape = op.inputs[1].get_shape().with_rank(1)

input_shape = op.inputs[0].get_shape().with_rank(dims_shape[0])

if input_shape.ndims is not None and input_shape.ndims > 8:

raise ValueError(

"tf.reverse() does not work on tensors with more than 8 dimensions")

return [input_shape]

def transpose(a, perm=None, name="transpose"):

"""Transposes `a`. Permutes the dimensions according to `perm`.

The returned tensor's dimension i will correspond to the input dimension

`perm[i]`. If `perm` is not given, it is set to (n-1...0), where n is

the rank of the input tensor. Hence by default, this operation performs a

regular matrix transpose on 2-D input Tensors.

For example:

```python

# 'x' is [[1 2 3]

# [4 5 6]]

tf.transpose(x) ==> [[1 4]

[2 5]

[3 6]]

# Equivalently

tf.transpose(x, perm=[1, 0]) ==> [[1 4]

[2 5]

[3 6]]

# 'perm' is more useful for n-dimensional tensors, for n > 2

# 'x' is [[[1 2 3]

# [4 5 6]]

# [[7 8 9]

# [10 11 12]]]

# Take the transpose of the matrices in dimension-0

tf.transpose(x, perm=[0, 2, 1]) ==> [[[1 4]

[2 5]

[3 6]]

[[7 10]

[8 11]

[9 12]]]

```

Args:

a: A `Tensor`.

perm: A permutation of the dimensions of `a`.

name: A name for the operation (optional).

Returns:

A transposed `Tensor`.

"""

with ops.op_scope([a], name, "transpose") as name:

if perm is None:

rank = gen_array_ops.rank(a)

perm = (rank - 1) - gen_math_ops._range(0, rank, 1)

ret = gen_array_ops.transpose(a, perm, name=name)

# NOTE(mrry): Setting the shape explicitly because

# reverse is not handled by the shape function.

input_shape = ret.op.inputs[0].get_shape().dims

if input_shape is not None:

ret.set_shape(input_shape[::-1])

else:

ret = gen_array_ops.transpose(a, perm, name=name)

return ret

def zeros(shape, dtype=dtypes.float32, name=None):

"""Creates a tensor with all elements set to zero.

This operation returns a tensor of type `dtype` with shape `shape` and

all elements set to zero.

For example:

```python

tf.zeros([3, 4], int32) ==> [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

```

Args:

shape: Either a list of integers, or a 1-D `Tensor` of type `int32`.

dtype: The type of an element in the resulting `Tensor`.

name: A name for the operation (optional).

Returns:

A `Tensor` with all elements set to zero.

"""

with ops.op_scope([shape], name, "zeros") as name:

try:

shape = tensor_shape.as_shape(shape)

output = constant(0, shape=shape, dtype=dtype, name=name)

except (TypeError, ValueError):

shape = ops.convert_to_tensor(shape, dtype=dtypes.int32, name="shape")

output = fill(shape, constant(0, dtype=dtype), name=name)

assert output.dtype.base_dtype == dtypes.as_dtype(dtype).base_dtype

return output

def zeros_like(tensor, dtype=None, name=None):

"""Creates a tensor with all elements set to zero.

Given a single tensor (`tensor`), this operation returns a tensor of the

same type and shape as `tensor` with all elements set to zero. Optionally,

you can use `dtype` to specify a new type for the returned tensor.

For example:

```python

# 'tensor' is [[1, 2, 3], [4, 5, 6]]

tf.zeros_like(tensor) ==> [[0, 0, 0], [0, 0, 0]]

```

Args:

tensor: A `Tensor`.

dtype: A type for the returned `Tensor`. Must be `float32`, `float64`,

`int8`, `int16`, `int32`, `int64`, `uint8`, `complex64`, or `complex128`.

name: A name for the operation (optional).

Returns:

A `Tensor` with all elements set to zero.

"""

with ops.op_scope([tensor], name, "zeros_like") as name:

tensor = ops.convert_to_tensor(tensor, name="tensor")

if dtype is not None and tensor.dtype != dtype:

ret = zeros(shape(tensor), dtype, name=name)

ret.set_shape(tensor.get_shape())

return ret

else:

return gen_array_ops._zeros_like(tensor, name=name)

def ones_like(tensor, dtype=None, name=None):

"""Creates a tensor with all elements set to 1.

Given a single tensor (`tensor`), this operation returns a tensor of the same

type and shape as `tensor` with all elements set to 1. Optionally, you can

specify a new type (`dtype`) for the returned tensor.

For example:

```python

# 'tensor' is [[1, 2, 3], [4, 5, 6]]

tf.ones_like(tensor) ==> [[1, 1, 1], [1, 1, 1]]

```

Args:

tensor: A `Tensor`.

dtype: A type for the returned `Tensor`. Must be `float32`, `float64`,

`int8`, `int16`, `int32`, `int64`, `uint8`, `complex64`, or `complex128`.

name: A name for the operation (optional).

Returns:

A `Tensor` with all elements set to 1.

"""

with ops.op_scope([tensor], name, "ones_like") as name:

tensor = ops.convert_to_tensor(tensor, name="tensor")

ones_shape = shape(tensor)

if dtype is None:

dtype = tensor.dtype

ret = ones(ones_shape, dtype=dtype, name=name)

ret.set_shape(tensor.get_shape())

return ret

def ones(shape, dtype=dtypes.float32, name=None):

"""Creates a tensor with all elements set to 1.

This operation returns a tensor of type `dtype` with shape `shape` and all

elements set to 1.

For example:

```python

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

```

Args:

shape: Either a list of integers, or a 1-D `Tensor` of type `int32`.

dtype: The type of an element in the resulting `Tensor`.

name: A name for the operation (optional).

Returns:

A `Tensor` with all elements set to 1.

"""

with ops.op_scope([shape], name, "ones") as name:

try:

shape = tensor_shape.as_shape(shape)

output = constant(1, shape=shape, dtype=dtype, name=name)

except (TypeError, ValueError):

shape = ops.convert_to_tensor(shape, dtype=dtypes.int32, name="shape")

output = fill(shape, constant(1, dtype=dtype), name=name)

assert output.dtype.base_dtype == dtypes.as_dtype(dtype).base_dtype

return output

def placeholder(dtype, shape=None, name=None):

"""Inserts a placeholder for a tensor that will be always fed.

**Important**: This tensor will produce an error if evaluated. Its value must

be fed using the `feed_dict` optional argument to `Session.run()`,

`Tensor.eval()`, or `Operation.run()`.

For example:

```python

x = tf.placeholder(tf.float32, shape=(1024, 1024))

y = tf.matmul(x, x)

with tf.Session() as sess:

print(sess.run(y)) # ERROR: will fail because x was not fed.

rand_array = np.random.rand(1024, 1024)

print(sess.run(y, feed_dict={x: rand_array})) # Will succeed.

```

Args:

dtype: The type of elements in the tensor to be fed.

shape: The shape of the tensor to be fed (optional). If the shape is not

specified, you can feed a tensor of any shape.

name: A name for the operation (optional).

Returns:

A `Tensor` that may be used as a handle for feeding a value, but not

evaluated directly.

"""

shape = tensor_shape.as_shape(shape)

if shape.is_fully_defined():

dim_list = shape.as_list()

else:

dim_list = []

ret = gen_array_ops._placeholder(

dtype=dtype,

shape=dim_list,

name=name)

ret.set_shape(shape)

return ret

def sparse_placeholder(dtype, shape=None, name=None):

"""Inserts a placeholder for a sparse tensor that will be always fed.

**Important**: This sparse tensor will produce an error if evaluated.

Its value must be fed using the `feed_dict` optional argument to

`Session.run()`, `Tensor.eval()`, or `Operation.run()`.

For example:

```python

x = tf.sparse_placeholder(tf.float32)

y = tf.sparse_reduce_sum(x)

with tf.Session() as sess:

print(sess.run(y)) # ERROR: will fail because x was not fed.

indices = np.array([[3, 2, 0], [4, 5, 1]], dtype=np.int64)

values = np.array([1.0, 2.0], dtype=np.float32)

shape = np.array([7, 9, 2], dtype=np.int64)

print(sess.run(y, feed_dict={

x: tf.SparseTensorValue(indices, values, shape)})) # Will succeed.

print(sess.run(y, feed_dict={

x: (indices, values, shape)})) # Will succeed.

sp = tf.SparseTensor(indices=indices, values=values, shape=shape)

sp_value = sp.eval(session)

print(sess.run(y, feed_dict={x: sp_value})) # Will succeed.

```

Args:

dtype: The type of `values` elements in the tensor to be fed.

shape: The shape of the tensor to be fed (optional). If the shape is not

specified, you can feed a sparse tensor of any shape.

name: A name for prefixing the operations (optional).

Returns:

A `SparseTensor` that may be used as a handle for feeding a value, but not

evaluated directly.

"""

if shape is None:

shape = placeholder(

dtypes.int64, name=(name + "/shape") if name is not None else None)

else:

shape = ops.convert_to_tensor(

shape, name=(name + "/shape") if name is not None else None)

return ops.SparseTensor(

values=placeholder(

dtype, name=(name + "/values") if name is not None else None),

indices=placeholder(

dtypes.int64,

name=(name + "/indices") if name is not None else None),

shape=shape

)

def pad(tensor, paddings, mode="CONSTANT", name=None): # pylint: disable=invalid-name

"""Pads a tensor.

This operation pads a `tensor` according to the `paddings` you specify.

`paddings` is an integer tensor with shape `[n, 2]`, where n is the rank of

`tensor`. For each dimension D of `input`, `paddings[D, 0]` indicates how

many values to add before the contents of `tensor` in that dimension, and

`paddings[D, 1]` indicates how many values to add after the contents of

`tensor` in that dimension. If `mode` is "REFLECT" then both `paddings[D, 0]`

and `paddings[D, 1]` must be no greater than `tensor.dim_size(D) - 1`. If

`mode` is "SYMMETRIC" then both `paddings[D, 0]` and `paddings[D, 1]` must be

no greater than `tensor.dim_size(D)`.

The padded size of each dimension D of the output is:

`paddings[D, 0] + tensor.dim_size(D) + paddings[D, 1]`

For example:

```python

# 't' is [[1, 2, 3], [4, 5, 6]].

# 'paddings' is [[1, 1,], [2, 2]].

# rank of 't' is 2.

pad(t, paddings, "CONSTANT") ==> [[0, 0, 0, 0, 0, 0, 0],

[0, 0, 1, 2, 3, 0, 0],

[0, 0, 4, 5, 6, 0, 0],

[0, 0, 0, 0, 0, 0, 0]]

pad(t, paddings, "REFLECT") ==> [[6, 5, 4, 5, 6, 5, 4],

[3, 2, 1, 2, 3, 2, 1],

[6, 5, 4, 5, 6, 5, 4],

[3, 2, 1, 2, 3, 2, 1]]

pad(t, paddings, "SYMMETRIC") ==> [[2, 1, 1, 2, 3, 3, 2],

[2, 1, 1, 2, 3, 3, 2],

[5, 4, 4, 5, 6, 6, 5],

[5, 4, 4, 5, 6, 6, 5]]

```

Args:

tensor: A `Tensor`.

paddings: A `Tensor` of type `int32`.

mode: One of "CONSTANT", "REFLECT", or "SYMMETRIC".

name: A name for the operation (optional).

Returns: