@synsci/cli-darwin-x64 1.1.97 → 1.1.99

package/bin/skills/aeon/references/regression.md

@@ -1,118 +0,0 @@
-# Time Series Regression
-
-Aeon provides time series regressors across 9 categories for predicting continuous values from temporal sequences.
-
-## Convolution-Based Regressors
-
-Apply convolutional kernels for feature extraction:
-
-- `HydraRegressor` - Multi-resolution dilated convolutions
-- `RocketRegressor` - Random convolutional kernels
-- `MiniRocketRegressor` - Simplified ROCKET for speed
-- `MultiRocketRegressor` - Combined ROCKET variants
-- `MultiRocketHydraRegressor` - Merges ROCKET and Hydra approaches
-
-**Use when**: Need fast regression with strong baseline performance.
-
-## Deep Learning Regressors
-
-Neural architectures for end-to-end temporal regression:
-
-- `FCNRegressor` - Fully convolutional network
-- `ResNetRegressor` - Residual blocks with skip connections
-- `InceptionTimeRegressor` - Multi-scale inception modules
-- `TimeCNNRegressor` - Standard CNN architecture
-- `RecurrentRegressor` - RNN/LSTM/GRU variants
-- `MLPRegressor` - Multi-layer perceptron
-- `EncoderRegressor` - Generic encoder wrapper
-- `LITERegressor` - Lightweight inception time ensemble
-- `DisjointCNNRegressor` - Specialized CNN architecture
-
-**Use when**: Large datasets, complex patterns, or need feature learning.
-
-## Distance-Based Regressors
-
-k-nearest neighbors with temporal distance metrics:
-
-- `KNeighborsTimeSeriesRegressor` - k-NN with DTW, LCSS, ERP, or other distances
-
-**Use when**: Small datasets, local similarity patterns, or interpretable predictions.
-
-## Feature-Based Regressors
-
-Extract statistical features before regression:
-
-- `Catch22Regressor` - 22 canonical time-series characteristics
-- `FreshPRINCERegressor` - Pipeline combining multiple feature extractors
-- `SummaryRegressor` - Summary statistics features
-- `TSFreshRegressor` - Automated tsfresh feature extraction
-
-**Use when**: Need interpretable features or domain-specific feature engineering.
-
-## Hybrid Regressors
-
-Combine multiple approaches:
-
-- `RISTRegressor` - Randomized Interval-Shapelet Transformation
-
-**Use when**: Benefit from combining interval and shapelet methods.
-
-## Interval-Based Regressors
-
-Extract features from time intervals:
-
-- `CanonicalIntervalForestRegressor` - Random intervals with decision trees
-- `DrCIFRegressor` - Diverse Representation CIF
-- `TimeSeriesForestRegressor` - Random interval ensemble
-- `RandomIntervalRegressor` - Simple interval-based approach
-- `RandomIntervalSpectralEnsembleRegressor` - Spectral interval features
-- `QUANTRegressor` - Quantile-based interval features
-
-**Use when**: Predictive patterns occur in specific time windows.
-
-## Shapelet-Based Regressors
-
-Use discriminative subsequences for prediction:
-
-- `RDSTRegressor` - Random Dilated Shapelet Transform
-
-**Use when**: Need phase-invariant discriminative patterns.
-
-## Composition Tools
-
-Build custom regression pipelines:
-
-- `RegressorPipeline` - Chain transformers with regressors
-- `RegressorEnsemble` - Weighted ensemble with learnable weights
-- `SklearnRegressorWrapper` - Adapt sklearn regressors for time series
-
-## Utilities
-
-- `DummyRegressor` - Baseline strategies (mean, median)
-- `BaseRegressor` - Abstract base for custom regressors
-- `BaseDeepRegressor` - Base for deep learning regressors
-
-## Quick Start
-
-```python
-from aeon.regression.convolution_based import RocketRegressor
-from aeon.datasets import load_regression
-
-# Load data
-X_train, y_train = load_regression("Covid3Month", split="train")
-X_test, y_test = load_regression("Covid3Month", split="test")
-
-# Train and predict
-reg = RocketRegressor()
-reg.fit(X_train, y_train)
-predictions = reg.predict(X_test)
-```
-
-## Algorithm Selection
-
-- **Speed priority**: MiniRocketRegressor
-- **Accuracy priority**: InceptionTimeRegressor, MultiRocketHydraRegressor
-- **Interpretability**: Catch22Regressor, SummaryRegressor
-- **Small data**: KNeighborsTimeSeriesRegressor
-- **Large data**: Deep learning regressors, ROCKET variants
-- **Interval patterns**: DrCIFRegressor, CanonicalIntervalForestRegressor

package/bin/skills/aeon/references/segmentation.md

@@ -1,163 +0,0 @@
-# Time Series Segmentation
-
-Aeon provides algorithms to partition time series into regions with distinct characteristics, identifying change points and boundaries.
-
-## Segmentation Algorithms
-
-### Binary Segmentation
-- `BinSegmenter` - Recursive binary segmentation
-  - Iteratively splits series at most significant change points
-  - Parameters: `n_segments`, `cost_function`
-  - **Use when**: Known number of segments, hierarchical structure
-
-### Classification-Based
-- `ClaSPSegmenter` - Classification Score Profile
-  - Uses classification performance to identify boundaries
-  - Discovers segments where classification distinguishes neighbors
-  - **Use when**: Segments have different temporal patterns
-
-### Fast Pattern-Based
-- `FLUSSSegmenter` - Fast Low-cost Unipotent Semantic Segmentation
-  - Efficient semantic segmentation using arc crossings
-  - Based on matrix profile
-  - **Use when**: Large time series, need speed and pattern discovery
-
-### Information Theory
-- `InformationGainSegmenter` - Information gain maximization
-  - Finds boundaries maximizing information gain
-  - **Use when**: Statistical differences between segments
-
-### Gaussian Modeling
-- `GreedyGaussianSegmenter` - Greedy Gaussian approximation
-  - Models segments as Gaussian distributions
-  - Incrementally adds change points
-  - **Use when**: Segments follow Gaussian distributions
-
-### Hierarchical Agglomerative
-- `EAggloSegmenter` - Bottom-up merging approach
-  - Estimates change points via agglomeration
-  - **Use when**: Want hierarchical segmentation structure
-
-### Hidden Markov Models
-- `HMMSegmenter` - HMM with Viterbi decoding
-  - Probabilistic state-based segmentation
-  - **Use when**: Segments represent hidden states
-
-### Dimensionality-Based
-- `HidalgoSegmenter` - Heterogeneous Intrinsic Dimensionality Algorithm
-  - Detects changes in local dimensionality
-  - **Use when**: Dimensionality shifts between segments
-
-### Baseline
-- `RandomSegmenter` - Random change point generation
-  - **Use when**: Need null hypothesis baseline
-
-## Quick Start
-
-```python
-from aeon.segmentation import ClaSPSegmenter
-import numpy as np
-
-# Create time series with regime changes
-y = np.concatenate([
-    np.sin(np.linspace(0, 10, 100)),      # Segment 1
-    np.cos(np.linspace(0, 10, 100)),      # Segment 2
-    np.sin(2 * np.linspace(0, 10, 100))   # Segment 3
-])
-
-# Segment the series
-segmenter = ClaSPSegmenter()
-change_points = segmenter.fit_predict(y)
-
-print(f"Detected change points: {change_points}")
-```
-
-## Output Format
-
-Segmenters return change point indices:
-
-```python
-# change_points = [100, 200]  # Boundaries between segments
-# This divides series into: [0:100], [100:200], [200:end]
-```
-
-## Algorithm Selection
-
-- **Speed priority**: FLUSSSegmenter, BinSegmenter
-- **Accuracy priority**: ClaSPSegmenter, HMMSegmenter
-- **Known segment count**: BinSegmenter with n_segments parameter
-- **Unknown segment count**: ClaSPSegmenter, InformationGainSegmenter
-- **Pattern changes**: FLUSSSegmenter, ClaSPSegmenter
-- **Statistical changes**: InformationGainSegmenter, GreedyGaussianSegmenter
-- **State transitions**: HMMSegmenter
-
-## Common Use Cases
-
-### Regime Change Detection
-Identify when time series behavior fundamentally changes:
-
-```python
-from aeon.segmentation import InformationGainSegmenter
-
-segmenter = InformationGainSegmenter(k=3)  # Up to 3 change points
-change_points = segmenter.fit_predict(stock_prices)
-```
-
-### Activity Segmentation
-Segment sensor data into activities:
-
-```python
-from aeon.segmentation import ClaSPSegmenter
-
-segmenter = ClaSPSegmenter()
-boundaries = segmenter.fit_predict(accelerometer_data)
-```
-
-### Seasonal Boundary Detection
-Find season transitions in time series:
-
-```python
-from aeon.segmentation import HMMSegmenter
-
-segmenter = HMMSegmenter(n_states=4)  # 4 seasons
-segments = segmenter.fit_predict(temperature_data)
-```
-
-## Evaluation Metrics
-
-Use segmentation quality metrics:
-
-```python
-from aeon.benchmarking.metrics.segmentation import (
-    count_error,
-    hausdorff_error
-)
-
-# Count error: difference in number of change points
-count_err = count_error(y_true, y_pred)
-
-# Hausdorff: maximum distance between predicted and true points
-hausdorff_err = hausdorff_error(y_true, y_pred)
-```
-
-## Best Practices
-
-1. **Normalize data**: Ensures change detection not dominated by scale
-2. **Choose appropriate metric**: Different algorithms optimize different criteria
-3. **Validate segments**: Visualize to verify meaningful boundaries
-4. **Handle noise**: Consider smoothing before segmentation
-5. **Domain knowledge**: Use expected segment count if known
-6. **Parameter tuning**: Adjust sensitivity parameters (thresholds, penalties)
-
-## Visualization
-
-```python
-import matplotlib.pyplot as plt
-
-plt.figure(figsize=(12, 4))
-plt.plot(y, label='Time Series')
-for cp in change_points:
-    plt.axvline(cp, color='r', linestyle='--', label='Change Point')
-plt.legend()
-plt.show()
-```

package/bin/skills/aeon/references/similarity_search.md

@@ -1,187 +0,0 @@
-# Similarity Search
-
-Aeon provides tools for finding similar patterns within and across time series, including subsequence search, motif discovery, and approximate nearest neighbors.
-
-## Subsequence Nearest Neighbors (SNN)
-
-Find most similar subsequences within a time series.
-
-### MASS Algorithm
-- `MassSNN` - Mueen's Algorithm for Similarity Search
-  - Fast normalized cross-correlation for similarity
-  - Computes distance profile efficiently
-  - **Use when**: Need exact nearest neighbor distances, large series
-
-### STOMP-Based Motif Discovery
-- `StompMotif` - Discovers recurring patterns (motifs)
-  - Finds top-k most similar subsequence pairs
-  - Based on matrix profile computation
-  - **Use when**: Want to discover repeated patterns
-
-### Brute Force Baseline
-- `DummySNN` - Exhaustive distance computation
-  - Computes all pairwise distances
-  - **Use when**: Small series, need exact baseline
-
-## Collection-Level Search
-
-Find similar time series across collections.
-
-### Approximate Nearest Neighbors (ANN)
-- `RandomProjectionIndexANN` - Locality-sensitive hashing
-  - Uses random projections with cosine similarity
-  - Builds index for fast approximate search
-  - **Use when**: Large collection, speed more important than exactness
-
-## Quick Start: Motif Discovery
-
-```python
-from aeon.similarity_search import StompMotif
-import numpy as np
-
-# Create time series with repeated patterns
-pattern = np.sin(np.linspace(0, 2*np.pi, 50))
-y = np.concatenate([
-    pattern + np.random.normal(0, 0.1, 50),
-    np.random.normal(0, 1, 100),
-    pattern + np.random.normal(0, 0.1, 50),
-    np.random.normal(0, 1, 100)
-])
-
-# Find top-3 motifs
-motif_finder = StompMotif(window_size=50, k=3)
-motifs = motif_finder.fit_predict(y)
-
-# motifs contains indices of motif occurrences
-for i, (idx1, idx2) in enumerate(motifs):
-    print(f"Motif {i+1} at positions {idx1} and {idx2}")
-```
-
-## Quick Start: Subsequence Search
-
-```python
-from aeon.similarity_search import MassSNN
-import numpy as np
-
-# Time series to search within
-y = np.sin(np.linspace(0, 20, 500))
-
-# Query subsequence
-query = np.sin(np.linspace(0, 2, 50))
-
-# Find nearest subsequences
-searcher = MassSNN()
-distances = searcher.fit_transform(y, query)
-
-# Find best match
-best_match_idx = np.argmin(distances)
-print(f"Best match at index {best_match_idx}")
-```
-
-## Quick Start: Approximate NN on Collections
-
-```python
-from aeon.similarity_search import RandomProjectionIndexANN
-from aeon.datasets import load_classification
-
-# Load time series collection
-X_train, _ = load_classification("GunPoint", split="train")
-
-# Build index
-ann = RandomProjectionIndexANN(n_projections=8, n_bits=4)
-ann.fit(X_train)
-
-# Find approximate nearest neighbors
-query = X_train[0]
-neighbors, distances = ann.kneighbors(query, k=5)
-```
-
-## Matrix Profile
-
-The matrix profile is a fundamental data structure for many similarity search tasks:
-
-- **Distance Profile**: Distances from a query to all subsequences
-- **Matrix Profile**: Minimum distance for each subsequence to any other
-- **Motif**: Pair of subsequences with minimum distance
-- **Discord**: Subsequence with maximum minimum distance (anomaly)
-
-```python
-from aeon.similarity_search import StompMotif
-
-# Compute matrix profile and find motifs/discords
-mp = StompMotif(window_size=50)
-mp.fit(y)
-
-# Access matrix profile
-profile = mp.matrix_profile_
-profile_indices = mp.matrix_profile_index_
-
-# Find discords (anomalies)
-discord_idx = np.argmax(profile)
-```
-
-## Algorithm Selection
-
-- **Exact subsequence search**: MassSNN
-- **Motif discovery**: StompMotif
-- **Anomaly detection**: Matrix profile (see anomaly_detection.md)
-- **Fast approximate search**: RandomProjectionIndexANN
-- **Small data**: DummySNN for exact results
-
-## Use Cases
-
-### Pattern Matching
-Find where a pattern occurs in a long series:
-
-```python
-# Find heartbeat pattern in ECG data
-searcher = MassSNN()
-distances = searcher.fit_transform(ecg_data, heartbeat_pattern)
-occurrences = np.where(distances < threshold)[0]
-```
-
-### Motif Discovery
-Identify recurring patterns:
-
-```python
-# Find repeated behavioral patterns
-motif_finder = StompMotif(window_size=100, k=5)
-motifs = motif_finder.fit_predict(activity_data)
-```
-
-### Time Series Retrieval
-Find similar time series in database:
-
-```python
-# Build searchable index
-ann = RandomProjectionIndexANN()
-ann.fit(time_series_database)
-
-# Query for similar series
-neighbors = ann.kneighbors(query_series, k=10)
-```
-
-## Best Practices
-
-1. **Window size**: Critical parameter for subsequence methods
-   - Too small: Captures noise
-   - Too large: Misses fine-grained patterns
-   - Rule of thumb: 10-20% of series length
-
-2. **Normalization**: Most methods assume z-normalized subsequences
-   - Handles amplitude variations
-   - Focus on shape similarity
-
-3. **Distance metrics**: Different metrics for different needs
-   - Euclidean: Fast, shape-based
-   - DTW: Handles temporal warping
-   - Cosine: Scale-invariant
-
-4. **Exclusion zone**: For motif discovery, exclude trivial matches
-   - Typically set to 0.5-1.0 × window_size
-   - Prevents finding overlapping occurrences
-
-5. **Performance**:
-   - MASS is O(n log n) vs O(n²) brute force
-   - ANN trades accuracy for speed
-   - GPU acceleration available for some methods

package/bin/skills/aeon/references/transformations.md

@@ -1,246 +0,0 @@
-# Transformations
-
-Aeon provides extensive transformation capabilities for preprocessing, feature extraction, and representation learning from time series data.
-
-## Transformation Types
-
-Aeon distinguishes between:
-- **CollectionTransformers**: Transform multiple time series (collections)
-- **SeriesTransformers**: Transform individual time series
-
-## Collection Transformers
-
-### Convolution-Based Feature Extraction
-
-Fast, scalable feature generation using random kernels:
-
-- `RocketTransformer` - Random convolutional kernels
-- `MiniRocketTransformer` - Simplified ROCKET for speed
-- `MultiRocketTransformer` - Enhanced ROCKET variant
-- `HydraTransformer` - Multi-resolution dilated convolutions
-- `MultiRocketHydraTransformer` - Combines ROCKET and Hydra
-- `ROCKETGPU` - GPU-accelerated variant
-
-**Use when**: Need fast, scalable features for any ML algorithm, strong baseline performance.
-
-### Statistical Feature Extraction
-
-Domain-agnostic features based on time series characteristics:
-
-- `Catch22` - 22 canonical time-series characteristics
-- `TSFresh` - Comprehensive automated feature extraction (100+ features)
-- `TSFreshRelevant` - Feature extraction with relevance filtering
-- `SevenNumberSummary` - Descriptive statistics (mean, std, quantiles)
-
-**Use when**: Need interpretable features, domain-agnostic approach, or feeding traditional ML.
-
-### Dictionary-Based Representations
-
-Symbolic approximations for discrete representations:
-
-- `SAX` - Symbolic Aggregate approXimation
-- `PAA` - Piecewise Aggregate Approximation
-- `SFA` - Symbolic Fourier Approximation
-- `SFAFast` - Optimized SFA
-- `SFAWhole` - SFA on entire series (no windowing)
-- `BORF` - Bag-of-Receptive-Fields
-
-**Use when**: Need discrete/symbolic representation, dimensionality reduction, interpretability.
-
-### Shapelet-Based Features
-
-Discriminative subsequence extraction:
-
-- `RandomShapeletTransform` - Random discriminative shapelets
-- `RandomDilatedShapeletTransform` - Dilated shapelets for multi-scale
-- `SAST` - Scalable And Accurate Subsequence Transform
-- `RSAST` - Randomized SAST
-
-**Use when**: Need interpretable discriminative patterns, phase-invariant features.
-
-### Interval-Based Features
-
-Statistical summaries from time intervals:
-
-- `RandomIntervals` - Features from random intervals
-- `SupervisedIntervals` - Supervised interval selection
-- `QUANTTransformer` - Quantile-based interval features
-
-**Use when**: Predictive patterns localized to specific windows.
-
-### Preprocessing Transformations
-
-Data preparation and normalization:
-
-- `MinMaxScaler` - Scale to [0, 1] range
-- `Normalizer` - Z-normalization (zero mean, unit variance)
-- `Centerer` - Center to zero mean
-- `SimpleImputer` - Fill missing values
-- `DownsampleTransformer` - Reduce temporal resolution
-- `Tabularizer` - Convert time series to tabular format
-
-**Use when**: Need standardization, missing value handling, format conversion.
-
-### Specialized Transformations
-
-Advanced analysis methods:
-
-- `MatrixProfile` - Computes distance profiles for pattern discovery
-- `DWTTransformer` - Discrete Wavelet Transform
-- `AutocorrelationFunctionTransformer` - ACF computation
-- `Dobin` - Distance-based Outlier BasIs using Neighbors
-- `SignatureTransformer` - Path signature methods
-- `PLATransformer` - Piecewise Linear Approximation
-
-### Class Imbalance Handling
-
-- `ADASYN` - Adaptive Synthetic Sampling
-- `SMOTE` - Synthetic Minority Over-sampling
-- `OHIT` - Over-sampling with Highly Imbalanced Time series
-
-**Use when**: Classification with imbalanced classes.
-
-### Pipeline Composition
-
-- `CollectionTransformerPipeline` - Chain multiple transformers
-
-## Series Transformers
-
-Transform individual time series (e.g., for preprocessing in forecasting).
-
-### Statistical Analysis
-
-- `AutoCorrelationSeriesTransformer` - Autocorrelation
-- `StatsModelsACF` - ACF using statsmodels
-- `StatsModelsPACF` - Partial autocorrelation
-
-### Smoothing and Filtering
-
-- `ExponentialSmoothing` - Exponentially weighted moving average
-- `MovingAverage` - Simple or weighted moving average
-- `SavitzkyGolayFilter` - Polynomial smoothing
-- `GaussianFilter` - Gaussian kernel smoothing
-- `BKFilter` - Baxter-King bandpass filter
-- `DiscreteFourierApproximation` - Fourier-based filtering
-
-**Use when**: Need noise reduction, trend extraction, or frequency filtering.
-
-### Dimensionality Reduction
-
-- `PCASeriesTransformer` - Principal component analysis
-- `PlASeriesTransformer` - Piecewise Linear Approximation
-
-### Transformations
-
-- `BoxCoxTransformer` - Variance stabilization
-- `LogTransformer` - Logarithmic scaling
-- `ClaSPTransformer` - Classification Score Profile
-
-### Pipeline Composition
-
-- `SeriesTransformerPipeline` - Chain series transformers
-
-## Quick Start: Feature Extraction
-
-```python
-from aeon.transformations.collection.convolution_based import RocketTransformer
-from aeon.classification.sklearn import RotationForest
-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")
-
-# Extract ROCKET features
-rocket = RocketTransformer()
-X_train_features = rocket.fit_transform(X_train)
-X_test_features = rocket.transform(X_test)
-
-# Use with any sklearn classifier
-clf = RotationForest()
-clf.fit(X_train_features, y_train)
-accuracy = clf.score(X_test_features, y_test)
-```
-
-## Quick Start: Preprocessing Pipeline
-
-```python
-from aeon.transformations.collection import (
-    MinMaxScaler,
-    SimpleImputer,
-    CollectionTransformerPipeline
-)
-
-# Build preprocessing pipeline
-pipeline = CollectionTransformerPipeline([
-    ('imputer', SimpleImputer(strategy='mean')),
-    ('scaler', MinMaxScaler())
-])
-
-X_transformed = pipeline.fit_transform(X_train)
-```
-
-## Quick Start: Series Smoothing
-
-```python
-from aeon.transformations.series import MovingAverage
-
-# Smooth individual time series
-smoother = MovingAverage(window_size=5)
-y_smoothed = smoother.fit_transform(y)
-```
-
-## Algorithm Selection
-
-### For Feature Extraction:
-- **Speed + Performance**: MiniRocketTransformer
-- **Interpretability**: Catch22, TSFresh
-- **Dimensionality reduction**: PAA, SAX, PCA
-- **Discriminative patterns**: Shapelet transforms
-- **Comprehensive features**: TSFresh (with longer runtime)
-
-### For Preprocessing:
-- **Normalization**: Normalizer, MinMaxScaler
-- **Smoothing**: MovingAverage, SavitzkyGolayFilter
-- **Missing values**: SimpleImputer
-- **Frequency analysis**: DWTTransformer, Fourier methods
-
-### For Symbolic Representation:
-- **Fast approximation**: PAA
-- **Alphabet-based**: SAX
-- **Frequency-based**: SFA, SFAFast
-
-## Best Practices
-
-1. **Fit on training data only**: Avoid data leakage
-   ```python
-   transformer.fit(X_train)
-   X_train_tf = transformer.transform(X_train)
-   X_test_tf = transformer.transform(X_test)
-   ```
-
-2. **Pipeline composition**: Chain transformers for complex workflows
-   ```python
-   pipeline = CollectionTransformerPipeline([
-       ('imputer', SimpleImputer()),
-       ('scaler', Normalizer()),
-       ('features', RocketTransformer())
-   ])
-   ```
-
-3. **Feature selection**: TSFresh can generate many features; consider selection
-   ```python
-   from sklearn.feature_selection import SelectKBest
-   selector = SelectKBest(k=100)
-   X_selected = selector.fit_transform(X_features, y)
-   ```
-
-4. **Memory considerations**: Some transformers memory-intensive on large datasets
-   - Use MiniRocket instead of ROCKET for speed
-   - Consider downsampling for very long series
-   - Use ROCKETGPU for GPU acceleration
-
-5. **Domain knowledge**: Choose transformations matching domain:
-   - Periodic data: Fourier-based methods
-   - Noisy data: Smoothing filters
-   - Spike detection: Wavelet transforms