Sovrapposizione iterazione sul tensore teano

Question

Sto provando a implementare un ciclo di scansione in theano, che dato un tensore userà una "porzione mobile" dell'input. Non deve essere effettivamente una fetta mobile, può essere un tensore preelaborato a un altro tensore che rappresenta la porzione mobile.

Essenzialmente:

[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16] 
|-------|         (first iteration) 
    |-------|        (second iteration) 
    |-------|        (third iteration) 
       ... 
        ... 
         ... 
           |-------| (last iteration) 

dove |-------| è l'ingresso per ogni iterazione.

Sto cercando di capire il modo più efficiente per farlo, magari usando una qualche forma di referenziazione o manipolazione delle falcate, ma non sono riuscito a far funzionare qualcosa anche per puro numpy.

Una possibile soluzione trovata è here, ma non riesco a capire come utilizzare le falcate e non vedo un modo per usarlo con theano.

Answer 1

È possibile creare un vettore contenente l'indice iniziale per la sezione a ogni timestep e chiamare Scan con quel vettore come sequenza e il vettore originale come non sequenza. Quindi, all'interno di Scansione, è possibile ottenere la fetta desiderata ad ogni iterazione.

ho incluso un esempio in cui ho fatto anche la dimensione delle fette un ingresso simbolico, nel caso in cui si desidera cambiare da una chiamata della funzione Theano a quella successiva:

import theano 
import theano.tensor as T 

# Input variables 
x = T.vector("x") 
slice_size = T.iscalar("slice_size") 


def step(idx, vect, length): 

    # From the idx of the start of the slice, the vector and the length of 
    # the slice, obtain the desired slice. 
    my_slice = vect[idx:idx + length] 

    # Do something with the slice here. I don't know what you want to do 
    # to I'll just return the slice itself. 
    output = my_slice 

    return output 

# Make a vector containing the start idx of every slice 
slice_start_indices = T.arange(x.shape[0] - slice_size + 1) 

out, updates = theano.scan(fn=step, 
         sequences=[slice_start_indices], 
         non_sequences=[x, slice_size]) 

fct = theano.function([x, slice_size], out) 

esecuzione della funzione con i parametri produce l'uscita:

print fct(range(17), 5) 

[[ 0. 1. 2. 3. 4.] 
[ 1. 2. 3. 4. 5.] 
[ 2. 3. 4. 5. 6.] 
[ 3. 4. 5. 6. 7.] 
[ 4. 5. 6. 7. 8.] 
[ 5. 6. 7. 8. 9.] 
[ 6. 7. 8. 9. 10.] 
[ 7. 8. 9. 10. 11.] 
[ 8. 9. 10. 11. 12.] 
[ 9. 10. 11. 12. 13.] 
[ 10. 11. 12. 13. 14.] 
[ 11. 12. 13. 14. 15.] 
[ 12. 13. 14. 15. 16.]] 

Answer 2

Si potrebbe utilizzare this rolling_window recipe:

import numpy as np 

def rolling_window_lastaxis(arr, winshape): 
    """ 
    Directly taken from Erik Rigtorp's post to numpy-discussion. 
    http://www.mail-archive.com/numpy-discussion@scipy.org/msg29450.html 
    (Erik Rigtorp, 2010-12-31) 

    See also: 
    http://mentat.za.net/numpy/numpy_advanced_slides/ (Stéfan van der Walt, 2008-08) 
    https://stackoverflow.com/a/21059308/190597 (Warren Weckesser, 2011-01-11) 
    https://stackoverflow.com/a/4924433/190597 (Joe Kington, 2011-02-07) 
    https://stackoverflow.com/a/4947453/190597 (Joe Kington, 2011-02-09) 
    """ 
    if winshape < 1: 
     raise ValueError("winshape must be at least 1.") 
    if winshape > arr.shape[-1]: 
     print(winshape, arr.shape) 
     raise ValueError("winshape is too long.") 
    shape = arr.shape[:-1] + (arr.shape[-1] - winshape + 1, winshape) 
    strides = arr.strides + (arr.strides[-1],) 
    return np.lib.stride_tricks.as_strided(arr, shape=shape, strides=strides) 

x = np.arange(17) 
print(rolling_window_lastaxis(x, 5)) 

che stampa

[[ 0 1 2 3 4] 
[ 1 2 3 4 5] 
[ 2 3 4 5 6] 
[ 3 4 5 6 7] 
[ 4 5 6 7 8] 
[ 5 6 7 8 9] 
[ 6 7 8 9 10] 
[ 7 8 9 10 11] 
[ 8 9 10 11 12] 
[ 9 10 11 12 13] 
[10 11 12 13 14] 
[11 12 13 14 15] 
[12 13 14 15 16]] 

noti che ci sono estensioni ancora più elaborate di questo, come ad esempio Joe Kington's rolling_window che può rotolare sopra le finestre multi-dimensionali, e Sebastian Berg's implementation che , inoltre, può saltare a passi.