从numpy的阵列获取的非重复的行

Question

比方说，我有以下形式的numpy的阵列

x = np.array([[2, 5], 
       [3, 4], 
       [1, 3], 
       [2, 5], 
       [4, 5], 
       [1, 3], 
       [1, 4], 
       [3, 4]]) 

我想从这个得到的是只包含其中不重复的行，即数组，我期望从这个例子

array([[4, 5], 
     [1, 4]]) 

我正在寻找一种方法，是相当快速和规模很好。我能想到做到这一点的唯一方法是

1. 首先找到该组唯一的行中x，作为一个新的阵列y。
2. 创建，其具有从x除去y那些个体元素的数组z，从而z是在x复制的行的列表。
3. 做一个x和z之间的差异。

虽然这似乎非常低效。任何人都有更好的方法？

如果它很重要，我保证我的每一行都会从最小排序到最大排列，因此您永远不会有一行是[5, 2]或[3, 1]。

Answer 1

方法＃1

下面是基于np.unique并考虑每行作为索引元组的效率（假定输入数组的整数）的方法 -

# Consider each row as indexing tuple & get linear indexing value    
lid = np.ravel_multi_index(x.T,x.max(0)+1) 

# Get counts and unique indices 
_,idx,count = np.unique(lid,return_index=True,return_counts=True) 

# See which counts are exactly 1 and select the corresponding unique indices 
# and thus the correspnding rows from input as the final output 
out = x[idx[count==1]] 

注：如果有一个巨大的列数输入数组，你可能希望得到的线性指数lid手动，以便您可以使用np.cumprod，像这样 -

lid = x.dot(np.append(1,(x.max(0)+1)[::-1][:-1].cumprod())[::-1]) 

方法2

下面是一个可供选择的一个可卸载计数任务np.bincount，这可能是更有效地用于这种目的 -

# Consider each row as indexing tuple & get linear indexing value    
lid = np.ravel_multi_index(x.T,x.max(0)+1) 

# Get unique indices and tagged indices for all elements 
_,unq_idx,tag_idx = np.unique(lid,return_index=True,return_inverse=True) 

# Use the tagged indices to count and look for count==1 and repeat like before 
out = x[unq_idx[np.bincount(tag_idx)==1]] 

方法3

下面是使用convolution赶上了不同的方法这样的模式。让内联评论帮助理解底层的想法。这里去 -

# Consider each row as indexing tuple & get linear indexing value    
lid = np.ravel_multi_index(x.T,x.max(0)+1) 

# Store sorted indices for lid 
sidx = lid.argsort() 

# Append 1s at either ends of sorted and differentiated version of lid 
mask = np.hstack((True,np.diff(lid[sidx])!=0,True)) 

# Perform convolution on it. Thus non duplicate elements would have 
# consecutive two True elements, which could be caught with convolution 
# kernel of [1,1]. Get the corresponding mask. 
# Index into sorted indices with it for final output 
out = x[sidx[(np.convolve(mask,[1,1])>1)[1:-1]]] 

Answer 2

这里是一个pandas的方法：

pd.DataFrame(x.T).T.drop_duplicates(keep=False).as_matrix() 

#array([[4, 5], 
#  [1, 4]]) 

Answer 3

一种可能性（需要用于包含大量元件的阵列大量的存储器）是通过首先创建一个布尔掩码，其中行等于：

b = np.sum(x[:, None, :] == x, axis=2) 
b 
array([[2, 0, 0, 2, 1, 0, 0, 0], 
     [0, 2, 0, 0, 0, 0, 1, 2], 
     [0, 0, 2, 0, 0, 2, 1, 0], 
     [2, 0, 0, 2, 1, 0, 0, 0], 
     [1, 0, 0, 1, 2, 0, 0, 0], 
     [0, 0, 2, 0, 0, 2, 1, 0], 
     [0, 1, 1, 0, 0, 1, 2, 1], 
     [0, 2, 0, 0, 0, 0, 1, 2]]) 

该数组显示哪一行具有多少个与另一行相同的元素。对角线是比较自身的行，以便需要设置为零：

np.fill_diagonal(b, 0) 
b 
array([[0, 0, 0, 2, 1, 0, 0, 0], 
     [0, 0, 0, 0, 0, 0, 1, 2], 
     [0, 0, 0, 0, 0, 2, 1, 0], 
     [2, 0, 0, 0, 1, 0, 0, 0], 
     [1, 0, 0, 1, 0, 0, 0, 0], 
     [0, 0, 2, 0, 0, 0, 1, 0], 
     [0, 1, 1, 0, 0, 1, 0, 1], 
     [0, 2, 0, 0, 0, 0, 1, 0]]) 

现在让我们来看看什么是每一行的最大：

c = np.max(b, axis=0) 
c 
array([2, 2, 2, 2, 1, 2, 1, 2]) 

，然后我们需要找到该值，其中这个最大是!=2和索引这些从原始数组：

x[np.where([c != 2])[1]] 
array([[4, 5], 
     [1, 4]]) 

Answer 4

对于completness，又见项目78 http://www.labri.fr/perso/nrougier/teaching/numpy.100/

Answer 5

这个问题可以有效地利用numpy_indexed包来解决（免责声明：我是它的作者）：

import numpy_indexed as npi 
x[npi.multiplicity(x) == 1] 

不只有这个解决方案非常易读，它也非常高效，并且可以与任意数量的列或dtypes一起使用。