Creación de una vista 4D en matriz 2D para dividirlo en células de tamaño fijo

Question

I tienen una matriz 2D t en numpy:

>>> t = numpy.array(range(81)).reshape((9,9)) 
>>> t 
array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8], 
     [ 9, 10, 11, 12, 13, 14, 15, 16, 17], 
     [18, 19, 20, 21, 22, 23, 24, 25, 26], 
     [27, 28, 29, 30, 31, 32, 33, 34, 35], 
     [36, 37, 38, 39, 40, 41, 42, 43, 44], 
     [45, 46, 47, 48, 49, 50, 51, 52, 53], 
     [54, 55, 56, 57, 58, 59, 60, 61, 62], 
     [63, 64, 65, 66, 67, 68, 69, 70, 71], 
     [72, 73, 74, 75, 76, 77, 78, 79, 80]]) 

Está indexada por dos números: fila y el índice de columna.

>>> t[2,3] 
21 
>>> t.shape 
(9, 9) 
>>> t.strides 
(72, 8) 

Lo que quiero hacer es divide la matriz en células rectangulares de tamaño fijo, 3 × 3, por ejemplo. Me gustaría evitar la copia de memoria. La forma en que trato de lograr esto es crear una vista en t con la forma correspondiente y los pasos ((3,3,3,3) y (216,24,72,8) respectivamente). De esta forma, los dos primeros índices de la vista significarían la posición de 3 × 3 células en la grilla más grande y las dos últimas significarían la posición del elemento dentro de la celda. Por ejemplo, t[0,1,:,:] volvería

array([[ 3, 4, 5], 
     [12, 13, 14], 
     [21, 22, 23]]) 

Así que mi pregunta es - cómo crear la vista descrito? ¿Me estoy perdiendo un método más simple? ¿Se puede hacer esto de forma elegante con la sintaxis de corte?

Answer 1

Editar: Una forma que no requiere que usted para averiguar los pasos a sí mismo es

numpy.rollaxis(t.reshape(3, 3, 3, 3), 2, 1) 

[fin de editar]

Otra forma de lograr esto es utilizar numpy.lib.stride_tricks.as_strided:

>>> t = numpy.arange(81.).reshape((9,9)) 
>>> numpy.lib.stride_tricks.as_strided(t, shape=(3,3,3,3), strides=(216,24,72,8)) 
array([[[[ 0., 1., 2.], 
     [ 9., 10., 11.], 
     [ 18., 19., 20.]], 

     [[ 3., 4., 5.], 
     [ 12., 13., 14.], 
     [ 21., 22., 23.]], 

     [[ 6., 7., 8.], 
     [ 15., 16., 17.], 
     [ 24., 25., 26.]]], 


     [[[ 27., 28., 29.], 
     [ 36., 37., 38.], 
     [ 45., 46., 47.]], 

     [[ 30., 31., 32.], 
     [ 39., 40., 41.], 
     [ 48., 49., 50.]], 

     [[ 33., 34., 35.], 
     [ 42., 43., 44.], 
     [ 51., 52., 53.]]], 


     [[[ 54., 55., 56.], 
     [ 63., 64., 65.], 
     [ 72., 73., 74.]], 

     [[ 57., 58., 59.], 
     [ 66., 67., 68.], 
     [ 75., 76., 77.]], 

     [[ 60., 61., 62.], 
     [ 69., 70., 71.], 
     [ 78., 79., 80.]]]]) 

Tenga en cuenta que las zancadas que proporcionó son correctas solo para matrices flotantes (itemsize == 8), whi le el ejemplo t en su publicación es una matriz int (que podría o no tener itemsize == 8).

Answer 2

que puede hacer:

t = np.arange(81).reshape(9,9) 
t.shape = (3, 3, 3, 3) 
t = t.transpose((0, 2, 1, 3)) 

>>> print t.strides 
(108, 12, 36, 4) 

>>> print t 
[[[[ 0 1 2] 
    [ 9 10 11] 
    [18 19 20]] 

    [[ 3 4 5] 
    [12 13 14] 
    [21 22 23]] 

    [[ 6 7 8] 
    [15 16 17] 
    [24 25 26]]] 


[[[27 28 29] 
    [36 37 38] 
    [45 46 47]] 

    [[30 31 32] 
    [39 40 41] 
    [48 49 50]] 

    [[33 34 35] 
    [42 43 44] 
    [51 52 53]]] 


[[[54 55 56] 
    [63 64 65] 
    [72 73 74]] 

    [[57 58 59] 
    [66 67 68] 
    [75 76 77]] 

    [[60 61 62] 
    [69 70 71] 
    [78 79 80]]]] 

transposición volverá una vista siempre que sea posible, de esa manera usted no tiene que preocuparse de saber el tipo de datos.