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 AlignerMultipleUnivariateUnequal(AlignerTestScenario):
"""Align univariate series, multiple alignment, unequal length."""
_tags = {
"X_univariate": True,
"pairwise": False,
"equal_length": False,
"pre-refactor": False,
}
args = {
"fit": {
"X": [
_make_series(n_timepoints=20,
n_columns=1,
random_state=RAND_SEED),
_make_series(n_timepoints=30,
n_columns=1,
random_state=RAND_SEED),
_make_series(n_timepoints=25,
n_columns=1,
random_state=RAND_SEED),
],
},
}
default_method_sequence = ["fit"]
def _make_fit_args(estimator, **kwargs):
if isinstance(estimator, BaseForecaster):
# we need to handle the TransformedTargetForecaster separately
if isinstance(estimator, _SeriesToSeriesTransformer):
y = _make_series(**kwargs)
else:
y = make_forecasting_problem(**kwargs)
fh = 1
X = None
return y, X, fh
elif isinstance(estimator, BaseSeriesAnnotator):
X = make_annotation_problem(**kwargs)
return (X,)
elif isinstance(estimator, BaseClassifier):
return make_classification_problem(**kwargs)
elif isinstance(estimator, BaseRegressor):
return make_regression_problem(**kwargs)
elif isinstance(
estimator, (_SeriesToPrimitivesTransformer, _SeriesToSeriesTransformer)
):
X = _make_series(**kwargs)
return (X,)
elif isinstance(estimator, (_PanelToTabularTransformer, _PanelToPanelTransformer)):
return make_classification_problem(**kwargs)
elif isinstance(estimator, BaseClusterer):
return (make_clustering_problem(**kwargs),)
else:
raise ValueError(_get_err_msg(estimator))
def _make_fit_args(estimator, **kwargs):
if isinstance(estimator, BaseForecaster):
# we need to handle the TransformedTargetForecaster separately
if isinstance(estimator, _SeriesToSeriesTransformer):
y = _make_series(**kwargs)
else:
# create matching n_columns input, if n_columns not passed
# e.g., to give bivariate y to strictly multivariate forecaster
if "n_columns" not in kwargs.keys():
n_columns = _get_n_columns(
estimator.get_tag(tag_name="scitype:y",
raise_error=False))[0]
y = make_forecasting_problem(n_columns=n_columns, **kwargs)
else:
y = make_forecasting_problem(**kwargs)
fh = 1
X = None
return y, X, fh
elif isinstance(estimator, BaseSeriesAnnotator):
X = make_annotation_problem(**kwargs)
return (X, )
elif isinstance(estimator, BaseClassifier):
return make_classification_problem(**kwargs)
elif isinstance(estimator, BaseRegressor):
return make_regression_problem(**kwargs)
elif isinstance(
estimator,
(_SeriesToPrimitivesTransformer, _SeriesToSeriesTransformer)):
X = _make_series(**kwargs)
return (X, )
elif isinstance(estimator,
(_PanelToTabularTransformer, _PanelToPanelTransformer)):
return make_classification_problem(**kwargs)
elif isinstance(estimator,
BaseTransformer) and estimator.get_tag("requires_y"):
return make_classification_problem(**kwargs)
elif isinstance(estimator, BaseTransformer):
X = _make_series(**kwargs)
return (X, )
elif isinstance(estimator, BaseClusterer):
return (make_clustering_problem(**kwargs), )
elif isinstance(estimator, BasePairwiseTransformer):
return None, None
elif isinstance(estimator, BasePairwiseTransformerPanel):
return None, None
elif isinstance(estimator, BaseAligner):
X = [
_make_series(n_columns=2, **kwargs),
_make_series(n_columns=2, **kwargs)
]
return (X, )
else:
raise ValueError(_get_err_msg(estimator))
class TransformerFitTransformSeriesMultivariate(TransformerTestScenario):
"""Fit/transform, multivariate Series X."""
_tags = {"X_scitype": "Series", "X_univariate": False, "has_y": False}
args = {
"fit": {
"X": _make_series(n_columns=2, n_timepoints=20, random_state=RAND_SEED)
},
"transform": {
"X": _make_series(n_columns=2, n_timepoints=10, random_state=RAND_SEED)
},
}
default_method_sequence = ["fit", "transform"]
def _make_fit_args(estimator, **kwargs):
if isinstance(estimator, BaseForecaster):
y = make_forecasting_problem(**kwargs)
fh = 1
X = None
return y, X, fh
elif isinstance(estimator, BaseClassifier):
return make_classification_problem(**kwargs)
elif isinstance(estimator, BaseRegressor):
return make_regression_problem(**kwargs)
elif isinstance(
estimator,
(_SeriesToPrimitivesTransformer, _SeriesToSeriesTransformer)):
X = _make_series(**kwargs)
return (X, )
elif isinstance(
estimator,
(
_PanelToTabularTransformer,
_PanelToPanelTransformer,
),
):
return make_classification_problem(**kwargs)
else:
raise ValueError(_get_err_msg(estimator))
class TransformerFitTransformSeriesUnivariate(TransformerTestScenario):
"""Fit/transform, univariate Series X."""
_tags = {
"X_scitype": "Series",
"X_univariate": True,
"has_y": False,
"pre-refactor": True,
}
args = {
"fit": {"X": _make_series(n_timepoints=20, random_state=RAND_SEED)},
"transform": {"X": _make_series(n_timepoints=10, random_state=RAND_SEED)},
# "inverse_transform": {"X": _make_series(n_timepoints=10)},
}
default_method_sequence = ["fit", "transform"]
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, )
elif isinstance(estimator, BaseTransformer):
X = _make_series(**kwargs)
return (X, )
else:
raise ValueError(_get_err_msg(estimator))
class AlignerPairwiseMultivariateEqual(AlignerTestScenario):
"""Align multivariate series, pairwise alignment, equal length."""
_tags = {
"X_univariate": False,
"pairwise": True,
"equal_length": True,
"is_enabled": True,
}
args = {
"fit": {
"X": [
_make_series(n_timepoints=20, n_columns=2, random_state=RAND_SEED),
_make_series(n_timepoints=20, n_columns=2, random_state=RAND_SEED),
],
},
}
default_method_sequence = ["fit"]
class ForecasterFitPredictUnivariateNoXEarlyFh(ForecasterTestScenario):
"""Fit/predict only, univariate y, no X, no fh in predict."""
_tags = {"univariate_y": True, "fh_passed_in_fit": True}
args = {
"fit": {
"y": _make_series(n_timepoints=20, random_state=RAND_SEED),
"fh": 1
},
"predict": {},
}
default_method_sequence = ["fit", "predict"]
class ForecasterFitPredictUnivariateWithXLongFh(ForecasterTestScenario):
"""Fit/predict only, univariate y, with X, and longer fh."""
_tags = {"univariate_y": True, "fh_passed_in_fit": True}
args = {
"fit": {
"y": _make_series(n_timepoints=20, random_state=RAND_SEED),
"X": X.copy(),
"fh": [1, 2, 3],
},
"predict": {
"X": X_test.copy()
},
}
default_method_sequence = ["fit", "predict"]
class ForecasterFitPredictMultivariateNoX(ForecasterTestScenario):
"""Fit/predict only, multivariate y, no X."""
_tags = {
"univariate_y": False,
"fh_passed_in_fit": True,
"pre-refactor": True
}
args = {
"fit": {
"y": _make_series(n_timepoints=20,
n_columns=2,
random_state=RAND_SEED),
"fh": 1,
},
"predict": {},
}
default_method_sequence = ["fit", "predict"]
# We here define the parameter values for unit testing.
TEST_WINDOW_LENGTHS = [1, 5]
TEST_STEP_LENGTHS = [1, 5]
TEST_OOS_FHS = [1, np.array([2, 5])] # out-of-sample
TEST_INS_FHS = [
-3, # single in-sample
np.array([-2, -5]), # multiple in-sample
0, # last training point
np.array([-3, 2]), # mixed in-sample and out-of-sample
]
TEST_FHS = TEST_OOS_FHS + TEST_INS_FHS
TEST_SPS = [3, 12]
TEST_ALPHAS = [0.05, 0.1]
TEST_YS = [
_make_series(all_positive=True),
]
# We currently support the following combinations of index and forecasting horizon types
VALID_INDEX_FH_COMBINATIONS = [
# index type, fh type, is_relative
("int", "int", True),
("int", "int", False),
("range", "int", True),
("range", "int", False),
("period", "int", True),
("period", "period", False),
("datetime", "int", True),
("datetime", "datetime", False),
]
#!/usr/bin/env python3 -u
# -*- coding: utf-8 -*-
__author__ = ["Tomasz Chodakowski"]
__all__ = [
"TEST_YS",
"TEST_YS_ZERO",
]
import pandas as pd
from sktime.utils._testing.forecasting import _make_series
RANDOM_SEED = 42
TEST_YS = [
_make_series(n_timepoints=50, random_state=RANDOM_SEED),
_make_series(n_timepoints=1, random_state=RANDOM_SEED),
pd.Series([0.0000001, 0.0000002, 0.0000003]),
]
TEST_YS_ZERO = [pd.Series([0.0, 0.0, 0.0])]
class ForecasterFitPredictUnivariateNoXLongFh(ForecasterTestScenario):
"""Fit/predict only, univariate y, no X, longer fh."""
_tags = {"univariate_y": True, "fh_passed_in_fit": True}
args = {
"fit": {
"y": _make_series(n_timepoints=20, random_state=RAND_SEED),
"fh": [1, 2, 3],
},
"predict": {},
}
default_method_sequence = ["fit", "predict"]
LONG_X = _make_series(n_columns=2, n_timepoints=30, random_state=RAND_SEED)
X = LONG_X.iloc[0:20]
X_test = LONG_X.iloc[20:23]
X_test_short = LONG_X.iloc[20:21]
class ForecasterFitPredictUnivariateWithX(ForecasterTestScenario):
"""Fit/predict only, univariate y, with X."""
_tags = {"univariate_y": True, "fh_passed_in_fit": True}
args = {
"fit": {
"y": _make_series(n_timepoints=20, random_state=RAND_SEED),
"X": X.copy(),
"fh": 1,
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
