Come funziona numpy.transpose per questo esempio?

Question

Ho difficoltà a capire come funziona in realtà il comando numerpy.transpose. Per esempio

a_value = array([[[0, 1], 
        [2, 3]], 

       [[4, 5], 
        [6, 7]]]) 

e quando lo faccio

np.transpose(a_value, (2, 1, 0)) 

ottengo

array([[[0, 4], 
     [2, 6]], 

     [[1, 5], 
     [3, 7]]]) 

Come posso ricavare questa trasposizione manualmente? Ho bisogno di capire la formula o i passaggi intuitivamente nel caso di cui sopra in modo da poter generalizzare per le dimensioni superiori.

Answer 1

come indicato nella documentation -

numpy.transpose(a, axes=None)

assi: lista di numeri interi, opzionale Per default, invertire le dimensioni, tuttavia permutare gli assi in base ai valori indicati.

Il secondo argomento sono gli assi mediante i quali i valori sono permutati. Questo è ad esempio se l'indice dell'elemento iniziale è (x,y,z) (dove x è 0 ° assi, è 1 ° asse e z è 2 ° assi), la posizione di tale elemento nell'array risultante diventa (z, y, x) (che è il 2 ° asse prima, poi il 1 ° asse e l'ultimo 0 ° asse), in base all'argomento fornito per axes.

Dal momento che si recepiscono una matrice di forma (2,2,2), la forma trasposta è anche (2,2,2), e le posizioni cambierebbe come -

(0,0,0) -> (0,0,0) 
(1,0,0) -> (0,0,1) 
(0,1,0) -> (0,1,0) 
(1,1,0) -> (0,1,1) 
... 

---

Dal momento che gli assi che si sceglie sono banali, permette di spiegare questo per altri assi. Esempio -

In [54]: A = np.arange(30).reshape((2, 3, 5)) 
In [55]: A 
Out[55]: 
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]]]) 

In [56]: np.transpose(A,(1,2,0)) 
Out[56]: 
array([[[ 0, 15], 
     [ 1, 16], 
     [ 2, 17], 
     [ 3, 18], 
     [ 4, 19]], 

     [[ 5, 20], 
     [ 6, 21], 
     [ 7, 22], 
     [ 8, 23], 
     [ 9, 24]], 

     [[10, 25], 
     [11, 26], 
     [12, 27], 
     [13, 28], 
     [14, 29]]]) 

Qui, il primo elemento (0,0,0) diventa l'elemento (0,0,0) nel risultato.

Il secondo elemento (0,0,1) diventa l'elemento (0,1,0) nel risultato. E così via -

(0,0,0) -> (0,0,0) 
(0,0,1) -> (0,1,0) 
(0,0,2) -> (0,2,0) 
... 
(2,3,4) -> (3,4,2) 
...