根据某些列在2d数组中重新排列条目

Question

假设我有一个M x N numpy数组，其中每一行代表一个数据条目，前N-1列代表不同的参数（独立变量），最后一列代表我感兴趣的数据（因变量）。

重新排列不同的行，以使它们按参数排序的最优雅的方法是什么？

示例：

# original
1                        0.1                      20                       0.30000000000000004      0.07819319717404902     
1                        1                        10                       0.2                      0.07550707294415204      
2                        0.1                      0                        0                        0.07078663749666488      
2                        0.1                      0                        0.1                      0.07284943819285646      
1                        1                        15                       0.4                      0.08047398714777267      
1                        1                        15                       0.5                      0.0820402298018169      
1                        1                        15                       0.30000000000000004      0.07819319717406738     
1                        1                        20                       0                        0.07079655446543297      
1                        1                        20                       0.1                      0.07286704639139795      
1                        1                        5                        0.4                       0.086521872154



# desired:
1                        0.1                      20                       0.30000000000000004      0.07819319717404902     
1                        1                        5                        0.4                       0.086521872154
1                        1                        10                       0.2                      0.07550707294415204      
1                        1                        15                       0.30000000000000004      0.07819319717406738
1                        1                        15                       0.4                      0.08047398714777267      
1                        1                        15                       0.5                      0.0820402298018169      
1                        1                        20                       0                        0.07079655446543297      
1                        1                        20                       0.1                      0.07286704639139795      
2                        0.1                      0                        0                        0.07078663749666488      
2                        0.1                      0                        0.1                      0.07284943819285646 

我希望按照每个参数中最小的顺序对数据进行排序。

Answer 1

如果要使用np.argsort在单个列上对ndarray排序

给出以下矩阵：

m = np.array([[5., 0.1, 3.4],
           [7., 0.3, 6.8],
           [3., 0.2, 5.6]])

此代码根据第0列对矩阵m进行排序：

m[m[:,0].argsort(kind='mergesort')]

结果：

array([[3. , 0.2, 5.6],
       [5. , 0.1, 3.4],
       [7. , 0.3, 6.8]])

如果要使用np.lexsort在多个列上对ndarray排序

给出：

a = np.array([[1,20,200], [1,30,100], [1,10,300]])
array([[  1,  20, 200],
       [  1,  30, 100],
       [  1,  10, 300]])

按第1列和第0列排序：

a[np.lexsort((a[:,0],a[:,1]))]
# output:
array([[  1,  10, 300],
       [  1,  20, 200],
       [  1,  30, 100]])

注意：最后一个右列（如果键是2D数组，则为行）是主要的排序键。

按所有列排序（从右开始）：

a[np.lexsort((a[:,0], a[:,1],a[:,2]))]
# output:
array([[  1,  30, 100],
       [  1,  20, 200],
       [  1,  10, 300]])

或等效地，按所有列排序，而无需手动指定列（遵循从右开始的矩阵中列的顺序）：

a[np.lexsort(list(map(tuple,np.column_stack(a))))]
# output:
array([[  1,  30, 100],
       [  1,  20, 200],
       [  1,  10, 300]])

其他选择：对于您的特定问题，熊猫是个好主意吗？

另一个选择是切换到熊猫。这是可行的，但速度要慢几个数量级。以下是执行时间的一些测试：

Benchmarck数据：

a = np.array([[1,20,200]*1000, [1,30,100]*1000, [1,10,300]*1000])

熊猫版本：

%%timeit
pd.DataFrame(a).sort_values(list(range(a.shape[1]))).values
# 3.66 s ± 110 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

数字版本：

%%timeit
a[np.lexsort((a[:,0], a[:,1],a[:,2]))]
# 39.6 µs ± 12.1 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

如您所见，您从numpy的微秒变为基于熊猫的版本的秒（慢了大约一百万倍）。
选择是您的：）

Answer 2

您可以使用lexsort：

original[np.lexsort(np.rot90(original))]

Answer 3

使用pandas的{​​{1}}的一个选项：

sort_values

输出：

pd.DataFrame(a).sort_values(list(range(a.shape[1]))).values