upload datasets

custom_dataset.py

@@ -93,7 +93,7 @@ def get_data_and_generate_train_val_test_sets(
     data_array: np.ndarray, # data matrix of shape (num_bldg,num_time_points,num_features). NOTE that features 2 and 3 are categorical features to embed time indices
     split_ratios: Union[List,Tuple], # 3-element list containing the ratios of train-val-test
     dataset_kwargs: Tuple # ONLY include num_bldg, lookback, lookahead, normalize, dtype, and transformer keys. See NRELComstock definition above for details.
-):
+) -> Tuple[torch.utils.data.Dataset, torch.utils.data.Dataset, torch.utils.data.Dataset, np.ndarray, np.ndarray]:
     
     assert len(split_ratios) == 3, "The split list must contain three elements."
     assert all(isinstance(i, (int, float)) for i in split_ratios), "List contains non-numeric elements"

custom_dataset_univariate.py

@@ -0,0 +1,143 @@
+import numpy as np
+import torch
+import torch.nn as nn
+from torch.utils.data import Dataset
+from typing import Union, List, Tuple, Dict
+
+# written by Shourya Bose
+
+class NRELComstock(Dataset):
+    """
+    torch Dataset class to load in data from numpy array
+    """
+    
+    def __init__(
+        self,
+        data_array: np.ndarray, # numpy array of shape (B,L,F). B: number of buildings, L: number of time indices, F: number of features; keep F at 1 for the univariate case (this script)
+        num_bldg: int = 12, # number of buildings to consider, should not be greater than first dimension of data_array
+        lookback: int = 12, # forecasting lookback window
+        lookahead: int = 4, # forecasting lookahead window
+        normalize: bool = True, # whether to normalize feature-wise
+        dtype: torch.dtype = torch.float32, # data type of outputs
+        mean: np.ndarray = None, # if you want to supply your own statistics rather than calculate it in the function, do here. shape (1,1,F)
+        std: np.ndarray = None, # if you want to supply your own statistics rather than calculate it in the function, do here. shape (1,1,F)
+        transformer: bool = True # if normalize=True, this disables normalization of time indices for xformer embedding - unused for the univariate case (this script)
+    ):
+        super(NRELComstock, self).__init__()
+        
+        if data_array.shape[0] < num_bldg:
+            raise ValueError('More buildings than present in file!')
+        else:
+            self.data = data_array[:num_bldg,:,[0]] # UNIVARIATE SELECTION: SELECT THE FIRST OUT OF 8 FEATURES
+        self.num_clients = num_bldg
+        
+        # lookback and lookahead
+        self.lookback, self.lookahead = lookback, lookahead
+        
+        # Calculate statistics
+        stacked = self.data.reshape(self.data.shape[0]*self.data.shape[1],self.data.shape[2])
+        if (mean is None) or (std is None): # statistics are not provided. Generate it from data
+            self.mean = stacked.mean(axis=0,keepdims=True)
+            self.std = stacked.std(axis=0,keepdims=True)
+        else: # statistics are provided. Use the provided statistics
+            self.mean = mean
+            self.std = std
+            
+        # if transformer:
+        #     # TRANSFORMER SPECIFIC: do not normalize date and time
+        #     self.mean[0,1], self.std[0,1] = 0., 1.
+        #     self.mean[0,2], self.std[0,2] = 0., 1.
+            
+        self.ndata = (self.data-self.mean)/self.std # normalized data
+        
+        # disambiguating between clients
+        len_per_client = self.data.shape[1] - lookback - lookahead + 1
+        self.total_len = len_per_client * self.num_clients
+        self.splits = np.array_split(np.arange(self.total_len),self.num_clients)
+        
+        # save whether to normalize, and the data type
+        self.normalize = normalize
+        self.dtype = dtype
+        
+        # if normalization is disabled, return to default statistics
+        if not self.normalize:
+            self.mean = np.zeros_like(self.mean)
+            self.std = np.ones_like(self.std)
+        
+    def _client_and_idx(self, idx):
+        
+        part_size = self.total_len // self.num_clients
+        part_index = idx // part_size
+        relative_position = idx % part_size
+        
+        return relative_position, part_index
+    
+    def __len__(self):
+        
+        return self.total_len
+    
+    def __getitem__(self, idx):
+        
+        tidx, cidx = self._client_and_idx(idx)
+        
+        if self.normalize:
+            x = self.ndata[cidx,tidx:tidx+self.lookback,0] 
+            y = self.ndata[cidx,tidx+self.lookback:tidx+self.lookback+self.lookahead,0]
+        else:
+            x = self.data[cidx,tidx:tidx+self.lookback,0]
+            y = self.data[cidx,tidx+self.lookback:tidx+self.lookback+self.lookahead,0]
+            
+        x, y = torch.tensor(x,dtype=self.dtype), torch.tensor(y,dtype=self.dtype)
+        
+        return x,y
+    
+
+def get_data_and_generate_train_val_test_sets(
+    data_array: np.ndarray, # numpy array of shape (B,L,F). B: number of buildings, L: number of time indices, F: number of features; keep F at 1 for the univariate case (this script)
+    split_ratios: Union[List,Tuple], # 3-element list containing the non-negative ratios of train-val-test that add upto 1. for example, [0.8,0.1,0.1]
+    dataset_kwargs: Tuple # kwargs dictionary to pass into NRELComstock class, check definition. Do not pass data_array, mean, or std into it since this function does that
+) -> Tuple[torch.utils.data.Dataset, torch.utils.data.Dataset, torch.utils.data.Dataset, np.ndarray, np.ndarray]:
+    """
+    function to create three torch Dataset objects, each corresponding to train, validation, and test sets
+    """
+    
+    assert len(split_ratios) == 3, "The split list must contain three elements."
+    assert all(isinstance(i, (int, float)) for i in split_ratios), "List contains non-numeric elements"
+    assert sum(split_ratios) <= 1, "Ratios must not sum upto more than 1."
+    
+    cum_splits = np.cumsum(split_ratios)
+    
+    train = data_array[:,:int(cum_splits[0]*data_array.shape[1]),:]
+    val = data_array[:,int(cum_splits[0]*data_array.shape[1]):int(cum_splits[1]*data_array.shape[1]),:]
+    test = data_array[:,int(cum_splits[1]*data_array.shape[1]):,:]
+    
+    if 0 in train.shape:
+        train_set = None
+        raise ValueError("Train set is empty. Possibly empty data matrix or 0 ratio for train set has been input.")
+    else:
+        train_set = NRELComstock(
+            data_array = train,
+            **dataset_kwargs
+        )
+        mean, std = train_set.mean, train_set.std
+    if 0 in val.shape:
+        val_set = None
+    else:
+        val_set = NRELComstock(
+            data_array = val,
+            mean = mean,
+            std = std,
+            **dataset_kwargs
+        )
+    if 0 in test.shape:
+        test_set = None
+    else:
+        test_set = NRELComstock(
+            data_array = test,
+            mean = mean,
+            std = std,
+            **dataset_kwargs
+        )
+    
+    # return the three datasets, as well as the statistics
+    return train_set, val_set, test_set, mean, std

example.py

@@ -0,0 +1,79 @@
+import os, sys
+import torch
+import numpy as np
+
+# import the dataset generation functions
+from custom_dataset import get_data_and_generate_train_val_test_sets as multivariate_dataset
+from custom_dataset_univariate import get_data_and_generate_train_val_test_sets as univariate_dataset
+
+# generate train-val-test datasets
+# CASE 1: multivariate, with the time indices also normalized
+train_1, val_1, test_1, mean_1, std_1 = multivariate_dataset(
+    data_array=np.load('./IllinoisHeterogenous.npz')['data'], # choose the appropriate file - homogenous or heterogenous
+    split_ratios=[0.8,0.1,0.1], # ratios that add up to 1 - the split is made along all buildings' time axis
+    dataset_kwargs={
+        'num_bldg': np.load('./IllinoisHeterogenous.npz')['data'].shape[0],
+        'lookback': 512,
+        'lookahead': 48,
+        'normalize': True,
+        'dtype': torch.float32,
+        'transformer': False # time indices are not normalized - use in non-Transformer scenarios where index embedding is not needed
+    }
+)
+# CASE 2: multivariate, with the time indices not normalized
+train_2, val_2, test_2, mean_2, std_2 = multivariate_dataset(
+    data_array=np.load('./IllinoisHeterogenous.npz')['data'], # choose the appropriate file - homogenous or heterogenous
+    split_ratios=[0.8,0.1,0.1], # ratios that add up to 1 - the split is made along all buildings' time axis
+    dataset_kwargs={
+        'num_bldg': np.load('./IllinoisHeterogenous.npz')['data'].shape[0],
+        'lookback': 512,
+        'lookahead': 48,
+        'normalize': True,
+        'dtype': torch.float32,
+        'transformer': True # time indices are normalized - use in Transformer scenarios where index is embedded
+    }
+)
+# CASE 3: univariate
+train_3, val_3, test_3, mean_3, std_3 = univariate_dataset(
+    data_array=np.load('./IllinoisHeterogenous.npz')['data'], # choose the appropriate file - homogenous or heterogenous
+    split_ratios=[0.8,0.1,0.1], # ratios that add up to 1 - the split is made along all buildings' time axis
+    dataset_kwargs={
+        'num_bldg': np.load('./IllinoisHeterogenous.npz')['data'].shape[0],
+        'lookback': 512,
+        'lookahead': 48,
+        'normalize': True,
+        'dtype': torch.float32,
+    }
+)
+
+
+if __name__ == "__main__":
+
+    # Create dataloaders
+    dl_1 = torch.utils.data.DataLoader(train_1, batch_size=32, shuffle=False)
+    dl_2 = torch.utils.data.DataLoader(train_2, batch_size=32, shuffle=False)
+    dl_3 = torch.utils.data.DataLoader(train_3, batch_size=32, shuffle=False)
+
+    # print out of the shapes of elements in the first dataloader
+    for inp, label, future_time in dl_1:
+        print("Case 1: Each dataloader contains input, label, future_time. Here time indices are normalized.")
+        print(f"Input shape is (including batch size of 32): {inp.shape}.")
+        print(f"Label shape is (including batch size of 32): {label.shape}.")
+        print(f"Future time shape is (including batch size of 32): {future_time.shape}.")
+        break
+
+    # print out of the shapes of elements in the second dataloader
+    for inp, label, future_time in dl_2:
+        print("Case 2: Each dataloader contains input, label, future_time. Here time indices are not normalized to allow embedding.")
+        print(f"Input shape is (including batch size of 32): {inp.shape}.")
+        print(f"Label shape is (including batch size of 32): {label.shape}.")
+        print(f"Future time shape is (including batch size of 32): {future_time.shape}.")
+        break
+
+    # print out of the shapes of elements in the third dataloader
+    for inp, label in dl_3:
+        print("Case 3: Each dataloader contains input, label.")
+        print(f"Input shape is (including batch size of 32): {inp.shape}.")
+        print(f"Label shape is (including batch size of 32): {label.shape}.")
+        break
+