Space T4 + real HF path: split requirements, GPU defaults, API reset behavior

- Add requirements-core.txt for slim Docker; root requirements.txt pulls core + PyTorch/TRL/PEFT for HF GPU Spaces.
- README Space frontmatter suggested_hardware t4-small; document secrets FORGE_DETERMINISTIC_RESET and FORGE_DEFAULT_PROVIDER.
- config: unset CODE_PROVIDER_MODE defaults to custom_hf when CUDA else offline.
- app: GPU-first provider order, default custom_hf on CUDA, higher episode caps on GPU, clearer provider info, fix coach lesson line duplication.
- trainer: benchmark respects requested episode count (no forced minimum of 20).
- api_server: varied tasks per reset unless FORGE_DETERMINISTIC_RESET=1.
- .env.example aligned with GPU Space defaults.

Made-with: Cursor

.env.example

@@ -15,8 +15,14 @@ OPENROUTER_API_KEY=
 OPENROUTER_MODEL=qwen/qwen2.5-coder-7b-instruct
 OPENROUTER_BASE_URL=https://openrouter.ai/api/v1
 
-# Policy "model": offline (default, instant deterministic baseline) | auto | custom_hf | nim | openrouter
-CODE_PROVIDER_MODE=offline
+# Policy "model": unset = auto (custom_hf if CUDA, else offline) | auto | custom_hf | nim | openrouter | offline
+CODE_PROVIDER_MODE=custom_hf
+
+# Optional: force Gradio default provider (custom_hf | offline | auto | nim | openrouter)
+# FORGE_DEFAULT_PROVIDER=custom_hf
+
+# API: set to 1 for identical first-task RNG each POST /reset (harness reproducibility)
+# FORGE_DETERMINISTIC_RESET=0
 
 # Cap local HF inference wait (seconds); increase on GPU machines if loads are slow.
 ROUTER_HF_TIMEOUT_SEC=90

Dockerfile

@@ -13,11 +13,11 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     curl \
     && rm -rf /var/lib/apt/lists/*
 
-# Slim image: Gradio + API + OpenEnv (no PyTorch). Builds in minutes — same stack as HF CPU Space.
-# For training inside Docker: docker build -f Dockerfile.train -t forge:train .
-COPY requirements.txt ./
+# Slim image: Gradio + API + OpenEnv (no PyTorch). Builds in minutes.
+# For GPU + local HF inside Docker: docker build -f Dockerfile.train -t forge:train .
+COPY requirements-core.txt ./
 RUN pip install --upgrade pip && \
-    pip install -r requirements.txt
+    pip install -r requirements-core.txt
 
 COPY . .
 

Dockerfile.train

@@ -15,7 +15,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     curl \
     && rm -rf /var/lib/apt/lists/*
 
-COPY requirements.txt requirements-train.txt ./
+COPY requirements-core.txt requirements.txt requirements-train.txt ./
 RUN pip install --upgrade pip && \
     pip install -r requirements.txt -r requirements-train.txt
 

README.md

@@ -9,8 +9,8 @@ sdk_version: 5.25.0
 python_version: 3.11
 app_file: app.py
 pinned: false
-# Hint for duplicators; does not upgrade your Space by itself. CPU-friendly demo (no PyTorch in requirements.txt).
-suggested_hardware: cpu-basic
+# Target: NVIDIA T4 Space (local HF inference). CPU-only duplicators: switch hardware in Space Settings and use provider "offline".
+suggested_hardware: t4-small
 ---
 
 # FORGE-v4 — Adversarial self-improvement for robust code generation
@@ -43,11 +43,11 @@ suggested_hardware: cpu-basic
 | **Command / security cheat sheet** | [guide.md](guide.md) |
 | **Video / slides** | YouTube demo placeholder: https://youtube.com/watch?v=YOUR_DEMO_VIDEO_ID |
 
-### Hugging Face Space (CPU-only)
+### Hugging Face Space (GPU — T4 recommended)
 
-- This repo’s **Space README** sets **`suggested_hardware: cpu-basic`** (see [Spaces config](https://huggingface.co/docs/hub/spaces-config-reference)). **Pick CPU hardware in the Space Settings UI** if you are not on GPU.
-- **`requirements.txt`** is intentionally **light** (no PyTorch / bitsandbytes) so CPU Spaces **build and start** reliably.
-- For a **CPU-only** Space, prefer Gradio provider **`offline`** (instant deterministic baseline) or **`auto`** with **NIM / OpenRouter** keys; local **`custom_hf`** loads PyTorch and a 1.5B+LoRA stack and may **OOM or time out** on free CPU.
+- This repo’s **Space README** sets **`suggested_hardware: t4-small`** (see [Spaces config](https://huggingface.co/docs/hub/spaces-config-reference)). **Enable a T4 (or better) GPU** in the Space **Settings → Hardware** so **`custom_hf`** can load PyTorch and Hub weights on-device.
+- **`requirements.txt`** includes **`requirements-core.txt`** plus **PyTorch / `transformers` / PEFT / TRL** so **`custom_hf`** is the default path when **CUDA** is visible (real local inference, not a stub).
+- **CPU-only duplicates:** switch hardware to **CPU** in Space Settings and use Gradio provider **`offline`** or API-only keys via **`auto`** (`NIM` / `OpenRouter`); **`custom_hf`** without a GPU is not supported in this layout.
 - **Repository secrets:** names must match environment variables exactly (see table below). After adding or changing secrets, **restart the Space** (or trigger a rebuild) so the container picks them up.
 - Full training stack: install **[`requirements-train.txt`](requirements-train.txt)** on **Colab** or locally (see Quickstart).
 
@@ -56,7 +56,9 @@ suggested_hardware: cpu-basic
 | **`NIM_API_KEY`** or **`NVIDIA_API_KEY`** | NVIDIA NIM chat API (`auto` / **nim**) |
 | **`OPENROUTER_API_KEY`** | OpenRouter (`auto` / **openrouter**) |
 | **`HF_TOKEN`** or **`HUGGING_FACE_HUB_TOKEN`** | Gated Hub downloads; if set, **`auto`** may try **custom_hf** after cloud APIs |
-| **`CODE_PROVIDER_MODE`** | Default when code does not pass a provider (optional; Gradio dropdown still overrides for benchmarks) |
+| **`CODE_PROVIDER_MODE`** | Unset = auto (`custom_hf` if CUDA else `offline`); or force `custom_hf` / `offline` / `auto` / … |
+| **`FORGE_DEFAULT_PROVIDER`** | Optional: force Gradio default dropdown (`custom_hf`, `offline`, …) |
+| **`FORGE_DETERMINISTIC_RESET`** | Set to **`1`** so **`POST /reset`** re-seeds RNG (harness reproducibility); omit for varied tasks |
 
 ### OpenEnv HTTP API on the Hugging Face Space
 
@@ -87,7 +89,7 @@ curl -sS -X POST "https://sanjay7676-team404-forge.hf.space/step" \
 
 | # | Requirement | FORGE-v4 |
 | :--: | :-- | :-- |
-| 1 | **OpenEnv (latest):** build on the framework | **`openenv-core>=0.2.3`** in [`requirements.txt`](requirements.txt). Training extras in [`requirements-train.txt`](requirements-train.txt). Wrapper: [`env_openenv.py`](env_openenv.py). Core: [`env.py`](env.py). |
+| 1 | **OpenEnv (latest):** build on the framework | **`openenv-core>=0.2.3`** in [`requirements-core.txt`](requirements-core.txt) (pulled via [`requirements.txt`](requirements.txt)). Training overlap in [`requirements-train.txt`](requirements-train.txt). Wrapper: [`env_openenv.py`](env_openenv.py). Core: [`env.py`](env.py). |
 | 2 | **Training:** Unsloth or TRL (or other RL stack) + **Colab** | [`train_unsloth.py`](train_unsloth.py) (Unsloth + TRL), [`train_colab.py`](train_colab.py), [`FORGE_Training_Colab.ipynb`](FORGE_Training_Colab.ipynb), Colab links in the table above. |
 | 3 | **Evidence of training:** loss + reward plots (real run) | Committed: [`outputs/reward_curve.png`](outputs/reward_curve.png), [`outputs/loss_curve.png`](outputs/loss_curve.png), [`outputs/pass_rate.png`](outputs/pass_rate.png), [`outputs/final_report.json`](outputs/final_report.json). |
 | 4 | **Writeup / video:** mini-blog on HF *or* <2 min YouTube *etc.* | **[BLOG.md](BLOG.md)** plus **[Space Discussions](https://huggingface.co/spaces/sanjay7676/Team404_FORGE/discussions)** for an on-Hub writeup; add **public YouTube or slide URL** in the judge table when published. |
@@ -287,7 +289,7 @@ Implementation: `forge/providers/*.py`, orchestration in `forge/providers/router
 
 **Hugging Face Space:** [https://huggingface.co/spaces/sanjay7676/Team404_FORGE](https://huggingface.co/spaces/sanjay7676/Team404_FORGE)
 
-The Space serves **Gradio at `/`** and the same **OpenEnv-style JSON routes** (`/health`, `/reset`, `/step`, `/state`) on the same host. **`POST /reset`** reseeds Python’s RNG so eval harnesses get a **deterministic** first task each episode. For local-only API, run `api_server.py` on port `8000` (see Docker Compose).
+The Space serves **Gradio at `/`** and the same **OpenEnv-style JSON routes** (`/health`, `/reset`, `/step`, `/state`) on the same host. **`POST /reset`** starts a **new random task** by default (same live env as the UI). For strict harness reproducibility, set Space secret **`FORGE_DETERMINISTIC_RESET=1`**. For local-only API, run `api_server.py` on port `8000` (see Docker Compose).
 
 ---
 
@@ -328,8 +330,11 @@ The Space serves **Gradio at `/`** and the same **OpenEnv-style JSON routes** (`
 ## Quickstart
 
 ```bash
+# Full stack (GPU + local HF — same as HF Space default):
 pip install -r requirements.txt
-# GPU / training / HF custom local weights (skip on HF CPU Space):
+# Slim CPU-only API / Gradio (no PyTorch):
+# pip install -r requirements-core.txt
+# Optional TRL overlap / Colab extras:
 pip install -r requirements-train.txt
 
 cp .env.example .env   # then edit — do not commit .env
@@ -359,7 +364,7 @@ Anyone can `docker pull` a **public** image without logging in. `docker login` i
 
 ### Build locally, tag, and push to Docker Hub (one-time)
 
-**Fast image (default `Dockerfile`):** only `requirements.txt` — no PyTorch. Usually **a few minutes**. Good for demo, Gradio, and `CODE_PROVIDER_MODE=offline` (or API-backed providers).
+**Fast image (default `Dockerfile`):** only [`requirements-core.txt`](requirements-core.txt) — no PyTorch. Usually **a few minutes**. Good for slim demo/API with `CODE_PROVIDER_MODE=offline` (or API-backed providers).
 
 **Full training image:** [`Dockerfile.train`](Dockerfile.train) adds `requirements-train.txt` (PyTorch + CUDA wheels). Expect **tens of minutes to an hour+** on first build.
 

api_server.py

@@ -1,6 +1,7 @@
 # api_server.py
 # FastAPI wrapper for FORGE-v4 Environment (OpenEnv standard).
 
+import os
 import random
 from typing import Any, List, Optional
 
@@ -26,8 +27,10 @@ class Action(BaseModel):
 @app.post("/reset")
 async def reset():
     """Reset the environment and return the initial state."""
-    # Deterministic task generation for eval harnesses (same seed every episode start).
-    random.seed(GLOBAL_RANDOM_SEED)
+    # Default: varied tasks per reset (real sandbox episodes). Set FORGE_DETERMINISTIC_RESET=1
+    # to re-seed RNG for harnesses that need identical first-task distributions.
+    if os.getenv("FORGE_DETERMINISTIC_RESET", "").strip().lower() in ("1", "true", "yes"):
+        random.seed(GLOBAL_RANDOM_SEED)
     state = env.reset()
     return state
 

app.py

@@ -33,20 +33,47 @@ def get_memory_lessons() -> str:
     top_lessons = summary.get("top_lessons", [])
     if not top_lessons:
         return "No lessons recorded yet."
-    
+
     output = ""
     for idx, lesson in enumerate(top_lessons):
-        output += f"{idx+1}. Episode {lesson.get('episode')}: {lesson.get('coach_note')} (Weight: {lesson.get('reward_weight')})\n"
+        note = lesson.get("coach_note") or ""
+        w = lesson.get("reward_weight", 0.0)
+        output += f"{idx + 1}. {note} (Weight: {w})\n"
     return output
 
-# Offline baseline first — instant deterministic runs for Spaces and demos.
-FORGE_PROVIDER_OPTIONS = ["offline", "auto", "nim", "openrouter", "custom_hf"]
+
+def _cuda_ready() -> bool:
+    try:
+        import torch  # noqa: PLC0415
+        return bool(torch.cuda.is_available())
+    except ImportError:
+        return False
+
+
+def _ui_provider_options() -> list[str]:
+    # GPU Space: lead with local HF (real weights on T4). CPU: lead with offline so demos stay instant.
+    if _cuda_ready():
+        return ["custom_hf", "auto", "nim", "openrouter", "offline"]
+    return ["offline", "auto", "nim", "openrouter", "custom_hf"]
+
+
+FORGE_PROVIDER_OPTIONS = _ui_provider_options()
+
+
+def default_forge_ui_provider() -> str:
+    override = os.getenv("FORGE_DEFAULT_PROVIDER", "").strip().lower()
+    if override in FORGE_PROVIDER_OPTIONS:
+        return override
+    return "custom_hf" if _cuda_ready() else "offline"
+
+
+def _benchmark_episode_cap() -> int:
+    return 30 if _cuda_ready() else 5
 
 
 def run_benchmark_ui(episodes, forge_provider_label: str):
     """Gradio wrapper for benchmark mode."""
-    # Limit episodes for demo stability on CPU
-    ep_count = min(int(episodes), 5)
+    ep_count = min(int(episodes), _benchmark_episode_cap())
     mode = forge_provider_label if forge_provider_label in (
         "auto", "custom_hf", "nim", "openrouter", "offline", "mock"
     ) else "offline"
@@ -77,7 +104,7 @@ def run_benchmark_ui(episodes, forge_provider_label: str):
 
 def run_compare_ui(episodes, forge_provider_label: str):
     """Gradio wrapper for compare mode."""
-    ep_count = min(int(episodes), 3)  # Very small for demo
+    ep_count = min(int(episodes), 10 if _cuda_ready() else 3)
     mode = forge_provider_label if forge_provider_label in (
         "auto", "custom_hf", "nim", "openrouter", "offline", "mock"
     ) else "offline"
@@ -133,9 +160,13 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
             episodes_input = gr.Slider(minimum=1, maximum=10, value=3, step=1, label="Episodes (Limited for Demo)")
             provider_input = gr.Dropdown(
                 choices=FORGE_PROVIDER_OPTIONS,
-                value="offline",
+                value=default_forge_ui_provider(),
                 label="Inference provider",
-                info="**Offline** = instant deterministic baseline. **auto** = NIM → OpenRouter → local HF only if Space secret **HF_TOKEN** is set → else offline. **custom_hf** always uses local PyTorch (can be slow on CPU).",
+                info=(
+                    "**custom_hf** = local PyTorch + Hub weights on this machine (default on **GPU**). "
+                    "**auto** = NIM → OpenRouter → optional local HF if **HF_TOKEN** is set → else offline. "
+                    "**offline** = no external APIs (CPU-friendly fallback)."
+                ),
             )
         
         with gr.Row():
@@ -166,7 +197,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
         FORGE-v4 serves **Gradio at `/`** and the OpenEnv JSON routes at the **same origin** (`/health`, `/reset`, `/step`, `/state`). Locally, `python api_server.py` serves **API-only** on **`:8000`**; `python app.py` serves UI **+** API on **`:7860`**. On this Space, use your **`*.hf.space`** base URL (no `/start` — use **`POST /reset`** then **`POST /step`**).
 
         - **`GET /health`**: Liveness / version check.
-        - **`POST /reset`**: Starts a new episode and returns the initial state.
+        - **`POST /reset`**: Starts a new episode and returns the initial state (new random task each time unless Space secret **`FORGE_DETERMINISTIC_RESET=1`**).
         - **`POST /step`**: JSON body: `coder_code`, `coder_version`, optional `candidate_solutions` (array of strings). Returns rewards and updated state.
         - **`GET /state`**: Current environment snapshot.
 

config.py

@@ -108,9 +108,25 @@ OPENROUTER_MODEL = os.getenv("OPENROUTER_MODEL", "qwen/qwen2.5-coder-7b-instruct
 
 HF_TOKEN = os.getenv("HF_TOKEN", os.getenv("HUGGING_FACE_HUB_TOKEN", ""))
 
-# Policy "model" routing: offline | auto | custom_hf | nim | openrouter (legacy env value "mock" == offline)
-_CODE_PROVIDER_RAW = os.getenv("CODE_PROVIDER_MODE", "offline").strip().lower()
-CODE_PROVIDER_MODE = "offline" if _CODE_PROVIDER_RAW in ("", "mock") else _CODE_PROVIDER_RAW
+# Policy "model" routing: offline | auto | custom_hf | nim | openrouter (legacy "mock" == offline).
+# If CODE_PROVIDER_MODE is unset: use custom_hf when CUDA is available (GPU Space), else offline.
+
+
+def _default_code_provider_mode() -> str:
+    try:
+        import torch  # noqa: PLC0415 — optional; absent in slim Docker images
+    except ImportError:
+        return "offline"
+    return "custom_hf" if torch.cuda.is_available() else "offline"
+
+
+_code_raw = os.getenv("CODE_PROVIDER_MODE", "").strip().lower()
+if _code_raw == "mock":
+    CODE_PROVIDER_MODE = "offline"
+elif _code_raw:
+    CODE_PROVIDER_MODE = _code_raw
+else:
+    CODE_PROVIDER_MODE = _default_code_provider_mode()
 
 # Per-provider HTTP / wrapped inference timeouts (seconds)
 # Local HF load+infer can exceed 60s on cold CPU; default cap keeps Gradio responsive (raise via env on GPU).

requirements-core.txt

@@ -0,0 +1,23 @@
+# FORGE-v4 — slim stack (Docker Hub image, CPU-only local runs, CI).
+# Hugging Face Spaces use root requirements.txt which includes this file plus PyTorch / HF inference.
+
+# OpenEnv (official framework — Meta / HF ecosystem)
+# Needs websockets>=15.1; use Gradio >=5.18 (see README Space sdk_version).
+openenv-core>=0.2.3
+
+# Core
+tqdm>=4.66.0
+numpy>=1.26.0
+pandas>=2.2.0
+matplotlib>=3.8.0
+PyYAML>=6.0.1
+requests>=2.32.0
+python-dotenv>=1.0.1
+
+# HF Spaces installs gradio[oauth]==sdk_version from README YAML — keep sdk_version in sync.
+gradio>=5.18.0,<6
+
+# API — Gradio 5.x needs fastapi>=0.115.2
+fastapi>=0.115.2,<1.0
+uvicorn>=0.30.0
+pydantic>=2.7.0

requirements-train.txt

@@ -1,5 +1,5 @@
-# GPU / Colab / full Docker image — install on top of requirements.txt
-# Not used on Hugging Face CPU Spaces (use CODE_PROVIDER_MODE=offline there).
+# Extra training stack — install with root requirements.txt (Spaces / Dockerfile.train).
+# Root requirements.txt already includes torch/transformers/PEFT; this file adds overlap for Colab-only flows.
 
 torch>=2.3.0
 transformers>=4.41.0

requirements.txt

@@ -1,23 +1,13 @@
-# FORGE-v4 — default install (Hugging Face CPU Spaces, Gradio demo, API).
-# For training / local_model / HF custom weights, also install: pip install -r requirements-train.txt
-
-# OpenEnv (official framework — Meta / HF ecosystem)
-# Needs websockets>=15.1; use Gradio >=5.18 (see README Space sdk_version).
-openenv-core>=0.2.3
-
-# Core
-tqdm>=4.66.0
-numpy>=1.26.0
-pandas>=2.2.0
-matplotlib>=3.8.0
-PyYAML>=6.0.1
-requests>=2.32.0
-python-dotenv>=1.0.1
-
-# HF Spaces installs gradio[oauth]==sdk_version from README YAML — keep sdk_version in sync.
-gradio>=5.18.0,<6
-
-# API — Gradio 5.x needs fastapi>=0.115.2
-fastapi>=0.115.2,<1.0
-uvicorn>=0.30.0
-pydantic>=2.7.0
+# FORGE-v4 — default install for Hugging Face Spaces (T4 GPU: local HF inference + Gradio + API).
+# Slim installs: use requirements-core.txt only (see Dockerfile).
+
+-r requirements-core.txt
+
+# Local Hugging Face inference (custom_hf on GPU Spaces)
+torch>=2.3.0
+transformers>=4.41.0
+trl>=0.9.4
+peft>=0.11.1
+datasets>=2.19.0
+accelerate>=0.30.0
+bitsandbytes>=0.43.1

trainer.py

@@ -275,7 +275,7 @@ def run_benchmark_mode(
     forge_provider: str | None = None,
 ) -> dict[str, Any]:
     """Run evidence benchmark and export judge assets."""
-    episodes = max(20, episodes)
+    episodes = max(1, int(episodes))
     summary = train_with_policy_name(
         policy_name=policy_name,
         num_episodes=episodes,