# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # 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. ############################################################################################################################ # IMPORTS import numpy as np import datasets from datasets import Value import pickle import pandas as pd ############################################################################################################################ # GLOBAL VARIABLES # BibTeX citation _CITATION = """\ @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} } """ # Description of the dataset _DESCRIPTION = """\ 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 = "" # 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'), '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')} # 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) : """ 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 concatenate_features(patch, lc_patch, input_features, encode_strat) : """ This function concatenates the features that the user requested. Args: - 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: - out_patch (np.array): the concatenated features """ # 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) # Concatenate the features current_idx = 0 # 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) # S2 dates if input_features['S2_dates'] : out_patch[current_idx : current_idx + 3] = patch[12:15] current_idx += 3 # Lat/Lon if input_features['lat_lon'] : out_patch[current_idx : current_idx + 4] = patch[15:19] current_idx += 4 # 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 # 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): """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 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"), ] DEFAULT_CONFIG_NAME = "default" def as_streaming_dataset(self, split=None, base_path=None): self._is_streaming = True return super().as_streaming_dataset(split=split, base_path=base_path) def _info(self): all_features = { 'input': datasets.Sequence(datasets.Sequence(datasets.Sequence(datasets.Value('float32')))), 'label': Value('float32') } for feat in self.additional_features: all_features[feat] = feature_dtype[feat] features = datasets.Features(all_features) return datasets.DatasetInfo( description=_DESCRIPTION, features=features, homepage=_HOMEPAGE, license=_LICENSE, citation=_CITATION, ) def _split_generators(self, dl_manager): self.original_dataset = datasets.load_dataset("prs-eth/AGBD_raw", streaming=self._is_streaming) return [ datasets.SplitGenerator(name=datasets.Split.TRAIN, gen_kwargs={"split": "train"}), datasets.SplitGenerator(name=datasets.Split.VALIDATION, gen_kwargs={"split": "validation"}), datasets.SplitGenerator(name=datasets.Split.TEST, gen_kwargs={"split": "test"}), ] def _generate_examples(self, split): for i, d in enumerate(self.original_dataset[split]): 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']) # Normalize DEM bands patch[31] = normalize_data(patch[31], norm_values['DEM'], self.norm_strat, NODATAVALS['DEM']) # 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 out_patch = out_patch[:, start_x : start_x + self.patch_size, start_y : start_y + self.patch_size] # ------------------------------------------------------------------------------------------------ # 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