Qu'est-ce que le défilement numpy?

Le défilement numpy est une fonction de la bibliothèque numpy qui nous permet de calculer des statistiques en défilement sur des tableaux. Il applique une fenêtre mobile aux données et effectue une fonction spécifiée sur les données en fenêtre. Cela est particulièrement utile pour l'analyse des séries temporelles et pour lisser les fluctuations des données.

Comment calculer des statistiques en défilement à l'aide de numpy?

Pour calculer des statistiques en défilement à l'aide de numpy, vous pouvez utiliser la fonction `numpy.rolling()` et spécifier la taille de la fenêtre ainsi que la fonction souhaitée (par exemple, moyenne, médiane) à appliquer aux données en fenêtre. La fonction itère sur le tableau, appliquant la fonction spécifiée à chaque fenêtre de données.

Quelle est la syntaxe de la fonction de défilement de numpy?

La syntaxe de la fonction de défilement de numpy est `numpy.rolling(fenêtre, axis=0)`, où `fenêtre` est la taille de la fenêtre mobile et `axis` (facultatif) spécifie l'axe le long duquel l'opération de défilement doit être effectuée. La fonction renvoie un objet de fenêtre mobile qui peut être utilisé pour appliquer différentes fonctions telles que la moyenne, la médiane, etc.

Numpy Rolling - Calcul du Rolling Mean en Python

Name: Sebastian Brandt

Updated on 17/08/2023

Dans le domaine de l'analyse de données, surtout lorsqu'il s'agit de données de séries chronologiques, la capacité de calculer des statistiques roulantes est une compétence cruciale. L'outil principal pour cela en Python est la bibliothèque numpy, et plus précisément, la fonction numpy rolling. Cette fonction nous permet de calculer différentes statistiques roulantes, telles que la moyenne roulante, sur nos données. Mais comment cela fonctionne-t-il et comment pouvons-nous l'utiliser efficacement ?

Numpy rolling est une fonction qui nous permet d'appliquer une fonction sur une fenêtre mobile d'une taille spécifiée à travers nos données. Cela est particulièrement utile dans l'analyse de séries chronologiques, où nous voulons souvent lisser les fluctuations à court terme pour mieux voir les tendances à long terme. Dans cet article, nous allons approfondir les détails de numpy rolling, en couvrant sa syntaxe, comment l'utiliser avec différentes tailles de fenêtre, comment l'appliquer aux tableaux 2D, et comment utiliser des filtres avec.

Vous souhaitez créer rapidement une visualisation de données à partir d'un dataframe Python Pandas sans écrire de code ?

PyGWalker est une bibliothèque Python pour l'analyse de données exploratoire avec la visualisation. PyGWalker (opens in a new tab) peut simplifier votre flux de travail d'analyse et de visualisation de données dans un notebook Jupyter, en transformant votre dataframe pandas (et dataframe polars) en une interface utilisateur de type Tableau pour l'exploration visuelle.

(opens in a new tab)

Comprendre Numpy Rolling

Numpy rolling est une fonction qui applique une fenêtre mobile à un tableau et applique une fonction sur les données dans cette fenêtre. La fenêtre se déplace le long du tableau, et la fonction est appliquée à la nouvelle fenêtre à chaque étape. La taille de la fenêtre est spécifiée par l'utilisateur et peut être un entier inférieur ou égal à la taille du tableau.

La syntaxe de la fonction rolling de numpy est la suivante :

numpy.rolling(window)

Ici, window est la taille de la fenêtre mobile. C'est un entier qui spécifie le nombre d'éléments consécutifs du tableau qui seront inclus dans la fenêtre.

Par exemple, si nous avons un tableau unidimensionnel de valeurs et que nous voulons calculer la moyenne roulante avec une taille de fenêtre de 3, nous utiliserions le code suivant :

import numpy as np
 
# Créer un tableau unidimensionnel
data = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
 
# Calculer la moyenne roulante avec une taille de fenêtre de 3
rolling_mean = np.rolling(3).mean(data)
 
print(rolling_mean)

Cela affichera le tableau suivant :

array([nan, nan, 2., 3., 4., 5., 6., 7., 8.])

Les deux premières valeurs sont nan car il n'y a pas suffisamment de valeurs précédentes pour remplir une fenêtre de taille 3. La troisième valeur est 2 car la moyenne des trois premières valeurs (1, 2, 3) est 2, et ainsi de suite.

Comparaison entre Numpy Rolling et Numpy Roll

Bien que numpy rolling et numpy roll puissent sembler similaires, ils servent à des fins différentes. Numpy roll est une fonction qui décale les éléments d'un tableau le long d'un axe spécifié, en faisant passer les éléments de l'autre côté du tableau. En revanche, numpy rolling applique une fenêtre mobile à un tableau et applique une fonction aux données dans cette fenêtre.

Par exemple, si nous avons le tableau unidimensionnel suivant :

import numpy as np
 
# Créer un tableau unidimensionnel
data = np.array([1, 2, 3, 4, 5])
 
# Utiliser numpy roll pour décaler les éléments de 2 positions vers la droite
rolled_data = np.roll(data, 2)
 
print(rolled_data)

Cela affichera le tableau suivant :

array([4, 5, 1, 2, 3])

Comme vous pouvez le voir, les éléments ont été décalés de deux positions vers la droite, avec les éléments qui ont été poussés hors de la fin étant ramenés au début du tableau.

Application de Numpy Rolling aux tableaux 2D

Numpy rolling peut également être appliqué aux tableaux 2D. Dans ce cas, la fenêtre mobile est appliquée à chaque ligne ou colonne du tableau (selon l'axe spécifié), et la fonction est appliquée aux données dans la fenêtre.

Par exemple, si nous avons un tableau 2D de valeurs et que nous voulons calculer la moyenne roulante avec une taille de fenêtre de 3 le long des lignes, nous utiliserions le code suivant :

import numpy as np
 
# Créer un tableau 2D
data = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15]])
 
# Calculer la moyenne roulante avec une taille de fenêtre de 3 le long des lignes
rolling_mean = np.rolling(3, axis=1).mean(data)
 
print(rolling_mean)

Cela affichera le tableau 2D suivant :

array([[nan, nan,  2.,  3.,  4.],
       [nan, nan,  7.,  8.,  9.],
       [nan, nan, 12., 13., 14.]])

Les deux premières valeurs de chaque ligne sont nan car il n'y a pas suffisamment de valeurs précédentes dans la ligne pour remplir une fenêtre de taille 3. La troisième valeur dans la première ligne est 2 car la moyenne des trois premières valeurs dans la ligne (1, 2, 3) est 2, et ainsi de suite.

Utilisation de filtres avec Numpy Rolling

Numpy rolling nous permet également d'appliquer des filtres aux données dans la fenêtre mobile. Cela peut être utile pour lisser les données ou éliminer les valeurs aberrantes.

Par exemple, si nous voulons calculer la médiane roulante (qui est moins sensible aux valeurs aberrantes que la moyenne) avec une taille de fenêtre de 3, nous utiliserions le code suivant :

import numpy as np
 
# Créer un tableau unidimensionnel
data = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
 
# Calculer la médiane roulante avec une taille de fenêtre de 3
rolling_median = np.rolling(3).median(data)
 
print(rolling_median)

Cela affichera le tableau suivant :

array([nan, nan, 2., 3., 4., 5., 6., 7., 8.])

Les deux premières valeurs sont nan car il n'y a pas assez de valeurs précédentes pour remplir une fenêtre de taille 3. La troisième valeur est 2 car la médiane des trois premières valeurs (1, 2, 3) est 2, et ainsi de suite.

Application de Numpy Rolling aux données de séries chronologiques

L'une des utilisations les plus courantes de Numpy Rolling consiste à analyser des données de séries chronologiques. Les données de séries chronologiques sont une séquence de points de données collectés au fil du temps, généralement à intervalles réguliers. Numpy Rolling nous permet de calculer des statistiques roulantes sur les données de séries chronologiques, ce qui nous donne des informations sur les tendances et les motifs.

Pour appliquer Numpy Rolling aux données de séries chronologiques, nous devons d'abord nous assurer que nos données sont correctement formatées. Généralement, les données de séries chronologiques sont représentées sous la forme d'un tableau à une dimension ou d'une colonne dans un tableau à deux dimensions, où chaque élément représente un point de données à un moment spécifique. Une fois que nous avons nos données de séries chronologiques dans le format souhaité, nous pouvons utiliser Numpy Rolling pour calculer des statistiques roulantes.

Par exemple, supposons que nous disposons d'un ensemble de données de séries chronologiques qui enregistre la température quotidienne dans une ville au cours de l'année écoulée. Nous voulons calculer la température moyenne sur 7 jours pour lisser les fluctuations quotidiennes et identifier les tendances de température à long terme. Voici comment nous pouvons le faire :

import numpy as np
 
# Supposons que nous ayons un tableau à 1 dimension 'temperature' avec les valeurs de température quotidiennes
# Calculer la température moyenne sur 7 jours
rolling_avg = np.rolling(7).mean(temperature)
 
print(rolling_avg)

Le tableau rolling_avg contiendra les valeurs de température moyenne sur 7 jours. Chaque valeur représente la température moyenne sur une fenêtre de 7 jours, ce qui nous permet d'observer la tendance générale de la température au fil du temps.

En appliquant Numpy Rolling aux données de séries chronologiques, nous pouvons découvrir des informations précieuses, telles que l'identification de la saisonnalité, la détection des anomalies ou la prédiction des tendances futures. Cela offre un outil puissant pour analyser et comprendre les motifs dépendants du temps dans différents domaines, notamment la finance, le climat, l'analyse des marchés boursiers, etc.

Manipulation des axes avec Numpy Rolling

Numpy Rolling nous permet non seulement d'appliquer une fenêtre mobile le long des lignes ou des colonnes d'un tableau à 2 dimensions, mais offre également une flexibilité pour manipuler les axes. Cette fonctionnalité est particulièrement utile lors de la manipulation de tableaux multidimensionnels et de la réalisation de calculs sur des dimensions spécifiques.

Par exemple, supposons que nous ayons un tableau à 3 dimensions représentant les mesures de température mensuelles dans différents lieux et périodes de temps. Nous voulons calculer la température moyenne roulante pour chaque emplacement le long de l'axe du temps. Voici comment nous pouvons y parvenir en utilisant Numpy Rolling :

import numpy as np
 
# Supposons que nous ayons un tableau à 3 dimensions 'temperature' avec une forme (num_locations, num_time_periods, num_months)
# Calculer la température moyenne roulante le long de l'axe du temps
rolling_avg = np.rolling(3, axis=1).mean(temperature)
 
print(rolling_avg)

Dans cet exemple, nous spécifions axis=1 pour indiquer que nous voulons appliquer la fenêtre mobile le long de l'axe du temps. Le tableau résultant rolling_avg contiendra les valeurs de température moyenne roulante pour chaque emplacement, en préservant la forme originale du tableau.

En manipulant les axes avec Numpy Rolling, nous pouvons effectuer des calculs roulants sur des dimensions spécifiques, ce qui nous permet d'analyser et d'extraire des informations significatives à partir de données multidimensionnelles.

Optimisation de Numpy Rolling pour l'analyse de données

Lorsque vous travaillez avec de grands ensembles de données ou effectuez des calculs complexes à l'aide de Numpy Rolling, l'optimisation devient cruciale pour garantir un calcul efficace et réduire le temps de traitement. Voici quelques conseils pour optimiser Numpy Rolling pour l'analyse de données :

Spécifiez le dtype : Lors de la création de tableaux ou du chargement de données dans Numpy, spécifiez le type de données approprié (dtype). L'utilisation du bon type de données permet non seulement d'économiser de la mémoire, mais aussi d'améliorer la vitesse de calcul.
Utilisez judicieusement la taille de la fenêtre : Ajustez la taille de la fenêtre en fonction de vos données et de vos besoins d'analyse. Une petite taille de fenêtre fournit des informations plus détaillées mais peut être sensible au bruit, tandis qu'une grande taille de fenêtre lisse les fluctuations mais peut négliger les motifs à court terme.
Exploitez les opérations vectorisées : Numpy est conçu pour les opérations vectorisées, qui peuvent considérablement améliorer les performances. Au lieu d'utiliser des boucles ou des calculs itératifs, essayez de formuler vos calculs à l'aide des fonctions et opérations intégrées à Numpy.
Envisagez la parallélisation : Si votre système prend en charge le calcul parallèle, explorez les options de parallélisation de vos calculs Numpy Rolling. La parallélisation peut répartir le calcul sur plusieurs cœurs ou processeurs, réduisant ainsi le temps de traitement pour les grands ensembles de données.

En suivant ces techniques d'optimisation, vous pouvez améliorer les performances de vos calculs Numpy Rolling et exploiter pleinement le potentiel de l'analyse de données.

Foire aux questions

Voici quelques questions fréquemment posées sur Numpy Rolling :

Qu'est-ce que Numpy Rolling ? Numpy Rolling est une fonction de la bibliothèque Numpy qui nous permet de calculer des statistiques roulantes sur des tableaux. Elle applique une fenêtre mobile aux données et effectue une fonction spécifiée sur les données fenêtrées. Cela est particulièrement utile pour l'analyse de séries chronologiques et lissage des fluctuations dans les données.
Comment calculer des statistiques roulantes avec numpy ? Pour calculer des statistiques roulantes avec Numpy, vous pouvez utiliser la fonction numpy.rolling() et spécifier la taille de la fenêtre et la fonction souhaitée (par exemple, la moyenne, la médiane) à appliquer aux données fenêtrées. La fonction itère sur le tableau, appliquant la fonction spécifiée à chaque fenêtre de données.
Quelle est la syntaxe de la fonction Numpy Rolling ? La syntaxe de la fonction Numpy Rolling est numpy.rolling(window, axis=0), où window est la taille de la fenêtre mobile et axis (facultatif) spécifie l'axe le long duquel l'opération roulante doit être effectuée. La fonction renvoie un objet de fenêtre roulante qui peut être utilisé pour appliquer diverses fonctions telles que la moyenne, la médiane, etc.