[PYTHON] Exemple de traitement efficace des données avec PANDAS

en premier

PANDAS est la meilleure bibliothèque de traitement de données pour les scientifiques de données, mais il faut veiller à éviter les pièges de performances lors du traitement de millions de lignes de données. Cette fois, je voudrais vous présenter quelques techniques que j'ai apprises dans mon travail.

DataFrame Puisque PANDAS est une structure de données orientée colonnes, nous sommes capables de traiter chaque colonne. Il est recommandé de créer un DataFrame au format" 1 enregistrement 1 ligne ", et de définir toutes les valeurs mesurables (humidité, prix, coordonnées, etc.) pour chaque colonne de chaque colonne.

Cependant, dans une énorme quantité de traitement de données, si un traitement en boucle pour chaque ligne est effectué, les performances seront considérablement réduites. Dans cet article, je voudrais présenter une manière intelligente d'ajouter des données en tenant compte des performances.

Commencez par créer un exemple de tableau.

data = {'Team': ['Tiger', 'Tiger', 'Rabbit', 'Rabbit', 'Cat',
   'Cat', 'Cat', 'Cat', 'Tiger', 'Human', 'Human', 'Tiger'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df= pd.DataFrame(data)
print(team_dashboard)
'''
      Team  Rank  Year  Points
0    Tiger     1  2014     876
1    Tiger     2  2015     789
2   Rabbit     2  2014     863
3   Rabbit     3  2015     673
4      Cat     3  2014     741
5      Cat     4  2015     812
6      Cat     1  2016     756
7      Cat     1  2017     788
8    Tiger     2  2016     694
9    Human     4  2014     701
10   Human     1  2015     804
11   Tiger     2  2017     690
'''

print(df.columns) #Obtenir le libellé de la colonne
'''
Index(['Team', 'Rank', 'Year', 'Points'], dtype='object')
'''

print(df.index) #Obtenir l'index des lignes
'''
RangeIndex(start=0, stop=12, step=1)
'''

Le DataFrame a une liste spéciale appelée index. Dans l'exemple ci-dessus, les éléments représentant chaque colonne sont étiquetés comme "['Team', 'Rank', 'Year', 'Points']` et 0, 1, 2, 3, ... sur le côté gauche. A un index de ligne qui représente chaque ligne.

groupby() groupby est utilisé lorsque vous souhaitez collecter des données avec la même valeur et effectuer des opérations communes pour chaque groupe. Bien qu'il soit devenu un standard dans le traitement des données, groupby est assez difficile au début car il a des utilisations diverses. Jetons un œil à un exemple. Si vous mettez le nom de la colonne dans la méthode groupby (), elle renvoie l'objet `` GroupBy```.

#1 niveau
df_g = df.groupby(by=['Team'])
print(df_g.groups)
'''
{'Cat': Int64Index([4, 5, 6, 7], dtype='int64'),
 'Human': Int64Index([9, 10], dtype='int64'),
 'Rabbit': Int64Index([2, 3], dtype='int64'),
 'Tiger': Int64Index([0, 1, 8, 11], dtype='int64')}
'''

#2 étiquettes (pluriel)
df_g = df.groupby(by=['Team', 'Year'])
print(df_g.groups)
'''
{('Cat', 2014): Int64Index([4], dtype='int64'),
 ('Cat', 2015): Int64Index([5], dtype='int64'),
 ('Cat', 2016): Int64Index([6], dtype='int64'),
 ('Cat', 2017): Int64Index([7], dtype='int64'),
 ('Human', 2014): Int64Index([9], dtype='int64'),
 ('Human', 2015): Int64Index([10], dtype='int64'),
 ('Rabbit', 2014): Int64Index([2], dtype='int64'),
 ('Rabbit', 2015): Int64Index([3], dtype='int64'),
 ('Tiger', 2014): Int64Index([0], dtype='int64'),
 ('Tiger', 2015): Int64Index([1], dtype='int64'),
 ('Tiger', 2016): Int64Index([8], dtype='int64'),
 ('Tiger', 2017): Int64Index([11], dtype='int64')}
'''

De cette façon, vous pouvez voir quelle colonne est dans quel groupe sous la forme de {étiquette de colonne: [étiquette de ligne, étiquette de ligne, ...]}. Chaque étiquette contient une liste d'index de ligne de données que possède la même étiquette.

Au fait, pour obtenir les données du groupe, passez la clé de groupe à get_group ().

df_oneGroup = df_g.get_group('Rabbit')
print(df_oneGroup)
'''
     Team  Rank  Year  Points
2  Rabbit     2  2014     863
3  Rabbit     3  2015     673
'''

df_oneGroup = df_g.get_group(('Cat', 2014))
print(df_oneGroup)
'''
  Team  Rank  Year  Points
4  Cat     3  2014     741
'''

Eh bien, en fait, get_group () n'est pas beaucoup utilisé sauf pour le débogage, mais l'objet GroupBy vous permet d'effectuer diverses opérations pour chaque groupe. Par exemple, appelez la méthode mean () pour faire la moyenne du classement et des points annuels de chaque équipe. De nombreuses autres méthodes sont fournies, telles que sum () et mode (). Au fait, ʻas_index = False` réinitialise l'étiquette de groupe par défaut à [0, 1, 2, ..., n].

df_mean = team_dashboard.groupby(by=['Team', 'Year']).mean()
print(df_mean)
'''
              Rank  Points
Team   Year              
Cat    2014     3     741
       2015     4     812
       2016     1     756
       2017     1     788
Human  2014     4     701
       2015     1     804
Rabbit 2014     2     863
       2015     3     673
Tiger  2014     1     876
       2015     2     789
       2016     2     694
       2017     2     690
'''

df_mean = team_dashboard.groupby(by=['Team', 'Year'], as_index=False).mean()
print(df_mean)
'''
      Team  Year  Rank  Points
0      Cat  2014     3     741
1      Cat  2015     4     812
2      Cat  2016     1     756
3      Cat  2017     1     788
4    Human  2014     4     701
5    Human  2015     1     804
6   Rabbit  2014     2     863
7   Rabbit  2015     3     673
8    Tiger  2014     1     876
9    Tiger  2015     2     789
10   Tiger  2016     2     694
11   Tiger  2017     2     690
'''

Renvoie plusieurs lignes pour chaque groupe en utilisant ʻagg () `

Comme le précédent GroupBy.mean (), vous pouvez obtenir la valeur numérique de chaque groupe, mais si vous voulez obtenir la valeur numérique de chaque groupe séparément, utilisez ʻagg () (Agrégation). Les fonctions utilisées pour l'agrégation peuvent être appelées avec des chaînes, des méthodes numpy, des fonctions personnalisées et des expressions lambda. Pour utiliser ʻagg () , définissez-le dansdict ()et passez-le comme suit.

'''
  location   col1  col2  col3  col4
0        a   True     2     1     4
1        a  False     6     2     6
2        b   True     7     6     3
3        b   True     3     3     4
4        b  False     8     4     6
5        c   True     9    57     8
6        d  False     1    74     9
'''
func_dict = {'col1': lambda x: x.any(),         #Confirmation de l'état manquant
             'col2': np.mean,                   #moyenne
             'col3': np.sum,                    #total
             'col4': lambda S: S.mode()[0]}     #Valeur la plus fréquente
df_agg = df.groupby('location').agg(func_dict).reset_index()
print(df_agg)
'''
  location   col1  col2  col3  col4
0        a   True     4     3     4
1        b   True     6    13     3
2        c   True     9    57     8
3        d  False     1    74     9
'''

Convertissez des variables catégorielles en nombres à des valeurs limites arbitraires en utilisant cut ()

Présentation de cut (), qui catégorise les données en fonction de la valeur limite spécifiée. Par exemple, il est facile de diviser l'ensemble des données en cinq catégories telles que «minuit, matin, midi, après-midi et nuit».

prods = pd.DataFrame({'hour':range(0, 24)})
b = [0, 6, 11, 12, 17, 24]
l = ['Minuit', 'un m.','le midi', 'après midi', 'Nuit']
prods['period'] = pd.cut(prods['hour'], bins=b, labels=l, include_lowest=True)
print(prods)

'''
    hour   period
0 0 minuit
1 1 minuit
2 2 minuit
3 3 minuit
4 4 minuit
5 5 minuit
6 6 minuit
7 7 heures du matin
8 8 h
9 9 heures
10 10 h
11 11 heures
12 12 heures
13 13 heures
14 14 h
15 15 h
16 16 h
17 17 h
18 18 nuit
19 19 nuit
20 20 nuit
21 21 nuit
22 22 nuit
23 23 nuit
'''

Regrouper et traiter les données de séries chronologiques en utilisant resample ()

Cette fois, disons "calculer le nombre cumulé de cas par heure". Je pense que je vais essayer d'utiliser pd.cumsum () ici, alors créez une colonne num_ride_1h à l'avance et donnez-lui" 1 ". Ensuite, après avoir groupé par resample () dans la colonne d'horodatage toutes les heures, chaque groupe peut être complété en appelant la méthode cumsum ().

df_raw= make_classification(n_samples, n_features+1)
df_raw['timestamp'] = random_datetimes_or_dates(start, end, n=n_samples)
df_raw['num_ride_1h'] = 1
print(df_raw)
'''
       var_0     var_1     var_2  class           timestamp  num_ride_1h
0   1.062513 -0.056001  0.761312      0 2020-09-21 00:01:57            1
1  -2.272391  1.307474 -1.276716      0 2020-09-21 00:14:49            1
2  -1.470793  1.245910 -0.708071      2 2020-09-21 00:17:46            1
3  -1.827838  1.365970 -0.933938      0 2020-09-21 00:25:13            1
4  -1.115794 -0.045542 -0.830372      0 2020-09-21 00:31:45            1
..       ...       ...       ...    ...                 ...          ...
95  0.247010  0.903812  0.448323      0 2020-09-21 23:29:25            1
96 -0.665399  1.861112  0.063642      1 2020-09-21 23:32:51            1
97  0.875282  0.028704  0.649306      2 2020-09-21 23:36:21            1
98  2.159065 -1.155290  1.238786      0 2020-09-21 23:37:23            1
99  1.739777 -1.775147  0.748372      2 2020-09-21 23:56:04            1
'''

df_raw['num_ride_1h'] = df_raw.resample('1H', on='timestamp')['num_ride_1h'].cumsum()

'''
       var_0     var_1     var_2  class           timestamp  num_ride_1h
0  -1.331170 -0.274703  0.809738      1 2020-10-11 00:10:54            1
1  -1.373495 -1.067991  1.738302      1 2020-10-11 00:14:24            2
2  -1.471448  0.216404  0.296618      0 2020-10-11 00:43:29            3
3  -2.282394 -1.528916  2.605747      1 2020-10-11 00:48:52            4
4   0.162427  0.524188 -0.663437      2 2020-10-11 00:51:23            5
..       ...       ...       ...    ...                 ...          ...
95  1.197076  0.274294 -0.759543      1 2020-10-11 22:23:50            3
96 -0.459688  0.646523 -0.573518      0 2020-10-11 23:00:20            1
97  0.212496  0.773962 -0.969428      2 2020-10-11 23:11:43            2
98  1.578519  0.496655 -1.156869      1 2020-10-11 23:14:31            3
99  1.318311 -0.324909 -0.114971      0 2020-10-11 23:46:46            4

'''

Vous pouvez également utiliser pd.Grouper (). Les deux peuvent produire le même résultat.

df_raw['num_ride_1h'] = df_raw.groupby(pd.Grouper(key='timestamp', freq='1h'))['num_ride_1h'].cumsum()

finalement

Il y a plusieurs autres exemples que je voudrais présenter, mais cette fois, je voudrais terminer ici. Si j'ai la prochaine opportunité, je présenterai le traitement des données centré sur les données de séries chronologiques.

** [Quand Co., Ltd.] ** Quand Co., Ltd., où je travaille, travaille sur des mises à niveau de l'industrie locale. S'il vous plaît, jetez un oeil. http://quando.jp/