feat: hand-written 3 Kaggle ipynbs with unsloth install attempt; train_lib disables actor grad-checkpoint + filters Phi3 warning spam (2x faster + clean logs)

colab/train_lib.py

@@ -22,16 +22,47 @@ T4. If a non-T4 GPU is available it will be used automatically.
 from __future__ import annotations
 
 import json
+import logging
 import os
 import re
 import sys
 import time
+import warnings
 from dataclasses import asdict, dataclass, field
 from pathlib import Path
 from typing import Any, Iterable
 
 import torch
 
+# ---------------------------------------------------------------------------
+# Silence the noisy per-token warnings emitted by Phi-3 and friends during
+# PPO updates (gradient checkpointing × cache interaction). They are harmless
+# but produce thousands of identical lines that hide actual progress.
+# ---------------------------------------------------------------------------
+warnings.filterwarnings(
+    "ignore", message=".*Caching is incompatible with gradient checkpointing.*")
+warnings.filterwarnings(
+    "ignore", message=".*None of the inputs have requires_grad=True.*")
+warnings.filterwarnings(
+    "ignore", message=".*use_reentrant parameter should be passed explicitly.*")
+warnings.filterwarnings(
+    "ignore", message=".*AccumulateGrad node's stream does not match.*")
+
+
+class _Phi3CacheFilter(logging.Filter):
+    def filter(self, record: logging.LogRecord) -> bool:                 # noqa: D401
+        msg = record.getMessage()
+        if "Caching is incompatible with gradient checkpointing" in msg:
+            return False
+        if "None of the inputs have requires_grad" in msg:
+            return False
+        return True
+
+
+for _name in ("transformers", "transformers.models.phi3.modeling_phi3",
+              "torch.utils.checkpoint", "torch.autograd.graph"):
+    logging.getLogger(_name).addFilter(_Phi3CacheFilter())
+
 # ---------------------------------------------------------------------------
 # Repository wiring — assumes you cloned the repo and the notebook lives in
 # /content/incident-commander/ on Colab.
@@ -314,7 +345,13 @@ class QwenActor:
             base = AutoModelForCausalLM.from_pretrained(
                 hf_name, quantization_config=bnb, device_map="auto",
                 trust_remote_code=False)
-            base = prepare_model_for_kbit_training(base)
+            # NOTE: gradient checkpointing is OFF for the 3.8B actor — it
+            # fits in T4 16 GB without it, and disabling it 1) eliminates
+            # the per-token "Caching is incompatible with gradient
+            # checkpointing in Phi3DecoderLayer" warning spam, and 2) speeds
+            # up the PPO backward pass roughly 2x by avoiding recompute.
+            base = prepare_model_for_kbit_training(
+                base, use_gradient_checkpointing=False)
             # Pick LoRA target modules that actually exist in this arch.
             # Qwen / Llama use split q/k/v/gate/up. Phi-3 uses fused
             # qkv_proj + gate_up_proj. Detect by introspecting param names.

kaggle/generate_notebooks.py

@@ -1,272 +0,0 @@
-"""Generate the 3 Kaggle notebooks for sharded IncidentCommander training.
-
-Each notebook is identical except for the IC_TASK_SHARD value (0/1/2) and
-the run_name. Re-run this script if you want to tweak the template.
-"""
-from __future__ import annotations
-
-import json
-from pathlib import Path
-
-NOTEBOOK_DIR = Path(__file__).resolve().parent
-
-# Kaggle Models mount paths (read-only, mounted at /kaggle/input/, do NOT
-# consume the 20 GB /kaggle/working/ quota). Exact paths the user pinned:
-#
-#   Actor : /kaggle/input/models/Microsoft/phi-3/pytorch/phi-3.5-mini-instruct/2
-#   Critic: /kaggle/input/models/deepseek-ai/deepseek-r1-0528/transformers/deepseek-r1-0528-qwen3-8b/1
-#
-# In the Kaggle notebook sidebar ("+ Add Input" → Models):
-#   • search `phi-3`         → publisher Microsoft  → framework PyTorch       → variation `phi-3.5-mini-instruct`        → version 2  → Add
-#   • search `deepseek-r1`   → publisher deepseek-ai → framework Transformers  → variation `deepseek-r1-0528-qwen3-8b`     → version 1  → Add
-ACTOR_PATH_LITERAL  = "/kaggle/input/models/Microsoft/phi-3/pytorch/phi-3.5-mini-instruct/2"
-CRITIC_PATH_LITERAL = "/kaggle/input/models/deepseek-ai/deepseek-r1-0528/transformers/deepseek-r1-0528-qwen3-8b/1"
-
-ACTOR_NAME  = "microsoft/Phi-3.5-mini-instruct"
-CRITIC_NAME = "deepseek-ai/DeepSeek-R1-0528-Qwen3-8B"
-
-REPO_URL = "https://github.com/r1cksync/meta-rl-hack.git"
-
-
-def cell_md(text: str) -> dict:
-    return {"cell_type": "markdown", "metadata": {},
-            "source": text.splitlines(keepends=True)}
-
-
-def cell_code(text: str) -> dict:
-    return {"cell_type": "code", "metadata": {}, "execution_count": None,
-            "outputs": [], "source": text.splitlines(keepends=True)}
-
-
-def build(shard: int, total_shards: int = 3) -> dict:
-    title = f"# IncidentCommander RL — Kaggle shard {shard + 1} / {total_shards}"
-    intro = f"""
-**Workload:** every {total_shards}rd task starting at index {shard}
-(~127 of 381 scenarios). Trains a LoRA on **{ACTOR_NAME}** using a local
-**{CRITIC_NAME}** critic — both attached as Kaggle Models so they live in
-the read-only `/kaggle/input/` mount and DO NOT eat the 20 GB working quota.
-
-**REQUIRED — attach these 2 Kaggle Models before running** (right sidebar →
-`+ Add Input` → `Models` tab). Both are open / no access request:
-1.  `Microsoft / phi-3`        → framework `PyTorch`       → variation `phi-3.5-mini-instruct`     → version `2`
-2.  `deepseek-ai / deepseek-r1-0528` → framework `Transformers` → variation `deepseek-r1-0528-qwen3-8b` → version `1`
-
-Expected mount paths after attach (cell 3 verifies):
-- `{ACTOR_PATH_LITERAL}`
-- `{CRITIC_PATH_LITERAL}`
-
-**Required notebook settings** (right-hand sidebar):
-- Accelerator: `GPU T4 x2` or `GPU P100`
-- Persistence: `Files only`
-- Internet: `On` (for `git clone` and optional HF Hub upload)
-
-**Optional** (only if you want intermediate checkpoint upload to your HF
-repo): Add-ons → Secrets → add `HF_TOKEN` and toggle it on.
-
-**Output:** `/kaggle/working/adapter_kaggle{shard + 1}.zip` — download from
-the sidebar after the run finishes. Combine all 3 with
-`scripts/merge_lora_adapters.py` on your laptop.
-"""
-    cells = [
-        cell_md(title + "\n" + intro),
-
-        cell_md("## 1. GPU + path sanity"),
-        cell_code(f"""\
-import subprocess
-print('--- GPU ---')
-subprocess.run(['nvidia-smi', '-L'], check=False)
-import torch
-print('CUDA OK?', torch.cuda.is_available(), '| device:',
-      torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'none')
-""".strip()),
-
-        cell_md("## 2. Install deps (Kaggle has torch/transformers preinstalled — we just pin compatible versions)"),
-        cell_code("""\
-# Qwen3 architecture (used inside DeepSeek-R1-0528-Qwen3-8B) requires
-# transformers >= 4.51. Bump the whole stack to a known-compatible set.
-%pip install -q -U \\
-    "transformers>=4.51,<4.55" \\
-    "peft>=0.13,<0.16" \\
-    "accelerate>=1.1,<1.5" \\
-    "bitsandbytes>=0.45.5" \\
-    "huggingface_hub>=0.25,<1.0" \\
-    "pydantic>=2,<3" \\
-    "datasets" "sentencepiece" "protobuf" "safetensors"
-""".strip()),
-
-        cell_md("## 3. Resolve attached Kaggle Models (read-only, no download)"),
-        cell_code(f"""\
-import os, pathlib
-
-ACTOR_PATH  = '{ACTOR_PATH_LITERAL}'
-CRITIC_PATH = '{CRITIC_PATH_LITERAL}'
-
-def verify(path, label):
-    p = pathlib.Path(path)
-    if not p.exists():
-        raise SystemExit(
-            f'{{label}} not found at {{path}}. Open the right sidebar → '
-            f'"+ Add Input" → Models → attach the model with the matching '
-            f'publisher/framework/variation/version (see the markdown above).')
-    has_weights = any(p.glob('*.safetensors')) or any(p.glob('*.bin'))
-    if not has_weights:
-        raise SystemExit(f'{{label}} found at {{path}} but no *.safetensors / *.bin inside.')
-    print(f'{{label}}: OK  →  {{path}}')
-
-verify(ACTOR_PATH,  'actor  (Phi-3.5-mini-instruct)')
-verify(CRITIC_PATH, 'critic (DeepSeek-R1-0528-Qwen3-8B)')
-
-# Push HF Hub cache out of /kaggle/working so an accidental snapshot_download
-# (e.g. by a tokenizer) writes to /tmp instead of eating the 20 GB quota.
-os.environ['HF_HOME']              = '/tmp/hf-cache'
-os.environ['HUGGINGFACE_HUB_CACHE'] = '/tmp/hf-cache'
-os.environ['TRANSFORMERS_CACHE']   = '/tmp/hf-cache'
-pathlib.Path('/tmp/hf-cache').mkdir(parents=True, exist_ok=True)
-
-# Optional HF_TOKEN — only used if you want to upload checkpoints.
-try:
-    from kaggle_secrets import UserSecretsClient
-    os.environ['HF_TOKEN'] = UserSecretsClient().get_secret('HF_TOKEN')
-    print('HF_TOKEN attached from Kaggle Secrets')
-except Exception:
-    print('No HF_TOKEN — that is fine, training works fully offline now.')
-
-# IMPORTANT: do NOT set TRANSFORMERS_TRUST_REMOTE_CODE here. Phi-3 (>=4.40)
-# and Qwen3 (>=4.51) are natively supported by transformers — using the
-# custom modeling_*.py shipped inside the Kaggle Models mount triggers an
-# `AttributeError: 'DynamicCache' object has no attribute 'get_max_length'`
-# because that custom code targets transformers <4.48. We force native impl
-# by NOT enabling trust_remote_code (train_lib.py also passes it as False).
-# Clear any previously-downloaded custom modeling code that an earlier run
-# may have cached, otherwise from_pretrained reuses it from the cache.
-import shutil as _sh, pathlib as _pl
-_modules = _pl.Path('/tmp/hf-cache/modules')
-if _modules.exists():
-    _sh.rmtree(_modules, ignore_errors=True)
-    print('cleared cached custom modeling code at', _modules)
-""".strip()),
-
-        cell_md("## 4. Clone the repo (public GitHub) — always pull latest"),
-        cell_code(f"""\
-import os, subprocess, pathlib, shutil
-WORK = '/kaggle/working/incident-commander'
-# IMPORTANT: chdir OUT of WORK before deleting it, otherwise git clone fails
-# with "Unable to read current working directory" on a re-run.
-os.chdir('/kaggle/working')
-p = pathlib.Path(WORK)
-if p.exists():
-    # Wipe any stale clone from a previous session/run so we always get the
-    # newest scripts/run_training.py + colab/train_lib.py from main.
-    shutil.rmtree(WORK, ignore_errors=True)
-subprocess.run(['git', 'clone', '--depth', '1',
-                '{REPO_URL}', WORK], check=True)
-os.chdir(WORK)
-# Show the commit we are running so it is obvious in the logs.
-subprocess.run(['git', '-C', WORK, 'log', '-1', '--oneline'], check=False)
-print('cwd =', os.getcwd())
-""".strip()),
-
-        cell_md("## 5. Configure run (shard, paths, env vars)"),
-        cell_code(f"""\
-import os
-
-os.environ['INCIDENT_COMMANDER_MOCK'] = 'true'
-os.environ['IC_ACTOR_MODEL']     = ACTOR_PATH
-os.environ['IC_CRITIC_PROVIDER'] = 'local'        # 7B critic on the same GPU
-os.environ['IC_CRITIC_MODEL']    = CRITIC_PATH
-os.environ['IC_TASK_MODE']       = 'all'           # full 381 corpus
-os.environ['IC_TASK_SHARDS']     = '{total_shards}'
-os.environ['IC_TASK_SHARD']      = '{shard}'
-os.environ['IC_TOTAL_UPDATES']   = '60'            # ~6h on T4 / P100
-os.environ['IC_ROLLOUTS']        = '3'
-os.environ['IC_MAX_STEPS']       = '12'
-os.environ['IC_CKPT_EVERY']      = '15'
-os.environ['IC_RUN_NAME']        = 'kaggle{shard + 1}'
-
-print('actor :', os.environ['IC_ACTOR_MODEL'])
-print('critic:', os.environ['IC_CRITIC_MODEL'])
-print('shard :', os.environ['IC_TASK_SHARD'], '/', os.environ['IC_TASK_SHARDS'])
-""".strip()),
-
-        cell_md("## 6. Train"),
-        cell_code("""\
-# The training script runs to completion. tqdm progress + ETA are streamed
-# to stdout. Kaggle truncates very long outputs — adapter checkpoints are
-# always written to /kaggle/working/incident-commander/colab/logs/ regardless.
-import subprocess, sys
-result = subprocess.run([sys.executable, 'scripts/run_training.py'],
-                         check=False)
-print('exit code:', result.returncode)
-""".strip()),
-
-        cell_md("## 7. Package outputs for download"),
-        cell_code(f"""\
-import shutil, glob, pathlib
-
-LOGS = pathlib.Path('colab/logs')
-finals = sorted(LOGS.glob('adapter_kaggle{shard + 1}_final'))
-ckpts  = sorted(LOGS.glob('adapter_kaggle{shard + 1}_u*'))
-keep   = (finals or ckpts)
-assert keep, 'No adapter directories found — check the training cell output for errors.'
-src = keep[-1]
-print('packaging', src)
-
-dst = pathlib.Path('/kaggle/working/adapter_kaggle{shard + 1}.zip')
-shutil.make_archive(str(dst.with_suffix('')), 'zip', root_dir=src)
-print('zipped to', dst, 'size:', dst.stat().st_size, 'bytes')
-
-# Also copy the JSON training log for plotting on your laptop.
-for j in glob.glob('colab/logs/training_kaggle{shard + 1}*.json'):
-    shutil.copy(j, '/kaggle/working/')
-print('files in /kaggle/working/:')
-for f in sorted(pathlib.Path('/kaggle/working/').iterdir()):
-    if f.name == 'hf-cache': continue   # don't list the model cache
-    print(' ', f.name, f.stat().st_size if f.is_file() else '<dir>')
-""".strip()),
-
-        cell_md(f"""\
-## Done
-
-Download `adapter_kaggle{shard + 1}.zip` from the **Output** tab on the
-right.  Repeat for the other two shards (notebooks 2 and 3), then on your
-laptop run:
-
-```powershell
-python scripts/merge_lora_adapters.py `
-    --inputs ./adapter_kaggle1 ./adapter_kaggle2 ./adapter_kaggle3 `
-    --output ./adapter_merged
-```
-
-The merged adapter loads with the standard `peft` API on top of
-`{ACTOR_NAME}`.
-"""),
-    ]
-
-    return {
-        "cells": cells,
-        "metadata": {
-            "kernelspec": {"display_name": "Python 3",
-                           "language": "python",
-                           "name": "python3"},
-            "language_info": {"name": "python", "version": "3.10"},
-            "kaggle": {"accelerator": "nvidiaTeslaT4",
-                       "dataSources": [],
-                       "isInternetEnabled": True,
-                       "language": "python",
-                       "sourceType": "notebook"},
-        },
-        "nbformat": 4,
-        "nbformat_minor": 5,
-    }
-
-
-def main() -> None:
-    for shard in range(3):
-        nb = build(shard)
-        path = NOTEBOOK_DIR / f"kaggle_train_shard{shard + 1}.ipynb"
-        path.write_text(json.dumps(nb, indent=1), encoding="utf-8")
-        print("wrote", path)
-
-
-if __name__ == "__main__":
-    main()

kaggle/kaggle_train_shard1.ipynb

@@ -6,94 +6,78 @@
    "source": [
     "# IncidentCommander RL — Kaggle shard 1 / 3\n",
     "\n",
-    "**Workload:** every 3rd task starting at index 0\n",
-    "(~127 of 381 scenarios). Trains a LoRA on **microsoft/Phi-3.5-mini-instruct** using a local\n",
-    "**deepseek-ai/DeepSeek-R1-0528-Qwen3-8B** critic — both attached as Kaggle Models so they live in\n",
-    "the read-only `/kaggle/input/` mount and DO NOT eat the 20 GB working quota.\n",
+    "**Workload:** every 3rd task starting at index **0** (~127 of 381 scenarios).\n",
+    "Trains a LoRA on **Phi-3.5-mini-instruct** using a local **DeepSeek-R1-0528-Qwen3-8B** critic.\n",
     "\n",
-    "**REQUIRED — attach these 2 Kaggle Models before running** (right sidebar →\n",
-    "`+ Add Input` → `Models` tab). Both are open / no access request:\n",
-    "1.  `Microsoft / phi-3`        → framework `PyTorch`       → variation `phi-3.5-mini-instruct`     → version `2`\n",
-    "2.  `deepseek-ai / deepseek-r1-0528` → framework `Transformers` → variation `deepseek-r1-0528-qwen3-8b` → version `1`\n",
+    "## REQUIRED — attach these 2 Kaggle Models before running\n",
+    "Right sidebar → `+ Add Input` → `Models` tab:\n",
+    "1. `Microsoft / phi-3` → framework `PyTorch` → variation `phi-3.5-mini-instruct` → version `2`\n",
+    "2. `deepseek-ai / deepseek-r1-0528` → framework `Transformers` → variation `deepseek-r1-0528-qwen3-8b` → version `1`\n",
     "\n",
-    "Expected mount paths after attach (cell 3 verifies):\n",
-    "- `/kaggle/input/models/Microsoft/phi-3/pytorch/phi-3.5-mini-instruct/2`\n",
-    "- `/kaggle/input/models/deepseek-ai/deepseek-r1-0528/transformers/deepseek-r1-0528-qwen3-8b/1`\n",
-    "\n",
-    "**Required notebook settings** (right-hand sidebar):\n",
+    "## Required notebook settings\n",
     "- Accelerator: `GPU T4 x2` or `GPU P100`\n",
+    "- Internet: `On`\n",
     "- Persistence: `Files only`\n",
-    "- Internet: `On` (for `git clone` and optional HF Hub upload)\n",
-    "\n",
-    "**Optional** (only if you want intermediate checkpoint upload to your HF\n",
-    "repo): Add-ons → Secrets → add `HF_TOKEN` and toggle it on.\n",
     "\n",
-    "**Output:** `/kaggle/working/adapter_kaggle1.zip` — download from\n",
-    "the sidebar after the run finishes. Combine all 3 with\n",
-    "`scripts/merge_lora_adapters.py` on your laptop.\n"
+    "**Output:** `/kaggle/working/adapter_kaggle1.zip` — download from the sidebar after the run finishes."
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1c28582e",
    "metadata": {},
+   "outputs": [],
    "source": [
-    "## 1. GPU + path sanity"
+    "# === 1. Install deps + unsloth (best-effort) ===\n",
+    "# Qwen3 (in DeepSeek-R1-0528) needs transformers >= 4.51. Unsloth speeds up\n",
+    "# the actor ~2x; if its install fails on this Kaggle image we fall back to\n",
+    "# pure HF transformers automatically (train_lib.py handles both paths).\n",
+    "import subprocess, sys\n",
+    "\n",
+    "def pip(*args):\n",
+    "    return subprocess.run([sys.executable, '-m', 'pip', 'install', '-q', *args],\n",
+    "                          check=False).returncode\n",
+    "\n",
+    "rc = pip('-U', 'unsloth')\n",
+    "print('[install] unsloth rc =', rc, '(non-zero is fine, HF fallback works)')\n",
+    "\n",
+    "pip('-U',\n",
+    "    'transformers>=4.51,<4.55',\n",
+    "    'peft>=0.13,<0.16',\n",
+    "    'accelerate>=1.1,<1.5',\n",
+    "    'bitsandbytes>=0.45.5',\n",
+    "    'huggingface_hub>=0.25,<1.0',\n",
+    "    'pydantic>=2,<3',\n",
+    "    'datasets', 'sentencepiece', 'protobuf', 'safetensors')\n",
+    "print('[install] pinned stack done')"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "37a868c2",
    "metadata": {},
    "outputs": [],
    "source": [
+    "# === 2. GPU sanity ===\n",
     "import subprocess\n",
     "print('--- GPU ---')\n",
     "subprocess.run(['nvidia-smi', '-L'], check=False)\n",
     "import torch\n",
-    "print('CUDA OK?', torch.cuda.is_available(), '| device:',\n",
-    "      torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'none')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 2. Install deps (Kaggle has torch/transformers preinstalled — we just pin compatible versions)"
+    "print('CUDA OK?', torch.cuda.is_available(),\n",
+    "      '| device:', torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'none')"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "fa14ea90",
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Qwen3 architecture (used inside DeepSeek-R1-0528-Qwen3-8B) requires\n",
-    "# transformers >= 4.51. Bump the whole stack to a known-compatible set.\n",
-    "%pip install -q -U \\\n",
-    "    \"transformers>=4.51,<4.55\" \\\n",
-    "    \"peft>=0.13,<0.16\" \\\n",
-    "    \"accelerate>=1.1,<1.5\" \\\n",
-    "    \"bitsandbytes>=0.45.5\" \\\n",
-    "    \"huggingface_hub>=0.25,<1.0\" \\\n",
-    "    \"pydantic>=2,<3\" \\\n",
-    "    \"datasets\" \"sentencepiece\" \"protobuf\" \"safetensors\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 3. Resolve attached Kaggle Models (read-only, no download)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "4e224033",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os, pathlib\n",
+    "# === 3. Verify attached Kaggle Models + suppress warning spam ===\n",
+    "import os, pathlib, shutil, warnings, logging\n",
     "\n",
     "ACTOR_PATH  = '/kaggle/input/models/Microsoft/phi-3/pytorch/phi-3.5-mini-instruct/2'\n",
     "CRITIC_PATH = '/kaggle/input/models/deepseek-ai/deepseek-r1-0528/transformers/deepseek-r1-0528-qwen3-8b/1'\n",
@@ -101,179 +85,143 @@
     "def verify(path, label):\n",
     "    p = pathlib.Path(path)\n",
     "    if not p.exists():\n",
-    "        raise SystemExit(\n",
-    "            f'{label} not found at {path}. Open the right sidebar → '\n",
-    "            f'\"+ Add Input\" → Models → attach the model with the matching '\n",
-    "            f'publisher/framework/variation/version (see the markdown above).')\n",
-    "    has_weights = any(p.glob('*.safetensors')) or any(p.glob('*.bin'))\n",
-    "    if not has_weights:\n",
-    "        raise SystemExit(f'{label} found at {path} but no *.safetensors / *.bin inside.')\n",
-    "    print(f'{label}: OK  →  {path}')\n",
+    "        raise SystemExit(f'{label} not found at {path}. Attach the matching Kaggle Model.')\n",
+    "    if not (any(p.glob('*.safetensors')) or any(p.glob('*.bin'))):\n",
+    "        raise SystemExit(f'{label} found at {path} but no weight files inside.')\n",
+    "    print(f'{label}: OK -> {path}')\n",
     "\n",
     "verify(ACTOR_PATH,  'actor  (Phi-3.5-mini-instruct)')\n",
     "verify(CRITIC_PATH, 'critic (DeepSeek-R1-0528-Qwen3-8B)')\n",
     "\n",
-    "# Push HF Hub cache out of /kaggle/working so an accidental snapshot_download\n",
-    "# (e.g. by a tokenizer) writes to /tmp instead of eating the 20 GB quota.\n",
     "os.environ['HF_HOME']              = '/tmp/hf-cache'\n",
     "os.environ['HUGGINGFACE_HUB_CACHE'] = '/tmp/hf-cache'\n",
     "os.environ['TRANSFORMERS_CACHE']   = '/tmp/hf-cache'\n",
     "pathlib.Path('/tmp/hf-cache').mkdir(parents=True, exist_ok=True)\n",
     "\n",
-    "# Optional HF_TOKEN — only used if you want to upload checkpoints.\n",
+    "modules_dir = pathlib.Path('/tmp/hf-cache/modules')\n",
+    "if modules_dir.exists():\n",
+    "    shutil.rmtree(modules_dir, ignore_errors=True)\n",
+    "    print('cleared cached custom modeling code at', modules_dir)\n",
+    "\n",
     "try:\n",
     "    from kaggle_secrets import UserSecretsClient\n",
     "    os.environ['HF_TOKEN'] = UserSecretsClient().get_secret('HF_TOKEN')\n",
     "    print('HF_TOKEN attached from Kaggle Secrets')\n",
     "except Exception:\n",
-    "    print('No HF_TOKEN — that is fine, training works fully offline now.')\n",
+    "    print('No HF_TOKEN -- training runs fully offline (that is fine).')\n",
     "\n",
-    "# IMPORTANT: do NOT set TRANSFORMERS_TRUST_REMOTE_CODE here. Phi-3 (>=4.40)\n",
-    "# and Qwen3 (>=4.51) are natively supported by transformers — using the\n",
-    "# custom modeling_*.py shipped inside the Kaggle Models mount triggers an\n",
-    "# `AttributeError: 'DynamicCache' object has no attribute 'get_max_length'`\n",
-    "# because that custom code targets transformers <4.48. We force native impl\n",
-    "# by NOT enabling trust_remote_code (train_lib.py also passes it as False).\n",
-    "# Clear any previously-downloaded custom modeling code that an earlier run\n",
-    "# may have cached, otherwise from_pretrained reuses it from the cache.\n",
-    "import shutil as _sh, pathlib as _pl\n",
-    "_modules = _pl.Path('/tmp/hf-cache/modules')\n",
-    "if _modules.exists():\n",
-    "    _sh.rmtree(_modules, ignore_errors=True)\n",
-    "    print('cleared cached custom modeling code at', _modules)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 4. Clone the repo (public GitHub) — always pull latest"
+    "for pat in ('.*Caching is incompatible with gradient checkpointing.*',\n",
+    "            '.*None of the inputs have requires_grad=True.*',\n",
+    "            '.*use_reentrant parameter should be passed explicitly.*',\n",
+    "            \".*AccumulateGrad node's stream does not match.*\"):\n",
+    "    warnings.filterwarnings('ignore', message=pat)\n",
+    "\n",
+    "class _PhiFilter(logging.Filter):\n",
+    "    def filter(self, r):\n",
+    "        return 'Caching is incompatible' not in r.getMessage()\n",
+    "for n in ('transformers', 'transformers.models.phi3.modeling_phi3',\n",
+    "          'torch.utils.checkpoint'):\n",
+    "    logging.getLogger(n).addFilter(_PhiFilter())\n",
+    "print('warning filters installed')"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "b83c7a39",
    "metadata": {},
    "outputs": [],
    "source": [
+    "# === 4. Clone the repo (fresh every run, prints commit hash) ===\n",
     "import os, subprocess, pathlib, shutil\n",
     "WORK = '/kaggle/working/incident-commander'\n",
-    "# IMPORTANT: chdir OUT of WORK before deleting it, otherwise git clone fails\n",
-    "# with \"Unable to read current working directory\" on a re-run.\n",
     "os.chdir('/kaggle/working')\n",
-    "p = pathlib.Path(WORK)\n",
-    "if p.exists():\n",
-    "    # Wipe any stale clone from a previous session/run so we always get the\n",
-    "    # newest scripts/run_training.py + colab/train_lib.py from main.\n",
+    "if pathlib.Path(WORK).exists():\n",
     "    shutil.rmtree(WORK, ignore_errors=True)\n",
     "subprocess.run(['git', 'clone', '--depth', '1',\n",
-    "                'https://github.com/r1cksync/meta-rl-hack.git', WORK], check=True)\n",
+    "                'https://github.com/r1cksync/meta-rl-hack.git', WORK],\n",
+    "               check=True)\n",
     "os.chdir(WORK)\n",
-    "# Show the commit we are running so it is obvious in the logs.\n",
     "subprocess.run(['git', '-C', WORK, 'log', '-1', '--oneline'], check=False)\n",
     "print('cwd =', os.getcwd())"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 5. Configure run (shard, paths, env vars)"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "81701d83",
    "metadata": {},
    "outputs": [],
    "source": [
+    "# === 5. Configure run (shard 1 / 3) ===\n",
     "import os\n",
-    "\n",
     "os.environ['INCIDENT_COMMANDER_MOCK'] = 'true'\n",
     "os.environ['IC_ACTOR_MODEL']     = ACTOR_PATH\n",
-    "os.environ['IC_CRITIC_PROVIDER'] = 'local'        # 7B critic on the same GPU\n",
+    "os.environ['IC_CRITIC_PROVIDER'] = 'local'\n",
     "os.environ['IC_CRITIC_MODEL']    = CRITIC_PATH\n",
-    "os.environ['IC_TASK_MODE']       = 'all'           # full 381 corpus\n",
+    "os.environ['IC_TASK_MODE']       = 'all'\n",
     "os.environ['IC_TASK_SHARDS']     = '3'\n",
     "os.environ['IC_TASK_SHARD']      = '0'\n",
-    "os.environ['IC_TOTAL_UPDATES']   = '60'            # ~6h on T4 / P100\n",
+    "os.environ['IC_TOTAL_UPDATES']   = '60'\n",
     "os.environ['IC_ROLLOUTS']        = '3'\n",
     "os.environ['IC_MAX_STEPS']       = '12'\n",
     "os.environ['IC_CKPT_EVERY']      = '15'\n",
     "os.environ['IC_RUN_NAME']        = 'kaggle1'\n",
-    "\n",
     "print('actor :', os.environ['IC_ACTOR_MODEL'])\n",
     "print('critic:', os.environ['IC_CRITIC_MODEL'])\n",
     "print('shard :', os.environ['IC_TASK_SHARD'], '/', os.environ['IC_TASK_SHARDS'])"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 6. Train"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "5fecb57e",
    "metadata": {},
    "outputs": [],
    "source": [
-    "# The training script runs to completion. tqdm progress + ETA are streamed\n",
-    "# to stdout. Kaggle truncates very long outputs — adapter checkpoints are\n",
-    "# always written to /kaggle/working/incident-commander/colab/logs/ regardless.\n",
+    "# === 6. Train ===\n",
     "import subprocess, sys\n",
-    "result = subprocess.run([sys.executable, 'scripts/run_training.py'],\n",
-    "                         check=False)\n",
+    "result = subprocess.run([sys.executable, 'scripts/run_training.py'], check=False)\n",
     "print('exit code:', result.returncode)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 7. Package outputs for download"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "ed71f261",
    "metadata": {},
    "outputs": [],
    "source": [
+    "# === 7. Package outputs for download ===\n",
     "import shutil, glob, pathlib\n",
-    "\n",
     "LOGS = pathlib.Path('colab/logs')\n",
     "finals = sorted(LOGS.glob('adapter_kaggle1_final'))\n",
     "ckpts  = sorted(LOGS.glob('adapter_kaggle1_u*'))\n",
-    "keep   = (finals or ckpts)\n",
-    "assert keep, 'No adapter directories found — check the training cell output for errors.'\n",
+    "keep = (finals or ckpts)\n",
+    "assert keep, 'No adapter directories found -- check the training cell output.'\n",
     "src = keep[-1]\n",
     "print('packaging', src)\n",
-    "\n",
     "dst = pathlib.Path('/kaggle/working/adapter_kaggle1.zip')\n",
     "shutil.make_archive(str(dst.with_suffix('')), 'zip', root_dir=src)\n",
     "print('zipped to', dst, 'size:', dst.stat().st_size, 'bytes')\n",
-    "\n",
-    "# Also copy the JSON training log for plotting on your laptop.\n",
     "for j in glob.glob('colab/logs/training_kaggle1*.json'):\n",
     "    shutil.copy(j, '/kaggle/working/')\n",
     "print('files in /kaggle/working/:')\n",
     "for f in sorted(pathlib.Path('/kaggle/working/').iterdir()):\n",
-    "    if f.name == 'hf-cache': continue   # don't list the model cache\n",
+    "    if f.name == 'hf-cache':\n",
+    "        continue\n",
     "    print(' ', f.name, f.stat().st_size if f.is_file() else '<dir>')"
    ]
   },
   {
    "cell_type": "markdown",
+   "id": "1be8077f",
    "metadata": {},
    "source": [
     "## Done\n",
     "\n",
-    "Download `adapter_kaggle1.zip` from the **Output** tab on the\n",
-    "right.  Repeat for the other two shards (notebooks 2 and 3), then on your\n",
-    "laptop run:\n",
+    "Download `adapter_kaggle1.zip` from the **Output** tab on the right.\n",
+    "Run shard 2 and shard 3 in parallel browser tabs, then on your laptop:\n",
     "\n",
     "```powershell\n",
     "python scripts/merge_lora_adapters.py `\n",
@@ -281,8 +229,7 @@
     "    --output ./adapter_merged\n",
     "```\n",
     "\n",
-    "The merged adapter loads with the standard `peft` API on top of\n",
-    "`microsoft/Phi-3.5-mini-instruct`.\n"
+    "The merged adapter loads with the standard `peft` API on top of `microsoft/Phi-3.5-mini-instruct`."
    ]
   }
  ],

kaggle/kaggle_train_shard2.ipynb

@@ -4,95 +4,77 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# IncidentCommander RL \u2014 Kaggle shard 2 / 3\n",
+    "# IncidentCommander RL — Kaggle shard 2 / 3\n",
     "\n",
-    "**Workload:** every 3rd task starting at index 1\n",
-    "(~127 of 381 scenarios). Trains a LoRA on **microsoft/Phi-3.5-mini-instruct** using a local\n",
-    "**deepseek-ai/DeepSeek-R1-0528-Qwen3-8B** critic \u2014 both attached as Kaggle Models so they live in\n",
-    "the read-only `/kaggle/input/` mount and DO NOT eat the 20 GB working quota.\n",
+    "**Workload:** every 3rd task starting at index **1** (~127 of 381 scenarios).\n",
+    "Trains a LoRA on **Phi-3.5-mini-instruct** using a local **DeepSeek-R1-0528-Qwen3-8B** critic.\n",
     "\n",
-    "**REQUIRED \u2014 attach these 2 Kaggle Models before running** (right sidebar \u2192\n",
-    "`+ Add Input` \u2192 `Models` tab). Both are open / no access request:\n",
-    "1.  `Microsoft / phi-3`        \u2192 framework `PyTorch`       \u2192 variation `phi-3.5-mini-instruct`     \u2192 version `2`\n",
-    "2.  `deepseek-ai / deepseek-r1-0528` \u2192 framework `Transformers` \u2192 variation `deepseek-r1-0528-qwen3-8b` \u2192 version `1`\n",
+    "## REQUIRED — attach these 2 Kaggle Models before running\n",
+    "Right sidebar → `+ Add Input` → `Models` tab:\n",
+    "1. `Microsoft / phi-3` → framework `PyTorch` → variation `phi-3.5-mini-instruct` → version `2`\n",
+    "2. `deepseek-ai / deepseek-r1-0528` → framework `Transformers` → variation `deepseek-r1-0528-qwen3-8b` → version `1`\n",
     "\n",
-    "Expected mount paths after attach (cell 3 verifies):\n",
-    "- `/kaggle/input/models/Microsoft/phi-3/pytorch/phi-3.5-mini-instruct/2`\n",
-    "- `/kaggle/input/models/deepseek-ai/deepseek-r1-0528/transformers/deepseek-r1-0528-qwen3-8b/1`\n",
-    "\n",
-    "**Required notebook settings** (right-hand sidebar):\n",
+    "## Required notebook settings\n",
     "- Accelerator: `GPU T4 x2` or `GPU P100`\n",
+    "- Internet: `On`\n",
     "- Persistence: `Files only`\n",
-    "- Internet: `On` (for `git clone` and optional HF Hub upload)\n",
-    "\n",
-    "**Optional** (only if you want intermediate checkpoint upload to your HF\n",
-    "repo): Add-ons \u2192 Secrets \u2192 add `HF_TOKEN` and toggle it on.\n",
     "\n",
-    "**Output:** `/kaggle/working/adapter_kaggle2.zip` \u2014 download from\n",
-    "the sidebar after the run finishes. Combine all 3 with\n",
-    "`scripts/merge_lora_adapters.py` on your laptop.\n"
+    "**Output:** `/kaggle/working/adapter_kaggle2.zip` — download from the sidebar after the run finishes."
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {},
+   "outputs": [],
    "source": [
-    "## 1. GPU + path sanity"
+    "# === 1. Install deps + unsloth (best-effort) ===\n",
+    "# Qwen3 (in DeepSeek-R1-0528) needs transformers >= 4.51. Unsloth speeds up\n",
+    "# the actor ~2x; if its install fails on this Kaggle image we fall back to\n",
+    "# pure HF transformers automatically (train_lib.py handles both paths).\n",
+    "import subprocess, sys\n",
+    "\n",
+    "def pip(*args):\n",
+    "    return subprocess.run([sys.executable, '-m', 'pip', 'install', '-q', *args],\n",
+    "                          check=False).returncode\n",
+    "\n",
+    "rc = pip('-U', 'unsloth')\n",
+    "print('[install] unsloth rc =', rc, '(non-zero is fine, HF fallback works)')\n",
+    "\n",
+    "pip('-U',\n",
+    "    'transformers>=4.51,<4.55',\n",
+    "    'peft>=0.13,<0.16',\n",
+    "    'accelerate>=1.1,<1.5',\n",
+    "    'bitsandbytes>=0.45.5',\n",
+    "    'huggingface_hub>=0.25,<1.0',\n",
+    "    'pydantic>=2,<3',\n",
+    "    'datasets', 'sentencepiece', 'protobuf', 'safetensors')\n",
+    "print('[install] pinned stack done')"
    ]
   },
   {
    "cell_type": "code",
-   "metadata": {},
    "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
+    "# === 2. GPU sanity ===\n",
     "import subprocess\n",
     "print('--- GPU ---')\n",
     "subprocess.run(['nvidia-smi', '-L'], check=False)\n",
     "import torch\n",
-    "print('CUDA OK?', torch.cuda.is_available(), '| device:',\n",
-    "      torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'none')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 2. Install deps (Kaggle has torch/transformers preinstalled \u2014 we just pin compatible versions)"
+    "print('CUDA OK?', torch.cuda.is_available(),\n",
+    "      '| device:', torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'none')"
    ]
   },
   {
    "cell_type": "code",
-   "metadata": {},
    "execution_count": null,
-   "outputs": [],
-   "source": [
-    "# Qwen3 architecture (used inside DeepSeek-R1-0528-Qwen3-8B) requires\n",
-    "# transformers >= 4.51. Bump the whole stack to a known-compatible set.\n",
-    "%pip install -q -U \\\n",
-    "    \"transformers>=4.51,<4.55\" \\\n",
-    "    \"peft>=0.13,<0.16\" \\\n",
-    "    \"accelerate>=1.1,<1.5\" \\\n",
-    "    \"bitsandbytes>=0.45.5\" \\\n",
-    "    \"huggingface_hub>=0.25,<1.0\" \\\n",
-    "    \"pydantic>=2,<3\" \\\n",
-    "    \"datasets\" \"sentencepiece\" \"protobuf\" \"safetensors\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 3. Resolve attached Kaggle Models (read-only, no download)"
-   ]
-  },
-  {
-   "cell_type": "code",
    "metadata": {},
-   "execution_count": null,
    "outputs": [],
    "source": [
-    "import os, pathlib\n",
+    "# === 3. Verify attached Kaggle Models + suppress warning spam ===\n",
+    "import os, pathlib, shutil, warnings, logging\n",
     "\n",
     "ACTOR_PATH  = '/kaggle/input/models/Microsoft/phi-3/pytorch/phi-3.5-mini-instruct/2'\n",
     "CRITIC_PATH = '/kaggle/input/models/deepseek-ai/deepseek-r1-0528/transformers/deepseek-r1-0528-qwen3-8b/1'\n",
@@ -100,167 +82,127 @@
     "def verify(path, label):\n",
     "    p = pathlib.Path(path)\n",
     "    if not p.exists():\n",
-    "        raise SystemExit(\n",
-    "            f'{label} not found at {path}. Open the right sidebar \u2192 '\n",
-    "            f'\"+ Add Input\" \u2192 Models \u2192 attach the model with the matching '\n",
-    "            f'publisher/framework/variation/version (see the markdown above).')\n",
-    "    has_weights = any(p.glob('*.safetensors')) or any(p.glob('*.bin'))\n",
-    "    if not has_weights:\n",
-    "        raise SystemExit(f'{label} found at {path} but no *.safetensors / *.bin inside.')\n",
-    "    print(f'{label}: OK  \u2192  {path}')\n",
+    "        raise SystemExit(f'{label} not found at {path}. Attach the matching Kaggle Model.')\n",
+    "    if not (any(p.glob('*.safetensors')) or any(p.glob('*.bin'))):\n",
+    "        raise SystemExit(f'{label} found at {path} but no weight files inside.')\n",
+    "    print(f'{label}: OK -> {path}')\n",
     "\n",
     "verify(ACTOR_PATH,  'actor  (Phi-3.5-mini-instruct)')\n",
     "verify(CRITIC_PATH, 'critic (DeepSeek-R1-0528-Qwen3-8B)')\n",
     "\n",
-    "# Push HF Hub cache out of /kaggle/working so an accidental snapshot_download\n",
-    "# (e.g. by a tokenizer) writes to /tmp instead of eating the 20 GB quota.\n",
     "os.environ['HF_HOME']              = '/tmp/hf-cache'\n",
     "os.environ['HUGGINGFACE_HUB_CACHE'] = '/tmp/hf-cache'\n",
     "os.environ['TRANSFORMERS_CACHE']   = '/tmp/hf-cache'\n",
     "pathlib.Path('/tmp/hf-cache').mkdir(parents=True, exist_ok=True)\n",
     "\n",
-    "# Optional HF_TOKEN \u2014 only used if you want to upload checkpoints.\n",
+    "modules_dir = pathlib.Path('/tmp/hf-cache/modules')\n",
+    "if modules_dir.exists():\n",
+    "    shutil.rmtree(modules_dir, ignore_errors=True)\n",
+    "    print('cleared cached custom modeling code at', modules_dir)\n",
+    "\n",
     "try:\n",
     "    from kaggle_secrets import UserSecretsClient\n",
     "    os.environ['HF_TOKEN'] = UserSecretsClient().get_secret('HF_TOKEN')\n",
     "    print('HF_TOKEN attached from Kaggle Secrets')\n",
     "except Exception:\n",
-    "    print('No HF_TOKEN \u2014 that is fine, training works fully offline now.')\n",
+    "    print('No HF_TOKEN -- training runs fully offline (that is fine).')\n",
     "\n",
-    "# IMPORTANT: do NOT set TRANSFORMERS_TRUST_REMOTE_CODE here. Phi-3 (>=4.40)\n",
-    "# and Qwen3 (>=4.51) are natively supported by transformers \u2014 using the\n",
-    "# custom modeling_*.py shipped inside the Kaggle Models mount triggers an\n",
-    "# `AttributeError: 'DynamicCache' object has no attribute 'get_max_length'`\n",
-    "# because that custom code targets transformers <4.48. We force native impl\n",
-    "# by NOT enabling trust_remote_code (train_lib.py also passes it as False).\n",
-    "# Clear any previously-downloaded custom modeling code that an earlier run\n",
-    "# may have cached, otherwise from_pretrained reuses it from the cache.\n",
-    "import shutil as _sh, pathlib as _pl\n",
-    "_modules = _pl.Path('/tmp/hf-cache/modules')\n",
-    "if _modules.exists():\n",
-    "    _sh.rmtree(_modules, ignore_errors=True)\n",
-    "    print('cleared cached custom modeling code at', _modules)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 4. Clone the repo (public GitHub) \u2014 always pull latest"
+    "for pat in ('.*Caching is incompatible with gradient checkpointing.*',\n",
+    "            '.*None of the inputs have requires_grad=True.*',\n",
+    "            '.*use_reentrant parameter should be passed explicitly.*',\n",
+    "            \".*AccumulateGrad node's stream does not match.*\"):\n",
+    "    warnings.filterwarnings('ignore', message=pat)\n",
+    "\n",
+    "class _PhiFilter(logging.Filter):\n",
+    "    def filter(self, r):\n",
+    "        return 'Caching is incompatible' not in r.getMessage()\n",
+    "for n in ('transformers', 'transformers.models.phi3.modeling_phi3',\n",
+    "          'torch.utils.checkpoint'):\n",
+    "    logging.getLogger(n).addFilter(_PhiFilter())\n",
+    "print('warning filters installed')"
    ]
   },
   {
    "cell_type": "code",
-   "metadata": {},
    "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
+    "# === 4. Clone the repo (fresh every run, prints commit hash) ===\n",
     "import os, subprocess, pathlib, shutil\n",
     "WORK = '/kaggle/working/incident-commander'\n",
-    "# IMPORTANT: chdir OUT of WORK before deleting it, otherwise git clone fails\n",
-    "# with \"Unable to read current working directory\" on a re-run.\n",
     "os.chdir('/kaggle/working')\n",
-    "p = pathlib.Path(WORK)\n",
-    "if p.exists():\n",
-    "    # Wipe any stale clone from a previous session/run so we always get the\n",
-    "    # newest scripts/run_training.py + colab/train_lib.py from main.\n",
+    "if pathlib.Path(WORK).exists():\n",
     "    shutil.rmtree(WORK, ignore_errors=True)\n",
     "subprocess.run(['git', 'clone', '--depth', '1',\n",
-    "                'https://github.com/r1cksync/meta-rl-hack.git', WORK], check=True)\n",
+    "                'https://github.com/r1cksync/meta-rl-hack.git', WORK],\n",
+    "               check=True)\n",
     "os.chdir(WORK)\n",
-    "# Show the commit we are running so it is obvious in the logs.\n",
     "subprocess.run(['git', '-C', WORK, 'log', '-1', '--oneline'], check=False)\n",
     "print('cwd =', os.getcwd())"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 5. Configure run (shard, paths, env vars)"
-   ]
-  },
   {
    "cell_type": "code",
-   "metadata": {},
    "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
+    "# === 5. Configure run (shard 2 / 3) ===\n",
     "import os\n",
-    "\n",
     "os.environ['INCIDENT_COMMANDER_MOCK'] = 'true'\n",
     "os.environ['IC_ACTOR_MODEL']     = ACTOR_PATH\n",
-    "os.environ['IC_CRITIC_PROVIDER'] = 'local'        # 7B critic on the same GPU\n",
+    "os.environ['IC_CRITIC_PROVIDER'] = 'local'\n",
     "os.environ['IC_CRITIC_MODEL']    = CRITIC_PATH\n",
-    "os.environ['IC_TASK_MODE']       = 'all'           # full 381 corpus\n",
+    "os.environ['IC_TASK_MODE']       = 'all'\n",
     "os.environ['IC_TASK_SHARDS']     = '3'\n",
     "os.environ['IC_TASK_SHARD']      = '1'\n",
-    "os.environ['IC_TOTAL_UPDATES']   = '60'            # ~6h on T4 / P100\n",
+    "os.environ['IC_TOTAL_UPDATES']   = '60'\n",
     "os.environ['IC_ROLLOUTS']        = '3'\n",
     "os.environ['IC_MAX_STEPS']       = '12'\n",
     "os.environ['IC_CKPT_EVERY']      = '15'\n",
     "os.environ['IC_RUN_NAME']        = 'kaggle2'\n",
-    "\n",
     "print('actor :', os.environ['IC_ACTOR_MODEL'])\n",
     "print('critic:', os.environ['IC_CRITIC_MODEL'])\n",
     "print('shard :', os.environ['IC_TASK_SHARD'], '/', os.environ['IC_TASK_SHARDS'])"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 6. Train"
-   ]
-  },
   {
    "cell_type": "code",
-   "metadata": {},
    "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
-    "# The training script runs to completion. tqdm progress + ETA are streamed\n",
-    "# to stdout. Kaggle truncates very long outputs \u2014 adapter checkpoints are\n",
-    "# always written to /kaggle/working/incident-commander/colab/logs/ regardless.\n",
+    "# === 6. Train ===\n",
     "import subprocess, sys\n",
-    "result = subprocess.run([sys.executable, 'scripts/run_training.py'],\n",
-    "                         check=False)\n",
+    "result = subprocess.run([sys.executable, 'scripts/run_training.py'], check=False)\n",
     "print('exit code:', result.returncode)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 7. Package outputs for download"
-   ]
-  },
   {
    "cell_type": "code",
-   "metadata": {},
    "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
+    "# === 7. Package outputs for download ===\n",
     "import shutil, glob, pathlib\n",
-    "\n",
     "LOGS = pathlib.Path('colab/logs')\n",
     "finals = sorted(LOGS.glob('adapter_kaggle2_final'))\n",
     "ckpts  = sorted(LOGS.glob('adapter_kaggle2_u*'))\n",
-    "keep   = (finals or ckpts)\n",
-    "assert keep, 'No adapter directories found \u2014 check the training cell output for errors.'\n",
+    "keep = (finals or ckpts)\n",
+    "assert keep, 'No adapter directories found -- check the training cell output.'\n",
     "src = keep[-1]\n",
     "print('packaging', src)\n",
-    "\n",
     "dst = pathlib.Path('/kaggle/working/adapter_kaggle2.zip')\n",
     "shutil.make_archive(str(dst.with_suffix('')), 'zip', root_dir=src)\n",
     "print('zipped to', dst, 'size:', dst.stat().st_size, 'bytes')\n",
-    "\n",
-    "# Also copy the JSON training log for plotting on your laptop.\n",
     "for j in glob.glob('colab/logs/training_kaggle2*.json'):\n",
     "    shutil.copy(j, '/kaggle/working/')\n",
     "print('files in /kaggle/working/:')\n",
     "for f in sorted(pathlib.Path('/kaggle/working/').iterdir()):\n",
-    "    if f.name == 'hf-cache': continue   # don't list the model cache\n",
+    "    if f.name == 'hf-cache':\n",
+    "        continue\n",
     "    print(' ', f.name, f.stat().st_size if f.is_file() else '<dir>')"
    ]
   },
@@ -270,9 +212,8 @@
    "source": [
     "## Done\n",
     "\n",
-    "Download `adapter_kaggle2.zip` from the **Output** tab on the\n",
-    "right.  Repeat for the other two shards (notebooks 2 and 3), then on your\n",
-    "laptop run:\n",
+    "Download `adapter_kaggle2.zip` from the **Output** tab on the right.\n",
+    "Run shard 2 and shard 3 in parallel browser tabs, then on your laptop:\n",
     "\n",
     "```powershell\n",
     "python scripts/merge_lora_adapters.py `\n",
@@ -280,8 +221,7 @@
     "    --output ./adapter_merged\n",
     "```\n",
     "\n",
-    "The merged adapter loads with the standard `peft` API on top of\n",
-    "`microsoft/Phi-3.5-mini-instruct`.\n"
+    "The merged adapter loads with the standard `peft` API on top of `microsoft/Phi-3.5-mini-instruct`."
    ]
   }
  ],

kaggle/kaggle_train_shard3.ipynb

@@ -4,95 +4,77 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# IncidentCommander RL \u2014 Kaggle shard 3 / 3\n",
+    "# IncidentCommander RL — Kaggle shard 3 / 3\n",
     "\n",
-    "**Workload:** every 3rd task starting at index 2\n",
-    "(~127 of 381 scenarios). Trains a LoRA on **microsoft/Phi-3.5-mini-instruct** using a local\n",
-    "**deepseek-ai/DeepSeek-R1-0528-Qwen3-8B** critic \u2014 both attached as Kaggle Models so they live in\n",
-    "the read-only `/kaggle/input/` mount and DO NOT eat the 20 GB working quota.\n",
+    "**Workload:** every 3rd task starting at index **2** (~127 of 381 scenarios).\n",
+    "Trains a LoRA on **Phi-3.5-mini-instruct** using a local **DeepSeek-R1-0528-Qwen3-8B** critic.\n",
     "\n",
-    "**REQUIRED \u2014 attach these 2 Kaggle Models before running** (right sidebar \u2192\n",
-    "`+ Add Input` \u2192 `Models` tab). Both are open / no access request:\n",
-    "1.  `Microsoft / phi-3`        \u2192 framework `PyTorch`       \u2192 variation `phi-3.5-mini-instruct`     \u2192 version `2`\n",
-    "2.  `deepseek-ai / deepseek-r1-0528` \u2192 framework `Transformers` \u2192 variation `deepseek-r1-0528-qwen3-8b` \u2192 version `1`\n",
+    "## REQUIRED — attach these 2 Kaggle Models before running\n",
+    "Right sidebar → `+ Add Input` → `Models` tab:\n",
+    "1. `Microsoft / phi-3` → framework `PyTorch` → variation `phi-3.5-mini-instruct` → version `2`\n",
+    "2. `deepseek-ai / deepseek-r1-0528` → framework `Transformers` → variation `deepseek-r1-0528-qwen3-8b` → version `1`\n",
     "\n",
-    "Expected mount paths after attach (cell 3 verifies):\n",
-    "- `/kaggle/input/models/Microsoft/phi-3/pytorch/phi-3.5-mini-instruct/2`\n",
-    "- `/kaggle/input/models/deepseek-ai/deepseek-r1-0528/transformers/deepseek-r1-0528-qwen3-8b/1`\n",
-    "\n",
-    "**Required notebook settings** (right-hand sidebar):\n",
+    "## Required notebook settings\n",
     "- Accelerator: `GPU T4 x2` or `GPU P100`\n",
+    "- Internet: `On`\n",
     "- Persistence: `Files only`\n",
-    "- Internet: `On` (for `git clone` and optional HF Hub upload)\n",
-    "\n",
-    "**Optional** (only if you want intermediate checkpoint upload to your HF\n",
-    "repo): Add-ons \u2192 Secrets \u2192 add `HF_TOKEN` and toggle it on.\n",
     "\n",
-    "**Output:** `/kaggle/working/adapter_kaggle3.zip` \u2014 download from\n",
-    "the sidebar after the run finishes. Combine all 3 with\n",
-    "`scripts/merge_lora_adapters.py` on your laptop.\n"
+    "**Output:** `/kaggle/working/adapter_kaggle3.zip` — download from the sidebar after the run finishes."
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {},
+   "outputs": [],
    "source": [
-    "## 1. GPU + path sanity"
+    "# === 1. Install deps + unsloth (best-effort) ===\n",
+    "# Qwen3 (in DeepSeek-R1-0528) needs transformers >= 4.51. Unsloth speeds up\n",
+    "# the actor ~2x; if its install fails on this Kaggle image we fall back to\n",
+    "# pure HF transformers automatically (train_lib.py handles both paths).\n",
+    "import subprocess, sys\n",
+    "\n",
+    "def pip(*args):\n",
+    "    return subprocess.run([sys.executable, '-m', 'pip', 'install', '-q', *args],\n",
+    "                          check=False).returncode\n",
+    "\n",
+    "rc = pip('-U', 'unsloth')\n",
+    "print('[install] unsloth rc =', rc, '(non-zero is fine, HF fallback works)')\n",
+    "\n",
+    "pip('-U',\n",
+    "    'transformers>=4.51,<4.55',\n",
+    "    'peft>=0.13,<0.16',\n",
+    "    'accelerate>=1.1,<1.5',\n",
+    "    'bitsandbytes>=0.45.5',\n",
+    "    'huggingface_hub>=0.25,<1.0',\n",
+    "    'pydantic>=2,<3',\n",
+    "    'datasets', 'sentencepiece', 'protobuf', 'safetensors')\n",
+    "print('[install] pinned stack done')"
    ]
   },
   {
    "cell_type": "code",
-   "metadata": {},
    "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
+    "# === 2. GPU sanity ===\n",
     "import subprocess\n",
     "print('--- GPU ---')\n",
     "subprocess.run(['nvidia-smi', '-L'], check=False)\n",
     "import torch\n",
-    "print('CUDA OK?', torch.cuda.is_available(), '| device:',\n",
-    "      torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'none')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 2. Install deps (Kaggle has torch/transformers preinstalled \u2014 we just pin compatible versions)"
+    "print('CUDA OK?', torch.cuda.is_available(),\n",
+    "      '| device:', torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'none')"
    ]
   },
   {
    "cell_type": "code",
-   "metadata": {},
    "execution_count": null,
-   "outputs": [],
-   "source": [
-    "# Qwen3 architecture (used inside DeepSeek-R1-0528-Qwen3-8B) requires\n",
-    "# transformers >= 4.51. Bump the whole stack to a known-compatible set.\n",
-    "%pip install -q -U \\\n",
-    "    \"transformers>=4.51,<4.55\" \\\n",
-    "    \"peft>=0.13,<0.16\" \\\n",
-    "    \"accelerate>=1.1,<1.5\" \\\n",
-    "    \"bitsandbytes>=0.45.5\" \\\n",
-    "    \"huggingface_hub>=0.25,<1.0\" \\\n",
-    "    \"pydantic>=2,<3\" \\\n",
-    "    \"datasets\" \"sentencepiece\" \"protobuf\" \"safetensors\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 3. Resolve attached Kaggle Models (read-only, no download)"
-   ]
-  },
-  {
-   "cell_type": "code",
    "metadata": {},
-   "execution_count": null,
    "outputs": [],
    "source": [
-    "import os, pathlib\n",
+    "# === 3. Verify attached Kaggle Models + suppress warning spam ===\n",
+    "import os, pathlib, shutil, warnings, logging\n",
     "\n",
     "ACTOR_PATH  = '/kaggle/input/models/Microsoft/phi-3/pytorch/phi-3.5-mini-instruct/2'\n",
     "CRITIC_PATH = '/kaggle/input/models/deepseek-ai/deepseek-r1-0528/transformers/deepseek-r1-0528-qwen3-8b/1'\n",
@@ -100,167 +82,127 @@
     "def verify(path, label):\n",
     "    p = pathlib.Path(path)\n",
     "    if not p.exists():\n",
-    "        raise SystemExit(\n",
-    "            f'{label} not found at {path}. Open the right sidebar \u2192 '\n",
-    "            f'\"+ Add Input\" \u2192 Models \u2192 attach the model with the matching '\n",
-    "            f'publisher/framework/variation/version (see the markdown above).')\n",
-    "    has_weights = any(p.glob('*.safetensors')) or any(p.glob('*.bin'))\n",
-    "    if not has_weights:\n",
-    "        raise SystemExit(f'{label} found at {path} but no *.safetensors / *.bin inside.')\n",
-    "    print(f'{label}: OK  \u2192  {path}')\n",
+    "        raise SystemExit(f'{label} not found at {path}. Attach the matching Kaggle Model.')\n",
+    "    if not (any(p.glob('*.safetensors')) or any(p.glob('*.bin'))):\n",
+    "        raise SystemExit(f'{label} found at {path} but no weight files inside.')\n",
+    "    print(f'{label}: OK -> {path}')\n",
     "\n",
     "verify(ACTOR_PATH,  'actor  (Phi-3.5-mini-instruct)')\n",
     "verify(CRITIC_PATH, 'critic (DeepSeek-R1-0528-Qwen3-8B)')\n",
     "\n",
-    "# Push HF Hub cache out of /kaggle/working so an accidental snapshot_download\n",
-    "# (e.g. by a tokenizer) writes to /tmp instead of eating the 20 GB quota.\n",
     "os.environ['HF_HOME']              = '/tmp/hf-cache'\n",
     "os.environ['HUGGINGFACE_HUB_CACHE'] = '/tmp/hf-cache'\n",
     "os.environ['TRANSFORMERS_CACHE']   = '/tmp/hf-cache'\n",
     "pathlib.Path('/tmp/hf-cache').mkdir(parents=True, exist_ok=True)\n",
     "\n",
-    "# Optional HF_TOKEN \u2014 only used if you want to upload checkpoints.\n",
+    "modules_dir = pathlib.Path('/tmp/hf-cache/modules')\n",
+    "if modules_dir.exists():\n",
+    "    shutil.rmtree(modules_dir, ignore_errors=True)\n",
+    "    print('cleared cached custom modeling code at', modules_dir)\n",
+    "\n",
     "try:\n",
     "    from kaggle_secrets import UserSecretsClient\n",
     "    os.environ['HF_TOKEN'] = UserSecretsClient().get_secret('HF_TOKEN')\n",
     "    print('HF_TOKEN attached from Kaggle Secrets')\n",
     "except Exception:\n",
-    "    print('No HF_TOKEN \u2014 that is fine, training works fully offline now.')\n",
+    "    print('No HF_TOKEN -- training runs fully offline (that is fine).')\n",
     "\n",
-    "# IMPORTANT: do NOT set TRANSFORMERS_TRUST_REMOTE_CODE here. Phi-3 (>=4.40)\n",
-    "# and Qwen3 (>=4.51) are natively supported by transformers \u2014 using the\n",
-    "# custom modeling_*.py shipped inside the Kaggle Models mount triggers an\n",
-    "# `AttributeError: 'DynamicCache' object has no attribute 'get_max_length'`\n",
-    "# because that custom code targets transformers <4.48. We force native impl\n",
-    "# by NOT enabling trust_remote_code (train_lib.py also passes it as False).\n",
-    "# Clear any previously-downloaded custom modeling code that an earlier run\n",
-    "# may have cached, otherwise from_pretrained reuses it from the cache.\n",
-    "import shutil as _sh, pathlib as _pl\n",
-    "_modules = _pl.Path('/tmp/hf-cache/modules')\n",
-    "if _modules.exists():\n",
-    "    _sh.rmtree(_modules, ignore_errors=True)\n",
-    "    print('cleared cached custom modeling code at', _modules)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 4. Clone the repo (public GitHub) \u2014 always pull latest"
+    "for pat in ('.*Caching is incompatible with gradient checkpointing.*',\n",
+    "            '.*None of the inputs have requires_grad=True.*',\n",
+    "            '.*use_reentrant parameter should be passed explicitly.*',\n",
+    "            \".*AccumulateGrad node's stream does not match.*\"):\n",
+    "    warnings.filterwarnings('ignore', message=pat)\n",
+    "\n",
+    "class _PhiFilter(logging.Filter):\n",
+    "    def filter(self, r):\n",
+    "        return 'Caching is incompatible' not in r.getMessage()\n",
+    "for n in ('transformers', 'transformers.models.phi3.modeling_phi3',\n",
+    "          'torch.utils.checkpoint'):\n",
+    "    logging.getLogger(n).addFilter(_PhiFilter())\n",
+    "print('warning filters installed')"
    ]
   },
   {
    "cell_type": "code",
-   "metadata": {},
    "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
+    "# === 4. Clone the repo (fresh every run, prints commit hash) ===\n",
     "import os, subprocess, pathlib, shutil\n",
     "WORK = '/kaggle/working/incident-commander'\n",
-    "# IMPORTANT: chdir OUT of WORK before deleting it, otherwise git clone fails\n",
-    "# with \"Unable to read current working directory\" on a re-run.\n",
     "os.chdir('/kaggle/working')\n",
-    "p = pathlib.Path(WORK)\n",
-    "if p.exists():\n",
-    "    # Wipe any stale clone from a previous session/run so we always get the\n",
-    "    # newest scripts/run_training.py + colab/train_lib.py from main.\n",
+    "if pathlib.Path(WORK).exists():\n",
     "    shutil.rmtree(WORK, ignore_errors=True)\n",
     "subprocess.run(['git', 'clone', '--depth', '1',\n",
-    "                'https://github.com/r1cksync/meta-rl-hack.git', WORK], check=True)\n",
+    "                'https://github.com/r1cksync/meta-rl-hack.git', WORK],\n",
+    "               check=True)\n",
     "os.chdir(WORK)\n",
-    "# Show the commit we are running so it is obvious in the logs.\n",
     "subprocess.run(['git', '-C', WORK, 'log', '-1', '--oneline'], check=False)\n",
     "print('cwd =', os.getcwd())"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 5. Configure run (shard, paths, env vars)"
-   ]
-  },
   {
    "cell_type": "code",
-   "metadata": {},
    "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
+    "# === 5. Configure run (shard 3 / 3) ===\n",
     "import os\n",
-    "\n",
     "os.environ['INCIDENT_COMMANDER_MOCK'] = 'true'\n",
     "os.environ['IC_ACTOR_MODEL']     = ACTOR_PATH\n",
-    "os.environ['IC_CRITIC_PROVIDER'] = 'local'        # 7B critic on the same GPU\n",
+    "os.environ['IC_CRITIC_PROVIDER'] = 'local'\n",
     "os.environ['IC_CRITIC_MODEL']    = CRITIC_PATH\n",
-    "os.environ['IC_TASK_MODE']       = 'all'           # full 381 corpus\n",
+    "os.environ['IC_TASK_MODE']       = 'all'\n",
     "os.environ['IC_TASK_SHARDS']     = '3'\n",
     "os.environ['IC_TASK_SHARD']      = '2'\n",
-    "os.environ['IC_TOTAL_UPDATES']   = '60'            # ~6h on T4 / P100\n",
+    "os.environ['IC_TOTAL_UPDATES']   = '60'\n",
     "os.environ['IC_ROLLOUTS']        = '3'\n",
     "os.environ['IC_MAX_STEPS']       = '12'\n",
     "os.environ['IC_CKPT_EVERY']      = '15'\n",
     "os.environ['IC_RUN_NAME']        = 'kaggle3'\n",
-    "\n",
     "print('actor :', os.environ['IC_ACTOR_MODEL'])\n",
     "print('critic:', os.environ['IC_CRITIC_MODEL'])\n",
     "print('shard :', os.environ['IC_TASK_SHARD'], '/', os.environ['IC_TASK_SHARDS'])"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 6. Train"
-   ]
-  },
   {
    "cell_type": "code",
-   "metadata": {},
    "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
-    "# The training script runs to completion. tqdm progress + ETA are streamed\n",
-    "# to stdout. Kaggle truncates very long outputs \u2014 adapter checkpoints are\n",
-    "# always written to /kaggle/working/incident-commander/colab/logs/ regardless.\n",
+    "# === 6. Train ===\n",
     "import subprocess, sys\n",
-    "result = subprocess.run([sys.executable, 'scripts/run_training.py'],\n",
-    "                         check=False)\n",
+    "result = subprocess.run([sys.executable, 'scripts/run_training.py'], check=False)\n",
     "print('exit code:', result.returncode)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 7. Package outputs for download"
-   ]
-  },
   {
    "cell_type": "code",
-   "metadata": {},
    "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
+    "# === 7. Package outputs for download ===\n",
     "import shutil, glob, pathlib\n",
-    "\n",
     "LOGS = pathlib.Path('colab/logs')\n",
     "finals = sorted(LOGS.glob('adapter_kaggle3_final'))\n",
     "ckpts  = sorted(LOGS.glob('adapter_kaggle3_u*'))\n",
-    "keep   = (finals or ckpts)\n",
-    "assert keep, 'No adapter directories found \u2014 check the training cell output for errors.'\n",
+    "keep = (finals or ckpts)\n",
+    "assert keep, 'No adapter directories found -- check the training cell output.'\n",
     "src = keep[-1]\n",
     "print('packaging', src)\n",
-    "\n",
     "dst = pathlib.Path('/kaggle/working/adapter_kaggle3.zip')\n",
     "shutil.make_archive(str(dst.with_suffix('')), 'zip', root_dir=src)\n",
     "print('zipped to', dst, 'size:', dst.stat().st_size, 'bytes')\n",
-    "\n",
-    "# Also copy the JSON training log for plotting on your laptop.\n",
     "for j in glob.glob('colab/logs/training_kaggle3*.json'):\n",
     "    shutil.copy(j, '/kaggle/working/')\n",
     "print('files in /kaggle/working/:')\n",
     "for f in sorted(pathlib.Path('/kaggle/working/').iterdir()):\n",
-    "    if f.name == 'hf-cache': continue   # don't list the model cache\n",
+    "    if f.name == 'hf-cache':\n",
+    "        continue\n",
     "    print(' ', f.name, f.stat().st_size if f.is_file() else '<dir>')"
    ]
   },
@@ -270,9 +212,8 @@
    "source": [
     "## Done\n",
     "\n",
-    "Download `adapter_kaggle3.zip` from the **Output** tab on the\n",
-    "right.  Repeat for the other two shards (notebooks 2 and 3), then on your\n",
-    "laptop run:\n",
+    "Download `adapter_kaggle3.zip` from the **Output** tab on the right.\n",
+    "Run shard 2 and shard 3 in parallel browser tabs, then on your laptop:\n",
     "\n",
     "```powershell\n",
     "python scripts/merge_lora_adapters.py `\n",
@@ -280,8 +221,7 @@
     "    --output ./adapter_merged\n",
     "```\n",
     "\n",
-    "The merged adapter loads with the standard `peft` API on top of\n",
-    "`microsoft/Phi-3.5-mini-instruct`.\n"
+    "The merged adapter loads with the standard `peft` API on top of `microsoft/Phi-3.5-mini-instruct`."
    ]
   }
  ],