Les pandas iterrows ont-ils des problèmes de performances?

J'ai remarqué de très mauvaises performances lors de l'utilisation d'iterrows de pandas.

Est-ce quelque chose que les autres vivent? Est-ce spécifique à iterrows et cette fonction doit-elle être évitée pour les données d'une certaine taille (je travaille avec 2-3 millions de lignes)?

Cette discussion sur GitHub m'a amené à croire que cela est causé lors du mélange de dtypes dans le dataframe, mais l'exemple simple ci-dessous montre qu'il existe même lorsque vous utilisez un dtype (float64). Cela prend 36 secondes sur ma machine:

import pandas as pd
import numpy as np
import time

s1 = np.random.randn(2000000)
s2 = np.random.randn(2000000)
dfa = pd.DataFrame({'s1': s1, 's2': s2})

start = time.time()
i=0
for rowindex, row in dfa.iterrows():
    i+=1
end = time.time()
print end - start

Pourquoi les opérations vectorisées comme s'appliquent-elles tellement plus rapidement? J'imagine qu'il doit y avoir une itération ligne par ligne là aussi.

Je ne peux pas comprendre comment ne pas utiliser iterrows dans mon cas (je vais le garder pour une question future). Par conséquent, j'apprécierais de savoir si vous avez toujours pu éviter cette itération. Je fais des calculs basés sur des données dans des dataframes séparés. Je vous remercie!

--- Edit: une version simplifiée de ce que je veux exécuter a été ajoutée ci-dessous ---

import pandas as pd
import numpy as np

#%% Create the original tables
t1 = {'letter':['a','b'],
      'number1':[50,-10]}

t2 = {'letter':['a','a','b','b'],
      'number2':[0.2,0.5,0.1,0.4]}

table1 = pd.DataFrame(t1)
table2 = pd.DataFrame(t2)

#%% Create the body of the new table
table3 = pd.DataFrame(np.nan, columns=['letter','number2'], index=[0])

#%% Iterate through filtering relevant data, optimizing, returning info
for row_index, row in table1.iterrows():   
    t2info = table2[table2.letter == row['letter']].reset_index()
    table3.ix[row_index,] = optimize(t2info,row['number1'])

#%% Define optimization
def optimize(t2info, t1info):
    calculation = []
    for index, r in t2info.iterrows():
        calculation.append(r['number2']*t1info)
    maxrow = calculation.index(max(calculation))
    return t2info.ix[maxrow]

Généralement, iterrowsne doit être utilisé que dans des cas très, très spécifiques. Voici l'ordre de priorité général pour l'exécution de diverses opérations:

1) vectorization
2) using a custom cython routine
3) apply
    a) reductions that can be performed in cython
    b) iteration in python space
4) itertuples
5) iterrows
6) updating an empty frame (e.g. using loc one-row-at-a-time)

L'utilisation d'une routine Cython personnalisée est généralement trop compliquée, alors sautons cela pour l'instant.

1) La vectorisation est TOUJOURS, TOUJOURS le premier et le meilleur choix. Cependant, il existe un petit ensemble de cas (impliquant généralement une récurrence) qui ne peuvent pas être vectorisés de manière évidente. De plus, sur une petite échelle DataFrame, il peut être plus rapide d'utiliser d'autres méthodes.

3) peut apply généralement être géré par un itérateur dans l'espace Cython. Ceci est géré en interne par les pandas, bien que cela dépende de ce qui se passe à l'intérieur duapply expression. Par exemple, df.apply(lambda x: np.sum(x))sera exécuté assez rapidement, mais bien sûr, df.sum(1)c'est encore mieux. Cependant, quelque chose comme df.apply(lambda x: x['b'] + 1)sera exécuté dans l'espace Python, et par conséquent est beaucoup plus lent.

4) itertuplesne place pas les données dans un fichier Series. Il renvoie simplement les données sous forme de tuples.

5) iterrows BOITE les données dans un fichier Series. À moins que vous n'en ayez vraiment besoin, utilisez une autre méthode.

6) Mise à jour d'une image vide une seule ligne à la fois. J'ai vu cette méthode trop utilisée. C'est de loin le plus lent. C'est probablement un endroit courant (et raisonnablement rapide pour certaines structures python), mais a DataFramefait un bon nombre de vérifications sur l'indexation, donc ce sera toujours très lent pour mettre à jour une ligne à la fois. Beaucoup mieux pour créer de nouvelles structures et concat.

Les opérations vectorielles dans Numpy et pandas sont beaucoup plus rapides que les opérations scalaires dans vanilla Python pour plusieurs raisons:

• Recherche de type amorti : Python est un langage typé dynamiquement, il y a donc une surcharge d'exécution pour chaque élément d'un tableau. Cependant, Numpy (et donc pandas) effectuent des calculs en C (souvent via Cython). Le type du tableau n'est déterminé qu'au début de l'itération; cette économie à elle seule est l'une des plus grandes victoires.

• Meilleure mise en cache : l'itération sur un tableau C est compatible avec le cache et donc très rapide. Un pandas DataFrame est une "table orientée colonnes", ce qui signifie que chaque colonne n'est en réalité qu'un tableau. Ainsi, les actions natives que vous pouvez effectuer sur un DataFrame (comme la somme de tous les éléments dans une colonne) vont avoir quelques échecs de cache.

• Plus de possibilités de parallélisme : un simple tableau C peut être utilisé via des instructions SIMD. Certaines parties de Numpy activent SIMD, en fonction de votre CPU et du processus d'installation. Les avantages du parallélisme ne seront pas aussi spectaculaires que le typage statique et une meilleure mise en cache, mais ils restent une victoire solide.

Morale de l'histoire: utilisez les opérations vectorielles dans Numpy et pandas. Elles sont plus rapides que les opérations scalaires en Python pour la simple raison que ces opérations sont exactement ce qu'un programmeur C aurait écrit à la main de toute façon. (Sauf que la notion de tableau est beaucoup plus facile à lire que les boucles explicites avec des instructions SIMD intégrées.)

Voici comment résoudre votre problème. Tout cela est vectorisé.

In [58]: df = table1.merge(table2,on='letter')

In [59]: df['calc'] = df['number1']*df['number2']

In [60]: df
Out[60]: 
  letter  number1  number2  calc
0      a       50      0.2    10
1      a       50      0.5    25
2      b      -10      0.1    -1
3      b      -10      0.4    -4

In [61]: df.groupby('letter')['calc'].max()
Out[61]: 
letter
a         25
b         -1
Name: calc, dtype: float64

In [62]: df.groupby('letter')['calc'].idxmax()
Out[62]: 
letter
a         1
b         2
Name: calc, dtype: int64

In [63]: df.loc[df.groupby('letter')['calc'].idxmax()]
Out[63]: 
  letter  number1  number2  calc
1      a       50      0.5    25
2      b      -10      0.1    -1

Une autre option consiste à utiliser to_records(), qui est plus rapide que les deux itertupleset iterrows.

Mais pour votre cas, il y a beaucoup de place pour d'autres types d'améliorations.

Voici ma dernière version optimisée

def iterthrough():
    ret = []
    grouped = table2.groupby('letter', sort=False)
    t2info = table2.to_records()
    for index, letter, n1 in table1.to_records():
        t2 = t2info[grouped.groups[letter].values]
        # np.multiply is in general faster than "x * y"
        maxrow = np.multiply(t2.number2, n1).argmax()
        # `[1:]`  removes the index column
        ret.append(t2[maxrow].tolist()[1:])
    global table3
    table3 = pd.DataFrame(ret, columns=('letter', 'number2'))

Test de référence:

-- iterrows() --
100 loops, best of 3: 12.7 ms per loop
  letter  number2
0      a      0.5
1      b      0.1
2      c      5.0
3      d      4.0

-- itertuple() --
100 loops, best of 3: 12.3 ms per loop

-- to_records() --
100 loops, best of 3: 7.29 ms per loop

-- Use group by --
100 loops, best of 3: 4.07 ms per loop
  letter  number2
1      a      0.5
2      b      0.1
4      c      5.0
5      d      4.0

-- Avoid multiplication --
1000 loops, best of 3: 1.39 ms per loop
  letter  number2
0      a      0.5
1      b      0.1
2      c      5.0
3      d      4.0

Code complet:

import pandas as pd
import numpy as np

#%% Create the original tables
t1 = {'letter':['a','b','c','d'],
      'number1':[50,-10,.5,3]}

t2 = {'letter':['a','a','b','b','c','d','c'],
      'number2':[0.2,0.5,0.1,0.4,5,4,1]}

table1 = pd.DataFrame(t1)
table2 = pd.DataFrame(t2)

#%% Create the body of the new table
table3 = pd.DataFrame(np.nan, columns=['letter','number2'], index=table1.index)


print('\n-- iterrows() --')

def optimize(t2info, t1info):
    calculation = []
    for index, r in t2info.iterrows():
        calculation.append(r['number2'] * t1info)
    maxrow_in_t2 = calculation.index(max(calculation))
    return t2info.loc[maxrow_in_t2]

#%% Iterate through filtering relevant data, optimizing, returning info
def iterthrough():
    for row_index, row in table1.iterrows():   
        t2info = table2[table2.letter == row['letter']].reset_index()
        table3.iloc[row_index,:] = optimize(t2info, row['number1'])

%timeit iterthrough()
print(table3)

print('\n-- itertuple() --')
def optimize(t2info, n1):
    calculation = []
    for index, letter, n2 in t2info.itertuples():
        calculation.append(n2 * n1)
    maxrow = calculation.index(max(calculation))
    return t2info.iloc[maxrow]

def iterthrough():
    for row_index, letter, n1 in table1.itertuples():   
        t2info = table2[table2.letter == letter]
        table3.iloc[row_index,:] = optimize(t2info, n1)

%timeit iterthrough()


print('\n-- to_records() --')
def optimize(t2info, n1):
    calculation = []
    for index, letter, n2 in t2info.to_records():
        calculation.append(n2 * n1)
    maxrow = calculation.index(max(calculation))
    return t2info.iloc[maxrow]

def iterthrough():
    for row_index, letter, n1 in table1.to_records():   
        t2info = table2[table2.letter == letter]
        table3.iloc[row_index,:] = optimize(t2info, n1)

%timeit iterthrough()

print('\n-- Use group by --')

def iterthrough():
    ret = []
    grouped = table2.groupby('letter', sort=False)
    for index, letter, n1 in table1.to_records():
        t2 = table2.iloc[grouped.groups[letter]]
        calculation = t2.number2 * n1
        maxrow = calculation.argsort().iloc[-1]
        ret.append(t2.iloc[maxrow])
    global table3
    table3 = pd.DataFrame(ret)

%timeit iterthrough()
print(table3)

print('\n-- Even Faster --')
def iterthrough():
    ret = []
    grouped = table2.groupby('letter', sort=False)
    t2info = table2.to_records()
    for index, letter, n1 in table1.to_records():
        t2 = t2info[grouped.groups[letter].values]
        maxrow = np.multiply(t2.number2, n1).argmax()
        # `[1:]`  removes the index column
        ret.append(t2[maxrow].tolist()[1:])
    global table3
    table3 = pd.DataFrame(ret, columns=('letter', 'number2'))

%timeit iterthrough()
print(table3)

La version finale est presque 10 fois plus rapide que le code d'origine. La stratégie est:

1. Utilisez groupbypour éviter la comparaison répétée des valeurs.
2. Permet to_recordsd'accéder aux objets numpy.records bruts.
3. N'opérez pas sur DataFrame tant que vous n'avez pas compilé toutes les données.

Oui, Pandas itertuples () est plus rapide que iterrows (). vous pouvez consulter la documentation: https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.iterrows.html

"Pour conserver les dtypes lors de l'itération sur les lignes, il est préférable d'utiliser itertuples () qui retourne des noms nommés des valeurs et qui est généralement plus rapide que iterrows."

Détails dans cette vidéo

Référence