update

logs_new_MUON_large_reshape/adam_lr_search/mode_5_param_qkvo_adam_lr_0.0001_seed_42/config.json

@@ -0,0 +1,27 @@
+{
+    "cli_args": {
+        "seed": 42,
+        "optimizer_mode": 5,
+        "model_parameterization": "qkvo",
+        "adam_lr": 0.0001,
+        "muon_lr": 0.05,
+        "base_dir": "logs_new_MUON_large_reshape/adam_lr_search"
+    },
+    "hyperparameters": {
+        "input_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "input_val_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "batch_size": 960,
+        "device_batch_size": 24,
+        "sequence_length": 1024,
+        "num_iterations": 6000,
+        "learning_rate": 0.0018,
+        "warmup_iters": 0,
+        "warmdown_iters": 0,
+        "weight_decay": 0,
+        "val_loss_every": 125,
+        "val_tokens": 10420224,
+        "save_every": 0
+    },
+    "run_uuid_for_log": "25bbd1f8-16e0-4420-8974-9d2327370772",
+    "script_code_logged_at_start": true
+}

logs_new_MUON_large_reshape/adam_lr_search/mode_5_param_qkvo_adam_lr_0.0002_seed_42/config.json

@@ -0,0 +1,27 @@
+{
+    "cli_args": {
+        "seed": 42,
+        "optimizer_mode": 5,
+        "model_parameterization": "qkvo",
+        "adam_lr": 0.0002,
+        "muon_lr": 0.05,
+        "base_dir": "logs_new_MUON_large_reshape/adam_lr_search"
+    },
+    "hyperparameters": {
+        "input_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "input_val_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "batch_size": 960,
+        "device_batch_size": 24,
+        "sequence_length": 1024,
+        "num_iterations": 6000,
+        "learning_rate": 0.0018,
+        "warmup_iters": 0,
+        "warmdown_iters": 0,
+        "weight_decay": 0,
+        "val_loss_every": 125,
+        "val_tokens": 10420224,
+        "save_every": 0
+    },
+    "run_uuid_for_log": "0d5098a3-838a-4da1-9c55-7cf124e00b3c",
+    "script_code_logged_at_start": true
+}

logs_new_MUON_large_reshape/adam_lr_search/mode_5_param_qkvo_adam_lr_0.0002_seed_43/config.json

@@ -0,0 +1,27 @@
+{
+    "cli_args": {
+        "seed": 43,
+        "optimizer_mode": 5,
+        "model_parameterization": "qkvo",
+        "adam_lr": 0.0002,
+        "muon_lr": 0.05,
+        "base_dir": "logs_new_MUON_large_reshape/adam_lr_search"
+    },
+    "hyperparameters": {
+        "input_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "input_val_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "batch_size": 960,
+        "device_batch_size": 24,
+        "sequence_length": 1024,
+        "num_iterations": 6000,
+        "learning_rate": 0.0018,
+        "warmup_iters": 0,
+        "warmdown_iters": 0,
+        "weight_decay": 0,
+        "val_loss_every": 125,
+        "val_tokens": 10420224,
+        "save_every": 0
+    },
+    "run_uuid_for_log": "54d1802f-5703-4c00-9c7a-31399abed1f8",
+    "script_code_logged_at_start": true
+}

logs_new_MUON_large_reshape/adam_lr_search/mode_5_param_qkvo_adam_lr_0.0002_seed_43/training_log_54d1802f-5703-4c00-9c7a-31399abed1f8.txt

@@ -0,0 +1,1398 @@
+import os
+import sys
+with open(sys.argv[0]) as f:
+    code = f.read() # read the code of this file ASAP, for logging
+import uuid
+import time
+import copy
+import glob
+from dataclasses import dataclass, asdict
+from functools import lru_cache
+from pathlib import Path
+import argparse # Keep argparse for --unet and potentially --optimizer_mode
+import json
+import random 
+import numpy as np 
+
+os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "expandable_segments:True"
+import torch
+torch.empty(1, device="cuda", requires_grad=True).backward() # prevents a bug on some systems
+from torch import Tensor, nn
+import torch.nn.functional as F
+import torch.distributed as dist
+# use of FlexAttention contributed by @KoszarskyB
+from torch.nn.attention.flex_attention import BlockMask, flex_attention
+sys.path.append("/home/aiops/zhangfz/MUON_theory/modded-nanogpt") # Already present
+from optimizers.MUON_new_large_nes import Muon
+from utils.float_compute import mm_op, backward as mm_backward_custom, setup_context as mm_setup_context_custom # Renamed
+import torch._inductor.config as config
+from torch.nn.parallel import DistributedDataParallel as DDP
+from kn_util.utils import setup_debugpy
+
+
+# -----------------------------------------------------------------------------
+# Seeding Function
+def set_seed(seed):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+    print(f"PRINT: Set seed to {seed}", flush=True) # Print immediately for all ranks
+
+
+# -----------------------------------------------------------------------------
+# Our own simple Distributed Data Loader
+
+def _peek_data_shard(filename):
+    # only reads the header, returns header data
+    with open(filename, "rb") as f:
+        # first read the header, which is 256 int32 integers (4 bytes each)
+        header = np.frombuffer(f.read(256*4), dtype=np.int32)
+    if header[0] != 20240520:
+        print("ERROR: magic number mismatch in the data .bin file!")
+        print("---> HINT: Are you passing in a correct file with --input_bin?")
+        print("---> HINT: Dataset encoding changed recently, re-run data prepro or refer again to README")
+        print("---> HINT: For example re-run: `python dev/data/tinyshakespeare.py`, then re-try")
+        exit(1)
+    assert header[1] == 1, "unsupported version"
+    ntok = header[2] # number of tokens (claimed)
+    return ntok # for now just return the number of tokens
+
+def _load_data_shard(filename):
+    with open(filename, "rb") as f:
+        # first read the header, which is 256 int32 integers (4 bytes each)
+        header = np.frombuffer(f.read(256*4), dtype=np.int32)
+        assert header[0] == 20240520, "magic number mismatch in the data .bin file"
+        assert header[1] == 1, "unsupported version"
+        ntok = header[2] # number of tokens (claimed)
+        # the rest of it are tokens, stored as uint16
+        tokens = np.frombuffer(f.read(), dtype=np.uint16)
+    assert len(tokens) == ntok, "number of tokens read does not match header?"
+    return tokens
+
+class DistributedDataLoader:
+    def __init__(self, filename_pattern, B, T, process_rank, num_processes):
+        self.process_rank = process_rank
+        self.num_processes = num_processes
+        self.B = B
+        self.T = T
+
+        # glob files that match the pattern
+        self.files = sorted(glob.glob(filename_pattern))
+        assert len(self.files) > 0, f"did not find any files that match the pattern {filename_pattern}"
+
+        # load and validate all data shards, count number of tokens in total
+        ntok_total = 0
+        for fname in self.files:
+            shard_ntok = _peek_data_shard(fname)
+            assert shard_ntok >= num_processes * B * T + 1
+            ntok_total += int(shard_ntok)
+        self.ntok_total = ntok_total
+
+        # kick things off
+        self.reset()
+
+    def reset(self):
+        self.current_shard = 0
+        self.current_position = self.process_rank * self.B * self.T
+        self.tokens = _load_data_shard(self.files[self.current_shard])
+
+    def advance(self): # advance to next data shard
+        self.current_shard = (self.current_shard + 1) % len(self.files)
+        self.current_position = self.process_rank * self.B * self.T
+        self.tokens = _load_data_shard(self.files[self.current_shard])
+
+    def next_batch(self):
+        B = self.B
+        T = self.T
+        buf = self.tokens[self.current_position : self.current_position+B*T+1]
+        buf = torch.tensor(buf.astype(np.int32), dtype=torch.long)
+        x = (buf[:-1]).view(B, T) # inputs
+        y = (buf[1:]).view(B, T) # targets
+        # advance current position and load next shard if necessary
+        self.current_position += B * T * self.num_processes
+        if self.current_position + (B * T * self.num_processes + 1) > len(self.tokens):
+            self.advance()
+        return x.cuda(), y.cuda()
+
+# -----------------------------------------------------------------------------
+# int main
+
+@dataclass
+class Hyperparameters:
+    # data hyperparams
+    input_bin : str = "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin"
+    input_val_bin : str = "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin"
+    # optimization hyperparams
+    batch_size : int = 8*120 # 8*120 # batch size, in sequences, across all devices
+    device_batch_size : int = 24 # batch size, in sequences, per device
+    sequence_length : int = 1024 # sequence length, in tokens
+    num_iterations : int = 6000 # number of iterations to run
+    learning_rate : float = 0.0036 / 2
+    warmup_iters : int = 0
+    warmdown_iters : int = 0 # number of iterations of linear warmup/warmdown for triangular or trapezoidal schedule
+    weight_decay : float = 0
+    # evaluation and logging hyperparams
+    val_loss_every : int = 125 # every how many steps to evaluate val loss? 0 for only at the end
+    val_tokens : int = 10420224 # 10420224 # how many tokens of validation data? it's important to keep this fixed for consistent comparisons
+    save_every : int = 0 # every how many steps to save the checkpoint? 0 for only at the end
+args = Hyperparameters()
+
+
+
+# -----------------------------------------------------------------------------
+# int main
+# setup_debugpy(force=True)
+parser = argparse.ArgumentParser(description="NanoGPT Training Script with Muon")
+parser.add_argument("--seed", type=int, default=42, help="Random seed for reproducibility")
+# --- MODIFICATION: Add optimizer_mode as a CLI argument ---
+parser.add_argument("--optimizer_mode", type=int, default=0,
+                    help="Defines how Muon is applied. "
+                         "0: Muon(All Hidden Attn+MLP - original); "
+                         "1: Muon(QK Attn)/Adam(VO Attn,MLP); "
+                         "2: Muon(VO Attn)/Adam(QK Attn,MLP); "
+                         "3: Muon(All Attn)/Adam(MLP); "
+                         "4: Muon(MLP)/Adam(All Attn)"
+                         "5: All Adam (No Muon, all applicable matrices to Adam)."
+                         "6: Muon(W_2 MLP)/Adam(attn, W_1 MLP)."
+                         "7: Muon(VO Attn, MLP)/Adam(QK Attn)."
+                         "8: Muon(VO Attn, W_2 MLP)/Adam(QK Attn, W_1 MLP)."
+                         )
+parser.add_argument("--model_parameterization", type=str, default="whole",choices=["whole","qkvo", "norope", "gated"])
+parser.add_argument("--adam_lr", type=float, default=0.008, help="Learning rate for Adam matrices")
+parser.add_argument("--muon_lr", type=float, default=0.05, help="Learning rate for Muon matrices")
+parser.add_argument("--base_dir", type=str, default="logs_new_MUON_large/test", help="Base directory for logs")
+exp_args = parser.parse_args()
+set_seed(exp_args.seed)
+
+
+
+# set up DDP (distributed data parallel). torchrun sets this env variable
+assert torch.cuda.is_available()
+dist.init_process_group(backend='nccl')
+ddp_rank = int(os.environ['RANK'])
+ddp_local_rank = int(os.environ['LOCAL_RANK'])
+ddp_world_size = int(os.environ['WORLD_SIZE'])
+device = f'cuda:{ddp_local_rank}'
+torch.cuda.set_device(device)
+print(f"using device: {device}")
+master_process = (ddp_rank == 0) # this process will do logging, checkpointing etc.
+
+logfile = None
+run_dir_path_str = None 
+base_log_dir = Path(exp_args.base_dir)
+
+
+if master_process:
+    import subprocess
+    set_seed(exp_args.seed)
+
+    # Construct folder name based on config and seed
+    run_folder_name = f"mode_{exp_args.optimizer_mode}_param_{exp_args.model_parameterization}_adam_lr_{exp_args.adam_lr}_seed_{exp_args.seed}"
+    # run_folder_name = f"mode_{exp_args.optimizer_mode}_param_{exp_args.model_parameterization}_muon_lr_{exp_args.muon_lr}_adam_lr_{exp_args.adam_lr}_seed_{exp_args.seed}"
+    run_dir_path = base_log_dir / run_folder_name
+    run_dir_path.mkdir(parents=True, exist_ok=True)
+    run_dir_path_str = str(run_dir_path)
+
+    run_uuid = uuid.uuid4() 
+    logfile = run_dir_path / f"training_log_{run_uuid}.txt" 
+    print(f"Logging to: {logfile}")
+
+    # Save configuration
+    config_to_save = {
+        "cli_args": vars(exp_args),
+        "hyperparameters": {k: v for k, v in args.__class__.__dict__.items() if not k.startswith('__') and not callable(v)}, 
+        "run_uuid_for_log": str(run_uuid),
+        "script_code_logged_at_start": True
+    }
+    config_file_path = run_dir_path / "config.json"
+    with open(config_file_path, "w") as f:
+        json.dump(config_to_save, f, indent=4)
+    print(f"Saved configuration to: {config_file_path}")
+
+# convenience variables
+B, T = args.device_batch_size, args.sequence_length
+# calculate the number of steps to take in the val loop.
+print(f"args.val_tokens: {args.val_tokens}, args.batch_size: {args.batch_size}, B: {B}, T: {T}, ddp_world_size: {ddp_world_size}")
+assert args.val_tokens % (B * T * ddp_world_size) == 0
+val_steps = args.val_tokens // (B * T * ddp_world_size)
+# calculate the steps of gradient accumulation required to attain the desired global batch size.
+assert args.batch_size % (B * ddp_world_size) == 0
+train_accumulation_steps = args.batch_size // (B * ddp_world_size)
+
+# load tokens
+train_loader = DistributedDataLoader(args.input_bin, B, T, ddp_rank, ddp_world_size)
+val_loader = DistributedDataLoader(args.input_val_bin, B, T, ddp_rank, ddp_world_size)
+if master_process:
+    print(f"Training DataLoader: total number of tokens: {train_loader.ntok_total} across {len(train_loader.files)} files")
+    print(f"Validation DataLoader: total number of tokens: {val_loader.ntok_total} across {len(val_loader.files)} files")
+x, y = train_loader.next_batch()
+
+# there are only 50257 unique GPT-2 tokens; we extend to nearest multiple of 128 for efficiency. suggested to me by @Grad62304977.
+# this originates from Karpathy's experiments.
+num_vocab = 50304
+
+
+if exp_args.model_parameterization == "qkvo":
+    from models.nano_GPT_qkvo_large import GPT, GPTConfig
+    # model = GPT(GPTConfig(vocab_size=num_vocab, n_layer=25, n_head=12, n_embd=1536))
+    model = GPT(GPTConfig(vocab_size=num_vocab, n_layer=36, n_head=20, n_embd=1280))
+elif exp_args.model_parameterization == "gated":
+    from models.nano_GPT_gated_large import GPT, GPTConfig
+    model = GPT(GPTConfig(vocab_size=num_vocab, n_layer=19, n_head=12, n_embd=1536))
+
+
+
+if master_process:
+    print(sum(p.numel() for p in model.parameters()))
+model = model.cuda()
+if hasattr(config, "coordinate_descent_tuning"):
+    config.coordinate_descent_tuning = True # suggested by @Chillee
+model = torch.compile(model)
+# here we wrap model into DDP container
+model = DDP(model, device_ids=[ddp_local_rank])
+raw_model = model.module # always contains the "raw" unwrapped model
+ctx = torch.amp.autocast(device_type='cuda', dtype=torch.bfloat16)
+
+# for name, param in raw_model.named_parameters():
+#     print(name, param.shape)
+
+if exp_args.model_parameterization == "qkvo" :
+    print("PRINT: Collecting parameters for optimizers...")
+    head_params = [raw_model.lm_head.weight]
+    # embed_params = [raw_model.transformer.wte.weight] 
+
+    # Granular collection for attention and MLP parts
+    attn_q_params = []
+    attn_k_params = []
+    attn_v_params = []
+    attn_o_params = [] # W_O from c_proj
+    mlp_fc_params = []
+    mlp_proj_params = []
+
+    for block_module in raw_model.transformer.h:
+        if block_module.attn is not None:
+            # These attributes (c_q, c_k, c_v) MUST exist in your CausalSelfAttention class
+            if hasattr(block_module.attn, 'c_q'): attn_q_params.append(block_module.attn.c_q.weight)
+            else:
+                print(f"PRINT: Warning: c_q not found in attn module of a block.")
+            if hasattr(block_module.attn, 'c_k'): attn_k_params.append(block_module.attn.c_k.weight)
+            else: print(f"PRINT: Warning: c_k not found in attn module of a block.")
+            if hasattr(block_module.attn, 'c_v'): attn_v_params.append(block_module.attn.c_v.weight)
+            else: print(f"PRINT: Warning: c_v not found in attn module of a block.")
+            attn_o_params.append(block_module.attn.c_proj.weight)
+        if block_module.mlp is not None:
+            mlp_fc_params.append(block_module.mlp.c_fc.weight)
+            mlp_proj_params.append(block_module.mlp.c_proj.weight)
+
+    # Combine into logical groups for experiments
+    attn_qk_group = attn_q_params + attn_k_params
+    attn_vo_group = attn_v_params + attn_o_params
+    all_attn_matrices = attn_qk_group + attn_vo_group
+    mlp_w1_group = mlp_fc_params
+    mlp_w2_group = mlp_proj_params
+    all_mlp_matrices = mlp_fc_params + mlp_proj_params
+
+    # Scalar parameters (all others not explicitly grouped as matrices)
+    # matrix_params_for_scalar_check = set(head_params + embed_params + all_attn_matrices + all_mlp_matrices)
+    matrix_params_for_scalar_check = set(head_params + all_attn_matrices + all_mlp_matrices)
+    scalar_params = [p for n, p in raw_model.named_parameters() if p not in matrix_params_for_scalar_check]
+    for p_scalar in scalar_params: # Sanity check
+        if p_scalar.ndim >=2:
+            print(f"PRINT: Warning - Parameter {p_scalar.shape} ended up in scalar_params but has ndim >= 2. Check grouping.")
+
+
+    # Determine parameter distribution based on optimizer_mode
+    muon_params_target_list = []
+    adam_matrix_target_list = [] # Matrices that Adam will handle specifically
+    adam_matrix_lr = exp_args.adam_lr  # LR for matrices if Adam handles them (can be tuned)
+
+    current_optimizer_mode = exp_args.optimizer_mode
+    
+    print(f"PRINT: Configuring optimizers for EXPERIMENT_MODE = {current_optimizer_mode}")
+
+    if current_optimizer_mode == 0: # Original behavior: Muon on all "hidden_matrix_params"
+        print(f"PRINT: Mode 0: Muon on ALL Attention (QKVO) and ALL MLP matrices.")
+        muon_params_target_list = all_attn_matrices + all_mlp_matrices
+        # Adam handles embeds, head, scalars by default. No extra matrices for Adam here.
+    elif current_optimizer_mode == 1: # Muon on QK, Adam on VO and MLP
+        print(f"PRINT: Mode 1: Muon on QK Attn. Adam on VO Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_qk_group
+        adam_matrix_target_list = attn_vo_group + all_mlp_matrices
+    elif current_optimizer_mode == 2: # Muon on VO, Adam on QK and MLP
+        print(f"PRINT: Mode 2: Muon on VO Attn. Adam on QK Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_vo_group
+        adam_matrix_target_list = attn_qk_group + all_mlp_matrices
+    elif current_optimizer_mode == 3: # Muon on All Attn (QKVO), Adam on MLP
+        print(f"PRINT: Mode 3: Muon on ALL Attn (QKVO). Adam on MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = all_attn_matrices
+        adam_matrix_target_list = all_mlp_matrices
+    elif current_optimizer_mode == 4: # Muon on MLP, Adam on All Attn (QKVO)
+        print(f"PRINT: Mode 4: Muon on MLP. Adam on ALL Attn (QKVO) (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = all_mlp_matrices
+        adam_matrix_target_list = all_attn_matrices
+    elif current_optimizer_mode == 5: # NEW MODE 5 - All Adam
+        print(f"PRINT: Mode 5: All Adam. All Attn and MLP matrices to Adam (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = [] 
+        adam_matrix_target_list = all_attn_matrices + all_mlp_matrices # All matrices to Adam
+    elif current_optimizer_mode == 6: # Muon on W_2 MLP, Adam on attn, W_1 MLP
+        print(f"PRINT: Mode 6: Muon on W_2 MLP. Adam on attn, W_1 MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = mlp_w2_group
+        adam_matrix_target_list = all_attn_matrices + mlp_w1_group
+    elif current_optimizer_mode == 7: # Muon on VO Attn, MLP, Adam on QK Attn
+        print(f"PRINT: Mode 7: Muon on VO Attn, MLP. Adam on QK Attn (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_vo_group + all_mlp_matrices
+        adam_matrix_target_list = attn_qk_group
+    elif current_optimizer_mode == 8: # Muon on VO Attn, W_2 MLP, Adam on QK Attn, W_1 MLP
+        print(f"PRINT: Mode 8: Muon on VO Attn, W_2 MLP. Adam on QK Attn, W_1 MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_vo_group + mlp_w2_group
+        adam_matrix_target_list = attn_qk_group + mlp_w1_group
+    elif current_optimizer_mode == 9: # Muon on V Attn, MLP
+        print(f"PRINT: Mode 9: Muon on V Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_v_params + all_mlp_matrices
+        adam_matrix_target_list = attn_o_params + attn_qk_group
+    elif current_optimizer_mode == 10: # Muon on O Attn, MLP
+        print(f"PRINT: Mode 10: Muon on O Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_o_params + all_mlp_matrices
+        adam_matrix_target_list = attn_v_params + attn_qk_group
+    elif current_optimizer_mode == 11: # Muon on W_1, Adam on O Attn, QK Attn
+        print(f"PRINT: Mode 11: Muon on W_1. Adam on O Attn, QK Attn (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = mlp_w1_group
+        adam_matrix_target_list = all_attn_matrices + mlp_w2_group
+    elif current_optimizer_mode == 12: # Muon on W_1, VO, Adam on others
+        print(f"PRINT: Mode 11: Muon on W_1. Adam on O Attn, QK Attn (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_vo_group + mlp_w1_group
+        adam_matrix_target_list = attn_qk_group + mlp_w2_group
+    elif current_optimizer_mode == 13:
+        print(f"PRINT: Mode 13: Muon on W_2, W_O. Adam on V Attn, QK Attn, W_1 (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_o_params + mlp_w2_group
+        adam_matrix_target_list = attn_qk_group + attn_v_params + mlp_w1_group 
+    elif current_optimizer_mode == 14:
+        print(f"PRINT: Mode 14: Muon on W_O. Adam on V Attn, QK Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_o_params
+        adam_matrix_target_list = attn_qk_group + attn_v_params +all_mlp_matrices
+    elif current_optimizer_mode == 15:
+        print(f"PRINT: Mode 15: Muon on W_V. Adam on O Attn, QK Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_v_params
+        adam_matrix_target_list = attn_qk_group + attn_o_params +all_mlp_matrices
+    else:
+        raise ValueError(f"Unsupported EXPERIMENT_MODE: {current_optimizer_mode}")
+
+    # Adam optimizer setup
+    adam_param_groups_config = [
+        dict(params=head_params, lr=adam_matrix_lr),
+        #dict(params=embed_params, lr=adam_matrix_lr),
+        dict(params=scalar_params, lr=adam_matrix_lr) # Scalar params always go to Adam
+    ]
+    # Add matrices specifically assigned to Adam for this experiment mode
+    if adam_matrix_target_list:
+        # Ensure adam_matrix_target_list is flat and contains Parameters
+        flat_adam_matrices = [p for sublist_or_p in adam_matrix_target_list for p in (sublist_or_p if isinstance(sublist_or_p, list) else [sublist_or_p]) if p is not None]
+        if flat_adam_matrices: # Only add group if there are params
+            adam_param_groups_config.append(dict(params=flat_adam_matrices, lr=adam_matrix_lr))
+
+    # Filter out any Adam groups that might be empty (e.g., if scalar_params was empty)
+    adam_param_groups_config = [g for g in adam_param_groups_config if g['params']]
+    print(f"PRINT: The length of Adam param groups config: {len(adam_param_groups_config)}")
+    optimizer1 = torch.optim.Adam(adam_param_groups_config, betas=(0.9, 0.95), eps=1e-10, fused=True)
+    optimizers = [optimizer1] # Start with Adam
+
+    # Muon optimizer setup
+    # if muon_params_target_list:
+    #     # Ensure muon_params_target_list is flat, unique, and contains Parameters
+    #     flat_unique_muon_params = []
+    #     seen_muon_ids = set()
+    #     for sublist_or_p in muon_params_target_list:
+    #         for p in (sublist_or_p if isinstance(sublist_or_p, list) else [sublist_or_p]):
+    #             if p is not None and id(p) not in seen_muon_ids:
+    #                 flat_unique_muon_params.append(p)
+    #                 seen_muon_ids.add(id(p))
+
+    #     muon_param_groups_config = []
+    #     if flat_unique_muon_params:
+    #         muon_param_groups_config.append(dict(params=flat_unique_muon_params, lr=exp_args.muon_lr))
+        
+    #     if flat_unique_muon_params: # Only create Muon if it has parameters
+    #         optimizer2 = Muon(muon_param_groups_config, lr=exp_args.muon_lr, momentum=0.95,rank=ddp_rank, world_size=ddp_world_size) # Pass nesterov, ns_steps
+    #         optimizers.append(optimizer2)
+    #     else:
+    #         print("PRINT: Muon optimizer not created as its target parameter list was empty.")
+    #         optimizer2 = None # Explicitly set to None if not created
+    # else:
+    #     print("PRINT: Muon optimizer not created as muon_params_target_list was empty (e.g. mode where Adam handles all matrices).")
+    #     optimizer2 = None # Explicitly set to None
+    # Muon optimizer setup
+    if muon_params_target_list:
+        # Ensure muon_params_target_list is flat, unique, and contains Parameters
+        flat_unique_muon_params = []
+        seen_muon_ids = set()
+        for sublist_or_p in muon_params_target_list:
+            for p in (sublist_or_p if isinstance(sublist_or_p, list) else [sublist_or_p]):
+                if p is not None and id(p) not in seen_muon_ids:
+                    flat_unique_muon_params.append(p)
+                    seen_muon_ids.add(id(p))
+        
+        if flat_unique_muon_params: # Only create Muon if it has parameters
+            optimizer2 = Muon(flat_unique_muon_params, lr=exp_args.muon_lr, momentum=0.95,rank=ddp_rank, world_size=ddp_world_size) # Pass nesterov, ns_steps
+            optimizers.append(optimizer2)
+        else:
+            print("PRINT: Muon optimizer not created as its target parameter list was empty.")
+            optimizer2 = None # Explicitly set to None if not created
+    else:
+        print("PRINT: Muon optimizer not created as muon_params_target_list was empty (e.g. mode where Adam handles all matrices).")
+        optimizer2 = None # Explicitly set to None
+
+    print(f"PRINT: Optimizers configured. Total optimizers: {len(optimizers)}")
+    if optimizer2:
+        print(f"PRINT: Muon optimizer is active with {len(flat_unique_muon_params)} parameters.")
+elif exp_args.model_parameterization == "gated":
+    print("PRINT: Collecting parameters for optimizers...")
+    head_params = [raw_model.lm_head.weight]
+    # embed_params = [raw_model.transformer.wte.weight] 
+
+    # Granular collection for attention and MLP parts
+    attn_q_params = []
+    attn_k_params = []
+    attn_v_params = []
+    attn_o_params = [] # W_O from c_proj
+    mlp_fc_params = []
+    mlp_proj_params = []
+    mlp_up_params = []
+
+    for block_module in raw_model.transformer.h:
+        if block_module.attn is not None:
+            # These attributes (c_q, c_k, c_v) MUST exist in your CausalSelfAttention class
+            if hasattr(block_module.attn, 'c_q'): attn_q_params.append(block_module.attn.c_q.weight)
+            else:
+                print(f"PRINT: Warning: c_q not found in attn module of a block.")
+            if hasattr(block_module.attn, 'c_k'): attn_k_params.append(block_module.attn.c_k.weight)
+            else: print(f"PRINT: Warning: c_k not found in attn module of a block.")
+            if hasattr(block_module.attn, 'c_v'): attn_v_params.append(block_module.attn.c_v.weight)
+            else: print(f"PRINT: Warning: c_v not found in attn module of a block.")
+            attn_o_params.append(block_module.attn.c_proj.weight)
+        if block_module.mlp is not None:
+            mlp_fc_params.append(block_module.mlp.c_fc.weight)
+            mlp_proj_params.append(block_module.mlp.c_proj.weight)
+            mlp_up_params.append(block_module.mlp.c_up.weight)
+
+    # Combine into logical groups for experiments
+    attn_qk_group = attn_q_params + attn_k_params
+    attn_vo_group = attn_v_params + attn_o_params
+    all_attn_matrices = attn_qk_group + attn_vo_group
+    mlp_w1_group = mlp_fc_params + mlp_up_params
+    mlp_w2_group = mlp_proj_params
+    all_mlp_matrices = mlp_fc_params + mlp_proj_params+ mlp_up_params
+
+    # Scalar parameters (all others not explicitly grouped as matrices)
+    # matrix_params_for_scalar_check = set(head_params + embed_params + all_attn_matrices + all_mlp_matrices)
+    matrix_params_for_scalar_check = set(head_params + all_attn_matrices + all_mlp_matrices)
+    scalar_params = [p for n, p in raw_model.named_parameters() if p not in matrix_params_for_scalar_check]
+    for p_scalar in scalar_params: # Sanity check
+        if p_scalar.ndim >=2:
+            print(f"PRINT: Warning - Parameter {p_scalar.shape} ended up in scalar_params but has ndim >= 2. Check grouping.")
+
+
+    # Determine parameter distribution based on optimizer_mode
+    muon_params_target_list = []
+    adam_matrix_target_list = [] # Matrices that Adam will handle specifically
+    adam_matrix_lr = exp_args.adam_lr  # LR for matrices if Adam handles them (can be tuned)
+
+    current_optimizer_mode = exp_args.optimizer_mode
+    
+    print(f"PRINT: Configuring optimizers for EXPERIMENT_MODE = {current_optimizer_mode}")
+
+    if current_optimizer_mode == 0: # Original behavior: Muon on all "hidden_matrix_params"
+        print(f"PRINT: Mode 0: Muon on ALL Attention (QKVO) and ALL MLP matrices.")
+        muon_params_target_list = all_attn_matrices + all_mlp_matrices
+        # Adam handles embeds, head, scalars by default. No extra matrices for Adam here.
+    elif current_optimizer_mode == 1: # Muon on QK, Adam on VO and MLP
+        print(f"PRINT: Mode 1: Muon on QK Attn. Adam on VO Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_qk_group
+        adam_matrix_target_list = attn_vo_group + all_mlp_matrices
+    elif current_optimizer_mode == 2: # Muon on VO, Adam on QK and MLP
+        print(f"PRINT: Mode 2: Muon on VO Attn. Adam on QK Attn, MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_vo_group
+        adam_matrix_target_list = attn_qk_group + all_mlp_matrices
+    elif current_optimizer_mode == 3: # Muon on All Attn (QKVO), Adam on MLP
+        print(f"PRINT: Mode 3: Muon on ALL Attn (QKVO). Adam on MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = all_attn_matrices
+        adam_matrix_target_list = all_mlp_matrices
+    elif current_optimizer_mode == 4: # Muon on MLP, Adam on All Attn (QKVO)
+        print(f"PRINT: Mode 4: Muon on MLP. Adam on ALL Attn (QKVO) (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = all_mlp_matrices
+        adam_matrix_target_list = all_attn_matrices
+    elif current_optimizer_mode == 5: # NEW MODE 5 - All Adam
+        print(f"PRINT: Mode 5: All Adam. All Attn and MLP matrices to Adam (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = [] 
+        adam_matrix_target_list = all_attn_matrices + all_mlp_matrices # All matrices to Adam
+    elif current_optimizer_mode == 6: # Muon on W_2 MLP, Adam on attn, W_1 MLP
+        print(f"PRINT: Mode 6: Muon on W_2 MLP. Adam on attn, W_1 MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = mlp_w2_group
+        adam_matrix_target_list = all_attn_matrices + mlp_w1_group
+    elif current_optimizer_mode == 7: # Muon on VO Attn, MLP, Adam on QK Attn
+        print(f"PRINT: Mode 7: Muon on VO Attn, MLP. Adam on QK Attn (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_vo_group + all_mlp_matrices
+        adam_matrix_target_list = attn_qk_group
+    elif current_optimizer_mode == 8: # Muon on VO Attn, W_2 MLP, Adam on QK Attn, W_1 MLP
+        print(f"PRINT: Mode 8: Muon on VO Attn, W_2 MLP. Adam on QK Attn, W_1 MLP (Adam LR: {adam_matrix_lr}).")
+        muon_params_target_list = attn_vo_group + mlp_w2_group
+        adam_matrix_target_list = attn_qk_group + mlp_w1_group
+    else:
+        raise ValueError(f"Unsupported EXPERIMENT_MODE: {current_optimizer_mode}")
+
+    # Adam optimizer setup
+    adam_param_groups_config = [
+        dict(params=head_params, lr=adam_matrix_lr),
+        # dict(params=embed_params, lr=adam_matrix_lr),
+        dict(params=scalar_params, lr=adam_matrix_lr) # Scalar params always go to Adam
+    ]
+    
+    # Add matrices specifically assigned to Adam for this experiment mode
+    if adam_matrix_target_list:
+        # Ensure adam_matrix_target_list is flat and contains Parameters
+        flat_adam_matrices = [p for sublist_or_p in adam_matrix_target_list for p in (sublist_or_p if isinstance(sublist_or_p, list) else [sublist_or_p]) if p is not None]
+        if flat_adam_matrices: # Only add group if there are params
+            adam_param_groups_config.append(dict(params=flat_adam_matrices, lr=adam_matrix_lr))
+
+    # Filter out any Adam groups that might be empty (e.g., if scalar_params was empty)
+    adam_param_groups_config = [g for g in adam_param_groups_config if g['params']]
+    # print(f"PRINT: The length of Adam param groups config: {len(adam_param_groups_config)}")
+    optimizer1 = torch.optim.Adam(adam_param_groups_config, betas=(0.9, 0.95), eps=1e-10, fused=True)
+    optimizers = [optimizer1] # Start with Adam
+
+    
+    if muon_params_target_list:
+        # Ensure muon_params_target_list is flat, unique, and contains Parameters
+        flat_unique_muon_params = []
+        seen_muon_ids = set()
+        for sublist_or_p in muon_params_target_list:
+            for p in (sublist_or_p if isinstance(sublist_or_p, list) else [sublist_or_p]):
+                if p is not None and id(p) not in seen_muon_ids:
+                    flat_unique_muon_params.append(p)
+                    seen_muon_ids.add(id(p))
+        
+        if flat_unique_muon_params: # Only create Muon if it has parameters
+            optimizer2 = Muon(flat_unique_muon_params, lr=exp_args.muon_lr, momentum=0.95,rank=ddp_rank, world_size=ddp_world_size) # Pass nesterov, ns_steps
+            optimizers.append(optimizer2)
+        else:
+            print("PRINT: Muon optimizer not created as its target parameter list was empty.")
+            optimizer2 = None # Explicitly set to None if not created
+    else:
+        print("PRINT: Muon optimizer not created as muon_params_target_list was empty (e.g. mode where Adam handles all matrices).")
+        optimizer2 = None # Explicitly set to None
+
+    print(f"PRINT: Optimizers configured. Total optimizers: {len(optimizers)}")
+    if optimizer2:
+        print(f"PRINT: Muon optimizer is active with {len(flat_unique_muon_params)} parameters.")
+    
+# optimizer1 = torch.optim.AdamW(raw_model.lm_head.parameters(), lr=args.learning_rate, betas=(0.9, 0.95),
+#                                weight_decay=args.weight_decay, fused=True)
+# optimizer2 = Muon(raw_model.transformer.h.parameters(), lr=0.1*args.learning_rate, momentum=0.95,
+#                   rank=ddp_rank, world_size=ddp_world_size)
+                  
+# optimizers = [optimizer1, optimizer2]
+# learning rate decay scheduler (linear warmup and warmdown)
+def get_lr(it):
+    assert it <= args.num_iterations
+    # 1) linear warmup for warmup_iters steps
+    if it < args.warmup_iters:
+        return (it+1) / args.warmup_iters
+    # 2) constant lr for a while
+    elif it < args.num_iterations - args.warmdown_iters:
+        return 1.0
+    # 3) linear warmdown
+    else:
+        decay_ratio = (args.num_iterations - it) / args.warmdown_iters
+        return decay_ratio
+schedulers = [torch.optim.lr_scheduler.LambdaLR(opt, get_lr) for opt in optimizers]
+
+if master_process:
+    with open(logfile, "a") as f:
+        f.write(code)
+
+training_time_ms = 0
+# start the clock
+torch.cuda.synchronize()
+t0 = time.time()
+# begin training
+train_loader.reset()
+for step in range(args.num_iterations + 1):
+    last_step = (step == args.num_iterations)
+    # This effectively ignores timing first 10 steps, which are slower for weird reasons.
+    # Alternately, and slightly more correctly in terms of benchmarking, we could do 10
+    # steps with dummy data first, and then re-initialize the model and reset the loader.
+    if step == 10:
+        training_time_ms = 0
+        t0 = time.time()
+    timed_steps = float('nan') if step <= 11 else (step - 10) + 1 # <= 11 to avoid bug in val
+
+    # once in a while evaluate the validation dataset
+    if (last_step or (args.val_loss_every > 0 and step % args.val_loss_every == 0)):
+        # stop the clock
+        torch.cuda.synchronize()
+        training_time_ms += 1000 * (time.time() - t0)
+        # run validation batches
+        with torch.no_grad():
+            val_loader.reset()
+            val_loss = 0.0
+            for _ in range(val_steps):
+                x_val, y_val = val_loader.next_batch()
+                with ctx: # of course, we'd like to use no_grad() here too, but that creates a torch.compile error for some reason
+                    _, loss = model(x_val, y_val, return_logits=False)
+                    val_loss += loss.detach()
+                    del loss
+            dist.all_reduce(val_loss, op=dist.ReduceOp.AVG)
+            val_loss /= val_steps
+            # log val loss to console and to logfile
+            if master_process:
+                print(f'step:{step}/{args.num_iterations} val_loss:{val_loss:.4f} train_time:{training_time_ms:.0f}ms step_avg:{training_time_ms/(timed_steps-1):.2f}ms')
+                with open(logfile, "a") as f:
+                    f.write(f'step:{step}/{args.num_iterations} val_loss:{val_loss:.4f} train_time:{training_time_ms:.0f}ms step_avg:{training_time_ms/(timed_steps-1):.2f}ms\n')
+            # start the clock again
+            torch.cuda.synchronize()
+        t0 = time.time()
+
+    if master_process and (last_step or (args.save_every > 0 and step % args.save_every == 0)):
+        # stop the clock
+        torch.cuda.synchronize()
+        training_time_ms += 1000 * (time.time() - t0)
+        # save the state of the training process
+        log = dict(step=step, code=code, model=raw_model.state_dict(), optimizers=[opt.state_dict() for opt in optimizers])
+        torch.save(log, 'logs/%s/state_step%06d.pt' % (run_id, step))
+        # start the clock again
+        torch.cuda.synchronize()
+        t0 = time.time()
+
+    # bit confusing: we want to make sure to eval on 0th iteration
+    # but also after the very last iteration. so we loop for step <= num_iterations
+    # instead of just < num_iterations (one extra due to <=), only to do
+    # the validation/sampling one last time, and then we break right here as we're done.
+    if last_step:
+        break
+
+    # --------------- TRAINING SECTION BEGIN -----------------
+    model.train()
+    for i in range(1, train_accumulation_steps+1):
+        # forward pass
+        with ctx:
+            _, loss = model(x, y, return_logits=False)
+            train_loss = loss.detach()
+        # advance the dataset for the next batch
+        x, y = train_loader.next_batch()
+        # backward pass
+        if i < train_accumulation_steps:
+            with model.no_sync(): # there's no need to sync gradients every accumulation step
+                loss.backward()
+        else:
+            loss.backward() # just sync on the last step
+    for p in model.parameters():
+        p.grad /= train_accumulation_steps
+    # step the optimizers and schedulers
+    for opt, sched in zip(optimizers, schedulers):
+        opt.step()
+        sched.step()
+    # null the gradients
+    model.zero_grad(set_to_none=True)
+    # --------------- TRAINING SECTION END -------------------
+    # everything that follows now is just diagnostics, prints, logging, etc.
+
+    #dist.all_reduce(train_loss, op=dist.ReduceOp.AVG) # all-reducing the training loss would be more correct in terms of logging, but slower
+    if master_process:
+        approx_time = training_time_ms + 1000 * (time.time() - t0)
+        print(f"step:{step+1}/{args.num_iterations} train_loss:{train_loss.item():.4f} train_time:{approx_time:.0f}ms step_avg:{approx_time/timed_steps:.2f}ms")
+        with open(logfile, "a") as f:
+            f.write(f"step:{step+1}/{args.num_iterations} train_loss:{train_loss.item():.4f} train_time:{approx_time:.0f}ms step_avg:{approx_time/timed_steps:.2f}ms\n")
+
+if master_process:
+    print(f"peak memory consumption: {torch.cuda.max_memory_allocated() // 1024 // 1024} MiB")step:0/6000 val_loss:20.6064 train_time:150ms step_avg:nanms
+step:1/6000 train_loss:20.6139 train_time:41365ms step_avg:nanms
+step:2/6000 train_loss:9.5932 train_time:44985ms step_avg:nanms
+step:3/6000 train_loss:9.4262 train_time:48551ms step_avg:nanms
+step:4/6000 train_loss:9.1741 train_time:52124ms step_avg:nanms
+step:5/6000 train_loss:8.8712 train_time:55697ms step_avg:nanms
+step:6/6000 train_loss:8.7882 train_time:59271ms step_avg:nanms
+step:7/6000 train_loss:8.3167 train_time:62844ms step_avg:nanms
+step:8/6000 train_loss:8.4007 train_time:66421ms step_avg:nanms
+step:9/6000 train_loss:8.1648 train_time:69996ms step_avg:nanms
+step:10/6000 train_loss:8.1921 train_time:73575ms step_avg:nanms
+step:11/6000 train_loss:8.0578 train_time:3418ms step_avg:nanms
+step:12/6000 train_loss:7.8729 train_time:7010ms step_avg:nanms
+step:13/6000 train_loss:8.1569 train_time:10599ms step_avg:3533.14ms
+step:14/6000 train_loss:7.7494 train_time:14186ms step_avg:3546.44ms
+step:15/6000 train_loss:7.7146 train_time:17770ms step_avg:3554.04ms
+step:16/6000 train_loss:7.7069 train_time:21355ms step_avg:3559.16ms
+step:17/6000 train_loss:7.4584 train_time:24940ms step_avg:3562.85ms
+step:18/6000 train_loss:7.7632 train_time:28528ms step_avg:3565.94ms
+step:19/6000 train_loss:7.6637 train_time:32117ms step_avg:3568.56ms
+step:20/6000 train_loss:7.4008 train_time:35709ms step_avg:3570.89ms
+step:21/6000 train_loss:7.6641 train_time:39304ms step_avg:3573.07ms
+step:22/6000 train_loss:7.8608 train_time:42902ms step_avg:3575.21ms
+step:23/6000 train_loss:7.8604 train_time:46505ms step_avg:3577.32ms
+step:24/6000 train_loss:7.5770 train_time:50111ms step_avg:3579.39ms
+step:25/6000 train_loss:7.7302 train_time:53720ms step_avg:3581.37ms
+step:26/6000 train_loss:7.3164 train_time:57331ms step_avg:3583.17ms
+step:27/6000 train_loss:7.3491 train_time:60941ms step_avg:3584.77ms
+step:28/6000 train_loss:7.2141 train_time:64553ms step_avg:3586.30ms
+step:29/6000 train_loss:7.7029 train_time:68168ms step_avg:3587.79ms
+step:30/6000 train_loss:7.4073 train_time:71782ms step_avg:3589.09ms
+step:31/6000 train_loss:7.5908 train_time:75396ms step_avg:3590.26ms
+step:32/6000 train_loss:7.5080 train_time:79011ms step_avg:3591.40ms
+step:33/6000 train_loss:7.4122 train_time:82624ms step_avg:3592.34ms
+step:34/6000 train_loss:9.4005 train_time:86237ms step_avg:3593.19ms
+step:35/6000 train_loss:7.4707 train_time:89853ms step_avg:3594.13ms
+step:36/6000 train_loss:7.5233 train_time:93466ms step_avg:3594.85ms
+step:37/6000 train_loss:7.8468 train_time:97081ms step_avg:3595.58ms
+step:38/6000 train_loss:7.2053 train_time:100696ms step_avg:3596.29ms
+step:39/6000 train_loss:7.4409 train_time:104313ms step_avg:3597.00ms
+step:40/6000 train_loss:7.3196 train_time:107931ms step_avg:3597.71ms
+step:41/6000 train_loss:8.3426 train_time:111548ms step_avg:3598.31ms
+step:42/6000 train_loss:7.2772 train_time:115169ms step_avg:3599.04ms
+step:43/6000 train_loss:7.1849 train_time:118788ms step_avg:3599.63ms
+step:44/6000 train_loss:7.2862 train_time:122406ms step_avg:3600.19ms
+step:45/6000 train_loss:7.9530 train_time:126027ms step_avg:3600.78ms
+step:46/6000 train_loss:7.1989 train_time:129648ms step_avg:3601.34ms
+step:47/6000 train_loss:7.0328 train_time:133269ms step_avg:3601.86ms
+step:48/6000 train_loss:7.1789 train_time:136890ms step_avg:3602.37ms
+step:49/6000 train_loss:6.9812 train_time:140511ms step_avg:3602.85ms
+step:50/6000 train_loss:7.1573 train_time:144136ms step_avg:3603.40ms
+step:51/6000 train_loss:7.1527 train_time:147759ms step_avg:3603.87ms
+step:52/6000 train_loss:7.0693 train_time:151379ms step_avg:3604.25ms
+step:53/6000 train_loss:6.8792 train_time:155002ms step_avg:3604.70ms
+step:54/6000 train_loss:7.1156 train_time:158623ms step_avg:3605.07ms
+step:55/6000 train_loss:7.0874 train_time:162243ms step_avg:3605.40ms
+step:56/6000 train_loss:7.1595 train_time:165868ms step_avg:3605.82ms
+step:57/6000 train_loss:6.7552 train_time:169493ms step_avg:3606.24ms
+step:58/6000 train_loss:7.0669 train_time:173122ms step_avg:3606.71ms
+step:59/6000 train_loss:6.8407 train_time:176751ms step_avg:3607.16ms
+step:60/6000 train_loss:6.9346 train_time:180377ms step_avg:3607.55ms
+step:61/6000 train_loss:6.9461 train_time:184000ms step_avg:3607.85ms
+step:62/6000 train_loss:7.1841 train_time:187653ms step_avg:3608.71ms
+step:63/6000 train_loss:7.0015 train_time:191280ms step_avg:3609.05ms
+step:64/6000 train_loss:6.8388 train_time:194905ms step_avg:3609.36ms
+step:65/6000 train_loss:7.0523 train_time:198534ms step_avg:3609.72ms
+step:66/6000 train_loss:7.1926 train_time:202164ms step_avg:3610.07ms
+step:67/6000 train_loss:6.8519 train_time:205792ms step_avg:3610.38ms
+step:68/6000 train_loss:7.0683 train_time:209421ms step_avg:3610.71ms
+step:69/6000 train_loss:6.9058 train_time:213049ms step_avg:3611.00ms
+step:70/6000 train_loss:6.9991 train_time:216682ms step_avg:3611.36ms
+step:71/6000 train_loss:6.7612 train_time:220313ms step_avg:3611.69ms
+step:72/6000 train_loss:6.5975 train_time:223946ms step_avg:3612.03ms
+step:73/6000 train_loss:7.1052 train_time:227579ms step_avg:3612.36ms
+step:74/6000 train_loss:6.7722 train_time:231210ms step_avg:3612.65ms
+step:75/6000 train_loss:6.6742 train_time:234840ms step_avg:3612.92ms
+step:76/6000 train_loss:7.0480 train_time:238470ms step_avg:3613.19ms
+step:77/6000 train_loss:6.8547 train_time:242107ms step_avg:3613.54ms
+step:78/6000 train_loss:6.8470 train_time:245737ms step_avg:3613.78ms
+step:79/6000 train_loss:6.7268 train_time:249371ms step_avg:3614.07ms
+step:80/6000 train_loss:7.1553 train_time:253006ms step_avg:3614.36ms
+step:81/6000 train_loss:6.3984 train_time:256636ms step_avg:3614.59ms
+step:82/6000 train_loss:6.8663 train_time:260266ms step_avg:3614.81ms
+step:83/6000 train_loss:6.7050 train_time:263897ms step_avg:3615.03ms
+step:84/6000 train_loss:6.7786 train_time:267531ms step_avg:3615.29ms
+step:85/6000 train_loss:6.6998 train_time:271165ms step_avg:3615.53ms
+step:86/6000 train_loss:6.6628 train_time:274797ms step_avg:3615.75ms
+step:87/6000 train_loss:6.8013 train_time:278429ms step_avg:3615.96ms
+step:88/6000 train_loss:6.7195 train_time:282065ms step_avg:3616.22ms
+step:89/6000 train_loss:6.6534 train_time:285698ms step_avg:3616.43ms
+step:90/6000 train_loss:6.3555 train_time:289332ms step_avg:3616.65ms
+step:91/6000 train_loss:6.5996 train_time:292964ms step_avg:3616.84ms
+step:92/6000 train_loss:6.7964 train_time:296597ms step_avg:3617.04ms
+step:93/6000 train_loss:6.3827 train_time:300231ms step_avg:3617.24ms
+step:94/6000 train_loss:6.5403 train_time:303867ms step_avg:3617.46ms
+step:95/6000 train_loss:6.6460 train_time:307502ms step_avg:3617.67ms
+step:96/6000 train_loss:6.6781 train_time:311137ms step_avg:3617.88ms
+step:97/6000 train_loss:6.5490 train_time:314772ms step_avg:3618.07ms
+step:98/6000 train_loss:6.5064 train_time:318408ms step_avg:3618.27ms
+step:99/6000 train_loss:6.5437 train_time:322042ms step_avg:3618.45ms
+step:100/6000 train_loss:6.6042 train_time:325677ms step_avg:3618.63ms
+step:101/6000 train_loss:6.6484 train_time:329309ms step_avg:3618.78ms
+step:102/6000 train_loss:6.4603 train_time:336008ms step_avg:3652.27ms
+step:103/6000 train_loss:6.3463 train_time:339634ms step_avg:3651.97ms
+step:104/6000 train_loss:6.6883 train_time:343258ms step_avg:3651.68ms
+step:105/6000 train_loss:6.6196 train_time:346886ms step_avg:3651.43ms
+step:106/6000 train_loss:6.5088 train_time:350511ms step_avg:3651.16ms
+step:107/6000 train_loss:6.0478 train_time:354138ms step_avg:3650.91ms
+step:108/6000 train_loss:6.9311 train_time:357768ms step_avg:3650.69ms
+step:109/6000 train_loss:6.4557 train_time:361401ms step_avg:3650.52ms
+step:110/6000 train_loss:6.4105 train_time:365033ms step_avg:3650.33ms
+step:111/6000 train_loss:6.5856 train_time:368708ms step_avg:3650.57ms
+step:112/6000 train_loss:6.5822 train_time:372343ms step_avg:3650.42ms
+step:113/6000 train_loss:6.4590 train_time:375977ms step_avg:3650.26ms
+step:114/6000 train_loss:6.2955 train_time:379609ms step_avg:3650.09ms
+step:115/6000 train_loss:6.5445 train_time:383246ms step_avg:3649.96ms
+step:116/6000 train_loss:6.3191 train_time:386879ms step_avg:3649.80ms
+step:117/6000 train_loss:6.4093 train_time:390513ms step_avg:3649.65ms
+step:118/6000 train_loss:6.3633 train_time:394146ms step_avg:3649.50ms
+step:119/6000 train_loss:6.6081 train_time:397782ms step_avg:3649.37ms
+step:120/6000 train_loss:6.4720 train_time:401421ms step_avg:3649.28ms
+step:121/6000 train_loss:6.1903 train_time:405056ms step_avg:3649.15ms
+step:122/6000 train_loss:6.3207 train_time:408690ms step_avg:3649.01ms
+step:123/6000 train_loss:6.3879 train_time:412324ms step_avg:3648.89ms
+step:124/6000 train_loss:6.4137 train_time:415959ms step_avg:3648.77ms
+step:125/6000 train_loss:6.1249 train_time:419590ms step_avg:3648.61ms
+step:125/6000 val_loss:6.3503 train_time:419759ms step_avg:3650.08ms
+step:126/6000 train_loss:6.3516 train_time:423202ms step_avg:3648.29ms
+step:127/6000 train_loss:6.3710 train_time:426824ms step_avg:3648.07ms
+step:128/6000 train_loss:6.1285 train_time:430451ms step_avg:3647.89ms
+step:129/6000 train_loss:7.3333 train_time:434082ms step_avg:3647.75ms
+step:130/6000 train_loss:6.3944 train_time:437713ms step_avg:3647.61ms
+step:131/6000 train_loss:6.2378 train_time:441347ms step_avg:3647.50ms
+step:132/6000 train_loss:6.2177 train_time:444987ms step_avg:3647.44ms
+step:133/6000 train_loss:6.4731 train_time:448625ms step_avg:3647.36ms
+step:134/6000 train_loss:6.2464 train_time:452263ms step_avg:3647.28ms
+step:135/6000 train_loss:6.1878 train_time:455899ms step_avg:3647.19ms
+step:136/6000 train_loss:6.1496 train_time:459539ms step_avg:3647.13ms
+step:137/6000 train_loss:6.6168 train_time:463175ms step_avg:3647.05ms
+step:138/6000 train_loss:6.0787 train_time:466814ms step_avg:3646.98ms
+step:139/6000 train_loss:6.2357 train_time:470450ms step_avg:3646.90ms
+step:140/6000 train_loss:6.3620 train_time:474086ms step_avg:3646.82ms
+step:141/6000 train_loss:6.3892 train_time:477721ms step_avg:3646.73ms
+step:142/6000 train_loss:6.1125 train_time:481357ms step_avg:3646.64ms
+step:143/6000 train_loss:6.4248 train_time:484992ms step_avg:3646.56ms
+step:144/6000 train_loss:5.9143 train_time:488625ms step_avg:3646.46ms
+step:145/6000 train_loss:6.2179 train_time:492259ms step_avg:3646.36ms
+step:146/6000 train_loss:7.0175 train_time:495892ms step_avg:3646.26ms
+step:147/6000 train_loss:6.1695 train_time:499525ms step_avg:3646.17ms
+step:148/6000 train_loss:6.1482 train_time:503160ms step_avg:3646.09ms
+step:149/6000 train_loss:6.2544 train_time:506793ms step_avg:3646.00ms
+step:150/6000 train_loss:5.9509 train_time:510426ms step_avg:3645.90ms
+step:151/6000 train_loss:5.9444 train_time:514058ms step_avg:3645.80ms
+step:152/6000 train_loss:6.3931 train_time:517691ms step_avg:3645.71ms
+step:153/6000 train_loss:6.1485 train_time:521324ms step_avg:3645.62ms
+step:154/6000 train_loss:6.1083 train_time:524955ms step_avg:3645.52ms
+step:155/6000 train_loss:6.1417 train_time:528589ms step_avg:3645.44ms
+step:156/6000 train_loss:6.2398 train_time:532221ms step_avg:3645.35ms
+step:157/6000 train_loss:5.9681 train_time:535855ms step_avg:3645.27ms
+step:158/6000 train_loss:6.1106 train_time:539492ms step_avg:3645.22ms
+step:159/6000 train_loss:5.9468 train_time:543125ms step_avg:3645.13ms
+step:160/6000 train_loss:5.8854 train_time:546760ms step_avg:3645.07ms
+step:161/6000 train_loss:6.0888 train_time:550392ms step_avg:3644.98ms
+step:162/6000 train_loss:6.3009 train_time:554027ms step_avg:3644.91ms
+step:163/6000 train_loss:6.0815 train_time:557659ms step_avg:3644.83ms
+step:164/6000 train_loss:6.1051 train_time:561295ms step_avg:3644.77ms
+step:165/6000 train_loss:6.0687 train_time:564932ms step_avg:3644.72ms
+step:166/6000 train_loss:6.1320 train_time:568569ms step_avg:3644.67ms
+step:167/6000 train_loss:5.8841 train_time:572202ms step_avg:3644.60ms
+step:168/6000 train_loss:6.2607 train_time:575835ms step_avg:3644.53ms
+step:169/6000 train_loss:6.1623 train_time:579472ms step_avg:3644.48ms
+step:170/6000 train_loss:6.0316 train_time:583107ms step_avg:3644.42ms
+step:171/6000 train_loss:6.1312 train_time:586746ms step_avg:3644.38ms
+step:172/6000 train_loss:6.0583 train_time:590511ms step_avg:3645.13ms
+step:173/6000 train_loss:6.4348 train_time:594604ms step_avg:3647.88ms
+step:174/6000 train_loss:5.9688 train_time:598563ms step_avg:3649.78ms
+step:175/6000 train_loss:6.1002 train_time:602392ms step_avg:3650.86ms
+step:176/6000 train_loss:6.1945 train_time:606298ms step_avg:3652.40ms
+step:177/6000 train_loss:5.9368 train_time:609928ms step_avg:3652.27ms
+step:178/6000 train_loss:6.0119 train_time:613561ms step_avg:3652.15ms
+step:179/6000 train_loss:5.9153 train_time:617193ms step_avg:3652.03ms
+step:180/6000 train_loss:7.6726 train_time:620823ms step_avg:3651.90ms
+step:181/6000 train_loss:6.2627 train_time:624450ms step_avg:3651.75ms
+step:182/6000 train_loss:6.1363 train_time:628079ms step_avg:3651.62ms
+step:183/6000 train_loss:6.3809 train_time:631711ms step_avg:3651.51ms
+step:184/6000 train_loss:6.0319 train_time:635341ms step_avg:3651.39ms
+step:185/6000 train_loss:5.8488 train_time:638971ms step_avg:3651.26ms
+step:186/6000 train_loss:6.1014 train_time:642602ms step_avg:3651.15ms
+step:187/6000 train_loss:5.7467 train_time:646230ms step_avg:3651.02ms
+step:188/6000 train_loss:5.7764 train_time:649859ms step_avg:3650.89ms
+step:189/6000 train_loss:6.0604 train_time:653488ms step_avg:3650.77ms
+step:190/6000 train_loss:6.0465 train_time:657117ms step_avg:3650.65ms
+step:191/6000 train_loss:6.0815 train_time:660747ms step_avg:3650.54ms
+step:192/6000 train_loss:5.9892 train_time:664377ms step_avg:3650.42ms
+step:193/6000 train_loss:5.9546 train_time:668005ms step_avg:3650.30ms
+step:194/6000 train_loss:5.8600 train_time:671634ms step_avg:3650.18ms
+step:195/6000 train_loss:5.7750 train_time:675259ms step_avg:3650.05ms
+step:196/6000 train_loss:6.1322 train_time:678887ms step_avg:3649.93ms
+step:197/6000 train_loss:6.0107 train_time:682513ms step_avg:3649.80ms
+step:198/6000 train_loss:6.0312 train_time:686141ms step_avg:3649.69ms
+step:199/6000 train_loss:5.9149 train_time:689772ms step_avg:3649.59ms
+step:200/6000 train_loss:5.9250 train_time:693402ms step_avg:3649.48ms
+step:201/6000 train_loss:6.6072 train_time:697029ms step_avg:3649.36ms
+step:202/6000 train_loss:5.6575 train_time:700659ms step_avg:3649.26ms
+step:203/6000 train_loss:5.8952 train_time:704289ms step_avg:3649.17ms
+step:204/6000 train_loss:5.9848 train_time:708493ms step_avg:3652.03ms
+step:205/6000 train_loss:5.8951 train_time:712126ms step_avg:3651.93ms
+step:206/6000 train_loss:6.0283 train_time:715761ms step_avg:3651.84ms
+step:207/6000 train_loss:6.0199 train_time:719393ms step_avg:3651.74ms
+step:208/6000 train_loss:5.8813 train_time:723026ms step_avg:3651.65ms
+step:209/6000 train_loss:5.7999 train_time:726660ms step_avg:3651.56ms
+step:210/6000 train_loss:5.7682 train_time:730295ms step_avg:3651.47ms
+step:211/6000 train_loss:5.8633 train_time:733930ms step_avg:3651.39ms
+step:212/6000 train_loss:5.7512 train_time:737564ms step_avg:3651.31ms
+step:213/6000 train_loss:6.0230 train_time:741198ms step_avg:3651.22ms
+step:214/6000 train_loss:5.8911 train_time:744830ms step_avg:3651.13ms
+step:215/6000 train_loss:5.7286 train_time:748464ms step_avg:3651.05ms
+step:216/6000 train_loss:5.7594 train_time:752099ms step_avg:3650.97ms
+step:217/6000 train_loss:5.9727 train_time:755734ms step_avg:3650.89ms
+step:218/6000 train_loss:5.7936 train_time:759367ms step_avg:3650.80ms
+step:219/6000 train_loss:5.7284 train_time:763002ms step_avg:3650.73ms
+step:220/6000 train_loss:5.8436 train_time:766638ms step_avg:3650.65ms
+step:221/6000 train_loss:5.7957 train_time:770271ms step_avg:3650.58ms
+step:222/6000 train_loss:5.7195 train_time:773908ms step_avg:3650.51ms
+step:223/6000 train_loss:5.7989 train_time:777546ms step_avg:3650.45ms
+step:224/6000 train_loss:5.6911 train_time:781181ms step_avg:3650.38ms
+step:225/6000 train_loss:5.7737 train_time:784814ms step_avg:3650.30ms
+step:226/6000 train_loss:5.6200 train_time:788448ms step_avg:3650.22ms
+step:227/6000 train_loss:5.8136 train_time:792084ms step_avg:3650.16ms
+step:228/6000 train_loss:5.7588 train_time:795721ms step_avg:3650.10ms
+step:229/6000 train_loss:5.5865 train_time:799353ms step_avg:3650.02ms
+step:230/6000 train_loss:5.5816 train_time:802984ms step_avg:3649.93ms
+step:231/6000 train_loss:5.6370 train_time:806619ms step_avg:3649.86ms
+step:232/6000 train_loss:5.9022 train_time:810252ms step_avg:3649.78ms
+step:233/6000 train_loss:5.6609 train_time:813887ms step_avg:3649.72ms
+step:234/6000 train_loss:5.7494 train_time:817523ms step_avg:3649.65ms
+step:235/6000 train_loss:5.7121 train_time:821158ms step_avg:3649.59ms
+step:236/6000 train_loss:5.8656 train_time:824790ms step_avg:3649.51ms
+step:237/6000 train_loss:5.8989 train_time:828425ms step_avg:3649.45ms
+step:238/6000 train_loss:5.4669 train_time:832059ms step_avg:3649.38ms
+step:239/6000 train_loss:5.8470 train_time:835692ms step_avg:3649.31ms
+step:240/6000 train_loss:5.6743 train_time:839328ms step_avg:3649.25ms
+step:241/6000 train_loss:5.7068 train_time:842960ms step_avg:3649.18ms
+step:242/6000 train_loss:5.4761 train_time:846593ms step_avg:3649.11ms
+step:243/6000 train_loss:5.5982 train_time:850225ms step_avg:3649.03ms
+step:244/6000 train_loss:5.5803 train_time:853857ms step_avg:3648.96ms
+step:245/6000 train_loss:5.6870 train_time:857489ms step_avg:3648.89ms
+step:246/6000 train_loss:5.6025 train_time:861123ms step_avg:3648.82ms
+step:247/6000 train_loss:5.3587 train_time:864757ms step_avg:3648.76ms
+step:248/6000 train_loss:5.5798 train_time:868386ms step_avg:3648.68ms
+step:249/6000 train_loss:5.6800 train_time:872018ms step_avg:3648.61ms
+step:250/6000 train_loss:5.5458 train_time:875648ms step_avg:3648.54ms
+step:250/6000 val_loss:5.6178 train_time:875817ms step_avg:3649.24ms
+step:251/6000 train_loss:5.5165 train_time:879271ms step_avg:3648.43ms
+step:252/6000 train_loss:5.3918 train_time:882901ms step_avg:3648.35ms
+step:253/6000 train_loss:5.8173 train_time:886535ms step_avg:3648.29ms
+step:254/6000 train_loss:5.5009 train_time:890167ms step_avg:3648.23ms
+step:255/6000 train_loss:5.5552 train_time:893801ms step_avg:3648.17ms
+step:256/6000 train_loss:5.5676 train_time:897437ms step_avg:3648.12ms
+step:257/6000 train_loss:5.5240 train_time:901071ms step_avg:3648.06ms
+step:258/6000 train_loss:5.4110 train_time:904707ms step_avg:3648.01ms
+step:259/6000 train_loss:5.6645 train_time:908343ms step_avg:3647.96ms
+step:260/6000 train_loss:5.5284 train_time:911981ms step_avg:3647.92ms
+step:261/6000 train_loss:5.6656 train_time:915616ms step_avg:3647.87ms
+step:262/6000 train_loss:5.6471 train_time:919253ms step_avg:3647.83ms
+step:263/6000 train_loss:5.6162 train_time:922891ms step_avg:3647.79ms
+step:264/6000 train_loss:5.3869 train_time:926530ms step_avg:3647.76ms
+step:265/6000 train_loss:5.4900 train_time:930168ms step_avg:3647.72ms
+step:266/6000 train_loss:5.6796 train_time:933808ms step_avg:3647.69ms
+step:267/6000 train_loss:5.7344 train_time:937447ms step_avg:3647.65ms
+step:268/6000 train_loss:7.0577 train_time:941084ms step_avg:3647.61ms
+step:269/6000 train_loss:5.4364 train_time:944719ms step_avg:3647.56ms
+step:270/6000 train_loss:5.5607 train_time:948356ms step_avg:3647.52ms
+step:271/6000 train_loss:5.5827 train_time:951989ms step_avg:3647.47ms
+step:272/6000 train_loss:5.5074 train_time:955626ms step_avg:3647.43ms
+step:273/6000 train_loss:5.7344 train_time:959261ms step_avg:3647.38ms
+step:274/6000 train_loss:5.6101 train_time:962895ms step_avg:3647.33ms
+step:275/6000 train_loss:5.4088 train_time:966528ms step_avg:3647.28ms
+step:276/6000 train_loss:5.5844 train_time:970162ms step_avg:3647.23ms
+step:277/6000 train_loss:5.2656 train_time:973799ms step_avg:3647.19ms
+step:278/6000 train_loss:5.4143 train_time:977437ms step_avg:3647.15ms
+step:279/6000 train_loss:5.5655 train_time:981075ms step_avg:3647.12ms
+step:280/6000 train_loss:5.5094 train_time:984714ms step_avg:3647.09ms
+step:281/6000 train_loss:5.6088 train_time:988349ms step_avg:3647.04ms
+step:282/6000 train_loss:5.3972 train_time:991985ms step_avg:3647.00ms
+step:283/6000 train_loss:5.4071 train_time:995623ms step_avg:3646.97ms
+step:284/6000 train_loss:5.2755 train_time:999261ms step_avg:3646.94ms
+step:285/6000 train_loss:5.4246 train_time:1002900ms step_avg:3646.91ms
+step:286/6000 train_loss:5.4583 train_time:1006538ms step_avg:3646.88ms
+step:287/6000 train_loss:5.4784 train_time:1010175ms step_avg:3646.84ms
+step:288/6000 train_loss:5.2774 train_time:1013813ms step_avg:3646.81ms
+step:289/6000 train_loss:5.3768 train_time:1017451ms step_avg:3646.78ms
+step:290/6000 train_loss:5.4798 train_time:1021090ms step_avg:3646.75ms
+step:291/6000 train_loss:5.5539 train_time:1024726ms step_avg:3646.71ms
+step:292/6000 train_loss:5.4353 train_time:1028360ms step_avg:3646.67ms
+step:293/6000 train_loss:5.6088 train_time:1031998ms step_avg:3646.64ms
+step:294/6000 train_loss:5.4513 train_time:1035638ms step_avg:3646.61ms
+step:295/6000 train_loss:5.7613 train_time:1039272ms step_avg:3646.57ms
+step:296/6000 train_loss:5.5382 train_time:1042908ms step_avg:3646.53ms
+step:297/6000 train_loss:5.6979 train_time:1046542ms step_avg:3646.49ms
+step:298/6000 train_loss:5.4610 train_time:1050179ms step_avg:3646.46ms
+step:299/6000 train_loss:5.7934 train_time:1053817ms step_avg:3646.43ms
+step:300/6000 train_loss:5.3698 train_time:1057457ms step_avg:3646.40ms
+step:301/6000 train_loss:5.3514 train_time:1061091ms step_avg:3646.36ms
+step:302/6000 train_loss:5.3965 train_time:1064729ms step_avg:3646.33ms
+step:303/6000 train_loss:5.2803 train_time:1068366ms step_avg:3646.30ms
+step:304/6000 train_loss:5.6529 train_time:1072003ms step_avg:3646.27ms
+step:305/6000 train_loss:5.1238 train_time:1078684ms step_avg:3656.56ms
+step:306/6000 train_loss:5.3095 train_time:1082311ms step_avg:3656.46ms
+step:307/6000 train_loss:5.2862 train_time:1085939ms step_avg:3656.36ms
+step:308/6000 train_loss:5.6199 train_time:1089570ms step_avg:3656.28ms
+step:309/6000 train_loss:5.3509 train_time:1093200ms step_avg:3656.19ms
+step:310/6000 train_loss:5.3536 train_time:1096834ms step_avg:3656.11ms
+step:311/6000 train_loss:5.2718 train_time:1100466ms step_avg:3656.03ms
+step:312/6000 train_loss:5.4072 train_time:1104094ms step_avg:3655.94ms
+step:313/6000 train_loss:5.4180 train_time:1107727ms step_avg:3655.86ms
+step:314/6000 train_loss:5.2266 train_time:1111361ms step_avg:3655.79ms
+step:315/6000 train_loss:5.1666 train_time:1114993ms step_avg:3655.72ms
+step:316/6000 train_loss:5.5031 train_time:1118625ms step_avg:3655.64ms
+step:317/6000 train_loss:5.4267 train_time:1122257ms step_avg:3655.56ms
+step:318/6000 train_loss:5.4147 train_time:1125887ms step_avg:3655.48ms
+step:319/6000 train_loss:5.2924 train_time:1129515ms step_avg:3655.39ms
+step:320/6000 train_loss:5.2803 train_time:1133149ms step_avg:3655.32ms
+step:321/6000 train_loss:5.2647 train_time:1136778ms step_avg:3655.23ms
+step:322/6000 train_loss:5.2246 train_time:1140408ms step_avg:3655.15ms
+step:323/6000 train_loss:5.4791 train_time:1144038ms step_avg:3655.07ms
+step:324/6000 train_loss:5.2629 train_time:1147668ms step_avg:3654.99ms
+step:325/6000 train_loss:5.3213 train_time:1151298ms step_avg:3654.91ms
+step:326/6000 train_loss:5.6975 train_time:1154927ms step_avg:3654.83ms
+step:327/6000 train_loss:5.3158 train_time:1158555ms step_avg:3654.75ms
+step:328/6000 train_loss:5.7257 train_time:1162186ms step_avg:3654.67ms
+step:329/6000 train_loss:5.1292 train_time:1165816ms step_avg:3654.59ms
+step:330/6000 train_loss:5.2763 train_time:1169447ms step_avg:3654.52ms
+step:331/6000 train_loss:5.4406 train_time:1173079ms step_avg:3654.45ms
+step:332/6000 train_loss:5.3636 train_time:1176711ms step_avg:3654.38ms
+step:333/6000 train_loss:5.2195 train_time:1180341ms step_avg:3654.31ms
+step:334/6000 train_loss:5.4190 train_time:1183971ms step_avg:3654.23ms
+step:335/6000 train_loss:5.0259 train_time:1187604ms step_avg:3654.17ms
+step:336/6000 train_loss:5.3140 train_time:1191234ms step_avg:3654.09ms
+step:337/6000 train_loss:5.4605 train_time:1194868ms step_avg:3654.03ms
+step:338/6000 train_loss:5.2046 train_time:1198499ms step_avg:3653.96ms
+step:339/6000 train_loss:5.0618 train_time:1202130ms step_avg:3653.89ms
+step:340/6000 train_loss:5.1788 train_time:1205760ms step_avg:3653.82ms
+step:341/6000 train_loss:5.4024 train_time:1209388ms step_avg:3653.74ms
+step:342/6000 train_loss:5.2952 train_time:1213018ms step_avg:3653.67ms
+step:343/6000 train_loss:5.6976 train_time:1216648ms step_avg:3653.60ms
+step:344/6000 train_loss:5.2602 train_time:1220278ms step_avg:3653.53ms
+step:345/6000 train_loss:5.1481 train_time:1223904ms step_avg:3653.45ms
+step:346/6000 train_loss:5.7334 train_time:1227533ms step_avg:3653.37ms
+step:347/6000 train_loss:5.3615 train_time:1231164ms step_avg:3653.31ms
+step:348/6000 train_loss:5.0662 train_time:1234797ms step_avg:3653.25ms
+step:349/6000 train_loss:5.2285 train_time:1238430ms step_avg:3653.19ms
+step:350/6000 train_loss:5.2518 train_time:1242062ms step_avg:3653.12ms
+step:351/6000 train_loss:5.1926 train_time:1245695ms step_avg:3653.06ms
+step:352/6000 train_loss:5.1052 train_time:1249327ms step_avg:3653.00ms
+step:353/6000 train_loss:5.1129 train_time:1252957ms step_avg:3652.94ms
+step:354/6000 train_loss:5.1330 train_time:1256589ms step_avg:3652.88ms
+step:355/6000 train_loss:5.1074 train_time:1260221ms step_avg:3652.82ms
+step:356/6000 train_loss:5.3666 train_time:1263856ms step_avg:3652.76ms
+step:357/6000 train_loss:5.0848 train_time:1267488ms step_avg:3652.70ms
+step:358/6000 train_loss:4.8210 train_time:1271121ms step_avg:3652.65ms
+step:359/6000 train_loss:5.6146 train_time:1274753ms step_avg:3652.59ms
+step:360/6000 train_loss:5.1904 train_time:1278387ms step_avg:3652.53ms
+step:361/6000 train_loss:5.0990 train_time:1282019ms step_avg:3652.47ms
+step:362/6000 train_loss:5.2032 train_time:1285650ms step_avg:3652.41ms
+step:363/6000 train_loss:5.1398 train_time:1289281ms step_avg:3652.36ms
+step:364/6000 train_loss:5.1299 train_time:1292912ms step_avg:3652.29ms
+step:365/6000 train_loss:5.2104 train_time:1296546ms step_avg:3652.24ms
+step:366/6000 train_loss:5.2871 train_time:1300178ms step_avg:3652.18ms
+step:367/6000 train_loss:5.0060 train_time:1303809ms step_avg:3652.13ms
+step:368/6000 train_loss:5.5723 train_time:1307441ms step_avg:3652.07ms
+step:369/6000 train_loss:5.1601 train_time:1311073ms step_avg:3652.02ms
+step:370/6000 train_loss:4.9992 train_time:1314707ms step_avg:3651.96ms
+step:371/6000 train_loss:5.0609 train_time:1318341ms step_avg:3651.92ms
+step:372/6000 train_loss:5.1341 train_time:1321975ms step_avg:3651.86ms
+step:373/6000 train_loss:5.0960 train_time:1325607ms step_avg:3651.81ms
+step:374/6000 train_loss:5.1838 train_time:1329238ms step_avg:3651.75ms
+step:375/6000 train_loss:5.0907 train_time:1332873ms step_avg:3651.71ms
+step:375/6000 val_loss:5.1201 train_time:1333040ms step_avg:3652.17ms
+step:376/6000 train_loss:5.0016 train_time:1336494ms step_avg:3651.62ms
+step:377/6000 train_loss:5.1430 train_time:1340121ms step_avg:3651.56ms
+step:378/6000 train_loss:4.9709 train_time:1343749ms step_avg:3651.49ms
+step:379/6000 train_loss:5.0950 train_time:1347379ms step_avg:3651.43ms
+step:380/6000 train_loss:4.8594 train_time:1351007ms step_avg:3651.37ms
+step:381/6000 train_loss:5.2141 train_time:1354630ms step_avg:3651.29ms
+step:382/6000 train_loss:5.2358 train_time:1358257ms step_avg:3651.23ms
+step:383/6000 train_loss:5.2249 train_time:1361883ms step_avg:3651.16ms
+step:384/6000 train_loss:5.2974 train_time:1365511ms step_avg:3651.10ms
+step:385/6000 train_loss:5.1060 train_time:1369139ms step_avg:3651.04ms
+step:386/6000 train_loss:5.0367 train_time:1372768ms step_avg:3650.98ms
+step:387/6000 train_loss:5.1220 train_time:1376393ms step_avg:3650.91ms
+step:388/6000 train_loss:5.3479 train_time:1380023ms step_avg:3650.85ms
+step:389/6000 train_loss:5.0079 train_time:1383652ms step_avg:3650.80ms
+step:390/6000 train_loss:5.3030 train_time:1387280ms step_avg:3650.74ms
+step:391/6000 train_loss:5.3397 train_time:1390905ms step_avg:3650.67ms
+step:392/6000 train_loss:5.1100 train_time:1394530ms step_avg:3650.60ms
+step:393/6000 train_loss:5.1160 train_time:1398156ms step_avg:3650.54ms
+step:394/6000 train_loss:5.1212 train_time:1401784ms step_avg:3650.48ms
+step:395/6000 train_loss:5.1876 train_time:1405411ms step_avg:3650.42ms
+step:396/6000 train_loss:5.1296 train_time:1409037ms step_avg:3650.36ms
+step:397/6000 train_loss:5.7646 train_time:1412664ms step_avg:3650.29ms
+step:398/6000 train_loss:5.0229 train_time:1416291ms step_avg:3650.23ms
+step:399/6000 train_loss:4.9349 train_time:1419919ms step_avg:3650.18ms
+step:400/6000 train_loss:5.1571 train_time:1423549ms step_avg:3650.12ms
+step:401/6000 train_loss:5.0514 train_time:1427174ms step_avg:3650.06ms
+step:402/6000 train_loss:5.1039 train_time:1430799ms step_avg:3650.00ms
+step:403/6000 train_loss:5.5100 train_time:1434429ms step_avg:3649.95ms
+step:404/6000 train_loss:4.9590 train_time:1438055ms step_avg:3649.88ms
+step:405/6000 train_loss:5.2261 train_time:1441681ms step_avg:3649.83ms
+step:406/6000 train_loss:4.9467 train_time:1445307ms step_avg:3649.76ms
+step:407/6000 train_loss:5.0047 train_time:1452009ms step_avg:3657.45ms
+step:408/6000 train_loss:5.1258 train_time:1455630ms step_avg:3657.36ms
+step:409/6000 train_loss:5.2743 train_time:1459252ms step_avg:3657.27ms
+step:410/6000 train_loss:4.9895 train_time:1462876ms step_avg:3657.19ms
+step:411/6000 train_loss:4.9393 train_time:1466498ms step_avg:3657.10ms
+step:412/6000 train_loss:5.2676 train_time:1470123ms step_avg:3657.02ms
+step:413/6000 train_loss:4.9466 train_time:1473749ms step_avg:3656.95ms
+step:414/6000 train_loss:5.0864 train_time:1477375ms step_avg:3656.87ms
+step:415/6000 train_loss:4.8074 train_time:1481002ms step_avg:3656.80ms
+step:416/6000 train_loss:5.1143 train_time:1484629ms step_avg:3656.72ms
+step:417/6000 train_loss:5.0373 train_time:1488261ms step_avg:3656.66ms
+step:418/6000 train_loss:4.9261 train_time:1491890ms step_avg:3656.59ms
+step:419/6000 train_loss:4.8459 train_time:1495522ms step_avg:3656.53ms
+step:420/6000 train_loss:4.4611 train_time:1499151ms step_avg:3656.47ms
+step:421/6000 train_loss:5.0802 train_time:1502779ms step_avg:3656.40ms
+step:422/6000 train_loss:4.9679 train_time:1506410ms step_avg:3656.33ms
+step:423/6000 train_loss:4.8546 train_time:1510039ms step_avg:3656.27ms
+step:424/6000 train_loss:4.9717 train_time:1513668ms step_avg:3656.20ms
+step:425/6000 train_loss:4.8077 train_time:1517296ms step_avg:3656.13ms
+step:426/6000 train_loss:4.9959 train_time:1520923ms step_avg:3656.06ms
+step:427/6000 train_loss:5.0800 train_time:1524552ms step_avg:3656.00ms
+step:428/6000 train_loss:5.0019 train_time:1528182ms step_avg:3655.94ms
+step:429/6000 train_loss:5.0183 train_time:1531809ms step_avg:3655.87ms
+step:430/6000 train_loss:4.0808 train_time:1535437ms step_avg:3655.80ms
+step:431/6000 train_loss:4.8463 train_time:1539064ms step_avg:3655.73ms
+step:432/6000 train_loss:4.8161 train_time:1542694ms step_avg:3655.67ms
+step:433/6000 train_loss:5.0160 train_time:1546320ms step_avg:3655.60ms
+step:434/6000 train_loss:5.0845 train_time:1549950ms step_avg:3655.54ms
+step:435/6000 train_loss:4.9424 train_time:1553577ms step_avg:3655.47ms
+step:436/6000 train_loss:5.0838 train_time:1557205ms step_avg:3655.41ms
+step:437/6000 train_loss:5.2553 train_time:1560834ms step_avg:3655.35ms
+step:438/6000 train_loss:5.0068 train_time:1564461ms step_avg:3655.28ms
+step:439/6000 train_loss:5.0367 train_time:1568091ms step_avg:3655.22ms
+step:440/6000 train_loss:4.9741 train_time:1571720ms step_avg:3655.16ms
+step:441/6000 train_loss:4.9165 train_time:1575351ms step_avg:3655.11ms
+step:442/6000 train_loss:5.3550 train_time:1578982ms step_avg:3655.05ms
+step:443/6000 train_loss:5.0345 train_time:1582611ms step_avg:3654.99ms
+step:444/6000 train_loss:4.9482 train_time:1586241ms step_avg:3654.93ms
+step:445/6000 train_loss:4.8915 train_time:1589872ms step_avg:3654.88ms
+step:446/6000 train_loss:4.9744 train_time:1593501ms step_avg:3654.82ms
+step:447/6000 train_loss:4.8587 train_time:1597130ms step_avg:3654.76ms
+step:448/6000 train_loss:4.9324 train_time:1600761ms step_avg:3654.71ms
+step:449/6000 train_loss:4.6643 train_time:1604391ms step_avg:3654.65ms
+step:450/6000 train_loss:4.9564 train_time:1608023ms step_avg:3654.60ms
+step:451/6000 train_loss:4.8272 train_time:1611652ms step_avg:3654.54ms
+step:452/6000 train_loss:4.9246 train_time:1615282ms step_avg:3654.48ms
+step:453/6000 train_loss:4.9574 train_time:1618909ms step_avg:3654.42ms
+step:454/6000 train_loss:4.7653 train_time:1622538ms step_avg:3654.36ms
+step:455/6000 train_loss:4.7497 train_time:1626165ms step_avg:3654.30ms
+step:456/6000 train_loss:4.7461 train_time:1629793ms step_avg:3654.25ms
+step:457/6000 train_loss:4.8511 train_time:1633421ms step_avg:3654.19ms
+step:458/6000 train_loss:5.0393 train_time:1637047ms step_avg:3654.12ms
+step:459/6000 train_loss:4.8129 train_time:1640676ms step_avg:3654.07ms
+step:460/6000 train_loss:5.0411 train_time:1644306ms step_avg:3654.01ms
+step:461/6000 train_loss:4.8110 train_time:1647936ms step_avg:3653.96ms
+step:462/6000 train_loss:5.0897 train_time:1651565ms step_avg:3653.90ms
+step:463/6000 train_loss:4.8307 train_time:1655194ms step_avg:3653.85ms
+step:464/6000 train_loss:4.8614 train_time:1658820ms step_avg:3653.79ms
+step:465/6000 train_loss:4.6934 train_time:1662449ms step_avg:3653.73ms
+step:466/6000 train_loss:5.0124 train_time:1666079ms step_avg:3653.68ms
+step:467/6000 train_loss:4.8417 train_time:1669707ms step_avg:3653.63ms
+step:468/6000 train_loss:4.9535 train_time:1673335ms step_avg:3653.57ms
+step:469/6000 train_loss:4.7321 train_time:1676963ms step_avg:3653.52ms
+step:470/6000 train_loss:5.0075 train_time:1680591ms step_avg:3653.46ms
+step:471/6000 train_loss:4.8125 train_time:1684219ms step_avg:3653.40ms
+step:472/6000 train_loss:4.7184 train_time:1687847ms step_avg:3653.35ms
+step:473/6000 train_loss:5.0503 train_time:1691474ms step_avg:3653.29ms
+step:474/6000 train_loss:5.7232 train_time:1695101ms step_avg:3653.23ms
+step:475/6000 train_loss:4.8569 train_time:1698731ms step_avg:3653.18ms
+step:476/6000 train_loss:4.7851 train_time:1702361ms step_avg:3653.14ms
+step:477/6000 train_loss:4.7731 train_time:1705990ms step_avg:3653.08ms
+step:478/6000 train_loss:4.2941 train_time:1709615ms step_avg:3653.02ms
+step:479/6000 train_loss:4.5978 train_time:1713245ms step_avg:3652.97ms
+step:480/6000 train_loss:4.7632 train_time:1716874ms step_avg:3652.92ms
+step:481/6000 train_loss:4.7322 train_time:1720501ms step_avg:3652.87ms
+step:482/6000 train_loss:4.7214 train_time:1724132ms step_avg:3652.82ms
+step:483/6000 train_loss:5.0827 train_time:1727760ms step_avg:3652.77ms
+step:484/6000 train_loss:4.8032 train_time:1731389ms step_avg:3652.72ms
+step:485/6000 train_loss:4.7942 train_time:1735019ms step_avg:3652.67ms
+step:486/6000 train_loss:5.1739 train_time:1738648ms step_avg:3652.62ms
+step:487/6000 train_loss:4.6447 train_time:1742277ms step_avg:3652.57ms
+step:488/6000 train_loss:4.8322 train_time:1745908ms step_avg:3652.53ms
+step:489/6000 train_loss:4.6539 train_time:1749537ms step_avg:3652.48ms
+step:490/6000 train_loss:4.8344 train_time:1753167ms step_avg:3652.43ms
+step:491/6000 train_loss:4.9443 train_time:1756841ms step_avg:3652.48ms
+step:492/6000 train_loss:4.6566 train_time:1760471ms step_avg:3652.43ms
+step:493/6000 train_loss:4.5952 train_time:1764101ms step_avg:3652.38ms
+step:494/6000 train_loss:4.6912 train_time:1767730ms step_avg:3652.33ms
+step:495/6000 train_loss:4.5607 train_time:1771360ms step_avg:3652.29ms
+step:496/6000 train_loss:4.9199 train_time:1774990ms step_avg:3652.24ms
+step:497/6000 train_loss:5.0203 train_time:1778619ms step_avg:3652.20ms
+step:498/6000 train_loss:4.8337 train_time:1782249ms step_avg:3652.15ms
+step:499/6000 train_loss:4.6731 train_time:1785878ms step_avg:3652.10ms
+step:500/6000 train_loss:5.3884 train_time:1789508ms step_avg:3652.06ms
+step:500/6000 val_loss:4.7687 train_time:1789674ms step_avg:3652.40ms
+step:501/6000 train_loss:4.4299 train_time:1793116ms step_avg:3651.97ms
+step:502/6000 train_loss:4.6955 train_time:1796730ms step_avg:3651.89ms
+step:503/6000 train_loss:4.7719 train_time:1800347ms step_avg:3651.82ms
+step:504/6000 train_loss:4.9558 train_time:1803968ms step_avg:3651.76ms
+step:505/6000 train_loss:4.7148 train_time:1807588ms step_avg:3651.69ms
+step:506/6000 train_loss:5.0235 train_time:1811211ms step_avg:3651.64ms
+step:507/6000 train_loss:4.7132 train_time:1814833ms step_avg:3651.58ms
+step:508/6000 train_loss:4.7709 train_time:1818512ms step_avg:3651.63ms
+step:509/6000 train_loss:6.0061 train_time:1825170ms step_avg:3657.65ms
+step:510/6000 train_loss:4.6490 train_time:1828789ms step_avg:3657.58ms
+step:511/6000 train_loss:4.7361 train_time:1832411ms step_avg:3657.51ms
+step:512/6000 train_loss:4.6377 train_time:1836037ms step_avg:3657.44ms
+step:513/6000 train_loss:4.9031 train_time:1839661ms step_avg:3657.38ms
+step:514/6000 train_loss:4.4241 train_time:1843284ms step_avg:3657.31ms
+step:515/6000 train_loss:4.6703 train_time:1846909ms step_avg:3657.24ms
+step:516/6000 train_loss:4.7645 train_time:1850533ms step_avg:3657.18ms
+step:517/6000 train_loss:4.6484 train_time:1854161ms step_avg:3657.12ms
+step:518/6000 train_loss:4.5278 train_time:1857790ms step_avg:3657.07ms
+step:519/6000 train_loss:4.7858 train_time:1861418ms step_avg:3657.01ms
+step:520/6000 train_loss:4.6826 train_time:1865047ms step_avg:3656.95ms
+step:521/6000 train_loss:4.5754 train_time:1868671ms step_avg:3656.89ms
+step:522/6000 train_loss:4.6022 train_time:1872298ms step_avg:3656.83ms
+step:523/6000 train_loss:4.7435 train_time:1875927ms step_avg:3656.78ms
+step:524/6000 train_loss:5.1156 train_time:1879556ms step_avg:3656.72ms
+step:525/6000 train_loss:4.7967 train_time:1883183ms step_avg:3656.67ms
+step:526/6000 train_loss:4.7887 train_time:1886811ms step_avg:3656.61ms
+step:527/6000 train_loss:4.8101 train_time:1890441ms step_avg:3656.56ms
+step:528/6000 train_loss:4.9607 train_time:1894070ms step_avg:3656.51ms
+step:529/6000 train_loss:4.7899 train_time:1897699ms step_avg:3656.45ms
+step:530/6000 train_loss:4.6622 train_time:1901327ms step_avg:3656.40ms
+step:531/6000 train_loss:4.5698 train_time:1904957ms step_avg:3656.35ms
+step:532/6000 train_loss:4.7495 train_time:1908587ms step_avg:3656.30ms
+step:533/6000 train_loss:4.5271 train_time:1912216ms step_avg:3656.24ms
+step:534/6000 train_loss:4.7791 train_time:1915845ms step_avg:3656.19ms
+step:535/6000 train_loss:4.6713 train_time:1919474ms step_avg:3656.14ms
+step:536/6000 train_loss:4.7117 train_time:1923105ms step_avg:3656.09ms
+step:537/6000 train_loss:4.5788 train_time:1926736ms step_avg:3656.05ms
+step:538/6000 train_loss:4.6305 train_time:1930366ms step_avg:3656.00ms
+step:539/6000 train_loss:4.5587 train_time:1933997ms step_avg:3655.95ms
+step:540/6000 train_loss:5.0118 train_time:1937628ms step_avg:3655.90ms
+step:541/6000 train_loss:4.0148 train_time:1941257ms step_avg:3655.85ms
+step:542/6000 train_loss:4.7977 train_time:1944888ms step_avg:3655.80ms
+step:543/6000 train_loss:4.6554 train_time:1948516ms step_avg:3655.75ms
+step:544/6000 train_loss:4.5977 train_time:1952149ms step_avg:3655.71ms
+step:545/6000 train_loss:4.5225 train_time:1955777ms step_avg:3655.66ms
+step:546/6000 train_loss:4.7838 train_time:1959407ms step_avg:3655.61ms
+step:547/6000 train_loss:4.7514 train_time:1963034ms step_avg:3655.56ms
+step:548/6000 train_loss:4.5054 train_time:1966666ms step_avg:3655.51ms
+step:549/6000 train_loss:4.4277 train_time:1970294ms step_avg:3655.46ms
+step:550/6000 train_loss:4.6098 train_time:1973922ms step_avg:3655.41ms
+step:551/6000 train_loss:4.6899 train_time:1977555ms step_avg:3655.37ms
+step:552/6000 train_loss:4.8056 train_time:1981187ms step_avg:3655.33ms
+step:553/6000 train_loss:4.5559 train_time:1984818ms step_avg:3655.28ms
+step:554/6000 train_loss:4.7542 train_time:1988450ms step_avg:3655.24ms
+step:555/6000 train_loss:4.6074 train_time:1992082ms step_avg:3655.20ms
+step:556/6000 train_loss:4.5659 train_time:1995714ms step_avg:3655.15ms
+step:557/6000 train_loss:4.6181 train_time:1999347ms step_avg:3655.11ms
+step:558/6000 train_loss:4.6267 train_time:2002981ms step_avg:3655.07ms
+step:559/6000 train_loss:4.6393 train_time:2006614ms step_avg:3655.04ms
+step:560/6000 train_loss:4.4061 train_time:2010251ms step_avg:3655.00ms
+step:561/6000 train_loss:4.6114 train_time:2013883ms step_avg:3654.96ms
+step:562/6000 train_loss:4.5854 train_time:2017514ms step_avg:3654.92ms
+step:563/6000 train_loss:4.5859 train_time:2021147ms step_avg:3654.88ms
+step:564/6000 train_loss:4.4435 train_time:2024780ms step_avg:3654.84ms
+step:565/6000 train_loss:4.4597 train_time:2028411ms step_avg:3654.80ms
+step:566/6000 train_loss:4.9380 train_time:2032043ms step_avg:3654.75ms
+step:567/6000 train_loss:4.5589 train_time:2035679ms step_avg:3654.72ms
+step:568/6000 train_loss:4.7541 train_time:2039313ms step_avg:3654.68ms
+step:569/6000 train_loss:4.4159 train_time:2042945ms step_avg:3654.64ms
+step:570/6000 train_loss:4.4905 train_time:2046578ms step_avg:3654.60ms
+step:571/6000 train_loss:4.2774 train_time:2050212ms step_avg:3654.57ms
+step:572/6000 train_loss:4.5427 train_time:2053842ms step_avg:3654.52ms
+step:573/6000 train_loss:4.7828 train_time:2057472ms step_avg:3654.48ms
+step:574/6000 train_loss:4.6250 train_time:2061104ms step_avg:3654.44ms
+step:575/6000 train_loss:4.3700 train_time:2064736ms step_avg:3654.40ms
+step:576/6000 train_loss:4.5276 train_time:2068365ms step_avg:3654.36ms
+step:577/6000 train_loss:4.5232 train_time:2071994ms step_avg:3654.31ms
+step:578/6000 train_loss:4.5612 train_time:2075626ms step_avg:3654.27ms
+step:579/6000 train_loss:4.4730 train_time:2079257ms step_avg:3654.23ms
+step:580/6000 train_loss:4.6328 train_time:2082887ms step_avg:3654.19ms
+step:581/6000 train_loss:4.5414 train_time:2086516ms step_avg:3654.14ms
+step:582/6000 train_loss:4.5132 train_time:2090144ms step_avg:3654.10ms
+step:583/6000 train_loss:4.4790 train_time:2093774ms step_avg:3654.06ms
+step:584/6000 train_loss:4.3751 train_time:2097448ms step_avg:3654.09ms
+step:585/6000 train_loss:4.5225 train_time:2101080ms step_avg:3654.05ms
+step:586/6000 train_loss:4.5223 train_time:2104711ms step_avg:3654.01ms
+step:587/6000 train_loss:4.6404 train_time:2108340ms step_avg:3653.97ms
+step:588/6000 train_loss:4.5573 train_time:2111969ms step_avg:3653.93ms
+step:589/6000 train_loss:4.3420 train_time:2115600ms step_avg:3653.89ms
+step:590/6000 train_loss:4.5855 train_time:2119228ms step_avg:3653.84ms
+step:591/6000 train_loss:4.7812 train_time:2122858ms step_avg:3653.80ms
+step:592/6000 train_loss:4.6544 train_time:2126488ms step_avg:3653.76ms
+step:593/6000 train_loss:4.3806 train_time:2130117ms step_avg:3653.72ms
+step:594/6000 train_loss:4.7755 train_time:2133746ms step_avg:3653.67ms
+step:595/6000 train_loss:4.7924 train_time:2137376ms step_avg:3653.64ms
+step:596/6000 train_loss:4.4418 train_time:2141006ms step_avg:3653.59ms
+step:597/6000 train_loss:4.6742 train_time:2144636ms step_avg:3653.55ms
+step:598/6000 train_loss:4.4761 train_time:2148267ms step_avg:3653.52ms
+step:599/6000 train_loss:4.5563 train_time:2151898ms step_avg:3653.48ms
+step:600/6000 train_loss:4.4303 train_time:2155531ms step_avg:3653.44ms
+step:601/6000 train_loss:4.4403 train_time:2159159ms step_avg:3653.40ms
+step:602/6000 train_loss:4.2670 train_time:2162793ms step_avg:3653.37ms
+step:603/6000 train_loss:4.3606 train_time:2166425ms step_avg:3653.33ms
+step:604/6000 train_loss:4.5873 train_time:2170055ms step_avg:3653.29ms
+step:605/6000 train_loss:4.7258 train_time:2173686ms step_avg:3653.25ms
+step:606/6000 train_loss:4.5174 train_time:2177316ms step_avg:3653.21ms
+step:607/6000 train_loss:4.4481 train_time:2180945ms step_avg:3653.17ms
+step:608/6000 train_loss:4.4979 train_time:2184577ms step_avg:3653.14ms
+step:609/6000 train_loss:4.1632 train_time:2188208ms step_avg:3653.10ms
+step:610/6000 train_loss:4.5947 train_time:2194900ms step_avg:3658.17ms
+step:611/6000 train_loss:4.5494 train_time:2198523ms step_avg:3658.11ms
+step:612/6000 train_loss:4.5678 train_time:2202151ms step_avg:3658.06ms
+step:613/6000 train_loss:4.4684 train_time:2205780ms step_avg:3658.01ms
+step:614/6000 train_loss:4.5639 train_time:2209407ms step_avg:3657.96ms
+step:615/6000 train_loss:4.3634 train_time:2213035ms step_avg:3657.91ms
+step:616/6000 train_loss:4.5191 train_time:2216667ms step_avg:3657.87ms
+step:617/6000 train_loss:4.4336 train_time:2220296ms step_avg:3657.82ms
+step:618/6000 train_loss:4.6884 train_time:2223928ms step_avg:3657.78ms
+step:619/6000 train_loss:4.5825 train_time:2227559ms step_avg:3657.73ms
+step:620/6000 train_loss:4.3245 train_time:2231195ms step_avg:3657.70ms
+step:621/6000 train_loss:4.4822 train_time:2234825ms step_avg:3657.65ms
+step:622/6000 train_loss:4.5575 train_time:2238459ms step_avg:3657.61ms
+step:623/6000 train_loss:4.5691 train_time:2242095ms step_avg:3657.58ms
+step:624/6000 train_loss:4.6687 train_time:2245728ms step_avg:3657.54ms
+step:625/6000 train_loss:4.6552 train_time:2249360ms step_avg:3657.50ms
+step:625/6000 val_loss:4.4481 train_time:2249528ms step_avg:3657.77ms
+step:626/6000 train_loss:4.3914 train_time:2252976ms step_avg:3657.43ms
+step:627/6000 train_loss:4.2471 train_time:2256600ms step_avg:3657.37ms
+step:628/6000 train_loss:4.4512 train_time:2260225ms step_avg:3657.32ms
+step:629/6000 train_loss:4.3585 train_time:2263851ms step_avg:3657.27ms
+step:630/6000 train_loss:4.3883 train_time:2267478ms step_avg:3657.22ms
+step:631/6000 train_loss:4.4097 train_time:2271109ms step_avg:3657.18ms
+step:632/6000 train_loss:4.4928 train_time:2274736ms step_avg:3657.13ms
+step:633/6000 train_loss:4.3365 train_time:2278365ms step_avg:3657.09ms
+step:634/6000 train_loss:4.3835 train_time:2281994ms step_avg:3657.04ms
+step:635/6000 train_loss:4.7298 train_time:2285626ms step_avg:3657.00ms
+step:636/6000 train_loss:4.2990 train_time:2289258ms step_avg:3656.96ms
+step:637/6000 train_loss:4.3027 train_time:2292889ms step_avg:3656.92ms
+step:638/6000 train_loss:4.3175 train_time:2296524ms step_avg:3656.89ms
+step:639/6000 train_loss:4.8215 train_time:2300156ms step_avg:3656.85ms
+step:640/6000 train_loss:4.3754 train_time:2303787ms step_avg:3656.80ms
+step:641/6000 train_loss:4.2805 train_time:2307416ms step_avg:3656.76ms
+step:642/6000 train_loss:4.6754 train_time:2311050ms step_avg:3656.72ms
+step:643/6000 train_loss:4.4327 train_time:2314681ms step_avg:3656.68ms
+step:644/6000 train_loss:4.5501 train_time:2318313ms step_avg:3656.65ms
+step:645/6000 train_loss:4.4077 train_time:2321943ms step_avg:3656.60ms
+step:646/6000 train_loss:4.4020 train_time:2325573ms step_avg:3656.56ms
+step:647/6000 train_loss:4.3372 train_time:2329203ms step_avg:3656.52ms
+step:648/6000 train_loss:4.2046 train_time:2332836ms step_avg:3656.48ms
+step:649/6000 train_loss:4.2835 train_time:2336466ms step_avg:3656.44ms
+step:650/6000 train_loss:4.2724 train_time:2340097ms step_avg:3656.40ms
+step:651/6000 train_loss:4.4419 train_time:2343727ms step_avg:3656.36ms
+step:652/6000 train_loss:4.4662 train_time:2347359ms step_avg:3656.32ms
+step:653/6000 train_loss:4.3646 train_time:2350994ms step_avg:3656.29ms
+step:654/6000 train_loss:4.4524 train_time:2354627ms step_avg:3656.25ms
+step:655/6000 train_loss:4.7181 train_time:2358258ms step_avg:3656.21ms
+step:656/6000 train_loss:4.2125 train_time:2361891ms step_avg:3656.18ms
+step:657/6000 train_loss:4.3028 train_time:2365521ms step_avg:3656.14ms
+step:658/6000 train_loss:4.6294 train_time:2369152ms step_avg:3656.10ms
+step:659/6000 train_loss:4.3472 train_time:2372782ms step_avg:3656.06ms
+step:660/6000 train_loss:4.3978 train_time:2376415ms step_avg:3656.02ms
+step:661/6000 train_loss:4.2346 train_time:2380046ms step_avg:3655.99ms
+step:662/6000 train_loss:4.0449 train_time:2383679ms step_avg:3655.95ms
+step:663/6000 train_loss:4.3472 train_time:2387311ms step_avg:3655.91ms
+step:664/6000 train_loss:4.2734 train_time:2390943ms step_avg:3655.88ms
+step:665/6000 train_loss:4.2062 train_time:2394575ms step_avg:3655.84ms
+step:666/6000 train_loss:4.2785 train_time:2398206ms step_avg:3655.80ms
+step:667/6000 train_loss:4.6495 train_time:2401840ms step_avg:3655.77ms
+step:668/6000 train_loss:4.2498 train_time:2405475ms step_avg:3655.74ms
+step:669/6000 train_loss:4.2067 train_time:2409105ms step_avg:3655.70ms
+step:670/6000 train_loss:4.6130 train_time:2412736ms step_avg:3655.66ms
+step:671/6000 train_loss:4.3435 train_time:2416365ms step_avg:3655.62ms
+step:672/6000 train_loss:4.3870 train_time:2419998ms step_avg:3655.59ms
+step:673/6000 train_loss:4.3546 train_time:2423632ms step_avg:3655.55ms
+step:674/6000 train_loss:4.0725 train_time:2427265ms step_avg:3655.52ms
+step:675/6000 train_loss:4.2985 train_time:2430894ms step_avg:3655.48ms
+step:676/6000 train_loss:4.3053 train_time:2434525ms step_avg:3655.44ms
+step:677/6000 train_loss:4.4992 train_time:2438154ms step_avg:3655.40ms
+step:678/6000 train_loss:4.2678 train_time:2441787ms step_avg:3655.37ms
+step:679/6000 train_loss:4.6663 train_time:2445417ms step_avg:3655.33ms
+step:680/6000 train_loss:4.2243 train_time:2449050ms step_avg:3655.30ms
+step:681/6000 train_loss:4.4718 train_time:2452677ms step_avg:3655.26ms
+step:682/6000 train_loss:4.3530 train_time:2456308ms step_avg:3655.22ms
+step:683/6000 train_loss:4.2803 train_time:2459939ms step_avg:3655.18ms
+step:684/6000 train_loss:4.5507 train_time:2463567ms step_avg:3655.14ms
+step:685/6000 train_loss:4.3428 train_time:2467198ms step_avg:3655.11ms

logs_new_MUON_large_reshape/adam_lr_search/mode_5_param_qkvo_adam_lr_0.0005_seed_42/config.json

@@ -0,0 +1,27 @@
+{
+    "cli_args": {
+        "seed": 42,
+        "optimizer_mode": 5,
+        "model_parameterization": "qkvo",
+        "adam_lr": 0.0005,
+        "muon_lr": 0.05,
+        "base_dir": "logs_new_MUON_large_reshape/adam_lr_search"
+    },
+    "hyperparameters": {
+        "input_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "input_val_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "batch_size": 960,
+        "device_batch_size": 24,
+        "sequence_length": 1024,
+        "num_iterations": 6000,
+        "learning_rate": 0.0018,
+        "warmup_iters": 0,
+        "warmdown_iters": 0,
+        "weight_decay": 0,
+        "val_loss_every": 125,
+        "val_tokens": 10420224,
+        "save_every": 0
+    },
+    "run_uuid_for_log": "468b38e5-f77c-4ee0-bcb4-4167524b1954",
+    "script_code_logged_at_start": true
+}

logs_new_MUON_large_reshape/muon_lr_search/mode_0_param_qkvo_muon_lr_0.0005_seed_42/config.json

@@ -0,0 +1,27 @@
+{
+    "cli_args": {
+        "seed": 42,
+        "optimizer_mode": 0,
+        "model_parameterization": "qkvo",
+        "adam_lr": 0.0005,
+        "muon_lr": 0.0005,
+        "base_dir": "logs_new_MUON_large_reshape/muon_lr_search"
+    },
+    "hyperparameters": {
+        "input_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "input_val_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "batch_size": 960,
+        "device_batch_size": 24,
+        "sequence_length": 1024,
+        "num_iterations": 6000,
+        "learning_rate": 0.0018,
+        "warmup_iters": 0,
+        "warmdown_iters": 0,
+        "weight_decay": 0,
+        "val_loss_every": 125,
+        "val_tokens": 10420224,
+        "save_every": 0
+    },
+    "run_uuid_for_log": "c9f9753c-1658-43e4-95d3-e6169bb4b689",
+    "script_code_logged_at_start": true
+}

logs_new_MUON_large_reshape/muon_lr_search/mode_0_param_qkvo_muon_lr_0.005_seed_42/config.json

@@ -0,0 +1,27 @@
+{
+    "cli_args": {
+        "seed": 42,
+        "optimizer_mode": 0,
+        "model_parameterization": "qkvo",
+        "adam_lr": 0.0005,
+        "muon_lr": 0.005,
+        "base_dir": "logs_new_MUON_large_reshape/muon_lr_search"
+    },
+    "hyperparameters": {
+        "input_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "input_val_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "batch_size": 960,
+        "device_batch_size": 24,
+        "sequence_length": 1024,
+        "num_iterations": 6000,
+        "learning_rate": 0.0018,
+        "warmup_iters": 0,
+        "warmdown_iters": 0,
+        "weight_decay": 0,
+        "val_loss_every": 125,
+        "val_tokens": 10420224,
+        "save_every": 0
+    },
+    "run_uuid_for_log": "e57f0ab5-52cb-4681-9781-64dc94922cf1",
+    "script_code_logged_at_start": true
+}

logs_new_MUON_large_reshape/muon_lr_search/mode_0_param_qkvo_muon_lr_5e-05_seed_42/config.json

@@ -0,0 +1,27 @@
+{
+    "cli_args": {
+        "seed": 42,
+        "optimizer_mode": 0,
+        "model_parameterization": "qkvo",
+        "adam_lr": 0.0005,
+        "muon_lr": 5e-05,
+        "base_dir": "logs_new_MUON_large_reshape/muon_lr_search"
+    },
+    "hyperparameters": {
+        "input_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "input_val_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "batch_size": 960,
+        "device_batch_size": 24,
+        "sequence_length": 1024,
+        "num_iterations": 6000,
+        "learning_rate": 0.0018,
+        "warmup_iters": 0,
+        "warmdown_iters": 0,
+        "weight_decay": 0,
+        "val_loss_every": 125,
+        "val_tokens": 10420224,
+        "save_every": 0
+    },
+    "run_uuid_for_log": "61537f41-2746-44ec-a838-26ce9c6334dc",
+    "script_code_logged_at_start": true
+}

logs_new_MUON_large_reshape/muon_lr_search_head/mode_0_param_qkvo_muon_lr_0.0005_adam_lr_0.005_seed_42/config.json

@@ -0,0 +1,27 @@
+{
+    "cli_args": {
+        "seed": 42,
+        "optimizer_mode": 0,
+        "model_parameterization": "qkvo",
+        "adam_lr": 0.005,
+        "muon_lr": 0.0005,
+        "base_dir": "logs_new_MUON_large_reshape/muon_lr_search_head"
+    },
+    "hyperparameters": {
+        "input_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "input_val_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "batch_size": 960,
+        "device_batch_size": 24,
+        "sequence_length": 1024,
+        "num_iterations": 6000,
+        "learning_rate": 0.0018,
+        "warmup_iters": 0,
+        "warmdown_iters": 0,
+        "weight_decay": 0,
+        "val_loss_every": 125,
+        "val_tokens": 10420224,
+        "save_every": 0
+    },
+    "run_uuid_for_log": "be3ad22d-9271-4557-8520-677019d1ba75",
+    "script_code_logged_at_start": true
+}

logs_new_MUON_large_reshape/muon_lr_search_nes/mode_0_param_qkvo_muon_lr_0.0005_adam_lr_0.0005_seed_42/config.json

@@ -0,0 +1,27 @@
+{
+    "cli_args": {
+        "seed": 42,
+        "optimizer_mode": 0,
+        "model_parameterization": "qkvo",
+        "adam_lr": 0.0005,
+        "muon_lr": 0.0005,
+        "base_dir": "logs_new_MUON_large_reshape/muon_lr_search_nes"
+    },
+    "hyperparameters": {
+        "input_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "input_val_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "batch_size": 960,
+        "device_batch_size": 24,
+        "sequence_length": 1024,
+        "num_iterations": 6000,
+        "learning_rate": 0.0018,
+        "warmup_iters": 0,
+        "warmdown_iters": 0,
+        "weight_decay": 0,
+        "val_loss_every": 125,
+        "val_tokens": 10420224,
+        "save_every": 0
+    },
+    "run_uuid_for_log": "9fef894a-70e9-4399-b152-6eaf5fc0a83a",
+    "script_code_logged_at_start": true
+}

logs_new_MUON_large_reshape/muon_lr_search_nes/mode_0_param_qkvo_muon_lr_0.0005_adam_lr_0.008_seed_42/config.json

@@ -0,0 +1,27 @@
+{
+    "cli_args": {
+        "seed": 42,
+        "optimizer_mode": 0,
+        "model_parameterization": "qkvo",
+        "adam_lr": 0.008,
+        "muon_lr": 0.0005,
+        "base_dir": "logs_new_MUON_large_reshape/muon_lr_search_nes"
+    },
+    "hyperparameters": {
+        "input_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "input_val_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "batch_size": 960,
+        "device_batch_size": 24,
+        "sequence_length": 1024,
+        "num_iterations": 6000,
+        "learning_rate": 0.0018,
+        "warmup_iters": 0,
+        "warmdown_iters": 0,
+        "weight_decay": 0,
+        "val_loss_every": 125,
+        "val_tokens": 10420224,
+        "save_every": 0
+    },
+    "run_uuid_for_log": "16f75572-a351-445f-b63f-555db4ad8a4a",
+    "script_code_logged_at_start": true
+}

logs_new_MUON_large_reshape/muon_lr_search_nes/mode_0_param_qkvo_muon_lr_0.005_adam_lr_0.008_seed_42/config.json

@@ -0,0 +1,27 @@
+{
+    "cli_args": {
+        "seed": 42,
+        "optimizer_mode": 0,
+        "model_parameterization": "qkvo",
+        "adam_lr": 0.008,
+        "muon_lr": 0.005,
+        "base_dir": "logs_new_MUON_large_reshape/muon_lr_search_nes"
+    },
+    "hyperparameters": {
+        "input_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_train_*.bin",
+        "input_val_bin": "/home/aiops/zhangfz/MUON_theory/modded-nanogpt/data/fineweb10B/fineweb_val_*.bin",
+        "batch_size": 960,
+        "device_batch_size": 24,
+        "sequence_length": 1024,
+        "num_iterations": 6000,
+        "learning_rate": 0.0018,
+        "warmup_iters": 0,
+        "warmdown_iters": 0,
+        "weight_decay": 0,
+        "val_loss_every": 125,
+        "val_tokens": 10420224,
+        "save_every": 0
+    },
+    "run_uuid_for_log": "ed6797f0-bbfd-4e73-ba21-3ae651151e5d",
+    "script_code_logged_at_start": true
+}