Permettere una matrice sul posto in numpy

Voglio modificare una densa matrice di transizione quadrata sul posto cambiando l'ordine di molte delle sue righe e colonne, usando la libreria numpy di Python. Matematicamente questo corrisponde a pre-moltiplicare la matrice per la matrice di permutazione P e post-moltiplicarla per P ^ -1 = P ^ T, ma questa non è una soluzione computazionalmente ragionevole.

In questo momento sto scambiando manualmente righe e colonne, ma mi sarei aspettato che numpy avesse una bella funzione f (M, v) dove M ha n righe e colonne e v ha n voci, quindi f (M, v) si aggiorna M secondo la permutazione dell'indice v. Forse non riesco a cercare su Internet.

Qualcosa del genere potrebbe essere possibile con l '"indicizzazione avanzata" di numpy, ma la mia comprensione è che tale soluzione non sarebbe in atto. Anche per alcune semplici situazioni può essere sufficiente tenere traccia separatamente di una permutazione dell'indice, ma questo non è conveniente nel mio caso.

Aggiunto: a
volte quando le persone parlano di permutazioni, significano solo il campionamento di permutazioni casuali, ad esempio come parte di una procedura per ottenere valori p nelle statistiche. Oppure significano contare o enumerare tutte le possibili permutazioni. Non sto parlando di queste cose.

Aggiunto:
la matrice è abbastanza piccola da adattarsi alla RAM del desktop ma abbastanza grande da non volerlo copiare senza pensarci. In realtà vorrei usare matrici il più grandi possibile, ma non voglio affrontare l'inconveniente di non essere in grado di tenerle nella RAM, e faccio O (N ^ 3) operazioni LAPACK sulla matrice che anche limitare le dimensioni pratiche della matrice. Attualmente copio matrici così grandi inutilmente, ma spero che questo possa essere facilmente evitato per permutazione.

Secondo i documenti, non esiste un metodo di permutazione sul posto in numpy, qualcosa come ndarray.sort .

Quindi le tue opzioni sono (supponendo che Msia una matrice e il vettore di permutazione)$N\times N$p

1. implementare il proprio algoritmo in C come modulo di estensione (ma gli algoritmi sul posto sono difficili, almeno per me!)

2. memoria overhead$N$

   for i in range(N):
       M[:,i] = M[p,i]
   for i in range(N):
       M[i,:] = M[i,p]

3. sovraccarico di memoria$N^2$

   M[:,:] = M[p,:]
   M[:,:] = M[:,p]

Spero che questi hack non ottimali siano utili.

Avvertenza: l'esempio seguente funziona correttamente, ma l' utilizzo dell'intero set di parametri suggerito alla fine del post espone un bug o almeno una "caratteristica non documentata" nella funzione numpy.take (). Vedi i commenti qui sotto per i dettagli. Segnalazione di bug archiviata .

Puoi farlo sul posto con la funzione take () di numpy , ma richiede un po 'di salto del cerchio.

Ecco un esempio di fare una permutazione casuale delle righe di una matrice di identità:

import numpy as np
i = np.identity(10)
rr = range(10)
np.random.shuffle(rr)
np.take(i, rr, axis=0)
array([[ 0.,  1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.,  1.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.,  0.],
       [ 0.,  0.,  0.,  0.,  0.,  0.,  1.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  1.,  0.,  0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  1.,  0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.,  0.,  0.],
       [ 1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  1.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.]])

Per farlo sul posto, tutto ciò che devi fare è specificare il parametro "out" in modo che sia lo stesso dell'array di input E devi impostare mode = "clip" o mode = "wrap". Se non imposti la modalità, verrà creata una copia per ripristinare lo stato dell'array su un'eccezione Python (vedi qui) .

In ultima analisi, take sembra essere un metodo array, quindi invece di

np.take(i, rr, axis=0)

potresti chiamare

i.take(rr, axis=0)

se questo è più di tuo gusto. Quindi, in totale, la tua chiamata dovrebbe essere simile alla seguente:

#Inplace Rearrange
arr = makeMyBixMatrix()
pVec0, pVec1 = calcMyPermutationVectors()
arr.take(pVec0, axis=0, out=arr, mode="clip")
arr.take(pVec1, axis=1, out=arr, mode="clip")

Per permutare sia le righe che le colonne, penso che sia necessario eseguirlo due volte o tirare alcuni brutti shenanigans con numpy.unravel_index che mi fa male alla testa a cui pensare.

Se hai una matrice sparsa archiviata in COOformato, potrebbe essere utile quanto segue

    A.row = perm[A.row];
    A.col = perm[A.col];

ACOOpermnumpy.array$m$$m$

Non ho abbastanza reputazione per commentare, ma penso che la seguente domanda SO possa essere utile: /programming/4370745/view-onto-a-numpy-array

I punti di base sono che è possibile utilizzare lo slicing di base e che creerà una vista sull'array senza copiare, ma se si esegue lo slicing / indicizzazione avanzati , verrà creata una copia.

Che dire

my_array [:, [0, 1]] = my_array [:, [1, 0]]