From 55810f5050c14e6442ff9d95461b2a94bdfc0ebf Mon Sep 17 00:00:00 2001 From: DVIDIA Date: Mon, 9 Nov 2026 10:47:22 -0500 Subject: [PATCH 1/3] Add reference-endpoint model training and simulation policy bridge --- docs/camera-action-reference-model-v01.md | 144 ++++++++ .../camera_action_reference_model.py | 340 ++++++++++++++++++ tests/test_camera_action_reference_model.py | 262 ++++++++++++++ 3 files changed, 746 insertions(+) create mode 100644 docs/camera-action-reference-model-v01.md create mode 100644 src/dvidia_training/camera_action_reference_model.py create mode 100644 tests/test_camera_action_reference_model.py diff --git a/docs/camera-action-reference-model-v01.md b/docs/camera-action-reference-model-v01.md new file mode 100644 index 0000000..8ce3f85 --- /dev/null +++ b/docs/camera-action-reference-model-v01.md @@ -0,0 +1,144 @@ +# Reference-endpoint model bridge + +This additive Python module connects the verified training export to a trainable +model and a callable local simulation policy. It implements the proposed Cabs +and Cdelta comparison; **no real-study model has been fitted or evaluated with +it**. The frozen v0.1 result remains 5/64 strict learned placements and +unqualified. The common-scale parameterization and the 164-attempt v0.2 screen +still need registration before real learning or rollouts. + +The module is `dvidia_training.camera_action_reference_model`. It changes none +of the existing recorder, trainer, model, installer, actuator limits or scorer. +It provides no hardware commands, new CLI command or installation qualification. +Its policy has the same callable interface that the unchanged +`camera_action_capture.run_rollout` already accepts. That interface compatibility +is tested with synthetic contexts; no native rollout was run for this bridge. + +## From sealed training inputs to actions + +`train(sources, variant='absolute' | 'delta')` accepts one independently pinned +demonstration reference export, optionally followed by the correction export. +Each source includes its reference directory, parent cache and all independently +retained manifest, protocol, stage, split and source pins. The existing reference +loader verifies both derived artifacts. Development and confirmation data are +refused; the API has no evaluation-data argument and does not accept substituted +unverified feature/label arrays. Both stages must share a protocol. Duplicate +recordings are rejected by the existing parent-data combiner. +The combined 128,000-row cap is enforced before concatenation, normalization +or parameter initialization, including when each input fits the cap separately. + +Training uses the original causal 269-dimensional full-feedback features. It +keeps their missing-value masks, historical initial visual anchor and 160 ms +history. Exact previous normal servo references and feasible endpoints are +separate float64 arrays. Each training episode must start at the source-bound +reset reference. Issued teacher targets and mixed-control teacher suggestions +retain their separate parent provenance; a suggestion is not a claim of actual +executed control. No original frames, native traces or query bodies are read by +this module. Raw-data validation is inherited from the pinned parent cache. + +The fixed recipe is seed 17, two 64-unit tanh hidden layers, 50 epochs, batch size +512 and Adam learning rate 0.003. Both variants initialize every parameter +identically and use the same example shuffles, float32 weights and Adam moments, +gradient clipping and parameter bounds. Feature mean and standard deviation +come only from the loaded training set. Training and policy normalization both +use float64 arithmetic and then cast the normalized features to float32; saving +and loading preserves this arithmetic exactly. + +For network output `g(x)`, the two decoders are: + +```text +r0 = [0, 1.57, -1.3485, 0, 0, 0, 0.035] +D = [0.03 rad × 6, 0.001 single-finger m] +S = [3 rad × 6, 0.035 single-finger m] +Cabs endpoint = r0 + D * g(x) +Cdelta endpoint = r + D * g(x) +loss = mean(((unprojected_endpoint - feasible_target) / S)²) +``` + +The decoder, loss and backpropagation chain rule use float64. The final network +output remains float32. Training differentiates the **unprojected** endpoint +loss; it does not silently optimize a saturated/clipped output. At execution, +both variants clip to the same original native joint/jaw bounds and apply the +same exact 20-update normal-reference projection. The existing native runtime +then retains its own rate, force and task checks. This bounds reference changes; +it does not guarantee contact safety or bound actual physical joint motion. + +At initialization, for the same reset inputs and targets, both variants have +the same decoded outputs, complete-network gradients and first Adam update. +Later references intentionally change the +decoder offset and can change losses, gradients and actions. This is a controlled +parameterization, not evidence that one representation learns better. + +## Exact state and a separate model format + +`ModelPolicy` reads `context['previous_applied']` directly as double precision; +it never reconstructs that state from normalized float32 features. The first +reference must equal the original reset. Reduced-precision NumPy arrays are +refused. The existing feature encoder enforces a fresh initial visual estimate, +20 ms increasing observation times, fixed destination and causal camera/signal +timestamps. Extra teacher labels, future snapshots and native object/contact +truth do not enter model features or decoding. + +The reference's authority comes from the recorder's existing field and its +source contract. The callable interface cannot authenticate an arbitrary caller +that deliberately supplies rounded or false values as ordinary Python floats. +Tests demonstrate that two exact references sharing the same float32 feature +representation still produce distinct delta outputs. They do not pretend a +number alone proves where it came from. + +The strict model schema is `dvidia.camera-action-reference-mlp/v1`. It stores the +variant, complete contract and recipe, source identity, normalization, exact +float32 parameters and training provenance. The latter binds parent/reference +datasets, independent input pins, groups, sample counts, initialization and the +fixed optimizer budget. Save uses exclusive creation; load rejects changed +fields, sources, units, bounds, order, recipe or float32 parameter encoding. +Models remain `physical_robot_ready=false`, `task_qualified=false`, with +`scientific_registration=null`. A model file is not an experiment registration +or a qualification receipt, and these hashes are not publisher authentication. + +For a future separately registered experiment, the API is: + +```python +from dvidia_training import camera_action_reference_model as reference_model + +# sources: independently reviewed list of {directory, parent_cache, pins}. +# Each pins object is the argument set for load_reference_export, including +# expected_manifest_sha256; never replace independent pins with file contents. +candidate = reference_model.train(sources, variant="delta") +reference_model.save_model(candidate, "/absolute/new/model.json") +policy = reference_model.ModelPolicy( + reference_model.load_model("/absolute/new/model.json") +) +# The unchanged recorder can invoke policy(context). Running a new simulation +# is a separate registered experiment, not part of loading this model. +``` + +## Verification and remaining gate + +Run the focused synthetic suite locally: + +```sh +python -B -m unittest tests.test_camera_action_reference_model -v +``` + +Each suite invocation performs exactly **two synthetic 12-row fits**, one per +variant, at the complete 50-epoch recipe. It also checks complete-network +gradient and single-update reset parity, finite-difference derivatives across +all six parameter tensors, legitimate later-state differences, exact shared +normalization, save/load policy parity, missing live observations, causal-input +refusal, independent-pin refusal, label exclusion and native-reference +projection against the original two numerical limiter statements. Those +statements are evaluated as arithmetic only; no physics engine executes. + +The full-chain derivative check uses a smooth float64 finite-difference oracle. +Production float32 forward/parameter/moment behavior is checked separately by +bitwise cross-variant reset parity and saved-model inference parity. These are +implementation tests, not task benchmarks. Synthetic fit losses are not +evidence of manipulation progress. + +Before the real v0.2 screen: register this parameterization and source, verify +shared initialization on the registered reset contexts, bind the exact dataset +and resource budgets, and then run the declared fits and fresh closed-loop +attempts with independent scoring. Existing confirmation data must remain +untouched. The installer needs a separate explicit extension before this new +model format can be offered as an installable simulation candidate. diff --git a/src/dvidia_training/camera_action_reference_model.py b/src/dvidia_training/camera_action_reference_model.py new file mode 100644 index 0000000..a62e547 --- /dev/null +++ b/src/dvidia_training/camera_action_reference_model.py @@ -0,0 +1,340 @@ +"""Unregistered reference-endpoint learning bridge; no hardware/skill qualification. + +Only independently pinned, train-only reference exports are training inputs. +The callable policy fits the unchanged camera/action recorder's four-key context. +Exact prior servo references are decoder state, never reconstructed from features. +""" +from __future__ import annotations + +import ast +from copy import deepcopy +from hashlib import sha256 +import math +from pathlib import Path +import time + +import numpy as np + +from . import camera_action_model as base +from . import camera_action_export as export +from . import camera_action_reference_export as ref + +SCHEMA = 'dvidia.camera-action-reference-mlp/v1' +SCOPE = 'Unregistered simulation-only reference-endpoint research candidate; no skill or hardware qualification.' +VARIANTS = ('absolute', 'delta') +R0 = [0., 1.57, -1.3485, 0., 0., 0., .035] +D = np.asarray([.03]*6+[.001], dtype=np.float64) +S = np.asarray([3.]*6+[.035], dtype=np.float64) +CONTRACT = dict(feature_contract=base.FEATURE_CONTRACT, + feature_contract_sha256=base.FEATURE_CONTRACT_SHA256, + reference_kind='previous_applied_normal_servo_reference', reset_reference=R0, + joint_order=[f'joint{i}' for i in range(1, 7)]+['single_finger_jaw'], + action_units=['rad']*6+['single_finger_m'], increment_scale=D.tolist(), loss_scale=S.tolist(), + absolute_decoder='r0 + D*g(x)', delta_decoder='r + D*g(x)', + loss='mean(((unprojected_endpoint-feasible_target)/S)**2)', + projection='native bounds then exact original 20 normal reference updates', + network_dtype='float32', decoder_loss_and_gradients_dtype='float64', adam_moments_dtype='float32', + history_seconds=.16, control_period_s=.02, hidden_units=[64, 64], blind=False) +RECIPE = dict(seed=17, epochs=50, batch_size=512, learning_rate=.003, + beta1=.9, beta2=.999, epsilon=1e-8, gradient_clip=1., parameter_clip=base.core.MAX_WEIGHT) +MODEL_FIELDS = {'schema', 'scope', 'variant', 'physical_robot_ready', 'task_qualified', + 'scientific_registration', 'contract', 'recipe', 'source_identity', 'feature_mean', + 'feature_scale', 'weights', 'biases', 'training'} +TRAINING_FIELDS = {'algorithm', 'samples', 'groups', 'parent_dataset_sha256', + 'parent_provenance', 'parent_provenance_sha256', 'reference_dataset_sha256', + 'reference_inputs', 'initial_parameters_sha256', 'initial_loss', 'final_loss', + 'optimizer_updates', 'normalization'} +PIN_FIELDS = {'expected_manifest_sha256', 'expected_parent_manifest_sha256', + 'expected_parent_source_sha256', 'expected_protocol_sha256', 'expected_stage', + 'expected_split', 'expected_source_sha256'} + + +def source_identity(): + """Fail closed on the frozen parent, limiter or reset-source contract.""" + identity = ref.source_identity() + tree = ast.parse(Path(base.__file__).with_name('piper_task.py').read_bytes()) + cls = next(n for n in tree.body if isinstance(n, ast.ClassDef) and n.name == 'PiperTaskEnv') + reset = next(n for n in cls.body if isinstance(n, ast.FunctionDef) and n.name == 'reset') + assignments = {ast.unparse(n.targets[0]): n.value for n in ast.walk(reset) + if isinstance(n, ast.Assign) and len(n.targets) == 1} + initial = ast.literal_eval(assignments['self.data.qpos[:8]'])[:6] + initial += [ast.literal_eval(assignments['self.command_gripper'])] + if initial != R0 or ast.unparse(assignments['self.command_targets']) != 'self.data.qpos[:6].copy()': + raise ValueError('The original constant reset-reference assignment changed.') + return dict(reference_export=identity, reset_reference=initial, + model_source_sha256=sha256(Path(__file__).read_bytes()).hexdigest()) + + +def _variant(variant): + if type(variant) is not str or variant not in VARIANTS: + raise ValueError('Choose absolute or delta reference-endpoint decoding.') + + +def _input_pins(value): + if type(value) is not dict or set(value) != PIN_FIELDS: + raise ValueError('Require all independent reference and parent pins.') + if value['expected_split'] != 'train' or value['expected_stage'] not in ('demonstrations', 'corrections'): + raise ValueError('Only sealed training reference exports may enter learning.') + for field in PIN_FIELDS-{'expected_split', 'expected_stage'}: + base._hash(value[field], field) + return deepcopy(value) + + +def _load_training(sources): + """Load/check derived bytes only; do not open source recordings or query bodies.""" + if type(sources) not in (list, tuple) or not 1 <= len(sources) <= 2: + raise ValueError('Use demonstrations, optionally followed by corrections.') + datasets, previous, endpoints, inputs = [], [], [], [] + combined_rows = 0 + for index, source in enumerate(sources): + if type(source) is not dict or set(source) != {'directory', 'parent_cache', 'pins'}: + raise ValueError('Reference inputs require directories and independent pins.') + pins = _input_pins(source['pins']) + if pins['expected_stage'] != ('demonstrations', 'corrections')[index]: + raise ValueError('Preserve demonstration then correction stage order.') + if inputs and pins['expected_protocol_sha256'] != inputs[0]['pins']['expected_protocol_sha256']: + raise ValueError('Training stages require the same registered parent protocol.') + loaded = ref.load_reference_export(source['directory'], source['parent_cache'], **pins) + combined_rows += len(loaded['previous_references']) + if not 1 <= combined_rows <= ref.MAX_SAMPLES: + raise ValueError('Combined training rows exceed the reference-model sample budget.') + offset = 0 + for episode in loaded['parent_dataset']['provenance']['episodes']: + if not np.array_equal(loaded['previous_references'][offset], np.asarray(R0)): + raise ValueError('Every training episode must retain the source-bound reset reference.') + offset += episode['sample_count'] + if offset != len(loaded['previous_references']): + raise ValueError('Episode offsets must cover every exact reference.') + datasets.append(loaded['parent_dataset']) + previous.append(loaded['previous_references']); endpoints.append(loaded['feasible_targets']) + inputs.append(dict(pins=pins, samples=len(previous[-1]))) + parent = export.combine_datasets(datasets) + x, _, groups, provenance, parent_hash = base._dataset(parent, blind=False) + r = np.ascontiguousarray(np.concatenate(previous), dtype=' count: + raise ValueError('Training groups cannot exceed samples.') + for name in ('parent_dataset_sha256', 'parent_provenance_sha256', 'reference_dataset_sha256', 'initial_parameters_sha256'): + base._hash(training[name], name) + if (type(training['parent_provenance']) is not dict or not training['parent_provenance'] + or base.digest(training['parent_provenance']) != training['parent_provenance_sha256']): + raise ValueError('Parent provenance identity changed.') + items = training['reference_inputs'] + if type(items) is not list or not 1 <= len(items) <= 2: + raise ValueError('Exact reference-input provenance is required.') + total = 0 + for index, item in enumerate(items): + if type(item) is not dict or set(item) != {'pins', 'samples'}: + raise ValueError('Unknown reference-input fields.') + pins = _input_pins(item['pins']) + if (pins['expected_stage'] != ('demonstrations', 'corrections')[index] + or pins['expected_protocol_sha256'] != items[0]['pins']['expected_protocol_sha256'] + or pins['expected_source_sha256'] != ref.source_digest() + or pins['expected_parent_source_sha256'] != ref.cache.source_digest()): + raise ValueError('Training input source, protocol or stage changed.') + total += base.core._integer(item['samples'], 'input samples', 1, ref.MAX_SAMPLES) + if total != count or type(training['optimizer_updates']) is not int or training['optimizer_updates'] != 50*math.ceil(count/512): + raise ValueError('Training sample count or fixed optimizer budget changed.') + for name in ('initial_loss', 'final_loss'): + base.core._number(training[name], name, 0., 1e12) + return value + + +def save_model(document, path): + value = validate_model(document) + with Path(path).open('xb') as stream: + stream.write(base.canonical(value)+b'\n') + return base.digest(value) + + +def load_model(path): + with Path(path).open('rb') as stream: + return validate_model(stream.read(base.core.MAX_MODEL_BYTES+1)) + + +def _previous(context): + """Trust the recorder's explicit field; reject already reduced-precision arrays. + + Python floats preserve JSON doubles but cannot authenticate their provenance. + No arbitrary caller can prove reference authority just by naming this field. + """ + value = context.get('previous_applied') + if type(value) is not dict or set(value) != {'joint_targets_rad', 'gripper_position_m'}: + raise ValueError('Require the recorder\'s exact previous_applied reference.') + joints = value['joint_targets_rad']; jaw = value['gripper_position_m'] + if isinstance(joints, np.ndarray): + if joints.dtype != np.dtype('float64'): + raise ValueError('Previous references must not be reduced-precision arrays.') + elif type(joints) not in (list, tuple) or any(type(x) not in (float, int, np.float64) for x in joints): + raise ValueError('Previous references require ordinary double-precision coordinates.') + if type(jaw) not in (float, int, np.float64): + raise ValueError('The exact single-finger reference is required.') + return np.ascontiguousarray(base.action_vector(value)[None, :], dtype=' Date: Mon, 9 Nov 2026 10:48:31 -0500 Subject: [PATCH 2/3] Verify reference model portability in the existing CI matrix --- .gitattributes | 1 + .github/workflows/ci.yml | 2 ++ 2 files changed, 3 insertions(+) diff --git a/.gitattributes b/.gitattributes index b47787f..aae0277 100644 --- a/.gitattributes +++ b/.gitattributes @@ -16,6 +16,7 @@ src/dvidia_training/camera_action_capture.py text eol=lf src/dvidia_training/robot_profiles.lock.json text eol=lf src/dvidia_training/camera_action_cache.py text eol=lf src/dvidia_training/camera_action_reference_export.py text eol=lf +src/dvidia_training/camera_action_reference_model.py text eol=lf src/dvidia_training/camera_action_study.py text eol=lf src/dvidia_training/piper_rgbd_tracker.py text eol=lf src/dvidia_training/action_demonstration.py text eol=lf diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 0243095..356fccb 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -84,6 +84,8 @@ jobs: run: | python -B -m unittest tests.test_camera_action_reference_export -v python -B -m unittest discover -s benchmarks/camera-action-v02-head-preflight -p test_preflight.py -v + - name: Verify reference-model training and inference on synthetic fixtures + run: python -B -m unittest tests.test_camera_action_reference_model -v - name: Test footage, visual training and loopback studio run: python -m unittest tests.test_footage_data tests.test_footage_train tests.test_footage_pipeline tests.test_footage_benchmark tests.test_training_studio tests.test_doctor tests.test_coverage tests.test_episode_tape tests.test_reaction tests.test_reaction_metrics tests.test_reaction_convergence tests.test_reaction_benchmark tests.test_motor_memory tests.test_motor_metrics tests.test_motor_benchmark tests.test_observations tests.test_observation_models tests.test_motion tests.test_motion_benchmark tests.test_transition_model tests.test_transition_pilot tests.test_transition_cli tests.test_embodiment_calibration tests.test_embodiment_cli tests.test_reference_sim -v From 8774265fdf2a4516520cdf36ff2eb41dcd04dfda Mon Sep 17 00:00:00 2001 From: DVIDIA Date: Mon, 9 Nov 2026 11:50:54 -0500 Subject: [PATCH 3/3] Publish reference-model fits and eight failed development placements --- .../LICENSE | 21 + .../README.md | 39 + .../data/README.md | 26 + .../evidence/development-smoke-status.json | 362 +++ .../evidence/graphics-preflight.json | 50 + .../evidence/initial-smoke-accounting.json | 14 + .../evidence/integration-result.json | 217 ++ .../evidence/native-smoke-diagnosis.json | 191 ++ .../evidence/native-smoke-v3-audit.json | 2238 +++++++++++++++++ .../evidence/renderer-warnings.json | 71 + .../evidence/training-input-identity.json | 214 ++ .../models/absolute/README.md | 81 + .../models/absolute/model.json | 1 + .../models/delta/README.md | 81 + .../models/delta/model.json | 1 + ...-action-reference-model-integration-v01.md | 36 + docs/camera-action-reference-model-v01.md | 22 +- 17 files changed, 3658 insertions(+), 7 deletions(-) create mode 100644 benchmarks/camera-action-reference-model-integration-v01/LICENSE create mode 100644 benchmarks/camera-action-reference-model-integration-v01/README.md create mode 100644 benchmarks/camera-action-reference-model-integration-v01/data/README.md create mode 100644 benchmarks/camera-action-reference-model-integration-v01/evidence/development-smoke-status.json create mode 100644 benchmarks/camera-action-reference-model-integration-v01/evidence/graphics-preflight.json create mode 100644 benchmarks/camera-action-reference-model-integration-v01/evidence/initial-smoke-accounting.json create mode 100644 benchmarks/camera-action-reference-model-integration-v01/evidence/integration-result.json create mode 100644 benchmarks/camera-action-reference-model-integration-v01/evidence/native-smoke-diagnosis.json create mode 100644 benchmarks/camera-action-reference-model-integration-v01/evidence/native-smoke-v3-audit.json create mode 100644 benchmarks/camera-action-reference-model-integration-v01/evidence/renderer-warnings.json create mode 100644 benchmarks/camera-action-reference-model-integration-v01/evidence/training-input-identity.json create mode 100644 benchmarks/camera-action-reference-model-integration-v01/models/absolute/README.md create mode 100644 benchmarks/camera-action-reference-model-integration-v01/models/absolute/model.json create mode 100644 benchmarks/camera-action-reference-model-integration-v01/models/delta/README.md create mode 100644 benchmarks/camera-action-reference-model-integration-v01/models/delta/model.json create mode 100644 docs/camera-action-reference-model-integration-v01.md diff --git a/benchmarks/camera-action-reference-model-integration-v01/LICENSE b/benchmarks/camera-action-reference-model-integration-v01/LICENSE new file mode 100644 index 0000000..a7056f2 --- /dev/null +++ b/benchmarks/camera-action-reference-model-integration-v01/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2026 DVIDIA contributors + +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. diff --git a/benchmarks/camera-action-reference-model-integration-v01/README.md b/benchmarks/camera-action-reference-model-integration-v01/README.md new file mode 100644 index 0000000..9412fb4 --- /dev/null +++ b/benchmarks/camera-action-reference-model-integration-v01/README.md @@ -0,0 +1,39 @@ +# DVIDIA reference-model training and inference integration + +Two small PiPER research candidates now train and serialize successfully from the same 96,000 training rows. The absolute-reference fit took 5.230713 s and the prior-reference delta fit took 5.097628 s on the measured shared CPU host. Both saved models reproduced all 1,000 outputs in the recorded-trajectory replay. This validates the learning/inference bridge, not task completion. + +- [Absolute candidate card](models/absolute/README.md) +- [Delta candidate card](models/delta/README.md) +- [Derived-data card](data/README.md) +- [Compact integration receipt](evidence/integration-result.json) +- [Training reference identity](evidence/training-input-identity.json) +- [Initial native smoke refusal accounting](evidence/initial-smoke-accounting.json) +- [All three engineering batches](evidence/development-smoke-status.json) +- [Independent eight-attempt native audit](evidence/native-smoke-v3-audit.json) +- [Renderer warnings](evidence/renderer-warnings.json) +- [Strict-state failure diagnosis](evidence/native-smoke-diagnosis.json) + +The third separately registered native batch completed eight attempts: **0/4 strict placements for each candidate**. Cabs made bilateral contact in 3/4 and a qualified lift in 1/4; Cdelta contacted in 4/4 and lifted in 0/4. Neither completed carry. Unexpected contacts occurred in 2/4 Cabs episodes and 4/4 Cdelta episodes. All four delta traces crossed the strict scorer’s finite TCP coordinate envelope of ±0.5 m; this was not a NaN or physics-warning failure. Full per-case evidence is retained, together with the sixteen earlier infrastructure refusals. No candidate was selected or qualified; the proposed 164-attempt screen and frozen v0.1 result are unchanged. + +The two candidate model files are included under `models/absolute/model.json` and `models/delta/model.json`. They are usable through the pinned Python API; this new model format is not supported by the qualified-skill CLI installer. Raw training recordings and derived reference arrays are not redistributed here. Original artifacts and source commit `78ea4fbb4b2733e7738eb425eeecd7cb67a52195` are unchanged. Exact original result SHA-256: `6d44d98488ef26f949412aadc94c32174bd5c4ce879442191b9784deff5b325f`. + + +## Inspect a retained candidate + +Use a source checkout containing this benchmark and the unchanged runtime bytes identified below. Install the package and its existing NumPy dependency with `python -m pip install -e .`, then run Python from the repository root: + +```python +from dvidia_training import camera_action_reference_model as reference_model + +model = reference_model.load_model( + "benchmarks/camera-action-reference-model-integration-v01/models/delta/model.json" +) +assert not model["task_qualified"] +assert not model["physical_robot_ready"] +policy = reference_model.ModelPolicy(model) +print(model["variant"], model["training"]["samples"]) +``` + +Loading does not start a simulator, read a camera or command hardware. Calling `policy(context)` requires the recorder's exact causal context and retained float64 previous reference, beginning at the registered reset; an arbitrary image or joint vector does not satisfy that contract. Any next native experiment requires its own registration; these two candidates remain unchanged. Do not infer operational task success from successful loading or a training-trajectory replay. + +Source at measurement: [`78ea4fbb4b2733e7738eb425eeecd7cb67a52195`](https://github.com/Dvidia-Inference/dvidia-training/tree/78ea4fbb4b2733e7738eb425eeecd7cb67a52195). See [the model bridge contract](../../docs/camera-action-reference-model-v01.md) and [integration notes](../../docs/camera-action-reference-model-integration-v01.md). diff --git a/benchmarks/camera-action-reference-model-integration-v01/data/README.md b/benchmarks/camera-action-reference-model-integration-v01/data/README.md new file mode 100644 index 0000000..96597c3 --- /dev/null +++ b/benchmarks/camera-action-reference-model-integration-v01/data/README.md @@ -0,0 +1,26 @@ +--- +license: mit +language: +- en +tags: +- robotics +- simulation +- demonstrations +- research +--- + +# DVIDIA PiPER reference training data + +This card describes the derived training inputs for both retained reference-model candidates. This data directory contains an identity receipt; the benchmark does not redistribute raw videos, caches or reference arrays. Both candidate model files are included separately. + +The data comprises 96,000 control rows from 96 existing simulation episodes in 32 training starting-position groups: 64 authored-teacher demonstrations covering both destinations, followed by 32 previously collected mixed-control corrections. These are synchronized simulated camera/action data, not recovered actions from human video. Development and confirmation episodes are excluded from fitting. + +Each parent row contains 269 causal features, the issued-teacher or separately recorded teacher-query target, group ownership and provenance. Each reference export adds two C-order float64 `(N, 7)` arrays: exact previous normal servo references and feasible target endpoints. Six dimensions use radians; the seventh is the single-finger jaw coordinate in metres. Reset references come from the recording reset; later references come from the preceding step's actual normal ramp state. The original 20 updates are applied to teacher labels. For mixed control this is counterfactual normal-reference supervision, not a statement that those labels were executed. + +The parent cache was built through the original strict exporter. The reference-export construction verified sealed recording metadata and caller-pinned parent data; cache/reference loads validate derived bytes without re-reading raw RGB-D frames. This integration experiment did not revalidate raw recordings. Array, protocol, stage, source, parent dataset and manifest identities are in [training-input-identity.json](../evidence/training-input-identity.json). + +Source: [DVIDIA training at the benchmark commit](https://github.com/Dvidia-Inference/dvidia-training/tree/78ea4fbb4b2733e7738eb425eeecd7cb67a52195). Training uses only training-data normalization. Current teacher actions, future observations and native object/contact truth are excluded from features. Missing visual observations remain masked, and historical estimates retain their age semantics. + +These bounded synthetic demonstrations do not establish transfer to shoes, arbitrary videos, other arms or physical hardware. Model training losses and a single training-trajectory replay do not establish generalization. The original dataset ownership and failure accounting are preserved. + +DVIDIA-generated derived data and accompanying documentation use [MIT](../LICENSE). Upstream simulator and robot asset licenses remain separate. No raw human footage, credentials or upstream model weights are included in this benchmark. diff --git a/benchmarks/camera-action-reference-model-integration-v01/evidence/development-smoke-status.json b/benchmarks/camera-action-reference-model-integration-v01/evidence/development-smoke-status.json new file mode 100644 index 0000000..d029aaa --- /dev/null +++ b/benchmarks/camera-action-reference-model-integration-v01/evidence/development-smoke-status.json @@ -0,0 +1,362 @@ +{ + "critical_contact_metrics": "See per-variant critical_contact_ticks and episodes_with_critical_contact in native-smoke-v3-audit.json.", + "evidence_state": "locally_validated_unqualified; remote hosting not asserted", + "funnel_metrics": { + "absolute": { + "callback_including_guard": { + "calls": 4000, + "maximum_seconds": 0.008621292014140636, + "median_seconds": 0.00023227051133289933, + "p95_seconds": 0.00029546011064667254 + }, + "carry_complete": 0, + "complete_episodes": 4, + "critical_contact_ticks": 7606, + "episodes_with_critical_contact": 2, + "full_boundary": { + "calls": 4000, + "maximum_seconds": 0.051054958981694654, + "median_seconds": 0.013028145520365797, + "p95_seconds": 0.022362537491426335 + }, + "grasp_seen": 3, + "lift_seen": 1, + "qualified": false, + "retention_lost": 0, + "scheduled": 4, + "scored_control_trajectories": 4, + "strict_successes": 0, + "terminal_only_successes": 0 + }, + "delta": { + "callback_including_guard": { + "calls": 4000, + "maximum_seconds": 0.021589000010862947, + "median_seconds": 0.00023095900542102754, + "p95_seconds": 0.0002842972404323518 + }, + "carry_complete": 0, + "complete_episodes": 4, + "critical_contact_ticks": 19751, + "episodes_with_critical_contact": 4, + "full_boundary": { + "calls": 4000, + "maximum_seconds": 0.058383833995321766, + "median_seconds": 0.013461853988701478, + "p95_seconds": 0.02204904312093276 + }, + "grasp_seen": 4, + "lift_seen": 0, + "qualified": false, + "retention_lost": 0, + "scheduled": 4, + "scored_control_trajectories": 4, + "strict_successes": 0, + "terminal_only_successes": 0 + } + }, + "independently_scored_control_trajectories": 8, + "initial_infrastructure_batches": [ + { + "initialization_refusals": 8, + "plan_sha256": "3818be616fe37f976e2b31f86a21f5c429f11b4e4131a43d5174ed1bb771e289", + "policy_callbacks": 0, + "recorded_control_intervals": 0, + "result": { + "bytes": 6130, + "sha256": "2e9a40eaa5799f3bc6d0d36ee10f5fe8a6cf0bfe387f428f399d66a4e9c5c6fe" + }, + "rows": [ + { + "files_verified": 2, + "id": "development-00-goal0-absolute", + "recorded_complete_intervals": 0, + "rollout_error": { + "message": "No network or child process inside native worker.", + "type": "RuntimeError" + }, + "startup_permission_closed": null, + "startup_probe_calls": 0, + "variant": "absolute", + "worker_receipt": { + "bytes": 2444, + "sha256": "059ef7b8732056b28e73b2dd50bd56dd95bbc22d9c633a9736609131f841ba42" + } + }, + { + "files_verified": 2, + "id": "development-00-goal0-delta", + "recorded_complete_intervals": 0, + "rollout_error": { + "message": "No network or child process inside native worker.", + "type": "RuntimeError" + }, + "startup_permission_closed": null, + "startup_probe_calls": 0, + "variant": "delta", + "worker_receipt": { + "bytes": 2435, + "sha256": "fb67f2ba4ed0a69f294541987288b40be51e7886302b976be43de547b5021dcc" + } + }, + { + "files_verified": 2, + "id": "development-00-goal1-absolute", + "recorded_complete_intervals": 0, + "rollout_error": { + "message": "No network or child process inside native worker.", + "type": "RuntimeError" + }, + "startup_permission_closed": null, + "startup_probe_calls": 0, + "variant": "absolute", + "worker_receipt": { + "bytes": 2443, + "sha256": "71285854d1e4f590a3b58fd4f97819ae46eb4d58d50d4932ddf34abed93884fd" + } + }, + { + "files_verified": 2, + "id": "development-00-goal1-delta", + "recorded_complete_intervals": 0, + "rollout_error": { + "message": "No network or child process inside native worker.", + "type": "RuntimeError" + }, + "startup_permission_closed": null, + "startup_probe_calls": 0, + "variant": "delta", + "worker_receipt": { + "bytes": 2434, + "sha256": "651a0ac311d20c08023a84945604f9591cacd12bfe7bc41fda763927ae4927c7" + } + }, + { + "files_verified": 2, + "id": "development-01-goal0-absolute", + "recorded_complete_intervals": 0, + "rollout_error": { + "message": "No network or child process inside native worker.", + "type": "RuntimeError" + }, + "startup_permission_closed": null, + "startup_probe_calls": 0, + "variant": "absolute", + "worker_receipt": { + "bytes": 2443, + "sha256": "fbc5c5419755eef28cd877949f534146c0594b65a6cfc44d784c21552c544516" + } + }, + { + "files_verified": 2, + "id": "development-01-goal0-delta", + "recorded_complete_intervals": 0, + "rollout_error": { + "message": "No network or child process inside native worker.", + "type": "RuntimeError" + }, + "startup_permission_closed": null, + "startup_probe_calls": 0, + "variant": "delta", + "worker_receipt": { + "bytes": 2434, + "sha256": "527b2af2befa2a1461db9d65b2730f790800937a3f97e2ae73f7b49c8f6c3214" + } + }, + { + "files_verified": 2, + "id": "development-01-goal1-absolute", + "recorded_complete_intervals": 0, + "rollout_error": { + "message": "No network or child process inside native worker.", + "type": "RuntimeError" + }, + "startup_permission_closed": null, + "startup_probe_calls": 0, + "variant": "absolute", + "worker_receipt": { + "bytes": 2443, + "sha256": "47c9609434b19a8c8da621cf0bb4a6c21fc64b1249bb26104a9f02669be40ff6" + } + }, + { + "files_verified": 2, + "id": "development-01-goal1-delta", + "recorded_complete_intervals": 0, + "rollout_error": { + "message": "No network or child process inside native worker.", + "type": "RuntimeError" + }, + "startup_permission_closed": null, + "startup_probe_calls": 0, + "variant": "delta", + "worker_receipt": { + "bytes": 2435, + "sha256": "9ae30452ca490e2adab099bc62206abdae3d029fbaa7c8c7e281ae20780a3ae8" + } + } + ], + "run_id": "reference-model-development-smoke-20261109", + "scheduled_attempts": 8 + }, + { + "initialization_refusals": 8, + "plan_sha256": "600b2129fc44c21e092390269e50ff43766262808b88add6d4718ea301c0d8e8", + "policy_callbacks": 0, + "recorded_control_intervals": 0, + "result": { + "bytes": 6664, + "sha256": "017d7ae05f64b8539d950ec00063345f30571e4a89086e06411b1b038c9a335c" + }, + "rows": [ + { + "files_verified": 2, + "id": "development-00-goal0-absolute", + "recorded_complete_intervals": 0, + "rollout_error": { + "message": "invalid CoreGraphics connection", + "type": "CGLError" + }, + "startup_permission_closed": true, + "startup_probe_calls": 1, + "variant": "absolute", + "worker_receipt": { + "bytes": 2918, + "sha256": "d3f14709e112bec83b112bf5391f61aebe4277b39adb5956030ebb4a11d6add6" + } + }, + { + "files_verified": 2, + "id": "development-00-goal0-delta", + "recorded_complete_intervals": 0, + "rollout_error": { + "message": "invalid CoreGraphics connection", + "type": "CGLError" + }, + "startup_permission_closed": true, + "startup_probe_calls": 1, + "variant": "delta", + "worker_receipt": { + "bytes": 2910, + "sha256": "965fba1d8c1e06eef6694ef65ec4d87dbf58966013712cd9aa8e6a2e8a426b04" + } + }, + { + "files_verified": 2, + "id": "development-00-goal1-absolute", + "recorded_complete_intervals": 0, + "rollout_error": { + "message": "invalid CoreGraphics connection", + "type": "CGLError" + }, + "startup_permission_closed": true, + "startup_probe_calls": 1, + "variant": "absolute", + "worker_receipt": { + "bytes": 2917, + "sha256": "de91ed38603f1ca847de2fbf0416687e52d5c4084a9bdf2242d5726c600c5fa8" + } + }, + { + "files_verified": 2, + "id": "development-00-goal1-delta", + "recorded_complete_intervals": 0, + "rollout_error": { + "message": "invalid CoreGraphics connection", + "type": "CGLError" + }, + "startup_permission_closed": true, + "startup_probe_calls": 1, + "variant": "delta", + "worker_receipt": { + "bytes": 2909, + "sha256": "aa0c157fbc73e6b501d9e1085fa526e153a322144709c175de18d212ee9fd4a7" + } + }, + { + "files_verified": 2, + "id": "development-01-goal0-absolute", + "recorded_complete_intervals": 0, + "rollout_error": { + "message": "invalid CoreGraphics connection", + "type": "CGLError" + }, + "startup_permission_closed": true, + "startup_probe_calls": 1, + "variant": "absolute", + "worker_receipt": { + "bytes": 2919, + "sha256": "c0cc1bacebe5f93cd1392df3f59dd617a6bcefb01caa508ae04116eedd377306" + } + }, + { + "files_verified": 2, + "id": "development-01-goal0-delta", + "recorded_complete_intervals": 0, + "rollout_error": { + "message": "invalid CoreGraphics connection", + "type": "CGLError" + }, + "startup_permission_closed": true, + "startup_probe_calls": 1, + "variant": "delta", + "worker_receipt": { + "bytes": 2909, + "sha256": "39b0786aaaeff0455416928bb05bdb8e69738573d3250bd88ba7a1a065dff260" + } + }, + { + "files_verified": 2, + "id": "development-01-goal1-absolute", + "recorded_complete_intervals": 0, + "rollout_error": { + "message": "invalid CoreGraphics connection", + "type": "CGLError" + }, + "startup_permission_closed": true, + "startup_probe_calls": 1, + "variant": "absolute", + "worker_receipt": { + "bytes": 2918, + "sha256": "ed64a04c503121a0649365fd24aa63a6aa357ab83633743820f1b4352a69ab3c" + } + }, + { + "files_verified": 2, + "id": "development-01-goal1-delta", + "recorded_complete_intervals": 0, + "rollout_error": { + "message": "invalid CoreGraphics connection", + "type": "CGLError" + }, + "startup_permission_closed": true, + "startup_probe_calls": 1, + "variant": "delta", + "worker_receipt": { + "bytes": 2909, + "sha256": "885c5b7ec717d1b8790cec4299c1a29e52024abac6cbd70b8bb3c5a3bf059cc7" + } + } + ], + "run_id": "reference-model-development-smoke-v2-20261109", + "scheduled_attempts": 8 + } + ], + "interpretation": "Report0/4 strict placements per model on four reused development scenarios. The prior16 infrastructure refusals are retained separately, not pooled into a0/24 manipulation score. This is not a generalization or comparator study.", + "learned_callback_latency": "See per-variant callback_including_guard distributions in native-smoke-v3-audit.json.", + "native_audit_sha256": "098c3c7b8c678790cc089dbec50d5c7c874e0a54da72844e48c49222683f9d7f", + "native_initialization_scope": "First eight import refusals and second eight graphics refusals remain separate. Third batch used separately registered scoped graphics access and completed all8 native learned-control attempts; neither model succeeded.", + "native_plan_sha256": "9912b3b86abe889d81073b1fee1c9cad9655264fdb325abbbf60dbebd89a490b", + "native_result_file": { + "bytes": 7153, + "sha256": "597277fd6c4671a7d2791aa861beb5da896573fcbf51f8db08e30d4bc501284e" + }, + "next_prerequisite": "A separately registered failure-correction experiment; no automatic retries, tuning or new qualification.", + "policy_callbacks": 8000, + "qualified": false, + "recorded_control_intervals": 8000, + "review_receipt_sha256": "2270d1043e8dd68286627d15f2c4f039a7fdda9913d843ebe5e7551e1523367e", + "scheduled_attempts_across_batches": 24, + "schema": "dvidia.reference-model-development-smoke-status/v2", + "selection_performed": false +} diff --git a/benchmarks/camera-action-reference-model-integration-v01/evidence/graphics-preflight.json b/benchmarks/camera-action-reference-model-integration-v01/evidence/graphics-preflight.json new file mode 100644 index 0000000..f4e355a --- /dev/null +++ b/benchmarks/camera-action-reference-model-integration-v01/evidence/graphics-preflight.json @@ -0,0 +1,50 @@ +{ + "results": { + "default-sandbox.json": { + "original_file": { + "bytes": 498, + "sha256": "74c96d8856d24c3f89680202b63ab67efe5a45b42a97e17ff44429d347827d7d" + }, + "result": { + "error": "invalid CoreGraphics connection", + "error_type": "CGLError", + "execution_context": "default-sandbox", + "machine": "arm64", + "mujoco": "3.15.0", + "numpy": "2.5.3", + "python": "3.12.9", + "scope": "Tiny authored static XML, forward kinematics only, one48x64RGB frame; no robot/assets/dataset/task/model weights or dynamics steps.", + "status": "failed", + "total_wall_seconds": 0.12905491699348204 + } + }, + "scoped-graphics-access.json": { + "original_file": { + "bytes": 674, + "sha256": "dbfaef196312bcd905ad97288a63732a9b57bca5eb3a4119e03a885f9af3af55" + }, + "result": { + "execution_context": "scoped-graphics-access", + "frame_dtype": "uint8", + "frame_max": 185, + "frame_min": 0, + "frame_sha256": "a1b17db25079e446d7030d4f72820efaf9c5163c0cdaccab6a7449cdee82916e", + "frame_shape": [ + 48, + 64, + 3 + ], + "machine": "arm64", + "mujoco": "3.15.0", + "numpy": "2.5.3", + "python": "3.12.9", + "render_wall_seconds": 0.020181250001769513, + "scope": "Tiny authored static XML, forward kinematics only, one48x64RGB frame; no robot/assets/dataset/task/model weights or dynamics steps.", + "status": "passed", + "total_wall_seconds": 0.16178770799888298 + } + } + }, + "schema": "dvidia.reference-model-graphics-preflight-summary/v1", + "scope": "One static48x64frame, forward kinematics only; no robot/assets/data/model weights or dynamics. Interpreter path omitted from this public summary." +} diff --git a/benchmarks/camera-action-reference-model-integration-v01/evidence/initial-smoke-accounting.json b/benchmarks/camera-action-reference-model-integration-v01/evidence/initial-smoke-accounting.json new file mode 100644 index 0000000..8a4e10b --- /dev/null +++ b/benchmarks/camera-action-reference-model-integration-v01/evidence/initial-smoke-accounting.json @@ -0,0 +1,14 @@ +{ + "cause": "The experiment wrapper prohibited MuJoCo macOS import-time sysctl subprocess; each attempt stopped before policy callbacks.", + "interpretation": "Infrastructure refusal, not measured manipulation failure. All eight scheduled attempts remain accounted for.", + "native_evaluation": "No valid closed-loop result yet. Any further attempt needs separate registration and must preserve these results.", + "native_initialization_refusals": 8, + "original_result_sha256": "2e9a40eaa5799f3bc6d0d36ee10f5fe8a6cf0bfe387f428f399d66a4e9c5c6fe", + "plan_sha256": "3818be616fe37f976e2b31f86a21f5c429f11b4e4131a43d5174ed1bb771e289", + "policy_callbacks": 0, + "qualified": false, + "scheduled_attempts": 8, + "schema": "dvidia.reference-model-initial-smoke-accounting/v1", + "selection_performed": false, + "strict_scored_rollouts": 0 +} diff --git a/benchmarks/camera-action-reference-model-integration-v01/evidence/integration-result.json b/benchmarks/camera-action-reference-model-integration-v01/evidence/integration-result.json new file mode 100644 index 0000000..6d3e80f --- /dev/null +++ b/benchmarks/camera-action-reference-model-integration-v01/evidence/integration-result.json @@ -0,0 +1,217 @@ +{ + "causal_replay_features_equal_parent": true, + "common_initialization_and_normalization": true, + "contract": { + "absolute_decoder": "r0 + D*g(x)", + "action_units": [ + "rad", + "rad", + "rad", + "rad", + "rad", + "rad", + "single_finger_m" + ], + "adam_moments_dtype": "float32", + "blind": false, + "control_period_s": 0.02, + "decoder_loss_and_gradients_dtype": "float64", + "delta_decoder": "r + D*g(x)", + "feature_contract": "camera-encoder-absolute-causal160/v1", + "feature_contract_sha256": "e2d45f2cb03b39d424559c76f11252978facdf911af541e8e294b7bb8cb03fe8", + "hidden_units": [ + 64, + 64 + ], + "history_seconds": 0.16, + "increment_scale": [ + 0.03, + 0.03, + 0.03, + 0.03, + 0.03, + 0.03, + 0.001 + ], + "joint_order": [ + "joint1", + "joint2", + "joint3", + "joint4", + "joint5", + "joint6", + "single_finger_jaw" + ], + "loss": "mean(((unprojected_endpoint-feasible_target)/S)**2)", + "loss_scale": [ + 3.0, + 3.0, + 3.0, + 3.0, + 3.0, + 3.0, + 0.035 + ], + "network_dtype": "float32", + "projection": "native bounds then exact original 20 normal reference updates", + "reference_kind": "previous_applied_normal_servo_reference", + "reset_reference": [ + 0.0, + 1.57, + -1.3485, + 0.0, + 0.0, + 0.0, + 0.035 + ] + }, + "evidence_state": "locally_validated_unqualified; remote hosting not asserted", + "feasible_endpoint_array_sha256": "d5754ace901e4d0fda4793be8e34aa9676009e8d700451937c439bd42c1d0163", + "feature_array_sha256": "8e2399f0753e20e86a50555dcf17a85c12b7c0b2583842f13da14a0bad393bee", + "fits": 2, + "forbidden_extra_input_invariance": true, + "hardware": { + "blas_threads_declared": 1, + "cpu_count": 10, + "machine": "arm64", + "numpy": "2.5.3", + "platform": "macOS-26.5.2-arm64-arm-64bit", + "processor": "arm", + "python": "3.12.9", + "shared_host": true + }, + "held_out_rows_read": 0, + "limitations": [ + "Training errors and one teacher-trajectory open-loop replay are not generalization or task success.", + "No controller was actuated, selected, qualified, installed or evaluated in a new environment.", + "Both candidates retained; frozenv01 results and unrun164-attemptv02 screen unchanged.", + "Registration binds this benchmark externally; model scientific_registration intentionally remains null." + ], + "native_rollouts": 0, + "original_metadata_files_read_count": 1003, + "original_result_sha256": "6d44d98488ef26f949412aadc94c32174bd5c4ce879442191b9784deff5b325f", + "peak_whole_process_rss_bytes": 1345404928, + "physical_robot_ready": false, + "previous_reference_array_sha256": "e2f84e643ad7e9d04fd2d993051f6873283a376c327838e2ee84733880c8af54", + "qualified": false, + "raw_recordings_revalidated": false, + "recipe": { + "batch_size": 512, + "beta1": 0.9, + "beta2": 0.999, + "epochs": 50, + "epsilon": 1e-08, + "gradient_clip": 1.0, + "learning_rate": 0.003, + "parameter_clip": 64.0, + "seed": 17 + }, + "registered_plan_sha256": "ffb52ed4226d48482010be7dc2a1acf2fa385202a0d7dc142ca3e8904cb7d4f8", + "replay_frames": 1000, + "replay_next_state_origin": "recorded teacher trajectory only", + "replay_predictions_actuated": false, + "resource_scope": "Single compute worker plus250ms resource observer. RSS/deadline/free-space stop thresholds are sampled controls, not kernel memory quotas or protection against unrelated disk writers.", + "schema": "dvidia.reference-model-integration-publication-summary/v1", + "script_sha256": "1cc8f9a82d7381ba56db401c9ea89246b67df4d281e930fc664001b888754a69", + "selection_performed": false, + "source_commit": "78ea4fbb4b2733e7738eb425eeecd7cb67a52195", + "source_identity_sha256": "12ea9757cb0d76573c2e67f80b56ab08271f95e43f18b344b6481cc9153d70bc", + "status": "complete", + "timing_scope": "Fit includes source/derived-input validation and normalization. Callback timing includes causal encoding, NumPy inference and reference projection; excludes camera/render/physics/transport. RSS is whole-process high-water mark, not an isolated model allocation.", + "total_wall_seconds": 12.93291958401096, + "training_rows_per_fit": 96000, + "variants": { + "absolute": { + "final_training_loss": 7.926108883701983e-06, + "fit_wall_seconds": 5.230713041994022, + "initial_training_loss": 0.04009072663323015, + "loaded_open_loop_callback_wall": { + "calls": 1000, + "maximum_seconds": 0.0003341670089866966, + "median_seconds": 0.00018152050324715674, + "p95_seconds": 0.0002062101018964313, + "sum_seconds": 0.18355957081075758 + }, + "model_content_sha256": "36af3fe1670494b04c48b5114d9be1a5f91632aa7992ba529d6587969ea37460", + "model_file": { + "bytes": 539345, + "sha256": "3dbf6911d92a9072297c9c3bb7c09f45809808272455ffd5562f4553a173f362" + }, + "model_save_load_identity": true, + "open_loop_callback_wall": { + "calls": 1000, + "maximum_seconds": 0.00027541699819266796, + "median_seconds": 0.0001818129967432469, + "p95_seconds": 0.00020484020933508873, + "sum_seconds": 0.18381304285139777 + }, + "open_loop_prediction_file": { + "bytes": 56128, + "sha256": "5dfbcebbb33a0a628b9e82ff5508097b7ec7b190566b2979a5f20255943dc914" + }, + "open_loop_saved_policy_outputs_bitwise_equal": true, + "peak_whole_process_rss_bytes_so_far": 1334378496, + "qualified": false, + "training": { + "algorithm": "numpy-tanh-2x64-adam-native-endpoint-mse/v1", + "final_loss": 7.926108883701983e-06, + "group_count": 32, + "initial_loss": 0.04009072663323015, + "initial_parameters_sha256": "9c50504160213ad5241d6d96ab9be938d6f49b1c4bf49ff39d0770dac83dce7e", + "normalization": "training features only; no label whitening", + "optimizer_updates": 9400, + "parent_dataset_sha256": "b500b3ba348bba44cc79e377266f92910bd7e0165c36cd8b2fe260909b30a2f9", + "parent_provenance_sha256": "52cbeda62e3aa50e8cd6a34688fba7583f9fcec927cb0eb434a6907c99695f4f", + "reference_dataset_sha256": "a9dcd66a81f177bb1910e08171ac7607f115ed47b51d93412107eb0e204aed73", + "samples": 96000 + }, + "training_trajectory_projected_endpoint_scaled_mse": 1.8801026187180245e-06 + }, + "delta": { + "final_training_loss": 3.531327787737655e-06, + "fit_wall_seconds": 5.097628457995597, + "initial_training_loss": 8.72223173973333e-05, + "loaded_open_loop_callback_wall": { + "calls": 1000, + "maximum_seconds": 0.00024516700068488717, + "median_seconds": 0.0001821249898057431, + "p95_seconds": 0.00020668574870796871, + "sum_seconds": 0.18321760100661777 + }, + "model_content_sha256": "4545be31f50267c9da29b211510c7a32df500678ba107c7a100604bb0c4c18ab", + "model_file": { + "bytes": 538021, + "sha256": "fece6d056e50a1bde41bdb9960bf7cbc81d983c4bfdb03a07632e30b712b1489" + }, + "model_save_load_identity": true, + "open_loop_callback_wall": { + "calls": 1000, + "maximum_seconds": 0.0002842499816324562, + "median_seconds": 0.00018272899615112692, + "p95_seconds": 0.00020738332968903706, + "sum_seconds": 0.18398747508763336 + }, + "open_loop_prediction_file": { + "bytes": 56128, + "sha256": "a741d006667a559c846c4b2cf19c88ea81ea4eaa55d75c53583e415e1f0dd665" + }, + "open_loop_saved_policy_outputs_bitwise_equal": true, + "peak_whole_process_rss_bytes_so_far": 1345404928, + "qualified": false, + "training": { + "algorithm": "numpy-tanh-2x64-adam-native-endpoint-mse/v1", + "final_loss": 3.531327787737655e-06, + "group_count": 32, + "initial_loss": 8.72223173973333e-05, + "initial_parameters_sha256": "9c50504160213ad5241d6d96ab9be938d6f49b1c4bf49ff39d0770dac83dce7e", + "normalization": "training features only; no label whitening", + "optimizer_updates": 9400, + "parent_dataset_sha256": "b500b3ba348bba44cc79e377266f92910bd7e0165c36cd8b2fe260909b30a2f9", + "parent_provenance_sha256": "52cbeda62e3aa50e8cd6a34688fba7583f9fcec927cb0eb434a6907c99695f4f", + "reference_dataset_sha256": "a9dcd66a81f177bb1910e08171ac7607f115ed47b51d93412107eb0e204aed73", + "samples": 96000 + }, + "training_trajectory_projected_endpoint_scaled_mse": 6.222337738975971e-07 + } + } +} diff --git a/benchmarks/camera-action-reference-model-integration-v01/evidence/native-smoke-diagnosis.json b/benchmarks/camera-action-reference-model-integration-v01/evidence/native-smoke-diagnosis.json new file mode 100644 index 0000000..1225743 --- /dev/null +++ b/benchmarks/camera-action-reference-model-integration-v01/evidence/native-smoke-diagnosis.json @@ -0,0 +1,191 @@ +{ + "delta_strict_violations": [ + { + "all_strict_vector_fields_finite": true, + "first_strict_state_envelope_violation": { + "object_position_m": [ + 0.4871081710122422, + -0.17988504093974045, + 0.09353123557334052 + ], + "state_index": 739, + "t_seconds": 14.779999999997248, + "table_object_contact_count": 1, + "violations": [ + { + "allowed_inclusive": [ + -0.5, + 0.5 + ], + "axis": "x", + "component": 0, + "field": "tcp_position_m", + "finite": true, + "value": 0.5018659985967776 + } + ] + }, + "id": "development-00-goal0-delta", + "integrity": { + "bytes": 567674, + "sha256": "d4a89f2555c2e9d86c745fbc0b20be34b39ce3fb2400d037a91c63a6d7d0cd1a" + }, + "native_episode": { + "bytes": 3274472, + "sha256": "3f91710eb25b61a0fb6c64fa050cc8406f8d11b2eeff3a65dee1502eb2c5fd8f" + }, + "physics_warnings": [] + }, + { + "all_strict_vector_fields_finite": true, + "first_strict_state_envelope_violation": { + "object_position_m": [ + 0.32931879716563506, + -0.12798862211401657, + 0.0798922445797837 + ], + "state_index": 713, + "t_seconds": 14.259999999997536, + "table_object_contact_count": 4, + "violations": [ + { + "allowed_inclusive": [ + -0.5, + 0.5 + ], + "axis": "x", + "component": 0, + "field": "tcp_position_m", + "finite": true, + "value": 0.5033371506888265 + } + ] + }, + "id": "development-00-goal1-delta", + "integrity": { + "bytes": 567674, + "sha256": "d9a2f3b46a3906153b5ee703d915c809b9d5903996abbc948a31ab42fae1e1dd" + }, + "native_episode": { + "bytes": 3199780, + "sha256": "c38becb927b94c6c7478c76253f86ee4a656f8d8ab1c482258fdfb5ef4dfa8b2" + }, + "physics_warnings": [] + }, + { + "all_strict_vector_fields_finite": true, + "first_strict_state_envelope_violation": { + "object_position_m": [ + 0.36982822089212286, + -0.17378339194526918, + 0.0798922445797837 + ], + "state_index": 687, + "t_seconds": 13.739999999997824, + "table_object_contact_count": 4, + "violations": [ + { + "allowed_inclusive": [ + -0.5, + 0.5 + ], + "axis": "z", + "component": 2, + "field": "tcp_position_m", + "finite": true, + "value": 0.5049848841298252 + } + ] + }, + "id": "development-01-goal0-delta", + "integrity": { + "bytes": 567674, + "sha256": "1f4b2db19b5c0ded4438d9cc549a65e6a25a9f1691118a4363f93bf0646e2a89" + }, + "native_episode": { + "bytes": 3081538, + "sha256": "51b909802d8da08157c87cc1d1dffac6eea4b28a8f9448669b5cc02797e961ae" + }, + "physics_warnings": [] + }, + { + "all_strict_vector_fields_finite": true, + "first_strict_state_envelope_violation": { + "object_position_m": [ + 0.4070060436188808, + -0.18591757382039348, + 0.0798922445794117 + ], + "state_index": 735, + "t_seconds": 14.699999999997292, + "table_object_contact_count": 4, + "violations": [ + { + "allowed_inclusive": [ + -0.5, + 0.5 + ], + "axis": "x", + "component": 0, + "field": "tcp_position_m", + "finite": true, + "value": 0.5001573804075903 + } + ] + }, + "id": "development-01-goal1-delta", + "integrity": { + "bytes": 567674, + "sha256": "99a748732c1cbb7761ec00b786a680da20f01b0abb038214451be42d069cd8e2" + }, + "native_episode": { + "bytes": 3104558, + "sha256": "42e5e034ee6c8a6d4cf58cdf7efe2d7545f4554d2e0253b6eca42d477e623da0" + }, + "physics_warnings": [] + } + ], + "interpretation": { + "causality": "Own-state reference drift is a candidate mechanism; this read-only smoke does not establish its cause or isolate a treatment. No tuning or model ranking conclusion from four cases per variant.", + "contact_scope": "Critical ticks count 1ms simulated timesteps with at least one critical contact, not independent collision events. No real hardware force inference.", + "delta_state_failure": "All four delta trajectories contain finite TCP coordinates outside the unchanged strict scorer component envelope [-0.5,0.5] metres. Generic invalid_state_value is not a NaN or solver-warning diagnosis.", + "dominant_failure": "Seven cases never achieved the required sustained bilateral table-free lift; one absolute case lifted but did not complete supported placement, release or retreat by the 20-second budget. All eight failed retained carry completion.", + "floor_case": "development-00-goal0-delta first fails on TCP x while block still has one table contact. It later ends with four explicitly mapped block-floor contacts, no table support, and block centre z=0.019892m.", + "prior_batches": "Two distinct eight-attempt initialization-refusal batches are preserved and linked from the v3 result. Those had zero controller calls and are not control performance evaluations.", + "timing_scope": "Model diagnostic includes causal feature encoding, NumPy inference and feasible-reference projection. Pooled callback includes separate cooperative disk guard. Full boundary includes captured simulation and measurement work. Rendering estimates are offline, with depth-accuracy warning; no physical latency claim.", + "valid_semantics": "Outer valid checks native arrays, recomputed metrics and warning-free native physics; success additionally requires unchanged strict_v01 and native task success. Valid is not a task, workspace or safety qualification." + }, + "model_selection": false, + "new_native_executions": 0, + "new_training_fits": 0, + "original_analysis_file": { + "bytes": 51280, + "sha256": "7ea36145088fda3e6e39a280c8e537d8ed0a1acab9503f1604ff812f1e971373" + }, + "qualified": false, + "result": { + "bytes": 7153, + "sha256": "597277fd6c4671a7d2791aa861beb5da896573fcbf51f8db08e30d4bc501284e" + }, + "schema": "dvidia.reference-model-smoke-diagnosis-summary/v1", + "scope": "Compact read-only diagnosis derived from the separately retained full analysis, not new simulation or a causal treatment experiment.", + "source_bindings": { + "camera_action_reference_model.py": { + "bytes": 19771, + "sha256": "952750fd6b99f97eb96054b8fe50710b83f7e8eb4e069601be442292dd0023bc" + }, + "piper_feedback_score.py": { + "bytes": 18866, + "sha256": "863a272828208c631de4cf57647e973eb3e4f5e99eb7a1eacb4eaa68dc42eb0e" + }, + "piper_imitation_score.py": { + "bytes": 11462, + "sha256": "0cd4663abfdd7f14f2f33d93e9a2bd45122b998d6160d45b8afcc880512cba2b" + }, + "piper_task.py": { + "bytes": 34355, + "sha256": "e66a44a8df4e7a8ee42e4f3866f889f8797cdfb8e2688a146e09b75d2c76664f" + } + }, + "source_commit": "78ea4fbb4b2733e7738eb425eeecd7cb67a52195" +} diff --git a/benchmarks/camera-action-reference-model-integration-v01/evidence/native-smoke-v3-audit.json b/benchmarks/camera-action-reference-model-integration-v01/evidence/native-smoke-v3-audit.json new file mode 100644 index 0000000..1af1e86 --- /dev/null +++ b/benchmarks/camera-action-reference-model-integration-v01/evidence/native-smoke-v3-audit.json @@ -0,0 +1,2238 @@ +{ + "attempts": [ + { + "camera_pairs": 501, + "case": { + "goal_id": 0, + "goal_position_m": [ + 0.35, + 0.08, + 0.08 + ], + "group_id": "development-00", + "id": "development-00-goal0", + "object_position_m": [ + 0.303692, + -0.033335, + 0.082 + ], + "seed": 311465, + "split": "development" + }, + "files_verified": 5010, + "frame_bytes": 168843964, + "guard": { + "checks": 1000, + "forwarded_calls": 1000, + "guard_wall_seconds": 0.00523591969977133, + "minimum_free_bytes": 40582459392, + "scope": "Once per simulated20ms callback, not a wall-clock50Hz monitor; no task features changed.", + "stop_reason": null + }, + "id": "development-00-goal0-absolute", + "inspection": { + "files_verified": 5010, + "physical_robot_ready": false, + "physics_executed": false, + "recorded_complete_intervals": 1000, + "schema": "dvidia.camera-action-rollout/v2/inspection", + "score": { + "evidence_scope": "Recomputed simulator-authored numeric evidence; no physics rerun, source attestation or hardware sensing.", + "false_alarms": { + "reason": "Continuous residual policy has no declared discrete alarm events.", + "status": "not_applicable" + }, + "grip_events": [ + { + "kind": "supported_grip_interruption", + "loss_onset_s": 12.229999999998661, + "loss_qualified_s": 12.24899999999865, + "onset_to_qualified_restoration_s": null, + "onset_to_restoration_s": null, + "relative_motion_since_loss_m": 0.037587862924821816, + "restoration_onset_s": null, + "restoration_qualified_s": null, + "restored": false, + "supported_at_onset": true + } + ], + "grip_summary": { + "airborne_events": 0, + "loss_events": 1, + "qualification_latency_s": [], + "restored_events": 0, + "supported_events": 1, + "unresolved_events": 1 + }, + "native_diagnostics": { + "premature_open_jaw": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + }, + "support_touchdown_before_destination": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + } + }, + "native_metrics_mismatches": [], + "native_recomputed": { + "carry_complete": false, + "carry_contact_loss_events": 0, + "dwell_seconds": 0.0, + "first_success_time_seconds": null, + "grasp_seen": true, + "lift_dwell_seconds": 0.0, + "lift_seen": false, + "max_carry_contact_loss_seconds": 0.0, + "max_object_lift_m": 0.003952023743962793, + "max_pad_normal_force_n": 2.795753702369255, + "retention_lost": false, + "success": false, + "unexpected_contact_native_ticks": 7454 + }, + "reason": "native_outcome_failed", + "restoration_scope": "Loaded contact restored for 100 ms after sustained loss; does not establish task recovery or airborne regrasp.", + "schema": "dvidia.piper-feedback-score/v1", + "strict_v01": { + "native_metrics_source": "simulator-authored episode record; not authenticated sensor input", + "native_outcome_success": false, + "native_outcome_valid": true, + "reason": "native_outcome_failed", + "reference_xy_m": [ + 0.35, + 0.08 + ], + "required_dwell_s": 0.25, + "required_lift_dwell_s": 0.1, + "sample_interval_s": 0.02, + "success": false, + "terminal_dwell_s": 0.0, + "terminal_reference_success": false, + "terminal_xy_error_m": 0.13859914919704855, + "trace_lift_dwell_s": 0.0, + "trajectory_complete": true + }, + "success": false, + "terminal_only": { + "dwell_s": 0.0, + "scope": "Terminal-only geometry/release/settling/dwell; excludes lift, carry and retention history.", + "success": false, + "terminal_xy_error_m": 0.13859914919704855 + }, + "valid": true + }, + "source_authenticated": false, + "status": "complete", + "strict_success": false + }, + "integrity_file": { + "bytes": 567674, + "sha256": "714cc6d64114af14d9d75967c57f7f977ed0c40df9ea87e601f3836eee99990a" + }, + "perception": { + "available": 384, + "decisions": 1000, + "longest_missing_seconds": 12.120000000000001, + "missing": 616 + }, + "policy": { + "model_sha256": "36af3fe1670494b04c48b5114d9be1a5f91632aa7992ba529d6587969ea37460", + "physical_robot_ready": false, + "policy_origin": "camera_encoder_reference_endpoint_numpy_mlp", + "runtime_teacher_available": false, + "student_inference_calls": 1000, + "student_inference_p95_seconds": 0.00026722680195234716, + "student_inference_seconds": 0.23363784674438648, + "task_qualified": false, + "teacher_fallback_calls": 0, + "timing_scope": "Causal feature encoding, NumPy inference and reference projection; excludes camera/render/actuation.", + "variant": "absolute" + }, + "qualified": false, + "recorded_complete_intervals": 1000, + "rollout_error": null, + "rollout_file": { + "bytes": 326965, + "sha256": "1104da3991eb6c3872c85c46eec6d4a5dcb89c0a10752d57c5ebc8071b14dee9" + }, + "rollout_status": "complete", + "rollout_wall_seconds": 12.169444583007134, + "score": { + "evidence_scope": "Recomputed simulator-authored numeric evidence; no physics rerun, source attestation or hardware sensing.", + "false_alarms": { + "reason": "Continuous residual policy has no declared discrete alarm events.", + "status": "not_applicable" + }, + "grip_events": [ + { + "kind": "supported_grip_interruption", + "loss_onset_s": 12.229999999998661, + "loss_qualified_s": 12.24899999999865, + "onset_to_qualified_restoration_s": null, + "onset_to_restoration_s": null, + "relative_motion_since_loss_m": 0.037587862924821816, + "restoration_onset_s": null, + "restoration_qualified_s": null, + "restored": false, + "supported_at_onset": true + } + ], + "grip_summary": { + "airborne_events": 0, + "loss_events": 1, + "qualification_latency_s": [], + "restored_events": 0, + "supported_events": 1, + "unresolved_events": 1 + }, + "native_diagnostics": { + "premature_open_jaw": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + }, + "support_touchdown_before_destination": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + } + }, + "native_metrics_mismatches": [], + "native_recomputed": { + "carry_complete": false, + "carry_contact_loss_events": 0, + "dwell_seconds": 0.0, + "first_success_time_seconds": null, + "grasp_seen": true, + "lift_dwell_seconds": 0.0, + "lift_seen": false, + "max_carry_contact_loss_seconds": 0.0, + "max_object_lift_m": 0.003952023743962793, + "max_pad_normal_force_n": 2.795753702369255, + "retention_lost": false, + "success": false, + "unexpected_contact_native_ticks": 7454 + }, + "reason": "native_outcome_failed", + "restoration_scope": "Loaded contact restored for 100 ms after sustained loss; does not establish task recovery or airborne regrasp.", + "schema": "dvidia.piper-feedback-score/v1", + "strict_v01": { + "native_metrics_source": "simulator-authored episode record; not authenticated sensor input", + "native_outcome_success": false, + "native_outcome_valid": true, + "reason": "native_outcome_failed", + "reference_xy_m": [ + 0.35, + 0.08 + ], + "required_dwell_s": 0.25, + "required_lift_dwell_s": 0.1, + "sample_interval_s": 0.02, + "success": false, + "terminal_dwell_s": 0.0, + "terminal_reference_success": false, + "terminal_xy_error_m": 0.13859914919704855, + "trace_lift_dwell_s": 0.0, + "trajectory_complete": true + }, + "success": false, + "terminal_only": { + "dwell_s": 0.0, + "scope": "Terminal-only geometry/release/settling/dwell; excludes lift, carry and retention history.", + "success": false, + "terminal_xy_error_m": 0.13859914919704855 + }, + "valid": true + }, + "scored_control_trajectory": true, + "strict_success": false, + "supervisor_cause": null, + "supervisor_status": "finished", + "variant": "absolute", + "worker_receipt": { + "bytes": 5163, + "sha256": "f3907fe87706a0f8f4593fe2e790c81ebc8018c185fa6ed17cd46f63c441019b" + }, + "worker_receipt_available": true, + "worker_wall_seconds": 13.846535541000776 + }, + { + "camera_pairs": 501, + "case": { + "goal_id": 0, + "goal_position_m": [ + 0.35, + 0.08, + 0.08 + ], + "group_id": "development-00", + "id": "development-00-goal0", + "object_position_m": [ + 0.303692, + -0.033335, + 0.082 + ], + "seed": 311465, + "split": "development" + }, + "files_verified": 5010, + "frame_bytes": 168625930, + "guard": { + "checks": 1000, + "forwarded_calls": 1000, + "guard_wall_seconds": 0.005588873696979135, + "minimum_free_bytes": 40378089472, + "scope": "Once per simulated20ms callback, not a wall-clock50Hz monitor; no task features changed.", + "stop_reason": null + }, + "id": "development-00-goal0-delta", + "inspection": { + "files_verified": 5010, + "physical_robot_ready": false, + "physics_executed": false, + "recorded_complete_intervals": 1000, + "schema": "dvidia.camera-action-rollout/v2/inspection", + "score": { + "evidence_scope": "Recomputed simulator-authored numeric evidence; no physics rerun, source attestation or hardware sensing.", + "false_alarms": { + "reason": "Continuous residual policy has no declared discrete alarm events.", + "status": "not_applicable" + }, + "grip_events": [ + { + "kind": "supported_grip_interruption", + "loss_onset_s": 12.32299999999861, + "loss_qualified_s": 12.341999999998599, + "onset_to_qualified_restoration_s": 0.4259999999997639, + "onset_to_restoration_s": 0.32699999999981877, + "relative_motion_since_loss_m": 0.033405944668013256, + "restoration_onset_s": 12.649999999998428, + "restoration_qualified_s": 12.748999999998373, + "restoration_supported": false, + "restored": true, + "supported_at_onset": true + }, + { + "kind": "supported_grip_interruption", + "loss_onset_s": 13.181999999998133, + "loss_qualified_s": 13.200999999998123, + "onset_to_qualified_restoration_s": 0.21699999999987973, + "onset_to_restoration_s": 0.1179999999999346, + "relative_motion_since_loss_m": 0.0201096558077051, + "restoration_onset_s": 13.299999999998068, + "restoration_qualified_s": 13.398999999998013, + "restoration_supported": true, + "restored": true, + "supported_at_onset": true + }, + { + "kind": "supported_grip_interruption", + "loss_onset_s": 17.108999999997927, + "loss_qualified_s": 17.12799999999795, + "onset_to_qualified_restoration_s": null, + "onset_to_restoration_s": null, + "relative_motion_since_loss_m": 0.2010864554938082, + "restoration_onset_s": null, + "restoration_qualified_s": null, + "restored": false, + "supported_at_onset": true + } + ], + "grip_summary": { + "airborne_events": 0, + "loss_events": 3, + "qualification_latency_s": [ + 0.4259999999997639, + 0.21699999999987973 + ], + "restored_events": 2, + "supported_events": 3, + "unresolved_events": 1 + }, + "native_diagnostics": { + "premature_open_jaw": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + }, + "support_touchdown_before_destination": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + } + }, + "native_metrics_mismatches": [], + "native_recomputed": { + "carry_complete": false, + "carry_contact_loss_events": 0, + "dwell_seconds": 0.0, + "first_success_time_seconds": null, + "grasp_seen": true, + "lift_dwell_seconds": 0.0, + "lift_seen": false, + "max_carry_contact_loss_seconds": 0.0, + "max_object_lift_m": 0.032622070113360255, + "max_pad_normal_force_n": 16.822725404528523, + "retention_lost": false, + "success": false, + "unexpected_contact_native_ticks": 7280 + }, + "reason": "invalid_state_value", + "restoration_scope": "Loaded contact restored for 100 ms after sustained loss; does not establish task recovery or airborne regrasp.", + "schema": "dvidia.piper-feedback-score/v1", + "strict_v01": { + "reason": "invalid_state_value", + "reference_xy_m": [ + 0.35, + 0.08 + ], + "state_index": 739, + "success": false + }, + "success": false, + "terminal_only": { + "dwell_s": 0.0, + "scope": "Terminal-only geometry/release/settling/dwell; excludes lift, carry and retention history.", + "success": false, + "terminal_xy_error_m": 0.35894977561012875 + }, + "valid": true + }, + "source_authenticated": false, + "status": "complete", + "strict_success": false + }, + "integrity_file": { + "bytes": 567674, + "sha256": "d4a89f2555c2e9d86c745fbc0b20be34b39ce3fb2400d037a91c63a6d7d0cd1a" + }, + "perception": { + "available": 472, + "decisions": 1000, + "longest_missing_seconds": 6.16, + "missing": 528 + }, + "policy": { + "model_sha256": "4545be31f50267c9da29b211510c7a32df500678ba107c7a100604bb0c4c18ab", + "physical_robot_ready": false, + "policy_origin": "camera_encoder_reference_endpoint_numpy_mlp", + "runtime_teacher_available": false, + "student_inference_calls": 1000, + "student_inference_p95_seconds": 0.00028345415339572346, + "student_inference_seconds": 0.2566282909247093, + "task_qualified": false, + "teacher_fallback_calls": 0, + "timing_scope": "Causal feature encoding, NumPy inference and reference projection; excludes camera/render/actuation.", + "variant": "delta" + }, + "qualified": false, + "recorded_complete_intervals": 1000, + "rollout_error": null, + "rollout_file": { + "bytes": 327328, + "sha256": "328cf546022fd2f79da3ec1a6161c0d3ebd777bd254edd89903a2629966a5c8e" + }, + "rollout_status": "complete", + "rollout_wall_seconds": 13.231359249999514, + "score": { + "evidence_scope": "Recomputed simulator-authored numeric evidence; no physics rerun, source attestation or hardware sensing.", + "false_alarms": { + "reason": "Continuous residual policy has no declared discrete alarm events.", + "status": "not_applicable" + }, + "grip_events": [ + { + "kind": "supported_grip_interruption", + "loss_onset_s": 12.32299999999861, + "loss_qualified_s": 12.341999999998599, + "onset_to_qualified_restoration_s": 0.4259999999997639, + "onset_to_restoration_s": 0.32699999999981877, + "relative_motion_since_loss_m": 0.033405944668013256, + "restoration_onset_s": 12.649999999998428, + "restoration_qualified_s": 12.748999999998373, + "restoration_supported": false, + "restored": true, + "supported_at_onset": true + }, + { + "kind": "supported_grip_interruption", + "loss_onset_s": 13.181999999998133, + "loss_qualified_s": 13.200999999998123, + "onset_to_qualified_restoration_s": 0.21699999999987973, + "onset_to_restoration_s": 0.1179999999999346, + "relative_motion_since_loss_m": 0.0201096558077051, + "restoration_onset_s": 13.299999999998068, + "restoration_qualified_s": 13.398999999998013, + "restoration_supported": true, + "restored": true, + "supported_at_onset": true + }, + { + "kind": "supported_grip_interruption", + "loss_onset_s": 17.108999999997927, + "loss_qualified_s": 17.12799999999795, + "onset_to_qualified_restoration_s": null, + "onset_to_restoration_s": null, + "relative_motion_since_loss_m": 0.2010864554938082, + "restoration_onset_s": null, + "restoration_qualified_s": null, + "restored": false, + "supported_at_onset": true + } + ], + "grip_summary": { + "airborne_events": 0, + "loss_events": 3, + "qualification_latency_s": [ + 0.4259999999997639, + 0.21699999999987973 + ], + "restored_events": 2, + "supported_events": 3, + "unresolved_events": 1 + }, + "native_diagnostics": { + "premature_open_jaw": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + }, + "support_touchdown_before_destination": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + } + }, + "native_metrics_mismatches": [], + "native_recomputed": { + "carry_complete": false, + "carry_contact_loss_events": 0, + "dwell_seconds": 0.0, + "first_success_time_seconds": null, + "grasp_seen": true, + "lift_dwell_seconds": 0.0, + "lift_seen": false, + "max_carry_contact_loss_seconds": 0.0, + "max_object_lift_m": 0.032622070113360255, + "max_pad_normal_force_n": 16.822725404528523, + "retention_lost": false, + "success": false, + "unexpected_contact_native_ticks": 7280 + }, + "reason": "invalid_state_value", + "restoration_scope": "Loaded contact restored for 100 ms after sustained loss; does not establish task recovery or airborne regrasp.", + "schema": "dvidia.piper-feedback-score/v1", + "strict_v01": { + "reason": "invalid_state_value", + "reference_xy_m": [ + 0.35, + 0.08 + ], + "state_index": 739, + "success": false + }, + "success": false, + "terminal_only": { + "dwell_s": 0.0, + "scope": "Terminal-only geometry/release/settling/dwell; excludes lift, carry and retention history.", + "success": false, + "terminal_xy_error_m": 0.35894977561012875 + }, + "valid": true + }, + "scored_control_trajectory": true, + "strict_success": false, + "supervisor_cause": null, + "supervisor_status": "finished", + "variant": "delta", + "worker_receipt": { + "bytes": 5647, + "sha256": "96102ceb6a288286b88dfac78b6e48fd2ad5f7fec02e5278b641802e0c650e7b" + }, + "worker_receipt_available": true, + "worker_wall_seconds": 14.912654209008906 + }, + { + "camera_pairs": 501, + "case": { + "goal_id": 1, + "goal_position_m": [ + 0.4, + -0.08, + 0.08 + ], + "group_id": "development-00", + "id": "development-00-goal1", + "object_position_m": [ + 0.303692, + -0.033335, + 0.082 + ], + "seed": 311466, + "split": "development" + }, + "files_verified": 5010, + "frame_bytes": 168809295, + "guard": { + "checks": 1000, + "forwarded_calls": 1000, + "guard_wall_seconds": 0.005257312848698348, + "minimum_free_bytes": 40164065280, + "scope": "Once per simulated20ms callback, not a wall-clock50Hz monitor; no task features changed.", + "stop_reason": null + }, + "id": "development-00-goal1-absolute", + "inspection": { + "files_verified": 5010, + "physical_robot_ready": false, + "physics_executed": false, + "recorded_complete_intervals": 1000, + "schema": "dvidia.camera-action-rollout/v2/inspection", + "score": { + "evidence_scope": "Recomputed simulator-authored numeric evidence; no physics rerun, source attestation or hardware sensing.", + "false_alarms": { + "reason": "Continuous residual policy has no declared discrete alarm events.", + "status": "not_applicable" + }, + "grip_events": [ + { + "kind": "supported_grip_interruption", + "loss_onset_s": 11.205999999999229, + "loss_qualified_s": 11.224999999999218, + "onset_to_qualified_restoration_s": null, + "onset_to_restoration_s": null, + "relative_motion_since_loss_m": 0.032740883409154146, + "restoration_onset_s": null, + "restoration_qualified_s": null, + "restored": false, + "supported_at_onset": true + } + ], + "grip_summary": { + "airborne_events": 0, + "loss_events": 1, + "qualification_latency_s": [], + "restored_events": 0, + "supported_events": 1, + "unresolved_events": 1 + }, + "native_diagnostics": { + "premature_open_jaw": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + }, + "support_touchdown_before_destination": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + } + }, + "native_metrics_mismatches": [], + "native_recomputed": { + "carry_complete": false, + "carry_contact_loss_events": 0, + "dwell_seconds": 0.0, + "first_success_time_seconds": null, + "grasp_seen": true, + "lift_dwell_seconds": 0.0, + "lift_seen": false, + "max_carry_contact_loss_seconds": 0.0, + "max_object_lift_m": 0.005454372207929728, + "max_pad_normal_force_n": 1.8253660550428599, + "retention_lost": false, + "success": false, + "unexpected_contact_native_ticks": 152 + }, + "reason": "native_outcome_failed", + "restoration_scope": "Loaded contact restored for 100 ms after sustained loss; does not establish task recovery or airborne regrasp.", + "schema": "dvidia.piper-feedback-score/v1", + "strict_v01": { + "native_metrics_source": "simulator-authored episode record; not authenticated sensor input", + "native_outcome_success": false, + "native_outcome_valid": true, + "reason": "native_outcome_failed", + "reference_xy_m": [ + 0.4, + -0.08 + ], + "required_dwell_s": 0.25, + "required_lift_dwell_s": 0.1, + "sample_interval_s": 0.02, + "success": false, + "terminal_dwell_s": 0.0, + "terminal_reference_success": false, + "terminal_xy_error_m": 0.004566382464358538, + "trace_lift_dwell_s": 0.0, + "trajectory_complete": true + }, + "success": false, + "terminal_only": { + "dwell_s": 0.0, + "scope": "Terminal-only geometry/release/settling/dwell; excludes lift, carry and retention history.", + "success": false, + "terminal_xy_error_m": 0.004566382464358537 + }, + "valid": true + }, + "source_authenticated": false, + "status": "complete", + "strict_success": false + }, + "integrity_file": { + "bytes": 567674, + "sha256": "08f7fbfcfa7a595575b5bf9e35f64a22a265862f3a33044282199847598bf095" + }, + "perception": { + "available": 320, + "decisions": 1000, + "longest_missing_seconds": 13.36, + "missing": 680 + }, + "policy": { + "model_sha256": "36af3fe1670494b04c48b5114d9be1a5f91632aa7992ba529d6587969ea37460", + "physical_robot_ready": false, + "policy_origin": "camera_encoder_reference_endpoint_numpy_mlp", + "runtime_teacher_available": false, + "student_inference_calls": 1000, + "student_inference_p95_seconds": 0.0002635062483022921, + "student_inference_seconds": 0.22442970832344145, + "task_qualified": false, + "teacher_fallback_calls": 0, + "timing_scope": "Causal feature encoding, NumPy inference and reference projection; excludes camera/render/actuation.", + "variant": "absolute" + }, + "qualified": false, + "recorded_complete_intervals": 1000, + "rollout_error": null, + "rollout_file": { + "bytes": 326955, + "sha256": "8b851f39d22f39b02709c7857d1c2a6afa2420e83d200e7ee9564baeeba82b07" + }, + "rollout_status": "complete", + "rollout_wall_seconds": 12.444784249993972, + "score": { + "evidence_scope": "Recomputed simulator-authored numeric evidence; no physics rerun, source attestation or hardware sensing.", + "false_alarms": { + "reason": "Continuous residual policy has no declared discrete alarm events.", + "status": "not_applicable" + }, + "grip_events": [ + { + "kind": "supported_grip_interruption", + "loss_onset_s": 11.205999999999229, + "loss_qualified_s": 11.224999999999218, + "onset_to_qualified_restoration_s": null, + "onset_to_restoration_s": null, + "relative_motion_since_loss_m": 0.032740883409154146, + "restoration_onset_s": null, + "restoration_qualified_s": null, + "restored": false, + "supported_at_onset": true + } + ], + "grip_summary": { + "airborne_events": 0, + "loss_events": 1, + "qualification_latency_s": [], + "restored_events": 0, + "supported_events": 1, + "unresolved_events": 1 + }, + "native_diagnostics": { + "premature_open_jaw": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + }, + "support_touchdown_before_destination": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + } + }, + "native_metrics_mismatches": [], + "native_recomputed": { + "carry_complete": false, + "carry_contact_loss_events": 0, + "dwell_seconds": 0.0, + "first_success_time_seconds": null, + "grasp_seen": true, + "lift_dwell_seconds": 0.0, + "lift_seen": false, + "max_carry_contact_loss_seconds": 0.0, + "max_object_lift_m": 0.005454372207929728, + "max_pad_normal_force_n": 1.8253660550428599, + "retention_lost": false, + "success": false, + "unexpected_contact_native_ticks": 152 + }, + "reason": "native_outcome_failed", + "restoration_scope": "Loaded contact restored for 100 ms after sustained loss; does not establish task recovery or airborne regrasp.", + "schema": "dvidia.piper-feedback-score/v1", + "strict_v01": { + "native_metrics_source": "simulator-authored episode record; not authenticated sensor input", + "native_outcome_success": false, + "native_outcome_valid": true, + "reason": "native_outcome_failed", + "reference_xy_m": [ + 0.4, + -0.08 + ], + "required_dwell_s": 0.25, + "required_lift_dwell_s": 0.1, + "sample_interval_s": 0.02, + "success": false, + "terminal_dwell_s": 0.0, + "terminal_reference_success": false, + "terminal_xy_error_m": 0.004566382464358538, + "trace_lift_dwell_s": 0.0, + "trajectory_complete": true + }, + "success": false, + "terminal_only": { + "dwell_s": 0.0, + "scope": "Terminal-only geometry/release/settling/dwell; excludes lift, carry and retention history.", + "success": false, + "terminal_xy_error_m": 0.004566382464358537 + }, + "valid": true + }, + "scored_control_trajectory": true, + "strict_success": false, + "supervisor_cause": null, + "supervisor_status": "finished", + "variant": "absolute", + "worker_receipt": { + "bytes": 5151, + "sha256": "d1456147a5784b4e80621edf48f807401a953ad8d5f168ea559c202e39eff446" + }, + "worker_receipt_available": true, + "worker_wall_seconds": 14.14837254100712 + }, + { + "camera_pairs": 501, + "case": { + "goal_id": 1, + "goal_position_m": [ + 0.4, + -0.08, + 0.08 + ], + "group_id": "development-00", + "id": "development-00-goal1", + "object_position_m": [ + 0.303692, + -0.033335, + 0.082 + ], + "seed": 311466, + "split": "development" + }, + "files_verified": 5010, + "frame_bytes": 168741922, + "guard": { + "checks": 1000, + "forwarded_calls": 1000, + "guard_wall_seconds": 0.005355292814783752, + "minimum_free_bytes": 39958847488, + "scope": "Once per simulated20ms callback, not a wall-clock50Hz monitor; no task features changed.", + "stop_reason": null + }, + "id": "development-00-goal1-delta", + "inspection": { + "files_verified": 5010, + "physical_robot_ready": false, + "physics_executed": false, + "recorded_complete_intervals": 1000, + "schema": "dvidia.camera-action-rollout/v2/inspection", + "score": { + "evidence_scope": "Recomputed simulator-authored numeric evidence; no physics rerun, source attestation or hardware sensing.", + "false_alarms": { + "reason": "Continuous residual policy has no declared discrete alarm events.", + "status": "not_applicable" + }, + "grip_events": [], + "grip_summary": { + "airborne_events": 0, + "loss_events": 0, + "qualification_latency_s": [], + "restored_events": 0, + "supported_events": 0, + "unresolved_events": 0 + }, + "native_diagnostics": { + "premature_open_jaw": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + }, + "support_touchdown_before_destination": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + } + }, + "native_metrics_mismatches": [], + "native_recomputed": { + "carry_complete": false, + "carry_contact_loss_events": 0, + "dwell_seconds": 0.0, + "first_success_time_seconds": null, + "grasp_seen": true, + "lift_dwell_seconds": 0.0, + "lift_seen": false, + "max_carry_contact_loss_seconds": 0.0, + "max_object_lift_m": 0.0011216542473738017, + "max_pad_normal_force_n": 1.7540589205645145, + "retention_lost": false, + "success": false, + "unexpected_contact_native_ticks": 8087 + }, + "reason": "invalid_state_value", + "restoration_scope": "Loaded contact restored for 100 ms after sustained loss; does not establish task recovery or airborne regrasp.", + "schema": "dvidia.piper-feedback-score/v1", + "strict_v01": { + "reason": "invalid_state_value", + "reference_xy_m": [ + 0.4, + -0.08 + ], + "state_index": 713, + "success": false + }, + "success": false, + "terminal_only": { + "dwell_s": 0.0, + "scope": "Terminal-only geometry/release/settling/dwell; excludes lift, carry and retention history.", + "success": false, + "terminal_xy_error_m": 0.08543266510853878 + }, + "valid": true + }, + "source_authenticated": false, + "status": "complete", + "strict_success": false + }, + "integrity_file": { + "bytes": 567674, + "sha256": "d9a2f3b46a3906153b5ee703d915c809b9d5903996abbc948a31ab42fae1e1dd" + }, + "perception": { + "available": 436, + "decisions": 1000, + "longest_missing_seconds": 4.92, + "missing": 564 + }, + "policy": { + "model_sha256": "4545be31f50267c9da29b211510c7a32df500678ba107c7a100604bb0c4c18ab", + "physical_robot_ready": false, + "policy_origin": "camera_encoder_reference_endpoint_numpy_mlp", + "runtime_teacher_available": false, + "student_inference_calls": 1000, + "student_inference_p95_seconds": 0.0002676416508620605, + "student_inference_seconds": 0.2281716027064249, + "task_qualified": false, + "teacher_fallback_calls": 0, + "timing_scope": "Causal feature encoding, NumPy inference and reference projection; excludes camera/render/actuation.", + "variant": "delta" + }, + "qualified": false, + "recorded_complete_intervals": 1000, + "rollout_error": null, + "rollout_file": { + "bytes": 326204, + "sha256": "83dee39e2cb1cbfd3ef72c741d854627bf54c021852ffb1430c66fe4b8fe8452" + }, + "rollout_status": "complete", + "rollout_wall_seconds": 12.688531916995998, + "score": { + "evidence_scope": "Recomputed simulator-authored numeric evidence; no physics rerun, source attestation or hardware sensing.", + "false_alarms": { + "reason": "Continuous residual policy has no declared discrete alarm events.", + "status": "not_applicable" + }, + "grip_events": [], + "grip_summary": { + "airborne_events": 0, + "loss_events": 0, + "qualification_latency_s": [], + "restored_events": 0, + "supported_events": 0, + "unresolved_events": 0 + }, + "native_diagnostics": { + "premature_open_jaw": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + }, + "support_touchdown_before_destination": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + } + }, + "native_metrics_mismatches": [], + "native_recomputed": { + "carry_complete": false, + "carry_contact_loss_events": 0, + "dwell_seconds": 0.0, + "first_success_time_seconds": null, + "grasp_seen": true, + "lift_dwell_seconds": 0.0, + "lift_seen": false, + "max_carry_contact_loss_seconds": 0.0, + "max_object_lift_m": 0.0011216542473738017, + "max_pad_normal_force_n": 1.7540589205645145, + "retention_lost": false, + "success": false, + "unexpected_contact_native_ticks": 8087 + }, + "reason": "invalid_state_value", + "restoration_scope": "Loaded contact restored for 100 ms after sustained loss; does not establish task recovery or airborne regrasp.", + "schema": "dvidia.piper-feedback-score/v1", + "strict_v01": { + "reason": "invalid_state_value", + "reference_xy_m": [ + 0.4, + -0.08 + ], + "state_index": 713, + "success": false + }, + "success": false, + "terminal_only": { + "dwell_s": 0.0, + "scope": "Terminal-only geometry/release/settling/dwell; excludes lift, carry and retention history.", + "success": false, + "terminal_xy_error_m": 0.08543266510853878 + }, + "valid": true + }, + "scored_control_trajectory": true, + "strict_success": false, + "supervisor_cause": null, + "supervisor_status": "finished", + "variant": "delta", + "worker_receipt": { + "bytes": 4443, + "sha256": "2d7d66b18c09275dd56980c72ee73cf6ab3b7b3f9a25d438e7175c8dbbbbaa03" + }, + "worker_receipt_available": true, + "worker_wall_seconds": 14.580125999986194 + }, + { + "camera_pairs": 501, + "case": { + "goal_id": 0, + "goal_position_m": [ + 0.35, + 0.08, + 0.08 + ], + "group_id": "development-01", + "id": "development-01-goal0", + "object_position_m": [ + 0.303637, + -0.039966, + 0.082 + ], + "seed": 311467, + "split": "development" + }, + "files_verified": 5010, + "frame_bytes": 169510528, + "guard": { + "checks": 1000, + "forwarded_calls": 1000, + "guard_wall_seconds": 0.005813365976791829, + "minimum_free_bytes": 39743258624, + "scope": "Once per simulated20ms callback, not a wall-clock50Hz monitor; no task features changed.", + "stop_reason": null + }, + "id": "development-01-goal0-absolute", + "inspection": { + "files_verified": 5010, + "physical_robot_ready": false, + "physics_executed": false, + "recorded_complete_intervals": 1000, + "schema": "dvidia.camera-action-rollout/v2/inspection", + "score": { + "evidence_scope": "Recomputed simulator-authored numeric evidence; no physics rerun, source attestation or hardware sensing.", + "false_alarms": { + "reason": "Continuous residual policy has no declared discrete alarm events.", + "status": "not_applicable" + }, + "grip_events": [], + "grip_summary": { + "airborne_events": 0, + "loss_events": 0, + "qualification_latency_s": [], + "restored_events": 0, + "supported_events": 0, + "unresolved_events": 0 + }, + "native_diagnostics": { + "premature_open_jaw": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + }, + "support_touchdown_before_destination": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + } + }, + "native_metrics_mismatches": [], + "native_recomputed": { + "carry_complete": false, + "carry_contact_loss_events": 0, + "dwell_seconds": 0.0, + "first_success_time_seconds": null, + "grasp_seen": false, + "lift_dwell_seconds": 0.0, + "lift_seen": false, + "max_carry_contact_loss_seconds": 0.0, + "max_object_lift_m": 6.22998874710845e-11, + "max_pad_normal_force_n": 0.0, + "retention_lost": false, + "success": false, + "unexpected_contact_native_ticks": 0 + }, + "reason": "native_outcome_failed", + "restoration_scope": "Loaded contact restored for 100 ms after sustained loss; does not establish task recovery or airborne regrasp.", + "schema": "dvidia.piper-feedback-score/v1", + "strict_v01": { + "native_metrics_source": "simulator-authored episode record; not authenticated sensor input", + "native_outcome_success": false, + "native_outcome_valid": true, + "reason": "native_outcome_failed", + "reference_xy_m": [ + 0.35, + 0.08 + ], + "required_dwell_s": 0.25, + "required_lift_dwell_s": 0.1, + "sample_interval_s": 0.02, + "success": false, + "terminal_dwell_s": 0.0, + "terminal_reference_success": false, + "terminal_xy_error_m": 0.12861307125253946, + "trace_lift_dwell_s": 0.0, + "trajectory_complete": true + }, + "success": false, + "terminal_only": { + "dwell_s": 0.0, + "scope": "Terminal-only geometry/release/settling/dwell; excludes lift, carry and retention history.", + "success": false, + "terminal_xy_error_m": 0.12861307125253946 + }, + "valid": true + }, + "source_authenticated": false, + "status": "complete", + "strict_success": false + }, + "integrity_file": { + "bytes": 567674, + "sha256": "22443164911963ff89e31663dc3a938cfeffd151a8e569f2d98f2563f18a8065" + }, + "perception": { + "available": 1000, + "decisions": 1000, + "longest_missing_seconds": 0.0, + "missing": 0 + }, + "policy": { + "model_sha256": "36af3fe1670494b04c48b5114d9be1a5f91632aa7992ba529d6587969ea37460", + "physical_robot_ready": false, + "policy_origin": "camera_encoder_reference_endpoint_numpy_mlp", + "runtime_teacher_available": false, + "student_inference_calls": 1000, + "student_inference_p95_seconds": 0.00030651460547233, + "student_inference_seconds": 0.24899018558789976, + "task_qualified": false, + "teacher_fallback_calls": 0, + "timing_scope": "Causal feature encoding, NumPy inference and reference projection; excludes camera/render/actuation.", + "variant": "absolute" + }, + "qualified": false, + "recorded_complete_intervals": 1000, + "rollout_error": null, + "rollout_file": { + "bytes": 326367, + "sha256": "47f735604508f95ad78f9d863ca88f13f77b0bb4f68a4fcc4b067b967704fb97" + }, + "rollout_status": "complete", + "rollout_wall_seconds": 13.759285707987146, + "score": { + "evidence_scope": "Recomputed simulator-authored numeric evidence; no physics rerun, source attestation or hardware sensing.", + "false_alarms": { + "reason": "Continuous residual policy has no declared discrete alarm events.", + "status": "not_applicable" + }, + "grip_events": [], + "grip_summary": { + "airborne_events": 0, + "loss_events": 0, + "qualification_latency_s": [], + "restored_events": 0, + "supported_events": 0, + "unresolved_events": 0 + }, + "native_diagnostics": { + "premature_open_jaw": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + }, + "support_touchdown_before_destination": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + } + }, + "native_metrics_mismatches": [], + "native_recomputed": { + "carry_complete": false, + "carry_contact_loss_events": 0, + "dwell_seconds": 0.0, + "first_success_time_seconds": null, + "grasp_seen": false, + "lift_dwell_seconds": 0.0, + "lift_seen": false, + "max_carry_contact_loss_seconds": 0.0, + "max_object_lift_m": 6.22998874710845e-11, + "max_pad_normal_force_n": 0.0, + "retention_lost": false, + "success": false, + "unexpected_contact_native_ticks": 0 + }, + "reason": "native_outcome_failed", + "restoration_scope": "Loaded contact restored for 100 ms after sustained loss; does not establish task recovery or airborne regrasp.", + "schema": "dvidia.piper-feedback-score/v1", + "strict_v01": { + "native_metrics_source": "simulator-authored episode record; not authenticated sensor input", + "native_outcome_success": false, + "native_outcome_valid": true, + "reason": "native_outcome_failed", + "reference_xy_m": [ + 0.35, + 0.08 + ], + "required_dwell_s": 0.25, + "required_lift_dwell_s": 0.1, + "sample_interval_s": 0.02, + "success": false, + "terminal_dwell_s": 0.0, + "terminal_reference_success": false, + "terminal_xy_error_m": 0.12861307125253946, + "trace_lift_dwell_s": 0.0, + "trajectory_complete": true + }, + "success": false, + "terminal_only": { + "dwell_s": 0.0, + "scope": "Terminal-only geometry/release/settling/dwell; excludes lift, carry and retention history.", + "success": false, + "terminal_xy_error_m": 0.12861307125253946 + }, + "valid": true + }, + "scored_control_trajectory": true, + "strict_success": false, + "supervisor_cause": null, + "supervisor_status": "finished", + "variant": "absolute", + "worker_receipt": { + "bytes": 4794, + "sha256": "170cecc5eb6733f7b1f3398af31f4f795b0115cc0860d9f8d13075d97e1297ed" + }, + "worker_receipt_available": true, + "worker_wall_seconds": 15.491917999985162 + }, + { + "camera_pairs": 501, + "case": { + "goal_id": 0, + "goal_position_m": [ + 0.35, + 0.08, + 0.08 + ], + "group_id": "development-01", + "id": "development-01-goal0", + "object_position_m": [ + 0.303637, + -0.039966, + 0.082 + ], + "seed": 311467, + "split": "development" + }, + "files_verified": 5010, + "frame_bytes": 166698225, + "guard": { + "checks": 1000, + "forwarded_calls": 1000, + "guard_wall_seconds": 0.005421159323304892, + "minimum_free_bytes": 39533481984, + "scope": "Once per simulated20ms callback, not a wall-clock50Hz monitor; no task features changed.", + "stop_reason": null + }, + "id": "development-01-goal0-delta", + "inspection": { + "files_verified": 5010, + "physical_robot_ready": false, + "physics_executed": false, + "recorded_complete_intervals": 1000, + "schema": "dvidia.camera-action-rollout/v2/inspection", + "score": { + "evidence_scope": "Recomputed simulator-authored numeric evidence; no physics rerun, source attestation or hardware sensing.", + "false_alarms": { + "reason": "Continuous residual policy has no declared discrete alarm events.", + "status": "not_applicable" + }, + "grip_events": [], + "grip_summary": { + "airborne_events": 0, + "loss_events": 0, + "qualification_latency_s": [], + "restored_events": 0, + "supported_events": 0, + "unresolved_events": 0 + }, + "native_diagnostics": { + "premature_open_jaw": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + }, + "support_touchdown_before_destination": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + } + }, + "native_metrics_mismatches": [], + "native_recomputed": { + "carry_complete": false, + "carry_contact_loss_events": 0, + "dwell_seconds": 0.0, + "first_success_time_seconds": null, + "grasp_seen": true, + "lift_dwell_seconds": 0.0, + "lift_seen": false, + "max_carry_contact_loss_seconds": 0.0, + "max_object_lift_m": 0.01765747992294485, + "max_pad_normal_force_n": 2.5154725382030216, + "retention_lost": false, + "success": false, + "unexpected_contact_native_ticks": 1240 + }, + "reason": "invalid_state_value", + "restoration_scope": "Loaded contact restored for 100 ms after sustained loss; does not establish task recovery or airborne regrasp.", + "schema": "dvidia.piper-feedback-score/v1", + "strict_v01": { + "reason": "invalid_state_value", + "reference_xy_m": [ + 0.35, + 0.08 + ], + "state_index": 687, + "success": false + }, + "success": false, + "terminal_only": { + "dwell_s": 0.0, + "scope": "Terminal-only geometry/release/settling/dwell; excludes lift, carry and retention history.", + "success": false, + "terminal_xy_error_m": 0.2545568078047586 + }, + "valid": true + }, + "source_authenticated": false, + "status": "complete", + "strict_success": false + }, + "integrity_file": { + "bytes": 567674, + "sha256": "1f4b2db19b5c0ded4438d9cc549a65e6a25a9f1691118a4363f93bf0646e2a89" + }, + "perception": { + "available": 732, + "decisions": 1000, + "longest_missing_seconds": 4.04, + "missing": 268 + }, + "policy": { + "model_sha256": "4545be31f50267c9da29b211510c7a32df500678ba107c7a100604bb0c4c18ab", + "physical_robot_ready": false, + "policy_origin": "camera_encoder_reference_endpoint_numpy_mlp", + "runtime_teacher_available": false, + "student_inference_calls": 1000, + "student_inference_p95_seconds": 0.0002795872074784711, + "student_inference_seconds": 0.2348349518433679, + "task_qualified": false, + "teacher_fallback_calls": 0, + "timing_scope": "Causal feature encoding, NumPy inference and reference projection; excludes camera/render/actuation.", + "variant": "delta" + }, + "qualified": false, + "recorded_complete_intervals": 1000, + "rollout_error": null, + "rollout_file": { + "bytes": 326043, + "sha256": "1302c51513d638910857c79bc78539bc9c59b546aeaf212d08b922ec06372a21" + }, + "rollout_status": "complete", + "rollout_wall_seconds": 12.975723750016186, + "score": { + "evidence_scope": "Recomputed simulator-authored numeric evidence; no physics rerun, source attestation or hardware sensing.", + "false_alarms": { + "reason": "Continuous residual policy has no declared discrete alarm events.", + "status": "not_applicable" + }, + "grip_events": [], + "grip_summary": { + "airborne_events": 0, + "loss_events": 0, + "qualification_latency_s": [], + "restored_events": 0, + "supported_events": 0, + "unresolved_events": 0 + }, + "native_diagnostics": { + "premature_open_jaw": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + }, + "support_touchdown_before_destination": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + } + }, + "native_metrics_mismatches": [], + "native_recomputed": { + "carry_complete": false, + "carry_contact_loss_events": 0, + "dwell_seconds": 0.0, + "first_success_time_seconds": null, + "grasp_seen": true, + "lift_dwell_seconds": 0.0, + "lift_seen": false, + "max_carry_contact_loss_seconds": 0.0, + "max_object_lift_m": 0.01765747992294485, + "max_pad_normal_force_n": 2.5154725382030216, + "retention_lost": false, + "success": false, + "unexpected_contact_native_ticks": 1240 + }, + "reason": "invalid_state_value", + "restoration_scope": "Loaded contact restored for 100 ms after sustained loss; does not establish task recovery or airborne regrasp.", + "schema": "dvidia.piper-feedback-score/v1", + "strict_v01": { + "reason": "invalid_state_value", + "reference_xy_m": [ + 0.35, + 0.08 + ], + "state_index": 687, + "success": false + }, + "success": false, + "terminal_only": { + "dwell_s": 0.0, + "scope": "Terminal-only geometry/release/settling/dwell; excludes lift, carry and retention history.", + "success": false, + "terminal_xy_error_m": 0.2545568078047586 + }, + "valid": true + }, + "scored_control_trajectory": true, + "strict_success": false, + "supervisor_cause": null, + "supervisor_status": "finished", + "variant": "delta", + "worker_receipt": { + "bytes": 4438, + "sha256": "992235bea602ec6bdcd12f82296d5a2f8b89d6ca7dfc598808e9f35f1256268d" + }, + "worker_receipt_available": true, + "worker_wall_seconds": 14.5429857079871 + }, + { + "camera_pairs": 501, + "case": { + "goal_id": 1, + "goal_position_m": [ + 0.4, + -0.08, + 0.08 + ], + "group_id": "development-01", + "id": "development-01-goal1", + "object_position_m": [ + 0.303637, + -0.039966, + 0.082 + ], + "seed": 311468, + "split": "development" + }, + "files_verified": 5010, + "frame_bytes": 169366324, + "guard": { + "checks": 1000, + "forwarded_calls": 1000, + "guard_wall_seconds": 0.005538281751796603, + "minimum_free_bytes": 39318462464, + "scope": "Once per simulated20ms callback, not a wall-clock50Hz monitor; no task features changed.", + "stop_reason": null + }, + "id": "development-01-goal1-absolute", + "inspection": { + "files_verified": 5010, + "physical_robot_ready": false, + "physics_executed": false, + "recorded_complete_intervals": 1000, + "schema": "dvidia.camera-action-rollout/v2/inspection", + "score": { + "evidence_scope": "Recomputed simulator-authored numeric evidence; no physics rerun, source attestation or hardware sensing.", + "false_alarms": { + "reason": "Continuous residual policy has no declared discrete alarm events.", + "status": "not_applicable" + }, + "grip_events": [ + { + "kind": "supported_grip_interruption", + "loss_onset_s": 18.28199999999936, + "loss_qualified_s": 18.300999999999384, + "onset_to_qualified_restoration_s": 0.1490000000001821, + "onset_to_restoration_s": 0.05000000000006111, + "relative_motion_since_loss_m": 0.0009026515472255445, + "restoration_onset_s": 18.33199999999942, + "restoration_qualified_s": 18.430999999999543, + "restoration_supported": true, + "restored": true, + "supported_at_onset": true + } + ], + "grip_summary": { + "airborne_events": 0, + "loss_events": 1, + "qualification_latency_s": [ + 0.1490000000001821 + ], + "restored_events": 1, + "supported_events": 1, + "unresolved_events": 0 + }, + "native_diagnostics": { + "premature_open_jaw": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + }, + "support_touchdown_before_destination": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + } + }, + "native_metrics_mismatches": [], + "native_recomputed": { + "carry_complete": false, + "carry_contact_loss_events": 0, + "dwell_seconds": 0.0, + "first_success_time_seconds": null, + "grasp_seen": true, + "lift_dwell_seconds": 0.0, + "lift_seen": true, + "max_carry_contact_loss_seconds": 0.0, + "max_object_lift_m": 0.12241943079952637, + "max_pad_normal_force_n": 0.6881092160543247, + "retention_lost": false, + "success": false, + "unexpected_contact_native_ticks": 0 + }, + "reason": "native_outcome_failed", + "restoration_scope": "Loaded contact restored for 100 ms after sustained loss; does not establish task recovery or airborne regrasp.", + "schema": "dvidia.piper-feedback-score/v1", + "strict_v01": { + "native_metrics_source": "simulator-authored episode record; not authenticated sensor input", + "native_outcome_success": false, + "native_outcome_valid": true, + "reason": "native_outcome_failed", + "reference_xy_m": [ + 0.4, + -0.08 + ], + "required_dwell_s": 0.25, + "required_lift_dwell_s": 0.1, + "sample_interval_s": 0.02, + "success": false, + "terminal_dwell_s": 0.0, + "terminal_reference_success": false, + "terminal_xy_error_m": 0.004469139679330379, + "trace_lift_dwell_s": 0.9799999999999969, + "trajectory_complete": true + }, + "success": false, + "terminal_only": { + "dwell_s": 0.0, + "scope": "Terminal-only geometry/release/settling/dwell; excludes lift, carry and retention history.", + "success": false, + "terminal_xy_error_m": 0.004469139679330379 + }, + "valid": true + }, + "source_authenticated": false, + "status": "complete", + "strict_success": false + }, + "integrity_file": { + "bytes": 567674, + "sha256": "00eea091817448e593ee0d9b6149af6b492291194f9caa914c942a6bc75fd9e7" + }, + "perception": { + "available": 692, + "decisions": 1000, + "longest_missing_seconds": 5.96, + "missing": 308 + }, + "policy": { + "model_sha256": "36af3fe1670494b04c48b5114d9be1a5f91632aa7992ba529d6587969ea37460", + "physical_robot_ready": false, + "policy_origin": "camera_encoder_reference_endpoint_numpy_mlp", + "runtime_teacher_available": false, + "student_inference_calls": 1000, + "student_inference_p95_seconds": 0.0002899830491514876, + "student_inference_seconds": 0.23790540907066315, + "task_qualified": false, + "teacher_fallback_calls": 0, + "timing_scope": "Causal feature encoding, NumPy inference and reference projection; excludes camera/render/actuation.", + "variant": "absolute" + }, + "qualified": false, + "recorded_complete_intervals": 1000, + "rollout_error": null, + "rollout_file": { + "bytes": 326868, + "sha256": "bb86dd380867955a60df4588140dc5c07e4f49129197c09e6b7fae9c64ce0d77" + }, + "rollout_status": "complete", + "rollout_wall_seconds": 13.351964041998144, + "score": { + "evidence_scope": "Recomputed simulator-authored numeric evidence; no physics rerun, source attestation or hardware sensing.", + "false_alarms": { + "reason": "Continuous residual policy has no declared discrete alarm events.", + "status": "not_applicable" + }, + "grip_events": [ + { + "kind": "supported_grip_interruption", + "loss_onset_s": 18.28199999999936, + "loss_qualified_s": 18.300999999999384, + "onset_to_qualified_restoration_s": 0.1490000000001821, + "onset_to_restoration_s": 0.05000000000006111, + "relative_motion_since_loss_m": 0.0009026515472255445, + "restoration_onset_s": 18.33199999999942, + "restoration_qualified_s": 18.430999999999543, + "restoration_supported": true, + "restored": true, + "supported_at_onset": true + } + ], + "grip_summary": { + "airborne_events": 0, + "loss_events": 1, + "qualification_latency_s": [ + 0.1490000000001821 + ], + "restored_events": 1, + "supported_events": 1, + "unresolved_events": 0 + }, + "native_diagnostics": { + "premature_open_jaw": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + }, + "support_touchdown_before_destination": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + } + }, + "native_metrics_mismatches": [], + "native_recomputed": { + "carry_complete": false, + "carry_contact_loss_events": 0, + "dwell_seconds": 0.0, + "first_success_time_seconds": null, + "grasp_seen": true, + "lift_dwell_seconds": 0.0, + "lift_seen": true, + "max_carry_contact_loss_seconds": 0.0, + "max_object_lift_m": 0.12241943079952637, + "max_pad_normal_force_n": 0.6881092160543247, + "retention_lost": false, + "success": false, + "unexpected_contact_native_ticks": 0 + }, + "reason": "native_outcome_failed", + "restoration_scope": "Loaded contact restored for 100 ms after sustained loss; does not establish task recovery or airborne regrasp.", + "schema": "dvidia.piper-feedback-score/v1", + "strict_v01": { + "native_metrics_source": "simulator-authored episode record; not authenticated sensor input", + "native_outcome_success": false, + "native_outcome_valid": true, + "reason": "native_outcome_failed", + "reference_xy_m": [ + 0.4, + -0.08 + ], + "required_dwell_s": 0.25, + "required_lift_dwell_s": 0.1, + "sample_interval_s": 0.02, + "success": false, + "terminal_dwell_s": 0.0, + "terminal_reference_success": false, + "terminal_xy_error_m": 0.004469139679330379, + "trace_lift_dwell_s": 0.9799999999999969, + "trajectory_complete": true + }, + "success": false, + "terminal_only": { + "dwell_s": 0.0, + "scope": "Terminal-only geometry/release/settling/dwell; excludes lift, carry and retention history.", + "success": false, + "terminal_xy_error_m": 0.004469139679330379 + }, + "valid": true + }, + "scored_control_trajectory": true, + "strict_success": false, + "supervisor_cause": null, + "supervisor_status": "finished", + "variant": "absolute", + "worker_receipt": { + "bytes": 5262, + "sha256": "9e24e931e0063d24b32beb1642abe26d59756af2c6a6d29e31d975f4a828d185" + }, + "worker_receipt_available": true, + "worker_wall_seconds": 15.055389708984876 + }, + { + "camera_pairs": 501, + "case": { + "goal_id": 1, + "goal_position_m": [ + 0.4, + -0.08, + 0.08 + ], + "group_id": "development-01", + "id": "development-01-goal1", + "object_position_m": [ + 0.303637, + -0.039966, + 0.082 + ], + "seed": 311468, + "split": "development" + }, + "files_verified": 5010, + "frame_bytes": 168677614, + "guard": { + "checks": 1000, + "forwarded_calls": 1000, + "guard_wall_seconds": 0.005143560847500339, + "minimum_free_bytes": 39110926336, + "scope": "Once per simulated20ms callback, not a wall-clock50Hz monitor; no task features changed.", + "stop_reason": null + }, + "id": "development-01-goal1-delta", + "inspection": { + "files_verified": 5010, + "physical_robot_ready": false, + "physics_executed": false, + "recorded_complete_intervals": 1000, + "schema": "dvidia.camera-action-rollout/v2/inspection", + "score": { + "evidence_scope": "Recomputed simulator-authored numeric evidence; no physics rerun, source attestation or hardware sensing.", + "false_alarms": { + "reason": "Continuous residual policy has no declared discrete alarm events.", + "status": "not_applicable" + }, + "grip_events": [ + { + "kind": "supported_grip_interruption", + "loss_onset_s": 13.27699999999808, + "loss_qualified_s": 13.29599999999807, + "onset_to_qualified_restoration_s": 0.5129999999997157, + "onset_to_restoration_s": 0.41399999999977055, + "relative_motion_since_loss_m": 0.04689580619513455, + "restoration_onset_s": 13.690999999997851, + "restoration_qualified_s": 13.789999999997796, + "restoration_supported": false, + "restored": true, + "supported_at_onset": true + }, + { + "kind": "supported_grip_interruption", + "loss_onset_s": 13.949999999997708, + "loss_qualified_s": 13.968999999997697, + "onset_to_qualified_restoration_s": null, + "onset_to_restoration_s": null, + "relative_motion_since_loss_m": 0.306676529975985, + "restoration_onset_s": null, + "restoration_qualified_s": null, + "restored": false, + "supported_at_onset": true + } + ], + "grip_summary": { + "airborne_events": 0, + "loss_events": 2, + "qualification_latency_s": [ + 0.5129999999997157 + ], + "restored_events": 1, + "supported_events": 2, + "unresolved_events": 1 + }, + "native_diagnostics": { + "premature_open_jaw": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + }, + "support_touchdown_before_destination": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + } + }, + "native_metrics_mismatches": [], + "native_recomputed": { + "carry_complete": false, + "carry_contact_loss_events": 0, + "dwell_seconds": 0.0, + "first_success_time_seconds": null, + "grasp_seen": true, + "lift_dwell_seconds": 0.0, + "lift_seen": false, + "max_carry_contact_loss_seconds": 0.0, + "max_object_lift_m": 0.030235768269076563, + "max_pad_normal_force_n": 2.8633099470994976, + "retention_lost": false, + "success": false, + "unexpected_contact_native_ticks": 3144 + }, + "reason": "invalid_state_value", + "restoration_scope": "Loaded contact restored for 100 ms after sustained loss; does not establish task recovery or airborne regrasp.", + "schema": "dvidia.piper-feedback-score/v1", + "strict_v01": { + "reason": "invalid_state_value", + "reference_xy_m": [ + 0.4, + -0.08 + ], + "state_index": 735, + "success": false + }, + "success": false, + "terminal_only": { + "dwell_s": 0.0, + "scope": "Terminal-only geometry/release/settling/dwell; excludes lift, carry and retention history.", + "success": false, + "terminal_xy_error_m": 0.10614903247737481 + }, + "valid": true + }, + "source_authenticated": false, + "status": "complete", + "strict_success": false + }, + "integrity_file": { + "bytes": 567674, + "sha256": "99a748732c1cbb7761ec00b786a680da20f01b0abb038214451be42d069cd8e2" + }, + "perception": { + "available": 508, + "decisions": 1000, + "longest_missing_seconds": 4.8, + "missing": 492 + }, + "policy": { + "model_sha256": "4545be31f50267c9da29b211510c7a32df500678ba107c7a100604bb0c4c18ab", + "physical_robot_ready": false, + "policy_origin": "camera_encoder_reference_endpoint_numpy_mlp", + "runtime_teacher_available": false, + "student_inference_calls": 1000, + "student_inference_p95_seconds": 0.0002611646079458296, + "student_inference_seconds": 0.23262492148205638, + "task_qualified": false, + "teacher_fallback_calls": 0, + "timing_scope": "Causal feature encoding, NumPy inference and reference projection; excludes camera/render/actuation.", + "variant": "delta" + }, + "qualified": false, + "recorded_complete_intervals": 1000, + "rollout_error": null, + "rollout_file": { + "bytes": 326951, + "sha256": "f0431561b7049a1058db91cc36bcf13cc7626ab9bbc50e57e0244fac52a9f563" + }, + "rollout_status": "complete", + "rollout_wall_seconds": 12.816186875017593, + "score": { + "evidence_scope": "Recomputed simulator-authored numeric evidence; no physics rerun, source attestation or hardware sensing.", + "false_alarms": { + "reason": "Continuous residual policy has no declared discrete alarm events.", + "status": "not_applicable" + }, + "grip_events": [ + { + "kind": "supported_grip_interruption", + "loss_onset_s": 13.27699999999808, + "loss_qualified_s": 13.29599999999807, + "onset_to_qualified_restoration_s": 0.5129999999997157, + "onset_to_restoration_s": 0.41399999999977055, + "relative_motion_since_loss_m": 0.04689580619513455, + "restoration_onset_s": 13.690999999997851, + "restoration_qualified_s": 13.789999999997796, + "restoration_supported": false, + "restored": true, + "supported_at_onset": true + }, + { + "kind": "supported_grip_interruption", + "loss_onset_s": 13.949999999997708, + "loss_qualified_s": 13.968999999997697, + "onset_to_qualified_restoration_s": null, + "onset_to_restoration_s": null, + "relative_motion_since_loss_m": 0.306676529975985, + "restoration_onset_s": null, + "restoration_qualified_s": null, + "restored": false, + "supported_at_onset": true + } + ], + "grip_summary": { + "airborne_events": 0, + "loss_events": 2, + "qualification_latency_s": [ + 0.5129999999997157 + ], + "restored_events": 1, + "supported_events": 2, + "unresolved_events": 1 + }, + "native_diagnostics": { + "premature_open_jaw": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + }, + "support_touchdown_before_destination": { + "count": 0, + "intervals": [], + "maximum_s": 0.0, + "total_s": 0.0 + } + }, + "native_metrics_mismatches": [], + "native_recomputed": { + "carry_complete": false, + "carry_contact_loss_events": 0, + "dwell_seconds": 0.0, + "first_success_time_seconds": null, + "grasp_seen": true, + "lift_dwell_seconds": 0.0, + "lift_seen": false, + "max_carry_contact_loss_seconds": 0.0, + "max_object_lift_m": 0.030235768269076563, + "max_pad_normal_force_n": 2.8633099470994976, + "retention_lost": false, + "success": false, + "unexpected_contact_native_ticks": 3144 + }, + "reason": "invalid_state_value", + "restoration_scope": "Loaded contact restored for 100 ms after sustained loss; does not establish task recovery or airborne regrasp.", + "schema": "dvidia.piper-feedback-score/v1", + "strict_v01": { + "reason": "invalid_state_value", + "reference_xy_m": [ + 0.4, + -0.08 + ], + "state_index": 735, + "success": false + }, + "success": false, + "terminal_only": { + "dwell_s": 0.0, + "scope": "Terminal-only geometry/release/settling/dwell; excludes lift, carry and retention history.", + "success": false, + "terminal_xy_error_m": 0.10614903247737481 + }, + "valid": true + }, + "scored_control_trajectory": true, + "strict_success": false, + "supervisor_cause": null, + "supervisor_status": "finished", + "variant": "delta", + "worker_receipt": { + "bytes": 5207, + "sha256": "8f5058b68c1541c1942702bdb95d1a697199b90efad02eab7afa86f0452bc8c5" + }, + "worker_receipt_available": true, + "worker_wall_seconds": 14.523490916006267 + } + ], + "by_variant": { + "absolute": { + "callback_including_guard": { + "calls": 4000, + "maximum_seconds": 0.008621292014140636, + "median_seconds": 0.00023227051133289933, + "p95_seconds": 0.00029546011064667254 + }, + "carry_complete": 0, + "complete_episodes": 4, + "critical_contact_ticks": 7606, + "episodes_with_critical_contact": 2, + "full_boundary": { + "calls": 4000, + "maximum_seconds": 0.051054958981694654, + "median_seconds": 0.013028145520365797, + "p95_seconds": 0.022362537491426335 + }, + "grasp_seen": 3, + "lift_seen": 1, + "qualified": false, + "retention_lost": 0, + "scheduled": 4, + "scored_control_trajectories": 4, + "strict_successes": 0, + "terminal_only_successes": 0 + }, + "delta": { + "callback_including_guard": { + "calls": 4000, + "maximum_seconds": 0.021589000010862947, + "median_seconds": 0.00023095900542102754, + "p95_seconds": 0.0002842972404323518 + }, + "carry_complete": 0, + "complete_episodes": 4, + "critical_contact_ticks": 19751, + "episodes_with_critical_contact": 4, + "full_boundary": { + "calls": 4000, + "maximum_seconds": 0.058383833995321766, + "median_seconds": 0.013461853988701478, + "p95_seconds": 0.02204904312093276 + }, + "grasp_seen": 4, + "lift_seen": 0, + "qualified": false, + "retention_lost": 0, + "scheduled": 4, + "scored_control_trajectories": 4, + "strict_successes": 0, + "terminal_only_successes": 0 + } + }, + "decision": "pass_integrity_and_accounting", + "evidence_scope": "Independent full artifact inventory hash/contract/authority checks and strict scorer reconstruction from saved native arrays, without physics replay or source authentication.", + "models": { + "absolute": { + "content_sha256": "36af3fe1670494b04c48b5114d9be1a5f91632aa7992ba529d6587969ea37460", + "file": { + "bytes": 539345, + "sha256": "3dbf6911d92a9072297c9c3bb7c09f45809808272455ffd5562f4553a173f362" + } + }, + "delta": { + "content_sha256": "4545be31f50267c9da29b211510c7a32df500678ba107c7a100604bb0c4c18ab", + "file": { + "bytes": 538021, + "sha256": "fece6d056e50a1bde41bdb9960bf7cbc81d983c4bfdb03a07632e30b712b1489" + } + } + }, + "original_result": { + "bytes": 7153, + "sha256": "597277fd6c4671a7d2791aa861beb5da896573fcbf51f8db08e30d4bc501284e" + }, + "passed": true, + "plan_sha256": "9912b3b86abe889d81073b1fee1c9cad9655264fdb325abbbf60dbebd89a490b", + "prior_batches": [ + { + "result_file": { + "bytes": 6130, + "sha256": "2e9a40eaa5799f3bc6d0d36ee10f5fe8a6cf0bfe387f428f399d66a4e9c5c6fe" + }, + "run_id": "reference-model-development-smoke-20261109", + "scheduled_attempts": 8 + }, + { + "result_file": { + "bytes": 6664, + "sha256": "017d7ae05f64b8539d950ec00063345f30571e4a89086e06411b1b038c9a335c" + }, + "run_id": "reference-model-development-smoke-v2-20261109", + "scheduled_attempts": 8 + } + ], + "qualification": false, + "result_file": { + "bytes": 7153, + "sha256": "597277fd6c4671a7d2791aa861beb5da896573fcbf51f8db08e30d4bc501284e" + }, + "review_fits": 0, + "review_physics_or_native_import": false, + "review_policy_inference": false, + "review_wall_seconds": 9.043949083017651, + "reviewed_at_utc": "2026-11-09T16:42:28.047717+00:00", + "reviewer": "export_cache", + "schema": "dvidia.reference-model-development-smoke-v3-result-review/v1", + "script_sha256": "8186572b17949cbe3add1ac4d1bc4dcca92cfa76f973892b64e1b4275b78c48a", + "selection_performed": false, + "source_commit": "78ea4fbb4b2733e7738eb425eeecd7cb67a52195", + "source_files": { + "src/dvidia_training/action_demonstration.py": { + "bytes": 36303, + "sha256": "439c7cce558571221660cd51e7dba1675203237706ea8ea0f97f2fcf9a6a24c5" + }, + "src/dvidia_training/camera_action_cache.py": { + "bytes": 23490, + "sha256": "9191f2eb9f96bd09d4f711c31966a583bd938853a874e6018f8ddebfb0bc00d8" + }, + "src/dvidia_training/camera_action_capture.py": { + "bytes": 34257, + "sha256": "399f512a08087c72bfa37e382157a2250f413e423974b77b1bd3c0a911ff0a1e" + }, + "src/dvidia_training/camera_action_export.py": { + "bytes": 7355, + "sha256": "2c4e30587605edc0342150a93430a70ed0559c3ee3eda17d93c5670831370b02" + }, + "src/dvidia_training/camera_action_model.py": { + "bytes": 27066, + "sha256": "e9a9c4d1d0f16fc7c91cac3ca2e6560d0532370ab78a2af5a4ec84425c23932f" + }, + "src/dvidia_training/camera_action_reference_export.py": { + "bytes": 19195, + "sha256": "ccf6f74f6100721868ccece67e5b27dae066c1b644c8297efe111125d9517753" + }, + "src/dvidia_training/camera_action_reference_model.py": { + "bytes": 19771, + "sha256": "952750fd6b99f97eb96054b8fe50710b83f7e8eb4e069601be442292dd0023bc" + }, + "src/dvidia_training/camera_action_study.py": { + "bytes": 46551, + "sha256": "196f669b03baff3df561fa9236c64dab401c954c929994dedc36721611c8948a" + }, + "src/dvidia_training/embodiment_calibration.py": { + "bytes": 14701, + "sha256": "0531be511b3bc549576a33930394d33b673c146d5e52c29198096632ea7478c5" + }, + "src/dvidia_training/episode_tape.py": { + "bytes": 31209, + "sha256": "abae9a4bd0080c7f638c5c82c050fb1364a20769998c054354b918233669f5d2" + }, + "src/dvidia_training/piper_action_capture.py": { + "bytes": 29069, + "sha256": "da037b2198cf7d2f3a9aa40fc19a4c0f5cc375a22c5dd75606e2c1856f6efc7f" + }, + "src/dvidia_training/piper_feedback_env.py": { + "bytes": 11247, + "sha256": "0dbae423231968a81bdeed52226d8dffaf8df622013ed3a360d7217148f1bcac" + }, + "src/dvidia_training/piper_feedback_score.py": { + "bytes": 18866, + "sha256": "863a272828208c631de4cf57647e973eb3e4f5e99eb7a1eacb4eaa68dc42eb0e" + }, + "src/dvidia_training/piper_imitation.py": { + "bytes": 25561, + "sha256": "849f66512c58441a240cd20230fcc58691234ddd254c5bbcbfd76abc21b14868" + }, + "src/dvidia_training/piper_imitation_score.py": { + "bytes": 11462, + "sha256": "0cd4663abfdd7f14f2f33d93e9a2bd45122b998d6160d45b8afcc880512cba2b" + }, + "src/dvidia_training/piper_motor_primitive.py": { + "bytes": 17476, + "sha256": "02a45b88913db6f223e4d9975eac64d4942a92739c5817c6ede4cc9fa332ed1c" + }, + "src/dvidia_training/piper_rgbd_tracker.py": { + "bytes": 17461, + "sha256": "43202cfcea404061a3a65124d6ad24aeeec5fae8ffaf863caa245f2f54c46c36" + }, + "src/dvidia_training/piper_task.py": { + "bytes": 34355, + "sha256": "e66a44a8df4e7a8ee42e4f3866f889f8797cdfb8e2688a146e09b75d2c76664f" + }, + "src/dvidia_training/reference_sim.py": { + "bytes": 24336, + "sha256": "c1201d22eb13dd07a236ee63cc4ba68e129f6067e8db61ed41af2d820eb5e3b8" + }, + "src/dvidia_training/reference_task.py": { + "bytes": 34166, + "sha256": "bbc768ccc202b8dd41cbd235b206e6478806ce47c1f30ae15dc662c0c1edcc3e" + }, + "src/dvidia_training/robot_profiles.lock.json": { + "bytes": 35002, + "sha256": "4b2ee2ca675aceb2f826983cb3082a3e08e9aa0ff419b23078abcff08ebcc6fe" + }, + "src/dvidia_training/robot_profiles.py": { + "bytes": 26493, + "sha256": "fb90782a6a9979e282182118ae0e3e29d00f101255cc57378dd3f692672bb13d" + } + }, + "timing_scope": "Stored rollout timings are shared-host offline paused-simulator wall measurements. Callback includes guard+causal encoding+inference+projection; ModelPolicy diagnostic excludes guard. Full boundary includes file writes and alternate camera work; initial acquisition timing row is separate and excluded from callback/boundary percentiles. Neither is physical delivery latency. Review verification time is separate." +} diff --git a/benchmarks/camera-action-reference-model-integration-v01/evidence/renderer-warnings.json b/benchmarks/camera-action-reference-model-integration-v01/evidence/renderer-warnings.json new file mode 100644 index 0000000..e8d4ddc --- /dev/null +++ b/benchmarks/camera-action-reference-model-integration-v01/evidence/renderer-warnings.json @@ -0,0 +1,71 @@ +{ + "attempts": [ + { + "id": "development-00-goal0-absolute", + "renderer_warnings": [ + "ARB_clip_control unavailable while mjDEPTH_ZEROFAR requested, depth accuracy will be limited" + ], + "rollout_sha256": "1104da3991eb6c3872c85c46eec6d4a5dcb89c0a10752d57c5ebc8071b14dee9", + "timing_entries_with_renderer_warnings": 501 + }, + { + "id": "development-00-goal0-delta", + "renderer_warnings": [ + "ARB_clip_control unavailable while mjDEPTH_ZEROFAR requested, depth accuracy will be limited" + ], + "rollout_sha256": "328cf546022fd2f79da3ec1a6161c0d3ebd777bd254edd89903a2629966a5c8e", + "timing_entries_with_renderer_warnings": 501 + }, + { + "id": "development-00-goal1-absolute", + "renderer_warnings": [ + "ARB_clip_control unavailable while mjDEPTH_ZEROFAR requested, depth accuracy will be limited" + ], + "rollout_sha256": "8b851f39d22f39b02709c7857d1c2a6afa2420e83d200e7ee9564baeeba82b07", + "timing_entries_with_renderer_warnings": 501 + }, + { + "id": "development-00-goal1-delta", + "renderer_warnings": [ + "ARB_clip_control unavailable while mjDEPTH_ZEROFAR requested, depth accuracy will be limited" + ], + "rollout_sha256": "83dee39e2cb1cbfd3ef72c741d854627bf54c021852ffb1430c66fe4b8fe8452", + "timing_entries_with_renderer_warnings": 501 + }, + { + "id": "development-01-goal0-absolute", + "renderer_warnings": [ + "ARB_clip_control unavailable while mjDEPTH_ZEROFAR requested, depth accuracy will be limited" + ], + "rollout_sha256": "47f735604508f95ad78f9d863ca88f13f77b0bb4f68a4fcc4b067b967704fb97", + "timing_entries_with_renderer_warnings": 501 + }, + { + "id": "development-01-goal0-delta", + "renderer_warnings": [ + "ARB_clip_control unavailable while mjDEPTH_ZEROFAR requested, depth accuracy will be limited" + ], + "rollout_sha256": "1302c51513d638910857c79bc78539bc9c59b546aeaf212d08b922ec06372a21", + "timing_entries_with_renderer_warnings": 501 + }, + { + "id": "development-01-goal1-absolute", + "renderer_warnings": [ + "ARB_clip_control unavailable while mjDEPTH_ZEROFAR requested, depth accuracy will be limited" + ], + "rollout_sha256": "bb86dd380867955a60df4588140dc5c07e4f49129197c09e6b7fae9c64ce0d77", + "timing_entries_with_renderer_warnings": 501 + }, + { + "id": "development-01-goal1-delta", + "renderer_warnings": [ + "ARB_clip_control unavailable while mjDEPTH_ZEROFAR requested, depth accuracy will be limited" + ], + "rollout_sha256": "f0431561b7049a1058db91cc36bcf13cc7626ab9bbc50e57e0244fac52a9f563", + "timing_entries_with_renderer_warnings": 501 + } + ], + "schema": "dvidia.reference-model-renderer-warning-summary/v1", + "scope": "Warnings retained from sealed rollout timing records. No claim of calibrated depth accuracy. Physics/scorer results remain unchanged.", + "source_result_sha256": "597277fd6c4671a7d2791aa861beb5da896573fcbf51f8db08e30d4bc501284e" +} diff --git a/benchmarks/camera-action-reference-model-integration-v01/evidence/training-input-identity.json b/benchmarks/camera-action-reference-model-integration-v01/evidence/training-input-identity.json new file mode 100644 index 0000000..ff0e263 --- /dev/null +++ b/benchmarks/camera-action-reference-model-integration-v01/evidence/training-input-identity.json @@ -0,0 +1,214 @@ +{ + "episodes": 96, + "groups": 32, + "initial_parameters_sha256": "9c50504160213ad5241d6d96ab9be938d6f49b1c4bf49ff39d0770dac83dce7e", + "model_source_identity_sha256": "12ea9757cb0d76573c2e67f80b56ab08271f95e43f18b344b6481cc9153d70bc", + "parent_dataset_sha256": "b500b3ba348bba44cc79e377266f92910bd7e0165c36cd8b2fe260909b30a2f9", + "parent_provenance_sha256": "52cbeda62e3aa50e8cd6a34688fba7583f9fcec927cb0eb434a6907c99695f4f", + "raw_recordings_revalidated_during_integration": false, + "reference_dataset_sha256": "a9dcd66a81f177bb1910e08171ac7607f115ed47b51d93412107eb0e204aed73", + "samples": 96000, + "schema": "dvidia.reference-model-training-input-identity/v1", + "source_commit": "78ea4fbb4b2733e7738eb425eeecd7cb67a52195", + "split": "train", + "stages": [ + { + "arrays": { + "feasible-targets.npy": { + "bytes": 3584128, + "dtype": "