Zezwól na macierz w miejscu w numpy

Chcę zmodyfikować gęstą kwadratową macierz przejścia w miejscu, zmieniając kolejność kilku jej wierszy i kolumn, używając biblioteki numpy Pythona. Matematycznie odpowiada to pomnożeniu macierzy przez macierz permutacji P i pomnożeniu jej przez P ^ -1 = P ^ T, ale nie jest to uzasadnione obliczeniowo rozwiązanie.

W tej chwili ręcznie zmieniam wiersze i kolumny, ale oczekiwałbym, że numpy będzie mieć fajną funkcję f (M, v), gdzie M ma n wierszy i kolumn, a v ma n wpisów, więc f (M, v) aktualizuje M zgodnie z permutacją indeksu v. Może po prostu nie udaje mi się przeszukać Internetu.

Coś takiego może być możliwe przy „zaawansowanym indeksowaniu” Numpy, ale rozumiem, że takie rozwiązanie nie byłoby na miejscu. Również w niektórych prostych sytuacjach może być wystarczające oddzielne śledzenie permutacji indeksu, ale w moim przypadku nie jest to wygodne.

Dodano:
Czasami, gdy ludzie mówią o permutacjach, mają na myśli jedynie próbkowanie permutacji losowych, na przykład jako część procedury uzyskiwania wartości pw statystyce. Lub oznaczają zliczanie lub wyliczanie wszystkich możliwych permutacji. Nie mówię o tych rzeczach.

Dodano:
Matryca jest wystarczająco mała, aby zmieściła się w RAM-ie pulpitu, ale wystarczająco duża, że ​​nie chcę jej bezmyślnie kopiować. Właściwie chciałbym używać macierzy tak dużych, jak to możliwe, ale nie chcę uporać się z niedogodnościami związanymi z niemożnością trzymania ich w pamięci RAM i wykonuję operacje O (N ^ 3) LAPACK na macierzy, które również ograniczyć praktyczny rozmiar matrycy. Obecnie niepotrzebnie kopiuję macierze tak duże, ale mam nadzieję, że można tego łatwo uniknąć w przypadku permutacji.

Według dokumentów nie ma metody permutacji w miejscu w numpy, coś takiego jak ndarray.sort .

Więc masz opcje (zakładając, że Mjest to macierz i wektor permutacji)$N\times N$p

1. implementacja własnego algorytmu w C jako modułu rozszerzenia (ale algorytmy lokalne są trudne, przynajmniej dla mnie!)

2. $N$Narzut pamięci

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

3. $N^2$Narzut pamięci

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

Mam nadzieję, że te nieoptymalne hacki są przydatne.

Ostrzeżenie: poniższy przykład działa poprawnie, ale użycie pełnego zestawu parametrów sugerowanych po zakończeniu ujawnia błąd lub przynajmniej „nieudokumentowaną funkcję” w funkcji numpy.take (). Szczegóły znajdują się w komentarzach poniżej. Zgłoszony raport o błędzie .

Możesz to zrobić w miejscu za pomocą funkcji take () numpy , ale wymaga to nieco przeskoku.

Oto przykład losowej permutacji wierszy macierzy tożsamości:

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

Aby to zrobić w miejscu, wystarczy podać parametr „out”, aby był taki sam jak tablica wejściowa ORAZ musisz ustawić tryb = „klip” lub tryb = „zawiń”. Jeśli nie ustawisz trybu, utworzy kopię, aby przywrócić stan tablicy w wyjątku Pythona (patrz tutaj) .

Na koniec uwaga wydaje się być metodą tablicową, więc zamiast

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

możesz zadzwonić

i.take(rr, axis=0)

jeśli to bardziej do gustu. W sumie zadzwoń powinien wyglądać mniej więcej tak:

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

Aby permutować zarówno wiersze, jak i kolumny, myślę, że albo trzeba je uruchomić dwa razy, albo wyciągnąć brzydkie shenanigany za pomocą numpy.unravel_index, który boli mnie do myślenia.

Jeśli masz rzadką macierz przechowywaną w COOformacie, pomocne mogą być następujące elementy

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

przy założeniu, że Azawiera COOmatrycę, oraz permjest numpy.arrayzawierający permutacji. Będzie to miało tylko narzut pamięci , gdzie jest liczbą niezerowych elementów macierzy.$m$$m$

Nie mam wystarczającej reputacji, aby móc komentować, ale myślę, że następujące SO pytanie może być pomocne: /programming/4370745/view-onto-a-numpy-array

Podstawowe punkty, które można wykorzystać podstawową krojenie i że stworzy widok na do tablicy bez kopiowania, ale jeśli zaawansowanym krojenia / indeksowanie to będzie utworzyć kopię.

Co powiesz na

moja_tablica [:, [0, 1]] = moja_tablica [:, [1, 0]]