假设我有一个pandas数据帧(从csv文件加载)具有此结构(var和err列的数量不是固定的,并且随文件而异):

var_0; var_1; var_2;
32;    9;     41;
47;    22;    41;
15;    12;    32;
3;     4;     4;
10;    9;     41;
43;    21;    45;
32;    14;    32;
51;    20;    40;

为了这个问题,我们放弃err_ds_j和err_mean列。
我必须将每一行的值与其他行的值进行自动比较;例如:我必须将第一行与第二行进行比较,然后与第三行进行比较,然后与第四行进行比较,依此类推,然后我必须将第二行与第一行进行比较,然后与第三行进行比较,对于数据帧的其余部分,以此类推。
深入探讨这个问题,我想看看对于每两行,其中一行的所有“var_I”值是否都高于或等于另一行的相应值。如果满足此条件,则具有更高值的行称为主导行,我将在另一个数据帧中添加具有以下结构的行:
SET_A; SET_B; DOMINANT_SET
0;     1;     B
...

其中SET_A和SET_B值是csv数据帧中的索引,而支配集告诉我这两个值中的哪一个是支配集(或者如果没有,它只是被指定为“无”)。
我发现第三列很有用,因为它可以帮助我避免以相反的方式比较已经比较过的行(例如:比较第1行和第0行是无用的,因为我之前已经比较过0和1)。
因此,对于csv文件,生成的输出应该是(实际上是,使用我的代码):
   SET_A SET_B DOMINANT_SET
1      0     1            B
2      0     2         none
3      0     3            A
4      0     4            A
5      0     5            B
6      0     6         none
7      0     7         none
8      1     2            A
9      1     3            A
10     1     4            A
11     1     5         none
12     1     6            A
13     1     7         none
14     2     3            A
15     2     4         none
16     2     5            B
17     2     6            B
18     2     7            B
19     3     4            B
20     3     5            B
21     3     6            B
22     3     7            B
23     4     5            B
24     4     6         none
25     4     7         none
26     5     6            A
27     5     7         none
28     6     7            B

我已经为这个特殊的问题编写了所有的代码,对于一些测试数据集(从一个实际的数据集中抽取100行数据)来说,它工作得很好。
以下是相关代码的片段:
import numpy as np
import pandas as pd

def couple_already_tested(index1, index2, dataframe):
    return (((dataframe['SET_A'] == index1) & (dataframe['SET_B'] == index2)).any()) | (((dataframe['SET_A'] == index2) & (dataframe['SET_B'] == index1)).any())

def check_dominance(set_a, set_b, index_i, index_j, dataframe):
    length = dataframe.shape[0]
    if np.all(set_a >= set_b):
        print("FOUND DOMINANT CONFIGURATION A > B")
        dataframe.loc[length+1] = [index_i,index_j,'A']
    elif np.all(set_b >= set_a):
        print("FOUND DOMINANT CONFIGURATION B > A")
        dataframe.loc[length+1] = [index_i,index_j,'B']
    else:
        dataframe.loc[length+1] = [index_i,index_j,'none']

df = pd.read_csv('test.csv', sep=';')
dom_table_df = pd.DataFrame(columns=['SET_A','SET_B','DOMINANT_SET'])
df_length = df.shape[0]
var_num = df.shape[1]-1

a = None
b = None

for i in range(0, df_length):
    a = df.iloc[i, 0:var_num].values
    for j in range(0, df_length):
        if j == i:
            continue
        b = df.iloc[j, 0:var_num].values
        if couple_already_tested(i,j,dom_table_df):
            print("WARNING: configuration", i, j, "already compared, skipping")
        else:
            print("Comparing configuration at row", i, "with configuration at row", j)
            check_dominance(a, b, i, j, dom_table_df)

print(dom_table_df)

问题是,由于对python和panda都不太精通(我已经学习了大约一个半月),这段代码当然非常慢(对于1000到10000行的数据集),因为我在算法中使用了迭代。我知道我可以使用一种称为矢量化的方法,但在阅读相关内容时,我并不完全确定这对我的用例有好处。
那么,我怎样才能加快计算速度呢?

最佳答案

另一个加速可以通过将.iloc[].values.loc[]替换为.values[]来实现,但是使用.loc[]我们必须调整下标,因为.values采用的是基于零的下标,这与基于1的dom_table_df.index不同。

dom_table_df = pd.DataFrame(index=np.arange(1, 1+(df_length**2-df_length)/2).astype('i'),
                            columns=['SET_A', 'SET_B', 'DOMINANT_SET'])
length = 0  # counter of already filled rows
for i in range(0, df_length):
    a = df.values[i, 0:var_num]
    for j in range(i+1, df_length): # we can skip the range from 0 to i
        b = df.values[j, 0:var_num]
        #print("Comparing configuration at row", i, "with configuration at row", j)
        if np.all(a >= b):
            #print("FOUND DOMINANT CONFIGURATION A > B")
            dom_table_df.values[length] = [i, j, 'A']
        elif np.all(b >= a):
            #print("FOUND DOMINANT CONFIGURATION B > A")
            dom_table_df.values[length] = [i, j, 'B']
        else:
            dom_table_df.values[length] = [i, j, 'none']
        length += 1

10-07 19:50
查看更多