Summary This skill should be used for time series machine learning tasks including classification, regression, clustering, forecasting, anomaly detection, segmentation, and similarity search. Use when working with temporal data, sequential patterns, or time-indexed observations requiring specialized algorithms beyond standard ML approaches. Particularly suited for univariate and multivariate time series analysis with scikit-learn compatible APIs.
Aeon Time Series Machine Learning
Overview
Aeon is a scikit-learn compatible Python toolkit for time series machine learning. It provides state-of-the-art algorithms for 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
Detecting anomalies or change points in temporal sequences
Clustering similar time series patterns
Forecasting future values
Finding repeated patterns (motifs) or unusual subsequences (discords)
Comparing time series with specialized distance metrics
Extracting features from temporal data
Installation
uv pip install aeon
Core Capabilities
1. Time Series Classification
Categorize time series into predefined classes. See references/classification.md for complete algorithm catalog.
Quick Start:
from aeon.classification.convolution_based import RocketClassifier
from aeon.datasets import load_classification
# Load data
X_train, y_train = load_classification("GunPoint", split="train")
X_test, y_test = load_classification("GunPoint", split="test")
# Train classifier
clf = RocketClassifier(n_kernels=10000)
clf.fit(X_train, y_train)
accuracy = clf.score(X_test, y_test)
Algorithm Selection:
Speed + Performance : MiniRocketClassifier, ArsenalMaximum Accuracy :
HIVECOTEV2
InceptionTimeClassifier
Interpretability : ShapeletTransformClassifier, Catch22Classifier
Small Datasets : KNeighborsTimeSeriesClassifier with DTW distance
2. Time Series Regression Predict continuous values from time series. See references/regression.md for algorithms.
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. Time Series Clustering Group similar time series without labels. See references/clustering.md for methods.
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. Forecasting Predict future time series values. See references/forecasting.md for forecasters.
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. Anomaly Detection Identify unusual patterns or outliers. See references/anomaly_detection.md for detectors.
from aeon.anomaly_detection import STOMP
detector = STOMP(window_size=50)
anomaly_scores = detector.fit_predict(y)
# Higher scores indicate anomalies
threshold = np.percentile(anomaly_scores, 95)
anomalies = anomaly_scores > threshold
6. Segmentation Partition time series into regions with change points. See references/segmentation.md.
from aeon.segmentation import ClaSPSegmenter
segmenter = ClaSPSegmenter()
change_points = segmenter.fit_predict(y)
7. Similarity Search Find similar patterns within or across time series. See references/similarity_search.md.
from aeon.similarity_search import StompMotif
# Find recurring patterns
motif_finder = StompMotif(window_size=50, k=3)
motifs = motif_finder.fit_predict(y)
Feature Extraction and Transformations Transform time series for feature engineering. See references/transformations.md.
from aeon.transformations.collection.convolution_based import RocketTransformer
rocket = RocketTransformer()
X_features = rocket.fit_transform(X_train)
# Use features with any sklearn classifier
from sklearn.ensemble import RandomForestClassifier
clf = RandomForestClassifier()
clf.fit(X_features, y_train)
from aeon.transformations.collection.feature_based import Catch22
catch22 = Catch22()
X_features = catch22.fit_transform(X_train)
from aeon.transformations.collection import MinMaxScaler, Normalizer
scaler = Normalizer() # Z-normalization
X_normalized = scaler.fit_transform(X_train)
Distance Metrics Specialized temporal distance measures. See references/distances.md for complete catalog.
from aeon.distances import dtw_distance, dtw_pairwise_distance
# Single distance
distance = dtw_distance(x, y, window=0.1)
# Pairwise distances
distance_matrix = dtw_pairwise_distance(X_train)
# Use with classifiers
from aeon.classification.distance_based import KNeighborsTimeSeriesClassifier
clf = KNeighborsTimeSeriesClassifier(
n_neighbors=5,
distance="dtw",
distance_params={"window": 0.2}
)
Elastic : DTW, DDTW, WDTW, ERP, EDR, LCSS, TWE, MSMLock-step : Euclidean, Manhattan, MinkowskiShape-based : Shape DTW, SBD
Deep Learning Networks Neural architectures for time series. See references/networks.md.
Convolutional: FCNClassifier, ResNetClassifier, InceptionTimeClassifier
Recurrent: RecurrentNetwork, TCNNetwork
Autoencoders: AEFCNClusterer, AEResNetClusterer
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 and Benchmarking Load standard benchmarks and evaluate performance. See references/datasets_benchmarking.md.
from aeon.datasets import load_classification, load_regression
# Classification
X_train, y_train = load_classification("ArrowHead", split="train")
# Regression
X_train, y_train = load_regression("Covid3Month", split="train")
from aeon.benchmarking import get_estimator_results
# Compare with published results
published = get_estimator_results("ROCKET", "GunPoint")
Common Workflows
Classification Pipeline 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)
Feature Extraction + Traditional ML from aeon.transformations.collection import RocketTransformer
from sklearn.ensemble import GradientBoostingClassifier
# Extract features
rocket = RocketTransformer()
X_train_features = rocket.fit_transform(X_train)
X_test_features = rocket.transform(X_test)
# Train traditional ML
clf = GradientBoostingClassifier()
clf.fit(X_train_features, y_train)
predictions = clf.predict(X_test_features)
Anomaly Detection with Visualization 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()
Best Practices
Data Preparation
Normalize : Most algorithms benefit from z-normalization
from aeon.transformations.collection import Normalizer
normalizer = Normalizer()
X_train = normalizer.fit_transform(X_train)
X_test = normalizer.transform(X_test)
Handle Missing Values : Impute before analysis
from aeon.transformations.collection import SimpleImputer
imputer = SimpleImputer(strategy='mean')
X_train = imputer.fit_transform(X_train)
Check Data Format : Aeon expects shape (n_samples, n_channels, n_timepoints)
Model Selection
Start Simple : Begin with ROCKET variants before deep learningUse Validation : Split training data for hyperparameter tuningCompare Baselines : Test against simple methods (1-NN Euclidean, Naive)Consider Resources : ROCKET for speed, deep learning if GPU available
Algorithm Selection Guide
Classification: MiniRocketClassifier
Regression: MiniRocketRegressor
Clustering: TimeSeriesKMeans with Euclidean
Classification: HIVECOTEV2, InceptionTimeClassifier
Regression: InceptionTimeRegressor
Forecasting: ARIMA, TCNForecaster
Classification: ShapeletTransformClassifier, Catch22Classifier
Features: Catch22, TSFresh
Distance-based: KNeighborsTimeSeriesClassifier with DTW
Avoid: Deep learning (requires large data)
Reference Documentation Detailed information available in references/:
classification.md - All classification algorithmsregression.md - Regression methodsclustering.md - Clustering algorithmsforecasting.md - Forecasting approachesanomaly_detection.md - Anomaly detection methodssegmentation.md - Segmentation algorithmssimilarity_search.md - Pattern matching and motif discoverytransformations.md - Feature extraction and preprocessingdistances.md - Time series distance metricsnetworks.md - Deep learning architecturesdatasets_benchmarking.md - Data loading and evaluation tools
Additional Resources 