Aeon

Aeon

Overview

Aeon is a comprehensive Python toolkit for time series machine learning, providing state-of-the-art algorithms and classical techniques for analyzing temporal data. Use this skill when working with sequential/​temporal data across seven primary learning tasks: classification, regression, clustering, forecasting, anomaly detection, segmentation, and similarity search.

When to Use This Skill

Apply this skill when:

• Classifying or predicting from time series data (e.g., ECG classification, activity recognition)
• Forecasting future values in temporal sequences (e.g., stock prices, energy demand)
• Detecting anomalies in sensor streams or operational data
• Clustering temporal patterns or discovering motifs
• Segmenting time series into meaningful regions (change point detection)
• Computing distances between time series using specialized metrics (DTW, MSM, ERP)
• Extracting features from temporal data using ROCKET, Catch22, TSFresh, or shapelets
• Building deep learning models for time series with specialized architectures

Core Capabilities

1. Time Series Classification

Classify labeled time series using diverse algorithm families:

• Convolution-based: ROCKET, MiniRocket, MultiRocket, Arsenal, Hydra
• Deep learning: InceptionTime, ResNet, FCN, TimeCNN, LITE
• Dictionary-based: BOSS, TDE, WEASEL, MrSEQL (symbolic representations)
• Distance-based: KNN with elastic distances, Elastic Ensemble, Proximity Forest
• Feature-based: Catch22, FreshPRINCE, Signature classifiers
• Interval-based: CIF, DrCIF, RISE, Random Interval variants
• Shapelet-based: Learning Shapelet, SAST
• Hybrid ensembles: HIVE-COTE V1/​V2

Example:

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

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

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

2. Time Series Regression

Predict continuous values from time series using adapted classification algorithms:

from aeon.regression.convolution_based import RocketRegressor

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

3. Forecasting

Predict future values using statistical and deep learning models:

• Statistical: ARIMA, ETS, Theta, TAR, AutoTAR, TVP
• Naive baselines: NaiveForecaster with seasonal strategies
• Deep learning: TCN (Temporal Convolutional Networks)
• Regression-based: RegressionForecaster with sliding windows

Example:

from aeon.forecasting.naive import NaiveForecaster

forecaster = NaiveForecaster(strategy="last")
forecaster.fit(y_train)
y_pred = forecaster.predict(fh=[1, 2, 3])  # forecast 3 steps ahead

4. Anomaly Detection

Identify outliers in time series data:

• Distance-based: KMeansAD, CBLOF, LOF, STOMP, LeftSTAMPi, MERLIN, ROCKAD
• Distribution-based: COPOD, DWT_MLEAD
• Outlier detection: IsolationForest, OneClassSVM, STRAY
• Collection adapters: ClassificationAdapter, OutlierDetectionAdapter

Example:

from aeon.anomaly_detection import STOMP

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

5. Clustering

Group similar time series without labels:

from aeon.clustering import TimeSeriesKMeans

clusterer = TimeSeriesKMeans(n_clusters=3, distance="dtw")
clusterer.fit(X_collection)
labels = clusterer.predict(X_new)

6. Segmentation

Divide time series into distinct regions or identify change points:

from aeon.segmentation import ClaSPSegmenter

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

7. Similarity Search

Find motifs and nearest neighbors in time series collections using specialized distance metrics and matrix profile techniques.

8. Transformations

Preprocess and extract features from time series:

• Collection transformers: ROCKET, Catch22, TSFresh, Shapelet, SAX, PAA, SFA
• Series transformers: Moving Average, Box-Cox, PCA, Fourier, Savitzky-Golay
• Channel operations: Selection, scoring, balancing
• Data balancing: SMOTE, ADASYN

Example:

from aeon.transformations.collection.convolution_based import Rocket

rocket = Rocket(num_kernels=10000)
X_transformed = rocket.fit_transform(X_train)

9. Distance Metrics

Compute specialized time series distances:

• Warping: DTW, WDTW, DDTW, WDDTW, Shape DTW, ADTW
• Edit distances: ERP, EDR, LCSS, TWE
• Standard: Euclidean, Manhattan, Minkowski, Squared
• Specialized: MSM, SBD

Example:

from aeon.distances import dtw_distance, pairwise_distance

dist = dtw_distance(series1, series2)
dist_matrix = pairwise_distance(X_collection, metric="dtw")

Installation

Install aeon using pip:

# Core dependencies only
pip install -U aeon

# All optional dependencies
pip install -U "aeon[all_extras]"

Or using conda:

conda create -n aeon-env -c conda-forge aeon
conda activate aeon-env

Requirements: Python 3.9, 3.10, 3.11, or 3.12

Data Format

Aeon uses standardized data shapes:

• Collections: (n_cases, n_channels, n_timepoints) as NumPy arrays or pandas DataFrames
• Single series: NumPy arrays or pandas Series
• Variable-length: Supported with padding or specialized handling

Load example datasets:

from aeon.datasets import load_arrow_head, load_airline

# Classification dataset
X_train, y_train = load_arrow_head(split="train")

# Forecasting dataset
y = load_airline()

Workflow Patterns

Pipeline Construction

Combine transformers and estimators using scikit-learn pipelines:

from sklearn.pipeline import Pipeline
from aeon.transformations.collection import Catch22
from aeon.classification.distance_based import KNeighborsTimeSeriesClassifier

pipeline = Pipeline([
    ('features', Catch22()),
    ('classifier', KNeighborsTimeSeriesClassifier())
])
pipeline.fit(X_train, y_train)

Discovery and Tags

Find estimators programmatically:

from aeon.utils.discovery import all_estimators

# Find all classifiers
classifiers = all_estimators(type_filter="classifier")

# Find all forecasters
forecasters = all_estimators(type_filter="forecaster")

References

The skill includes modular reference files with comprehensive details:

references/​learning_tasks.md

In-depth coverage of classification, regression, clustering, and similarity search, including algorithm categories, use cases, and code patterns.

references/​temporal_analysis.md

Detailed information on forecasting, anomaly detection, and segmentation tasks with model descriptions and workflows.

references/​core_modules.md

Comprehensive documentation of transformations, distances, networks, datasets, and benchmarking utilities.

references/​workflows.md

Common workflow patterns, pipeline examples, cross-validation strategies, and integration with scikit-learn.

Load these reference files as needed for detailed information on specific modules or workflows.