Datasets:

License:
AGBD / AGBD.py
ghjuliasialelli's picture
Update AGBD.py
8ac67ec verified
# 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