def __init__(self, minimum_training_size, validation_window_size=None, padding_between_training_and_validation=0, drop_remainder=False, scoring_function=r2_score, joiner=NumpyConcatenateInnerFeatures()): """ Create a anchored walk forward time series cross validation object. The size of the validation split is defined by `validation_window_size`. The difference in start position between two consecutive validation split is also equal to `validation_window_size`. :param minimum_training_size: size of the smallest training split. :param validation_window_size: size of each validation split and also the time step taken between each forward roll, by default None. If None : It takes the value `minimum_training_size`. :param padding_between_training_and_validation: the size of the padding between the end of the training split and the start of the validation split, by default 0. :param drop_remainder: drop the last split if the last validation split does not coincide with a full validation_window_size, by default False. :param scoring_function: scoring function use to validate performance if it is not None, by default r2_score, :param joiner the joiner callable that can join the different result together. :return: WalkForwardTimeSeriesCrossValidation instance. """ BaseCrossValidationWrapper.__init__(self, scoring_function=scoring_function, joiner=joiner) self.minimum_training_size = minimum_training_size # If validation_window_size is None, we give the same value as training_window_size. self.validation_window_size = validation_window_size or self.minimum_training_size self.padding_between_training_and_validation = padding_between_training_and_validation self.drop_remainder = drop_remainder self._validation_initial_start = self.minimum_training_size + self.padding_between_training_and_validation
def test_feature_union_should_transform_with_concatenate_inner_features(): p = Pipeline([ FeatureUnion([ Identity(), Identity(), ], joiner=NumpyConcatenateInnerFeatures()) ]) data_inputs = np.random.randint((1, 20)) outputs = p.transform(data_inputs) assert np.array_equal(outputs, np.concatenate([data_inputs, data_inputs]))
def test_feature_union_should_fit_transform_with_concatenate_inner_features(): p = Pipeline([ FeatureUnion([ Identity(), Identity(), ], joiner=NumpyConcatenateInnerFeatures()) ]) data_inputs = np.random.randint(low=0, high=100, size=(2, 20)) expected_outputs = None p, outputs = p.fit_transform(data_inputs, expected_outputs) assert np.array_equal(outputs, np.concatenate([data_inputs, data_inputs], axis=-1))
def __init__(self, steps_as_tuple: NamedTupleList, joiner: NonFittableMixin = NumpyConcatenateInnerFeatures(), n_jobs: int = None, backend: str = "threading"): """ Create a feature union. :param steps_as_tuple: the NamedTupleList of steps to process in parallel and to join. :param joiner: What will be used to join the features. For example, ``NumpyConcatenateInnerFeatures()``. :param n_jobs: The number of jobs for the parallelized ``joblib.Parallel`` loop in fit and in transform. :param backend: The type of parallelization to do with ``joblib.Parallel``. Possible values: "loky", "multiprocessing", "threading", "dask" if you use dask, and more. """ TruncableSteps.__init__(self, steps_as_tuple) self.joiner = joiner self.n_jobs = n_jobs self.backend = backend
def __init__(self): super().__init__([ Pipeline([ NumpyFFT(), NumpyAbs(), FeatureUnion( [ NumpyFlattenDatum( ), # Reshape from 3D to flat 2D: flattening data except on batch size FFTPeakBinWithValue( ) # Extract 2D features from the 3D FFT bins ], joiner=NumpyConcatenateInnerFeatures()) ]).set_name('FFT'), NumpyMean(), NumpyMedian(), NumpyMin(), NumpyMax() ])
def __init__(self, steps_as_tuple: NamedTupleList, joiner: BaseTransformer = None, n_jobs: int = None, backend: str = "threading", cache_folder_when_no_handle: str = None): """ Create a feature union. :param steps_as_tuple: the NamedTupleList of steps to process in parallel and to join. :param joiner: What will be used to join the features. ``NumpyConcatenateInnerFeatures()`` is used by default. :param n_jobs: The number of jobs for the parallelized ``joblib.Parallel`` loop in fit and in transform. :param backend: The type of parallelization to do with ``joblib.Parallel``. Possible values: "loky", "multiprocessing", "threading", "dask" if you use dask, and more. """ if joiner is None: joiner = NumpyConcatenateInnerFeatures() steps_as_tuple.append(('joiner', joiner)) TruncableSteps.__init__(self, steps_as_tuple) ForceHandleOnlyMixin.__init__(self, cache_folder=cache_folder_when_no_handle) self.n_jobs = n_jobs self.backend = backend
def __init__(self): super().__init__( [NumpyArgMax(axis=-2), NumpyMax(axis=-2)], joiner=NumpyConcatenateInnerFeatures())