NanGuard: zero grads BEFORE diagnostics; dump wrapped in try/except (first run confirmed rows have 6-77 unmasked labels at the poison step)

job-0.5b-nanguard.py

@@ -186,35 +186,44 @@ class NanGuard(SFTTrainer):
                         for p in model.parameters() if p.requires_grad)
         if grads_bad or not torch.isfinite(loss):
             NanGuard._dumped += 1
-            print(f"\n!!! non-finite {'grads' if grads_bad else 'loss'} #{NanGuard._dumped} "
-                  f"at global_step {self.state.global_step} epoch {self.state.epoch}")
-            if NanGuard._dumped <= 2:  # full dump only for the first two events
-                unmasked = (labels != -100).sum(-1)
-                print("micro-batch loss:", loss.item() if hasattr(loss, "item") else loss)
-                print("num_items_in_batch:", num_items_in_batch)
-                print("shape:", tuple(ids.shape), "id range:", ids.min().item(), ids.max().item())
-                print("unmasked label tokens per row:", unmasked.tolist())
-                was_training = model.training
-                model.eval()
-                with torch.no_grad():
-                    outbf = model(input_ids=ids, attention_mask=inputs.get("attention_mask"),
-                                  labels=labels)
-                    print("bf16 no-grad reforward loss:",
-                          None if outbf.loss is None else outbf.loss.item(),
-                          "logits nan:", torch.isnan(outbf.logits).any().item(),
-                          "inf:", torch.isinf(outbf.logits).any().item())
-                if was_training:
-                    model.train()
-                for k in range(ids.shape[0]):
-                    txt = tokenizer.decode(ids[k], skip_special_tokens=False)
-                    txt = txt.replace(tokenizer.pad_token, "")
-                    print(f"--- row {k} unmasked={unmasked[k].item()} chars={len(txt)}")
-                    print("  tail:", repr(txt[-300:]))
-            # neutralize: zero every gradient so the coming optimizer.step is a no-op
+            # SAFETY FIRST: neutralize before any diagnostic can crash. Zeroed
+            # grads make the coming optimizer.step a no-op; the poison never
+            # reaches the weights even if everything below throws.
             for p in model.parameters():
                 if p.grad is not None:
                     p.grad.zero_()
+            print(f"\n!!! non-finite {'grads' if grads_bad else 'loss'} #{NanGuard._dumped} "
+                  f"at global_step {self.state.global_step} epoch {self.state.epoch}")
             print(">>> gradients zeroed - this update is skipped, training continues")
+            if NanGuard._dumped <= 2:  # full dump only for the first two events
+                try:
+                    unmasked = (labels != -100).sum(-1)
+                    print("micro-batch loss:", loss.item() if hasattr(loss, "item") else loss)
+                    print("num_items_in_batch:", num_items_in_batch)
+                    print("shape:", tuple(ids.shape), "id range:", ids.min().item(), ids.max().item())
+                    print("unmasked label tokens per row:", unmasked.tolist())
+                    bad_params = [n for n, p in model.named_parameters()
+                                  if p.grad is not None and not torch.isfinite(p.grad).all()]
+                    print(f"non-finite grad params: 0 after zeroing; offenders were "
+                          f"{len(bad_params)} (grads already cleared)")
+                    with torch.no_grad():
+                        outbf = model(input_ids=ids,
+                                      attention_mask=inputs.get("attention_mask"),
+                                      labels=labels)
+                        print("bf16 no-grad reforward loss:",
+                              None if outbf.loss is None else outbf.loss.item(),
+                              "logits nan:", torch.isnan(outbf.logits).any().item(),
+                              "inf:", torch.isinf(outbf.logits).any().item())
+                    for k in range(ids.shape[0]):
+                        txt = tokenizer.decode(ids[k], skip_special_tokens=False)
+                        txt = txt.replace(tokenizer.pad_token, "")
+                        print(f"--- row {k} unmasked={unmasked[k].item()} chars={len(txt)}")
+                        print("  tail:", repr(txt[-300:]))
+                except Exception as e:
+                    import traceback
+                    print("diagnostic dump failed (training continues):",
+                          type(e).__name__, e)
+                    traceback.print_exc()
             return torch.zeros_like(loss)
         return loss