update

logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm/opt_adam_alr_0.0001_mlr_0.01_seed_42/config.json

@@ -0,0 +1,41 @@
+{
+    "cli_args": {
+        "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",
+        "output_dir": "/home/aiops/zhangfz/MUON_sharpness/logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm",
+        "model": "d12",
+        "batch_size": 4,
+        "sequence_length": 1024,
+        "total_batch_size": 524288,
+        "num_iterations": 10000,
+        "inference_only": 0,
+        "adam_lr": 0.0001,
+        "warmup_iters": 1500,
+        "lr_decay_frac": 0.0,
+        "weight_decay": 0.0,
+        "grad_clip": 100000.0,
+        "val_loss_every": 250,
+        "val_max_steps": 20,
+        "sample_every": 0,
+        "overfit_single_batch": 0,
+        "shuffle_files": true,
+        "tensorcores": 1,
+        "device": "",
+        "compile": 1,
+        "flash": 1,
+        "dtype": "bfloat16",
+        "zero_stage": 1,
+        "optimizer": "adam",
+        "muon_lr": 0.01,
+        "muon_momentum": 0.95,
+        "muon_weight_decay": 0.0,
+        "muon_ns_steps": 5,
+        "muon_nesterov": false,
+        "write_tensors": 0,
+        "seed": 42,
+        "analyze_sharpness": false,
+        "sharpness_analysis_interval": 500
+    },
+    "run_uuid": "50546d87-1827-453c-b739-8394ec9b4cf5",
+    "script_code_logged_at_start": true
+}

logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm/opt_adam_alr_0.0001_mlr_0.01_seed_43/config.json

@@ -0,0 +1,41 @@
+{
+    "cli_args": {
+        "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",
+        "output_dir": "/home/aiops/zhangfz/MUON_sharpness/logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm",
+        "model": "d12",
+        "batch_size": 4,
+        "sequence_length": 1024,
+        "total_batch_size": 524288,
+        "num_iterations": 10000,
+        "inference_only": 0,
+        "adam_lr": 0.0001,
+        "warmup_iters": 1500,
+        "lr_decay_frac": 0.0,
+        "weight_decay": 0.0,
+        "grad_clip": 100000.0,
+        "val_loss_every": 250,
+        "val_max_steps": 20,
+        "sample_every": 0,
+        "overfit_single_batch": 0,
+        "shuffle_files": true,
+        "tensorcores": 1,
+        "device": "",
+        "compile": 1,
+        "flash": 1,
+        "dtype": "bfloat16",
+        "zero_stage": 1,
+        "optimizer": "adam",
+        "muon_lr": 0.01,
+        "muon_momentum": 0.95,
+        "muon_weight_decay": 0.0,
+        "muon_ns_steps": 5,
+        "muon_nesterov": false,
+        "write_tensors": 0,
+        "seed": 43,
+        "analyze_sharpness": false,
+        "sharpness_analysis_interval": 500
+    },
+    "run_uuid": "5ffd855e-623a-438c-9e89-8ba2b9eb6f4c",
+    "script_code_logged_at_start": true
+}

logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm/opt_adam_alr_0.0001_mlr_0.01_seed_44/config.json

@@ -0,0 +1,41 @@
+{
+    "cli_args": {
+        "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",
+        "output_dir": "/home/aiops/zhangfz/MUON_sharpness/logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm",
+        "model": "d12",
+        "batch_size": 4,
+        "sequence_length": 1024,
+        "total_batch_size": 524288,
+        "num_iterations": 10000,
+        "inference_only": 0,
+        "adam_lr": 0.0001,
+        "warmup_iters": 1500,
+        "lr_decay_frac": 0.0,
+        "weight_decay": 0.0,
+        "grad_clip": 100000.0,
+        "val_loss_every": 250,
+        "val_max_steps": 20,
+        "sample_every": 0,
+        "overfit_single_batch": 0,
+        "shuffle_files": true,
+        "tensorcores": 1,
+        "device": "",
+        "compile": 1,
+        "flash": 1,
+        "dtype": "bfloat16",
+        "zero_stage": 1,
+        "optimizer": "adam",
+        "muon_lr": 0.01,
+        "muon_momentum": 0.95,
+        "muon_weight_decay": 0.0,
+        "muon_ns_steps": 5,
+        "muon_nesterov": false,
+        "write_tensors": 0,
+        "seed": 44,
+        "analyze_sharpness": false,
+        "sharpness_analysis_interval": 500
+    },
+    "run_uuid": "159018cc-e918-44bf-b157-117db3870552",
+    "script_code_logged_at_start": true
+}

logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm/opt_adam_alr_0.0002_mlr_0.01_seed_42/config.json

@@ -0,0 +1,41 @@
+{
+    "cli_args": {
+        "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",
+        "output_dir": "/home/aiops/zhangfz/MUON_sharpness/logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm",
+        "model": "d12",
+        "batch_size": 4,
+        "sequence_length": 1024,
+        "total_batch_size": 524288,
+        "num_iterations": 10000,
+        "inference_only": 0,
+        "adam_lr": 0.0002,
+        "warmup_iters": 1500,
+        "lr_decay_frac": 0.0,
+        "weight_decay": 0.0,
+        "grad_clip": 100000.0,
+        "val_loss_every": 250,
+        "val_max_steps": 20,
+        "sample_every": 0,
+        "overfit_single_batch": 0,
+        "shuffle_files": true,
+        "tensorcores": 1,
+        "device": "",
+        "compile": 1,
+        "flash": 1,
+        "dtype": "bfloat16",
+        "zero_stage": 1,
+        "optimizer": "adam",
+        "muon_lr": 0.01,
+        "muon_momentum": 0.95,
+        "muon_weight_decay": 0.0,
+        "muon_ns_steps": 5,
+        "muon_nesterov": false,
+        "write_tensors": 0,
+        "seed": 42,
+        "analyze_sharpness": false,
+        "sharpness_analysis_interval": 500
+    },
+    "run_uuid": "f483da9a-f60a-4caa-8058-ef3f0eccf830",
+    "script_code_logged_at_start": true
+}

logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm/opt_adam_alr_0.0002_mlr_0.01_seed_42/training_log.txt

@@ -0,0 +1,1932 @@
+"""
+Reference code for GPT-2 training and inference with Sharpness Analysis.
+Will save the model weights into files, to be read from C as initialization.
+
+References:
+1) the official GPT-2 TensorFlow implementation released by OpenAI:
+https://github.com/openai/gpt-2/blob/master/src/model.py
+2) huggingface/transformers PyTorch implementation:
+https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt2/modeling_gpt2.py
+
+Example launches to only benchmark the speed of bfloat16 compiled GPU training:
+1 GPU:
+python train_gpt2.py --write_tensors=0 --num_iterations=50 --sequence_length=1024 --compile=1 --tensorcores=1 --dtype=bfloat16
+you can also turn on flash-attention by appending --flash=1
+4 GPU:
+torchrun --standalone --nproc_per_node=4 train_gpt2.py --write_tensors=0 --num_iterations=50 --sequence_length=1024 --compile=1 --tensorcores=1 --dtype=bfloat16
+"""
+import sys
+with open(sys.argv[0]) as f:
+    code = f.read() # read the code of this file ASAP, for logging
+
+import os
+import math
+import glob
+import struct
+import inspect
+from contextlib import nullcontext
+from dataclasses import dataclass
+import random
+
+import numpy as np
+import torch
+from torch import Tensor
+import torch.nn as nn
+from torch.nn import functional as F
+import torch._inductor.config as config
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.distributed import init_process_group, destroy_process_group
+from torch.distributed.optim import ZeroRedundancyOptimizer
+import torch.distributed as dist
+from torch.amp import autocast
+import copy
+import gc
+import uuid
+import json
+from pathlib import Path
+
+# Import Muon optimizer
+import sys
+sys.path.append("/home/aiops/zhangfz/MUON_sharpness/modded-nanogpt/optimizers")
+from MUON_fix import Muon
+
+# Import GPT model
+sys.path.append("/home/aiops/zhangfz/MUON_sharpness/modded-nanogpt/models")
+import  nano_GPT_qkvonorm_pure
+from nano_GPT_qkvonorm_pure import GPT, GPTConfig
+
+# Import debug utilities
+# from debug_utils import setup_debugpy
+
+# -----------------------------------------------------------------------------
+# 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,
+                 shuffle_files=False, random_seed=None):
+        self.process_rank = process_rank
+        self.num_processes = num_processes
+        self.B = B
+        self.T = T
+        self.shuffle_files = shuffle_files
+        self.random_seed = random_seed
+        self._rng = random.Random(random_seed) if shuffle_files and random_seed is not None else None
+
+        # 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}"
+        if self.shuffle_files:
+            self._shuffle_files()
+
+        # 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 += shard_ntok
+        self.ntok_total = ntok_total
+        print0(f"DataLoader: total number of tokens: {ntok_total:,} across {len(self.files)} files")
+
+        # kick things off
+        self.current_shard = None
+        self.reset()
+
+    def reset(self):
+        # we're being a bit clever here: if we already had shard 0 loaded,
+        # then don't do the work to reload it, just reset the pointer
+        if self.current_shard != 0:
+            self.current_shard = 0
+            self.tokens = _load_data_shard(self.files[self.current_shard])
+        self.current_position = self.process_rank * self.B * self.T
+
+    def advance(self): # advance to next data shard
+        next_shard = (self.current_shard + 1) % len(self.files)
+        if next_shard == 0 and self.shuffle_files:
+            self._shuffle_files()
+        self.current_shard = next_shard
+        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 the start pointer in current shard
+        self.current_position += B * T * self.num_processes
+        # if loading the next batch would be out of bounds advance the shard
+        if self.current_position + (B * T * self.num_processes + 1) > len(self.tokens):
+            self.advance()
+        return x, y
+
+    def _shuffle_files(self):
+        if self._rng is not None:
+            self._rng.shuffle(self.files)
+        else:
+            random.shuffle(self.files)
+
+# -----------------------------------------------------------------------------
+# Python -> C bridge utilities for saving params/grads/activations to .bin files
+
+def write_fp32(tensor, file):
+    t = tensor.detach().cpu().to(torch.float32)
+    b = t.numpy().tobytes()
+    file.write(b)
+
+def write_bf16(tensor, file):
+    t = tensor.detach().cpu().to(torch.bfloat16)
+    # numpy doesn't have bf16 datatype so we have to trick it
+    t = t.view(torch.int16) # trick: reinterpret as int16
+    b = t.numpy().tobytes()
+    file.write(b)
+
+def write_tensors(model_tensors, L, file, dtype):
+    # writes the GPT-2 model's weights to a binary file
+    assert dtype in {"float32", "bfloat16"}
+    write_fun = write_fp32 if dtype == "float32" else write_bf16
+    write_fun(model_tensors["transformer.wte.weight"], file) # (V, C)
+    write_fun(model_tensors["transformer.wpe.weight"], file) # (T, C)
+    for i in range(L): # (L, C)
+        write_fun(model_tensors[f"transformer.h.{i}.ln_1.weight"], file)
+    for i in range(L): # (L, C)
+        write_fun(model_tensors[f"transformer.h.{i}.ln_1.bias"], file)
+    for i in range(L): # (L, 3C, C)
+        write_fun(model_tensors[f"transformer.h.{i}.attn.c_attn.weight"], file)
+    for i in range(L): # (L, 3C)
+        write_fun(model_tensors[f"transformer.h.{i}.attn.c_attn.bias"], file)
+    for i in range(L): # (L, C, C)
+        write_fun(model_tensors[f"transformer.h.{i}.attn.c_proj.weight"], file)
+    for i in range(L): # (L, C)
+        write_fun(model_tensors[f"transformer.h.{i}.attn.c_proj.bias"], file)
+    for i in range(L): # (L, C)
+        write_fun(model_tensors[f"transformer.h.{i}.ln_2.weight"], file)
+    for i in range(L): # (L, C)
+        write_fun(model_tensors[f"transformer.h.{i}.ln_2.bias"], file)
+    for i in range(L): # (L, 4C, C)
+        write_fun(model_tensors[f"transformer.h.{i}.mlp.c_fc.weight"], file)
+    for i in range(L): # (L, 4C)
+        write_fun(model_tensors[f"transformer.h.{i}.mlp.c_fc.bias"], file)
+    for i in range(L): # (L, C, 4C)
+        write_fun(model_tensors[f"transformer.h.{i}.mlp.c_proj.weight"], file)
+    for i in range(L): # (L, C)
+        write_fun(model_tensors[f"transformer.h.{i}.mlp.c_proj.bias"], file)
+    write_fun(model_tensors["transformer.ln_f.weight"], file) # (C, )
+    write_fun(model_tensors["transformer.ln_f.bias"], file) # (C, )
+
+@torch.no_grad()
+def pad_vocab(tensor, multiple=128, value=0):
+    """
+    The dimension of the vocab size in GPT-2 is 50,257
+    which is unfortunately a very unfriendly number for a lot of
+    matrix operations on the GPU. So we pad it to the nearest
+    friendlier multiple, e.g. 50,304 if multiple=128 when we
+    export the weights into C land. This is a NOOP algorithmically
+    and is only done to make the tensor operations more efficient.
+    """
+    assert tensor.ndim == 2
+    V, C = tensor.shape
+    assert V == 50257, "just being defensive here"
+    # calculate padded vocab size by rounding up to nearest multiple
+    Vp = ((V + multiple - 1) // multiple) * multiple
+    # pad the tensor
+    pad_rows = Vp - V
+    padded = tensor if pad_rows == 0 else F.pad(tensor, (0, 0, 0, pad_rows), value=value)
+    assert padded.shape == (Vp, C)
+    return padded
+
+def write_model(model, filename, dtype):
+    # everything we need to instantiate the model
+    # 1) header is: version int, GPTConfig ints, padding to 1024 bytes
+    assert dtype in {"float32", "bfloat16"} # float16 todo maybe later
+    version = {
+        "float32": 3, # 3: all tensors are fp32, padded vocab
+        "bfloat16": 5, # 5: all tensors are bf16, padded vocab
+    }[dtype]
+    header = torch.zeros(256, dtype=torch.int32)
+    header[0] = 20240326 # magic
+    header[1] = version # checkpoint version
+    header[2] = model.config.block_size
+    header[3] = model.config.vocab_size
+    header[4] = model.config.n_layer
+    header[5] = model.config.n_head
+    header[6] = model.config.n_embd
+    # 2) the parameters follow the header
+    params = {name: param.cpu() for name, param in model.named_parameters()}
+    # pad the vocab to a multiple of 128 here at export, for efficiency in C
+    wte = params["transformer.wte.weight"] # (V, C)
+    wte_padded = pad_vocab(wte) # (Vp, C)
+    params["transformer.wte.weight"] = wte_padded # (Vp, C)
+    print(f"padded vocab size from {wte.size(0)} to {wte_padded.size(0)}")
+    header[7] = wte_padded.size(0) # padded vocab size store in header
+    # now write to file
+    with open(filename, "wb") as file:
+        file.write(header.numpy().tobytes()) # header
+        write_tensors(params, model.config.n_layer, file, dtype) # params
+    print(f"wrote {filename}")
+
+def write_state(model, x, y, logits, loss, filename):
+    # the state is used for debugging.
+    # it contains information about the input, logits, loss, and the parameter gradients
+    # this can be used for checking the computation correctness in C
+    header = torch.zeros(256, dtype=torch.int32)
+    header[0] = 20240327 # magic
+    header[1] = 2 # run state version = 2 (1 -> 2 for padded vocab changes)
+    header[2] = x.size(0) # batch size of the batch, B
+    header[3] = x.size(1) # temporal extent of the batch, T
+    grads = {name: param.grad.cpu() for name, param in model.named_parameters()}
+    # pad the vocab grads here as well, to mirror write_model
+    wte_grad = grads["transformer.wte.weight"] # (V, C)
+    wte_grad_padded = pad_vocab(wte_grad, value=0) # (Vp, C) # TODO later maybe pad with nan?
+    grads["transformer.wte.weight"] = wte_grad_padded # (Vp, C)
+    print(f"padded vocab size in reference grads from {wte_grad.size(0)} to {wte_grad_padded.size(0)}")
+    with open(filename, "wb") as file:
+        # header
+        file.write(header.numpy().tobytes())
+        # input x
+        file.write(x.cpu().numpy().astype("int32").tobytes()) # (B, T)
+        # targets y
+        file.write(y.cpu().numpy().astype("int32").tobytes()) # (B, T)
+        # logits (result of the model forward pass)
+        write_fp32(logits.cpu(), file)
+        # loss (single float, result of the cross entropy loss)
+        write_fp32(loss.cpu(), file)
+        # gradients
+        write_tensors(grads, model.config.n_layer, file, "float32")
+    print(f"wrote {filename}")
+
+def write_tokenizer(enc, filename):
+    n = enc.max_token_value + 1
+    header = torch.zeros(256, dtype=torch.int32)
+    header[0] = 20240328 # magic
+    header[1] = 2 # tokenizer version = 2 (1 -> 2: includes EOT token)
+    header[2] = n # number of tokens
+    header[3] = enc.eot_token # EOT token
+    with open(filename, "wb") as file:
+        file.write(header.numpy().tobytes())
+        for i in range(n):
+            b = enc.decode_bytes([i])
+            length = len(b)
+            assert length < 256, f"Token length exceeds 255: {length}"
+            file.write(struct.pack("<B", length))  # Write the length as a 1-byte unsigned integer
+            file.write(b)  # Write the actual bytes
+    print(f"wrote {filename}")
+
+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
+
+# -----------------------------------------------------------------------------
+# Helper functions for norm calculations
+
+def calculate_l1_to_linf_norm(matrix):
+    if matrix.ndim == 1:
+        return torch.sum(torch.abs(matrix))
+    elif matrix.ndim == 2:
+        # Each row's L1 norm, then take maximum
+        row_l1_norms = torch.sum(torch.abs(matrix), dim=1)
+        return torch.max(row_l1_norms)
+    else:
+        # For higher-dimensional tensors, flatten to 2D
+        matrix_2d = matrix.view(matrix.shape[0], -1)
+        row_l1_norms = torch.sum(torch.abs(matrix_2d), dim=1)
+        return torch.max(row_l1_norms)
+
+def calculate_spectral_norm(matrix):
+    """
+    Calculate the spectral norm (largest singular value) of a matrix.
+    For vectors, returns the L2 norm.
+    """
+    # Convert to float32 if needed for linalg operations
+    if matrix.dtype in [torch.bfloat16, torch.float16]:
+        matrix = matrix.float()
+    
+    if matrix.ndim == 1:
+        return torch.norm(matrix, p=2)
+    elif matrix.ndim == 2:
+        # Use matrix 2-norm (largest singular value)
+        return torch.linalg.matrix_norm(matrix, ord=2)
+    else:
+        # For higher-dimensional tensors, flatten to 2D
+        matrix_2d = matrix.view(matrix.shape[0], -1)
+        return torch.linalg.matrix_norm(matrix_2d, ord=2)
+
+# -----------------------------------------------------------------------------
+# Comprehensive sharpness analysis function
+
+def calculate_comprehensive_sharpness(model, model_for_forward, optimizers, step, train_loader, val_loader,
+                                      rank, world_size, device, B, T, ptdtype, grad_accum_steps, last_training_update=None, last_training_gradient=None, last_training_batches=None):
+    prev_training_mode = model.training
+    model.eval()
+    
+    NUM_LAYERS = model.config.n_layer # Number of transformer blocks
+    analysis_results = {}
+    
+    # --- 1. Get the true update direction 'v' ---
+    assert last_training_update is not None, \
+        f"[Step {step}] BUG: last_training_update is None! Check sharpness timing logic."
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] Using update from previous training step")
+    update_direction_v = last_training_update
+    
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] Restoring parameters to θ_t for HVP calculation...")
+    with torch.no_grad():
+        for p, v in zip(model.parameters(), update_direction_v):
+            p.data.sub_(v)  # Now parameters are at θ_t
+    
+    # --- 2. Calculate update norms (Frobenius, Max-of-Max, Spectral) ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Calculating update norms...")
+    
+    total_update_norm_sq = sum(torch.sum(v * v) for v in update_direction_v)
+    dist.all_reduce(total_update_norm_sq, op=dist.ReduceOp.AVG)
+    analysis_results["total_update_fnorm"] = torch.sqrt(total_update_norm_sq).item()
+    
+    # Calculate TOTAL update Max-of-Max and Spectral norms
+    print0(f"[Enhanced Sharpness @ Step {step}] Calculating total update Max-of-Max and Spectral norms...")
+    try:
+        all_updates_flat = torch.cat([v.flatten() for v in update_direction_v if v.numel() > 0])
+        
+        if all_updates_flat.numel() > 0:
+            total_l1_linf_norm = torch.sum(torch.abs(all_updates_flat))
+            analysis_results["total_l1_linf_norm"] = total_l1_linf_norm.item()
+            
+            total_spectral_norm = torch.norm(all_updates_flat, p=2)
+            analysis_results["total_spectral_norm"] = total_spectral_norm.item()
+        else:
+            analysis_results["total_l1_linf_norm"] = 0.0
+            analysis_results["total_spectral_norm"] = 0.0
+            
+        del all_updates_flat
+    except Exception as e:
+        print0(f"[Enhanced Sharpness @ Step {step}] Error calculating total norms: {e}")
+        analysis_results["total_l1_linf_norm"] = 0.0
+        analysis_results["total_spectral_norm"] = 0.0
+    
+    # --- 3. Setup layer parameter groups (adapt to new model structure) ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Setting up layer parameter groups...")
+    
+    all_param_groups = {}
+    
+    
+    all_param_groups["embed_lm_head"] = list(model.lm_head.parameters())
+    
+    blocks = model.transformer.h
+    
+    for i, block in enumerate(blocks):
+        layer_name = f"layer_{i+1}"
+        all_param_groups[layer_name] = list(block.parameters())
+    
+    # Add fine-grained params for selected layers (0, 3, 7, 11)
+    selected_layers = [0, 3, 7, 11]
+    for layer_idx in selected_layers:
+        block = blocks[layer_idx]
+        prefix = f"block{layer_idx}"
+        # Attention: Q, K, V, O
+        all_param_groups[f"{prefix}_q"] = [block.attn.q_w.weight]
+        all_param_groups[f"{prefix}_k"] = [block.attn.k_w.weight]
+        all_param_groups[f"{prefix}_v"] = [block.attn.v_w.weight]
+        all_param_groups[f"{prefix}_o"] = [block.attn.c_proj.weight]
+        # MLP: c_fc (win) and c_proj (wout)
+        all_param_groups[f"{prefix}_mlp_win"] = [block.mlp.c_fc.weight]
+        all_param_groups[f"{prefix}_mlp_wout"] = [block.mlp.c_proj.weight]
+    
+    # --- 4. Calculate layer-wise update norms ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Calculating layer-wise update norms...")
+    
+    param_to_idx = {id(p): i for i, p in enumerate(model.parameters())}
+    
+    for group_name, param_group in all_param_groups.items():
+        if not param_group:
+            continue
+            
+        # Get indices for this group
+        indices = [param_to_idx[id(p)] for p in param_group if id(p) in param_to_idx]
+        if not indices:
+            continue
+        
+        # Calculate Frobenius norm for this group
+        group_update_norm_sq = sum(torch.sum(update_direction_v[i] * update_direction_v[i]) for i in indices)
+        dist.all_reduce(group_update_norm_sq, op=dist.ReduceOp.AVG)
+        analysis_results[f"{group_name}_update_fnorm"] = torch.sqrt(group_update_norm_sq).item()
+        
+        # Calculate Max-of-Max and Spectral norms for this group
+        group_l1_linf_norms = []
+        group_spectral_norms = []
+        
+        for i in indices:
+            if i < len(update_direction_v) and update_direction_v[i].numel() > 0:
+                try:
+                    l1_linf_norm = calculate_l1_to_linf_norm(update_direction_v[i])
+                    group_l1_linf_norms.append(l1_linf_norm.item())
+                    
+                    spectral_norm = calculate_spectral_norm(update_direction_v[i])
+                    group_spectral_norms.append(spectral_norm.item())
+                except Exception as e:
+                    print0(f"[Enhanced Sharpness @ Step {step}] Error calculating norms for group {group_name}, param {i}: {e}")
+                    group_l1_linf_norms.append(0.0)
+                    group_spectral_norms.append(0.0)
+        
+        if group_l1_linf_norms:
+            analysis_results[f"{group_name}_max_l1_linf_norm"] = max(group_l1_linf_norms)
+        else:
+            analysis_results[f"{group_name}_max_l1_linf_norm"] = 0.0
+            
+        if group_spectral_norms:
+            analysis_results[f"{group_name}_max_spectral_norm"] = max(group_spectral_norms)
+        else:
+            analysis_results[f"{group_name}_max_spectral_norm"] = 0.0
+    
+    # --- 5. Setup for HVP calculation on TRAIN data ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Setting up HVP calculation in {ptdtype} on TRAIN data...")
+    
+    original_flash = nano_GPT_qkvonorm_pure.FLASH
+    nano_GPT_qkvonorm_pure.FLASH = 0
+    print0(f"[Enhanced Sharpness @ Step {step}] Disabled FLASH attention for HVP (was {original_flash})")
+
+    # Get block parameter indices for cross-layer analysis (need this before loop)
+    block_param_indices = set()
+    for group_name, param_group in all_param_groups.items():
+        if group_name.startswith("layer_"):
+            for p in param_group:
+                if id(p) in param_to_idx:
+                    block_param_indices.add(param_to_idx[id(p)])
+
+    # Initialize accumulators for all quantities we need
+    grads_hvp = None          
+    hvp_v_total = None        
+    hvp_v_block = None        
+    hvp_g_accum = None       
+    layer_hvp_accum = {}
+    
+   
+    group_names_to_process = [gn for gn, pg in all_param_groups.items() 
+                              if pg and any(id(p) in param_to_idx for p in pg)]
+    
+    if last_training_batches is not None and len(last_training_batches) > 0:
+        
+        batch_iterator = [(x, y) for x, y in last_training_batches]
+        n_batches = len(batch_iterator)
+        print0(f"[Enhanced Sharpness @ Step {step}] Using {n_batches} microbatches for HVP (out of {grad_accum_steps} training microbatches)")
+        restore_loader = False
+    else:
+        # Fallback: use new batches from train_loader (should rarely happen)
+        print0(f"[Enhanced Sharpness @ Step {step}] WARNING: last_training_batches is None/empty, using {grad_accum_steps} new batches (inconsistent)")
+        saved_current_shard = train_loader.current_shard
+        saved_current_position = train_loader.current_position
+        n_batches = grad_accum_steps  # Use same number as training for consistency
+        batch_iterator = []
+        shard_was_changed = False
+        for _ in range(n_batches):
+            x_hvp, y_hvp = train_loader.next_batch()
+            batch_iterator.append((x_hvp, y_hvp))
+            shard_was_changed = shard_was_changed or (train_loader.current_shard != saved_current_shard)
+        restore_loader = True
+
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] Computing HVPs for {n_batches} microbatches")
+    for mb_idx, (x_hvp, y_hvp) in enumerate(batch_iterator):
+        x_hvp, y_hvp = x_hvp.to(device), y_hvp.to(device)
+        
+        
+        _, loss_mb = model(x_hvp, y_hvp, return_logits=False)
+        grads_mb = torch.autograd.grad(loss_mb, model.parameters(), create_graph=True, allow_unused=True)
+        
+        # Compute H·v (total sharpness)
+        v_dot_g_total = sum(torch.sum(g * v) for g, v in zip(grads_mb, update_direction_v) if g is not None)
+        
+        if not isinstance(v_dot_g_total, torch.Tensor):
+            v_dot_g_total = torch.tensor(0.0, device=device, requires_grad=True)
+        hvp_v_total_mb = torch.autograd.grad(v_dot_g_total, model.parameters(), retain_graph=True, allow_unused=True)
+        
+        # Compute H·v_block (block-only sharpness)
+        if block_param_indices:  
+            v_dot_g_block = sum(torch.sum(grads_mb[i] * update_direction_v[i]) 
+                               for i in block_param_indices if grads_mb[i] is not None)
+            if not isinstance(v_dot_g_block, torch.Tensor):
+                v_dot_g_block = torch.tensor(0.0, device=device, requires_grad=True)
+            hvp_v_block_mb = torch.autograd.grad(v_dot_g_block, model.parameters(), retain_graph=True, allow_unused=True)
+        else:
+            
+            hvp_v_block_mb = [None] * len(list(model.parameters()))
+        
+        
+        g_dot_g = sum(torch.sum(g * g) for g in grads_mb if g is not None)
+        if not isinstance(g_dot_g, torch.Tensor):
+            g_dot_g = torch.tensor(0.0, device=device, requires_grad=True)
+        
+        
+        hvp_g_mb_raw = torch.autograd.grad(g_dot_g, model.parameters(), 
+                                           retain_graph=True, allow_unused=True)
+        hvp_g_mb = [h / 2.0 if h is not None else None for h in hvp_g_mb_raw]
+        
+        # Compute per-layer H_kk·v_k (for layer-wise sharpness)
+        for group_idx, group_name in enumerate(group_names_to_process):
+            param_group = all_param_groups[group_name]
+            indices = {param_to_idx[id(p)] for p in param_group if id(p) in param_to_idx}
+            if not indices:
+                continue
+            
+            is_last_layer = (group_idx == len(group_names_to_process) - 1)
+            is_last_microbatch = (mb_idx == n_batches - 1)
+            need_retain = not (is_last_layer and is_last_microbatch)
+            
+            try:
+                v_dot_g_layer = sum(torch.sum(grads_mb[i] * update_direction_v[i]) 
+                                   for i in indices if grads_mb[i] is not None)
+                
+                if not isinstance(v_dot_g_layer, torch.Tensor):
+                    v_dot_g_layer = torch.tensor(0.0, device=device, requires_grad=True)
+                    
+                hvp_layer_mb = torch.autograd.grad(v_dot_g_layer, model.parameters(), 
+                                                   retain_graph=need_retain,
+                                                   allow_unused=True)
+
+                if group_name not in layer_hvp_accum:
+                    layer_hvp_accum[group_name] = [(h.detach() / n_batches).cpu() if h is not None else None for h in hvp_layer_mb]
+                else:
+                    layer_hvp_accum[group_name] = [
+                        (h_acc + (h.detach() / n_batches).cpu()) if (h is not None and h_acc is not None)
+                        else ((h.detach() / n_batches).cpu() if h is not None else h_acc)
+                        for h_acc, h in zip(layer_hvp_accum[group_name], hvp_layer_mb)
+                    ]
+                
+                # Accumulate layer HVP
+                # if group_name not in layer_hvp_accum:
+                #     layer_hvp_accum[group_name] = [h.detach() / n_batches if h is not None else None for h in hvp_layer_mb]
+                # else:
+                #     layer_hvp_accum[group_name] = [
+                #         (h_acc + h.detach() / n_batches) if (h is not None and h_acc is not None)
+                #         else (h.detach() / n_batches if h is not None else h_acc)
+                #         for h_acc, h in zip(layer_hvp_accum[group_name], hvp_layer_mb)
+                #     ]
+                #     del hvp_layer_mb, v_dot_g_layer
+                #     torch.cuda.empty_cache()
+            except Exception as e:
+                print0(f"[Enhanced Sharpness @ Step {step}] Error computing layer HVP for '{group_name}' in microbatch {mb_idx}: {e}")
+                if group_name not in layer_hvp_accum:
+                    layer_hvp_accum[group_name] = None
+        
+        # 6. Accumulate all quantities
+        if grads_hvp is None:
+            grads_hvp = [(g.detach() / n_batches).cpu() if g is not None else None for g in grads_mb]
+            hvp_v_total = [(h.detach() / n_batches).cpu() if h is not None else None for h in hvp_v_total_mb]
+            hvp_v_block = [(h.detach() / n_batches).cpu() if h is not None else None for h in hvp_v_block_mb]
+            hvp_g_accum = [(h.detach() / n_batches).cpu() if h is not None else None for h in hvp_g_mb]
+        else:
+            grads_hvp = [
+                (g_acc + (g.detach() / n_batches).cpu()) if (g is not None and g_acc is not None) 
+                else ((g.detach() / n_batches).cpu() if g is not None else g_acc)
+                for g_acc, g in zip(grads_hvp, grads_mb)
+            ]
+            hvp_v_total = [
+                (h_acc + (h.detach() / n_batches).cpu()) if (h is not None and h_acc is not None)
+                else ((h.detach() / n_batches).cpu() if h is not None else h_acc)
+                for h_acc, h in zip(hvp_v_total, hvp_v_total_mb)
+            ]
+            hvp_v_block = [
+                (h_acc + (h.detach() / n_batches).cpu()) if (h is not None and h_acc is not None)
+                else ((h.detach() / n_batches).cpu() if h is not None else h_acc)
+                for h_acc, h in zip(hvp_v_block, hvp_v_block_mb)
+            ]
+            hvp_g_accum = [
+                (h_acc + (h.detach() / n_batches).cpu()) if (h is not None and h_acc is not None)
+                else ((h.detach() / n_batches).cpu() if h is not None else h_acc)
+                for h_acc, h in zip(hvp_g_accum, hvp_g_mb)
+            ]
+
+        
+        
+        if mb_idx % max(1, n_batches // 4) == 0:
+            print0(f"[Enhanced Sharpness @ Step {step}] Processed microbatch {mb_idx + 1}/{n_batches}")
+    
+   
+    if restore_loader:
+        train_loader.current_shard = saved_current_shard
+        train_loader.current_position = saved_current_position
+        if shard_was_changed:
+            train_loader.tokens = _load_data_shard(train_loader.files[train_loader.current_shard])
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] Finished computing all HVPs for {n_batches} microbatches")
+    grads_hvp = [g.to(device) if g is not None else None for g in grads_hvp]
+    hvp_v_total = [h.to(device) if h is not None else None for h in hvp_v_total]
+    hvp_v_block = [h.to(device) if h is not None else None for h in hvp_v_block]
+    hvp_g_accum = [h.to(device) if h is not None else None for h in hvp_g_accum]
+    for group_name in layer_hvp_accum:
+        if layer_hvp_accum[group_name] is not None:
+            layer_hvp_accum[group_name] = [h.to(device) if h is not None else None for h in layer_hvp_accum[group_name]]
+    # --- Calculate TOTAL sharpness ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Calculating TOTAL sharpness...")
+    # hvp_v_total is already computed in the loop above
+    vhp_dot_v_total = sum(torch.sum(hvp * v) for hvp, v in zip(hvp_v_total, update_direction_v) if hvp is not None)
+    v_norm_sq_total = sum(torch.sum(v * v) for v in update_direction_v)
+    
+    # Ensure they are tensors
+    if not isinstance(vhp_dot_v_total, torch.Tensor):
+        vhp_dot_v_total = torch.tensor(0.0, device=device)
+    if not isinstance(v_norm_sq_total, torch.Tensor):
+        v_norm_sq_total = torch.tensor(0.0, device=device)
+
+    dist.all_reduce(vhp_dot_v_total, op=dist.ReduceOp.AVG)
+    dist.all_reduce(v_norm_sq_total, op=dist.ReduceOp.AVG)
+
+    if v_norm_sq_total.item() > 1e-12:
+        analysis_results["total_sharpness"] = (vhp_dot_v_total / v_norm_sq_total).item()
+    else:
+        analysis_results["total_sharpness"] = 0.0
+
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] Calculating BLOCK-ONLY total sharpness...")
+    # hvp_v_block is already computed in the loop above
+    if block_param_indices:  # Only compute if there are block parameters
+        # Compute v_block^T H v_block (only sum over block indices)
+        vhp_dot_v_block = sum(torch.sum(hvp_v_block[i] * update_direction_v[i]) 
+                              for i in block_param_indices if hvp_v_block[i] is not None)
+        
+        v_norm_sq_block = sum(torch.sum(update_direction_v[i] * update_direction_v[i]) 
+                              for i in block_param_indices)
+        
+        # Ensure they are tensors
+        if not isinstance(vhp_dot_v_block, torch.Tensor):
+            vhp_dot_v_block = torch.tensor(0.0, device=device)
+        if not isinstance(v_norm_sq_block, torch.Tensor):
+            v_norm_sq_block = torch.tensor(0.0, device=device)
+        
+        dist.all_reduce(vhp_dot_v_block, op=dist.ReduceOp.AVG)
+        dist.all_reduce(v_norm_sq_block, op=dist.ReduceOp.AVG)
+        
+        if v_norm_sq_block.item() > 1e-12:
+            analysis_results["block_total_sharpness"] = (vhp_dot_v_block / v_norm_sq_block).item()
+        else:
+            analysis_results["block_total_sharpness"] = 0.0
+        
+        analysis_results["v_norm_block"] = torch.sqrt(v_norm_sq_block).item()
+        analysis_results["v_T_H_v_block"] = vhp_dot_v_block.item()
+    else:
+        # No block parameters
+        analysis_results["block_total_sharpness"] = 0.0
+        analysis_results["v_norm_block"] = 0.0
+        analysis_results["v_T_H_v_block"] = 0.0
+    
+    torch.cuda.empty_cache()
+
+    # ---- Alignment metrics between update v and (negative) gradient g ----
+    eps = 1e-12
+    v_norm = torch.sqrt(v_norm_sq_total + eps)
+    analysis_results["v_norm"] = v_norm.item()
+    
+    # --- Version 1: g_hvp  ---
+    ip_v_neg_g_hvp = sum(torch.sum(v * (-g)) for v, g in zip(update_direction_v, grads_hvp) if g is not None)
+    g_hvp_norm_sq = sum(torch.sum(g * g) for g in grads_hvp if g is not None)
+    
+    if not isinstance(ip_v_neg_g_hvp, torch.Tensor):
+        ip_v_neg_g_hvp = torch.tensor(0.0, device=device)
+    if not isinstance(g_hvp_norm_sq, torch.Tensor):
+        g_hvp_norm_sq = torch.tensor(0.0, device=device)
+    dist.all_reduce(ip_v_neg_g_hvp, op=dist.ReduceOp.AVG)
+    dist.all_reduce(g_hvp_norm_sq, op=dist.ReduceOp.AVG)
+    g_hvp_norm = torch.sqrt(g_hvp_norm_sq + eps)
+    analysis_results["ip_v_neg_g_hvp"] = ip_v_neg_g_hvp.item()
+    analysis_results["cos_v_neg_g_hvp"] = (ip_v_neg_g_hvp / (v_norm * g_hvp_norm + eps)).item()
+    analysis_results["g_hvp_norm"] = g_hvp_norm.item()
+    
+    # --- Version 2: g_t (original gradient that produced v) ---
+    # last_training_gradient is the actual gradient from training that led to the update v
+    if last_training_gradient is not None:
+        ip_v_neg_g_t = sum(torch.sum(v * (-g)) for v, g in zip(update_direction_v, last_training_gradient) if g is not None)
+        g_t_norm_sq = sum(torch.sum(g * g) for g in last_training_gradient if g is not None)
+        dist.all_reduce(ip_v_neg_g_t, op=dist.ReduceOp.AVG)
+        dist.all_reduce(g_t_norm_sq, op=dist.ReduceOp.AVG)
+        g_t_norm = torch.sqrt(g_t_norm_sq + eps)
+        analysis_results["ip_v_neg_g_t"] = ip_v_neg_g_t.item()
+        analysis_results["cos_v_neg_g_t"] = (ip_v_neg_g_t / (v_norm * g_t_norm + eps)).item()
+        analysis_results["g_t_norm"] = g_t_norm.item()
+    else:
+        print0(f"[Enhanced Sharpness @ Step {step}] Warning: last_training_gradient is None, skipping g_t metrics")
+    
+    # Keep backward compatibility aliases (g_norm uses g_hvp for now)
+    g_norm_sq = g_hvp_norm_sq
+    g_norm = g_hvp_norm
+    analysis_results["g_norm"] = g_norm.item()
+
+    # ---- Cosine between v and Hv (curvature pull along v) ----
+    hv_norm_sq = sum(torch.sum(hvp * hvp) for hvp in hvp_v_total if hvp is not None)
+    if not isinstance(hv_norm_sq, torch.Tensor):
+        hv_norm_sq = torch.tensor(0.0, device=device)
+    dist.all_reduce(hv_norm_sq, op=dist.ReduceOp.AVG)
+    hv_norm = torch.sqrt(hv_norm_sq + eps)
+    ip_v_hv = vhp_dot_v_total  # already reduced AVG
+    analysis_results["hv_norm"] = hv_norm.item()
+    analysis_results["cos_v_hv"] = (ip_v_hv / (v_norm * hv_norm + eps)).item()
+
+    # ---- Cosine between g and Hg ----
+    # hvp_g_accum is already computed in the loop above
+    ip_g_hg = sum(torch.sum(g * hg) for g, hg in zip(grads_hvp, hvp_g_accum) if (g is not None and hg is not None))
+    hg_norm_sq = sum(torch.sum(hg * hg) for hg in hvp_g_accum if hg is not None)
+    if not isinstance(ip_g_hg, torch.Tensor):
+        ip_g_hg = torch.tensor(0.0, device=device)
+    if not isinstance(hg_norm_sq, torch.Tensor):
+        hg_norm_sq = torch.tensor(0.0, device=device)
+    dist.all_reduce(ip_g_hg, op=dist.ReduceOp.AVG)
+    dist.all_reduce(hg_norm_sq, op=dist.ReduceOp.AVG)
+    hg_norm = torch.sqrt(hg_norm_sq + eps)
+    analysis_results["hg_norm"] = hg_norm.item()
+    analysis_results["cos_g_hg"] = (ip_g_hg / (g_norm * hg_norm + eps)).item() if g_norm.item() > 0 else 0.0
+
+    # ---- Decompose v into parallel / perpendicular to -g ----
+    if g_norm.item() > 0:
+        v_parallel = [(torch.sum(v * (-g)) / (g_norm_sq + eps)) * (-g) if g is not None else torch.zeros_like(v)
+                      for v, g in zip(update_direction_v, grads_hvp)]
+        v_parallel_norm_sq = sum(torch.sum(vp * vp) for vp in v_parallel)
+        if not isinstance(v_parallel_norm_sq, torch.Tensor):
+            v_parallel_norm_sq = torch.tensor(0.0, device=device)
+        dist.all_reduce(v_parallel_norm_sq, op=dist.ReduceOp.AVG)
+        v_parallel_norm = torch.sqrt(v_parallel_norm_sq + eps)
+        v_perp_norm = torch.sqrt(torch.clamp(v_norm_sq_total - v_parallel_norm_sq, min=0.0) + eps)
+        analysis_results["v_parallel_norm"] = v_parallel_norm.item()
+        analysis_results["v_perp_norm"] = v_perp_norm.item()
+
+    # ---- Per-layer additions: cos_v_neg_g_layer, v_norm_layer ----
+    for group_name, param_group in all_param_groups.items():
+        indices = {param_to_idx[id(p)] for p in param_group if id(p) in param_to_idx}
+        if not indices:
+            continue
+        v_norm_sq_layer = sum(torch.sum(update_direction_v[i] * update_direction_v[i]) for i in indices)
+        g_norm_sq_layer = sum(torch.sum(grads_hvp[i] * grads_hvp[i]) for i in indices if grads_hvp[i] is not None)
+        ip_v_neg_g_layer = sum(torch.sum(update_direction_v[i] * (-grads_hvp[i]))
+                               for i in indices if grads_hvp[i] is not None)
+        # Ensure they are tensors
+        if not isinstance(v_norm_sq_layer, torch.Tensor):
+            v_norm_sq_layer = torch.tensor(0.0, device=device)
+        if not isinstance(g_norm_sq_layer, torch.Tensor):
+            g_norm_sq_layer = torch.tensor(0.0, device=device)
+        if not isinstance(ip_v_neg_g_layer, torch.Tensor):
+            ip_v_neg_g_layer = torch.tensor(0.0, device=device)
+        dist.all_reduce(v_norm_sq_layer, op=dist.ReduceOp.AVG)
+        dist.all_reduce(g_norm_sq_layer, op=dist.ReduceOp.AVG)
+        dist.all_reduce(ip_v_neg_g_layer, op=dist.ReduceOp.AVG)
+        v_norm_layer = torch.sqrt(v_norm_sq_layer + eps)
+        g_norm_layer = torch.sqrt(g_norm_sq_layer + eps)
+        analysis_results[f"{group_name}_v_norm"] = v_norm_layer.item()
+        if g_norm_layer.item() > 0:
+            analysis_results[f"{group_name}_cos_v_neg_g"] = (ip_v_neg_g_layer / (v_norm_layer * g_norm_layer + eps)).item()
+
+    # --- 7. Calculate layer-wise sharpness ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Calculating layer-wise sharpness...")
+    print0(f"[Enhanced Sharpness @ Step {step}] Processing {len(all_param_groups)} layers for sharpness...")
+    
+    for group_name, param_group in all_param_groups.items():
+        if not param_group:
+            continue
+            
+        print0(f"[Enhanced Sharpness @ Step {step}] Processing '{group_name}'...")
+        indices = {param_to_idx[id(p)] for p in param_group if id(p) in param_to_idx}
+        if not indices: 
+            continue
+
+        try:
+            if group_name not in layer_hvp_accum or layer_hvp_accum[group_name] is None:
+                print0(f"[Enhanced Sharpness @ Step {step}] No HVP data for '{group_name}', skipping")
+                analysis_results[f"{group_name}_sharpness"] = 0.0
+                continue
+                
+            hvp_group_result = layer_hvp_accum[group_name]
+            
+            vhp_dot_v_group = sum(torch.sum(hvp_group_result[i] * update_direction_v[i]) 
+                                for i in indices if hvp_group_result[i] is not None)
+            v_norm_sq_group = sum(torch.sum(update_direction_v[i] * update_direction_v[i]) 
+                                for i in indices)
+            
+            # Ensure they are tensors
+            if not isinstance(vhp_dot_v_group, torch.Tensor):
+                vhp_dot_v_group = torch.tensor(0.0, device=device)
+            if not isinstance(v_norm_sq_group, torch.Tensor):
+                v_norm_sq_group = torch.tensor(0.0, device=device)
+            
+            dist.all_reduce(vhp_dot_v_group, op=dist.ReduceOp.AVG)
+            dist.all_reduce(v_norm_sq_group, op=dist.ReduceOp.AVG)
+            
+            if v_norm_sq_group.item() > 1e-12:
+                analysis_results[f"{group_name}_sharpness"] = (vhp_dot_v_group / v_norm_sq_group).item()
+            else:
+                analysis_results[f"{group_name}_sharpness"] = 0.0
+            
+        except torch.OutOfMemoryError as e:
+            print0(f"[Enhanced Sharpness @ Step {step}] OOM error for '{group_name}': {e}")
+            analysis_results[f"{group_name}_sharpness"] = 0.0
+            torch.cuda.empty_cache()
+        except Exception as e:
+            print0(f"[Enhanced Sharpness @ Step {step}] Error processing '{group_name}': {e}")
+            analysis_results[f"{group_name}_sharpness"] = 0.0
+
+    # --- Calculate block-diagonal approximation and cross-layer interaction ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Calculating block-diagonal and cross-layer sharpness...")
+    
+    sum_layer_numerators = 0.0
+    for layer in range(1, NUM_LAYERS + 1):
+        layer_name = f"layer_{layer}"
+        if f"{layer_name}_sharpness" in analysis_results and f"{layer_name}_v_norm" in analysis_results:
+            s_k = analysis_results[f"{layer_name}_sharpness"]
+            v_k_norm = analysis_results[f"{layer_name}_v_norm"]
+            sum_layer_numerators += s_k * (v_k_norm ** 2)
+    
+    analysis_results["sum_layer_numerators"] = sum_layer_numerators
+    
+    # Block-diagonal sharpness (using block ||v||²)
+    v_norm_block = analysis_results.get("v_norm_block", 0)
+    v_norm_sq_block_val = v_norm_block ** 2 if v_norm_block else 1e-12
+    
+    if v_norm_sq_block_val > 1e-12:
+        analysis_results["block_diag_sharpness"] = sum_layer_numerators / v_norm_sq_block_val
+    else:
+        analysis_results["block_diag_sharpness"] = 0.0
+    
+    # Cross-layer interaction = block_total - block_diag
+    block_total = analysis_results.get("block_total_sharpness", 0)
+    block_diag = analysis_results.get("block_diag_sharpness", 0)
+    analysis_results["cross_layer_sharpness"] = block_total - block_diag
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] block_total={block_total:.6f}, block_diag={block_diag:.6f}, cross_layer={block_total - block_diag:.6f}")
+
+    # --- Compute true_dec and pred_dec ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Computing true_dec (L(t) - L(t+1)) on training batch...")
+    try:
+        # Restore FLASH for forward pass 
+        nano_GPT_qkvonorm_pure.FLASH = original_flash
+
+        
+        loss_at_theta_t = 0.0
+        with torch.no_grad():
+            for x_td, y_td in batch_iterator:
+                x_td, y_td = x_td.to(device), y_td.to(device)
+                _, loss_td = model(x_td, y_td, return_logits=False)
+                loss_at_theta_t += loss_td.item()
+        loss_at_theta_t /= len(batch_iterator)  # average over microbatches
+
+        with torch.no_grad():
+            for p, v in zip(model.parameters(), update_direction_v):
+                p.data.add_(v)
+
+        loss_at_theta_t1 = 0.0
+        with torch.no_grad():
+            for x_td, y_td in batch_iterator:
+                x_td, y_td = x_td.to(device), y_td.to(device)
+                _, loss_td = model(x_td, y_td, return_logits=False)
+                loss_at_theta_t1 += loss_td.item()
+        loss_at_theta_t1 /= len(batch_iterator)
+
+        with torch.no_grad():
+            for p, v in zip(model.parameters(), update_direction_v):
+                p.data.sub_(v)
+
+        loss_t_tensor = torch.tensor(loss_at_theta_t, device=device)
+        loss_t1_tensor = torch.tensor(loss_at_theta_t1, device=device)
+        dist.all_reduce(loss_t_tensor, op=dist.ReduceOp.AVG)
+        dist.all_reduce(loss_t1_tensor, op=dist.ReduceOp.AVG)
+        loss_at_theta_t = loss_t_tensor.item()
+        loss_at_theta_t1 = loss_t1_tensor.item()
+
+        true_dec = loss_at_theta_t - loss_at_theta_t1
+        analysis_results["loss_at_theta_t"] = loss_at_theta_t
+        analysis_results["loss_at_theta_t1"] = loss_at_theta_t1
+        analysis_results["true_dec"] = true_dec
+
+        # pred_dec = (-g)^T v - 0.5 * v^T H v 
+        first_order = analysis_results.get("ip_v_neg_g_t", analysis_results.get("ip_v_neg_g_hvp", 0.0))
+        sharpness_val = analysis_results.get("total_sharpness", 0.0)
+        v_norm_val = analysis_results.get("v_norm", 0.0)
+        curvature_term = 0.5 * sharpness_val * (v_norm_val ** 2)
+        pred_dec = first_order - curvature_term
+
+        analysis_results["pred_dec"] = pred_dec
+        analysis_results["first_order_descent"] = first_order
+        analysis_results["curvature_penalty"] = curvature_term
+
+        print0(f"[Enhanced Sharpness @ Step {step}] L(θ_t)={loss_at_theta_t:.6f}, L(θ_{{t+1}})={loss_at_theta_t1:.6f}, "
+               f"true_dec={true_dec:.6f}, pred_dec={pred_dec:.6f}, 1st_order={first_order:.6f}, curvature={curvature_term:.6f}")
+    except Exception as e:
+        print0(f"[Enhanced Sharpness @ Step {step}] Error computing true_dec: {e}")
+        analysis_results["true_dec"] = 0.0
+        analysis_results["pred_dec"] = 0.0
+
+    # --- Cleanup ---
+    nano_GPT_qkvonorm_pure.FLASH = original_flash
+    print0(f"[Enhanced Sharpness @ Step {step}] Restored FLASH attention to {original_flash}")
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] Restoring parameters back to θ_{{t+1}}...")
+    with torch.no_grad():
+        for p, v in zip(model.parameters(), update_direction_v):
+            p.data.add_(v)  
+    
+    if prev_training_mode:
+        model.train()
+    else:
+        model.eval()
+    
+    # Thorough cleanup of all temporary variables
+    del update_direction_v, grads_hvp
+    del hvp_v_total, hvp_v_block, hvp_g_accum, layer_hvp_accum
+    del vhp_dot_v_total, v_norm_sq_total
+    del vhp_dot_v_block, v_norm_sq_block
+    if 'all_param_groups' in locals():
+        del all_param_groups
+    if 'param_to_idx' in locals():
+        del param_to_idx
+    
+    # Synchronize CUDA operations before cleanup
+    if device == "cuda":
+        torch.cuda.synchronize()
+    
+    gc.collect()
+    torch.cuda.empty_cache()
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] Analysis complete. Generated {len(analysis_results)} metrics.")
+    return analysis_results
+
+def format_comprehensive_results(results):
+    """
+    Format the comprehensive analysis results for logging.
+    """
+    log_parts = []
+    
+    # Total sharpness
+    if 'total_sharpness' in results:
+        log_parts.append(f"total_sharp:{results['total_sharpness']:.4e}")
+    
+    # Layer-wise sharpness - dynamically detect number of layers
+    layer_sharpness = []
+    layer_num = 1
+    while True:
+        layer_key = f"layer_{layer_num}_sharpness"
+        if layer_key in results:
+            layer_sharpness.append(f"L{layer_num}_sharp:{results[layer_key]:.4e}")
+            layer_num += 1
+        else:
+            break
+    
+    if layer_sharpness:
+        log_parts.append(" ".join(layer_sharpness))
+    
+    # Total update norms
+    total_norms = []
+    if 'total_update_fnorm' in results:
+        total_norms.append(f"total_fnorm:{results['total_update_fnorm']:.4e}")
+    if 'total_l1_linf_norm' in results:
+        total_norms.append(f"total_l1_linf:{results['total_l1_linf_norm']:.4e}")
+    if 'total_spectral_norm' in results:
+        total_norms.append(f"total_spectral:{results['total_spectral_norm']:.4e}")
+    
+    if total_norms:
+        log_parts.append(" ".join(total_norms))
+    
+    # Layer-wise update norms (Frobenius)
+    layer_fnorms = []
+    layer_num = 1
+    while True:
+        layer_key = f"layer_{layer_num}_update_fnorm"
+        if layer_key in results:
+            layer_fnorms.append(f"L{layer_num}_fnorm:{results[layer_key]:.4e}")
+            layer_num += 1
+        else:
+            break
+    
+    if layer_fnorms:
+        log_parts.append(" ".join(layer_fnorms))
+    
+    # Layer-wise update norms (Max-of-Max)
+    layer_l1_linf = []
+    layer_num = 1
+    while True:
+        layer_key = f"layer_{layer_num}_max_l1_linf_norm"
+        if layer_key in results:
+            layer_l1_linf.append(f"L{layer_num}_l1linf:{results[layer_key]:.4e}")
+            layer_num += 1
+        else:
+            break
+    
+    if layer_l1_linf:
+        log_parts.append(" ".join(layer_l1_linf))
+    
+    # Layer-wise update norms (Spectral)
+    layer_spectral = []
+    layer_num = 1
+    while True:
+        layer_key = f"layer_{layer_num}_max_spectral_norm"
+        if layer_key in results:
+            layer_spectral.append(f"L{layer_num}_spectral:{results[layer_key]:.4e}")
+            layer_num += 1
+        else:
+            break
+    
+    if layer_spectral:
+        log_parts.append(" ".join(layer_spectral))
+
+    # Alignment and curvature metrics (global)
+    misc_parts = []
+    if 'v_norm' in results:
+        misc_parts.append(f"v_norm:{results['v_norm']:.4e}")
+    
+    # Version 1: g_hvp (new batch, computed at θ_t during HVP calculation)
+    if 'cos_v_neg_g_hvp' in results:
+        misc_parts.append(f"cos_v_-g_hvp:{results['cos_v_neg_g_hvp']:.4e}")
+    if 'g_hvp_norm' in results:
+        misc_parts.append(f"g_hvp_norm:{results['g_hvp_norm']:.4e}")
+    
+    # Version 2: g_t (original gradient that produced v)
+    if 'cos_v_neg_g_t' in results:
+        misc_parts.append(f"cos_v_-g_t:{results['cos_v_neg_g_t']:.4e}")
+    if 'g_t_norm' in results:
+        misc_parts.append(f"g_t_norm:{results['g_t_norm']:.4e}")
+    
+    if 'hv_norm' in results:
+        misc_parts.append(f"hv_norm:{results['hv_norm']:.4e}")
+    if 'cos_v_hv' in results:
+        misc_parts.append(f"cos_v_hv:{results['cos_v_hv']:.4e}")
+    if 'hg_norm' in results:
+        misc_parts.append(f"hg_norm:{results['hg_norm']:.4e}")
+    if 'cos_g_hg' in results:
+        misc_parts.append(f"cos_g_hg:{results['cos_g_hg']:.4e}")
+    if 'v_parallel_norm' in results:
+        misc_parts.append(f"v_par:{results['v_parallel_norm']:.4e}")
+    if 'v_perp_norm' in results:
+        misc_parts.append(f"v_perp:{results['v_perp_norm']:.4e}")
+    if misc_parts:
+        log_parts.append(" ".join(misc_parts))
+
+    # Per-layer alignment metrics (cos_v_neg_g and v_norm per layer)
+    layer_cos = []
+    layer_num = 1
+    while True:
+        layer_key = f"layer_{layer_num}_cos_v_neg_g"
+        layer_vn_key = f"layer_{layer_num}_v_norm"
+        if layer_key in results:
+            layer_cos.append(f"L{layer_num}_cos_v_neg_g:{results[layer_key]:.4e}")
+        if layer_vn_key in results:
+            layer_cos.append(f"L{layer_num}_v_norm:{results[layer_vn_key]:.4e}")
+        if layer_key not in results and layer_vn_key not in results:
+            break
+        layer_num += 1
+    if layer_cos:
+        log_parts.append(" ".join(layer_cos))
+    
+    return " ".join(log_parts)
+
+# -----------------------------------------------------------------------------
+# int main
+
+def print0(*args, **kwargs):
+    # modified print that only prints from the master process
+    # if this is not a distributed run, it's just a print
+    if int(os.environ.get("RANK", 0)) == 0:
+        print(*args, **kwargs)
+
+if __name__ == "__main__":
+    import time
+    import argparse
+    import tiktoken
+    print0(f"Running pytorch {torch.version.__version__}")
+
+    # default settings will overfit a tiny batch of data
+    # and save model weights and debug state to disk on the first iteration
+    parser = argparse.ArgumentParser()
+    # file system input / output
+    parser.add_argument("--input_bin", type=str, default="dev/data/tinyshakespeare/tiny_shakespeare_val.bin", help="input .bin to train on")
+    parser.add_argument("--input_val_bin", type=str, default="", help="input .bin to eval validation loss on")
+    parser.add_argument("--output_dir", type=str, default="", help="output directory to which to write logs and checkpoints")
+    parser.add_argument("--model", type=str, default="gpt2", help="gpt2|gpt2-medium|gpt2-large|gpt2-xl|d8|d12|d24|d36|d48")
+    # token layout for each step of the optimization
+    parser.add_argument("--batch_size", type=int, default=4, help="batch size, in units of #batch dimensions")
+    parser.add_argument("--sequence_length", type=int, default=64, help="sequence length")
+    parser.add_argument("--total_batch_size", type=int, default=256, help="total desired batch size, in units of #tokens")
+    # workload (number of steps)
+    parser.add_argument("--num_iterations", type=int, default=10, help="number of iterations to run")
+    parser.add_argument("--inference_only", type=int, default=0, help="only run inference")
+    # optimization
+    parser.add_argument("--adam_lr", type=float, default=1e-4, help="learning rate warmup iterations")
+    parser.add_argument("--warmup_iters", type=int, default=0, help="learning rate warmup iterations")
+    parser.add_argument("--lr_decay_frac", type=float, default=1.0, help="learning rate warmup iterations")
+    parser.add_argument("--weight_decay", type=float, default=0.0, help="weight decay")
+    parser.add_argument("--grad_clip", type=float, default=1.0, help="maximum gradient magnitude")
+    # evaluation
+    parser.add_argument("--val_loss_every", type=int, default=0, help="every how mant steps to evaluate val loss?")
+    parser.add_argument("--val_max_steps", type=int, default=20, help="how many batches of val to average?")
+    parser.add_argument("--sample_every", type=int, default=0, help="how often to sample from the model?")
+    # debugging
+    parser.add_argument("--overfit_single_batch", type=int, default=0, help="overfit just one batch of data")
+    parser.add_argument("--shuffle_files", action="store_true")
+    # numerics
+    parser.add_argument("--tensorcores", type=int, default=0, help="use tensorcores")
+    # memory management
+    parser.add_argument("--device", type=str, default="", help="by default we autodetect, or set it here")
+    parser.add_argument("--compile", type=int, default=0, help="torch.compile the model")
+    parser.add_argument("--flash", type=int, default=0, help="use flash attention")
+    parser.add_argument("--dtype", type=str, default="float32", help="float32|float16|bfloat16")
+    parser.add_argument("--zero_stage", type=int, default=0, help="zero redundancy optimizer stage (0/1/2/3)")
+    # Muon optimizer specific arguments
+    parser.add_argument("--optimizer", type=str, default="adam", help="optimizer to use: adam|muon")
+    parser.add_argument("--muon_lr", type=float, default=0.02, help="learning rate for Muon optimizer")
+    parser.add_argument("--muon_momentum", type=float, default=0.95, help="momentum for Muon optimizer")
+    parser.add_argument("--muon_weight_decay", type=float, default=0.00, help="weight decay for Muon optimizer")
+    parser.add_argument("--muon_ns_steps", type=int, default=5, help="number of Newton-Schulz steps for Muon")
+    parser.add_argument("--muon_nesterov", type=bool, default=False, help="use Nesterov momentum for Muon (0/1)")
+    # python -> C bridge
+    parser.add_argument("--write_tensors", type=int, default=1, help="write tensors to disk")
+    parser.add_argument("--seed", type=int, default=42, help="random seed")
+    # Sharpness analysis arguments
+    parser.add_argument("--analyze_sharpness", action="store_true", help="Enable comprehensive sharpness analysis")
+    parser.add_argument("--sharpness_analysis_interval", type=int, default=500, help="Interval for sharpness analysis")
+    args = parser.parse_args()
+
+    # args error checking and convenience variables
+    B, T = args.batch_size, args.sequence_length
+    assert 1 <= T <= 1024
+    assert args.dtype in {"float32", "float16", "bfloat16"}
+    assert args.model in {"gpt2", "gpt2-medium", "gpt2-large", "gpt2-xl", "d8", "d12", "d24", "d36", "d48"}
+    assert args.optimizer in {"adam", "muon"}
+
+    set_seed(args.seed)
+
+    # set up DDP (distributed data parallel). torchrun sets this env variable
+    ddp = int(os.environ.get('RANK', -1)) != -1 # is this a ddp run?
+    if ddp:
+        # use of DDP atm demands CUDA, we set the device appropriately according to rank
+        assert torch.cuda.is_available(), "for now i think we need CUDA for DDP"
+        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)
+        master_process = ddp_rank == 0 # this process will do logging, checkpointing etc.
+        seed_offset = 0 # each process gets the exact same seed
+        zero_stage = args.zero_stage
+    else:
+        ddp_rank = 0
+        ddp_local_rank = 0
+        zero_stage = 0
+        ddp_world_size = 1
+        master_process = True
+        seed_offset = 0
+        # select the device
+        if args.device:
+            # provided explicitly by the user
+            device = args.device
+        else:
+            # attempt to autodetect the device
+            device = "cpu"
+            if torch.cuda.is_available():
+                device = "cuda"
+            elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
+                device = "mps"
+    print(f"using device: {device}")
+    device_type = 'cuda' if 'cuda' in device else 'cpu'
+
+    # Setup debugpy for remote debugging (only activates if DEBUGPY env var is set)
+    # setup_debugpy(rank=ddp_rank, force=True)
+
+    # calculate gradient accumulation from the desired total batch size and the current run configuration
+    tokens_per_fwdbwd = B * T * ddp_world_size
+    assert args.total_batch_size % tokens_per_fwdbwd == 0
+    grad_accum_steps = args.total_batch_size // tokens_per_fwdbwd
+    print0(f"total desired batch size: {args.total_batch_size}")
+    print0(f"=> calculated gradient accumulation steps: {grad_accum_steps}")
+
+    # set up a context manager following the desired dtype and device
+    ptdtype = {'float32': torch.float32, 'bfloat16': torch.bfloat16, 'float16': torch.float16}[args.dtype]
+    ctx = torch.amp.autocast(device_type=device_type, dtype=ptdtype) if device_type == "cuda" else nullcontext()
+
+    # rng / reproducibility
+    torch.manual_seed(42)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed(42)
+
+    # set the torch precision mode to use TensorFloat32 (TF32) for matmuls
+    # docs https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html
+    if args.tensorcores:
+        torch.set_float32_matmul_precision('high')
+
+    # turn on/off flash attention
+    assert args.flash in {0, 1}
+    nano_GPT_qkvonorm_pure.FLASH = args.flash  # Set module-level FLASH for training
+
+    # init (and write) the tokenizer
+    enc = tiktoken.get_encoding("gpt2")
+    if master_process and args.write_tensors: # tokenizer is technically not tensors but ok
+        write_tokenizer(enc, "gpt2_tokenizer.bin")
+
+    # init the model, either from scratch or from OpenAI pretrained checkpoint
+    if args.model[0] == "d":
+        # from scratch (random weights)
+        model_config = {
+            "d8":  GPTConfig(block_size=1024, vocab_size=50257, n_layer=8,  n_head=8,  n_embd=512),
+            "d12": GPTConfig(block_size=1024, vocab_size=50257, n_layer=12, n_head=12, n_embd=768),
+            "d24": GPTConfig(block_size=1024, vocab_size=50257, n_layer=24, n_head=16, n_embd=1024),
+            "d36": GPTConfig(block_size=1024, vocab_size=50257, n_layer=36, n_head=20, n_embd=1280),
+            "d48": GPTConfig(block_size=1024, vocab_size=50257, n_layer=48, n_head=25, n_embd=1600),
+        }[args.model]
+        model = GPT(model_config)
+    else:
+        # load the GPT-2 model weights
+        model = GPT.from_pretrained(args.model)
+    model.train()
+    model.to(device)
+    
+    # Save uncompiled model reference for sharpness analysis (needs double backward)
+    raw_model_uncompiled = model
+    
+    if args.compile:
+        if hasattr(config, "coordinate_descent_tuning"):
+            config.coordinate_descent_tuning = True # suggested by @Chillee
+        print0("compiling the model...")
+        model = torch.compile(model)
+
+    # -------------------------------------------------------------------------
+    # Our own version of a simple DistributedDataLoader
+
+    # load tokens
+    train_loader = DistributedDataLoader(
+        args.input_bin, B, T, ddp_rank, ddp_world_size,
+        shuffle_files=args.shuffle_files, random_seed=args.seed
+    )
+    val_loader = None
+    if args.input_val_bin:
+        val_loader = DistributedDataLoader(args.input_val_bin, B, T, ddp_rank, ddp_world_size)
+
+    # -------------------------------------------------------------------------
+    # PyTorch -> C bridge: save some weights and state for C to load later as reference
+
+    # do one forward pass to generate ground truth for our C tests
+    if master_process and args.write_tensors and (not args.inference_only):
+        x, y = train_loader.next_batch()
+        x, y = x.to(device), y.to(device)
+        logits, loss = model(x, y, return_logits=True)  # Need logits for write_state
+        loss.backward()
+        # save model params, in both float32 and bfloat16
+        model_to_size = {"gpt2": "124M", "gpt2-medium": "355M", "gpt2-large": "774M", "gpt2-xl": "1558M"}
+        model_to_size.update({f"d{d}": f"d{d}" for d in [12, 24, 36, 48]})
+        model_size_str = model_to_size[args.model] # e.g. "124M", or "d12"
+        write_model(model, f"gpt2_{model_size_str}.bin", dtype="float32")
+        write_model(model, f"gpt2_{model_size_str}_bf16.bin", dtype="bfloat16")
+        # save x, y, logits, loss, and parameter gradients, for debugging C
+        # always store these in fp32 to have an accurate reference (?)
+        write_state(model, x, y, logits, loss, f"gpt2_{model_size_str}_debug_state.bin")
+        # reset the train_loader for the optimization below
+        train_loader.reset()
+
+    # -------------------------------------------------------------------------
+    # main training loop
+
+    # here we wrap model into DDP container
+    if ddp:
+        model = DDP(model, device_ids=[ddp_local_rank])
+    raw_model = model.module if ddp else model # always contains the "raw" unwrapped model
+    
+    base_module = model.module if ddp else model
+    # If compiled, unwrap to get the original module
+    if hasattr(base_module, "_orig_mod"):
+        base_module = base_module._orig_mod
+    
+    raw_params = list(raw_model_uncompiled.parameters())
+    train_params = list(base_module.parameters())
+    
+    assert len(raw_params) == len(train_params), \
+        f"Parameter count mismatch: raw_model_uncompiled has {len(raw_params)}, training model has {len(train_params)}"
+    for i, (rp, tp) in enumerate(zip(raw_params, train_params)):
+        assert rp.data_ptr() == tp.data_ptr(), \
+            f"Parameter {i} has different data_ptr: raw_model_uncompiled and training model do not share parameters!"
+    print0(f"[Verified] raw_model_uncompiled and training model share the same {len(raw_params)} Parameter objects")
+    
+    last_training_update = None
+    last_training_gradient = None  # Store the original gradient that produced the update
+    last_training_batches = None  # Store ALL microbatches (x, y) for consistent HVP calculation
+
+
+    def configure_adam(model, weight_decay, learning_rate, betas, device_type, zero_stage):
+        # start with all of the candidate parameters
+        param_dict = {pn: p for pn, p in model.named_parameters()}
+        # filter out those that do not require grad
+        param_dict = {pn: p for pn, p in param_dict.items() if p.requires_grad}
+        # create optim groups. Any parameters that is 2D will be weight decayed, otherwise no.
+        # i.e. all weight tensors in matmuls + embeddings decay, all biases and layernorms don't.
+        decay_params = [p for n, p in param_dict.items() if p.dim() >= 2]
+        nodecay_params = [p for n, p in param_dict.items() if p.dim() < 2]
+        optim_groups = [
+            {'params': decay_params, 'weight_decay': weight_decay},
+            {'params': nodecay_params, 'weight_decay': 0.0}
+        ]
+        num_decay_params = sum(p.numel() for p in decay_params)
+        num_nodecay_params = sum(p.numel() for p in nodecay_params)
+        print0(f"num decayed parameter tensors: {len(decay_params)}, with {num_decay_params:,} parameters")
+        print0(f"num non-decayed parameter tensors: {len(nodecay_params)}, with {num_nodecay_params:,} parameters")
+        # Create AdamW optimizer and use the fused version if it is available
+        fused_available = 'fused' in inspect.signature(torch.optim.AdamW).parameters
+        use_fused = fused_available and device_type == 'cuda'
+        print0(f"using fused AdamW: {use_fused}")
+        if zero_stage == 1:
+            print0("using ZeroRedundancyOptimizer")
+            optimizer = ZeroRedundancyOptimizer(**optim_groups[0], optimizer_class=torch.optim.AdamW,
+                                                lr=learning_rate, betas=betas, fused=use_fused)
+            optimizer.add_param_group(optim_groups[1])
+        else:
+            print0("using regular AdamW")
+            optimizer = torch.optim.AdamW(optim_groups, lr=learning_rate, betas=betas, fused=use_fused)
+        return [optimizer]
+
+    def configure_muon(model, weight_decay, adam_lr, muon_lr, momentum, nesterov, ns_steps, device_type, zero_stage, ddp_rank, ddp_world_size):
+        # start with all of the candidate parameters
+        param_dict = {pn: p for pn, p in model.named_parameters()}
+        # filter out those that do not require grad
+        param_dict = {pn: p for pn, p in param_dict.items() if p.requires_grad}
+        
+        # For Muon, we need to separate 2D parameters (which can be orthogonalized) 
+        # from other parameters (which should use standard optimization)
+        muon_params = []  # 2D parameters for Muon
+        other_params = []  # other parameters for AdamW
+
+        muon_name = []
+        other_name = []
+        for n, p in param_dict.items():
+            if "wte.weight" in n :
+                other_params.append(p)
+                other_name.append(n)
+                continue
+
+            if p.dim() >= 2:  # 2D parameters (weight matrices)
+                muon_params.append(p)
+                muon_name.append(n)
+            else:  # 1D parameters (biases, embeddings, etc.)
+                other_params.append(p)
+                other_name.append(n)
+
+        # print("================================================\n")
+        # print(f"Muon parameters: {muon_name}\n")
+        # print(f"Other parameters: {other_name}\n")
+        # print("================================================\n")
+        
+        print0(f"Muon parameters (2D): {len(muon_params)} tensors")
+        print0(f"Other parameters (non-2D): {len(other_params)} tensors")
+        
+        # Create Muon optimizer for 2D parameters
+        muon_optimizer = None
+        if muon_params:
+            muon_optimizer = Muon(
+                params=muon_params,
+                lr=muon_lr,
+                weight_decay=weight_decay,
+                momentum=momentum,
+                nesterov=nesterov,
+                ns_steps=ns_steps,
+                rank=ddp_rank,
+                world_size=ddp_world_size
+            )
+        
+        # Create AdamW optimizer for non-2D parameters
+        adam_optimizer = None
+        if other_params:
+            # create optim groups for AdamW
+            # decay_params = [p for p in other_params if p.dim() >= 2]
+            # nodecay_params = [p for p in other_params if p.dim() < 2]
+            optim_groups = [
+                {'params': other_params, 'weight_decay': weight_decay},
+                # {'params': nodecay_params, 'weight_decay': 0.0}
+            ]
+            
+            # Create AdamW optimizer
+            fused_available = 'fused' in inspect.signature(torch.optim.AdamW).parameters
+            use_fused = fused_available and device_type == 'cuda'
+            print0(f"using fused AdamW for non-Muon params: {use_fused}")
+            
+            if zero_stage == 1:
+                print0("using ZeroRedundancyOptimizer for non-Muon params")
+                adam_optimizer = ZeroRedundancyOptimizer(**optim_groups[0], optimizer_class=torch.optim.AdamW,
+                                                        lr=adam_lr, betas=(0.9, 0.95), fused=use_fused)
+                # adam_optimizer.add_param_group(optim_groups[1])
+            else:
+                print0("using regular AdamW for non-Muon params")
+                adam_optimizer = torch.optim.AdamW(optim_groups, lr=adam_lr, betas=(0.9, 0.95), fused=use_fused)
+        
+        return [muon_optimizer, adam_optimizer]
+
+    # init the optimizer
+    if args.optimizer == "adam":
+        optimizers = configure_adam(model=raw_model_uncompiled, weight_decay=args.weight_decay,
+                                                   learning_rate=args.adam_lr, betas=(0.9, 0.95),
+                                                   device_type=device, zero_stage=zero_stage)
+    elif args.optimizer == "muon":
+        optimizers = configure_muon(
+            model=raw_model_uncompiled, 
+            weight_decay=args.muon_weight_decay,
+            muon_lr=args.muon_lr,
+            adam_lr=args.adam_lr,
+            momentum=args.muon_momentum,
+            nesterov=bool(args.muon_nesterov),
+            ns_steps=args.muon_ns_steps,
+            device_type=device,
+            zero_stage=zero_stage,
+            ddp_rank=ddp_rank,
+            ddp_world_size=ddp_world_size
+        )
+        # We'll use muon_optimizer and adam_optimizer separately
+
+    # learning rate decay scheduler (cosine with warmup)
+    def get_lr(it,base_lr):
+        # if args.optimizer == "adam":
+        #     base_lr = args.adam_lr
+        # else:  # muon
+        #     base_lr = args.muon_lr
+        min_lr = base_lr * args.lr_decay_frac
+        # 1) linear warmup for warmup_iters steps
+        if it < args.warmup_iters:
+            return base_lr * (it+1) / args.warmup_iters
+        # 2) if it > lr_decay_iters, return min learning rate
+        if it > args.num_iterations:
+            return min_lr
+        # 3) in between, use cosine decay down to min learning rate
+        decay_ratio = (it - args.warmup_iters) / (args.num_iterations - args.warmup_iters)
+        assert 0 <= decay_ratio <= 1
+        coeff = 0.5 * (1.0 + math.cos(math.pi * decay_ratio)) # coeff starts at 1 and goes to 0
+        return min_lr + coeff * (base_lr - min_lr)
+
+    def get_wsd_lr(it, base_lr):
+        min_lr = base_lr * args.lr_decay_frac
+        # cooldown_iters = int(args.num_iterations * 0.2)
+        cooldown_iters = int(0)
+        # 1) Warmup: linear warmup for warmup_iters steps
+        if it < args.warmup_iters:
+            return base_lr * (it + 1) / args.warmup_iters
+        # 3) Decay: linear decay from base_lr to min_lr in the last cooldown_iters steps
+        cooldown_start = args.num_iterations - cooldown_iters
+        if it >= cooldown_start:
+            decay_ratio = (it - cooldown_start) / cooldown_iters
+            return base_lr - decay_ratio * (base_lr - min_lr)
+        # 2) Stable: constant learning rate at base_lr
+        return base_lr
+
+    # create the logging directory if it does not exist
+    logfile = None
+    run_dir_path = None
+    
+    file_name  = f"mode_{args.optimizer}_adam_lr_{args.adam_lr}_muon_lr_{args.muon_lr}_seed_{args.seed}.log"
+    if args.output_dir:
+        base_log_dir = Path(args.output_dir)
+        base_log_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Create run-specific directory
+        # Generate UUID on master process and broadcast to all ranks
+        if master_process:
+            run_uuid = uuid.uuid4()
+            uuid_str = str(run_uuid)
+        else:
+            uuid_str = None
+        
+        # Broadcast UUID from rank 0 to all other ranks
+        if ddp:
+            # Create a tensor to hold the UUID string length and content
+            if master_process:
+                uuid_bytes = uuid_str.encode('utf-8')
+                uuid_len = len(uuid_bytes)
+            else:
+                uuid_len = 0
+            
+            # Broadcast length
+            uuid_len_tensor = torch.tensor(uuid_len, dtype=torch.long, device=device)
+            dist.broadcast(uuid_len_tensor, src=0)
+            
+            # Broadcast UUID string
+            if master_process:
+                uuid_tensor = torch.ByteTensor(list(uuid_bytes)).to(device)
+            else:
+                uuid_tensor = torch.ByteTensor([0] * uuid_len_tensor.item()).to(device)
+            dist.broadcast(uuid_tensor, src=0)
+            
+            # Decode on non-master processes
+            if not master_process:
+                uuid_str = bytes(uuid_tensor.cpu().numpy()).decode('utf-8')
+                run_uuid = uuid.UUID(uuid_str)
+            else:
+                run_uuid = uuid.UUID(uuid_str)
+        else:
+            run_uuid = uuid.uuid4()
+        
+        # run_folder_name = f"opt_{args.optimizer}_alr_{args.adam_lr}_mlr_{args.muon_lr}_seed_{args.seed}_{run_uuid}"
+        run_folder_name = f"opt_{args.optimizer}_alr_{args.adam_lr}_mlr_{args.muon_lr}_seed_{args.seed}"
+        run_dir_path = base_log_dir / run_folder_name
+        if run_dir_path.exists():
+            run_flag = False
+        else:
+            run_flag = True
+        torch.cuda.synchronize()
+        
+        
+        # Only master process creates the directory
+        if master_process:
+            run_dir_path.mkdir(parents=True, exist_ok=True)
+        
+        logfile = str(run_dir_path / "training_log.txt")
+        
+        # Save configuration
+    
+    if run_flag:
+        if master_process:
+            config_to_save = {
+                "cli_args": vars(args),
+                "run_uuid": 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)
+            print0(f"Saved configuration to: {config_file_path}")
+            
+        if master_process and logfile:
+            with open(logfile, "w") as f:
+                pass  # Create/clear the file
+            with open(logfile, "a") as f:
+                f.write(code)
+
+        if device == "cuda":
+            torch.cuda.reset_peak_memory_stats()
+        timings = []
+        norm = -1.0   # dummy value to print in inference-only mode
+        for step in range(args.num_iterations + 1):
+            t0 = time.time()
+            last_step = (step == args.num_iterations)
+
+            # once in a while evaluate the validation dataset
+            if (args.val_loss_every > 0 \
+                and (step % args.val_loss_every == 0 or last_step)) \
+                and (val_loader is not None):
+                model.eval()
+                val_loader.reset()
+                with torch.no_grad():
+                    val_loss = 0.0
+                    for _ in range(args.val_max_steps):
+                        x, y = val_loader.next_batch()
+                        x, y = x.to(device), y.to(device)
+                        _, loss = model(x, y, return_logits=False)
+                        val_loss += loss.item()
+                    val_loss /= args.val_max_steps
+                
+                # --- Comprehensive Sharpness Analysis ---
+                sharpness_log_str = ""
+                # Skip step 0 since we don't have a previous training update yet
+                if args.analyze_sharpness and step > 0 and (step % args.sharpness_analysis_interval == 0 or last_step):
+                    print0(f"[Sharpness @ Step {step}] Starting comprehensive sharpness analysis...")
+                    for optimizer in optimizers:
+                        if isinstance(optimizer, ZeroRedundancyOptimizer) or isinstance(optimizer, torch.optim.AdamW):
+                            optimizer.zero_grad(set_to_none=True)
+                        elif isinstance(optimizer, Muon):
+                            optimizer.zero_grad()
+                    comprehensive_results = calculate_comprehensive_sharpness(
+                        model=raw_model_uncompiled,  # Use uncompiled model for HVP (double backward)
+                        model_for_forward=model,     # Use compiled+DDP model for forward pass
+                        optimizers=optimizers,
+                        step=step,
+                        train_loader=train_loader,
+                        val_loader=val_loader,
+                        rank=ddp_rank,
+                        world_size=ddp_world_size,
+                        device=device,
+                        B=B,
+                        T=T,
+                        ptdtype=ptdtype,
+                        grad_accum_steps=grad_accum_steps,  # Pass grad accumulation steps to scale loss correctly
+                        last_training_update=last_training_update,  # Pass the real update captured from training
+                        last_training_gradient=last_training_gradient,  # Pass the original gradient g_t
+                        last_training_batches=last_training_batches  # Pass ALL microbatches for consistent HVP
+                    )
+                    sharpness_log_str = format_comprehensive_results(comprehensive_results)
+                    
+                    # Save sharpness results to file
+                    if master_process and run_dir_path:
+                        sharpness_file = run_dir_path / f"sharpness_step_{step}.json"
+                        with open(sharpness_file, "w") as f:
+                            json.dump(comprehensive_results, f, indent=4)
+                        print0(f"[Sharpness @ Step {step}] Results saved to {sharpness_file}")
+                    
+                    # Clean up memory after sharpness analysis
+                    del comprehensive_results
+                    # Ensure all CUDA operations are complete before cleaning up
+                    if device == "cuda":
+                        torch.cuda.synchronize()
+                    torch.cuda.empty_cache()
+                    gc.collect()
+                    if ddp:
+                        dist.barrier()  # Sync all ranks after cleanup
+                    print0(f"[Step {step}] Memory cleaned up after sharpness analysis")
+                
+                # log to console and to file
+                if sharpness_log_str:
+                    print0(f"step {step}/{args.num_iterations} | val loss {val_loss:.6f} | {sharpness_log_str}")
+                else:
+                    print0(f"step {step}/{args.num_iterations} | val loss {val_loss:.6f}")
+                
+                if master_process and logfile is not None:
+                    with open(logfile, "a") as f:
+                        f.write("step:%d validation loss:%f" % (step, val_loss))
+                        if sharpness_log_str:
+                            f.write(" %s" % sharpness_log_str)
+                        f.write("\n")
+
+            # once in a while perform model inference on the master process
+            if (args.sample_every > 0 \
+                and (step % args.sample_every == 0 or last_step)) \
+                and master_process:
+                model.eval()
+                # before we end, let's also do one round of inference
+                # we'll kick off the generation with "<|endoftext|>", which designates the start of a new sequence
+                start_ids = [enc.eot_token]
+                xg = (torch.tensor(start_ids, dtype=torch.long, device=device)[None, ...])
+                max_new_tokens = 32
+                temperature = 1.0
+                top_k = 40
+                yg = raw_model.generate(xg, max_new_tokens, temperature=temperature, top_k=top_k)
+                print0('---------------')
+                print0(enc.decode(yg[0].tolist()))
+                print0('---------------')
+
+            # bit confusing: we want to make sure to eval and sample 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()
+            # Zero gradients for the appropriate optimizer(s)
+
+            for optimizer in optimizers:
+                if isinstance(optimizer, ZeroRedundancyOptimizer) or isinstance(optimizer, torch.optim.AdamW):
+                    optimizer.zero_grad(set_to_none=True)
+                elif isinstance(optimizer, Muon):
+                    optimizer.zero_grad()
+            # if args.optimizer == "adam":
+            #     optimizer.zero_grad(set_to_none=True)
+            # else:  # muon
+            #     if muon_optimizer is not None:
+            #         muon_optimizer.zero_grad()
+            #     if adam_optimizer is not None:
+            #         adam_optimizer.zero_grad(set_to_none=True)
+            # if we are trying to overfit a single batch, we reset the loader here
+            if args.overfit_single_batch:
+                train_loader.reset()
+            # micro-batch loop where we do gradient accumulation to reach desired total batch size
+            lossf = 0.0 # for getting the mean loss (as simple float) over the accumulation steps
+            
+            # Pre-check if we need to collect microbatches for sharpness analysis
+            next_step = step + 1
+            will_analyze_sharpness_next = args.analyze_sharpness and next_step > 0 and (
+                (next_step % args.sharpness_analysis_interval == 0) or 
+                (next_step == args.num_iterations)
+            )
+            
+
+            microbatches_this_step = [] if will_analyze_sharpness_next else None
+            
+            for micro_step in range(grad_accum_steps):
+                # fetch a batch
+                x, y = train_loader.next_batch()
+                x, y = x.to(device), y.to(device)
+                
+                # Store ALL microbatches for memory-efficient HVP calculation
+                if will_analyze_sharpness_next:
+                    microbatches_this_step.append((x.detach().clone(), y.detach().clone()))
+                
+                if ddp:
+                    model.require_backward_grad_sync = (micro_step == grad_accum_steps - 1)
+                # forward pass
+                with ctx:
+                    _, loss = model(x, y, return_logits=False)
+                    loss = loss / grad_accum_steps
+                    lossf += loss.detach() # keep track of the mean loss
+                # backward pass
+                if not args.inference_only:
+                    loss.backward()
+            if ddp:
+                dist.all_reduce(lossf, op=dist.ReduceOp.AVG)
+            lossf = lossf.item()
+            
+            #no clipping
+            norm = torch.nn.utils.clip_grad_norm_(raw_model_uncompiled.parameters(), args.grad_clip)
+            
+            
+            if will_analyze_sharpness_next:
+                # Use raw_model_uncompiled's parameter order so it matches sharpness analysis codepaths.
+                # (DDP/torch.compile wrappers can be a footgun if parameter iteration order ever diverges.)
+                print(raw_model_uncompiled.transformer.h[0].attn.q_w.weight[:5,:5])
+                params_before_optimizer_step = [p.detach().clone() for p in raw_model_uncompiled.parameters()]
+                # Save the original gradient g_t that will produce the update v
+                last_training_gradient = [
+                    p.grad.detach().clone() if p.grad is not None else torch.zeros_like(p)
+                    for p in raw_model_uncompiled.parameters()
+                ]
+                # Capture ALL microbatches for consistent HVP calculation
+                # This ensures H is computed on the exact same objective as g_t and v
+                last_training_batches = microbatches_this_step  # Already cloned above
+            else:
+                params_before_optimizer_step = None
+                last_training_batches = None
+            
+            # Update learning rate and step optimizers
+            for optimizer in optimizers:
+                if isinstance(optimizer, ZeroRedundancyOptimizer) or isinstance(optimizer, torch.optim.AdamW):
+                    adam_lr = get_wsd_lr(step,args.adam_lr)
+                    for param_group in optimizer.param_groups:
+                        param_group['lr'] = adam_lr
+                    optimizer.step()
+                elif isinstance(optimizer, Muon):
+                    muon_lr = get_wsd_lr(step,args.muon_lr)
+                    for param_group in optimizer.param_groups:
+                        param_group['lr'] = muon_lr
+                    optimizer.step()
+                else:
+                    raise ValueError(f"Unsupported optimizer: {type(optimizer)}")
+            
+            
+            if params_before_optimizer_step is not None:
+                # Clean up old update to save memory
+                if last_training_update is not None:
+                    del last_training_update
+                
+                last_training_update = [
+                    p.detach() - p_before
+                    for p_before, p in zip(params_before_optimizer_step, raw_model_uncompiled.parameters())
+                ]
+                del params_before_optimizer_step
+            
+            # --------------- TRAINING SECTION END -------------------
+
+            # wait on the CPU for all device work to end so we get accurate per-iteration timings below
+            if device == "mps":
+                torch.mps.synchronize()
+            elif device == "cuda":
+                torch.cuda.synchronize()
+            # time and print
+            t1 = time.time()
+            # the 0th iteration is often an outlier (much slower) => skip logging it
+            tokens_per_second = grad_accum_steps * ddp_world_size * B * T / (t1-t0)
+            print0(f"step {step+1:4d}/{args.num_iterations} | train loss {lossf:.6f} | norm {norm:.4f} | ({(t1-t0)*1000:.2f} ms | {tokens_per_second:.0f} tok/s)")
+            # log to logile
+            if master_process and logfile is not None:
+                with open(logfile, "a") as f:
+                    f.write("step:%d train loss:%f\n" % (step, lossf))
+
+            # keep track of smooth timings, last 20 iterations
+            if step > 0 and step > args.num_iterations - 20:
+                timings.append(t1-t0)
+
+        # print the average of the last 20 timings, to get something smooth-ish
+        timings = timings[-20:]
+        print0(f"final {len(timings)} iters avg: {np.mean(timings)*1000:.3f}ms")
+        print0(f"peak memory consumption: {torch.cuda.max_memory_allocated() // 1024 // 1024} MiB")
+
+        # -------------------------------------------------------------------------
+        # clean up nice
+    if ddp:
+        destroy_process_group()step:0 validation loss:11.020914
+step:0 train loss:11.018947
+step:1 train loss:11.015901
+step:2 train loss:11.001139
+step:3 train loss:10.974218
+step:4 train loss:10.947017
+step:5 train loss:10.921179
+step:6 train loss:10.861053
+step:7 train loss:10.812024
+step:8 train loss:10.757435
+step:9 train loss:10.703061
+step:10 train loss:10.627495
+step:11 train loss:10.570812
+step:12 train loss:10.518988
+step:13 train loss:10.450851
+step:14 train loss:10.389409
+step:15 train loss:10.324161
+step:16 train loss:10.293379
+step:17 train loss:10.256920
+step:18 train loss:10.199411
+step:19 train loss:10.153182
+step:20 train loss:10.085126
+step:21 train loss:10.072214
+step:22 train loss:10.032795
+step:23 train loss:9.983107
+step:24 train loss:9.939043
+step:25 train loss:9.952696
+step:26 train loss:9.890882
+step:27 train loss:9.873850
+step:28 train loss:9.837166
+step:29 train loss:9.804578
+step:30 train loss:9.789116
+step:31 train loss:9.762375
+step:32 train loss:9.722699
+step:33 train loss:9.734813
+step:34 train loss:9.722623
+step:35 train loss:9.703139
+step:36 train loss:9.685809
+step:37 train loss:9.658072
+step:38 train loss:9.661681
+step:39 train loss:9.631407
+step:40 train loss:9.609830
+step:41 train loss:9.626093
+step:42 train loss:9.632925
+step:43 train loss:9.592793
+step:44 train loss:9.580933
+step:45 train loss:9.595030
+step:46 train loss:9.563819
+step:47 train loss:9.542810
+step:48 train loss:9.543258
+step:49 train loss:9.526043
+step:50 train loss:9.511073
+step:51 train loss:9.493608
+step:52 train loss:9.483408
+step:53 train loss:9.484899
+step:54 train loss:9.470613
+step:55 train loss:9.465339
+step:56 train loss:9.434980
+step:57 train loss:9.422531
+step:58 train loss:9.431874
+step:59 train loss:9.385880
+step:60 train loss:9.388974
+step:61 train loss:9.419999
+step:62 train loss:9.358437
+step:63 train loss:9.337664
+step:64 train loss:9.336971
+step:65 train loss:9.322704
+step:66 train loss:9.252651
+step:67 train loss:9.313890
+step:68 train loss:9.279621
+step:69 train loss:9.212382
+step:70 train loss:9.240768
+step:71 train loss:9.234261
+step:72 train loss:9.163614
+step:73 train loss:9.146738
+step:74 train loss:9.177152
+step:75 train loss:9.150363
+step:76 train loss:9.106675
+step:77 train loss:9.146784
+step:78 train loss:9.107823
+step:79 train loss:9.082148
+step:80 train loss:9.059367
+step:81 train loss:9.079405
+step:82 train loss:9.099257
+step:83 train loss:9.031517
+step:84 train loss:9.043550
+step:85 train loss:9.016241
+step:86 train loss:8.968640
+step:87 train loss:8.988386
+step:88 train loss:8.979951
+step:89 train loss:8.933968
+step:90 train loss:8.959427
+step:91 train loss:8.941217
+step:92 train loss:8.921014
+step:93 train loss:8.867045
+step:94 train loss:8.873112
+step:95 train loss:8.868813
+step:96 train loss:8.847641
+step:97 train loss:8.841789
+step:98 train loss:8.850140
+step:99 train loss:8.791707
+step:100 train loss:8.756621
+step:101 train loss:8.784798
+step:102 train loss:8.775515
+step:103 train loss:8.782326
+step:104 train loss:8.687901
+step:105 train loss:8.757630
+step:106 train loss:8.700429
+step:107 train loss:8.685413
+step:108 train loss:8.628991
+step:109 train loss:8.796276
+step:110 train loss:8.646223
+step:111 train loss:8.637555
+step:112 train loss:8.621561

logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm/opt_adam_alr_0.0002_mlr_0.01_seed_43/config.json

@@ -0,0 +1,41 @@
+{
+    "cli_args": {
+        "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",
+        "output_dir": "/home/aiops/zhangfz/MUON_sharpness/logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm",
+        "model": "d12",
+        "batch_size": 4,
+        "sequence_length": 1024,
+        "total_batch_size": 524288,
+        "num_iterations": 10000,
+        "inference_only": 0,
+        "adam_lr": 0.0002,
+        "warmup_iters": 1500,
+        "lr_decay_frac": 0.0,
+        "weight_decay": 0.0,
+        "grad_clip": 100000.0,
+        "val_loss_every": 250,
+        "val_max_steps": 20,
+        "sample_every": 0,
+        "overfit_single_batch": 0,
+        "shuffle_files": true,
+        "tensorcores": 1,
+        "device": "",
+        "compile": 1,
+        "flash": 1,
+        "dtype": "bfloat16",
+        "zero_stage": 1,
+        "optimizer": "adam",
+        "muon_lr": 0.01,
+        "muon_momentum": 0.95,
+        "muon_weight_decay": 0.0,
+        "muon_ns_steps": 5,
+        "muon_nesterov": false,
+        "write_tensors": 0,
+        "seed": 43,
+        "analyze_sharpness": false,
+        "sharpness_analysis_interval": 500
+    },
+    "run_uuid": "8b654986-1317-48b5-9e08-c1064a25bd30",
+    "script_code_logged_at_start": true
+}

logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm/opt_adam_alr_0.0002_mlr_0.01_seed_44/config.json

@@ -0,0 +1,41 @@
+{
+    "cli_args": {
+        "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",
+        "output_dir": "/home/aiops/zhangfz/MUON_sharpness/logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm",
+        "model": "d12",
+        "batch_size": 4,
+        "sequence_length": 1024,
+        "total_batch_size": 524288,
+        "num_iterations": 10000,
+        "inference_only": 0,
+        "adam_lr": 0.0002,
+        "warmup_iters": 1500,
+        "lr_decay_frac": 0.0,
+        "weight_decay": 0.0,
+        "grad_clip": 100000.0,
+        "val_loss_every": 250,
+        "val_max_steps": 20,
+        "sample_every": 0,
+        "overfit_single_batch": 0,
+        "shuffle_files": true,
+        "tensorcores": 1,
+        "device": "",
+        "compile": 1,
+        "flash": 1,
+        "dtype": "bfloat16",
+        "zero_stage": 1,
+        "optimizer": "adam",
+        "muon_lr": 0.01,
+        "muon_momentum": 0.95,
+        "muon_weight_decay": 0.0,
+        "muon_ns_steps": 5,
+        "muon_nesterov": false,
+        "write_tensors": 0,
+        "seed": 44,
+        "analyze_sharpness": false,
+        "sharpness_analysis_interval": 500
+    },
+    "run_uuid": "844818d1-11a7-4b2f-9276-af4502cf3ab0",
+    "script_code_logged_at_start": true
+}

logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm/opt_adam_alr_0.0005_mlr_0.01_seed_42/config.json

@@ -0,0 +1,41 @@
+{
+    "cli_args": {
+        "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",
+        "output_dir": "/home/aiops/zhangfz/MUON_sharpness/logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm",
+        "model": "d12",
+        "batch_size": 4,
+        "sequence_length": 1024,
+        "total_batch_size": 524288,
+        "num_iterations": 10000,
+        "inference_only": 0,
+        "adam_lr": 0.0005,
+        "warmup_iters": 1500,
+        "lr_decay_frac": 0.0,
+        "weight_decay": 0.0,
+        "grad_clip": 100000.0,
+        "val_loss_every": 250,
+        "val_max_steps": 20,
+        "sample_every": 0,
+        "overfit_single_batch": 0,
+        "shuffle_files": true,
+        "tensorcores": 1,
+        "device": "",
+        "compile": 1,
+        "flash": 1,
+        "dtype": "bfloat16",
+        "zero_stage": 1,
+        "optimizer": "adam",
+        "muon_lr": 0.01,
+        "muon_momentum": 0.95,
+        "muon_weight_decay": 0.0,
+        "muon_ns_steps": 5,
+        "muon_nesterov": false,
+        "write_tensors": 0,
+        "seed": 42,
+        "analyze_sharpness": false,
+        "sharpness_analysis_interval": 500
+    },
+    "run_uuid": "35307a01-6527-4f49-8de1-26bf220d63a5",
+    "script_code_logged_at_start": true
+}

logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm/opt_adam_alr_0.0005_mlr_0.01_seed_43/config.json

@@ -0,0 +1,41 @@
+{
+    "cli_args": {
+        "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",
+        "output_dir": "/home/aiops/zhangfz/MUON_sharpness/logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm",
+        "model": "d12",
+        "batch_size": 4,
+        "sequence_length": 1024,
+        "total_batch_size": 524288,
+        "num_iterations": 10000,
+        "inference_only": 0,
+        "adam_lr": 0.0005,
+        "warmup_iters": 1500,
+        "lr_decay_frac": 0.0,
+        "weight_decay": 0.0,
+        "grad_clip": 100000.0,
+        "val_loss_every": 250,
+        "val_max_steps": 20,
+        "sample_every": 0,
+        "overfit_single_batch": 0,
+        "shuffle_files": true,
+        "tensorcores": 1,
+        "device": "",
+        "compile": 1,
+        "flash": 1,
+        "dtype": "bfloat16",
+        "zero_stage": 1,
+        "optimizer": "adam",
+        "muon_lr": 0.01,
+        "muon_momentum": 0.95,
+        "muon_weight_decay": 0.0,
+        "muon_ns_steps": 5,
+        "muon_nesterov": false,
+        "write_tensors": 0,
+        "seed": 43,
+        "analyze_sharpness": false,
+        "sharpness_analysis_interval": 500
+    },
+    "run_uuid": "0ebf0760-8c51-44f3-8325-aed663a64a9c",
+    "script_code_logged_at_start": true
+}

logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm/opt_adam_alr_0.0005_mlr_0.01_seed_44/config.json

@@ -0,0 +1,41 @@
+{
+    "cli_args": {
+        "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",
+        "output_dir": "/home/aiops/zhangfz/MUON_sharpness/logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm",
+        "model": "d12",
+        "batch_size": 4,
+        "sequence_length": 1024,
+        "total_batch_size": 524288,
+        "num_iterations": 10000,
+        "inference_only": 0,
+        "adam_lr": 0.0005,
+        "warmup_iters": 1500,
+        "lr_decay_frac": 0.0,
+        "weight_decay": 0.0,
+        "grad_clip": 100000.0,
+        "val_loss_every": 250,
+        "val_max_steps": 20,
+        "sample_every": 0,
+        "overfit_single_batch": 0,
+        "shuffle_files": true,
+        "tensorcores": 1,
+        "device": "",
+        "compile": 1,
+        "flash": 1,
+        "dtype": "bfloat16",
+        "zero_stage": 1,
+        "optimizer": "adam",
+        "muon_lr": 0.01,
+        "muon_momentum": 0.95,
+        "muon_weight_decay": 0.0,
+        "muon_ns_steps": 5,
+        "muon_nesterov": false,
+        "write_tensors": 0,
+        "seed": 44,
+        "analyze_sharpness": false,
+        "sharpness_analysis_interval": 500
+    },
+    "run_uuid": "95c102cc-02c4-4501-8021-b8881b637d8c",
+    "script_code_logged_at_start": true
+}

logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm/opt_adam_alr_0.001_mlr_0.01_seed_42/config.json

@@ -0,0 +1,41 @@
+{
+    "cli_args": {
+        "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",
+        "output_dir": "/home/aiops/zhangfz/MUON_sharpness/logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm",
+        "model": "d12",
+        "batch_size": 4,
+        "sequence_length": 1024,
+        "total_batch_size": 524288,
+        "num_iterations": 10000,
+        "inference_only": 0,
+        "adam_lr": 0.001,
+        "warmup_iters": 1500,
+        "lr_decay_frac": 0.0,
+        "weight_decay": 0.0,
+        "grad_clip": 100000.0,
+        "val_loss_every": 250,
+        "val_max_steps": 20,
+        "sample_every": 0,
+        "overfit_single_batch": 0,
+        "shuffle_files": true,
+        "tensorcores": 1,
+        "device": "",
+        "compile": 1,
+        "flash": 1,
+        "dtype": "bfloat16",
+        "zero_stage": 1,
+        "optimizer": "adam",
+        "muon_lr": 0.01,
+        "muon_momentum": 0.95,
+        "muon_weight_decay": 0.0,
+        "muon_ns_steps": 5,
+        "muon_nesterov": false,
+        "write_tensors": 0,
+        "seed": 42,
+        "analyze_sharpness": false,
+        "sharpness_analysis_interval": 500
+    },
+    "run_uuid": "243865af-2ce2-43f3-8609-4742cef9ebe0",
+    "script_code_logged_at_start": true
+}

logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm/opt_adam_alr_0.001_mlr_0.01_seed_43/config.json

@@ -0,0 +1,41 @@
+{
+    "cli_args": {
+        "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",
+        "output_dir": "/home/aiops/zhangfz/MUON_sharpness/logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm",
+        "model": "d12",
+        "batch_size": 4,
+        "sequence_length": 1024,
+        "total_batch_size": 524288,
+        "num_iterations": 10000,
+        "inference_only": 0,
+        "adam_lr": 0.001,
+        "warmup_iters": 1500,
+        "lr_decay_frac": 0.0,
+        "weight_decay": 0.0,
+        "grad_clip": 100000.0,
+        "val_loss_every": 250,
+        "val_max_steps": 20,
+        "sample_every": 0,
+        "overfit_single_batch": 0,
+        "shuffle_files": true,
+        "tensorcores": 1,
+        "device": "",
+        "compile": 1,
+        "flash": 1,
+        "dtype": "bfloat16",
+        "zero_stage": 1,
+        "optimizer": "adam",
+        "muon_lr": 0.01,
+        "muon_momentum": 0.95,
+        "muon_weight_decay": 0.0,
+        "muon_ns_steps": 5,
+        "muon_nesterov": false,
+        "write_tensors": 0,
+        "seed": 43,
+        "analyze_sharpness": false,
+        "sharpness_analysis_interval": 500
+    },
+    "run_uuid": "6347f5e5-e9d1-445c-aeb1-8231b5c874aa",
+    "script_code_logged_at_start": true
+}

logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm/opt_adam_alr_0.001_mlr_0.01_seed_44/config.json

@@ -0,0 +1,41 @@
+{
+    "cli_args": {
+        "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",
+        "output_dir": "/home/aiops/zhangfz/MUON_sharpness/logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm",
+        "model": "d12",
+        "batch_size": 4,
+        "sequence_length": 1024,
+        "total_batch_size": 524288,
+        "num_iterations": 10000,
+        "inference_only": 0,
+        "adam_lr": 0.001,
+        "warmup_iters": 1500,
+        "lr_decay_frac": 0.0,
+        "weight_decay": 0.0,
+        "grad_clip": 100000.0,
+        "val_loss_every": 250,
+        "val_max_steps": 20,
+        "sample_every": 0,
+        "overfit_single_batch": 0,
+        "shuffle_files": true,
+        "tensorcores": 1,
+        "device": "",
+        "compile": 1,
+        "flash": 1,
+        "dtype": "bfloat16",
+        "zero_stage": 1,
+        "optimizer": "adam",
+        "muon_lr": 0.01,
+        "muon_momentum": 0.95,
+        "muon_weight_decay": 0.0,
+        "muon_ns_steps": 5,
+        "muon_nesterov": false,
+        "write_tensors": 0,
+        "seed": 44,
+        "analyze_sharpness": false,
+        "sharpness_analysis_interval": 500
+    },
+    "run_uuid": "1aa19b22-d653-4300-a823-9aed4bcc29d2",
+    "script_code_logged_at_start": true
+}

logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm/opt_adam_alr_0.002_mlr_0.01_seed_42/config.json

@@ -0,0 +1,41 @@
+{
+    "cli_args": {
+        "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",
+        "output_dir": "/home/aiops/zhangfz/MUON_sharpness/logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm",
+        "model": "d12",
+        "batch_size": 4,
+        "sequence_length": 1024,
+        "total_batch_size": 524288,
+        "num_iterations": 10000,
+        "inference_only": 0,
+        "adam_lr": 0.002,
+        "warmup_iters": 1500,
+        "lr_decay_frac": 0.0,
+        "weight_decay": 0.0,
+        "grad_clip": 100000.0,
+        "val_loss_every": 250,
+        "val_max_steps": 20,
+        "sample_every": 0,
+        "overfit_single_batch": 0,
+        "shuffle_files": true,
+        "tensorcores": 1,
+        "device": "",
+        "compile": 1,
+        "flash": 1,
+        "dtype": "bfloat16",
+        "zero_stage": 1,
+        "optimizer": "adam",
+        "muon_lr": 0.01,
+        "muon_momentum": 0.95,
+        "muon_weight_decay": 0.0,
+        "muon_ns_steps": 5,
+        "muon_nesterov": false,
+        "write_tensors": 0,
+        "seed": 42,
+        "analyze_sharpness": false,
+        "sharpness_analysis_interval": 500
+    },
+    "run_uuid": "158aab84-4c15-43a1-b32b-e91df5d7b08c",
+    "script_code_logged_at_start": true
+}

logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm/opt_adam_alr_0.002_mlr_0.01_seed_43/config.json

@@ -0,0 +1,41 @@
+{
+    "cli_args": {
+        "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",
+        "output_dir": "/home/aiops/zhangfz/MUON_sharpness/logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm",
+        "model": "d12",
+        "batch_size": 4,
+        "sequence_length": 1024,
+        "total_batch_size": 524288,
+        "num_iterations": 10000,
+        "inference_only": 0,
+        "adam_lr": 0.002,
+        "warmup_iters": 1500,
+        "lr_decay_frac": 0.0,
+        "weight_decay": 0.0,
+        "grad_clip": 100000.0,
+        "val_loss_every": 250,
+        "val_max_steps": 20,
+        "sample_every": 0,
+        "overfit_single_batch": 0,
+        "shuffle_files": true,
+        "tensorcores": 1,
+        "device": "",
+        "compile": 1,
+        "flash": 1,
+        "dtype": "bfloat16",
+        "zero_stage": 1,
+        "optimizer": "adam",
+        "muon_lr": 0.01,
+        "muon_momentum": 0.95,
+        "muon_weight_decay": 0.0,
+        "muon_ns_steps": 5,
+        "muon_nesterov": false,
+        "write_tensors": 0,
+        "seed": 43,
+        "analyze_sharpness": false,
+        "sharpness_analysis_interval": 500
+    },
+    "run_uuid": "90d01ca9-df46-40ad-a3e5-b6f274313dd1",
+    "script_code_logged_at_start": true
+}

logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm/opt_adam_alr_0.002_mlr_0.01_seed_44/config.json

@@ -0,0 +1,41 @@
+{
+    "cli_args": {
+        "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",
+        "output_dir": "/home/aiops/zhangfz/MUON_sharpness/logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm",
+        "model": "d12",
+        "batch_size": 4,
+        "sequence_length": 1024,
+        "total_batch_size": 524288,
+        "num_iterations": 10000,
+        "inference_only": 0,
+        "adam_lr": 0.002,
+        "warmup_iters": 1500,
+        "lr_decay_frac": 0.0,
+        "weight_decay": 0.0,
+        "grad_clip": 100000.0,
+        "val_loss_every": 250,
+        "val_max_steps": 20,
+        "sample_every": 0,
+        "overfit_single_batch": 0,
+        "shuffle_files": true,
+        "tensorcores": 1,
+        "device": "",
+        "compile": 1,
+        "flash": 1,
+        "dtype": "bfloat16",
+        "zero_stage": 1,
+        "optimizer": "adam",
+        "muon_lr": 0.01,
+        "muon_momentum": 0.95,
+        "muon_weight_decay": 0.0,
+        "muon_ns_steps": 5,
+        "muon_nesterov": false,
+        "write_tensors": 0,
+        "seed": 44,
+        "analyze_sharpness": false,
+        "sharpness_analysis_interval": 500
+    },
+    "run_uuid": "8b031d99-ab22-4c6c-ba27-d51289e64de3",
+    "script_code_logged_at_start": true
+}

logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm/opt_adam_alr_0.005_mlr_0.01_seed_42/config.json

@@ -0,0 +1,41 @@
+{
+    "cli_args": {
+        "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",
+        "output_dir": "/home/aiops/zhangfz/MUON_sharpness/logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm",
+        "model": "d12",
+        "batch_size": 4,
+        "sequence_length": 1024,
+        "total_batch_size": 524288,
+        "num_iterations": 10000,
+        "inference_only": 0,
+        "adam_lr": 0.005,
+        "warmup_iters": 1500,
+        "lr_decay_frac": 0.0,
+        "weight_decay": 0.0,
+        "grad_clip": 100000.0,
+        "val_loss_every": 250,
+        "val_max_steps": 20,
+        "sample_every": 0,
+        "overfit_single_batch": 0,
+        "shuffle_files": true,
+        "tensorcores": 1,
+        "device": "",
+        "compile": 1,
+        "flash": 1,
+        "dtype": "bfloat16",
+        "zero_stage": 1,
+        "optimizer": "adam",
+        "muon_lr": 0.01,
+        "muon_momentum": 0.95,
+        "muon_weight_decay": 0.0,
+        "muon_ns_steps": 5,
+        "muon_nesterov": false,
+        "write_tensors": 0,
+        "seed": 42,
+        "analyze_sharpness": false,
+        "sharpness_analysis_interval": 500
+    },
+    "run_uuid": "dc7eaf93-71ea-4340-b7cb-7436b55e754d",
+    "script_code_logged_at_start": true
+}

logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm/opt_adam_alr_0.005_mlr_0.01_seed_42/training_log.txt

@@ -0,0 +1,1819 @@
+"""
+Reference code for GPT-2 training and inference with Sharpness Analysis.
+Will save the model weights into files, to be read from C as initialization.
+
+References:
+1) the official GPT-2 TensorFlow implementation released by OpenAI:
+https://github.com/openai/gpt-2/blob/master/src/model.py
+2) huggingface/transformers PyTorch implementation:
+https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt2/modeling_gpt2.py
+
+Example launches to only benchmark the speed of bfloat16 compiled GPU training:
+1 GPU:
+python train_gpt2.py --write_tensors=0 --num_iterations=50 --sequence_length=1024 --compile=1 --tensorcores=1 --dtype=bfloat16
+you can also turn on flash-attention by appending --flash=1
+4 GPU:
+torchrun --standalone --nproc_per_node=4 train_gpt2.py --write_tensors=0 --num_iterations=50 --sequence_length=1024 --compile=1 --tensorcores=1 --dtype=bfloat16
+"""
+import sys
+with open(sys.argv[0]) as f:
+    code = f.read() # read the code of this file ASAP, for logging
+
+import os
+import math
+import glob
+import struct
+import inspect
+from contextlib import nullcontext
+from dataclasses import dataclass
+import random
+
+import numpy as np
+import torch
+from torch import Tensor
+import torch.nn as nn
+from torch.nn import functional as F
+import torch._inductor.config as config
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.distributed import init_process_group, destroy_process_group
+from torch.distributed.optim import ZeroRedundancyOptimizer
+import torch.distributed as dist
+from torch.amp import autocast
+import copy
+import gc
+import uuid
+import json
+from pathlib import Path
+
+# Import Muon optimizer
+import sys
+sys.path.append("/home/aiops/zhangfz/MUON_sharpness/modded-nanogpt/optimizers")
+from MUON_fix import Muon
+
+# Import GPT model
+sys.path.append("/home/aiops/zhangfz/MUON_sharpness/modded-nanogpt/models")
+import  nano_GPT_qkvonorm_pure
+from nano_GPT_qkvonorm_pure import GPT, GPTConfig
+
+# Import debug utilities
+# from debug_utils import setup_debugpy
+
+# -----------------------------------------------------------------------------
+# 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,
+                 shuffle_files=False, random_seed=None):
+        self.process_rank = process_rank
+        self.num_processes = num_processes
+        self.B = B
+        self.T = T
+        self.shuffle_files = shuffle_files
+        self.random_seed = random_seed
+        self._rng = random.Random(random_seed) if shuffle_files and random_seed is not None else None
+
+        # 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}"
+        if self.shuffle_files:
+            self._shuffle_files()
+
+        # 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 += shard_ntok
+        self.ntok_total = ntok_total
+        print0(f"DataLoader: total number of tokens: {ntok_total:,} across {len(self.files)} files")
+
+        # kick things off
+        self.current_shard = None
+        self.reset()
+
+    def reset(self):
+        # we're being a bit clever here: if we already had shard 0 loaded,
+        # then don't do the work to reload it, just reset the pointer
+        if self.current_shard != 0:
+            self.current_shard = 0
+            self.tokens = _load_data_shard(self.files[self.current_shard])
+        self.current_position = self.process_rank * self.B * self.T
+
+    def advance(self): # advance to next data shard
+        next_shard = (self.current_shard + 1) % len(self.files)
+        if next_shard == 0 and self.shuffle_files:
+            self._shuffle_files()
+        self.current_shard = next_shard
+        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 the start pointer in current shard
+        self.current_position += B * T * self.num_processes
+        # if loading the next batch would be out of bounds advance the shard
+        if self.current_position + (B * T * self.num_processes + 1) > len(self.tokens):
+            self.advance()
+        return x, y
+
+    def _shuffle_files(self):
+        if self._rng is not None:
+            self._rng.shuffle(self.files)
+        else:
+            random.shuffle(self.files)
+
+# -----------------------------------------------------------------------------
+# Python -> C bridge utilities for saving params/grads/activations to .bin files
+
+def write_fp32(tensor, file):
+    t = tensor.detach().cpu().to(torch.float32)
+    b = t.numpy().tobytes()
+    file.write(b)
+
+def write_bf16(tensor, file):
+    t = tensor.detach().cpu().to(torch.bfloat16)
+    # numpy doesn't have bf16 datatype so we have to trick it
+    t = t.view(torch.int16) # trick: reinterpret as int16
+    b = t.numpy().tobytes()
+    file.write(b)
+
+def write_tensors(model_tensors, L, file, dtype):
+    # writes the GPT-2 model's weights to a binary file
+    assert dtype in {"float32", "bfloat16"}
+    write_fun = write_fp32 if dtype == "float32" else write_bf16
+    write_fun(model_tensors["transformer.wte.weight"], file) # (V, C)
+    write_fun(model_tensors["transformer.wpe.weight"], file) # (T, C)
+    for i in range(L): # (L, C)
+        write_fun(model_tensors[f"transformer.h.{i}.ln_1.weight"], file)
+    for i in range(L): # (L, C)
+        write_fun(model_tensors[f"transformer.h.{i}.ln_1.bias"], file)
+    for i in range(L): # (L, 3C, C)
+        write_fun(model_tensors[f"transformer.h.{i}.attn.c_attn.weight"], file)
+    for i in range(L): # (L, 3C)
+        write_fun(model_tensors[f"transformer.h.{i}.attn.c_attn.bias"], file)
+    for i in range(L): # (L, C, C)
+        write_fun(model_tensors[f"transformer.h.{i}.attn.c_proj.weight"], file)
+    for i in range(L): # (L, C)
+        write_fun(model_tensors[f"transformer.h.{i}.attn.c_proj.bias"], file)
+    for i in range(L): # (L, C)
+        write_fun(model_tensors[f"transformer.h.{i}.ln_2.weight"], file)
+    for i in range(L): # (L, C)
+        write_fun(model_tensors[f"transformer.h.{i}.ln_2.bias"], file)
+    for i in range(L): # (L, 4C, C)
+        write_fun(model_tensors[f"transformer.h.{i}.mlp.c_fc.weight"], file)
+    for i in range(L): # (L, 4C)
+        write_fun(model_tensors[f"transformer.h.{i}.mlp.c_fc.bias"], file)
+    for i in range(L): # (L, C, 4C)
+        write_fun(model_tensors[f"transformer.h.{i}.mlp.c_proj.weight"], file)
+    for i in range(L): # (L, C)
+        write_fun(model_tensors[f"transformer.h.{i}.mlp.c_proj.bias"], file)
+    write_fun(model_tensors["transformer.ln_f.weight"], file) # (C, )
+    write_fun(model_tensors["transformer.ln_f.bias"], file) # (C, )
+
+@torch.no_grad()
+def pad_vocab(tensor, multiple=128, value=0):
+    """
+    The dimension of the vocab size in GPT-2 is 50,257
+    which is unfortunately a very unfriendly number for a lot of
+    matrix operations on the GPU. So we pad it to the nearest
+    friendlier multiple, e.g. 50,304 if multiple=128 when we
+    export the weights into C land. This is a NOOP algorithmically
+    and is only done to make the tensor operations more efficient.
+    """
+    assert tensor.ndim == 2
+    V, C = tensor.shape
+    assert V == 50257, "just being defensive here"
+    # calculate padded vocab size by rounding up to nearest multiple
+    Vp = ((V + multiple - 1) // multiple) * multiple
+    # pad the tensor
+    pad_rows = Vp - V
+    padded = tensor if pad_rows == 0 else F.pad(tensor, (0, 0, 0, pad_rows), value=value)
+    assert padded.shape == (Vp, C)
+    return padded
+
+def write_model(model, filename, dtype):
+    # everything we need to instantiate the model
+    # 1) header is: version int, GPTConfig ints, padding to 1024 bytes
+    assert dtype in {"float32", "bfloat16"} # float16 todo maybe later
+    version = {
+        "float32": 3, # 3: all tensors are fp32, padded vocab
+        "bfloat16": 5, # 5: all tensors are bf16, padded vocab
+    }[dtype]
+    header = torch.zeros(256, dtype=torch.int32)
+    header[0] = 20240326 # magic
+    header[1] = version # checkpoint version
+    header[2] = model.config.block_size
+    header[3] = model.config.vocab_size
+    header[4] = model.config.n_layer
+    header[5] = model.config.n_head
+    header[6] = model.config.n_embd
+    # 2) the parameters follow the header
+    params = {name: param.cpu() for name, param in model.named_parameters()}
+    # pad the vocab to a multiple of 128 here at export, for efficiency in C
+    wte = params["transformer.wte.weight"] # (V, C)
+    wte_padded = pad_vocab(wte) # (Vp, C)
+    params["transformer.wte.weight"] = wte_padded # (Vp, C)
+    print(f"padded vocab size from {wte.size(0)} to {wte_padded.size(0)}")
+    header[7] = wte_padded.size(0) # padded vocab size store in header
+    # now write to file
+    with open(filename, "wb") as file:
+        file.write(header.numpy().tobytes()) # header
+        write_tensors(params, model.config.n_layer, file, dtype) # params
+    print(f"wrote {filename}")
+
+def write_state(model, x, y, logits, loss, filename):
+    # the state is used for debugging.
+    # it contains information about the input, logits, loss, and the parameter gradients
+    # this can be used for checking the computation correctness in C
+    header = torch.zeros(256, dtype=torch.int32)
+    header[0] = 20240327 # magic
+    header[1] = 2 # run state version = 2 (1 -> 2 for padded vocab changes)
+    header[2] = x.size(0) # batch size of the batch, B
+    header[3] = x.size(1) # temporal extent of the batch, T
+    grads = {name: param.grad.cpu() for name, param in model.named_parameters()}
+    # pad the vocab grads here as well, to mirror write_model
+    wte_grad = grads["transformer.wte.weight"] # (V, C)
+    wte_grad_padded = pad_vocab(wte_grad, value=0) # (Vp, C) # TODO later maybe pad with nan?
+    grads["transformer.wte.weight"] = wte_grad_padded # (Vp, C)
+    print(f"padded vocab size in reference grads from {wte_grad.size(0)} to {wte_grad_padded.size(0)}")
+    with open(filename, "wb") as file:
+        # header
+        file.write(header.numpy().tobytes())
+        # input x
+        file.write(x.cpu().numpy().astype("int32").tobytes()) # (B, T)
+        # targets y
+        file.write(y.cpu().numpy().astype("int32").tobytes()) # (B, T)
+        # logits (result of the model forward pass)
+        write_fp32(logits.cpu(), file)
+        # loss (single float, result of the cross entropy loss)
+        write_fp32(loss.cpu(), file)
+        # gradients
+        write_tensors(grads, model.config.n_layer, file, "float32")
+    print(f"wrote {filename}")
+
+def write_tokenizer(enc, filename):
+    n = enc.max_token_value + 1
+    header = torch.zeros(256, dtype=torch.int32)
+    header[0] = 20240328 # magic
+    header[1] = 2 # tokenizer version = 2 (1 -> 2: includes EOT token)
+    header[2] = n # number of tokens
+    header[3] = enc.eot_token # EOT token
+    with open(filename, "wb") as file:
+        file.write(header.numpy().tobytes())
+        for i in range(n):
+            b = enc.decode_bytes([i])
+            length = len(b)
+            assert length < 256, f"Token length exceeds 255: {length}"
+            file.write(struct.pack("<B", length))  # Write the length as a 1-byte unsigned integer
+            file.write(b)  # Write the actual bytes
+    print(f"wrote {filename}")
+
+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
+
+# -----------------------------------------------------------------------------
+# Helper functions for norm calculations
+
+def calculate_l1_to_linf_norm(matrix):
+    if matrix.ndim == 1:
+        return torch.sum(torch.abs(matrix))
+    elif matrix.ndim == 2:
+        # Each row's L1 norm, then take maximum
+        row_l1_norms = torch.sum(torch.abs(matrix), dim=1)
+        return torch.max(row_l1_norms)
+    else:
+        # For higher-dimensional tensors, flatten to 2D
+        matrix_2d = matrix.view(matrix.shape[0], -1)
+        row_l1_norms = torch.sum(torch.abs(matrix_2d), dim=1)
+        return torch.max(row_l1_norms)
+
+def calculate_spectral_norm(matrix):
+    """
+    Calculate the spectral norm (largest singular value) of a matrix.
+    For vectors, returns the L2 norm.
+    """
+    # Convert to float32 if needed for linalg operations
+    if matrix.dtype in [torch.bfloat16, torch.float16]:
+        matrix = matrix.float()
+    
+    if matrix.ndim == 1:
+        return torch.norm(matrix, p=2)
+    elif matrix.ndim == 2:
+        # Use matrix 2-norm (largest singular value)
+        return torch.linalg.matrix_norm(matrix, ord=2)
+    else:
+        # For higher-dimensional tensors, flatten to 2D
+        matrix_2d = matrix.view(matrix.shape[0], -1)
+        return torch.linalg.matrix_norm(matrix_2d, ord=2)
+
+# -----------------------------------------------------------------------------
+# Comprehensive sharpness analysis function
+
+def calculate_comprehensive_sharpness(model, model_for_forward, optimizers, step, train_loader, val_loader,
+                                      rank, world_size, device, B, T, ptdtype, grad_accum_steps, last_training_update=None, last_training_gradient=None, last_training_batches=None):
+    prev_training_mode = model.training
+    model.eval()
+    
+    NUM_LAYERS = model.config.n_layer # Number of transformer blocks
+    analysis_results = {}
+    
+    # --- 1. Get the true update direction 'v' ---
+    assert last_training_update is not None, \
+        f"[Step {step}] BUG: last_training_update is None! Check sharpness timing logic."
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] Using update from previous training step")
+    update_direction_v = last_training_update
+    
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] Restoring parameters to θ_t for HVP calculation...")
+    with torch.no_grad():
+        for p, v in zip(model.parameters(), update_direction_v):
+            p.data.sub_(v)  # Now parameters are at θ_t
+    
+    # --- 2. Calculate update norms (Frobenius, Max-of-Max, Spectral) ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Calculating update norms...")
+    
+    total_update_norm_sq = sum(torch.sum(v * v) for v in update_direction_v)
+    dist.all_reduce(total_update_norm_sq, op=dist.ReduceOp.AVG)
+    analysis_results["total_update_fnorm"] = torch.sqrt(total_update_norm_sq).item()
+    
+    # Calculate TOTAL update Max-of-Max and Spectral norms
+    print0(f"[Enhanced Sharpness @ Step {step}] Calculating total update Max-of-Max and Spectral norms...")
+    try:
+        all_updates_flat = torch.cat([v.flatten() for v in update_direction_v if v.numel() > 0])
+        
+        if all_updates_flat.numel() > 0:
+            total_l1_linf_norm = torch.sum(torch.abs(all_updates_flat))
+            analysis_results["total_l1_linf_norm"] = total_l1_linf_norm.item()
+            
+            total_spectral_norm = torch.norm(all_updates_flat, p=2)
+            analysis_results["total_spectral_norm"] = total_spectral_norm.item()
+        else:
+            analysis_results["total_l1_linf_norm"] = 0.0
+            analysis_results["total_spectral_norm"] = 0.0
+            
+        del all_updates_flat
+    except Exception as e:
+        print0(f"[Enhanced Sharpness @ Step {step}] Error calculating total norms: {e}")
+        analysis_results["total_l1_linf_norm"] = 0.0
+        analysis_results["total_spectral_norm"] = 0.0
+    
+    # --- 3. Setup layer parameter groups (adapt to new model structure) ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Setting up layer parameter groups...")
+    
+    all_param_groups = {}
+    
+    
+    all_param_groups["embed_lm_head"] = list(model.lm_head.parameters())
+    
+    blocks = model.transformer.h
+    
+    for i, block in enumerate(blocks):
+        layer_name = f"layer_{i+1}"
+        all_param_groups[layer_name] = list(block.parameters())
+    
+    # Add fine-grained params for selected layers (0, 3, 7, 11)
+    selected_layers = [0, 3, 7, 11]
+    for layer_idx in selected_layers:
+        block = blocks[layer_idx]
+        prefix = f"block{layer_idx}"
+        # Attention: Q, K, V, O
+        all_param_groups[f"{prefix}_q"] = [block.attn.q_w.weight]
+        all_param_groups[f"{prefix}_k"] = [block.attn.k_w.weight]
+        all_param_groups[f"{prefix}_v"] = [block.attn.v_w.weight]
+        all_param_groups[f"{prefix}_o"] = [block.attn.c_proj.weight]
+        # MLP: c_fc (win) and c_proj (wout)
+        all_param_groups[f"{prefix}_mlp_win"] = [block.mlp.c_fc.weight]
+        all_param_groups[f"{prefix}_mlp_wout"] = [block.mlp.c_proj.weight]
+    
+    # --- 4. Calculate layer-wise update norms ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Calculating layer-wise update norms...")
+    
+    param_to_idx = {id(p): i for i, p in enumerate(model.parameters())}
+    
+    for group_name, param_group in all_param_groups.items():
+        if not param_group:
+            continue
+            
+        # Get indices for this group
+        indices = [param_to_idx[id(p)] for p in param_group if id(p) in param_to_idx]
+        if not indices:
+            continue
+        
+        # Calculate Frobenius norm for this group
+        group_update_norm_sq = sum(torch.sum(update_direction_v[i] * update_direction_v[i]) for i in indices)
+        dist.all_reduce(group_update_norm_sq, op=dist.ReduceOp.AVG)
+        analysis_results[f"{group_name}_update_fnorm"] = torch.sqrt(group_update_norm_sq).item()
+        
+        # Calculate Max-of-Max and Spectral norms for this group
+        group_l1_linf_norms = []
+        group_spectral_norms = []
+        
+        for i in indices:
+            if i < len(update_direction_v) and update_direction_v[i].numel() > 0:
+                try:
+                    l1_linf_norm = calculate_l1_to_linf_norm(update_direction_v[i])
+                    group_l1_linf_norms.append(l1_linf_norm.item())
+                    
+                    spectral_norm = calculate_spectral_norm(update_direction_v[i])
+                    group_spectral_norms.append(spectral_norm.item())
+                except Exception as e:
+                    print0(f"[Enhanced Sharpness @ Step {step}] Error calculating norms for group {group_name}, param {i}: {e}")
+                    group_l1_linf_norms.append(0.0)
+                    group_spectral_norms.append(0.0)
+        
+        if group_l1_linf_norms:
+            analysis_results[f"{group_name}_max_l1_linf_norm"] = max(group_l1_linf_norms)
+        else:
+            analysis_results[f"{group_name}_max_l1_linf_norm"] = 0.0
+            
+        if group_spectral_norms:
+            analysis_results[f"{group_name}_max_spectral_norm"] = max(group_spectral_norms)
+        else:
+            analysis_results[f"{group_name}_max_spectral_norm"] = 0.0
+    
+    # --- 5. Setup for HVP calculation on TRAIN data ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Setting up HVP calculation in {ptdtype} on TRAIN data...")
+    
+    original_flash = nano_GPT_qkvonorm_pure.FLASH
+    nano_GPT_qkvonorm_pure.FLASH = 0
+    print0(f"[Enhanced Sharpness @ Step {step}] Disabled FLASH attention for HVP (was {original_flash})")
+
+    # Get block parameter indices for cross-layer analysis (need this before loop)
+    block_param_indices = set()
+    for group_name, param_group in all_param_groups.items():
+        if group_name.startswith("layer_"):
+            for p in param_group:
+                if id(p) in param_to_idx:
+                    block_param_indices.add(param_to_idx[id(p)])
+
+    # Initialize accumulators for all quantities we need
+    grads_hvp = None          
+    hvp_v_total = None        
+    hvp_v_block = None        
+    hvp_g_accum = None       
+    layer_hvp_accum = {}
+    
+   
+    group_names_to_process = [gn for gn, pg in all_param_groups.items() 
+                              if pg and any(id(p) in param_to_idx for p in pg)]
+    
+    if last_training_batches is not None and len(last_training_batches) > 0:
+        
+        batch_iterator = [(x, y) for x, y in last_training_batches]
+        n_batches = len(batch_iterator)
+        print0(f"[Enhanced Sharpness @ Step {step}] Using {n_batches} microbatches for HVP (out of {grad_accum_steps} training microbatches)")
+        restore_loader = False
+    else:
+        # Fallback: use new batches from train_loader (should rarely happen)
+        print0(f"[Enhanced Sharpness @ Step {step}] WARNING: last_training_batches is None/empty, using {grad_accum_steps} new batches (inconsistent)")
+        saved_current_shard = train_loader.current_shard
+        saved_current_position = train_loader.current_position
+        n_batches = grad_accum_steps  # Use same number as training for consistency
+        batch_iterator = []
+        shard_was_changed = False
+        for _ in range(n_batches):
+            x_hvp, y_hvp = train_loader.next_batch()
+            batch_iterator.append((x_hvp, y_hvp))
+            shard_was_changed = shard_was_changed or (train_loader.current_shard != saved_current_shard)
+        restore_loader = True
+
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] Computing HVPs for {n_batches} microbatches")
+    for mb_idx, (x_hvp, y_hvp) in enumerate(batch_iterator):
+        x_hvp, y_hvp = x_hvp.to(device), y_hvp.to(device)
+        
+        
+        _, loss_mb = model(x_hvp, y_hvp, return_logits=False)
+        grads_mb = torch.autograd.grad(loss_mb, model.parameters(), create_graph=True, allow_unused=True)
+        
+        # Compute H·v (total sharpness)
+        v_dot_g_total = sum(torch.sum(g * v) for g, v in zip(grads_mb, update_direction_v) if g is not None)
+        
+        if not isinstance(v_dot_g_total, torch.Tensor):
+            v_dot_g_total = torch.tensor(0.0, device=device, requires_grad=True)
+        hvp_v_total_mb = torch.autograd.grad(v_dot_g_total, model.parameters(), retain_graph=True, allow_unused=True)
+        
+        # Compute H·v_block (block-only sharpness)
+        if block_param_indices:  
+            v_dot_g_block = sum(torch.sum(grads_mb[i] * update_direction_v[i]) 
+                               for i in block_param_indices if grads_mb[i] is not None)
+            if not isinstance(v_dot_g_block, torch.Tensor):
+                v_dot_g_block = torch.tensor(0.0, device=device, requires_grad=True)
+            hvp_v_block_mb = torch.autograd.grad(v_dot_g_block, model.parameters(), retain_graph=True, allow_unused=True)
+        else:
+            
+            hvp_v_block_mb = [None] * len(list(model.parameters()))
+        
+        
+        g_dot_g = sum(torch.sum(g * g) for g in grads_mb if g is not None)
+        if not isinstance(g_dot_g, torch.Tensor):
+            g_dot_g = torch.tensor(0.0, device=device, requires_grad=True)
+        
+        
+        hvp_g_mb_raw = torch.autograd.grad(g_dot_g, model.parameters(), 
+                                           retain_graph=True, allow_unused=True)
+        hvp_g_mb = [h / 2.0 if h is not None else None for h in hvp_g_mb_raw]
+        
+        # Compute per-layer H_kk·v_k (for layer-wise sharpness)
+        for group_idx, group_name in enumerate(group_names_to_process):
+            param_group = all_param_groups[group_name]
+            indices = {param_to_idx[id(p)] for p in param_group if id(p) in param_to_idx}
+            if not indices:
+                continue
+            
+            is_last_layer = (group_idx == len(group_names_to_process) - 1)
+            is_last_microbatch = (mb_idx == n_batches - 1)
+            need_retain = not (is_last_layer and is_last_microbatch)
+            
+            try:
+                v_dot_g_layer = sum(torch.sum(grads_mb[i] * update_direction_v[i]) 
+                                   for i in indices if grads_mb[i] is not None)
+                
+                if not isinstance(v_dot_g_layer, torch.Tensor):
+                    v_dot_g_layer = torch.tensor(0.0, device=device, requires_grad=True)
+                    
+                hvp_layer_mb = torch.autograd.grad(v_dot_g_layer, model.parameters(), 
+                                                   retain_graph=need_retain,
+                                                   allow_unused=True)
+
+                if group_name not in layer_hvp_accum:
+                    layer_hvp_accum[group_name] = [(h.detach() / n_batches).cpu() if h is not None else None for h in hvp_layer_mb]
+                else:
+                    layer_hvp_accum[group_name] = [
+                        (h_acc + (h.detach() / n_batches).cpu()) if (h is not None and h_acc is not None)
+                        else ((h.detach() / n_batches).cpu() if h is not None else h_acc)
+                        for h_acc, h in zip(layer_hvp_accum[group_name], hvp_layer_mb)
+                    ]
+                
+                # Accumulate layer HVP
+                # if group_name not in layer_hvp_accum:
+                #     layer_hvp_accum[group_name] = [h.detach() / n_batches if h is not None else None for h in hvp_layer_mb]
+                # else:
+                #     layer_hvp_accum[group_name] = [
+                #         (h_acc + h.detach() / n_batches) if (h is not None and h_acc is not None)
+                #         else (h.detach() / n_batches if h is not None else h_acc)
+                #         for h_acc, h in zip(layer_hvp_accum[group_name], hvp_layer_mb)
+                #     ]
+                #     del hvp_layer_mb, v_dot_g_layer
+                #     torch.cuda.empty_cache()
+            except Exception as e:
+                print0(f"[Enhanced Sharpness @ Step {step}] Error computing layer HVP for '{group_name}' in microbatch {mb_idx}: {e}")
+                if group_name not in layer_hvp_accum:
+                    layer_hvp_accum[group_name] = None
+        
+        # 6. Accumulate all quantities
+        if grads_hvp is None:
+            grads_hvp = [(g.detach() / n_batches).cpu() if g is not None else None for g in grads_mb]
+            hvp_v_total = [(h.detach() / n_batches).cpu() if h is not None else None for h in hvp_v_total_mb]
+            hvp_v_block = [(h.detach() / n_batches).cpu() if h is not None else None for h in hvp_v_block_mb]
+            hvp_g_accum = [(h.detach() / n_batches).cpu() if h is not None else None for h in hvp_g_mb]
+        else:
+            grads_hvp = [
+                (g_acc + (g.detach() / n_batches).cpu()) if (g is not None and g_acc is not None) 
+                else ((g.detach() / n_batches).cpu() if g is not None else g_acc)
+                for g_acc, g in zip(grads_hvp, grads_mb)
+            ]
+            hvp_v_total = [
+                (h_acc + (h.detach() / n_batches).cpu()) if (h is not None and h_acc is not None)
+                else ((h.detach() / n_batches).cpu() if h is not None else h_acc)
+                for h_acc, h in zip(hvp_v_total, hvp_v_total_mb)
+            ]
+            hvp_v_block = [
+                (h_acc + (h.detach() / n_batches).cpu()) if (h is not None and h_acc is not None)
+                else ((h.detach() / n_batches).cpu() if h is not None else h_acc)
+                for h_acc, h in zip(hvp_v_block, hvp_v_block_mb)
+            ]
+            hvp_g_accum = [
+                (h_acc + (h.detach() / n_batches).cpu()) if (h is not None and h_acc is not None)
+                else ((h.detach() / n_batches).cpu() if h is not None else h_acc)
+                for h_acc, h in zip(hvp_g_accum, hvp_g_mb)
+            ]
+
+        
+        
+        if mb_idx % max(1, n_batches // 4) == 0:
+            print0(f"[Enhanced Sharpness @ Step {step}] Processed microbatch {mb_idx + 1}/{n_batches}")
+    
+   
+    if restore_loader:
+        train_loader.current_shard = saved_current_shard
+        train_loader.current_position = saved_current_position
+        if shard_was_changed:
+            train_loader.tokens = _load_data_shard(train_loader.files[train_loader.current_shard])
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] Finished computing all HVPs for {n_batches} microbatches")
+    grads_hvp = [g.to(device) if g is not None else None for g in grads_hvp]
+    hvp_v_total = [h.to(device) if h is not None else None for h in hvp_v_total]
+    hvp_v_block = [h.to(device) if h is not None else None for h in hvp_v_block]
+    hvp_g_accum = [h.to(device) if h is not None else None for h in hvp_g_accum]
+    for group_name in layer_hvp_accum:
+        if layer_hvp_accum[group_name] is not None:
+            layer_hvp_accum[group_name] = [h.to(device) if h is not None else None for h in layer_hvp_accum[group_name]]
+    # --- Calculate TOTAL sharpness ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Calculating TOTAL sharpness...")
+    # hvp_v_total is already computed in the loop above
+    vhp_dot_v_total = sum(torch.sum(hvp * v) for hvp, v in zip(hvp_v_total, update_direction_v) if hvp is not None)
+    v_norm_sq_total = sum(torch.sum(v * v) for v in update_direction_v)
+    
+    # Ensure they are tensors
+    if not isinstance(vhp_dot_v_total, torch.Tensor):
+        vhp_dot_v_total = torch.tensor(0.0, device=device)
+    if not isinstance(v_norm_sq_total, torch.Tensor):
+        v_norm_sq_total = torch.tensor(0.0, device=device)
+
+    dist.all_reduce(vhp_dot_v_total, op=dist.ReduceOp.AVG)
+    dist.all_reduce(v_norm_sq_total, op=dist.ReduceOp.AVG)
+
+    if v_norm_sq_total.item() > 1e-12:
+        analysis_results["total_sharpness"] = (vhp_dot_v_total / v_norm_sq_total).item()
+    else:
+        analysis_results["total_sharpness"] = 0.0
+
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] Calculating BLOCK-ONLY total sharpness...")
+    # hvp_v_block is already computed in the loop above
+    if block_param_indices:  # Only compute if there are block parameters
+        # Compute v_block^T H v_block (only sum over block indices)
+        vhp_dot_v_block = sum(torch.sum(hvp_v_block[i] * update_direction_v[i]) 
+                              for i in block_param_indices if hvp_v_block[i] is not None)
+        
+        v_norm_sq_block = sum(torch.sum(update_direction_v[i] * update_direction_v[i]) 
+                              for i in block_param_indices)
+        
+        # Ensure they are tensors
+        if not isinstance(vhp_dot_v_block, torch.Tensor):
+            vhp_dot_v_block = torch.tensor(0.0, device=device)
+        if not isinstance(v_norm_sq_block, torch.Tensor):
+            v_norm_sq_block = torch.tensor(0.0, device=device)
+        
+        dist.all_reduce(vhp_dot_v_block, op=dist.ReduceOp.AVG)
+        dist.all_reduce(v_norm_sq_block, op=dist.ReduceOp.AVG)
+        
+        if v_norm_sq_block.item() > 1e-12:
+            analysis_results["block_total_sharpness"] = (vhp_dot_v_block / v_norm_sq_block).item()
+        else:
+            analysis_results["block_total_sharpness"] = 0.0
+        
+        analysis_results["v_norm_block"] = torch.sqrt(v_norm_sq_block).item()
+        analysis_results["v_T_H_v_block"] = vhp_dot_v_block.item()
+    else:
+        # No block parameters
+        analysis_results["block_total_sharpness"] = 0.0
+        analysis_results["v_norm_block"] = 0.0
+        analysis_results["v_T_H_v_block"] = 0.0
+    
+    torch.cuda.empty_cache()
+
+    # ---- Alignment metrics between update v and (negative) gradient g ----
+    eps = 1e-12
+    v_norm = torch.sqrt(v_norm_sq_total + eps)
+    analysis_results["v_norm"] = v_norm.item()
+    
+    # --- Version 1: g_hvp  ---
+    ip_v_neg_g_hvp = sum(torch.sum(v * (-g)) for v, g in zip(update_direction_v, grads_hvp) if g is not None)
+    g_hvp_norm_sq = sum(torch.sum(g * g) for g in grads_hvp if g is not None)
+    
+    if not isinstance(ip_v_neg_g_hvp, torch.Tensor):
+        ip_v_neg_g_hvp = torch.tensor(0.0, device=device)
+    if not isinstance(g_hvp_norm_sq, torch.Tensor):
+        g_hvp_norm_sq = torch.tensor(0.0, device=device)
+    dist.all_reduce(ip_v_neg_g_hvp, op=dist.ReduceOp.AVG)
+    dist.all_reduce(g_hvp_norm_sq, op=dist.ReduceOp.AVG)
+    g_hvp_norm = torch.sqrt(g_hvp_norm_sq + eps)
+    analysis_results["ip_v_neg_g_hvp"] = ip_v_neg_g_hvp.item()
+    analysis_results["cos_v_neg_g_hvp"] = (ip_v_neg_g_hvp / (v_norm * g_hvp_norm + eps)).item()
+    analysis_results["g_hvp_norm"] = g_hvp_norm.item()
+    
+    # --- Version 2: g_t (original gradient that produced v) ---
+    # last_training_gradient is the actual gradient from training that led to the update v
+    if last_training_gradient is not None:
+        ip_v_neg_g_t = sum(torch.sum(v * (-g)) for v, g in zip(update_direction_v, last_training_gradient) if g is not None)
+        g_t_norm_sq = sum(torch.sum(g * g) for g in last_training_gradient if g is not None)
+        dist.all_reduce(ip_v_neg_g_t, op=dist.ReduceOp.AVG)
+        dist.all_reduce(g_t_norm_sq, op=dist.ReduceOp.AVG)
+        g_t_norm = torch.sqrt(g_t_norm_sq + eps)
+        analysis_results["ip_v_neg_g_t"] = ip_v_neg_g_t.item()
+        analysis_results["cos_v_neg_g_t"] = (ip_v_neg_g_t / (v_norm * g_t_norm + eps)).item()
+        analysis_results["g_t_norm"] = g_t_norm.item()
+    else:
+        print0(f"[Enhanced Sharpness @ Step {step}] Warning: last_training_gradient is None, skipping g_t metrics")
+    
+    # Keep backward compatibility aliases (g_norm uses g_hvp for now)
+    g_norm_sq = g_hvp_norm_sq
+    g_norm = g_hvp_norm
+    analysis_results["g_norm"] = g_norm.item()
+
+    # ---- Cosine between v and Hv (curvature pull along v) ----
+    hv_norm_sq = sum(torch.sum(hvp * hvp) for hvp in hvp_v_total if hvp is not None)
+    if not isinstance(hv_norm_sq, torch.Tensor):
+        hv_norm_sq = torch.tensor(0.0, device=device)
+    dist.all_reduce(hv_norm_sq, op=dist.ReduceOp.AVG)
+    hv_norm = torch.sqrt(hv_norm_sq + eps)
+    ip_v_hv = vhp_dot_v_total  # already reduced AVG
+    analysis_results["hv_norm"] = hv_norm.item()
+    analysis_results["cos_v_hv"] = (ip_v_hv / (v_norm * hv_norm + eps)).item()
+
+    # ---- Cosine between g and Hg ----
+    # hvp_g_accum is already computed in the loop above
+    ip_g_hg = sum(torch.sum(g * hg) for g, hg in zip(grads_hvp, hvp_g_accum) if (g is not None and hg is not None))
+    hg_norm_sq = sum(torch.sum(hg * hg) for hg in hvp_g_accum if hg is not None)
+    if not isinstance(ip_g_hg, torch.Tensor):
+        ip_g_hg = torch.tensor(0.0, device=device)
+    if not isinstance(hg_norm_sq, torch.Tensor):
+        hg_norm_sq = torch.tensor(0.0, device=device)
+    dist.all_reduce(ip_g_hg, op=dist.ReduceOp.AVG)
+    dist.all_reduce(hg_norm_sq, op=dist.ReduceOp.AVG)
+    hg_norm = torch.sqrt(hg_norm_sq + eps)
+    analysis_results["hg_norm"] = hg_norm.item()
+    analysis_results["cos_g_hg"] = (ip_g_hg / (g_norm * hg_norm + eps)).item() if g_norm.item() > 0 else 0.0
+
+    # ---- Decompose v into parallel / perpendicular to -g ----
+    if g_norm.item() > 0:
+        v_parallel = [(torch.sum(v * (-g)) / (g_norm_sq + eps)) * (-g) if g is not None else torch.zeros_like(v)
+                      for v, g in zip(update_direction_v, grads_hvp)]
+        v_parallel_norm_sq = sum(torch.sum(vp * vp) for vp in v_parallel)
+        if not isinstance(v_parallel_norm_sq, torch.Tensor):
+            v_parallel_norm_sq = torch.tensor(0.0, device=device)
+        dist.all_reduce(v_parallel_norm_sq, op=dist.ReduceOp.AVG)
+        v_parallel_norm = torch.sqrt(v_parallel_norm_sq + eps)
+        v_perp_norm = torch.sqrt(torch.clamp(v_norm_sq_total - v_parallel_norm_sq, min=0.0) + eps)
+        analysis_results["v_parallel_norm"] = v_parallel_norm.item()
+        analysis_results["v_perp_norm"] = v_perp_norm.item()
+
+    # ---- Per-layer additions: cos_v_neg_g_layer, v_norm_layer ----
+    for group_name, param_group in all_param_groups.items():
+        indices = {param_to_idx[id(p)] for p in param_group if id(p) in param_to_idx}
+        if not indices:
+            continue
+        v_norm_sq_layer = sum(torch.sum(update_direction_v[i] * update_direction_v[i]) for i in indices)
+        g_norm_sq_layer = sum(torch.sum(grads_hvp[i] * grads_hvp[i]) for i in indices if grads_hvp[i] is not None)
+        ip_v_neg_g_layer = sum(torch.sum(update_direction_v[i] * (-grads_hvp[i]))
+                               for i in indices if grads_hvp[i] is not None)
+        # Ensure they are tensors
+        if not isinstance(v_norm_sq_layer, torch.Tensor):
+            v_norm_sq_layer = torch.tensor(0.0, device=device)
+        if not isinstance(g_norm_sq_layer, torch.Tensor):
+            g_norm_sq_layer = torch.tensor(0.0, device=device)
+        if not isinstance(ip_v_neg_g_layer, torch.Tensor):
+            ip_v_neg_g_layer = torch.tensor(0.0, device=device)
+        dist.all_reduce(v_norm_sq_layer, op=dist.ReduceOp.AVG)
+        dist.all_reduce(g_norm_sq_layer, op=dist.ReduceOp.AVG)
+        dist.all_reduce(ip_v_neg_g_layer, op=dist.ReduceOp.AVG)
+        v_norm_layer = torch.sqrt(v_norm_sq_layer + eps)
+        g_norm_layer = torch.sqrt(g_norm_sq_layer + eps)
+        analysis_results[f"{group_name}_v_norm"] = v_norm_layer.item()
+        if g_norm_layer.item() > 0:
+            analysis_results[f"{group_name}_cos_v_neg_g"] = (ip_v_neg_g_layer / (v_norm_layer * g_norm_layer + eps)).item()
+
+    # --- 7. Calculate layer-wise sharpness ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Calculating layer-wise sharpness...")
+    print0(f"[Enhanced Sharpness @ Step {step}] Processing {len(all_param_groups)} layers for sharpness...")
+    
+    for group_name, param_group in all_param_groups.items():
+        if not param_group:
+            continue
+            
+        print0(f"[Enhanced Sharpness @ Step {step}] Processing '{group_name}'...")
+        indices = {param_to_idx[id(p)] for p in param_group if id(p) in param_to_idx}
+        if not indices: 
+            continue
+
+        try:
+            if group_name not in layer_hvp_accum or layer_hvp_accum[group_name] is None:
+                print0(f"[Enhanced Sharpness @ Step {step}] No HVP data for '{group_name}', skipping")
+                analysis_results[f"{group_name}_sharpness"] = 0.0
+                continue
+                
+            hvp_group_result = layer_hvp_accum[group_name]
+            
+            vhp_dot_v_group = sum(torch.sum(hvp_group_result[i] * update_direction_v[i]) 
+                                for i in indices if hvp_group_result[i] is not None)
+            v_norm_sq_group = sum(torch.sum(update_direction_v[i] * update_direction_v[i]) 
+                                for i in indices)
+            
+            # Ensure they are tensors
+            if not isinstance(vhp_dot_v_group, torch.Tensor):
+                vhp_dot_v_group = torch.tensor(0.0, device=device)
+            if not isinstance(v_norm_sq_group, torch.Tensor):
+                v_norm_sq_group = torch.tensor(0.0, device=device)
+            
+            dist.all_reduce(vhp_dot_v_group, op=dist.ReduceOp.AVG)
+            dist.all_reduce(v_norm_sq_group, op=dist.ReduceOp.AVG)
+            
+            if v_norm_sq_group.item() > 1e-12:
+                analysis_results[f"{group_name}_sharpness"] = (vhp_dot_v_group / v_norm_sq_group).item()
+            else:
+                analysis_results[f"{group_name}_sharpness"] = 0.0
+            
+        except torch.OutOfMemoryError as e:
+            print0(f"[Enhanced Sharpness @ Step {step}] OOM error for '{group_name}': {e}")
+            analysis_results[f"{group_name}_sharpness"] = 0.0
+            torch.cuda.empty_cache()
+        except Exception as e:
+            print0(f"[Enhanced Sharpness @ Step {step}] Error processing '{group_name}': {e}")
+            analysis_results[f"{group_name}_sharpness"] = 0.0
+
+    # --- Calculate block-diagonal approximation and cross-layer interaction ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Calculating block-diagonal and cross-layer sharpness...")
+    
+    sum_layer_numerators = 0.0
+    for layer in range(1, NUM_LAYERS + 1):
+        layer_name = f"layer_{layer}"
+        if f"{layer_name}_sharpness" in analysis_results and f"{layer_name}_v_norm" in analysis_results:
+            s_k = analysis_results[f"{layer_name}_sharpness"]
+            v_k_norm = analysis_results[f"{layer_name}_v_norm"]
+            sum_layer_numerators += s_k * (v_k_norm ** 2)
+    
+    analysis_results["sum_layer_numerators"] = sum_layer_numerators
+    
+    # Block-diagonal sharpness (using block ||v||²)
+    v_norm_block = analysis_results.get("v_norm_block", 0)
+    v_norm_sq_block_val = v_norm_block ** 2 if v_norm_block else 1e-12
+    
+    if v_norm_sq_block_val > 1e-12:
+        analysis_results["block_diag_sharpness"] = sum_layer_numerators / v_norm_sq_block_val
+    else:
+        analysis_results["block_diag_sharpness"] = 0.0
+    
+    # Cross-layer interaction = block_total - block_diag
+    block_total = analysis_results.get("block_total_sharpness", 0)
+    block_diag = analysis_results.get("block_diag_sharpness", 0)
+    analysis_results["cross_layer_sharpness"] = block_total - block_diag
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] block_total={block_total:.6f}, block_diag={block_diag:.6f}, cross_layer={block_total - block_diag:.6f}")
+
+    # --- Compute true_dec and pred_dec ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Computing true_dec (L(t) - L(t+1)) on training batch...")
+    try:
+        # Restore FLASH for forward pass 
+        nano_GPT_qkvonorm_pure.FLASH = original_flash
+
+        
+        loss_at_theta_t = 0.0
+        with torch.no_grad():
+            for x_td, y_td in batch_iterator:
+                x_td, y_td = x_td.to(device), y_td.to(device)
+                _, loss_td = model(x_td, y_td, return_logits=False)
+                loss_at_theta_t += loss_td.item()
+        loss_at_theta_t /= len(batch_iterator)  # average over microbatches
+
+        with torch.no_grad():
+            for p, v in zip(model.parameters(), update_direction_v):
+                p.data.add_(v)
+
+        loss_at_theta_t1 = 0.0
+        with torch.no_grad():
+            for x_td, y_td in batch_iterator:
+                x_td, y_td = x_td.to(device), y_td.to(device)
+                _, loss_td = model(x_td, y_td, return_logits=False)
+                loss_at_theta_t1 += loss_td.item()
+        loss_at_theta_t1 /= len(batch_iterator)
+
+        with torch.no_grad():
+            for p, v in zip(model.parameters(), update_direction_v):
+                p.data.sub_(v)
+
+        loss_t_tensor = torch.tensor(loss_at_theta_t, device=device)
+        loss_t1_tensor = torch.tensor(loss_at_theta_t1, device=device)
+        dist.all_reduce(loss_t_tensor, op=dist.ReduceOp.AVG)
+        dist.all_reduce(loss_t1_tensor, op=dist.ReduceOp.AVG)
+        loss_at_theta_t = loss_t_tensor.item()
+        loss_at_theta_t1 = loss_t1_tensor.item()
+
+        true_dec = loss_at_theta_t - loss_at_theta_t1
+        analysis_results["loss_at_theta_t"] = loss_at_theta_t
+        analysis_results["loss_at_theta_t1"] = loss_at_theta_t1
+        analysis_results["true_dec"] = true_dec
+
+        # pred_dec = (-g)^T v - 0.5 * v^T H v 
+        first_order = analysis_results.get("ip_v_neg_g_t", analysis_results.get("ip_v_neg_g_hvp", 0.0))
+        sharpness_val = analysis_results.get("total_sharpness", 0.0)
+        v_norm_val = analysis_results.get("v_norm", 0.0)
+        curvature_term = 0.5 * sharpness_val * (v_norm_val ** 2)
+        pred_dec = first_order - curvature_term
+
+        analysis_results["pred_dec"] = pred_dec
+        analysis_results["first_order_descent"] = first_order
+        analysis_results["curvature_penalty"] = curvature_term
+
+        print0(f"[Enhanced Sharpness @ Step {step}] L(θ_t)={loss_at_theta_t:.6f}, L(θ_{{t+1}})={loss_at_theta_t1:.6f}, "
+               f"true_dec={true_dec:.6f}, pred_dec={pred_dec:.6f}, 1st_order={first_order:.6f}, curvature={curvature_term:.6f}")
+    except Exception as e:
+        print0(f"[Enhanced Sharpness @ Step {step}] Error computing true_dec: {e}")
+        analysis_results["true_dec"] = 0.0
+        analysis_results["pred_dec"] = 0.0
+
+    # --- Cleanup ---
+    nano_GPT_qkvonorm_pure.FLASH = original_flash
+    print0(f"[Enhanced Sharpness @ Step {step}] Restored FLASH attention to {original_flash}")
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] Restoring parameters back to θ_{{t+1}}...")
+    with torch.no_grad():
+        for p, v in zip(model.parameters(), update_direction_v):
+            p.data.add_(v)  
+    
+    if prev_training_mode:
+        model.train()
+    else:
+        model.eval()
+    
+    # Thorough cleanup of all temporary variables
+    del update_direction_v, grads_hvp
+    del hvp_v_total, hvp_v_block, hvp_g_accum, layer_hvp_accum
+    del vhp_dot_v_total, v_norm_sq_total
+    del vhp_dot_v_block, v_norm_sq_block
+    if 'all_param_groups' in locals():
+        del all_param_groups
+    if 'param_to_idx' in locals():
+        del param_to_idx
+    
+    # Synchronize CUDA operations before cleanup
+    if device == "cuda":
+        torch.cuda.synchronize()
+    
+    gc.collect()
+    torch.cuda.empty_cache()
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] Analysis complete. Generated {len(analysis_results)} metrics.")
+    return analysis_results
+
+def format_comprehensive_results(results):
+    """
+    Format the comprehensive analysis results for logging.
+    """
+    log_parts = []
+    
+    # Total sharpness
+    if 'total_sharpness' in results:
+        log_parts.append(f"total_sharp:{results['total_sharpness']:.4e}")
+    
+    # Layer-wise sharpness - dynamically detect number of layers
+    layer_sharpness = []
+    layer_num = 1
+    while True:
+        layer_key = f"layer_{layer_num}_sharpness"
+        if layer_key in results:
+            layer_sharpness.append(f"L{layer_num}_sharp:{results[layer_key]:.4e}")
+            layer_num += 1
+        else:
+            break
+    
+    if layer_sharpness:
+        log_parts.append(" ".join(layer_sharpness))
+    
+    # Total update norms
+    total_norms = []
+    if 'total_update_fnorm' in results:
+        total_norms.append(f"total_fnorm:{results['total_update_fnorm']:.4e}")
+    if 'total_l1_linf_norm' in results:
+        total_norms.append(f"total_l1_linf:{results['total_l1_linf_norm']:.4e}")
+    if 'total_spectral_norm' in results:
+        total_norms.append(f"total_spectral:{results['total_spectral_norm']:.4e}")
+    
+    if total_norms:
+        log_parts.append(" ".join(total_norms))
+    
+    # Layer-wise update norms (Frobenius)
+    layer_fnorms = []
+    layer_num = 1
+    while True:
+        layer_key = f"layer_{layer_num}_update_fnorm"
+        if layer_key in results:
+            layer_fnorms.append(f"L{layer_num}_fnorm:{results[layer_key]:.4e}")
+            layer_num += 1
+        else:
+            break
+    
+    if layer_fnorms:
+        log_parts.append(" ".join(layer_fnorms))
+    
+    # Layer-wise update norms (Max-of-Max)
+    layer_l1_linf = []
+    layer_num = 1
+    while True:
+        layer_key = f"layer_{layer_num}_max_l1_linf_norm"
+        if layer_key in results:
+            layer_l1_linf.append(f"L{layer_num}_l1linf:{results[layer_key]:.4e}")
+            layer_num += 1
+        else:
+            break
+    
+    if layer_l1_linf:
+        log_parts.append(" ".join(layer_l1_linf))
+    
+    # Layer-wise update norms (Spectral)
+    layer_spectral = []
+    layer_num = 1
+    while True:
+        layer_key = f"layer_{layer_num}_max_spectral_norm"
+        if layer_key in results:
+            layer_spectral.append(f"L{layer_num}_spectral:{results[layer_key]:.4e}")
+            layer_num += 1
+        else:
+            break
+    
+    if layer_spectral:
+        log_parts.append(" ".join(layer_spectral))
+
+    # Alignment and curvature metrics (global)
+    misc_parts = []
+    if 'v_norm' in results:
+        misc_parts.append(f"v_norm:{results['v_norm']:.4e}")
+    
+    # Version 1: g_hvp (new batch, computed at θ_t during HVP calculation)
+    if 'cos_v_neg_g_hvp' in results:
+        misc_parts.append(f"cos_v_-g_hvp:{results['cos_v_neg_g_hvp']:.4e}")
+    if 'g_hvp_norm' in results:
+        misc_parts.append(f"g_hvp_norm:{results['g_hvp_norm']:.4e}")
+    
+    # Version 2: g_t (original gradient that produced v)
+    if 'cos_v_neg_g_t' in results:
+        misc_parts.append(f"cos_v_-g_t:{results['cos_v_neg_g_t']:.4e}")
+    if 'g_t_norm' in results:
+        misc_parts.append(f"g_t_norm:{results['g_t_norm']:.4e}")
+    
+    if 'hv_norm' in results:
+        misc_parts.append(f"hv_norm:{results['hv_norm']:.4e}")
+    if 'cos_v_hv' in results:
+        misc_parts.append(f"cos_v_hv:{results['cos_v_hv']:.4e}")
+    if 'hg_norm' in results:
+        misc_parts.append(f"hg_norm:{results['hg_norm']:.4e}")
+    if 'cos_g_hg' in results:
+        misc_parts.append(f"cos_g_hg:{results['cos_g_hg']:.4e}")
+    if 'v_parallel_norm' in results:
+        misc_parts.append(f"v_par:{results['v_parallel_norm']:.4e}")
+    if 'v_perp_norm' in results:
+        misc_parts.append(f"v_perp:{results['v_perp_norm']:.4e}")
+    if misc_parts:
+        log_parts.append(" ".join(misc_parts))
+
+    # Per-layer alignment metrics (cos_v_neg_g and v_norm per layer)
+    layer_cos = []
+    layer_num = 1
+    while True:
+        layer_key = f"layer_{layer_num}_cos_v_neg_g"
+        layer_vn_key = f"layer_{layer_num}_v_norm"
+        if layer_key in results:
+            layer_cos.append(f"L{layer_num}_cos_v_neg_g:{results[layer_key]:.4e}")
+        if layer_vn_key in results:
+            layer_cos.append(f"L{layer_num}_v_norm:{results[layer_vn_key]:.4e}")
+        if layer_key not in results and layer_vn_key not in results:
+            break
+        layer_num += 1
+    if layer_cos:
+        log_parts.append(" ".join(layer_cos))
+    
+    return " ".join(log_parts)
+
+# -----------------------------------------------------------------------------
+# int main
+
+def print0(*args, **kwargs):
+    # modified print that only prints from the master process
+    # if this is not a distributed run, it's just a print
+    if int(os.environ.get("RANK", 0)) == 0:
+        print(*args, **kwargs)
+
+if __name__ == "__main__":
+    import time
+    import argparse
+    import tiktoken
+    print0(f"Running pytorch {torch.version.__version__}")
+
+    # default settings will overfit a tiny batch of data
+    # and save model weights and debug state to disk on the first iteration
+    parser = argparse.ArgumentParser()
+    # file system input / output
+    parser.add_argument("--input_bin", type=str, default="dev/data/tinyshakespeare/tiny_shakespeare_val.bin", help="input .bin to train on")
+    parser.add_argument("--input_val_bin", type=str, default="", help="input .bin to eval validation loss on")
+    parser.add_argument("--output_dir", type=str, default="", help="output directory to which to write logs and checkpoints")
+    parser.add_argument("--model", type=str, default="gpt2", help="gpt2|gpt2-medium|gpt2-large|gpt2-xl|d8|d12|d24|d36|d48")
+    # token layout for each step of the optimization
+    parser.add_argument("--batch_size", type=int, default=4, help="batch size, in units of #batch dimensions")
+    parser.add_argument("--sequence_length", type=int, default=64, help="sequence length")
+    parser.add_argument("--total_batch_size", type=int, default=256, help="total desired batch size, in units of #tokens")
+    # workload (number of steps)
+    parser.add_argument("--num_iterations", type=int, default=10, help="number of iterations to run")
+    parser.add_argument("--inference_only", type=int, default=0, help="only run inference")
+    # optimization
+    parser.add_argument("--adam_lr", type=float, default=1e-4, help="learning rate warmup iterations")
+    parser.add_argument("--warmup_iters", type=int, default=0, help="learning rate warmup iterations")
+    parser.add_argument("--lr_decay_frac", type=float, default=1.0, help="learning rate warmup iterations")
+    parser.add_argument("--weight_decay", type=float, default=0.0, help="weight decay")
+    parser.add_argument("--grad_clip", type=float, default=1.0, help="maximum gradient magnitude")
+    # evaluation
+    parser.add_argument("--val_loss_every", type=int, default=0, help="every how mant steps to evaluate val loss?")
+    parser.add_argument("--val_max_steps", type=int, default=20, help="how many batches of val to average?")
+    parser.add_argument("--sample_every", type=int, default=0, help="how often to sample from the model?")
+    # debugging
+    parser.add_argument("--overfit_single_batch", type=int, default=0, help="overfit just one batch of data")
+    parser.add_argument("--shuffle_files", action="store_true")
+    # numerics
+    parser.add_argument("--tensorcores", type=int, default=0, help="use tensorcores")
+    # memory management
+    parser.add_argument("--device", type=str, default="", help="by default we autodetect, or set it here")
+    parser.add_argument("--compile", type=int, default=0, help="torch.compile the model")
+    parser.add_argument("--flash", type=int, default=0, help="use flash attention")
+    parser.add_argument("--dtype", type=str, default="float32", help="float32|float16|bfloat16")
+    parser.add_argument("--zero_stage", type=int, default=0, help="zero redundancy optimizer stage (0/1/2/3)")
+    # Muon optimizer specific arguments
+    parser.add_argument("--optimizer", type=str, default="adam", help="optimizer to use: adam|muon")
+    parser.add_argument("--muon_lr", type=float, default=0.02, help="learning rate for Muon optimizer")
+    parser.add_argument("--muon_momentum", type=float, default=0.95, help="momentum for Muon optimizer")
+    parser.add_argument("--muon_weight_decay", type=float, default=0.00, help="weight decay for Muon optimizer")
+    parser.add_argument("--muon_ns_steps", type=int, default=5, help="number of Newton-Schulz steps for Muon")
+    parser.add_argument("--muon_nesterov", type=bool, default=False, help="use Nesterov momentum for Muon (0/1)")
+    # python -> C bridge
+    parser.add_argument("--write_tensors", type=int, default=1, help="write tensors to disk")
+    parser.add_argument("--seed", type=int, default=42, help="random seed")
+    # Sharpness analysis arguments
+    parser.add_argument("--analyze_sharpness", action="store_true", help="Enable comprehensive sharpness analysis")
+    parser.add_argument("--sharpness_analysis_interval", type=int, default=500, help="Interval for sharpness analysis")
+    args = parser.parse_args()
+
+    # args error checking and convenience variables
+    B, T = args.batch_size, args.sequence_length
+    assert 1 <= T <= 1024
+    assert args.dtype in {"float32", "float16", "bfloat16"}
+    assert args.model in {"gpt2", "gpt2-medium", "gpt2-large", "gpt2-xl", "d8", "d12", "d24", "d36", "d48"}
+    assert args.optimizer in {"adam", "muon"}
+
+    set_seed(args.seed)
+
+    # set up DDP (distributed data parallel). torchrun sets this env variable
+    ddp = int(os.environ.get('RANK', -1)) != -1 # is this a ddp run?
+    if ddp:
+        # use of DDP atm demands CUDA, we set the device appropriately according to rank
+        assert torch.cuda.is_available(), "for now i think we need CUDA for DDP"
+        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)
+        master_process = ddp_rank == 0 # this process will do logging, checkpointing etc.
+        seed_offset = 0 # each process gets the exact same seed
+        zero_stage = args.zero_stage
+    else:
+        ddp_rank = 0
+        ddp_local_rank = 0
+        zero_stage = 0
+        ddp_world_size = 1
+        master_process = True
+        seed_offset = 0
+        # select the device
+        if args.device:
+            # provided explicitly by the user
+            device = args.device
+        else:
+            # attempt to autodetect the device
+            device = "cpu"
+            if torch.cuda.is_available():
+                device = "cuda"
+            elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
+                device = "mps"
+    print(f"using device: {device}")
+    device_type = 'cuda' if 'cuda' in device else 'cpu'
+
+    # Setup debugpy for remote debugging (only activates if DEBUGPY env var is set)
+    # setup_debugpy(rank=ddp_rank, force=True)
+
+    # calculate gradient accumulation from the desired total batch size and the current run configuration
+    tokens_per_fwdbwd = B * T * ddp_world_size
+    assert args.total_batch_size % tokens_per_fwdbwd == 0
+    grad_accum_steps = args.total_batch_size // tokens_per_fwdbwd
+    print0(f"total desired batch size: {args.total_batch_size}")
+    print0(f"=> calculated gradient accumulation steps: {grad_accum_steps}")
+
+    # set up a context manager following the desired dtype and device
+    ptdtype = {'float32': torch.float32, 'bfloat16': torch.bfloat16, 'float16': torch.float16}[args.dtype]
+    ctx = torch.amp.autocast(device_type=device_type, dtype=ptdtype) if device_type == "cuda" else nullcontext()
+
+    # rng / reproducibility
+    torch.manual_seed(42)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed(42)
+
+    # set the torch precision mode to use TensorFloat32 (TF32) for matmuls
+    # docs https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html
+    if args.tensorcores:
+        torch.set_float32_matmul_precision('high')
+
+    # turn on/off flash attention
+    assert args.flash in {0, 1}
+    nano_GPT_qkvonorm_pure.FLASH = args.flash  # Set module-level FLASH for training
+
+    # init (and write) the tokenizer
+    enc = tiktoken.get_encoding("gpt2")
+    if master_process and args.write_tensors: # tokenizer is technically not tensors but ok
+        write_tokenizer(enc, "gpt2_tokenizer.bin")
+
+    # init the model, either from scratch or from OpenAI pretrained checkpoint
+    if args.model[0] == "d":
+        # from scratch (random weights)
+        model_config = {
+            "d8":  GPTConfig(block_size=1024, vocab_size=50257, n_layer=8,  n_head=8,  n_embd=512),
+            "d12": GPTConfig(block_size=1024, vocab_size=50257, n_layer=12, n_head=12, n_embd=768),
+            "d24": GPTConfig(block_size=1024, vocab_size=50257, n_layer=24, n_head=16, n_embd=1024),
+            "d36": GPTConfig(block_size=1024, vocab_size=50257, n_layer=36, n_head=20, n_embd=1280),
+            "d48": GPTConfig(block_size=1024, vocab_size=50257, n_layer=48, n_head=25, n_embd=1600),
+        }[args.model]
+        model = GPT(model_config)
+    else:
+        # load the GPT-2 model weights
+        model = GPT.from_pretrained(args.model)
+    model.train()
+    model.to(device)
+    
+    # Save uncompiled model reference for sharpness analysis (needs double backward)
+    raw_model_uncompiled = model
+    
+    if args.compile:
+        if hasattr(config, "coordinate_descent_tuning"):
+            config.coordinate_descent_tuning = True # suggested by @Chillee
+        print0("compiling the model...")
+        model = torch.compile(model)
+
+    # -------------------------------------------------------------------------
+    # Our own version of a simple DistributedDataLoader
+
+    # load tokens
+    train_loader = DistributedDataLoader(
+        args.input_bin, B, T, ddp_rank, ddp_world_size,
+        shuffle_files=args.shuffle_files, random_seed=args.seed
+    )
+    val_loader = None
+    if args.input_val_bin:
+        val_loader = DistributedDataLoader(args.input_val_bin, B, T, ddp_rank, ddp_world_size)
+
+    # -------------------------------------------------------------------------
+    # PyTorch -> C bridge: save some weights and state for C to load later as reference
+
+    # do one forward pass to generate ground truth for our C tests
+    if master_process and args.write_tensors and (not args.inference_only):
+        x, y = train_loader.next_batch()
+        x, y = x.to(device), y.to(device)
+        logits, loss = model(x, y, return_logits=True)  # Need logits for write_state
+        loss.backward()
+        # save model params, in both float32 and bfloat16
+        model_to_size = {"gpt2": "124M", "gpt2-medium": "355M", "gpt2-large": "774M", "gpt2-xl": "1558M"}
+        model_to_size.update({f"d{d}": f"d{d}" for d in [12, 24, 36, 48]})
+        model_size_str = model_to_size[args.model] # e.g. "124M", or "d12"
+        write_model(model, f"gpt2_{model_size_str}.bin", dtype="float32")
+        write_model(model, f"gpt2_{model_size_str}_bf16.bin", dtype="bfloat16")
+        # save x, y, logits, loss, and parameter gradients, for debugging C
+        # always store these in fp32 to have an accurate reference (?)
+        write_state(model, x, y, logits, loss, f"gpt2_{model_size_str}_debug_state.bin")
+        # reset the train_loader for the optimization below
+        train_loader.reset()
+
+    # -------------------------------------------------------------------------
+    # main training loop
+
+    # here we wrap model into DDP container
+    if ddp:
+        model = DDP(model, device_ids=[ddp_local_rank])
+    raw_model = model.module if ddp else model # always contains the "raw" unwrapped model
+    
+    base_module = model.module if ddp else model
+    # If compiled, unwrap to get the original module
+    if hasattr(base_module, "_orig_mod"):
+        base_module = base_module._orig_mod
+    
+    raw_params = list(raw_model_uncompiled.parameters())
+    train_params = list(base_module.parameters())
+    
+    assert len(raw_params) == len(train_params), \
+        f"Parameter count mismatch: raw_model_uncompiled has {len(raw_params)}, training model has {len(train_params)}"
+    for i, (rp, tp) in enumerate(zip(raw_params, train_params)):
+        assert rp.data_ptr() == tp.data_ptr(), \
+            f"Parameter {i} has different data_ptr: raw_model_uncompiled and training model do not share parameters!"
+    print0(f"[Verified] raw_model_uncompiled and training model share the same {len(raw_params)} Parameter objects")
+    
+    last_training_update = None
+    last_training_gradient = None  # Store the original gradient that produced the update
+    last_training_batches = None  # Store ALL microbatches (x, y) for consistent HVP calculation
+
+
+    def configure_adam(model, weight_decay, learning_rate, betas, device_type, zero_stage):
+        # start with all of the candidate parameters
+        param_dict = {pn: p for pn, p in model.named_parameters()}
+        # filter out those that do not require grad
+        param_dict = {pn: p for pn, p in param_dict.items() if p.requires_grad}
+        # create optim groups. Any parameters that is 2D will be weight decayed, otherwise no.
+        # i.e. all weight tensors in matmuls + embeddings decay, all biases and layernorms don't.
+        decay_params = [p for n, p in param_dict.items() if p.dim() >= 2]
+        nodecay_params = [p for n, p in param_dict.items() if p.dim() < 2]
+        optim_groups = [
+            {'params': decay_params, 'weight_decay': weight_decay},
+            {'params': nodecay_params, 'weight_decay': 0.0}
+        ]
+        num_decay_params = sum(p.numel() for p in decay_params)
+        num_nodecay_params = sum(p.numel() for p in nodecay_params)
+        print0(f"num decayed parameter tensors: {len(decay_params)}, with {num_decay_params:,} parameters")
+        print0(f"num non-decayed parameter tensors: {len(nodecay_params)}, with {num_nodecay_params:,} parameters")
+        # Create AdamW optimizer and use the fused version if it is available
+        fused_available = 'fused' in inspect.signature(torch.optim.AdamW).parameters
+        use_fused = fused_available and device_type == 'cuda'
+        print0(f"using fused AdamW: {use_fused}")
+        if zero_stage == 1:
+            print0("using ZeroRedundancyOptimizer")
+            optimizer = ZeroRedundancyOptimizer(**optim_groups[0], optimizer_class=torch.optim.AdamW,
+                                                lr=learning_rate, betas=betas, fused=use_fused)
+            optimizer.add_param_group(optim_groups[1])
+        else:
+            print0("using regular AdamW")
+            optimizer = torch.optim.AdamW(optim_groups, lr=learning_rate, betas=betas, fused=use_fused)
+        return [optimizer]
+
+    def configure_muon(model, weight_decay, adam_lr, muon_lr, momentum, nesterov, ns_steps, device_type, zero_stage, ddp_rank, ddp_world_size):
+        # start with all of the candidate parameters
+        param_dict = {pn: p for pn, p in model.named_parameters()}
+        # filter out those that do not require grad
+        param_dict = {pn: p for pn, p in param_dict.items() if p.requires_grad}
+        
+        # For Muon, we need to separate 2D parameters (which can be orthogonalized) 
+        # from other parameters (which should use standard optimization)
+        muon_params = []  # 2D parameters for Muon
+        other_params = []  # other parameters for AdamW
+
+        muon_name = []
+        other_name = []
+        for n, p in param_dict.items():
+            if "wte.weight" in n :
+                other_params.append(p)
+                other_name.append(n)
+                continue
+
+            if p.dim() >= 2:  # 2D parameters (weight matrices)
+                muon_params.append(p)
+                muon_name.append(n)
+            else:  # 1D parameters (biases, embeddings, etc.)
+                other_params.append(p)
+                other_name.append(n)
+
+        # print("================================================\n")
+        # print(f"Muon parameters: {muon_name}\n")
+        # print(f"Other parameters: {other_name}\n")
+        # print("================================================\n")
+        
+        print0(f"Muon parameters (2D): {len(muon_params)} tensors")
+        print0(f"Other parameters (non-2D): {len(other_params)} tensors")
+        
+        # Create Muon optimizer for 2D parameters
+        muon_optimizer = None
+        if muon_params:
+            muon_optimizer = Muon(
+                params=muon_params,
+                lr=muon_lr,
+                weight_decay=weight_decay,
+                momentum=momentum,
+                nesterov=nesterov,
+                ns_steps=ns_steps,
+                rank=ddp_rank,
+                world_size=ddp_world_size
+            )
+        
+        # Create AdamW optimizer for non-2D parameters
+        adam_optimizer = None
+        if other_params:
+            # create optim groups for AdamW
+            # decay_params = [p for p in other_params if p.dim() >= 2]
+            # nodecay_params = [p for p in other_params if p.dim() < 2]
+            optim_groups = [
+                {'params': other_params, 'weight_decay': weight_decay},
+                # {'params': nodecay_params, 'weight_decay': 0.0}
+            ]
+            
+            # Create AdamW optimizer
+            fused_available = 'fused' in inspect.signature(torch.optim.AdamW).parameters
+            use_fused = fused_available and device_type == 'cuda'
+            print0(f"using fused AdamW for non-Muon params: {use_fused}")
+            
+            if zero_stage == 1:
+                print0("using ZeroRedundancyOptimizer for non-Muon params")
+                adam_optimizer = ZeroRedundancyOptimizer(**optim_groups[0], optimizer_class=torch.optim.AdamW,
+                                                        lr=adam_lr, betas=(0.9, 0.95), fused=use_fused)
+                # adam_optimizer.add_param_group(optim_groups[1])
+            else:
+                print0("using regular AdamW for non-Muon params")
+                adam_optimizer = torch.optim.AdamW(optim_groups, lr=adam_lr, betas=(0.9, 0.95), fused=use_fused)
+        
+        return [muon_optimizer, adam_optimizer]
+
+    # init the optimizer
+    if args.optimizer == "adam":
+        optimizers = configure_adam(model=raw_model_uncompiled, weight_decay=args.weight_decay,
+                                                   learning_rate=args.adam_lr, betas=(0.9, 0.95),
+                                                   device_type=device, zero_stage=zero_stage)
+    elif args.optimizer == "muon":
+        optimizers = configure_muon(
+            model=raw_model_uncompiled, 
+            weight_decay=args.muon_weight_decay,
+            muon_lr=args.muon_lr,
+            adam_lr=args.adam_lr,
+            momentum=args.muon_momentum,
+            nesterov=bool(args.muon_nesterov),
+            ns_steps=args.muon_ns_steps,
+            device_type=device,
+            zero_stage=zero_stage,
+            ddp_rank=ddp_rank,
+            ddp_world_size=ddp_world_size
+        )
+        # We'll use muon_optimizer and adam_optimizer separately
+
+    # learning rate decay scheduler (cosine with warmup)
+    def get_lr(it,base_lr):
+        # if args.optimizer == "adam":
+        #     base_lr = args.adam_lr
+        # else:  # muon
+        #     base_lr = args.muon_lr
+        min_lr = base_lr * args.lr_decay_frac
+        # 1) linear warmup for warmup_iters steps
+        if it < args.warmup_iters:
+            return base_lr * (it+1) / args.warmup_iters
+        # 2) if it > lr_decay_iters, return min learning rate
+        if it > args.num_iterations:
+            return min_lr
+        # 3) in between, use cosine decay down to min learning rate
+        decay_ratio = (it - args.warmup_iters) / (args.num_iterations - args.warmup_iters)
+        assert 0 <= decay_ratio <= 1
+        coeff = 0.5 * (1.0 + math.cos(math.pi * decay_ratio)) # coeff starts at 1 and goes to 0
+        return min_lr + coeff * (base_lr - min_lr)
+
+    def get_wsd_lr(it, base_lr):
+        min_lr = base_lr * args.lr_decay_frac
+        # cooldown_iters = int(args.num_iterations * 0.2)
+        cooldown_iters = int(0)
+        # 1) Warmup: linear warmup for warmup_iters steps
+        if it < args.warmup_iters:
+            return base_lr * (it + 1) / args.warmup_iters
+        # 3) Decay: linear decay from base_lr to min_lr in the last cooldown_iters steps
+        cooldown_start = args.num_iterations - cooldown_iters
+        if it >= cooldown_start:
+            decay_ratio = (it - cooldown_start) / cooldown_iters
+            return base_lr - decay_ratio * (base_lr - min_lr)
+        # 2) Stable: constant learning rate at base_lr
+        return base_lr
+
+    # create the logging directory if it does not exist
+    logfile = None
+    run_dir_path = None
+    
+    file_name  = f"mode_{args.optimizer}_adam_lr_{args.adam_lr}_muon_lr_{args.muon_lr}_seed_{args.seed}.log"
+    if args.output_dir:
+        base_log_dir = Path(args.output_dir)
+        base_log_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Create run-specific directory
+        # Generate UUID on master process and broadcast to all ranks
+        if master_process:
+            run_uuid = uuid.uuid4()
+            uuid_str = str(run_uuid)
+        else:
+            uuid_str = None
+        
+        # Broadcast UUID from rank 0 to all other ranks
+        if ddp:
+            # Create a tensor to hold the UUID string length and content
+            if master_process:
+                uuid_bytes = uuid_str.encode('utf-8')
+                uuid_len = len(uuid_bytes)
+            else:
+                uuid_len = 0
+            
+            # Broadcast length
+            uuid_len_tensor = torch.tensor(uuid_len, dtype=torch.long, device=device)
+            dist.broadcast(uuid_len_tensor, src=0)
+            
+            # Broadcast UUID string
+            if master_process:
+                uuid_tensor = torch.ByteTensor(list(uuid_bytes)).to(device)
+            else:
+                uuid_tensor = torch.ByteTensor([0] * uuid_len_tensor.item()).to(device)
+            dist.broadcast(uuid_tensor, src=0)
+            
+            # Decode on non-master processes
+            if not master_process:
+                uuid_str = bytes(uuid_tensor.cpu().numpy()).decode('utf-8')
+                run_uuid = uuid.UUID(uuid_str)
+            else:
+                run_uuid = uuid.UUID(uuid_str)
+        else:
+            run_uuid = uuid.uuid4()
+        
+        # run_folder_name = f"opt_{args.optimizer}_alr_{args.adam_lr}_mlr_{args.muon_lr}_seed_{args.seed}_{run_uuid}"
+        run_folder_name = f"opt_{args.optimizer}_alr_{args.adam_lr}_mlr_{args.muon_lr}_seed_{args.seed}"
+        run_dir_path = base_log_dir / run_folder_name
+        if run_dir_path.exists():
+            run_flag = False
+        else:
+            run_flag = True
+        torch.cuda.synchronize()
+        
+        
+        # Only master process creates the directory
+        if master_process:
+            run_dir_path.mkdir(parents=True, exist_ok=True)
+        
+        logfile = str(run_dir_path / "training_log.txt")
+        
+        # Save configuration
+    
+    if run_flag:
+        if master_process:
+            config_to_save = {
+                "cli_args": vars(args),
+                "run_uuid": 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)
+            print0(f"Saved configuration to: {config_file_path}")
+            
+        if master_process and logfile:
+            with open(logfile, "w") as f:
+                pass  # Create/clear the file
+            with open(logfile, "a") as f:
+                f.write(code)
+
+        if device == "cuda":
+            torch.cuda.reset_peak_memory_stats()
+        timings = []
+        norm = -1.0   # dummy value to print in inference-only mode
+        for step in range(args.num_iterations + 1):
+            t0 = time.time()
+            last_step = (step == args.num_iterations)
+
+            # once in a while evaluate the validation dataset
+            if (args.val_loss_every > 0 \
+                and (step % args.val_loss_every == 0 or last_step)) \
+                and (val_loader is not None):
+                model.eval()
+                val_loader.reset()
+                with torch.no_grad():
+                    val_loss = 0.0
+                    for _ in range(args.val_max_steps):
+                        x, y = val_loader.next_batch()
+                        x, y = x.to(device), y.to(device)
+                        _, loss = model(x, y, return_logits=False)
+                        val_loss += loss.item()
+                    val_loss /= args.val_max_steps
+                
+                # --- Comprehensive Sharpness Analysis ---
+                sharpness_log_str = ""
+                # Skip step 0 since we don't have a previous training update yet
+                if args.analyze_sharpness and step > 0 and (step % args.sharpness_analysis_interval == 0 or last_step):
+                    print0(f"[Sharpness @ Step {step}] Starting comprehensive sharpness analysis...")
+                    for optimizer in optimizers:
+                        if isinstance(optimizer, ZeroRedundancyOptimizer) or isinstance(optimizer, torch.optim.AdamW):
+                            optimizer.zero_grad(set_to_none=True)
+                        elif isinstance(optimizer, Muon):
+                            optimizer.zero_grad()
+                    comprehensive_results = calculate_comprehensive_sharpness(
+                        model=raw_model_uncompiled,  # Use uncompiled model for HVP (double backward)
+                        model_for_forward=model,     # Use compiled+DDP model for forward pass
+                        optimizers=optimizers,
+                        step=step,
+                        train_loader=train_loader,
+                        val_loader=val_loader,
+                        rank=ddp_rank,
+                        world_size=ddp_world_size,
+                        device=device,
+                        B=B,
+                        T=T,
+                        ptdtype=ptdtype,
+                        grad_accum_steps=grad_accum_steps,  # Pass grad accumulation steps to scale loss correctly
+                        last_training_update=last_training_update,  # Pass the real update captured from training
+                        last_training_gradient=last_training_gradient,  # Pass the original gradient g_t
+                        last_training_batches=last_training_batches  # Pass ALL microbatches for consistent HVP
+                    )
+                    sharpness_log_str = format_comprehensive_results(comprehensive_results)
+                    
+                    # Save sharpness results to file
+                    if master_process and run_dir_path:
+                        sharpness_file = run_dir_path / f"sharpness_step_{step}.json"
+                        with open(sharpness_file, "w") as f:
+                            json.dump(comprehensive_results, f, indent=4)
+                        print0(f"[Sharpness @ Step {step}] Results saved to {sharpness_file}")
+                    
+                    # Clean up memory after sharpness analysis
+                    del comprehensive_results
+                    # Ensure all CUDA operations are complete before cleaning up
+                    if device == "cuda":
+                        torch.cuda.synchronize()
+                    torch.cuda.empty_cache()
+                    gc.collect()
+                    if ddp:
+                        dist.barrier()  # Sync all ranks after cleanup
+                    print0(f"[Step {step}] Memory cleaned up after sharpness analysis")
+                
+                # log to console and to file
+                if sharpness_log_str:
+                    print0(f"step {step}/{args.num_iterations} | val loss {val_loss:.6f} | {sharpness_log_str}")
+                else:
+                    print0(f"step {step}/{args.num_iterations} | val loss {val_loss:.6f}")
+                
+                if master_process and logfile is not None:
+                    with open(logfile, "a") as f:
+                        f.write("step:%d validation loss:%f" % (step, val_loss))
+                        if sharpness_log_str:
+                            f.write(" %s" % sharpness_log_str)
+                        f.write("\n")
+
+            # once in a while perform model inference on the master process
+            if (args.sample_every > 0 \
+                and (step % args.sample_every == 0 or last_step)) \
+                and master_process:
+                model.eval()
+                # before we end, let's also do one round of inference
+                # we'll kick off the generation with "<|endoftext|>", which designates the start of a new sequence
+                start_ids = [enc.eot_token]
+                xg = (torch.tensor(start_ids, dtype=torch.long, device=device)[None, ...])
+                max_new_tokens = 32
+                temperature = 1.0
+                top_k = 40
+                yg = raw_model.generate(xg, max_new_tokens, temperature=temperature, top_k=top_k)
+                print0('---------------')
+                print0(enc.decode(yg[0].tolist()))
+                print0('---------------')
+
+            # bit confusing: we want to make sure to eval and sample 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()
+            # Zero gradients for the appropriate optimizer(s)
+
+            for optimizer in optimizers:
+                if isinstance(optimizer, ZeroRedundancyOptimizer) or isinstance(optimizer, torch.optim.AdamW):
+                    optimizer.zero_grad(set_to_none=True)
+                elif isinstance(optimizer, Muon):
+                    optimizer.zero_grad()
+            # if args.optimizer == "adam":
+            #     optimizer.zero_grad(set_to_none=True)
+            # else:  # muon
+            #     if muon_optimizer is not None:
+            #         muon_optimizer.zero_grad()
+            #     if adam_optimizer is not None:
+            #         adam_optimizer.zero_grad(set_to_none=True)
+            # if we are trying to overfit a single batch, we reset the loader here
+            if args.overfit_single_batch:
+                train_loader.reset()
+            # micro-batch loop where we do gradient accumulation to reach desired total batch size
+            lossf = 0.0 # for getting the mean loss (as simple float) over the accumulation steps
+            
+            # Pre-check if we need to collect microbatches for sharpness analysis
+            next_step = step + 1
+            will_analyze_sharpness_next = args.analyze_sharpness and next_step > 0 and (
+                (next_step % args.sharpness_analysis_interval == 0) or 
+                (next_step == args.num_iterations)
+            )
+            
+
+            microbatches_this_step = [] if will_analyze_sharpness_next else None
+            
+            for micro_step in range(grad_accum_steps):
+                # fetch a batch
+                x, y = train_loader.next_batch()
+                x, y = x.to(device), y.to(device)
+                
+                # Store ALL microbatches for memory-efficient HVP calculation
+                if will_analyze_sharpness_next:
+                    microbatches_this_step.append((x.detach().clone(), y.detach().clone()))
+                
+                if ddp:
+                    model.require_backward_grad_sync = (micro_step == grad_accum_steps - 1)
+                # forward pass
+                with ctx:
+                    _, loss = model(x, y, return_logits=False)
+                    loss = loss / grad_accum_steps
+                    lossf += loss.detach() # keep track of the mean loss
+                # backward pass
+                if not args.inference_only:
+                    loss.backward()
+            if ddp:
+                dist.all_reduce(lossf, op=dist.ReduceOp.AVG)
+            lossf = lossf.item()
+            
+            #no clipping
+            norm = torch.nn.utils.clip_grad_norm_(raw_model_uncompiled.parameters(), args.grad_clip)
+            
+            
+            if will_analyze_sharpness_next:
+                # Use raw_model_uncompiled's parameter order so it matches sharpness analysis codepaths.
+                # (DDP/torch.compile wrappers can be a footgun if parameter iteration order ever diverges.)
+                print(raw_model_uncompiled.transformer.h[0].attn.q_w.weight[:5,:5])
+                params_before_optimizer_step = [p.detach().clone() for p in raw_model_uncompiled.parameters()]
+                # Save the original gradient g_t that will produce the update v
+                last_training_gradient = [
+                    p.grad.detach().clone() if p.grad is not None else torch.zeros_like(p)
+                    for p in raw_model_uncompiled.parameters()
+                ]
+                # Capture ALL microbatches for consistent HVP calculation
+                # This ensures H is computed on the exact same objective as g_t and v
+                last_training_batches = microbatches_this_step  # Already cloned above
+            else:
+                params_before_optimizer_step = None
+                last_training_batches = None
+            
+            # Update learning rate and step optimizers
+            for optimizer in optimizers:
+                if isinstance(optimizer, ZeroRedundancyOptimizer) or isinstance(optimizer, torch.optim.AdamW):
+                    adam_lr = get_wsd_lr(step,args.adam_lr)
+                    for param_group in optimizer.param_groups:
+                        param_group['lr'] = adam_lr
+                    optimizer.step()
+                elif isinstance(optimizer, Muon):
+                    muon_lr = get_wsd_lr(step,args.muon_lr)
+                    for param_group in optimizer.param_groups:
+                        param_group['lr'] = muon_lr
+                    optimizer.step()
+                else:
+                    raise ValueError(f"Unsupported optimizer: {type(optimizer)}")
+            
+            
+            if params_before_optimizer_step is not None:
+                # Clean up old update to save memory
+                if last_training_update is not None:
+                    del last_training_update
+                
+                last_training_update = [
+                    p.detach() - p_before
+                    for p_before, p in zip(params_before_optimizer_step, raw_model_uncompiled.parameters())
+                ]
+                del params_before_optimizer_step
+            
+            # --------------- TRAINING SECTION END -------------------
+
+            # wait on the CPU for all device work to end so we get accurate per-iteration timings below
+            if device == "mps":
+                torch.mps.synchronize()
+            elif device == "cuda":
+                torch.cuda.synchronize()
+            # time and print
+            t1 = time.time()
+            # the 0th iteration is often an outlier (much slower) => skip logging it
+            tokens_per_second = grad_accum_steps * ddp_world_size * B * T / (t1-t0)
+            print0(f"step {step+1:4d}/{args.num_iterations} | train loss {lossf:.6f} | norm {norm:.4f} | ({(t1-t0)*1000:.2f} ms | {tokens_per_second:.0f} tok/s)")
+            # log to logile
+            if master_process and logfile is not None:
+                with open(logfile, "a") as f:
+                    f.write("step:%d train loss:%f\n" % (step, lossf))
+
+            # keep track of smooth timings, last 20 iterations
+            if step > 0 and step > args.num_iterations - 20:
+                timings.append(t1-t0)
+
+        # print the average of the last 20 timings, to get something smooth-ish
+        timings = timings[-20:]
+        print0(f"final {len(timings)} iters avg: {np.mean(timings)*1000:.3f}ms")
+        print0(f"peak memory consumption: {torch.cuda.max_memory_allocated() // 1024 // 1024} MiB")
+
+        # -------------------------------------------------------------------------
+        # clean up nice
+    if ddp:
+        destroy_process_group()step:0 validation loss:11.020913

logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm/opt_adam_alr_0.005_mlr_0.01_seed_43/config.json

@@ -0,0 +1,41 @@
+{
+    "cli_args": {
+        "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",
+        "output_dir": "/home/aiops/zhangfz/MUON_sharpness/logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm",
+        "model": "d12",
+        "batch_size": 4,
+        "sequence_length": 1024,
+        "total_batch_size": 524288,
+        "num_iterations": 10000,
+        "inference_only": 0,
+        "adam_lr": 0.005,
+        "warmup_iters": 1500,
+        "lr_decay_frac": 0.0,
+        "weight_decay": 0.0,
+        "grad_clip": 100000.0,
+        "val_loss_every": 250,
+        "val_max_steps": 20,
+        "sample_every": 0,
+        "overfit_single_batch": 0,
+        "shuffle_files": true,
+        "tensorcores": 1,
+        "device": "",
+        "compile": 1,
+        "flash": 1,
+        "dtype": "bfloat16",
+        "zero_stage": 1,
+        "optimizer": "adam",
+        "muon_lr": 0.01,
+        "muon_momentum": 0.95,
+        "muon_weight_decay": 0.0,
+        "muon_ns_steps": 5,
+        "muon_nesterov": false,
+        "write_tensors": 0,
+        "seed": 43,
+        "analyze_sharpness": false,
+        "sharpness_analysis_interval": 500
+    },
+    "run_uuid": "c99b1b66-7532-4deb-823d-bdfbb8c6549a",
+    "script_code_logged_at_start": true
+}

logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm/opt_adam_alr_0.005_mlr_0.01_seed_44/config.json

@@ -0,0 +1,41 @@
+{
+    "cli_args": {
+        "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",
+        "output_dir": "/home/aiops/zhangfz/MUON_sharpness/logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm",
+        "model": "d12",
+        "batch_size": 4,
+        "sequence_length": 1024,
+        "total_batch_size": 524288,
+        "num_iterations": 10000,
+        "inference_only": 0,
+        "adam_lr": 0.005,
+        "warmup_iters": 1500,
+        "lr_decay_frac": 0.0,
+        "weight_decay": 0.0,
+        "grad_clip": 100000.0,
+        "val_loss_every": 250,
+        "val_max_steps": 20,
+        "sample_every": 0,
+        "overfit_single_batch": 0,
+        "shuffle_files": true,
+        "tensorcores": 1,
+        "device": "",
+        "compile": 1,
+        "flash": 1,
+        "dtype": "bfloat16",
+        "zero_stage": 1,
+        "optimizer": "adam",
+        "muon_lr": 0.01,
+        "muon_momentum": 0.95,
+        "muon_weight_decay": 0.0,
+        "muon_ns_steps": 5,
+        "muon_nesterov": false,
+        "write_tensors": 0,
+        "seed": 44,
+        "analyze_sharpness": false,
+        "sharpness_analysis_interval": 500
+    },
+    "run_uuid": "5a199f32-8e9a-4ef5-b431-c80a5fd4dcd9",
+    "script_code_logged_at_start": true
+}

logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm/opt_adam_alr_0.01_mlr_0.01_seed_42/config.json

@@ -0,0 +1,41 @@
+{
+    "cli_args": {
+        "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",
+        "output_dir": "/home/aiops/zhangfz/MUON_sharpness/logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm",
+        "model": "d12",
+        "batch_size": 4,
+        "sequence_length": 1024,
+        "total_batch_size": 524288,
+        "num_iterations": 10000,
+        "inference_only": 0,
+        "adam_lr": 0.01,
+        "warmup_iters": 1500,
+        "lr_decay_frac": 0.0,
+        "weight_decay": 0.0,
+        "grad_clip": 100000.0,
+        "val_loss_every": 250,
+        "val_max_steps": 20,
+        "sample_every": 0,
+        "overfit_single_batch": 0,
+        "shuffle_files": true,
+        "tensorcores": 1,
+        "device": "",
+        "compile": 1,
+        "flash": 1,
+        "dtype": "bfloat16",
+        "zero_stage": 1,
+        "optimizer": "adam",
+        "muon_lr": 0.01,
+        "muon_momentum": 0.95,
+        "muon_weight_decay": 0.0,
+        "muon_ns_steps": 5,
+        "muon_nesterov": false,
+        "write_tensors": 0,
+        "seed": 42,
+        "analyze_sharpness": false,
+        "sharpness_analysis_interval": 500
+    },
+    "run_uuid": "fa3316af-70cf-44df-ad5e-5695fe819bde",
+    "script_code_logged_at_start": true
+}

logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm/opt_adam_alr_0.01_mlr_0.01_seed_42/training_log.txt

@@ -0,0 +1,1819 @@
+"""
+Reference code for GPT-2 training and inference with Sharpness Analysis.
+Will save the model weights into files, to be read from C as initialization.
+
+References:
+1) the official GPT-2 TensorFlow implementation released by OpenAI:
+https://github.com/openai/gpt-2/blob/master/src/model.py
+2) huggingface/transformers PyTorch implementation:
+https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt2/modeling_gpt2.py
+
+Example launches to only benchmark the speed of bfloat16 compiled GPU training:
+1 GPU:
+python train_gpt2.py --write_tensors=0 --num_iterations=50 --sequence_length=1024 --compile=1 --tensorcores=1 --dtype=bfloat16
+you can also turn on flash-attention by appending --flash=1
+4 GPU:
+torchrun --standalone --nproc_per_node=4 train_gpt2.py --write_tensors=0 --num_iterations=50 --sequence_length=1024 --compile=1 --tensorcores=1 --dtype=bfloat16
+"""
+import sys
+with open(sys.argv[0]) as f:
+    code = f.read() # read the code of this file ASAP, for logging
+
+import os
+import math
+import glob
+import struct
+import inspect
+from contextlib import nullcontext
+from dataclasses import dataclass
+import random
+
+import numpy as np
+import torch
+from torch import Tensor
+import torch.nn as nn
+from torch.nn import functional as F
+import torch._inductor.config as config
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.distributed import init_process_group, destroy_process_group
+from torch.distributed.optim import ZeroRedundancyOptimizer
+import torch.distributed as dist
+from torch.amp import autocast
+import copy
+import gc
+import uuid
+import json
+from pathlib import Path
+
+# Import Muon optimizer
+import sys
+sys.path.append("/home/aiops/zhangfz/MUON_sharpness/modded-nanogpt/optimizers")
+from MUON_fix import Muon
+
+# Import GPT model
+sys.path.append("/home/aiops/zhangfz/MUON_sharpness/modded-nanogpt/models")
+import  nano_GPT_qkvonorm_pure
+from nano_GPT_qkvonorm_pure import GPT, GPTConfig
+
+# Import debug utilities
+# from debug_utils import setup_debugpy
+
+# -----------------------------------------------------------------------------
+# 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,
+                 shuffle_files=False, random_seed=None):
+        self.process_rank = process_rank
+        self.num_processes = num_processes
+        self.B = B
+        self.T = T
+        self.shuffle_files = shuffle_files
+        self.random_seed = random_seed
+        self._rng = random.Random(random_seed) if shuffle_files and random_seed is not None else None
+
+        # 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}"
+        if self.shuffle_files:
+            self._shuffle_files()
+
+        # 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 += shard_ntok
+        self.ntok_total = ntok_total
+        print0(f"DataLoader: total number of tokens: {ntok_total:,} across {len(self.files)} files")
+
+        # kick things off
+        self.current_shard = None
+        self.reset()
+
+    def reset(self):
+        # we're being a bit clever here: if we already had shard 0 loaded,
+        # then don't do the work to reload it, just reset the pointer
+        if self.current_shard != 0:
+            self.current_shard = 0
+            self.tokens = _load_data_shard(self.files[self.current_shard])
+        self.current_position = self.process_rank * self.B * self.T
+
+    def advance(self): # advance to next data shard
+        next_shard = (self.current_shard + 1) % len(self.files)
+        if next_shard == 0 and self.shuffle_files:
+            self._shuffle_files()
+        self.current_shard = next_shard
+        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 the start pointer in current shard
+        self.current_position += B * T * self.num_processes
+        # if loading the next batch would be out of bounds advance the shard
+        if self.current_position + (B * T * self.num_processes + 1) > len(self.tokens):
+            self.advance()
+        return x, y
+
+    def _shuffle_files(self):
+        if self._rng is not None:
+            self._rng.shuffle(self.files)
+        else:
+            random.shuffle(self.files)
+
+# -----------------------------------------------------------------------------
+# Python -> C bridge utilities for saving params/grads/activations to .bin files
+
+def write_fp32(tensor, file):
+    t = tensor.detach().cpu().to(torch.float32)
+    b = t.numpy().tobytes()
+    file.write(b)
+
+def write_bf16(tensor, file):
+    t = tensor.detach().cpu().to(torch.bfloat16)
+    # numpy doesn't have bf16 datatype so we have to trick it
+    t = t.view(torch.int16) # trick: reinterpret as int16
+    b = t.numpy().tobytes()
+    file.write(b)
+
+def write_tensors(model_tensors, L, file, dtype):
+    # writes the GPT-2 model's weights to a binary file
+    assert dtype in {"float32", "bfloat16"}
+    write_fun = write_fp32 if dtype == "float32" else write_bf16
+    write_fun(model_tensors["transformer.wte.weight"], file) # (V, C)
+    write_fun(model_tensors["transformer.wpe.weight"], file) # (T, C)
+    for i in range(L): # (L, C)
+        write_fun(model_tensors[f"transformer.h.{i}.ln_1.weight"], file)
+    for i in range(L): # (L, C)
+        write_fun(model_tensors[f"transformer.h.{i}.ln_1.bias"], file)
+    for i in range(L): # (L, 3C, C)
+        write_fun(model_tensors[f"transformer.h.{i}.attn.c_attn.weight"], file)
+    for i in range(L): # (L, 3C)
+        write_fun(model_tensors[f"transformer.h.{i}.attn.c_attn.bias"], file)
+    for i in range(L): # (L, C, C)
+        write_fun(model_tensors[f"transformer.h.{i}.attn.c_proj.weight"], file)
+    for i in range(L): # (L, C)
+        write_fun(model_tensors[f"transformer.h.{i}.attn.c_proj.bias"], file)
+    for i in range(L): # (L, C)
+        write_fun(model_tensors[f"transformer.h.{i}.ln_2.weight"], file)
+    for i in range(L): # (L, C)
+        write_fun(model_tensors[f"transformer.h.{i}.ln_2.bias"], file)
+    for i in range(L): # (L, 4C, C)
+        write_fun(model_tensors[f"transformer.h.{i}.mlp.c_fc.weight"], file)
+    for i in range(L): # (L, 4C)
+        write_fun(model_tensors[f"transformer.h.{i}.mlp.c_fc.bias"], file)
+    for i in range(L): # (L, C, 4C)
+        write_fun(model_tensors[f"transformer.h.{i}.mlp.c_proj.weight"], file)
+    for i in range(L): # (L, C)
+        write_fun(model_tensors[f"transformer.h.{i}.mlp.c_proj.bias"], file)
+    write_fun(model_tensors["transformer.ln_f.weight"], file) # (C, )
+    write_fun(model_tensors["transformer.ln_f.bias"], file) # (C, )
+
+@torch.no_grad()
+def pad_vocab(tensor, multiple=128, value=0):
+    """
+    The dimension of the vocab size in GPT-2 is 50,257
+    which is unfortunately a very unfriendly number for a lot of
+    matrix operations on the GPU. So we pad it to the nearest
+    friendlier multiple, e.g. 50,304 if multiple=128 when we
+    export the weights into C land. This is a NOOP algorithmically
+    and is only done to make the tensor operations more efficient.
+    """
+    assert tensor.ndim == 2
+    V, C = tensor.shape
+    assert V == 50257, "just being defensive here"
+    # calculate padded vocab size by rounding up to nearest multiple
+    Vp = ((V + multiple - 1) // multiple) * multiple
+    # pad the tensor
+    pad_rows = Vp - V
+    padded = tensor if pad_rows == 0 else F.pad(tensor, (0, 0, 0, pad_rows), value=value)
+    assert padded.shape == (Vp, C)
+    return padded
+
+def write_model(model, filename, dtype):
+    # everything we need to instantiate the model
+    # 1) header is: version int, GPTConfig ints, padding to 1024 bytes
+    assert dtype in {"float32", "bfloat16"} # float16 todo maybe later
+    version = {
+        "float32": 3, # 3: all tensors are fp32, padded vocab
+        "bfloat16": 5, # 5: all tensors are bf16, padded vocab
+    }[dtype]
+    header = torch.zeros(256, dtype=torch.int32)
+    header[0] = 20240326 # magic
+    header[1] = version # checkpoint version
+    header[2] = model.config.block_size
+    header[3] = model.config.vocab_size
+    header[4] = model.config.n_layer
+    header[5] = model.config.n_head
+    header[6] = model.config.n_embd
+    # 2) the parameters follow the header
+    params = {name: param.cpu() for name, param in model.named_parameters()}
+    # pad the vocab to a multiple of 128 here at export, for efficiency in C
+    wte = params["transformer.wte.weight"] # (V, C)
+    wte_padded = pad_vocab(wte) # (Vp, C)
+    params["transformer.wte.weight"] = wte_padded # (Vp, C)
+    print(f"padded vocab size from {wte.size(0)} to {wte_padded.size(0)}")
+    header[7] = wte_padded.size(0) # padded vocab size store in header
+    # now write to file
+    with open(filename, "wb") as file:
+        file.write(header.numpy().tobytes()) # header
+        write_tensors(params, model.config.n_layer, file, dtype) # params
+    print(f"wrote {filename}")
+
+def write_state(model, x, y, logits, loss, filename):
+    # the state is used for debugging.
+    # it contains information about the input, logits, loss, and the parameter gradients
+    # this can be used for checking the computation correctness in C
+    header = torch.zeros(256, dtype=torch.int32)
+    header[0] = 20240327 # magic
+    header[1] = 2 # run state version = 2 (1 -> 2 for padded vocab changes)
+    header[2] = x.size(0) # batch size of the batch, B
+    header[3] = x.size(1) # temporal extent of the batch, T
+    grads = {name: param.grad.cpu() for name, param in model.named_parameters()}
+    # pad the vocab grads here as well, to mirror write_model
+    wte_grad = grads["transformer.wte.weight"] # (V, C)
+    wte_grad_padded = pad_vocab(wte_grad, value=0) # (Vp, C) # TODO later maybe pad with nan?
+    grads["transformer.wte.weight"] = wte_grad_padded # (Vp, C)
+    print(f"padded vocab size in reference grads from {wte_grad.size(0)} to {wte_grad_padded.size(0)}")
+    with open(filename, "wb") as file:
+        # header
+        file.write(header.numpy().tobytes())
+        # input x
+        file.write(x.cpu().numpy().astype("int32").tobytes()) # (B, T)
+        # targets y
+        file.write(y.cpu().numpy().astype("int32").tobytes()) # (B, T)
+        # logits (result of the model forward pass)
+        write_fp32(logits.cpu(), file)
+        # loss (single float, result of the cross entropy loss)
+        write_fp32(loss.cpu(), file)
+        # gradients
+        write_tensors(grads, model.config.n_layer, file, "float32")
+    print(f"wrote {filename}")
+
+def write_tokenizer(enc, filename):
+    n = enc.max_token_value + 1
+    header = torch.zeros(256, dtype=torch.int32)
+    header[0] = 20240328 # magic
+    header[1] = 2 # tokenizer version = 2 (1 -> 2: includes EOT token)
+    header[2] = n # number of tokens
+    header[3] = enc.eot_token # EOT token
+    with open(filename, "wb") as file:
+        file.write(header.numpy().tobytes())
+        for i in range(n):
+            b = enc.decode_bytes([i])
+            length = len(b)
+            assert length < 256, f"Token length exceeds 255: {length}"
+            file.write(struct.pack("<B", length))  # Write the length as a 1-byte unsigned integer
+            file.write(b)  # Write the actual bytes
+    print(f"wrote {filename}")
+
+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
+
+# -----------------------------------------------------------------------------
+# Helper functions for norm calculations
+
+def calculate_l1_to_linf_norm(matrix):
+    if matrix.ndim == 1:
+        return torch.sum(torch.abs(matrix))
+    elif matrix.ndim == 2:
+        # Each row's L1 norm, then take maximum
+        row_l1_norms = torch.sum(torch.abs(matrix), dim=1)
+        return torch.max(row_l1_norms)
+    else:
+        # For higher-dimensional tensors, flatten to 2D
+        matrix_2d = matrix.view(matrix.shape[0], -1)
+        row_l1_norms = torch.sum(torch.abs(matrix_2d), dim=1)
+        return torch.max(row_l1_norms)
+
+def calculate_spectral_norm(matrix):
+    """
+    Calculate the spectral norm (largest singular value) of a matrix.
+    For vectors, returns the L2 norm.
+    """
+    # Convert to float32 if needed for linalg operations
+    if matrix.dtype in [torch.bfloat16, torch.float16]:
+        matrix = matrix.float()
+    
+    if matrix.ndim == 1:
+        return torch.norm(matrix, p=2)
+    elif matrix.ndim == 2:
+        # Use matrix 2-norm (largest singular value)
+        return torch.linalg.matrix_norm(matrix, ord=2)
+    else:
+        # For higher-dimensional tensors, flatten to 2D
+        matrix_2d = matrix.view(matrix.shape[0], -1)
+        return torch.linalg.matrix_norm(matrix_2d, ord=2)
+
+# -----------------------------------------------------------------------------
+# Comprehensive sharpness analysis function
+
+def calculate_comprehensive_sharpness(model, model_for_forward, optimizers, step, train_loader, val_loader,
+                                      rank, world_size, device, B, T, ptdtype, grad_accum_steps, last_training_update=None, last_training_gradient=None, last_training_batches=None):
+    prev_training_mode = model.training
+    model.eval()
+    
+    NUM_LAYERS = model.config.n_layer # Number of transformer blocks
+    analysis_results = {}
+    
+    # --- 1. Get the true update direction 'v' ---
+    assert last_training_update is not None, \
+        f"[Step {step}] BUG: last_training_update is None! Check sharpness timing logic."
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] Using update from previous training step")
+    update_direction_v = last_training_update
+    
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] Restoring parameters to θ_t for HVP calculation...")
+    with torch.no_grad():
+        for p, v in zip(model.parameters(), update_direction_v):
+            p.data.sub_(v)  # Now parameters are at θ_t
+    
+    # --- 2. Calculate update norms (Frobenius, Max-of-Max, Spectral) ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Calculating update norms...")
+    
+    total_update_norm_sq = sum(torch.sum(v * v) for v in update_direction_v)
+    dist.all_reduce(total_update_norm_sq, op=dist.ReduceOp.AVG)
+    analysis_results["total_update_fnorm"] = torch.sqrt(total_update_norm_sq).item()
+    
+    # Calculate TOTAL update Max-of-Max and Spectral norms
+    print0(f"[Enhanced Sharpness @ Step {step}] Calculating total update Max-of-Max and Spectral norms...")
+    try:
+        all_updates_flat = torch.cat([v.flatten() for v in update_direction_v if v.numel() > 0])
+        
+        if all_updates_flat.numel() > 0:
+            total_l1_linf_norm = torch.sum(torch.abs(all_updates_flat))
+            analysis_results["total_l1_linf_norm"] = total_l1_linf_norm.item()
+            
+            total_spectral_norm = torch.norm(all_updates_flat, p=2)
+            analysis_results["total_spectral_norm"] = total_spectral_norm.item()
+        else:
+            analysis_results["total_l1_linf_norm"] = 0.0
+            analysis_results["total_spectral_norm"] = 0.0
+            
+        del all_updates_flat
+    except Exception as e:
+        print0(f"[Enhanced Sharpness @ Step {step}] Error calculating total norms: {e}")
+        analysis_results["total_l1_linf_norm"] = 0.0
+        analysis_results["total_spectral_norm"] = 0.0
+    
+    # --- 3. Setup layer parameter groups (adapt to new model structure) ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Setting up layer parameter groups...")
+    
+    all_param_groups = {}
+    
+    
+    all_param_groups["embed_lm_head"] = list(model.lm_head.parameters())
+    
+    blocks = model.transformer.h
+    
+    for i, block in enumerate(blocks):
+        layer_name = f"layer_{i+1}"
+        all_param_groups[layer_name] = list(block.parameters())
+    
+    # Add fine-grained params for selected layers (0, 3, 7, 11)
+    selected_layers = [0, 3, 7, 11]
+    for layer_idx in selected_layers:
+        block = blocks[layer_idx]
+        prefix = f"block{layer_idx}"
+        # Attention: Q, K, V, O
+        all_param_groups[f"{prefix}_q"] = [block.attn.q_w.weight]
+        all_param_groups[f"{prefix}_k"] = [block.attn.k_w.weight]
+        all_param_groups[f"{prefix}_v"] = [block.attn.v_w.weight]
+        all_param_groups[f"{prefix}_o"] = [block.attn.c_proj.weight]
+        # MLP: c_fc (win) and c_proj (wout)
+        all_param_groups[f"{prefix}_mlp_win"] = [block.mlp.c_fc.weight]
+        all_param_groups[f"{prefix}_mlp_wout"] = [block.mlp.c_proj.weight]
+    
+    # --- 4. Calculate layer-wise update norms ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Calculating layer-wise update norms...")
+    
+    param_to_idx = {id(p): i for i, p in enumerate(model.parameters())}
+    
+    for group_name, param_group in all_param_groups.items():
+        if not param_group:
+            continue
+            
+        # Get indices for this group
+        indices = [param_to_idx[id(p)] for p in param_group if id(p) in param_to_idx]
+        if not indices:
+            continue
+        
+        # Calculate Frobenius norm for this group
+        group_update_norm_sq = sum(torch.sum(update_direction_v[i] * update_direction_v[i]) for i in indices)
+        dist.all_reduce(group_update_norm_sq, op=dist.ReduceOp.AVG)
+        analysis_results[f"{group_name}_update_fnorm"] = torch.sqrt(group_update_norm_sq).item()
+        
+        # Calculate Max-of-Max and Spectral norms for this group
+        group_l1_linf_norms = []
+        group_spectral_norms = []
+        
+        for i in indices:
+            if i < len(update_direction_v) and update_direction_v[i].numel() > 0:
+                try:
+                    l1_linf_norm = calculate_l1_to_linf_norm(update_direction_v[i])
+                    group_l1_linf_norms.append(l1_linf_norm.item())
+                    
+                    spectral_norm = calculate_spectral_norm(update_direction_v[i])
+                    group_spectral_norms.append(spectral_norm.item())
+                except Exception as e:
+                    print0(f"[Enhanced Sharpness @ Step {step}] Error calculating norms for group {group_name}, param {i}: {e}")
+                    group_l1_linf_norms.append(0.0)
+                    group_spectral_norms.append(0.0)
+        
+        if group_l1_linf_norms:
+            analysis_results[f"{group_name}_max_l1_linf_norm"] = max(group_l1_linf_norms)
+        else:
+            analysis_results[f"{group_name}_max_l1_linf_norm"] = 0.0
+            
+        if group_spectral_norms:
+            analysis_results[f"{group_name}_max_spectral_norm"] = max(group_spectral_norms)
+        else:
+            analysis_results[f"{group_name}_max_spectral_norm"] = 0.0
+    
+    # --- 5. Setup for HVP calculation on TRAIN data ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Setting up HVP calculation in {ptdtype} on TRAIN data...")
+    
+    original_flash = nano_GPT_qkvonorm_pure.FLASH
+    nano_GPT_qkvonorm_pure.FLASH = 0
+    print0(f"[Enhanced Sharpness @ Step {step}] Disabled FLASH attention for HVP (was {original_flash})")
+
+    # Get block parameter indices for cross-layer analysis (need this before loop)
+    block_param_indices = set()
+    for group_name, param_group in all_param_groups.items():
+        if group_name.startswith("layer_"):
+            for p in param_group:
+                if id(p) in param_to_idx:
+                    block_param_indices.add(param_to_idx[id(p)])
+
+    # Initialize accumulators for all quantities we need
+    grads_hvp = None          
+    hvp_v_total = None        
+    hvp_v_block = None        
+    hvp_g_accum = None       
+    layer_hvp_accum = {}
+    
+   
+    group_names_to_process = [gn for gn, pg in all_param_groups.items() 
+                              if pg and any(id(p) in param_to_idx for p in pg)]
+    
+    if last_training_batches is not None and len(last_training_batches) > 0:
+        
+        batch_iterator = [(x, y) for x, y in last_training_batches]
+        n_batches = len(batch_iterator)
+        print0(f"[Enhanced Sharpness @ Step {step}] Using {n_batches} microbatches for HVP (out of {grad_accum_steps} training microbatches)")
+        restore_loader = False
+    else:
+        # Fallback: use new batches from train_loader (should rarely happen)
+        print0(f"[Enhanced Sharpness @ Step {step}] WARNING: last_training_batches is None/empty, using {grad_accum_steps} new batches (inconsistent)")
+        saved_current_shard = train_loader.current_shard
+        saved_current_position = train_loader.current_position
+        n_batches = grad_accum_steps  # Use same number as training for consistency
+        batch_iterator = []
+        shard_was_changed = False
+        for _ in range(n_batches):
+            x_hvp, y_hvp = train_loader.next_batch()
+            batch_iterator.append((x_hvp, y_hvp))
+            shard_was_changed = shard_was_changed or (train_loader.current_shard != saved_current_shard)
+        restore_loader = True
+
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] Computing HVPs for {n_batches} microbatches")
+    for mb_idx, (x_hvp, y_hvp) in enumerate(batch_iterator):
+        x_hvp, y_hvp = x_hvp.to(device), y_hvp.to(device)
+        
+        
+        _, loss_mb = model(x_hvp, y_hvp, return_logits=False)
+        grads_mb = torch.autograd.grad(loss_mb, model.parameters(), create_graph=True, allow_unused=True)
+        
+        # Compute H·v (total sharpness)
+        v_dot_g_total = sum(torch.sum(g * v) for g, v in zip(grads_mb, update_direction_v) if g is not None)
+        
+        if not isinstance(v_dot_g_total, torch.Tensor):
+            v_dot_g_total = torch.tensor(0.0, device=device, requires_grad=True)
+        hvp_v_total_mb = torch.autograd.grad(v_dot_g_total, model.parameters(), retain_graph=True, allow_unused=True)
+        
+        # Compute H·v_block (block-only sharpness)
+        if block_param_indices:  
+            v_dot_g_block = sum(torch.sum(grads_mb[i] * update_direction_v[i]) 
+                               for i in block_param_indices if grads_mb[i] is not None)
+            if not isinstance(v_dot_g_block, torch.Tensor):
+                v_dot_g_block = torch.tensor(0.0, device=device, requires_grad=True)
+            hvp_v_block_mb = torch.autograd.grad(v_dot_g_block, model.parameters(), retain_graph=True, allow_unused=True)
+        else:
+            
+            hvp_v_block_mb = [None] * len(list(model.parameters()))
+        
+        
+        g_dot_g = sum(torch.sum(g * g) for g in grads_mb if g is not None)
+        if not isinstance(g_dot_g, torch.Tensor):
+            g_dot_g = torch.tensor(0.0, device=device, requires_grad=True)
+        
+        
+        hvp_g_mb_raw = torch.autograd.grad(g_dot_g, model.parameters(), 
+                                           retain_graph=True, allow_unused=True)
+        hvp_g_mb = [h / 2.0 if h is not None else None for h in hvp_g_mb_raw]
+        
+        # Compute per-layer H_kk·v_k (for layer-wise sharpness)
+        for group_idx, group_name in enumerate(group_names_to_process):
+            param_group = all_param_groups[group_name]
+            indices = {param_to_idx[id(p)] for p in param_group if id(p) in param_to_idx}
+            if not indices:
+                continue
+            
+            is_last_layer = (group_idx == len(group_names_to_process) - 1)
+            is_last_microbatch = (mb_idx == n_batches - 1)
+            need_retain = not (is_last_layer and is_last_microbatch)
+            
+            try:
+                v_dot_g_layer = sum(torch.sum(grads_mb[i] * update_direction_v[i]) 
+                                   for i in indices if grads_mb[i] is not None)
+                
+                if not isinstance(v_dot_g_layer, torch.Tensor):
+                    v_dot_g_layer = torch.tensor(0.0, device=device, requires_grad=True)
+                    
+                hvp_layer_mb = torch.autograd.grad(v_dot_g_layer, model.parameters(), 
+                                                   retain_graph=need_retain,
+                                                   allow_unused=True)
+
+                if group_name not in layer_hvp_accum:
+                    layer_hvp_accum[group_name] = [(h.detach() / n_batches).cpu() if h is not None else None for h in hvp_layer_mb]
+                else:
+                    layer_hvp_accum[group_name] = [
+                        (h_acc + (h.detach() / n_batches).cpu()) if (h is not None and h_acc is not None)
+                        else ((h.detach() / n_batches).cpu() if h is not None else h_acc)
+                        for h_acc, h in zip(layer_hvp_accum[group_name], hvp_layer_mb)
+                    ]
+                
+                # Accumulate layer HVP
+                # if group_name not in layer_hvp_accum:
+                #     layer_hvp_accum[group_name] = [h.detach() / n_batches if h is not None else None for h in hvp_layer_mb]
+                # else:
+                #     layer_hvp_accum[group_name] = [
+                #         (h_acc + h.detach() / n_batches) if (h is not None and h_acc is not None)
+                #         else (h.detach() / n_batches if h is not None else h_acc)
+                #         for h_acc, h in zip(layer_hvp_accum[group_name], hvp_layer_mb)
+                #     ]
+                #     del hvp_layer_mb, v_dot_g_layer
+                #     torch.cuda.empty_cache()
+            except Exception as e:
+                print0(f"[Enhanced Sharpness @ Step {step}] Error computing layer HVP for '{group_name}' in microbatch {mb_idx}: {e}")
+                if group_name not in layer_hvp_accum:
+                    layer_hvp_accum[group_name] = None
+        
+        # 6. Accumulate all quantities
+        if grads_hvp is None:
+            grads_hvp = [(g.detach() / n_batches).cpu() if g is not None else None for g in grads_mb]
+            hvp_v_total = [(h.detach() / n_batches).cpu() if h is not None else None for h in hvp_v_total_mb]
+            hvp_v_block = [(h.detach() / n_batches).cpu() if h is not None else None for h in hvp_v_block_mb]
+            hvp_g_accum = [(h.detach() / n_batches).cpu() if h is not None else None for h in hvp_g_mb]
+        else:
+            grads_hvp = [
+                (g_acc + (g.detach() / n_batches).cpu()) if (g is not None and g_acc is not None) 
+                else ((g.detach() / n_batches).cpu() if g is not None else g_acc)
+                for g_acc, g in zip(grads_hvp, grads_mb)
+            ]
+            hvp_v_total = [
+                (h_acc + (h.detach() / n_batches).cpu()) if (h is not None and h_acc is not None)
+                else ((h.detach() / n_batches).cpu() if h is not None else h_acc)
+                for h_acc, h in zip(hvp_v_total, hvp_v_total_mb)
+            ]
+            hvp_v_block = [
+                (h_acc + (h.detach() / n_batches).cpu()) if (h is not None and h_acc is not None)
+                else ((h.detach() / n_batches).cpu() if h is not None else h_acc)
+                for h_acc, h in zip(hvp_v_block, hvp_v_block_mb)
+            ]
+            hvp_g_accum = [
+                (h_acc + (h.detach() / n_batches).cpu()) if (h is not None and h_acc is not None)
+                else ((h.detach() / n_batches).cpu() if h is not None else h_acc)
+                for h_acc, h in zip(hvp_g_accum, hvp_g_mb)
+            ]
+
+        
+        
+        if mb_idx % max(1, n_batches // 4) == 0:
+            print0(f"[Enhanced Sharpness @ Step {step}] Processed microbatch {mb_idx + 1}/{n_batches}")
+    
+   
+    if restore_loader:
+        train_loader.current_shard = saved_current_shard
+        train_loader.current_position = saved_current_position
+        if shard_was_changed:
+            train_loader.tokens = _load_data_shard(train_loader.files[train_loader.current_shard])
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] Finished computing all HVPs for {n_batches} microbatches")
+    grads_hvp = [g.to(device) if g is not None else None for g in grads_hvp]
+    hvp_v_total = [h.to(device) if h is not None else None for h in hvp_v_total]
+    hvp_v_block = [h.to(device) if h is not None else None for h in hvp_v_block]
+    hvp_g_accum = [h.to(device) if h is not None else None for h in hvp_g_accum]
+    for group_name in layer_hvp_accum:
+        if layer_hvp_accum[group_name] is not None:
+            layer_hvp_accum[group_name] = [h.to(device) if h is not None else None for h in layer_hvp_accum[group_name]]
+    # --- Calculate TOTAL sharpness ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Calculating TOTAL sharpness...")
+    # hvp_v_total is already computed in the loop above
+    vhp_dot_v_total = sum(torch.sum(hvp * v) for hvp, v in zip(hvp_v_total, update_direction_v) if hvp is not None)
+    v_norm_sq_total = sum(torch.sum(v * v) for v in update_direction_v)
+    
+    # Ensure they are tensors
+    if not isinstance(vhp_dot_v_total, torch.Tensor):
+        vhp_dot_v_total = torch.tensor(0.0, device=device)
+    if not isinstance(v_norm_sq_total, torch.Tensor):
+        v_norm_sq_total = torch.tensor(0.0, device=device)
+
+    dist.all_reduce(vhp_dot_v_total, op=dist.ReduceOp.AVG)
+    dist.all_reduce(v_norm_sq_total, op=dist.ReduceOp.AVG)
+
+    if v_norm_sq_total.item() > 1e-12:
+        analysis_results["total_sharpness"] = (vhp_dot_v_total / v_norm_sq_total).item()
+    else:
+        analysis_results["total_sharpness"] = 0.0
+
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] Calculating BLOCK-ONLY total sharpness...")
+    # hvp_v_block is already computed in the loop above
+    if block_param_indices:  # Only compute if there are block parameters
+        # Compute v_block^T H v_block (only sum over block indices)
+        vhp_dot_v_block = sum(torch.sum(hvp_v_block[i] * update_direction_v[i]) 
+                              for i in block_param_indices if hvp_v_block[i] is not None)
+        
+        v_norm_sq_block = sum(torch.sum(update_direction_v[i] * update_direction_v[i]) 
+                              for i in block_param_indices)
+        
+        # Ensure they are tensors
+        if not isinstance(vhp_dot_v_block, torch.Tensor):
+            vhp_dot_v_block = torch.tensor(0.0, device=device)
+        if not isinstance(v_norm_sq_block, torch.Tensor):
+            v_norm_sq_block = torch.tensor(0.0, device=device)
+        
+        dist.all_reduce(vhp_dot_v_block, op=dist.ReduceOp.AVG)
+        dist.all_reduce(v_norm_sq_block, op=dist.ReduceOp.AVG)
+        
+        if v_norm_sq_block.item() > 1e-12:
+            analysis_results["block_total_sharpness"] = (vhp_dot_v_block / v_norm_sq_block).item()
+        else:
+            analysis_results["block_total_sharpness"] = 0.0
+        
+        analysis_results["v_norm_block"] = torch.sqrt(v_norm_sq_block).item()
+        analysis_results["v_T_H_v_block"] = vhp_dot_v_block.item()
+    else:
+        # No block parameters
+        analysis_results["block_total_sharpness"] = 0.0
+        analysis_results["v_norm_block"] = 0.0
+        analysis_results["v_T_H_v_block"] = 0.0
+    
+    torch.cuda.empty_cache()
+
+    # ---- Alignment metrics between update v and (negative) gradient g ----
+    eps = 1e-12
+    v_norm = torch.sqrt(v_norm_sq_total + eps)
+    analysis_results["v_norm"] = v_norm.item()
+    
+    # --- Version 1: g_hvp  ---
+    ip_v_neg_g_hvp = sum(torch.sum(v * (-g)) for v, g in zip(update_direction_v, grads_hvp) if g is not None)
+    g_hvp_norm_sq = sum(torch.sum(g * g) for g in grads_hvp if g is not None)
+    
+    if not isinstance(ip_v_neg_g_hvp, torch.Tensor):
+        ip_v_neg_g_hvp = torch.tensor(0.0, device=device)
+    if not isinstance(g_hvp_norm_sq, torch.Tensor):
+        g_hvp_norm_sq = torch.tensor(0.0, device=device)
+    dist.all_reduce(ip_v_neg_g_hvp, op=dist.ReduceOp.AVG)
+    dist.all_reduce(g_hvp_norm_sq, op=dist.ReduceOp.AVG)
+    g_hvp_norm = torch.sqrt(g_hvp_norm_sq + eps)
+    analysis_results["ip_v_neg_g_hvp"] = ip_v_neg_g_hvp.item()
+    analysis_results["cos_v_neg_g_hvp"] = (ip_v_neg_g_hvp / (v_norm * g_hvp_norm + eps)).item()
+    analysis_results["g_hvp_norm"] = g_hvp_norm.item()
+    
+    # --- Version 2: g_t (original gradient that produced v) ---
+    # last_training_gradient is the actual gradient from training that led to the update v
+    if last_training_gradient is not None:
+        ip_v_neg_g_t = sum(torch.sum(v * (-g)) for v, g in zip(update_direction_v, last_training_gradient) if g is not None)
+        g_t_norm_sq = sum(torch.sum(g * g) for g in last_training_gradient if g is not None)
+        dist.all_reduce(ip_v_neg_g_t, op=dist.ReduceOp.AVG)
+        dist.all_reduce(g_t_norm_sq, op=dist.ReduceOp.AVG)
+        g_t_norm = torch.sqrt(g_t_norm_sq + eps)
+        analysis_results["ip_v_neg_g_t"] = ip_v_neg_g_t.item()
+        analysis_results["cos_v_neg_g_t"] = (ip_v_neg_g_t / (v_norm * g_t_norm + eps)).item()
+        analysis_results["g_t_norm"] = g_t_norm.item()
+    else:
+        print0(f"[Enhanced Sharpness @ Step {step}] Warning: last_training_gradient is None, skipping g_t metrics")
+    
+    # Keep backward compatibility aliases (g_norm uses g_hvp for now)
+    g_norm_sq = g_hvp_norm_sq
+    g_norm = g_hvp_norm
+    analysis_results["g_norm"] = g_norm.item()
+
+    # ---- Cosine between v and Hv (curvature pull along v) ----
+    hv_norm_sq = sum(torch.sum(hvp * hvp) for hvp in hvp_v_total if hvp is not None)
+    if not isinstance(hv_norm_sq, torch.Tensor):
+        hv_norm_sq = torch.tensor(0.0, device=device)
+    dist.all_reduce(hv_norm_sq, op=dist.ReduceOp.AVG)
+    hv_norm = torch.sqrt(hv_norm_sq + eps)
+    ip_v_hv = vhp_dot_v_total  # already reduced AVG
+    analysis_results["hv_norm"] = hv_norm.item()
+    analysis_results["cos_v_hv"] = (ip_v_hv / (v_norm * hv_norm + eps)).item()
+
+    # ---- Cosine between g and Hg ----
+    # hvp_g_accum is already computed in the loop above
+    ip_g_hg = sum(torch.sum(g * hg) for g, hg in zip(grads_hvp, hvp_g_accum) if (g is not None and hg is not None))
+    hg_norm_sq = sum(torch.sum(hg * hg) for hg in hvp_g_accum if hg is not None)
+    if not isinstance(ip_g_hg, torch.Tensor):
+        ip_g_hg = torch.tensor(0.0, device=device)
+    if not isinstance(hg_norm_sq, torch.Tensor):
+        hg_norm_sq = torch.tensor(0.0, device=device)
+    dist.all_reduce(ip_g_hg, op=dist.ReduceOp.AVG)
+    dist.all_reduce(hg_norm_sq, op=dist.ReduceOp.AVG)
+    hg_norm = torch.sqrt(hg_norm_sq + eps)
+    analysis_results["hg_norm"] = hg_norm.item()
+    analysis_results["cos_g_hg"] = (ip_g_hg / (g_norm * hg_norm + eps)).item() if g_norm.item() > 0 else 0.0
+
+    # ---- Decompose v into parallel / perpendicular to -g ----
+    if g_norm.item() > 0:
+        v_parallel = [(torch.sum(v * (-g)) / (g_norm_sq + eps)) * (-g) if g is not None else torch.zeros_like(v)
+                      for v, g in zip(update_direction_v, grads_hvp)]
+        v_parallel_norm_sq = sum(torch.sum(vp * vp) for vp in v_parallel)
+        if not isinstance(v_parallel_norm_sq, torch.Tensor):
+            v_parallel_norm_sq = torch.tensor(0.0, device=device)
+        dist.all_reduce(v_parallel_norm_sq, op=dist.ReduceOp.AVG)
+        v_parallel_norm = torch.sqrt(v_parallel_norm_sq + eps)
+        v_perp_norm = torch.sqrt(torch.clamp(v_norm_sq_total - v_parallel_norm_sq, min=0.0) + eps)
+        analysis_results["v_parallel_norm"] = v_parallel_norm.item()
+        analysis_results["v_perp_norm"] = v_perp_norm.item()
+
+    # ---- Per-layer additions: cos_v_neg_g_layer, v_norm_layer ----
+    for group_name, param_group in all_param_groups.items():
+        indices = {param_to_idx[id(p)] for p in param_group if id(p) in param_to_idx}
+        if not indices:
+            continue
+        v_norm_sq_layer = sum(torch.sum(update_direction_v[i] * update_direction_v[i]) for i in indices)
+        g_norm_sq_layer = sum(torch.sum(grads_hvp[i] * grads_hvp[i]) for i in indices if grads_hvp[i] is not None)
+        ip_v_neg_g_layer = sum(torch.sum(update_direction_v[i] * (-grads_hvp[i]))
+                               for i in indices if grads_hvp[i] is not None)
+        # Ensure they are tensors
+        if not isinstance(v_norm_sq_layer, torch.Tensor):
+            v_norm_sq_layer = torch.tensor(0.0, device=device)
+        if not isinstance(g_norm_sq_layer, torch.Tensor):
+            g_norm_sq_layer = torch.tensor(0.0, device=device)
+        if not isinstance(ip_v_neg_g_layer, torch.Tensor):
+            ip_v_neg_g_layer = torch.tensor(0.0, device=device)
+        dist.all_reduce(v_norm_sq_layer, op=dist.ReduceOp.AVG)
+        dist.all_reduce(g_norm_sq_layer, op=dist.ReduceOp.AVG)
+        dist.all_reduce(ip_v_neg_g_layer, op=dist.ReduceOp.AVG)
+        v_norm_layer = torch.sqrt(v_norm_sq_layer + eps)
+        g_norm_layer = torch.sqrt(g_norm_sq_layer + eps)
+        analysis_results[f"{group_name}_v_norm"] = v_norm_layer.item()
+        if g_norm_layer.item() > 0:
+            analysis_results[f"{group_name}_cos_v_neg_g"] = (ip_v_neg_g_layer / (v_norm_layer * g_norm_layer + eps)).item()
+
+    # --- 7. Calculate layer-wise sharpness ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Calculating layer-wise sharpness...")
+    print0(f"[Enhanced Sharpness @ Step {step}] Processing {len(all_param_groups)} layers for sharpness...")
+    
+    for group_name, param_group in all_param_groups.items():
+        if not param_group:
+            continue
+            
+        print0(f"[Enhanced Sharpness @ Step {step}] Processing '{group_name}'...")
+        indices = {param_to_idx[id(p)] for p in param_group if id(p) in param_to_idx}
+        if not indices: 
+            continue
+
+        try:
+            if group_name not in layer_hvp_accum or layer_hvp_accum[group_name] is None:
+                print0(f"[Enhanced Sharpness @ Step {step}] No HVP data for '{group_name}', skipping")
+                analysis_results[f"{group_name}_sharpness"] = 0.0
+                continue
+                
+            hvp_group_result = layer_hvp_accum[group_name]
+            
+            vhp_dot_v_group = sum(torch.sum(hvp_group_result[i] * update_direction_v[i]) 
+                                for i in indices if hvp_group_result[i] is not None)
+            v_norm_sq_group = sum(torch.sum(update_direction_v[i] * update_direction_v[i]) 
+                                for i in indices)
+            
+            # Ensure they are tensors
+            if not isinstance(vhp_dot_v_group, torch.Tensor):
+                vhp_dot_v_group = torch.tensor(0.0, device=device)
+            if not isinstance(v_norm_sq_group, torch.Tensor):
+                v_norm_sq_group = torch.tensor(0.0, device=device)
+            
+            dist.all_reduce(vhp_dot_v_group, op=dist.ReduceOp.AVG)
+            dist.all_reduce(v_norm_sq_group, op=dist.ReduceOp.AVG)
+            
+            if v_norm_sq_group.item() > 1e-12:
+                analysis_results[f"{group_name}_sharpness"] = (vhp_dot_v_group / v_norm_sq_group).item()
+            else:
+                analysis_results[f"{group_name}_sharpness"] = 0.0
+            
+        except torch.OutOfMemoryError as e:
+            print0(f"[Enhanced Sharpness @ Step {step}] OOM error for '{group_name}': {e}")
+            analysis_results[f"{group_name}_sharpness"] = 0.0
+            torch.cuda.empty_cache()
+        except Exception as e:
+            print0(f"[Enhanced Sharpness @ Step {step}] Error processing '{group_name}': {e}")
+            analysis_results[f"{group_name}_sharpness"] = 0.0
+
+    # --- Calculate block-diagonal approximation and cross-layer interaction ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Calculating block-diagonal and cross-layer sharpness...")
+    
+    sum_layer_numerators = 0.0
+    for layer in range(1, NUM_LAYERS + 1):
+        layer_name = f"layer_{layer}"
+        if f"{layer_name}_sharpness" in analysis_results and f"{layer_name}_v_norm" in analysis_results:
+            s_k = analysis_results[f"{layer_name}_sharpness"]
+            v_k_norm = analysis_results[f"{layer_name}_v_norm"]
+            sum_layer_numerators += s_k * (v_k_norm ** 2)
+    
+    analysis_results["sum_layer_numerators"] = sum_layer_numerators
+    
+    # Block-diagonal sharpness (using block ||v||²)
+    v_norm_block = analysis_results.get("v_norm_block", 0)
+    v_norm_sq_block_val = v_norm_block ** 2 if v_norm_block else 1e-12
+    
+    if v_norm_sq_block_val > 1e-12:
+        analysis_results["block_diag_sharpness"] = sum_layer_numerators / v_norm_sq_block_val
+    else:
+        analysis_results["block_diag_sharpness"] = 0.0
+    
+    # Cross-layer interaction = block_total - block_diag
+    block_total = analysis_results.get("block_total_sharpness", 0)
+    block_diag = analysis_results.get("block_diag_sharpness", 0)
+    analysis_results["cross_layer_sharpness"] = block_total - block_diag
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] block_total={block_total:.6f}, block_diag={block_diag:.6f}, cross_layer={block_total - block_diag:.6f}")
+
+    # --- Compute true_dec and pred_dec ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Computing true_dec (L(t) - L(t+1)) on training batch...")
+    try:
+        # Restore FLASH for forward pass 
+        nano_GPT_qkvonorm_pure.FLASH = original_flash
+
+        
+        loss_at_theta_t = 0.0
+        with torch.no_grad():
+            for x_td, y_td in batch_iterator:
+                x_td, y_td = x_td.to(device), y_td.to(device)
+                _, loss_td = model(x_td, y_td, return_logits=False)
+                loss_at_theta_t += loss_td.item()
+        loss_at_theta_t /= len(batch_iterator)  # average over microbatches
+
+        with torch.no_grad():
+            for p, v in zip(model.parameters(), update_direction_v):
+                p.data.add_(v)
+
+        loss_at_theta_t1 = 0.0
+        with torch.no_grad():
+            for x_td, y_td in batch_iterator:
+                x_td, y_td = x_td.to(device), y_td.to(device)
+                _, loss_td = model(x_td, y_td, return_logits=False)
+                loss_at_theta_t1 += loss_td.item()
+        loss_at_theta_t1 /= len(batch_iterator)
+
+        with torch.no_grad():
+            for p, v in zip(model.parameters(), update_direction_v):
+                p.data.sub_(v)
+
+        loss_t_tensor = torch.tensor(loss_at_theta_t, device=device)
+        loss_t1_tensor = torch.tensor(loss_at_theta_t1, device=device)
+        dist.all_reduce(loss_t_tensor, op=dist.ReduceOp.AVG)
+        dist.all_reduce(loss_t1_tensor, op=dist.ReduceOp.AVG)
+        loss_at_theta_t = loss_t_tensor.item()
+        loss_at_theta_t1 = loss_t1_tensor.item()
+
+        true_dec = loss_at_theta_t - loss_at_theta_t1
+        analysis_results["loss_at_theta_t"] = loss_at_theta_t
+        analysis_results["loss_at_theta_t1"] = loss_at_theta_t1
+        analysis_results["true_dec"] = true_dec
+
+        # pred_dec = (-g)^T v - 0.5 * v^T H v 
+        first_order = analysis_results.get("ip_v_neg_g_t", analysis_results.get("ip_v_neg_g_hvp", 0.0))
+        sharpness_val = analysis_results.get("total_sharpness", 0.0)
+        v_norm_val = analysis_results.get("v_norm", 0.0)
+        curvature_term = 0.5 * sharpness_val * (v_norm_val ** 2)
+        pred_dec = first_order - curvature_term
+
+        analysis_results["pred_dec"] = pred_dec
+        analysis_results["first_order_descent"] = first_order
+        analysis_results["curvature_penalty"] = curvature_term
+
+        print0(f"[Enhanced Sharpness @ Step {step}] L(θ_t)={loss_at_theta_t:.6f}, L(θ_{{t+1}})={loss_at_theta_t1:.6f}, "
+               f"true_dec={true_dec:.6f}, pred_dec={pred_dec:.6f}, 1st_order={first_order:.6f}, curvature={curvature_term:.6f}")
+    except Exception as e:
+        print0(f"[Enhanced Sharpness @ Step {step}] Error computing true_dec: {e}")
+        analysis_results["true_dec"] = 0.0
+        analysis_results["pred_dec"] = 0.0
+
+    # --- Cleanup ---
+    nano_GPT_qkvonorm_pure.FLASH = original_flash
+    print0(f"[Enhanced Sharpness @ Step {step}] Restored FLASH attention to {original_flash}")
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] Restoring parameters back to θ_{{t+1}}...")
+    with torch.no_grad():
+        for p, v in zip(model.parameters(), update_direction_v):
+            p.data.add_(v)  
+    
+    if prev_training_mode:
+        model.train()
+    else:
+        model.eval()
+    
+    # Thorough cleanup of all temporary variables
+    del update_direction_v, grads_hvp
+    del hvp_v_total, hvp_v_block, hvp_g_accum, layer_hvp_accum
+    del vhp_dot_v_total, v_norm_sq_total
+    del vhp_dot_v_block, v_norm_sq_block
+    if 'all_param_groups' in locals():
+        del all_param_groups
+    if 'param_to_idx' in locals():
+        del param_to_idx
+    
+    # Synchronize CUDA operations before cleanup
+    if device == "cuda":
+        torch.cuda.synchronize()
+    
+    gc.collect()
+    torch.cuda.empty_cache()
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] Analysis complete. Generated {len(analysis_results)} metrics.")
+    return analysis_results
+
+def format_comprehensive_results(results):
+    """
+    Format the comprehensive analysis results for logging.
+    """
+    log_parts = []
+    
+    # Total sharpness
+    if 'total_sharpness' in results:
+        log_parts.append(f"total_sharp:{results['total_sharpness']:.4e}")
+    
+    # Layer-wise sharpness - dynamically detect number of layers
+    layer_sharpness = []
+    layer_num = 1
+    while True:
+        layer_key = f"layer_{layer_num}_sharpness"
+        if layer_key in results:
+            layer_sharpness.append(f"L{layer_num}_sharp:{results[layer_key]:.4e}")
+            layer_num += 1
+        else:
+            break
+    
+    if layer_sharpness:
+        log_parts.append(" ".join(layer_sharpness))
+    
+    # Total update norms
+    total_norms = []
+    if 'total_update_fnorm' in results:
+        total_norms.append(f"total_fnorm:{results['total_update_fnorm']:.4e}")
+    if 'total_l1_linf_norm' in results:
+        total_norms.append(f"total_l1_linf:{results['total_l1_linf_norm']:.4e}")
+    if 'total_spectral_norm' in results:
+        total_norms.append(f"total_spectral:{results['total_spectral_norm']:.4e}")
+    
+    if total_norms:
+        log_parts.append(" ".join(total_norms))
+    
+    # Layer-wise update norms (Frobenius)
+    layer_fnorms = []
+    layer_num = 1
+    while True:
+        layer_key = f"layer_{layer_num}_update_fnorm"
+        if layer_key in results:
+            layer_fnorms.append(f"L{layer_num}_fnorm:{results[layer_key]:.4e}")
+            layer_num += 1
+        else:
+            break
+    
+    if layer_fnorms:
+        log_parts.append(" ".join(layer_fnorms))
+    
+    # Layer-wise update norms (Max-of-Max)
+    layer_l1_linf = []
+    layer_num = 1
+    while True:
+        layer_key = f"layer_{layer_num}_max_l1_linf_norm"
+        if layer_key in results:
+            layer_l1_linf.append(f"L{layer_num}_l1linf:{results[layer_key]:.4e}")
+            layer_num += 1
+        else:
+            break
+    
+    if layer_l1_linf:
+        log_parts.append(" ".join(layer_l1_linf))
+    
+    # Layer-wise update norms (Spectral)
+    layer_spectral = []
+    layer_num = 1
+    while True:
+        layer_key = f"layer_{layer_num}_max_spectral_norm"
+        if layer_key in results:
+            layer_spectral.append(f"L{layer_num}_spectral:{results[layer_key]:.4e}")
+            layer_num += 1
+        else:
+            break
+    
+    if layer_spectral:
+        log_parts.append(" ".join(layer_spectral))
+
+    # Alignment and curvature metrics (global)
+    misc_parts = []
+    if 'v_norm' in results:
+        misc_parts.append(f"v_norm:{results['v_norm']:.4e}")
+    
+    # Version 1: g_hvp (new batch, computed at θ_t during HVP calculation)
+    if 'cos_v_neg_g_hvp' in results:
+        misc_parts.append(f"cos_v_-g_hvp:{results['cos_v_neg_g_hvp']:.4e}")
+    if 'g_hvp_norm' in results:
+        misc_parts.append(f"g_hvp_norm:{results['g_hvp_norm']:.4e}")
+    
+    # Version 2: g_t (original gradient that produced v)
+    if 'cos_v_neg_g_t' in results:
+        misc_parts.append(f"cos_v_-g_t:{results['cos_v_neg_g_t']:.4e}")
+    if 'g_t_norm' in results:
+        misc_parts.append(f"g_t_norm:{results['g_t_norm']:.4e}")
+    
+    if 'hv_norm' in results:
+        misc_parts.append(f"hv_norm:{results['hv_norm']:.4e}")
+    if 'cos_v_hv' in results:
+        misc_parts.append(f"cos_v_hv:{results['cos_v_hv']:.4e}")
+    if 'hg_norm' in results:
+        misc_parts.append(f"hg_norm:{results['hg_norm']:.4e}")
+    if 'cos_g_hg' in results:
+        misc_parts.append(f"cos_g_hg:{results['cos_g_hg']:.4e}")
+    if 'v_parallel_norm' in results:
+        misc_parts.append(f"v_par:{results['v_parallel_norm']:.4e}")
+    if 'v_perp_norm' in results:
+        misc_parts.append(f"v_perp:{results['v_perp_norm']:.4e}")
+    if misc_parts:
+        log_parts.append(" ".join(misc_parts))
+
+    # Per-layer alignment metrics (cos_v_neg_g and v_norm per layer)
+    layer_cos = []
+    layer_num = 1
+    while True:
+        layer_key = f"layer_{layer_num}_cos_v_neg_g"
+        layer_vn_key = f"layer_{layer_num}_v_norm"
+        if layer_key in results:
+            layer_cos.append(f"L{layer_num}_cos_v_neg_g:{results[layer_key]:.4e}")
+        if layer_vn_key in results:
+            layer_cos.append(f"L{layer_num}_v_norm:{results[layer_vn_key]:.4e}")
+        if layer_key not in results and layer_vn_key not in results:
+            break
+        layer_num += 1
+    if layer_cos:
+        log_parts.append(" ".join(layer_cos))
+    
+    return " ".join(log_parts)
+
+# -----------------------------------------------------------------------------
+# int main
+
+def print0(*args, **kwargs):
+    # modified print that only prints from the master process
+    # if this is not a distributed run, it's just a print
+    if int(os.environ.get("RANK", 0)) == 0:
+        print(*args, **kwargs)
+
+if __name__ == "__main__":
+    import time
+    import argparse
+    import tiktoken
+    print0(f"Running pytorch {torch.version.__version__}")
+
+    # default settings will overfit a tiny batch of data
+    # and save model weights and debug state to disk on the first iteration
+    parser = argparse.ArgumentParser()
+    # file system input / output
+    parser.add_argument("--input_bin", type=str, default="dev/data/tinyshakespeare/tiny_shakespeare_val.bin", help="input .bin to train on")
+    parser.add_argument("--input_val_bin", type=str, default="", help="input .bin to eval validation loss on")
+    parser.add_argument("--output_dir", type=str, default="", help="output directory to which to write logs and checkpoints")
+    parser.add_argument("--model", type=str, default="gpt2", help="gpt2|gpt2-medium|gpt2-large|gpt2-xl|d8|d12|d24|d36|d48")
+    # token layout for each step of the optimization
+    parser.add_argument("--batch_size", type=int, default=4, help="batch size, in units of #batch dimensions")
+    parser.add_argument("--sequence_length", type=int, default=64, help="sequence length")
+    parser.add_argument("--total_batch_size", type=int, default=256, help="total desired batch size, in units of #tokens")
+    # workload (number of steps)
+    parser.add_argument("--num_iterations", type=int, default=10, help="number of iterations to run")
+    parser.add_argument("--inference_only", type=int, default=0, help="only run inference")
+    # optimization
+    parser.add_argument("--adam_lr", type=float, default=1e-4, help="learning rate warmup iterations")
+    parser.add_argument("--warmup_iters", type=int, default=0, help="learning rate warmup iterations")
+    parser.add_argument("--lr_decay_frac", type=float, default=1.0, help="learning rate warmup iterations")
+    parser.add_argument("--weight_decay", type=float, default=0.0, help="weight decay")
+    parser.add_argument("--grad_clip", type=float, default=1.0, help="maximum gradient magnitude")
+    # evaluation
+    parser.add_argument("--val_loss_every", type=int, default=0, help="every how mant steps to evaluate val loss?")
+    parser.add_argument("--val_max_steps", type=int, default=20, help="how many batches of val to average?")
+    parser.add_argument("--sample_every", type=int, default=0, help="how often to sample from the model?")
+    # debugging
+    parser.add_argument("--overfit_single_batch", type=int, default=0, help="overfit just one batch of data")
+    parser.add_argument("--shuffle_files", action="store_true")
+    # numerics
+    parser.add_argument("--tensorcores", type=int, default=0, help="use tensorcores")
+    # memory management
+    parser.add_argument("--device", type=str, default="", help="by default we autodetect, or set it here")
+    parser.add_argument("--compile", type=int, default=0, help="torch.compile the model")
+    parser.add_argument("--flash", type=int, default=0, help="use flash attention")
+    parser.add_argument("--dtype", type=str, default="float32", help="float32|float16|bfloat16")
+    parser.add_argument("--zero_stage", type=int, default=0, help="zero redundancy optimizer stage (0/1/2/3)")
+    # Muon optimizer specific arguments
+    parser.add_argument("--optimizer", type=str, default="adam", help="optimizer to use: adam|muon")
+    parser.add_argument("--muon_lr", type=float, default=0.02, help="learning rate for Muon optimizer")
+    parser.add_argument("--muon_momentum", type=float, default=0.95, help="momentum for Muon optimizer")
+    parser.add_argument("--muon_weight_decay", type=float, default=0.00, help="weight decay for Muon optimizer")
+    parser.add_argument("--muon_ns_steps", type=int, default=5, help="number of Newton-Schulz steps for Muon")
+    parser.add_argument("--muon_nesterov", type=bool, default=False, help="use Nesterov momentum for Muon (0/1)")
+    # python -> C bridge
+    parser.add_argument("--write_tensors", type=int, default=1, help="write tensors to disk")
+    parser.add_argument("--seed", type=int, default=42, help="random seed")
+    # Sharpness analysis arguments
+    parser.add_argument("--analyze_sharpness", action="store_true", help="Enable comprehensive sharpness analysis")
+    parser.add_argument("--sharpness_analysis_interval", type=int, default=500, help="Interval for sharpness analysis")
+    args = parser.parse_args()
+
+    # args error checking and convenience variables
+    B, T = args.batch_size, args.sequence_length
+    assert 1 <= T <= 1024
+    assert args.dtype in {"float32", "float16", "bfloat16"}
+    assert args.model in {"gpt2", "gpt2-medium", "gpt2-large", "gpt2-xl", "d8", "d12", "d24", "d36", "d48"}
+    assert args.optimizer in {"adam", "muon"}
+
+    set_seed(args.seed)
+
+    # set up DDP (distributed data parallel). torchrun sets this env variable
+    ddp = int(os.environ.get('RANK', -1)) != -1 # is this a ddp run?
+    if ddp:
+        # use of DDP atm demands CUDA, we set the device appropriately according to rank
+        assert torch.cuda.is_available(), "for now i think we need CUDA for DDP"
+        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)
+        master_process = ddp_rank == 0 # this process will do logging, checkpointing etc.
+        seed_offset = 0 # each process gets the exact same seed
+        zero_stage = args.zero_stage
+    else:
+        ddp_rank = 0
+        ddp_local_rank = 0
+        zero_stage = 0
+        ddp_world_size = 1
+        master_process = True
+        seed_offset = 0
+        # select the device
+        if args.device:
+            # provided explicitly by the user
+            device = args.device
+        else:
+            # attempt to autodetect the device
+            device = "cpu"
+            if torch.cuda.is_available():
+                device = "cuda"
+            elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
+                device = "mps"
+    print(f"using device: {device}")
+    device_type = 'cuda' if 'cuda' in device else 'cpu'
+
+    # Setup debugpy for remote debugging (only activates if DEBUGPY env var is set)
+    # setup_debugpy(rank=ddp_rank, force=True)
+
+    # calculate gradient accumulation from the desired total batch size and the current run configuration
+    tokens_per_fwdbwd = B * T * ddp_world_size
+    assert args.total_batch_size % tokens_per_fwdbwd == 0
+    grad_accum_steps = args.total_batch_size // tokens_per_fwdbwd
+    print0(f"total desired batch size: {args.total_batch_size}")
+    print0(f"=> calculated gradient accumulation steps: {grad_accum_steps}")
+
+    # set up a context manager following the desired dtype and device
+    ptdtype = {'float32': torch.float32, 'bfloat16': torch.bfloat16, 'float16': torch.float16}[args.dtype]
+    ctx = torch.amp.autocast(device_type=device_type, dtype=ptdtype) if device_type == "cuda" else nullcontext()
+
+    # rng / reproducibility
+    torch.manual_seed(42)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed(42)
+
+    # set the torch precision mode to use TensorFloat32 (TF32) for matmuls
+    # docs https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html
+    if args.tensorcores:
+        torch.set_float32_matmul_precision('high')
+
+    # turn on/off flash attention
+    assert args.flash in {0, 1}
+    nano_GPT_qkvonorm_pure.FLASH = args.flash  # Set module-level FLASH for training
+
+    # init (and write) the tokenizer
+    enc = tiktoken.get_encoding("gpt2")
+    if master_process and args.write_tensors: # tokenizer is technically not tensors but ok
+        write_tokenizer(enc, "gpt2_tokenizer.bin")
+
+    # init the model, either from scratch or from OpenAI pretrained checkpoint
+    if args.model[0] == "d":
+        # from scratch (random weights)
+        model_config = {
+            "d8":  GPTConfig(block_size=1024, vocab_size=50257, n_layer=8,  n_head=8,  n_embd=512),
+            "d12": GPTConfig(block_size=1024, vocab_size=50257, n_layer=12, n_head=12, n_embd=768),
+            "d24": GPTConfig(block_size=1024, vocab_size=50257, n_layer=24, n_head=16, n_embd=1024),
+            "d36": GPTConfig(block_size=1024, vocab_size=50257, n_layer=36, n_head=20, n_embd=1280),
+            "d48": GPTConfig(block_size=1024, vocab_size=50257, n_layer=48, n_head=25, n_embd=1600),
+        }[args.model]
+        model = GPT(model_config)
+    else:
+        # load the GPT-2 model weights
+        model = GPT.from_pretrained(args.model)
+    model.train()
+    model.to(device)
+    
+    # Save uncompiled model reference for sharpness analysis (needs double backward)
+    raw_model_uncompiled = model
+    
+    if args.compile:
+        if hasattr(config, "coordinate_descent_tuning"):
+            config.coordinate_descent_tuning = True # suggested by @Chillee
+        print0("compiling the model...")
+        model = torch.compile(model)
+
+    # -------------------------------------------------------------------------
+    # Our own version of a simple DistributedDataLoader
+
+    # load tokens
+    train_loader = DistributedDataLoader(
+        args.input_bin, B, T, ddp_rank, ddp_world_size,
+        shuffle_files=args.shuffle_files, random_seed=args.seed
+    )
+    val_loader = None
+    if args.input_val_bin:
+        val_loader = DistributedDataLoader(args.input_val_bin, B, T, ddp_rank, ddp_world_size)
+
+    # -------------------------------------------------------------------------
+    # PyTorch -> C bridge: save some weights and state for C to load later as reference
+
+    # do one forward pass to generate ground truth for our C tests
+    if master_process and args.write_tensors and (not args.inference_only):
+        x, y = train_loader.next_batch()
+        x, y = x.to(device), y.to(device)
+        logits, loss = model(x, y, return_logits=True)  # Need logits for write_state
+        loss.backward()
+        # save model params, in both float32 and bfloat16
+        model_to_size = {"gpt2": "124M", "gpt2-medium": "355M", "gpt2-large": "774M", "gpt2-xl": "1558M"}
+        model_to_size.update({f"d{d}": f"d{d}" for d in [12, 24, 36, 48]})
+        model_size_str = model_to_size[args.model] # e.g. "124M", or "d12"
+        write_model(model, f"gpt2_{model_size_str}.bin", dtype="float32")
+        write_model(model, f"gpt2_{model_size_str}_bf16.bin", dtype="bfloat16")
+        # save x, y, logits, loss, and parameter gradients, for debugging C
+        # always store these in fp32 to have an accurate reference (?)
+        write_state(model, x, y, logits, loss, f"gpt2_{model_size_str}_debug_state.bin")
+        # reset the train_loader for the optimization below
+        train_loader.reset()
+
+    # -------------------------------------------------------------------------
+    # main training loop
+
+    # here we wrap model into DDP container
+    if ddp:
+        model = DDP(model, device_ids=[ddp_local_rank])
+    raw_model = model.module if ddp else model # always contains the "raw" unwrapped model
+    
+    base_module = model.module if ddp else model
+    # If compiled, unwrap to get the original module
+    if hasattr(base_module, "_orig_mod"):
+        base_module = base_module._orig_mod
+    
+    raw_params = list(raw_model_uncompiled.parameters())
+    train_params = list(base_module.parameters())
+    
+    assert len(raw_params) == len(train_params), \
+        f"Parameter count mismatch: raw_model_uncompiled has {len(raw_params)}, training model has {len(train_params)}"
+    for i, (rp, tp) in enumerate(zip(raw_params, train_params)):
+        assert rp.data_ptr() == tp.data_ptr(), \
+            f"Parameter {i} has different data_ptr: raw_model_uncompiled and training model do not share parameters!"
+    print0(f"[Verified] raw_model_uncompiled and training model share the same {len(raw_params)} Parameter objects")
+    
+    last_training_update = None
+    last_training_gradient = None  # Store the original gradient that produced the update
+    last_training_batches = None  # Store ALL microbatches (x, y) for consistent HVP calculation
+
+
+    def configure_adam(model, weight_decay, learning_rate, betas, device_type, zero_stage):
+        # start with all of the candidate parameters
+        param_dict = {pn: p for pn, p in model.named_parameters()}
+        # filter out those that do not require grad
+        param_dict = {pn: p for pn, p in param_dict.items() if p.requires_grad}
+        # create optim groups. Any parameters that is 2D will be weight decayed, otherwise no.
+        # i.e. all weight tensors in matmuls + embeddings decay, all biases and layernorms don't.
+        decay_params = [p for n, p in param_dict.items() if p.dim() >= 2]
+        nodecay_params = [p for n, p in param_dict.items() if p.dim() < 2]
+        optim_groups = [
+            {'params': decay_params, 'weight_decay': weight_decay},
+            {'params': nodecay_params, 'weight_decay': 0.0}
+        ]
+        num_decay_params = sum(p.numel() for p in decay_params)
+        num_nodecay_params = sum(p.numel() for p in nodecay_params)
+        print0(f"num decayed parameter tensors: {len(decay_params)}, with {num_decay_params:,} parameters")
+        print0(f"num non-decayed parameter tensors: {len(nodecay_params)}, with {num_nodecay_params:,} parameters")
+        # Create AdamW optimizer and use the fused version if it is available
+        fused_available = 'fused' in inspect.signature(torch.optim.AdamW).parameters
+        use_fused = fused_available and device_type == 'cuda'
+        print0(f"using fused AdamW: {use_fused}")
+        if zero_stage == 1:
+            print0("using ZeroRedundancyOptimizer")
+            optimizer = ZeroRedundancyOptimizer(**optim_groups[0], optimizer_class=torch.optim.AdamW,
+                                                lr=learning_rate, betas=betas, fused=use_fused)
+            optimizer.add_param_group(optim_groups[1])
+        else:
+            print0("using regular AdamW")
+            optimizer = torch.optim.AdamW(optim_groups, lr=learning_rate, betas=betas, fused=use_fused)
+        return [optimizer]
+
+    def configure_muon(model, weight_decay, adam_lr, muon_lr, momentum, nesterov, ns_steps, device_type, zero_stage, ddp_rank, ddp_world_size):
+        # start with all of the candidate parameters
+        param_dict = {pn: p for pn, p in model.named_parameters()}
+        # filter out those that do not require grad
+        param_dict = {pn: p for pn, p in param_dict.items() if p.requires_grad}
+        
+        # For Muon, we need to separate 2D parameters (which can be orthogonalized) 
+        # from other parameters (which should use standard optimization)
+        muon_params = []  # 2D parameters for Muon
+        other_params = []  # other parameters for AdamW
+
+        muon_name = []
+        other_name = []
+        for n, p in param_dict.items():
+            if "wte.weight" in n :
+                other_params.append(p)
+                other_name.append(n)
+                continue
+
+            if p.dim() >= 2:  # 2D parameters (weight matrices)
+                muon_params.append(p)
+                muon_name.append(n)
+            else:  # 1D parameters (biases, embeddings, etc.)
+                other_params.append(p)
+                other_name.append(n)
+
+        # print("================================================\n")
+        # print(f"Muon parameters: {muon_name}\n")
+        # print(f"Other parameters: {other_name}\n")
+        # print("================================================\n")
+        
+        print0(f"Muon parameters (2D): {len(muon_params)} tensors")
+        print0(f"Other parameters (non-2D): {len(other_params)} tensors")
+        
+        # Create Muon optimizer for 2D parameters
+        muon_optimizer = None
+        if muon_params:
+            muon_optimizer = Muon(
+                params=muon_params,
+                lr=muon_lr,
+                weight_decay=weight_decay,
+                momentum=momentum,
+                nesterov=nesterov,
+                ns_steps=ns_steps,
+                rank=ddp_rank,
+                world_size=ddp_world_size
+            )
+        
+        # Create AdamW optimizer for non-2D parameters
+        adam_optimizer = None
+        if other_params:
+            # create optim groups for AdamW
+            # decay_params = [p for p in other_params if p.dim() >= 2]
+            # nodecay_params = [p for p in other_params if p.dim() < 2]
+            optim_groups = [
+                {'params': other_params, 'weight_decay': weight_decay},
+                # {'params': nodecay_params, 'weight_decay': 0.0}
+            ]
+            
+            # Create AdamW optimizer
+            fused_available = 'fused' in inspect.signature(torch.optim.AdamW).parameters
+            use_fused = fused_available and device_type == 'cuda'
+            print0(f"using fused AdamW for non-Muon params: {use_fused}")
+            
+            if zero_stage == 1:
+                print0("using ZeroRedundancyOptimizer for non-Muon params")
+                adam_optimizer = ZeroRedundancyOptimizer(**optim_groups[0], optimizer_class=torch.optim.AdamW,
+                                                        lr=adam_lr, betas=(0.9, 0.95), fused=use_fused)
+                # adam_optimizer.add_param_group(optim_groups[1])
+            else:
+                print0("using regular AdamW for non-Muon params")
+                adam_optimizer = torch.optim.AdamW(optim_groups, lr=adam_lr, betas=(0.9, 0.95), fused=use_fused)
+        
+        return [muon_optimizer, adam_optimizer]
+
+    # init the optimizer
+    if args.optimizer == "adam":
+        optimizers = configure_adam(model=raw_model_uncompiled, weight_decay=args.weight_decay,
+                                                   learning_rate=args.adam_lr, betas=(0.9, 0.95),
+                                                   device_type=device, zero_stage=zero_stage)
+    elif args.optimizer == "muon":
+        optimizers = configure_muon(
+            model=raw_model_uncompiled, 
+            weight_decay=args.muon_weight_decay,
+            muon_lr=args.muon_lr,
+            adam_lr=args.adam_lr,
+            momentum=args.muon_momentum,
+            nesterov=bool(args.muon_nesterov),
+            ns_steps=args.muon_ns_steps,
+            device_type=device,
+            zero_stage=zero_stage,
+            ddp_rank=ddp_rank,
+            ddp_world_size=ddp_world_size
+        )
+        # We'll use muon_optimizer and adam_optimizer separately
+
+    # learning rate decay scheduler (cosine with warmup)
+    def get_lr(it,base_lr):
+        # if args.optimizer == "adam":
+        #     base_lr = args.adam_lr
+        # else:  # muon
+        #     base_lr = args.muon_lr
+        min_lr = base_lr * args.lr_decay_frac
+        # 1) linear warmup for warmup_iters steps
+        if it < args.warmup_iters:
+            return base_lr * (it+1) / args.warmup_iters
+        # 2) if it > lr_decay_iters, return min learning rate
+        if it > args.num_iterations:
+            return min_lr
+        # 3) in between, use cosine decay down to min learning rate
+        decay_ratio = (it - args.warmup_iters) / (args.num_iterations - args.warmup_iters)
+        assert 0 <= decay_ratio <= 1
+        coeff = 0.5 * (1.0 + math.cos(math.pi * decay_ratio)) # coeff starts at 1 and goes to 0
+        return min_lr + coeff * (base_lr - min_lr)
+
+    def get_wsd_lr(it, base_lr):
+        min_lr = base_lr * args.lr_decay_frac
+        # cooldown_iters = int(args.num_iterations * 0.2)
+        cooldown_iters = int(0)
+        # 1) Warmup: linear warmup for warmup_iters steps
+        if it < args.warmup_iters:
+            return base_lr * (it + 1) / args.warmup_iters
+        # 3) Decay: linear decay from base_lr to min_lr in the last cooldown_iters steps
+        cooldown_start = args.num_iterations - cooldown_iters
+        if it >= cooldown_start:
+            decay_ratio = (it - cooldown_start) / cooldown_iters
+            return base_lr - decay_ratio * (base_lr - min_lr)
+        # 2) Stable: constant learning rate at base_lr
+        return base_lr
+
+    # create the logging directory if it does not exist
+    logfile = None
+    run_dir_path = None
+    
+    file_name  = f"mode_{args.optimizer}_adam_lr_{args.adam_lr}_muon_lr_{args.muon_lr}_seed_{args.seed}.log"
+    if args.output_dir:
+        base_log_dir = Path(args.output_dir)
+        base_log_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Create run-specific directory
+        # Generate UUID on master process and broadcast to all ranks
+        if master_process:
+            run_uuid = uuid.uuid4()
+            uuid_str = str(run_uuid)
+        else:
+            uuid_str = None
+        
+        # Broadcast UUID from rank 0 to all other ranks
+        if ddp:
+            # Create a tensor to hold the UUID string length and content
+            if master_process:
+                uuid_bytes = uuid_str.encode('utf-8')
+                uuid_len = len(uuid_bytes)
+            else:
+                uuid_len = 0
+            
+            # Broadcast length
+            uuid_len_tensor = torch.tensor(uuid_len, dtype=torch.long, device=device)
+            dist.broadcast(uuid_len_tensor, src=0)
+            
+            # Broadcast UUID string
+            if master_process:
+                uuid_tensor = torch.ByteTensor(list(uuid_bytes)).to(device)
+            else:
+                uuid_tensor = torch.ByteTensor([0] * uuid_len_tensor.item()).to(device)
+            dist.broadcast(uuid_tensor, src=0)
+            
+            # Decode on non-master processes
+            if not master_process:
+                uuid_str = bytes(uuid_tensor.cpu().numpy()).decode('utf-8')
+                run_uuid = uuid.UUID(uuid_str)
+            else:
+                run_uuid = uuid.UUID(uuid_str)
+        else:
+            run_uuid = uuid.uuid4()
+        
+        # run_folder_name = f"opt_{args.optimizer}_alr_{args.adam_lr}_mlr_{args.muon_lr}_seed_{args.seed}_{run_uuid}"
+        run_folder_name = f"opt_{args.optimizer}_alr_{args.adam_lr}_mlr_{args.muon_lr}_seed_{args.seed}"
+        run_dir_path = base_log_dir / run_folder_name
+        if run_dir_path.exists():
+            run_flag = False
+        else:
+            run_flag = True
+        torch.cuda.synchronize()
+        
+        
+        # Only master process creates the directory
+        if master_process:
+            run_dir_path.mkdir(parents=True, exist_ok=True)
+        
+        logfile = str(run_dir_path / "training_log.txt")
+        
+        # Save configuration
+    
+    if run_flag:
+        if master_process:
+            config_to_save = {
+                "cli_args": vars(args),
+                "run_uuid": 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)
+            print0(f"Saved configuration to: {config_file_path}")
+            
+        if master_process and logfile:
+            with open(logfile, "w") as f:
+                pass  # Create/clear the file
+            with open(logfile, "a") as f:
+                f.write(code)
+
+        if device == "cuda":
+            torch.cuda.reset_peak_memory_stats()
+        timings = []
+        norm = -1.0   # dummy value to print in inference-only mode
+        for step in range(args.num_iterations + 1):
+            t0 = time.time()
+            last_step = (step == args.num_iterations)
+
+            # once in a while evaluate the validation dataset
+            if (args.val_loss_every > 0 \
+                and (step % args.val_loss_every == 0 or last_step)) \
+                and (val_loader is not None):
+                model.eval()
+                val_loader.reset()
+                with torch.no_grad():
+                    val_loss = 0.0
+                    for _ in range(args.val_max_steps):
+                        x, y = val_loader.next_batch()
+                        x, y = x.to(device), y.to(device)
+                        _, loss = model(x, y, return_logits=False)
+                        val_loss += loss.item()
+                    val_loss /= args.val_max_steps
+                
+                # --- Comprehensive Sharpness Analysis ---
+                sharpness_log_str = ""
+                # Skip step 0 since we don't have a previous training update yet
+                if args.analyze_sharpness and step > 0 and (step % args.sharpness_analysis_interval == 0 or last_step):
+                    print0(f"[Sharpness @ Step {step}] Starting comprehensive sharpness analysis...")
+                    for optimizer in optimizers:
+                        if isinstance(optimizer, ZeroRedundancyOptimizer) or isinstance(optimizer, torch.optim.AdamW):
+                            optimizer.zero_grad(set_to_none=True)
+                        elif isinstance(optimizer, Muon):
+                            optimizer.zero_grad()
+                    comprehensive_results = calculate_comprehensive_sharpness(
+                        model=raw_model_uncompiled,  # Use uncompiled model for HVP (double backward)
+                        model_for_forward=model,     # Use compiled+DDP model for forward pass
+                        optimizers=optimizers,
+                        step=step,
+                        train_loader=train_loader,
+                        val_loader=val_loader,
+                        rank=ddp_rank,
+                        world_size=ddp_world_size,
+                        device=device,
+                        B=B,
+                        T=T,
+                        ptdtype=ptdtype,
+                        grad_accum_steps=grad_accum_steps,  # Pass grad accumulation steps to scale loss correctly
+                        last_training_update=last_training_update,  # Pass the real update captured from training
+                        last_training_gradient=last_training_gradient,  # Pass the original gradient g_t
+                        last_training_batches=last_training_batches  # Pass ALL microbatches for consistent HVP
+                    )
+                    sharpness_log_str = format_comprehensive_results(comprehensive_results)
+                    
+                    # Save sharpness results to file
+                    if master_process and run_dir_path:
+                        sharpness_file = run_dir_path / f"sharpness_step_{step}.json"
+                        with open(sharpness_file, "w") as f:
+                            json.dump(comprehensive_results, f, indent=4)
+                        print0(f"[Sharpness @ Step {step}] Results saved to {sharpness_file}")
+                    
+                    # Clean up memory after sharpness analysis
+                    del comprehensive_results
+                    # Ensure all CUDA operations are complete before cleaning up
+                    if device == "cuda":
+                        torch.cuda.synchronize()
+                    torch.cuda.empty_cache()
+                    gc.collect()
+                    if ddp:
+                        dist.barrier()  # Sync all ranks after cleanup
+                    print0(f"[Step {step}] Memory cleaned up after sharpness analysis")
+                
+                # log to console and to file
+                if sharpness_log_str:
+                    print0(f"step {step}/{args.num_iterations} | val loss {val_loss:.6f} | {sharpness_log_str}")
+                else:
+                    print0(f"step {step}/{args.num_iterations} | val loss {val_loss:.6f}")
+                
+                if master_process and logfile is not None:
+                    with open(logfile, "a") as f:
+                        f.write("step:%d validation loss:%f" % (step, val_loss))
+                        if sharpness_log_str:
+                            f.write(" %s" % sharpness_log_str)
+                        f.write("\n")
+
+            # once in a while perform model inference on the master process
+            if (args.sample_every > 0 \
+                and (step % args.sample_every == 0 or last_step)) \
+                and master_process:
+                model.eval()
+                # before we end, let's also do one round of inference
+                # we'll kick off the generation with "<|endoftext|>", which designates the start of a new sequence
+                start_ids = [enc.eot_token]
+                xg = (torch.tensor(start_ids, dtype=torch.long, device=device)[None, ...])
+                max_new_tokens = 32
+                temperature = 1.0
+                top_k = 40
+                yg = raw_model.generate(xg, max_new_tokens, temperature=temperature, top_k=top_k)
+                print0('---------------')
+                print0(enc.decode(yg[0].tolist()))
+                print0('---------------')
+
+            # bit confusing: we want to make sure to eval and sample 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()
+            # Zero gradients for the appropriate optimizer(s)
+
+            for optimizer in optimizers:
+                if isinstance(optimizer, ZeroRedundancyOptimizer) or isinstance(optimizer, torch.optim.AdamW):
+                    optimizer.zero_grad(set_to_none=True)
+                elif isinstance(optimizer, Muon):
+                    optimizer.zero_grad()
+            # if args.optimizer == "adam":
+            #     optimizer.zero_grad(set_to_none=True)
+            # else:  # muon
+            #     if muon_optimizer is not None:
+            #         muon_optimizer.zero_grad()
+            #     if adam_optimizer is not None:
+            #         adam_optimizer.zero_grad(set_to_none=True)
+            # if we are trying to overfit a single batch, we reset the loader here
+            if args.overfit_single_batch:
+                train_loader.reset()
+            # micro-batch loop where we do gradient accumulation to reach desired total batch size
+            lossf = 0.0 # for getting the mean loss (as simple float) over the accumulation steps
+            
+            # Pre-check if we need to collect microbatches for sharpness analysis
+            next_step = step + 1
+            will_analyze_sharpness_next = args.analyze_sharpness and next_step > 0 and (
+                (next_step % args.sharpness_analysis_interval == 0) or 
+                (next_step == args.num_iterations)
+            )
+            
+
+            microbatches_this_step = [] if will_analyze_sharpness_next else None
+            
+            for micro_step in range(grad_accum_steps):
+                # fetch a batch
+                x, y = train_loader.next_batch()
+                x, y = x.to(device), y.to(device)
+                
+                # Store ALL microbatches for memory-efficient HVP calculation
+                if will_analyze_sharpness_next:
+                    microbatches_this_step.append((x.detach().clone(), y.detach().clone()))
+                
+                if ddp:
+                    model.require_backward_grad_sync = (micro_step == grad_accum_steps - 1)
+                # forward pass
+                with ctx:
+                    _, loss = model(x, y, return_logits=False)
+                    loss = loss / grad_accum_steps
+                    lossf += loss.detach() # keep track of the mean loss
+                # backward pass
+                if not args.inference_only:
+                    loss.backward()
+            if ddp:
+                dist.all_reduce(lossf, op=dist.ReduceOp.AVG)
+            lossf = lossf.item()
+            
+            #no clipping
+            norm = torch.nn.utils.clip_grad_norm_(raw_model_uncompiled.parameters(), args.grad_clip)
+            
+            
+            if will_analyze_sharpness_next:
+                # Use raw_model_uncompiled's parameter order so it matches sharpness analysis codepaths.
+                # (DDP/torch.compile wrappers can be a footgun if parameter iteration order ever diverges.)
+                print(raw_model_uncompiled.transformer.h[0].attn.q_w.weight[:5,:5])
+                params_before_optimizer_step = [p.detach().clone() for p in raw_model_uncompiled.parameters()]
+                # Save the original gradient g_t that will produce the update v
+                last_training_gradient = [
+                    p.grad.detach().clone() if p.grad is not None else torch.zeros_like(p)
+                    for p in raw_model_uncompiled.parameters()
+                ]
+                # Capture ALL microbatches for consistent HVP calculation
+                # This ensures H is computed on the exact same objective as g_t and v
+                last_training_batches = microbatches_this_step  # Already cloned above
+            else:
+                params_before_optimizer_step = None
+                last_training_batches = None
+            
+            # Update learning rate and step optimizers
+            for optimizer in optimizers:
+                if isinstance(optimizer, ZeroRedundancyOptimizer) or isinstance(optimizer, torch.optim.AdamW):
+                    adam_lr = get_wsd_lr(step,args.adam_lr)
+                    for param_group in optimizer.param_groups:
+                        param_group['lr'] = adam_lr
+                    optimizer.step()
+                elif isinstance(optimizer, Muon):
+                    muon_lr = get_wsd_lr(step,args.muon_lr)
+                    for param_group in optimizer.param_groups:
+                        param_group['lr'] = muon_lr
+                    optimizer.step()
+                else:
+                    raise ValueError(f"Unsupported optimizer: {type(optimizer)}")
+            
+            
+            if params_before_optimizer_step is not None:
+                # Clean up old update to save memory
+                if last_training_update is not None:
+                    del last_training_update
+                
+                last_training_update = [
+                    p.detach() - p_before
+                    for p_before, p in zip(params_before_optimizer_step, raw_model_uncompiled.parameters())
+                ]
+                del params_before_optimizer_step
+            
+            # --------------- TRAINING SECTION END -------------------
+
+            # wait on the CPU for all device work to end so we get accurate per-iteration timings below
+            if device == "mps":
+                torch.mps.synchronize()
+            elif device == "cuda":
+                torch.cuda.synchronize()
+            # time and print
+            t1 = time.time()
+            # the 0th iteration is often an outlier (much slower) => skip logging it
+            tokens_per_second = grad_accum_steps * ddp_world_size * B * T / (t1-t0)
+            print0(f"step {step+1:4d}/{args.num_iterations} | train loss {lossf:.6f} | norm {norm:.4f} | ({(t1-t0)*1000:.2f} ms | {tokens_per_second:.0f} tok/s)")
+            # log to logile
+            if master_process and logfile is not None:
+                with open(logfile, "a") as f:
+                    f.write("step:%d train loss:%f\n" % (step, lossf))
+
+            # keep track of smooth timings, last 20 iterations
+            if step > 0 and step > args.num_iterations - 20:
+                timings.append(t1-t0)
+
+        # print the average of the last 20 timings, to get something smooth-ish
+        timings = timings[-20:]
+        print0(f"final {len(timings)} iters avg: {np.mean(timings)*1000:.3f}ms")
+        print0(f"peak memory consumption: {torch.cuda.max_memory_allocated() // 1024 // 1024} MiB")
+
+        # -------------------------------------------------------------------------
+        # clean up nice
+    if ddp:
+        destroy_process_group()step:0 validation loss:11.020913

logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm/opt_adam_alr_0.01_mlr_0.01_seed_43/config.json

@@ -0,0 +1,41 @@
+{
+    "cli_args": {
+        "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",
+        "output_dir": "/home/aiops/zhangfz/MUON_sharpness/logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm",
+        "model": "d12",
+        "batch_size": 4,
+        "sequence_length": 1024,
+        "total_batch_size": 524288,
+        "num_iterations": 10000,
+        "inference_only": 0,
+        "adam_lr": 0.01,
+        "warmup_iters": 1500,
+        "lr_decay_frac": 0.0,
+        "weight_decay": 0.0,
+        "grad_clip": 100000.0,
+        "val_loss_every": 250,
+        "val_max_steps": 20,
+        "sample_every": 0,
+        "overfit_single_batch": 0,
+        "shuffle_files": true,
+        "tensorcores": 1,
+        "device": "",
+        "compile": 1,
+        "flash": 1,
+        "dtype": "bfloat16",
+        "zero_stage": 1,
+        "optimizer": "adam",
+        "muon_lr": 0.01,
+        "muon_momentum": 0.95,
+        "muon_weight_decay": 0.0,
+        "muon_ns_steps": 5,
+        "muon_nesterov": false,
+        "write_tensors": 0,
+        "seed": 43,
+        "analyze_sharpness": false,
+        "sharpness_analysis_interval": 500
+    },
+    "run_uuid": "47f63560-10bc-4d75-b4e5-15f00f3f71f4",
+    "script_code_logged_at_start": true
+}

logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm/opt_adam_alr_0.01_mlr_0.01_seed_44/config.json

@@ -0,0 +1,41 @@
+{
+    "cli_args": {
+        "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",
+        "output_dir": "/home/aiops/zhangfz/MUON_sharpness/logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm",
+        "model": "d12",
+        "batch_size": 4,
+        "sequence_length": 1024,
+        "total_batch_size": 524288,
+        "num_iterations": 10000,
+        "inference_only": 0,
+        "adam_lr": 0.01,
+        "warmup_iters": 1500,
+        "lr_decay_frac": 0.0,
+        "weight_decay": 0.0,
+        "grad_clip": 100000.0,
+        "val_loss_every": 250,
+        "val_max_steps": 20,
+        "sample_every": 0,
+        "overfit_single_batch": 0,
+        "shuffle_files": true,
+        "tensorcores": 1,
+        "device": "",
+        "compile": 1,
+        "flash": 1,
+        "dtype": "bfloat16",
+        "zero_stage": 1,
+        "optimizer": "adam",
+        "muon_lr": 0.01,
+        "muon_momentum": 0.95,
+        "muon_weight_decay": 0.0,
+        "muon_ns_steps": 5,
+        "muon_nesterov": false,
+        "write_tensors": 0,
+        "seed": 44,
+        "analyze_sharpness": false,
+        "sharpness_analysis_interval": 500
+    },
+    "run_uuid": "95e21787-edbd-4ea3-bf86-ba9b7bcad9f1",
+    "script_code_logged_at_start": true
+}

logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm/opt_adam_alr_0.01_mlr_0.01_seed_44/training_log.txt

@@ -0,0 +1,1819 @@
+"""
+Reference code for GPT-2 training and inference with Sharpness Analysis.
+Will save the model weights into files, to be read from C as initialization.
+
+References:
+1) the official GPT-2 TensorFlow implementation released by OpenAI:
+https://github.com/openai/gpt-2/blob/master/src/model.py
+2) huggingface/transformers PyTorch implementation:
+https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt2/modeling_gpt2.py
+
+Example launches to only benchmark the speed of bfloat16 compiled GPU training:
+1 GPU:
+python train_gpt2.py --write_tensors=0 --num_iterations=50 --sequence_length=1024 --compile=1 --tensorcores=1 --dtype=bfloat16
+you can also turn on flash-attention by appending --flash=1
+4 GPU:
+torchrun --standalone --nproc_per_node=4 train_gpt2.py --write_tensors=0 --num_iterations=50 --sequence_length=1024 --compile=1 --tensorcores=1 --dtype=bfloat16
+"""
+import sys
+with open(sys.argv[0]) as f:
+    code = f.read() # read the code of this file ASAP, for logging
+
+import os
+import math
+import glob
+import struct
+import inspect
+from contextlib import nullcontext
+from dataclasses import dataclass
+import random
+
+import numpy as np
+import torch
+from torch import Tensor
+import torch.nn as nn
+from torch.nn import functional as F
+import torch._inductor.config as config
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.distributed import init_process_group, destroy_process_group
+from torch.distributed.optim import ZeroRedundancyOptimizer
+import torch.distributed as dist
+from torch.amp import autocast
+import copy
+import gc
+import uuid
+import json
+from pathlib import Path
+
+# Import Muon optimizer
+import sys
+sys.path.append("/home/aiops/zhangfz/MUON_sharpness/modded-nanogpt/optimizers")
+from MUON_fix import Muon
+
+# Import GPT model
+sys.path.append("/home/aiops/zhangfz/MUON_sharpness/modded-nanogpt/models")
+import  nano_GPT_qkvonorm_pure
+from nano_GPT_qkvonorm_pure import GPT, GPTConfig
+
+# Import debug utilities
+# from debug_utils import setup_debugpy
+
+# -----------------------------------------------------------------------------
+# 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,
+                 shuffle_files=False, random_seed=None):
+        self.process_rank = process_rank
+        self.num_processes = num_processes
+        self.B = B
+        self.T = T
+        self.shuffle_files = shuffle_files
+        self.random_seed = random_seed
+        self._rng = random.Random(random_seed) if shuffle_files and random_seed is not None else None
+
+        # 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}"
+        if self.shuffle_files:
+            self._shuffle_files()
+
+        # 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 += shard_ntok
+        self.ntok_total = ntok_total
+        print0(f"DataLoader: total number of tokens: {ntok_total:,} across {len(self.files)} files")
+
+        # kick things off
+        self.current_shard = None
+        self.reset()
+
+    def reset(self):
+        # we're being a bit clever here: if we already had shard 0 loaded,
+        # then don't do the work to reload it, just reset the pointer
+        if self.current_shard != 0:
+            self.current_shard = 0
+            self.tokens = _load_data_shard(self.files[self.current_shard])
+        self.current_position = self.process_rank * self.B * self.T
+
+    def advance(self): # advance to next data shard
+        next_shard = (self.current_shard + 1) % len(self.files)
+        if next_shard == 0 and self.shuffle_files:
+            self._shuffle_files()
+        self.current_shard = next_shard
+        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 the start pointer in current shard
+        self.current_position += B * T * self.num_processes
+        # if loading the next batch would be out of bounds advance the shard
+        if self.current_position + (B * T * self.num_processes + 1) > len(self.tokens):
+            self.advance()
+        return x, y
+
+    def _shuffle_files(self):
+        if self._rng is not None:
+            self._rng.shuffle(self.files)
+        else:
+            random.shuffle(self.files)
+
+# -----------------------------------------------------------------------------
+# Python -> C bridge utilities for saving params/grads/activations to .bin files
+
+def write_fp32(tensor, file):
+    t = tensor.detach().cpu().to(torch.float32)
+    b = t.numpy().tobytes()
+    file.write(b)
+
+def write_bf16(tensor, file):
+    t = tensor.detach().cpu().to(torch.bfloat16)
+    # numpy doesn't have bf16 datatype so we have to trick it
+    t = t.view(torch.int16) # trick: reinterpret as int16
+    b = t.numpy().tobytes()
+    file.write(b)
+
+def write_tensors(model_tensors, L, file, dtype):
+    # writes the GPT-2 model's weights to a binary file
+    assert dtype in {"float32", "bfloat16"}
+    write_fun = write_fp32 if dtype == "float32" else write_bf16
+    write_fun(model_tensors["transformer.wte.weight"], file) # (V, C)
+    write_fun(model_tensors["transformer.wpe.weight"], file) # (T, C)
+    for i in range(L): # (L, C)
+        write_fun(model_tensors[f"transformer.h.{i}.ln_1.weight"], file)
+    for i in range(L): # (L, C)
+        write_fun(model_tensors[f"transformer.h.{i}.ln_1.bias"], file)
+    for i in range(L): # (L, 3C, C)
+        write_fun(model_tensors[f"transformer.h.{i}.attn.c_attn.weight"], file)
+    for i in range(L): # (L, 3C)
+        write_fun(model_tensors[f"transformer.h.{i}.attn.c_attn.bias"], file)
+    for i in range(L): # (L, C, C)
+        write_fun(model_tensors[f"transformer.h.{i}.attn.c_proj.weight"], file)
+    for i in range(L): # (L, C)
+        write_fun(model_tensors[f"transformer.h.{i}.attn.c_proj.bias"], file)
+    for i in range(L): # (L, C)
+        write_fun(model_tensors[f"transformer.h.{i}.ln_2.weight"], file)
+    for i in range(L): # (L, C)
+        write_fun(model_tensors[f"transformer.h.{i}.ln_2.bias"], file)
+    for i in range(L): # (L, 4C, C)
+        write_fun(model_tensors[f"transformer.h.{i}.mlp.c_fc.weight"], file)
+    for i in range(L): # (L, 4C)
+        write_fun(model_tensors[f"transformer.h.{i}.mlp.c_fc.bias"], file)
+    for i in range(L): # (L, C, 4C)
+        write_fun(model_tensors[f"transformer.h.{i}.mlp.c_proj.weight"], file)
+    for i in range(L): # (L, C)
+        write_fun(model_tensors[f"transformer.h.{i}.mlp.c_proj.bias"], file)
+    write_fun(model_tensors["transformer.ln_f.weight"], file) # (C, )
+    write_fun(model_tensors["transformer.ln_f.bias"], file) # (C, )
+
+@torch.no_grad()
+def pad_vocab(tensor, multiple=128, value=0):
+    """
+    The dimension of the vocab size in GPT-2 is 50,257
+    which is unfortunately a very unfriendly number for a lot of
+    matrix operations on the GPU. So we pad it to the nearest
+    friendlier multiple, e.g. 50,304 if multiple=128 when we
+    export the weights into C land. This is a NOOP algorithmically
+    and is only done to make the tensor operations more efficient.
+    """
+    assert tensor.ndim == 2
+    V, C = tensor.shape
+    assert V == 50257, "just being defensive here"
+    # calculate padded vocab size by rounding up to nearest multiple
+    Vp = ((V + multiple - 1) // multiple) * multiple
+    # pad the tensor
+    pad_rows = Vp - V
+    padded = tensor if pad_rows == 0 else F.pad(tensor, (0, 0, 0, pad_rows), value=value)
+    assert padded.shape == (Vp, C)
+    return padded
+
+def write_model(model, filename, dtype):
+    # everything we need to instantiate the model
+    # 1) header is: version int, GPTConfig ints, padding to 1024 bytes
+    assert dtype in {"float32", "bfloat16"} # float16 todo maybe later
+    version = {
+        "float32": 3, # 3: all tensors are fp32, padded vocab
+        "bfloat16": 5, # 5: all tensors are bf16, padded vocab
+    }[dtype]
+    header = torch.zeros(256, dtype=torch.int32)
+    header[0] = 20240326 # magic
+    header[1] = version # checkpoint version
+    header[2] = model.config.block_size
+    header[3] = model.config.vocab_size
+    header[4] = model.config.n_layer
+    header[5] = model.config.n_head
+    header[6] = model.config.n_embd
+    # 2) the parameters follow the header
+    params = {name: param.cpu() for name, param in model.named_parameters()}
+    # pad the vocab to a multiple of 128 here at export, for efficiency in C
+    wte = params["transformer.wte.weight"] # (V, C)
+    wte_padded = pad_vocab(wte) # (Vp, C)
+    params["transformer.wte.weight"] = wte_padded # (Vp, C)
+    print(f"padded vocab size from {wte.size(0)} to {wte_padded.size(0)}")
+    header[7] = wte_padded.size(0) # padded vocab size store in header
+    # now write to file
+    with open(filename, "wb") as file:
+        file.write(header.numpy().tobytes()) # header
+        write_tensors(params, model.config.n_layer, file, dtype) # params
+    print(f"wrote {filename}")
+
+def write_state(model, x, y, logits, loss, filename):
+    # the state is used for debugging.
+    # it contains information about the input, logits, loss, and the parameter gradients
+    # this can be used for checking the computation correctness in C
+    header = torch.zeros(256, dtype=torch.int32)
+    header[0] = 20240327 # magic
+    header[1] = 2 # run state version = 2 (1 -> 2 for padded vocab changes)
+    header[2] = x.size(0) # batch size of the batch, B
+    header[3] = x.size(1) # temporal extent of the batch, T
+    grads = {name: param.grad.cpu() for name, param in model.named_parameters()}
+    # pad the vocab grads here as well, to mirror write_model
+    wte_grad = grads["transformer.wte.weight"] # (V, C)
+    wte_grad_padded = pad_vocab(wte_grad, value=0) # (Vp, C) # TODO later maybe pad with nan?
+    grads["transformer.wte.weight"] = wte_grad_padded # (Vp, C)
+    print(f"padded vocab size in reference grads from {wte_grad.size(0)} to {wte_grad_padded.size(0)}")
+    with open(filename, "wb") as file:
+        # header
+        file.write(header.numpy().tobytes())
+        # input x
+        file.write(x.cpu().numpy().astype("int32").tobytes()) # (B, T)
+        # targets y
+        file.write(y.cpu().numpy().astype("int32").tobytes()) # (B, T)
+        # logits (result of the model forward pass)
+        write_fp32(logits.cpu(), file)
+        # loss (single float, result of the cross entropy loss)
+        write_fp32(loss.cpu(), file)
+        # gradients
+        write_tensors(grads, model.config.n_layer, file, "float32")
+    print(f"wrote {filename}")
+
+def write_tokenizer(enc, filename):
+    n = enc.max_token_value + 1
+    header = torch.zeros(256, dtype=torch.int32)
+    header[0] = 20240328 # magic
+    header[1] = 2 # tokenizer version = 2 (1 -> 2: includes EOT token)
+    header[2] = n # number of tokens
+    header[3] = enc.eot_token # EOT token
+    with open(filename, "wb") as file:
+        file.write(header.numpy().tobytes())
+        for i in range(n):
+            b = enc.decode_bytes([i])
+            length = len(b)
+            assert length < 256, f"Token length exceeds 255: {length}"
+            file.write(struct.pack("<B", length))  # Write the length as a 1-byte unsigned integer
+            file.write(b)  # Write the actual bytes
+    print(f"wrote {filename}")
+
+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
+
+# -----------------------------------------------------------------------------
+# Helper functions for norm calculations
+
+def calculate_l1_to_linf_norm(matrix):
+    if matrix.ndim == 1:
+        return torch.sum(torch.abs(matrix))
+    elif matrix.ndim == 2:
+        # Each row's L1 norm, then take maximum
+        row_l1_norms = torch.sum(torch.abs(matrix), dim=1)
+        return torch.max(row_l1_norms)
+    else:
+        # For higher-dimensional tensors, flatten to 2D
+        matrix_2d = matrix.view(matrix.shape[0], -1)
+        row_l1_norms = torch.sum(torch.abs(matrix_2d), dim=1)
+        return torch.max(row_l1_norms)
+
+def calculate_spectral_norm(matrix):
+    """
+    Calculate the spectral norm (largest singular value) of a matrix.
+    For vectors, returns the L2 norm.
+    """
+    # Convert to float32 if needed for linalg operations
+    if matrix.dtype in [torch.bfloat16, torch.float16]:
+        matrix = matrix.float()
+    
+    if matrix.ndim == 1:
+        return torch.norm(matrix, p=2)
+    elif matrix.ndim == 2:
+        # Use matrix 2-norm (largest singular value)
+        return torch.linalg.matrix_norm(matrix, ord=2)
+    else:
+        # For higher-dimensional tensors, flatten to 2D
+        matrix_2d = matrix.view(matrix.shape[0], -1)
+        return torch.linalg.matrix_norm(matrix_2d, ord=2)
+
+# -----------------------------------------------------------------------------
+# Comprehensive sharpness analysis function
+
+def calculate_comprehensive_sharpness(model, model_for_forward, optimizers, step, train_loader, val_loader,
+                                      rank, world_size, device, B, T, ptdtype, grad_accum_steps, last_training_update=None, last_training_gradient=None, last_training_batches=None):
+    prev_training_mode = model.training
+    model.eval()
+    
+    NUM_LAYERS = model.config.n_layer # Number of transformer blocks
+    analysis_results = {}
+    
+    # --- 1. Get the true update direction 'v' ---
+    assert last_training_update is not None, \
+        f"[Step {step}] BUG: last_training_update is None! Check sharpness timing logic."
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] Using update from previous training step")
+    update_direction_v = last_training_update
+    
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] Restoring parameters to θ_t for HVP calculation...")
+    with torch.no_grad():
+        for p, v in zip(model.parameters(), update_direction_v):
+            p.data.sub_(v)  # Now parameters are at θ_t
+    
+    # --- 2. Calculate update norms (Frobenius, Max-of-Max, Spectral) ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Calculating update norms...")
+    
+    total_update_norm_sq = sum(torch.sum(v * v) for v in update_direction_v)
+    dist.all_reduce(total_update_norm_sq, op=dist.ReduceOp.AVG)
+    analysis_results["total_update_fnorm"] = torch.sqrt(total_update_norm_sq).item()
+    
+    # Calculate TOTAL update Max-of-Max and Spectral norms
+    print0(f"[Enhanced Sharpness @ Step {step}] Calculating total update Max-of-Max and Spectral norms...")
+    try:
+        all_updates_flat = torch.cat([v.flatten() for v in update_direction_v if v.numel() > 0])
+        
+        if all_updates_flat.numel() > 0:
+            total_l1_linf_norm = torch.sum(torch.abs(all_updates_flat))
+            analysis_results["total_l1_linf_norm"] = total_l1_linf_norm.item()
+            
+            total_spectral_norm = torch.norm(all_updates_flat, p=2)
+            analysis_results["total_spectral_norm"] = total_spectral_norm.item()
+        else:
+            analysis_results["total_l1_linf_norm"] = 0.0
+            analysis_results["total_spectral_norm"] = 0.0
+            
+        del all_updates_flat
+    except Exception as e:
+        print0(f"[Enhanced Sharpness @ Step {step}] Error calculating total norms: {e}")
+        analysis_results["total_l1_linf_norm"] = 0.0
+        analysis_results["total_spectral_norm"] = 0.0
+    
+    # --- 3. Setup layer parameter groups (adapt to new model structure) ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Setting up layer parameter groups...")
+    
+    all_param_groups = {}
+    
+    
+    all_param_groups["embed_lm_head"] = list(model.lm_head.parameters())
+    
+    blocks = model.transformer.h
+    
+    for i, block in enumerate(blocks):
+        layer_name = f"layer_{i+1}"
+        all_param_groups[layer_name] = list(block.parameters())
+    
+    # Add fine-grained params for selected layers (0, 3, 7, 11)
+    selected_layers = [0, 3, 7, 11]
+    for layer_idx in selected_layers:
+        block = blocks[layer_idx]
+        prefix = f"block{layer_idx}"
+        # Attention: Q, K, V, O
+        all_param_groups[f"{prefix}_q"] = [block.attn.q_w.weight]
+        all_param_groups[f"{prefix}_k"] = [block.attn.k_w.weight]
+        all_param_groups[f"{prefix}_v"] = [block.attn.v_w.weight]
+        all_param_groups[f"{prefix}_o"] = [block.attn.c_proj.weight]
+        # MLP: c_fc (win) and c_proj (wout)
+        all_param_groups[f"{prefix}_mlp_win"] = [block.mlp.c_fc.weight]
+        all_param_groups[f"{prefix}_mlp_wout"] = [block.mlp.c_proj.weight]
+    
+    # --- 4. Calculate layer-wise update norms ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Calculating layer-wise update norms...")
+    
+    param_to_idx = {id(p): i for i, p in enumerate(model.parameters())}
+    
+    for group_name, param_group in all_param_groups.items():
+        if not param_group:
+            continue
+            
+        # Get indices for this group
+        indices = [param_to_idx[id(p)] for p in param_group if id(p) in param_to_idx]
+        if not indices:
+            continue
+        
+        # Calculate Frobenius norm for this group
+        group_update_norm_sq = sum(torch.sum(update_direction_v[i] * update_direction_v[i]) for i in indices)
+        dist.all_reduce(group_update_norm_sq, op=dist.ReduceOp.AVG)
+        analysis_results[f"{group_name}_update_fnorm"] = torch.sqrt(group_update_norm_sq).item()
+        
+        # Calculate Max-of-Max and Spectral norms for this group
+        group_l1_linf_norms = []
+        group_spectral_norms = []
+        
+        for i in indices:
+            if i < len(update_direction_v) and update_direction_v[i].numel() > 0:
+                try:
+                    l1_linf_norm = calculate_l1_to_linf_norm(update_direction_v[i])
+                    group_l1_linf_norms.append(l1_linf_norm.item())
+                    
+                    spectral_norm = calculate_spectral_norm(update_direction_v[i])
+                    group_spectral_norms.append(spectral_norm.item())
+                except Exception as e:
+                    print0(f"[Enhanced Sharpness @ Step {step}] Error calculating norms for group {group_name}, param {i}: {e}")
+                    group_l1_linf_norms.append(0.0)
+                    group_spectral_norms.append(0.0)
+        
+        if group_l1_linf_norms:
+            analysis_results[f"{group_name}_max_l1_linf_norm"] = max(group_l1_linf_norms)
+        else:
+            analysis_results[f"{group_name}_max_l1_linf_norm"] = 0.0
+            
+        if group_spectral_norms:
+            analysis_results[f"{group_name}_max_spectral_norm"] = max(group_spectral_norms)
+        else:
+            analysis_results[f"{group_name}_max_spectral_norm"] = 0.0
+    
+    # --- 5. Setup for HVP calculation on TRAIN data ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Setting up HVP calculation in {ptdtype} on TRAIN data...")
+    
+    original_flash = nano_GPT_qkvonorm_pure.FLASH
+    nano_GPT_qkvonorm_pure.FLASH = 0
+    print0(f"[Enhanced Sharpness @ Step {step}] Disabled FLASH attention for HVP (was {original_flash})")
+
+    # Get block parameter indices for cross-layer analysis (need this before loop)
+    block_param_indices = set()
+    for group_name, param_group in all_param_groups.items():
+        if group_name.startswith("layer_"):
+            for p in param_group:
+                if id(p) in param_to_idx:
+                    block_param_indices.add(param_to_idx[id(p)])
+
+    # Initialize accumulators for all quantities we need
+    grads_hvp = None          
+    hvp_v_total = None        
+    hvp_v_block = None        
+    hvp_g_accum = None       
+    layer_hvp_accum = {}
+    
+   
+    group_names_to_process = [gn for gn, pg in all_param_groups.items() 
+                              if pg and any(id(p) in param_to_idx for p in pg)]
+    
+    if last_training_batches is not None and len(last_training_batches) > 0:
+        
+        batch_iterator = [(x, y) for x, y in last_training_batches]
+        n_batches = len(batch_iterator)
+        print0(f"[Enhanced Sharpness @ Step {step}] Using {n_batches} microbatches for HVP (out of {grad_accum_steps} training microbatches)")
+        restore_loader = False
+    else:
+        # Fallback: use new batches from train_loader (should rarely happen)
+        print0(f"[Enhanced Sharpness @ Step {step}] WARNING: last_training_batches is None/empty, using {grad_accum_steps} new batches (inconsistent)")
+        saved_current_shard = train_loader.current_shard
+        saved_current_position = train_loader.current_position
+        n_batches = grad_accum_steps  # Use same number as training for consistency
+        batch_iterator = []
+        shard_was_changed = False
+        for _ in range(n_batches):
+            x_hvp, y_hvp = train_loader.next_batch()
+            batch_iterator.append((x_hvp, y_hvp))
+            shard_was_changed = shard_was_changed or (train_loader.current_shard != saved_current_shard)
+        restore_loader = True
+
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] Computing HVPs for {n_batches} microbatches")
+    for mb_idx, (x_hvp, y_hvp) in enumerate(batch_iterator):
+        x_hvp, y_hvp = x_hvp.to(device), y_hvp.to(device)
+        
+        
+        _, loss_mb = model(x_hvp, y_hvp, return_logits=False)
+        grads_mb = torch.autograd.grad(loss_mb, model.parameters(), create_graph=True, allow_unused=True)
+        
+        # Compute H·v (total sharpness)
+        v_dot_g_total = sum(torch.sum(g * v) for g, v in zip(grads_mb, update_direction_v) if g is not None)
+        
+        if not isinstance(v_dot_g_total, torch.Tensor):
+            v_dot_g_total = torch.tensor(0.0, device=device, requires_grad=True)
+        hvp_v_total_mb = torch.autograd.grad(v_dot_g_total, model.parameters(), retain_graph=True, allow_unused=True)
+        
+        # Compute H·v_block (block-only sharpness)
+        if block_param_indices:  
+            v_dot_g_block = sum(torch.sum(grads_mb[i] * update_direction_v[i]) 
+                               for i in block_param_indices if grads_mb[i] is not None)
+            if not isinstance(v_dot_g_block, torch.Tensor):
+                v_dot_g_block = torch.tensor(0.0, device=device, requires_grad=True)
+            hvp_v_block_mb = torch.autograd.grad(v_dot_g_block, model.parameters(), retain_graph=True, allow_unused=True)
+        else:
+            
+            hvp_v_block_mb = [None] * len(list(model.parameters()))
+        
+        
+        g_dot_g = sum(torch.sum(g * g) for g in grads_mb if g is not None)
+        if not isinstance(g_dot_g, torch.Tensor):
+            g_dot_g = torch.tensor(0.0, device=device, requires_grad=True)
+        
+        
+        hvp_g_mb_raw = torch.autograd.grad(g_dot_g, model.parameters(), 
+                                           retain_graph=True, allow_unused=True)
+        hvp_g_mb = [h / 2.0 if h is not None else None for h in hvp_g_mb_raw]
+        
+        # Compute per-layer H_kk·v_k (for layer-wise sharpness)
+        for group_idx, group_name in enumerate(group_names_to_process):
+            param_group = all_param_groups[group_name]
+            indices = {param_to_idx[id(p)] for p in param_group if id(p) in param_to_idx}
+            if not indices:
+                continue
+            
+            is_last_layer = (group_idx == len(group_names_to_process) - 1)
+            is_last_microbatch = (mb_idx == n_batches - 1)
+            need_retain = not (is_last_layer and is_last_microbatch)
+            
+            try:
+                v_dot_g_layer = sum(torch.sum(grads_mb[i] * update_direction_v[i]) 
+                                   for i in indices if grads_mb[i] is not None)
+                
+                if not isinstance(v_dot_g_layer, torch.Tensor):
+                    v_dot_g_layer = torch.tensor(0.0, device=device, requires_grad=True)
+                    
+                hvp_layer_mb = torch.autograd.grad(v_dot_g_layer, model.parameters(), 
+                                                   retain_graph=need_retain,
+                                                   allow_unused=True)
+
+                if group_name not in layer_hvp_accum:
+                    layer_hvp_accum[group_name] = [(h.detach() / n_batches).cpu() if h is not None else None for h in hvp_layer_mb]
+                else:
+                    layer_hvp_accum[group_name] = [
+                        (h_acc + (h.detach() / n_batches).cpu()) if (h is not None and h_acc is not None)
+                        else ((h.detach() / n_batches).cpu() if h is not None else h_acc)
+                        for h_acc, h in zip(layer_hvp_accum[group_name], hvp_layer_mb)
+                    ]
+                
+                # Accumulate layer HVP
+                # if group_name not in layer_hvp_accum:
+                #     layer_hvp_accum[group_name] = [h.detach() / n_batches if h is not None else None for h in hvp_layer_mb]
+                # else:
+                #     layer_hvp_accum[group_name] = [
+                #         (h_acc + h.detach() / n_batches) if (h is not None and h_acc is not None)
+                #         else (h.detach() / n_batches if h is not None else h_acc)
+                #         for h_acc, h in zip(layer_hvp_accum[group_name], hvp_layer_mb)
+                #     ]
+                #     del hvp_layer_mb, v_dot_g_layer
+                #     torch.cuda.empty_cache()
+            except Exception as e:
+                print0(f"[Enhanced Sharpness @ Step {step}] Error computing layer HVP for '{group_name}' in microbatch {mb_idx}: {e}")
+                if group_name not in layer_hvp_accum:
+                    layer_hvp_accum[group_name] = None
+        
+        # 6. Accumulate all quantities
+        if grads_hvp is None:
+            grads_hvp = [(g.detach() / n_batches).cpu() if g is not None else None for g in grads_mb]
+            hvp_v_total = [(h.detach() / n_batches).cpu() if h is not None else None for h in hvp_v_total_mb]
+            hvp_v_block = [(h.detach() / n_batches).cpu() if h is not None else None for h in hvp_v_block_mb]
+            hvp_g_accum = [(h.detach() / n_batches).cpu() if h is not None else None for h in hvp_g_mb]
+        else:
+            grads_hvp = [
+                (g_acc + (g.detach() / n_batches).cpu()) if (g is not None and g_acc is not None) 
+                else ((g.detach() / n_batches).cpu() if g is not None else g_acc)
+                for g_acc, g in zip(grads_hvp, grads_mb)
+            ]
+            hvp_v_total = [
+                (h_acc + (h.detach() / n_batches).cpu()) if (h is not None and h_acc is not None)
+                else ((h.detach() / n_batches).cpu() if h is not None else h_acc)
+                for h_acc, h in zip(hvp_v_total, hvp_v_total_mb)
+            ]
+            hvp_v_block = [
+                (h_acc + (h.detach() / n_batches).cpu()) if (h is not None and h_acc is not None)
+                else ((h.detach() / n_batches).cpu() if h is not None else h_acc)
+                for h_acc, h in zip(hvp_v_block, hvp_v_block_mb)
+            ]
+            hvp_g_accum = [
+                (h_acc + (h.detach() / n_batches).cpu()) if (h is not None and h_acc is not None)
+                else ((h.detach() / n_batches).cpu() if h is not None else h_acc)
+                for h_acc, h in zip(hvp_g_accum, hvp_g_mb)
+            ]
+
+        
+        
+        if mb_idx % max(1, n_batches // 4) == 0:
+            print0(f"[Enhanced Sharpness @ Step {step}] Processed microbatch {mb_idx + 1}/{n_batches}")
+    
+   
+    if restore_loader:
+        train_loader.current_shard = saved_current_shard
+        train_loader.current_position = saved_current_position
+        if shard_was_changed:
+            train_loader.tokens = _load_data_shard(train_loader.files[train_loader.current_shard])
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] Finished computing all HVPs for {n_batches} microbatches")
+    grads_hvp = [g.to(device) if g is not None else None for g in grads_hvp]
+    hvp_v_total = [h.to(device) if h is not None else None for h in hvp_v_total]
+    hvp_v_block = [h.to(device) if h is not None else None for h in hvp_v_block]
+    hvp_g_accum = [h.to(device) if h is not None else None for h in hvp_g_accum]
+    for group_name in layer_hvp_accum:
+        if layer_hvp_accum[group_name] is not None:
+            layer_hvp_accum[group_name] = [h.to(device) if h is not None else None for h in layer_hvp_accum[group_name]]
+    # --- Calculate TOTAL sharpness ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Calculating TOTAL sharpness...")
+    # hvp_v_total is already computed in the loop above
+    vhp_dot_v_total = sum(torch.sum(hvp * v) for hvp, v in zip(hvp_v_total, update_direction_v) if hvp is not None)
+    v_norm_sq_total = sum(torch.sum(v * v) for v in update_direction_v)
+    
+    # Ensure they are tensors
+    if not isinstance(vhp_dot_v_total, torch.Tensor):
+        vhp_dot_v_total = torch.tensor(0.0, device=device)
+    if not isinstance(v_norm_sq_total, torch.Tensor):
+        v_norm_sq_total = torch.tensor(0.0, device=device)
+
+    dist.all_reduce(vhp_dot_v_total, op=dist.ReduceOp.AVG)
+    dist.all_reduce(v_norm_sq_total, op=dist.ReduceOp.AVG)
+
+    if v_norm_sq_total.item() > 1e-12:
+        analysis_results["total_sharpness"] = (vhp_dot_v_total / v_norm_sq_total).item()
+    else:
+        analysis_results["total_sharpness"] = 0.0
+
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] Calculating BLOCK-ONLY total sharpness...")
+    # hvp_v_block is already computed in the loop above
+    if block_param_indices:  # Only compute if there are block parameters
+        # Compute v_block^T H v_block (only sum over block indices)
+        vhp_dot_v_block = sum(torch.sum(hvp_v_block[i] * update_direction_v[i]) 
+                              for i in block_param_indices if hvp_v_block[i] is not None)
+        
+        v_norm_sq_block = sum(torch.sum(update_direction_v[i] * update_direction_v[i]) 
+                              for i in block_param_indices)
+        
+        # Ensure they are tensors
+        if not isinstance(vhp_dot_v_block, torch.Tensor):
+            vhp_dot_v_block = torch.tensor(0.0, device=device)
+        if not isinstance(v_norm_sq_block, torch.Tensor):
+            v_norm_sq_block = torch.tensor(0.0, device=device)
+        
+        dist.all_reduce(vhp_dot_v_block, op=dist.ReduceOp.AVG)
+        dist.all_reduce(v_norm_sq_block, op=dist.ReduceOp.AVG)
+        
+        if v_norm_sq_block.item() > 1e-12:
+            analysis_results["block_total_sharpness"] = (vhp_dot_v_block / v_norm_sq_block).item()
+        else:
+            analysis_results["block_total_sharpness"] = 0.0
+        
+        analysis_results["v_norm_block"] = torch.sqrt(v_norm_sq_block).item()
+        analysis_results["v_T_H_v_block"] = vhp_dot_v_block.item()
+    else:
+        # No block parameters
+        analysis_results["block_total_sharpness"] = 0.0
+        analysis_results["v_norm_block"] = 0.0
+        analysis_results["v_T_H_v_block"] = 0.0
+    
+    torch.cuda.empty_cache()
+
+    # ---- Alignment metrics between update v and (negative) gradient g ----
+    eps = 1e-12
+    v_norm = torch.sqrt(v_norm_sq_total + eps)
+    analysis_results["v_norm"] = v_norm.item()
+    
+    # --- Version 1: g_hvp  ---
+    ip_v_neg_g_hvp = sum(torch.sum(v * (-g)) for v, g in zip(update_direction_v, grads_hvp) if g is not None)
+    g_hvp_norm_sq = sum(torch.sum(g * g) for g in grads_hvp if g is not None)
+    
+    if not isinstance(ip_v_neg_g_hvp, torch.Tensor):
+        ip_v_neg_g_hvp = torch.tensor(0.0, device=device)
+    if not isinstance(g_hvp_norm_sq, torch.Tensor):
+        g_hvp_norm_sq = torch.tensor(0.0, device=device)
+    dist.all_reduce(ip_v_neg_g_hvp, op=dist.ReduceOp.AVG)
+    dist.all_reduce(g_hvp_norm_sq, op=dist.ReduceOp.AVG)
+    g_hvp_norm = torch.sqrt(g_hvp_norm_sq + eps)
+    analysis_results["ip_v_neg_g_hvp"] = ip_v_neg_g_hvp.item()
+    analysis_results["cos_v_neg_g_hvp"] = (ip_v_neg_g_hvp / (v_norm * g_hvp_norm + eps)).item()
+    analysis_results["g_hvp_norm"] = g_hvp_norm.item()
+    
+    # --- Version 2: g_t (original gradient that produced v) ---
+    # last_training_gradient is the actual gradient from training that led to the update v
+    if last_training_gradient is not None:
+        ip_v_neg_g_t = sum(torch.sum(v * (-g)) for v, g in zip(update_direction_v, last_training_gradient) if g is not None)
+        g_t_norm_sq = sum(torch.sum(g * g) for g in last_training_gradient if g is not None)
+        dist.all_reduce(ip_v_neg_g_t, op=dist.ReduceOp.AVG)
+        dist.all_reduce(g_t_norm_sq, op=dist.ReduceOp.AVG)
+        g_t_norm = torch.sqrt(g_t_norm_sq + eps)
+        analysis_results["ip_v_neg_g_t"] = ip_v_neg_g_t.item()
+        analysis_results["cos_v_neg_g_t"] = (ip_v_neg_g_t / (v_norm * g_t_norm + eps)).item()
+        analysis_results["g_t_norm"] = g_t_norm.item()
+    else:
+        print0(f"[Enhanced Sharpness @ Step {step}] Warning: last_training_gradient is None, skipping g_t metrics")
+    
+    # Keep backward compatibility aliases (g_norm uses g_hvp for now)
+    g_norm_sq = g_hvp_norm_sq
+    g_norm = g_hvp_norm
+    analysis_results["g_norm"] = g_norm.item()
+
+    # ---- Cosine between v and Hv (curvature pull along v) ----
+    hv_norm_sq = sum(torch.sum(hvp * hvp) for hvp in hvp_v_total if hvp is not None)
+    if not isinstance(hv_norm_sq, torch.Tensor):
+        hv_norm_sq = torch.tensor(0.0, device=device)
+    dist.all_reduce(hv_norm_sq, op=dist.ReduceOp.AVG)
+    hv_norm = torch.sqrt(hv_norm_sq + eps)
+    ip_v_hv = vhp_dot_v_total  # already reduced AVG
+    analysis_results["hv_norm"] = hv_norm.item()
+    analysis_results["cos_v_hv"] = (ip_v_hv / (v_norm * hv_norm + eps)).item()
+
+    # ---- Cosine between g and Hg ----
+    # hvp_g_accum is already computed in the loop above
+    ip_g_hg = sum(torch.sum(g * hg) for g, hg in zip(grads_hvp, hvp_g_accum) if (g is not None and hg is not None))
+    hg_norm_sq = sum(torch.sum(hg * hg) for hg in hvp_g_accum if hg is not None)
+    if not isinstance(ip_g_hg, torch.Tensor):
+        ip_g_hg = torch.tensor(0.0, device=device)
+    if not isinstance(hg_norm_sq, torch.Tensor):
+        hg_norm_sq = torch.tensor(0.0, device=device)
+    dist.all_reduce(ip_g_hg, op=dist.ReduceOp.AVG)
+    dist.all_reduce(hg_norm_sq, op=dist.ReduceOp.AVG)
+    hg_norm = torch.sqrt(hg_norm_sq + eps)
+    analysis_results["hg_norm"] = hg_norm.item()
+    analysis_results["cos_g_hg"] = (ip_g_hg / (g_norm * hg_norm + eps)).item() if g_norm.item() > 0 else 0.0
+
+    # ---- Decompose v into parallel / perpendicular to -g ----
+    if g_norm.item() > 0:
+        v_parallel = [(torch.sum(v * (-g)) / (g_norm_sq + eps)) * (-g) if g is not None else torch.zeros_like(v)
+                      for v, g in zip(update_direction_v, grads_hvp)]
+        v_parallel_norm_sq = sum(torch.sum(vp * vp) for vp in v_parallel)
+        if not isinstance(v_parallel_norm_sq, torch.Tensor):
+            v_parallel_norm_sq = torch.tensor(0.0, device=device)
+        dist.all_reduce(v_parallel_norm_sq, op=dist.ReduceOp.AVG)
+        v_parallel_norm = torch.sqrt(v_parallel_norm_sq + eps)
+        v_perp_norm = torch.sqrt(torch.clamp(v_norm_sq_total - v_parallel_norm_sq, min=0.0) + eps)
+        analysis_results["v_parallel_norm"] = v_parallel_norm.item()
+        analysis_results["v_perp_norm"] = v_perp_norm.item()
+
+    # ---- Per-layer additions: cos_v_neg_g_layer, v_norm_layer ----
+    for group_name, param_group in all_param_groups.items():
+        indices = {param_to_idx[id(p)] for p in param_group if id(p) in param_to_idx}
+        if not indices:
+            continue
+        v_norm_sq_layer = sum(torch.sum(update_direction_v[i] * update_direction_v[i]) for i in indices)
+        g_norm_sq_layer = sum(torch.sum(grads_hvp[i] * grads_hvp[i]) for i in indices if grads_hvp[i] is not None)
+        ip_v_neg_g_layer = sum(torch.sum(update_direction_v[i] * (-grads_hvp[i]))
+                               for i in indices if grads_hvp[i] is not None)
+        # Ensure they are tensors
+        if not isinstance(v_norm_sq_layer, torch.Tensor):
+            v_norm_sq_layer = torch.tensor(0.0, device=device)
+        if not isinstance(g_norm_sq_layer, torch.Tensor):
+            g_norm_sq_layer = torch.tensor(0.0, device=device)
+        if not isinstance(ip_v_neg_g_layer, torch.Tensor):
+            ip_v_neg_g_layer = torch.tensor(0.0, device=device)
+        dist.all_reduce(v_norm_sq_layer, op=dist.ReduceOp.AVG)
+        dist.all_reduce(g_norm_sq_layer, op=dist.ReduceOp.AVG)
+        dist.all_reduce(ip_v_neg_g_layer, op=dist.ReduceOp.AVG)
+        v_norm_layer = torch.sqrt(v_norm_sq_layer + eps)
+        g_norm_layer = torch.sqrt(g_norm_sq_layer + eps)
+        analysis_results[f"{group_name}_v_norm"] = v_norm_layer.item()
+        if g_norm_layer.item() > 0:
+            analysis_results[f"{group_name}_cos_v_neg_g"] = (ip_v_neg_g_layer / (v_norm_layer * g_norm_layer + eps)).item()
+
+    # --- 7. Calculate layer-wise sharpness ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Calculating layer-wise sharpness...")
+    print0(f"[Enhanced Sharpness @ Step {step}] Processing {len(all_param_groups)} layers for sharpness...")
+    
+    for group_name, param_group in all_param_groups.items():
+        if not param_group:
+            continue
+            
+        print0(f"[Enhanced Sharpness @ Step {step}] Processing '{group_name}'...")
+        indices = {param_to_idx[id(p)] for p in param_group if id(p) in param_to_idx}
+        if not indices: 
+            continue
+
+        try:
+            if group_name not in layer_hvp_accum or layer_hvp_accum[group_name] is None:
+                print0(f"[Enhanced Sharpness @ Step {step}] No HVP data for '{group_name}', skipping")
+                analysis_results[f"{group_name}_sharpness"] = 0.0
+                continue
+                
+            hvp_group_result = layer_hvp_accum[group_name]
+            
+            vhp_dot_v_group = sum(torch.sum(hvp_group_result[i] * update_direction_v[i]) 
+                                for i in indices if hvp_group_result[i] is not None)
+            v_norm_sq_group = sum(torch.sum(update_direction_v[i] * update_direction_v[i]) 
+                                for i in indices)
+            
+            # Ensure they are tensors
+            if not isinstance(vhp_dot_v_group, torch.Tensor):
+                vhp_dot_v_group = torch.tensor(0.0, device=device)
+            if not isinstance(v_norm_sq_group, torch.Tensor):
+                v_norm_sq_group = torch.tensor(0.0, device=device)
+            
+            dist.all_reduce(vhp_dot_v_group, op=dist.ReduceOp.AVG)
+            dist.all_reduce(v_norm_sq_group, op=dist.ReduceOp.AVG)
+            
+            if v_norm_sq_group.item() > 1e-12:
+                analysis_results[f"{group_name}_sharpness"] = (vhp_dot_v_group / v_norm_sq_group).item()
+            else:
+                analysis_results[f"{group_name}_sharpness"] = 0.0
+            
+        except torch.OutOfMemoryError as e:
+            print0(f"[Enhanced Sharpness @ Step {step}] OOM error for '{group_name}': {e}")
+            analysis_results[f"{group_name}_sharpness"] = 0.0
+            torch.cuda.empty_cache()
+        except Exception as e:
+            print0(f"[Enhanced Sharpness @ Step {step}] Error processing '{group_name}': {e}")
+            analysis_results[f"{group_name}_sharpness"] = 0.0
+
+    # --- Calculate block-diagonal approximation and cross-layer interaction ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Calculating block-diagonal and cross-layer sharpness...")
+    
+    sum_layer_numerators = 0.0
+    for layer in range(1, NUM_LAYERS + 1):
+        layer_name = f"layer_{layer}"
+        if f"{layer_name}_sharpness" in analysis_results and f"{layer_name}_v_norm" in analysis_results:
+            s_k = analysis_results[f"{layer_name}_sharpness"]
+            v_k_norm = analysis_results[f"{layer_name}_v_norm"]
+            sum_layer_numerators += s_k * (v_k_norm ** 2)
+    
+    analysis_results["sum_layer_numerators"] = sum_layer_numerators
+    
+    # Block-diagonal sharpness (using block ||v||²)
+    v_norm_block = analysis_results.get("v_norm_block", 0)
+    v_norm_sq_block_val = v_norm_block ** 2 if v_norm_block else 1e-12
+    
+    if v_norm_sq_block_val > 1e-12:
+        analysis_results["block_diag_sharpness"] = sum_layer_numerators / v_norm_sq_block_val
+    else:
+        analysis_results["block_diag_sharpness"] = 0.0
+    
+    # Cross-layer interaction = block_total - block_diag
+    block_total = analysis_results.get("block_total_sharpness", 0)
+    block_diag = analysis_results.get("block_diag_sharpness", 0)
+    analysis_results["cross_layer_sharpness"] = block_total - block_diag
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] block_total={block_total:.6f}, block_diag={block_diag:.6f}, cross_layer={block_total - block_diag:.6f}")
+
+    # --- Compute true_dec and pred_dec ---
+    print0(f"[Enhanced Sharpness @ Step {step}] Computing true_dec (L(t) - L(t+1)) on training batch...")
+    try:
+        # Restore FLASH for forward pass 
+        nano_GPT_qkvonorm_pure.FLASH = original_flash
+
+        
+        loss_at_theta_t = 0.0
+        with torch.no_grad():
+            for x_td, y_td in batch_iterator:
+                x_td, y_td = x_td.to(device), y_td.to(device)
+                _, loss_td = model(x_td, y_td, return_logits=False)
+                loss_at_theta_t += loss_td.item()
+        loss_at_theta_t /= len(batch_iterator)  # average over microbatches
+
+        with torch.no_grad():
+            for p, v in zip(model.parameters(), update_direction_v):
+                p.data.add_(v)
+
+        loss_at_theta_t1 = 0.0
+        with torch.no_grad():
+            for x_td, y_td in batch_iterator:
+                x_td, y_td = x_td.to(device), y_td.to(device)
+                _, loss_td = model(x_td, y_td, return_logits=False)
+                loss_at_theta_t1 += loss_td.item()
+        loss_at_theta_t1 /= len(batch_iterator)
+
+        with torch.no_grad():
+            for p, v in zip(model.parameters(), update_direction_v):
+                p.data.sub_(v)
+
+        loss_t_tensor = torch.tensor(loss_at_theta_t, device=device)
+        loss_t1_tensor = torch.tensor(loss_at_theta_t1, device=device)
+        dist.all_reduce(loss_t_tensor, op=dist.ReduceOp.AVG)
+        dist.all_reduce(loss_t1_tensor, op=dist.ReduceOp.AVG)
+        loss_at_theta_t = loss_t_tensor.item()
+        loss_at_theta_t1 = loss_t1_tensor.item()
+
+        true_dec = loss_at_theta_t - loss_at_theta_t1
+        analysis_results["loss_at_theta_t"] = loss_at_theta_t
+        analysis_results["loss_at_theta_t1"] = loss_at_theta_t1
+        analysis_results["true_dec"] = true_dec
+
+        # pred_dec = (-g)^T v - 0.5 * v^T H v 
+        first_order = analysis_results.get("ip_v_neg_g_t", analysis_results.get("ip_v_neg_g_hvp", 0.0))
+        sharpness_val = analysis_results.get("total_sharpness", 0.0)
+        v_norm_val = analysis_results.get("v_norm", 0.0)
+        curvature_term = 0.5 * sharpness_val * (v_norm_val ** 2)
+        pred_dec = first_order - curvature_term
+
+        analysis_results["pred_dec"] = pred_dec
+        analysis_results["first_order_descent"] = first_order
+        analysis_results["curvature_penalty"] = curvature_term
+
+        print0(f"[Enhanced Sharpness @ Step {step}] L(θ_t)={loss_at_theta_t:.6f}, L(θ_{{t+1}})={loss_at_theta_t1:.6f}, "
+               f"true_dec={true_dec:.6f}, pred_dec={pred_dec:.6f}, 1st_order={first_order:.6f}, curvature={curvature_term:.6f}")
+    except Exception as e:
+        print0(f"[Enhanced Sharpness @ Step {step}] Error computing true_dec: {e}")
+        analysis_results["true_dec"] = 0.0
+        analysis_results["pred_dec"] = 0.0
+
+    # --- Cleanup ---
+    nano_GPT_qkvonorm_pure.FLASH = original_flash
+    print0(f"[Enhanced Sharpness @ Step {step}] Restored FLASH attention to {original_flash}")
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] Restoring parameters back to θ_{{t+1}}...")
+    with torch.no_grad():
+        for p, v in zip(model.parameters(), update_direction_v):
+            p.data.add_(v)  
+    
+    if prev_training_mode:
+        model.train()
+    else:
+        model.eval()
+    
+    # Thorough cleanup of all temporary variables
+    del update_direction_v, grads_hvp
+    del hvp_v_total, hvp_v_block, hvp_g_accum, layer_hvp_accum
+    del vhp_dot_v_total, v_norm_sq_total
+    del vhp_dot_v_block, v_norm_sq_block
+    if 'all_param_groups' in locals():
+        del all_param_groups
+    if 'param_to_idx' in locals():
+        del param_to_idx
+    
+    # Synchronize CUDA operations before cleanup
+    if device == "cuda":
+        torch.cuda.synchronize()
+    
+    gc.collect()
+    torch.cuda.empty_cache()
+    
+    print0(f"[Enhanced Sharpness @ Step {step}] Analysis complete. Generated {len(analysis_results)} metrics.")
+    return analysis_results
+
+def format_comprehensive_results(results):
+    """
+    Format the comprehensive analysis results for logging.
+    """
+    log_parts = []
+    
+    # Total sharpness
+    if 'total_sharpness' in results:
+        log_parts.append(f"total_sharp:{results['total_sharpness']:.4e}")
+    
+    # Layer-wise sharpness - dynamically detect number of layers
+    layer_sharpness = []
+    layer_num = 1
+    while True:
+        layer_key = f"layer_{layer_num}_sharpness"
+        if layer_key in results:
+            layer_sharpness.append(f"L{layer_num}_sharp:{results[layer_key]:.4e}")
+            layer_num += 1
+        else:
+            break
+    
+    if layer_sharpness:
+        log_parts.append(" ".join(layer_sharpness))
+    
+    # Total update norms
+    total_norms = []
+    if 'total_update_fnorm' in results:
+        total_norms.append(f"total_fnorm:{results['total_update_fnorm']:.4e}")
+    if 'total_l1_linf_norm' in results:
+        total_norms.append(f"total_l1_linf:{results['total_l1_linf_norm']:.4e}")
+    if 'total_spectral_norm' in results:
+        total_norms.append(f"total_spectral:{results['total_spectral_norm']:.4e}")
+    
+    if total_norms:
+        log_parts.append(" ".join(total_norms))
+    
+    # Layer-wise update norms (Frobenius)
+    layer_fnorms = []
+    layer_num = 1
+    while True:
+        layer_key = f"layer_{layer_num}_update_fnorm"
+        if layer_key in results:
+            layer_fnorms.append(f"L{layer_num}_fnorm:{results[layer_key]:.4e}")
+            layer_num += 1
+        else:
+            break
+    
+    if layer_fnorms:
+        log_parts.append(" ".join(layer_fnorms))
+    
+    # Layer-wise update norms (Max-of-Max)
+    layer_l1_linf = []
+    layer_num = 1
+    while True:
+        layer_key = f"layer_{layer_num}_max_l1_linf_norm"
+        if layer_key in results:
+            layer_l1_linf.append(f"L{layer_num}_l1linf:{results[layer_key]:.4e}")
+            layer_num += 1
+        else:
+            break
+    
+    if layer_l1_linf:
+        log_parts.append(" ".join(layer_l1_linf))
+    
+    # Layer-wise update norms (Spectral)
+    layer_spectral = []
+    layer_num = 1
+    while True:
+        layer_key = f"layer_{layer_num}_max_spectral_norm"
+        if layer_key in results:
+            layer_spectral.append(f"L{layer_num}_spectral:{results[layer_key]:.4e}")
+            layer_num += 1
+        else:
+            break
+    
+    if layer_spectral:
+        log_parts.append(" ".join(layer_spectral))
+
+    # Alignment and curvature metrics (global)
+    misc_parts = []
+    if 'v_norm' in results:
+        misc_parts.append(f"v_norm:{results['v_norm']:.4e}")
+    
+    # Version 1: g_hvp (new batch, computed at θ_t during HVP calculation)
+    if 'cos_v_neg_g_hvp' in results:
+        misc_parts.append(f"cos_v_-g_hvp:{results['cos_v_neg_g_hvp']:.4e}")
+    if 'g_hvp_norm' in results:
+        misc_parts.append(f"g_hvp_norm:{results['g_hvp_norm']:.4e}")
+    
+    # Version 2: g_t (original gradient that produced v)
+    if 'cos_v_neg_g_t' in results:
+        misc_parts.append(f"cos_v_-g_t:{results['cos_v_neg_g_t']:.4e}")
+    if 'g_t_norm' in results:
+        misc_parts.append(f"g_t_norm:{results['g_t_norm']:.4e}")
+    
+    if 'hv_norm' in results:
+        misc_parts.append(f"hv_norm:{results['hv_norm']:.4e}")
+    if 'cos_v_hv' in results:
+        misc_parts.append(f"cos_v_hv:{results['cos_v_hv']:.4e}")
+    if 'hg_norm' in results:
+        misc_parts.append(f"hg_norm:{results['hg_norm']:.4e}")
+    if 'cos_g_hg' in results:
+        misc_parts.append(f"cos_g_hg:{results['cos_g_hg']:.4e}")
+    if 'v_parallel_norm' in results:
+        misc_parts.append(f"v_par:{results['v_parallel_norm']:.4e}")
+    if 'v_perp_norm' in results:
+        misc_parts.append(f"v_perp:{results['v_perp_norm']:.4e}")
+    if misc_parts:
+        log_parts.append(" ".join(misc_parts))
+
+    # Per-layer alignment metrics (cos_v_neg_g and v_norm per layer)
+    layer_cos = []
+    layer_num = 1
+    while True:
+        layer_key = f"layer_{layer_num}_cos_v_neg_g"
+        layer_vn_key = f"layer_{layer_num}_v_norm"
+        if layer_key in results:
+            layer_cos.append(f"L{layer_num}_cos_v_neg_g:{results[layer_key]:.4e}")
+        if layer_vn_key in results:
+            layer_cos.append(f"L{layer_num}_v_norm:{results[layer_vn_key]:.4e}")
+        if layer_key not in results and layer_vn_key not in results:
+            break
+        layer_num += 1
+    if layer_cos:
+        log_parts.append(" ".join(layer_cos))
+    
+    return " ".join(log_parts)
+
+# -----------------------------------------------------------------------------
+# int main
+
+def print0(*args, **kwargs):
+    # modified print that only prints from the master process
+    # if this is not a distributed run, it's just a print
+    if int(os.environ.get("RANK", 0)) == 0:
+        print(*args, **kwargs)
+
+if __name__ == "__main__":
+    import time
+    import argparse
+    import tiktoken
+    print0(f"Running pytorch {torch.version.__version__}")
+
+    # default settings will overfit a tiny batch of data
+    # and save model weights and debug state to disk on the first iteration
+    parser = argparse.ArgumentParser()
+    # file system input / output
+    parser.add_argument("--input_bin", type=str, default="dev/data/tinyshakespeare/tiny_shakespeare_val.bin", help="input .bin to train on")
+    parser.add_argument("--input_val_bin", type=str, default="", help="input .bin to eval validation loss on")
+    parser.add_argument("--output_dir", type=str, default="", help="output directory to which to write logs and checkpoints")
+    parser.add_argument("--model", type=str, default="gpt2", help="gpt2|gpt2-medium|gpt2-large|gpt2-xl|d8|d12|d24|d36|d48")
+    # token layout for each step of the optimization
+    parser.add_argument("--batch_size", type=int, default=4, help="batch size, in units of #batch dimensions")
+    parser.add_argument("--sequence_length", type=int, default=64, help="sequence length")
+    parser.add_argument("--total_batch_size", type=int, default=256, help="total desired batch size, in units of #tokens")
+    # workload (number of steps)
+    parser.add_argument("--num_iterations", type=int, default=10, help="number of iterations to run")
+    parser.add_argument("--inference_only", type=int, default=0, help="only run inference")
+    # optimization
+    parser.add_argument("--adam_lr", type=float, default=1e-4, help="learning rate warmup iterations")
+    parser.add_argument("--warmup_iters", type=int, default=0, help="learning rate warmup iterations")
+    parser.add_argument("--lr_decay_frac", type=float, default=1.0, help="learning rate warmup iterations")
+    parser.add_argument("--weight_decay", type=float, default=0.0, help="weight decay")
+    parser.add_argument("--grad_clip", type=float, default=1.0, help="maximum gradient magnitude")
+    # evaluation
+    parser.add_argument("--val_loss_every", type=int, default=0, help="every how mant steps to evaluate val loss?")
+    parser.add_argument("--val_max_steps", type=int, default=20, help="how many batches of val to average?")
+    parser.add_argument("--sample_every", type=int, default=0, help="how often to sample from the model?")
+    # debugging
+    parser.add_argument("--overfit_single_batch", type=int, default=0, help="overfit just one batch of data")
+    parser.add_argument("--shuffle_files", action="store_true")
+    # numerics
+    parser.add_argument("--tensorcores", type=int, default=0, help="use tensorcores")
+    # memory management
+    parser.add_argument("--device", type=str, default="", help="by default we autodetect, or set it here")
+    parser.add_argument("--compile", type=int, default=0, help="torch.compile the model")
+    parser.add_argument("--flash", type=int, default=0, help="use flash attention")
+    parser.add_argument("--dtype", type=str, default="float32", help="float32|float16|bfloat16")
+    parser.add_argument("--zero_stage", type=int, default=0, help="zero redundancy optimizer stage (0/1/2/3)")
+    # Muon optimizer specific arguments
+    parser.add_argument("--optimizer", type=str, default="adam", help="optimizer to use: adam|muon")
+    parser.add_argument("--muon_lr", type=float, default=0.02, help="learning rate for Muon optimizer")
+    parser.add_argument("--muon_momentum", type=float, default=0.95, help="momentum for Muon optimizer")
+    parser.add_argument("--muon_weight_decay", type=float, default=0.00, help="weight decay for Muon optimizer")
+    parser.add_argument("--muon_ns_steps", type=int, default=5, help="number of Newton-Schulz steps for Muon")
+    parser.add_argument("--muon_nesterov", type=bool, default=False, help="use Nesterov momentum for Muon (0/1)")
+    # python -> C bridge
+    parser.add_argument("--write_tensors", type=int, default=1, help="write tensors to disk")
+    parser.add_argument("--seed", type=int, default=42, help="random seed")
+    # Sharpness analysis arguments
+    parser.add_argument("--analyze_sharpness", action="store_true", help="Enable comprehensive sharpness analysis")
+    parser.add_argument("--sharpness_analysis_interval", type=int, default=500, help="Interval for sharpness analysis")
+    args = parser.parse_args()
+
+    # args error checking and convenience variables
+    B, T = args.batch_size, args.sequence_length
+    assert 1 <= T <= 1024
+    assert args.dtype in {"float32", "float16", "bfloat16"}
+    assert args.model in {"gpt2", "gpt2-medium", "gpt2-large", "gpt2-xl", "d8", "d12", "d24", "d36", "d48"}
+    assert args.optimizer in {"adam", "muon"}
+
+    set_seed(args.seed)
+
+    # set up DDP (distributed data parallel). torchrun sets this env variable
+    ddp = int(os.environ.get('RANK', -1)) != -1 # is this a ddp run?
+    if ddp:
+        # use of DDP atm demands CUDA, we set the device appropriately according to rank
+        assert torch.cuda.is_available(), "for now i think we need CUDA for DDP"
+        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)
+        master_process = ddp_rank == 0 # this process will do logging, checkpointing etc.
+        seed_offset = 0 # each process gets the exact same seed
+        zero_stage = args.zero_stage
+    else:
+        ddp_rank = 0
+        ddp_local_rank = 0
+        zero_stage = 0
+        ddp_world_size = 1
+        master_process = True
+        seed_offset = 0
+        # select the device
+        if args.device:
+            # provided explicitly by the user
+            device = args.device
+        else:
+            # attempt to autodetect the device
+            device = "cpu"
+            if torch.cuda.is_available():
+                device = "cuda"
+            elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
+                device = "mps"
+    print(f"using device: {device}")
+    device_type = 'cuda' if 'cuda' in device else 'cpu'
+
+    # Setup debugpy for remote debugging (only activates if DEBUGPY env var is set)
+    # setup_debugpy(rank=ddp_rank, force=True)
+
+    # calculate gradient accumulation from the desired total batch size and the current run configuration
+    tokens_per_fwdbwd = B * T * ddp_world_size
+    assert args.total_batch_size % tokens_per_fwdbwd == 0
+    grad_accum_steps = args.total_batch_size // tokens_per_fwdbwd
+    print0(f"total desired batch size: {args.total_batch_size}")
+    print0(f"=> calculated gradient accumulation steps: {grad_accum_steps}")
+
+    # set up a context manager following the desired dtype and device
+    ptdtype = {'float32': torch.float32, 'bfloat16': torch.bfloat16, 'float16': torch.float16}[args.dtype]
+    ctx = torch.amp.autocast(device_type=device_type, dtype=ptdtype) if device_type == "cuda" else nullcontext()
+
+    # rng / reproducibility
+    torch.manual_seed(42)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed(42)
+
+    # set the torch precision mode to use TensorFloat32 (TF32) for matmuls
+    # docs https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html
+    if args.tensorcores:
+        torch.set_float32_matmul_precision('high')
+
+    # turn on/off flash attention
+    assert args.flash in {0, 1}
+    nano_GPT_qkvonorm_pure.FLASH = args.flash  # Set module-level FLASH for training
+
+    # init (and write) the tokenizer
+    enc = tiktoken.get_encoding("gpt2")
+    if master_process and args.write_tensors: # tokenizer is technically not tensors but ok
+        write_tokenizer(enc, "gpt2_tokenizer.bin")
+
+    # init the model, either from scratch or from OpenAI pretrained checkpoint
+    if args.model[0] == "d":
+        # from scratch (random weights)
+        model_config = {
+            "d8":  GPTConfig(block_size=1024, vocab_size=50257, n_layer=8,  n_head=8,  n_embd=512),
+            "d12": GPTConfig(block_size=1024, vocab_size=50257, n_layer=12, n_head=12, n_embd=768),
+            "d24": GPTConfig(block_size=1024, vocab_size=50257, n_layer=24, n_head=16, n_embd=1024),
+            "d36": GPTConfig(block_size=1024, vocab_size=50257, n_layer=36, n_head=20, n_embd=1280),
+            "d48": GPTConfig(block_size=1024, vocab_size=50257, n_layer=48, n_head=25, n_embd=1600),
+        }[args.model]
+        model = GPT(model_config)
+    else:
+        # load the GPT-2 model weights
+        model = GPT.from_pretrained(args.model)
+    model.train()
+    model.to(device)
+    
+    # Save uncompiled model reference for sharpness analysis (needs double backward)
+    raw_model_uncompiled = model
+    
+    if args.compile:
+        if hasattr(config, "coordinate_descent_tuning"):
+            config.coordinate_descent_tuning = True # suggested by @Chillee
+        print0("compiling the model...")
+        model = torch.compile(model)
+
+    # -------------------------------------------------------------------------
+    # Our own version of a simple DistributedDataLoader
+
+    # load tokens
+    train_loader = DistributedDataLoader(
+        args.input_bin, B, T, ddp_rank, ddp_world_size,
+        shuffle_files=args.shuffle_files, random_seed=args.seed
+    )
+    val_loader = None
+    if args.input_val_bin:
+        val_loader = DistributedDataLoader(args.input_val_bin, B, T, ddp_rank, ddp_world_size)
+
+    # -------------------------------------------------------------------------
+    # PyTorch -> C bridge: save some weights and state for C to load later as reference
+
+    # do one forward pass to generate ground truth for our C tests
+    if master_process and args.write_tensors and (not args.inference_only):
+        x, y = train_loader.next_batch()
+        x, y = x.to(device), y.to(device)
+        logits, loss = model(x, y, return_logits=True)  # Need logits for write_state
+        loss.backward()
+        # save model params, in both float32 and bfloat16
+        model_to_size = {"gpt2": "124M", "gpt2-medium": "355M", "gpt2-large": "774M", "gpt2-xl": "1558M"}
+        model_to_size.update({f"d{d}": f"d{d}" for d in [12, 24, 36, 48]})
+        model_size_str = model_to_size[args.model] # e.g. "124M", or "d12"
+        write_model(model, f"gpt2_{model_size_str}.bin", dtype="float32")
+        write_model(model, f"gpt2_{model_size_str}_bf16.bin", dtype="bfloat16")
+        # save x, y, logits, loss, and parameter gradients, for debugging C
+        # always store these in fp32 to have an accurate reference (?)
+        write_state(model, x, y, logits, loss, f"gpt2_{model_size_str}_debug_state.bin")
+        # reset the train_loader for the optimization below
+        train_loader.reset()
+
+    # -------------------------------------------------------------------------
+    # main training loop
+
+    # here we wrap model into DDP container
+    if ddp:
+        model = DDP(model, device_ids=[ddp_local_rank])
+    raw_model = model.module if ddp else model # always contains the "raw" unwrapped model
+    
+    base_module = model.module if ddp else model
+    # If compiled, unwrap to get the original module
+    if hasattr(base_module, "_orig_mod"):
+        base_module = base_module._orig_mod
+    
+    raw_params = list(raw_model_uncompiled.parameters())
+    train_params = list(base_module.parameters())
+    
+    assert len(raw_params) == len(train_params), \
+        f"Parameter count mismatch: raw_model_uncompiled has {len(raw_params)}, training model has {len(train_params)}"
+    for i, (rp, tp) in enumerate(zip(raw_params, train_params)):
+        assert rp.data_ptr() == tp.data_ptr(), \
+            f"Parameter {i} has different data_ptr: raw_model_uncompiled and training model do not share parameters!"
+    print0(f"[Verified] raw_model_uncompiled and training model share the same {len(raw_params)} Parameter objects")
+    
+    last_training_update = None
+    last_training_gradient = None  # Store the original gradient that produced the update
+    last_training_batches = None  # Store ALL microbatches (x, y) for consistent HVP calculation
+
+
+    def configure_adam(model, weight_decay, learning_rate, betas, device_type, zero_stage):
+        # start with all of the candidate parameters
+        param_dict = {pn: p for pn, p in model.named_parameters()}
+        # filter out those that do not require grad
+        param_dict = {pn: p for pn, p in param_dict.items() if p.requires_grad}
+        # create optim groups. Any parameters that is 2D will be weight decayed, otherwise no.
+        # i.e. all weight tensors in matmuls + embeddings decay, all biases and layernorms don't.
+        decay_params = [p for n, p in param_dict.items() if p.dim() >= 2]
+        nodecay_params = [p for n, p in param_dict.items() if p.dim() < 2]
+        optim_groups = [
+            {'params': decay_params, 'weight_decay': weight_decay},
+            {'params': nodecay_params, 'weight_decay': 0.0}
+        ]
+        num_decay_params = sum(p.numel() for p in decay_params)
+        num_nodecay_params = sum(p.numel() for p in nodecay_params)
+        print0(f"num decayed parameter tensors: {len(decay_params)}, with {num_decay_params:,} parameters")
+        print0(f"num non-decayed parameter tensors: {len(nodecay_params)}, with {num_nodecay_params:,} parameters")
+        # Create AdamW optimizer and use the fused version if it is available
+        fused_available = 'fused' in inspect.signature(torch.optim.AdamW).parameters
+        use_fused = fused_available and device_type == 'cuda'
+        print0(f"using fused AdamW: {use_fused}")
+        if zero_stage == 1:
+            print0("using ZeroRedundancyOptimizer")
+            optimizer = ZeroRedundancyOptimizer(**optim_groups[0], optimizer_class=torch.optim.AdamW,
+                                                lr=learning_rate, betas=betas, fused=use_fused)
+            optimizer.add_param_group(optim_groups[1])
+        else:
+            print0("using regular AdamW")
+            optimizer = torch.optim.AdamW(optim_groups, lr=learning_rate, betas=betas, fused=use_fused)
+        return [optimizer]
+
+    def configure_muon(model, weight_decay, adam_lr, muon_lr, momentum, nesterov, ns_steps, device_type, zero_stage, ddp_rank, ddp_world_size):
+        # start with all of the candidate parameters
+        param_dict = {pn: p for pn, p in model.named_parameters()}
+        # filter out those that do not require grad
+        param_dict = {pn: p for pn, p in param_dict.items() if p.requires_grad}
+        
+        # For Muon, we need to separate 2D parameters (which can be orthogonalized) 
+        # from other parameters (which should use standard optimization)
+        muon_params = []  # 2D parameters for Muon
+        other_params = []  # other parameters for AdamW
+
+        muon_name = []
+        other_name = []
+        for n, p in param_dict.items():
+            if "wte.weight" in n :
+                other_params.append(p)
+                other_name.append(n)
+                continue
+
+            if p.dim() >= 2:  # 2D parameters (weight matrices)
+                muon_params.append(p)
+                muon_name.append(n)
+            else:  # 1D parameters (biases, embeddings, etc.)
+                other_params.append(p)
+                other_name.append(n)
+
+        # print("================================================\n")
+        # print(f"Muon parameters: {muon_name}\n")
+        # print(f"Other parameters: {other_name}\n")
+        # print("================================================\n")
+        
+        print0(f"Muon parameters (2D): {len(muon_params)} tensors")
+        print0(f"Other parameters (non-2D): {len(other_params)} tensors")
+        
+        # Create Muon optimizer for 2D parameters
+        muon_optimizer = None
+        if muon_params:
+            muon_optimizer = Muon(
+                params=muon_params,
+                lr=muon_lr,
+                weight_decay=weight_decay,
+                momentum=momentum,
+                nesterov=nesterov,
+                ns_steps=ns_steps,
+                rank=ddp_rank,
+                world_size=ddp_world_size
+            )
+        
+        # Create AdamW optimizer for non-2D parameters
+        adam_optimizer = None
+        if other_params:
+            # create optim groups for AdamW
+            # decay_params = [p for p in other_params if p.dim() >= 2]
+            # nodecay_params = [p for p in other_params if p.dim() < 2]
+            optim_groups = [
+                {'params': other_params, 'weight_decay': weight_decay},
+                # {'params': nodecay_params, 'weight_decay': 0.0}
+            ]
+            
+            # Create AdamW optimizer
+            fused_available = 'fused' in inspect.signature(torch.optim.AdamW).parameters
+            use_fused = fused_available and device_type == 'cuda'
+            print0(f"using fused AdamW for non-Muon params: {use_fused}")
+            
+            if zero_stage == 1:
+                print0("using ZeroRedundancyOptimizer for non-Muon params")
+                adam_optimizer = ZeroRedundancyOptimizer(**optim_groups[0], optimizer_class=torch.optim.AdamW,
+                                                        lr=adam_lr, betas=(0.9, 0.95), fused=use_fused)
+                # adam_optimizer.add_param_group(optim_groups[1])
+            else:
+                print0("using regular AdamW for non-Muon params")
+                adam_optimizer = torch.optim.AdamW(optim_groups, lr=adam_lr, betas=(0.9, 0.95), fused=use_fused)
+        
+        return [muon_optimizer, adam_optimizer]
+
+    # init the optimizer
+    if args.optimizer == "adam":
+        optimizers = configure_adam(model=raw_model_uncompiled, weight_decay=args.weight_decay,
+                                                   learning_rate=args.adam_lr, betas=(0.9, 0.95),
+                                                   device_type=device, zero_stage=zero_stage)
+    elif args.optimizer == "muon":
+        optimizers = configure_muon(
+            model=raw_model_uncompiled, 
+            weight_decay=args.muon_weight_decay,
+            muon_lr=args.muon_lr,
+            adam_lr=args.adam_lr,
+            momentum=args.muon_momentum,
+            nesterov=bool(args.muon_nesterov),
+            ns_steps=args.muon_ns_steps,
+            device_type=device,
+            zero_stage=zero_stage,
+            ddp_rank=ddp_rank,
+            ddp_world_size=ddp_world_size
+        )
+        # We'll use muon_optimizer and adam_optimizer separately
+
+    # learning rate decay scheduler (cosine with warmup)
+    def get_lr(it,base_lr):
+        # if args.optimizer == "adam":
+        #     base_lr = args.adam_lr
+        # else:  # muon
+        #     base_lr = args.muon_lr
+        min_lr = base_lr * args.lr_decay_frac
+        # 1) linear warmup for warmup_iters steps
+        if it < args.warmup_iters:
+            return base_lr * (it+1) / args.warmup_iters
+        # 2) if it > lr_decay_iters, return min learning rate
+        if it > args.num_iterations:
+            return min_lr
+        # 3) in between, use cosine decay down to min learning rate
+        decay_ratio = (it - args.warmup_iters) / (args.num_iterations - args.warmup_iters)
+        assert 0 <= decay_ratio <= 1
+        coeff = 0.5 * (1.0 + math.cos(math.pi * decay_ratio)) # coeff starts at 1 and goes to 0
+        return min_lr + coeff * (base_lr - min_lr)
+
+    def get_wsd_lr(it, base_lr):
+        min_lr = base_lr * args.lr_decay_frac
+        # cooldown_iters = int(args.num_iterations * 0.2)
+        cooldown_iters = int(0)
+        # 1) Warmup: linear warmup for warmup_iters steps
+        if it < args.warmup_iters:
+            return base_lr * (it + 1) / args.warmup_iters
+        # 3) Decay: linear decay from base_lr to min_lr in the last cooldown_iters steps
+        cooldown_start = args.num_iterations - cooldown_iters
+        if it >= cooldown_start:
+            decay_ratio = (it - cooldown_start) / cooldown_iters
+            return base_lr - decay_ratio * (base_lr - min_lr)
+        # 2) Stable: constant learning rate at base_lr
+        return base_lr
+
+    # create the logging directory if it does not exist
+    logfile = None
+    run_dir_path = None
+    
+    file_name  = f"mode_{args.optimizer}_adam_lr_{args.adam_lr}_muon_lr_{args.muon_lr}_seed_{args.seed}.log"
+    if args.output_dir:
+        base_log_dir = Path(args.output_dir)
+        base_log_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Create run-specific directory
+        # Generate UUID on master process and broadcast to all ranks
+        if master_process:
+            run_uuid = uuid.uuid4()
+            uuid_str = str(run_uuid)
+        else:
+            uuid_str = None
+        
+        # Broadcast UUID from rank 0 to all other ranks
+        if ddp:
+            # Create a tensor to hold the UUID string length and content
+            if master_process:
+                uuid_bytes = uuid_str.encode('utf-8')
+                uuid_len = len(uuid_bytes)
+            else:
+                uuid_len = 0
+            
+            # Broadcast length
+            uuid_len_tensor = torch.tensor(uuid_len, dtype=torch.long, device=device)
+            dist.broadcast(uuid_len_tensor, src=0)
+            
+            # Broadcast UUID string
+            if master_process:
+                uuid_tensor = torch.ByteTensor(list(uuid_bytes)).to(device)
+            else:
+                uuid_tensor = torch.ByteTensor([0] * uuid_len_tensor.item()).to(device)
+            dist.broadcast(uuid_tensor, src=0)
+            
+            # Decode on non-master processes
+            if not master_process:
+                uuid_str = bytes(uuid_tensor.cpu().numpy()).decode('utf-8')
+                run_uuid = uuid.UUID(uuid_str)
+            else:
+                run_uuid = uuid.UUID(uuid_str)
+        else:
+            run_uuid = uuid.uuid4()
+        
+        # run_folder_name = f"opt_{args.optimizer}_alr_{args.adam_lr}_mlr_{args.muon_lr}_seed_{args.seed}_{run_uuid}"
+        run_folder_name = f"opt_{args.optimizer}_alr_{args.adam_lr}_mlr_{args.muon_lr}_seed_{args.seed}"
+        run_dir_path = base_log_dir / run_folder_name
+        if run_dir_path.exists():
+            run_flag = False
+        else:
+            run_flag = True
+        torch.cuda.synchronize()
+        
+        
+        # Only master process creates the directory
+        if master_process:
+            run_dir_path.mkdir(parents=True, exist_ok=True)
+        
+        logfile = str(run_dir_path / "training_log.txt")
+        
+        # Save configuration
+    
+    if run_flag:
+        if master_process:
+            config_to_save = {
+                "cli_args": vars(args),
+                "run_uuid": 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)
+            print0(f"Saved configuration to: {config_file_path}")
+            
+        if master_process and logfile:
+            with open(logfile, "w") as f:
+                pass  # Create/clear the file
+            with open(logfile, "a") as f:
+                f.write(code)
+
+        if device == "cuda":
+            torch.cuda.reset_peak_memory_stats()
+        timings = []
+        norm = -1.0   # dummy value to print in inference-only mode
+        for step in range(args.num_iterations + 1):
+            t0 = time.time()
+            last_step = (step == args.num_iterations)
+
+            # once in a while evaluate the validation dataset
+            if (args.val_loss_every > 0 \
+                and (step % args.val_loss_every == 0 or last_step)) \
+                and (val_loader is not None):
+                model.eval()
+                val_loader.reset()
+                with torch.no_grad():
+                    val_loss = 0.0
+                    for _ in range(args.val_max_steps):
+                        x, y = val_loader.next_batch()
+                        x, y = x.to(device), y.to(device)
+                        _, loss = model(x, y, return_logits=False)
+                        val_loss += loss.item()
+                    val_loss /= args.val_max_steps
+                
+                # --- Comprehensive Sharpness Analysis ---
+                sharpness_log_str = ""
+                # Skip step 0 since we don't have a previous training update yet
+                if args.analyze_sharpness and step > 0 and (step % args.sharpness_analysis_interval == 0 or last_step):
+                    print0(f"[Sharpness @ Step {step}] Starting comprehensive sharpness analysis...")
+                    for optimizer in optimizers:
+                        if isinstance(optimizer, ZeroRedundancyOptimizer) or isinstance(optimizer, torch.optim.AdamW):
+                            optimizer.zero_grad(set_to_none=True)
+                        elif isinstance(optimizer, Muon):
+                            optimizer.zero_grad()
+                    comprehensive_results = calculate_comprehensive_sharpness(
+                        model=raw_model_uncompiled,  # Use uncompiled model for HVP (double backward)
+                        model_for_forward=model,     # Use compiled+DDP model for forward pass
+                        optimizers=optimizers,
+                        step=step,
+                        train_loader=train_loader,
+                        val_loader=val_loader,
+                        rank=ddp_rank,
+                        world_size=ddp_world_size,
+                        device=device,
+                        B=B,
+                        T=T,
+                        ptdtype=ptdtype,
+                        grad_accum_steps=grad_accum_steps,  # Pass grad accumulation steps to scale loss correctly
+                        last_training_update=last_training_update,  # Pass the real update captured from training
+                        last_training_gradient=last_training_gradient,  # Pass the original gradient g_t
+                        last_training_batches=last_training_batches  # Pass ALL microbatches for consistent HVP
+                    )
+                    sharpness_log_str = format_comprehensive_results(comprehensive_results)
+                    
+                    # Save sharpness results to file
+                    if master_process and run_dir_path:
+                        sharpness_file = run_dir_path / f"sharpness_step_{step}.json"
+                        with open(sharpness_file, "w") as f:
+                            json.dump(comprehensive_results, f, indent=4)
+                        print0(f"[Sharpness @ Step {step}] Results saved to {sharpness_file}")
+                    
+                    # Clean up memory after sharpness analysis
+                    del comprehensive_results
+                    # Ensure all CUDA operations are complete before cleaning up
+                    if device == "cuda":
+                        torch.cuda.synchronize()
+                    torch.cuda.empty_cache()
+                    gc.collect()
+                    if ddp:
+                        dist.barrier()  # Sync all ranks after cleanup
+                    print0(f"[Step {step}] Memory cleaned up after sharpness analysis")
+                
+                # log to console and to file
+                if sharpness_log_str:
+                    print0(f"step {step}/{args.num_iterations} | val loss {val_loss:.6f} | {sharpness_log_str}")
+                else:
+                    print0(f"step {step}/{args.num_iterations} | val loss {val_loss:.6f}")
+                
+                if master_process and logfile is not None:
+                    with open(logfile, "a") as f:
+                        f.write("step:%d validation loss:%f" % (step, val_loss))
+                        if sharpness_log_str:
+                            f.write(" %s" % sharpness_log_str)
+                        f.write("\n")
+
+            # once in a while perform model inference on the master process
+            if (args.sample_every > 0 \
+                and (step % args.sample_every == 0 or last_step)) \
+                and master_process:
+                model.eval()
+                # before we end, let's also do one round of inference
+                # we'll kick off the generation with "<|endoftext|>", which designates the start of a new sequence
+                start_ids = [enc.eot_token]
+                xg = (torch.tensor(start_ids, dtype=torch.long, device=device)[None, ...])
+                max_new_tokens = 32
+                temperature = 1.0
+                top_k = 40
+                yg = raw_model.generate(xg, max_new_tokens, temperature=temperature, top_k=top_k)
+                print0('---------------')
+                print0(enc.decode(yg[0].tolist()))
+                print0('---------------')
+
+            # bit confusing: we want to make sure to eval and sample 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()
+            # Zero gradients for the appropriate optimizer(s)
+
+            for optimizer in optimizers:
+                if isinstance(optimizer, ZeroRedundancyOptimizer) or isinstance(optimizer, torch.optim.AdamW):
+                    optimizer.zero_grad(set_to_none=True)
+                elif isinstance(optimizer, Muon):
+                    optimizer.zero_grad()
+            # if args.optimizer == "adam":
+            #     optimizer.zero_grad(set_to_none=True)
+            # else:  # muon
+            #     if muon_optimizer is not None:
+            #         muon_optimizer.zero_grad()
+            #     if adam_optimizer is not None:
+            #         adam_optimizer.zero_grad(set_to_none=True)
+            # if we are trying to overfit a single batch, we reset the loader here
+            if args.overfit_single_batch:
+                train_loader.reset()
+            # micro-batch loop where we do gradient accumulation to reach desired total batch size
+            lossf = 0.0 # for getting the mean loss (as simple float) over the accumulation steps
+            
+            # Pre-check if we need to collect microbatches for sharpness analysis
+            next_step = step + 1
+            will_analyze_sharpness_next = args.analyze_sharpness and next_step > 0 and (
+                (next_step % args.sharpness_analysis_interval == 0) or 
+                (next_step == args.num_iterations)
+            )
+            
+
+            microbatches_this_step = [] if will_analyze_sharpness_next else None
+            
+            for micro_step in range(grad_accum_steps):
+                # fetch a batch
+                x, y = train_loader.next_batch()
+                x, y = x.to(device), y.to(device)
+                
+                # Store ALL microbatches for memory-efficient HVP calculation
+                if will_analyze_sharpness_next:
+                    microbatches_this_step.append((x.detach().clone(), y.detach().clone()))
+                
+                if ddp:
+                    model.require_backward_grad_sync = (micro_step == grad_accum_steps - 1)
+                # forward pass
+                with ctx:
+                    _, loss = model(x, y, return_logits=False)
+                    loss = loss / grad_accum_steps
+                    lossf += loss.detach() # keep track of the mean loss
+                # backward pass
+                if not args.inference_only:
+                    loss.backward()
+            if ddp:
+                dist.all_reduce(lossf, op=dist.ReduceOp.AVG)
+            lossf = lossf.item()
+            
+            #no clipping
+            norm = torch.nn.utils.clip_grad_norm_(raw_model_uncompiled.parameters(), args.grad_clip)
+            
+            
+            if will_analyze_sharpness_next:
+                # Use raw_model_uncompiled's parameter order so it matches sharpness analysis codepaths.
+                # (DDP/torch.compile wrappers can be a footgun if parameter iteration order ever diverges.)
+                print(raw_model_uncompiled.transformer.h[0].attn.q_w.weight[:5,:5])
+                params_before_optimizer_step = [p.detach().clone() for p in raw_model_uncompiled.parameters()]
+                # Save the original gradient g_t that will produce the update v
+                last_training_gradient = [
+                    p.grad.detach().clone() if p.grad is not None else torch.zeros_like(p)
+                    for p in raw_model_uncompiled.parameters()
+                ]
+                # Capture ALL microbatches for consistent HVP calculation
+                # This ensures H is computed on the exact same objective as g_t and v
+                last_training_batches = microbatches_this_step  # Already cloned above
+            else:
+                params_before_optimizer_step = None
+                last_training_batches = None
+            
+            # Update learning rate and step optimizers
+            for optimizer in optimizers:
+                if isinstance(optimizer, ZeroRedundancyOptimizer) or isinstance(optimizer, torch.optim.AdamW):
+                    adam_lr = get_wsd_lr(step,args.adam_lr)
+                    for param_group in optimizer.param_groups:
+                        param_group['lr'] = adam_lr
+                    optimizer.step()
+                elif isinstance(optimizer, Muon):
+                    muon_lr = get_wsd_lr(step,args.muon_lr)
+                    for param_group in optimizer.param_groups:
+                        param_group['lr'] = muon_lr
+                    optimizer.step()
+                else:
+                    raise ValueError(f"Unsupported optimizer: {type(optimizer)}")
+            
+            
+            if params_before_optimizer_step is not None:
+                # Clean up old update to save memory
+                if last_training_update is not None:
+                    del last_training_update
+                
+                last_training_update = [
+                    p.detach() - p_before
+                    for p_before, p in zip(params_before_optimizer_step, raw_model_uncompiled.parameters())
+                ]
+                del params_before_optimizer_step
+            
+            # --------------- TRAINING SECTION END -------------------
+
+            # wait on the CPU for all device work to end so we get accurate per-iteration timings below
+            if device == "mps":
+                torch.mps.synchronize()
+            elif device == "cuda":
+                torch.cuda.synchronize()
+            # time and print
+            t1 = time.time()
+            # the 0th iteration is often an outlier (much slower) => skip logging it
+            tokens_per_second = grad_accum_steps * ddp_world_size * B * T / (t1-t0)
+            print0(f"step {step+1:4d}/{args.num_iterations} | train loss {lossf:.6f} | norm {norm:.4f} | ({(t1-t0)*1000:.2f} ms | {tokens_per_second:.0f} tok/s)")
+            # log to logile
+            if master_process and logfile is not None:
+                with open(logfile, "a") as f:
+                    f.write("step:%d train loss:%f\n" % (step, lossf))
+
+            # keep track of smooth timings, last 20 iterations
+            if step > 0 and step > args.num_iterations - 20:
+                timings.append(t1-t0)
+
+        # print the average of the last 20 timings, to get something smooth-ish
+        timings = timings[-20:]
+        print0(f"final {len(timings)} iters avg: {np.mean(timings)*1000:.3f}ms")
+        print0(f"peak memory consumption: {torch.cuda.max_memory_allocated() // 1024 // 1024} MiB")
+
+        # -------------------------------------------------------------------------
+        # clean up nice
+    if ddp:
+        destroy_process_group()step:0 validation loss:11.020914

logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm/opt_adam_alr_0.02_mlr_0.01_seed_42/config.json

@@ -0,0 +1,41 @@
+{
+    "cli_args": {
+        "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",
+        "output_dir": "/home/aiops/zhangfz/MUON_sharpness/logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm",
+        "model": "d12",
+        "batch_size": 4,
+        "sequence_length": 1024,
+        "total_batch_size": 524288,
+        "num_iterations": 10000,
+        "inference_only": 0,
+        "adam_lr": 0.02,
+        "warmup_iters": 1500,
+        "lr_decay_frac": 0.0,
+        "weight_decay": 0.0,
+        "grad_clip": 100000.0,
+        "val_loss_every": 250,
+        "val_max_steps": 20,
+        "sample_every": 0,
+        "overfit_single_batch": 0,
+        "shuffle_files": true,
+        "tensorcores": 1,
+        "device": "",
+        "compile": 1,
+        "flash": 1,
+        "dtype": "bfloat16",
+        "zero_stage": 1,
+        "optimizer": "adam",
+        "muon_lr": 0.01,
+        "muon_momentum": 0.95,
+        "muon_weight_decay": 0.0,
+        "muon_ns_steps": 5,
+        "muon_nesterov": false,
+        "write_tensors": 0,
+        "seed": 42,
+        "analyze_sharpness": false,
+        "sharpness_analysis_interval": 500
+    },
+    "run_uuid": "79e4918e-522c-4139-af5b-d80a5252170a",
+    "script_code_logged_at_start": true
+}

logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm/opt_adam_alr_0.02_mlr_0.01_seed_43/config.json

@@ -0,0 +1,41 @@
+{
+    "cli_args": {
+        "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",
+        "output_dir": "/home/aiops/zhangfz/MUON_sharpness/logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm",
+        "model": "d12",
+        "batch_size": 4,
+        "sequence_length": 1024,
+        "total_batch_size": 524288,
+        "num_iterations": 10000,
+        "inference_only": 0,
+        "adam_lr": 0.02,
+        "warmup_iters": 1500,
+        "lr_decay_frac": 0.0,
+        "weight_decay": 0.0,
+        "grad_clip": 100000.0,
+        "val_loss_every": 250,
+        "val_max_steps": 20,
+        "sample_every": 0,
+        "overfit_single_batch": 0,
+        "shuffle_files": true,
+        "tensorcores": 1,
+        "device": "",
+        "compile": 1,
+        "flash": 1,
+        "dtype": "bfloat16",
+        "zero_stage": 1,
+        "optimizer": "adam",
+        "muon_lr": 0.01,
+        "muon_momentum": 0.95,
+        "muon_weight_decay": 0.0,
+        "muon_ns_steps": 5,
+        "muon_nesterov": false,
+        "write_tensors": 0,
+        "seed": 43,
+        "analyze_sharpness": false,
+        "sharpness_analysis_interval": 500
+    },
+    "run_uuid": "72adc14c-d1ef-4cb4-893e-7d9a24a84f90",
+    "script_code_logged_at_start": true
+}

logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm/opt_adam_alr_0.02_mlr_0.01_seed_44/config.json

@@ -0,0 +1,41 @@
+{
+    "cli_args": {
+        "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",
+        "output_dir": "/home/aiops/zhangfz/MUON_sharpness/logs_sharpness_pure_qk_nonorm_no_clip_small_bsz/adam_lr_search_longwarm",
+        "model": "d12",
+        "batch_size": 4,
+        "sequence_length": 1024,
+        "total_batch_size": 524288,
+        "num_iterations": 10000,
+        "inference_only": 0,
+        "adam_lr": 0.02,
+        "warmup_iters": 1500,
+        "lr_decay_frac": 0.0,
+        "weight_decay": 0.0,
+        "grad_clip": 100000.0,
+        "val_loss_every": 250,
+        "val_max_steps": 20,
+        "sample_every": 0,
+        "overfit_single_batch": 0,
+        "shuffle_files": true,
+        "tensorcores": 1,
+        "device": "",
+        "compile": 1,
+        "flash": 1,
+        "dtype": "bfloat16",
+        "zero_stage": 1,
+        "optimizer": "adam",
+        "muon_lr": 0.01,
+        "muon_momentum": 0.95,
+        "muon_weight_decay": 0.0,
+        "muon_ns_steps": 5,
+        "muon_nesterov": false,
+        "write_tensors": 0,
+        "seed": 44,
+        "analyze_sharpness": false,
+        "sharpness_analysis_interval": 500
+    },
+    "run_uuid": "2b74613f-a927-4188-a403-f44fd7612f1e",
+    "script_code_logged_at_start": true
+}