def __init__(self,
num_features=10000,
max_dilations_per_kernel=32,
random_state=None,
alphas=np.logspace(-3, 3, 13),
*,
normalize=True,
memory=None,
verbose=False,
scoring=None,
**kwargs):
"""
MiniRocketRegressor is recommended for up to 10k time series.
For a larger dataset, you can use MINIROCKET (in Pytorch).
scoring = None --> defaults to r2.
"""
self.steps = [('minirocketmultivariate',
MiniRocketMultivariate(
num_features=num_features,
max_dilations_per_kernel=max_dilations_per_kernel,
random_state=random_state)),
('ridgecv',
RidgeCV(alphas=alphas,
normalize=normalize,
scoring=scoring,
**kwargs))]
self.num_features, self.max_dilations_per_kernel, self.random_state = num_features, max_dilations_per_kernel, random_state
self.alphas, self.normalize, self.scoring, self.kwargs = alphas, normalize, scoring, kwargs
self.memory = memory
self.verbose = verbose
self._validate_steps()
class MiniRocketClassifier(sklearn.pipeline.Pipeline):
def __init__(self,
num_features=10_000,
max_dilations_per_kernel=32,
random_state=None,
alphas=np.logspace(-3, 3, 7),
normalize_features=True,
memory=None,
verbose=False,
scoring=None,
class_weight=None,
**kwargs):
"""
MiniRocketClassifier is recommended for up to 10k time series.
For a larger dataset, you can use MINIROCKET (in Pytorch).
scoring = None --> defaults to accuracy.
"""
self.steps = [('minirocketmultivariate',
MiniRocketMultivariate(
num_features=num_features,
max_dilations_per_kernel=max_dilations_per_kernel,
random_state=random_state)),
('ridgeclassifiercv',
RidgeClassifierCV(alphas=alphas,
normalize=normalize_features,
scoring=scoring,
class_weight=class_weight,
**kwargs))]
store_attr()
self._validate_steps()
def test_minirocket_multivariate_on_basic_motions():
"""Test of MiniRocketMultivariate on basic motions."""
# load training data
X_training, Y_training = load_basic_motions(split="train", return_X_y=True)
# 'fit' MINIROCKET -> infer data dimensions, generate random kernels
minirocket = MiniRocketMultivariate()
minirocket.fit(X_training)
# transform training data
X_training_transform = minirocket.transform(X_training)
# test shape of transformed training data -> (number of training
# examples, nearest multiple of 84 < 10,000)
np.testing.assert_equal(X_training_transform.shape, (len(X_training), 9_996))
# fit classifier
classifier = make_pipeline(
StandardScaler(with_mean=False),
RidgeClassifierCV(alphas=np.logspace(-3, 3, 10)),
)
classifier.fit(X_training_transform, Y_training)
# load test data
X_test, Y_test = load_basic_motions(split="test", return_X_y=True)
# transform test data
X_test_transform = minirocket.transform(X_test)
# test shape of transformed test data -> (number of test examples,
# nearest multiple of 84 < 10,000)
np.testing.assert_equal(X_test_transform.shape, (len(X_test), 9_996))
# predict (alternatively: 'classifier.score(X_test_transform, Y_test)')
predictions = classifier.predict(X_test_transform)
accuracy = accuracy_score(predictions, Y_test)
# test predictions (on BasicMotions, should be 100% accurate)
assert accuracy == 1.0
def _fit(self, X, y):
"""Fit Arsenal to training data.
Parameters
----------
X : 3D np.array of shape = [n_instances, n_dimensions, series_length]
The training data.
y : array-like, shape = [n_instances]
The class labels.
Returns
-------
self :
Reference to self.
Notes
-----
Changes state by creating a fitted model that updates attributes
ending in "_" and sets is_fitted flag to True.
"""
self.n_instances_, self.n_dims_, self.series_length_ = X.shape
time_limit = self.time_limit_in_minutes * 60
start_time = time.time()
train_time = 0
if self.rocket_transform == "rocket":
base_rocket = Rocket(num_kernels=self.num_kernels)
elif self.rocket_transform == "minirocket":
if self.n_dims_ > 1:
base_rocket = MiniRocketMultivariate(
num_kernels=self.num_kernels,
max_dilations_per_kernel=self.max_dilations_per_kernel,
)
else:
base_rocket = MiniRocket(
num_kernels=self.num_kernels,
max_dilations_per_kernel=self.max_dilations_per_kernel,
)
elif self.rocket_transform == "multirocket":
if self.n_dims_ > 1:
base_rocket = MultiRocketMultivariate(
num_kernels=self.num_kernels,
max_dilations_per_kernel=self.max_dilations_per_kernel,
n_features_per_kernel=self.n_features_per_kernel,
)
else:
base_rocket = MultiRocket(
num_kernels=self.num_kernels,
max_dilations_per_kernel=self.max_dilations_per_kernel,
n_features_per_kernel=self.n_features_per_kernel,
)
else:
raise ValueError(f"Invalid Rocket transformer: {self.rocket_transform}")
if time_limit > 0:
self.n_estimators = 0
self.estimators_ = []
self.transformed_data_ = []
while (
train_time < time_limit
and self.n_estimators < self.contract_max_n_estimators
):
fit = Parallel(n_jobs=self._threads_to_use)(
delayed(self._fit_estimator)(
_clone_estimator(
base_rocket,
None
if self.random_state is None
else (255 if self.random_state == 0 else self.random_state)
* 37
* (i + 1),
),
X,
y,
)
for i in range(self._threads_to_use)
)
estimators, transformed_data = zip(*fit)
self.estimators_ += estimators
self.transformed_data_ += transformed_data
self.n_estimators += self._threads_to_use
train_time = time.time() - start_time
else:
fit = Parallel(n_jobs=self._threads_to_use)(
delayed(self._fit_estimator)(
_clone_estimator(
base_rocket,
None
if self.random_state is None
else (255 if self.random_state == 0 else self.random_state)
* 37
* (i + 1),
),
X,
y,
)
for i in range(self.n_estimators)
)
self.estimators_, self.transformed_data_ = zip(*fit)
self.weights_ = []
self._weight_sum = 0
for rocket_pipeline in self.estimators_:
weight = rocket_pipeline.steps[1][1].best_score_
self.weights_.append(weight)
self._weight_sum += weight
return self
def _fit(self, X, y):
"""Build a pipeline containing the Rocket transformer and RidgeClassifierCV.
Parameters
----------
X : 3D np.array of shape = [n_instances, n_dimensions, series_length]
The training data.
y : array-like, shape = [n_instances]
The class labels.
Returns
-------
self :
Reference to self.
Notes
-----
Changes state by creating a fitted model that updates attributes
ending in "_" and sets is_fitted flag to True.
"""
_, n_dims, _ = X.shape
if self.rocket_transform == "rocket":
rocket = Rocket(
num_kernels=self.num_kernels,
random_state=self.random_state,
n_jobs=self._threads_to_use,
)
elif self.rocket_transform == "minirocket":
if n_dims > 1:
rocket = MiniRocketMultivariate(
num_kernels=self.num_kernels,
max_dilations_per_kernel=self.max_dilations_per_kernel,
random_state=self.random_state,
n_jobs=self._threads_to_use,
)
else:
rocket = MiniRocket(
num_kernels=self.num_kernels,
max_dilations_per_kernel=self.max_dilations_per_kernel,
random_state=self.random_state,
n_jobs=self._threads_to_use,
)
elif self.rocket_transform == "multirocket":
if n_dims > 1:
rocket = MultiRocketMultivariate(
num_kernels=self.num_kernels,
max_dilations_per_kernel=self.max_dilations_per_kernel,
n_features_per_kernel=self.n_features_per_kernel,
random_state=self.random_state,
n_jobs=self._threads_to_use,
)
else:
rocket = MultiRocket(
num_kernels=self.num_kernels,
max_dilations_per_kernel=self.max_dilations_per_kernel,
n_features_per_kernel=self.n_features_per_kernel,
random_state=self.random_state,
n_jobs=self._threads_to_use,
)
else:
raise ValueError(
f"Invalid Rocket transformer: {self.rocket_transform}")
self._pipeline = rocket_pipeline = make_pipeline(
rocket,
RidgeClassifierCV(alphas=np.logspace(-3, 3, 10), normalize=True),
)
rocket_pipeline.fit(X, y)
return self