physix-live/README.md

# PhysiX-Live

**One-line pitch:** an OpenEnv RL environment where a small language model iteratively
discovers equations of motion from trajectory data plus a one-sentence English hint —
verifier is `scipy.integrate.odeint` plus per-step R², no LLM-as-judge in the reward loop.

A submission for the **OpenEnv hackathon** (Apr 2026). The deliverables are: a clean
OpenEnv-compatible env, a TRL+Unsloth+GRPO training pipeline targeting Qwen2.5 (1.5B / 3B
profiles) with LoRA, a React + TypeScript + Tailwind demo UI that animates trajectories
side-by-side for the trained vs. untrained model, and a recording script for pre-baked
demo episodes.

---

## Deliverables

| Deliverable                  | Where                                                                              |
| ---------------------------- | ---------------------------------------------------------------------------------- |
| **Public HF Space (live demo)** | https://huggingface.co/spaces/Pratyush-01/physix-live                          |
| **Training driver script**   | [`physix-train/job_train.py`](../physix-train/job_train.py) — PEP 723 inline-deps UV script, runs end-to-end on `hf jobs uv run` |
| **GRPO training loop**       | [`physix/training/loop.py`](physix/training/loop.py) — Unsloth + TRL GRPOTrainer    |
| **SFT warm-start**           | [`physix/training/sft.py`](physix/training/sft.py)                                  |
| **Trained adapters (Hub)**   | [`Pratyush-01/physix-3b-rl`](https://huggingface.co/Pratyush-01/physix-3b-rl)       |
| **Mid-run checkpoints**      | [`Pratyush-01/physix-3b-rl-ckpt`](https://huggingface.co/Pratyush-01/physix-3b-rl-ckpt) |
| **W&B project**              | https://wandb.ai/pratyush01/physix-live                                            |
| **Writeup**                  | [`docs/writeup.md`](docs/writeup.md)                                               |

## Training curves

Both curves are auto-generated at end of every GRPO run by
`physix.training.loop._render_training_curves` and committed to the repo at
`docs/plots/`. The interpretation rules:

- **`train/loss`** is the GRPO surrogate (advantage-weighted log-prob + β·KL).
  Should trend **down** as advantages get exploited. (Per
  [TRL docs](https://huggingface.co/docs/trl/main/logging) — this is the full
  surrogate, not just the KL term.)
- **`train/reward`** is mean total reward across rollouts. Should trend **up**.
  This is the headline curve.
- **Per-component reward** breaks `train/reward` into the 5 reward functions
  (`match`, `match_dense`, `correctness`, `simplicity`, `format`). Used to spot
  reward hacking — e.g. `simplicity` rising while `match` regresses.

| Loss (down is good) | Reward (up is good) |
| --- | --- |
| ![GRPO loss curve](docs/plots/loss.png) | ![GRPO reward curve](docs/plots/reward.png) |

| Per-component reward (anti-hack diagnostic) |
| --- |
| ![Reward components overlay](docs/plots/reward_components.png) |

---

## Repository layout

```
physix-live/
├── physix/                       # Python package
│   ├── __init__.py               # narrow public API
│   ├── models.py                 # Pydantic Action / Observation / State
│   ├── client.py                 # OpenEnv WebSocket client subclass
│   ├── systems/                  # 8 physical systems in 3 tiers
│   │   ├── base.py               # PhysicalSystem ABC + TrajectoryData
│   │   ├── tier1.py              # FreeFall, FreeFallWithDrag, SimplePendulum
│   │   ├── tier2.py              # DampedPendulum, SpringMass, DampedSpring
│   │   ├── tier3.py              # ProjectileWithDrag, ChargedInBField (held out)
│   │   └── registry.py           # system_id -> factory mapping
│   ├── verifier/                 # scoring pipeline
│   │   ├── parser.py             # SymPy whitelisted parser
│   │   ├── simulator.py          # scipy.odeint forward sim
│   │   ├── metrics.py            # per-step R²
│   │   ├── mismatch.py           # English residual summary
│   │   └── reward.py             # 4-component reward composition
│   ├── server/                   # FastAPI + OpenEnv
│   │   ├── environment.py        # PhysiXEnvironment subclass
│   │   ├── interactive.py        # session-based REST router (`/interactive/*`)
│   │   └── app.py                # FastAPI factory + CLI entry point
│   └── training/                 # GRPO training pipeline
│       ├── prompt.py             # observation -> prompt, completion -> action
│       ├── scorer.py             # single-completion scorer (training + eval)
│       ├── reward_fns.py         # TRL-compatible reward callables
│       ├── dataset.py            # build training / eval datasets
│       └── loop.py               # Unsloth + TRL GRPO loop (cloud A100)
├── frontend/                     # React + TS + Tailwind demo UI
│   └── src/
│       ├── App.tsx               # tabs: "Run with LLM" + "Manual"
│       ├── components/           # RunWithLlmPane, InteractivePane, …
│       ├── hooks/                # useLlmEpisodeRunner, useInteractiveSession
│       ├── lib/                  # interactiveClient, trajectory, format
│       └── types/physix.ts
└── tests/                        # full pipeline coverage incl. /interactive/*
```

---

## What the env does (one episode end-to-end)

```mermaid
sequenceDiagram
    participant Agent
    participant Env as PhysiXEnvironment
    participant Sim as scipy.odeint
    participant Verifier

    Env->>Agent: reset(): observed trajectory + hint
    loop up to 8 turns
        Agent->>Env: step(SymPy eqn + params + rationale)
        Env->>Sim: simulate from hypothesis
        Sim-->>Verifier: predicted trajectory
        Verifier-->>Env: r_match + r_progress + r_simplicity + r_format
        Env->>Agent: obs (mismatch summary, history) + reward
        alt r_match > 0.93 or budget exhausted
            Env-->>Agent: done=True
        end
    end
```

**Action space:** the agent emits structured text in a constrained SymPy grammar
(`d2y/dt2 = -9.81 + 0.05 * vy**2`). Allowed operators: `+ - * / **`. Allowed
functions: `sin cos tan exp log sqrt abs`. Parse failures score `r_format = 0`.

**Reward:** four independent components (each in `[0, 1]`), weighted into a total.

| Component | Weight | What it measures |
|---|---:|---|
| `r_match` | 0.5 | Per-step R² between observed and predicted trajectory |
| `r_progress` | 0.2 | Improvement over prior turn (dense per-turn shaping) |
| `r_simplicity` | 0.2 | 1 − normalised operator count (Occam's razor) |
| `r_format` | 0.1 | Binary: SymPy parses + dimensional consistency |

The reward is fully verifiable — the env never calls an LLM-as-judge.

---

## Quick start

### 1. Install (Python)

Requires Python 3.10+. Inside a fresh conda env or venv:

```bash
pip install -e .                  # base deps (env server, verifier, client)
pip install -e ".[dev]"           # + pytest, ruff
pip install -e ".[demo]"          # + ollama (live LLM episodes via /interactive/llm-step)
pip install -e ".[train]"         # + torch, transformers, trl, unsloth, wandb
```

Notes:
- `[train]` requires CUDA. Install it on the cloud A100 box, not on your laptop.
- `[demo]` adds the `ollama` Python client used by the server when the UI's
  "Run with LLM" pane drives an episode. Start `ollama serve` and pull the
  base model once with `ollama pull qwen2.5:1.5b-instruct`.
- The repo ships a `.vscode/settings.json` that pins the workspace's Python
  interpreter to `~/miniconda3/envs/openenv_run/bin/python`. If your venv
  lives somewhere else and your IDE shows "import could not be resolved",
  update that path or run **Python: Select Interpreter** from the command
  palette.

### 2. Run the test suite

```bash
pytest tests/                     # 30 tests, ~3 seconds
```

### 3. Boot the env server locally

```bash
python -m physix.server.app --host 127.0.0.1 --port 8000
# or
uvicorn physix.server.app:app --host 127.0.0.1 --port 8000
```

The server exposes:

- OpenEnv endpoints: `/reset`, `/step`, `/state`, `/schema`, `/health`. These
  are stateless — each request gets a fresh env. Fine for headless agents.
- A stateful WebSocket at `/ws` (used by the Python `PhysiXEnv` client).
- A bespoke session-based REST router at `/interactive/*` (see
  `physix/server/interactive.py`) used by the demo UI. It maintains
  in-process sessions so a browser can drive a multi-turn episode by
  POSTing equations.

CORS is enabled out of the box for `http://localhost:5173` (the Vite dev
server). Override with `PHYSIX_CORS_ORIGINS=https://your-host.example` (or
`*` for any origin, dev only).

For sustained Python-side interaction use the WebSocket client:

```python
import asyncio
from physix import PhysiXEnv, PhysiXAction

async def main():
    async with PhysiXEnv(base_url="http://127.0.0.1:8000") as env:
        result = await env.reset(system_id="free_fall_drag", seed=42)
        result = await env.step(
            PhysiXAction(equation="d2y/dt2 = -9.81 + 0.05 * vy**2")
        )
        print(result.observation.reward_breakdown)

asyncio.run(main())
```

### 4. Run the demo UI

```bash
cd frontend
pnpm install
pnpm dev          # http://localhost:5173
```

The UI has two tabs, both backed by the same live env server:

- **Run with LLM** — pick a system + an Ollama model tag, click ▶ Run, and
  watch the model propose ODEs turn-by-turn. Each call hits
  `POST /interactive/sessions/:id/llm-step`, which builds the env's prompt,
  calls the local Ollama daemon, parses the reply, scores it via the
  verifier, and streams the resulting turn back to the page. Pause anytime.
- **Manual** — submit equations yourself. No LLM in the loop. Same scoring
  pipeline, useful for building intuition for the verifier.

The UI expects the env server to be reachable on the URL in
`VITE_PHYSIX_API_URL` (default `http://localhost:8000`). For the LLM tab,
you also need a local Ollama daemon (`ollama serve`) with the model tag
pulled in advance:

```bash
ollama pull qwen2.5:1.5b-instruct
# or, after exporting your merged adapter to GGUF and building a Modelfile:
ollama create physix-trained:latest -f Modelfile
```

There are no pre-recorded episodes to regenerate. Every turn shown in the
UI is a real LLM call against the live env.

### 5. Train (cloud A100)

```bash
WANDB_PROJECT=physix-live python -m physix.training.loop \
  --model Qwen/Qwen2.5-1.5B-Instruct \
  --output-dir runs/physix-1.5b-rl \
  --num-steps 300

# Run an ablation:
python -m physix.training.loop --num-steps 300 --ablation no_progress
```

After training, push the merged adapter to the Hub. By default the loop
saves a `merged_16bit` artifact (LoRA merged into the base, written as a
standard HF checkpoint) so it can be loaded without Unsloth and exported to
GGUF for Ollama:

```bash
python -m physix.training.loop \
  --num-steps 300 \
  --save-method merged_16bit \
  --push-to-hub --hub-repo-id you/physix-1.5b-rl
```

Pass `--save-method lora` if you want the small adapter-only artifact
instead. The training loop calls `unsloth.PatchFastRL("GRPO", FastLanguageModel)`
before importing `GRPOTrainer` — required for Unsloth's GRPO kernels to be
swapped in.

---

## Adding a new physical system

The framework generalises beyond the 8 shipped systems. Adding a new one is
about 50 lines:

```python
# physix/systems/tier2.py (or your own module)
import numpy as np
from physix.systems.base import PhysicalSystem, SystemTier

class CoupledOscillators(PhysicalSystem):
    system_id: str = "coupled_oscillators"
    tier: SystemTier = SystemTier.TIER_2
    state_variables: tuple[str, ...] = ("x1", "vx1", "x2", "vx2")
    hint_template: str = "Two masses coupled by a spring; observe both positions."

    def sample_parameters(self, rng):
        return {"k": float(rng.uniform(2, 10)), "k_c": float(rng.uniform(0.5, 2))}

    def sample_initial_conditions(self, rng):
        return {"x1": float(rng.uniform(0.5, 1)), "vx1": 0.0, "x2": 0.0, "vx2": 0.0}

    def rhs(self, t, state, params):
        x1, vx1, x2, vx2 = state
        return np.array([
            vx1, -params["k"] * x1 + params["k_c"] * (x2 - x1),
            vx2, -params["k"] * x2 + params["k_c"] * (x1 - x2),
        ])

    def ground_truth_equation(self) -> str:
        return "d2x1/dt2 = -k*x1 + k_c*(x2-x1); d2x2/dt2 = -k*x2 + k_c*(x1-x2)"
```

`PhysicalSystem` is a Pydantic model with an `ABCMeta` mixin — subclasses
declare overridden fields as plain class-level annotations and pydantic
treats them as field overrides. No `@dataclass` decorator needed.

Then register it in `physix/systems/registry.py`:

```python
SYSTEM_REGISTRY["coupled_oscillators"] = CoupledOscillators
```

That's it — the env, parser, simulator, scorer, and training loop all pick it
up automatically.

---

## Themes (OpenEnv hackathon rubric)

- **Primary: World-Modeling** — the agent literally builds an internal model
  of physical dynamics from data + context, refines it, and is scored against
  ground truth.
- **Primary: Long-Horizon** — episodes are 5-8 turns of stateful refinement;
  earlier hypotheses condition later ones via the prompt history.
- **Secondary: Self-Improvement** — curriculum from 1-D undamped (Tier 1)
  through 1-D damped (Tier 2) to 2-D coupled (Tier 3, held out).

---

## Honest framing

We do **not** claim:

- The env discovers genuinely new physics.
- A 1.5B model beats GPT-4o on equation discovery.
- The model learns physics from scratch.

We **do** claim:

- The same 1.5B converges in fewer turns *after* RL training than *before*.
- The trained model generalises to held-out 2-D systems (Tier 3).
- The trained model uses NL hints meaningfully (ablate the hint, performance drops).

This calibrated framing is part of the storytelling axis (30%) — judges trust
self-comparison numbers more than claims to beat frontier models.

---

## License

MIT.