Upload 2 files

helper.py

@@ -0,0 +1,318 @@
+"""
+
+This script contains helper functions to process the AGBD Dataset hosted on HuggingFace at: https://huggingface.co/datasets/prs-eth/AGBD.
+
+"""
+
+
+############################################################################################################################
+# Imports
+
+import numpy as np
+from datasets import Value
+import pickle
+import pandas as pd
+
+############################################################################################################################
+# Global variables
+
+# Metadata features
+feature_dtype = {'s2_num_days': Value('int16'),
+                'gedi_num_days': Value('uint16'),
+                'lat': Value('float32'),
+                'lon': Value('float32'),
+                "agbd_se": Value('float32'),
+                "elev_lowes": Value('float32'),
+                "leaf_off_f": Value('uint8'),
+                "pft_class": Value('uint8'),
+                "region_cla": Value('uint8'),
+                "rh98": Value('float32'),
+                "sensitivity": Value('float32'),
+                "solar_elev": Value('float32'),
+                "urban_prop":Value('uint8')}
+
+# Mapping from Sentinel-2 band to index in the data
+s2_bands_idx = {'B01': 0, 'B02': 1, 'B03': 2, 'B04': 3, 'B05': 4, 'B06': 5, 'B07': 6, 'B08': 7, 'B8A': 8, 'B09': 9, 'B11': 10, 'B12': 11}
+
+# Normalization values
+with open('statistics.pkl', 'rb') as f: norm_values = pickle.load(f)
+
+# Define the nodata values for each data source
+NODATAVALS = {'S2_bands' : 0, 'CH': 255, 'ALOS_bands': -9999.0, 'DEM': -9999, 'LC': 255}
+
+# Reference biomes, and derived metrics
+REF_BIOMES = {20: 'Shrubs', 30: 'Herbaceous vegetation', 40: 'Cultivated', 90: 'Herbaceous wetland', 111: 'Closed-ENL', 112: 'Closed-EBL', 114: 'Closed-DBL', 115: 'Closed-mixed', 116: 'Closed-other', 121: 'Open-ENL', 122: 'Open-EBL', 124: 'Open-DBL', 125: 'Open-mixed', 126: 'Open-other'}
+_biome_values_mapping = {v: i for i, v in enumerate(REF_BIOMES.keys())}
+
+############################################################################################################################
+# Helper functions
+
+def normalize_data(data, norm_values, norm_strat, nodata_value = None) :
+    """
+    Normalize the data, according to various strategies:
+    - mean_std: subtract the mean and divide by the standard deviation
+    - pct: subtract the 1st percentile and divide by the 99th percentile
+    - min_max: subtract the minimum and divide by the maximum
+
+    Args:
+    - data (np.array): the data to normalize
+    - norm_values (dict): the normalization values
+    - norm_strat (str): the normalization strategy
+
+    Returns:
+    - normalized_data (np.array): the normalized data
+    """
+
+    if norm_strat == 'mean_std' :
+        mean, std = norm_values['mean'], norm_values['std']
+        if nodata_value is not None :
+            data = np.where(data == nodata_value, 0, (data - mean) / std)
+        else : data = (data - mean) / std
+
+    elif norm_strat == 'pct' :
+        p1, p99 = norm_values['p1'], norm_values['p99']
+        if nodata_value is not None :
+            data = np.where(data == nodata_value, 0, (data - p1) / (p99 - p1))
+        else :
+            data = (data - p1) / (p99 - p1)
+        data = np.clip(data, 0, 1)
+
+    elif norm_strat == 'min_max' :
+        min_val, max_val = norm_values['min'], norm_values['max']
+        if nodata_value is not None :
+            data = np.where(data == nodata_value, 0, (data - min_val) / (max_val - min_val))
+        else:
+            data = (data - min_val) / (max_val - min_val)
+    
+    else: 
+        raise ValueError(f'Normalization strategy `{norm_strat}` is not valid.')
+
+    return data
+
+
+def normalize_bands(bands_data, norm_values, order, norm_strat, nodata_value = None) :
+    """
+    This function normalizes the bands data using the normalization values and strategy.
+
+    Args:
+    - bands_data (np.array): the bands data to normalize
+    - norm_values (dict): the normalization values
+    - order (list): the order of the bands
+    - norm_strat (str): the normalization strategy
+    - nodata_value (int/float): the nodata value
+
+    Returns:
+    - bands_data (np.array): the normalized bands data
+    """
+    
+    for i, band in enumerate(order) :
+        band_norm = norm_values[band]
+        bands_data[:, :, i] = normalize_data(bands_data[:, :, i], band_norm, norm_strat, nodata_value)
+    
+    return bands_data
+
+
+def one_hot(x) :
+    one_hot = np.zeros(len(_biome_values_mapping))
+    one_hot[_biome_values_mapping.get(x, 0)] = 1
+    return one_hot
+
+def encode_biome(lc, encode_strat, embeddings = None) :
+    """
+    This function encodes the land cover data using different strategies: 1) sin/cosine encoding, 
+    2) cat2vec embeddings, 3) one-hot encoding.
+
+    Args:
+    - lc (np.array): the land cover data
+    - encode_strat (str): the encoding strategy
+    - embeddings (dict): the cat2vec embeddings
+
+    Returns:
+    - encoded_lc (np.array): the encoded land cover data
+    """
+
+    if encode_strat == 'sin_cos' :
+        # Encode the LC classes with sin/cosine values and scale the data to [0,1]
+        lc_cos = np.where(lc == NODATAVALS['LC'], 0, (np.cos(2 * np.pi * lc / 201) + 1) / 2)
+        lc_sin = np.where(lc == NODATAVALS['LC'], 0, (np.sin(2 * np.pi * lc / 201) + 1) / 2)
+        return np.stack([lc_cos, lc_sin], axis = -1).astype(np.float32)
+    
+    elif encode_strat == 'cat2vec' :
+        # Embed the LC classes using the cat2vec embeddings
+        lc_cat2vec = np.vectorize(lambda x: embeddings.get(x, embeddings.get(0)), signature = '()->(n)')(lc)
+        return lc_cat2vec.astype(np.float32)
+
+    elif encode_strat == 'onehot' :
+        lc_onehot = np.vectorize(one_hot, signature = '() -> (n)')(lc).astype(np.float32)
+        return lc_onehot
+
+    else: raise ValueError(f'Encoding strategy `{encode_strat}` is not valid.')
+
+
+def compute_num_features(input_features, encode_strat) :
+    """
+    This function computes the number of features that will be used in the model.
+
+    Args:
+    - input_features (dict): the input features configuration
+    - encode_strat (str): the encoding strategy
+
+    Returns:
+    - num_features (int): the number of features
+    """
+
+    num_features = len(input_features['S2_bands'])
+    if input_features['S2_dates'] : num_features += 3
+    if input_features['lat_lon'] : num_features += 4
+    if input_features['GEDI_dates'] : num_features += 3
+    if input_features['ALOS'] : num_features += 2
+    if input_features['CH'] : num_features += 2
+    if input_features['LC'] :
+        num_features += 1
+        if encode_strat == 'sin_cos' : num_features += 2
+        elif encode_strat == 'cat2vec' : num_features += 5
+        elif encode_strat == 'onehot' : num_features += len(REF_BIOMES)
+    if input_features['DEM'] : num_features += 1
+    if input_features['topo'] : num_features += 3
+
+    return num_features
+
+
+def load_embeddings(user_config) :
+
+    if user_config['encode_strat'] == 'cat2vec' :
+        embeddings = pd.read_csv("embeddings_train.csv")
+        embeddings = dict([(v,np.array([a,b,c,d,e])) for v, a,b,c,d,e in zip(embeddings.mapping, embeddings.dim0, embeddings.dim1, embeddings.dim2, embeddings.dim3, embeddings.dim4)])
+        user_config['embeddings'] = embeddings
+    else: user_config['embeddings'] = None
+
+    return user_config
+
+
+############################################################################################################################
+# Main function to process a batch
+
+def process_batch(batch, norm_strat, encode_strat, input_features, metadata, patch_size, embeddings):
+    """
+    This function processes a batch of data from the HuggingFace AGBD dataset according to the user-defined configuration.
+
+    Args:
+    - batch (dict): the batch of data from the dataset
+    - norm_strat (str): the normalization strategy
+    - encode_strat (str): the encoding strategy for land cover data
+    - input_features (dict): the input features configuration
+    - metadata (list): the metadata variables to return
+    - patch_size (int): the size of the patches
+    - embeddings (dict): the cat2vec embeddings for land cover data
+
+    Returns:
+    - processed_batch (dict): the processed batch of data with normalized and concatenated features
+    """
+
+    ################################################################################
+    # Structure of the "input" data:
+    # - 12 x Sentinel-2 bands
+    # - 3 x S2 dates bands (s2_num_days, s2_doy_cos, s2_doy_sin)
+    # - 4 x lat/lon (lat_cos, lat_sin, lon_cos, lon_sin)
+    # - 3 x GEDI dates bands (gedi_num_days, gedi_doy_cos, gedi_doy_sin)
+    # - 2 x ALOS bands (HH, HV)
+    # - 2 x CH bands (ch, std)
+    # - 2 x LC bands (lc encoding, lc_prob)
+    # - 4 x DEM bands (slope, aspect_cos, aspect_sin, dem)
+    ################################################################################
+
+    # Normalize the inputs
+    patches = np.asarray(batch["input"])
+    batch_size = patches.shape[0]
+    og_patch_size = patches.shape[-1]
+
+    # Select the features according to input_features
+    num_features = compute_num_features(input_features, encode_strat)
+    out_patch = np.zeros((batch_size, num_features, og_patch_size, og_patch_size), dtype = np.float32)
+    current_idx = 0
+    
+    # Sentinel-2 bands
+    s2_indices = [s2_bands_idx[band] for band in input_features['S2_bands']]
+    out_patch[:, current_idx : current_idx + len(s2_indices)] = patches[:, s2_indices] if norm_strat == 'none' else normalize_bands(patches[:, s2_indices], norm_values['S2_bands'], ['B01', 'B02', 'B03', 'B04', 'B05', 'B06', 'B07', 'B08', 'B8A', 'B09','B11', 'B12'], norm_strat, NODATAVALS['S2_bands'])
+    current_idx += len(s2_indices)
+
+    # S2 dates
+    if input_features['S2_dates'] : 
+        out_patch[:, current_idx : current_idx + 3] = patches[:, 12:15] if norm_strat == 'none' else np.stack([
+            normalize_data(patches[:, 12], norm_values['Sentinel_metadata']['S2_date'], 'min_max' if norm_strat == 'pct' else norm_strat),
+            patches[:, 13],
+            patches[:, 14]
+        ], axis = 1)
+        current_idx += 3
+    
+    # Lat/Lon
+    if input_features['lat_lon'] : 
+        out_patch[:, current_idx : current_idx + 4] = patches[:, 15:19]
+        current_idx += 4
+    
+    # GEDI dates
+    if input_features['GEDI_dates'] : 
+        out_patch[:, current_idx : current_idx + 3] = patches[:, 19:22] if norm_strat == 'none' else np.stack([
+            normalize_data(patches[:, 19], norm_values['GEDI']['date'], 'min_max' if norm_strat == 'pct' else norm_strat),
+            patches[:, 20],
+            patches[:, 21]
+        ], axis = 1)
+        current_idx += 3
+    
+    # ALOS bands
+    if input_features['ALOS'] : 
+        out_patch[:, current_idx : current_idx + 2] = patches[:, 22:24] if norm_strat == 'none' else normalize_bands(patches[:, 22:24], norm_values['ALOS_bands'], ['HH', 'HV'], norm_strat, NODATAVALS['ALOS_bands'])
+        current_idx += 2
+    
+    # CH bands
+    if input_features['CH'] : 
+        out_patch[:, current_idx] = patches[:, 24] if norm_strat == 'none' else normalize_data(patches[:, 24], norm_values['CH']['ch'], norm_strat, NODATAVALS['CH'])
+        out_patch[:, current_idx + 1] = patches[:, 25] if norm_strat == 'none' else normalize_data(patches[:, 25], norm_values['CH']['std'], norm_strat, NODATAVALS['CH'])
+        current_idx += 2
+    
+    # LC data
+    if input_features['LC'] :
+
+        # LC encoding
+        if encode_strat != 'none' :
+            lc_patch = np.vectorize(lambda x: encode_biome(x, encode_strat, embeddings), signature = '()->(n)')(patches[:, 26])
+            out_patch[:, current_idx : current_idx + lc_patch.shape[-1]] = lc_patch.swapaxes(-1,1)
+            current_idx += lc_patch.shape[-1]
+        else:
+            out_patch[:, current_idx] = patches[:, 26]
+            current_idx += 1
+        
+        # LC probability
+        out_patch[:, current_idx] = patches[:, 27] / 100  # Put lc_prob in [0,1] range
+        current_idx += 1
+    
+    # DEM topo bands
+    if input_features['topo'] :
+
+        out_patch[:, current_idx : current_idx + 3] = patches[:, 28:31]
+        current_idx += 3
+    
+    # DEM band
+    if input_features['DEM'] : 
+        out_patch[:, current_idx] = patches[:, 31] if norm_strat == 'none' else normalize_data(patches[:, 31], norm_values['DEM'], norm_strat, NODATAVALS['DEM'])
+        current_idx += 1
+
+    # ------------------------------------------------------------------------------------------------
+
+    # Crop to the patch size
+    start = (patches.shape[-1] - patch_size) // 2
+    out_patch = out_patch[:, start : start + patch_size, start : start + patch_size]
+
+    # ------------------------------------------------------------------------------------------------
+
+    # Select the metadata
+    if metadata == [] : out_metadata = [{} for _ in range(batch_size)]
+    else:
+        out_metadata = [
+            {key: d[key] for key in metadata} 
+            for d in batch["metadata"]
+        ]
+
+    # ------------------------------------------------------------------------------------------------
+
+    return {'input': out_patch, 'label': batch["label"], 'metadata': out_metadata}

statistics.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3b1e646dc6255806de50416f4d8d9bf79ebf8060d569f454fe513b3521883636
+size 2797