Architecting Future Intelligence.

Why a large language model can check several guessed tokens for about the cost of generating one, how the acceptance rule keeps the output exactly the same, the main ways to make guesses (draft models, n-grams, Medusa, EAGLE, multi-token prediction), and when it stops helping, including for vision-language and mixture-of-experts models.

A map of the models that see, read and act, for robots and for cars: where their training data comes from and how it's curated (with Qwen-Drive's pipeline as a worked example), the three ways to turn a language model into a controller, how they're trained, and why evaluating them is harder than building them.

One support team, one screenshot, one model. How a Qwen-style vision-language model reads an image, how a mixture-of-experts layer routes each token to a few experts, how the router and experts are trained without collapsing, and what changes when you deploy it.

How models learned to look at a picture and talk about it, told as a short sequence of ideas: CLIP's shared space, BLIP's captions, Flamingo's frozen language model, LLaVA's thin adapter, and natively multimodal models.

Reinforcement learning is how an agent learns what to do now when the reward comes later. The core ideas (states, rewards, value, Q-learning and deep Q-networks), built up on one tiny grid world.

Backpropagation answers one question: when a network's prediction is wrong, how much should each weight change? Here's the idea, the three equations that do the work, and a tiny network you can trace by hand.

A short map of the Python tools that show up again and again in coding interviews (heaps, memoization, union-find, tries, binary search) and the gotchas that cost people time, organized by the shape of the problem.

Retrieval-augmented generation lets a model answer from your documents instead of its memory. A map of what it takes to make it work beyond a demo: hybrid search, reranking, chunking, video, freshness and how to measure it.

A map of how vision-language models, image generators and video generators are built: the data, the two kinds of visual tokens, the training stages and how they're evaluated, with links out for depth.

AI can now write a clean, tested change in seconds. This post is about the part it can't see: who owns the code, who depends on it, and how to stay the person who understands the system.

Serving a model that answers questions is one problem. Serving one that queries databases, runs code and sends messages is another. A map of what changes: the agent loop, tools through MCP, sandboxes, safety and versioning.

On a modern GPU, arithmetic is cheap and moving data is expensive. A map of why that's true, how fusion and tiling fix it, how FlashAttention works, and when it's worth writing your own kernel.

A model that doesn't fit on one GPU has to be split across many. A map of where training memory goes, how DDP, ZeRO and FSDP divide it, when to add tensor and pipeline parallelism, and how big runs survive failures.

A guide to this site's MLOps series: eight short modules that follow a model from the files its data lives in to the GPUs that serve it, with the one trade-off each layer is about.

Where the time goes when you send a prompt to a model in production: the network, the queue, tokenization, batching, the two very different GPU phases, and streaming the answer back. Following one request from start to finish.

Airflow, Kubeflow, Temporal and Ray all 'orchestrate,' but they sit at different layers and solve different problems. A map of the layers, using one daily retraining pipeline to show which tool owns which part.

Pre-training gives a model knowledge; post-training gives it behavior. A map of the main steps (supervised fine-tuning, LoRA, preference tuning, and reinforcement learning with checkable rewards), following one model as it becomes a SQL assistant.

How data is laid out on disk and in memory decides how fast everything above it can go. A map of Parquet (for storing) and Arrow (for computing), why ML pipelines use both, and the file-layout mistakes that quietly slow training down.

When you serve a large language model, the GPU usually runs out of memory for conversations long before it runs out of compute. A map of the KV cache, PagedAttention, continuous batching and the other tricks that let one GPU serve many more people.

Self-driving stacks were built as a chain of specialist modules. Foundation models promise one model that sees, reasons and acts. Here's what that looks like, why teams keep a fast path and a safety layer around it, and what's still unsolved.

GPU utilization is a lagging indicator — the real battle is in the data pipeline. A practitioner's deep dive into PyTorch DataLoader internals, zero-copy data pumps, WebDataset streaming, and the exact questions this gets you in ML system design interviews.

How diffusion models predict action sequences instead of pixels. Covers Diffusion Policy, world models for robotics, and connecting diffusion to reinforcement learning for autonomous systems.

A deep dive into the physics and probability of diffusion models. Learn how reversing a stochastic process became the foundation for modern generative AI, from Stable Diffusion to robotics and protein design.

The evolution of image diffusion architectures. Learn how we moved from convolutional U-Nets to scalable Diffusion Transformers (DiT), and why treating images like language changed everything.

Exploring the state-of-the-art in video generation. Learn how Sora and Veo use Spatiotemporal Transformers to simulate the physical world, and the challenges of achieving perfect motion fidelity.

How to move from visual imitation to law-governed motion. Deep dive into injecting PDEs into neural networks, implicit physics extraction, and LLM-guided physical reasoning.

How to train a world-class diffusion model. Covers the complete lifecycle: from large-scale pre-training on noisy web data to specialized post-training, alignment, and aesthetic fine-tuning.

How to accelerate diffusion sampling and steer creativity. Learn the mechanics of DDIM, DPM-Solver, Classifier-Free Guidance (CFG), and the math of negative prompting.

The fundamentals of video diffusion models. Learn how we extend 2D diffusion to time, the mechanics of temporal attention, and the architectural shifts required for motion consistency.

Why L5 autonomy is harder than a moon landing. Understanding ODD, latency loops, compute constraints, and the modern Hybrid Architecture (Modular vs. End-to-End).

The raw senses of an autonomous vehicle: What data does each sensor provide? Covers cameras, radar, LiDAR, ultrasonics, and microphones—their physics, strengths, weaknesses, and why fusion is necessary.

From GPS to centimeter accuracy: How autonomous vehicles know their exact position. Covers GNSS, IMU, wheel odometry, scan matching, and Factor Graphs.

How autonomous vehicles remember the world. Covers HD maps, lane graphs, offline vs. online mapping, MapTR, and the map-heavy vs. map-light debate.

From pixels to 4D realities: How AVs understand their environment. Deep dive into BEV Transformers, Panoptic Occupancy, Scene Flow, and Foundation Models for open-world perception.

The hardest problem in AV: predicting human irrationality. From physics-based Kalman Filters to Joint Autoregressive Distributions, Generative Motion Diffusion, and World State Propagations.

From perception to action: How autonomous vehicles make decisions. Covers cost functions, game-theoretic planning, MPC, and the "End-to-End" debate.

If you don't know where your eyes are relative to your feet, you trip. Covers intrinsics, extrinsics, SE(3) transforms, online vs. offline calibration, and time synchronization.

A deep dive into XGBoost — how second-order Taylor approximations and sophisticated regularization make it the dominant algorithm for structured data, bridging mathematical rigor with system engineering excellence.

Part 4 of a comprehensive guide to agentic AI design patterns. Covers common failure modes, safety mechanisms, verifiable pipelines, and how to build reliable production systems.

Part 3 of a comprehensive guide to agentic AI design patterns. Covers specialized patterns: embodied agents, 3D scene understanding, imagination loops, multi-agent societies, error recovery, and self-debugging.

Part 5 of a comprehensive guide to agentic AI design patterns. Covers 2025 trends, cost optimization, case studies, production checklist, and the state of the field.

Part 1 of a comprehensive guide to agentic AI design patterns. Covers the fundamentals: ReAct loops, planning, tool use, self-consistency, and graph-based reasoning.

An intuitive introduction to the Transformer architecture — from the attention mechanism to self-attention and cross-attention, using language translation as a concrete example.

An intuitive introduction to Variational Autoencoders — how compressing data into probabilistic codes enables machines to generate realistic images, sounds, and structures.

Part 2 of a comprehensive guide to agentic AI design patterns. Covers production-ready patterns: memory management, supervisor/orchestrator, parallel tool execution, and hidden reasoning.

An exploration of modern agent systems, with math, analogies, and examples. From ReAct loops to multi-agent societies, discover the design patterns that make AI agents think, act, and fix themselves.

Reflections on building production-grade behavior prediction systems for autonomous vehicles — and why closed-loop reasoning is the bridge between perception and planning.

My research journey from wireless communication foundations to solving the camera calibration bottleneck that enables autonomous vehicle vision.

How we used deep learning to automatically calibrate traffic cameras by observing vehicle motion—work that won Best Paper Award at ACM BuildSys 2017.