ROCKET

ROCKET (RandOm Convolutional KErnel Transform) functions for univariate and multivariate time series.

---

source

RocketClassifier

def RocketClassifier(
    num_kernels:int=10000, normalize_input:bool=True, 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 ROCKET features and a linear classifier

---

source

load_rocket

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

Call self as a function.

---

source

RocketRegressor

def RocketRegressor(
    num_kernels:int=10000, normalize_input:bool=True, 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 ROCKET 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 _FakeRocket(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_rocket_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')
    rocket_mod.Rocket = _FakeRocket
    sktime_mod.transformations = transformations_mod
    transformations_mod.panel = panel_mod
    panel_mod.rocket = rocket_mod
    modules = {
        'sktime': sktime_mod,
        'sktime.transformations': transformations_mod,
        'sktime.transformations.panel': panel_mod,
        'sktime.transformations.panel.rocket': rocket_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_rocket_deps():
    cls = RocketClassifier(normalize_features=False)
    test_eq(cls.transform_input, None)
    cls.fit(X, y)
    reg = RocketRegressor(normalize_features=False)
    test_eq(reg.transform_input, None)
    reg.fit(X, np.arange(len(X), dtype='float64'))

# Univariate classification with sklearn-type API
dsid = 'OliveOil'
fname = 'RocketClassifier'
X_train, y_train, X_test, y_test = get_UCR_data(dsid, Xdtype='float64')
cls = RocketClassifier()
cls.fit(X_train, y_train)
cls.save(fname)
del cls
cls = load_rocket(fname)
print(cls.score(X_test, y_test))

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

0.9

# Multivariate classification with sklearn-type API
dsid = 'NATOPS'
fname = 'RocketClassifier'
X_train, y_train, X_test, y_test = get_UCR_data(dsid, Xdtype='float64')
cls = RocketClassifier()
cls.fit(X_train, y_train)
cls.save(fname)
del cls
cls = load_rocket(fname)
print(cls.score(X_test, y_test))

0.8666666666666667

from sklearn.metrics import mean_squared_error

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

0.03908714523468997

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

2.287302226812576