Advertencia: esta API está obsoleta y se eliminará en una versión futura de TensorFlow una vez que el reemplazo sea ​​estable.

StridedSlice

StridedSlice public final class

Devuelve un corte escalonado de "input".

Tenga en cuenta que la mayoría de los usuarios de Python querrán usar Python `Tensor .__ getitem__` o` Variable .__ getitem__` en lugar de esta operación directamente.

El objetivo de esta operación es producir un nuevo tensor con un subconjunto de los elementos del tensor de `entrada` dimensional` n`. El subconjunto se elige utilizando una secuencia de especificaciones de rango disperso "m" codificadas en los argumentos de esta función. Tenga en cuenta que, en algunos casos, `m` podría ser igual a` n`, pero no es necesario que sea así. Cada entrada de especificación de rango puede ser una de las siguientes:

- Una elipsis (...). Las elipses se usan para implicar cero o más dimensiones de la selección de dimensión completa y se producen usando `ellipsis_mask`. Por ejemplo, "foo [...]" es el segmento de identidad.

- Un nuevo eje. Esto se usa para insertar una nueva forma = 1 dimensión y se produce usando `new_axis_mask`. Por ejemplo, `foo [:, ...]` donde `foo` es la forma` (3, 4) `produce un tensor` (1, 3, 4) `.

- Un rango `begin: end: stride`. Se utiliza para especificar cuánto elegir de una dimensión determinada. `stride` puede ser cualquier número entero excepto 0.` begin` es un número entero que representa el índice del primer valor a seleccionar mientras que `end` representa el índice del último valor a seleccionar. El número de valores seleccionados en cada dimensión es `end - begin` si` stride> 0` y `begin - end` si` stride <0`. `begin` y` end` pueden ser negativos donde `-1` es el último elemento,` -2` es el penúltimo. `begin_mask` controla si se debe reemplazar el` begin` dado explícitamente con un valor efectivo implícito de `0` si` stride> 0` y `-1` si` stride <0`. `end_mask` es análogo pero produce el número requerido para crear el intervalo abierto más grande. Por ejemplo, dada una forma `(3,)` tensor `foo [:]`, los efectivos `begin` y` end` son `0` y` 3`. No asuma que esto es equivalente a "foo [0: -1]" que tiene un "comienzo" y un "fin" efectivos de "0" y "2". Otro ejemplo es `foo [-2 :: - 1]` que invierte la primera dimensión de un tensor mientras descarta las dos últimas (en los elementos del orden original). Por ejemplo, `foo = [1,2,3,4]; foo [-2 :: - 1] `es` [4,3] `.

- Un solo índice. Esto se usa para mantener solo los elementos que tienen un índice determinado. Por ejemplo, (`foo [2,:]` en una forma `(5,6)` tensor produce un tensor de forma `(6,)`. Este tensor está codificado en `begin` y` end` y `shrink_axis_mask`.

Cada especificación de rango conceptual está codificada en el argumento de la operación. Esta codificación se comprende mejor si se considera un ejemplo no trivial. En particular, `foo [1, 2: 4, Ninguno, ...,: -3: -1,:]` será codificado como

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 = 1
 
En este caso si `foo.shape` es (5, 5, 5, 5, 5, 5) la forma final de la rebanada se convierte en (2, 1, 5, 5, 2, 5). Caminemos paso a paso a través de la especificación de cada argumento.

1. El primer argumento en el segmento de ejemplo se convierte en `begin = 1` y` end = begin + 1 = 2`. Para eliminar la ambigüedad de la especificación original `2: 4` también establecemos el bit apropiado en` shrink_axis_mask`.

2. "2: 4" contribuye con 2, 4, 1 para comenzar, terminar y avanzar. Todas las máscaras tienen aportación de cero bits.

3. Ninguno es sinónimo de `tf.newaxis`. Esto significa insertar una dimensión de tamaño 1 en la forma final. Los valores ficticios se contribuyen al inicio, finalización y zancada, mientras que el bit new_axis_mask está establecido.

4. "..." tome los rangos completos de tantas dimensiones como sea necesario para especificar completamente un corte para cada dimensión de la forma de entrada.

5. `: -3: -1` muestra el uso de índices negativos. Un índice negativo "i" asociado con una dimensión que tiene forma "s" se convierte en un índice positivo "s + i". Entonces, `-1` se convierte en` s-1` (es decir, el último elemento). Esta conversión se realiza internamente, por lo que begin, end y strides reciben x, -3 y -1. El bit begin_mask apropiado se establece para indicar que el rango de inicio es el rango completo (ignorando la x).

6. `:` indica que se ha seleccionado todo el contenido de la dimensión correspondiente. Esto es equivalente a `::` o `0 :: 1`. begin, end y strides reciben 0, 0 y 1, respectivamente. También se establecen los bits apropiados en `begin_mask` y` end_mask`.

Requisitos:! `0 = zancadas [i] para i en [0, m)` `ellipsis_mask debe ser una potencia de dos (solamente una elipsis)`

Clases anidadas

clase StridedSlice.Options Los atributos opcionales para StridedSlice

Métodos públicos

Salida <T>
asOutput ()
Devuelve el identificador simbólico de un tensor.
estáticas StridedSlice.Options
beginMask (Long beginMask)
estática <T, U se extiende Número> StridedSlice <T>
crear ( Alcance alcance, operando <T> de entrada, operando <U> empezar, operando <U> extremo, operando <U> zancadas, Opciones ... Opciones)
Método de fábrica para crear una clase que envuelva una nueva operación StridedSlice.
estáticas StridedSlice.Options
ellipsisMask (Long ellipsisMask)
estáticas StridedSlice.Options
endMask (Long endMask)
estáticas StridedSlice.Options
newAxisMask (Long newAxisMask)
Salida <T>
salida ()
estáticas StridedSlice.Options
shrinkAxisMask (Long shrinkAxisMask)

Métodos heredados

Métodos públicos

pública de salida <T> asOutput ()

Devuelve el identificador simbólico de un tensor.

Las entradas a las operaciones de TensorFlow son salidas de otra operación de TensorFlow. Este método se utiliza para obtener un identificador simbólico que representa el cálculo de la entrada.

public static StridedSlice.Options beginMask (Long beginMask)

Parámetros
beginMask una máscara de bits donde un bit i es 1 significa ignorar el valor inicial y, en su lugar, usar el intervalo más grande posible. En tiempo de ejecución, begin [i] será reemplazado por `[0, n-1)` if `stride [i]> 0` o` [-1, n-1] `if` stride [i] <0`

public static StridedSlice <T> crear ( Alcance alcance, operando <T> de entrada, operando <U> empezar, operando <U> extremo, operando <U> zancadas, Opciones ... Opciones)

Método de fábrica para crear una clase que envuelva una nueva operación StridedSlice.

Parámetros
alcance alcance actual
empezar `begin [k]` especifica el desplazamiento en la especificación del rango `k`th. La dimensión exacta a la que esto corresponde estará determinada por el contexto. Los valores fuera de límites se bloquearán silenciosamente. Si el bit `k`th de` begin_mask`, entonces se ignora `begin [k]` y en su lugar se usa el rango completo de la dimensión apropiada. Los valores negativos hacen que la indexación comience desde el elemento más alto, por ejemplo, si `foo == [1,2,3]` entonces `foo [-1] == 3`.
fin `end [i]` es como `begin` con la excepción de que` end_mask` se usa para determinar rangos completos.
zancadas `strides [i]` especifica el incremento en la especificación `i`th después de extraer un elemento dado. Los índices negativos invertirán el orden original. Los valores de rango o de salida están sujetos a `[0, dim [i]) si segmento [i]> 0` o` [-1, dim [i] -1] si segmento [i] <0`
opciones lleva valores de atributos opcionales
Devoluciones
  • una nueva instancia de StridedSlice

public static StridedSlice.Options ellipsisMask (Long ellipsisMask)

Parámetros
elipsisMáscara una máscara de bits donde el bit `i` es 1 significa que la posición` i`th es en realidad una elipsis. Un bit como máximo puede ser 1. Si `ellipsis_mask == 0`, entonces se proporciona una máscara de elipsis implícita de` 1 << (m + 1) `. Esto significa que `foo [3: 5] == foo [3: 5, ...]`. Una elipsis crea implícitamente tantas especificaciones de rango como sea necesario para especificar completamente el rango dividido para cada dimensión. Por ejemplo, para un tensor de 4 dimensiones `foo`, el segmento` foo [2, ..., 5: 8] `implica` foo [2,:,:, 5: 8] `.

public static StridedSlice.Options endMask (Long endMask)

Parámetros
endMask análogo a `begin_mask`

public static StridedSlice.Options newAxisMask (Long newAxisMask)

Parámetros
newAxisMask una máscara de bits donde el bit `i` es 1 significa que la especificación` i`th crea una nueva dimensión de forma 1. Por ejemplo, `foo [: 4, tf.newaxis,: 2]` produciría un tensor de forma `(4, 1, 2)`.

pública de salida <T> salida ()

public static StridedSlice.Options shrinkAxisMask (Long shrinkAxisMask)

Parámetros
shrinkAxisMask una máscara de bits donde el bit `i` implica que la especificación` i`th debería reducir la dimensionalidad. begin y end deben implicar una porción de tamaño 1 en la dimensión. Por ejemplo, en Python uno podría hacer `foo [:, 3,:]` lo que resultaría en que `shrink_axis_mask` sea 2.