如何基于另一个 ndarray 最有效地切换一个 ndarray 中的元素

Question

I'm having trouble figuring out how to efficently create a copy of a 3d numpy array where a small number of the elements are swapped around.

I'd like to be able to do something like the following:

#the matrix to rearange 
a=np.array(
 [[[ 0,  1,  2],
    [ 3,  4,  5],
    [ 6,  7,  8]],

   [[ 9, 10, 11],
    [12, 13, 14],
    [15, 16, 17]],

   [[18, 19, 20],
    [21, 22, 23],
    [24, 25, 26]]])

#a matric of indicies in a. In this case, [0,1,0] -> [0,0,0] -> [0,2,1] and all the rest are the the same
b=np.array(
[[[[0, 1, 0], [0, 0, 1], [0, 0, 2]],
  [[0, 2, 1], [0, 1, 1], [0, 1, 2]],
  [[0, 2, 0], [0, 0, 0], [0, 2, 2]]],

[[[1, 0, 0], [1, 0, 1], [1, 0, 2]],
 [[1, 1, 0], [1, 1, 1], [1, 1, 2]],
 [[1, 2, 0], [1, 2, 1], [1, 2, 2]]],

[[[2, 0, 0], [2, 0, 1], [2, 0, 2]],
 [[2, 1, 0], [2, 1, 1], [2, 1, 2]],
 [[2, 2, 0], [2, 2, 1], [2, 2, 2]]]])

>>>np.something(a,b,whatever)
>>>np.array(
 [[[ 3,  1,  2],
   [ 7,  4,  5],
   [ 6,  0,  8]],

   [[ 9, 10, 11],
    [12, 13, 14],
    [15, 16, 17]],

   [[18, 19, 20],
    [21, 22, 23],
    [24, 25, 26]]])

I'm also open to having b be full of indicies in the flattened version of a instead of coordinate vectors, but I'm still not sure how/if it could work efficiently.

Alternatively, if there's a way to make this work, the transformation matrix could be encoded with unit translations like this:

#the matrix to rearange 
a=np.array(
  [[[ 0,  1,  2],
    [ 3,  4,  5],
    [ 6,  7,  8]],

   [[ 9, 10, 11],
    [12, 13, 14],
    [15, 16, 17]],

   [[18, 19, 20],
    [21, 22, 23],
    [24, 25, 26]]])

 #a transformation matric showing the same [0,1,0] -> [0,0,0] -> [0,2,1], but in terms of displacement. 
#In other words, the data in [0,0,0] is moved down 2 rows and right 1 column to [0,2,0], because b[0,0,0]=[0,2,1]
b=np.array(
[[[[0, 2, 1], [0, 0, 0], [0, 0, 0]],
  [[0, -1, 0], [0, 0, 0], [0, 0, 0]],
  [[0, 0, 0], [0, -1, -1], [0, 0, 0]]],

 [[[0, 0, 0], [0, 0, 0], [0, 0, 0]],
  [[0, 0, 0], [0, 0, 0], [0, 0, 0]],
  [[0, 0, 0], [0, 0, 0], [0, 0, 0]]],

 [[[0, 0, 0], [0, 0, 0], [0, 0, 0]],
  [[0, 0, 0], [0, 0, 0], [0, 0, 0]],
  [[0, 0, 0], [0, 0, 0], [0, 0, 0]]]])


>>>np.something(a,b,whatever)
>>>np.array(
  [[[ 3,  1,  2],
    [ 7,  4,  5],
    [ 6,  0,  8]],

   [[ 9, 10, 11],
    [12, 13, 14],
    [15, 16, 17]],

   [[18, 19, 20],
    [21, 22, 23],
    [24, 25, 26]]])

Answer 1

(Using your first version of a and b ) You are looking for

a[tuple(np.moveaxis(b,-1,0))]

this splits b into individual arrays, one for each dimension of a and then uses them to index into a by means of "advanced" or "fancy" indexing.

Please note that the tuple conversion is important here. It changes the way numpy interprets the indices by telling it to treat each element of the tuple as indexing into one dimension. Left as a single nd array instead it would have been read as all indexing into dimension 0 . Try it out to get a feel for it!