Smit Patel (Kumbhani)

Machine Learning @Amazon || Research Intern (Post-Training) at Zeblok || MS-CS @ Stony Brook Uni. || Interests: RL/Post training, Diffusion Models

[Smit Patel (Kumbhani) @kumbhani_smit]

@natolambert Best lecture series! 🏆

[Smit Patel (Kumbhani) @kumbhani_smit]

@TheAhmadOsman 💯

[Ahmad @TheAhmadOsman]

Don’t know where to start with Local AI?

Read my Local LLMs From Zero to Hero series

It covers:
- Hardware
- Software
- Models Mechanics
- Everything else necessary

Needs no prior experience

Easy to understand for any background

Local / Opensource AI FTW

[Smit Patel (Kumbhani) @kumbhani_smit]

@yunta_tsai Even at 100x today’s pace, we’re looking at least 300 more years!
#spacex

[Smit Patel (Kumbhani) @kumbhani_smit]

@hyhieu226 Congrats @hyhieu226

[Ahmad @TheAhmadOsman]

How to go about learning all of this?

1st: Start with the serving engine view

- vLLM: PagedAttention, continuous batching, prefix caching, CUDA graphs

- SGLang: RadixAttention/prefix reuse, speculative decoding, MoE, structured/agent workloads

- TensorRT-LLM: NVIDIA peak stack, FP8/FP4, Wide-EP, disaggregated serving

- FlashInfer: reusable kernel/operator library for attention/GEMM/MoE/sampling

2nd: Go down the stack

- Triton tutorials → custom fused kernels

- CUTLASS/CuTe → Tensor Core GEMM and Blackwell/Hopper details

- FlashAttention papers → attention algorithm/kernel co-design

- PagedAttention paper → KV-cache memory management

- MoE docs → routing + grouped GEMM + all-to-all

- Nsight profiling → stop guessing

3rd: Do this mini-project sequence

1. Implement RMSNorm in Triton; compare to PyTorch

2. Implement fused SiLU × gate

3. Implement simple FP16 matmul; compare to cuBLAS/rocBLAS

4. Implement paged KV lookup for decode attention

5. Add FP8 KV cache with per-block scales

6. Implement toy top-k sampling on GPU

7. Implement tiny MoE dispatch + grouped GEMM

8. Integrate one custom op into vLLM or SGLang and profile end-to-end

[Cameron R. Wolfe, Ph.D. @cwolferesearch]

Interested in learning how to run RL at scale? Here are the best resources to read…

Research on Scaling RL
1. The Art of Scaling RL compute for LLMs: https://t.co/PGjI6Gwgv0
2. Scaling Behaviors of LLM RL Post-Training: https://t.co/2u2saB3C0h
3. Optimally Scaling Sampling Compute for LLM RL: https://t.co/rUSdUvJyNH
4. Scaling up RL: https://t.co/O8vV6z8ymx
5. ProRL V2 - Prolonged Training Validates RL Scaling Laws: https://t.co/vu72juvRW4
6. Polaris - A Recipe for Scaling RL with Reasoning Models: https://t.co/rMibSAeJbg

RL Frameworks
1. Hybrid Flow (early outline of the verl framework): https://t.co/GnWXx131uD
a. More up-to-date info can be found here: https://t.co/j801HcJmPP
2. AReal - Large-Scale Async RL: https://t.co/qhOvsQK09N
3. PipelineRL - Fast On-Policy RL: https://t.co/iRM7KzySXe
4. AsyncFlow - Async Streaming RL: https://t.co/YwmzFtiU2q

RL for Agents
1. DeepSWE - Open Coding Agent Trained w/ RL: https://t.co/GHQHcmtE6F
2. AutoForge - Environment Synthesis for Agentic RL: https://t.co/mr3WDIL5vq
3. Agent-R1 - Training Agents w/ End-to-End RL: https://t.co/xpfQJGgzEv
4. AgentRL - Scaling RL for Multi-Turn, Multi-Task Agents: https://t.co/7fbVl0RWXG
5. The Landscape of Agentic RL: https://t.co/OMnSV4rgdW
6. Training SWE Agents with RL: https://t.co/YqMqySbyXS

Case Studies & Tech Reports
1. Kimi tech reports:
a. Kimi K2 - Open Agentic Intelligence: https://t.co/aAw17SXrIw
b. Kimi End-to-end Agentic RL: https://t.co/ProBpOPIiI
c. Kimi K1.5 - Scaling RL for LLMs: https://t.co/kRGOxY9Jvp
2. Composer series from Cursor:
a. Composer 2: https://t.co/K0v8rNCE6Z
b. Composer 2.5: https://t.co/D9PYimfOMU
3. Olmo 3 (also has open code / data): https://t.co/khetJFvp6N
4. MiniMax tech reports:
a. MiniMax-M2: https://t.co/HApb0OB80S
b. MiniMax-M1: https://t.co/mZj9UQsrnC
5. Nemotron 3 (NVIDIA): https://t.co/lCpE1GzxSi

[Smit Patel (Kumbhani) @kumbhani_smit]

@TheAhmadOsman When is it coming to New York!?

[Pedro Domingos @pmddomingos]

@GrdDscntN2Madnz We won't need chatbots when our brains can communicate directly with AI.

[Smit Patel (Kumbhani) @kumbhani_smit]

Well written 💯👌

[will brown @willccbb]

https://t.co/gCIFKAjB0Z

[Smit Patel (Kumbhani) @kumbhani_smit]

Bang on 💯💯
Mythos >> 4.7 >> V4 == 5.5 🫠

[Elon Musk @elonmusk]

Engineering is real magic

[Smit Patel (Kumbhani) @kumbhani_smit]

Completed ~250 pages in 2.5 hours!
.
What a great book on “Inference at a scale”
Kudos to @philipkiely and @baseten

[Smit Patel (Kumbhani) @kumbhani_smit]

💯💯

[Zhuokai Zhao @zhuokaiz]

I wish someone had told me this when I started digging into diffusion language models (dLLMs) from an LLM post-training background.

I've spent the last few weeks reading across both the dLLM RL literature (d1, EGSPO, MDPO, LLaDA 1.5) and the older robotics literature on diffusion policies + RL (DPPO, Diffusion-QL, and follow-up work). What surprised me most wasn't the algorithms themselves — it was realizing that the robotics community had already worked through several of the same problems the dLLM community is hitting now.

The robotics insight — structured exploration — doesn't transfer to discrete dLLMs as directly as I initially thought, but the broader lesson does.

The multi-step denoising process isn't just an expensive way to generate tokens. It gives RL tools that autoregressive models don't have — intermediate evaluations, entropy signals, a natural coarse-to-fine hierarchy — and understanding how to use (and not break) these tools is probably one of the key challenges.

This post is me organizing what I've learned — how RL post-training works (or doesn't) with diffusion language models, what carries over from the autoregressive world, what's genuinely new, and where I'm still confused.

A Quick Intro to How dLLMs Generate
Autoregressive LLMs generate left-to-right, one token at a time, and each token choice is irreversible during generation. The probability of a sequence factorizes as a product of conditional distributions: p(x₁)·p(x₂|x₁)·p(x₃|x₁,x₂)·…

Diffusion language models generate through iterative denoising. The mainstream approach right now — masked diffusion (LLaDA, Dream, MDLM) — starts with the entire response masked, then over T denoising steps, progressively unmasks tokens.

At each step, the model predicts all masked positions simultaneously using bidirectional attention, and selectively reveals the most confident predictions. The process repeats until all tokens are unmasked.

Properties of this process matter a lot for RL
(a) No fixed generation order.
Tokens can be revealed in any order — high-confidence tokens first, uncertain ones later. This means the model can lay down the skeleton of a response early and refine details later. Think of it as coarse-to-fine generation rather than left-to-right.

(b) Complete generations at every intermediate step.
Unlike autoregressive models where you have a partial sequence mid-generation, a dLLM produces a full (noisy) output at every denoising step. This turns out to be very useful for RL — you can evaluate intermediate states cheaply.

(c) No cheap exact autoregressive-style sequence log-probability.
Autoregressive models give you log p(sequence) for free via the chain rule. dLLMs don't have an equally convenient sequence-level factorization for standard RL objectives, so exact likelihood-style updates become awkward and expensive. Practical methods usually rely on approximations, surrogates, or stepwise reformulations. This is one of the core obstacles for applying standard RL algorithms directly.

The field has moved fast over the last year or so. Notable models include LLaDA 8B (trained from scratch, reported by its authors as competitive with LLaMA 3 8B), Dream 7B (adapted from Qwen2.5, notably strong on planning tasks), Mercury 2 (Inception, focused on inference speed), and LLaDA 2.0 (scaled to 100B).

Where the Standard RL Pipeline Breaks
The standard RL post-training pipeline for autoregressive models is straightforward. Sample a response, get a reward, compute log-probability of the response under the current policy, estimate advantage, update with policy gradient.

The log-probability computation is trivial since you just sum per-token log-probs from the forward pass.
With dLLMs, this pipeline breaks at step 3. You can sample responses and get rewards just fine. But you can't recover an exact autoregressive-style response log-probability with the same convenience, because there's no left-to-right chain-rule factorization.

So RL methods that rely on likelihood ratios or preference-style likelihood comparisons (PPO, GRPO, DPO-style objectives) need some workaround.

So far, a few approaches have emerged.
(a) Mean-field approximation (d1 / diffu-GRPO).
Since exact autoregressive-style sequence likelihood is unavailable in a convenient form, approximate it by treating token positions more independently and summing per-token terms — similar in spirit to autoregressive likelihood computation, but ignoring some within-step dependencies. This is cheap and works surprisingly well in practice, but it is still an approximation, especially in early denoising steps where token predictions can be strongly correlated.

(b) ELBO-based estimates with variance reduction (LLaDA 1.5 / VRPO).
Instead of computing the exact likelihood, these approaches use a tractable surrogate based on the ELBO, which is already central to diffusion-model training. The problem is that these estimates can be noisy — high variance makes preference-style updates unstable. LLaDA 1.5's key contribution is VRPO, which analyzes this variance explicitly and introduces variance-reduction techniques that make this route much more practical.

(c) Treat denoising as an MDP (EGSPO, MDPO, DiFFPO).
This is the approach most analogous to DPPO in robotics. Formulate the T-step denoising process as a finite-horizon MDP where
state = the current partially denoised sequence,
action = the denoising decision at that step,
reward = often sparse at the end, though some methods also use intermediate rewards.

Each denoising step has tractable local transition probabilities. Then apply policy gradient across the denoising chain.

A Parallel Story from Robotics
In robotics, from-scratch online RL for diffusion policies has proven challenging and often unstable or sample-inefficient enough to motivate alternatives and architectural workarounds. But in the fine-tuning regime — pretrain a diffusion policy from demonstrations, then improve with RL — the results are much better.

DPPO reports strong gains over alternative fine-tuning baselines, including standard Gaussian PPO-style policies, especially in sim-to-real transfer.

On the Furniture-Bench assembly task, DPPO achieves 80% real-robot success zero-shot from simulation, while a Gaussian PPO baseline achieves 88% in simulation and 0% on hardware.

The explanation offered by this line of work is structured, on-manifold exploration.

In continuous action spaces, a pretrained diffusion policy denoises noisy actions back toward the data manifold. Each denoising step adds stochasticity (exploration) while also restoring structure, so the exploration stays in the neighborhood of plausible behavior rather than scattering across the full action space.

This is why RL fine-tuning works despite the long denoising horizon — most sampled trajectories are still "reasonable," so even coarse credit assignment can produce useful gradients.

Now, this specific geometric mechanism doesn't transfer cleanly to dLLMs.

In masked diffusion, the "actions" are discrete token predictions, not continuous vectors. There's no continuous score field pulling tokens back toward a manifold in the same way.

But the broader principle does transfer — the denoising process is sequential structure that RL can exploit.

What the Denoising Structure Gives dLLM RL
The denoising chain gives dLLM RL methods specific tools that don't exist in the autoregressive setting.

(a) Iterative self-correction.
dLLMs can revise tokens across denoising steps. d1 observed "aha moments" — the model initially commits to a wrong reasoning path, then during later denoising steps, corrects itself. Autoregressive models can do chain-of-thought, but they can't go back and change earlier tokens. For RL, this means the policy has a built-in error-correction mechanism that RL doesn't need to learn from scratch.

(b) Free intermediate evaluations.
Because dLLMs produce complete outputs at every denoising step, you can evaluate quality at intermediate steps without extra rollouts. MDPO exploits this directly — it checks whether the answer is correct at each denoising step and uses these intermediate rewards for credit assignment. They also discovered something interesting — over-denoising, where models sometimes get the right answer at an intermediate step, then "refine" it into a wrong answer. This is probably the dLLM version of RL over-optimization destroying a good pretrained policy.

(c) Entropy-guided compute allocation.
EGSPO uses the model's entropy at each denoising step to decide where to spend training compute. High-entropy steps (where the model is most uncertain) get more gradient signal; low-entropy steps (where the model is confident) get less. The intuition is that you're directing optimization pressure where decisions are most consequential. My interpretation of this, in the structured-exploration framing, is that high entropy often marks denoising steps where the model has not yet committed to a stable solution, so optimization matters more there. Low entropy steps are more settled and may offer less room for improvement.

(d) Denoising discount as an implicit regularizer.
DPPO in robotics uses a denoising discount that downweights earlier (noisier) denoising steps in the policy gradient. My read is that this plays a role similar to regularization — it discourages RL from aggressively modifying the early, structure-establishing denoising steps, while allowing more freedom in later refinement steps. The same principle may apply to dLLMs — you want to preserve the coarse structure and optimize the fine-grained details more aggressively.

The Failure Modes We're Seeing
The robotics literature warns about specific failure modes, and we're already seeing some of the analogues in dLLMs.

(a)Mode collapse.
This is a recurring concern in RL fine-tuning of diffusion models more broadly, including image-generation work and policy fine-tuning. RL optimization can collapse multimodal distributions toward a smaller set of reward-favored modes. dLLMs' ability to represent multiple valid responses (different reasoning paths, different coding styles) is a key advantage — but RL will try to compress this diversity. The DPPO paper argues that its specific setup is relatively robust to catastrophic collapse, but the broader diffusion-RL literature suggests this risk is real.

(b) Data/manifold bias.
The pretrained distribution is bounded by pretraining + SFT data. If your SFT data only demonstrates one reasoning style, RL can optimize that style but can't easily discover fundamentally different approaches. The denoising process may make this harder to escape, since it actively pulls generations back toward the pretrained distribution.

(c) Over-denoising / over-optimization.
MDPO's finding that models get correct answers at intermediate steps and then "refine" them into wrong final answers is the dLLM-specific version of RLHF over-optimization. The iterative structure that provides self-correction can also provide self-destruction if RL pushes too hard.

What this Suggests?
If this framing is roughly right, then maybe we should:

(a) Invest heavily in pretraining and SFT quality, not just fancier RL.
My current read is that the quality of the pretrained dLLM and SFT data may matter more than the choice between diffu-GRPO, EGSPO, or MDPO. The pretrained distribution appears to be doing a lot of the heavy lifting. If your pretrained model doesn't cover the relevant solution space, no amount of RL sophistication will find what isn't there.

(b) Exploit denoising structure for credit assignment.
The intermediate evaluations that dLLMs offer for free might be under-appreciated. MDPO and EGSPO are pointing the way. Use entropy-guided step selection. Use intermediate rewards. The denoising chain gives you structure that autoregressive models don't have; so why not use it.

(c) Be careful with early denoising steps.
The early steps establish coarse structure — the overall shape of the response. Aggressively optimizing these risks destroying the pretrained distribution. Consider denoising discounting, or only fine-tuning later denoising steps, or using larger clipping ratios for early steps. DPPO in robotics found that fine-tuning only the last K' of K denoising steps can work well — the same principle likely applies.

(d) Monitor for over-denoising.
Track performance at intermediate denoising steps, not just the final output. If intermediate steps consistently outperform the final output after RL, you're over-optimizing. This is a dLLM-specific early warning system for reward hacking.

(e) Take mode collapse seriously.
If the task has multiple valid solution strategies, check that RL preserves them. Measure output diversity, not just reward. KL from the reference model is necessary but probably not sufficient.

What I Still Don't Know
1. Does the denoising structure actually help RL quantitatively?
The robotics evidence is strong — DPPO clearly outperforms Gaussian PPO in the fine-tuning regime. For dLLMs, the comparison would be whether diffu-GRPO on a dLLM produces more stable or efficient RL fine-tuning than standard GRPO on an equivalently pretrained autoregressive model. I haven't seen this head-to-head comparison done cleanly. d1 shows diffu-GRPO works, but doesn't compare against autoregressive GRPO with matched pretraining quality.

2. Is the planning advantage real?
Dream 7B reports substantially stronger results than Qwen2.5 7B on several planning-style tasks (for example, Countdown 16.0 vs 6.2 and Sudoku 81.0 vs 21.0 in the paper's evaluation). Is this because the non-autoregressive generation structure is genuinely better for constraint satisfaction, or is it an artifact of evaluation methodology? If it's real, it suggests dLLMs + RL could be particularly powerful for agentic tasks that require planning.

3. How far does this scale?
DPPO in robotics works for 7-DOF manipulation but hasn't been tested on truly high-dimensional action spaces. dLLMs operate in vocabulary-size action spaces (32K+). Do the denoising structure advantages hold at this scale?

4. Can you escape the pretrained distribution when you need to?
The denoising process constrains RL to stay near the pretrained distribution, which helps stability but limits what RL can discover. For genuinely novel reasoning, not just refinement of existing patterns, you may need to break free. What's the dLLM equivalent of off-distribution exploration?

What I keep coming back to is that when you move from autoregressive to diffusion generation, the denoising chain provides exploitable structure for RL, but it also constrains what RL can do.

The methods that seem to work best are the ones that take both sides of this seriously — exploiting the structure where it helps, and being careful not to destroy it where it matters.

[Smit Patel (Kumbhani) @kumbhani_smit]

@peholderrieth @viddivj Cool, Weekend is all set now 💯

[Sebastian Raschka @rasbt]

I (finally) put together a new LLM Architecture Gallery that collects the architecture figures all in one place!
https://t.co/NO7z6XSRHS

[Moonlake @moonlake]

https://t.co/vHXbGcwESD

[Smit Patel (Kumbhani) @kumbhani_smit]

@chrmanning @goodfellow_ian @sunfanyun @grok, share your thoughts on this!

[Smit Patel (Kumbhani) @kumbhani_smit]

Controversial: 💯
Cricket is as complex as F1

Many external factors can influence the result other than just skills!

#INDvsENG #T20WorldCup

[Smit Patel (Kumbhani) @kumbhani_smit]

Large batch size increases communication cost along with higher computation latency resulting 75% of gpus sitting in ideal states, classic bubble issue that arises with pipeline parallelism

Solution:
1. Pipeline parallelism with better micro-batching
2. apply horizontal tensors parallelism under fsdp setup to hide communication bandwidth behind compute