Aeon Time Series Machine Learning

Overview

Aeon est une boîte à outils Python compatible scikit-learn pour le machine learning sur séries temporelles. Elle fournit des algorithmes de pointe pour la classification, la régression, le clustering, la prévision, la détection d'anomalies, la segmentation et la recherche de similarité.

Quand utiliser cette skill

Appliquez cette skill quand vous :

• Classifiez ou prédisez à partir de données de séries temporelles
• Détectez des anomalies ou des points de changement dans des séquences temporelles
• Regroupez des motifs de séries temporelles similaires
• Prédisez des valeurs futures
• Trouvez des motifs répétés (motifs) ou des sous-séquences inhabituelles (discords)
• Comparez des séries temporelles avec des métriques de distance spécialisées
• Extrayez des caractéristiques à partir de données temporelles

Installation

uv pip install aeon

Capacités principales

1. Classification de séries temporelles

Catégorisez les séries temporelles en classes prédéfinies. Voir references/classification.md pour le catalogue complet des algorithmes.

Démarrage rapide :

from aeon.classification.convolution_based import RocketClassifier
from aeon.datasets import load_classification

# Charger les données
X_train, y_train = load_classification("GunPoint", split="train")
X_test, y_test = load_classification("GunPoint", split="test")

# Entraîner le classificateur
clf = RocketClassifier(n_kernels=10000)
clf.fit(X_train, y_train)
accuracy = clf.score(X_test, y_test)

Sélection d'algorithme :

• Vitesse + Performance : MiniRocketClassifier, Arsenal
• Précision maximale : HIVECOTEV2, InceptionTimeClassifier
• Interprétabilité : ShapeletTransformClassifier, Catch22Classifier
• Petits datasets : KNeighborsTimeSeriesClassifier avec distance DTW

2. Régression de séries temporelles

Prédisez des valeurs continues à partir de séries temporelles. Voir references/regression.md pour les algorithmes.

Démarrage rapide :

from aeon.regression.convolution_based import RocketRegressor
from aeon.datasets import load_regression

X_train, y_train = load_regression("Covid3Month", split="train")
X_test, y_test = load_regression("Covid3Month", split="test")

reg = RocketRegressor()
reg.fit(X_train, y_train)
predictions = reg.predict(X_test)

3. Clustering de séries temporelles

Regroupez des séries temporelles similaires sans labels. Voir references/clustering.md pour les méthodes.

Démarrage rapide :

from aeon.clustering import TimeSeriesKMeans

clusterer = TimeSeriesKMeans(
    n_clusters=3,
    distance="dtw",
    averaging_method="ba"
)
labels = clusterer.fit_predict(X_train)
centers = clusterer.cluster_centers_

4. Prévision

Prédisez les valeurs futures des séries temporelles. Voir references/forecasting.md pour les prévisionnistes.

Démarrage rapide :

from aeon.forecasting.arima import ARIMA

forecaster = ARIMA(order=(1, 1, 1))
forecaster.fit(y_train)
y_pred = forecaster.predict(fh=[1, 2, 3, 4, 5])

5. Détection d'anomalies

Identifiez les motifs inhabituels ou les valeurs aberrantes. Voir references/anomaly_detection.md pour les détecteurs.

Démarrage rapide :

from aeon.anomaly_detection import STOMP

detector = STOMP(window_size=50)
anomaly_scores = detector.fit_predict(y)

# Les scores plus élevés indiquent des anomalies
threshold = np.percentile(anomaly_scores, 95)
anomalies = anomaly_scores > threshold

6. Segmentation

Partitionnez les séries temporelles en régions avec points de changement. Voir references/segmentation.md.

Démarrage rapide :

from aeon.segmentation import ClaSPSegmenter

segmenter = ClaSPSegmenter()
change_points = segmenter.fit_predict(y)

7. Recherche de similarité

Trouvez des motifs similaires au sein ou entre des séries temporelles. Voir references/similarity_search.md.

Démarrage rapide :

from aeon.similarity_search import StompMotif

# Trouver des motifs récurrents
motif_finder = StompMotif(window_size=50, k=3)
motifs = motif_finder.fit_predict(y)

Extraction de caractéristiques et transformations

Transformez les séries temporelles pour l'engineering de caractéristiques. Voir references/transformations.md.

Caractéristiques ROCKET :

from aeon.transformations.collection.convolution_based import RocketTransformer

rocket = RocketTransformer()
X_features = rocket.fit_transform(X_train)

# Utilisez les caractéristiques avec n'importe quel classificateur sklearn
from sklearn.ensemble import RandomForestClassifier
clf = RandomForestClassifier()
clf.fit(X_features, y_train)

Caractéristiques statistiques :

from aeon.transformations.collection.feature_based import Catch22

catch22 = Catch22()
X_features = catch22.fit_transform(X_train)

Prétraitement :

from aeon.transformations.collection import MinMaxScaler, Normalizer

scaler = Normalizer()  # Normalisation z-score
X_normalized = scaler.fit_transform(X_train)

Métriques de distance

Mesures de distance temporelles spécialisées. Voir references/distances.md pour le catalogue complet.

Utilisation :

from aeon.distances import dtw_distance, dtw_pairwise_distance

# Distance unique
distance = dtw_distance(x, y, window=0.1)

# Distances par paire
distance_matrix = dtw_pairwise_distance(X_train)

# Utilisez avec des classificateurs
from aeon.classification.distance_based import KNeighborsTimeSeriesClassifier

clf = KNeighborsTimeSeriesClassifier(
    n_neighbors=5,
    distance="dtw",
    distance_params={"window": 0.2}
)

Distances disponibles :

• Élastiques : DTW, DDTW, WDTW, ERP, EDR, LCSS, TWE, MSM
• Pas à pas : Euclidienne, Manhattan, Minkowski
• Basées sur la forme : Shape DTW, SBD

Réseaux de deep learning

Architectures neuronales pour séries temporelles. Voir references/networks.md.

Architectures :

• Convolutionnelles : FCNClassifier, ResNetClassifier, InceptionTimeClassifier
• Récurrentes : RecurrentNetwork, TCNNetwork
• Autoencodeurs : AEFCNClusterer, AEResNetClusterer

Utilisation :

from aeon.classification.deep_learning import InceptionTimeClassifier

clf = InceptionTimeClassifier(n_epochs=100, batch_size=32)
clf.fit(X_train, y_train)
predictions = clf.predict(X_test)

Datasets et benchmarking

Chargez des benchmarks standards et évaluez les performances. Voir references/datasets_benchmarking.md.

Charger des datasets :

from aeon.datasets import load_classification, load_regression

# Classification
X_train, y_train = load_classification("ArrowHead", split="train")

# Régression
X_train, y_train = load_regression("Covid3Month", split="train")

Benchmarking :

from aeon.benchmarking import get_estimator_results

# Comparez avec les résultats publiés
published = get_estimator_results("ROCKET", "GunPoint")

Workflows courants

Pipeline de classification

from aeon.transformations.collection import Normalizer
from aeon.classification.convolution_based import RocketClassifier
from sklearn.pipeline import Pipeline

pipeline = Pipeline([
    ('normalize', Normalizer()),
    ('classify', RocketClassifier())
])

pipeline.fit(X_train, y_train)
accuracy = pipeline.score(X_test, y_test)

Extraction de caractéristiques + ML traditionnel

from aeon.transformations.collection import RocketTransformer
from sklearn.ensemble import GradientBoostingClassifier

# Extraire les caractéristiques
rocket = RocketTransformer()
X_train_features = rocket.fit_transform(X_train)
X_test_features = rocket.transform(X_test)

# Entraîner le ML traditionnel
clf = GradientBoostingClassifier()
clf.fit(X_train_features, y_train)
predictions = clf.predict(X_test_features)

Détection d'anomalies avec visualisation

from aeon.anomaly_detection import STOMP
import matplotlib.pyplot as plt

detector = STOMP(window_size=50)
scores = detector.fit_predict(y)

plt.figure(figsize=(15, 5))
plt.subplot(2, 1, 1)
plt.plot(y, label='Time Series')
plt.subplot(2, 1, 2)
plt.plot(scores, label='Anomaly Scores', color='red')
plt.axhline(np.percentile(scores, 95), color='k', linestyle='--')
plt.show()

Bonnes pratiques

Préparation des données

1. Normaliser : La plupart des algorithmes bénéficient de la normalisation z-score

   from aeon.transformations.collection import Normalizer
   normalizer = Normalizer()
   X_train = normalizer.fit_transform(X_train)
   X_test = normalizer.transform(X_test)

2. Gérer les valeurs manquantes : Imputez avant l'analyse

   from aeon.transformations.collection import SimpleImputer
   imputer = SimpleImputer(strategy='mean')
   X_train = imputer.fit_transform(X_train)

3. Vérifier le format des données : Aeon attend la forme (n_samples, n_channels, n_timepoints)

Sélection du modèle

1. Commencez simple : Commencez par les variantes ROCKET avant le deep learning
2. Utilisez la validation : Divisez les données d'entraînement pour l'ajustement des hyperparamètres
3. Comparez les baselines : Testez contre les méthodes simples (1-NN Euclidienne, Naive)
4. Considérez les ressources : ROCKET pour la vitesse, deep learning si GPU disponible

Guide de sélection d'algorithme

Pour le prototypage rapide :

• Classification : MiniRocketClassifier
• Régression : MiniRocketRegressor
• Clustering : TimeSeriesKMeans avec Euclidienne

Pour la précision maximale :

• Classification : HIVECOTEV2, InceptionTimeClassifier
• Régression : InceptionTimeRegressor
• Prévision : ARIMA, TCNForecaster

Pour l'interprétabilité :

• Classification : ShapeletTransformClassifier, Catch22Classifier
• Caractéristiques : Catch22, TSFresh

Pour les petits datasets :

• Basé sur la distance : KNeighborsTimeSeriesClassifier avec DTW
• À éviter : Deep learning (nécessite de grandes données)

Documentation de référence

Des informations détaillées sont disponibles dans references/ :

• classification.md - Tous les algorithmes de classification
• regression.md - Méthodes de régression
• clustering.md - Algorithmes de clustering
• forecasting.md - Approches de prévision
• anomaly_detection.md - Méthodes de détection d'anomalies
• segmentation.md - Algorithmes de segmentation
• similarity_search.md - Correspondance de motifs et découverte de motifs
• transformations.md - Extraction de caractéristiques et prétraitement
• distances.md - Métriques de distance pour séries temporelles
• networks.md - Architectures de deep learning
• datasets_benchmarking.md - Outils de chargement de données et d'évaluation

Ressources supplémentaires

• Documentation : https://www.aeon-toolkit.org/
• GitHub : https://github.com/aeon-toolkit/aeon
• Exemples : https://www.aeon-toolkit.org/en/stable/examples.html
• Référence API : https://www.aeon-toolkit.org/en/stable/api_reference.html