# Aeon > Para tareas de machine learning con series temporales: clasificación, regresión, clustering, forecasting, detección de anomalías, segmentación y búsqueda de similitud, con APIs compatibles con scikit-learn. Fuente: https://skillsagentes.com/skills/k-dense-ai/scientific-agent-skills/aeon Markdown: https://skillsagentes.com/skills/k-dense-ai/scientific-agent-skills/aeon.md Repositorio: https://github.com/K-Dense-AI/scientific-agent-skills Autor: K-Dense-AI Licencia: BSD-3-Clause license Actualizado: el mes pasado Coste de contexto: 111 tok instalada, 3.1k tok al activarse, 19k tok con todos los archivos del bundle Bundle: 12 archivos, 74 KB Permisos que pide: read write edit bash ## Instalación Un skill son archivos markdown: los mismos archivos valen para cualquier agente y lo único que cambia es el directorio de destino, es decir la bandera `--agent`. Añade `-g` para instalarlo en todos los proyectos de la máquina. ```bash # Claude Code npx -y skills add K-Dense-AI/scientific-agent-skills --skill aeon --agent claude-code # Cursor npx -y skills add K-Dense-AI/scientific-agent-skills --skill aeon --agent cursor # Codex npx -y skills add K-Dense-AI/scientific-agent-skills --skill aeon --agent codex # Gemini CLI npx -y skills add K-Dense-AI/scientific-agent-skills --skill aeon --agent gemini # Windsurf npx -y skills add K-Dense-AI/scientific-agent-skills --skill aeon --agent windsurf # Cline npx -y skills add K-Dense-AI/scientific-agent-skills --skill aeon --agent cline ``` ## Qué hace - Proporciona algoritmos de series temporales para clasificación, regresión, clustering, forecasting, detección de anomalías, segmentación y búsqueda de similitud - Ofrece una API compatible con scikit-learn (fit/predict) para todos los estimadores - Extrae características de series temporales (ROCKET, Catch22) y calcula distancias especializadas (DTW, entre otras) - Incluye datasets de referencia y herramientas de benchmarking para comparar con resultados publicados - Cubre arquitecturas de deep learning para series temporales (InceptionTime, ResNet, redes recurrentes) ## Cuándo usarla - Clasificar, predecir o agrupar series temporales univariadas o multivariadas - Detectar anomalías o puntos de cambio en secuencias temporales - Pronosticar valores futuros de una serie temporal - Buscar patrones repetidos (motifs) o comparar series con distancias especializadas ## Qué la activa - "Clasifica estas series temporales con aeon" - "Detecta anomalías en esta serie temporal" - "Haz forecasting de esta serie con ARIMA en aeon" - "Agrupa estas series temporales por similitud" ## Antes de instalar - Necesita Python 3.10+ y el paquete aeon (uv pip install); aeon[all_extras] es opcional para deep learning. ## Archivos - SKILL.md — 12 KB - references/anomaly_detection.md — 5 KB - references/classification.md — 5 KB - references/clustering.md — 4 KB - references/datasets_benchmarking.md — 9 KB - references/distances.md — 6 KB - references/forecasting.md — 4 KB - references/networks.md — 8 KB - references/regression.md — 4 KB - references/segmentation.md — 5 KB - references/similarity_search.md — 5 KB - references/transformations.md — 8 KB ## SKILL.md Reproducido tal cual desde K-Dense-AI/scientific-agent-skills bajo BSD-3-Clause license. Esta sección es el documento original y está en inglés. # Aeon Time Series Machine Learning ## Overview Aeon is a scikit-learn compatible Python toolkit for time series machine learning ([aeon-toolkit.org](https://www.aeon-toolkit.org/)). It provides algorithms across classification, regression, clustering, forecasting, anomaly detection, segmentation, similarity search, distances, transformations, benchmarking, and visualization — with a consistent estimator API. **Version note:** Examples target **aeon 1.x** (stable docs: v1.4.0, March 2026). The v1.0 release reworked forecasting and transformations; import paths differ from aeon 0.x/sktime-era code. ## 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 Requires **Python 3.10+** (3.11+ recommended). Pin a 1.x release for reproducibility: ```bash uv pip install "aeon>=1.4,<2" ``` For deep learning forecasters/classifiers and other optional estimators: ```bash uv pip install "aeon[all_extras]>=1.4,<2" ``` On zsh, quote the extras: `uv pip install "aeon[all_extras]>=1.4,<2"`. ### Experimental modules Upstream treats **forecasting**, **anomaly_detection**, **segmentation**, **similarity_search**, and **visualisation** as experimental — interfaces may change between minor releases. Prefer stable modules (classification, regression, clustering, distances, transformations) for production pipelines unless you need these tasks. ## Core Capabilities ### 1. Time Series Classification Categorize time series into predefined classes. See `references/classification.md` for complete algorithm catalog. **Quick Start:** ```python 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`, `Arsenal` - **Maximum 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. **Quick Start:** ```python 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. **Quick Start:** ```python 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 (experimental module in aeon 1.x). See `references/forecasting.md` for forecasters. **Quick Start:** ```python import numpy as np from aeon.forecasting import NaiveForecaster from aeon.forecasting.stats import ARIMA y_train = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]) # Set horizon in the constructor; predict passes the series to forecast from naive = NaiveForecaster(strategy="last", horizon=5) naive.fit(y_train) y_pred = naive.predict(y_train) # ARIMA uses p/d/q (not order=); multi-step via iterative_forecast arima = ARIMA(p=1, d=1, q=1) arima.fit(y_train) y_pred = arima.iterative_forecast(y_train, prediction_horizon=5) ``` ### 5. Anomaly Detection Identify unusual patterns or outliers. See `references/anomaly_detection.md` for detectors. **Quick Start:** ```python 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`. **Quick Start:** ```python 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`. **Quick Start:** ```python 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`. **ROCKET Features:** ```python 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) ``` **Statistical Features:** ```python from aeon.transformations.collection.feature_based import Catch22 catch22 = Catch22() X_features = catch22.fit_transform(X_train) ``` **Preprocessing:** ```python 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. **Usage:** ```python 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} ) ``` **Available Distances:** - **Elastic**: DTW, DDTW, WDTW, ERP, EDR, LCSS, TWE, MSM - **Lock-step**: Euclidean, Manhattan, Minkowski - **Shape-based**: Shape DTW, SBD ## Deep Learning Networks Neural architectures for time series. See `references/networks.md`. **Architectures:** - Convolutional: `FCNClassifier`, `ResNetClassifier`, `InceptionTimeClassifier` - Recurrent: `RecurrentNetwork`, `TCNNetwork` - Autoencoders: `AEFCNClusterer`, `AEResNetClusterer` **Usage:** ```python 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`. **Load Datasets:** ```python from aeon.datasets import load_classification, load_gunpoint, load_regression # Classification (generic loader or dataset-specific helper) X_train, y_train = load_classification("GunPoint", split="train") X_train, y_train = load_gunpoint(split="train") # same UCR dataset # Regression X_train, y_train = load_regression("Covid3Month", split="train") ``` **Benchmarking:** ```python from aeon.benchmarking import get_estimator_results # Compare with published results published = get_estimator_results("ROCKET", "GunPoint") ``` ## Common Workflows ### Classification Pipeline ```python 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 ```python 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 ```python 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 1. **Normalize**: Most algorithms benefit from z-normalization ```python from aeon.transformations.collection import Normalizer normalizer = Normalizer() X_train = normalizer.fit_transform(X_train) X_test = normalizer.transform(X_test) ``` 2. **Handle Missing Values**: Impute before analysis ```python from aeon.transformations.collection import SimpleImputer imputer = SimpleImputer(strategy='mean') X_train = imputer.fit_transform(X_train) ``` 3. **Check Data Format**: Collections use `(n_cases, n_channels, n_timepoints)`; single series use `(n_channels, n_timepoints)` (see [data format](https://www.aeon-toolkit.org/en/stable/api_reference/data_format.html)) ### Model Selection 1. **Start Simple**: Begin with ROCKET variants before deep learning 2. **Use Validation**: Split training data for hyperparameter tuning 3. **Compare Baselines**: Test against simple methods (1-NN Euclidean, Naive) 4. **Consider Resources**: ROCKET for speed, deep learning if GPU available ### Algorithm Selection Guide **For Fast Prototyping:** - Classification: `MiniRocketClassifier` - Regression: `MiniRocketRegressor` - Clustering: `TimeSeriesKMeans` with Euclidean **For Maximum Accuracy:** - Classification: `HIVECOTEV2`, `InceptionTimeClassifier` - Regression: `InceptionTimeRegressor` - Forecasting: `AutoARIMA`, `AutoETS`, `TCNForecaster` (requires `[all_extras]` for deep learning) **For Interpretability:** - Classification: `ShapeletTransformClassifier`, `Catch22Classifier` - Features: `Catch22`, `TSFresh` **For Small Datasets:** - Distance-based: `KNeighborsTimeSeriesClassifier` with DTW - Avoid: Deep learning (requires large data) ## Reference Documentation Detailed information available in `references/`: - `classification.md` - All classification algorithms - `regression.md` - Regression methods - `clustering.md` - Clustering algorithms - `forecasting.md` - Forecasting approaches - `anomaly_detection.md` - Anomaly detection methods - `segmentation.md` - Segmentation algorithms - `similarity_search.md` - Pattern matching and motif discovery - `transformations.md` - Feature extraction and preprocessing - `distances.md` - Time series distance metrics - `networks.md` - Deep learning architectures - `datasets_benchmarking.md` - Data loading and evaluation tools ## Additional Resources - Documentation: https://www.aeon-toolkit.org/ - GitHub: https://github.com/aeon-toolkit/aeon - Examples: https://www.aeon-toolkit.org/en/stable/examples.html - API Reference: https://www.aeon-toolkit.org/en/stable/api_reference.html ## Dónde encaja - Categoría: [Datos y analítica](https://skillsagentes.com/categorias/datos-analitica.md) — Consulta, limpia y visualiza datos sin salir del agente. - Creador: [K-Dense-AI](https://skillsagentes.com/creators/k-dense-ai.md) — 163 skills en el directorio - [Todas las skills](https://skillsagentes.com/skills.md) - [Ranking de instalaciones](https://skillsagentes.com/ranking.md) ## Otras skills del mismo repositorio - [Citation Management](https://skillsagentes.com/skills/k-dense-ai/scientific-agent-skills/citation-management.md): Gestión integral de citas académicas: busca en OpenAlex, PubMed y Google Scholar, extrae metadatos precisos, valida citas y genera entradas BibTeX correctamente formateadas. - [Scientific Slides](https://skillsagentes.com/skills/k-dense-ai/scientific-agent-skills/scientific-slides.md): Crea decks de diapositivas y presentaciones para charlas de investigación: PowerPoint, presentaciones de conferencia, seminarios, defensas de tesis. Da estructura, plantillas, guía de tiempos y validación visual. - [Literature Review](https://skillsagentes.com/skills/k-dense-ai/scientific-agent-skills/literature-review.md): Realiza revisiones bibliográficas sistemáticas y completas usando varias bases académicas (PubMed, arXiv, bioRxiv, Semantic Scholar). Genera markdown y PDF con citas verificadas en varios estilos (APA, Nature, Vancouver). - [Infographics](https://skillsagentes.com/skills/k-dense-ai/scientific-agent-skills/infographics.md): Crea infografías profesionales con Nano Banana Pro AI y refinamiento iterativo inteligente. Usa Gemini 3.6 Flash para revisar la calidad e integra investigación con Perplexity Sonar. Soporta 10 tipos, 8 estilos y paletas para daltonismo. - [Latex Posters](https://skillsagentes.com/skills/k-dense-ai/scientific-agent-skills/latex-posters.md): Crea pósteres de investigación profesionales en LaTeX con beamerposter, tikzposter o baposter, para conferencias y comunicación científica: layout, colores, columnas múltiples e integración de figuras. --- Skills Agentes · [Índice de páginas en markdown](https://skillsagentes.com/sitemap.md) · [Inicio](https://skillsagentes.com/index.md)