StridedSlice

classe finale pubblica StridedSlice

Restituisce una sezione striata da "input".

Nota, la maggior parte degli utenti Python vorrà utilizzare Python `Tensor.__getitem__` o `Variable.__getitem__` anziché direttamente questa operazione.

L'obiettivo di questa operazione è produrre un nuovo tensore con un sottoinsieme di elementi dal tensore "input" `n` 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ì. Ciascuna voce di specifica dell'intervallo può essere una delle seguenti:

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

- Un nuovo asse. Viene utilizzato per inserire una nuova dimensione shape=1 e viene prodotto utilizzando "new_axis_mask". Ad esempio, `foo[:, ...]` dove `foo` è la forma `(3, 4)` produce un tensore `(1, 3, 4)`.

- Un intervallo `begin:end:stride`. Viene utilizzato per specificare quanto scegliere da una determinata 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 ciascuna dimensione è "fine - inizio" se "stride > 0" e "inizio - fine" se "stride < 0". "begin" e "end" possono essere negativi dove "-1" è l'ultimo elemento e "-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, dato un tensore di forma "(3,)" "foo[:]", gli effettivi "begin" e "end" sono "0" e "3". Non dare per scontato che ciò equivalga a "foo[0:-1]" che ha effettivi "begin" e "end" pari a "0" e "2". Un altro esempio è `foo[-2::-1]` che inverte la prima dimensione di un tensore lasciando cadere le ultime due (nell'ordine originale degli elementi). 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 un tensore di forma "(5,6)" produce un tensore di forma "(6,)". Questo è codificato in "begin" e "end" e "shrink_axis_mask".

Ogni specifica dell'intervallo concettuale è codificata nell'argomento dell'operazione. Questa codifica può essere meglio compresa considerando un esempio non banale. In particolare, `foo[1, 2:4, None, ..., :-3:-1, :]` verrà 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 ciascun argomento.

1. Il primo argomento nella sezione di esempio viene trasformato in `begin = 1` e `end = Begin + 1 = 2`. Per evitare ambiguità rispetto alla specifica originale `2:4`, impostiamo anche il bit appropriato in `shrink_axis_mask`.

2. "2:4" contribuisce con 2, 4, 1 all'inizio, alla fine e al passo. Tutte le maschere hanno un contributo pari a zero bit.

3. Nessuno è un sinonimo di "tf.newaxis". Ciò significa inserire una dimensione di dimensione 1 nella forma finale. Vengono aggiunti valori fittizi a inizio, fine e passo, mentre viene impostato il bit new_axis_mask.

4. `...` cattura 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 che ha 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 passi ricevono x, -3 e -1. Il bit Begin_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. Ciò equivale a `::` o `0::1`. inizio, fine e passi 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 deve essere una potenza di due (solo un punto di sospensione)`

Classi nidificate

classe StridedSlice.Opzioni Attributi facoltativi per StridedSlice

Metodi pubblici

Uscita <T>
comeuscita ()
Restituisce la maniglia simbolica di un tensore.
StridedSlice.Options statico
BeginMask (Maschera iniziale lunga)
statico <T, U estende Numero> StridedSlice <T>
create ( ambito ambito , operando <T> input, operando <U> inizio, operando <U> fine, operando <U> passi, Opzioni... opzioni)
Metodo factory per creare una classe che racchiude una nuova operazione StridedSlice.
StridedSlice.Options statico
ellipsisMask (ellipsisMask lungo)
StridedSlice.Options statico
endMask (Maschera finale lunga)
StridedSlice.Options statico
newAxisMask (NewAxisMask lungo)
Uscita <T>
StridedSlice.Options statico
ShrinkAxisMask (ShrinkAxisMask lungo)

Metodi ereditati

Metodi pubblici

Uscita pubblica <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 (BeginMask lungo)

Parametri
BeginMask una maschera di bit in cui un bit i essendo 1 significa ignorare il valore iniziale e utilizzare invece l'intervallo più grande possibile. In fase di esecuzione, Begin[i] verrà sostituito con `[0, n-1)` se `stride[i] > 0` o `[-1, n-1]` se `stride[i] < 0`

public static StridedSlice <T> create ( scope scope, operando <T> input, operando <U> inizio, operando <U> fine, operando <U> strides, Opzioni... opzioni)

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

Parametri
scopo ambito attuale
inizio "begin[k]" specifica l'offset nella specifica dell'intervallo "k"esimo. La dimensione esatta a cui corrisponde sarà determinata dal contesto. I valori fuori limite verranno bloccati silenziosamente. Se il `k`esimo bit di `begin_mask` allora `begin[k]` viene ignorato e viene invece utilizzato l'intero intervallo della dimensione appropriata. I valori negativi fanno sì che l'indicizzazione inizi dall'elemento più alto, ad esempio se `foo==[1,2,3]` allora `foo[-1]==3`.
FINE `end[i]` è come `begin` con l'eccezione che `end_mask` viene utilizzato per determinare intervalli completi.
passi da gigante "strides[i]" specifica l'incremento nella "i" specifica dopo aver estratto un dato elemento. Gli indici negativi invertiranno l'ordine originale. I valori fuori o intervallo sono limitati 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 (ellipsisMask lungo)

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

pubblico statico StridedSlice.Options endMask (endMask lungo)

Parametri
endMask analogo a "begin_mask".

public static StridedSlice.Options newAxisMask (newAxisMask lungo)

Parametri
nuova maschera dell'asse una maschera di bit in cui 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)".

Uscita pubblica <T> uscita ()

public static StridedSlice.Options ShrinkAxisMask (Long ShrinkAxisMask)

Parametri
restringimentoAxisMask una maschera di bit in cui il bit "i" implica che la specifica "i" 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` pari a 2.