Excited to share that I’ll be attending the SIAM Conference on Uncertainty Quantification (UQ26) this year! 🎙️ At the conference, I will deliver an invited talk on Physics-Informed Posterior Sampling for Scientific Inverse Problems. Time: Tuesday 3 PM Link: Many scientific inverse problems ask us to reconstruct complex hidden fields from sparse, noisy observations. In these settings, a single best guess is often not enough. What we really need is a way to generate solutions that are both uncertainty-aware and faithful to the underlying physics. 💫 In this talk, I'll present a central message: Function-space diffusion can serve as a foundation for posterior sampling; decoupling prior and physics fixes the low-data bottleneck; and the resulting framework works in realistic scientific applications with verified posterior. I’m especially looking forward to sharing and learning new theories and advances. 🧸 If you’re attending UQ26, I would love to connect! #ScientificMachineLearning# #UncertaintyQuantification# #InverseProblems# #DiffusionModels# #PhysicsInformedAI# #BayesianInference# #MachineLearning#

🔁 Easy tokens and hard tokens get the exact same compute. That, this paper argues, is why diffusion language models still trail autoregressive ones. Title: ALoDLM: Adaptively Looped Diffusion Language Models URL: 📘 Overview It adds an inner loop to each denoising step so individual tokens can exit at different recurrent depths. Across eleven benchmarks it beats not just comparable diffusion models but the autoregressive baselines too. 🔥 The problem it solves Within a single denoising step, some masked positions are easy and others need real computation. Standard DLMs apply one fixed depth to every position, wasting compute on the easy ones and starving the hard ones. Confidence-based deferral only half-fixes this, since a deferred token's latent computation is thrown away and recomputed from its mask embedding next step. 🛠 Methodology The Transformer splits into a prelude, a recurrent core looped up to four times, and a coda. ・Tokens whose predictive entropy falls below a threshold commit, then feed back as discrete context ・Unresolved tokens keep their accumulated latent state and keep refining ・Halting probabilities accumulate until a threshold ends the inner loop Because each commit changes the context, summing over exit schedules exactly is intractable, so exit depths become latent variables trained via a variational bound with unbiased gradients. 📊 Results ・Average scores of 65.5 at 1.7B and 80.3 at 8B, past Qwen3's 63.8 and 78.5 ・On GSM8K, roughly 2.7x the throughput of vLLM-served Qwen3-8B at comparable or better accuracy ・Raising the exit threshold at inference lifts loops per token from 1.6 to 2.34 and average score from 77.9% to 79.1% ・With no difficulty labels at all, it learned to spend the deepest computation on numeric tokens #DiffusionModels# #LLM#

Ask for "a lizard wearing sunglasses" and you get either no sunglasses or a distorted lizard. Google just gave the control problem behind image generation a mathematical answer. Title: How Diffusion Controller unifies and simplifies AI image generation URL: 📝 Overview Diffusion Controller reframes image generation as a continuous control problem rather than a sequence of isolated steps. It keeps the base model frozen and adds a lightweight side network to steer its behavior. ❓ Problem Solved Inference-time guidance and heavy fine-tuning methods like LoRA sit in two disconnected camps with no unified mathematical principle, leaving engineers to guess their way through balancing preference alignment against image quality. 💡 Method & Approach The side network observes intermediate denoising states and injects tiny steering corrections without touching the model's internal weights. Two implementations — a policy-gradient (PPO) approach and a reward-weighted loss approach — both include guardrails against quality degradation. This design even lets you control closed-source models you can't otherwise access. 📊 Results On Stable Diffusion v1.4, Diffusion Controller outperformed LoRA across both SFT and RWL training tracks despite touching fewer layers, hit a 90% win rate over baseline in its fully unlocked version, and delivered the best subjective quality in human evaluation on complex prompts. #ImageGeneration# #DiffusionModels#

🎨 A text-to-image model trained entirely from scratch with a fully open recipe, closing in on top-tier model performance. Title: LLaDA-Image: Building Strong Image Generators with Fully Open Training Recipes URL: 🖼️ Overview LLaDA-Image trains a 6B-parameter Diffusion Transformer from scratch and pairs it with a dLLM-based vision-language understanding module in one unified generation-and-editing model. A TwinFlow-distilled Turbo version also ships, cutting inference down to just 2-4 sampling steps. 🧩 Problem Solved High-quality image generation has traditionally demanded massive paired image-text datasets, while inconsistent caption quality and the difficulty of unifying generation and editing in a single model remained open challenges. 🛠️ Methodology & Proposed Approach The recipe centers on image-only pretraining: over 90% of the 220M training samples are image-only, with real images making up 98% of generation-stage data and over 70% even during supervised fine-tuning — a deliberately "real-data-dominant" strategy. A parameter-free RMSNorm stabilizes long training runs, and an editing architecture conditions on reference images through both a semantic path and a pixel path. 📊 Use Cases / Experimental Results LLaDA-Image scores 53.53 on the English Qwen-Image-Bench track and 53.38 on Chinese, beating the leading open-source Z-Image Turbo (51.66 / 52.71). It also tops the long-text-rendering CVTG-2K benchmark with 0.875 word accuracy. On the flip side, GenEval's counting sub-task sits at just 0.53, a clearly flagged area for improvement. #ImageGeneration# #DiffusionModels#

⚙ SGLang Diffusion Is Retiring torch.compile, With Help From an AI Agent After testing 35 diffusion model presets on H100 and H200 GPUs, SGLang Diffusion found that eager execution now usually matches or outperforms torch.compile. Zhihu contributor BBuf argues that this is more than a benchmark result. Agent-written optimizations and Breakable CUDA Graphs can now replace the two main benefits that torch.compile once provided. 1️⃣ The “seven sins” are three production failures torch.compile can fuse kernels and reduce Python overhead. But in production diffusion serving, BBuf found that its operational cost often outweighed those gains. 🔹 Slow and unpredictable Compilation may take several minutes, and complex models can take more than half an hour. Performance also changes unpredictably across compiler modes, models, and GPU generations. An optimization that works on one GPU may become a regression on another. 🔹 Hostile to manual optimization A custom fused kernel may accelerate eager execution but slow down the compiled model. Graph breaks or broader compiler fusion can erase the improvement. Developers then have to debug both their kernels and the compiler’s changing graph decisions. 🔹 Opaque and difficult to maintain Compiled traces are hard to map back to Python calls. Generated kernels are also difficult to inspect, benchmark independently, or modify. Over time, engineers are pulled into compiler-specific fusion rules and workarounds instead of optimizing the actual model. 2️⃣ The current benchmark changed the calculation In SGLang Diffusion’s latest H100 and H200 tests, torch.compile was usually slower than eager execution or roughly tied with it. Compile jobs taking longer than three minutes were stopped. Several models also encountered timeouts or runtime failures. Some models had previously benefited from compilation. But after explicit kernel optimization, most of those gaps disappeared. For models dominated by launch overhead, eager execution plus Breakable CUDA Graphs could match or beat the compiled path. 3️⃣ An Agent replaced the hidden optimizations The team did not build an elaborate multi-agent system. They used Fable with a simple optimization flow and two Kernel Design Agent skills. The Agent profiled the VAE and model components, identified bottlenecks, implemented explicit optimizations, and repeatedly checked correctness and performance. Within two weeks, this workflow optimized more than 30 diffusion models. Their eager paths reached or surpassed the performance previously provided by torch.compile. The crucial difference is ownership: these optimizations now exist as visible, testable, and maintainable code. 4️⃣ Breakable CUDA Graph replaced the other benefit Kernel fusion is only one reason to use torch.compile. The other is reducing framework overhead through graph execution. SGLang previously relied on compiler-assisted Piecewise CUDA Graphs. After dealing with substantial compiler complexity, it developed Breakable CUDA Graph, which captures reusable execution paths while allowing controlled graph breaks. SGLang Diffusion now uses the same approach. It is easier to integrate into real serving systems and can outperform the compiled path on overhead-heavy models. 5️⃣ The deeper shift is from compiler magic to Agent-owned code A general compiler applies hidden transformations at runtime. An Agent can instead inspect the workload, reproduce useful transformations as source code, and validate them on the target hardware. This makes performance work easier to profile, review, debug, and adapt. BBuf’s claim is specifically about diffusion serving, not every PyTorch workload. But within that scope, the conclusion is blunt: If Agents can reproduce the useful kernel optimizations, while CUDA Graph techniques remove framework overhead, torch.compile no longer has a unique role. 🔗 Full Reading: 🔗 Performance results: 🔗 Kernel Design Agents: 🔗 SGLang: 🔗 Agent optimization skills: #SGLang# #PyTorch# #CUDA# #AIInfra# #DiffusionModels# #AIAgents#

🖼 Test-time scaling for image editing tends to hand every edit the same compute budget, wasting a lot of it. By allocating budget by difficulty and pruning with edit-specific verification, this work hits up to 2.2x speedup while preserving quality. Title: From Scale to Speed: Adaptive Test-Time Scaling for Image Editing URL: 📝 Overview ADE-CoT is a test-time scaling method tailored to goal-directed image editing. Instead of reusing Image-CoT methods built for text-to-image generation, it combines three strategies, difficulty-aware allocation, edit-specific early verification, and opportunistic stopping, to cut compute substantially while preserving quality. ❓ Challenges Solved Prior methods had three mismatches. ・Fixed sampling budgets waste compute on easy edits that barely improve ・General MLLM scores wrongly prune about 40% of samples that start low but ultimately score high ・Large-scale sampling produces redundant identical correct outputs, adding needless compute 💡 Methodology & Proposed Approach ・It reads edit difficulty, giving easy edits a minimal budget and expanding the search for hard ones ・A one-step preview estimates clean latents from noisy intermediates without extra denoising, making early verification reliable ・Grounded SAM2 checks that only the intended region changed, and DINOv2 embeddings remove redundant candidates ・It generates candidates sequentially and stops, via depth-first opportunistic stopping, once enough intent-aligned results are found 🎯 Use Cases It fits complex pose changes, multi-object removal or replacement, fine-grained regional edits, multi-turn editing, and high-quality editing under compute constraints, and is especially valuable where inference cost matters, like a production image-editing API. 📊 Experimental Results ・On GEdit-Bench, FLUX.1 Kontext is 2.2x, BAGEL 1.8x, and Step1X-Edit 2.0x faster than Best-of-N ・Reasoning efficiency more than doubles on a fixed 32-sample budget, and outcome efficiency rises 4.9x, 2.7x, and 2.9x across three benchmarks ・On hard multi-object edits like "remove the person standing next to the lady in white," it fixes the baseline's misidentification #ImageEditing# #DiffusionModels#

🎨 The reason diffusion models lose quality during generation turns out to be an "SNR vs timestep" mismatch. A training-free correction cuts FID by up to 47%. Title: Elucidating the SNR-t Bias of Diffusion Probabilistic Models URL: 📝 Overview During training, a diffusion model's signal-to-noise ratio (SNR) is deterministically tied to the timestep. During generation, accumulated errors break that coupling, so a sample's SNR no longer matches its assigned timestep, an "SNR-t bias." This paper elucidates the mechanism and proposes a correction called DCW. ❓ Challenges Solved Reverse-denoising samples consistently have lower SNR than forward samples at the same timestep. As a result, the network systematically overestimates its outputs, degrading generation quality. 💡 Methodology & Proposed Approach ・At each denoising step it applies a differential correction using the difference between the predicted and reconstructed samples ・It works in the wavelet domain, leveraging how diffusion models reconstruct low frequencies first and high-frequency detail later ・A discrete wavelet transform splits samples into frequency subbands, with low-frequency weights decaying over time and high-frequency weights increasing ・It is training-free and plug-and-play, working with IDDPM, EDM, DDIM, FLUX, and many others 🎯 Use Cases It can boost the quality of existing pretrained diffusion models after the fact, ideal when you want high-quality generation with few sampling steps. 📊 Experimental Results ・On IDDPM (CIFAR-10) it cuts 20-step FID by 42.6% ・On EDM (CIFAR-10) it reduces FID by 47.1% / 47.4% / 36.4% at 13/21/35 NFE ・It adds further gains even on top of SOTA bias-correction methods (A-DPM-FR improves from 12.38 to 10.91 FID at 10 steps) ・Compute overhead is tiny: ~0.47% on CelebA and 0.08% on ImageNet #DiffusionModels# #GenerativeAI#

Accurate modeling of CO₂ storage in the subsurface is a critical challenge for scaling Carbon Capture and Storage (CCS). 🌎 But here’s the catch: the inverse problem (recovering geological properties from sparse field observations) is severely ill-posed. 🤒 Traditional approaches either struggle with the scarcity of measured data or are too computationally expensive. 💸 In our new work, we introduce Fun-DDPS (Function-space Decoupled Diffusion Posterior Sampling), a generative framework that decouples the problem into two parts: a function-space diffusion model that learns a prior over geological parameters, and a differentiable Local Neural Operator surrogate for physics modeling and conditioning. ✨ Why does the decoupling matter? The diffusion prior handles the heavy lifting of recovering missing geological information, while the neural operator surrogate makes data assimilation fast and physically grounded — no expensive full-physics simulations in the loop. Key results on synthetic CCS datasets: ⏩ 11x improvement in forward modeling with only 25% observations ✅ Robust inverse modeling for data assimilation under sparse, noisy conditions 🔥 First rigorous validation of diffusion-based inverse solvers against asymptotically exact Rejection Sampling (RS) posteriors This points toward a scalable, practical path for uncertainty-aware subsurface characterization — something the CCS community needs as projects move from pilots to full-scale deployment. 📷 Huge kudos to my amazing collaborators — this work wouldn’t have been possible without them: @IsaacJu13 @AnimaAnandkumar Sally M Benson @ggg_www_ #CarbonCapture# #CO2Sequestration# #MachineLearning# #DiffusionModels# #NeuralOperators# #AI4Science# #CCS# #Sustainability#

I got a diffusion model to run really fast, glued it to a LLM, and it blows my mind how much of the interactivity we expect from software (editing text, dragging things around, clicking on "links") just works™️ in pixel space. The future of software is bright

I decided to have fun this weekend and train my own image diffusion model from scratch. Training on a single local GPU. This is 2 days in. It is a purely experimental arch that is working surprisingly well for its size and how it works. There is no text encoder. I am using the qwen3 tokenizer and dumping those token embeddings straight in next to image tokens with a time 0. Only self attention. It is pixel space. I am just doing patch 16 straight into the transformer. I am not doing any projection layers. The hidden size is 768 so the blocks work directly on the pixels not a projected image embedding. There were visible patches, but I added a shuffler to fix it. It does an alternating unpatching, mirror padding 8 on all sides and then re patching so the cross seams land in the center of patches, runs through a block, then depatch, crop and repatch every other block. It cleaned up immediately when I added it, something only possible without projection. There is no VAE, no text encoder, and it is tiny and super fast. Really tiny. It is 441 million parameters total. 116 (1/4) of those is the token embedding table. To put that in perspective, SD 1.5 was 983 million (te and unet) Will it be able to make coherent images? Not sure. I will keep training it for a bit though to find out. It seems to be understanding the basic concept of the prompts and if you squint really hard, it kind of looks like the other AITK samples with the same prompts.