我想将一个数组中的每个向量与另一个数组中的所有向量进行比较,并计算每个向量匹配多少个符号。让我举一个例子。
我有两个数组,a和b。
对于a中的每个向量,我想将其与b中的每个向量进行比较。然后,我想返回一个维度为np.array((len(a),14))的新数组,其中每个向量保存a中向量与b中的向量匹配的次数为0、1、2、3、4,..,12、13的次数。期望的结果显示在下面的数组c中。

我已经使用np.newaxis()解决了这个问题,但是我的问题是(请参阅下面的函数),它占用了很多内存,因此当a和b变大时,我的计算机无法处理它。因此,我正在寻找一种更有效的方法来进行此计算,因为这会浪费大量的时间来增加矢量的维数,从而使我的记忆变得很困难。一种解决方案是使用普通的for循环,但是这种方法相当慢。

有可能使这些计算更加有效吗?

a = array([[1., 1., 1., 2., 1., 1., 2., 1., 0., 2., 2., 2., 2.],
           [0., 2., 2., 0., 1., 1., 0., 1., 1., 0., 2., 1., 2.],
           [0., 0., 0., 1., 1., 0., 2., 1., 2., 0., 1., 2., 2.],
           [1., 2., 2., 0., 1., 1., 0., 2., 0., 1., 1., 0., 2.],
           [1., 2., 0., 2., 2., 0., 2., 0., 0., 1., 2., 0., 0.]])

b = array([[0., 2., 0., 0., 0., 0., 0., 1., 1., 1., 0., 2., 2.],
           [1., 0., 1., 2., 2., 0., 1., 1., 1., 1., 2., 1., 2.],
           [1., 2., 1., 2., 0., 0., 0., 1., 1., 2., 2., 0., 2.],
           [0., 1., 2., 0., 2., 1., 0., 1., 2., 0., 0., 0., 2.],
           [0., 2., 2., 1., 2., 1., 0., 1., 1., 1., 2., 2., 2.],
           [0., 2., 2., 1., 0., 1., 1., 0., 1., 0., 2., 2., 1.],
           [1., 0., 2., 2., 0., 1., 0., 1., 0., 1., 1., 2., 2.],
           [1., 1., 0., 2., 1., 1., 1., 1., 0., 2., 0., 2., 2.],
           [1., 2., 0., 0., 0., 1., 2., 1., 0., 1., 2., 0., 1.],
           [1., 2., 1., 2., 2., 1., 2., 0., 2., 0., 0., 1., 1.]])

c = array([[0, 0, 0, 2, 1, 2, 2, 2, 0, 0, 1, 0, 0, 0],
           [0, 0, 0, 0, 2, 3, 1, 2, 1, 1, 0, 0, 0, 0],
           [0, 0, 0, 3, 2, 4, 1, 0, 0, 0, 0, 0, 0, 0],
           [0, 0, 0, 3, 0, 3, 2, 1, 1, 0, 0, 0, 0, 0],
           [0, 0, 1, 1, 4, 0, 3, 0, 1, 0, 0, 0, 0, 0]])


我的解决方案:

def new_method_test(a,b):
    test = (a[:,np.newaxis] == b).sum(axis=2)
    zero     = (test == 0).sum(axis=1)
    one      = (test == 1).sum(axis=1)
    two      = (test == 2).sum(axis=1)
    three    = (test == 3).sum(axis=1)
    four     = (test == 4).sum(axis=1)
    five     = (test == 5).sum(axis=1)
    six      = (test == 6).sum(axis=1)
    seven    = (test == 7).sum(axis=1)
    eight    = (test == 8).sum(axis=1)
    nine     = (test == 9).sum(axis=1)
    ten      = (test == 10).sum(axis=1)
    eleven   = (test == 11).sum(axis=1)
    twelve   = (test == 12).sum(axis=1)
    thirteen = (test == 13).sum(axis=1)
    c = np.concatenate((zero,one,two,three,four,five,six,seven,eight,nine,ten,eleven,twelve,thirteen), axis = 0).reshape(14,len(a)).T
    return c


谢谢你的帮助。

最佳答案

欢迎来到Stackoverflow!我认为,如果要节省内存,for循环是解决问题的方法(而且速度并不慢)。另外,您可以使用np.bincount直接从一项测试转到您的c输出矩阵。我认为这种方法将与您的方法差不多快,并且相比之下,它将使用更少的内存。

import numpy as np
c = np.empty(a.shape, dtype=int)
for i in range(a.shape[0]):
    test_one_vector = (a[i,:]==b).sum(axis=1)
    c[i,:] = np.bincount(test_one_vector, minlength=a.shape[1])




小旁注:如果您确实要处理a和b中的浮点数,则应考虑放弃等式检查(==),转而支持类似度检查的方法,例如np.isclose

关于python - np.newaxis()的替代方案,用于在比较数组时节省内存,我们在Stack Overflow上找到一个类似的问题:https://stackoverflow.com/questions/59855869/

10-10 14:18
查看更多