Python矩阵比较

我有大数据，比如：

{'a_1':0b110000,
 'a_2':0b001100,
 'a_3':0b000011,
 'b_1':0b100100,
 'b_2':0b000001,
 'c_1':0b100000,}

等等。。。数据的结构可以重新组织，更能显示我想要实现的目标。“a”的行永远不会被其子行重叠。 根据大多数匹配值，获得两行（ab、ac）或三行（abc）或更多行的最佳组合的性能方法是什么？ 希望，这些问题在某种程度上是明确的，难以描述：/ 也许是numpy的一些矩阵运算

更多信息： 两种可能的组合为ab、ac、bc。ab将a（a_1，a_2，a_3）的行与b（b_1，b_2）的行相互检查。a_1和b_1表示0b110000和0b100100，将给出一个结果。a_1和b_2表示0b110000和0b000001，不会给出结果。这可能是循环对解决方案的描述，但速度非常慢，特别是对于8个左右的组合（示例数据未涵盖）

也许数据的结构更清晰：

{'a': [0b110000,
       0b001100,
       0b000011],
 'b': [0b100100,
       0b000001],
 'c': [0b100000]}

让我展示一下，到目前为止我是如何进行这些计算的。数据结构有点不同，因为我试图以一个“我认为”更好的结构开始这个问题

data = {'a':[1,1,2,2,3,3],
        'b':[4,5,5,5,4,5],
        'c':[6,7,7,7,6,7]}    

combine_count = 3
for config in combinations(['a','b','c'],combine_count):
    ret = {}
    for index,combined in enumerate(zip(*tuple(data.get(k) for k in config))):
        ret.setdefault(combined, []).append(index)

for k,v in ret.items():
    score = len(v)
    if score >= 2:
        print(k,score)

我的问题是，尤其是构建与更大的联合计数相结合的过程需要很多时间。

---

当然，数据要大得多。它有大约231个键，每个键的列表长度约为60000。此外，RAM消耗太高

不确定您的三重评估*但是您可以修改它来做您想做的事情。我假设您将迭代a、b、c等的组合

#!/usr/bin/python
import numpy as np
import random
import time

A = [np.random.randint(0, 2**15, random.randint(1, 5)) + 2**16 for i in range(231)]
best_score = 0
tm = time.time()
for i, a in enumerate(A):
  for j, b in enumerate(A[1:]):
    for k, c in enumerate(A[2:]):
      an, bn, cn = len(a), len(b), len(c) #some shortcuts

      a_block = np.broadcast_to(a.reshape(an, 1, 1), (an, bn, cn))
      b_block = np.broadcast_to(b.reshape(1, bn, 1), (an, bn, cn))
      c_block = np.broadcast_to(c.reshape(1, 1, cn), (an, bn, cn))

      all_and = c_block & b_block & a_block

      all_score = ((all_and & 1) + 
                   ((all_and >> 1) & 1) +
                   ((all_and >> 2) & 1) +
                   ((all_and >> 3) & 1) +
                   ((all_and >> 4) & 1) +
                   ((all_and >> 5) & 1))
      ix = np.unravel_index(np.argmax(all_score), (an, bn, cn))
      if all_score[ix] > best_score:
        print(i,j,k, ix, all_score[ix], a_block[ix], b_block[ix], c_block[ix])
        best_score = all_score[ix]
        best_abc = (i, j, k)
        best_ix = ix[:]

print(time.time() - tm)
print(best_score)
print(best_abc)
print(best_ix)
''' gives
0 0 0 (0, 2, 0) 2 95038 76894 78667
0 0 1 (0, 3, 1) 3 95038 70262 96242
0 0 2 (0, 2, 0) 4 95038 76894 96255
0 3 2 (0, 0, 0) 5 95038 96255 96255
4 3 2 (0, 0, 0) 6 96255 96255 96255
871.6093053817749
6
(4, 3, 2)
(0, 0, 0)
'''

编辑*我认为该代码可以：找到a1&b1&c1、a2&b1&c1、a3&b1&c1、a1&b2&c1等之间的最大值的位置（和值），这可能与a1&b1&c1 | a2&b1&c1 | a3&b1&c1 | a1&b2&c1不同

EDIT2更明确地显示了在伪数据集上迭代的过程。a、 b、c是1到5长的数组，但numpy randint不能生成60000位长的随机数，而且我也没有尝试确保所有的数字都是唯一的（这很容易做到），在这个功能不太强大的笔记本电脑上大约需要15米，所以这给了您一个比较的起点

---

加速该过程的一种方法可能是将比较限制在两种情况下，即A、b开始并保留一份高分者列表，然后根据列表中的所有其他条目进行组合，以选择三种方式中得分最高的一种。

使用数据示例准确显示您获得的结果。（ab，ac）和（abc）似乎不知从何而来，与您的大数据没有直接关系。添加了更多信息。希望，这会有帮助。那么ab是否会导致a1&b1->16，a1&b2->0，a2&b1->4，a2&b2->0，a3&b1->0，a3&b2->1，它们都会得到1分匹配且相等？对于你的三重版本，估值会是，比如说，a1和b1 | a1和c1 | b1和c1？准确地说。更多的匹配意味着更高的分数。但是三重评估将是a1&b1&c1 | a2&b1&c1……好的，今天我们已经离开了，但明天会提出一些建议。您可能会对每个组合执行3个阶段的过程1）平铺并重塑每个阵列（即，对于a、b或c），以使它们是相同大小的阵列，但按不同维度排序2）&它们一起3）按位移位计数位&1感谢您的回答：）。我需要一些时间来检查一下。但是你能解释一下它的输出吗？我不太确定这是什么意思。顺便说一句，也许我应该注意，输入数据不需要是那些二进制数。他们只是在标记a、b、c的不同值的位置。这是你的答案的输出：[[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的两位匹配，并添加了更多解释。希望现在更清楚了。（也将all_或重命名为all_，不知道我以前为什么称它为“或！”）遗憾的是，您的解决方案在应用于我的数据时不起作用。“shape”（an，1，1的a.reforme（an，1，1））的长度是231，我得到这个错误：ValueError:sequence太大；不能大于32。如果您输入的是231维数组，那么这将破坏我的代码。a、 b、c等都必须是一维的。是否有任何地方可以看到您想要分析的完整数据集？