Tensorflow Strides Argument

Sto cercando di capire l' argomento strides in tf.nn.avg_pool, tf.nn.max_pool, tf.nn.conv2d.

La documentazione dice ripetutamente

strides: un elenco di int che ha lunghezza> = 4. Il passo della finestra scorrevole per ogni dimensione del tensore di input.

Le mie domande sono:

1. Cosa rappresenta ciascuno dei 4+ numeri interi?
2. Perché devono avere strides [0] = strides [3] = 1 per le convnet?
3. In questo esempio vediamo tf.reshape(_X,shape=[-1, 28, 28, 1]). Perché -1?

Purtroppo gli esempi nei documenti per rimodellare utilizzando -1 non si traducono troppo bene in questo scenario.

Le operazioni di pooling e convoluzionale fanno scorrere una "finestra" sul tensore di input. Usando tf.nn.conv2dcome esempio: Se il tensore di input ha 4 dimensioni [batch, height, width, channels]:, allora la convoluzione opera su una finestra 2D sulle height, widthdimensioni.

stridesdetermina di quanto si sposta la finestra in ciascuna delle dimensioni. L'uso tipico imposta il primo passo (il lotto) e l'ultimo (la profondità) a 1.

Usiamo un esempio molto concreto: eseguire una convoluzione 2-d su un'immagine di input in scala di grigi 32x32. Dico scala di grigi perché l'immagine di input ha profondità = 1, il che aiuta a mantenerlo semplice. Lascia che l'immagine abbia questo aspetto:

00 01 02 03 04 ...
10 11 12 13 14 ...
20 21 22 23 24 ...
30 31 32 33 34 ...
...

Eseguiamo una finestra di convoluzione 2x2 su un singolo esempio (dimensione batch = 1). Daremo alla convoluzione una profondità del canale di uscita di 8.

L'input per la convoluzione ha shape=[1, 32, 32, 1].

Se si specifica strides=[1,1,1,1]con padding=SAME, l'output del filtro sarà [1, 32, 32, 8].

Il filtro creerà prima un output per:

F(00 01
  10 11)

E poi per:

F(01 02
  11 12)

e così via. Quindi passerà alla seconda riga, calcolando:

F(10, 11
  20, 21)

poi

F(11, 12
  21, 22)

Se specifichi un passo di [1, 2, 2, 1] non verranno sovrapposte le finestre. Calcolerà:

F(00, 01
  10, 11)

e poi

F(02, 03
  12, 13)

Il passo funziona in modo simile per gli operatori di pooling.

Domanda 2: Perché passi [1, x, y, 1] per le convnet

Il primo è il batch: di solito non vuoi saltare gli esempi nel tuo batch, o non avresti dovuto includerli in primo luogo. :)

L'ultimo 1 è la profondità della convoluzione: di solito non vuoi saltare gli input, per lo stesso motivo.

L'operatore conv2d è più generale, in modo da potrebbe creare circonvoluzioni che scorrono lungo la finestra di altre dimensioni, ma che non è un uso tipico in convnets. L'utilizzo tipico è quello di usarli spazialmente.

Perché reshape a -1 -1 è un segnaposto che dice "aggiusta come necessario per abbinare la dimensione necessaria per l'intero tensore". È un modo per rendere il codice indipendente dalla dimensione del batch di input, in modo da poter modificare la pipeline e non dover regolare la dimensione del batch ovunque nel codice.

Gli input sono quadridimensionali e sono di forma: [batch_size, image_rows, image_cols, number_of_colors]

I passi, in generale, definiscono una sovrapposizione tra le operazioni di applicazione. Nel caso di conv2d, specifica qual è la distanza tra applicazioni consecutive di filtri convoluzionali. Il valore 1 in una dimensione specifica significa che applichiamo l'operatore ad ogni riga / colonna, il valore 2 significa ogni secondo e così via.

Rif 1) I valori che contano per le convoluzioni sono 2 ° e 3 ° e rappresentano la sovrapposizione nell'applicazione dei filtri convoluzionali lungo righe e colonne. Il valore di [1, 2, 2, 1] dice che vogliamo applicare i filtri su ogni seconda riga e colonna.

Ri 2) Non conosco i limiti tecnici (potrebbe essere il requisito CuDNN) ma in genere le persone usano passi lungo le dimensioni delle righe o delle colonne. Non ha necessariamente senso farlo oltre le dimensioni del batch. Non sono sicuro dell'ultima dimensione.

Rif. 3) Impostare -1 per una delle dimensioni significa "impostare il valore per la prima dimensione in modo che il numero totale di elementi nel tensore sia invariato". Nel nostro caso, -1 sarà uguale a batch_size.

Cominciamo con quello che fa il passo nel caso 1-dim.

Supponiamo che il tuo input = [1, 0, 2, 3, 0, 1, 1]e kernel = [2, 1, 3]il risultato della convoluzione sia [8, 11, 7, 9, 4], che viene calcolato facendo scorrere il kernel sull'input, eseguendo la moltiplicazione in base agli elementi e sommando tutto. In questo modo :

• 8 = 1 * 2 + 0 * 1 + 2 * 3
• 11 = 0 * 2 + 2 * 1 + 3 * 3
• 7 = 2 * 2 + 3 * 1 + 0 * 3
• 9 = 3 * 2 + 0 * 1 + 1 * 3
• 4 = 0 * 2 + 1 * 1 + 1 * 3

Qui scorriamo di un elemento, ma niente ti ferma usando un altro numero. Questo numero è il tuo passo. Puoi pensarlo come un downsampling del risultato della convoluzione a 1 passo prendendo solo ogni s-esimo risultato.

Conoscendo la dimensione di input i , la dimensione del kernel k , lo stride se il padding p puoi facilmente calcolare la dimensione di output della convoluzione come:

Qui || operatore significa funzionamento a soffitto. Per uno strato di raggruppamento s = 1.

Case N-dim.

Conoscendo la matematica per un caso 1-dim, il caso n-dim è facile una volta che vedi che ogni dim è indipendente. Quindi fai scorrere ciascuna dimensione separatamente. Ecco un esempio per 2-d . Notare che non è necessario avere la stessa andatura per tutte le dimensioni. Quindi per un input / kernel N-dim dovresti fornire N passi.

Quindi ora è facile rispondere a tutte le tue domande:

1. Cosa rappresenta ciascuno dei 4+ numeri interi? . conv2d , pool ti dice che questo elenco rappresenta i passi avanti tra ogni dimensione. Si noti che la lunghezza dell'elenco dei passi è uguale al rango del tensore del kernel.
2. Perché devono avere passi [0] = passi 3 = 1 per le convnet? . La prima dimensione è la dimensione del batch, l'ultima è i canali. Non ha senso saltare né il batch né il canale. Quindi li fai 1. Per larghezza / altezza puoi saltare qualcosa ed è per questo che potrebbero non essere 1.
3. tf.reshape (_X, shape = [- 1, 28, 28, 1]). Perché -1? tf.reshape ha quello che fa per te:

   Se un componente della forma è il valore speciale -1, la dimensione di quella dimensione viene calcolata in modo che la dimensione totale rimanga costante. In particolare, una forma di [-1] si appiattisce in 1-D. Al massimo un componente della forma può essere -1.

@dga ha fatto un ottimo lavoro spiegando e non posso essere abbastanza grato di quanto sia stato utile. Allo stesso modo, vorrei condividere le mie scoperte su come stridefunziona nella convoluzione 3D.

Secondo la documentazione di TensorFlow su conv3d, la forma dell'input deve essere in questo ordine:

[batch, in_depth, in_height, in_width, in_channels]

Spieghiamo le variabili dall'estrema destra a sinistra usando un esempio. Supponendo che la forma di input sia input_shape = [1000,16,112,112,3]

input_shape[4] is the number of colour channels (RGB or whichever format it is extracted in)
input_shape[3] is the width of the image
input_shape[2] is the height of the image
input_shape[1] is the number of frames that have been lumped into 1 complete data
input_shape[0] is the number of lumped frames of images we have.

Di seguito è riportata una documentazione di riepilogo su come viene utilizzata la falcata.

strides: un elenco di int che ha lunghezza> = 5. Tensore 1-D di lunghezza 5. Il passo della finestra scorrevole per ogni dimensione di input. Deve averestrides[0] = strides[4] = 1

Come indicato in molti lavori, i passi significano semplicemente quanti passi una finestra o un kernel salta dall'elemento più vicino, sia esso un data frame o un pixel (questo è parafrasato a proposito).

Dalla documentazione di cui sopra, un passo in 3D sarà simile a questo passo = (1, X , Y , Z , 1).

La documentazione lo sottolinea strides[0] = strides[4] = 1.

strides[0]=1 means that we do not want to skip any data in the batch 
strides[4]=1 means that we do not want to skip in the channel 

passi [X] indica quanti salti dovremmo fare nei fotogrammi concentrati. Quindi, ad esempio, se abbiamo 16 frame, X = 1 significa utilizzare ogni frame. X = 2 significa usare ogni secondo fotogramma e va avanti

strides [y] e strides [z] seguono la spiegazione di @dga, quindi non rifarò quella parte.

In keras, tuttavia, è sufficiente specificare una tupla / lista di 3 numeri interi, specificando i passi della convoluzione lungo ciascuna dimensione spaziale, dove la dimensione spaziale è stride [x], strides [y] e strides [z]. strides [0] e strides [4] è già impostato su 1.

Spero che qualcuno lo trovi utile!