Analyse de séries temporelles : Maîtriser les fonctions fenêtres pour l'analyse de données

Les données de séries temporelles, caractérisées par leur nature séquentielle et dépendante du temps, sont omniprésentes dans tous les secteurs. Du suivi des cours boursiers et de la surveillance du trafic d'un site web à l'analyse des relevés de capteurs et à la prévision des tendances des ventes, la capacité d'extraire des informations significatives des données de séries temporelles est cruciale pour une prise de décision éclairée. Les fonctions fenêtres constituent un ensemble d'outils puissant et flexible pour effectuer des calculs sur un ensemble de lignes liées à la ligne actuelle d'une table ou d'un cadre de données, ce qui les rend indispensables pour l'analyse des séries temporelles.

Comprendre les données de séries temporelles

Les données de séries temporelles sont une séquence de points de données indexés dans l'ordre chronologique. Les points de données peuvent représenter diverses mesures, telles que :

• Données financières : Cours des actions, taux de change, volumes de transactions
• Données de vente : Chiffres de vente quotidiens, hebdomadaires ou mensuels pour divers produits
• Données de capteurs : Relevés de température, mesures de pression, niveaux d'humidité
• Données de trafic web : Visites de sites web, pages vues, taux de rebond
• Données de consommation d'énergie : Consommation d'électricité horaire ou quotidienne

L'analyse des données de séries temporelles implique l'identification de schémas, de tendances et de saisonnalités, qui peuvent être utilisés pour prévoir les valeurs futures, détecter les anomalies et optimiser les processus métier.

Introduction aux fonctions fenêtres

Les fonctions fenêtres, également appelées agrégats fenêtrés ou fonctions analytiques, vous permettent d'effectuer des calculs sur un ensemble de lignes liées à la ligne actuelle, sans regrouper les lignes en un seul ensemble de résultats comme les fonctions d'agrégation traditionnelles (par exemple, SUM, AVG, COUNT). Cette capacité est particulièrement utile pour l'analyse des séries temporelles, où vous devez souvent calculer des moyennes mobiles, des sommes cumulatives et d'autres mesures temporelles.

Une fonction fenêtre se compose généralement des éléments suivants :

1. Fonction : Le calcul à effectuer (par exemple, AVG, SUM, RANK, LAG).
2. Clause OVER : Définit la fenêtre de lignes utilisée pour le calcul.
3. Clause PARTITION BY (facultatif) : Divise les données en partitions, et la fonction fenêtre est appliquée à chaque partition indépendamment.
4. Clause ORDER BY (facultatif) : Spécifie l'ordre des lignes dans chaque partition.
5. Clause ROWS/RANGE (facultatif) : Définit le cadre de la fenêtre, qui est l'ensemble de lignes par rapport à la ligne actuelle utilisées pour le calcul.

Concepts clés et syntaxe

1. La clause OVER()

La clause OVER() est au cœur d'une fonction fenêtre. Elle définit la fenêtre de lignes sur laquelle la fonction va opérer. Une simple clause OVER() sans arguments considérera l'ensemble du résultat comme la fenêtre. Par exemple :

Exemple SQL :

SELECT
  date,
  ventes,
  AVG(ventes) OVER()
FROM
  donnees_ventes;

Cette requête calcule la moyenne des ventes sur toutes les dates de la table donnees_ventes.

2. PARTITION BY

La clause PARTITION BY divise les données en partitions, et la fonction fenêtre est appliquée séparément à chaque partition. Ceci est utile lorsque vous souhaitez calculer des mesures pour différents groupes au sein de vos données.

Exemple SQL :

SELECT
  date,
  produit_id,
  ventes,
  AVG(ventes) OVER (PARTITION BY produit_id)
FROM
  donnees_ventes;

Cette requête calcule la moyenne des ventes pour chaque produit séparément.

3. ORDER BY

La clause ORDER BY spécifie l'ordre des lignes dans chaque partition. Ceci est essentiel pour calculer les totaux courants, les moyennes mobiles et d'autres mesures temporelles.

Exemple SQL :

SELECT
  date,
  ventes,
  SUM(ventes) OVER (ORDER BY date)
FROM
  donnees_ventes;

Cette requête calcule la somme cumulative des ventes au fil du temps.

4. ROWS/RANGE

Les clauses ROWS et RANGE définissent le cadre de la fenêtre, qui est l'ensemble de lignes par rapport à la ligne actuelle utilisées pour le calcul. La clause ROWS spécifie le cadre de la fenêtre en fonction du numéro de ligne physique, tandis que la clause RANGE spécifie le cadre de la fenêtre en fonction des valeurs de la colonne ORDER BY.

Exemple ROWS :

SELECT
  date,
  ventes,
  AVG(ventes) OVER (ORDER BY date ROWS BETWEEN 2 PRECEDING AND CURRENT ROW)
FROM
  donnees_ventes;

Cette requête calcule la moyenne mobile des ventes sur les 3 derniers jours (y compris le jour actuel).

Exemple RANGE :

SELECT
  date,
  ventes,
  AVG(ventes) OVER (ORDER BY date RANGE BETWEEN INTERVAL '2' DAY PRECEDING AND CURRENT ROW)
FROM
  donnees_ventes;

Cette requête calcule la moyenne mobile des ventes sur les 2 derniers jours (y compris le jour actuel). Notez que RANGE nécessite une colonne ordonnée de type numérique ou date/heure.

Fonctions fenêtres courantes pour l'analyse des séries temporelles

1. Moyenne glissante/mobile

La moyenne glissante, également appelée moyenne mobile, est une technique largement utilisée pour lisser les fluctuations à court terme des données de séries temporelles et mettre en évidence les tendances à plus long terme. Elle est calculée en faisant la moyenne des valeurs sur une fenêtre de temps spécifiée.

Exemple SQL :

SELECT
  date,
  ventes,
  AVG(ventes) OVER (ORDER BY date ROWS BETWEEN 6 PRECEDING AND CURRENT ROW) AS moyenne_mobile_7_jours
FROM
  donnees_ventes;

Cette requête calcule la moyenne mobile des ventes sur 7 jours.

Exemple Python (avec Pandas) :

import pandas as pd

# En supposant que vous avez un DataFrame Pandas appelé 'ventes_df' avec les colonnes 'date' et 'ventes'

ventes_df['moyenne_mobile_7_jours'] = ventes_df['ventes'].rolling(window=7).mean()

Exemple d'application globale : Un détaillant multinational pourrait utiliser une moyenne mobile sur 30 jours pour lisser les fluctuations quotidiennes des ventes et identifier les tendances de vente sous-jacentes dans différentes régions.

2. Somme cumulative

La somme cumulative, également appelée total courant, calcule la somme des valeurs jusqu'à la ligne actuelle. Elle est utile pour suivre la valeur totale accumulée au fil du temps.

Exemple SQL :

SELECT
  date,
  ventes,
  SUM(ventes) OVER (ORDER BY date) AS ventes_cumulees
FROM
  donnees_ventes;

Cette requête calcule la somme cumulative des ventes au fil du temps.

Exemple Python (avec Pandas) :

import pandas as pd

# En supposant que vous avez un DataFrame Pandas appelé 'ventes_df' avec les colonnes 'date' et 'ventes'

ventes_df['ventes_cumulees'] = ventes_df['ventes'].cumsum()

Exemple d'application globale : Une entreprise internationale de commerce électronique peut utiliser les ventes cumulées pour suivre le revenu total généré par le lancement d'un nouveau produit sur différents marchés.

3. Lead et Lag

Les fonctions LEAD et LAG vous permettent d'accéder aux données des lignes suivantes ou précédentes, respectivement. Elles sont utiles pour calculer les variations d'une période à l'autre, identifier les tendances et comparer les valeurs sur différentes périodes.

Exemple SQL :

SELECT
  date,
  ventes,
  LAG(ventes, 1, 0) OVER (ORDER BY date) AS ventes_jour_precedent,
  ventes - LAG(ventes, 1, 0) OVER (ORDER BY date) AS difference_ventes
FROM
  donnees_ventes;

Cette requête calcule la différence de ventes par rapport au jour précédent. La fonction LAG(ventes, 1, 0) récupère la valeur des ventes de la ligne précédente (décalage de 1), et s'il n'y a pas de ligne précédente (par exemple, la première ligne), elle renvoie 0 (la valeur par défaut).

Exemple Python (avec Pandas) :

import pandas as pd

# En supposant que vous avez un DataFrame Pandas appelé 'ventes_df' avec les colonnes 'date' et 'ventes'

ventes_df['ventes_jour_precedent'] = ventes_df['ventes'].shift(1)
ventes_df['difference_ventes'] = ventes_df['ventes'] - ventes_df['ventes_jour_precedent'].fillna(0)

Exemple d'application globale : Une compagnie aérienne mondiale peut utiliser les fonctions lead et lag pour comparer les ventes de billets pour le même itinéraire sur différentes semaines et identifier les fluctuations potentielles de la demande.

4. Rank et Dense Rank

Les fonctions RANK() et DENSE_RANK() attribuent un rang à chaque ligne dans une partition en fonction de l'ordre spécifié. RANK() attribue des rangs avec des trous (par exemple, 1, 2, 2, 4), tandis que DENSE_RANK() attribue des rangs sans trous (par exemple, 1, 2, 2, 3).

Exemple SQL :

SELECT
  date,
  ventes,
  RANK() OVER (ORDER BY ventes DESC) AS rang_ventes,
  DENSE_RANK() OVER (ORDER BY ventes DESC) AS rang_dense_ventes
FROM
  donnees_ventes;

Cette requête classe les valeurs des ventes par ordre décroissant.

Exemple d'application globale : Un marché en ligne mondial peut utiliser les fonctions de classement pour identifier les produits les plus vendus dans chaque pays ou région.

Techniques avancées et applications

1. Combiner les fonctions fenêtres

Les fonctions fenêtres peuvent être combinées pour effectuer des calculs plus complexes. Par exemple, vous pouvez calculer la moyenne mobile de la somme cumulative.

Exemple SQL :

SELECT
  date,
  ventes,
  AVG(ventes_cumulees) OVER (ORDER BY date ROWS BETWEEN 6 PRECEDING AND CURRENT ROW) AS moyenne_mobile_ventes_cumulees
FROM
  (
    SELECT
      date,
      ventes,
      SUM(ventes) OVER (ORDER BY date) AS ventes_cumulees
    FROM
      donnees_ventes
  ) AS sous_requete;

2. Utilisation des fonctions fenêtres avec l'agrégation conditionnelle

Vous pouvez utiliser les fonctions fenêtres conjointement avec l'agrégation conditionnelle (par exemple, en utilisant les instructions CASE) pour effectuer des calculs basés sur des conditions spécifiques.

Exemple SQL :

SELECT
  date,
  ventes,
  AVG(CASE WHEN ventes > 100 THEN ventes ELSE NULL END) OVER (ORDER BY date ROWS BETWEEN 6 PRECEDING AND CURRENT ROW) AS moyenne_mobile_ventes_hautes
FROM
  donnees_ventes;

Cette requête calcule la moyenne mobile des ventes uniquement pour les jours où les ventes sont supérieures à 100.

3. Décomposition des séries temporelles

Les fonctions fenêtres peuvent être utilisées pour décomposer une série temporelle en ses composantes de tendance, saisonnière et résiduelle. Cela implique de calculer des moyennes mobiles pour estimer la tendance, d'identifier les schémas saisonniers, puis de soustraire les composantes de tendance et saisonnières pour obtenir les résidus.

4. Détection des anomalies

Les fonctions fenêtres peuvent être utilisées pour détecter les anomalies dans les données de séries temporelles en calculant les moyennes mobiles et les écarts types. Les points de données qui se situent en dehors d'une certaine plage (par exemple, +/- 3 écarts types de la moyenne mobile) peuvent être signalés comme des anomalies.

Exemples pratiques dans tous les secteurs

1. Finance

• Analyse des cours des actions : Calculer les moyennes mobiles des cours des actions pour identifier les tendances et les signaux potentiels d'achat/vente.
• Gestion des risques : Calculer les écarts types glissants des rendements de portefeuille pour évaluer la volatilité et le risque.
• Détection des fraudes : Identifier les schémas de transactions inhabituels en comparant les montants des transactions actuelles aux moyennes historiques.

2. Commerce de détail

• Prévisions des ventes : Utiliser les moyennes mobiles et les données de ventes cumulées pour prévoir les tendances futures des ventes.
• Gestion des stocks : Optimiser les niveaux de stocks en analysant les données de ventes passées et en identifiant les schémas saisonniers.
• Segmentation de la clientèle : Segmenter les clients en fonction de leur comportement d'achat au fil du temps.

3. Fabrication

• Maintenance prédictive : Utiliser les données des capteurs des équipements pour prévoir les pannes potentielles et planifier la maintenance de manière proactive.
• Contrôle qualité : Surveiller les processus de production et identifier les écarts par rapport aux performances attendues.
• Optimisation des processus : Analyser les données de production pour identifier les goulots d'étranglement et optimiser les processus de fabrication.

4. Soins de santé

• Surveillance des patients : Surveiller les signes vitaux des patients au fil du temps et détecter les anomalies qui peuvent indiquer un problème de santé.
• Détection des épidémies : Suivre la propagation des maladies et identifier les épidémies potentielles.
• Allocation des ressources de soins de santé : Allouer les ressources en fonction des besoins des patients et des schémas de demande historiques.

Choisir le bon outil

Les fonctions fenêtres sont disponibles dans divers outils de traitement de données et langages de programmation, notamment :

• SQL : La plupart des systèmes de gestion de bases de données relationnelles (SGBDR) modernes prennent en charge les fonctions fenêtres, notamment PostgreSQL, MySQL (version 8.0+), SQL Server, Oracle et Amazon Redshift.
• Python : La bibliothèque Pandas offre un excellent support pour les fonctions fenêtres grâce aux méthodes rolling() et expanding().
• Spark : Les API SQL et DataFrame d'Apache Spark prennent également en charge les fonctions fenêtres.

Le choix de l'outil dépend de vos besoins spécifiques et de votre expertise technique. SQL est bien adapté aux données stockées dans des bases de données relationnelles, tandis que Python et Spark sont plus flexibles pour le traitement de grands ensembles de données et l'exécution d'analyses complexes.

Meilleures pratiques

• Comprendre les données : Avant d'appliquer les fonctions fenêtres, comprenez bien les caractéristiques de vos données de séries temporelles, notamment leur fréquence, leur saisonnalité et les valeurs aberrantes potentielles.
• Choisir la taille de fenêtre appropriée : Le choix de la taille de la fenêtre dépend de l'analyse spécifique que vous effectuez. Une taille de fenêtre plus petite sera plus sensible aux fluctuations à court terme, tandis qu'une taille de fenêtre plus grande lissera les données et mettra en évidence les tendances à plus long terme.
• Tenir compte des cas limites : Soyez conscient de la façon dont les fonctions fenêtres gèrent les cas limites, tels que les données manquantes ou le début et la fin de la série temporelle. Utilisez les valeurs par défaut appropriées ou des techniques de filtrage pour gérer ces cas.
• Optimiser les performances : Les fonctions fenêtres peuvent être coûteuses en termes de calcul, en particulier pour les grands ensembles de données. Optimisez vos requêtes et votre code pour améliorer les performances, par exemple en utilisant des index et des stratégies de partitionnement appropriés.
• Documenter votre code : Documentez clairement votre code et vos requêtes pour expliquer le but et la logique des fonctions fenêtres. Cela facilitera la compréhension et la maintenance de votre code par d'autres personnes.

Conclusion

Les fonctions fenêtres sont un outil puissant pour l'analyse des séries temporelles, vous permettant de calculer des moyennes mobiles, des sommes cumulatives, des valeurs de décalage, et d'autres mesures basées sur le temps. En maîtrisant les fonctions fenêtres, vous pouvez extraire des informations précieuses de vos données de séries temporelles et prendre des décisions plus éclairées. Que vous analysiez des données financières, des données de vente, des données de capteurs ou des données de trafic web, les fonctions fenêtres peuvent vous aider à identifier les schémas, les tendances et les anomalies qui seraient difficiles à détecter à l'aide des techniques d'agrégation traditionnelles. En comprenant les concepts clés et la syntaxe des fonctions fenêtres et en suivant les meilleures pratiques, vous pouvez les utiliser efficacement pour résoudre un large éventail de problèmes du monde réel dans divers secteurs.