Add GeoSET release files (189/211)

baselines/spacenet6/cbbdm/README.md

@@ -0,0 +1,42 @@
+# cBBDM · SpaceNet6
+
+cBBDM (GRSL'25) retrained by the GeoSET authors on the SpaceNet6 split. These are the weights behind
+the cBBDM row for SpaceNet6 in Table 3 of the GeoSET paper
+([arXiv:2609.37496](https://arxiv.org/abs/2609.37496)).
+
+- Method: Kim and Chung, "Conditional Brownian bridge diffusion model for VHR SAR to optical image translation", IEEE Geoscience and Remote Sensing Letters, 2025.
+- Implementation: [egshkim/ConditionalBBDM-for-VHR-SAR-to-Optical](https://github.com/egshkim/ConditionalBBDM-for-VHR-SAR-to-Optical) at commit `8ce15934f4d4e3f01efe70d11e2d9b9e0859210c`.
+- Training and inference code: [`baselines/cbbdm`](https://github.com/KAIST-VICLab/GeoSET/tree/main/baselines/cbbdm) in the GeoSET repository.
+
+## Files
+
+| File | Bytes | SHA-256 | Role |
+|---|---:|---|---|
+| `last_model.pth` | 2,118,345,622 | `4c6148b7e86c1764ddbdfaa655d6a84a2f663a1174d61a9107cc98af25836f0b` | cBBDM checkpoint (`model`, `ema`, `epoch`, `step`), including the vq-f4 autoencoder; test.sh samples with the EMA weights |
+
+## Results (GeoSET paper, Table 3)
+
+SpaceNet6 test split, 495 pairs, 256 × 256.
+
+| FID↓ | DISTS↓ | KID↓ | DINO↑ | LPIPS↓ | SSIM↑ | PSNR↑ |
+|---:|---:|---:|---:|---:|---:|---:|
+| 280.4 | 0.347 | 0.2620 | 0.450 | 0.419 | 0.447 | 19.72 |
+
+## Inference
+
+```bash
+git clone https://github.com/KAIST-VICLab/GeoSET && cd GeoSET
+export BASELINES_ROOT=/path/to/upstream_code DATA_ROOT=/path/to/data WORK_DIR=/path/to/work CKPT_ROOT=/path/to/checkpoints
+bash baselines/cbbdm/fetch.sh
+python scripts/datasets/build_spacenet6.py --data-root $DATA_ROOT
+python baselines/data/ldm_prepare.py spacenet6
+wget https://ommer-lab.com/files/latent-diffusion/vq-f4.zip && unzip vq-f4.zip -d $CKPT_ROOT/vq-f4
+hf download JeonghyeokDo/GeoSET "baselines/spacenet6/cbbdm/last_model.pth" --local-dir hf
+mkdir -p $CKPT_ROOT/cbbdm/spacenet6 && cp hf/baselines/spacenet6/cbbdm/* $CKPT_ROOT/cbbdm/spacenet6/
+bash baselines/cbbdm/test.sh spacenet6        # writes $WORK_DIR/results/cbbdm/spacenet6/<stem>.png
+python scripts/evaluate.py --dataset spacenet6 --pred-dir $WORK_DIR/results/cbbdm/spacenet6
+```
+
+## Licence
+
+These weights are released under the MIT licence of the cBBDM code (Copyright (c) 2025 egshkim, [LICENSE](https://github.com/egshkim/ConditionalBBDM-for-VHR-SAR-to-Optical/blob/8ce15934f4d4e3f01efe70d11e2d9b9e0859210c/LICENSE)). The checkpoint contains the weights of the CompVis latent-diffusion vq-f4 autoencoder, MIT licence, Copyright (c) 2022 Machine Vision and Learning Group, LMU Munich ([LICENSE](https://github.com/CompVis/latent-diffusion/blob/main/LICENSE)).

baselines/spacenet6/cbbdm/last_model.pth

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

baselines/spacenet6/conddiff/README.md

@@ -0,0 +1,40 @@
+# CondDiff · SpaceNet6
+
+CondDiff (GRSL'23) retrained by the GeoSET authors on the SpaceNet6 split. These are the weights behind
+the CondDiff row for SpaceNet6 in Table 3 of the GeoSET paper
+([arXiv:2609.37496](https://arxiv.org/abs/2609.37496)).
+
+- Method: Bai, Pu and Xu, "Conditional diffusion for SAR to optical image translation", GRSL 2023.
+- Implementation: [Coordi777/Conditional-Diffusion-for-SAR-to-Optical-Image-Translation](https://github.com/Coordi777/Conditional-Diffusion-for-SAR-to-Optical-Image-Translation) at commit `8326f54adf3a8d717792cb7abc7d3d2b7dfac565`.
+- Training and inference code: [`baselines/conddiff`](https://github.com/KAIST-VICLab/GeoSET/tree/main/baselines/conddiff) in the GeoSET repository.
+
+## Files
+
+| File | Bytes | SHA-256 | Role |
+|---|---:|---|---|
+| `ema_final.pt` | 657,495,287 | `7ba72b69057de1aaef89ce7aabd3adc358dd7f1123874952fbc29cf9e7bf5b66` | UNet EMA (0.9999) weights at step 50,000 (256 × 256 model) |
+
+## Results (GeoSET paper, Table 3)
+
+SpaceNet6 test split, 495 pairs, 256 × 256.
+
+| FID↓ | DISTS↓ | KID↓ | DINO↑ | LPIPS↓ | SSIM↑ | PSNR↑ |
+|---:|---:|---:|---:|---:|---:|---:|
+| 160.1 | 0.274 | 0.1012 | 0.514 | 0.517 | 0.198 | 14.68 |
+
+## Inference
+
+```bash
+git clone https://github.com/KAIST-VICLab/GeoSET && cd GeoSET
+export BASELINES_ROOT=/path/to/upstream_code DATA_ROOT=/path/to/data WORK_DIR=/path/to/work CKPT_ROOT=/path/to/checkpoints
+bash baselines/conddiff/fetch.sh
+python baselines/data/diff_data.py conddiff spacenet6
+hf download JeonghyeokDo/GeoSET --include "baselines/spacenet6/conddiff/*" --local-dir hf
+mkdir -p $CKPT_ROOT/conddiff/spacenet6 && cp hf/baselines/spacenet6/conddiff/ema_final.pt $CKPT_ROOT/conddiff/spacenet6/
+bash baselines/conddiff/test.sh spacenet6        # writes $WORK_DIR/results/conddiff/spacenet6/<stem>.png
+python scripts/evaluate.py --dataset spacenet6 --pred-dir $WORK_DIR/results/conddiff/spacenet6
+```
+
+## Licence
+
+The CondDiff repository contains no licence file; it is derived from [openai/guided-diffusion](https://github.com/openai/guided-diffusion) (MIT). These weights were trained by the GeoSET authors with that code; the GeoSET repository distributes only its changes to the code.

baselines/spacenet6/conddiff/ema_final.pt

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

baselines/spacenet6/controlnet/README.md

@@ -0,0 +1,41 @@
+# ControlNet · SpaceNet6
+
+ControlNet (ICCV'23) retrained by the GeoSET authors on the SpaceNet6 split. These are the weights behind
+the ControlNet row for SpaceNet6 in Table 3 of the GeoSET paper
+([arXiv:2609.37496](https://arxiv.org/abs/2609.37496)).
+
+- Method: Zhang, Rao and Agrawala, "Adding conditional control to text-to-image diffusion models", ICCV 2023.
+- Implementation: the diffusers ControlNet training example ([`examples/controlnet/train_controlnet.py`](https://github.com/huggingface/diffusers/blob/v0.37.0/examples/controlnet/train_controlnet.py), v0.37.0) on Stable Diffusion 2.1-base (`Manojb/stable-diffusion-2-1-base`, revision `0094d483a120f3f33dafbd187ea4aa60d10de75c`).
+- Training and inference code: [`baselines/controlnet`](https://github.com/KAIST-VICLab/GeoSET/tree/main/baselines/controlnet) in the GeoSET repository.
+
+## Files
+
+| File | Bytes | SHA-256 | Role |
+|---|---:|---|---|
+| `diffusion_pytorch_model.safetensors` | 1,456,953,560 | `39c14b3d5059b9380673b9c9341f0aa7774a36ad8d39419d0360e5ff76afeea4` | ControlNet weights (diffusers `ControlNetModel`, fp32) |
+| `config.json` | 1,293 | `911d4ffe1344ecfbb778a561186875c08ae2fc51a9f3a4c54a087363ef09b881` | ControlNet configuration |
+
+## Results (GeoSET paper, Table 3)
+
+SpaceNet6 test split, 495 pairs, 256 × 256.
+
+| FID↓ | DISTS↓ | KID↓ | DINO↑ | LPIPS↓ | SSIM↑ | PSNR↑ |
+|---:|---:|---:|---:|---:|---:|---:|
+| 131.3 | 0.279 | 0.0635 | 0.615 | 0.413 | 0.448 | 14.45 |
+
+## Inference
+
+```bash
+git clone https://github.com/KAIST-VICLab/GeoSET && cd GeoSET
+export BASELINES_ROOT=/path/to/upstream_code DATA_ROOT=/path/to/data WORK_DIR=/path/to/work CKPT_ROOT=/path/to/checkpoints
+python scripts/datasets/build_spacenet6.py --data-root $DATA_ROOT
+python baselines/data/ldm_prepare.py spacenet6
+hf download JeonghyeokDo/GeoSET "baselines/spacenet6/controlnet/diffusion_pytorch_model.safetensors" "baselines/spacenet6/controlnet/config.json" --local-dir hf
+mkdir -p $CKPT_ROOT/controlnet/spacenet6 && cp hf/baselines/spacenet6/controlnet/* $CKPT_ROOT/controlnet/spacenet6/
+bash baselines/controlnet/test.sh spacenet6        # writes $WORK_DIR/results/controlnet/spacenet6/<stem>.png
+python scripts/evaluate.py --dataset spacenet6 --pred-dir $WORK_DIR/results/controlnet/spacenet6
+```
+
+## Licence
+
+These weights are a derivative of Stable Diffusion 2.1-base and are released under the CreativeML Open RAIL++-M licence ([text](https://huggingface.co/stabilityai/stable-diffusion-2/blob/main/LICENSE-MODEL)); the use-based restrictions of its Attachment A apply to any use and redistribution. The training script is Apache-2.0 (diffusers).

baselines/spacenet6/controlnet/config.json

@@ -0,0 +1,56 @@
+{
+  "_class_name": "ControlNetModel",
+  "_diffusers_version": "0.37.1",
+  "act_fn": "silu",
+  "addition_embed_type": null,
+  "addition_embed_type_num_heads": 64,
+  "addition_time_embed_dim": null,
+  "attention_head_dim": [
+    5,
+    10,
+    20,
+    20
+  ],
+  "block_out_channels": [
+    320,
+    640,
+    1280,
+    1280
+  ],
+  "class_embed_type": null,
+  "conditioning_channels": 3,
+  "conditioning_embedding_out_channels": [
+    16,
+    32,
+    96,
+    256
+  ],
+  "controlnet_conditioning_channel_order": "rgb",
+  "cross_attention_dim": 1024,
+  "down_block_types": [
+    "CrossAttnDownBlock2D",
+    "CrossAttnDownBlock2D",
+    "CrossAttnDownBlock2D",
+    "DownBlock2D"
+  ],
+  "downsample_padding": 1,
+  "encoder_hid_dim": null,
+  "encoder_hid_dim_type": null,
+  "flip_sin_to_cos": true,
+  "freq_shift": 0,
+  "global_pool_conditions": false,
+  "in_channels": 4,
+  "layers_per_block": 2,
+  "mid_block_scale_factor": 1,
+  "mid_block_type": "UNetMidBlock2DCrossAttn",
+  "norm_eps": 1e-05,
+  "norm_num_groups": 32,
+  "num_attention_heads": null,
+  "num_class_embeds": null,
+  "only_cross_attention": false,
+  "projection_class_embeddings_input_dim": null,
+  "resnet_time_scale_shift": "default",
+  "transformer_layers_per_block": 1,
+  "upcast_attention": false,
+  "use_linear_projection": true
+}

baselines/spacenet6/controlnet/diffusion_pytorch_model.safetensors

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

baselines/spacenet6/cyclegan/README.md

@@ -0,0 +1,43 @@
+# CycleGAN · SpaceNet6
+
+CycleGAN (ICCV'17) retrained by the GeoSET authors on the SpaceNet6 split. These are the weights behind
+the CycleGAN row for SpaceNet6 in Table 3 of the GeoSET paper
+([arXiv:2609.37496](https://arxiv.org/abs/2609.37496)).
+
+- Method: Zhu, Park, Isola and Efros, "Unpaired image-to-image translation using cycle-consistent adversarial networks", ICCV 2017.
+- Implementation: [junyanz/pytorch-CycleGAN-and-pix2pix](https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix) at commit `2a7afba2895d52556dd5dfe07e8555ef657ced6f`.
+- Training and inference code: [`baselines/cyclegan`](https://github.com/KAIST-VICLab/GeoSET/tree/main/baselines/cyclegan) in the GeoSET repository.
+
+## Files
+
+| File | Bytes | SHA-256 | Role |
+|---|---:|---|---|
+| `net_G_A.pth` | 45,533,133 | `580135302c8bfa73b258f37c3194c5ab4a3bbe2b26c25bdd17cb77506f6e99a2` | Generator G_A (`resnet_9blocks`), SAR → EO; produces the output image |
+| `net_G_B.pth` | 45,533,133 | `bdd465d9502581b9181d0a8f6f8dd7ddda35e549815b6c8dba147f525a917aa3` | Generator G_B (`resnet_9blocks`), EO → SAR; loaded by the upstream test script |
+
+## Results (GeoSET paper, Table 3)
+
+SpaceNet6 test split, 495 pairs, 256 × 256.
+
+| FID↓ | DISTS↓ | KID↓ | DINO↑ | LPIPS↓ | SSIM↑ | PSNR↑ |
+|---:|---:|---:|---:|---:|---:|---:|
+| 119.3 | 0.219 | 0.0436 | 0.660 | 0.373 | 0.478 | 16.88 |
+
+## Inference
+
+```bash
+git clone https://github.com/KAIST-VICLab/GeoSET && cd GeoSET
+export BASELINES_ROOT=/path/to/upstream_code DATA_ROOT=/path/to/data WORK_DIR=/path/to/work CKPT_ROOT=/path/to/checkpoints
+bash baselines/cyclegan/fetch.sh
+bash baselines/pix2pix/fetch.sh            # combine_A_and_B.py, used by gan_prepare.py
+python scripts/datasets/build_spacenet6.py --data-root $DATA_ROOT
+python baselines/data/gan_prepare.py spacenet6
+hf download JeonghyeokDo/GeoSET --include "baselines/spacenet6/cyclegan/*.pth" --local-dir hf
+mkdir -p $CKPT_ROOT/cyclegan/spacenet6 && cp hf/baselines/spacenet6/cyclegan/*.pth $CKPT_ROOT/cyclegan/spacenet6/
+bash baselines/cyclegan/test.sh spacenet6        # writes $WORK_DIR/results/cyclegan/spacenet6/<stem>.png
+python scripts/evaluate.py --dataset spacenet6 --pred-dir $WORK_DIR/results/cyclegan/spacenet6
+```
+
+## Licence
+
+These weights were trained with the pytorch-CycleGAN-and-pix2pix code and are released under its BSD licence (Copyright (c) 2017 Jun-Yan Zhu and Taesung Park; Copyright (c) 2016 Phillip Isola and Jun-Yan Zhu; [LICENSE](https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix/blob/2a7afba2895d52556dd5dfe07e8555ef657ced6f/LICENSE)). The GeoSET repository states its change to the code (`baselines/cyclegan`).

baselines/spacenet6/cyclegan/net_G_A.pth

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

baselines/spacenet6/cyclegan/net_G_B.pth

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

baselines/spacenet6/ddpm-sr3/README.md

@@ -0,0 +1,40 @@
+# DDPM (SR3) · SpaceNet6
+
+DDPM (SR3) (TPAMI'22) retrained by the GeoSET authors on the SpaceNet6 split. These are the weights behind
+the DDPM (SR3) row for SpaceNet6 in Table 3 of the GeoSET paper
+([arXiv:2609.37496](https://arxiv.org/abs/2609.37496)).
+
+- Method: Saharia, Ho, Chan, Salimans, Fleet and Norouzi, "Image super-resolution via iterative refinement", TPAMI 2022.
+- Implementation: stage 1 (conditional DDPM) of [DeepSARRS/E3Diff](https://github.com/DeepSARRS/E3Diff) at commit `38601093ab8f8e4b478144621f20890b100a3b74`.
+- Training and inference code: [`baselines/ddpm-sr3`](https://github.com/KAIST-VICLab/GeoSET/tree/main/baselines/ddpm-sr3) in the GeoSET repository.
+
+## Files
+
+| File | Bytes | SHA-256 | Role |
+|---|---:|---|---|
+| `gen.pth` | 768,427,299 | `204f19caaa3efb59cd4d351a2792a6671bdb40f3400eae39aa6ee006fd203db6` | Conditional DDPM UNet (E3Diff stage 1), state dict at iteration 250,000; 3-channel output, [SAR-PPB, SAR-canny, SAR] condition |
+
+## Results (GeoSET paper, Table 3)
+
+SpaceNet6 test split, 495 pairs, 256 × 256.
+
+| FID↓ | DISTS↓ | KID↓ | DINO↑ | LPIPS↓ | SSIM↑ | PSNR↑ |
+|---:|---:|---:|---:|---:|---:|---:|
+| 219.1 | 0.333 | 0.1616 | 0.419 | 0.622 | 0.111 | 12.45 |
+
+## Inference
+
+```bash
+git clone https://github.com/KAIST-VICLab/GeoSET && cd GeoSET
+export BASELINES_ROOT=/path/to/upstream_code DATA_ROOT=/path/to/data WORK_DIR=/path/to/work CKPT_ROOT=/path/to/checkpoints
+bash baselines/ddpm-sr3/fetch.sh
+python baselines/data/diff_data.py e3diff spacenet6
+hf download JeonghyeokDo/GeoSET --include "baselines/spacenet6/ddpm-sr3/*" --local-dir hf
+mkdir -p $CKPT_ROOT/ddpm-sr3/spacenet6 && cp hf/baselines/spacenet6/ddpm-sr3/gen.pth $CKPT_ROOT/ddpm-sr3/spacenet6/
+bash baselines/ddpm-sr3/test.sh spacenet6        # writes $WORK_DIR/results/ddpm-sr3/spacenet6/<stem>.png
+python scripts/evaluate.py --dataset spacenet6 --pred-dir $WORK_DIR/results/ddpm-sr3/spacenet6
+```
+
+## Licence
+
+The E3Diff repository contains no licence file (its bundled `SoftPool/` directory is MIT). These weights were trained by the GeoSET authors with that code; the GeoSET repository distributes only its changes to the code.

baselines/spacenet6/ddpm-sr3/gen.pth

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

baselines/spacenet6/e3diff/README.md

@@ -0,0 +1,41 @@
+# E3Diff · SpaceNet6
+
+E3Diff (GRSL'24) retrained by the GeoSET authors on the SpaceNet6 split. These are the weights behind
+the E3Diff row for SpaceNet6 in Table 3 of the GeoSET paper
+([arXiv:2609.37496](https://arxiv.org/abs/2609.37496)).
+
+- Method: Qin, Zou, Li and Zhang, "Efficient end-to-end diffusion model for one-step SAR-to-optical translation", GRSL 2024.
+- Implementation: [DeepSARRS/E3Diff](https://github.com/DeepSARRS/E3Diff) at commit `38601093ab8f8e4b478144621f20890b100a3b74` (stage 2, initialised from the DDPM (SR3) stage-1 weights).
+- Training and inference code: [`baselines/e3diff`](https://github.com/KAIST-VICLab/GeoSET/tree/main/baselines/e3diff) in the GeoSET repository.
+
+## Files
+
+| File | Bytes | SHA-256 | Role |
+|---|---:|---|---|
+| `gen.pth` | 768,427,299 | `53786dd3255871070effc0353ffefffa3339ab3ebacccbde3f9d5ed04fef542c` | One-step generator UNet (E3Diff stage 2), state dict at iteration 310,000; 3-channel output, [SAR-PPB, SAR-canny, SAR] condition |
+
+## Results (GeoSET paper, Table 3)
+
+SpaceNet6 test split, 495 pairs, 256 × 256.
+
+| FID↓ | DISTS↓ | KID↓ | DINO↑ | LPIPS↓ | SSIM↑ | PSNR↑ |
+|---:|---:|---:|---:|---:|---:|---:|
+| 110.6 | 0.197 | 0.0440 | 0.696 | 0.361 | 0.462 | 18.32 |
+
+## Inference
+
+```bash
+git clone https://github.com/KAIST-VICLab/GeoSET && cd GeoSET
+export BASELINES_ROOT=/path/to/upstream_code DATA_ROOT=/path/to/data WORK_DIR=/path/to/work CKPT_ROOT=/path/to/checkpoints
+bash baselines/e3diff/fetch.sh
+# vision-aided-loss (CLIP discriminator, built by the model): see baselines/e3diff/README.md
+python baselines/data/diff_data.py e3diff spacenet6
+hf download JeonghyeokDo/GeoSET --include "baselines/spacenet6/e3diff/*" --local-dir hf
+mkdir -p $CKPT_ROOT/e3diff/spacenet6 && cp hf/baselines/spacenet6/e3diff/gen.pth $CKPT_ROOT/e3diff/spacenet6/
+bash baselines/e3diff/test.sh spacenet6        # writes $WORK_DIR/results/e3diff/spacenet6/<stem>.png
+python scripts/evaluate.py --dataset spacenet6 --pred-dir $WORK_DIR/results/e3diff/spacenet6
+```
+
+## Licence
+
+The E3Diff repository contains no licence file (its bundled `SoftPool/` directory is MIT). These weights were trained by the GeoSET authors with that code; the GeoSET repository distributes only its changes to the code.

baselines/spacenet6/e3diff/gen.pth

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

baselines/spacenet6/hi-diff/README.md

@@ -0,0 +1,44 @@
+# HI-Diff · SpaceNet6
+
+HI-Diff (NeurIPS'23) retrained by the GeoSET authors on the SpaceNet6 split. These are the weights behind
+the HI-Diff row for SpaceNet6 in Table 3 of the GeoSET paper
+([arXiv:2609.37496](https://arxiv.org/abs/2609.37496)).
+
+- Method: Chen, Zhang, Liu, Gu, Kong, Yuan et al., "Hierarchical integration diffusion model for realistic image deblurring", NeurIPS 2023.
+- Implementation: [zhengchen1999/HI-Diff](https://github.com/zhengchen1999/HI-Diff) at commit `b3bfd167997e27f8edd57681cf70e5031a0e35f2`.
+- Training and inference code: [`baselines/hi-diff`](https://github.com/KAIST-VICLab/GeoSET/tree/main/baselines/hi-diff) in the GeoSET repository.
+
+## Files
+
+| File | Bytes | SHA-256 | Role |
+|---|---:|---|---|
+| `S1_net_g_latest.pth` | 101,401,457 | `7e5b2546e43ed2ab3b6543733ffc7bec2ec74fbdc43f150a134527ac4c8aef71` | Stage-1 Transformer restorer (iteration 25,000) |
+| `S1_net_le_latest.pth` | 2,357,509 | `b2ea2d2c8df523aac1220377dc05bf62655963842c4098fa13adc6eac0205993` | Stage-1 latent encoder, SAR + EO input (iteration 25,000) |
+| `S2_net_g_latest.pth` | 101,401,457 | `8de9e57dc6e2a8c6c7299e846d0021eebcb1090ce162e023c8e804aa6f42b0c0` | Stage-2 Transformer restorer (iteration 25,000); used by test.sh |
+| `S2_net_le_dm_latest.pth` | 2,247,061 | `b8ed232b742fcbb4eb836b1185b9947d65781a87afa9a627b412553ea028773a` | Stage-2 latent encoder, SAR input (iteration 25,000); used by test.sh |
+| `S2_net_d_latest.pth` | 10,530,491 | `6fb28955d58f72a71f9d4e7da7049d12430749340dd7d6fb7847cdcdea4e6878` | Stage-2 latent denoising network (iteration 25,000); used by test.sh |
+
+## Results (GeoSET paper, Table 3)
+
+SpaceNet6 test split, 495 pairs, 256 × 256.
+
+| FID↓ | DISTS↓ | KID↓ | DINO↑ | LPIPS↓ | SSIM↑ | PSNR↑ |
+|---:|---:|---:|---:|---:|---:|---:|
+| 261.2 | 0.300 | 0.2036 | 0.499 | 0.403 | 0.589 | 20.61 |
+
+## Inference
+
+```bash
+git clone https://github.com/KAIST-VICLab/GeoSET && cd GeoSET
+export BASELINES_ROOT=/path/to/upstream_code DATA_ROOT=/path/to/data WORK_DIR=/path/to/work CKPT_ROOT=/path/to/checkpoints
+bash baselines/hi-diff/fetch.sh
+python baselines/data/diff_data.py paired spacenet6
+hf download JeonghyeokDo/GeoSET --include "baselines/spacenet6/hi-diff/*" --local-dir hf
+mkdir -p $CKPT_ROOT/hi-diff/spacenet6 && cp hf/baselines/spacenet6/hi-diff/*.pth $CKPT_ROOT/hi-diff/spacenet6/
+bash baselines/hi-diff/test.sh spacenet6        # writes $WORK_DIR/results/hi-diff/spacenet6/<stem>.png
+python scripts/evaluate.py --dataset spacenet6 --pred-dir $WORK_DIR/results/hi-diff/spacenet6
+```
+
+## Licence
+
+These weights were trained with the HI-Diff code and are released under its [Apache-2.0](https://github.com/zhengchen1999/HI-Diff/blob/b3bfd167997e27f8edd57681cf70e5031a0e35f2/LICENSE) licence; the GeoSET repository states its modifications to the code (`baselines/hi-diff`).

baselines/spacenet6/hi-diff/S1_net_g_latest.pth

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

baselines/spacenet6/hi-diff/S1_net_le_latest.pth

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

baselines/spacenet6/hi-diff/S2_net_d_latest.pth

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

baselines/spacenet6/hi-diff/S2_net_g_latest.pth

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

baselines/spacenet6/hi-diff/S2_net_le_dm_latest.pth

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

baselines/spacenet6/pix2pix/README.md

@@ -0,0 +1,41 @@
+# pix2pix · SpaceNet6
+
+pix2pix (CVPR'17) retrained by the GeoSET authors on the SpaceNet6 split. These are the weights behind
+the pix2pix row for SpaceNet6 in Table 3 of the GeoSET paper
+([arXiv:2609.37496](https://arxiv.org/abs/2609.37496)).
+
+- Method: Isola, Zhu, Zhou and Efros, "Image-to-image translation with conditional adversarial networks", CVPR 2017.
+- Implementation: [junyanz/pytorch-CycleGAN-and-pix2pix](https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix) at commit `2a7afba2895d52556dd5dfe07e8555ef657ced6f`.
+- Training and inference code: [`baselines/pix2pix`](https://github.com/KAIST-VICLab/GeoSET/tree/main/baselines/pix2pix) in the GeoSET repository.
+
+## Files
+
+| File | Bytes | SHA-256 | Role |
+|---|---:|---|---|
+| `net_G.pth` | 217,728,293 | `a9a8c502b453643b26f5718ece86d27a7af503adce5d0e85cb694adbd4aeaf26` | U-Net generator (`unet_256`), SAR → EO; used by test.sh |
+
+## Results (GeoSET paper, Table 3)
+
+SpaceNet6 test split, 495 pairs, 256 × 256.
+
+| FID↓ | DISTS↓ | KID↓ | DINO↑ | LPIPS↓ | SSIM↑ | PSNR↑ |
+|---:|---:|---:|---:|---:|---:|---:|
+| 166.7 | 0.242 | 0.1091 | 0.589 | 0.419 | 0.459 | 17.07 |
+
+## Inference
+
+```bash
+git clone https://github.com/KAIST-VICLab/GeoSET && cd GeoSET
+export BASELINES_ROOT=/path/to/upstream_code DATA_ROOT=/path/to/data WORK_DIR=/path/to/work CKPT_ROOT=/path/to/checkpoints
+bash baselines/pix2pix/fetch.sh
+python scripts/datasets/build_spacenet6.py --data-root $DATA_ROOT
+python baselines/data/gan_prepare.py spacenet6
+hf download JeonghyeokDo/GeoSET --include "baselines/spacenet6/pix2pix/*.pth" --local-dir hf
+mkdir -p $CKPT_ROOT/pix2pix/spacenet6 && cp hf/baselines/spacenet6/pix2pix/*.pth $CKPT_ROOT/pix2pix/spacenet6/
+bash baselines/pix2pix/test.sh spacenet6        # writes $WORK_DIR/results/pix2pix/spacenet6/<stem>.png
+python scripts/evaluate.py --dataset spacenet6 --pred-dir $WORK_DIR/results/pix2pix/spacenet6
+```
+
+## Licence
+
+These weights were trained with the pytorch-CycleGAN-and-pix2pix code and are released under its BSD licence (Copyright (c) 2017 Jun-Yan Zhu and Taesung Park; Copyright (c) 2016 Phillip Isola and Jun-Yan Zhu; [LICENSE](https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix/blob/2a7afba2895d52556dd5dfe07e8555ef657ced6f/LICENSE)). The GeoSET repository states its change to the code (`baselines/pix2pix`).

baselines/spacenet6/pix2pix/net_G.pth

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

baselines/spacenet6/pix2pixhd/README.md

@@ -0,0 +1,42 @@
+# pix2pixHD · SpaceNet6
+
+pix2pixHD (CVPR'18) retrained by the GeoSET authors on the SpaceNet6 split. These are the weights behind
+the pix2pixHD row for SpaceNet6 in Table 3 of the GeoSET paper
+([arXiv:2609.37496](https://arxiv.org/abs/2609.37496)).
+
+- Method: Wang, Liu, Zhu, Tao, Kautz and Catanzaro, "High-resolution image synthesis and semantic manipulation with conditional GANs", CVPR 2018.
+- Implementation: [NVIDIA/pix2pixHD](https://github.com/NVIDIA/pix2pixHD) at commit `14b3b3c7fff413086e3b58df52096f16b6891172`.
+- Training and inference code: [`baselines/pix2pixhd`](https://github.com/KAIST-VICLab/GeoSET/tree/main/baselines/pix2pixhd) in the GeoSET repository.
+
+## Files
+
+| File | Bytes | SHA-256 | Role |
+|---|---:|---|---|
+| `net_G.pth` | 729,795,505 | `1f32e16f7468b5fe285645926b75e6730bbb5068cd2d7f3e5b840a0931df5eca` | Global generator (4 downsampling layers, 9 residual blocks), SAR → EO; used by test.sh |
+
+## Results (GeoSET paper, Table 3)
+
+SpaceNet6 test split, 495 pairs, 256 × 256.
+
+| FID↓ | DISTS↓ | KID↓ | DINO↑ | LPIPS↓ | SSIM↑ | PSNR↑ |
+|---:|---:|---:|---:|---:|---:|---:|
+| 175.1 | 0.246 | 0.1136 | 0.682 | 0.361 | 0.525 | 19.21 |
+
+## Inference
+
+```bash
+git clone https://github.com/KAIST-VICLab/GeoSET && cd GeoSET
+export BASELINES_ROOT=/path/to/upstream_code DATA_ROOT=/path/to/data WORK_DIR=/path/to/work CKPT_ROOT=/path/to/checkpoints
+bash baselines/pix2pixhd/fetch.sh
+bash baselines/pix2pix/fetch.sh            # combine_A_and_B.py, used by gan_prepare.py
+python scripts/datasets/build_spacenet6.py --data-root $DATA_ROOT
+python baselines/data/gan_prepare.py spacenet6
+hf download JeonghyeokDo/GeoSET --include "baselines/spacenet6/pix2pixhd/*.pth" --local-dir hf
+mkdir -p $CKPT_ROOT/pix2pixhd/spacenet6 && cp hf/baselines/spacenet6/pix2pixhd/*.pth $CKPT_ROOT/pix2pixhd/spacenet6/
+bash baselines/pix2pixhd/test.sh spacenet6        # writes $WORK_DIR/results/pix2pixhd/spacenet6/<stem>.png
+python scripts/evaluate.py --dataset spacenet6 --pred-dir $WORK_DIR/results/pix2pixhd/spacenet6
+```
+
+## Licence
+
+These weights were trained with the pix2pixHD code and are released under its BSD licence (Copyright (C) 2019 NVIDIA Corporation, Ting-Chun Wang, Ming-Yu Liu, Jun-Yan Zhu; [LICENSE.txt](https://github.com/NVIDIA/pix2pixHD/blob/14b3b3c7fff413086e3b58df52096f16b6891172/LICENSE.txt)). The GeoSET repository states its changes to the code (`baselines/pix2pixhd`).

baselines/spacenet6/pix2pixhd/net_G.pth

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

baselines/spacenet6/resshift/README.md

@@ -0,0 +1,40 @@
+# ResShift · SpaceNet6
+
+ResShift (NeurIPS'23) retrained by the GeoSET authors on the SpaceNet6 split. These are the weights behind
+the ResShift row for SpaceNet6 in Table 3 of the GeoSET paper
+([arXiv:2609.37496](https://arxiv.org/abs/2609.37496)).
+
+- Method: Yue, Wang and Loy, "ResShift: Efficient diffusion model for image super-resolution by residual shifting", NeurIPS 2023.
+- Implementation: [zsyOAOA/ResShift](https://github.com/zsyOAOA/ResShift) at commit `bb03b7d21614cace01787e097c8a6ab6b945227d`.
+- Training and inference code: [`baselines/resshift`](https://github.com/KAIST-VICLab/GeoSET/tree/main/baselines/resshift) in the GeoSET repository.
+
+## Files
+
+| File | Bytes | SHA-256 | Role |
+|---|---:|---|---|
+| `ema_model.pth` | 478,392,663 | `a5c3d1b910970efd770bee33e76d6ab0e308df9d721a2c1f2174cd89e56e904d` | UNetModelSwin EMA (0.999) weights at iteration 50,000; used with the ResShift VQ-f4 autoencoder, which `baselines/resshift/fetch.sh` downloads |
+
+## Results (GeoSET paper, Table 3)
+
+SpaceNet6 test split, 495 pairs, 256 × 256.
+
+| FID↓ | DISTS↓ | KID↓ | DINO↑ | LPIPS↓ | SSIM↑ | PSNR↑ |
+|---:|---:|---:|---:|---:|---:|---:|
+| 155.4 | 0.230 | 0.0858 | 0.540 | 0.367 | 0.421 | 18.58 |
+
+## Inference
+
+```bash
+git clone https://github.com/KAIST-VICLab/GeoSET && cd GeoSET
+export BASELINES_ROOT=/path/to/upstream_code DATA_ROOT=/path/to/data WORK_DIR=/path/to/work CKPT_ROOT=/path/to/checkpoints
+bash baselines/resshift/fetch.sh
+python baselines/data/diff_data.py paired spacenet6
+hf download JeonghyeokDo/GeoSET --include "baselines/spacenet6/resshift/*" --local-dir hf
+mkdir -p $CKPT_ROOT/resshift/spacenet6 && cp hf/baselines/spacenet6/resshift/ema_model.pth $CKPT_ROOT/resshift/spacenet6/
+bash baselines/resshift/test.sh spacenet6        # writes $WORK_DIR/results/resshift/spacenet6/<stem>.png
+python scripts/evaluate.py --dataset spacenet6 --pred-dir $WORK_DIR/results/resshift/spacenet6
+```
+
+## Licence
+
+These weights were trained with the ResShift code and are released under its [S-Lab License 1.0](https://github.com/zsyOAOA/ResShift/blob/bb03b7d21614cace01787e097c8a6ab6b945227d/LICENSE) (Copyright 2022 S-Lab): non-commercial use only. The VQ-f4 autoencoder used at inference is part of the ResShift v2.0 release and is not included here.

baselines/spacenet6/resshift/ema_model.pth

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

baselines/spacenet6/sd21-ft/README.md

@@ -0,0 +1,42 @@
+# SD2.1 FT · SpaceNet6
+
+SD2.1 FT (CVPR'22) retrained by the GeoSET authors on the SpaceNet6 split. These are the weights behind
+the SD2.1 FT row for SpaceNet6 in Table 3 of the GeoSET paper
+([arXiv:2609.37496](https://arxiv.org/abs/2609.37496)).
+
+- Method: Rombach, Blattmann, Lorenz, Esser and Ommer, "High-resolution image synthesis with latent diffusion models", CVPR 2022.
+- Implementation: Stable Diffusion 2.1-base (`Manojb/stable-diffusion-2-1-base`, revision `0094d483a120f3f33dafbd187ea4aa60d10de75c`), fine-tuned with the stage-1 scripts that `baselines/sd21-ft/sd21-ft.patch` adds to [KAIST-VICLab/C-DiffSET](https://github.com/KAIST-VICLab/C-DiffSET) at commit `6fc380215ae97c9d134e8f1434061b652339b45c`.
+- Training and inference code: [`baselines/sd21-ft`](https://github.com/KAIST-VICLab/GeoSET/tree/main/baselines/sd21-ft) in the GeoSET repository.
+
+## Files
+
+| File | Bytes | SHA-256 | Role |
+|---|---:|---|---|
+| `diffusion_pytorch_model.safetensors` | 3,463,772,592 | `93c99b5bf5cefb5df57a403f9691b3b50a138d6a41b1d4726f64035ddf8c5fd4` | UNet weights (diffusers `UNet2DConditionModel`, fp32); input = SAR latent and noisy EO latent (8 channels), output = noise (4 channels) |
+| `config.json` | 911 | `4ea373ed4a09313343a02c2ebb22a839cca967e7e97a9dd281f68b7d0fbee7c3` | UNet configuration |
+
+## Results (GeoSET paper, Table 3)
+
+SpaceNet6 test split, 495 pairs, 256 × 256.
+
+| FID↓ | DISTS↓ | KID↓ | DINO↑ | LPIPS↓ | SSIM↑ | PSNR↑ |
+|---:|---:|---:|---:|---:|---:|---:|
+| 124.7 | 0.196 | 0.0537 | 0.612 | 0.348 | 0.513 | 19.29 |
+
+## Inference
+
+```bash
+git clone https://github.com/KAIST-VICLab/GeoSET && cd GeoSET
+export BASELINES_ROOT=/path/to/upstream_code DATA_ROOT=/path/to/data WORK_DIR=/path/to/work CKPT_ROOT=/path/to/checkpoints
+bash baselines/sd21-ft/fetch.sh
+python scripts/datasets/build_spacenet6.py --data-root $DATA_ROOT
+python baselines/data/ldm_prepare.py spacenet6
+hf download JeonghyeokDo/GeoSET "baselines/spacenet6/sd21-ft/diffusion_pytorch_model.safetensors" "baselines/spacenet6/sd21-ft/config.json" --local-dir hf
+mkdir -p $CKPT_ROOT/sd21-ft/spacenet6 && cp hf/baselines/spacenet6/sd21-ft/* $CKPT_ROOT/sd21-ft/spacenet6/
+bash baselines/sd21-ft/test.sh spacenet6        # writes $WORK_DIR/results/sd21-ft/spacenet6/<stem>.png
+python scripts/evaluate.py --dataset spacenet6 --pred-dir $WORK_DIR/results/sd21-ft/spacenet6
+```
+
+## Licence
+
+These weights are a derivative of Stable Diffusion 2.1-base and are released under the CreativeML Open RAIL++-M licence ([text](https://huggingface.co/stabilityai/stable-diffusion-2/blob/main/LICENSE-MODEL)); the use-based restrictions of its Attachment A apply to any use and redistribution. The training code is MIT (C-DiffSET, Copyright (c) 2026 KAIST VICLab).

baselines/spacenet6/sd21-ft/config.json

@@ -0,0 +1,45 @@
+{
+  "_class_name": "UNet2DConditionModel",
+  "_diffusers_version": "0.10.0.dev0",
+  "act_fn": "silu",
+  "attention_head_dim": [
+    5,
+    10,
+    20,
+    20
+  ],
+  "block_out_channels": [
+    320,
+    640,
+    1280,
+    1280
+  ],
+  "center_input_sample": false,
+  "cross_attention_dim": 1024,
+  "down_block_types": [
+    "CrossAttnDownBlock2D",
+    "CrossAttnDownBlock2D",
+    "CrossAttnDownBlock2D",
+    "DownBlock2D"
+  ],
+  "downsample_padding": 1,
+  "dual_cross_attention": false,
+  "flip_sin_to_cos": true,
+  "freq_shift": 0,
+  "in_channels": 8,
+  "layers_per_block": 2,
+  "mid_block_scale_factor": 1,
+  "norm_eps": 1e-05,
+  "norm_num_groups": 32,
+  "num_class_embeds": null,
+  "only_cross_attention": false,
+  "out_channels": 4,
+  "sample_size": 64,
+  "up_block_types": [
+    "UpBlock2D",
+    "CrossAttnUpBlock2D",
+    "CrossAttnUpBlock2D",
+    "CrossAttnUpBlock2D"
+  ],
+  "use_linear_projection": true
+}

baselines/spacenet6/sd21-ft/diffusion_pytorch_model.safetensors

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

baselines/spacenet6/seg-cyclegan/README.md

@@ -0,0 +1,44 @@
+# Seg-CycleGAN · SpaceNet6
+
+Seg-CycleGAN (GRSL'25) retrained by the GeoSET authors on the SpaceNet6 split. These are the weights behind
+the Seg-CycleGAN row for SpaceNet6 in Table 3 of the GeoSET paper
+([arXiv:2609.37496](https://arxiv.org/abs/2609.37496)).
+
+- Method: Zhang, Li, Lin, Zhang, Fan, Liu and Liu, "Seg-CycleGAN: SAR-to-optical image translation guided by a downstream task", IEEE GRSL 2025.
+- Implementation: [NWPU-LHH/Seg-CycleGAN](https://github.com/NWPU-LHH/Seg-CycleGAN) at commit `f12ff88ac089b7099443ffa2c34fc47e035def6a`.
+- Training and inference code: [`baselines/seg-cyclegan`](https://github.com/KAIST-VICLab/GeoSET/tree/main/baselines/seg-cyclegan) in the GeoSET repository.
+
+## Files
+
+| File | Bytes | SHA-256 | Role |
+|---|---:|---|---|
+| `net_G_A.pth` | 45,532,493 | `a3cfe869a0d67bc298d52527b95eec952fbe301959d43c7d971a74cbca3c5b9f` | Generator G_A (`resnet_9blocks`), SAR → EO; produces the output image |
+| `net_G_B.pth` | 45,532,493 | `592a9e9770f78bd9df29a14e01344a5a4bf29f1121e2a6c3ad7252d79ac5824f` | Generator G_B (`resnet_9blocks`), EO → SAR; loaded by the upstream test script |
+| `segnet_guide.pth` | 117,899,184 | `f48ed0a584d9dde5a6a4b8cde3eace2104dbb6006d378ea26c2b460ceded1934` | Guide SegNet (VGG16-BN encoder; background / building) trained by the GeoSET authors with `baselines/seg-cyclegan/train_segnet.py` on the SpaceNet6 training tiles; used by train.sh only |
+
+## Results (GeoSET paper, Table 3)
+
+SpaceNet6 test split, 495 pairs, 256 × 256.
+
+| FID↓ | DISTS↓ | KID↓ | DINO↑ | LPIPS↓ | SSIM↑ | PSNR↑ |
+|---:|---:|---:|---:|---:|---:|---:|
+| 131.4 | 0.229 | 0.0611 | 0.649 | 0.386 | 0.471 | 16.62 |
+
+## Inference
+
+```bash
+git clone https://github.com/KAIST-VICLab/GeoSET && cd GeoSET
+export BASELINES_ROOT=/path/to/upstream_code DATA_ROOT=/path/to/data WORK_DIR=/path/to/work CKPT_ROOT=/path/to/checkpoints
+bash baselines/seg-cyclegan/fetch.sh
+bash baselines/pix2pix/fetch.sh            # combine_A_and_B.py, used by gan_prepare.py
+python scripts/datasets/build_spacenet6.py --data-root $DATA_ROOT
+python baselines/data/gan_prepare.py spacenet6
+hf download JeonghyeokDo/GeoSET --include "baselines/spacenet6/seg-cyclegan/*.pth" --local-dir hf
+mkdir -p $CKPT_ROOT/seg-cyclegan/spacenet6 && cp hf/baselines/spacenet6/seg-cyclegan/*.pth $CKPT_ROOT/seg-cyclegan/spacenet6/
+bash baselines/seg-cyclegan/test.sh spacenet6        # writes $WORK_DIR/results/seg-cyclegan/spacenet6/<stem>.png
+python scripts/evaluate.py --dataset spacenet6 --pred-dir $WORK_DIR/results/seg-cyclegan/spacenet6
+```
+
+## Licence
+
+The Seg-CycleGAN repository contains no licence file. These weights were trained by the GeoSET authors with that code; the GeoSET repository distributes only its changes to the code. The CycleGAN components of that code derive from junyanz/pytorch-CycleGAN-and-pix2pix (BSD).

baselines/spacenet6/seg-cyclegan/net_G_A.pth

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

baselines/spacenet6/seg-cyclegan/net_G_B.pth

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

baselines/spacenet6/seg-cyclegan/segnet_guide.pth

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

baselines/spacenet6/spade/README.md

@@ -0,0 +1,42 @@
+# SPADE · SpaceNet6
+
+SPADE (CVPR'19) retrained by the GeoSET authors on the SpaceNet6 split. These are the weights behind
+the SPADE row for SpaceNet6 in Table 3 of the GeoSET paper
+([arXiv:2609.37496](https://arxiv.org/abs/2609.37496)).
+
+- Method: Park, Liu, Wang and Zhu, "Semantic image synthesis with spatially-adaptive normalization", CVPR 2019.
+- Implementation: [NVlabs/SPADE](https://github.com/NVlabs/SPADE) at commit `fecacc920c1367a038995c45a39c15f6521ca64f`.
+- Training and inference code: [`baselines/spade`](https://github.com/KAIST-VICLab/GeoSET/tree/main/baselines/spade) in the GeoSET repository.
+
+## Files
+
+| File | Bytes | SHA-256 | Role |
+|---|---:|---|---|
+| `net_G.pth` | 368,775,707 | `b6714fb30bd34f62c8495af92bc225b96d9363cb8edc2839df3918784f2a4e6f` | SPADE generator with the SAR image as its 3-channel input map, SAR → EO; loads only into the code patched by `baselines/spade/spade.patch`; used by test.sh |
+
+## Results (GeoSET paper, Table 3)
+
+SpaceNet6 test split, 495 pairs, 256 × 256.
+
+| FID↓ | DISTS↓ | KID↓ | DINO↑ | LPIPS↓ | SSIM↑ | PSNR↑ |
+|---:|---:|---:|---:|---:|---:|---:|
+| 179.7 | 0.242 | 0.1228 | 0.662 | 0.385 | 0.489 | 17.77 |
+
+## Inference
+
+```bash
+git clone https://github.com/KAIST-VICLab/GeoSET && cd GeoSET
+export BASELINES_ROOT=/path/to/upstream_code DATA_ROOT=/path/to/data WORK_DIR=/path/to/work CKPT_ROOT=/path/to/checkpoints
+bash baselines/spade/fetch.sh
+bash baselines/pix2pix/fetch.sh            # combine_A_and_B.py, used by gan_prepare.py
+python scripts/datasets/build_spacenet6.py --data-root $DATA_ROOT
+python baselines/data/gan_prepare.py spacenet6
+hf download JeonghyeokDo/GeoSET --include "baselines/spacenet6/spade/*.pth" --local-dir hf
+mkdir -p $CKPT_ROOT/spade/spacenet6 && cp hf/baselines/spacenet6/spade/*.pth $CKPT_ROOT/spade/spacenet6/
+bash baselines/spade/test.sh spacenet6        # writes $WORK_DIR/results/spade/spacenet6/<stem>.png
+python scripts/evaluate.py --dataset spacenet6 --pred-dir $WORK_DIR/results/spade/spacenet6
+```
+
+## Licence
+
+These weights were trained with the SPADE code (Copyright (C) 2019 NVIDIA Corporation) and are released under its licence, [CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode) ([LICENSE.md](https://github.com/NVlabs/SPADE/blob/fecacc920c1367a038995c45a39c15f6521ca64f/LICENSE.md)): non-commercial use only, and adaptations must be shared under the same licence. The GeoSET repository states its changes to the code (`baselines/spade`, same licence).

baselines/spacenet6/spade/net_G.pth

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

baselines/spacenet6/stegogan/README.md

@@ -0,0 +1,43 @@
+# StegoGAN · SpaceNet6
+
+StegoGAN (CVPR'24) retrained by the GeoSET authors on the SpaceNet6 split. These are the weights behind
+the StegoGAN row for SpaceNet6 in Table 3 of the GeoSET paper
+([arXiv:2609.37496](https://arxiv.org/abs/2609.37496)).
+
+- Method: Wu, Chen, Mermet, Hurni, Schindler, Gonthier and Landrieu, "StegoGAN: Leveraging steganography for non-bijective image-to-image translation", CVPR 2024.
+- Implementation: [sian-wusidi/StegoGAN](https://github.com/sian-wusidi/StegoGAN) at commit `cad61997c0f82793444f60f81298142b80cdf3c1`.
+- Training and inference code: [`baselines/stegogan`](https://github.com/KAIST-VICLab/GeoSET/tree/main/baselines/stegogan) in the GeoSET repository.
+
+## Files
+
+| File | Bytes | SHA-256 | Role |
+|---|---:|---|---|
+| `net_G_A.pth` | 50,254,749 | `27aad6ddc483d83eba63c500080cf7f6b4a02205defbf468c7dd222ab4c445fa` | Generator G_A (`resnet_9blocks_maskv1`), SAR → EO; the output image is G_A applied to the SAR image alone (`fake_B_clean`) |
+| `net_G_B.pth` | 52,615,525 | `425e3a0a0a08a0cd30d257f8085b8c33e68efb26a174f3443740e3f8d74bc6dc` | Generator G_B (`resnet_9blocks_maskv3`), EO → SAR; loaded by the upstream test script |
+
+## Results (GeoSET paper, Table 3)
+
+SpaceNet6 test split, 495 pairs, 256 × 256.
+
+| FID↓ | DISTS↓ | KID↓ | DINO↑ | LPIPS↓ | SSIM↑ | PSNR↑ |
+|---:|---:|---:|---:|---:|---:|---:|
+| 113.1 | 0.225 | 0.0361 | 0.649 | 0.388 | 0.457 | 16.04 |
+
+## Inference
+
+```bash
+git clone https://github.com/KAIST-VICLab/GeoSET && cd GeoSET
+export BASELINES_ROOT=/path/to/upstream_code DATA_ROOT=/path/to/data WORK_DIR=/path/to/work CKPT_ROOT=/path/to/checkpoints
+bash baselines/stegogan/fetch.sh
+bash baselines/pix2pix/fetch.sh            # combine_A_and_B.py, used by gan_prepare.py
+python scripts/datasets/build_spacenet6.py --data-root $DATA_ROOT
+python baselines/data/gan_prepare.py spacenet6
+hf download JeonghyeokDo/GeoSET --include "baselines/spacenet6/stegogan/*.pth" --local-dir hf
+mkdir -p $CKPT_ROOT/stegogan/spacenet6 && cp hf/baselines/spacenet6/stegogan/*.pth $CKPT_ROOT/stegogan/spacenet6/
+bash baselines/stegogan/test.sh spacenet6        # writes $WORK_DIR/results/stegogan/spacenet6/<stem>.png
+python scripts/evaluate.py --dataset spacenet6 --pred-dir $WORK_DIR/results/stegogan/spacenet6
+```
+
+## Licence
+
+The StegoGAN repository contains no licence file. These weights were trained by the GeoSET authors with that code; the GeoSET repository distributes only scripts that run the unmodified code.

baselines/spacenet6/stegogan/net_G_A.pth

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

baselines/spacenet6/stegogan/net_G_B.pth

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

generalist/autoencoder_flux2.py

@@ -0,0 +1,224 @@
+# Copyright (c) Black Forest Labs.
+# Copyright (c) 2026 The GeoSET Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Adapted from black-forest-labs/flux2 (Apache-2.0). Modified by the GeoSET authors.
+"""Frozen FLUX.2 autoencoder with the packed (2x2 space-to-depth), BatchNorm-normalised 128-channel latent."""
+
+from __future__ import annotations
+
+import torch
+from diffusers.configuration_utils import ConfigMixin, register_to_config
+from diffusers.models.modeling_utils import ModelMixin
+from einops import rearrange
+from torch import Tensor, nn
+
+
+def swish(x: Tensor) -> Tensor:
+    return x * torch.sigmoid(x)
+
+
+class AttnBlock(nn.Module):
+    def __init__(self, in_channels: int):
+        super().__init__()
+        self.norm = nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True)
+        self.q = nn.Conv2d(in_channels, in_channels, kernel_size=1)
+        self.k = nn.Conv2d(in_channels, in_channels, kernel_size=1)
+        self.v = nn.Conv2d(in_channels, in_channels, kernel_size=1)
+        self.proj_out = nn.Conv2d(in_channels, in_channels, kernel_size=1)
+
+    def forward(self, x: Tensor) -> Tensor:
+        h_ = self.norm(x)
+        q, k, v = self.q(h_), self.k(h_), self.v(h_)
+        b, c, h, w = q.shape
+        q, k, v = (rearrange(t, "b c h w -> b 1 (h w) c").contiguous() for t in (q, k, v))
+        h_ = nn.functional.scaled_dot_product_attention(q, k, v)
+        return x + self.proj_out(rearrange(h_, "b 1 (h w) c -> b c h w", h=h, w=w, c=c, b=b))
+
+
+class ResnetBlock(nn.Module):
+    def __init__(self, in_channels: int, out_channels: int):
+        super().__init__()
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.norm1 = nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True)
+        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1)
+        self.norm2 = nn.GroupNorm(num_groups=32, num_channels=out_channels, eps=1e-6, affine=True)
+        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1)
+        if in_channels != out_channels:
+            self.nin_shortcut = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0)
+
+    def forward(self, x: Tensor) -> Tensor:
+        h = self.conv1(swish(self.norm1(x)))
+        h = self.conv2(swish(self.norm2(h)))
+        if self.in_channels != self.out_channels:
+            x = self.nin_shortcut(x)
+        return x + h
+
+
+class Downsample(nn.Module):
+    def __init__(self, in_channels: int):
+        super().__init__()
+        self.conv = nn.Conv2d(in_channels, in_channels, kernel_size=3, stride=2, padding=0)
+
+    def forward(self, x: Tensor) -> Tensor:
+        return self.conv(nn.functional.pad(x, (0, 1, 0, 1), mode="constant", value=0))
+
+
+class Upsample(nn.Module):
+    def __init__(self, in_channels: int):
+        super().__init__()
+        self.conv = nn.Conv2d(in_channels, in_channels, kernel_size=3, stride=1, padding=1)
+
+    def forward(self, x: Tensor) -> Tensor:
+        return self.conv(nn.functional.interpolate(x, scale_factor=2.0, mode="nearest"))
+
+
+class Encoder(nn.Module):
+    """Image -> latent moments (mean and log-variance, 2 * z_channels at 1/8 resolution)."""
+
+    def __init__(self, in_channels: int, ch: int, ch_mult: list[int], num_res_blocks: int, z_channels: int):
+        super().__init__()
+        self.quant_conv = nn.Conv2d(2 * z_channels, 2 * z_channels, 1)
+        self.num_resolutions = len(ch_mult)
+        self.num_res_blocks = num_res_blocks
+        self.conv_in = nn.Conv2d(in_channels, ch, kernel_size=3, stride=1, padding=1)
+        in_ch_mult = (1,) + tuple(ch_mult)
+        self.down = nn.ModuleList()
+        for i_level in range(self.num_resolutions):
+            block = nn.ModuleList()
+            block_in = ch * in_ch_mult[i_level]
+            block_out = ch * ch_mult[i_level]
+            for _ in range(num_res_blocks):
+                block.append(ResnetBlock(block_in, block_out))
+                block_in = block_out
+            down = nn.Module()
+            down.block = block
+            if i_level != self.num_resolutions - 1:
+                down.downsample = Downsample(block_in)
+            self.down.append(down)
+        self.mid = nn.Module()
+        self.mid.block_1 = ResnetBlock(block_in, block_in)
+        self.mid.attn_1 = AttnBlock(block_in)
+        self.mid.block_2 = ResnetBlock(block_in, block_in)
+        self.norm_out = nn.GroupNorm(num_groups=32, num_channels=block_in, eps=1e-6, affine=True)
+        self.conv_out = nn.Conv2d(block_in, 2 * z_channels, kernel_size=3, stride=1, padding=1)
+
+    def forward(self, x: Tensor) -> Tensor:
+        h = self.conv_in(x)
+        for i_level in range(self.num_resolutions):
+            for i_block in range(self.num_res_blocks):
+                h = self.down[i_level].block[i_block](h)
+            if i_level != self.num_resolutions - 1:
+                h = self.down[i_level].downsample(h)
+        h = self.mid.block_2(self.mid.attn_1(self.mid.block_1(h)))
+        return self.quant_conv(self.conv_out(swish(self.norm_out(h))))
+
+
+class Decoder(nn.Module):
+    """Latent (z_channels at 1/8 resolution) -> image."""
+
+    def __init__(self, ch: int, out_ch: int, ch_mult: list[int], num_res_blocks: int, z_channels: int):
+        super().__init__()
+        self.post_quant_conv = nn.Conv2d(z_channels, z_channels, 1)
+        self.num_resolutions = len(ch_mult)
+        self.num_res_blocks = num_res_blocks
+        block_in = ch * ch_mult[-1]
+        self.conv_in = nn.Conv2d(z_channels, block_in, kernel_size=3, stride=1, padding=1)
+        self.mid = nn.Module()
+        self.mid.block_1 = ResnetBlock(block_in, block_in)
+        self.mid.attn_1 = AttnBlock(block_in)
+        self.mid.block_2 = ResnetBlock(block_in, block_in)
+        self.up = nn.ModuleList()
+        for i_level in reversed(range(self.num_resolutions)):
+            block = nn.ModuleList()
+            block_out = ch * ch_mult[i_level]
+            for _ in range(num_res_blocks + 1):
+                block.append(ResnetBlock(block_in, block_out))
+                block_in = block_out
+            up = nn.Module()
+            up.block = block
+            if i_level != 0:
+                up.upsample = Upsample(block_in)
+            self.up.insert(0, up)
+        self.norm_out = nn.GroupNorm(num_groups=32, num_channels=block_in, eps=1e-6, affine=True)
+        self.conv_out = nn.Conv2d(block_in, out_ch, kernel_size=3, stride=1, padding=1)
+
+    def trunk(self, z: Tensor) -> Tensor:
+        """Every layer except ``conv_out``: returns the ``ch``-channel features at full resolution."""
+        h = self.conv_in(self.post_quant_conv(z))
+        h = self.mid.block_2(self.mid.attn_1(self.mid.block_1(h)))
+        h = h.to(next(self.up.parameters()).dtype)
+        for i_level in reversed(range(self.num_resolutions)):
+            for i_block in range(self.num_res_blocks + 1):
+                h = self.up[i_level].block[i_block](h)
+            if i_level != 0:
+                h = self.up[i_level].upsample(h)
+        return swish(self.norm_out(h))
+
+    def forward(self, z: Tensor) -> Tensor:
+        return self.conv_out(self.trunk(z))
+
+
+class AutoencoderFlux2(ModelMixin, ConfigMixin):
+    """FLUX.2 autoencoder: ``encode`` maps ``[B, 3, H, W]`` in [-1, 1] to ``[B, 128, H/16, W/16]``, ``decode`` inverts it.
+
+    The latent is the posterior mean, packed 2x2 space-to-depth and normalised by a BatchNorm with fixed running
+    statistics. The module is frozen and always in eval mode.
+    """
+
+    @register_to_config
+    def __init__(
+        self,
+        in_channels: int = 3,
+        out_ch: int = 3,
+        ch: int = 128,
+        ch_mult: tuple[int, ...] = (1, 2, 4, 4),
+        num_res_blocks: int = 2,
+        z_channels: int = 32,
+    ):
+        super().__init__()
+        self.encoder = Encoder(in_channels, ch, list(ch_mult), num_res_blocks, z_channels)
+        self.decoder = Decoder(ch, out_ch, list(ch_mult), num_res_blocks, z_channels)
+        self.bn = nn.BatchNorm2d(4 * z_channels, eps=1e-4, momentum=0.1, affine=False, track_running_stats=True)
+        self.requires_grad_(False)
+        self.eval()
+
+    @staticmethod
+    def pack(z: Tensor) -> Tensor:
+        return rearrange(z, "... c (i pi) (j pj) -> ... (c pi pj) i j", pi=2, pj=2)
+
+    @staticmethod
+    def unpack(z: Tensor) -> Tensor:
+        return rearrange(z, "... (c pi pj) i j -> ... c (i pi) (j pj)", pi=2, pj=2)
+
+    def normalize(self, z: Tensor) -> Tensor:
+        self.bn.eval()
+        return self.bn(z)
+
+    def inv_normalize(self, z: Tensor) -> Tensor:
+        self.bn.eval()
+        s = torch.sqrt(self.bn.running_var.view(1, -1, 1, 1) + self.bn.eps)
+        m = self.bn.running_mean.view(1, -1, 1, 1)
+        return z * s + m
+
+    def encode(self, x: Tensor) -> Tensor:
+        moments = self.encoder(x)
+        return self.normalize(self.pack(torch.chunk(moments, 2, dim=1)[0]))
+
+    def decode(self, z: Tensor) -> Tensor:
+        return self.decoder(self.unpack(self.inv_normalize(z)))
+
+    def train(self, mode: bool = True) -> "AutoencoderFlux2":
+        return super().train(False)

generalist/lora.py

@@ -0,0 +1,130 @@
+"""LoRA for the GeoSET transformer: rank-r adapters on the attention and MLP projections of every block.
+
+An adapter directory holds ``adapter_model.safetensors`` (``<module path>.lora_A`` ``[r, in]`` and
+``<module path>.lora_B`` ``[out, r]``, float32) and ``adapter_config.json``.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import os
+from pathlib import Path
+
+import torch
+import torch.nn.functional as F
+from safetensors.torch import load_file, save_file
+from torch import Tensor, nn
+
+LORA_TARGETS = (
+    "img_attn.qkv", "img_attn.proj", "img_mlp.0", "img_mlp.2",
+    "txt_attn.qkv", "txt_attn.proj", "txt_mlp.0", "txt_mlp.2",
+    "linear1", "linear2",
+)
+_FINGERPRINT_TENSORS = ("img_in.weight", "final_layer.linear.weight", "time_in.in_layer.weight")
+
+
+class LoRALinear(nn.Linear):
+    """``W x + (alpha / r) B A x`` sharing the base weight; ``A`` is Kaiming-uniform, ``B`` starts at zero."""
+
+    def __init__(self, base: nn.Linear, rank: int, alpha: float):
+        nn.Module.__init__(self)
+        self.in_features = base.in_features
+        self.out_features = base.out_features
+        self.weight = base.weight
+        self.register_parameter("bias", base.bias)
+        self.rank = int(rank)
+        self.alpha = float(alpha)
+        self.scale = self.alpha / self.rank
+        kw = dict(dtype=self.weight.dtype, device=self.weight.device)
+        self.lora_A = nn.Parameter(torch.empty(self.rank, self.in_features, **kw))
+        self.lora_B = nn.Parameter(torch.zeros(self.out_features, self.rank, **kw))
+        nn.init.kaiming_uniform_(self.lora_A, a=math.sqrt(5))
+
+    def forward(self, x: Tensor) -> Tensor:
+        return F.linear(x, self.weight, self.bias) + F.linear(F.linear(x, self.lora_A), self.lora_B) * self.scale
+
+
+def add_lora(model: nn.Module, rank: int = 16, alpha: float = 16.0) -> list[str]:
+    """Wrap the target projections in place and freeze every other parameter; returns the wrapped module paths."""
+    targets = [name for name, mod in model.named_modules()
+               if isinstance(mod, nn.Linear) and name.startswith(("double_blocks.", "single_blocks."))
+               and name.split(".", 2)[2] in LORA_TARGETS]
+    model.requires_grad_(False)
+    for path in targets:
+        parent, _, leaf = path.rpartition(".")
+        setattr(model.get_submodule(parent), leaf, LoRALinear(model.get_submodule(path), rank, alpha))
+    for p in lora_parameters(model).values():
+        p.requires_grad_(True)
+    return targets
+
+
+def lora_parameters(model: nn.Module) -> dict[str, nn.Parameter]:
+    """The adapter parameters by name, in module order."""
+    return {n: p for n, p in model.named_parameters() if n.endswith((".lora_A", ".lora_B"))}
+
+
+def check_lora_grads(model: nn.Module) -> int:
+    """Raise unless exactly the adapter parameters carry gradients; returns their count."""
+    params = dict(model.named_parameters())
+    adapter = lora_parameters(model)
+    wrong = [n for n, p in params.items() if p.grad is not None and n not in adapter]
+    dead = [n for n, p in adapter.items() if p.grad is None]
+    if wrong or dead or not adapter:
+        raise RuntimeError(f"LoRA gradient check failed: base tensors with grad {wrong[:3]}, adapter tensors without {dead[:3]}")
+    return len(adapter)
+
+
+def base_fingerprint(model: nn.Module) -> str:
+    """sha256 over three base tensors that no adapter modifies."""
+    sd = model.state_dict()
+    h = hashlib.sha256()
+    for name in _FINGERPRINT_TENSORS:
+        h.update(name.encode())
+        h.update(sd[name].detach().float().cpu().contiguous().numpy().tobytes())
+    return h.hexdigest()
+
+
+def save_lora(save_directory: str | os.PathLike, adapter: dict[str, Tensor], rank: int, alpha: float,
+              base_fingerprint: str) -> None:
+    """Write ``adapter_model.safetensors`` and ``adapter_config.json``."""
+    out = Path(save_directory)
+    out.mkdir(parents=True, exist_ok=True)
+    tensors = {k: v.detach().float().cpu().contiguous() for k, v in adapter.items()}
+    save_file(tensors, str(out / "adapter_model.safetensors"), metadata={"format": "pt"})
+    config = {
+        "rank": int(rank),
+        "alpha": float(alpha),
+        "target_modules": sorted({k.rsplit(".", 1)[0] for k in tensors}),
+        "base_fingerprint": base_fingerprint,
+    }
+    (out / "adapter_config.json").write_text(json.dumps(config, indent=2) + "\n")
+
+
+def load_lora(path: str | os.PathLike) -> tuple[dict[str, Tensor], dict]:
+    """Read an adapter directory: ``(tensors, config)``."""
+    path = Path(path)
+    return load_file(str(path / "adapter_model.safetensors")), json.loads((path / "adapter_config.json").read_text())
+
+
+@torch.no_grad()
+def merge_lora(model: nn.Module, path: str | os.PathLike) -> dict:
+    """Fold an adapter into an unadapted model in place: ``W += (alpha / r) B A`` (float32); returns a report."""
+    if getattr(model, "_lora_merged", None):
+        raise RuntimeError(f"{model._lora_merged} is already merged into this model")
+    tensors, cfg = load_lora(path)
+    if base_fingerprint(model) != cfg["base_fingerprint"]:
+        raise RuntimeError("this adapter was trained on different base weights")
+    scale = float(cfg["alpha"]) / float(cfg["rank"])
+    params = dict(model.named_parameters())
+    num = den = 0.0
+    for name in cfg["target_modules"]:
+        w = params[f"{name}.weight"]
+        d = (tensors[f"{name}.lora_B"].float() @ tensors[f"{name}.lora_A"].float()) * scale
+        num += float(d.pow(2).sum())
+        den += float(w.detach().float().pow(2).sum())
+        w.add_(d.to(w.dtype, copy=False).to(w.device))
+    model._lora_merged = str(path)
+    return {"rank": cfg["rank"], "alpha": cfg["alpha"], "merged_modules": len(cfg["target_modules"]),
+            "delta_rel_fro": math.sqrt(num / den)}

generalist/model_index.json

@@ -0,0 +1,20 @@
+{
+  "_class_name": "GeoSETPipeline",
+  "_diffusers_version": "0.37.1",
+  "sar_encoder": [
+    "sar_encoder_geoset",
+    "GeoSETSAREncoder"
+  ],
+  "scheduler": [
+    "scheduler_flow_bridge",
+    "FlowBridgeScheduler"
+  ],
+  "transformer": [
+    "transformer_geoset",
+    "GeoSETTransformer2DModel"
+  ],
+  "vae": [
+    "autoencoder_flux2",
+    "AutoencoderFlux2"
+  ]
+}

generalist/pipeline.py

@@ -0,0 +1,121 @@
+"""GeoSET SAR-to-EO translation pipeline."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Optional, Union
+
+import numpy as np
+import torch
+from diffusers.models.modeling_utils import ModelMixin
+from diffusers.pipelines.pipeline_utils import DiffusionPipeline, ImagePipelineOutput
+from diffusers.schedulers.scheduling_utils import SchedulerMixin
+from diffusers.utils.torch_utils import randn_tensor
+from huggingface_hub import snapshot_download
+from PIL import Image
+
+from .lora import merge_lora
+
+HUB_REPO = "JeonghyeokDo/GeoSET"
+LORA_ADAPTERS = ("qxs-saropt", "sar2opt", "sar2eo", "spacenet6")
+
+
+def sar_to_tensor(image: Image.Image) -> torch.Tensor:
+    """8-bit SAR image -> ``[1, H, W]`` float32 in [-1, 1] (colour inputs are reduced to luminance)."""
+    return torch.from_numpy(np.asarray(image.convert("L"), np.float32)[None] / 127.5 - 1.0)
+
+
+class GeoSETPipeline(DiffusionPipeline):
+    """SAR image -> EO image.
+
+    Components: ``transformer`` (GeoSETTransformer2DModel), ``sar_encoder`` (GeoSETSAREncoder), ``vae``
+    (AutoencoderFlux2) and ``scheduler`` (FlowBridgeScheduler). The SAR encoder maps the input to the condition
+    latent ``z_s``; the flow bridge is integrated from Gaussian noise with classifier-free guidance
+    ``v_u + w (v_c - v_u)`` (all-zero null condition) and the result is decoded by the FLUX.2 autoencoder. The
+    transformer and the SAR encoder run in float32 (the transformer under bfloat16 autocast on CUDA); the
+    autoencoder decodes in bfloat16.
+    """
+
+    model_cpu_offload_seq = "sar_encoder->transformer->vae"
+
+    def __init__(
+        self,
+        transformer: ModelMixin,
+        sar_encoder: ModelMixin,
+        vae: ModelMixin,
+        scheduler: SchedulerMixin,
+    ):
+        super().__init__()
+        vae.to(dtype=torch.bfloat16, memory_format=torch.channels_last)
+        self.register_modules(transformer=transformer, sar_encoder=sar_encoder, vae=vae, scheduler=scheduler)
+
+    def load_lora(self, adapter: Union[str, os.PathLike], repo_id: str = HUB_REPO) -> dict:
+        """Merge a dataset adapter into the transformer: a released key (``LORA_ADAPTERS``) or an adapter directory."""
+        path = Path(adapter)
+        if not path.is_dir():
+            if adapter not in LORA_ADAPTERS:
+                raise ValueError(f"{adapter!r} is neither an adapter directory nor one of {LORA_ADAPTERS}")
+            root = Path(self.name_or_path).parent if self.name_or_path else None
+            if root is None or not (root / "lora" / adapter).is_dir():
+                root = Path(snapshot_download(repo_id, allow_patterns=[f"lora/{adapter}/*"]))
+            path = root / "lora" / adapter
+        return merge_lora(self.transformer, path)
+
+    @staticmethod
+    def preprocess(image: Union[Image.Image, list, torch.Tensor]) -> torch.Tensor:
+        """PIL image(s) -> ``[B, 1, H, W]`` in [-1, 1]; tensors ``[C, H, W]`` / ``[B, C, H, W]`` must be in [-1, 1]."""
+        if isinstance(image, torch.Tensor):
+            return image if image.ndim == 4 else image[None]
+        images = image if isinstance(image, (list, tuple)) else [image]
+        return torch.stack([sar_to_tensor(im) for im in images])
+
+    @torch.no_grad()
+    def __call__(
+        self,
+        image: Union[Image.Image, list, torch.Tensor],
+        num_inference_steps: int = 50,
+        guidance_scale: float = 2.0,
+        generator: Optional[Union[torch.Generator, list]] = None,
+        latents: Optional[torch.Tensor] = None,
+        output_type: str = "pil",
+        return_dict: bool = True,
+    ) -> Union[ImagePipelineOutput, tuple]:
+        """Translate SAR image(s); height and width must be multiples of 16.
+
+        Returns EO images as PIL (8-bit RGB), or as float tensors / arrays in [0, 1] (``"pt"`` ``[B, 3, H, W]``,
+        ``"np"`` ``[B, H, W, 3]``).
+        """
+        if output_type not in ("pil", "np", "pt"):
+            raise ValueError(f"output_type must be 'pil', 'np' or 'pt', got {output_type!r}")
+        device = self._execution_device
+        sar = self.preprocess(image).to(device=device, dtype=torch.float32)
+        if sar.shape[-2] % 16 or sar.shape[-1] % 16:
+            raise ValueError(f"SAR size {tuple(sar.shape[-2:])} must be a multiple of 16")
+        z_s = self.sar_encoder(sar)
+        if latents is None:
+            latents = randn_tensor(z_s.shape, generator=generator, device=device, dtype=torch.float32)
+        latents = latents.to(device=device, dtype=torch.float32)
+        null = torch.zeros_like(z_s)
+
+        self.scheduler.set_timesteps(num_inference_steps, device=device)
+        with torch.autocast("cuda", dtype=torch.bfloat16, enabled=device.type == "cuda"):
+            for t in self.progress_bar(self.scheduler.timesteps):
+                t_batch = t.expand(latents.shape[0])
+                v = self.transformer(latents, t_batch, z_s)
+                if guidance_scale != 1.0:
+                    v_u = self.transformer(latents, t_batch, null)
+                    v = v_u + guidance_scale * (v - v_u)
+                latents = self.scheduler.step(v, t, latents, return_dict=False)[0]
+            image = self.vae.decode(latents.to(self.vae.dtype)).float()
+        image = ((image + 1) / 2).clamp(0, 1)
+        self.maybe_free_model_hooks()
+
+        if output_type == "pil":
+            arr = (image * 255).round().to(torch.uint8).permute(0, 2, 3, 1).cpu().numpy()
+            image = [Image.fromarray(a) for a in arr]
+        elif output_type == "np":
+            image = image.permute(0, 2, 3, 1).cpu().numpy()
+        if not return_dict:
+            return (image,)
+        return ImagePipelineOutput(images=image)

generalist/pipeline_geoset.py

@@ -0,0 +1,121 @@
+"""GeoSET SAR-to-EO translation pipeline."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Optional, Union
+
+import numpy as np
+import torch
+from diffusers.models.modeling_utils import ModelMixin
+from diffusers.pipelines.pipeline_utils import DiffusionPipeline, ImagePipelineOutput
+from diffusers.schedulers.scheduling_utils import SchedulerMixin
+from diffusers.utils.torch_utils import randn_tensor
+from huggingface_hub import snapshot_download
+from PIL import Image
+
+from .lora import merge_lora
+
+HUB_REPO = "JeonghyeokDo/GeoSET"
+LORA_ADAPTERS = ("qxs-saropt", "sar2opt", "sar2eo", "spacenet6")
+
+
+def sar_to_tensor(image: Image.Image) -> torch.Tensor:
+    """8-bit SAR image -> ``[1, H, W]`` float32 in [-1, 1] (colour inputs are reduced to luminance)."""
+    return torch.from_numpy(np.asarray(image.convert("L"), np.float32)[None] / 127.5 - 1.0)
+
+
+class GeoSETPipeline(DiffusionPipeline):
+    """SAR image -> EO image.
+
+    Components: ``transformer`` (GeoSETTransformer2DModel), ``sar_encoder`` (GeoSETSAREncoder), ``vae``
+    (AutoencoderFlux2) and ``scheduler`` (FlowBridgeScheduler). The SAR encoder maps the input to the condition
+    latent ``z_s``; the flow bridge is integrated from Gaussian noise with classifier-free guidance
+    ``v_u + w (v_c - v_u)`` (all-zero null condition) and the result is decoded by the FLUX.2 autoencoder. The
+    transformer and the SAR encoder run in float32 (the transformer under bfloat16 autocast on CUDA); the
+    autoencoder decodes in bfloat16.
+    """
+
+    model_cpu_offload_seq = "sar_encoder->transformer->vae"
+
+    def __init__(
+        self,
+        transformer: ModelMixin,
+        sar_encoder: ModelMixin,
+        vae: ModelMixin,
+        scheduler: SchedulerMixin,
+    ):
+        super().__init__()
+        vae.to(dtype=torch.bfloat16, memory_format=torch.channels_last)
+        self.register_modules(transformer=transformer, sar_encoder=sar_encoder, vae=vae, scheduler=scheduler)
+
+    def load_lora(self, adapter: Union[str, os.PathLike], repo_id: str = HUB_REPO) -> dict:
+        """Merge a dataset adapter into the transformer: a released key (``LORA_ADAPTERS``) or an adapter directory."""
+        path = Path(adapter)
+        if not path.is_dir():
+            if adapter not in LORA_ADAPTERS:
+                raise ValueError(f"{adapter!r} is neither an adapter directory nor one of {LORA_ADAPTERS}")
+            root = Path(self.name_or_path).parent if self.name_or_path else None
+            if root is None or not (root / "lora" / adapter).is_dir():
+                root = Path(snapshot_download(repo_id, allow_patterns=[f"lora/{adapter}/*"]))
+            path = root / "lora" / adapter
+        return merge_lora(self.transformer, path)
+
+    @staticmethod
+    def preprocess(image: Union[Image.Image, list, torch.Tensor]) -> torch.Tensor:
+        """PIL image(s) -> ``[B, 1, H, W]`` in [-1, 1]; tensors ``[C, H, W]`` / ``[B, C, H, W]`` must be in [-1, 1]."""
+        if isinstance(image, torch.Tensor):
+            return image if image.ndim == 4 else image[None]
+        images = image if isinstance(image, (list, tuple)) else [image]
+        return torch.stack([sar_to_tensor(im) for im in images])
+
+    @torch.no_grad()
+    def __call__(
+        self,
+        image: Union[Image.Image, list, torch.Tensor],
+        num_inference_steps: int = 50,
+        guidance_scale: float = 2.0,
+        generator: Optional[Union[torch.Generator, list]] = None,
+        latents: Optional[torch.Tensor] = None,
+        output_type: str = "pil",
+        return_dict: bool = True,
+    ) -> Union[ImagePipelineOutput, tuple]:
+        """Translate SAR image(s); height and width must be multiples of 16.
+
+        Returns EO images as PIL (8-bit RGB), or as float tensors / arrays in [0, 1] (``"pt"`` ``[B, 3, H, W]``,
+        ``"np"`` ``[B, H, W, 3]``).
+        """
+        if output_type not in ("pil", "np", "pt"):
+            raise ValueError(f"output_type must be 'pil', 'np' or 'pt', got {output_type!r}")
+        device = self._execution_device
+        sar = self.preprocess(image).to(device=device, dtype=torch.float32)
+        if sar.shape[-2] % 16 or sar.shape[-1] % 16:
+            raise ValueError(f"SAR size {tuple(sar.shape[-2:])} must be a multiple of 16")
+        z_s = self.sar_encoder(sar)
+        if latents is None:
+            latents = randn_tensor(z_s.shape, generator=generator, device=device, dtype=torch.float32)
+        latents = latents.to(device=device, dtype=torch.float32)
+        null = torch.zeros_like(z_s)
+
+        self.scheduler.set_timesteps(num_inference_steps, device=device)
+        with torch.autocast("cuda", dtype=torch.bfloat16, enabled=device.type == "cuda"):
+            for t in self.progress_bar(self.scheduler.timesteps):
+                t_batch = t.expand(latents.shape[0])
+                v = self.transformer(latents, t_batch, z_s)
+                if guidance_scale != 1.0:
+                    v_u = self.transformer(latents, t_batch, null)
+                    v = v_u + guidance_scale * (v - v_u)
+                latents = self.scheduler.step(v, t, latents, return_dict=False)[0]
+            image = self.vae.decode(latents.to(self.vae.dtype)).float()
+        image = ((image + 1) / 2).clamp(0, 1)
+        self.maybe_free_model_hooks()
+
+        if output_type == "pil":
+            arr = (image * 255).round().to(torch.uint8).permute(0, 2, 3, 1).cpu().numpy()
+            image = [Image.fromarray(a) for a in arr]
+        elif output_type == "np":
+            image = image.permute(0, 2, 3, 1).cpu().numpy()
+        if not return_dict:
+            return (image,)
+        return ImagePipelineOutput(images=image)

generalist/sar_encoder/autoencoder_flux2.py

@@ -0,0 +1,224 @@
+# Copyright (c) Black Forest Labs.
+# Copyright (c) 2026 The GeoSET Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Adapted from black-forest-labs/flux2 (Apache-2.0). Modified by the GeoSET authors.
+"""Frozen FLUX.2 autoencoder with the packed (2x2 space-to-depth), BatchNorm-normalised 128-channel latent."""
+
+from __future__ import annotations
+
+import torch
+from diffusers.configuration_utils import ConfigMixin, register_to_config
+from diffusers.models.modeling_utils import ModelMixin
+from einops import rearrange
+from torch import Tensor, nn
+
+
+def swish(x: Tensor) -> Tensor:
+    return x * torch.sigmoid(x)
+
+
+class AttnBlock(nn.Module):
+    def __init__(self, in_channels: int):
+        super().__init__()
+        self.norm = nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True)
+        self.q = nn.Conv2d(in_channels, in_channels, kernel_size=1)
+        self.k = nn.Conv2d(in_channels, in_channels, kernel_size=1)
+        self.v = nn.Conv2d(in_channels, in_channels, kernel_size=1)
+        self.proj_out = nn.Conv2d(in_channels, in_channels, kernel_size=1)
+
+    def forward(self, x: Tensor) -> Tensor:
+        h_ = self.norm(x)
+        q, k, v = self.q(h_), self.k(h_), self.v(h_)
+        b, c, h, w = q.shape
+        q, k, v = (rearrange(t, "b c h w -> b 1 (h w) c").contiguous() for t in (q, k, v))
+        h_ = nn.functional.scaled_dot_product_attention(q, k, v)
+        return x + self.proj_out(rearrange(h_, "b 1 (h w) c -> b c h w", h=h, w=w, c=c, b=b))
+
+
+class ResnetBlock(nn.Module):
+    def __init__(self, in_channels: int, out_channels: int):
+        super().__init__()
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.norm1 = nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True)
+        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1)
+        self.norm2 = nn.GroupNorm(num_groups=32, num_channels=out_channels, eps=1e-6, affine=True)
+        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1)
+        if in_channels != out_channels:
+            self.nin_shortcut = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0)
+
+    def forward(self, x: Tensor) -> Tensor:
+        h = self.conv1(swish(self.norm1(x)))
+        h = self.conv2(swish(self.norm2(h)))
+        if self.in_channels != self.out_channels:
+            x = self.nin_shortcut(x)
+        return x + h
+
+
+class Downsample(nn.Module):
+    def __init__(self, in_channels: int):
+        super().__init__()
+        self.conv = nn.Conv2d(in_channels, in_channels, kernel_size=3, stride=2, padding=0)
+
+    def forward(self, x: Tensor) -> Tensor:
+        return self.conv(nn.functional.pad(x, (0, 1, 0, 1), mode="constant", value=0))
+
+
+class Upsample(nn.Module):
+    def __init__(self, in_channels: int):
+        super().__init__()
+        self.conv = nn.Conv2d(in_channels, in_channels, kernel_size=3, stride=1, padding=1)
+
+    def forward(self, x: Tensor) -> Tensor:
+        return self.conv(nn.functional.interpolate(x, scale_factor=2.0, mode="nearest"))
+
+
+class Encoder(nn.Module):
+    """Image -> latent moments (mean and log-variance, 2 * z_channels at 1/8 resolution)."""
+
+    def __init__(self, in_channels: int, ch: int, ch_mult: list[int], num_res_blocks: int, z_channels: int):
+        super().__init__()
+        self.quant_conv = nn.Conv2d(2 * z_channels, 2 * z_channels, 1)
+        self.num_resolutions = len(ch_mult)
+        self.num_res_blocks = num_res_blocks
+        self.conv_in = nn.Conv2d(in_channels, ch, kernel_size=3, stride=1, padding=1)
+        in_ch_mult = (1,) + tuple(ch_mult)
+        self.down = nn.ModuleList()
+        for i_level in range(self.num_resolutions):
+            block = nn.ModuleList()
+            block_in = ch * in_ch_mult[i_level]
+            block_out = ch * ch_mult[i_level]
+            for _ in range(num_res_blocks):
+                block.append(ResnetBlock(block_in, block_out))
+                block_in = block_out
+            down = nn.Module()
+            down.block = block
+            if i_level != self.num_resolutions - 1:
+                down.downsample = Downsample(block_in)
+            self.down.append(down)
+        self.mid = nn.Module()
+        self.mid.block_1 = ResnetBlock(block_in, block_in)
+        self.mid.attn_1 = AttnBlock(block_in)
+        self.mid.block_2 = ResnetBlock(block_in, block_in)
+        self.norm_out = nn.GroupNorm(num_groups=32, num_channels=block_in, eps=1e-6, affine=True)
+        self.conv_out = nn.Conv2d(block_in, 2 * z_channels, kernel_size=3, stride=1, padding=1)
+
+    def forward(self, x: Tensor) -> Tensor:
+        h = self.conv_in(x)
+        for i_level in range(self.num_resolutions):
+            for i_block in range(self.num_res_blocks):
+                h = self.down[i_level].block[i_block](h)
+            if i_level != self.num_resolutions - 1:
+                h = self.down[i_level].downsample(h)
+        h = self.mid.block_2(self.mid.attn_1(self.mid.block_1(h)))
+        return self.quant_conv(self.conv_out(swish(self.norm_out(h))))
+
+
+class Decoder(nn.Module):
+    """Latent (z_channels at 1/8 resolution) -> image."""
+
+    def __init__(self, ch: int, out_ch: int, ch_mult: list[int], num_res_blocks: int, z_channels: int):
+        super().__init__()
+        self.post_quant_conv = nn.Conv2d(z_channels, z_channels, 1)
+        self.num_resolutions = len(ch_mult)
+        self.num_res_blocks = num_res_blocks
+        block_in = ch * ch_mult[-1]
+        self.conv_in = nn.Conv2d(z_channels, block_in, kernel_size=3, stride=1, padding=1)
+        self.mid = nn.Module()
+        self.mid.block_1 = ResnetBlock(block_in, block_in)
+        self.mid.attn_1 = AttnBlock(block_in)
+        self.mid.block_2 = ResnetBlock(block_in, block_in)
+        self.up = nn.ModuleList()
+        for i_level in reversed(range(self.num_resolutions)):
+            block = nn.ModuleList()
+            block_out = ch * ch_mult[i_level]
+            for _ in range(num_res_blocks + 1):
+                block.append(ResnetBlock(block_in, block_out))
+                block_in = block_out
+            up = nn.Module()
+            up.block = block
+            if i_level != 0:
+                up.upsample = Upsample(block_in)
+            self.up.insert(0, up)
+        self.norm_out = nn.GroupNorm(num_groups=32, num_channels=block_in, eps=1e-6, affine=True)
+        self.conv_out = nn.Conv2d(block_in, out_ch, kernel_size=3, stride=1, padding=1)
+
+    def trunk(self, z: Tensor) -> Tensor:
+        """Every layer except ``conv_out``: returns the ``ch``-channel features at full resolution."""
+        h = self.conv_in(self.post_quant_conv(z))
+        h = self.mid.block_2(self.mid.attn_1(self.mid.block_1(h)))
+        h = h.to(next(self.up.parameters()).dtype)
+        for i_level in reversed(range(self.num_resolutions)):
+            for i_block in range(self.num_res_blocks + 1):
+                h = self.up[i_level].block[i_block](h)
+            if i_level != 0:
+                h = self.up[i_level].upsample(h)
+        return swish(self.norm_out(h))
+
+    def forward(self, z: Tensor) -> Tensor:
+        return self.conv_out(self.trunk(z))
+
+
+class AutoencoderFlux2(ModelMixin, ConfigMixin):
+    """FLUX.2 autoencoder: ``encode`` maps ``[B, 3, H, W]`` in [-1, 1] to ``[B, 128, H/16, W/16]``, ``decode`` inverts it.
+
+    The latent is the posterior mean, packed 2x2 space-to-depth and normalised by a BatchNorm with fixed running
+    statistics. The module is frozen and always in eval mode.
+    """
+
+    @register_to_config
+    def __init__(
+        self,
+        in_channels: int = 3,
+        out_ch: int = 3,
+        ch: int = 128,
+        ch_mult: tuple[int, ...] = (1, 2, 4, 4),
+        num_res_blocks: int = 2,
+        z_channels: int = 32,
+    ):
+        super().__init__()
+        self.encoder = Encoder(in_channels, ch, list(ch_mult), num_res_blocks, z_channels)
+        self.decoder = Decoder(ch, out_ch, list(ch_mult), num_res_blocks, z_channels)
+        self.bn = nn.BatchNorm2d(4 * z_channels, eps=1e-4, momentum=0.1, affine=False, track_running_stats=True)
+        self.requires_grad_(False)
+        self.eval()
+
+    @staticmethod
+    def pack(z: Tensor) -> Tensor:
+        return rearrange(z, "... c (i pi) (j pj) -> ... (c pi pj) i j", pi=2, pj=2)
+
+    @staticmethod
+    def unpack(z: Tensor) -> Tensor:
+        return rearrange(z, "... (c pi pj) i j -> ... c (i pi) (j pj)", pi=2, pj=2)
+
+    def normalize(self, z: Tensor) -> Tensor:
+        self.bn.eval()
+        return self.bn(z)
+
+    def inv_normalize(self, z: Tensor) -> Tensor:
+        self.bn.eval()
+        s = torch.sqrt(self.bn.running_var.view(1, -1, 1, 1) + self.bn.eps)
+        m = self.bn.running_mean.view(1, -1, 1, 1)
+        return z * s + m
+
+    def encode(self, x: Tensor) -> Tensor:
+        moments = self.encoder(x)
+        return self.normalize(self.pack(torch.chunk(moments, 2, dim=1)[0]))
+
+    def decode(self, z: Tensor) -> Tensor:
+        return self.decoder(self.unpack(self.inv_normalize(z)))
+
+    def train(self, mode: bool = True) -> "AutoencoderFlux2":
+        return super().train(False)

generalist/sar_encoder/config.json

@@ -0,0 +1,13 @@
+{
+  "_class_name": "GeoSETSAREncoder",
+  "_diffusers_version": "0.37.1",
+  "ch": 128,
+  "ch_mult": [
+    1,
+    2,
+    4,
+    4
+  ],
+  "num_res_blocks": 2,
+  "z_channels": 32
+}

generalist/sar_encoder/diffusion_pytorch_model.safetensors

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

generalist/sar_encoder/sar_encoder_geoset.py

@@ -0,0 +1,102 @@
+# Copyright (c) Black Forest Labs.
+# Copyright (c) 2026 The GeoSET Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Adapted from black-forest-labs/flux2 (Apache-2.0). Modified by the GeoSET authors.
+"""Speckle-robust SAR encoder (stage 1): the FLUX.2 encoder trunk with channel-specific input and output stems."""
+
+from __future__ import annotations
+
+import torch
+from diffusers.configuration_utils import ConfigMixin, register_to_config
+from diffusers.models.modeling_utils import ModelMixin
+from torch import Tensor, nn
+
+from .autoencoder_flux2 import AutoencoderFlux2, Encoder
+
+_CHUNK = 32
+
+
+class GeoSETSAREncoder(ModelMixin, ConfigMixin):
+    """SAR image ``[B, 1|2, H, W]`` in [-1, 1] -> SAR latent ``z_s`` ``[B, 128, H/16, W/16]``.
+
+    Stems are keyed by input channels: ``"3"`` takes single-channel SAR folded to three channels, ``"2"`` takes
+    VV/VH. The latent is normalised with the autoencoder's fixed BatchNorm statistics. ``stem_out`` (stage-1
+    reconstruction heads) is not used by ``forward``.
+    """
+
+    @register_to_config
+    def __init__(
+        self,
+        ch: int = 128,
+        ch_mult: tuple[int, ...] = (1, 2, 4, 4),
+        num_res_blocks: int = 2,
+        z_channels: int = 32,
+    ):
+        super().__init__()
+        self.encoder = Encoder(3, ch, list(ch_mult), num_res_blocks, z_channels)
+        self.encoder.conv_in = nn.Identity()
+        self.bn = nn.BatchNorm2d(4 * z_channels, eps=1e-4, momentum=0.1, affine=False, track_running_stats=True)
+        self.bn.eval()
+        self.stem_in = nn.ModuleDict({"3": nn.Conv2d(3, ch, 3, 1, 1), "2": nn.Conv2d(2, ch, 3, 1, 1)})
+        self.stem_out = nn.ModuleDict({"3": nn.Conv2d(ch, 3, 3, 1, 1), "2": nn.Conv2d(ch, 2, 3, 1, 1)})
+
+    def train(self, mode: bool = True) -> "GeoSETSAREncoder":
+        super().train(mode)
+        self.bn.eval()
+        return self
+
+    def encode(self, x: Tensor) -> tuple[Tensor, Tensor]:
+        """``[B, 3|2, H, W]`` -> ``(z, z_raw)``: the BatchNorm-normalised and the raw packed posterior mean."""
+        moments = self.encoder(self.stem_in[str(x.shape[1])](x))
+        z_raw = AutoencoderFlux2.pack(torch.chunk(moments, 2, dim=1)[0])
+        return self.bn(z_raw), z_raw
+
+    def forward(self, sar: Tensor) -> Tensor:
+        if sar.shape[1] == 1:
+            sar = sar.repeat(1, 3, 1, 1)
+        return torch.cat([self.encode(c)[0] for c in sar.split(_CHUNK)], dim=0).float()
+
+    def reconstruct(self, x: Tensor, vae: AutoencoderFlux2) -> Tensor:
+        """Stage-1 reconstruction ``[B, 3|2, H, W]`` -> ``[B, 3|2, H, W]`` through the frozen decoder trunk."""
+        _, z_raw = self.encode(x)
+        return self.stem_out[str(x.shape[1])](vae.decoder.trunk(AutoencoderFlux2.unpack(z_raw)))
+
+    @classmethod
+    @torch.no_grad()
+    def from_autoencoder(cls, vae: AutoencoderFlux2) -> "GeoSETSAREncoder":
+        """Stage-1 initialisation from the FLUX.2 autoencoder.
+
+        The trunk and latent BatchNorm are copies of the encoder's; ``conv_in`` and ``conv_out`` become the
+        three-channel stems; the two-channel stems start from their input-channel sum and output-channel mean.
+        Trainable: the trunk, both input stems and ``stem_out["2"]``; ``stem_out["3"]`` and the BatchNorm stay fixed.
+        """
+        c = vae.config
+        model = cls(ch=c.ch, ch_mult=c.ch_mult, num_res_blocks=c.num_res_blocks, z_channels=c.z_channels)
+        model.encoder.load_state_dict({k: v for k, v in vae.encoder.state_dict().items()
+                                       if not k.startswith("conv_in.")})
+        model.bn.load_state_dict(vae.bn.state_dict())
+        w_in, b_in = vae.encoder.conv_in.weight.float(), vae.encoder.conv_in.bias.float()
+        w_out, b_out = vae.decoder.conv_out.weight.float(), vae.decoder.conv_out.bias.float()
+        stems = {
+            ("stem_in", "3"): (w_in, b_in),
+            ("stem_in", "2"): (w_in.sum(dim=1, keepdim=True).repeat(1, 2, 1, 1) / 2, b_in.clone()),
+            ("stem_out", "3"): (w_out, b_out),
+            ("stem_out", "2"): (w_out.mean(dim=0, keepdim=True).repeat(2, 1, 1, 1), b_out.mean().repeat(2)),
+        }
+        for (group, key), (w, b) in stems.items():
+            getattr(model, group)[key].weight.copy_(w)
+            getattr(model, group)[key].bias.copy_(b)
+        model.stem_out["3"].requires_grad_(False)
+        return model

generalist/sar_encoder_geoset.py

@@ -0,0 +1,102 @@
+# Copyright (c) Black Forest Labs.
+# Copyright (c) 2026 The GeoSET Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Adapted from black-forest-labs/flux2 (Apache-2.0). Modified by the GeoSET authors.
+"""Speckle-robust SAR encoder (stage 1): the FLUX.2 encoder trunk with channel-specific input and output stems."""
+
+from __future__ import annotations
+
+import torch
+from diffusers.configuration_utils import ConfigMixin, register_to_config
+from diffusers.models.modeling_utils import ModelMixin
+from torch import Tensor, nn
+
+from .autoencoder_flux2 import AutoencoderFlux2, Encoder
+
+_CHUNK = 32
+
+
+class GeoSETSAREncoder(ModelMixin, ConfigMixin):
+    """SAR image ``[B, 1|2, H, W]`` in [-1, 1] -> SAR latent ``z_s`` ``[B, 128, H/16, W/16]``.
+
+    Stems are keyed by input channels: ``"3"`` takes single-channel SAR folded to three channels, ``"2"`` takes
+    VV/VH. The latent is normalised with the autoencoder's fixed BatchNorm statistics. ``stem_out`` (stage-1
+    reconstruction heads) is not used by ``forward``.
+    """
+
+    @register_to_config
+    def __init__(
+        self,
+        ch: int = 128,
+        ch_mult: tuple[int, ...] = (1, 2, 4, 4),
+        num_res_blocks: int = 2,
+        z_channels: int = 32,
+    ):
+        super().__init__()
+        self.encoder = Encoder(3, ch, list(ch_mult), num_res_blocks, z_channels)
+        self.encoder.conv_in = nn.Identity()
+        self.bn = nn.BatchNorm2d(4 * z_channels, eps=1e-4, momentum=0.1, affine=False, track_running_stats=True)
+        self.bn.eval()
+        self.stem_in = nn.ModuleDict({"3": nn.Conv2d(3, ch, 3, 1, 1), "2": nn.Conv2d(2, ch, 3, 1, 1)})
+        self.stem_out = nn.ModuleDict({"3": nn.Conv2d(ch, 3, 3, 1, 1), "2": nn.Conv2d(ch, 2, 3, 1, 1)})
+
+    def train(self, mode: bool = True) -> "GeoSETSAREncoder":
+        super().train(mode)
+        self.bn.eval()
+        return self
+
+    def encode(self, x: Tensor) -> tuple[Tensor, Tensor]:
+        """``[B, 3|2, H, W]`` -> ``(z, z_raw)``: the BatchNorm-normalised and the raw packed posterior mean."""
+        moments = self.encoder(self.stem_in[str(x.shape[1])](x))
+        z_raw = AutoencoderFlux2.pack(torch.chunk(moments, 2, dim=1)[0])
+        return self.bn(z_raw), z_raw
+
+    def forward(self, sar: Tensor) -> Tensor:
+        if sar.shape[1] == 1:
+            sar = sar.repeat(1, 3, 1, 1)
+        return torch.cat([self.encode(c)[0] for c in sar.split(_CHUNK)], dim=0).float()
+
+    def reconstruct(self, x: Tensor, vae: AutoencoderFlux2) -> Tensor:
+        """Stage-1 reconstruction ``[B, 3|2, H, W]`` -> ``[B, 3|2, H, W]`` through the frozen decoder trunk."""
+        _, z_raw = self.encode(x)
+        return self.stem_out[str(x.shape[1])](vae.decoder.trunk(AutoencoderFlux2.unpack(z_raw)))
+
+    @classmethod
+    @torch.no_grad()
+    def from_autoencoder(cls, vae: AutoencoderFlux2) -> "GeoSETSAREncoder":
+        """Stage-1 initialisation from the FLUX.2 autoencoder.
+
+        The trunk and latent BatchNorm are copies of the encoder's; ``conv_in`` and ``conv_out`` become the
+        three-channel stems; the two-channel stems start from their input-channel sum and output-channel mean.
+        Trainable: the trunk, both input stems and ``stem_out["2"]``; ``stem_out["3"]`` and the BatchNorm stay fixed.
+        """
+        c = vae.config
+        model = cls(ch=c.ch, ch_mult=c.ch_mult, num_res_blocks=c.num_res_blocks, z_channels=c.z_channels)
+        model.encoder.load_state_dict({k: v for k, v in vae.encoder.state_dict().items()
+                                       if not k.startswith("conv_in.")})
+        model.bn.load_state_dict(vae.bn.state_dict())
+        w_in, b_in = vae.encoder.conv_in.weight.float(), vae.encoder.conv_in.bias.float()
+        w_out, b_out = vae.decoder.conv_out.weight.float(), vae.decoder.conv_out.bias.float()
+        stems = {
+            ("stem_in", "3"): (w_in, b_in),
+            ("stem_in", "2"): (w_in.sum(dim=1, keepdim=True).repeat(1, 2, 1, 1) / 2, b_in.clone()),
+            ("stem_out", "3"): (w_out, b_out),
+            ("stem_out", "2"): (w_out.mean(dim=0, keepdim=True).repeat(2, 1, 1, 1), b_out.mean().repeat(2)),
+        }
+        for (group, key), (w, b) in stems.items():
+            getattr(model, group)[key].weight.copy_(w)
+            getattr(model, group)[key].bias.copy_(b)
+        model.stem_out["3"].requires_grad_(False)
+        return model

generalist/scheduler/scheduler_config.json

@@ -0,0 +1,4 @@
+{
+  "_class_name": "FlowBridgeScheduler",
+  "_diffusers_version": "0.37.1"
+}

generalist/scheduler/scheduler_flow_bridge.py

@@ -0,0 +1,59 @@
+"""Explicit-Euler solver for the GeoSET flow bridge (t = 0: Gaussian noise, t = 1: EO latent)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional, Union
+
+import torch
+from diffusers.configuration_utils import ConfigMixin, register_to_config
+from diffusers.schedulers.scheduling_utils import SchedulerMixin
+from diffusers.utils import BaseOutput
+
+
+@dataclass
+class FlowBridgeSchedulerOutput(BaseOutput):
+    prev_sample: torch.Tensor
+
+
+class FlowBridgeScheduler(SchedulerMixin, ConfigMixin):
+    """Uniform grid ``linspace(0, 1, N + 1)``; the model is queried at the first ``N`` points, ``t`` ascending.
+
+    ``step`` integrates the velocity ``dz/dt`` over one grid interval in float32.
+    """
+
+    order = 1
+
+    @register_to_config
+    def __init__(self):
+        self.grid: Optional[torch.Tensor] = None
+        self.num_inference_steps: Optional[int] = None
+        self.step_index = 0
+
+    @property
+    def timesteps(self) -> torch.Tensor:
+        return self.grid[:-1]
+
+    def set_timesteps(self, num_inference_steps: int, device: Optional[Union[str, torch.device]] = None) -> None:
+        if num_inference_steps < 1:
+            raise ValueError(f"num_inference_steps must be >= 1, got {num_inference_steps}")
+        self.num_inference_steps = num_inference_steps
+        self.grid = torch.linspace(0.0, 1.0, num_inference_steps + 1, device=device, dtype=torch.float32)
+        self.step_index = 0
+
+    def step(
+        self,
+        model_output: torch.Tensor,
+        timestep: Union[float, torch.Tensor],
+        sample: torch.Tensor,
+        return_dict: bool = True,
+    ) -> Union[FlowBridgeSchedulerOutput, tuple]:
+        """``z + (t_next - t) * v``; steps must follow ``timesteps`` in order."""
+        t, t_next = self.grid[self.step_index], self.grid[self.step_index + 1]
+        if float(timestep) != float(t):
+            raise ValueError(f"expected timestep {float(t)} at step {self.step_index}, got {float(timestep)}")
+        prev_sample = sample.float() + (t_next - t) * model_output.float()
+        self.step_index += 1
+        if not return_dict:
+            return (prev_sample,)
+        return FlowBridgeSchedulerOutput(prev_sample=prev_sample)