Update, V1.1.0

AGBD.py

@@ -11,38 +11,45 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-# TODO: Address all TODOs and remove all explanatory comments
-"""TODO: Add a description here."""
+
+############################################################################################################################
+# IMPORTS
 
 import numpy as np
 import datasets
 from datasets import Value
 import pickle
-# TODO: Add BibTeX citation
-# Find for instance the citation on arxiv or on the dataset repo/website
+import pandas as pd
+
+############################################################################################################################
+# GLOBAL VARIABLES
+
+# BibTeX citation
 _CITATION = """\
-@InProceedings{huggingface:dataset,
-title = {A great new dataset},
-author={huggingface, Inc.
-},
-year={2020}
+@misc{https://doi.org/10.48550/arxiv.2406.04928,
+  doi = {10.48550/ARXIV.2406.04928},
+  url = {https://arxiv.org/abs/2406.04928},
+  author = {Sialelli,  Ghjulia and Peters,  Torben and Wegner,  Jan D. and Schindler,  Konrad},
+  keywords = {Computer Vision and Pattern Recognition (cs.CV),  Machine Learning (cs.LG),  Image and Video Processing (eess.IV),  FOS: Computer and information sciences,  FOS: Computer and information sciences,  FOS: Electrical engineering,  electronic engineering,  information engineering,  FOS: Electrical engineering,  electronic engineering,  information engineering},
+  title = {AGBD: A Global-scale Biomass Dataset},
+  publisher = {arXiv},
+  year = {2024},
+  copyright = {Creative Commons Attribution Non Commercial Share Alike 4.0 International}
 }
 """
 
-# TODO: Add description of the dataset here
-# You can copy an official description
+# Description of the dataset
 _DESCRIPTION = """\
-This new dataset is designed to solve this great NLP task and is crafted with a lot of care.
+This new dataset is a machine-learning ready dataset of high-resolution (10m), multi-modal satellite imagery, paired with AGB reference values from NASA’s Global Ecosystem Dynamics Investigation (GEDI) mission.
 """
 
 # TODO: Add a link to an official homepage for the dataset here
 _HOMEPAGE = ""
 
-# TODO: Add the licence for the dataset here if you can find it
-_LICENSE = ""
-
-
+# License of the dataset
+_LICENSE = "https://creativecommons.org/licenses/by-nc/4.0/"
 
+# Metadata features
 feature_dtype = {'s2_num_days': Value('int16'),
                 'gedi_num_days': Value('uint16'),
                 'lat': Value('float32'),
@@ -57,213 +64,305 @@ feature_dtype = {'s2_num_days': Value('int16'),
                 "solar_elev": Value('float32'),
                 "urban_prop":Value('uint8')}
 
-norm_values = {'ALOS_bands': {
-    'HH': {'mean': -10.381429, 'std': 8.561741, 'min': -83.0, 'max': 13.329468, 'p1': -19.542107, 'p99': -2.402588},
-    'HV': {'mean': -16.722847, 'std': 8.718428, 'min': -83.0, 'max': 11.688309, 'p1': -29.285168, 'p99': -8.773987}},
-               'S2_bands': {'B01': {'mean': 0.12478869, 'std': 0.024433358, 'min': 1e-04, 'max': 1.8808, 'p1': 0.0787,
-                                    'p99': 0.1946},
-                            'B02': {'mean': 0.13480005, 'std': 0.02822557, 'min': 1e-04, 'max': 2.1776, 'p1': 0.0925,
-                                    'p99': 0.2216},
-                            'B03': {'mean': 0.16031432, 'std': 0.032037303, 'min': 1e-04, 'max': 2.12, 'p1': 0.1035,
-                                    'p99': 0.2556},
-                            'B04': {'mean': 0.1532097, 'std': 0.038628064, 'min': 1e-04, 'max': 2.0032, 'p1': 0.1023,
-                                    'p99': 0.2816},
-                            'B05': {'mean': 0.20312776, 'std': 0.04205057, 'min': 0.0422, 'max': 1.7502, 'p1': 0.1178,
-                                    'p99': 0.319},
-                            'B06': {'mean': 0.32636437, 'std': 0.07139242, 'min': 0.0502, 'max': 1.7245, 'p1': 0.1633,
-                                    'p99': 0.519},
-                            'B07': {'mean': 0.36605212, 'std': 0.08555025, 'min': 0.0616, 'max': 1.7149, 'p1': 0.1776,
-                                    'p99': 0.6076},
-                            'B08': {'mean': 0.3811653, 'std': 0.092815965, 'min': 1e-04, 'max': 1.7488, 'p1': 0.1691,
-                                    'p99': 0.646},
-                            'B8A': {'mean': 0.3910436, 'std': 0.0896364, 'min': 0.055, 'max': 1.688, 'p1': 0.1871,
-                                    'p99': 0.6386},
-                            'B09': {'mean': 0.3910644, 'std': 0.0836445, 'min': 0.0012, 'max': 1.7915, 'p1': 0.2124,
-                                    'p99': 0.6241},
-                            'B11': {'mean': 0.2917373, 'std': 0.07472579, 'min': 0.0953, 'max': 1.648, 'p1': 0.1334,
-                                    'p99': 0.4827},
-                            'B12': {'mean': 0.21169408, 'std': 0.05880649, 'min': 0.0975, 'max': 1.6775, 'p1': 0.115,
-                                    'p99': 0.3872}},
-               'CH': {'ch': {'mean': 9.736144, 'std': 9.493601, 'min': 0.0, 'max': 61.0, 'p1': 0.0, 'p99': 38.0},
-                      'std': {'mean': 7.9882116, 'std': 4.549494, 'min': 0.0, 'max': 254.0, 'p1': 0.0, 'p99': 18.0}},
-               'DEM': {'mean': 604.63727, 'std': 588.02094, 'min': -82.0, 'max': 5205.0, 'p1': 507.0, 'p99': 450.0},
-               'Sentinel_metadata': {
-                   'S2_vegetation_score': {'mean': 89.168724, 'std': 17.17321, 'min': 20.0, 'max': 100.0, 'p1': 29.0,
-                                           'p99': 100.0},
-                   'S2_date': {'mean': 299.1638, 'std': 192.87402, 'min': -165.0, 'max': 623.0, 'p1': 253.0,
-                               'p99': 277.0}}, 'GEDI': {
-        'agbd': {'mean': 66.97266, 'std': 98.66588, 'min': 0.0, 'max': 499.99985, 'p1': 0.9703503, 'p99': 163.46234},
-        'agbd_se': {'mean': 8.360701, 'std': 4.211524, 'min': 2.981795, 'max': 25.041483, 'p1': 2.9830396,
-                    'p99': 8.612499},
-        'rh98': {'mean': 12.074685, 'std': 10.276359, 'min': -1.1200076, 'max': 111.990005, 'p1': 2.3599916,
-                 'p99': 6.9500012},
-        'date': {'mean': 361.7431, 'std': 175.37294, 'min': 0.0, 'max': 624.0, 'p1': 360.0, 'p99': 146.0}}}
-
-def encode_lat_lon(lat, lon):
+# Default input features configuration
+default_input_features = {'S2_bands': ['B01', 'B02', 'B03', 'B04', 'B05', 'B06', 'B07', 'B08', 'B8A', 'B09','B11', 'B12'], 
+                            'S2_dates' : False, 'lat_lon': True, 'GEDI_dates': False, 'ALOS': True, 'CH': True, 'LC': True, 
+                            'DEM': True, 'topo': False}
+
+# 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
+norm_values = {
+    'ALOS_bands': {
+        'HH': {'mean': -10.381429, 'std': 8.561741, 'min': -83.0, 'max': 13.329468, 'p1': -83.0, 'p99': -2.1084213},
+        'HV': {'mean': -16.722847, 'std': 8.718428, 'min': -83.0, 'max': 11.688309, 'p1': -83.0, 'p99': -7.563843}},
+    'S2_bands': 
+        {'B01': {'mean': 0.12478869, 'std': 0.024433358, 'min': 1e-04, 'max': 1.8808, 'p1': 0.0787, 'p99': 0.1944}, 
+        'B02': {'mean': 0.13480005, 'std': 0.02822557, 'min': 1e-04, 'max': 2.1776, 'p1': 0.0925, 'p99': 0.2214}, 
+        'B03': {'mean': 0.16031432, 'std': 0.032037303, 'min': 1e-04, 'max': 2.12, 'p1': 0.1035, 'p99': 0.2556}, 
+        'B04': {'mean': 0.1532097, 'std': 0.038628064, 'min': 1e-04, 'max': 2.0032, 'p1': 0.1023, 'p99': 0.2816}, 
+        'B05': {'mean': 0.20312776, 'std': 0.04205057, 'min': 0.0422, 'max': 1.7502, 'p1': 0.1178, 'p99': 0.3189}, 
+        'B06': {'mean': 0.32636437, 'std': 0.07139242, 'min': 0.0502, 'max': 1.7245, 'p1': 0.1632, 'p99': 0.519}, 
+        'B07': {'mean': 0.36605212, 'std': 0.08555025, 'min': 0.0616, 'max': 1.7149, 'p1': 0.1775, 'p99': 0.6075}, 
+        'B08': {'mean': 0.3811653, 'std': 0.092815965, 'min': 1e-04, 'max': 1.7488, 'p1': 0.1691, 'p99': 0.646}, 
+        'B8A': {'mean': 0.3910436, 'std': 0.0896364, 'min': 0.055, 'max': 1.688, 'p1': 0.187, 'p99': 0.6385}, 
+        'B09': {'mean': 0.3910644, 'std': 0.0836445, 'min': 0.0012, 'max': 1.7915, 'p1': 0.2123, 'p99': 0.6238}, 
+        'B11': {'mean': 0.2917373, 'std': 0.07472579, 'min': 0.0953, 'max': 1.648, 'p1': 0.1334, 'p99': 0.4827}, 
+        'B12': {'mean': 0.21169408, 'std': 0.05880649, 'min': 0.0975, 'max': 1.6775, 'p1': 0.1149, 'p99': 0.3869}},
+    'CH': {
+        'ch': {'mean': 9.736144, 'std': 9.493601, 'min': 0.0, 'max': 61.0, 'p1': 0.0, 'p99': 38.0},
+        'std': {'mean': 7.9882116, 'std': 4.549494, 'min': 0.0, 'max': 254.0, 'p1': 0.0, 'p99': 18.0}},
+    'DEM': {
+        'mean': 604.63727, 'std': 588.02094, 'min': -82.0, 'max': 5205.0, 'p1': 4.0, 'p99': 2297.0},
+    'Sentinel_metadata': {
+        'S2_vegetation_score': {'mean': 89.168724, 'std': 17.17321, 'min': 20.0, 'max': 100.0, 'p1': 29.0, 'p99': 100.0},
+        'S2_date': {'mean': 299.1638, 'std': 192.87402, 'min': -165.0, 'max': 623.0, 'p1': -105.0, 'p99': 602.0}}, 
+    'GEDI': {
+        'agbd': {'mean': 66.97266, 'std': 98.66588, 'min': 0.0, 'max': 499.99985, 'p1': 0.0, 'p99': 429.7605},
+        'agbd_se': {'mean': 8.360701, 'std': 4.211524, 'min': 2.981795, 'max': 25.041483, 'p1': 2.9819136, 'p99': 17.13577},
+        'rh98': {'mean': 12.074685, 'std': 10.276359, 'min': -1.1200076, 'max': 111.990005, 'p1': 2.3599916, 'p99': 41.96},
+        'date': {'mean': 361.7431, 'std': 175.37294, 'min': 0.0, 'max': 624.0, 'p1': 5.0, 'p99': 619.0}}
+    }
+
+# 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())}
+_ref_biome_values = [v for v in REF_BIOMES.keys()]
+
+############################################################################################################################
+# Helper functions
+
+def normalize_data(data, norm_values, norm_strat, nodata_value = None) :
     """
-    Encode the latitude and longitude into sin/cosine values. We use a simple WRAP positional encoding, as
-    Mac Aodha et al. (2019).
+    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:
-    - lat (float): the latitude
-    - lon (float): the longitude
+    - data (np.array): the data to normalize
+    - norm_values (dict): the normalization values
+    - norm_strat (str): the normalization strategy
 
     Returns:
-    - (lat_cos, lat_sin, lon_cos, lon_sin) (tuple): the sin/cosine values for the latitude and longitude
+    - normalized_data (np.array): the normalized data
     """
 
-    # The latitude goes from -90 to 90
-    lat_cos, lat_sin = np.cos(np.pi * lat / 90), np.sin(np.pi * lat / 90)
-    # The longitude goes from -180 to 180
-    lon_cos, lon_sin = np.cos(np.pi * lon / 180), np.sin(np.pi * lon / 180)
+    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)
 
-    # Now we put everything in the [0,1] range
-    lat_cos, lat_sin = (lat_cos + 1) / 2, (lat_sin + 1) / 2
-    lon_cos, lon_sin = (lon_cos + 1) / 2, (lon_sin + 1) / 2
+    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 lat_cos, lat_sin, lon_cos, lon_sin
+    return data
 
 
-def encode_coords(central_lat, central_lon, patch_size, resolution=10):
+def normalize_bands(bands_data, norm_values, order, norm_strat, nodata_value = None) :
     """
-    This function computes the latitude and longitude of a patch, from the latitude and longitude of its central pixel.
-    It then encodes these values into sin/cosine values, and scales the results to [0,1].
+    This function normalizes the bands data using the normalization values and strategy.
 
     Args:
-    - central_lat (float): the latitude of the central pixel
-    - central_lon (float): the longitude of the central pixel
-    - patch_size (tuple): the size of the patch
-    - resolution (int): the resolution of the patch
+    - 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:
-    - (lat_cos, lat_sin, lon_cos, lon_sin) (tuple): the sin/cosine values for the latitude and longitude
+    - 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
 
-    # Initialize arrays to store latitude and longitude coordinates
-
-    i_indices, j_indices = np.indices(patch_size)
-
-    # Calculate the distance offset in meters for each pixel
-    offset_lat = (i_indices - patch_size[0] // 2) * resolution
-    offset_lon = (j_indices - patch_size[1] // 2) * resolution
 
-    # Calculate the latitude and longitude for each pixel
-    latitudes = central_lat + (offset_lat / 6371000) * (180 / np.pi)
-    longitudes = central_lon + (offset_lon / 6371000) * (180 / np.pi) / np.cos(central_lat * np.pi / 180)
+def one_hot(x) :
+    one_hot = np.zeros(len(_biome_values_mapping))
+    one_hot[_biome_values_mapping.get(x, 0)] = 1
+    return one_hot
 
-    lat_cos, lat_sin, lon_cos, lon_sin = encode_lat_lon(latitudes, longitudes)
+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.
 
-    return lat_cos, lat_sin, lon_cos, lon_sin
+    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
+    """
 
-"""
-Example usage:
-lat_cos, lat_sin, lon_cos, lon_sin = encode_coords(lat, lon, self.patch_size)
-lat_cos, lat_sin, lon_cos, lon_sin = lat_cos[..., np.newaxis], lat_sin[..., np.newaxis], lon_cos[..., np.newaxis], lon_sin[..., np.newaxis]
-"""
+    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
 
-#########################################################################################################################
-# Denormalizer
+    else: raise ValueError(f'Encoding strategy `{encode_strat}` is not valid.')
 
 
-def denormalize_data(data, norm_values, norm_strat='pct'):
+def compute_num_features(input_features, encode_strat) :
     """
-    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
+    This function computes the number of features that will be used in the model.
 
     Args:
-    - data (np.array): the data to normalize
-    - norm_values (dict): the normalization values
-    - norm_strat (str): the normalization strategy
+    - input_features (dict): the input features configuration
+    - encode_strat (str): the encoding strategy
 
     Returns:
-    - normalized_data (np.array): the normalized data
+    - num_features (int): the number of features
     """
 
-    if norm_strat == 'mean_std':
-        mean, std = norm_values['mean'], norm_values['std']
-        data = (data - mean) / std
+    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
 
-    elif norm_strat == 'pct':
-        p1, p99 = norm_values['p1'], norm_values['p99']
-        data = data * (p99 - p1) + p1
+    return num_features
 
-    elif norm_strat == 'min_max':
-        min_val, max_val = norm_values['min'], norm_values['max']
-        data = data * (max_val - min_val) + min_val
 
-    else:
-        raise ValueError(f'De-normalization strategy `{norm_strat}` is not valid.')
-
-    return data
-
-
-def denormalize_bands(bands_data, norm_values, order, norm_strat='pct'):
+def concatenate_features(patch, lc_patch, input_features, encode_strat) :
     """
-    This function normalizes the bands data using the normalization values and strategy.
+    This function concatenates the features that the user requested.
 
     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
+    - patch (np.array): the patch data
+    - lc_patch (np.array): the land cover data
+    - input_features (dict): the input features configuration
+    - encode_strat (str): the encoding strategy
 
     Returns:
-    - bands_data (np.array): the normalized bands data
+    - out_patch (np.array): the concatenated features
     """
 
-    for i, band in enumerate(order):
-        band_norm = norm_values[band]
-        bands_data[:, :, i] = denormalize_data(bands_data[:, :, i], band_norm, norm_strat)
+    # Compute the number of features
+    num_features = compute_num_features(input_features, encode_strat)
+    out_patch = np.zeros((num_features, patch.shape[1], patch.shape[2]), dtype = np.float32)
 
-    return bands_data
+    # Concatenate the features
+    current_idx = 0
 
-"""
-def decode_lc(encoded_lc, mode='cos'):
-    # Encode the LC classes with sin/cosine values and scale the data to [0,1]
-    if mode == 'cos':
-        lc = 100 * np.arccos(2 * encoded_lc - 1) / (2 * np.pi)
-    elif mode == 'sin':
-        lc = 100 * np.arcsin(2 * encoded_lc - 1) / (2 * np.pi)
-    else:
-        raise ValueError(f'Mode `{mode}` is not valid.')
-    return lc
-"""
-
-def recover_lc_map(lc_cos, lc_sin):
+    # Sentinel-2 bands
+    s2_indices = [s2_bands_idx[band] for band in input_features['S2_bands']]
+    out_patch[: current_idx + len(s2_indices)] = patch[s2_indices]
+    current_idx += len(s2_indices)
     
-    # Convert lc_cos and lc_sin back to the range of the original sin and cos values
-    lc_cos = 2 * lc_cos - 1
-    lc_sin = 2 * lc_sin - 1
+    # S2 dates
+    if input_features['S2_dates'] : 
+        out_patch[current_idx : current_idx + 3] = patch[12:15]
+        current_idx += 3
     
-    # Calculate the angles using arccos and arcsin
-    theta_cos = np.arccos(lc_cos)
-    sin_theta_cos = np.sin(theta_cos)
-    check = np.isclose(sin_theta_cos, lc_sin, atol = 1e-8)
-    theta = np.where(check, theta_cos, 2 * np.pi - theta_cos)
+    # Lat/Lon
+    if input_features['lat_lon'] : 
+        out_patch[current_idx : current_idx + 4] = patch[15:19]
+        current_idx += 4
     
-    # Convert the angle theta back to lc_map
-    lc_map = np.round((theta / (2 * np.pi)) * 100)
-    lc_map = np.where(lc_map % 10 != 0, lc_map + 100, lc_map)
+    # GEDI dates
+    if input_features['GEDI_dates'] :
+        out_patch[current_idx : current_idx + 3] = patch[19:22]
+        current_idx += 3
+
+    # ALOS bands
+    if input_features['ALOS'] :
+        out_patch[current_idx : current_idx + 2] = patch[22:24]
+        current_idx += 2
     
-    return lc_map
+    # CH bands
+    if input_features['CH'] :
+        out_patch[current_idx] = patch[24]
+        out_patch[current_idx + 1] = patch[25]
+        current_idx += 2
+    
+    # LC data
+    if input_features['LC'] :
+
+        # LC encoding
+        if encode_strat == 'sin_cos' :
+            out_patch[current_idx : current_idx + 2] = lc_patch
+            current_idx += 2
+        elif encode_strat == 'cat2vec' :
+            out_patch[current_idx : current_idx + 5] = lc_patch
+            current_idx += 5
+        elif encode_strat == 'onehot' :
+            out_patch[current_idx : current_idx + len(REF_BIOMES)] = lc_patch
+            current_idx += len(REF_BIOMES)
+        elif encode_strat == 'none' : 
+            out_patch[current_idx] = lc_patch
+            current_idx += 1
+        
+        # LC probability
+        out_patch[current_idx] = patch[27]
+        current_idx += 1
+
+    # Topographic data
+    if input_features['topo'] : 
+        out_patch[current_idx : current_idx + 3] = patch[28:31]
+        current_idx += 3
+
+    # DEM
+    if input_features['DEM'] :
+        out_patch[current_idx] = patch[31]
+        current_idx += 1
+
+    return out_patch
 
+#########################################################################################################################
+# DATASET CLASS DEFINITION
 
 class NewDataset(datasets.GeneratorBasedBuilder):
-    def __init__(self, *args, additional_features=[], normalize_data=True, patch_size=15, **kwargs):
+    """DatasetBuilder for AGBD dataset."""
+    def __init__(self, *args, input_features = default_input_features, additional_features = [], norm_strat = 'pct', 
+                encode_strat = 'sin_cos', patch_size = 15, **kwargs):
+        
         self.inner_dataset_kwargs = kwargs
         self._is_streaming = False
         self.patch_size = patch_size
-        self.normalize_data = normalize_data
+
+        assert norm_strat in ['mean_std', 'pct', 'none'], f'Normalization strategy `{norm_strat}` is not valid.'
+        self.norm_strat = norm_strat
+        
+        assert encode_strat in ['sin_cos', 'cat2vec', 'onehot', 'none'], f'Encoding strategy `{encode_strat}` is not valid.'
+        self.encode_strat = encode_strat
+        
+        self.input_features = input_features
         self.additional_features = additional_features
+
+        if self.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)])
+            self.embeddings = embeddings
+        else: self.embeddings = None
+
         super().__init__(*args, **kwargs)
 
     VERSION = datasets.Version("1.1.0")
 
-
     BUILDER_CONFIGS = [
         datasets.BuilderConfig(name="default", version=VERSION, description="Normalized data"),
         datasets.BuilderConfig(name="unnormalized", version=VERSION, description="Unnormalized data"),
@@ -293,8 +392,6 @@ class NewDataset(datasets.GeneratorBasedBuilder):
             citation=_CITATION,
         )
 
-
-
     def _split_generators(self, dl_manager):
         self.original_dataset = datasets.load_dataset("prs-eth/AGBD_raw", streaming=self._is_streaming)
         return [
@@ -305,38 +402,70 @@ class NewDataset(datasets.GeneratorBasedBuilder):
 
     def _generate_examples(self, split):
         for i, d in enumerate(self.original_dataset[split]):
-            if self.normalize_data :
-                patch = np.asarray(d["input"])
 
-            else:
-                patch = np.asarray(d["input"])
-                patch[:12] = denormalize_bands(patch[:12], norm_values['S2_bands'],['B01', 'B02', 'B03', 'B04', 'B05', 'B06', 'B07', 'B08', 'B8A', 'B09','B11', 'B12'])
-                patch[12:14] = denormalize_bands(patch[12:14], norm_values['ALOS_bands'], ['HH', 'HV'])
-                patch[14] = denormalize_data(patch[14], norm_values['CH']['ch'])
-                patch[15] = denormalize_data(patch[15], norm_values['CH']['std'])
-                lc_cos, lc_sin = patch[16], patch[17]
-                lc = recover_lc_map(lc_cos, lc_sin)
-                patch[16] = lc
-                patch[17] = lc
-                patch[18] = patch[18] * 100
-                patch[19] = denormalize_data(patch[19], norm_values['DEM'])
+            patch = np.asarray(d["input"])
+
+            # ------------------------------------------------------------------------------------------------
+            # Process the data that needs to be processed
+            
+            # Structure of the d["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)
+
+            if self.norm_strat != 'none' :
+
+                # Normalize S2 bands
+                patch[:12] = normalize_bands(patch[:12], norm_values['S2_bands'], ['B01', 'B02', 'B03', 'B04', 'B05', 'B06', 'B07', 'B08', 'B8A', 'B09','B11', 'B12'], self.norm_strat, NODATAVALS['S2_bands'])
+
+                # Normalize s2_num_days
+                patch[12] = normalize_data(patch[12], norm_values['Sentinel_metadata']['S2_date'], 'min_max' if self.norm_strat == 'pct' else self.norm_strat)
 
+                # Normalize gedi_num_days
+                patch[19] = normalize_data(patch[19], norm_values['GEDI']['date'], 'min_max' if self.norm_strat == 'pct' else self.norm_strat)
+                
+                # Normalize ALOS bands
+                patch[22:24] = normalize_bands(patch[22:24], norm_values['ALOS_bands'], ['HH', 'HV'], self.norm_strat, NODATAVALS['ALOS_bands'])
+                
+                # Normalize CH bands
+                patch[24] = normalize_data(patch[24], norm_values['CH']['ch'], self.norm_strat, NODATAVALS['CH'])
+                patch[25] = normalize_data(patch[25], norm_values['CH']['std'], self.norm_strat, NODATAVALS['CH'])
 
-            lat, lon = d["metadata"]["lat"],d["metadata"]["lon"]
+                # Normalize DEM bands
+                patch[31] = normalize_data(patch[31], norm_values['DEM'], self.norm_strat, NODATAVALS['DEM'])
 
-            latlon_patch = encode_coords(lat, lon,(self.patch_size,self.patch_size))
+            # Encode LC data
+            if self.encode_strat != 'none' : lc_patch = encode_biome(patch[26], self.encode_strat, self.embeddings).swapaxes(-1,0)
+            else: lc_patch = patch[26]
 
+            # Put lc_prob in [0,1] range
+            patch[27] = patch[27] / 100
 
+            # ------------------------------------------------------------------------------------------------
+            # Concatenate the features that the user requested
+
+            out_patch = concatenate_features(patch, lc_patch, self.input_features, self.encode_strat)
+
+            # ------------------------------------------------------------------------------------------------
+
+            # Crop to the patch size
             start_x = (patch.shape[1] - self.patch_size) // 2
             start_y = (patch.shape[2] - self.patch_size) // 2
-            patch = patch[:, start_x:start_x + self.patch_size, start_y:start_y + self.patch_size]
+            out_patch = out_patch[:, start_x : start_x + self.patch_size, start_y : start_y + self.patch_size]
 
-            patch = np.concatenate([patch[:12],latlon_patch,patch[12:]],0)
+            # ------------------------------------------------------------------------------------------------
 
-            data = {'input': patch, 'label': d["label"]}
+            # Create the data dictionary
+            data = {'input': out_patch, 'label': d["label"]}
+
+            # Add the additional features
             for feat in self.additional_features:
                 data[feat] = d["metadata"][feat]
 
             yield i, data
 
-