Fixed the non autoregressive final metric calculations

Dockerfile

@@ -2,7 +2,7 @@ FROM pytorch/pytorch:2.0.1-cuda11.7-cudnn8-runtime
 
 RUN apt-get update
 RUN apt-get install -y git
-RUN apt-get install texlive-latex-base texlive-fonts-recommended texlive-fonts-extra texlive-bibtex-extra
+# RUN apt-get install texlive-latex-base texlive-fonts-recommended texlive-fonts-extra texlive-bibtex-extra
 
 COPY requirements.txt /tmp/requirements.txt
 

src/trainers/quantile_trainer.py

@@ -558,18 +558,23 @@ class NonAutoRegressiveQuantileRegression(Trainer):
                 inputs, targets = inputs.to(self.device), targets.to(self.device)
 
                 outputs = self.model(inputs)
-
+                outputs = outputs.reshape(-1, 96, len(self.quantiles))
-                outputs = outputs.reshape(-1, len(self.quantiles))
 
                 outputted_samples = [
-                    sample_from_dist(self.quantiles, output.cpu()) for output in outputs
+                    sample_from_dist(self.quantiles, output.cpu()) for _ in range(100) for output in outputs
                 ]
 
+
                 outputted_samples = torch.tensor(outputted_samples)
                 inversed_outputs_samples = self.data_processor.inverse_transform(
                     outputted_samples
                 )
 
+                expanded_targets = targets.unsqueeze(1).repeat(1, 100, 1).reshape(-1, 96)
+                inversed_expanded_targets = self.data_processor.inverse_transform(
+                    expanded_targets
+                )
+
                 outputs = outputs.reshape(inputs.shape[0], -1, len(self.quantiles))
                 inversed_outputs = self.data_processor.inverse_transform(outputs)
                 inversed_targets = self.data_processor.inverse_transform(targets)
@@ -579,13 +584,17 @@ class NonAutoRegressiveQuantileRegression(Trainer):
                 outputted_samples = outputted_samples.to(self.device)
                 inversed_outputs = inversed_outputs.to(self.device)
 
+                expanded_targets = expanded_targets.to(self.device)
+                inversed_expanded_targets = inversed_expanded_targets.to(self.device)
+
+
                 for metric in self.metrics_to_track:
                     if metric.__class__ != PinballLoss and metric.__class__ != CRPSLoss:
                         transformed_metrics[metric.__class__.__name__] += metric(
-                            outputted_samples, targets
+                            outputted_samples, expanded_targets
                         )
                         metrics[metric.__class__.__name__] += metric(
-                            inversed_outputs_samples, inversed_targets
+                            inversed_outputs_samples, inversed_expanded_targets
                         )
                     else:
                         transformed_metrics[metric.__class__.__name__] += metric(

src/training_scripts/non_autoregressive_quantiles.py

@@ -2,7 +2,7 @@ from src.utils.clearml import ClearMLHelper
 
 #### ClearML ####
 clearml_helper = ClearMLHelper(project_name="Thesis/NAQR: Linear")
-task = clearml_helper.get_task(task_name="NAQR: Non Linear")
+task = clearml_helper.get_task(task_name="NAQR: Linear + Load + PV + Wind + Net Position")
 task.execute_remotely(queue_name="default", exit_process=True)
 
 from src.policies.PolicyEvaluator import PolicyEvaluator
@@ -27,22 +27,22 @@ from src.models.time_embedding_layer import TimeEmbedding
 data_config = DataConfig()
 
 data_config.NRV_HISTORY = True
-data_config.LOAD_HISTORY = False
+data_config.LOAD_HISTORY = True
-data_config.LOAD_FORECAST = False
+data_config.LOAD_FORECAST = True
 
-data_config.WIND_FORECAST = False
+data_config.WIND_FORECAST = True
-data_config.WIND_HISTORY = False
+data_config.WIND_HISTORY = True
 
-data_config.PV_FORECAST = False
+data_config.PV_FORECAST = True
-data_config.PV_HISTORY = False
+data_config.PV_HISTORY = True
 
-data_config.NOMINAL_NET_POSITION = False
+data_config.NOMINAL_NET_POSITION = True
 
 
 data_config = task.connect(data_config, name="data_features")
 
 data_processor = DataProcessor(data_config, path="", lstm=False)
-data_processor.set_batch_size(512)
+data_processor.set_batch_size(64)
 data_processor.set_full_day_skip(True)
 
 
@@ -72,9 +72,6 @@ model_parameters = {
 
 model_parameters = task.connect(model_parameters, name="model_parameters")
 
-time_embedding = TimeEmbedding(
-    data_processor.get_time_feature_size(), model_parameters["time_feature_embedding"]
-)
 # lstm_model = GRUModel(
 #     time_embedding.output_dim(inputDim),
 #     len(quantiles),
@@ -91,9 +88,9 @@ time_embedding = TimeEmbedding(
 #     dropout=model_parameters["dropout"],
 # )
 
-linear_model = LinearRegression(time_embedding.output_dim(inputDim), len(quantiles))
+linear_model = LinearRegression(inputDim, len(quantiles) * 96)
 
-model = nn.Sequential(time_embedding, linear_model)
+model = linear_model
 model.output_size = 96
 optimizer = torch.optim.Adam(model.parameters(), lr=model_parameters["learning_rate"])
 
@@ -117,8 +114,8 @@ trainer = NonAutoRegressiveQuantileRegression(
 trainer.add_metrics_to_track(
     [PinballLoss(quantiles), MSELoss(), L1Loss(), CRPSLoss(quantiles)]
 )
-trainer.early_stopping(patience=10)
+trainer.early_stopping(patience=5)
-trainer.plot_every(5)
+trainer.plot_every(20)
 trainer.train(task=task, epochs=epochs, remotely=True)
 
 ### Policy Evaluation ###