PVNet 2.6.10__tar.gz → 2.6.11__tar.gz

{PVNet-2.6.10 → PVNet-2.6.11}/PKG-INFO

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

{PVNet-2.6.10 → PVNet-2.6.11}/PVNet.egg-info/PKG-INFO

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

{PVNet-2.6.10 → PVNet-2.6.11}/PVNet.egg-info/SOURCES.txt

@@ -16,7 +16,9 @@ pvnet/optimizers.py
 pvnet/training.py
 pvnet/utils.py
 pvnet/data/__init__.py
+pvnet/data/base.py
 pvnet/data/datamodule.py
+pvnet/data/pv_site_datamodule.py
 pvnet/data/utils.py
 pvnet/data/wind_datamodule.py
 pvnet/models/__init__.py

PVNet-2.6.11/pvnet/__init__.py

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

PVNet-2.6.10/pvnet/data/datamodule.py → PVNet-2.6.11/pvnet/data/base.py

@@ -11,7 +11,7 @@ from torch.utils.data.datapipes.iter import FileLister
 from pvnet.data.utils import batch_to_tensor
 
 
-class DataModule(LightningDataModule):
+class BaseDataModule(LightningDataModule):
     """Datamodule for training pvnet and using pvnet pipeline in `ocf_datapipes`."""
 
     def __init__(

PVNet-2.6.11/pvnet/data/datamodule.py

@@ -0,0 +1,92 @@
+""" Data module for pytorch lightning """
+
+import torch
+from ocf_datapipes.batch import stack_np_examples_into_batch
+from ocf_datapipes.training.pvnet import pvnet_datapipe
+from torch.utils.data.datapipes.iter import FileLister
+
+from pvnet.data.base import BaseDataModule
+from pvnet.data.utils import batch_to_tensor
+
+
+class DataModule(BaseDataModule):
+    """Datamodule for training pvnet and using pvnet pipeline in `ocf_datapipes`."""
+
+    def __init__(
+        self,
+        configuration=None,
+        batch_size=16,
+        num_workers=0,
+        prefetch_factor=None,
+        train_period=[None, None],
+        val_period=[None, None],
+        test_period=[None, None],
+        batch_dir=None,
+    ):
+        """Datamodule for training pvnet and using pvnet pipeline in `ocf_datapipes`.
+
+        Can also be used with pre-made batches if `batch_dir` is set.
+
+
+        Args:
+            configuration: Path to datapipe configuration file.
+            batch_size: Batch size.
+            num_workers: Number of workers to use in multiprocess batch loading.
+            prefetch_factor: Number of data will be prefetched at the end of each worker process.
+            train_period: Date range filter for train dataloader.
+            val_period: Date range filter for val dataloader.
+            test_period: Date range filter for test dataloader.
+            batch_dir: Path to the directory of pre-saved batches. Cannot be used together with
+                `configuration` or 'train/val/test_period'.
+
+        """
+        super().__init__(
+            configuration=configuration,
+            batch_size=batch_size,
+            num_workers=num_workers,
+            prefetch_factor=prefetch_factor,
+            train_period=train_period,
+            val_period=val_period,
+            test_period=test_period,
+            batch_dir=batch_dir,
+        )
+
+    def _get_datapipe(self, start_time, end_time):
+        data_pipeline = pvnet_datapipe(
+            self.configuration,
+            start_time=start_time,
+            end_time=end_time,
+        )
+
+        data_pipeline = (
+            data_pipeline.batch(self.batch_size)
+            .map(stack_np_examples_into_batch)
+            .map(batch_to_tensor)
+        )
+        return data_pipeline
+
+    def _get_premade_batches_datapipe(self, subdir, shuffle=False):
+        data_pipeline = FileLister(f"{self.batch_dir}/{subdir}", masks="*.pt", recursive=False)
+        if shuffle:
+            data_pipeline = (
+                data_pipeline.shuffle(buffer_size=10_000)
+                .sharding_filter()
+                .map(torch.load)
+                # Split the batches and reshuffle them to be combined into new batches
+                .split_batches()
+                .shuffle(buffer_size=100 * self.batch_size)
+            )
+        else:
+            data_pipeline = (
+                data_pipeline.sharding_filter().map(torch.load)
+                # Split the batches so we can use any batch-size
+                .split_batches()
+            )
+
+        data_pipeline = (
+            data_pipeline.batch(self.batch_size)
+            .map(stack_np_examples_into_batch)
+            .map(batch_to_tensor)
+        )
+
+        return data_pipeline

PVNet-2.6.11/pvnet/data/pv_site_datamodule.py

@@ -0,0 +1,98 @@
+""" Data module for pytorch lightning """
+import glob
+
+from ocf_datapipes.batch import BatchKey, stack_np_examples_into_batch
+from ocf_datapipes.training.pvnet_site import pvnet_site_netcdf_datapipe
+
+from pvnet.data.base import BaseDataModule
+from pvnet.data.utils import batch_to_tensor
+
+
+class PVSiteDataModule(BaseDataModule):
+    """Datamodule for training pvnet site and using pvnet site pipeline in `ocf_datapipes`."""
+
+    def __init__(
+        self,
+        configuration=None,
+        batch_size=16,
+        num_workers=0,
+        prefetch_factor=None,
+        train_period=[None, None],
+        val_period=[None, None],
+        test_period=[None, None],
+        batch_dir=None,
+    ):
+        """Datamodule for training pvnet stie and using pvnet site pipeline in `ocf_datapipes`.
+
+        Can also be used with pre-made batches if `batch_dir` is set.
+
+
+        Args:
+            configuration: Path to datapipe configuration file.
+            batch_size: Batch size.
+            num_workers: Number of workers to use in multiprocess batch loading.
+            train_period: Date range filter for train dataloader.
+            val_period: Date range filter for val dataloader.
+            test_period: Date range filter for test dataloader.
+            prefetch_factor: Number of data will be prefetched at the end of each worker process.
+            batch_dir: Path to the directory of pre-saved batches. Cannot be used together with
+                'train/val/test_period'.
+
+        """
+        super().__init__(
+            configuration=configuration,
+            batch_size=batch_size,
+            num_workers=num_workers,
+            prefetch_factor=prefetch_factor,
+            train_period=train_period,
+            val_period=val_period,
+            test_period=test_period,
+            batch_dir=batch_dir,
+        )
+
+    def _get_datapipe(self, start_time, end_time):
+        data_pipeline = pvnet_site_netcdf_datapipe(
+            keys=["pv", "nwp"],
+        )
+
+        data_pipeline = (
+            data_pipeline.batch(self.batch_size)
+            .map(stack_np_examples_into_batch)
+            .map(batch_to_tensor)
+        )
+        return data_pipeline
+
+    def _get_premade_batches_datapipe(self, subdir, shuffle=False):
+        filenames = list(glob.glob(f"{self.batch_dir}/{subdir}/*.nc"))
+        data_pipeline = pvnet_site_netcdf_datapipe(
+            keys=["pv", "nwp"],
+            filenames=filenames,
+        )
+        data_pipeline = (
+            data_pipeline.batch(self.batch_size)
+            .map(stack_np_examples_into_batch)
+            .map(batch_to_tensor)
+        )
+        if shuffle:
+            data_pipeline = (
+                data_pipeline.shuffle(buffer_size=100)
+                .sharding_filter()
+                # Split the batches and reshuffle them to be combined into new batches
+                .split_batches(splitting_key=BatchKey.pv)
+                .shuffle(buffer_size=100 * self.batch_size)
+            )
+        else:
+            data_pipeline = (
+                data_pipeline.sharding_filter()
+                # Split the batches so we can use any batch-size
+                .split_batches(splitting_key=BatchKey.pv)
+            )
+
+        data_pipeline = (
+            data_pipeline.batch(self.batch_size)
+            .map(stack_np_examples_into_batch)
+            .map(batch_to_tensor)
+            .set_length(int(len(filenames) / self.batch_size))
+        )
+
+        return data_pipeline

PVNet-2.6.11/pvnet/data/wind_datamodule.py

@@ -0,0 +1,99 @@
+""" Data module for pytorch lightning """
+import glob
+
+from ocf_datapipes.batch import BatchKey, stack_np_examples_into_batch
+from ocf_datapipes.training.windnet import windnet_netcdf_datapipe
+
+from pvnet.data.base import BaseDataModule
+from pvnet.data.utils import batch_to_tensor
+
+
+class WindDataModule(BaseDataModule):
+    """Datamodule for training windnet and using windnet pipeline in `ocf_datapipes`."""
+
+    def __init__(
+        self,
+        configuration=None,
+        batch_size=16,
+        num_workers=0,
+        prefetch_factor=None,
+        train_period=[None, None],
+        val_period=[None, None],
+        test_period=[None, None],
+        batch_dir=None,
+    ):
+        """Datamodule for training windnet and using windnet pipeline in `ocf_datapipes`.
+
+        Can also be used with pre-made batches if `batch_dir` is set.
+
+
+        Args:
+            configuration: Path to datapipe configuration file.
+            batch_size: Batch size.
+            train_period: Date range filter for train dataloader.
+            val_period: Date range filter for val dataloader.
+            test_period: Date range filter for test dataloader.
+            num_workers: Number of workers to use in multiprocess batch loading.
+            prefetch_factor: Number of data will be prefetched at the end of each worker process.
+            batch_dir: Path to the directory of pre-saved batches. Cannot be used together with
+                'train/val/test_period'.
+
+        """
+        super().__init__(
+            configuration=configuration,
+            batch_size=batch_size,
+            num_workers=num_workers,
+            prefetch_factor=prefetch_factor,
+            train_period=train_period,
+            val_period=val_period,
+            test_period=test_period,
+            batch_dir=batch_dir,
+        )
+
+    def _get_datapipe(self, start_time, end_time):
+        data_pipeline = windnet_netcdf_datapipe(
+            self.configuration,
+            keys=["wind", "nwp"],
+        )
+
+        data_pipeline = (
+            data_pipeline.batch(self.batch_size)
+            .map(stack_np_examples_into_batch)
+            .map(batch_to_tensor)
+        )
+        return data_pipeline
+
+    def _get_premade_batches_datapipe(self, subdir, shuffle=False):
+        filenames = list(glob.glob(f"{self.batch_dir}/{subdir}/*.nc"))
+        data_pipeline = windnet_netcdf_datapipe(
+            keys=["wind", "nwp"],
+            filenames=filenames,
+        )
+        data_pipeline = (
+            data_pipeline.batch(self.batch_size)
+            .map(stack_np_examples_into_batch)
+            .map(batch_to_tensor)
+        )
+        if shuffle:
+            data_pipeline = (
+                data_pipeline.shuffle(buffer_size=100)
+                .sharding_filter()
+                # Split the batches and reshuffle them to be combined into new batches
+                .split_batches(splitting_key=BatchKey.wind)
+                .shuffle(buffer_size=100 * self.batch_size)
+            )
+        else:
+            data_pipeline = (
+                data_pipeline.sharding_filter()
+                # Split the batches so we can use any batch-size
+                .split_batches(splitting_key=BatchKey.wind)
+            )
+
+        data_pipeline = (
+            data_pipeline.batch(self.batch_size)
+            .map(stack_np_examples_into_batch)
+            .map(batch_to_tensor)
+            .set_length(int(len(filenames) / self.batch_size))
+        )
+
+        return data_pipeline

{PVNet-2.6.10 → PVNet-2.6.11}/pvnet/models/base_model.py

@@ -7,6 +7,7 @@ from typing import Dict, Optional, Union
 
 import hydra
 import lightning.pytorch as pl
+import matplotlib.pyplot as plt
 import pandas as pd
 import torch
 import torch.nn.functional as F
@@ -19,7 +20,6 @@ from huggingface_hub.hf_api import HfApi
 from huggingface_hub.utils._deprecation import _deprecate_positional_args
 from ocf_datapipes.batch import BatchKey
 from ocf_ml_metrics.evaluation.evaluation import evaluation
-from ocf_ml_metrics.metrics.errors import common_metrics
 
 from pvnet.models.utils import (
     BatchAccumulator,
@@ -65,6 +65,11 @@ def make_clean_data_config(input_path, output_path, placeholder="PLACEHOLDER"):
             d["pv_filename"] = f"{placeholder}.netcdf"
             d["pv_metadata_filename"] = f"{placeholder}.csv"
 
+    if "sensor" in config["input_data"]:
+        # If not empty - i.e. if used
+        if config["input_data"][source][f"{source}_filename"] != "":
+            config["input_data"][source][f"{source}_filename"] = f"{placeholder}.nc"
+
     with open(output_path, "w") as outfile:
         yaml.dump(config, outfile, default_flow_style=False)
 
@@ -234,7 +239,9 @@ class BaseModel(pl.LightningModule, PVNetModelHubMixin):
         forecast_minutes: int,
         optimizer: AbstractOptimizer,
         output_quantiles: Optional[list[float]] = None,
-        target_key: BatchKey = BatchKey.gsp,
+        target_key: str = "gsp",
+        interval_minutes: int = 30,
+        timestep_intervals_to_plot: Optional[list[int]] = None,
     ):
         """Abtstract base class for PVNet submodels.
 
@@ -245,11 +252,21 @@ class BaseModel(pl.LightningModule, PVNetModelHubMixin):
             output_quantiles: A list of float (0.0, 1.0) quantiles to predict values for. If set to
                 None the output is a single value.
             target_key: The key of the target variable in the batch
+            interval_minutes: The interval in minutes between each timestep in the data
+            timestep_intervals_to_plot: Intervals, in timesteps, to plot during training
         """
         super().__init__()
 
         self._optimizer = optimizer
-        self._target_key = target_key
+        self._target_key_name = target_key
+        self._target_key = BatchKey[f"{target_key}"]
+        if timestep_intervals_to_plot is not None:
+            for interval in timestep_intervals_to_plot:
+                assert type(interval) in [list, tuple] and len(interval) == 2, ValueError(
+                    f"timestep_intervals_to_plot must be a list of tuples or lists of length 2, "
+                    f"but got {timestep_intervals_to_plot=}"
+                )
+        self.time_step_intervals_to_plot = timestep_intervals_to_plot
 
         # Model must have lr to allow tuning
         # This setting is only used when lr is tuned with callback
@@ -260,13 +277,13 @@ class BaseModel(pl.LightningModule, PVNetModelHubMixin):
         self.output_quantiles = output_quantiles
 
         # Number of timestemps for 30 minutely data
-        self.history_len_30 = history_minutes // 30
-        self.forecast_len_30 = forecast_minutes // 30
+        self.history_len = history_minutes // interval_minutes
+        self.forecast_len = forecast_minutes // interval_minutes
 
-        self.weighted_losses = WeightedLosses(forecast_length=self.forecast_len_30)
+        self.weighted_losses = WeightedLosses(forecast_length=self.forecast_len)
 
         self._accumulated_metrics = MetricAccumulator()
-        self._accumulated_batches = BatchAccumulator()
+        self._accumulated_batches = BatchAccumulator(key_to_keep=self._target_key_name)
         self._accumulated_y_hat = PredAccumulator()
 
     @property
@@ -278,9 +295,9 @@ class BaseModel(pl.LightningModule, PVNetModelHubMixin):
     def num_output_features(self):
         """Number of ouput features he model chould predict for"""
         if self.use_quantile_regression:
-            out_features = self.forecast_len_30 * len(self.output_quantiles)
+            out_features = self.forecast_len * len(self.output_quantiles)
         else:
-            out_features = self.forecast_len_30
+            out_features = self.forecast_len
         return out_features
 
     def _quantiles_to_prediction(self, y_quantiles):
@@ -372,15 +389,12 @@ 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)
 
-        common_metrics_each_step = common_metrics(
-            predictions=y_hat.cpu().numpy(), target=y.cpu().numpy()
-        )
-        mse_each_step = common_metrics_each_step["rmse"] ** 2
-        mae_each_step = common_metrics_each_step["mae"]
+        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)})
 
-        losses.update({f"MSE_horizon/step_{i:02}": m for i, m in enumerate(mse_each_step)})
-        losses.update({f"MAE_horizon/step_{i:02}": m for i, m in enumerate(mae_each_step)})
         return losses
 
     def _calculate_test_losses(self, y, y_hat):
@@ -421,13 +435,20 @@ class BaseModel(pl.LightningModule, PVNetModelHubMixin):
             # We only create the figure every 8 log steps
             # This was reduced as it was creating figures too often
             if grad_batch_num % (8 * self.trainer.log_every_n_steps) == 0:
-                fig = plot_batch_forecasts(batch, y_hat, batch_idx, quantiles=self.output_quantiles)
+                fig = plot_batch_forecasts(
+                    batch,
+                    y_hat,
+                    batch_idx,
+                    quantiles=self.output_quantiles,
+                    key_to_plot=self._target_key_name,
+                )
                 fig.savefig("latest_logged_train_batch.png")
+                plt.close(fig)
 
     def training_step(self, batch, batch_idx):
         """Run training step"""
         y_hat = self(batch)
-        y = batch[self._target_key][:, -self.forecast_len_30 :, 0]
+        y = batch[self._target_key][:, -self.forecast_len :, 0]
 
         losses = self._calculate_common_losses(y, y_hat)
         losses = {f"{k}/train": v for k, v in losses.items()}
@@ -443,12 +464,36 @@ class BaseModel(pl.LightningModule, PVNetModelHubMixin):
     def validation_step(self, batch: dict, batch_idx):
         """Run validation step"""
         y_hat = self(batch)
-        y = batch[self._target_key][:, -self.forecast_len_30 :, 0]
+        # Sensor seems to be in batch, station, time order
+        y = batch[self._target_key][:, -self.forecast_len :, 0]
 
         losses = self._calculate_common_losses(y, y_hat)
         losses.update(self._calculate_val_losses(y, y_hat))
 
         logged_losses = {f"{k}/val": v for k, v in losses.items()}
+        # 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,
@@ -462,23 +507,46 @@ class BaseModel(pl.LightningModule, PVNetModelHubMixin):
             # Store these temporarily under self
             if not hasattr(self, "_val_y_hats"):
                 self._val_y_hats = PredAccumulator()
-                self._val_batches = BatchAccumulator()
+                self._val_batches = BatchAccumulator(key_to_keep=self._target_key_name)
 
             self._val_y_hats.append(y_hat)
             self._val_batches.append(batch)
-
             # if batch had 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(batch, y_hat, quantiles=self.output_quantiles)
+                fig = plot_batch_forecasts(
+                    batch,
+                    y_hat,
+                    quantiles=self.output_quantiles,
+                    key_to_plot=self._target_key_name,
+                )
 
                 self.logger.experiment.log(
                     {
-                        f"val_forecast_samples/batch_idx_{accum_batch_num}": wandb.Image(fig),
+                        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(
+                            batch,
+                            y_hat,
+                            quantiles=self.output_quantiles,
+                            key_to_plot=self._target_key_name,
+                            timesteps_to_plot=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
 
@@ -487,7 +555,7 @@ class BaseModel(pl.LightningModule, PVNetModelHubMixin):
     def test_step(self, batch, batch_idx):
         """Run test step"""
         y_hat = self(batch)
-        y = batch[self._target_key][:, -self.forecast_len_30 :, 0]
+        y = batch[self._target_key][:, -self.forecast_len :, 0]
 
         losses = self._calculate_common_losses(y, y_hat)
         losses.update(self._calculate_val_losses(y, y_hat))

{PVNet-2.6.10 → PVNet-2.6.11}/pvnet/models/baseline/last_value.py

@@ -36,8 +36,8 @@ class Model(BaseModel):
 
         # take the last value non forecaster value and the first in the pv yeild
         # (this is the pv site we are preditcting for)
-        y_hat = gsp_yield[:, -self.forecast_len_30 - 1, 0]
+        y_hat = gsp_yield[:, -self.forecast_len - 1, 0]
 
         # expand the last valid forward n predict steps
-        out = y_hat.unsqueeze(1).repeat(1, self.forecast_len_30)
+        out = y_hat.unsqueeze(1).repeat(1, self.forecast_len)
         return out

{PVNet-2.6.10 → PVNet-2.6.11}/pvnet/models/baseline/single_value.py

@@ -33,5 +33,5 @@ class Model(BaseModel):
     def forward(self, x: dict):
         """Run model forward on dict batch of data"""
         # Returns a single value at all steps
-        y_hat = torch.zeros_like(x[BatchKey.gsp][:, : self.forecast_len_30, 0]) + self._value
+        y_hat = torch.zeros_like(x[BatchKey.gsp][:, : self.forecast_len, 0]) + self._value
         return y_hat

{PVNet-2.6.10 → PVNet-2.6.11}/pvnet/models/multimodal/deep_supervision.py

@@ -161,7 +161,7 @@ class Model(BaseModel):
         if self.include_sun:
             # the minus 12 is bit of hard coded smudge for pvnet
             self.sun_fc1 = nn.Linear(
-                in_features=2 * (self.forecast_len_30 + self.history_len_30 + 1),
+                in_features=2 * (self.forecast_len + self.history_len + 1),
                 out_features=16,
             )
 
@@ -170,18 +170,18 @@ class Model(BaseModel):
             num_cat_features += encoder_out_features
             self.sat_output_network = output_network(
                 in_features=encoder_out_features,
-                out_features=self.forecast_len_30,
+                out_features=self.forecast_len,
                 **output_network_kwargs,
             )
         if include_nwp:
             num_cat_features += encoder_out_features
             self.nwp_output_network = output_network(
                 in_features=encoder_out_features,
-                out_features=self.forecast_len_30,
+                out_features=self.forecast_len,
                 **output_network_kwargs,
             )
         if include_gsp_yield_history:
-            num_cat_features += self.history_len_30
+            num_cat_features += self.history_len
         if embedding_dim:
             num_cat_features += embedding_dim
         if include_sun:
@@ -189,7 +189,7 @@ class Model(BaseModel):
 
         self.output_network = output_network(
             in_features=num_cat_features,
-            out_features=self.forecast_len_30,
+            out_features=self.forecast_len,
             **output_network_kwargs,
         )
 
@@ -226,7 +226,7 @@ class Model(BaseModel):
         # *********************** GSP Data ************************************
         # add gsp yield history
         if self.include_gsp_yield_history:
-            gsp_history = x[BatchKey.gsp][:, : self.history_len_30].float()
+            gsp_history = x[BatchKey.gsp][:, : self.history_len].float()
             gsp_history = gsp_history.reshape(gsp_history.shape[0], -1)
             gsp_history = self.source_dropout_0d(gsp_history)
             modes["gsp"] = gsp_history
@@ -266,7 +266,7 @@ class Model(BaseModel):
     def training_step(self, batch, batch_idx):
         """Training step"""
         y_hats = self.multi_mode_forward(batch)
-        y = batch[BatchKey.gsp][:, -self.forecast_len_30 :, 0]
+        y = batch[BatchKey.gsp][:, -self.forecast_len :, 0]
 
         losses = self._calculate_common_losses(y, y_hats["all"])
         losses = {f"{k}/train": v for k, v in losses.items()}