Upload folder using huggingface_hub

UnCRtainTS/.gitignore

@@ -0,0 +1,6 @@
+*.npy
+logs
+model/inference
+model/checkpoint
+model/results
+*_pycache_*

UnCRtainTS/Dockerfile

@@ -0,0 +1,35 @@
+FROM pytorch/pytorch:2.0.0-cuda11.7-cudnn8-runtime
+
+# install dependencies
+#RUN pip install functorch 
+# '' may actually no longer be needed from torch 1.13 on
+RUN pip install cupy-cuda112
+RUN conda install -c conda-forge cupy  
+#RUN conda install pytorch torchvision cudatoolkit=11.7 -c pytorch
+RUN pip install opencv-python 
+# RUN conda install -c conda-forge opencv
+RUN pip install scipy rasterio natsort matplotlib scikit-image tqdm pandas
+RUN pip install Pillow dominate visdom tensorboard
+RUN pip install kornia torchgeometry torchmetrics torchnet segmentation-models-pytorch
+RUN pip install s2cloudless 
+# see: https://github.com/sentinel-hub/sentinel2-cloud-detector/issues/17
+RUN pip install numpy==1.21.6
+
+RUN apt-get -y update
+RUN apt-get -y install git
+RUN pip install -U 'git+https://github.com/facebookresearch/fvcore'
+
+# just in case some last-minute changes are needed
+RUN apt-get install nano
+
+# bake repository into dockerfile
+RUN mkdir -p ./data
+RUN mkdir -p ./model
+RUN mkdir -p ./util
+
+ADD data ./data
+ADD model ./model
+ADD util ./util
+ADD . ./
+
+WORKDIR /workspace/model

UnCRtainTS/README.md

@@ -0,0 +1,109 @@
+# UnCRtainTS: Uncertainty Quantification for Cloud Removal in Optical Satellite Time Series
+
+![banner](architecture.png)
+>
+> _This is the official repository for UnCRtainTS, a network for multi-temporal cloud removal in satellite data combining a novel attention-based architecture, and a formulation for multivariate uncertainty prediction. These two components combined set a new state-of-the-art performance in terms of image reconstruction on two public cloud removal datasets. Additionally, we show how the well-calibrated predicted uncertainties enable a precise control of the reconstruction quality._
+----
+This repository contains code accompanying the paper
+> P. Ebel, V. Garnot, M. Schmitt, J. Wegner and X. X. Zhu. UnCRtainTS: Uncertainty Quantification for Cloud Removal in Optical Satellite Time Series. Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops, 2023.
+
+For additional information:
+
+* The publication is available in the [CVPRW Proceedings](https://openaccess.thecvf.com/content/CVPR2023W/EarthVision/papers/Ebel_UnCRtainTS_Uncertainty_Quantification_for_Cloud_Removal_in_Optical_Satellite_Time_CVPRW_2023_paper.pdf). 
+* The SEN12MS-CR-TS data set is accessible at the MediaTUM page [here](https://mediatum.ub.tum.de/1639953) (train split) and [here](https://mediatum.ub.tum.de/1659251) (test split).
+* You can find additional information on this and related projects on the associated [cloud removal projects page](https://patrickTUM.github.io/cloud_removal/).
+* For any further questions, please reach out to me here or via the credentials on my [website](https://pwjebel.com).
+---
+
+## Installation
+### Dataset
+
+You can easily download the multi-temporal SEN12MS-CR-TS (and, optionally, the mono-temporal SEN12MS-CR) dataset via the shell script in [`./util/dl_data.sh`](https://github.com/PatrickTUM/UnCRtainTS/blob/main/util/dl_data.sh). Alternatively, you may download the SEN12MS-CR-TS data set (or parts of it) via the MediaTUM website [here](https://mediatum.ub.tum.de/1639953) (train split) and [here](https://mediatum.ub.tum.de/1659251) (test split), with further instructions provided in the dataset's own [dedicated repository](https://github.com/PatrickTUM/SEN12MS-CR-TS#dataset).
+
+### Code
+Clone this repository via `git clone https://github.com/PatrickTUM/UnCRtainTS.git`.
+
+and set up the Python environment via 
+
+```bash
+conda env create --file environment.yaml
+conda activate uncrtaints
+```
+
+Alternatively, you may install all that's needed via 
+```bash
+pip install -r requirements.txt
+```
+or by building a Docker image of `Dockerfile` and deploying a container.
+
+The code is written in Python 3 and uses PyTorch $\geq$ 2.0. It is strongly recommended to run the code with CUDA and GPU support. The code has been developed and deployed in Ubuntu 20 LTS and should be able to run in any comparable OS.
+
+---
+
+## Usage
+### Dataset 
+If you already have your own model in place or wish to build one on the SEN12MS-CR-TS data loader for training and testing, the data loader can be used as a stand-alone script as demonstrated in `./standalone_dataloader.py`. This only requires the files `./data/dataLoader.py` (the actual data loader) and `./util/detect_cloudshadow.py` (if this type of cloud detector is chosen).
+
+For using the dataset as a stand-alone with your own model, loading multi-temporal multi-modal data from SEN12MS-CR-TS is as simple as
+
+``` python
+import torch
+from data.dataLoader import SEN12MSCRTS
+dir_SEN12MSCRTS = '/path/to/your/SEN12MSCRTS'
+sen12mscrts     = SEN12MSCRTS(dir_SEN12MSCRTS, split='all', region='all', n_input_samples=3)
+dataloader      = torch.utils.data.DataLoader(sen12mscrts)
+
+for pdx, samples in enumerate(dataloader): print(samples['input'].keys())
+```
+
+and, likewise, if you wish to (pre-)train on the mono-temporal multi-modal SEN12MS-CR dataset:
+ 
+``` python
+import torch
+from data.dataLoader import SEN12MSCR
+dir_SEN12MSCR   = '/path/to/your/SEN12MSCR'
+sen12mscr       = SEN12MSCR(dir_SEN12MSCR, split='all', region='all')
+dataloader      = torch.utils.data.DataLoader(sen12mscr)
+
+for pdx, samples in enumerate(dataloader): print(samples['input'].keys())
+```
+
+Note that computing cloud masks on the fly, depending on the choice of cloud detection, may slow down data loading. For greater efficiency, files of pre-computed cloud coverage statistics can be 
+downloaded [here](https://u.pcloud.link/publink/show?code=kZXdbk0ZaAHNV2a5ofbB9UW4xCyCT0YFYAFk) or pre-computed via `./util/pre_compute_data_samples.py`, and then loaded with the `--precomputed /path/to/files/` flag.
+
+### Basic Commands
+You can train a new model via
+```bash
+cd ./UnCRtainTS/model
+python train_reconstruct.py --experiment_name my_first_experiment --root1 path/to/SEN12MSCRtrain --root2 path/to/SEN12MSCRtest --root3 path/to/SEN12MSCR --model uncrtaints --input_t 3 --region all --epochs 20 --lr 0.001 --batch_size 4 --gamma 1.0 --scale_by 10.0 --trained_checkp "" --loss MGNLL --covmode diag --var_nonLinearity softplus --display_step 10 --use_sar --block_type mbconv --n_head 16 --device cuda --res_dir ./results --rdm_seed 1
+```
+and you can test a (pre-)trained model via
+```bash
+python test_reconstruct.py --experiment_name my_first_experiment -root1 path/to/SEN12MSCRtrain --root2 path/to/SEN12MSCRtest --root3 path/to/SEN12MSCR --input_t 3 --region all --export_every 1 --res_dir ./inference --weight_folder ./results
+```
+
+For a list and description of all flags, please see the parser file `./model/parse_args.py`. To perform inference with pre-trained models, [here](https://u.pcloud.link/publink/show?code=kZsdbk0Z5Y2Y2UEm48XLwOvwSVlL8R2L3daV)'s where you can find the checkpoints. Every checkpoint is accompanied by a json file, documenting the flags set during training and expected to reproduce the model's behavior at test time. If pointing towards the exported configurations upon call, the correct settings get loaded automatically in the test script. Finally, following the exporting of model predictions via `test_reconstruct.py`, multiple models' outputs can be ensembled via `ensemble_reconstruct.py`, to obtain estimates of epistemic uncertainty.
+
+---
+
+
+## References
+
+If you use this code, our models or data set for your research, please cite [this](https://openaccess.thecvf.com/content/CVPR2023W/EarthVision/papers/Ebel_UnCRtainTS_Uncertainty_Quantification_for_Cloud_Removal_in_Optical_Satellite_Time_CVPRW_2023_paper.pdf) publication:
+```bibtex
+@inproceedings{UnCRtainTS,
+        title = {{UnCRtainTS: Uncertainty Quantification for Cloud Removal in Optical Satellite Time Series}},
+        author = {Ebel, Patrick and Garnot, Vivien Sainte Fare and Schmitt, Michael and Wegner, Jan and Zhu, Xiao Xiang},
+        booktitle = {Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops},
+        year = {2023},
+        organization = {IEEE},
+        url = {"https://openaccess.thecvf.com/content/CVPR2023W/EarthVision/papers/Ebel_UnCRtainTS_Uncertainty_Quantification_for_Cloud_Removal_in_Optical_Satellite_Time_CVPRW_2023_paper.pdf"}
+} 
+```
+You may also be interested in our related works, which you can discover on the accompanying [cloud removal projects website](https://patrickTUM.github.io/cloud_removal/).
+
+
+
+## Credits
+
+This code was originally based on the [UTAE](https://github.com/VSainteuf/utae-paps) and the [SEN12MS-CR-TS](https://github.com/PatrickTUM/SEN12MS-CR-TS) repositories. Thanks for making your code publicly available! We hope this repository will equally contribute to the development of future exciting work.

UnCRtainTS/data/dataLoader.py

@@ -0,0 +1,633 @@
+import os
+import glob
+import warnings
+import numpy as np
+from natsort import natsorted
+
+from datetime import datetime
+
+to_date = lambda string: datetime.strptime(string, "%Y-%m-%d")
+S1_LAUNCH = to_date("2014-04-03")
+
+# s2cloudless: see https://github.com/sentinel-hub/sentinel2-cloud-detector
+from s2cloudless import S2PixelCloudDetector
+
+import rasterio
+from rasterio.merge import merge
+from scipy.ndimage import gaussian_filter
+from torch.utils.data import Dataset
+# import sys
+
+# sys.path.append(".")
+from util.detect_cloudshadow import get_cloud_mask, get_shadow_mask
+
+
+# utility functions used in the dataloaders of SEN12MS-CR and SEN12MS-CR-TS
+def read_tif(path_IMG):
+    tif = rasterio.open(path_IMG)
+    return tif
+
+
+def read_img(tif):
+    return tif.read().astype(np.float32)
+
+
+def rescale(img, oldMin, oldMax):
+    oldRange = oldMax - oldMin
+    img = (img - oldMin) / oldRange
+    return img
+
+
+def process_MS(img, method):
+    if method == "default":
+        intensity_min, intensity_max = (
+            0,
+            10000,
+        )  # define a reasonable range of MS intensities
+        img = np.clip(
+            img, intensity_min, intensity_max
+        )  # intensity clipping to a global unified MS intensity range
+        img = rescale(
+            img, intensity_min, intensity_max
+        )  # project to [0,1], preserve global intensities (across patches), gets mapped to [-1,+1] in wrapper
+    if method == "resnet":
+        intensity_min, intensity_max = (
+            0,
+            10000,
+        )  # define a reasonable range of MS intensities
+        img = np.clip(
+            img, intensity_min, intensity_max
+        )  # intensity clipping to a global unified MS intensity range
+        img /= 2000  # project to [0,5], preserve global intensities (across patches)
+    img = np.nan_to_num(img)
+    return img
+
+
+def process_SAR(img, method):
+    if method == "default":
+        dB_min, dB_max = -25, 0  # define a reasonable range of SAR dB
+        img = np.clip(
+            img, dB_min, dB_max
+        )  # intensity clipping to a global unified SAR dB range
+        img = rescale(
+            img, dB_min, dB_max
+        )  # project to [0,1], preserve global intensities (across patches), gets mapped to [-1,+1] in wrapper
+    if method == "resnet":
+        # project SAR to [0, 2] range
+        dB_min, dB_max = [-25.0, -32.5], [0, 0]
+        img = np.concatenate(
+            [
+                (
+                    2
+                    * (np.clip(img[0], dB_min[0], dB_max[0]) - dB_min[0])
+                    / (dB_max[0] - dB_min[0])
+                )[None, ...],
+                (
+                    2
+                    * (np.clip(img[1], dB_min[1], dB_max[1]) - dB_min[1])
+                    / (dB_max[1] - dB_min[1])
+                )[None, ...],
+            ],
+            axis=0,
+        )
+    img = np.nan_to_num(img)
+    return img
+
+
+def get_cloud_cloudshadow_mask(img, cloud_threshold=0.2):
+    cloud_mask = get_cloud_mask(img, cloud_threshold, binarize=True)
+    shadow_mask = get_shadow_mask(img)
+
+    # encode clouds and shadows as segmentation masks
+    cloud_cloudshadow_mask = np.zeros_like(cloud_mask)
+    cloud_cloudshadow_mask[shadow_mask < 0] = -1
+    cloud_cloudshadow_mask[cloud_mask > 0] = 1
+
+    # label clouds and shadows
+    cloud_cloudshadow_mask[cloud_cloudshadow_mask != 0] = 1
+    return cloud_cloudshadow_mask
+
+
+# recursively apply function to nested dictionary
+def iterdict(dictionary, fct):
+    for k, v in dictionary.items():
+        if isinstance(v, dict):
+            dictionary[k] = iterdict(v, fct)
+        else:
+            dictionary[k] = fct(v)
+    return dictionary
+
+
+def get_cloud_map(img, detector, instance=None):
+    # get cloud masks
+    img = np.clip(img, 0, 10000)
+    mask = np.ones((img.shape[-1], img.shape[-1]))
+    # note: if your model may suffer from dark pixel artifacts,
+    #       you may consider adjusting these filtering parameters
+    if not (img.mean() < 1e-5 and img.std() < 1e-5):
+        if detector == "cloud_cloudshadow_mask":
+            threshold = 0.2  # set to e.g. 0.2 or 0.4
+            mask = get_cloud_cloudshadow_mask(img, threshold)
+        elif detector == "s2cloudless_map":
+            threshold = 0.5
+            mask = instance.get_cloud_probability_maps(
+                np.moveaxis(img / 10000, 0, -1)[None, ...]
+            )[0, ...]
+            mask[mask < threshold] = 0
+            mask = gaussian_filter(mask, sigma=2)
+        elif detector == "s2cloudless_mask":
+            mask = instance.get_cloud_masks(np.moveaxis(img / 10000, 0, -1)[None, ...])[
+                0, ...
+            ]
+        else:
+            mask = np.ones((img.shape[-1], img.shape[-1]))
+            warnings.warn(f"Method {detector} not yet implemented!")
+    else:
+        warnings.warn(f"Encountered a blank sample, defaulting to cloudy mask.")
+    return mask.astype(np.float32)
+
+
+# function to fetch paired data, which may differ in modalities or dates
+def get_pairedS1(patch_list, root_dir, mod=None, time=None):
+    paired_list = []
+    for patch in patch_list:
+        seed, roi, modality, time_number, fname = patch.split("/")
+        time = time_number if time is None else time  # unless overwriting, ...
+        mod = (
+            modality if mod is None else mod
+        )  # keep the patch list's original time and modality
+        n_patch = fname.split("patch_")[-1].split(".tif")[0]
+        paired_dir = os.path.join(seed, roi, mod.upper(), str(time))
+        candidates = os.path.join(
+            root_dir,
+            paired_dir,
+            f"{mod}_{seed}_{roi}_ImgNo_{time}_*_patch_{n_patch}.tif",
+        )
+        paired_list.append(
+            os.path.join(paired_dir, os.path.basename(glob.glob(candidates)[0]))
+        )
+    return paired_list
+
+
+
+
+
+
+""" SEN12MSCR data loader class, inherits from torch.utils.data.Dataset
+
+    IN: 
+    root:               str, path to your copy of the SEN12MS-CR-TS data set
+    split:              str, in [all | train | val | test]
+    region:             str, [all | africa | america | asiaEast | asiaWest | europa]
+    cloud_masks:        str, type of cloud mask detector to run on optical data, in []
+    sample_type:        str, [generic | cloudy_cloudfree]
+    n_input_samples:    int, number of input samples in time series
+    rescale_method:     str, [default | resnet]
+    
+    OUT:
+    data_loader:        SEN12MSCRTS instance, implements an iterator that can be traversed via __getitem__(pdx),
+                        which returns the pdx-th dictionary of patch-samples (whose structure depends on sample_type)
+"""
+
+
+class SEN12MSCR(Dataset):
+    def __init__(
+        self,
+        root,
+        split="all",
+        region="all",
+        cloud_masks="s2cloudless_mask",
+        sample_type="pretrain",
+        rescale_method="default",
+    ):
+        self.root_dir = root  # set root directory which contains all ROI
+        self.region = region  # region according to which the ROI are selected
+        if self.region != "all":
+            raise NotImplementedError  # TODO: currently only supporting 'all'
+        self.ROI = {
+            "ROIs1158": ["106"],
+            "ROIs1868": [
+                "17",
+                "36",
+                "56",
+                "73",
+                "85",
+                "100",
+                "114",
+                "119",
+                "121",
+                "126",
+                "127",
+                "139",
+                "142",
+                "143",
+            ],
+            "ROIs1970": [
+                "20",
+                "21",
+                "35",
+                "40",
+                "57",
+                "65",
+                "71",
+                "82",
+                "83",
+                "91",
+                "112",
+                "116",
+                "119",
+                "128",
+                "132",
+                "133",
+                "135",
+                "139",
+                "142",
+                "144",
+                "149",
+            ],
+            "ROIs2017": [
+                "8",
+                "22",
+                "25",
+                "32",
+                "49",
+                "61",
+                "63",
+                "69",
+                "75",
+                "103",
+                "108",
+                "115",
+                "116",
+                "117",
+                "130",
+                "140",
+                "146",
+            ],
+        }
+
+        # define splits conform with SEN12MS-CR-TS
+        self.splits = {}
+        self.splits["train"] = [
+            "ROIs1970_fall_s1/s1_3",
+            "ROIs1970_fall_s1/s1_22",
+            "ROIs1970_fall_s1/s1_148",
+            "ROIs1970_fall_s1/s1_107",
+            "ROIs1970_fall_s1/s1_1",
+            "ROIs1970_fall_s1/s1_114",
+            "ROIs1970_fall_s1/s1_135",
+            "ROIs1970_fall_s1/s1_40",
+            "ROIs1970_fall_s1/s1_42",
+            "ROIs1970_fall_s1/s1_31",
+            "ROIs1970_fall_s1/s1_149",
+            "ROIs1970_fall_s1/s1_64",
+            "ROIs1970_fall_s1/s1_28",
+            "ROIs1970_fall_s1/s1_144",
+            "ROIs1970_fall_s1/s1_57",
+            "ROIs1970_fall_s1/s1_35",
+            "ROIs1970_fall_s1/s1_133",
+            "ROIs1970_fall_s1/s1_30",
+            "ROIs1970_fall_s1/s1_134",
+            "ROIs1970_fall_s1/s1_141",
+            "ROIs1970_fall_s1/s1_112",
+            "ROIs1970_fall_s1/s1_116",
+            "ROIs1970_fall_s1/s1_37",
+            "ROIs1970_fall_s1/s1_26",
+            "ROIs1970_fall_s1/s1_77",
+            "ROIs1970_fall_s1/s1_100",
+            "ROIs1970_fall_s1/s1_83",
+            "ROIs1970_fall_s1/s1_71",
+            "ROIs1970_fall_s1/s1_93",
+            "ROIs1970_fall_s1/s1_119",
+            "ROIs1970_fall_s1/s1_104",
+            "ROIs1970_fall_s1/s1_136",
+            "ROIs1970_fall_s1/s1_6",
+            "ROIs1970_fall_s1/s1_41",
+            "ROIs1970_fall_s1/s1_125",
+            "ROIs1970_fall_s1/s1_91",
+            "ROIs1970_fall_s1/s1_131",
+            "ROIs1970_fall_s1/s1_120",
+            "ROIs1970_fall_s1/s1_110",
+            "ROIs1970_fall_s1/s1_19",
+            "ROIs1970_fall_s1/s1_14",
+            "ROIs1970_fall_s1/s1_81",
+            "ROIs1970_fall_s1/s1_39",
+            "ROIs1970_fall_s1/s1_109",
+            "ROIs1970_fall_s1/s1_33",
+            "ROIs1970_fall_s1/s1_88",
+            "ROIs1970_fall_s1/s1_11",
+            "ROIs1970_fall_s1/s1_128",
+            "ROIs1970_fall_s1/s1_142",
+            "ROIs1970_fall_s1/s1_122",
+            "ROIs1970_fall_s1/s1_4",
+            "ROIs1970_fall_s1/s1_27",
+            "ROIs1970_fall_s1/s1_147",
+            "ROIs1970_fall_s1/s1_85",
+            "ROIs1970_fall_s1/s1_82",
+            "ROIs1970_fall_s1/s1_105",
+            "ROIs1158_spring_s1/s1_9",
+            "ROIs1158_spring_s1/s1_1",
+            "ROIs1158_spring_s1/s1_124",
+            "ROIs1158_spring_s1/s1_40",
+            "ROIs1158_spring_s1/s1_101",
+            "ROIs1158_spring_s1/s1_21",
+            "ROIs1158_spring_s1/s1_134",
+            "ROIs1158_spring_s1/s1_145",
+            "ROIs1158_spring_s1/s1_141",
+            "ROIs1158_spring_s1/s1_66",
+            "ROIs1158_spring_s1/s1_8",
+            "ROIs1158_spring_s1/s1_26",
+            "ROIs1158_spring_s1/s1_77",
+            "ROIs1158_spring_s1/s1_113",
+            "ROIs1158_spring_s1/s1_100",
+            "ROIs1158_spring_s1/s1_117",
+            "ROIs1158_spring_s1/s1_119",
+            "ROIs1158_spring_s1/s1_6",
+            "ROIs1158_spring_s1/s1_58",
+            "ROIs1158_spring_s1/s1_120",
+            "ROIs1158_spring_s1/s1_110",
+            "ROIs1158_spring_s1/s1_126",
+            "ROIs1158_spring_s1/s1_115",
+            "ROIs1158_spring_s1/s1_121",
+            "ROIs1158_spring_s1/s1_39",
+            "ROIs1158_spring_s1/s1_109",
+            "ROIs1158_spring_s1/s1_63",
+            "ROIs1158_spring_s1/s1_75",
+            "ROIs1158_spring_s1/s1_132",
+            "ROIs1158_spring_s1/s1_128",
+            "ROIs1158_spring_s1/s1_142",
+            "ROIs1158_spring_s1/s1_15",
+            "ROIs1158_spring_s1/s1_45",
+            "ROIs1158_spring_s1/s1_97",
+            "ROIs1158_spring_s1/s1_147",
+            "ROIs1868_summer_s1/s1_90",
+            "ROIs1868_summer_s1/s1_87",
+            "ROIs1868_summer_s1/s1_25",
+            "ROIs1868_summer_s1/s1_124",
+            "ROIs1868_summer_s1/s1_114",
+            "ROIs1868_summer_s1/s1_135",
+            "ROIs1868_summer_s1/s1_40",
+            "ROIs1868_summer_s1/s1_101",
+            "ROIs1868_summer_s1/s1_42",
+            "ROIs1868_summer_s1/s1_31",
+            "ROIs1868_summer_s1/s1_36",
+            "ROIs1868_summer_s1/s1_139",
+            "ROIs1868_summer_s1/s1_56",
+            "ROIs1868_summer_s1/s1_133",
+            "ROIs1868_summer_s1/s1_55",
+            "ROIs1868_summer_s1/s1_43",
+            "ROIs1868_summer_s1/s1_113",
+            "ROIs1868_summer_s1/s1_76",
+            "ROIs1868_summer_s1/s1_123",
+            "ROIs1868_summer_s1/s1_143",
+            "ROIs1868_summer_s1/s1_93",
+            "ROIs1868_summer_s1/s1_125",
+            "ROIs1868_summer_s1/s1_89",
+            "ROIs1868_summer_s1/s1_120",
+            "ROIs1868_summer_s1/s1_126",
+            "ROIs1868_summer_s1/s1_72",
+            "ROIs1868_summer_s1/s1_115",
+            "ROIs1868_summer_s1/s1_121",
+            "ROIs1868_summer_s1/s1_146",
+            "ROIs1868_summer_s1/s1_140",
+            "ROIs1868_summer_s1/s1_95",
+            "ROIs1868_summer_s1/s1_102",
+            "ROIs1868_summer_s1/s1_7",
+            "ROIs1868_summer_s1/s1_11",
+            "ROIs1868_summer_s1/s1_132",
+            "ROIs1868_summer_s1/s1_15",
+            "ROIs1868_summer_s1/s1_137",
+            "ROIs1868_summer_s1/s1_4",
+            "ROIs1868_summer_s1/s1_27",
+            "ROIs1868_summer_s1/s1_147",
+            "ROIs1868_summer_s1/s1_86",
+            "ROIs1868_summer_s1/s1_47",
+            "ROIs2017_winter_s1/s1_68",
+            "ROIs2017_winter_s1/s1_25",
+            "ROIs2017_winter_s1/s1_62",
+            "ROIs2017_winter_s1/s1_135",
+            "ROIs2017_winter_s1/s1_42",
+            "ROIs2017_winter_s1/s1_64",
+            "ROIs2017_winter_s1/s1_21",
+            "ROIs2017_winter_s1/s1_55",
+            "ROIs2017_winter_s1/s1_112",
+            "ROIs2017_winter_s1/s1_116",
+            "ROIs2017_winter_s1/s1_8",
+            "ROIs2017_winter_s1/s1_59",
+            "ROIs2017_winter_s1/s1_49",
+            "ROIs2017_winter_s1/s1_104",
+            "ROIs2017_winter_s1/s1_81",
+            "ROIs2017_winter_s1/s1_146",
+            "ROIs2017_winter_s1/s1_75",
+            "ROIs2017_winter_s1/s1_94",
+            "ROIs2017_winter_s1/s1_102",
+            "ROIs2017_winter_s1/s1_61",
+            "ROIs2017_winter_s1/s1_47",
+            "ROIs1868_summer_s1/s1_100",  # note: this ROI is also used for testing in SEN12MS-CR-TS. If you wish to combine both datasets, please comment out this line
+        ]
+        self.splits["val"] = [
+            "ROIs2017_winter_s1/s1_22",
+            "ROIs1868_summer_s1/s1_19",
+            "ROIs1970_fall_s1/s1_65",
+            "ROIs1158_spring_s1/s1_17",
+            "ROIs2017_winter_s1/s1_107",
+            "ROIs1868_summer_s1/s1_80",
+            "ROIs1868_summer_s1/s1_127",
+            "ROIs2017_winter_s1/s1_130",
+            "ROIs1868_summer_s1/s1_17",
+            "ROIs2017_winter_s1/s1_84",
+        ]
+        self.splits["test"] = [
+            "ROIs1158_spring_s1/s1_106",
+            "ROIs1158_spring_s1/s1_123",
+            "ROIs1158_spring_s1/s1_140",
+            "ROIs1158_spring_s1/s1_31",
+            "ROIs1158_spring_s1/s1_44",
+            "ROIs1868_summer_s1/s1_119",
+            "ROIs1868_summer_s1/s1_73",
+            "ROIs1970_fall_s1/s1_139",
+            "ROIs2017_winter_s1/s1_108",
+            "ROIs2017_winter_s1/s1_63",
+        ]
+
+        self.splits["all"] = (
+            self.splits["train"] + self.splits["test"] + self.splits["val"]
+        )
+        self.split = split
+
+        assert split in [
+            "all",
+            "train",
+            "val",
+            "test",
+        ], "Input dataset must be either assigned as all, train, test, or val!"
+        assert sample_type in ["pretrain"], "Input data must be pretrain!"
+        assert cloud_masks in [
+            None,
+            "cloud_cloudshadow_mask",
+            "s2cloudless_map",
+            "s2cloudless_mask",
+        ], "Unknown cloud mask type!"
+
+        self.modalities = ["S1", "S2"]
+        self.cloud_masks = cloud_masks  # e.g. 'cloud_cloudshadow_mask', 's2cloudless_map', 's2cloudless_mask'
+        self.sample_type = sample_type  # e.g. 'pretrain'
+
+        self.time_points = range(1)
+        self.n_input_t = 1  # specifies the number of samples, if only part of the time series is used as an input
+
+        if self.cloud_masks in ["s2cloudless_map", "s2cloudless_mask"]:
+            self.cloud_detector = S2PixelCloudDetector(
+                threshold=0.4, all_bands=True, average_over=4, dilation_size=2
+            )
+        else:
+            self.cloud_detector = None
+
+        self.paths = self.get_paths()
+        self.n_samples = len(self.paths)
+
+        # raise a warning if no data has been found
+        if not self.n_samples:
+            self.throw_warn()
+
+        self.method = rescale_method
+
+    # indexes all patches contained in the current data split
+    def get_paths(
+        self,
+    ):  # assuming for the same ROI+num, the patch numbers are the same
+        print(f"\nProcessing paths for {self.split} split of region {self.region}")
+
+        paths = []
+        seeds_S1 = natsorted(
+            [s1dir for s1dir in os.listdir(self.root_dir) if "_s1" in s1dir]
+        )
+        for seed in seeds_S1:
+            rois_S1 = natsorted(os.listdir(os.path.join(self.root_dir, seed)))
+            for roi in rois_S1:
+                roi_dir = os.path.join(self.root_dir, seed, roi)
+                paths_S1 = natsorted(
+                    [os.path.join(roi_dir, s1patch) for s1patch in os.listdir(roi_dir)]
+                )
+                paths_S2 = [
+                    patch.replace("/s1", "/s2").replace("_s1", "_s2")
+                    for patch in paths_S1
+                ]
+                paths_S2_cloudy = [
+                    patch.replace("/s1", "/s2_cloudy").replace("_s1", "_s2_cloudy")
+                    for patch in paths_S1
+                ]
+
+                for pdx, _ in enumerate(paths_S1):
+                    # omit patches that are potentially unpaired
+                    if not all(
+                        [
+                            os.path.isfile(paths_S1[pdx]),
+                            os.path.isfile(paths_S2[pdx]),
+                            os.path.isfile(paths_S2_cloudy[pdx]),
+                        ]
+                    ):
+                        continue
+                    # don't add patch if not belonging to the selected split
+                    if not any(
+                        [
+                            split_roi in paths_S1[pdx]
+                            for split_roi in self.splits[self.split]
+                        ]
+                    ):
+                        continue
+                    sample = {
+                        "S1": paths_S1[pdx],
+                        "S2": paths_S2[pdx],
+                        "S2_cloudy": paths_S2_cloudy[pdx],
+                    }
+                    paths.append(sample)
+        return paths
+
+    def __getitem__(self, pdx):  # get the triplet of patch with ID pdx
+        s1_tif = read_tif(self.paths[pdx]["S1"])
+        s2_tif = read_tif(self.paths[pdx]["S2"])
+        s2_cloudy_tif = read_tif(self.paths[pdx]["S2_cloudy"])
+        coord = list(s2_tif.bounds)
+        s1 = process_SAR(read_img(s1_tif), self.method)
+        s2 = read_img(s2_tif)  # note: pre-processing happens after cloud detection
+        s2_cloudy = read_img(
+            s2_cloudy_tif
+        )  # note: pre-processing happens after cloud detection
+        mask = (
+            None
+            if not self.cloud_masks
+            else get_cloud_map(s2_cloudy, self.cloud_masks, self.cloud_detector)
+        )
+
+        sample = {
+            "input": {
+                "S1": s1,
+                "S2": process_MS(s2_cloudy, self.method),
+                "masks": mask,
+                "coverage": np.mean(mask),
+                "S1 path": os.path.join(self.root_dir, self.paths[pdx]["S1"]),
+                "S2 path": os.path.join(self.root_dir, self.paths[pdx]["S2_cloudy"]),
+                "coord": coord,
+            },
+            "target": {
+                "S2": process_MS(s2, self.method),
+                "S2 path": os.path.join(self.root_dir, self.paths[pdx]["S2"]),
+                "coord": coord,
+            },
+        }
+        return sample
+
+    def throw_warn(self):
+        warnings.warn(
+            """No data samples found! Please use the following directory structure:
+
+        path/to/your/SEN12MSCR/directory:
+            ├───ROIs1158_spring_s1
+            |   ├─s1_1
+            |   |   |...
+            |   |   ├─ROIs1158_spring_s1_1_p407.tif
+            |   |   |...
+            |    ...
+            ├───ROIs1158_spring_s2
+            |   ├─s2_1
+            |   |   |...
+            |   |   ├─ROIs1158_spring_s2_1_p407.tif
+            |   |   |...
+            |    ...
+            ├───ROIs1158_spring_s2_cloudy
+            |   ├─s2_cloudy_1
+            |   |   |...
+            |   |   ├─ROIs1158_spring_s2_cloudy_1_p407.tif
+            |   |   |...
+            |    ...
+            ...
+
+        Note: Please arrange the dataset in a format as e.g. provided by the script dl_data.sh.
+        """
+        )
+
+    def __len__(self):
+        # length of generated list
+        return self.n_samples
+
+
+if __name__ == "__main__":
+    dataset = SEN12MSCR(
+        root="data2/SEN12MSCR",
+        split="all",
+        region="all",
+        cloud_masks="s2cloudless_mask",
+        sample_type="pretrain",
+        rescale_method="default",
+    )
+    for each in dataset:
+        print(f"{each['input']['S1'].shape}")
+        print(f"{each['input']['S2'].shape}")
+        print(f"{each['input']['masks'].shape}")
+        print(f"{each['target']['S2'].shape}")
+        # (2, 256, 256)
+        # (13, 256, 256)
+        # (256, 256)
+        # (13, 256, 256)
+        break

UnCRtainTS/environment.yaml

@@ -0,0 +1,13 @@
+name: uncrtaints
+channels:
+  - nvidia
+  - pytorch
+  - defaults
+dependencies:
+  - nvidia::cudatoolkit=11.7
+  - python
+  - pip=20.3
+  - pytorch::pytorch=2.0.0
+  - numpy
+  - pip:
+

UnCRtainTS/model/.gitignore

@@ -0,0 +1,136 @@
+# Byte-compiled / optimized / DLL files
+todo.txt
+__pycache__/
+*.py[cod]
+*$py.class
+*.swp
+# C extensions
+*.so
+.idea/
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+
+.DS_Store
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# ignore particular folders and directories
+./util/precomputed

UnCRtainTS/model/checkpoint/diffcr_bs32_epoch17/model.pth.tar

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

UnCRtainTS/model/checkpoint/monotemporalL2/conf.json

@@ -0,0 +1,56 @@
+{
+    "model": "uncrtaints",
+    "encoder_widths": [
+        128
+    ],
+    "decoder_widths": [
+        128,
+        128,
+        128,
+        128,
+        128
+    ],
+    "out_conv": [
+        13
+    ],
+    "mean_nonLinearity": true,
+    "var_nonLinearity": "softplus",
+    "use_sar": true,
+    "agg_mode": "att_group",
+    "encoder_norm": "group",
+    "decoder_norm": "batch",
+    "n_head": 1,
+    "d_model": 256,
+    "use_v": false,
+    "positional_encoding": true,
+    "d_k": 4,
+    "res_dir": "./results",
+    "experiment_name": "monotemporalL2",
+    "device": "cuda",
+    "display_step": 10,
+    "batch_size": 4,
+    "lr": 0.001,
+    "gamma": 0.8,
+    "ref_date": "2014-04-03",
+    "pad_value": 0,
+    "padding_mode": "reflect",
+    "val_every": 1,
+    "val_after": 0,
+    "pretrain": true,
+    "input_t": 1,
+    "sample_type": "pretrain",
+    "vary_samples": true,
+    "min_cov": 0.0,
+    "max_cov": 1.0,
+    "region": "all",
+    "max_samples": 1000000000,
+    "input_size": 256,
+    "plot_every": -1,
+    "loss": "l2",
+    "covmode": "diag",
+    "scale_by": 10.0,
+    "separate_out": false,
+    "resume_from": false,
+    "epochs": 20,
+    "trained_checkp": ""
+}

UnCRtainTS/model/checkpoint/monotemporalL2/model.pth.tar

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

UnCRtainTS/model/ensemble_reconstruct.py

@@ -0,0 +1,180 @@
+"""
+ Python script to obtain Deep Ensemble predictions by collecting each instance's pre-computed predictions.
+    Each member's predictions are first meant to be pre-computed via test_reconstruct.py, with the outputs exported,
+    and read again in this script. Online ensembling is currently not implemented as this may exceed hardware constraints.
+    For every ensemble member, the path to its output directory has to be specified in the list 'ensemble_paths'.
+"""
+
+import os
+import sys
+import torch
+import numpy as np
+from tqdm import tqdm
+from natsort import natsorted
+
+dirname = os.path.dirname(os.path.abspath(__file__))
+sys.path.append(os.path.dirname(dirname))
+
+from data.dataLoader import SEN12MSCR, SEN12MSCRTS
+from src.learning.metrics import img_metrics, avg_img_metrics
+from train_reconstruct import recursive_todevice, compute_uce_auce, export, plot_img, save_results
+
+epoch       = 1
+root		= '/home/data/' # path to directory containing dataset
+mode        = 'test'        # split to evaluate on
+in_time     = 3             # length of input time series
+region      = 'all'         # region of areas of interest
+max_samples = 1e9           # maximum count of samples to consider
+uncertainty = 'both'        # e.g. 'aleatoric', 'epistemic', 'both' --- only matters if ensemble==True
+ensemble    = True          # whether to compute ensemble mean and var or not
+pixelwise   = True          # whether to summarize errors and variances for image-based AUCE and UCE or keep pixel-based statistics
+export_path = None          # where to export ensemble statistics, set to None if no writing to files is desired
+
+# define path to find the individual ensembe member's predictions in
+ensemble_paths = [os.path.join(dirname, 'inference', f'diagonal_1/export/epoch_{epoch}/{mode}'),
+                  os.path.join(dirname, 'inference', f'diagonal_2/export/epoch_{epoch}/{mode}'),
+                  os.path.join(dirname, 'inference', f'diagonal_3/export/epoch_{epoch}/{mode}'),
+                  os.path.join(dirname, 'inference', f'diagonal_4/export/epoch_{epoch}/{mode}'), 
+                  os.path.join(dirname, 'inference', f'diagonal_5/export/epoch_{epoch}/{mode}'),
+                  ]
+
+n_ensemble = len(ensemble_paths)
+print('Ensembling over model predictions:')
+for instance in ensemble_paths: print(instance)
+
+if export_path:
+    plot_dir    = os.path.join(export_path, 'plots', f'epoch_{epoch}', f'{mode}')
+    export_dir  = os.path.join(export_path, 'export', f'epoch_{epoch}', f'{mode}')
+
+
+def prepare_data_multi(batch, device, batch_size=1, use_sar=True):
+    in_S2     = recursive_todevice(torch.tensor(batch['input']['S2']), device)
+    in_S2_td  = recursive_todevice(torch.tensor(batch['input']['S2 TD']), device)
+    if batch_size>1: in_S2_td = torch.stack((in_S2_td)).T
+    in_m      = recursive_todevice(torch.tensor(batch['input']['masks']), device) 
+    target_S2 = recursive_todevice(torch.tensor(batch['target']['S2']), device)
+    y         = target_S2 
+
+    if use_sar: 
+        in_S1 = recursive_todevice(torch.tensor(batch['input']['S1']), device)
+        in_S1_td = recursive_todevice(torch.tensor(batch['input']['S1 TD']), device)
+        if batch_size>1: in_S1_td = torch.stack((in_S1_td)).T
+        x     = torch.cat((torch.stack(in_S1,dim=1), torch.stack(in_S2,dim=1)),dim=2)
+        dates = torch.stack((torch.tensor(in_S1_td),torch.tensor(in_S2_td))).float().mean(dim=0).to(device)
+    else:
+        x     = in_S2 # torch.stack(in_S2,dim=1)
+        dates = torch.tensor(in_S2_td).float().to(device)
+    
+    return x.unsqueeze(dim=0), y.unsqueeze(dim=0), in_m.unsqueeze(dim=0), dates
+
+
+def main():
+
+    # list all predictions of the first ensemble member
+    dataPath = ensemble_paths[0]
+    samples  = natsorted([os.path.join(dataPath, f) for f in os.listdir(dataPath) if (os.path.isfile(os.path.join(dataPath, f)) and "_pred.npy" in f)])
+
+    # collect sample-averaged uncertainties and errors
+    img_meter  = avg_img_metrics()
+    vars_aleatoric = []
+    errs, errs_se, errs_ae = [], [], []
+
+    import_data_path = os.path.join(os.getcwd(), 'util', 'precomputed', f'generic_{in_time}_{mode}_{region}_s2cloudless_mask.npy')
+    import_data_path = import_data_path if os.path.isfile(import_data_path) else None
+    dt_test          = SEN12MSCRTS(os.path.join(root, 'SEN12MSCRTS'), split=mode, region=region, sample_type="cloudy_cloudfree" , n_input_samples=in_time, import_data_path=import_data_path)
+    if len(dt_test.paths) != len(samples): raise AssertionError
+
+    # iterate over the ensemble member's mean predictions
+    for idx, sample_mean in enumerate(tqdm(samples)):
+        if idx >= max_samples: break # exceeded desired sample count
+
+        # fetch target data and cloud masks of idx-th sample from
+        batch = dt_test.getsample(idx) # ... in order to compute metrics
+        x, y, in_m, _ = prepare_data_multi(batch, 'cuda', batch_size=1, use_sar=False)
+
+        try:
+            mean, var = [], []
+            for path in ensemble_paths: # for each ensemble member ...
+                # ... load the member's mean predictions and ...
+                mean.append(np.load(os.path.join(path, os.path.basename(sample_mean))))
+                # ... load the member's covariance or var predictions
+                sample_var  = sample_mean.replace('_pred', '_covar') 
+                if not os.path.isfile(os.path.join(path, os.path.basename(sample_var))):
+                    sample_var  = sample_mean.replace('_pred', '_var') 
+                var.append(np.load(os.path.join(path, os.path.basename(sample_var))))
+        except:
+            # skip any sample for which not all members provide predictions
+            # (note: we also next'ed the dataloader's sample already)
+            print(f'Skipped sample {idx}, missing data.')
+            continue
+        mean, var = np.array(mean), np.array(var)
+
+        # get the variances from the covariance matrix
+        if len(var.shape) > 4: # loaded covariance matrix
+            var = np.moveaxis(np.diagonal(var, axis1=1, axis2=2), -1, 1)
+
+        # combine predictions
+
+        if ensemble:
+            # get ensemble estimate and epistemic uncertainty,
+            # approximate 1 Gaussian by mixture parameter ensembling
+            mean_ensemble = 1/n_ensemble * np.sum(mean, axis=0)
+            
+            if uncertainty == 'aleatoric':
+                # average the members' aleatoric uncertainties
+                var_ensemble  = 1/n_ensemble * np.sum(var, axis=0)
+            elif uncertainty == 'epistemic':     
+                # compute average variance of ensemble predictions      
+                var_ensemble  = 1/n_ensemble * np.sum(mean**2, axis=0) - mean_ensemble**2
+            elif uncertainty == 'both':
+                # combine both
+                var_ensemble  = 1/n_ensemble * np.sum(var + mean**2, axis=0) - mean_ensemble**2
+            else: raise NotImplementedError
+        else: mean_ensemble, var_ensemble = mean[0], var[0]
+
+        mean_ensemble = torch.tensor(mean_ensemble).cuda()
+        var_ensemble  = torch.tensor(var_ensemble).cuda()
+
+        # compute test metrics on ensemble prediction
+        extended_metrics = img_metrics(y[0], mean_ensemble.unsqueeze(dim=0),
+                                       var=var_ensemble.unsqueeze(dim=0), 
+                                       pixelwise=pixelwise)
+        img_meter.add(extended_metrics) # accumulate performances over the entire split
+
+        if pixelwise: # collect variances and errors
+            vars_aleatoric.extend(extended_metrics['pixelwise var']) 
+            errs.extend(extended_metrics['pixelwise error']) 
+            errs_se.extend(extended_metrics['pixelwise se']) 
+            errs_ae.extend(extended_metrics['pixelwise ae']) 
+        else:
+            vars_aleatoric.append(extended_metrics['mean var']) 
+            errs.append(extended_metrics['error'])
+            errs_se.append(extended_metrics['mean se'])
+            errs_ae.append(extended_metrics['mean ae'])
+
+        if export_path: # plot and export ensemble predictions
+            plot_img(mean_ensemble.unsqueeze(dim=0), 'pred', plot_dir, file_id=idx)
+            plot_img(x[0], 'in', plot_dir, file_id=idx)
+            plot_img(var_ensemble.mean(dim=0, keepdims=True).expand(3, *var_ensemble.shape[1:]).unsqueeze(dim=0), 'var', plot_dir, file_id=idx)
+            export(mean_ensemble[None], 'pred', export_dir, file_id=idx)
+            export(var_ensemble[None], 'var', export_dir, file_id=idx)
+
+
+    # compute UCE and AUCE
+    uce_l2, auce_l2 = compute_uce_auce(vars_aleatoric, errs, len(vars_aleatoric), percent=5, l2=True, mode=mode, step=0)
+
+    # no need for a running mean here
+    img_meter.value()['UCE SE']  = uce_l2.cpu().numpy().item()
+    img_meter.value()['AUCE SE'] = auce_l2.cpu().numpy().item()
+
+    print(f'{mode} split image metrics: {img_meter.value()}')
+    if export_path:
+        np.save(os.path.join(export_path, f'pred_var_{uncertainty}.npy'), vars_aleatoric)
+        np.save(os.path.join(export_path, 'errors.npy'), errs)
+        save_results(img_meter.value(), export_path, split=mode)
+        print(f'Exported predictions to path {export_path}')
+
+
+if __name__ == "__main__":
+    main()
+    exit()

UnCRtainTS/model/inference/diffcr_bs32_epoch17/conf.json

@@ -0,0 +1,73 @@
+{
+    "model": "uncrtaints",
+    "experiment_name": "diffcr_bs32_epoch17",
+    "res_dir": "./inference",
+    "plot_every": -1,
+    "export_every": 1,
+    "resume_at": -1,
+    "encoder_widths": [
+        128
+    ],
+    "decoder_widths": [
+        128,
+        128,
+        128,
+        128,
+        128
+    ],
+    "out_conv": [
+        13
+    ],
+    "mean_nonLinearity": true,
+    "var_nonLinearity": "softplus",
+    "agg_mode": "att_group",
+    "encoder_norm": "group",
+    "decoder_norm": "batch",
+    "block_type": "mbconv",
+    "padding_mode": "reflect",
+    "pad_value": 0,
+    "n_head": 16,
+    "d_model": 256,
+    "positional_encoding": true,
+    "d_k": 4,
+    "low_res_size": 32,
+    "use_v": false,
+    "num_workers": 0,
+    "rdm_seed": 1,
+    "device": "cuda:6",
+    "display_step": 10,
+    "loss": "MGNLL",
+    "resume_from": false,
+    "unfreeze_after": 0,
+    "epochs": 20,
+    "batch_size": 32,
+    "chunk_size": null,
+    "lr": 0.01,
+    "gamma": 1.0,
+    "val_every": 1,
+    "val_after": 0,
+    "use_sar": true,
+    "pretrain": true,
+    "input_t": 1,
+    "ref_date": "2014-04-03",
+    "sample_type": "pretrain",
+    "vary_samples": true,
+    "min_cov": 0.0,
+    "max_cov": 1.0,
+    "root1": "/home/data/SEN12MSCRTS",
+    "root2": "/home/data/SEN12MSCRTS",
+    "root3": "data2/SEN12MSCR",
+    "precomputed": "/home/code/UnCRtainTS/util/precomputed",
+    "region": "all",
+    "max_samples_count": 1000000000,
+    "max_samples_frac": 1.0,
+    "profile": false,
+    "trained_checkp": "",
+    "covmode": "diag",
+    "scale_by": 1.0,
+    "separate_out": false,
+    "weight_folder": "checkpoint/",
+    "use_custom": false,
+    "load_config": "",
+    "pid": 2049339
+}

UnCRtainTS/model/inference/monotemporalL2/conf.json

@@ -0,0 +1,75 @@
+{
+    "model": "uncrtaints",
+    "encoder_widths": [
+        128
+    ],
+    "decoder_widths": [
+        128,
+        128,
+        128,
+        128,
+        128
+    ],
+    "out_conv": [
+        13
+    ],
+    "mean_nonLinearity": true,
+    "var_nonLinearity": "softplus",
+    "use_sar": true,
+    "agg_mode": "att_group",
+    "encoder_norm": "group",
+    "decoder_norm": "batch",
+    "n_head": 1,
+    "d_model": 256,
+    "use_v": false,
+    "positional_encoding": true,
+    "d_k": 4,
+    "experiment_name": "monotemporalL2",
+    "lr": 0.001,
+    "gamma": 0.8,
+    "ref_date": "2014-04-03",
+    "pad_value": 0,
+    "padding_mode": "reflect",
+    "val_every": 1,
+    "val_after": 0,
+    "pretrain": true,
+    "sample_type": "pretrain",
+    "vary_samples": true,
+    "max_samples": 1000000000,
+    "input_size": 256,
+    "loss": "l2",
+    "covmode": "diag",
+    "scale_by": 10.0,
+    "separate_out": false,
+    "resume_from": false,
+    "epochs": 20,
+    "res_dir": "./inference",
+    "plot_every": -1,
+    "export_every": 1,
+    "resume_at": -1,
+    "device": "cuda:6",
+    "display_step": 10,
+    "batch_size": 128,
+    "input_t": 1,
+    "min_cov": 0.0,
+    "max_cov": 1.0,
+    "root1": "/home/data/SEN12MSCRTS",
+    "root2": "/home/data/SEN12MSCRTS",
+    "root3": "data2/SEN12MSCR",
+    "region": "all",
+    "max_samples_count": 1000000000,
+    "trained_checkp": "",
+    "weight_folder": "checkpoint/",
+    "pid": 2973877,
+    "block_type": "mbconv",
+    "low_res_size": 32,
+    "num_workers": 0,
+    "rdm_seed": 1,
+    "unfreeze_after": 0,
+    "chunk_size": null,
+    "precomputed": "/home/code/UnCRtainTS/util/precomputed",
+    "max_samples_frac": 1.0,
+    "profile": false,
+    "use_custom": false,
+    "load_config": ""
+}

UnCRtainTS/model/inference/monotemporalL2/test_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.038980784788900186,
+    "MAE": 0.02744151706378001,
+    "PSNR": 28.900039257648842,
+    "SAM": 8.320397798952893,
+    "SSIM": 0.8797316785507024,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/parse_args.py

@@ -0,0 +1,95 @@
+import argparse
+
+S2_BANDS = 13
+
+def create_parser(mode='train'):
+    parser = argparse.ArgumentParser()
+    # model parameters
+    parser.add_argument(
+        "--model",
+        default='uncrtaints', # e.g. 'unet', 'utae', 'uncrtaints',
+        type=str,
+        help="Type of architecture to use. Can be one of: (utae/unet3d/fpn/convlstm/convgru/uconvlstm/buconvlstm)",
+    )
+    parser.add_argument("--experiment_name", default='my_first_experiment', help="Name of the current experiment",)
+
+    # fast switching between default arguments, depending on train versus test mode
+    if mode=='train':
+        parser.add_argument("--res_dir", default="./results", help="Path to where the results are stored, e.g. ./results for training or ./inference for testing",)
+        parser.add_argument("--plot_every", default=-1, type=int, help="Interval (in items) of exporting plots at validation or test time. Set -1 to disable")
+        parser.add_argument("--export_every", default=-1, type=int, help="Interval (in items) of exporting data at validation or test time. Set -1 to disable")
+        parser.add_argument("--resume_at", default=0, type=int, help="Epoch to resume training from (may re-weight --lr in the optimizer) or epoch to load checkpoint from at test time")
+    elif mode=='test':
+        parser.add_argument("--res_dir", default="./inference", type=str, help="Path to directory where results are written.")
+        parser.add_argument("--plot_every", default=-1, type=int, help="Interval (in items) of exporting plots at validation or test time. Set -1 to disable")
+        parser.add_argument("--export_every", default=1, type=int, help="Interval (in items) of exporting data at validation or test time. Set -1 to disable")
+        parser.add_argument("--resume_at", default=-1, type=int, help="Epoch to load checkpoint from and run testing with (use -1 for best on validation split)")
+
+    parser.add_argument("--encoder_widths", default="[128]", type=str, help="e.g. [64,64,64,128] for U-TAE or [128] for UnCRtainTS")
+    parser.add_argument("--decoder_widths", default="[128,128,128,128,128]", type=str, help="e.g. [64,64,64,128] for U-TAE or [128,128,128,128,128] for UnCRtainTS")
+    parser.add_argument("--out_conv", default=f"[{S2_BANDS}]", help="output CONV, note: if inserting another layer then consider treating normalizations separately")
+    parser.add_argument("--mean_nonLinearity", dest="mean_nonLinearity", action="store_false", help="whether to apply a sigmoidal output nonlinearity to the mean prediction") 
+    parser.add_argument("--var_nonLinearity", default="softplus", type=str, help="how to squash the network's variance outputs [relu | softplus | elu ]")
+    parser.add_argument("--agg_mode", default="att_group", type=str, help="type of temporal aggregation in L-TAE module")
+    parser.add_argument("--encoder_norm", default="group", type=str, help="e.g. 'group' (when using many channels) or 'instance' (for few channels)")
+    parser.add_argument("--decoder_norm", default="batch", type=str, help="e.g. 'group' (when using many channels) or 'instance' (for few channels)")
+    parser.add_argument("--block_type", default="mbconv", type=str, help="type of CONV block to use [residual | mbconv]")
+    parser.add_argument("--padding_mode", default="reflect", type=str)
+    parser.add_argument("--pad_value", default=0, type=float)
+
+    # attention-specific parameters
+    parser.add_argument("--n_head", default=16, type=int, help="default value of 16, 4 for debugging")
+    parser.add_argument("--d_model", default=256, type=int, help="layers in L-TAE, default value of 256")
+    parser.add_argument("--positional_encoding", dest="positional_encoding", action="store_false", help="whether to use positional encoding or not") 
+    parser.add_argument("--d_k", default=4, type=int)
+    parser.add_argument("--low_res_size", default=32, type=int, help="resolution to downsample to")
+    parser.add_argument("--use_v", dest="use_v", action="store_true", help="whether to use values v or not")
+
+    # set-up parameters
+    parser.add_argument("--num_workers", default=0, type=int, help="Number of data loading workers")
+    parser.add_argument("--rdm_seed", default=1, type=int, help="Random seed")
+    parser.add_argument("--device",default="cuda",type=str,help="Name of device to use for tensor computations (cuda/cpu)",)
+    parser.add_argument("--display_step", default=10, type=int, help="Interval in batches between display of training metrics",)
+
+    # training parameters
+    parser.add_argument("--loss", default="MGNLL", type=str, help="Image reconstruction loss to utilize [l1|l2|GNLL|MGNLL].")
+    parser.add_argument("--resume_from", dest="resume_from", action="store_true", help="resume training acc. to JSON in --experiment_name and *.pth chckp in --trained_checkp")
+    parser.add_argument("--unfreeze_after", default=0, type=int, help="When to unfreeze ALL weights for training")
+    parser.add_argument("--epochs", default=20, type=int, help="Number of epochs to train")
+    parser.add_argument("--batch_size", default=4, type=int, help="Batch size")
+    parser.add_argument("--chunk_size", type=int, help="Size of vmap batches, this can be adjusted to accommodate for additional memory needs")
+    parser.add_argument("--lr", default=1e-2, type=float, help="Learning rate, e.g. 0.01")
+    parser.add_argument("--gamma", default=1.0, type=float, help="Learning rate decay parameter for scheduler")
+    parser.add_argument("--val_every", default=1, type=int, help="Interval in epochs between two validation steps.")
+    parser.add_argument("--val_after", default=0, type=int, help="Do validation only after that many epochs.")
+
+    # flags specific to SEN12MS-CR and SEN12MS-CR-TS
+    parser.add_argument("--use_sar", dest="use_sar", action="store_true", help="whether to use SAR or not")
+    parser.add_argument("--pretrain", dest="pretrain", action="store_true", help="whether to perform pretraining on SEN12MS-CR or training on SEN12MS-CR-TS") 
+    parser.add_argument("--input_t", default=3, type=int, help="number of input time points to sample, unet3d needs at least 4 time points")
+    parser.add_argument("--ref_date", default="2014-04-03", type=str, help="reference date for Sentinel observations")
+    parser.add_argument("--sample_type", default="cloudy_cloudfree", type=str, help="type of samples returned [cloudy_cloudfree | generic]")
+    parser.add_argument("--vary_samples", dest="vary_samples", action="store_false", help="whether to sample different time points across epochs or not") 
+    parser.add_argument("--min_cov", default=0.0, type=float, help="The minimum cloud coverage to accept per input sample at train time. Gets overwritten by --vary_samples")
+    parser.add_argument("--max_cov", default=1.0, type=float, help="The maximum cloud coverage to accept per input sample at train time. Gets overwritten by --vary_samples")
+    parser.add_argument("--root1", default='/home/data/SEN12MSCRTS', type=str, help="path to your copy of SEN12MS-CR-TS")
+    parser.add_argument("--root2", default='/home/data/SEN12MSCRTS', type=str, help="path to your copy of SEN12MS-CR-TS validation & test splits")
+    parser.add_argument("--root3", default='/home/data/SEN12MSCR', type=str, help="path to your copy of SEN12MS-CR for pretraining")
+    parser.add_argument("--precomputed", default='/home/code/UnCRtainTS/util/precomputed', type=str, help="path to pre-computed cloud statistics")
+    parser.add_argument("--region", default="all", type=str, help="region to (sub-)sample ROI from [all|africa|america|asiaEast|asiaWest|europa]")
+    parser.add_argument("--max_samples_count", default=int(1e9), type=int, help="count of data (sub-)samples to take")
+    parser.add_argument("--max_samples_frac", default=1.0, type=float, help="fraction of data (sub-)samples to take")
+    parser.add_argument("--profile", dest="profile", action="store_true", help="whether to profile code or not") 
+    parser.add_argument("--trained_checkp", default="", type=str, help="Path to loading a pre-trained network *.pth file, rather than initializing weights randomly")
+
+    # flags specific to uncertainty modeling
+    parser.add_argument("--covmode", default='diag', type=str, help="covariance matrix type [uni|iso|diag].")
+    parser.add_argument("--scale_by", default=1.0, type=float, help="rescale data within model, e.g. to [0,10]")
+    parser.add_argument("--separate_out", dest="separate_out", action="store_true", help="whether to separately process mean and variance predictions or in a shared layer")
+
+    # flags specific for testing
+    parser.add_argument("--weight_folder", type=str, default="./results", help="Path to the main folder containing the pre-trained weights")
+    parser.add_argument("--use_custom", dest="use_custom", action="store_true", help="whether to test on individually specified patches or not")
+    parser.add_argument("--load_config", default='', type=str, help="path of conf.json file to load")
+
+    return parser

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/conf.json

@@ -0,0 +1,74 @@
+{
+    "model": "uncrtaints",
+    "experiment_name": "diffcr_bs32_lr15e-4",
+    "res_dir": "./results",
+    "plot_every": -1,
+    "export_every": -1,
+    "resume_at": 0,
+    "encoder_widths": [
+        128
+    ],
+    "decoder_widths": [
+        128,
+        128,
+        128,
+        128,
+        128
+    ],
+    "out_conv": [
+        13
+    ],
+    "mean_nonLinearity": false,
+    "var_nonLinearity": "softplus",
+    "agg_mode": "att_group",
+    "encoder_norm": "group",
+    "decoder_norm": "batch",
+    "block_type": "mbconv",
+    "padding_mode": "reflect",
+    "pad_value": 0.0,
+    "n_head": 1,
+    "d_model": 256,
+    "positional_encoding": false,
+    "d_k": 4,
+    "low_res_size": 32,
+    "use_v": false,
+    "num_workers": 16,
+    "rdm_seed": 1,
+    "device": "cuda:0",
+    "display_step": 10,
+    "loss": "l2",
+    "resume_from": false,
+    "unfreeze_after": 0,
+    "epochs": 100,
+    "batch_size": 32,
+    "chunk_size": null,
+    "lr": 0.0005,
+    "gamma": 0.8,
+    "val_every": 1,
+    "val_after": 0,
+    "use_sar": true,
+    "pretrain": true,
+    "input_t": 1,
+    "ref_date": "2014-04-03",
+    "sample_type": "pretrain",
+    "vary_samples": false,
+    "min_cov": 0.0,
+    "max_cov": 1.0,
+    "root1": "/home/data/SEN12MSCRTS",
+    "root2": "/home/data/SEN12MSCRTS",
+    "root3": "data2/SEN12MSCR",
+    "precomputed": "/home/code/UnCRtainTS/util/precomputed",
+    "region": "all",
+    "max_samples_count": 1000000000,
+    "max_samples_frac": 1.0,
+    "profile": false,
+    "trained_checkp": "",
+    "covmode": "diag",
+    "scale_by": 10.0,
+    "separate_out": false,
+    "weight_folder": "./results",
+    "use_custom": false,
+    "load_config": "",
+    "pid": 2877152,
+    "N_params": 19322381
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/model.pth.tar

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

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/model_epoch_11.pth.tar

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

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/model_epoch_36.pth.tar

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

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_10_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.029363970156402505,
+    "MAE": 0.020022216210124334,
+    "PSNR": 31.572881788434003,
+    "SAM": 5.883645729394377,
+    "SSIM": 0.8995029243551826,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_11_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.028865320518000174,
+    "MAE": 0.019421607403492344,
+    "PSNR": 31.768579506695946,
+    "SAM": 5.820518317864266,
+    "SSIM": 0.9015902346229956,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_12_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.028450740317855727,
+    "MAE": 0.019143247260043655,
+    "PSNR": 31.91159520461337,
+    "SAM": 5.6859444906808125,
+    "SSIM": 0.9034519373110392,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_13_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.02858291424103222,
+    "MAE": 0.01927231159917463,
+    "PSNR": 31.870293692465435,
+    "SAM": 5.595422786736038,
+    "SSIM": 0.9039587730968367,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_14_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.028029547319395425,
+    "MAE": 0.018867645016614896,
+    "PSNR": 32.0631246642833,
+    "SAM": 5.500893342840581,
+    "SSIM": 0.9053583295002058,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_15_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.028002896943423252,
+    "MAE": 0.018806874698693236,
+    "PSNR": 32.124292399735644,
+    "SAM": 5.547215727374945,
+    "SSIM": 0.9059335617932202,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_16_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.027591812040673,
+    "MAE": 0.018454319715277293,
+    "PSNR": 32.246636826172086,
+    "SAM": 5.4618273344745045,
+    "SSIM": 0.9069541601278078,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_17_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.027644014190348384,
+    "MAE": 0.018551536467928936,
+    "PSNR": 32.24370574226725,
+    "SAM": 5.461317134667159,
+    "SSIM": 0.9069266391564054,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_18_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.027595730930196957,
+    "MAE": 0.018533841286411494,
+    "PSNR": 32.25086082007444,
+    "SAM": 5.458732208793296,
+    "SSIM": 0.9071483427338218,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_19_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.027390471058173046,
+    "MAE": 0.018348841181363623,
+    "PSNR": 32.342438679101114,
+    "SAM": 5.419562214702756,
+    "SSIM": 0.9077709371763801,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_1_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.044388687314263,
+    "MAE": 0.03238296521911765,
+    "PSNR": 27.6217471128898,
+    "SAM": 10.4182609624991,
+    "SSIM": 0.763119293530315,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_20_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.02744433999974496,
+    "MAE": 0.018402347492774685,
+    "PSNR": 32.3317267860638,
+    "SAM": 5.421831781584368,
+    "SSIM": 0.9078204176338086,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_21_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.02734196908368276,
+    "MAE": 0.018271456095607545,
+    "PSNR": 32.37505691355452,
+    "SAM": 5.414982792168764,
+    "SSIM": 0.9081676423451513,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_22_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.027245160590102936,
+    "MAE": 0.018224454178698474,
+    "PSNR": 32.41090423394659,
+    "SAM": 5.398054870446574,
+    "SSIM": 0.9083186444307726,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_23_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.02729571228139796,
+    "MAE": 0.01828788889602147,
+    "PSNR": 32.395462209747514,
+    "SAM": 5.393570169404665,
+    "SSIM": 0.9081527106459147,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_24_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.027244927966896305,
+    "MAE": 0.018264471261733865,
+    "PSNR": 32.41291005914153,
+    "SAM": 5.392408405063824,
+    "SSIM": 0.908316025697424,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_25_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.027284221707286997,
+    "MAE": 0.018280692685820887,
+    "PSNR": 32.40145441845609,
+    "SAM": 5.39122454551732,
+    "SSIM": 0.9083838710484244,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_26_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.02726639931698313,
+    "MAE": 0.01826652071185466,
+    "PSNR": 32.41051288700818,
+    "SAM": 5.3847173492672225,
+    "SSIM": 0.9083935374216957,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_27_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.027239437090096214,
+    "MAE": 0.018245351712652874,
+    "PSNR": 32.42091501759734,
+    "SAM": 5.386129859399605,
+    "SSIM": 0.9085140088899692,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_28_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.027215027071061892,
+    "MAE": 0.018221582465008372,
+    "PSNR": 32.42838631419994,
+    "SAM": 5.384088766455628,
+    "SSIM": 0.9085492332580157,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_29_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.027242751470667303,
+    "MAE": 0.01824946738290542,
+    "PSNR": 32.41849800725127,
+    "SAM": 5.381040883963731,
+    "SSIM": 0.9085034823882493,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_2_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.04118385424327889,
+    "MAE": 0.029236674496597642,
+    "PSNR": 28.28133535765438,
+    "SAM": 8.635967488469356,
+    "SSIM": 0.8477815685430351,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_30_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.027199031498741918,
+    "MAE": 0.01820931484350237,
+    "PSNR": 32.43442219682148,
+    "SAM": 5.381641721873335,
+    "SSIM": 0.9086828993640171,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_31_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.027213316269354252,
+    "MAE": 0.01822304026870589,
+    "PSNR": 32.43005099008614,
+    "SAM": 5.380723569767104,
+    "SSIM": 0.9086281500793518,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_32_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.027218542108819188,
+    "MAE": 0.01823459587795115,
+    "PSNR": 32.429575243876165,
+    "SAM": 5.380705763062456,
+    "SSIM": 0.9086230123762922,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_33_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.027201242979035374,
+    "MAE": 0.01821136096979529,
+    "PSNR": 32.4347129297312,
+    "SAM": 5.380752220457475,
+    "SSIM": 0.9086639188425286,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_34_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.02720954676425417,
+    "MAE": 0.01821668226351625,
+    "PSNR": 32.43351948486106,
+    "SAM": 5.378364858830772,
+    "SSIM": 0.9086556218518279,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_35_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.027196117778619137,
+    "MAE": 0.018208952186562502,
+    "PSNR": 32.43714808439791,
+    "SAM": 5.377404463051186,
+    "SSIM": 0.9086787752794829,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_36_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.027197365488975264,
+    "MAE": 0.018207441006122857,
+    "PSNR": 32.437294496043016,
+    "SAM": 5.378433104420995,
+    "SSIM": 0.908667840788918,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}

UnCRtainTS/model/results/diffcr_bs32_lr15e-4/test_epoch_3_metrics.json

@@ -0,0 +1,11 @@
+{
+    "RMSE": 0.03848631408196211,
+    "MAE": 0.02771346952286548,
+    "PSNR": 28.855159436197052,
+    "SAM": 7.957361651426766,
+    "SSIM": 0.8585438828465877,
+    "error": NaN,
+    "mean se": NaN,
+    "mean ae": NaN,
+    "mean var": NaN
+}