Je dois comparer les données de chaque ligne d'un Pandas DataFrame avec les données du reste des lignes, existe-t-il un moyen d'accélérer le calcul?

Disons que j'ai un pandas DataFrame (chargé à partir d'un fichier csv) avec cette structure (le nombre de colonnes var et err n'est pas fixe et varie d'un fichier à l'autre):

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)

Supprimons les colonnes err_ds_j et err_mean pour le bien de cette question. Je dois effectuer une comparaison automatique des valeurs de chaque ligne, avec les valeurs des autres lignes; à titre d'exemple: je dois comparer la première ligne avec la deuxième ligne, puis avec la troisième, puis avec la quatrième, et ainsi de suite, puis je dois prendre la deuxième ligne et la comparer avec la première, puis avec la troisième un, et ainsi de suite pour le reste du DataFrame.

Pour approfondir le problème, je veux voir si pour chaque couple de lignes, toutes les valeurs "var_i" de l'une d'entre elles sont supérieures ou égales à les valeurs correspondantes de l'autre ligne. Si cela est satisfait, la ligne avec les valeurs les plus élevées est appelée DOMINANT, et j'ajoute une ligne dans un autre DataFrame, avec cette structure:

   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

Où les valeurs SET_A et SET_B sont des indices de le csv DataFrame, et DOMINANT_SET me dit lequel des deux est l'ensemble dominant (ou s'il n'y en a pas, il est simplement assigné à "aucun"). J'ai trouvé la troisième colonne utile car elle m'aide à éviter la comparaison des lignes que j'ai déjà comparées de manière opposée (par exemple: comparer la ligne 1 avec la ligne 0 est inutile, car j'ai déjà comparé 0 et 1 précédemment).

Donc, pour ce fichier csv, la sortie produite devrait être (et est en fait, avec mon code):

SET_A; SET_B; DOMINANT_SET
0;     1;     B
...

J'ai déjà tout écrit du code pour ce problème particulier, et cela fonctionne très bien avec certains ensembles de données de test (100 lignes échantillonnées à partir d'un ensemble de données réel).

Voici un extrait du code pertinent:

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;

Le problème est que, n'étant pas aussi compétent en python et en pandas (je les apprends depuis environ un mois et demi), ce code est bien sûr terriblement lent (pour les ensembles de données avec, comme , 1000 à 10000 lignes) car j'utilise des itérations dans mon algorithme. Je sais que je peux utiliser quelque chose appelé vectorisation, mais en lisant à ce sujet, je ne suis pas tout à fait sûr que ce soit bon pour mon cas d'utilisation.

Alors, comment pourrais-je accélérer les calculs?

p >