从 Pandas 数据帧中删除'dominated'行(所有值都小于任何其他行的值的行)

Question

编辑:更改示例df，以便更清晰

我有一个数据框架，类似于下面给出的数据框架(除了真正的数据框架有几千行和几千列，并且值是浮点数):

df = pd.DataFrame([[6,5,4,3,8], [6,5,4,3,6], [1,1,3,9,5], [0,1,2,7,4], [2, 0, 0, 4, 0])
0   1   2   3   4
0   6   5   4   3   8
1   6   5   4   3   6
2   1   1   3   9   5
3   0   1   2   7   4
4   2   0   0   4   0

从这个数据框中，我想删除所有值小于或等于任何其他行的所有行。对于这个简单的示例，应该删除第1行和第3行(分别由第0行和第2行'主导'):

filtered df:
0   1   2   3   4
0   6   5   4   3   8
2   1   1   3   9   5
4   2   0   0   4   0

如果该方法可以考虑到浮点错误，那就更好了，因为我的实际数据帧包含浮点数(即，而不是删除所有值都较低/相等的行，值不应该低于少量(例如0.0001)。

我解决这个问题的最初想法如下:

1. 选择第一行
2. 使用列表推导式将其他行与它进行比较(见下文)
3. 删除所有返回True的行
4. 重复下一行

列表推导式代码:

selected_row = df.loc[0
[(df.loc[r]<=selected_row).all() and (df.loc[r]<selected_row).any() for r in range(len(df))]
[False, True, False, False, False]

然而，这似乎很难有效。如果能就如何(有效)解决这个问题提出任何建议，我将不胜感激。

Answer 1

我们可以试试broadcasting:

import pandas as pd
df = pd.DataFrame([
[6, 5, 4, 3, 8], [6, 5, 4, 3, 6], [1, 1, 3, 9, 5],
[0, 1, 2, 7, 4], [2, 0, 0, 4, 0]
])
# Need to ensure only one of each row present since comparing to 1
# there needs to be one and only one of each row
df = df.drop_duplicates()
# Broadcasted comparison explanation below
cmp = (df.values[:, None] <= df.values).all(axis=2).sum(axis=1) == 1
# Filter using the results from the comparison
df = df[cmp]

df:

0  1  2  3  4
0  6  5  4  3  8
2  1  1  3  9  5
4  2  0  0  4  0

---

直觉:

在DataFrame上广播比较操作:

(df.values[:, None] <= df.values)

[[[ True  True  True  True  True]
[ True  True  True  True False]
[False False False  True False]
[False False False  True False]
[False False False  True False]]  # df vs [6 5 4 3 8]
[[ True  True  True  True  True]
[ True  True  True  True  True]
[False False False  True False]
[False False False  True False]
[False False False  True False]]  # df vs [6 5 4 3 6]
[[ True  True  True False  True]
[ True  True  True False  True]
[ True  True  True  True  True]
[False  True False False False]
[ True False False False False]]  # df vs [1 1 3 9 5]
[[ True  True  True False  True]
[ True  True  True False  True]
[ True  True  True  True  True]
[ True  True  True  True  True]
[ True False False False False]]  # df vs [0 1 2 7 4]
[[ True  True  True False  True]
[ True  True  True False  True]
[False  True  True  True  True]
[False  True  True  True  True]
[ True  True  True  True  True]]]  # df vs [2 0 0 4 0]

然后我们可以在axis=2上检查all:

(df.values[:, None] <= df.values).all(axis=2)

[[ True False False False False]   # Rows le [6 5 4 3 8]
[ True  True False False False]   # Rows le [6 5 4 3 6]
[False False  True False False]   # Rows le [1 1 3 9 5]
[False False  True  True False]   # Rows le [0 1 2 7 4]
[False False False False  True]]  # Rows le [2 0 0 4 0]

然后我们可以使用sum来计算小于等于的行数:

(df.values[:, None] <= df.values).all(axis=2).sum(axis=1)

[1 2 1 2 1]

只有1行小于或等于(self match only)的行是要保留的行。因为我们使用drop_duplicates，所以数据框中不会有重复的内容，所以True的值只有自匹配和小于或等于:

的值。

(df.values[:, None] <= df.values).all(axis=2).sum(axis=1) == 1

[ True False  True False  True]

这将成为DataFrame的过滤器:

df = df[[True, False, True, False, True]]

df:

0  1  2  3  4
0  6  5  4  3  8
2  1  1  3  9  5
4  2  0  0  4  0

Answer 2

优势行的预期比例是多少?您将处理的数据集的大小和可用内存是多少?

虽然像广播方法这样的解决方案非常聪明和高效(矢量化)，但它将无法处理大数据帧，因为广播的大小将迅速超出内存限制(100,000×10输入数组将而不是)。

这里是另一种避免测试所有组合并在内存中一次计算所有内容的方法。由于循环，它的速度较慢，但它应该能够处理更大的数组。当被支配行的比例增加时，它也会运行得更快。

总之，它将数据集与第一行进行比较，删除占主导地位的行，将第一行移到末尾，然后重新开始，直到完成一个完整的循环。如果行随着时间的推移被删除，比较的次数会减少。

def get_dominants_loop(df):
from tqdm import tqdm
seen = [] # keep track of tested rows
idx = df.index # initial index
for i in tqdm(range(len(df)+1)):
x = idx[0]
if x in seen:   # done a full loop
return df.loc[idx]
seen.append(idx[0])
# check which rows are dominated and drop them from the index
idx = (df.loc[idx]-df.loc[x]).le(0).all(axis=1)
# put tested row at the end
idx = list(idx[~idx].index)+[x]

删除主导行:

df = get_dominants_loop(df)

NB。我使用tqdm在这里有一个进度条。代码不需要运行

广播方法无法运行时的快速基准测试:在大多数行未被支配的情况下，对100k×10进行2min;

Answer 3

你可以试试:

df[df.shift(1)[0] >= df[1][0]]

<表类>01234tbody><<tr>165436211395

你可以试试这样做:

# Cartesian product
x = np.tile(df, df.shape[0]).reshape(-1, df.shape[1])
y = np.tile(df.T, df.shape[0]).T
# Remove same rows
#dups = np.all(x == y, axis=1)
#x = x[~dups]
#y = y[~dups]
x = np.delete(x, slice(None, None, df.shape[0]+1), axis=0)
y = np.delete(y, slice(None, None, df.shape[0]+1), axis=0)
# Keep dominant rows
m = x[np.all(x >= y, axis=1)]

>>> m
array([[6, 5, 4, 3, 8],
[1, 1, 3, 9, 5]])

# Before remove duplicates
# df1 = pd.DataFrame({'x': x.tolist(), 'y': y.tolist()})
>>> df1
x                y
0   [6, 5, 4, 3, 8]  [6, 5, 4, 3, 8]  # dup
1   [6, 5, 4, 3, 8]  [6, 5, 4, 3, 6]  # DOMINANT
2   [6, 5, 4, 3, 8]  [1, 1, 3, 9, 5]
3   [6, 5, 4, 3, 8]  [0, 1, 2, 7, 4]
4   [6, 5, 4, 3, 6]  [6, 5, 4, 3, 8]
5   [6, 5, 4, 3, 6]  [6, 5, 4, 3, 6]  # dup
6   [6, 5, 4, 3, 6]  [1, 1, 3, 9, 5]
7   [6, 5, 4, 3, 6]  [0, 1, 2, 7, 4]
8   [1, 1, 3, 9, 5]  [6, 5, 4, 3, 8]
9   [1, 1, 3, 9, 5]  [6, 5, 4, 3, 6]
10  [1, 1, 3, 9, 5]  [1, 1, 3, 9, 5]  # dup
11  [1, 1, 3, 9, 5]  [0, 1, 2, 7, 4]  # DOMINANT
12  [0, 1, 2, 7, 4]  [6, 5, 4, 3, 8]
13  [0, 1, 2, 7, 4]  [6, 5, 4, 3, 6]
14  [0, 1, 2, 7, 4]  [1, 1, 3, 9, 5]
15  [0, 1, 2, 7, 4]  [0, 1, 2, 7, 4]  # dup

使用df.apply()

m = (pd.concat(df.apply(lambda x: df.ge(x,axis=1),axis=1).tolist(),keys = df.index)
.all(axis=1)
.groupby(level=0)
.sum()
.eq(1))
ndf = df.loc[m]

输出:

0  1  2  3  4
0  6  5  4  3  8
2  1  1  3  9  5
4  2  0  0  4  0