YeTI: You Only Need Two Noisy Images for Real-World sRGB Noise Generation

ECCV 2026

Jaekyun Ko^1,2*  Byung Wan Lim^1*  Soomin Lee¹  Dongjin Kim¹  Tae Hyun Kim^1†

¹Department of Computer Science, Hanyang University   ²Mobile eXperience (MX) Division, Samsung Electronics

^*Equal contribution   ^†Corresponding author

---

📝 Abstract

YeTI is a real-world sRGB noise generation framework that learns from only two noisy observations of the same scene — no clean ground truth or camera metadata required. A Reconstruction Autoencoder disentangles scene structure from noise characteristics, and a one-step Conditional Diffusion Transformer, trained with consistency objectives, models the latent noise distribution. At inference, YeTI turns a single noisy image into realistic, signal-dependent noisy samples that improve downstream (self-supervised) denoisers on real-world benchmarks.

🔍 Method Overview

Unlike prior clean-dependent noise generation methods, YeTI learns to synthesize realistic sRGB noise without any clean reference image — using only two noisy observations of the same scene at training time.

---

This repository is a self-contained release of the source code, configuration files, and run scripts needed to reproduce and share the final YeTI model. The yeti package and its configs are designed to run independently, with no external dependencies other than the pretrained model checkpoints.

📦 Installation

git clone https://github.com/ByungWanLim/YeTI.git
cd YeTI

conda env create -f environment_yeti.yaml
conda activate YeTI

📂 Directory Structure

YeTI/
├── yeti/                                               # core package
│   ├── archs/                                         # model architecture definitions
│   │   ├── apbsn.py                                   # AP-BSN architecture
│   │   ├── autoencoder.py                             # Reconstruction AutoEncoder (RAE) architecture
│   │   ├── masks.py                                   # pixel masking / noise mask utilities
│   │   ├── mmbsn.py                                   # MM-BSN architecture
│   │   ├── norm.py                                    # normalization layers
│   │   └── prompt_dit.py                              # Conditional Diffusion Transformer (C-DiT) architecture
│   ├── datasets/                                      # dataset classes and data loaders
│   ├── losses/                                        # loss function definitions
│   ├── lpips/                                         # LPIPS metric package
│   ├── misc/                                          # standalone helper / inference scripts
│   ├── models/                                        # PyTorch Lightning training / validation modules
│   └── utils/                                         # shared utilities
│
├── configs/                                           # model and dataset configuration files
│   ├── datasets/                                      # dataset configs (train / val)
│   ├── models/                                        # per-model architecture configs (C-DiT / denoiser / RAE)
│   ├── train/                                         # training configs (model + dataset + trainer merged)
│   └── val/                                           # validation configs
│
├── ckpt/                                              # pretrained weights (download from Hugging Face, see below)
├── assets/                                             # images used in this README
├── main.py                                            # main entry point for training / validation
├── run_train.sh / run_val.sh / run_compute_latent.sh
├── run_generate_image.sh / run_generate_burst_images.sh
├── environment_yeti.yaml                              # conda environment definition
├── LICENSE
├── CITATION.cff
└── .gitignore

🤗 Pretrained Checkpoints

Model weights are hosted on Hugging Face (not on GitHub, due to file size). Download them into the ckpt/ folder:

# download everything
huggingface-cli download BWLim/YeTI --local-dir ckpt

# or with huggingface_hub
python -c "from huggingface_hub import snapshot_download; snapshot_download(repo_id='BWLim/YeTI', local_dir='ckpt')"

Checkpoint	Description	Size
rae.ckpt	Reconstruction AutoEncoder (disentangles structure / noise latents)	~148 MB
c_dit.ckpt	Conditional Diffusion Transformer (main noise generation model)	~856 MB
apbsn.ckpt	AP-BSN self-supervised denoiser, trained on YeTI-generated noisy data only	~46 MB
apbsn_mix.ckpt	AP-BSN denoiser trained on a 50:50 mix of YeTI-generated and real noisy data	~46 MB
mmbsn.ckpt	MM-BSN self-supervised denoiser, trained on YeTI-generated noisy data only	~68 MB
mmbsn_mix.ckpt	MM-BSN denoiser trained on a 50:50 mix of YeTI-generated and real noisy data	~68 MB

💾 Dataset Preparation

Datasets are hosted on Hugging Face Datasets. Download the archives you need:

huggingface-cli download BWLim/YeTI --repo-type dataset --local-dir data

Archive	Description	Used for
sidd_patch.tar.gz	SIDD training patches	RAE / C-DiT training
sidd_noisy.tar.gz	SIDD noisy images (full)	Denoiser (AP-BSN / MM-BSN) training
sidd_val.tar.gz	SIDD validation set	Validation
siddplus_val.tar.gz	SIDD+ validation set	Validation
mai_val.tar.gz	MAI2021 validation set	Validation

Extract the archives you need into the repository root, or any accessible path, then set the dataroot field in the corresponding YAML file under configs/datasets/ to the extracted path.

Example (configs/datasets/train/sidd_cdit_train.yaml):

dataset:
  target: yeti.datasets.sidd.SIDDBurstDataset
  params:
    dataroot: /path/to/extracted/sidd_patch    # set the actual extracted path
    patch_size: 256

🚀 Usage

All commands below are run from the repository root directory.

1. Training

# Train RAE
python main.py --config configs/train/RAE/train_lit_rae.yaml

# Train C-DiT
bash run_train.sh
# or: python main.py --config configs/train/C-DiT/train_lit_c-dit.yaml

# Train Denoiser (AP-BSN / MM-BSN)
python main.py --config configs/train/denoiser/train_lit_apbsn.yaml
python main.py --config configs/train/denoiser/train_lit_mmbsn.yaml

2. Validation / Evaluation

# C-DiT validation (defaults to ckpt/c_dit.ckpt)
bash run_val.sh
# or: python main.py --config configs/val/C-DiT/val_lit_c-dit.yaml --ckpt ckpt/c_dit.ckpt

3. Utility Scripts

# Compute RAE latent statistics
bash run_compute_latent.sh

# Generate noisy images (.png) with C-DiT
bash run_generate_image.sh

# Generate a burst noise animation (.gif) with C-DiT
bash run_generate_burst_images.sh

See each run_*.sh script and the argparse definitions in yeti/misc/*.py for the full list of arguments.

---

📊 Denoising Result

YeTI-generated noisy data improves downstream self-supervised denoisers (AP-BSN, MM-BSN) on the SIDD benchmark, narrowing the gap to real noisy data and outperforming prior clean-dependent generators (NAFlow, SeNM-VAE).

📖 Citation

If you find this code or model useful for your research, please cite our paper (the camera-ready citation will be updated after ECCV 2026 publication):

@article{ko2026yeti,
  title   = {YeTI: You Only Need Two Noisy Images for Real-World sRGB Noise Generation},
  author  = {Ko, Jaekyun and Lim, Byung Wan and Lee, Soomin and Kim, Dongjin and Kim, Tae Hyun},
  journal = {arXiv preprint arXiv:2607.09193},
  year    = {2026}
}

📄 License

The code in this repository, the model weights, and the preprocessed datasets hosted on Hugging Face are released for academic / non-commercial research use only. See LICENSE for the full terms. For commercial licensing inquiries, please contact the corresponding author (Tae Hyun Kim, Hanyang University).