Upload dataset.py with huggingface_hub

dataset.py

@@ -0,0 +1,233 @@
+import torch
+from torch import Tensor
+import torch.nn.functional as F
+from torch.utils.data import Dataset
+from typing import *
+from pathlib import Path
+import re
+import xarray as xr
+import numpy as np
+import h5py
+
+
+IGRA_VARS = ['air_temperature', 'relative_humidity', 'wind_speed', 'geopotential_height', 'air_dewpoint_depression']
+
+CLARA_VARS_D = {
+    'CFC': ['cfc'],
+    'CTO': ['ctt', 'cth', 'ctp'],
+    'IWP': ['iwp', 'cot_ice', 'cre_ice'],
+    'LWP': ['lwp', 'cot_liq', 'cre_liq']
+}
+
+CLARA_VARS = [value for values_list in CLARA_VARS_D.values() for value in values_list]
+
+
+class ERA5Dataset(Dataset):
+    def __init__(
+        self, 
+        size: Tuple[int] = (720, 1440),
+        window: int = 1,
+        flatten: bool = True,
+        mode: str = 'train'
+    ) -> None:
+        
+        self.size = size
+        self.window = window
+        self.flatten = flatten
+        self.mode = mode
+        self.data_dir = Path('.') / 'era5'
+        self.normalization_dir = Path('.') / 'era5' / 'stats_v0'
+        
+        # Lazily load data
+        self.file_paths = list((self.data_dir / self.mode).glob('*.h5'))
+        self.file_paths.sort()
+        
+        self.sample_indices = []
+        for file_idx, file_path in enumerate(self.file_paths):
+            h5_file = h5py.File(file_path, 'r')
+            num_samples = h5_file['fields'].shape[0]
+            self.sample_indices.extend([(file_idx, i) for i in range(num_samples)])
+            h5_file.close()
+    
+        
+        # Retrieve climatology to normalize
+        self.normalization_mean = np.load(self.normalization_dir / 'global_means.npy')
+        self.normalization_sigma = np.load(self.normalization_dir / 'global_stds.npy')
+        
+
+    def _open_file(self, file_path, sample_idx):
+        h5_file = h5py.File(file_path, 'r')
+        sample = h5_file['fields'][sample_idx]
+        h5_file.close()
+            
+        return sample[:, :self.size[0], :self.size[1]]
+    
+    
+    def __len__(self):
+        return len(self.sample_indices) - self.window + 1
+
+    
+    def __getitem__(self, i):
+        step_indices = [target_idx for target_idx in range(i, i + self.window)]
+        
+        x = list()
+        for step_idx in step_indices:
+            file_idx, sample_idx = self.sample_indices[step_idx]
+            x.append(self._open_file(self.file_paths[file_idx], sample_idx))
+        
+        x = (x - self.normalization_mean) / self.normalization_sigma
+        x = torch.tensor(x).float()
+
+        if self.flatten:
+            return x.flatten(0, 1), {}
+        else:
+            return x, {}
+        
+
+class AuxDataset(Dataset):
+    def __init__(
+        self,
+        data_var: str = '',
+        size: Tuple[int] = (720, 1440),
+        window: int = 1,
+        flatten: bool = True,
+        mode: str = 'train'
+    ) -> None:
+        
+        assert data_var in ['igra', 'clara'], 'Dataset is not implemented, choose one of [igra, clara]'
+        
+        self.data_var = data_var
+        self.size = size
+        self.window = window
+        self.flatten = flatten
+        self.mode = mode
+        
+        self.data_dir = Path('.') / data_var
+        self.normalization_file = Path('.') / 'climatology' / f'climatology_{self.data_var}.zarr'
+        
+        # Check if years specified are within valid bounds
+        if self.mode == 'train':
+            years = [str(year) for year in np.arange(2011,2016)]
+        elif self.mode == 'val':
+            years = [str(year) for year in np.arange(2016,2018)]
+        elif self.mode == 'test':
+            years = [str(year) for year in np.arange(2018,2019)]
+        else:
+            raise NotImplementedError('Mode is invalid, choose one of [train, val, test]')
+        
+        # Subset files that match with patterns (eg. years specified)
+        self.EXTENSION = 'nc'
+        self.ENGINE = 'netcdf4'
+        self.PARAMS = IGRA_VARS if self.data_var == 'igra' else CLARA_VARS
+        
+        file_paths = list()
+        for year in years:
+            pattern = rf'.*{year}\d{{4}}\.{self.EXTENSION}$'
+            curr_files = list(self.data_dir.glob(f'*{year}*.{self.EXTENSION}'))
+            file_paths.extend(
+                [f for f in curr_files if re.match(pattern, str(f.name)) and not self._is_leap(f.name)]
+            )
+            
+        self.file_paths = file_paths
+        self.file_paths.sort()
+        
+        # Lazily load data (i.e., igra has multiple (4; 6-hourly) timesteps in a daily file, while clara only has 1)
+        self.sample_indices = []
+        if data_var == 'igra':
+            self.sample_indices = [(file_idx, i) for file_idx in range(len(self.file_paths)) for i in range(4)]
+        
+        else:
+            self.sample_indices = [(file_idx, 0) for file_idx in range(len(self.file_paths)) for i in range(4)]
+        
+        # Retrieve climatology to normalize
+        self.normalization = xr.open_dataset(self.normalization_file, engine='zarr')
+        self.normalization = self.normalization.sel(param=self.PARAMS)
+        self.normalization_mean = self.normalization['mean'].values[np.newaxis, :, np.newaxis, np.newaxis]
+        self.normalization_sigma = self.normalization['sigma'].values[np.newaxis, :, np.newaxis, np.newaxis]
+        
+
+    def _is_leap(self, filename):
+        """FCN training data for ERA5 ignores leap day"""
+        match = re.search(r'(\d{4})(\d{2})(\d{2})', filename)
+        if match:
+            year, month, day = map(int, match.groups())
+            return month == 2 and day == 29
+        
+        return False
+    
+    def _open_file(self, file_path, sample_idx):
+        sample = xr.open_dataset(file_path, engine=self.ENGINE)
+        sample = sample[self.PARAMS]
+        sample = sample.sortby('lat', ascending=False) # aligned with FCN ERA5
+        sample = sample.roll(lon=len(sample.lon) // 2, roll_coords=True) # aligned with FCN ERA5
+        
+        
+        if self.data_var == 'igra':
+            
+            # Some daily files do not have some snapshots in time; init an empty np.nan tensor instead
+            try:
+                sample = sample.isel(time=sample_idx).to_array().values
+            
+            except:
+                sample = np.full((len(IGRA_VARS), self.size[0], self.size[1]), np.nan)
+
+
+        else:
+            sample = sample.to_array().values
+            
+        return sample
+    
+    
+    def __len__(self):
+        return len(self.sample_indices) - self.window + 1
+
+    
+    def __getitem__(self, i):
+        step_indices = [target_idx for target_idx in range(i, i + self.window)]
+        
+        x = list()
+        for step_idx in step_indices:
+            file_idx, sample_idx = self.sample_indices[step_idx]
+            x.append(self._open_file(self.file_paths[file_idx], sample_idx))
+        
+        x = (x - self.normalization_mean) / self.normalization_sigma
+        x = torch.tensor(x).float()
+        x = torch.nan_to_num(x)
+
+        if self.flatten:
+            return x.flatten(0, 1), {}
+        else:
+            return x, {}
+
+
+class MultimodalDataset(Dataset):
+    def __init__(
+        self, 
+        datasets, 
+        background: bool=False
+    ):
+        self.datasets = datasets
+        self.is_flatten = datasets[0].flatten
+        
+        # Handle variable future timestepping to generate background state
+        self.background = background 
+
+    def __len__(self):
+        if self.background:
+            return len(self.datasets[0]) - 1  # lead_time = 1
+        else:
+            return len(self.datasets[0])
+
+    def __getitem__(self, idx):
+        dim = 0 if self.is_flatten else 1
+        x = [dataset[idx][0] for dataset in self.datasets]
+        x = torch.cat(x, dim=dim).float()
+        
+        if self.background:
+            # Also return future lead_time as target y
+            y = [dataset[idx+1][0] for dataset in self.datasets]
+            y = torch.cat(y, dim=dim).float()
+            return x, y, {}
+        
+        else:
+            return x, {}