def test_col_ens_on_basic_motions():
"""Test of ColumnEnsembleClassifier on basic motions data."""
# load basic motions data
X_train, y_train = load_basic_motions(split="train")
X_test, y_test = load_basic_motions(split="test")
indices = np.random.RandomState(4).choice(len(y_train), 10, replace=False)
fp = FreshPRINCE(
random_state=0,
default_fc_parameters="minimal",
n_estimators=10,
)
tde = TemporalDictionaryEnsemble(
n_parameter_samples=10,
max_ensemble_size=5,
randomly_selected_params=5,
random_state=0,
)
drcif = DrCIF(n_estimators=10, random_state=0, save_transformed_data=True)
estimators = [
("FreshPrince", fp, [0, 1, 2]),
("TDE", tde, [3, 4]),
("DrCIF", drcif, [5]),
]
# train column ensemble
col_ens = ColumnEnsembleClassifier(estimators=estimators)
col_ens.fit(X_train, y_train)
# preds = col_ens.predict(X_test.iloc[indices])
# assert preds[0] == 2
# assert probabilities are the same
probas = col_ens.predict_proba(X_test.iloc[indices])
testing.assert_array_almost_equal(probas,
col_ens_basic_motions_probas,
decimal=2)
def test_col_ens_on_basic_motions():
"""Test of ColumnEnsembleClassifier on basic motions data."""
# load basic motions data
X_train, y_train = load_basic_motions(split="train")
X_test, y_test = load_basic_motions(split="test")
indices = np.random.RandomState(4).choice(len(y_train), 10, replace=False)
tde = TemporalDictionaryEnsemble(
n_parameter_samples=10,
max_ensemble_size=5,
randomly_selected_params=5,
random_state=0,
)
drcif = DrCIF(n_estimators=10, random_state=0)
estimators = [
("TDE", tde, [3, 4]),
("DrCIF", drcif, [5]),
]
# train column ensemble
col_ens = ColumnEnsembleClassifier(estimators=estimators)
col_ens.fit(X_train, y_train)
probas = col_ens.predict_proba(X_test.iloc[indices])
testing.assert_array_almost_equal(probas,
col_ens_basic_motions_probas,
decimal=2)
def set_classifier(cls, resampleId=None):
"""
Basic way of creating the classifier to build using the default settings. This
set up is to help with batch jobs for multiple problems to facilitate easy
reproducability. You can set up bespoke classifier in many other ways.
:param cls: String indicating which classifier you want
:param resampleId: classifier random seed
:return: A classifier.
"""
name = cls.lower()
# Distance based
if name == "pf" or name == "proximityforest":
return ProximityForest(random_state=resampleId)
elif name == "pt" or name == "proximitytree":
return ProximityTree(random_state=resampleId)
elif name == "ps" or name == "proximityStump":
return ProximityStump(random_state=resampleId)
elif name == "dtwcv" or name == "kneighborstimeseriesclassifier":
return KNeighborsTimeSeriesClassifier(distance="dtwcv")
elif name == "dtw" or name == "1nn-dtw":
return KNeighborsTimeSeriesClassifier(distance="dtw")
elif name == "msm" or name == "1nn-msm":
return KNeighborsTimeSeriesClassifier(distance="msm")
elif name == "ee" or name == "elasticensemble":
return ElasticEnsemble()
elif name == "shapedtw":
return ShapeDTW()
# Dictionary based
elif name == "boss" or name == "bossensemble":
return BOSSEnsemble(random_state=resampleId)
elif name == "cboss" or name == "contractableboss":
return ContractableBOSS(random_state=resampleId)
elif name == "tde" or name == "temporaldictionaryensemble":
return TemporalDictionaryEnsemble(random_state=resampleId)
elif name == "weasel":
return WEASEL(random_state=resampleId)
elif name == "muse":
return MUSE(random_state=resampleId)
# Interval based
elif name == "rise" or name == "randomintervalspectralforest":
return RandomIntervalSpectralForest(random_state=resampleId)
elif name == "tsf" or name == "timeseriesforestclassifier":
return TimeSeriesForestClassifier(random_state=resampleId)
elif name == "cif" or name == "canonicalintervalforest":
return CanonicalIntervalForest(random_state=resampleId)
elif name == "drcif":
return DrCIF(random_state=resampleId)
# Shapelet based
elif name == "stc" or name == "shapelettransformclassifier":
return ShapeletTransformClassifier(
random_state=resampleId, time_contract_in_mins=1
)
elif name == "mrseql" or name == "mrseqlclassifier":
return MrSEQLClassifier(seql_mode="fs", symrep=["sax", "sfa"])
elif name == "rocket":
return ROCKETClassifier(random_state=resampleId)
elif name == "arsenal":
return Arsenal(random_state=resampleId)
# Hybrid
elif name == "catch22":
return Catch22ForestClassifier(random_state=resampleId)
elif name == "hivecotev1":
return HIVECOTEV1(random_state=resampleId)
else:
raise Exception("UNKNOWN CLASSIFIER")
def set_classifier(cls, resample_id=None, train_file=False):
"""Construct a classifier.
Basic way of creating the classifier to build using the default settings. This
set up is to help with batch jobs for multiple problems to facilitate easy
reproducibility for use with load_and_run_classification_experiment. You can pass a
classifier object instead to run_classification_experiment.
Parameters
----------
cls : str
String indicating which classifier you want.
resample_id : int or None, default=None
Classifier random seed.
train_file : bool, default=False
Whether a train file is being produced.
Return
------
classifier : A BaseClassifier.
The classifier matching the input classifier name.
"""
name = cls.lower()
# Dictionary based
if name == "boss" or name == "bossensemble":
return BOSSEnsemble(random_state=resample_id)
elif name == "cboss" or name == "contractableboss":
return ContractableBOSS(random_state=resample_id)
elif name == "tde" or name == "temporaldictionaryensemble":
return TemporalDictionaryEnsemble(
random_state=resample_id, save_train_predictions=train_file
)
elif name == "weasel":
return WEASEL(random_state=resample_id)
elif name == "muse":
return MUSE(random_state=resample_id)
# Distance based
elif name == "pf" or name == "proximityforest":
return ProximityForest(random_state=resample_id)
elif name == "pt" or name == "proximitytree":
return ProximityTree(random_state=resample_id)
elif name == "ps" or name == "proximityStump":
return ProximityStump(random_state=resample_id)
elif name == "dtwcv" or name == "kneighborstimeseriesclassifier":
return KNeighborsTimeSeriesClassifier(distance="dtwcv")
elif name == "dtw" or name == "1nn-dtw":
return KNeighborsTimeSeriesClassifier(distance="dtw")
elif name == "msm" or name == "1nn-msm":
return KNeighborsTimeSeriesClassifier(distance="msm")
elif name == "ee" or name == "elasticensemble":
return ElasticEnsemble(random_state=resample_id)
elif name == "shapedtw":
return ShapeDTW()
# Feature based
elif name == "catch22":
return Catch22Classifier(
random_state=resample_id, estimator=RandomForestClassifier(n_estimators=500)
)
elif name == "matrixprofile":
return MatrixProfileClassifier(random_state=resample_id)
elif name == "signature":
return SignatureClassifier(
random_state=resample_id,
estimator=RandomForestClassifier(n_estimators=500),
)
elif name == "tsfresh":
return TSFreshClassifier(
random_state=resample_id, estimator=RandomForestClassifier(n_estimators=500)
)
elif name == "tsfresh-r":
return TSFreshClassifier(
random_state=resample_id,
estimator=RandomForestClassifier(n_estimators=500),
relevant_feature_extractor=True,
)
# Hybrid
elif name == "hc1" or name == "hivecotev1":
return HIVECOTEV1(random_state=resample_id)
elif name == "hc2" or name == "hivecotev2":
return HIVECOTEV2(random_state=resample_id)
# Interval based
elif name == "rise" or name == "randomintervalspectralforest":
return RandomIntervalSpectralEnsemble(
random_state=resample_id, n_estimators=500
)
elif name == "tsf" or name == "timeseriesforestclassifier":
return TimeSeriesForestClassifier(random_state=resample_id, n_estimators=500)
elif name == "cif" or name == "canonicalintervalforest":
return CanonicalIntervalForest(random_state=resample_id, n_estimators=500)
elif name == "stsf" or name == "supervisedtimeseriesforest":
return SupervisedTimeSeriesForest(random_state=resample_id, n_estimators=500)
elif name == "drcif":
return DrCIF(
random_state=resample_id, n_estimators=500, save_transformed_data=train_file
)
# Kernel based
elif name == "rocket":
return ROCKETClassifier(random_state=resample_id)
elif name == "arsenal":
return Arsenal(random_state=resample_id, save_transformed_data=train_file)
# Shapelet based
elif name == "stc" or name == "shapelettransformclassifier":
return ShapeletTransformClassifier(
random_state=resample_id, save_transformed_data=train_file
)
elif name == "mrseql" or name == "mrseqlclassifier":
return MrSEQLClassifier(seql_mode="fs", symrep=["sax", "sfa"])
else:
raise Exception("UNKNOWN CLASSIFIER")
class HIVECOTEV2(BaseClassifier):
"""Hierarchical Vote Collective of Transformation-based Ensembles (HIVE-COTE) V2.
An ensemble of the STC, DrCIF, Arsenal and TDE classifiers from different feature
representations using the CAWPE structure as described in [1].
Parameters
----------
stc_params : dict or None, default=None
Parameters for the ShapeletTransformClassifier module. If None, uses the
default parameters with a 2 hour transform contract.
drcif_params : dict or None, default=None
Parameters for the DrCIF module. If None, uses the default parameters with
n_estimators set to 500.
arsenal_params : dict or None, default=None
Parameters for the Arsenal module. If None, uses the default parameters.
tde_params : dict or None, default=None
Parameters for the TemporalDictionaryEnsemble module. If None, uses the default
parameters.
time_limit_in_minutes : int, default=0
Time contract to limit build time in minutes, overriding
n_estimators/n_parameter_samples for each component.
Default of 0 means n_estimators/n_parameter_samples for each component is used.
save_component_probas : bool, default=False
When predict/predict_proba is called, save each HIVE-COTEV2 component
probability predictions in component_probas.
verbose : int, default=0
Level of output printed to the console (for information only).
n_jobs : int, default=1
The number of jobs to run in parallel for both `fit` and `predict`.
``-1`` means using all processors.
random_state : int or None, default=None
Seed for random number generation.
Attributes
----------
n_classes_ : int
The number of classes.
classes_ : list
The unique class labels.
stc_weight_ : float
The weight for STC probabilities.
drcif_weight_ : float
The weight for DrCIF probabilities.
arsenal_weight_ : float
The weight for Arsenal probabilities.
tde_weight_ : float
The weight for TDE probabilities.
component_probas : dict
Only used if save_component_probas is true. Saved probability predictions for
each HIVE-COTEV2 component.
See Also
--------
HIVECOTEV1, ShapeletTransformClassifier, DrCIF, Arsenal, TemporalDictionaryEnsemble
Notes
-----
For the Java version, see
`https://github.com/uea-machine-learning/tsml/blob/master/src/main/java/
tsml/classifiers/hybrids/HIVE_COTE.java`_.
References
----------
.. [1] Middlehurst, Matthew, James Large, Michael Flynn, Jason Lines, Aaron Bostrom,
and Anthony Bagnall. "HIVE-COTE 2.0: a new meta ensemble for time series
classification." Machine Learning (2021).
Examples
--------
>>> from sktime.classification.hybrid import HIVECOTEV2
>>> from sktime.contrib.vector_classifiers._rotation_forest import RotationForest
>>> from sktime.datasets import load_unit_test
>>> X_train, y_train = load_unit_test(split="train", return_X_y=True)
>>> X_test, y_test = load_unit_test(split="test", return_X_y=True)
>>> clf = HIVECOTEV2(
... stc_params={
... "estimator": RotationForest(n_estimators=3),
... "n_shapelet_samples": 500,
... "max_shapelets": 20,
... "batch_size": 100,
... },
... drcif_params={"n_estimators": 10},
... arsenal_params={"num_kernels": 100, "n_estimators": 5},
... tde_params={
... "n_parameter_samples": 25,
... "max_ensemble_size": 5,
... "randomly_selected_params": 10,
... },
... )
>>> clf.fit(X_train, y_train)
HIVECOTEV2(...)
>>> y_pred = clf.predict(X_test)
"""
_tags = {
"capability:multivariate": True,
"capability:contractable": True,
"capability:multithreading": True,
}
def __init__(
self,
stc_params=None,
drcif_params=None,
arsenal_params=None,
tde_params=None,
time_limit_in_minutes=0,
save_component_probas=False,
verbose=0,
n_jobs=1,
random_state=None,
):
self.stc_params = stc_params
self.drcif_params = drcif_params
self.arsenal_params = arsenal_params
self.tde_params = tde_params
self.time_limit_in_minutes = time_limit_in_minutes
self.save_component_probas = save_component_probas
self.verbose = verbose
self.n_jobs = n_jobs
self.random_state = random_state
self.stc_weight_ = 0
self.drcif_weight_ = 0
self.arsenal_weight_ = 0
self.tde_weight_ = 0
self.component_probas = {}
self._stc_params = stc_params
self._drcif_params = drcif_params
self._arsenal_params = arsenal_params
self._tde_params = tde_params
self._stc = None
self._drcif = None
self._arsenal = None
self._tde = None
super(HIVECOTEV2, self).__init__()
def _fit(self, X, y):
"""Fit HIVE-COTE 2.0 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.
"""
# Default values from HC2 paper
if self.stc_params is None:
self._stc_params = {"transform_limit_in_minutes": 120}
if self.drcif_params is None:
self._drcif_params = {"n_estimators": 500}
if self.arsenal_params is None:
self._arsenal_params = {}
if self.tde_params is None:
self._tde_params = {}
# If we are contracting split the contract time between each algorithm
if self.time_limit_in_minutes > 0:
# Leave 1/3 for train estimates
ct = self.time_limit_in_minutes / 6
self._stc_params["time_limit_in_minutes"] = ct
self._drcif_params["time_limit_in_minutes"] = ct
self._arsenal_params["time_limit_in_minutes"] = ct
self._tde_params["time_limit_in_minutes"] = ct
# Build STC
self._stc = ShapeletTransformClassifier(
**self._stc_params,
save_transformed_data=True,
random_state=self.random_state,
n_jobs=self._threads_to_use,
)
self._stc.fit(X, y)
if self.verbose > 0:
print("STC ", datetime.now().strftime("%H:%M:%S %d/%m/%Y")) # noqa
# Find STC weight using train set estimate
train_probs = self._stc._get_train_probs(X, y)
train_preds = self._stc.classes_[np.argmax(train_probs, axis=1)]
self.stc_weight_ = accuracy_score(y, train_preds) ** 4
if self.verbose > 0:
print( # noqa
"STC train estimate ",
datetime.now().strftime("%H:%M:%S %d/%m/%Y"),
)
print("STC weight = " + str(self.stc_weight_)) # noqa
# Build DrCIF
self._drcif = DrCIF(
**self._drcif_params,
save_transformed_data=True,
random_state=self.random_state,
n_jobs=self._threads_to_use,
)
self._drcif.fit(X, y)
if self.verbose > 0:
print("DrCIF ", datetime.now().strftime("%H:%M:%S %d/%m/%Y")) # noqa
# Find DrCIF weight using train set estimate
train_probs = self._drcif._get_train_probs(X, y)
train_preds = self._drcif.classes_[np.argmax(train_probs, axis=1)]
self.drcif_weight_ = accuracy_score(y, train_preds) ** 4
if self.verbose > 0:
print( # noqa
"DrCIF train estimate ",
datetime.now().strftime("%H:%M:%S %d/%m/%Y"),
)
print("DrCIF weight = " + str(self.drcif_weight_)) # noqa
# Build Arsenal
self._arsenal = Arsenal(
**self._arsenal_params,
save_transformed_data=True,
random_state=self.random_state,
n_jobs=self._threads_to_use,
)
self._arsenal.fit(X, y)
if self.verbose > 0:
print("Arsenal ", datetime.now().strftime("%H:%M:%S %d/%m/%Y")) # noqa
# Find Arsenal weight using train set estimate
train_probs = self._arsenal._get_train_probs(X, y)
train_preds = self._arsenal.classes_[np.argmax(train_probs, axis=1)]
self.arsenal_weight_ = accuracy_score(y, train_preds) ** 4
if self.verbose > 0:
print( # noqa
"Arsenal train estimate ",
datetime.now().strftime("%H:%M:%S %d/%m/%Y"),
)
print("Arsenal weight = " + str(self.arsenal_weight_)) # noqa
# Build TDE
self._tde = TemporalDictionaryEnsemble(
**self._tde_params,
save_train_predictions=True,
random_state=self.random_state,
n_jobs=self._threads_to_use,
)
self._tde.fit(X, y)
if self.verbose > 0:
print("TDE ", datetime.now().strftime("%H:%M:%S %d/%m/%Y")) # noqa
# Find TDE weight using train set estimate
train_probs = self._tde._get_train_probs(X, y, train_estimate_method="loocv")
train_preds = self._tde.classes_[np.argmax(train_probs, axis=1)]
self.tde_weight_ = accuracy_score(y, train_preds) ** 4
if self.verbose > 0:
print( # noqa
"TDE train estimate ",
datetime.now().strftime("%H:%M:%S %d/%m/%Y"),
)
print("TDE weight = " + str(self.tde_weight_)) # noqa
return self
def _predict(self, X):
"""Predicts labels for sequences in X.
Parameters
----------
X : 3D np.array of shape = [n_instances, n_dimensions, series_length]
The data to make predictions for.
Returns
-------
y : array-like, shape = [n_instances]
Predicted class labels.
"""
rng = check_random_state(self.random_state)
return np.array(
[
self.classes_[int(rng.choice(np.flatnonzero(prob == prob.max())))]
for prob in self.predict_proba(X)
]
)
def _predict_proba(self, X, return_component_probas=False):
"""Predicts labels probabilities for sequences in X.
Parameters
----------
X : 3D np.array of shape = [n_instances, n_dimensions, series_length]
The data to make predict probabilities for.
Returns
-------
y : array-like, shape = [n_instances, n_classes_]
Predicted probabilities using the ordering in classes_.
"""
dists = np.zeros((X.shape[0], self.n_classes_))
# Call predict proba on each classifier, multiply the probabilities by the
# classifiers weight then add them to the current HC2 probabilities
stc_probas = self._stc.predict_proba(X)
dists = np.add(
dists,
stc_probas * (np.ones(self.n_classes_) * self.stc_weight_),
)
drcif_probas = self._drcif.predict_proba(X)
dists = np.add(
dists,
drcif_probas * (np.ones(self.n_classes_) * self.drcif_weight_),
)
arsenal_probas = self._arsenal.predict_proba(X)
dists = np.add(
dists,
arsenal_probas * (np.ones(self.n_classes_) * self.arsenal_weight_),
)
tde_probas = self._tde.predict_proba(X)
dists = np.add(
dists,
tde_probas * (np.ones(self.n_classes_) * self.tde_weight_),
)
if self.save_component_probas:
self.component_probas = {
"STC": stc_probas,
"DrCIF": drcif_probas,
"Arsenal": arsenal_probas,
"TDE": tde_probas,
}
# Make each instances probability array sum to 1 and return
return dists / dists.sum(axis=1, keepdims=True)
def _fit(self, X, y):
"""Fit HIVE-COTE 2.0 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.
"""
# Default values from HC2 paper
if self.stc_params is None:
self._stc_params = {"transform_limit_in_minutes": 120}
if self.drcif_params is None:
self._drcif_params = {"n_estimators": 500}
if self.arsenal_params is None:
self._arsenal_params = {}
if self.tde_params is None:
self._tde_params = {}
# If we are contracting split the contract time between each algorithm
if self.time_limit_in_minutes > 0:
# Leave 1/3 for train estimates
ct = self.time_limit_in_minutes / 6
self._stc_params["time_limit_in_minutes"] = ct
self._drcif_params["time_limit_in_minutes"] = ct
self._arsenal_params["time_limit_in_minutes"] = ct
self._tde_params["time_limit_in_minutes"] = ct
# Build STC
self._stc = ShapeletTransformClassifier(
**self._stc_params,
save_transformed_data=True,
random_state=self.random_state,
n_jobs=self._threads_to_use,
)
self._stc.fit(X, y)
if self.verbose > 0:
print("STC ", datetime.now().strftime("%H:%M:%S %d/%m/%Y")) # noqa
# Find STC weight using train set estimate
train_probs = self._stc._get_train_probs(X, y)
train_preds = self._stc.classes_[np.argmax(train_probs, axis=1)]
self.stc_weight_ = accuracy_score(y, train_preds) ** 4
if self.verbose > 0:
print( # noqa
"STC train estimate ",
datetime.now().strftime("%H:%M:%S %d/%m/%Y"),
)
print("STC weight = " + str(self.stc_weight_)) # noqa
# Build DrCIF
self._drcif = DrCIF(
**self._drcif_params,
save_transformed_data=True,
random_state=self.random_state,
n_jobs=self._threads_to_use,
)
self._drcif.fit(X, y)
if self.verbose > 0:
print("DrCIF ", datetime.now().strftime("%H:%M:%S %d/%m/%Y")) # noqa
# Find DrCIF weight using train set estimate
train_probs = self._drcif._get_train_probs(X, y)
train_preds = self._drcif.classes_[np.argmax(train_probs, axis=1)]
self.drcif_weight_ = accuracy_score(y, train_preds) ** 4
if self.verbose > 0:
print( # noqa
"DrCIF train estimate ",
datetime.now().strftime("%H:%M:%S %d/%m/%Y"),
)
print("DrCIF weight = " + str(self.drcif_weight_)) # noqa
# Build Arsenal
self._arsenal = Arsenal(
**self._arsenal_params,
save_transformed_data=True,
random_state=self.random_state,
n_jobs=self._threads_to_use,
)
self._arsenal.fit(X, y)
if self.verbose > 0:
print("Arsenal ", datetime.now().strftime("%H:%M:%S %d/%m/%Y")) # noqa
# Find Arsenal weight using train set estimate
train_probs = self._arsenal._get_train_probs(X, y)
train_preds = self._arsenal.classes_[np.argmax(train_probs, axis=1)]
self.arsenal_weight_ = accuracy_score(y, train_preds) ** 4
if self.verbose > 0:
print( # noqa
"Arsenal train estimate ",
datetime.now().strftime("%H:%M:%S %d/%m/%Y"),
)
print("Arsenal weight = " + str(self.arsenal_weight_)) # noqa
# Build TDE
self._tde = TemporalDictionaryEnsemble(
**self._tde_params,
save_train_predictions=True,
random_state=self.random_state,
n_jobs=self._threads_to_use,
)
self._tde.fit(X, y)
if self.verbose > 0:
print("TDE ", datetime.now().strftime("%H:%M:%S %d/%m/%Y")) # noqa
# Find TDE weight using train set estimate
train_probs = self._tde._get_train_probs(X, y, train_estimate_method="loocv")
train_preds = self._tde.classes_[np.argmax(train_probs, axis=1)]
self.tde_weight_ = accuracy_score(y, train_preds) ** 4
if self.verbose > 0:
print( # noqa
"TDE train estimate ",
datetime.now().strftime("%H:%M:%S %d/%m/%Y"),
)
print("TDE weight = " + str(self.tde_weight_)) # noqa
return self
_reproduce_classification_unit_test(
MUSE(random_state=0, window_inc=4, use_first_order_differences=False)
),
)
_print_array(
"MUSE - BasicMotions",
_reproduce_classification_basic_motions(
MUSE(random_state=0, window_inc=4, use_first_order_differences=False)
),
)
_print_array(
"TemporalDictionaryEnsemble - UnitTest",
_reproduce_classification_unit_test(
TemporalDictionaryEnsemble(
n_parameter_samples=10,
max_ensemble_size=5,
randomly_selected_params=5,
random_state=0,
)
),
)
_print_array(
"TemporalDictionaryEnsemble - BasicMotions",
_reproduce_classification_basic_motions(
TemporalDictionaryEnsemble(
n_parameter_samples=10,
max_ensemble_size=5,
randomly_selected_params=5,
random_state=0,
)
),
)
def set_classifier(cls, resampleId):
"""
Basic way of determining the classifier to build. To differentiate settings just and another elif. So, for example, if
you wanted tuned TSF, you just pass TuneTSF and set up the tuning mechanism in the elif.
This may well get superceded, it is just how e have always done it
:param cls: String indicating which classifier you want
:return: A classifier.
"""
if cls.lower() == "pf":
return pf.ProximityForest(random_state=resampleId)
elif cls.lower() == "pt":
return pf.ProximityTree(random_state=resampleId)
elif cls.lower() == "ps":
return pf.ProximityStump(random_state=resampleId)
elif cls.lower() == "rise":
return fb.RandomIntervalSpectralForest(random_state=resampleId)
elif cls.lower() == "tsf":
return ib.TimeSeriesForest(random_state=resampleId)
elif cls.lower() == "cif":
return CanonicalIntervalForest(random_state=resampleId)
elif cls.lower() == "boss":
return BOSSEnsemble(random_state=resampleId)
elif cls.lower() == "cboss":
return ContractableBOSS(random_state=resampleId)
elif cls.lower() == "tde":
return TemporalDictionaryEnsemble(random_state=resampleId)
elif cls.lower() == "st":
return st.ShapeletTransformClassifier(time_contract_in_mins=1500)
elif cls.lower() == "dtwcv":
return nn.KNeighborsTimeSeriesClassifier(metric="dtwcv")
elif cls.lower() == "ee" or cls.lower() == "elasticensemble":
return dist.ElasticEnsemble()
elif cls.lower() == "tsfcomposite":
# It defaults to TSF
return ensemble.TimeSeriesForestClassifier()
elif cls.lower() == "risecomposite":
steps = [
("segment", RandomIntervalSegmenter(n_intervals=1, min_length=5)),
(
"transform",
FeatureUnion([
(
"acf",
make_row_transformer(
FunctionTransformer(func=acf_coefs,
validate=False)),
),
(
"ps",
make_row_transformer(
FunctionTransformer(func=powerspectrum,
validate=False)),
),
]),
),
("tabularise", Tabularizer()),
("clf", DecisionTreeClassifier()),
]
base_estimator = Pipeline(steps)
return ensemble.TimeSeriesForestClassifier(estimator=base_estimator,
n_estimators=100)
elif cls.lower() == "rocket":
rocket_pipeline = make_pipeline(
Rocket(random_state=resampleId),
RidgeClassifierCV(alphas=np.logspace(-3, 3, 10), normalize=True),
)
return rocket_pipeline
else:
raise Exception("UNKNOWN CLASSIFIER")
