initial commit

README.md

@@ -1,3 +1,133 @@
----
-license: mit
----
+---
+license: mit
+language:
+  - en
+tags:
+  - optimization
+  - muon
+  - deep-learning
+  - pytorch
+  - distributed-computing
+  - tutorial
+  - cpu-friendly
+---
+
+# 🧩 The "Muon is Scalable" Blueprint: A Distributed Muon Tutorial(CPU-Friendly)
+
+A practical, **annotated tutorial** for the Muon optimizer — extended into a fully distributed (DP × TP) version that actually runs on **plain CPU/Gloo**, so broke-but-curious builders can still get their hands dirty.
+
+This is the expert-level systems engineering companion to my original [**Understanding the Muon Optimizer**](https://huggingface.co/datasets/bird-of-paradise/muon-tutorial) tutorial.
+
+> 💡 _“Because sometimes the best way to learn the distributed nightmare is to get your hands dirty and your eyes crossed.”_ 🤪
+
+---
+
+## 🌕 Why This Exists
+
+Most public Muon examples (like MoonShot’s PoC) are designed for multi-GPU NCCL clusters, making them impossible to run or debug for most of us. In addition, most documentation for distributed systems is written by experts, for experts, making it a "nightmare" to learn. My goal is to change that.
+
+This repository is **not** a "simplified" version that "flattens the depth" of the work.
+
+Instead, it's a **didactic refactor**. I've taken the complex, real-world PoC and optimized it for *readability* and *learning*, so you can see the "blueprint" behind the "chaos":
+-   Fully **annotated** to **demonstrate** data parallel (ZeRO-1) + tensor parallel (TP) orchestration end-to-end.
+-   Understand every “distributed acrobatic” step (`DP gather` → `TP gather` → `Newton–Schulz` → `TP shard` → `DP shard`).
+-   The code is optimized to highlight **symmetrical logic** and **consistent naming**, showing the "opposite arrow" data flow of the "virtual map" (`dist_meta`).
+-   It's built to run **on a single CPU machine or Colab notebook**.
+
+---
+
+## 🧠 The “Turtle Speed” Breakthrough: The Full Story
+
+This code is complex. It's a "distributed nightmare" 🫠.
+
+Instead of a traditional, long-form `README`, the best documentation is the "making of" story. I've chronicled my entire journey of reverse-engineering and debugging this code in my "Turtle Speed Breakthrough" series on Medium.
+
+* **[Part 1: The “Turtle Speed” Breakthrough: Decoding Distributed Optimizers](https://medium.com/@jenwei0312/the-turtle-speed-breakthrough-decoding-distributed-optimizers-from-fsdp-to-muons-secret-sauce-64fc76f20cd7)**
+* **[Part 2: My Map of the Distributed Nightmare (The Blueprint)](https://medium.com/@jenwei0312/the-turtle-speed-breakthrough-part-2-the-blueprint-for-distributed-chaos-37fe343e7aa9)**
+* **[Part 3: The Final Bugs and "Aha!" Moments](https://medium.com/@jenwei0312/the-turtle-speed-breakthrough-part-3-my-map-of-the-distributed-nightmare-b10ff4affd56)**
+
+This tutorial is the final, runnable code that resulted from that deep dive.
+
+---
+
+## 🚀 Quick Start
+
+Run the CPU-safe, fully-annotated notebook right from your browser:
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](<distributed_muon_cpu.ipynb>)
+
+Or, you can clone this repo and run the Python script locally to simulate an 8-process cluster on your CPU:
+
+```bash
+git clone [https://huggingface.co/datasets/](https://huggingface.co/datasets/)bird-of-paradise/muon_distributed
+cd muon_distributed
+
+# This will spawn 8 processes and run the full test
+!python distributed_muon_cpu.py
+````
+
+(Note: For the original, un-annotated, buggy Moonshot PoC that this work is based on, you can find it in this [commit](https://github.com/NVIDIA/Megatron-LM/pull/1428/commits/f432fbe45c169aeb5a0805ff6f41e13f989c6730#diff-8fe91f4096ff232fc6f97b17e60e619eda92b6dffc80b4573a23e06aa56d2559).)
+
+-----
+
+## 🗂️ What's Inside (File Guide)
+
+  * `distributed_muon_cpu.ipynb`: **(Start Here)** The Colab-friendly notebook that walks through the environment fixes and runs the code.
+  * `distributed_muon_cpu.py`: The final, **tested, fixed, and heavily-annotated** Python script. This is the "golden" code that runs on a CPU-only environment using the `"gloo"` backend.
+  * `distributed_muon.py`: My **annotated and logically debugged** version of the *GPU* code. This is for users who have a multi-GPU `"nccl"` environment. (Note: Since I don't have a multi-GPU cluster, this version is untested... unless someone wants to sponsor me with some GPUs! 😉)
+
+-----
+
+## 🎓 What You'll Learn (The "Nightmare" Blueprint)
+
+By exploring this code, you'll see the *real* implementation of the concepts I discuss in my articles:
+
+  * **The 2D Grid:** How to set up orthogonal `dist_group` (DP) and `tp_group` (TP) handles.
+  * **The "Aisles" & "Pallets":** How `param_groups` (`buffer_idx`) and communication `buckets` (`bucket_idx`) are used to organize parameters.
+  * **The "Virtual Buffer":** How a "master plan" (`dist_meta` and `global_buffer_size`) is used to manage memory for sharding (ZeRO-1).
+  * **The Acrobatic Data Flow:** The full `(DP gather -> TP gather) -> (Run Math) -> (TP shard -> DP shard)` journey.
+  * **The Nuance:** You'll see *why* we bucket the slow DP `all_gather` but *don't* need to bucket the fast, on-node TP `all_gather`.
+
+-----
+
+## 🐞 Summary of All Fixes
+
+This repo isn't just a copy-paste. It's the result of a week-long debugging "nightmare." Here are all the bugs we had to find and fix to make it run:
+
+| Issue | Problem | Solution |
+| :--- | :--- | :--- |
+| **Logic Bug \#1** | Missing `params = group["params"]` | Added the line in the Muon update loop. |
+| **Logic Bug \#2** | `ns_input` was 1D after unpacking, crashing `zeropower`.| Changed `.view(-1)` to `.view(dist_meta.shape)` to restore the 2D shape. |
+| **Systems Bug** | Hardcoded `bfloat16` | Changed to `float32` (`first_param.dtype`) to work with the `"gloo"` (CPU) backend. |
+| **Env Bug \#1** | Hardcoded `"nccl"` backend. | Changed `dist.init_process_group` to use `"gloo"`. |
+| **Env Bug \#2** | Hardcoded `'cuda'` device. | Changed `gen_param_and_grads` to use `'cpu'`. |
+| **Env Bug \#3** | `mp.spawn()` crashes in Jupyter/Colab. | The `.ipynb` runs the code as a `!python` subprocess, bypassing the notebook kernel. |
+
+-----
+
+## 📖 Citation
+
+If you use this tutorial in your work, please cite the original Muon paper and this tutorial.
+
+```bibtex
+@misc{wei2025muondistributed,
+  author = {Wei, Jen},
+  title = {A CPU-Friendly Tutorial for Distributed Muon (DPxTP)},
+  year = {2025},
+  howpublished = {\url{[https://huggingface.co/datasets/](https://huggingface.co/datasets/)<your-hf-handle>/muon-distributed}}
+}
+
+@misc{jordan2024muon,
+  author = {Jordan, Keller, et al.},
+  title = {Muon: An optimizer for hidden layers in neural networks},
+  year = {2024},
+  url = {[https://kellerjordan.github.io/posts/muon/](https://kellerjordan.github.io/posts/muon/)}
+}
+
+@misc{liu2025muonscalable,
+  author = {Liu, Jingyuan, et al.},
+  title = {Muon is Scalable for LLM Training},
+  year = {2025},
+  url = {[https://arxiv.org/abs/2502.16982](https://arxiv.org/abs/2502.16982)}
+}
+```

distributed_muon.py

@@ -0,0 +1,555 @@
+# megatron/core/optimizer/muon.py
+from typing import Tuple, Dict
+import torch
+import math
+import torch.distributed as dist
+
+
+# copy from https://github.com/KellerJordan/Muon/tree/master
+# @torch.compile
+def zeropower_via_newtonschulz5(G, steps):
+    """
+    Newton-Schulz iteration to compute the zeroth power / orthogonalization of G. We opt to use a
+    quintic iteration whose coefficients are selected to maximize the slope at zero. For the purpose
+    of minimizing steps, it turns out to be empirically effective to keep increasing the slope at
+    zero even beyond the point where the iteration no longer converges all the way to one everywhere
+    on the interval. This iteration therefore does not produce UV^T but rather something like US'V^T
+    where S' is diagonal with S_{ii}' ~ Uniform(0.5, 1.5), which turns out not to hurt model
+    performance at all relative to UV^T, where USV^T = G is the SVD.
+    """
+    assert len(G.shape) == 2
+    a, b, c = (3.4445, -4.7750,  2.0315)
+    X = G
+    if G.size(0) > G.size(1):
+        X = X.T
+
+    # Ensure spectral norm is at most 1
+    X = X / (X.norm() + 1e-7)
+    # Perform the NS iterations
+    for _ in range(steps):
+        A = X @ X.T
+        B = b * A + c * A @ A # adapted from suggestion by @jxbz, @leloykun, and @YouJiacheng
+        X = a * X + B @ X
+
+    if G.size(0) > G.size(1):
+        X = X.T
+    return X
+
+def normalize_range(range: Tuple[int, int], start):
+    return (range[0] - start, range[1] - start)
+
+class MuonDistMeta:
+
+    # which buffer and bucket param belongs to
+    buffer_idx: int = 0
+    bucket_idx: int = 0
+    # param shape after tp
+    shape: torch.Size = None
+    # param location in global buffer
+    global_range: Tuple[int, int] = None
+    tp_split_dim: int = -1
+    # param location in global buffer (current dp slice)
+    local_range: Tuple[int, int] = None
+
+    def __init__(self, buffer_idx: int, bucket_idx: int, shape: torch.Size, global_range: Tuple[int, int], tp_split_dim: int):
+        self.buffer_idx = buffer_idx
+        self.bucket_idx = bucket_idx
+        self.shape = shape
+        self.global_range = global_range
+        self.tp_split_dim = tp_split_dim
+
+    def set_local_buffer_range(self,  local_buffer_range: Tuple[int, int]):
+        start = max(self.global_range[0], local_buffer_range[0])
+        end = min(self.global_range[1], local_buffer_range[1])
+        self.local_range = (start, end) if start < end else (local_buffer_range[0], local_buffer_range[0])
+
+# adjust LR based on: https://github.com/MoonshotAI/Moonlight
+def adjust_lr_wd_for_muon(lr, matched_adamw_rms, param_shape):
+    A, B = param_shape[:2]
+    adjusted_ratio = math.sqrt(max(A, B)) * matched_adamw_rms
+    adjusted_lr = lr * adjusted_ratio
+    return adjusted_lr
+
+# copy from https://github.com/KellerJordan/Muon/tree/master and support distributed solution
+class Muon(torch.optim.Optimizer):
+    """
+    Muon - MomentUm Orthogonalized by Newton-schulz
+    Muon internally runs standard SGD-momentum, and then performs an orthogonalization post-
+    processing step, in which each 2D parameter's update is replaced with the nearest orthogonal
+    matrix. To efficiently orthogonalize each update, we use a Newton-Schulz iteration, which has
+    the advantage that it can be stably run in bfloat16 on the GPU.
+    Some warnings:
+    - We believe this optimizer is unlikely to work well for training with small batch size.
+    - We believe it may not work well for finetuning pretrained models, but we haven't tested this.
+    Arguments:
+        param_groups: The parameters to be optimized.
+        lr: The learning rate. The updates will have spectral norm of `lr`. (0.02 is a good default)
+        momentum: The momentum used by the internal SGD. (0.95 is a good default)
+        matched_adamw_rms: The AdamW Update RMS that Muon is designed to match. (0.2~0.4 recommended)
+        nesterov: Whether to use Nesterov-style momentum in the internal SGD. (recommended)
+        ns_steps: The number of Newton-Schulz iterations to run. (5 is probably always enough)
+        {0, 1}-D or are detected as being the embed or lm_head will be optimized by AdamW as well.
+        adamw_betas: The betas for the internal AdamW.
+        adamw_eps: The epsilon for the internal AdamW.
+        adamw_wd: The weight decay for the internal AdamW.
+    """
+    def __init__(self, param_groups, lr=2e-2, weight_decay=0.1,
+                 matched_adamw_rms=0.2, momentum=0.95, nesterov=True, ns_steps=5,
+                 adamw_betas=(0.95, 0.95), adamw_eps=1e-8):
+
+        defaults = dict(lr=lr, weight_decay=weight_decay,
+                        matched_adamw_rms=matched_adamw_rms,
+                        momentum=momentum, nesterov=nesterov, ns_steps=ns_steps,
+                        adamw_betas=adamw_betas, adamw_eps=adamw_eps,)
+
+        super().__init__(param_groups, defaults)
+        self.distributed_mode = False
+
+
+    def enable_distributed_mode(self, global_buffer_sizes, dist_group, tp_group,
+                                dist_metas: Dict[torch.nn.Parameter, MuonDistMeta]):
+        """
+        enable distributed mode
+        Args:
+            global_buffer_size: global buffer size
+            dist group: optimizer sharding group
+            tp group: param tp group
+            dist metas: dist metas for all param
+        """
+
+        self.global_buffer_sizes = global_buffer_sizes
+        self.dist_group = dist_group
+        self.tp_group = tp_group
+        self.dist_metas = dist_metas
+
+        world_size = dist.get_world_size(dist_group)
+        rank = dist.get_rank(dist_group)
+
+        # calc local buffer range
+        self.local_buffer_sizes = []
+        self.local_buffer_ranges = []
+        # The outer loop is for different parameter groups (e.g., weights vs. biases)
+        for global_bucket_sizes in global_buffer_sizes: # <--- rename `global_bucket_sizes`
+            local_bucket_sizes = []
+            local_bucket_ranges = []
+
+            # The inner loop is for the different buckets within a single group
+            for (global_bucket_size, bucket_offset) in global_bucket_sizes:
+                # calculate the local range for THIS specific bucket
+                assert global_bucket_size % world_size == 0
+                local_bucket_size = global_bucket_size // world_size
+                # Renaming here makes the logic so much clearer
+                local_bucket_start = local_bucket_size * rank + bucket_offset
+                local_buffer_range = (local_bucket_start, local_bucket_start + local_bucket_size)
+                local_bucket_sizes.append(local_bucket_size)
+                local_bucket_ranges.append(local_buffer_range)
+
+            self.local_buffer_sizes.append(local_bucket_sizes)
+            self.local_buffer_ranges.append(local_bucket_ranges)
+
+        # calc local range for params
+        for dist_meta in dist_metas.values():
+            local_buffer_range = self.local_buffer_ranges[dist_meta.buffer_idx][dist_meta.bucket_idx]
+            dist_meta.set_local_buffer_range(local_buffer_range)
+
+        self.distributed_mode = True
+
+    def step(self):
+
+        dtype = torch.bfloat16
+        device = torch.cuda.current_device()
+
+        ns_inputs = {}
+
+        # update muon momentum first
+        # `self.param_groups` is already sharded
+        for group in self.param_groups:
+
+            if not group.get("use_muon", False):
+                continue
+
+            momentum = group['momentum']
+            params = group["params"]
+
+            for p in params:
+
+                g = p.grad
+                assert g is not None
+                # 1-dim grad for distributed mode
+                assert self.distributed_mode or g.dim() == 2
+
+                # prepare muon buffer in state
+                state = self.state[p]
+                if not "muon_buffer" in state:
+                    state["muon_buffer"] = torch.zeros_like(g)
+                buf = state["muon_buffer"]
+                buf.mul_(momentum).add_(g)
+
+                # save to ns input
+                g = g.add(buf, alpha=momentum) if group['nesterov'] else buf
+                ns_inputs[p] = g.bfloat16()
+
+        # rewrite ns_inputs if distributed
+        """
+        the four-step "acrobatic" journey of the ns_inputs data:
+
+        1.  **DP `all_gather`**: (ZeRO) Gather all the sharded pieces from your data-parallel "column" to re-create your **full TP slice**.
+        2.  **TP `all_gather`**: Gather all the TP slices from your tensor-parallel "row" to re-create the **full, 100% complete matrix**.
+        3.  *(...Run the math on the full matrix...)*
+        4.  **TP `shard`**: Shard the full `update` matrix back down to your **local TP slice**.
+        5.  **DP `shard`**: (ZeRO) Shard that TP slice *again* back down to the **local DP/ZeRO slice** that you're responsible for.
+
+        """
+        if self.distributed_mode:
+
+            # initialize buffers 
+            # hanged the variable nnames to `local_bucket_size` and `global_bucket_size` for clarity
+            ns_input_local_buffers = [
+                [ torch.empty((local_bucket_size), device=device, dtype=dtype)
+                    for local_bucket_size in local_bucket_sizes ]
+                for local_bucket_sizes in self.local_buffer_sizes
+            ]
+            ns_input_global_buffers = [
+                [ torch.empty((global_bucket_size), device=device, dtype=dtype)
+                    for (global_bucket_size, bucket_offset) in global_bucket_sizes ]
+                for global_bucket_sizes in self.global_buffer_sizes
+            ]
+
+            # fill ns input data to local buffer
+            # looping through all params in local rank, ok.
+            for param, ns_input in ns_inputs.items():
+                dist_meta = self.dist_metas[param]
+                # ceate a reference to `ns_input_local_buffers`
+                # the update is in local rank, so we only need one `for` loop
+                ns_input_local_buffer = ns_input_local_buffers[dist_meta.buffer_idx][dist_meta.bucket_idx]
+                local_buffer_range = self.local_buffer_ranges[dist_meta.buffer_idx][dist_meta.bucket_idx]
+                local_range = normalize_range(dist_meta.local_range, local_buffer_range[0]) # local_range in global_range
+                # copy data into this `ns_input_local_buffer` memory
+                # because dist.all_gather requires a single, physically contiguous block of memory to work efficiently.
+                ns_input_local_buffer[local_range[0]:local_range[1]].copy_(ns_input.view(-1))
+
+            # all gather buffers: one bucket at a time. -- the "shipping" phase
+            for ns_input_global_buffer, ns_input_local_buffer in zip(ns_input_global_buffers, ns_input_local_buffers):
+                for ns_input_global_bucket, ns_input_local_bucket in zip(ns_input_global_buffer, ns_input_local_buffer):
+                    dist.all_gather_into_tensor(ns_input_global_bucket, ns_input_local_bucket, group=self.dist_group)
+
+            # overwrite ns input with the `all_gather`-ed `ns_inputs` -- the "unpacking" phase
+            # this is the "opposite" of filling ns input data to local buffer
+            for p in ns_inputs.keys():
+                dist_meta = self.dist_metas[p]
+                ns_input_global_buffer = ns_input_global_buffers[dist_meta.buffer_idx][dist_meta.bucket_idx]
+                offset = self.global_buffer_sizes[dist_meta.buffer_idx][dist_meta.bucket_idx][1]
+                global_range = normalize_range(dist_meta.global_range, offset)
+
+                #ns_inputs[p] = ns_input_global_buffer[global_range[0]:global_range[1]].view(-1) 
+                ## bug fix 👆🏻-- overwrite ns input with the `all_gather`-ed `ns_inputs` -- the "unpacking" phase
+                #ns_inputs[p] = ns_input_global_buffer[global_range[0]:global_range[1]].view(-1)
+                # Unpack the 1D slice of data
+                unpacked_data = ns_input_global_buffer[global_range[0]:global_range[1]]
+
+                # THIS IS THE FIX: Reshape it to its correct 2D shape, not view(-1)
+                ns_inputs[p] = unpacked_data.view(dist_meta.shape)    
+
+            # set tp info
+            tp_world_size = dist.get_world_size(self.tp_group)
+            tp_rank = dist.get_rank(self.tp_group)
+
+        # update muon momentum first
+        for group in self.param_groups:
+
+            if not group.get('use_muon', False):
+                continue
+
+            lr = group["lr"]
+            ns_steps = group["ns_steps"]
+            weight_decay = group["weight_decay"]
+            matched_adamw_rms = group["matched_adamw_rms"]
+            params = group["params"] # <-- add this
+
+            for p in params:
+
+                ns_input = ns_inputs[p]
+                tp_split_dim = -1
+
+                if self.distributed_mode:
+                    dist_meta = self.dist_metas[p]
+                    tp_split_dim = dist_meta.tp_split_dim
+
+                # gather tensor parallel ( if tp )
+                if tp_split_dim != -1:
+                    ns_input_shards = [ torch.empty_like(ns_input) for _ in range(tp_world_size) ]
+                    dist.all_gather(ns_input_shards, ns_input, self.tp_group)
+                    ns_input = torch.cat(ns_input_shards, dim=tp_split_dim)
+
+                # calc update
+                update = zeropower_via_newtonschulz5(ns_input, steps=ns_steps)
+
+                # only local tp part
+                # this is effectivly "shadding" the newtonschulz-processed update, 
+                # and keep only your assigned piece, discarding the rest
+                if tp_split_dim != -1:
+                    update = update.chunk(tp_world_size, dim=tp_split_dim)[tp_rank]
+
+                # only local dp buffer part
+                if self.distributed_mode:
+                    # local range in global range
+                    # unpacking the tp sharded update to dp sharded update
+                    local_range = normalize_range(dist_meta.local_range, dist_meta.global_range[0])
+                    update = update.reshape(-1)[local_range[0]:local_range[1]]
+
+                # apply weight decay
+                p.data.mul_(1 - lr*weight_decay)
+
+                #  adjust lr and apply update
+                adjusted_lr = adjust_lr_wd_for_muon(lr, matched_adamw_rms, ns_input.shape)
+                p.data.add_(update, alpha=-adjusted_lr)
+
+        # use adam for other params
+        for group in self.param_groups:
+
+            if group.get('use_muon', False):
+                continue
+
+            # init step
+            if 'step' in group:
+                group['step'] += 1
+            else:
+                group['step'] = 1
+
+            step = group['step']
+            params = group["params"]
+            lr = group['lr']
+            weight_decay = group['weight_decay']
+            beta1, beta2 = group['adamw_betas']
+            eps = group['adamw_eps']
+
+            for p in params:
+
+                g = p.grad
+                assert g is not None
+                state = self.state[p]
+
+                if len(state) == 0:
+                    state['adamw_exp_avg'] = torch.zeros_like(g)
+                    state['adamw_exp_avg_sq'] = torch.zeros_like(g)
+
+                buf1 = state['adamw_exp_avg']
+                buf2 = state['adamw_exp_avg_sq']
+                buf1.lerp_(g, 1-beta1)
+                buf2.lerp_(g.square(), 1-beta2)
+
+                g = buf1 / (eps + buf2.sqrt())
+
+                bias_correction1 = 1 - beta1**step
+                bias_correction2 = 1 - beta2**step
+                scale = bias_correction1 / bias_correction2**0.5
+                p.data.mul_(1 - lr * weight_decay)
+                p.data.add_(g, alpha=-lr/scale)
+
+
+##--------------- tests/unit_tests/test_optimizer_muon.py -----------------
+import os
+
+import torch
+import torch.distributed as dist
+
+#from megatron.core.optimizer.muon import Muon, MuonDistMeta, normalize_range
+
+def is_rank_0():
+    return torch.distributed.get_rank() == 0
+
+def print_rank_0(*args):
+    if is_rank_0():
+        print(*args)
+
+def cdiv(x: int, y: int):
+    return (x + y - 1) // y
+
+def gen_param_and_grads():
+
+    # reset manual seed
+    torch.manual_seed(0)
+    torch.cuda.manual_seed(0)
+    device = 'cuda'
+    dtype = torch.float32
+
+    # gen params
+    params = [ torch.randn(shape, device=device, dtype=dtype) for shape in [
+            (100, 100), (124, 324), (456, 124), (676, 876), (128, 128), ] ]
+
+    # gen grads [ [ grad-list ] * step ]
+    grads = [ [ torch.randn_like(param) for param in params ] for _ in range(10) ]
+
+    return params, grads
+
+def distribute_params(params, grads, tp_dims, dist_group, tp_group):
+    """ 将 param 进行 dist & tp shard, 仅保留自己的一部分 """
+
+    params = params.copy()
+    grads = [ step_grads.copy() for step_grads in grads ]
+
+    # tp dist
+    tp_size = dist.get_world_size(tp_group)
+    tp_rank = dist.get_rank(tp_group)
+    for i, param in enumerate(params):
+        tp_dim = tp_dims[i]
+        if tp_dim == -1:
+            continue
+        # Shard the parameter tensor along the `tp_dim` dimension.
+        assert param.shape[tp_dim] % tp_size == 0
+        local_range_start = param.shape[tp_dim] // tp_size * tp_rank
+        # range of the shard based on the rank of the current GOU in the given `tp_group``
+        local_range_end = param.shape[tp_dim] // tp_size * (tp_rank + 1)
+        # each GPU gets `[local_range_start:local_range_end, :] ` rows or `[:, local_range_start:local_range_end]` columns
+        params[i] = param[local_range_start:local_range_end, :] if tp_dim == 0 else \
+                    param[:, local_range_start:local_range_end].contiguous()
+        # same logic applies to sharding the gradients for the current layer(param)
+        for step_grads in grads:
+            step_grads[i] = step_grads[i][local_range_start:local_range_end, :] if tp_dim == 0 else \
+                            step_grads[i][:, local_range_start:local_range_end].contiguous()
+
+    # distributed
+    world_size = dist.get_world_size(dist_group)
+    rank = dist.get_rank(dist_group)
+
+    # global as the given DP group
+    # "global" here means "global to the TP group's worth of parameters."
+    global_buffer_size = sum(param.numel() for param in params)
+    local_buffer_size = cdiv(global_buffer_size, world_size)
+    # deciding the shard range for this rank
+    local_buffer_range = (local_buffer_size * rank, local_buffer_size * (rank + 1))
+    # padded global_buffer_size
+    global_buffer_size = local_buffer_size * world_size # fix global buffer size
+
+    numel_acc = 0
+    dist_params = []
+    dist_grads = [[] for _ in grads]
+    dist_metas = {}
+    for i, param in enumerate(params):
+
+        # gen meta
+        # align global buffer index(range) with local buffer index(range)
+        # see handwritten diagram for more details
+        numel = param.numel()
+        dist_meta = MuonDistMeta(0, 0, param.shape, (numel_acc, numel_acc + numel), tp_dims[i])
+        dist_meta.set_local_buffer_range(local_buffer_range)
+        numel_acc += numel
+
+        # skip if no element in this shard
+        if dist_meta.local_range[0] == dist_meta.local_range[1]:
+            continue
+
+        # gen param
+
+        # Convert the ABSOLUTE slice range (from the global virtual buffer)
+        # into a RELATIVE slice range (local to just this one parameter).
+        local_range = normalize_range(dist_meta.local_range, dist_meta.global_range[0]) 
+        
+        # 1. Flatten the 2D parameter tensor into a 1D vector.
+        # 2. Use the relative range to slice out the piece this GPU is responsible for storing.
+        dist_param = param.view(-1)[local_range[0]:local_range[1]]
+        dist_params.append(dist_param)
+        dist_metas[dist_param] = dist_meta
+
+        # gen grad
+        # same logoc as the `gen param` scetion
+        for step, step_grads in enumerate(grads):
+            dist_grad = step_grads[i].view(-1)[local_range[0]:local_range[1]]
+            dist_grads[step].append(dist_grad)
+
+    return dist_params, dist_grads, global_buffer_size, dist_metas
+
+
+def test_muon_dist(dp_size, tp_size):
+
+    world_size = dist.get_world_size()
+    rank = dist.get_rank()
+    assert dp_size * tp_size == world_size
+
+    # init dist group
+    for i in range(tp_size):
+        # decide the tp group based on grod of size `tp_size`
+        ranks = range(i, world_size, tp_size)
+        group = dist.new_group(ranks)
+        # each rank finds its groups
+        if rank in ranks:
+            # groups are passed as instructions
+            dist_group = group
+    # init tp group
+    for i in range(dp_size):
+        ranks = range(i * tp_size, (i + 1) * tp_size)
+        group = dist.new_group(ranks)
+        if rank in ranks:
+            tp_group = group
+
+    print_rank_0("process group initialized")
+
+    params_ref, grads_ref = gen_param_and_grads()
+    params_test, grads_test = gen_param_and_grads()
+    tp_dims = [0, 1, -1, 1, 0]
+
+    # global_buffer_size is the padded buffer size of the dp group where the current rank belongs to
+    params_test, grads_test, global_buffer_size, dist_metas \
+         = distribute_params(params_test, grads_test, tp_dims, dist_group, tp_group)
+
+    muon_args = {
+        "use_muon": True,
+        "lr": 0.1,
+        "momentum": 0.9,
+        "nesterov": True,
+        "ns_steps": 5,
+        "weight_decay": 0.1,
+    }
+
+    # gen params
+    ref_param_groups = [{
+        "params": params_ref,
+        **muon_args
+    }]
+    test_param_groups = [{
+        "params": params_test,
+        **muon_args
+    }]
+
+    ref_muon  = Muon(ref_param_groups)
+    test_muon = Muon(test_param_groups)
+    test_muon.enable_distributed_mode([[(global_buffer_size, 0)]], dist_group, tp_group, dist_metas)
+
+    for step in range(10):
+
+        # add grad
+        for i, grad in enumerate(grads_ref[step]):
+            params_ref[i].grad = grad.clone()
+        for i, grad in enumerate(grads_test[step]):
+            params_test[i].grad = grad.clone()
+        # step
+        ref_muon.step()
+        test_muon.step()
+        # distribute ref params
+        dist_ref_params, _, _, _ = distribute_params(params_ref, [], tp_dims, dist_group, tp_group)
+        # verify
+        for i, params_x2 in enumerate(zip(dist_ref_params, params_test)):
+            assert (params_x2[0] == params_x2[1]).all(), f"rank {rank} param {i} verify failed"
+        print_rank_0(f" - step {step} verify passed")
+
+    print_rank_0(f"dist dp = {dp_size} tp = {tp_size} test passed")
+
+def run_process(rank, world_size):
+
+    # init dist
+    torch.cuda.set_device(rank)
+    dist.init_process_group("nccl", rank=rank, world_size=world_size)
+
+    test_muon_dist(dp_size=4, tp_size=2)
+    test_muon_dist(dp_size=2, tp_size=4)
+
+    dist.destroy_process_group()
+
+if __name__ == "__main__":
+
+    world_size = 8
+    os.environ['MASTER_ADDR'] = 'localhost'
+    os.environ['MASTER_PORT'] = '12345'
+    os.environ['CUDA_DEVICE_MAX_CONNECTIONS'] = '1'
+
+    torch.multiprocessing.spawn(run_process, args=(world_size,), nprocs=world_size, join=True)

distributed_muon_cpu.ipynb

@@ -0,0 +1,719 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "s0j9J9zu4v00"
+   },
+   "source": [
+    "**Muon is scalable for LLM Trainings -- Optimized and tested code**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "kXO67qguR1cD",
+    "outputId": "74e0a52d-36dd-4313-e9d5-76763a06d591"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✅ Test code written to /content/test_muon_dist.py\n",
+      "\n",
+      "Now run it with:\n",
+      "!python /content/test_muon_dist.py\n"
+     ]
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "COLAB WORKAROUND: Write code to file and run as subprocess\n",
+    "This avoids the multiprocessing limitations in Jupyter notebooks\n",
+    "\"\"\"\n",
+    "test_code = '''\n",
+    "\n",
+    "# Step 1: Write the distributed test code to a file\n",
+    "\n",
+    "import os\n",
+    "import sys\n",
+    "import torch\n",
+    "import torch.distributed as dist\n",
+    "import torch.multiprocessing as mp\n",
+    "import math\n",
+    "from typing import Tuple, Dict\n",
+    "\n",
+    "\n",
+    "# copy from https://github.com/KellerJordan/Muon/tree/master\n",
+    "# @torch.compile\n",
+    "def zeropower_via_newtonschulz5(G, steps):\n",
+    "    \"\"\"\n",
+    "    Newton-Schulz iteration to compute the zeroth power / orthogonalization of G. We opt to use a\n",
+    "    quintic iteration whose coefficients are selected to maximize the slope at zero. For the purpose\n",
+    "    of minimizing steps, it turns out to be empirically effective to keep increasing the slope at\n",
+    "    zero even beyond the point where the iteration no longer converges all the way to one everywhere\n",
+    "    on the interval. This iteration therefore does not produce UV^T but rather something like US'V^T\n",
+    "    where S' is diagonal with S_{ii}' ~ Uniform(0.5, 1.5), which turns out not to hurt model\n",
+    "    performance at all relative to UV^T, where USV^T = G is the SVD.\n",
+    "    \"\"\"\n",
+    "    assert len(G.shape) == 2\n",
+    "    a, b, c = (3.4445, -4.7750,  2.0315)\n",
+    "    X = G\n",
+    "    if G.size(0) > G.size(1):\n",
+    "        X = X.T\n",
+    "\n",
+    "    # Ensure spectral norm is at most 1\n",
+    "    X = X / (X.norm() + 1e-7)\n",
+    "    # Perform the NS iterations\n",
+    "    for _ in range(steps):\n",
+    "        A = X @ X.T\n",
+    "        B = b * A + c * A @ A # adapted from suggestion by @jxbz, @leloykun, and @YouJiacheng\n",
+    "        X = a * X + B @ X\n",
+    "\n",
+    "    if G.size(0) > G.size(1):\n",
+    "        X = X.T\n",
+    "    return X\n",
+    "\n",
+    "def normalize_range(range: Tuple[int, int], start):\n",
+    "    return (range[0] - start, range[1] - start)\n",
+    "\n",
+    "class MuonDistMeta:\n",
+    "\n",
+    "    # which buffer and bucket param belongs to\n",
+    "    buffer_idx: int = 0\n",
+    "    bucket_idx: int = 0\n",
+    "    # param shape after tp\n",
+    "    shape: torch.Size = None\n",
+    "    # param location in global buffer\n",
+    "    global_range: Tuple[int, int] = None\n",
+    "    tp_split_dim: int = -1\n",
+    "    # param location in global buffer (current dp slice)\n",
+    "    local_range: Tuple[int, int] = None\n",
+    "\n",
+    "    def __init__(self, buffer_idx: int, bucket_idx: int, shape: torch.Size, global_range: Tuple[int, int], tp_split_dim: int):\n",
+    "        self.buffer_idx = buffer_idx\n",
+    "        self.bucket_idx = bucket_idx\n",
+    "        self.shape = shape\n",
+    "        self.global_range = global_range\n",
+    "        self.tp_split_dim = tp_split_dim\n",
+    "\n",
+    "    def set_local_buffer_range(self,  local_buffer_range: Tuple[int, int]):\n",
+    "        start = max(self.global_range[0], local_buffer_range[0])\n",
+    "        end = min(self.global_range[1], local_buffer_range[1])\n",
+    "        self.local_range = (start, end) if start < end else (local_buffer_range[0], local_buffer_range[0])\n",
+    "\n",
+    "# adjust LR based on: https://github.com/MoonshotAI/Moonlight\n",
+    "def adjust_lr_wd_for_muon(lr, matched_adamw_rms, param_shape):\n",
+    "    A, B = param_shape[:2]\n",
+    "    adjusted_ratio = math.sqrt(max(A, B)) * matched_adamw_rms\n",
+    "    adjusted_lr = lr * adjusted_ratio\n",
+    "    return adjusted_lr\n",
+    "\n",
+    "# copy from https://github.com/KellerJordan/Muon/tree/master and support distributed solution\n",
+    "class Muon(torch.optim.Optimizer):\n",
+    "    \"\"\"\n",
+    "    Muon - MomentUm Orthogonalized by Newton-schulz\n",
+    "    Muon internally runs standard SGD-momentum, and then performs an orthogonalization post-\n",
+    "    processing step, in which each 2D parameter's update is replaced with the nearest orthogonal\n",
+    "    matrix. To efficiently orthogonalize each update, we use a Newton-Schulz iteration, which has\n",
+    "    the advantage that it can be stably run in bfloat16 on the GPU.\n",
+    "    Some warnings:\n",
+    "    - We believe this optimizer is unlikely to work well for training with small batch size.\n",
+    "    - We believe it may not work well for finetuning pretrained models, but we haven't tested this.\n",
+    "    Arguments:\n",
+    "        param_groups: The parameters to be optimized.\n",
+    "        lr: The learning rate. The updates will have spectral norm of `lr`. (0.02 is a good default)\n",
+    "        momentum: The momentum used by the internal SGD. (0.95 is a good default)\n",
+    "        matched_adamw_rms: The AdamW Update RMS that Muon is designed to match. (0.2~0.4 recommended)\n",
+    "        nesterov: Whether to use Nesterov-style momentum in the internal SGD. (recommended)\n",
+    "        ns_steps: The number of Newton-Schulz iterations to run. (5 is probably always enough)\n",
+    "        {0, 1}-D or are detected as being the embed or lm_head will be optimized by AdamW as well.\n",
+    "        adamw_betas: The betas for the internal AdamW.\n",
+    "        adamw_eps: The epsilon for the internal AdamW.\n",
+    "        adamw_wd: The weight decay for the internal AdamW.\n",
+    "    \"\"\"\n",
+    "    def __init__(self, param_groups, lr=2e-2, weight_decay=0.1,\n",
+    "                 matched_adamw_rms=0.2, momentum=0.95, nesterov=True, ns_steps=5,\n",
+    "                 adamw_betas=(0.95, 0.95), adamw_eps=1e-8):\n",
+    "\n",
+    "        defaults = dict(lr=lr, weight_decay=weight_decay,\n",
+    "                        matched_adamw_rms=matched_adamw_rms,\n",
+    "                        momentum=momentum, nesterov=nesterov, ns_steps=ns_steps,\n",
+    "                        adamw_betas=adamw_betas, adamw_eps=adamw_eps,)\n",
+    "\n",
+    "        super().__init__(param_groups, defaults)\n",
+    "        self.distributed_mode = False\n",
+    "\n",
+    "\n",
+    "    def enable_distributed_mode(self, global_buffer_sizes, dist_group, tp_group,\n",
+    "                                dist_metas: Dict[torch.nn.Parameter, MuonDistMeta]):\n",
+    "        \"\"\"\n",
+    "        enable distributed mode\n",
+    "        Args:\n",
+    "            global_buffer_size: global buffer size\n",
+    "            dist group: optimizer sharding group\n",
+    "            tp group: param tp group\n",
+    "            dist metas: dist metas for all param\n",
+    "        \"\"\"\n",
+    "\n",
+    "        self.global_buffer_sizes = global_buffer_sizes\n",
+    "        self.dist_group = dist_group\n",
+    "        self.tp_group = tp_group\n",
+    "        self.dist_metas = dist_metas\n",
+    "\n",
+    "        world_size = dist.get_world_size(dist_group)\n",
+    "        rank = dist.get_rank(dist_group)\n",
+    "\n",
+    "        # calc local buffer range\n",
+    "        self.local_buffer_sizes = []\n",
+    "        self.local_buffer_ranges = []\n",
+    "        # The outer loop is for different parameter groups (e.g., weights vs. biases)\n",
+    "        for global_bucket_sizes in global_buffer_sizes: # <--- rename `global_bucket_sizes`\n",
+    "            local_bucket_sizes = []\n",
+    "            local_bucket_ranges = []\n",
+    "\n",
+    "            # The inner loop is for the different buckets within a single group\n",
+    "            for (global_bucket_size, bucket_offset) in global_bucket_sizes:\n",
+    "                # calculate the local range for THIS specific bucket\n",
+    "                assert global_bucket_size % world_size == 0\n",
+    "                local_bucket_size = global_bucket_size // world_size\n",
+    "                # Renaming here makes the logic so much clearer\n",
+    "                local_bucket_start = local_bucket_size * rank + bucket_offset\n",
+    "                local_buffer_range = (local_bucket_start, local_bucket_start + local_bucket_size)\n",
+    "                local_bucket_sizes.append(local_bucket_size)\n",
+    "                local_bucket_ranges.append(local_buffer_range)\n",
+    "\n",
+    "            self.local_buffer_sizes.append(local_bucket_sizes)\n",
+    "            self.local_buffer_ranges.append(local_bucket_ranges)\n",
+    "\n",
+    "        # calc local range for params\n",
+    "        for dist_meta in dist_metas.values():\n",
+    "            local_buffer_range = self.local_buffer_ranges[dist_meta.buffer_idx][dist_meta.bucket_idx]\n",
+    "            dist_meta.set_local_buffer_range(local_buffer_range)\n",
+    "\n",
+    "        self.distributed_mode = True\n",
+    "\n",
+    "    def step(self):\n",
+    "        first_param = self.param_groups[0]['params'][0]\n",
+    "        device = first_param.device\n",
+    "        dtype = torch.bfloat16\n",
+    "\n",
+    "        ns_inputs = {}\n",
+    "\n",
+    "        # update muon momentum first\n",
+    "        # `self.param_groups` is already sharded\n",
+    "        for group in self.param_groups:\n",
+    "\n",
+    "            if not group.get(\"use_muon\", False):\n",
+    "                continue\n",
+    "\n",
+    "            momentum = group['momentum']\n",
+    "            params = group[\"params\"]\n",
+    "\n",
+    "            for p in params:\n",
+    "\n",
+    "                g = p.grad\n",
+    "                assert g is not None\n",
+    "                # 1-dim grad for distributed mode\n",
+    "                assert self.distributed_mode or g.dim() == 2\n",
+    "\n",
+    "                # prepare muon buffer in state\n",
+    "                state = self.state[p]\n",
+    "                if not \"muon_buffer\" in state:\n",
+    "                    state[\"muon_buffer\"] = torch.zeros_like(g)\n",
+    "                buf = state[\"muon_buffer\"]\n",
+    "                buf.mul_(momentum).add_(g)\n",
+    "\n",
+    "                # save to ns input\n",
+    "                g = g.add(buf, alpha=momentum) if group['nesterov'] else buf\n",
+    "                ns_inputs[p] = g.bfloat16()\n",
+    "\n",
+    "        # rewrite ns_inputs if distributed\n",
+    "        \"\"\"\n",
+    "        the four-step \"acrobatic\" journey of the ns_inputs data:\n",
+    "\n",
+    "        1.  **DP `all_gather`**: (ZeRO) Gather all the sharded pieces from your data-parallel \"column\" to re-create your **full TP slice**.\n",
+    "        2.  **TP `all_gather`**: Gather all the TP slices from your tensor-parallel \"row\" to re-create the **full, 100% complete matrix**.\n",
+    "        3.  *(...Run the math on the full matrix...)*\n",
+    "        4.  **TP `shard`**: Shard the full `update` matrix back down to your **local TP slice**.\n",
+    "        5.  **DP `shard`**: (ZeRO) Shard that TP slice *again* back down to the **local DP/ZeRO slice** that you're responsible for.\n",
+    "\n",
+    "        \"\"\"\n",
+    "        if self.distributed_mode:\n",
+    "\n",
+    "            # initialize buffers\n",
+    "            # hanged the variable nnames to `local_bucket_size` and `global_bucket_size` for clarity\n",
+    "            ns_input_local_buffers = [\n",
+    "                [ torch.empty((local_bucket_size), device=device, dtype=dtype)\n",
+    "                    for local_bucket_size in local_bucket_sizes ]\n",
+    "                for local_bucket_sizes in self.local_buffer_sizes\n",
+    "            ]\n",
+    "            ns_input_global_buffers = [\n",
+    "                [ torch.empty((global_bucket_size), device=device, dtype=dtype)\n",
+    "                    for (global_bucket_size, bucket_offset) in global_bucket_sizes ]\n",
+    "                for global_bucket_sizes in self.global_buffer_sizes\n",
+    "            ]\n",
+    "\n",
+    "            # fill ns input data to local buffer\n",
+    "            # looping through all params in local rank, ok.\n",
+    "            for param, ns_input in ns_inputs.items():\n",
+    "                dist_meta = self.dist_metas[param]\n",
+    "                # ceate a reference to `ns_input_local_buffers`\n",
+    "                # the update is in local rank, so we only need one `for` loop\n",
+    "                ns_input_local_buffer = ns_input_local_buffers[dist_meta.buffer_idx][dist_meta.bucket_idx]\n",
+    "                local_buffer_range = self.local_buffer_ranges[dist_meta.buffer_idx][dist_meta.bucket_idx]\n",
+    "                local_range = normalize_range(dist_meta.local_range, local_buffer_range[0]) # local_range in global_range\n",
+    "                # copy data into this `ns_input_local_buffer` memory\n",
+    "                # because dist.all_gather requires a single, physically contiguous block of memory to work efficiently.\n",
+    "                ns_input_local_buffer[local_range[0]:local_range[1]].copy_(ns_input.view(-1))\n",
+    "\n",
+    "            # all gather buffers: one bucket at a time. -- the \"shipping\" phase\n",
+    "            for ns_input_global_buffer, ns_input_local_buffer in zip(ns_input_global_buffers, ns_input_local_buffers):\n",
+    "                for ns_input_global_bucket, ns_input_local_bucket in zip(ns_input_global_buffer, ns_input_local_buffer):\n",
+    "                    dist.all_gather_into_tensor(ns_input_global_bucket, ns_input_local_bucket, group=self.dist_group)\n",
+    "\n",
+    "            # overwrite ns input with the `all_gather`-ed `ns_inputs` -- the \"unpacking\" phase\n",
+    "            # this is the \"opposite\" of filling ns input data to local buffer\n",
+    "            for p in ns_inputs.keys():\n",
+    "                dist_meta = self.dist_metas[p]\n",
+    "                ns_input_global_buffer = ns_input_global_buffers[dist_meta.buffer_idx][dist_meta.bucket_idx]\n",
+    "                offset = self.global_buffer_sizes[dist_meta.buffer_idx][dist_meta.bucket_idx][1]\n",
+    "                global_range = normalize_range(dist_meta.global_range, offset)\n",
+    "\n",
+    "                #ns_inputs[p] = ns_input_global_buffer[global_range[0]:global_range[1]].view(-1)\n",
+    "                ## bug fix 👆🏻-- overwrite ns input with the `all_gather`-ed `ns_inputs` -- the \"unpacking\" phase\n",
+    "                #ns_inputs[p] = ns_input_global_buffer[global_range[0]:global_range[1]].view(-1)\n",
+    "                # Unpack the 1D slice of data\n",
+    "                unpacked_data = ns_input_global_buffer[global_range[0]:global_range[1]]\n",
+    "\n",
+    "                # THIS IS THE FIX: Reshape it to its correct 2D shape, not view(-1)\n",
+    "                ns_inputs[p] = unpacked_data.view(dist_meta.shape)\n",
+    "\n",
+    "            # set tp info\n",
+    "            tp_world_size = dist.get_world_size(self.tp_group)\n",
+    "            tp_rank = dist.get_rank(self.tp_group)\n",
+    "\n",
+    "        # update muon momentum first\n",
+    "        for group in self.param_groups:\n",
+    "\n",
+    "            if not group.get('use_muon', False):\n",
+    "                continue\n",
+    "\n",
+    "            lr = group[\"lr\"]\n",
+    "            ns_steps = group[\"ns_steps\"]\n",
+    "            weight_decay = group[\"weight_decay\"]\n",
+    "            matched_adamw_rms = group[\"matched_adamw_rms\"]\n",
+    "            params = group[\"params\"] # <-- add this\n",
+    "\n",
+    "            for p in params:\n",
+    "\n",
+    "                ns_input = ns_inputs[p]\n",
+    "                tp_split_dim = -1\n",
+    "\n",
+    "                if self.distributed_mode:\n",
+    "                    dist_meta = self.dist_metas[p]\n",
+    "                    tp_split_dim = dist_meta.tp_split_dim\n",
+    "\n",
+    "                # gather tensor parallel ( if tp )\n",
+    "                if tp_split_dim != -1:\n",
+    "                    ns_input_shards = [ torch.empty_like(ns_input) for _ in range(tp_world_size) ]\n",
+    "                    dist.all_gather(ns_input_shards, ns_input, self.tp_group)\n",
+    "                    ns_input = torch.cat(ns_input_shards, dim=tp_split_dim)\n",
+    "\n",
+    "                # calc update\n",
+    "                update = zeropower_via_newtonschulz5(ns_input, steps=ns_steps)\n",
+    "\n",
+    "                # only local tp part\n",
+    "                # this is effectivly \"shadding\" the newtonschulz-processed update,\n",
+    "                # and keep only your assigned piece, discarding the rest\n",
+    "                if tp_split_dim != -1:\n",
+    "                    update = update.chunk(tp_world_size, dim=tp_split_dim)[tp_rank]\n",
+    "\n",
+    "                # only local dp buffer part\n",
+    "                if self.distributed_mode:\n",
+    "                    # local range in global range\n",
+    "                    # unpacking the tp sharded update to dp sharded update\n",
+    "                    local_range = normalize_range(dist_meta.local_range, dist_meta.global_range[0])\n",
+    "                    update = update.reshape(-1)[local_range[0]:local_range[1]]\n",
+    "\n",
+    "                # apply weight decay\n",
+    "                p.data.mul_(1 - lr*weight_decay)\n",
+    "\n",
+    "                #  adjust lr and apply update\n",
+    "                adjusted_lr = adjust_lr_wd_for_muon(lr, matched_adamw_rms, ns_input.shape)\n",
+    "                p.data.add_(update, alpha=-adjusted_lr)\n",
+    "\n",
+    "        # use adam for other params\n",
+    "        for group in self.param_groups:\n",
+    "\n",
+    "            if group.get('use_muon', False):\n",
+    "                continue\n",
+    "\n",
+    "            # init step\n",
+    "            if 'step' in group:\n",
+    "                group['step'] += 1\n",
+    "            else:\n",
+    "                group['step'] = 1\n",
+    "\n",
+    "            step = group['step']\n",
+    "            params = group[\"params\"]\n",
+    "            lr = group['lr']\n",
+    "            weight_decay = group['weight_decay']\n",
+    "            beta1, beta2 = group['adamw_betas']\n",
+    "            eps = group['adamw_eps']\n",
+    "\n",
+    "            for p in params:\n",
+    "\n",
+    "                g = p.grad\n",
+    "                assert g is not None\n",
+    "                state = self.state[p]\n",
+    "\n",
+    "                if len(state) == 0:\n",
+    "                    state['adamw_exp_avg'] = torch.zeros_like(g)\n",
+    "                    state['adamw_exp_avg_sq'] = torch.zeros_like(g)\n",
+    "\n",
+    "                buf1 = state['adamw_exp_avg']\n",
+    "                buf2 = state['adamw_exp_avg_sq']\n",
+    "                buf1.lerp_(g, 1-beta1)\n",
+    "                buf2.lerp_(g.square(), 1-beta2)\n",
+    "\n",
+    "                g = buf1 / (eps + buf2.sqrt())\n",
+    "\n",
+    "                bias_correction1 = 1 - beta1**step\n",
+    "                bias_correction2 = 1 - beta2**step\n",
+    "                scale = bias_correction1 / bias_correction2**0.5\n",
+    "                p.data.mul_(1 - lr * weight_decay)\n",
+    "                p.data.add_(g, alpha=-lr/scale)\n",
+    "\n",
+    "\n",
+    "##--------------- tests/unit_tests/test_optimizer_muon.py -----------------\n",
+    "import os\n",
+    "\n",
+    "import torch\n",
+    "import torch.distributed as dist\n",
+    "\n",
+    "#from megatron.core.optimizer.muon import Muon, MuonDistMeta, normalize_range\n",
+    "\n",
+    "def is_rank_0():\n",
+    "    return torch.distributed.get_rank() == 0\n",
+    "\n",
+    "def print_rank_0(*args):\n",
+    "    if is_rank_0():\n",
+    "        print(*args)\n",
+    "\n",
+    "def cdiv(x: int, y: int):\n",
+    "    return (x + y - 1) // y\n",
+    "\n",
+    "def gen_param_and_grads():\n",
+    "\n",
+    "    # reset manual seed\n",
+    "    torch.manual_seed(0)\n",
+    "    device = 'cpu'\n",
+    "    dtype = torch.float32\n",
+    "\n",
+    "    # gen params\n",
+    "    params = [ torch.randn(shape, device=device, dtype=dtype) for shape in [\n",
+    "            (100, 100), (124, 324), (456, 124), (676, 876), (128, 128), ] ]\n",
+    "\n",
+    "    # gen grads [ [ grad-list ] * step ]\n",
+    "    grads = [ [ torch.randn_like(param) for param in params ] for _ in range(10) ]\n",
+    "\n",
+    "    return params, grads\n",
+    "\n",
+    "def distribute_params(params, grads, tp_dims, dist_group, tp_group):\n",
+    "    \"\"\" 将 param 进行 dist & tp shard, 仅保留自己的一部分 \"\"\"\n",
+    "\n",
+    "    params = params.copy()\n",
+    "    grads = [ step_grads.copy() for step_grads in grads ]\n",
+    "\n",
+    "    # tp dist\n",
+    "    tp_size = dist.get_world_size(tp_group)\n",
+    "    tp_rank = dist.get_rank(tp_group)\n",
+    "    for i, param in enumerate(params):\n",
+    "        tp_dim = tp_dims[i]\n",
+    "        if tp_dim == -1:\n",
+    "            continue\n",
+    "        # Shard the parameter tensor along the `tp_dim` dimension.\n",
+    "        assert param.shape[tp_dim] % tp_size == 0\n",
+    "        local_range_start = param.shape[tp_dim] // tp_size * tp_rank\n",
+    "        # range of the shard based on the rank of the current GOU in the given `tp_group``\n",
+    "        local_range_end = param.shape[tp_dim] // tp_size * (tp_rank + 1)\n",
+    "        # each GPU gets `[local_range_start:local_range_end, :] ` rows or `[:, local_range_start:local_range_end]` columns\n",
+    "        params[i] = param[local_range_start:local_range_end, :] if tp_dim == 0 else \\\n",
+    "                    param[:, local_range_start:local_range_end].contiguous()\n",
+    "        # same logic applies to sharding the gradients for the current layer(param)\n",
+    "        for step_grads in grads:\n",
+    "            step_grads[i] = step_grads[i][local_range_start:local_range_end, :] if tp_dim == 0 else \\\n",
+    "                            step_grads[i][:, local_range_start:local_range_end].contiguous()\n",
+    "\n",
+    "    # distributed\n",
+    "    world_size = dist.get_world_size(dist_group)\n",
+    "    rank = dist.get_rank(dist_group)\n",
+    "\n",
+    "    # global as the given DP group\n",
+    "    # \"global\" here means \"global to the TP group's worth of parameters.\"\n",
+    "    global_buffer_size = sum(param.numel() for param in params)\n",
+    "    local_buffer_size = cdiv(global_buffer_size, world_size)\n",
+    "    # deciding the shard range for this rank\n",
+    "    local_buffer_range = (local_buffer_size * rank, local_buffer_size * (rank + 1))\n",
+    "    # padded global_buffer_size\n",
+    "    global_buffer_size = local_buffer_size * world_size # fix global buffer size\n",
+    "\n",
+    "    numel_acc = 0\n",
+    "    dist_params = []\n",
+    "    dist_grads = [[] for _ in grads]\n",
+    "    dist_metas = {}\n",
+    "    for i, param in enumerate(params):\n",
+    "\n",
+    "        # gen meta\n",
+    "        # align global buffer index(range) with local buffer index(range)\n",
+    "        # see handwritten diagram for more details\n",
+    "        numel = param.numel()\n",
+    "        dist_meta = MuonDistMeta(0, 0, param.shape, (numel_acc, numel_acc + numel), tp_dims[i])\n",
+    "        dist_meta.set_local_buffer_range(local_buffer_range)\n",
+    "        numel_acc += numel\n",
+    "\n",
+    "        # skip if no element in this shard\n",
+    "        if dist_meta.local_range[0] == dist_meta.local_range[1]:\n",
+    "            continue\n",
+    "\n",
+    "        # gen param\n",
+    "\n",
+    "        # Convert the ABSOLUTE slice range (from the global virtual buffer)\n",
+    "        # into a RELATIVE slice range (local to just this one parameter).\n",
+    "        local_range = normalize_range(dist_meta.local_range, dist_meta.global_range[0])\n",
+    "\n",
+    "        # 1. Flatten the 2D parameter tensor into a 1D vector.\n",
+    "        # 2. Use the relative range to slice out the piece this GPU is responsible for storing.\n",
+    "        dist_param = param.view(-1)[local_range[0]:local_range[1]]\n",
+    "        dist_params.append(dist_param)\n",
+    "        dist_metas[dist_param] = dist_meta\n",
+    "\n",
+    "        # gen grad\n",
+    "        # same logoc as the `gen param` scetion\n",
+    "        for step, step_grads in enumerate(grads):\n",
+    "            dist_grad = step_grads[i].view(-1)[local_range[0]:local_range[1]]\n",
+    "            dist_grads[step].append(dist_grad)\n",
+    "\n",
+    "    return dist_params, dist_grads, global_buffer_size, dist_metas\n",
+    "\n",
+    "\n",
+    "def test_muon_dist(dp_size, tp_size):\n",
+    "\n",
+    "    world_size = dist.get_world_size()\n",
+    "    rank = dist.get_rank()\n",
+    "    assert dp_size * tp_size == world_size\n",
+    "\n",
+    "    # init dist group\n",
+    "    for i in range(tp_size):\n",
+    "        # decide the tp group based on grod of size `tp_size`\n",
+    "        ranks = range(i, world_size, tp_size)\n",
+    "        group = dist.new_group(ranks)\n",
+    "        # each rank finds its groups\n",
+    "        if rank in ranks:\n",
+    "            # groups are passed as instructions\n",
+    "            dist_group = group\n",
+    "    # init tp group\n",
+    "    for i in range(dp_size):\n",
+    "        ranks = range(i * tp_size, (i + 1) * tp_size)\n",
+    "        group = dist.new_group(ranks)\n",
+    "        if rank in ranks:\n",
+    "            tp_group = group\n",
+    "\n",
+    "    print_rank_0(\"process group initialized\")\n",
+    "\n",
+    "    params_ref, grads_ref = gen_param_and_grads()\n",
+    "    params_test, grads_test = gen_param_and_grads()\n",
+    "    tp_dims = [0, 1, -1, 1, 0]\n",
+    "\n",
+    "    # global_buffer_size is the padded buffer size of the dp group where the current rank belongs to\n",
+    "    params_test, grads_test, global_buffer_size, dist_metas \\\n",
+    "         = distribute_params(params_test, grads_test, tp_dims, dist_group, tp_group)\n",
+    "\n",
+    "    muon_args = {\n",
+    "        \"use_muon\": True,\n",
+    "        \"lr\": 0.1,\n",
+    "        \"momentum\": 0.9,\n",
+    "        \"nesterov\": True,\n",
+    "        \"ns_steps\": 5,\n",
+    "        \"weight_decay\": 0.1,\n",
+    "    }\n",
+    "\n",
+    "    # gen params\n",
+    "    ref_param_groups = [{\n",
+    "        \"params\": params_ref,\n",
+    "        **muon_args\n",
+    "    }]\n",
+    "    test_param_groups = [{\n",
+    "        \"params\": params_test,\n",
+    "        **muon_args\n",
+    "    }]\n",
+    "\n",
+    "    ref_muon  = Muon(ref_param_groups)\n",
+    "    test_muon = Muon(test_param_groups)\n",
+    "    test_muon.enable_distributed_mode([[(global_buffer_size, 0)]], dist_group, tp_group, dist_metas)\n",
+    "\n",
+    "    for step in range(10):\n",
+    "\n",
+    "        # add grad\n",
+    "        for i, grad in enumerate(grads_ref[step]):\n",
+    "            params_ref[i].grad = grad.clone()\n",
+    "        for i, grad in enumerate(grads_test[step]):\n",
+    "            params_test[i].grad = grad.clone()\n",
+    "        # step\n",
+    "        ref_muon.step()\n",
+    "        test_muon.step()\n",
+    "        # distribute ref params\n",
+    "        dist_ref_params, _, _, _ = distribute_params(params_ref, [], tp_dims, dist_group, tp_group)\n",
+    "        # verify\n",
+    "        for i, params_x2 in enumerate(zip(dist_ref_params, params_test)):\n",
+    "            assert (params_x2[0] == params_x2[1]).all(), f\"rank {rank} param {i} verify failed\"\n",
+    "        print_rank_0(f\" - step {step} verify passed\")\n",
+    "\n",
+    "    print_rank_0(f\"dist dp = {dp_size} tp = {tp_size} test passed\")\n",
+    "\n",
+    "\n",
+    "\n",
+    "def run_process(rank, world_size):\n",
+    "    os.environ['MASTER_ADDR'] = 'localhost'\n",
+    "    os.environ['MASTER_PORT'] = '12355'\n",
+    "    dist.init_process_group(\"gloo\", rank=rank, world_size=world_size)\n",
+    "    test_muon_dist(dp_size=4, tp_size=2)\n",
+    "    test_muon_dist(dp_size=2, tp_size=4)\n",
+    "    dist.destroy_process_group()\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    world_size = 8\n",
+    "    os.environ['CUDA_DEVICE_MAX_CONNECTIONS'] = '1'\n",
+    "    mp.spawn(run_process, args=(world_size,), nprocs=world_size, join=True)\n",
+    "    print(\"\\\\n✅ All tests passed!\")\n",
+    "'''\n",
+    "\n",
+    "# Step 2: Write to file\n",
+    "with open('/content/test_muon_dist.py', 'w') as f:\n",
+    "    f.write(test_code)\n",
+    "\n",
+    "print(\"✅ Test code written to /content/test_muon_dist.py\")\n",
+    "print(\"\\nNow run it with:\")\n",
+    "print(\"!python /content/test_muon_dist.py\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "18Xbd3ovSDxx",
+    "outputId": "4b82d48c-455f-4278-988f-32916a87d336"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[Gloo] Rank 6 is connected to 7 peer ranks. Expected number of connected peer ranks is : 7\n",
+      "[Gloo] Rank 5 is connected to 7 peer ranks. Expected number of connected peer ranks is : 7\n",
+      "[Gloo] Rank 1 is connected to 7 peer ranks. Expected number of connected peer ranks is : 7\n",
+      "[Gloo] Rank 3 is connected to 7 peer ranks. Expected number of connected peer ranks is : 7\n",
+      "[Gloo] Rank 4 is connected to 7 peer ranks. Expected number of connected peer ranks is : 7\n",
+      "[Gloo] Rank 2 is connected to 7 peer ranks. Expected number of connected peer ranks is : 7\n",
+      "[Gloo] Rank 7 is connected to 7 peer ranks. Expected number of connected peer ranks is : 7\n",
+      "[Gloo] Rank 0 is connected to 7 peer ranks. Expected number of connected peer ranks is : 7\n",
+      "[Gloo] Rank 0 is connected to 3 peer ranks. Expected number of connected peer ranks is : 3\n",
+      "[Gloo] Rank 1 is connected to 3 peer ranks. Expected number of connected peer ranks is : 3\n",
+      "[Gloo] Rank 2 is connected to 3 peer ranks. Expected number of connected peer ranks is : 3\n",
+      "[Gloo] Rank 3 is connected to 3 peer ranks. Expected number of connected peer ranks is : 3\n",
+      "[Gloo] Rank 0 is connected to 3 peer ranks. Expected number of connected peer ranks is : 3\n",
+      "[Gloo] Rank 1 is connected to 3 peer ranks. Expected number of connected peer ranks is : 3\n",
+      "[Gloo] Rank 3 is connected to 3 peer ranks. Expected number of connected peer ranks is : 3\n",
+      "[Gloo] Rank 1 is connected to 1 peer ranks. Expected number of connected peer ranks is : 1\n",
+      "[Gloo] Rank 2 is connected to 3 peer ranks. Expected number of connected peer ranks is : 3\n",
+      "[Gloo] Rank 0 is connected to 1 peer ranks. Expected number of connected peer ranks is : 1\n",
+      "[Gloo] Rank 1 is connected to 1 peer ranks. Expected number of connected peer ranks is : 1\n",
+      "[Gloo] Rank 0 is connected to 1 peer ranks. Expected number of connected peer ranks is : 1\n",
+      "[Gloo] Rank 0 is connected to 1 peer ranks. Expected number of connected peer ranks is : 1\n",
+      "process group initialized\n",
+      "[Gloo] Rank 1 is connected to 1 peer ranks. Expected number of connected peer ranks is : 1\n",
+      "[Gloo] Rank 1 is connected to 1 peer ranks. Expected number of connected peer ranks is : 1\n",
+      "[Gloo] Rank 0 is connected to 1 peer ranks. Expected number of connected peer ranks is : 1\n",
+      " - step 0 verify passed\n",
+      " - step 1 verify passed\n",
+      " - step 2 verify passed\n",
+      " - step 3 verify passed\n",
+      " - step 4 verify passed\n",
+      " - step 5 verify passed\n",
+      " - step 6 verify passed\n",
+      " - step 7 verify passed\n",
+      " - step 8 verify passed\n",
+      "[Gloo] Rank 0 is connected to 1 peer ranks. Expected number of connected peer ranks is : 1\n",
+      "[Gloo] Rank 1 is connected to 1 peer ranks. Expected number of connected peer ranks is : 1\n",
+      "[Gloo] Rank 1 is connected to 1 peer ranks. Expected number of connected peer ranks is : 1\n",
+      "[Gloo] Rank 0 is connected to 1 peer ranks. Expected number of connected peer ranks is : 1\n",
+      "[Gloo] Rank 1 is connected to 1 peer ranks. Expected number of connected peer ranks is : 1\n",
+      "[Gloo] Rank 0 is connected to 1 peer ranks. Expected number of connected peer ranks is : 1\n",
+      " - step 9 verify passed\n",
+      "dist dp = 4 tp = 2 test passed\n",
+      "[Gloo] Rank 1 is connected to 1 peer ranks. Expected number of connected peer ranks is : 1\n",
+      "[Gloo] Rank 0 is connected to 1 peer ranks. Expected number of connected peer ranks is : 1\n",
+      "[Gloo] Rank 0 is connected to 3 peer ranks. Expected number of connected peer ranks is : 3\n",
+      "[Gloo] Rank 2 is connected to 3 peer ranks. Expected number of connected peer ranks is : 3\n",
+      "[Gloo] Rank 1 is connected to 3 peer ranks. Expected number of connected peer ranks is : 3\n",
+      "[Gloo] Rank 3 is connected to 3 peer ranks. Expected number of connected peer ranks is : 3\n",
+      "[Gloo] Rank 0 is connected to 3 peer ranks. Expected number of connected peer ranks is : 3\n",
+      "process group initialized\n",
+      "[Gloo] Rank 3 is connected to 3 peer ranks. Expected number of connected peer ranks is : 3\n",
+      "[Gloo] Rank 2 is connected to 3 peer ranks. Expected number of connected peer ranks is : 3\n",
+      "[Gloo] Rank 1 is connected to 3 peer ranks. Expected number of connected peer ranks is : 3\n",
+      " - step 0 verify passed\n",
+      " - step 1 verify passed\n",
+      " - step 2 verify passed\n",
+      " - step 3 verify passed\n",
+      " - step 4 verify passed\n",
+      " - step 5 verify passed\n",
+      " - step 6 verify passed\n",
+      " - step 7 verify passed\n",
+      " - step 8 verify passed\n",
+      " - step 9 verify passed\n",
+      "dist dp = 2 tp = 4 test passed\n",
+      "\n",
+      "✅ All tests passed!\n"
+     ]
+    }
+   ],
+   "source": [
+    "!python /content/test_muon_dist.py"
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

distributed_muon_cpu.py

@@ -0,0 +1,552 @@
+import os
+import sys
+import torch
+import torch.distributed as dist
+import torch.multiprocessing as mp
+import math
+from typing import Tuple, Dict
+
+
+# copy from https://github.com/KellerJordan/Muon/tree/master
+# @torch.compile
+def zeropower_via_newtonschulz5(G, steps):
+    """
+    Newton-Schulz iteration to compute the zeroth power / orthogonalization of G. We opt to use a
+    quintic iteration whose coefficients are selected to maximize the slope at zero. For the purpose
+    of minimizing steps, it turns out to be empirically effective to keep increasing the slope at
+    zero even beyond the point where the iteration no longer converges all the way to one everywhere
+    on the interval. This iteration therefore does not produce UV^T but rather something like US'V^T
+    where S' is diagonal with S_{ii}' ~ Uniform(0.5, 1.5), which turns out not to hurt model
+    performance at all relative to UV^T, where USV^T = G is the SVD.
+    """
+    assert len(G.shape) == 2
+    a, b, c = (3.4445, -4.7750,  2.0315)
+    X = G
+    if G.size(0) > G.size(1):
+        X = X.T
+
+    # Ensure spectral norm is at most 1
+    X = X / (X.norm() + 1e-7)
+    # Perform the NS iterations
+    for _ in range(steps):
+        A = X @ X.T
+        B = b * A + c * A @ A # adapted from suggestion by @jxbz, @leloykun, and @YouJiacheng
+        X = a * X + B @ X
+
+    if G.size(0) > G.size(1):
+        X = X.T
+    return X
+
+def normalize_range(range: Tuple[int, int], start):
+    return (range[0] - start, range[1] - start)
+
+class MuonDistMeta:
+
+    # which buffer and bucket param belongs to
+    buffer_idx: int = 0
+    bucket_idx: int = 0
+    # param shape after tp
+    shape: torch.Size = None
+    # param location in global buffer
+    global_range: Tuple[int, int] = None
+    tp_split_dim: int = -1
+    # param location in global buffer (current dp slice)
+    local_range: Tuple[int, int] = None
+
+    def __init__(self, buffer_idx: int, bucket_idx: int, shape: torch.Size, global_range: Tuple[int, int], tp_split_dim: int):
+        self.buffer_idx = buffer_idx
+        self.bucket_idx = bucket_idx
+        self.shape = shape
+        self.global_range = global_range
+        self.tp_split_dim = tp_split_dim
+
+    def set_local_buffer_range(self,  local_buffer_range: Tuple[int, int]):
+        start = max(self.global_range[0], local_buffer_range[0])
+        end = min(self.global_range[1], local_buffer_range[1])
+        self.local_range = (start, end) if start < end else (local_buffer_range[0], local_buffer_range[0])
+
+# adjust LR based on: https://github.com/MoonshotAI/Moonlight
+def adjust_lr_wd_for_muon(lr, matched_adamw_rms, param_shape):
+    A, B = param_shape[:2]
+    adjusted_ratio = math.sqrt(max(A, B)) * matched_adamw_rms
+    adjusted_lr = lr * adjusted_ratio
+    return adjusted_lr
+
+# copy from https://github.com/KellerJordan/Muon/tree/master and support distributed solution
+class Muon(torch.optim.Optimizer):
+    """
+    Muon - MomentUm Orthogonalized by Newton-schulz
+    Muon internally runs standard SGD-momentum, and then performs an orthogonalization post-
+    processing step, in which each 2D parameter's update is replaced with the nearest orthogonal
+    matrix. To efficiently orthogonalize each update, we use a Newton-Schulz iteration, which has
+    the advantage that it can be stably run in bfloat16 on the GPU.
+    Some warnings:
+    - We believe this optimizer is unlikely to work well for training with small batch size.
+    - We believe it may not work well for finetuning pretrained models, but we haven't tested this.
+    Arguments:
+        param_groups: The parameters to be optimized.
+        lr: The learning rate. The updates will have spectral norm of `lr`. (0.02 is a good default)
+        momentum: The momentum used by the internal SGD. (0.95 is a good default)
+        matched_adamw_rms: The AdamW Update RMS that Muon is designed to match. (0.2~0.4 recommended)
+        nesterov: Whether to use Nesterov-style momentum in the internal SGD. (recommended)
+        ns_steps: The number of Newton-Schulz iterations to run. (5 is probably always enough)
+        {0, 1}-D or are detected as being the embed or lm_head will be optimized by AdamW as well.
+        adamw_betas: The betas for the internal AdamW.
+        adamw_eps: The epsilon for the internal AdamW.
+        adamw_wd: The weight decay for the internal AdamW.
+    """
+    def __init__(self, param_groups, lr=2e-2, weight_decay=0.1,
+                 matched_adamw_rms=0.2, momentum=0.95, nesterov=True, ns_steps=5,
+                 adamw_betas=(0.95, 0.95), adamw_eps=1e-8):
+
+        defaults = dict(lr=lr, weight_decay=weight_decay,
+                        matched_adamw_rms=matched_adamw_rms,
+                        momentum=momentum, nesterov=nesterov, ns_steps=ns_steps,
+                        adamw_betas=adamw_betas, adamw_eps=adamw_eps,)
+
+        super().__init__(param_groups, defaults)
+        self.distributed_mode = False
+
+
+    def enable_distributed_mode(self, global_buffer_sizes, dist_group, tp_group,
+                                dist_metas: Dict[torch.nn.Parameter, MuonDistMeta]):
+        """
+        enable distributed mode
+        Args:
+            global_buffer_size: global buffer size
+            dist group: optimizer sharding group
+            tp group: param tp group
+            dist metas: dist metas for all param
+        """
+
+        self.global_buffer_sizes = global_buffer_sizes
+        self.dist_group = dist_group
+        self.tp_group = tp_group
+        self.dist_metas = dist_metas
+
+        world_size = dist.get_world_size(dist_group)
+        rank = dist.get_rank(dist_group)
+
+        # calc local buffer range
+        self.local_buffer_sizes = []
+        self.local_buffer_ranges = []
+        # The outer loop is for different parameter groups (e.g., weights vs. biases)
+        for global_bucket_sizes in global_buffer_sizes: # <--- rename `global_bucket_sizes`
+            local_bucket_sizes = []
+            local_bucket_ranges = []
+
+            # The inner loop is for the different buckets within a single group
+            for (global_bucket_size, bucket_offset) in global_bucket_sizes:
+                # calculate the local range for THIS specific bucket
+                assert global_bucket_size % world_size == 0
+                local_bucket_size = global_bucket_size // world_size
+                # Renaming here makes the logic so much clearer
+                local_bucket_start = local_bucket_size * rank + bucket_offset
+                local_buffer_range = (local_bucket_start, local_bucket_start + local_bucket_size)
+                local_bucket_sizes.append(local_bucket_size)
+                local_bucket_ranges.append(local_buffer_range)
+
+            self.local_buffer_sizes.append(local_bucket_sizes)
+            self.local_buffer_ranges.append(local_bucket_ranges)
+
+        # calc local range for params
+        for dist_meta in dist_metas.values():
+            local_buffer_range = self.local_buffer_ranges[dist_meta.buffer_idx][dist_meta.bucket_idx]
+            dist_meta.set_local_buffer_range(local_buffer_range)
+
+        self.distributed_mode = True
+
+    def step(self):
+        first_param = self.param_groups[0]['params'][0]
+        device = first_param.device
+        dtype = torch.bfloat16
+
+        ns_inputs = {}
+
+        # update muon momentum first
+        # `self.param_groups` is already sharded
+        for group in self.param_groups:
+
+            if not group.get("use_muon", False):
+                continue
+
+            momentum = group['momentum']
+            params = group["params"]
+
+            for p in params:
+
+                g = p.grad
+                assert g is not None
+                # 1-dim grad for distributed mode
+                assert self.distributed_mode or g.dim() == 2
+
+                # prepare muon buffer in state
+                state = self.state[p]
+                if not "muon_buffer" in state:
+                    state["muon_buffer"] = torch.zeros_like(g)
+                buf = state["muon_buffer"]
+                buf.mul_(momentum).add_(g)
+
+                # save to ns input
+                g = g.add(buf, alpha=momentum) if group['nesterov'] else buf
+                ns_inputs[p] = g.bfloat16()
+
+        # rewrite ns_inputs if distributed
+        """
+        the four-step "acrobatic" journey of the ns_inputs data:
+
+        1.  **DP `all_gather`**: (ZeRO) Gather all the sharded pieces from your data-parallel "column" to re-create your **full TP slice**.
+        2.  **TP `all_gather`**: Gather all the TP slices from your tensor-parallel "row" to re-create the **full, 100% complete matrix**.
+        3.  *(...Run the math on the full matrix...)*
+        4.  **TP `shard`**: Shard the full `update` matrix back down to your **local TP slice**.
+        5.  **DP `shard`**: (ZeRO) Shard that TP slice *again* back down to the **local DP/ZeRO slice** that you're responsible for.
+
+        """
+        if self.distributed_mode:
+
+            # initialize buffers
+            # hanged the variable nnames to `local_bucket_size` and `global_bucket_size` for clarity
+            ns_input_local_buffers = [
+                [ torch.empty((local_bucket_size), device=device, dtype=dtype)
+                    for local_bucket_size in local_bucket_sizes ]
+                for local_bucket_sizes in self.local_buffer_sizes
+            ]
+            ns_input_global_buffers = [
+                [ torch.empty((global_bucket_size), device=device, dtype=dtype)
+                    for (global_bucket_size, bucket_offset) in global_bucket_sizes ]
+                for global_bucket_sizes in self.global_buffer_sizes
+            ]
+
+            # fill ns input data to local buffer
+            # looping through all params in local rank, ok.
+            for param, ns_input in ns_inputs.items():
+                dist_meta = self.dist_metas[param]
+                # ceate a reference to `ns_input_local_buffers`
+                # the update is in local rank, so we only need one `for` loop
+                ns_input_local_buffer = ns_input_local_buffers[dist_meta.buffer_idx][dist_meta.bucket_idx]
+                local_buffer_range = self.local_buffer_ranges[dist_meta.buffer_idx][dist_meta.bucket_idx]
+                local_range = normalize_range(dist_meta.local_range, local_buffer_range[0]) # local_range in global_range
+                # copy data into this `ns_input_local_buffer` memory
+                # because dist.all_gather requires a single, physically contiguous block of memory to work efficiently.
+                ns_input_local_buffer[local_range[0]:local_range[1]].copy_(ns_input.view(-1))
+
+            # all gather buffers: one bucket at a time. -- the "shipping" phase
+            for ns_input_global_buffer, ns_input_local_buffer in zip(ns_input_global_buffers, ns_input_local_buffers):
+                for ns_input_global_bucket, ns_input_local_bucket in zip(ns_input_global_buffer, ns_input_local_buffer):
+                    dist.all_gather_into_tensor(ns_input_global_bucket, ns_input_local_bucket, group=self.dist_group)
+
+            # overwrite ns input with the `all_gather`-ed `ns_inputs` -- the "unpacking" phase
+            # this is the "opposite" of filling ns input data to local buffer
+            for p in ns_inputs.keys():
+                dist_meta = self.dist_metas[p]
+                ns_input_global_buffer = ns_input_global_buffers[dist_meta.buffer_idx][dist_meta.bucket_idx]
+                offset = self.global_buffer_sizes[dist_meta.buffer_idx][dist_meta.bucket_idx][1]
+                global_range = normalize_range(dist_meta.global_range, offset)
+
+                #ns_inputs[p] = ns_input_global_buffer[global_range[0]:global_range[1]].view(-1)
+                ## bug fix 👆🏻-- overwrite ns input with the `all_gather`-ed `ns_inputs` -- the "unpacking" phase
+                #ns_inputs[p] = ns_input_global_buffer[global_range[0]:global_range[1]].view(-1)
+                # Unpack the 1D slice of data
+                unpacked_data = ns_input_global_buffer[global_range[0]:global_range[1]]
+
+                # THIS IS THE FIX: Reshape it to its correct 2D shape, not view(-1)
+                ns_inputs[p] = unpacked_data.view(dist_meta.shape)
+
+            # set tp info
+            tp_world_size = dist.get_world_size(self.tp_group)
+            tp_rank = dist.get_rank(self.tp_group)
+
+        # update muon momentum first
+        for group in self.param_groups:
+
+            if not group.get('use_muon', False):
+                continue
+
+            lr = group["lr"]
+            ns_steps = group["ns_steps"]
+            weight_decay = group["weight_decay"]
+            matched_adamw_rms = group["matched_adamw_rms"]
+            params = group["params"] # <-- add this
+
+            for p in params:
+
+                ns_input = ns_inputs[p]
+                tp_split_dim = -1
+
+                if self.distributed_mode:
+                    dist_meta = self.dist_metas[p]
+                    tp_split_dim = dist_meta.tp_split_dim
+
+                # gather tensor parallel ( if tp )
+                if tp_split_dim != -1:
+                    ns_input_shards = [ torch.empty_like(ns_input) for _ in range(tp_world_size) ]
+                    dist.all_gather(ns_input_shards, ns_input, self.tp_group)
+                    ns_input = torch.cat(ns_input_shards, dim=tp_split_dim)
+
+                # calc update
+                update = zeropower_via_newtonschulz5(ns_input, steps=ns_steps)
+
+                # only local tp part
+                # this is effectivly "shadding" the newtonschulz-processed update,
+                # and keep only your assigned piece, discarding the rest
+                if tp_split_dim != -1:
+                    update = update.chunk(tp_world_size, dim=tp_split_dim)[tp_rank]
+
+                # only local dp buffer part
+                if self.distributed_mode:
+                    # local range in global range
+                    # unpacking the tp sharded update to dp sharded update
+                    local_range = normalize_range(dist_meta.local_range, dist_meta.global_range[0])
+                    update = update.reshape(-1)[local_range[0]:local_range[1]]
+
+                # apply weight decay
+                p.data.mul_(1 - lr*weight_decay)
+
+                #  adjust lr and apply update
+                adjusted_lr = adjust_lr_wd_for_muon(lr, matched_adamw_rms, ns_input.shape)
+                p.data.add_(update, alpha=-adjusted_lr)
+
+        # use adam for other params
+        for group in self.param_groups:
+
+            if group.get('use_muon', False):
+                continue
+
+            # init step
+            if 'step' in group:
+                group['step'] += 1
+            else:
+                group['step'] = 1
+
+            step = group['step']
+            params = group["params"]
+            lr = group['lr']
+            weight_decay = group['weight_decay']
+            beta1, beta2 = group['adamw_betas']
+            eps = group['adamw_eps']
+
+            for p in params:
+
+                g = p.grad
+                assert g is not None
+                state = self.state[p]
+
+                if len(state) == 0:
+                    state['adamw_exp_avg'] = torch.zeros_like(g)
+                    state['adamw_exp_avg_sq'] = torch.zeros_like(g)
+
+                buf1 = state['adamw_exp_avg']
+                buf2 = state['adamw_exp_avg_sq']
+                buf1.lerp_(g, 1-beta1)
+                buf2.lerp_(g.square(), 1-beta2)
+
+                g = buf1 / (eps + buf2.sqrt())
+
+                bias_correction1 = 1 - beta1**step
+                bias_correction2 = 1 - beta2**step
+                scale = bias_correction1 / bias_correction2**0.5
+                p.data.mul_(1 - lr * weight_decay)
+                p.data.add_(g, alpha=-lr/scale)
+
+
+##--------------- tests/unit_tests/test_optimizer_muon.py -----------------
+import os
+
+import torch
+import torch.distributed as dist
+
+#from megatron.core.optimizer.muon import Muon, MuonDistMeta, normalize_range
+
+def is_rank_0():
+    return torch.distributed.get_rank() == 0
+
+def print_rank_0(*args):
+    if is_rank_0():
+        print(*args)
+
+def cdiv(x: int, y: int):
+    return (x + y - 1) // y
+
+def gen_param_and_grads():
+
+    # reset manual seed
+    torch.manual_seed(0)
+    device = 'cpu'
+    dtype = torch.float32
+
+    # gen params
+    params = [ torch.randn(shape, device=device, dtype=dtype) for shape in [
+            (100, 100), (124, 324), (456, 124), (676, 876), (128, 128), ] ]
+
+    # gen grads [ [ grad-list ] * step ]
+    grads = [ [ torch.randn_like(param) for param in params ] for _ in range(10) ]
+
+    return params, grads
+
+def distribute_params(params, grads, tp_dims, dist_group, tp_group):
+    """ 将 param 进行 dist & tp shard, 仅保留自己的一部分 """
+
+    params = params.copy()
+    grads = [ step_grads.copy() for step_grads in grads ]
+
+    # tp dist
+    tp_size = dist.get_world_size(tp_group)
+    tp_rank = dist.get_rank(tp_group)
+    for i, param in enumerate(params):
+        tp_dim = tp_dims[i]
+        if tp_dim == -1:
+            continue
+        # Shard the parameter tensor along the `tp_dim` dimension.
+        assert param.shape[tp_dim] % tp_size == 0
+        local_range_start = param.shape[tp_dim] // tp_size * tp_rank
+        # range of the shard based on the rank of the current GOU in the given `tp_group``
+        local_range_end = param.shape[tp_dim] // tp_size * (tp_rank + 1)
+        # each GPU gets `[local_range_start:local_range_end, :] ` rows or `[:, local_range_start:local_range_end]` columns
+        params[i] = param[local_range_start:local_range_end, :] if tp_dim == 0 else \
+                    param[:, local_range_start:local_range_end].contiguous()
+        # same logic applies to sharding the gradients for the current layer(param)
+        for step_grads in grads:
+            step_grads[i] = step_grads[i][local_range_start:local_range_end, :] if tp_dim == 0 else \
+                            step_grads[i][:, local_range_start:local_range_end].contiguous()
+
+    # distributed
+    world_size = dist.get_world_size(dist_group)
+    rank = dist.get_rank(dist_group)
+
+    # global as the given DP group
+    # "global" here means "global to the TP group's worth of parameters."
+    global_buffer_size = sum(param.numel() for param in params)
+    local_buffer_size = cdiv(global_buffer_size, world_size)
+    # deciding the shard range for this rank
+    local_buffer_range = (local_buffer_size * rank, local_buffer_size * (rank + 1))
+    # padded global_buffer_size
+    global_buffer_size = local_buffer_size * world_size # fix global buffer size
+
+    numel_acc = 0
+    dist_params = []
+    dist_grads = [[] for _ in grads]
+    dist_metas = {}
+    for i, param in enumerate(params):
+
+        # gen meta
+        # align global buffer index(range) with local buffer index(range)
+        # see handwritten diagram for more details
+        numel = param.numel()
+        dist_meta = MuonDistMeta(0, 0, param.shape, (numel_acc, numel_acc + numel), tp_dims[i])
+        dist_meta.set_local_buffer_range(local_buffer_range)
+        numel_acc += numel
+
+        # skip if no element in this shard
+        if dist_meta.local_range[0] == dist_meta.local_range[1]:
+            continue
+
+        # gen param
+
+        # Convert the ABSOLUTE slice range (from the global virtual buffer)
+        # into a RELATIVE slice range (local to just this one parameter).
+        local_range = normalize_range(dist_meta.local_range, dist_meta.global_range[0])
+
+        # 1. Flatten the 2D parameter tensor into a 1D vector.
+        # 2. Use the relative range to slice out the piece this GPU is responsible for storing.
+        dist_param = param.view(-1)[local_range[0]:local_range[1]]
+        dist_params.append(dist_param)
+        dist_metas[dist_param] = dist_meta
+
+        # gen grad
+        # same logoc as the `gen param` scetion
+        for step, step_grads in enumerate(grads):
+            dist_grad = step_grads[i].view(-1)[local_range[0]:local_range[1]]
+            dist_grads[step].append(dist_grad)
+
+    return dist_params, dist_grads, global_buffer_size, dist_metas
+
+
+def test_muon_dist(dp_size, tp_size):
+
+    world_size = dist.get_world_size()
+    rank = dist.get_rank()
+    assert dp_size * tp_size == world_size
+
+    # init dist group
+    for i in range(tp_size):
+        # decide the tp group based on grod of size `tp_size`
+        ranks = range(i, world_size, tp_size)
+        group = dist.new_group(ranks)
+        # each rank finds its groups
+        if rank in ranks:
+            # groups are passed as instructions
+            dist_group = group
+    # init tp group
+    for i in range(dp_size):
+        ranks = range(i * tp_size, (i + 1) * tp_size)
+        group = dist.new_group(ranks)
+        if rank in ranks:
+            tp_group = group
+
+    print_rank_0("process group initialized")
+
+    params_ref, grads_ref = gen_param_and_grads()
+    params_test, grads_test = gen_param_and_grads()
+    tp_dims = [0, 1, -1, 1, 0]
+
+    # global_buffer_size is the padded buffer size of the dp group where the current rank belongs to
+    params_test, grads_test, global_buffer_size, dist_metas \
+         = distribute_params(params_test, grads_test, tp_dims, dist_group, tp_group)
+
+    muon_args = {
+        "use_muon": True,
+        "lr": 0.1,
+        "momentum": 0.9,
+        "nesterov": True,
+        "ns_steps": 5,
+        "weight_decay": 0.1,
+    }
+
+    # gen params
+    ref_param_groups = [{
+        "params": params_ref,
+        **muon_args
+    }]
+    test_param_groups = [{
+        "params": params_test,
+        **muon_args
+    }]
+
+    ref_muon  = Muon(ref_param_groups)
+    test_muon = Muon(test_param_groups)
+    test_muon.enable_distributed_mode([[(global_buffer_size, 0)]], dist_group, tp_group, dist_metas)
+
+    for step in range(10):
+
+        # add grad
+        for i, grad in enumerate(grads_ref[step]):
+            params_ref[i].grad = grad.clone()
+        for i, grad in enumerate(grads_test[step]):
+            params_test[i].grad = grad.clone()
+        # step
+        ref_muon.step()
+        test_muon.step()
+        # distribute ref params
+        dist_ref_params, _, _, _ = distribute_params(params_ref, [], tp_dims, dist_group, tp_group)
+        # verify
+        for i, params_x2 in enumerate(zip(dist_ref_params, params_test)):
+            assert (params_x2[0] == params_x2[1]).all(), f"rank {rank} param {i} verify failed"
+        print_rank_0(f" - step {step} verify passed")
+
+    print_rank_0(f"dist dp = {dp_size} tp = {tp_size} test passed")
+
+
+
+def run_process(rank, world_size):
+    os.environ['MASTER_ADDR'] = 'localhost'
+    os.environ['MASTER_PORT'] = '12355'
+    dist.init_process_group("gloo", rank=rank, world_size=world_size)
+    test_muon_dist(dp_size=4, tp_size=2)
+    test_muon_dist(dp_size=2, tp_size=4)
+    dist.destroy_process_group()
+
+if __name__ == "__main__":
+    world_size = 8
+    os.environ['CUDA_DEVICE_MAX_CONNECTIONS'] = '1'
+    mp.spawn(run_process, args=(world_size,), nprocs=world_size, join=True)
+    print("\\n✅ All tests passed!")