Link Search Menu Expand Document
enuSpace-tensorflow Manual

StridedSlice

tensorflow C++ API

tensorflow::ops::StridedSlice

Return a strided slice from input.

Summary

Note, most python users will want to use the PythonTensor.__getitem__orVariable.__getitem__rather than this op directly.

The goal of this op is to produce a new tensor with a subset of the elements from thendimensionalinputtensor. The subset is chosen using a sequence ofmsparse range specifications encoded into the arguments of this function. Note, in some casesmcould be equal ton, but this need not be the case. Each range specification entry can be one of the following:

  • An ellipsis (…). Ellipses are used to imply zero or more dimensions of full-dimension selection and are produced using ellipsis_mask. For example, foo[...] is the identity slice.
  • A new axis. This is used to insert a new shape=1 dimension and is produced using new_axis_mask. For example, foo[:, ...] where foo is shape (3, 4) produces a (1, 3, 4) tensor.
  • A range begin:end:stride. This is used to specify how much to choose from a given dimension. stride can be any integer but 0. begin is an integer which represents the index of the first value to select while end represents the index of the last value to select. The number of values selected in each dimension is end - begin if stride > 0 and begin - end if stride < 0. begin and end can be negative where -1 is the last element, -2 is the second to last. begin_mask controls whether to replace the explicitly given begin with an implicit effective value of 0 if stride > 0and -1 if stride < 0. end_mask is analogous but produces the number required to create the largest open interval. For example, given a shape(3,) tensor foo[:], the effective begin and end are 0 and 3. Do not assume this is equivalent to foo[0:-1] which has an effective begin and end of 0 and 2. Another example is foo[-2::-1] which reverses the first dimension of a tensor while dropping the last two (in the original order elements). For example foo = [1,2,3,4]; foo[-2::-1] is[4,3].
  • A single index. This is used to keep only elements that have a given index. For example (foo[2, :]on a shape (5,6) tensor produces a shape (6,) tensor. This is encoded in begin and end and shrink_axis_mask.

Each conceptual range specification is encoded in the op’s argument. This encoding is best understand by considering a non-trivial example. In particular,foo[1, 2:4, None, ..., :-3:-1, :]will be encoded as

``` begin = [1, 2, x, x, 0, x] # x denotes don’t care (usually 0) end = [2, 4, x, x, -3, x] strides = [1, 1, x, x, -1, 1] begin_mask = 1<<4 | 1 << 5 = 48 end_mask = 1<<5 = 32 ellipsis_mask = 1<<3 = 8 new_axis_mask = 1<<2 4 shrink_axis_mask = 1<<0 ```

In this case if `foo.shape` is (5, 5, 5, 5, 5, 5) the final shape of the slice becomes (2, 1, 5, 5, 2, 5). Let us walk step by step through each argument specification.

  1. The first argument in the example slice is turned into `begin = 1` and `end = begin + 1 = 2`. To disambiguate from the original spec `2:4` we also set the appropriate bit in `shrink_axis_mask`.
  2. `2:4` is contributes 2, 4, 1 to begin, end, and stride. All masks have zero bits contributed.
  3. None is a synonym for `tf.newaxis`. This means insert a dimension of size 1 dimension in the final shape. Dummy values are contributed to begin, end and stride, while the new_axis_mask bit is set.
  4. `…` grab the full ranges from as many dimensions as needed to fully specify a slice for every dimension of the input shape.
  5. `:-3:-1` shows the use of negative indices. A negative index `i` associated with a dimension that has shape `s` is converted to a positive index `s + i`. So `-1` becomes `s-1` (i.e. the last element). This conversion is done internally so begin, end and strides receive x, -3, and -1. The appropriate begin_mask bit is set to indicate the start range is the full range (ignoring the x).
  6. `:` indicates that the entire contents of the corresponding dimension is selected. This is equivalent to `::` or `0::1`. begin, end, and strides receive 0, 0, and 1, respectively. The appropriate bits in `begin_mask` and `end_mask` are also set.

*Requirements*: `0 != strides[i] for i in [0, m)` `ellipsis_mask must be a power of two (only one ellipsis)`

NOTE:beginandendare zero-indexed.strides` entries must be non-zero.

# 'input' is [[[1, 1, 1], [2, 2, 2]],
#             [[3, 3, 3], [4, 4, 4]],
#             [[5, 5, 5], [6, 6, 6]]]
tf.strided_slice(input,[1,0,0],[2,1,3],[1,1,1])==>[[[3,3,3]]]
tf.strided_slice(input,[1,0,0],[2,2,3],[1,1,1])==>[[[3,3,3],[4,4,4]]]
tf.strided_slice(input,[1,-1,0],[2,-3,3],[1,-1,1])==>[[[4,4,4],[3,3,3]]]

Arguments:

  • scope: A Scope object
  • begin: `begin[k]` specifies the offset into the `k`th range specification. The exact dimension this corresponds to will be determined by context. Out-of-bounds values will be silently clamped. If the `k`th bit of `begin_mask` then `begin[k]` is ignored and the full range of the appropriate dimension is used instead. Negative values causes indexing to start from the highest element e.g. If `foo==[1,2,3]` then `foo[-1]==3`.
  • end: `end[i]` is like `begin` with the exception that `end_mask` is used to determine full ranges.
  • strides: `strides[i]` specifies the increment in the `i`th specification after extracting a given element. Negative indices will reverse the original order. Out or range values are clamped to `[0,dim[i]) if slice[i]>0 or [-1,dim[i]-1] if slice[i] < 0`

Optional attributes (seeAttrs):

  • begin_mask: a bitmask where a bit i being 1 means to ignore the begin value and instead use the largest interval possible. At runtime begin[i] will be replaced with [0, n-1) if stride[i] > 0 or[-1, n-1] if stride[i] < 0
  • end_mask: analogous to begin_mask
  • ellipsis_mask: a bitmask where bit i being 1 means the i`th position is actually an ellipsis. One bit at most can be 1. If ellipsis_mask == 0, then an implicit ellipsis mask of 1 << (m+1) is provided. This means that foo[3:5] == foo[3:5, …]. An ellipsis implicitly creates as many range specifications as necessary to fully specify the sliced range for every dimension. For example for a 4-dimensional tensor foo the slice foo[2, …, 5:8] implies foo[2, :, :, 5:8].
  • new_axis_mask: a bitmask where bit i being 1 means the i th specification creates a new shape 1 dimension. For example foo[:4, tf.newaxis, :2] would produce a shape (4, 1, 2) tensor.
  • shrink_axis_mask: a bitmask where bit i implies that the i th specification should shrink the dimensionality. begin and end must imply a slice of size 1 in the dimension. For example in python one might do foo[:, 3, :] which would result in shrink_axis_mask being 2.

Returns:

StridedSlice block

Source link :https://github.com/EXPNUNI/enuSpaceTensorflow/blob/master/enuSpaceTensorflow/tf_array_ops.cpp

Argument:

  • Scope scope : A Scope object (A scope is generated automatically each page. A scope is not connected.)
  • Input input: A Tensor.
  • Input begin: An int32 or int64 Tensor. `begin[k]` specifies the offset into the `k`th range specification. The exact dimension this corresponds to will be determined by context. Out-of-bounds values will be silently clamped. If the `k`th bit of `begin_mask` then `begin[k]` is ignored and the full range of the appropriate dimension is used instead. Negative values causes indexing to start from the highest element e.g. If `foo==[1,2,3]` then `foo[-1]==3`.
  • Input end: An int32 or int64 Tensor. `end[i]` is like `begin` with the exception that `end_mask` is used to determine full ranges.
  • Input strides: An int32 or int64 Tensor. `strides[i]` specifies the increment in the `i`th specification after extracting a given element. Negative indices will reverse the original order. Out or range values are clamped to `[0,dim[i]) if slice[i]>0 or [-1,dim[i]-1] if slice[i] < 0`
  • StridedSlice::Attrs attrs:
    • begin_mask: a bitmask where a bit i being 1 means to ignore the begin value and instead use the largest interval possible. At runtime begin[i] will be replaced with [0, n-1) if stride[i] > 0 or[-1, n-1] if stride[i] < 0
    • end_mask: analogous to begin_mask
    • shrink_axis_mask: a bitmask where bit i implies that the i th specification should shrink the dimensionality. begin and end must imply a slice of size 1 in the dimension. For example in python one might do foo[:, 3, :] which would result in shrink_axis_mask being 2.
    • ellipsis_mask: a bitmask where bit i being 1 means the i`th position is actually an ellipsis. One bit at most can be 1. If ellipsis_mask == 0, then an implicit ellipsis mask of 1 << (m+1) is provided. This means that foo[3:5] == foo[3:5, …]. An ellipsis implicitly creates as many range specifications as necessary to fully specify the sliced range for every dimension. For example for a 4-dimensional tensor foo the slice foo[2, …, 5:8] implies foo[2, :, :, 5:8].
    • new_axis_mask: a bitmask where bit i being 1 means the i th specification creates a new shape 1 dimension. For example foo[:4, tf.newaxis, :2] would produce a shape (4, 1, 2) tensor.

Output:

  • Output output: Output object of StridedSlice class object.

Result:

  • std::vector(Tensor) result_output: A Tensor the same type as input.

Using Method

※input에서 특정한 부분을 잘라내는 기능을 한다. begin은 각 차원에서 잘라낼 시작지점(마이너스 값일 경우 reverse시키는것으로 보임), end는 어디까지 자를것인지 입력한다. strides는 몇 스텝을 이동할 것인지 정한다(ex: strides가 2일 경우 시작인 1에서 두칸 넘어간 3 그다음은 5 이런식이다.).