code/architectures/SpatiotemporalGatedTransformer/dataloader/dataloaderMapping.py

import numpy as np
import torch
from torch.utils.data import Dataset
import os
import glob
from config import bands_list_order, time_before, window_size
import re
from accelerate import Accelerator
from torch.utils.data import DataLoader

class RasterTensorDataset1Mil(Dataset):
    def __init__(self, base_path):
        self.folder_path = base_path
        self.id_to_file = self._create_id_mapping()
        self.data_cache = {id_num: np.load(filepath) for id_num, filepath in self.id_to_file.items()}

    def _create_id_mapping(self):
        id_to_file = {}
        for file_path in glob.glob(os.path.join(self.folder_path, "*.npy")):
            match = re.search(r'ID(\d+)N', file_path)
            if match:
                id_num = int(match.group(1))
                id_to_file[id_num] = file_path
        return id_to_file

    def get_tensor_by_location(self, id_num, x, y, window_size=window_size):
        if id_num not in self.id_to_file:
            raise ValueError(f"ID {id_num} not found in dataset")
        # CRITICAL: previous code was
        #   data = self.data_cache.get(id_num, np.load(self.id_to_file[id_num]))
        # — which evaluated the np.load default eagerly on EVERY call, even
        # on cache hits, loading the entire ~1.9 MB tile from disk every
        # time. At ~30 raster lookups per sample × 256 samples × ~50
        # batches that's ~370 GB of pointless I/O. Using `if` avoids it.
        data = self.data_cache.get(id_num)
        if data is None:
            data = np.load(self.id_to_file[id_num])
            self.data_cache[id_num] = data
        # Cast x, y to int up front. coordinates.npy stores them as
        # numpy.float64, which trickled into the padded-window branch as
        # float slice indices and crashed ~0.4% of grid points (edge
        # pixels). One cast covers both branches.
        x = int(x); y = int(y)
        half_window = window_size // 2
        x_start, x_end = max(0, x - half_window), min(data.shape[0], x + half_window + 1)
        y_start, y_end = max(0, y - half_window), min(data.shape[1], y + half_window + 1)
        window = data[x_start:x_end, y_start:y_end]
        if window.shape != (window_size, window_size):
            padded_window = np.zeros((window_size, window_size))
            x_offset = half_window - (x - x_start)
            y_offset = half_window - (y - y_start)
            padded_window[x_offset:x_offset + window.shape[0], y_offset:y_offset + window.shape[1]] = window
            window = padded_window
        return torch.from_numpy(window).float()

    def __len__(self):
        return len(self.id_to_file)

    def __getitem__(self, idx):
        id_num = list(self.id_to_file.keys())[idx]
        return self.data_cache[id_num]


class MultiRasterDataset1MilMultiYears(Dataset):
    def __init__(self, samples_coordinates_array_subfolders, data_array_subfolders, dataframe, time_before=time_before):
        def flatten_list(lst):
            return [item for sublist in lst for item in (flatten_list(sublist) if isinstance(sublist, list) else [sublist])]

        self.data_array_subfolders = flatten_list(data_array_subfolders)
        self.seasonalityBased = self.check_seasonality(self.data_array_subfolders)
        self.time_before = time_before
        self.samples_coordinates_array_subfolders = flatten_list(samples_coordinates_array_subfolders)
        self.dataframe = dataframe
        self.datasets = {
            self.get_last_three_folders(subfolder): RasterTensorDataset1Mil(subfolder)
            for subfolder in self.data_array_subfolders
        }
        self.coordinates = {
            self.get_last_three_folders(subfolder): np.load(f"{subfolder}/coordinates.npy")
            for subfolder in self.samples_coordinates_array_subfolders
        }

        # Build (lat, lon) -> (id_num, x, y) hashmap per subfolder so that
        # find_coordinates_index() is O(1) instead of an O(N) np.where scan
        # over the 1.3 M-row coordinates.npy. Cuts 80k-sample dataset
        # materialisation from ~tens-of-minutes to seconds. Keys are
        # quantised to 9 decimal digits (≈ sub-mm at the equator) to be
        # robust against float-equality flakiness.
        self._coord_index = {
            subfolder: {
                (round(float(row[0]), 9), round(float(row[1]), 9)):
                    (row[2], row[3], row[4])
                for row in coords
            }
            for subfolder, coords in self.coordinates.items()
        }

    def check_seasonality(self, data_array_subfolders):
        seasons = ['winter', 'spring', 'summer', 'autumn']
        return any(any(season in subfolder.lower() for season in seasons) for subfolder in data_array_subfolders)

    def get_last_three_folders(self, path):
        parts = path.rstrip('/').split('/')
        return '/'.join(parts[-2:])

    def find_coordinates_index(self, subfolder, longitude, latitude):
        key = (round(float(latitude), 9), round(float(longitude), 9))
        idx = self._coord_index[subfolder].get(key)
        if idx is None:
            # Fallback to legacy linear scan (handles any edge-case keys
            # that don't survive the round-trip — should never fire in
            # practice but kept as a safety net).
            coords = self.coordinates[subfolder]
            match = np.where((coords[:, 1] == longitude) & (coords[:, 0] == latitude))[0]
            if match.size == 0:
                raise ValueError(f"Coordinates ({longitude}, {latitude}) not found in {subfolder}")
            return coords[match[0], 2], coords[match[0], 3], coords[match[0], 4]
        return idx

    def filter_by_season_or_year(self, season, year, seasonality_based):
        if seasonality_based:
            filtered_array = [
                path for path in self.samples_coordinates_array_subfolders
                if ('Elevation' in path) or
                   ('MODIS_NPP' in path and path.endswith(str(year))) or
                   (not 'Elevation' in path and not 'MODIS_NPP' in path and path.endswith(season))
            ]
        else:
            filtered_array = [
                path for path in self.samples_coordinates_array_subfolders
                if ('Elevation' in path) or
                   (not 'Elevation' in path and path.endswith(str(year)))
            ]
        return filtered_array

    def __getitem__(self, index):
        row = self.dataframe.iloc[index]
        longitude, latitude = row["longitude"], row["latitude"]
        filtered_array = self.filter_by_season_or_year(row.get('season', ''), row.get('year', ''), self.seasonalityBased)

        band_tensors = {band: [] for band in bands_list_order}

        for subfolder in filtered_array:
            subfolder_key = self.get_last_three_folders(subfolder)
            if subfolder_key.split(os.path.sep)[-1] == 'Elevation':
                id_num, x, y = self.find_coordinates_index(subfolder_key, longitude, latitude)
                elevation_tensor = self.datasets[subfolder_key].get_tensor_by_location(id_num, x, y)
                if elevation_tensor is not None:
                    for _ in range(self.time_before):
                        band_tensors['Elevation'].append(elevation_tensor)
            else:
                year = int(subfolder_key.split(os.path.sep)[-1])
                for decrement in range(self.time_before):
                    current_year = year - decrement
                    decremented_subfolder = os.path.sep.join(subfolder_key.split(os.path.sep)[:-1] + [str(current_year)])
                    if decremented_subfolder in self.datasets:
                        id_num, x, y = self.find_coordinates_index(decremented_subfolder, longitude, latitude)
                        tensor = self.datasets[decremented_subfolder].get_tensor_by_location(id_num, x, y)
                        if tensor is not None:
                            band = subfolder_key.split(os.path.sep)[-2]
                            if band in band_tensors:
                                band_tensors[band].append(tensor)

        stacked_tensors = []
        for band in bands_list_order:
            if not band_tensors[band]:
                band_tensors[band] = [torch.zeros(window_size, window_size) for _ in range(self.time_before)]
            elif len(band_tensors[band]) < self.time_before:
                while len(band_tensors[band]) < self.time_before:
                    band_tensors[band].append(torch.zeros(window_size, window_size))
            elif len(band_tensors[band]) > self.time_before:
                band_tensors[band] = band_tensors[band][:self.time_before]
            stacked_tensor = torch.stack(band_tensors[band])
            stacked_tensors.append(stacked_tensor)

        if len(stacked_tensors) != len(bands_list_order):
            raise ValueError(f"Expected {len(bands_list_order)} bands, but got {len(stacked_tensors)}")

        final_tensor = torch.stack(stacked_tensors)
        final_tensor = final_tensor.permute(0, 2, 3, 1)
        return longitude, latitude, final_tensor

    def __len__(self):
        return len(self.dataframe)

    def get_tensor_by_location(self, subfolder, id_num, x, y):
        return self.datasets[subfolder].get_tensor_by_location(id_num, x, y)

class NormalizedMultiRasterDataset1MilMultiYears(MultiRasterDataset1MilMultiYears):
    """Wrapper around MultiRasterDatasetMultiYears that adds feature normalization"""
    def __init__(self, samples_coordinates_array_path, data_array_path, df,feature_means,feature_stds,time_before):
        super().__init__(samples_coordinates_array_path, data_array_path, df,time_before)
        self.feature_means=feature_means
        self.feature_stds=feature_stds
        time_before=time_before
        

    def __getitem__(self, idx):
        longitude, latitude, features = super().__getitem__(idx)
        features = (features - self.feature_means[:, None, None]) / self.feature_stds[:, None, None]
        return longitude, latitude, features