maint

autoPyTorch/pipeline/components/setup/network/forecasting_architecture.py

@@ -204,7 +204,7 @@ def __init__(self,
                                                       dataset_properties=dataset_properties,
                                                       network_encoder=network_encoder,
                                                       auto_regressive=auto_regressive)
-        has_temporal_fusion = temporal_fusion is not None
+        has_temporal_fusion = network_structure.use_temporal_fusion
         self.encoder = StackedEncoder(network_structure=network_structure,
                                       has_temporal_fusion=has_temporal_fusion,
                                       encoder_info=network_encoder,
@@ -541,7 +541,7 @@ def forward(self,
                 decoder_output = self.temporal_fusion(encoder_output=encoder_output,
                                                       decoder_output=decoder_output,
                                                       encoder_lengths=encoder_lengths,
-                                                      self.n_prediction_steps,
+                                                      decoder_length=self.n_prediction_steps,
                                                       static_embedding=x_static
                                                       )
             net_output = self.head(decoder_output)

autoPyTorch/pipeline/components/setup/network/forecasting_network.py

@@ -85,6 +85,7 @@ def fit(self, X: Dict[str, Any], y: Any = None) -> autoPyTorchTrainingComponent:
                                    network_embedding=X['network_embedding'],
                                    network_encoder=network_encoder,
                                    network_decoder=network_decoder,
+                                   temporal_fusion=X.get("temporal_fusion", None),
                                    network_head=X['network_head'],
                                    auto_regressive=X['auto_regressive'],
                                    window_size=X['window_size'],

autoPyTorch/pipeline/components/setup/network_backbone/forecasting_backbone/forecasting_encoder/seq_encoder/__init__.py

@@ -30,8 +30,10 @@
 
 from autoPyTorch.pipeline.components.setup.network_backbone.forecasting_backbone.forecasting_encoder. \
     base_forecasting_encoder import BaseForecastingEncoder
-from autoPyTorch.pipeline.components.setup.network_backbone.forecasting_backbone.components_util import ForecastingNetworkStructure
-from autoPyTorch.pipeline.components.setup.network_backbone.forecasting_backbone.other_components.TemporalFusion import TemporalFusion
+from autoPyTorch.pipeline.components.setup.network_backbone.forecasting_backbone.components_util import \
+    ForecastingNetworkStructure
+from autoPyTorch.pipeline.components.setup.network_backbone.forecasting_backbone.other_components.TemporalFusion import \
+    TemporalFusion
 
 directory = os.path.split(__file__)[0]
 _encoders = find_components(__package__,
@@ -83,7 +85,8 @@ def get_hyperparameter_search_space(
             use_temporal_fusion: HyperparameterSearchSpace = HyperparameterSearchSpace(
                 hyperparameter='use_temporal_fusion',
                 value_range=(True, False),
-                default_value=False),
+                default_value=False,
+            ),
             decoder_auto_regressive: HyperparameterSearchSpace = HyperparameterSearchSpace(
                 hyperparameter="decoder_auto_regressive",
                 value_range=(True, False),
@@ -156,14 +159,13 @@ def get_hyperparameter_search_space(
         variable_selection = get_hyperparameter(variable_selection, CategoricalHyperparameter)
         share_single_variable_networks = get_hyperparameter(share_single_variable_networks, CategoricalHyperparameter)
 
-        use_temporal_fusion = get_hyperparameter(use_temporal_fusion, CategoricalHyperparameter)
         decoder_auto_regressive = get_hyperparameter(decoder_auto_regressive, CategoricalHyperparameter)
         num_blocks = get_hyperparameter(num_blocks, UniformIntegerHyperparameter)
 
         skip_connection = get_hyperparameter(skip_connection, CategoricalHyperparameter)
 
         hp_network_structures = [num_blocks, decoder_auto_regressive, variable_selection,
-                                 skip_connection, use_temporal_fusion]
+                                 skip_connection]
         cond_skip_connections = []
         if True in skip_connection.choices:
             skip_connection_type = get_hyperparameter(skip_connection_type, CategoricalHyperparameter)
@@ -344,7 +346,6 @@ def get_hyperparameter_search_space(
 
                 cs.add_conditions(conditions_to_add)
 
-
         use_temporal_fusion = get_hyperparameter(use_temporal_fusion, CategoricalHyperparameter)
         cs.add_hyperparameter(use_temporal_fusion)
         if True in use_temporal_fusion.choices:
@@ -417,8 +418,9 @@ def set_hyperparameters(self,
         params = configuration.get_dictionary()
         num_blocks = params['num_blocks']
         decoder_auto_regressive = params['decoder_auto_regressive']
+        use_temporal_fusion = params['use_temporal_fusion']
         forecasting_structure_kwargs = dict(num_blocks=num_blocks,
-                                            use_temporal_fusion=params['use_temporal_fusion'],
+                                            use_temporal_fusion=use_temporal_fusion,
                                             variable_selection=params['variable_selection'],
                                             skip_connection=params['skip_connection'])
         if 'share_single_variable_networks' in params:
@@ -497,7 +499,6 @@ def set_hyperparameters(self,
             self.encoder_choice.append(encoder)
             self.decoder_choice.append(decoder)
 
-        use_temporal_fusion = params["use_temporal_fusion"]
         new_params = []
         if use_temporal_fusion:
             for param, value in params.items():

autoPyTorch/pipeline/components/training/trainer/forecasting_trainer/forecasting_base_trainer.py

@@ -101,7 +101,7 @@ def train_epoch(self, train_loader: torch.utils.data.DataLoader, epoch: int,
                 outputs_data.append(outputs.detach().cpu())
                 targets_data.append(targets.detach().cpu())
 
-            batch_size = data["past_target"].size(0)
+            batch_size = data["past_targets"].size(0)
             loss_sum += loss * batch_size
             N += batch_size
 
@@ -142,7 +142,7 @@ def train_step(self, data: Dict[str, torch.Tensor], future_targets: torch.Tensor
             torch.Tensor: The predictions of the network
             float: the loss incurred in the prediction
         """
-        past_target = data['past_target'].float()
+        past_target = data['past_targets'].float()
 
         future_targets = self.cast_targets(future_targets)
 
@@ -224,7 +224,7 @@ def evaluate(self, test_loader: torch.utils.data.DataLoader, epoch: int,
 
         with torch.no_grad():
             for step, (data, future_targets) in enumerate(test_loader):
-                past_target = data['past_target'].float()
+                past_target = data['past_targets'].float()
 
                 mase_coefficients.append(data['mase_coefficient'])
                 if isinstance(self.criterion, MASELoss):