Upload kaggle/director_lora_train.py with huggingface_hub

kaggle/director_lora_train.py

@@ -43,6 +43,11 @@ ACCUM = int(os.environ.get("ACCUM", "4"))
 MAX_LEN = int(os.environ.get("MAX_LEN", "2048"))
 SEED = int(os.environ.get("SEED", "20261107"))
 GRAD_CKPT = os.environ.get("GRAD_CKPT", "0") == "1"
+# Wall-clock budget for the optimizer loop. The T4 has no causal_conv1d or
+# flash-linear-attention kernels, so Gated DeltaNet falls back to the slow
+# reference implementation. Stop and save a usable adapter rather than let
+# the notebook timeout throw away the whole run.
+MAX_TRAIN_SECONDS = int(os.environ.get("MAX_TRAIN_SECONDS", "4200"))
 
 # peft matches a list of target names against the last segment of a module key
 # (key == target or key.endswith("." + target)). Short names are portable across
@@ -216,6 +221,24 @@ def verify_targets(model, torch) -> None:
         raise SystemExit("unexpected LoRA target set; refusing to train")
 
 
+def neutralize_torchao() -> None:
+    """Kaggle ships torchao 0.10.0; peft 0.21.2 *raises* on torchao < 0.16
+    instead of treating it as absent. We never quantize here, so force the
+    'not installed' branch in both places that consult it. The notebook also
+    uninstalls torchao; this is the belt-and-braces fallback.
+    """
+    patched = []
+    for modname in ("peft.import_utils", "peft.tuners.lora.torchao"):
+        try:
+            mod = __import__(modname, fromlist=["is_torchao_available"])
+        except ImportError:
+            continue
+        if hasattr(mod, "is_torchao_available"):
+            mod.is_torchao_available = lambda: False
+            patched.append(modname)
+    log(f"peft torchao dispatcher disabled in {patched}")
+
+
 def main() -> None:
     import torch
     from peft import LoraConfig, get_peft_model
@@ -244,6 +267,7 @@ def main() -> None:
     smoke_generate(torch, model, tok, rows[0])
     model.config.use_cache = False
 
+    neutralize_torchao()
     cfg = LoraConfig(r=R, lora_alpha=ALPHA, lora_dropout=DROPOUT, bias="none",
                      task_type="CAUSAL_LM", target_modules=SHORT_TARGETS)
     model = get_peft_model(model, cfg, autocast_adapter_dtype=True)
@@ -276,10 +300,16 @@ def main() -> None:
     opt = torch.optim.AdamW(trainable, lr=LR, betas=(0.9, 0.95), weight_decay=0.01)
     model.train()
     step, running, group, t0 = 0, 0.0, 0.0, time.time()
+    budget_hit = False
     for epoch in range(EPOCHS):
         order = list(range(len(encoded)))
         random.shuffle(order)
         for i, idx in enumerate(order):
+            if time.time() - t0 > MAX_TRAIN_SECONDS:
+                log(f"time budget {MAX_TRAIN_SECONDS}s reached at epoch {epoch} "
+                    f"iter {i}/{len(order)}; saving what we have")
+                budget_hit = True
+                break
             batch = {k: v.cuda() for k, v in encoded[idx].items()}
             loss = model(**batch).loss / ACCUM
             loss.backward()
@@ -295,7 +325,9 @@ def main() -> None:
                     log(f"epoch {epoch} step {step} loss {running/25:.4f} "
                         f"({time.time()-t0:.0f}s)")
                     running = 0.0
-        log(f"epoch {epoch} done")
+        log(f"epoch {epoch} done ({time.time()-t0:.0f}s total)")
+        if budget_hit:
+            break
     opt.zero_grad(set_to_none=True)
 
     adapter = OUT / "adapter"
@@ -332,6 +364,7 @@ def main() -> None:
         "dtype": str(dtype), "rows": len(encoded), "epochs": EPOCHS, "lr": LR,
         "r": R, "alpha": ALPHA, "targets": len(SHORT_TARGETS),
         "trainable": n_train, "steps": step, "seconds": round(time.time() - t0),
+        "budget_hit": budget_hit, "budget_seconds": MAX_TRAIN_SECONDS,
     }, indent=1), encoding="utf-8")
     log("done")