Initial commit

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dmitry T (Dimitrius174)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,199 @@
+---
+license: mit
+library_name: pytorch
+tags:
+- reinforcement-learning
+- lunarlander
+- gymnasium
+- tiny-model
+- linear-policy
+- model-compression
+---
+
+# LunarLander-v3 in 32 parameters (max-safety)
+
+A **32-parameter single-layer neural network** that solves Gymnasium
+[`LunarLander-v3`](https://gymnasium.farama.org/environments/box2d/lunar_lander/):
+**231.2 mean return, 99.7% landings, 60/60 seeds**, crashing in only ~0.25% of episodes.
+
+```
+logits = Linear(8 -> 4, bias=False)(obs)     # 32 parameters
+action = argmax(logits)
+```
+
+The weights shipped here are the **max-safety** variant (see *Choice of objective* below).
+
+## Evaluation
+
+60 evaluation seeds x 100 episodes = 6000 episodes, deterministic greedy policy:
+
+| metric | **max-safety** (this model) | crash-averse | mean-optimal teacher |
+|---|---|---|---|
+| mean return | 231.23 | 239.46 | 247.20 |
+| std over seeds | 3.39 | 2.87 | 5.89 |
+| min / max seed mean | 223.30 / 238.74 | 232.21 / 244.62 | 232.78 / 260.70 |
+| seeds with mean >= 200 | **60 / 60** | 60 / 60 | 60 / 60 |
+| landing rate (env `+100`) | **99.67%** | 99.42% | 94.10% |
+| crash rate (env `-100`) | **0.25%** | 0.57% | 5.88% |
+| parameters | 32 | 32 | 32 |
+
+Reference random policy on this env is about -100..-500; the "solved" threshold
+is 200. Reproduce with:
+
+```bash
+pip install -r requirements.txt
+python verify.py --episodes 100 --seeds 60
+```
+
+**What "landing rate" means.** An episode ends with the environment's own ±100 signal:
+`+100` when the lander comes to rest (both legs grounded, low speed, small angle) — a *safe
+landing*; `-100` when the lander's body hits the ground or it flies off screen — a *crash*
+(see `LunarLander._get_reward`). "Landing rate" is the fraction of episodes that received the
+`+100` verdict. Measured exactly on the 6000 episodes:
+
+| verdict | episodes | share |
+|---|---|---|
+| landed (env `+100`) | 5980 | 99.67% |
+| crashed (env `-100`) | 15 | 0.25% |
+| timeout (1000 steps) | 5 | 0.08% |
+
+The `return >= 100` proxy (99.67%) agrees with the environment's own verdict on **6000 / 6000**
+episodes. `python landing_check.py` reproduces this cross-check.
+
+Because a safe landing is worth roughly +100..+320 (the terminal +100 plus shaping and leg
+contacts), the "solved" criterion (mean >= 200) is equivalent to "lands almost every time".
+
+## Choice of objective (why 231 and not 247)
+
+In this environment **average score and reliability trade off**, and the shipped weights pick
+maximum safety. Starting from the mean-optimal teacher (247.2 mean, 5.9% crashes) the weights were
+refined against a crash-penalised objective (`mean - 500 * crash_rate`) on a *separate* train
+seed set, evaluating on held-out seeds. On the 60 canonical evaluation seeds:
+
+| | mean | landings | crashes |
+|---|---|---|---|
+| mean-optimal teacher | 247.2 | 94.1% | 5.9% |
+| crash-averse | 239.5 | 99.4% | 0.6% |
+| **max-safety** (this model) | 231.2 | **99.7%** | **0.25%** |
+
+The crashes are not caused by a few "bad seeds" — all 60 seeds pass, and failures are spread
+over episodes (2-11 crashes out of 100 per seed); they start from faster, more tilted spawns.
+They are also *policy-addressable*: the same 32-parameter class contains a policy with ~20x
+fewer crashes, so 5.9% is a compromise of one point, not a hard limit of the class. Reliability
+is bought with mean return — within the same 32 parameters.
+
+Earlier revisions (crash-averse 239.5 / 0.6%; mean-optimal 247.2 / 5.9%) are preserved in this
+repository's git history.
+
+### Reproducibility (why not to over-trust the crash rate)
+
+The max-safety weights above are **start 1** of an experiment with 6 independent optimisation
+runs of the same objective (`mean - 500 * crash_rate`). The six runs land at very different
+points, and several barely move from the teacher at all:
+
+| start | TEST mean | TEST crash rate |
+|---|---|---|
+| 0 | 247.7 | 5.7% |
+| 1 | 231.6 | **0.22%** |
+| 2 | 250.1 | 2.0% |
+| 3 | 246.8 | 6.7% |
+| 4 | **258.1** | 3.5% |
+| 5 | 237.7 | 4.0% |
+| (teacher) | 248.3 | 5.5% |
+
+All six still solve every seed (>= 230 mean, 60/60), so the *regime* is safe — but the crash rate
+is noisy: only 2 of 6 starts reached <= 2%. Reproducing a specific crash rate is therefore **not
+guaranteed** at this small optimisation budget; run more starts (or a larger budget) if you need a
+target reliability. Two starts **Pareto-dominate the teacher on both axes** (start 2: 250.1 / 2.0%;
+start 4: 258.1 / 3.5%), i.e. higher score *and* fewer crashes than the mean-optimal policy.
+
+### Out-of-sample check (fresh seeds)
+
+Because the shipped weights were *selected* as the best of those 6 runs, the numbers above were
+re-checked on entirely fresh seeds — three disjoint blocks of 60 seeds x 100 episodes
+(18,000 episodes per policy) that were used neither for training nor for selection:
+
+| policy | mean | landings | crashes | seeds >= 200 |
+|---|---|---|---|---|
+| **max-safety** (this model) | **231.4** | **99.83%** | **0.17%** | 60/60 in every block |
+| mean-optimal teacher | 246.0 | 93.9% | 6.0% | 60/60 |
+| start 2 (kept in history) | 248.6 | 97.7% | 2.3% | 60/60 |
+| start 4 (kept in history) | **258.0** | 96.3% | 3.5% | 60/60 |
+
+The shipped model reproduces its canonical numbers on fresh seeds (231.4 vs 231.2 mean; 0.17% vs
+0.25% crashes), so its low crash rate is a property of the weights, not of the seed set used to
+pick them. The two variants kept in history also hold up out-of-sample and **Pareto-dominate the
+mean-optimal teacher on both axes** (higher score *and* fewer crashes).
+
+## Usage
+
+Standalone (only `torch` + `safetensors`):
+
+```python
+from model import TinyLunarPolicy
+
+policy = TinyLunarPolicy.from_pretrained("Dimitrius174/lunarlander-lin32")
+# or: TinyLunarPolicy.from_safetensors("model.safetensors")
+
+action = policy.act([0.0, 1.4, 0.0, -0.6, 0.0, 0.0, 0.0, 0.0])   # int in 0..3
+```
+
+With `transformers` (custom code via `auto_map`):
+
+```python
+import torch
+from transformers import AutoModel
+
+model = AutoModel.from_pretrained("Dimitrius174/lunarlander-lin32", trust_remote_code=True).eval()
+logits = model(torch.tensor([0.0, 1.4, 0.0, -0.6, 0.0, 0.0, 0.0, 0.0]))   # shape (4,)
+action = int(logits.argmax())
+```
+
+Gymnasium loop:
+
+```python
+import gymnasium as gym
+from model import TinyLunarPolicy
+
+env = gym.make("LunarLander-v3")
+policy = TinyLunarPolicy.from_pretrained("Dimitrius174/lunarlander-lin32")
+obs, _ = env.reset(seed=0)
+done = False
+while not done:
+    obs, _, term, trunc, _ = env.step(policy.act(obs))
+    done = term or trunc
+```
+
+## Observation and action space
+
+`obs` (8,): `x, y, vx, vy, angle, angular_velocity, leg_left_contact, leg_right_contact`.
+`action` (4): `do nothing`, `fire left engine`, `fire main engine`, `fire right engine`.
+
+## Is 32 really minimal?
+
+In a capacity study of small networks fitted to this policy (same data,
+optimiser and steps; verified on the same 60 seeds), the findings were:
+
+* the linear 32-parameter model was the **only** one that reproduced the policy under
+  every regime tried (activation, initialisation, training budget);
+* a 1-hidden-layer `tanh` MLP needed **~43-56** parameters (43 borderline, 56 reliable);
+* `ReLU`-family MLPs at the same budget were **unreliable** (some seeds solve, most do
+  not), so extra non-linearity costs parameters *and* training fragility;
+* beyond ~56 parameters nothing improves (the environment, not the network, sets the ceiling).
+
+Buying a linear layer instead of an MLP is therefore the cheap and robust choice.
+
+## Files
+
+| file | what |
+|---|---|
+| `model.py` | standalone `TinyLunarPolicy` (`nn.Module`), no extra deps |
+| `modeling_tiny.py`, `configuration_tiny.py` | `transformers` wrappers (`auto_map`, `trust_remote_code`) |
+| `config.json` | architecture + env metadata |
+| `model.safetensors` | the 32 weights (`linear.weight`, shape 4x8) — max-safety variant |
+| `verify.py` | structural checks + live Gymnasium evaluation |
+| `landing_check.py` | cross-checks the "landing rate" against the environment's own ±100 verdict |
+
+## License
+
+MIT. See `LICENSE`.

config.json

@@ -0,0 +1,39 @@
+{
+  "architectures": ["TinyLunarPolicy"],
+  "model_type": "tiny-lunar-policy",
+  "auto_map": {
+    "AutoConfig": "configuration_tiny.TinyLunarConfig",
+    "AutoModel": "modeling_tiny.TinyLunarPolicy"
+  },
+  "obs_dim": 8,
+  "n_actions": 4,
+  "bias": false,
+  "n_params": 32,
+  "variant": "max-safety",
+  "metrics_eval_60x100": {
+    "mean_return": 231.227,
+    "std_over_seeds": 3.394,
+    "seeds_with_mean_ge_200": "60/60",
+    "landing_rate": 0.9967,
+    "crash_rate": 0.0025,
+    "episodes": 6000
+  },
+  "env_id": "LunarLander-v3",
+  "observation_names": [
+    "x",
+    "y",
+    "vx",
+    "vy",
+    "angle",
+    "angular_velocity",
+    "leg_left_contact",
+    "leg_right_contact"
+  ],
+  "action_meanings": [
+    "do nothing",
+    "fire left orientation engine",
+    "fire main engine",
+    "fire right orientation engine"
+  ],
+  "torch_dtype": "float32"
+}

configuration_tiny.py

@@ -0,0 +1,12 @@
+"""Hugging Face configuration for TinyLunarPolicy (32-param linear LunarLander policy)."""
+from transformers import PretrainedConfig
+
+
+class TinyLunarConfig(PretrainedConfig):
+    model_type = "tiny-lunar-policy"
+
+    def __init__(self, obs_dim: int = 8, n_actions: int = 4, bias: bool = False, **kwargs):
+        self.obs_dim = int(obs_dim)
+        self.n_actions = int(n_actions)
+        self.bias = bool(bias)
+        super().__init__(**kwargs)

landing_check.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+"""Что значит «landing rate 94.1%»: сверяем прокси-порог (return>=100) с ВЕРДИКТОМ САМОЙ СРЕДЫ.
+
+В gymnasium LunarLander на терминальном шаге награда ПЕРЕЗАПИСЫВАЕТСЯ:
+  reward = -100  если game_over или |x|>=1.0   (крушение / вылет)
+  reward = +100  если not lander.awake          (безопасная посадка: аппарат замер)
+Поэтому категорию эпизода можно прочитать точно, по последней награде.
+"""
+import os, sys, warnings, numpy as np, gymnasium as gym
+warnings.filterwarnings('ignore')
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+from model import TinyLunarPolicy
+from verify import EVAL_SEEDS
+
+pol = TinyLunarPolicy.from_safetensors(os.path.join(HERE, 'model.safetensors'))
+env = gym.make('LunarLander-v3')
+
+rows = []
+for s in EVAL_SEEDS:
+    for ep in range(100):
+        o, _ = env.reset(seed=int(s) * 1000 + ep)
+        done, tot, last, term, trunc = False, 0.0, None, False, False
+        while not done:
+            o, r, term, trunc, info = env.step(pol.act(o))
+            tot += r
+            last = r
+            done = term or trunc
+        if term and not trunc:
+            cat = 'landed' if last == 100.0 else ('crashed' if last == -100.0 else 'other')
+        else:
+            cat = 'timeout'
+        rows.append((tot, cat))
+
+tot = np.array([x[0] for x in rows], float)
+cat = np.array([x[1] for x in rows])
+n = len(rows)
+print(f'эпизодов: {n}')
+for k in ('landed', 'crashed', 'timeout', 'other'):
+    if (cat == k).any():
+        print(f'  вердикт среды {k:8s}: {int((cat==k).sum()):5d}  { (cat==k).mean():.4f}')
+print(f'  mean return            : {tot.mean():.3f}   (эталон 247.198)')
+proxy = tot >= 100
+print(f'\nпрокси  return>=100      : {proxy.mean():.4f}  ({int(proxy.sum())}/{n})')
+print(f'среда   landed           : {(cat=="landed").mean():.4f}  ({int((cat=="landed").sum())}/{n})')
+print('\nтаблица сопряжённости (прокси x вердикт):')
+print(f'  return>=100 & landed    : {int((proxy&(cat=="landed")).sum())}')
+print(f'  return>=100 & НЕ landed : {int((proxy&(cat!="landed")).sum())}  <- ложные посадки')
+print(f'  return<100  & landed    : {int((~proxy&(cat=="landed")).sum())}  <- пропущенные посадки')
+print(f'  return<100  & НЕ landed : {int((~proxy&(cat!="landed")).sum())}')
+print(f'\nсовпадение прокси и вердикта среды: {int((proxy==(cat=="landed")).sum())}/{n} '
+      f'({(proxy==(cat=="landed")).mean()*100:.2f}%)')

model.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""TinyLunarPolicy — a 32-parameter single-layer neural network that lands LunarLander-v3.
+
+    logits = Linear(8 -> 4, bias=False)(obs)     # 32 parameters
+    action = argmax(logits)
+
+This is the *minimal* policy that solves Gymnasium `LunarLander-v3`:
+mean return ~231.2, 99.7% landings (0.25% crashes), 60/60 evaluation seeds solved (see README).
+It is exactly a single linear layer + argmax.
+
+Dependencies: torch, safetensors (numpy optional, only for `.act`).
+"""
+from __future__ import annotations
+
+import numpy as np
+import torch
+import torch.nn as nn
+
+OBS_DIM = 8
+N_ACTIONS = 4
+
+# Gymnasium LunarLander-v3 observation layout (for interpretability only).
+OBS_NAMES = [
+    "x", "y", "vx", "vy", "angle", "angular_velocity",
+    "leg_left_contact", "leg_right_contact",
+]
+
+
+class TinyLunarPolicy(nn.Module):
+    """Linear 8->4 policy head; the action is the argmax of the four logits."""
+
+    def __init__(self, obs_dim: int = OBS_DIM, n_actions: int = N_ACTIONS,
+                 bias: bool = False) -> None:
+        super().__init__()
+        self.obs_dim = int(obs_dim)
+        self.n_actions = int(n_actions)
+        self.linear = nn.Linear(self.obs_dim, self.n_actions, bias=bias)
+
+    # ── introspection ────────────────────────────────────────────────────────
+    @property
+    def n_params(self) -> int:
+        return sum(p.numel() for p in self.parameters())
+
+    def weights(self) -> np.ndarray:
+        """Return W of shape (obs_dim, n_actions) such that logits = obs @ W."""
+        return self.linear.weight.detach().cpu().numpy().T  # (8, 4)
+
+    # ── policy ───────────────────────────────────────────────────────────────
+    def forward(self, obs: torch.Tensor) -> torch.Tensor:
+        """obs: (..., 8) -> logits (..., 4)."""
+        return self.linear(obs)
+
+    @torch.no_grad()
+    def logits(self, obs) -> torch.Tensor:
+        o = torch.as_tensor(np.asarray(obs, dtype=np.float32))
+        return self.forward(o)
+
+    @torch.no_grad()
+    def act(self, obs) -> int:
+        """Greedy action for a single observation (array-like of length 8)."""
+        return int(torch.argmax(self.logits(obs)).item())
+
+    # ── loading ──────────────────────────────────────────────────────────────
+    @classmethod
+    def from_safetensors(cls, path: str, **kwargs) -> "TinyLunarPolicy":
+        """Load from a local `.safetensors` file."""
+        from safetensors.torch import load_file
+        model = cls(**kwargs)
+        model.load_state_dict(load_file(path))
+        model.eval()
+        return model
+
+    @classmethod
+    def from_pretrained(cls, repo_id_or_path: str = "Dimitrius174/lunarlander-lin32",
+                        filename: str = "model.safetensors", **kwargs) -> "TinyLunarPolicy":
+        """Load from the Hugging Face Hub (or a local directory)."""
+        import os
+        if os.path.isdir(repo_id_or_path):
+            return cls.from_safetensors(os.path.join(repo_id_or_path, filename), **kwargs)
+        from huggingface_hub import hf_hub_download
+        return cls.from_safetensors(hf_hub_download(repo_id_or_path, filename), **kwargs)

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7c7a1dae65f52640896e4a432012e461db3faaed3a8bd760025dbcc2f6645fce
+size 208

modeling_tiny.py

@@ -0,0 +1,37 @@
+"""Hugging Face `PreTrainedModel` wrapper for TinyLunarPolicy (auto_map / trust_remote_code).
+
+Usage:
+    from transformers import AutoModel
+    model = AutoModel.from_pretrained("<repo>", trust_remote_code=True)
+    logits = model(torch.tensor(obs, dtype=torch.float32))   # (4,)
+    action = int(logits.argmax())
+"""
+import torch
+import torch.nn as nn
+from transformers import PreTrainedModel
+
+from configuration_tiny import TinyLunarConfig
+
+
+class TinyLunarPolicy(PreTrainedModel):
+    config_class = TinyLunarConfig
+    # no tied weights; these two forms keep compatibility across transformers v4 and v5
+    _tied_weights_keys = []
+    all_tied_weights_keys = {}
+
+    def __init__(self, config: TinyLunarConfig):
+        super().__init__(config)
+        self.linear = nn.Linear(config.obs_dim, config.n_actions, bias=config.bias)
+
+    @property
+    def n_params(self) -> int:
+        return sum(p.numel() for p in self.parameters())
+
+    def forward(self, obs: torch.Tensor) -> torch.Tensor:
+        """obs: (..., obs_dim) -> logits (..., n_actions)."""
+        return self.linear(obs)
+
+    @torch.no_grad()
+    def act(self, obs) -> int:
+        o = torch.as_tensor(obs, dtype=torch.float32)
+        return int(self.forward(o).argmax().item())

requirements.txt

@@ -0,0 +1,8 @@
+torch>=2.0
+safetensors>=0.4
+numpy
+huggingface_hub>=0.20
+# optional: the transformers AutoModel entry point (config.json auto_map)
+transformers>=4.40
+# optional: live evaluation of the policy in Gymnasium
+gymnasium[box2d]>=0.29

verify.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+"""Reproduce the reported numbers for TinyLunarPolicy.
+
+  python verify.py                          # structural checks only (torch only)
+  python verify.py --episodes 100           # + live Gymnasium evaluation
+  python verify.py --seeds 60 --episodes 100  # full 60x100 protocol (mean ~247.2)
+
+The reported reference numbers use the 60 evaluation seeds listed in README
+(60 seeds x 100 episodes = 6000 episodes): mean 231.23, 99.67% landings, 0.25% crashes, 60/60 solved.
+"""
+from __future__ import annotations
+import argparse
+import os
+
+import numpy as np
+
+from model import TinyLunarPolicy, OBS_DIM, N_ACTIONS
+
+# The 60 evaluation seeds used for the reported reference numbers
+# (episode seed = seed * 1000 + episode_index).
+EVAL_SEEDS = [
+    40122, 42940, 51305, 55316, 60944, 61197, 93978, 96327, 103680, 157789,
+    184578, 197504, 208678, 250957, 289579, 296198, 296953, 309957, 318961, 323741,
+    349217, 350692, 373376, 382648, 383930, 385293, 393420, 400382, 414089, 450829,
+    467030, 482346, 490224, 498162, 501685, 515927, 535096, 543079, 544042, 553850,
+    555722, 571111, 615137, 634353, 642133, 660500, 665066, 684081, 732008, 743613,
+    800434, 816622, 819515, 839392, 845498, 852069, 852799, 867535, 894908, 898516,
+]
+
+
+
+def structural_checks(path: str) -> TinyLunarPolicy:
+    m = TinyLunarPolicy.from_safetensors(path)
+    W = m.weights()
+    print(f"params                : {m.n_params}   (expected 32)")
+    print(f"weights shape (obs,act): {W.shape}   (expected (8, 4))")
+    assert m.n_params == 32, m.n_params
+
+    rng = np.random.default_rng(0)
+    O = rng.standard_normal((2000, OBS_DIM)).astype(np.float32)
+    ref = np.argmax(O @ W, axis=1)                       # obs @ W  -> argmax
+    got = np.asarray([m.act(o) for o in O[:500]])         # module argmax
+    assert (ref[:500] == got).all(), "module disagrees with obs @ W argmax"
+    print(f"argmax(obs @ W) == module.act : {int((ref[:500] == got).sum())}/500  OK")
+    return m
+
+
+def live_eval(m: TinyLunarPolicy, seeds, n_ep: int, env_id: str = "LunarLander-v3"):
+    import gymnasium as gym
+    env = gym.make(env_id)
+    means, lands, crashes = [], 0, 0
+    for s in seeds:
+        rs = []
+        for ep in range(n_ep):
+            o, _ = env.reset(seed=int(s) * 1000 + ep)
+            done, tot = False, 0.0
+            while not done:
+                o, r, term, trunc, info = env.step(m.act(o))
+                tot += r
+                done = term or trunc
+            rs.append(tot)
+            lands += int(tot > 100)          # heuristic: landed (LunarLander landing ~ +100..300)
+            crashes += int(tot < -100)
+        means.append(float(np.mean(rs)))
+    means = np.asarray(means)
+    print(f"seeds={len(seeds)} x {n_ep} ep = {len(seeds) * n_ep} episodes")
+    print(f"mean={means.mean():.3f}  std={means.std():.3f}  "
+          f"min={means.min():.2f}  max={means.max():.2f}")
+    print(f"seeds with mean>=200: {int((means >= 200).sum())}/{len(means)}")
+    print(f"landing rate~{lands / (len(seeds) * n_ep):.4f}  crash rate~{crashes / (len(seeds) * n_ep):.4f}")
+    return means
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--weights", default=os.path.join(os.path.dirname(__file__), "model.safetensors"))
+    ap.add_argument("--episodes", type=int, default=0, help="episodes per seed (0 = skip live eval)")
+    ap.add_argument("--seeds", type=int, default=60, help="number of seeds to evaluate")
+    ap.add_argument("--env-id", default="LunarLander-v3")
+    a = ap.parse_args()
+
+    m = structural_checks(a.weights)
+    if a.episodes > 0:
+        live_eval(m, EVAL_SEEDS[: a.seeds], a.episodes, a.env_id)
+
+
+if __name__ == "__main__":
+    main()