Ultimate Aeon Framework

A scientific computing skill for working with the Aeon machine learning framework — a Python toolkit designed for time series classification, regression, and clustering. Ultimate Aeon Framework helps you build time series models, perform feature extraction, and benchmark algorithms across standard datasets.

When to Use This Skill

Choose Ultimate Aeon Framework when:

• Building time series classification or regression models
• Comparing multiple time series algorithms on benchmark datasets
• Extracting temporal features from sequential data
• Working with multivariate time series analysis

Consider alternatives when:

• You need general tabular ML (use scikit-learn directly)
• You're doing deep learning on sequences (use PyTorch or TensorFlow)
• You need real-time streaming analysis (use Apache Kafka or Flink)
• You're working with NLP text sequences (use Hugging Face transformers)

Quick Start

Copy
claude "Classify time series data using the Aeon framework"

Copy
# Install Aeon
# pip install aeon

from aeon.classification.distance_based import KNeighborsTimeSeriesClassifier
from aeon.datasets import load_classification

# Load a benchmark dataset
X_train, y_train = load_classification("GunPoint", split="train")
X_test, y_test = load_classification("GunPoint", split="test")

print(f"Train shape: {X_train.shape}")  # (n_samples, n_channels, n_timepoints)
print(f"Classes: {set(y_train)}")

# Train a KNN classifier with DTW distance
clf = KNeighborsTimeSeriesClassifier(distance="dtw", n_neighbors=3)
clf.fit(X_train, y_train)

# Evaluate
accuracy = clf.score(X_test, y_test)
print(f"Accuracy: {accuracy:.4f}")

Core Concepts

Aeon Module Overview

Module	Purpose	Key Classes
classification	Time series classification	KNN, ROCKET, InceptionTime
regression	Time series regression	TimeSeriesForestRegressor
clustering	Time series clustering	TimeSeriesKMeans
transformations	Feature extraction	ROCKET, Catch22, TSFresh
distances	Distance metrics	DTW, ERP, LCSS, MSM
datasets	Benchmark data loading	UCR/UEA archive datasets

Classification Algorithms

Copy
from aeon.classification.convolution_based import RocketClassifier
from aeon.classification.deep_learning import InceptionTimeClassifier
from aeon.classification.dictionary_based import BOSSClassifier
from aeon.classification.interval_based import TimeSeriesForestClassifier

# ROCKET — Fast and accurate (recommended starting point)
rocket = RocketClassifier(num_kernels=10000)
rocket.fit(X_train, y_train)
print(f"ROCKET accuracy: {rocket.score(X_test, y_test):.4f}")

# InceptionTime — Deep learning approach
inception = InceptionTimeClassifier(n_epochs=100)
inception.fit(X_train, y_train)
print(f"InceptionTime accuracy: {inception.score(X_test, y_test):.4f}")

# BOSS — Dictionary-based
boss = BOSSClassifier()
boss.fit(X_train, y_train)
print(f"BOSS accuracy: {boss.score(X_test, y_test):.4f}")

Feature Extraction

Copy
from aeon.transformations.collection.convolution_based import Rocket
from aeon.transformations.collection.feature_based import Catch22

# ROCKET features (random convolutional kernels)
rocket_transform = Rocket(num_kernels=10000)
X_features = rocket_transform.fit_transform(X_train)
print(f"ROCKET features shape: {X_features.shape}")

# Catch22 features (22 canonical time series features)
catch22 = Catch22()
X_catch22 = catch22.fit_transform(X_train)
print(f"Catch22 features shape: {X_catch22.shape}")

# Use extracted features with sklearn classifiers
from sklearn.linear_model import RidgeClassifierCV
ridge = RidgeClassifierCV()
ridge.fit(X_features, y_train)

Configuration

Parameter	Description	Default
distance_metric	DTW, ERP, LCSS, MSM, Euclidean	dtw
num_kernels	Number of random kernels (ROCKET)	10000
n_epochs	Training epochs (deep learning models)	1500
n_estimators	Number of trees (forest methods)	200
random_state	Reproducibility seed	None

Best Practices

1. Start with ROCKET for classification. ROCKET achieves near state-of-the-art accuracy with significantly less training time than deep learning methods. Use it as a baseline before trying more complex approaches — often ROCKET is good enough.

2. Normalize time series before distance-based methods. DTW and other distance metrics are sensitive to scale. Z-normalize each time series (zero mean, unit variance) unless the absolute values carry domain-specific meaning.

3. Use the 3D array format consistently. Aeon expects time series data as (n_samples, n_channels, n_timepoints) arrays. Single-channel data should be (n_samples, 1, n_timepoints), not (n_samples, n_timepoints). Reshape if needed.

4. Benchmark on UCR/UEA datasets first. Before applying algorithms to your custom data, test them on standard benchmark datasets. This verifies your pipeline works correctly and gives you expected accuracy baselines for comparison.

5. Monitor memory with large datasets. Distance matrix computation (especially DTW) is O(n^2) in the number of samples. For datasets with >10,000 samples, use ROCKET or other scalable methods instead of distance-based classifiers.

Common Issues

Shape mismatch error when fitting classifiers. Aeon expects 3D arrays (samples, channels, timepoints). If your data is 2D (samples, timepoints), reshape with X = X.reshape(X.shape[0], 1, X.shape[1]). This is the most common error for new users.

DTW-based classifier is extremely slow. DTW distance computation is O(n*m) per pair where n,m are series lengths. For long time series (>1000 points), use the window parameter to limit the warping path, or switch to ROCKET which is orders of magnitude faster.

Deep learning model doesn't converge. InceptionTime and other deep models need sufficient data (hundreds of samples minimum). Check that your data is normalized, increase n_epochs, and ensure you're using a GPU for training. If the dataset is too small, ROCKET or BOSS will likely perform better.