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

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

# pylint: disable=g-short-docstring-punctuation

"""Sparse Tensor Representation.

See also `tf.sparse.SparseTensor`.

API docstring: tensorflow.sparse

"""

import numbers

import numpy as np

from tensorflow.python.framework import composite_tensor

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 as tensor_lib

from tensorflow.python.framework import tensor_conversion

from tensorflow.python.framework import tensor_shape

from tensorflow.python.framework import tensor_util

from tensorflow.python.ops import array_ops

from tensorflow.python.ops import array_ops_stack

from tensorflow.python.ops import bincount_ops

from tensorflow.python.ops import check_ops

from tensorflow.python.ops import control_flow_ops

from tensorflow.python.ops import gen_count_ops

from tensorflow.python.ops import gen_math_ops

from tensorflow.python.ops import gen_sparse_ops

from tensorflow.python.ops import math_ops

from tensorflow.python.ops import special_math_ops

# go/tf-wildcard-import

# pylint: disable=wildcard-import

from tensorflow.python.ops.gen_sparse_ops import *

# pylint: enable=wildcard-import

from tensorflow.python.util import compat

from tensorflow.python.util import deprecation

from tensorflow.python.util import dispatch

from tensorflow.python.util import nest

from tensorflow.python.util import tf_inspect

from tensorflow.python.util.compat import collections_abc

from tensorflow.python.util.tf_export import get_canonical_name_for_symbol

from tensorflow.python.util.tf_export import tf_export

def _convert_to_sparse_tensor(sp_input):

"""Convert `sp_input` to `SparseTensor` and return it.

Args:

sp_input: `SparseTensor` or `SparseTensorValue`.

Returns:

`sp_input` converted to `SparseTensor`.

Raises:

ValueError: if `sp_input` is neither `SparseTensor` nor `SparseTensorValue`.

"""

if isinstance(sp_input, sparse_tensor.SparseTensorValue):

return sparse_tensor.SparseTensor.from_value(sp_input)

if not isinstance(sp_input, sparse_tensor.SparseTensor):

raise TypeError("Input must be a SparseTensor.")

return sp_input

def _convert_to_sparse_tensors(sp_inputs):

"""Convert `sp_inputs` to `SparseTensor` objects and return them.

Args:

sp_inputs: `list` or `tuple` of `SparseTensor` or `SparseTensorValue`

objects.

Returns:

`sp_inputs` converted to `SparseTensor` objects.

Raises:

ValueError: if any item in `sp_inputs` is neither `SparseTensor` nor

`SparseTensorValue`.

"""

if isinstance(sp_inputs, list):

return [_convert_to_sparse_tensor(sp_input) for sp_input in sp_inputs]

if isinstance(sp_inputs, tuple):

return (_convert_to_sparse_tensor(sp_input) for sp_input in sp_inputs)

raise TypeError("Inputs must be a list or tuple.")

def _make_int64_tensor(value, name):

if isinstance(value, compat.integral_types):

return ops.convert_to_tensor(value, name=name, dtype=dtypes.int64)

if not isinstance(value, tensor_lib.Tensor):

raise TypeError("{} must be an integer value".format(name))

if value.dtype == dtypes.int64:

return value

return math_ops.cast(value, dtypes.int64)

@tf_export("sparse.from_dense")

def from_dense(tensor, name=None):

"""Converts a dense tensor into a sparse tensor.

Only elements not equal to zero will be present in the result. The resulting

`SparseTensor` has the same dtype and shape as the input.

>>> sp = tf.sparse.from_dense([0, 0, 3, 0, 1])

>>> sp.shape.as_list()

[5]

>>> sp.values.numpy()

array([3, 1], dtype=int32)

>>> sp.indices.numpy()

array([[2],

[4]])

Args:

tensor: A dense `Tensor` to be converted to a `SparseTensor`.

name: Optional name for the op.

Returns:

The `SparseTensor`.

"""

with ops.name_scope(name, "dense_to_sparse"):

tensor = ops.convert_to_tensor(tensor)

indices = array_ops.where_v2(

math_ops.not_equal(tensor, array_ops.zeros_like(tensor)))

values = array_ops.gather_nd(tensor, indices)

shape = array_ops.shape(tensor, out_type=dtypes.int64)

return sparse_tensor.SparseTensor(indices, values, shape)

@tf_export("sparse.expand_dims")

def sparse_expand_dims(sp_input, axis=None, name=None):

"""Returns a tensor with an 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 sparse tensor with shape `[height, width, depth]`:

>>> sp = tf.sparse.SparseTensor(indices=[[3,4,1]], values=[7,],

... dense_shape=[10,10,3])

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

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

[1, 10, 10, 3]

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

>>> tf.sparse.expand_dims(sp, 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.sparse.expand_dims(sp, axis=-1).shape.as_list()

[10, 10, 3, 1]

Note: Unlike `tf.expand_dims` this function includes a default value for the

`axis`: `-1`. So if `axis is not specified, an inner dimension is added.

>>> sp.shape.as_list()

[10, 10, 3]

>>> tf.sparse.expand_dims(sp).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.expand_dims`, which provides this functionality for dense tensors.

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

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

Args:

sp_input: A `SparseTensor`.

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

shape of `input`. Must be in the range `[-rank(sp_input) - 1,

rank(sp_input)]`. Defaults to `-1`.

name: The name of the output `SparseTensor`.

Returns:

A `SparseTensor` with the same data as `sp_input`, but its shape has an

additional dimension of size 1 added.

"""

rank = sp_input.dense_shape.get_shape()[0]

if rank is None:

rank = array_ops.shape(sp_input.dense_shape)[0]

axis = -1 if axis is None else axis

with ops.name_scope(name, default_name="expand_dims", values=[sp_input]):

if isinstance(axis, compat.integral_types):

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

elif not isinstance(axis, tensor_lib.Tensor):

raise TypeError("axis must be an integer value in range [-rank(sp_input)"

" - 1, rank(sp_input)]")

# Convert axis to a positive value if it is negative.

axis = array_ops.where_v2(axis >= 0, axis, axis + rank + 1)

# Create the new column of indices for the sparse tensor by slicing

# the indices and inserting a new column of indices for the new dimension.

column_size = array_ops.shape(sp_input.indices)[0]

new_index = array_ops.zeros([column_size, 1], dtype=dtypes.int64)

indices_before = array_ops.slice(sp_input.indices, [0, 0], [-1, axis])

indices_after = array_ops.slice(sp_input.indices, [0, axis], [-1, -1])

indices = array_ops.concat(

[indices_before, new_index, indices_after], axis=1)

# Create the new dense shape by splicing the tensor [1] in the correct

# dimension of the existing shape.

shape_before = array_ops.slice(sp_input.dense_shape, [0], [axis])

shape_after = array_ops.slice(sp_input.dense_shape, [axis], [-1])

new_shape = ops.convert_to_tensor([1], name="new_shape", dtype=dtypes.int64)

shape = array_ops.concat([shape_before, new_shape, shape_after], axis=0)

# Create the output sparse tensor.

return sparse_tensor.SparseTensor(

indices=indices, values=sp_input.values, dense_shape=shape)

@tf_export("sparse.eye")

def sparse_eye(num_rows,

num_columns=None,

dtype=dtypes.float32,

name=None):

"""Creates a two-dimensional sparse tensor with ones along the diagonal.

Args:

num_rows: Non-negative integer or `int32` scalar `tensor` giving the number

of rows in the resulting matrix.

num_columns: Optional non-negative integer or `int32` scalar `tensor` giving

the number of columns in the resulting matrix. Defaults to `num_rows`.

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

name: A name for this `Op`. Defaults to "eye".

Returns:

A `SparseTensor` of shape [num_rows, num_columns] with ones along the

diagonal.

"""

with ops.name_scope(name, default_name="eye", values=[num_rows, num_columns]):

num_rows = _make_int64_tensor(num_rows, "num_rows")

num_columns = num_rows if num_columns is None else _make_int64_tensor(

num_columns, "num_columns")

# Create the sparse tensor.

diag_size = math_ops.minimum(num_rows, num_columns)

diag_range = math_ops.range(diag_size, dtype=dtypes.int64)

return sparse_tensor.SparseTensor(

indices=array_ops_stack.stack([diag_range, diag_range], axis=1),

values=array_ops.ones(diag_size, dtype=dtype),

dense_shape=[num_rows, num_columns])

# pylint: disable=protected-access

@tf_export(v1=["sparse.concat", "sparse_concat"])

@deprecation.deprecated_endpoints("sparse_concat")

@deprecation.deprecated_args(

None, "concat_dim is deprecated, use axis instead", "concat_dim")

def sparse_concat(axis,

sp_inputs,

name=None,

expand_nonconcat_dim=False,

concat_dim=None,

expand_nonconcat_dims=None):

"""Concatenates a list of `SparseTensor` along the specified dimension.

Concatenation is with respect to the dense versions of each sparse input.

It is assumed that each inputs is a `SparseTensor` whose elements are ordered

along increasing dimension number.

If expand_nonconcat_dim is False, all inputs' shapes must match, except for

the concat dimension. If expand_nonconcat_dim is True, then inputs' shapes are

allowed to vary among all inputs.

The `indices`, `values`, and `shapes` lists must have the same length.

If expand_nonconcat_dim is False, then the output shape is identical to the

inputs', except along the concat dimension, where it is the sum of the inputs'

sizes along that dimension.

If expand_nonconcat_dim is True, then the output shape along the non-concat

dimensions will be expand to be the largest among all inputs, and it is the

sum of the inputs sizes along the concat dimension.

The output elements will be resorted to preserve the sort order along

increasing dimension number.

This op runs in `O(M log M)` time, where `M` is the total number of non-empty

values across all inputs. This is due to the need for an internal sort in

order to concatenate efficiently across an arbitrary dimension.

For example, if `axis = 1` and the inputs are

sp_inputs[0]: shape = [2, 3]

[0, 2]: "a"

[1, 0]: "b"

[1, 1]: "c"

sp_inputs[1]: shape = [2, 4]

[0, 1]: "d"

[0, 2]: "e"

then the output will be

shape = [2, 7]

[0, 2]: "a"

[0, 4]: "d"

[0, 5]: "e"

[1, 0]: "b"

[1, 1]: "c"

Graphically this is equivalent to doing

[ a] concat [ d e ] = [ a d e ]

[b c ] [ ] [b c ]

Another example, if 'axis = 1' and the inputs are

sp_inputs[0]: shape = [3, 3]

[0, 2]: "a"

[1, 0]: "b"

[2, 1]: "c"

sp_inputs[1]: shape = [2, 4]

[0, 1]: "d"

[0, 2]: "e"

if expand_nonconcat_dim = False, this will result in an error. But if

expand_nonconcat_dim = True, this will result in:

shape = [3, 7]

[0, 2]: "a"

[0, 4]: "d"

[0, 5]: "e"

[1, 0]: "b"

[2, 1]: "c"

Graphically this is equivalent to doing

[ a] concat [ d e ] = [ a d e ]

[b ] [ ] [b ]

[ c ] [ c ]

Args:

axis: Dimension to concatenate along. Must be in range [-rank, rank),

where rank is the number of dimensions in each input `SparseTensor`.

sp_inputs: List of `SparseTensor` to concatenate.

name: A name prefix for the returned tensors (optional).

expand_nonconcat_dim: Whether to allow the expansion in the non-concat

dimensions. Defaulted to False.

concat_dim: The old (deprecated) name for axis.

expand_nonconcat_dims: alias for expand_nonconcat_dim

Returns:

A `SparseTensor` with the concatenated output.

Raises:

TypeError: If `sp_inputs` is not a list of `SparseTensor`.

"""

expand_nonconcat_dim = deprecation.deprecated_argument_lookup(

"expand_nonconcat_dims", expand_nonconcat_dims,

"expand_nonconcat_dim", expand_nonconcat_dim)

if expand_nonconcat_dims is not None:

expand_nonconcat_dim = expand_nonconcat_dims

axis = deprecation.deprecated_argument_lookup("axis", axis, "concat_dim",

concat_dim)

return sparse_concat_v2(axis, sp_inputs, expand_nonconcat_dim, name)

@tf_export("sparse.concat", v1=[])

def sparse_concat_v2(axis, sp_inputs, expand_nonconcat_dims=False, name=None): # pylint: disable=missing-docstring

sp_inputs = _convert_to_sparse_tensors(sp_inputs)

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

return sp_inputs[0]

inds = [sp_input.indices for sp_input in sp_inputs]

vals = [sp_input.values for sp_input in sp_inputs]

shapes = [sp_input.dense_shape for sp_input in sp_inputs]

if expand_nonconcat_dims:

max_shape = math_ops.reduce_max(

array_ops.concat(

[array_ops.reshape(shape, [1, -1]) for shape in shapes], 0), 0)

shapes = [

array_ops.concat([

max_shape[:axis], shape[-1:]

if axis == -1 else shape[axis:axis + 1], []

if axis == -1 else max_shape[axis + 1:]

], 0) for shape in shapes

]

output_ind, output_val, output_shape = (

gen_sparse_ops.sparse_concat(inds, vals, shapes, axis, name=name))

input_shapes = [inp.shape for inp in sp_inputs]

if all(shape.rank is not None for shape in input_shapes):

if expand_nonconcat_dims:

static_output_shape = []

for dim in range(input_shapes[0].rank):

static_output_shape.append(

max(tensor_shape.dimension_at_index(shape, dim)

for shape in input_shapes))

else:

static_output_shape = input_shapes[0].as_list()

static_output_shape[axis] = sum(

tensor_shape.dimension_at_index(shape, axis)

for shape in input_shapes)

else:

static_output_shape = tensor_shape.unknown_shape()

if all(shape.is_fully_defined() for shape in input_shapes):

output_shape = ops.convert_to_tensor(static_output_shape,

dtype=dtypes.int64)

return sparse_tensor.SparseTensor(output_ind, output_val, output_shape)

else:

# In case there are partially defined shape, we couldn't update the

# output_shape tensor value. We update the output._dense_shape_default,

# which populate output.shape as the best effort.

output = sparse_tensor.SparseTensor(output_ind, output_val, output_shape)

output.set_shape(tensor_shape.TensorShape(static_output_shape))

return output

sparse_concat_v2.__doc__ = sparse_concat.__doc__.replace(

" concat_dim: The old (deprecated) name for axis.\n",

"").replace(" expand_nonconcat_dims: alias for expand_nonconcat_dim\n",

"")

@tf_export(v1=["sparse.add", "sparse_add"])

@deprecation.deprecated_endpoints("sparse_add")

@deprecation.deprecated_args(

None, "thresh is deprecated, use threshold instead", "thresh")

def sparse_add(a, b, threshold=None, thresh=None):

"""Adds two tensors, at least one of each is a `SparseTensor`.

If one `SparseTensor` and one `Tensor` are passed in, returns a `Tensor`. If

both arguments are `SparseTensor`s, this returns a `SparseTensor`. The order

of arguments does not matter. Use vanilla `tf.add()` for adding two dense

`Tensor`s.

The shapes of the two operands must match: broadcasting is not supported.

The indices of any input `SparseTensor` are assumed ordered in standard

lexicographic order. If this is not the case, before this step run

`SparseReorder` to restore index ordering.

If both arguments are sparse, we perform "clipping" as follows. By default,

if two values sum to zero at some index, the output `SparseTensor` would still

include that particular location in its index, storing a zero in the

corresponding value slot. To override this, callers can specify `thresh`,

indicating that if the sum has a magnitude strictly smaller than `thresh`, its

corresponding value and index would then not be included. In particular,

`thresh == 0.0` (default) means everything is kept and actual thresholding

happens only for a positive value.

For example, suppose the logical sum of two sparse operands is (densified):

[ 2]

[.1 0]

[ 6 -.2]

Then,

* `thresh == 0` (the default): all 5 index/value pairs will be returned.

* `thresh == 0.11`: only .1 and 0 will vanish, and the remaining three

index/value pairs will be returned.

* `thresh == 0.21`: .1, 0, and -.2 will vanish.

Args:

a: The first operand; `SparseTensor` or `Tensor`.

b: The second operand; `SparseTensor` or `Tensor`. At least one operand

must be sparse.

threshold: An optional 0-D `Tensor` (defaults to `0`). The magnitude

threshold that determines if an output value/index pair takes space. Its

dtype should match that of the values if they are real; if the latter are

complex64/complex128, then the dtype should be float32/float64,

correspondingly.

thresh: Deprecated alias for `threshold`.

Returns:

A `SparseTensor` or a `Tensor`, representing the sum.

Raises:

TypeError: If both `a` and `b` are `Tensor`s. Use `tf.add()` instead.

"""

threshold = deprecation.deprecated_argument_lookup("threshold", threshold,

"thresh", thresh)

if threshold is None:

threshold = 0

return sparse_add_v2(a, b, threshold)

@tf_export("sparse.add", v1=[])

def sparse_add_v2(a, b, threshold=0):

"""Adds two tensors, at least one of each is a `SparseTensor`.

If one `SparseTensor` and one `Tensor` are passed in, returns a `Tensor`. If

both arguments are `SparseTensor`s, this returns a `SparseTensor`. The order

of arguments does not matter. Use vanilla `tf.add()` for adding two dense

`Tensor`s.

The shapes of the two operands must match: broadcasting is not supported.

The indices of any input `SparseTensor` are assumed ordered in standard

lexicographic order. If this is not the case, before this step run

`SparseReorder` to restore index ordering.

If both arguments are sparse, we perform "clipping" as follows. By default,

if two values sum to zero at some index, the output `SparseTensor` would still

include that particular location in its index, storing a zero in the

corresponding value slot. To override this, callers can specify `threshold`,

indicating that if the sum has a magnitude strictly smaller than `threshold`,

its corresponding value and index would then not be included. In particular,

`threshold == 0.0` (default) means everything is kept and actual thresholding

happens only for a positive value.

For example, suppose the logical sum of two sparse operands is (densified):

[ 2]

[.1 0]

[ 6 -.2]

Then,

* `threshold == 0` (the default): all 5 index/value pairs will be

returned.

* `threshold == 0.11`: only .1 and 0 will vanish, and the remaining three

index/value pairs will be returned.

* `threshold == 0.21`: .1, 0, and -.2 will vanish.

Args:

a: The first operand; `SparseTensor` or `Tensor`.

b: The second operand; `SparseTensor` or `Tensor`. At least one operand

must be sparse.

threshold: A 0-D `Tensor`. The magnitude threshold that determines if an

output value/index pair takes space. Its dtype should match that of the

values if they are real; if the latter are complex64/complex128, then the

dtype should be float32/float64, correspondingly.

Returns:

A `SparseTensor` or a `Tensor`, representing the sum.

Raises:

TypeError: If both `a` and `b` are `Tensor`s. Use `tf.add()` instead.

"""

sparse_classes = (sparse_tensor.SparseTensor, sparse_tensor.SparseTensorValue)

if not any(isinstance(inp, sparse_classes) for inp in [a, b]):

raise TypeError("At least one input should be SparseTensor; do you mean to"

" use tf.add()?")

if all(isinstance(inp, sparse_classes) for inp in [a, b]):

a = _convert_to_sparse_tensor(a)

b = _convert_to_sparse_tensor(b)

threshold = ops.convert_to_tensor(

threshold, dtype=a.values.dtype.real_dtype.base_dtype, name="threshold")

output_ind, output_val, output_shape = (

gen_sparse_ops.sparse_add(a.indices, a.values, a.dense_shape,

b.indices, b.values, b.dense_shape,

threshold))

# Attempt to get output_shape statically.

a.get_shape().assert_is_compatible_with(b.get_shape())

static_shape = array_ops.broadcast_static_shape(a.get_shape(),

b.get_shape())

if static_shape.is_fully_defined():

output_shape = static_shape.as_list()

return sparse_tensor.SparseTensor(output_ind, output_val, output_shape)

else:

# swap to make `a` the SparseTensor.

if isinstance(b, sparse_classes):

a, b = b, a

return gen_sparse_ops.sparse_tensor_dense_add(a.indices, a.values,

a.dense_shape, b)

@tf_export("sparse.cross")

def sparse_cross(inputs, name=None, separator=None):

"""Generates sparse cross from a list of sparse and dense tensors.

For example, if the inputs are

* inputs[0]: SparseTensor with shape = [2, 2]

[0, 0]: "a"

[1, 0]: "b"

[1, 1]: "c"

* inputs[1]: SparseTensor with shape = [2, 1]

[0, 0]: "d"

[1, 0]: "e"

* inputs[2]: Tensor [["f"], ["g"]]

then the output will be:

shape = [2, 2]

[0, 0]: "a_X_d_X_f"

[1, 0]: "b_X_e_X_g"

[1, 1]: "c_X_e_X_g"

Customized separator "_Y_":

>>> inp_0 = tf.constant([['a'], ['b']])

>>> inp_1 = tf.constant([['c'], ['d']])

>>> output = tf.sparse.cross([inp_0, inp_1], separator='_Y_')

>>> output.values

<tf.Tensor: shape=(2,), dtype=string, numpy=array([b'a_Y_c', b'b_Y_d'],

dtype=object)>

Args:

inputs: An iterable of `Tensor` or `SparseTensor`.

name: Optional name for the op.

separator: A string added between each string being joined. Defaults to

'_X_'.

Returns:

A `SparseTensor` of type `string`.

"""

if separator is None:

separator = "_X_"

separator = ops.convert_to_tensor(separator, dtypes.string)

indices, values, shapes, dense_inputs = _sparse_cross_internal_v2(inputs)

indices_out, values_out, shape_out = gen_sparse_ops.sparse_cross_v2(

indices=indices,

values=values,

shapes=shapes,

dense_inputs=dense_inputs,

sep=separator,

name=name)

return sparse_tensor.SparseTensor(indices_out, values_out, shape_out)

_sparse_cross = sparse_cross

@tf_export("sparse.cross_hashed")

def sparse_cross_hashed(inputs, num_buckets=0, hash_key=None, name=None):

"""Generates hashed sparse cross from a list of sparse and dense tensors.

For example, if the inputs are

* inputs[0]: SparseTensor with shape = [2, 2]

[0, 0]: "a"

[1, 0]: "b"

[1, 1]: "c"

* inputs[1]: SparseTensor with shape = [2, 1]

[0, 0]: "d"

[1, 0]: "e"

* inputs[2]: Tensor [["f"], ["g"]]

then the output will be:

shape = [2, 2]

[0, 0]: FingerprintCat64(

Fingerprint64("f"), FingerprintCat64(

Fingerprint64("d"), Fingerprint64("a")))

[1, 0]: FingerprintCat64(

Fingerprint64("g"), FingerprintCat64(

Fingerprint64("e"), Fingerprint64("b")))

[1, 1]: FingerprintCat64(

Fingerprint64("g"), FingerprintCat64(

Fingerprint64("e"), Fingerprint64("c")))

Args:

inputs: An iterable of `Tensor` or `SparseTensor`.

num_buckets: An `int` that is `>= 0`.

output = hashed_value%num_buckets if num_buckets > 0 else hashed_value.

hash_key: Integer hash_key that will be used by the `FingerprintCat64`

function. If not given, will use a default key.

name: Optional name for the op.

Returns:

A `SparseTensor` of type `int64`.

"""

return _sparse_cross_internal(

inputs=inputs,

hashed_output=True,

num_buckets=num_buckets,

hash_key=hash_key,

name=name)

_sparse_cross_hashed = sparse_cross_hashed

_DEFAULT_HASH_KEY = 0xDECAFCAFFE

def _sparse_cross_internal_v2(inputs):

"""See gen_sparse_ops.sparse_cross_v2."""

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

raise TypeError("Inputs must be a list")

if not all(

isinstance(

i, sparse_tensor.SparseTensor) or isinstance(i, tensor_lib.Tensor)

for i in inputs):

raise TypeError("All inputs must be Tensor or SparseTensor.")

sparse_inputs = [

i for i in inputs if isinstance(i, sparse_tensor.SparseTensor)

]

dense_inputs = [

i for i in inputs if not isinstance(i, sparse_tensor.SparseTensor)

]

indices = [sp_input.indices for sp_input in sparse_inputs]

values = [sp_input.values for sp_input in sparse_inputs]

shapes = [sp_input.dense_shape for sp_input in sparse_inputs]

for i in range(len(values)):

if values[i].dtype != dtypes.string:

values[i] = math_ops.cast(values[i], dtypes.int64)

for i in range(len(dense_inputs)):

if dense_inputs[i].dtype != dtypes.string:

dense_inputs[i] = math_ops.cast(dense_inputs[i], dtypes.int64)

return indices, values, shapes, dense_inputs

def _sparse_cross_internal(inputs,

hashed_output=False,

num_buckets=0,

hash_key=None,

name=None):

"""See gen_sparse_ops.sparse_cross."""

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

raise TypeError("Inputs must be a list")

if not all(

isinstance(

i, sparse_tensor.SparseTensor) or isinstance(i, tensor_lib.Tensor)

for i in inputs):

raise TypeError("All inputs must be SparseTensors")

sparse_inputs = [

i for i in inputs if isinstance(i, sparse_tensor.SparseTensor)

]

dense_inputs = [

i for i in inputs if not isinstance(i, sparse_tensor.SparseTensor)

]

indices = [sp_input.indices for sp_input in sparse_inputs]

values = [sp_input.values for sp_input in sparse_inputs]

shapes = [sp_input.dense_shape for sp_input in sparse_inputs]

out_type = dtypes.int64 if hashed_output else dtypes.string

internal_type = dtypes.string

for i in range(len(values)):

if values[i].dtype != dtypes.string:

values[i] = math_ops.cast(values[i], dtypes.int64)

internal_type = dtypes.int64

for i in range(len(dense_inputs)):

if dense_inputs[i].dtype != dtypes.string:

dense_inputs[i] = math_ops.cast(dense_inputs[i], dtypes.int64)

internal_type = dtypes.int64

indices_out, values_out, shape_out = gen_sparse_ops.sparse_cross(

indices=indices,

values=values,

shapes=shapes,

dense_inputs=dense_inputs,

hashed_output=hashed_output,

num_buckets=num_buckets,

hash_key=hash_key or _DEFAULT_HASH_KEY,

out_type=out_type,

internal_type=internal_type,

name=name)

return sparse_tensor.SparseTensor(indices_out, values_out, shape_out)

def sparse_dense_cwise_add(sp_t, dense_t):

"""Adds up a SparseTensor and a dense Tensor, using these special rules:

(1) Broadcasts the dense side to have the same shape as the sparse side, if

eligible;

(2) Then, only the dense values pointed to by the indices of the SparseTensor

participate in the cwise addition.

By the rules, the result is a logical SparseTensor with exactly the same

indices and shape, but possibly with different non-zero values. The output of

this Op is the resultant non-zero values.

Args:

sp_t: the SparseTensor operand.

dense_t: the dense Tensor operand; must have the same dtype and a

broadcast-compatible shape as `sp_t`.

Returns:

output: the SparseTensor output.

"""

result = gen_sparse_ops.sparse_dense_cwise_add(sp_t.indices, sp_t.values,

sp_t.dense_shape, dense_t)

return sparse_tensor.SparseTensor(sp_t.indices, result, sp_t.dense_shape)

@tf_export("sparse.reorder", v1=["sparse.reorder", "sparse_reorder"])

@deprecation.deprecated_endpoints("sparse_reorder")

def sparse_reorder(sp_input, name=None):

"""Reorders a `SparseTensor` into the canonical, row-major ordering.

Note that by convention, all sparse ops preserve the canonical ordering

along increasing dimension number. The only time ordering can be violated

is during manual manipulation of the indices and values to add entries.

Reordering does not affect the shape of the `SparseTensor`.

For example, if `sp_input` has shape `[4, 5]` and `indices` / `values`:

[0, 3]: b

[0, 1]: a

[3, 1]: d

[2, 0]: c

then the output will be a `SparseTensor` of shape `[4, 5]` and

`indices` / `values`:

[0, 1]: a

[0, 3]: b

[2, 0]: c

[3, 1]: d

Args:

sp_input: The input `SparseTensor`.

name: A name prefix for the returned tensors (optional)

Returns:

A `SparseTensor` with the same shape and non-empty values, but in

canonical ordering.

Raises:

TypeError: If `sp_input` is not a `SparseTensor`.

"""

sp_input = _convert_to_sparse_tensor(sp_input)

reordered_ind, reordered_val = (

gen_sparse_ops.sparse_reorder(

sp_input.indices, sp_input.values, sp_input.dense_shape, name=name))

if sp_input.get_shape().is_fully_defined():

dense_shape = sp_input.get_shape().as_list()

return sparse_tensor.SparseTensor(reordered_ind, reordered_val, dense_shape)

else:

dense_shape = array_ops.identity(sp_input.dense_shape)

sp_output = sparse_tensor.SparseTensor(reordered_ind, reordered_val,

dense_shape)

# propagate the static shape

sp_output.set_shape(sp_input.shape)

return sp_output

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

@deprecation.deprecated_endpoints("sparse_reshape")

@dispatch.add_dispatch_support

def sparse_reshape(sp_input, shape, name=None):

"""Reshapes a `SparseTensor` to represent values in a new dense shape.

This operation has the same semantics as `reshape` on the represented dense

tensor. The indices of non-empty values in `sp_input` are recomputed based

on the new dense shape, and a new `SparseTensor` is returned containing the

new indices and new shape. The order of non-empty values in `sp_input` is

unchanged.

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

dimension is computed so that the total dense size remains constant. At

most one component of `shape` can be -1. The number of dense elements

implied by `shape` must be the same as the number of dense elements

originally represented by `sp_input`.

For example, if `sp_input` has shape `[2, 3, 6]` and `indices` / `values`:

[0, 0, 0]: a

[0, 0, 1]: b

[0, 1, 0]: c

[1, 0, 0]: d

[1, 2, 3]: e

and `shape` is `[9, -1]`, then the output will be a `SparseTensor` of

shape `[9, 4]` and `indices` / `values`:

[0, 0]: a

[0, 1]: b

[1, 2]: c

[4, 2]: d

[8, 1]: e

Args:

sp_input: The input `SparseTensor`.

shape: A 1-D (vector) int64 `Tensor` specifying the new dense shape of the

represented `SparseTensor`.

name: A name prefix for the returned tensors (optional)

Returns:

A `SparseTensor` with the same non-empty values but with indices calculated

by the new dense shape.

Raises:

TypeError: If `sp_input` is not a `SparseTensor`.

ValueError: If argument `shape` requests a `SparseTensor` with a different

number of elements than `sp_input`.

ValueError: If `shape` has more than one inferred (== -1) dimension.

"""

sp_input = _convert_to_sparse_tensor(sp_input)

shape = math_ops.cast(shape, dtype=dtypes.int64)

with ops.name_scope(name, "SparseReshape", [sp_input]) as name:

reshaped_ind, reshaped_shape = gen_sparse_ops.sparse_reshape(

sp_input.indices, sp_input.dense_shape, shape, name=name)

reshaped_shape_const = tensor_util.constant_value_as_shape(shape)

reshaped_shape_const = (

reshaped_shape_const.as_list() if reshaped_shape_const.ndims is not None

else None)

if (reshaped_shape_const is not None

and sp_input.shape.is_fully_defined()):

# constant_value_as_shape tends to get more information about the partial

# shape values, but here we specifically need to know if the *user* passed

# a shape with 2+ unknown dimensions; and for that constant_value

# provides either the user's direct value or None if only partial elements

# are known via the python shape inference code.

shape_const_by_user = tensor_util.constant_value(shape)

if shape_const_by_user is not None:

num_implied_by_user = sum(d == -1 for d in shape_const_by_user)

if num_implied_by_user > 1:

raise ValueError(

"At most one dimension can be inferred (-1). Found: %s"

% shape_const_by_user)

original_reshaped_shape = list(reshaped_shape_const) # A copy

in_shape_size = np.prod(sp_input.shape.as_list())

num_implied = sum(dim is None for dim in reshaped_shape_const)

# If there is a 0 dim in the user-provided shape, we cannot infer the

# unknown dim reliably. This is why we skip the `if` branch below when

# a 0 is present in `reshaped_shape_const`. Same below.

if num_implied == 1 and 0 not in reshaped_shape_const:

implied_idx = original_reshaped_shape.index(None)

non_implied_idx = (

original_reshaped_shape[:implied_idx] +

original_reshaped_shape[implied_idx + 1:])

reshaped_shape_const[implied_idx] = int(

in_shape_size // np.prod(non_implied_idx))

if num_implied == 0 or (num_implied == 1 and

0 not in reshaped_shape_const):

reshaped_size = np.prod(reshaped_shape_const)

if reshaped_size != in_shape_size:

raise ValueError(

"Cannot reshape a tensor with %d elements to shape %s "

"(%d elements)." %

(in_shape_size, original_reshaped_shape, reshaped_size))

reshaped_shape = constant_op.constant(

reshaped_shape_const, dtype=dtypes.int64)

return sparse_tensor.SparseTensor(reshaped_ind,

array_ops.identity(sp_input.values),

reshaped_shape)

# TODO(aselle): Remove keyword required once for 1.0 final

class KeywordRequired:

def __repr__(self):

# This is needed to make documentation without fully qualified module paths

return "KeywordRequired()"

@tf_export(v1=["sparse.split", "sparse_split"])

@deprecation.deprecated_endpoints("sparse_split")

@deprecation.deprecated_args(

None, "split_dim is deprecated, use axis instead", "split_dim")

def sparse_split(keyword_required=KeywordRequired(),

sp_input=None,

num_split=None,

axis=None,

name=None,

split_dim=None):