Time series forecasting

autoPyTorch/api/base_task.py

@@ -1055,11 +1055,14 @@ def _search(
                 Additionally, the keyword 'greedy' is supported,
                 which would use the default portfolio from
                 `AutoPyTorch Tabular <https://arxiv.org/abs/2006.13799>`_
-            time_series_forecasting: bool
-                if time series forecasting task is implemented.
             kwargs: Any
-                additional arguments
-
+                additional arguments that are customed by some specific task.
+                For instance, forecasting tasks require:
+                    min_num_test_instances (int):  minimal number of instances used to initialize a proxy validation set
+                    suggested_init_models (List[str]):  A set of initial models suggested by the users. Their
+                        hyperparameters are determined by the default configurations
+                    custom_init_setting_path (str): The path to the initial hyperparameter configurations set by
+                    the users
         Returns:
             self
 
@@ -1339,8 +1342,13 @@ def _get_fit_dictionary(
         dataset: BaseDataset,
         split_id: int = 0
     ) -> Dict[str, Any]:
-        X_test = dataset.test_tensors[0].copy() if dataset.test_tensors is not None else None
-        y_test = dataset.test_tensors[1].copy() if dataset.test_tensors is not None else None
+        if dataset.test_tensors is not None:
+            X_test = dataset.test_tensors[0].copy() if dataset.test_tensors[0] is not None else None
+            y_test = dataset.test_tensors[1].copy() if dataset.test_tensors[1] is not None else None
+        else:
+            X_test = None
+            y_test = None
+
         X_train = dataset.train_tensors[0].copy() if dataset.train_tensors[0] is not None else None
         y_train = dataset.train_tensors[1].copy()
         X: Dict[str, Any] = dict({'dataset_properties': dataset_properties,

autoPyTorch/api/time_series_forecasting.py

@@ -18,7 +18,6 @@
     BaseDatasetPropertiesType
 )
 from autoPyTorch.datasets.resampling_strategy import (
-    CrossValTypes,
     HoldoutValTypes,
     ResamplingStrategies
 )
@@ -422,6 +421,8 @@ def search(
             self._dataset_compression = get_dataset_compression_mapping(
                 memory_limit, dataset_compression
             )
+        else:
+            self._dataset_compression = None
 
         self.dataset, self.input_validator = self._get_dataset_input_validator(
             X_train=X_train,
@@ -536,7 +537,7 @@ def predict(
             return forecasting * std + mean
         return forecasting
 
-    def update_sliding_window_size(self, n_prediction_steps: int):
+    def update_sliding_window_size(self, n_prediction_steps: int) -> None:
         """
         the size of the sliding window is heavily dependent on the dataset,
         so we only update them when we get the information from the

autoPyTorch/evaluation/time_series_forecasting_train_evaluator.py

@@ -22,6 +22,86 @@
 
 
 class TimeSeriesForecastingTrainEvaluator(TrainEvaluator):
+    """
+    This class is  similar to the TrainEvaluator. Except that given the specific
+
+    Attributes:
+        backend (Backend):
+            An object to interface with the disk storage. In particular, allows to
+            access the train and test datasets
+        queue (Queue):
+            Each worker available will instantiate an evaluator, and after completion,
+            it will return the evaluation result via a multiprocessing queue
+        metric (autoPyTorchMetric):
+            A scorer object that is able to evaluate how good a pipeline was fit. It
+            is a wrapper on top of the actual score method (a wrapper on top of scikit
+            lean accuracy for example) that formats the predictions accordingly.
+        budget: (float):
+            The amount of epochs/time a configuration is allowed to run.
+        budget_type  (str):
+            The budget type, which can be epochs or time
+        pipeline_config (Optional[Dict[str, Any]]):
+            Defines the content of the pipeline being evaluated. For example, it
+            contains pipeline specific settings like logging name, or whether or not
+            to use tensorboard.
+        configuration (Union[int, str, Configuration]):
+            Determines the pipeline to be constructed. A dummy estimator is created for
+            integer configurations, a traditional machine learning pipeline is created
+            for string based configuration, and NAS is performed when a configuration
+            object is passed.
+        seed (int):
+            A integer that allows for reproducibility of results
+        output_y_hat_optimization (bool):
+            Whether this worker should output the target predictions, so that they are
+            stored on disk. Fundamentally, the resampling strategy might shuffle the
+            Y_train targets, so we store the split in order to re-use them for ensemble
+            selection.
+        num_run (Optional[int]):
+            An identifier of the current configuration being fit. This number is unique per
+            configuration.
+        include (Optional[Dict[str, Any]]):
+            An optional dictionary to include components of the pipeline steps.
+        exclude (Optional[Dict[str, Any]]):
+            An optional dictionary to exclude components of the pipeline steps.
+        disable_file_output (Optional[List[Union[str, DisableFileOutputParameters]]]):
+            Used as a list to pass more fine-grained
+            information on what to save. Must be a member of `DisableFileOutputParameters`.
+            Allowed elements in the list are:
+
+            + `y_optimization`:
+                do not save the predictions for the optimization set,
+                which would later on be used to build an ensemble. Note that SMAC
+                optimizes a metric evaluated on the optimization set.
+            + `pipeline`:
+                do not save any individual pipeline files
+            + `pipelines`:
+                In case of cross validation, disables saving the joint model of the
+                pipelines fit on each fold.
+            + `y_test`:
+                do not save the predictions for the test set.
+            + `all`:
+                do not save any of the above.
+            For more information check `autoPyTorch.evaluation.utils.DisableFileOutputParameters`.
+        init_params (Optional[Dict[str, Any]]):
+            Optional argument that is passed to each pipeline step. It is the equivalent of
+            kwargs for the pipeline steps.
+        logger_port (Optional[int]):
+            Logging is performed using a socket-server scheme to be robust against many
+            parallel entities that want to write to the same file. This integer states the
+            socket port for the communication channel. If None is provided, a traditional
+            logger is used.
+        all_supported_metrics  (bool):
+            Whether all supported metric should be calculated for every configuration.
+        search_space_updates (Optional[HyperparameterSearchSpaceUpdates]):
+            An object used to fine tune the hyperparameter search space of the pipeline
+        max_budget (float):
+            maximal budget value available for the optimizer. This is applied to compute the size of the proxy
+            validation sets
+        min_num_test_instances (Optional[int]):
+            minimal number of instances to be validated. We do so to ensure that there are enough instances in
+            the validation set
+
+    """
     def __init__(self, backend: Backend, queue: Queue,
                  metric: autoPyTorchMetric,
                  budget: float,
@@ -41,16 +121,6 @@ def __init__(self, backend: Backend, queue: Queue,
                  search_space_updates: Optional[HyperparameterSearchSpaceUpdates] = None,
                  max_budget: float = 1.0,
                  min_num_test_instances: Optional[int] = None) -> None:
-        """
-        Attributes:
-            max_budget (Optional[float]):
-                maximal budget the optimizer could allocate
-            min_num_test_instances: Optional[int]
-                minimal number of validation instances to be evaluated, if the size of the validation set is greater
-                than this value, then less instances from validation sets will be evaluated. The other predictions
-                 will be filled with dummy predictor
-
-        """
         super(TimeSeriesForecastingTrainEvaluator, self).__init__(
             backend=backend,
             queue=queue,

autoPyTorch/optimizer/smbo.py

@@ -8,11 +8,11 @@
 
 import dask.distributed
 
-from smac.facade.smac_hpo_facade import SMAC4HPO
+from smac.facade.smac_ac_facade import SMAC4AC
 from smac.intensification.hyperband import Hyperband
 from smac.intensification.intensification import Intensifier
 from smac.runhistory.runhistory import RunHistory
-from smac.runhistory.runhistory2epm import RunHistory2EPM4LogScaledCost
+from smac.runhistory.runhistory2epm import RunHistory2EPM4LogCost
 from smac.scenario.scenario import Scenario
 from smac.tae.dask_runner import DaskParallelRunner
 from smac.tae.serial_runner import SerialRunner
@@ -50,7 +50,7 @@ def get_smac_object(
     max_budget: Union[int, float],
     dask_client: Optional[dask.distributed.Client],
     initial_configurations: Optional[List[Configuration]] = None,
-) -> SMAC4HPO:
+) -> SMAC4AC:
     """
     This function returns an SMAC object that is gonna be used as
     optimizer of pipelines
@@ -73,16 +73,17 @@ def get_smac_object(
 
     """
     if initial_budget == max_budget:
+        # This allows vanilla BO optimization
         intensifier = Intensifier
         intensifier_kwargs: Dict[str, Any] = {'deterministic': True, }
 
     else:
         intensifier = Hyperband
         intensifier_kwargs = {'initial_budget': initial_budget, 'max_budget': max_budget,
                               'eta': 3, 'min_chall': 1, 'instance_order': 'shuffle_once'}
-    rh2EPM = RunHistory2EPM4LogScaledCost
+    rh2EPM = RunHistory2EPM4LogCost
 
-    return SMAC4HPO(
+    return SMAC4AC(
         scenario=Scenario(scenario_dict),
         rng=seed,
         runhistory2epm=rh2EPM,
@@ -209,12 +210,13 @@ def __init__(self,
             task_type (str):
                 task type. Forecasting tasks require special process
             kwargs (Any):
-                Additional Arguments for forecasting tasks. It includes:
-                    min_num_test_instances (int): minimal number of instances used to initialize a proxy validation set
-                    suggested_init_models (List[str]): A set of initial models suggested by the users.
-                        Their hyperparameters are still determined by the default configurations
-                    custom_init_setting_path (str): the path to the initial hyperparameter configurations set by the
-                        users
+                additional arguments that are customed by some specific task.
+                For instance, forecasting tasks require:
+                    min_num_test_instances (int):  minimal number of instances used to initialize a proxy validation set
+                    suggested_init_models (List[str]):  A set of initial models suggested by the users. Their
+                        hyperparameters are determined by the default configurations
+                    custom_init_setting_path (str): The path to the initial hyperparameter configurations set by
+                    the users
 
         """
         super(AutoMLSMBO, self).__init__()

autoPyTorch/pipeline/components/setup/forecasting_target_scaling/base_target_scaler.py

@@ -1,6 +1,6 @@
 from typing import Any, Dict, Optional, Union
 
-from ConfigSpace import ConfigurationSpace, CategoricalHyperparameter
+from ConfigSpace import CategoricalHyperparameter, ConfigurationSpace
 
 import numpy as np
 
@@ -12,7 +12,7 @@
 from autoPyTorch.datasets.base_dataset import BaseDatasetPropertiesType
 from autoPyTorch.pipeline.components.base_component import autoPyTorchComponent
 from autoPyTorch.pipeline.components.setup.forecasting_target_scaling.utils import TargetScaler
-from autoPyTorch.utils.common import add_hyperparameter, HyperparameterSearchSpace
+from autoPyTorch.utils.common import HyperparameterSearchSpace, add_hyperparameter
 
 
 class BaseTargetScaler(autoPyTorchComponent):

autoPyTorch/pipeline/components/setup/forecasting_training_loss/__init__.py

@@ -54,12 +54,12 @@ def get_available_components(
         include/exclude directives, as well as the dataset properties
 
         Args:
-         include (Optional[Dict[str, Any]]):
-            what hyper-parameter configurations to honor when creating the configuration space
-         exclude (Optional[Dict[str, Any]]):
-            what hyper-parameter configurations to remove from the configuration space
-         dataset_properties (Optional[Dict[str, BaseDatasetPropertiesType]]):
-            Characteristics of the dataset to guide the pipeline choices of components
+            include (Optional[Dict[str, Any]]):
+                what hyper-parameter configurations to honor when creating the configuration space
+            exclude (Optional[Dict[str, Any]]):
+                what hyper-parameter configurations to remove from the configuration space
+            dataset_properties (Optional[Dict[str, BaseDatasetPropertiesType]]):
+                Characteristics of the dataset to guide the pipeline choices of components
 
         Returns:
             Dict[str, autoPyTorchComponent]: A filtered dict of learning