def dropout_v2(x: ragged_tensor.Ragged,
rate,
noise_shape=None,
seed=None,
name=None):
"""Ragged dispatch target for tf.nn.dropout."""
if noise_shape is not None:
raise ValueError('noise_shape is not supported yet for RaggedTensor x')
with ops.name_scope(name, 'RaggedNNDropout', [x, rate]):
x = ragged_tensor.convert_to_tensor_or_ragged_tensor(x, name='x')
return x.with_flat_values(
nn_ops.dropout_v2(x.flat_values, rate=rate, seed=seed))
def ragged_cumsum(x: ragged_tensor.Ragged,
axis: int = 0,
exclusive: bool = False,
reverse: bool = False,
name: typing.Optional[str] = None):
"""Calculate math_ops.cumsum for a RaggedTensor.
Given a ragged tensor `x`, the `result` is a ragged tensor with the same
shape. One can calculate the value of `result[i_1...i_k]` as follows:
```
dense_result=tf.math.cumsum(rt.to_tensor(), axis=axis, exclusive=exclusive,
reverse=reverse)
result[i_1...i_k]=dense_result[i_1...i_k]
```
Args:
x: the original ragged tensor to sum.
axis: the axis along which to sum, can range -rank<=axis<rank.
exclusive: is the sum exclusive or inclusive? If True, then result[0]=0.
If False, then result[0]=x[0].
reverse: If True, sum from back to front.
name: the name of the op.
Returns:
the cumulative sum.
"""
with ops.name_scope(name, 'RaggedCumSum', [x, axis, exclusive, reverse]):
axis = array_ops.get_positive_axis(axis, x.shape.rank, ndims_name='rank')
if axis == x.ragged_rank:
last_rp = x._nested_row_partitions[-1] # pylint: disable=protected-access
return x.with_flat_values(
_cumsum_flat_values_at_ragged_rank(last_rp, x.flat_values,
exclusive=exclusive,
reverse=reverse))
elif axis > x.ragged_rank:
new_axis = axis - x.ragged_rank
cumsum_bound = functools.partial(
math_ops.cumsum, axis=new_axis, exclusive=exclusive, reverse=reverse)
return ragged_functional_ops.map_flat_values(cumsum_bound, x)
else:
dense_version = x.to_tensor()
result = math_ops.cumsum(
dense_version, axis, exclusive=exclusive, reverse=reverse, name=name)
return ragged_tensor.RaggedTensor.from_tensor(
result, lengths=x.nested_row_lengths())
def ragged_one_hot(indices: ragged_tensor.Ragged,
depth,
on_value=None,
off_value=None,
axis=None,
dtype=None,
name=None):
"""Applies tf.one_hot along the values of a RaggedTensor."""
# Get the adjusted axis value for the call to array_ops.one_hot.
# Note: the only negative `axis` value supported by array_ops.one_hot is -1.
if isinstance(axis, int) and axis >= 0:
if axis <= indices.ragged_rank:
raise ValueError('axis (%d) must be greater than indices.ragged_rank '
'(%d).' % (axis, indices.ragged_rank))
axis -= indices.ragged_rank
with ops.name_scope(name, 'RaggedOneHot',
[indices, depth, on_value, off_value, axis]):
indices = ragged_tensor.convert_to_tensor_or_ragged_tensor(
indices, name='indices')
return indices.with_flat_values(
array_ops.one_hot(indices.flat_values, depth, on_value, off_value, axis,
dtype, name))