update

logs_new_MUON_large_reshape_svd_gated/ori/mode_7_param_gated_muon_lr_0.0005_adam_lr_0.0002_seed_42/config.json

@@ -22,6 +22,6 @@
         "val_tokens": 10420224,
         "save_every": 0
     },
-    "run_uuid_for_log": "de92121d-9f3a-4470-a944-fb1adf4c28d0",
+    "run_uuid_for_log": "01057053-d2d8-460a-ab4b-8f0dcb45709c",
     "script_code_logged_at_start": true
 }

logs_new_MUON_large_reshape_svd_gated/ori/mode_7_param_gated_muon_lr_0.0005_adam_lr_0.0002_seed_43/config.json

@@ -0,0 +1,27 @@
+{
+    "cli_args": {
+        "seed": 43,
+        "optimizer_mode": 7,
+        "model_parameterization": "gated",
+        "adam_lr": 0.0002,
+        "muon_lr": 0.0005,
+        "base_dir": "logs_new_MUON_large_reshape_svd_gated/ori"
+    },
+    "hyperparameters": {
+        "input_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "input_val_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "batch_size": 960,
+        "device_batch_size": 24,
+        "sequence_length": 1024,
+        "num_iterations": 6000,
+        "learning_rate": 0.0018,
+        "warmup_iters": 0,
+        "warmdown_iters": 0,
+        "weight_decay": 0,
+        "val_loss_every": 125,
+        "val_tokens": 10420224,
+        "save_every": 0
+    },
+    "run_uuid_for_log": "039021ab-4477-44e2-9121-ce92354d757a",
+    "script_code_logged_at_start": true
+}

logs_new_MUON_large_reshape_svd_gated/ori/mode_9_param_gated_muon_lr_0.0005_adam_lr_0.0002_seed_42/config.json

@@ -0,0 +1,27 @@
+{
+    "cli_args": {
+        "seed": 42,
+        "optimizer_mode": 9,
+        "model_parameterization": "gated",
+        "adam_lr": 0.0002,
+        "muon_lr": 0.0005,
+        "base_dir": "logs_new_MUON_large_reshape_svd_gated/ori"
+    },
+    "hyperparameters": {
+        "input_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "input_val_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "batch_size": 960,
+        "device_batch_size": 24,
+        "sequence_length": 1024,
+        "num_iterations": 6000,
+        "learning_rate": 0.0018,
+        "warmup_iters": 0,
+        "warmdown_iters": 0,
+        "weight_decay": 0,
+        "val_loss_every": 125,
+        "val_tokens": 10420224,
+        "save_every": 0
+    },
+    "run_uuid_for_log": "62c86858-e544-45fa-8e10-20927225390f",
+    "script_code_logged_at_start": true
+}

logs_new_MUON_large_reshape_svd_gated/ori/mode_9_param_gated_muon_lr_0.0005_adam_lr_0.0002_seed_43/config.json

@@ -0,0 +1,27 @@
+{
+    "cli_args": {
+        "seed": 43,
+        "optimizer_mode": 9,
+        "model_parameterization": "gated",
+        "adam_lr": 0.0002,
+        "muon_lr": 0.0005,
+        "base_dir": "logs_new_MUON_large_reshape_svd_gated/ori"
+    },
+    "hyperparameters": {
+        "input_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "input_val_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "batch_size": 960,
+        "device_batch_size": 24,
+        "sequence_length": 1024,
+        "num_iterations": 6000,
+        "learning_rate": 0.0018,
+        "warmup_iters": 0,
+        "warmdown_iters": 0,
+        "weight_decay": 0,
+        "val_loss_every": 125,
+        "val_tokens": 10420224,
+        "save_every": 0
+    },
+    "run_uuid_for_log": "9ebd0b66-cbf1-499b-a4e8-6a3e8c6248a9",
+    "script_code_logged_at_start": true
+}

logs_new_MUON_large_reshape_svd_gated/svd/mode_0_param_gated_muon_lr_0.0005_adam_lr_0.0002_seed_42/config.json

@@ -0,0 +1,27 @@
+{
+    "cli_args": {
+        "seed": 42,
+        "optimizer_mode": 0,
+        "model_parameterization": "gated",
+        "adam_lr": 0.0002,
+        "muon_lr": 0.0005,
+        "base_dir": "logs_new_MUON_large_reshape_svd_gated/svd"
+    },
+    "hyperparameters": {
+        "input_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "input_val_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "batch_size": 960,
+        "device_batch_size": 24,
+        "sequence_length": 1024,
+        "num_iterations": 6000,
+        "learning_rate": 0.0018,
+        "warmup_iters": 0,
+        "warmdown_iters": 0,
+        "weight_decay": 0,
+        "val_loss_every": 125,
+        "val_tokens": 10420224,
+        "save_every": 0
+    },
+    "run_uuid_for_log": "533563b5-4895-416e-8ea4-9baaf8e74134",
+    "script_code_logged_at_start": true
+}

logs_new_MUON_large_reshape_svd_gated/svd/mode_0_param_gated_muon_lr_0.0005_adam_lr_0.0002_seed_42/training_log_533563b5-4895-416e-8ea4-9baaf8e74134.txt

@@ -0,0 +1,856 @@
+import os
+import os
+import sys
+with open(sys.argv[0]) as f:
+    code = f.read() # read the code of this file ASAP, for logging
+import uuid
+import time
+import copy
+import glob
+from dataclasses import dataclass, asdict
+from functools import lru_cache
+from pathlib import Path
+import argparse # Keep argparse for --unet and potentially --optimizer_mode
+import json
+import random 
+import numpy as np 
+
+os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "expandable_segments:True"
+import torch
+torch.empty(1, device="cuda", requires_grad=True).backward() # prevents a bug on some systems
+from torch import Tensor, nn
+import torch.nn.functional as F
+import torch.distributed as dist
+# use of FlexAttention contributed by @KoszarskyB
+from torch.nn.attention.flex_attention import BlockMask, flex_attention
+sys.path.append("/home/aiops/zhangfz/MUON_theory/modded-nanogpt") # Already present
+from optimizers.MUON_new_large_nes import Muon
+from utils.float_compute import mm_op, backward as mm_backward_custom, setup_context as mm_setup_context_custom # Renamed
+import torch._inductor.config as config
+from torch.nn.parallel import DistributedDataParallel as DDP
+from kn_util.utils import setup_debugpy
+
+
+# -----------------------------------------------------------------------------
+# Seeding Function
+def set_seed(seed):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+    print(f"PRINT: Set seed to {seed}", flush=True) # Print immediately for all ranks
+
+
+# ---- ADD: spectral metrics helper ----
+def calculate_svd_metrics(matrix: torch.Tensor, *, topk: int = 10):
+    """
+    Returns dict with:
+      - entropy_norm: normalized SVD entropy
+      - erank: effective rank = exp(Shannon entropy of p)
+      - topk_energy: sum of top-k p_i (energy fraction in the top-k singular values)
+      - q75_q25: ratio of 75th to 25th percentile of eigenvalues (sigma^2)
+    """
+    with torch.no_grad():
+        s = torch.linalg.svdvals(matrix.detach().to('cpu', torch.float32))
+        s = s[s > 1e-9]
+        n = s.numel()
+        if n == 0:
+            return dict(entropy_norm=0.0, erank=0.0, topk_energy=0.0, q75_q25=float('inf'))
+
+        s2 = s * s
+        S2_sum = float(torch.sum(s2))
+        if S2_sum == 0.0:
+            return dict(entropy_norm=0.0, erank=0.0, topk_energy=0.0, q75_q25=float('inf'))
+
+        p = s2 / S2_sum  # energy distribution
+        # Shannon entropy H (natural log)
+        H = float(torch.sum(torch.special.entr(p)))
+        entropy_norm = H / np.log(max(n, 2))  
+        erank = float(np.exp(H))
+
+        k = min(topk, n)
+        topk_energy = float(torch.topk(p, k).values.sum())
+
+        # eigenvalues = s^2, use quantiles on s^2
+        q25 = float(torch.quantile(s2, 0.25))
+        q75 = float(torch.quantile(s2, 0.75))
+        q75_q25 = (q75 / q25) if q25 > 0 else float('inf')
+
+        return dict(
+            entropy_norm=entropy_norm,
+            erank=erank,
+            topk_energy=topk_energy,
+            q75_q25=q75_q25,
+        )
+
+
+# -----------------------------------------------------------------------------
+# Our own simple Distributed Data Loader
+
+def _peek_data_shard(filename):
+    # only reads the header, returns header data
+    with open(filename, "rb") as f:
+        # first read the header, which is 256 int32 integers (4 bytes each)
+        header = np.frombuffer(f.read(256*4), dtype=np.int32)
+    if header[0] != 20240520:
+        print("ERROR: magic number mismatch in the data .bin file!")
+        print("---> HINT: Are you passing in a correct file with --input_bin?")
+        print("---> HINT: Dataset encoding changed recently, re-run data prepro or refer again to README")
+        print("---> HINT: For example re-run: `python dev/data/tinyshakespeare.py`, then re-try")
+        exit(1)
+    assert header[1] == 1, "unsupported version"
+    ntok = header[2] # number of tokens (claimed)
+    return ntok # for now just return the number of tokens
+
+def _load_data_shard(filename):
+    with open(filename, "rb") as f:
+        # first read the header, which is 256 int32 integers (4 bytes each)
+        header = np.frombuffer(f.read(256*4), dtype=np.int32)
+        assert header[0] == 20240520, "magic number mismatch in the data .bin file"
+        assert header[1] == 1, "unsupported version"
+        ntok = header[2] # number of tokens (claimed)
+        # the rest of it are tokens, stored as uint16
+        tokens = np.frombuffer(f.read(), dtype=np.uint16)
+    assert len(tokens) == ntok, "number of tokens read does not match header?"
+    return tokens
+
+class DistributedDataLoader:
+    def __init__(self, filename_pattern, B, T, process_rank, num_processes):
+        self.process_rank = process_rank
+        self.num_processes = num_processes
+        self.B = B
+        self.T = T
+
+        # glob files that match the pattern
+        self.files = sorted(glob.glob(filename_pattern))
+        assert len(self.files) > 0, f"did not find any files that match the pattern {filename_pattern}"
+
+        # load and validate all data shards, count number of tokens in total
+        ntok_total = 0
+        for fname in self.files:
+            shard_ntok = _peek_data_shard(fname)
+            assert shard_ntok >= num_processes * B * T + 1
+            ntok_total += int(shard_ntok)
+        self.ntok_total = ntok_total
+
+        # kick things off
+        self.reset()
+
+    def reset(self):
+        self.current_shard = 0
+        self.current_position = self.process_rank * self.B * self.T
+        self.tokens = _load_data_shard(self.files[self.current_shard])
+
+    def advance(self): # advance to next data shard
+        self.current_shard = (self.current_shard + 1) % len(self.files)
+        self.current_position = self.process_rank * self.B * self.T
+        self.tokens = _load_data_shard(self.files[self.current_shard])
+
+    def next_batch(self):
+        B = self.B
+        T = self.T
+        buf = self.tokens[self.current_position : self.current_position+B*T+1]
+        buf = torch.tensor(buf.astype(np.int32), dtype=torch.long)
+        x = (buf[:-1]).view(B, T) # inputs
+        y = (buf[1:]).view(B, T) # targets
+        # advance current position and load next shard if necessary
+        self.current_position += B * T * self.num_processes
+        if self.current_position + (B * T * self.num_processes + 1) > len(self.tokens):
+            self.advance()
+        return x.cuda(), y.cuda()
+
+# -----------------------------------------------------------------------------
+# int main
+
+@dataclass
+class Hyperparameters:
+    # data hyperparams
+    input_bin : str = "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin"
+    input_val_bin : str = "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin"
+    # optimization hyperparams
+    batch_size : int = 8*120 # 8*120 # batch size, in sequences, across all devices
+    device_batch_size : int = 24 # batch size, in sequences, per device
+    sequence_length : int = 1024 # sequence length, in tokens
+    num_iterations : int = 6000 # number of iterations to run
+    learning_rate : float = 0.0036 / 2
+    warmup_iters : int = 0
+    warmdown_iters : int = 0 # number of iterations of linear warmup/warmdown for triangular or trapezoidal schedule
+    weight_decay : float = 0
+    # evaluation and logging hyperparams
+    val_loss_every : int = 125 # every how many steps to evaluate val loss? 0 for only at the end
+    val_tokens : int = 10420224 # how many tokens of validation data? it's important to keep this fixed for consistent comparisons
+    save_every : int = 0 # every how many steps to save the checkpoint? 0 for only at the end
+args = Hyperparameters()
+
+
+
+# -----------------------------------------------------------------------------
+# int main
+# setup_debugpy(force=True)
+parser = argparse.ArgumentParser(description="NanoGPT Training Script with Muon")
+parser.add_argument("--seed", type=int, default=42, help="Random seed for reproducibility")
+# --- MODIFICATION: Add optimizer_mode as a CLI argument ---
+parser.add_argument("--optimizer_mode", type=int, default=0,
+                    help="Defines how Muon is applied. "
+                         "0: Muon(All Hidden Attn+MLP - original); "
+                         "1: Muon(QK Attn)/Adam(VO Attn,MLP); "
+                         "2: Muon(VO Attn)/Adam(QK Attn,MLP); "
+                         "3: Muon(All Attn)/Adam(MLP); "
+                         "4: Muon(MLP)/Adam(All Attn)"
+                         "5: All Adam (No Muon, all applicable matrices to Adam)."
+                         "6: Muon(W_2 MLP)/Adam(attn, W_1 MLP)."
+                         "7: Muon(VO Attn, MLP)/Adam(QK Attn)."
+                         "8: Muon(VO Attn, W_2 MLP)/Adam(QK Attn, W_1 MLP)."
+                         )
+parser.add_argument("--model_parameterization", type=str, default="whole",choices=["whole","qkvo", "norope", "gated"])
+parser.add_argument("--adam_lr", type=float, default=0.008, help="Learning rate for Adam matrices")
+parser.add_argument("--muon_lr", type=float, default=0.05, help="Learning rate for Muon matrices")
+parser.add_argument("--base_dir", type=str, default="logs_new_MUON_large/test", help="Base directory for logs")
+exp_args = parser.parse_args()
+set_seed(exp_args.seed)
+
+
+
+# set up DDP (distributed data parallel). torchrun sets this env variable
+assert torch.cuda.is_available()
+dist.init_process_group(backend='nccl')
+ddp_rank = int(os.environ['RANK'])
+ddp_local_rank = int(os.environ['LOCAL_RANK'])
+ddp_world_size = int(os.environ['WORLD_SIZE'])
+device = f'cuda:{ddp_local_rank}'
+torch.cuda.set_device(device)
+print(f"using device: {device}")
+master_process = (ddp_rank == 0) # this process will do logging, checkpointing etc.
+
+logfile = None
+run_dir_path_str = None 
+base_log_dir = Path(exp_args.base_dir)
+
+
+if master_process:
+    import subprocess
+    set_seed(exp_args.seed)
+
+    # Construct folder name based on config and seed
+    # run_folder_name = f"mode_{exp_args.optimizer_mode}_param_{exp_args.model_parameterization}_adam_lr_{exp_args.adam_lr}_seed_{exp_args.seed}"
+    run_folder_name = f"mode_{exp_args.optimizer_mode}_param_{exp_args.model_parameterization}_muon_lr_{exp_args.muon_lr}_adam_lr_{exp_args.adam_lr}_seed_{exp_args.seed}"
+    run_dir_path = base_log_dir / run_folder_name
+    run_dir_path.mkdir(parents=True, exist_ok=True)
+    run_dir_path_str = str(run_dir_path)
+
+    run_uuid = uuid.uuid4() 
+    logfile = run_dir_path / f"training_log_{run_uuid}.txt" 
+    print(f"Logging to: {logfile}")
+
+    # Save configuration
+    config_to_save = {
+        "cli_args": vars(exp_args),
+        "hyperparameters": {k: v for k, v in args.__class__.__dict__.items() if not k.startswith('__') and not callable(v)}, 
+        "run_uuid_for_log": str(run_uuid),
+        "script_code_logged_at_start": True
+    }
+    config_file_path = run_dir_path / "config.json"
+    with open(config_file_path, "w") as f:
+        json.dump(config_to_save, f, indent=4)
+    print(f"Saved configuration to: {config_file_path}")
+
+# convenience variables
+B, T = args.device_batch_size, args.sequence_length
+# calculate the number of steps to take in the val loop.
+print(f"args.val_tokens: {args.val_tokens}, args.batch_size: {args.batch_size}, B: {B}, T: {T}, ddp_world_size: {ddp_world_size}")
+assert args.val_tokens % (B * T * ddp_world_size) == 0
+val_steps = args.val_tokens // (B * T * ddp_world_size)
+# calculate the steps of gradient accumulation required to attain the desired global batch size.
+assert args.batch_size % (B * ddp_world_size) == 0
+train_accumulation_steps = args.batch_size // (B * ddp_world_size)
+
+# load tokens
+train_loader = DistributedDataLoader(args.input_bin, B, T, ddp_rank, ddp_world_size)
+val_loader = DistributedDataLoader(args.input_val_bin, B, T, ddp_rank, ddp_world_size)
+if master_process:
+    print(f"Training DataLoader: total number of tokens: {train_loader.ntok_total} across {len(train_loader.files)} files")
+    print(f"Validation DataLoader: total number of tokens: {val_loader.ntok_total} across {len(val_loader.files)} files")
+x, y = train_loader.next_batch()
+
+# there are only 50257 unique GPT-2 tokens; we extend to nearest multiple of 128 for efficiency. suggested to me by @Grad62304977.
+# this originates from Karpathy's experiments.
+num_vocab = 50304
+
+
+
+if exp_args.model_parameterization == "qkvo":
+    from models.nano_GPT_qkvo_large import GPT, GPTConfig
+    # model = GPT(GPTConfig(vocab_size=num_vocab, n_layer=25, n_head=12, n_embd=1536))
+    model = GPT(GPTConfig(vocab_size=num_vocab, n_layer=36, n_head=20, n_embd=1280))
+elif exp_args.model_parameterization == "gated":
+    from models.nano_GPT_gated_large import GPT, GPTConfig
+    model = GPT(GPTConfig(vocab_size=num_vocab, n_layer=27, n_head=20, n_embd=1280))
+
+if master_process:
+    print(sum(p.numel() for p in model.parameters()))
+model = model.cuda()
+if hasattr(config, "coordinate_descent_tuning"):
+    config.coordinate_descent_tuning = True # suggested by @Chillee
+model = torch.compile(model)
+# here we wrap model into DDP container
+model = DDP(model, device_ids=[ddp_local_rank])
+raw_model = model.module # always contains the "raw" unwrapped model
+ctx = torch.amp.autocast(device_type='cuda', dtype=torch.bfloat16)
+
+# for name, param in raw_model.named_parameters():
+#     print(name, param.shape)
+
+if exp_args.model_parameterization == "qkvo" :
+    print("PRINT: Collecting parameters for optimizers...")
+    head_params = [raw_model.lm_head.weight]
+    # embed_params = [raw_model.transformer.wte.weight] 
+
+    # Granular collection for attention and MLP parts
+    attn_q_params = []
+    attn_k_params = []
+    attn_v_params = []
+    attn_o_params = [] # W_O from c_proj
+    mlp_fc_params = []
+    mlp_proj_params = []
+
+    for block_module in raw_model.transformer.h:
+        if block_module.attn is not None:
+            # These attributes (c_q, c_k, c_v) MUST exist in your CausalSelfAttention class
+            if hasattr(block_module.attn, 'c_q'): attn_q_params.append(block_module.attn.c_q.weight)
+            else:
+                print(f"PRINT: Warning: c_q not found in attn module of a block.")
+            if hasattr(block_module.attn, 'c_k'): attn_k_params.append(block_module.attn.c_k.weight)
+            else: print(f"PRINT: Warning: c_k not found in attn module of a block.")
+            if hasattr(block_module.attn, 'c_v'): attn_v_params.append(block_module.attn.c_v.weight)
+            else: print(f"PRINT: Warning: c_v not found in attn module of a block.")
+            attn_o_params.append(block_module.attn.c_proj.weight)
+        if block_module.mlp is not None:
+            mlp_fc_params.append(block_module.mlp.c_fc.weight)
+            mlp_proj_params.append(block_module.mlp.c_proj.weight)
+
+    # Combine into logical groups for experiments
+    attn_qk_group = attn_q_params + attn_k_params
+    attn_vo_group = attn_v_params + attn_o_params
+    all_attn_matrices = attn_qk_group + attn_vo_group
+    mlp_w1_group = mlp_fc_params
+    mlp_w2_group = mlp_proj_params
+    all_mlp_matrices = mlp_fc_params + mlp_proj_params
+
+    # Scalar parameters (all others not explicitly grouped as matrices)
+    # matrix_params_for_scalar_check = set(head_params + embed_params + all_attn_matrices + all_mlp_matrices)
+    matrix_params_for_scalar_check = set(head_params + all_attn_matrices + all_mlp_matrices)
+    scalar_params = [p for n, p in raw_model.named_parameters() if p not in matrix_params_for_scalar_check]
+    for p_scalar in scalar_params: # Sanity check
+        if p_scalar.ndim >=2:
+            print(f"PRINT: Warning - Parameter {p_scalar.shape} ended up in scalar_params but has ndim >= 2. Check grouping.")
+
+
+    # Determine parameter distribution based on optimizer_mode
+    muon_params_target_list = []
+    adam_matrix_target_list = [] # Matrices that Adam will handle specifically
+    adam_matrix_lr = exp_args.adam_lr  # LR for matrices if Adam handles them (can be tuned)
+
+    current_optimizer_mode = exp_args.optimizer_mode
+    
+    print(f"PRINT: Configuring optimizers for EXPERIMENT_MODE = {current_optimizer_mode}")
+
+    if current_optimizer_mode == 0: # Original behavior: Muon on all "hidden_matrix_params"
+        print(f"PRINT: Mode 0: Muon on ALL Attention (QKVO) and ALL MLP matrices.")
+        muon_params_target_list = all_attn_matrices + all_mlp_matrices
+        # Adam handles embeds, head, scalars by default. No extra matrices for Adam here.
+    elif current_optimizer_mode == 1: # Muon on QK, Adam on VO and MLP
+        print(f"PRINT: Mode 1: Muon on QK Attn. Adam on VO Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_qk_group
+        adam_matrix_target_list = attn_vo_group + all_mlp_matrices
+    elif current_optimizer_mode == 2: # Muon on VO, Adam on QK and MLP
+        print(f"PRINT: Mode 2: Muon on VO Attn. Adam on QK Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_vo_group
+        adam_matrix_target_list = attn_qk_group + all_mlp_matrices
+    elif current_optimizer_mode == 3: # Muon on All Attn (QKVO), Adam on MLP
+        print(f"PRINT: Mode 3: Muon on ALL Attn (QKVO). Adam on MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = all_attn_matrices
+        adam_matrix_target_list = all_mlp_matrices
+    elif current_optimizer_mode == 4: # Muon on MLP, Adam on All Attn (QKVO)
+        print(f"PRINT: Mode 4: Muon on MLP. Adam on ALL Attn (QKVO) (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = all_mlp_matrices
+        adam_matrix_target_list = all_attn_matrices
+    elif current_optimizer_mode == 5: # NEW MODE 5 - All Adam
+        print(f"PRINT: Mode 5: All Adam. All Attn and MLP matrices to Adam (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = [] 
+        adam_matrix_target_list = all_attn_matrices + all_mlp_matrices # All matrices to Adam
+    elif current_optimizer_mode == 6: # Muon on W_2 MLP, Adam on attn, W_1 MLP
+        print(f"PRINT: Mode 6: Muon on W_2 MLP. Adam on attn, W_1 MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = mlp_w2_group
+        adam_matrix_target_list = all_attn_matrices + mlp_w1_group
+    elif current_optimizer_mode == 7: # Muon on VO Attn, MLP, Adam on QK Attn
+        print(f"PRINT: Mode 7: Muon on VO Attn, MLP. Adam on QK Attn (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_vo_group + all_mlp_matrices
+        adam_matrix_target_list = attn_qk_group
+    elif current_optimizer_mode == 8: # Muon on VO Attn, W_2 MLP, Adam on QK Attn, W_1 MLP
+        print(f"PRINT: Mode 8: Muon on VO Attn, W_2 MLP. Adam on QK Attn, W_1 MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_vo_group + mlp_w2_group
+        adam_matrix_target_list = attn_qk_group + mlp_w1_group
+    elif current_optimizer_mode == 9: # Muon on V Attn, MLP
+        print(f"PRINT: Mode 9: Muon on V Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_v_params + all_mlp_matrices
+        adam_matrix_target_list = attn_o_params + attn_qk_group
+    elif current_optimizer_mode == 10: # Muon on O Attn, MLP
+        print(f"PRINT: Mode 10: Muon on O Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_o_params + all_mlp_matrices
+        adam_matrix_target_list = attn_v_params + attn_qk_group
+    elif current_optimizer_mode == 11: # Muon on W_1, Adam on O Attn, QK Attn
+        print(f"PRINT: Mode 11: Muon on W_1. Adam on O Attn, QK Attn (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = mlp_w1_group
+        adam_matrix_target_list = all_attn_matrices + mlp_w2_group
+    elif current_optimizer_mode == 12: # Muon on W_1, VO, Adam on others
+        print(f"PRINT: Mode 12: Muon on W_1. Adam on O Attn, QK Attn (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_vo_group + mlp_w1_group
+        adam_matrix_target_list = attn_qk_group + mlp_w2_group
+    elif current_optimizer_mode == 13:
+        print(f"PRINT: Mode 13: Muon on W_2, W_O. Adam on V Attn, QK Attn, W_1 (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_o_params + mlp_w2_group
+        adam_matrix_target_list = attn_qk_group + attn_v_params + mlp_w1_group 
+    elif current_optimizer_mode == 14:
+        print(f"PRINT: Mode 14: Muon on W_O. Adam on V Attn, QK Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_o_params
+        adam_matrix_target_list = attn_qk_group + attn_v_params +all_mlp_matrices
+    elif current_optimizer_mode == 15:
+        print(f"PRINT: Mode 15: Muon on W_V. Adam on O Attn, QK Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_v_params
+        adam_matrix_target_list = attn_qk_group + attn_o_params +all_mlp_matrices
+    elif current_optimizer_mode == 16:
+        print(f"PRINT: Mode 15: Muon on QKV. Adam on O Attn, QK Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_v_params + attn_qk_group
+        adam_matrix_target_list = attn_o_params +all_mlp_matrices
+    else:
+        raise ValueError(f"Unsupported EXPERIMENT_MODE: {current_optimizer_mode}")
+
+    # Adam optimizer setup
+    adam_param_groups_config = [
+        dict(params=head_params, lr=adam_matrix_lr),
+        # dict(params=embed_params, lr=adam_matrix_lr),
+        dict(params=scalar_params, lr=adam_matrix_lr) # Scalar params always go to Adam
+    ]
+    # Add matrices specifically assigned to Adam for this experiment mode
+    if adam_matrix_target_list:
+        # Ensure adam_matrix_target_list is flat and contains Parameters
+        flat_adam_matrices = [p for sublist_or_p in adam_matrix_target_list for p in (sublist_or_p if isinstance(sublist_or_p, list) else [sublist_or_p]) if p is not None]
+        if flat_adam_matrices: # Only add group if there are params
+            adam_param_groups_config.append(dict(params=flat_adam_matrices, lr=adam_matrix_lr))
+
+    # Filter out any Adam groups that might be empty (e.g., if scalar_params was empty)
+    adam_param_groups_config = [g for g in adam_param_groups_config if g['params']]
+    optimizer1 = torch.optim.Adam(adam_param_groups_config, betas=(0.9, 0.95), eps=1e-10, fused=True)
+    optimizers = [optimizer1] # Start with Adam
+
+    # Muon optimizer setup
+    # if muon_params_target_list:
+    #     # Ensure muon_params_target_list is flat, unique, and contains Parameters
+    #     flat_unique_muon_params = []
+    #     seen_muon_ids = set()
+    #     for sublist_or_p in muon_params_target_list:
+    #         for p in (sublist_or_p if isinstance(sublist_or_p, list) else [sublist_or_p]):
+    #             if p is not None and id(p) not in seen_muon_ids:
+    #                 flat_unique_muon_params.append(p)
+    #                 seen_muon_ids.add(id(p))
+
+    #     muon_param_groups_config = []
+    #     if flat_unique_muon_params:
+    #         muon_param_groups_config.append(dict(params=flat_unique_muon_params, lr=exp_args.muon_lr))
+        
+    #     if flat_unique_muon_params: # Only create Muon if it has parameters
+    #         optimizer2 = Muon(muon_param_groups_config, lr=exp_args.muon_lr, momentum=0.95,rank=ddp_rank, world_size=ddp_world_size) # Pass nesterov, ns_steps
+    #         optimizers.append(optimizer2)
+    #     else:
+    #         print("PRINT: Muon optimizer not created as its target parameter list was empty.")
+    #         optimizer2 = None # Explicitly set to None if not created
+    # else:
+    #     print("PRINT: Muon optimizer not created as muon_params_target_list was empty (e.g. mode where Adam handles all matrices).")
+    #     optimizer2 = None # Explicitly set to None
+    # Muon optimizer setup
+    if muon_params_target_list:
+        # Ensure muon_params_target_list is flat, unique, and contains Parameters
+        flat_unique_muon_params = []
+        seen_muon_ids = set()
+        for sublist_or_p in muon_params_target_list:
+            for p in (sublist_or_p if isinstance(sublist_or_p, list) else [sublist_or_p]):
+                if p is not None and id(p) not in seen_muon_ids:
+                    flat_unique_muon_params.append(p)
+                    seen_muon_ids.add(id(p))
+        
+        if flat_unique_muon_params: # Only create Muon if it has parameters
+            optimizer2 = Muon(flat_unique_muon_params, lr=exp_args.muon_lr, momentum=0.95,rank=ddp_rank, world_size=ddp_world_size) # Pass nesterov, ns_steps
+            optimizers.append(optimizer2)
+        else:
+            print("PRINT: Muon optimizer not created as its target parameter list was empty.")
+            optimizer2 = None # Explicitly set to None if not created
+    else:
+        print("PRINT: Muon optimizer not created as muon_params_target_list was empty (e.g. mode where Adam handles all matrices).")
+        optimizer2 = None # Explicitly set to None
+
+    print(f"PRINT: Optimizers configured. Total optimizers: {len(optimizers)}")
+    if optimizer2:
+        print(f"PRINT: Muon optimizer is active with {len(flat_unique_muon_params)} parameters.")
+    
+    # Set up parameter groups for SVD analysis
+    matrix_groups_for_svd = {}
+    if master_process:
+        matrix_groups_for_svd = {
+            "attn_qk": attn_qk_group,
+            "attn_vo": attn_vo_group,
+            "mlp_w1": mlp_w1_group,
+            "mlp_w2": mlp_w2_group 
+        }
+
+elif exp_args.model_parameterization == "gated":
+    print("PRINT: Collecting parameters for optimizers...")
+    head_params = [raw_model.lm_head.weight]
+    # embed_params = [raw_model.transformer.wte.weight] 
+
+    # Granular collection for attention and MLP parts
+    attn_q_params = []
+    attn_k_params = []
+    attn_v_params = []
+    attn_o_params = [] # W_O from c_proj
+    mlp_fc_params = []
+    mlp_proj_params = []
+    mlp_up_params = []
+
+    for block_module in raw_model.transformer.h:
+        if block_module.attn is not None:
+            # These attributes (c_q, c_k, c_v) MUST exist in your CausalSelfAttention class
+            if hasattr(block_module.attn, 'c_q'): attn_q_params.append(block_module.attn.c_q.weight)
+            else:
+                print(f"PRINT: Warning: c_q not found in attn module of a block.")
+            if hasattr(block_module.attn, 'c_k'): attn_k_params.append(block_module.attn.c_k.weight)
+            else: print(f"PRINT: Warning: c_k not found in attn module of a block.")
+            if hasattr(block_module.attn, 'c_v'): attn_v_params.append(block_module.attn.c_v.weight)
+            else: print(f"PRINT: Warning: c_v not found in attn module of a block.")
+            attn_o_params.append(block_module.attn.c_proj.weight)
+        if block_module.mlp is not None:
+            mlp_fc_params.append(block_module.mlp.c_fc.weight)
+            mlp_proj_params.append(block_module.mlp.c_proj.weight)
+            mlp_up_params.append(block_module.mlp.c_up.weight)
+
+    # Combine into logical groups for experiments
+    attn_qk_group = attn_q_params + attn_k_params
+    attn_vo_group = attn_v_params + attn_o_params
+    all_attn_matrices = attn_qk_group + attn_vo_group
+    mlp_w1_group = mlp_fc_params 
+    mlp_w2_group = mlp_proj_params
+    mlp_up_group = mlp_up_params
+    all_mlp_matrices = mlp_fc_params + mlp_proj_params+ mlp_up_params
+
+    # Scalar parameters (all others not explicitly grouped as matrices)
+    # matrix_params_for_scalar_check = set(head_params + embed_params + all_attn_matrices + all_mlp_matrices)
+    matrix_params_for_scalar_check = set(head_params + all_attn_matrices + all_mlp_matrices)
+    scalar_params = [p for n, p in raw_model.named_parameters() if p not in matrix_params_for_scalar_check]
+    for p_scalar in scalar_params: # Sanity check
+        if p_scalar.ndim >=2:
+            print(f"PRINT: Warning - Parameter {p_scalar.shape} ended up in scalar_params but has ndim >= 2. Check grouping.")
+
+
+    # Determine parameter distribution based on optimizer_mode
+    muon_params_target_list = []
+    adam_matrix_target_list = [] # Matrices that Adam will handle specifically
+    adam_matrix_lr = exp_args.adam_lr  # LR for matrices if Adam handles them (can be tuned)
+
+    current_optimizer_mode = exp_args.optimizer_mode
+    
+    print(f"PRINT: Configuring optimizers for EXPERIMENT_MODE = {current_optimizer_mode}")
+
+    if current_optimizer_mode == 0: # Original behavior: Muon on all "hidden_matrix_params"
+        print(f"PRINT: Mode 0: Muon on ALL Attention (QKVO) and ALL MLP matrices.")
+        muon_params_target_list = all_attn_matrices + all_mlp_matrices
+        # Adam handles embeds, head, scalars by default. No extra matrices for Adam here.
+    elif current_optimizer_mode == 1: # Muon on QK, Adam on VO and MLP
+        print(f"PRINT: Mode 1: Muon on QK Attn. Adam on VO Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_qk_group
+        adam_matrix_target_list = attn_vo_group + all_mlp_matrices
+    elif current_optimizer_mode == 2: # Muon on VO, Adam on QK and MLP
+        print(f"PRINT: Mode 2: Muon on VO Attn. Adam on QK Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_vo_group
+        adam_matrix_target_list = attn_qk_group + all_mlp_matrices
+    elif current_optimizer_mode == 3: # Muon on All Attn (QKVO), Adam on MLP
+        print(f"PRINT: Mode 3: Muon on ALL Attn (QKVO). Adam on MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = all_attn_matrices
+        adam_matrix_target_list = all_mlp_matrices
+    elif current_optimizer_mode == 4: # Muon on MLP, Adam on All Attn (QKVO)
+        print(f"PRINT: Mode 4: Muon on MLP. Adam on ALL Attn (QKVO) (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = all_mlp_matrices
+        adam_matrix_target_list = all_attn_matrices
+    elif current_optimizer_mode == 5: # NEW MODE 5 - All Adam
+        print(f"PRINT: Mode 5: All Adam. All Attn and MLP matrices to Adam (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = [] 
+        adam_matrix_target_list = all_attn_matrices + all_mlp_matrices # All matrices to Adam
+    elif current_optimizer_mode == 6: # Muon on W_2 MLP, Adam on attn, W_1 MLP
+        print(f"PRINT: Mode 6: Muon on W_2 MLP. Adam on attn, W_1 MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = mlp_w2_group
+        adam_matrix_target_list = all_attn_matrices + mlp_w1_group
+    elif current_optimizer_mode == 7: # Muon on VO Attn, MLP, Adam on QK Attn
+        print(f"PRINT: Mode 7: Muon on VO Attn, MLP. Adam on QK Attn (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_vo_group + all_mlp_matrices
+        adam_matrix_target_list = attn_qk_group
+    elif current_optimizer_mode == 8: # Muon on VO Attn, W_2 MLP, Adam on QK Attn, W_1 MLP
+        print(f"PRINT: Mode 8: Muon on VO Attn, W_2 MLP. Adam on QK Attn, W_1 MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_vo_group + mlp_w2_group
+        adam_matrix_target_list = attn_qk_group + mlp_w1_group
+    elif current_optimizer_mode == 9: # Muon on V Attn, MLP
+        print(f"PRINT: Mode 9: Muon on V Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_v_params + all_mlp_matrices
+        adam_matrix_target_list = attn_o_params + attn_qk_group
+    elif current_optimizer_mode == 10: # Muon on O Attn, MLP
+        print(f"PRINT: Mode 10: Muon on O Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_o_params + all_mlp_matrices
+        adam_matrix_target_list = attn_v_params + attn_qk_group
+    elif current_optimizer_mode == 11: # Muon on W_1, Adam on O Attn, QK Attn
+        print(f"PRINT: Mode 11: Muon on W_1. Adam on O Attn, QK Attn (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = mlp_w1_group
+        adam_matrix_target_list = all_attn_matrices + mlp_w2_group
+    elif current_optimizer_mode == 12: # Muon on W_1, VO, Adam on others
+        print(f"PRINT: Mode 11: Muon on W_1. Adam on O Attn, QK Attn (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_vo_group + mlp_w1_group
+        adam_matrix_target_list = attn_qk_group + mlp_w2_group
+    elif current_optimizer_mode == 13:
+        print(f"PRINT: Mode 13: Muon on W_2, W_O. Adam on V Attn, QK Attn, W_1 (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_o_params + mlp_w2_group
+        adam_matrix_target_list = attn_qk_group + attn_v_params + mlp_w1_group 
+    elif current_optimizer_mode == 14:
+        print(f"PRINT: Mode 14: Muon on W_O. Adam on V Attn, QK Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_o_params
+        adam_matrix_target_list = attn_qk_group + attn_v_params +all_mlp_matrices
+    elif current_optimizer_mode == 15:
+        print(f"PRINT: Mode 15: Muon on W_V. Adam on O Attn, QK Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_v_params
+        adam_matrix_target_list = attn_qk_group + attn_o_params +all_mlp_matrices
+    elif current_optimizer_mode == 16:
+        print(f"PRINT: Mode 15: Muon on QKV. Adam on O Attn, QK Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_v_params + attn_qk_group
+        adam_matrix_target_list = attn_o_params +all_mlp_matrices
+    else:
+        raise ValueError(f"Unsupported EXPERIMENT_MODE: {current_optimizer_mode}")
+
+    # Adam optimizer setup
+    adam_param_groups_config = [
+        dict(params=head_params, lr=adam_matrix_lr),
+        # dict(params=embed_params, lr=adam_matrix_lr),
+        dict(params=scalar_params, lr=adam_matrix_lr) # Scalar params always go to Adam
+    ]
+    
+    # Add matrices specifically assigned to Adam for this experiment mode
+    if adam_matrix_target_list:
+        # Ensure adam_matrix_target_list is flat and contains Parameters
+        flat_adam_matrices = [p for sublist_or_p in adam_matrix_target_list for p in (sublist_or_p if isinstance(sublist_or_p, list) else [sublist_or_p]) if p is not None]
+        if flat_adam_matrices: # Only add group if there are params
+            adam_param_groups_config.append(dict(params=flat_adam_matrices, lr=adam_matrix_lr))
+
+    # Filter out any Adam groups that might be empty (e.g., if scalar_params was empty)
+    adam_param_groups_config = [g for g in adam_param_groups_config if g['params']]
+    # print(f"PRINT: The length of Adam param groups config: {len(adam_param_groups_config)}")
+    optimizer1 = torch.optim.Adam(adam_param_groups_config, betas=(0.9, 0.95), eps=1e-10, fused=True)
+    optimizers = [optimizer1] # Start with Adam
+
+    
+    if muon_params_target_list:
+        # Ensure muon_params_target_list is flat, unique, and contains Parameters
+        flat_unique_muon_params = []
+        seen_muon_ids = set()
+        for sublist_or_p in muon_params_target_list:
+            for p in (sublist_or_p if isinstance(sublist_or_p, list) else [sublist_or_p]):
+                if p is not None and id(p) not in seen_muon_ids:
+                    flat_unique_muon_params.append(p)
+                    seen_muon_ids.add(id(p))
+        
+        if flat_unique_muon_params: # Only create Muon if it has parameters
+            optimizer2 = Muon(flat_unique_muon_params, lr=exp_args.muon_lr, momentum=0.95,rank=ddp_rank, world_size=ddp_world_size) # Pass nesterov, ns_steps
+            optimizers.append(optimizer2)
+        else:
+            print("PRINT: Muon optimizer not created as its target parameter list was empty.")
+            optimizer2 = None # Explicitly set to None if not created
+    else:
+        print("PRINT: Muon optimizer not created as muon_params_target_list was empty (e.g. mode where Adam handles all matrices).")
+        optimizer2 = None # Explicitly set to None
+
+    print(f"PRINT: Optimizers configured. Total optimizers: {len(optimizers)}")
+    if optimizer2:
+        print(f"PRINT: Muon optimizer is active with {len(flat_unique_muon_params)} parameters.")
+    
+    # Set up parameter groups for SVD analysis
+    matrix_groups_for_svd = {
+                "attn_qk": attn_qk_group,
+                "attn_vo": attn_vo_group,
+                "mlp_w1": mlp_w1_group,      # c_fc only
+                "mlp_up": mlp_up_group,      # c_up only  
+                "mlp_w2": mlp_proj_params 
+            }
+    
+# optimizer1 = torch.optim.AdamW(raw_model.lm_head.parameters(), lr=args.learning_rate, betas=(0.9, 0.95),
+#                                weight_decay=args.weight_decay, fused=True)
+# optimizer2 = Muon(raw_model.transformer.h.parameters(), lr=0.1*args.learning_rate, momentum=0.95,
+#                   rank=ddp_rank, world_size=ddp_world_size)
+                  
+# optimizers = [optimizer1, optimizer2]
+# learning rate decay scheduler (linear warmup and warmdown)
+def get_lr(it):
+    assert it <= args.num_iterations
+    # 1) linear warmup for warmup_iters steps
+    if it < args.warmup_iters:
+        return (it+1) / args.warmup_iters
+    # 2) constant lr for a while
+    elif it < args.num_iterations - args.warmdown_iters:
+        return 1.0
+    # 3) linear warmdown
+    else:
+        decay_ratio = (args.num_iterations - it) / args.warmdown_iters
+        return decay_ratio
+schedulers = [torch.optim.lr_scheduler.LambdaLR(opt, get_lr) for opt in optimizers]
+
+if master_process:
+    with open(logfile, "a") as f:
+        f.write(code)
+
+training_time_ms = 0
+# start the clock
+torch.cuda.synchronize()
+t0 = time.time()
+# begin training
+train_loader.reset()
+for step in range(args.num_iterations + 1):
+    last_step = (step == args.num_iterations)
+    # This effectively ignores timing first 10 steps, which are slower for weird reasons.
+    # Alternately, and slightly more correctly in terms of benchmarking, we could do 10
+    # steps with dummy data first, and then re-initialize the model and reset the loader.
+    if step == 10:
+        training_time_ms = 0
+        t0 = time.time()
+    timed_steps = float('nan') if step <= 11 else (step - 10) + 1 # <= 11 to avoid bug in val
+
+    # once in a while evaluate the validation dataset
+    if (last_step or (args.val_loss_every > 0 and step % args.val_loss_every == 0)):
+        # stop the clock
+        torch.cuda.synchronize()
+        training_time_ms += 1000 * (time.time() - t0)
+        # run validation batches
+        with torch.no_grad():
+            val_loader.reset()
+            val_loss = 0.0
+            for _ in range(val_steps):
+                x_val, y_val = val_loader.next_batch()
+                with ctx: # of course, we'd like to use no_grad() here too, but that creates a torch.compile error for some reason
+                    _, loss = model(x_val, y_val, return_logits=False)
+                    val_loss += loss.detach()
+                    del loss
+            dist.all_reduce(val_loss, op=dist.ReduceOp.AVG)
+            val_loss /= val_steps
+            
+            # SVD metrics calculation
+            svd_log_str = ""
+            if master_process and 'matrix_groups_for_svd' in locals() and matrix_groups_for_svd:
+                TOPK = 10 
+                svd_results_by_category = {}
+
+                with torch.no_grad():
+                    # per-category metrics (average over matrices in the group)
+                    for name, group_params in matrix_groups_for_svd.items():
+                        if not group_params:
+                            continue
+                        mets = [calculate_svd_metrics(p, topk=TOPK) for p in group_params]
+                        if mets:
+                            avg_entropy = float(np.mean([m['entropy_norm'] for m in mets]))
+                            avg_erank   = float(np.mean([m['erank']        for m in mets]))
+                            avg_topkE   = float(np.mean([m['topk_energy']  for m in mets]))
+                            avg_qratio  = float(np.mean([m['q75_q25']      for m in mets]))
+                            svd_results_by_category[name] = dict(
+                                entropy=avg_entropy, erank=avg_erank, topkE=avg_topkE, q75_q25=avg_qratio
+                            )
+
+                    # VO product as another category
+                    if attn_v_params and attn_o_params:
+                        vo_mets = []
+                        num_layers = len(attn_v_params)
+                        for i in range(num_layers):
+                            w_v = attn_v_params[i]
+                            w_o = attn_o_params[i]
+                            w_ov_product = torch.matmul(w_o, w_v)
+                            vo_mets.append(calculate_svd_metrics(w_ov_product, topk=TOPK))
+                        if vo_mets:
+                            svd_results_by_category['vo_prod'] = dict(
+                                entropy=float(np.mean([m['entropy_norm'] for m in vo_mets])),
+                                erank=float(np.mean([m['erank']        for m in vo_mets])),
+                                topkE=float(np.mean([m['topk_energy']  for m in vo_mets])),
+                                q75_q25=float(np.mean([m['q75_q25']    for m in vo_mets])),
+                            )
+
+                # format logging string (append metrics after entropy)
+                svd_log_parts = []
+                for name, vals in svd_results_by_category.items():
+                    svd_log_parts.append(
+                        f"{name}:H={vals['entropy']:.4f},top{TOPK}E={vals['topkE']:.2f},eRank={vals['erank']:.1f},q75/q25={vals['q75_q25']:.2f}"
+                    )
+                svd_log_str = " ".join(svd_log_parts)
+            
+            # log val loss to console and to logfile
+            if master_process:
+                print(f'step:{step}/{args.num_iterations} val_loss:{val_loss:.4f} svd_entropy: {svd_log_str} train_time:{training_time_ms:.0f}ms step_avg:{training_time_ms/(timed_steps-1):.2f}ms')
+                with open(logfile, "a") as f:
+                    f.write(f'step:{step}/{args.num_iterations} val_loss:{val_loss:.4f} svd_entropy: {svd_log_str} train_time:{training_time_ms:.0f}ms step_avg:{training_time_ms/(timed_steps-1):.2f}ms\n')
+            # start the clock again
+            torch.cuda.synchronize()
+        t0 = time.time()
+
+    if master_process and (last_step or (args.save_every > 0 and step % args.save_every == 0)):
+        # stop the clock
+        torch.cuda.synchronize()
+        training_time_ms += 1000 * (time.time() - t0)
+        # save the state of the training process
+        log = dict(step=step, code=code, model=raw_model.state_dict(), optimizers=[opt.state_dict() for opt in optimizers])
+        if run_dir_path_str:
+            save_path = f'{run_dir_path_str}/state_step{step:06d}.pt'
+            torch.save(log, save_path)
+        # start the clock again
+        torch.cuda.synchronize()
+        t0 = time.time()
+
+    # bit confusing: we want to make sure to eval on 0th iteration
+    # but also after the very last iteration. so we loop for step <= num_iterations
+    # instead of just < num_iterations (one extra due to <=), only to do
+    # the validation/sampling one last time, and then we break right here as we're done.
+    if last_step:
+        break
+
+    # --------------- TRAINING SECTION BEGIN -----------------
+    model.train()
+    for i in range(1, train_accumulation_steps+1):
+        # forward pass
+        with ctx:
+            _, loss = model(x, y, return_logits=False)
+            train_loss = loss.detach()
+        # advance the dataset for the next batch
+        x, y = train_loader.next_batch()
+        # backward pass
+        if i < train_accumulation_steps:
+            with model.no_sync(): # there's no need to sync gradients every accumulation step
+                loss.backward()
+        else:
+            loss.backward() # just sync on the last step
+    for p in model.parameters():
+        p.grad /= train_accumulation_steps
+    # step the optimizers and schedulers
+    for opt, sched in zip(optimizers, schedulers):
+        opt.step()
+        sched.step()
+    # null the gradients
+    model.zero_grad(set_to_none=True)
+    # --------------- TRAINING SECTION END -------------------
+    # everything that follows now is just diagnostics, prints, logging, etc.
+
+    #dist.all_reduce(train_loss, op=dist.ReduceOp.AVG) # all-reducing the training loss would be more correct in terms of logging, but slower
+    if master_process:
+        approx_time = training_time_ms + 1000 * (time.time() - t0)
+        print(f"step:{step+1}/{args.num_iterations} train_loss:{train_loss.item():.4f} train_time:{approx_time:.0f}ms step_avg:{approx_time/timed_steps:.2f}ms")
+        with open(logfile, "a") as f:
+            f.write(f"step:{step+1}/{args.num_iterations} train_loss:{train_loss.item():.4f} train_time:{approx_time:.0f}ms step_avg:{approx_time/timed_steps:.2f}ms\n")
+
+if master_process:
+    print(f"peak memory consumption: {torch.cuda.max_memory_allocated() // 1024 // 1024} MiB")

logs_new_MUON_large_reshape_svd_gated/svd/mode_5_param_gated_muon_lr_0.0005_adam_lr_0.0002_seed_42/config.json

@@ -0,0 +1,27 @@
+{
+    "cli_args": {
+        "seed": 42,
+        "optimizer_mode": 5,
+        "model_parameterization": "gated",
+        "adam_lr": 0.0002,
+        "muon_lr": 0.0005,
+        "base_dir": "logs_new_MUON_large_reshape_svd_gated/svd"
+    },
+    "hyperparameters": {
+        "input_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "input_val_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "batch_size": 960,
+        "device_batch_size": 24,
+        "sequence_length": 1024,
+        "num_iterations": 6000,
+        "learning_rate": 0.0018,
+        "warmup_iters": 0,
+        "warmdown_iters": 0,
+        "weight_decay": 0,
+        "val_loss_every": 125,
+        "val_tokens": 10420224,
+        "save_every": 0
+    },
+    "run_uuid_for_log": "c51a87f3-6af4-417a-86fa-83dd74e4e135",
+    "script_code_logged_at_start": true
+}

logs_new_MUON_large_reshape_svd_gated/svd/mode_5_param_gated_muon_lr_0.0005_adam_lr_0.0002_seed_43/config.json

@@ -0,0 +1,27 @@
+{
+    "cli_args": {
+        "seed": 43,
+        "optimizer_mode": 5,
+        "model_parameterization": "gated",
+        "adam_lr": 0.0002,
+        "muon_lr": 0.0005,
+        "base_dir": "logs_new_MUON_large_reshape_svd_gated/svd"
+    },
+    "hyperparameters": {
+        "input_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "input_val_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "batch_size": 960,
+        "device_batch_size": 24,
+        "sequence_length": 1024,
+        "num_iterations": 6000,
+        "learning_rate": 0.0018,
+        "warmup_iters": 0,
+        "warmdown_iters": 0,
+        "weight_decay": 0,
+        "val_loss_every": 125,
+        "val_tokens": 10420224,
+        "save_every": 0
+    },
+    "run_uuid_for_log": "ba9ae92f-719c-4f06-8489-a3fe9a80096d",
+    "script_code_logged_at_start": true
+}

logs_new_MUON_large_reshape_svd_gated/svd/mode_5_param_gated_muon_lr_0.0005_adam_lr_0.0002_seed_43/training_log_ba9ae92f-719c-4f06-8489-a3fe9a80096d.txt

@@ -0,0 +1,856 @@
+import os
+import os
+import sys
+with open(sys.argv[0]) as f:
+    code = f.read() # read the code of this file ASAP, for logging
+import uuid
+import time
+import copy
+import glob
+from dataclasses import dataclass, asdict
+from functools import lru_cache
+from pathlib import Path
+import argparse # Keep argparse for --unet and potentially --optimizer_mode
+import json
+import random 
+import numpy as np 
+
+os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "expandable_segments:True"
+import torch
+torch.empty(1, device="cuda", requires_grad=True).backward() # prevents a bug on some systems
+from torch import Tensor, nn
+import torch.nn.functional as F
+import torch.distributed as dist
+# use of FlexAttention contributed by @KoszarskyB
+from torch.nn.attention.flex_attention import BlockMask, flex_attention
+sys.path.append("/home/aiops/zhangfz/MUON_theory/modded-nanogpt") # Already present
+from optimizers.MUON_new_large_nes import Muon
+from utils.float_compute import mm_op, backward as mm_backward_custom, setup_context as mm_setup_context_custom # Renamed
+import torch._inductor.config as config
+from torch.nn.parallel import DistributedDataParallel as DDP
+from kn_util.utils import setup_debugpy
+
+
+# -----------------------------------------------------------------------------
+# Seeding Function
+def set_seed(seed):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+    print(f"PRINT: Set seed to {seed}", flush=True) # Print immediately for all ranks
+
+
+# ---- ADD: spectral metrics helper ----
+def calculate_svd_metrics(matrix: torch.Tensor, *, topk: int = 10):
+    """
+    Returns dict with:
+      - entropy_norm: normalized SVD entropy
+      - erank: effective rank = exp(Shannon entropy of p)
+      - topk_energy: sum of top-k p_i (energy fraction in the top-k singular values)
+      - q75_q25: ratio of 75th to 25th percentile of eigenvalues (sigma^2)
+    """
+    with torch.no_grad():
+        s = torch.linalg.svdvals(matrix.detach().to('cpu', torch.float32))
+        s = s[s > 1e-9]
+        n = s.numel()
+        if n == 0:
+            return dict(entropy_norm=0.0, erank=0.0, topk_energy=0.0, q75_q25=float('inf'))
+
+        s2 = s * s
+        S2_sum = float(torch.sum(s2))
+        if S2_sum == 0.0:
+            return dict(entropy_norm=0.0, erank=0.0, topk_energy=0.0, q75_q25=float('inf'))
+
+        p = s2 / S2_sum  # energy distribution
+        # Shannon entropy H (natural log)
+        H = float(torch.sum(torch.special.entr(p)))
+        entropy_norm = H / np.log(max(n, 2))  
+        erank = float(np.exp(H))
+
+        k = min(topk, n)
+        topk_energy = float(torch.topk(p, k).values.sum())
+
+        # eigenvalues = s^2, use quantiles on s^2
+        q25 = float(torch.quantile(s2, 0.25))
+        q75 = float(torch.quantile(s2, 0.75))
+        q75_q25 = (q75 / q25) if q25 > 0 else float('inf')
+
+        return dict(
+            entropy_norm=entropy_norm,
+            erank=erank,
+            topk_energy=topk_energy,
+            q75_q25=q75_q25,
+        )
+
+
+# -----------------------------------------------------------------------------
+# Our own simple Distributed Data Loader
+
+def _peek_data_shard(filename):
+    # only reads the header, returns header data
+    with open(filename, "rb") as f:
+        # first read the header, which is 256 int32 integers (4 bytes each)
+        header = np.frombuffer(f.read(256*4), dtype=np.int32)
+    if header[0] != 20240520:
+        print("ERROR: magic number mismatch in the data .bin file!")
+        print("---> HINT: Are you passing in a correct file with --input_bin?")
+        print("---> HINT: Dataset encoding changed recently, re-run data prepro or refer again to README")
+        print("---> HINT: For example re-run: `python dev/data/tinyshakespeare.py`, then re-try")
+        exit(1)
+    assert header[1] == 1, "unsupported version"
+    ntok = header[2] # number of tokens (claimed)
+    return ntok # for now just return the number of tokens
+
+def _load_data_shard(filename):
+    with open(filename, "rb") as f:
+        # first read the header, which is 256 int32 integers (4 bytes each)
+        header = np.frombuffer(f.read(256*4), dtype=np.int32)
+        assert header[0] == 20240520, "magic number mismatch in the data .bin file"
+        assert header[1] == 1, "unsupported version"
+        ntok = header[2] # number of tokens (claimed)
+        # the rest of it are tokens, stored as uint16
+        tokens = np.frombuffer(f.read(), dtype=np.uint16)
+    assert len(tokens) == ntok, "number of tokens read does not match header?"
+    return tokens
+
+class DistributedDataLoader:
+    def __init__(self, filename_pattern, B, T, process_rank, num_processes):
+        self.process_rank = process_rank
+        self.num_processes = num_processes
+        self.B = B
+        self.T = T
+
+        # glob files that match the pattern
+        self.files = sorted(glob.glob(filename_pattern))
+        assert len(self.files) > 0, f"did not find any files that match the pattern {filename_pattern}"
+
+        # load and validate all data shards, count number of tokens in total
+        ntok_total = 0
+        for fname in self.files:
+            shard_ntok = _peek_data_shard(fname)
+            assert shard_ntok >= num_processes * B * T + 1
+            ntok_total += int(shard_ntok)
+        self.ntok_total = ntok_total
+
+        # kick things off
+        self.reset()
+
+    def reset(self):
+        self.current_shard = 0
+        self.current_position = self.process_rank * self.B * self.T
+        self.tokens = _load_data_shard(self.files[self.current_shard])
+
+    def advance(self): # advance to next data shard
+        self.current_shard = (self.current_shard + 1) % len(self.files)
+        self.current_position = self.process_rank * self.B * self.T
+        self.tokens = _load_data_shard(self.files[self.current_shard])
+
+    def next_batch(self):
+        B = self.B
+        T = self.T
+        buf = self.tokens[self.current_position : self.current_position+B*T+1]
+        buf = torch.tensor(buf.astype(np.int32), dtype=torch.long)
+        x = (buf[:-1]).view(B, T) # inputs
+        y = (buf[1:]).view(B, T) # targets
+        # advance current position and load next shard if necessary
+        self.current_position += B * T * self.num_processes
+        if self.current_position + (B * T * self.num_processes + 1) > len(self.tokens):
+            self.advance()
+        return x.cuda(), y.cuda()
+
+# -----------------------------------------------------------------------------
+# int main
+
+@dataclass
+class Hyperparameters:
+    # data hyperparams
+    input_bin : str = "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin"
+    input_val_bin : str = "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin"
+    # optimization hyperparams
+    batch_size : int = 8*120 # 8*120 # batch size, in sequences, across all devices
+    device_batch_size : int = 24 # batch size, in sequences, per device
+    sequence_length : int = 1024 # sequence length, in tokens
+    num_iterations : int = 6000 # number of iterations to run
+    learning_rate : float = 0.0036 / 2
+    warmup_iters : int = 0
+    warmdown_iters : int = 0 # number of iterations of linear warmup/warmdown for triangular or trapezoidal schedule
+    weight_decay : float = 0
+    # evaluation and logging hyperparams
+    val_loss_every : int = 125 # every how many steps to evaluate val loss? 0 for only at the end
+    val_tokens : int = 10420224 # how many tokens of validation data? it's important to keep this fixed for consistent comparisons
+    save_every : int = 0 # every how many steps to save the checkpoint? 0 for only at the end
+args = Hyperparameters()
+
+
+
+# -----------------------------------------------------------------------------
+# int main
+# setup_debugpy(force=True)
+parser = argparse.ArgumentParser(description="NanoGPT Training Script with Muon")
+parser.add_argument("--seed", type=int, default=42, help="Random seed for reproducibility")
+# --- MODIFICATION: Add optimizer_mode as a CLI argument ---
+parser.add_argument("--optimizer_mode", type=int, default=0,
+                    help="Defines how Muon is applied. "
+                         "0: Muon(All Hidden Attn+MLP - original); "
+                         "1: Muon(QK Attn)/Adam(VO Attn,MLP); "
+                         "2: Muon(VO Attn)/Adam(QK Attn,MLP); "
+                         "3: Muon(All Attn)/Adam(MLP); "
+                         "4: Muon(MLP)/Adam(All Attn)"
+                         "5: All Adam (No Muon, all applicable matrices to Adam)."
+                         "6: Muon(W_2 MLP)/Adam(attn, W_1 MLP)."
+                         "7: Muon(VO Attn, MLP)/Adam(QK Attn)."
+                         "8: Muon(VO Attn, W_2 MLP)/Adam(QK Attn, W_1 MLP)."
+                         )
+parser.add_argument("--model_parameterization", type=str, default="whole",choices=["whole","qkvo", "norope", "gated"])
+parser.add_argument("--adam_lr", type=float, default=0.008, help="Learning rate for Adam matrices")
+parser.add_argument("--muon_lr", type=float, default=0.05, help="Learning rate for Muon matrices")
+parser.add_argument("--base_dir", type=str, default="logs_new_MUON_large/test", help="Base directory for logs")
+exp_args = parser.parse_args()
+set_seed(exp_args.seed)
+
+
+
+# set up DDP (distributed data parallel). torchrun sets this env variable
+assert torch.cuda.is_available()
+dist.init_process_group(backend='nccl')
+ddp_rank = int(os.environ['RANK'])
+ddp_local_rank = int(os.environ['LOCAL_RANK'])
+ddp_world_size = int(os.environ['WORLD_SIZE'])
+device = f'cuda:{ddp_local_rank}'
+torch.cuda.set_device(device)
+print(f"using device: {device}")
+master_process = (ddp_rank == 0) # this process will do logging, checkpointing etc.
+
+logfile = None
+run_dir_path_str = None 
+base_log_dir = Path(exp_args.base_dir)
+
+
+if master_process:
+    import subprocess
+    set_seed(exp_args.seed)
+
+    # Construct folder name based on config and seed
+    # run_folder_name = f"mode_{exp_args.optimizer_mode}_param_{exp_args.model_parameterization}_adam_lr_{exp_args.adam_lr}_seed_{exp_args.seed}"
+    run_folder_name = f"mode_{exp_args.optimizer_mode}_param_{exp_args.model_parameterization}_muon_lr_{exp_args.muon_lr}_adam_lr_{exp_args.adam_lr}_seed_{exp_args.seed}"
+    run_dir_path = base_log_dir / run_folder_name
+    run_dir_path.mkdir(parents=True, exist_ok=True)
+    run_dir_path_str = str(run_dir_path)
+
+    run_uuid = uuid.uuid4() 
+    logfile = run_dir_path / f"training_log_{run_uuid}.txt" 
+    print(f"Logging to: {logfile}")
+
+    # Save configuration
+    config_to_save = {
+        "cli_args": vars(exp_args),
+        "hyperparameters": {k: v for k, v in args.__class__.__dict__.items() if not k.startswith('__') and not callable(v)}, 
+        "run_uuid_for_log": str(run_uuid),
+        "script_code_logged_at_start": True
+    }
+    config_file_path = run_dir_path / "config.json"
+    with open(config_file_path, "w") as f:
+        json.dump(config_to_save, f, indent=4)
+    print(f"Saved configuration to: {config_file_path}")
+
+# convenience variables
+B, T = args.device_batch_size, args.sequence_length
+# calculate the number of steps to take in the val loop.
+print(f"args.val_tokens: {args.val_tokens}, args.batch_size: {args.batch_size}, B: {B}, T: {T}, ddp_world_size: {ddp_world_size}")
+assert args.val_tokens % (B * T * ddp_world_size) == 0
+val_steps = args.val_tokens // (B * T * ddp_world_size)
+# calculate the steps of gradient accumulation required to attain the desired global batch size.
+assert args.batch_size % (B * ddp_world_size) == 0
+train_accumulation_steps = args.batch_size // (B * ddp_world_size)
+
+# load tokens
+train_loader = DistributedDataLoader(args.input_bin, B, T, ddp_rank, ddp_world_size)
+val_loader = DistributedDataLoader(args.input_val_bin, B, T, ddp_rank, ddp_world_size)
+if master_process:
+    print(f"Training DataLoader: total number of tokens: {train_loader.ntok_total} across {len(train_loader.files)} files")
+    print(f"Validation DataLoader: total number of tokens: {val_loader.ntok_total} across {len(val_loader.files)} files")
+x, y = train_loader.next_batch()
+
+# there are only 50257 unique GPT-2 tokens; we extend to nearest multiple of 128 for efficiency. suggested to me by @Grad62304977.
+# this originates from Karpathy's experiments.
+num_vocab = 50304
+
+
+
+if exp_args.model_parameterization == "qkvo":
+    from models.nano_GPT_qkvo_large import GPT, GPTConfig
+    # model = GPT(GPTConfig(vocab_size=num_vocab, n_layer=25, n_head=12, n_embd=1536))
+    model = GPT(GPTConfig(vocab_size=num_vocab, n_layer=36, n_head=20, n_embd=1280))
+elif exp_args.model_parameterization == "gated":
+    from models.nano_GPT_gated_large import GPT, GPTConfig
+    model = GPT(GPTConfig(vocab_size=num_vocab, n_layer=27, n_head=20, n_embd=1280))
+
+if master_process:
+    print(sum(p.numel() for p in model.parameters()))
+model = model.cuda()
+if hasattr(config, "coordinate_descent_tuning"):
+    config.coordinate_descent_tuning = True # suggested by @Chillee
+model = torch.compile(model)
+# here we wrap model into DDP container
+model = DDP(model, device_ids=[ddp_local_rank])
+raw_model = model.module # always contains the "raw" unwrapped model
+ctx = torch.amp.autocast(device_type='cuda', dtype=torch.bfloat16)
+
+# for name, param in raw_model.named_parameters():
+#     print(name, param.shape)
+
+if exp_args.model_parameterization == "qkvo" :
+    print("PRINT: Collecting parameters for optimizers...")
+    head_params = [raw_model.lm_head.weight]
+    # embed_params = [raw_model.transformer.wte.weight] 
+
+    # Granular collection for attention and MLP parts
+    attn_q_params = []
+    attn_k_params = []
+    attn_v_params = []
+    attn_o_params = [] # W_O from c_proj
+    mlp_fc_params = []
+    mlp_proj_params = []
+
+    for block_module in raw_model.transformer.h:
+        if block_module.attn is not None:
+            # These attributes (c_q, c_k, c_v) MUST exist in your CausalSelfAttention class
+            if hasattr(block_module.attn, 'c_q'): attn_q_params.append(block_module.attn.c_q.weight)
+            else:
+                print(f"PRINT: Warning: c_q not found in attn module of a block.")
+            if hasattr(block_module.attn, 'c_k'): attn_k_params.append(block_module.attn.c_k.weight)
+            else: print(f"PRINT: Warning: c_k not found in attn module of a block.")
+            if hasattr(block_module.attn, 'c_v'): attn_v_params.append(block_module.attn.c_v.weight)
+            else: print(f"PRINT: Warning: c_v not found in attn module of a block.")
+            attn_o_params.append(block_module.attn.c_proj.weight)
+        if block_module.mlp is not None:
+            mlp_fc_params.append(block_module.mlp.c_fc.weight)
+            mlp_proj_params.append(block_module.mlp.c_proj.weight)
+
+    # Combine into logical groups for experiments
+    attn_qk_group = attn_q_params + attn_k_params
+    attn_vo_group = attn_v_params + attn_o_params
+    all_attn_matrices = attn_qk_group + attn_vo_group
+    mlp_w1_group = mlp_fc_params
+    mlp_w2_group = mlp_proj_params
+    all_mlp_matrices = mlp_fc_params + mlp_proj_params
+
+    # Scalar parameters (all others not explicitly grouped as matrices)
+    # matrix_params_for_scalar_check = set(head_params + embed_params + all_attn_matrices + all_mlp_matrices)
+    matrix_params_for_scalar_check = set(head_params + all_attn_matrices + all_mlp_matrices)
+    scalar_params = [p for n, p in raw_model.named_parameters() if p not in matrix_params_for_scalar_check]
+    for p_scalar in scalar_params: # Sanity check
+        if p_scalar.ndim >=2:
+            print(f"PRINT: Warning - Parameter {p_scalar.shape} ended up in scalar_params but has ndim >= 2. Check grouping.")
+
+
+    # Determine parameter distribution based on optimizer_mode
+    muon_params_target_list = []
+    adam_matrix_target_list = [] # Matrices that Adam will handle specifically
+    adam_matrix_lr = exp_args.adam_lr  # LR for matrices if Adam handles them (can be tuned)
+
+    current_optimizer_mode = exp_args.optimizer_mode
+    
+    print(f"PRINT: Configuring optimizers for EXPERIMENT_MODE = {current_optimizer_mode}")
+
+    if current_optimizer_mode == 0: # Original behavior: Muon on all "hidden_matrix_params"
+        print(f"PRINT: Mode 0: Muon on ALL Attention (QKVO) and ALL MLP matrices.")
+        muon_params_target_list = all_attn_matrices + all_mlp_matrices
+        # Adam handles embeds, head, scalars by default. No extra matrices for Adam here.
+    elif current_optimizer_mode == 1: # Muon on QK, Adam on VO and MLP
+        print(f"PRINT: Mode 1: Muon on QK Attn. Adam on VO Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_qk_group
+        adam_matrix_target_list = attn_vo_group + all_mlp_matrices
+    elif current_optimizer_mode == 2: # Muon on VO, Adam on QK and MLP
+        print(f"PRINT: Mode 2: Muon on VO Attn. Adam on QK Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_vo_group
+        adam_matrix_target_list = attn_qk_group + all_mlp_matrices
+    elif current_optimizer_mode == 3: # Muon on All Attn (QKVO), Adam on MLP
+        print(f"PRINT: Mode 3: Muon on ALL Attn (QKVO). Adam on MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = all_attn_matrices
+        adam_matrix_target_list = all_mlp_matrices
+    elif current_optimizer_mode == 4: # Muon on MLP, Adam on All Attn (QKVO)
+        print(f"PRINT: Mode 4: Muon on MLP. Adam on ALL Attn (QKVO) (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = all_mlp_matrices
+        adam_matrix_target_list = all_attn_matrices
+    elif current_optimizer_mode == 5: # NEW MODE 5 - All Adam
+        print(f"PRINT: Mode 5: All Adam. All Attn and MLP matrices to Adam (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = [] 
+        adam_matrix_target_list = all_attn_matrices + all_mlp_matrices # All matrices to Adam
+    elif current_optimizer_mode == 6: # Muon on W_2 MLP, Adam on attn, W_1 MLP
+        print(f"PRINT: Mode 6: Muon on W_2 MLP. Adam on attn, W_1 MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = mlp_w2_group
+        adam_matrix_target_list = all_attn_matrices + mlp_w1_group
+    elif current_optimizer_mode == 7: # Muon on VO Attn, MLP, Adam on QK Attn
+        print(f"PRINT: Mode 7: Muon on VO Attn, MLP. Adam on QK Attn (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_vo_group + all_mlp_matrices
+        adam_matrix_target_list = attn_qk_group
+    elif current_optimizer_mode == 8: # Muon on VO Attn, W_2 MLP, Adam on QK Attn, W_1 MLP
+        print(f"PRINT: Mode 8: Muon on VO Attn, W_2 MLP. Adam on QK Attn, W_1 MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_vo_group + mlp_w2_group
+        adam_matrix_target_list = attn_qk_group + mlp_w1_group
+    elif current_optimizer_mode == 9: # Muon on V Attn, MLP
+        print(f"PRINT: Mode 9: Muon on V Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_v_params + all_mlp_matrices
+        adam_matrix_target_list = attn_o_params + attn_qk_group
+    elif current_optimizer_mode == 10: # Muon on O Attn, MLP
+        print(f"PRINT: Mode 10: Muon on O Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_o_params + all_mlp_matrices
+        adam_matrix_target_list = attn_v_params + attn_qk_group
+    elif current_optimizer_mode == 11: # Muon on W_1, Adam on O Attn, QK Attn
+        print(f"PRINT: Mode 11: Muon on W_1. Adam on O Attn, QK Attn (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = mlp_w1_group
+        adam_matrix_target_list = all_attn_matrices + mlp_w2_group
+    elif current_optimizer_mode == 12: # Muon on W_1, VO, Adam on others
+        print(f"PRINT: Mode 12: Muon on W_1. Adam on O Attn, QK Attn (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_vo_group + mlp_w1_group
+        adam_matrix_target_list = attn_qk_group + mlp_w2_group
+    elif current_optimizer_mode == 13:
+        print(f"PRINT: Mode 13: Muon on W_2, W_O. Adam on V Attn, QK Attn, W_1 (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_o_params + mlp_w2_group
+        adam_matrix_target_list = attn_qk_group + attn_v_params + mlp_w1_group 
+    elif current_optimizer_mode == 14:
+        print(f"PRINT: Mode 14: Muon on W_O. Adam on V Attn, QK Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_o_params
+        adam_matrix_target_list = attn_qk_group + attn_v_params +all_mlp_matrices
+    elif current_optimizer_mode == 15:
+        print(f"PRINT: Mode 15: Muon on W_V. Adam on O Attn, QK Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_v_params
+        adam_matrix_target_list = attn_qk_group + attn_o_params +all_mlp_matrices
+    elif current_optimizer_mode == 16:
+        print(f"PRINT: Mode 15: Muon on QKV. Adam on O Attn, QK Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_v_params + attn_qk_group
+        adam_matrix_target_list = attn_o_params +all_mlp_matrices
+    else:
+        raise ValueError(f"Unsupported EXPERIMENT_MODE: {current_optimizer_mode}")
+
+    # Adam optimizer setup
+    adam_param_groups_config = [
+        dict(params=head_params, lr=adam_matrix_lr),
+        # dict(params=embed_params, lr=adam_matrix_lr),
+        dict(params=scalar_params, lr=adam_matrix_lr) # Scalar params always go to Adam
+    ]
+    # Add matrices specifically assigned to Adam for this experiment mode
+    if adam_matrix_target_list:
+        # Ensure adam_matrix_target_list is flat and contains Parameters
+        flat_adam_matrices = [p for sublist_or_p in adam_matrix_target_list for p in (sublist_or_p if isinstance(sublist_or_p, list) else [sublist_or_p]) if p is not None]
+        if flat_adam_matrices: # Only add group if there are params
+            adam_param_groups_config.append(dict(params=flat_adam_matrices, lr=adam_matrix_lr))
+
+    # Filter out any Adam groups that might be empty (e.g., if scalar_params was empty)
+    adam_param_groups_config = [g for g in adam_param_groups_config if g['params']]
+    optimizer1 = torch.optim.Adam(adam_param_groups_config, betas=(0.9, 0.95), eps=1e-10, fused=True)
+    optimizers = [optimizer1] # Start with Adam
+
+    # Muon optimizer setup
+    # if muon_params_target_list:
+    #     # Ensure muon_params_target_list is flat, unique, and contains Parameters
+    #     flat_unique_muon_params = []
+    #     seen_muon_ids = set()
+    #     for sublist_or_p in muon_params_target_list:
+    #         for p in (sublist_or_p if isinstance(sublist_or_p, list) else [sublist_or_p]):
+    #             if p is not None and id(p) not in seen_muon_ids:
+    #                 flat_unique_muon_params.append(p)
+    #                 seen_muon_ids.add(id(p))
+
+    #     muon_param_groups_config = []
+    #     if flat_unique_muon_params:
+    #         muon_param_groups_config.append(dict(params=flat_unique_muon_params, lr=exp_args.muon_lr))
+        
+    #     if flat_unique_muon_params: # Only create Muon if it has parameters
+    #         optimizer2 = Muon(muon_param_groups_config, lr=exp_args.muon_lr, momentum=0.95,rank=ddp_rank, world_size=ddp_world_size) # Pass nesterov, ns_steps
+    #         optimizers.append(optimizer2)
+    #     else:
+    #         print("PRINT: Muon optimizer not created as its target parameter list was empty.")
+    #         optimizer2 = None # Explicitly set to None if not created
+    # else:
+    #     print("PRINT: Muon optimizer not created as muon_params_target_list was empty (e.g. mode where Adam handles all matrices).")
+    #     optimizer2 = None # Explicitly set to None
+    # Muon optimizer setup
+    if muon_params_target_list:
+        # Ensure muon_params_target_list is flat, unique, and contains Parameters
+        flat_unique_muon_params = []
+        seen_muon_ids = set()
+        for sublist_or_p in muon_params_target_list:
+            for p in (sublist_or_p if isinstance(sublist_or_p, list) else [sublist_or_p]):
+                if p is not None and id(p) not in seen_muon_ids:
+                    flat_unique_muon_params.append(p)
+                    seen_muon_ids.add(id(p))
+        
+        if flat_unique_muon_params: # Only create Muon if it has parameters
+            optimizer2 = Muon(flat_unique_muon_params, lr=exp_args.muon_lr, momentum=0.95,rank=ddp_rank, world_size=ddp_world_size) # Pass nesterov, ns_steps
+            optimizers.append(optimizer2)
+        else:
+            print("PRINT: Muon optimizer not created as its target parameter list was empty.")
+            optimizer2 = None # Explicitly set to None if not created
+    else:
+        print("PRINT: Muon optimizer not created as muon_params_target_list was empty (e.g. mode where Adam handles all matrices).")
+        optimizer2 = None # Explicitly set to None
+
+    print(f"PRINT: Optimizers configured. Total optimizers: {len(optimizers)}")
+    if optimizer2:
+        print(f"PRINT: Muon optimizer is active with {len(flat_unique_muon_params)} parameters.")
+    
+    # Set up parameter groups for SVD analysis
+    matrix_groups_for_svd = {}
+    if master_process:
+        matrix_groups_for_svd = {
+            "attn_qk": attn_qk_group,
+            "attn_vo": attn_vo_group,
+            "mlp_w1": mlp_w1_group,
+            "mlp_w2": mlp_w2_group 
+        }
+
+elif exp_args.model_parameterization == "gated":
+    print("PRINT: Collecting parameters for optimizers...")
+    head_params = [raw_model.lm_head.weight]
+    # embed_params = [raw_model.transformer.wte.weight] 
+
+    # Granular collection for attention and MLP parts
+    attn_q_params = []
+    attn_k_params = []
+    attn_v_params = []
+    attn_o_params = [] # W_O from c_proj
+    mlp_fc_params = []
+    mlp_proj_params = []
+    mlp_up_params = []
+
+    for block_module in raw_model.transformer.h:
+        if block_module.attn is not None:
+            # These attributes (c_q, c_k, c_v) MUST exist in your CausalSelfAttention class
+            if hasattr(block_module.attn, 'c_q'): attn_q_params.append(block_module.attn.c_q.weight)
+            else:
+                print(f"PRINT: Warning: c_q not found in attn module of a block.")
+            if hasattr(block_module.attn, 'c_k'): attn_k_params.append(block_module.attn.c_k.weight)
+            else: print(f"PRINT: Warning: c_k not found in attn module of a block.")
+            if hasattr(block_module.attn, 'c_v'): attn_v_params.append(block_module.attn.c_v.weight)
+            else: print(f"PRINT: Warning: c_v not found in attn module of a block.")
+            attn_o_params.append(block_module.attn.c_proj.weight)
+        if block_module.mlp is not None:
+            mlp_fc_params.append(block_module.mlp.c_fc.weight)
+            mlp_proj_params.append(block_module.mlp.c_proj.weight)
+            mlp_up_params.append(block_module.mlp.c_up.weight)
+
+    # Combine into logical groups for experiments
+    attn_qk_group = attn_q_params + attn_k_params
+    attn_vo_group = attn_v_params + attn_o_params
+    all_attn_matrices = attn_qk_group + attn_vo_group
+    mlp_w1_group = mlp_fc_params 
+    mlp_w2_group = mlp_proj_params
+    mlp_up_group = mlp_up_params
+    all_mlp_matrices = mlp_fc_params + mlp_proj_params+ mlp_up_params
+
+    # Scalar parameters (all others not explicitly grouped as matrices)
+    # matrix_params_for_scalar_check = set(head_params + embed_params + all_attn_matrices + all_mlp_matrices)
+    matrix_params_for_scalar_check = set(head_params + all_attn_matrices + all_mlp_matrices)
+    scalar_params = [p for n, p in raw_model.named_parameters() if p not in matrix_params_for_scalar_check]
+    for p_scalar in scalar_params: # Sanity check
+        if p_scalar.ndim >=2:
+            print(f"PRINT: Warning - Parameter {p_scalar.shape} ended up in scalar_params but has ndim >= 2. Check grouping.")
+
+
+    # Determine parameter distribution based on optimizer_mode
+    muon_params_target_list = []
+    adam_matrix_target_list = [] # Matrices that Adam will handle specifically
+    adam_matrix_lr = exp_args.adam_lr  # LR for matrices if Adam handles them (can be tuned)
+
+    current_optimizer_mode = exp_args.optimizer_mode
+    
+    print(f"PRINT: Configuring optimizers for EXPERIMENT_MODE = {current_optimizer_mode}")
+
+    if current_optimizer_mode == 0: # Original behavior: Muon on all "hidden_matrix_params"
+        print(f"PRINT: Mode 0: Muon on ALL Attention (QKVO) and ALL MLP matrices.")
+        muon_params_target_list = all_attn_matrices + all_mlp_matrices
+        # Adam handles embeds, head, scalars by default. No extra matrices for Adam here.
+    elif current_optimizer_mode == 1: # Muon on QK, Adam on VO and MLP
+        print(f"PRINT: Mode 1: Muon on QK Attn. Adam on VO Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_qk_group
+        adam_matrix_target_list = attn_vo_group + all_mlp_matrices
+    elif current_optimizer_mode == 2: # Muon on VO, Adam on QK and MLP
+        print(f"PRINT: Mode 2: Muon on VO Attn. Adam on QK Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_vo_group
+        adam_matrix_target_list = attn_qk_group + all_mlp_matrices
+    elif current_optimizer_mode == 3: # Muon on All Attn (QKVO), Adam on MLP
+        print(f"PRINT: Mode 3: Muon on ALL Attn (QKVO). Adam on MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = all_attn_matrices
+        adam_matrix_target_list = all_mlp_matrices
+    elif current_optimizer_mode == 4: # Muon on MLP, Adam on All Attn (QKVO)
+        print(f"PRINT: Mode 4: Muon on MLP. Adam on ALL Attn (QKVO) (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = all_mlp_matrices
+        adam_matrix_target_list = all_attn_matrices
+    elif current_optimizer_mode == 5: # NEW MODE 5 - All Adam
+        print(f"PRINT: Mode 5: All Adam. All Attn and MLP matrices to Adam (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = [] 
+        adam_matrix_target_list = all_attn_matrices + all_mlp_matrices # All matrices to Adam
+    elif current_optimizer_mode == 6: # Muon on W_2 MLP, Adam on attn, W_1 MLP
+        print(f"PRINT: Mode 6: Muon on W_2 MLP. Adam on attn, W_1 MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = mlp_w2_group
+        adam_matrix_target_list = all_attn_matrices + mlp_w1_group
+    elif current_optimizer_mode == 7: # Muon on VO Attn, MLP, Adam on QK Attn
+        print(f"PRINT: Mode 7: Muon on VO Attn, MLP. Adam on QK Attn (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_vo_group + all_mlp_matrices
+        adam_matrix_target_list = attn_qk_group
+    elif current_optimizer_mode == 8: # Muon on VO Attn, W_2 MLP, Adam on QK Attn, W_1 MLP
+        print(f"PRINT: Mode 8: Muon on VO Attn, W_2 MLP. Adam on QK Attn, W_1 MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_vo_group + mlp_w2_group
+        adam_matrix_target_list = attn_qk_group + mlp_w1_group
+    elif current_optimizer_mode == 9: # Muon on V Attn, MLP
+        print(f"PRINT: Mode 9: Muon on V Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_v_params + all_mlp_matrices
+        adam_matrix_target_list = attn_o_params + attn_qk_group
+    elif current_optimizer_mode == 10: # Muon on O Attn, MLP
+        print(f"PRINT: Mode 10: Muon on O Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_o_params + all_mlp_matrices
+        adam_matrix_target_list = attn_v_params + attn_qk_group
+    elif current_optimizer_mode == 11: # Muon on W_1, Adam on O Attn, QK Attn
+        print(f"PRINT: Mode 11: Muon on W_1. Adam on O Attn, QK Attn (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = mlp_w1_group
+        adam_matrix_target_list = all_attn_matrices + mlp_w2_group
+    elif current_optimizer_mode == 12: # Muon on W_1, VO, Adam on others
+        print(f"PRINT: Mode 11: Muon on W_1. Adam on O Attn, QK Attn (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_vo_group + mlp_w1_group
+        adam_matrix_target_list = attn_qk_group + mlp_w2_group
+    elif current_optimizer_mode == 13:
+        print(f"PRINT: Mode 13: Muon on W_2, W_O. Adam on V Attn, QK Attn, W_1 (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_o_params + mlp_w2_group
+        adam_matrix_target_list = attn_qk_group + attn_v_params + mlp_w1_group 
+    elif current_optimizer_mode == 14:
+        print(f"PRINT: Mode 14: Muon on W_O. Adam on V Attn, QK Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_o_params
+        adam_matrix_target_list = attn_qk_group + attn_v_params +all_mlp_matrices
+    elif current_optimizer_mode == 15:
+        print(f"PRINT: Mode 15: Muon on W_V. Adam on O Attn, QK Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_v_params
+        adam_matrix_target_list = attn_qk_group + attn_o_params +all_mlp_matrices
+    elif current_optimizer_mode == 16:
+        print(f"PRINT: Mode 15: Muon on QKV. Adam on O Attn, QK Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_v_params + attn_qk_group
+        adam_matrix_target_list = attn_o_params +all_mlp_matrices
+    else:
+        raise ValueError(f"Unsupported EXPERIMENT_MODE: {current_optimizer_mode}")
+
+    # Adam optimizer setup
+    adam_param_groups_config = [
+        dict(params=head_params, lr=adam_matrix_lr),
+        # dict(params=embed_params, lr=adam_matrix_lr),
+        dict(params=scalar_params, lr=adam_matrix_lr) # Scalar params always go to Adam
+    ]
+    
+    # Add matrices specifically assigned to Adam for this experiment mode
+    if adam_matrix_target_list:
+        # Ensure adam_matrix_target_list is flat and contains Parameters
+        flat_adam_matrices = [p for sublist_or_p in adam_matrix_target_list for p in (sublist_or_p if isinstance(sublist_or_p, list) else [sublist_or_p]) if p is not None]
+        if flat_adam_matrices: # Only add group if there are params
+            adam_param_groups_config.append(dict(params=flat_adam_matrices, lr=adam_matrix_lr))
+
+    # Filter out any Adam groups that might be empty (e.g., if scalar_params was empty)
+    adam_param_groups_config = [g for g in adam_param_groups_config if g['params']]
+    # print(f"PRINT: The length of Adam param groups config: {len(adam_param_groups_config)}")
+    optimizer1 = torch.optim.Adam(adam_param_groups_config, betas=(0.9, 0.95), eps=1e-10, fused=True)
+    optimizers = [optimizer1] # Start with Adam
+
+    
+    if muon_params_target_list:
+        # Ensure muon_params_target_list is flat, unique, and contains Parameters
+        flat_unique_muon_params = []
+        seen_muon_ids = set()
+        for sublist_or_p in muon_params_target_list:
+            for p in (sublist_or_p if isinstance(sublist_or_p, list) else [sublist_or_p]):
+                if p is not None and id(p) not in seen_muon_ids:
+                    flat_unique_muon_params.append(p)
+                    seen_muon_ids.add(id(p))
+        
+        if flat_unique_muon_params: # Only create Muon if it has parameters
+            optimizer2 = Muon(flat_unique_muon_params, lr=exp_args.muon_lr, momentum=0.95,rank=ddp_rank, world_size=ddp_world_size) # Pass nesterov, ns_steps
+            optimizers.append(optimizer2)
+        else:
+            print("PRINT: Muon optimizer not created as its target parameter list was empty.")
+            optimizer2 = None # Explicitly set to None if not created
+    else:
+        print("PRINT: Muon optimizer not created as muon_params_target_list was empty (e.g. mode where Adam handles all matrices).")
+        optimizer2 = None # Explicitly set to None
+
+    print(f"PRINT: Optimizers configured. Total optimizers: {len(optimizers)}")
+    if optimizer2:
+        print(f"PRINT: Muon optimizer is active with {len(flat_unique_muon_params)} parameters.")
+    
+    # Set up parameter groups for SVD analysis
+    matrix_groups_for_svd = {
+                "attn_qk": attn_qk_group,
+                "attn_vo": attn_vo_group,
+                "mlp_w1": mlp_w1_group,      # c_fc only
+                "mlp_up": mlp_up_group,      # c_up only  
+                "mlp_w2": mlp_proj_params 
+            }
+    
+# optimizer1 = torch.optim.AdamW(raw_model.lm_head.parameters(), lr=args.learning_rate, betas=(0.9, 0.95),
+#                                weight_decay=args.weight_decay, fused=True)
+# optimizer2 = Muon(raw_model.transformer.h.parameters(), lr=0.1*args.learning_rate, momentum=0.95,
+#                   rank=ddp_rank, world_size=ddp_world_size)
+                  
+# optimizers = [optimizer1, optimizer2]
+# learning rate decay scheduler (linear warmup and warmdown)
+def get_lr(it):
+    assert it <= args.num_iterations
+    # 1) linear warmup for warmup_iters steps
+    if it < args.warmup_iters:
+        return (it+1) / args.warmup_iters
+    # 2) constant lr for a while
+    elif it < args.num_iterations - args.warmdown_iters:
+        return 1.0
+    # 3) linear warmdown
+    else:
+        decay_ratio = (args.num_iterations - it) / args.warmdown_iters
+        return decay_ratio
+schedulers = [torch.optim.lr_scheduler.LambdaLR(opt, get_lr) for opt in optimizers]
+
+if master_process:
+    with open(logfile, "a") as f:
+        f.write(code)
+
+training_time_ms = 0
+# start the clock
+torch.cuda.synchronize()
+t0 = time.time()
+# begin training
+train_loader.reset()
+for step in range(args.num_iterations + 1):
+    last_step = (step == args.num_iterations)
+    # This effectively ignores timing first 10 steps, which are slower for weird reasons.
+    # Alternately, and slightly more correctly in terms of benchmarking, we could do 10
+    # steps with dummy data first, and then re-initialize the model and reset the loader.
+    if step == 10:
+        training_time_ms = 0
+        t0 = time.time()
+    timed_steps = float('nan') if step <= 11 else (step - 10) + 1 # <= 11 to avoid bug in val
+
+    # once in a while evaluate the validation dataset
+    if (last_step or (args.val_loss_every > 0 and step % args.val_loss_every == 0)):
+        # stop the clock
+        torch.cuda.synchronize()
+        training_time_ms += 1000 * (time.time() - t0)
+        # run validation batches
+        with torch.no_grad():
+            val_loader.reset()
+            val_loss = 0.0
+            for _ in range(val_steps):
+                x_val, y_val = val_loader.next_batch()
+                with ctx: # of course, we'd like to use no_grad() here too, but that creates a torch.compile error for some reason
+                    _, loss = model(x_val, y_val, return_logits=False)
+                    val_loss += loss.detach()
+                    del loss
+            dist.all_reduce(val_loss, op=dist.ReduceOp.AVG)
+            val_loss /= val_steps
+            
+            # SVD metrics calculation
+            svd_log_str = ""
+            if master_process and 'matrix_groups_for_svd' in locals() and matrix_groups_for_svd:
+                TOPK = 10 
+                svd_results_by_category = {}
+
+                with torch.no_grad():
+                    # per-category metrics (average over matrices in the group)
+                    for name, group_params in matrix_groups_for_svd.items():
+                        if not group_params:
+                            continue
+                        mets = [calculate_svd_metrics(p, topk=TOPK) for p in group_params]
+                        if mets:
+                            avg_entropy = float(np.mean([m['entropy_norm'] for m in mets]))
+                            avg_erank   = float(np.mean([m['erank']        for m in mets]))
+                            avg_topkE   = float(np.mean([m['topk_energy']  for m in mets]))
+                            avg_qratio  = float(np.mean([m['q75_q25']      for m in mets]))
+                            svd_results_by_category[name] = dict(
+                                entropy=avg_entropy, erank=avg_erank, topkE=avg_topkE, q75_q25=avg_qratio
+                            )
+
+                    # VO product as another category
+                    if attn_v_params and attn_o_params:
+                        vo_mets = []
+                        num_layers = len(attn_v_params)
+                        for i in range(num_layers):
+                            w_v = attn_v_params[i]
+                            w_o = attn_o_params[i]
+                            w_ov_product = torch.matmul(w_o, w_v)
+                            vo_mets.append(calculate_svd_metrics(w_ov_product, topk=TOPK))
+                        if vo_mets:
+                            svd_results_by_category['vo_prod'] = dict(
+                                entropy=float(np.mean([m['entropy_norm'] for m in vo_mets])),
+                                erank=float(np.mean([m['erank']        for m in vo_mets])),
+                                topkE=float(np.mean([m['topk_energy']  for m in vo_mets])),
+                                q75_q25=float(np.mean([m['q75_q25']    for m in vo_mets])),
+                            )
+
+                # format logging string (append metrics after entropy)
+                svd_log_parts = []
+                for name, vals in svd_results_by_category.items():
+                    svd_log_parts.append(
+                        f"{name}:H={vals['entropy']:.4f},top{TOPK}E={vals['topkE']:.2f},eRank={vals['erank']:.1f},q75/q25={vals['q75_q25']:.2f}"
+                    )
+                svd_log_str = " ".join(svd_log_parts)
+            
+            # log val loss to console and to logfile
+            if master_process:
+                print(f'step:{step}/{args.num_iterations} val_loss:{val_loss:.4f} svd_entropy: {svd_log_str} train_time:{training_time_ms:.0f}ms step_avg:{training_time_ms/(timed_steps-1):.2f}ms')
+                with open(logfile, "a") as f:
+                    f.write(f'step:{step}/{args.num_iterations} val_loss:{val_loss:.4f} svd_entropy: {svd_log_str} train_time:{training_time_ms:.0f}ms step_avg:{training_time_ms/(timed_steps-1):.2f}ms\n')
+            # start the clock again
+            torch.cuda.synchronize()
+        t0 = time.time()
+
+    if master_process and (last_step or (args.save_every > 0 and step % args.save_every == 0)):
+        # stop the clock
+        torch.cuda.synchronize()
+        training_time_ms += 1000 * (time.time() - t0)
+        # save the state of the training process
+        log = dict(step=step, code=code, model=raw_model.state_dict(), optimizers=[opt.state_dict() for opt in optimizers])
+        if run_dir_path_str:
+            save_path = f'{run_dir_path_str}/state_step{step:06d}.pt'
+            torch.save(log, save_path)
+        # start the clock again
+        torch.cuda.synchronize()
+        t0 = time.time()
+
+    # bit confusing: we want to make sure to eval on 0th iteration
+    # but also after the very last iteration. so we loop for step <= num_iterations
+    # instead of just < num_iterations (one extra due to <=), only to do
+    # the validation/sampling one last time, and then we break right here as we're done.
+    if last_step:
+        break
+
+    # --------------- TRAINING SECTION BEGIN -----------------
+    model.train()
+    for i in range(1, train_accumulation_steps+1):
+        # forward pass
+        with ctx:
+            _, loss = model(x, y, return_logits=False)
+            train_loss = loss.detach()
+        # advance the dataset for the next batch
+        x, y = train_loader.next_batch()
+        # backward pass
+        if i < train_accumulation_steps:
+            with model.no_sync(): # there's no need to sync gradients every accumulation step
+                loss.backward()
+        else:
+            loss.backward() # just sync on the last step
+    for p in model.parameters():
+        p.grad /= train_accumulation_steps
+    # step the optimizers and schedulers
+    for opt, sched in zip(optimizers, schedulers):
+        opt.step()
+        sched.step()
+    # null the gradients
+    model.zero_grad(set_to_none=True)
+    # --------------- TRAINING SECTION END -------------------
+    # everything that follows now is just diagnostics, prints, logging, etc.
+
+    #dist.all_reduce(train_loss, op=dist.ReduceOp.AVG) # all-reducing the training loss would be more correct in terms of logging, but slower
+    if master_process:
+        approx_time = training_time_ms + 1000 * (time.time() - t0)
+        print(f"step:{step+1}/{args.num_iterations} train_loss:{train_loss.item():.4f} train_time:{approx_time:.0f}ms step_avg:{approx_time/timed_steps:.2f}ms")
+        with open(logfile, "a") as f:
+            f.write(f"step:{step+1}/{args.num_iterations} train_loss:{train_loss.item():.4f} train_time:{approx_time:.0f}ms step_avg:{approx_time/timed_steps:.2f}ms\n")
+
+if master_process:
+    print(f"peak memory consumption: {torch.cuda.max_memory_allocated() // 1024 // 1024} MiB")