Cho phép một ma trận tại chỗ trong numpy

Tôi muốn sửa đổi một ma trận chuyển tiếp hình vuông dày đặc tại chỗ bằng cách thay đổi thứ tự của một số hàng và cột của nó, sử dụng thư viện numpy của python. Về mặt toán học, điều này tương ứng với việc nhân trước ma trận với ma trận hoán vị P và nhân sau với P ^ -1 = P ^ T, nhưng đây không phải là một giải pháp hợp lý về mặt tính toán.

Ngay bây giờ tôi đang trao đổi các hàng và cột theo cách thủ công, nhưng tôi đã mong đợi numpy có một hàm đẹp f (M, v) trong đó M có n hàng và cột và v có n mục, để f (M, v) cập nhật M theo hoán vị chỉ số v. Có lẽ tôi chỉ thất bại trong việc tìm kiếm trên internet.

Một cái gì đó như thế này có thể khả thi với "lập chỉ mục nâng cao" của numpy nhưng sự hiểu biết của tôi là một giải pháp như vậy sẽ không được áp dụng. Ngoài ra đối với một số tình huống đơn giản, có thể chỉ cần theo dõi riêng một hoán vị chỉ số, nhưng điều này không thuận tiện trong trường hợp của tôi.

Đã thêm:
Đôi khi khi mọi người nói về hoán vị, họ chỉ có nghĩa là lấy mẫu các hoán vị ngẫu nhiên, ví dụ như một phần của quy trình để lấy giá trị p trong thống kê. Hoặc họ có nghĩa là đếm hoặc liệt kê tất cả các hoán vị có thể. Tôi không nói về những điều này.

Đã thêm:
Ma trận đủ nhỏ để vừa với RAM máy tính để bàn nhưng đủ lớn để tôi không muốn sao chép nó một cách thiếu suy nghĩ. Trên thực tế tôi muốn sử dụng ma trận càng lớn càng tốt, nhưng tôi không muốn đối phó với sự bất tiện khi không thể giữ chúng trong RAM và tôi thực hiện các thao tác LAPACK O (N ^ 3) trên ma trận cũng sẽ giới hạn kích thước ma trận thực tế. Tôi hiện đang sao chép ma trận lớn này một cách không cần thiết, nhưng tôi hy vọng điều này có thể dễ dàng tránh được cho hoán vị.

Theo các tài liệu, không có phương pháp hoán vị tại chỗ trong numpy, một cái gì đó giống như ndarray.sort .

Vì vậy, các tùy chọn của bạn là (giả sử đó Mlà ma trận và vectơ hoán vị)$N\times N$p

1. thực hiện thuật toán của riêng bạn trong C như một mô-đun mở rộng (nhưng thuật toán tại chỗ rất khó, ít nhất là đối với tôi!)

2. $N$ bộ nhớ trên không

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

3. $N^2$ bộ nhớ trên đầu

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

Hy vọng rằng những hack tối ưu này là hữu ích.

Cảnh báo: Ví dụ bên dưới hoạt động chính xác, nhưng sử dụng bộ tham số đầy đủ được đề xuất ở cuối bài đăng sẽ phát hiện ra lỗi hoặc ít nhất là "tính năng không có tài liệu" trong hàm numpy.take (). Xem ý kiến ​​dưới đây để biết chi tiết. Báo cáo lỗi đã nộp .

Bạn có thể thực hiện việc này tại chỗ với chức năng Take () của numpy , nhưng nó đòi hỏi một chút nhảy vọt.

Dưới đây là một ví dụ về thực hiện hoán vị ngẫu nhiên các hàng của ma trận danh tính:

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

Để thực hiện tại chỗ, tất cả những gì bạn cần làm là chỉ định tham số "out" giống với mảng đầu vào VÀ bạn phải đặt mode = "clip" hoặc mode = "quấn". Nếu bạn không đặt chế độ, nó sẽ tạo một bản sao để khôi phục trạng thái mảng trên một ngoại lệ Python (xem tại đây) .

Trên một lưu ý cuối cùng, dường như là một phương thức mảng, vì vậy thay vì

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

bạn có thể gọi

i.take(rr, axis=0)

nếu đó là nhiều hơn với khẩu vị của bạn. Vì vậy, trong tổng số bạn gọi nên trông giống như sau:

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

Để hoán vị cả hàng và cột tôi nghĩ rằng bạn phải chạy nó hai lần hoặc kéo một số shenanigans xấu xí bằng numpy.unravel_index làm tôi đau đầu khi nghĩ về.

Nếu bạn có một ma trận thưa thớt được lưu trữ ở COOđịnh dạng, những điều sau đây có thể hữu ích

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

ACOOpermnumpy.array$m$$m$

Tôi không đủ danh tiếng để bình luận, nhưng tôi nghĩ câu hỏi SO sau đây có thể hữu ích: https://stackoverflow.com/questions/4370745/view-onto-a-numpy-array

Các điểm cơ bản là bạn có thể sử dụng cắt cơ bản và điều đó sẽ tạo ra một khung nhìn vào mảng mà không cần sao chép, nhưng nếu bạn thực hiện cắt / lập chỉ mục nâng cao thì nó sẽ tạo một bản sao.

Thế còn

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