rskill-robometer_4b-any-general-nf4
Requires OpenRAL Pro. This rSkill runs at
int4 (NF4)(sub-16-bit weights). Under ADR-0123, open-source OpenRAL loads only fp32, fp16 and bf16 weights; quantized formats (int8, fp8, int4/NF4, nvfp4) need the OpenRAL Pro quantization package.
OpenRAL rSkill โ Robometer-4B (Qwen3-VL-4B robotic reward foundation model) packaged as an NF4 bitsandbytes
rewardrSkill. Given a rollout's RGB frames plus the task instruction, it emits per-frame normalized progress (0โ1) and per-frame success probability, queried on demand by the Reasoner. No actuators. Advisory-only. Apache-2.0.
Preview
Per-frame progress + success on a real LIBERO libero_spatial deploy
clip โ task "pick up the black bowl and place it on the plate" โ scored live
with the NF4 Qwen3-VL-4B backbone (peak 3.79 GB, RTX 4070 Laptop 8 GB).
Progress rises from 0.44 (first 20% of frames) to 0.72 (last 20%) as the
bowl is grasped and placed:
In deploy the Reasoner scores the whole attempt (startโnow, up to
reward.frame_window_s= 40 s) and reads the last-frame value (success_now) โ what this preview reproduces on one clip. HF cards render images but not HTML5<video>; the full overlay ismedia/progress.mp4(20 frames, downloadable).Runs the lerobot 0.6.0 in-tree
RobometerRewardModel(plaintransformers, norobometergit package, notransformers==4.57.1pin), lighter than the original vendored-loader recipe.
Quick Start
openral rskill install OpenRAL/rskill-robometer_4b-any-general-nf4
from openral_core.schemas import RSkillManifest
manifest = RSkillManifest.from_yaml("rskills/robometer-4b/rskill.yaml")
assert manifest.kind == "reward"
assert manifest.role == "s2"
assert manifest.reward.progress_range == (0.0, 1.0)
assert manifest.quantization.extra["scheme"] == "nf4"
assert manifest.is_commercial_use_allowed is True
What It Does
Robometer is a general-purpose robotic reward model trained on RBM-1M (>1M trajectories across diverse embodiments, including failures) with a dual objective: a frame-level progress loss anchored on expert data and a trajectory-comparison preference loss for global ordering. Given a task instruction and a rollout video, it predicts per-frame progress (continuous values over time) and per-frame success probability.
It is kind: reward, role: s2: a pure perception consumer at S2
(slow-reasoning) rate (~0.2โ1 Hz), not an S1 fast policy. It runs in parallel
with a kind: vla policy, ingesting the VLA's camera frames into a rolling
window, and the Reasoner queries it on demand ("how is success doing now / over
the last X seconds?") to decide whether to continue, escalate to a scene VLM
(query_scene), advance to the next subgoal, or enter the replanning ladder. It
never drives ros2_control joints and never gates motors (CLAUDE.md ยง1.1).
Why a reward model alongside the VLA
A VLA policy emits actions but cannot tell whether it is succeeding. Robometer turns the camera stream into a normalized per-frame progress + success signal, so a stalled or failing rollout triggers replanning instead of running to a timeout.
Architecture
Robometer-4B finetunes Qwen/Qwen3-VL-4B-Instruct (model_type: qwen3_vl)
with three prediction heads โ progress_head, success_head, preference_head
โ on top of a frame-pooled attention readout (frame_pool_attn). The on-disk
HF config.json advertises architectures: ["RFM"]; OpenRAL loads it through
lerobot's in-tree lerobot.rewards.robometer.RobometerRewardModel and the
pre-quantized OpenRAL NF4 checkpoint, without executing the old upstream
robometer runtime package.
Runtime
The kind: reward runtime is implemented as a read-only Reasoner tool
(QueryTaskProgressTool), not an ExecuteRskill (a reward monitor produces
scalars, not actions):
- Reward monitor node:
openral_perception_ros.reward_monitor_nodeboots the NF4 model in-process, maintains a rolling time-indexed frame buffer (frame_window_s), and answers windowed progress/success queries. It loads via lerobot's in-treeRobometerRewardModelwith plaintransformers. - Frame source: abstracted for sim and real. The reward monitor consumes the
same
sensor_msgs/Imagecamera topic the co-active VLA uses โ fed by the GStreamer perception tee on real hardware, or by the sim HAL camera publisher indeploy-sim(which has no GStreamer). Indeploy-simonly camera-rendering robots expose frames; absent frames surface asROSPerceptionStale. - Reasoner tool: the LLM sees the read-only
query_task_progresstool when a reward rSkill is co-active with a VLA. It asks for the windowed assessment (progress_now,success_now, trends,stalled) and the answer feeds the next reasoning tick / the replanning ladder.
Inference contract
Discrete (binned) mode yields the normalized signal OpenRAL consumes:
compute_batch_outputs(..., sample_type="progress", is_discrete_mode=True, num_bins=100) returns progress_pred (per-frame โ [0,1]) and
outputs_success["success_probs"] (per-frame โ [0,1]). Continuous mode returns
raw, unnormalized regression values instead. Default sampling is 3 fps.
Validated live
End-to-end on an NVIDIA RTX 4070 Laptop (8 GB):
- NF4 quantization: 236
Linearmodules โLinear4bit; 8.91 GB bf16 โ 3.33 GB resident, 3.56 GB peak including an 8-frame forward โ 4.44 GB headroom for a co-resident small NF4 VLA. - Working monitor: streaming a real rollout video ("Put green stick in brown bowl") through the reward monitor, progress ramped 0.21 โ 0.88 and success spiked to 0.90 exactly at task completion, then eased.
The expandable-segments allocator config must be set before the first CUDA
allocation: PYTORCH_ALLOC_CONF=expandable_segments:True on torch โฅ2.9,
PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True on older torch (renamed in
2.9; the old name logs a deprecation warning). The reward monitor sets it for
you.
Benchmark Numbers
Paper-reported (Robometer team, March 2026, arXiv 2603.02115); not
reproduced locally, and no eval/*.json ships with this rSkill. Robometer reports more generalizable reward
functions than prior methods (GVL, VLAC, RoboDopamine, TOPReward) across
benchmarks and real-world evaluations, improving downstream robot-learning
performance. See the paper for the full tables.
Supported robots and embodiments
Embodiment-agnostic: it scores camera frames + a task instruction and emits scalars, never actuator commands, so the only hardware dependency is an RGB camera stream of at least 224ร224. It pairs with any S1 VLA policy: the VLA acts, this model reports whether the task is progressing / has succeeded.
Sensors and Observation Contract
| Direction | Key | Modality | Shape / format | Notes |
|---|---|---|---|---|
| in | any RGB camera | RGB video frames | min 224 ร 224 | the same topic the co-active VLA consumes |
| in | task instruction | text | natural language | required (instruction_required: true) |
| out | progress | float per frame | โ progress_range ([0,1]) |
normalized task progress |
| out | success | float per frame | โ [0,1] |
per-frame success probability |
The model emits no action chunks and has no proprioception contract.
Manifest Summary
| Field | Value |
|---|---|
name |
OpenRAL/rskill-robometer_4b-any-general-nf4 |
version |
0.1.0 |
license |
apache-2.0 |
role / kind |
s2 / reward |
runtime |
pytorch |
quantization.dtype / scheme |
int4 / nf4 |
weights_uri |
hf://OpenRAL/rskill-robometer_4b-any-general-nf4 (pre-quantized NF4, meta-loadable; built from the SHA-pinned upstream source_repo) |
min_vram_gb.bf16 |
9.0 GB |
min_vram_gb.int4 |
5.5 GB |
reward.frame_window_s / target_fps |
40.0 s / 3.0 fps (the Reasoner's verify scores the whole attempt startโnow, not a trailing slice) |
reward.progress_range / success_threshold / check_floor |
[0,1] / 0.8 / 0.5 |
latency_budget.per_chunk_ms |
3000 ms |
actions |
monitor |
License
The rSkill package metadata and README are OpenRAL project files under
Apache-2.0. The wrapped Robometer-4B weights are released under Apache-2.0,
permitting commercial use. No OPENRAL_ALLOW_NONCOMMERCIAL=1 flag is needed.
The model loads through lerobot's in-tree Robometer module with plain
transformers; no pinned upstream robometer runtime package is executed.
- Downloads last month
- 132



