Question

考虑数组a

np.random.seed([3,1415])
a = np.random.randint(10, size=(5, 4))
a

array([[0, 2, 7, 3],
       [8, 7, 0, 6],
       [8, 6, 0, 2],
       [0, 4, 9, 7],
       [3, 2, 4, 3]])

我可以创建包含排列的b来对每列进行排序。

b = a.argsort(0)
b

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

我可以使用a

对b进行排序

a[b, np.arange(a.shape[1])[None, :]]

array([[0, 2, 0, 2],
       [0, 2, 0, 3],
       [3, 4, 4, 3],
       [8, 6, 7, 6],
       [8, 7, 9, 7]])

这是介绍我正在寻找的输出的初级读物。我想要一个数组b，它具有排序a中相应列的所需排列，同时还考虑了lexsort与另一个数组。

np.random.seed([3,1415])
a = np.random.randint(10, size=(10, 4))
g = np.random.choice(list('abc'), 10)

a

array([[0, 2, 7, 3],
       [8, 7, 0, 6],
       [8, 6, 0, 2],
       [0, 4, 9, 7],
       [3, 2, 4, 3],
       [3, 6, 7, 7],
       [4, 5, 3, 7],
       [5, 9, 8, 7],
       [6, 4, 7, 6],
       [2, 6, 6, 5]])

g

array(['c', 'a', 'c', 'b', 'a', 'a', 'a', 'b', 'c', 'b'], 
      dtype='<U1')

我想生成一个数组b，其中每列是lexsort相应列a的必要排列。而lexsort是首先按g定义的组排序列，然后按a中每列的值排序。

我可以用：

生成结果

r = np.column_stack([np.lexsort([a[:, i], g]) for i in range(a.shape[1])])
r

array([[4, 4, 1, 4],
       [5, 6, 6, 1],
       [6, 5, 4, 5],
       [1, 1, 5, 6],
       [3, 3, 9, 9],
       [9, 9, 7, 3],
       [7, 7, 3, 7],
       [0, 0, 2, 2],
       [8, 8, 0, 0],
       [2, 2, 8, 8]])

我们可以看到这是有效的

g[r]

array([['a', 'a', 'a', 'a'],
       ['a', 'a', 'a', 'a'],
       ['a', 'a', 'a', 'a'],
       ['a', 'a', 'a', 'a'],
       ['b', 'b', 'b', 'b'],
       ['b', 'b', 'b', 'b'],
       ['b', 'b', 'b', 'b'],
       ['c', 'c', 'c', 'c'],
       ['c', 'c', 'c', 'c'],
       ['c', 'c', 'c', 'c']], 
      dtype='<U1')

和

a[r, np.arange(a.shape[1])[None, :]]

array([[3, 2, 0, 3],
       [3, 5, 3, 6],
       [4, 6, 4, 7],
       [8, 7, 7, 7],
       [0, 4, 6, 5],
       [2, 6, 8, 7],
       [5, 9, 9, 7],
       [0, 2, 0, 2],
       [6, 4, 7, 3],
       [8, 6, 7, 6]])

问题

是否可以播放＆＃34;广播＆＃34;使用分组数组g在每个列lexsort中使用？什么是更有效的方法呢？

Answer 1

这是一种方法 -

def app1(a, g):
    m,n = a.shape

    g_idx = np.unique(g, return_inverse=1)[1]
    N = g_idx.max()+1

    g_idx2D = g_idx[:,None] + N*np.arange(n)
    r_out = np.lexsort([a.ravel('F'), g_idx2D.ravel('F')]).reshape(-1,m).T
    r_out -= m*np.arange(n)
    return r_out

我们的想法很简单，我们创建2D整数版g字符串数组的网格，然后通过一个屏障来偏移每一列，这会限制每列中的lexsort搜索

现在，就性能而言，似乎对于大型数据集，lexsort本身就是瓶颈。对于我们的问题，我们只处理两列。因此，我们可以创建自己的自定义lexsort，根据偏移量缩放第二列，偏移量是第一列中数字的最大限制。相同的实现看起来像这样 -

def lexsort_twocols(A, B):
    S = A.max() - A.min() + 1
    return (B*S + A).argsort()

因此，将此结合到我们提出的方法中并优化g_idx2D的创建，我们将有一个像这样的正式函数 -

def proposed_app(a, g):
    m,n = a.shape

    g_idx = np.unique(g, return_inverse=1)[1]
    N = g_idx.max()+1

    g_idx2D = (g_idx + N*np.arange(n)[:,None]).ravel()
    r_out = lexsort_twocols(a.ravel('F'), g_idx2D).reshape(-1,m).T    
    r_out -= m*np.arange(n)
    return r_out

运行时测试

原创方法：

def org_app(a, g):
    return np.column_stack([np.lexsort([a[:, i], g]) for i in range(a.shape[1])])

计时 -

In [763]: a = np.random.randint(10, size=(20, 10000))
     ...: g = np.random.choice(list('abcdefgh'), 20)
     ...: 

In [764]: %timeit org_app(a,g)
10 loops, best of 3: 27.7 ms per loop

In [765]: %timeit app1(a,g)
10 loops, best of 3: 25.4 ms per loop

In [766]: %timeit proposed_app(a,g)
100 loops, best of 3: 5.93 ms per loop

Answer 2

根据Divakar的回答，我只是张贴这个来展示我的衍生作品的好地方。他的lexsort_twocols函数可以完成我们需要的所有功能，并且可以轻松地应用于广播单个维度而不是其他几个维度。我们可以放弃proposed_app中的其他工作，因为我们可以在axis=0函数的argsort中使用lexsort_twocols。

def lexsort2(a, g):
    n, m = a.shape
    f = np.unique(g, return_inverse=1)[1] * (a.max() - a.min() + 1)
    return (f[:, None] + a).argsort(0)

lexsort2(a, g)

array([[5, 5, 1, 1],
       [1, 1, 5, 5],
       [9, 9, 9, 9],
       [0, 0, 2, 2],
       [2, 2, 0, 0],
       [4, 4, 6, 4],
       [6, 6, 4, 6],
       [3, 3, 7, 3],
       [7, 7, 3, 7],
       [8, 8, 8, 8]])

我也想到了这一点......虽然不是那么好，因为我仍然依赖于np.lexsort，正如迪瓦卡指出的那样，可能会很慢。

def lexsort3(a, g):
    n, m = a.shape
    a_ = a.ravel()
    g_ = np.repeat(g, m)
    c_ = np.tile(np.arange(m), n)
    return np.lexsort([c_, a_, g_]).reshape(n, m) // m

lexsort3(a, g)

array([[5, 5, 1, 1],
       [1, 1, 5, 5],
       [9, 9, 9, 9],
       [0, 0, 2, 2],
       [2, 2, 0, 0],
       [4, 4, 6, 4],
       [6, 6, 4, 6],
       [3, 3, 7, 3],
       [7, 7, 3, 7],
       [8, 8, 8, 8]])

假设我的第一个概念是lexsort1

def lexsort1(a, g):
    return np.column_stack(
        [np.lexsort([a[:, i], g]) for i in range(a.shape[1])]
    )

from timeit import timeit
import pandas as pd

results = pd.DataFrame(
    index=[100, 300, 1000, 3000, 10000, 30000, 100000, 300000, 1000000],
    columns=['lexsort1', 'lexsort2', 'lexsort3']
)

for i in results.index:
    a = np.random.randint(100, size=(i, 4))
    g = np.random.choice(list('abcdefghijklmn'), i)
    for f in results.columns:
        results.set_value(
            i, f,
            timeit('{}(a, g)'.format(f), 'from __main__ import a, g, {}'.format(f))
        )

results.plot()

再次感谢@Divakar。请提出他的回答!!!

针对lexsort的2D数组广播1D数组：当考虑另一个向量时，用于独立地对每列进行排序的排列

2 个答案: