Update best.py

best.py

@@ -50,11 +50,10 @@ class ModelConfig:
     num_layers: int = 12
     num_attention_heads: int = 6
     num_key_value_heads: int = 2     # GQA
-    # intermediate_size is a real stored field so old checkpoints load correctly.
-    # Default -1 means: derive from hidden_size at __post_init__ time.
-    # load_model() always overwrites this from the checkpoint's state dict shapes,
-    # so a checkpoint trained with intermediate=960 will always load as 960.
-    intermediate_size: int = -1
+    # Stored as a plain int field — NEVER a @property — so pickle round-trips work.
+    # 0 = unset (load_model will fill it from checkpoint weight shapes).
+    # New training always passes this explicitly from len(tokenizer) / hidden_size.
+    intermediate_size: int = 0
     max_position_embeddings: int = 2048
     rms_norm_eps: float = 1e-6
     rope_theta: float = 10000.0
@@ -68,10 +67,8 @@ class ModelConfig:
     label_smoothing: float = 0.1
 
     def __post_init__(self):
-        # Derive intermediate_size when not explicitly set
-        if self.intermediate_size == -1:
-            # Original code used hidden * 3; keep that as default so new
-            # training runs match the formula the user originally chose.
+        # Set intermediate_size only when not already provided
+        if self.intermediate_size <= 0:
             self.intermediate_size = self.hidden_size * 3
         assert self.hidden_size % self.num_attention_heads == 0, \
             f"hidden_size {self.hidden_size} not divisible by num_heads {self.num_attention_heads}"
@@ -294,11 +291,16 @@ class GroupedQueryAttention(nn.Module):
 class SwiGLUMLP(nn.Module):
     def __init__(self, config: ModelConfig):
         super().__init__()
-        self.hidden_size      = config.hidden_size
-        self.intermediate_size = config.intermediate_size  # now a @property
-        self.gate_proj = nn.Linear(self.hidden_size,      self.intermediate_size, bias=False)
-        self.up_proj   = nn.Linear(self.hidden_size,      self.intermediate_size, bias=False)
-        self.down_proj = nn.Linear(self.intermediate_size, self.hidden_size,      bias=False)
+        self.hidden_size = config.hidden_size
+        # Read intermediate_size defensively: if somehow 0 or negative (e.g. old
+        # unpickled config that missed __post_init__), fall back to hidden * 3.
+        inter = getattr(config, 'intermediate_size', 0)
+        if not isinstance(inter, int) or inter <= 0:
+            inter = self.hidden_size * 3
+        self.intermediate_size = inter
+        self.gate_proj = nn.Linear(self.hidden_size,       self.intermediate_size, bias=False)
+        self.up_proj   = nn.Linear(self.hidden_size,       self.intermediate_size, bias=False)
+        self.down_proj = nn.Linear(self.intermediate_size, self.hidden_size,       bias=False)
 
     def forward(self, x):
         return self.down_proj(F.silu(self.gate_proj(x)) * self.up_proj(x))
@@ -1068,6 +1070,15 @@ def generate_text(
     """
     model.eval()
 
+    # Reseed from OS entropy so repeated calls with the same prompt diverge.
+    # This is the core fix: torch.multinomial outcome depends on torch RNG state,
+    # which was frozen to seed=42 at startup. Each call now starts from a unique state.
+    import os as _os
+    _entropy = int.from_bytes(_os.urandom(4), 'little')
+    torch.manual_seed(_entropy)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(_entropy)
+
     eos_id = tokenizer.eos_token_id or tokenizer.sep_token_id or 2
     pad_id = tokenizer.pad_token_id or 0
 
@@ -1281,7 +1292,14 @@ def run_benchmark(model, tokenizer, device, dataset_path: str = None, n: int = 2
         print("No valid samples.")
         return
 
-    random.seed(42)
+    # Time-based seed: different sample selection AND different generation each run
+    import time
+    live_seed = int(time.time() * 1000) % (2**31)
+    random.seed(live_seed)
+    torch.manual_seed(live_seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(live_seed)
+
     samples = random.sample(all_samples, min(n, len(all_samples)))
     model.eval()
 
@@ -1296,7 +1314,7 @@ def run_benchmark(model, tokenizer, device, dataset_path: str = None, n: int = 2
         prompt   = f"{inp} <cot>"
 
         full         = generate_text(model, tokenizer, prompt=prompt, max_new_tokens=150,
-                                     temperature=0.3, top_k=20, top_p=0.9, device=device)
+                                     temperature=0.7, top_k=40, top_p=0.92, device=device)
         raw          = full[len(prompt):].strip()
         _, answer    = _extract_thinking(raw)
         answer_lower = answer.lower()
@@ -1448,7 +1466,20 @@ def main():
     save_fp16        = not args.save_fp32
     use_cot_training = not args.no_cot
 
-    set_seed(args.seed)
+    # Only fix the seed for training (reproducibility).
+    # Chat and benchmark must NOT be seeded — identical seeds produce identical
+    # outputs every run, making the model feel like a lookup table.
+    if args.train or args.finetune or args.continue_train:
+        set_seed(args.seed)
+    else:
+        # Use a time-based seed so every run is different
+        import time
+        live_seed = int(time.time() * 1000) % (2**31)
+        random.seed(live_seed)
+        np.random.seed(live_seed)
+        torch.manual_seed(live_seed)
+        if torch.cuda.is_available():
+            torch.cuda.manual_seed_all(live_seed)
     device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
     print(f"\nDevice: {device}")
     if torch.cuda.is_available():