#include <array_ops.h>
Return a strided slice from input
.
Note, most python users will want to use the Python Tensor.__getitem__
or Variable.__getitem__
rather than this op directly.
The goal of this op is to produce a new tensor with a subset of the elements from the n
dimensional input
tensor. The subset is chosen using a sequence of m
sparse range specifications encoded into the arguments of this function. Note, in some cases m
could be equal to n
, but this need not be the case. Each range specification entry can be one of the following:
ellipsis_mask
. For example, foo[...]
is the identity slice.new_axis_mask
. For example, foo[:, ...]
where foo
is shape (3, 4)
produces a (1, 3, 4)
tensor.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 > 0
and -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]
.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.
*Requirements*: `0 != strides[i] for i in [0, m)` `ellipsis_mask must be a power of two (only one ellipsis)`
Arguments:
or
[-1,dim[i]-1] if slice[i] < 0`Optional attributes (see Attrs
):
[0, n-1) if
stride[i] > 0or
[-1, n-1]if
stride[i] < 0
end_mask: analogous to
begin_mask
ellipsis_mask: a bitmask where bit
ibeing 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]
.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.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:
Output
: The output tensor. Constructors and Destructors | |
---|---|
StridedSlice(const ::tensorflow::Scope & scope, ::tensorflow::Input input, ::tensorflow::Input begin, ::tensorflow::Input end, ::tensorflow::Input strides) | |
StridedSlice(const ::tensorflow::Scope & scope, ::tensorflow::Input input, ::tensorflow::Input begin, ::tensorflow::Input end, ::tensorflow::Input strides, const StridedSlice::Attrs & attrs) |
Public attributes | |
---|---|
output |
Public functions | |
---|---|
node() const | ::tensorflow::Node * |
operator::tensorflow::Input() const | |
operator::tensorflow::Output() const |
Public static functions | |
---|---|
BeginMask(int64 x) | |
EllipsisMask(int64 x) | |
EndMask(int64 x) | |
NewAxisMask(int64 x) | |
ShrinkAxisMask(int64 x) |
Structs | |
---|---|
tensorflow::ops::StridedSlice::Attrs | Optional attribute setters for StridedSlice. |
::tensorflow::Output output
StridedSlice( const ::tensorflow::Scope & scope, ::tensorflow::Input input, ::tensorflow::Input begin, ::tensorflow::Input end, ::tensorflow::Input strides )
StridedSlice( const ::tensorflow::Scope & scope, ::tensorflow::Input input, ::tensorflow::Input begin, ::tensorflow::Input end, ::tensorflow::Input strides, const StridedSlice::Attrs & attrs )
::tensorflow::Node * node() const
operator::tensorflow::Input() const
operator::tensorflow::Output() const
Attrs BeginMask( int64 x )
Attrs EllipsisMask( int64 x )
Attrs EndMask( int64 x )
Attrs NewAxisMask( int64 x )
Attrs ShrinkAxisMask( int64 x )
© 2017 The TensorFlow Authors. All rights reserved.
Licensed under the Creative Commons Attribution License 3.0.
Code samples licensed under the Apache 2.0 License.
https://www.tensorflow.org/api_docs/cc/class/tensorflow/ops/strided-slice.html