Python 3：删除表中的重叠

Question

我有一个表格（程序的简化输出），我需要对其进行过滤：

id   hit from   to value
A   hit1    56  102 0.00085
B   hit2    89  275 0.00034
B   hit3    240 349 0.00034
C   hit4    332 480 3.40E-15
D   hit5    291 512 3.80E-24
D   hit6    287 313 0.00098
D   hit7    381 426 0.00098
D   hit8    287 316 0.0029
D   hit9    373 422 0.0029
D   hit10   514 600 0.0021

对于每个 id，df 应按 from 排序，如果有重叠的命中，则保留 value 较低的那个。

到目前为止，这是我的代码，它首先由from 开始，然后由value 开始：

import pandas
df = pandas.read_csv("table", sep='\s+', names=["id", "hit", "from", "to", "value"])
df.sort_values(['from', "value"]).groupby('id')

但是我如何检查重叠（from 到 to）并删除具有更高分数的重叠？

这是我的预期输出：

id   hit from   to valu
A   hit1    56  102 0.00085
C   hit4    332 480 3.40E-15
D   hit5    291 512 3.80E-24
D   hit10   514 600 0.0021

请注意，id B 有两个相同值的重叠命中，因此两个条目都将被踢出。

Answer 1

如果你不介意你的代码中有多行，我猜这样的东西应该可以工作......（这里是python新手......）source

df.sort_values(['from', "value"]).groupby('id')
df.drop_duplicates(subset=['id', 'value'], keep=False, inplace=True)

"keep" 参数设置为 false，因为您根本不想要重复的行。

这会导致：

  id    hit from   to     value
0  A   hit1   56  102   0.00085
3  C   hit4  332  480  3.40E-15
4  D   hit5  291  512  3.80E-24
9  D  hit10  514  600    0.0021

并摆脱凌乱的索引列：

df.reset_index(drop=True, inplace=True)

这会导致：

  id    hit from   to     value
0  A   hit1   56  102   0.00085
1  C   hit4  332  480  3.40E-15
2  D   hit5  291  512  3.80E-24
3  D  hit10  514  600    0.0021

PS：这是我第一次回答，所以请温柔。而且，我还在学习英语。

Answer 2

首先我们引入一个独特的ID并使用pd.Interval：

df['ID'] = range(df.shape[0])
df['Interval'] = df.apply(lambda x: pd.Interval(x['from'], x['to'], closed='both'), axis=1)

在这之后我们加入 df 并计算重叠部分：

columns = ['id', 'Interval', 'ID']
connected = df[columns].merge(df[columns], on='id')
connected['Overlap'] = connected.apply(lambda x: x['Interval_x'].overlaps(x['Interval_y']), axis=1) 
connected = connected.loc[connected['Overlap'] == True, ['id', 'ID_x', 'ID_y']]

现在我们知道哪些 ID 重叠，但我们不知道它们中的哪些构建了连接组件。一般来说，这不能通过像重新编码这样的简单算法来完成，但graph theory 有点帮助。所以我们建立一个图

graph = connected.groupby(['id', 'ID_x']).agg(list)

并通过depth first search计算连通分量

def connections(graph, id):
    def dict_to_df(d):
        df = pd.DataFrame(data=[d.keys(), d.values()], index=['ID', 'Subgraph']).T
        df['id'] = id
        return df[['id', 'Subgraph', 'ID']]

    def dfs(node, num):
        visited[node] = num
        for _node in graph.loc[node].iloc[0]:
            if _node not in visited:
                dfs(_node, num)

    visited = {}
    graph = graph.loc[id]
    for (num, node) in enumerate(graph.index):
        if node not in visited:
            dfs(node, num)

    return dict_to_df(visited)

dfs = []
for id in graph.index.get_level_values(0).unique():
    dfs.append(connections(graph, id))

conns = pd.concat(dfs)

conns 保存连接的组件，我们可以将它们放在一起：

data = df.merge(conns[['Subgraph', 'ID']], on=['ID'])

我们的最后一个任务是选择我们想要保留的行：

def select_min(x):
    m = x['value'].min()
    if len(x) > 1 and (x['value'] == m).all():
        return -1
    else:
        return x['value'].idxmin()

selected = data.groupby(['id', 'Subgraph'])['value', 'ID'].apply(select_min)
selected = selected[selected >= 0]

现在我们完成了：

print(df.loc[df.ID.isin(selected), :].drop(columns=['ID', 'Interval']))
  id    hit  from   to         value
0  A   hit1    56  102  8.500000e-04
3  C   hit4   332  480  3.400000e-15
4  D   hit5   291  512  3.800000e-24
9  D  hit10   514  600  2.100000e-03

Answer 3

df = pd.DataFrame({'id': ['A', 'B', 'B', 'C', 'D', 'D' ,'D', 'D', 'D', 'D', 'D'],
                  'hit': ['hit1', 'hit2', 'hit3','hit4', 'hit5','hit6', 'hit7','hit8', 'hit9','hit10', 'hit11'],
                  'from': [56,89,240,332,291,287,381,287,373,514, 599],
                  'to':[102,275,349,480,512,313,426,316,422,600, 602],
                  'value': [0.00085,0.00034,0.00034,3.40E-15,3.80E-24,0.00098,0.00098,0.0029,0.0029,0.0021, 0.002]})

overlapMask =  df.sort_values(by = 'from')\
                 .groupby('id')\
                 .apply(lambda x: np.where(x['from'] < x['to'].shift(), 0 , 1).cumsum())\
                 .reset_index()

df['Mask'] = np.concatenate((overlapMask[0].values))


df.drop_duplicates(subset = ['id','value'], keep = False, inplace = True)


df.sort_values(by = 'value')\
  .groupby(['id', 'Mask'])\
  .head(1)\
  .reset_index()\
  .drop(['Mask', 'index'],axis = 1)\
  .sort_values(by = 'id')


    id  hit    from  to    value
2   A   hit1    56  102 8.500000e-04
1   C   hit4    332 480 3.400000e-15
0   D   hit5    291 512 3.800000e-24
3   D   hit11   599 602 2.000000e-03

所以我的解决方案使用掩码来检查重叠。通过对'from'值进行排序，并检查下一个'from'值是否小于前一个'to'值。 np.inf 只是为了确保分组中的第一个值始终为 0。

然后，我们在 df 中将掩码设为自己的列。然后我们按我们需要的所有内容进行分组，删除所有重复项，重置索引，最后删除我们的掩码。

Answer 4

如果你排序 id == 'D'

    id  hit from    to  value
5   D   hit6    287 313 9.800000e-04
7   D   hit8    287 316 2.900000e-03
4   D   hit5    291 512 3.800000e-24
8   D   hit9    373 422 2.900000e-03
6   D   hit7    381 426 9.800000e-04
9   D   hit10   514 600 2.100000e-03

重叠将是：

• 命中 6、8 和 5 = 保持 5 bc 最低值

• 命中 9 和 7 = kepp 7

• 打10是单守吗？

Answer 5

如果您按组进行，然后逐行执行，似乎实现起来相当简单。pandas 中似乎没有一种方法可以编写一个以有效方式一次对多行和多列进行操作的函数。

def strip(group):
    non_overlapping=[]
    overlapping = [list(group.itertuples())[0]]
    end = list(group.itertuples())[0].to
    for row in list(group.itertuples())[1:]:
        if row[3]<=end:
            overlapping.append(row)
            if row.to > end:
                end = row.to
        else:
            non_overlapping.append(reduce_overlap(overlapping))
            overlapping=[row]
    non_overlapping.append(reduce_overlap(overlapping))
    return non_overlapping

搜索算法非常简单，您有一组排序的非空行，它们都具有相同的 ID。你去第一个元素并结束。在此之前开始的所有后续行都是重叠的，如果它们在我们将它们结束之后结束，我们将其作为新的结束值。

def reduce_overlap(overlapping):
    overlapping= sorted(overlapping,key=lambda x: x.value)
    if len(overlapping)==1 or overlapping[0].value != overlapping[1].value:
        return overlapping[0]
    else:
        return []

为了找到要返回的值，我们按不返回任何值的值进行排序，如果碰巧它们是两个相同的值。

编辑： 这是将其应用于我尚未测试的整个数据框的函数。

def nonoverlapping(df):
  return df.Dataframe.from_records([strip(group) for name,group in df.sort_values(['from', "value"]).groupby('id')])