Permutez une matrice en place dans numpy

Je veux modifier une matrice de transition carrée dense en place en changeant l'ordre de plusieurs de ses lignes et colonnes, en utilisant la bibliothèque numpy de python. Mathématiquement, cela correspond à la pré-multiplication de la matrice par la matrice de permutation P et à la post-multiplication par P ^ -1 = P ^ T, mais ce n'est pas une solution calculable.

En ce moment, j'échange manuellement des lignes et des colonnes, mais je m'attendais à ce que numpy ait une belle fonction f (M, v) où M a n lignes et colonnes, et v a n entrées, de sorte que f (M, v) se mette à jour M selon la permutation d'index v. Peut-être que je ne réussis pas à chercher sur Internet.

Quelque chose comme cela pourrait être possible avec "l'indexation avancée" de numpy mais je crois comprendre qu'une telle solution ne serait pas en place. De plus, pour certaines situations simples, il peut être suffisant de suivre séparément une permutation d'index, mais ce n'est pas pratique dans mon cas.

Ajouté:
Parfois, lorsque les gens parlent de permutations, ils ne signifient que l'échantillonnage de permutations aléatoires, par exemple dans le cadre d'une procédure pour obtenir des valeurs de p dans les statistiques. Ou ils signifient compter ou énumérer toutes les permutations possibles. Je ne parle pas de ces choses.

Ajouté:
La matrice est assez petite pour tenir dans la RAM du bureau mais assez grande pour que je ne veuille pas la copier sans réfléchir. En fait, je voudrais utiliser des matrices aussi grandes que possible, mais je ne veux pas gérer l'inconvénient de ne pas pouvoir les conserver dans la RAM, et je fais des opérations O (N ^ 3) LAPACK sur la matrice qui serait également limiter la taille de la matrice pratique. Je copie actuellement des matrices de cette taille inutilement, mais j'espère que cela pourrait être facilement évité pour la permutation.

Selon les documents, il n'y a pas de méthode de permutation sur place dans numpy, quelque chose comme ndarray.sort .

Donc, vos options sont (en supposant que Mc'est une matrice et le vecteur de permutation)$N\times N$p

1. implémenter votre propre algorithme en C comme module d'extension (mais les algorithmes sur place sont difficiles, du moins pour moi!)

2. $N$ mémoire

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

3. $N^2$ mémoire

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

J'espère que ces hacks sous-optimaux sont utiles.

Avertissement: L'exemple ci-dessous fonctionne correctement, mais l' utilisation de l'ensemble complet des paramètres suggérés à la fin du post expose un bogue , ou au moins une "fonctionnalité non documentée" dans la fonction numpy.take (). Voir les commentaires ci-dessous pour plus de détails. Rapport de bogue déposé .

Vous pouvez le faire sur place avec la fonction take () de numpy , mais cela nécessite un peu de saut de cerceau.

Voici un exemple de réalisation d'une permutation aléatoire des lignes d'une matrice d'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.]])

Pour le faire sur place, tout ce que vous devez faire est de spécifier que le paramètre "out" doit être le même que le tableau d'entrée ET vous devez définir le mode = "clip" ou mode = "wrap". Si vous ne définissez pas le mode, il fera une copie pour restaurer l'état du tableau sur une exception Python (voir ici) .

Sur une note finale, take semble être une méthode de tableau, donc au lieu de

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

tu pourrais appeler

i.take(rr, axis=0)

si c'est plus à votre goût. Donc, au total, vous appelez devrait ressembler à ceci:

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

Pour permuter les lignes et les colonnes, je pense que vous devez soit l'exécuter deux fois, soit tirer de vilains manigances avec numpy.unravel_index qui me font penser à la tête.

Si vous avez une matrice clairsemée stockée au COOformat, les éléments suivants peuvent être utiles

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

en supposant que Acontient la COOmatrice, et permest un numpy.arraycontenant la permutation. Il n'y aura que surcharge mémoire, où est le nombre d'éléments non nuls de la matrice.$m$$m$

Je n'ai pas assez de réputation pour commenter, mais je pense que la question SO suivante pourrait être utile: /programming/4370745/view-onto-a-numpy-array

Les points de base sont que vous pouvez utiliser le découpage de base et créerez une vue sur le tableau sans copier, mais si vous le faites tranchage / indexation avancée , alors il va créer une copie.

Qu'en est-il de

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