[PYTHON] Comment utiliser Pandas Rolling

Pour avoir une idée approximative des tendances des données qui fluctuent en détail, telles que les cours des actions et le nombre de nouveaux patients positifs pour les coronavirus, prenez la moyenne en incluant les chiffres avant et après un certain moment. Prenez note du roulement, une fonction Pandas qui fait cela.

Utilisation normale

import pandas as pd

Tout d'abord, pour confirmer l'opération de base du laminage, créez une série avec 10 1 et nommez-la.

ones = pd.Series([1] * 10)
ones

0    1
1    1
2    1
3    1
4    1
5    1
6    1
7    1
8    1
9    1
dtype: int64

Utilisez le roulement pour en ajouter quatre à la fois. Bien sûr, le résultat est une colonne de 4, car vous ajoutez simplement les nombres 1 par quatre. Cependant, le résultat des quatre premières données manquantes est NaN. J'ai répertorié sum-4 suite à l'ajout de ceux-ci pour comparaison avec la colonne d'origine.

De cette façon, spécifiez le nombre de données (largeur de la fenêtre) à agréger dans la fenêtre. C'est une image de quatre fenêtres se déplaçant du début à la fin et comptant. Les résultats agrégés sont enregistrés à la fin de la fenêtre, de sorte que les trois premières valeurs de sum-4 sont NaN.

pd.DataFrame({
    'ones': ones,
    'sum-4': ones.rolling(window=4).sum(),
})

Si center = True est spécifié, le résultat agrégé peut être enregistré au centre au lieu d'être enregistré à la fin de la fenêtre. Organisons cela comme un centre de somme. Lorsque la fenêtre est égale, enregistrez après le centre. Maintenant, le dernier élément est NaN.

pd.DataFrame({
    'ones': ones,
    'sum-4': ones.rolling(window=4).sum(),
    'sum-center': ones.rolling(window=4, center=True).sum(),
})

Par défaut, la partie des données qui n'est pas assez large n'est pas agrégée. Cependant, si vous spécifiez min_periods, il sera agrégé s'il y a au moins min_periods. Dans cet exemple, min_period = 2 est spécifié, le résultat apparaîtra donc à partir de la deuxième ligne.

pd.DataFrame({
    'ones': ones,
    'sum-4': ones.rolling(4).sum(),
    'min-periods': ones.rolling(window=4, min_periods=2).sum(),
})

Jusqu'à présent, tous les éléments de la fenêtre sont utilisés pour l'agrégation, mais il semble que le poids de la valeur agrégée puisse être changé en utilisant win_type. Nécessite une installation scipy.

pd.DataFrame({
    'ones': ones,
    'sum-4': ones.rolling(4).sum(),
    'win_type': ones.rolling(window=4, win_type='nuttall').sum(),
})

Utiliser la date pour l'index

Jusqu'à présent, vous avez spécifié le nombre d'éléments dans la fenêtre. Ici, vous pouvez spécifier la période telle que l'heure ou le nombre de jours dans la fenêtre uniquement lorsque l'index de la série est la date ou l'heure. Je vais créer des échantillons de données immédiatement.

date_ones = pd.Series(
    index=[
        pd.Timestamp('2020-01-01'),
        pd.Timestamp('2020-01-02'),
        pd.Timestamp('2020-01-07'),
        pd.Timestamp('2020-01-08'),
        pd.Timestamp('2020-01-09'),
        pd.Timestamp('2020-01-16'),
    ],
    data=[1,1,1,1,1,1]
)
date_ones

2020-01-01    1
2020-01-02    1
2020-01-07    1
2020-01-08    1
2020-01-09    1
2020-01-16    1
dtype: int64

Si vous spécifiez window = '7d' ici, les éléments d'il y a 7 jours seront utilisés pour l'agrégation.

pd.DataFrame({
    'ones': date_ones,
    'rolling-7d': date_ones.rolling('7D').sum(),
})

Dans cet exemple

• 2020-01-01: 1 car il n'y a rien avant
• 2020-01-02: Il y en a un il y a 7 jours, donc 2
• 2020-01-07: Il y a 2020-01-01, 2020-01-02, 2020-01-07 dans 7 jours, donc 3
• 2020-01-08: Il y a 2020-01-02, 2020-01-07, 2020-01-08 dans 7 jours, donc 3
• 2020-01-16: 1 car il n'y a rien dans les 7 jours

Ce sera.

Cette méthode de spécification de type '7D' est appelée offset. Il est expliqué dans Offset aliases.

Si vous utilisez le décalage pour la fenêtre, les données seront au moins agrégées, donc NaN ne sera pas enregistré arbitrairement. Inversement, si min_periods est spécifié, il sera NaN s'il n'y a pas plus de données que celles spécifiées dans la période de décalage spécifiée.

pd.DataFrame({
    'ones': date_ones,
    'rolling-7d': date_ones.rolling('7D').sum(),
    'rolling-min-periods': date_ones.rolling('7D', min_periods=3).sum(),
})

Exemple de moyenne mobile

Maintenant, dessinons un graphique de moyenne mobile du nombre de personnes infectées par le nouveau virus corona à Tokyo en utilisant les connaissances jusqu'à présent.

Les données sont empruntées à Détails de l'annonce de nouveaux patients positifs au coronavirus à Tokyo.

covid_src = pd.read_csv('https://stopcovid19.metro.tokyo.lg.jp/data/130001_tokyo_covid19_patients.csv', parse_dates=['Publié_Date'])
covid_src

Comme nous n'avons besoin que du nombre de personnes, nous utiliserons le groupe par et la taille pour obtenir le nombre de cas par date.

covid_daily = covid_src.groupby("Publié_Date").size()
covid_daily.index.name = 'date'
covid_daily

date
2020-01-24      1
2020-01-25      1
2020-01-30      1
2020-02-13      1
2020-02-14      2
             ... 
2020-10-10    249
2020-10-11    146
2020-10-12     78
2020-10-13    166
2020-10-14    177
Length: 239, dtype: int64

Si vous dessinez simplement le nombre d'observations pour chaque date sur le graphique, ce sera en zigzag comme ceci.

covid_daily.plot()

Mettre en place une fenêtre hebdomadaire pour capturer les tendances chez les patients positifs. Si vous utilisez mean () au lieu de sum (), vous obtiendrez une moyenne mobile.

covid_daily.rolling(window='7D').mean().plot()

référence

• Comment utiliser la fonction de roulement pour combiner plusieurs éléments adjacents dans Pandas
• pandas.Series.rolling