Add transformers-backend GRPO loader (no triton/Unsloth dep) + fix Jobs deps

The first HF Jobs validation hit two image-level issues:
* pip's resolution pulled torch 2.11+cu130 into a CUDA-12.4 image, so
bitsandbytes failed to load (libnvJitLink.so.13 missing)
* Unsloth requires triton, which JIT-compiles a CUDA helper at runtime
and needs `cc` — the slim pytorch image doesn't ship one

Changes:
* grpo_train.py: add load_transformers_model() (plain transformers +
peft + bnb 4-bit) and load_model() dispatcher with auto-fallback
* CLI flag --backend {auto,unsloth,transformers}
* scripts/jobs_grpo_train.sh: pin torch 2.4.1+cu124, bitsandbytes 0.43.3,
upper-bound transformers/trl/peft/datasets/accelerate to versions that
ship CUDA-12 wheels; default GRPO_BACKEND=transformers so triton
isn't needed in the Job container

110/110 tests still green; new code paths only execute on the GPU side.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

scripts/jobs_grpo_train.sh

@@ -34,18 +34,24 @@ echo "==[chaosops]== GPU info"
 nvidia-smi | head -3 || true
 
 echo "==[chaosops]== installing python deps"
+# Pin torch/torchvision to the image's CUDA 12.4 wheels so transformers/peft
+# don't get pulled into a CUDA-13 wheel set (the bitsandbytes mismatch we
+# saw in the first validation run). bitsandbytes is pinned to the last
+# CUDA-12 compatible release.
 pip install --quiet --upgrade pip
+pip install --quiet --no-deps \
+  "torch==2.4.1+cu124" \
+  --index-url https://download.pytorch.org/whl/cu124 || true
 pip install --quiet \
-  "trl>=0.10.0" \
-  "peft>=0.12.0" \
-  "datasets>=2.20.0" \
-  "accelerate>=0.33.0" \
-  "transformers>=4.44.0" \
-  "bitsandbytes" \
+  "transformers>=4.44.0,<4.50.0" \
+  "trl>=0.10.0,<0.15.0" \
+  "peft>=0.12.0,<0.14.0" \
+  "datasets>=2.20.0,<3.0.0" \
+  "accelerate>=0.33.0,<0.36.0" \
+  "bitsandbytes==0.43.3" \
   "huggingface_hub>=0.24.0" \
   "pydantic>=2.0.0" \
-  "matplotlib>=3.7.0" \
-  "unsloth"
+  "matplotlib>=3.7.0"
 
 echo "==[chaosops]== preparing source tree"
 mkdir -p /workspace
@@ -55,9 +61,12 @@ export PYTHONPATH="/tmp:${PYTHONPATH:-}"
 cd /workspace
 mkdir -p "${OUTPUT_DIR}"
 
-echo "==[chaosops]== launching GRPO ($GRPO_EPISODES episodes, group=$GRPO_GROUP_SIZE, lora_rank=$GRPO_LORA_RANK)"
+GRPO_BACKEND="${GRPO_BACKEND:-transformers}"
+
+echo "==[chaosops]== launching GRPO (backend=$GRPO_BACKEND, $GRPO_EPISODES episodes, group=$GRPO_GROUP_SIZE, lora_rank=$GRPO_LORA_RANK)"
 python -m chaosops.train.grpo_train \
   --model-name "${GRPO_MODEL}" \
+  --backend "${GRPO_BACKEND}" \
   --total-episodes "${GRPO_EPISODES}" \
   --group-size "${GRPO_GROUP_SIZE}" \
   --log-every "${GRPO_LOG_EVERY}" \

train/grpo_train.py

@@ -317,7 +317,11 @@ def load_unsloth_model(
     load_in_4bit: bool = True,
     lora_rank: int = 32,
 ):
-    """Load a base LLM with Unsloth + LoRA. Returns ``(model, tokenizer)``."""
+    """Load a base LLM with Unsloth + LoRA. Returns ``(model, tokenizer)``.
+
+    Requires triton + a C compiler at runtime; if either is missing,
+    fall back to :func:`load_transformers_model`.
+    """
     from unsloth import FastLanguageModel  # type: ignore[import-not-found]
 
     model, tokenizer = FastLanguageModel.from_pretrained(
@@ -345,6 +349,117 @@ def load_unsloth_model(
     return model, tokenizer
 
 
+def load_transformers_model(
+    model_name: str,
+    *,
+    max_seq_length: int = 2048,
+    load_in_4bit: bool = True,
+    lora_rank: int = 32,
+):
+    """Plain ``transformers + peft`` model loader — no Unsloth/triton dep.
+
+    Used when the runtime image doesn't ship triton/cc (most lightweight
+    CUDA images). Slightly slower per step than Unsloth but works on any
+    standard PyTorch image.
+    """
+    import torch  # type: ignore[import-not-found]
+    from peft import LoraConfig, get_peft_model  # type: ignore[import-not-found]
+    from transformers import (  # type: ignore[import-not-found]
+        AutoModelForCausalLM,
+        AutoTokenizer,
+    )
+
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    if tokenizer.pad_token_id is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    load_kwargs: dict[str, Any] = {}
+    if load_in_4bit:
+        try:
+            from transformers import BitsAndBytesConfig  # type: ignore[import-not-found]
+
+            load_kwargs["quantization_config"] = BitsAndBytesConfig(
+                load_in_4bit=True,
+                bnb_4bit_quant_type="nf4",
+                bnb_4bit_use_double_quant=True,
+                bnb_4bit_compute_dtype=torch.float16,
+            )
+        except Exception:
+            # bnb unavailable — fall back to fp16 full-precision LoRA.
+            load_kwargs["torch_dtype"] = torch.float16
+    else:
+        load_kwargs["torch_dtype"] = torch.float16
+
+    if torch.cuda.is_available():
+        load_kwargs["device_map"] = {"": 0}
+
+    base = AutoModelForCausalLM.from_pretrained(model_name, **load_kwargs)
+    lora_cfg = LoraConfig(
+        r=lora_rank,
+        lora_alpha=lora_rank,
+        lora_dropout=0.0,
+        bias="none",
+        target_modules=[
+            "q_proj",
+            "k_proj",
+            "v_proj",
+            "o_proj",
+            "gate_proj",
+            "up_proj",
+            "down_proj",
+        ],
+        task_type="CAUSAL_LM",
+    )
+    model = get_peft_model(base, lora_cfg)
+    return model, tokenizer
+
+
+def load_model(
+    model_name: str,
+    *,
+    backend: str = "auto",
+    max_seq_length: int = 2048,
+    load_in_4bit: bool = True,
+    lora_rank: int = 32,
+):
+    """Dispatch to the requested loader, with auto-fallback.
+
+    ``backend`` ∈ ``{"auto", "unsloth", "transformers"}``. ``auto`` tries
+    Unsloth first and falls back to transformers if the import fails or
+    the runtime can't satisfy triton's C-compiler dep.
+    """
+    if backend == "transformers":
+        return load_transformers_model(
+            model_name,
+            max_seq_length=max_seq_length,
+            load_in_4bit=load_in_4bit,
+            lora_rank=lora_rank,
+        )
+    if backend == "unsloth":
+        return load_unsloth_model(
+            model_name,
+            max_seq_length=max_seq_length,
+            load_in_4bit=load_in_4bit,
+            lora_rank=lora_rank,
+        )
+    # auto
+    try:
+        return load_unsloth_model(
+            model_name,
+            max_seq_length=max_seq_length,
+            load_in_4bit=load_in_4bit,
+            lora_rank=lora_rank,
+        )
+    except Exception as exc:
+        print(f"[grpo_train] Unsloth path failed ({exc!r}); using transformers")
+        return load_transformers_model(
+            model_name,
+            max_seq_length=max_seq_length,
+            load_in_4bit=load_in_4bit,
+            lora_rank=lora_rank,
+        )
+
+
 def make_generate_fn(
     model, tokenizer, *, max_new_tokens: int = 96, temperature: float = 0.7
 ) -> GenerateFn:
@@ -588,13 +703,21 @@ def _parse_args() -> argparse.Namespace:
         default=DifficultyTier.EASY.value,
         choices=[t.value for t in DifficultyTier],
     )
+    parser.add_argument(
+        "--backend",
+        type=str,
+        default="auto",
+        choices=["auto", "unsloth", "transformers"],
+        help="Model loader. 'auto' tries Unsloth, falls back to transformers.",
+    )
     return parser.parse_args()
 
 
 def main() -> None:
     args = _parse_args()
-    model, tokenizer = load_unsloth_model(
+    model, tokenizer = load_model(
         args.model_name,
+        backend=args.backend,
         max_seq_length=args.max_seq_length,
         lora_rank=args.lora_rank,
     )