StridedSlice

classe finale pubblica StridedSlice

Restituisce una sezione a gradini da "input".

Nota, la maggior parte degli utenti di Python vorrà usare Python `Tensor .__ getitem__` o` Variable .__ getitem__` invece di questa operazione direttamente.

Lo scopo di questa operazione è produrre un nuovo tensore con un sottoinsieme di elementi dal tensore "n" input "dimensionale. Il sottoinsieme viene scelto utilizzando una sequenza di specifiche di intervallo sparse `m` codificate negli argomenti di questa funzione. Nota, in alcuni casi "m" potrebbe essere uguale a "n", ma non è necessario che sia così. Ogni voce di specifica dell'intervallo può essere una delle seguenti:

- Un'ellissi (...). Le ellissi sono usate per implicare zero o più dimensioni della selezione a dimensione intera e sono prodotte usando `ellipsis_mask`. Ad esempio, "foo [...]" è la fetta di identità.

- Un nuovo asse. Questo è usato per inserire una nuova forma = 1 dimensione ed è prodotto usando `new_axis_mask`. Ad esempio, `foo [:, ...]` dove `foo` è shape` (3, 4) `produce un tensore` (1, 3, 4) `.

- Un intervallo `inizio: fine: stride`. Viene utilizzato per specificare quanto scegliere da una data dimensione. `stride` può essere qualsiasi numero intero tranne 0.` begin` è un numero intero che rappresenta l'indice del primo valore da selezionare mentre `end` rappresenta l'indice dell'ultimo valore da selezionare. Il numero di valori selezionati in ogni dimensione è "fine - inizio" se "passo> 0" e "inizio - fine" se "passo <0". "inizio" e "fine" possono essere negativi dove "-1" è l'ultimo elemento, "-2" è il penultimo. `begin_mask` controlla se sostituire il` begin` fornito esplicitamente con un valore effettivo implicito di `0` se` stride> 0` e `-1` se` stride <0`. `end_mask` è analogo ma produce il numero richiesto per creare l'intervallo aperto più grande. Ad esempio, data una forma "(3,)" tensore "pippo [:]", "inizio" e "fine" effettivi sono "0" e "3". Non dare per scontato che sia equivalente a "foo [0: -1]" che ha un "inizio" e una "fine" effettivi di "0" e "2". Un altro esempio è `foo [-2 :: - 1]` che inverte la prima dimensione di un tensore rilasciando le ultime due (nell'ordine degli elementi originali). Ad esempio `foo = [1,2,3,4]; foo [-2 :: - 1] "è" [4,3] ".

- Un unico indice. Viene utilizzato per mantenere solo gli elementi che hanno un determinato indice. Ad esempio (`foo [2,:]` su una forma `(5,6)` tensore produce un tensore di forma `(6,)`. Questo è codificato in `begin` e` end` e `shrink_axis_mask`.

Ogni specifica di intervallo concettuale è codificata nell'argomento dell'operazione. Questa codifica può essere compresa meglio considerando un esempio non banale. In particolare, `foo [1, 2: 4, None, ...,: -3: -1,:]` sarà codificato come

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
 
In questo caso se `foo.shape` è (5, 5, 5, 5, 5, 5) la forma finale della fetta diventa (2, 1, 5, 5, 2, 5). Esaminiamo passo dopo passo la specifica di ogni argomento.

1. Il primo argomento nello slice di esempio viene trasformato in "begin = 1" e "end = begin + 1 = 2". Per disambiguare le specifiche originali `2: 4` impostiamo anche il bit appropriato in` shrink_axis_mask`.

2. "2: 4" contribuisce 2, 4, 1 all'inizio, alla fine e al passo. Tutte le maschere hanno zero bit forniti.

3. Nessuno è sinonimo di "tf.newaxis". Ciò significa inserire una dimensione di dimensione 1 nella forma finale. I valori fittizi vengono aggiunti all'inizio, alla fine e al passo, mentre viene impostato il bit new_axis_mask.

4. "..." afferra gli intervalli completi da tutte le dimensioni necessarie per specificare completamente una sezione per ogni dimensione della forma di input.

5. ": -3: -1" mostra l'uso di indici negativi. Un indice negativo "i" associato a una dimensione con forma "s" viene convertito in un indice positivo "s + i". Quindi "-1" diventa "s-1" (cioè l'ultimo elemento). Questa conversione viene eseguita internamente, quindi inizio, fine e falcate ricevono x, -3 e -1. Il bit di inizio_mask appropriato è impostato per indicare che l'intervallo iniziale è l'intervallo completo (ignorando la x).

6. `:` indica che è selezionato l'intero contenuto della dimensione corrispondente. Questo è equivalente a "::" o "0 :: 1". inizio, fine e falcate ricevono rispettivamente 0, 0 e 1. Vengono impostati anche i bit appropriati in `begin_mask` e` end_mask`.

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

Classi annidate

classe StridedSlice.Options Attributi opzionali per StridedSlice

Metodi pubblici

Uscita <T>
asOutput ()
Restituisce la maniglia simbolica di un tensore.
static StridedSlice.Options
beginMask (Long beginMask)
static <T, U estende Number> StridedSlice <T>
create ( Scope scope, Operando <T> input, Operand <U> begin, Operand <U> end, Operand <U> strides, Options ... options)
Metodo Factory per creare una classe che racchiude una nuova operazione StridedSlice.
static StridedSlice.Options
ellipsisMask (Long ellipsisMask)
static StridedSlice.Options
endMask (Long endMask)
static StridedSlice.Options
newAxisMask (lungo newAxisMask)
Uscita <T>
output ()
static StridedSlice.Options
shrinkAxisMask (Long shrinkAxisMask)

Metodi ereditati

Metodi pubblici

output pubblico <T> asOutput ()

Restituisce la maniglia simbolica di un tensore.

Gli input per le operazioni TensorFlow sono output di un'altra operazione TensorFlow. Questo metodo viene utilizzato per ottenere un handle simbolico che rappresenta il calcolo dell'input.

public static StridedSlice.Options beginMask (Long beginMask)

Parametri
beginMask una maschera di bit dove un bit i è 1 significa ignorare il valore iniziale e invece utilizzare l'intervallo più grande possibile. All'inizio del runtime [i] sarà sostituito con "[0, n-1)" se "stride [i]> 0" o "[-1, n-1]" se "stride [i] <0"

public static StridedSlice <T> create ( Scope scope, Operand <T> input, Operand <U> begin, Operand <U> end, Operand <U> strides, Options ... options)

Metodo Factory per creare una classe che racchiude una nuova operazione StridedSlice.

Parametri
scopo ambito attuale
inizio `begin [k]` specifica l'offset nella specifica di `k`th intervallo. La dimensione esatta a cui corrisponde sarà determinata dal contesto. I valori fuori limite verranno bloccati silenziosamente. Se il `k`th bit di` begin_mask`, `begin [k]` viene ignorato e viene invece utilizzato l'intero intervallo della dimensione appropriata. Valori negativi fanno sì che l'indicizzazione inizi dall'elemento più alto, ad esempio se `foo == [1,2,3]` then `foo [-1] == 3`.
fine `end [i]` è come `begin` con l'eccezione che` end_mask` è usato per determinare gli intervalli completi.
passi "strides [i]" specifica l'incremento nella specifica "i" dopo l'estrazione di un dato elemento. Gli indici negativi invertiranno l'ordine originale. I valori out o range sono fissati a "[0, dim [i]) se slice [i]> 0` o" [-1, dim [i] -1] se slice [i] <0`
opzioni trasporta valori di attributi opzionali
ritorna
  • una nuova istanza di StridedSlice

public static StridedSlice.Options ellipsisMask (Long ellipsisMask)

Parametri
ellipsisMask una maschera di bit dove il bit "i" è 1 significa che la posizione "i" è in realtà un'ellissi. Un bit al massimo può essere 1. Se "ellipsis_mask == 0", viene fornita una maschera di ellissi implicita di "1 << (m + 1)". Ciò significa che `foo [3: 5] == foo [3: 5, ...]`. I puntini di sospensione creano implicitamente tutte le specifiche dell'intervallo necessarie per specificare completamente l'intervallo suddiviso per ogni dimensione. Ad esempio per un tensore quadridimensionale `foo` la slice` foo [2, ..., 5: 8] `implica` foo [2,:,:, 5: 8] `.

public static StridedSlice.Options endMask (Long endMask)

Parametri
endMask analogo a "begin_mask"

public static StridedSlice.Options newAxisMask (Long newAxisMask)

Parametri
newAxisMask una maschera di bit dove il bit "i" è 1 significa che la specifica "i" crea una nuova dimensione di forma 1. Ad esempio "foo [: 4, tf.newaxis,: 2]" produrrebbe un tensore di forma "(4, 1, 2)".

output pubblico <T> output ()

public static StridedSlice.Options shrinkAxisMask (Long shrinkAxisMask)

Parametri
shrinkAxisMask una maschera di bit dove il bit "i" implica che la specifica "i" esima dovrebbe ridurre la dimensionalità. inizio e fine devono implicare una fetta di dimensione 1 nella dimensione. Ad esempio in python si potrebbe fare `foo [:, 3,:]` che risulterebbe in `shrink_axis_mask` 2.