PVNet_summation 1.1.0__tar.gz → 1.1.1__tar.gz

{pvnet_summation-1.1.0 → pvnet_summation-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PVNet_summation
-Version: 1.1.0
+Version: 1.1.1
 Summary: PVNet_summation
 Author-email: James Fulton <info@openclimatefix.org>
 Requires-Python: >=3.11

{pvnet_summation-1.1.0 → pvnet_summation-1.1.1}/PVNet_summation.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PVNet_summation
-Version: 1.1.0
+Version: 1.1.1
 Summary: PVNet_summation
 Author-email: James Fulton <info@openclimatefix.org>
 Requires-Python: >=3.11

{pvnet_summation-1.1.0 → pvnet_summation-1.1.1}/pvnet_summation/training/lightning_module.py

@@ -141,6 +141,7 @@ class PVNetSummationLightningModule(pl.LightningModule):
         self._val_horizon_maes: list[np.array] = []
         if self.current_epoch==0:
             self._val_persistence_horizon_maes: list[np.array] = []
+            self._val_loc_sum_horizon_maes: list[np.array] = []
         
         # Plot some sample forecasts
         val_dataset = self.trainer.val_dataloaders.dataset
@@ -159,8 +160,10 @@ class PVNetSummationLightningModule(pl.LightningModule):
             batch = self.transfer_batch_to_device(batch, self.device, dataloader_idx=0)
             with torch.no_grad():
                 y_hat = self.model(batch)
+
+            y_loc_sum = self.model.sum_of_locations(batch)
             
-            fig = plot_sample_forecasts(batch, y_hat, quantiles=self.model.output_quantiles)
+            fig = plot_sample_forecasts(batch, y_hat, y_loc_sum, self.model.output_quantiles)
 
             plot_name = f"val_forecast_samples/sample_set_{plot_num}"
 
@@ -195,9 +198,11 @@ class PVNetSummationLightningModule(pl.LightningModule):
         losses.update({f"val_step_MAE/step_{i:03}": m for i, m in enumerate(mae_step)})
         losses.update({f"val_step_MSE/step_{i:03}": m for i, m in enumerate(mse_step)})
 
-        # Calculate the persistance losses - we only need to do this once per training run
-        # not every epoch
+        # Calculate the persistence and sum-of-locations losses - we only need to do this once per 
+        # training run not every epoch
         if self.current_epoch==0:
+            
+            # Persistence
             y_persist = batch["last_outturn"].unsqueeze(1).expand(-1, self.model.forecast_len)
             mae_step_persist, mse_step_persist = self._calculate_step_metrics(y, y_persist)
             self._val_persistence_horizon_maes.append(mae_step_persist)
@@ -208,6 +213,17 @@ class PVNetSummationLightningModule(pl.LightningModule):
                 }
             )
 
+            # Sum of Locations
+            y_loc_sum = self.model.sum_of_locations(batch)
+            mae_step_loc_sum, mse_step_loc_sum = self._calculate_step_metrics(y, y_loc_sum)
+            self._val_loc_sum_horizon_maes.append(mae_step_loc_sum)
+            losses.update(
+                {
+                    "MAE/val_location_sum": mae_step_loc_sum.mean(), 
+                    "MSE/val_location_sum": mse_step_loc_sum.mean()
+                }
+            )
+
         # Log the metrics
         self.log_dict(losses, on_step=False, on_epoch=True)
 
@@ -217,11 +233,6 @@ class PVNetSummationLightningModule(pl.LightningModule):
         val_horizon_maes = np.mean(self._val_horizon_maes, axis=0)
         self._val_horizon_maes = []
 
-        # We only run this on the first epoch
-        if self.current_epoch==0:
-            val_persistence_horizon_maes = np.mean(self._val_persistence_horizon_maes, axis=0)
-            self._val_persistence_horizon_maes = []
-
         if isinstance(self.logger, pl.loggers.WandbLogger):
             
             # Create the horizon accuracy curve
@@ -235,8 +246,14 @@ class PVNetSummationLightningModule(pl.LightningModule):
             
             wandb.log({"val_horizon_mae_plot": horizon_mae_plot})
 
-            # Create persistence horizon accuracy curve but only on first epoch
+            # Create persistence and location-sum horizon accuracy curve on first epoch
             if self.current_epoch==0:
+                val_persistence_horizon_maes = np.mean(self._val_persistence_horizon_maes, axis=0)
+                del self._val_persistence_horizon_maes
+
+                val_loc_sum_horizon_maes = np.mean(self._val_loc_sum_horizon_maes, axis=0)
+                del self._val_loc_sum_horizon_maes
+
                 persist_horizon_mae_plot = wandb_line_plot(
                     x=np.arange(self.model.forecast_len), 
                     y=val_persistence_horizon_maes,
@@ -244,4 +261,18 @@ class PVNetSummationLightningModule(pl.LightningModule):
                     ylabel="MAE",
                     title="Val persistence horizon loss curve",
                 )
-                wandb.log({"persistence_val_horizon_mae_plot": persist_horizon_mae_plot})
+
+                loc_sum_horizon_mae_plot = wandb_line_plot(
+                    x=np.arange(self.model.forecast_len), 
+                    y=val_loc_sum_horizon_maes,
+                    xlabel="Horizon step",
+                    ylabel="MAE",
+                    title="Val location-sum horizon loss curve",
+                )
+
+                wandb.log(
+                    {
+                        "persistence_val_horizon_mae_plot": persist_horizon_mae_plot,
+                        "location_sum_val_horizon_mae_plot": loc_sum_horizon_mae_plot,
+                    }
+                )

{pvnet_summation-1.1.0 → pvnet_summation-1.1.1}/pvnet_summation/training/plots.py

@@ -26,12 +26,14 @@ def wandb_line_plot(
 def plot_sample_forecasts(
     batch: SumTensorBatch,
     y_hat: torch.Tensor,
+    y_loc_sum: torch.Tensor,
     quantiles: list[float] | None,
 ) -> plt.Figure:
     """Plot a batch of data and the forecast from that batch"""
 
     y = batch["target"].cpu().numpy()
-    y_hat = y_hat.cpu().numpy()    
+    y_hat = y_hat.cpu().numpy()
+    y_loc_sum = y_loc_sum.cpu().numpy()
     times_utc = pd.to_datetime(batch["valid_times"].cpu().numpy().astype("datetime64[ns]"))
     batch_size = y.shape[0]
 
@@ -41,9 +43,18 @@ def plot_sample_forecasts(
 
         ax.plot(times_utc[i], y[i], marker=".", color="k", label=r"$y$")
 
+        ax.plot(
+            times_utc[i],
+            y_loc_sum[i], 
+            marker=".",
+            linestyle="-.",
+            color="r",
+            label=r"$\hat{y}_{loc-sum}$",
+        )
+
         if quantiles is None:
             ax.plot(
-                times_utc[i][-len(y_hat[i]) :],
+                times_utc[i],
                 y_hat[i], 
                 marker=".", 
                 color="r", 
@@ -53,7 +64,7 @@ def plot_sample_forecasts(
             cm = pylab.get_cmap("twilight")
             for nq, q in enumerate(quantiles):
                 ax.plot(
-                    times_utc[i][-len(y_hat[i]) :],
+                    times_utc[i],
                     y_hat[i, :, nq],
                     color=cm(q),
                     label=r"$\hat{y}$" + f"({q})",