{ "cells": [ { "cell_type": "markdown", "id": "af2accab", "metadata": {}, "source": [ "# EICC GRPO Training Notebook (Theme #3.1 World Modeling)\n", "\n", "Colab / HF-Space-ready notebook. **Just run the cells top-to-bottom** — the default flow trains and evaluates against the **VM environment (Mode 3)**, which is the harder, more realistic lane. The Mock environment (Mode 2) lane is provided as commented-out alternatives in the same cells in case you want to compare.\n", "\n", "## Two lanes, one trained checkpoint\n", "\n", "- **VM environment (Mode 3) — default lane**: same `/reset`+`/step` API, routed to a **live container cluster** running on `127.0.0.1` via `python -m sandbox.launch_no_docker`. This is what the default cells below run.\n", "- **Mock environment (Mode 2) — optional lane**: deterministic simulated backend, fully in-process. Available as commented lines you can uncomment if you want.\n", "\n", "Both lanes evaluate the **same** trained adapter from Step 5, so the gap between them is a direct sim→VM transfer measurement.\n", "\n", "## Run order (default = VM env)\n", "\n", "| Step | What it does |\n", "|---|---|\n", "| 1 | Clone repo |\n", "| 2 | Install training deps (Unsloth + TRL + peft + bitsandbytes + fastapi/uvicorn) |\n", "| 3 | Dry-run sanity check |\n", "| ⚠️ | **Start `python -m sandbox.launch_no_docker` in a SEPARATE terminal** (cell right above Step 4) |\n", "| 4 | (Optional) Mock-env baseline — the default sandbox baseline is produced by Step 6 below |\n", "| 5 | GRPO training (~1 hour quick profile) — produces `artifacts/train/trained_adapter/` |\n", "| 6 | Compare baseline vs trained on the **VM env** (default; writes both reports in one call) |\n", "| 7 | Inspect reports + `policy_used` provenance |\n", "| 8 | Display 3 mentor curves (easy / medium / hard) |\n", "\n", "## Where outputs go\n", "\n", "- VM env (default) → `artifacts/eval_sandbox/` (baseline_report.json, trained_report.json, reward_curve_{easy,medium,hard}.png)\n", "- Mock env (optional) → `artifacts/eval_simple/` (same filenames)\n", "- Training → `artifacts/train/trained_adapter/` + `artifacts/train/reward_history.json`\n", "\n", "For final submission, copy curated files into `results/sandbox/`, `results/simple/`, and `results/training/` (those folders are tracked in git).\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "867af87d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Cloning into 'OpenEnv-Customer-Support'...\n", "remote: Enumerating objects: 432, done.\u001b[K\n", "remote: Counting objects: 100% (103/103), done.\u001b[K\n", "remote: Compressing objects: 100% (76/76), done.\u001b[K\n", "remote: Total 432 (delta 37), reused 72 (delta 25), pack-reused 329 (from 1)\u001b[K\n", "Receiving objects: 100% (432/432), 571.79 KiB | 27.23 MiB/s, done.\n", "Resolving deltas: 100% (188/188), done.\n", "/data/OpenEnv-Customer-Support\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/home/user/miniconda/lib/python3.10/site-packages/IPython/core/magics/osm.py:417: UserWarning: This is now an optional IPython functionality, setting dhist requires you to install the `pickleshare` library.\n", " self.shell.db['dhist'] = compress_dhist(dhist)[-100:]\n" ] } ], "source": [ "# Step 1: Clone your repo\n", "!git clone https://github.com/anujkamaljain/OpenEnv-Customer-Support.git\n", "%cd OpenEnv-Customer-Support" ] }, { "cell_type": "code", "execution_count": 2, "id": "77d87c12", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Note: you may need to restart the kernel to use updated packages.\n", "Note: you may need to restart the kernel to use updated packages.\n", "Note: you may need to restart the kernel to use updated packages.\n", "Note: you may need to restart the kernel to use updated packages.\n" ] } ], "source": [ "# Step 2: Install training dependencies (clean path)\n", "# If Colab asks for runtime restart, restart and rerun from Step 1.\n", "%pip install -q -U pip setuptools wheel jedi\n", "%pip install -q -U \"pydantic>=2.12,<3\" \"click<8.2\"\n", "%pip install -q -U \"trl==0.15.2\" \"transformers==4.51.3\" datasets peft bitsandbytes accelerate matplotlib llm-blender mergekit\n", "%pip install -q -U unsloth" ] }, { "cell_type": "code", "execution_count": 3, "id": "46380f9e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "🦥 Unsloth: Will patch your computer to enable 2x faster free finetuning.\n", "🦥 Unsloth Zoo will now patch everything to make training faster!\n", "unsloth: 2026.4.8\n", "trl: 0.24.0\n", "transformers: 4.57.6\n", "[train] iteration=1 episodes=1 avg_step_reward=0.0055\n", "[dry-run] collected_rows=40 iterations=1 episodes=1\n" ] } ], "source": [ "# Step 3: Verify training stack + environment (quick sanity check)\n", "import importlib.metadata as im\n", "from unsloth import FastLanguageModel\n", "from trl import GRPOConfig, GRPOTrainer\n", "\n", "print(\"unsloth:\", im.version(\"unsloth\"))\n", "print(\"trl:\", im.version(\"trl\"))\n", "print(\"transformers:\", im.version(\"transformers\"))\n", "\n", "!python train.py --iterations 1 --episodes 1 --k 2 --dry-run" ] }, { "cell_type": "markdown", "id": "feec155c", "metadata": {}, "source": [ "## ⚠️ Before Step 4 — Start the VM cluster (default lane)\n", "\n", "The default flow in this notebook trains and evaluates against the **VM environment (Mode 3)**, so the live cluster needs to be running before Step 4 / Step 6.\n", "\n", "**Open a second terminal on the same machine / HF Space and run:**\n", "\n", "```bash\n", "pip install -U fastapi uvicorn # one-time\n", "python -m sandbox.launch_no_docker # leave running\n", "```\n", "\n", "Wait until that terminal prints:\n", "\n", "```\n", "[sandbox-no-docker] all services listening (Ctrl+C to stop).\n", "```\n", "\n", "Only **after** that, continue to Step 4 below.\n", "\n", "> **Just want the Mock env (Mode 2) instead?** You can skip this prereq — every cell below has a commented-out Mock-env command you can uncomment. Mock env runs entirely in-process and needs no second terminal.\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "2157d4c6", "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{\n", " \"avg_normalized_reward\": 0.0,\n", " \"avg_raw_reward\": -2.0800000000000005,\n", " \"sla_compliance_rate\": 0.0,\n", " \"tool_efficiency\": 1.0,\n", " \"root_cause_accuracy\": 0.0,\n", " \"long_horizon_consistency\": 0.0,\n", " \"skill_scores\": {\n", " \"investigation_before_action\": 1.0,\n", " \"kb_cross_verification\": 1.0,\n", " \"policy_checking\": 0.0,\n", " \"stakeholder_proactivity\": 0.0,\n", " \"root_cause_accuracy\": 0.0,\n", " \"tone_matching\": 0.0,\n", " \"resource_efficiency\": 1.0,\n", " \"red_herring_dismissal\": 0.0\n", " },\n", " \"per_difficulty\": {\n", " \"easy\": 0.0,\n", " \"medium\": 0.0,\n", " \"hard\": 0.0,\n", " \"nightmare\": 0.0\n", " },\n", " \"reward_history\": [\n", " 0.0,\n", " 0.0,\n", " 0.0,\n", " 0.0,\n", " 0.0,\n", " 0.0,\n", " 0.0,\n", " 0.0,\n", " 0.0,\n", " 0.0,\n", " 0.0,\n", " 0.0,\n", " 0.0,\n", " 0.0,\n", " 0.0,\n", " 0.0,\n", " 0.0,\n", " 0.0,\n", " 0.0,\n", " 0.0\n", " ],\n", " \"raw_reward_history\": [\n", " -1.28,\n", " -1.28,\n", " -1.28,\n", " -1.28,\n", " -1.28,\n", " -1.68,\n", " -1.68,\n", " -1.68,\n", " -1.68,\n", " -1.68,\n", " -2.48,\n", " -2.48,\n", " -2.48,\n", " -2.48,\n", " -2.48,\n", " -2.88,\n", " -2.88,\n", " -2.88,\n", " -2.88,\n", " -2.88\n", " ],\n", " \"per_difficulty_reward_history\": {\n", " \"easy\": [\n", " 0.0,\n", " 0.0,\n", " 0.0,\n", " 0.0,\n", " 0.0\n", " ],\n", " \"medium\": [\n", " 0.0,\n", " 0.0,\n", " 0.0,\n", " 0.0,\n", " 0.0\n", " ],\n", " \"hard\": [\n", " 0.0,\n", " 0.0,\n", " 0.0,\n", " 0.0,\n", " 0.0\n", " ],\n", " \"nightmare\": [\n", " 0.0,\n", " 0.0,\n", " 0.0,\n", " 0.0,\n", " 0.0\n", " ]\n", " },\n", " \"behavior_examples\": [],\n", " \"policy_used\": \"baseline\",\n", " \"episodes_per_difficulty\": 5\n", "}\n" ] } ], "source": [ "# Step 4 (OPTIONAL): Mock-env baseline (Lane A only)\n", "#\n", "# Default flow: SKIP this cell. Step 6 below runs `--policy compare --sandbox`\n", "# which writes BOTH baseline_report.json and trained_report.json to\n", "# artifacts/eval_sandbox/ in a single call — so the sandbox baseline is\n", "# produced there automatically.\n", "#\n", "# This cell only runs the Mock-env (Mode 2) baseline, which is useful if you\n", "# also want a Lane A reference number. It was executed once in this run, hence\n", "# the artifacts/eval_simple/baseline_report.json output below.\n", "!python evaluate.py --policy baseline --episodes-per-difficulty 5 --output-dir artifacts/eval_simple\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "08ad923e", "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[train] iteration=1 episodes=15 avg_step_reward=-0.0320\n", "[train] iteration=2 episodes=15 avg_step_reward=-0.0320\n", "[train] iteration=3 episodes=15 avg_step_reward=-0.0320\n", "[train] iteration=4 episodes=15 avg_step_reward=-0.0320\n", "[train] iteration=5 episodes=15 avg_step_reward=0.0203\n", "[train] iteration=6 episodes=15 avg_step_reward=0.0203\n", "[train] iteration=7 episodes=15 avg_step_reward=0.0203\n", "[train] iteration=8 episodes=15 avg_step_reward=0.0203\n", "[train] iteration=9 episodes=15 avg_step_reward=0.0096\n", "[train] iteration=10 episodes=15 avg_step_reward=0.0096\n", "🦥 Unsloth: Will patch your computer to enable 2x faster free finetuning.\n", "🦥 Unsloth Zoo will now patch everything to make training faster!\n", "==((====))== Unsloth 2026.4.8: Fast Qwen2 patching. Transformers: 4.57.6.\n", " \\\\ /| NVIDIA A10G. Num GPUs = 1. Max memory: 22.301 GB. Platform: Linux.\n", "O^O/ \\_/ \\ Torch: 2.10.0+cu128. CUDA: 8.6. CUDA Toolkit: 12.8. Triton: 3.6.0\n", "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.35. FA2 = False]\n", " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n", "model.safetensors: 100%|████████████████████| 2.36G/2.36G [00:04<00:00, 509MB/s]\n", "generation_config.json: 100%|██████████████████| 271/271 [00:00<00:00, 4.48MB/s]\n", "tokenizer_config.json: 100%|███████████████| 7.36k/7.36k [00:00<00:00, 65.7MB/s]\n", "vocab.json: 100%|██████████████████████████| 2.78M/2.78M [00:00<00:00, 35.7MB/s]\n", "merges.txt: 100%|██████████████████████████| 1.67M/1.67M [00:00<00:00, 67.2MB/s]\n", "added_tokens.json: 100%|███████████████████████| 605/605 [00:00<00:00, 6.06MB/s]\n", "special_tokens_map.json: 100%|█████████████████| 614/614 [00:00<00:00, 9.98MB/s]\n", "tokenizer.json: 100%|██████████████████████| 11.4M/11.4M [00:00<00:00, 53.6MB/s]\n", "unsloth/qwen2.5-3b-instruct-unsloth-bnb-4bit does not have a padding token! Will use pad_token = <|PAD_TOKEN|>.\n", "Unsloth 2026.4.8 patched 36 layers with 36 QKV layers, 36 O layers and 36 MLP layers.\n", "==((====))== Unsloth - 2x faster free finetuning | Num GPUs used = 1\n", " \\\\ /| Num examples = 4,620 | Num Epochs = 1 | Total steps = 2,310\n", "O^O/ \\_/ \\ Batch size per device = 4 | Gradient accumulation steps = 2\n", "\\ / Data Parallel GPUs = 1 | Total batch size (4 x 2 x 1) = 8\n", " \"-____-\" Trainable parameters = 29,933,568 of 3,115,872,256 (0.96% trained)\n", " 0%| | 0/2310 [00:00 AFTER TRAINING\n", "============================================================\n", "Normalized Reward: 0.000 -> 0.104 (1041.7x)\n", "Raw Cumulative: -2.080 -> -0.568\n", "SLA Compliance: 0% -> 0%\n", "Root Cause Accuracy:0% -> 25%\n", "Tool Efficiency: 1.00 -> 0.49\n", "Long-Horizon Consistency: 0.00 -> 0.19\n", " investigation_before_action: 100% -> 50%\n", " kb_cross_verification: 100% -> 50%\n", " policy_checking: 0% -> 100%\n", " stakeholder_proactivity: 0% -> 50%\n", " root_cause_accuracy: 0% -> 25%\n", " tone_matching: 0% -> 75%\n", " resource_efficiency: 100% -> 100%\n", " red_herring_dismissal: 0% -> 25%\n", "[train] trained_report.policy_used=trained_checkpoint\n" ] } ], "source": [ "# Step 5: GRPO training (BOTH lanes share this checkpoint)\n", "#\n", "# Quick profile (~1 hour on A10/T4). After this, artifacts/train/trained_adapter/\n", "# exists, and both Step 6 (VM env, default) and the optional Mock-env path\n", "# can evaluate the SAME checkpoint.\n", "#\n", "# Step 5a (commented): faster quick profile\n", "# !python -u train.py --iterations 6 --episodes 8 --k 2 --eval-episodes 1 --seed 7 --max-completion-length 96 --output-dir artifacts/train\n", "\n", "# Step 5b: STRONGER profile (this is what was actually executed below)\n", "!python -u train.py --iterations 10 --episodes 15 --k 4 --eval-episodes 1 --seed 7 --max-completion-length 96 --output-dir artifacts/train\n" ] }, { "cell_type": "code", "execution_count": 14, "id": "26597aaf", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Skipping import of cpp extensions due to incompatible torch version. Please upgrade to torch >= 2.11.0 (found 2.10.0+cu128).\n", "Loading checkpoint shards: 100%|██████████████████| 2/2 [00:04<00:00, 2.38s/it]\n", "The following generation flags are not valid and may be ignored: ['temperature', 'top_p', 'top_k']. Set `TRANSFORMERS_VERBOSITY=info` for more details.\n", "============================================================\n", "BEFORE TRAINING -> AFTER TRAINING\n", "============================================================\n", "Normalized Reward: 0.000 -> 0.214 (2138.0x)\n", "Raw Cumulative: -2.080 -> -0.220\n", "SLA Compliance: 0% -> 0%\n", "Root Cause Accuracy:0% -> 33%\n", "Tool Efficiency: 1.00 -> 0.70\n", "Long-Horizon Consistency: 0.00 -> 0.25\n", " investigation_before_action: 100% -> 83%\n", " kb_cross_verification: 100% -> 58%\n", " policy_checking: 0% -> 92%\n", " stakeholder_proactivity: 0% -> 33%\n", " root_cause_accuracy: 0% -> 33%\n", " tone_matching: 0% -> 58%\n", " resource_efficiency: 100% -> 100%\n", " red_herring_dismissal: 0% -> 17%\n", "\n", "Structured behavior diffs:\n", "- Investigation strategy: check_monitoring-before-fix 100% -> 83%.\n", "- KB trust vs verification: kb_cross_verification 100% -> 58%.\n", "- Long-horizon execution: consistency 0.00 -> 0.25.\n" ] } ], "source": [ "# Step 6: Compare baseline vs trained on VM env (Mode 3) — DEFAULT LANE\n", "#\n", "# REQUIRES: `python -m sandbox.launch_no_docker` running in another terminal\n", "# (see prereq cell above). Mentor-friendly stage curves: --episodes-per-difficulty\n", "# controls how many stages are plotted on each easy/medium/hard graph.\n", "#\n", "# Writes:\n", "# artifacts/eval_sandbox/baseline_report.json\n", "# artifacts/eval_sandbox/trained_report.json\n", "# artifacts/eval_sandbox/reward_curve_{easy,medium,hard}.png\n", "#\n", "# --- OPTIONAL: Mock-env (Lane A) compare. Uncomment if you also want Lane A. ---\n", "# !python -u evaluate.py --policy compare --compare-trained-policy trained_checkpoint --checkpoint-dir artifacts/train/trained_adapter --checkpoint-base-model Qwen/Qwen2.5-3B-Instruct --episodes-per-difficulty 7 --plot --output-dir artifacts/eval_simple\n", "\n", "!OPENENV_SANDBOX_CLUSTER_URL=http://127.0.0.1 OPENENV_SANDBOX_CHAOS_URL=http://127.0.0.1:6660 python -u evaluate.py --policy compare --compare-trained-policy trained_checkpoint --checkpoint-dir artifacts/train/trained_adapter --checkpoint-base-model Qwen/Qwen2.5-3B-Instruct --episodes-per-difficulty 3 --plot --sandbox --output-dir artifacts/eval_sandbox\n" ] }, { "cell_type": "code", "execution_count": 15, "id": "6d39f940", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Track: sandbox\n", "policy_used: trained_checkpoint\n", "Baseline raw: -2.0799999999999996 norm: 0.0\n", "Trained raw: -0.22000000000000006 norm: 0.2137962962962963\n" ] } ], "source": [ "# Step 7: Inspect reports\n", "#\n", "# TRACK = \"sandbox\" -> VM env (Mode 3) results from Step 6 (default)\n", "# TRACK = \"simple\" -> Mock env (Mode 2) results from optional Mock path\n", "import json\n", "from pathlib import Path\n", "TRACK = \"sandbox\" # change to \"simple\" only if you uncommented the Mock-env compare\n", "report_dir = Path(\"artifacts/eval_simple\" if TRACK == \"simple\" else \"artifacts/eval_sandbox\")\n", "\n", "b = json.loads((report_dir / \"baseline_report.json\").read_text())\n", "t = json.loads((report_dir / \"trained_report.json\").read_text())\n", "print(\"Track:\", TRACK)\n", "print(\"policy_used:\", t.get(\"policy_used\"))\n", "print(\"Baseline raw:\", b[\"avg_raw_reward\"], \"norm:\", b[\"avg_normalized_reward\"])\n", "print(\"Trained raw:\", t[\"avg_raw_reward\"], \"norm:\", t[\"avg_normalized_reward\"])\n" ] }, { "cell_type": "code", "execution_count": 16, "id": "ba427b61", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "reward_curve_easy.png\n" ] }, { "data": { "image/png": "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", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "reward_curve_medium.png\n" ] }, { "data": { "image/png": "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", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "reward_curve_hard.png\n" ] }, { "data": { "image/png": "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", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Step 8: Display mentor graphs (easy/medium/hard)\n", "#\n", "# TRACK = \"sandbox\" -> VM env curves from Step 6 (default)\n", "# TRACK = \"simple\" -> Mock env curves from the optional Mock-env compare\n", "from pathlib import Path\n", "from IPython.display import Image, display\n", "\n", "TRACK = \"sandbox\" # change to \"simple\" only if you uncommented the Mock-env compare\n", "curve_dir = Path(\"artifacts/eval_simple\" if TRACK == \"simple\" else \"artifacts/eval_sandbox\")\n", "curves = [\n", " curve_dir / \"reward_curve_easy.png\",\n", " curve_dir / \"reward_curve_medium.png\",\n", " curve_dir / \"reward_curve_hard.png\",\n", "]\n", "missing = [str(p) for p in curves if not p.exists()]\n", "if missing:\n", " print(\"Run Step 6 with --plot first. Missing:\")\n", " for p in missing:\n", " print(\" -\", p)\n", "else:\n", " for curve in curves:\n", " print(curve.name)\n", " display(Image(filename=str(curve)))\n" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.8" } }, "nbformat": 4, "nbformat_minor": 5 }