Feature engineering sur séries temporelles : tirer parti d'itertools en Python

Python itertools est un module natif dédié aux itérateurs. Il devient un outil incontournable pour le feature engineering sur séries temporelles. Si vous construisez vos features à coups de boucles et de copies de datasets, itertools vous permettra d'aller plusieurs fois plus vite tout en consommant bien moins de mémoire.

Qu'est-ce qu'itertools et à quoi sert-il

Le module itertools regroupe des fonctions qui créent des itérateurs rapides et économes en mémoire. Pour les séries temporelles, c'est décisif : au lieu de stocker des listes en mémoire, on génère les features à la volée. Sur des datasets de plusieurs millions ou milliards de points, ce n'est pas seulement pratique, c'est indispensable pour pouvoir travailler tout court.

Les principales fonctions d'itertools pour le feature engineering :

• combinations() — toutes les paires et combinaisons d'éléments (features de lag, interactions entre variables)
• permutations() — toutes les permutations (pour tester l'ordre des features et leur influence)
• islice() — extraction de sous-séquences et de fenêtres glissantes sans copie
• zip_longest() — fusion de séries de longueurs différentes avec gestion des valeurs manquantes
• chain() — fusion d'itérateurs en un seul flux sans copie des données

Exemples pratiques : de l'approche naïve à l'approche scalable

Cas d'école : une série temporelle de prix, sur laquelle il faut construire des features de lag avec des décalages de 1, 2 et 3.

Méthode naïve (lente) :

``python import pandas as pd data = pd.read_csv('prices.csv') for lag in range(1, 4): data[f'price_lag_{lag}'] = data['price'].shift(lag) ``

Le problème : chaque shift() crée une copie du dataset en mémoire. Sur 10 millions de lignes, cela représente ~300 millions d'opérations de copie, plus une consommation mémoire multipliée par 3x.

Avec itertools (rapide et économe) :

``python from itertools import islice prices = [100, 102, 105, 103, 107, 110] for lag in range(1, 4): lagged = list(islice(prices, lag, None)) print(f'lag {lag}: {lagged}') ``

islice ne copie pas la liste : il se contente de déplacer le pointeur à la position voulue. Sur de gros datasets, cela économise des heures de calcul.

Deuxième exemple, les fenêtres glissantes :

``python from itertools import islice, tee def sliding_window(iterable, n): iterables = tee(iterable, n) for i, it in enumerate(iterables): for _ in range(i): next(it, None) return zip(*iterables) prices = [100, 102, 105, 103, 107, 110] windows = list(sliding_window(prices, 3)) ``

Ce code crée des fenêtres glissantes de taille 3 à l'aide d'itérateurs paresseux, sans copier le tableau.

Performances : où se font les gains de mémoire et de temps

Sur des datasets de plusieurs milliards de points :

• Évaluation paresseuse — les éléments sont générés uniquement à la demande, sans être chargés en bloc
• Chaînage des opérations — chain() fusionne les sources sans copies intermédiaires
• Composition — en combinant les fonctions d'itertools, on construit un pipeline complexe avec un minimum de mémoire

Résultat : la consommation mémoire peut baisser d'un facteur 10 à 100. Dans le cloud, cela se traduit par une facture plus légère. Sur une machine locale, des traitements qui ne tenaient pas en RAM deviennent possibles.

Ce que cela change pour vous

Pour les data scientists : vous pouvez travailler sur des datasets qui, jusqu'ici, ne tenaient tout simplement pas en mémoire. Pour les ingénieurs ML : le modèle en production consomme moins de ressources et gagne en stabilité.

itertools n'a rien de magique : c'est une manière native de manipuler les données plus intelligemment. Commencez par les features de lag et les fenêtres glissantes, vous trouverez ensuite d'autres endroits où appliquer l'évaluation paresseuse.