
Show Notes
This episode examines a Meta and AMD paper claiming that AMD's MI350X can train Meta's production recommendation models at roughly the throughput of NVIDIA's B200. It explains why recommendation models are a harder training target than LLMs: terabyte-scale sharded embedding tables, irregular gathers, heavy all-to-all communication, odd-shaped matrix multiplies, and atomic-update-heavy backward passes. It compares the two chips. Peak compute and memory bandwidth are close, the MI350X has about 1.6 times the HBM capacity, and the B200 has faster scale-up interconnect. The discussion defines "co-design" as adapting the model recipe to a purchased chip, for example by dropping activation checkpointing to use the extra memory, rather than building the platform as in Meta's earlier ZionEX work. It also raises fairness concerns about the headline parity: the recipe was changed for the AMD hardware, several co-authors are AMD engineers, and the MI350X ran at 1000 watts against the B200's 750-watt cap. The episode previews the paper's analytical GEMM tile-selection model and its agentic CUDA-to-AMD kernel porting.
Sources: 1. Architecting for Hardware Diversity: Meta's End-to-End Co-Design for High-Performance AI Training on AMD GPUs — Haoyu Zhang, Arshad Rahman, Adnan Aziz, Ajith Prabhudev, Amin Farmahini, Ben Rhoads, Benson Ma, Brian Shi, Cen Zhao, CK Luk, Dingming Wu, Emad El-Haraty, Eric Chen, Frank Li, Gary Huang, Gefei Zuo, Haoran Zhang, Hiwot Kassa, Hongyi Zeng, Jack Taylor, Jeremy Hadidjojo, John Donati, Jonathan Sheffield, Julio Machado Silva, Karthik Ganesan, Kent Russell, KR Kishore, Lei Tian, Liu Ke, Muhammad Osama, Peng Chen, Rakesh Hemnani, Ryan Swann, Saleel Kudchadker, Shankar Yanamandram, Shobhit Kanaujia, Shucai Xiao, Srinath Bayareddy, Srinivas Vaidyanathan, Sudharssun Subramanian, Supadchaya Puangpontip, Taylor Robie, Tianhao Huang, Tyler Hart, Viswesh Sankaran, Weijun Jiang, Wenkai Du, Xiaodong Wang, Xiaohu Guo, Yao Rong, Yinbin Ma, Yue Dong, Yuzhen Huang, Yvonne Liu, Zhan Shu, Dan Rabinovitsj, Ajit Mathews, Chunqiang Tang, 2026 http://arxiv.org/abs/2610.22230 2. FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness — Tri Dao, Daniel Y. Fu, Stefano Ermon, Atri Rudra, Christopher Ré, 2022 https://scholar.google.com/scholar?q=FlashAttention%3A+Fast+and+Memory-Efficient+Exact+Attention+with+IO-Awareness 3. Deep Learning Recommendation Model for Personalization and Recommendation Systems — Maxim Naumov, Dheevatsa Mudigere, et al. (Facebook AI), 2019 https://scholar.google.com/scholar?q=Deep+Learning+Recommendation+Model+for+Personalization+and+Recommendation+Systems 4. Software-Hardware Co-design for Fast and Scalable Training of Deep Learning Recommendation Models — Dheevatsa Mudigere, Yuchen Hao, Jianyu Huang, et al., 2022 https://scholar.google.com/scholar?q=Software-Hardware+Co-design+for+Fast+and+Scalable+Training+of+Deep+Learning+Recommendation+Models 5. DeepSeek-V3 Technical Report (and the follow-up 'Insights into DeepSeek-V3: Scaling Challenges and Reflections on Hardware for AI Architectures') — DeepSeek-AI, 2024-2025 https://scholar.google.com/scholar?q=DeepSeek-V3+Technical+Report+%28and+the+follow-up+%27Insights+into+DeepSeek-V3%3A+Scaling+Challenges+and+Reflections+on+Hardware+for+AI+Architectures%27%29 6. Ansor: Generating High-Performance Tensor Programs for Deep Learning — Lianmin Zheng, Chengfan Jia, Minmin Sun, et al., 2020 https://scholar.google.com/scholar?q=Ansor%3A+Generating+High-Performance+Tensor+Programs+for+Deep+Learning 7. A Learned Performance Model for Tensor Processing Units — Samuel J. Kaufman, Phitchaya Mangpo Phothilimthana, Yanqi Zhou, et al., 2021 https://scholar.google.com/scholar?q=A+Learned+Performance+Model+for+Tensor+Processing+Units 8. Roofline: An Insightful Visual Performance Model for Multicore Architectures — Samuel Williams, Andrew Waterman, David Patterson, 2009 https://scholar.google.com/scholar?q=Roofline%3A+An+Insightful+Visual+P
More from AI Post Transformers
This episode examines "500xCompressor," a soft prompt compression method that squeezes hundreds of tokens of context into as little as a single learned token. A frozen Llama-3-8B decoder then answers questions from that token's key-value (KV) vectors alone. It covers why long contexts are costly (KV cache memory and attention cost grow with length). It also contrasts hard compression, which deletes text (Selective Context, LLMLingua), with soft approaches (gist tokens, AutoCompressor, ICAE, xRAG). The discussion walks through how a LoRA-adapted encoder and autoencoder-style regeneration pretraining produce those KV values, and what the headline 6x–480x ratios and 62–73% retained capability actually measure. The hosts also scrutinize the evaluation: arXiv abstracts from early 2024 are used to avoid pretraining leakage, and F1 versus Exact Match are explained. Listeners get a critical look at whether KV beats embeddings and whether the benchmark can be trusted.
This episode explores Context Language Models, a proposal that lets a model write directly to its own context as an editable file instead of relying on human-designed harnesses. It first surveys the existing approaches: fixed-policy compaction, action-based tools such as Context Folding, and recursive language models. It then shows why they fall short on tasks like in-place Sudoku edits, using a diagnostic benchmark that varies context pressure. The discussion explains why edits to the middle of a context break prefix caching and force costly recomputation, and why the paper measures cost in prefix-reuse FLOPs. It also lays out the paper's five claims: zero-shot gains on deep research and coding, swarms of agents with file-based contexts, evolved natural-language skills, online reinforcement learning, and a serving change called Suffix Cache Reuse. The hosts stress the difference between percentage points and relative percent, and they note that the strongest evidence is zero-shot with a large model while the training evidence is thinner.
This episode examines a 2024 paper arguing that mixture-of-experts models outperform dense Transformers at every compute budget, with a gap that widens at scale. That claim contradicts earlier Meta and DeepMind studies, which saw the MoE advantage shrink, and the authors blame two hidden assumptions: a fixed training duration and a fixed expert size. The discussion builds the background from dense feed-forward layers, routers, and the difference between active and total parameters, through the Kaplan and Chinchilla scaling laws. It then introduces "granularity", the ratio of dense feed-forward width to expert width, as a third scaling axis. Granularity is a design choice that was inherited by convention and never shown to be optimal. The episode also stays skeptical of the evidence. The law is fit on a ragged grid of small models (3M to 85M active parameters), yet its headline claims extrapolate to a trillion active parameters, so listeners get a clear view of both the idea and its limits.
This episode examines "HyperTuning," an ICML 2023 paper that uses a hypernetwork (HyperT5) to adapt a frozen language model to a new task in a single forward pass, with no back-propagation through the downstream model. It explains how the hypermodel reads up to sixteen labeled examples and emits prefix or LoRA parameters that the downstream model reuses for every query without seeing the examples again. The discussion covers why per-task adaptation is costly, how parameter-efficient methods still require a full backward pass, and how the work relates to earlier hypernetwork, meta-learning, and instruction-to-parameter approaches. It also sets up a skeptical reading of the paper's three claims: that HyperT5 roughly matches full fine-tuning on held-out tasks, that it beats shared-parameter PEFT baselines, and that its output works as a PEFT initialization. The skeptical questions are where the training cost actually moves to, and whether the headline margins hold beyond single-run noise.
This episode examines "Mixture of A Million Experts," a 2024 paper proposing a learned router that selects among more than a million single-neuron experts at sublinear cost. It explains why conventional mixture-of-experts routing stalls around 128 experts: scoring every expert against every token scales linearly. It also covers why fixed hash routers fall short. The discussion traces the paper's building blocks: fine-grained MoE scaling laws that favor ever-smaller experts, Product Key Memory's Cartesian-product trick for cheap retrieval, and the view of feedforward layers as key-value memories. Along the way, the hosts flag caveats, including the paper's redefinition of granularity, the extrapolation of a scaling law far beyond where it was fitted, and lifelong learning being motivation only, with no experiment. They also raise whether FLOP-based isoFLOP wins will hold up on real hardware, where scattered lookups into a million-entry table are a poor fit for large matrix multiplies.