DeCo-VTON: Decouple, Don't Denoise

Official PyTorch implementation of Rethinking Garment Conditioning in Diffusion-based Virtual Try-On: Decouple, Don't Denoise, accepted at ECCV 2026.

This work was initially released as Re-CatVTON. The former Hugging Face URL redirects to levinna/DeCo-VTON.

📢 News

• [2026.06] Accepted to ECCV 2026.
• [2025.12.22] Inference code and pretrained models released.
• [2025.11.24] The paper is available on arXiv.

🔍 Overview

DeCo-VTON is a single-UNet virtual try-on model that separates garment conditioning from the denoising target. It builds on the Stable Diffusion 1.5 inpainting architecture without requiring a separate garment UNet.

🛠️ Installation

conda create -n decovton python=3.12
conda activate decovton
git clone https://github.com/Levinna/DeCo-VTON.git
cd DeCo-VTON
pip install -r requirements.txt
pip install -e .

We trained and tested DeCo-VTON on Python 3.12, PyTorch 2.8.0 with CUDA 12.9.

The requirements file includes the dependencies used for inference and evaluation. DressCode mask preprocessing has two additional dependencies listed below. Training code is not included in this release.

An NVIDIA GPU is required for practical inference. requirements.txt installs the CUDA 12.9 build of PyTorch; install the matching PyTorch build first if your system uses a different CUDA version.

🚀 Inference

Data Preparation

A prepared VITON-HD or DressCode dataset is required for inference. The expected inputs are:

VITON-HD/
├── test_pairs.txt
├── test_pairs_unpaired.txt (optional; falls back to test_pairs.txt)
└── test/{image,cloth,agnostic-mask}/

DressCode/
├── upper_body/{test_pairs_paired.txt,test_pairs_unpaired.txt,images,agnostic_masks}/
├── lower_body/{test_pairs_paired.txt,test_pairs_unpaired.txt,images,agnostic_masks}/
└── dresses/{test_pairs_paired.txt,test_pairs_unpaired.txt,images,agnostic_masks}/

Preprocess Mask

VITON-HD inference uses the agnostic masks distributed with the prepared dataset. For DressCode, install the optional DensePose dependencies and generate masks for the test splits. The preprocessing code is adapted from CatVTON.

pip install 'git+https://github.com/facebookresearch/detectron2.git'
pip install 'git+https://github.com/facebookresearch/detectron2.git#subdirectory=projects/DensePose'

CUDA_VISIBLE_DEVICES=0 python -m thirdparty.preprocess_agnostic_mask \
    --data_root_path /path/to/DressCode \
    --pair_files test_pairs_paired.txt test_pairs_unpaired.txt

Run Inference

Option 1: Load from Hugging Face Hub

python inference.py \
    --hf_repo levinna/DeCo-VTON \
    --hf_subfolder VITON-HD-512/unet \
    --dataset_name vitonhd \
    --data_root_path /path/to/VITON-HD \
    --output_dir ./output \
    --resolution 512 \
    --batch_size 1 \
    --mixed_precision bf16

Option 2: Load from local path

# First, download the model
hf download levinna/DeCo-VTON \
    --include "VITON-HD-512/*" \
    --local-dir ./checkpoints

# Then run inference
python inference.py \
    --base_model_path ./checkpoints/VITON-HD-512 \
    --dataset_name vitonhd \
    --data_root_path /path/to/VITON-HD \
    --output_dir ./output \
    --resolution 512 \
    --batch_size 1 \
    --mixed_precision bf16

If your GPU does not support bf16, use fp16 or fp32. For a custom size, pass --height and --width instead of --resolution. When loading from Hugging Face at a custom size, also pass --hf_subfolder explicitly because the checkpoint resolution cannot be inferred.

Option 3: Use the pipeline directly in Python

import torch
from decovton import DeCoVTONPipeline

pipe = DeCoVTONPipeline.from_vton_checkpoint(
    hf_repo="levinna/DeCo-VTON",
    subfolder="VITON-HD-512/unet",
    torch_dtype=torch.bfloat16,
).to("cuda")

Available Checkpoints

Dataset	HF Subfolder	Resolution	Availability
VITON-HD	VITON-HD-512/unet	512×384	Available
DressCode	DressCode-512/unet	512×384	Available
VITON-HD	VITON-HD-1024/unet	1024×768	Checkpoint required; planned for a later release
DressCode	DressCode-1024/unet	1024×768	Checkpoint required; planned for a later release

The 1024 preset is retained for use with an explicit local or Hub checkpoint, but neither 1024 checkpoint is currently published in levinna/DeCo-VTON.

Inference Options

Argument	Default	Description
--resolution	512	Resolution preset: 512 or 1024; 1024 requires a separate checkpoint that will be released later
--sampler	ddim	Sampler type: ddim, ddpm, unipc, dpmpp
--num_inference_steps	50	Number of diffusion steps
--guidance_scale	2.5	CFG guidance scale
--repaint / --no-repaint	True	Blend result with original background
--eval_pair / --no-eval-pair	True	Evaluate on paired split (--eval-pair is also accepted)

Recommended steps per sampler:

• ddim: 50 steps (main results)
• unipc: 30 steps
• dpmpp: 25 steps

📊 Results

Model	FID ↓	KID ↓	LPIPS ↓	Params (M)
CatVTON	5.888	0.513	0.061	859.5
Leffa	4.540	0.050	0.048	1802.7
DeCo-VTON (Ours)	4.438	0.010	0.047	859.5

Comparison on the VITON-HD paired setting.

Evaluation

evaluation.py reports PyTorch-FID, Clean-FID, and Clean-KID. Add --paired to also report PSNR, SSIM, and LPIPS. Both ground-truth and prediction folders may contain category subdirectories, as in the DressCode output layout.

CUDA_VISIBLE_DEVICES=0 python evaluation.py \
    --gt_folder /path/to/ground-truth-images \
    --pred_folder ./output/vitonhd-512/paired \
    --paired \
    --batch_size 16 \
    --num_workers 4

The ground-truth folder should contain only the person images for the evaluated split. The shell wrapper accepts the same two folders as positional arguments:

bash evaluation.sh /path/to/ground-truth-images ./output/vitonhd-512/paired

📂 Project Structure

DeCo-VTON/
├── decovton/
│   ├── __init__.py
│   ├── pipeline.py
│   ├── attn_processor.py
│   ├── presets.py
│   └── utils.py
├── thirdparty/
│   ├── __init__.py
│   ├── SCHP/
│   ├── DensePose/
│   ├── cloth_masker.py
│   ├── preprocess_agnostic_mask.py
│   └── preprocess_agnostic_mask.sh
├── model/                     # deprecated stubs -> decovton (kept for compatibility)
├── assets/
├── inference.py
├── inference.sh
├── inference_recatvton.py     # deprecated stub -> inference.py
├── inference_recatvton.sh
├── vton_datasets.py
├── evaluation.py
├── evaluation.sh
├── pyproject.toml
├── requirements.txt
├── LICENSE
└── README.md

📝 Roadmap

• 1024×768 checkpoints for VITON-HD and DressCode (planned)
• ComfyUI support

📄 License

• Code: CC-BY-NC-SA 4.0
• Model Weights: CC-BY-NC 4.0

Note: The model weights are licensed under CC BY-NC 4.0 because VITON-HD and DressCode are restricted to non-commercial use.

🙏 Acknowledgements

This project is built upon Diffusers and uses Stable Diffusion v1.5 Inpainting as the base model.

For fair comparison, our data pipeline for inference and evaluation protocol follow those of CatVTON and Leffa.

Citation

If you find our work helpful, please consider citing:

@article{na2025rethinking,
  title={Rethinking Garment Conditioning in Diffusion-based Virtual Try-On: Decouple, Don't Denoise},
  author={Na, Kihyun and Choi, Jinyoung and Kim, Injung},
  journal={arXiv preprint arXiv:2511.18775},
  year={2025}
}