Permuta una matriz en el lugar en numpy

Quiero modificar una matriz de transición cuadrada densa en el lugar cambiando el orden de varias de sus filas y columnas, usando la biblioteca numpy de python. Matemáticamente, esto corresponde a la multiplicación previa de la matriz por la matriz de permutación P y la multiplicación posterior por P ^ -1 = P ^ T, pero esta no es una solución computacionalmente razonable.

En este momento estoy intercambiando manualmente filas y columnas, pero hubiera esperado que numpy tuviera una buena función f (M, v) donde M tiene n filas y columnas, y v tiene n entradas, de modo que f (M, v) se actualiza M de acuerdo con el índice de permutación v. Tal vez simplemente no estoy buscando en Internet.

Algo así podría ser posible con la "indexación avanzada" de numpy, pero entiendo que tal solución no estaría en su lugar. También para algunas situaciones simples puede ser suficiente rastrear por separado una permutación de índice, pero esto no es conveniente en mi caso.

Agregado: a
veces, cuando las personas hablan de permutaciones, solo se refieren al muestreo de permutaciones aleatorias, por ejemplo, como parte de un procedimiento para obtener valores p en las estadísticas. O significan contar o enumerar todas las permutaciones posibles. No estoy hablando de estas cosas.

Agregado:
la matriz es lo suficientemente pequeña como para caber en la RAM del escritorio, pero lo suficientemente grande como para que no quiera copiarla sin pensar. En realidad, me gustaría usar matrices lo más grandes posible, pero no quiero lidiar con el inconveniente de no poder mantenerlas en la RAM, y hago operaciones de O (N ^ 3) LAPACK en la matriz que también limitar el tamaño práctico de la matriz. Actualmente copio matrices tan grandes innecesariamente, pero espero que esto pueda evitarse fácilmente para la permutación.

Según los documentos, no hay un método de permutación en el lugar en numpy, algo así como ndarray.sort .

Entonces, sus opciones son (suponiendo que Msea ​​una matriz y el vector de permutación)$N\times N$p

1. implementando su propio algoritmo en C como módulo de extensión (¡pero los algoritmos locales son difíciles, al menos para mí!)

2. $N$ sobrecarga de memoria

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

3. $N^2$ sobrecarga de memoria

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

Espero que estos hacks subóptimos sean útiles.

Advertencia: El siguiente ejemplo funciona correctamente, pero el uso del conjunto completo de parámetros sugeridos al final de la publicación expone un error , o al menos una "característica no documentada" en la función numpy.take (). Vea los comentarios a continuación para más detalles. Informe de error archivado .

Puede hacerlo en el lugar con la función take () de numpy , pero requiere un poco de salto de aro.

Aquí hay un ejemplo de hacer una permutación aleatoria de las filas de una matriz de identidad:

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.]])

Para hacerlo en el lugar, todo lo que necesita hacer es especificar el parámetro "out" para que sea el mismo que la matriz de entrada Y debe configurar mode = "clip" o mode = "wrap". Si no configura el modo, realizará una copia para restaurar el estado de la matriz en una excepción de Python (consulte aquí) .

En una nota final, take parece ser un método de matriz, así que en lugar de

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

podrías llamar

i.take(rr, axis=0)

si eso es más a tu gusto. Entonces, en total, la llamada debe tener un aspecto similar al siguiente:

#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")

Para permutar tanto las filas como las columnas, creo que tienes que ejecutarlo dos veces, o sacar algunas travesuras feas con numpy.unravel_index que me duele la cabeza al pensar.

Si tiene una matriz dispersa almacenada en COOformato, lo siguiente podría ser útil

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

suponiendo que Acontiene la COOmatriz, y permes un que numpy.arraycontiene la permutación. Esto solo tendrá sobrecarga de memoria, donde es el número de elementos distintos de cero de la matriz.$m$$m$

No tengo suficiente reputación para comentar, pero creo que la siguiente pregunta SO podría ser útil: /programming/4370745/view-onto-a-numpy-array

Los puntos básicos son que se puede utilizar rebanar básica y que va a crear una visión de a la matriz sin necesidad de copiar, pero si lo hace avanzada rebanar / indexación entonces se van a crear una copia.

Qué pasa

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