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