custom_dataset_univariate.py

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