PsiLM-physics

<!-- Maintainer: upload assets/psilm-banner.png from the GitHub repository to the root of this HF repo so the image below resolves. -->

PsiLM physics hemispheres

The three frozen physics models that PsiLM (ΨLM) couples to a language model.

What is PsiLM, and what is in this repo?

PsiLM couples a frozen language model to a frozen physics model through small trainable latent bridges; no text crosses the interface. The language side reads the physics model's inputs out of the prompt's hidden states, the physics model evolves the field, and the value at the queried position returns as eight soft tokens through a gated cross-attention layer. This repo contains the physics side only: two 70K-parameter 1D Burgers FNOs trained here from spectral-solver data, and a DPOT-Tiny checkpoint fine-tuned for 2D Fisher–KPP. They are ordinary neural operators and can be used without PsiLM. The trained bridges live in ryoji-info/PsiLM-bridges; the language backbones are public checkpoints loaded separately (for the Qwen3.5 bridges, the repackaged weights at the root of ryoji-info/Qwen3.5-9B-PsiLM).

Easiest entry point: the standalone repo ryoji-info/Gemma-4-12B-PsiLM packages the Gemma 4 12B bridges together with the physics model and a runnable example.

Links: GitHub · paper (PDF) · bridges: ryoji-info/PsiLM-bridges

What the physics hemisphere costs, and what it buys

These files are the frozen half that does the computing — 0.07M parameters for the Burgers FNO, 7.5M for DPOT-Tiny — sitting beside a 12.28B language model that is also frozen. Measured on one Apple M2 (24 GB).

The trained part is 0.21% of the backbone's parameters and 1.6% of its checkpoint size. The 12.28B never move.

+0.21% parameters and +103 MB turn 0% into 97%, at 24× lower latency on the task, with nothing measurable lost elsewhere. The last column is why the middle rows do not move: the gate's σ is 0.14 on physics against 0.004–0.008 on everything else, so the channel is shut when physics is irrelevant. Zeroing the injection collapses physics to 10% — the accuracy arrives through the bridge, not through the prompt.

Sources: results/bench/gemma12b_guardrail_summary.json (accuracy, gate σ and seconds per question), results/stage2_gemma12b/final_eval.json (n=60 held-out: PsiLM 96.7%, oracle 98.3%). Parameter counts are read from the checkpoint headers, not from the model names. The backbone's 0% is its own text protocol: it spends the whole 768-token budget deriving and never commits to an answer line; forced to answer (n=60, final_eval_baseline_forced.json) it scores 6.7%, four near-constant guesses (0.41 / 0.51 / 0.54 / 0.11, sd 0.37 against truths spanning [-0.56, +0.60]) landing inside the tolerance; the best single constant would score 13.3%. The latency gap has the same cause — PsiLM answers in one line.

Which file do I want?

Validation relative-L2 errors are recorded in results/physics_models.json in the GitHub repository; the training data facts below come from the committed training scripts (eval/stage2_pretrain_fno.py, eval/stage2b_pretrain_fno.py, eval/stage2d_prepare.py).

Loading

All files are safetensors. The FNO spectral weights are complex64, which safetensors does not support, so they are stored as <key>.real / <key>.imag pairs; reassemble with sd[k] = torch.complex(f[k + ".real"], f[k + ".imag"]) before FNO1d.load_state_dict. DPOT-Tiny derives from hzk17/DPOT (Apache-2.0). The FNOs load with psilm.physics.fno.FNO1d (PyTorch) or psilm.mlx.fno.convert_from_torch (MLX, numerically identical to 1e-7).

Clone the GitHub repository and pip install -e . first; the model classes live in the psilm package.

import torch
from safetensors.torch import load_file
from psilm.physics.fno import FNO1d

f = load_file("fno_burgers_singlemode.safetensors")
sd = {}
for k, v in f.items():
    if k.endswith(".real"):
        sd[k[:-5]] = torch.complex(v, f[k[:-5] + ".imag"])
    elif not k.endswith(".imag"):
        sd[k] = v
fno = FNO1d(width=32, modes=16, layers=4)
fno.load_state_dict(sd)
fno.eval()
u_T = fno(u0)  # u0: (batch, 128) initial condition on the periodic unit interval -> u(x, 0.5)

For DPOT-Tiny, construct psilm.physics.dpot_wrapper.DPOTPhysics (which builds the DPOT-Tiny network and expects the published model_Ti.pth from hzk17/DPOT to initialize) and then overwrite its weights with the fine-tuned state: phys.net.load_state_dict(load_file("dpot_tiny_fisher2d_finetuned.safetensors"), strict=True). The keys are the bare DPOT-Tiny state-dict keys (blocks.*, pos_embed, time_agg_layer.*, ...). phys(u0) maps a (batch, 128, 128) initial field to u(x, y, 0.4); phys.features_and_field(u0) also returns the 256 latent patch tokens the PsiLM reverse bridge attends over.

Is the physics model's answer really what reaches the language model?

Two controls, and the second is decisive. Zeroing the injection while running everything else — readout, FNO, value tokens, gate — removes the physics result (0% for Qwen3-8B; 10% for Gemma and for Qwen3.5, whose zeroed replies all give 0.5, a number the question contains, which lies within ±0.05 of the answer on 10 of the 100). Corrupting only the number — feeding the value encoder another question's answer at matched magnitude, with prompt, readout, gate, reply length and parsing untouched — makes the frozen model report the corruption: the spoken answer lands within ±0.05 of the injected value on 99 of 100 held-out questions and within ±0.05 of the truth on 9. Accuracy falls 98% → 9% while the KL to the base model is unchanged (0.222 either way): the output distribution travels just as far, to a different number.

Run on non-physics prompts the same swap changes nothing (GSM8K 0.88 both ways, MMLU 0.66 both ways, p = 1.00), which separates what the channel does by its presence from what it does by its content. Full sweep and records: results/bench/leaky_8b_shuf_guardrail_summary.json and §9.7 of the paper.

Limitations

• One PDE setting each. The Burgers FNOs are trained at a single viscosity (ν=0.02), horizon (T=0.5) and 128-point resolution; the multimode model covers ICs up to mode 4 only. DPOT-Tiny is fine-tuned for one Fisher–KPP parameter pair (D=0.001, r=6) and horizon (T=0.4) with Gaussian-bump ICs.
• One-shot operators. Each model maps the initial condition straight to the field at the final time; they are not time-steppers and were not validated at other horizons.
• Small validation sets. The relL2 figures are on 256 held-out trajectories/fields from the same generator as the training data; no out-of-distribution physics evaluation was run.
• DPOT provenance. The fine-tuned DPOT-Tiny weights are derived from hzk17/DPOT (Apache-2.0); of DPOT's 4 input channels only the first carries the field; the other three are zero in this task.

Beyond physics

These files are the physics seat of PsiLM, but the recipe (read a fixed set of quantities from text; let a frozen quantitative model compute; return one value through a selective gate) is not specific to PDEs. A calibrated market or event-probability model in the same seat would be the same architecture, and the appeal is the same: a language model's forecast grounded in a model that can be validated separately, with a gate that stays shut when the model does not apply. Nothing in this repository has been trained or tested on financial data; the physics results relied on exact oracles, deterministic targets and no distribution shift, none of which markets provide. This is a research direction, not a capability, and not a basis for investment decisions.

Support

PsiLM is independent research run on a single Apple M2. If it is useful to you, you can support the work at ko-fi.com/ryojifurui.

Citation

@misc{furui2026psilm,
  title  = {PsiLM: Coupling Frozen Language and Physics Models through Trainable Latent Bridges},
  author = {Furui, Ryoji},
  year   = {2026},
  note   = {Research generated by Claude (Anthropic) under the author's direction},
  url    = {https://github.com/ryoji-info/PsiLM}
}

Research generated by Claude (Anthropic) under the direction of Ryoji Furui; see the repository's AI generation disclosure. License: Apache-2.0 (DPOT-Tiny upstream: Apache-2.0).