Update README.md

README.md

@@ -1,28 +1,33 @@
 ---
 license: cc-by-4.0
-pretty_name: SatClean-Bench
+pretty_name: "SatClean-Bench"
 task_categories:
-- image-to-image
+  - image-to-image
 tags:
-- remote-sensing
-- satellite
-- super-resolution
-- denoising
-- sentinel-2
-- benchmark
-- earth-observation
+  - remote-sensing
+  - satellite
+  - earth-observation
+  - sentinel-2
+  - image-restoration
+  - image-denoising
+  - super-resolution
+  - 3x-super-resolution
+  - benchmark
+  - computer-vision
+  - geospatial
 size_categories:
-- n<1K
+  - n<1K
 ---
-
 <div align="center">
 
 # SatClean-Bench
 
-**Fixed evaluation benchmark for joint denoising + 3× super-resolution of Sentinel-2 imagery**
+**A fixed, reproducible benchmark for joint denoising and 3× super-resolution of Sentinel-2 RGB imagery**
+
+SatClean-Bench evaluates whether an image-restoration model can recover a clean, high-resolution Sentinel-2 RGB image from a degraded, lower-resolution observation.
 
 [![GitHub](https://img.shields.io/badge/GitHub-Nora--Research--Lab-181717?logo=github)](https://github.com/Nora-Research-Lab)
-[![Hugging Face](https://img.shields.io/badge/HuggingFace-NoraResearchLab-FFD21E?logo=huggingface&logoColor=black)](https://huggingface.co/NoraResearchLab)
+[![Hugging Face](https://img.shields.io/badge/HuggingFace-NoraResearchLab-FFD21E?logo=huggingface\&logoColor=yellow)](https://huggingface.co/NoraResearchLab)
 [![LinkedIn](https://img.shields.io/badge/LinkedIn-NORA%20Research%20Lab-0A66C2?logo=linkedin)](https://www.linkedin.com/company/nora-research-lab)
 [![X](https://img.shields.io/badge/X-@noraresearchlab-000000?logo=x)](https://x.com/noraresearchlab)
 [![Website](https://img.shields.io/badge/Website-noraresearchlab.site-2ea44f)](https://noraresearchlab.site)
@@ -31,56 +36,534 @@ size_categories:
 
 ---
 
-## Task
+## Overview
+
+**SatClean-Bench** is a fixed evaluation benchmark designed to measure the performance of computer-vision models on **joint image denoising and 3× super-resolution** for Sentinel-2 RGB satellite imagery.
+
+The benchmark intentionally combines multiple degradation mechanisms rather than evaluating super-resolution or denoising in isolation. A model must therefore reconstruct spatial detail while simultaneously removing synthetic sensor and atmospheric artefacts.
+
+The benchmark is designed around a simple evaluation question:
+
+> **Given a degraded 30 m RGB observation, how accurately can a model reconstruct the corresponding clean 10 m RGB image?**
+
+Every benchmark sample has a corresponding clean high-resolution target. The degraded inputs are generated using a **locked degradation specification**, allowing different models to be evaluated under exactly the same conditions.
+
+SatClean-Bench is intended primarily for **model evaluation and comparison**, rather than as a general-purpose training dataset.
+
+---
+
+## Why this benchmark exists
+
+Satellite image restoration is frequently evaluated using isolated tasks such as super-resolution, denoising, or dehazing. Real-world Earth-observation imagery, however, can contain several degradation mechanisms simultaneously.
+
+SatClean-Bench therefore evaluates a more demanding restoration problem in which a model must address:
+
+* spatial resolution loss;
+* Gaussian sensor noise;
+* structured striping artefacts;
+* atmospheric haze;
+* quantisation effects;
+* and the interaction between degradation processes.
+
+The benchmark provides three predefined degradation levels, allowing researchers to measure how model performance changes as the restoration problem becomes more difficult.
+
+Because the degradation parameters and evaluation protocol are fixed, results from different models can be compared without changing the test distribution.
+
+---
+
+# Task
+
+## Input
+
+The input to the model is a degraded **30 m RGB image** with spatial dimensions:
+
+```text
+3 × 128 × 128
+```
+
+The three channels correspond to RGB.
+
+## Target
+
+The target is the corresponding clean **10 m RGB image**:
+
+```text
+384 × 384 × 3
+```
+
+The spatial scale factor is therefore:
+
+```text
+384 / 128 = 3×
+```
+
+The model must perform both:
+
+1. **Denoising/restoration** of the degraded observation.
+2. **3× spatial super-resolution** to recover the high-resolution target.
+
+This makes SatClean-Bench a **joint image-restoration benchmark**, rather than a conventional super-resolution benchmark in which the only degradation is spatial downsampling.
+
+---
+
+# Benchmark Degradation Levels
+
+SatClean-Bench provides three fixed degradation conditions.
+
+| Level       | Gaussian Noise σ | Striping | Haze | Difficulty |
+| ----------- | ---------------: | -------: | ---: | ---------- |
+| **Level 1** |            15 DN |     None | None | Mild       |
+| **Level 2** |            25 DN |     8 DN | None | Moderate   |
+| **Level 3** |            50 DN |     None | 0.35 | Severe     |
+
+Noise values are defined in the benchmark's 8-bit intensity domain.
+
+### Level 1 — Mild degradation
+
+Level 1 introduces moderate Gaussian noise while preserving the basic appearance of the underlying image.
+
+This level primarily evaluates whether a model can perform spatial reconstruction without substantially amplifying or preserving noise.
+
+### Level 2 — Structured degradation
+
+Level 2 introduces stronger Gaussian noise together with an 8 DN striping component.
+
+This tests whether a model can distinguish meaningful spatial structures from structured artefacts that may resemble real image content.
+
+### Level 3 — Severe degradation
+
+Level 3 introduces substantially stronger noise together with atmospheric haze.
+
+The haze component uses an airlight-blending factor of **0.35**, producing a more challenging reconstruction problem involving both image restoration and recovery of spatial detail under reduced contrast.
+
+---
+
+# Degradation Pipeline
+
+The benchmark generation process is deterministic and specified in:
+
+```text
+bench_spec.json
+```
+
+The conceptual pipeline is:
+
+```text
+Clean 10 m RGB image
+        ↓
+3× spatial downsampling
+        ↓
+Mild Gaussian PSF blur
+        ↓
+Optional atmospheric haze
+        ↓
+Additive Gaussian noise
+        ↓
+Optional row/column striping
+        ↓
+Clamping
+        ↓
+8-bit quantisation
+        ↓
+Degraded 30 m RGB input
+```
+
+More specifically:
+
+### 1. 3× spatial downsampling
+
+The original 10 m image is downsampled by a factor of three to produce the 30 m observation.
+
+The resulting spatial dimensions are:
+
+```text
+384 × 384 → 128 × 128
+```
+
+### 2. Gaussian PSF blur
+
+A mild Gaussian point-spread-function blur is applied before the final low-resolution observation is produced.
+
+The benchmark uses:
+
+```text
+σ = 0.5 px
+```
+
+This represents additional optical/sensor response smoothing during image formation.
+
+### 3. Optional haze
+
+For the applicable degradation level, a smooth airlight field is blended into the image.
+
+The haze parameter for Level 3 is:
+
+```text
+airlight blend = 0.35
+```
+
+### 4. Additive Gaussian noise
+
+Gaussian noise is added according to the predefined level-specific standard deviation.
+
+The noise is expressed in the benchmark's 8-bit DN/intensity domain.
+
+### 5. Optional striping
+
+Level 2 includes an 8 DN structured striping component.
+
+The striping is intended to introduce a non-independent image artefact that differs from ordinary pixel-wise Gaussian noise.
+
+### 6. Clamping and quantisation
+
+The resulting values are clamped to the valid image range and converted to 8-bit unsigned integer representation.
+
+The final benchmark inputs therefore use:
+
+```text
+dtype = uint8
+range = [0, 255]
+```
+
+All parameters required to reproduce the degradation process are recorded in `bench_spec.json`.
+
+---
+
+# Dataset Structure
+
+The benchmark contains **600 fixed evaluation scenes**.
+
+Each scene has one clean high-resolution target and three degraded versions corresponding to the three benchmark levels.
+
+| File              | Shape                | Data type | Description                                            |
+| ----------------- | -------------------- | --------- | ------------------------------------------------------ |
+| `test_hr.npy`     | `(600, 384, 384, 3)` | `uint8`   | Clean 10 m RGB reference images                        |
+| `level1_lr.npy`   | `(600, 3, 128, 128)` | `uint8`   | Level 1 degraded 30 m inputs                           |
+| `level2_lr.npy`   | `(600, 3, 128, 128)` | `uint8`   | Level 2 degraded 30 m inputs                           |
+| `level3_lr.npy`   | `(600, 3, 128, 128)` | `uint8`   | Level 3 degraded 30 m inputs                           |
+| `bench_spec.json` | —                    | JSON      | Benchmark specification and reproducibility parameters |
+
+The same 600 high-resolution targets are used across all three degradation levels.
+
+Consequently, a model can be evaluated under progressively different degradation conditions without changing the underlying geographic scenes.
+
+---
+
+# Tensor Conventions
+
+The high-resolution reference file uses:
+
+```text
+(N, H, W, C)
+```
+
+with:
+
+```text
+N = 600
+H = 384
+W = 384
+C = 3
+```
+
+The low-resolution files use:
+
+```text
+(N, C, H, W)
+```
+
+with:
+
+```text
+N = 600
+C = 3
+H = 128
+W = 128
+```
+
+Users should therefore account for the different channel ordering when loading the arrays.
+
+Example:
+
+```python
+import numpy as np
+
+hr = np.load("test_hr.npy")
+lr = np.load("level1_lr.npy")
+
+print(hr.shape)
+# (600, 384, 384, 3)
+
+print(lr.shape)
+# (600, 3, 128, 128)
+```
+
+---
+
+# Data Source
 
-Given a **noisy 30 m RGB** image, recover a **clean 10 m RGB** image.
+The clean high-resolution image patches are extracted from the publicly available:
 
-The benchmark supplies three fixed, reproducible degradation levels that cover (and exceed) typical atmospheric and sensor artefacts found in real Sentinel-2 data:
+**Major-TOM / Core-S2L2A**
 
-| Level | Noise σ (DN of 255) | Striping | Haze (airlight blend) | Description              |
-|-------|---------------------|----------|-----------------------|--------------------------|
-| 1     | 15                  | none     | none                  | mild noise               |
-| 2     | 25                  | 8 DN     | none                  | noise + striping         |
-| 3     | 50                  | none     | 0.35                  | heavy noise + haze       |
+dataset:
 
-**Degradation pipeline** (locked in `bench_spec.json`):
+https://huggingface.co/datasets/Major-TOM/Core-S2L2A
 
-1. 3× box downsample (10 m → 30 m)
-2. Mild Gaussian PSF blur (σ = 0.5 px)
-3. Optional haze (smooth airlight field)
-4. Additive Gaussian noise
-5. Optional row/column striping
-6. Clamp → 8-bit quantisation
+The source imagery is based on **Sentinel-2 Level-2A** observations at 10 m spatial resolution.
 
-## Files
+SatClean-Bench does not attempt to reproduce the complete Sentinel-2 acquisition process. Instead, it constructs a controlled restoration benchmark from high-resolution source imagery using a fixed synthetic degradation model.
 
-| File              | Shape                     | Role                          |
-|-------------------|---------------------------|-------------------------------|
-| `test_hr.npy`     | (600, 384, 384, 3) uint8  | Clean high-resolution targets |
-| `level1_lr.npy`   | (600, 3, 128, 128) uint8  | Degraded inputs – Level 1     |
-| `level2_lr.npy`   | (600, 3, 128, 128) uint8  | Degraded inputs – Level 2     |
-| `level3_lr.npy`   | (600, 3, 128, 128) uint8  | Degraded inputs – Level 3     |
-| `bench_spec.json` | —                         | Exact parameters, seed, metrics definition |
+This distinction is important: the benchmark measures performance under the specified degradation distribution and should not be interpreted as a complete simulation of every physical Sentinel-2 imaging artefact.
 
-## Metrics
+---
+
+# Radiometric Processing
+
+A tone transformation is applied to the source imagery before benchmark generation:
+
+```text
+clip(DN / 3000) ** 0.7
+```
+
+where `DN` represents the source digital-number/intensity value.
 
-All metrics are computed on the **uint8-quantised** RGB output:
+The resulting image is subsequently represented in the benchmark's 8-bit RGB space.
 
-- **PSNR** / **SSIM**
-- **LPIPS** (AlexNet backbone)
-- Optional efficiency: FLOPs on a 256×256 LR tile and tiled fp16 latency on 1024×1024 LR input
+The exact processing parameters should be taken from `bench_spec.json` when reproducing the benchmark.
 
-## Source data
+---
 
-High-resolution patches are extracted from the public
-[Major-TOM / Core-S2L2A](https://huggingface.co/datasets/Major-TOM/Core-S2L2A) dataset
-(Sentinel-2 Level-2A, 10 m).
+# Evaluation Protocol
 
-Tone curve applied: `clip(DN / 3000) ** 0.7`.
+Models should be evaluated independently on:
 
-## Citation
+```text
+Level 1
+Level 2
+Level 3
+```
 
-If you use SatClean-Bench please cite both the original Major-TOM paper and this benchmark:
+For each input image, the model produces a reconstructed 10 m RGB image.
+
+The output should correspond to:
+
+```text
+384 × 384 × 3
+```
+
+and should be evaluated against the matching image in:
+
+```text
+test_hr.npy
+```
+
+Evaluation is performed after converting the model output to the benchmark's **uint8 representation**.
+
+This is important because evaluation occurs in the same quantised image space used to define the benchmark targets.
+
+---
+
+# Primary Metrics
+
+SatClean-Bench reports three primary image-quality metrics.
+
+## PSNR
+
+**Peak Signal-to-Noise Ratio (PSNR)** measures pixel-level reconstruction fidelity.
+
+Higher PSNR indicates lower reconstruction error relative to the reference image.
+
+PSNR is particularly useful for measuring whether a restoration model accurately reproduces the target pixel values.
+
+## SSIM
+
+**Structural Similarity Index Measure (SSIM)** evaluates structural similarity between the reconstructed image and the reference.
+
+Unlike PSNR, SSIM is designed to capture perceptual changes in local image structure.
+
+Higher SSIM indicates greater structural similarity.
+
+## LPIPS
+
+**Learned Perceptual Image Patch Similarity (LPIPS)** measures deep feature-space similarity using an AlexNet-based feature representation.
+
+Lower LPIPS indicates greater perceptual similarity between the reconstructed image and the reference.
+
+Together, these metrics provide complementary measurements:
+
+| Metric | Measures                      | Preferred direction |
+| ------ | ----------------------------- | ------------------- |
+| PSNR   | Pixel-level fidelity          | Higher              |
+| SSIM   | Structural similarity         | Higher              |
+| LPIPS  | Learned perceptual similarity | Lower               |
+
+No single metric completely characterises satellite-image restoration quality. Reporting all three helps distinguish pixel fidelity from structural and perceptual reconstruction quality.
+
+---
+
+# Optional Efficiency Metrics
+
+SatClean-Bench can additionally be used to report computational efficiency.
+
+Recommended measurements include:
+
+### FLOPs
+
+Compute the approximate number of floating-point operations required for inference on a:
+
+```text
+256 × 256
+```
+
+low-resolution tile.
+
+### Inference latency
+
+Measure tiled FP16 inference latency for a:
+
+```text
+1024 × 1024
+```
+
+low-resolution input.
+
+When reporting latency, researchers should state the hardware, software framework, precision, batch size, and tiling configuration because these factors can substantially affect results.
+
+Efficiency measurements are supplementary and should not replace the image-quality metrics.
+
+---
+
+# Recommended Reporting Format
+
+For reproducible model comparisons, report results separately for every degradation level.
+
+| Model   | Level | PSNR ↑ | SSIM ↑ | LPIPS ↓ | FLOPs | Latency |
+| ------- | ----- | -----: | -----: | ------: | ----: | ------: |
+| Model A | 1     |      — |      — |       — |     — |       — |
+| Model A | 2     |      — |      — |       — |     — |       — |
+| Model A | 3     |      — |      — |       — |     — |       — |
+
+Researchers should not report only an aggregate score because the three levels represent different restoration conditions.
+
+Per-level results make it possible to determine whether a model's performance is stable as degradation becomes more severe.
+
+---
+
+# Reproducibility
+
+The benchmark is intended to be **fixed and reproducible**.
+
+The benchmark specification is stored in:
+
+```text
+bench_spec.json
+```
+
+This file contains the parameters necessary to reproduce the degradation procedure, including the relevant random seed and metric definitions.
+
+The benchmark therefore separates:
+
+**Benchmark generation**
+
+from:
+
+**Model evaluation**
+
+Researchers evaluating a model should use the released benchmark arrays rather than regenerating the test set with modified degradation parameters.
+
+This prevents differences in preprocessing or random degradation from becoming a source of variation between reported model results.
+
+---
+
+# Benchmark Design Principles
+
+SatClean-Bench follows several principles:
+
+**Fixed evaluation set.**
+The same 600 reference scenes are used for all models.
+
+**Multiple degradation regimes.**
+Models are tested under mild, structured, and severe degradation.
+
+**Joint restoration.**
+The task combines denoising and 3× super-resolution instead of treating them as independent problems.
+
+**Deterministic specification.**
+The degradation procedure is defined by a versioned benchmark specification.
+
+**Multiple evaluation dimensions.**
+PSNR, SSIM, and LPIPS capture different aspects of reconstruction quality.
+
+**Separation of training and evaluation.**
+SatClean-Bench is intended as a held-out evaluation benchmark rather than simply another training corpus.
+
+---
+
+# Intended Uses
+
+SatClean-Bench can be used for:
+
+* benchmarking satellite image-restoration architectures;
+* comparing CNN, Transformer, diffusion, and hybrid restoration models;
+* evaluating denoising + super-resolution pipelines;
+* testing lightweight Earth-observation models;
+* studying robustness to increasing degradation;
+* measuring the trade-off between reconstruction quality and computational cost;
+* establishing reproducible baselines for Sentinel-2 image restoration.
+
+The benchmark can also be used to evaluate models intended for downstream Earth-observation workflows where image quality affects subsequent computer-vision tasks.
+
+---
+
+# Out-of-Scope Uses and Limitations
+
+SatClean-Bench should not be interpreted as a complete representation of real Sentinel-2 image degradation.
+
+The benchmark uses controlled synthetic degradation. Real satellite imagery may contain additional effects including:
+
+* atmospheric variability;
+* cloud and cloud-shadow contamination;
+* spatially varying sensor effects;
+* radiometric calibration differences;
+* compression artefacts;
+* geometric misregistration;
+* temporal changes between observations;
+* surface reflectance variation;
+* sensor-specific noise characteristics;
+* spatially correlated degradation not represented by the benchmark.
+
+Consequently, strong performance on SatClean-Bench demonstrates performance on the **defined benchmark task**, but does not by itself establish equivalent performance on every real-world Sentinel-2 restoration scenario.
+
+For real-world deployment, benchmark results should therefore be complemented with evaluation on independent real satellite observations.
+
+---
+
+# Data Leakage and Evaluation Integrity
+
+Because SatClean-Bench is intended as a fixed evaluation benchmark, users should avoid training directly on the released test targets or their corresponding degraded inputs.
+
+For meaningful comparisons, benchmark samples should remain unseen during model training.
+
+If a model is trained using imagery derived from the same underlying source data, researchers should explicitly disclose this in their experiment description.
+
+---
+
+# License
+
+SatClean-Bench is released under:
+
+**CC BY 4.0**
+
+Users should also review the licensing and usage conditions of the underlying Major-TOM / Core-S2L2A source dataset before redistributing derived data or using the benchmark in a downstream project.
+
+---
+
+# Citation
+
+If you use SatClean-Bench in research, benchmarking, model development, or publications, please cite both the underlying Major-TOM dataset/paper and this benchmark.
+
+### Major TOM
 
 ```bibtex
 @inproceedings{Major_TOM,
@@ -94,18 +577,59 @@ If you use SatClean-Bench please cite both the original Major-TOM paper and this
 }
 ```
 
-## Maintainer
+### SatClean-Bench
+
+```bibtex
+@misc{satcleanbench2026,
+  title        = {SatClean-Bench: A Fixed Benchmark for Joint Denoising and 3x Super-Resolution of Sentinel-2 Imagery},
+  author       = {{NORA Research Lab}},
+  year         = {2026},
+  publisher    = {Hugging Face},
+  note         = {Benchmark dataset}
+}
+```
+
+---
+
+# Maintainer
 
 **NORA Research Lab**
 
+NORA Research Lab develops datasets, models, tools, and benchmarks for artificial intelligence applied to real-world scientific and Earth-observation problems.
+
 [![GitHub](https://img.shields.io/badge/GitHub-Nora--Research--Lab-181717?logo=github)](https://github.com/Nora-Research-Lab)
-[![Hugging Face](https://img.shields.io/badge/HuggingFace-NoraResearchLab-FFD21E?logo=huggingface&logoColor=black)](https://huggingface.co/NoraResearchLab)
+[![Hugging Face](https://img.shields.io/badge/HuggingFace-NoraResearchLab-FFD21E?logo=huggingface\&logoColor=black)](https://huggingface.co/NoraResearchLab)
 [![LinkedIn](https://img.shields.io/badge/LinkedIn-NORA%20Research%20Lab-0A66C2?logo=linkedin)](https://www.linkedin.com/company/nora-research-lab)
-[![X](https://img.shields.io/badge/X-@noraresearchlab-000000?logo=x)](https://x.com/noraresearchlab)
+[![X](https://img.shields.io/badge/X-@noraresearchlab-000000?logo=linkedin)](https://x.com/noraresearchlab)
+
+### Quick Links
 
-Quick links:
 [Website](https://noraresearchlab.site) ·
 [GitHub](https://github.com/Nora-Research-Lab) ·
 [Hugging Face](https://huggingface.co/NoraResearchLab) ·
 [LinkedIn](https://www.linkedin.com/company/nora-research-lab) ·
-[X](https://x.com/noraresearchlab)
+[X](https://x.com/noraresearchlab)
+
+---
+
+# Summary
+
+**SatClean-Bench** provides 600 fixed Sentinel-2 RGB evaluation scenes across three controlled degradation regimes.
+
+The benchmark asks models to transform:
+
+```text
+128 × 128 × 3
+30 m degraded RGB
+```
+
+into:
+
+```text
+384 × 384 × 3
+10 m clean RGB
+```
+
+while simultaneously addressing noise, spatial resolution loss, and selected structured/atmospheric artefacts.
+
+The fixed test set, locked degradation specification, and multi-metric evaluation protocol are intended to make SatClean-Bench a reproducible reference point for research on satellite image restoration.