PVNet 3.0.25__tar.gz → 3.0.27__tar.gz

{pvnet-3.0.25 → pvnet-3.0.27}/PKG-INFO

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

{pvnet-3.0.25 → pvnet-3.0.27}/PVNet.egg-info/PKG-INFO

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

pvnet-3.0.27/pvnet/__init__.py

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

{pvnet-3.0.25 → pvnet-3.0.27}/pvnet/data/wind_datamodule.py

@@ -13,7 +13,7 @@ class WindDataModule(BaseDataModule):
     def _get_datapipe(self, start_time, end_time):
         data_pipeline = windnet_netcdf_datapipe(
             self.configuration,
-            keys=["wind", "nwp"],
+            keys=["wind", "nwp", "sensor"],
         )
 
         data_pipeline = (
@@ -26,7 +26,7 @@ class WindDataModule(BaseDataModule):
     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"],
+            keys=["wind", "nwp", "sensor"],
             filenames=filenames,
         )
         data_pipeline = (

{pvnet-3.0.25 → pvnet-3.0.27}/pvnet/models/multimodal/multimodal.py

@@ -57,6 +57,7 @@ class Model(MultimodalBaseModel):
         pv_history_minutes: Optional[int] = None,
         wind_history_minutes: Optional[int] = None,
         sensor_history_minutes: Optional[int] = None,
+        sensor_forecast_minutes: Optional[int] = None,
         optimizer: AbstractOptimizer = pvnet.optimizers.Adam(),
         target_key: str = "gsp",
         interval_minutes: int = 30,
@@ -121,6 +122,7 @@ class Model(MultimodalBaseModel):
             addition to the full forecast
             sensor_encoder: Encoder for sensor data
             sensor_history_minutes: Length of recent sensor data used as input.
+            sensor_forecast_minutes: Length of forecast sensor data used as input.
             adapt_batches: If set to true, we attempt to slice the batches to the expected shape for
                 the model to use. This allows us to overprepare batches and slice from them for the
                 data we need for a model run.
@@ -240,9 +242,13 @@ class Model(MultimodalBaseModel):
         if self.include_sensor:
             if sensor_history_minutes is None:
                 sensor_history_minutes = history_minutes
+            if sensor_forecast_minutes is None:
+                sensor_forecast_minutes = forecast_minutes
 
             self.sensor_encoder = sensor_encoder(
-                sequence_length=sensor_history_minutes // sensor_interval_minutes + 1,
+                sequence_length=sensor_history_minutes // sensor_interval_minutes
+                + sensor_forecast_minutes // sensor_interval_minutes
+                + 1,
                 target_key_to_use=self._target_key_name,
                 input_key_to_use="sensor",
             )

{pvnet-3.0.25 → pvnet-3.0.27}/pvnet/models/multimodal/site_encoders/encoders.py

@@ -2,6 +2,7 @@
 
 """
 
+import einops
 import torch
 from ocf_datapipes.batch import BatchKey
 from torch import nn
@@ -128,6 +129,8 @@ class SingleAttentionNetwork(AbstractPVSitesEncoder):
         target_id_dim: int = 318,
         target_key_to_use: str = "gsp",
         input_key_to_use: str = "pv",
+        num_channels: int = 1,
+        num_sites_in_inference: int = 1,
     ):
         """A simple attention-based model with a single multihead attention layer
 
@@ -148,6 +151,13 @@ class SingleAttentionNetwork(AbstractPVSitesEncoder):
             target_id_dim: The number of unique IDs.
             target_key_to_use: The key to use for the target in the attention layer.
             input_key_to_use: The key to use for the input in the attention layer.
+            num_channels: Number of channels in the input data. For single site generation,
+                this will be 1, as there is not channel dimension, for Sensors,
+                 this will probably be higher than that
+            num_sites_in_inference: Number of sites to use in inference.
+                This is used to determine the number of sites to use in the
+                 attention layer, for a single site, 1 works, while for multiple sites
+                (such as multiple sensors), this would be higher than that
 
         """
         super().__init__(sequence_length, num_sites, out_features)
@@ -158,15 +168,18 @@ class SingleAttentionNetwork(AbstractPVSitesEncoder):
         self.use_id_in_value = use_id_in_value
         self.target_key_to_use = target_key_to_use
         self.input_key_to_use = input_key_to_use
+        self.num_channels = num_channels
+        self.num_sites_in_inference = num_sites_in_inference
 
         if use_id_in_value:
             self.value_id_embedding = nn.Embedding(num_sites, id_embed_dim)
 
         self._value_encoder = nn.Sequential(
             ResFCNet2(
-                in_features=sequence_length + int(use_id_in_value) * id_embed_dim,
+                in_features=sequence_length * self.num_channels
+                + int(use_id_in_value) * id_embed_dim,
                 out_features=out_features,
-                fc_hidden_features=sequence_length,
+                fc_hidden_features=sequence_length * self.num_channels,
                 n_res_blocks=n_kv_res_blocks,
                 res_block_layers=kv_res_block_layers,
                 dropout_frac=0,
@@ -175,9 +188,9 @@ class SingleAttentionNetwork(AbstractPVSitesEncoder):
 
         self._key_encoder = nn.Sequential(
             ResFCNet2(
-                in_features=sequence_length + id_embed_dim,
+                in_features=id_embed_dim + sequence_length * self.num_channels,
                 out_features=kdim,
-                fc_hidden_features=id_embed_dim + sequence_length,
+                fc_hidden_features=id_embed_dim + sequence_length * self.num_channels,
                 n_res_blocks=n_kv_res_blocks,
                 res_block_layers=kv_res_block_layers,
                 dropout_frac=0,
@@ -192,6 +205,20 @@ class SingleAttentionNetwork(AbstractPVSitesEncoder):
             batch_first=True,
         )
 
+    def _encode_inputs(self, x):
+        # Shape: [batch size, sequence length, PV site] -> [8, 197, 1]
+        # Shape: [batch size,  station_id, sequence length,  channels] -> [8, 197, 26, 23]
+        input_data = x[BatchKey[f"{self.input_key_to_use}"]]
+        if len(input_data.shape) == 4:  # Has multiple channels
+            input_data = input_data[:, :, : self.sequence_length]
+            input_data = einops.rearrange(input_data, "b id s c -> b (s c) id")
+        else:
+            input_data = input_data[:, : self.sequence_length]
+        site_seqs = input_data.float()
+        batch_size = site_seqs.shape[0]
+        site_seqs = site_seqs.swapaxes(1, 2)  # [batch size, Site ID, sequence length]
+        return site_seqs, batch_size
+
     def _encode_query(self, x):
         # Select the first one
         if self.target_key_to_use == "gsp":
@@ -206,14 +233,12 @@ class SingleAttentionNetwork(AbstractPVSitesEncoder):
         return query
 
     def _encode_key(self, x):
-        # Shape: [batch size, sequence length, PV site]
-        site_seqs = x[BatchKey[f"{self.input_key_to_use}"]][:, : self.sequence_length].float()
-        batch_size = site_seqs.shape[0]
+        site_seqs, batch_size = self._encode_inputs(x)
 
         # wind ID embeddings are the same for each sample
         site_id_embed = torch.tile(self.site_id_embedding(self._ids), (batch_size, 1, 1))
         # Each concated (wind sequence, wind ID embedding) is processed with encoder
-        x_seq_in = torch.cat((site_seqs.swapaxes(1, 2), site_id_embed), dim=2).flatten(0, 1)
+        x_seq_in = torch.cat((site_seqs, site_id_embed), dim=2).flatten(0, 1)
         key = self._key_encoder(x_seq_in)
 
         # Reshape to [batch size, PV site, kdim]
@@ -221,19 +246,16 @@ class SingleAttentionNetwork(AbstractPVSitesEncoder):
         return key
 
     def _encode_value(self, x):
-        # Shape: [batch size, sequence length, PV site]
-        site_seqs = x[BatchKey[f"{self.input_key_to_use}"]][:, : self.sequence_length].float()
-        batch_size = site_seqs.shape[0]
+        site_seqs, batch_size = self._encode_inputs(x)
 
         if self.use_id_in_value:
             # wind ID embeddings are the same for each sample
             site_id_embed = torch.tile(self.value_id_embedding(self._ids), (batch_size, 1, 1))
             # Each concated (wind sequence, wind ID embedding) is processed with encoder
-            x_seq_in = torch.cat((site_seqs.swapaxes(1, 2), site_id_embed), dim=2).flatten(0, 1)
+            x_seq_in = torch.cat((site_seqs, site_id_embed), dim=2).flatten(0, 1)
         else:
             # Encode each PV sequence independently
-            x_seq_in = site_seqs.swapaxes(1, 2).flatten(0, 1)
-
+            x_seq_in = site_seqs.flatten(0, 1)
         value = self._value_encoder(x_seq_in)
 
         # Reshape to [batch size, PV site, vdim]

{pvnet-3.0.25 → pvnet-3.0.27}/tests/conftest.py

@@ -14,6 +14,7 @@ from datetime import timedelta
 
 import pvnet
 from pvnet.data.datamodule import DataModule
+from pvnet.data.wind_datamodule import WindDataModule
 
 import pvnet.models.multimodal.encoders.encoders3d
 import pvnet.models.multimodal.linear_networks.networks
@@ -161,6 +162,22 @@ def sample_pv_batch(sample_batch):
     return pv_data
 
 
+@pytest.fixture()
+def sample_wind_batch():
+    dm = WindDataModule(
+        configuration=None,
+        batch_size=2,
+        num_workers=0,
+        prefetch_factor=None,
+        train_period=[None, None],
+        val_period=[None, None],
+        test_period=[None, None],
+        batch_dir="tests/test_data/sample_wind_batches",
+    )
+    batch = next(iter(dm.train_dataloader()))
+    return batch
+
+
 @pytest.fixture()
 def model_minutes_kwargs():
     kwargs = dict(
@@ -193,6 +210,20 @@ def site_encoder_model_kwargs():
     return kwargs
 
 
+@pytest.fixture()
+def site_encoder_sensor_model_kwargs():
+    # Used to test site encoder model on PV data
+    kwargs = dict(
+        sequence_length=180 // 5 + 1,
+        num_sites=26,
+        out_features=128,
+        num_channels=23,
+        target_key_to_use="wind",
+        input_key_to_use="sensor",
+    )
+    return kwargs
+
+
 @pytest.fixture()
 def raw_multimodal_model_kwargs(model_minutes_kwargs):
     kwargs = dict(

pvnet-3.0.25/pvnet/__init__.py

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