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

StridedSlice

clase final pública StridedSlice

Devuelve un segmento con zancadas desde `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 `n` dimensional `input`. 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 este no tiene por qué ser el caso. Cada entrada de especificación de rango puede ser una de las siguientes:

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

- Un nuevo eje. Esto se usa para insertar una nueva dimensión de forma = 1 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`. Esto se utiliza para especificar cuánto elegir de una dimensión dada. `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 "final - inicio" si "paso > 0" y "comienzo - fin" si "paso < 0". `begin` y `end` pueden ser negativos donde `-1` es el último elemento, `-2` es el penúltimo. `begin_mask` controla si se reemplaza 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 mayor intervalo abierto. Por ejemplo, dado un tensor de forma `(3,)` `foo[:]`, el `begin` y el `end` efectivos son `0` y `3`. No asumas que esto es equivalente a `foo[0:-1]` que tiene un `begin` y `end` efectivos de `0` y `2`. Otro ejemplo es `foo[-2::-1]` que invierte la primera dimensión de un tensor mientras elimina los dos últimos (en el orden original de los elementos). 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 dado. Por ejemplo (`foo[2, :]` en un tensor de forma `(5,6)` produce un tensor de forma `(6,)`. Esto 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 considerando un ejemplo no trivial. En particular, `foo[1, 2:4, None, ..., :-3:-1, :]` se codificará 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 del corte se convierte en (2, 1, 5, 5, 2, 5). Veamos paso a paso 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 configuramos el bit apropiado en `shrink_axis_mask`.

2. `2:4` contribuye 2, 4, 1 para comenzar, terminar y avanzar. Todas las máscaras tienen cero bits contribuidos.

3. Ninguno es sinónimo de tf.newaxis . Esto significa insertar una dimensión de tamaño 1 dimensión en la forma final. Se aportan valores ficticios para comenzar, finalizar y avanzar, mientras se establece el bit new_axis_mask.

4. `...` tome los rangos completos de tantas dimensiones como sea necesario para especificar completamente un segmento 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 la 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 el comienzo, el final y los pasos 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 selecciona 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)` `elipsis_mask debe ser una potencia de dos (solo una elipsis)`

Clases anidadas

clase StridedSlice.Opciones Atributos opcionales para StridedSlice

Métodos públicos

Salida <T>
como salida ()
Devuelve el identificador simbólico de un tensor.
StridedSlice.Options estático
beginMask (máscara de inicio larga)
estático <T, U extiende Número> StridedSlice <T>
crear ( Alcance alcance, Operando <T> entrada, Operando <U> inicio, Operando <U> final, Operando <U> zancadas, Opciones... opciones)
Método de fábrica para crear una clase que envuelve una nueva operación StridedSlice.
StridedSlice.Options estático
máscara de puntos suspensivos (máscara de puntos suspensivos largos)
StridedSlice.Options estático
endMask (Máscara final larga)
StridedSlice.Options estático
newAxisMask (nueva máscara de eje larga)
Salida <T>
salida ()
StridedSlice.Options estático
encogerAxisMask (EncogerAxisMask largo)

Métodos Heredados

Métodos públicos

salida pública <T> como salida ()

Devuelve el identificador simbólico de un tensor.

Las entradas de 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.

StridedSlice público estático. Opciones beginMask (Long beginMask)

Parámetros
comenzarMáscara una máscara de bits donde un bit i es 1 significa ignorar el valor inicial y en su lugar usar el mayor intervalo posible. En tiempo de ejecución, begin[i] se reemplazará con `[0, n-1)` si `stride[i] > 0` o `[-1, n-1]` si `stride[i] < 0`

StridedSlice público estático <T> crear ( Ámbito de ámbito, Operando <T> entrada, Operando <U> inicio, Operando <U> final, Operando <U> zancadas, Opciones... opciones)

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

Parámetros
alcance alcance actual
comenzar `begin[k]` especifica el desplazamiento en la especificación de rango `k`th. La dimensión exacta a la que esto corresponde será determinada por el contexto. Los valores fuera de los límites se bloquearán silenciosamente. Si se ignora el `k`ésimo bit de `begin_mask` entonces se ignora `begin[k]` y se usa el rango completo de la dimensión apropiada en su lugar. 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 `i`ésima especificación después de extraer un elemento dado. Los índices negativos invertirán el orden original. Los valores fuera o de rango se fijan a `[0,dim[i]) si slice[i]>0` o `[-1,dim[i]-1] si slice[i] < 0`
opciones lleva valores de atributos opcionales
Devoluciones
  • una nueva instancia de StridedSlice

public static StridedSlice.Options ellipsisMask ( Máscara de puntos suspensivos largos)

Parámetros
puntos suspensivosMáscara una máscara de bits donde el bit `i` es 1 significa que la posición `i` es en realidad una elipsis. Un bit como máximo puede ser 1. Si `elipsis_mask == 0`, entonces se proporciona una máscara de puntos suspensivos 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`, la porción `foo[2, ..., 5:8]` implica `foo[2, :, :, 5:8]`.

StridedSlice.Options public static endMask (Long endMask)

Parámetros
endMask análogo a `begin_mask`

public static StridedSlice.Options newAxisMask (Larga newAxisMask)

Parámetros
nuevoAxisMask 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)`.

salida pública <T> salida ()

StridedSlice.Options público estático ShrinkAxisMask ( Long ShrinkAxisMask)

Parámetros
encogerAxisMask 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 un segmento de tamaño 1 en la dimensión. Por ejemplo, en python se podría hacer `foo[:, 3, :]`, lo que daría como resultado que `shrink_axis_mask` fuera 2.