diff --git a/agent_d20_e20/frozen_20261102/tasks/DualArmFoldHandKerchief-v1/frozen/build_bank.py b/agent_d20_e20/frozen_20261102/tasks/DualArmFoldHandKerchief-v1/frozen/build_bank.py new file mode 100644 index 0000000000000000000000000000000000000000..b35d1569598ce6d149ca5f108833b7afc08cf3fa --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/DualArmFoldHandKerchief-v1/frozen/build_bank.py @@ -0,0 +1,17 @@ +"""Offline compilation of authorized observation/action examples; no optimization.""" +import importlib.util,json +from pathlib import Path +import numpy as np +from features import features,CAMERAS,PATHS +spec=importlib.util.spec_from_file_location('worker_api','/worker_api.py');m=importlib.util.module_from_spec(spec);spec.loader.exec_module(m);api=m.API() +manifest=json.load(open('/demo_manifest.json'));qs=[];vs=[];areas=[];actions=[];phase=[];ids=[];frames=[] +for di,e in enumerate(manifest['episodes']): + fields=['obs/'+p for p in PATHS]+[f'obs/sensor_data/{c}/rgb' for c in CAMERAS]+[f'actions/panda-{r}' for r in range(2)] + d=api.read_demo(e['demo_id'],fields=fields);n=e['length'];a=np.concatenate([d[f'actions/panda-{r}'] for r in range(2)],1) + close=int(np.where(a[:,6]<0)[0][0]);release=int(np.where((np.arange(n)>close)&(a[:,13]>0))[0][0]) + for t in range(n+1): + o={'rgb':{c:d[f'obs/sensor_data/{c}/rgb'][t] for c in CAMERAS},'proprioception':{p:d['obs/'+p][t] for p in PATHS}} + q,v,ar=features(o);qs.append(q);vs.append(v);areas.append(ar);actions.append(a[min(t,n-1)]);ids.append(di);frames.append(t) + phase.append(float(np.interp(t,[0,close,release,n],[0,1,2,3]))) +np.savez_compressed(Path(__file__).with_name('reference_bank.npz'),q=qs,v=vs,area=areas,action=actions,phase=phase,demo=ids,frame=frames,terminal=np.array(phase)==3) +print('Compiled',len(qs),'observations from',len(manifest['episodes']),'demos') diff --git a/agent_d20_e20/frozen_20261102/tasks/DualArmFoldHandKerchief-v1/frozen/check_synthetic.py b/agent_d20_e20/frozen_20261102/tasks/DualArmFoldHandKerchief-v1/frozen/check_synthetic.py new file mode 100644 index 0000000000000000000000000000000000000000..2c8860c8a1269e562dce60efab9fa8d32ac48065 --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/DualArmFoldHandKerchief-v1/frozen/check_synthetic.py @@ -0,0 +1,33 @@ +"""Interface checks using fabricated arrays only; not a task/environment test.""" +import copy, importlib.util, pathlib, py_compile, hashlib,json +import numpy as np +root=pathlib.Path(__file__).parent +for p in root.glob('*.py'):py_compile.compile(str(p),doraise=True) +spec=importlib.util.spec_from_file_location('draft',root/'controller.py');c=importlib.util.module_from_spec(spec);spec.loader.exec_module(c) +o={'rgb':{k:np.zeros((80,80,3),np.uint8) for k in c._f.CAMERAS},'proprioception':{p:np.zeros(9,np.float32) for p in c._f.PATHS},'instruction':'Fold a handkerchief','step_id':1} +# Loading the real reference artifact with wholly fabricated input is a smoke check only. +c.reset_episode();a=c.act(o);assert a is None or (a.shape==(14,) and np.isfinite(a).all() and np.max(abs(a))<=1) +q,v,ar=c._f.features(o) +a0=np.zeros(14,np.float32);a0[[6,13]]=1;a0[0]=.1 +a1=a0.copy();a1[0]=-.1 +other=copy.deepcopy(o);other['rgb']['top_camera'][:]=[255,255,0] +q1,v1,ar1=c._f.features(other) +c._bank={'q':np.stack([q,q1]),'v':np.stack([v,v1]),'area':np.stack([ar,ar1]),'action':np.stack([a0,a1]),'phase':np.zeros(2),'terminal':np.zeros(2)} +c.reset_episode();r0=c.act(o);c.reset_episode();r1=c.act(other) +assert r0[0]>0 and r1[0]<0,'RGB must affect action selection' +# Proprioception response with equal visual inputs. +c._bank['v'][1]=v;c._bank['q'][1]=q+1 +joint=copy.deepcopy(o) +for p in c._f.PATHS:joint['proprioception'][p][:]=np.array([.35]*7+[.025]*2) if p.endswith('qpos') else 2. +c.reset_episode();assert c.act(joint)[0]<0 +batched=copy.deepcopy(o) +for k in batched['rgb']:batched['rgb'][k]=batched['rgb'][k][None] +c.reset_episode();assert c.act(batched).shape==(14,) +o['step_id']=299;c.reset_episode();assert c.act(o).shape==(14,) +o['step_id']=300;assert c.act(o) is None +bad=copy.deepcopy(o);bad['step_id']=1;bad['proprioception'][c._f.PATHS[0]][0]=np.nan +assert c.act(bad) is None +c.reset_episode();assert c._progress==0 and c._last_step==0 +print('PASS: Python syntax; real-bank load with fabricated observation; synthetic-bank RGB and proprioception responsiveness; HWC/1HWC; finite bounded 14-vector; steps 299/300; malformed input; reset.') +print('Synthetic inputs only. No environment, replay evaluation, simulator, success estimate or rollout.') +m=json.load(open(root/'model_tool_manifest.yaml'));m['artifact_sha256']={p.name:hashlib.sha256(p.read_bytes()).hexdigest() for p in [root/'controller.py',root/'features.py',root/'reference_bank.npz']};(root/'model_tool_manifest.yaml').write_text(json.dumps(m,indent=2)+'\n') diff --git a/agent_d20_e20/frozen_20261102/tasks/DualArmFoldHandKerchief-v1/frozen/demo_manifest.json b/agent_d20_e20/frozen_20261102/tasks/DualArmFoldHandKerchief-v1/frozen/demo_manifest.json new file mode 100644 index 0000000000000000000000000000000000000000..7e3dfbbf10c9705fab2ef9679c51057d77313691 --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/DualArmFoldHandKerchief-v1/frozen/demo_manifest.json @@ -0,0 +1,2168 @@ +{ + "task_id": "DualArmFoldHandKerchief-v1", + "status": "released", + "selection_rule": "prefer existing pinned D20, otherwise numeric trajectory ID sort before reading data", + "lineage_status": "pinned_comparator", + "episodes": [ + { + "demo_id": "demo_00", + "file": "demo_00.h5", + "length": 229, + "fields": [ + { + "path": "actions/panda-0", + "shape": [ + 229, + 7 + ], + "dtype": "float32" + }, + { + "path": "actions/panda-1", + "shape": [ + 229, + 7 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qpos", + "shape": [ + 230, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qvel", + "shape": [ + 230, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qpos", + "shape": [ + 230, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qvel", + "shape": [ + 230, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 230, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 230, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 230, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 230, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 230, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "5648cab4a7a872ff328bf02f66b0b8ec59499c8c62d4002dbb3ae8c4c82374d4", + "source_sha256": "da15eb1389e7d8f3f708495189a732278efe8df699cf3d942c4e79b1bb92b9b5", + "view_sha256": "86d12baa67226bbce45df91f6f4bf6a42211454bb0b2530f5ecb5798deba7923" + }, + { + "demo_id": "demo_01", + "file": "demo_01.h5", + "length": 262, + "fields": [ + { + "path": "actions/panda-0", + "shape": [ + 262, + 7 + ], + "dtype": "float32" + }, + { + "path": "actions/panda-1", + "shape": [ + 262, + 7 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qpos", + "shape": [ + 263, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qvel", + "shape": [ + 263, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qpos", + "shape": [ + 263, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qvel", + "shape": [ + 263, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 263, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 263, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 263, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 263, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 263, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "918e68d817350b60dc0359e9c87f3d2f54a17c20bf41ccd2c58c07b1fcafa485", + "source_sha256": "0ffd8db7e0f37257da7a0aabc7488a71c8ee24471da7540d9537490a8bbe584b", + "view_sha256": "f6feaae38a42aef0fc87ecb572f7856cc9815e92a64b733817b479e1a5d313b3" + }, + { + "demo_id": "demo_02", + "file": "demo_02.h5", + "length": 251, + "fields": [ + { + "path": "actions/panda-0", + "shape": [ + 251, + 7 + ], + "dtype": "float32" + }, + { + "path": "actions/panda-1", + "shape": [ + 251, + 7 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qpos", + "shape": [ + 252, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qvel", + "shape": [ + 252, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qpos", + "shape": [ + 252, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qvel", + "shape": [ + 252, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 252, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 252, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 252, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 252, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 252, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "e73b2b581865cb80ab4eb14b665bba61f4003364753607bb4fe47eaadce43385", + "source_sha256": "5b32d6771292340b6b663e085d1f8ce65eaa1d9c6a0e5fa705cd66e4ae7bea98", + "view_sha256": "41442c9de6cbec0e18c328b8c887a9fa718bdb6429f5d0ed092020134bd1e950" + }, + { + "demo_id": "demo_03", + "file": "demo_03.h5", + "length": 229, + "fields": [ + { + "path": "actions/panda-0", + "shape": [ + 229, + 7 + ], + "dtype": "float32" + }, + { + "path": "actions/panda-1", + "shape": [ + 229, + 7 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qpos", + "shape": [ + 230, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qvel", + "shape": [ + 230, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qpos", + "shape": [ + 230, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qvel", + "shape": [ + 230, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 230, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 230, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 230, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 230, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 230, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "d6d2a5cf8d6359bdf2c4dc72f0b37f37d065a95f026695425cddfc5f160fd202", + "source_sha256": "dc8047867280a09e1fc361aa8bb19a2c729962408efeedbba6e9738f0b539d7e", + "view_sha256": "971d17a10c3c03368ac7ddb658c76c641ac79c8eb143d912e7fa688a2956d712" + }, + { + "demo_id": "demo_04", + "file": "demo_04.h5", + "length": 225, + "fields": [ + { + "path": "actions/panda-0", + "shape": [ + 225, + 7 + ], + "dtype": "float32" + }, + { + "path": "actions/panda-1", + "shape": [ + 225, + 7 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qpos", + "shape": [ + 226, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qvel", + "shape": [ + 226, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qpos", + "shape": [ + 226, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qvel", + "shape": [ + 226, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 226, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 226, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 226, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 226, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 226, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "9a2c344a047bed1cc5194d2f4e78cc1167717aadef6c7861b882bedd9bf17103", + "source_sha256": "12ebe83e2710fa916a456680e9c99fe867cf5d44c46684113bc758a88f9cd120", + "view_sha256": "d1c69c4ef6648d80807e7f152e56f578e4ff66204ff26246d84e2124d857a8f9" + }, + { + "demo_id": "demo_05", + "file": "demo_05.h5", + "length": 228, + "fields": [ + { + "path": "actions/panda-0", + "shape": [ + 228, + 7 + ], + "dtype": "float32" + }, + { + "path": "actions/panda-1", + "shape": [ + 228, + 7 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qpos", + "shape": [ + 229, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qvel", + "shape": [ + 229, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qpos", + "shape": [ + 229, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qvel", + "shape": [ + 229, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 229, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 229, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 229, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 229, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 229, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "470ba9e8b708f032d45862d2a1c3e77152daaafdbdfbcfcac59786e43d8d0f45", + "source_sha256": "517bfa1fdfa36d4862d83fb696f34dc2aaa5c16622cea5cac636451b7e62f5aa", + "view_sha256": "cbd22f18a95edb6616339cc5d4a4cba2a4d8f9dc3e68ca5dda206b078bee05df" + }, + { + "demo_id": "demo_06", + "file": "demo_06.h5", + "length": 270, + "fields": [ + { + "path": "actions/panda-0", + "shape": [ + 270, + 7 + ], + "dtype": "float32" + }, + { + "path": "actions/panda-1", + "shape": [ + 270, + 7 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qpos", + "shape": [ + 271, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qvel", + "shape": [ + 271, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qpos", + "shape": [ + 271, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qvel", + "shape": [ + 271, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 271, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 271, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 271, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 271, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 271, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "331f6b1de540c7dd4654666abf6d4d6ea76ccb5a5e444f1af1e1263dbaef9075", + "source_sha256": "91b0b78c8d029736476bc367a580bc26abd7db37f79cbc4d3d9e682011b7c2b3", + "view_sha256": "e511e007095c2ee27d1d784c06e80d2adefb3eee51fc5d795bf8b39e8fe4e5eb" + }, + { + "demo_id": "demo_07", + "file": "demo_07.h5", + "length": 255, + "fields": [ + { + "path": "actions/panda-0", + "shape": [ + 255, + 7 + ], + "dtype": "float32" + }, + { + "path": "actions/panda-1", + "shape": [ + 255, + 7 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qpos", + "shape": [ + 256, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qvel", + "shape": [ + 256, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qpos", + "shape": [ + 256, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qvel", + "shape": [ + 256, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 256, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 256, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 256, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 256, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 256, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "dde2ee7e7b01c2a1384c118bbcb648e826b253faf7d8effa79ea496146c5a660", + "source_sha256": "0bf884323929fce446f4564f9dd2a8ad18808628c95e053063d1ebe87cc671c0", + "view_sha256": "ad31e5e2ced962e40029d678ebe9088f55cccc1c417574088f2ce0d3373db2e4" + }, + { + "demo_id": "demo_08", + "file": "demo_08.h5", + "length": 227, + "fields": [ + { + "path": "actions/panda-0", + "shape": [ + 227, + 7 + ], + "dtype": "float32" + }, + { + "path": "actions/panda-1", + "shape": [ + 227, + 7 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qpos", + "shape": [ + 228, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qvel", + "shape": [ + 228, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qpos", + "shape": [ + 228, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qvel", + "shape": [ + 228, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 228, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 228, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 228, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 228, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 228, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "f94f2acd2f24d394dcec46061a8764b945c4338c82364a5c15e773110eea2ee4", + "source_sha256": "910c4073d0fe26a9b993ebd62bae8f3b3963231d794ef93ceac48d9521c377fe", + "view_sha256": "e6bdbdc6294b5780dcb424549d85f1a36693bfa74476fcc93aa91dbe41f467e0" + }, + { + "demo_id": "demo_09", + "file": "demo_09.h5", + "length": 260, + "fields": [ + { + "path": "actions/panda-0", + "shape": [ + 260, + 7 + ], + "dtype": "float32" + }, + { + "path": "actions/panda-1", + "shape": [ + 260, + 7 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qpos", + "shape": [ + 261, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qvel", + "shape": [ + 261, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qpos", + "shape": [ + 261, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qvel", + "shape": [ + 261, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 261, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 261, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 261, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 261, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 261, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "95a441b70be6612969bee56eb5cb03a9885835480dc211a21141fadb71509736", + "source_sha256": "d71582192943c9f55fe8b23236e74e9c303d3fa66aae022816432b32c5e3b96b", + "view_sha256": "7db3675ad504c2c24dd58216246d1e8476a4bbdafa51ab64c3288b73e34ea1b0" + }, + { + "demo_id": "demo_10", + "file": "demo_10.h5", + "length": 228, + "fields": [ + { + "path": "actions/panda-0", + "shape": [ + 228, + 7 + ], + "dtype": "float32" + }, + { + "path": "actions/panda-1", + "shape": [ + 228, + 7 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qpos", + "shape": [ + 229, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qvel", + "shape": [ + 229, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qpos", + "shape": [ + 229, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qvel", + "shape": [ + 229, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 229, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 229, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 229, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 229, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 229, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "b9910f0fdf899d3b46457ad6436617c3ae44c11d847bf625f545ced622d885fb", + "source_sha256": "15160fa45513224d317c3848783ac2e48f1c3a7a07374743ac56c8fa02e7a93f", + "view_sha256": "9b45758b14889ea559055c57814a2e9b94d00c876a8edede1446a0e39f6fb4db" + }, + { + "demo_id": "demo_11", + "file": "demo_11.h5", + "length": 230, + "fields": [ + { + "path": "actions/panda-0", + "shape": [ + 230, + 7 + ], + "dtype": "float32" + }, + { + "path": "actions/panda-1", + "shape": [ + 230, + 7 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qpos", + "shape": [ + 231, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qvel", + "shape": [ + 231, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qpos", + "shape": [ + 231, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qvel", + "shape": [ + 231, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 231, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 231, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 231, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 231, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 231, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "590aa6d10e47b1f8afd9a2438eaf2d279036182c31a898d6a3d5acd94ba31fb1", + "source_sha256": "027fd772119b6547aa296d4529e4069006ed2438e900608fd483260ab9f33512", + "view_sha256": "14939697824e6d08d6dfd648b906885f80bf87b7378eab0af13038696e83a241" + }, + { + "demo_id": "demo_12", + "file": "demo_12.h5", + "length": 274, + "fields": [ + { + "path": "actions/panda-0", + "shape": [ + 274, + 7 + ], + "dtype": "float32" + }, + { + "path": "actions/panda-1", + "shape": [ + 274, + 7 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qpos", + "shape": [ + 275, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qvel", + "shape": [ + 275, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qpos", + "shape": [ + 275, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qvel", + "shape": [ + 275, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 275, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 275, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 275, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 275, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 275, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "852e687ddfdfffc395914d9038349d41c14d6c1e114034cb5486ea8b90be30aa", + "source_sha256": "eb8d502fe2810314166c4e341506bce2d42cf2a1481a93e1c68f6f7c8e847789", + "view_sha256": "04c92be1d6924fa9f0799187a9b07b6f215c94dceaaf3531eea94df3986ec42e" + }, + { + "demo_id": "demo_13", + "file": "demo_13.h5", + "length": 225, + "fields": [ + { + "path": "actions/panda-0", + "shape": [ + 225, + 7 + ], + "dtype": "float32" + }, + { + "path": "actions/panda-1", + "shape": [ + 225, + 7 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qpos", + "shape": [ + 226, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qvel", + "shape": [ + 226, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qpos", + "shape": [ + 226, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qvel", + "shape": [ + 226, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 226, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 226, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 226, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 226, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 226, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "3f7328b217faa757fe79e123a7964a0b5a946e216b6d029ea8bab6da7bb3083a", + "source_sha256": "e2b8387e25984af73a6e7c8ca1e65e3aa3bc091531fcccaf73d2c5f634fda66a", + "view_sha256": "10b787ce6f5251fea712d9931d6644ce54fc7934141844d55b836d03f3f24cae" + }, + { + "demo_id": "demo_14", + "file": "demo_14.h5", + "length": 228, + "fields": [ + { + "path": "actions/panda-0", + "shape": [ + 228, + 7 + ], + "dtype": "float32" + }, + { + "path": "actions/panda-1", + "shape": [ + 228, + 7 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qpos", + "shape": [ + 229, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qvel", + "shape": [ + 229, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qpos", + "shape": [ + 229, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qvel", + "shape": [ + 229, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 229, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 229, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 229, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 229, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 229, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "37fbef4dfac0f3c7073bfedc050cf00994818954239e66c42a6a89382655396e", + "source_sha256": "d89720a31be64353c45da44848dca9acabca44c43db52f553f0c3b8301dce5e5", + "view_sha256": "49ad3137e5f12e607be76b780dfe0ecba47e8ea8fa7ca579ffc9b922f177f38c" + }, + { + "demo_id": "demo_15", + "file": "demo_15.h5", + "length": 230, + "fields": [ + { + "path": "actions/panda-0", + "shape": [ + 230, + 7 + ], + "dtype": "float32" + }, + { + "path": "actions/panda-1", + "shape": [ + 230, + 7 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qpos", + "shape": [ + 231, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qvel", + "shape": [ + 231, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qpos", + "shape": [ + 231, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qvel", + "shape": [ + 231, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 231, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 231, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 231, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 231, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 231, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "2dca354b2511ca24564d4c4cdedd5a5c09d9f695fb7b70418c10d6f2863eaeff", + "source_sha256": "1417e4f83939ba724e12fef310945c3ddcd56878f45a56e5610f075c9ab18776", + "view_sha256": "e237032a791b021736c6dd4ed5d73f6e91f569866c98c451e91786b8126fdffb" + }, + { + "demo_id": "demo_16", + "file": "demo_16.h5", + "length": 226, + "fields": [ + { + "path": "actions/panda-0", + "shape": [ + 226, + 7 + ], + "dtype": "float32" + }, + { + "path": "actions/panda-1", + "shape": [ + 226, + 7 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qpos", + "shape": [ + 227, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qvel", + "shape": [ + 227, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qpos", + "shape": [ + 227, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qvel", + "shape": [ + 227, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 227, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 227, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 227, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 227, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 227, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "0c1b391e9fd47bc173a24548437c791f3181ceaa20f62224d90978b15e749881", + "source_sha256": "da27102daccf42b3c300ff376a5e73f4caec9591f0e02c7d290d55dcb55ba38e", + "view_sha256": "90332e029671cf6c6937fc2e3bfa4ac5190c240f85363da5dc4301b691ef5691" + }, + { + "demo_id": "demo_17", + "file": "demo_17.h5", + "length": 247, + "fields": [ + { + "path": "actions/panda-0", + "shape": [ + 247, + 7 + ], + "dtype": "float32" + }, + { + "path": "actions/panda-1", + "shape": [ + 247, + 7 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qpos", + "shape": [ + 248, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qvel", + "shape": [ + 248, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qpos", + "shape": [ + 248, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qvel", + "shape": [ + 248, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 248, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 248, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 248, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 248, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 248, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "dc8e33c0e6cedbf5a10a8cc98e7a150b73fc6b22cb52ad7a402957a9a75be5b1", + "source_sha256": "5397b16cd88493918bebb5366fdbadcfb467473ffbd3daf58181cc89ff00ac22", + "view_sha256": "90ca9e1b8e1ed2f092246918126c1660ee8f3f8eeaba56b2761932cbeaa5f0bd" + }, + { + "demo_id": "demo_18", + "file": "demo_18.h5", + "length": 226, + "fields": [ + { + "path": "actions/panda-0", + "shape": [ + 226, + 7 + ], + "dtype": "float32" + }, + { + "path": "actions/panda-1", + "shape": [ + 226, + 7 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qpos", + "shape": [ + 227, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qvel", + "shape": [ + 227, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qpos", + "shape": [ + 227, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qvel", + "shape": [ + 227, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 227, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 227, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 227, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 227, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 227, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "a3474e55c96d8a465b775595f1a3185ff130150281eaafc80bd3a2a9bc15c2cc", + "source_sha256": "78c9b3cbcf67e9c7688f31277045319a82bf9dfdd83df39b7257cf531bdbc994", + "view_sha256": "5e3834be653bff024b52bd0e591ede700c8be788ccfe9833414293f9f9300188" + }, + { + "demo_id": "demo_19", + "file": "demo_19.h5", + "length": 254, + "fields": [ + { + "path": "actions/panda-0", + "shape": [ + 254, + 7 + ], + "dtype": "float32" + }, + { + "path": "actions/panda-1", + "shape": [ + 254, + 7 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qpos", + "shape": [ + 255, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-0/qvel", + "shape": [ + 255, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qpos", + "shape": [ + 255, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/panda-1/qvel", + "shape": [ + 255, + 9 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 255, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 255, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 255, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 255, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 255, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "7323575b4e03cc3c4d10acfdda1671f1efeab5fb9fc47db1b3a16673b9661414", + "source_sha256": "4135eb3977ee788eca2650a60ffc24e8c7998a7478e2728bfa08262623bc3ceb", + "view_sha256": "54fea9809ebf536bbfa0006a64b1f24d0e2f1ec85772fc393ed649c1f223ac04" + } + ] +} diff --git a/agent_d20_e20/frozen_20261102/tasks/DualArmFoldHandKerchief-v1/frozen/findings.md b/agent_d20_e20/frozen_20261102/tasks/DualArmFoldHandKerchief-v1/frozen/findings.md new file mode 100644 index 0000000000000000000000000000000000000000..8a7b4c45b955138551ed9122ac3fa8ad0d99e29b --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/DualArmFoldHandKerchief-v1/frozen/findings.md @@ -0,0 +1,27 @@ +# Legal E20 exploration ledger + +Budget first queried: 0/20 used. Contract: DualArmFoldHandKerchief-v1, 14 normalized delta-pose/gripper components, 300 native steps, hold consumes first step. All environment interaction uses /worker_api.py API only. No simulator access or resets, neural fitting, or external data. + +Preregistered visible rule: success only if legal images unambiguously show the handkerchief folded into a substantially smaller layered shape; a merely occluded, lifted, wrinkled, or ambiguous patch is false. Native sparse success is recorded separately when returned and is never inferred. + +## Episode 1 +Initial cloth localized visually as yellow diamond below and to the right of the top-view center. Observation has five RGB cameras and four flat proprioception paths, with step_id in the API envelope. Initial candidate action executed once. Harness expected an unwrapped action response and stopped; actual execute_actions returns {'executed', 'steps'}. Saved unexpected.pkl and action. finish_episode called. Program failure; no folding assessment. Fixed harness extraction to steps[-1]. + +## Episode 2 +Original candidate ran full 300-step horizon. Native success remained false. Observed phase rose to 1.1596 by step 100 then stayed there through 300. Top/front step121 images show a broad flat cloth, no unambiguous fold. Retrieval stalled on post-close settling rows with unchanged arm pose and zero motion. Grasp itself unverified. Proposed v2 adds monotonic phase advancement at demonstration-scale rates and excludes far-behind phase rows, keeping current image/proprioception matching across all demos. This directly addresses timing deadlock, not grasp localization. + +## Episode 3 +v2 phase advancement ran all 300 steps; native success false throughout. Phase passed 1 at roughly 70, 2 at 178, and 3 by 240. Step141 top and step181 front show cloth transported into a narrower shape, unlike the flat stalled ep2. Step221 still has elongated cloth and strong hand occlusion. No definitive completion. Closed finger qpos values are near zero for both demos and live scene, so finger gap alone cannot certify cloth grasp. Pose/vision feedback remains essential. Independent runner check scheduled episode4. + +## Episode 4 (independent rehearsal) +Bundle 535604fc09493af34fcbf530bde4be84d42245cb27bc522a0101d264e1960f00 valid, finished, native success false. Final top/front saved through latest_observation. Cloth broad and irregular after prolonged endpoint actions. Visible judgment false. First score submission used a structured evidence object and was rejected; resubmitted as an evidence string. No episode charged for scoring. Practical plan: constrain timing, stop residual endpoint movement, release and retreat to expose actual shape; then test local pose correction and localization weighting. +Scoring clarification: string-evidence submission for episode4 was also rejected because native or previous scores cannot be overwritten. The rehearsal already has native_step_feedback=false, which is authoritative. The visual false judgment remains documented locally; score_rehearsal will be used only when native feedback is absent. + +## Episode 5 +v3 adds a finish sequence at phase2.75: open both grippers for 8 steps, then upward z .08 for 20 steps, then settle for 17. Completed at step251; native success false. Final top/front show smaller roughly rectangular cloth with curling, still partially occluded. Folding incomplete/ambiguous. The release reduces endpoint drifting and makes morphology easier to judge. Next v4 adds bounded local numerical pose correction, estimated solely from legal demonstration joint differences and actions (no neural weights). Correction per translational component capped at .035 normalized, gain .25. + +## Episode 6 +v4 bounded numerical pose correction, fixed phase schedule. Ended step257, native success false. Midfold step141 front and step161 top show a largely flat cloth despite arm travel; grasp likely missed. Pose correction alone did not establish contact. Timing may force closure before the relevant demonstration's approach completes. v5 replaces fixed phase rates with the retrieved examples' actual phase increments (derived from bank sequence differences), retaining feedback and bounded correction. + +## Episode 7 +v5 adaptive demonstration phase increments with bounded local pose correction. Native success TRUE at step196 and terminated TRUE. Exact returned event saved in ep07/events.json. Final image ep07/step196/top_camera.png shows compact folded cloth; native signal is authoritative. This is one interactive success, not independent validation. Preserve this version and rehearse it in episode8 before changing behavior. diff --git a/agent_d20_e20/frozen_20261102/tasks/DualArmFoldHandKerchief-v1/frozen/handoff.md b/agent_d20_e20/frozen_20261102/tasks/DualArmFoldHandKerchief-v1/frozen/handoff.md new file mode 100644 index 0000000000000000000000000000000000000000..3dcad2c36731d35aad1878060937ca5980ffa506 --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/DualArmFoldHandKerchief-v1/frozen/handoff.md @@ -0,0 +1,3 @@ +# Runtime handoff: adaptive feedback retrieval +Call reset_episode() then act(obs) after the runner hold. step_id 1..299 yields a bounded 14-vector or None; step300 stops. Uses legal RGB/proprioception/instruction/step_id only. Runtime files: controller.py, features.py, reference_bank.npz, servo.py, servo_bank.npz. NumPy and OpenCV must be installed; no networking, RPC, neural weights or external model at runtime. +Reference bank derives from exactly this task's 20 authorized D20 demonstrations. servo_bank contains numerical joint differences and action averages from those same demonstrations; no neural weights were trained. Local inverse regression supplies bounded pose correction. Phase increments are derived from original bank sequence differences. One interactive native success in episode7 at step196; other scenes failed, so robustness is unresolved. Current version must be independently rehearsed before submission. All legal exploration evidence resides in ../exploration; no evaluation data accessed. diff --git a/agent_d20_e20/frozen_20261102/tasks/DualArmFoldHandKerchief-v1/frozen/policy_runner.py b/agent_d20_e20/frozen_20261102/tasks/DualArmFoldHandKerchief-v1/frozen/policy_runner.py new file mode 100644 index 0000000000000000000000000000000000000000..e49448d6245feb7818ae505f1061708ab97c6ead --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/DualArmFoldHandKerchief-v1/frozen/policy_runner.py @@ -0,0 +1,25 @@ +"""Frozen-program entry point; no development agent and no reset capability.""" +import importlib.util +import sys + +sys.path.insert(0,'/artifact') +sys.path.insert(0,'/') +from worker_api import API + + +def main(): + spec=importlib.util.spec_from_file_location('controller','/artifact/controller.py') + module=importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + module.reset_episode() + api=API() + result=api.latest_observation() + while not (result['terminated'] or result['truncated'] or result['horizon_reached']): + obs=dict(result['observation'],step_id=result['step_id']) + action=module.act(obs) + if action is None:break + response=api.execute_actions([action]) + result=response['steps'][-1] + + +if __name__=='__main__':main() diff --git a/agent_d20_e20/frozen_20261102/tasks/DualArmFoldHandKerchief-v1/frozen/servo.py b/agent_d20_e20/frozen_20261102/tasks/DualArmFoldHandKerchief-v1/frozen/servo.py new file mode 100644 index 0000000000000000000000000000000000000000..42d1f1349e5a80ac842f2168625b82a365e8d359 --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/DualArmFoldHandKerchief-v1/frozen/servo.py @@ -0,0 +1,18 @@ +"""Local numerical inverse motion map from this task's legal demonstrations.""" +from pathlib import Path +import numpy as np +_data=None +def correction(q, target): + global _data + if _data is None: + with np.load(Path(__file__).with_name('servo_bank.npz'),allow_pickle=False) as z:_data={k:z[k].astype(np.float32) for k in z.files} + out=np.zeros(14,np.float32) + for r in range(2): + sl=slice(r*7,r*7+7);j=np.arange(r*18,r*18+7) + current=q[j]*.35;goal=target[j]*.35 + cost=np.mean((_data['q'][:,sl]-current)**2,axis=1) + ix=np.argsort(cost)[:160] + X=_data['dq'][ix,sl];Y=_data['a'][ix,r*3:r*3+3] + W=np.linalg.solve(X.T@X+np.eye(7)*1e-4,X.T@Y) + out[r*7:r*7+3]=np.clip(.25*(goal-current)@W,-.035,.035) + return out diff --git a/agent_d20_e20/frozen_20261102/tasks/DualArmFoldHandKerchief-v1/frozen/synthetic_check.txt b/agent_d20_e20/frozen_20261102/tasks/DualArmFoldHandKerchief-v1/frozen/synthetic_check.txt new file mode 100644 index 0000000000000000000000000000000000000000..06df6708b5726e28aa029df91b83693edcb9217b --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/DualArmFoldHandKerchief-v1/frozen/synthetic_check.txt @@ -0,0 +1,2 @@ +PASS: Python syntax; real-bank load with fabricated observation; synthetic-bank RGB and proprioception responsiveness; HWC/1HWC; finite bounded 14-vector; steps 299/300; malformed input; reset. +Synthetic inputs only. No environment, replay evaluation, simulator, success estimate or rollout. diff --git a/agent_d20_e20/frozen_20261102/tasks/DualArmFoldHandKerchief-v1/frozen/worker_api.py b/agent_d20_e20/frozen_20261102/tasks/DualArmFoldHandKerchief-v1/frozen/worker_api.py new file mode 100644 index 0000000000000000000000000000000000000000..ff137d1c68cb70a1549326d2d22b430c9cf4e20c --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/DualArmFoldHandKerchief-v1/frozen/worker_api.py @@ -0,0 +1,81 @@ +"""Standalone worker client; safe to mount without the runner package.""" +import base64 +import json +import socket +import struct +import uuid +import os +from pathlib import Path + +import numpy as np + + +def array_hook(value): + if value.get('__array__') is True: + dtype=np.dtype(value['dtype']) + if dtype.kind not in 'bifu':raise ValueError('non-numeric array from service') + raw=base64.b64decode(value['data'],validate=True) + return np.frombuffer(raw,dtype=dtype).reshape(value['shape']).copy() + return value + + +class API: + def __init__(self,socket_path='/rpc/control.sock',demo_root='/demonstrations',manifest='/demo_manifest.json'): + self.socket_path=socket_path + self.demo_root=Path(demo_root) + self.manifest=Path(manifest) + + def call(self,method,arguments=None,request_id=None): + # Caller can persist a request ID before sending. Never automatically retry. + request_id=request_id or str(uuid.uuid4()) + request={'request_id':request_id,'method':method,'arguments':arguments or {}} + if os.environ.get('AGENT_E20_RPC_TOKEN'): + request['token']=os.environ['AGENT_E20_RPC_TOKEN'] + payload=json.dumps(request,allow_nan=False).encode() + if len(payload)>65536:raise ValueError('request too large') + with socket.socket(socket.AF_UNIX,socket.SOCK_STREAM) as s: + s.settimeout(1810);s.connect(self.socket_path) + s.sendall(struct.pack('!I',len(payload))+payload) + def exact(n): + chunks=[] + while n: + chunk=s.recv(min(n,1024*1024)) + if not chunk:raise RuntimeError('RPC interrupted; do not replay action with a new ID') + chunks.append(chunk);n-=len(chunk) + return b''.join(chunks) + length=struct.unpack('!I',exact(4))[0] + if length>64*1024*1024:raise RuntimeError('response too large') + result=json.loads(exact(length),object_hook=array_hook) + if not result['ok']:raise RuntimeError(result['error']) + return result['result'] + + def next_episode(self,request_id=None):return self.call('next_episode',request_id=request_id) + def latest_observation(self):return self.call('latest_observation') + def execute_actions(self,actions,request_id=None): + return self.call('execute_actions',{'actions':np.asarray(actions).tolist()},request_id) + def finish_episode(self):return self.call('finish_episode') + def budget_status(self):return self.call('budget_status') + def rehearse(self,candidate='candidate',request_id=None): + return self.call('rehearse',{'candidate':candidate},request_id) + def score_rehearsal(self,episode,visible_success,evidence): + return self.call('score_rehearsal',{'episode':episode,'visible_success':visible_success,'evidence':evidence}) + def freeze(self):return self.call('freeze') + + def read_demo(self,demo_id,start=0,stop=None,fields=None): + import h5py + manifest=json.loads(self.manifest.read_text()) + if manifest.get('status') not in ('released','released_for_offline_analysis'): + raise RuntimeError('demonstrations not released by trusted preflight') + entries={e['demo_id']:e for e in manifest['episodes']} + if demo_id not in entries:raise ValueError('unauthorized demo ID') + entry=entries[demo_id] + allowed={f['path'] for f in entry['fields']} + fields=sorted(allowed) if fields is None else fields + if not set(fields)<=allowed:raise ValueError('unauthorized demo field') + stop=entry['length']+1 if stop is None else stop + if not isinstance(start,int) or not isinstance(stop,int) or not 0<=start25px or radius changes>10px per step. Recompiled all legal demo ball tracks with same continuity rule. Retains extended lift schedule to isolate localization change. +- Episode6 tracked localization reached symmetric contact at111 but lost ball by151. Extended-lift override accidentally zeroed the computed x feedback after phase130. Corrected for episode7; this is a controller program failure. No recovery after ball loss. Native success false. +- Episode7 trial: stop rotation at110, keep grippers open, z=.08 and inward y=.035 until180, preserving x feedback throughout. This tests a wider cradle and avoids closing fingers out from under the sphere. +- Episode7 open-finger cradle still slipped forward by141. Kept depth feedback but cumulative commanded offsets were inadequate to estimate actual hand location. No native success. +- Episode8 introduces analytical Panda serial-chain forward kinematics from observed qpos only (NumPy matrix operations; no simulator or dynamics). Demonstration calibration at phase50 gives depth=.00221695*top_ball_x-.530522; robot0 local-y and negative robot1 local-y align with action-x effects. Runtime x command=clip(5*(ball_depth-hand_depth),-.18,.18). One visually clearly lifting demo00 supplies other channels. No neural weights fitted. Geometric pixel calibration used only own D20 data. Open cradle / rotation cutoff110 retained to isolate control-estimate change. +- Episode8: direct joint-based depth feedback gave orderly contact at121, but ball lost by161. Fixed wrist tilt with continuing z commands did not yield expected upward hand motion; pose/IK constraints are a suspected cause, not a measured simulator diagnosis. Native success false. +- Episode9 restores demo00 full tilt and closure through140; keeps measured depth servo. FK tool offset corrected to .2104m (flange plus hand offset) for lateral/vertical estimates; depth axis is nearly invariant to pure tilt. Extended phase140:180 uses z=.1, opposite rx=.03, and measured lateral target local-x=.58 with gain5 and cap.04, closed grippers. This replaces unbounded accumulated inward travel. +- Episode9 achieved native success=true and terminated=true at step140. Preserved latest native return and final images. The interactive harness incorrectly attempted a further action, rejected as inactive. Budget remains9 slots. Fixed termination checks and incremental JSONL action logging for future interactive runs. Episode9's per-action list was in memory and lost on this harness exception; sparse observations every10 steps plus final return remain. Do not reconstruct or claim a complete action trace. Extended phase after140 was not exercised because native success terminated the episode. +- Episode10 independent rehearsal hash c07bad9cd66b8bd1b7c0671e48211a25872fa76ca5c6081ecdcd052c439a2239 valid=true, native success=false at210. Final front empty hands, top hands far to positive-depth side. Direct depth tracking did not arrest rolling drift. +- Episode11 adds filtered ball depth velocity (0.65 previous +0.35 finite difference), 3-step lead, .3 restoring offset from initial ball depth, gain8/cap.25. This is a handcrafted anticipatory servo, not a neural model. Other channels unchanged from episode9/10. +- Episode11 native success false. Initial ballx263.5, at101 x288.5 with hand depth~.101m; by111 ballx371.5, handdepth~.274m. By121 sphere leaves image edge. X actuator cap .25 was reached; controller lagged accelerating roll. Recorded top121 shows ball at right edge, not a support mistaken for success. +- Episode12 increases prediction lead6, drift restoring coefficient.6, proportional gain12, cap.6; prebias .2*initial_depth during contact phase>=80. Converts apparent ball offset to depth using radius-normalized .15*(x-239.3)/r, calibrated from demo geometry, to reduce height-dependent projection error. No official dimensions or hidden state read. +- Episode12 native success false. Initial ballx199.5; at111 x178.5, by121 true sphere center~39.5 (top image saved). High gains did not arrest drift and hands followed it toward edge. Front141 showed transient elevation but unstable asymmetric contact, not success. +- Episode13 trial removes moving-ball chasing: initial depth localized once, held by qpos-based proportional feedback gain8/cap.25 through grasp and lift. Same demonstrated tilt/closure and extended lift. Tests whether pursuit adds destabilizing motion. +- Episode13 native success false. Fixed initial depth did not retain sphere through late lift. This ablation rules out pursuit as the sole failure cause. +- Episode14 trial: track demo00 measured hand-depth trajectory translated by initial ball-depth offset. Add bounded gain8 correction to demo x feedforward, using current qpos FK and same-time demo FK. Uses both measured pose and initial localization without chasing later ball slips. Other channels unchanged. All geometry comes from legal qpos and compiled demo arrays. +- Episode14 translated-path trial lost ball, native success false. No demonstrated recovery method proved effective. +- Final development decision: restore the episode9/10 runtime behavior (v8_native_success). It achieved native success at140 in episode9 and independently ran valid but failed in episode10. All other tested runtime changes failed. Episodes15–20 will independently rehearse one unchanged, documented bundle of this behavior. Final selection belongs to API.freeze(), using its specified ranking. diff --git a/agent_d20_e20/frozen_20261102/tasks/DualArmLiftBall-v1/frozen/policy_runner.py b/agent_d20_e20/frozen_20261102/tasks/DualArmLiftBall-v1/frozen/policy_runner.py new file mode 100644 index 0000000000000000000000000000000000000000..e49448d6245feb7818ae505f1061708ab97c6ead --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/DualArmLiftBall-v1/frozen/policy_runner.py @@ -0,0 +1,25 @@ +"""Frozen-program entry point; no development agent and no reset capability.""" +import importlib.util +import sys + +sys.path.insert(0,'/artifact') +sys.path.insert(0,'/') +from worker_api import API + + +def main(): + spec=importlib.util.spec_from_file_location('controller','/artifact/controller.py') + module=importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + module.reset_episode() + api=API() + result=api.latest_observation() + while not (result['terminated'] or result['truncated'] or result['horizon_reached']): + obs=dict(result['observation'],step_id=result['step_id']) + action=module.act(obs) + if action is None:break + response=api.execute_actions([action]) + result=response['steps'][-1] + + +if __name__=='__main__':main() diff --git a/agent_d20_e20/frozen_20261102/tasks/DualArmLiftBall-v1/frozen/worker_api.py b/agent_d20_e20/frozen_20261102/tasks/DualArmLiftBall-v1/frozen/worker_api.py new file mode 100644 index 0000000000000000000000000000000000000000..ff137d1c68cb70a1549326d2d22b430c9cf4e20c --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/DualArmLiftBall-v1/frozen/worker_api.py @@ -0,0 +1,81 @@ +"""Standalone worker client; safe to mount without the runner package.""" +import base64 +import json +import socket +import struct +import uuid +import os +from pathlib import Path + +import numpy as np + + +def array_hook(value): + if value.get('__array__') is True: + dtype=np.dtype(value['dtype']) + if dtype.kind not in 'bifu':raise ValueError('non-numeric array from service') + raw=base64.b64decode(value['data'],validate=True) + return np.frombuffer(raw,dtype=dtype).reshape(value['shape']).copy() + return value + + +class API: + def __init__(self,socket_path='/rpc/control.sock',demo_root='/demonstrations',manifest='/demo_manifest.json'): + self.socket_path=socket_path + self.demo_root=Path(demo_root) + self.manifest=Path(manifest) + + def call(self,method,arguments=None,request_id=None): + # Caller can persist a request ID before sending. Never automatically retry. + request_id=request_id or str(uuid.uuid4()) + request={'request_id':request_id,'method':method,'arguments':arguments or {}} + if os.environ.get('AGENT_E20_RPC_TOKEN'): + request['token']=os.environ['AGENT_E20_RPC_TOKEN'] + payload=json.dumps(request,allow_nan=False).encode() + if len(payload)>65536:raise ValueError('request too large') + with socket.socket(socket.AF_UNIX,socket.SOCK_STREAM) as s: + s.settimeout(1810);s.connect(self.socket_path) + s.sendall(struct.pack('!I',len(payload))+payload) + def exact(n): + chunks=[] + while n: + chunk=s.recv(min(n,1024*1024)) + if not chunk:raise RuntimeError('RPC interrupted; do not replay action with a new ID') + chunks.append(chunk);n-=len(chunk) + return b''.join(chunks) + length=struct.unpack('!I',exact(4))[0] + if length>64*1024*1024:raise RuntimeError('response too large') + result=json.loads(exact(length),object_hook=array_hook) + if not result['ok']:raise RuntimeError(result['error']) + return result['result'] + + def next_episode(self,request_id=None):return self.call('next_episode',request_id=request_id) + def latest_observation(self):return self.call('latest_observation') + def execute_actions(self,actions,request_id=None): + return self.call('execute_actions',{'actions':np.asarray(actions).tolist()},request_id) + def finish_episode(self):return self.call('finish_episode') + def budget_status(self):return self.call('budget_status') + def rehearse(self,candidate='candidate',request_id=None): + return self.call('rehearse',{'candidate':candidate},request_id) + def score_rehearsal(self,episode,visible_success,evidence): + return self.call('score_rehearsal',{'episode':episode,'visible_success':visible_success,'evidence':evidence}) + def freeze(self):return self.call('freeze') + + def read_demo(self,demo_id,start=0,stop=None,fields=None): + import h5py + manifest=json.loads(self.manifest.read_text()) + if manifest.get('status') not in ('released','released_for_offline_analysis'): + raise RuntimeError('demonstrations not released by trusted preflight') + entries={e['demo_id']:e for e in manifest['episodes']} + if demo_id not in entries:raise ValueError('unauthorized demo ID') + entry=entries[demo_id] + allowed={f['path'] for f in entry['fields']} + fields=sorted(allowed) if fields is None else fields + if not set(fields)<=allowed:raise ValueError('unauthorized demo field') + stop=entry['length']+1 if stop is None else stop + if not isinstance(start,int) or not isinstance(stop,int) or not 0<=start225).astype('uint8'); mask[130:]=0 + n, labels, stats, cent = cv2.connectedComponentsWithStats(mask) + if n < 2: return b + i = 1+np.argmax(stats[1:,4]); x,y,w,h,area=stats[i] + if area<500 or w<20: return b + g=np.load(Path(__file__).with_name('geometry.npz')) + target=np.array([x+w/2,y+h,1])@g['W'] + _scene_target=target.copy() + offsets=target-g['targets'][b['demo'].astype(int)] + ph=b['phase'] + f0=np.minimum(ph/.5,1)*np.clip((4-ph)/.45,0,1) + f1=np.clip((ph-1.42)/.4,0,1) + for j in (0,1): + b['q'][:,j] += offsets[:,j]*f0 + b['a'][:,j] += offsets[:,j]*f0 + b['q'][:,12+j] += offsets[:,j]*f1 + b['a'][:,10+j] += offsets[:,j]*f1 + _scene_ready=True + return b + +def detect_object(obs): + global _object_mode, _object_votes + if not (1.98 < _progress < 2.5): return + a=cv2.resize(np.asarray(obs['rgb']['front_camera']).squeeze(),(320,240),interpolation=cv2.INTER_AREA).astype(float) + r,g,bl=a.transpose(2,0,1) + mask=(bl>r+3)&(bl>g+2)&(r<60)&(g<60)&(bl<100) + mask[:60]=False;mask[132:]=False;mask[:,:110]=False;mask[:,185:]=False + y,x=np.where(mask) + if len(y)>=5: + _object_centers.append([float(np.median(x)),float(np.median(y))]) + _object_votes.append(int(np.median(y)<110)) + if len(_object_votes)>=3: _object_mode=int(np.mean(_object_votes[-15:])>=.5) + + +def refine_object(b): + global _object_adjusted + if _object_adjusted or _object_mode is None or _scene_target is None or _progress<2.25: return + og=np.load(Path(__file__).with_name('object_geometry.npz')) + center=np.median(_object_centers[-15:],axis=0) + target=np.r_[center,_scene_target,1]@og['weights'][_object_mode] + demos=np.flatnonzero(og['mode']==_object_mode) + # Restrict interpolation to the observed within-shelf pose envelope. + target[3:]=np.clip(target[3:],og['targets'][demos,3:].min(0),og['targets'][demos,3:].max(0)) + target[:3]=np.clip(target[:3],b['base_low'][:3],b['base_high'][:3]) + for di in demos: + ids=np.flatnonzero(b['demo']==di) + grasp=ids[np.flatnonzero(b['phase'][ids]>=3)[0]] + offset=target-b['q'][grasp,:10] + f=np.clip((b['phase'][ids]-2.08)/.62,0,1)*np.clip((3.6-b['phase'][ids])/.4,0,1) + b['q'][ids,:10]+=f[:,None]*offset + b['a'][ids,:3]+=f[:,None]*offset[:3] + _object_adjusted=True + +def _hold(q): + a = np.zeros(20, dtype=np.float32) + for r in (0, 1): + a[10*r:10*r+3] = q[12*r:12*r+3] + a[10*r+9] = np.clip(2*(q[12*r+10]+0.01)/0.05-1, -1, 1) + return a + +def act(obs): + """Return a 20-vector or None; step 1 follows the runner-owned hold. + + Base bounds are absent in the supplied contract. Base outputs lie within + the observed demonstration envelope, except measured-position fallback + holds. Neither constitutes verification of unknown native limits. + """ + global _progress, _terminal_count, _last_step, _last_action, _grasp_settle, _grasp_target, _grasp_retry + step = int(obs.get('step_id', 1)) + if step < _last_step: + reset_episode() + if step == _last_step and _last_action is not None: + return _last_action.copy() + # 650 includes runner's initial hold: at most 649 controller actions. + if step >= 650: + return None + try: + p = obs['proprioception'] + arrays = [np.asarray(p[path], dtype=np.float32).reshape(-1) for path in PATHS] + if any(a.size != 12 or not np.isfinite(a).all() for a in arrays): + return None + q = np.concatenate((arrays[0], arrays[2])) + v = np.concatenate((arrays[1], arrays[3])) + except (KeyError, TypeError, ValueError): + return None + b = _load() + try: b = localize_scene(obs,b) + except (KeyError, ValueError, cv2.error): pass + hold = _hold(q) + try: + image = visual_feature(obs['rgb']).astype(np.float32)/255.0 + except (KeyError, TypeError, ValueError, cv2.error): + _last_step, _last_action = step, hold + return hold.copy() + try: detect_object(obs) + except (KeyError,ValueError,cv2.error): pass + refine_object(b) + # Progress is inferred from current observations across all 20 demos; + # it is never set from an episode ID, hidden seed, or step schedule. + eligible = np.flatnonzero((b['phase'] >= _progress-0.015) & + (b['phase'] <= _progress+0.45)) + if _object_mode is not None and _progress>2.08: + og=np.load(Path(__file__).with_name('object_geometry.npz')) + eligible=eligible[og['mode'][b['demo'][eligible].astype(int)]==_object_mode] + dq = (b['q'][eligible]-q)/b['qscale'] + qcost = np.mean(np.minimum(dq*dq, 100), axis=1) + dv = (b['v'][eligible]-v)/b['vscale'] + vcost = np.mean(np.minimum(dv*dv, 25), axis=1) + preliminary = qcost + 0.03*vcost + k = min(96, len(eligible)) + short = np.argpartition(preliminary, k-1)[:k] + ids = eligible[short] + visual = np.mean((b['rgb'][ids].astype(np.float32)/255.0-image)**2, axis=1) + continuity = 0.12*(b['phase'][ids]-(_progress+0.025))**2 + cost = preliminary[short] + 12*visual + continuity + best_local = int(np.argmin(cost)); best = ids[best_local] + # Conservative, uncalibrated rejection; does not certify safety/success. + if qcost[short[best_local]] > 2.5 or visual[best_local] > 0.09: + _terminal_count = 0 + _last_step, _last_action = step, hold + return hold.copy() + _progress = min(4.99, max(_progress + 0.004, float(b['phase'][best]))) + # Never blend conflicting gripper commands or widely separated phases. + compatible = (np.all(b['a'][ids][:,[9,19]] == b['a'][best,[9,19]], axis=1) & + (np.abs(b['phase'][ids]-_progress) < 0.045)) + selected = np.flatnonzero(compatible) + selected = selected[np.argsort(cost[selected])[:4]] + weights = np.exp(-(cost[selected]-cost[selected].min())/0.035) + weights /= weights.sum() + # Small demonstrated lookahead avoids stationary nearest-neighbor fixed points. + future = np.minimum(ids[selected]+2, len(b['a'])-1) + future = np.where(b['demo'][future] == b['demo'][ids[selected]], future, ids[selected]) + a = weights @ b['a'][future] + a[[9,19]] = b['a'][best,[9,19]] + if 2.05 < _progress < 3.5: + pm=np.load(Path(__file__).with_name('pose_maps.npz')) + mi=int(np.argmin(abs(pm['centers']-_progress))) + qref=weights @ b['q'][ids[selected]][:,3:10] + correction=(qref-q[3:10])@pm['maps'][mi] + a[3:9] += np.clip(correction,[-.04,-.04,-.04,-.02,-.02,-.02],[.04,.04,.04,.02,.02,.02]) + # Advance demonstrated support-base placement while the handle is opening. + if 1.35 < _progress < 1.99: + support=np.flatnonzero((b['demo']==b['demo'][best])&(b['phase']>=min(1.99,_progress+.18))) + if len(support): a[10:13]=b['a'][support[0],10:13] + # Fixed grasp-pose servo, followed by closure dwell and one empty-grasp retry. + if 2.96 < _progress < 3.18 and _grasp_settle < 50 and _object_mode is not None: + if _grasp_target is None: + og=np.load(Path(__file__).with_name('object_geometry.npz')) + gi=np.flatnonzero((b['phase']>=3.03)&(b['phase']<=3.06)&(og['mode'][b['demo'].astype(int)]==_object_mode)) + err=np.mean(((b['q'][gi,:10]-q[:10])/b['qscale'][:10])**2,axis=1) + _grasp_target=b['q'][gi[np.argmin(err)]].copy() + ref=_grasp_target + pm=np.load(Path(__file__).with_name('pose_maps.npz')) + mi=int(np.argmin(abs(pm['centers']-3))) + a[:3]=ref[:3] + a[3:9]=np.clip(2*(ref[3:10]-q[3:10])@pm['maps'][mi],-.1,.1) + a[9]=1 if _grasp_settle<35 else -1 + _progress=2.97 + _grasp_settle+=1 + if _grasp_settle==50: + if q[10]<.004 and not _grasp_retry: + _grasp_retry=True + _grasp_target[0]-=.025 + _grasp_settle=15 + else: _progress=3.06 + # Base targets remain absolute. Rate limit distance from measured base. + current_base = q[[0,1,2,12,13,14]] + a[BASE] = current_base + np.clip(a[BASE]-current_base, + -b['base_step_cap'], b['base_step_cap']) + a[BASE] = np.clip(a[BASE], b['base_low'], b['base_high']) + a[NORMALIZED] = np.clip(a[NORMALIZED], -1, 1) + # Terminal similarity is only a stop heuristic, never a success signal. + if _progress > 4.85 and a[9] > 0 and visual[best_local] < 0.012 and qcost[short[best_local]] < 0.15: + _terminal_count += 1 + else: + _terminal_count = 0 + if _terminal_count >= 8: + return None + _last_step, _last_action = step, a.astype(np.float32) + return _last_action.copy() diff --git a/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/demo_manifest.json b/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/demo_manifest.json new file mode 100644 index 0000000000000000000000000000000000000000..8fc3ed449fceaeea6c1d10e35b7c4d71bf422004 --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/demo_manifest.json @@ -0,0 +1,2168 @@ +{ + "task_id": "DualArmOpenFridge-v1", + "status": "released", + "selection_rule": "prefer existing pinned D20, otherwise numeric trajectory ID sort before reading data", + "lineage_status": "pinned_comparator", + "episodes": [ + { + "demo_id": "demo_00", + "file": "demo_00.h5", + "length": 520, + "fields": [ + { + "path": "actions/mobile_panda-0", + "shape": [ + 520, + 10 + ], + "dtype": "float32" + }, + { + "path": "actions/mobile_panda-1", + "shape": [ + 520, + 10 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qpos", + "shape": [ + 521, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qvel", + "shape": [ + 521, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qpos", + "shape": [ + 521, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qvel", + "shape": [ + 521, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 521, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 521, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 521, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 521, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 521, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "265ff9457d944f49d9893682e24b57dc5a89d2b622515b53489dba8e2e921fe5", + "source_sha256": "770ac39e1460eaf41d4622eedf33c4e9cee5f591cc7fbecc66f64e1960a20ac0", + "view_sha256": "cc40ac4d8abf2f55c384f8947724515346f89248ad80ba4f389cab3660083f15" + }, + { + "demo_id": "demo_01", + "file": "demo_01.h5", + "length": 514, + "fields": [ + { + "path": "actions/mobile_panda-0", + "shape": [ + 514, + 10 + ], + "dtype": "float32" + }, + { + "path": "actions/mobile_panda-1", + "shape": [ + 514, + 10 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qpos", + "shape": [ + 515, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qvel", + "shape": [ + 515, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qpos", + "shape": [ + 515, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qvel", + "shape": [ + 515, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 515, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 515, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 515, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 515, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 515, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "775969c28abbbb25362dc3ff83e7d40f16e768d10f29fb76e374197f654c6e78", + "source_sha256": "e154d25ad488edbf9ec15947d769d13c2ec8258daab578a259a9aecaafd7734d", + "view_sha256": "445d84eb102d8bfd1e08a38d5d6f1467612d0c31f4c1cb0408c3ce25b845696d" + }, + { + "demo_id": "demo_02", + "file": "demo_02.h5", + "length": 491, + "fields": [ + { + "path": "actions/mobile_panda-0", + "shape": [ + 491, + 10 + ], + "dtype": "float32" + }, + { + "path": "actions/mobile_panda-1", + "shape": [ + 491, + 10 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qpos", + "shape": [ + 492, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qvel", + "shape": [ + 492, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qpos", + "shape": [ + 492, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qvel", + "shape": [ + 492, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 492, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 492, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 492, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 492, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 492, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "47afe58bbf75c34d76c123d22cddc6d05176e32f5a66b5ef7c66bdcdc1094bd1", + "source_sha256": "436e2843954018282d8a925a211a68f2f8822452d3ba9fc885e3a4c365c2cb73", + "view_sha256": "e5527220fd2a0c619d33bd85f88d2dd313316a7c63e4662d560e9c3e4784f17a" + }, + { + "demo_id": "demo_03", + "file": "demo_03.h5", + "length": 508, + "fields": [ + { + "path": "actions/mobile_panda-0", + "shape": [ + 508, + 10 + ], + "dtype": "float32" + }, + { + "path": "actions/mobile_panda-1", + "shape": [ + 508, + 10 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qpos", + "shape": [ + 509, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qvel", + "shape": [ + 509, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qpos", + "shape": [ + 509, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qvel", + "shape": [ + 509, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 509, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 509, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 509, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 509, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 509, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "10fdafa333a1c26a857bcc4c1f37d8d4cbf2853c1237b364bc864afe6cb23fa1", + "source_sha256": "2d0b6584ea86fbf51ea289c47425237abd5001f54ab353d540b71d5113226b2a", + "view_sha256": "8e1f50be23ec6d10211744dd4b2555ccdaf2a60454ce5b4c17a032b4597fac83" + }, + { + "demo_id": "demo_04", + "file": "demo_04.h5", + "length": 530, + "fields": [ + { + "path": "actions/mobile_panda-0", + "shape": [ + 530, + 10 + ], + "dtype": "float32" + }, + { + "path": "actions/mobile_panda-1", + "shape": [ + 530, + 10 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qpos", + "shape": [ + 531, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qvel", + "shape": [ + 531, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qpos", + "shape": [ + 531, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qvel", + "shape": [ + 531, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 531, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 531, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 531, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 531, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 531, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "44db4c5ef549fb503c36f650ec671418765fea18cebbd47d9917c45e35aa6dff", + "source_sha256": "6a01ee468fbc1c9f9b88d43209ccbc7552252d9f3e8ec0ad4b95b3b6d051db0f", + "view_sha256": "3c7aa820c44510c28d19adce767a99b96a639f3c9929731ae3671a1b913652c1" + }, + { + "demo_id": "demo_05", + "file": "demo_05.h5", + "length": 483, + "fields": [ + { + "path": "actions/mobile_panda-0", + "shape": [ + 483, + 10 + ], + "dtype": "float32" + }, + { + "path": "actions/mobile_panda-1", + "shape": [ + 483, + 10 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qpos", + "shape": [ + 484, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qvel", + "shape": [ + 484, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qpos", + "shape": [ + 484, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qvel", + "shape": [ + 484, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 484, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 484, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 484, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 484, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 484, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "a468895ecdc8f8d064601292bed320e90921465dca437e916ba1202d20749724", + "source_sha256": "c629973dd9378ac76cf5dc9fbecee75080801975b40f1aa93f27971852220b01", + "view_sha256": "c89a9bfe5ab6a92f07f5132aab3983e881b01c91dd532ee00cf15c6f94e0d47a" + }, + { + "demo_id": "demo_06", + "file": "demo_06.h5", + "length": 511, + "fields": [ + { + "path": "actions/mobile_panda-0", + "shape": [ + 511, + 10 + ], + "dtype": "float32" + }, + { + "path": "actions/mobile_panda-1", + "shape": [ + 511, + 10 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qpos", + "shape": [ + 512, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qvel", + "shape": [ + 512, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qpos", + "shape": [ + 512, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qvel", + "shape": [ + 512, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 512, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 512, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 512, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 512, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 512, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "55d12484b6ac89affc80bf89d384e47c97f3cdb93246579c29b325f4abab805a", + "source_sha256": "8ca44a403d76fe5a1ea5cdfa4fc0bd9c4ee0bc46931ba37be8309be57e870673", + "view_sha256": "43166fb59ea76178cc351872b56244a88cd5dee83611a731cc007339aa255912" + }, + { + "demo_id": "demo_07", + "file": "demo_07.h5", + "length": 490, + "fields": [ + { + "path": "actions/mobile_panda-0", + "shape": [ + 490, + 10 + ], + "dtype": "float32" + }, + { + "path": "actions/mobile_panda-1", + "shape": [ + 490, + 10 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qpos", + "shape": [ + 491, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qvel", + "shape": [ + 491, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qpos", + "shape": [ + 491, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qvel", + "shape": [ + 491, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 491, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 491, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 491, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 491, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 491, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "82ce6760ee72ccb258728d96bf990f6c6e9e3994caf00951f3d6a28d9e7b4f19", + "source_sha256": "a3bc3285abae6e2ce671c51ae8f089ab9b9265ce7c7fca8d3ef4101e40cb313e", + "view_sha256": "80b0aeb63dd303df8243d9ebb6d6d92752b531f77ec25cb296241b0789337cb9" + }, + { + "demo_id": "demo_08", + "file": "demo_08.h5", + "length": 509, + "fields": [ + { + "path": "actions/mobile_panda-0", + "shape": [ + 509, + 10 + ], + "dtype": "float32" + }, + { + "path": "actions/mobile_panda-1", + "shape": [ + 509, + 10 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qpos", + "shape": [ + 510, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qvel", + "shape": [ + 510, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qpos", + "shape": [ + 510, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qvel", + "shape": [ + 510, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 510, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 510, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 510, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 510, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 510, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "4522989dbb175e706d3282e9e46147e13d07621debda419c1c93314e041241ea", + "source_sha256": "2b9df294e603a5443f24b60ee756d2805333fb88dde7e6047bc45e2542774007", + "view_sha256": "b97b9cf77ef22609c847f8284ca9cbc5e840579f94c0c2b3dec16f01bfa8349d" + }, + { + "demo_id": "demo_09", + "file": "demo_09.h5", + "length": 525, + "fields": [ + { + "path": "actions/mobile_panda-0", + "shape": [ + 525, + 10 + ], + "dtype": "float32" + }, + { + "path": "actions/mobile_panda-1", + "shape": [ + 525, + 10 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qpos", + "shape": [ + 526, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qvel", + "shape": [ + 526, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qpos", + "shape": [ + 526, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qvel", + "shape": [ + 526, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 526, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 526, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 526, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 526, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 526, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "9793dd2494dc9962f01cc4cc5f22af0abf0466cd0136e1dc5ff4c170bef19efb", + "source_sha256": "4657a969b3e622c225ffaddf7ce6ee6fe14fdc80bcea9edf8c30d7f49dcbc832", + "view_sha256": "ce810ca9a42d66cd330482f92d797abe702f14ce0079bf7b34ac5d420b7e74a8" + }, + { + "demo_id": "demo_10", + "file": "demo_10.h5", + "length": 523, + "fields": [ + { + "path": "actions/mobile_panda-0", + "shape": [ + 523, + 10 + ], + "dtype": "float32" + }, + { + "path": "actions/mobile_panda-1", + "shape": [ + 523, + 10 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qpos", + "shape": [ + 524, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qvel", + "shape": [ + 524, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qpos", + "shape": [ + 524, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qvel", + "shape": [ + 524, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 524, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 524, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 524, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 524, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 524, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "e4a6ea69ce94b8733554fe63161d8f57fc26655a2a8ffd6ea59f69ab697f9a39", + "source_sha256": "e1cb1dba42f6094dffe7227b041b8f2d26ae1e065b169e00f76fef462690cedb", + "view_sha256": "34e98d7318411c0fe3e7ff25641ab11a8b4a7aa846ad816bc45b1ccffa8539a8" + }, + { + "demo_id": "demo_11", + "file": "demo_11.h5", + "length": 498, + "fields": [ + { + "path": "actions/mobile_panda-0", + "shape": [ + 498, + 10 + ], + "dtype": "float32" + }, + { + "path": "actions/mobile_panda-1", + "shape": [ + 498, + 10 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qpos", + "shape": [ + 499, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qvel", + "shape": [ + 499, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qpos", + "shape": [ + 499, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qvel", + "shape": [ + 499, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 499, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 499, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 499, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 499, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 499, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "aaccf2d2007797926cba4ad0108b24945750a540bfcc8da7a15660066a73448e", + "source_sha256": "2ec75ac5a6d495af7fa4601ed489df27b3795509bc686074ec7f64d65e5eb482", + "view_sha256": "284d69f5db81e912b0f9811cd39e9bcf656cc989cab370896673a39e00b246a8" + }, + { + "demo_id": "demo_12", + "file": "demo_12.h5", + "length": 521, + "fields": [ + { + "path": "actions/mobile_panda-0", + "shape": [ + 521, + 10 + ], + "dtype": "float32" + }, + { + "path": "actions/mobile_panda-1", + "shape": [ + 521, + 10 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qpos", + "shape": [ + 522, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qvel", + "shape": [ + 522, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qpos", + "shape": [ + 522, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qvel", + "shape": [ + 522, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 522, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 522, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 522, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 522, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 522, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "64f181046fe8a3cb1dc927f419bdb6de1e05cb7cec931fabd6f657fe44e6bf07", + "source_sha256": "f01c4447282351554b9eb473708b65bd7c51e5494626b93159fe82a7cd5bb5d5", + "view_sha256": "37a3fde2705304fb0c36455d4bd9d627772e88b643f019eaf6fd155e851cacf9" + }, + { + "demo_id": "demo_13", + "file": "demo_13.h5", + "length": 520, + "fields": [ + { + "path": "actions/mobile_panda-0", + "shape": [ + 520, + 10 + ], + "dtype": "float32" + }, + { + "path": "actions/mobile_panda-1", + "shape": [ + 520, + 10 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qpos", + "shape": [ + 521, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qvel", + "shape": [ + 521, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qpos", + "shape": [ + 521, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qvel", + "shape": [ + 521, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 521, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 521, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 521, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 521, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 521, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "a7d51f0436ee44ff4973a73b6785c32d0af8663da7e680c665dfdb6f755ca342", + "source_sha256": "f11b2f9d0dd53777e35277d3d2a8d4a40f3570f16ef70842a100ad438462dcda", + "view_sha256": "727cb43c0be8d0f8d206b81889072dd3e60d82e2b33295fd4a2b969a7a34e920" + }, + { + "demo_id": "demo_14", + "file": "demo_14.h5", + "length": 511, + "fields": [ + { + "path": "actions/mobile_panda-0", + "shape": [ + 511, + 10 + ], + "dtype": "float32" + }, + { + "path": "actions/mobile_panda-1", + "shape": [ + 511, + 10 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qpos", + "shape": [ + 512, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qvel", + "shape": [ + 512, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qpos", + "shape": [ + 512, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qvel", + "shape": [ + 512, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 512, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 512, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 512, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 512, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 512, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "971658a33fe74d443914a48e3c72362eaec941caa51ccc846fa2196f2e03be28", + "source_sha256": "6e6a3e4d3120d9eb73b4be6a223a2d40e64fa9eba826ff1b463eeea9585f546a", + "view_sha256": "07daca8ba882035ec8fcf206bdf44a7ba73a3a08b0e4c6cc62fa62ff88686d91" + }, + { + "demo_id": "demo_15", + "file": "demo_15.h5", + "length": 513, + "fields": [ + { + "path": "actions/mobile_panda-0", + "shape": [ + 513, + 10 + ], + "dtype": "float32" + }, + { + "path": "actions/mobile_panda-1", + "shape": [ + 513, + 10 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qpos", + "shape": [ + 514, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qvel", + "shape": [ + 514, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qpos", + "shape": [ + 514, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qvel", + "shape": [ + 514, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 514, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 514, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 514, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 514, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 514, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "d1ae568de023e3bf22fcbc0a3e4d11b91c54e9d389ca943fe14b5f1ed09dcd7c", + "source_sha256": "ae63fb099ea400c5aa0eeb58c098ab627401cc31ec8e76b1b249b8a0cab57bba", + "view_sha256": "70fe443ca31d11aead05ee2f3c0f1bb38e1dd841f7fc8cb35545387fdeb984aa" + }, + { + "demo_id": "demo_16", + "file": "demo_16.h5", + "length": 512, + "fields": [ + { + "path": "actions/mobile_panda-0", + "shape": [ + 512, + 10 + ], + "dtype": "float32" + }, + { + "path": "actions/mobile_panda-1", + "shape": [ + 512, + 10 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qpos", + "shape": [ + 513, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qvel", + "shape": [ + 513, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qpos", + "shape": [ + 513, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qvel", + "shape": [ + 513, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 513, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 513, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 513, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 513, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 513, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "c0b433c4d3c3138547708008811a15049c62d7aef16d3e0187bc657daafe64ac", + "source_sha256": "6063e50c39da57732e3cc632329399a82eea0571b8ef33da8aa2625e3aa38224", + "view_sha256": "5df554e9f2c1a00dd4f13ebe2b2d86d7740771328c78ddc34ded95d028e7a0ed" + }, + { + "demo_id": "demo_17", + "file": "demo_17.h5", + "length": 521, + "fields": [ + { + "path": "actions/mobile_panda-0", + "shape": [ + 521, + 10 + ], + "dtype": "float32" + }, + { + "path": "actions/mobile_panda-1", + "shape": [ + 521, + 10 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qpos", + "shape": [ + 522, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qvel", + "shape": [ + 522, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qpos", + "shape": [ + 522, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qvel", + "shape": [ + 522, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 522, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 522, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 522, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 522, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 522, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "100571473ec1e7970c9a77acd62685c253c7efd2398419fae32c464d75c2a254", + "source_sha256": "2bf7387af1f366d3e82f7ee7b4edb764ba8356046153f3498c019c497fd4056a", + "view_sha256": "f2e5cca4551d7fe9900cdb4629cc0dca4281adf9e7271d33189e168f6cf46400" + }, + { + "demo_id": "demo_18", + "file": "demo_18.h5", + "length": 508, + "fields": [ + { + "path": "actions/mobile_panda-0", + "shape": [ + 508, + 10 + ], + "dtype": "float32" + }, + { + "path": "actions/mobile_panda-1", + "shape": [ + 508, + 10 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qpos", + "shape": [ + 509, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qvel", + "shape": [ + 509, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qpos", + "shape": [ + 509, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qvel", + "shape": [ + 509, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 509, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 509, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 509, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 509, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 509, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "881dfc3cad386076951950f43b4a2cee9636fb36e54712e9419be5377b6bc7ea", + "source_sha256": "147204e660f8fe5f03303a447666b68b26d837027d0bf9f6c88b3e29ad0c04e0", + "view_sha256": "6f0b695c5b97cdf0380232acbd6546435628096dba16d61325329abdf0da91d4" + }, + { + "demo_id": "demo_19", + "file": "demo_19.h5", + "length": 510, + "fields": [ + { + "path": "actions/mobile_panda-0", + "shape": [ + 510, + 10 + ], + "dtype": "float32" + }, + { + "path": "actions/mobile_panda-1", + "shape": [ + 510, + 10 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qpos", + "shape": [ + 511, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-0/qvel", + "shape": [ + 511, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qpos", + "shape": [ + 511, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/mobile_panda-1/qvel", + "shape": [ + 511, + 12 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 511, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 511, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_0/rgb", + "shape": [ + 511, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera_1/rgb", + "shape": [ + 511, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 511, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "95c5c7032de3d30edff4ad4f550a6282c3be129c927fbf73508411eba1ee996f", + "source_sha256": "c521cb43e1c2fa271924c68bb531283f8f81cb7af60f09d5df7db7c9a54f41bc", + "view_sha256": "088a4c559d4a063526cfc7ef74b3763d98a0141e8a83db6b2691c10f2e5f3c61" + } + ] +} diff --git a/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/environment.lock b/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/environment.lock new file mode 100644 index 0000000000000000000000000000000000000000..b2237f47d93aa4c3efad07728ae6acd137912d6d --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/environment.lock @@ -0,0 +1,249 @@ +absl-py==2.4.0 +accelerate==1.13.0 +addict==2.4.0 +aiohappyeyeballs==2.6.1 +aiohttp==3.13.5 +aiosignal==1.4.0 +annotated-types==0.7.0 +anyio==4.13.0 +anytree==2.13.0 +asttokens==3.0.1 +async-timeout==5.0.1 +attrs==26.1.0 +av==15.1.0 +blinker==1.9.0 +casadi==3.7.2 +certifi==2026.4.22 +cffi==2.0.0 +charset-normalizer==3.4.7 +click==8.3.3 +cloudpickle==3.1.2 +cmake==4.1.3 +coacd==1.0.11 +colorama==0.4.6 +colorlog==6.10.1 +comm==0.2.3 +ConfigArgParse==1.7.5 +contourpy==1.3.2 +cuda-bindings==12.9.4 +cuda-pathfinder==1.5.4 +cycler==0.12.1 +dacite==1.9.2 +dash==4.1.0 +dataclasses-json==0.6.7 +datasets==4.8.5 +decorator==5.2.1 +deepdiff==8.6.2 +Deprecated==1.3.1 +diffusers==0.35.2 +dill==0.4.1 +docstring_parser==0.18.0 +draccus==0.10.0 +einops==0.8.2 +embreex==4.4.0 +etils==1.13.0 +evdev==1.9.3 +exceptiongroup==1.3.1 +executing==2.2.1 +Farama-Notifications==0.0.6 +fast_simplification==0.1.13 +fastjsonschema==2.21.2 +filelock==3.29.0 +Flask==3.1.3 +fonttools==4.63.0 +freetype-py==2.5.1 +frozenlist==1.8.0 +fsspec==2026.2.0 +genesis-world @ file:///data/gck/genesis-world +git-filter-repo==2.47.0 +gitdb==4.0.12 +GitPython==3.1.50 +glfw==2.10.0 +gs-madrona==0.0.5 +gstaichi==3.3.0 +gym==0.26.2 +gym-notices==0.1.0 +gymnasium==1.3.0 +h11==0.16.0 +h5py==3.16.0 +hf-xet==1.5.0 +hf_transfer==0.1.9 +httpcore==1.0.9 +httpx==0.28.1 +huggingface-hub==0.35.3 +idna==3.15 +ImageIO==2.37.3 +imageio-ffmpeg==0.6.0 +importlib_metadata==9.0.0 +importlib_resources==7.1.0 +inquirerpy==0.3.4 +ipython==8.39.0 +ipywidgets==8.1.8 +itsdangerous==2.2.0 +jedi==0.20.0 +Jinja2==3.1.6 +joblib==1.5.3 +jsonlines==4.0.0 +jsonschema==4.26.0 +jsonschema-specifications==2025.9.1 +jupyter_core==5.9.1 +jupyterlab_widgets==3.0.16 +kiwisolver==1.5.0 +lazy-loader==0.5 +lerobot==0.4.4 +libigl==2.6.2 +llvmlite==0.47.0 +loguru==0.7.3 +lxml==6.1.0 +manifold3d==3.4.1 +-e git+ssh://git@github.com/HeegerGao/maniladder.git@f6eed17496816bb41ce484f2d7580990a908d3e6#egg=maniladder +mapbox_earcut==2.0.0 +markdown-it-py==4.2.0 +MarkupSafe==3.0.3 +marshmallow==3.26.2 +matplotlib==3.10.9 +matplotlib-inline==0.2.2 +mdurl==0.1.2 +mergedeep==1.3.4 +moviepy==2.2.1 +mpmath==1.3.0 +msgspec==0.21.1 +mujoco==3.8.1 +multidict==6.7.1 +multiprocess==0.70.19 +mypy_extensions==1.1.0 +nbformat==5.10.4 +nest-asyncio==1.6.0 +networkx==3.4.2 +ninja==1.13.0 +nlopt==2.10.0 +numba==0.65.1 +numpy @ file:///home/conda/feedstock_root/build_artifacts/numpy_1747544640217/work/dist/numpy-2.2.6-cp310-cp310-linux_x86_64.whl#sha256=d6d964caeef85d00073d27cd62b46883d275b3d8162f723f0fcabbd0b3cc3f9d +nvidia-cublas-cu12==12.8.4.1 +nvidia-cuda-cupti-cu12==12.8.90 +nvidia-cuda-nvrtc-cu12==12.8.93 +nvidia-cuda-runtime-cu12==12.8.90 +nvidia-cudnn-cu12==9.10.2.21 +nvidia-cufft-cu12==11.3.3.83 +nvidia-cufile-cu12==1.13.1.3 +nvidia-curand-cu12==10.3.9.90 +nvidia-cusolver-cu12==11.7.3.90 +nvidia-cusparse-cu12==12.5.8.93 +nvidia-cusparselt-cu12==0.7.1 +nvidia-nccl-cu12==2.27.5 +nvidia-nvjitlink-cu12==12.8.93 +nvidia-nvshmem-cu12==3.4.5 +nvidia-nvtx-cu12==12.8.90 +open3d==0.19.0 +opencv-python==4.13.0.92 +opencv-python-headless==4.12.0.88 +OpenEXR==3.4.11 +orderly-set==5.5.0 +packaging==25.0 +pandas==2.3.3 +parso==0.8.7 +pexpect==4.9.0 +pfzy==0.3.4 +pillow==11.3.0 +pin==4.0.0 +pip @ file:///home/task_177498883471825/croot/pip_1774988882575/work +platformdirs==4.9.6 +plotly==5.24.1 +polyscope==2.6.1 +proglog==0.1.12 +prompt_toolkit==3.0.52 +propcache==0.5.2 +protobuf==6.33.6 +psutil==7.2.2 +ptyprocess==0.7.0 +pure_eval==0.2.3 +py-cpuinfo==9.0.0 +py-spy==0.4.2 +pyarrow==24.0.0 +pycollada==0.9.3 +pycparser==3.0 +pydantic==2.13.4 +pydantic_core==2.46.4 +PyGEL3D==0.6.1 +pyglet==2.1.14 +pygltflib==1.16.0 +Pygments==2.20.0 +pymeshlab==2025.7.post1 +pynput==1.8.2 +PyOpenGL==3.1.10 +pyparsing==3.3.2 +pyperclip==1.11.0 +PyQt6==6.11.0 +PyQt6-Qt6==6.11.0 +PyQt6_sip==13.11.1 +pyquaternion==0.9.9 +pyserial==3.5 +pysplashsurf==0.12.0.2 +python-dateutil==2.9.0.post0 +python-dotenv==1.2.2 +python-xlib==0.33 +pytransform3d==3.15.0 +pytz==2026.2 +pyuipc @ file:///tmp/claude-1005/-mnt4-gck-maniladder/9f005e67-04f6-4368-bd0e-9f40896c7dbf/scratchpad/pyuipc_dl/pyuipc-0.0.25-cp310-cp310-manylinux_2_34_x86_64.whl#sha256=76ff13554e1971ea4401db2c875369cf32352ae3a5a4c398c45193231b5cbf00 +PyYAML==6.0.3 +pyyaml-include==1.4.1 +referencing==0.37.0 +regex==2026.5.9 +requests==2.34.2 +rerun-sdk==0.26.2 +retrying==1.4.2 +rich==14.3.4 +rpds-py==0.30.0 +rtree==1.4.1 +safetensors==0.7.0 +sapien==3.0.3 +scikit-image==0.25.2 +scikit-learn==1.7.2 +scipy @ file:///home/conda/feedstock_root/build_artifacts/scipy-split_1739790642651/work/dist/scipy-1.15.2-cp310-cp310-linux_x86_64.whl#sha256=9e52bad6c3294d1a5b04a13632118ca2157130603c6c018c2d710162b223b27e +sentry-sdk==2.60.0 +setuptools==80.10.2 +shapely==2.1.2 +six==1.17.0 +smmap==5.0.3 +stack-data==0.6.3 +svg.path==7.0 +sympy==1.14.0 +tenacity==9.1.4 +termcolor==3.3.0 +tetgen==0.8.4 +threadpoolctl==3.6.0 +tifffile==2025.5.10 +timm==1.0.27 +toml==0.10.2 +torch==2.10.0 +torchaudio==2.11.0 +torchcodec==0.10.0 +torchvision==0.25.0 +tqdm==4.67.3 +traitlets==5.15.0 +transforms3d==0.4.2 +trimesh==4.12.2 +triton==3.6.0 +typeguard==4.5.2 +typing-inspect==0.9.0 +typing-inspection==0.4.2 +typing_extensions==4.15.0 +tyro==1.0.13 +tzdata==2026.2 +urllib3==2.7.0 +vhacdx==0.0.10 +viser==1.0.27 +vtk==9.6.1 +wandb==0.24.2 +wcwidth==0.7.0 +websockets==16.0 +Werkzeug==3.1.8 +wheel==0.46.3 +widgetsnbextension==4.0.15 +wrapt==2.1.2 +xxhash==3.7.0 +yarl==1.23.0 +yourdfpy==0.0.60 +z3-solver==4.16.0.0 +zipp==3.23.1 +zstandard==0.25.0 diff --git a/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/findings.md b/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/findings.md new file mode 100644 index 0000000000000000000000000000000000000000..74b1ee2e6e2d8a68ef8ca2347d0172df0beee6a3 --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/findings.md @@ -0,0 +1,33 @@ +# Findings + +Episode 1: harness failure. execute_actions returns a steps list, unlike next_episode. Stale step id caused cached first action to repeat through step 149; step 150 was a measured hold. Interrupted pending RPC was not replayed. Final observation preserved. No success claimed. Corrected result unpacking for episode 2. + +Episode 2: corrected feedback reached handle approach by step 50 (phase 0.86). Short diagnostic stopped at step 71; native success false. Saved emitted actions through last fully received step; one interrupted pending call is not replayed and latest observation establishes final step. Full-sequence independent rehearsal scheduled as episode 3. + +Episode 3: independent valid v0 hash d82f7dd692e1394ed26dde77d755b0ab86f2aed8789e0ab6ca55fdb92732732a, native success false at horizon 650. Final closed door, nearest demo frames ~71 phase1.106. Robot1 yaw stalled at -0.125. Likely blended retrieval fixed point. v1 narrows backward window, adds monotonic phase minimum increment .004, and two-frame action lookahead with discrete gripper preserved. + +Episode 4: v1 progressed to phase1.8 at step180, robot1 rotated and both bases moved, but door remained closed. Native success false. Handle localization/grasp failed despite timing fix. v2 adds non-neural affine top-camera rectangle calibration from all20 authorized initial images to demonstrated handle base targets, with max in-sample errors 7.9mm/4.9mm. Scene-relative base reference shifts ramp in during approach and out during table transfer. Calibration is approximate and unvalidated until episode5. + +Episode5 v2: finger gap ~9.7mm at step87, door visibly opens by150; at220 door widely open, robot1 against door, robot0 gripper released (~.04m), phase2.098. Native false (short diagnostic, no object placement). Images initial/50/100/150/200/final saved; action and progress logs preserved. Scene calibration appears useful but only one live trial. + +Episode6 v2: repeat handle gap9.7mm, visible door opening150 and support250. Object grasp failed: phase3.16 at350 and fingers~0 by360, versus demonstrated object gap17-18mm. Reached410 without placement; native false. v3 adds bounded empirical pose correction at phases2.05..3.5 using least-squares maps from 4-step demonstrated arm-joint differences to mean EE actions in local phase neighborhoods. No neural fitting or simulator used. + +Episode7 v3: door open by200. Saved front frame200 has13 blue pixels median(x,y)=(162,92), upper shelf. Controller nevertheless reached lower-shelf joint posture at360 (joint4=.593,joint7=-1.477), fingers~0, native false. Local pose correction alone cannot resolve object branch. v4 gates demonstrations by front-camera blue-object shelf classification with >=3 votes during phase1.75..2.5; gate starts2.08. + +Episode9 v4: door visibly open at200, lower shelf selected, fingers close to zero at350..404. Missed grasp; stopped after404. v5 uses observed blue-pixel centroid and calibrated fridge location in the existing D20 within-shelf linear target map; clamps to demonstrated pose envelope and smoothly adjusts object-phase base and joint references. + +Episode10 v5: door open at200, lower-shelf reach and adjusted target, fingers zero by331. No successful grasp. v6 tests 25-step preclosure pose settling with bounded empirical action correction and demonstrated base target. + +Episode11 v6: upper-shelf classification. Settling active at350; finger gap about16.97mm at395..400 matches demonstrated object contact. Door remains open. Short diagnostic ended400, so transfer/placement not tested and success not claimed. + +Episode12 v6: handle gap9.7mm through130, empty fingers150, door fully closed by200. Stopped early; grasp stage not meaningfully testable. v7 advances robot1 demonstrated support-base placement by .18 phase during1.35..1.99 to catch the door before handle slip. + +Episode13 v7: door stays open at200, upper-shelf reach, empty closure. Full qpos log shows substantial arm movement after settling ends. v8 fixes a post-contact demonstrated pose, servos it through open/closed dwell, and retries once 25mm deeper when achieved finger gap<4mm. Extra dwell is bounded to85 actions and horizon remains650. + +Episode14 v8: lower grasp and25mm deeper retry both empty. Pose actually settled. Direct authorized demo07 frame337 front/wrist/top comparison saved grasp_compare14.jpg. Reconstructed visible target predicted basex=-.778 but within-shelf absolute clamp forced-.736; even retry stopped-.761. v9 preserves scene-dependent base prediction within overall demonstrated base limits, clamps only arm joints to shelf envelope. + +Episode15 v9: open door and upper shelf; fixed closure and retry empty. Table release reached600, no object visible on table. v10 delays object target commitment tophase2.25 and limits centroid votes tophase>1.98 to reduce opening occlusion. + +Episode16 v10: closed door visible at200, no object classification through322. Earlier support reduces neither all handle slips nor all reclosures. Stopped failed diagnostic. Final candidate retains observation-conditioned localization, fixed-pose grasp dwell, one bounded retry, and late centroid commitment. No successful placement established in development. Episodes17-20 reserved for exact independent rehearsals with no intervention. + +Episode8 is charged in the surviving budget; its saved trace ends at29 and does not establish completion. All demonstrations and exploration evidence belong only to this task. Native results, camera evidence and exact rehearsal hashes are retained in /workspace/exploration. diff --git a/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/freeze_manifest.json b/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/freeze_manifest.json new file mode 100644 index 0000000000000000000000000000000000000000..f5a91aaf2c570cc0f3288c18668e24479833a183 --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/freeze_manifest.json @@ -0,0 +1,97 @@ +{ + "files": { + "__pycache__/build_exemplars.cpython-310.pyc": "ec7fae4b9117ca6e37b5b82f562ac2753c2cf2daff5baabc53d37f9a97833c03", + "__pycache__/controller.cpython-310.pyc": "3ff6b9f6257edfeb03f900456e7bcb18cafc9789c703b2824a98cfbe538fe44a", + "__pycache__/synthetic_checks.cpython-310.pyc": "8629ad1666724bb08060b61f740da0cf8d42f38d2e20d474d06fabd64ebaa9ba", + "build_exemplars.py": "c13f164532f7e230b3c440090a0fb1708ea7a6c5eb1855aa032e84404754d0c3", + "compile_provenance.json": "484e14d0a2b4ed0daee85b814ebd6882aa06e2f131e655af64b9077911e64f28", + "controller.py": "a362dab1ea5bd9c926588bc1ac88843970daf10a35925066d16b87e7348561b8", + "demo_manifest.json": "e77ca8643780c7e621bb6ef3ee7855c2351b4ea765e012dcfbdc39ecffd9fa31", + "demonstrations_readonly/demo_00.h5": "cc40ac4d8abf2f55c384f8947724515346f89248ad80ba4f389cab3660083f15", + "demonstrations_readonly/demo_01.h5": "445d84eb102d8bfd1e08a38d5d6f1467612d0c31f4c1cb0408c3ce25b845696d", + "demonstrations_readonly/demo_02.h5": "e5527220fd2a0c619d33bd85f88d2dd313316a7c63e4662d560e9c3e4784f17a", + "demonstrations_readonly/demo_03.h5": "8e1f50be23ec6d10211744dd4b2555ccdaf2a60454ce5b4c17a032b4597fac83", + "demonstrations_readonly/demo_04.h5": "3c7aa820c44510c28d19adce767a99b96a639f3c9929731ae3671a1b913652c1", + "demonstrations_readonly/demo_05.h5": "c89a9bfe5ab6a92f07f5132aab3983e881b01c91dd532ee00cf15c6f94e0d47a", + "demonstrations_readonly/demo_06.h5": "43166fb59ea76178cc351872b56244a88cd5dee83611a731cc007339aa255912", + "demonstrations_readonly/demo_07.h5": "80b0aeb63dd303df8243d9ebb6d6d92752b531f77ec25cb296241b0789337cb9", + "demonstrations_readonly/demo_08.h5": "b97b9cf77ef22609c847f8284ca9cbc5e840579f94c0c2b3dec16f01bfa8349d", + "demonstrations_readonly/demo_09.h5": "ce810ca9a42d66cd330482f92d797abe702f14ce0079bf7b34ac5d420b7e74a8", + "demonstrations_readonly/demo_10.h5": "34e98d7318411c0fe3e7ff25641ab11a8b4a7aa846ad816bc45b1ccffa8539a8", + "demonstrations_readonly/demo_11.h5": "284d69f5db81e912b0f9811cd39e9bcf656cc989cab370896673a39e00b246a8", + "demonstrations_readonly/demo_12.h5": "37a3fde2705304fb0c36455d4bd9d627772e88b643f019eaf6fd155e851cacf9", + "demonstrations_readonly/demo_13.h5": "727cb43c0be8d0f8d206b81889072dd3e60d82e2b33295fd4a2b969a7a34e920", + "demonstrations_readonly/demo_14.h5": "07daca8ba882035ec8fcf206bdf44a7ba73a3a08b0e4c6cc62fa62ff88686d91", + "demonstrations_readonly/demo_15.h5": "70fe443ca31d11aead05ee2f3c0f1bb38e1dd841f7fc8cb35545387fdeb984aa", + "demonstrations_readonly/demo_16.h5": "5df554e9f2c1a00dd4f13ebe2b2d86d7740771328c78ddc34ded95d028e7a0ed", + "demonstrations_readonly/demo_17.h5": "f2e5cca4551d7fe9900cdb4629cc0dca4281adf9e7271d33189e168f6cf46400", + "demonstrations_readonly/demo_18.h5": "6f0b695c5b97cdf0380232acbd6546435628096dba16d61325329abdf0da91d4", + "demonstrations_readonly/demo_19.h5": "088a4c559d4a063526cfc7ef74b3763d98a0141e8a83db6b2691c10f2e5f3c61", + "environment.lock": "f9f11f093744865020243315494d48c69e38ff9e67783e7cf5f0a1e5f22b34aa", + "exemplars.npz": "36b80d5bcb6923bbb1f70e009c832d979a58c93f8822f5af33d59946af26376d", + "findings.md": "39df848489d4fc0e9614bf0ced683e571260f7a48a735b3c985775db4cc3755e", + "geometry.npz": "d8c29d8ba2b2b79bfcbb924dafa41ec1442a5bd71340119070fb063e2eb5f4c5", + "handoff.md": "3af8fe251a5a06ed4f917aafbd3d8cb55ae7f8dc873610b97b32dbc6d1545c00", + "model_tool_manifest.yaml": "3077cd56e46759bac7ac6a1eaec03b437a6f2367dd9e778857c0a558a130703a", + "object_geometry.npz": "62a9ed8b690ef2130c9271d0846f88904d0e5e2544491efe49c853fd6dfb5f8c", + "policy_runner.py": "cd8a30fc763583fb9bf6570414f01d56aba16241c733fc0cdfdfab0f8f27270e", + "pose_maps.npz": "b165fcd2ff88678acac5be09e968ade3000c6f061f95d2cde4b7fcbc2fff307f", + "skills.md": "2b778d7036ca5f3d5f4e1b1de7338662f3b53db69495cbb183d6ff2e32bfb048", + "synthetic_checks.py": "f1f0528142a2884b8bd56f955d89564d05165d1fae1c59ef24e84defad957eb7", + "validation.json": "4c0b78f171eae499349e5e7b8c24f6dc4882f13304bd0bf9f4e34efe3fb838c9", + "worker_api.py": "88cca5fa5c1c9570ca2bd90e8848f67c09224fa498d94e63634ad191e913c41e" + }, + "bundle_hash": "269a5e1e1869addcfa252db7b879e01734b8bd299cda6e38ef811d5765edce67", + "exploration_ledger_hash": "379c4361a4217351475b2a3309973edcd5fa89374ef96be3aca9beb7784fb05f", + "entrypoint": "controller.reset_episode(); controller.act(obs)", + "selection": { + "rule": "exact-version success rate, valid rehearsal count, recency", + "rehearsals": [ + { + "bundle_hash": "d82f7dd692e1394ed26dde77d755b0ab86f2aed8789e0ab6ca55fdb92732732a", + "episode": 3, + "independent": true, + "score_source": "native_step_feedback", + "status": "finished", + "success": false, + "valid": true + }, + { + "episode": 17, + "bundle_hash": "269a5e1e1869addcfa252db7b879e01734b8bd299cda6e38ef811d5765edce67", + "independent": true, + "valid": true, + "status": "finished", + "success": false, + "score_source": "native_step_feedback" + }, + { + "episode": 18, + "bundle_hash": "269a5e1e1869addcfa252db7b879e01734b8bd299cda6e38ef811d5765edce67", + "independent": true, + "valid": true, + "status": "finished", + "success": false, + "score_source": "native_step_feedback" + }, + { + "episode": 19, + "bundle_hash": "269a5e1e1869addcfa252db7b879e01734b8bd299cda6e38ef811d5765edce67", + "independent": true, + "valid": true, + "status": "finished", + "success": false, + "score_source": "native_step_feedback" + }, + { + "episode": 20, + "bundle_hash": "269a5e1e1869addcfa252db7b879e01734b8bd299cda6e38ef811d5765edce67", + "independent": true, + "valid": true, + "status": "finished", + "success": false, + "score_source": "native_step_feedback" + } + ] + } +} diff --git a/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/handoff.md b/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/handoff.md new file mode 100644 index 0000000000000000000000000000000000000000..d17c7d114c09eeae35cb307a7f25767fe4a7cd37 --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/handoff.md @@ -0,0 +1,13 @@ +# Handoff + +Authorized D20-E20 continuation for DualArmOpenFridge-v1. See findings.md and /workspace/exploration for actual episode evidence. Earlier offline-only status in historical notes is superseded by the exploration ledger. + +controller.py exposes reset_episode() and act(obs). The runner supplies legal five-camera RGB, flattened proprioception paths, and step_id after its charged hold. Runtime uses only NumPy, OpenCV, pathlib and adjacent exemplars.npz, geometry.npz, object_geometry.npz, pose_maps.npz. No network, simulator, model agent, neural training or extra demonstration data is required. Each action is a finite 20-vector in contract order; None requests termination. Native horizon includes the runner hold. + +The controller localizes the fridge rectangle, retrieves compatible demonstrated observations/actions and selects an object shelf from visible blue pixels. Pose corrections are bounded empirical linear maps. These are approximations; object localization, grasp, recovery and final support remain unverified. Missing imagery holds measured positions. Native base limits are unspecified; demonstrated base envelopes constrain targets. + +The runner must select a completed independent exact rehearsal by the prescribed ranking. Rehearsal native sparse success is recorded only when supplied. Otherwise apply /workspace/exploration/visible_rule.md: ambiguous placement is false. Do not claim success based on terminal posture alone. + +Development is complete through slot16. Slots17-20 will independently rehearse this exact bundle. The authoritative outcomes and selected hash are in the external exploration audit and API freeze return; this file does not anticipate success. Do not modify candidate behavior after its final rehearsal. The budget must end at exactly20 and freeze must be called. + +Fixed-pose closure now includes35 open settling actions then15 closure actions, with one35-action retry25mm deeper if the achieved gap is below4mm. This can consume85 actions and is subordinate to the650-step horizon. Earlier support and refined target coordinates remain imperfect: failed door opening and empty grasps occurred during development. diff --git a/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/model_tool_manifest.yaml b/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/model_tool_manifest.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b40535b316a68b4024bfdd7d4276740b501e637d --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/model_tool_manifest.yaml @@ -0,0 +1,66 @@ +{ + "stage": "final_candidate_for_independent_rehearsals", + "status": "development_not_frozen", + "task": "DualArmOpenFridge-v1", + "worker": "Agent-D20-E20-Compiled", + "python": "3.10.20", + "runtime_dependencies": { + "numpy": "2.2.6", + "opencv": "4.12.0", + "pillow": "not used by controller; exploration image evidence only" + }, + "build_dependencies": { + "h5py": "3.16.0", + "worker_api": "/worker_api.py standalone API.read_demo" + }, + "available_but_not_used_for_computation": { + "scipy": "1.15.3", + "torch": "2.10.0" + }, + "actual_tools": [ + "functions.exec / exec_command: local scripts and file operations", + "functions.exec / view_image: legal image contact sheets", + "worker_api.API.read_demo: local authorized HDF5 read only", + "NumPy: action statistics, descriptors, exemplar retrieval, synthetic checks", + "OpenCV: image resize, contact-sheet annotation and encoding", + "h5py: used internally by API.read_demo", + "Python standard library: importlib, json, pathlib, hashlib, platform, metadata", + "worker_api.API budget_status/next_episode/latest_observation/execute_actions/finish_episode/rehearse: only trusted environment interface" + ], + "pretrained_weight_references": [], + "coding_model": { + "identity": "Codex; exact provider model/weight revision not exposed", + "weights_modified": false + }, + "neural_finetuning": false, + "external_downloads": [], + "exploration_episodes": "See API budget and exploration audit; counts mutable during development", + "internet": { + "used": false, + "restriction": "audited provider proxy only", + "availability_tested": false + }, + "provenance": { + "/task_contract.json": "20baa6869a232d3c4fafd9450e0a0e135d8ac1793ddc9f2a021561481d8887c5", + "/demo_manifest.json": "9a5319655b09742301b40a30de2a99fcc0b872c326a06c8e196b0334f204bb8e", + "/worker_api.py": "88cca5fa5c1c9570ca2bd90e8848f67c09224fa498d94e63634ad191e913c41e" + }, + "demo_source": "Exactly manifest episodes demo_00..demo_19 through API.read_demo; no other tasks/data", + "derived_artifacts": { + "exemplars.npz": "Nonparametric legal observation/action bank; not pretrained weights", + "compile_provenance.json": "Per-demo processing intervals and manifest-declared hashes", + "../evidence": "Authorized RGB contact sheets and numeric summaries", + "geometry.npz": "Non-neural affine camera geometry calibration from D20 initial images and base targets", + "pose_maps.npz": "Local least-squares action response maps from D20 joint differences", + "object_geometry.npz": "D20 shelf labels and non-neural linear grasp-target map from visible object centroid and fridge localization; no neural weights" + }, + "runner_supplies_separately": [ + "verified demo manifest", + "common environment lock" + ], + "limitations": [ + "No native finite base limits supplied", + "No pretrained model or neural fitting", + "Visible success requires unambiguous placement; native results recorded separately" + ] +} \ No newline at end of file diff --git a/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/policy_runner.py b/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/policy_runner.py new file mode 100644 index 0000000000000000000000000000000000000000..e49448d6245feb7818ae505f1061708ab97c6ead --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/policy_runner.py @@ -0,0 +1,25 @@ +"""Frozen-program entry point; no development agent and no reset capability.""" +import importlib.util +import sys + +sys.path.insert(0,'/artifact') +sys.path.insert(0,'/') +from worker_api import API + + +def main(): + spec=importlib.util.spec_from_file_location('controller','/artifact/controller.py') + module=importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + module.reset_episode() + api=API() + result=api.latest_observation() + while not (result['terminated'] or result['truncated'] or result['horizon_reached']): + obs=dict(result['observation'],step_id=result['step_id']) + action=module.act(obs) + if action is None:break + response=api.execute_actions([action]) + result=response['steps'][-1] + + +if __name__=='__main__':main() diff --git a/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/skills.md b/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/skills.md new file mode 100644 index 0000000000000000000000000000000000000000..e8a788d083eba858c6a48ae9820fe0a69c1daf7c --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/skills.md @@ -0,0 +1,11 @@ +# Controller behaviors and limits + +Approach and handle grasp use D20 RGB/proprioception retrieval with top-camera fridge localization. Door opening uses demonstrated motion, with support-base placement advanced during opening. Open-door configurations have been visibly observed in exploration; reliability is incomplete. + +Interior reach selects the shelf using visible blue pixels. A non-neural linear map from object centroid and fridge location refines base and arm references. A fixed grasp-pose servo settles before closure and holds through closure. One empty-grasp retry shifts the base25mm deeper. These are tested development heuristics, not certified capabilities. + +Transfer and release use observation-conditioned demonstrated actions. Finger-gap contact has been observed in episode11, but stable final placement has not yet been established. No official success is inferred from finger gap or posture. + +Current RGB/proprioception is used each action. Progress is bounded and observation-conditioned, with explicit grasp dwell. Missing imagery or large mismatch holds measured positions. Invalid proprioception or exhausted horizon returns None. All actions respect the650-step native horizon including the initial runner hold. + +No hidden state, seed, reset identity, external task artifact, neural fine-tuning, network or simulator is used. Required offline runtime assets are listed in model_tool_manifest.yaml. Exact independent rehearsal evidence and final selection are retained outside candidate in the task exploration audit. diff --git a/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/synthetic_checks.py b/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/synthetic_checks.py new file mode 100644 index 0000000000000000000000000000000000000000..46c2ee1c309ba009ae8e860394f825e738561a85 --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/synthetic_checks.py @@ -0,0 +1,37 @@ +"""Interface/branch checks using fabricated arrays only; no task rollout.""" +import numpy as np +import controller as c + +def fake_bank(): + q=np.zeros((128,24),np.float32);q[:,[10,11,22,23]]=.04 + a=np.zeros((128,20),np.float32);a[:,[9,19]]=1;a[:64,3]=.1;a[64:,3]=-.1 + rgb=np.zeros((128,2880),np.uint8);rgb[64:]=255 + return dict(q=q,v=np.zeros_like(q),a=a,rgb=rgb,phase=np.full(128,.1,np.float32),qscale=np.ones(24),vscale=np.ones(24),base_low=np.full(6,-10),base_high=np.full(6,10),base_step_cap=np.ones(6)) +def observation(value=0,batch=False): + p={} + for path in c.PATHS: + q=np.zeros(12,np.float32) + if path.endswith('qpos'):q[10:]=.04 + p[path]=q[None] if batch else q + return dict(rgb={k:np.full((1,240,320,3) if batch else (240,320,3),value,np.uint8) for k in c.CAMERAS},proprioception=p,instruction='synthetic interface fixture',step_id=1) + +c._bank=fake_bank();c.reset_episode();black=c.act(observation()) +assert black.shape==(20,) and black.dtype==np.float32 and np.isfinite(black).all() +assert black[3] > 0 and np.all(np.abs(black[c.NORMALIZED])<=1) +c.reset_episode();white=c.act(observation(255,True));assert white[3]<0 +# Same pixels, different measured base coordinates select different synthetic examples. +c._bank=fake_bank();c._bank['rgb'][:]=0;c._bank['q'][64:,0]=1 +c.reset_episode();near=c.act(observation());o=observation();o['proprioception'][c.PATHS[0]][0]=1 +c.reset_episode();far=c.act(o);assert near[3]>0 and far[3]<0 +# Missing RGB produces measured-position hold; malformed proprio finishes. +c.reset_episode();o=observation();o['rgb']={};o['proprioception'][c.PATHS[0]][0]=.123 +hold=c.act(o);assert np.isclose(hold[0],.123) and np.isclose(hold[9],1) +c.reset_episode();o=observation();o['proprioception'][c.PATHS[0]][0]=np.nan;assert c.act(o) is None +c.reset_episode();o=observation();o['step_id']=650;assert c.act(o) is None +c.reset_episode();first=c.act(observation());assert np.array_equal(first,c.act(observation())) +# Synthetic terminal matches exercise the stopping branch without task evidence. +c._bank=fake_bank();c._bank['phase'][:]=4.9;c.reset_episode();c._progress=4.9 +for step in range(1,9): + o=observation();o['step_id']=step;end=c.act(o) +assert end is None +print('PASS: synthetic RGB and proprio response, shapes, batching, finite normalized bounds, fallback, reset, duplicate step, horizon, terminal heuristic. No real task testing.') diff --git a/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/validation.json b/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/validation.json new file mode 100644 index 0000000000000000000000000000000000000000..7da64b72b8108865f3b2fde761a5e605f40d9cfc --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/validation.json @@ -0,0 +1,20 @@ +{ + "mode": "offline artifact integrity and synthetic checks only", + "rows": 10218, + "demonstrations": 20, + "all_arrays_finite": true, + "known_normalized_label_bounds_pass": true, + "native_base_bounds_verified": false, + "base_step_cap": [ + 0.08000001311302185, + 0.08000004291534424, + 0.2500000298023224, + 0.08000001311302185, + 0.08000004291534424, + 0.2500000298023224 + ], + "real_task_tests": 0, + "exploration_episodes": 0, + "synthetic_checks": "PASS: synthetic RGB and proprio response, shapes, batching, finite normalized bounds, fallback, reset, duplicate step, horizon, terminal heuristic. No real task testing.", + "syntax_checks": "pass" +} diff --git a/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/worker_api.py b/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/worker_api.py new file mode 100644 index 0000000000000000000000000000000000000000..ff137d1c68cb70a1549326d2d22b430c9cf4e20c --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/DualArmOpenFridge-v1/frozen/worker_api.py @@ -0,0 +1,81 @@ +"""Standalone worker client; safe to mount without the runner package.""" +import base64 +import json +import socket +import struct +import uuid +import os +from pathlib import Path + +import numpy as np + + +def array_hook(value): + if value.get('__array__') is True: + dtype=np.dtype(value['dtype']) + if dtype.kind not in 'bifu':raise ValueError('non-numeric array from service') + raw=base64.b64decode(value['data'],validate=True) + return np.frombuffer(raw,dtype=dtype).reshape(value['shape']).copy() + return value + + +class API: + def __init__(self,socket_path='/rpc/control.sock',demo_root='/demonstrations',manifest='/demo_manifest.json'): + self.socket_path=socket_path + self.demo_root=Path(demo_root) + self.manifest=Path(manifest) + + def call(self,method,arguments=None,request_id=None): + # Caller can persist a request ID before sending. Never automatically retry. + request_id=request_id or str(uuid.uuid4()) + request={'request_id':request_id,'method':method,'arguments':arguments or {}} + if os.environ.get('AGENT_E20_RPC_TOKEN'): + request['token']=os.environ['AGENT_E20_RPC_TOKEN'] + payload=json.dumps(request,allow_nan=False).encode() + if len(payload)>65536:raise ValueError('request too large') + with socket.socket(socket.AF_UNIX,socket.SOCK_STREAM) as s: + s.settimeout(1810);s.connect(self.socket_path) + s.sendall(struct.pack('!I',len(payload))+payload) + def exact(n): + chunks=[] + while n: + chunk=s.recv(min(n,1024*1024)) + if not chunk:raise RuntimeError('RPC interrupted; do not replay action with a new ID') + chunks.append(chunk);n-=len(chunk) + return b''.join(chunks) + length=struct.unpack('!I',exact(4))[0] + if length>64*1024*1024:raise RuntimeError('response too large') + result=json.loads(exact(length),object_hook=array_hook) + if not result['ok']:raise RuntimeError(result['error']) + return result['result'] + + def next_episode(self,request_id=None):return self.call('next_episode',request_id=request_id) + def latest_observation(self):return self.call('latest_observation') + def execute_actions(self,actions,request_id=None): + return self.call('execute_actions',{'actions':np.asarray(actions).tolist()},request_id) + def finish_episode(self):return self.call('finish_episode') + def budget_status(self):return self.call('budget_status') + def rehearse(self,candidate='candidate',request_id=None): + return self.call('rehearse',{'candidate':candidate},request_id) + def score_rehearsal(self,episode,visible_success,evidence): + return self.call('score_rehearsal',{'episode':episode,'visible_success':visible_success,'evidence':evidence}) + def freeze(self):return self.call('freeze') + + def read_demo(self,demo_id,start=0,stop=None,fields=None): + import h5py + manifest=json.loads(self.manifest.read_text()) + if manifest.get('status') not in ('released','released_for_offline_analysis'): + raise RuntimeError('demonstrations not released by trusted preflight') + entries={e['demo_id']:e for e in manifest['episodes']} + if demo_id not in entries:raise ValueError('unauthorized demo ID') + entry=entries[demo_id] + allowed={f['path'] for f in entry['fields']} + fields=sorted(allowed) if fields is None else fields + if not set(fields)<=allowed:raise ValueError('unauthorized demo field') + stop=entry['length']+1 if stop is None else stop + if not isinstance(start,int) or not isinstance(stop,int) or not 0<=start.09 and b[0]<-.09 + assert np.all(c.act(obs(qvalue=100))==0) + assert c.act(obs(step=500)) is None + assert c.act(obs(step=499)).shape==(22,) + broken=obs();broken['proprioception']['agent/qpos'][0]=np.nan;assert np.all(c.act(broken)==0) + assert np.all(c.act({'step_id':1})==0) + c.reset_episode();assert np.all(c.act(obs(qvalue=10))==0) and c._holding + c.reset_episode();assert not c._holding + c._BANK=real + for o in [obs(),obs(255,batch=True),obs(90,qvalue=.2)]: + a=c.act(o);assert a.shape==(22,) and a.dtype==np.float32 and np.isfinite(a).all() and np.max(abs(a))<=1 + print('PASS: syntax separate; bank structure, synthetic RGB/proprio dependence, HWC/1HWC, finite legal outputs, malformed-input hold, terminal heuristic/reset, native-budget boundary. No task testing.') +if __name__=='__main__':main() diff --git a/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/controller.py b/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/controller.py new file mode 100644 index 0000000000000000000000000000000000000000..916c5a5586d77db214643eb8531aac517f59f65e --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/controller.py @@ -0,0 +1,124 @@ +"""D20 observation-conditioned phase-aligned interpolation. No simulator.""" +from pathlib import Path +import numpy as np +import cv2 + +CAMERAS = ('front_camera', 'left_camera', 'top_camera') +_BANK = None +_SCENE = None +_holding = False +_hold_index = None + +def image_features(rgb): + features = [] + for name in CAMERAS: + im = np.asarray(rgb[name]) + if im.ndim == 4 and im.shape[0] == 1: + im = im[0] + if im.ndim != 3 or im.shape[2] != 3 or im.dtype != np.uint8: + raise ValueError('Expected uint8 HWC or 1HWC RGB') + size = (12, 16) if name == 'top_camera' else (16, 12) + features.append(cv2.resize(im, size, interpolation=cv2.INTER_AREA).reshape(-1)) + return np.concatenate(features).astype(np.float32) / 255. + +def _bank(): + global _BANK + if _BANK is None: + with np.load(Path(__file__).with_name('demo_bank.npz'), allow_pickle=False) as z: + _BANK = {k: z[k] for k in z.files} + _BANK['images'] = _BANK['images'].astype(np.float32) / 255. + return _BANK + +def reset_episode(): + """Runner owns the charged initial hold; no action is emitted here.""" + global _holding, _hold_index, _SCENE + _SCENE = None + _holding = False + _hold_index = None + +def act(obs): + """Return the single 22-wide action part in contract order, or budget stop.""" + global _holding, _hold_index + # 500 native steps includes one runner-owned hold: commands at 1..499. + if int(obs.get('step_id', 1)) >= 500: + return None + zero = np.zeros(22, dtype=np.float32) + try: + p = obs['proprioception'] + q = np.asarray(p['agent/qpos'], dtype=np.float32).reshape(-1) + v = np.asarray(p['agent/qvel'], dtype=np.float32).reshape(-1) + if q.shape != (23,) or v.shape != (23,) or not np.isfinite(q).all() or not np.isfinite(v).all(): + return zero + f = image_features(obs['rgb']) + except (KeyError, ValueError, TypeError): + return zero + b = _condition_bank(q) + # Every lookup uses present observations; no episode/seed/time matching. + qdist = np.mean(((b['q'] - q) / b['qscale'])**2, axis=1) + vdist = np.mean(((b['v'] - v) / b['vscale'])**2, axis=1) + idist = np.mean((b['images'] - f)**2, axis=1) + dist = .65*qdist + .05*np.minimum(vdist, 4.) + .30*idist/(.12**2) + terminals = np.flatnonzero(b['terminal']) + ti = terminals[np.argmin(dist[terminals])] + qerr = float(np.sqrt(np.mean((b['q'][ti] - q)**2))) + ierr = float(np.sqrt(idist[ti])) + if _holding: + h = _hold_index + # Loss of the observed configuration allows retrieval to resume. + if np.sqrt(np.mean((b['q'][h]-q)**2)) < .12 and np.sqrt(idist[h]) < .12: + return zero + _holding, _hold_index = False, None + if qerr < .04 and np.max(np.abs(b['q'][ti,:7]-q[:7])) < .10 and ierr < .06: + _holding, _hold_index = True, int(ti) + return zero # A stability attempt, never a verified success signal. + k = min(3, len(dist)) + ix = np.argpartition(dist, k-1)[:k] + nearest = float(np.min(dist[ix])) + if nearest > 3.: + return zero # Unfamiliar observations: do not extrapolate a trajectory. + weights = np.exp(-(dist[ix]-nearest)/.025) + action = np.sum(b['actions'][ix]*weights[:,None], axis=0)/weights.sum() + # Lower magnitude outside demonstrated support; heuristic, unvalidated. + action *= min(1., 1./max(1., nearest)) + # One robot part: xyz, root-aligned rotation, 16 native hand joint deltas. + return np.clip(action, -1., 1.).astype(np.float32) + + +def _condition_bank(q): + """Interpolate neighboring initial robot configurations; retrieve by live state. + + This empirical conditioning assumes initial arm angle co-varies with scene + layout as observed in the authorized demonstrations. It is not a seed ID. + Phase alignment is built from action transitions, not a live frame schedule. + """ + global _SCENE + if _SCENE is not None: + return _SCENE + b = _bank() + ends = np.flatnonzero(b['terminal']) + starts = np.r_[0, ends[:-1]+1] + angles = b['q'][starts, 0] + order = np.argsort(angles) + where = int(np.searchsorted(angles[order], q[0])) + if where == 0 or where == len(order): + _SCENE = b + return b + lo, hi = order[where-1], order[where] + mix = float((q[0]-angles[lo])/(angles[hi]-angles[lo])) + common = np.array([0,140,204,244,328]) + aligned = [] + for d in (lo,hi): + start, end = starts[d], ends[d] + a = b['actions'][start:end] + down = np.flatnonzero(a[:,2] < -.02)[0] + close = np.flatnonzero(np.max(np.abs(a[:,6:]),axis=1) > .02)[0] + up = np.flatnonzero(a[:,2] > .02)[0] + loc = np.interp(np.arange(329),common,[0,down,close,up,end-start]) + i = np.floor(loc).astype(int);j = np.minimum(i+1,end-start) + w = (loc-i).astype(np.float32)[:,None] + aligned.append({key:(1-w)*b[key][start+i]+w*b[key][start+j] + for key in ('q','v','images','actions')}) + _SCENE = {key:(1-mix)*aligned[0][key]+mix*aligned[1][key] + for key in ('q','v','images','actions')} + _SCENE.update(qscale=b['qscale'],vscale=b['vscale'],terminal=np.arange(329)==328) + return _SCENE diff --git a/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/demo_manifest.json b/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/demo_manifest.json new file mode 100644 index 0000000000000000000000000000000000000000..bb6ef8589c9c19baa15cb9087b38fd41afd0f77c --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/demo_manifest.json @@ -0,0 +1,1488 @@ +{ + "task_id": "RopePalmCageHoldDex-v1", + "status": "released", + "selection_rule": "prefer existing pinned D20, otherwise numeric trajectory ID sort before reading data", + "lineage_status": "pinned_comparator", + "episodes": [ + { + "demo_id": "demo_00", + "file": "demo_00.h5", + "length": 286, + "fields": [ + { + "path": "actions", + "shape": [ + 286, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 287, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 287, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 287, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 287, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 287, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 287, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "dc1fa7dd45b3c83a72256d1224835e9bb6dff52c77e70a089a35fb6c749caac3", + "source_sha256": "15ad0e6dd43a20920406627e17c579bc4ceaf96dcaa1be37ed6b963f587c7594", + "view_sha256": "855f757c50a8db43a13a83a982fde01f2d44e7160f6abc1b8f1be3e3759d44ea" + }, + { + "demo_id": "demo_01", + "file": "demo_01.h5", + "length": 293, + "fields": [ + { + "path": "actions", + "shape": [ + 293, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 294, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 294, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 294, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 294, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 294, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 294, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "685e4dbd75654a86df860a8ff13f9ce401bab80626c230bf3a6f63b0a2b16ca3", + "source_sha256": "a73669a18efbc6d023b4fa203ade55d62152813c1c64874f1fce791beec7742d", + "view_sha256": "bab25a636b9d182ccf860daa17968a199a379f22ba18668bc86b93b487b4044b" + }, + { + "demo_id": "demo_02", + "file": "demo_02.h5", + "length": 328, + "fields": [ + { + "path": "actions", + "shape": [ + 328, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 329, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 329, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 329, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 329, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 329, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 329, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "91fa666d82359f00d1f8a46efc7eef27c69ee9e523a33ffb9c95613145423aaa", + "source_sha256": "cb579c0907c5ba113ea4a67d4dffce9f37556d943d0b393448bc69a5a4973199", + "view_sha256": "6a497dadb9bd41465d8c9742377c78ea065a5f8ca8f43b32225456c1849cbe7a" + }, + { + "demo_id": "demo_03", + "file": "demo_03.h5", + "length": 328, + "fields": [ + { + "path": "actions", + "shape": [ + 328, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 329, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 329, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 329, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 329, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 329, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 329, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "5820c8151c57caebe60fa97d60919dce12f805a1daa5cf6cbeb8c40735cc2c83", + "source_sha256": "508f81dd8365f052712d273444761fd5799299c0ae3ac6f199a65ef85ee17460", + "view_sha256": "ab914feab9b19e5d4946d44d7dd9f172ab5f434131d84292204a4974f49e8ace" + }, + { + "demo_id": "demo_04", + "file": "demo_04.h5", + "length": 326, + "fields": [ + { + "path": "actions", + "shape": [ + 326, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 327, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 327, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 327, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 327, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 327, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 327, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "47698160ed2b365c0d0eb7db5ffeac3da1ee527f753dac4628a38009507d3f32", + "source_sha256": "d184fbb234ca3af5763341a08fad3a63a9a5f7ee8f55ba011a86fd424b264ce9", + "view_sha256": "f7d0336b0bb7013d5d21104ab4a304725c789894a8b8340a5dcfd723790f11b4" + }, + { + "demo_id": "demo_05", + "file": "demo_05.h5", + "length": 314, + "fields": [ + { + "path": "actions", + "shape": [ + 314, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 315, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 315, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 315, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 315, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 315, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 315, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "1424e6a0c69d8f60ae1046481ce47109bcbad202976e2423fe1e77b527a4dead", + "source_sha256": "5dbb1fb8a5131203d35dc7ac146e26118e97b47fb1a54d2f65d2d39a079a4203", + "view_sha256": "98d2b9678383d0885e9c45f8e3b1dbcb5e6eb7c251c3bfb62a3c3b3b1e4a288b" + }, + { + "demo_id": "demo_06", + "file": "demo_06.h5", + "length": 326, + "fields": [ + { + "path": "actions", + "shape": [ + 326, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 327, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 327, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 327, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 327, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 327, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 327, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "49811319582b31d6537368d3a880a6b667b071a2e9b26d076b150a17145653b5", + "source_sha256": "a7b3a83a285ee2f3acb6cbfc7ba6f0ed1088bd72a158d6ca72bce14f6b1afc2b", + "view_sha256": "5ea7ce45fbbe4140cbe5cdea09248012da127b989a1564738246b9216142af50" + }, + { + "demo_id": "demo_07", + "file": "demo_07.h5", + "length": 297, + "fields": [ + { + "path": "actions", + "shape": [ + 297, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 298, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 298, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 298, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 298, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 298, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 298, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "205a60102e891727192c3788fbad3dc96ade3549896a84379a802b084e1310b1", + "source_sha256": "36cdcbb2f9b4b00d1f0a1746ae4bd8a856525ba4a31d8aee64af4e1633c240d2", + "view_sha256": "eed21a1500e954cd1ffee97544a5d9c0fbb2427152fe335398c7b523adf1f644" + }, + { + "demo_id": "demo_08", + "file": "demo_08.h5", + "length": 294, + "fields": [ + { + "path": "actions", + "shape": [ + 294, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 295, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 295, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 295, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 295, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 295, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 295, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "76a6a7bf2dae97991ab3fd7b7892b12d8e8a297eeb5e8b5444e0af092f0a3ca7", + "source_sha256": "8b127766c1c883c7ab0957c373df704cfd3a2214f3ce7b6f0254e630ac14cc7e", + "view_sha256": "eaa224bcd93df6eb40cb4141faa9f667e22d6b2f47e3f88399a77aa9b675bc6b" + }, + { + "demo_id": "demo_09", + "file": "demo_09.h5", + "length": 328, + "fields": [ + { + "path": "actions", + "shape": [ + 328, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 329, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 329, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 329, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 329, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 329, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 329, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "ac52d6d25fbeb9571534d18ba7d75e626d18cf6357c7370b210eee994996cb0e", + "source_sha256": "321689fc4fb0ba216d8a5cfd51920923e98cf0810817a12003eb5378f9174395", + "view_sha256": "cc779251fcddb2e6458e1062fab9ab816be2af2336292cba876bcb24b2a3d882" + }, + { + "demo_id": "demo_10", + "file": "demo_10.h5", + "length": 294, + "fields": [ + { + "path": "actions", + "shape": [ + 294, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 295, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 295, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 295, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 295, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 295, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 295, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "5915c906b5f07ef52bcede823ef5115d90c05c1fbcf077cba32db56407398f1a", + "source_sha256": "aabc360d9cb112cb7e7066cc9258961138465d4008909f967ab4a6b22f6773a5", + "view_sha256": "4afa1a6414be5d1a34e231bc8c093b42c22be209a82d41869e763d8960be8bcc" + }, + { + "demo_id": "demo_11", + "file": "demo_11.h5", + "length": 308, + "fields": [ + { + "path": "actions", + "shape": [ + 308, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 309, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 309, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 309, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 309, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 309, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 309, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "b4d622226a2605fbf3d99bf4a2bc2b24d680c847faa9fc1b27aa7b674bbe4a99", + "source_sha256": "eda449dd8861eccff8ea689bf640bb3476f1e59fc0b6bf5a6c96c8e495ed872e", + "view_sha256": "48a495ea8ff3572ebbe2275463976149dcf0141b436b9e074a0dfc6037af87fe" + }, + { + "demo_id": "demo_12", + "file": "demo_12.h5", + "length": 299, + "fields": [ + { + "path": "actions", + "shape": [ + 299, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 300, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 300, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 300, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 300, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 300, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 300, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "c0355c1b4bb5c05f0e7af6ba1463f425a551ad097349393f27e6605796d3fd0d", + "source_sha256": "3e70c8a89f4a0071ede8c4a3fc3e4c6e1eb273a03d873be202df805e139c7223", + "view_sha256": "260e0ee5c9bd2d080e244e36781dc759063dd0d17b498d19e3e866f25b1f1679" + }, + { + "demo_id": "demo_13", + "file": "demo_13.h5", + "length": 303, + "fields": [ + { + "path": "actions", + "shape": [ + 303, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 304, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 304, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 304, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 304, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 304, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 304, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "192a3a770a2e21b571a5b799dc0f04d6a53dda43d5c222aec3989a7b0e19a799", + "source_sha256": "10f70d15bf5708a3cd18c9e2945023ca6b9c40ff404abc076bcd8985e97ded9a", + "view_sha256": "56b73a341c527160376b2b400ab4e4e7c2c2f53f17293c23027edf083e0b61cf" + }, + { + "demo_id": "demo_14", + "file": "demo_14.h5", + "length": 327, + "fields": [ + { + "path": "actions", + "shape": [ + 327, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 328, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 328, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 328, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 328, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 328, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 328, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "5d73f70ae023e6557013b3e4f0b80e5bf7715d8e13b65faeef452b7da6a6ddd6", + "source_sha256": "9dcf91eaa6f8fb76c9152638774541321cf0765b98b111024bd003399589e041", + "view_sha256": "7f0bd9e0cc2574986b4551db5b77cac82a9297d7b70d32af6f0a975490e683e3" + }, + { + "demo_id": "demo_15", + "file": "demo_15.h5", + "length": 319, + "fields": [ + { + "path": "actions", + "shape": [ + 319, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 320, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 320, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 320, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 320, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 320, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 320, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "04afcfc4e1f3365f0d0c0d5d7e714e05c76223df64fa7769354f073206bcf441", + "source_sha256": "03ea7cf49fef8400a362b91cc48c3c44961b64c1ec51f709b18b70c7b3d9ed6a", + "view_sha256": "fc99f701e7c7517f35907c910adfd8cf74cefe7a161d3f447a6f3be757e4a27d" + }, + { + "demo_id": "demo_16", + "file": "demo_16.h5", + "length": 290, + "fields": [ + { + "path": "actions", + "shape": [ + 290, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 291, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 291, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 291, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 291, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 291, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 291, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "915422700c8222bc030758c8c328f4528ab44433ee4e20acef6f43678472aadd", + "source_sha256": "204c9e8bf1074bd36b6b241eb8ea3b0f70cf5c52c59799869ffffaa227a3f12f", + "view_sha256": "6be6c23a1c57e3b663aa8b2071571ffda16d7b88c791792eaf35173f0e187055" + }, + { + "demo_id": "demo_17", + "file": "demo_17.h5", + "length": 327, + "fields": [ + { + "path": "actions", + "shape": [ + 327, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 328, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 328, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 328, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 328, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 328, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 328, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "9203082169f55204cc4d4404245bb900478d6676bc9d0adee5982a84ea1b7efb", + "source_sha256": "54c13058e131e2b216a8c06e399e9eb6a51e976fefe2c9e1f003e3e79311d42a", + "view_sha256": "c43803218b5b923679fc4ebba2edf87434d3e97c399f527e8d15ffdbb49306b7" + }, + { + "demo_id": "demo_18", + "file": "demo_18.h5", + "length": 325, + "fields": [ + { + "path": "actions", + "shape": [ + 325, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 326, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 326, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 326, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 326, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 326, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 326, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "8ea1772b41334f816fc8d4cd9fe9c249fa1978e3731935dbcfe45cbc1a6af44a", + "source_sha256": "bd9d77c5226ad20228e73ce78402d086c54d8cf27f48808f08ad2fc175e9dc17", + "view_sha256": "1e59d615819b007c81a9f5ba9af6d7a6d0fdb6c42cb0d67739452e245e6d06d8" + }, + { + "demo_id": "demo_19", + "file": "demo_19.h5", + "length": 313, + "fields": [ + { + "path": "actions", + "shape": [ + 313, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 314, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 314, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 314, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 314, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 314, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 314, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "2937d5975a9115bbf35f3175d8ee91cb37274b14365866a21c170979ebd095a7", + "source_sha256": "c78e816f01f011aeaad1143d74dbd23dba46916fa13ab891f293ffa095163ec1", + "view_sha256": "59b3c753977985699b44ccb6f3023f6f65041688425f7f90453b3bb53cd26a8c" + } + ] +} diff --git a/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/environment.lock b/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/environment.lock new file mode 100644 index 0000000000000000000000000000000000000000..b2237f47d93aa4c3efad07728ae6acd137912d6d --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/environment.lock @@ -0,0 +1,249 @@ +absl-py==2.4.0 +accelerate==1.13.0 +addict==2.4.0 +aiohappyeyeballs==2.6.1 +aiohttp==3.13.5 +aiosignal==1.4.0 +annotated-types==0.7.0 +anyio==4.13.0 +anytree==2.13.0 +asttokens==3.0.1 +async-timeout==5.0.1 +attrs==26.1.0 +av==15.1.0 +blinker==1.9.0 +casadi==3.7.2 +certifi==2026.4.22 +cffi==2.0.0 +charset-normalizer==3.4.7 +click==8.3.3 +cloudpickle==3.1.2 +cmake==4.1.3 +coacd==1.0.11 +colorama==0.4.6 +colorlog==6.10.1 +comm==0.2.3 +ConfigArgParse==1.7.5 +contourpy==1.3.2 +cuda-bindings==12.9.4 +cuda-pathfinder==1.5.4 +cycler==0.12.1 +dacite==1.9.2 +dash==4.1.0 +dataclasses-json==0.6.7 +datasets==4.8.5 +decorator==5.2.1 +deepdiff==8.6.2 +Deprecated==1.3.1 +diffusers==0.35.2 +dill==0.4.1 +docstring_parser==0.18.0 +draccus==0.10.0 +einops==0.8.2 +embreex==4.4.0 +etils==1.13.0 +evdev==1.9.3 +exceptiongroup==1.3.1 +executing==2.2.1 +Farama-Notifications==0.0.6 +fast_simplification==0.1.13 +fastjsonschema==2.21.2 +filelock==3.29.0 +Flask==3.1.3 +fonttools==4.63.0 +freetype-py==2.5.1 +frozenlist==1.8.0 +fsspec==2026.2.0 +genesis-world @ file:///data/gck/genesis-world +git-filter-repo==2.47.0 +gitdb==4.0.12 +GitPython==3.1.50 +glfw==2.10.0 +gs-madrona==0.0.5 +gstaichi==3.3.0 +gym==0.26.2 +gym-notices==0.1.0 +gymnasium==1.3.0 +h11==0.16.0 +h5py==3.16.0 +hf-xet==1.5.0 +hf_transfer==0.1.9 +httpcore==1.0.9 +httpx==0.28.1 +huggingface-hub==0.35.3 +idna==3.15 +ImageIO==2.37.3 +imageio-ffmpeg==0.6.0 +importlib_metadata==9.0.0 +importlib_resources==7.1.0 +inquirerpy==0.3.4 +ipython==8.39.0 +ipywidgets==8.1.8 +itsdangerous==2.2.0 +jedi==0.20.0 +Jinja2==3.1.6 +joblib==1.5.3 +jsonlines==4.0.0 +jsonschema==4.26.0 +jsonschema-specifications==2025.9.1 +jupyter_core==5.9.1 +jupyterlab_widgets==3.0.16 +kiwisolver==1.5.0 +lazy-loader==0.5 +lerobot==0.4.4 +libigl==2.6.2 +llvmlite==0.47.0 +loguru==0.7.3 +lxml==6.1.0 +manifold3d==3.4.1 +-e git+ssh://git@github.com/HeegerGao/maniladder.git@f6eed17496816bb41ce484f2d7580990a908d3e6#egg=maniladder +mapbox_earcut==2.0.0 +markdown-it-py==4.2.0 +MarkupSafe==3.0.3 +marshmallow==3.26.2 +matplotlib==3.10.9 +matplotlib-inline==0.2.2 +mdurl==0.1.2 +mergedeep==1.3.4 +moviepy==2.2.1 +mpmath==1.3.0 +msgspec==0.21.1 +mujoco==3.8.1 +multidict==6.7.1 +multiprocess==0.70.19 +mypy_extensions==1.1.0 +nbformat==5.10.4 +nest-asyncio==1.6.0 +networkx==3.4.2 +ninja==1.13.0 +nlopt==2.10.0 +numba==0.65.1 +numpy @ file:///home/conda/feedstock_root/build_artifacts/numpy_1747544640217/work/dist/numpy-2.2.6-cp310-cp310-linux_x86_64.whl#sha256=d6d964caeef85d00073d27cd62b46883d275b3d8162f723f0fcabbd0b3cc3f9d +nvidia-cublas-cu12==12.8.4.1 +nvidia-cuda-cupti-cu12==12.8.90 +nvidia-cuda-nvrtc-cu12==12.8.93 +nvidia-cuda-runtime-cu12==12.8.90 +nvidia-cudnn-cu12==9.10.2.21 +nvidia-cufft-cu12==11.3.3.83 +nvidia-cufile-cu12==1.13.1.3 +nvidia-curand-cu12==10.3.9.90 +nvidia-cusolver-cu12==11.7.3.90 +nvidia-cusparse-cu12==12.5.8.93 +nvidia-cusparselt-cu12==0.7.1 +nvidia-nccl-cu12==2.27.5 +nvidia-nvjitlink-cu12==12.8.93 +nvidia-nvshmem-cu12==3.4.5 +nvidia-nvtx-cu12==12.8.90 +open3d==0.19.0 +opencv-python==4.13.0.92 +opencv-python-headless==4.12.0.88 +OpenEXR==3.4.11 +orderly-set==5.5.0 +packaging==25.0 +pandas==2.3.3 +parso==0.8.7 +pexpect==4.9.0 +pfzy==0.3.4 +pillow==11.3.0 +pin==4.0.0 +pip @ file:///home/task_177498883471825/croot/pip_1774988882575/work +platformdirs==4.9.6 +plotly==5.24.1 +polyscope==2.6.1 +proglog==0.1.12 +prompt_toolkit==3.0.52 +propcache==0.5.2 +protobuf==6.33.6 +psutil==7.2.2 +ptyprocess==0.7.0 +pure_eval==0.2.3 +py-cpuinfo==9.0.0 +py-spy==0.4.2 +pyarrow==24.0.0 +pycollada==0.9.3 +pycparser==3.0 +pydantic==2.13.4 +pydantic_core==2.46.4 +PyGEL3D==0.6.1 +pyglet==2.1.14 +pygltflib==1.16.0 +Pygments==2.20.0 +pymeshlab==2025.7.post1 +pynput==1.8.2 +PyOpenGL==3.1.10 +pyparsing==3.3.2 +pyperclip==1.11.0 +PyQt6==6.11.0 +PyQt6-Qt6==6.11.0 +PyQt6_sip==13.11.1 +pyquaternion==0.9.9 +pyserial==3.5 +pysplashsurf==0.12.0.2 +python-dateutil==2.9.0.post0 +python-dotenv==1.2.2 +python-xlib==0.33 +pytransform3d==3.15.0 +pytz==2026.2 +pyuipc @ file:///tmp/claude-1005/-mnt4-gck-maniladder/9f005e67-04f6-4368-bd0e-9f40896c7dbf/scratchpad/pyuipc_dl/pyuipc-0.0.25-cp310-cp310-manylinux_2_34_x86_64.whl#sha256=76ff13554e1971ea4401db2c875369cf32352ae3a5a4c398c45193231b5cbf00 +PyYAML==6.0.3 +pyyaml-include==1.4.1 +referencing==0.37.0 +regex==2026.5.9 +requests==2.34.2 +rerun-sdk==0.26.2 +retrying==1.4.2 +rich==14.3.4 +rpds-py==0.30.0 +rtree==1.4.1 +safetensors==0.7.0 +sapien==3.0.3 +scikit-image==0.25.2 +scikit-learn==1.7.2 +scipy @ file:///home/conda/feedstock_root/build_artifacts/scipy-split_1739790642651/work/dist/scipy-1.15.2-cp310-cp310-linux_x86_64.whl#sha256=9e52bad6c3294d1a5b04a13632118ca2157130603c6c018c2d710162b223b27e +sentry-sdk==2.60.0 +setuptools==80.10.2 +shapely==2.1.2 +six==1.17.0 +smmap==5.0.3 +stack-data==0.6.3 +svg.path==7.0 +sympy==1.14.0 +tenacity==9.1.4 +termcolor==3.3.0 +tetgen==0.8.4 +threadpoolctl==3.6.0 +tifffile==2025.5.10 +timm==1.0.27 +toml==0.10.2 +torch==2.10.0 +torchaudio==2.11.0 +torchcodec==0.10.0 +torchvision==0.25.0 +tqdm==4.67.3 +traitlets==5.15.0 +transforms3d==0.4.2 +trimesh==4.12.2 +triton==3.6.0 +typeguard==4.5.2 +typing-inspect==0.9.0 +typing-inspection==0.4.2 +typing_extensions==4.15.0 +tyro==1.0.13 +tzdata==2026.2 +urllib3==2.7.0 +vhacdx==0.0.10 +viser==1.0.27 +vtk==9.6.1 +wandb==0.24.2 +wcwidth==0.7.0 +websockets==16.0 +Werkzeug==3.1.8 +wheel==0.46.3 +widgetsnbextension==4.0.15 +wrapt==2.1.2 +xxhash==3.7.0 +yarl==1.23.0 +yourdfpy==0.0.60 +z3-solver==4.16.0.0 +zipp==3.23.1 +zstandard==0.25.0 diff --git a/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/findings.md b/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/findings.md new file mode 100644 index 0000000000000000000000000000000000000000..20ceab4ace0ca67b1e52687f09780ae385a77f3f --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/findings.md @@ -0,0 +1,13 @@ +# Findings from authorized D20/E20 work + +All 20 authorized demonstrations were analyzed; see the preserved /workspace/demo_analysis.md and bank_provenance.json for exact source frames. The bank contains 6,245 legal observations and 6,225 expert actions. Twenty terminal zero labels are synthetic. + +The API is the only source of live task observations and actions. Episode 1 ended after one command because the exploration harness misread the API result envelope; corrected before episode 2. Episodes 2 and 3 returned native success at steps 324 and 306. Evidence, images and actions are preserved under /workspace/evidence. Further exploration and rehearsals are recorded there independently of this immutable snapshot. + +Localization uses front/left/top pooled RGB jointly with qpos/qvel. It is not a metric rope detector. Approach and descent matched demonstrated poses closely; closure/lift deviated more. Pose-conditioned retrieval delayed lift until fingers approached demonstrated configurations. Rotation labels remain zero. Finger mapping is inherited from native expert actions rather than inferred joint order. No neural weights are fitted. + +Native success was returned during lifting in the initial full attempts. Terminal holding and slip recovery remain unverified. Missing observations or unsupported states cause zero deltas; this prevents unsupported extrapolation but can stall. There is no validated dropped-rope recovery. Image pooling can obscure thin rope geometry and action averaging can mix phases. No official success is inferred from images or endpoint proximity. + +Variant v1 conditions the reference bank on the first observed arm angle, interpolating neighboring legal demonstration configurations after phase alignment by action onsets. Current images and joints still select every action. This empirical relationship may not generalize and is not a seed inference. Three nearest actions reduce phase mixing. Baseline rehearsal episode 5 was valid and native false. + +V1 interactive episode 6 returned native success at step 292. This is a single-scene result; independent rehearsal remains required for exact bundle qualification. diff --git a/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/freeze_manifest.json b/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/freeze_manifest.json new file mode 100644 index 0000000000000000000000000000000000000000..75af374614a8f5251f444eeeccc47b21a6abf533 --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/freeze_manifest.json @@ -0,0 +1,103 @@ +{ + "files": { + "__pycache__/build_bank.cpython-310.pyc": "6234b2077d286e37189bc1526e679d7e8ca55e0a77fdcadba74bd1462bbb5d7c", + "__pycache__/check_synthetic.cpython-310.pyc": "1ecb8ed2229890ce0a79b343eb0c1018b2938cac7709162c1d7a6b06966a7adf", + "__pycache__/controller.cpython-310.pyc": "a54cfc03ead6bfc0004b87ec63226ebe9e8f6ae9253f9322ec5be6de6d64eb19", + "bank_provenance.json": "6497a99c4d96766af095d6784793e38b252b3160e6606fd2554ab252189dfb0a", + "build_bank.py": "3bd7d8817cb98ea6104b38e8d24e5a0732e3f7e3c03c3f333e00de2f78ffdde5", + "check_synthetic.py": "8eb6a2a1590aa559f70c5f94cbee8206d23008f40b0be30562ac83758a9f0f0b", + "controller.py": "57668febee1dac198c70960f328eba0960330366eabe6dff9413f7de1d27df33", + "demo_bank.npz": "2ece502bc8d7e3c93041dc46f38c9ed04c71687a92bf6aa9fcb7a61ca012ad74", + "demo_manifest.json": "5bd34e5d418b562175761d019841bc68b2da06f408cd911976a5e7661a1eb60c", + "demonstrations_readonly/demo_00.h5": "855f757c50a8db43a13a83a982fde01f2d44e7160f6abc1b8f1be3e3759d44ea", + "demonstrations_readonly/demo_01.h5": "bab25a636b9d182ccf860daa17968a199a379f22ba18668bc86b93b487b4044b", + "demonstrations_readonly/demo_02.h5": "6a497dadb9bd41465d8c9742377c78ea065a5f8ca8f43b32225456c1849cbe7a", + "demonstrations_readonly/demo_03.h5": "ab914feab9b19e5d4946d44d7dd9f172ab5f434131d84292204a4974f49e8ace", + "demonstrations_readonly/demo_04.h5": "f7d0336b0bb7013d5d21104ab4a304725c789894a8b8340a5dcfd723790f11b4", + "demonstrations_readonly/demo_05.h5": "98d2b9678383d0885e9c45f8e3b1dbcb5e6eb7c251c3bfb62a3c3b3b1e4a288b", + "demonstrations_readonly/demo_06.h5": "5ea7ce45fbbe4140cbe5cdea09248012da127b989a1564738246b9216142af50", + "demonstrations_readonly/demo_07.h5": "eed21a1500e954cd1ffee97544a5d9c0fbb2427152fe335398c7b523adf1f644", + "demonstrations_readonly/demo_08.h5": "eaa224bcd93df6eb40cb4141faa9f667e22d6b2f47e3f88399a77aa9b675bc6b", + "demonstrations_readonly/demo_09.h5": "cc779251fcddb2e6458e1062fab9ab816be2af2336292cba876bcb24b2a3d882", + "demonstrations_readonly/demo_10.h5": "4afa1a6414be5d1a34e231bc8c093b42c22be209a82d41869e763d8960be8bcc", + "demonstrations_readonly/demo_11.h5": "48a495ea8ff3572ebbe2275463976149dcf0141b436b9e074a0dfc6037af87fe", + "demonstrations_readonly/demo_12.h5": "260e0ee5c9bd2d080e244e36781dc759063dd0d17b498d19e3e866f25b1f1679", + "demonstrations_readonly/demo_13.h5": "56b73a341c527160376b2b400ab4e4e7c2c2f53f17293c23027edf083e0b61cf", + "demonstrations_readonly/demo_14.h5": "7f0bd9e0cc2574986b4551db5b77cac82a9297d7b70d32af6f0a975490e683e3", + "demonstrations_readonly/demo_15.h5": "fc99f701e7c7517f35907c910adfd8cf74cefe7a161d3f447a6f3be757e4a27d", + "demonstrations_readonly/demo_16.h5": "6be6c23a1c57e3b663aa8b2071571ffda16d7b88c791792eaf35173f0e187055", + "demonstrations_readonly/demo_17.h5": "c43803218b5b923679fc4ebba2edf87434d3e97c399f527e8d15ffdbb49306b7", + "demonstrations_readonly/demo_18.h5": "1e59d615819b007c81a9f5ba9af6d7a6d0fdb6c42cb0d67739452e245e6d06d8", + "demonstrations_readonly/demo_19.h5": "59b3c753977985699b44ccb6f3023f6f65041688425f7f90453b3bb53cd26a8c", + "environment.lock": "f9f11f093744865020243315494d48c69e38ff9e67783e7cf5f0a1e5f22b34aa", + "findings.md": "1761925ee167d3bdcb6ed5c20e07beabbb0e88409d9c3e06c14be7a3adb272b9", + "handoff.md": "b4433c7f64c0e8f9bb851a4121e36ff4d7ca42d7c752121cdf323052381437e5", + "model_tool_manifest.yaml": "cde4612b3990ccb0413830d8732fc9e95b7333ce7eb8ad911937ba2d56095877", + "policy_runner.py": "cd8a30fc763583fb9bf6570414f01d56aba16241c733fc0cdfdfab0f8f27270e", + "skills.md": "da28c58a7db61a17eda9388c59b65b45a8637566d6653bbe98f4579bfdab8edf", + "synthetic_check_result.txt": "a95257781425b8f1cd325c6bc0c1f7a75afd081befc7e67b2b5646a22378522a", + "worker_api.py": "88cca5fa5c1c9570ca2bd90e8848f67c09224fa498d94e63634ad191e913c41e" + }, + "bundle_hash": "588d98196f5ab555d9910b17e77f1f074c4c4165d6a10169ed4211358ccc5996", + "exploration_ledger_hash": "1f6d64a08df356f1be6f2e746fb085a0e34987a4aacfe5d8a5e60ac8dea21784", + "entrypoint": "controller.reset_episode(); controller.act(obs)", + "selection": { + "rule": "exact-version success rate, valid rehearsal count, recency", + "rehearsals": [ + { + "bundle_hash": "c7bd3ca2ca37398ee468f6dec1481f1c0172b2cfb746047f99da0e93d52d0194", + "episode": 5, + "independent": true, + "score_source": "native_step_feedback", + "status": "finished", + "success": false, + "valid": true + }, + { + "bundle_hash": "588d98196f5ab555d9910b17e77f1f074c4c4165d6a10169ed4211358ccc5996", + "episode": 7, + "independent": true, + "score_source": "native_step_feedback", + "status": "finished", + "success": true, + "valid": true + }, + { + "episode": 17, + "bundle_hash": "588d98196f5ab555d9910b17e77f1f074c4c4165d6a10169ed4211358ccc5996", + "independent": true, + "valid": true, + "status": "finished", + "success": true, + "score_source": "native_step_feedback" + }, + { + "episode": 18, + "bundle_hash": "588d98196f5ab555d9910b17e77f1f074c4c4165d6a10169ed4211358ccc5996", + "independent": true, + "valid": true, + "status": "finished", + "success": true, + "score_source": "native_step_feedback" + }, + { + "episode": 19, + "bundle_hash": "588d98196f5ab555d9910b17e77f1f074c4c4165d6a10169ed4211358ccc5996", + "independent": true, + "valid": true, + "status": "finished", + "success": true, + "score_source": "native_step_feedback" + }, + { + "episode": 20, + "bundle_hash": "588d98196f5ab555d9910b17e77f1f074c4c4165d6a10169ed4211358ccc5996", + "independent": true, + "valid": true, + "status": "finished", + "success": true, + "score_source": "native_step_feedback" + } + ] + } +} diff --git a/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/handoff.md b/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/handoff.md new file mode 100644 index 0000000000000000000000000000000000000000..b176415ae3ec0acbc5de1c7710371580cfa1a6da --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/handoff.md @@ -0,0 +1,9 @@ +# Handoff — Agent-D20-E20-Compiled + +Runtime: controller.py exposes reset_episode() and act(obs). The program uses only its bundled demo_bank.npz, NumPy, OpenCV and pathlib. No network, simulator import, agent or pretrained model is needed. Runner supplies the verified demonstrations and common environment lock. + +Input: current legal RGB and agent/qpos, agent/qvel under proprioception. Output: a 22-component native normalized action with arm translation/rotation followed by sixteen hand deltas. The runner's initial hold consumes step 1; act returns None at step_id >=500. reset_episode clears local memory only. + +This candidate uses observation-conditioned retrieval, not a timed demonstration replay. All source and synthetic-label provenance is in bank_provenance.json. The worker preserved original D20 analysis and legal E20 evidence outside the bundle. Rehearsal results and exact hashes are runner-authoritative; this document makes no future success claim. At budget exhaustion select only an independently rehearsed runnable exact version through API.freeze(). + +Limitations: pooled-image localization, unknown metric calibration and hand joint permutation, unsupported-state stalling, and unvalidated slip recovery and terminal hold. Native success must come from native returns; absent native labels, ambiguous visible evidence is false. diff --git a/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/model_tool_manifest.yaml b/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/model_tool_manifest.yaml new file mode 100644 index 0000000000000000000000000000000000000000..8ed0922ddf3f7b91ffbde8ec64df61eba7ab8c68 --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/model_tool_manifest.yaml @@ -0,0 +1,144 @@ +{ + "schema_version": 1, + "task_id": "RopePalmCageHoldDex-v1", + "worker": "Agent-D20-E20-Compiled", + "stage": "AUTHORIZED_E20_EXPLORATION", + "status": "candidate_for_independent_rehearsal", + "task_testing_performed": true, + "neural_finetuning": false, + "weight_updates": false, + "coding_model": { + "identity": "Codex based on GPT-6 per supplied system/developer context", + "exact_checkpoint": "not exposed", + "weights": "provider managed; no modification or download" + }, + "pretrained_tool_weights": [], + "frozen_weight_references": [], + "policy": { + "kind": "observation-conditioned retrieval from phase-aligned, initial-pose-interpolated legal demonstration references", + "artifact": "demo_bank.npz", + "artifact_is_neural_weights": false, + "synthetic_labels": "20 zero-delta terminal holds; not expert labels", + "observations": 6245, + "expert_actions": 6225, + "demo_ids": [ + "demo_00", + "demo_01", + "demo_02", + "demo_03", + "demo_04", + "demo_05", + "demo_06", + "demo_07", + "demo_08", + "demo_09", + "demo_10", + "demo_11", + "demo_12", + "demo_13", + "demo_14", + "demo_15", + "demo_16", + "demo_17", + "demo_18", + "demo_19" + ], + "source": "Authorized sanitized demonstrations only, through API.read_demo", + "provenance_file": "bank_provenance.json" + }, + "tools_used": [ + { + "name": "functions.exec / exec_command", + "purpose": "local shell and Python execution" + }, + { + "name": "view_image", + "purpose": "inspect legal RGB contact sheets" + }, + { + "name": "worker_api.API.read_demo", + "purpose": "local authorized HDF5 reads", + "source": "/worker_api.py", + "sha256": "88cca5fa5c1c9570ca2bd90e8848f67c09224fa498d94e63634ad191e913c41e" + }, + { + "name": "NumPy", + "purpose": "statistics, feature distances, action interpolation, artifact storage" + }, + { + "name": "OpenCV cv2", + "purpose": "area resizing, contact sheets, image encoding" + }, + { + "name": "h5py", + "purpose": "HDF5 reading inside API.read_demo" + }, + { + "name": "worker_api.API", + "purpose": "budget, legal exploration, independent rehearsal, scoring and freeze only" + } + ], + "versions": { + "python": "3.10.20", + "numpy": "2.2.6", + "cv2_runtime": "4.12.0", + "h5py": "3.16.0", + "opencv_python_distribution": "4.13.0.92", + "opencv_python_headless_distribution": "4.12.0.88" + }, + "runtime_dependencies": [ + "Python 3.10 compatible", + "numpy", + "cv2", + "Python stdlib pathlib" + ], + "build_dependencies": [ + "runtime dependencies", + "h5py", + "Python stdlib importlib and json", + "authorized /worker_api.py and demo mounts" + ], + "available_but_not_used": { + "scipy": "1.15.3", + "torch": "2.10.0" + }, + "external_access": { + "internet_used": false, + "audited_provider_proxy": "not invoked or tested", + "environment_rpc": "Only trusted worker_api.API", + "simulator": "not created or imported" + }, + "verification": { + "syntax": "passed py_compile", + "synthetic_inputs": "passed check_synthetic.py", + "real_environment": "Authorized API episodes; evidence ledger outside immutable bundle", + "demonstration_policy_replay": "not performed" + }, + "limitations": [ + "Success evidence is limited to authorized API returns; generalization unverified", + "No hidden state, contacts, rewards or rope pose", + "No pretrained vision encoder or learned perception", + "Metric camera calibration and joint-name permutation unavailable", + "Pooled images and neighbor averaging may fail", + "Terminal hold is an unvalidated heuristic", + "Dual OpenCV distributions installed; cv2 runtime version above is authoritative for this process", + "Model checkpoint identifier and provider tool implementation versions not exposed", + "20 Hz end-to-end runtime not benchmarked", + "Runner supplies verified demo manifest and common lock separately" + ], + "input_documents": { + "/task_contract.json": "40c07726d814d0ceda85ade62bd239734d08dbaba41d2e0f87daeddd671e3424", + "/demo_manifest.json": "83ea3b207807f36b73917e3367f27f5f580f6f933239210db1a7998ad3f4efaf" + }, + "artifact_sha256": { + "check_synthetic.py": "8eb6a2a1590aa559f70c5f94cbee8206d23008f40b0be30562ac83758a9f0f0b", + "findings.md": "1761925ee167d3bdcb6ed5c20e07beabbb0e88409d9c3e06c14be7a3adb272b9", + "demo_bank.npz": "2ece502bc8d7e3c93041dc46f38c9ed04c71687a92bf6aa9fcb7a61ca012ad74", + "handoff.md": "b4433c7f64c0e8f9bb851a4121e36ff4d7ca42d7c752121cdf323052381437e5", + "bank_provenance.json": "6497a99c4d96766af095d6784793e38b252b3160e6606fd2554ab252189dfb0a", + "build_bank.py": "3bd7d8817cb98ea6104b38e8d24e5a0732e3f7e3c03c3f333e00de2f78ffdde5", + "controller.py": "57668febee1dac198c70960f328eba0960330366eabe6dff9413f7de1d27df33", + "skills.md": "da28c58a7db61a17eda9388c59b65b45a8637566d6653bbe98f4579bfdab8edf", + "synthetic_check_result.txt": "a95257781425b8f1cd325c6bc0c1f7a75afd081befc7e67b2b5646a22378522a" + } +} diff --git a/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/policy_runner.py b/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/policy_runner.py new file mode 100644 index 0000000000000000000000000000000000000000..e49448d6245feb7818ae505f1061708ab97c6ead --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/policy_runner.py @@ -0,0 +1,25 @@ +"""Frozen-program entry point; no development agent and no reset capability.""" +import importlib.util +import sys + +sys.path.insert(0,'/artifact') +sys.path.insert(0,'/') +from worker_api import API + + +def main(): + spec=importlib.util.spec_from_file_location('controller','/artifact/controller.py') + module=importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + module.reset_episode() + api=API() + result=api.latest_observation() + while not (result['terminated'] or result['truncated'] or result['horizon_reached']): + obs=dict(result['observation'],step_id=result['step_id']) + action=module.act(obs) + if action is None:break + response=api.execute_actions([action]) + result=response['steps'][-1] + + +if __name__=='__main__':main() diff --git a/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/skills.md b/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/skills.md new file mode 100644 index 0000000000000000000000000000000000000000..22e6516cd878708b8dd06d4e5f0e0c89920c6f72 --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/skills.md @@ -0,0 +1,11 @@ +# Operational skills + +These mechanisms are tested only through the authorized API. Initial full interactive attempts returned native success; exact bundle qualification requires independent rehearsal. + +- Observe: read current front/left/top RGB and qpos/qvel. Accept HWC or singleton-batch RGB. Area pooling retains native image orientation, using 16×12 for front/left and 12×16 for top. No depth or hidden state. +- Approach and cage: retrieve nearby legal observation/action pairs jointly by image and joint state, then average three action vectors from a phase-aligned reference interpolated between initial observed arm configurations. All 20 demonstrations contribute. No timed phase schedule or fixed live target pose. +- Attempt retention: near a terminal observed configuration, issue zero normalized deltas. Continue monitoring image/joint displacement; resume retrieval if that configuration changes substantially. This is an unvalidated design, since demonstration tails still ascend. +- Handle unsupported observations: return legal zeros on missing/malformed required sensor data or large distance from the reference bank. This may stall and is not a proven recovery strategy. +- Respect runner boundaries: reset only clears local hold memory. Runner owns initial hold. Emit one 22-component action for each native step 1..499; return None at 500. Do not claim task completion from elapsed time or endpoint similarity. + +No task-specific expert/controller, simulator, kinematic model, neural model, optimizer, pretrained visual encoder, or external service is used at runtime. diff --git a/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/synthetic_check_result.txt b/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/synthetic_check_result.txt new file mode 100644 index 0000000000000000000000000000000000000000..e2ea85f63584904309c8bfde20b5ac266990970c --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/synthetic_check_result.txt @@ -0,0 +1 @@ +PASS: syntax separate; bank structure, synthetic RGB/proprio dependence, HWC/1HWC, finite legal outputs, malformed-input hold, terminal heuristic/reset, native-budget boundary. No task testing. diff --git a/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/worker_api.py b/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/worker_api.py new file mode 100644 index 0000000000000000000000000000000000000000..ff137d1c68cb70a1549326d2d22b430c9cf4e20c --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/RopePalmCageHoldDex-v1/frozen/worker_api.py @@ -0,0 +1,81 @@ +"""Standalone worker client; safe to mount without the runner package.""" +import base64 +import json +import socket +import struct +import uuid +import os +from pathlib import Path + +import numpy as np + + +def array_hook(value): + if value.get('__array__') is True: + dtype=np.dtype(value['dtype']) + if dtype.kind not in 'bifu':raise ValueError('non-numeric array from service') + raw=base64.b64decode(value['data'],validate=True) + return np.frombuffer(raw,dtype=dtype).reshape(value['shape']).copy() + return value + + +class API: + def __init__(self,socket_path='/rpc/control.sock',demo_root='/demonstrations',manifest='/demo_manifest.json'): + self.socket_path=socket_path + self.demo_root=Path(demo_root) + self.manifest=Path(manifest) + + def call(self,method,arguments=None,request_id=None): + # Caller can persist a request ID before sending. Never automatically retry. + request_id=request_id or str(uuid.uuid4()) + request={'request_id':request_id,'method':method,'arguments':arguments or {}} + if os.environ.get('AGENT_E20_RPC_TOKEN'): + request['token']=os.environ['AGENT_E20_RPC_TOKEN'] + payload=json.dumps(request,allow_nan=False).encode() + if len(payload)>65536:raise ValueError('request too large') + with socket.socket(socket.AF_UNIX,socket.SOCK_STREAM) as s: + s.settimeout(1810);s.connect(self.socket_path) + s.sendall(struct.pack('!I',len(payload))+payload) + def exact(n): + chunks=[] + while n: + chunk=s.recv(min(n,1024*1024)) + if not chunk:raise RuntimeError('RPC interrupted; do not replay action with a new ID') + chunks.append(chunk);n-=len(chunk) + return b''.join(chunks) + length=struct.unpack('!I',exact(4))[0] + if length>64*1024*1024:raise RuntimeError('response too large') + result=json.loads(exact(length),object_hook=array_hook) + if not result['ok']:raise RuntimeError(result['error']) + return result['result'] + + def next_episode(self,request_id=None):return self.call('next_episode',request_id=request_id) + def latest_observation(self):return self.call('latest_observation') + def execute_actions(self,actions,request_id=None): + return self.call('execute_actions',{'actions':np.asarray(actions).tolist()},request_id) + def finish_episode(self):return self.call('finish_episode') + def budget_status(self):return self.call('budget_status') + def rehearse(self,candidate='candidate',request_id=None): + return self.call('rehearse',{'candidate':candidate},request_id) + def score_rehearsal(self,episode,visible_success,evidence): + return self.call('score_rehearsal',{'episode':episode,'visible_success':visible_success,'evidence':evidence}) + def freeze(self):return self.call('freeze') + + def read_demo(self,demo_id,start=0,stop=None,fields=None): + import h5py + manifest=json.loads(self.manifest.read_text()) + if manifest.get('status') not in ('released','released_for_offline_analysis'): + raise RuntimeError('demonstrations not released by trusted preflight') + entries={e['demo_id']:e for e in manifest['episodes']} + if demo_id not in entries:raise ValueError('unauthorized demo ID') + entry=entries[demo_id] + allowed={f['path'] for f in entry['fields']} + fields=sorted(allowed) if fields is None else fields + if not set(fields)<=allowed:raise ValueError('unauthorized demo field') + stop=entry['length']+1 if stop is None else stop + if not isinstance(start,int) or not isinstance(stop,int) or not 0<=start.4 +c._bank['visual'][:]=black;c._bank['q'][5:]=2 +c.reset_episode();a=c.act(obs());b=c.act(obs(q=2));assert np.max(abs(a-b))>.4 +c.reset_episode();assert c.act(obs(step=300)) is None +c.reset_episode();assert c.act({'step_id':1}).shape==(22,) +c.reset_episode();bad=obs();bad['proprioception']['agent/qpos'][0]=np.nan;assert np.array_equal(c.act(bad),np.zeros(22)) +c.reset_episode() +for i in range(299): assert c.act({'step_id':i+1}).shape==(22,) +assert c.act({'step_id':300}) is None +c.reset_episode();assert c.act({'step_id':1}).shape==(22,) +c._bank=real_bank +print('PASS: import, artifact load, synthetic RGB/proprio feedback, HWC/1HWC, finite bounded 22-vector, missing/NaN fallback, budget, reset. No task testing.') diff --git a/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/controller.py b/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/controller.py new file mode 100644 index 0000000000000000000000000000000000000000..31dd202a11cac6de948533aa13ef9a9d7c529feb --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/controller.py @@ -0,0 +1,98 @@ +"""D20 demonstrated-pose servo with legal RGB/proprioception feedback. +No simulator, hidden state, seed, fitted network, or task expert is used. +""" +from pathlib import Path +import importlib.util +import numpy as np + +_ROOT = Path(__file__).resolve().parent +_spec = importlib.util.spec_from_file_location('_d20_features', _ROOT/'features.py') +_features = importlib.util.module_from_spec(_spec) +_spec.loader.exec_module(_features) +_kspec = importlib.util.spec_from_file_location('_robot_fk', _ROOT/'kinematics.py') +_kin = importlib.util.module_from_spec(_kspec) +_kspec.loader.exec_module(_kin) +_bank = None +_calls = 0 +_phase = 0 +last_diagnostics = {} + +def reset_episode(): + global _calls, _phase, last_diagnostics + _calls = 0 + _phase = 0 + last_diagnostics = {} + +def _load(): + global _bank + if _bank is None: + with np.load(_ROOT/'bank.npz', allow_pickle=False) as f: + _bank = {k: f[k] for k in ('q','v','visual','actions','qscale','vscale','frame_index')} + return _bank + +def act(obs): + """Return one float32 (22,) native action, or finish at native budget. + + step_id=1 is already after the runner's charged initial hold. No extra + initialization action is inserted here. Missing/invalid observations hold. + None means budget exhaustion only, never an assertion of success. + """ + global _calls, _phase, last_diagnostics + step = int(obs.get('step_id', _calls+1)) + if step >= 300 or _calls >= 299: + last_diagnostics = {'status':'native_budget_exhausted'} + return None + _calls += 1 + hold = np.zeros(22, np.float32) + try: + p = obs['proprioception'] + q = np.asarray(p['agent/qpos'], np.float32).reshape(-1) + v = np.asarray(p['agent/qvel'], np.float32).reshape(-1) + if q.shape != (23,) or v.shape != (23,) or not np.isfinite(q).all() or not np.isfinite(v).all(): + raise ValueError('Invalid proprioception') + rgb = obs['rgb'] + visual = [(j, _features.image_features(rgb[cam])) + for j,cam in enumerate(_features.CAMERAS) if cam in rgb] + if not visual: + raise ValueError('No RGB cameras') + except (KeyError, TypeError, ValueError): + last_diagnostics = {'status':'invalid_observation_hold'} + return hold + bank = _load() + qerr = ((bank['q']-q)/bank['qscale'])**2 + # Seven arm joints and sixteen hand joints: empirical qpos width is 23. + # Robot kinematics use qpos; no calibrated scene/camera transform is used. + distance_q = qerr[:,:7].mean(1) + .05*qerr[:,7:].mean(1) + distance_v = (((bank['v']-v)/bank['vscale'])**2).mean(1) + distance_rgb = np.zeros(len(distance_q),np.float32) + for j,x in visual: + distance_rgb += ((bank['visual'][:,j]-x)**2).sum(1)/len(visual) + distance = distance_q + .02*distance_v + .2*distance_rgb + frames = bank['frame_index'] + _phase = min(_calls-1,199) + distance[(frames != _phase) | ((np.arange(len(frames)) <791) | (np.arange(len(frames)) >=991))] += 10000 + nearest = int(np.argmin(distance)) + _phase = int(frames[nearest]) + if distance_q[nearest] > 50 or distance_rgb[nearest] > 12: + last_diagnostics = {'status':'outside_demo_support_hold', 'distance':float(distance[nearest])} + return hold + # Timed demo04 pose reference; feedback is recalculated every action. + # No scene identity or seed is used. + k = 1 + neighbors = np.argpartition(distance,k-1)[:k] + weights = 1/(distance[neighbors]+.001) + weights /= weights.sum() + action = np.sum(bank['actions'][neighbors]*weights[:,None],axis=0) + desired = _kin.fk(bank['q'][min(nearest+1,990),:7]) + actual = _kin.fk(q[:7]) + error_R = desired[:3,:3] @ actual[:3,:3].T + rot = np.array([error_R[2,1]-error_R[1,2], error_R[0,2]-error_R[2,0], error_R[1,0]-error_R[0,1]])/2 + action[:3] = 25*(desired[:3,3]-actual[:3,3]) + action[3:6] = -6*rot + target = bank['q'][min(nearest+1,990)].copy() + mapping = [4,0,8,12,5,1,9,13,6,2,10,14,3,7,11,15] + action[6:] = 10*(target[7:]-q[7:])[mapping] + last_diagnostics = {'frame':int(bank['frame_index'][nearest]), 'status':'reference_pose_servo','distance':float(distance[nearest]), + 'visual_distance':float(distance_rgb[nearest]), 'nearest':nearest, 'q_distance':float(distance_q[nearest])} + # One contract action part: six arm then sixteen dex joint deltas. + return np.clip(action,-1.,1.).astype(np.float32) diff --git a/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/data_digests.json b/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/data_digests.json new file mode 100644 index 0000000000000000000000000000000000000000..bfb1f24eebd65ccc866444ba4fcbca71009573b1 --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/data_digests.json @@ -0,0 +1,102 @@ +[ + { + "demo_id": "demo_00", + "actions_sha256": "30fcca0b80eaa77e59ddbdee31b19a886ee64d86f4b2d46457c7f763d4a73b73", + "qpos_sha256": "db6ff2ef9cd444c7ef6493f02617807349679f19fb9a9b5ee1562cc9f7216fe7" + }, + { + "demo_id": "demo_01", + "actions_sha256": "5ecf3f6a5cd1a338746159caf660f44f4802e10b1f8a72ef9ffc47d2b2563f4f", + "qpos_sha256": "f31c62aed6c847e5c1322b36b93694cfb09d97c432bac3ade731d508f018f3bf" + }, + { + "demo_id": "demo_02", + "actions_sha256": "efb19cedfcaee20a58bae5f310c6e6009b8df972fa3bce345d941d335db7448b", + "qpos_sha256": "00a62d475305d08a1e9c3737456c777ab61c70c38c70519b7cf167c22c1435db" + }, + { + "demo_id": "demo_03", + "actions_sha256": "1064d56cb7dc170244c45eba9c73fd4d488040aab4a2a0debdaa6c8cde338bc4", + "qpos_sha256": "4d80175a3093c52db88c677707817b1a0519a005240a46784b5c6a37705dec80" + }, + { + "demo_id": "demo_04", + "actions_sha256": "c1e915fffd9b3d1098f56444bcec56108f3cca283ae01ca8de027b18162764c4", + "qpos_sha256": "eb5415bc7717cd74a2535d51b197de3fc4f7ea1492baf4c98186912f5f0d9727" + }, + { + "demo_id": "demo_05", + "actions_sha256": "30fcca0b80eaa77e59ddbdee31b19a886ee64d86f4b2d46457c7f763d4a73b73", + "qpos_sha256": "db6ff2ef9cd444c7ef6493f02617807349679f19fb9a9b5ee1562cc9f7216fe7" + }, + { + "demo_id": "demo_06", + "actions_sha256": "5ecf3f6a5cd1a338746159caf660f44f4802e10b1f8a72ef9ffc47d2b2563f4f", + "qpos_sha256": "f31c62aed6c847e5c1322b36b93694cfb09d97c432bac3ade731d508f018f3bf" + }, + { + "demo_id": "demo_07", + "actions_sha256": "efb19cedfcaee20a58bae5f310c6e6009b8df972fa3bce345d941d335db7448b", + "qpos_sha256": "00a62d475305d08a1e9c3737456c777ab61c70c38c70519b7cf167c22c1435db" + }, + { + "demo_id": "demo_08", + "actions_sha256": "1064d56cb7dc170244c45eba9c73fd4d488040aab4a2a0debdaa6c8cde338bc4", + "qpos_sha256": "4d80175a3093c52db88c677707817b1a0519a005240a46784b5c6a37705dec80" + }, + { + "demo_id": "demo_09", + "actions_sha256": "c1e915fffd9b3d1098f56444bcec56108f3cca283ae01ca8de027b18162764c4", + "qpos_sha256": "eb5415bc7717cd74a2535d51b197de3fc4f7ea1492baf4c98186912f5f0d9727" + }, + { + "demo_id": "demo_10", + "actions_sha256": "30fcca0b80eaa77e59ddbdee31b19a886ee64d86f4b2d46457c7f763d4a73b73", + "qpos_sha256": "db6ff2ef9cd444c7ef6493f02617807349679f19fb9a9b5ee1562cc9f7216fe7" + }, + { + "demo_id": "demo_11", + "actions_sha256": "5ecf3f6a5cd1a338746159caf660f44f4802e10b1f8a72ef9ffc47d2b2563f4f", + "qpos_sha256": "f31c62aed6c847e5c1322b36b93694cfb09d97c432bac3ade731d508f018f3bf" + }, + { + "demo_id": "demo_12", + "actions_sha256": "efb19cedfcaee20a58bae5f310c6e6009b8df972fa3bce345d941d335db7448b", + "qpos_sha256": "00a62d475305d08a1e9c3737456c777ab61c70c38c70519b7cf167c22c1435db" + }, + { + "demo_id": "demo_13", + "actions_sha256": "1064d56cb7dc170244c45eba9c73fd4d488040aab4a2a0debdaa6c8cde338bc4", + "qpos_sha256": "4d80175a3093c52db88c677707817b1a0519a005240a46784b5c6a37705dec80" + }, + { + "demo_id": "demo_14", + "actions_sha256": "c1e915fffd9b3d1098f56444bcec56108f3cca283ae01ca8de027b18162764c4", + "qpos_sha256": "eb5415bc7717cd74a2535d51b197de3fc4f7ea1492baf4c98186912f5f0d9727" + }, + { + "demo_id": "demo_15", + "actions_sha256": "30fcca0b80eaa77e59ddbdee31b19a886ee64d86f4b2d46457c7f763d4a73b73", + "qpos_sha256": "db6ff2ef9cd444c7ef6493f02617807349679f19fb9a9b5ee1562cc9f7216fe7" + }, + { + "demo_id": "demo_16", + "actions_sha256": "5ecf3f6a5cd1a338746159caf660f44f4802e10b1f8a72ef9ffc47d2b2563f4f", + "qpos_sha256": "f31c62aed6c847e5c1322b36b93694cfb09d97c432bac3ade731d508f018f3bf" + }, + { + "demo_id": "demo_17", + "actions_sha256": "efb19cedfcaee20a58bae5f310c6e6009b8df972fa3bce345d941d335db7448b", + "qpos_sha256": "00a62d475305d08a1e9c3737456c777ab61c70c38c70519b7cf167c22c1435db" + }, + { + "demo_id": "demo_18", + "actions_sha256": "1064d56cb7dc170244c45eba9c73fd4d488040aab4a2a0debdaa6c8cde338bc4", + "qpos_sha256": "4d80175a3093c52db88c677707817b1a0519a005240a46784b5c6a37705dec80" + }, + { + "demo_id": "demo_19", + "actions_sha256": "c1e915fffd9b3d1098f56444bcec56108f3cca283ae01ca8de027b18162764c4", + "qpos_sha256": "eb5415bc7717cd74a2535d51b197de3fc4f7ea1492baf4c98186912f5f0d9727" + } +] \ No newline at end of file diff --git a/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/demo_manifest.json b/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/demo_manifest.json new file mode 100644 index 0000000000000000000000000000000000000000..2e6d5bfb616ed6ead0462935fc47bd97d6aff3e3 --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/demo_manifest.json @@ -0,0 +1,1488 @@ +{ + "task_id": "SwingRing-v1", + "status": "released", + "selection_rule": "prefer existing pinned D20, otherwise numeric trajectory ID sort before reading data", + "lineage_status": "fixed_numeric_ids_no_existing_comparator", + "episodes": [ + { + "demo_id": "demo_00", + "file": "demo_00.h5", + "length": 196, + "fields": [ + { + "path": "actions", + "shape": [ + 196, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 197, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 197, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 197, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 197, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 197, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 197, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "5ba9e8277b118ec0185b3290d46e7622e99626c9893d2c1f6bb824e210201123", + "source_sha256": "996be209c0ebddf2a71a7023ff223678d9891fd75909997cc2ef3f2e107d1b48", + "view_sha256": "32027094b90b832c8c5d996168f980a94f6dc681382efd4f99122e3ee285b2de" + }, + { + "demo_id": "demo_01", + "file": "demo_01.h5", + "length": 198, + "fields": [ + { + "path": "actions", + "shape": [ + 198, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 199, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 199, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 199, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 199, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 199, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 199, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "b857e7a5c3707a980dabf188f37298ccc41ddd3acb39751a7c04b7927c5d37bb", + "source_sha256": "5478fe22dddaefe730f428e484a0fa08e2d817034be879b4f3188d0e7a3a3287", + "view_sha256": "f16779da596aa643a6ac1f436c86305a3e3eb748bcdf4594ce7731d71cd2fae1" + }, + { + "demo_id": "demo_02", + "file": "demo_02.h5", + "length": 198, + "fields": [ + { + "path": "actions", + "shape": [ + 198, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 199, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 199, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 199, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 199, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 199, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 199, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "bffb5a2b8ea39f87ea289eed9071a848a33b4bc298a1273b963bc2188b02b4d0", + "source_sha256": "9e2502e7c48b23b1f7a1162f1b3b76bb025bdedb4e216d237a3ca5161d3d0490", + "view_sha256": "addc4dc8a5a5f15dd3b430fa846ed337af747866236efd9d0c35d99292340b7d" + }, + { + "demo_id": "demo_03", + "file": "demo_03.h5", + "length": 199, + "fields": [ + { + "path": "actions", + "shape": [ + 199, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 200, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 200, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 200, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 200, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 200, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 200, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "87542782501a7d1b0086a2fd68a11d6894aec1bac035ee0a59b13265b7543f06", + "source_sha256": "c515ab817ded2404ca98050b639b2b5b56215ba344739350287ff35fdc4ecbdc", + "view_sha256": "61b52f3082f2ae4ab5460ebef32964ff3c46186bd56889e6f16e9cce9e3b3ceb" + }, + { + "demo_id": "demo_04", + "file": "demo_04.h5", + "length": 200, + "fields": [ + { + "path": "actions", + "shape": [ + 200, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 201, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 201, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 201, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 201, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 201, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 201, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "1f937f4cf5b894eaa668118ea6e5b05c29c02114c87265a72a698acd39f18cb2", + "source_sha256": "b667b896c6c152e6ca0e0b0efa86b95db27820235d81919529c9b8418d7a5464", + "view_sha256": "0c6878d6275b38d18c77a282926def0899669b9b9a7423325f02888bcce7fca3" + }, + { + "demo_id": "demo_05", + "file": "demo_05.h5", + "length": 196, + "fields": [ + { + "path": "actions", + "shape": [ + 196, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 197, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 197, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 197, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 197, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 197, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 197, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "819140a3ea90f5ad69d452cf7561a0f8e72a528ac865b24640235b3047cb2a3b", + "source_sha256": "0f82f7411fff77c35ff80ab2919413e16afe21b7c1b1de953121581bc4ba8e39", + "view_sha256": "f5505d338ead7de84a0ecbf8779c5e575ead35268045910f199100b2f8a44e02" + }, + { + "demo_id": "demo_06", + "file": "demo_06.h5", + "length": 198, + "fields": [ + { + "path": "actions", + "shape": [ + 198, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 199, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 199, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 199, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 199, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 199, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 199, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "bf05805c0c2d906eed0080ef510a1041fd7869e514a8311e32685befdbeac7cb", + "source_sha256": "34e0f358aa064c34cf7c9b297828d19e5b10b5e3a8620ad79eca62654247a157", + "view_sha256": "6ca2c72af0acc8536331190d797d66576133855b96ca5d2737567cf6c2ac5dfe" + }, + { + "demo_id": "demo_07", + "file": "demo_07.h5", + "length": 198, + "fields": [ + { + "path": "actions", + "shape": [ + 198, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 199, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 199, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 199, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 199, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 199, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 199, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "3e300570c52ccd98f892ed97937812f8da5e0edaedae1e547371527d274242ee", + "source_sha256": "8729c101e30d2d799f6b120f0dca9d02bfebebf685aecdfa8e485711b0aa49f6", + "view_sha256": "874d599bf6418ce249f55298b1c6002f4edf660c2c693309b1f69034e34e10df" + }, + { + "demo_id": "demo_08", + "file": "demo_08.h5", + "length": 199, + "fields": [ + { + "path": "actions", + "shape": [ + 199, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 200, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 200, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 200, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 200, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 200, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 200, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "d76ca4759cbc22d93c5cefe6078cf1fe69583f50fa9c3b94e672ae6e741edbd7", + "source_sha256": "af9ea3ced11407471ea6b6d380028822f925b284703c333473be4d35be3b16a5", + "view_sha256": "c9ac0a53a001f3f90e54179447fbe650c9ca5602abcf700707d77d5e415abad5" + }, + { + "demo_id": "demo_09", + "file": "demo_09.h5", + "length": 200, + "fields": [ + { + "path": "actions", + "shape": [ + 200, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 201, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 201, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 201, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 201, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 201, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 201, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "f448f8495c45cf1de70a2862a91f23b1a20463934dc6a10ded2626c9f72ecb46", + "source_sha256": "c6217bc036e268a5c7961d3036fbf28c3238bd3af296de6db69227eac46db5f6", + "view_sha256": "3947bcd522127c46691e9d512c30eb82af5ff7340171503568823e288db5552f" + }, + { + "demo_id": "demo_10", + "file": "demo_10.h5", + "length": 196, + "fields": [ + { + "path": "actions", + "shape": [ + 196, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 197, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 197, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 197, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 197, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 197, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 197, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "b15d94f85c42f0fc92d4458275a8f7b137d9578b9924b71772ae4633409099d2", + "source_sha256": "b29880d164e0c07004421aa751be6d7fe49e79b5197efe94414caa50079982ff", + "view_sha256": "37b5bacacff1711d83c674029929bf31c35957ca8724600275f04a5322394277" + }, + { + "demo_id": "demo_11", + "file": "demo_11.h5", + "length": 198, + "fields": [ + { + "path": "actions", + "shape": [ + 198, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 199, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 199, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 199, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 199, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 199, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 199, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "f25025aa136853d1606a3f91f5d99e2292e20292d47115af5eb5ebbaa4dd308c", + "source_sha256": "2a397c4c5a0fa4c9014ee9001510d52b40acf175c0b8be729bf280ec27d1cb49", + "view_sha256": "8b53728ba7427cfec80235ff64e1bfa66a935e2e3faa73fb00b7d49ef215f58d" + }, + { + "demo_id": "demo_12", + "file": "demo_12.h5", + "length": 198, + "fields": [ + { + "path": "actions", + "shape": [ + 198, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 199, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 199, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 199, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 199, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 199, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 199, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "c31ab933644cc250bdd75019225685e39a49031e7207c1e0166538ace096db02", + "source_sha256": "8cd9c327e98a311316af143192363c384651e5ace34bb9de90f03e44c8e174ad", + "view_sha256": "4241cefe99af9d6801ca66478425b099f8144545ae58ef768c4c1613973ddf37" + }, + { + "demo_id": "demo_13", + "file": "demo_13.h5", + "length": 199, + "fields": [ + { + "path": "actions", + "shape": [ + 199, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 200, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 200, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 200, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 200, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 200, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 200, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "832cba9fbd6abf0c8f5fcbf9372e6cf4c9e226a1b1c016541d80900ac520c7e0", + "source_sha256": "ea955875dea64b94ba7b764b408453421e4285a02a08ff744d417f05fb37a242", + "view_sha256": "09ea5f05aac1530a442813af179ea15af46634f9b134e488f98a1bf93dec675d" + }, + { + "demo_id": "demo_14", + "file": "demo_14.h5", + "length": 200, + "fields": [ + { + "path": "actions", + "shape": [ + 200, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 201, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 201, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 201, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 201, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 201, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 201, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "4009a7f76e6462fb0e7bec38d7e66c3948f384fb36c686c02db25fda86392bcf", + "source_sha256": "0ca09ff5d3d0ed8448db40ee3121b991889cc586fd0588181d4bdb51c1b1164d", + "view_sha256": "5c274b5856264852b6fc4f5b31032ceeccf7e43e1bf6a24cae8b85039e49f191" + }, + { + "demo_id": "demo_15", + "file": "demo_15.h5", + "length": 196, + "fields": [ + { + "path": "actions", + "shape": [ + 196, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 197, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 197, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 197, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 197, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 197, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 197, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "9d2367251e1072884fb21ace557f9235dc0bc55b7091908d8e9b8bfc4c878500", + "source_sha256": "fc532f0c25f87ed7d7abfd43b53e29da2ffc50713692a8e16cf8953f3d2aeb4f", + "view_sha256": "b7c99599a0ba49abb0ffc60c6c9b8354dd4d05a17111c1d736e74440ea9322d1" + }, + { + "demo_id": "demo_16", + "file": "demo_16.h5", + "length": 198, + "fields": [ + { + "path": "actions", + "shape": [ + 198, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 199, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 199, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 199, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 199, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 199, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 199, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "32a5e6d50cf5dfd9ddf33fd540b8dedbc57669b28791476e17e13d41389c9ed2", + "source_sha256": "696cefbc51b218cf2f02e52ceca07ae76077bf863f4b10139b3228cc4ac8462e", + "view_sha256": "e9b31caf8323c348dfb6f50f1c2c183478cd124dc654045eb5607422f14a7a4c" + }, + { + "demo_id": "demo_17", + "file": "demo_17.h5", + "length": 198, + "fields": [ + { + "path": "actions", + "shape": [ + 198, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 199, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 199, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 199, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 199, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 199, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 199, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "ea33e02e59e1058e6e90df526f158e7bfa98232a0443b74f21752f7d8c69ba4d", + "source_sha256": "1eb5cf3145b6a5563ae248c46c7cf0831ad5be062a2bc50e06b7812c95d68585", + "view_sha256": "3a720b9fc8282f23167a27f807e9cfb530f5e31b502c5fbc67161b49cb27b419" + }, + { + "demo_id": "demo_18", + "file": "demo_18.h5", + "length": 199, + "fields": [ + { + "path": "actions", + "shape": [ + 199, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 200, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 200, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 200, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 200, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 200, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 200, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "d008711e3c4a4ddb6c99dcb99dc350de99af89d85de53b5fafad290747b694b1", + "source_sha256": "a2747112f34657b128424908128a02ebd29044485abde18f94189b7b4ee6df4b", + "view_sha256": "47105464bee6ae8c1c3bb985ed4d23383c67bbe2a9596c0ede0d34e1b401c57f" + }, + { + "demo_id": "demo_19", + "file": "demo_19.h5", + "length": 200, + "fields": [ + { + "path": "actions", + "shape": [ + 200, + 22 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qpos", + "shape": [ + 201, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/agent/qvel", + "shape": [ + 201, + 23 + ], + "dtype": "float32" + }, + { + "path": "obs/sensor_data/front_camera/rgb", + "shape": [ + 201, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/left_camera/rgb", + "shape": [ + 201, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/robot_camera/rgb", + "shape": [ + 201, + 240, + 320, + 3 + ], + "dtype": "uint8" + }, + { + "path": "obs/sensor_data/top_camera/rgb", + "shape": [ + 201, + 320, + 240, + 3 + ], + "dtype": "uint8" + } + ], + "trajectory_sha256": "d2ab9b88709750b8a5c720397d843544b5d7e399c6f689caf3406764160b5af2", + "source_sha256": "3d7b90f9a7fe9b90d319aa77ca02e1478cbabbd8b3d166d6baaf7c44d116c9fc", + "view_sha256": "dc613c10b03c817c13987d3f35c812c5937b95b86407b2f4d230819201f25fc2" + } + ] +} diff --git a/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/environment.lock b/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/environment.lock new file mode 100644 index 0000000000000000000000000000000000000000..b2237f47d93aa4c3efad07728ae6acd137912d6d --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/environment.lock @@ -0,0 +1,249 @@ +absl-py==2.4.0 +accelerate==1.13.0 +addict==2.4.0 +aiohappyeyeballs==2.6.1 +aiohttp==3.13.5 +aiosignal==1.4.0 +annotated-types==0.7.0 +anyio==4.13.0 +anytree==2.13.0 +asttokens==3.0.1 +async-timeout==5.0.1 +attrs==26.1.0 +av==15.1.0 +blinker==1.9.0 +casadi==3.7.2 +certifi==2026.4.22 +cffi==2.0.0 +charset-normalizer==3.4.7 +click==8.3.3 +cloudpickle==3.1.2 +cmake==4.1.3 +coacd==1.0.11 +colorama==0.4.6 +colorlog==6.10.1 +comm==0.2.3 +ConfigArgParse==1.7.5 +contourpy==1.3.2 +cuda-bindings==12.9.4 +cuda-pathfinder==1.5.4 +cycler==0.12.1 +dacite==1.9.2 +dash==4.1.0 +dataclasses-json==0.6.7 +datasets==4.8.5 +decorator==5.2.1 +deepdiff==8.6.2 +Deprecated==1.3.1 +diffusers==0.35.2 +dill==0.4.1 +docstring_parser==0.18.0 +draccus==0.10.0 +einops==0.8.2 +embreex==4.4.0 +etils==1.13.0 +evdev==1.9.3 +exceptiongroup==1.3.1 +executing==2.2.1 +Farama-Notifications==0.0.6 +fast_simplification==0.1.13 +fastjsonschema==2.21.2 +filelock==3.29.0 +Flask==3.1.3 +fonttools==4.63.0 +freetype-py==2.5.1 +frozenlist==1.8.0 +fsspec==2026.2.0 +genesis-world @ file:///data/gck/genesis-world +git-filter-repo==2.47.0 +gitdb==4.0.12 +GitPython==3.1.50 +glfw==2.10.0 +gs-madrona==0.0.5 +gstaichi==3.3.0 +gym==0.26.2 +gym-notices==0.1.0 +gymnasium==1.3.0 +h11==0.16.0 +h5py==3.16.0 +hf-xet==1.5.0 +hf_transfer==0.1.9 +httpcore==1.0.9 +httpx==0.28.1 +huggingface-hub==0.35.3 +idna==3.15 +ImageIO==2.37.3 +imageio-ffmpeg==0.6.0 +importlib_metadata==9.0.0 +importlib_resources==7.1.0 +inquirerpy==0.3.4 +ipython==8.39.0 +ipywidgets==8.1.8 +itsdangerous==2.2.0 +jedi==0.20.0 +Jinja2==3.1.6 +joblib==1.5.3 +jsonlines==4.0.0 +jsonschema==4.26.0 +jsonschema-specifications==2025.9.1 +jupyter_core==5.9.1 +jupyterlab_widgets==3.0.16 +kiwisolver==1.5.0 +lazy-loader==0.5 +lerobot==0.4.4 +libigl==2.6.2 +llvmlite==0.47.0 +loguru==0.7.3 +lxml==6.1.0 +manifold3d==3.4.1 +-e git+ssh://git@github.com/HeegerGao/maniladder.git@f6eed17496816bb41ce484f2d7580990a908d3e6#egg=maniladder +mapbox_earcut==2.0.0 +markdown-it-py==4.2.0 +MarkupSafe==3.0.3 +marshmallow==3.26.2 +matplotlib==3.10.9 +matplotlib-inline==0.2.2 +mdurl==0.1.2 +mergedeep==1.3.4 +moviepy==2.2.1 +mpmath==1.3.0 +msgspec==0.21.1 +mujoco==3.8.1 +multidict==6.7.1 +multiprocess==0.70.19 +mypy_extensions==1.1.0 +nbformat==5.10.4 +nest-asyncio==1.6.0 +networkx==3.4.2 +ninja==1.13.0 +nlopt==2.10.0 +numba==0.65.1 +numpy @ file:///home/conda/feedstock_root/build_artifacts/numpy_1747544640217/work/dist/numpy-2.2.6-cp310-cp310-linux_x86_64.whl#sha256=d6d964caeef85d00073d27cd62b46883d275b3d8162f723f0fcabbd0b3cc3f9d +nvidia-cublas-cu12==12.8.4.1 +nvidia-cuda-cupti-cu12==12.8.90 +nvidia-cuda-nvrtc-cu12==12.8.93 +nvidia-cuda-runtime-cu12==12.8.90 +nvidia-cudnn-cu12==9.10.2.21 +nvidia-cufft-cu12==11.3.3.83 +nvidia-cufile-cu12==1.13.1.3 +nvidia-curand-cu12==10.3.9.90 +nvidia-cusolver-cu12==11.7.3.90 +nvidia-cusparse-cu12==12.5.8.93 +nvidia-cusparselt-cu12==0.7.1 +nvidia-nccl-cu12==2.27.5 +nvidia-nvjitlink-cu12==12.8.93 +nvidia-nvshmem-cu12==3.4.5 +nvidia-nvtx-cu12==12.8.90 +open3d==0.19.0 +opencv-python==4.13.0.92 +opencv-python-headless==4.12.0.88 +OpenEXR==3.4.11 +orderly-set==5.5.0 +packaging==25.0 +pandas==2.3.3 +parso==0.8.7 +pexpect==4.9.0 +pfzy==0.3.4 +pillow==11.3.0 +pin==4.0.0 +pip @ file:///home/task_177498883471825/croot/pip_1774988882575/work +platformdirs==4.9.6 +plotly==5.24.1 +polyscope==2.6.1 +proglog==0.1.12 +prompt_toolkit==3.0.52 +propcache==0.5.2 +protobuf==6.33.6 +psutil==7.2.2 +ptyprocess==0.7.0 +pure_eval==0.2.3 +py-cpuinfo==9.0.0 +py-spy==0.4.2 +pyarrow==24.0.0 +pycollada==0.9.3 +pycparser==3.0 +pydantic==2.13.4 +pydantic_core==2.46.4 +PyGEL3D==0.6.1 +pyglet==2.1.14 +pygltflib==1.16.0 +Pygments==2.20.0 +pymeshlab==2025.7.post1 +pynput==1.8.2 +PyOpenGL==3.1.10 +pyparsing==3.3.2 +pyperclip==1.11.0 +PyQt6==6.11.0 +PyQt6-Qt6==6.11.0 +PyQt6_sip==13.11.1 +pyquaternion==0.9.9 +pyserial==3.5 +pysplashsurf==0.12.0.2 +python-dateutil==2.9.0.post0 +python-dotenv==1.2.2 +python-xlib==0.33 +pytransform3d==3.15.0 +pytz==2026.2 +pyuipc @ file:///tmp/claude-1005/-mnt4-gck-maniladder/9f005e67-04f6-4368-bd0e-9f40896c7dbf/scratchpad/pyuipc_dl/pyuipc-0.0.25-cp310-cp310-manylinux_2_34_x86_64.whl#sha256=76ff13554e1971ea4401db2c875369cf32352ae3a5a4c398c45193231b5cbf00 +PyYAML==6.0.3 +pyyaml-include==1.4.1 +referencing==0.37.0 +regex==2026.5.9 +requests==2.34.2 +rerun-sdk==0.26.2 +retrying==1.4.2 +rich==14.3.4 +rpds-py==0.30.0 +rtree==1.4.1 +safetensors==0.7.0 +sapien==3.0.3 +scikit-image==0.25.2 +scikit-learn==1.7.2 +scipy @ file:///home/conda/feedstock_root/build_artifacts/scipy-split_1739790642651/work/dist/scipy-1.15.2-cp310-cp310-linux_x86_64.whl#sha256=9e52bad6c3294d1a5b04a13632118ca2157130603c6c018c2d710162b223b27e +sentry-sdk==2.60.0 +setuptools==80.10.2 +shapely==2.1.2 +six==1.17.0 +smmap==5.0.3 +stack-data==0.6.3 +svg.path==7.0 +sympy==1.14.0 +tenacity==9.1.4 +termcolor==3.3.0 +tetgen==0.8.4 +threadpoolctl==3.6.0 +tifffile==2025.5.10 +timm==1.0.27 +toml==0.10.2 +torch==2.10.0 +torchaudio==2.11.0 +torchcodec==0.10.0 +torchvision==0.25.0 +tqdm==4.67.3 +traitlets==5.15.0 +transforms3d==0.4.2 +trimesh==4.12.2 +triton==3.6.0 +typeguard==4.5.2 +typing-inspect==0.9.0 +typing-inspection==0.4.2 +typing_extensions==4.15.0 +tyro==1.0.13 +tzdata==2026.2 +urllib3==2.7.0 +vhacdx==0.0.10 +viser==1.0.27 +vtk==9.6.1 +wandb==0.24.2 +wcwidth==0.7.0 +websockets==16.0 +Werkzeug==3.1.8 +wheel==0.46.3 +widgetsnbextension==4.0.15 +wrapt==2.1.2 +xxhash==3.7.0 +yarl==1.23.0 +yourdfpy==0.0.60 +z3-solver==4.16.0.0 +zipp==3.23.1 +zstandard==0.25.0 diff --git a/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/features.py b/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/features.py new file mode 100644 index 0000000000000000000000000000000000000000..81cfe0c748987ff8cbd1800a3f7ca1a15e7c2fa6 --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/features.py @@ -0,0 +1,26 @@ +"""Fixed, non-neural image descriptors. No model weights or scene calibration.""" +import cv2 +import numpy as np +CAMERAS = ('front_camera', 'left_camera', 'robot_camera', 'top_camera') + +def image_features(image): + x = np.asarray(image) + if x.ndim == 4 and x.shape[0] == 1: + x = x[0] + if x.ndim != 3 or x.shape[2] != 3 or x.dtype != np.uint8: + raise ValueError('Expected uint8 RGB HWC or 1HWC') + x = x.astype(np.float32) / 255. + small = cv2.resize(x, (16, 12), interpolation=cv2.INTER_AREA) + r, g, b = x.transpose(2, 0, 1) + masks = [(r > .35) & (r > 1.6*g) & (r > 1.6*b), + (g > .25) & (g > 1.4*r) & (g > 1.3*b), + (r > .5) & (g > .4) & (b < .55*g)] + parts = [small.ravel() * (2 / np.sqrt(small.size))] + for mask in masks: + yy, xx = np.nonzero(mask) + present = len(xx) >= 3 + moments = [xx.mean()/x.shape[1], yy.mean()/x.shape[0], + min(len(xx)/(.01*x.shape[0]*x.shape[1]), 1), 1] if present else [0,0,0,0] + parts.append(np.asarray(moments, np.float32)) + parts.append(cv2.resize(mask.astype(np.float32), (16,12), interpolation=cv2.INTER_AREA).ravel() * .5) + return np.concatenate(parts).astype(np.float32) diff --git a/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/findings.md b/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/findings.md new file mode 100644 index 0000000000000000000000000000000000000000..488225bd8a6dab27e4151fee212a5b75363aadb9 --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/findings.md @@ -0,0 +1,41 @@ +# Exploration ledger + +Budget checked before task access: 0/20. All environment interaction uses trusted API. + +Episode 1: integration failure at step 2. execute_actions returns an envelope with a steps list; the interactive driver initially expected an observation at the top level and finished early. Corrected the driver to unwrap steps[-1]. Candidate itself did not fail. Live images have twice the demo resolution; normalized descriptors support this. Initial front image shows hand adjacent to suspended red ring, retaining hook partly occluded. Native success false at returned step. This slot is spent and is not retried. + +Visible scoring rule preregistered: only mark true if legal images unambiguously show the suspended ring retained on the hook after the hand separates; ambiguous evidence is false. Native success, when returned, is reported separately and never invented. + +Episode 2: full 300 steps, native success false. Lift/outward pull and release occurred, but top view at step 200 showed ring clearly separated from retaining hook. Initial qpos matched demo initial qpos exactly. Hand qpos deviated strongly (mean normalized squared hand error >21 by end), while closest arm pose remained around demo frame106. Raw hand action labels accumulated beyond desired pose; no recovery after release. + +Episode 3: legal sequential +0.5/-0.5 three-step finger probes, 97 steps total including initial hold. Mapping from hand action indices 0..15 to hand qpos indices: [4,0,8,12,5,1,9,13,6,2,10,14,3,7,11,15]. Each isolated positive probe produced ~0.146rad dominant displacement in the mapped joint. No success attempt; saved deltas and terminal images. Mapping measured, not obtained from simulator internals. + +Practical plan after episodes1–3: retain visual/proprio nearest-label arm control, replace accumulated hand labels with qpos feedback toward two-frame demonstration lookahead. Lower hand/visual metric weights to reduce phase selection distortion. Test grip/pose and swing timing in episode4, then improve based on legal trajectory evidence. No recovery is claimed until tested. + +Episode4: hand feedback reduced normalized q distance to ~0.01 through prep. At live step80 nearest demo phase77; at step85 phase91 (premature phase jump), step95 phase97 with q distance7.83. Wrist joint rose to3.71rad versus demonstrated ~2.1rad and policy hit support hold; no recovery, native success false. Legal images show released ring away from hook. Next change gates retrieval within +/-2 demo frames of prior matched phase and reverses arm rotation labels to test sign mismatch; contract native negative scaling remains unchanged. + +Episode5: phase gate and reversed rotation labels still failed. Prep q distance ~.003–.08; live phase progressed too slowly and then repeated strong swing labels as joint error grew. At step120 arm q=[.19,-1.09,.63,-2.93,-.46,2.87,2.8], outside demo path. Finished at170 with native success false. Rotation sign alone does not fix pose control; phase matching is unstable around ballistic swing. Episode6 tests demo-clock arm phase with current-observation variant selection and hand feedback. This intentionally supersedes the original draft's no-clock design; no hidden identifiers are used. + +Episode6: timed phase with visual/proprio variant selection and reversed rotation failed at swing (native success false at160). At95 it selected y-rotation label magnitude.74 whereas demo00 at95 is.37; selecting different demonstrations at equal frame numbers mixed distinct swing timings. q support threshold held from100 onward. Episode7 removes variant mixing by using demo00 timed arm labels, original rotation sign, and measured finger feedback. This is a diagnostic single-path policy, not a claim of visual generalization. + +Episode7: single demo00 arm path with original rotations closely tracked until85, then wrist error grew to1.18rad and support hold engaged. Native success false at150. Thus eliminating phase/variant mixing is insufficient: label replay is sensitive to pose deviations. Analytical Panda serial-chain FK was written from general robot geometry to analyze legal qpos (kinematics only; no task simulator or environment instantiation). It shows initial live/demo translation increments match exactly. Episode8 probes native arm directions to validate FK-root action response before closed-loop pose correction. + +Episode8:37 native steps, six +.15/- .15 arm probes of3 steps each. XYZ measured FK displacements ~+.0176,.0177,.0179m on commanded axes. Rotation response ~-.065rad on commanded axes, confirming native negative rotation convention. No task completion attempt. FK tool-point offset is approximate; rotation induces some apparent translation, so no calibrated scene pose claim is made. Episode9 uses demo00 feedforward plus FK position gain10 and root rotation error gain-2, with current legal q feedback. The rotation sign flip hypothesis was rejected; original demo labels retained. + +Episode9: feedforward plus weak FK feedback failed during wrist acceleration; native success false at160. Prep pose error was <.001 normalized, finger error mostly <.01rad by80. At98 wrist error ~.83rad, so finger drift is no longer primary. Recovery did not occur before support hold. Episode10 replaces arm labels with next-demonstrated-pose feedback (position gain25, rotation gain-6), using the small-command measured response as gain guidance, and raises q support threshold to50 to allow correction. Analytic pose target is robot-relative; no image-derived object calibration is claimed. + +Episode10: direct next-pose servo solved gross wrist divergence (q distance .009 at98, .0025 aftersettling), but native success stayed false through160. Top/left images at100 and120 show ring hanging well short of the hook. At80 it remains adjacent to the hand and pulled outward. Localization: color descriptors only, camera viewpoints vary, no calibrated hook offset. Pose tracking alone does not guarantee ring engagement. Episode11 changes hand target from two-frame lookahead/gain8 to one-frame lookahead/gain10, seeking more faithful grasp/release timing. No successful recovery has been demonstrated. + +Episode11: one-frame finger tracking changed contact dynamics: q distance2.94 near98, then recovered to.127 by149 without support hold, but native success remained false. Top image120 shows ring near but not retained on hook. This is pose recovery, not task recovery. Testing other authorized demonstrated robot trajectories (five distinct paths) with same closed-loop pose/finger control in episodes12 onward; no scene ID or seed selection. + +Episode12: demo01 direct-pose/finger servo; native success false through160. Wrist stayed much closer during swing than failed label policies (.039 q distance at98), but ring fell short. Top100 shows ring under suspension anchor rather than on hook. Episode13 retains demo01 and adds .15rad closure on three non-thumb finger chains during phase20..95, removed at96. This tests engagement, not a validated grasp model. Hand joint ordering remains measured episode3 permutation. + +Episode13: demo01 +.15 finger closure bias, native success false through160. At95 left image ring already separates from hand and lies below hook; at105 it travels toward retaining post but remains too low. Bias did not establish capture. Episode14 adds smooth +.06m root-z preparation lift (ramps30–55, tapers88–102), preserving bounded actions and other feedback. This is an empirical swing-height modification; no ballistic model or simulator is used. + +Episode14: .06m preparation lift + closure bias, native success false through170. Ring approached hook in top view but no retention; pose correction remained operational. Episode15 uses demo04 (fifth distinct motion) with direct pose/finger tracking, no added lift or closure bias. Slots16–20 are reserved for independent exact-bundle rehearsals. No successful capture has yet been established; ambiguous appearances are false under preregistered rule. + +Episode15: demo04 direct pose/finger feedback, native success false through170. q error stayed below.14 after swing rather than diverging into hold. This is the selected runnable development line for independent validation; no success claim is made. Comments/docs were reconciled with implemented behavior; no new control behavior was added before rehearsal16. + +## Pre-rehearsal assessment + +Localization: legal RGB fixed descriptors detect broad color/layout support; no calibrated ring/hook pose or robust completion detector. Pose: analytic FK servo greatly reduces the large wrist divergence seen with retrieved labels; FK offset is approximate. Grasp: measured joint mapping eliminates raw-delta drift, but contact/capture remains unreliable; closure bias and lift did not establish success. Timing: timed single-demo reference avoids repeated ballistic labels and cross-demo phase mixing. Recovery: pose correction may converge after swing, but no regrasp or repeat swing is implemented; hold fallback cannot accomplish the task. Program failure: episode1 driver envelope mismatch was fixed and charged. All15 interactive slots and all authorized demo-derived artifacts are preserved. Independent exact-bundle validation is still required; remaining5 slots are allocated to it. diff --git a/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/freeze_manifest.json b/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/freeze_manifest.json new file mode 100644 index 0000000000000000000000000000000000000000..c8049e925504f3a99d3ffd5e6028daef75182663 --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/freeze_manifest.json @@ -0,0 +1,96 @@ +{ + "files": { + "__pycache__/build_bank.cpython-310.pyc": "d343eac4e2dd03014e9086c46b35b3e0c7f7bdc2d8895186d6c0970b3b94b518", + "__pycache__/check_synthetic.cpython-310.pyc": "6cf3c4f735db7f7f34b9137a8369249967f52eb5e31c7d2a5347d53ee41ab139", + "__pycache__/controller.cpython-310.pyc": "f509f1c5f6ceea97c33c074c3c08557673af70d2a43a5b4682065d612e0c37df", + "__pycache__/features.cpython-310.pyc": "20ee129179d4597d0b430c12d6a5a9e89db9bfeeb7aadf23ff53eb0c7aa140a1", + "bank.npz": "f2ae657e57f0e1c62ce6b0573a1ff8a88c791fab967d750c4cc1cc1bcaece826", + "build_bank.py": "a5075544da962f1fd00a76b411393d4feb6b7abc46ed9542893d7fc94c7d2f83", + "check_synthetic.py": "4deecd2848653c8393801349c8d823660ec218339467020574e2e63467f3b190", + "controller.py": "4380076e1096865517f8f648fc78b4ad17bd00d909653b2c4985169e451c4d47", + "data_digests.json": "a06009391b6f7a0ef92967e76366344aa82b5df58b99ae683e6216f2bc479f5d", + "demo_manifest.json": "378ed825a4ecd1bea2392b15a24fdb08c3961100a010abcb3ca13d6012602652", + "demonstrations_readonly/demo_00.h5": "32027094b90b832c8c5d996168f980a94f6dc681382efd4f99122e3ee285b2de", + "demonstrations_readonly/demo_01.h5": "f16779da596aa643a6ac1f436c86305a3e3eb748bcdf4594ce7731d71cd2fae1", + "demonstrations_readonly/demo_02.h5": "addc4dc8a5a5f15dd3b430fa846ed337af747866236efd9d0c35d99292340b7d", + "demonstrations_readonly/demo_03.h5": "61b52f3082f2ae4ab5460ebef32964ff3c46186bd56889e6f16e9cce9e3b3ceb", + "demonstrations_readonly/demo_04.h5": "0c6878d6275b38d18c77a282926def0899669b9b9a7423325f02888bcce7fca3", + "demonstrations_readonly/demo_05.h5": "f5505d338ead7de84a0ecbf8779c5e575ead35268045910f199100b2f8a44e02", + "demonstrations_readonly/demo_06.h5": "6ca2c72af0acc8536331190d797d66576133855b96ca5d2737567cf6c2ac5dfe", + "demonstrations_readonly/demo_07.h5": "874d599bf6418ce249f55298b1c6002f4edf660c2c693309b1f69034e34e10df", + "demonstrations_readonly/demo_08.h5": "c9ac0a53a001f3f90e54179447fbe650c9ca5602abcf700707d77d5e415abad5", + "demonstrations_readonly/demo_09.h5": "3947bcd522127c46691e9d512c30eb82af5ff7340171503568823e288db5552f", + "demonstrations_readonly/demo_10.h5": "37b5bacacff1711d83c674029929bf31c35957ca8724600275f04a5322394277", + "demonstrations_readonly/demo_11.h5": "8b53728ba7427cfec80235ff64e1bfa66a935e2e3faa73fb00b7d49ef215f58d", + "demonstrations_readonly/demo_12.h5": "4241cefe99af9d6801ca66478425b099f8144545ae58ef768c4c1613973ddf37", + "demonstrations_readonly/demo_13.h5": "09ea5f05aac1530a442813af179ea15af46634f9b134e488f98a1bf93dec675d", + "demonstrations_readonly/demo_14.h5": "5c274b5856264852b6fc4f5b31032ceeccf7e43e1bf6a24cae8b85039e49f191", + "demonstrations_readonly/demo_15.h5": "b7c99599a0ba49abb0ffc60c6c9b8354dd4d05a17111c1d736e74440ea9322d1", + "demonstrations_readonly/demo_16.h5": "e9b31caf8323c348dfb6f50f1c2c183478cd124dc654045eb5607422f14a7a4c", + "demonstrations_readonly/demo_17.h5": "3a720b9fc8282f23167a27f807e9cfb530f5e31b502c5fbc67161b49cb27b419", + "demonstrations_readonly/demo_18.h5": "47105464bee6ae8c1c3bb985ed4d23383c67bbe2a9596c0ede0d34e1b401c57f", + "demonstrations_readonly/demo_19.h5": "dc613c10b03c817c13987d3f35c812c5937b95b86407b2f4d230819201f25fc2", + "environment.lock": "f9f11f093744865020243315494d48c69e38ff9e67783e7cf5f0a1e5f22b34aa", + "features.py": "b35d733a4adf5115c546d15783ed69c98d792a66386aad45492cb011ec5d8a87", + "findings.md": "9d804a0ab7b3df27a0163f60e46cd8f2cc4dbe7c2e4da7258ad00c7a988a9125", + "handoff.md": "d59404d137c175991c681b3dfc2b998c8db73f5b4d0227b62c3e5788ff879de0", + "kinematics.py": "42c833e6a84493f7c017ec508e26b7532301ea191b8289467b7be88d8df24fbf", + "model_tool_manifest.yaml": "9c5b36b3eb64d99576e48e9b7314f2a3ed3defc683eca9374bd1c43f575c92be", + "policy_runner.py": "cd8a30fc763583fb9bf6570414f01d56aba16241c733fc0cdfdfab0f8f27270e", + "skills.md": "6b933296747c6a89bc69611cf89f9c1612d9335cc7e8d8cbd64ef9bdadf70af3", + "worker_api.py": "88cca5fa5c1c9570ca2bd90e8848f67c09224fa498d94e63634ad191e913c41e" + }, + "bundle_hash": "d3e2e02cc3270fd7b36b8235dd518e014398ea48fc4be4eb3b05def39747f0e0", + "exploration_ledger_hash": "8841b2734b29cbac91eeaeba66f607a6922d20ce5a5b3d26494b81317c0c6c08", + "entrypoint": "controller.reset_episode(); controller.act(obs)", + "selection": { + "rule": "exact-version success rate, valid rehearsal count, recency", + "rehearsals": [ + { + "episode": 16, + "bundle_hash": "d3e2e02cc3270fd7b36b8235dd518e014398ea48fc4be4eb3b05def39747f0e0", + "independent": true, + "valid": true, + "status": "finished", + "success": false, + "score_source": "native_step_feedback" + }, + { + "episode": 17, + "bundle_hash": "d3e2e02cc3270fd7b36b8235dd518e014398ea48fc4be4eb3b05def39747f0e0", + "independent": true, + "valid": true, + "status": "finished", + "success": false, + "score_source": "native_step_feedback" + }, + { + "episode": 18, + "bundle_hash": "d3e2e02cc3270fd7b36b8235dd518e014398ea48fc4be4eb3b05def39747f0e0", + "independent": true, + "valid": true, + "status": "finished", + "success": false, + "score_source": "native_step_feedback" + }, + { + "episode": 19, + "bundle_hash": "d3e2e02cc3270fd7b36b8235dd518e014398ea48fc4be4eb3b05def39747f0e0", + "independent": true, + "valid": true, + "status": "finished", + "success": false, + "score_source": "native_step_feedback" + }, + { + "episode": 20, + "bundle_hash": "d3e2e02cc3270fd7b36b8235dd518e014398ea48fc4be4eb3b05def39747f0e0", + "independent": true, + "valid": true, + "status": "finished", + "success": false, + "score_source": "native_step_feedback" + } + ] + } +} diff --git a/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/handoff.md b/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/handoff.md new file mode 100644 index 0000000000000000000000000000000000000000..fa37d7a4ce8866ed8374186f4cadf2edf92b5196 --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/handoff.md @@ -0,0 +1,9 @@ +# Offline executable handoff + +Entrypoints: controller.py reset_episode() and act(obs). Runtime files: controller.py, features.py, kinematics.py, bank.npz. Dependencies: Python standard library, NumPy, OpenCV. No network, development agent, simulator, external model, or mutable neural weights are used. + +Input: legal RGB camera arrays and proprioception agent/qpos and agent/qvel (23 values), plus optional step_id. Output: float32 normalized22-vector; None only at horizon exhaustion. First action follows runner-owned charged hold; at most299 subsequent actions. The controller does not infer success. + +The bank contains all20 authorized demos; runtime follows demo04's200-frame pose path with current-q feedback and visual support checks. It holds the last pose reference after the path finishes. Analytic robot transforms are used only for FK feedback, not as a task simulator. Hand action permutation came from legal episode3 probes; native arm sign was checked in episode8. + +Exploration versions and evidence remain outside this bundle in /workspace/versions and /workspace/exploration. Findings document failed grasp, timing, pose, and recovery attempts. Independent rehearsal results and exact bundle hashes are recorded by the trusted runner and in the external audit ledger. Success must come from native returns or the preregistered strict visible rule; ambiguous evidence is false. No reliable missed-ring recovery exists. diff --git a/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/kinematics.py b/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/kinematics.py new file mode 100644 index 0000000000000000000000000000000000000000..319ba1a12187fe00d5a8a02fe7be7780972e4333 --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/kinematics.py @@ -0,0 +1,10 @@ +import numpy as np +# Analytic serial-chain robot transforms, no simulation or environment instantiation. +XYZ=[[0,0,.333],[0,0,0],[0,-.316,0],[.0825,0,0],[-.0825,.384,0],[0,0,0],[.088,0,0]] +RX=[0,-np.pi/2,np.pi/2,np.pi/2,-np.pi/2,np.pi/2,np.pi/2] +def fk(q): + T=np.eye(4) + for qi,xyz,rx in zip(q,XYZ,RX): + c,s=np.cos(rx),np.sin(rx);A=np.eye(4);A[:3,3]=xyz;A[:3,:3]=[[1,0,0],[0,c,-s],[0,s,c]] + c,s=np.cos(qi),np.sin(qi);B=np.eye(4);B[:3,:3]=[[c,-s,0],[s,c,0],[0,0,1]];T=T@A@B + T[:3,3]+=T[:3,:3]@np.array([0,0,.107]);return T diff --git a/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/model_tool_manifest.yaml b/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/model_tool_manifest.yaml new file mode 100644 index 0000000000000000000000000000000000000000..cc44a3b35de9c097d9b8ae65e600cbd3e57ff28e --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/model_tool_manifest.yaml @@ -0,0 +1,92 @@ +{ + "status": "prepared_for_independent_rehearsal", + "task": "SwingRing-v1", + "worker": "Agent-D20-E20-Compiled", + "versions": { + "python": "3.10.20", + "numpy": "2.2.6", + "opencv": "4.12.0" + }, + "runtime_dependencies": [ + "Python standard library", + "numpy", + "opencv" + ], + "preparation_dependencies": [ + "h5py", + "worker_api.API.read_demo" + ], + "tools_used": [ + "exec_command: local bash/Python scripts and py_compile", + "view_image: legal RGB contact sheets", + "worker_api.API.read_demo: authorized local demo fields only" + ], + "data_provenance": { + "contract": "/task_contract.json", + "demo_manifest": "/demo_manifest.json", + "demo_ids": [ + "demo_00", + "demo_01", + "demo_02", + "demo_03", + "demo_04", + "demo_05", + "demo_06", + "demo_07", + "demo_08", + "demo_09", + "demo_10", + "demo_11", + "demo_12", + "demo_13", + "demo_14", + "demo_15", + "demo_16", + "demo_17", + "demo_18", + "demo_19" + ], + "root": "/demonstrations", + "action_samples": 3964, + "accessed_fields": [ + "actions", + "obs/agent/qpos", + "obs/agent/qvel", + "obs/sensor_data/front_camera/rgb", + "obs/sensor_data/left_camera/rgb", + "obs/sensor_data/robot_camera/rgb", + "obs/sensor_data/top_camera/rgb" + ] + }, + "weights": { + "neural_models_loaded": false, + "pretrained_tool_weights_loaded": false, + "weight_updates": false, + "frozen_weight_references": [], + "note": "No external weight artifacts used. Coding assistant identity/version beyond provider session is not available in workspace; its weights were not modified." + }, + "method": "Timed demo04 robot pose reference with analytical FK closed-loop arm feedback, measured hand permutation and qpos feedback, fixed RGB support check", + "network_calls": 0, + "environment_calls": "Only /worker_api.py trusted API", + "exploration_episodes": "15 interactive slots before independent rehearsals; surviving budget is authoritative", + "tests": [ + "Python AST syntax parsing", + "Trusted API exploration; external audit ledger" + ], + "limitations": [ + "No verified capture in interactive exploration", + "No calibrated object localization", + "No regrasp/retry recovery", + "Camera/support thresholds heuristic", + "Robot FK tool offset approximate" + ], + "runner_supplies": [ + "verified demo manifest", + "common environment lock" + ], + "input_file_sha256": { + "/worker_api.py": "88cca5fa5c1c9570ca2bd90e8848f67c09224fa498d94e63634ad191e913c41e", + "/task_contract.json": "d7b731de3a6e884b78775e865147c4bb8822ffa2f23ae699a251838dd9554a02", + "/demo_manifest.json": "992a94800bdd9f1288b9b5e9321526adaa2500554a003c613fe4cf5894d25e44" + } +} \ No newline at end of file diff --git a/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/policy_runner.py b/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/policy_runner.py new file mode 100644 index 0000000000000000000000000000000000000000..e49448d6245feb7818ae505f1061708ab97c6ead --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/policy_runner.py @@ -0,0 +1,25 @@ +"""Frozen-program entry point; no development agent and no reset capability.""" +import importlib.util +import sys + +sys.path.insert(0,'/artifact') +sys.path.insert(0,'/') +from worker_api import API + + +def main(): + spec=importlib.util.spec_from_file_location('controller','/artifact/controller.py') + module=importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + module.reset_episode() + api=API() + result=api.latest_observation() + while not (result['terminated'] or result['truncated'] or result['horizon_reached']): + obs=dict(result['observation'],step_id=result['step_id']) + action=module.act(obs) + if action is None:break + response=api.execute_actions([action]) + result=response['steps'][-1] + + +if __name__=='__main__':main() diff --git a/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/skills.md b/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/skills.md new file mode 100644 index 0000000000000000000000000000000000000000..0a86a8a2b99fa352b4941dc62b9a29a80f7d5c52 --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/skills.md @@ -0,0 +1,8 @@ +# Implemented mechanisms and limits + +- Read legal RGB and 23-joint qpos/qvel. Fixed color/thumbnail descriptors provide a support check; they do not yield calibrated ring/hook pose. +- Follow the timed robot-pose reference from authorized demo04, with current-q analytical serial-chain position/orientation feedback. Root XYZ gain25 and rotation-error gain-6 produce native normalized deltas. Native negative rotation response was probed in episode8. +- Track the next demonstrated finger pose with gain10 and the action/qpos permutation measured in episode3. This is feedback control, not raw hand-label replay. +- Keep actions finite and within[-1,1], hold on malformed or unsupported observations, and stop at native horizon300 including runner-owned hold. + +Pose correction sometimes recovers joint error after the swing. Regrasping a missed ring, retrying a swing, stable hook localization, and completion detection are not implemented or claimed. Exploration had not established capture before independent rehearsals. No neural models or network tools are needed. diff --git a/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/worker_api.py b/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/worker_api.py new file mode 100644 index 0000000000000000000000000000000000000000..ff137d1c68cb70a1549326d2d22b430c9cf4e20c --- /dev/null +++ b/agent_d20_e20/frozen_20261102/tasks/SwingRing-v1/frozen/worker_api.py @@ -0,0 +1,81 @@ +"""Standalone worker client; safe to mount without the runner package.""" +import base64 +import json +import socket +import struct +import uuid +import os +from pathlib import Path + +import numpy as np + + +def array_hook(value): + if value.get('__array__') is True: + dtype=np.dtype(value['dtype']) + if dtype.kind not in 'bifu':raise ValueError('non-numeric array from service') + raw=base64.b64decode(value['data'],validate=True) + return np.frombuffer(raw,dtype=dtype).reshape(value['shape']).copy() + return value + + +class API: + def __init__(self,socket_path='/rpc/control.sock',demo_root='/demonstrations',manifest='/demo_manifest.json'): + self.socket_path=socket_path + self.demo_root=Path(demo_root) + self.manifest=Path(manifest) + + def call(self,method,arguments=None,request_id=None): + # Caller can persist a request ID before sending. Never automatically retry. + request_id=request_id or str(uuid.uuid4()) + request={'request_id':request_id,'method':method,'arguments':arguments or {}} + if os.environ.get('AGENT_E20_RPC_TOKEN'): + request['token']=os.environ['AGENT_E20_RPC_TOKEN'] + payload=json.dumps(request,allow_nan=False).encode() + if len(payload)>65536:raise ValueError('request too large') + with socket.socket(socket.AF_UNIX,socket.SOCK_STREAM) as s: + s.settimeout(1810);s.connect(self.socket_path) + s.sendall(struct.pack('!I',len(payload))+payload) + def exact(n): + chunks=[] + while n: + chunk=s.recv(min(n,1024*1024)) + if not chunk:raise RuntimeError('RPC interrupted; do not replay action with a new ID') + chunks.append(chunk);n-=len(chunk) + return b''.join(chunks) + length=struct.unpack('!I',exact(4))[0] + if length>64*1024*1024:raise RuntimeError('response too large') + result=json.loads(exact(length),object_hook=array_hook) + if not result['ok']:raise RuntimeError(result['error']) + return result['result'] + + def next_episode(self,request_id=None):return self.call('next_episode',request_id=request_id) + def latest_observation(self):return self.call('latest_observation') + def execute_actions(self,actions,request_id=None): + return self.call('execute_actions',{'actions':np.asarray(actions).tolist()},request_id) + def finish_episode(self):return self.call('finish_episode') + def budget_status(self):return self.call('budget_status') + def rehearse(self,candidate='candidate',request_id=None): + return self.call('rehearse',{'candidate':candidate},request_id) + def score_rehearsal(self,episode,visible_success,evidence): + return self.call('score_rehearsal',{'episode':episode,'visible_success':visible_success,'evidence':evidence}) + def freeze(self):return self.call('freeze') + + def read_demo(self,demo_id,start=0,stop=None,fields=None): + import h5py + manifest=json.loads(self.manifest.read_text()) + if manifest.get('status') not in ('released','released_for_offline_analysis'): + raise RuntimeError('demonstrations not released by trusted preflight') + entries={e['demo_id']:e for e in manifest['episodes']} + if demo_id not in entries:raise ValueError('unauthorized demo ID') + entry=entries[demo_id] + allowed={f['path'] for f in entry['fields']} + fields=sorted(allowed) if fields is None else fields + if not set(fields)<=allowed:raise ValueError('unauthorized demo field') + stop=entry['length']+1 if stop is None else stop + if not isinstance(start,int) or not isinstance(stop,int) or not 0<=start