Question

我想遍历矩阵矩阵（确实，听起来很奇怪），

import numpy as np

ar = np.array

A = ar([[[1,2,3],[4,5,6],[7,8,9]],[[11,12,13],[14,15,16],[17,18,19]], [[1,2,3],[4,5,6],[7,8,9]], [[20,21,22],[23,24,25],[26,27,28]]])

B = np.copy(A)
C = np.copy(A)

im = np.array([A,B,C])

以便接收在后续矩阵中存储（x，y）位置值的矩阵。例如，在[1，2，3]中，位置1表示：A [0,0,0]，在接下来的矩阵中将仅出现一个。因此，我将在新矩阵中接收一个数组（还要考虑A [0,0,1]和A [0,0,2]）：

[[1  1  1] [2  2  2] [3  3  3]]

因此对于A的第一个数组：

[[[1  1  1] [2  2  2] [3  3  3]]
[[4  4  4] [5  5  5] [6  6  6]]
[[7  7  7] [8  8  8] [9  9  9]]]

我已经创建了此功能：

def loop_ar(arr):
    matrix, v, c, s = arr.shape
    new = np.zeros((v,c,s,matrix)) #The columns in the last array of new represent the subsequent arrays
    for x in range(v):
        for y in range(c):
            for s in range(s):
                for ma in range(matrix):
                    new[x,y,s,ma] = arr[ma, x, y, s]
    return new

但是，输出指示矩阵经过几转后就停止了迭代：

[[[[1. 1. 1.]
   [2. 2. 2.]
   [3. 3. 3.]]

  [[4. 4. 4.]
   [5. 5. 5.]
   [0. 0. 0.]]

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

   ...

当我在列表上测试此功能时，它起作用了。在这种情况下发生了什么？我该如何解决？这只是一个简单的例子来说明我的期望；但是，当B和C不是A的副本时，我想知道一个更复杂的问题的解决方案。如何强制循环迭代？

在更复杂的情况下，B和C应该具有与A相同的形状，但是在最后一个数组中它们将有所不同。像在A中一样：

[1  2  3]

在B中，例如，我们将处于同一位置：

[23  34  56]

和C：

[54  43  32]

因此，新矩阵将包括数组：

[[1  23  54]  [2  34  43]  [3  56  32]]

我已经完成了将列表转换为数组的任务（我希望如此），因为loop_arr适用于列表。但是，这是一个转轮游戏。我想要解决方案和循环中断的解释。

在这里，我为更复杂的问题提供了随机数据：

A = ar([[[1,2,3],[4,5,6],[7,8,9]],[[11,12,13],[14,15,16],[17,18,19]],[[20,21,22],[23,24,25],[26,27,28]]])

B = ar([[[23,34,56], [56, 78, 90], [12, 34, 32]], [[74,75,65], [25,57,76], [90,24,35]]])

C = ar([[[13,31,53], [54,96,69], [78, 90, 99]], [[35,64,66], [13,35,53], [37,73,61]], [[62, 87,97], [80,35,62], [75,76,67]]]

新矩阵如下：

[[[[1  23  13]  [2  34  31]  [3  56  53]]
[[4  56  54]  [5  78  96] [6  90  69]]
[[7  12  78]  [8  34  90]  [9  32  99]]]
      ...so on, so on, so on...
                                     ]]]]

Answer 1

numpy已被矢量化。您可以制作克罗内克产品：

 np.kron(a,np.ones(3)).reshape(np.r_[a.shape,3])

array([[[[ 1.,  1.,  1.],
         [ 2.,  2.,  2.],
         [ 3.,  3.,  3.]],

        [[ 4.,  4.,  4.],
         [ 5.,  5.,  5.],
         [ 6.,  6.,  6.]],

        [[ 7.,  7.,  7.],
         [ 8.,  8.,  8.],
         [ 9.,  9.,  9.]]],


       [[[11., 11., 11.],
         [12., 12., 12.],
         [13., 13., 13.]],


        : : : : 
        : : : :

Answer 2

In [44]: A = np.array([[[1,2,3],[4,5,6],[7,8,9]],[[11,12,13],[14,15,16],[17,18,19]], 
    ...: [[1,2,3],[4,5,6],[7,8,9]], [[20,21,22],[23,24,25],[26,27,28]]]) 
    ...:                                                                         
In [45]: A.shape                                                                     
Out[45]: (4, 3, 3)
In [46]: im = np.array([A,A+10,A+20])                                                
In [47]: im.shape                                                                    
Out[47]: (3, 4, 3, 3)

在我看来，您的代码只是对轴进行换位，将matrix尺寸放在最后而不是放在第一。 np.stack采用轴参数。另外，我们可以使用transpose函数/方法：

In [48]: im1 = np.stack([A,A+10,A+20], axis=3)                                       
In [49]: im1.shape                                                                   
Out[49]: (4, 3, 3, 3)
In [50]: im2 = im.transpose(1,2,3,0)                                                 
In [51]: im2.shape                                                                   
Out[51]: (4, 3, 3, 3)
In [52]: im2                                                                         
Out[52]: 
array([[[[ 1, 11, 21],
         [ 2, 12, 22],
         [ 3, 13, 23]],

        [[ 4, 14, 24],
         [ 5, 15, 25],
         [ 6, 16, 26]],

        [[ 7, 17, 27],
         [ 8, 18, 28],
         [ 9, 19, 29]]],

        ....
        [[26, 36, 46],
         [27, 37, 47],
         [28, 38, 48]]]])
In [53]: np.allclose(im1,im2)                                                        
Out[53]: True

我无法测试更复杂的情况，因为B的形状错误。并且C的终止字符错误。

===

要查看您的迭代有什么问题，请在其循环开始时打印s。看看它是如何演变的。然后将迭代变量更改为k，并进行观察。

遍历在numpy中停止的列表中的矩阵

2 个答案: