def test_dunder_mul():
"""Test the mul dunder method."""
RAND_SEED = 42
y = _make_classification_y(n_instances=10, random_state=RAND_SEED)
X = _make_panel_X(n_instances=10,
n_timepoints=20,
random_state=RAND_SEED,
y=y)
X_test = _make_panel_X(n_instances=5,
n_timepoints=20,
random_state=RAND_SEED)
t1 = ExponentTransformer(power=4)
t2 = ExponentTransformer(power=0.25)
c = KNeighborsTimeSeriesClassifier()
t12c_1 = t1 * (t2 * c)
t12c_2 = (t1 * t2) * c
t12c_3 = t1 * t2 * c
assert isinstance(t12c_1, ClassifierPipeline)
assert isinstance(t12c_2, ClassifierPipeline)
assert isinstance(t12c_3, ClassifierPipeline)
y_pred = c.fit(X, y).predict(X_test)
_assert_array_almost_equal(y_pred, t12c_1.fit(X, y).predict(X_test))
_assert_array_almost_equal(y_pred, t12c_2.fit(X, y).predict(X_test))
_assert_array_almost_equal(y_pred, t12c_3.fit(X, y).predict(X_test))
def test_mul_sklearn_autoadapt():
"""Test auto-adapter for sklearn in mul."""
RAND_SEED = 42
y = _make_classification_y(n_instances=10, random_state=RAND_SEED)
X = _make_panel_X(n_instances=10,
n_timepoints=20,
random_state=RAND_SEED,
y=y)
X_test = _make_panel_X(n_instances=10,
n_timepoints=20,
random_state=RAND_SEED)
t1 = ExponentTransformer(power=2)
t2 = StandardScaler()
c = KNeighborsTimeSeriesClassifier()
t12c_1 = t1 * (t2 * c)
t12c_2 = (t1 * t2) * c
t12c_3 = t1 * t2 * c
assert isinstance(t12c_1, ClassifierPipeline)
assert isinstance(t12c_2, ClassifierPipeline)
assert isinstance(t12c_3, ClassifierPipeline)
y_pred = t12c_1.fit(X, y).predict(X_test)
_assert_array_almost_equal(y_pred, t12c_2.fit(X, y).predict(X_test))
_assert_array_almost_equal(y_pred, t12c_3.fit(X, y).predict(X_test))
class TransformerFitTransformPanelMultivariate(TransformerTestScenario):
"""Fit/transform, multivariate Panel X."""
_tags = {"X_scitype": "Panel", "X_univariate": False, "has_y": False}
args = {
"fit": {"X": _make_panel_X(n_instances=7, n_columns=2, n_timepoints=20)},
"transform": {"X": _make_panel_X(n_instances=7, n_columns=2, n_timepoints=20)},
}
default_method_sequence = ["fit", "transform"]
def _make_predict_args(estimator, **kwargs):
if isinstance(estimator, BaseForecaster):
fh = 1
return (fh, )
elif isinstance(estimator, (BaseClassifier, BaseRegressor)):
X = _make_panel_X(**kwargs)
return (X, )
elif isinstance(estimator, BaseClusterer):
X = _make_panel_X(**kwargs)
return (X, )
else:
raise ValueError(_get_err_msg(estimator))
def _make_predict_args(estimator, **kwargs):
if isinstance(estimator, BaseForecaster):
fh = 1
return (fh, )
elif isinstance(estimator, (BaseClassifier, BaseRegressor)):
X = _make_panel_X(**kwargs)
return (X, )
elif isinstance(estimator, BaseSeriesAnnotator):
X = make_annotation_problem(n_timepoints=10, **kwargs)
return (X, )
elif isinstance(estimator, BaseClusterer):
X = _make_panel_X(**kwargs)
return (X, )
else:
raise ValueError(_get_err_msg(estimator))
def _make_transform_args(estimator, **kwargs):
if isinstance(
estimator,
(_SeriesToPrimitivesTransformer, _SeriesToSeriesTransformer)):
X = _make_series(**kwargs)
return (X, )
elif isinstance(
estimator,
(
_PanelToTabularTransformer,
_PanelToPanelTransformer,
),
):
X = _make_panel_X(**kwargs)
return (X, )
elif isinstance(estimator, BaseTransformer):
X = _make_series(**kwargs)
return (X, )
elif isinstance(estimator, BasePairwiseTransformer):
d = {"col1": [1, 2], "col2": [3, 4]}
return pd.DataFrame(d), pd.DataFrame(d)
elif isinstance(estimator, BasePairwiseTransformerPanel):
d = pd.DataFrame({"col1": [1, 2], "col2": [3, 4]})
X = [d, d]
return X, X
else:
raise ValueError(_get_err_msg(estimator))
class TransformerFitTransformPanelUnivariate(TransformerTestScenario):
"""Fit/transform, univariate Panel X."""
_tags = {"X_scitype": "Panel", "X_univariate": True, "has_y": False}
args = {
"fit": {
"X": _make_panel_X(
n_instances=7, n_columns=1, n_timepoints=20, random_state=RAND_SEED
)
},
"transform": {
"X": _make_panel_X(
n_instances=3, n_columns=1, n_timepoints=10, random_state=RAND_SEED
)
},
}
default_method_sequence = ["fit", "transform"]
class ClustererFitPredict(ClustererTestScenario):
"""Fit/predict with panel Xmake_clustering_problem."""
_tags = {"X_univariate": True, "pre-refactor": True}
args = {
"fit": {"X": make_clustering_problem(random_state=RAND_SEED)},
"predict": {"X": _make_panel_X(random_state=RAND_SEED)},
}
default_method_sequence = ["fit", "predict"]
class TransformerFitTransformPanelUnivariateWithClassY(TransformerTestScenario):
"""Fit/transform, multivariate Panel X."""
_tags = {
"X_scitype": "Panel",
"X_univariate": True,
"pre-refactor": True,
"has_y": True,
"y_scitype": "classes",
}
args = {
"fit": {
"X": _make_panel_X(n_instances=7, n_columns=1, n_timepoints=20),
"y": _make_classification_y(n_instances=7, n_classes=2),
},
"transform": {"X": _make_panel_X(n_instances=7, n_columns=1, n_timepoints=20)},
}
default_method_sequence = ["fit", "transform"]
def _create_test_distances(n_instance,
n_columns,
n_timepoints,
random_state=1):
if n_instance > 1:
return _make_panel_X(
n_instances=n_instance,
n_columns=n_columns,
n_timepoints=n_timepoints,
random_state=random_state,
)
else:
return _make_series(n_timepoints, n_columns, random_state=random_state)
def _make_inverse_transform_args(estimator, **kwargs):
if isinstance(estimator, _SeriesToPrimitivesTransformer):
X = _make_primitives(**kwargs)
return (X, )
elif isinstance(estimator, _SeriesToSeriesTransformer):
X = _make_series(**kwargs)
return (X, )
elif isinstance(estimator, _PanelToTabularTransformer):
X = _make_tabular_X(**kwargs)
return (X, )
elif isinstance(estimator, _PanelToPanelTransformer):
X = _make_panel_X(**kwargs)
return (X, )
else:
raise ValueError(_get_err_msg(estimator))
# if X is multivariate, applicable only if can handle multivariate
is_multivariate = not self.get_tag("X_univariate")
if is_multivariate and not get_tag(obj, "capability:multivariate"):
return False
# if X is unequal length, applicable only if can handle unequal length
is_unequal_length = self.get_tag("X_unequal_length")
if is_unequal_length and not get_tag(obj, "capability:unequal_length"):
return False
return True
y = _make_classification_y(n_instances=10, random_state=RAND_SEED)
X = _make_panel_X(n_instances=10, n_timepoints=20, random_state=RAND_SEED, y=y)
X_test = _make_panel_X(n_instances=5, n_timepoints=20, random_state=RAND_SEED)
X_multivariate = _make_panel_X(n_instances=10,
n_columns=2,
n_timepoints=20,
random_state=RAND_SEED,
y=y)
X_test_multivariate = _make_panel_X(n_instances=5,
n_columns=2,
n_timepoints=20,
random_state=RAND_SEED)
class ClassifierFitPredict(ClassifierTestScenario):
"""Fit/predict with univariate panel X and labels y."""
_tags = {"univariate_y": False, "fh_passed_in_fit": True}
args = {
"fit": {
"y": _make_series(n_timepoints=20, n_columns=2, random_state=RAND_SEED),
"X": X.copy(),
"fh": [1, 2, 3],
},
"predict": {"X": X_test.copy()},
}
default_method_sequence = ["fit", "predict"]
y_panel = _make_panel_X(
n_instances=3, n_timepoints=10, n_columns=1, random_state=RAND_SEED
)
class ForecasterFitPredictPanelSimple(ForecasterTestScenario):
"""Fit/predict only, univariate Panel y, no X, and longer fh."""
_tags = {"univariate_y": True, "fh_passed_in_fit": True}
args = {"fit": {"y": y_panel.copy(), "fh": [1, 2, 3]}, "predict": {}}
default_method_sequence = ["fit", "predict"]
y_hierarchical = _make_hierarchical(n_columns=1, random_state=RAND_SEED)
but scripted method will look at key with same name as default
"""
# use same args for predict-like functions as for predict
if key in ["predict_proba", "decision_function"]:
key = "predict"
args = self.args[key]
if deepcopy_args:
args = deepcopy(args)
return args
y = _make_classification_y(n_instances=10, random_state=RAND_SEED)
X = _make_panel_X(n_instances=10, n_timepoints=20, random_state=RAND_SEED, y=y)
X_test = _make_panel_X(n_instances=5, n_timepoints=20, random_state=RAND_SEED)
class ClassifierFitPredict(ClassifierTestScenario):
"""Fit/predict with panel X and labels y."""
_tags = {"X_univariate": True, "pre-refactor": True}
args = {
"fit": {
"y": y,
"X": X
},
"predict": {
"X": X_test
def get_args(self, key, obj=None, deepcopy_args=False):
"""Return args for key. Can be overridden for dynamic arg generation.
If overridden, must not have any side effects on self.args
e.g., avoid assignments args[key] = x without deepcopying self.args first
Parameters
----------
key : str, argument key to construct/retrieve args for
obj : obj, optional, default=None. Object to construct args for.
deepcopy_args : bool, optional, default=True. Whether to deepcopy return.
Returns
-------
args : argument dict to be used for a method, keyed by `key`
names for keys need not equal names of methods these are used in
but scripted method will look at key with same name as default
"""
if key == "inverse_transform":
if obj is None:
raise ValueError('if key="inverse_transform", obj must be provided')
X_scitype = self.get_tag("X_scitype")
X_out_scitype = get_tag(obj, "scitype:transform-output")
X_panel = get_tag(obj, "scitype:instancewise")
X_out_series = X_out_scitype == "Series"
X_out_prim = X_out_scitype == "Primitives"
# determine output by X_out_scitype
# until transformer refactor is complete, use the old classes, too
if _is_child_of(obj, OLD_MIXINS):
s2s = _is_child_of(obj, _SeriesToSeriesTransformer)
s2p = _is_child_of(obj, _SeriesToPrimitivesTransformer)
p2t = _is_child_of(obj, _PanelToTabularTransformer)
p2p = _is_child_of(obj, _PanelToPanelTransformer)
else:
s2s = X_scitype == "Series" and X_out_series
s2p = X_scitype == "Series" and X_out_prim
p2t = X_scitype == "Panel" and X_out_prim
p2p = X_scitype == "Panel" and X_out_series
# expected input type of inverse_transform is expected output of transform
if s2p:
args = {"X": _make_primitives(random_state=RAND_SEED)}
elif s2s:
args = {"X": _make_series(n_timepoints=20, random_state=RAND_SEED)}
elif p2t:
args = {"X": _make_tabular_X(n_instances=7, random_state=RAND_SEED)}
elif p2p:
args = {
"X": _make_panel_X(
n_instances=7, n_timepoints=20, random_state=RAND_SEED
)
}
else:
raise RuntimeError(
"transformer with unexpected combination of tags: "
f"X_out_scitype = {X_out_scitype}, scitype:instancewise = {X_panel}"
)
else:
# default behaviour, happens except when key = "inverse_transform"
args = self.args[key]
if deepcopy_args:
args = deepcopy(args)
return args
