MINIROCKET

A Very Fast (Almost) Deterministic Transform for Time Series Classification.

---

source

MiniRocketClassifier

def MiniRocketClassifier(
    num_features:int=10000, max_dilations_per_kernel:int=32, random_state:NoneType=None,
    alphas:tuple=(0.001, 0.01, 0.1, 1.0, 10.0, 100.0, 1000.0), normalize_features:bool=True, memory:NoneType=None,
    verbose:bool=False, scoring:NoneType=None, class_weight:NoneType=None, kwargs:VAR_KEYWORD
):

Time series classification using MINIROCKET features and a linear classifier

---

source

load_minirocket

def load_minirocket(
    fname, path:str='./models'
):

Call self as a function.

---

source

MiniRocketRegressor

def MiniRocketRegressor(
    num_features:int=10000, max_dilations_per_kernel:int=32, random_state:NoneType=None,
    alphas:tuple=(0.001, 0.01, 0.1, 1.0, 10.0, 100.0, 1000.0), normalize_features:bool=True, memory:NoneType=None,
    verbose:bool=False, scoring:NoneType=None, kwargs:VAR_KEYWORD
):

Time series regression using MINIROCKET features and a linear regressor

# Test sklearn Pipeline initialization stays compatible with sklearn>=1.6
import sys, types
from contextlib import contextmanager
from sklearn.base import BaseEstimator, TransformerMixin, ClassifierMixin, RegressorMixin

class _FakeMiniRocket(BaseEstimator, TransformerMixin):
    def __init__(self, **kwargs): self.kwargs = kwargs
    def fit(self, X, y=None): return self
    def transform(self, X):
        X = np.asarray(X)
        return X.reshape(X.shape[0], -1)

class _FakeClassifier(BaseEstimator, ClassifierMixin):
    def __init__(self, **kwargs): self.kwargs = kwargs
    def fit(self, X, y):
        self.classes_ = np.unique(y)
        return self
    def predict(self, X): return np.repeat(self.classes_[0], len(X))

class _FakeRegressor(BaseEstimator, RegressorMixin):
    def __init__(self, **kwargs): self.kwargs = kwargs
    def fit(self, X, y):
        self.y_mean_ = float(np.mean(y))
        return self
    def predict(self, X): return np.full(len(X), self.y_mean_)

@contextmanager
def _patched_minirocket_deps():
    sktime_mod = types.ModuleType('sktime')
    transformations_mod = types.ModuleType('sktime.transformations')
    panel_mod = types.ModuleType('sktime.transformations.panel')
    rocket_mod = types.ModuleType('sktime.transformations.panel.rocket')
    minirocket_mod = types.ModuleType('sktime.transformations.panel.rocket._minirocket_multivariate')
    minirocket_mod.MiniRocketMultivariate = _FakeMiniRocket
    sktime_mod.transformations = transformations_mod
    transformations_mod.panel = panel_mod
    panel_mod.rocket = rocket_mod
    rocket_mod._minirocket_multivariate = minirocket_mod
    modules = {
        'sktime': sktime_mod,
        'sktime.transformations': transformations_mod,
        'sktime.transformations.panel': panel_mod,
        'sktime.transformations.panel.rocket': rocket_mod,
        'sktime.transformations.panel.rocket._minirocket_multivariate': minirocket_mod,
    }
    old_modules = {k: sys.modules.get(k) for k in modules}
    old_classifier, old_regressor = RidgeClassifierCV, RidgeCV
    try:
        sys.modules.update(modules)
        globals()['RidgeClassifierCV'] = _FakeClassifier
        globals()['RidgeCV'] = _FakeRegressor
        yield
    finally:
        globals()['RidgeClassifierCV'] = old_classifier
        globals()['RidgeCV'] = old_regressor
        for k, v in old_modules.items():
            if v is None: sys.modules.pop(k, None)
            else: sys.modules[k] = v

X = np.arange(24, dtype='float64').reshape(6, 1, 4)
y = np.array([0, 1, 0, 1, 0, 1])
with _patched_minirocket_deps():
    cls = MiniRocketClassifier(normalize_features=False)
    test_eq(cls.transform_input, None)
    cls.fit(X, y)
    reg = MiniRocketRegressor(normalize_features=False)
    test_eq(reg.transform_input, None)
    reg.fit(X, np.arange(len(X), dtype='float64'))

---

source

load_minirocket

def load_minirocket(
    fname, path:str='./models'
):

Call self as a function.

---

source

MiniRocketVotingClassifier

def MiniRocketVotingClassifier(
    n_estimators:int=5, weights:NoneType=None, n_jobs:int=-1, num_features:int=10000,
    max_dilations_per_kernel:int=32, random_state:NoneType=None,
    alphas:tuple=(0.001, 0.01, 0.1, 1.0, 10.0, 100.0, 1000.0), normalize_features:bool=True, memory:NoneType=None,
    verbose:bool=False, scoring:NoneType=None, class_weight:NoneType=None, kwargs:VAR_KEYWORD
):

Time series classification ensemble using MINIROCKET features, a linear classifier and majority voting

---

source

get_minirocket_preds

def get_minirocket_preds(
    X, fname, path:str='./models', model:NoneType=None
):

Call self as a function.

---

source

MiniRocketVotingRegressor

def MiniRocketVotingRegressor(
    n_estimators:int=5, weights:NoneType=None, n_jobs:int=-1, num_features:int=10000,
    max_dilations_per_kernel:int=32, random_state:NoneType=None,
    alphas:tuple=(0.001, 0.01, 0.1, 1.0, 10.0, 100.0, 1000.0), normalize_features:bool=True, memory:NoneType=None,
    verbose:bool=False, scoring:NoneType=None, kwargs:VAR_KEYWORD
):

Time series regression ensemble using MINIROCKET features, a linear regressor and a voting regressor

# Univariate classification with sklearn-type API
dsid = 'OliveOil'
fname = 'MiniRocketClassifier'
X_train, y_train, X_test, y_test = get_UCR_data(dsid)
cls = MiniRocketClassifier()
cls.fit(X_train, y_train)
cls.save(fname)
pred = cls.score(X_test, y_test)
del cls
cls = load_minirocket(fname)
test_eq(cls.score(X_test, y_test), pred)

OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.

# Multivariate classification with sklearn-type API
dsid = 'NATOPS'
X_train, y_train, X_test, y_test = get_UCR_data(dsid)
cls = MiniRocketClassifier()
cls.fit(X_train, y_train)
cls.score(X_test, y_test)

0.9277777777777778

# Multivariate classification with sklearn-type API
dsid = 'NATOPS'
X_train, y_train, X_test, y_test = get_UCR_data(dsid)
cls = MiniRocketVotingClassifier(5)
cls.fit(X_train, y_train)
cls.score(X_test, y_test)

OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.
OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.
OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.
OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.
OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.

0.9166666666666666

from sklearn.metrics import mean_squared_error

# Univariate regression with sklearn-type API
dsid = 'Covid3Month'
fname = 'MiniRocketRegressor'
X_train, y_train, X_test, y_test = get_Monash_regression_data(dsid)
if X_train is not None:
    rmse_scorer = make_scorer(mean_squared_error, greater_is_better=False)
    reg = MiniRocketRegressor(scoring=rmse_scorer)
    reg.fit(X_train, y_train)
    reg.save(fname)
    del reg
    reg = load_minirocket(fname)
    y_pred = reg.predict(X_test)
    print(mean_squared_error(y_test, y_pred, squared=False))

0.04099244037606886

# Multivariate regression with sklearn-type API
dsid = 'AppliancesEnergy'
X_train, y_train, X_test, y_test = get_Monash_regression_data(dsid)
if X_train is not None:
    rmse_scorer = make_scorer(mean_squared_error, greater_is_better=False)
    reg = MiniRocketRegressor(scoring=rmse_scorer)
    reg.fit(X_train, y_train)
    reg.save(fname)
    del reg
    reg = load_minirocket(fname)
    y_pred = reg.predict(X_test)
    print(mean_squared_error(y_test, y_pred, squared=False))

2.2938026879322577

# Multivariate regression ensemble with sklearn-type API
if X_train is not None:
    reg = MiniRocketVotingRegressor(5, scoring=rmse_scorer)
    reg.fit(X_train, y_train)
    y_pred = reg.predict(X_test)
    print(mean_squared_error(y_test, y_pred, squared=False))

OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.
OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.

2.286295546348893