Function ragged_tensor_getitem

tensorflow/python/ops/ragged/ragged_getitem.py:31–104

Returns the specified piece of this RaggedTensor. Supports multidimensional indexing and slicing, with one restriction: indexing into a ragged inner dimension is not allowed. This case is problematic because the indicated value may exist in some rows but not others. In such cases, it's no

(self, key)

def ragged_tensor_getitem(self, key):
  """Returns the specified piece of this RaggedTensor.

  Supports multidimensional indexing and slicing, with one restriction:
  indexing into a ragged inner dimension is not allowed.  This case is
  problematic because the indicated value may exist in some rows but not
  others.  In such cases, it's not obvious whether we should (1) report an
  IndexError; (2) use a default value; or (3) skip that value and return a
  tensor with fewer rows than we started with.  Following the guiding
  principles of Python ("In the face of ambiguity, refuse the temptation to
  guess"), we simply disallow this operation.

  Any dimensions added by `array_ops.newaxis` will be ragged if the following
  dimension is ragged.

  Args:
    self: The RaggedTensor to slice.
    key: Indicates which piece of the RaggedTensor to return, using standard
      Python semantics (e.g., negative values index from the end).  `key`
      may have any of the following types:

      * `int` constant
      * Scalar integer `Tensor`
      * `slice` containing integer constants and/or scalar integer
        `Tensor`s
      * `Ellipsis`
      * `tf.newaxis`
      * `tuple` containing any of the above (for multidimentional indexing)

  Returns:
    A `Tensor` or `RaggedTensor` object.  Values that include at least one
    ragged dimension are returned as `RaggedTensor`.  Values that include no
    ragged dimensions are returned as `Tensor`.  See above for examples of
    expressions that return `Tensor`s vs `RaggedTensor`s.

  Raises:
    ValueError: If `key` is out of bounds.
    ValueError: If `key` is not supported.
    TypeError: If the indices in `key` have an unsupported type.

  Examples:

    ```python
    >>> # A 2-D ragged tensor with 1 ragged dimension.
    >>> rt = ragged.constant([['a', 'b', 'c'], ['d', 'e'], ['f'], ['g']])
    >>> rt[0].eval().tolist()       # First row (1-D `Tensor`)
    ['a', 'b', 'c']
    >>> rt[:3].eval().tolist()      # First three rows (2-D RaggedTensor)
    [['a', 'b', 'c'], ['d', 'e'], '[f'], [g']]
    >>> rt[3, 0].eval().tolist()    # 1st element of 4th row (scalar)
    'g'

    >>> # A 3-D ragged tensor with 2 ragged dimensions.
    >>> rt = ragged.constant([[[1, 2, 3], [4]],
    ...                    [[5], [], [6]],
    ...                    [[7]],
    ...                    [[8, 9], [10]]])
    >>> rt[1].eval().tolist()       # Second row (2-D RaggedTensor)