2D numpy中的所有二元组合

Question

我正在尝试创建一个代码，该代码可以在不包括旋转的Numpy矩阵中生成所有可能的组合。 我是什么意思旋转？我的意思是，以下矩阵数据实际上是相同的，因为它具有相同的数据，但旋转了90º，180º和270º。

我一直在尝试以下代码，但我认为我没有得到所有组合，并且其中一些缺少。您是否知道这是正确的方法？您知道是否有更有效的方法？

例如，考虑dx = 3和dy = 3

import numpy as np

def myfunction(data)
   print(data)

dx=3
dy=3
data = np.zeros([dx, dy], dtype=np.uint8)

y=0

for x in range(dx):
    for r in range(2):
        data[x, y] = r
        myfunction(data)
        for y in range(dy):
            for s in range(2):
                data[x, y] = s
                myfunction(data)

非常感谢！

Answer 1

这是一个矢量化解决方案，可以适用于小矩阵尺寸；代码中的评论说明了3乘3的情况：

def get_binary_mats(n):
  # all possible n by n binary matrices up to rotation: 
  bin_mats = (np.bitwise_and(np.arange(2**(n*n))[:,None], 2 ** np.arange(n*n)) > 0)\
    .reshape(-1, n, n)
  # define a score for each matrix based on position of ones
  score = 2 ** np.arange(n*n).reshape(n,n)
  # array([[  1,   2,   4],
        #  [  8,  16,  32],
        #  [ 64, 128, 256]])
  score_arr = np.stack([np.rot90(score, k=k) for k in range(4)])
  # array([[[  1,   2,   4],
  #         [  8,  16,  32],
  #         [ 64, 128, 256]],

  #        [[  4,  32, 256],
  #         [  2,  16, 128],
  #         [  1,   8,  64]],

  #        [[256, 128,  64],
  #         [ 32,  16,   8],
  #         [  4,   2,   1]],

  #        [[ 64,   8,   1],
  #         [128,  16,   2],
  #         [256,  32,   4]]])

  scores = np.einsum("ijk,ljk->il", bin_mats, score_arr)
  _, idx = np.unique(scores.min(1), return_index=True)
  return bin_mats[idx,...]

主要思想是，我们可以将n b n b n binary矩阵的“点产品”与n by n矩阵一起使用，该矩阵由n矩阵组成，该矩阵由2的第一个n^2 powers组成（我称为后者得分矩阵）。当我们这样做时，我们将为每个可能的二进制矩阵获得一个唯一的整数。

为了说明旋转，我们可以使用“分数”矩阵4旋转的“点产品”，并将每个二进制矩阵与四个结果的最小值相关联。我们可以将此最小值称为二进制矩阵的分数。

最后，我们可以使用np.nique为每个唯一分数选择一个矩阵。例如，这是n = 2的输出：

array([[[False, False],
        [False, False]],

       [[ True, False],
        [False, False]],

       [[ True,  True],
        [False, False]],

       [[False,  True],
        [ True, False]],

       [[ True,  True],
        [ True, False]],

       [[ True,  True],
        [ True,  True]]])

作为一项理智检查，二进制矩阵的数量直至旋转，此OEIS序列 n最多5：

%time assert [get_binary_mats(k).shape[0] for k in range(1, 6)] == [2, 6, 140, 16456, 8390720]
# takes 20 seconds on my machine

Answer 2

我不确定我的答案是否是最有效的方法，但是无论如何。

我们可以使用numpy.rot90函数旋转每个矩阵。

让我们创建两个不同的词典，一个用于存储主矩阵，另一个用于存储主矩阵旋转，因此我们可以验证新矩阵是否只是先前发现的矩阵的旋转。

def Not_Rotated(dx, dy):
    import numpy as np
    from itertools import product

    Big_Matrix = np.array([[list(i[x:x+dx]) for x in range(0, len(i), dx)] for i in product("01", repeat=dx*dy)])  # Stores all possible combinations

    Main = dict()  # Stores not rotated
    Main_c = 0

    Rotations = dict()  # Stores rotated
    Rotation_c = 0

    for i in range(len(Big_Matrix)):  # Going through all combinations
        flag = 1  # A flag to check if this combination is rotated of previous ones or not. 1= is not rotated of previous ones. 0 = is rotated.
        for z in range(Rotation_c):
            if np.array_equal(Big_Matrix[i],Rotations[z]):  # Checking if this combination is rotated of previous ones or not
                flag = 0

        if flag:  # If this combination is not a rotation of previous ones
            Main[Main_c] = Big_Matrix[i]
            # Rotate it three times and store the matrices
            Rotations[Rotation_c] = np.rot90(Main[Main_c])
            Rotations[Rotation_c + 1] = np.rot90(Main[Main_c])
            Rotations[Rotation_c + 2] = np.rot90(Main[Main_c])
            Rotation_c += 3
            Main_c += 1
    return Main