使用 np.where 的瓶颈（就计算资源而言，即内存和速度）

Question

在当前示例中，我花了（很多）小时来找到一种对 M 矩阵进行排序的方法，以便它完全对应于目标矩阵。

• 前 2 列用于重组 M
• matrixOrder 指示如何“继续”（几个值很重要）
• 注意必须以不同方式处理的 2 对 [5, 15] 和 [5, 11]
• 在最后阶段，提取第三列

对于大数组（几十万行，甚至几百万行），内存量巨大，这一步时间很消耗（瓶颈）；欢迎任何有关如何改进此类代码的建议。

谢谢

保罗

# -*- coding: utf-8 -*-
"""
import numpy as np

M = np.array([ [ 5  , 15 , 6 ],
               [ 14 , 15 , 14 ],
               [ 5  , 11 , 350 ],
               [ 5  , 11, 352 ],
               [ 5  , 11 , 351 ],
               [ 5  , 11 , 350 ],
               [ 9  , 11 , 351 ],
               [ 9  , 11 , 95 ],
               [ 9  , 11 , 353 ],
               [ 9  , 11 , 354 ],
               [ 28 , 15 , 28 ],
               [ 2  , 8 , 46 ],
               [ 2  , 8 , 353 ],
               [ 2  , 8 , 45 ],
               [ 21 , 15 , 21 ],
               [ 31 , 20 , 355 ],
               [ 31 , 20 , 358 ]])


matrixOrder = np.array([ [14, 15],
                         [2 , 8],
                         [31, 20],
                         [5 , 11],
                         [21, 15],
                         [9, 11],
                         [5, 15],
                         [28, 15] ])
                       
                       
                       
                       
Target = np.array([ [ 14 , 15 , 14 ],
                    [ 2 , 8 , 46 ],
                    [ 2 , 8 , 353 ],
                    [ 2 , 8 , 45 ],
                    [ 31 , 20 , 355 ],
                    [ 31 , 20 , 358 ],
                    [ 5 , 11 , 350 ],
                    [ 5 , 11 , 352 ],
                    [ 5 , 11 , 351 ],
                    [ 5 , 11 , 350 ],
                    [ 21 , 15 , 21 ],
                    [ 9 , 11 , 351 ],
                    [ 9 , 11 , 95 ],
                    [ 9 , 11 , 353 ],
                    [ 9 , 11 , 354 ],
                    [ 5 , 15 , 6 ],
                    [ 28 , 15 , 28 ] ])
                       
                       
                       
                       
index = np.where( (matrixOrder[:, 0].reshape(-1, 1) == M[:, 0].tolist()) &
                  (matrixOrder[:, 1].reshape(-1, 1) == M[:, 1].tolist()) )



T = M[index[1], :]
check = np.array_equal(Target, T)

Answer 1

尝试进行字典查找而不是使用 np.where

类似-

def sort_mat(M, ord):

k = [tuple(r) for r in ord]
d = {k: i for i,k in enumerate(k)}
idx = sorted(range(len(M)), key=lambda x: d.get((M[x,0], M[x,1]), len(k)))
return M[idx]