PVNet 3.0.22__tar.gz → 3.0.24__tar.gz

{PVNet-3.0.22 → PVNet-3.0.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PVNet
-Version: 3.0.22
+Version: 3.0.24
 Summary: PVNet
 Author: Peter Dudfield
 Author-email: info@openclimatefix.org

{PVNet-3.0.22 → PVNet-3.0.24}/PVNet.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PVNet
-Version: 3.0.22
+Version: 3.0.24
 Summary: PVNet
 Author: Peter Dudfield
 Author-email: info@openclimatefix.org

PVNet-3.0.24/pvnet/__init__.py

@@ -0,0 +1,2 @@
+"""PVNet"""
+__version__ = "3.0.24"

{PVNet-3.0.22 → PVNet-3.0.24}/pvnet/models/base_model.py

@@ -165,7 +165,7 @@ class PVNetModelHubMixin(PyTorchModelHubMixin):
         self,
         save_directory: Union[str, Path],
         config: dict,
-        data_config: Union[str, Path],
+        data_config: Optional[Union[str, Path]],
         repo_id: Optional[str] = None,
         push_to_hub: bool = False,
         wandb_ids: Optional[Union[list[str], str]] = None,
@@ -206,7 +206,8 @@ class PVNetModelHubMixin(PyTorchModelHubMixin):
             (save_directory / CONFIG_NAME).write_text(json.dumps(config, indent=4))
 
         # Save cleaned datapipes configuration file
-        make_clean_data_config(data_config, save_directory / DATA_CONFIG_NAME)
+        if data_config is not None:
+            make_clean_data_config(data_config, save_directory / DATA_CONFIG_NAME)
 
         # Creating and saving model card.
         card_data = ModelCardData(language="en", license="mit", library_name="pytorch")
@@ -301,6 +302,7 @@ class BaseModel(pl.LightningModule, PVNetModelHubMixin):
         self._accumulated_metrics = MetricAccumulator()
         self._accumulated_batches = BatchAccumulator(key_to_keep=self._target_key_name)
         self._accumulated_y_hat = PredAccumulator()
+        self._horizon_maes = MetricAccumulator()
 
         # Store whether the model should use quantile regression or simply predict the mean
         self.use_quantile_regression = self.output_quantiles is not None
@@ -389,6 +391,18 @@ class BaseModel(pl.LightningModule, PVNetModelHubMixin):
 
         return losses
 
+    def _step_mae_and_mse(self, y, y_hat, dict_key_root):
+        """Calculate the MSE and MAE at each forecast step"""
+        losses = {}
+
+        mse_each_step = torch.mean((y_hat - y) ** 2, dim=0)
+        mae_each_step = torch.mean(torch.abs(y_hat - y), dim=0)
+
+        losses.update({f"MSE_{dict_key_root}/step_{i:03}": m for i, m in enumerate(mse_each_step)})
+        losses.update({f"MAE_{dict_key_root}/step_{i:03}": m for i, m in enumerate(mae_each_step)})
+
+        return losses
+
     def _calculate_val_losses(self, y, y_hat):
         """Calculate additional validation losses"""
 
@@ -404,12 +418,17 @@ class BaseModel(pl.LightningModule, PVNetModelHubMixin):
 
             # Take median value for remaining metric calculations
             y_hat = self._quantiles_to_prediction(y_hat)
-        mse_each_step = torch.mean((y_hat - y) ** 2, dim=0)
-        mae_each_step = torch.mean(torch.abs(y_hat - y), dim=0)
 
-        losses.update({f"MSE_horizon/step_{i:03}": m for i, m in enumerate(mse_each_step)})
-        losses.update({f"MAE_horizon/step_{i:03}": m for i, m in enumerate(mae_each_step)})
+        # Log the loss at each time horizon
+        losses.update(self._step_mae_and_mse(y, y_hat, dict_key_root="horizon"))
+
+        # Log the persistance losses
+        y_persist = y[:, -1].unsqueeze(1).expand(-1, self.forecast_len)
+        losses["MAE_persistence/val"] = F.l1_loss(y_persist, y)
+        losses["MSE_persistence/val"] = F.mse_loss(y_persist, y)
 
+        # Log persistance loss at each time horizon
+        losses.update(self._step_mae_and_mse(y, y_persist, dict_key_root="persistence"))
         return losses
 
     def _calculate_test_losses(self, y, y_hat):
@@ -476,51 +495,36 @@ class BaseModel(pl.LightningModule, PVNetModelHubMixin):
             opt_target = losses["MAE/train"]
         return opt_target
 
+    def _log_forecast_plot(self, batch, y_hat, accum_batch_num, timesteps_to_plot, plot_suffix):
+        """Log forecast plot to wandb"""
+        fig = plot_batch_forecasts(
+            batch,
+            y_hat,
+            quantiles=self.output_quantiles,
+            key_to_plot=self._target_key_name,
+        )
+
+        plot_name = f"val_forecast_samples/batch_idx_{accum_batch_num}_{plot_suffix}"
+
+        self.logger.experiment.log({plot_name: wandb.Image(fig)})
+        plt.close(fig)
+
     def validation_step(self, batch: dict, batch_idx):
         """Run validation step"""
         y_hat = self(batch)
         # Sensor seems to be in batch, station, time order
         y = batch[self._target_key][:, -self.forecast_len :, 0]
-        persistence = batch[self._target_key][:, -self.forecast_len - 1, 0]
+
         # Expand persistence to be the same shape as y
-        persistence = persistence.unsqueeze(1).expand(-1, self.forecast_len)
         losses = self._calculate_common_losses(y, y_hat)
         losses.update(self._calculate_val_losses(y, y_hat))
 
+        # Store these to make horizon accuracy plot
+        self._horizon_maes.append(
+            {i: losses[f"MAE_horizon/step_{i:03}"] for i in range(self.forecast_len)}
+        )
+
         logged_losses = {f"{k}/val": v for k, v in losses.items()}
-        logged_losses["MAE_persistence/val"] = F.l1_loss(persistence, y)
-        logged_losses["MSE_persistence/val"] = F.mse_loss(persistence, y)
-        # Log for each timestep the persistence loss
-        for i in range(self.forecast_len):
-            logged_losses[f"MAE_persistence/step_{i:03}/val"] = F.l1_loss(
-                persistence[:, i], y[:, i]
-            )
-            logged_losses[f"MSE_persistence/step_{i:03}/val"] = F.mse_loss(
-                persistence[:, i], y[:, i]
-            )
-        # Get the losses in the format of {VAL>_horizon/step_000: 0.1, VAL>_horizon/step_001: 0.2}
-        # for each step in the forecast horizon
-        # This is needed for the custom plot
-        # And needs to be in order of step
-        x_values = [
-            int(k.split("_")[-1].split("/")[0])
-            for k in logged_losses.keys()
-            if "MAE_horizon/step" in k
-        ]
-        y_values = []
-        for x in x_values:
-            y_values.append(logged_losses[f"MAE_horizon/step_{x:03}/val"])
-        per_step_losses = [[x, y] for (x, y) in zip(x_values, y_values)]
-        # Check if WandBLogger is being used
-        if isinstance(self.logger, pl.loggers.WandbLogger):
-            table = wandb.Table(data=per_step_losses, columns=["timestep", "MAE"])
-            wandb.log(
-                {
-                    "mae_vs_timestep": wandb.plot.line(
-                        table, "timestep", "MAE", title="MAE vs Timestep"
-                    )
-                }
-            )
 
         self.log_dict(
             logged_losses,
@@ -530,7 +534,8 @@ class BaseModel(pl.LightningModule, PVNetModelHubMixin):
 
         accum_batch_num = batch_idx // self.trainer.accumulate_grad_batches
 
-        if accum_batch_num in [0, 1]:
+        # Make plots only if using wandb logger
+        if isinstance(self.logger, pl.loggers.WandbLogger) and accum_batch_num in [0, 1]:
             # Store these temporarily under self
             if not hasattr(self, "_val_y_hats"):
                 self._val_y_hats = PredAccumulator()
@@ -538,47 +543,53 @@ class BaseModel(pl.LightningModule, PVNetModelHubMixin):
 
             self._val_y_hats.append(y_hat)
             self._val_batches.append(batch)
-            # if batch had accumulated
+
+            # if batch has accumulated
             if (batch_idx + 1) % self.trainer.accumulate_grad_batches == 0:
                 y_hat = self._val_y_hats.flush()
                 batch = self._val_batches.flush()
 
-                fig = plot_batch_forecasts(
+                self._log_forecast_plot(
                     batch,
                     y_hat,
-                    quantiles=self.output_quantiles,
-                    key_to_plot=self._target_key_name,
+                    accum_batch_num,
+                    timesteps_to_plot=None,
+                    plot_suffix="all",
                 )
 
-                self.logger.experiment.log(
-                    {
-                        f"val_forecast_samples/batch_idx_{accum_batch_num}_all": wandb.Image(fig),
-                    }
-                )
-                plt.close(fig)
-
                 if self.time_step_intervals_to_plot is not None:
                     for interval in self.time_step_intervals_to_plot:
-                        fig = plot_batch_forecasts(
+                        self._log_forecast_plot(
                             batch,
                             y_hat,
-                            quantiles=self.output_quantiles,
-                            key_to_plot=self._target_key_name,
+                            accum_batch_num,
                             timesteps_to_plot=interval,
+                            plot_suffix=f"timestep_{interval}",
                         )
-                        self.logger.experiment.log(
-                            {
-                                f"val_forecast_samples/batch_idx_{accum_batch_num}_"
-                                f"timestep_{interval}": wandb.Image(fig),
-                            }
-                        )
-                        plt.close(fig)
 
                 del self._val_y_hats
                 del self._val_batches
 
         return logged_losses
 
+    def on_validation_epoch_end(self):
+        """Run on epoch end"""
+
+        horizon_maes_dict = self._horizon_maes.flush()
+
+        # Create the horizon accuracy curve
+        if isinstance(self.logger, pl.loggers.WandbLogger):
+            per_step_losses = [[i, horizon_maes_dict[i]] for i in range(self.forecast_len)]
+
+            table = wandb.Table(data=per_step_losses, columns=["horizon_step", "MAE"])
+            wandb.log(
+                {
+                    "horizon_loss_curve": wandb.plot.line(
+                        table, "horizon_step", "MAE", title="Horizon loss curve"
+                    )
+                },
+            )
+
     def test_step(self, batch, batch_idx):
         """Run test step"""
         y_hat = self(batch)

{PVNet-3.0.22 → PVNet-3.0.24}/pvnet/models/multimodal/unimodal_teacher.py

@@ -369,7 +369,10 @@ class Model(MultimodalBaseModel):
     def convert_to_multimodal_model(self, config):
         """Convert the model into a multimodal model class whilst preserving weights"""
         config = config.copy()
-        del config["cold_start"]
+
+        if "cold_start" in config:
+            del config["cold_start"]
+
         config["_target_"] = "pvnet.models.multimodal.multimodal.Model"
 
         sources = []
@@ -416,4 +419,10 @@ class Model(MultimodalBaseModel):
 
         multimodal_model.output_network.load_state_dict(self.output_network.state_dict())
 
+        if self.embedding_dim:
+            multimodal_model.embed.load_state_dict(self.embed.state_dict())
+
+        if self.include_sun:
+            multimodal_model.sun_fc1.load_state_dict(self.sun_fc1.state_dict())
+
         return multimodal_model, config

{PVNet-3.0.22 → PVNet-3.0.24}/pvnet/optimizers.py

@@ -185,7 +185,6 @@ class AdamWReduceLROnPlateau(AbstractOptimizer):
         if not isinstance(self._lr, float):
             return self._call_multi(model)
         else:
-            assert False
             default_lr = self._lr if model.lr is None else model.lr
             opt = torch.optim.AdamW(model.parameters(), lr=default_lr, **self.opt_kwargs)
             sch = torch.optim.lr_scheduler.ReduceLROnPlateau(

PVNet-3.0.22/pvnet/__init__.py

@@ -1,2 +0,0 @@
-"""PVNet"""
-__version__ = "3.0.22"