Upload patch-forcing

patch-forcing/.gitignore

@@ -0,0 +1,16 @@
+sandbox
+checkpoints
+results
+logs
+wandb
+outputs
+
+*__pycache__*
+.idea
+venv
+
+*.DS_Store
+*._.DS_Store
+shardsFaceHQ
+testy.ipynb
+third_party

patch-forcing/README.md

@@ -0,0 +1,198 @@
+<p align="center">
+ <h2 align="center">Denoising, Fast and Slow: Difficulty-Aware Adaptive Sampling for Image Generation</h2>
+ <p align="center">
+ <b>
+ Johannes Schusterbauer<sup>*</sup> · Ming Gui<sup>*</sup> · Yusong Li · Pingchuan Ma · Felix Krause · Björn Ommer
+ </b>
+ <p align="center"> 
+    CompVis Group @ LMU Munich, Munich Center for Machine Learning (MCML)
+ </p>
+ <p align="center"> 
+    CVPR 2026
+ </p>
+</p>
+ </p>
+<div align="center">
+
+
+[![Website](https://img.shields.io/badge/Project-Page-lightgrey)]()
+[![Paper](https://img.shields.io/badge/arXiv-PDF-b31b1b)](https://github.com/CompVis/patch-forcing)
+
+<p align="center"> <sup>*</sup> <i>equal contribution</i> </p>
+
+</div>
+
+
+<p align="center">
+<img src="assets/fpf.png" alt="Patch Forcing overview" width="60%">
+</p>
+
+# 🚀 TL;DR
+
+
+**Patch Forcing turns denoising into a spatially adaptive process.** During training, different image patches receive heterogeneous timesteps. While conceptually straightforward, this only works well with a dedicated timestep sampler that controls how much clean information is exposed per sample, closing the train–test gap where inference starts from pure noise. This framework enables dynamic sampling strategies, where easy regions can be denoised faster and provide cleaner context for harder ones.
+
+
+🔥 **Contributions**
+- Patch-wise timesteps $\rightarrow$ enables heterogeneous denoising
+- LTG timestep sampler $\rightarrow$ fixes train-test mismatch
+- Patch difficulty-guided sampling $\rightarrow$ allocates compute adaptively
+
+
+<img src="assets/fpf-inference.png" alt="Patch Forcing inference" width="100%">
+
+
+# 📖 Overview
+
+
+Natural images are highly spatially heterogeneous: some regions (e.g. backgrounds) are easy to denoise, while others (e.g. fine structures, text) require more refinement and context.
+However, standard diffusion and flow-based models treat all regions equally, applying the same timestep and compute everywhere.
+
+
+**Key idea**: move from global to patch-wise denoising, where different regions follow different noise trajectories.
+
+
+### Training
+
+Naively assigning random timesteps per patch does *not work*. When timesteps are sampled independently and uniformly, most training samples contain a mix of noisy and already partially clean regions. As a result, the model learns to rely on this implicit context, even though such states never occur at inference, where generation starts from pure noise. This creates a clear train–test mismatch.
+
+<p align="center">
+<img src="assets/srm-comparison.png" alt="Schedule Comparison" width="100%">
+</p>
+
+Prior work (SRM) addresses this by controlling the average amount of information per sample. While this partially mitigates the issue, it does not fully resolve it: even if the average is well-behaved, individual patches can still be nearly clean. In practice, this means that almost every training example still contains highly informative regions.
+
+
+Our key idea is to instead **control the maximum information** available in each sample. Concretely, we first sample a maximum timestep and then restrict all patch-wise timesteps to lie below it. This prevents any region from becoming too clean during training and ensures that the model consistently operates in regimes that match inference.
+
+With this simple change, heterogeneous patch-wise denoising works! Even without any adaptive sampling at inference, this training strategy already improves generation quality over standard diffusion models with uniform timesteps.
+
+
+### Inference
+
+To fully leverage patch-wise denoising at inference, we need to decide **which regions should be denoised faster** and **which require more refinement**. For this, we augment the model with a lightweight uncertainty (difficulty) head that predicts, for each patch, how reliable the current denoising velocity prediction is.
+
+<p align="center">
+<img src="assets/uncertainty.png" alt="Uncertainty" width="40%">
+</p>
+
+With heterogeneous denoising and the uncertainty head, we base our adaptive samplers on three key findings:
+
+- **context helps denoising** $\rightarrow$ advancing confident (easy) regions provides cleaner context that improves predictions in harder regions
+- **uncertainty reflects patch difficulty** $\rightarrow$ higher uncertainty correlates with higher validation loss
+- **more context reduces uncertainty** $\rightarrow$ cleaner neighboring regions make difficult patches easier to denoise
+
+These findings naturally lead to adaptive sampling strategies that allocate compute where it is most useful. Instead of denoising all patches uniformly, we use the predicted uncertainty to guide the process: easy regions are advanced more aggressively, while difficult ones receive additional refinement.
+
+
+<p align="center">
+<img src="assets/denoising-schedule-performance.png" alt="ImageNet Results" width="100%">
+</p>
+
+- The **dual-loop** sampler alternates between quickly advancing confident patches and refining uncertain ones with smaller steps.
+- The **look-ahead** sampler goes one step further by explicitly advancing confident patches into the future and using their cleaner states as context for denoising harder regions.
+
+**Together, these strategies turn patch-wise heterogeneity into adaptive inference, improving generation quality under the same compute budget by focusing effort where it matters most.**
+
+
+Please refer to our paper for a more detailed description of our framework. 😉
+
+
+# 🛠️ Code Setup
+
+This codebase is based on Python `3.12` and the packages listed in `requirements.txt`.
+
+First, clone the repository:
+
+```bash
+git clone git@github.com:CompVis/patch-forcing.git
+cd patch-forcing
+```
+
+Then create the environment and install the dependencies:
+
+```bash
+conda create -n pft python=3.12
+conda activate pft
+pip install -r requirements.txt
+```
+
+If the default install fails on your machine, follow the safer install order noted in ?`requirements.txt`: install `torch` and `torchvision` first, then `flash-attn`, then the remaining requirements.
+
+We release two Patch Forcing checkpoints: [PFT-B](https://ommer-lab.com/files/pft/pft-b_step400k_ema.ckpt) and [PFT-XL](https://ommer-lab.com/files/pft/pft-xl_step400k_ema.ckpt). The checkpoints contain the EMA weights, as well as the model config.
+
+### Class-Conditional Generation
+
+#### Inference
+
+To generate class-conditional samples use:
+
+```bash
+python scripts/sample.py \
+  --ckpt /path/to/model.ckpt \
+  --sample-fn-config configs/sampler/dual-loop.yaml \
+  --num-sampling-steps 100 \
+  --cfg-scale 4.0
+  # ... you can add sampler specific args via dot-notation
+```
+
+For FID samples use `scripts/sample_ddp.py`:
+
+```bash
+torchrun --standalone --nproc_per_node=8 scripts/sample_ddp.py \
+  --ckpt /path/to/model.ckpt \
+  --sample-fn-config configs/sampler/euler-pf.yaml \
+  --per-proc-batch-size 64 \
+  --num-fid-samples 50000 \
+  --num-sampling-steps 100 \
+  --cfg-scale 1.0
+```
+
+If your checkpoint comes from training and does not already contain the compact `config` + `state_dict` format expected by the samplers, convert it first:
+
+```bash
+python scripts/convert_ckpt.py /path/to/training.ckpt
+```
+
+
+#### Training
+
+You can train new models via `train.py`. The repository is based on `hydra`, and the base config lives in `configs/config.yaml`. Experiments in `configs/experiment` overwrite this base config. Use CLI overrides to swap configs or change individual fields, for example `python train.py experiment=imnet-pft-b name=imnet/my-run data=dummy256 train_params.max_steps=10000`.
+
+To directly use the ImageNet-256 webdataset file, configure the ImageNet-256 shard locations in `configs/data/imagenet256.yaml`.
+For debugging, use you can use `configs/data/dummy256.yaml`.
+
+Train the main class-conditional experiments with:
+
+```bash
+python train.py experiment=imnet-pft-b
+python train.py experiment=imnet-pft-xl
+```
+
+If you want to use your own dataloader, make sure it returns a dictionary with `image` (bchw tensor normalized to $[-1, 1]$) and `label`.
+
+### Text-to-Image
+
+For text-to-image training, first fill in the gaps in `configs/data/t2i-256.yaml` and then you can train them with
+
+```bash
+python train.py experiment=t2i-pft1.2b-qwen
+```
+
+The batch should contain a dict with `image`, text (set corresponding text key in trainer), and `img_meta` if you want to include crop size conditioning via RoPE (see `patch_flow/data_utils.py` for more info). The default loader uses random caption sampling (as we used multiple caption lengths during training).
+
+You can use `scripts/t2i_sample.py` to sample images based on a text prompt.
+
+
+## 🎓 Citation
+
+If you use our work in your research, please use the following BibTeX entry. 🙂
+
+```bibtex
+@InProceedings{schusterbauer2025patchforcing,
+      title={Denoising, Fast and Slow: Difficulty-Aware Adaptive Sampling for Image Generation},
+      author={Johannes Schusterbauer and Ming Gui and Yusong Li and Pingchuan Ma and Felix Krause and Björn Ommer},
+      booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition},
+      year={2026}
+}
+```

patch-forcing/checkpoints/pft-b_step400k_ema.ckpt

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

patch-forcing/checkpoints/sd_ae.ckpt

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

patch-forcing/checkpoints/sd_ae_full.ckpt

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

patch-forcing/configs/autoencoder/flux2_ae.yaml

@@ -0,0 +1,4 @@
+name: FLUX2AutoencoderKL
+target: jutils.nn.ae_flux2.FLUX2AutoencoderKL      # first stage model (KL-Autoencoder from FLUX.2)
+params:
+  ckpt_path: checkpoints/flux2_ae.ckpt

patch-forcing/configs/autoencoder/sd_ae.yaml

@@ -0,0 +1,4 @@
+name: AutoencoderKL
+target: jutils.nn.kl_autoencoder.AutoencoderKL      # first stage model (KL-Autoencoder from LDM)
+params:
+  ckpt_path: checkpoints/sd_ae.ckpt

patch-forcing/configs/autoencoder/tiny_ae.yaml

@@ -0,0 +1,6 @@
+name: TinyAutoencoderKL
+target: jutils.nn.tiny_autoencoder.TinyAutoencoderKL
+params:
+  encoder_path: checkpoints/taesd_encoder.pth
+  decoder_path: checkpoints/taesd_decoder.pth
+  latent_channels: 4

patch-forcing/configs/config.yaml

@@ -0,0 +1,93 @@
+defaults:
+  - _self_
+  - model: dit-b
+  - data: dummy256    # dummy data
+  - autoencoder: tiny_ae
+  - lr_scheduler: null
+  - trainer: flow
+  - experiment: null    # must be last in defaults list as it can override all others
+
+  # disable hydra logging
+  - override hydra/hydra_logging: disabled
+  - override hydra/job_logging: disabled
+  
+# ----------------------------------------
+name: debug/your_exp
+
+# ----------------------------------------
+# logging
+use_wandb: False
+use_wandb_offline: False
+wandb_project: patch-forcing
+
+tags: []
+
+# checkpoint loading
+load_weights: null
+load_strict: True
+# resume_step: 0    # can be used for load_weights to specify step (not required for resume_checkpoint)
+resume_checkpoint: null
+
+# checkpoint saving (lightning callback)
+checkpoint_params:              # filename refers to number of gradient updates
+    every_n_train_steps: 10000  # gradient update steps
+    save_top_k: -1              # needs to be -1, otherwise it overwrites
+    verbose: True
+    save_last: True
+    auto_insert_metric_name: False
+
+# ----------------------------------------
+train_params:
+  max_steps: -1
+  max_epochs: -1
+  num_sanity_val_steps: 0
+  accumulate_grad_batches: 1
+  log_every_n_steps: 1        # gradient update steps
+  limit_val_batches: 8        # per GPU
+  val_check_interval: 5000    # steps, regardless of gradient accumulation
+  precision: bf16-mixed
+  clip_grad_norm: 1.0
+
+callbacks:
+  - target: lightning.pytorch.callbacks.LearningRateMonitor
+    params:
+      logging_interval: 'step'
+
+# ----------------------------------------
+# profiling
+profile: false
+profiling:
+  warmup: 40
+  active: 1
+  filename: profile.json
+  cpu: true
+  cuda: true
+  record_shapes: false
+  profile_memory: false
+  with_flops: false
+
+# ----------------------------------------
+# distributed
+num_nodes: 1
+devices: -1
+auto_requeue: False
+tqdm_refresh_rate: 1        # set higher on slurm (otherwise prints tqdm every step)
+deepspeed_stage: 0
+p2p_disable: False
+slurm_id: null
+cuda_prefetch: False
+cuda_prefetch_factor: 2
+ddp_kwargs:
+  find_unused_parameters: False   # default: False
+  gradient_as_bucket_view: True   # default: False
+  bucket_cap_mb: 100              # default: 25
+  broadcast_buffers: True         # default: True
+
+# ----------------------------------------
+user: ${oc.env:USER}
+
+# don't log and save files
+hydra:
+  output_subdir: null
+  run:
+    dir: .

patch-forcing/configs/data/dummy256.yaml

@@ -0,0 +1,17 @@
+name: Dummy_256
+num_classes: 1000
+target: patch_flow.dataloader.DataModuleFromConfig
+params:
+  batch_size: 16
+  num_workers: 4
+  train:
+    target: patch_flow.dataloader.DummyDataset
+    params:
+      image: [3, 256, 256]
+      label: [1]
+
+  validation:
+    target: patch_flow.dataloader.DummyDataset
+    params:
+      image: [3, 256, 256]
+      label: [1]

patch-forcing/configs/data/imagenet256.yaml

@@ -0,0 +1,44 @@
+name: ImageNet_256px
+num_classes: 1000
+target: patch_flow.dataloader.WebDataModuleFromConfig
+params:
+  tar_base: ...   # TODO: add path to tar files: path/to/tars
+  batch_size: 32
+  num_workers: 4
+  val_num_workers: 1
+  multinode: True
+  train:
+    shards: ...   # TODO: add shards like this: 'train/{000000..999999}.tar'
+    shuffle: 100
+    image_key: jpeg
+    rename:
+      image: jpeg
+      label: cls
+    image_transforms:
+      - target: torchvision.transforms.RandomHorizontalFlip
+        params:
+          p: 0.5
+      - target: torchvision.transforms.Resize
+        params:
+          size: 256
+          interpolation: 2
+          antialias: True
+      - target: torchvision.transforms.CenterCrop
+        params:
+          size: 256
+
+  validation:
+    shards: ...   # TODO: validation shards:'val/{000000..000100}.tar'
+    image_key: jpeg
+    rename:
+      image: jpeg
+      label: cls
+    image_transforms:
+      - target: torchvision.transforms.Resize
+        params:
+          size: 256
+          interpolation: 2
+          antialias: True
+      - target: torchvision.transforms.CenterCrop
+        params:
+          size: 256

patch-forcing/configs/data/t2i-256.yaml

@@ -0,0 +1,51 @@
+target: patch_flow.dataloader.WebDataModuleFromConfig
+params:
+  tar_base: ...   # TODO: add path to tar files: path/to/tars
+  batch_size: 8
+  num_workers: 8
+  val_batch_size: 16
+  val_num_workers: 1
+  multinode: True
+
+  train:
+    shards: ...   # TODO: add shards like this: 'train/{000000..999999}.tar'
+    shuffle: 100
+    image_key: jpg
+    rename:
+      image: jpg
+    dataset_transforms:
+      target: patch_flow.data_utils.TransformComposer
+      params:
+        transforms:
+          # crop-size conditioning via RoPE
+          - target: patch_flow.data_utils.ResizeCropWithMetaInfo
+            params:
+              size: 256
+              img_key: image
+              meta_key: img_meta
+          # if available, caption sampling with probs per caption type/length
+          - target: patch_flow.data_utils.CaptionSampler
+            params:
+              out_txt_key: txt
+              txt_sampling_cfg:
+                txt: 1
+                long: 2
+                medium: 3
+                short: 4
+                keywords: 2
+
+  validation:
+    shards: ...   # TODO: validation shards:'val/{000000..000100}.tar'
+    image_key: jpg
+    rename:
+      image: jpg
+      txt: medium  # use medium caption for val
+    image_transforms:
+      - target: torchvision.transforms.Resize
+        params:
+          size: 256
+          interpolation: 2
+          antialias: True
+      - target: torchvision.transforms.CenterCrop
+        params:
+          size: 256

patch-forcing/configs/experiment/imnet-dit-b.yaml

@@ -0,0 +1,24 @@
+# @package _global_
+defaults:
+  - override /trainer: flow
+  - override /data: imagenet256
+  - override /model: dit-b
+  - override /autoencoder: sd_ae
+  - override /lr_scheduler: constant
+
+name: debug/imnet256/dit-b
+
+model:
+  params:
+    compile: true
+
+data:
+  params:
+    batch_size: 64
+    val_batch_size: 32
+
+train_params:
+  max_steps: 400000
+  limit_val_batches: 40
+  val_check_interval: 10000
+  precision: bf16-mixed

patch-forcing/configs/experiment/imnet-dit-b_lognorm.yaml

@@ -0,0 +1,34 @@
+# @package _global_
+defaults:
+  - override /trainer: flow
+  - override /data: imagenet256
+  - override /model: dit-b
+  - override /autoencoder: sd_ae
+  - override /lr_scheduler: constant
+
+name: debug/imnet256/dit-b/lognorm/l0.0_s1.0
+
+model:
+  params:
+    compile: true
+
+trainer:
+  params:
+    flow:
+      params:
+        timestep_sampler:
+          target: patch_flow.flow.LogitNormalSampler
+          params:
+            loc: 0.0
+            scale: 1.0
+
+data:
+  params:
+    batch_size: 64
+    val_batch_size: 32
+
+train_params:
+  max_steps: 400000
+  limit_val_batches: 40
+  val_check_interval: 10000
+  precision: bf16-mixed

patch-forcing/configs/experiment/imnet-dit-xl.yaml

@@ -0,0 +1,24 @@
+# @package _global_
+defaults:
+  - override /trainer: flow
+  - override /data: imagenet256
+  - override /model: dit-xl
+  - override /autoencoder: sd_ae
+  - override /lr_scheduler: constant
+
+name: debug/imnet256/dit-xl
+
+model:
+  params:
+    compile: true
+
+data:
+  params:
+    batch_size: 32
+    val_batch_size: 32
+
+train_params:
+  max_steps: 400000
+  limit_val_batches: 40
+  val_check_interval: 10000
+  precision: bf16-mixed

patch-forcing/configs/experiment/imnet-dit-xl_lognorm.yaml

@@ -0,0 +1,34 @@
+# @package _global_
+defaults:
+  - override /trainer: flow
+  - override /data: imagenet256
+  - override /model: dit-xl
+  - override /autoencoder: sd_ae
+  - override /lr_scheduler: constant
+
+name: debug/imnet256/dit-xl/lognorm/l0.0_s1.0
+
+model:
+  params:
+    compile: true
+
+trainer:
+  params:
+    flow:
+      params:
+        timestep_sampler:
+          target: patch_flow.flow.LogitNormalSampler
+          params:
+            loc: 0.0
+            scale: 1.0
+
+data:
+  params:
+    batch_size: 32
+    val_batch_size: 32
+
+train_params:
+  max_steps: 400000
+  limit_val_batches: 40
+  val_check_interval: 10000
+  precision: bf16-mixed

patch-forcing/configs/experiment/imnet-pft-b.yaml

@@ -0,0 +1,24 @@
+# @package _global_
+defaults:
+  - override /trainer: patch_flow
+  - override /data: imagenet256
+  - override /model: pft-b
+  - override /autoencoder: sd_ae
+  - override /lr_scheduler: constant
+
+name: debug/imnet256/pft-b
+
+model:
+  params:
+    compile: true
+
+data:
+  params:
+    batch_size: 64
+    val_batch_size: 32
+
+train_params:
+  max_steps: 400000
+  limit_val_batches: 40
+  val_check_interval: 10000
+  precision: bf16-mixed

patch-forcing/configs/experiment/imnet-pft-xl.yaml

@@ -0,0 +1,24 @@
+# @package _global_
+defaults:
+  - override /trainer: patch_flow
+  - override /data: imagenet256
+  - override /model: pft-xl
+  - override /autoencoder: sd_ae
+  - override /lr_scheduler: constant
+
+name: debug/imnet256/pft-xl
+
+model:
+  params:
+    compile: true
+
+data:
+  params:
+    batch_size: 32
+    val_batch_size: 32
+
+train_params:
+  max_steps: 400000
+  limit_val_batches: 40
+  val_check_interval: 10000
+  precision: bf16-mixed

patch-forcing/configs/experiment/t2i-pft1.2b-qwen.yaml

@@ -0,0 +1,34 @@
+# @package _global_
+defaults:
+  - override /trainer: patch_flow_t2i
+  - override /data: t2i-256   # change to your data config
+  - override /model: t2i-pft-1.2b
+  - override /autoencoder: flux2_ae
+  - override /lr_scheduler: constant
+
+name: debug/t2i/coyo/qwen2b/pf-1.2b
+
+compile: true
+
+data:
+  params:
+    batch_size: 32
+    val_batch_size: 32
+    num_workers: 8
+
+model:
+  params:
+    in_dim: 32      # must match latent space dim
+    compile: ${compile}
+
+trainer:
+  params:
+    text_encoder:
+      params:
+        compile: ${compile}
+
+train_params:
+  max_steps: 400000
+  limit_val_batches: 10
+  val_check_interval: 10000
+  precision: bf16-mixed

patch-forcing/configs/lr_scheduler/constant.yaml

@@ -0,0 +1,4 @@
+name: constant
+target: jutils.nn.lr_schedulers.get_constant_schedule_with_warmup
+params:
+  num_warmup_steps: 1000

patch-forcing/configs/lr_scheduler/cosine.yaml

@@ -0,0 +1,6 @@
+name: cosine
+target: jutils.nn.lr_schedulers.get_cosine_schedule_with_warmup
+params:
+  num_warmup_steps: 1000
+  num_training_steps: 100000
+  num_cycles: 0.5

patch-forcing/configs/lr_scheduler/exp.yaml

@@ -0,0 +1,10 @@
+# Warmup-Stable-Decay (WSD) learning rate schedule according to the paper:
+# 'MiniCPM: Unveiling the Potential of Small Language Models with Scalable Training Strategies'
+# - Hu et al. (2024)
+# Max training steps in WSD annealing phase: 3 * t_decay
+# t_decay should be ~2% of the previous training steps with constant lr
+name: exponential
+target: jutils.nn.lr_schedulers.get_exponential_decay_schedule
+params:
+  num_warmup_steps: 0
+  t_decay: 2000

patch-forcing/configs/lr_scheduler/iter_exp.yaml

@@ -0,0 +1,6 @@
+name: iter_exponential
+target: jutils.nn.lr_schedulers.get_iter_exponential_schedule
+params:
+  num_warmup_steps: 1000
+  num_training_steps: 100000
+  final_ratio: 0.05

patch-forcing/configs/model/dit-b.yaml

@@ -0,0 +1,10 @@
+target: patch_flow.models.dit.DiT
+params:
+  in_channels: 4
+  input_size: 32
+  depth: 12
+  hidden_size: 768
+  patch_size: 2
+  num_heads: 12
+  num_classes: 1000
+  compile: true

patch-forcing/configs/model/dit-xl.yaml

@@ -0,0 +1,10 @@
+target: patch_flow.models.dit.DiT
+params:
+  in_channels: 4
+  input_size: 32
+  depth: 28
+  hidden_size: 1152
+  patch_size: 2
+  num_heads: 16
+  num_classes: 1000
+  compile: true

patch-forcing/configs/model/pft-b.yaml

@@ -0,0 +1,11 @@
+target: patch_flow.models.pf_transformer.PatchForcingDiT
+params:
+  in_channels: 4
+  input_size: 32
+  depth: 12
+  hidden_size: 768
+  patch_size: 2
+  num_heads: 12
+  num_classes: 1000
+  compile: true
+  predict_uncertainty: true

patch-forcing/configs/model/pft-xl.yaml

@@ -0,0 +1,11 @@
+target: patch_flow.models.pf_transformer.PatchForcingDiT
+params:
+  in_channels: 4
+  input_size: 32
+  depth: 28
+  hidden_size: 1152
+  patch_size: 2
+  num_heads: 16
+  num_classes: 1000
+  compile: true
+  predict_uncertainty: true

patch-forcing/configs/model/t2i-pft-1.2b.yaml

@@ -0,0 +1,16 @@
+# params: 1,239,969,008
+target: patch_flow.models.pf_transformer_t2i.PatchForcingTransformerT2I
+params:
+  in_dim: 4
+  depth: 28
+  hidden_dim: 1536
+  head_dim: 96      # 16 heads
+  mapping_dim: 384
+  mapping_depth: 2
+  patch_size: 2
+  # text things
+  txt_in_dim: 2048    # must match text encoder output dim!
+  txt_refiner_dim: 1536
+  txt_refiner_head_dim: 128   # 12 heads
+  txt_refiner_depth: 2  
+  compile: false

patch-forcing/configs/sampler/dual-loop.yaml

@@ -0,0 +1,5 @@
+target: patch_flow.integrators.DualLoopSampler
+params:
+  p: 0.4
+  n_inner: 4
+  patch_size: 2

patch-forcing/configs/sampler/euler-pf.yaml

@@ -0,0 +1,2 @@
+target: patch_flow.integrators.EulerPF
+params: {}

patch-forcing/configs/sampler/euler.yaml

@@ -0,0 +1,2 @@
+target: patch_flow.integrators.Euler
+params: {}

patch-forcing/configs/sampler/look-ahead.yaml

@@ -0,0 +1,5 @@
+target: patch_flow.integrators.LookAheadSampler
+params:
+  p: 0.4
+  patch_size: 2
+  context_t_ratio: 1.4

patch-forcing/configs/trainer/flow.yaml

@@ -0,0 +1,19 @@
+target: patch_flow.trainer.LatentFlowTrainer
+params:
+  model: ${oc.select:model, null}
+  first_stage: ${oc.select:autoencoder, null}
+  flow:
+    target: patch_flow.flow.Flow
+    params:
+      timestep_sampler: null
+
+  # learning
+  lr: 1e-4
+  weight_decay: 0.0
+  ema_rate: 0.9999
+  lr_scheduler_cfg: ${oc.select:lr_scheduler, null}
+
+  # sampling
+  sample_kwargs:
+    num_steps: 50
+    progress: False

patch-forcing/configs/trainer/patch_flow.yaml

@@ -0,0 +1,28 @@
+target: patch_flow.trainer.LatentPatchForcingTrainer
+
+params:
+  model: ${oc.select:model, null}
+  first_stage: ${oc.select:autoencoder, null}
+  
+  # patch flow forcing
+  flow:
+    target: patch_flow.flow_pf.PatchFlowForcing
+    params:
+      patch_size: 2
+      timestep_sampler:
+        target: patch_flow.timestep_schedules.LogitNormalTruncatedGaussian
+        params:
+          std: 0.6
+          loc: 0.7
+          scale: 1.0
+
+  # learning
+  lr: 1e-4
+  weight_decay: 0.0
+  ema_rate: 0.9999
+  lr_scheduler_cfg: ${oc.select:lr_scheduler, null}
+
+  # sampling
+  sample_kwargs:
+    num_steps: 50
+    progress: False

patch-forcing/configs/trainer/patch_flow_t2i.yaml

@@ -0,0 +1,38 @@
+target: patch_flow.trainer_t2i.PatchForcingT2ITrainer
+
+params:
+  model: ${oc.select:model, null}
+  first_stage: ${oc.select:autoencoder, null}
+  
+  # patch flow forcing
+  flow:
+    target: patch_flow.flow_pf.PatchFlowForcing
+    params:
+      patch_size: 2
+      timestep_sampler:
+        target: patch_flow.timestep_schedules.LogitNormalTruncatedGaussian
+        params:
+          std: 0.6
+          loc: 0.5
+          scale: 1.0
+
+  # text conditioning
+  text_encoder:
+    target: patch_flow.text_encoder.Qwen3VLEmbedder2B
+    params:
+      compile: true
+  text_dropout_prob: 0.1
+  text_key: txt
+  
+  # learning
+  lr: 1e-4
+  weight_decay: 0.0
+  ema_rate: 0.9999
+  lr_scheduler_cfg: ${oc.select:lr_scheduler, null}
+  rope_jittering: true
+  uncertainty_weight: 0.01
+
+  # sampling
+  sample_kwargs:
+    num_steps: 50
+    progress: False

patch-forcing/logs/debug/train-official/2026-04-22/T230557/events.out.tfevents.1776870357.hk01dgx015.877147.0

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

patch-forcing/logs/debug/train-official/2026-04-22/T230729/events.out.tfevents.1776870449.hk01dgx015.885834.0

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

patch-forcing/logs/debug/train-official/2026-04-22/T230841/events.out.tfevents.1776870521.hk01dgx015.890508.0

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

patch-forcing/logs/debug/train-official/2026-04-22/T230921/config.yaml

@@ -0,0 +1,164 @@
+name: debug/train-official
+use_wandb: false
+use_wandb_offline: false
+wandb_project: patch-forcing
+tags: []
+load_weights: null
+load_strict: true
+resume_checkpoint: null
+checkpoint_params:
+  every_n_train_steps: 10000
+  save_top_k: -1
+  verbose: true
+  save_last: true
+  auto_insert_metric_name: false
+train_params:
+  max_steps: 1
+  max_epochs: -1
+  num_sanity_val_steps: 0
+  accumulate_grad_batches: 1
+  log_every_n_steps: 1
+  limit_val_batches: 0
+  val_check_interval: 10000
+  precision: bf16-mixed
+  clip_grad_norm: 1.0
+callbacks:
+- target: lightning.pytorch.callbacks.LearningRateMonitor
+  params:
+    logging_interval: step
+profile: false
+profiling:
+  warmup: 40
+  active: 1
+  filename: profile.json
+  cpu: true
+  cuda: true
+  record_shapes: false
+  profile_memory: false
+  with_flops: false
+num_nodes: 1
+devices: -1
+auto_requeue: false
+tqdm_refresh_rate: 1
+deepspeed_stage: 0
+p2p_disable: false
+slurm_id: null
+cuda_prefetch: false
+cuda_prefetch_factor: 2
+ddp_kwargs:
+  find_unused_parameters: false
+  gradient_as_bucket_view: true
+  bucket_cap_mb: 100
+  broadcast_buffers: true
+user: dyvm6xrauser11
+model:
+  target: patch_flow.models.pf_transformer.PatchForcingDiT
+  params:
+    in_channels: 4
+    input_size: 32
+    depth: 12
+    hidden_size: 768
+    patch_size: 2
+    num_heads: 12
+    num_classes: 1000
+    compile: false
+    predict_uncertainty: true
+data:
+  name: Dummy_256
+  num_classes: 1000
+  target: patch_flow.dataloader.DataModuleFromConfig
+  params:
+    batch_size: 2
+    num_workers: 0
+    train:
+      target: patch_flow.dataloader.DummyDataset
+      params:
+        image:
+        - 3
+        - 256
+        - 256
+        label:
+        - 1
+    validation:
+      target: patch_flow.dataloader.DummyDataset
+      params:
+        image:
+        - 3
+        - 256
+        - 256
+        label:
+        - 1
+    val_batch_size: 32
+autoencoder:
+  name: AutoencoderKL
+  target: jutils.nn.kl_autoencoder.AutoencoderKL
+  params:
+    ckpt_path: checkpoints/sd_ae.ckpt
+lr_scheduler:
+  name: constant
+  target: jutils.nn.lr_schedulers.get_constant_schedule_with_warmup
+  params:
+    num_warmup_steps: 1000
+trainer:
+  target: patch_flow.trainer.LatentPatchForcingTrainer
+  params:
+    model:
+      target: patch_flow.models.pf_transformer.PatchForcingDiT
+      params:
+        in_channels: 4
+        input_size: 32
+        depth: 12
+        hidden_size: 768
+        patch_size: 2
+        num_heads: 12
+        num_classes: 1000
+        compile: false
+        predict_uncertainty: true
+    first_stage:
+      name: AutoencoderKL
+      target: jutils.nn.kl_autoencoder.AutoencoderKL
+      params:
+        ckpt_path: checkpoints/sd_ae.ckpt
+    flow:
+      target: patch_flow.flow_pf.PatchFlowForcing
+      params:
+        patch_size: 2
+        timestep_sampler:
+          target: patch_flow.timestep_schedules.LogitNormalTruncatedGaussian
+          params:
+            std: 0.6
+            loc: 0.7
+            scale: 1.0
+    lr: 0.0001
+    weight_decay: 0.0
+    ema_rate: 0.9999
+    lr_scheduler_cfg:
+      name: constant
+      target: jutils.nn.lr_schedulers.get_constant_schedule_with_warmup
+      params:
+        num_warmup_steps: 1000
+    sample_kwargs:
+      num_steps: 50
+      progress: false
+
+
+# ----------------------------------------
+# Command         : python train.py experiment=imnet-pft-b data=dummy256 autoencoder=sd_ae model.params.compile=false train_params.max_steps=1 train_params.limit_val_batches=0 data.params.batch_size=2 data.params.num_workers=0 name=debug/train-official
+# Name            : debug/train-official/2026-04-22/T230921
+# Log dir         : logs/debug/train-official/2026-04-22/T230921
+# Trainer Module  : patch_flow.trainer.LatentPatchForcingTrainer
+# Params          : 130,306,580
+# Data            : Dummy_256
+# Batchsize       : 2
+# Devices         : 1
+# Num nodes       : 1
+# Gradient accum  : 1
+# Global batchsize: 2
+# Val samples     : 0
+# LR              : 0.00010
+# LR scheduler    : constant
+# Resume ckpt     : None
+# Load weights    : None
+# Profiling       : None
+# Precision       : bf16-mixed
+# ----------------------------------------

patch-forcing/logs/debug/train-official/2026-04-22/T230921/events.out.tfevents.1776870561.hk01dgx015.893414.0

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

patch-forcing/logs/debug/train-official/2026-04-22/T231137/config.yaml

@@ -0,0 +1,164 @@
+name: debug/train-official
+use_wandb: false
+use_wandb_offline: false
+wandb_project: patch-forcing
+tags: []
+load_weights: null
+load_strict: true
+resume_checkpoint: null
+checkpoint_params:
+  every_n_train_steps: 10000
+  save_top_k: -1
+  verbose: true
+  save_last: true
+  auto_insert_metric_name: false
+train_params:
+  max_steps: 1
+  max_epochs: -1
+  num_sanity_val_steps: 0
+  accumulate_grad_batches: 1
+  log_every_n_steps: 1
+  limit_val_batches: 0
+  val_check_interval: 1000
+  precision: bf16-mixed
+  clip_grad_norm: 1.0
+callbacks:
+- target: lightning.pytorch.callbacks.LearningRateMonitor
+  params:
+    logging_interval: step
+profile: false
+profiling:
+  warmup: 40
+  active: 1
+  filename: profile.json
+  cpu: true
+  cuda: true
+  record_shapes: false
+  profile_memory: false
+  with_flops: false
+num_nodes: 1
+devices: -1
+auto_requeue: false
+tqdm_refresh_rate: 1
+deepspeed_stage: 0
+p2p_disable: false
+slurm_id: null
+cuda_prefetch: false
+cuda_prefetch_factor: 2
+ddp_kwargs:
+  find_unused_parameters: false
+  gradient_as_bucket_view: true
+  bucket_cap_mb: 100
+  broadcast_buffers: true
+user: dyvm6xrauser11
+model:
+  target: patch_flow.models.pf_transformer.PatchForcingDiT
+  params:
+    in_channels: 4
+    input_size: 32
+    depth: 12
+    hidden_size: 768
+    patch_size: 2
+    num_heads: 12
+    num_classes: 1000
+    compile: false
+    predict_uncertainty: true
+data:
+  name: Dummy_256
+  num_classes: 1000
+  target: patch_flow.dataloader.DataModuleFromConfig
+  params:
+    batch_size: 2
+    num_workers: 0
+    train:
+      target: patch_flow.dataloader.DummyDataset
+      params:
+        image:
+        - 3
+        - 256
+        - 256
+        label:
+        - 1
+    validation:
+      target: patch_flow.dataloader.DummyDataset
+      params:
+        image:
+        - 3
+        - 256
+        - 256
+        label:
+        - 1
+    val_batch_size: 32
+autoencoder:
+  name: AutoencoderKL
+  target: jutils.nn.kl_autoencoder.AutoencoderKL
+  params:
+    ckpt_path: checkpoints/sd_ae.ckpt
+lr_scheduler:
+  name: constant
+  target: jutils.nn.lr_schedulers.get_constant_schedule_with_warmup
+  params:
+    num_warmup_steps: 1000
+trainer:
+  target: patch_flow.trainer.LatentPatchForcingTrainer
+  params:
+    model:
+      target: patch_flow.models.pf_transformer.PatchForcingDiT
+      params:
+        in_channels: 4
+        input_size: 32
+        depth: 12
+        hidden_size: 768
+        patch_size: 2
+        num_heads: 12
+        num_classes: 1000
+        compile: false
+        predict_uncertainty: true
+    first_stage:
+      name: AutoencoderKL
+      target: jutils.nn.kl_autoencoder.AutoencoderKL
+      params:
+        ckpt_path: checkpoints/sd_ae.ckpt
+    flow:
+      target: patch_flow.flow_pf.PatchFlowForcing
+      params:
+        patch_size: 2
+        timestep_sampler:
+          target: patch_flow.timestep_schedules.LogitNormalTruncatedGaussian
+          params:
+            std: 0.6
+            loc: 0.7
+            scale: 1.0
+    lr: 0.0001
+    weight_decay: 0.0
+    ema_rate: 0.9999
+    lr_scheduler_cfg:
+      name: constant
+      target: jutils.nn.lr_schedulers.get_constant_schedule_with_warmup
+      params:
+        num_warmup_steps: 1000
+    sample_kwargs:
+      num_steps: 50
+      progress: false
+
+
+# ----------------------------------------
+# Command         : python train.py experiment=imnet-pft-b data=dummy256 autoencoder=sd_ae model.params.compile=false train_params.max_steps=100 train_params.val_check_interval=1000 train_params.limit_val_batches=0 data.params.batch_size=4 data.params.num_workers=0 name=debug/train-official train_params.max_steps=1 train_params.limit_val_batches=0 data.params.batch_size=2
+# Name            : debug/train-official/2026-04-22/T231137
+# Log dir         : logs/debug/train-official/2026-04-22/T231137
+# Trainer Module  : patch_flow.trainer.LatentPatchForcingTrainer
+# Params          : 130,306,580
+# Data            : Dummy_256
+# Batchsize       : 2
+# Devices         : 1
+# Num nodes       : 1
+# Gradient accum  : 1
+# Global batchsize: 2
+# Val samples     : 0
+# LR              : 0.00010
+# LR scheduler    : constant
+# Resume ckpt     : None
+# Load weights    : None
+# Profiling       : None
+# Precision       : bf16-mixed
+# ----------------------------------------

patch-forcing/logs/debug/train-official/2026-04-22/T231137/events.out.tfevents.1776870697.hk01dgx015.903650.0

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

patch-forcing/patch_flow/__init__.py

@@ -0,0 +1,6 @@
+import os
+import sys
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from omegaconf import OmegaConf
+OmegaConf.register_new_resolver("mul", lambda a, b: a * b)