Devuelve un segmento recorrido desde la "entrada".
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 elementos del tensor de "entrada" de "n" dimensiones. El subconjunto se elige utilizando una secuencia de `m` especificaciones de rango disperso codificadas en los argumentos de esta función. Tenga en cuenta que, en algunos casos, "m" podría ser igual a "n", pero no tiene por qué ser así. Cada entrada de especificación de rango puede ser una de las siguientes:
- Una elipsis (...). Las elipses se utilizan para implicar cero o más dimensiones de selección de dimensiones completas y se producen utilizando "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 `comienzo:fin:zancada`. Esto 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 "fin - comienzo" si "zancada > 0" y "comienzo - fin" si "zancada < 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 necesario para crear el intervalo abierto más grande. Por ejemplo, dada una forma `(3,)` tensor `foo[:]`, el `comienzo` y el `fin` efectivos 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 elimina las dos últimas (en el orden original de los elementos). Por ejemplo `foo = [1,2,3,4]; foo[-2::-1]` es `[4,3]`.
- Un índice único. Esto se utiliza para mantener sólo los elementos que tienen un índice determinado. 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, Ninguno, ..., :-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
1. El primer argumento en el segmento de ejemplo se convierte en "comienzo = 1" y "fin = comienzo + 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 al comienzo, al final y al paso. Todas las máscaras tienen cero bits aportados.
3. Ninguno es sinónimo de tf.newaxis . Esto significa insertar una dimensión de tamaño 1 en la forma final. Se aportan valores ficticios para comenzar, finalizar y avanzar, mientras el bit new_axis_mask está establecido.
4. `...` toma los rangos completos de tantas dimensiones como sea necesario para especificar completamente un sector 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 el inicio, el final y los pasos reciben x, -3 y -1. El bit de máscara de inicio apropiado se establece para indicar que el rango inicial 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`. el inicio, el final y los pasos reciben 0, 0 y 1, respectivamente. También se configuran 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 (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. |
| Opciones estáticas de StridedSlice. | comenzarMask (máscara de inicio larga) |
| estático <T, U extiende Número> StridedSlice <T> | crear (alcance alcance , entrada del operando <T>, comienzo del operando <U>, final del operando <U>, avances del operando <U>, opciones... opciones) Método de fábrica para crear una clase que envuelve una nueva operación StridedSlice. |
| Opciones estáticas de StridedSlice. | Máscara de puntos suspensivos (Máscara de puntos suspensivos larga) |
| Opciones estáticas de StridedSlice. | endMask (máscara final larga) |
| Opciones estáticas de StridedSlice. | newAxisMask (nueva máscara de eje larga) |
| Salida <T> | producción () |
| Opciones estáticas de StridedSlice. | encogimientoAxisMask (encogimiento largo de AxisMask) |
Métodos heredados
Métodos públicos
Salida pública <T> como Salida ()
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.
StridedSlice.Options estático público comenzarMask (Máscara de inicio larga)
Parámetros
| comenzarMáscara | una máscara de bits donde un bit i siendo 1 significa ignorar el valor inicial y en su lugar utilizar el intervalo más grande posible. En tiempo de ejecución, comenzar[i] será reemplazado por `[0, n-1)` si `stride[i] > 0` o `[-1, n-1]` si `stride[i] < 0` |
|---|
creación pública estática de StridedSlice <T> (alcance del alcance , entrada del operando <T>, inicio del operando <U>, final del operando <U>, avances del operando <U>, 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`. La dimensión exacta a la que esto corresponde estará determinada por el contexto. Los valores fuera de los límites se limitarán silenciosamente. Si el `k`ésimo bit de `begin_mask` entonces se ignora `begin[k]` y en su lugar se utiliza 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 `i`ésima especificación después de extraer un elemento determinado. Los índices negativos invertirán el orden original. Los valores de salida o rango se limitan a `[0,dim[i]) si el segmento[i]>0` o `[-1,dim[i]-1] si el segmento[i] < 0` |
| opciones | lleva valores de atributos opcionales |
Devoluciones
- una nueva instancia de StridedSlice
StridedSlice.Options estática pública máscara de puntos suspensivos (máscara de puntos suspensivos larga)
Parámetros
| elipsisMá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 `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 sean necesarias para especificar completamente el rango cortado para cada dimensión. Por ejemplo, para un tensor de 4 dimensiones `foo`, el segmento `foo[2, ..., 5:8]` implica `foo[2, :, :, 5:8]`. |
|---|
StridedSlice.Options estático público endMask (Máscara final larga)
Parámetros
| máscara final | análogo a `begin_mask` |
|---|
StridedSlice.Options estático público newAxisMask (newAxisMask largo)
Parámetros
| nuevoEjeMáscara | una máscara de bits donde el bit "i" es 1 significa que la especificación "i" crea una nueva forma de 1 dimensión. Por ejemplo, `foo[:4, tf.newaxis, :2]` produciría un tensor de forma `(4, 1, 2)`. |
|---|
público estático StridedSlice.Options encogimientoAxisMask (encogimiento largo de AxisMask)
Parámetros
| encogerAxisMask | una máscara de bits donde el bit "i" implica que la especificación "i" debería reducir la dimensionalidad. El inicio y el final deben implicar una porción 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. |
|---|