Permita uma matriz no local em numpy

Eu quero modificar uma matriz de transição quadrada densa no local, alterando a ordem de várias de suas linhas e colunas, usando a biblioteca numpy do python. Matematicamente, isso corresponde à pré-multiplicação da matriz pela matriz de permutação P e à pós-multiplicação por P ^ -1 = P ^ T, mas essa não é uma solução computacionalmente razoável.

No momento, estou trocando manualmente linhas e colunas, mas eu esperava que o numpy tivesse uma boa função f (M, v), onde M tem n linhas e colunas ev tem n entradas, para que f (M, v) seja atualizado M de acordo com a permutação de índice v. Talvez eu esteja apenas falhando ao pesquisar na internet.

Algo assim pode ser possível com a "indexação avançada" da numpy, mas meu entendimento é que essa solução não estaria em vigor. Também para algumas situações simples, pode ser suficiente rastrear apenas uma permutação de índice separadamente, mas isso não é conveniente no meu caso.

Adicionado:
Às vezes, quando as pessoas falam sobre permutações, elas significam apenas a amostragem de permutações aleatórias, por exemplo, como parte de um procedimento para obter valores de p em estatística. Ou eles significam contar ou enumerar todas as permutações possíveis. Eu não estou falando sobre essas coisas.

Adicionado:
a matriz é pequena o suficiente para caber na RAM da área de trabalho, mas grande o suficiente para que eu não queira copiá-la sem pensar. Na verdade, eu gostaria de usar matrizes tão grandes quanto possível, mas não quero lidar com o inconveniente de não poder mantê-las na RAM e faço O (N ^ 3) operações LAPACK na matriz, o que também limitar o tamanho da matriz prática. Atualmente, copio matrizes desse tamanho desnecessariamente, mas espero que isso possa ser facilmente evitado por permutação.

De acordo com os documentos, não existe um método de permutação no local em numpy, algo como ndarray.sort .

Portanto, suas opções são (assumindo que Mseja uma matriz e o vetor de permutação)$N\times N$p

1. implementar seu próprio algoritmo em C como um módulo de extensão (mas algoritmos no local são difíceis, pelo menos para mim!)

2. $N$Sobrecarga de memória

   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 memória

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

Espero que esses hacks abaixo do ideal sejam úteis.

Aviso: O exemplo abaixo funciona corretamente, mas o uso do conjunto completo de parâmetros sugeridos no final da publicação expõe um bug ou pelo menos um "recurso não documentado" na função numpy.take (). Veja os comentários abaixo para obter detalhes. Relatório de bug arquivado .

Você pode fazer isso no local com a função take () de numpy , mas isso requer um pouco de pulos de argola.

Aqui está um exemplo de como fazer uma permutação aleatória das linhas de uma matriz de identidade:

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 fazer isso no local, tudo o que você precisa fazer é especificar o parâmetro "out" para ser o mesmo da matriz de entrada E você deve definir o mode = "clip" ou mode = "wrap". Se você não definir o modo, ele fará uma cópia para restaurar o estado do array em uma exceção do Python (veja aqui) .

Em uma nota final, take parece ser um método de matriz, portanto, em vez de

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

você poderia ligar

i.take(rr, axis=0)

se isso é mais do seu gosto. Portanto, no total, você chama deve ser algo como o seguinte:

#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 linhas e colunas, acho que você precisa executá-lo duas vezes ou puxar algumas travessuras feias com numpy.unravel_index que machuca minha cabeça.

Se você possui uma matriz esparsa armazenada em COOformato, o seguinte pode ser útil

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

ACOOpermnumpy.array$m$$m$

Não tenho reputação suficiente para comentar, mas acho que a seguinte pergunta SO pode ser útil: /programming/4370745/view-onto-a-numpy-array

Os pontos básicos são que você pode usar o corte básico e que irá criar uma visão para a matriz sem copiar, mas se você fizer avançado corte / indexação em seguida, ele irá criar uma cópia.

Sobre o quê

minha matriz [:, [0, 1]] = minha matriz [:, [1, 0]]