Update AGBD.py

AGBD.py

@@ -14,12 +14,10 @@
 # TODO: Address all TODOs and remove all explanatory comments
 """TODO: Add a description here."""
 
-import csv
-import json
-import os
 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
 _CITATION = """\
@@ -43,19 +41,7 @@ _HOMEPAGE = ""
 # TODO: Add the licence for the dataset here if you can find it
 _LICENSE = ""
 
-norm_values = {
- '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}}
+
 
 feature_dtype = {'s2_num_days': Value('int16'),
  'gedi_num_days': Value('uint16'),
@@ -71,6 +57,140 @@ feature_dtype = {'s2_num_days': Value('int16'),
  "solar_elev": Value('float32'),
  "urban_prop":Value('uint8')}
 
+
+def encode_lat_lon(lat, lon):
+ """
+ Encode the latitude and longitude into sin/cosine values. We use a simple WRAP positional encoding, as
+ Mac Aodha et al. (2019).
+
+ Args:
+ - lat (float): the latitude
+ - lon (float): the longitude
+
+ Returns:
+ - (lat_cos, lat_sin, lon_cos, lon_sin) (tuple): the sin/cosine values for the latitude and longitude
+ """
+
+ # 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)
+
+ # 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
+
+ return lat_cos, lat_sin, lon_cos, lon_sin
+
+
+def encode_coords(central_lat, central_lon, patch_size, resolution=10):
+ """
+ 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].
+
+ 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
+
+ Returns:
+ - (lat_cos, lat_sin, lon_cos, lon_sin) (tuple): the sin/cosine values for the latitude and longitude
+ """
+
+ # 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)
+
+ lat_cos, lat_sin, lon_cos, lon_sin = encode_lat_lon(latitudes, longitudes)
+
+ return lat_cos, lat_sin, lon_cos, lon_sin
+
+
+"""
+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]
+"""
+
+
+#########################################################################################################################
+# Denormalizer
+
+
+def denormalize_data(data, norm_values, norm_strat='pct'):
+ """
+ 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']
+ data = (data - mean) / std
+
+ elif norm_strat == 'pct':
+ p1, p99 = norm_values['p1'], norm_values['p99']
+ data = data * (p99 - p1) + p1
+
+ 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'):
+ """
+ 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
+
+ Returns:
+ - bands_data (np.array): the normalized bands data
+ """
+
+ for i, band in enumerate(order):
+ band_norm = norm_values[band]
+ bands_data[:, :, i] = denormalize_data(bands_data[:, :, i], band_norm, norm_strat)
+
+ return bands_data
+
+
+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
+
 class NewDataset(datasets.GeneratorBasedBuilder):
  def __init__(self, *args, additional_features=[], normalize_data=True, patch_size=15, **kwargs):
  self.inner_dataset_kwargs = kwargs
@@ -82,6 +202,7 @@ class NewDataset(datasets.GeneratorBasedBuilder):
 
  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"),
@@ -94,6 +215,9 @@ class NewDataset(datasets.GeneratorBasedBuilder):
  return super().as_streaming_dataset(split=split, base_path=base_path)
 
  def _info(self):
+ with open('statistics.pkl', 'rb') as f:
+ self.norm_values = pickle.load(f)
+
  all_features = {
  'input': datasets.Sequence(datasets.Sequence(datasets.Sequence(datasets.Value('float32')))),
  'label': Value('float32')
@@ -110,14 +234,7 @@ class NewDataset(datasets.GeneratorBasedBuilder):
  citation=_CITATION,
  )
 
- def denormalize_s2(self, patch):
- res = []
- for band, band_value in zip(['B04', 'B03', 'B02'], [patch[3], patch[2], patch[1]]):
- p1, p99 = norm_values[band]['p1'], norm_values[band]['p99']
- band_value = (p99 - p1) * band_value + p1
- res.append(band_value)
- patch[3], patch[2], patch[1] = res
- return patch
+
 
  def _split_generators(self, dl_manager):
  self.original_dataset = datasets.load_dataset("prs-eth/AGBD_raw", streaming=self._is_streaming)
@@ -129,18 +246,34 @@ class NewDataset(datasets.GeneratorBasedBuilder):
 
  def _generate_examples(self, split):
  for i, d in enumerate(self.original_dataset[split]):
- if self.config.name == "default":
- data = {'input': np.asarray(d["input"]), 'label': d["label"]}
- elif self.config.name == "unnormalized":
- data = {'input': np.asarray(self.denormalize_s2(np.array(d["input"]))), 'label': d["label"]}
+ if self.normalize_data :
+ patch = np.asarray(d["input"])
+
+ else:
+ patch = np.asarray(d["input"])
+ patch[:12] = denormalize_bands(patch[:12], self.norm_values['S2_bands'],['B01', 'B02', 'B03', 'B04', 'B05', 'B06', 'B07', 'B08', 'B8A', 'B09','B11', 'B12'])
+ patch[12:14] = denormalize_bands(patch[12:14], self.norm_values['ALOS_bands'], ['HH', 'HV'])
+ patch[14] = denormalize_data(patch[14], self.norm_values['CH']['ch'])
+ patch[15] = denormalize_data(patch[15], self.norm_values['CH']['std'])
+ patch[16] = decode_lc(patch[16], 'cos')
+ patch[17] = decode_lc(patch[17], 'sin')
+ patch[18] = patch[18] * 100
+ patch[19] = denormalize_data(patch[19], self.norm_values['DEM'])
+
 
- start_x = (data["input"].shape[1] - self.patch_size) // 2
- start_y = (data["input"].shape[2] - self.patch_size) // 2
- data["input"] = data["input"][:, start_x:start_x + self.patch_size, start_y:start_y + self.patch_size]
+ lat, lon = d["metadata"]["lat"],d["metadata"]["lon"]
 
+ latlon_patch = encode_coords(lat, lon,(self.patch_size,self.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]
+
+ patch = np.concatenate([patch[:12],latlon_patch,patch[12:]],0)
+
+ data = {'input': patch, 'label': d["label"]}
  for feat in self.additional_features:
  data[feat] = d["metadata"][feat]
 
  yield i, data
-
-