Keshigeyan Chandrasegaran^*1,2,  Michael Poli^*1,2, Daniel Y. Fu^3,4, Dongjun Kim¹,
Lea M. Hadzic¹, Manling Li^1,5, Agrim Gupta⁶, Stefano Massaroli^2,7,
 Azalia Mirhoseini¹,  Juan Carlos Niebles^†1,8,  Stefano Ermon^†1,  Li Fei-Fei^†1
1 Stanford University   ² Liquid AI   ³ Together AI   ⁴ UC San Diego  
⁵ Northwestern University   ⁶ Google DeepMind   ⁷ RIKEN   ⁸ Salesforce Research  
^* Equal contribution, ^† Equal senior authorship
NeurIPS 2025 Oral
🌎Website | 🤗 Grafted Models | 📄 arXiv | ✍️ Blog

• [2026-01-07]: Training/ Evaluation code released
• [2025-06-10]: Grafting codebase released

Designing model architectures requires decisions such as selecting operators (e.g., attention, convolution) and configurations (e.g., depth, width). However, evaluating the impact of these decisions on model quality requires costly pretraining, limiting architectural investigation. Inspired by how new software is built on existing code, we ask: can new architecture designs be studied using pretrained models? To this end, we present grafting, a simple approach for editing pretrained diffusion transformers (DiTs) to materialize new architectures under small compute budgets. Informed by our analysis of activation behavior and attention locality, we construct a testbed based on the DiT-XL/2 design to study the impact of grafting on model quality. Using this testbed, we develop a family of hybrid designs via grafting: replacing softmax attention with gated convolution, local attention, and linear attention, and replacing MLPs with variable expansion ratio and convolutional variants. Notably, many hybrid designs achieve good quality (FID: 2.38-2.64 vs. 2.27 for DiT-XL/2) using <2% pretraining compute. We then graft a text-to-image model (PixArt-Sigma), achieving a 1.43x speedup with less than a 2% drop in GenEval score. Finally, we present a case study that restructures DiT-XL/2 by converting every pair of sequential transformer blocks into parallel blocks via grafting. This reduces model depth by 2x and yields better quality (FID: 2.77) than other models of comparable depth. Together, we show that new diffusion model designs can be explored by grafting pretrained DiTs, with edits ranging from operator replacement to architecture restructuring.

The Grafting codebase is written in Pytorch and provides a simple implementation for grafting Diffusion Transformers (DiTs).

We provide 22 grafted models for ImageNet-1K 256×256 generation.

Start generating samples using our grafted models (See demo_notebooks/grafting_demo.ipynb)

This guide describes the complete training pipeline for grafting on the ImageNet-1K dataset. The pipeline is modular and can be adapted to different operators, layers and resolutions as needed. All the results reported in the paper can be reproduced using this codebase. All experiments are specified via YAML config files. We provide Dockerfiles. For reference, we provide a step-by-step demo for replacing 3 Multi-Head Attention (MHA) operators in DiT-XL/2 with Hyena-Y operator:

1. Data preparation & feature extraction
2. Stage 1: Activation distillation
3. Stage 2: Lightweight fine-tuning
4. Sampling + FID evaluation

• Build Docker image: docker build -t grafting .

• (Optional) Create a persistent cache volume for downloading Hugging Face models: docker volume create huggingface_cache

• Run container (An example shown below):

  docker run --gpus all --ipc=host --ulimit memlock=-1 --ulimit stack=67108864 -v ~/keshik/workspace/projects/grafting:/workspace -v huggingface_cache:/home/user/.cache/huggingface -v ~/keshik/data:/data -it grafting /bin/bash

• Download ImageNet-1K dataset from here.

• Extract SD-VAE features for the ImageNet-1K dataset at 256×256:

  bash bash_scripts/imagenet_1k/extract_vae_fts.sh

• Expected output directory created: /data/vae_features/imagenet_256/train/

• Generates a stratified 128k ImageNet-1K subset (10% used in the paper) and saves image paths + SHA hash so the exact subset can be used across different experiments. This can be increased up to the full ImageNet size if required.

  bash bash_scripts/dit_imagenet_1k_256x256/generate_dataset_hash.sh

⚡Recommended 1× H100

Note: Extracted SD-VAE features for ImageNet-1K dataset can be downloaded from Hugging Face: sd_vae_features_imagenet_1k_256x256.

• Stage-1 requires intermediate DiT-XL/2 activations:

  bash bash_scripts/dit_imagenet_1k_256x256/extract_mha_scion_fts.sh

• Inside the script, users must manually set:

  • SPLIT=train for the training set

  • SPLIT=val for the validation set

• This produces:

  • /data/scion_fts_mha/train/

  • /data/scion_fts_mha/val/

⚡Recommended 1× H100

• Train replacement attention/MLP operators by distilling the extracted activations:

  bash bash_scripts/dit_imagenet_1k_256x256/train_stage1.sh

• Stage-1 trained operator checkpoints are saved under: ./results/

• Optional post Stage-1 sampling:

  bash bash_scripts/dit_imagenet_1k_256x256/sample_stage1.sh

⚡Recommended 1× H100 (You can run this in parallel for different layers)

• Perform end-to-end fine-tuning after activation distillation:

  bash bash_scripts/dit_imagenet_1k_256x256/train_stage2.sh

• Stage-1 trained operator checkpoints are saved under: ./results/

⚡Recommended 8× H100

• Generate samples from the fine-tuned model and save as .npz:

  bash bash_scripts/dit_imagenet_1k_256x256/sample_stage2.sh

• Then compute FID using OpenAI’s reference batch.Frist, install dependencies using the official requirements.txt, or use the Dockerfile at assets/tf_Dockerfile/Dockerfile for evaluation. Then run the following:

  cd ./external/guided_diffusion/evaluations/ && wget https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/imagenet/256/VIRTUAL_imagenet256_labeled.npz && python evaluator.py VIRTUAL_imagenet256_labeled.npz ./samples/demo/hyena_y_6_16_27.npz

⚡Recommended 8× H100

• Keshigeyan Chandrasegaran: keshik@stanford.edu
• Michael Poli: poli@stanford.edu

For issues, feedback, or contributions, please open an issue or submit a pull request.

We acknowledge the following works and libraries:

• Scalable Diffusion Models with Transformers (DiT): https://github.com/facebookresearch/DiT
• https://github.com/chuanyangjin/fast-DiT
• Convolutions for Sequence Modeling: https://github.com/HazyResearch/safari
• Mamba SSM architecture: https://github.com/state-spaces/mamba
• Causal depthwise conv1d in CUDA, with a PyTorch interface: https://github.com/Dao-AILab/causal-conv1d
• Experiment Tracking with Weights and Biases : https://www.wandb.com/

@article{chandrasegaran2025grafting,
      title={Exploring Diffusion Transformer Designs via Grafting},
      author={Chandrasegaran, Keshigeyan and Poli, Michael and Fu, Daniel Y. and Kim, Dongjun and 
      Hadzic, Lea M. and Li, Manling and Gupta, Agrim and Massaroli, Stefano and 
      Mirhoseini, Azalia and Niebles, Juan Carlos and Ermon, Stefano and Li, Fei-Fei},
      booktitle = {Advances in Neural Information Processing Systems},
      volume = {38}
      year={2025},
      url={https://arxiv.org/abs/2506.05340}, 
}