update

logs_new_MUON_large_reshape_svd_gated/adam_lr_search/mode_5_param_gated_muon_lr_0.0005_adam_lr_0.0001_seed_42/config.json

@@ -0,0 +1,27 @@
+{
+    "cli_args": {
+        "seed": 42,
+        "optimizer_mode": 5,
+        "model_parameterization": "gated",
+        "adam_lr": 0.0001,
+        "muon_lr": 0.0005,
+        "base_dir": "logs_new_MUON_large_reshape_svd_gated/adam_lr_search"
+    },
+    "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": "261fa789-df7d-467c-8a61-132d8b890d81",
+    "script_code_logged_at_start": true
+}

logs_new_MUON_large_reshape_svd_gated/adam_lr_search/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/adam_lr_search"
+    },
+    "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": "e1801bc8-61ea-4070-99f6-ffb8e3ec4441",
+    "script_code_logged_at_start": true
+}

logs_new_MUON_large_reshape_svd_gated/adam_lr_search/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/adam_lr_search"
+    },
+    "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": "87651557-14a7-4c0b-80e7-7f6b32172f1e",
+    "script_code_logged_at_start": true
+}

logs_new_MUON_large_reshape_svd_gated/ori/mode_1_param_gated_muon_lr_0.0005_adam_lr_0.0005_seed_42/config.json

@@ -0,0 +1,27 @@
+{
+    "cli_args": {
+        "seed": 42,
+        "optimizer_mode": 1,
+        "model_parameterization": "gated",
+        "adam_lr": 0.0005,
+        "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": "0df68171-82e1-4de2-a0c5-af00f95db131",
+    "script_code_logged_at_start": true
+}

logs_new_MUON_large_reshape_svd_gated/ori/mode_1_param_gated_muon_lr_0.0005_adam_lr_0.0005_seed_43/config.json

@@ -0,0 +1,27 @@
+{
+    "cli_args": {
+        "seed": 43,
+        "optimizer_mode": 1,
+        "model_parameterization": "gated",
+        "adam_lr": 0.0005,
+        "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": "14f8cd0f-e874-488a-ab8b-8e92f305dfaf",
+    "script_code_logged_at_start": true
+}

logs_new_MUON_large_reshape_svd_gated/ori/mode_1_param_gated_muon_lr_0.0005_adam_lr_0.0005_seed_43/training_log_14f8cd0f-e874-488a-ab8b-8e92f305dfaf.txt

@@ -0,0 +1,1168 @@
+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
+
+
+# -----------------------------------------------------------------------------
+# 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 # 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 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
+    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
+
+    # 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.")
+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_up_params
+    mlp_w2_group = mlp_proj_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
+    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.")
+    
+# 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
+            # log val loss to console and to logfile
+            if master_process:
+                print(f'step:{step}/{args.num_iterations} val_loss:{val_loss:.4f} 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} 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])
+        torch.save(log, 'logs/%s/state_step%06d.pt' % (run_id, step))
+        # 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")step:0/6000 val_loss:10.9980 train_time:147ms step_avg:nanms
+step:1/6000 train_loss:11.0032 train_time:40163ms step_avg:nanms
+step:2/6000 train_loss:10.0867 train_time:43651ms step_avg:nanms
+step:3/6000 train_loss:9.3940 train_time:47079ms step_avg:nanms
+step:4/6000 train_loss:8.8213 train_time:50448ms step_avg:nanms
+step:5/6000 train_loss:8.5063 train_time:53816ms step_avg:nanms
+step:6/6000 train_loss:8.3227 train_time:57183ms step_avg:nanms
+step:7/6000 train_loss:7.8312 train_time:60551ms step_avg:nanms
+step:8/6000 train_loss:7.9443 train_time:63915ms step_avg:nanms
+step:9/6000 train_loss:7.6822 train_time:67277ms step_avg:nanms
+step:10/6000 train_loss:7.9030 train_time:70641ms step_avg:nanms
+step:11/6000 train_loss:7.9286 train_time:3266ms step_avg:nanms
+step:12/6000 train_loss:7.7966 train_time:6632ms step_avg:nanms
+step:13/6000 train_loss:8.2405 train_time:10001ms step_avg:3333.77ms
+step:14/6000 train_loss:7.7617 train_time:13371ms step_avg:3342.81ms
+step:15/6000 train_loss:7.7143 train_time:16742ms step_avg:3348.42ms
+step:16/6000 train_loss:7.7441 train_time:20115ms step_avg:3352.52ms
+step:17/6000 train_loss:7.4602 train_time:23486ms step_avg:3355.14ms
+step:18/6000 train_loss:7.7831 train_time:26862ms step_avg:3357.80ms
+step:19/6000 train_loss:7.7015 train_time:30235ms step_avg:3359.50ms
+step:20/6000 train_loss:7.4613 train_time:33610ms step_avg:3361.04ms
+step:21/6000 train_loss:7.7094 train_time:36985ms step_avg:3362.29ms
+step:22/6000 train_loss:7.8955 train_time:40362ms step_avg:3363.51ms
+step:23/6000 train_loss:7.9146 train_time:43739ms step_avg:3364.55ms
+step:24/6000 train_loss:7.6228 train_time:47119ms step_avg:3365.61ms
+step:25/6000 train_loss:7.7719 train_time:50501ms step_avg:3366.72ms
+step:26/6000 train_loss:7.3381 train_time:53887ms step_avg:3367.93ms
+step:27/6000 train_loss:7.3544 train_time:57276ms step_avg:3369.18ms
+step:28/6000 train_loss:7.2266 train_time:60667ms step_avg:3370.38ms
+step:29/6000 train_loss:7.7346 train_time:64062ms step_avg:3371.70ms
+step:30/6000 train_loss:7.3986 train_time:67459ms step_avg:3372.94ms
+step:31/6000 train_loss:7.5775 train_time:70856ms step_avg:3374.09ms
+step:32/6000 train_loss:7.4900 train_time:74253ms step_avg:3375.15ms
+step:33/6000 train_loss:7.3644 train_time:77655ms step_avg:3376.29ms
+step:34/6000 train_loss:9.5895 train_time:81055ms step_avg:3377.31ms
+step:35/6000 train_loss:7.4402 train_time:84460ms step_avg:3378.42ms
+step:36/6000 train_loss:7.4615 train_time:87865ms step_avg:3379.42ms
+step:37/6000 train_loss:7.8023 train_time:91270ms step_avg:3380.37ms
+step:38/6000 train_loss:7.1083 train_time:94683ms step_avg:3381.52ms
+step:39/6000 train_loss:7.3571 train_time:98092ms step_avg:3382.49ms
+step:40/6000 train_loss:7.2065 train_time:101505ms step_avg:3383.50ms
+step:41/6000 train_loss:8.4150 train_time:104913ms step_avg:3384.30ms
+step:42/6000 train_loss:7.1353 train_time:108324ms step_avg:3385.13ms
+step:43/6000 train_loss:7.0507 train_time:111738ms step_avg:3386.00ms
+step:44/6000 train_loss:7.2028 train_time:115147ms step_avg:3386.68ms
+step:45/6000 train_loss:8.0166 train_time:118560ms step_avg:3387.44ms
+step:46/6000 train_loss:7.0652 train_time:121970ms step_avg:3388.05ms
+step:47/6000 train_loss:6.8885 train_time:125379ms step_avg:3388.61ms
+step:48/6000 train_loss:7.0325 train_time:128786ms step_avg:3389.10ms
+step:49/6000 train_loss:6.8367 train_time:132195ms step_avg:3389.61ms
+step:50/6000 train_loss:7.0070 train_time:135606ms step_avg:3390.16ms
+step:51/6000 train_loss:7.0726 train_time:139017ms step_avg:3390.66ms
+step:52/6000 train_loss:6.9066 train_time:142429ms step_avg:3391.17ms
+step:53/6000 train_loss:6.6981 train_time:145842ms step_avg:3391.68ms
+step:54/6000 train_loss:6.9595 train_time:149256ms step_avg:3392.17ms
+step:55/6000 train_loss:6.9502 train_time:152673ms step_avg:3392.73ms
+step:56/6000 train_loss:7.0270 train_time:156085ms step_avg:3393.15ms
+step:57/6000 train_loss:6.5760 train_time:159500ms step_avg:3393.61ms
+step:58/6000 train_loss:6.9247 train_time:162916ms step_avg:3394.08ms
+step:59/6000 train_loss:6.6995 train_time:166331ms step_avg:3394.51ms
+step:60/6000 train_loss:6.7923 train_time:169748ms step_avg:3394.97ms
+step:61/6000 train_loss:6.7997 train_time:173163ms step_avg:3395.36ms
+step:62/6000 train_loss:7.0957 train_time:176582ms step_avg:3395.81ms
+step:63/6000 train_loss:6.8985 train_time:180000ms step_avg:3396.23ms
+step:64/6000 train_loss:6.7014 train_time:183439ms step_avg:3397.02ms
+step:65/6000 train_loss:6.9532 train_time:186860ms step_avg:3397.46ms
+step:66/6000 train_loss:7.1222 train_time:190281ms step_avg:3397.88ms
+step:67/6000 train_loss:6.7153 train_time:193700ms step_avg:3398.25ms
+step:68/6000 train_loss:6.9772 train_time:197122ms step_avg:3398.65ms
+step:69/6000 train_loss:6.7818 train_time:200542ms step_avg:3399.02ms
+step:70/6000 train_loss:6.8963 train_time:203964ms step_avg:3399.40ms
+step:71/6000 train_loss:6.6256 train_time:207385ms step_avg:3399.76ms
+step:72/6000 train_loss:6.4692 train_time:210807ms step_avg:3400.11ms
+step:73/6000 train_loss:7.0340 train_time:214228ms step_avg:3400.44ms
+step:74/6000 train_loss:6.6450 train_time:217650ms step_avg:3400.78ms
+step:75/6000 train_loss:6.5455 train_time:221072ms step_avg:3401.11ms
+step:76/6000 train_loss:6.9795 train_time:224495ms step_avg:3401.44ms
+step:77/6000 train_loss:6.7381 train_time:227918ms step_avg:3401.76ms
+step:78/6000 train_loss:6.6731 train_time:231340ms step_avg:3402.07ms
+step:79/6000 train_loss:6.6018 train_time:234762ms step_avg:3402.35ms
+step:80/6000 train_loss:7.0440 train_time:238185ms step_avg:3402.64ms
+step:81/6000 train_loss:6.2447 train_time:241610ms step_avg:3402.96ms
+step:82/6000 train_loss:6.7507 train_time:245034ms step_avg:3403.25ms
+step:83/6000 train_loss:6.5987 train_time:248458ms step_avg:3403.54ms
+step:84/6000 train_loss:6.6679 train_time:251883ms step_avg:3403.83ms
+step:85/6000 train_loss:6.5572 train_time:255310ms step_avg:3404.13ms
+step:86/6000 train_loss:6.5454 train_time:258738ms step_avg:3404.45ms
+step:87/6000 train_loss:6.7837 train_time:262162ms step_avg:3404.70ms
+step:88/6000 train_loss:6.6183 train_time:265587ms step_avg:3404.97ms
+step:89/6000 train_loss:6.5827 train_time:269015ms step_avg:3405.25ms
+step:90/6000 train_loss:6.2560 train_time:272441ms step_avg:3405.51ms
+step:91/6000 train_loss:6.5403 train_time:275867ms step_avg:3405.77ms
+step:92/6000 train_loss:6.7094 train_time:279295ms step_avg:3406.03ms
+step:93/6000 train_loss:6.3179 train_time:282723ms step_avg:3406.30ms
+step:94/6000 train_loss:6.4432 train_time:286150ms step_avg:3406.55ms
+step:95/6000 train_loss:6.5397 train_time:289577ms step_avg:3406.78ms
+step:96/6000 train_loss:6.5843 train_time:293007ms step_avg:3407.05ms
+step:97/6000 train_loss:6.4347 train_time:296434ms step_avg:3407.28ms
+step:98/6000 train_loss:6.4028 train_time:299861ms step_avg:3407.51ms
+step:99/6000 train_loss:6.4276 train_time:303287ms step_avg:3407.72ms
+step:100/6000 train_loss:6.5565 train_time:306715ms step_avg:3407.95ms
+step:101/6000 train_loss:6.5317 train_time:310142ms step_avg:3408.16ms
+step:102/6000 train_loss:6.3285 train_time:316608ms step_avg:3441.39ms
+step:103/6000 train_loss:6.2299 train_time:320028ms step_avg:3441.16ms
+step:104/6000 train_loss:6.6324 train_time:323450ms step_avg:3440.96ms
+step:105/6000 train_loss:6.5289 train_time:326874ms step_avg:3440.78ms
+step:106/6000 train_loss:6.3982 train_time:330303ms step_avg:3440.66ms
+step:107/6000 train_loss:5.9289 train_time:333733ms step_avg:3440.54ms
+step:108/6000 train_loss:6.8416 train_time:337165ms step_avg:3440.46ms
+step:109/6000 train_loss:6.3654 train_time:340597ms step_avg:3440.37ms
+step:110/6000 train_loss:6.3199 train_time:344028ms step_avg:3440.28ms
+step:111/6000 train_loss:6.4951 train_time:347463ms step_avg:3440.23ms
+step:112/6000 train_loss:6.4661 train_time:350897ms step_avg:3440.17ms
+step:113/6000 train_loss:6.3542 train_time:354332ms step_avg:3440.12ms
+step:114/6000 train_loss:6.1977 train_time:357768ms step_avg:3440.08ms
+step:115/6000 train_loss:6.4477 train_time:361206ms step_avg:3440.06ms
+step:116/6000 train_loss:6.1892 train_time:364641ms step_avg:3440.01ms
+step:117/6000 train_loss:6.3011 train_time:368074ms step_avg:3439.95ms
+step:118/6000 train_loss:6.2822 train_time:371509ms step_avg:3439.90ms
+step:119/6000 train_loss:6.4953 train_time:374944ms step_avg:3439.85ms
+step:120/6000 train_loss:6.3468 train_time:378379ms step_avg:3439.81ms
+step:121/6000 train_loss:6.0975 train_time:381812ms step_avg:3439.75ms
+step:122/6000 train_loss:6.2077 train_time:385244ms step_avg:3439.68ms
+step:123/6000 train_loss:6.2784 train_time:388680ms step_avg:3439.64ms
+step:124/6000 train_loss:6.2644 train_time:392113ms step_avg:3439.59ms
+step:125/6000 train_loss:5.9758 train_time:395546ms step_avg:3439.53ms
+step:125/6000 val_loss:6.2202 train_time:395644ms step_avg:3440.38ms
+step:126/6000 train_loss:6.2274 train_time:398970ms step_avg:3439.39ms
+step:127/6000 train_loss:6.2286 train_time:402398ms step_avg:3439.30ms
+step:128/6000 train_loss:5.9971 train_time:405829ms step_avg:3439.23ms
+step:129/6000 train_loss:7.3516 train_time:409261ms step_avg:3439.17ms
+step:130/6000 train_loss:6.2489 train_time:412687ms step_avg:3439.06ms
+step:131/6000 train_loss:6.1241 train_time:416120ms step_avg:3439.01ms
+step:132/6000 train_loss:6.0882 train_time:419552ms step_avg:3438.95ms
+step:133/6000 train_loss:6.3320 train_time:422982ms step_avg:3438.88ms
+step:134/6000 train_loss:6.1205 train_time:426413ms step_avg:3438.81ms
+step:135/6000 train_loss:6.0544 train_time:429844ms step_avg:3438.75ms
+step:136/6000 train_loss:5.9895 train_time:433275ms step_avg:3438.69ms
+step:137/6000 train_loss:6.4605 train_time:436704ms step_avg:3438.61ms
+step:138/6000 train_loss:5.9376 train_time:440133ms step_avg:3438.54ms
+step:139/6000 train_loss:6.1267 train_time:443563ms step_avg:3438.47ms
+step:140/6000 train_loss:6.2660 train_time:446996ms step_avg:3438.43ms
+step:141/6000 train_loss:6.2711 train_time:450427ms step_avg:3438.38ms
+step:142/6000 train_loss:5.9940 train_time:453860ms step_avg:3438.33ms
+step:143/6000 train_loss:6.2173 train_time:457291ms step_avg:3438.28ms
+step:144/6000 train_loss:5.7843 train_time:460719ms step_avg:3438.20ms
+step:145/6000 train_loss:6.0585 train_time:464148ms step_avg:3438.13ms
+step:146/6000 train_loss:6.8930 train_time:467578ms step_avg:3438.07ms
+step:147/6000 train_loss:6.0025 train_time:471005ms step_avg:3437.99ms
+step:148/6000 train_loss:5.9709 train_time:474433ms step_avg:3437.92ms
+step:149/6000 train_loss:6.0879 train_time:477861ms step_avg:3437.85ms
+step:150/6000 train_loss:5.8014 train_time:481292ms step_avg:3437.80ms
+step:151/6000 train_loss:5.8108 train_time:484719ms step_avg:3437.72ms
+step:152/6000 train_loss:6.2351 train_time:488149ms step_avg:3437.67ms
+step:153/6000 train_loss:6.0089 train_time:491580ms step_avg:3437.62ms
+step:154/6000 train_loss:5.9436 train_time:495011ms step_avg:3437.58ms
+step:155/6000 train_loss:5.9776 train_time:498442ms step_avg:3437.53ms
+step:156/6000 train_loss:6.0841 train_time:501874ms step_avg:3437.49ms
+step:157/6000 train_loss:5.8146 train_time:505308ms step_avg:3437.47ms
+step:158/6000 train_loss:5.9461 train_time:508739ms step_avg:3437.42ms
+step:159/6000 train_loss:5.8189 train_time:512169ms step_avg:3437.37ms
+step:160/6000 train_loss:5.7114 train_time:515598ms step_avg:3437.32ms
+step:161/6000 train_loss:5.8973 train_time:519027ms step_avg:3437.27ms
+step:162/6000 train_loss:6.1168 train_time:522459ms step_avg:3437.23ms
+step:163/6000 train_loss:5.9027 train_time:525887ms step_avg:3437.17ms
+step:164/6000 train_loss:5.9478 train_time:529316ms step_avg:3437.12ms
+step:165/6000 train_loss:5.9128 train_time:532743ms step_avg:3437.05ms
+step:166/6000 train_loss:5.9402 train_time:536169ms step_avg:3436.98ms
+step:167/6000 train_loss:5.7465 train_time:539596ms step_avg:3436.91ms
+step:168/6000 train_loss:6.1393 train_time:543024ms step_avg:3436.86ms
+step:169/6000 train_loss:6.0217 train_time:546452ms step_avg:3436.81ms
+step:170/6000 train_loss:5.8525 train_time:549881ms step_avg:3436.75ms
+step:171/6000 train_loss:5.9346 train_time:553306ms step_avg:3436.68ms
+step:172/6000 train_loss:5.8628 train_time:556736ms step_avg:3436.64ms
+step:173/6000 train_loss:6.2714 train_time:560165ms step_avg:3436.59ms
+step:174/6000 train_loss:5.8207 train_time:563594ms step_avg:3436.55ms
+step:175/6000 train_loss:5.9392 train_time:567023ms step_avg:3436.50ms
+step:176/6000 train_loss:6.0277 train_time:570451ms step_avg:3436.45ms
+step:177/6000 train_loss:5.7605 train_time:573881ms step_avg:3436.41ms
+step:178/6000 train_loss:5.8249 train_time:577311ms step_avg:3436.38ms
+step:179/6000 train_loss:5.7059 train_time:580739ms step_avg:3436.33ms
+step:180/6000 train_loss:7.6142 train_time:584172ms step_avg:3436.30ms
+step:181/6000 train_loss:6.0449 train_time:587598ms step_avg:3436.24ms
+step:182/6000 train_loss:5.9221 train_time:591025ms step_avg:3436.19ms
+step:183/6000 train_loss:6.1453 train_time:594456ms step_avg:3436.16ms
+step:184/6000 train_loss:5.8522 train_time:597887ms step_avg:3436.13ms
+step:185/6000 train_loss:5.7065 train_time:601317ms step_avg:3436.10ms
+step:186/6000 train_loss:5.8987 train_time:604745ms step_avg:3436.05ms
+step:187/6000 train_loss:5.5877 train_time:608173ms step_avg:3436.00ms
+step:188/6000 train_loss:5.6168 train_time:611601ms step_avg:3435.96ms
+step:189/6000 train_loss:5.8485 train_time:615029ms step_avg:3435.92ms
+step:190/6000 train_loss:5.8701 train_time:618457ms step_avg:3435.87ms
+step:191/6000 train_loss:5.9194 train_time:621886ms step_avg:3435.84ms
+step:192/6000 train_loss:5.7652 train_time:625313ms step_avg:3435.78ms
+step:193/6000 train_loss:5.7282 train_time:628738ms step_avg:3435.73ms
+step:194/6000 train_loss:5.5799 train_time:632164ms step_avg:3435.67ms
+step:195/6000 train_loss:5.5540 train_time:635590ms step_avg:3435.62ms
+step:196/6000 train_loss:5.9021 train_time:639015ms step_avg:3435.57ms
+step:197/6000 train_loss:5.8146 train_time:642443ms step_avg:3435.52ms
+step:198/6000 train_loss:5.7791 train_time:645871ms step_avg:3435.48ms
+step:199/6000 train_loss:5.7060 train_time:649296ms step_avg:3435.43ms
+step:200/6000 train_loss:5.6925 train_time:652722ms step_avg:3435.38ms
+step:201/6000 train_loss:6.4219 train_time:656152ms step_avg:3435.35ms
+step:202/6000 train_loss:5.4622 train_time:659580ms step_avg:3435.31ms
+step:203/6000 train_loss:5.7132 train_time:663007ms step_avg:3435.27ms
+step:204/6000 train_loss:5.8492 train_time:667029ms step_avg:3438.29ms
+step:205/6000 train_loss:5.6963 train_time:670454ms step_avg:3438.22ms
+step:206/6000 train_loss:5.8170 train_time:673879ms step_avg:3438.16ms
+step:207/6000 train_loss:5.6781 train_time:677304ms step_avg:3438.09ms
+step:208/6000 train_loss:5.6581 train_time:680731ms step_avg:3438.04ms
+step:209/6000 train_loss:5.5768 train_time:684158ms step_avg:3437.98ms
+step:210/6000 train_loss:5.5374 train_time:687585ms step_avg:3437.93ms
+step:211/6000 train_loss:5.6328 train_time:691011ms step_avg:3437.86ms
+step:212/6000 train_loss:5.5371 train_time:694438ms step_avg:3437.81ms
+step:213/6000 train_loss:5.7779 train_time:697868ms step_avg:3437.77ms
+step:214/6000 train_loss:5.6459 train_time:701292ms step_avg:3437.71ms
+step:215/6000 train_loss:5.5111 train_time:704717ms step_avg:3437.64ms
+step:216/6000 train_loss:5.5370 train_time:708144ms step_avg:3437.59ms
+step:217/6000 train_loss:5.7410 train_time:711569ms step_avg:3437.53ms
+step:218/6000 train_loss:5.5489 train_time:714993ms step_avg:3437.47ms
+step:219/6000 train_loss:5.5209 train_time:718419ms step_avg:3437.41ms
+step:220/6000 train_loss:5.6407 train_time:721846ms step_avg:3437.36ms
+step:221/6000 train_loss:5.5778 train_time:725269ms step_avg:3437.30ms
+step:222/6000 train_loss:5.5257 train_time:728694ms step_avg:3437.24ms
+step:223/6000 train_loss:5.5941 train_time:732118ms step_avg:3437.17ms
+step:224/6000 train_loss:5.4758 train_time:735542ms step_avg:3437.11ms
+step:225/6000 train_loss:5.5554 train_time:738969ms step_avg:3437.07ms
+step:226/6000 train_loss:5.3976 train_time:742394ms step_avg:3437.01ms
+step:227/6000 train_loss:5.5843 train_time:745823ms step_avg:3436.97ms
+step:228/6000 train_loss:5.4941 train_time:749249ms step_avg:3436.92ms
+step:229/6000 train_loss:5.3370 train_time:752674ms step_avg:3436.87ms
+step:230/6000 train_loss:5.3272 train_time:756095ms step_avg:3436.80ms
+step:231/6000 train_loss:5.3964 train_time:759521ms step_avg:3436.75ms
+step:232/6000 train_loss:5.6522 train_time:762945ms step_avg:3436.69ms
+step:233/6000 train_loss:5.3876 train_time:766370ms step_avg:3436.64ms
+step:234/6000 train_loss:5.5173 train_time:769797ms step_avg:3436.59ms
+step:235/6000 train_loss:5.4452 train_time:773222ms step_avg:3436.54ms
+step:236/6000 train_loss:5.5613 train_time:776647ms step_avg:3436.49ms
+step:237/6000 train_loss:5.6494 train_time:780072ms step_avg:3436.44ms
+step:238/6000 train_loss:5.2440 train_time:783498ms step_avg:3436.39ms
+step:239/6000 train_loss:5.5541 train_time:786923ms step_avg:3436.34ms
+step:240/6000 train_loss:5.4429 train_time:790351ms step_avg:3436.31ms
+step:241/6000 train_loss:5.4246 train_time:793772ms step_avg:3436.24ms
+step:242/6000 train_loss:5.2503 train_time:797195ms step_avg:3436.18ms
+step:243/6000 train_loss:5.3397 train_time:800620ms step_avg:3436.14ms
+step:244/6000 train_loss:5.3209 train_time:804043ms step_avg:3436.08ms
+step:245/6000 train_loss:5.3957 train_time:807465ms step_avg:3436.02ms
+step:246/6000 train_loss:5.3504 train_time:810889ms step_avg:3435.97ms
+step:247/6000 train_loss:5.0592 train_time:814310ms step_avg:3435.91ms
+step:248/6000 train_loss:5.3366 train_time:817732ms step_avg:3435.85ms
+step:249/6000 train_loss:5.4224 train_time:821155ms step_avg:3435.79ms
+step:250/6000 train_loss:5.3302 train_time:824579ms step_avg:3435.75ms
+step:250/6000 val_loss:5.3795 train_time:824677ms step_avg:3436.16ms
+step:251/6000 train_loss:5.3206 train_time:827988ms step_avg:3435.64ms
+step:252/6000 train_loss:5.1456 train_time:831406ms step_avg:3435.56ms
+step:253/6000 train_loss:5.5313 train_time:834824ms step_avg:3435.49ms
+step:254/6000 train_loss:5.2743 train_time:838240ms step_avg:3435.41ms
+step:255/6000 train_loss:5.3182 train_time:841660ms step_avg:3435.35ms
+step:256/6000 train_loss:5.2744 train_time:845082ms step_avg:3435.29ms
+step:257/6000 train_loss:5.2935 train_time:848504ms step_avg:3435.24ms
+step:258/6000 train_loss:5.1391 train_time:851929ms step_avg:3435.20ms
+step:259/6000 train_loss:5.3879 train_time:855355ms step_avg:3435.16ms
+step:260/6000 train_loss:5.2551 train_time:858784ms step_avg:3435.14ms
+step:261/6000 train_loss:5.4110 train_time:862210ms step_avg:3435.10ms
+step:262/6000 train_loss:5.3616 train_time:865637ms step_avg:3435.07ms
+step:263/6000 train_loss:5.3344 train_time:869062ms step_avg:3435.03ms
+step:264/6000 train_loss:5.1001 train_time:872486ms step_avg:3434.99ms
+step:265/6000 train_loss:5.2383 train_time:875905ms step_avg:3434.92ms
+step:266/6000 train_loss:5.4192 train_time:879318ms step_avg:3434.84ms
+step:267/6000 train_loss:5.4532 train_time:882726ms step_avg:3434.73ms
+step:268/6000 train_loss:6.9081 train_time:886133ms step_avg:3434.62ms
+step:269/6000 train_loss:5.1305 train_time:889540ms step_avg:3434.52ms
+step:270/6000 train_loss:5.2639 train_time:892947ms step_avg:3434.41ms
+step:271/6000 train_loss:5.3229 train_time:896352ms step_avg:3434.30ms
+step:272/6000 train_loss:5.2331 train_time:899757ms step_avg:3434.19ms
+step:273/6000 train_loss:5.4332 train_time:903162ms step_avg:3434.08ms
+step:274/6000 train_loss:5.3627 train_time:906566ms step_avg:3433.96ms
+step:275/6000 train_loss:5.1428 train_time:909974ms step_avg:3433.86ms
+step:276/6000 train_loss:5.3207 train_time:913382ms step_avg:3433.77ms
+step:277/6000 train_loss:4.9842 train_time:916788ms step_avg:3433.66ms
+step:278/6000 train_loss:5.1754 train_time:920196ms step_avg:3433.57ms
+step:279/6000 train_loss:5.2977 train_time:923605ms step_avg:3433.47ms
+step:280/6000 train_loss:5.2565 train_time:927013ms step_avg:3433.38ms
+step:281/6000 train_loss:5.3619 train_time:930419ms step_avg:3433.28ms
+step:282/6000 train_loss:5.1270 train_time:933826ms step_avg:3433.18ms
+step:283/6000 train_loss:5.1333 train_time:937234ms step_avg:3433.09ms
+step:284/6000 train_loss:4.9990 train_time:940642ms step_avg:3433.00ms
+step:285/6000 train_loss:5.1462 train_time:944052ms step_avg:3432.92ms
+step:286/6000 train_loss:5.1908 train_time:947460ms step_avg:3432.83ms
+step:287/6000 train_loss:5.1320 train_time:950870ms step_avg:3432.74ms
+step:288/6000 train_loss:5.0049 train_time:954278ms step_avg:3432.65ms
+step:289/6000 train_loss:5.1106 train_time:957685ms step_avg:3432.56ms
+step:290/6000 train_loss:5.1938 train_time:961094ms step_avg:3432.48ms
+step:291/6000 train_loss:5.2408 train_time:964502ms step_avg:3432.39ms
+step:292/6000 train_loss:5.1533 train_time:967912ms step_avg:3432.31ms
+step:293/6000 train_loss:5.3285 train_time:971320ms step_avg:3432.23ms
+step:294/6000 train_loss:5.1832 train_time:974732ms step_avg:3432.15ms
+step:295/6000 train_loss:5.4237 train_time:978141ms step_avg:3432.07ms
+step:296/6000 train_loss:5.1898 train_time:981550ms step_avg:3431.99ms
+step:297/6000 train_loss:5.4226 train_time:984962ms step_avg:3431.92ms
+step:298/6000 train_loss:5.1682 train_time:988372ms step_avg:3431.85ms
+step:299/6000 train_loss:5.5279 train_time:991780ms step_avg:3431.76ms
+step:300/6000 train_loss:5.0578 train_time:995193ms step_avg:3431.70ms
+step:301/6000 train_loss:5.0428 train_time:998602ms step_avg:3431.62ms
+step:302/6000 train_loss:5.0813 train_time:1002013ms step_avg:3431.55ms
+step:303/6000 train_loss:4.9587 train_time:1005424ms step_avg:3431.48ms
+step:304/6000 train_loss:5.3799 train_time:1008832ms step_avg:3431.40ms
+step:305/6000 train_loss:4.8587 train_time:1015284ms step_avg:3441.64ms
+step:306/6000 train_loss:5.0054 train_time:1018692ms step_avg:3441.53ms
+step:307/6000 train_loss:5.0133 train_time:1022097ms step_avg:3441.40ms
+step:308/6000 train_loss:5.2828 train_time:1025507ms step_avg:3441.30ms
+step:309/6000 train_loss:5.0624 train_time:1028912ms step_avg:3441.18ms
+step:310/6000 train_loss:5.0572 train_time:1032319ms step_avg:3441.06ms
+step:311/6000 train_loss:4.9191 train_time:1035721ms step_avg:3440.93ms
+step:312/6000 train_loss:5.0762 train_time:1039125ms step_avg:3440.81ms
+step:313/6000 train_loss:5.0400 train_time:1042526ms step_avg:3440.68ms
+step:314/6000 train_loss:4.8921 train_time:1045925ms step_avg:3440.54ms
+step:315/6000 train_loss:4.8536 train_time:1049322ms step_avg:3440.40ms
+step:316/6000 train_loss:5.1940 train_time:1052715ms step_avg:3440.25ms
+step:317/6000 train_loss:5.0798 train_time:1056110ms step_avg:3440.10ms
+step:318/6000 train_loss:5.1254 train_time:1059503ms step_avg:3439.94ms
+step:319/6000 train_loss:4.9326 train_time:1062897ms step_avg:3439.80ms
+step:320/6000 train_loss:4.9668 train_time:1066385ms step_avg:3439.95ms
+step:321/6000 train_loss:4.9541 train_time:1069778ms step_avg:3439.80ms
+step:322/6000 train_loss:4.9330 train_time:1073172ms step_avg:3439.65ms
+step:323/6000 train_loss:5.1838 train_time:1076565ms step_avg:3439.50ms
+step:324/6000 train_loss:4.9301 train_time:1079956ms step_avg:3439.35ms
+step:325/6000 train_loss:5.0161 train_time:1083349ms step_avg:3439.20ms
+step:326/6000 train_loss:5.3797 train_time:1086741ms step_avg:3439.05ms
+step:327/6000 train_loss:4.9991 train_time:1090132ms step_avg:3438.90ms
+step:328/6000 train_loss:5.4944 train_time:1093530ms step_avg:3438.77ms
+step:329/6000 train_loss:4.8390 train_time:1096924ms step_avg:3438.63ms
+step:330/6000 train_loss:4.9219 train_time:1100319ms step_avg:3438.50ms
+step:331/6000 train_loss:5.1130 train_time:1103712ms step_avg:3438.36ms
+step:332/6000 train_loss:5.0294 train_time:1107103ms step_avg:3438.21ms
+step:333/6000 train_loss:4.9084 train_time:1110498ms step_avg:3438.08ms
+step:334/6000 train_loss:5.0865 train_time:1113893ms step_avg:3437.94ms
+step:335/6000 train_loss:4.7078 train_time:1117285ms step_avg:3437.80ms
+step:336/6000 train_loss:4.9595 train_time:1120681ms step_avg:3437.67ms
+step:337/6000 train_loss:5.0856 train_time:1124075ms step_avg:3437.54ms
+step:338/6000 train_loss:4.9088 train_time:1127727ms step_avg:3438.19ms
+step:339/6000 train_loss:4.7798 train_time:1131125ms step_avg:3438.07ms
+step:340/6000 train_loss:4.8553 train_time:1134525ms step_avg:3437.96ms
+step:341/6000 train_loss:5.0935 train_time:1137921ms step_avg:3437.83ms
+step:342/6000 train_loss:4.9783 train_time:1141319ms step_avg:3437.71ms
+step:343/6000 train_loss:5.4003 train_time:1144720ms step_avg:3437.60ms
+step:344/6000 train_loss:4.8966 train_time:1148118ms step_avg:3437.48ms
+step:345/6000 train_loss:4.8369 train_time:1151516ms step_avg:3437.36ms
+step:346/6000 train_loss:5.4137 train_time:1154916ms step_avg:3437.25ms
+step:347/6000 train_loss:5.0305 train_time:1158313ms step_avg:3437.13ms
+step:348/6000 train_loss:4.7383 train_time:1161713ms step_avg:3437.02ms
+step:349/6000 train_loss:4.9226 train_time:1165111ms step_avg:3436.91ms
+step:350/6000 train_loss:4.9266 train_time:1168509ms step_avg:3436.79ms
+step:351/6000 train_loss:4.8785 train_time:1171910ms step_avg:3436.69ms
+step:352/6000 train_loss:4.7483 train_time:1175309ms step_avg:3436.58ms
+step:353/6000 train_loss:4.8046 train_time:1178708ms step_avg:3436.47ms
+step:354/6000 train_loss:4.8389 train_time:1182109ms step_avg:3436.36ms
+step:355/6000 train_loss:4.8083 train_time:1185509ms step_avg:3436.26ms
+step:356/6000 train_loss:5.0028 train_time:1188908ms step_avg:3436.15ms
+step:357/6000 train_loss:4.7255 train_time:1192311ms step_avg:3436.05ms
+step:358/6000 train_loss:4.4875 train_time:1195713ms step_avg:3435.96ms
+step:359/6000 train_loss:5.3345 train_time:1199114ms step_avg:3435.86ms
+step:360/6000 train_loss:4.8856 train_time:1202518ms step_avg:3435.76ms
+step:361/6000 train_loss:4.7809 train_time:1205918ms step_avg:3435.66ms
+step:362/6000 train_loss:4.8236 train_time:1209320ms step_avg:3435.57ms
+step:363/6000 train_loss:4.8012 train_time:1212722ms step_avg:3435.47ms
+step:364/6000 train_loss:4.7757 train_time:1216124ms step_avg:3435.38ms
+step:365/6000 train_loss:4.8710 train_time:1219528ms step_avg:3435.29ms
+step:366/6000 train_loss:4.9393 train_time:1222929ms step_avg:3435.19ms
+step:367/6000 train_loss:4.6886 train_time:1226332ms step_avg:3435.10ms
+step:368/6000 train_loss:5.2882 train_time:1229733ms step_avg:3435.01ms
+step:369/6000 train_loss:4.8391 train_time:1233134ms step_avg:3434.91ms
+step:370/6000 train_loss:4.6043 train_time:1236537ms step_avg:3434.83ms
+step:371/6000 train_loss:4.7194 train_time:1239937ms step_avg:3434.73ms
+step:372/6000 train_loss:4.8174 train_time:1243338ms step_avg:3434.63ms
+step:373/6000 train_loss:4.7960 train_time:1246740ms step_avg:3434.55ms
+step:374/6000 train_loss:4.8462 train_time:1250142ms step_avg:3434.46ms
+step:375/6000 train_loss:4.7751 train_time:1253542ms step_avg:3434.36ms
+step:375/6000 val_loss:4.7849 train_time:1253642ms step_avg:3434.64ms
+step:376/6000 train_loss:4.6820 train_time:1256946ms step_avg:3434.28ms
+step:377/6000 train_loss:4.8238 train_time:1260351ms step_avg:3434.20ms
+step:378/6000 train_loss:4.6150 train_time:1263756ms step_avg:3434.12ms
+step:379/6000 train_loss:4.7386 train_time:1267158ms step_avg:3434.03ms
+step:380/6000 train_loss:4.5651 train_time:1270563ms step_avg:3433.96ms
+step:381/6000 train_loss:4.8766 train_time:1273967ms step_avg:3433.87ms
+step:382/6000 train_loss:4.8782 train_time:1277370ms step_avg:3433.79ms
+step:383/6000 train_loss:4.8772 train_time:1280772ms step_avg:3433.71ms
+step:384/6000 train_loss:4.9635 train_time:1284175ms step_avg:3433.62ms
+step:385/6000 train_loss:4.7697 train_time:1287580ms step_avg:3433.55ms
+step:386/6000 train_loss:4.6847 train_time:1290981ms step_avg:3433.46ms
+step:387/6000 train_loss:4.8016 train_time:1294383ms step_avg:3433.38ms
+step:388/6000 train_loss:5.0025 train_time:1297784ms step_avg:3433.29ms
+step:389/6000 train_loss:4.7109 train_time:1301187ms step_avg:3433.21ms
+step:390/6000 train_loss:4.9732 train_time:1304589ms step_avg:3433.13ms
+step:391/6000 train_loss:4.9900 train_time:1307990ms step_avg:3433.04ms
+step:392/6000 train_loss:4.7626 train_time:1311391ms step_avg:3432.96ms
+step:393/6000 train_loss:4.8017 train_time:1314793ms step_avg:3432.88ms
+step:394/6000 train_loss:4.7786 train_time:1318195ms step_avg:3432.80ms
+step:395/6000 train_loss:4.8375 train_time:1321598ms step_avg:3432.72ms
+step:396/6000 train_loss:4.7687 train_time:1324999ms step_avg:3432.64ms
+step:397/6000 train_loss:5.4127 train_time:1328401ms step_avg:3432.56ms
+step:398/6000 train_loss:4.6990 train_time:1331803ms step_avg:3432.48ms
+step:399/6000 train_loss:4.5973 train_time:1335207ms step_avg:3432.41ms
+step:400/6000 train_loss:4.7991 train_time:1338611ms step_avg:3432.34ms
+step:401/6000 train_loss:4.7391 train_time:1342014ms step_avg:3432.26ms
+step:402/6000 train_loss:4.7799 train_time:1345418ms step_avg:3432.19ms
+step:403/6000 train_loss:5.2799 train_time:1348820ms step_avg:3432.11ms
+step:404/6000 train_loss:4.6204 train_time:1352224ms step_avg:3432.04ms
+step:405/6000 train_loss:4.8722 train_time:1355627ms step_avg:3431.97ms
+step:406/6000 train_loss:4.6097 train_time:1359028ms step_avg:3431.89ms
+step:407/6000 train_loss:4.6709 train_time:1365494ms step_avg:3439.53ms
+step:408/6000 train_loss:4.8273 train_time:1368897ms step_avg:3439.44ms
+step:409/6000 train_loss:4.9456 train_time:1372300ms step_avg:3439.35ms
+step:410/6000 train_loss:4.6677 train_time:1375708ms step_avg:3439.27ms
+step:411/6000 train_loss:4.6155 train_time:1379117ms step_avg:3439.19ms
+step:412/6000 train_loss:4.9266 train_time:1382528ms step_avg:3439.12ms
+step:413/6000 train_loss:4.6171 train_time:1385938ms step_avg:3439.05ms
+step:414/6000 train_loss:4.7515 train_time:1389349ms step_avg:3438.98ms
+step:415/6000 train_loss:4.4478 train_time:1392762ms step_avg:3438.92ms
+step:416/6000 train_loss:4.7730 train_time:1396174ms step_avg:3438.85ms
+step:417/6000 train_loss:4.7134 train_time:1399585ms step_avg:3438.78ms
+step:418/6000 train_loss:4.6088 train_time:1402992ms step_avg:3438.71ms
+step:419/6000 train_loss:4.4995 train_time:1406398ms step_avg:3438.63ms
+step:420/6000 train_loss:4.1972 train_time:1409803ms step_avg:3438.54ms
+step:421/6000 train_loss:4.6705 train_time:1413205ms step_avg:3438.46ms
+step:422/6000 train_loss:4.6486 train_time:1416608ms step_avg:3438.37ms
+step:423/6000 train_loss:4.5639 train_time:1420008ms step_avg:3438.28ms
+step:424/6000 train_loss:4.6561 train_time:1423410ms step_avg:3438.19ms
+step:425/6000 train_loss:4.4786 train_time:1426809ms step_avg:3438.09ms
+step:426/6000 train_loss:4.6403 train_time:1430213ms step_avg:3438.01ms
+step:427/6000 train_loss:4.7093 train_time:1433615ms step_avg:3437.92ms
+step:428/6000 train_loss:4.6496 train_time:1437016ms step_avg:3437.84ms
+step:429/6000 train_loss:4.6269 train_time:1440416ms step_avg:3437.75ms

sharpness/logs_qkvo_grid_fix/mode_0/mode_0_param_qkvo_adam_lr_0.001_muon_lr_0.01_seed_42/config.json

@@ -20,6 +20,6 @@
         "val_loss_every": 400,
         "save_checkpoint": false
     },
-    "run_uuid_for_log": "da4207c8-70c2-4886-bf2f-a09da8f9b132",
+    "run_uuid_for_log": "b8831a4c-12f0-4a61-ae8b-4f32def89ede",
     "script_code_logged_at_start": true
 }

sharpness/logs_qkvo_grid_fix/mode_0/mode_0_param_qkvo_adam_lr_0.001_muon_lr_0.01_seed_43/config.json

@@ -0,0 +1,25 @@
+{
+    "cli_args": {
+        "unet": false,
+        "seed": 43,
+        "optimizer_mode": 0,
+        "model_parameterization": "qkvo",
+        "adam_lr": 0.001,
+        "muon_lr": 0.01,
+        "base_dir": "logs_qkvo_grid_fix/mode_0"
+    },
+    "hyperparameters": {
+        "train_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "val_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "val_tokens": 491520,
+        "train_seq_len": 3072,
+        "val_seq_len": 16384,
+        "num_iterations": 10000,
+        "cooldown_frac": 0.4,
+        "vocab_size": 50257,
+        "val_loss_every": 400,
+        "save_checkpoint": false
+    },
+    "run_uuid_for_log": "13322988-b0ae-4e6e-81c8-a19f29460fb7",
+    "script_code_logged_at_start": true
+}

sharpness/logs_qkvo_grid_fix/mode_0/mode_0_param_qkvo_adam_lr_0.001_muon_lr_0.01_seed_45/config.json

@@ -0,0 +1,25 @@
+{
+    "cli_args": {
+        "unet": false,
+        "seed": 45,
+        "optimizer_mode": 0,
+        "model_parameterization": "qkvo",
+        "adam_lr": 0.001,
+        "muon_lr": 0.01,
+        "base_dir": "logs_qkvo_grid_fix/mode_0"
+    },
+    "hyperparameters": {
+        "train_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "val_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "val_tokens": 491520,
+        "train_seq_len": 3072,
+        "val_seq_len": 16384,
+        "num_iterations": 10000,
+        "cooldown_frac": 0.4,
+        "vocab_size": 50257,
+        "val_loss_every": 400,
+        "save_checkpoint": false
+    },
+    "run_uuid_for_log": "f3c2cbd7-4390-4795-8459-adb334970d83",
+    "script_code_logged_at_start": true
+}

sharpness/logs_qkvo_grid_fix/mode_0/mode_0_param_qkvo_adam_lr_0.001_muon_lr_0.01_seed_46/config.json

@@ -0,0 +1,25 @@
+{
+    "cli_args": {
+        "unet": false,
+        "seed": 46,
+        "optimizer_mode": 0,
+        "model_parameterization": "qkvo",
+        "adam_lr": 0.001,
+        "muon_lr": 0.01,
+        "base_dir": "logs_qkvo_grid_fix/mode_0"
+    },
+    "hyperparameters": {
+        "train_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "val_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "val_tokens": 491520,
+        "train_seq_len": 3072,
+        "val_seq_len": 16384,
+        "num_iterations": 10000,
+        "cooldown_frac": 0.4,
+        "vocab_size": 50257,
+        "val_loss_every": 400,
+        "save_checkpoint": false
+    },
+    "run_uuid_for_log": "8c5ef51b-70e7-40a7-8fcb-ab0c5dbcbca6",
+    "script_code_logged_at_start": true
+}

sharpness/logs_qkvo_grid_fix/mode_0/mode_0_param_qkvo_adam_lr_0.001_muon_lr_0.02_seed_42/config.json

@@ -0,0 +1,25 @@
+{
+    "cli_args": {
+        "unet": false,
+        "seed": 42,
+        "optimizer_mode": 0,
+        "model_parameterization": "qkvo",
+        "adam_lr": 0.001,
+        "muon_lr": 0.02,
+        "base_dir": "logs_qkvo_grid_fix/mode_0"
+    },
+    "hyperparameters": {
+        "train_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "val_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "val_tokens": 491520,
+        "train_seq_len": 3072,
+        "val_seq_len": 16384,
+        "num_iterations": 10000,
+        "cooldown_frac": 0.4,
+        "vocab_size": 50257,
+        "val_loss_every": 400,
+        "save_checkpoint": false
+    },
+    "run_uuid_for_log": "535acb30-1e05-43d0-8a6e-f7fdd7e93523",
+    "script_code_logged_at_start": true
+}

sharpness/logs_qkvo_grid_fix/mode_0/mode_0_param_qkvo_adam_lr_0.001_muon_lr_0.02_seed_43/config.json

@@ -0,0 +1,25 @@
+{
+    "cli_args": {
+        "unet": false,
+        "seed": 43,
+        "optimizer_mode": 0,
+        "model_parameterization": "qkvo",
+        "adam_lr": 0.001,
+        "muon_lr": 0.02,
+        "base_dir": "logs_qkvo_grid_fix/mode_0"
+    },
+    "hyperparameters": {
+        "train_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "val_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "val_tokens": 491520,
+        "train_seq_len": 3072,
+        "val_seq_len": 16384,
+        "num_iterations": 10000,
+        "cooldown_frac": 0.4,
+        "vocab_size": 50257,
+        "val_loss_every": 400,
+        "save_checkpoint": false
+    },
+    "run_uuid_for_log": "51a5fccc-1092-4e8f-b775-94e3f7f8f701",
+    "script_code_logged_at_start": true
+}

sharpness/logs_qkvo_grid_fix/mode_0/mode_0_param_qkvo_adam_lr_0.001_muon_lr_0.02_seed_45/config.json

@@ -0,0 +1,25 @@
+{
+    "cli_args": {
+        "unet": false,
+        "seed": 45,
+        "optimizer_mode": 0,
+        "model_parameterization": "qkvo",
+        "adam_lr": 0.001,
+        "muon_lr": 0.02,
+        "base_dir": "logs_qkvo_grid_fix/mode_0"
+    },
+    "hyperparameters": {
+        "train_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "val_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "val_tokens": 491520,
+        "train_seq_len": 3072,
+        "val_seq_len": 16384,
+        "num_iterations": 10000,
+        "cooldown_frac": 0.4,
+        "vocab_size": 50257,
+        "val_loss_every": 400,
+        "save_checkpoint": false
+    },
+    "run_uuid_for_log": "6b55014d-0163-4948-acef-1bd7c6fac142",
+    "script_code_logged_at_start": true
+}

sharpness/logs_qkvo_grid_fix/mode_0/mode_0_param_qkvo_adam_lr_0.001_muon_lr_0.02_seed_46/config.json

@@ -0,0 +1,25 @@
+{
+    "cli_args": {
+        "unet": false,
+        "seed": 46,
+        "optimizer_mode": 0,
+        "model_parameterization": "qkvo",
+        "adam_lr": 0.001,
+        "muon_lr": 0.02,
+        "base_dir": "logs_qkvo_grid_fix/mode_0"
+    },
+    "hyperparameters": {
+        "train_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "val_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "val_tokens": 491520,
+        "train_seq_len": 3072,
+        "val_seq_len": 16384,
+        "num_iterations": 10000,
+        "cooldown_frac": 0.4,
+        "vocab_size": 50257,
+        "val_loss_every": 400,
+        "save_checkpoint": false
+    },
+    "run_uuid_for_log": "14b69eae-8a7c-4dbc-8bac-b2aab72b48a7",
+    "script_code_logged_at_start": true
+}

sharpness/logs_qkvo_grid_fix/mode_0/mode_0_param_qkvo_adam_lr_0.001_muon_lr_0.05_seed_42/config.json

@@ -0,0 +1,25 @@
+{
+    "cli_args": {
+        "unet": false,
+        "seed": 42,
+        "optimizer_mode": 0,
+        "model_parameterization": "qkvo",
+        "adam_lr": 0.001,
+        "muon_lr": 0.05,
+        "base_dir": "logs_qkvo_grid_fix/mode_0"
+    },
+    "hyperparameters": {
+        "train_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "val_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "val_tokens": 491520,
+        "train_seq_len": 3072,
+        "val_seq_len": 16384,
+        "num_iterations": 10000,
+        "cooldown_frac": 0.4,
+        "vocab_size": 50257,
+        "val_loss_every": 400,
+        "save_checkpoint": false
+    },
+    "run_uuid_for_log": "ff0f11cb-7fdd-4119-a532-b5b040bdd0b2",
+    "script_code_logged_at_start": true
+}

sharpness/logs_qkvo_grid_fix/mode_0/mode_0_param_qkvo_adam_lr_0.001_muon_lr_0.05_seed_43/config.json

@@ -0,0 +1,25 @@
+{
+    "cli_args": {
+        "unet": false,
+        "seed": 43,
+        "optimizer_mode": 0,
+        "model_parameterization": "qkvo",
+        "adam_lr": 0.001,
+        "muon_lr": 0.05,
+        "base_dir": "logs_qkvo_grid_fix/mode_0"
+    },
+    "hyperparameters": {
+        "train_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "val_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "val_tokens": 491520,
+        "train_seq_len": 3072,
+        "val_seq_len": 16384,
+        "num_iterations": 10000,
+        "cooldown_frac": 0.4,
+        "vocab_size": 50257,
+        "val_loss_every": 400,
+        "save_checkpoint": false
+    },
+    "run_uuid_for_log": "74fa81b7-209f-4653-9e84-0c69fb6fc666",
+    "script_code_logged_at_start": true
+}

sharpness/logs_qkvo_grid_fix/mode_0/mode_0_param_qkvo_adam_lr_0.001_muon_lr_0.05_seed_45/config.json

@@ -0,0 +1,25 @@
+{
+    "cli_args": {
+        "unet": false,
+        "seed": 45,
+        "optimizer_mode": 0,
+        "model_parameterization": "qkvo",
+        "adam_lr": 0.001,
+        "muon_lr": 0.05,
+        "base_dir": "logs_qkvo_grid_fix/mode_0"
+    },
+    "hyperparameters": {
+        "train_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "val_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "val_tokens": 491520,
+        "train_seq_len": 3072,
+        "val_seq_len": 16384,
+        "num_iterations": 10000,
+        "cooldown_frac": 0.4,
+        "vocab_size": 50257,
+        "val_loss_every": 400,
+        "save_checkpoint": false
+    },
+    "run_uuid_for_log": "15456da8-2f1d-4ae5-965d-2481be0b71f3",
+    "script_code_logged_at_start": true
+}

sharpness/logs_qkvo_grid_fix/mode_0/mode_0_param_qkvo_adam_lr_0.001_muon_lr_0.05_seed_46/config.json

@@ -0,0 +1,25 @@
+{
+    "cli_args": {
+        "unet": false,
+        "seed": 46,
+        "optimizer_mode": 0,
+        "model_parameterization": "qkvo",
+        "adam_lr": 0.001,
+        "muon_lr": 0.05,
+        "base_dir": "logs_qkvo_grid_fix/mode_0"
+    },
+    "hyperparameters": {
+        "train_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "val_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "val_tokens": 491520,
+        "train_seq_len": 3072,
+        "val_seq_len": 16384,
+        "num_iterations": 10000,
+        "cooldown_frac": 0.4,
+        "vocab_size": 50257,
+        "val_loss_every": 400,
+        "save_checkpoint": false
+    },
+    "run_uuid_for_log": "a54cc0c5-fdb0-4fe6-a467-7df0739500c8",
+    "script_code_logged_at_start": true
+}

sharpness/logs_qkvo_grid_fix/mode_0/mode_0_param_qkvo_adam_lr_0.001_muon_lr_0.1_seed_42/config.json

@@ -20,6 +20,6 @@
         "val_loss_every": 400,
         "save_checkpoint": false
     },
-    "run_uuid_for_log": "a34e4e8b-a0cd-4255-8913-e1f97f4711b0",
+    "run_uuid_for_log": "fab5639f-ba5b-4d9f-a38c-69aa47967c84",
     "script_code_logged_at_start": true
 }

sharpness/logs_qkvo_grid_fix/mode_0/mode_0_param_qkvo_adam_lr_0.001_muon_lr_0.1_seed_43/config.json

@@ -0,0 +1,25 @@
+{
+    "cli_args": {
+        "unet": false,
+        "seed": 43,
+        "optimizer_mode": 0,
+        "model_parameterization": "qkvo",
+        "adam_lr": 0.001,
+        "muon_lr": 0.1,
+        "base_dir": "logs_qkvo_grid_fix/mode_0"
+    },
+    "hyperparameters": {
+        "train_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "val_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "val_tokens": 491520,
+        "train_seq_len": 3072,
+        "val_seq_len": 16384,
+        "num_iterations": 10000,
+        "cooldown_frac": 0.4,
+        "vocab_size": 50257,
+        "val_loss_every": 400,
+        "save_checkpoint": false
+    },
+    "run_uuid_for_log": "c98c52eb-2b46-4f88-badc-890fc51959c2",
+    "script_code_logged_at_start": true
+}

sharpness/logs_qkvo_grid_fix/mode_0/mode_0_param_qkvo_adam_lr_0.001_muon_lr_0.1_seed_45/config.json

@@ -0,0 +1,25 @@
+{
+    "cli_args": {
+        "unet": false,
+        "seed": 45,
+        "optimizer_mode": 0,
+        "model_parameterization": "qkvo",
+        "adam_lr": 0.001,
+        "muon_lr": 0.1,
+        "base_dir": "logs_qkvo_grid_fix/mode_0"
+    },
+    "hyperparameters": {
+        "train_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "val_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "val_tokens": 491520,
+        "train_seq_len": 3072,
+        "val_seq_len": 16384,
+        "num_iterations": 10000,
+        "cooldown_frac": 0.4,
+        "vocab_size": 50257,
+        "val_loss_every": 400,
+        "save_checkpoint": false
+    },
+    "run_uuid_for_log": "ef7bf1f7-de55-4a4b-a0ab-27702430dc8d",
+    "script_code_logged_at_start": true
+}

sharpness/logs_qkvo_grid_fix/mode_0/mode_0_param_qkvo_adam_lr_0.001_muon_lr_0.1_seed_46/config.json

@@ -0,0 +1,25 @@
+{
+    "cli_args": {
+        "unet": false,
+        "seed": 46,
+        "optimizer_mode": 0,
+        "model_parameterization": "qkvo",
+        "adam_lr": 0.001,
+        "muon_lr": 0.1,
+        "base_dir": "logs_qkvo_grid_fix/mode_0"
+    },
+    "hyperparameters": {
+        "train_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "val_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "val_tokens": 491520,
+        "train_seq_len": 3072,
+        "val_seq_len": 16384,
+        "num_iterations": 10000,
+        "cooldown_frac": 0.4,
+        "vocab_size": 50257,
+        "val_loss_every": 400,
+        "save_checkpoint": false
+    },
+    "run_uuid_for_log": "7b0e9962-3dc8-4d4b-9148-5ebf758f1505",
+    "script_code_logged_at_start": true
+}

sharpness/logs_qkvo_grid_fix/mode_0/mode_0_param_qkvo_adam_lr_0.002_muon_lr_0.01_seed_42/config.json

@@ -20,6 +20,6 @@
         "val_loss_every": 400,
         "save_checkpoint": false
     },
-    "run_uuid_for_log": "4c66d719-6cf5-4687-958d-d269ff6045a1",
+    "run_uuid_for_log": "980127d3-ed72-4576-88df-d5d63142f40f",
     "script_code_logged_at_start": true
 }

sharpness/logs_qkvo_grid_fix/mode_0/mode_0_param_qkvo_adam_lr_0.002_muon_lr_0.01_seed_43/config.json

@@ -0,0 +1,25 @@
+{
+    "cli_args": {
+        "unet": false,
+        "seed": 43,
+        "optimizer_mode": 0,
+        "model_parameterization": "qkvo",
+        "adam_lr": 0.002,
+        "muon_lr": 0.01,
+        "base_dir": "logs_qkvo_grid_fix/mode_0"
+    },
+    "hyperparameters": {
+        "train_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "val_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "val_tokens": 491520,
+        "train_seq_len": 3072,
+        "val_seq_len": 16384,
+        "num_iterations": 10000,
+        "cooldown_frac": 0.4,
+        "vocab_size": 50257,
+        "val_loss_every": 400,
+        "save_checkpoint": false
+    },
+    "run_uuid_for_log": "6f3da0f7-185f-42a1-a36f-b3e49dc3211c",
+    "script_code_logged_at_start": true
+}

sharpness/logs_qkvo_grid_fix/mode_0/mode_0_param_qkvo_adam_lr_0.002_muon_lr_0.01_seed_45/config.json

@@ -0,0 +1,25 @@
+{
+    "cli_args": {
+        "unet": false,
+        "seed": 45,
+        "optimizer_mode": 0,
+        "model_parameterization": "qkvo",
+        "adam_lr": 0.002,
+        "muon_lr": 0.01,
+        "base_dir": "logs_qkvo_grid_fix/mode_0"
+    },
+    "hyperparameters": {
+        "train_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "val_files": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "val_tokens": 491520,
+        "train_seq_len": 3072,
+        "val_seq_len": 16384,
+        "num_iterations": 10000,
+        "cooldown_frac": 0.4,
+        "vocab_size": 50257,
+        "val_loss_every": 400,
+        "save_checkpoint": false
+    },
+    "run_uuid_for_log": "a2a2964f-b4b1-4192-b944-13a0b2cbcc4f",
+    "script_code_logged_at_start": true
+}