diff --git a/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/REPORT.md b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/REPORT.md new file mode 100644 index 0000000000000000000000000000000000000000..7f2af02a5f64a7ae2fdb82b2a93c6eaac45fb57d --- /dev/null +++ b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/REPORT.md @@ -0,0 +1,20 @@ +# QwenOFT mean-trained checkpoints under profile simulation + +Four final step-5000 H1 checkpoints; two rounds, one evaluation per physical GPU2/3,100 episodes each (400 total). + +The training latency was fixed mean; this evaluation samples the complete archived RTX3090 temporal hidden-regime profile. Simulator FPS, seeds, horizon, limits and model/profile identities are in evaluation-plan.json. Standard deviations below use ddof=0. Returns have task-specific scales. Startup checks are separate and excluded. + +| Task | Episodes | Return mean +/- SD | Length mean +/- SD | Success | Invalid | +|---|---:|---:|---:|---:|---:| +| flappy | 100 | 384.824005 +/- 116.787774 | 3119.31 +/- 939.87 | not provided by task | 0 | +| deadly_corridor | 100 | 1620.798776 +/- 913.624278 | 148.53 +/- 49.46 | not provided by task | 0 | +| ant | 100 | 1453.844064 +/- 693.727520 | 803.85 +/- 328.81 | not provided by task | 0 | +| intercept | 100 | 3.544349 +/- 7.071923 | 60.00 +/- 0.00 | 9/100 | 0 | + +No success metric is invented for Flappy/Deadly/Ant. Intercept reports the native accumulated success flag. No policy-quality acceptance gate is claimed. + +Compatibility repairs: portable robot_type copied from each actual training manifest (weights unchanged); official ViZDoom1.2.4 VizdoomCorridor-v0 uses the same deadly_corridor WAD as SF, preserves render contract and semantic seven-button ordering; public action space is equivalent MultiBinary7. Existing native render/button/history tests passed. Full eval source/patch and original profile assets are archived. + +Flappy/Deadly seeds1000000..1000099; Ant42..141; Intercept4242424242..4242424341. Latency seed271828. Flappy10/10Hz, Deadly35/8.75Hz, Ant10/10Hz, Intercept20/20Hz. Max raw frames3600/3600/1000/60; capacities1. MIKASA H1 holds last chunk action; no prefix, no DAgger. Ant keeps its training prompt label1 while execution latency is sampled. + +Raw JSONL logs are losslessly gzip-compressed for distribution; original uncompressed records remain on the experiment host. Empty observation_attempts files are retained; admission/drop evidence is in steps/actions. Per-task CSV and full400 episode CSV are provided. diff --git a/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/all_episodes.csv b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/all_episodes.csv new file mode 100644 index 0000000000000000000000000000000000000000..be5e27101cb97f6a2dd0d85a0399d3fb8a5ea839 --- /dev/null +++ b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/all_episodes.csv @@ -0,0 +1,401 @@ +task,episode_id,seed,return_env,length,mean_latency_ms,success +flappy,0,1000000,444.6000052243471,3600,76.02271694866694, +flappy,1,1000001,444.6000052243471,3600,76.14445348705047, +flappy,2,1000002,444.6000052243471,3600,75.83047266244563, +flappy,3,1000003,444.6000052243471,3600,76.04121221698036, +flappy,4,1000004,444.6000052243471,3600,75.7789115791707, +flappy,5,1000005,228.2000027000904,1861,76.22757676162651, +flappy,6,1000006,444.6000052243471,3600,75.98373978309758, +flappy,7,1000007,444.6000052243471,3600,75.85552109823348, +flappy,8,1000008,444.6000052243471,3600,75.9782303085917, +flappy,9,1000009,444.6000052243471,3600,75.94667987356688, +flappy,10,1000010,444.6000052243471,3600,75.66396359484234, +flappy,11,1000011,444.6000052243471,3600,75.7794525026407, +flappy,12,1000012,444.6000052243471,3600,75.90110110734818, +flappy,13,1000013,444.6000052243471,3600,76.01870178237883, +flappy,14,1000014,444.6000052243471,3600,75.75567207010911, +flappy,15,1000015,444.6000052243471,3600,75.83026036637241, +flappy,16,1000016,444.6000052243471,3600,75.74502908171665, +flappy,17,1000017,444.6000052243471,3600,75.84316844302293, +flappy,18,1000018,444.6000052243471,3600,75.85876738771161, +flappy,19,1000019,265.50000313669443,2162,75.89492798135642, +flappy,20,1000020,444.6000052243471,3600,75.90859756288593, +flappy,21,1000021,444.6000052243471,3600,75.93474621914784, +flappy,22,1000022,444.6000052243471,3600,75.77022360156529, +flappy,23,1000023,444.6000052243471,3600,75.8506098974935, +flappy,24,1000024,444.6000052243471,3600,75.80511776716725, +flappy,25,1000025,116.00000138580799,955,76.07937915327228, +flappy,26,1000026,444.6000052243471,3600,75.77409482659607, +flappy,27,1000027,444.6000052243471,3600,75.82354466933252, +flappy,28,1000028,444.6000052243471,3600,75.92578714415393, +flappy,29,1000029,444.6000052243471,3600,75.77326038618416, +flappy,30,1000030,256.0000030249357,2085,75.8461606092662, +flappy,31,1000031,444.6000052243471,3600,75.87053786258159, +flappy,32,1000032,444.6000052243471,3600,75.90930861144982, +flappy,33,1000033,444.6000052243471,3600,75.80530422686525, +flappy,34,1000034,444.6000052243471,3600,76.05997569829616, +flappy,35,1000035,444.6000052243471,3600,75.67579907153437, +flappy,36,1000036,444.6000052243471,3600,76.07561842170198, +flappy,37,1000037,444.6000052243471,3600,75.87459102177027, +flappy,38,1000038,55.60000067949295,468,75.8887188983619, +flappy,39,1000039,444.6000052243471,3600,75.86536772802552, +flappy,40,1000040,432.900005094707,3512,76.00355652525975, +flappy,41,1000041,274.8000032454729,2237,75.7658282850597, +flappy,42,1000042,264.90000312775373,2156,75.95264956954799, +flappy,43,1000043,265.4000031352043,2161,75.82748305801191, +flappy,44,1000044,444.6000052243471,3600,75.9295822845668, +flappy,45,1000045,143.90000171214342,1180,75.94310218110371, +flappy,46,1000046,444.6000052243471,3600,75.69568531179425, +flappy,47,1000047,93.1000011190772,771,76.0527875505066, +flappy,48,1000048,56.10000068694353,473,76.20882901957174, +flappy,49,1000049,265.2000031322241,2159,76.05401077635972, +flappy,50,1000050,444.6000052243471,3600,75.89333271844873, +flappy,51,1000051,444.6000052243471,3600,75.89090159365671, +flappy,52,1000052,398.80000469088554,3234,75.91218218803246, +flappy,53,1000053,444.6000052243471,3600,75.86400590251726, +flappy,54,1000054,270.2000031918287,2200,76.01590238337654, +flappy,55,1000055,69.70000084489584,582,75.68422480575155, +flappy,56,1000056,444.6000052243471,3600,75.87884524455251, +flappy,57,1000057,444.6000052243471,3600,75.96981187494319, +flappy,58,1000058,444.6000052243471,3600,76.03772455115222, +flappy,59,1000059,437.90000515431166,3553,76.04088529786887, +flappy,60,1000060,348.9000041112304,2834,75.79422825165413, +flappy,61,1000061,444.6000052243471,3600,75.87728099437057, +flappy,62,1000062,78.9000009521842,656,75.96352981662133, +flappy,63,1000063,444.6000052243471,3600,75.80269270184165, +flappy,64,1000064,444.6000052243471,3600,75.88518180564401, +flappy,65,1000065,444.6000052243471,3600,75.87533034544981, +flappy,66,1000066,444.6000052243471,3600,75.94241138050401, +flappy,67,1000067,444.6000052243471,3600,75.95312277771471, +flappy,68,1000068,444.6000052243471,3600,75.8998829764233, +flappy,69,1000069,444.6000052243471,3600,75.98564617573034, +flappy,70,1000070,444.6000052243471,3600,75.68328575087021, +flappy,71,1000071,135.0000016093254,1109,75.99546963217229, +flappy,72,1000072,444.6000052243471,3600,75.9923106611263, +flappy,73,1000073,444.6000052243471,3600,75.80422251719546, +flappy,74,1000074,444.6000052243471,3600,75.95469853250815, +flappy,75,1000075,444.6000052243471,3600,75.74551875442629, +flappy,76,1000076,444.6000052243471,3600,75.93301571087362, +flappy,77,1000077,444.6000052243471,3600,75.98384926019328, +flappy,78,1000078,444.6000052243471,3600,75.85055115368883, +flappy,79,1000079,444.6000052243471,3600,75.97142616222317, +flappy,80,1000080,444.6000052243471,3600,75.97039764106849, +flappy,81,1000081,444.6000052243471,3600,75.74469321422862, +flappy,82,1000082,116.20000138878822,957,76.0366526049804, +flappy,83,1000083,444.6000052243471,3600,75.95924386190674, +flappy,84,1000084,444.6000052243471,3600,76.0310580385874, +flappy,85,1000085,36.60000045597553,314,75.8634823847272, +flappy,86,1000086,260.90000308305025,2125,75.91783880059099, +flappy,87,1000087,444.6000052243471,3600,76.16752514785735, +flappy,88,1000088,444.6000052243471,3600,75.83331254385584, +flappy,89,1000089,444.6000052243471,3600,76.2113387300584, +flappy,90,1000090,444.6000052243471,3600,75.8334932097261, +flappy,91,1000091,225.20000265538692,1831,75.75618859671614, +flappy,92,1000092,444.6000052243471,3600,75.79683788505955, +flappy,93,1000093,180.9000021442771,1478,75.96465307644473, +flappy,94,1000094,305.2000035941601,2478,75.86565754734926, +flappy,95,1000095,444.6000052243471,3600,75.74523644464854, +flappy,96,1000096,444.6000052243471,3600,75.94353591524424, +flappy,97,1000097,444.6000052243471,3600,75.81927739599219, +flappy,98,1000098,444.6000052243471,3600,75.96229410618645, +flappy,99,1000099,444.6000052243471,3600,75.94512877548694, +deadly_corridor,0,1000000,337.47547912597656,72,71.90727374040254, +deadly_corridor,1,1000001,819.0284423828125,143,73.84762082340946, +deadly_corridor,2,1000002,2284.857650756836,182,72.79171012339609, +deadly_corridor,3,1000003,2276.2068634033203,189,76.345275285376, +deadly_corridor,4,1000004,805.2153015136719,150,73.86282581373551, +deadly_corridor,5,1000005,621.8231658935547,115,74.31105893586228, +deadly_corridor,6,1000006,2276.414749145508,176,74.2226331369995, +deadly_corridor,7,1000007,2284.310989379883,176,72.9072057957754, +deadly_corridor,8,1000008,81.07798767089844,49,73.20258272646697, +deadly_corridor,9,1000009,317.2351837158203,75,72.54774919154028, +deadly_corridor,10,1000010,2282.7608489990234,176,72.78293151689127, +deadly_corridor,11,1000011,88.11907958984375,45,72.60486105128022, +deadly_corridor,12,1000012,2281.468536376953,176,72.29193331603048, +deadly_corridor,13,1000013,2276.6868591308594,178,72.73330265771509, +deadly_corridor,14,1000014,2276.1705932617188,178,73.30067987408609, +deadly_corridor,15,1000015,2282.6631622314453,177,72.49405489224537, +deadly_corridor,16,1000016,2280.300033569336,172,72.80884970803692, +deadly_corridor,17,1000017,2280.4182891845703,182,73.03539182090206, +deadly_corridor,18,1000018,2281.2594451904297,177,72.50972089313564, +deadly_corridor,19,1000019,479.8523712158203,99,72.58046231642126, +deadly_corridor,20,1000020,2279.7379455566406,181,72.47468246266928, +deadly_corridor,21,1000021,2284.9097442626953,197,83.18983231769475, +deadly_corridor,22,1000022,2286.2730407714844,172,72.84281562147524, +deadly_corridor,23,1000023,244.51919555664062,74,76.23461799191558, +deadly_corridor,24,1000024,2279.957275390625,195,72.94927214021655, +deadly_corridor,25,1000025,2283.952178955078,179,73.18968843008061, +deadly_corridor,26,1000026,2276.701370239258,178,72.87702909462648, +deadly_corridor,27,1000027,2277.142562866211,190,72.45412386128042, +deadly_corridor,28,1000028,2279.025634765625,177,74.11102172804317, +deadly_corridor,29,1000029,2285.7152099609375,177,71.63189230597281, +deadly_corridor,30,1000030,53.374298095703125,44,72.51418721312025, +deadly_corridor,31,1000031,2279.8080444335938,183,72.72702656843174, +deadly_corridor,32,1000032,2282.307357788086,178,74.33584751930213, +deadly_corridor,33,1000033,2282.834014892578,192,73.95005063555192, +deadly_corridor,34,1000034,2284.200241088867,188,76.29368894499888, +deadly_corridor,35,1000035,2287.2159118652344,179,72.81890806090988, +deadly_corridor,36,1000036,2284.693832397461,183,76.28284599973325, +deadly_corridor,37,1000037,2283.2066650390625,178,72.1797344044525, +deadly_corridor,38,1000038,2281.032196044922,178,73.74343783824916, +deadly_corridor,39,1000039,2282.960678100586,190,73.24816830891406, +deadly_corridor,40,1000040,2287.094253540039,185,72.35711232966574, +deadly_corridor,41,1000041,2279.3030853271484,179,72.42125368367608, +deadly_corridor,42,1000042,440.0892791748047,104,73.92064892672727, +deadly_corridor,43,1000043,2280.8592529296875,177,72.36020918178356, +deadly_corridor,44,1000044,2283.4308471679688,189,75.93658060557208, +deadly_corridor,45,1000045,2282.324264526367,181,73.54224681770178, +deadly_corridor,46,1000046,326.0184631347656,74,73.1983876441008, +deadly_corridor,47,1000047,2279.086135864258,182,73.00958120503027, +deadly_corridor,48,1000048,2280.3804626464844,179,73.17268244992928, +deadly_corridor,49,1000049,2276.215301513672,189,75.47590644230628, +deadly_corridor,50,1000050,2278.132034301758,182,74.50495464842548, +deadly_corridor,51,1000051,2285.6056518554688,181,73.41699294418743, +deadly_corridor,52,1000052,2287.240921020508,173,73.22110809114655, +deadly_corridor,53,1000053,310.81517028808594,73,74.09003681120738, +deadly_corridor,54,1000054,2276.6219787597656,175,72.98605010243534, +deadly_corridor,55,1000055,2276.2769470214844,194,75.17704077845171, +deadly_corridor,56,1000056,2278.861602783203,178,72.97353037051572, +deadly_corridor,57,1000057,2279.728561401367,181,73.96913002154926, +deadly_corridor,58,1000058,2280.544464111328,176,73.02432805290651, +deadly_corridor,59,1000059,487.829833984375,108,78.89398217393664, +deadly_corridor,60,1000060,567.0655517578125,113,72.64874721482185, +deadly_corridor,61,1000061,2278.210220336914,177,72.96068484971086, +deadly_corridor,62,1000062,2281.436721801758,186,75.46710866924751, +deadly_corridor,63,1000063,382.2119903564453,89,81.21157315209366, +deadly_corridor,64,1000064,246.2946014404297,70,73.9736408486285, +deadly_corridor,65,1000065,285.21240234375,76,73.13661133681993, +deadly_corridor,66,1000066,310.6737365722656,75,73.40468658737086, +deadly_corridor,67,1000067,346.1162872314453,75,72.1929723632303, +deadly_corridor,68,1000068,804.7056121826172,150,73.76397959753224, +deadly_corridor,69,1000069,2285.6442108154297,184,75.13255757158333, +deadly_corridor,70,1000070,730.5995788574219,132,73.25446825350764, +deadly_corridor,71,1000071,86.91796875,47,76.28335745963689, +deadly_corridor,72,1000072,60.30122375488281,44,76.83513093208644, +deadly_corridor,73,1000073,768.6264343261719,141,77.27057350071598, +deadly_corridor,74,1000074,2280.1071166992188,172,74.16699734355548, +deadly_corridor,75,1000075,860.9334106445312,151,73.15118478347584, +deadly_corridor,76,1000076,722.9459228515625,143,75.5655785931314, +deadly_corridor,77,1000077,2276.8687438964844,182,72.95102474014934, +deadly_corridor,78,1000078,368.3357238769531,79,71.51096709276341, +deadly_corridor,79,1000079,-76.45918273925781,17,72.24888432102617, +deadly_corridor,80,1000080,2281.5543823242188,183,73.32589540463356, +deadly_corridor,81,1000081,2281.6688842773438,171,73.10600900440717, +deadly_corridor,82,1000082,2277.5223083496094,178,73.55648700566698, +deadly_corridor,83,1000083,42.30937194824219,41,73.52700344736942, +deadly_corridor,84,1000084,2285.8980407714844,176,71.98655161011203, +deadly_corridor,85,1000085,68.90191650390625,45,72.84773487604696, +deadly_corridor,86,1000086,2286.2190551757812,171,72.82303966497733, +deadly_corridor,87,1000087,281.1173553466797,76,72.26983276661764, +deadly_corridor,88,1000088,2283.1607971191406,175,73.49638264342678, +deadly_corridor,89,1000089,2277.888946533203,177,73.44736473371472, +deadly_corridor,90,1000090,429.36326599121094,93,71.86172378947977, +deadly_corridor,91,1000091,252.0751953125,70,72.26459581736903, +deadly_corridor,92,1000092,2278.306442260742,192,80.97328482778371, +deadly_corridor,93,1000093,2285.236801147461,175,74.02717585214627, +deadly_corridor,94,1000094,857.2727355957031,152,85.59110000526613, +deadly_corridor,95,1000095,2275.9288024902344,199,73.62958803645523, +deadly_corridor,96,1000096,2286.8704833984375,179,72.31519682456816, +deadly_corridor,97,1000097,2278.048355102539,181,73.50330330803081, +deadly_corridor,98,1000098,2277.4480743408203,178,76.78472725777, +deadly_corridor,99,1000099,2276.9671478271484,178,77.9678189026336, +ant,0,42,1846.1103431567394,1000,89.89614608291177, +ant,1,43,2415.720790707953,1000,90.00308114332259, +ant,2,44,457.34421085068755,177,89.83716885697598, +ant,3,45,1421.7952163289683,1000,89.87909631338808, +ant,4,46,2037.7234409469488,937,89.82685347370092, +ant,5,47,2330.630175869275,1000,90.47193606091501, +ant,6,48,1161.643572255748,429,89.84194070141322, +ant,7,49,2351.1524624990343,1000,89.92640891799017, +ant,8,50,513.2964809479813,210,89.88895656571908, +ant,9,51,1126.8652528911032,660,89.91361550654544, +ant,10,52,1693.436933192597,1000,89.84960962337662, +ant,11,53,948.3780972955639,1000,89.94678527711802, +ant,12,54,2322.052445211472,1000,90.11873818885832, +ant,13,55,960.4026770814776,1000,90.93377411320307, +ant,14,56,1464.564005196777,1000,89.80893705661644, +ant,15,57,1110.548792782156,1000,89.99466844889166, +ant,16,58,2246.207900740156,1000,90.1624262080728, +ant,17,59,85.64836938561511,60,89.87005518664785, +ant,18,60,340.54799067574436,143,89.94240076131771, +ant,19,61,2457.088748930458,1000,89.92054036086635, +ant,20,62,2166.2512677098603,1000,89.95452553058773, +ant,21,63,2357.957592244385,1000,89.86780458600198, +ant,22,64,1654.8780938737275,871,90.08433827425095, +ant,23,65,1499.367100151414,1000,89.89663615668341, +ant,24,66,2297.4032619179525,1000,90.09818426014289, +ant,25,67,1253.360764666355,543,89.9390124443734, +ant,26,68,1221.270312709775,1000,89.84986177450952, +ant,27,69,2389.2476464763376,1000,89.95772586857817, +ant,28,70,1682.5290233886233,707,89.76145439054764, +ant,29,71,2474.676425615127,1000,89.82093759631324, +ant,30,72,382.9231146443659,256,90.69916524888657, +ant,31,73,1837.8126619276347,1000,90.03642087221974, +ant,32,74,227.19436616673684,101,89.8553742761573, +ant,33,75,1700.6312067622644,1000,89.80097198453268, +ant,34,76,960.9452812639541,372,89.8420903148968, +ant,35,77,2290.6720141359438,1000,89.91770573449698, +ant,36,78,328.5729178056416,162,90.01187187392946, +ant,37,79,1180.073938772476,1000,89.81938304804656, +ant,38,80,817.4190215442345,363,89.85140773938038, +ant,39,81,1651.2255208727013,1000,91.17610023451576, +ant,40,82,1428.174672693164,1000,89.8551155619885, +ant,41,83,1627.3838925098842,1000,90.55986754698809, +ant,42,84,1079.756369746183,680,90.17098553312343, +ant,43,85,2173.9447393037276,1000,89.84319301261918, +ant,44,86,409.90633829945847,160,89.66802828269809, +ant,45,87,2467.2636019929073,1000,89.90844708827387, +ant,46,88,657.4084558813478,248,89.86487149424892, +ant,47,89,974.7436031610902,1000,89.76305094278182, +ant,48,90,1510.5184342975385,1000,90.24355118464125, +ant,49,91,602.2339441184535,260,89.7103209703719, +ant,50,92,760.9784375126189,316,89.8206829517188, +ant,51,93,1941.172113330597,1000,90.30785204408768, +ant,52,94,624.3590446196446,281,89.94582387208622, +ant,53,95,2163.4347041279893,1000,89.84848132390947, +ant,54,96,1126.9957963444238,1000,89.84637728060243, +ant,55,97,1405.131632695366,1000,90.18855922596491, +ant,56,98,1206.2916757636292,1000,89.78065539051504, +ant,57,99,2392.7980761515178,1000,89.76388668266138, +ant,58,100,964.0216541467705,1000,89.82618651237911, +ant,59,101,2252.192880003706,1000,89.8197082349776, +ant,60,102,2471.9158497657563,1000,89.96642568195992, +ant,61,103,1902.8491241623092,1000,89.87542708971246, +ant,62,104,1435.6661382989703,1000,90.28644124851098, +ant,63,105,1668.3237703695809,1000,89.86433221097877, +ant,64,106,1813.291243529155,1000,89.85118001877315, +ant,65,107,446.72353548541076,189,89.8309544306309, +ant,66,108,130.84194814079504,74,89.82416773165995, +ant,67,109,2315.857153770824,1000,90.25959750757508, +ant,68,110,288.3915792961347,116,90.09271984792927, +ant,69,111,894.0228631227924,1000,89.89663691508213, +ant,70,112,2030.322535823717,1000,89.84028619017428, +ant,71,113,507.9449555916754,215,90.57267432538549, +ant,72,114,2377.7373967468293,1000,89.84919425782105, +ant,73,115,897.3077114027096,1000,89.90431472264346, +ant,74,116,1454.612590266188,1000,91.19515970740413, +ant,75,117,2292.457960175467,1000,89.8333901030839, +ant,76,118,1424.378337790017,1000,89.88029014661089, +ant,77,119,1441.1111023164538,1000,89.79844243631413, +ant,78,120,1265.4771503717611,1000,89.86009503143968, +ant,79,121,1662.8808067819505,1000,90.5661722205243, +ant,80,122,2508.917122342891,1000,89.87403626041336, +ant,81,123,1655.3510139158748,1000,90.05039760075688, +ant,82,124,1387.3843721247736,821,90.10235730111886, +ant,83,125,646.4356689469432,271,89.7559653760994, +ant,84,126,2172.801064037805,1000,89.84602989356796, +ant,85,127,165.9213897970373,72,89.66756877688618, +ant,86,128,1063.1483912161111,1000,89.77409215132576, +ant,87,129,1000.135342286622,1000,89.81900933661238, +ant,88,130,1977.2359176146426,1000,89.77653862908736, +ant,89,131,1937.1674235355138,1000,90.12773943823525, +ant,90,132,1344.7729257831547,1000,90.39620143170467, +ant,91,133,786.3379828975102,441,89.82893206036925, +ant,92,134,1391.060299752017,1000,89.86676880070257, +ant,93,135,503.300235688713,250,89.94819176115624, +ant,94,136,2446.7482357041768,1000,89.84848658183878, +ant,95,137,1171.9102336514923,1000,89.92785850220504, +ant,96,138,2356.7311711183065,1000,90.42933754946152, +ant,97,139,2356.12199478712,1000,89.82049779117614, +ant,98,140,1389.2987977192308,1000,90.82209581044775, +ant,99,141,967.2335383727841,1000,89.80016695371027, +intercept,0,4242424242,0.7267571190313902,60,99.89614420497905,0.0 +intercept,1,4242424243,2.9096362272975966,60,99.91707940536706,0.0 +intercept,2,4242424244,3.2060351513209753,60,97.78809018716221,0.0 +intercept,3,4242424245,0.7574528902187012,60,98.54894447730877,0.0 +intercept,4,4242424246,0.6827895979695313,60,99.11745353519741,0.0 +intercept,5,4242424247,29.923812823486514,60,99.04064156549293,1.0 +intercept,6,4242424248,0.7661087726592086,60,98.25342313549518,0.0 +intercept,7,4242424249,0.8284444468154106,60,97.98431264506286,0.0 +intercept,8,4242424250,0.9707721562881488,60,99.10671115977826,0.0 +intercept,9,4242424251,1.0944434545235708,60,99.10142489904808,0.0 +intercept,10,4242424252,0.7526731102407211,60,98.24263629181895,0.0 +intercept,11,4242424253,1.0327306617691647,60,99.90610126116793,0.0 +intercept,12,4242424254,24.08529434411321,60,99.04964452767656,1.0 +intercept,13,4242424255,0.8258126199943945,60,99.06333184347895,0.0 +intercept,14,4242424256,0.6465023508935701,60,99.96017435988418,0.0 +intercept,15,4242424257,1.2059930491086561,60,99.07293754243183,0.0 +intercept,16,4242424258,0.8975468523567542,60,99.10975490804557,0.0 +intercept,17,4242424259,0.638558203499997,60,99.9008234011206,0.0 +intercept,18,4242424260,2.473904824233614,60,99.1007534285042,0.0 +intercept,19,4242424261,0.8594156300532632,60,98.2804424689215,0.0 +intercept,20,4242424262,0.7127419076277874,60,97.42140552034121,0.0 +intercept,21,4242424263,1.1195833964738995,60,99.05356389575846,0.0 +intercept,22,4242424264,1.4589147588121705,60,99.10476263429966,0.0 +intercept,23,4242424265,22.348254217096837,60,98.14243140713285,1.0 +intercept,24,4242424266,27.43761277961312,60,99.03063235183511,1.0 +intercept,25,4242424267,0.797963114338927,60,98.95851806063928,0.0 +intercept,26,4242424268,0.6415987604705151,60,99.1202532952496,0.0 +intercept,27,4242424269,1.502438226743834,60,99.8369766656745,0.0 +intercept,28,4242424270,1.277322537265718,60,99.13638822823135,0.0 +intercept,29,4242424271,0.6413188653605175,60,99.8165233572777,0.0 +intercept,30,4242424272,26.015227647672873,60,99.93359984997578,1.0 +intercept,31,4242424273,0.7568511647114065,60,98.29798580223347,0.0 +intercept,32,4242424274,0.7758818510046694,60,95.9119617819155,0.0 +intercept,33,4242424275,0.743274000211386,60,99.16579733811342,0.0 +intercept,34,4242424276,0.9812663898337632,60,99.96913332715677,0.0 +intercept,35,4242424277,0.7364500367548317,60,98.4144170848438,0.0 +intercept,36,4242424278,0.7676261149172205,60,99.87913624991887,0.0 +intercept,37,4242424279,2.6105462690466084,60,99.0124647390605,0.0 +intercept,38,4242424280,0.8922563010128215,60,99.49582641131909,0.0 +intercept,39,4242424281,0.7909053032053635,60,99.95776157301488,0.0 +intercept,40,4242424282,27.747763212013524,60,99.89232705853966,1.0 +intercept,41,4242424283,2.830903574009426,60,99.11182141335861,0.0 +intercept,42,4242424284,3.749473527306691,60,99.89401411987875,0.0 +intercept,43,4242424285,3.2371535471174866,60,98.58941395009701,0.0 +intercept,44,4242424286,1.141169616690604,60,98.95023432158384,0.0 +intercept,45,4242424287,1.2504711685760412,60,99.8783128676535,0.0 +intercept,46,4242424288,1.1401455145678483,60,99.09364640302553,0.0 +intercept,47,4242424289,1.1743367564631626,60,98.24703755640672,0.0 +intercept,48,4242424290,0.6911400489043444,60,98.98847807253395,0.0 +intercept,49,4242424291,0.966755291854497,60,98.31297463384391,0.0 +intercept,50,4242424292,3.7725237559643574,60,98.1307167401627,0.0 +intercept,51,4242424293,0.7292428385990206,60,99.08520847604322,0.0 +intercept,52,4242424294,2.733719722367823,60,99.8949988335446,0.0 +intercept,53,4242424295,2.7277548569836654,60,99.16542541107671,0.0 +intercept,54,4242424296,0.8013565168366767,60,98.2801475641182,0.0 +intercept,55,4242424297,0.9918300381395966,60,98.74883429246843,0.0 +intercept,56,4242424298,3.8384227409260347,60,98.30485570834159,0.0 +intercept,57,4242424299,2.525593837024644,60,99.08211861473346,0.0 +intercept,58,4242424300,1.1939986812940333,60,99.95562586586023,0.0 +intercept,59,4242424301,1.1946645161951892,60,99.11887142756973,0.0 +intercept,60,4242424302,0.6632764584392135,60,99.92733404817194,0.0 +intercept,61,4242424303,0.7345126099826302,60,99.61093201950378,0.0 +intercept,62,4242424304,1.1547945403144695,60,98.88382479344455,0.0 +intercept,63,4242424305,1.0395031699445099,60,99.10455669644611,0.0 +intercept,64,4242424306,2.7713681719324086,60,99.99607387713222,0.0 +intercept,65,4242424307,3.8083399715833366,60,99.90908449191997,0.0 +intercept,66,4242424308,3.1245881704380736,60,99.86388390473627,0.0 +intercept,67,4242424309,0.9936205917911138,60,99.06530098425861,0.0 +intercept,68,4242424310,0.6479002644773573,60,97.31661851374615,0.0 +intercept,69,4242424311,1.09404552471824,60,99.06482130667098,0.0 +intercept,70,4242424312,0.725047086874838,60,99.39714496924636,0.0 +intercept,71,4242424313,2.085218493710272,60,99.91926924929075,0.0 +intercept,72,4242424314,25.112157980707707,60,99.89495984140663,1.0 +intercept,73,4242424315,0.7960666966973804,60,99.91315720008677,0.0 +intercept,74,4242424316,1.8899870013119653,60,99.8635479883608,0.0 +intercept,75,4242424317,24.77215793245705,60,99.08978442272605,1.0 +intercept,76,4242424318,0.763190906640375,60,99.1181927131107,0.0 +intercept,77,4242424319,0.8356004936795216,60,98.87472332915829,0.0 +intercept,78,4242424320,24.543561146681895,60,98.85109478338812,1.0 +intercept,79,4242424321,0.7962639288743958,60,96.64267992061197,0.0 +intercept,80,4242424322,0.6807828926102957,60,98.70551839611774,0.0 +intercept,81,4242424323,1.1704122956143692,60,99.1162675413269,0.0 +intercept,82,4242424324,0.8024117537715938,60,99.10984056283594,0.0 +intercept,83,4242424325,1.0154686415335163,60,99.90653765962175,0.0 +intercept,84,4242424326,0.6267238368745893,60,99.14313411902761,0.0 +intercept,85,4242424327,1.1180786813492887,60,99.87378109642233,0.0 +intercept,86,4242424328,1.0531825890648179,60,99.90759275984404,0.0 +intercept,87,4242424329,0.7319892354425974,60,99.07934787032669,0.0 +intercept,88,4242424330,1.1460731038823724,60,98.32584786308246,0.0 +intercept,89,4242424331,1.145515855285339,60,99.853580446333,0.0 +intercept,90,4242424332,3.1438898412743583,60,98.23875463665809,0.0 +intercept,91,4242424333,1.1678254807484336,60,99.94300368083988,0.0 +intercept,92,4242424334,1.1468605129048228,60,98.28856657896678,0.0 +intercept,93,4242424335,2.816772125195712,60,99.10609232867152,0.0 +intercept,94,4242424336,1.1577836629003286,60,99.93574594730708,0.0 +intercept,95,4242424337,1.0533778404060286,60,99.92123883389186,0.0 +intercept,96,4242424338,0.8533297177054919,60,99.06174133027585,0.0 +intercept,97,4242424339,0.7617567333800253,60,99.95316521359209,0.0 +intercept,98,4242424340,0.9895546428160742,60,99.11385213912092,0.0 +intercept,99,4242424341,0.770722996792756,60,99.44169788411487,0.0 diff --git a/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/comparison.csv b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/comparison.csv new file mode 100644 index 0000000000000000000000000000000000000000..1b381df6789eea28ea56149c4b780cf0cade01c0 --- /dev/null +++ b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/comparison.csv @@ -0,0 +1,5 @@ +task,episodes,return_mean,return_sd,length_mean,length_sd,success_count,success_rate,invalid_actions,dropped_actions +flappy,100,384.8240045265853,116.78777394316903,3119.31,939.8693174585497,,,0,64 +deadly_corridor,100,1620.7987757873534,913.6242782186637,148.53,49.455930888013825,,,0,0 +ant,100,1453.844063807972,693.7275200567642,803.85,328.8088312378486,,,0,0 +intercept,100,3.5443485127069287,7.07192296411853,60.0,0.0,9,0.09,0,10 diff --git a/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/comparison.json b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/comparison.json new file mode 100644 index 0000000000000000000000000000000000000000..8486070c582599f0cb0c336c70e6569823f4990f --- /dev/null +++ b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/comparison.json @@ -0,0 +1,205 @@ +{ + "condition": "profile-latency", + "executor_mode": "simulated", + "latency_method": "temporal/profile_sample", + "episodes_per_checkpoint": 100, + "total_episodes": 400, + "checkpoints_metadata_revision": "d4825bbad8d15bc50b6b8481eb2abc84846a54fb", + "results": { + "flappy": { + "n_episodes": 100, + "mean_return": 384.8240045265853, + "std_return": 116.78777394316903, + "min_return": 36.60000045597553, + "max_return": 444.6000052243471, + "mean_length": 3119.31, + "std_length": 939.8693174585497, + "min_length": 314.0, + "max_length": 3600.0, + "return_field": "episode_return_env", + "length_field": "survival_steps", + "mode": "simulated", + "policy_id": "starvla", + "env_id": "flappy", + "model_id": "openvla", + "gpu_class": "1x-rtx3090", + "workload_id": "flappy", + "instance_id": "instance_a5037b165aa0cedc", + "source_run_id": "20260914T122201421825Z", + "profile_ref": null, + "env_fps": 10.0, + "obs_fps": 10.0, + "frame_ms": 100.0, + "latency_type": "profile_sample", + "task": "flappy", + "checkpoint_revision": "d4825bbad8d15bc50b6b8481eb2abc84846a54fb", + "checkpoint_path": "latency-aware/flappy/vla/starvla-qwenoft-h1/flappy-qwenoft-mean-3090-s42", + "profile_sha256": "c266cba7ebac05c7e37bc83f1f16fe4b27dab97942ff43290e6c41514f6e39fc", + "condition": "profile-latency", + "invalid_actions": 0, + "dropped_actions": 64, + "unique_seeds": 100, + "physical_gpu": 2, + "eval_config": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/flappy.yaml", + "execution_audit": { + "issued_action_records": 311075, + "applied_action_records": 310911, + "dropped_action_records": 64, + "nonnoop_issued_records": 30817, + "finite_action_values": true, + "latency_sample_count": 311075, + "latency_mean_ms": 75.89784633675906, + "latency_std_ms": 3.799946378622932, + "latency_p95_ms": 81.3960393048375, + "latency_p99_ms": 87.23844517488543 + } + }, + "deadly_corridor": { + "n_episodes": 100, + "mean_return": 1620.7987757873534, + "std_return": 913.6242782186637, + "min_return": -76.45918273925781, + "max_return": 2287.240921020508, + "mean_length": 148.53, + "std_length": 49.455930888013825, + "min_length": 17.0, + "max_length": 199.0, + "return_field": "episode_return_env", + "length_field": "survival_steps", + "mode": "simulated", + "policy_id": "starvla", + "env_id": "doom_deadly_corridor", + "model_id": "openvla", + "gpu_class": "1x-rtx3090", + "workload_id": "deadly_corridor", + "instance_id": "instance_a5037b165aa0cedc", + "source_run_id": "20260914T171446047509Z", + "profile_ref": null, + "env_fps": 35.0, + "obs_fps": 8.75, + "frame_ms": 28.571428571428573, + "latency_type": "profile_sample", + "task": "deadly_corridor", + "checkpoint_revision": "d4825bbad8d15bc50b6b8481eb2abc84846a54fb", + "checkpoint_path": "latency-aware/deadly-corridor/vla/starvla-qwenoft-h1/deadly_corridor-qwenoft-mean-3090-s42", + "profile_sha256": "bbfb93cef9f63750a9a159ec10a93a9fc6c25e4cb0cac3b39532663b4dc11eba", + "condition": "profile-latency", + "invalid_actions": 0, + "dropped_actions": 0, + "unique_seeds": 100, + "physical_gpu": 3, + "eval_config": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/deadly_corridor.yaml", + "execution_audit": { + "issued_action_records": 3753, + "applied_action_records": 3673, + "dropped_action_records": 0, + "nonnoop_issued_records": 3753, + "finite_action_values": true, + "latency_sample_count": 3753, + "latency_mean_ms": 74.01999621872471, + "latency_std_ms": 5.5537519652567635, + "latency_p95_ms": 89.54825982614612, + "latency_p99_ms": 95.97310052501227 + } + }, + "ant": { + "n_episodes": 100, + "mean_return": 1453.844063807972, + "std_return": 693.7275200567642, + "min_return": 85.64836938561511, + "max_return": 2508.917122342891, + "mean_length": 803.85, + "std_length": 328.8088312378486, + "min_length": 60.0, + "max_length": 1000.0, + "return_field": "episode_return_env", + "length_field": "survival_steps", + "mode": "simulated", + "policy_id": "starvla", + "env_id": "LatencyBench/AntContinuous-v0", + "model_id": "qwenoft", + "gpu_class": "1x-rtx3090", + "workload_id": "ant", + "instance_id": "instance_859cf1e47bca6046", + "source_run_id": "20260911T033037730561Z", + "profile_ref": null, + "env_fps": 10.0, + "obs_fps": 10.0, + "frame_ms": 100.0, + "latency_type": "profile_sample", + "task": "ant", + "checkpoint_revision": "d4825bbad8d15bc50b6b8481eb2abc84846a54fb", + "checkpoint_path": "latency-aware/ant/vla/starvla-qwenoft-h1/ant-qwenoft-mean-3090-s42", + "profile_sha256": "0e49f72ec05ac600a54e07bbca5af3143708444d606167f33fa21788a9fefe50", + "condition": "profile-latency", + "invalid_actions": 0, + "dropped_actions": 0, + "unique_seeds": 100, + "physical_gpu": 2, + "eval_config": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/ant.yaml", + "execution_audit": { + "issued_action_records": 79573, + "applied_action_records": 79465, + "dropped_action_records": 0, + "nonnoop_issued_records": 79573, + "finite_action_values": true, + "latency_sample_count": 79573, + "latency_mean_ms": 90.00919554158884, + "latency_std_ms": 2.514492574433973, + "latency_p95_ms": 91.11971585797141, + "latency_p99_ms": 102.67108120995428 + } + }, + "intercept": { + "n_episodes": 100, + "mean_return": 3.5443485127069287, + "std_return": 7.07192296411853, + "min_return": 0.6267238368745893, + "max_return": 29.923812823486514, + "mean_length": 60.0, + "std_length": 0.0, + "min_length": 60.0, + "max_length": 60.0, + "return_field": "episode_return_env", + "length_field": "survival_steps", + "mode": "simulated", + "policy_id": "starvla", + "env_id": "mikasa_intercept_grab_fast", + "model_id": "qwenoft", + "gpu_class": "1x-rtx3090", + "workload_id": "mikasa_intercept_grab_fast", + "instance_id": "instance_3a0d42681a03715c", + "source_run_id": "20260909T044501695676Z", + "profile_ref": null, + "env_fps": 20.0, + "obs_fps": 20.0, + "frame_ms": 50.0, + "latency_type": "profile_sample", + "task": "intercept", + "checkpoint_revision": "d4825bbad8d15bc50b6b8481eb2abc84846a54fb", + "checkpoint_path": "latency-aware/mikasa-intercept-grab-fast/vla/starvla-qwenoft-h1/intercept-qwenoft-mean-3090-h1-s0", + "profile_sha256": "31a9b15d6b04182439934f0b377cb3d09be16ce21f3cf95c1049918f8a5d4984", + "condition": "profile-latency", + "invalid_actions": 0, + "dropped_actions": 10, + "unique_seeds": 100, + "physical_gpu": 3, + "eval_config": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/intercept.yaml", + "success_count": 9, + "success_rate": 0.09, + "execution_audit": { + "issued_action_records": 2974, + "applied_action_records": 2864, + "dropped_action_records": 10, + "nonnoop_issued_records": 2974, + "finite_action_values": true, + "latency_sample_count": 2974, + "latency_mean_ms": 99.11060319379854, + "latency_std_ms": 4.301543980874005, + "latency_p95_ms": 100.2889407458356, + "latency_p99_ms": 100.64616770379737 + } + } + }, + "quality_acceptance": "not inferred; observed statistics only" +} diff --git a/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/episodes.csv b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/episodes.csv new file mode 100644 index 0000000000000000000000000000000000000000..b2bcd64fa67fa91907bbb6010397f02aa525e767 --- /dev/null +++ b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/episodes.csv @@ -0,0 +1,101 @@ +episode_id,seed,return_env,length,mean_latency_ms,invalid_actions,dropped_actions +0,1000000,337.47547912597656,72,71.90727374040254,0,0 +1,1000001,819.0284423828125,143,73.84762082340946,0,0 +2,1000002,2284.857650756836,182,72.79171012339609,0,0 +3,1000003,2276.2068634033203,189,76.345275285376,0,0 +4,1000004,805.2153015136719,150,73.86282581373551,0,0 +5,1000005,621.8231658935547,115,74.31105893586228,0,0 +6,1000006,2276.414749145508,176,74.2226331369995,0,0 +7,1000007,2284.310989379883,176,72.9072057957754,0,0 +8,1000008,81.07798767089844,49,73.20258272646697,0,0 +9,1000009,317.2351837158203,75,72.54774919154028,0,0 +10,1000010,2282.7608489990234,176,72.78293151689127,0,0 +11,1000011,88.11907958984375,45,72.60486105128022,0,0 +12,1000012,2281.468536376953,176,72.29193331603048,0,0 +13,1000013,2276.6868591308594,178,72.73330265771509,0,0 +14,1000014,2276.1705932617188,178,73.30067987408609,0,0 +15,1000015,2282.6631622314453,177,72.49405489224537,0,0 +16,1000016,2280.300033569336,172,72.80884970803692,0,0 +17,1000017,2280.4182891845703,182,73.03539182090206,0,0 +18,1000018,2281.2594451904297,177,72.50972089313564,0,0 +19,1000019,479.8523712158203,99,72.58046231642126,0,0 +20,1000020,2279.7379455566406,181,72.47468246266928,0,0 +21,1000021,2284.9097442626953,197,83.18983231769475,0,0 +22,1000022,2286.2730407714844,172,72.84281562147524,0,0 +23,1000023,244.51919555664062,74,76.23461799191558,0,0 +24,1000024,2279.957275390625,195,72.94927214021655,0,0 +25,1000025,2283.952178955078,179,73.18968843008061,0,0 +26,1000026,2276.701370239258,178,72.87702909462648,0,0 +27,1000027,2277.142562866211,190,72.45412386128042,0,0 +28,1000028,2279.025634765625,177,74.11102172804317,0,0 +29,1000029,2285.7152099609375,177,71.63189230597281,0,0 +30,1000030,53.374298095703125,44,72.51418721312025,0,0 +31,1000031,2279.8080444335938,183,72.72702656843174,0,0 +32,1000032,2282.307357788086,178,74.33584751930213,0,0 +33,1000033,2282.834014892578,192,73.95005063555192,0,0 +34,1000034,2284.200241088867,188,76.29368894499888,0,0 +35,1000035,2287.2159118652344,179,72.81890806090988,0,0 +36,1000036,2284.693832397461,183,76.28284599973325,0,0 +37,1000037,2283.2066650390625,178,72.1797344044525,0,0 +38,1000038,2281.032196044922,178,73.74343783824916,0,0 +39,1000039,2282.960678100586,190,73.24816830891406,0,0 +40,1000040,2287.094253540039,185,72.35711232966574,0,0 +41,1000041,2279.3030853271484,179,72.42125368367608,0,0 +42,1000042,440.0892791748047,104,73.92064892672727,0,0 +43,1000043,2280.8592529296875,177,72.36020918178356,0,0 +44,1000044,2283.4308471679688,189,75.93658060557208,0,0 +45,1000045,2282.324264526367,181,73.54224681770178,0,0 +46,1000046,326.0184631347656,74,73.1983876441008,0,0 +47,1000047,2279.086135864258,182,73.00958120503027,0,0 +48,1000048,2280.3804626464844,179,73.17268244992928,0,0 +49,1000049,2276.215301513672,189,75.47590644230628,0,0 +50,1000050,2278.132034301758,182,74.50495464842548,0,0 +51,1000051,2285.6056518554688,181,73.41699294418743,0,0 +52,1000052,2287.240921020508,173,73.22110809114655,0,0 +53,1000053,310.81517028808594,73,74.09003681120738,0,0 +54,1000054,2276.6219787597656,175,72.98605010243534,0,0 +55,1000055,2276.2769470214844,194,75.17704077845171,0,0 +56,1000056,2278.861602783203,178,72.97353037051572,0,0 +57,1000057,2279.728561401367,181,73.96913002154926,0,0 +58,1000058,2280.544464111328,176,73.02432805290651,0,0 +59,1000059,487.829833984375,108,78.89398217393664,0,0 +60,1000060,567.0655517578125,113,72.64874721482185,0,0 +61,1000061,2278.210220336914,177,72.96068484971086,0,0 +62,1000062,2281.436721801758,186,75.46710866924751,0,0 +63,1000063,382.2119903564453,89,81.21157315209366,0,0 +64,1000064,246.2946014404297,70,73.9736408486285,0,0 +65,1000065,285.21240234375,76,73.13661133681993,0,0 +66,1000066,310.6737365722656,75,73.40468658737086,0,0 +67,1000067,346.1162872314453,75,72.1929723632303,0,0 +68,1000068,804.7056121826172,150,73.76397959753224,0,0 +69,1000069,2285.6442108154297,184,75.13255757158333,0,0 +70,1000070,730.5995788574219,132,73.25446825350764,0,0 +71,1000071,86.91796875,47,76.28335745963689,0,0 +72,1000072,60.30122375488281,44,76.83513093208644,0,0 +73,1000073,768.6264343261719,141,77.27057350071598,0,0 +74,1000074,2280.1071166992188,172,74.16699734355548,0,0 +75,1000075,860.9334106445312,151,73.15118478347584,0,0 +76,1000076,722.9459228515625,143,75.5655785931314,0,0 +77,1000077,2276.8687438964844,182,72.95102474014934,0,0 +78,1000078,368.3357238769531,79,71.51096709276341,0,0 +79,1000079,-76.45918273925781,17,72.24888432102617,0,0 +80,1000080,2281.5543823242188,183,73.32589540463356,0,0 +81,1000081,2281.6688842773438,171,73.10600900440717,0,0 +82,1000082,2277.5223083496094,178,73.55648700566698,0,0 +83,1000083,42.30937194824219,41,73.52700344736942,0,0 +84,1000084,2285.8980407714844,176,71.98655161011203,0,0 +85,1000085,68.90191650390625,45,72.84773487604696,0,0 +86,1000086,2286.2190551757812,171,72.82303966497733,0,0 +87,1000087,281.1173553466797,76,72.26983276661764,0,0 +88,1000088,2283.1607971191406,175,73.49638264342678,0,0 +89,1000089,2277.888946533203,177,73.44736473371472,0,0 +90,1000090,429.36326599121094,93,71.86172378947977,0,0 +91,1000091,252.0751953125,70,72.26459581736903,0,0 +92,1000092,2278.306442260742,192,80.97328482778371,0,0 +93,1000093,2285.236801147461,175,74.02717585214627,0,0 +94,1000094,857.2727355957031,152,85.59110000526613,0,0 +95,1000095,2275.9288024902344,199,73.62958803645523,0,0 +96,1000096,2286.8704833984375,179,72.31519682456816,0,0 +97,1000097,2278.048355102539,181,73.50330330803081,0,0 +98,1000098,2277.4480743408203,178,76.78472725777,0,0 +99,1000099,2276.9671478271484,178,77.9678189026336,0,0 diff --git a/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/eval_config.yaml b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/eval_config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..7833b316cd581921c857de1c220fca6247c0193a --- /dev/null +++ b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/eval_config.yaml @@ -0,0 +1,164 @@ +experiment: + name: deadly_corridor-mean5000-profile-simulation-100ep + seed: 1000000 +backend: + type: sample_factory + algo: APPO + device: cpu + train_dir: results/sample_factory + restart_behavior: resume + run_mode: eval +executor: + mode: simulated + simulated_worker_capacity: 1 + simulated_inference_pool: true + inference_devices: + - cuda:0 + inference_batch_size: 32 +env: + name: deadly_corridor + env_id: doom_deadly_corridor + env_fps: 35 + obs_fps: 8.75 + noop_action: + - 0 + - 0 + - 0 + - 0 + frame_stack: 1 + res_w: 128 + res_h: 72 + wide_aspect_ratio: false + simulator: cpu + obs_resize: + - 224 + - 224 + action_map: + noop: + - 0 + - 0 + - 0 + - 0 + move_forward: + - 0 + - 1 + - 0 + - 0 + move_backward: + - 0 + - 2 + - 0 + - 0 + move_left: + - 0 + - 0 + - 1 + - 0 + move_right: + - 0 + - 0 + - 2 + - 0 + turn_left: + - 1 + - 0 + - 0 + - 0 + turn_right: + - 2 + - 0 + - 0 + - 0 + attack: + - 0 + - 0 + - 0 + - 1 + action_history_decisions: 8 + screen_resolution: RES_160X120 + render_hud: true + render_crosshair: false + render_weapon: true + render_decals: false + render_particles: false +latency: + method: temporal + profile_path: /home/ubuntu/lzj/profiles/published/profiles/openvla/1x-rtx3090/deadly_corridor/instance_a5037b165aa0cedc/profile.json + profile_worker_slot: 0 + seed: 271828 + add_latency_info: false +scheduler: + hold_policy: hold + ordering_policy: latest_ready +policy: + type: starvla + actions: + - MOVE_FORWARD + - MOVE_BACKWARD + - MOVE_LEFT + - MOVE_RIGHT + - TURN_LEFT + - TURN_RIGHT + - ATTACK + checkpoint_path: /home/ubuntu/lzj/mean-profiling/deadly_corridor/vla-publication/checkpoints/model.pt + model_config_path: /home/ubuntu/lzj/mean-profiling/deadly_corridor/vla-publication/config.full.yaml + device: cuda:0 + unnorm_key: new_embodiment + prompt_mode: latency_neutral + action_layout: multibinary_7 + state_source: transport + backbone_path: /home/ubuntu/lzj/models/Qwen3-VL-4B-Instruct + worker_python_executable: /home/ubuntu/lzj/conda/envs/qwenoft/bin/python +training: + train_for_env_steps: 25000000 + num_workers: 32 + num_envs_per_worker: 4 + worker_num_splits: 2 + num_policies: 1 + batch_size: 1024 + rollout: 128 + recurrence: 128 + num_epochs: 2 + num_batches_per_epoch: 2 + learning_rate: 0.0001 + gamma: 0.99 + gae_lambda: 0.95 + ppo_clip_ratio: 0.1 + ppo_clip_value: 0.2 + exploration_loss: symmetric_kl + exploration_loss_coeff: 0.001 + value_loss_coeff: 0.5 + max_grad_norm: 4.0 + async_rl: true + use_rnn: true + rnn_type: gru + rnn_size: 512 + normalize_input: true + normalize_returns: true + stats_avg: 100 + experiment_summaries_interval: 1 + save_every_sec: 600 + keep_checkpoints: 5 +evaluation: + eval_interval_steps: 1000000 + eval_episodes: 100 + eval_parallel_envs: 32 + eval_max_steps: 3600 + eval_deterministic: true + eval_raw_reward: true + eval_suites: + fixed: [] + normal: [] + uniform: [] + eval_latency_values: null +logging: + output_dir: /home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/deadly_corridor + video: + enabled: false + save_step_records: true + save_action_records: true + save_latency_records: true + wandb_project: null + wandb_group: null + wandb_job_type: null + wandb_tags: '' diff --git a/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/batched_simulated.py b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/batched_simulated.py new file mode 100644 index 0000000000000000000000000000000000000000..d5edbe901e40e8e9cbb2e0763281fdfcd77dbfcc --- /dev/null +++ b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/batched_simulated.py @@ -0,0 +1,702 @@ +from __future__ import annotations + +import time +from collections.abc import Callable, Mapping, Sequence +from dataclasses import dataclass, field +from pathlib import Path + +import numpy as np + +from latency_bench.core.clock import EnvClock +from latency_bench.core.decision_action_history import DecisionActionHistory +from latency_bench.core.timing import StageProfiler, profiler_scope +from latency_bench.core.types import ActionEvent, EpisodeMetrics, LatencyRecord, Observation, StepRecord +from latency_bench.envs.atari import TRUE_EPISODE_END_INFO_KEY +from latency_bench.envs.base import EnvAdapter +from latency_bench.executors._simulated_timeline import ( + SimulatedResultTimeline, + SimulatedWorkerCapacity, + build_simulated_action_event, +) +from latency_bench.executors.base import BatchedExecutor +from latency_bench.executors.env_step_backend import EnvStepBackend, env_action_space +from latency_bench.latency.sample import LatencySample +from latency_bench.latency.samplers import LatencySampler +from latency_bench.logging.metrics import ( + compute_episode_metrics, + compute_episode_metrics_from_aggregates, + episode_raw_fact_metadata, + latency_type_from_source, + profile_metadata_from_source, +) +from latency_bench.logging.records import build_step_record +from latency_bench.logging.trajectory_logger import TrajectoryLogger +from latency_bench.policy.action_prefix import with_action_prefix +from latency_bench.policy.base import PolicyRunner +from latency_bench.scheduler.action_queue import ActionScheduler +from latency_bench.scheduler.decision import DecisionScheduler +from latency_bench.utils.io import write_json +from latency_bench.utils.stats import series_stats + + +@dataclass +class _EpisodeBuffers: + step_records: list[StepRecord] | None = None + action_events: list[ActionEvent] | None = None + latency_records: list[LatencyRecord] | None = None + latency_values_ms: list[float] = field(default_factory=list) + episode_return_env: float = 0.0 + survival_steps: int = 0 + game_score: float | None = None + return_raw: float | None = None + num_actions: int = 0 + num_dropped_actions: int = 0 + num_invalid_actions: int = 0 + submitted_observation_frames: int = 0 + dropped_observation_count: int = 0 + soft_reset_count: int = 0 + final_lives: int | None = None + final_is_true_episode_end: bool | None = None + task_metrics: dict | None = None + task_metric_moments: dict | None = None + + def record_step(self, *, reward: float, info: dict) -> None: + self.episode_return_env += float(reward) + self.survival_steps += 1 + if "invalid_action" in info and info["invalid_action"]: + self.num_invalid_actions += 1 + if "soft_reset" in info and info["soft_reset"]: + self.soft_reset_count += 1 + if "lives" in info: + self.final_lives = info["lives"] + if TRUE_EPISODE_END_INFO_KEY in info: + self.final_is_true_episode_end = info[TRUE_EPISODE_END_INFO_KEY] + if "game_score" in info: + self.game_score = float(info["game_score"]) + if "score" in info: + self.game_score = float(info["score"]) + if "task_metrics" in info: + self.task_metrics = info["task_metrics"] + if "task_metric_moments" in info: + self.task_metric_moments = info["task_metric_moments"] + self._update_return_raw(info) + extra_stats = info["episode_extra_stats"] if "episode_extra_stats" in info else None + if isinstance(extra_stats, dict): + self._update_return_raw(extra_stats) + + def _update_return_raw(self, stats: dict) -> None: + for key in ("return_raw", "raw_return", "episodic_raw_return", "episode/raw_return"): + if key in stats and stats[key] is not None: + self.return_raw = float(stats[key]) + + +@dataclass +class _SlotState: + slot_id: int + env: EnvAdapter + latency_source: LatencySampler + action_scheduler: ActionScheduler + result_timeline: SimulatedResultTimeline + active: bool = False + episode_id: int | None = None + episode_seed: int | None = None + env_step: int = 0 + recent_drop_count: int = 0 + decision_action_history: DecisionActionHistory | None = None + decision_admitted: bool = False + decision_issued_action: object = None + buffers: _EpisodeBuffers = field(default_factory=_EpisodeBuffers) + worker_capacity: SimulatedWorkerCapacity = field( + default_factory=lambda: SimulatedWorkerCapacity(capacity=None, busy_until_by_worker={}) + ) + + +@dataclass +class _PendingPolicyObservation: + slot: _SlotState + observation: Observation + obs_id: int + latency_sample: LatencySample + worker_slot: int + + +class BatchedSimulatedLatencyExecutor(BatchedExecutor): + """Run multiple simulated episodes concurrently with independent slot state. + + The main process owns policy inference, latency scheduling, episode accounting, + and logging. Env stepping can be serial in-process or delegated to worker + subprocesses through env_backend. + """ + + def __init__( + self, + *, + env_backend: EnvStepBackend, + policy: PolicyRunner, + decision_scheduler: DecisionScheduler, + latency_sources: Sequence[LatencySampler], + action_schedulers: Sequence[ActionScheduler], + clock: EnvClock, + logger: TrajectoryLogger | None = None, + episode_latency_source_factory: Callable[[int], LatencySampler] | None = None, + simulated_worker_capacity: int | None = None, + profile_pipeline: bool = False, + inference_pool=None, + action_prefix=None, + action_history_decisions: int | None = None, + ): + slot_count = env_backend.num_slots + self.env_backend = env_backend + self.envs = list(env_backend.slot_handles) + self.policy = policy + self.decision_scheduler = decision_scheduler + self.clock = clock + self.logger = logger + self.profile_pipeline = bool(profile_pipeline) + self.inference_pool = inference_pool + self.action_prefix = action_prefix + self._pipeline_profile_rows: list[dict[str, float]] = [] + self.simulated_worker_capacity = simulated_worker_capacity + self._collect_step_records = bool(logger is not None and logger.save_step_records) + self._collect_action_records = bool(logger is not None and logger.save_action_records) + self._collect_latency_records = bool(logger is not None and logger.save_latency_records) + self.episode_latency_source_factory = episode_latency_source_factory + self.slots = [ + _SlotState( + slot_id=slot_id, + env=self.envs[slot_id], + latency_source=latency_sources[slot_id], + action_scheduler=action_schedulers[slot_id], + result_timeline=SimulatedResultTimeline( + ordering_policy=action_schedulers[slot_id].ordering_policy + ), + decision_action_history=( + DecisionActionHistory( + env_action_space(self.envs[slot_id]), num_envs=1, decisions=action_history_decisions + ) if action_history_decisions is not None else None + ), + buffers=self._new_episode_buffers(), + worker_capacity=SimulatedWorkerCapacity( + capacity=simulated_worker_capacity, + busy_until_by_worker={}, + ), + ) + for slot_id in range(slot_count) + ] + self._next_obs_id = 0 + self._next_action_id = 0 + self.started_episodes = 0 + self.completed_episodes = 0 + self._completed_metrics: dict[int, EpisodeMetrics] = {} + self._completed_buffers: dict[int, _EpisodeBuffers] = {} + self._episode_log_order: list[int] = [] + self._next_episode_log_index = 0 + + @property + def num_slots(self) -> int: + return len(self.slots) + + def close(self) -> None: + if self.inference_pool is not None: + self.inference_pool.close() + self.env_backend.close() + + def run_episodes( + self, + *, + episode_ids: Sequence[int], + seeds: Sequence[int | None], + eval_max_steps: int = 10000, + on_episode_complete: Callable[[EpisodeMetrics], None] | None = None, + ) -> list[EpisodeMetrics]: + if eval_max_steps < 0: + raise ValueError("eval_max_steps must be non-negative") + episode_ids = [int(episode_id) for episode_id in episode_ids] + if len(seeds) != len(episode_ids): + raise ValueError("seeds length must match episode_ids length") + + self._reset_run_state(episode_ids) + if not episode_ids: + return [] + + next_episode_index = 0 + initial_slots = min(self.num_slots, len(episode_ids)) + for slot in self.slots[:initial_slots]: + self._start_slot( + slot, + episode_id=episode_ids[next_episode_index], + seed=seeds[next_episode_index], + ) + next_episode_index += 1 + + while self.completed_episodes < len(episode_ids): + active_slots = self._active_slots() + if eval_max_steps == 0: + for slot in active_slots: + self._complete_slot(slot, on_episode_complete=on_episode_complete) + if next_episode_index < len(episode_ids): + self._start_slot( + slot, + episode_id=episode_ids[next_episode_index], + seed=seeds[next_episode_index], + ) + next_episode_index += 1 + continue + + observations = [] + observation_slots: list[_SlotState] = [] + step_capacity_info: dict[int, dict[str, int | bool | None]] = {} + for slot in active_slots: + current_time_ms = self.clock.step_to_time_ms(slot.env_step) + slot.worker_capacity.release_ready(slot.env_step) + self._deliver_arrived_results(slot, raw_frame=slot.env_step) + observation_submitted = False + observation_dropped = False + if self.decision_scheduler.should_observe(slot.env_step, current_time_ms): + prefix_request_pending = ( + self.action_prefix is not None + and self.action_prefix["mode"] != "none" + and slot.result_timeline.pending_observation_count > 0 + ) + if slot.worker_capacity.can_submit() and not prefix_request_pending: + observation_slots.append(slot) + observation_submitted = True + else: + slot.buffers.dropped_observation_count += 1 + observation_dropped = True + slot.recent_drop_count += 1 + if self.simulated_worker_capacity is not None: + step_capacity_info[slot.slot_id] = { + "observation_submitted": observation_submitted, + "observation_dropped": observation_dropped, + } + if slot.decision_action_history is not None and slot.env_step % self.clock.obs_stride_raw_frames == 0: + slot.decision_admitted = observation_submitted + slot.decision_issued_action = slot.action_scheduler.noop_action.value + + observe_ms = 0.0 + if observation_slots: + observe_start = time.perf_counter() + observations_by_slot = self.env_backend.observe_slots([slot.slot_id for slot in observation_slots]) + observe_ms = (time.perf_counter() - observe_start) * 1000.0 + pending_observations = [ + self._sample_policy_observation( + slot, + self._policy_observation( + slot, + observations_by_slot[slot.slot_id], + transport=( + slot.decision_action_history.observation()[0] + if slot.decision_action_history is not None else None + ), + ), + ) + for slot in observation_slots + ] + observations = [pending.observation for pending in pending_observations] + + profile_row = None + if observations: + profiler = StageProfiler(enabled=self.profile_pipeline) + with profiler_scope(profiler): + policy_outputs = ( + self.inference_pool.predict_batch(observations) + if self.inference_pool is not None + else self.policy.predict_batch(observations) + ) + if len(policy_outputs) != len(observations): + raise RuntimeError("policy.predict_batch returned the wrong number of outputs") + if self.profile_pipeline: + profile_row = { + "active_slots": float(len(active_slots)), + "batch_size": float(len(observations)), + "observe_slots_ms": observe_ms, + **{key: float(value) for key, value in profiler.timings.items()}, + } + for pending, policy_output in zip(pending_observations, policy_outputs): + if pending.slot.decision_action_history is not None: + pending.slot.decision_issued_action = policy_output.action.value + self._enqueue_policy_output( + pending.slot, + pending.observation, + policy_output, + obs_id=pending.obs_id, + latency_sample=pending.latency_sample, + worker_slot=pending.worker_slot, + ) + + actions_by_slot = {} + for slot in active_slots: + current_time_ms = self.clock.step_to_time_ms(slot.env_step) + self._deliver_arrived_results(slot, raw_frame=slot.env_step) + active_action = slot.action_scheduler.update(slot.env_step, current_time_ms) + actions_by_slot[slot.slot_id] = active_action + + env_step_start = time.perf_counter() + step_responses = self.env_backend.step_slots(actions_by_slot) + if profile_row is not None: + profile_row["env_step_ms"] = (time.perf_counter() - env_step_start) * 1000.0 + self._pipeline_profile_rows.append(profile_row) + for slot in active_slots: + current_time_ms = self.clock.step_to_time_ms(slot.env_step) + active_action = actions_by_slot[slot.slot_id] + if ( + slot.decision_action_history is not None + and (slot.env_step + 1) % self.clock.obs_stride_raw_frames == 0 + ): + slot.decision_action_history.append( + [0], [slot.decision_admitted], + [slot.decision_issued_action], [active_action.value], + ) + result = step_responses[slot.slot_id].result + soft_reset = bool(result.info.get("soft_reset")) if isinstance(result.info, dict) else False + episode_done = bool(result.done or result.truncated) and not soft_reset + if slot.buffers.step_records is not None: + record = build_step_record( + episode_id=int(slot.episode_id), + env_step=slot.env_step, + scheduled_time_ms=current_time_ms, + active_action=active_action, + reward=result.reward, + done=episode_done, + info=result.info, + active_event=slot.action_scheduler.latest_applied_event, + frame_ms=self.clock.frame_ms, + latency_type=latency_type_from_source(slot.latency_source), + ) + slot.buffers.step_records.append(record) + slot.buffers.record_step(reward=float(result.reward), info=record.info) + else: + slot.buffers.record_step(reward=float(result.reward), info=result.info) + if self.simulated_worker_capacity is not None and slot.buffers.step_records is not None: + slot.buffers.step_records[-1].info.update( + { + **step_capacity_info[slot.slot_id], + "in_flight_count": slot.worker_capacity.in_flight_count, + "idle_worker_count": slot.worker_capacity.idle_worker_count, + } + ) + if soft_reset: + slot.buffers.num_dropped_actions += slot.action_scheduler.dropped_events_count + slot.action_scheduler.reset() + slot.result_timeline.reset() + self._reset_policy_state(slot.slot_id) + slot.worker_capacity.reset() + if slot.decision_action_history is not None: + slot.decision_action_history.reset() + slot.recent_drop_count = 0 + + slot.env_step += 1 + if episode_done or slot.env_step >= eval_max_steps: + self._complete_slot(slot, on_episode_complete=on_episode_complete) + if next_episode_index < len(episode_ids): + self._start_slot( + slot, + episode_id=episode_ids[next_episode_index], + seed=seeds[next_episode_index], + ) + next_episode_index += 1 + + self._write_pipeline_profile_summary() + return self._ordered_metrics(episode_ids) + + def _policy_observation( + self, + slot: _SlotState, + observation: Observation, + transport: np.ndarray | None = None, + ) -> Observation: + observation = with_action_prefix(observation, slot.action_scheduler, self.action_prefix) + metadata = dict(observation.metadata) + metadata["slot_id"] = slot.slot_id + metadata["episode_id"] = int(slot.episode_id) + metadata["action_noise_seed"] = slot.episode_seed + data = observation.data + if transport is not None: + data = {**data, "transport": transport} if isinstance(data, Mapping) else {"obs": data, "transport": transport} + return Observation( + data=data, + env_step=observation.env_step, + sim_time_ms=observation.sim_time_ms, + metadata=metadata, + ) + + def _sample_policy_observation( + self, + slot: _SlotState, + observation: Observation, + ) -> _PendingPolicyObservation: + obs_id = self._next_obs_id + self._next_obs_id += 1 + raw_frame = int(slot.env_step) + current_time_ms = self.clock.step_to_time_ms(raw_frame) + worker_slot = slot.worker_capacity.assign_worker() + latency_context = { + "observation": observation, + "obs_id": obs_id, + "env_step": raw_frame, + "raw_frame": raw_frame, + "sim_time_ms": current_time_ms, + "episode_id": slot.episode_id, + "slot_id": slot.slot_id, + "worker_slot": worker_slot, + "recent_drop_count": slot.recent_drop_count, + "in_flight_count": slot.worker_capacity.in_flight_count, + "idle_worker_count": slot.worker_capacity.idle_worker_count, + } + latency_sample = slot.latency_source.sample(latency_context) + metadata = dict(observation.metadata) + metadata["obs_id"] = obs_id + policy_observation = Observation( + data=observation.data, + env_step=observation.env_step, + sim_time_ms=observation.sim_time_ms, + metadata=metadata, + ) + slot.worker_capacity.submit( + worker_slot, raw_frame + latency_sample.worker_service_raw_frames + ) + return _PendingPolicyObservation( + slot=slot, + obs_id=obs_id, + latency_sample=latency_sample, + worker_slot=worker_slot, + observation=policy_observation, + ) + + def _reset_run_state(self, episode_ids: Sequence[int]) -> None: + self.started_episodes = 0 + self.completed_episodes = 0 + self._pipeline_profile_rows.clear() + self._completed_metrics.clear() + self._completed_buffers.clear() + self._episode_log_order = [int(episode_id) for episode_id in episode_ids] + self._next_episode_log_index = 0 + for slot in self.slots: + slot.active = False + slot.episode_id = None + slot.episode_seed = None + slot.env_step = 0 + slot.recent_drop_count = 0 + slot.buffers = self._new_episode_buffers() + slot.action_scheduler.reset() + slot.result_timeline.reset() + slot.worker_capacity.reset() + if slot.decision_action_history is not None: + slot.decision_action_history.reset() + + def _active_slots(self) -> list[_SlotState]: + return [slot for slot in self.slots if slot.active] + + def _deliver_arrived_results(self, slot: _SlotState, *, raw_frame: int | None) -> None: + released, dropped = slot.result_timeline.release_arrived(raw_frame) + slot.buffers.num_dropped_actions += len(dropped) + for event in released: + slot.action_scheduler.enqueue(event) + + def _start_slot(self, slot: _SlotState, *, episode_id: int, seed: int | None) -> None: + if self.episode_latency_source_factory is not None: + slot.latency_source = self.episode_latency_source_factory(episode_id) + slot.active = True + slot.episode_id = int(episode_id) + slot.episode_seed = None if seed is None else int(seed) + slot.env_step = 0 + slot.recent_drop_count = 0 + slot.buffers = self._new_episode_buffers() + slot.action_scheduler.reset() + slot.result_timeline.reset() + slot.worker_capacity.reset() + if slot.decision_action_history is not None: + slot.decision_action_history.reset() + self._reset_policy_state(slot.slot_id) + self.env_backend.reset_slot(slot.slot_id, episode_id=episode_id, seed=seed) + self.started_episodes += 1 + + def _reset_policy_state(self, slot_id: int) -> None: + if self.inference_pool is not None: + self.inference_pool.reset_state(slot_id) + else: + self.policy.reset_state(slot_id=slot_id) + + def _complete_slot( + self, + slot: _SlotState, + *, + on_episode_complete: Callable[[EpisodeMetrics], None] | None = None, + ) -> None: + if not slot.active or slot.episode_id is None: + return + episode_id = int(slot.episode_id) + self._deliver_arrived_results(slot, raw_frame=None) + slot.buffers.num_dropped_actions += slot.action_scheduler.dropped_events_count + metrics = self._compute_episode_metrics( + episode_id=episode_id, + buffers=slot.buffers, + metadata=episode_raw_fact_metadata( + mode="simulated", + episode_seed=slot.episode_seed, + env_fps=self.clock.env_fps, + obs_fps=self.clock.obs_fps, + frame_ms=self.clock.frame_ms, + latency_type=latency_type_from_source(slot.latency_source), + latency_source=slot.latency_source, + ) + | slot.action_scheduler.chunk_metrics() + | ( + { + "submitted_observation_frames": slot.buffers.submitted_observation_frames, + "dropped_observation_count": slot.buffers.dropped_observation_count, + "simulated_worker_capacity": self.simulated_worker_capacity, + "inference_worker_count": self.simulated_worker_capacity, + "in_flight_count": slot.worker_capacity.in_flight_count, + "idle_worker_count": slot.worker_capacity.idle_worker_count, + } + if self.simulated_worker_capacity is not None + else {} + ), + ) + self._completed_metrics[episode_id] = metrics + self._completed_buffers[episode_id] = slot.buffers + self.completed_episodes += 1 + slot.active = False + slot.episode_id = None + slot.episode_seed = None + slot.env_step = 0 + slot.recent_drop_count = 0 + slot.buffers = self._new_episode_buffers() + slot.action_scheduler.reset() + slot.result_timeline.reset() + slot.worker_capacity.reset() + if slot.decision_action_history is not None: + slot.decision_action_history.reset() + self._flush_completed_in_episode_order() + if on_episode_complete is not None: + on_episode_complete(metrics) + + def _enqueue_policy_output( + self, + slot: _SlotState, + observation, + policy_output, + *, + obs_id: int, + latency_sample: LatencySample, + worker_slot: int, + ) -> None: + raw_frame = int(slot.env_step) + latency_ms = latency_sample.latency_ms + ready_raw_frame = raw_frame + latency_sample.action_ready_raw_frames + ready_time_ms = self.clock.step_to_time_ms(ready_raw_frame) + latency_type = latency_type_from_source(slot.latency_source) + profile_metadata = profile_metadata_from_source(slot.latency_source) + slot_metadata = { + "episode_id": int(slot.episode_id), + "slot_id": int(slot.slot_id), + "worker_id": int(worker_slot), + } + latency_record, event = build_simulated_action_event( + action_id=self._next_action_id, + obs_id=obs_id, + policy_output=policy_output, + raw_frame=raw_frame, + ready_raw_frame=ready_raw_frame, + ready_time_ms=ready_time_ms, + latency_sample=latency_sample, + frame_ms=self.clock.frame_ms, + latency_type=latency_type, + profile_metadata=profile_metadata, + latency_record_metadata=slot_metadata, + extra_event_metadata=slot_metadata, + ) + self._next_action_id += 1 + slot.result_timeline.submit(obs_id=obs_id, ready_raw_frame=ready_raw_frame, event=event) + slot.buffers.submitted_observation_frames += 1 + slot.recent_drop_count = 0 + slot.buffers.num_actions += 1 + if slot.buffers.action_events is not None: + slot.buffers.action_events.append(event) + slot.buffers.latency_values_ms.append(latency_ms) + if slot.buffers.latency_records is not None: + slot.buffers.latency_records.append(latency_record) + + def _flush_completed_in_episode_order(self) -> None: + if self.logger is None: + return + while self._next_episode_log_index < len(self._episode_log_order): + episode_id = self._episode_log_order[self._next_episode_log_index] + if episode_id not in self._completed_metrics: + break + buffers = self._completed_buffers[episode_id] + metrics = self._completed_metrics[episode_id] + if buffers.step_records is not None: + for record in buffers.step_records: + self.logger.log_step(record) + if buffers.action_events is not None: + for event in buffers.action_events: + self.logger.log_action_event(event) + if buffers.latency_records is not None: + for latency_record in buffers.latency_records: + self.logger.log_latency(latency_record) + self.logger.log_episode_metrics(metrics) + self._next_episode_log_index += 1 + + def _ordered_metrics(self, episode_ids: Sequence[int]) -> list[EpisodeMetrics]: + return [self._completed_metrics[int(episode_id)] for episode_id in episode_ids] + + def _new_episode_buffers(self) -> _EpisodeBuffers: + return _EpisodeBuffers( + step_records=[] if self._collect_step_records else None, + action_events=[] if self._collect_action_records else None, + latency_records=[] if self._collect_latency_records else None, + ) + + def _write_pipeline_profile_summary(self) -> None: + if not self.profile_pipeline or self.logger is None or not self._pipeline_profile_rows: + return + keys = sorted({key for row in self._pipeline_profile_rows for key in row}) + summary = { + "num_profiled_batches": len(self._pipeline_profile_rows), + **{ + key: series_stats([float(row[key]) for row in self._pipeline_profile_rows if key in row]) + for key in keys + }, + } + write_json(Path(self.logger.output_dir) / "simulated_pipeline_summary.json", summary) + + def _compute_episode_metrics( + self, + *, + episode_id: int, + buffers: _EpisodeBuffers, + metadata: dict, + ) -> EpisodeMetrics: + if buffers.task_metrics is not None: + metadata["task_metrics"] = buffers.task_metrics + if buffers.task_metric_moments is not None: + metadata["task_metric_moments"] = buffers.task_metric_moments + if buffers.final_lives is not None: + metadata["final_lives"] = buffers.final_lives + if buffers.final_is_true_episode_end is not None: + metadata["final_is_true_episode_end"] = buffers.final_is_true_episode_end + metadata["soft_reset_count"] = buffers.soft_reset_count + if buffers.step_records is not None and buffers.action_events is not None: + return compute_episode_metrics( + episode_id=episode_id, + step_records=buffers.step_records, + action_events=buffers.action_events, + latency_values_ms=buffers.latency_values_ms, + metadata=metadata, + frame_ms=self.clock.frame_ms, + ) + return compute_episode_metrics_from_aggregates( + episode_id=episode_id, + episode_return_env=buffers.episode_return_env, + survival_steps=buffers.survival_steps, + return_raw=buffers.return_raw, + game_score=buffers.game_score, + latency_values_ms=buffers.latency_values_ms, + num_actions=buffers.num_actions, + num_dropped_actions=buffers.num_dropped_actions, + num_invalid_actions=buffers.num_invalid_actions, + metadata=metadata, + ) diff --git a/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/deadly-compatibility.patch b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/deadly-compatibility.patch new file mode 100644 index 0000000000000000000000000000000000000000..bdeca64d184242eedaa57463d2e0a242f43e19ba --- /dev/null +++ b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/deadly-compatibility.patch @@ -0,0 +1,99 @@ +diff --git a/latency_bench/envs/deadly_corridor.py b/latency_bench/envs/deadly_corridor.py +index 4dcaa48c..dc4d1186 100644 +--- a/latency_bench/envs/deadly_corridor.py ++++ b/latency_bench/envs/deadly_corridor.py +@@ -5,7 +5,7 @@ from collections import deque + from typing import Any + + import numpy as np +-from gymnasium.spaces import Box, Tuple ++from gymnasium.spaces import Box, MultiBinary, Tuple + + from latency_bench.core.types import Action, Observation, StepResult + from latency_bench.envs.base import EnvAdapter +@@ -346,6 +346,7 @@ class DeadlyCorridorVlaEnvAdapter(EnvAdapter): + export_env_raw_rgb_frames: bool = True, + ): + import gymnasium as gym ++ import vizdoom + import vizdoom.gymnasium_wrapper # noqa: F401 (registers the env ids) + + env_cfg = config["env"] +@@ -360,30 +361,27 @@ class DeadlyCorridorVlaEnvAdapter(EnvAdapter): + ) + if key in env_cfg + } +- attempts = [ +- ("VizdoomDeadlyCorridor-MultiBinary-v1", {}), +- ("VizdoomDeadlyCorridor-MultiBinary-v0", {}), +- ("VizdoomDeadlyCorridor-v1", {"max_buttons_pressed": 0}), +- ("VizdoomDeadlyCorridor-v0", {"max_buttons_pressed": 0}), +- ] +- last_exc: Exception | None = None +- self.gym_env = None +- for env_id, kwargs in attempts: +- try: +- # frame_skip=1: the latency_bench scheduler advances obs_stride raw +- # frames per decision and holds the action between observations. +- self.gym_env = gym.make( +- env_id, render_mode="rgb_array", frame_skip=1, **render_options, **kwargs +- ) +- self.env_id = env_id +- break +- except (gym.error.NameNotFound, gym.error.VersionNotFound, gym.error.NamespaceNotFound) as exc: +- last_exc = exc +- if self.gym_env is None: +- raise RuntimeError(f"Failed to create Deadly Corridor MultiBinary env: {last_exc}") ++ # ViZDoom registers deadly_corridor.cfg under this official Gym ID. ++ self.env_id = "VizdoomCorridor-v0" ++ self.gym_env = gym.make( ++ self.env_id, render_mode="rgb_array", frame_skip=1, max_buttons_pressed=0, ++ ) ++ game = self.gym_env.unwrapped.game ++ game.close() ++ for key, value in render_options.items(): ++ if key == "screen_resolution": ++ value = getattr(vizdoom.ScreenResolution, value) ++ getattr(game, f"set_{key}")(value) ++ game.init() ++ self.gym_env.unwrapped.observation_space.spaces["screen"] = Box( ++ 0, 255, ++ shape=(game.get_screen_height(), game.get_screen_width(), game.get_screen_channels()), ++ dtype=np.uint8, ++ ) + + self._runtime_button_order = _deadly_runtime_button_names(self.gym_env) + self._num_buttons = len(self._runtime_button_order) ++ self.gym_env.unwrapped.action_space = MultiBinary(self._num_buttons) + self.noop_action = noop_action or Action( + value=[0] * self._num_buttons, name="NOOP", is_noop=True + ) +diff --git a/tests/integration/test_deadly_render_contract.py b/tests/integration/test_deadly_render_contract.py +index 535db22a..09894b1b 100644 +--- a/tests/integration/test_deadly_render_contract.py ++++ b/tests/integration/test_deadly_render_contract.py +@@ -5,11 +5,13 @@ import json + import numpy as np + import pytest + +-pytest.importorskip("vizdoom", minversion="1.3.0") ++pytest.importorskip("vizdoom", minversion="1.2.4") + pytest.importorskip("sample_factory") + + from latency_bench.envs.deadly_corridor import DeadlyCorridorEnvAdapter, DeadlyCorridorVlaEnvAdapter + from latency_bench.envs.raw_rgb import ENV_RAW_RGB_FRAME_STACK_INFO_KEY ++from latency_bench.core.types import Action ++from gymnasium.spaces import MultiBinary + from scripts.tasks.decision_history.eval_vla_hist8 import evaluation_config + + +@@ -33,6 +35,9 @@ def test_hist8_deadly_vla_uses_the_teacher_resolution_and_hud(tmp_path): + # The health/ammo panel is stable across the two engine reset paths; + # the animated face and enemies can differ with their RNG streams. + np.testing.assert_array_equal(teacher_frame[-20:, :64], student_frame[-20:, :64]) ++ assert isinstance(student.gym_env.action_space, MultiBinary) ++ step = student.step(Action(value=[1, 0, 0, 0, 0, 0, 1], name="forward_attack")) ++ assert np.isfinite(step.reward) + finally: + teacher.close() + student.close() diff --git a/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/deadly_corridor.py b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/deadly_corridor.py new file mode 100644 index 0000000000000000000000000000000000000000..1016be20dca9e949c752192edb407b9a84e30e35 --- /dev/null +++ b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/deadly_corridor.py @@ -0,0 +1,455 @@ +from __future__ import annotations + +import copy +from collections import deque +from typing import Any + +import numpy as np +from gymnasium.spaces import Box, MultiBinary, Tuple + +from latency_bench.core.types import Action, Observation, StepResult +from latency_bench.envs.base import EnvAdapter +from latency_bench.utils.array import looks_chw +from latency_bench.envs.raw_rgb import RawRgbFrameStackBuffer + + +def _noop_action_from_space(space) -> Any: + n = getattr(space, "n", None) + if n is not None: + return 0 + if isinstance(space, Tuple): + return tuple(_noop_action_from_space(subspace) for subspace in space.spaces) + if isinstance(space, Box): + import numpy as np + + return np.zeros(space.shape, dtype=space.dtype) + raise TypeError(f"Unsupported action space for Deadly Corridor no-op action: {space}") + + +def _coerce_noop_action_for_space(value: Any, space) -> Any: + if isinstance(space, Tuple): + if isinstance(value, (list, tuple)): + if len(value) != len(space.spaces): + raise ValueError( + f"Deadly Corridor no-op action length {len(value)} does not match action space {space}" + ) + return tuple( + _coerce_noop_action_for_space(item, subspace) + for item, subspace in zip(value, space.spaces) + ) + if value == 0: + return _noop_action_from_space(space) + return value + + +def _spec_with_reward_scaling(spec: Any, disable_reward_scaling: bool) -> Any: + if not disable_reward_scaling: + return spec + spec_to_use = copy.copy(spec) + spec_to_use.reward_scaling = 1.0 + return spec_to_use + + +def _synchronous_eval_fps_from_config(config: dict[str, Any], default: int = 35) -> int: + env_cfg = config.get("env", {}) + try: + fps = int(float(env_cfg.get("env_fps", default))) + except (TypeError, ValueError) as exc: + raise ValueError("env_fps must be positive") from exc + if fps <= 0: + raise ValueError("env_fps must be positive") + return fps + + +def _build_sample_factory_eval_cfg(config: dict[str, Any]) -> Any: + from training.deadly_corridor_sf import integration + from training.common.utils import maybe_set_cli_override + + integration.register_deadly_corridor_components() + base_cfg = integration.SAMPLE_FACTORY_CONFIG_PARSER.parse_eval( + integration.build_cli_args_from_config(config) + ) + eval_fps = _synchronous_eval_fps_from_config(config) + cfg = copy.deepcopy(base_cfg) + if _requires_sample_factory_checkpoint_config(config): + from sample_factory.cfg.arguments import load_from_checkpoint + + cfg = load_from_checkpoint(cfg) + + for key in ( + "seed", + "res_w", + "res_h", + "wide_aspect_ratio", + ): + if hasattr(base_cfg, key): + maybe_set_cli_override(cfg, key, getattr(base_cfg, key)) + maybe_set_cli_override(cfg, "frame_stack", 1) + explicit_max_episode_steps = int(getattr(base_cfg, "max_episode_steps", 0) or 0) + if explicit_max_episode_steps > 0: + maybe_set_cli_override(cfg, "max_episode_steps", explicit_max_episode_steps) + else: + eval_max_steps = int(getattr(base_cfg, "eval_max_steps", 0) or 0) + if eval_max_steps > 0: + maybe_set_cli_override(cfg, "max_episode_steps", eval_max_steps) + + maybe_set_cli_override(cfg, "mode", "eval") + maybe_set_cli_override(cfg, "latency_type", "zero") + maybe_set_cli_override(cfg, "fixed_latency_ms", 0.0) + maybe_set_cli_override(cfg, "env_frameskip", 1) + maybe_set_cli_override(cfg, "eval_env_frameskip", 1) + maybe_set_cli_override(cfg, "num_envs", 1) + maybe_set_cli_override(cfg, "no_render", True) + maybe_set_cli_override(cfg, "save_video", False) + maybe_set_cli_override(cfg, "fps", eval_fps) + maybe_set_cli_override(cfg, "eval_deterministic", bool(getattr(base_cfg, "eval_deterministic", True))) + maybe_set_cli_override(cfg, "disable_reward_scaling", bool(getattr(base_cfg, "eval_raw_reward", False))) + return cfg + + +def _requires_sample_factory_checkpoint_config(config: dict[str, Any]) -> bool: + policy_type = str(config.get("policy", {}).get("type", "")).strip().lower() + return policy_type == "deadly_corridor_sf" + + +def _seed_initialized_vizdoom_game(env: Any, seed: int) -> bool: + unwrapped = getattr(env, "unwrapped", env) + game = getattr(unwrapped, "game", None) + if game is None: + return False + unwrapped.seed(int(seed)) + game.set_seed(int(unwrapped.curr_seed)) + return True + + +class DeadlyCorridorEnvAdapter(EnvAdapter): + """Latency-bench adapter for ViZDoom Deadly Corridor using the SF Doom env stack.""" + OBSERVATION_TYPE = "vizdoom_frame_v1" + + def __init__( + self, + *, + config: dict[str, Any], + noop_action: Action | None = None, + export_env_raw_rgb_frames: bool = False, + ): + env_cfg = config["env"] + env_id = str(env_cfg.get("env_id", "doom_deadly_corridor")) + env_fps = float(env_cfg.get("env_fps", 35)) + self.frame_stack = int(env_cfg.get("frame_stack", 1) or 1) + + from sample_factory.utils.attr_dict import AttrDict + from sf_examples.vizdoom.doom.doom_utils import DOOM_ENVS, make_doom_env_from_spec + + cfg = _build_sample_factory_eval_cfg(config) + spec = next((item for item in DOOM_ENVS if item.name == str(env_id)), None) + if spec is None: + raise ValueError(f"Unknown ViZDoom env spec: {env_id}") + spec_to_use = _spec_with_reward_scaling( + spec, + disable_reward_scaling=bool(getattr(cfg, "disable_reward_scaling", False)), + ) + self.gym_env = make_doom_env_from_spec( + spec_to_use, + str(env_id), + cfg, + AttrDict(worker_index=0, vector_index=0, env_id=0), + render_mode=None, + ) + self.cfg = cfg + self.env_id = env_id + self.env_fps = float(env_fps) + action_space = self.gym_env.action_space + noop_value = _noop_action_from_space(action_space) + if noop_action is None: + self.noop_action = Action(value=noop_value, name=str(noop_value), is_noop=True) + else: + coerced_noop_value = _coerce_noop_action_for_space(noop_action.value, action_space) + self.noop_action = Action( + value=coerced_noop_value, + name=str(coerced_noop_value), + is_noop=True, + is_oneshot=noop_action.is_oneshot, + ) + self.env_step = 0 + self.export_env_raw_rgb_frames = bool(export_env_raw_rgb_frames) + self._last_info: dict[str, Any] = {} + self._last_frame: Any = None + self._observed_frames: deque[np.ndarray] = deque(maxlen=self.frame_stack) + self._raw_rgb_frames = RawRgbFrameStackBuffer(num_frames=self.frame_stack) + + def reset(self, seed: int | None = None) -> Observation: + self.env_step = 0 + self._observed_frames.clear() + if seed is not None: + if _seed_initialized_vizdoom_game(self.gym_env, int(seed)): + obs, info = self.gym_env.reset() + else: + try: + obs, info = self.gym_env.reset(seed=seed) + except TypeError: + obs, info = self.gym_env.reset() + else: + obs, info = self.gym_env.reset() + self._last_frame = obs + self._last_info = dict(info or {}) + self._reset_frame_stack(obs) + if self.export_env_raw_rgb_frames: + self._reset_raw_rgb_frame_stack() + return self._make_observation(info=self._last_info) + + def step(self, action: Action) -> StepResult: + gym_action = action.value + obs, reward, terminated, truncated, info = self.gym_env.step(gym_action) + self.env_step += 1 + self._last_frame = obs + self._last_info = dict(info or {}) + self._append_frame(obs) + if self.export_env_raw_rgb_frames and not bool(terminated or truncated): + self._append_raw_rgb_frame() + observation = self._make_observation(info=self._last_info) + step_info = dict(self._last_info) + step_info.update( + { + "env_step": self.env_step, + "sim_time_ms": self.env_step * self.frame_ms, + "applied_action": gym_action, + "applied_action_name": action.name, + "observation": "vizdoom_frame_v1", + } + ) + return StepResult( + observation=observation, + reward=float(reward), + done=bool(terminated), + truncated=bool(truncated), + info=step_info, + ) + + def observe(self) -> Observation: + if self._last_frame is None: + raise RuntimeError("DeadlyCorridorEnvAdapter has no current observation; call reset() first") + metadata = self._metadata(self._last_info) + return Observation( + data=self._policy_frame_stack(), + env_step=self.env_step, + sim_time_ms=self.env_step * self.frame_ms, + metadata=metadata, + ) + + def render_game_frame(self) -> np.ndarray: + return np.transpose(self.gym_env.unwrapped.game.get_state().screen_buffer, (1, 2, 0)) + + def close(self) -> None: + self.gym_env.close() + + def _reset_frame_stack(self, frame: Any) -> None: + self._observed_frames.clear() + self._append_frame(frame) + + def _append_frame(self, frame: Any) -> None: + self._observed_frames.append(_single_frame_data(frame)) + + def _policy_frame_stack(self) -> np.ndarray: + frames = list(self._observed_frames) + if not frames: + raise RuntimeError("Deadly Corridor observe() has no current frame; call reset() first") + if len(frames) < self.frame_stack: + frames = [frames[0]] * (self.frame_stack - len(frames)) + frames + frames = [np.asarray(frame, dtype=np.uint8) for frame in frames[-self.frame_stack :]] + if self.frame_stack == 1: + return frames[-1] + axis = 0 if looks_chw(frames[0]) else -1 + return np.concatenate(frames, axis=axis) + + +def _single_frame_data(frame: Any) -> np.ndarray: + value = frame.get("obs") if isinstance(frame, dict) else frame + arr = np.asarray(value, dtype=np.uint8) + if arr.ndim == 2: + return arr[..., None] + if arr.ndim != 3: + raise ValueError(f"Expected Deadly Corridor image frame with 2 or 3 dims, got {arr.shape!r}") + return arr + + +# Fixed semantic button order the StarVLA multibinary head is trained against. +# Mirrors starVLA.training.rl_games.eval_core._semantic_to_runtime_multibinary. +DEADLY_CORRIDOR_SEMANTIC_BUTTON_ORDER = ( + "MOVE_FORWARD", + "MOVE_BACKWARD", + "MOVE_LEFT", + "MOVE_RIGHT", + "TURN_LEFT", + "TURN_RIGHT", + "ATTACK", +) + + +def _deadly_runtime_button_names(gym_env: Any) -> list[str]: + """Return the live ViZDoom action-button order (ports eval_core helper). + + The MultiBinary action vector is indexed by the game's available-button + order, which is not guaranteed to equal the semantic order the head emits. + """ + + def _button_name(button: Any) -> str: + name = getattr(button, "name", None) + if name is not None: + return str(name) + text = str(button) + return text.split(".")[-1] if "." in text else text + + for candidate in (gym_env, getattr(gym_env, "unwrapped", None)): + if candidate is None: + continue + for attr_name in ("game", "_game"): + game = getattr(candidate, attr_name, None) + if game is None: + continue + getter = getattr(game, "get_available_buttons", None) + if getter is None: + continue + names = [_button_name(button) for button in getter()] + if names: + return names + return list(DEADLY_CORRIDOR_SEMANTIC_BUTTON_ORDER) + + +def _semantic_to_runtime_multibinary(semantic_values: list[int], runtime_order: list[str]) -> list[int]: + semantic_map = { + name: int(semantic_values[idx]) + for idx, name in enumerate(DEADLY_CORRIDOR_SEMANTIC_BUTTON_ORDER) + if idx < len(semantic_values) + } + return [semantic_map.get(name, 0) for name in runtime_order] + + +class DeadlyCorridorVlaEnvAdapter(EnvAdapter): + """Deadly Corridor adapter for StarVLA eval, matching eval_core's env. + + Unlike :class:`DeadlyCorridorEnvAdapter` (sample_factory, factorised action + tuple), this uses the gymnasium ``VizdoomDeadlyCorridor-MultiBinary`` env so + the model's multibinary head can fire arbitrary button subsets, exactly like + ``starVLA.training.rl_games.eval_core``. Native ``frame_skip=1`` is used so + latency_bench's observation-cadence scheduler owns the obs_stride stepping + (see ObservationCadenceDecisionScheduler); setting a native skip would + double-count it. + """ + + OBSERVATION_TYPE = "vizdoom_frame_v1" + + def __init__( + self, + *, + config: dict[str, Any], + noop_action: Action | None = None, + export_env_raw_rgb_frames: bool = True, + ): + import gymnasium as gym + import vizdoom + import vizdoom.gymnasium_wrapper # noqa: F401 (registers the env ids) + + env_cfg = config["env"] + self.env_fps = float(env_cfg.get("env_fps", 35)) + self.frame_stack = int(env_cfg.get("frame_stack", 1) or 1) + # The raw teacher view is part of the policy's observation contract. + render_options = { + key: env_cfg[key] + for key in ( + "screen_resolution", "render_hud", "render_crosshair", + "render_weapon", "render_decals", "render_particles", + ) + if key in env_cfg + } + # ViZDoom registers deadly_corridor.cfg under this official Gym ID. + self.env_id = "VizdoomCorridor-v0" + self.gym_env = gym.make( + self.env_id, render_mode="rgb_array", frame_skip=1, max_buttons_pressed=0, + ) + game = self.gym_env.unwrapped.game + game.close() + for key, value in render_options.items(): + if key == "screen_resolution": + value = getattr(vizdoom.ScreenResolution, value) + getattr(game, f"set_{key}")(value) + game.init() + self.gym_env.unwrapped.observation_space.spaces["screen"] = Box( + 0, 255, + shape=(game.get_screen_height(), game.get_screen_width(), game.get_screen_channels()), + dtype=np.uint8, + ) + + self._runtime_button_order = _deadly_runtime_button_names(self.gym_env) + self._num_buttons = len(self._runtime_button_order) + self.gym_env.unwrapped.action_space = MultiBinary(self._num_buttons) + self.noop_action = noop_action or Action( + value=[0] * self._num_buttons, name="NOOP", is_noop=True + ) + self.export_env_raw_rgb_frames = bool(export_env_raw_rgb_frames) + self.env_step = 0 + self._last_info: dict[str, Any] = {} + self._last_frame: Any = None + self._raw_rgb_frames = RawRgbFrameStackBuffer(num_frames=self.frame_stack) + + def reset(self, seed: int | None = None) -> Observation: + self.env_step = 0 + try: + obs, info = self.gym_env.reset(seed=seed) + except TypeError: + obs, info = self.gym_env.reset() + self._last_frame = obs + self._last_info = dict(info or {}) + if self.export_env_raw_rgb_frames: + self._reset_raw_rgb_frame_stack() + return self._make_observation(info=self._last_info) + + def step(self, action: Action) -> StepResult: + # action.value is a 7-dim multibinary vector in semantic order; re-order + # to the live game's button layout before stepping the MultiBinary env. + semantic = [int(v) for v in np.asarray(action.value).reshape(-1).tolist()] + expected = len(DEADLY_CORRIDOR_SEMANTIC_BUTTON_ORDER) + if len(semantic) != expected: + raise ValueError( + "DeadlyCorridorVlaEnvAdapter expects a " + f"{expected}-dim multibinary action in semantic order, got " + f"{len(semantic)} values ({action.value!r}). This usually means the " + "policy decoded a non-multibinary layout; ensure the deadly head is " + "action_layout=multibinary_7 and reached the multibinary decode path." + ) + runtime_buttons = _semantic_to_runtime_multibinary(semantic, self._runtime_button_order) + gym_action = np.asarray(runtime_buttons, dtype=np.int8) + obs, reward, terminated, truncated, info = self.gym_env.step(gym_action) + self.env_step += 1 + self._last_frame = obs + self._last_info = dict(info or {}) + if self.export_env_raw_rgb_frames and not bool(terminated or truncated): + self._append_raw_rgb_frame() + observation = self._make_observation(info=self._last_info) + step_info = dict(self._last_info) + step_info.update( + { + "env_step": self.env_step, + "sim_time_ms": self.env_step * self.frame_ms, + "applied_action": runtime_buttons, + "applied_action_name": action.name, + "observation": self.OBSERVATION_TYPE, + } + ) + return StepResult( + observation=observation, + reward=float(reward), + done=bool(terminated), + truncated=bool(truncated), + info=step_info, + ) + + def observe(self) -> Observation: + return self._make_observation(info=self._last_info) + + def render_game_frame(self) -> np.ndarray: + frame = self.gym_env.render() + return np.asarray(frame, dtype=np.uint8) + + def close(self) -> None: + self.gym_env.close() diff --git a/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/decision_action_history.py b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/decision_action_history.py new file mode 100644 index 0000000000000000000000000000000000000000..13f64ef81329e0b3c9296a066e17196a7e6c1d56 --- /dev/null +++ b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/decision_action_history.py @@ -0,0 +1,60 @@ +"""Causal action history sampled at completed decision boundaries.""" + +from __future__ import annotations + +import numpy as np +from gymnasium.spaces import Discrete, MultiBinary, Tuple + + +class DecisionActionHistory: + """Encode admission, admitted command, and last applied action for each decision.""" + + def __init__(self, action_space, *, num_envs: int, decisions: int): + self._multibinary = isinstance(action_space, MultiBinary) + if isinstance(action_space, Discrete): + self.action_sizes = (action_space.n,) + elif isinstance(action_space, Tuple) and all(isinstance(space, Discrete) for space in action_space.spaces): + self.action_sizes = tuple(space.n for space in action_space.spaces) + elif self._multibinary and action_space.shape == (7,): + self.action_sizes = (3, 3, 3, 2) + else: + raise NotImplementedError(f"Decision action history does not support {action_space!r}") + self.decisions = decisions + self.action_dim = sum(size - 1 for size in self.action_sizes) + self.step_dim = 1 + 2 * self.action_dim + self.data = np.zeros((num_envs, decisions, self.step_dim), dtype=np.float32) + self._basis = tuple(np.eye(size, dtype=np.float32)[:, 1:] for size in self.action_sizes) + + @property + def observation_dim(self) -> int: + return self.decisions * self.step_dim + + def reset(self, indices=None) -> None: + if indices is None: + self.data.fill(0) + else: + self.data[indices] = 0 + + def append(self, indices, admitted, issued_actions, applied_actions) -> None: + admitted = np.asarray(admitted, dtype=np.float32).reshape(-1) + issued = self._encode(issued_actions) * admitted[:, None] + applied = self._encode(applied_actions) + rows = self.data[indices].copy() + rows[:, :-1] = rows[:, 1:] + rows[:, -1, 0] = admitted + rows[:, -1, 1 : 1 + self.action_dim] = issued + rows[:, -1, 1 + self.action_dim :] = applied + self.data[indices] = rows + + def observation(self) -> np.ndarray: + return self.data.reshape(self.data.shape[0], self.observation_dim).copy() + + def _encode(self, actions) -> np.ndarray: + if self._multibinary: + # The VLA button order is move, strafe, turn, attack; teacher history + # encodes turn, move, strafe, attack. Keep both opposing bits if issued. + return np.asarray(actions, dtype=np.float32).reshape(-1, 7)[:, [4, 5, 0, 1, 2, 3, 6]] + values = np.asarray(actions, dtype=np.int64).reshape(-1, len(self.action_sizes)) + return np.concatenate( + [basis[values[:, index]] for index, basis in enumerate(self._basis)], axis=1 + ) diff --git a/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/eval_driver.py b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/eval_driver.py new file mode 100644 index 0000000000000000000000000000000000000000..fca10fa388e20c9df4abb2f235ac4ea284a3144c --- /dev/null +++ b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/eval_driver.py @@ -0,0 +1,216 @@ +"""Single evaluation driver: run one config's episodes and attach metadata. + +This is the core ``run_from_config`` and its episode-side helpers. Sweep/suite +orchestration lives in :mod:`latency_bench.eval.sweeps`; the CLI in +:mod:`latency_bench.run`. +""" +from __future__ import annotations + +from collections.abc import Callable, Sequence +from pathlib import Path +from typing import Any + +import yaml + +from training.common.utils import seed_everything +from latency_bench.core.types import EpisodeMetrics, ExecutorMode +from latency_bench.eval.config import ( + _episode_seed, + _eval_episodes, + _eval_max_steps, + _evaluation_seed, + resolve_evaluation_config, +) +from latency_bench.eval.reporting import _write_non_sweep_summary +from latency_bench.envs.base import EnvAdapter +from latency_bench.executors.base import BatchedExecutor +from latency_bench.executors.factory import build_executor +from latency_bench.executors.realtime_warmup import plot_realtime_eval_latency +from latency_bench.latency.config import latency_type_from_config +from latency_bench.logging.action_trace_replay import record_videos_from_action_trace +from latency_bench.logging.video import select_episode_return_stratified + + +def run_from_config( + config: dict[str, Any], + extra_metadata: dict[str, Any] | None = None, + *, + write_summary: bool = True, + on_episode_complete: Callable[[EpisodeMetrics], None] | None = None, + episode_ids: Sequence[int] | None = None, + policy: Any | None = None, + env: EnvAdapter | None = None, + env_backend: Any | None = None, + inference_devices: list[str] | None = None, +) -> list[EpisodeMetrics]: + eval_max_steps = _eval_max_steps(config) + resolve_evaluation_config(config) + if ( + policy is None + and env is None + and env_backend is None + and config["policy"]["type"] == "starvla" + ): + from latency_bench.policy.starvla import prepare_starvla_checkpoint_input_config + + prepare_starvla_checkpoint_input_config(config) + + experiment_cfg = config["experiment"] + policy_cfg = config["policy"] + logging_cfg = config["logging"] + seed = _evaluation_seed(config) + configured_num_episodes = _eval_episodes(config) + selected_episode_ids = list(range(configured_num_episodes)) if episode_ids is None else list(episode_ids) + seed_everything(seed) + + executor_kwargs = {} + if policy is not None: + executor_kwargs["policy"] = policy + if env is not None: + executor_kwargs["env"] = env + if env_backend is not None: + executor_kwargs["env_backend"] = env_backend + if inference_devices is not None: + executor_kwargs["inference_devices"] = inference_devices + executor = build_executor(config, **executor_kwargs) + metrics = [] + warmup_metadata_by_episode: dict[int, dict[str, Any]] = {} + try: + output_dir = Path(logging_cfg["output_dir"]) + output_dir.mkdir(parents=True, exist_ok=True) + (output_dir / "resolved_config.yaml").write_text( + yaml.safe_dump(config, sort_keys=False), encoding="utf-8" + ) + if isinstance(executor, BatchedExecutor): + warmup_metadata = executor.run_warmup() + run_episodes_kwargs: dict[str, Any] = { + "episode_ids": selected_episode_ids, + "seeds": [_episode_seed(config, episode_id) for episode_id in selected_episode_ids], + "eval_max_steps": eval_max_steps, + } + if on_episode_complete is not None: + run_episodes_kwargs["on_episode_complete"] = on_episode_complete + metrics = list(executor.run_episodes(**run_episodes_kwargs)) + warmup_metadata_by_episode.update( + (episode_id, warmup_metadata) for episode_id in selected_episode_ids + ) + else: + warmup_metadata = executor.run_warmup() + for episode_id in selected_episode_ids: + warmup_metadata_by_episode[episode_id] = warmup_metadata + episode_metrics = executor.run_episode( + episode_id=episode_id, + seed=_episode_seed(config, episode_id), + eval_max_steps=eval_max_steps, + ) + metrics.append(episode_metrics) + if on_episode_complete is not None: + on_episode_complete(episode_metrics) + metrics.sort(key=lambda item: int(item.episode_id)) + for episode_metrics in metrics: + for key, value in _evaluation_raw_fact_metadata(config, int(episode_metrics.episode_id)).items(): + if episode_metrics.metadata.get(key) is None: + episode_metrics.metadata[key] = value + episode_metrics.metadata.update(warmup_metadata_by_episode[int(episode_metrics.episode_id)]) + if "measurement" in config: + episode_metrics.metadata["measurement"] = config["measurement"] + episode_metrics.metadata["config_name"] = experiment_cfg.get("name") + episode_metrics.metadata["run_name"] = experiment_cfg.get("name") + if "checkpoint_path" in policy_cfg: + episode_metrics.metadata["checkpoint_path"] = policy_cfg["checkpoint_path"] + if "profile_path" in config["latency"]: + episode_metrics.metadata["source_profile_path"] = config["latency"]["profile_path"] + if "checkpoint_kind" in policy_cfg: + episode_metrics.metadata["checkpoint_kind"] = str(policy_cfg["checkpoint_kind"]) + episode_metrics.metadata["output_dir"] = str(logging_cfg["output_dir"]) + if "action_prefix" in policy_cfg: + episode_metrics.metadata["action_prefix"] = policy_cfg["action_prefix"] + if extra_metadata: + episode_metrics.metadata.update(extra_metadata) + if executor.logger is not None: + executor.logger.flush() + _record_realtime_eval_latency_plot(config, executor) + if write_summary: + _write_non_sweep_summary(config, metrics) + _record_stratified_replay_videos(config, metrics, seed=seed) + finally: + executor.close() + return metrics + + +def _record_realtime_eval_latency_plot(config: dict[str, Any], executor: Any) -> None: + if ExecutorMode(config["executor"]["mode"]) != ExecutorMode.REALTIME: + return + if not config["logging"]["save_latency_records"]: + return + + latency_values = list(executor.logger.latency_ms_values) + plot_realtime_eval_latency( + latency_values, + Path(config["logging"]["output_dir"]) / "eval_latency_trace.png", + ) + + +def _record_stratified_replay_videos( + config: dict[str, Any], + metrics: list[EpisodeMetrics], + *, + seed: int, +) -> None: + if "video" not in config["logging"]: + return + video_cfg = config["logging"]["video"] + if not video_cfg["enabled"]: + return + if not config["logging"]["save_step_records"]: + # Replay reads steps.jsonl, which is only written when save_step_records is on. + # Without it (e.g. factor-sweep evals) skip video instead of crashing on a missing file. + return + if ExecutorMode(config["executor"]["mode"]) == ExecutorMode.REALTIME: + return + selections = select_episode_return_stratified( + metrics, + num_bins=video_cfg["num_bins"], + seed=seed, + ) + record_videos_from_action_trace(config, selections=selections, metrics=metrics) + + +def _evaluation_raw_fact_metadata(config: dict[str, Any], episode_id: int) -> dict[str, Any]: + env_cfg = config.get("env", {}) + policy_cfg = config.get("policy", {}) + latency_cfg = config.get("latency", {}) + executor_cfg = config.get("executor", {}) + env_fps = float(env_cfg["env_fps"]) if "env_fps" in env_cfg else None + obs_fps = float(env_cfg["obs_fps"]) if "obs_fps" in env_cfg else None + frame_ms = None if env_fps is None or env_fps <= 0 else 1000.0 / env_fps + executor_mode = str(executor_cfg.get("mode", "")).strip().lower() + latency_type = latency_type_from_config(latency_cfg) + if executor_mode == "paused": + latency_type = "zero" + elif executor_mode == "realtime": + latency_type = "measured" + return { + "mode": executor_cfg.get("mode"), + "episode_seed": _episode_seed(config, episode_id), + "policy_id": _metadata_id(policy_cfg, "policy_id", "id", "type"), + "env_id": _metadata_id(env_cfg, "env_id", "id", "name"), + "model_id": latency_cfg.get("model_id"), + "gpu_class": latency_cfg.get("gpu_class"), + "workload_id": latency_cfg.get("workload_id"), + "instance_id": latency_cfg.get("instance_id"), + "source_run_id": latency_cfg.get("source_run_id"), + "profile_ref": latency_cfg.get("profile_ref"), + "env_fps": env_fps, + "obs_fps": obs_fps, + "frame_ms": frame_ms, + "latency_type": latency_type, + } + + +def _metadata_id(config: dict[str, Any], *keys: str) -> str | None: + for key in keys: + value = config.get(key) + if value is not None: + return str(value) + return None diff --git a/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/mikasa_evaluate.py b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/mikasa_evaluate.py new file mode 100644 index 0000000000000000000000000000000000000000..19206ec9dfd77ce730fbaee77fe932956dac0b4d --- /dev/null +++ b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/mikasa_evaluate.py @@ -0,0 +1,341 @@ +#!/usr/bin/env python3 +from __future__ import annotations + +import argparse +import json +import sys +from pathlib import Path +from typing import Any + +import gymnasium as gym +import numpy as np +import torch +import yaml + + +ROOT = Path(__file__).resolve().parents[2] +sys.path.insert(0, str(ROOT)) +sys.path.insert(0, str(ROOT / "third_party" / "MIKASA-Robo")) + +from latency_bench.core.types import Action, Observation # noqa: E402 +from latency_bench.executors.gpu_batched_env_step_backend import ( # noqa: E402 + GpuBatchedEnvStepBackendBase, + SlotStepOutcome, +) +from mikasa_robo_suite.seed_reset import ( # noqa: E402 + reset_seeded_slot as _reset_seeded_slot, + reset_seeded_slots as _reset_seeded_slots, +) + + +ENV_ID = "InterceptGrabFast-VLA-v0" +INSTRUCTION = "Intercept the rolling ball and grasp it to stop it." +START_SEED = 4242424242 +MIKASA_IMAGE_VIEWS_INFO_KEY = "mikasa_image_views" +MIKASA_STATE_INFO_KEY = "mikasa_proprio" + + +def _scalar(value: Any) -> Any: + if torch.is_tensor(value): + return value.detach().reshape(-1)[0].cpu().item() + return np.asarray(value).reshape(-1)[0].item() + + +def _make_raw_env( + obs_mode: str, + num_envs: int = 1, + simulator_device: str = "gpu", +): + import mikasa_robo_suite.vla.memory_envs # noqa: F401 + + return gym.make( + ENV_ID, + num_envs=num_envs, + obs_mode=obs_mode, + control_mode="pd_ee_delta_pose", + render_mode="all", + sim_backend=simulator_device, + render_backend=simulator_device, + reward_mode="normalized_dense", + ) + + +def _make_ppo_env(num_envs: int = 1, simulator_device: str = "gpu"): + from baselines.ppo.ppo_memtasks import FlattenRGBDObservationWrapper + from mani_skill.vector.wrappers.gymnasium import ManiSkillVectorEnv + from mikasa_robo_suite.vla.dataset_collectors.get_mikasa_robo_datasets import ( + env_info, + ) + + env = _make_raw_env( + "state", + num_envs=num_envs, + simulator_device=simulator_device, + ) + wrappers, _ = env_info(ENV_ID) + for wrapper, kwargs in wrappers: + env = wrapper(env, **kwargs) + env = FlattenRGBDObservationWrapper(env, rgb=False, depth=False, state=True) + return ManiSkillVectorEnv( + env, + num_envs, + ignore_terminations=True, + record_metrics=True, + ) + + +def _make_vla_env(num_envs: int = 1, simulator_device: str = "gpu"): + from mikasa_robo_suite.vla.utils.apply_wrappers import apply_mikasa_vla_wrappers + + return apply_mikasa_vla_wrappers( + _make_raw_env( + "rgb", + num_envs=num_envs, + simulator_device=simulator_device, + ), + include_overlays=False, + ) + + +class _PpoPolicy: + def __init__(self, env, checkpoint: Path): + from baselines.ppo.ppo_memtasks import AgentStateOnly + + self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + self.agent = AgentStateOnly(env).to(self.device) + self.agent.load_state_dict(torch.load(checkpoint, map_location=self.device)) + self.agent.eval() + + def forward(self, observation): + with torch.no_grad(): + return self.agent.get_action( + {key: value.to(self.device) for key, value in observation.items()}, + deterministic=True, + ) + + +class MikasaEnvStepBackend(GpuBatchedEnvStepBackendBase): + """Own the native MIKASA simulator and its 7D action contract.""" + + backend_name = "mikasa_gpu_batched" + + def __init__(self, *, config: dict[str, Any], num_slots: int, env=None): + noop_action = Action( + value=np.asarray(config["env"]["noop_action"], dtype=np.float32), + name="noop", + is_noop=True, + ) + super().__init__( + config=config, + noop_action=noop_action, + num_slots=num_slots, + action_space=gym.spaces.Box(-1.0, 1.0, shape=(7,), dtype=np.float32), + ) + self.env = ( + _make_vla_env( + num_envs=num_slots, + simulator_device=config["env"]["simulator_device"], + ) + if env is None + else env + ) + self._episode_seeds = [0] * num_slots + self._success = np.zeros(num_slots, dtype=np.bool_) + self._observation, _ = self.env.reset(seed=self._episode_seeds) + + def _reset_slot_observation(self, slot_id: int, *, seed: int | None) -> Observation: + if seed is not None: + self._episode_seeds[slot_id] = int(seed) + self._observation, _ = _reset_seeded_slot( + self.env, + slot_id=slot_id, + seed=self._episode_seeds[slot_id], + ) + self._env_steps[slot_id] = 0 + self._success[slot_id] = False + return self._observation_for_slot(slot_id) + + def _observe_slot_observations( + self, + slot_ids: list[int], + ) -> dict[int, Observation]: + return {slot_id: self._observation_for_slot(slot_id) for slot_id in slot_ids} + + def _step_cores( + self, + slot_ids: list[int], + *, + actions: np.ndarray, + active_mask: np.ndarray, + ) -> Any: + del slot_ids, active_mask + tensor_actions = torch.as_tensor( + actions, + dtype=torch.float32, + device=self.env.unwrapped.device, + ) + self._observation, reward, terminated, truncated, info = self.env.step( + tensor_actions + ) + return reward, terminated, truncated, info + + def _slot_step_outcome(self, state: Any, slot_id: int) -> SlotStepOutcome: + reward, terminated, truncated, info = state + success = bool(_slot_value(info["success"], slot_id)) + self._success[slot_id] |= success + return SlotStepOutcome( + reward=float(_slot_value(reward, slot_id)), + done=bool(_slot_value(terminated, slot_id)), + truncated=bool(_slot_value(truncated, slot_id)), + info={ + "success": success, + "task_metrics": {"success": float(self._success[slot_id])}, + }, + ) + + def _observation_for_slot(self, slot_id: int) -> Observation: + rgb = self._observation["rgb"] + if torch.is_tensor(rgb): + rgb = rgb.detach().cpu().numpy() + rgb = np.asarray(rgb) + views = np.stack( + [ + np.asarray(rgb[slot_id, :, :, :3], dtype=np.uint8), + np.asarray(rgb[slot_id, :, :, 3:6], dtype=np.uint8), + ] + ) + metadata = { + MIKASA_IMAGE_VIEWS_INFO_KEY: views, + MIKASA_STATE_INFO_KEY: self._observation["proprio"][slot_id].detach().cpu().numpy(), + "slot_id": slot_id, + } + if "action_prefix_state_key" in self.config["env"]: + metadata["action_prefix_state_key"] = self.config["env"]["action_prefix_state_key"] + if "returned_action_context" in self.config["env"]: + context = self.config["env"]["returned_action_context"] + metadata["returned_action_context"] = { + **context, + "order": np.asarray(context["order"]), + "low": np.asarray(context["low"], dtype=np.float32), + "high": np.asarray(context["high"], dtype=np.float32), + } + return Observation( + data=None, + env_step=int(self._env_steps[slot_id]), + sim_time_ms=float(self._env_steps[slot_id]) * self._frame_ms, + metadata=metadata, + ) + + def close(self) -> None: + if not self.closed: + self.env.close() + super().close() + + +def _slot_value(value: Any, slot_id: int) -> Any: + if torch.is_tensor(value): + return value.detach().reshape(-1)[slot_id].cpu().item() + return np.asarray(value).reshape(-1)[slot_id].item() + + +def _evaluate(args: argparse.Namespace) -> dict[str, Any]: + env = _make_ppo_env() + policy = _PpoPolicy(env, args.checkpoint) + seeds = [] + successes = [] + returns = [] + lengths = [] + try: + for episode_index in range(args.episodes): + seed = START_SEED + episode_index + observation, _ = env.reset(seed=seed) + success_once = False + episode_return = 0.0 + for step in range(60): + action = policy.forward(observation) + observation, reward, terminated, truncated, info = env.step(action) + success_once = success_once or bool(_scalar(info["success"])) + episode_return += float(_scalar(reward)) + if bool(_scalar(terminated)) or bool(_scalar(truncated)): + break + seeds.append(seed) + successes.append(success_once) + returns.append(episode_return) + lengths.append(step + 1) + finally: + env.close() + summary = { + "seeds": seeds, + "successes": successes, + "success_rate": float(np.mean(successes)), + "returns": returns, + "lengths": lengths, + } + (args.output_dir / "summary.json").write_text( + json.dumps(summary, indent=2) + "\n", encoding="utf-8" + ) + return summary + + +def _latency_eval(argv: list[str]) -> None: + from latency_bench.core.config import load_config + from latency_bench.eval.config import apply_runtime_overrides + from latency_bench.eval.driver import run_from_config + + parser = argparse.ArgumentParser() + parser.add_argument("--eval-config", type=Path, required=True) + parser.add_argument("--checkpoint-path", type=Path) + parser.add_argument("--model-config-path", type=Path) + parser.add_argument("--task-contract-path", type=Path) + parser.add_argument("--run-name") + parser.add_argument("--output-dir", type=Path) + parser.add_argument("--latency-method", choices=("zero", "temporal")) + parser.add_argument("--profile-path", type=Path) + parser.add_argument("--latency-seed", type=int) + args = parser.parse_args(argv) + config = load_config(args.eval_config) + apply_runtime_overrides( + config, + checkpoint_path=args.checkpoint_path, + model_config_path=args.model_config_path, + task_contract_path=args.task_contract_path, + run_name=args.run_name, + output_dir=args.output_dir, + latency_method=args.latency_method, + latency_profile_path=args.profile_path, + latency_seed=args.latency_seed, + ) + output_dir = Path(config["logging"]["output_dir"]) + output_dir.mkdir(parents=True, exist_ok=True) + (output_dir / "eval_config.yaml").write_text( + yaml.safe_dump(config, sort_keys=False), encoding="utf-8" + ) + backend = MikasaEnvStepBackend( + config=config, + num_slots=int(config["evaluation"]["eval_parallel_envs"]), + ) + run_from_config( + config, + env_backend=backend, + inference_devices=config["executor"]["inference_devices"], + ) + + +def main() -> None: + if sys.argv[1:2] == ["latency-eval"]: + _latency_eval(sys.argv[2:]) + return + + parser = argparse.ArgumentParser() + parser.add_argument("--policy", choices=("ppo",), required=True) + parser.add_argument("--checkpoint", type=Path) + parser.add_argument("--episodes", type=int, default=50) + parser.add_argument("--output-dir", type=Path, required=True) + args = parser.parse_args() + args.output_dir.mkdir(parents=True, exist_ok=True) + + _evaluate(args) + + +if __name__ == "__main__": + main() diff --git a/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/starvla.py b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/starvla.py new file mode 100644 index 0000000000000000000000000000000000000000..7b9cab3b3fad77d6f6a3b7919ff4a8124c98d011 --- /dev/null +++ b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/starvla.py @@ -0,0 +1,1207 @@ +from __future__ import annotations + +import json +import sys +from collections.abc import Mapping, Sequence +from pathlib import Path +from typing import Any + +import numpy as np +import numpy.typing as npt +from PIL import Image + +from latency_bench.core.actions import ActionResolver +from latency_bench.core.clock import EnvClock +from latency_bench.core.timing import current_profiler +from latency_bench.core.types import Action, Observation, PolicyOutput +from latency_bench.data.ghost_trail import GhostTrailConfig, build_flappy_ghost_trail_window +from latency_bench.data.state_normalization import min_max_normalize_state +from latency_bench.envs.raw_rgb import ENV_RAW_RGB_FRAME_STACK_INFO_KEY +from latency_bench.envs.gymnasium_task import ( + gymnasium_action_space_contract, + gymnasium_task_contract, +) +from latency_bench.policy.base import PolicyRunner +from latency_bench.policy.starvla_prompts import load_latency_prompt_map, resolve_starvla_prompt + +from latency_bench.utils.paths import REPO_ROOT + + +STARVLA_ROOT = REPO_ROOT / "third_party" / "starVLA" +STATEFUL_STARVLA_MODEL_IDS: tuple[str, ...] = ( + "pi0", + "pi-0", + "pi05", + "pi-0.5", + "gr00t", + "qwenpi", + "qwenpi_v3", + "qwengr00t", +) +STATELESS_STARVLA_MODEL_IDS: tuple[str, ...] = ( + "openvla", + "qwenoft", +) + +DEMON_ATTACK_ACTION_LABELS: tuple[str, ...] = ( + "NOOP", + "FIRE", + "RIGHT", + "LEFT", + "RIGHTFIRE", + "LEFTFIRE", +) +DEADLY_CORRIDOR_TURN_LABELS: tuple[str, ...] = ( + "TURN_NOOP", + "TURN_LEFT", + "TURN_RIGHT", +) +DEADLY_CORRIDOR_MOVE_LABELS: tuple[str, ...] = ( + "MOVE_NOOP", + "MOVE_FORWARD", + "MOVE_BACKWARD", +) +DEADLY_CORRIDOR_STRAFE_LABELS: tuple[str, ...] = ( + "STRAFE_NOOP", + "MOVE_LEFT", + "MOVE_RIGHT", +) +DEADLY_CORRIDOR_ATTACK_LABELS: tuple[str, ...] = ( + "ATTACK_NOOP", + "ATTACK", +) + + +class StarVlaPolicyRunner(PolicyRunner): + """Translate observations and model outputs using the task action contract.""" + + def __init__( + self, + *, + wrapper: Any, + checkpoint_path: str, + device: str, + unnorm_key: str | None, + env_name: str, + action_resolver: ActionResolver, + action_refs: Sequence[Any], + latency_prompt_map: dict[str, Any] | None = None, + base_prompt: str | None = None, + latency_prompt_key: int | str | None = None, + prompt_mode: str | None = None, + obs_resize: tuple[int, int] | None = None, + image_transform_config: Mapping[str, Any] | None = None, + observation_stride_raw_frames: int, + model_cfg: Mapping[str, Any] | None = None, + state_normalization: Mapping[str, Any] | None = None, + state_source: str | None = None, + image_views_info_key: str | None = None, + action_output_type: str | None = None, + ) -> None: + self._wrapper = wrapper + self._obs_resize = tuple(obs_resize) if obs_resize else None + self._checkpoint_path = checkpoint_path + self._device = device + self._unnorm_key = unnorm_key + self._env_name = env_name + self._action_by_raw_id = { + raw_action_id: action_resolver.resolve(action_ref) + for raw_action_id, action_ref in enumerate(action_refs) + } + self._latency_prompt_map = latency_prompt_map + self._base_prompt = base_prompt + self._latency_prompt_key = latency_prompt_key + self._prompt_mode = str(prompt_mode or "default").strip().lower() + self._image_transform_config = dict(image_transform_config or {"image_transform": "raw_rgb"}) + self._image_transform = str( + self._image_transform_config.get("image_transform", "raw_rgb") or "raw_rgb" + ).strip().lower() + model_cfg = ( + _normalized_model_cfg_from_wrapper(wrapper) + if model_cfg is None + else _normalized_model_cfg(model_cfg) + ) + self._include_state = _include_state_from_model_cfg(model_cfg) + self._state_dim = _state_dim_from_model_cfg(model_cfg) if self._include_state else None + self._state_normalization = dict(state_normalization or {}) + self._state_source = state_source + self._image_views_info_key = image_views_info_key + self._action_output_type = action_output_type + vla_data = (model_cfg.get("datasets", {}) or {}).get("vla_data", {}) or {} + self._pack_image_sequence = ( + bool(vla_data["pack_image_sequence"]) + if "pack_image_sequence" in vla_data + else False + ) + self._image_sequence_length = ( + int(vla_data["image_sequence_length"]) + if self._pack_image_sequence + else 1 + ) + self._observation_stride_raw_frames = int(observation_stride_raw_frames) + self._image_sequence_raw_span = ( + 1 + + (self._image_sequence_length - 1) + * self._observation_stride_raw_frames + ) + self._num_obs_frames = int(vla_data.get("num_obs_frames", 1) or 1) + self._image_mode = str(vla_data.get("image_mode", "single")) + self._stitch_grid = tuple(vla_data.get("stitch_grid", [2, 2])) + framework_cfg = model_cfg["framework"] + kv_cfg = framework_cfg["kv_memory"] if "kv_memory" in framework_cfg else {} + self._kv_memory_enabled = bool(kv_cfg["enabled"]) if "enabled" in kv_cfg else False + + def reset_state(self, slot_id: int | None = None) -> None: + # Clears the model's per-slot KV memory at episode boundaries (req3). + # No-op unless the framework maintains KV memory. + reset = getattr(self._wrapper, "reset_memory", None) + if callable(reset): + reset(slot_id) + + def predict(self, observation: Observation) -> PolicyOutput: + return self.predict_batch([observation])[0] + + def predict_batch(self, observations: Sequence[Observation]) -> list[PolicyOutput]: + profiler = current_profiler() + with profiler.time("policy_build_example_ms"): + examples = [self._build_example(observation) for observation in observations] + with profiler.time("policy_wrapper_predict_action_ms"): + prediction = self._wrapper.predict_action( + examples=examples, unnorm_key=self._unnorm_key, profiler=profiler + ) + with profiler.time("policy_decode_ms"): + outputs = [ + self._decode_prediction( + prediction=prediction, + index=index, + observation=observation, + example=example, + ) + for index, (observation, example) in enumerate(zip(observations, examples)) + ] + return outputs + + def _decode_prediction( + self, + *, + prediction: dict[str, Any], + index: int, + observation: Observation, + example: dict[str, Any], + ) -> PolicyOutput: + actions = np.asarray(prediction["actions"]) + raw_action_scores = ( + np.asarray(prediction["raw_action_scores"]) + if "raw_action_scores" in prediction + else None + ) + return self._policy_output( + observation=observation, + example=example, + action_payload=actions[index, 0], + action_output_type=( + prediction["action_output_type"] + if self._action_output_type is None + else self._action_output_type + ), + raw_action_scores=None if raw_action_scores is None else raw_action_scores[index, 0], + ) + + def _build_example(self, observation: Observation) -> dict[str, Any]: + frame_source = observation.metadata[ + ENV_RAW_RGB_FRAME_STACK_INFO_KEY + if self._image_views_info_key is None + else self._image_views_info_key + ] + frames = observation_data_to_hwc_uint8_frames(frame_source) # oldest .. newest + transformed = self._transformed_frame(frames=frames, observation=observation) + + if self._image_views_info_key is not None: + pass + elif self._pack_image_sequence: + if transformed is not None: + raise ValueError( + "WanOFT packed image sequences require image_transform=raw_rgb" + ) + if len(frames) < self._image_sequence_raw_span: + raise ValueError( + "WanOFT packed image sequence requires " + f"{self._image_sequence_raw_span} raw frames for " + f"{self._image_sequence_length} decision observations at stride " + f"{self._observation_stride_raw_frames}, got {len(frames)}" + ) + frames = frames[ + -self._image_sequence_raw_span + :: self._observation_stride_raw_frames + ] + elif transformed is not None: + frames = [transformed] + elif self._image_mode == "single" or self._kv_memory_enabled: + frames = frames[-1:] + else: + # Select the temporal observation window to match training (_pack_sample). + raw_span = 1 + (self._num_obs_frames - 1) * self._observation_stride_raw_frames + frames = frames[-raw_span :: self._observation_stride_raw_frames] + + prompt = resolve_starvla_prompt( + env_name=self._env_name, + observation_metadata=observation.metadata, + latency_prompt_map=self._latency_prompt_map, + base_prompt=self._base_prompt, + latency_prompt_key=self._latency_prompt_key, + prompt_mode=self._prompt_mode, + ) + + if self._image_mode == "stitch": + if transformed is not None: + raise ValueError("image_transform is not compatible with image_mode=stitch") + # Tile the window into one image; matches _pack_sample's stitch branch + # (raw frames passed to stitch_frames, which resizes each cell to 224). + images = [_get_stitch_frames()(frames, grid=self._stitch_grid, size=(224, 224))] + else: + if self._obs_resize is not None: + height, width = self._obs_resize + # match training preprocessing exactly: gr00t LeRobotSingleDataset._pack_sample + # does `Image.fromarray(image).resize((224, 224))` (PIL default resample = BICUBIC). + frames = [ + np.asarray(Image.fromarray(frame).resize((width, height)), dtype=np.uint8) + for frame in frames + ] + images = [Image.fromarray(frame) for frame in frames] + + example = { + "image": images, + "lang": prompt, + } + if self._kv_memory_enabled: + example["slot_id"] = observation.metadata["slot_id"] + elif "slot_id" in observation.metadata: + example["slot_id"] = observation.metadata["slot_id"] + if self._include_state: + if self._state_source == "transport": + state = np.asarray(observation.data["transport"], dtype=np.float32) + example["state"] = state.reshape(1, self._state_dim) + elif self._state_normalization: + state = np.asarray( + observation.metadata["gymnasium_state"], dtype=np.float32 + ) + state_min = np.asarray(self._state_normalization["min"], dtype=np.float32) + state_max = np.asarray(self._state_normalization["max"], dtype=np.float32) + state = min_max_normalize_state(state, state_min, state_max) + example["state"] = state.reshape(1, self._state_dim) + else: + example["state"] = np.zeros((1, self._state_dim), dtype=np.float32) + return example + + def _transformed_frame( + self, + *, + frames: Sequence[npt.NDArray[np.uint8]], + observation: Observation, + ) -> npt.NDArray[np.uint8] | None: + if self._image_transform in {"", "none", "raw", "raw_rgb"}: + return None + if self._image_transform not in {"flappy_ghost_trail", "demon_attack_ghost_trail"}: + raise ValueError(f"Unsupported StarVLA image_transform={self._image_transform!r}") + if self._image_transform == "flappy_ghost_trail" and self._env_name != "flappy": + raise ValueError("image_transform=flappy_ghost_trail is only supported for env_name=flappy") + if self._image_transform == "demon_attack_ghost_trail" and self._env_name != "demon_attack": + raise ValueError("image_transform=demon_attack_ghost_trail is only supported for env_name=demon_attack") + + config = GhostTrailConfig( + image_transform=self._image_transform, + history_frames=int(self._image_transform_config.get("history_frames", 5)), + gamma=float(self._image_transform_config.get("gamma", 1.3)), + min_alpha=int(self._image_transform_config.get("min_alpha", 35)), + ground_fraction=float(self._image_transform_config.get("ground_fraction", 0.22)), + scroll_px_per_step=float(self._image_transform_config.get("scroll_px_per_step", 4.0)), + ) + if self._image_transform == "demon_attack_ghost_trail": + # env_step counts raw ALE frames (buffer updated 4× per decision step). + # frames[-0:] == frames, so env_step=0 falls back to the full reset-fill buffer. + valid_count = min(len(frames), int(observation.env_step)) + else: + max_frames = max(1, int(config.history_frames) + 1) + valid_count = min(len(frames), max(1, int(observation.env_step) + 1), max_frames) + window = [np.asarray(frame, dtype=np.uint8) for frame in frames[-valid_count:]] + + if self._image_transform == "demon_attack_ghost_trail": + from latency_bench.data.ghost_trail_demon import build_demon_attack_ghost_trail_window + steps_arg = list(range(len(window))) + return build_demon_attack_ghost_trail_window(window, steps_arg, config=config) + + current_step = int(observation.env_step) + start_step = current_step - valid_count + 1 + steps = list(range(start_step, current_step + 1)) + return build_flappy_ghost_trail_window(window, steps, config=config) + + def _policy_output( + self, + *, + observation: Observation, + example: dict[str, Any], + action_payload: npt.NDArray[Any], + action_output_type: str, + raw_action_scores: npt.NDArray[Any] | None, + ) -> PolicyOutput: + payload = np.asarray(action_payload) + action, action_metadata = action_from_starvla_payload( + payload=payload, + env_name=self._env_name, + action_by_raw_id=self._action_by_raw_id, + action_output_type=action_output_type, + ) + metadata = { + "policy_type": "starvla", + "prompt_source": "latency_prompt_map" if self._latency_prompt_map is not None else "base", + "checkpoint_path": self._checkpoint_path, + "unnorm_key": self._unnorm_key, + "device": self._device, + "input_frame_count": len(example["image"]), + "image_transform": self._image_transform, + "action_output_type": action_output_type, + "action_payload": to_jsonable_action_payload(payload), + "kv_memory_enabled": self._kv_memory_enabled, + **action_metadata, + } + if self._pack_image_sequence: + metadata["image_sequence_length"] = self._image_sequence_length + metadata["input_frame_raw_stride"] = self._observation_stride_raw_frames + metadata["input_frame_raw_span"] = self._image_sequence_raw_span + if "slot_id" in example: + metadata["slot_id"] = example["slot_id"] + if raw_action_scores is not None: + metadata["raw_action_scores"] = [ + float(item) for item in np.asarray(raw_action_scores, dtype=np.float32).tolist() + ] + if "latency_raw_frames" in observation.metadata: + metadata["latency_raw_frames"] = observation.metadata["latency_raw_frames"] + if "latency_ms" in observation.metadata: + metadata["latency_ms"] = observation.metadata["latency_ms"] + if self._latency_prompt_key is not None: + metadata["latency_prompt_key"] = self._latency_prompt_key + return PolicyOutput( + action=action, + raw_output=metadata["action_payload"], + metadata=metadata, + ) + + +def observation_data_to_hwc_uint8_frames(data: Any) -> list[npt.NDArray[np.uint8]]: + frame = _extract_observation_array(data) + if frame.ndim == 4 and frame.shape[-1] == 3: + return [_as_uint8_image(item) for item in frame] + if frame.ndim == 4 and frame.shape[1] == 3: + return [_as_uint8_image(np.transpose(item, (1, 2, 0))) for item in frame] + if frame.ndim == 3 and frame.shape[-1] == 3: + return [_as_uint8_image(frame)] + if frame.ndim == 3 and frame.shape[0] == 3: + return [_as_uint8_image(np.transpose(frame, (1, 2, 0)))] + if ( + frame.ndim == 3 + and frame.shape[0] % 3 == 0 + and frame.shape[0] < frame.shape[1] + and frame.shape[0] < frame.shape[2] + ): + return [ + _as_uint8_image(np.transpose(frame[start : start + 3, :, :], (1, 2, 0))) + for start in range(0, frame.shape[0], 3) + ] + if frame.ndim == 3 and frame.shape[-1] % 3 == 0: + return [ + _as_uint8_image(frame[:, :, start : start + 3]) + for start in range(0, frame.shape[-1], 3) + ] + if frame.ndim == 3 and frame.shape[0] % 3 == 0: + return [ + _as_uint8_image(np.transpose(frame[start : start + 3, :, :], (1, 2, 0))) + for start in range(0, frame.shape[0], 3) + ] + return [_as_uint8_image(frame)] + + +def decode_starvla_action( + *, + vector: npt.NDArray[Any], + env_name: str, + action_by_raw_id: Mapping[int, Action], + action_layout: str | None = None, +) -> tuple[Action, dict[str, Any]]: + deadly_layout = None + if str(env_name) == "deadly_corridor": + action_dim = int(np.asarray(vector).shape[-1]) + deadly_layouts = { + 7: "deadly_corridor_semantic_7", + 11: "deadly_corridor_factorized_11", + 54: "deadly_corridor_joint_54", + } + if action_dim not in deadly_layouts: + raise ValueError( + "Deadly Corridor StarVLA action vector expected 7, 11, or 54 " + f"values, got {action_dim}" + ) + deadly_layout = deadly_layouts[action_dim] + asterix_layout = None + if str(env_name) == "asterix": + action_dim = int(np.asarray(vector).shape[-1]) + if action_layout is not None: + asterix_layout = str(action_layout).strip().lower() + else: + asterix_layout = "factorized_6" if action_dim < 9 else "discrete_9" + + decode_rl_games_actions, _, _ = _load_rl_games_action_decode() + prediction = decode_rl_games_actions( + normalized_actions=np.asarray(vector), + env_name=str(env_name), + deadly_action_layout=(deadly_layout.removeprefix("deadly_corridor_") if deadly_layout is not None else None), + asterix_action_layout=asterix_layout, + ) + action, metadata = action_from_starvla_payload( + payload=np.asarray(prediction["actions"]), + env_name=env_name, + action_by_raw_id=action_by_raw_id, + action_output_type=prediction["action_output_type"], + ) + if deadly_layout is not None: + metadata["action_layout"] = deadly_layout + if deadly_layout == "deadly_corridor_joint_54": + turn, move, strafe, attack = action.value + metadata["raw_action_id"] = turn * 18 + move * 6 + strafe * 2 + attack + elif deadly_layout == "deadly_corridor_semantic_7": + semantic_actions = ( + [0, 1, 0, 0], + [0, 2, 0, 0], + [0, 0, 1, 0], + [0, 0, 2, 0], + [1, 0, 0, 0], + [2, 0, 0, 0], + [0, 0, 0, 1], + ) + metadata["raw_action_id"] = semantic_actions.index(action.value) + if asterix_layout is not None: + metadata["action_layout"] = asterix_layout + return action, metadata + + +# Fixed semantic button order the StarVLA multibinary head is trained against. +# Mirrors starVLA.training.rl_games.eval_core._semantic_to_runtime_multibinary; +# the env adapter re-orders this to the live ViZDoom button layout. +DEADLY_CORRIDOR_SEMANTIC_BUTTON_ORDER = ( + "MOVE_FORWARD", + "MOVE_BACKWARD", + "MOVE_LEFT", + "MOVE_RIGHT", + "TURN_LEFT", + "TURN_RIGHT", + "ATTACK", +) + + +def action_from_starvla_payload( + *, + payload: npt.NDArray[Any], + env_name: str, + action_by_raw_id: Mapping[int, Action], + action_output_type: str = "", +) -> tuple[Action, dict[str, Any]]: + if str(action_output_type) == "rl_games_continuous": + values = [float(item) for item in np.asarray(payload).reshape(-1).tolist()] + return Action( + value=values, + name="continuous_torque", + is_noop=all(value == 0.0 for value in values), + is_oneshot=False, + ), {"continuous_action": values} + if str(env_name) == "demon_attack": + return demon_attack_action_from_id(int(np.asarray(payload).reshape(-1)[0])) + if str(env_name) == "deadly_corridor": + # Multibinary heads emit an already-thresholded 7-dim button vector in + # fixed semantic order; the env adapter re-orders it to the live ViZDoom + # button layout. Keep it as-is rather than reinterpreting it as a + # [turn, move, strafe, attack] categorical tuple. + if str(action_output_type) == "rl_games_deadly_corridor_multibinary": + buttons = [int(item) for item in np.asarray(payload).reshape(-1).tolist()] + active = [ + DEADLY_CORRIDOR_SEMANTIC_BUTTON_ORDER[idx] + for idx, pressed in enumerate(buttons) + if idx < len(DEADLY_CORRIDOR_SEMANTIC_BUTTON_ORDER) and pressed + ] + action_name = "+".join(active) if active else "NOOP" + return Action( + value=buttons, + name=action_name, + is_noop=not any(buttons), + is_oneshot=False, + ), { + "decoded_multibinary_buttons": buttons, + "action_label": action_name, + "action_layout": "deadly_corridor_multibinary_7", + } + return deadly_corridor_action_from_tuple( + action_value=[int(item) for item in np.asarray(payload).reshape(-1).tolist()], + metadata={"action_layout": "deadly_corridor_tuple"}, + ) + raw_action_id = int(np.asarray(payload).reshape(-1)[0]) + return action_by_raw_id[raw_action_id], {"raw_action_id": raw_action_id} + + +def to_jsonable_action_payload(payload: npt.NDArray[Any]) -> Any: + value = np.asarray(payload).tolist() + if isinstance(value, list) and len(value) == 1: + return value[0] + return value + + +def demon_attack_action_from_id(action_id: int) -> tuple[Action, dict[str, Any]]: + action = Action( + value=action_id, + name=DEMON_ATTACK_ACTION_LABELS[action_id], + is_noop=action_id == 0, + is_oneshot=False, + ) + return action, {"raw_action_id": action_id, "action_label": action.name} + + +def deadly_corridor_action_from_tuple( + *, + action_value: list[int], + metadata: dict[str, Any], +) -> tuple[Action, dict[str, Any]]: + turn, move, strafe, attack = action_value + action_value = [turn, move, strafe, attack] + turn_label = DEADLY_CORRIDOR_TURN_LABELS[turn] + move_label = DEADLY_CORRIDOR_MOVE_LABELS[move] + strafe_label = DEADLY_CORRIDOR_STRAFE_LABELS[strafe] + attack_label = DEADLY_CORRIDOR_ATTACK_LABELS[attack] + active_labels = [ + label + for label in (turn_label, move_label, strafe_label, attack_label) + if not label.endswith("_NOOP") + ] + action_name = "+".join(active_labels) if active_labels else "NOOP" + return Action( + value=action_value, + name=action_name, + is_noop=action_value == [0, 0, 0, 0], + is_oneshot=False, + ), { + "decoded_action_tuple": action_value, + "turn_label": turn_label, + "move_label": move_label, + "strafe_label": strafe_label, + "attack_label": attack_label, + "action_label": action_name, + **metadata, + } + + +def _extract_observation_array(data: Any) -> npt.NDArray[Any]: + if isinstance(data, Mapping): + return np.asarray(data["observation"]) + return np.asarray(data) + + +def _as_uint8_image(frame: npt.NDArray[Any]) -> npt.NDArray[np.uint8]: + return np.ascontiguousarray(frame, dtype=np.uint8) + + +def _normalized_model_cfg(model_cfg: Mapping[str, Any]) -> dict[str, Any]: + _ensure_starvla_path() + from omegaconf import OmegaConf + from starVLA.model.framework.share_tools import apply_config_compat + + cfg = OmegaConf.create(model_cfg) + apply_config_compat(cfg) + _apply_model_family_include_state_compat(cfg) + return OmegaConf.to_container(cfg, resolve=True) + + +def _normalized_model_cfg_from_wrapper(wrapper: Any) -> dict[str, Any]: + return _normalized_model_cfg(wrapper._model_cfg) + + +def _load_starvla_model_config(path: str | Path) -> dict[str, Any]: + from omegaconf import OmegaConf + + return _normalized_model_cfg(OmegaConf.load(path)) + + +def _apply_model_family_include_state_compat(cfg: Any) -> None: + from omegaconf import OmegaConf + + if OmegaConf.select(cfg, "datasets.vla_data.include_state") is not None: + return + + model_ids = ( + _normalized_optional_config_string(cfg, ("model",)), + _normalized_optional_config_string(cfg, ("rl_games", "model_alias")), + _normalized_optional_config_string(cfg, ("framework", "name")), + ) + if any(model_id in STATEFUL_STARVLA_MODEL_IDS for model_id in model_ids if model_id is not None): + OmegaConf.update(cfg, "datasets.vla_data.include_state", True, force_add=True) + return + if any(model_id in STATELESS_STARVLA_MODEL_IDS for model_id in model_ids if model_id is not None): + OmegaConf.update(cfg, "datasets.vla_data.include_state", False, force_add=True) + + +def _normalized_optional_config_string(cfg: Any, path: tuple[str, ...]) -> str | None: + from omegaconf import OmegaConf + + value = OmegaConf.select(cfg, ".".join(path)) + if value is None: + return None + return str(value).strip().lower() + + +def _state_dim_from_model_cfg(model_cfg: dict[str, Any]) -> int: + return model_cfg["framework"]["action_model"]["state_dim"] + + +def _include_state_from_model_cfg(model_cfg: dict[str, Any]) -> bool: + return model_cfg["datasets"]["vla_data"]["include_state"] + + +_STITCH_FRAMES = None + + +def _get_stitch_frames(): + """Lazily import starVLA's stitch_frames (starVLA path is added at runtime).""" + global _STITCH_FRAMES + if _STITCH_FRAMES is None: + _ensure_starvla_path() + from starVLA.training.trainer_utils.trainer_tools import stitch_frames + + _STITCH_FRAMES = stitch_frames + return _STITCH_FRAMES + + +def _ensure_starvla_path() -> None: + starvla_root = str(STARVLA_ROOT) + if starvla_root not in sys.path: + sys.path.insert(0, starvla_root) + + +def _observation_stride_raw_frames(config: Mapping[str, Any]) -> int: + env_cfg = config["env"] + return EnvClock( + env_fps=float(env_cfg["env_fps"]), + obs_fps=float(env_cfg["obs_fps"]), + ).obs_stride_raw_frames + + +def apply_starvla_model_input_config( + config: dict[str, Any], + *, + model_cfg: Mapping[str, Any], + image_transform: str = "raw_rgb", +) -> None: + """Match latency_bench's raw frame stack to a saved StarVLA input contract.""" + vla_data = model_cfg["datasets"]["vla_data"] + pack_image_sequence = ( + bool(vla_data["pack_image_sequence"]) + if "pack_image_sequence" in vla_data + else False + ) + normalized_transform = str(image_transform).strip().lower() + raw_image_transform = normalized_transform in {"", "none", "raw", "raw_rgb"} + if pack_image_sequence: + if not raw_image_transform: + raise ValueError( + "WanOFT packed image sequences require image_transform=raw_rgb" + ) + input_frame_count = int(vla_data["image_sequence_length"]) + else: + if not raw_image_transform: + return + framework_cfg = model_cfg["framework"] + kv_cfg = framework_cfg["kv_memory"] if "kv_memory" in framework_cfg else {} + kv_memory_enabled = bool(kv_cfg["enabled"]) if "enabled" in kv_cfg else False + if kv_memory_enabled: + return + image_mode = str(vla_data["image_mode"]) if "image_mode" in vla_data else "single" + if image_mode == "single": + return + input_frame_count = int(vla_data["num_obs_frames"]) + + observation_stride = _observation_stride_raw_frames(config) + required_raw_frames = 1 + (input_frame_count - 1) * observation_stride + config["env"]["frame_stack"] = max( + int(config["env"]["frame_stack"]), + required_raw_frames, + ) + + +def prepare_starvla_checkpoint_input_config(config: dict[str, Any]) -> None: + """Apply the saved checkpoint input contract before env construction.""" + if config["policy"]["type"] != "starvla": + return + + policy_cfg = config["policy"] + if "task_contract_path" in policy_cfg: + if config["env"]["name"] == "gymnasium": + contract = json.loads( + Path(policy_cfg["task_contract_path"]).read_text(encoding="utf-8") + ) + config["env"]["state_space"] = {"labels": contract["state_labels"]} + if contract["robot_type"] in ("latency_balance_profile_h8", "latency_balance_profile_h16"): + config["env"]["name"] = "balance_profile" + config["env"]["action_context_horizon"] = contract["action_horizon"] + config["env"]["frame_stack"] = 1 + return + if "model_config_path" in policy_cfg: + model_cfg = _load_starvla_model_config(policy_cfg["model_config_path"]) + else: + _ensure_starvla_path() + from starVLA.model.framework.share_tools import read_mode_config + + saved_model_cfg, _norm_stats = read_mode_config(policy_cfg["checkpoint_path"]) + model_cfg = _normalized_model_cfg(saved_model_cfg) + if config["env"]["name"] == "gymnasium": + image_size = model_cfg["rl_games"]["env_eval"]["image_size"] + config["env"]["obs_resize"] = [image_size, image_size] + image_transform_cfg = ( + policy_cfg["image_transform_config"] + if "image_transform_config" in policy_cfg + else {} + ) + image_transform = ( + image_transform_cfg["image_transform"] + if "image_transform" in image_transform_cfg + else "raw_rgb" + ) + apply_starvla_model_input_config( + config, + model_cfg=model_cfg, + image_transform=image_transform, + ) + + +def _load_policy_wrapper_class() -> Any: + _ensure_starvla_path() + from deployment.model_server.policy_wrapper import PolicyServerWrapper + + return PolicyServerWrapper + + +def _profiler_stage(profiler: Any, name: str) -> Any: + from contextlib import nullcontext + + return profiler.time(name) if profiler is not None else nullcontext() + + +def _load_rl_games_action_decode() -> tuple[Any, Any, Any]: + _ensure_starvla_path() + from deployment.model_server.rl_games_action_decode import ( + decode_rl_games_actions, + resolve_asterix_action_decode_spec, + resolve_deadly_action_decode_spec, + ) + + return decode_rl_games_actions, resolve_deadly_action_decode_spec, resolve_asterix_action_decode_spec + + +class LiveStarVlaWrapper: + """In-process stand-in for ``PolicyServerWrapper`` over a *live* framework. + + During training the trainer already holds the model in memory + (``accelerator.unwrap_model(self.model)`` — the same object eval_core calls). + This wrapper exposes only the rl_games-mode surface ``StarVlaPolicyRunner`` + uses — ``predict_action`` (framework forward + rl_games decode), + ``reset_memory`` passthrough, and the ``_model_cfg`` attribute — so no + checkpoint reload is needed. The disk-backed ``PolicyNormProcessor`` is never + built because rl_games decoding ignores un-normalization stats. + """ + + def __init__( + self, + *, + framework: Any, + model_cfg: dict[str, Any], + env_name: str, + rl_games_action_env_dim: int | None = None, + gymnasium_action_space_type: str = "discrete", + action_layout: str | None = None, + multibinary_threshold: float | None = None, + ) -> None: + self._framework = framework + self._model_cfg = model_cfg + self._rl_games_env_name = str(env_name) + self._rl_games_action_env_dim = rl_games_action_env_dim + self._gymnasium_action_space_type = gymnasium_action_space_type + ( + self._decode_rl_games_actions, + resolve_deadly_action_decode_spec, + resolve_asterix_action_decode_spec, + ) = _load_rl_games_action_decode() + self._action_layout = action_layout + self._multibinary_threshold = multibinary_threshold + if self._rl_games_env_name == "deadly_corridor": + self._action_layout, self._multibinary_threshold = resolve_deadly_action_decode_spec( + model_cfg, + action_layout=action_layout, + multibinary_threshold=multibinary_threshold, + ) + elif self._rl_games_env_name == "asterix": + self._action_layout = resolve_asterix_action_decode_spec( + model_cfg, + action_layout=action_layout, + ) + + def reset_memory(self, slot_id: int | None = None) -> None: + reset = getattr(self._framework, "reset_memory", None) + if callable(reset): + reset(slot_id) + + def predict_action( + self, + examples: list[dict[str, Any]], + unnorm_key: str | None = None, + **kwargs: Any, + ) -> dict[str, Any]: + # unnorm_key is unused in rl_games mode; kept for interface parity. + del unnorm_key + profiler = kwargs["profiler"] if "profiler" in kwargs else None + out = self._framework.predict_action(examples=examples, **kwargs) + normalized = np.asarray(out["normalized_actions"]) # (B, T, D) + decode_kwargs: dict[str, Any] = {} + if self._rl_games_env_name == "gymnasium": + decode_kwargs["action_env_dim"] = self._rl_games_action_env_dim + if self._gymnasium_action_space_type == "box": + decode_kwargs["gymnasium_action_space_type"] = "box" + with _profiler_stage(profiler, "starvla_wrapper_rl_games_decode_ms"): + return self._decode_rl_games_actions( + normalized_actions=normalized, + env_name=self._rl_games_env_name, + deadly_action_layout=( + self._action_layout + if self._rl_games_env_name == "deadly_corridor" + else None + ), + deadly_multibinary_threshold=( + self._multibinary_threshold + if self._rl_games_env_name == "deadly_corridor" + else None + ), + asterix_action_layout=( + self._action_layout + if self._rl_games_env_name == "asterix" + else None + ), + **decode_kwargs, + ) + + +_LEGACY_GYMNASIUM_TASK_NAMES = { + "ant_rgb_state": "ant", + "half_cheetah_rgb_state": "half_cheetah", + "hopper_rgb_state": "hopper", + "humanoid_rgb_state": "humanoid", + "inverted_pendulum_rgb_state": "inverted_pendulum", + "swimmer_rgb_state": "swimmer", + "walker2d_rgb_state": "walker2d", +} + + +def _canonical_gymnasium_contract_namespace( + contract: Mapping[str, Any], +) -> dict[str, Any]: + canonical = dict(contract) + task_name = canonical["task_name"] + if task_name in _LEGACY_GYMNASIUM_TASK_NAMES: + canonical["task_name"] = _LEGACY_GYMNASIUM_TASK_NAMES[task_name] + if canonical["env_id"] == "LatencyBench/HopperRgbState-v0": + canonical["env_id"] = "LatencyBench/Hopper-v0" + canonical["registration_imports"] = [ + "latency_bench.envs.gymnasium_hopper" + if module == "latency_bench.envs.gymnasium_hopper_rgb_state" + else module + for module in canonical["registration_imports"] + ] + return canonical + + +def _validate_gymnasium_starvla_contract( + *, + env_cfg: Mapping[str, Any], + policy_cfg: Mapping[str, Any], + model_cfg: Mapping[str, Any], + manifest: Mapping[str, Any], +) -> None: + eval_contract = gymnasium_task_contract(env_cfg) + manifest_task = manifest.get("gymnasium_task") + expected = policy_cfg.get( + "gymnasium_training_task_contract", manifest_task or eval_contract + ) + comparable_eval_contract = {**eval_contract, "make_kwargs": expected["make_kwargs"]} + if _canonical_gymnasium_contract_namespace( + comparable_eval_contract + ) != _canonical_gymnasium_contract_namespace(expected): + raise ValueError( + "Evaluation Gymnasium task contract does not match the StarVLA training contract or dataset manifest" + ) + if manifest.get("integration_name", "gymnasium") != "gymnasium": + raise ValueError("StarVLA task manifest is not a Gymnasium handoff") + if manifest_task is not None: + if _canonical_gymnasium_contract_namespace( + manifest_task + ) != _canonical_gymnasium_contract_namespace(expected): + raise ValueError( + "Evaluation Gymnasium task contract does not match the StarVLA dataset manifest" + ) + model_contract = model_cfg["datasets"]["vla_data"].get("gymnasium_task_contract") + if model_contract is not None: + if _canonical_gymnasium_contract_namespace( + model_contract + ) != _canonical_gymnasium_contract_namespace(expected): + raise ValueError( + "Evaluation Gymnasium task contract does not match the StarVLA model config" + ) + action_space = gymnasium_action_space_contract(env_cfg) + action_layout = str(policy_cfg.get("action_layout", "") or "").strip().lower() + is_asterix_factorized = ( + str(env_cfg.get("task_name", "")) == "asterix" + and action_layout in {"factorized_6", "factorized6", "asterix_factorized_6", "asterix_factorized6"} + ) + if not is_asterix_factorized and manifest["active_action_dim"] != len(action_space["labels"]): + raise ValueError( + "StarVLA dataset active_action_dim does not match its Gymnasium action catalog" + ) + if ( + model_cfg["framework"]["action_model"]["action_env_dim"] + != manifest["active_action_dim"] + ): + raise ValueError( + "StarVLA model action_env_dim does not match the dataset manifest" + ) + model_uses_state = bool(model_cfg["datasets"]["vla_data"]["include_state"]) + manifest_has_state_metadata = ( + "uses_state" in manifest or "state_labels" in manifest + ) + manifest_uses_state = bool(manifest.get("uses_state", model_uses_state)) + if manifest_has_state_metadata: + if policy_cfg.get("state_source") != "transport" and manifest_uses_state != ("state_space" in expected): + raise ValueError( + "StarVLA dataset uses_state does not match the Gymnasium state space" + ) + if manifest_uses_state != model_uses_state: + raise ValueError( + "StarVLA dataset uses_state does not match the model include_state" + ) + if manifest_has_state_metadata and manifest_uses_state: + state_labels = manifest["state_labels"] + expected_state_labels = expected["state_space"]["labels"] if policy_cfg.get("state_source") != "transport" else state_labels + if state_labels != expected_state_labels: + raise ValueError( + "StarVLA dataset state_labels do not match the Gymnasium state space" + ) + if manifest["state_dim"] != len(state_labels): + raise ValueError( + "StarVLA dataset state_dim does not match its state_labels" + ) + if ( + model_cfg["framework"]["action_model"]["state_dim"] + != manifest["state_dim"] + ): + raise ValueError( + "StarVLA model state_dim does not match the dataset manifest" + ) + if not manifest["state_normalization"]: + raise ValueError( + "StarVLA state-enabled dataset manifest is missing state_normalization" + ) + + +def _starvla_runner_kwargs( + config: dict[str, Any], + action_resolver: ActionResolver, + model_cfg: Mapping[str, Any] | None, + *, + base_prompt: str | None, +) -> dict[str, Any]: + """Resolve task and input settings shared by checkpoint and resident models.""" + env_cfg = config["env"] + policy_cfg = config["policy"] + if env_cfg["name"] == "gymnasium": + task_manifest = json.loads( + Path(policy_cfg["task_manifest_path"]).read_text(encoding="utf-8") + ) + _validate_gymnasium_starvla_contract( + env_cfg=env_cfg, + policy_cfg=policy_cfg, + model_cfg=model_cfg, + manifest=task_manifest, + ) + semantic_env_name = env_cfg["task_name"] + action_refs = env_cfg.get("action_order", []) + base_prompt = env_cfg["base_prompt"] + state_normalization = task_manifest.get("state_normalization") + else: + semantic_env_name = env_cfg["name"] + action_refs = policy_cfg.get("actions", action_resolver.default_action_refs()) + state_normalization = policy_cfg["state_normalization"] if "state_normalization" in policy_cfg else None + return dict( + unnorm_key=policy_cfg.get("unnorm_key"), + env_name=semantic_env_name, + action_resolver=action_resolver, + action_refs=action_refs, + latency_prompt_map=( + load_latency_prompt_map(policy_cfg["latency_prompt_map_path"]) + if "latency_prompt_map_path" in policy_cfg + else None + ), + base_prompt=base_prompt, + latency_prompt_key=policy_cfg.get("latency_prompt_key"), + prompt_mode=policy_cfg.get("prompt_mode"), + obs_resize=tuple(env_cfg["obs_resize"]) if env_cfg.get("obs_resize") else None, + image_transform_config=policy_cfg.get("image_transform_config"), + observation_stride_raw_frames=_observation_stride_raw_frames(config), + model_cfg=model_cfg, + state_normalization=state_normalization, + state_source=policy_cfg["state_source"] if "state_source" in policy_cfg else None, + ) + + +def build_starvla_policy( + config: dict[str, Any], + action_resolver: ActionResolver, +) -> PolicyRunner: + policy_cfg = config["policy"] + if "task_contract_path" in policy_cfg: + _ensure_starvla_path() + from latency_bench.policy.starvla_tasks import build_task_starvla_policy + + return build_task_starvla_policy(config) + env_cfg = config["env"] + integration_env_name = env_cfg["name"] + model_cfg = ( + _load_starvla_model_config(policy_cfg["model_config_path"]) + if integration_env_name == "gymnasium" or "model_config_path" in policy_cfg + else None + ) + runner_kwargs = _starvla_runner_kwargs( + config, action_resolver, model_cfg, base_prompt=env_cfg.get("base_prompt") + ) + wrapper_cls = _load_policy_wrapper_class() + wrapper_kwargs: dict[str, Any] = dict( + ckpt_path=policy_cfg["checkpoint_path"], + device=policy_cfg["device"], + use_bf16=True, + unnorm_key=runner_kwargs["unnorm_key"], + action_output_mode=( + policy_cfg["action_output_mode"] + if "action_output_mode" in policy_cfg + else "rl_games" + ), + rl_games_env_name=integration_env_name, + rl_games_action_layout=( + policy_cfg["action_layout"] if "action_layout" in policy_cfg else None + ), + rl_games_multibinary_threshold=( + policy_cfg["multibinary_threshold"] + if "multibinary_threshold" in policy_cfg + else None + ), + ) + if "backbone_path" in policy_cfg: + wrapper_kwargs["backbone_path"] = policy_cfg["backbone_path"] + if integration_env_name == "gymnasium": + action_space = gymnasium_action_space_contract(env_cfg) + wrapper_kwargs["rl_games_action_env_dim"] = len(action_space["labels"]) + if action_space["type"] == "box": + wrapper_kwargs["rl_games_gymnasium_action_space_type"] = "box" + wrapper_kwargs["rl_games_env_name"] = integration_env_name + wrapper = wrapper_cls(**wrapper_kwargs) + return StarVlaPolicyRunner( + wrapper=wrapper, + checkpoint_path=policy_cfg["checkpoint_path"], + device=policy_cfg["device"], + **runner_kwargs, + image_views_info_key=( + policy_cfg["image_views_info_key"] + if "image_views_info_key" in policy_cfg + else None + ), + action_output_type=( + policy_cfg["action_output_type"] + if "action_output_type" in policy_cfg + else None + ), + ) + + +def build_live_starvla_policy( + *, + framework: Any, + model_cfg: dict[str, Any], + config: dict[str, Any], + action_resolver: ActionResolver | None = None, +) -> PolicyRunner: + """Build a StarVLA policy around a *live* in-memory framework (no reload). + + Mirrors ``build_starvla_policy`` but swaps the ckpt-loading + ``PolicyServerWrapper`` for :class:`LiveStarVlaWrapper`, so the trainer's + resident model is evaluated directly. ``model_cfg`` is the in-memory model + config (e.g. ``read_mode_config`` output) the wrapper would otherwise read + from disk. + """ + policy_cfg = config["policy"] + if "task_contract_path" in policy_cfg: + from latency_bench.policy.starvla_tasks import TaskStarVlaPolicyRunner + + contract = json.loads( + Path(policy_cfg["task_contract_path"]).read_text(encoding="utf-8") + ) + return TaskStarVlaPolicyRunner( + framework, + policy_config=policy_cfg, + model_config=model_cfg, + contract=contract, + ) + + env_cfg = config["env"] + integration_env_name = env_cfg["name"] + normalized_model_cfg = ( + _normalized_model_cfg(model_cfg) + if integration_env_name == "gymnasium" + else None + ) + # Resident evaluation historically takes non-Gymnasium prompts from the map. + runner_kwargs = _starvla_runner_kwargs( + config, action_resolver, normalized_model_cfg, base_prompt=None + ) + wrapper_kwargs: dict[str, Any] = dict( + framework=framework, + model_cfg=model_cfg, + env_name=integration_env_name, + action_layout=policy_cfg["action_layout"] if "action_layout" in policy_cfg else None, + multibinary_threshold=( + policy_cfg["multibinary_threshold"] + if "multibinary_threshold" in policy_cfg + else None + ), + ) + if integration_env_name == "gymnasium": + action_space = gymnasium_action_space_contract(env_cfg) + wrapper_kwargs["rl_games_action_env_dim"] = len(action_space["labels"]) + if action_space["type"] == "box": + wrapper_kwargs["gymnasium_action_space_type"] = "box" + wrapper_kwargs["env_name"] = integration_env_name + wrapper = LiveStarVlaWrapper(**wrapper_kwargs) + return StarVlaPolicyRunner( + wrapper=wrapper, + checkpoint_path=policy_cfg.get("checkpoint_path", ""), + device=policy_cfg.get("device", "cuda"), + **runner_kwargs, + ) + + +__all__ = [ + "LiveStarVlaWrapper", + "StarVlaPolicyRunner", + "apply_starvla_model_input_config", + "build_live_starvla_policy", + "build_starvla_policy", + "decode_starvla_action", + "observation_data_to_hwc_uint8_frames", + "prepare_starvla_checkpoint_input_config", +] diff --git a/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/starvla_tasks.py b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/starvla_tasks.py new file mode 100644 index 0000000000000000000000000000000000000000..4a5cc03813f1bc524a30a7b6b7292a4f4fca85d4 --- /dev/null +++ b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/starvla_tasks.py @@ -0,0 +1,92 @@ +"""StarVLA inference using the task's training observation/action contract.""" + +from __future__ import annotations + +import json +from pathlib import Path + +import numpy as np +from PIL import Image + +from latency_bench.core.types import Action, Observation, PolicyOutput +from latency_bench.data.starvla_tasks import denormalize, normalize +from latency_bench.policy.base import PolicyRunner + + +class TaskStarVlaPolicyRunner(PolicyRunner): + """Map task RGB/state into a StarVLA model and decode its action chunk.""" + + def __init__(self, framework, *, policy_config: dict, model_config: dict, contract: dict): + self.framework = framework + self.policy_config = policy_config + self.model_config = model_config + self.contract = contract + + def _example(self, observation: Observation) -> dict: + cfg = self.policy_config + state = normalize( + observation.metadata[cfg["state_info_key"]], + self.contract["normalization"]["state"], + ).reshape(1, self.contract["state_dim"]) + data_cfg = self.model_config["datasets"]["vla_data"] + height, width = data_cfg["obs_image_size"] + images = [ + Image.fromarray(frame).resize((width, height)) + for frame in observation.metadata[cfg["image_views_info_key"]] + ] + if data_cfg["image_mode"] == "stitch_views": + from starVLA.training.trainer_utils.trainer_tools import stitch_frames + + # MIKASA's two simultaneous views form one Wan observation, not a video. + images = [stitch_frames(images, grid=data_cfg["stitch_grid"], size=(width, height))] + example = {"image": images, "state": state, "lang": self.contract["prompt"]} + if "action_prefix" in observation.metadata: + example["action_prefix"] = normalize( + observation.metadata["action_prefix"], + self.contract["normalization"]["action"], + ) + example["action_prefix_mask"] = observation.metadata["action_prefix_mask"] + return example + + def predict(self, observation: Observation) -> PolicyOutput: + return self.predict_batch([observation])[0] + + def predict_batch(self, observations: list[Observation]) -> list[PolicyOutput]: + prediction = self.framework.predict_action( + examples=[self._example(observation) for observation in observations] + ) + actions = denormalize( + prediction["normalized_actions"], self.contract["normalization"]["action"] + ) + # Prefix heads were excluded from the loss; retain the frozen controller plan. + for chunk, observation in zip(actions, observations): + if "action_prefix" in observation.metadata: + mask = observation.metadata["action_prefix_mask"] + chunk[mask] = observation.metadata["action_prefix"][mask] + return [ + PolicyOutput( + action=Action(value=chunk[0].tolist(), name="task_command"), + action_chunk=chunk, + raw_output=chunk.tolist(), + metadata={"policy_type": "starvla", "task": self.contract["task"]}, + ) + for chunk in actions + ] + + +def build_task_starvla_policy(config: dict) -> TaskStarVlaPolicyRunner: + # StarVLA and torch are optional in the simulator process; workers own them. + import torch + from starVLA.model.framework.base_framework import baseframework + from starVLA.model.framework.share_tools import read_mode_config + + cfg = config["policy"] + model_config, _ = read_mode_config(cfg["checkpoint_path"]) + framework = baseframework.from_pretrained( + cfg["checkpoint_path"], backbone_path=cfg["backbone_path"] + ) + framework = framework.to(device=cfg["device"], dtype=torch.bfloat16).eval() + contract = json.loads(Path(cfg["task_contract_path"]).read_text(encoding="utf-8")) + return TaskStarVlaPolicyRunner( + framework, policy_config=cfg, model_config=model_config, contract=contract + ) diff --git a/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-plan.json b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-plan.json new file mode 100644 index 0000000000000000000000000000000000000000..371542eee194a26ff888c211317abe89050b38e0 --- /dev/null +++ b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-plan.json @@ -0,0 +1,105 @@ +{ + "condition": "profile-latency", + "executor_mode": "simulated", + "latency_method": "temporal", + "profile_source": "originalRTX3090immutableprofiles", + "episodes_per_checkpoint": 100, + "total_episodes": 400, + "rounds": [ + [ + "flappy", + "deadly_corridor" + ], + [ + "ant", + "intercept" + ] + ], + "physical_gpu_assignments": { + "flappy": 2, + "deadly_corridor": 3, + "ant": 2, + "intercept": 3 + }, + "single_gpu_per_job": true, + "round2_requires_both_round1_complete": true, + "latency_seed": 271828, + "tasks": { + "flappy": { + "gpu": 2, + "seed_start": 1000000, + "seed_end": 1000099, + "env_fps": 10, + "obs_fps": 10, + "max_raw_steps": 3600, + "parallel_envs": 32, + "checkpoint_revision": "d4825bbad8d15bc50b6b8481eb2abc84846a54fb", + "checkpoint_path": "latency-aware/flappy/vla/starvla-qwenoft-h1/flappy-qwenoft-mean-3090-s42", + "profile": { + "mean_ms": 75.87417450998383, + "profile": "/home/ubuntu/lzj/profiles/published/profiles/openvla/1x-rtx3090/flappy/instance_a5037b165aa0cedc/profile.json", + "sha256": "c266cba7ebac05c7e37bc83f1f16fe4b27dab97942ff43290e6c41514f6e39fc" + }, + "config": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/flappy.yaml", + "output": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/flappy", + "metrics": "return mean/std/min/max;length mean/std;success where nativeprovided;latency/drops/invalid/action audits;100 episode vectors" + }, + "deadly_corridor": { + "gpu": 3, + "seed_start": 1000000, + "seed_end": 1000099, + "env_fps": 35, + "obs_fps": 8.75, + "max_raw_steps": 3600, + "parallel_envs": 32, + "checkpoint_revision": "d4825bbad8d15bc50b6b8481eb2abc84846a54fb", + "checkpoint_path": "latency-aware/deadly-corridor/vla/starvla-qwenoft-h1/deadly_corridor-qwenoft-mean-3090-s42", + "profile": { + "mean_ms": 73.69250777493353, + "profile": "/home/ubuntu/lzj/profiles/published/profiles/openvla/1x-rtx3090/deadly_corridor/instance_a5037b165aa0cedc/profile.json", + "sha256": "bbfb93cef9f63750a9a159ec10a93a9fc6c25e4cb0cac3b39532663b4dc11eba" + }, + "config": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/deadly_corridor.yaml", + "output": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/deadly_corridor", + "metrics": "return mean/std/min/max;length mean/std;success where nativeprovided;latency/drops/invalid/action audits;100 episode vectors" + }, + "ant": { + "gpu": 2, + "seed_start": 42, + "seed_end": 141, + "env_fps": 10, + "obs_fps": 10, + "max_raw_steps": 1000, + "parallel_envs": 16, + "checkpoint_revision": "d4825bbad8d15bc50b6b8481eb2abc84846a54fb", + "checkpoint_path": "latency-aware/ant/vla/starvla-qwenoft-h1/ant-qwenoft-mean-3090-s42", + "profile": { + "mean_ms": 90.56460638563993, + "profile": "/home/ubuntu/lzj/mean-profiling/reference/checkpoint-configs/latency-aware/ant/small-policy/sample-factory-qwenoft-rtx3090-v1/profile/profile.json", + "sha256": "0e49f72ec05ac600a54e07bbca5af3143708444d606167f33fa21788a9fefe50" + }, + "config": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/ant.yaml", + "output": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/ant", + "metrics": "return mean/std/min/max;length mean/std;success where nativeprovided;latency/drops/invalid/action audits;100 episode vectors" + }, + "intercept": { + "gpu": 3, + "seed_start": 4242424242, + "seed_end": 4242424341, + "env_fps": 20, + "obs_fps": 20, + "max_raw_steps": 60, + "parallel_envs": 32, + "checkpoint_revision": "d4825bbad8d15bc50b6b8481eb2abc84846a54fb", + "checkpoint_path": "latency-aware/mikasa-intercept-grab-fast/vla/starvla-qwenoft-h1/intercept-qwenoft-mean-3090-h1-s0", + "profile": { + "mean_ms": 99.05021289731565, + "profile": "/home/ubuntu/lzj/profiles/intercept-published/profiles/qwenoft/1x-rtx3090/mikasa_intercept_grab_fast/instance_3a0d42681a03715c/profile.json", + "sha256": "31a9b15d6b04182439934f0b377cb3d09be16ce21f3cf95c1049918f8a5d4984" + }, + "config": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/intercept.yaml", + "output": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/intercept", + "metrics": "return mean/std/min/max;length mean/std;success where nativeprovided;latency/drops/invalid/action audits;100 episode vectors" + } + } +} diff --git a/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/execution_audit.json b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/execution_audit.json new file mode 100644 index 0000000000000000000000000000000000000000..f31796ff7f863ded0d604d536b2e134831e3e066 --- /dev/null +++ b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/execution_audit.json @@ -0,0 +1,12 @@ +{ + "issued_action_records": 3753, + "applied_action_records": 3673, + "dropped_action_records": 0, + "nonnoop_issued_records": 3753, + "finite_action_values": true, + "latency_sample_count": 3753, + "latency_mean_ms": 74.01999621872471, + "latency_std_ms": 5.5537519652567635, + "latency_p95_ms": 89.54825982614612, + "latency_p99_ms": 95.97310052501227 +} diff --git a/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/files.sha256.json b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/files.sha256.json new file mode 100644 index 0000000000000000000000000000000000000000..dba4b5c6a7651a34c5a6868a9277dfb3c05de805 --- /dev/null +++ b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/files.sha256.json @@ -0,0 +1,130 @@ +{ + "REPORT.md": { + "bytes": 2163, + "sha256": "b2fd63b1cde2a415b2d77daf0184ce5ec3b6ada1aa199c21941fb04031f77db6" + }, + "all_episodes.csv": { + "bytes": 25198, + "sha256": "bd41f35a464250ed6f9bc16e466aa9f1b55a48ac29072bb0ec3559a24129edac" + }, + "comparison.csv": { + "bytes": 438, + "sha256": "a0c7cf191395dd851bd6222bdf61427f15782fea2db4416ddc072a5f5dc8a861" + }, + "comparison.json": { + "bytes": 7826, + "sha256": "0d5dd042439466aee84cd0d96c31a27a951e57965a7e468cb73ec07883f1f751" + }, + "episodes.csv": { + "bytes": 5665, + "sha256": "69e8140b74f407803e15adcf4412ccb7c5a51abd0a9c274ee55a6c51b4e9245d" + }, + "eval_config.yaml": { + "bytes": 3299, + "sha256": "cdebec7e4e48415f530a665a08f2dd98808381ce1d871f75d25385e4a38b54ec" + }, + "evaluation-code/batched_simulated.py": { + "bytes": 31282, + "sha256": "b901f966d911feab7962a32f21095cb90f7880121811f2b4eab2193afe1381db" + }, + "evaluation-code/deadly-compatibility.patch": { + "bytes": 4570, + "sha256": "623676cc4542b1eab6c9395b163b369ddc605353c1de02d17d8f713167ee07fa" + }, + "evaluation-code/deadly_corridor.py": { + "bytes": 17902, + "sha256": "47f7bc65cba9853e66d79ed2a28f844bd2a094f1285458be166045f2db1690dc" + }, + "evaluation-code/decision_action_history.py": { + "bytes": 2746, + "sha256": "14a9d223e775745b6c402dbce9e2a50a1c3f7b5b9fe528150ef8689126fe97cf" + }, + "evaluation-code/eval_driver.py": { + "bytes": 9133, + "sha256": "330030270fbb695bc5f14037ef7349650bd20c53c881c1159ee55ea066408d9e" + }, + "evaluation-code/mikasa_evaluate.py": { + "bytes": 11466, + "sha256": "6cf9ffee25fcfd6f3255c520fc544c48ff2c8f8912e5369c2410a709820c4ffd" + }, + "evaluation-code/starvla.py": { + "bytes": 48378, + "sha256": "6d9988f3a28d39e46c2f6e80da85edebc42cafa629a2b9f75000414324c1065a" + }, + "evaluation-code/starvla_tasks.py": { + "bytes": 4029, + "sha256": "3fc74169d1554d9dc3358ed85e450cca75eb69bc1fff85284c1054a605633a52" + }, + "evaluation-plan.json": { + "bytes": 4698, + "sha256": "b758a5fb72dcdef49d025e2fd168d024ebd8b18b2b00125145b3cde38b16a318" + }, + "execution_audit.json": { + "bytes": 357, + "sha256": "cd445b9926cd0c8b4da3e48d2137bf80ae44e44a0cef30563d3c7a1f2a31b920" + }, + "profile/latency_burst_model.json": { + "bytes": 26211, + "sha256": "2e52774207a61ccc9902ec6c576d75ae0f60925611f1f8a9fc55c3109f7ff34c" + }, + "profile/latency_distribution.json": { + "bytes": 25069, + "sha256": "c6c7926af60218a9b5f8b0fbabb7f10466d224dd739171349650520ef1da9fc8" + }, + "profile/profile.json": { + "bytes": 2115, + "sha256": "bbfb93cef9f63750a9a159ec10a93a9fc6c25e4cb0cac3b39532663b4dc11eba" + }, + "provenance.json": { + "bytes": 3856, + "sha256": "a34689af61c380a5e7a64d3bf25d921a44967aee0c2220c7ede4a36a97b9cae5" + }, + "queue_eval_latency_profile_sample.json": { + "bytes": 3848, + "sha256": "dd4c4be8669838a85c0d7e06c5ccf20f133bb2fb2cacdd9b905972343bbd03b6" + }, + "raw-records/actions.jsonl.gz": { + "bytes": 522227, + "sha256": "53f0b7bb59fb99cdd2917642c9881cb1443f897c78e20f1567929b4b232680fd" + }, + "raw-records/e2e_latencies.jsonl.gz": { + "bytes": 70931, + "sha256": "9c6b0b88fbfb5f6b37ea28ac5c6701c9abc2fa89b2d6b36b7fe747b6c1cf4398" + }, + "raw-records/episode_metrics.jsonl.gz": { + "bytes": 7835, + "sha256": "c96daa6d0d6f5051f6a20701c54ba21ebf5e425740028916cd553e2c8bd7cbd2" + }, + "raw-records/infer_latencies.jsonl.gz": { + "bytes": 60189, + "sha256": "42a899945c8383a4d86d62b77692c1a2f4022a3cec41d5aada23bdc8f45df931" + }, + "raw-records/latencies.jsonl.gz": { + "bytes": 60183, + "sha256": "12d682b1436b118a5058ec2364e2e7ee9cf45035224d7e04e0723689f476b01b" + }, + "raw-records/observation_attempts.jsonl.gz": { + "bytes": 47, + "sha256": "6ce7d0c6fa3086525b7ba82526a5db7d4a26d33a64b16875bdd644c436069469" + }, + "raw-records/queue_eval_results.jsonl.gz": { + "bytes": 1468, + "sha256": "c717edfdd81c255faec3f3f765ecc4d378f353e459e1124a02b3fb070c71a10a" + }, + "raw-records/steps.jsonl.gz": { + "bytes": 495220, + "sha256": "f6a4d4bf35f367394f0754bff9ada16daa229726d0ccbbfede23411cffbdbd74" + }, + "resolved_config.yaml": { + "bytes": 3367, + "sha256": "0ac444e55dcf84745badbb2614d75fc38b23abd09c87aee5fbc2ecba991854f0" + }, + "statistics.json": { + "bytes": 1288, + "sha256": "39d572fde494928e335d2999b2731fc2705e3d98bb260af101e2d1eef2089467" + }, + "stdout.log": { + "bytes": 59183, + "sha256": "3a511f78f66916995fc35c64092732d1e1499a092cb4db441e003c70a6273c2f" + } +} diff --git a/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/provenance.json b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/provenance.json new file mode 100644 index 0000000000000000000000000000000000000000..3fd256ee48d5caba5dd1af86179e478bf9212765 --- /dev/null +++ b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/provenance.json @@ -0,0 +1,97 @@ +{ + "task": "deadly_corridor", + "protocol": { + "gpu": 3, + "seed_start": 1000000, + "seed_end": 1000099, + "env_fps": 35, + "obs_fps": 8.75, + "max_raw_steps": 3600, + "parallel_envs": 32, + "checkpoint_revision": "d4825bbad8d15bc50b6b8481eb2abc84846a54fb", + "checkpoint_path": "latency-aware/deadly-corridor/vla/starvla-qwenoft-h1/deadly_corridor-qwenoft-mean-3090-s42", + "profile": { + "mean_ms": 73.69250777493353, + "profile": "/home/ubuntu/lzj/profiles/published/profiles/openvla/1x-rtx3090/deadly_corridor/instance_a5037b165aa0cedc/profile.json", + "sha256": "bbfb93cef9f63750a9a159ec10a93a9fc6c25e4cb0cac3b39532663b4dc11eba" + }, + "config": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/deadly_corridor.yaml", + "output": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/deadly_corridor", + "metrics": "return mean/std/min/max;length mean/std;success where nativeprovided;latency/drops/invalid/action audits;100 episode vectors" + }, + "checkpoint_weights": { + "bytes": 9785680289, + "sha256": "a756924b1f9a93cc4f278e03535dd61535977037f9484957672336e6b9c9265c" + }, + "evaluation": { + "n_episodes": 100, + "mean_return": 1620.7987757873534, + "std_return": 913.6242782186637, + "min_return": -76.45918273925781, + "max_return": 2287.240921020508, + "mean_length": 148.53, + "std_length": 49.455930888013825, + "min_length": 17.0, + "max_length": 199.0, + "return_field": "episode_return_env", + "length_field": "survival_steps", + "mode": "simulated", + "policy_id": "starvla", + "env_id": "doom_deadly_corridor", + "model_id": "openvla", + "gpu_class": "1x-rtx3090", + "workload_id": "deadly_corridor", + "instance_id": "instance_a5037b165aa0cedc", + "source_run_id": "20260914T171446047509Z", + "profile_ref": null, + "env_fps": 35.0, + "obs_fps": 8.75, + "frame_ms": 28.571428571428573, + "latency_type": "profile_sample", + "task": "deadly_corridor", + "checkpoint_revision": "d4825bbad8d15bc50b6b8481eb2abc84846a54fb", + "checkpoint_path": "latency-aware/deadly-corridor/vla/starvla-qwenoft-h1/deadly_corridor-qwenoft-mean-3090-s42", + "profile_sha256": "bbfb93cef9f63750a9a159ec10a93a9fc6c25e4cb0cac3b39532663b4dc11eba", + "condition": "profile-latency", + "invalid_actions": 0, + "dropped_actions": 0, + "unique_seeds": 100, + "physical_gpu": 3, + "eval_config": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/deadly_corridor.yaml", + "execution_audit": { + "issued_action_records": 3753, + "applied_action_records": 3673, + "dropped_action_records": 0, + "nonnoop_issued_records": 3753, + "finite_action_values": true, + "latency_sample_count": 3753, + "latency_mean_ms": 74.01999621872471, + "latency_std_ms": 5.5537519652567635, + "latency_p95_ms": 89.54825982614612, + "latency_p99_ms": 95.97310052501227 + } + }, + "source_revision": { + "repo": "c3c6a39365a151e9b7a5e215452fd64e957c2b29", + "starvla": "ccca13c5177fe3d3c884b6e2de4965d916016649", + "runtime_fixes": [ + "mean-profile-preparation.patch", + "gym-language-contract.patch", + "loader-spawn-cache.patch", + "loader-spawn-test.patch", + "doom-mean-reset.patch" + ], + "pytorch3d": { + "revision": "33824be3cbc87a7dd1db0f6a9a9de9ac81b2d0ba", + "build": "transforms-only, no native render extension; QwenOFT uses transforms only" + }, + "decord": { + "version": "0.6.0", + "build": "official source CPU decoder CP310", + "wheel_sha256": "e193b356b1e984b4eff08d23b62e482c2c9e5037a6efdc0b1af47079ae2e4c47" + } + }, + "raw_records_format": "gzip(JSONL), lossless", + "startup_checks_included_in_score": false, + "results_status": "evaluation_complete; acceptance_not_inferred" +} diff --git a/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/queue_eval_latency_profile_sample.json b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/queue_eval_latency_profile_sample.json new file mode 100644 index 0000000000000000000000000000000000000000..9a96fc304bcba5747159ca9c32bf1ca8ff753a55 --- /dev/null +++ b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/queue_eval_latency_profile_sample.json @@ -0,0 +1,217 @@ +{ + "checkpoint_path": "/home/ubuntu/lzj/mean-profiling/deadly_corridor/vla-publication/checkpoints/model.pt", + "experiment_name": "deadly_corridor-mean5000-profile-simulation-100ep", + "latency": "profile_sample", + "latency_type": "profile_sample", + "lengths": [ + 72, + 143, + 182, + 189, + 150, + 115, + 176, + 176, + 49, + 75, + 176, + 45, + 176, + 178, + 178, + 177, + 172, + 182, + 177, + 99, + 181, + 197, + 172, + 74, + 195, + 179, + 178, + 190, + 177, + 177, + 44, + 183, + 178, + 192, + 188, + 179, + 183, + 178, + 178, + 190, + 185, + 179, + 104, + 177, + 189, + 181, + 74, + 182, + 179, + 189, + 182, + 181, + 173, + 73, + 175, + 194, + 178, + 181, + 176, + 108, + 113, + 177, + 186, + 89, + 70, + 76, + 75, + 75, + 150, + 184, + 132, + 47, + 44, + 141, + 172, + 151, + 143, + 182, + 79, + 17, + 183, + 171, + 178, + 41, + 176, + 45, + 171, + 76, + 175, + 177, + 93, + 70, + 192, + 175, + 152, + 199, + 179, + 181, + 178, + 178 + ], + "mean_length": 148.53, + "mean_return": 1620.7987757873534, + "returns": [ + 337.47547912597656, + 819.0284423828125, + 2284.857650756836, + 2276.2068634033203, + 805.2153015136719, + 621.8231658935547, + 2276.414749145508, + 2284.310989379883, + 81.07798767089844, + 317.2351837158203, + 2282.7608489990234, + 88.11907958984375, + 2281.468536376953, + 2276.6868591308594, + 2276.1705932617188, + 2282.6631622314453, + 2280.300033569336, + 2280.4182891845703, + 2281.2594451904297, + 479.8523712158203, + 2279.7379455566406, + 2284.9097442626953, + 2286.2730407714844, + 244.51919555664062, + 2279.957275390625, + 2283.952178955078, + 2276.701370239258, + 2277.142562866211, + 2279.025634765625, + 2285.7152099609375, + 53.374298095703125, + 2279.8080444335938, + 2282.307357788086, + 2282.834014892578, + 2284.200241088867, + 2287.2159118652344, + 2284.693832397461, + 2283.2066650390625, + 2281.032196044922, + 2282.960678100586, + 2287.094253540039, + 2279.3030853271484, + 440.0892791748047, + 2280.8592529296875, + 2283.4308471679688, + 2282.324264526367, + 326.0184631347656, + 2279.086135864258, + 2280.3804626464844, + 2276.215301513672, + 2278.132034301758, + 2285.6056518554688, + 2287.240921020508, + 310.81517028808594, + 2276.6219787597656, + 2276.2769470214844, + 2278.861602783203, + 2279.728561401367, + 2280.544464111328, + 487.829833984375, + 567.0655517578125, + 2278.210220336914, + 2281.436721801758, + 382.2119903564453, + 246.2946014404297, + 285.21240234375, + 310.6737365722656, + 346.1162872314453, + 804.7056121826172, + 2285.6442108154297, + 730.5995788574219, + 86.91796875, + 60.30122375488281, + 768.6264343261719, + 2280.1071166992188, + 860.9334106445312, + 722.9459228515625, + 2276.8687438964844, + 368.3357238769531, + -76.45918273925781, + 2281.5543823242188, + 2281.6688842773438, + 2277.5223083496094, + 42.30937194824219, + 2285.8980407714844, + 68.90191650390625, + 2286.2190551757812, + 281.1173553466797, + 2283.1607971191406, + 2277.888946533203, + 429.36326599121094, + 252.0751953125, + 2278.306442260742, + 2285.236801147461, + 857.2727355957031, + 2275.9288024902344, + 2286.8704833984375, + 2278.048355102539, + 2277.4480743408203, + 2276.9671478271484 + ], + "seed": 1000000, + "source_profile_path": "/home/ubuntu/lzj/profiles/published/profiles/openvla/1x-rtx3090/deadly_corridor/instance_a5037b165aa0cedc/profile.json", + "std_return": 913.6242782186637, + "suite_name": "profile_sample", + "timestamp_utc": "2026-10-01T06:01:50.313923+00:00" +} diff --git a/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/raw-records/actions.jsonl.gz b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/raw-records/actions.jsonl.gz new file mode 100644 index 0000000000000000000000000000000000000000..dc7821ad2e4ec900e5606b84345af50d4e930ac9 --- /dev/null +++ b/evaluations/deadly-corridor/deadly_corridor-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/raw-records/actions.jsonl.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:53f0b7bb59fb99cdd2917642c9881cb1443f897c78e20f1567929b4b232680fd +size 522227 diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/REPORT.md b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/REPORT.md new file mode 100644 index 0000000000000000000000000000000000000000..7f2af02a5f64a7ae2fdb82b2a93c6eaac45fb57d --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/REPORT.md @@ -0,0 +1,20 @@ +# QwenOFT mean-trained checkpoints under profile simulation + +Four final step-5000 H1 checkpoints; two rounds, one evaluation per physical GPU2/3,100 episodes each (400 total). + +The training latency was fixed mean; this evaluation samples the complete archived RTX3090 temporal hidden-regime profile. Simulator FPS, seeds, horizon, limits and model/profile identities are in evaluation-plan.json. Standard deviations below use ddof=0. Returns have task-specific scales. Startup checks are separate and excluded. + +| Task | Episodes | Return mean +/- SD | Length mean +/- SD | Success | Invalid | +|---|---:|---:|---:|---:|---:| +| flappy | 100 | 384.824005 +/- 116.787774 | 3119.31 +/- 939.87 | not provided by task | 0 | +| deadly_corridor | 100 | 1620.798776 +/- 913.624278 | 148.53 +/- 49.46 | not provided by task | 0 | +| ant | 100 | 1453.844064 +/- 693.727520 | 803.85 +/- 328.81 | not provided by task | 0 | +| intercept | 100 | 3.544349 +/- 7.071923 | 60.00 +/- 0.00 | 9/100 | 0 | + +No success metric is invented for Flappy/Deadly/Ant. Intercept reports the native accumulated success flag. No policy-quality acceptance gate is claimed. + +Compatibility repairs: portable robot_type copied from each actual training manifest (weights unchanged); official ViZDoom1.2.4 VizdoomCorridor-v0 uses the same deadly_corridor WAD as SF, preserves render contract and semantic seven-button ordering; public action space is equivalent MultiBinary7. Existing native render/button/history tests passed. Full eval source/patch and original profile assets are archived. + +Flappy/Deadly seeds1000000..1000099; Ant42..141; Intercept4242424242..4242424341. Latency seed271828. Flappy10/10Hz, Deadly35/8.75Hz, Ant10/10Hz, Intercept20/20Hz. Max raw frames3600/3600/1000/60; capacities1. MIKASA H1 holds last chunk action; no prefix, no DAgger. Ant keeps its training prompt label1 while execution latency is sampled. + +Raw JSONL logs are losslessly gzip-compressed for distribution; original uncompressed records remain on the experiment host. Empty observation_attempts files are retained; admission/drop evidence is in steps/actions. Per-task CSV and full400 episode CSV are provided. diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/all_episodes.csv b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/all_episodes.csv new file mode 100644 index 0000000000000000000000000000000000000000..be5e27101cb97f6a2dd0d85a0399d3fb8a5ea839 --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/all_episodes.csv @@ -0,0 +1,401 @@ +task,episode_id,seed,return_env,length,mean_latency_ms,success +flappy,0,1000000,444.6000052243471,3600,76.02271694866694, +flappy,1,1000001,444.6000052243471,3600,76.14445348705047, +flappy,2,1000002,444.6000052243471,3600,75.83047266244563, +flappy,3,1000003,444.6000052243471,3600,76.04121221698036, +flappy,4,1000004,444.6000052243471,3600,75.7789115791707, +flappy,5,1000005,228.2000027000904,1861,76.22757676162651, +flappy,6,1000006,444.6000052243471,3600,75.98373978309758, +flappy,7,1000007,444.6000052243471,3600,75.85552109823348, +flappy,8,1000008,444.6000052243471,3600,75.9782303085917, +flappy,9,1000009,444.6000052243471,3600,75.94667987356688, +flappy,10,1000010,444.6000052243471,3600,75.66396359484234, +flappy,11,1000011,444.6000052243471,3600,75.7794525026407, +flappy,12,1000012,444.6000052243471,3600,75.90110110734818, +flappy,13,1000013,444.6000052243471,3600,76.01870178237883, +flappy,14,1000014,444.6000052243471,3600,75.75567207010911, +flappy,15,1000015,444.6000052243471,3600,75.83026036637241, +flappy,16,1000016,444.6000052243471,3600,75.74502908171665, +flappy,17,1000017,444.6000052243471,3600,75.84316844302293, +flappy,18,1000018,444.6000052243471,3600,75.85876738771161, +flappy,19,1000019,265.50000313669443,2162,75.89492798135642, +flappy,20,1000020,444.6000052243471,3600,75.90859756288593, +flappy,21,1000021,444.6000052243471,3600,75.93474621914784, +flappy,22,1000022,444.6000052243471,3600,75.77022360156529, +flappy,23,1000023,444.6000052243471,3600,75.8506098974935, +flappy,24,1000024,444.6000052243471,3600,75.80511776716725, +flappy,25,1000025,116.00000138580799,955,76.07937915327228, +flappy,26,1000026,444.6000052243471,3600,75.77409482659607, +flappy,27,1000027,444.6000052243471,3600,75.82354466933252, +flappy,28,1000028,444.6000052243471,3600,75.92578714415393, +flappy,29,1000029,444.6000052243471,3600,75.77326038618416, +flappy,30,1000030,256.0000030249357,2085,75.8461606092662, +flappy,31,1000031,444.6000052243471,3600,75.87053786258159, +flappy,32,1000032,444.6000052243471,3600,75.90930861144982, +flappy,33,1000033,444.6000052243471,3600,75.80530422686525, +flappy,34,1000034,444.6000052243471,3600,76.05997569829616, +flappy,35,1000035,444.6000052243471,3600,75.67579907153437, +flappy,36,1000036,444.6000052243471,3600,76.07561842170198, +flappy,37,1000037,444.6000052243471,3600,75.87459102177027, +flappy,38,1000038,55.60000067949295,468,75.8887188983619, +flappy,39,1000039,444.6000052243471,3600,75.86536772802552, +flappy,40,1000040,432.900005094707,3512,76.00355652525975, +flappy,41,1000041,274.8000032454729,2237,75.7658282850597, +flappy,42,1000042,264.90000312775373,2156,75.95264956954799, +flappy,43,1000043,265.4000031352043,2161,75.82748305801191, +flappy,44,1000044,444.6000052243471,3600,75.9295822845668, +flappy,45,1000045,143.90000171214342,1180,75.94310218110371, +flappy,46,1000046,444.6000052243471,3600,75.69568531179425, +flappy,47,1000047,93.1000011190772,771,76.0527875505066, +flappy,48,1000048,56.10000068694353,473,76.20882901957174, +flappy,49,1000049,265.2000031322241,2159,76.05401077635972, +flappy,50,1000050,444.6000052243471,3600,75.89333271844873, +flappy,51,1000051,444.6000052243471,3600,75.89090159365671, +flappy,52,1000052,398.80000469088554,3234,75.91218218803246, +flappy,53,1000053,444.6000052243471,3600,75.86400590251726, +flappy,54,1000054,270.2000031918287,2200,76.01590238337654, +flappy,55,1000055,69.70000084489584,582,75.68422480575155, +flappy,56,1000056,444.6000052243471,3600,75.87884524455251, +flappy,57,1000057,444.6000052243471,3600,75.96981187494319, +flappy,58,1000058,444.6000052243471,3600,76.03772455115222, +flappy,59,1000059,437.90000515431166,3553,76.04088529786887, +flappy,60,1000060,348.9000041112304,2834,75.79422825165413, +flappy,61,1000061,444.6000052243471,3600,75.87728099437057, +flappy,62,1000062,78.9000009521842,656,75.96352981662133, +flappy,63,1000063,444.6000052243471,3600,75.80269270184165, +flappy,64,1000064,444.6000052243471,3600,75.88518180564401, +flappy,65,1000065,444.6000052243471,3600,75.87533034544981, +flappy,66,1000066,444.6000052243471,3600,75.94241138050401, +flappy,67,1000067,444.6000052243471,3600,75.95312277771471, +flappy,68,1000068,444.6000052243471,3600,75.8998829764233, +flappy,69,1000069,444.6000052243471,3600,75.98564617573034, +flappy,70,1000070,444.6000052243471,3600,75.68328575087021, +flappy,71,1000071,135.0000016093254,1109,75.99546963217229, +flappy,72,1000072,444.6000052243471,3600,75.9923106611263, +flappy,73,1000073,444.6000052243471,3600,75.80422251719546, +flappy,74,1000074,444.6000052243471,3600,75.95469853250815, +flappy,75,1000075,444.6000052243471,3600,75.74551875442629, +flappy,76,1000076,444.6000052243471,3600,75.93301571087362, +flappy,77,1000077,444.6000052243471,3600,75.98384926019328, +flappy,78,1000078,444.6000052243471,3600,75.85055115368883, +flappy,79,1000079,444.6000052243471,3600,75.97142616222317, +flappy,80,1000080,444.6000052243471,3600,75.97039764106849, +flappy,81,1000081,444.6000052243471,3600,75.74469321422862, +flappy,82,1000082,116.20000138878822,957,76.0366526049804, +flappy,83,1000083,444.6000052243471,3600,75.95924386190674, +flappy,84,1000084,444.6000052243471,3600,76.0310580385874, +flappy,85,1000085,36.60000045597553,314,75.8634823847272, +flappy,86,1000086,260.90000308305025,2125,75.91783880059099, +flappy,87,1000087,444.6000052243471,3600,76.16752514785735, +flappy,88,1000088,444.6000052243471,3600,75.83331254385584, +flappy,89,1000089,444.6000052243471,3600,76.2113387300584, +flappy,90,1000090,444.6000052243471,3600,75.8334932097261, +flappy,91,1000091,225.20000265538692,1831,75.75618859671614, +flappy,92,1000092,444.6000052243471,3600,75.79683788505955, +flappy,93,1000093,180.9000021442771,1478,75.96465307644473, +flappy,94,1000094,305.2000035941601,2478,75.86565754734926, +flappy,95,1000095,444.6000052243471,3600,75.74523644464854, +flappy,96,1000096,444.6000052243471,3600,75.94353591524424, +flappy,97,1000097,444.6000052243471,3600,75.81927739599219, +flappy,98,1000098,444.6000052243471,3600,75.96229410618645, +flappy,99,1000099,444.6000052243471,3600,75.94512877548694, +deadly_corridor,0,1000000,337.47547912597656,72,71.90727374040254, +deadly_corridor,1,1000001,819.0284423828125,143,73.84762082340946, +deadly_corridor,2,1000002,2284.857650756836,182,72.79171012339609, +deadly_corridor,3,1000003,2276.2068634033203,189,76.345275285376, +deadly_corridor,4,1000004,805.2153015136719,150,73.86282581373551, +deadly_corridor,5,1000005,621.8231658935547,115,74.31105893586228, +deadly_corridor,6,1000006,2276.414749145508,176,74.2226331369995, +deadly_corridor,7,1000007,2284.310989379883,176,72.9072057957754, +deadly_corridor,8,1000008,81.07798767089844,49,73.20258272646697, +deadly_corridor,9,1000009,317.2351837158203,75,72.54774919154028, +deadly_corridor,10,1000010,2282.7608489990234,176,72.78293151689127, +deadly_corridor,11,1000011,88.11907958984375,45,72.60486105128022, +deadly_corridor,12,1000012,2281.468536376953,176,72.29193331603048, +deadly_corridor,13,1000013,2276.6868591308594,178,72.73330265771509, +deadly_corridor,14,1000014,2276.1705932617188,178,73.30067987408609, +deadly_corridor,15,1000015,2282.6631622314453,177,72.49405489224537, +deadly_corridor,16,1000016,2280.300033569336,172,72.80884970803692, +deadly_corridor,17,1000017,2280.4182891845703,182,73.03539182090206, +deadly_corridor,18,1000018,2281.2594451904297,177,72.50972089313564, +deadly_corridor,19,1000019,479.8523712158203,99,72.58046231642126, +deadly_corridor,20,1000020,2279.7379455566406,181,72.47468246266928, +deadly_corridor,21,1000021,2284.9097442626953,197,83.18983231769475, +deadly_corridor,22,1000022,2286.2730407714844,172,72.84281562147524, +deadly_corridor,23,1000023,244.51919555664062,74,76.23461799191558, +deadly_corridor,24,1000024,2279.957275390625,195,72.94927214021655, +deadly_corridor,25,1000025,2283.952178955078,179,73.18968843008061, +deadly_corridor,26,1000026,2276.701370239258,178,72.87702909462648, +deadly_corridor,27,1000027,2277.142562866211,190,72.45412386128042, +deadly_corridor,28,1000028,2279.025634765625,177,74.11102172804317, +deadly_corridor,29,1000029,2285.7152099609375,177,71.63189230597281, +deadly_corridor,30,1000030,53.374298095703125,44,72.51418721312025, +deadly_corridor,31,1000031,2279.8080444335938,183,72.72702656843174, +deadly_corridor,32,1000032,2282.307357788086,178,74.33584751930213, +deadly_corridor,33,1000033,2282.834014892578,192,73.95005063555192, +deadly_corridor,34,1000034,2284.200241088867,188,76.29368894499888, +deadly_corridor,35,1000035,2287.2159118652344,179,72.81890806090988, +deadly_corridor,36,1000036,2284.693832397461,183,76.28284599973325, +deadly_corridor,37,1000037,2283.2066650390625,178,72.1797344044525, +deadly_corridor,38,1000038,2281.032196044922,178,73.74343783824916, +deadly_corridor,39,1000039,2282.960678100586,190,73.24816830891406, +deadly_corridor,40,1000040,2287.094253540039,185,72.35711232966574, +deadly_corridor,41,1000041,2279.3030853271484,179,72.42125368367608, +deadly_corridor,42,1000042,440.0892791748047,104,73.92064892672727, +deadly_corridor,43,1000043,2280.8592529296875,177,72.36020918178356, +deadly_corridor,44,1000044,2283.4308471679688,189,75.93658060557208, +deadly_corridor,45,1000045,2282.324264526367,181,73.54224681770178, +deadly_corridor,46,1000046,326.0184631347656,74,73.1983876441008, +deadly_corridor,47,1000047,2279.086135864258,182,73.00958120503027, +deadly_corridor,48,1000048,2280.3804626464844,179,73.17268244992928, +deadly_corridor,49,1000049,2276.215301513672,189,75.47590644230628, +deadly_corridor,50,1000050,2278.132034301758,182,74.50495464842548, +deadly_corridor,51,1000051,2285.6056518554688,181,73.41699294418743, +deadly_corridor,52,1000052,2287.240921020508,173,73.22110809114655, +deadly_corridor,53,1000053,310.81517028808594,73,74.09003681120738, +deadly_corridor,54,1000054,2276.6219787597656,175,72.98605010243534, +deadly_corridor,55,1000055,2276.2769470214844,194,75.17704077845171, +deadly_corridor,56,1000056,2278.861602783203,178,72.97353037051572, +deadly_corridor,57,1000057,2279.728561401367,181,73.96913002154926, +deadly_corridor,58,1000058,2280.544464111328,176,73.02432805290651, +deadly_corridor,59,1000059,487.829833984375,108,78.89398217393664, +deadly_corridor,60,1000060,567.0655517578125,113,72.64874721482185, +deadly_corridor,61,1000061,2278.210220336914,177,72.96068484971086, +deadly_corridor,62,1000062,2281.436721801758,186,75.46710866924751, +deadly_corridor,63,1000063,382.2119903564453,89,81.21157315209366, +deadly_corridor,64,1000064,246.2946014404297,70,73.9736408486285, +deadly_corridor,65,1000065,285.21240234375,76,73.13661133681993, +deadly_corridor,66,1000066,310.6737365722656,75,73.40468658737086, +deadly_corridor,67,1000067,346.1162872314453,75,72.1929723632303, +deadly_corridor,68,1000068,804.7056121826172,150,73.76397959753224, +deadly_corridor,69,1000069,2285.6442108154297,184,75.13255757158333, +deadly_corridor,70,1000070,730.5995788574219,132,73.25446825350764, +deadly_corridor,71,1000071,86.91796875,47,76.28335745963689, +deadly_corridor,72,1000072,60.30122375488281,44,76.83513093208644, +deadly_corridor,73,1000073,768.6264343261719,141,77.27057350071598, +deadly_corridor,74,1000074,2280.1071166992188,172,74.16699734355548, +deadly_corridor,75,1000075,860.9334106445312,151,73.15118478347584, +deadly_corridor,76,1000076,722.9459228515625,143,75.5655785931314, +deadly_corridor,77,1000077,2276.8687438964844,182,72.95102474014934, +deadly_corridor,78,1000078,368.3357238769531,79,71.51096709276341, +deadly_corridor,79,1000079,-76.45918273925781,17,72.24888432102617, +deadly_corridor,80,1000080,2281.5543823242188,183,73.32589540463356, +deadly_corridor,81,1000081,2281.6688842773438,171,73.10600900440717, +deadly_corridor,82,1000082,2277.5223083496094,178,73.55648700566698, +deadly_corridor,83,1000083,42.30937194824219,41,73.52700344736942, +deadly_corridor,84,1000084,2285.8980407714844,176,71.98655161011203, +deadly_corridor,85,1000085,68.90191650390625,45,72.84773487604696, +deadly_corridor,86,1000086,2286.2190551757812,171,72.82303966497733, +deadly_corridor,87,1000087,281.1173553466797,76,72.26983276661764, +deadly_corridor,88,1000088,2283.1607971191406,175,73.49638264342678, +deadly_corridor,89,1000089,2277.888946533203,177,73.44736473371472, +deadly_corridor,90,1000090,429.36326599121094,93,71.86172378947977, +deadly_corridor,91,1000091,252.0751953125,70,72.26459581736903, +deadly_corridor,92,1000092,2278.306442260742,192,80.97328482778371, +deadly_corridor,93,1000093,2285.236801147461,175,74.02717585214627, +deadly_corridor,94,1000094,857.2727355957031,152,85.59110000526613, +deadly_corridor,95,1000095,2275.9288024902344,199,73.62958803645523, +deadly_corridor,96,1000096,2286.8704833984375,179,72.31519682456816, +deadly_corridor,97,1000097,2278.048355102539,181,73.50330330803081, +deadly_corridor,98,1000098,2277.4480743408203,178,76.78472725777, +deadly_corridor,99,1000099,2276.9671478271484,178,77.9678189026336, +ant,0,42,1846.1103431567394,1000,89.89614608291177, +ant,1,43,2415.720790707953,1000,90.00308114332259, +ant,2,44,457.34421085068755,177,89.83716885697598, +ant,3,45,1421.7952163289683,1000,89.87909631338808, +ant,4,46,2037.7234409469488,937,89.82685347370092, +ant,5,47,2330.630175869275,1000,90.47193606091501, +ant,6,48,1161.643572255748,429,89.84194070141322, +ant,7,49,2351.1524624990343,1000,89.92640891799017, +ant,8,50,513.2964809479813,210,89.88895656571908, +ant,9,51,1126.8652528911032,660,89.91361550654544, +ant,10,52,1693.436933192597,1000,89.84960962337662, +ant,11,53,948.3780972955639,1000,89.94678527711802, +ant,12,54,2322.052445211472,1000,90.11873818885832, +ant,13,55,960.4026770814776,1000,90.93377411320307, +ant,14,56,1464.564005196777,1000,89.80893705661644, +ant,15,57,1110.548792782156,1000,89.99466844889166, +ant,16,58,2246.207900740156,1000,90.1624262080728, +ant,17,59,85.64836938561511,60,89.87005518664785, +ant,18,60,340.54799067574436,143,89.94240076131771, +ant,19,61,2457.088748930458,1000,89.92054036086635, +ant,20,62,2166.2512677098603,1000,89.95452553058773, +ant,21,63,2357.957592244385,1000,89.86780458600198, +ant,22,64,1654.8780938737275,871,90.08433827425095, +ant,23,65,1499.367100151414,1000,89.89663615668341, +ant,24,66,2297.4032619179525,1000,90.09818426014289, +ant,25,67,1253.360764666355,543,89.9390124443734, +ant,26,68,1221.270312709775,1000,89.84986177450952, +ant,27,69,2389.2476464763376,1000,89.95772586857817, +ant,28,70,1682.5290233886233,707,89.76145439054764, +ant,29,71,2474.676425615127,1000,89.82093759631324, +ant,30,72,382.9231146443659,256,90.69916524888657, +ant,31,73,1837.8126619276347,1000,90.03642087221974, +ant,32,74,227.19436616673684,101,89.8553742761573, +ant,33,75,1700.6312067622644,1000,89.80097198453268, +ant,34,76,960.9452812639541,372,89.8420903148968, +ant,35,77,2290.6720141359438,1000,89.91770573449698, +ant,36,78,328.5729178056416,162,90.01187187392946, +ant,37,79,1180.073938772476,1000,89.81938304804656, +ant,38,80,817.4190215442345,363,89.85140773938038, +ant,39,81,1651.2255208727013,1000,91.17610023451576, +ant,40,82,1428.174672693164,1000,89.8551155619885, +ant,41,83,1627.3838925098842,1000,90.55986754698809, +ant,42,84,1079.756369746183,680,90.17098553312343, +ant,43,85,2173.9447393037276,1000,89.84319301261918, +ant,44,86,409.90633829945847,160,89.66802828269809, +ant,45,87,2467.2636019929073,1000,89.90844708827387, +ant,46,88,657.4084558813478,248,89.86487149424892, +ant,47,89,974.7436031610902,1000,89.76305094278182, +ant,48,90,1510.5184342975385,1000,90.24355118464125, +ant,49,91,602.2339441184535,260,89.7103209703719, +ant,50,92,760.9784375126189,316,89.8206829517188, +ant,51,93,1941.172113330597,1000,90.30785204408768, +ant,52,94,624.3590446196446,281,89.94582387208622, +ant,53,95,2163.4347041279893,1000,89.84848132390947, +ant,54,96,1126.9957963444238,1000,89.84637728060243, +ant,55,97,1405.131632695366,1000,90.18855922596491, +ant,56,98,1206.2916757636292,1000,89.78065539051504, +ant,57,99,2392.7980761515178,1000,89.76388668266138, +ant,58,100,964.0216541467705,1000,89.82618651237911, +ant,59,101,2252.192880003706,1000,89.8197082349776, +ant,60,102,2471.9158497657563,1000,89.96642568195992, +ant,61,103,1902.8491241623092,1000,89.87542708971246, +ant,62,104,1435.6661382989703,1000,90.28644124851098, +ant,63,105,1668.3237703695809,1000,89.86433221097877, +ant,64,106,1813.291243529155,1000,89.85118001877315, +ant,65,107,446.72353548541076,189,89.8309544306309, +ant,66,108,130.84194814079504,74,89.82416773165995, +ant,67,109,2315.857153770824,1000,90.25959750757508, +ant,68,110,288.3915792961347,116,90.09271984792927, +ant,69,111,894.0228631227924,1000,89.89663691508213, +ant,70,112,2030.322535823717,1000,89.84028619017428, +ant,71,113,507.9449555916754,215,90.57267432538549, +ant,72,114,2377.7373967468293,1000,89.84919425782105, +ant,73,115,897.3077114027096,1000,89.90431472264346, +ant,74,116,1454.612590266188,1000,91.19515970740413, +ant,75,117,2292.457960175467,1000,89.8333901030839, +ant,76,118,1424.378337790017,1000,89.88029014661089, +ant,77,119,1441.1111023164538,1000,89.79844243631413, +ant,78,120,1265.4771503717611,1000,89.86009503143968, +ant,79,121,1662.8808067819505,1000,90.5661722205243, +ant,80,122,2508.917122342891,1000,89.87403626041336, +ant,81,123,1655.3510139158748,1000,90.05039760075688, +ant,82,124,1387.3843721247736,821,90.10235730111886, +ant,83,125,646.4356689469432,271,89.7559653760994, +ant,84,126,2172.801064037805,1000,89.84602989356796, +ant,85,127,165.9213897970373,72,89.66756877688618, +ant,86,128,1063.1483912161111,1000,89.77409215132576, +ant,87,129,1000.135342286622,1000,89.81900933661238, +ant,88,130,1977.2359176146426,1000,89.77653862908736, +ant,89,131,1937.1674235355138,1000,90.12773943823525, +ant,90,132,1344.7729257831547,1000,90.39620143170467, +ant,91,133,786.3379828975102,441,89.82893206036925, +ant,92,134,1391.060299752017,1000,89.86676880070257, +ant,93,135,503.300235688713,250,89.94819176115624, +ant,94,136,2446.7482357041768,1000,89.84848658183878, +ant,95,137,1171.9102336514923,1000,89.92785850220504, +ant,96,138,2356.7311711183065,1000,90.42933754946152, +ant,97,139,2356.12199478712,1000,89.82049779117614, +ant,98,140,1389.2987977192308,1000,90.82209581044775, +ant,99,141,967.2335383727841,1000,89.80016695371027, +intercept,0,4242424242,0.7267571190313902,60,99.89614420497905,0.0 +intercept,1,4242424243,2.9096362272975966,60,99.91707940536706,0.0 +intercept,2,4242424244,3.2060351513209753,60,97.78809018716221,0.0 +intercept,3,4242424245,0.7574528902187012,60,98.54894447730877,0.0 +intercept,4,4242424246,0.6827895979695313,60,99.11745353519741,0.0 +intercept,5,4242424247,29.923812823486514,60,99.04064156549293,1.0 +intercept,6,4242424248,0.7661087726592086,60,98.25342313549518,0.0 +intercept,7,4242424249,0.8284444468154106,60,97.98431264506286,0.0 +intercept,8,4242424250,0.9707721562881488,60,99.10671115977826,0.0 +intercept,9,4242424251,1.0944434545235708,60,99.10142489904808,0.0 +intercept,10,4242424252,0.7526731102407211,60,98.24263629181895,0.0 +intercept,11,4242424253,1.0327306617691647,60,99.90610126116793,0.0 +intercept,12,4242424254,24.08529434411321,60,99.04964452767656,1.0 +intercept,13,4242424255,0.8258126199943945,60,99.06333184347895,0.0 +intercept,14,4242424256,0.6465023508935701,60,99.96017435988418,0.0 +intercept,15,4242424257,1.2059930491086561,60,99.07293754243183,0.0 +intercept,16,4242424258,0.8975468523567542,60,99.10975490804557,0.0 +intercept,17,4242424259,0.638558203499997,60,99.9008234011206,0.0 +intercept,18,4242424260,2.473904824233614,60,99.1007534285042,0.0 +intercept,19,4242424261,0.8594156300532632,60,98.2804424689215,0.0 +intercept,20,4242424262,0.7127419076277874,60,97.42140552034121,0.0 +intercept,21,4242424263,1.1195833964738995,60,99.05356389575846,0.0 +intercept,22,4242424264,1.4589147588121705,60,99.10476263429966,0.0 +intercept,23,4242424265,22.348254217096837,60,98.14243140713285,1.0 +intercept,24,4242424266,27.43761277961312,60,99.03063235183511,1.0 +intercept,25,4242424267,0.797963114338927,60,98.95851806063928,0.0 +intercept,26,4242424268,0.6415987604705151,60,99.1202532952496,0.0 +intercept,27,4242424269,1.502438226743834,60,99.8369766656745,0.0 +intercept,28,4242424270,1.277322537265718,60,99.13638822823135,0.0 +intercept,29,4242424271,0.6413188653605175,60,99.8165233572777,0.0 +intercept,30,4242424272,26.015227647672873,60,99.93359984997578,1.0 +intercept,31,4242424273,0.7568511647114065,60,98.29798580223347,0.0 +intercept,32,4242424274,0.7758818510046694,60,95.9119617819155,0.0 +intercept,33,4242424275,0.743274000211386,60,99.16579733811342,0.0 +intercept,34,4242424276,0.9812663898337632,60,99.96913332715677,0.0 +intercept,35,4242424277,0.7364500367548317,60,98.4144170848438,0.0 +intercept,36,4242424278,0.7676261149172205,60,99.87913624991887,0.0 +intercept,37,4242424279,2.6105462690466084,60,99.0124647390605,0.0 +intercept,38,4242424280,0.8922563010128215,60,99.49582641131909,0.0 +intercept,39,4242424281,0.7909053032053635,60,99.95776157301488,0.0 +intercept,40,4242424282,27.747763212013524,60,99.89232705853966,1.0 +intercept,41,4242424283,2.830903574009426,60,99.11182141335861,0.0 +intercept,42,4242424284,3.749473527306691,60,99.89401411987875,0.0 +intercept,43,4242424285,3.2371535471174866,60,98.58941395009701,0.0 +intercept,44,4242424286,1.141169616690604,60,98.95023432158384,0.0 +intercept,45,4242424287,1.2504711685760412,60,99.8783128676535,0.0 +intercept,46,4242424288,1.1401455145678483,60,99.09364640302553,0.0 +intercept,47,4242424289,1.1743367564631626,60,98.24703755640672,0.0 +intercept,48,4242424290,0.6911400489043444,60,98.98847807253395,0.0 +intercept,49,4242424291,0.966755291854497,60,98.31297463384391,0.0 +intercept,50,4242424292,3.7725237559643574,60,98.1307167401627,0.0 +intercept,51,4242424293,0.7292428385990206,60,99.08520847604322,0.0 +intercept,52,4242424294,2.733719722367823,60,99.8949988335446,0.0 +intercept,53,4242424295,2.7277548569836654,60,99.16542541107671,0.0 +intercept,54,4242424296,0.8013565168366767,60,98.2801475641182,0.0 +intercept,55,4242424297,0.9918300381395966,60,98.74883429246843,0.0 +intercept,56,4242424298,3.8384227409260347,60,98.30485570834159,0.0 +intercept,57,4242424299,2.525593837024644,60,99.08211861473346,0.0 +intercept,58,4242424300,1.1939986812940333,60,99.95562586586023,0.0 +intercept,59,4242424301,1.1946645161951892,60,99.11887142756973,0.0 +intercept,60,4242424302,0.6632764584392135,60,99.92733404817194,0.0 +intercept,61,4242424303,0.7345126099826302,60,99.61093201950378,0.0 +intercept,62,4242424304,1.1547945403144695,60,98.88382479344455,0.0 +intercept,63,4242424305,1.0395031699445099,60,99.10455669644611,0.0 +intercept,64,4242424306,2.7713681719324086,60,99.99607387713222,0.0 +intercept,65,4242424307,3.8083399715833366,60,99.90908449191997,0.0 +intercept,66,4242424308,3.1245881704380736,60,99.86388390473627,0.0 +intercept,67,4242424309,0.9936205917911138,60,99.06530098425861,0.0 +intercept,68,4242424310,0.6479002644773573,60,97.31661851374615,0.0 +intercept,69,4242424311,1.09404552471824,60,99.06482130667098,0.0 +intercept,70,4242424312,0.725047086874838,60,99.39714496924636,0.0 +intercept,71,4242424313,2.085218493710272,60,99.91926924929075,0.0 +intercept,72,4242424314,25.112157980707707,60,99.89495984140663,1.0 +intercept,73,4242424315,0.7960666966973804,60,99.91315720008677,0.0 +intercept,74,4242424316,1.8899870013119653,60,99.8635479883608,0.0 +intercept,75,4242424317,24.77215793245705,60,99.08978442272605,1.0 +intercept,76,4242424318,0.763190906640375,60,99.1181927131107,0.0 +intercept,77,4242424319,0.8356004936795216,60,98.87472332915829,0.0 +intercept,78,4242424320,24.543561146681895,60,98.85109478338812,1.0 +intercept,79,4242424321,0.7962639288743958,60,96.64267992061197,0.0 +intercept,80,4242424322,0.6807828926102957,60,98.70551839611774,0.0 +intercept,81,4242424323,1.1704122956143692,60,99.1162675413269,0.0 +intercept,82,4242424324,0.8024117537715938,60,99.10984056283594,0.0 +intercept,83,4242424325,1.0154686415335163,60,99.90653765962175,0.0 +intercept,84,4242424326,0.6267238368745893,60,99.14313411902761,0.0 +intercept,85,4242424327,1.1180786813492887,60,99.87378109642233,0.0 +intercept,86,4242424328,1.0531825890648179,60,99.90759275984404,0.0 +intercept,87,4242424329,0.7319892354425974,60,99.07934787032669,0.0 +intercept,88,4242424330,1.1460731038823724,60,98.32584786308246,0.0 +intercept,89,4242424331,1.145515855285339,60,99.853580446333,0.0 +intercept,90,4242424332,3.1438898412743583,60,98.23875463665809,0.0 +intercept,91,4242424333,1.1678254807484336,60,99.94300368083988,0.0 +intercept,92,4242424334,1.1468605129048228,60,98.28856657896678,0.0 +intercept,93,4242424335,2.816772125195712,60,99.10609232867152,0.0 +intercept,94,4242424336,1.1577836629003286,60,99.93574594730708,0.0 +intercept,95,4242424337,1.0533778404060286,60,99.92123883389186,0.0 +intercept,96,4242424338,0.8533297177054919,60,99.06174133027585,0.0 +intercept,97,4242424339,0.7617567333800253,60,99.95316521359209,0.0 +intercept,98,4242424340,0.9895546428160742,60,99.11385213912092,0.0 +intercept,99,4242424341,0.770722996792756,60,99.44169788411487,0.0 diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/comparison.csv b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/comparison.csv new file mode 100644 index 0000000000000000000000000000000000000000..1b381df6789eea28ea56149c4b780cf0cade01c0 --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/comparison.csv @@ -0,0 +1,5 @@ +task,episodes,return_mean,return_sd,length_mean,length_sd,success_count,success_rate,invalid_actions,dropped_actions +flappy,100,384.8240045265853,116.78777394316903,3119.31,939.8693174585497,,,0,64 +deadly_corridor,100,1620.7987757873534,913.6242782186637,148.53,49.455930888013825,,,0,0 +ant,100,1453.844063807972,693.7275200567642,803.85,328.8088312378486,,,0,0 +intercept,100,3.5443485127069287,7.07192296411853,60.0,0.0,9,0.09,0,10 diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/comparison.json b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/comparison.json new file mode 100644 index 0000000000000000000000000000000000000000..8486070c582599f0cb0c336c70e6569823f4990f --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/comparison.json @@ -0,0 +1,205 @@ +{ + "condition": "profile-latency", + "executor_mode": "simulated", + "latency_method": "temporal/profile_sample", + "episodes_per_checkpoint": 100, + "total_episodes": 400, + "checkpoints_metadata_revision": "d4825bbad8d15bc50b6b8481eb2abc84846a54fb", + "results": { + "flappy": { + "n_episodes": 100, + "mean_return": 384.8240045265853, + "std_return": 116.78777394316903, + "min_return": 36.60000045597553, + "max_return": 444.6000052243471, + "mean_length": 3119.31, + "std_length": 939.8693174585497, + "min_length": 314.0, + "max_length": 3600.0, + "return_field": "episode_return_env", + "length_field": "survival_steps", + "mode": "simulated", + "policy_id": "starvla", + "env_id": "flappy", + "model_id": "openvla", + "gpu_class": "1x-rtx3090", + "workload_id": "flappy", + "instance_id": "instance_a5037b165aa0cedc", + "source_run_id": "20260914T122201421825Z", + "profile_ref": null, + "env_fps": 10.0, + "obs_fps": 10.0, + "frame_ms": 100.0, + "latency_type": "profile_sample", + "task": "flappy", + "checkpoint_revision": "d4825bbad8d15bc50b6b8481eb2abc84846a54fb", + "checkpoint_path": "latency-aware/flappy/vla/starvla-qwenoft-h1/flappy-qwenoft-mean-3090-s42", + "profile_sha256": "c266cba7ebac05c7e37bc83f1f16fe4b27dab97942ff43290e6c41514f6e39fc", + "condition": "profile-latency", + "invalid_actions": 0, + "dropped_actions": 64, + "unique_seeds": 100, + "physical_gpu": 2, + "eval_config": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/flappy.yaml", + "execution_audit": { + "issued_action_records": 311075, + "applied_action_records": 310911, + "dropped_action_records": 64, + "nonnoop_issued_records": 30817, + "finite_action_values": true, + "latency_sample_count": 311075, + "latency_mean_ms": 75.89784633675906, + "latency_std_ms": 3.799946378622932, + "latency_p95_ms": 81.3960393048375, + "latency_p99_ms": 87.23844517488543 + } + }, + "deadly_corridor": { + "n_episodes": 100, + "mean_return": 1620.7987757873534, + "std_return": 913.6242782186637, + "min_return": -76.45918273925781, + "max_return": 2287.240921020508, + "mean_length": 148.53, + "std_length": 49.455930888013825, + "min_length": 17.0, + "max_length": 199.0, + "return_field": "episode_return_env", + "length_field": "survival_steps", + "mode": "simulated", + "policy_id": "starvla", + "env_id": "doom_deadly_corridor", + "model_id": "openvla", + "gpu_class": "1x-rtx3090", + "workload_id": "deadly_corridor", + "instance_id": "instance_a5037b165aa0cedc", + "source_run_id": "20260914T171446047509Z", + "profile_ref": null, + "env_fps": 35.0, + "obs_fps": 8.75, + "frame_ms": 28.571428571428573, + "latency_type": "profile_sample", + "task": "deadly_corridor", + "checkpoint_revision": "d4825bbad8d15bc50b6b8481eb2abc84846a54fb", + "checkpoint_path": "latency-aware/deadly-corridor/vla/starvla-qwenoft-h1/deadly_corridor-qwenoft-mean-3090-s42", + "profile_sha256": "bbfb93cef9f63750a9a159ec10a93a9fc6c25e4cb0cac3b39532663b4dc11eba", + "condition": "profile-latency", + "invalid_actions": 0, + "dropped_actions": 0, + "unique_seeds": 100, + "physical_gpu": 3, + "eval_config": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/deadly_corridor.yaml", + "execution_audit": { + "issued_action_records": 3753, + "applied_action_records": 3673, + "dropped_action_records": 0, + "nonnoop_issued_records": 3753, + "finite_action_values": true, + "latency_sample_count": 3753, + "latency_mean_ms": 74.01999621872471, + "latency_std_ms": 5.5537519652567635, + "latency_p95_ms": 89.54825982614612, + "latency_p99_ms": 95.97310052501227 + } + }, + "ant": { + "n_episodes": 100, + "mean_return": 1453.844063807972, + "std_return": 693.7275200567642, + "min_return": 85.64836938561511, + "max_return": 2508.917122342891, + "mean_length": 803.85, + "std_length": 328.8088312378486, + "min_length": 60.0, + "max_length": 1000.0, + "return_field": "episode_return_env", + "length_field": "survival_steps", + "mode": "simulated", + "policy_id": "starvla", + "env_id": "LatencyBench/AntContinuous-v0", + "model_id": "qwenoft", + "gpu_class": "1x-rtx3090", + "workload_id": "ant", + "instance_id": "instance_859cf1e47bca6046", + "source_run_id": "20260911T033037730561Z", + "profile_ref": null, + "env_fps": 10.0, + "obs_fps": 10.0, + "frame_ms": 100.0, + "latency_type": "profile_sample", + "task": "ant", + "checkpoint_revision": "d4825bbad8d15bc50b6b8481eb2abc84846a54fb", + "checkpoint_path": "latency-aware/ant/vla/starvla-qwenoft-h1/ant-qwenoft-mean-3090-s42", + "profile_sha256": "0e49f72ec05ac600a54e07bbca5af3143708444d606167f33fa21788a9fefe50", + "condition": "profile-latency", + "invalid_actions": 0, + "dropped_actions": 0, + "unique_seeds": 100, + "physical_gpu": 2, + "eval_config": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/ant.yaml", + "execution_audit": { + "issued_action_records": 79573, + "applied_action_records": 79465, + "dropped_action_records": 0, + "nonnoop_issued_records": 79573, + "finite_action_values": true, + "latency_sample_count": 79573, + "latency_mean_ms": 90.00919554158884, + "latency_std_ms": 2.514492574433973, + "latency_p95_ms": 91.11971585797141, + "latency_p99_ms": 102.67108120995428 + } + }, + "intercept": { + "n_episodes": 100, + "mean_return": 3.5443485127069287, + "std_return": 7.07192296411853, + "min_return": 0.6267238368745893, + "max_return": 29.923812823486514, + "mean_length": 60.0, + "std_length": 0.0, + "min_length": 60.0, + "max_length": 60.0, + "return_field": "episode_return_env", + "length_field": "survival_steps", + "mode": "simulated", + "policy_id": "starvla", + "env_id": "mikasa_intercept_grab_fast", + "model_id": "qwenoft", + "gpu_class": "1x-rtx3090", + "workload_id": "mikasa_intercept_grab_fast", + "instance_id": "instance_3a0d42681a03715c", + "source_run_id": "20260909T044501695676Z", + "profile_ref": null, + "env_fps": 20.0, + "obs_fps": 20.0, + "frame_ms": 50.0, + "latency_type": "profile_sample", + "task": "intercept", + "checkpoint_revision": "d4825bbad8d15bc50b6b8481eb2abc84846a54fb", + "checkpoint_path": "latency-aware/mikasa-intercept-grab-fast/vla/starvla-qwenoft-h1/intercept-qwenoft-mean-3090-h1-s0", + "profile_sha256": "31a9b15d6b04182439934f0b377cb3d09be16ce21f3cf95c1049918f8a5d4984", + "condition": "profile-latency", + "invalid_actions": 0, + "dropped_actions": 10, + "unique_seeds": 100, + "physical_gpu": 3, + "eval_config": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/intercept.yaml", + "success_count": 9, + "success_rate": 0.09, + "execution_audit": { + "issued_action_records": 2974, + "applied_action_records": 2864, + "dropped_action_records": 10, + "nonnoop_issued_records": 2974, + "finite_action_values": true, + "latency_sample_count": 2974, + "latency_mean_ms": 99.11060319379854, + "latency_std_ms": 4.301543980874005, + "latency_p95_ms": 100.2889407458356, + "latency_p99_ms": 100.64616770379737 + } + } + }, + "quality_acceptance": "not inferred; observed statistics only" +} diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/episodes.csv b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/episodes.csv new file mode 100644 index 0000000000000000000000000000000000000000..1febb012a47b2112b19d73367a5f3616e7bd210e --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/episodes.csv @@ -0,0 +1,101 @@ +episode_id,seed,return_env,length,mean_latency_ms,invalid_actions,dropped_actions +0,1000000,444.6000052243471,3600,76.02271694866694,0,0 +1,1000001,444.6000052243471,3600,76.14445348705047,0,1 +2,1000002,444.6000052243471,3600,75.83047266244563,0,0 +3,1000003,444.6000052243471,3600,76.04121221698036,0,2 +4,1000004,444.6000052243471,3600,75.7789115791707,0,1 +5,1000005,228.2000027000904,1861,76.22757676162651,0,0 +6,1000006,444.6000052243471,3600,75.98373978309758,0,0 +7,1000007,444.6000052243471,3600,75.85552109823348,0,2 +8,1000008,444.6000052243471,3600,75.9782303085917,0,2 +9,1000009,444.6000052243471,3600,75.94667987356688,0,1 +10,1000010,444.6000052243471,3600,75.66396359484234,0,0 +11,1000011,444.6000052243471,3600,75.7794525026407,0,0 +12,1000012,444.6000052243471,3600,75.90110110734818,0,0 +13,1000013,444.6000052243471,3600,76.01870178237883,0,0 +14,1000014,444.6000052243471,3600,75.75567207010911,0,0 +15,1000015,444.6000052243471,3600,75.83026036637241,0,0 +16,1000016,444.6000052243471,3600,75.74502908171665,0,1 +17,1000017,444.6000052243471,3600,75.84316844302293,0,1 +18,1000018,444.6000052243471,3600,75.85876738771161,0,2 +19,1000019,265.50000313669443,2162,75.89492798135642,0,0 +20,1000020,444.6000052243471,3600,75.90859756288593,0,0 +21,1000021,444.6000052243471,3600,75.93474621914784,0,0 +22,1000022,444.6000052243471,3600,75.77022360156529,0,0 +23,1000023,444.6000052243471,3600,75.8506098974935,0,0 +24,1000024,444.6000052243471,3600,75.80511776716725,0,0 +25,1000025,116.00000138580799,955,76.07937915327228,0,1 +26,1000026,444.6000052243471,3600,75.77409482659607,0,0 +27,1000027,444.6000052243471,3600,75.82354466933252,0,0 +28,1000028,444.6000052243471,3600,75.92578714415393,0,2 +29,1000029,444.6000052243471,3600,75.77326038618416,0,0 +30,1000030,256.0000030249357,2085,75.8461606092662,0,1 +31,1000031,444.6000052243471,3600,75.87053786258159,0,1 +32,1000032,444.6000052243471,3600,75.90930861144982,0,1 +33,1000033,444.6000052243471,3600,75.80530422686525,0,0 +34,1000034,444.6000052243471,3600,76.05997569829616,0,1 +35,1000035,444.6000052243471,3600,75.67579907153437,0,0 +36,1000036,444.6000052243471,3600,76.07561842170198,0,3 +37,1000037,444.6000052243471,3600,75.87459102177027,0,0 +38,1000038,55.60000067949295,468,75.8887188983619,0,0 +39,1000039,444.6000052243471,3600,75.86536772802552,0,0 +40,1000040,432.900005094707,3512,76.00355652525975,0,0 +41,1000041,274.8000032454729,2237,75.7658282850597,0,0 +42,1000042,264.90000312775373,2156,75.95264956954799,0,0 +43,1000043,265.4000031352043,2161,75.82748305801191,0,1 +44,1000044,444.6000052243471,3600,75.9295822845668,0,1 +45,1000045,143.90000171214342,1180,75.94310218110371,0,0 +46,1000046,444.6000052243471,3600,75.69568531179425,0,0 +47,1000047,93.1000011190772,771,76.0527875505066,0,0 +48,1000048,56.10000068694353,473,76.20882901957174,0,0 +49,1000049,265.2000031322241,2159,76.05401077635972,0,0 +50,1000050,444.6000052243471,3600,75.89333271844873,0,1 +51,1000051,444.6000052243471,3600,75.89090159365671,0,0 +52,1000052,398.80000469088554,3234,75.91218218803246,0,1 +53,1000053,444.6000052243471,3600,75.86400590251726,0,0 +54,1000054,270.2000031918287,2200,76.01590238337654,0,2 +55,1000055,69.70000084489584,582,75.68422480575155,0,0 +56,1000056,444.6000052243471,3600,75.87884524455251,0,0 +57,1000057,444.6000052243471,3600,75.96981187494319,0,1 +58,1000058,444.6000052243471,3600,76.03772455115222,0,0 +59,1000059,437.90000515431166,3553,76.04088529786887,0,1 +60,1000060,348.9000041112304,2834,75.79422825165413,0,0 +61,1000061,444.6000052243471,3600,75.87728099437057,0,1 +62,1000062,78.9000009521842,656,75.96352981662133,0,0 +63,1000063,444.6000052243471,3600,75.80269270184165,0,1 +64,1000064,444.6000052243471,3600,75.88518180564401,0,0 +65,1000065,444.6000052243471,3600,75.87533034544981,0,1 +66,1000066,444.6000052243471,3600,75.94241138050401,0,0 +67,1000067,444.6000052243471,3600,75.95312277771471,0,0 +68,1000068,444.6000052243471,3600,75.8998829764233,0,0 +69,1000069,444.6000052243471,3600,75.98564617573034,0,1 +70,1000070,444.6000052243471,3600,75.68328575087021,0,0 +71,1000071,135.0000016093254,1109,75.99546963217229,0,4 +72,1000072,444.6000052243471,3600,75.9923106611263,0,0 +73,1000073,444.6000052243471,3600,75.80422251719546,0,0 +74,1000074,444.6000052243471,3600,75.95469853250815,0,0 +75,1000075,444.6000052243471,3600,75.74551875442629,0,1 +76,1000076,444.6000052243471,3600,75.93301571087362,0,3 +77,1000077,444.6000052243471,3600,75.98384926019328,0,1 +78,1000078,444.6000052243471,3600,75.85055115368883,0,1 +79,1000079,444.6000052243471,3600,75.97142616222317,0,2 +80,1000080,444.6000052243471,3600,75.97039764106849,0,0 +81,1000081,444.6000052243471,3600,75.74469321422862,0,0 +82,1000082,116.20000138878822,957,76.0366526049804,0,1 +83,1000083,444.6000052243471,3600,75.95924386190674,0,0 +84,1000084,444.6000052243471,3600,76.0310580385874,0,0 +85,1000085,36.60000045597553,314,75.8634823847272,0,0 +86,1000086,260.90000308305025,2125,75.91783880059099,0,2 +87,1000087,444.6000052243471,3600,76.16752514785735,0,0 +88,1000088,444.6000052243471,3600,75.83331254385584,0,1 +89,1000089,444.6000052243471,3600,76.2113387300584,0,7 +90,1000090,444.6000052243471,3600,75.8334932097261,0,1 +91,1000091,225.20000265538692,1831,75.75618859671614,0,0 +92,1000092,444.6000052243471,3600,75.79683788505955,0,1 +93,1000093,180.9000021442771,1478,75.96465307644473,0,0 +94,1000094,305.2000035941601,2478,75.86565754734926,0,0 +95,1000095,444.6000052243471,3600,75.74523644464854,0,1 +96,1000096,444.6000052243471,3600,75.94353591524424,0,1 +97,1000097,444.6000052243471,3600,75.81927739599219,0,1 +98,1000098,444.6000052243471,3600,75.96229410618645,0,0 +99,1000099,444.6000052243471,3600,75.94512877548694,0,1 diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/eval_config.yaml b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/eval_config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..91e25ca724de4d0e3b48900a0afb7c517b3b439a --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/eval_config.yaml @@ -0,0 +1,82 @@ +experiment: + name: flappy-mean5000-profile-simulation-100ep + seed: 1000000 +backend: + run_mode: eval +executor: + mode: simulated + simulated_worker_capacity: 1 + simulated_inference_pool: true + inference_devices: + - cuda:0 + inference_batch_size: 32 +env: + name: flappy + gym_id: FlappyBird-v0 + env_fps: 10 + obs_fps: 10 + render_mode: rgb_array + observation_mode: image + use_lidar: false + normalize_obs: true + audio_on: false + frame_stack: 1 + obs_resize: + - 224 + - 224 + simulator: gpu + use_gpu_render: false + gpu_render_device: auto + gpu_render_profile: false + gpu_render_profile_interval: 200 + noop_action: noop + action_map: + noop: 0 + flap: 1 + oneshot_actions: + - flap + action_history_decisions: 8 +latency: + method: temporal + profile_path: /home/ubuntu/lzj/profiles/published/profiles/openvla/1x-rtx3090/flappy/instance_a5037b165aa0cedc/profile.json + profile_worker_slot: 0 + seed: 271828 + add_latency_info: false +scheduler: + hold_policy: one_frame_then_noop + ordering_policy: latest_ready +policy: + type: starvla + checkpoint_path: /home/ubuntu/lzj/mean-profiling/flappy/vla-publication/checkpoints/model.pt + model_config_path: /home/ubuntu/lzj/mean-profiling/flappy/vla-publication/config.full.yaml + device: cuda:0 + unnorm_key: new_embodiment + prompt_mode: latency_neutral + actions: + - noop + - flap + state_source: transport + backbone_path: /home/ubuntu/lzj/models/Qwen3-VL-4B-Instruct + worker_python_executable: /home/ubuntu/lzj/conda/envs/qwenoft/bin/python +evaluation: + eval_episodes: 100 + eval_parallel_envs: 32 + latency_bench_env_backend: flappy_gpu_batched + eval_latency_values: null + eval_max_steps: 3600 + eval_deterministic: true + eval_raw_reward: true + eval_suites: + fixed: [] + normal: [] + uniform: [] +logging: + output_dir: /home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/flappy + save_step_records: true + save_action_records: true + save_latency_records: true + video: + enabled: false + wandb_project: null + wandb_group: null + wandb_job_type: null diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/batched_simulated.py b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/batched_simulated.py new file mode 100644 index 0000000000000000000000000000000000000000..d5edbe901e40e8e9cbb2e0763281fdfcd77dbfcc --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/batched_simulated.py @@ -0,0 +1,702 @@ +from __future__ import annotations + +import time +from collections.abc import Callable, Mapping, Sequence +from dataclasses import dataclass, field +from pathlib import Path + +import numpy as np + +from latency_bench.core.clock import EnvClock +from latency_bench.core.decision_action_history import DecisionActionHistory +from latency_bench.core.timing import StageProfiler, profiler_scope +from latency_bench.core.types import ActionEvent, EpisodeMetrics, LatencyRecord, Observation, StepRecord +from latency_bench.envs.atari import TRUE_EPISODE_END_INFO_KEY +from latency_bench.envs.base import EnvAdapter +from latency_bench.executors._simulated_timeline import ( + SimulatedResultTimeline, + SimulatedWorkerCapacity, + build_simulated_action_event, +) +from latency_bench.executors.base import BatchedExecutor +from latency_bench.executors.env_step_backend import EnvStepBackend, env_action_space +from latency_bench.latency.sample import LatencySample +from latency_bench.latency.samplers import LatencySampler +from latency_bench.logging.metrics import ( + compute_episode_metrics, + compute_episode_metrics_from_aggregates, + episode_raw_fact_metadata, + latency_type_from_source, + profile_metadata_from_source, +) +from latency_bench.logging.records import build_step_record +from latency_bench.logging.trajectory_logger import TrajectoryLogger +from latency_bench.policy.action_prefix import with_action_prefix +from latency_bench.policy.base import PolicyRunner +from latency_bench.scheduler.action_queue import ActionScheduler +from latency_bench.scheduler.decision import DecisionScheduler +from latency_bench.utils.io import write_json +from latency_bench.utils.stats import series_stats + + +@dataclass +class _EpisodeBuffers: + step_records: list[StepRecord] | None = None + action_events: list[ActionEvent] | None = None + latency_records: list[LatencyRecord] | None = None + latency_values_ms: list[float] = field(default_factory=list) + episode_return_env: float = 0.0 + survival_steps: int = 0 + game_score: float | None = None + return_raw: float | None = None + num_actions: int = 0 + num_dropped_actions: int = 0 + num_invalid_actions: int = 0 + submitted_observation_frames: int = 0 + dropped_observation_count: int = 0 + soft_reset_count: int = 0 + final_lives: int | None = None + final_is_true_episode_end: bool | None = None + task_metrics: dict | None = None + task_metric_moments: dict | None = None + + def record_step(self, *, reward: float, info: dict) -> None: + self.episode_return_env += float(reward) + self.survival_steps += 1 + if "invalid_action" in info and info["invalid_action"]: + self.num_invalid_actions += 1 + if "soft_reset" in info and info["soft_reset"]: + self.soft_reset_count += 1 + if "lives" in info: + self.final_lives = info["lives"] + if TRUE_EPISODE_END_INFO_KEY in info: + self.final_is_true_episode_end = info[TRUE_EPISODE_END_INFO_KEY] + if "game_score" in info: + self.game_score = float(info["game_score"]) + if "score" in info: + self.game_score = float(info["score"]) + if "task_metrics" in info: + self.task_metrics = info["task_metrics"] + if "task_metric_moments" in info: + self.task_metric_moments = info["task_metric_moments"] + self._update_return_raw(info) + extra_stats = info["episode_extra_stats"] if "episode_extra_stats" in info else None + if isinstance(extra_stats, dict): + self._update_return_raw(extra_stats) + + def _update_return_raw(self, stats: dict) -> None: + for key in ("return_raw", "raw_return", "episodic_raw_return", "episode/raw_return"): + if key in stats and stats[key] is not None: + self.return_raw = float(stats[key]) + + +@dataclass +class _SlotState: + slot_id: int + env: EnvAdapter + latency_source: LatencySampler + action_scheduler: ActionScheduler + result_timeline: SimulatedResultTimeline + active: bool = False + episode_id: int | None = None + episode_seed: int | None = None + env_step: int = 0 + recent_drop_count: int = 0 + decision_action_history: DecisionActionHistory | None = None + decision_admitted: bool = False + decision_issued_action: object = None + buffers: _EpisodeBuffers = field(default_factory=_EpisodeBuffers) + worker_capacity: SimulatedWorkerCapacity = field( + default_factory=lambda: SimulatedWorkerCapacity(capacity=None, busy_until_by_worker={}) + ) + + +@dataclass +class _PendingPolicyObservation: + slot: _SlotState + observation: Observation + obs_id: int + latency_sample: LatencySample + worker_slot: int + + +class BatchedSimulatedLatencyExecutor(BatchedExecutor): + """Run multiple simulated episodes concurrently with independent slot state. + + The main process owns policy inference, latency scheduling, episode accounting, + and logging. Env stepping can be serial in-process or delegated to worker + subprocesses through env_backend. + """ + + def __init__( + self, + *, + env_backend: EnvStepBackend, + policy: PolicyRunner, + decision_scheduler: DecisionScheduler, + latency_sources: Sequence[LatencySampler], + action_schedulers: Sequence[ActionScheduler], + clock: EnvClock, + logger: TrajectoryLogger | None = None, + episode_latency_source_factory: Callable[[int], LatencySampler] | None = None, + simulated_worker_capacity: int | None = None, + profile_pipeline: bool = False, + inference_pool=None, + action_prefix=None, + action_history_decisions: int | None = None, + ): + slot_count = env_backend.num_slots + self.env_backend = env_backend + self.envs = list(env_backend.slot_handles) + self.policy = policy + self.decision_scheduler = decision_scheduler + self.clock = clock + self.logger = logger + self.profile_pipeline = bool(profile_pipeline) + self.inference_pool = inference_pool + self.action_prefix = action_prefix + self._pipeline_profile_rows: list[dict[str, float]] = [] + self.simulated_worker_capacity = simulated_worker_capacity + self._collect_step_records = bool(logger is not None and logger.save_step_records) + self._collect_action_records = bool(logger is not None and logger.save_action_records) + self._collect_latency_records = bool(logger is not None and logger.save_latency_records) + self.episode_latency_source_factory = episode_latency_source_factory + self.slots = [ + _SlotState( + slot_id=slot_id, + env=self.envs[slot_id], + latency_source=latency_sources[slot_id], + action_scheduler=action_schedulers[slot_id], + result_timeline=SimulatedResultTimeline( + ordering_policy=action_schedulers[slot_id].ordering_policy + ), + decision_action_history=( + DecisionActionHistory( + env_action_space(self.envs[slot_id]), num_envs=1, decisions=action_history_decisions + ) if action_history_decisions is not None else None + ), + buffers=self._new_episode_buffers(), + worker_capacity=SimulatedWorkerCapacity( + capacity=simulated_worker_capacity, + busy_until_by_worker={}, + ), + ) + for slot_id in range(slot_count) + ] + self._next_obs_id = 0 + self._next_action_id = 0 + self.started_episodes = 0 + self.completed_episodes = 0 + self._completed_metrics: dict[int, EpisodeMetrics] = {} + self._completed_buffers: dict[int, _EpisodeBuffers] = {} + self._episode_log_order: list[int] = [] + self._next_episode_log_index = 0 + + @property + def num_slots(self) -> int: + return len(self.slots) + + def close(self) -> None: + if self.inference_pool is not None: + self.inference_pool.close() + self.env_backend.close() + + def run_episodes( + self, + *, + episode_ids: Sequence[int], + seeds: Sequence[int | None], + eval_max_steps: int = 10000, + on_episode_complete: Callable[[EpisodeMetrics], None] | None = None, + ) -> list[EpisodeMetrics]: + if eval_max_steps < 0: + raise ValueError("eval_max_steps must be non-negative") + episode_ids = [int(episode_id) for episode_id in episode_ids] + if len(seeds) != len(episode_ids): + raise ValueError("seeds length must match episode_ids length") + + self._reset_run_state(episode_ids) + if not episode_ids: + return [] + + next_episode_index = 0 + initial_slots = min(self.num_slots, len(episode_ids)) + for slot in self.slots[:initial_slots]: + self._start_slot( + slot, + episode_id=episode_ids[next_episode_index], + seed=seeds[next_episode_index], + ) + next_episode_index += 1 + + while self.completed_episodes < len(episode_ids): + active_slots = self._active_slots() + if eval_max_steps == 0: + for slot in active_slots: + self._complete_slot(slot, on_episode_complete=on_episode_complete) + if next_episode_index < len(episode_ids): + self._start_slot( + slot, + episode_id=episode_ids[next_episode_index], + seed=seeds[next_episode_index], + ) + next_episode_index += 1 + continue + + observations = [] + observation_slots: list[_SlotState] = [] + step_capacity_info: dict[int, dict[str, int | bool | None]] = {} + for slot in active_slots: + current_time_ms = self.clock.step_to_time_ms(slot.env_step) + slot.worker_capacity.release_ready(slot.env_step) + self._deliver_arrived_results(slot, raw_frame=slot.env_step) + observation_submitted = False + observation_dropped = False + if self.decision_scheduler.should_observe(slot.env_step, current_time_ms): + prefix_request_pending = ( + self.action_prefix is not None + and self.action_prefix["mode"] != "none" + and slot.result_timeline.pending_observation_count > 0 + ) + if slot.worker_capacity.can_submit() and not prefix_request_pending: + observation_slots.append(slot) + observation_submitted = True + else: + slot.buffers.dropped_observation_count += 1 + observation_dropped = True + slot.recent_drop_count += 1 + if self.simulated_worker_capacity is not None: + step_capacity_info[slot.slot_id] = { + "observation_submitted": observation_submitted, + "observation_dropped": observation_dropped, + } + if slot.decision_action_history is not None and slot.env_step % self.clock.obs_stride_raw_frames == 0: + slot.decision_admitted = observation_submitted + slot.decision_issued_action = slot.action_scheduler.noop_action.value + + observe_ms = 0.0 + if observation_slots: + observe_start = time.perf_counter() + observations_by_slot = self.env_backend.observe_slots([slot.slot_id for slot in observation_slots]) + observe_ms = (time.perf_counter() - observe_start) * 1000.0 + pending_observations = [ + self._sample_policy_observation( + slot, + self._policy_observation( + slot, + observations_by_slot[slot.slot_id], + transport=( + slot.decision_action_history.observation()[0] + if slot.decision_action_history is not None else None + ), + ), + ) + for slot in observation_slots + ] + observations = [pending.observation for pending in pending_observations] + + profile_row = None + if observations: + profiler = StageProfiler(enabled=self.profile_pipeline) + with profiler_scope(profiler): + policy_outputs = ( + self.inference_pool.predict_batch(observations) + if self.inference_pool is not None + else self.policy.predict_batch(observations) + ) + if len(policy_outputs) != len(observations): + raise RuntimeError("policy.predict_batch returned the wrong number of outputs") + if self.profile_pipeline: + profile_row = { + "active_slots": float(len(active_slots)), + "batch_size": float(len(observations)), + "observe_slots_ms": observe_ms, + **{key: float(value) for key, value in profiler.timings.items()}, + } + for pending, policy_output in zip(pending_observations, policy_outputs): + if pending.slot.decision_action_history is not None: + pending.slot.decision_issued_action = policy_output.action.value + self._enqueue_policy_output( + pending.slot, + pending.observation, + policy_output, + obs_id=pending.obs_id, + latency_sample=pending.latency_sample, + worker_slot=pending.worker_slot, + ) + + actions_by_slot = {} + for slot in active_slots: + current_time_ms = self.clock.step_to_time_ms(slot.env_step) + self._deliver_arrived_results(slot, raw_frame=slot.env_step) + active_action = slot.action_scheduler.update(slot.env_step, current_time_ms) + actions_by_slot[slot.slot_id] = active_action + + env_step_start = time.perf_counter() + step_responses = self.env_backend.step_slots(actions_by_slot) + if profile_row is not None: + profile_row["env_step_ms"] = (time.perf_counter() - env_step_start) * 1000.0 + self._pipeline_profile_rows.append(profile_row) + for slot in active_slots: + current_time_ms = self.clock.step_to_time_ms(slot.env_step) + active_action = actions_by_slot[slot.slot_id] + if ( + slot.decision_action_history is not None + and (slot.env_step + 1) % self.clock.obs_stride_raw_frames == 0 + ): + slot.decision_action_history.append( + [0], [slot.decision_admitted], + [slot.decision_issued_action], [active_action.value], + ) + result = step_responses[slot.slot_id].result + soft_reset = bool(result.info.get("soft_reset")) if isinstance(result.info, dict) else False + episode_done = bool(result.done or result.truncated) and not soft_reset + if slot.buffers.step_records is not None: + record = build_step_record( + episode_id=int(slot.episode_id), + env_step=slot.env_step, + scheduled_time_ms=current_time_ms, + active_action=active_action, + reward=result.reward, + done=episode_done, + info=result.info, + active_event=slot.action_scheduler.latest_applied_event, + frame_ms=self.clock.frame_ms, + latency_type=latency_type_from_source(slot.latency_source), + ) + slot.buffers.step_records.append(record) + slot.buffers.record_step(reward=float(result.reward), info=record.info) + else: + slot.buffers.record_step(reward=float(result.reward), info=result.info) + if self.simulated_worker_capacity is not None and slot.buffers.step_records is not None: + slot.buffers.step_records[-1].info.update( + { + **step_capacity_info[slot.slot_id], + "in_flight_count": slot.worker_capacity.in_flight_count, + "idle_worker_count": slot.worker_capacity.idle_worker_count, + } + ) + if soft_reset: + slot.buffers.num_dropped_actions += slot.action_scheduler.dropped_events_count + slot.action_scheduler.reset() + slot.result_timeline.reset() + self._reset_policy_state(slot.slot_id) + slot.worker_capacity.reset() + if slot.decision_action_history is not None: + slot.decision_action_history.reset() + slot.recent_drop_count = 0 + + slot.env_step += 1 + if episode_done or slot.env_step >= eval_max_steps: + self._complete_slot(slot, on_episode_complete=on_episode_complete) + if next_episode_index < len(episode_ids): + self._start_slot( + slot, + episode_id=episode_ids[next_episode_index], + seed=seeds[next_episode_index], + ) + next_episode_index += 1 + + self._write_pipeline_profile_summary() + return self._ordered_metrics(episode_ids) + + def _policy_observation( + self, + slot: _SlotState, + observation: Observation, + transport: np.ndarray | None = None, + ) -> Observation: + observation = with_action_prefix(observation, slot.action_scheduler, self.action_prefix) + metadata = dict(observation.metadata) + metadata["slot_id"] = slot.slot_id + metadata["episode_id"] = int(slot.episode_id) + metadata["action_noise_seed"] = slot.episode_seed + data = observation.data + if transport is not None: + data = {**data, "transport": transport} if isinstance(data, Mapping) else {"obs": data, "transport": transport} + return Observation( + data=data, + env_step=observation.env_step, + sim_time_ms=observation.sim_time_ms, + metadata=metadata, + ) + + def _sample_policy_observation( + self, + slot: _SlotState, + observation: Observation, + ) -> _PendingPolicyObservation: + obs_id = self._next_obs_id + self._next_obs_id += 1 + raw_frame = int(slot.env_step) + current_time_ms = self.clock.step_to_time_ms(raw_frame) + worker_slot = slot.worker_capacity.assign_worker() + latency_context = { + "observation": observation, + "obs_id": obs_id, + "env_step": raw_frame, + "raw_frame": raw_frame, + "sim_time_ms": current_time_ms, + "episode_id": slot.episode_id, + "slot_id": slot.slot_id, + "worker_slot": worker_slot, + "recent_drop_count": slot.recent_drop_count, + "in_flight_count": slot.worker_capacity.in_flight_count, + "idle_worker_count": slot.worker_capacity.idle_worker_count, + } + latency_sample = slot.latency_source.sample(latency_context) + metadata = dict(observation.metadata) + metadata["obs_id"] = obs_id + policy_observation = Observation( + data=observation.data, + env_step=observation.env_step, + sim_time_ms=observation.sim_time_ms, + metadata=metadata, + ) + slot.worker_capacity.submit( + worker_slot, raw_frame + latency_sample.worker_service_raw_frames + ) + return _PendingPolicyObservation( + slot=slot, + obs_id=obs_id, + latency_sample=latency_sample, + worker_slot=worker_slot, + observation=policy_observation, + ) + + def _reset_run_state(self, episode_ids: Sequence[int]) -> None: + self.started_episodes = 0 + self.completed_episodes = 0 + self._pipeline_profile_rows.clear() + self._completed_metrics.clear() + self._completed_buffers.clear() + self._episode_log_order = [int(episode_id) for episode_id in episode_ids] + self._next_episode_log_index = 0 + for slot in self.slots: + slot.active = False + slot.episode_id = None + slot.episode_seed = None + slot.env_step = 0 + slot.recent_drop_count = 0 + slot.buffers = self._new_episode_buffers() + slot.action_scheduler.reset() + slot.result_timeline.reset() + slot.worker_capacity.reset() + if slot.decision_action_history is not None: + slot.decision_action_history.reset() + + def _active_slots(self) -> list[_SlotState]: + return [slot for slot in self.slots if slot.active] + + def _deliver_arrived_results(self, slot: _SlotState, *, raw_frame: int | None) -> None: + released, dropped = slot.result_timeline.release_arrived(raw_frame) + slot.buffers.num_dropped_actions += len(dropped) + for event in released: + slot.action_scheduler.enqueue(event) + + def _start_slot(self, slot: _SlotState, *, episode_id: int, seed: int | None) -> None: + if self.episode_latency_source_factory is not None: + slot.latency_source = self.episode_latency_source_factory(episode_id) + slot.active = True + slot.episode_id = int(episode_id) + slot.episode_seed = None if seed is None else int(seed) + slot.env_step = 0 + slot.recent_drop_count = 0 + slot.buffers = self._new_episode_buffers() + slot.action_scheduler.reset() + slot.result_timeline.reset() + slot.worker_capacity.reset() + if slot.decision_action_history is not None: + slot.decision_action_history.reset() + self._reset_policy_state(slot.slot_id) + self.env_backend.reset_slot(slot.slot_id, episode_id=episode_id, seed=seed) + self.started_episodes += 1 + + def _reset_policy_state(self, slot_id: int) -> None: + if self.inference_pool is not None: + self.inference_pool.reset_state(slot_id) + else: + self.policy.reset_state(slot_id=slot_id) + + def _complete_slot( + self, + slot: _SlotState, + *, + on_episode_complete: Callable[[EpisodeMetrics], None] | None = None, + ) -> None: + if not slot.active or slot.episode_id is None: + return + episode_id = int(slot.episode_id) + self._deliver_arrived_results(slot, raw_frame=None) + slot.buffers.num_dropped_actions += slot.action_scheduler.dropped_events_count + metrics = self._compute_episode_metrics( + episode_id=episode_id, + buffers=slot.buffers, + metadata=episode_raw_fact_metadata( + mode="simulated", + episode_seed=slot.episode_seed, + env_fps=self.clock.env_fps, + obs_fps=self.clock.obs_fps, + frame_ms=self.clock.frame_ms, + latency_type=latency_type_from_source(slot.latency_source), + latency_source=slot.latency_source, + ) + | slot.action_scheduler.chunk_metrics() + | ( + { + "submitted_observation_frames": slot.buffers.submitted_observation_frames, + "dropped_observation_count": slot.buffers.dropped_observation_count, + "simulated_worker_capacity": self.simulated_worker_capacity, + "inference_worker_count": self.simulated_worker_capacity, + "in_flight_count": slot.worker_capacity.in_flight_count, + "idle_worker_count": slot.worker_capacity.idle_worker_count, + } + if self.simulated_worker_capacity is not None + else {} + ), + ) + self._completed_metrics[episode_id] = metrics + self._completed_buffers[episode_id] = slot.buffers + self.completed_episodes += 1 + slot.active = False + slot.episode_id = None + slot.episode_seed = None + slot.env_step = 0 + slot.recent_drop_count = 0 + slot.buffers = self._new_episode_buffers() + slot.action_scheduler.reset() + slot.result_timeline.reset() + slot.worker_capacity.reset() + if slot.decision_action_history is not None: + slot.decision_action_history.reset() + self._flush_completed_in_episode_order() + if on_episode_complete is not None: + on_episode_complete(metrics) + + def _enqueue_policy_output( + self, + slot: _SlotState, + observation, + policy_output, + *, + obs_id: int, + latency_sample: LatencySample, + worker_slot: int, + ) -> None: + raw_frame = int(slot.env_step) + latency_ms = latency_sample.latency_ms + ready_raw_frame = raw_frame + latency_sample.action_ready_raw_frames + ready_time_ms = self.clock.step_to_time_ms(ready_raw_frame) + latency_type = latency_type_from_source(slot.latency_source) + profile_metadata = profile_metadata_from_source(slot.latency_source) + slot_metadata = { + "episode_id": int(slot.episode_id), + "slot_id": int(slot.slot_id), + "worker_id": int(worker_slot), + } + latency_record, event = build_simulated_action_event( + action_id=self._next_action_id, + obs_id=obs_id, + policy_output=policy_output, + raw_frame=raw_frame, + ready_raw_frame=ready_raw_frame, + ready_time_ms=ready_time_ms, + latency_sample=latency_sample, + frame_ms=self.clock.frame_ms, + latency_type=latency_type, + profile_metadata=profile_metadata, + latency_record_metadata=slot_metadata, + extra_event_metadata=slot_metadata, + ) + self._next_action_id += 1 + slot.result_timeline.submit(obs_id=obs_id, ready_raw_frame=ready_raw_frame, event=event) + slot.buffers.submitted_observation_frames += 1 + slot.recent_drop_count = 0 + slot.buffers.num_actions += 1 + if slot.buffers.action_events is not None: + slot.buffers.action_events.append(event) + slot.buffers.latency_values_ms.append(latency_ms) + if slot.buffers.latency_records is not None: + slot.buffers.latency_records.append(latency_record) + + def _flush_completed_in_episode_order(self) -> None: + if self.logger is None: + return + while self._next_episode_log_index < len(self._episode_log_order): + episode_id = self._episode_log_order[self._next_episode_log_index] + if episode_id not in self._completed_metrics: + break + buffers = self._completed_buffers[episode_id] + metrics = self._completed_metrics[episode_id] + if buffers.step_records is not None: + for record in buffers.step_records: + self.logger.log_step(record) + if buffers.action_events is not None: + for event in buffers.action_events: + self.logger.log_action_event(event) + if buffers.latency_records is not None: + for latency_record in buffers.latency_records: + self.logger.log_latency(latency_record) + self.logger.log_episode_metrics(metrics) + self._next_episode_log_index += 1 + + def _ordered_metrics(self, episode_ids: Sequence[int]) -> list[EpisodeMetrics]: + return [self._completed_metrics[int(episode_id)] for episode_id in episode_ids] + + def _new_episode_buffers(self) -> _EpisodeBuffers: + return _EpisodeBuffers( + step_records=[] if self._collect_step_records else None, + action_events=[] if self._collect_action_records else None, + latency_records=[] if self._collect_latency_records else None, + ) + + def _write_pipeline_profile_summary(self) -> None: + if not self.profile_pipeline or self.logger is None or not self._pipeline_profile_rows: + return + keys = sorted({key for row in self._pipeline_profile_rows for key in row}) + summary = { + "num_profiled_batches": len(self._pipeline_profile_rows), + **{ + key: series_stats([float(row[key]) for row in self._pipeline_profile_rows if key in row]) + for key in keys + }, + } + write_json(Path(self.logger.output_dir) / "simulated_pipeline_summary.json", summary) + + def _compute_episode_metrics( + self, + *, + episode_id: int, + buffers: _EpisodeBuffers, + metadata: dict, + ) -> EpisodeMetrics: + if buffers.task_metrics is not None: + metadata["task_metrics"] = buffers.task_metrics + if buffers.task_metric_moments is not None: + metadata["task_metric_moments"] = buffers.task_metric_moments + if buffers.final_lives is not None: + metadata["final_lives"] = buffers.final_lives + if buffers.final_is_true_episode_end is not None: + metadata["final_is_true_episode_end"] = buffers.final_is_true_episode_end + metadata["soft_reset_count"] = buffers.soft_reset_count + if buffers.step_records is not None and buffers.action_events is not None: + return compute_episode_metrics( + episode_id=episode_id, + step_records=buffers.step_records, + action_events=buffers.action_events, + latency_values_ms=buffers.latency_values_ms, + metadata=metadata, + frame_ms=self.clock.frame_ms, + ) + return compute_episode_metrics_from_aggregates( + episode_id=episode_id, + episode_return_env=buffers.episode_return_env, + survival_steps=buffers.survival_steps, + return_raw=buffers.return_raw, + game_score=buffers.game_score, + latency_values_ms=buffers.latency_values_ms, + num_actions=buffers.num_actions, + num_dropped_actions=buffers.num_dropped_actions, + num_invalid_actions=buffers.num_invalid_actions, + metadata=metadata, + ) diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/deadly-compatibility.patch b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/deadly-compatibility.patch new file mode 100644 index 0000000000000000000000000000000000000000..bdeca64d184242eedaa57463d2e0a242f43e19ba --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/deadly-compatibility.patch @@ -0,0 +1,99 @@ +diff --git a/latency_bench/envs/deadly_corridor.py b/latency_bench/envs/deadly_corridor.py +index 4dcaa48c..dc4d1186 100644 +--- a/latency_bench/envs/deadly_corridor.py ++++ b/latency_bench/envs/deadly_corridor.py +@@ -5,7 +5,7 @@ from collections import deque + from typing import Any + + import numpy as np +-from gymnasium.spaces import Box, Tuple ++from gymnasium.spaces import Box, MultiBinary, Tuple + + from latency_bench.core.types import Action, Observation, StepResult + from latency_bench.envs.base import EnvAdapter +@@ -346,6 +346,7 @@ class DeadlyCorridorVlaEnvAdapter(EnvAdapter): + export_env_raw_rgb_frames: bool = True, + ): + import gymnasium as gym ++ import vizdoom + import vizdoom.gymnasium_wrapper # noqa: F401 (registers the env ids) + + env_cfg = config["env"] +@@ -360,30 +361,27 @@ class DeadlyCorridorVlaEnvAdapter(EnvAdapter): + ) + if key in env_cfg + } +- attempts = [ +- ("VizdoomDeadlyCorridor-MultiBinary-v1", {}), +- ("VizdoomDeadlyCorridor-MultiBinary-v0", {}), +- ("VizdoomDeadlyCorridor-v1", {"max_buttons_pressed": 0}), +- ("VizdoomDeadlyCorridor-v0", {"max_buttons_pressed": 0}), +- ] +- last_exc: Exception | None = None +- self.gym_env = None +- for env_id, kwargs in attempts: +- try: +- # frame_skip=1: the latency_bench scheduler advances obs_stride raw +- # frames per decision and holds the action between observations. +- self.gym_env = gym.make( +- env_id, render_mode="rgb_array", frame_skip=1, **render_options, **kwargs +- ) +- self.env_id = env_id +- break +- except (gym.error.NameNotFound, gym.error.VersionNotFound, gym.error.NamespaceNotFound) as exc: +- last_exc = exc +- if self.gym_env is None: +- raise RuntimeError(f"Failed to create Deadly Corridor MultiBinary env: {last_exc}") ++ # ViZDoom registers deadly_corridor.cfg under this official Gym ID. ++ self.env_id = "VizdoomCorridor-v0" ++ self.gym_env = gym.make( ++ self.env_id, render_mode="rgb_array", frame_skip=1, max_buttons_pressed=0, ++ ) ++ game = self.gym_env.unwrapped.game ++ game.close() ++ for key, value in render_options.items(): ++ if key == "screen_resolution": ++ value = getattr(vizdoom.ScreenResolution, value) ++ getattr(game, f"set_{key}")(value) ++ game.init() ++ self.gym_env.unwrapped.observation_space.spaces["screen"] = Box( ++ 0, 255, ++ shape=(game.get_screen_height(), game.get_screen_width(), game.get_screen_channels()), ++ dtype=np.uint8, ++ ) + + self._runtime_button_order = _deadly_runtime_button_names(self.gym_env) + self._num_buttons = len(self._runtime_button_order) ++ self.gym_env.unwrapped.action_space = MultiBinary(self._num_buttons) + self.noop_action = noop_action or Action( + value=[0] * self._num_buttons, name="NOOP", is_noop=True + ) +diff --git a/tests/integration/test_deadly_render_contract.py b/tests/integration/test_deadly_render_contract.py +index 535db22a..09894b1b 100644 +--- a/tests/integration/test_deadly_render_contract.py ++++ b/tests/integration/test_deadly_render_contract.py +@@ -5,11 +5,13 @@ import json + import numpy as np + import pytest + +-pytest.importorskip("vizdoom", minversion="1.3.0") ++pytest.importorskip("vizdoom", minversion="1.2.4") + pytest.importorskip("sample_factory") + + from latency_bench.envs.deadly_corridor import DeadlyCorridorEnvAdapter, DeadlyCorridorVlaEnvAdapter + from latency_bench.envs.raw_rgb import ENV_RAW_RGB_FRAME_STACK_INFO_KEY ++from latency_bench.core.types import Action ++from gymnasium.spaces import MultiBinary + from scripts.tasks.decision_history.eval_vla_hist8 import evaluation_config + + +@@ -33,6 +35,9 @@ def test_hist8_deadly_vla_uses_the_teacher_resolution_and_hud(tmp_path): + # The health/ammo panel is stable across the two engine reset paths; + # the animated face and enemies can differ with their RNG streams. + np.testing.assert_array_equal(teacher_frame[-20:, :64], student_frame[-20:, :64]) ++ assert isinstance(student.gym_env.action_space, MultiBinary) ++ step = student.step(Action(value=[1, 0, 0, 0, 0, 0, 1], name="forward_attack")) ++ assert np.isfinite(step.reward) + finally: + teacher.close() + student.close() diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/deadly_corridor.py b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/deadly_corridor.py new file mode 100644 index 0000000000000000000000000000000000000000..1016be20dca9e949c752192edb407b9a84e30e35 --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/deadly_corridor.py @@ -0,0 +1,455 @@ +from __future__ import annotations + +import copy +from collections import deque +from typing import Any + +import numpy as np +from gymnasium.spaces import Box, MultiBinary, Tuple + +from latency_bench.core.types import Action, Observation, StepResult +from latency_bench.envs.base import EnvAdapter +from latency_bench.utils.array import looks_chw +from latency_bench.envs.raw_rgb import RawRgbFrameStackBuffer + + +def _noop_action_from_space(space) -> Any: + n = getattr(space, "n", None) + if n is not None: + return 0 + if isinstance(space, Tuple): + return tuple(_noop_action_from_space(subspace) for subspace in space.spaces) + if isinstance(space, Box): + import numpy as np + + return np.zeros(space.shape, dtype=space.dtype) + raise TypeError(f"Unsupported action space for Deadly Corridor no-op action: {space}") + + +def _coerce_noop_action_for_space(value: Any, space) -> Any: + if isinstance(space, Tuple): + if isinstance(value, (list, tuple)): + if len(value) != len(space.spaces): + raise ValueError( + f"Deadly Corridor no-op action length {len(value)} does not match action space {space}" + ) + return tuple( + _coerce_noop_action_for_space(item, subspace) + for item, subspace in zip(value, space.spaces) + ) + if value == 0: + return _noop_action_from_space(space) + return value + + +def _spec_with_reward_scaling(spec: Any, disable_reward_scaling: bool) -> Any: + if not disable_reward_scaling: + return spec + spec_to_use = copy.copy(spec) + spec_to_use.reward_scaling = 1.0 + return spec_to_use + + +def _synchronous_eval_fps_from_config(config: dict[str, Any], default: int = 35) -> int: + env_cfg = config.get("env", {}) + try: + fps = int(float(env_cfg.get("env_fps", default))) + except (TypeError, ValueError) as exc: + raise ValueError("env_fps must be positive") from exc + if fps <= 0: + raise ValueError("env_fps must be positive") + return fps + + +def _build_sample_factory_eval_cfg(config: dict[str, Any]) -> Any: + from training.deadly_corridor_sf import integration + from training.common.utils import maybe_set_cli_override + + integration.register_deadly_corridor_components() + base_cfg = integration.SAMPLE_FACTORY_CONFIG_PARSER.parse_eval( + integration.build_cli_args_from_config(config) + ) + eval_fps = _synchronous_eval_fps_from_config(config) + cfg = copy.deepcopy(base_cfg) + if _requires_sample_factory_checkpoint_config(config): + from sample_factory.cfg.arguments import load_from_checkpoint + + cfg = load_from_checkpoint(cfg) + + for key in ( + "seed", + "res_w", + "res_h", + "wide_aspect_ratio", + ): + if hasattr(base_cfg, key): + maybe_set_cli_override(cfg, key, getattr(base_cfg, key)) + maybe_set_cli_override(cfg, "frame_stack", 1) + explicit_max_episode_steps = int(getattr(base_cfg, "max_episode_steps", 0) or 0) + if explicit_max_episode_steps > 0: + maybe_set_cli_override(cfg, "max_episode_steps", explicit_max_episode_steps) + else: + eval_max_steps = int(getattr(base_cfg, "eval_max_steps", 0) or 0) + if eval_max_steps > 0: + maybe_set_cli_override(cfg, "max_episode_steps", eval_max_steps) + + maybe_set_cli_override(cfg, "mode", "eval") + maybe_set_cli_override(cfg, "latency_type", "zero") + maybe_set_cli_override(cfg, "fixed_latency_ms", 0.0) + maybe_set_cli_override(cfg, "env_frameskip", 1) + maybe_set_cli_override(cfg, "eval_env_frameskip", 1) + maybe_set_cli_override(cfg, "num_envs", 1) + maybe_set_cli_override(cfg, "no_render", True) + maybe_set_cli_override(cfg, "save_video", False) + maybe_set_cli_override(cfg, "fps", eval_fps) + maybe_set_cli_override(cfg, "eval_deterministic", bool(getattr(base_cfg, "eval_deterministic", True))) + maybe_set_cli_override(cfg, "disable_reward_scaling", bool(getattr(base_cfg, "eval_raw_reward", False))) + return cfg + + +def _requires_sample_factory_checkpoint_config(config: dict[str, Any]) -> bool: + policy_type = str(config.get("policy", {}).get("type", "")).strip().lower() + return policy_type == "deadly_corridor_sf" + + +def _seed_initialized_vizdoom_game(env: Any, seed: int) -> bool: + unwrapped = getattr(env, "unwrapped", env) + game = getattr(unwrapped, "game", None) + if game is None: + return False + unwrapped.seed(int(seed)) + game.set_seed(int(unwrapped.curr_seed)) + return True + + +class DeadlyCorridorEnvAdapter(EnvAdapter): + """Latency-bench adapter for ViZDoom Deadly Corridor using the SF Doom env stack.""" + OBSERVATION_TYPE = "vizdoom_frame_v1" + + def __init__( + self, + *, + config: dict[str, Any], + noop_action: Action | None = None, + export_env_raw_rgb_frames: bool = False, + ): + env_cfg = config["env"] + env_id = str(env_cfg.get("env_id", "doom_deadly_corridor")) + env_fps = float(env_cfg.get("env_fps", 35)) + self.frame_stack = int(env_cfg.get("frame_stack", 1) or 1) + + from sample_factory.utils.attr_dict import AttrDict + from sf_examples.vizdoom.doom.doom_utils import DOOM_ENVS, make_doom_env_from_spec + + cfg = _build_sample_factory_eval_cfg(config) + spec = next((item for item in DOOM_ENVS if item.name == str(env_id)), None) + if spec is None: + raise ValueError(f"Unknown ViZDoom env spec: {env_id}") + spec_to_use = _spec_with_reward_scaling( + spec, + disable_reward_scaling=bool(getattr(cfg, "disable_reward_scaling", False)), + ) + self.gym_env = make_doom_env_from_spec( + spec_to_use, + str(env_id), + cfg, + AttrDict(worker_index=0, vector_index=0, env_id=0), + render_mode=None, + ) + self.cfg = cfg + self.env_id = env_id + self.env_fps = float(env_fps) + action_space = self.gym_env.action_space + noop_value = _noop_action_from_space(action_space) + if noop_action is None: + self.noop_action = Action(value=noop_value, name=str(noop_value), is_noop=True) + else: + coerced_noop_value = _coerce_noop_action_for_space(noop_action.value, action_space) + self.noop_action = Action( + value=coerced_noop_value, + name=str(coerced_noop_value), + is_noop=True, + is_oneshot=noop_action.is_oneshot, + ) + self.env_step = 0 + self.export_env_raw_rgb_frames = bool(export_env_raw_rgb_frames) + self._last_info: dict[str, Any] = {} + self._last_frame: Any = None + self._observed_frames: deque[np.ndarray] = deque(maxlen=self.frame_stack) + self._raw_rgb_frames = RawRgbFrameStackBuffer(num_frames=self.frame_stack) + + def reset(self, seed: int | None = None) -> Observation: + self.env_step = 0 + self._observed_frames.clear() + if seed is not None: + if _seed_initialized_vizdoom_game(self.gym_env, int(seed)): + obs, info = self.gym_env.reset() + else: + try: + obs, info = self.gym_env.reset(seed=seed) + except TypeError: + obs, info = self.gym_env.reset() + else: + obs, info = self.gym_env.reset() + self._last_frame = obs + self._last_info = dict(info or {}) + self._reset_frame_stack(obs) + if self.export_env_raw_rgb_frames: + self._reset_raw_rgb_frame_stack() + return self._make_observation(info=self._last_info) + + def step(self, action: Action) -> StepResult: + gym_action = action.value + obs, reward, terminated, truncated, info = self.gym_env.step(gym_action) + self.env_step += 1 + self._last_frame = obs + self._last_info = dict(info or {}) + self._append_frame(obs) + if self.export_env_raw_rgb_frames and not bool(terminated or truncated): + self._append_raw_rgb_frame() + observation = self._make_observation(info=self._last_info) + step_info = dict(self._last_info) + step_info.update( + { + "env_step": self.env_step, + "sim_time_ms": self.env_step * self.frame_ms, + "applied_action": gym_action, + "applied_action_name": action.name, + "observation": "vizdoom_frame_v1", + } + ) + return StepResult( + observation=observation, + reward=float(reward), + done=bool(terminated), + truncated=bool(truncated), + info=step_info, + ) + + def observe(self) -> Observation: + if self._last_frame is None: + raise RuntimeError("DeadlyCorridorEnvAdapter has no current observation; call reset() first") + metadata = self._metadata(self._last_info) + return Observation( + data=self._policy_frame_stack(), + env_step=self.env_step, + sim_time_ms=self.env_step * self.frame_ms, + metadata=metadata, + ) + + def render_game_frame(self) -> np.ndarray: + return np.transpose(self.gym_env.unwrapped.game.get_state().screen_buffer, (1, 2, 0)) + + def close(self) -> None: + self.gym_env.close() + + def _reset_frame_stack(self, frame: Any) -> None: + self._observed_frames.clear() + self._append_frame(frame) + + def _append_frame(self, frame: Any) -> None: + self._observed_frames.append(_single_frame_data(frame)) + + def _policy_frame_stack(self) -> np.ndarray: + frames = list(self._observed_frames) + if not frames: + raise RuntimeError("Deadly Corridor observe() has no current frame; call reset() first") + if len(frames) < self.frame_stack: + frames = [frames[0]] * (self.frame_stack - len(frames)) + frames + frames = [np.asarray(frame, dtype=np.uint8) for frame in frames[-self.frame_stack :]] + if self.frame_stack == 1: + return frames[-1] + axis = 0 if looks_chw(frames[0]) else -1 + return np.concatenate(frames, axis=axis) + + +def _single_frame_data(frame: Any) -> np.ndarray: + value = frame.get("obs") if isinstance(frame, dict) else frame + arr = np.asarray(value, dtype=np.uint8) + if arr.ndim == 2: + return arr[..., None] + if arr.ndim != 3: + raise ValueError(f"Expected Deadly Corridor image frame with 2 or 3 dims, got {arr.shape!r}") + return arr + + +# Fixed semantic button order the StarVLA multibinary head is trained against. +# Mirrors starVLA.training.rl_games.eval_core._semantic_to_runtime_multibinary. +DEADLY_CORRIDOR_SEMANTIC_BUTTON_ORDER = ( + "MOVE_FORWARD", + "MOVE_BACKWARD", + "MOVE_LEFT", + "MOVE_RIGHT", + "TURN_LEFT", + "TURN_RIGHT", + "ATTACK", +) + + +def _deadly_runtime_button_names(gym_env: Any) -> list[str]: + """Return the live ViZDoom action-button order (ports eval_core helper). + + The MultiBinary action vector is indexed by the game's available-button + order, which is not guaranteed to equal the semantic order the head emits. + """ + + def _button_name(button: Any) -> str: + name = getattr(button, "name", None) + if name is not None: + return str(name) + text = str(button) + return text.split(".")[-1] if "." in text else text + + for candidate in (gym_env, getattr(gym_env, "unwrapped", None)): + if candidate is None: + continue + for attr_name in ("game", "_game"): + game = getattr(candidate, attr_name, None) + if game is None: + continue + getter = getattr(game, "get_available_buttons", None) + if getter is None: + continue + names = [_button_name(button) for button in getter()] + if names: + return names + return list(DEADLY_CORRIDOR_SEMANTIC_BUTTON_ORDER) + + +def _semantic_to_runtime_multibinary(semantic_values: list[int], runtime_order: list[str]) -> list[int]: + semantic_map = { + name: int(semantic_values[idx]) + for idx, name in enumerate(DEADLY_CORRIDOR_SEMANTIC_BUTTON_ORDER) + if idx < len(semantic_values) + } + return [semantic_map.get(name, 0) for name in runtime_order] + + +class DeadlyCorridorVlaEnvAdapter(EnvAdapter): + """Deadly Corridor adapter for StarVLA eval, matching eval_core's env. + + Unlike :class:`DeadlyCorridorEnvAdapter` (sample_factory, factorised action + tuple), this uses the gymnasium ``VizdoomDeadlyCorridor-MultiBinary`` env so + the model's multibinary head can fire arbitrary button subsets, exactly like + ``starVLA.training.rl_games.eval_core``. Native ``frame_skip=1`` is used so + latency_bench's observation-cadence scheduler owns the obs_stride stepping + (see ObservationCadenceDecisionScheduler); setting a native skip would + double-count it. + """ + + OBSERVATION_TYPE = "vizdoom_frame_v1" + + def __init__( + self, + *, + config: dict[str, Any], + noop_action: Action | None = None, + export_env_raw_rgb_frames: bool = True, + ): + import gymnasium as gym + import vizdoom + import vizdoom.gymnasium_wrapper # noqa: F401 (registers the env ids) + + env_cfg = config["env"] + self.env_fps = float(env_cfg.get("env_fps", 35)) + self.frame_stack = int(env_cfg.get("frame_stack", 1) or 1) + # The raw teacher view is part of the policy's observation contract. + render_options = { + key: env_cfg[key] + for key in ( + "screen_resolution", "render_hud", "render_crosshair", + "render_weapon", "render_decals", "render_particles", + ) + if key in env_cfg + } + # ViZDoom registers deadly_corridor.cfg under this official Gym ID. + self.env_id = "VizdoomCorridor-v0" + self.gym_env = gym.make( + self.env_id, render_mode="rgb_array", frame_skip=1, max_buttons_pressed=0, + ) + game = self.gym_env.unwrapped.game + game.close() + for key, value in render_options.items(): + if key == "screen_resolution": + value = getattr(vizdoom.ScreenResolution, value) + getattr(game, f"set_{key}")(value) + game.init() + self.gym_env.unwrapped.observation_space.spaces["screen"] = Box( + 0, 255, + shape=(game.get_screen_height(), game.get_screen_width(), game.get_screen_channels()), + dtype=np.uint8, + ) + + self._runtime_button_order = _deadly_runtime_button_names(self.gym_env) + self._num_buttons = len(self._runtime_button_order) + self.gym_env.unwrapped.action_space = MultiBinary(self._num_buttons) + self.noop_action = noop_action or Action( + value=[0] * self._num_buttons, name="NOOP", is_noop=True + ) + self.export_env_raw_rgb_frames = bool(export_env_raw_rgb_frames) + self.env_step = 0 + self._last_info: dict[str, Any] = {} + self._last_frame: Any = None + self._raw_rgb_frames = RawRgbFrameStackBuffer(num_frames=self.frame_stack) + + def reset(self, seed: int | None = None) -> Observation: + self.env_step = 0 + try: + obs, info = self.gym_env.reset(seed=seed) + except TypeError: + obs, info = self.gym_env.reset() + self._last_frame = obs + self._last_info = dict(info or {}) + if self.export_env_raw_rgb_frames: + self._reset_raw_rgb_frame_stack() + return self._make_observation(info=self._last_info) + + def step(self, action: Action) -> StepResult: + # action.value is a 7-dim multibinary vector in semantic order; re-order + # to the live game's button layout before stepping the MultiBinary env. + semantic = [int(v) for v in np.asarray(action.value).reshape(-1).tolist()] + expected = len(DEADLY_CORRIDOR_SEMANTIC_BUTTON_ORDER) + if len(semantic) != expected: + raise ValueError( + "DeadlyCorridorVlaEnvAdapter expects a " + f"{expected}-dim multibinary action in semantic order, got " + f"{len(semantic)} values ({action.value!r}). This usually means the " + "policy decoded a non-multibinary layout; ensure the deadly head is " + "action_layout=multibinary_7 and reached the multibinary decode path." + ) + runtime_buttons = _semantic_to_runtime_multibinary(semantic, self._runtime_button_order) + gym_action = np.asarray(runtime_buttons, dtype=np.int8) + obs, reward, terminated, truncated, info = self.gym_env.step(gym_action) + self.env_step += 1 + self._last_frame = obs + self._last_info = dict(info or {}) + if self.export_env_raw_rgb_frames and not bool(terminated or truncated): + self._append_raw_rgb_frame() + observation = self._make_observation(info=self._last_info) + step_info = dict(self._last_info) + step_info.update( + { + "env_step": self.env_step, + "sim_time_ms": self.env_step * self.frame_ms, + "applied_action": runtime_buttons, + "applied_action_name": action.name, + "observation": self.OBSERVATION_TYPE, + } + ) + return StepResult( + observation=observation, + reward=float(reward), + done=bool(terminated), + truncated=bool(truncated), + info=step_info, + ) + + def observe(self) -> Observation: + return self._make_observation(info=self._last_info) + + def render_game_frame(self) -> np.ndarray: + frame = self.gym_env.render() + return np.asarray(frame, dtype=np.uint8) + + def close(self) -> None: + self.gym_env.close() diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/decision_action_history.py b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/decision_action_history.py new file mode 100644 index 0000000000000000000000000000000000000000..13f64ef81329e0b3c9296a066e17196a7e6c1d56 --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/decision_action_history.py @@ -0,0 +1,60 @@ +"""Causal action history sampled at completed decision boundaries.""" + +from __future__ import annotations + +import numpy as np +from gymnasium.spaces import Discrete, MultiBinary, Tuple + + +class DecisionActionHistory: + """Encode admission, admitted command, and last applied action for each decision.""" + + def __init__(self, action_space, *, num_envs: int, decisions: int): + self._multibinary = isinstance(action_space, MultiBinary) + if isinstance(action_space, Discrete): + self.action_sizes = (action_space.n,) + elif isinstance(action_space, Tuple) and all(isinstance(space, Discrete) for space in action_space.spaces): + self.action_sizes = tuple(space.n for space in action_space.spaces) + elif self._multibinary and action_space.shape == (7,): + self.action_sizes = (3, 3, 3, 2) + else: + raise NotImplementedError(f"Decision action history does not support {action_space!r}") + self.decisions = decisions + self.action_dim = sum(size - 1 for size in self.action_sizes) + self.step_dim = 1 + 2 * self.action_dim + self.data = np.zeros((num_envs, decisions, self.step_dim), dtype=np.float32) + self._basis = tuple(np.eye(size, dtype=np.float32)[:, 1:] for size in self.action_sizes) + + @property + def observation_dim(self) -> int: + return self.decisions * self.step_dim + + def reset(self, indices=None) -> None: + if indices is None: + self.data.fill(0) + else: + self.data[indices] = 0 + + def append(self, indices, admitted, issued_actions, applied_actions) -> None: + admitted = np.asarray(admitted, dtype=np.float32).reshape(-1) + issued = self._encode(issued_actions) * admitted[:, None] + applied = self._encode(applied_actions) + rows = self.data[indices].copy() + rows[:, :-1] = rows[:, 1:] + rows[:, -1, 0] = admitted + rows[:, -1, 1 : 1 + self.action_dim] = issued + rows[:, -1, 1 + self.action_dim :] = applied + self.data[indices] = rows + + def observation(self) -> np.ndarray: + return self.data.reshape(self.data.shape[0], self.observation_dim).copy() + + def _encode(self, actions) -> np.ndarray: + if self._multibinary: + # The VLA button order is move, strafe, turn, attack; teacher history + # encodes turn, move, strafe, attack. Keep both opposing bits if issued. + return np.asarray(actions, dtype=np.float32).reshape(-1, 7)[:, [4, 5, 0, 1, 2, 3, 6]] + values = np.asarray(actions, dtype=np.int64).reshape(-1, len(self.action_sizes)) + return np.concatenate( + [basis[values[:, index]] for index, basis in enumerate(self._basis)], axis=1 + ) diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/eval_driver.py b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/eval_driver.py new file mode 100644 index 0000000000000000000000000000000000000000..fca10fa388e20c9df4abb2f235ac4ea284a3144c --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/eval_driver.py @@ -0,0 +1,216 @@ +"""Single evaluation driver: run one config's episodes and attach metadata. + +This is the core ``run_from_config`` and its episode-side helpers. Sweep/suite +orchestration lives in :mod:`latency_bench.eval.sweeps`; the CLI in +:mod:`latency_bench.run`. +""" +from __future__ import annotations + +from collections.abc import Callable, Sequence +from pathlib import Path +from typing import Any + +import yaml + +from training.common.utils import seed_everything +from latency_bench.core.types import EpisodeMetrics, ExecutorMode +from latency_bench.eval.config import ( + _episode_seed, + _eval_episodes, + _eval_max_steps, + _evaluation_seed, + resolve_evaluation_config, +) +from latency_bench.eval.reporting import _write_non_sweep_summary +from latency_bench.envs.base import EnvAdapter +from latency_bench.executors.base import BatchedExecutor +from latency_bench.executors.factory import build_executor +from latency_bench.executors.realtime_warmup import plot_realtime_eval_latency +from latency_bench.latency.config import latency_type_from_config +from latency_bench.logging.action_trace_replay import record_videos_from_action_trace +from latency_bench.logging.video import select_episode_return_stratified + + +def run_from_config( + config: dict[str, Any], + extra_metadata: dict[str, Any] | None = None, + *, + write_summary: bool = True, + on_episode_complete: Callable[[EpisodeMetrics], None] | None = None, + episode_ids: Sequence[int] | None = None, + policy: Any | None = None, + env: EnvAdapter | None = None, + env_backend: Any | None = None, + inference_devices: list[str] | None = None, +) -> list[EpisodeMetrics]: + eval_max_steps = _eval_max_steps(config) + resolve_evaluation_config(config) + if ( + policy is None + and env is None + and env_backend is None + and config["policy"]["type"] == "starvla" + ): + from latency_bench.policy.starvla import prepare_starvla_checkpoint_input_config + + prepare_starvla_checkpoint_input_config(config) + + experiment_cfg = config["experiment"] + policy_cfg = config["policy"] + logging_cfg = config["logging"] + seed = _evaluation_seed(config) + configured_num_episodes = _eval_episodes(config) + selected_episode_ids = list(range(configured_num_episodes)) if episode_ids is None else list(episode_ids) + seed_everything(seed) + + executor_kwargs = {} + if policy is not None: + executor_kwargs["policy"] = policy + if env is not None: + executor_kwargs["env"] = env + if env_backend is not None: + executor_kwargs["env_backend"] = env_backend + if inference_devices is not None: + executor_kwargs["inference_devices"] = inference_devices + executor = build_executor(config, **executor_kwargs) + metrics = [] + warmup_metadata_by_episode: dict[int, dict[str, Any]] = {} + try: + output_dir = Path(logging_cfg["output_dir"]) + output_dir.mkdir(parents=True, exist_ok=True) + (output_dir / "resolved_config.yaml").write_text( + yaml.safe_dump(config, sort_keys=False), encoding="utf-8" + ) + if isinstance(executor, BatchedExecutor): + warmup_metadata = executor.run_warmup() + run_episodes_kwargs: dict[str, Any] = { + "episode_ids": selected_episode_ids, + "seeds": [_episode_seed(config, episode_id) for episode_id in selected_episode_ids], + "eval_max_steps": eval_max_steps, + } + if on_episode_complete is not None: + run_episodes_kwargs["on_episode_complete"] = on_episode_complete + metrics = list(executor.run_episodes(**run_episodes_kwargs)) + warmup_metadata_by_episode.update( + (episode_id, warmup_metadata) for episode_id in selected_episode_ids + ) + else: + warmup_metadata = executor.run_warmup() + for episode_id in selected_episode_ids: + warmup_metadata_by_episode[episode_id] = warmup_metadata + episode_metrics = executor.run_episode( + episode_id=episode_id, + seed=_episode_seed(config, episode_id), + eval_max_steps=eval_max_steps, + ) + metrics.append(episode_metrics) + if on_episode_complete is not None: + on_episode_complete(episode_metrics) + metrics.sort(key=lambda item: int(item.episode_id)) + for episode_metrics in metrics: + for key, value in _evaluation_raw_fact_metadata(config, int(episode_metrics.episode_id)).items(): + if episode_metrics.metadata.get(key) is None: + episode_metrics.metadata[key] = value + episode_metrics.metadata.update(warmup_metadata_by_episode[int(episode_metrics.episode_id)]) + if "measurement" in config: + episode_metrics.metadata["measurement"] = config["measurement"] + episode_metrics.metadata["config_name"] = experiment_cfg.get("name") + episode_metrics.metadata["run_name"] = experiment_cfg.get("name") + if "checkpoint_path" in policy_cfg: + episode_metrics.metadata["checkpoint_path"] = policy_cfg["checkpoint_path"] + if "profile_path" in config["latency"]: + episode_metrics.metadata["source_profile_path"] = config["latency"]["profile_path"] + if "checkpoint_kind" in policy_cfg: + episode_metrics.metadata["checkpoint_kind"] = str(policy_cfg["checkpoint_kind"]) + episode_metrics.metadata["output_dir"] = str(logging_cfg["output_dir"]) + if "action_prefix" in policy_cfg: + episode_metrics.metadata["action_prefix"] = policy_cfg["action_prefix"] + if extra_metadata: + episode_metrics.metadata.update(extra_metadata) + if executor.logger is not None: + executor.logger.flush() + _record_realtime_eval_latency_plot(config, executor) + if write_summary: + _write_non_sweep_summary(config, metrics) + _record_stratified_replay_videos(config, metrics, seed=seed) + finally: + executor.close() + return metrics + + +def _record_realtime_eval_latency_plot(config: dict[str, Any], executor: Any) -> None: + if ExecutorMode(config["executor"]["mode"]) != ExecutorMode.REALTIME: + return + if not config["logging"]["save_latency_records"]: + return + + latency_values = list(executor.logger.latency_ms_values) + plot_realtime_eval_latency( + latency_values, + Path(config["logging"]["output_dir"]) / "eval_latency_trace.png", + ) + + +def _record_stratified_replay_videos( + config: dict[str, Any], + metrics: list[EpisodeMetrics], + *, + seed: int, +) -> None: + if "video" not in config["logging"]: + return + video_cfg = config["logging"]["video"] + if not video_cfg["enabled"]: + return + if not config["logging"]["save_step_records"]: + # Replay reads steps.jsonl, which is only written when save_step_records is on. + # Without it (e.g. factor-sweep evals) skip video instead of crashing on a missing file. + return + if ExecutorMode(config["executor"]["mode"]) == ExecutorMode.REALTIME: + return + selections = select_episode_return_stratified( + metrics, + num_bins=video_cfg["num_bins"], + seed=seed, + ) + record_videos_from_action_trace(config, selections=selections, metrics=metrics) + + +def _evaluation_raw_fact_metadata(config: dict[str, Any], episode_id: int) -> dict[str, Any]: + env_cfg = config.get("env", {}) + policy_cfg = config.get("policy", {}) + latency_cfg = config.get("latency", {}) + executor_cfg = config.get("executor", {}) + env_fps = float(env_cfg["env_fps"]) if "env_fps" in env_cfg else None + obs_fps = float(env_cfg["obs_fps"]) if "obs_fps" in env_cfg else None + frame_ms = None if env_fps is None or env_fps <= 0 else 1000.0 / env_fps + executor_mode = str(executor_cfg.get("mode", "")).strip().lower() + latency_type = latency_type_from_config(latency_cfg) + if executor_mode == "paused": + latency_type = "zero" + elif executor_mode == "realtime": + latency_type = "measured" + return { + "mode": executor_cfg.get("mode"), + "episode_seed": _episode_seed(config, episode_id), + "policy_id": _metadata_id(policy_cfg, "policy_id", "id", "type"), + "env_id": _metadata_id(env_cfg, "env_id", "id", "name"), + "model_id": latency_cfg.get("model_id"), + "gpu_class": latency_cfg.get("gpu_class"), + "workload_id": latency_cfg.get("workload_id"), + "instance_id": latency_cfg.get("instance_id"), + "source_run_id": latency_cfg.get("source_run_id"), + "profile_ref": latency_cfg.get("profile_ref"), + "env_fps": env_fps, + "obs_fps": obs_fps, + "frame_ms": frame_ms, + "latency_type": latency_type, + } + + +def _metadata_id(config: dict[str, Any], *keys: str) -> str | None: + for key in keys: + value = config.get(key) + if value is not None: + return str(value) + return None diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/mikasa_evaluate.py b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/mikasa_evaluate.py new file mode 100644 index 0000000000000000000000000000000000000000..19206ec9dfd77ce730fbaee77fe932956dac0b4d --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/mikasa_evaluate.py @@ -0,0 +1,341 @@ +#!/usr/bin/env python3 +from __future__ import annotations + +import argparse +import json +import sys +from pathlib import Path +from typing import Any + +import gymnasium as gym +import numpy as np +import torch +import yaml + + +ROOT = Path(__file__).resolve().parents[2] +sys.path.insert(0, str(ROOT)) +sys.path.insert(0, str(ROOT / "third_party" / "MIKASA-Robo")) + +from latency_bench.core.types import Action, Observation # noqa: E402 +from latency_bench.executors.gpu_batched_env_step_backend import ( # noqa: E402 + GpuBatchedEnvStepBackendBase, + SlotStepOutcome, +) +from mikasa_robo_suite.seed_reset import ( # noqa: E402 + reset_seeded_slot as _reset_seeded_slot, + reset_seeded_slots as _reset_seeded_slots, +) + + +ENV_ID = "InterceptGrabFast-VLA-v0" +INSTRUCTION = "Intercept the rolling ball and grasp it to stop it." +START_SEED = 4242424242 +MIKASA_IMAGE_VIEWS_INFO_KEY = "mikasa_image_views" +MIKASA_STATE_INFO_KEY = "mikasa_proprio" + + +def _scalar(value: Any) -> Any: + if torch.is_tensor(value): + return value.detach().reshape(-1)[0].cpu().item() + return np.asarray(value).reshape(-1)[0].item() + + +def _make_raw_env( + obs_mode: str, + num_envs: int = 1, + simulator_device: str = "gpu", +): + import mikasa_robo_suite.vla.memory_envs # noqa: F401 + + return gym.make( + ENV_ID, + num_envs=num_envs, + obs_mode=obs_mode, + control_mode="pd_ee_delta_pose", + render_mode="all", + sim_backend=simulator_device, + render_backend=simulator_device, + reward_mode="normalized_dense", + ) + + +def _make_ppo_env(num_envs: int = 1, simulator_device: str = "gpu"): + from baselines.ppo.ppo_memtasks import FlattenRGBDObservationWrapper + from mani_skill.vector.wrappers.gymnasium import ManiSkillVectorEnv + from mikasa_robo_suite.vla.dataset_collectors.get_mikasa_robo_datasets import ( + env_info, + ) + + env = _make_raw_env( + "state", + num_envs=num_envs, + simulator_device=simulator_device, + ) + wrappers, _ = env_info(ENV_ID) + for wrapper, kwargs in wrappers: + env = wrapper(env, **kwargs) + env = FlattenRGBDObservationWrapper(env, rgb=False, depth=False, state=True) + return ManiSkillVectorEnv( + env, + num_envs, + ignore_terminations=True, + record_metrics=True, + ) + + +def _make_vla_env(num_envs: int = 1, simulator_device: str = "gpu"): + from mikasa_robo_suite.vla.utils.apply_wrappers import apply_mikasa_vla_wrappers + + return apply_mikasa_vla_wrappers( + _make_raw_env( + "rgb", + num_envs=num_envs, + simulator_device=simulator_device, + ), + include_overlays=False, + ) + + +class _PpoPolicy: + def __init__(self, env, checkpoint: Path): + from baselines.ppo.ppo_memtasks import AgentStateOnly + + self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + self.agent = AgentStateOnly(env).to(self.device) + self.agent.load_state_dict(torch.load(checkpoint, map_location=self.device)) + self.agent.eval() + + def forward(self, observation): + with torch.no_grad(): + return self.agent.get_action( + {key: value.to(self.device) for key, value in observation.items()}, + deterministic=True, + ) + + +class MikasaEnvStepBackend(GpuBatchedEnvStepBackendBase): + """Own the native MIKASA simulator and its 7D action contract.""" + + backend_name = "mikasa_gpu_batched" + + def __init__(self, *, config: dict[str, Any], num_slots: int, env=None): + noop_action = Action( + value=np.asarray(config["env"]["noop_action"], dtype=np.float32), + name="noop", + is_noop=True, + ) + super().__init__( + config=config, + noop_action=noop_action, + num_slots=num_slots, + action_space=gym.spaces.Box(-1.0, 1.0, shape=(7,), dtype=np.float32), + ) + self.env = ( + _make_vla_env( + num_envs=num_slots, + simulator_device=config["env"]["simulator_device"], + ) + if env is None + else env + ) + self._episode_seeds = [0] * num_slots + self._success = np.zeros(num_slots, dtype=np.bool_) + self._observation, _ = self.env.reset(seed=self._episode_seeds) + + def _reset_slot_observation(self, slot_id: int, *, seed: int | None) -> Observation: + if seed is not None: + self._episode_seeds[slot_id] = int(seed) + self._observation, _ = _reset_seeded_slot( + self.env, + slot_id=slot_id, + seed=self._episode_seeds[slot_id], + ) + self._env_steps[slot_id] = 0 + self._success[slot_id] = False + return self._observation_for_slot(slot_id) + + def _observe_slot_observations( + self, + slot_ids: list[int], + ) -> dict[int, Observation]: + return {slot_id: self._observation_for_slot(slot_id) for slot_id in slot_ids} + + def _step_cores( + self, + slot_ids: list[int], + *, + actions: np.ndarray, + active_mask: np.ndarray, + ) -> Any: + del slot_ids, active_mask + tensor_actions = torch.as_tensor( + actions, + dtype=torch.float32, + device=self.env.unwrapped.device, + ) + self._observation, reward, terminated, truncated, info = self.env.step( + tensor_actions + ) + return reward, terminated, truncated, info + + def _slot_step_outcome(self, state: Any, slot_id: int) -> SlotStepOutcome: + reward, terminated, truncated, info = state + success = bool(_slot_value(info["success"], slot_id)) + self._success[slot_id] |= success + return SlotStepOutcome( + reward=float(_slot_value(reward, slot_id)), + done=bool(_slot_value(terminated, slot_id)), + truncated=bool(_slot_value(truncated, slot_id)), + info={ + "success": success, + "task_metrics": {"success": float(self._success[slot_id])}, + }, + ) + + def _observation_for_slot(self, slot_id: int) -> Observation: + rgb = self._observation["rgb"] + if torch.is_tensor(rgb): + rgb = rgb.detach().cpu().numpy() + rgb = np.asarray(rgb) + views = np.stack( + [ + np.asarray(rgb[slot_id, :, :, :3], dtype=np.uint8), + np.asarray(rgb[slot_id, :, :, 3:6], dtype=np.uint8), + ] + ) + metadata = { + MIKASA_IMAGE_VIEWS_INFO_KEY: views, + MIKASA_STATE_INFO_KEY: self._observation["proprio"][slot_id].detach().cpu().numpy(), + "slot_id": slot_id, + } + if "action_prefix_state_key" in self.config["env"]: + metadata["action_prefix_state_key"] = self.config["env"]["action_prefix_state_key"] + if "returned_action_context" in self.config["env"]: + context = self.config["env"]["returned_action_context"] + metadata["returned_action_context"] = { + **context, + "order": np.asarray(context["order"]), + "low": np.asarray(context["low"], dtype=np.float32), + "high": np.asarray(context["high"], dtype=np.float32), + } + return Observation( + data=None, + env_step=int(self._env_steps[slot_id]), + sim_time_ms=float(self._env_steps[slot_id]) * self._frame_ms, + metadata=metadata, + ) + + def close(self) -> None: + if not self.closed: + self.env.close() + super().close() + + +def _slot_value(value: Any, slot_id: int) -> Any: + if torch.is_tensor(value): + return value.detach().reshape(-1)[slot_id].cpu().item() + return np.asarray(value).reshape(-1)[slot_id].item() + + +def _evaluate(args: argparse.Namespace) -> dict[str, Any]: + env = _make_ppo_env() + policy = _PpoPolicy(env, args.checkpoint) + seeds = [] + successes = [] + returns = [] + lengths = [] + try: + for episode_index in range(args.episodes): + seed = START_SEED + episode_index + observation, _ = env.reset(seed=seed) + success_once = False + episode_return = 0.0 + for step in range(60): + action = policy.forward(observation) + observation, reward, terminated, truncated, info = env.step(action) + success_once = success_once or bool(_scalar(info["success"])) + episode_return += float(_scalar(reward)) + if bool(_scalar(terminated)) or bool(_scalar(truncated)): + break + seeds.append(seed) + successes.append(success_once) + returns.append(episode_return) + lengths.append(step + 1) + finally: + env.close() + summary = { + "seeds": seeds, + "successes": successes, + "success_rate": float(np.mean(successes)), + "returns": returns, + "lengths": lengths, + } + (args.output_dir / "summary.json").write_text( + json.dumps(summary, indent=2) + "\n", encoding="utf-8" + ) + return summary + + +def _latency_eval(argv: list[str]) -> None: + from latency_bench.core.config import load_config + from latency_bench.eval.config import apply_runtime_overrides + from latency_bench.eval.driver import run_from_config + + parser = argparse.ArgumentParser() + parser.add_argument("--eval-config", type=Path, required=True) + parser.add_argument("--checkpoint-path", type=Path) + parser.add_argument("--model-config-path", type=Path) + parser.add_argument("--task-contract-path", type=Path) + parser.add_argument("--run-name") + parser.add_argument("--output-dir", type=Path) + parser.add_argument("--latency-method", choices=("zero", "temporal")) + parser.add_argument("--profile-path", type=Path) + parser.add_argument("--latency-seed", type=int) + args = parser.parse_args(argv) + config = load_config(args.eval_config) + apply_runtime_overrides( + config, + checkpoint_path=args.checkpoint_path, + model_config_path=args.model_config_path, + task_contract_path=args.task_contract_path, + run_name=args.run_name, + output_dir=args.output_dir, + latency_method=args.latency_method, + latency_profile_path=args.profile_path, + latency_seed=args.latency_seed, + ) + output_dir = Path(config["logging"]["output_dir"]) + output_dir.mkdir(parents=True, exist_ok=True) + (output_dir / "eval_config.yaml").write_text( + yaml.safe_dump(config, sort_keys=False), encoding="utf-8" + ) + backend = MikasaEnvStepBackend( + config=config, + num_slots=int(config["evaluation"]["eval_parallel_envs"]), + ) + run_from_config( + config, + env_backend=backend, + inference_devices=config["executor"]["inference_devices"], + ) + + +def main() -> None: + if sys.argv[1:2] == ["latency-eval"]: + _latency_eval(sys.argv[2:]) + return + + parser = argparse.ArgumentParser() + parser.add_argument("--policy", choices=("ppo",), required=True) + parser.add_argument("--checkpoint", type=Path) + parser.add_argument("--episodes", type=int, default=50) + parser.add_argument("--output-dir", type=Path, required=True) + args = parser.parse_args() + args.output_dir.mkdir(parents=True, exist_ok=True) + + _evaluate(args) + + +if __name__ == "__main__": + main() diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/starvla.py b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/starvla.py new file mode 100644 index 0000000000000000000000000000000000000000..7b9cab3b3fad77d6f6a3b7919ff4a8124c98d011 --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/starvla.py @@ -0,0 +1,1207 @@ +from __future__ import annotations + +import json +import sys +from collections.abc import Mapping, Sequence +from pathlib import Path +from typing import Any + +import numpy as np +import numpy.typing as npt +from PIL import Image + +from latency_bench.core.actions import ActionResolver +from latency_bench.core.clock import EnvClock +from latency_bench.core.timing import current_profiler +from latency_bench.core.types import Action, Observation, PolicyOutput +from latency_bench.data.ghost_trail import GhostTrailConfig, build_flappy_ghost_trail_window +from latency_bench.data.state_normalization import min_max_normalize_state +from latency_bench.envs.raw_rgb import ENV_RAW_RGB_FRAME_STACK_INFO_KEY +from latency_bench.envs.gymnasium_task import ( + gymnasium_action_space_contract, + gymnasium_task_contract, +) +from latency_bench.policy.base import PolicyRunner +from latency_bench.policy.starvla_prompts import load_latency_prompt_map, resolve_starvla_prompt + +from latency_bench.utils.paths import REPO_ROOT + + +STARVLA_ROOT = REPO_ROOT / "third_party" / "starVLA" +STATEFUL_STARVLA_MODEL_IDS: tuple[str, ...] = ( + "pi0", + "pi-0", + "pi05", + "pi-0.5", + "gr00t", + "qwenpi", + "qwenpi_v3", + "qwengr00t", +) +STATELESS_STARVLA_MODEL_IDS: tuple[str, ...] = ( + "openvla", + "qwenoft", +) + +DEMON_ATTACK_ACTION_LABELS: tuple[str, ...] = ( + "NOOP", + "FIRE", + "RIGHT", + "LEFT", + "RIGHTFIRE", + "LEFTFIRE", +) +DEADLY_CORRIDOR_TURN_LABELS: tuple[str, ...] = ( + "TURN_NOOP", + "TURN_LEFT", + "TURN_RIGHT", +) +DEADLY_CORRIDOR_MOVE_LABELS: tuple[str, ...] = ( + "MOVE_NOOP", + "MOVE_FORWARD", + "MOVE_BACKWARD", +) +DEADLY_CORRIDOR_STRAFE_LABELS: tuple[str, ...] = ( + "STRAFE_NOOP", + "MOVE_LEFT", + "MOVE_RIGHT", +) +DEADLY_CORRIDOR_ATTACK_LABELS: tuple[str, ...] = ( + "ATTACK_NOOP", + "ATTACK", +) + + +class StarVlaPolicyRunner(PolicyRunner): + """Translate observations and model outputs using the task action contract.""" + + def __init__( + self, + *, + wrapper: Any, + checkpoint_path: str, + device: str, + unnorm_key: str | None, + env_name: str, + action_resolver: ActionResolver, + action_refs: Sequence[Any], + latency_prompt_map: dict[str, Any] | None = None, + base_prompt: str | None = None, + latency_prompt_key: int | str | None = None, + prompt_mode: str | None = None, + obs_resize: tuple[int, int] | None = None, + image_transform_config: Mapping[str, Any] | None = None, + observation_stride_raw_frames: int, + model_cfg: Mapping[str, Any] | None = None, + state_normalization: Mapping[str, Any] | None = None, + state_source: str | None = None, + image_views_info_key: str | None = None, + action_output_type: str | None = None, + ) -> None: + self._wrapper = wrapper + self._obs_resize = tuple(obs_resize) if obs_resize else None + self._checkpoint_path = checkpoint_path + self._device = device + self._unnorm_key = unnorm_key + self._env_name = env_name + self._action_by_raw_id = { + raw_action_id: action_resolver.resolve(action_ref) + for raw_action_id, action_ref in enumerate(action_refs) + } + self._latency_prompt_map = latency_prompt_map + self._base_prompt = base_prompt + self._latency_prompt_key = latency_prompt_key + self._prompt_mode = str(prompt_mode or "default").strip().lower() + self._image_transform_config = dict(image_transform_config or {"image_transform": "raw_rgb"}) + self._image_transform = str( + self._image_transform_config.get("image_transform", "raw_rgb") or "raw_rgb" + ).strip().lower() + model_cfg = ( + _normalized_model_cfg_from_wrapper(wrapper) + if model_cfg is None + else _normalized_model_cfg(model_cfg) + ) + self._include_state = _include_state_from_model_cfg(model_cfg) + self._state_dim = _state_dim_from_model_cfg(model_cfg) if self._include_state else None + self._state_normalization = dict(state_normalization or {}) + self._state_source = state_source + self._image_views_info_key = image_views_info_key + self._action_output_type = action_output_type + vla_data = (model_cfg.get("datasets", {}) or {}).get("vla_data", {}) or {} + self._pack_image_sequence = ( + bool(vla_data["pack_image_sequence"]) + if "pack_image_sequence" in vla_data + else False + ) + self._image_sequence_length = ( + int(vla_data["image_sequence_length"]) + if self._pack_image_sequence + else 1 + ) + self._observation_stride_raw_frames = int(observation_stride_raw_frames) + self._image_sequence_raw_span = ( + 1 + + (self._image_sequence_length - 1) + * self._observation_stride_raw_frames + ) + self._num_obs_frames = int(vla_data.get("num_obs_frames", 1) or 1) + self._image_mode = str(vla_data.get("image_mode", "single")) + self._stitch_grid = tuple(vla_data.get("stitch_grid", [2, 2])) + framework_cfg = model_cfg["framework"] + kv_cfg = framework_cfg["kv_memory"] if "kv_memory" in framework_cfg else {} + self._kv_memory_enabled = bool(kv_cfg["enabled"]) if "enabled" in kv_cfg else False + + def reset_state(self, slot_id: int | None = None) -> None: + # Clears the model's per-slot KV memory at episode boundaries (req3). + # No-op unless the framework maintains KV memory. + reset = getattr(self._wrapper, "reset_memory", None) + if callable(reset): + reset(slot_id) + + def predict(self, observation: Observation) -> PolicyOutput: + return self.predict_batch([observation])[0] + + def predict_batch(self, observations: Sequence[Observation]) -> list[PolicyOutput]: + profiler = current_profiler() + with profiler.time("policy_build_example_ms"): + examples = [self._build_example(observation) for observation in observations] + with profiler.time("policy_wrapper_predict_action_ms"): + prediction = self._wrapper.predict_action( + examples=examples, unnorm_key=self._unnorm_key, profiler=profiler + ) + with profiler.time("policy_decode_ms"): + outputs = [ + self._decode_prediction( + prediction=prediction, + index=index, + observation=observation, + example=example, + ) + for index, (observation, example) in enumerate(zip(observations, examples)) + ] + return outputs + + def _decode_prediction( + self, + *, + prediction: dict[str, Any], + index: int, + observation: Observation, + example: dict[str, Any], + ) -> PolicyOutput: + actions = np.asarray(prediction["actions"]) + raw_action_scores = ( + np.asarray(prediction["raw_action_scores"]) + if "raw_action_scores" in prediction + else None + ) + return self._policy_output( + observation=observation, + example=example, + action_payload=actions[index, 0], + action_output_type=( + prediction["action_output_type"] + if self._action_output_type is None + else self._action_output_type + ), + raw_action_scores=None if raw_action_scores is None else raw_action_scores[index, 0], + ) + + def _build_example(self, observation: Observation) -> dict[str, Any]: + frame_source = observation.metadata[ + ENV_RAW_RGB_FRAME_STACK_INFO_KEY + if self._image_views_info_key is None + else self._image_views_info_key + ] + frames = observation_data_to_hwc_uint8_frames(frame_source) # oldest .. newest + transformed = self._transformed_frame(frames=frames, observation=observation) + + if self._image_views_info_key is not None: + pass + elif self._pack_image_sequence: + if transformed is not None: + raise ValueError( + "WanOFT packed image sequences require image_transform=raw_rgb" + ) + if len(frames) < self._image_sequence_raw_span: + raise ValueError( + "WanOFT packed image sequence requires " + f"{self._image_sequence_raw_span} raw frames for " + f"{self._image_sequence_length} decision observations at stride " + f"{self._observation_stride_raw_frames}, got {len(frames)}" + ) + frames = frames[ + -self._image_sequence_raw_span + :: self._observation_stride_raw_frames + ] + elif transformed is not None: + frames = [transformed] + elif self._image_mode == "single" or self._kv_memory_enabled: + frames = frames[-1:] + else: + # Select the temporal observation window to match training (_pack_sample). + raw_span = 1 + (self._num_obs_frames - 1) * self._observation_stride_raw_frames + frames = frames[-raw_span :: self._observation_stride_raw_frames] + + prompt = resolve_starvla_prompt( + env_name=self._env_name, + observation_metadata=observation.metadata, + latency_prompt_map=self._latency_prompt_map, + base_prompt=self._base_prompt, + latency_prompt_key=self._latency_prompt_key, + prompt_mode=self._prompt_mode, + ) + + if self._image_mode == "stitch": + if transformed is not None: + raise ValueError("image_transform is not compatible with image_mode=stitch") + # Tile the window into one image; matches _pack_sample's stitch branch + # (raw frames passed to stitch_frames, which resizes each cell to 224). + images = [_get_stitch_frames()(frames, grid=self._stitch_grid, size=(224, 224))] + else: + if self._obs_resize is not None: + height, width = self._obs_resize + # match training preprocessing exactly: gr00t LeRobotSingleDataset._pack_sample + # does `Image.fromarray(image).resize((224, 224))` (PIL default resample = BICUBIC). + frames = [ + np.asarray(Image.fromarray(frame).resize((width, height)), dtype=np.uint8) + for frame in frames + ] + images = [Image.fromarray(frame) for frame in frames] + + example = { + "image": images, + "lang": prompt, + } + if self._kv_memory_enabled: + example["slot_id"] = observation.metadata["slot_id"] + elif "slot_id" in observation.metadata: + example["slot_id"] = observation.metadata["slot_id"] + if self._include_state: + if self._state_source == "transport": + state = np.asarray(observation.data["transport"], dtype=np.float32) + example["state"] = state.reshape(1, self._state_dim) + elif self._state_normalization: + state = np.asarray( + observation.metadata["gymnasium_state"], dtype=np.float32 + ) + state_min = np.asarray(self._state_normalization["min"], dtype=np.float32) + state_max = np.asarray(self._state_normalization["max"], dtype=np.float32) + state = min_max_normalize_state(state, state_min, state_max) + example["state"] = state.reshape(1, self._state_dim) + else: + example["state"] = np.zeros((1, self._state_dim), dtype=np.float32) + return example + + def _transformed_frame( + self, + *, + frames: Sequence[npt.NDArray[np.uint8]], + observation: Observation, + ) -> npt.NDArray[np.uint8] | None: + if self._image_transform in {"", "none", "raw", "raw_rgb"}: + return None + if self._image_transform not in {"flappy_ghost_trail", "demon_attack_ghost_trail"}: + raise ValueError(f"Unsupported StarVLA image_transform={self._image_transform!r}") + if self._image_transform == "flappy_ghost_trail" and self._env_name != "flappy": + raise ValueError("image_transform=flappy_ghost_trail is only supported for env_name=flappy") + if self._image_transform == "demon_attack_ghost_trail" and self._env_name != "demon_attack": + raise ValueError("image_transform=demon_attack_ghost_trail is only supported for env_name=demon_attack") + + config = GhostTrailConfig( + image_transform=self._image_transform, + history_frames=int(self._image_transform_config.get("history_frames", 5)), + gamma=float(self._image_transform_config.get("gamma", 1.3)), + min_alpha=int(self._image_transform_config.get("min_alpha", 35)), + ground_fraction=float(self._image_transform_config.get("ground_fraction", 0.22)), + scroll_px_per_step=float(self._image_transform_config.get("scroll_px_per_step", 4.0)), + ) + if self._image_transform == "demon_attack_ghost_trail": + # env_step counts raw ALE frames (buffer updated 4× per decision step). + # frames[-0:] == frames, so env_step=0 falls back to the full reset-fill buffer. + valid_count = min(len(frames), int(observation.env_step)) + else: + max_frames = max(1, int(config.history_frames) + 1) + valid_count = min(len(frames), max(1, int(observation.env_step) + 1), max_frames) + window = [np.asarray(frame, dtype=np.uint8) for frame in frames[-valid_count:]] + + if self._image_transform == "demon_attack_ghost_trail": + from latency_bench.data.ghost_trail_demon import build_demon_attack_ghost_trail_window + steps_arg = list(range(len(window))) + return build_demon_attack_ghost_trail_window(window, steps_arg, config=config) + + current_step = int(observation.env_step) + start_step = current_step - valid_count + 1 + steps = list(range(start_step, current_step + 1)) + return build_flappy_ghost_trail_window(window, steps, config=config) + + def _policy_output( + self, + *, + observation: Observation, + example: dict[str, Any], + action_payload: npt.NDArray[Any], + action_output_type: str, + raw_action_scores: npt.NDArray[Any] | None, + ) -> PolicyOutput: + payload = np.asarray(action_payload) + action, action_metadata = action_from_starvla_payload( + payload=payload, + env_name=self._env_name, + action_by_raw_id=self._action_by_raw_id, + action_output_type=action_output_type, + ) + metadata = { + "policy_type": "starvla", + "prompt_source": "latency_prompt_map" if self._latency_prompt_map is not None else "base", + "checkpoint_path": self._checkpoint_path, + "unnorm_key": self._unnorm_key, + "device": self._device, + "input_frame_count": len(example["image"]), + "image_transform": self._image_transform, + "action_output_type": action_output_type, + "action_payload": to_jsonable_action_payload(payload), + "kv_memory_enabled": self._kv_memory_enabled, + **action_metadata, + } + if self._pack_image_sequence: + metadata["image_sequence_length"] = self._image_sequence_length + metadata["input_frame_raw_stride"] = self._observation_stride_raw_frames + metadata["input_frame_raw_span"] = self._image_sequence_raw_span + if "slot_id" in example: + metadata["slot_id"] = example["slot_id"] + if raw_action_scores is not None: + metadata["raw_action_scores"] = [ + float(item) for item in np.asarray(raw_action_scores, dtype=np.float32).tolist() + ] + if "latency_raw_frames" in observation.metadata: + metadata["latency_raw_frames"] = observation.metadata["latency_raw_frames"] + if "latency_ms" in observation.metadata: + metadata["latency_ms"] = observation.metadata["latency_ms"] + if self._latency_prompt_key is not None: + metadata["latency_prompt_key"] = self._latency_prompt_key + return PolicyOutput( + action=action, + raw_output=metadata["action_payload"], + metadata=metadata, + ) + + +def observation_data_to_hwc_uint8_frames(data: Any) -> list[npt.NDArray[np.uint8]]: + frame = _extract_observation_array(data) + if frame.ndim == 4 and frame.shape[-1] == 3: + return [_as_uint8_image(item) for item in frame] + if frame.ndim == 4 and frame.shape[1] == 3: + return [_as_uint8_image(np.transpose(item, (1, 2, 0))) for item in frame] + if frame.ndim == 3 and frame.shape[-1] == 3: + return [_as_uint8_image(frame)] + if frame.ndim == 3 and frame.shape[0] == 3: + return [_as_uint8_image(np.transpose(frame, (1, 2, 0)))] + if ( + frame.ndim == 3 + and frame.shape[0] % 3 == 0 + and frame.shape[0] < frame.shape[1] + and frame.shape[0] < frame.shape[2] + ): + return [ + _as_uint8_image(np.transpose(frame[start : start + 3, :, :], (1, 2, 0))) + for start in range(0, frame.shape[0], 3) + ] + if frame.ndim == 3 and frame.shape[-1] % 3 == 0: + return [ + _as_uint8_image(frame[:, :, start : start + 3]) + for start in range(0, frame.shape[-1], 3) + ] + if frame.ndim == 3 and frame.shape[0] % 3 == 0: + return [ + _as_uint8_image(np.transpose(frame[start : start + 3, :, :], (1, 2, 0))) + for start in range(0, frame.shape[0], 3) + ] + return [_as_uint8_image(frame)] + + +def decode_starvla_action( + *, + vector: npt.NDArray[Any], + env_name: str, + action_by_raw_id: Mapping[int, Action], + action_layout: str | None = None, +) -> tuple[Action, dict[str, Any]]: + deadly_layout = None + if str(env_name) == "deadly_corridor": + action_dim = int(np.asarray(vector).shape[-1]) + deadly_layouts = { + 7: "deadly_corridor_semantic_7", + 11: "deadly_corridor_factorized_11", + 54: "deadly_corridor_joint_54", + } + if action_dim not in deadly_layouts: + raise ValueError( + "Deadly Corridor StarVLA action vector expected 7, 11, or 54 " + f"values, got {action_dim}" + ) + deadly_layout = deadly_layouts[action_dim] + asterix_layout = None + if str(env_name) == "asterix": + action_dim = int(np.asarray(vector).shape[-1]) + if action_layout is not None: + asterix_layout = str(action_layout).strip().lower() + else: + asterix_layout = "factorized_6" if action_dim < 9 else "discrete_9" + + decode_rl_games_actions, _, _ = _load_rl_games_action_decode() + prediction = decode_rl_games_actions( + normalized_actions=np.asarray(vector), + env_name=str(env_name), + deadly_action_layout=(deadly_layout.removeprefix("deadly_corridor_") if deadly_layout is not None else None), + asterix_action_layout=asterix_layout, + ) + action, metadata = action_from_starvla_payload( + payload=np.asarray(prediction["actions"]), + env_name=env_name, + action_by_raw_id=action_by_raw_id, + action_output_type=prediction["action_output_type"], + ) + if deadly_layout is not None: + metadata["action_layout"] = deadly_layout + if deadly_layout == "deadly_corridor_joint_54": + turn, move, strafe, attack = action.value + metadata["raw_action_id"] = turn * 18 + move * 6 + strafe * 2 + attack + elif deadly_layout == "deadly_corridor_semantic_7": + semantic_actions = ( + [0, 1, 0, 0], + [0, 2, 0, 0], + [0, 0, 1, 0], + [0, 0, 2, 0], + [1, 0, 0, 0], + [2, 0, 0, 0], + [0, 0, 0, 1], + ) + metadata["raw_action_id"] = semantic_actions.index(action.value) + if asterix_layout is not None: + metadata["action_layout"] = asterix_layout + return action, metadata + + +# Fixed semantic button order the StarVLA multibinary head is trained against. +# Mirrors starVLA.training.rl_games.eval_core._semantic_to_runtime_multibinary; +# the env adapter re-orders this to the live ViZDoom button layout. +DEADLY_CORRIDOR_SEMANTIC_BUTTON_ORDER = ( + "MOVE_FORWARD", + "MOVE_BACKWARD", + "MOVE_LEFT", + "MOVE_RIGHT", + "TURN_LEFT", + "TURN_RIGHT", + "ATTACK", +) + + +def action_from_starvla_payload( + *, + payload: npt.NDArray[Any], + env_name: str, + action_by_raw_id: Mapping[int, Action], + action_output_type: str = "", +) -> tuple[Action, dict[str, Any]]: + if str(action_output_type) == "rl_games_continuous": + values = [float(item) for item in np.asarray(payload).reshape(-1).tolist()] + return Action( + value=values, + name="continuous_torque", + is_noop=all(value == 0.0 for value in values), + is_oneshot=False, + ), {"continuous_action": values} + if str(env_name) == "demon_attack": + return demon_attack_action_from_id(int(np.asarray(payload).reshape(-1)[0])) + if str(env_name) == "deadly_corridor": + # Multibinary heads emit an already-thresholded 7-dim button vector in + # fixed semantic order; the env adapter re-orders it to the live ViZDoom + # button layout. Keep it as-is rather than reinterpreting it as a + # [turn, move, strafe, attack] categorical tuple. + if str(action_output_type) == "rl_games_deadly_corridor_multibinary": + buttons = [int(item) for item in np.asarray(payload).reshape(-1).tolist()] + active = [ + DEADLY_CORRIDOR_SEMANTIC_BUTTON_ORDER[idx] + for idx, pressed in enumerate(buttons) + if idx < len(DEADLY_CORRIDOR_SEMANTIC_BUTTON_ORDER) and pressed + ] + action_name = "+".join(active) if active else "NOOP" + return Action( + value=buttons, + name=action_name, + is_noop=not any(buttons), + is_oneshot=False, + ), { + "decoded_multibinary_buttons": buttons, + "action_label": action_name, + "action_layout": "deadly_corridor_multibinary_7", + } + return deadly_corridor_action_from_tuple( + action_value=[int(item) for item in np.asarray(payload).reshape(-1).tolist()], + metadata={"action_layout": "deadly_corridor_tuple"}, + ) + raw_action_id = int(np.asarray(payload).reshape(-1)[0]) + return action_by_raw_id[raw_action_id], {"raw_action_id": raw_action_id} + + +def to_jsonable_action_payload(payload: npt.NDArray[Any]) -> Any: + value = np.asarray(payload).tolist() + if isinstance(value, list) and len(value) == 1: + return value[0] + return value + + +def demon_attack_action_from_id(action_id: int) -> tuple[Action, dict[str, Any]]: + action = Action( + value=action_id, + name=DEMON_ATTACK_ACTION_LABELS[action_id], + is_noop=action_id == 0, + is_oneshot=False, + ) + return action, {"raw_action_id": action_id, "action_label": action.name} + + +def deadly_corridor_action_from_tuple( + *, + action_value: list[int], + metadata: dict[str, Any], +) -> tuple[Action, dict[str, Any]]: + turn, move, strafe, attack = action_value + action_value = [turn, move, strafe, attack] + turn_label = DEADLY_CORRIDOR_TURN_LABELS[turn] + move_label = DEADLY_CORRIDOR_MOVE_LABELS[move] + strafe_label = DEADLY_CORRIDOR_STRAFE_LABELS[strafe] + attack_label = DEADLY_CORRIDOR_ATTACK_LABELS[attack] + active_labels = [ + label + for label in (turn_label, move_label, strafe_label, attack_label) + if not label.endswith("_NOOP") + ] + action_name = "+".join(active_labels) if active_labels else "NOOP" + return Action( + value=action_value, + name=action_name, + is_noop=action_value == [0, 0, 0, 0], + is_oneshot=False, + ), { + "decoded_action_tuple": action_value, + "turn_label": turn_label, + "move_label": move_label, + "strafe_label": strafe_label, + "attack_label": attack_label, + "action_label": action_name, + **metadata, + } + + +def _extract_observation_array(data: Any) -> npt.NDArray[Any]: + if isinstance(data, Mapping): + return np.asarray(data["observation"]) + return np.asarray(data) + + +def _as_uint8_image(frame: npt.NDArray[Any]) -> npt.NDArray[np.uint8]: + return np.ascontiguousarray(frame, dtype=np.uint8) + + +def _normalized_model_cfg(model_cfg: Mapping[str, Any]) -> dict[str, Any]: + _ensure_starvla_path() + from omegaconf import OmegaConf + from starVLA.model.framework.share_tools import apply_config_compat + + cfg = OmegaConf.create(model_cfg) + apply_config_compat(cfg) + _apply_model_family_include_state_compat(cfg) + return OmegaConf.to_container(cfg, resolve=True) + + +def _normalized_model_cfg_from_wrapper(wrapper: Any) -> dict[str, Any]: + return _normalized_model_cfg(wrapper._model_cfg) + + +def _load_starvla_model_config(path: str | Path) -> dict[str, Any]: + from omegaconf import OmegaConf + + return _normalized_model_cfg(OmegaConf.load(path)) + + +def _apply_model_family_include_state_compat(cfg: Any) -> None: + from omegaconf import OmegaConf + + if OmegaConf.select(cfg, "datasets.vla_data.include_state") is not None: + return + + model_ids = ( + _normalized_optional_config_string(cfg, ("model",)), + _normalized_optional_config_string(cfg, ("rl_games", "model_alias")), + _normalized_optional_config_string(cfg, ("framework", "name")), + ) + if any(model_id in STATEFUL_STARVLA_MODEL_IDS for model_id in model_ids if model_id is not None): + OmegaConf.update(cfg, "datasets.vla_data.include_state", True, force_add=True) + return + if any(model_id in STATELESS_STARVLA_MODEL_IDS for model_id in model_ids if model_id is not None): + OmegaConf.update(cfg, "datasets.vla_data.include_state", False, force_add=True) + + +def _normalized_optional_config_string(cfg: Any, path: tuple[str, ...]) -> str | None: + from omegaconf import OmegaConf + + value = OmegaConf.select(cfg, ".".join(path)) + if value is None: + return None + return str(value).strip().lower() + + +def _state_dim_from_model_cfg(model_cfg: dict[str, Any]) -> int: + return model_cfg["framework"]["action_model"]["state_dim"] + + +def _include_state_from_model_cfg(model_cfg: dict[str, Any]) -> bool: + return model_cfg["datasets"]["vla_data"]["include_state"] + + +_STITCH_FRAMES = None + + +def _get_stitch_frames(): + """Lazily import starVLA's stitch_frames (starVLA path is added at runtime).""" + global _STITCH_FRAMES + if _STITCH_FRAMES is None: + _ensure_starvla_path() + from starVLA.training.trainer_utils.trainer_tools import stitch_frames + + _STITCH_FRAMES = stitch_frames + return _STITCH_FRAMES + + +def _ensure_starvla_path() -> None: + starvla_root = str(STARVLA_ROOT) + if starvla_root not in sys.path: + sys.path.insert(0, starvla_root) + + +def _observation_stride_raw_frames(config: Mapping[str, Any]) -> int: + env_cfg = config["env"] + return EnvClock( + env_fps=float(env_cfg["env_fps"]), + obs_fps=float(env_cfg["obs_fps"]), + ).obs_stride_raw_frames + + +def apply_starvla_model_input_config( + config: dict[str, Any], + *, + model_cfg: Mapping[str, Any], + image_transform: str = "raw_rgb", +) -> None: + """Match latency_bench's raw frame stack to a saved StarVLA input contract.""" + vla_data = model_cfg["datasets"]["vla_data"] + pack_image_sequence = ( + bool(vla_data["pack_image_sequence"]) + if "pack_image_sequence" in vla_data + else False + ) + normalized_transform = str(image_transform).strip().lower() + raw_image_transform = normalized_transform in {"", "none", "raw", "raw_rgb"} + if pack_image_sequence: + if not raw_image_transform: + raise ValueError( + "WanOFT packed image sequences require image_transform=raw_rgb" + ) + input_frame_count = int(vla_data["image_sequence_length"]) + else: + if not raw_image_transform: + return + framework_cfg = model_cfg["framework"] + kv_cfg = framework_cfg["kv_memory"] if "kv_memory" in framework_cfg else {} + kv_memory_enabled = bool(kv_cfg["enabled"]) if "enabled" in kv_cfg else False + if kv_memory_enabled: + return + image_mode = str(vla_data["image_mode"]) if "image_mode" in vla_data else "single" + if image_mode == "single": + return + input_frame_count = int(vla_data["num_obs_frames"]) + + observation_stride = _observation_stride_raw_frames(config) + required_raw_frames = 1 + (input_frame_count - 1) * observation_stride + config["env"]["frame_stack"] = max( + int(config["env"]["frame_stack"]), + required_raw_frames, + ) + + +def prepare_starvla_checkpoint_input_config(config: dict[str, Any]) -> None: + """Apply the saved checkpoint input contract before env construction.""" + if config["policy"]["type"] != "starvla": + return + + policy_cfg = config["policy"] + if "task_contract_path" in policy_cfg: + if config["env"]["name"] == "gymnasium": + contract = json.loads( + Path(policy_cfg["task_contract_path"]).read_text(encoding="utf-8") + ) + config["env"]["state_space"] = {"labels": contract["state_labels"]} + if contract["robot_type"] in ("latency_balance_profile_h8", "latency_balance_profile_h16"): + config["env"]["name"] = "balance_profile" + config["env"]["action_context_horizon"] = contract["action_horizon"] + config["env"]["frame_stack"] = 1 + return + if "model_config_path" in policy_cfg: + model_cfg = _load_starvla_model_config(policy_cfg["model_config_path"]) + else: + _ensure_starvla_path() + from starVLA.model.framework.share_tools import read_mode_config + + saved_model_cfg, _norm_stats = read_mode_config(policy_cfg["checkpoint_path"]) + model_cfg = _normalized_model_cfg(saved_model_cfg) + if config["env"]["name"] == "gymnasium": + image_size = model_cfg["rl_games"]["env_eval"]["image_size"] + config["env"]["obs_resize"] = [image_size, image_size] + image_transform_cfg = ( + policy_cfg["image_transform_config"] + if "image_transform_config" in policy_cfg + else {} + ) + image_transform = ( + image_transform_cfg["image_transform"] + if "image_transform" in image_transform_cfg + else "raw_rgb" + ) + apply_starvla_model_input_config( + config, + model_cfg=model_cfg, + image_transform=image_transform, + ) + + +def _load_policy_wrapper_class() -> Any: + _ensure_starvla_path() + from deployment.model_server.policy_wrapper import PolicyServerWrapper + + return PolicyServerWrapper + + +def _profiler_stage(profiler: Any, name: str) -> Any: + from contextlib import nullcontext + + return profiler.time(name) if profiler is not None else nullcontext() + + +def _load_rl_games_action_decode() -> tuple[Any, Any, Any]: + _ensure_starvla_path() + from deployment.model_server.rl_games_action_decode import ( + decode_rl_games_actions, + resolve_asterix_action_decode_spec, + resolve_deadly_action_decode_spec, + ) + + return decode_rl_games_actions, resolve_deadly_action_decode_spec, resolve_asterix_action_decode_spec + + +class LiveStarVlaWrapper: + """In-process stand-in for ``PolicyServerWrapper`` over a *live* framework. + + During training the trainer already holds the model in memory + (``accelerator.unwrap_model(self.model)`` — the same object eval_core calls). + This wrapper exposes only the rl_games-mode surface ``StarVlaPolicyRunner`` + uses — ``predict_action`` (framework forward + rl_games decode), + ``reset_memory`` passthrough, and the ``_model_cfg`` attribute — so no + checkpoint reload is needed. The disk-backed ``PolicyNormProcessor`` is never + built because rl_games decoding ignores un-normalization stats. + """ + + def __init__( + self, + *, + framework: Any, + model_cfg: dict[str, Any], + env_name: str, + rl_games_action_env_dim: int | None = None, + gymnasium_action_space_type: str = "discrete", + action_layout: str | None = None, + multibinary_threshold: float | None = None, + ) -> None: + self._framework = framework + self._model_cfg = model_cfg + self._rl_games_env_name = str(env_name) + self._rl_games_action_env_dim = rl_games_action_env_dim + self._gymnasium_action_space_type = gymnasium_action_space_type + ( + self._decode_rl_games_actions, + resolve_deadly_action_decode_spec, + resolve_asterix_action_decode_spec, + ) = _load_rl_games_action_decode() + self._action_layout = action_layout + self._multibinary_threshold = multibinary_threshold + if self._rl_games_env_name == "deadly_corridor": + self._action_layout, self._multibinary_threshold = resolve_deadly_action_decode_spec( + model_cfg, + action_layout=action_layout, + multibinary_threshold=multibinary_threshold, + ) + elif self._rl_games_env_name == "asterix": + self._action_layout = resolve_asterix_action_decode_spec( + model_cfg, + action_layout=action_layout, + ) + + def reset_memory(self, slot_id: int | None = None) -> None: + reset = getattr(self._framework, "reset_memory", None) + if callable(reset): + reset(slot_id) + + def predict_action( + self, + examples: list[dict[str, Any]], + unnorm_key: str | None = None, + **kwargs: Any, + ) -> dict[str, Any]: + # unnorm_key is unused in rl_games mode; kept for interface parity. + del unnorm_key + profiler = kwargs["profiler"] if "profiler" in kwargs else None + out = self._framework.predict_action(examples=examples, **kwargs) + normalized = np.asarray(out["normalized_actions"]) # (B, T, D) + decode_kwargs: dict[str, Any] = {} + if self._rl_games_env_name == "gymnasium": + decode_kwargs["action_env_dim"] = self._rl_games_action_env_dim + if self._gymnasium_action_space_type == "box": + decode_kwargs["gymnasium_action_space_type"] = "box" + with _profiler_stage(profiler, "starvla_wrapper_rl_games_decode_ms"): + return self._decode_rl_games_actions( + normalized_actions=normalized, + env_name=self._rl_games_env_name, + deadly_action_layout=( + self._action_layout + if self._rl_games_env_name == "deadly_corridor" + else None + ), + deadly_multibinary_threshold=( + self._multibinary_threshold + if self._rl_games_env_name == "deadly_corridor" + else None + ), + asterix_action_layout=( + self._action_layout + if self._rl_games_env_name == "asterix" + else None + ), + **decode_kwargs, + ) + + +_LEGACY_GYMNASIUM_TASK_NAMES = { + "ant_rgb_state": "ant", + "half_cheetah_rgb_state": "half_cheetah", + "hopper_rgb_state": "hopper", + "humanoid_rgb_state": "humanoid", + "inverted_pendulum_rgb_state": "inverted_pendulum", + "swimmer_rgb_state": "swimmer", + "walker2d_rgb_state": "walker2d", +} + + +def _canonical_gymnasium_contract_namespace( + contract: Mapping[str, Any], +) -> dict[str, Any]: + canonical = dict(contract) + task_name = canonical["task_name"] + if task_name in _LEGACY_GYMNASIUM_TASK_NAMES: + canonical["task_name"] = _LEGACY_GYMNASIUM_TASK_NAMES[task_name] + if canonical["env_id"] == "LatencyBench/HopperRgbState-v0": + canonical["env_id"] = "LatencyBench/Hopper-v0" + canonical["registration_imports"] = [ + "latency_bench.envs.gymnasium_hopper" + if module == "latency_bench.envs.gymnasium_hopper_rgb_state" + else module + for module in canonical["registration_imports"] + ] + return canonical + + +def _validate_gymnasium_starvla_contract( + *, + env_cfg: Mapping[str, Any], + policy_cfg: Mapping[str, Any], + model_cfg: Mapping[str, Any], + manifest: Mapping[str, Any], +) -> None: + eval_contract = gymnasium_task_contract(env_cfg) + manifest_task = manifest.get("gymnasium_task") + expected = policy_cfg.get( + "gymnasium_training_task_contract", manifest_task or eval_contract + ) + comparable_eval_contract = {**eval_contract, "make_kwargs": expected["make_kwargs"]} + if _canonical_gymnasium_contract_namespace( + comparable_eval_contract + ) != _canonical_gymnasium_contract_namespace(expected): + raise ValueError( + "Evaluation Gymnasium task contract does not match the StarVLA training contract or dataset manifest" + ) + if manifest.get("integration_name", "gymnasium") != "gymnasium": + raise ValueError("StarVLA task manifest is not a Gymnasium handoff") + if manifest_task is not None: + if _canonical_gymnasium_contract_namespace( + manifest_task + ) != _canonical_gymnasium_contract_namespace(expected): + raise ValueError( + "Evaluation Gymnasium task contract does not match the StarVLA dataset manifest" + ) + model_contract = model_cfg["datasets"]["vla_data"].get("gymnasium_task_contract") + if model_contract is not None: + if _canonical_gymnasium_contract_namespace( + model_contract + ) != _canonical_gymnasium_contract_namespace(expected): + raise ValueError( + "Evaluation Gymnasium task contract does not match the StarVLA model config" + ) + action_space = gymnasium_action_space_contract(env_cfg) + action_layout = str(policy_cfg.get("action_layout", "") or "").strip().lower() + is_asterix_factorized = ( + str(env_cfg.get("task_name", "")) == "asterix" + and action_layout in {"factorized_6", "factorized6", "asterix_factorized_6", "asterix_factorized6"} + ) + if not is_asterix_factorized and manifest["active_action_dim"] != len(action_space["labels"]): + raise ValueError( + "StarVLA dataset active_action_dim does not match its Gymnasium action catalog" + ) + if ( + model_cfg["framework"]["action_model"]["action_env_dim"] + != manifest["active_action_dim"] + ): + raise ValueError( + "StarVLA model action_env_dim does not match the dataset manifest" + ) + model_uses_state = bool(model_cfg["datasets"]["vla_data"]["include_state"]) + manifest_has_state_metadata = ( + "uses_state" in manifest or "state_labels" in manifest + ) + manifest_uses_state = bool(manifest.get("uses_state", model_uses_state)) + if manifest_has_state_metadata: + if policy_cfg.get("state_source") != "transport" and manifest_uses_state != ("state_space" in expected): + raise ValueError( + "StarVLA dataset uses_state does not match the Gymnasium state space" + ) + if manifest_uses_state != model_uses_state: + raise ValueError( + "StarVLA dataset uses_state does not match the model include_state" + ) + if manifest_has_state_metadata and manifest_uses_state: + state_labels = manifest["state_labels"] + expected_state_labels = expected["state_space"]["labels"] if policy_cfg.get("state_source") != "transport" else state_labels + if state_labels != expected_state_labels: + raise ValueError( + "StarVLA dataset state_labels do not match the Gymnasium state space" + ) + if manifest["state_dim"] != len(state_labels): + raise ValueError( + "StarVLA dataset state_dim does not match its state_labels" + ) + if ( + model_cfg["framework"]["action_model"]["state_dim"] + != manifest["state_dim"] + ): + raise ValueError( + "StarVLA model state_dim does not match the dataset manifest" + ) + if not manifest["state_normalization"]: + raise ValueError( + "StarVLA state-enabled dataset manifest is missing state_normalization" + ) + + +def _starvla_runner_kwargs( + config: dict[str, Any], + action_resolver: ActionResolver, + model_cfg: Mapping[str, Any] | None, + *, + base_prompt: str | None, +) -> dict[str, Any]: + """Resolve task and input settings shared by checkpoint and resident models.""" + env_cfg = config["env"] + policy_cfg = config["policy"] + if env_cfg["name"] == "gymnasium": + task_manifest = json.loads( + Path(policy_cfg["task_manifest_path"]).read_text(encoding="utf-8") + ) + _validate_gymnasium_starvla_contract( + env_cfg=env_cfg, + policy_cfg=policy_cfg, + model_cfg=model_cfg, + manifest=task_manifest, + ) + semantic_env_name = env_cfg["task_name"] + action_refs = env_cfg.get("action_order", []) + base_prompt = env_cfg["base_prompt"] + state_normalization = task_manifest.get("state_normalization") + else: + semantic_env_name = env_cfg["name"] + action_refs = policy_cfg.get("actions", action_resolver.default_action_refs()) + state_normalization = policy_cfg["state_normalization"] if "state_normalization" in policy_cfg else None + return dict( + unnorm_key=policy_cfg.get("unnorm_key"), + env_name=semantic_env_name, + action_resolver=action_resolver, + action_refs=action_refs, + latency_prompt_map=( + load_latency_prompt_map(policy_cfg["latency_prompt_map_path"]) + if "latency_prompt_map_path" in policy_cfg + else None + ), + base_prompt=base_prompt, + latency_prompt_key=policy_cfg.get("latency_prompt_key"), + prompt_mode=policy_cfg.get("prompt_mode"), + obs_resize=tuple(env_cfg["obs_resize"]) if env_cfg.get("obs_resize") else None, + image_transform_config=policy_cfg.get("image_transform_config"), + observation_stride_raw_frames=_observation_stride_raw_frames(config), + model_cfg=model_cfg, + state_normalization=state_normalization, + state_source=policy_cfg["state_source"] if "state_source" in policy_cfg else None, + ) + + +def build_starvla_policy( + config: dict[str, Any], + action_resolver: ActionResolver, +) -> PolicyRunner: + policy_cfg = config["policy"] + if "task_contract_path" in policy_cfg: + _ensure_starvla_path() + from latency_bench.policy.starvla_tasks import build_task_starvla_policy + + return build_task_starvla_policy(config) + env_cfg = config["env"] + integration_env_name = env_cfg["name"] + model_cfg = ( + _load_starvla_model_config(policy_cfg["model_config_path"]) + if integration_env_name == "gymnasium" or "model_config_path" in policy_cfg + else None + ) + runner_kwargs = _starvla_runner_kwargs( + config, action_resolver, model_cfg, base_prompt=env_cfg.get("base_prompt") + ) + wrapper_cls = _load_policy_wrapper_class() + wrapper_kwargs: dict[str, Any] = dict( + ckpt_path=policy_cfg["checkpoint_path"], + device=policy_cfg["device"], + use_bf16=True, + unnorm_key=runner_kwargs["unnorm_key"], + action_output_mode=( + policy_cfg["action_output_mode"] + if "action_output_mode" in policy_cfg + else "rl_games" + ), + rl_games_env_name=integration_env_name, + rl_games_action_layout=( + policy_cfg["action_layout"] if "action_layout" in policy_cfg else None + ), + rl_games_multibinary_threshold=( + policy_cfg["multibinary_threshold"] + if "multibinary_threshold" in policy_cfg + else None + ), + ) + if "backbone_path" in policy_cfg: + wrapper_kwargs["backbone_path"] = policy_cfg["backbone_path"] + if integration_env_name == "gymnasium": + action_space = gymnasium_action_space_contract(env_cfg) + wrapper_kwargs["rl_games_action_env_dim"] = len(action_space["labels"]) + if action_space["type"] == "box": + wrapper_kwargs["rl_games_gymnasium_action_space_type"] = "box" + wrapper_kwargs["rl_games_env_name"] = integration_env_name + wrapper = wrapper_cls(**wrapper_kwargs) + return StarVlaPolicyRunner( + wrapper=wrapper, + checkpoint_path=policy_cfg["checkpoint_path"], + device=policy_cfg["device"], + **runner_kwargs, + image_views_info_key=( + policy_cfg["image_views_info_key"] + if "image_views_info_key" in policy_cfg + else None + ), + action_output_type=( + policy_cfg["action_output_type"] + if "action_output_type" in policy_cfg + else None + ), + ) + + +def build_live_starvla_policy( + *, + framework: Any, + model_cfg: dict[str, Any], + config: dict[str, Any], + action_resolver: ActionResolver | None = None, +) -> PolicyRunner: + """Build a StarVLA policy around a *live* in-memory framework (no reload). + + Mirrors ``build_starvla_policy`` but swaps the ckpt-loading + ``PolicyServerWrapper`` for :class:`LiveStarVlaWrapper`, so the trainer's + resident model is evaluated directly. ``model_cfg`` is the in-memory model + config (e.g. ``read_mode_config`` output) the wrapper would otherwise read + from disk. + """ + policy_cfg = config["policy"] + if "task_contract_path" in policy_cfg: + from latency_bench.policy.starvla_tasks import TaskStarVlaPolicyRunner + + contract = json.loads( + Path(policy_cfg["task_contract_path"]).read_text(encoding="utf-8") + ) + return TaskStarVlaPolicyRunner( + framework, + policy_config=policy_cfg, + model_config=model_cfg, + contract=contract, + ) + + env_cfg = config["env"] + integration_env_name = env_cfg["name"] + normalized_model_cfg = ( + _normalized_model_cfg(model_cfg) + if integration_env_name == "gymnasium" + else None + ) + # Resident evaluation historically takes non-Gymnasium prompts from the map. + runner_kwargs = _starvla_runner_kwargs( + config, action_resolver, normalized_model_cfg, base_prompt=None + ) + wrapper_kwargs: dict[str, Any] = dict( + framework=framework, + model_cfg=model_cfg, + env_name=integration_env_name, + action_layout=policy_cfg["action_layout"] if "action_layout" in policy_cfg else None, + multibinary_threshold=( + policy_cfg["multibinary_threshold"] + if "multibinary_threshold" in policy_cfg + else None + ), + ) + if integration_env_name == "gymnasium": + action_space = gymnasium_action_space_contract(env_cfg) + wrapper_kwargs["rl_games_action_env_dim"] = len(action_space["labels"]) + if action_space["type"] == "box": + wrapper_kwargs["gymnasium_action_space_type"] = "box" + wrapper_kwargs["env_name"] = integration_env_name + wrapper = LiveStarVlaWrapper(**wrapper_kwargs) + return StarVlaPolicyRunner( + wrapper=wrapper, + checkpoint_path=policy_cfg.get("checkpoint_path", ""), + device=policy_cfg.get("device", "cuda"), + **runner_kwargs, + ) + + +__all__ = [ + "LiveStarVlaWrapper", + "StarVlaPolicyRunner", + "apply_starvla_model_input_config", + "build_live_starvla_policy", + "build_starvla_policy", + "decode_starvla_action", + "observation_data_to_hwc_uint8_frames", + "prepare_starvla_checkpoint_input_config", +] diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/starvla_tasks.py b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/starvla_tasks.py new file mode 100644 index 0000000000000000000000000000000000000000..4a5cc03813f1bc524a30a7b6b7292a4f4fca85d4 --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-code/starvla_tasks.py @@ -0,0 +1,92 @@ +"""StarVLA inference using the task's training observation/action contract.""" + +from __future__ import annotations + +import json +from pathlib import Path + +import numpy as np +from PIL import Image + +from latency_bench.core.types import Action, Observation, PolicyOutput +from latency_bench.data.starvla_tasks import denormalize, normalize +from latency_bench.policy.base import PolicyRunner + + +class TaskStarVlaPolicyRunner(PolicyRunner): + """Map task RGB/state into a StarVLA model and decode its action chunk.""" + + def __init__(self, framework, *, policy_config: dict, model_config: dict, contract: dict): + self.framework = framework + self.policy_config = policy_config + self.model_config = model_config + self.contract = contract + + def _example(self, observation: Observation) -> dict: + cfg = self.policy_config + state = normalize( + observation.metadata[cfg["state_info_key"]], + self.contract["normalization"]["state"], + ).reshape(1, self.contract["state_dim"]) + data_cfg = self.model_config["datasets"]["vla_data"] + height, width = data_cfg["obs_image_size"] + images = [ + Image.fromarray(frame).resize((width, height)) + for frame in observation.metadata[cfg["image_views_info_key"]] + ] + if data_cfg["image_mode"] == "stitch_views": + from starVLA.training.trainer_utils.trainer_tools import stitch_frames + + # MIKASA's two simultaneous views form one Wan observation, not a video. + images = [stitch_frames(images, grid=data_cfg["stitch_grid"], size=(width, height))] + example = {"image": images, "state": state, "lang": self.contract["prompt"]} + if "action_prefix" in observation.metadata: + example["action_prefix"] = normalize( + observation.metadata["action_prefix"], + self.contract["normalization"]["action"], + ) + example["action_prefix_mask"] = observation.metadata["action_prefix_mask"] + return example + + def predict(self, observation: Observation) -> PolicyOutput: + return self.predict_batch([observation])[0] + + def predict_batch(self, observations: list[Observation]) -> list[PolicyOutput]: + prediction = self.framework.predict_action( + examples=[self._example(observation) for observation in observations] + ) + actions = denormalize( + prediction["normalized_actions"], self.contract["normalization"]["action"] + ) + # Prefix heads were excluded from the loss; retain the frozen controller plan. + for chunk, observation in zip(actions, observations): + if "action_prefix" in observation.metadata: + mask = observation.metadata["action_prefix_mask"] + chunk[mask] = observation.metadata["action_prefix"][mask] + return [ + PolicyOutput( + action=Action(value=chunk[0].tolist(), name="task_command"), + action_chunk=chunk, + raw_output=chunk.tolist(), + metadata={"policy_type": "starvla", "task": self.contract["task"]}, + ) + for chunk in actions + ] + + +def build_task_starvla_policy(config: dict) -> TaskStarVlaPolicyRunner: + # StarVLA and torch are optional in the simulator process; workers own them. + import torch + from starVLA.model.framework.base_framework import baseframework + from starVLA.model.framework.share_tools import read_mode_config + + cfg = config["policy"] + model_config, _ = read_mode_config(cfg["checkpoint_path"]) + framework = baseframework.from_pretrained( + cfg["checkpoint_path"], backbone_path=cfg["backbone_path"] + ) + framework = framework.to(device=cfg["device"], dtype=torch.bfloat16).eval() + contract = json.loads(Path(cfg["task_contract_path"]).read_text(encoding="utf-8")) + return TaskStarVlaPolicyRunner( + framework, policy_config=cfg, model_config=model_config, contract=contract + ) diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-plan.json b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-plan.json new file mode 100644 index 0000000000000000000000000000000000000000..371542eee194a26ff888c211317abe89050b38e0 --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/evaluation-plan.json @@ -0,0 +1,105 @@ +{ + "condition": "profile-latency", + "executor_mode": "simulated", + "latency_method": "temporal", + "profile_source": "originalRTX3090immutableprofiles", + "episodes_per_checkpoint": 100, + "total_episodes": 400, + "rounds": [ + [ + "flappy", + "deadly_corridor" + ], + [ + "ant", + "intercept" + ] + ], + "physical_gpu_assignments": { + "flappy": 2, + "deadly_corridor": 3, + "ant": 2, + "intercept": 3 + }, + "single_gpu_per_job": true, + "round2_requires_both_round1_complete": true, + "latency_seed": 271828, + "tasks": { + "flappy": { + "gpu": 2, + "seed_start": 1000000, + "seed_end": 1000099, + "env_fps": 10, + "obs_fps": 10, + "max_raw_steps": 3600, + "parallel_envs": 32, + "checkpoint_revision": "d4825bbad8d15bc50b6b8481eb2abc84846a54fb", + "checkpoint_path": "latency-aware/flappy/vla/starvla-qwenoft-h1/flappy-qwenoft-mean-3090-s42", + "profile": { + "mean_ms": 75.87417450998383, + "profile": "/home/ubuntu/lzj/profiles/published/profiles/openvla/1x-rtx3090/flappy/instance_a5037b165aa0cedc/profile.json", + "sha256": "c266cba7ebac05c7e37bc83f1f16fe4b27dab97942ff43290e6c41514f6e39fc" + }, + "config": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/flappy.yaml", + "output": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/flappy", + "metrics": "return mean/std/min/max;length mean/std;success where nativeprovided;latency/drops/invalid/action audits;100 episode vectors" + }, + "deadly_corridor": { + "gpu": 3, + "seed_start": 1000000, + "seed_end": 1000099, + "env_fps": 35, + "obs_fps": 8.75, + "max_raw_steps": 3600, + "parallel_envs": 32, + "checkpoint_revision": "d4825bbad8d15bc50b6b8481eb2abc84846a54fb", + "checkpoint_path": "latency-aware/deadly-corridor/vla/starvla-qwenoft-h1/deadly_corridor-qwenoft-mean-3090-s42", + "profile": { + "mean_ms": 73.69250777493353, + "profile": "/home/ubuntu/lzj/profiles/published/profiles/openvla/1x-rtx3090/deadly_corridor/instance_a5037b165aa0cedc/profile.json", + "sha256": "bbfb93cef9f63750a9a159ec10a93a9fc6c25e4cb0cac3b39532663b4dc11eba" + }, + "config": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/deadly_corridor.yaml", + "output": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/deadly_corridor", + "metrics": "return mean/std/min/max;length mean/std;success where nativeprovided;latency/drops/invalid/action audits;100 episode vectors" + }, + "ant": { + "gpu": 2, + "seed_start": 42, + "seed_end": 141, + "env_fps": 10, + "obs_fps": 10, + "max_raw_steps": 1000, + "parallel_envs": 16, + "checkpoint_revision": "d4825bbad8d15bc50b6b8481eb2abc84846a54fb", + "checkpoint_path": "latency-aware/ant/vla/starvla-qwenoft-h1/ant-qwenoft-mean-3090-s42", + "profile": { + "mean_ms": 90.56460638563993, + "profile": "/home/ubuntu/lzj/mean-profiling/reference/checkpoint-configs/latency-aware/ant/small-policy/sample-factory-qwenoft-rtx3090-v1/profile/profile.json", + "sha256": "0e49f72ec05ac600a54e07bbca5af3143708444d606167f33fa21788a9fefe50" + }, + "config": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/ant.yaml", + "output": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/ant", + "metrics": "return mean/std/min/max;length mean/std;success where nativeprovided;latency/drops/invalid/action audits;100 episode vectors" + }, + "intercept": { + "gpu": 3, + "seed_start": 4242424242, + "seed_end": 4242424341, + "env_fps": 20, + "obs_fps": 20, + "max_raw_steps": 60, + "parallel_envs": 32, + "checkpoint_revision": "d4825bbad8d15bc50b6b8481eb2abc84846a54fb", + "checkpoint_path": "latency-aware/mikasa-intercept-grab-fast/vla/starvla-qwenoft-h1/intercept-qwenoft-mean-3090-h1-s0", + "profile": { + "mean_ms": 99.05021289731565, + "profile": "/home/ubuntu/lzj/profiles/intercept-published/profiles/qwenoft/1x-rtx3090/mikasa_intercept_grab_fast/instance_3a0d42681a03715c/profile.json", + "sha256": "31a9b15d6b04182439934f0b377cb3d09be16ce21f3cf95c1049918f8a5d4984" + }, + "config": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/intercept.yaml", + "output": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/intercept", + "metrics": "return mean/std/min/max;length mean/std;success where nativeprovided;latency/drops/invalid/action audits;100 episode vectors" + } + } +} diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/execution_audit.json b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/execution_audit.json new file mode 100644 index 0000000000000000000000000000000000000000..8b0f90c02aad8843102296664b294f5e1e34bc15 --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/execution_audit.json @@ -0,0 +1,12 @@ +{ + "issued_action_records": 311075, + "applied_action_records": 310911, + "dropped_action_records": 64, + "nonnoop_issued_records": 30817, + "finite_action_values": true, + "latency_sample_count": 311075, + "latency_mean_ms": 75.89784633675906, + "latency_std_ms": 3.799946378622932, + "latency_p95_ms": 81.3960393048375, + "latency_p99_ms": 87.23844517488543 +} diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/files.sha256.json b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/files.sha256.json new file mode 100644 index 0000000000000000000000000000000000000000..915ce79e26f5741fe4309d3091c4407129ee424c --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/files.sha256.json @@ -0,0 +1,130 @@ +{ + "REPORT.md": { + "bytes": 2163, + "sha256": "b2fd63b1cde2a415b2d77daf0184ce5ec3b6ada1aa199c21941fb04031f77db6" + }, + "all_episodes.csv": { + "bytes": 25198, + "sha256": "bd41f35a464250ed6f9bc16e466aa9f1b55a48ac29072bb0ec3559a24129edac" + }, + "comparison.csv": { + "bytes": 438, + "sha256": "a0c7cf191395dd851bd6222bdf61427f15782fea2db4416ddc072a5f5dc8a861" + }, + "comparison.json": { + "bytes": 7826, + "sha256": "0d5dd042439466aee84cd0d96c31a27a951e57965a7e468cb73ec07883f1f751" + }, + "episodes.csv": { + "bytes": 5755, + "sha256": "92b258a93b02c0511f19d7b50975e2a167dd0ca796834f581be77245037ff135" + }, + "eval_config.yaml": { + "bytes": 2056, + "sha256": "9ad297a08d96c66a4ed57c2d66083faf36fdd585a7955faa1d39d9deefa43794" + }, + "evaluation-code/batched_simulated.py": { + "bytes": 31282, + "sha256": "b901f966d911feab7962a32f21095cb90f7880121811f2b4eab2193afe1381db" + }, + "evaluation-code/deadly-compatibility.patch": { + "bytes": 4570, + "sha256": "623676cc4542b1eab6c9395b163b369ddc605353c1de02d17d8f713167ee07fa" + }, + "evaluation-code/deadly_corridor.py": { + "bytes": 17902, + "sha256": "47f7bc65cba9853e66d79ed2a28f844bd2a094f1285458be166045f2db1690dc" + }, + "evaluation-code/decision_action_history.py": { + "bytes": 2746, + "sha256": "14a9d223e775745b6c402dbce9e2a50a1c3f7b5b9fe528150ef8689126fe97cf" + }, + "evaluation-code/eval_driver.py": { + "bytes": 9133, + "sha256": "330030270fbb695bc5f14037ef7349650bd20c53c881c1159ee55ea066408d9e" + }, + "evaluation-code/mikasa_evaluate.py": { + "bytes": 11466, + "sha256": "6cf9ffee25fcfd6f3255c520fc544c48ff2c8f8912e5369c2410a709820c4ffd" + }, + "evaluation-code/starvla.py": { + "bytes": 48378, + "sha256": "6d9988f3a28d39e46c2f6e80da85edebc42cafa629a2b9f75000414324c1065a" + }, + "evaluation-code/starvla_tasks.py": { + "bytes": 4029, + "sha256": "3fc74169d1554d9dc3358ed85e450cca75eb69bc1fff85284c1054a605633a52" + }, + "evaluation-plan.json": { + "bytes": 4698, + "sha256": "b758a5fb72dcdef49d025e2fd168d024ebd8b18b2b00125145b3cde38b16a318" + }, + "execution_audit.json": { + "bytes": 363, + "sha256": "ae7af259c3c9c6c1f8c9686b831e1c6692231af9f005ae862af9e14760b1dbef" + }, + "profile/latency_burst_model.json": { + "bytes": 24143, + "sha256": "8dbbcb87d41bf25c3ca421d80427445d29c31b323e306e8ada99c845746187b3" + }, + "profile/latency_distribution.json": { + "bytes": 25054, + "sha256": "e568e466bdec6ab73d4b5c595bc02e7c7047bdb3f39324254a3aa6f660900250" + }, + "profile/profile.json": { + "bytes": 2140, + "sha256": "c266cba7ebac05c7e37bc83f1f16fe4b27dab97942ff43290e6c41514f6e39fc" + }, + "provenance.json": { + "bytes": 3736, + "sha256": "21329d6e66227f37d21d6e78676038d151e6f99f472b30288792b4ff0d8171f3" + }, + "queue_eval_latency_profile_sample.json": { + "bytes": 3915, + "sha256": "3a18d8878aeb1a459aaf716db04b930b7d1bc9d61273d9a5532beb829c984aa8" + }, + "raw-records/actions.jsonl.gz": { + "bytes": 23634236, + "sha256": "783f69617b6eeba129eadb2d698719018b185e13f9558e2fd644fd584ea5471e" + }, + "raw-records/e2e_latencies.jsonl.gz": { + "bytes": 6608982, + "sha256": "c273135c50f8244c182e67fc63203c3bb9f95cc4d8654f26ea5a0008895c2350" + }, + "raw-records/episode_metrics.jsonl.gz": { + "bytes": 6794, + "sha256": "ead85d36c65e4badc29e9e9d97f3a0b0899c7ad0116354adc91b364cfcf52a43" + }, + "raw-records/infer_latencies.jsonl.gz": { + "bytes": 4678442, + "sha256": "6046f2601da69be9c8849b5ca4f69a89e3ad2354d17a8788708c0b2a20ddb47e" + }, + "raw-records/latencies.jsonl.gz": { + "bytes": 4678436, + "sha256": "b79be007401a136bb21ad8e25c4932b567c61dab18e3a052ae0f21ec790a15ea" + }, + "raw-records/observation_attempts.jsonl.gz": { + "bytes": 47, + "sha256": "8b9659fba7af43449720211464ae93a9fa76d044dcceae45b6c39d556ca9f404" + }, + "raw-records/queue_eval_results.jsonl.gz": { + "bytes": 794, + "sha256": "8b7dcbafff1492142f70180b7c6c63cc53b8d866c0247569ebe7498200717e4e" + }, + "raw-records/steps.jsonl.gz": { + "bytes": 7221452, + "sha256": "5bdf7b2ae8b367dd6412faaca477cdb70d3f6bdbc1142a1688d6f48f9801abd8" + }, + "resolved_config.yaml": { + "bytes": 2124, + "sha256": "5ada3462c4b88aff8bfb7604eaa003b6621167dfc3f35675e001ee0725fd52dc" + }, + "statistics.json": { + "bytes": 1218, + "sha256": "232db020427660a6a0f8721175f3433c23b0e2cc51c3769ffffb55a6a96e8aac" + }, + "stdout.log": { + "bytes": 27195, + "sha256": "580e80297e5ea307aad4668e1a25996e033ec23e021d1dff12a0e80e6d23e52c" + } +} diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/provenance.json b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/provenance.json new file mode 100644 index 0000000000000000000000000000000000000000..9dffc6d4e2d595269089223f89b654c4c1548406 --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/provenance.json @@ -0,0 +1,97 @@ +{ + "task": "flappy", + "protocol": { + "gpu": 2, + "seed_start": 1000000, + "seed_end": 1000099, + "env_fps": 10, + "obs_fps": 10, + "max_raw_steps": 3600, + "parallel_envs": 32, + "checkpoint_revision": "d4825bbad8d15bc50b6b8481eb2abc84846a54fb", + "checkpoint_path": "latency-aware/flappy/vla/starvla-qwenoft-h1/flappy-qwenoft-mean-3090-s42", + "profile": { + "mean_ms": 75.87417450998383, + "profile": "/home/ubuntu/lzj/profiles/published/profiles/openvla/1x-rtx3090/flappy/instance_a5037b165aa0cedc/profile.json", + "sha256": "c266cba7ebac05c7e37bc83f1f16fe4b27dab97942ff43290e6c41514f6e39fc" + }, + "config": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/flappy.yaml", + "output": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/flappy", + "metrics": "return mean/std/min/max;length mean/std;success where nativeprovided;latency/drops/invalid/action audits;100 episode vectors" + }, + "checkpoint_weights": { + "bytes": 9785137569, + "sha256": "f784cb7d6c19872b4ac419f8a31459b395c12f23809f561ae134080a74c6e80a" + }, + "evaluation": { + "n_episodes": 100, + "mean_return": 384.8240045265853, + "std_return": 116.78777394316903, + "min_return": 36.60000045597553, + "max_return": 444.6000052243471, + "mean_length": 3119.31, + "std_length": 939.8693174585497, + "min_length": 314.0, + "max_length": 3600.0, + "return_field": "episode_return_env", + "length_field": "survival_steps", + "mode": "simulated", + "policy_id": "starvla", + "env_id": "flappy", + "model_id": "openvla", + "gpu_class": "1x-rtx3090", + "workload_id": "flappy", + "instance_id": "instance_a5037b165aa0cedc", + "source_run_id": "20260914T122201421825Z", + "profile_ref": null, + "env_fps": 10.0, + "obs_fps": 10.0, + "frame_ms": 100.0, + "latency_type": "profile_sample", + "task": "flappy", + "checkpoint_revision": "d4825bbad8d15bc50b6b8481eb2abc84846a54fb", + "checkpoint_path": "latency-aware/flappy/vla/starvla-qwenoft-h1/flappy-qwenoft-mean-3090-s42", + "profile_sha256": "c266cba7ebac05c7e37bc83f1f16fe4b27dab97942ff43290e6c41514f6e39fc", + "condition": "profile-latency", + "invalid_actions": 0, + "dropped_actions": 64, + "unique_seeds": 100, + "physical_gpu": 2, + "eval_config": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/flappy.yaml", + "execution_audit": { + "issued_action_records": 311075, + "applied_action_records": 310911, + "dropped_action_records": 64, + "nonnoop_issued_records": 30817, + "finite_action_values": true, + "latency_sample_count": 311075, + "latency_mean_ms": 75.89784633675906, + "latency_std_ms": 3.799946378622932, + "latency_p95_ms": 81.3960393048375, + "latency_p99_ms": 87.23844517488543 + } + }, + "source_revision": { + "repo": "c3c6a39365a151e9b7a5e215452fd64e957c2b29", + "starvla": "ccca13c5177fe3d3c884b6e2de4965d916016649", + "runtime_fixes": [ + "mean-profile-preparation.patch", + "gym-language-contract.patch", + "loader-spawn-cache.patch", + "loader-spawn-test.patch", + "doom-mean-reset.patch" + ], + "pytorch3d": { + "revision": "33824be3cbc87a7dd1db0f6a9a9de9ac81b2d0ba", + "build": "transforms-only, no native render extension; QwenOFT uses transforms only" + }, + "decord": { + "version": "0.6.0", + "build": "official source CPU decoder CP310", + "wheel_sha256": "e193b356b1e984b4eff08d23b62e482c2c9e5037a6efdc0b1af47079ae2e4c47" + } + }, + "raw_records_format": "gzip(JSONL), lossless", + "startup_checks_included_in_score": false, + "results_status": "evaluation_complete; acceptance_not_inferred" +} diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/queue_eval_latency_profile_sample.json b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/queue_eval_latency_profile_sample.json new file mode 100644 index 0000000000000000000000000000000000000000..57d8a8691bb9bd3e99061eb8e279b89268ee9383 --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/queue_eval_latency_profile_sample.json @@ -0,0 +1,217 @@ +{ + "checkpoint_path": "/home/ubuntu/lzj/mean-profiling/flappy/vla-publication/checkpoints/model.pt", + "experiment_name": "flappy-mean5000-profile-simulation-100ep", + "latency": "profile_sample", + "latency_type": "profile_sample", + "lengths": [ + 3600, + 3600, + 3600, + 3600, + 3600, + 1861, + 3600, + 3600, + 3600, + 3600, + 3600, + 3600, + 3600, + 3600, + 3600, + 3600, + 3600, + 3600, + 3600, + 2162, + 3600, + 3600, + 3600, + 3600, + 3600, + 955, + 3600, + 3600, + 3600, + 3600, + 2085, + 3600, + 3600, + 3600, + 3600, + 3600, + 3600, + 3600, + 468, + 3600, + 3512, + 2237, + 2156, + 2161, + 3600, + 1180, + 3600, + 771, + 473, + 2159, + 3600, + 3600, + 3234, + 3600, + 2200, + 582, + 3600, + 3600, + 3600, + 3553, + 2834, + 3600, + 656, + 3600, + 3600, + 3600, + 3600, + 3600, + 3600, + 3600, + 3600, + 1109, + 3600, + 3600, + 3600, + 3600, + 3600, + 3600, + 3600, + 3600, + 3600, + 3600, + 957, + 3600, + 3600, + 314, + 2125, + 3600, + 3600, + 3600, + 3600, + 1831, + 3600, + 1478, + 2478, + 3600, + 3600, + 3600, + 3600, + 3600 + ], + "mean_length": 3119.31, + "mean_return": 384.8240045265853, + "returns": [ + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 228.2000027000904, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 265.50000313669443, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 116.00000138580799, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 256.0000030249357, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 55.60000067949295, + 444.6000052243471, + 432.900005094707, + 274.8000032454729, + 264.90000312775373, + 265.4000031352043, + 444.6000052243471, + 143.90000171214342, + 444.6000052243471, + 93.1000011190772, + 56.10000068694353, + 265.2000031322241, + 444.6000052243471, + 444.6000052243471, + 398.80000469088554, + 444.6000052243471, + 270.2000031918287, + 69.70000084489584, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 437.90000515431166, + 348.9000041112304, + 444.6000052243471, + 78.9000009521842, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 135.0000016093254, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 116.20000138878822, + 444.6000052243471, + 444.6000052243471, + 36.60000045597553, + 260.90000308305025, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 225.20000265538692, + 444.6000052243471, + 180.9000021442771, + 305.2000035941601, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471, + 444.6000052243471 + ], + "seed": 1000000, + "source_profile_path": "/home/ubuntu/lzj/profiles/published/profiles/openvla/1x-rtx3090/flappy/instance_a5037b165aa0cedc/profile.json", + "std_return": 116.78777394316901, + "suite_name": "profile_sample", + "timestamp_utc": "2026-10-01T06:42:51.932491+00:00" +} diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/raw-records/actions.jsonl.gz b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/raw-records/actions.jsonl.gz new file mode 100644 index 0000000000000000000000000000000000000000..a4b5e1527a34b6d2b179b3e421edcd577863dcf1 --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/raw-records/actions.jsonl.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:783f69617b6eeba129eadb2d698719018b185e13f9558e2fd644fd584ea5471e +size 23634236 diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/raw-records/e2e_latencies.jsonl.gz b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/raw-records/e2e_latencies.jsonl.gz new file mode 100644 index 0000000000000000000000000000000000000000..859dcfcce636712935274362fb40228dd788d875 --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/raw-records/e2e_latencies.jsonl.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c273135c50f8244c182e67fc63203c3bb9f95cc4d8654f26ea5a0008895c2350 +size 6608982 diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/raw-records/episode_metrics.jsonl.gz b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/raw-records/episode_metrics.jsonl.gz new file mode 100644 index 0000000000000000000000000000000000000000..a2d6d2b94691817ae45a9b30f1ea71b48d210ae0 --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/raw-records/episode_metrics.jsonl.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ead85d36c65e4badc29e9e9d97f3a0b0899c7ad0116354adc91b364cfcf52a43 +size 6794 diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/raw-records/infer_latencies.jsonl.gz b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/raw-records/infer_latencies.jsonl.gz new file mode 100644 index 0000000000000000000000000000000000000000..993dfad54ffa58b27f5448f1708f63e5ed5742c8 --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/raw-records/infer_latencies.jsonl.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6046f2601da69be9c8849b5ca4f69a89e3ad2354d17a8788708c0b2a20ddb47e +size 4678442 diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/raw-records/latencies.jsonl.gz b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/raw-records/latencies.jsonl.gz new file mode 100644 index 0000000000000000000000000000000000000000..2fe21e1ec379bef81ffcc1b7d4b982025bb3329f --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/raw-records/latencies.jsonl.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b79be007401a136bb21ad8e25c4932b567c61dab18e3a052ae0f21ec790a15ea +size 4678436 diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/raw-records/observation_attempts.jsonl.gz b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/raw-records/observation_attempts.jsonl.gz new file mode 100644 index 0000000000000000000000000000000000000000..a506d732f42c8d042187a8054fcb69ca5fda46bf --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/raw-records/observation_attempts.jsonl.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8b9659fba7af43449720211464ae93a9fa76d044dcceae45b6c39d556ca9f404 +size 47 diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/raw-records/queue_eval_results.jsonl.gz b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/raw-records/queue_eval_results.jsonl.gz new file mode 100644 index 0000000000000000000000000000000000000000..5441778983ca22a88fa86523831d9ea4f3339376 --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/raw-records/queue_eval_results.jsonl.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8b7dcbafff1492142f70180b7c6c63cc53b8d866c0247569ebe7498200717e4e +size 794 diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/raw-records/steps.jsonl.gz b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/raw-records/steps.jsonl.gz new file mode 100644 index 0000000000000000000000000000000000000000..557c8dba22329716082e7adaabf78d9579ab43db --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/raw-records/steps.jsonl.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5bdf7b2ae8b367dd6412faaca477cdb70d3f6bdbc1142a1688d6f48f9801abd8 +size 7221452 diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/resolved_config.yaml b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/resolved_config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..6d136497e97788cc84a6fb209e4f5957fd1fc5d0 --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/resolved_config.yaml @@ -0,0 +1,85 @@ +experiment: + name: flappy-mean5000-profile-simulation-100ep + seed: 1000000 +backend: + run_mode: eval +executor: + mode: simulated + simulated_worker_capacity: 1 + simulated_inference_pool: true + inference_devices: + - cuda:0 + inference_batch_size: 32 +env: + name: flappy + gym_id: FlappyBird-v0 + env_fps: 10 + obs_fps: 10 + render_mode: rgb_array + observation_mode: image + use_lidar: false + normalize_obs: true + audio_on: false + frame_stack: 1 + obs_resize: + - 224 + - 224 + simulator: gpu + use_gpu_render: false + gpu_render_device: auto + gpu_render_profile: false + gpu_render_profile_interval: 200 + noop_action: noop + action_map: + noop: 0 + flap: 1 + oneshot_actions: + - flap + action_history_decisions: 8 +latency: + method: temporal + profile_path: /home/ubuntu/lzj/profiles/published/profiles/openvla/1x-rtx3090/flappy/instance_a5037b165aa0cedc/profile.json + profile_worker_slot: 0 + seed: 271828 + add_latency_info: false +scheduler: + hold_policy: one_frame_then_noop + ordering_policy: latest_ready +policy: + type: starvla + checkpoint_path: /home/ubuntu/lzj/mean-profiling/flappy/vla-publication/checkpoints/model.pt + model_config_path: /home/ubuntu/lzj/mean-profiling/flappy/vla-publication/config.full.yaml + device: cuda:0 + unnorm_key: new_embodiment + prompt_mode: latency_neutral + actions: + - noop + - flap + state_source: transport + backbone_path: /home/ubuntu/lzj/models/Qwen3-VL-4B-Instruct + worker_python_executable: /home/ubuntu/lzj/conda/envs/qwenoft/bin/python + action_prefix: + mode: none +evaluation: + eval_episodes: 100 + eval_parallel_envs: 32 + latency_bench_env_backend: flappy_gpu_batched + eval_latency_values: null + eval_max_steps: 3600 + eval_deterministic: true + eval_raw_reward: true + eval_suites: + fixed: [] + normal: [] + uniform: [] +logging: + output_dir: /home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/flappy + save_step_records: true + save_action_records: true + save_latency_records: true + video: + enabled: false + wandb_project: null + wandb_group: null + wandb_job_type: null + simulated_pipeline_profile: false diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/statistics.json b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/statistics.json new file mode 100644 index 0000000000000000000000000000000000000000..15a41ce3a1890fc73dcdeee46f8bad4c59bc237d --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/statistics.json @@ -0,0 +1,36 @@ +{ + "n_episodes": 100, + "mean_return": 384.8240045265853, + "std_return": 116.78777394316903, + "min_return": 36.60000045597553, + "max_return": 444.6000052243471, + "mean_length": 3119.31, + "std_length": 939.8693174585497, + "min_length": 314.0, + "max_length": 3600.0, + "return_field": "episode_return_env", + "length_field": "survival_steps", + "mode": "simulated", + "policy_id": "starvla", + "env_id": "flappy", + "model_id": "openvla", + "gpu_class": "1x-rtx3090", + "workload_id": "flappy", + "instance_id": "instance_a5037b165aa0cedc", + "source_run_id": "20260914T122201421825Z", + "profile_ref": null, + "env_fps": 10.0, + "obs_fps": 10.0, + "frame_ms": 100.0, + "latency_type": "profile_sample", + "task": "flappy", + "checkpoint_revision": "d4825bbad8d15bc50b6b8481eb2abc84846a54fb", + "checkpoint_path": "latency-aware/flappy/vla/starvla-qwenoft-h1/flappy-qwenoft-mean-3090-s42", + "profile_sha256": "c266cba7ebac05c7e37bc83f1f16fe4b27dab97942ff43290e6c41514f6e39fc", + "condition": "profile-latency", + "invalid_actions": 0, + "dropped_actions": 64, + "unique_seeds": 100, + "physical_gpu": 2, + "eval_config": "/home/ubuntu/lzj/mean-profiling/evaluation/profile-latency-100ep-20261001/flappy.yaml" +} diff --git a/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/stdout.log b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/stdout.log new file mode 100644 index 0000000000000000000000000000000000000000..d1310154151082d5f90c29adacecc0b1fd3ee446 --- /dev/null +++ b/evaluations/flappy/flappy-qwenoft-mean-3090-s42/evaluation/profile-simulation-100ep-20261001/stdout.log @@ -0,0 +1,397 @@ +[bench] run=flappy-mean5000-profile-simulation-100ep sweeps=1 episodes_per_sweep=100 total_episode_runs=100 +[bench] sweep 1/1: eval_latency=profile_sample +/home/ubuntu/lzj/conda/envs/qwenoft/lib/python3.10/site-packages/pygame/pkgdata.py:25: UserWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html. The pkg_resources package is slated for removal as early as 2025-11-30. Refrain from using this package or pin to Setuptools<81. + from pkg_resources import resource_stream, resource_exists +10/01 [06:01:51] INFO | >> Loaded mixtures from Behavior registry.py:113 + (data_config): ['BEHAVIOR_challenge'] + INFO | >> Loaded data_config from DOMINO: registry.py:107 + ['robotwin'] + INFO | >> Loaded embodiment_tags from registry.py:110 + DOMINO (data_config): [] + INFO | >> Loaded mixtures from DOMINO registry.py:113 + (data_config): ['domino', + 'domino_clean', 'domino_random', + 'domino_cotrain'] + INFO | >> Loaded data_config from Franka: registry.py:107 + ['custom_robot_config', + 'demo_sim_franka_delta_joints', + 'SO101'] + INFO | >> Loaded embodiment_tags from registry.py:110 + Franka (data_config): [] + INFO | >> Loaded mixtures from Franka registry.py:113 + (data_config): ['custom_dataset', + 'custom_dataset_2', + 'demo_sim_pick_place', 'SO101_pick'] + INFO | >> Loaded data_config from LIBERO: registry.py:107 + ['libero_franka'] + INFO | >> Loaded embodiment_tags from registry.py:110 + LIBERO (data_config): [] + INFO | >> Loaded mixtures from LIBERO registry.py:113 + (data_config): ['libero_all', + 'libero_goal', 'multi_robot'] + INFO | >> Loaded data_config from MIKASA: registry.py:107 + ['mikasa_franka_h1'] + INFO | >> Loaded embodiment_tags from registry.py:110 + MIKASA (data_config): + ['mikasa_franka_h1'] + INFO | >> Loaded mixtures from MIKASA registry.py:113 + (data_config): + ['local/intercept_grab_fast_vla_v0_h1_ + train'] + INFO | >> Loaded data_config from registry.py:107 + RoboChallenge_table30v2: + ['ur5_robochallenge', + 'arx5_robochallenge', + 'dosw1_robochallenge'] + INFO | >> Loaded embodiment_tags from registry.py:110 + RoboChallenge_table30v2 (data_config): + ['ur5_robochallenge', + 'arx5_robochallenge', + 'dosw1_robochallenge'] + INFO | >> Loaded mixtures from registry.py:113 + RoboChallenge_table30v2 (data_config): + ['robochallenge_table30v2_shred_paper' + , 'robochallenge_table30v2_ur5_all', + 'robochallenge_table30v2_arx5_all', + 'robochallenge_table30v2_dosw1_all'] + INFO | >> Loaded data_config from registry.py:107 + Robocasa_365: + ['panda_omron_robocasa365'] + INFO | >> Loaded embodiment_tags from registry.py:110 + Robocasa_365 (data_config): [] + INFO | >> Loaded mixtures from registry.py:113 + Robocasa_365 (data_config): + ['robocasa365_open_drawer_target_human + ', + 'robocasa365_atomic_target_human_all', + 'robocasa365_composite_target_human_al + l', 'robocasa365_target_human_all'] + INFO | >> Loaded data_config from registry.py:107 + Robocasa_tabletop: + ['fourier_gr1_arms_waist'] + INFO | >> Loaded embodiment_tags from registry.py:110 + Robocasa_tabletop (data_config): [] + INFO | >> Loaded mixtures from registry.py:113 + Robocasa_tabletop (data_config): + ['fourier_gr1_unified_1000'] + INFO | >> Loaded data_config from registry.py:107 + Robotwin: ['robotwin', 'robotwin50', + 'arx_x5'] + INFO | >> Loaded embodiment_tags from registry.py:110 + Robotwin (data_config): [] + INFO | >> Loaded mixtures from Robotwin registry.py:113 + (data_config): ['robotwin_all', + 'robotwin_all_50', 'robotwin', + 'robotwin_task1', 'robotwin_task2', + 'arx_x5'] + INFO | >> Loaded data_config from registry.py:107 + SimplerEnv: ['oxe_droid', + 'oxe_bridge', 'oxe_rt1'] + INFO | >> Loaded embodiment_tags from registry.py:110 + SimplerEnv (data_config): [] + INFO | >> Loaded mixtures from SimplerEnv registry.py:113 + (data_config): ['bridge', + 'bridge_rt_1'] + INFO | >> Loaded data_config from registry.py:107 + VLA-Arena: ['vla_arena_franka'] + INFO | >> Loaded embodiment_tags from registry.py:110 + VLA-Arena (data_config): [] + INFO | >> Loaded mixtures from VLA-Arena registry.py:113 + (data_config): ['vla_arena_L0_S', + 'vla_arena_L0_M', 'vla_arena_L0_L'] + INFO | >> Loaded data_config from registry.py:107 + rl_games: ['rl_games_flappy', + 'rl_games_demon_attack', + 'rl_games_defend_the_line', + 'rl_games_deadly_corridor', + 'rl_games_asterix', + 'rl_games_atlantis', + 'rl_games_gymnasium', + 'rl_games_gymnasium_discrete', + 'rl_games_gymnasium_native'] + INFO | >> Loaded embodiment_tags from registry.py:110 + rl_games (data_config): + ['rl_games_flappy', + 'rl_games_demon_attack', + 'rl_games_defend_the_line', + 'rl_games_deadly_corridor', + 'rl_games_asterix', + 'rl_games_atlantis', + 'rl_games_gymnasium', + 'rl_games_gymnasium_discrete', + 'rl_games_gymnasium_native'] + INFO | >> Loaded mixtures from rl_games registry.py:113 + (data_config): ['flappy_train', + 'flappy_train__bridge', + 'flappy_mixed_latency_train', + 'flappy_mixed_latency_train__bridge', + 'demon_attack_train', + 'demon_attack_train__bridge', + 'demon_attack_mixed_latency_train', + 'demon_attack_mixed_latency_train__bri + dge', 'defend_the_line_train', + 'defend_the_line_train__bridge', + 'defend_the_line_mixed_latency_train', + 'defend_the_line_mixed_latency_train__ + bridge', 'deadly_corridor_train', + 'deadly_corridor_train__bridge', + 'deadly_corridor_mixed_latency_train', + 'deadly_corridor_mixed_latency_train__ + bridge', 'asterix_train', + 'asterix_train__bridge', + 'asterix_mixed_latency_train', + 'asterix_mixed_latency_train__bridge', + 'atlantis_train', + 'atlantis_train__bridge', + 'atlantis_mixed_latency_train', + 'atlantis_mixed_latency_train__bridge' + , 'h1hand_balance_hard'] + INFO | >> PolicyServerWrapper: loading policy_wrapper.py:73 + framework from + /home/ubuntu/lzj/mean-profiling/f + lappy/vla-publication/checkpoints + /model.pt + INFO | >> [*] Loading from local share_tools.py:418 + checkpoint path + `/home/ubuntu/lzj/mean-profiling/fl + appy/vla-publication/checkpoints/mo + del.pt` +[QWen3] loading /home/ubuntu/lzj/models/Qwen3-VL-4B-Instruct with gradient_checkpointing=False + Loading checkpoint shards: 0%| | 0/2 [00:00> [*] Loading from local share_tools.py:418 + checkpoint path + `/home/ubuntu/lzj/mean-profiling/fl + appy/vla-publication/checkpoints/mo + del.pt` + INFO | >> [*] Loading from local share_tools.py:418 + checkpoint path + `/home/ubuntu/lzj/mean-profiling/fl + appy/vla-publication/checkpoints/mo + del.pt` + INFO | >> [*] Loading from local share_tools.py:418 + checkpoint path + `/home/ubuntu/lzj/mean-profiling/fl + appy/vla-publication/checkpoints/mo + del.pt` + INFO | >> PolicyNormProcessor policy_norm_processor.py:333 + ready: + robot_type=rl_games_flapp + y, + unnorm_key=new_embodiment + , + action_keys=['action.butt + on'] (dims=[2]), + state_keys=['state.game_s + tate'] + INFO | >> PolicyServerWrapper ready: policy_wrapper.py:126 + action_chunk_size=1, + default_unnorm_key=new_embodimen + t, + available_unnorm_keys=['new_embo + diment'], + action_keys=['action.button'], + state_keys=['state.game_state'] +[bench] sweep 1/1 episode 1/100 done +[bench] sweep 1/1 episode 2/100 done +[bench] sweep 1/1 episode 3/100 done +[bench] sweep 1/1 episode 4/100 done +[bench] sweep 1/1 episode 5/100 done +[bench] sweep 1/1 episode 6/100 done +[bench] sweep 1/1 episode 7/100 done +[bench] sweep 1/1 episode 8/100 done +[bench] sweep 1/1 episode 9/100 done +[bench] sweep 1/1 episode 10/100 done +[bench] sweep 1/1 episode 11/100 done +[bench] sweep 1/1 episode 12/100 done +[bench] sweep 1/1 episode 13/100 done +[bench] sweep 1/1 episode 14/100 done +[bench] sweep 1/1 episode 15/100 done +[bench] sweep 1/1 episode 16/100 done +[bench] sweep 1/1 episode 17/100 done +[bench] sweep 1/1 episode 18/100 done +[bench] sweep 1/1 episode 19/100 done +[bench] sweep 1/1 episode 20/100 done +[bench] sweep 1/1 episode 21/100 done +[bench] sweep 1/1 episode 22/100 done +[bench] sweep 1/1 episode 23/100 done +[bench] sweep 1/1 episode 24/100 done +[bench] sweep 1/1 episode 25/100 done +[bench] sweep 1/1 episode 26/100 done +[bench] sweep 1/1 episode 27/100 done +[bench] sweep 1/1 episode 28/100 done +[bench] sweep 1/1 episode 29/100 done +[bench] sweep 1/1 episode 30/100 done +[bench] sweep 1/1 episode 31/100 done +[bench] sweep 1/1 episode 32/100 done +[bench] sweep 1/1 episode 33/100 done +[bench] sweep 1/1 episode 34/100 done +[bench] sweep 1/1 episode 35/100 done +[bench] sweep 1/1 episode 36/100 done +[bench] sweep 1/1 episode 37/100 done +[bench] sweep 1/1 episode 38/100 done +[bench] sweep 1/1 episode 39/100 done +[bench] sweep 1/1 episode 40/100 done +[bench] sweep 1/1 episode 41/100 done +[bench] sweep 1/1 episode 42/100 done +[bench] sweep 1/1 episode 43/100 done +[bench] sweep 1/1 episode 44/100 done +[bench] sweep 1/1 episode 45/100 done +[bench] sweep 1/1 episode 46/100 done +[bench] sweep 1/1 episode 47/100 done +[bench] sweep 1/1 episode 48/100 done +[bench] sweep 1/1 episode 49/100 done +[bench] sweep 1/1 episode 50/100 done +[bench] sweep 1/1 episode 51/100 done +[bench] sweep 1/1 episode 52/100 done +[bench] sweep 1/1 episode 53/100 done +[bench] sweep 1/1 episode 54/100 done +[bench] sweep 1/1 episode 55/100 done +[bench] sweep 1/1 episode 56/100 done +[bench] sweep 1/1 episode 57/100 done +[bench] sweep 1/1 episode 58/100 done +[bench] sweep 1/1 episode 59/100 done +[bench] sweep 1/1 episode 60/100 done +[bench] sweep 1/1 episode 61/100 done +[bench] sweep 1/1 episode 62/100 done +[bench] sweep 1/1 episode 63/100 done +[bench] sweep 1/1 episode 64/100 done +[bench] sweep 1/1 episode 65/100 done +[bench] sweep 1/1 episode 66/100 done +[bench] sweep 1/1 episode 67/100 done +[bench] sweep 1/1 episode 68/100 done +[bench] sweep 1/1 episode 69/100 done +[bench] sweep 1/1 episode 70/100 done +[bench] sweep 1/1 episode 71/100 done +[bench] sweep 1/1 episode 72/100 done +[bench] sweep 1/1 episode 73/100 done +[bench] sweep 1/1 episode 74/100 done +[bench] sweep 1/1 episode 75/100 done +[bench] sweep 1/1 episode 76/100 done +[bench] sweep 1/1 episode 77/100 done +[bench] sweep 1/1 episode 78/100 done +[bench] sweep 1/1 episode 79/100 done +[bench] sweep 1/1 episode 80/100 done +[bench] sweep 1/1 episode 81/100 done +[bench] sweep 1/1 episode 82/100 done +[bench] sweep 1/1 episode 83/100 done +[bench] sweep 1/1 episode 84/100 done +[bench] sweep 1/1 episode 85/100 done +[bench] sweep 1/1 episode 86/100 done +[bench] sweep 1/1 episode 87/100 done +[bench] sweep 1/1 episode 88/100 done +[bench] sweep 1/1 episode 89/100 done +[bench] sweep 1/1 episode 90/100 done +[bench] sweep 1/1 episode 91/100 done +[bench] sweep 1/1 episode 92/100 done +[bench] sweep 1/1 episode 93/100 done +[bench] sweep 1/1 episode 94/100 done +[bench] sweep 1/1 episode 95/100 done +[bench] sweep 1/1 episode 96/100 done +[bench] sweep 1/1 episode 97/100 done +[bench] sweep 1/1 episode 98/100 done +[bench] sweep 1/1 episode 99/100 done +[bench] sweep 1/1 episode 100/100 done +[bench] sweep 1/1 complete elapsed=2511.2s +episode=0 return=444.600 steps=3600 mean_latency_ms=76.02271694866694 +episode=1 return=444.600 steps=3600 mean_latency_ms=76.14445348705047 +episode=2 return=444.600 steps=3600 mean_latency_ms=75.83047266244563 +episode=3 return=444.600 steps=3600 mean_latency_ms=76.04121221698036 +episode=4 return=444.600 steps=3600 mean_latency_ms=75.7789115791707 +episode=5 return=228.200 steps=1861 mean_latency_ms=76.22757676162651 +episode=6 return=444.600 steps=3600 mean_latency_ms=75.98373978309758 +episode=7 return=444.600 steps=3600 mean_latency_ms=75.85552109823348 +episode=8 return=444.600 steps=3600 mean_latency_ms=75.9782303085917 +episode=9 return=444.600 steps=3600 mean_latency_ms=75.94667987356688 +episode=10 return=444.600 steps=3600 mean_latency_ms=75.66396359484234 +episode=11 return=444.600 steps=3600 mean_latency_ms=75.7794525026407 +episode=12 return=444.600 steps=3600 mean_latency_ms=75.90110110734818 +episode=13 return=444.600 steps=3600 mean_latency_ms=76.01870178237883 +episode=14 return=444.600 steps=3600 mean_latency_ms=75.75567207010911 +episode=15 return=444.600 steps=3600 mean_latency_ms=75.83026036637241 +episode=16 return=444.600 steps=3600 mean_latency_ms=75.74502908171665 +episode=17 return=444.600 steps=3600 mean_latency_ms=75.84316844302293 +episode=18 return=444.600 steps=3600 mean_latency_ms=75.85876738771161 +episode=19 return=265.500 steps=2162 mean_latency_ms=75.89492798135642 +episode=20 return=444.600 steps=3600 mean_latency_ms=75.90859756288593 +episode=21 return=444.600 steps=3600 mean_latency_ms=75.93474621914784 +episode=22 return=444.600 steps=3600 mean_latency_ms=75.77022360156529 +episode=23 return=444.600 steps=3600 mean_latency_ms=75.8506098974935 +episode=24 return=444.600 steps=3600 mean_latency_ms=75.80511776716725 +episode=25 return=116.000 steps=955 mean_latency_ms=76.07937915327228 +episode=26 return=444.600 steps=3600 mean_latency_ms=75.77409482659607 +episode=27 return=444.600 steps=3600 mean_latency_ms=75.82354466933252 +episode=28 return=444.600 steps=3600 mean_latency_ms=75.92578714415393 +episode=29 return=444.600 steps=3600 mean_latency_ms=75.77326038618416 +episode=30 return=256.000 steps=2085 mean_latency_ms=75.8461606092662 +episode=31 return=444.600 steps=3600 mean_latency_ms=75.87053786258159 +episode=32 return=444.600 steps=3600 mean_latency_ms=75.90930861144982 +episode=33 return=444.600 steps=3600 mean_latency_ms=75.80530422686525 +episode=34 return=444.600 steps=3600 mean_latency_ms=76.05997569829616 +episode=35 return=444.600 steps=3600 mean_latency_ms=75.67579907153437 +episode=36 return=444.600 steps=3600 mean_latency_ms=76.07561842170198 +episode=37 return=444.600 steps=3600 mean_latency_ms=75.87459102177027 +episode=38 return=55.600 steps=468 mean_latency_ms=75.8887188983619 +episode=39 return=444.600 steps=3600 mean_latency_ms=75.86536772802552 +episode=40 return=432.900 steps=3512 mean_latency_ms=76.00355652525975 +episode=41 return=274.800 steps=2237 mean_latency_ms=75.7658282850597 +episode=42 return=264.900 steps=2156 mean_latency_ms=75.95264956954799 +episode=43 return=265.400 steps=2161 mean_latency_ms=75.82748305801191 +episode=44 return=444.600 steps=3600 mean_latency_ms=75.9295822845668 +episode=45 return=143.900 steps=1180 mean_latency_ms=75.94310218110371 +episode=46 return=444.600 steps=3600 mean_latency_ms=75.69568531179425 +episode=47 return=93.100 steps=771 mean_latency_ms=76.0527875505066 +episode=48 return=56.100 steps=473 mean_latency_ms=76.20882901957174 +episode=49 return=265.200 steps=2159 mean_latency_ms=76.05401077635972 +episode=50 return=444.600 steps=3600 mean_latency_ms=75.89333271844873 +episode=51 return=444.600 steps=3600 mean_latency_ms=75.89090159365671 +episode=52 return=398.800 steps=3234 mean_latency_ms=75.91218218803246 +episode=53 return=444.600 steps=3600 mean_latency_ms=75.86400590251726 +episode=54 return=270.200 steps=2200 mean_latency_ms=76.01590238337654 +episode=55 return=69.700 steps=582 mean_latency_ms=75.68422480575155 +episode=56 return=444.600 steps=3600 mean_latency_ms=75.87884524455251 +episode=57 return=444.600 steps=3600 mean_latency_ms=75.96981187494319 +episode=58 return=444.600 steps=3600 mean_latency_ms=76.03772455115222 +episode=59 return=437.900 steps=3553 mean_latency_ms=76.04088529786887 +episode=60 return=348.900 steps=2834 mean_latency_ms=75.79422825165413 +episode=61 return=444.600 steps=3600 mean_latency_ms=75.87728099437057 +episode=62 return=78.900 steps=656 mean_latency_ms=75.96352981662133 +episode=63 return=444.600 steps=3600 mean_latency_ms=75.80269270184165 +episode=64 return=444.600 steps=3600 mean_latency_ms=75.88518180564401 +episode=65 return=444.600 steps=3600 mean_latency_ms=75.87533034544981 +episode=66 return=444.600 steps=3600 mean_latency_ms=75.94241138050401 +episode=67 return=444.600 steps=3600 mean_latency_ms=75.95312277771471 +episode=68 return=444.600 steps=3600 mean_latency_ms=75.8998829764233 +episode=69 return=444.600 steps=3600 mean_latency_ms=75.98564617573034 +episode=70 return=444.600 steps=3600 mean_latency_ms=75.68328575087021 +episode=71 return=135.000 steps=1109 mean_latency_ms=75.99546963217229 +episode=72 return=444.600 steps=3600 mean_latency_ms=75.9923106611263 +episode=73 return=444.600 steps=3600 mean_latency_ms=75.80422251719546 +episode=74 return=444.600 steps=3600 mean_latency_ms=75.95469853250815 +episode=75 return=444.600 steps=3600 mean_latency_ms=75.74551875442629 +episode=76 return=444.600 steps=3600 mean_latency_ms=75.93301571087362 +episode=77 return=444.600 steps=3600 mean_latency_ms=75.98384926019328 +episode=78 return=444.600 steps=3600 mean_latency_ms=75.85055115368883 +episode=79 return=444.600 steps=3600 mean_latency_ms=75.97142616222317 +episode=80 return=444.600 steps=3600 mean_latency_ms=75.97039764106849 +episode=81 return=444.600 steps=3600 mean_latency_ms=75.74469321422862 +episode=82 return=116.200 steps=957 mean_latency_ms=76.0366526049804 +episode=83 return=444.600 steps=3600 mean_latency_ms=75.95924386190674 +episode=84 return=444.600 steps=3600 mean_latency_ms=76.0310580385874 +episode=85 return=36.600 steps=314 mean_latency_ms=75.8634823847272 +episode=86 return=260.900 steps=2125 mean_latency_ms=75.91783880059099 +episode=87 return=444.600 steps=3600 mean_latency_ms=76.16752514785735 +episode=88 return=444.600 steps=3600 mean_latency_ms=75.83331254385584 +episode=89 return=444.600 steps=3600 mean_latency_ms=76.2113387300584 +episode=90 return=444.600 steps=3600 mean_latency_ms=75.8334932097261 +episode=91 return=225.200 steps=1831 mean_latency_ms=75.75618859671614 +episode=92 return=444.600 steps=3600 mean_latency_ms=75.79683788505955 +episode=93 return=180.900 steps=1478 mean_latency_ms=75.96465307644473 +episode=94 return=305.200 steps=2478 mean_latency_ms=75.86565754734926 +episode=95 return=444.600 steps=3600 mean_latency_ms=75.74523644464854 +episode=96 return=444.600 steps=3600 mean_latency_ms=75.94353591524424 +episode=97 return=444.600 steps=3600 mean_latency_ms=75.81927739599219 +episode=98 return=444.600 steps=3600 mean_latency_ms=75.96229410618645 +episode=99 return=444.600 steps=3600 mean_latency_ms=75.94512877548694 +summary latency=profile_sample episodes=100 mean_return=384.824 std_return=116.788 mean_length=3119.3 +/home/ubuntu/lzj/conda/envs/qwenoft/lib/python3.10/multiprocessing/resource_tracker.py:224: UserWarning: resource_tracker: There appear to be 1 leaked semaphore objects to clean up at shutdown + warnings.warn('resource_tracker: There appear to be %d ' diff --git a/latency-aware/demon-attack/demon_attack_fixed_latency_6_200ep_7k2steps_ghost15_2/filter_report.json b/latency-aware/demon-attack/demon_attack_fixed_latency_6_200ep_7k2steps_ghost15_2/filter_report.json new file mode 100644 index 0000000000000000000000000000000000000000..a13a320aeb51fb2152bc843c8453f84d25c4dc74 --- /dev/null +++ b/latency-aware/demon-attack/demon_attack_fixed_latency_6_200ep_7k2steps_ghost15_2/filter_report.json @@ -0,0 +1,19 @@ +{ + "accepted_episodes": 200, + "accepted_train_episodes": 198, + "accepted_val_episodes": 2, + "attempted_episodes": 200, + "preset": "none", + "raw_score_bins": { + "6460-6889": 0, + "6890-7309": 0, + "7310-7999": 0, + "<6460": 200, + ">=8000": 0 + }, + "rejected_episodes": 0, + "train_rows_after_row_filter": 1055141, + "train_rows_before_row_filter": 1056688, + "val_rows_after_row_filter": 9843, + "val_rows_before_row_filter": 9860 +} diff --git a/latency-aware/demon-attack/demon_attack_fixed_latency_6_200ep_7k2steps_ghost15_2/metadata.json b/latency-aware/demon-attack/demon_attack_fixed_latency_6_200ep_7k2steps_ghost15_2/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..7f86fa864318b8ca70630c397e8103b24469597f --- /dev/null +++ b/latency-aware/demon-attack/demon_attack_fixed_latency_6_200ep_7k2steps_ghost15_2/metadata.json @@ -0,0 +1,337 @@ +{ + "action_labels": [ + "NOOP", + "FIRE", + "RIGHT", + "LEFT", + "RIGHTFIRE", + "LEFTFIRE" + ], + "action_layout": "demon_attack_discrete", + "base_prompt": "You are playing Demon Attack from a single game image. Choose exactly one action from: NOOP, FIRE, RIGHT, LEFT, RIGHTFIRE, LEFTFIRE. Survive, avoid enemy fire, and shoot enemies to maximize score.", + "checkpoint_config": { + "actor_critic_share_weights": true, + "actor_worker_gpus": [ + 0 + ], + "adam_beta1": 0.9, + "adam_beta2": 0.999, + "adam_eps": 1e-05, + "adaptive_stddev": true, + "add_latency_info": false, + "algo": "APPO", + "async_rl": true, + "batch_size": 1024, + "batched_sampling": true, + "benchmark": false, + "cli_args": { + "actor_worker_gpus": [ + 0 + ], + "add_latency_info": false, + "algo": "APPO", + "async_rl": true, + "batch_size": 1024, + "batched_sampling": true, + "clip_reward": true, + "device": "gpu", + "env": "latency_demon_attack", + "env_fps": 60.0, + "env_gpu_actions": true, + "env_gpu_observations": true, + "env_id": "ALE/DemonAttack-v5", + "episode_metrics_path": "results/checkpoints/memory/rollout_teacher/demon_attack_teacher_fixed_l6_obs15_seed0/episode_metrics.jsonl", + "eval_deterministic": true, + "eval_episodes": 100, + "eval_max_steps": 7200, + "eval_parallel_envs": 50, + "eval_raw_reward": true, + "experiment": "demon_attack_teacher_fixed_l6_obs15_seed0", + "experiment_summaries_interval": 1, + "fixed_latency_ms": 100.0, + "frame_stack": 4, + "full_action_space": false, + "gae_lambda": 0.95, + "gamma": 0.99, + "gpu_env_batch_size": 512, + "gpu_env_device": "auto", + "hold_policy": "hold", + "keep_checkpoints": 5, + "latency_type": "fixed", + "learning_rate": 0.000303, + "max_episode_steps": 25000, + "max_grad_norm": 0.0, + "max_policy_lag": 300, + "mode": "train", + "noop_max": 30, + "normalize_input": true, + "normalize_returns": true, + "num_batches_per_epoch": 8, + "num_envs_per_worker": 1, + "num_epochs": 2, + "num_policies": 1, + "num_workers": 1, + "obs_fps": 15.0, + "ordering_policy": "latest_ready", + "ppo_clip_ratio": 0.1, + "ppo_clip_value": 0.2, + "recurrence": 32, + "repeat_action_probability": 0.0, + "reset_mode": "fire", + "restart_behavior": "resume", + "rollout": 64, + "save_every_sec": 600, + "screen_size": 84, + "seed": 0, + "simulator": "gpu", + "stats_avg": 100, + "terminal_on_life_loss": true, + "train_dir": "results/checkpoints/memory/rollout_teacher", + "train_for_env_steps": 25000000, + "use_rnn": false, + "value_loss_coeff": 0.5, + "wandb_group": "demon-attack-obs15-fixed_l6", + "wandb_job_type": "sample_factory", + "wandb_project": "latency-sensitive-bench", + "wandb_tags": [ + "memory_rollout_teacher", + "demon-attack", + "teacher", + "fixed", + "fixed_l6", + "obs15", + "seed0" + ], + "with_wandb": true, + "worker_num_splits": 1 + }, + "clip_reward": true, + "command_line": "--mode train --algo APPO --env latency_demon_attack --experiment demon_attack_teacher_fixed_l6_obs15_seed0 --train_dir results/checkpoints/memory/rollout_teacher --restart_behavior resume --device gpu --actor_worker_gpus 0 --env_gpu_observations True --env_gpu_actions True --gpu-env-batch-size 512 --seed 0 --episode_metrics_path results/checkpoints/memory/rollout_teacher/demon_attack_teacher_fixed_l6_obs15_seed0/episode_metrics.jsonl --train_for_env_steps 25000000 --num_workers 1 --num_envs_per_worker 1 --num_policies 1 --batch_size 1024 --rollout 64 --recurrence 32 --num_epochs 2 --num_batches_per_epoch 8 --worker_num_splits 1 --max_policy_lag 300 --learning_rate 0.000303 --gamma 0.99 --gae_lambda 0.95 --ppo_clip_ratio 0.1 --ppo_clip_value 0.2 --value_loss_coeff 0.5 --max_grad_norm 0.0 --save_every_sec 600 --keep_checkpoints 5 --stats_avg 100 --experiment_summaries_interval 1 --batched_sampling True --async_rl True --batched_sampling True --use_rnn False --normalize_returns True --normalize_input True --latency-type fixed --fixed-latency-ms 100.0 --add-latency-info False --eval-episodes 100 --eval-parallel-envs 50 --eval-max-steps 7200 --eval-deterministic True --eval-raw-reward --with_wandb True --wandb_project latency-sensitive-bench --wandb_group demon-attack-obs15-fixed_l6 --wandb_job_type sample_factory --wandb_tags memory_rollout_teacher demon-attack teacher fixed fixed_l6 obs15 seed0 --env_id ALE/DemonAttack-v5 --env-fps 60 --obs-fps 15.0 --screen_size 84 --noop_max 30 --reset-mode fire --frame_stack 4 --terminal_on_life_loss True --clip_reward True --repeat_action_probability 0.0 --full_action_space False --max_episode_steps 25000 --simulator gpu --gpu-env-device auto --hold-policy hold --ordering-policy latest_ready", + "continuous_tanh_scale": 0.0, + "decoder_mlp_layers": [], + "decorrelate_envs_on_one_worker": true, + "decorrelate_experience_max_seconds": 0, + "default_niceness": 0, + "device": "gpu", + "encoder_conv_architecture": "convnet_atari", + "encoder_conv_mlp_layers": [ + 512 + ], + "encoder_mlp_layers": [ + 512, + 512 + ], + "env": "latency_demon_attack", + "env_fps": 60.0, + "env_frameskip": 1, + "env_framestack": 1, + "env_gpu_actions": true, + "env_gpu_observations": true, + "env_id": "ALE/DemonAttack-v5", + "episode_metrics_path": "results/checkpoints/memory/rollout_teacher/demon_attack_teacher_fixed_l6_obs15_seed0/episode_metrics.jsonl", + "eval_deterministic": true, + "eval_env_frameskip": 1, + "eval_episodes": 100, + "eval_latency_raw_frame_values": "0,1,2,3,4,5", + "eval_max_steps": 7200, + "eval_parallel_envs": 50, + "eval_raw_reward": true, + "experiment": "demon_attack_teacher_fixed_l6_obs15_seed0", + "experiment_summaries_interval": 1, + "exploration_loss": "entropy", + "exploration_loss_coeff": 0.003, + "export_env_raw_rgb_frames": false, + "fixed_latency_ms": 100.0, + "flush_summaries_interval": 30, + "force_envs_single_thread": false, + "frame_stack": 4, + "full_action_space": false, + "gae_lambda": 0.95, + "gamma": 0.99, + "git_hash": "bedb62f3a97309f6dacdb6a2953e3312d9776765", + "git_repo_name": "git@github.com:ZihanWang314/latency-sensitive-bench.git", + "gpu_env_batch_size": 512, + "gpu_env_device": "auto", + "heartbeat_interval": 20, + "heartbeat_reporting_interval": 180, + "help": false, + "hold_policy": "hold", + "initial_stddev": 1.0, + "keep_checkpoints": 5, + "kl_loss_coeff": 0.0, + "latency_seed": null, + "latency_type": "fixed", + "learning_rate": 0.000303, + "load_checkpoint_kind": "latest", + "log_to_file": true, + "lr_adaptive_max": 0.01, + "lr_adaptive_min": 1e-06, + "lr_schedule": "linear_decay", + "lr_schedule_kl_threshold": 0.008, + "max_episode_steps": 25000, + "max_grad_norm": 0.0, + "max_latency_ms": null, + "max_pending_actions": null, + "max_policy_lag": 300, + "mean_latency_ms": null, + "min_latency_ms": null, + "mode": "train", + "nonlinearity": "elu", + "noop_max": 30, + "normalize_input": true, + "normalize_input_keys": null, + "normalize_returns": true, + "num_batches_per_epoch": 8, + "num_batches_to_accumulate": 2, + "num_envs_per_worker": 1, + "num_epochs": 2, + "num_policies": 1, + "num_workers": 1, + "obs_fps": 15.0, + "obs_scale": 255.0, + "obs_subtract_mean": 0.0, + "optimizer": "adam", + "ordering_policy": "latest_ready", + "output_dir": "outputs/memory/rollout_teacher/demon_attack/train/teacher/fixed_l6/obs15/seed_0", + "pbt_mix_policies_in_one_env": true, + "pbt_mutation_rate": 0.15, + "pbt_optimize_gamma": false, + "pbt_period_env_steps": 5000000, + "pbt_perturb_max": 1.5, + "pbt_perturb_min": 1.1, + "pbt_replace_fraction": 0.3, + "pbt_replace_reward_gap": 0.1, + "pbt_replace_reward_gap_absolute": 1e-06, + "pbt_start_mutation": 20000000, + "pbt_target_objective": "true_objective", + "pixel_format": "CHW", + "policy_init_gain": 1.0, + "policy_initialization": "orthogonal", + "policy_workers_per_policy": 1, + "ppo_clip_ratio": 0.1, + "ppo_clip_value": 0.2, + "recurrence": 32, + "repeat_action_probability": 0.0, + "reset_mode": "fire", + "restart_behavior": "resume", + "reward_clip": 1000.0, + "reward_scale": 1.0, + "rnn_num_layers": 1, + "rnn_size": 512, + "rnn_type": "gru", + "rollout": 64, + "save_best_after": 100000, + "save_best_every_sec": 5, + "save_best_metric": "reward", + "save_every_sec": 600, + "save_milestones_sec": -1, + "screen_size": 84, + "seed": 0, + "serial_mode": false, + "set_workers_cpu_affinity": true, + "shuffle_minibatches": false, + "simulator": "gpu", + "stats_avg": 100, + "std_latency_ms": null, + "summaries_use_frameskip": true, + "terminal_on_life_loss": true, + "train_dir": "results/checkpoints/memory/rollout_teacher", + "train_for_env_steps": 25000000, + "train_for_seconds": 10000000000, + "use_env_info_cache": false, + "use_record_episode_statistics": false, + "use_rnn": false, + "value_bootstrap": false, + "value_loss_coeff": 0.5, + "vtrace_c": 1.0, + "vtrace_rho": 1.0, + "wandb_group": "demon-attack-obs15-fixed_l6", + "wandb_job_type": "sample_factory", + "wandb_project": "latency-sensitive-bench", + "wandb_tags": [ + "memory_rollout_teacher", + "demon-attack", + "teacher", + "fixed", + "fixed_l6", + "obs15", + "seed0" + ], + "wandb_unique_id": "demon-attack-obs15-fixed_l6-s0", + "wandb_user": null, + "with_pbt": false, + "with_vtrace": false, + "with_wandb": true, + "worker_num_splits": 1 + }, + "checkpoint_experiment_dir": "/lustre/fsw/portfolios/nvr/projects/nvr_lacr_llm/users/zihwang/ghost_ws/ghost15_2_demon/paper_experiment_models/memory/rollout_teachers/demon_attack/train/memory_rollout_teacher:demon_attack:teacher:fixed_l6:fs4:obs15:stride4:seed0", + "checkpoint_path": null, + "checkpoint_train_step": 0, + "config_source": "/lustre/fsw/portfolios/nvr/projects/nvr_lacr_llm/users/zihwang/ghost_ws/ghost15_2_demon/paper_experiment_models/memory/rollout_teachers/demon_attack/train/memory_rollout_teacher:demon_attack:teacher:fixed_l6:fs4:obs15:stride4:seed0/config.json", + "context_image_count": 0, + "context_window": 1, + "env_fps": 60.0, + "env_name": "demon_attack", + "episode_return_field": "episode_raw_return", + "filter_preset": "none", + "filter_report": { + "accepted_episodes": 200, + "accepted_train_episodes": 198, + "accepted_val_episodes": 2, + "attempted_episodes": 200, + "preset": "none", + "raw_score_bins": { + "6460-6889": 0, + "6890-7309": 0, + "7310-7999": 0, + "<6460": 200, + ">=8000": 0 + }, + "rejected_episodes": 0, + "train_rows_after_row_filter": 1055141, + "train_rows_before_row_filter": 1056688, + "val_rows_after_row_filter": 9843, + "val_rows_before_row_filter": 9860 + }, + "frame_stack": 4, + "image_resolution": [ + 210, + 160, + 3 + ], + "image_source": "env_raw_rgb_demon_attack_ghost_trail", + "image_transform": { + "gamma": 1.3, + "ground_fraction": 0.22, + "history_frames": 15, + "image_transform": "demon_attack_ghost_trail", + "min_alpha": 35, + "scroll_px_per_step": 4.0 + }, + "image_transform_prompt_contexts": { + "demon_attack_ghost_trail": " You can see the recent motion of the ship, missiles, and demons in the image. Use it to make your decision.", + "flappy_ghost_trail": " You can see the past motion of the bird in the image. Use it to make your decision." + }, + "latency_override": null, + "latency_source": "checkpoint", + "max_episodes": 200, + "max_steps_per_episode": 7200, + "num_envs": 2048, + "obs_fps": 15.0, + "obs_stride_raw_frames": 4, + "prompt_source": "latency_bench.data.prompts", + "prompt_timing_suffix": " Current action latency is {latency_raw_frames} raw frames ({latency_ms:.2f} ms). The environment runs at {env_fps:g} FPS and observations are emitted at {obs_fps:g} FPS. Choose the best next action.", + "replay_num_envs": 16, + "reward_field": "raw_reward", + "reward_semantics": "raw_reward", + "rows_unit": "decision_step", + "schema_version": 2, + "split_seed": 0, + "total_episodes": 200, + "total_rows": 1064984, + "train_episodes": 198, + "train_rows": 1055141, + "val_episodes": 2, + "val_fraction": 0.1, + "val_rows": 9843 +} diff --git a/latency-aware/demon-attack/demon_attack_fixed_latency_6_200ep_7k2steps_ghost15_2/train.parquet b/latency-aware/demon-attack/demon_attack_fixed_latency_6_200ep_7k2steps_ghost15_2/train.parquet new file mode 100644 index 0000000000000000000000000000000000000000..3334fcc30663cb6ca82eb2037f94a970f30af313 --- /dev/null +++ b/latency-aware/demon-attack/demon_attack_fixed_latency_6_200ep_7k2steps_ghost15_2/train.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5e846a0aad4d9f01334ae54dc8c160aae3a56c22441e5f151e9fb502ca365b8c +size 1697465463 diff --git a/latency-aware/demon-attack/demon_attack_fixed_latency_6_200ep_7k2steps_ghost15_2/val.parquet b/latency-aware/demon-attack/demon_attack_fixed_latency_6_200ep_7k2steps_ghost15_2/val.parquet new file mode 100644 index 0000000000000000000000000000000000000000..ed83f90e15f67ce8f2e9e780aa296f576f3859ed --- /dev/null +++ b/latency-aware/demon-attack/demon_attack_fixed_latency_6_200ep_7k2steps_ghost15_2/val.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fd69cbf030de8478d63714ba04616f15a01a4fd30eca17ce428fc78f505f81a7 +size 15383294 diff --git a/latency-aware/flappy/flappy_fixed_latency_3_200ep_7k2steps_ghost7/metadata.json b/latency-aware/flappy/flappy_fixed_latency_3_200ep_7k2steps_ghost7/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..67553c4caf71dc8c8877ae49ca056cd59ef76751 --- /dev/null +++ b/latency-aware/flappy/flappy_fixed_latency_3_200ep_7k2steps_ghost7/metadata.json @@ -0,0 +1,337 @@ +{ + "action_labels": [ + "NOOP", + "FLAP" + ], + "action_layout": "flappy_discrete", + "base_prompt": "You are playing Flappy Bird. Pass through the pipe gaps and stay alive. Choose the action: NOOP, FLAP.", + "checkpoint_config": { + "actor_critic_share_weights": true, + "actor_worker_gpus": [ + 0 + ], + "adam_beta1": 0.9, + "adam_beta2": 0.999, + "adam_eps": 1e-05, + "adaptive_stddev": true, + "add_latency_info": false, + "algo": "APPO", + "async_rl": true, + "audio_on": false, + "background": "day", + "batch_size": 4096, + "batched_sampling": true, + "benchmark": false, + "bird_color": "yellow", + "cli_args": { + "actor_worker_gpus": [ + 0 + ], + "add_latency_info": false, + "algo": "APPO", + "async_rl": true, + "audio_on": false, + "background": "day", + "batch_size": 4096, + "batched_sampling": true, + "bird_color": "yellow", + "debug": false, + "debug_timelimit_diagnostics": false, + "device": "gpu", + "env": "latency_flappy", + "env_fps": 30.0, + "env_gpu_actions": true, + "env_gpu_observations": true, + "episode_metrics_path": "results/checkpoints/memory/rollout_teacher/flappy_teacher_fixed_l3_obs30_seed0/episode_metrics.jsonl", + "eval_deterministic": true, + "eval_episodes": 100, + "eval_max_steps": 7200, + "eval_parallel_envs": 50, + "experiment": "flappy_teacher_fixed_l3_obs30_seed0", + "experiment_summaries_interval": 1, + "fixed_latency_ms": 100.0, + "frame_stack": 4, + "gae_lambda": 0.95, + "gamma": 0.99, + "gpu_render_batch_size": 128, + "gpu_render_device": "auto", + "gpu_render_profile": false, + "gpu_render_profile_interval": 200, + "gym_id": "FlappyBird-v0", + "hold_policy": "one_frame_then_noop", + "keep_checkpoints": 5, + "latency_type": "fixed", + "learning_rate": 0.00025, + "max_grad_norm": 0.5, + "max_policy_lag": 400, + "mode": "train", + "normalize_input": true, + "normalize_obs": true, + "normalize_returns": true, + "num_batches_per_epoch": 8, + "num_envs_per_worker": 1, + "num_epochs": 8, + "num_policies": 1, + "num_workers": 2, + "obs_fps": 30.0, + "obs_resize": "84,84", + "ordering_policy": "latest_ready", + "pipe_color": "green", + "pipe_gap": 100, + "ppo_clip_ratio": 0.1, + "ppo_clip_value": 0.2, + "recurrence": 1, + "restart_behavior": "resume", + "rollout": 128, + "save_every_sec": 600, + "seed": 0, + "simulator": "gpu", + "stats_avg": 100, + "train_dir": "results/checkpoints/memory/rollout_teacher", + "train_for_env_steps": 25000000, + "use_gpu_render": true, + "use_lidar": false, + "use_rnn": false, + "value_loss_coeff": 0.5, + "wandb_group": "flappy-obs30-fixed_l3", + "wandb_job_type": "sample_factory", + "wandb_project": "latency-sensitive-bench", + "wandb_tags": [ + "memory_rollout_teacher", + "flappy", + "teacher", + "fixed", + "fixed_l3", + "obs30", + "seed0" + ], + "with_wandb": true, + "worker_num_splits": 1 + }, + "command_line": "--mode train --algo APPO --env latency_flappy --experiment flappy_teacher_fixed_l3_obs30_seed0 --train_dir results/checkpoints/memory/rollout_teacher --restart_behavior resume --device gpu --actor_worker_gpus 0 --env_gpu_observations True --env_gpu_actions True --gpu-render-batch-size 128 --seed 0 --episode_metrics_path results/checkpoints/memory/rollout_teacher/flappy_teacher_fixed_l3_obs30_seed0/episode_metrics.jsonl --train_for_env_steps 25000000 --num_workers 2 --num_envs_per_worker 1 --num_policies 1 --batch_size 4096 --rollout 128 --recurrence 1 --num_epochs 8 --num_batches_per_epoch 8 --worker_num_splits 1 --max_policy_lag 400 --learning_rate 0.00025 --gamma 0.99 --gae_lambda 0.95 --ppo_clip_ratio 0.1 --ppo_clip_value 0.2 --value_loss_coeff 0.5 --max_grad_norm 0.5 --save_every_sec 600 --keep_checkpoints 5 --stats_avg 100 --experiment_summaries_interval 1 --batched_sampling True --async_rl True --use_rnn False --normalize_returns True --normalize_input True --latency-type fixed --fixed-latency-ms 100.0 --add-latency-info False --eval-episodes 100 --eval-parallel-envs 50 --eval-max-steps 7200 --eval-deterministic True --with_wandb True --wandb_project latency-sensitive-bench --wandb_group flappy-obs30-fixed_l3 --wandb_job_type sample_factory --wandb_tags memory_rollout_teacher flappy teacher fixed fixed_l3 obs30 seed0 --gym_id FlappyBird-v0 --env-fps 30 --obs-fps 30.0 --use_lidar False --normalize_obs True --audio_on False --obs_resize 84,84 --use-gpu-render True --simulator gpu --gpu-render-device auto --gpu-render-profile False --gpu-render-profile-interval 200 --pipe_gap 100 --bird_color yellow --pipe_color green --background day --frame_stack 4 --debug False --debug-timelimit-diagnostics False --hold-policy one_frame_then_noop --ordering-policy latest_ready", + "continuous_tanh_scale": 0.0, + "debug": false, + "debug_timelimit_diagnostics": false, + "decoder_mlp_layers": [], + "decorrelate_envs_on_one_worker": true, + "decorrelate_experience_max_seconds": 0, + "default_niceness": 0, + "device": "gpu", + "encoder_conv_architecture": "convnet_atari", + "encoder_conv_mlp_layers": [ + 512 + ], + "encoder_mlp_layers": [ + 512, + 512 + ], + "env": "latency_flappy", + "env_fps": 30.0, + "env_frameskip": 1, + "env_framestack": 1, + "env_gpu_actions": true, + "env_gpu_observations": true, + "episode_metrics_path": "results/checkpoints/memory/rollout_teacher/flappy_teacher_fixed_l3_obs30_seed0/episode_metrics.jsonl", + "eval_deterministic": true, + "eval_env_frameskip": 1, + "eval_episodes": 100, + "eval_latency_raw_frame_values": "0,1,2,3,4,5", + "eval_max_steps": 7200, + "eval_parallel_envs": 50, + "eval_raw_reward": false, + "experiment": "flappy_teacher_fixed_l3_obs30_seed0", + "experiment_summaries_interval": 1, + "exploration_loss": "entropy", + "exploration_loss_coeff": 0.003, + "fixed_latency_ms": 100.0, + "flush_summaries_interval": 30, + "force_envs_single_thread": false, + "frame_stack": 4, + "gae_lambda": 0.95, + "gamma": 0.99, + "git_hash": "bedb62f3a97309f6dacdb6a2953e3312d9776765", + "git_repo_name": "git@github.com:ZihanWang314/latency-sensitive-bench.git", + "gpu_render_batch_size": 128, + "gpu_render_device": "auto", + "gpu_render_profile": false, + "gpu_render_profile_interval": 200, + "gym_id": "FlappyBird-v0", + "heartbeat_interval": 20, + "heartbeat_reporting_interval": 180, + "help": false, + "hold_policy": "one_frame_then_noop", + "initial_stddev": 1.0, + "keep_checkpoints": 5, + "kl_loss_coeff": 0.0, + "latency_seed": null, + "latency_type": "fixed", + "learning_rate": 0.00025, + "load_checkpoint_kind": "latest", + "log_to_file": true, + "lr_adaptive_max": 0.01, + "lr_adaptive_min": 1e-06, + "lr_schedule": "linear_decay", + "lr_schedule_kl_threshold": 0.008, + "max_episode_steps": 0, + "max_grad_norm": 0.5, + "max_latency_ms": null, + "max_pending_actions": null, + "max_policy_lag": 400, + "mean_latency_ms": null, + "min_latency_ms": null, + "mode": "train", + "nonlinearity": "elu", + "normalize_input": true, + "normalize_input_keys": null, + "normalize_obs": true, + "normalize_returns": true, + "num_batches_per_epoch": 8, + "num_batches_to_accumulate": 2, + "num_envs_per_worker": 1, + "num_epochs": 8, + "num_policies": 1, + "num_workers": 2, + "obs_fps": 30.0, + "obs_resize": "84,84", + "obs_scale": 255.0, + "obs_subtract_mean": 0.0, + "optimizer": "adam", + "ordering_policy": "latest_ready", + "output_dir": "outputs/memory/rollout_teacher/flappy/train/teacher/fixed_l3/obs30/seed_0", + "pbt_mix_policies_in_one_env": true, + "pbt_mutation_rate": 0.15, + "pbt_optimize_gamma": false, + "pbt_period_env_steps": 5000000, + "pbt_perturb_max": 1.5, + "pbt_perturb_min": 1.1, + "pbt_replace_fraction": 0.3, + "pbt_replace_reward_gap": 0.1, + "pbt_replace_reward_gap_absolute": 1e-06, + "pbt_start_mutation": 20000000, + "pbt_target_objective": "true_objective", + "pipe_color": "green", + "pipe_gap": 100, + "pixel_format": "CHW", + "policy_init_gain": 1.0, + "policy_initialization": "orthogonal", + "policy_workers_per_policy": 1, + "ppo_clip_ratio": 0.1, + "ppo_clip_value": 0.2, + "recurrence": 1, + "restart_behavior": "resume", + "reward_clip": 1000.0, + "reward_scale": 1.0, + "rnn_num_layers": 1, + "rnn_size": 512, + "rnn_type": "gru", + "rollout": 128, + "save_best_after": 100000, + "save_best_every_sec": 5, + "save_best_metric": "reward", + "save_every_sec": 600, + "save_milestones_sec": -1, + "score_limit": -1, + "screen_size": "", + "seed": 0, + "serial_mode": false, + "set_workers_cpu_affinity": true, + "shuffle_minibatches": false, + "simulator": "gpu", + "stats_avg": 100, + "std_latency_ms": null, + "summaries_use_frameskip": true, + "train_dir": "results/checkpoints/memory/rollout_teacher", + "train_for_env_steps": 25000000, + "train_for_seconds": 10000000000, + "use_env_info_cache": false, + "use_gpu_render": true, + "use_lidar": false, + "use_record_episode_statistics": false, + "use_rnn": false, + "value_bootstrap": false, + "value_loss_coeff": 0.5, + "vtrace_c": 1.0, + "vtrace_rho": 1.0, + "wandb_group": "flappy-obs30-fixed_l3", + "wandb_job_type": "sample_factory", + "wandb_project": "latency-sensitive-bench", + "wandb_tags": [ + "memory_rollout_teacher", + "flappy", + "teacher", + "fixed", + "fixed_l3", + "obs30", + "seed0" + ], + "wandb_unique_id": "flappy-obs30-fixed_l3-s0", + "wandb_user": null, + "with_pbt": false, + "with_vtrace": false, + "with_wandb": true, + "worker_num_splits": 1 + }, + "checkpoint_experiment_dir": "/lustre/fsw/portfolios/nvr/projects/nvr_lacr_llm/users/zihwang/ghost_ws/ghost7_flappy/paper_experiment_models/memory/rollout_teachers/flappy/train/memory_rollout_teacher:flappy:teacher:fixed_l3:fs4:obs30:stride1:seed0", + "checkpoint_path": null, + "checkpoint_train_step": 0, + "config_source": "/lustre/fsw/portfolios/nvr/projects/nvr_lacr_llm/users/zihwang/ghost_ws/ghost7_flappy/paper_experiment_models/memory/rollout_teachers/flappy/train/memory_rollout_teacher:flappy:teacher:fixed_l3:fs4:obs30:stride1:seed0/config.json", + "context_image_count": 0, + "context_window": 1, + "env_fps": 30.0, + "env_name": "flappy", + "episode_return_field": "episode_raw_return", + "filter_preset": "none", + "filter_report": { + "accepted_episodes": 10, + "accepted_train_episodes": 10, + "accepted_val_episodes": 0, + "attempted_episodes": 10, + "preset": "none", + "rejected_episodes": 0, + "train_rows_after_row_filter": 72000, + "train_rows_before_row_filter": 72000, + "val_rows_after_row_filter": 0, + "val_rows_before_row_filter": 0 + }, + "frame_stack": 4, + "image_resolution": [ + 512, + 288, + 3 + ], + "image_source": "env_raw_rgb_flappy_ghost_trail", + "image_transform": { + "gamma": 1.3, + "ground_fraction": 0.22, + "history_frames": 7, + "image_transform": "flappy_ghost_trail", + "min_alpha": 35, + "scroll_px_per_step": 4.0 + }, + "image_transform_prompt_contexts": { + "demon_attack_ghost_trail": " You can see the recent motion of the ship, missiles, and demons in the image. Use it to make your decision.", + "flappy_ghost_trail": " You can see the past motion of the bird in the image. Use it to make your decision." + }, + "latency_override": null, + "latency_source": "checkpoint", + "max_episodes": 200, + "max_steps_per_episode": 7200, + "num_envs": 2048, + "obs_fps": 30.0, + "obs_stride_raw_frames": 1, + "prompt_source": "latency_bench.data.prompts", + "prompt_timing_suffix": " Current action latency is {latency_raw_frames} raw frames ({latency_ms:.2f} ms). The environment runs at {env_fps:g} FPS and observations are emitted at {obs_fps:g} FPS. Choose the best next action.", + "replay_num_envs": 16, + "reward_field": "raw_reward", + "reward_semantics": "raw_reward", + "rows_unit": "decision_step", + "schema_version": 2, + "split_seed": 0, + "total_episodes": 200, + "total_rows": 1408142, + "train_episodes": 198, + "train_rows": 1393742, + "val_episodes": 2, + "val_fraction": 0.1, + "val_rows": 14400 +} \ No newline at end of file diff --git a/latency-aware/flappy/flappy_fixed_latency_3_200ep_7k2steps_ghost7/train.parquet b/latency-aware/flappy/flappy_fixed_latency_3_200ep_7k2steps_ghost7/train.parquet new file mode 100644 index 0000000000000000000000000000000000000000..d1f4befd436a95348ffab14311f073a6d3c61d44 --- /dev/null +++ b/latency-aware/flappy/flappy_fixed_latency_3_200ep_7k2steps_ghost7/train.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9e69eef85c5e7fe367e4478f3ef2d754eb17ab6a4b6d1c915adfd3b1ec0b43f6 +size 20650738510 diff --git a/latency-aware/flappy/flappy_fixed_latency_3_200ep_7k2steps_ghost7/val.parquet b/latency-aware/flappy/flappy_fixed_latency_3_200ep_7k2steps_ghost7/val.parquet new file mode 100644 index 0000000000000000000000000000000000000000..635984332d772713866ba3cc86ca72517dddc21e --- /dev/null +++ b/latency-aware/flappy/flappy_fixed_latency_3_200ep_7k2steps_ghost7/val.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7e23d80149600625b96f6d2a9a24619ce2d970cc42a454d2aeafc552d9488819 +size 213718706 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_28.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_28.npz new file mode 100644 index 0000000000000000000000000000000000000000..35ab2f19f564ceb236845de4121bf74f7eb83612 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_28.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b5320a7657c27e5d2fb13b4c4f98c01b94eccbd9fb30bc48bf21f10d32dd7fc5 +size 5029132 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_29.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_29.npz new file mode 100644 index 0000000000000000000000000000000000000000..f6624a0336c4890c01d016f150ef9adbc701f1e0 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_29.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:44480d115355f8a5d76e46c4995fd090bda3a2a69b9b0850d822576e24ddc100 +size 4044802 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_3.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_3.npz new file mode 100644 index 0000000000000000000000000000000000000000..244e88c210596dbd5e93aa9f7137296fcfbe7345 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_3.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:713d0bde7d5ba202d6e49b87b6b92f9f8f265883e98b89f4f64a10f93a8b7b39 +size 4635400 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_30.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_30.npz new file mode 100644 index 0000000000000000000000000000000000000000..501945ebd32d310fcaf59b9cc57201524e1258f7 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_30.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:35564e399d62452ae4ae7bef7a4ab4e7ffd6b7e14bca0b8be411127a1500c9e6 +size 4438534 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_31.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_31.npz new file mode 100644 index 0000000000000000000000000000000000000000..39cc3ed92f66572122d9594d0952de4d782c2a58 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_31.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2e79eb8cac26cbe65bd6bea360aa0235bf8e8c80d590737fb921288c0068fa04 +size 4635400 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_32.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_32.npz new file mode 100644 index 0000000000000000000000000000000000000000..710fc2b9e9bf2fabfcc33a825064ce102547a15d --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_32.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f7616c9ad1a1aa7403578c23962ea8dd47c3c557a0fdeb9be033585e9acf0969 +size 4044802 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_33.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_33.npz new file mode 100644 index 0000000000000000000000000000000000000000..308a3c374427332df3ae8ceafdd5c76a165ab29d --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_33.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f3b742cb21c1f3b570ac7a9d01511008cef31f7455fe360a664890923b1a0141 +size 4832266 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_34.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_34.npz new file mode 100644 index 0000000000000000000000000000000000000000..d91b1a4603447d6e33cc58477c9a9a8ea3bd52af --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_34.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7f7e2931461c4948cfc4bac96c5deea8fd4e11153f1757667f12f9ffdf4ab11a +size 4241668 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_35.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_35.npz new file mode 100644 index 0000000000000000000000000000000000000000..244c27732796ba825a8c3fa0e7d9d1e8448f6f82 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_35.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7f584bc1d0f132de30cf60e46e72992103fd1ed869310b8d80179cf82496ca71 +size 4438534 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_36.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_36.npz new file mode 100644 index 0000000000000000000000000000000000000000..d1aa1572121ccec278c21f4acc181aab568df389 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_36.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:36143726ba26431a4b196e37b5c00e46a83961ec048c451a65c1731108dd9696 +size 4241668 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_37.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_37.npz new file mode 100644 index 0000000000000000000000000000000000000000..de9a7bf3c8600cbe783bb96fefb7609fecdb65a3 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_37.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d727ca4c244ef44d8861b255224ceb49ce0e851148817135353e62023deab5d3 +size 4635400 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_38.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_38.npz new file mode 100644 index 0000000000000000000000000000000000000000..eb2dce39ed28325e2b28a4c29979cb967c75cfd6 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_38.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8eed4560105df8799518ac5d3180875cca4a2d38b4ed7351111e672ac0d92154 +size 4635400 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_39.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_39.npz new file mode 100644 index 0000000000000000000000000000000000000000..536397db371741944de6fe4ac2ee63c664486edf --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_39.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cda5ac3d01bcbac63c9d8903db82e5b6be2e7788ba62f88b0a45a9027f440fab +size 4438534 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_4.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_4.npz new file mode 100644 index 0000000000000000000000000000000000000000..26ae66eafc035d37614c93775e2fa71211faf57e --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_4.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e8900ae34148d591b52a07e35b087a41756dc40875c7fcf07142ac35c886f085 +size 4635400 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_40.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_40.npz new file mode 100644 index 0000000000000000000000000000000000000000..39e75da0360a730a06a25d57aaa026030616c3f6 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_40.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fa4ad02c303feae3cf067bae4b1c65bbfc7be6fe286f7b48980aa3f079fbf717 +size 4438534 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_41.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_41.npz new file mode 100644 index 0000000000000000000000000000000000000000..b3f98e2bc02c49528f7bb1ca6d0775b3c0fe98a0 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_41.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cb76da95fcd05e3ada4d458c2cc497b7f17d28a54bb936e1cb5df38adfcf4445 +size 4241668 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_42.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_42.npz new file mode 100644 index 0000000000000000000000000000000000000000..bafa0da25a896d4261f573cf85aa05d28063cb01 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_42.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dec6fcff4fe73fef8427c965560b3404f544f1d9b6b7edbb3577bbd65377f99b +size 4044802 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_43.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_43.npz new file mode 100644 index 0000000000000000000000000000000000000000..dc735680a166e032cade32900787ff12de0b593b --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_43.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a7aecc5aed769c4cb9a6dff9838730e293e1f056530afb2bdc930c195ef0ac91 +size 4832266 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_44.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_44.npz new file mode 100644 index 0000000000000000000000000000000000000000..cd621bc191e056a20620780a3cece72d974263a0 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_44.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c944511da34496365c5b359db2010c5a0f42d2a6c392e8c4fef67aad540335d8 +size 4241668 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_45.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_45.npz new file mode 100644 index 0000000000000000000000000000000000000000..032d13f99c14d72ff200bfa103c5a7520bb11a3a --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_45.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7d3a1c53e76f89eb6827766842c5269945518d17128c4d306f82e827762d9820 +size 4438534 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_46.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_46.npz new file mode 100644 index 0000000000000000000000000000000000000000..50d4ce236fc53e441b0f1228b0854b92d32076c2 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_46.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a95331f1016895127233337aba7835ec720d5c2086ac101088694ae7bbf0f667 +size 5225998 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_47.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_47.npz new file mode 100644 index 0000000000000000000000000000000000000000..8b86bb00d02cc6433c0b12ed9dae22b861d77648 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_47.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8e9e566ea04f0e7946c73e02d0aedf8008fb46055c6a779ae34852b0987fb2ce +size 4241668 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_48.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_48.npz new file mode 100644 index 0000000000000000000000000000000000000000..c902219ca4d8c830efab9409c77b7584c4c28f4e --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_48.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6e39d49739ea6998183bb739161de0d3bd70b403ea688a91db5ca9b98ed14995 +size 4044802 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_49.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_49.npz new file mode 100644 index 0000000000000000000000000000000000000000..c90e7bdd35561c271ea3cc33fc82e45d2ad53a5b --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_49.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7fef2d9842cabd054be217a5daa37bd8ca3a302e05d04394db979ce75539515e +size 4438534 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_5.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_5.npz new file mode 100644 index 0000000000000000000000000000000000000000..aebd5bf0823b446a83b44257d4b3df1b607382c8 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_5.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b951945f3f698d14e9a37807ca77fbb7bea6afe5334c60c6cb451816cbc47d39 +size 4044802 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_50.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_50.npz new file mode 100644 index 0000000000000000000000000000000000000000..d74a9e81751770d9664b7f8039950dfda7d883c1 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_50.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5ab30ad72cda954e4cfa52344b20500bc392419f5d215cd94f232a108f0f52c3 +size 4438534 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_51.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_51.npz new file mode 100644 index 0000000000000000000000000000000000000000..d972275212e53e10727cbf492dc31703462a1dcf --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_51.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1c9475d8290d78ddd880a39211496b9d95cb9abfd6aac903b61e7c62e3a4653b +size 3847936 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_52.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_52.npz new file mode 100644 index 0000000000000000000000000000000000000000..bc56721f3e635c3c82449c0013032e8f6af79355 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_52.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39832cfa3ead2636b73edd2704a2954fddf9f425aed445fb4f7586fb17860e0b +size 4438534 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_53.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_53.npz new file mode 100644 index 0000000000000000000000000000000000000000..a82187745f5fea1e9d92208b40d8958e17d7bc07 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_53.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:951d80d39c2400fcbc0d384adc342f87994c681fa7cb7f2e988bba9fba66dc61 +size 4832266 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_54.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_54.npz new file mode 100644 index 0000000000000000000000000000000000000000..806de6bc005ff4c0dcfa284dab34eabf5cb5f4b4 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_54.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fc0968808517611c7ebd275e572c954c86d9861c9216a9d1585b955244828965 +size 4241668 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_55.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_55.npz new file mode 100644 index 0000000000000000000000000000000000000000..ee0522526015ef114c505b24c718bcca400ed6a1 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_55.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:730c6716d2a2980ce4e5883fca23b1919f92615a7450f241f75ea08d659fc2d3 +size 4241668 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_56.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_56.npz new file mode 100644 index 0000000000000000000000000000000000000000..39ba4b69c8d7c739b54f389a54f746d859c64ee3 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_56.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:37394a154b2f9c1a7121540c432e9d5bff504e5792c1116c584bf3bb4e6641eb +size 4438534 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_57.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_57.npz new file mode 100644 index 0000000000000000000000000000000000000000..69bc6f9f231ce2c0ff9b7747b26d7eee8cb16b9b --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_57.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7704eaaf40c7a2dcea8b64cfe2d4b3f9e32990c0ebbadeb7d096bec52b7f21f3 +size 4438534 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_58.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_58.npz new file mode 100644 index 0000000000000000000000000000000000000000..a283e8ec1cb62ef165f156cb67525d91bdc64f17 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_58.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:325c1de37a64a8b3d45caa162733f64af3a1ae6906d76a6946d6cdeae9820338 +size 3847936 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_59.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_59.npz new file mode 100644 index 0000000000000000000000000000000000000000..ce59bf54fa336a072e6005d27e75d67f591662e4 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_59.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ee08d0f108943b24d5d0742536916703a409c3c1eaaebf6ccdf73b5a6df97ff8 +size 4438534 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_6.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_6.npz new file mode 100644 index 0000000000000000000000000000000000000000..e6e0fb9e5fbf3e951835f315af083bf4dcd61f26 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_6.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3d080746b440cae809adcee2898c40cdb32044dcd94b628dc1ec16c95d071c0f +size 4536967 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_60.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_60.npz new file mode 100644 index 0000000000000000000000000000000000000000..980eb03d86ba5caca154b6949005aeaab2c31847 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_60.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:55c9255dc842bdf0cea317e564d922cabba74688338aee131147bed1ef4a9125 +size 4241668 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_61.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_61.npz new file mode 100644 index 0000000000000000000000000000000000000000..e7b7bcffc4507b6f039ba932c8ca64afb3bac2ce --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_61.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:379ddbe8eb09d1e55693180c1d5256215d305703903a8b90d182060e5b5b7988 +size 3847936 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_62.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_62.npz new file mode 100644 index 0000000000000000000000000000000000000000..b14577e30a7771c4b3af55d6121c3399c57627db --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_62.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ae3f74dfc9299d71ae86507f408149c402e33b69a5c04058c6a3b940991f647f +size 4832266 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_63.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_63.npz new file mode 100644 index 0000000000000000000000000000000000000000..b456c6e13269bf865178cf9e9e5fc1f5795bde28 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_63.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eb15280fe51fb290e33ff963cd4e952af96c1d08a7b2a25c366c1f0bfc70156d +size 4044802 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_64.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_64.npz new file mode 100644 index 0000000000000000000000000000000000000000..820b2d3b18df6bdefd6ea964e6d585360eba9c12 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_64.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a9cbc2686cb488ac1a40f0c1fff9eb99eb9039a3495f4d229c7127bf74c3a5a7 +size 4438534 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_65.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_65.npz new file mode 100644 index 0000000000000000000000000000000000000000..eefad40b31c4fa644acb80205c3ae8d09c37ffc6 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_65.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7962a5412e474ac2725ca0f011cd4a35b79c337646d5bc951ebe55d4d43ed854 +size 5225998 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_66.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_66.npz new file mode 100644 index 0000000000000000000000000000000000000000..52c22b7a6ce7dc2e21a378401cde7a79b8933ce3 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_66.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:180d71389b17cab2374d25f197811dae597e17bb653cdc1024deab98ce854a18 +size 4438534 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_67.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_67.npz new file mode 100644 index 0000000000000000000000000000000000000000..7c5ab289e6236a5b83ccf8d47657c98cfd9cb1bd --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_67.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e8e212f683c1c7f735f32d77f578759d65ffda99510c5944f9566e2c112a9bec +size 4241668 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_68.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_68.npz new file mode 100644 index 0000000000000000000000000000000000000000..1c0102f2440806183ed2fd21c0c6022647b914be --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_68.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b8588299b74a5ece659f8a98486c11b2d74e30fbb4259758a81579ead261adf5 +size 4635400 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_69.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_69.npz new file mode 100644 index 0000000000000000000000000000000000000000..584ade72430e8b8cabcaf45131a62a0dba797ced --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_69.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ba878963d8a03e4d7ac64b1472ecee1637664766f4b371405e99f868a8d3be56 +size 4241668 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_7.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_7.npz new file mode 100644 index 0000000000000000000000000000000000000000..f3061f69990b8b3724ce8f063780b657f8882f44 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_7.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:204354927c0c97883ef390ab205207e8849686c089983cd79d9c6c311518946f +size 4438534 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_70.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_70.npz new file mode 100644 index 0000000000000000000000000000000000000000..f4b3c49849b2be872a7afaea6cec68bf12f33524 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_70.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c00c035ad562b7430c38677f718c247f1b6f5131a0da4697da79f022c786bf02 +size 4044802 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_71.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_71.npz new file mode 100644 index 0000000000000000000000000000000000000000..bc0950cbf266264a6b5c9903d5d6ed6137917103 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_71.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b675d10a6198f809bf7e899d89b47dc8e0fa8327f6e19c8b0b5dff2206e235e1 +size 4832266 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_72.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_72.npz new file mode 100644 index 0000000000000000000000000000000000000000..7a44b1941365f67cc47bf06028b853c131171a77 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_72.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d3edb3a33a0e624a2b1d32497ee8c3c35b5fbd9115f88f243ae94d4ed6190ecb +size 4241668 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_73.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_73.npz new file mode 100644 index 0000000000000000000000000000000000000000..477d8a84f8469bcc5d5fd47bee856bfa2eec7c8c --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_73.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:91e30e47c4ce5d691c9772fc049929b2a2da6c0307725716eaa1b6ba6fc2b436 +size 4536967 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_74.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_74.npz new file mode 100644 index 0000000000000000000000000000000000000000..b6784a1a1f755946dc45acc91294d7b3e761436e --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_74.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f6419b22ddaa2515991d015168eddca669bfeebcd25642b90e8c6dae60eb89e5 +size 5225998 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_75.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_75.npz new file mode 100644 index 0000000000000000000000000000000000000000..8b83299b92cb54b2adc1e6cc1c958b320b0be64a --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_75.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a1341585bad232ad73347f86ec6ff98fe4c4bf9617823a5abe3ca660d0df63ba +size 4241668 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_76.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_76.npz new file mode 100644 index 0000000000000000000000000000000000000000..a8a2be99e0fc8138a6b5786157512f337abf4642 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_76.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cc7137dbb32da2b7cb6662a5aad049dd437837965bda1ad207decea1b2b9d2a3 +size 4635400 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_77.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_77.npz new file mode 100644 index 0000000000000000000000000000000000000000..dfb97086f3dabe8a8fdcd2bcb74da6c268404903 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_77.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bdd07d47a5da836dd0217ef07701405a2d442da8ed8412b380fa16c06dad7526 +size 4241668 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_78.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_78.npz new file mode 100644 index 0000000000000000000000000000000000000000..b319a18654cd009edfcd9bec7a2c23f01324616c --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_78.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ecebc5966faea7d2c4aee865c96604a8dbfc7a7726cc3774a545960e4942a80d +size 4241668 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_79.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_79.npz new file mode 100644 index 0000000000000000000000000000000000000000..2e42e05cfb867e7eba72dd753b6a7fb981283914 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_79.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:942e4e34b69cca483ff1ef9962209a4f79344e4ecccdda80b7038fb3c269aebf +size 4044802 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_8.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_8.npz new file mode 100644 index 0000000000000000000000000000000000000000..83537ea50d40194289b9c99615fec0b677ebdcd8 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_8.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:09425e9fd5f214318bb041fb476172d44cd367c1a03331ca72367f02ccece425 +size 4241668 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_80.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_80.npz new file mode 100644 index 0000000000000000000000000000000000000000..b8a2a2c7784786324078197612f2c82a8964a2af --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_80.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3e0504d3abc9dafffe588f6f55314f5b4b306323b4254250bbb995862ea848be +size 5127565 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_81.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_81.npz new file mode 100644 index 0000000000000000000000000000000000000000..2cf1136eba24c1a4da91113827bd5f83b83dc3d9 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_81.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:88dbb571d02f53e76f2746104ac10e9a44109183689e05bc20369f86901aa006 +size 4733833 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_82.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_82.npz new file mode 100644 index 0000000000000000000000000000000000000000..a982bdfbbd89dc41941cba99f9ebd958337a0317 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_82.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c7c39bcb495615dfcecfc9e55eed11a0d87a268f222e707240aabe15ed7361b8 +size 4635400 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_83.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_83.npz new file mode 100644 index 0000000000000000000000000000000000000000..2c2aa68de30763db91910a52652a76868c18d27d --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_83.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:163f584763d383b6444e685632c739f70bbe030aff1181a4cfd78b1003b66404 +size 4044802 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_84.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_84.npz new file mode 100644 index 0000000000000000000000000000000000000000..12ca73c043e6d9030e32099228fa4954e7ad8c49 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_84.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b1fedb687e38768c8656792e1e550aa51d3757b8caf89d470cb5b7dd0b637234 +size 3847936 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_85.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_85.npz new file mode 100644 index 0000000000000000000000000000000000000000..840a3348a3b5f4aadf52c99a57c43c4eb1f64506 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_85.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4657b5b6e2226e727ba922c4263285fe5e05f8f1d275312f07b12ac9bf068ed6 +size 4635400 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_86.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_86.npz new file mode 100644 index 0000000000000000000000000000000000000000..ba2669913795f093691f512f48418d5f02a84127 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_86.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6412b826f40f86db6a36a4c4e1669bcb241b8759098303aab061cef46fb9bf8e +size 4438534 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_87.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_87.npz new file mode 100644 index 0000000000000000000000000000000000000000..4204244324b9ed61576a1c698c72033771459c4d --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_87.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c326017ac939b7419cb4582a34b37a1d0c285998e594c48862e469b493a20331 +size 5029132 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_88.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_88.npz new file mode 100644 index 0000000000000000000000000000000000000000..ccdad7db82defc01fb7b369bca0fdb87402ee601 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_88.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d6d8f7fed355f09c3e53b2d85a7306ec2a5179ad2068b159539bb61799f8306c +size 4832266 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_89.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_89.npz new file mode 100644 index 0000000000000000000000000000000000000000..7b5d9d359b5a468d668060a4af4d89b1755f3136 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_89.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f99a96e0e447bebc32cf401d782c55bb121c36ab149ca96bd2096ed3ad8ae1ef +size 3847936 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_9.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_9.npz new file mode 100644 index 0000000000000000000000000000000000000000..3080b9a1ab2c2ce3ed5cba9cf85c9735ee034ff1 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_9.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:970f8d0a2ab9b4dc095246fe15f1e18d698376e785c4a51eccfb36aa8c5b184c +size 3847936 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_90.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_90.npz new file mode 100644 index 0000000000000000000000000000000000000000..87a540825c5b7355781457c7c8f3af52cb6f51fb --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_90.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6c7fa5581c0e14c59896afd5e9cacc6f26e7d1141df63c29a790429211e462b9 +size 4044802 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_91.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_91.npz new file mode 100644 index 0000000000000000000000000000000000000000..7c14ba49c9adfa321f76ce4e348c8c05ad96c753 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_91.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:91c5eb8532c325862df91f90df1e093445c87a7bc895803710d02cfcc0c0e9c2 +size 4832266 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_92.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_92.npz new file mode 100644 index 0000000000000000000000000000000000000000..021500a501cc034dd448ff2674420a7966523b1b --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_92.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:41d874e92f9992a6e8f3dcb5b4925a4c6add49f1235f5c35562a277d986bc19f +size 4340101 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_93.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_93.npz new file mode 100644 index 0000000000000000000000000000000000000000..4b7725d4432b9bdab48435c2952d3d170bb4f8ad --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_93.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ce5a044e1f7812eb74fcc64996523b165cf5e9b883232894868b20100ef93a86 +size 4832266 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_94.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_94.npz new file mode 100644 index 0000000000000000000000000000000000000000..28f5f025bc89d94d2cf63fdd0a58ffd061cb4bc4 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_94.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5e0cb1448719e142d180c5a94ea9ffe78f96470e855e65dc4aab8308943e1374 +size 4438534 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_95.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_95.npz new file mode 100644 index 0000000000000000000000000000000000000000..a75217d74230242af078b8fd6990f4bf1d1f6d5f --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_95.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:438a3b55e03c2f81638919dd4e42eac5c5e4714f7414fc378f8252688bc2c814 +size 4241668 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_96.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_96.npz new file mode 100644 index 0000000000000000000000000000000000000000..76be1a47738745d8808478a67b888ac927be0a60 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_96.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7b9034eaf8daaddac273a8b8551d62c0289a507f65c7b46f6feb37529a0b8d31 +size 4635400 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_97.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_97.npz new file mode 100644 index 0000000000000000000000000000000000000000..f4a1995342cd74090ae29910f001cf895a219eed --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_97.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:303d4768a8b4e3fbae803c4e6f9a2650b37a13a68cd5b00290d1f141791d31e3 +size 4044802 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_98.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_98.npz new file mode 100644 index 0000000000000000000000000000000000000000..b68ac40852da638bef90356799c59633fd87f473 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_98.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:82536395dc50cbe35e3ef84d172470caa4e2d7275f331ce5b947b62c355f703f +size 3847936 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_99.npz b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_99.npz new file mode 100644 index 0000000000000000000000000000000000000000..3134ff1b4848f78af5415611b635462460fb2671 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/raw_npz/train_data_99.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:05a2540c05ff7df5a9fb84b50af74be943d3fe9f05d6dc64f255659bd2b0e778 +size 4635400 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/train_manifest.jsonl b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/train_manifest.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..83da445d6fad0574dc4c6c3f7fef8924c145943e --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/train_manifest.jsonl @@ -0,0 +1,250 @@ +{"npz_path": "raw_npz/train_data_242.npz", "episode_seed": 67, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_232.npz", "episode_seed": 57, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_132.npz", "episode_seed": 202, "episode_length": 53, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_61.npz", "episode_seed": 141, "episode_length": 39, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_176.npz", "episode_seed": 246, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_227.npz", "episode_seed": 52, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_127.npz", "episode_seed": 27, "episode_length": 49, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_63.npz", "episode_seed": 143, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_212.npz", "episode_seed": 37, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_30.npz", "episode_seed": 110, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_224.npz", "episode_seed": 49, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_155.npz", "episode_seed": 225, "episode_length": 49, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_28.npz", "episode_seed": 108, "episode_length": 51, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_94.npz", "episode_seed": 174, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_119.npz", "episode_seed": 199, "episode_length": 44, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_107.npz", "episode_seed": 187, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_85.npz", "episode_seed": 165, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_43.npz", "episode_seed": 123, "episode_length": 49, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_20.npz", "episode_seed": 100, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_27.npz", "episode_seed": 107, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_80.npz", "episode_seed": 160, "episode_length": 52, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_82.npz", "episode_seed": 162, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_249.npz", "episode_seed": 74, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_274.npz", "episode_seed": 99, "episode_length": 39, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_188.npz", "episode_seed": 258, "episode_length": 39, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_83.npz", "episode_seed": 163, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_44.npz", "episode_seed": 124, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_246.npz", "episode_seed": 71, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_255.npz", "episode_seed": 80, "episode_length": 39, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_32.npz", "episode_seed": 112, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_192.npz", "episode_seed": 262, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_139.npz", "episode_seed": 209, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_9.npz", "episode_seed": 9, "episode_length": 39, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_77.npz", "episode_seed": 157, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_217.npz", "episode_seed": 42, "episode_length": 39, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_112.npz", "episode_seed": 192, "episode_length": 44, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_60.npz", "episode_seed": 140, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_51.npz", "episode_seed": 131, "episode_length": 39, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_181.npz", "episode_seed": 251, "episode_length": 49, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_203.npz", "episode_seed": 273, "episode_length": 52, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_21.npz", "episode_seed": 101, "episode_length": 44, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_104.npz", "episode_seed": 184, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_110.npz", "episode_seed": 190, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_228.npz", "episode_seed": 53, "episode_length": 39, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_58.npz", "episode_seed": 138, "episode_length": 39, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_158.npz", "episode_seed": 228, "episode_length": 49, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_54.npz", "episode_seed": 134, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_78.npz", "episode_seed": 158, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_170.npz", "episode_seed": 240, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_95.npz", "episode_seed": 175, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_48.npz", "episode_seed": 128, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_259.npz", "episode_seed": 84, "episode_length": 49, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_106.npz", "episode_seed": 186, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_183.npz", "episode_seed": 253, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_202.npz", "episode_seed": 272, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_169.npz", "episode_seed": 239, "episode_length": 49, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_73.npz", "episode_seed": 153, "episode_length": 46, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_185.npz", "episode_seed": 255, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_171.npz", "episode_seed": 241, "episode_length": 39, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_219.npz", "episode_seed": 44, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_136.npz", "episode_seed": 206, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_93.npz", "episode_seed": 173, "episode_length": 49, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_126.npz", "episode_seed": 26, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_229.npz", "episode_seed": 54, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_267.npz", "episode_seed": 92, "episode_length": 49, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_174.npz", "episode_seed": 244, "episode_length": 50, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_101.npz", "episode_seed": 181, "episode_length": 49, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_251.npz", "episode_seed": 76, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_130.npz", "episode_seed": 200, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_200.npz", "episode_seed": 270, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_125.npz", "episode_seed": 25, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_45.npz", "episode_seed": 125, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_264.npz", "episode_seed": 89, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_52.npz", "episode_seed": 132, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_86.npz", "episode_seed": 166, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_8.npz", "episode_seed": 8, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_108.npz", "episode_seed": 188, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_173.npz", "episode_seed": 243, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_35.npz", "episode_seed": 115, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_240.npz", "episode_seed": 65, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_23.npz", "episode_seed": 103, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_49.npz", "episode_seed": 129, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_74.npz", "episode_seed": 154, "episode_length": 53, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_198.npz", "episode_seed": 268, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_149.npz", "episode_seed": 219, "episode_length": 39, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_36.npz", "episode_seed": 116, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_55.npz", "episode_seed": 135, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_40.npz", "episode_seed": 120, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_37.npz", "episode_seed": 117, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_97.npz", "episode_seed": 177, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_10.npz", "episode_seed": 10, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_22.npz", "episode_seed": 102, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_250.npz", "episode_seed": 75, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_161.npz", "episode_seed": 231, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_218.npz", "episode_seed": 43, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_244.npz", "episode_seed": 69, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_270.npz", "episode_seed": 95, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_50.npz", "episode_seed": 130, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_238.npz", "episode_seed": 63, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_137.npz", "episode_seed": 207, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_75.npz", "episode_seed": 155, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_33.npz", "episode_seed": 113, "episode_length": 49, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_194.npz", "episode_seed": 264, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_142.npz", "episode_seed": 212, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_163.npz", "episode_seed": 233, "episode_length": 48, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_1.npz", "episode_seed": 1, "episode_length": 37, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_117.npz", "episode_seed": 197, "episode_length": 49, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_76.npz", "episode_seed": 156, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_15.npz", "episode_seed": 15, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_260.npz", "episode_seed": 85, "episode_length": 44, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_59.npz", "episode_seed": 139, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_12.npz", "episode_seed": 12, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_29.npz", "episode_seed": 109, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_245.npz", "episode_seed": 70, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_116.npz", "episode_seed": 196, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_208.npz", "episode_seed": 33, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_42.npz", "episode_seed": 122, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_79.npz", "episode_seed": 159, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_262.npz", "episode_seed": 87, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_223.npz", "episode_seed": 48, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_266.npz", "episode_seed": 91, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_204.npz", "episode_seed": 274, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_17.npz", "episode_seed": 17, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_5.npz", "episode_seed": 5, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_13.npz", "episode_seed": 13, "episode_length": 48, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_89.npz", "episode_seed": 169, "episode_length": 39, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_209.npz", "episode_seed": 34, "episode_length": 49, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_105.npz", "episode_seed": 185, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_71.npz", "episode_seed": 151, "episode_length": 49, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_134.npz", "episode_seed": 204, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_150.npz", "episode_seed": 220, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_144.npz", "episode_seed": 214, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_70.npz", "episode_seed": 150, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_24.npz", "episode_seed": 104, "episode_length": 51, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_234.npz", "episode_seed": 59, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_64.npz", "episode_seed": 144, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_7.npz", "episode_seed": 7, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_41.npz", "episode_seed": 121, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_167.npz", "episode_seed": 237, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_210.npz", "episode_seed": 35, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_207.npz", "episode_seed": 32, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_272.npz", "episode_seed": 97, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_133.npz", "episode_seed": 203, "episode_length": 39, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_128.npz", "episode_seed": 28, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_205.npz", "episode_seed": 30, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_88.npz", "episode_seed": 168, "episode_length": 49, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_216.npz", "episode_seed": 41, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_254.npz", "episode_seed": 79, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_18.npz", "episode_seed": 18, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_99.npz", "episode_seed": 179, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_225.npz", "episode_seed": 50, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_196.npz", "episode_seed": 266, "episode_length": 39, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_2.npz", "episode_seed": 2, "episode_length": 50, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_239.npz", "episode_seed": 64, "episode_length": 49, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_6.npz", "episode_seed": 6, "episode_length": 46, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_124.npz", "episode_seed": 24, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_247.npz", "episode_seed": 72, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_103.npz", "episode_seed": 183, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_179.npz", "episode_seed": 249, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_3.npz", "episode_seed": 3, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_184.npz", "episode_seed": 254, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_190.npz", "episode_seed": 260, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_123.npz", "episode_seed": 23, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_222.npz", "episode_seed": 47, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_47.npz", "episode_seed": 127, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_147.npz", "episode_seed": 217, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_135.npz", "episode_seed": 205, "episode_length": 48, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_68.npz", "episode_seed": 148, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_258.npz", "episode_seed": 83, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_273.npz", "episode_seed": 98, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_195.npz", "episode_seed": 265, "episode_length": 51, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_91.npz", "episode_seed": 171, "episode_length": 49, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_235.npz", "episode_seed": 60, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_271.npz", "episode_seed": 96, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_193.npz", "episode_seed": 263, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_141.npz", "episode_seed": 211, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_90.npz", "episode_seed": 170, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_87.npz", "episode_seed": 167, "episode_length": 51, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_154.npz", "episode_seed": 224, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_248.npz", "episode_seed": 73, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_131.npz", "episode_seed": 201, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_34.npz", "episode_seed": 114, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_26.npz", "episode_seed": 106, "episode_length": 44, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_72.npz", "episode_seed": 152, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_56.npz", "episode_seed": 136, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_215.npz", "episode_seed": 40, "episode_length": 49, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_19.npz", "episode_seed": 19, "episode_length": 49, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_159.npz", "episode_seed": 229, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_211.npz", "episode_seed": 36, "episode_length": 49, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_164.npz", "episode_seed": 234, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_109.npz", "episode_seed": 189, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_199.npz", "episode_seed": 269, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_157.npz", "episode_seed": 227, "episode_length": 39, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_148.npz", "episode_seed": 218, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_146.npz", "episode_seed": 216, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_67.npz", "episode_seed": 147, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_118.npz", "episode_seed": 198, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_16.npz", "episode_seed": 16, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_191.npz", "episode_seed": 261, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_230.npz", "episode_seed": 55, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_39.npz", "episode_seed": 119, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_252.npz", "episode_seed": 77, "episode_length": 55, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_213.npz", "episode_seed": 38, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_151.npz", "episode_seed": 221, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_121.npz", "episode_seed": 21, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_25.npz", "episode_seed": 105, "episode_length": 39, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_114.npz", "episode_seed": 194, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_165.npz", "episode_seed": 235, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_11.npz", "episode_seed": 11, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_231.npz", "episode_seed": 56, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_261.npz", "episode_seed": 86, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_201.npz", "episode_seed": 271, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_113.npz", "episode_seed": 193, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_38.npz", "episode_seed": 118, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_189.npz", "episode_seed": 259, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_98.npz", "episode_seed": 178, "episode_length": 39, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_241.npz", "episode_seed": 66, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_236.npz", "episode_seed": 61, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_233.npz", "episode_seed": 58, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_46.npz", "episode_seed": 126, "episode_length": 53, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_145.npz", "episode_seed": 215, "episode_length": 46, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_14.npz", "episode_seed": 14, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_100.npz", "episode_seed": 180, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_220.npz", "episode_seed": 45, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_269.npz", "episode_seed": 94, "episode_length": 39, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_65.npz", "episode_seed": 145, "episode_length": 53, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_81.npz", "episode_seed": 161, "episode_length": 48, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_84.npz", "episode_seed": 164, "episode_length": 39, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_31.npz", "episode_seed": 111, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_172.npz", "episode_seed": 242, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_140.npz", "episode_seed": 210, "episode_length": 37, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_4.npz", "episode_seed": 4, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_120.npz", "episode_seed": 20, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_214.npz", "episode_seed": 39, "episode_length": 49, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_0.npz", "episode_seed": 0, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_111.npz", "episode_seed": 191, "episode_length": 49, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_160.npz", "episode_seed": 230, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_122.npz", "episode_seed": 22, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_263.npz", "episode_seed": 88, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_153.npz", "episode_seed": 223, "episode_length": 39, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_197.npz", "episode_seed": 267, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_138.npz", "episode_seed": 208, "episode_length": 49, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_53.npz", "episode_seed": 133, "episode_length": 49, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_156.npz", "episode_seed": 226, "episode_length": 39, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_162.npz", "episode_seed": 232, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_166.npz", "episode_seed": 236, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_168.npz", "episode_seed": 238, "episode_length": 49, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_178.npz", "episode_seed": 248, "episode_length": 39, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_92.npz", "episode_seed": 172, "episode_length": 44, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_66.npz", "episode_seed": 146, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/val_manifest.jsonl b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/val_manifest.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..525387240bcaed6c0bf14318f85adb686a18be15 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/raw/val_manifest.jsonl @@ -0,0 +1,25 @@ +{"npz_path": "raw_npz/train_data_206.npz", "episode_seed": 31, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_226.npz", "episode_seed": 51, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_57.npz", "episode_seed": 137, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_237.npz", "episode_seed": 62, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_96.npz", "episode_seed": 176, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_182.npz", "episode_seed": 252, "episode_length": 51, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_180.npz", "episode_seed": 250, "episode_length": 47, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_187.npz", "episode_seed": 257, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_186.npz", "episode_seed": 256, "episode_length": 46, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_268.npz", "episode_seed": 93, "episode_length": 39, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_175.npz", "episode_seed": 245, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_143.npz", "episode_seed": 213, "episode_length": 46, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_152.npz", "episode_seed": 222, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_69.npz", "episode_seed": 149, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_265.npz", "episode_seed": 90, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_129.npz", "episode_seed": 29, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_102.npz", "episode_seed": 182, "episode_length": 51, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_221.npz", "episode_seed": 46, "episode_length": 41, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_257.npz", "episode_seed": 82, "episode_length": 39, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_62.npz", "episode_seed": 142, "episode_length": 49, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_253.npz", "episode_seed": 78, "episode_length": 43, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_243.npz", "episode_seed": 68, "episode_length": 37, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_256.npz", "episode_seed": 81, "episode_length": 45, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_115.npz", "episode_seed": 195, "episode_length": 44, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} +{"npz_path": "raw_npz/train_data_177.npz", "episode_seed": 247, "episode_length": 37, "success_once": true, "fixed_latency_ms": 99.05021289731565, "env_fps": 20, "action_horizon": 1} diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/validation/collection.complete.json b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/validation/collection.complete.json new file mode 100644 index 0000000000000000000000000000000000000000..09b65848dcfa1e60483f8fc3831ea4da5dd4cc6c --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/validation/collection.complete.json @@ -0,0 +1,306 @@ +{ + "episodes": 275, + "unique_seeds": 275, + "rows": 12211, + "length_min": 37, + "length_max": 55, + "all_success_once": true, + "state_dim": 7, + "action_dim": 7, + "rgb_shape": [ + 128, + 128, + 6 + ], + "finite_numeric": true, + "latency_raw_frames": 2, + "applied_command_matches_source_issued_action": true, + "action_horizon": 1, + "dagger": false, + "raw_bytes": 1204453838, + "episode_seeds": [ + 0, + 1, + 10, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 11, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 12, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 13, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 14, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 15, + 220, + 221, + 222, + 223, + 224, + 225, + 226, + 227, + 228, + 229, + 16, + 230, + 231, + 232, + 233, + 234, + 235, + 236, + 237, + 238, + 239, + 17, + 240, + 241, + 242, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 18, + 250, + 251, + 252, + 253, + 254, + 255, + 256, + 257, + 258, + 259, + 19, + 260, + 261, + 262, + 263, + 264, + 265, + 266, + 267, + 268, + 269, + 2, + 100, + 270, + 271, + 272, + 273, + 274, + 30, + 31, + 32, + 33, + 34, + 101, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 102, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 103, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 104, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 105, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 106, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 107, + 95, + 96, + 97, + 98, + 99, + 108, + 109, + 3, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 4, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 5, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 6, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 7, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 8, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 9, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179 + ], + "train_episodes": 250, + "val_episodes": 25, + "train_rows": 11119, + "val_rows": 1092, + "teacher_checkpoint": "/home/ubuntu/lzj/mean-profiling/intercept/teacher-publication/checkpoint.pt", + "teacher_sha256": "e47526f03fad3ed251dd78f3cacfba8aa8b60bd1578f40bd7a1393e17298e973", + "fixed_latency_ms": 99.05021289731565, + "conversion_complete": true +} diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/validation/dataset.audit.raw.json b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/validation/dataset.audit.raw.json new file mode 100644 index 0000000000000000000000000000000000000000..4283c267f0ddd5c2ced93fd63c065222b1783bb5 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/validation/dataset.audit.raw.json @@ -0,0 +1,298 @@ +{ + "episodes": 275, + "unique_seeds": 275, + "rows": 12211, + "length_min": 37, + "length_max": 55, + "all_success_once": true, + "state_dim": 7, + "action_dim": 7, + "rgb_shape": [ + 128, + 128, + 6 + ], + "finite_numeric": true, + "latency_raw_frames": 2, + "applied_command_matches_source_issued_action": true, + "action_horizon": 1, + "dagger": false, + "raw_bytes": 1204453838, + "episode_seeds": [ + 0, + 1, + 10, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 11, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 12, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 13, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 14, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 15, + 220, + 221, + 222, + 223, + 224, + 225, + 226, + 227, + 228, + 229, + 16, + 230, + 231, + 232, + 233, + 234, + 235, + 236, + 237, + 238, + 239, + 17, + 240, + 241, + 242, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 18, + 250, + 251, + 252, + 253, + 254, + 255, + 256, + 257, + 258, + 259, + 19, + 260, + 261, + 262, + 263, + 264, + 265, + 266, + 267, + 268, + 269, + 2, + 100, + 270, + 271, + 272, + 273, + 274, + 30, + 31, + 32, + 33, + 34, + 101, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 102, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 103, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 104, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 105, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 106, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 107, + 95, + 96, + 97, + 98, + 99, + 108, + 109, + 3, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 4, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 5, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 6, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 7, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 8, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 9, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179 + ] +} diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/validation/dataset.split.audit.json b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/validation/dataset.split.audit.json new file mode 100644 index 0000000000000000000000000000000000000000..169bed06c93facb10d6116c74d5f49ba91c8671f --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/demonstrations/validation/dataset.split.audit.json @@ -0,0 +1,1388 @@ +{ + "source": "originalTFDS episode_metadata.file_path,shuffle_files=false", + "splits": { + "train": [ + { + "npz_file": "train_data_242.npz", + "episode_seed": 67, + "episode_length": 43 + }, + { + "npz_file": "train_data_232.npz", + "episode_seed": 57, + "episode_length": 45 + }, + { + "npz_file": "train_data_132.npz", + "episode_seed": 202, + "episode_length": 53 + }, + { + "npz_file": "train_data_61.npz", + "episode_seed": 141, + "episode_length": 39 + }, + { + "npz_file": "train_data_176.npz", + "episode_seed": 246, + "episode_length": 45 + }, + { + "npz_file": "train_data_227.npz", + "episode_seed": 52, + "episode_length": 41 + }, + { + "npz_file": "train_data_127.npz", + "episode_seed": 27, + "episode_length": 49 + }, + { + "npz_file": "train_data_63.npz", + "episode_seed": 143, + "episode_length": 41 + }, + { + "npz_file": "train_data_212.npz", + "episode_seed": 37, + "episode_length": 47 + }, + { + "npz_file": "train_data_30.npz", + "episode_seed": 110, + "episode_length": 45 + }, + { + "npz_file": "train_data_224.npz", + "episode_seed": 49, + "episode_length": 45 + }, + { + "npz_file": "train_data_155.npz", + "episode_seed": 225, + "episode_length": 49 + }, + { + "npz_file": "train_data_28.npz", + "episode_seed": 108, + "episode_length": 51 + }, + { + "npz_file": "train_data_94.npz", + "episode_seed": 174, + "episode_length": 45 + }, + { + "npz_file": "train_data_119.npz", + "episode_seed": 199, + "episode_length": 44 + }, + { + "npz_file": "train_data_107.npz", + "episode_seed": 187, + "episode_length": 41 + }, + { + "npz_file": "train_data_85.npz", + "episode_seed": 165, + "episode_length": 47 + }, + { + "npz_file": "train_data_43.npz", + "episode_seed": 123, + "episode_length": 49 + }, + { + "npz_file": "train_data_20.npz", + "episode_seed": 100, + "episode_length": 47 + }, + { + "npz_file": "train_data_27.npz", + "episode_seed": 107, + "episode_length": 43 + }, + { + "npz_file": "train_data_80.npz", + "episode_seed": 160, + "episode_length": 52 + }, + { + "npz_file": "train_data_82.npz", + "episode_seed": 162, + "episode_length": 47 + }, + { + "npz_file": "train_data_249.npz", + "episode_seed": 74, + "episode_length": 47 + }, + { + "npz_file": "train_data_274.npz", + "episode_seed": 99, + "episode_length": 39 + }, + { + "npz_file": "train_data_188.npz", + "episode_seed": 258, + "episode_length": 39 + }, + { + "npz_file": "train_data_83.npz", + "episode_seed": 163, + "episode_length": 41 + }, + { + "npz_file": "train_data_44.npz", + "episode_seed": 124, + "episode_length": 43 + }, + { + "npz_file": "train_data_246.npz", + "episode_seed": 71, + "episode_length": 41 + }, + { + "npz_file": "train_data_255.npz", + "episode_seed": 80, + "episode_length": 39 + }, + { + "npz_file": "train_data_32.npz", + "episode_seed": 112, + "episode_length": 41 + }, + { + "npz_file": "train_data_192.npz", + "episode_seed": 262, + "episode_length": 47 + }, + { + "npz_file": "train_data_139.npz", + "episode_seed": 209, + "episode_length": 43 + }, + { + "npz_file": "train_data_9.npz", + "episode_seed": 9, + "episode_length": 39 + }, + { + "npz_file": "train_data_77.npz", + "episode_seed": 157, + "episode_length": 43 + }, + { + "npz_file": "train_data_217.npz", + "episode_seed": 42, + "episode_length": 39 + }, + { + "npz_file": "train_data_112.npz", + "episode_seed": 192, + "episode_length": 44 + }, + { + "npz_file": "train_data_60.npz", + "episode_seed": 140, + "episode_length": 43 + }, + { + "npz_file": "train_data_51.npz", + "episode_seed": 131, + "episode_length": 39 + }, + { + "npz_file": "train_data_181.npz", + "episode_seed": 251, + "episode_length": 49 + }, + { + "npz_file": "train_data_203.npz", + "episode_seed": 273, + "episode_length": 52 + }, + { + "npz_file": "train_data_21.npz", + "episode_seed": 101, + "episode_length": 44 + }, + { + "npz_file": "train_data_104.npz", + "episode_seed": 184, + "episode_length": 43 + }, + { + "npz_file": "train_data_110.npz", + "episode_seed": 190, + "episode_length": 43 + }, + { + "npz_file": "train_data_228.npz", + "episode_seed": 53, + "episode_length": 39 + }, + { + "npz_file": "train_data_58.npz", + "episode_seed": 138, + "episode_length": 39 + }, + { + "npz_file": "train_data_158.npz", + "episode_seed": 228, + "episode_length": 49 + }, + { + "npz_file": "train_data_54.npz", + "episode_seed": 134, + "episode_length": 43 + }, + { + "npz_file": "train_data_78.npz", + "episode_seed": 158, + "episode_length": 43 + }, + { + "npz_file": "train_data_170.npz", + "episode_seed": 240, + "episode_length": 41 + }, + { + "npz_file": "train_data_95.npz", + "episode_seed": 175, + "episode_length": 43 + }, + { + "npz_file": "train_data_48.npz", + "episode_seed": 128, + "episode_length": 41 + }, + { + "npz_file": "train_data_259.npz", + "episode_seed": 84, + "episode_length": 49 + }, + { + "npz_file": "train_data_106.npz", + "episode_seed": 186, + "episode_length": 45 + }, + { + "npz_file": "train_data_183.npz", + "episode_seed": 253, + "episode_length": 47 + }, + { + "npz_file": "train_data_202.npz", + "episode_seed": 272, + "episode_length": 41 + }, + { + "npz_file": "train_data_169.npz", + "episode_seed": 239, + "episode_length": 49 + }, + { + "npz_file": "train_data_73.npz", + "episode_seed": 153, + "episode_length": 46 + }, + { + "npz_file": "train_data_185.npz", + "episode_seed": 255, + "episode_length": 43 + }, + { + "npz_file": "train_data_171.npz", + "episode_seed": 241, + "episode_length": 39 + }, + { + "npz_file": "train_data_219.npz", + "episode_seed": 44, + "episode_length": 45 + }, + { + "npz_file": "train_data_136.npz", + "episode_seed": 206, + "episode_length": 43 + }, + { + "npz_file": "train_data_93.npz", + "episode_seed": 173, + "episode_length": 49 + }, + { + "npz_file": "train_data_126.npz", + "episode_seed": 26, + "episode_length": 43 + }, + { + "npz_file": "train_data_229.npz", + "episode_seed": 54, + "episode_length": 41 + }, + { + "npz_file": "train_data_267.npz", + "episode_seed": 92, + "episode_length": 49 + }, + { + "npz_file": "train_data_174.npz", + "episode_seed": 244, + "episode_length": 50 + }, + { + "npz_file": "train_data_101.npz", + "episode_seed": 181, + "episode_length": 49 + }, + { + "npz_file": "train_data_251.npz", + "episode_seed": 76, + "episode_length": 47 + }, + { + "npz_file": "train_data_130.npz", + "episode_seed": 200, + "episode_length": 45 + }, + { + "npz_file": "train_data_200.npz", + "episode_seed": 270, + "episode_length": 43 + }, + { + "npz_file": "train_data_125.npz", + "episode_seed": 25, + "episode_length": 43 + }, + { + "npz_file": "train_data_45.npz", + "episode_seed": 125, + "episode_length": 45 + }, + { + "npz_file": "train_data_264.npz", + "episode_seed": 89, + "episode_length": 47 + }, + { + "npz_file": "train_data_52.npz", + "episode_seed": 132, + "episode_length": 45 + }, + { + "npz_file": "train_data_86.npz", + "episode_seed": 166, + "episode_length": 45 + }, + { + "npz_file": "train_data_8.npz", + "episode_seed": 8, + "episode_length": 43 + }, + { + "npz_file": "train_data_108.npz", + "episode_seed": 188, + "episode_length": 43 + }, + { + "npz_file": "train_data_173.npz", + "episode_seed": 243, + "episode_length": 43 + }, + { + "npz_file": "train_data_35.npz", + "episode_seed": 115, + "episode_length": 45 + }, + { + "npz_file": "train_data_240.npz", + "episode_seed": 65, + "episode_length": 43 + }, + { + "npz_file": "train_data_23.npz", + "episode_seed": 103, + "episode_length": 45 + }, + { + "npz_file": "train_data_49.npz", + "episode_seed": 129, + "episode_length": 45 + }, + { + "npz_file": "train_data_74.npz", + "episode_seed": 154, + "episode_length": 53 + }, + { + "npz_file": "train_data_198.npz", + "episode_seed": 268, + "episode_length": 41 + }, + { + "npz_file": "train_data_149.npz", + "episode_seed": 219, + "episode_length": 39 + }, + { + "npz_file": "train_data_36.npz", + "episode_seed": 116, + "episode_length": 43 + }, + { + "npz_file": "train_data_55.npz", + "episode_seed": 135, + "episode_length": 43 + }, + { + "npz_file": "train_data_40.npz", + "episode_seed": 120, + "episode_length": 45 + }, + { + "npz_file": "train_data_37.npz", + "episode_seed": 117, + "episode_length": 47 + }, + { + "npz_file": "train_data_97.npz", + "episode_seed": 177, + "episode_length": 41 + }, + { + "npz_file": "train_data_10.npz", + "episode_seed": 10, + "episode_length": 41 + }, + { + "npz_file": "train_data_22.npz", + "episode_seed": 102, + "episode_length": 45 + }, + { + "npz_file": "train_data_250.npz", + "episode_seed": 75, + "episode_length": 47 + }, + { + "npz_file": "train_data_161.npz", + "episode_seed": 231, + "episode_length": 45 + }, + { + "npz_file": "train_data_218.npz", + "episode_seed": 43, + "episode_length": 45 + }, + { + "npz_file": "train_data_244.npz", + "episode_seed": 69, + "episode_length": 43 + }, + { + "npz_file": "train_data_270.npz", + "episode_seed": 95, + "episode_length": 45 + }, + { + "npz_file": "train_data_50.npz", + "episode_seed": 130, + "episode_length": 45 + }, + { + "npz_file": "train_data_238.npz", + "episode_seed": 63, + "episode_length": 47 + }, + { + "npz_file": "train_data_137.npz", + "episode_seed": 207, + "episode_length": 47 + }, + { + "npz_file": "train_data_75.npz", + "episode_seed": 155, + "episode_length": 43 + }, + { + "npz_file": "train_data_33.npz", + "episode_seed": 113, + "episode_length": 49 + }, + { + "npz_file": "train_data_194.npz", + "episode_seed": 264, + "episode_length": 43 + }, + { + "npz_file": "train_data_142.npz", + "episode_seed": 212, + "episode_length": 43 + }, + { + "npz_file": "train_data_163.npz", + "episode_seed": 233, + "episode_length": 48 + }, + { + "npz_file": "train_data_1.npz", + "episode_seed": 1, + "episode_length": 37 + }, + { + "npz_file": "train_data_117.npz", + "episode_seed": 197, + "episode_length": 49 + }, + { + "npz_file": "train_data_76.npz", + "episode_seed": 156, + "episode_length": 47 + }, + { + "npz_file": "train_data_15.npz", + "episode_seed": 15, + "episode_length": 45 + }, + { + "npz_file": "train_data_260.npz", + "episode_seed": 85, + "episode_length": 44 + }, + { + "npz_file": "train_data_59.npz", + "episode_seed": 139, + "episode_length": 45 + }, + { + "npz_file": "train_data_12.npz", + "episode_seed": 12, + "episode_length": 43 + }, + { + "npz_file": "train_data_29.npz", + "episode_seed": 109, + "episode_length": 41 + }, + { + "npz_file": "train_data_245.npz", + "episode_seed": 70, + "episode_length": 41 + }, + { + "npz_file": "train_data_116.npz", + "episode_seed": 196, + "episode_length": 45 + }, + { + "npz_file": "train_data_208.npz", + "episode_seed": 33, + "episode_length": 41 + }, + { + "npz_file": "train_data_42.npz", + "episode_seed": 122, + "episode_length": 41 + }, + { + "npz_file": "train_data_79.npz", + "episode_seed": 159, + "episode_length": 41 + }, + { + "npz_file": "train_data_262.npz", + "episode_seed": 87, + "episode_length": 47 + }, + { + "npz_file": "train_data_223.npz", + "episode_seed": 48, + "episode_length": 43 + }, + { + "npz_file": "train_data_266.npz", + "episode_seed": 91, + "episode_length": 43 + }, + { + "npz_file": "train_data_204.npz", + "episode_seed": 274, + "episode_length": 47 + }, + { + "npz_file": "train_data_17.npz", + "episode_seed": 17, + "episode_length": 45 + }, + { + "npz_file": "train_data_5.npz", + "episode_seed": 5, + "episode_length": 41 + }, + { + "npz_file": "train_data_13.npz", + "episode_seed": 13, + "episode_length": 48 + }, + { + "npz_file": "train_data_89.npz", + "episode_seed": 169, + "episode_length": 39 + }, + { + "npz_file": "train_data_209.npz", + "episode_seed": 34, + "episode_length": 49 + }, + { + "npz_file": "train_data_105.npz", + "episode_seed": 185, + "episode_length": 43 + }, + { + "npz_file": "train_data_71.npz", + "episode_seed": 151, + "episode_length": 49 + }, + { + "npz_file": "train_data_134.npz", + "episode_seed": 204, + "episode_length": 43 + }, + { + "npz_file": "train_data_150.npz", + "episode_seed": 220, + "episode_length": 47 + }, + { + "npz_file": "train_data_144.npz", + "episode_seed": 214, + "episode_length": 43 + }, + { + "npz_file": "train_data_70.npz", + "episode_seed": 150, + "episode_length": 41 + }, + { + "npz_file": "train_data_24.npz", + "episode_seed": 104, + "episode_length": 51 + }, + { + "npz_file": "train_data_234.npz", + "episode_seed": 59, + "episode_length": 47 + }, + { + "npz_file": "train_data_64.npz", + "episode_seed": 144, + "episode_length": 45 + }, + { + "npz_file": "train_data_7.npz", + "episode_seed": 7, + "episode_length": 45 + }, + { + "npz_file": "train_data_41.npz", + "episode_seed": 121, + "episode_length": 43 + }, + { + "npz_file": "train_data_167.npz", + "episode_seed": 237, + "episode_length": 43 + }, + { + "npz_file": "train_data_210.npz", + "episode_seed": 35, + "episode_length": 43 + }, + { + "npz_file": "train_data_207.npz", + "episode_seed": 32, + "episode_length": 45 + }, + { + "npz_file": "train_data_272.npz", + "episode_seed": 97, + "episode_length": 41 + }, + { + "npz_file": "train_data_133.npz", + "episode_seed": 203, + "episode_length": 39 + }, + { + "npz_file": "train_data_128.npz", + "episode_seed": 28, + "episode_length": 41 + }, + { + "npz_file": "train_data_205.npz", + "episode_seed": 30, + "episode_length": 43 + }, + { + "npz_file": "train_data_88.npz", + "episode_seed": 168, + "episode_length": 49 + }, + { + "npz_file": "train_data_216.npz", + "episode_seed": 41, + "episode_length": 47 + }, + { + "npz_file": "train_data_254.npz", + "episode_seed": 79, + "episode_length": 43 + }, + { + "npz_file": "train_data_18.npz", + "episode_seed": 18, + "episode_length": 43 + }, + { + "npz_file": "train_data_99.npz", + "episode_seed": 179, + "episode_length": 47 + }, + { + "npz_file": "train_data_225.npz", + "episode_seed": 50, + "episode_length": 41 + }, + { + "npz_file": "train_data_196.npz", + "episode_seed": 266, + "episode_length": 39 + }, + { + "npz_file": "train_data_2.npz", + "episode_seed": 2, + "episode_length": 50 + }, + { + "npz_file": "train_data_239.npz", + "episode_seed": 64, + "episode_length": 49 + }, + { + "npz_file": "train_data_6.npz", + "episode_seed": 6, + "episode_length": 46 + }, + { + "npz_file": "train_data_124.npz", + "episode_seed": 24, + "episode_length": 43 + }, + { + "npz_file": "train_data_247.npz", + "episode_seed": 72, + "episode_length": 43 + }, + { + "npz_file": "train_data_103.npz", + "episode_seed": 183, + "episode_length": 43 + }, + { + "npz_file": "train_data_179.npz", + "episode_seed": 249, + "episode_length": 45 + }, + { + "npz_file": "train_data_3.npz", + "episode_seed": 3, + "episode_length": 47 + }, + { + "npz_file": "train_data_184.npz", + "episode_seed": 254, + "episode_length": 43 + }, + { + "npz_file": "train_data_190.npz", + "episode_seed": 260, + "episode_length": 43 + }, + { + "npz_file": "train_data_123.npz", + "episode_seed": 23, + "episode_length": 43 + }, + { + "npz_file": "train_data_222.npz", + "episode_seed": 47, + "episode_length": 45 + }, + { + "npz_file": "train_data_47.npz", + "episode_seed": 127, + "episode_length": 43 + }, + { + "npz_file": "train_data_147.npz", + "episode_seed": 217, + "episode_length": 43 + }, + { + "npz_file": "train_data_135.npz", + "episode_seed": 205, + "episode_length": 48 + }, + { + "npz_file": "train_data_68.npz", + "episode_seed": 148, + "episode_length": 47 + }, + { + "npz_file": "train_data_258.npz", + "episode_seed": 83, + "episode_length": 43 + }, + { + "npz_file": "train_data_273.npz", + "episode_seed": 98, + "episode_length": 47 + }, + { + "npz_file": "train_data_195.npz", + "episode_seed": 265, + "episode_length": 51 + }, + { + "npz_file": "train_data_91.npz", + "episode_seed": 171, + "episode_length": 49 + }, + { + "npz_file": "train_data_235.npz", + "episode_seed": 60, + "episode_length": 45 + }, + { + "npz_file": "train_data_271.npz", + "episode_seed": 96, + "episode_length": 47 + }, + { + "npz_file": "train_data_193.npz", + "episode_seed": 263, + "episode_length": 43 + }, + { + "npz_file": "train_data_141.npz", + "episode_seed": 211, + "episode_length": 47 + }, + { + "npz_file": "train_data_90.npz", + "episode_seed": 170, + "episode_length": 41 + }, + { + "npz_file": "train_data_87.npz", + "episode_seed": 167, + "episode_length": 51 + }, + { + "npz_file": "train_data_154.npz", + "episode_seed": 224, + "episode_length": 47 + }, + { + "npz_file": "train_data_248.npz", + "episode_seed": 73, + "episode_length": 45 + }, + { + "npz_file": "train_data_131.npz", + "episode_seed": 201, + "episode_length": 43 + }, + { + "npz_file": "train_data_34.npz", + "episode_seed": 114, + "episode_length": 43 + }, + { + "npz_file": "train_data_26.npz", + "episode_seed": 106, + "episode_length": 44 + }, + { + "npz_file": "train_data_72.npz", + "episode_seed": 152, + "episode_length": 43 + }, + { + "npz_file": "train_data_56.npz", + "episode_seed": 136, + "episode_length": 45 + }, + { + "npz_file": "train_data_215.npz", + "episode_seed": 40, + "episode_length": 49 + }, + { + "npz_file": "train_data_19.npz", + "episode_seed": 19, + "episode_length": 49 + }, + { + "npz_file": "train_data_159.npz", + "episode_seed": 229, + "episode_length": 43 + }, + { + "npz_file": "train_data_211.npz", + "episode_seed": 36, + "episode_length": 49 + }, + { + "npz_file": "train_data_164.npz", + "episode_seed": 234, + "episode_length": 43 + }, + { + "npz_file": "train_data_109.npz", + "episode_seed": 189, + "episode_length": 47 + }, + { + "npz_file": "train_data_199.npz", + "episode_seed": 269, + "episode_length": 47 + }, + { + "npz_file": "train_data_157.npz", + "episode_seed": 227, + "episode_length": 39 + }, + { + "npz_file": "train_data_148.npz", + "episode_seed": 218, + "episode_length": 47 + }, + { + "npz_file": "train_data_146.npz", + "episode_seed": 216, + "episode_length": 47 + }, + { + "npz_file": "train_data_67.npz", + "episode_seed": 147, + "episode_length": 43 + }, + { + "npz_file": "train_data_118.npz", + "episode_seed": 198, + "episode_length": 41 + }, + { + "npz_file": "train_data_16.npz", + "episode_seed": 16, + "episode_length": 43 + }, + { + "npz_file": "train_data_191.npz", + "episode_seed": 261, + "episode_length": 45 + }, + { + "npz_file": "train_data_230.npz", + "episode_seed": 55, + "episode_length": 41 + }, + { + "npz_file": "train_data_39.npz", + "episode_seed": 119, + "episode_length": 45 + }, + { + "npz_file": "train_data_252.npz", + "episode_seed": 77, + "episode_length": 55 + }, + { + "npz_file": "train_data_213.npz", + "episode_seed": 38, + "episode_length": 45 + }, + { + "npz_file": "train_data_151.npz", + "episode_seed": 221, + "episode_length": 43 + }, + { + "npz_file": "train_data_121.npz", + "episode_seed": 21, + "episode_length": 43 + }, + { + "npz_file": "train_data_25.npz", + "episode_seed": 105, + "episode_length": 39 + }, + { + "npz_file": "train_data_114.npz", + "episode_seed": 194, + "episode_length": 47 + }, + { + "npz_file": "train_data_165.npz", + "episode_seed": 235, + "episode_length": 41 + }, + { + "npz_file": "train_data_11.npz", + "episode_seed": 11, + "episode_length": 41 + }, + { + "npz_file": "train_data_231.npz", + "episode_seed": 56, + "episode_length": 45 + }, + { + "npz_file": "train_data_261.npz", + "episode_seed": 86, + "episode_length": 45 + }, + { + "npz_file": "train_data_201.npz", + "episode_seed": 271, + "episode_length": 45 + }, + { + "npz_file": "train_data_113.npz", + "episode_seed": 193, + "episode_length": 45 + }, + { + "npz_file": "train_data_38.npz", + "episode_seed": 118, + "episode_length": 47 + }, + { + "npz_file": "train_data_189.npz", + "episode_seed": 259, + "episode_length": 41 + }, + { + "npz_file": "train_data_98.npz", + "episode_seed": 178, + "episode_length": 39 + }, + { + "npz_file": "train_data_241.npz", + "episode_seed": 66, + "episode_length": 41 + }, + { + "npz_file": "train_data_236.npz", + "episode_seed": 61, + "episode_length": 47 + }, + { + "npz_file": "train_data_233.npz", + "episode_seed": 58, + "episode_length": 43 + }, + { + "npz_file": "train_data_46.npz", + "episode_seed": 126, + "episode_length": 53 + }, + { + "npz_file": "train_data_145.npz", + "episode_seed": 215, + "episode_length": 46 + }, + { + "npz_file": "train_data_14.npz", + "episode_seed": 14, + "episode_length": 45 + }, + { + "npz_file": "train_data_100.npz", + "episode_seed": 180, + "episode_length": 41 + }, + { + "npz_file": "train_data_220.npz", + "episode_seed": 45, + "episode_length": 41 + }, + { + "npz_file": "train_data_269.npz", + "episode_seed": 94, + "episode_length": 39 + }, + { + "npz_file": "train_data_65.npz", + "episode_seed": 145, + "episode_length": 53 + }, + { + "npz_file": "train_data_81.npz", + "episode_seed": 161, + "episode_length": 48 + }, + { + "npz_file": "train_data_84.npz", + "episode_seed": 164, + "episode_length": 39 + }, + { + "npz_file": "train_data_31.npz", + "episode_seed": 111, + "episode_length": 47 + }, + { + "npz_file": "train_data_172.npz", + "episode_seed": 242, + "episode_length": 45 + }, + { + "npz_file": "train_data_140.npz", + "episode_seed": 210, + "episode_length": 37 + }, + { + "npz_file": "train_data_4.npz", + "episode_seed": 4, + "episode_length": 47 + }, + { + "npz_file": "train_data_120.npz", + "episode_seed": 20, + "episode_length": 41 + }, + { + "npz_file": "train_data_214.npz", + "episode_seed": 39, + "episode_length": 49 + }, + { + "npz_file": "train_data_0.npz", + "episode_seed": 0, + "episode_length": 41 + }, + { + "npz_file": "train_data_111.npz", + "episode_seed": 191, + "episode_length": 49 + }, + { + "npz_file": "train_data_160.npz", + "episode_seed": 230, + "episode_length": 47 + }, + { + "npz_file": "train_data_122.npz", + "episode_seed": 22, + "episode_length": 43 + }, + { + "npz_file": "train_data_263.npz", + "episode_seed": 88, + "episode_length": 41 + }, + { + "npz_file": "train_data_153.npz", + "episode_seed": 223, + "episode_length": 39 + }, + { + "npz_file": "train_data_197.npz", + "episode_seed": 267, + "episode_length": 47 + }, + { + "npz_file": "train_data_138.npz", + "episode_seed": 208, + "episode_length": 49 + }, + { + "npz_file": "train_data_53.npz", + "episode_seed": 133, + "episode_length": 49 + }, + { + "npz_file": "train_data_156.npz", + "episode_seed": 226, + "episode_length": 39 + }, + { + "npz_file": "train_data_162.npz", + "episode_seed": 232, + "episode_length": 45 + }, + { + "npz_file": "train_data_166.npz", + "episode_seed": 236, + "episode_length": 47 + }, + { + "npz_file": "train_data_168.npz", + "episode_seed": 238, + "episode_length": 49 + }, + { + "npz_file": "train_data_178.npz", + "episode_seed": 248, + "episode_length": 39 + }, + { + "npz_file": "train_data_92.npz", + "episode_seed": 172, + "episode_length": 44 + }, + { + "npz_file": "train_data_66.npz", + "episode_seed": 146, + "episode_length": 45 + } + ], + "val": [ + { + "npz_file": "train_data_206.npz", + "episode_seed": 31, + "episode_length": 43 + }, + { + "npz_file": "train_data_226.npz", + "episode_seed": 51, + "episode_length": 41 + }, + { + "npz_file": "train_data_57.npz", + "episode_seed": 137, + "episode_length": 45 + }, + { + "npz_file": "train_data_237.npz", + "episode_seed": 62, + "episode_length": 43 + }, + { + "npz_file": "train_data_96.npz", + "episode_seed": 176, + "episode_length": 47 + }, + { + "npz_file": "train_data_182.npz", + "episode_seed": 252, + "episode_length": 51 + }, + { + "npz_file": "train_data_180.npz", + "episode_seed": 250, + "episode_length": 47 + }, + { + "npz_file": "train_data_187.npz", + "episode_seed": 257, + "episode_length": 41 + }, + { + "npz_file": "train_data_186.npz", + "episode_seed": 256, + "episode_length": 46 + }, + { + "npz_file": "train_data_268.npz", + "episode_seed": 93, + "episode_length": 39 + }, + { + "npz_file": "train_data_175.npz", + "episode_seed": 245, + "episode_length": 43 + }, + { + "npz_file": "train_data_143.npz", + "episode_seed": 213, + "episode_length": 46 + }, + { + "npz_file": "train_data_152.npz", + "episode_seed": 222, + "episode_length": 45 + }, + { + "npz_file": "train_data_69.npz", + "episode_seed": 149, + "episode_length": 43 + }, + { + "npz_file": "train_data_265.npz", + "episode_seed": 90, + "episode_length": 45 + }, + { + "npz_file": "train_data_129.npz", + "episode_seed": 29, + "episode_length": 41 + }, + { + "npz_file": "train_data_102.npz", + "episode_seed": 182, + "episode_length": 51 + }, + { + "npz_file": "train_data_221.npz", + "episode_seed": 46, + "episode_length": 41 + }, + { + "npz_file": "train_data_257.npz", + "episode_seed": 82, + "episode_length": 39 + }, + { + "npz_file": "train_data_62.npz", + "episode_seed": 142, + "episode_length": 49 + }, + { + "npz_file": "train_data_253.npz", + "episode_seed": 78, + "episode_length": 43 + }, + { + "npz_file": "train_data_243.npz", + "episode_seed": 68, + "episode_length": 37 + }, + { + "npz_file": "train_data_256.npz", + "episode_seed": 81, + "episode_length": 45 + }, + { + "npz_file": "train_data_115.npz", + "episode_seed": 195, + "episode_length": 44 + }, + { + "npz_file": "train_data_177.npz", + "episode_seed": 247, + "episode_length": 37 + } + ] + }, + "train_rows": 11119, + "val_rows": 1092, + "unique_seeds": 275, + "split_intersection": 0 +} diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/evidence/collect_intercept.py b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/evidence/collect_intercept.py new file mode 100644 index 0000000000000000000000000000000000000000..f44c4745cd9660c3ff1c2d2ceda7e67c198eea59 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/evidence/collect_intercept.py @@ -0,0 +1,47 @@ +from pathlib import Path +import json, os, subprocess, shutil, hashlib +import numpy as np +from scripts.starvla.collect import _write_mikasa_contract +P=Path('/home/ubuntu/lzj/mean-profiling'); out=P/'intercept'; root=Path('/home/ubuntu/lzj/latency-sensitive-bench'); mikasa=root/'third_party/MIKASA-Robo'; data=out/'data'; data.mkdir() +receipt=json.loads((out/'teacher.upload.json').read_text()); assert receipt['status']=='complete_verified' +checkpoint=receipt['local_checkpoint']; config=out/'teacher.yaml' +collection={'episodes':275,'num_envs':10,'keep_failed':False,'train_split':'train[:250]','val_split':'train[250:275]','fps':20,'horizon':1,'dagger':False,'seed_policy':'native attempted_batch*10 + env_slot, successful unique seeds'} +(data/'provenance.json').write_text(json.dumps({'teacher':receipt,'latency_config':str(config),'fixed_latency_ms':99.05021289731565,'env_fps':20,'obs_fps':20,'effective_latency_raw_frames':2,'collection':collection,'action_labels':'issued actions at admitted request observations','conversion':'original NPZ -> RLDS -> LeRobot'},indent=2)+'\n') +shutil.copy2(config,data/'latency.yaml') +def run(stage,command,gpu): + env=os.environ.copy(); env['CUDA_VISIBLE_DEVICES']=gpu + print(stage,flush=True) + with (out/f'{stage}.log').open('w') as log: + subprocess.run(command,cwd=root,env=env,stdout=log,stderr=subprocess.STDOUT,check=True) +run('rollout',['bash','scripts/tasks/mikasa_intercept_grab_fast/collect_latency.sh','--latency-config',str(config),'--checkpoint',checkpoint,'--path-to-save-data',str(data),'--num-train-data','275','--num-envs','10'],os.environ['CUDA_VISIBLE_DEVICES']) +raw=data/'data_npz/intercept_grab_fast_vla_v0'; files=sorted(raw.glob('train_data_*.npz')); assert len(files)==275 +seeds=[]; lengths=[] +for f in files: + with np.load(f,allow_pickle=False) as ep: + n=ep['episode_length'].item(); seed=ep['episode_seed'].item(); assert ep['success_once'].item() and 10<=n<=60 + assert ep['rgb'].shape==(n,128,128,6) and ep['rgb'].dtype==np.uint8 + assert ep['proprio'].shape==(n,7) and ep['action'].shape==(n,7) + assert np.isfinite(ep['proprio']).all() and np.isfinite(ep['action']).all() and np.isfinite(ep['reward']).all() + admitted=ep['command_admitted']; assert np.array_equal(ep['issued_raw_frame'],np.arange(n)) + assert np.all(ep['ready_raw_frame'][admitted]-ep['issued_raw_frame'][admitted]==2) + source=ep['applied_source_raw_frame']; selected=source>=0 + assert np.all(ep['applied_chunk_index'][selected]==0) + assert np.array_equal(ep['applied_command'][selected],ep['action'][source[selected]]) + seeds.append(seed); lengths.append(n) +assert len(set(seeds))==275 +metadata=json.loads((raw/'metadata.json').read_text()); assert metadata['num_episodes']==275 and set(metadata['episode_seeds'])==set(seeds) +audit={'episodes':275,'unique_seeds':275,'rows':sum(lengths),'length_min':min(lengths),'length_max':max(lengths),'all_success_once':True,'state_dim':7,'action_dim':7,'rgb_shape':[128,128,6],'finite_numeric':True,'latency_raw_frames':2,'applied_command_matches_source_issued_action':True,'action_horizon':1,'dagger':False,'raw_bytes':sum(f.stat().st_size for f in files),'episode_seeds':seeds} +(data/'dataset.audit.raw.json').write_text(json.dumps(audit,indent=2)+'\n') +builder=mikasa/'utils/convert_npz_to_rlds/rlds_dataset_builder/.venv/bin/python'; converter=mikasa/'utils/convert_rlds_to_lerobot/.venv/bin/python' +run('rlds',[str(builder),str(mikasa/'utils/convert_npz_to_rlds/convert_npz_task_to_rlds.py'),'--task','InterceptGrabFast-VLA-v0','--repo-root',str(mikasa),'--npz-root',str(data/'data_npz'),'--rlds-root',str(data/'data_rlds')],'') +for split in ('train','val'): + run('lerobot_'+split,[str(converter),str(mikasa/'utils/convert_rlds_to_lerobot/convert_rlds_to_lerobot.py'),'--task','InterceptGrabFast-VLA-v0','--repo-root',str(mikasa),'--rlds-root',str(data/'data_rlds'),'--lerobot-root',str(data/'data_lerobot'),'--repo-id-template',f'local/{{task}}_h1_{split}','--fps','20','--split',collection[split+'_split']],'') +for split,name,episodes in [('train','lerobot',250),('val','lerobot__val',25)]: + shutil.move(str(data/'data_lerobot/local'/f'intercept_grab_fast_vla_v0_h1_{split}'),str(data/name)) + info=json.loads((data/name/'meta/info.json').read_text()); assert info['total_episodes']==episodes and info['fps']==20 +subprocess.run(['/home/ubuntu/lzj/conda/envs/sf-data/bin/python', '-c', 'from pathlib import Path; from scripts.starvla.collect import _write_mikasa_contract; import sys; _write_mikasa_contract(Path(sys.argv[1]),Path(sys.argv[2]))',str(data/'lerobot'),str(data/'lerobot__val')],cwd=root,check=True) +train=json.loads((data/'lerobot/meta/info.json').read_text()); val=json.loads((data/'lerobot__val/meta/info.json').read_text()); assert train['total_frames']+val['total_frames']==sum(lengths) +robot_type=json.loads((data/'lerobot/task_contract.json').read_text())['robot_type'] +(data/'mixture.json').write_text(json.dumps({'train':[[str(data/'lerobot'),1.0,robot_type]],'validation':[[str(data/'lerobot__val'),1.0,robot_type]]},indent=2)+'\n') +audit.update({'train_episodes':250,'val_episodes':25,'train_rows':train['total_frames'],'val_rows':val['total_frames'],'teacher_checkpoint':checkpoint,'teacher_sha256':hashlib.sha256(Path(checkpoint).read_bytes()).hexdigest(),'fixed_latency_ms':99.05021289731565,'conversion_complete':True}) +(data/'collection.complete.json').write_text(json.dumps(audit,indent=2)+'\n'); print(json.dumps(audit),flush=True) diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/evidence/collector.source.py b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/evidence/collector.source.py new file mode 100644 index 0000000000000000000000000000000000000000..27a9a596fd57746abb7ba1d53fac1d93ead28f43 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/evidence/collector.source.py @@ -0,0 +1,894 @@ +import json +import os +import sys +from dataclasses import dataclass +from pathlib import Path +from typing import Optional + +import gymnasium as gym +import numpy as np +import torch +import tyro +from tqdm import tqdm + +sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "../"))) + +from mani_skill.utils.wrappers import FlattenActionSpaceWrapper +from mani_skill.vector.wrappers.gymnasium import ManiSkillVectorEnv + +import mikasa_robo_suite.vla.memory_envs # noqa: F401 +from baselines.ppo.ppo_memtasks import AgentStateOnly, FlattenRGBDObservationWrapper +from mikasa_robo_suite.seed_reset import reset_seeded_slots +from mikasa_robo_suite.vla.utils.dataset_naming import env_id_to_dataset_name +from mikasa_robo_suite.vla.utils.wrappers import * + +DATA_NPZ_DIRNAME = "data_npz" +BATCHED_TMP_SUBDIR = "_batched" +MIN_EPISODE_LENGTH_TO_SAVE = 10 +DEFAULT_BATCH_SIZE = 10 +BATCH_SIZE_OVERRIDE_BY_ENV = { + "ShellGamePick-VLA-v0": 1, +} + + +def _env_flag_is_true(name: str, default: str = "0") -> bool: + value = os.getenv(name, default) + return str(value).strip().lower() in {"1", "true", "yes", "y", "on"} + + +LOG_EPISODE_LENGTHS = _env_flag_is_true("MIKASA_LOG_EPISODE_LENGTHS", "0") + + +SHELL_GAME_CORE_ENVS = { + "ShellGameTouch-VLA-v0", + "ShellGamePush-VLA-v0", + "ShellGamePick-VLA-v0", +} + +INTERCEPT_ENVS = { + "InterceptSlow-VLA-v0", + "InterceptMedium-VLA-v0", + "InterceptFast-VLA-v0", + "InterceptGrabSlow-VLA-v0", + "InterceptGrabMedium-VLA-v0", + "InterceptGrabFast-VLA-v0", +} + +ROTATE_LENIENT_ENVS = { + "RotateLenientPos-VLA-v0", + "RotateLenientPosNeg-VLA-v0", +} + +ROTATE_STRICT_ENVS = { + "RotateStrictPos-VLA-v0", + "RotateStrictPosNeg-VLA-v0", +} + +COLOR_MEMORY_ENVS = { + "RememberColor3-VLA-v0", + "RememberColor5-VLA-v0", + "RememberColor9-VLA-v0", + "FindImposterColor3-VLA-v0", + "FindImposterColor5-VLA-v0", + "FindImposterColor9-VLA-v0", +} + +SHAPE_MEMORY_ENVS = { + "RememberShape3-VLA-v0", + "RememberShape5-VLA-v0", + "RememberShape9-VLA-v0", + "FindImposterShape3-VLA-v0", + "FindImposterShape5-VLA-v0", + "FindImposterShape9-VLA-v0", +} + +SHAPE_COLOR_MEMORY_ENVS = { + "RememberShapeAndColor3x2-VLA-v0", + "RememberShapeAndColor3x3-VLA-v0", + "RememberShapeAndColor5x3-VLA-v0", + "FindImposterShapeAndColor3x2-VLA-v0", + "FindImposterShapeAndColor3x3-VLA-v0", + "FindImposterShapeAndColor5x3-VLA-v0", +} + +MEMORY_CAPACITY_ENVS = { + "BunchOfColors3-VLA-v0", + "BunchOfColors5-VLA-v0", + "BunchOfColors7-VLA-v0", + "SeqOfColors3-VLA-v0", + "SeqOfColors5-VLA-v0", + "SeqOfColors7-VLA-v0", + "ChainOfColors3-VLA-v0", + "ChainOfColors5-VLA-v0", + "ChainOfColors7-VLA-v0", +} + +SHELL_GAME_LAMP_ENVS = { + "ShellGameShuffleColorLampTouch-VLA-v0", + "ShellGameColorLampTouch-VLA-v0", +} + +EPISODE_TIMEOUT_BY_ENV = { + "ShellGameTouch-VLA-v0": 30, + "ShellGamePush-VLA-v0": 30, + "ShellGamePick-VLA-v0": 30, + "InterceptSlow-VLA-v0": 60, + "InterceptMedium-VLA-v0": 60, + "InterceptFast-VLA-v0": 60, + "InterceptGrabSlow-VLA-v0": 60, + "InterceptGrabMedium-VLA-v0": 60, + "InterceptGrabFast-VLA-v0": 60, + "RotateLenientPos-VLA-v0": 60, + "RotateLenientPosNeg-VLA-v0": 60, + "RotateStrictPos-VLA-v0": 90, + "RotateStrictPosNeg-VLA-v0": 90, + "TakeItBack-VLA-v0": 60, + "RememberColor3-VLA-v0": 25, + "RememberColor5-VLA-v0": 25, + "RememberColor9-VLA-v0": 25, + "RememberShape3-VLA-v0": 25, + "RememberShape5-VLA-v0": 25, + "RememberShape9-VLA-v0": 25, + "RememberShapeAndColor3x2-VLA-v0": 25, + "RememberShapeAndColor3x3-VLA-v0": 25, + "RememberShapeAndColor5x3-VLA-v0": 25, + "BunchOfColors3-VLA-v0": 100, + "BunchOfColors5-VLA-v0": 100, + "BunchOfColors7-VLA-v0": 100, + "SeqOfColors3-VLA-v0": 100, + "SeqOfColors5-VLA-v0": 100, + "SeqOfColors7-VLA-v0": 100, + "ChainOfColors3-VLA-v0": 100, + "ChainOfColors5-VLA-v0": 100, + "ChainOfColors7-VLA-v0": 100, + "ShellGameShuffleTouch-VLA-v0": 60, + "ShellGameShuffleColorLampTouch-VLA-v0": 60, + "ShellGameColorLampTouch-VLA-v0": 30, + "FindImposterColor3-VLA-v0": 25, + "FindImposterColor5-VLA-v0": 25, + "FindImposterColor9-VLA-v0": 25, + "FindImposterShape3-VLA-v0": 25, + "FindImposterShape5-VLA-v0": 25, + "FindImposterShape9-VLA-v0": 25, + "FindImposterShapeAndColor3x2-VLA-v0": 25, + "FindImposterShapeAndColor3x3-VLA-v0": 25, + "FindImposterShapeAndColor5x3-VLA-v0": 40, +} + + +def env_info(env_id: str): + if env_id not in EPISODE_TIMEOUT_BY_ENV: + raise ValueError(f"Unknown environment: {env_id}. Supported envs: {sorted(EPISODE_TIMEOUT_BY_ENV.keys())}") + + if env_id in SHELL_GAME_CORE_ENVS: + wrappers_list = [ + (CurriculumPhaseNoopActionWrapper, {}), + (RenderStepInfoWrapper, {}), + (ShellGameRenderCupInfoWrapper, {}), + (RenderRewardInfoWrapper, {}), + (DebugRewardWrapper, {}), + ] + elif env_id in INTERCEPT_ENVS: + wrappers_list = [ + (RenderStepInfoWrapper, {}), + (RenderRewardInfoWrapper, {}), + (DebugRewardWrapper, {}), + ] + elif env_id in ROTATE_LENIENT_ENVS or env_id in ROTATE_STRICT_ENVS: + wrappers_list = [ + (RenderStepInfoWrapper, {}), + (RenderRewardInfoWrapper, {}), + (RotateRenderAngleInfoWrapper, {}), + (DebugRewardWrapper, {}), + ] + elif env_id == "TakeItBack-VLA-v0": + wrappers_list = [ + (RenderStepInfoWrapper, {}), + (RenderRewardInfoWrapper, {}), + (DebugRewardWrapper, {}), + ] + elif env_id in COLOR_MEMORY_ENVS: + wrappers_list = [ + (CurriculumPhaseNoopActionWrapper, {}), + (RememberColorInfoWrapper, {}), + (RenderStepInfoWrapper, {}), + (RenderRewardInfoWrapper, {}), + (DebugRewardWrapper, {}), + ] + elif env_id in SHAPE_MEMORY_ENVS: + wrappers_list = [ + (CurriculumPhaseNoopActionWrapper, {}), + (RememberShapeInfoWrapper, {}), + (RenderStepInfoWrapper, {}), + (RenderRewardInfoWrapper, {}), + (DebugRewardWrapper, {}), + ] + elif env_id in SHAPE_COLOR_MEMORY_ENVS: + wrappers_list = [ + (CurriculumPhaseNoopActionWrapper, {}), + (RememberShapeAndColorInfoWrapper, {}), + (RenderStepInfoWrapper, {}), + (RenderRewardInfoWrapper, {}), + (DebugRewardWrapper, {}), + ] + elif env_id in MEMORY_CAPACITY_ENVS: + wrappers_list = [ + (CurriculumPhaseNoopActionWrapper, {}), + (MemoryCapacityInfoWrapper, {}), + (RenderStepInfoWrapper, {}), + (RenderRewardInfoWrapper, {}), + (DebugRewardWrapper, {}), + ] + elif env_id == "ShellGameShuffleTouch-VLA-v0": + wrappers_list = [ + (CurriculumPhaseNoopActionWrapper, {}), + (RenderStepInfoWrapper, {}), + (ShellGameRenderCupInfoWrapper, {}), + (RenderRewardInfoWrapper, {}), + (DebugRewardWrapper, {}), + ] + elif env_id in SHELL_GAME_LAMP_ENVS: + wrappers_list = [ + (CurriculumPhaseNoopActionWrapper, {}), + (RenderStepInfoWrapper, {}), + (ShellGameRenderCupInfoWrapper, {}), + (RenderRewardInfoWrapper, {}), + (DebugRewardWrapper, {}), + ] + else: + raise ValueError(f"Unknown environment: {env_id}") + + wrappers_list.insert(0, (StateOnlyTensorToDictWrapper, {})) + return wrappers_list, EPISODE_TIMEOUT_BY_ENV[env_id] + + +def _to_uint8_rgb_batch(rgb_batch: torch.Tensor) -> np.ndarray: + rgb_np = rgb_batch.detach().cpu().numpy() + if rgb_np.dtype == np.uint8: + return rgb_np + + rgb_np = rgb_np.astype(np.float32, copy=False) + max_val = float(np.nanmax(rgb_np)) if rgb_np.size > 0 else 0.0 + if max_val <= 1.0 + 1e-5: + rgb_np = rgb_np * 255.0 + return np.clip(rgb_np, 0.0, 255.0).astype(np.uint8, copy=False) + + +def npz_layout_roots(path_to_save_data: str) -> tuple[Path, Path]: + base = Path(path_to_save_data) + npz_root = base / DATA_NPZ_DIRNAME + batched_root = npz_root / BATCHED_TMP_SUBDIR + return npz_root, batched_root + + +def _extract_language_instruction_single(info: dict) -> str: + if "language_instruction" not in info: + raise KeyError("language_instruction is missing in env info.") + + language = info["language_instruction"] + if isinstance(language, str): + return language + + if isinstance(language, np.ndarray): + if language.ndim == 0: + return str(language.item()) + return str(language.reshape(-1)[0]) + + if isinstance(language, (list, tuple)): + if not language: + raise ValueError("language_instruction list is empty.") + return str(language[0]) + + if torch.is_tensor(language): + if language.ndim == 0: + return str(language.item()) + return str(language.detach().cpu().reshape(-1)[0].item()) + + return str(language) + + +def _to_scalar_bool(x) -> bool: + if isinstance(x, bool): + return x + if torch.is_tensor(x): + return bool(x.reshape(-1)[0].item()) + if isinstance(x, np.ndarray): + return bool(np.asarray(x).reshape(-1)[0]) + return bool(x) + + +def _to_bool_batch(x, batch_size: int) -> np.ndarray: + if torch.is_tensor(x): + arr = x.detach().cpu().numpy() + else: + arr = np.asarray(x) + + if arr.ndim == 0: + return np.full((batch_size,), bool(arr.item()), dtype=np.bool_) + + arr = arr.reshape(-1) + if arr.shape[0] == 1: + return np.full((batch_size,), bool(arr[0]), dtype=np.bool_) + + if arr.shape[0] != batch_size: + raise ValueError(f"Expected batch dimension {batch_size}, got {arr.shape[0]} for bool batch") + + return arr.astype(np.bool_, copy=False) + + +def _extract_language_instruction_batch(info: dict, batch_size: int) -> list[str]: + if "language_instruction" not in info: + raise KeyError("language_instruction is missing in env info.") + + language = info["language_instruction"] + if isinstance(language, str): + return [language for _ in range(batch_size)] + + if torch.is_tensor(language): + language = language.detach().cpu().numpy() + + if isinstance(language, np.ndarray): + if language.ndim == 0: + return [str(language.item()) for _ in range(batch_size)] + flat = language.reshape(-1) + if flat.shape[0] == 1: + return [str(flat[0]) for _ in range(batch_size)] + if flat.shape[0] != batch_size: + raise ValueError(f"Expected batch dimension {batch_size}, got {flat.shape[0]} for language_instruction") + return [str(x) for x in flat] + + if isinstance(language, (list, tuple)): + if len(language) == 1: + return [str(language[0]) for _ in range(batch_size)] + if len(language) != batch_size: + raise ValueError(f"Expected batch dimension {batch_size}, got {len(language)} for language_instruction") + return [str(x) for x in language] + + # Fallback: same value for every env. + return [str(language) for _ in range(batch_size)] + + +def get_list_of_all_checkpoints_available(ckpt_dir: str = "."): + oracle_checkpoints_dir = os.path.join(ckpt_dir, "oracle_checkpoints") + + if not os.path.exists(oracle_checkpoints_dir): + raise FileNotFoundError(f"Directory {oracle_checkpoints_dir} does not exist.") + + # Merge checkpoints from both layouts: + # 1) legacy: oracle_checkpoints//.../final_success_ckpt.pt + # 2) normalized: oracle_checkpoints/ppo_memtasks/state/normalized_dense//.../final_success_ckpt.pt + # Keep one checkpoint per env, preferring newer mtime. + latest_by_env: dict[str, tuple[float, str]] = {} + + def register_checkpoint(env_id: str, ckpt_path: str): + if not env_id: + return + try: + mtime = os.path.getmtime(ckpt_path) + except OSError: + return + + prev = latest_by_env.get(env_id) + if prev is None or mtime >= prev[0]: + latest_by_env[env_id] = (mtime, ckpt_path) + + normalized_dense_dir = os.path.join( + oracle_checkpoints_dir, + "ppo_memtasks", + "state", + "normalized_dense", + ) + if os.path.isdir(normalized_dense_dir): + for env_dir in os.listdir(normalized_dense_dir): + env_path = os.path.join(normalized_dense_dir, env_dir) + if not os.path.isdir(env_path): + continue + for root, _, files in os.walk(env_path): + if "final_success_ckpt.pt" in files: + register_checkpoint(env_dir, os.path.join(root, "final_success_ckpt.pt")) + + skip_top_level = {"ppo_memtasks"} + for env_dir in os.listdir(oracle_checkpoints_dir): + if env_dir in skip_top_level: + continue + env_path = os.path.join(oracle_checkpoints_dir, env_dir) + if not os.path.isdir(env_path): + continue + for root, _, files in os.walk(env_path): + if "final_success_ckpt.pt" in files: + register_checkpoint(env_dir, os.path.join(root, "final_success_ckpt.pt")) + + return [[env_id, ckpt_path] for env_id, (_, ckpt_path) in sorted(latest_by_env.items())] + + +def collect_batched_data_from_ckpt( + env_id: str = "ShellGameTouch-VLA-v0", + checkpoint_path: Optional[str] = None, + path_to_save_data: str = "data_mikasa_robo", + num_train_data: int = 250, + latency_config: Optional[str] = None, + keep_failed: bool = False, + num_envs: Optional[int] = None, +): + """Collect aligned issued labels; keep_failed allows finite smoke collection.""" + + target_successful_episodes = num_train_data + batch_size = BATCH_SIZE_OVERRIDE_BY_ENV.get(env_id, DEFAULT_BATCH_SIZE) + if num_envs is not None: + batch_size = num_envs + + device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + + env_kwargs_state = dict( + obs_mode="state", + control_mode="pd_ee_delta_pose", + render_mode="all", + sim_backend="gpu", + reward_mode="normalized_dense", + ) + + env_kwargs_rgb = dict( + obs_mode="rgb", + control_mode="pd_ee_delta_pose", + render_mode="all", + sim_backend="gpu", + reward_mode="normalized_dense", + ) + + env_state = gym.make(env_id, num_envs=batch_size, **env_kwargs_state) + env_rgb = gym.make(env_id, num_envs=batch_size, **env_kwargs_rgb) + + wrappers_list, episode_timeout = env_info(env_id) + + for wrapper_class, wrapper_kwargs in wrappers_list: + env_state = wrapper_class(env_state, **wrapper_kwargs) + + env_state = FlattenRGBDObservationWrapper( + env_state, + rgb=False, + depth=False, + state=True, + oracle=False, + joints=False, + ) + + for wrapper_class, wrapper_kwargs in wrappers_list: + env_rgb = wrapper_class(env_rgb, **wrapper_kwargs) + + env_rgb = FlattenRGBDObservationWrapper( + env_rgb, + rgb=True, + depth=False, + state=False, + oracle=False, + joints=True, + ) + env_rgb = ConvertJointsToEEFXyzRpyGripperWrapper(env_rgb) + + if isinstance(env_state.action_space, gym.spaces.Dict): + env_state = FlattenActionSpaceWrapper(env_state) + if isinstance(env_rgb.action_space, gym.spaces.Dict): + env_rgb = FlattenActionSpaceWrapper(env_rgb) + + env_state = ManiSkillVectorEnv( + env_state, + batch_size, + ignore_terminations=True, + record_metrics=True, + ) + env_rgb = ManiSkillVectorEnv( + env_rgb, + batch_size, + ignore_terminations=True, + record_metrics=True, + ) + + agent = AgentStateOnly(env_state).to(device) + agent.load_state_dict(torch.load(checkpoint_path, map_location=device)) + agent.eval() + + transport = None + if latency_config is not None: + from latency_bench.core.config import load_config + from training.common.action_latency import ActionLatencyBatch + + config = load_config(latency_config) + transport = ActionLatencyBatch( + config, num_envs=batch_size, device=device, + noop_command=config["env"]["noop_action"], + ) + + dataset_name = env_id_to_dataset_name(env_id) + _, batched_root = npz_layout_roots(path_to_save_data) + save_dir = batched_root / dataset_name + save_dir.mkdir(parents=True, exist_ok=True) + + print( + f"Collecting {target_successful_episodes} episodes for {env_id} " + f"(timeout={episode_timeout}, batch_size={batch_size}, " + f"keep_failed={keep_failed}, min_episode_len={MIN_EPISODE_LENGTH_TO_SAVE}, " + f"log_episode_lengths={int(LOG_EPISODE_LENGTHS)})" + ) + + saved_successful = 0 + attempted_batches = 0 + accepted_batches = 0 + skipped_short_episodes = 0 + + progress = tqdm(total=target_successful_episodes, desc="Saved episodes", unit="ep") + while saved_successful < target_successful_episodes: + remaining_needed = target_successful_episodes - saved_successful + seeds = [attempted_batches * batch_size + i for i in range(batch_size)] + attempted_batches += 1 + + obs_state = reset_seeded_slots(env_state, seeds) + obs_rgb = reset_seeded_slots(env_rgb, seeds) + if transport is not None: + transport.reset() + + rgb_steps = [] + proprio_steps = [] + action_steps = [] + reward_steps = [] + success_steps = [] + done_steps = [] + admitted_steps = [] + applied_steps = [] + ready_steps = [] + applied_source_steps = [] + applied_chunk_steps = [] + + language_by_env: list[Optional[str]] = [None for _ in range(batch_size)] + success_once = np.zeros((batch_size,), dtype=np.bool_) + first_done_step = np.full((batch_size,), -1, dtype=np.int32) + + total_steps = 0 + for step_idx in range(episode_timeout): + rgb_steps.append(_to_uint8_rgb_batch(obs_rgb["rgb"])) + proprio_np = obs_rgb["proprio"].detach().cpu().numpy().astype(np.float32, copy=False) + if proprio_np.ndim != 2 or proprio_np.shape[0] != batch_size or proprio_np.shape[1] != 7: + raise RuntimeError( + "Expected proprio observation shape (batch_size, 7) for " + "eef xyz+rpy+gripper proprio, got " + f"{proprio_np.shape}." + ) + proprio_steps.append(proprio_np) + + with torch.no_grad(): + for key, value in obs_state.items(): + obs_state[key] = value.to(device) + action = agent.get_action(obs_state, deterministic=True) + + action_np = action.detach().cpu().numpy().astype(np.float32, copy=False) + # Clip to [-1, 1] to match what the controller actually receives + # (PDEEPoseController clips internally; store the effective action). + action_np = np.clip(action_np, -1.0, 1.0) + if transport is not None: + admitted = transport.submit(action.clamp(-1, 1)) + action = transport.actions() + admitted_steps.append(admitted.cpu().numpy()) + applied_steps.append(action.cpu().numpy()) + applied_source_steps.append([ + record["source_raw_frame"] for record in transport.last_application + ]) + applied_chunk_steps.append([ + record["chunk_index"] for record in transport.last_application + ]) + ready_steps.append([ + record["ready_raw_frame"] if record is not None else -1 + for record in transport.last_submission + ]) + obs_state, _, _, _, _ = env_state.step(action) + obs_rgb, reward_rgb, term_rgb, trunc_rgb, info_rgb = env_rgb.step(action) + if transport is not None: + transport.advance() + transport.reset(torch.nonzero(term_rgb | trunc_rgb).flatten().tolist()) + + batch_language = _extract_language_instruction_batch(info_rgb, batch_size) + for i, lang in enumerate(batch_language): + if language_by_env[i] is None: + language_by_env[i] = lang + + reward_np = reward_rgb.detach().cpu().numpy().reshape(-1).astype(np.float32, copy=False) + success_np = _to_bool_batch(info_rgb["success"], batch_size) + term_np = _to_bool_batch(term_rgb, batch_size) + trunc_np = _to_bool_batch(trunc_rgb, batch_size) + done_np = np.logical_or(np.logical_or(term_np, trunc_np), success_np) + + success_once = np.logical_or(success_once, success_np) + + just_finished = np.logical_and(done_np, first_done_step < 0) + if np.any(just_finished): + first_done_step[just_finished] = step_idx + 1 + + action_steps.append(action_np) + reward_steps.append(reward_np) + success_steps.append(success_np.astype(np.int32, copy=False)) + done_steps.append(done_np.astype(np.int32, copy=False)) + + total_steps = step_idx + 1 + if np.all(first_done_step >= 0): + break + + episode_lengths = np.where(first_done_step > 0, first_done_step, total_steps).astype(np.int32, copy=False) + max_to_take = min(batch_size, remaining_needed) + batch_all_success = bool(np.all(success_once)) + + if LOG_EPISODE_LENGTHS: + for env_idx in range(batch_size): + ep_len = int(episode_lengths[env_idx]) + ep_success = bool(success_once[env_idx]) + is_short = ep_len < MIN_EPISODE_LENGTH_TO_SAVE + + if not ep_success: + reason = "unsuccessful" + saved_flag = 0 + elif is_short: + reason = "too_short" + saved_flag = 0 + elif env_idx >= max_to_take: + reason = "extra_for_target" + saved_flag = 0 + elif not batch_all_success: + reason = "batch_not_full_success" + saved_flag = 0 + else: + reason = "saved" + saved_flag = 1 + + print( + f"[EPISODE] env={env_id} batch_attempt={attempted_batches} idx={env_idx} " + f"seed={seeds[env_idx]} length={ep_len} success={int(ep_success)} " + f"saved={saved_flag} reason={reason}", + flush=True, + ) + + if not batch_all_success and not keep_failed: + progress.set_postfix(attempted_batches=attempted_batches, accepted_batches=accepted_batches) + continue + + # Convert step-major lists into arrays: (T, B, ...) + rgb_arr = np.stack(rgb_steps, axis=0) + proprio_arr = np.stack(proprio_steps, axis=0) + action_arr = np.stack(action_steps, axis=0) + reward_arr = np.stack(reward_steps, axis=0) + success_arr = np.stack(success_steps, axis=0) + done_arr = np.stack(done_steps, axis=0) + + episodes_in_this_batch = [] + for env_idx in range(max_to_take): + ep_len = int(episode_lengths[env_idx]) + if ep_len < MIN_EPISODE_LENGTH_TO_SAVE and not keep_failed: + skipped_short_episodes += 1 + continue + + language_instruction = language_by_env[env_idx] + if language_instruction is None: + raise RuntimeError("Failed to capture language_instruction for at least one env in batch.") + + episode_data = { + "rgb": rgb_arr[:ep_len, env_idx].astype(np.uint8, copy=False), + "proprio": proprio_arr[:ep_len, env_idx].astype(np.float32, copy=False), + "action": action_arr[:ep_len, env_idx].astype(np.float32, copy=False), + "reward": reward_arr[:ep_len, env_idx].astype(np.float32, copy=False), + "success": success_arr[:ep_len, env_idx].astype(np.int32, copy=False), + "done": done_arr[:ep_len, env_idx].astype(np.int32, copy=False), + "language_instruction": np.array(language_instruction, dtype=np.str_), + "success_once": np.array(success_once[env_idx], dtype=np.bool_), + "episode_length": np.array(ep_len, dtype=np.int32), + "episode_seed": np.array(seeds[env_idx], dtype=np.int64), + } + if transport is not None: + episode_data.update( + command_admitted=np.stack(admitted_steps)[:ep_len, env_idx], + applied_command=np.stack(applied_steps)[:ep_len, env_idx], + applied_source_raw_frame=np.asarray(applied_source_steps)[:ep_len, env_idx], + applied_chunk_index=np.asarray(applied_chunk_steps)[:ep_len, env_idx], + issued_raw_frame=np.arange(ep_len, dtype=np.int64), + ready_raw_frame=np.asarray(ready_steps)[:ep_len, env_idx], + latency_config=np.array(str(Path(latency_config).resolve())), + resolved_latency_config=np.array(json.dumps(config, sort_keys=True)), + teacher_checkpoint=np.array(str(Path(checkpoint_path).resolve())), + ) + episodes_in_this_batch.append(episode_data) + + if len(episodes_in_this_batch) == 0: + progress.set_postfix( + attempted_batches=attempted_batches, + accepted_batches=accepted_batches, + skipped_short=skipped_short_episodes, + ) + continue + + accepted_batches += 1 + batch_payload = np.array(episodes_in_this_batch, dtype=object) + batch_file = save_dir / f"train_data_batch_{accepted_batches - 1}.npz" + np.savez( + batch_file, + episode_data=batch_payload, + batch_size=np.array(len(episodes_in_this_batch), dtype=np.int32), + all_success_once=np.array(batch_all_success, dtype=np.bool_), + ) + + saved_successful += len(episodes_in_this_batch) + progress.update(len(episodes_in_this_batch)) + progress.set_postfix( + attempted_batches=attempted_batches, + accepted_batches=accepted_batches, + skipped_short=skipped_short_episodes, + ) + + progress.close() + env_state.close() + env_rgb.close() + + print( + f"Saved {saved_successful} episodes " + f"(attempted_batches={attempted_batches}, accepted_batches={accepted_batches}, " + f"skipped_short={skipped_short_episodes}) to {save_dir}" + ) + + +def collect_unbatched_data_from_batched( + env_id: str = "ShellGameTouch-VLA-v0", + path_to_save_data: str = "data_mikasa_robo", + keep_failed: bool = False, +): + dataset_name = env_id_to_dataset_name(env_id) + npz_root, batched_root = npz_layout_roots(path_to_save_data) + batched_dir = batched_root / dataset_name + unbatched_dir = npz_root / dataset_name + unbatched_dir.mkdir(parents=True, exist_ok=True) + + batch_files = sorted(batched_dir.glob("train_data_*.npz")) + print(f"Unbatching {batched_dir}, {len(batch_files)} files") + + episode_lengths = [] + success_once_list = [] + reward_sums = [] + seeds = [] + + traj_idx = 0 + for batch_file in tqdm(batch_files): + npz_obj = np.load(batch_file, allow_pickle=True) + data = {key: npz_obj[key] for key in npz_obj.keys()} + + if "episode_data" in data: + episodes = list(np.asarray(data["episode_data"], dtype=object).reshape(-1)) + for episode_data in episodes: + success_once = episode_data["success_once"].item() + if not success_once and not keep_failed: + continue + + ep_len = episode_data["episode_length"].item() + if ep_len < MIN_EPISODE_LENGTH_TO_SAVE and not keep_failed: + continue + + out_file = unbatched_dir / f"train_data_{traj_idx}.npz" + np.savez(out_file, **episode_data) + + ep_reward_sum = float(np.asarray(episode_data["reward"], dtype=np.float32).sum()) + ep_seed = episode_data["episode_seed"].item() + + episode_lengths.append(ep_len) + success_once_list.append(success_once) + reward_sums.append(ep_reward_sum) + seeds.append(ep_seed) + traj_idx += 1 + else: + # Backward compatibility with old format (one episode per .npz file) + success_once = bool(data.get("success_once", np.array(False)).reshape(-1)[0]) + if not success_once: + continue + + ep_len = int(data.get("episode_length", np.array(data["action"].shape[0])).reshape(-1)[0]) + if ep_len < MIN_EPISODE_LENGTH_TO_SAVE: + continue + + out_file = unbatched_dir / f"train_data_{traj_idx}.npz" + np.savez(out_file, **data) + + ep_reward_sum = float(np.asarray(data["reward"], dtype=np.float32).sum()) + ep_seed = int(data.get("episode_seed", np.array(-1)).reshape(-1)[0]) + + episode_lengths.append(ep_len) + success_once_list.append(True) + reward_sums.append(ep_reward_sum) + seeds.append(ep_seed) + traj_idx += 1 + + metadata = { + "env_id": env_id, + "num_episodes": len(episode_lengths), + "episode_lengths": episode_lengths, + "success_once": success_once_list, + "reward_sums": reward_sums, + "episode_seeds": seeds, + "batched_source_dir": str(batched_dir), + "unbatched_dir": str(unbatched_dir), + } + metadata_path = unbatched_dir / "metadata.json" + with open(metadata_path, "w", encoding="utf-8") as f: + json.dump(metadata, f, ensure_ascii=False, indent=2) + + # Remove only batched files here. Caller can delete dir if it becomes empty. + for batch_file in batch_files: + try: + batch_file.unlink() + except FileNotFoundError: + pass + + +def maybe_remove_empty_batched_dir(env_id: str, path_to_save_data: str = "data_mikasa_robo"): + dataset_name = env_id_to_dataset_name(env_id) + _, batched_root = npz_layout_roots(path_to_save_data) + batched_dir = batched_root / dataset_name + if batched_dir.exists() and batched_dir.is_dir() and not any(batched_dir.iterdir()): + batched_dir.rmdir() + print(f"Deleted empty batched dir: {batched_dir}") + if batched_root.exists() and batched_root.is_dir() and not any(batched_root.iterdir()): + batched_root.rmdir() + print(f"Deleted empty temporary batched root: {batched_root}") + + +def collect_for_env( + env_id: str, + checkpoint: str, + path_to_save_data: str, + num_train_data: int, + latency_config: Optional[str] = None, + keep_failed: bool = False, + num_envs: Optional[int] = None, +): + collect_batched_data_from_ckpt( + env_id=env_id, + checkpoint_path=checkpoint, + path_to_save_data=path_to_save_data, + num_train_data=num_train_data, + latency_config=latency_config, + keep_failed=keep_failed, + num_envs=num_envs, + ) + + collect_unbatched_data_from_batched( + env_id=env_id, + path_to_save_data=path_to_save_data, + keep_failed=keep_failed, + ) + + maybe_remove_empty_batched_dir(env_id=env_id, path_to_save_data=path_to_save_data) + + +@dataclass +class Args: + env_id: Optional[str] = "ShellGameTouch-VLA-v0" + path_to_save_data: str = "data_mikasa_robo" + ckpt_dir: str = "." + num_train_data: int = 250 + checkpoint: Optional[str] = None + latency_config: Optional[str] = None + keep_failed: bool = False + num_envs: Optional[int] = None + + +if __name__ == "__main__": + args = tyro.cli(Args) + + if args.checkpoint is not None: + checkpoint_map = {args.env_id: args.checkpoint} + else: + checkpoints = get_list_of_all_checkpoints_available(ckpt_dir=args.ckpt_dir) + checkpoint_map = {env: ckpt for env, ckpt in checkpoints} + + print(f"Collecting data for {args.env_id} from {checkpoint_map[args.env_id]}") + collect_for_env( + env_id=args.env_id, + checkpoint=checkpoint_map[args.env_id], + path_to_save_data=args.path_to_save_data, + num_train_data=args.num_train_data, + latency_config=args.latency_config, + keep_failed=args.keep_failed, + num_envs=args.num_envs, + ) + +# python3 mikasa_robo_suite/vla/dataset_collectors/get_mikasa_robo_datasets.py --env-id=ShellGameTouch-VLA-v0 --path-to-save-data=data_mikasa_robo --ckpt-dir=. --num-train-data=250 diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/evidence/convert_npz_task_to_rlds.py b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/evidence/convert_npz_task_to_rlds.py new file mode 100644 index 0000000000000000000000000000000000000000..302dbd343c7c4dc6096501aab4476086957dfc89 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/evidence/convert_npz_task_to_rlds.py @@ -0,0 +1,158 @@ +#!/usr/bin/env python3 +"""Convert one MIKASA .npz task directory into RLDS artifacts.""" + +from __future__ import annotations + +import argparse +import os +import shutil +import subprocess +import sys +import tempfile +from pathlib import Path + +# Import the naming helper directly, bypassing mikasa_robo_suite package __init__ +# so this converter can run in a lightweight venv without sapien/mani_skill. +sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "mikasa_robo_suite" / "vla" / "utils")) +from dataset_naming import env_id_to_dataset_name # noqa: E402 + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser(description="Convert MIKASA-Robo-VLA task from .npz episodes to RLDS.") + parser.add_argument( + "--task", + required=True, + help=( + "Task folder name under data_mikasa_robo/data_npz " + "(gym env_id like 'RememberColor3-VLA-v0' or snake_case 'remember_color_3_vla_v0')." + ), + ) + parser.add_argument( + "--repo-root", + default=None, + help="Path to MIKASA-Robo root. Defaults to auto-detect from script location.", + ) + parser.add_argument( + "--npz-root", + default="data_mikasa_robo/data_npz", + help="Relative path (from repo root) to source .npz task directories.", + ) + parser.add_argument( + "--rlds-root", + default="data_mikasa_robo/data_rlds", + help="Relative path (from repo root) for converted RLDS output.", + ) + parser.add_argument( + "--builder-dir", + default="utils/convert_npz_to_rlds/rlds_dataset_builder/mikasa_dataset", + help="Relative path (from repo root) to TFDS dataset builder directory.", + ) + parser.add_argument( + "--dataset-name", + default="mikasa_dataset", + help="TFDS dataset folder name generated under ~/tensorflow_datasets.", + ) + parser.add_argument( + "--tfds-data-dir", + default=None, + help=( + "Directory for TFDS build artifacts. " + "If omitted, a per-run temporary directory is used (safe for parallel runs)." + ), + ) + parser.add_argument( + "--overwrite-dest", + action="store_true", + help="Remove existing destination directory for this task before copy.", + ) + return parser.parse_args() + + +def run(cmd: list[str], cwd: Path, env: dict[str, str]) -> None: + print(f"+ (cd {cwd} && {' '.join(cmd)})") + subprocess.run(cmd, cwd=cwd, env=env, check=True) + + +def main() -> None: + args = parse_args() + repo_root = Path(args.repo_root).resolve() if args.repo_root else Path(__file__).resolve().parents[2] + dataset_name = env_id_to_dataset_name(args.task) + npz_root = repo_root / args.npz_root + task_dir = npz_root / dataset_name + builder_dir = repo_root / args.builder_dir + version_name = "1.0.0" + destination_task_dir = repo_root / args.rlds_root / dataset_name + destination_version_dir = destination_task_dir / version_name + source_metadata = task_dir / "metadata.json" + destination_metadata = destination_version_dir / "metadata.json" + + if not task_dir.exists(): + raise FileNotFoundError(f"Task dir not found: {task_dir}") + if not source_metadata.exists(): + raise FileNotFoundError(f"Task metadata.json not found: {source_metadata}") + if not builder_dir.exists(): + raise FileNotFoundError(f"Builder dir not found: {builder_dir}") + + env = os.environ.copy() + env["MIKASA_TASK_NAME"] = dataset_name + try: + env["MIKASA_NPZ_ROOT"] = str(npz_root.relative_to(repo_root)) + except ValueError: + env["MIKASA_NPZ_ROOT"] = str(npz_root) + + # Use per-run TFDS output dir by default to avoid collisions in parallel runs. + temp_data_dir_obj: tempfile.TemporaryDirectory[str] | None = None + if args.tfds_data_dir: + tfds_data_dir = Path(args.tfds_data_dir).expanduser().resolve() + tfds_data_dir.mkdir(parents=True, exist_ok=True) + else: + safe_task = "".join(ch if ch.isalnum() or ch in "-_." else "_" for ch in dataset_name) + temp_data_dir_obj = tempfile.TemporaryDirectory(prefix=f"mikasa_tfds_{safe_task}_") + tfds_data_dir = Path(temp_data_dir_obj.name) + + tfds_dataset_dir = tfds_data_dir / args.dataset_name + source_version_dir = tfds_dataset_dir / version_name + env["TFDS_DATA_DIR"] = str(tfds_data_dir) + + try: + # Use the same interpreter as this script so `tfds` matches `uv run --project ...` deps. + # Calling bare `tfds` uses PATH and can pick another venv (e.g. convert_rlds_to_lerobot) + # where tensorflow_datasets imports apache_beam but beam is not installed. + run( + [ + sys.executable, + "-m", + "tensorflow_datasets.scripts.cli.main", + "build", + "--overwrite", + f"--data_dir={tfds_data_dir}", + ], + cwd=builder_dir, + env=env, + ) + + if not source_version_dir.exists(): + raise FileNotFoundError( + f"TFDS output version dir not found: {source_version_dir}. tfds build may have failed." + ) + + if destination_task_dir.exists() and args.overwrite_dest: + shutil.rmtree(destination_task_dir) + elif destination_task_dir.exists() and not args.overwrite_dest: + raise FileExistsError( + f"Destination already exists: {destination_task_dir}. Use --overwrite-dest to replace it." + ) + + destination_task_dir.mkdir(parents=True, exist_ok=True) + shutil.copytree(source_version_dir, destination_version_dir) + shutil.copy2(source_metadata, destination_metadata) + finally: + if temp_data_dir_obj is not None: + temp_data_dir_obj.cleanup() + + print(f"RLDS dataset written to: {destination_task_dir}") + print(f"Metadata copied to: {destination_metadata}") + + +if __name__ == "__main__": + main() diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/evidence/convert_rlds_to_lerobot.py b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/evidence/convert_rlds_to_lerobot.py new file mode 100644 index 0000000000000000000000000000000000000000..effa589435952410f0857328e8c0866d21030e86 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/evidence/convert_rlds_to_lerobot.py @@ -0,0 +1,509 @@ +#!/usr/bin/env python3 +"""Convert RLDS (TFDS episodic format) datasets to LeRobotDataset v3 format.""" + +from __future__ import annotations + +import argparse +import os +import shutil +import sys +from dataclasses import dataclass +from pathlib import Path +from typing import Any, Iterable + +import numpy as np +from tqdm import tqdm + +# Import the naming helper directly, bypassing mikasa_robo_suite package __init__ +# so this converter can run in a lightweight venv without sapien/mani_skill. +sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "mikasa_robo_suite" / "vla" / "utils")) +from dataset_naming import env_id_to_dataset_name # noqa: E402 + +# Keep tfds builds quiet on local/offline machines. +os.environ.setdefault("TF_CPP_MIN_LOG_LEVEL", "2") +os.environ.setdefault("TFDS_DISABLE_GCS", "1") + + +@dataclass +class TaskPaths: + task_id: str + rlds_task_dir: Path + rlds_version_dir: Path + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser( + description="Convert RLDS task dataset(s) in data_mikasa_robo/data_rlds/* to LeRobotDataset v3." + ) + scope = parser.add_mutually_exclusive_group(required=True) + scope.add_argument( + "--task", + type=str, + help=( + "Convert one RLDS task id. Accepts either gym env_id " + "('RememberColor3-VLA-v0') or snake_case dataset name ('remember_color_3_vla_v0')." + ), + ) + scope.add_argument( + "--all", + action="store_true", + help="Convert all task directories under --rlds-root.", + ) + + parser.add_argument( + "--repo-root", + type=str, + default=None, + help="Path to MIKASA-Robo root. Defaults to auto-detect from this script.", + ) + parser.add_argument( + "--rlds-root", + type=str, + default="data_mikasa_robo/data_rlds", + help="Relative path from repo root containing RLDS task directories.", + ) + parser.add_argument( + "--lerobot-root", + type=str, + default="data_mikasa_robo/data_lerobot", + help="Relative path from repo root where LeRobot datasets are written.", + ) + parser.add_argument( + "--repo-id-template", + type=str, + default="{task}", + help=("Template for LeRobot repo_id. Use {task} placeholder. Examples: '{task}' or 'avanturist322/{task}'."), + ) + parser.add_argument( + "--version", + type=str, + default=None, + help="RLDS version folder (default: latest semver subdir, e.g., 1.0.0).", + ) + parser.add_argument( + "--split", + type=str, + default="train", + help="TFDS split name to read from RLDS task dataset.", + ) + parser.add_argument("--fps", type=int, default=10, help="LeRobot dataset FPS.") + parser.add_argument( + "--robot-type", + type=str, + default="mikasa_robo", + help="LeRobot robot_type metadata.", + ) + parser.add_argument( + "--max-episodes", + type=int, + default=None, + help="Optional cap for number of converted episodes per task.", + ) + parser.add_argument( + "--overwrite-dest", + action="store_true", + help="Remove existing output directory for each task before conversion.", + ) + parser.add_argument( + "--skip-existing", + action="store_true", + help="Skip tasks whose output directory already exists instead of failing.", + ) + parser.add_argument( + "--no-videos", + action="store_true", + help="Store image frames directly instead of encoding MP4 videos.", + ) + return parser.parse_args() + + +def repo_root_from_args(value: str | None) -> Path: + if value: + return Path(value).resolve() + return Path(__file__).resolve().parents[2] + + +def repo_id_to_relpath(repo_id: str) -> Path: + return Path(*repo_id.split("/")) + + +def semver_key(version: str) -> tuple[int, int, int]: + major, minor, patch = version.split(".") + return int(major), int(minor), int(patch) + + +def resolve_version_dir(task_dir: Path, forced_version: str | None) -> Path: + if forced_version: + version_dir = task_dir / forced_version + if not version_dir.exists(): + raise FileNotFoundError(f"Version dir not found: {version_dir}") + return version_dir + + semver_dirs = [p for p in task_dir.iterdir() if p.is_dir() and p.name.count(".") == 2] + semver_dirs = [p for p in semver_dirs if all(chunk.isdigit() for chunk in p.name.split("."))] + if not semver_dirs: + raise FileNotFoundError(f"No semver version dirs found in {task_dir}. Expected e.g. {task_dir / '1.0.0'}") + semver_dirs.sort(key=lambda p: semver_key(p.name)) + return semver_dirs[-1] + + +def discover_tasks( + rlds_root: Path, + task: str | None, + all_tasks: bool, + forced_version: str | None, +) -> list[TaskPaths]: + if task: + dataset_name = env_id_to_dataset_name(task) + task_dir = rlds_root / dataset_name + if not task_dir.exists(): + raise FileNotFoundError(f"Task not found in RLDS root: {task_dir}") + return [ + TaskPaths( + task_id=dataset_name, + rlds_task_dir=task_dir, + rlds_version_dir=resolve_version_dir(task_dir, forced_version), + ) + ] + + if not all_tasks: + raise ValueError("Either --task or --all must be provided.") + + tasks: list[TaskPaths] = [] + for task_dir in sorted(rlds_root.iterdir()): + if not task_dir.is_dir() or task_dir.name.startswith("_"): + continue + try: + version_dir = resolve_version_dir(task_dir, forced_version) + except FileNotFoundError: + continue + tasks.append( + TaskPaths( + task_id=task_dir.name, + rlds_task_dir=task_dir, + rlds_version_dir=version_dir, + ) + ) + if not tasks: + raise FileNotFoundError(f"No RLDS tasks discovered in {rlds_root}") + return tasks + + +def normalize_text(value: Any) -> str: + if isinstance(value, str): + return value + if isinstance(value, bytes): + return value.decode("utf-8", errors="ignore") + if isinstance(value, np.ndarray): + if value.ndim == 0: + return normalize_text(value.item()) + if value.size == 1: + return normalize_text(value.reshape(-1)[0]) + return str(value) + + +def to_uint8_hwc(image: Any) -> np.ndarray: + arr = np.asarray(image) + if arr.ndim != 3: + raise ValueError(f"Expected image with 3 dims (H,W,C), got shape={arr.shape}") + if arr.dtype == np.uint8: + return arr + if np.issubdtype(arr.dtype, np.floating): + clipped = np.clip(arr, 0.0, 1.0) + return (clipped * 255.0).astype(np.uint8) + return np.clip(arr, 0, 255).astype(np.uint8) + + +def dict_leaf_length(data: dict[str, Any]) -> int: + first_value = next(iter(data.values())) + if isinstance(first_value, dict): + return dict_leaf_length(first_value) + return len(first_value) + + +def index_nested(data: Any, idx: int) -> Any: + if isinstance(data, dict): + return {k: index_nested(v, idx) for k, v in data.items()} + return data[idx] + + +def iter_episode_steps(steps_obj: Any) -> Iterable[dict[str, Any]]: + if hasattr(steps_obj, "as_numpy_iterator"): + yield from steps_obj.as_numpy_iterator() + return + + if isinstance(steps_obj, dict): + length = dict_leaf_length(steps_obj) + for i in range(length): + yield index_nested(steps_obj, i) + return + + yield from steps_obj + + +def infer_features(first_step: dict[str, Any], include_wrist: bool) -> dict[str, dict[str, Any]]: + top = to_uint8_hwc(first_step["observation"]["image"]) + proprio = np.asarray(first_step["observation"]["proprio"], dtype=np.float32) + action = np.asarray(first_step["action"], dtype=np.float32) + + features: dict[str, dict[str, Any]] = { + "observation.images.top": { + "dtype": "video", + "shape": tuple(top.shape), + "names": ["height", "width", "channel"], + }, + "observation.state": { + "dtype": "float32", + "shape": tuple(proprio.shape), + }, + "action": { + "dtype": "float32", + "shape": tuple(action.shape), + }, + } + if include_wrist: + wrist = to_uint8_hwc(first_step["observation"]["wrist_image"]) + features["observation.images.wrist"] = { + "dtype": "video", + "shape": tuple(wrist.shape), + "names": ["height", "width", "channel"], + } + return features + + +def create_lerobot_dataset( + repo_id: str, + root: Path, + fps: int, + robot_type: str, + features: dict[str, dict[str, Any]], + use_videos: bool, +): + from lerobot.datasets.lerobot_dataset import LeRobotDataset + + attempts: list[dict[str, Any]] = [ + { + "repo_id": repo_id, + "root": root, + "fps": fps, + "robot_type": robot_type, + "features": features, + "use_videos": use_videos, + }, + { + "repo_id": repo_id, + "root": root, + "fps": fps, + "robot_type": robot_type, + "features": features, + }, + ] + + last_error: Exception | None = None + for kwargs in attempts: + try: + return LeRobotDataset.create(**kwargs) + except TypeError as exc: + last_error = exc + assert last_error is not None + raise last_error + + +def save_episode_compat(dataset: Any) -> None: + try: + dataset.save_episode(parallel_encoding=False) + except TypeError: + dataset.save_episode() + + +def finalize_dataset(dataset: Any) -> None: + if hasattr(dataset, "finalize"): + dataset.finalize() + return + if hasattr(dataset, "consolidate"): + dataset.consolidate() + return + raise AttributeError("LeRobot dataset object does not expose finalize() or consolidate().") + + +def convert_one_task( + task_paths: TaskPaths, + output_root: Path, + repo_id_template: str, + split: str, + fps: int, + robot_type: str, + use_videos: bool, + overwrite_dest: bool, + skip_existing: bool, + max_episodes: int | None, +) -> bool: + import tensorflow_datasets as tfds + + task = task_paths.task_id + repo_id = repo_id_template.format(task=task) + if not repo_id.strip(): + raise ValueError("repo_id from --repo-id-template is empty") + + destination_dir = output_root / repo_id_to_relpath(repo_id) + if destination_dir.exists(): + if overwrite_dest: + shutil.rmtree(destination_dir) + elif skip_existing: + print(f"[{task}] skip: destination already exists -> {destination_dir}") + return False + else: + raise FileExistsError( + f"Destination already exists: {destination_dir}. " + "Use --overwrite-dest to replace or --skip-existing to skip." + ) + + builder = tfds.builder_from_directory(str(task_paths.rlds_version_dir)) + ds = builder.as_dataset(split=split) + if max_episodes is not None: + ds = ds.take(max_episodes) + + lerobot_dataset = None + include_wrist = True + episodes_written = 0 + steps_written = 0 + latest_instruction = task + + episodes_iter = tfds.as_numpy(ds) + for episode in tqdm(episodes_iter, desc=f"[{task}] episodes", unit="ep"): + steps = iter_episode_steps(episode["steps"]) + try: + first_step = next(steps) + except StopIteration: + continue + + if lerobot_dataset is None: + include_wrist = "wrist_image" in first_step["observation"] + features = infer_features(first_step, include_wrist=include_wrist) + try: + lerobot_dataset = create_lerobot_dataset( + repo_id=repo_id, + root=destination_dir, + fps=fps, + robot_type=robot_type, + features=features, + use_videos=use_videos, + ) + except ValueError as exc: + if "/" not in repo_id: + fallback_repo_id = f"local/{repo_id}" + print( + f"[{task}] repo_id='{repo_id}' not accepted by current lerobot. " + f"Falling back to '{fallback_repo_id}'." + ) + repo_id = fallback_repo_id + destination_dir = output_root / repo_id_to_relpath(repo_id) + if destination_dir.exists(): + if overwrite_dest: + shutil.rmtree(destination_dir) + elif skip_existing: + print(f"[{task}] skip: fallback destination already exists -> {destination_dir}") + return False + else: + raise FileExistsError( + f"Destination already exists: {destination_dir}. " + "Use --overwrite-dest to replace or --skip-existing to skip." + ) + lerobot_dataset = create_lerobot_dataset( + repo_id=repo_id, + root=destination_dir, + fps=fps, + robot_type=robot_type, + features=features, + use_videos=use_videos, + ) + else: + raise exc + + def write_step(step: dict[str, Any]) -> None: + nonlocal steps_written, latest_instruction + if "language_instruction" in step: + txt = normalize_text(step["language_instruction"]).strip() + if txt: + latest_instruction = txt + + frame = { + "observation.images.top": to_uint8_hwc(step["observation"]["image"]), + "observation.state": np.asarray(step["observation"]["proprio"], dtype=np.float32), + "action": np.asarray(step["action"], dtype=np.float32), + "task": latest_instruction or task, + } + if include_wrist and "wrist_image" in step["observation"]: + frame["observation.images.wrist"] = to_uint8_hwc(step["observation"]["wrist_image"]) + + lerobot_dataset.add_frame(frame) + steps_written += 1 + + write_step(first_step) + for step in steps: + write_step(step) + + save_episode_compat(lerobot_dataset) + episodes_written += 1 + + if lerobot_dataset is None: + raise RuntimeError(f"No episodes written for task '{task}'. Check split='{split}' and RLDS data content.") + + finalize_dataset(lerobot_dataset) + + source_metadata = task_paths.rlds_version_dir / "metadata.json" + if source_metadata.exists() and destination_dir.exists(): + shutil.copy2(source_metadata, destination_dir / "source_rlds_metadata.json") + + print(f"[{task}] done: episodes={episodes_written}, steps={steps_written}, output={destination_dir}") + return True + + +def main() -> None: + args = parse_args() + repo_root = repo_root_from_args(args.repo_root) + rlds_root = (repo_root / args.rlds_root).resolve() + output_root = (repo_root / args.lerobot_root).resolve() + + if "{task}" not in args.repo_id_template: + raise ValueError("--repo-id-template must include '{task}' placeholder") + if not rlds_root.exists(): + raise FileNotFoundError(f"RLDS root not found: {rlds_root}") + + tasks = discover_tasks( + rlds_root=rlds_root, + task=args.task, + all_tasks=args.all, + forced_version=args.version, + ) + output_root.mkdir(parents=True, exist_ok=True) + + if args.overwrite_dest and args.skip_existing: + raise ValueError("--overwrite-dest and --skip-existing are mutually exclusive.") + + converted: list[str] = [] + skipped: list[str] = [] + for tp in tasks: + did_convert = convert_one_task( + task_paths=tp, + output_root=output_root, + repo_id_template=args.repo_id_template, + split=args.split, + fps=args.fps, + robot_type=args.robot_type, + use_videos=not args.no_videos, + overwrite_dest=args.overwrite_dest, + skip_existing=args.skip_existing, + max_episodes=args.max_episodes, + ) + (converted if did_convert else skipped).append(tp.task_id) + + print(f"Summary: converted={len(converted)}, skipped={len(skipped)}, total={len(tasks)}") + if skipped: + print("Skipped tasks:") + for t in skipped: + print(f" - {t}") + + +if __name__ == "__main__": + main() diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/evidence/latency.yaml b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/evidence/latency.yaml new file mode 100644 index 0000000000000000000000000000000000000000..69f8314b5d2287bfc167bccda0e6b06ecede06ff --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/evidence/latency.yaml @@ -0,0 +1,40 @@ +env: + env_fps: 20 + obs_fps: 20 + noop_action: + - 0 + - 0 + - 0 + - 0 + - 0 + - 0 + - 0 +executor: + simulated_worker_capacity: 1 +latency: + method: fixed + fixed_latency_ms: 99.05021289731565 + seed: 0 +scheduler: + ordering_policy: latest_ready + hold_policy: hold +training: + num_envs: 1024 + num_eval_envs: 16 + num_steps: 60 + num_minibatches: 32 + update_epochs: 8 + total_timesteps: 150000000 + eval_freq: 25 + track: true + exp_name: small-ppo-intercept-qwenoft-mean-rtx3090-h1-s123 + checkpoint: null + resume: null + seed: 123 + num_eval_steps: 60 + learning_rate: 0.0001 + target_kl: 0.2 +profile_source: + repo_id: latency-sensitive-bench/profiles + revision: 66414463f2a609316da63935941a79abf0a73ce9 + path: profiles/qwenoft/1x-rtx3090/mikasa_intercept_grab_fast/instance_3a0d42681a03715c diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/evidence/mikasa_dataset_dataset_builder.py b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/evidence/mikasa_dataset_dataset_builder.py new file mode 100644 index 0000000000000000000000000000000000000000..10c067762da94d9bb17273017cc9e49fe7f0f2d3 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/evidence/mikasa_dataset_dataset_builder.py @@ -0,0 +1,161 @@ +import glob +import os +from pathlib import Path +from typing import Any, Iterator, Tuple + +import numpy as np + +# Keep tfds builds quiet on local/offline machines. +os.environ.setdefault("TF_CPP_MIN_LOG_LEVEL", "2") +os.environ.setdefault("TFDS_DISABLE_GCS", "1") + +import tensorflow_datasets as tfds + + +class MikasaDataset(tfds.core.GeneratorBasedBuilder): + """DatasetBuilder for MIKASA-Robo-VLA dataset.""" + + VERSION = tfds.core.Version("1.0.0") + RELEASE_NOTES = { + "1.0.0": "Initial release.", + } + _REPO_ROOT = Path(__file__).resolve().parents[4] + _DEFAULT_NPZ_ROOT = Path("data_mikasa_robo/data_npz") + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + def _info(self) -> tfds.core.DatasetInfo: + """Dataset metadata (homepage, citation,...).""" + return self.dataset_info_from_configs( + features=tfds.features.FeaturesDict( + { + "steps": tfds.features.Dataset( + { + "observation": tfds.features.FeaturesDict( + { + "image": tfds.features.Image( + shape=(128, 128, 3), + dtype=np.uint8, + encoding_format="png", + doc="Base camera RGB observation.", + ), + "wrist_image": tfds.features.Image( + shape=(128, 128, 3), + dtype=np.uint8, + encoding_format="png", + doc="Wist camera RGB observation.", + ), + "proprio": tfds.features.Tensor( + shape=(7,), + dtype=np.float32, + doc="EEF XYZ(3) + RPY(3) + GRIPPER(1)", + ), + } + ), + "action": tfds.features.Tensor( + shape=(7,), + dtype=np.float32, + doc="Robot action, for control type: pd_ee_delta_pose (see ManiSkill docs). \ + EEF Delta XYZ(3) + Delta RPY(3) + Delta GRIPPER(1)", + ), + "discount": tfds.features.Scalar( + dtype=np.float32, doc="Discount if provided, default to 1." + ), + "reward": tfds.features.Scalar( + dtype=np.float32, doc="Reward if provided, 1 on final step for demos." + ), + "is_first": tfds.features.Scalar(dtype=np.bool_, doc="True on first step of the episode."), + "is_last": tfds.features.Scalar(dtype=np.bool_, doc="True on last step of the episode."), + "is_terminal": tfds.features.Scalar( + dtype=np.bool_, + doc="True on last step of the episode if it is a terminal step, True for demos.", + ), + "language_instruction": tfds.features.Text(doc="Language Instruction."), + } + ), + "episode_metadata": tfds.features.FeaturesDict( + { + "file_path": tfds.features.Text(doc="Path to the original data file."), + } + ), + } + ) + ) + + def _split_generators(self, dl_manager: tfds.download.DownloadManager): + """Define data splits.""" + task_name = os.environ.get("MIKASA_TASK_NAME", "remember_color_3_vla_v0") + npz_root = Path(os.environ.get("MIKASA_NPZ_ROOT", str(self._DEFAULT_NPZ_ROOT))) + train_pattern = str(npz_root / task_name / "train_data_*.npz") + return { + "train": self._generate_examples(path=train_pattern), + # 'val': self._generate_examples(path='data/val/episode_*.npy'), + } + + def _generate_examples(self, path) -> Iterator[Tuple[str, Any]]: + """Generator of examples for each split.""" + + def _parse_example(episode_path): + # load raw data --> this should change for your dataset + data = np.load(episode_path) # this is a list of dicts in our case + + # assemble episode --> here we're assuming demos so we set reward to 1 at the end + episode = [] + traj_len = data["success"].shape[0] + raw_instruction = data["language_instruction"] + + # Support both: + # 1) episode-level scalar string (np.array("...")) + # 2) per-step array/list of strings with length = traj_len + if isinstance(raw_instruction, np.ndarray) and raw_instruction.ndim == 0: + episode_instruction = str(raw_instruction.item()) + per_step_instruction = None + elif np.isscalar(raw_instruction): + episode_instruction = str(raw_instruction) + per_step_instruction = None + else: + per_step_instruction = raw_instruction + episode_instruction = None + + for i in range(traj_len): + language_instruction = ( + episode_instruction if per_step_instruction is None else str(per_step_instruction[i]) + ) + episode.append( + { + "observation": { + "image": data["rgb"][i][:, :, :3], + "wrist_image": data["rgb"][i][:, :, 3:], + "proprio": data["proprio"][i], + }, + "action": data["action"][i], + "discount": 1.0, + "reward": data["reward"][i], # float(i == (len(data) - 1)), + "is_first": i == 0, + "is_last": i == (traj_len - 1), + "is_terminal": data["done"][i], # i == (traj_len - 1), + "language_instruction": language_instruction, + } + ) + + # create output data sample + sample = {"steps": episode, "episode_metadata": {"file_path": episode_path}} + + # if you want to skip an example for whatever reason, simply return None + return episode_path, sample + + # Resolve relative patterns from the MIKASA-Robo repository root so + # TFDS can be launched from any working directory. + path_pattern = Path(path) + if not path_pattern.is_absolute(): + path_pattern = self._REPO_ROOT / path_pattern + + # create list of all examples + episode_paths = sorted(glob.glob(str(path_pattern))) + if not episode_paths: + raise FileNotFoundError(f"No .npz episodes found for pattern: {path_pattern}") + + # for smallish datasets, use single-thread parsing + for sample in episode_paths: + yield _parse_example(sample) diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/evidence/profile.source.json b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/evidence/profile.source.json new file mode 100644 index 0000000000000000000000000000000000000000..22b4d0dd275f2dfde5c7c996197cac820bb8b5f0 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/evidence/profile.source.json @@ -0,0 +1,66 @@ +{ + "burst_model_path": "latency_burst_model.json", + "distribution_path": "latency_distribution.json", + "env_fps": 20, + "frame_ms": 50.0, + "gpu_class": "1x-rtx3090", + "instance_id": "instance_3a0d42681a03715c", + "latency_kind": "observation_to_action_latency", + "latency_method": "temporal", + "model_id": "qwenoft", + "n_admitted_observations": 7505, + "n_capacity_drops": 7495, + "n_observation_attempts": 15000, + "per_slot_summary": { + "0": { + "admitted_count": 7505, + "mean_observation_to_action_latency_ms": 99.05021289731565, + "mean_worker_service_time_ms": 98.55270653801072, + "p95_observation_to_action_latency_ms": 100.32732703685761, + "p95_worker_service_time_ms": 99.84762226343155, + "p99_worker_service_time_ms": 100.37557450771331 + } + }, + "provenance": { + "base_config": "configs/examples/mikasa/official_starvla_profile.yaml", + "checkpoint_kind": "best", + "model_artifact": { + "checkpoint": "checkpoints/model.pt", + "model_config": "config.yaml", + "path_in_repo": "zero-latency/mikasa-intercept-grab-fast/vla/starvla-qwenoft-h1/mikasa_intercept_grab_fast_qwenoft_formal_latest_r8gpu8_20260907T082154Z", + "repo_id": "latency-sensitive-bench/benchmark-models", + "source": "hf" + }, + "session_ids": [ + 0, + 1, + 2, + 3, + 4 + ] + }, + "sample_model_type": "hidden_regime", + "source_run_id": "20260909T044501695676Z", + "summary": { + "frame_ms": 50.0, + "max_ms": 101.19136601686478, + "mean_effective_frames": 1.981004257946313, + "mean_ms": 99.05021289731565, + "min_ms": 57.612886011600494, + "n_samples": 7505, + "p50_frames": 1.9978350806236267, + "p50_ms": 99.89175403118134, + "p90_frames": 2.0040290887355803, + "p90_ms": 100.20145443677902, + "p95_frames": 2.006546540737152, + "p95_ms": 100.32732703685761, + "p99_frames": 2.0128874400138854, + "p99_ms": 100.64437200069428, + "prob_latency_gt_1_frame": 1.0, + "prob_latency_gt_2_frames": 0.2139906728847435, + "prob_latency_gt_3_frames": 0.0, + "std_ms": 4.583189247461202 + }, + "visualization_path": "latency_profile.png", + "workload_id": "mikasa_intercept_grab_fast" +} diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/files.sha256.json b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/files.sha256.json new file mode 100644 index 0000000000000000000000000000000000000000..758bc2648a9fa82768c5d01cbe9603221fbbdaf2 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/files.sha256.json @@ -0,0 +1,1234 @@ +{ + "README.md": { + "bytes": 1004, + "sha256": "0c34630502cd6eef0aefa03bd3f6b0805db45a04d41463d977f1051df9bcad60" + }, + "demonstrations/conversion/README.md": { + "bytes": 792, + "sha256": "c5c80defd8d5586323ed256a24601804c5b7805ddb391ab3b19333e066afea89" + }, + "demonstrations/conversion/expected/lerobot/manifest.json": { + "bytes": 221, + "sha256": "97b5bea337c766d9db49c8e3a01ad93de4721dbdf965acf31e7eba4948f24421" + }, + "demonstrations/conversion/expected/lerobot/meta/episodes/chunk-000/file-000.parquet": { + "bytes": 1070540, + "sha256": "5d0ecb7b2409699ddd06a99ecd4863c6fc20cfdd4bef55473c68baf35aa86a94" + }, + "demonstrations/conversion/expected/lerobot/meta/info.json": { + "bytes": 2739, + "sha256": "a1075892e94e55ba2d5b52772755ebc7a4203a4e9e9fa2ad451eec63551cc36f" + }, + "demonstrations/conversion/expected/lerobot/meta/modality.json": { + "bytes": 578, + "sha256": "54e078201621e3317d9e20e8a4a4d12390fbfe4faab2fead65fb25843d9b88e8" + }, + "demonstrations/conversion/expected/lerobot/meta/stats.json": { + "bytes": 13705, + "sha256": "cb6f3403f3cdec7aaf9577886c8ad78acbc1197e49796b96a434582a4a3a2cf2" + }, + "demonstrations/conversion/expected/lerobot/meta/stats_gr00t.json": { + "bytes": 2741, + "sha256": "34907e741f41ff468b77fefbe8ba40aa1abb4e2f78f1adacd3ecb0bc0db19276" + }, + "demonstrations/conversion/expected/lerobot/meta/tasks.parquet": { + "bytes": 2351, + "sha256": "29b49531995b967e7b4afc52add5605c15e84ad1dd445ca06dccff69df98e5f5" + }, + "demonstrations/conversion/expected/lerobot/task_contract.json": { + "bytes": 3063, + "sha256": "b40d58b27dfa9431f86f83ea5d4f36bcd652b3e3517c044638282df0d1e86c6b" + }, + "demonstrations/conversion/expected/lerobot__val/manifest.json": { + "bytes": 221, + "sha256": "97b5bea337c766d9db49c8e3a01ad93de4721dbdf965acf31e7eba4948f24421" + }, + "demonstrations/conversion/expected/lerobot__val/meta/episodes/chunk-000/file-000.parquet": { + "bytes": 143349, + "sha256": "725ec4029a221dc57f839cfbca5698355ccfdf91f9fdea11d6db570017e89a76" + }, + "demonstrations/conversion/expected/lerobot__val/meta/info.json": { + "bytes": 2736, + "sha256": "423c6745fd805f6e0a9913670039e3313746055ddc2dca936494f28d2442a826" + }, + "demonstrations/conversion/expected/lerobot__val/meta/modality.json": { + "bytes": 578, + "sha256": "54e078201621e3317d9e20e8a4a4d12390fbfe4faab2fead65fb25843d9b88e8" + }, + "demonstrations/conversion/expected/lerobot__val/meta/stats.json": { + "bytes": 13718, + "sha256": "008a58da0162af6b3a95361b7b08a305c2ad064d323717977f3bbc15cd4e9057" + }, + "demonstrations/conversion/expected/lerobot__val/meta/stats_gr00t.json": { + "bytes": 2741, + "sha256": "34907e741f41ff468b77fefbe8ba40aa1abb4e2f78f1adacd3ecb0bc0db19276" + }, + "demonstrations/conversion/expected/lerobot__val/meta/tasks.parquet": { + "bytes": 2351, + "sha256": "29b49531995b967e7b4afc52add5605c15e84ad1dd445ca06dccff69df98e5f5" + }, + "demonstrations/conversion/expected/lerobot__val/task_contract.json": { + "bytes": 3063, + "sha256": "b40d58b27dfa9431f86f83ea5d4f36bcd652b3e3517c044638282df0d1e86c6b" + }, + "demonstrations/conversion/expected/mixture.json": { + "bytes": 275, + "sha256": "a495229de3c15cd9740127401429af41d09b3f367a90f6da757126fbfe8a30b3" + }, + "demonstrations/raw/metadata.json": { + "bytes": 14020, + "sha256": "4dd5427cf7d8b52b6f5e44c5c19d2011841c27cc65e3d4c36929ed875377a1e2" + }, + "demonstrations/raw/raw_npz/train_data_0.npz": { + "bytes": 4044802, + "sha256": "7f46ff64233ec31a56a61dae27c793633d13c13781b031ce8da94a6a113b5448" + }, + "demonstrations/raw/raw_npz/train_data_1.npz": { + "bytes": 3651070, + "sha256": "6d743ab66ad0541b61d462bef9e6a062ab02a52974a7f8f62c0d38596a51944b" + }, + "demonstrations/raw/raw_npz/train_data_10.npz": { + "bytes": 4044802, + "sha256": "348a02b483ec901d6db5d7e50ab5838bdfb08776b2e8f5e2abe80b7b4936a856" + }, + "demonstrations/raw/raw_npz/train_data_100.npz": { + "bytes": 4044802, + "sha256": "15e93b5d927bacfb43d309989d7475af98e1a2f03753542fc40c002b54f7c3be" + }, + "demonstrations/raw/raw_npz/train_data_101.npz": { + "bytes": 4832266, + "sha256": "525af0c145e326d3064c35e6fd9fc5b9bedc2ebf8fceaa0031b5787094cee260" + }, + "demonstrations/raw/raw_npz/train_data_102.npz": { + "bytes": 5029132, + "sha256": "9e30c999efee7e7668317400ce1926f2d80ee7d17a44ea30b04cfa0a4c3ebff6" + }, + "demonstrations/raw/raw_npz/train_data_103.npz": { + "bytes": 4241668, + "sha256": "a483ae377f694ddecbe35420f2c9759188e87cbc493247507c702b8be47bd38c" + }, + "demonstrations/raw/raw_npz/train_data_104.npz": { + "bytes": 4241668, + "sha256": "41b706b4e791b9ef7d2e2535908cb9a072978d955be48a23ef408bdf53d0039e" + }, + "demonstrations/raw/raw_npz/train_data_105.npz": { + "bytes": 4241668, + "sha256": "1c361ec3fddf99a8b45736b72248b972460c5b1d479de1ea0341573f3d388901" + }, + "demonstrations/raw/raw_npz/train_data_106.npz": { + "bytes": 4438534, + "sha256": "61b9059cd8ead3031aa02b778c8e343362a1118cebe1202bf71f77e57c7ddadd" + }, + "demonstrations/raw/raw_npz/train_data_107.npz": { + "bytes": 4044802, + "sha256": "2a68f80ccccba23fb92c97061e9100594a9d13c0408b65e1d91b455731cb9176" + }, + "demonstrations/raw/raw_npz/train_data_108.npz": { + "bytes": 4241668, + "sha256": "ed52a51d6092b34ed9eeef52af0a5299861ead967d2ab15c1d0d8634d908934f" + }, + "demonstrations/raw/raw_npz/train_data_109.npz": { + "bytes": 4635400, + "sha256": "49c02fd4d1bdd82f88b641deccf31c350eb7acc05077af55523983c53689c1c0" + }, + "demonstrations/raw/raw_npz/train_data_11.npz": { + "bytes": 4044802, + "sha256": "3627f87b6d9c7544d75c39310ca7a53042cee43dd18e1e24388ff1b1531c9843" + }, + "demonstrations/raw/raw_npz/train_data_110.npz": { + "bytes": 4241668, + "sha256": "5c555b4ade1b2f3a22faaa0dde6bdabf83a194208a6228d27ad46604746aa3be" + }, + "demonstrations/raw/raw_npz/train_data_111.npz": { + "bytes": 4832266, + "sha256": "10a164d5b3b766aff39e86300951e0a3409ffb80eddeb84389ad4e60958e6af7" + }, + "demonstrations/raw/raw_npz/train_data_112.npz": { + "bytes": 4340101, + "sha256": "bb632da6917093027bcfc388570f5520b0166806b74edc147aec0754da29737f" + }, + "demonstrations/raw/raw_npz/train_data_113.npz": { + "bytes": 4438534, + "sha256": "18d449d81ac535f9271228b5b0fe4316b52a6fa1d8ff1381ed81e5f9cf29a86c" + }, + "demonstrations/raw/raw_npz/train_data_114.npz": { + "bytes": 4635400, + "sha256": "d3fb11a5b98307f3abcf504ff6d5d7798f5609ed303c4301da50fe30ebb0b99d" + }, + "demonstrations/raw/raw_npz/train_data_115.npz": { + "bytes": 4340101, + "sha256": "2f1855433bbfc6254f67635201acacdf3df8d465632804c05b8c6177cffba706" + }, + "demonstrations/raw/raw_npz/train_data_116.npz": { + "bytes": 4438534, + "sha256": "72fb4d40b458d86b6ffb4bf2fb12bc92d16e857adccc7e56e17dfc05308db356" + }, + "demonstrations/raw/raw_npz/train_data_117.npz": { + "bytes": 4832266, + "sha256": "c0c7ad42cc4c5826b9150507f0c0e045e1eebf278452d7dd3635a73a18e19b43" + }, + "demonstrations/raw/raw_npz/train_data_118.npz": { + "bytes": 4044802, + "sha256": "1404382f5404b2118223f013835f8f5cc8600d3815961223fbfebd2ae558f935" + }, + "demonstrations/raw/raw_npz/train_data_119.npz": { + "bytes": 4340101, + "sha256": "115d5be6bbb4311a2f30fbf081d651a39dbb1db2e8b958698db4bc183437f1c3" + }, + "demonstrations/raw/raw_npz/train_data_12.npz": { + "bytes": 4241668, + "sha256": "2056d656e52d4763c76e376e80239889e6100d7469d15001da7129b7f78fa684" + }, + "demonstrations/raw/raw_npz/train_data_120.npz": { + "bytes": 4044802, + "sha256": "f53b257fa2de0a710087543a54941b0fefb18106333e7139e70b1cfddd59be96" + }, + "demonstrations/raw/raw_npz/train_data_121.npz": { + "bytes": 4241668, + "sha256": "9406e14ae0c52b80ac95e9acd2a40a4cf7cc5e8edb7a7b8b1c41e33469125322" + }, + "demonstrations/raw/raw_npz/train_data_122.npz": { + "bytes": 4241668, + "sha256": "e9696baa716f38fa519895dc9df10c4780c606382b2a7c00494cd110ddc4df2c" + }, + "demonstrations/raw/raw_npz/train_data_123.npz": { + "bytes": 4241668, + "sha256": "7bf61acc286c1a830ebbcedef9104b7835d862471e00a4fc55cef5bebe8a26c0" + }, + "demonstrations/raw/raw_npz/train_data_124.npz": { + "bytes": 4241668, + "sha256": "6897861a7a58d5b3f5d3b8c9e9cb73345eb61723d920f74ecb66b773e5cef6fc" + }, + "demonstrations/raw/raw_npz/train_data_125.npz": { + "bytes": 4241668, + "sha256": "059d4ec1d5380c1fb70440d3ceddca68285eb777c26c133cdf3a1b347b398c60" + }, + "demonstrations/raw/raw_npz/train_data_126.npz": { + "bytes": 4241668, + "sha256": "3a3f8db5089c6b64fda6621e234c2a15afb3787274c0b82c61860a91cf9a6e9d" + }, + "demonstrations/raw/raw_npz/train_data_127.npz": { + "bytes": 4832266, + "sha256": "246fcbc029d51882633c18ce0fd6406e3a24a35ed9737984b4ff95fcec12d6dd" + }, + "demonstrations/raw/raw_npz/train_data_128.npz": { + "bytes": 4044802, + "sha256": "c7289651b9f991aa868b3316071b954f8fc4769893fb66a089f5ab74991b010f" + }, + "demonstrations/raw/raw_npz/train_data_129.npz": { + "bytes": 4044802, + "sha256": "1bbb18a9fda56d8997ce76ed03bc43532007d2a1c337d6ac662332c419ab4ee1" + }, + "demonstrations/raw/raw_npz/train_data_13.npz": { + "bytes": 4733833, + "sha256": "110f8907a57320f59e9ba4b5b821ad8f841d2b2e59cde1b646bc7c3c2e57ed19" + }, + "demonstrations/raw/raw_npz/train_data_130.npz": { + "bytes": 4438534, + "sha256": "d78ea6f511245fddc4bd402956559ea20215a6d2dfc1beca8d493e83de7c71bc" + }, + "demonstrations/raw/raw_npz/train_data_131.npz": { + "bytes": 4241668, + "sha256": "4df76f00f851c05302cdd6018f2d9d661c89a94e4f4078eeb376a43a5b8efd99" + }, + "demonstrations/raw/raw_npz/train_data_132.npz": { + "bytes": 5225998, + "sha256": "8c229ccaaffb0d18319a237873188d34e98bd6985d0013ff35dbf1c6201b79a1" + }, + "demonstrations/raw/raw_npz/train_data_133.npz": { + "bytes": 3847936, + "sha256": "73a3e1cbae75db6ba339f0d403e663cbf87a03a75150ffaa287c70af3a8abb16" + }, + "demonstrations/raw/raw_npz/train_data_134.npz": { + "bytes": 4241668, + "sha256": "0c1f3170be76488b1f77bd2cd023da14072098939a5457fecce18c578764ae17" + }, + "demonstrations/raw/raw_npz/train_data_135.npz": { + "bytes": 4733833, + "sha256": "1ef9d0a7c89cb7f402c33b3660765a4ddf701efeafd5f9f689afc2e8182255e6" + }, + "demonstrations/raw/raw_npz/train_data_136.npz": { + "bytes": 4241668, + "sha256": "86b6575de22724f342d3661809199a39297a191965bd62c811dcb97ccc377986" + }, + "demonstrations/raw/raw_npz/train_data_137.npz": { + "bytes": 4635400, + "sha256": "a351d9eeef529fc28ac6f01d0895a052914d8bc44d3be593c35d88702eaf6056" + }, + "demonstrations/raw/raw_npz/train_data_138.npz": { + "bytes": 4832266, + "sha256": "3bb17983e272681485f473735132fd555cd595ea7a9385c5dd45c8159d327afc" + }, + "demonstrations/raw/raw_npz/train_data_139.npz": { + "bytes": 4241668, + "sha256": "5b2cbefbb1d1e164ebb0fb8d750b4a8f00b05e6e74de037325881e3b292df2c3" + }, + "demonstrations/raw/raw_npz/train_data_14.npz": { + "bytes": 4438534, + "sha256": "a6bf1eb27de8c8fc5145fd61e3bfb8b7ef3b252c0645b67f2149ab6e1746dcad" + }, + "demonstrations/raw/raw_npz/train_data_140.npz": { + "bytes": 3651070, + "sha256": "8066b681aeb0fa3231627cef6ffd9efcaa2bbf097a5e78c2b7e26c55ea32a44c" + }, + "demonstrations/raw/raw_npz/train_data_141.npz": { + "bytes": 4635400, + "sha256": "14b788ae7a0c4970736565b620676db93b094c02c1546a70c5892713dd1e5c86" + }, + "demonstrations/raw/raw_npz/train_data_142.npz": { + "bytes": 4241668, + "sha256": "caaf191b8b0321f3af3b1ef227e101ab972a4123b1639f36db95de989b53e584" + }, + "demonstrations/raw/raw_npz/train_data_143.npz": { + "bytes": 4536967, + "sha256": "10ca2882864a487d8aed1e858acbf57b55baefe5a5ee3127ccb3d46f528aa6c5" + }, + "demonstrations/raw/raw_npz/train_data_144.npz": { + "bytes": 4241668, + "sha256": "b5c92e7d295aa89d6c2ceccbb0424e0b253c7fbb048463b2ab91939093c67ba6" + }, + "demonstrations/raw/raw_npz/train_data_145.npz": { + "bytes": 4536967, + "sha256": "7586a6b866c59ddafb0dc5492c91884eae82d565781ab7cbe1e77fd811f0e418" + }, + "demonstrations/raw/raw_npz/train_data_146.npz": { + "bytes": 4635400, + "sha256": "c5974c8ec7743156b28cf1ef9ca66ecf346e1020f6bd3bbc7c662b193cb71a12" + }, + "demonstrations/raw/raw_npz/train_data_147.npz": { + "bytes": 4241668, + "sha256": "3742de610318604ecb9daf90bfc73bb64f3f4a2236264267210900a521caa52e" + }, + "demonstrations/raw/raw_npz/train_data_148.npz": { + "bytes": 4635400, + "sha256": "af5c9a1d6aa25afcdd3c892fd591eae149bf7b6480b5e4700e07f1b8768571df" + }, + "demonstrations/raw/raw_npz/train_data_149.npz": { + "bytes": 3847936, + "sha256": "4442f35bc59965067834bd622bfe35b5ef7dc65d9a4dae372deca4b2ac0784d4" + }, + "demonstrations/raw/raw_npz/train_data_15.npz": { + "bytes": 4438534, + "sha256": "f4ee8dffea4192d0000db10184b8270e7b6d6f49779940e569277ca17686e1b8" + }, + "demonstrations/raw/raw_npz/train_data_150.npz": { + "bytes": 4635400, + "sha256": "93ff2abac6d2c18b702aaa37363c0e2cc29d4c7d0663cbc125edc77bd507302c" + }, + "demonstrations/raw/raw_npz/train_data_151.npz": { + "bytes": 4241668, + "sha256": "e6fad1d6736a3758bdddca4382060a49d4d9efad43556254935bec722eee0e5d" + }, + "demonstrations/raw/raw_npz/train_data_152.npz": { + "bytes": 4438534, + "sha256": "f344522fe4a816a9ade2da77f2600c40e1e38321cde1baa8c74e3eab6fe8a1b5" + }, + "demonstrations/raw/raw_npz/train_data_153.npz": { + "bytes": 3847936, + "sha256": "39598bca70fbebe7cf20eef190720a35f8eded5cacbd51eb99431047da63f1e6" + }, + "demonstrations/raw/raw_npz/train_data_154.npz": { + "bytes": 4635400, + "sha256": "e86e53bd2c1bc865acdab7bb59c19df8cb57945d6f49d40b82db43befa222468" + }, + "demonstrations/raw/raw_npz/train_data_155.npz": { + "bytes": 4832266, + "sha256": "0f7c04f24c34ea4e6228bd4a5f8aee8774fba3c562498dd949af9b0139e1b821" + }, + "demonstrations/raw/raw_npz/train_data_156.npz": { + "bytes": 3847936, + "sha256": "82c37680065e1110866e8ea1862c7b5a65ddb8d4082696e787e24e2831965e97" + }, + "demonstrations/raw/raw_npz/train_data_157.npz": { + "bytes": 3847936, + "sha256": "3a7316328f6b73421abd3a46e66a4425934e2f4fc7e159023be7a7ee523f9460" + }, + "demonstrations/raw/raw_npz/train_data_158.npz": { + "bytes": 4832266, + "sha256": "9268ff2b7c9e40efb2a95d8c8ccc1eabf6ed150c772f2d6425213ae568d9f67a" + }, + "demonstrations/raw/raw_npz/train_data_159.npz": { + "bytes": 4241668, + "sha256": "a67e15d551575f97f080d70fca3968fe33784f2acf95dddde89bee93fac0a0a4" + }, + "demonstrations/raw/raw_npz/train_data_16.npz": { + "bytes": 4241668, + "sha256": "cc40de641109d7511ad40053d305256d76e8bcbca5c05d471660f8c7ab7e8936" + }, + "demonstrations/raw/raw_npz/train_data_160.npz": { + "bytes": 4635400, + "sha256": "3cbebb9c78e87f6f12257e2e91140b2561093e752421fc81c8752209fff0d5fa" + }, + "demonstrations/raw/raw_npz/train_data_161.npz": { + "bytes": 4438534, + "sha256": "9d4405328bb6a1f5878ac5b5a461c6cf2db38144ffe2719f14e79e8df2d3a7fb" + }, + "demonstrations/raw/raw_npz/train_data_162.npz": { + "bytes": 4438534, + "sha256": "0eaec68d165b2171a60f3350ea1a01ec806ee6ad19889ad8504f33e9c79f0613" + }, + "demonstrations/raw/raw_npz/train_data_163.npz": { + "bytes": 4733833, + "sha256": "3e9085aa7f317fe443cd720ac323954b8aa515ed4a7f22b85f59b91aab04b60f" + }, + "demonstrations/raw/raw_npz/train_data_164.npz": { + "bytes": 4241668, + "sha256": "77cebaaa16c1aebed76fa70e5c95ca73192776b6d0001b16e600c1cb60365864" + }, + "demonstrations/raw/raw_npz/train_data_165.npz": { + "bytes": 4044802, + "sha256": "e67bbdd6d2c61b2d512459348bc25733c3dcf198ae2d4d989651ad2728dfdb10" + }, + "demonstrations/raw/raw_npz/train_data_166.npz": { + "bytes": 4635400, + "sha256": "de065712d2de81d39a6cde3aa05cb84edf7694845f8ca3f1fdadba91cdc65924" + }, + "demonstrations/raw/raw_npz/train_data_167.npz": { + "bytes": 4241668, + "sha256": "b1f4b7acdaf6452a004604bf41b8d09b54f6769b01f2b60470a5262ab0b1a5c9" + }, + "demonstrations/raw/raw_npz/train_data_168.npz": { + "bytes": 4832266, + "sha256": "8860733b56d85019e2aa6c27ac49dc5c896f66a377bbc36099e50f46a3a7fbd9" + }, + "demonstrations/raw/raw_npz/train_data_169.npz": { + "bytes": 4832266, + "sha256": "5a8107bedcb3187c3f5c76b7768fd43ba5ae701e21aa7f50ceb217113daef05c" + }, + "demonstrations/raw/raw_npz/train_data_17.npz": { + "bytes": 4438534, + "sha256": "58973e25cf7d98a6f644c2da571a951c5efbbf5e8da6fdc7add211091df97905" + }, + "demonstrations/raw/raw_npz/train_data_170.npz": { + "bytes": 4044802, + "sha256": "faff1f3348b2a65aee609fb7da4278178db2de184021cbaad457c5e4924e9cf3" + }, + "demonstrations/raw/raw_npz/train_data_171.npz": { + "bytes": 3847936, + "sha256": "50995642ae92378964b334f8480e415197fc651a475218f3a529f045cbcded78" + }, + "demonstrations/raw/raw_npz/train_data_172.npz": { + "bytes": 4438534, + "sha256": "9ff2f5b6e4d505405e25fb2771f02cd2749426bd10d2744cfe8b0aea266a09c5" + }, + "demonstrations/raw/raw_npz/train_data_173.npz": { + "bytes": 4241668, + "sha256": "d4385aaddeac106c47e69d1a2b58a9388dbc4748c252955c8df190f5ddb61a1d" + }, + "demonstrations/raw/raw_npz/train_data_174.npz": { + "bytes": 4930699, + "sha256": "cd2d5f56f7a3bb77acf6bc6a766363019474dd8b409c83ca23075c20991a7647" + }, + "demonstrations/raw/raw_npz/train_data_175.npz": { + "bytes": 4241668, + "sha256": "4cc0a3b29a35d2070c9a53a0568f1cd055dc52000335419a8b40ccb732a94caf" + }, + "demonstrations/raw/raw_npz/train_data_176.npz": { + "bytes": 4438534, + "sha256": "1cc07ee321906e883d2ecf7a4c88a11e98925ccd94f413531deed46f7b02ebaf" + }, + "demonstrations/raw/raw_npz/train_data_177.npz": { + "bytes": 3651070, + "sha256": "3ca2d97c219bb1be6628be49b0f348b3a9d565000019031a009d9bc5a506c7af" + }, + "demonstrations/raw/raw_npz/train_data_178.npz": { + "bytes": 3847936, + "sha256": "cb68c709162fcc707de44d8e90211dee5828535b3d7f20ce6a9bdc25d9fe93dc" + }, + "demonstrations/raw/raw_npz/train_data_179.npz": { + "bytes": 4438534, + "sha256": "5e276b1cbebf65370b11f8627caa17715ea28949a009fd97bc8b9775120bf3ec" + }, + "demonstrations/raw/raw_npz/train_data_18.npz": { + "bytes": 4241668, + "sha256": "a4449a420cef345bef738d4c48924d3ae0604cd8cfe817a3715de4f5f8433ad5" + }, + "demonstrations/raw/raw_npz/train_data_180.npz": { + "bytes": 4635400, + "sha256": "d9b4723ada48b5f275bcce74861e843b5e682f15c93b6c8048411849c75c2a4c" + }, + "demonstrations/raw/raw_npz/train_data_181.npz": { + "bytes": 4832266, + "sha256": "9691fa96352ae54f940904a5bc94117eb2eb534ba979f0143f13f2e95fc9f277" + }, + "demonstrations/raw/raw_npz/train_data_182.npz": { + "bytes": 5029132, + "sha256": "8ad46cd699f44a60aa04823ade618dca44ec6015ce2e874ccb6c0a073c3e566e" + }, + "demonstrations/raw/raw_npz/train_data_183.npz": { + "bytes": 4635400, + "sha256": "8948f4de898f48941424e61e972c6d2feab001ec1bebaa51ac3efa59e528906a" + }, + "demonstrations/raw/raw_npz/train_data_184.npz": { + "bytes": 4241668, + "sha256": "ccf73d021c58b8269ffbd6572f4eaeac4f1d20b172d760a271b78adf373e22fa" + }, + "demonstrations/raw/raw_npz/train_data_185.npz": { + "bytes": 4241668, + "sha256": "2733ebfcd4fb7fec23ccb7779cf1d0b40d34c9e8018a35109a49ff51fe9fa8fe" + }, + "demonstrations/raw/raw_npz/train_data_186.npz": { + "bytes": 4536967, + "sha256": "25851c9d7d0e039013a86a6448951edfed45da190f2dce0462eb8f075a9d18be" + }, + "demonstrations/raw/raw_npz/train_data_187.npz": { + "bytes": 4044802, + "sha256": "b7f5e0409620b1c6f17054045756639275d1100223a2d4619a8a9f7a700f2297" + }, + "demonstrations/raw/raw_npz/train_data_188.npz": { + "bytes": 3847936, + "sha256": "2b32c9a6ec6aa9a55a800f33464860eda99a86520853648b4f285e98efd1c98b" + }, + "demonstrations/raw/raw_npz/train_data_189.npz": { + "bytes": 4044802, + "sha256": "5271ad153b0058601d5017ac89b8b7fa58f5204f9f533d6a8c2c99aeba25148d" + }, + "demonstrations/raw/raw_npz/train_data_19.npz": { + "bytes": 4832266, + "sha256": "88fc34bb84aaac6113b623c7564835a311ab3977bb6c18504668c4e28f24b9b0" + }, + "demonstrations/raw/raw_npz/train_data_190.npz": { + "bytes": 4241668, + "sha256": "30f54638610694b2757fe7f5ce8855dd7aae40ffbba088610491aad4b42af5b2" + }, + "demonstrations/raw/raw_npz/train_data_191.npz": { + "bytes": 4438534, + "sha256": "9db74391d77dd555e1b0d531ace0b646b4ffc94e58ab7eebc0b20b6a5747f5be" + }, + "demonstrations/raw/raw_npz/train_data_192.npz": { + "bytes": 4635400, + "sha256": "07590a9235224c6a7829f776de28d0d2cc8045710631d1b4a768ac87c1043476" + }, + "demonstrations/raw/raw_npz/train_data_193.npz": { + "bytes": 4241668, + "sha256": "c4a9618c2546d0a12fdbefc6fa113ae4d63cef2b7bc197fb7dbe6dd0cae2b4ab" + }, + "demonstrations/raw/raw_npz/train_data_194.npz": { + "bytes": 4241668, + "sha256": "70fd2062ab7f39e92cd930fa99f0149631d7ab0ce584268dd31ba0829d9bd0e8" + }, + "demonstrations/raw/raw_npz/train_data_195.npz": { + "bytes": 5029132, + "sha256": "647d145818abbda7f29bf3d85445ebea493f5ed48d983e2dc65f94c8fe7119d3" + }, + "demonstrations/raw/raw_npz/train_data_196.npz": { + "bytes": 3847936, + "sha256": "5261480711c29edc46857e54a912f922e5055472f61af6b7a0fc9fca0edf0271" + }, + "demonstrations/raw/raw_npz/train_data_197.npz": { + "bytes": 4635400, + "sha256": "d5c0b6119d0c2be61a42d38835107e5f19b543b30cb8c7d82f1f04fec223243d" + }, + "demonstrations/raw/raw_npz/train_data_198.npz": { + "bytes": 4044802, + "sha256": "0c11b6d6108873034dca714339e9cf79f31ae5003401bc277fb9bbd99aa4581f" + }, + "demonstrations/raw/raw_npz/train_data_199.npz": { + "bytes": 4635400, + "sha256": "90c2020b4695a32ba33720f1fab0c9fbafc6f9e8ae9c9279e5323456dfb338a3" + }, + "demonstrations/raw/raw_npz/train_data_2.npz": { + "bytes": 4930699, + "sha256": "e59ab9bc5e9ab987b51cb0d8812690b552ed0f54b43fe9e86867dc82cd7980f5" + }, + "demonstrations/raw/raw_npz/train_data_20.npz": { + "bytes": 4635400, + "sha256": "52c74c8a940ec93f975d567abde25148ceb26812747bb015c6303f8056c67006" + }, + "demonstrations/raw/raw_npz/train_data_200.npz": { + "bytes": 4241668, + "sha256": "f1f4177bb85cd609df7bd9b7734a324608ca1b5dccca09e720d676aa73f7458e" + }, + "demonstrations/raw/raw_npz/train_data_201.npz": { + "bytes": 4438534, + "sha256": "91782e5fb7641825b61950da9ebd1c7d0c1c908db7e53a78036e400bf84ff2d6" + }, + "demonstrations/raw/raw_npz/train_data_202.npz": { + "bytes": 4044802, + "sha256": "e4133f3f3ddb4d1c4223fde1b7b3226704aabf5b9405f26b7ed172fc6e4587d6" + }, + "demonstrations/raw/raw_npz/train_data_203.npz": { + "bytes": 5127565, + "sha256": "e74ded681804def4b07df430457eaf441651d8635f980f9241dc680777db78db" + }, + "demonstrations/raw/raw_npz/train_data_204.npz": { + "bytes": 4635400, + "sha256": "3e16c8fe33cbf67c77f8100847b9ecc6ce0a17da0c9ad4e78bedd82221b9528c" + }, + "demonstrations/raw/raw_npz/train_data_205.npz": { + "bytes": 4241668, + "sha256": "24ec245601acfe51a8811343773b4cf764cd5cdc20f1e086592ef9d4998043ed" + }, + "demonstrations/raw/raw_npz/train_data_206.npz": { + "bytes": 4241668, + "sha256": "fcd8237950909f4b3190228af65f83a595dd2bf17c94f591fa781f306e66a348" + }, + "demonstrations/raw/raw_npz/train_data_207.npz": { + "bytes": 4438534, + "sha256": "a44c695c573d7ed6b9cce83356ad674efe723fb32ef7c6f22e09427ce60a5d30" + }, + "demonstrations/raw/raw_npz/train_data_208.npz": { + "bytes": 4044802, + "sha256": "a563a022eb522e96d219102dda32c3d9663be60d9007304517196b8c74585410" + }, + "demonstrations/raw/raw_npz/train_data_209.npz": { + "bytes": 4832266, + "sha256": "040e3ba0706e5a1c48e3d00dee309d61b1d453aa8aefbbc2e09211930d073151" + }, + "demonstrations/raw/raw_npz/train_data_21.npz": { + "bytes": 4340101, + "sha256": "174daab81590a5ec83b6d209ec14ed588663252b82e4492bb594268e0cf4cdb4" + }, + "demonstrations/raw/raw_npz/train_data_210.npz": { + "bytes": 4241668, + "sha256": "ba9ebba4be42ab0a3eb5f7f79b3a2e7f143148074b05ca64a2411c2996e5013e" + }, + "demonstrations/raw/raw_npz/train_data_211.npz": { + "bytes": 4832266, + "sha256": "78b70fd8372170d2b01bd53c300f09c5d1170904e8f6f9b84e22e79fde70ff61" + }, + "demonstrations/raw/raw_npz/train_data_212.npz": { + "bytes": 4635400, + "sha256": "edb287ea093b7c5bf2305c887da5aae5450cf70ce15f85adf85edad9a46e2fae" + }, + "demonstrations/raw/raw_npz/train_data_213.npz": { + "bytes": 4438534, + "sha256": "14d9386e6a91ae034da0c70d08f256ac0807f6a79205ce31110efe0a5d632b26" + }, + "demonstrations/raw/raw_npz/train_data_214.npz": { + "bytes": 4832266, + "sha256": "92f21d588934d16b7ea6784f19520c455c2af8ba3dc65ad7034fe4c8200e2cd8" + }, + "demonstrations/raw/raw_npz/train_data_215.npz": { + "bytes": 4832266, + "sha256": "1c9367e09f8027760a7ef317adbba068251a8ba2263fee577ba61b8936af9a68" + }, + "demonstrations/raw/raw_npz/train_data_216.npz": { + "bytes": 4635400, + "sha256": "4ea035e5f0ab7f6903bb91b32e2d90a9d471424e27431305816cf7a14370e98a" + }, + "demonstrations/raw/raw_npz/train_data_217.npz": { + "bytes": 3847936, + "sha256": "7454dbe041747395eb8d012c7782395e86e96e05c85a347eb57b243383c1b0f0" + }, + "demonstrations/raw/raw_npz/train_data_218.npz": { + "bytes": 4438534, + "sha256": "489f525b51e008056124e2d1668589e83b9409d884701a3e7edabfc2a249624c" + }, + "demonstrations/raw/raw_npz/train_data_219.npz": { + "bytes": 4438534, + "sha256": "dd7fd756ff37e55dea0b35f4805f3d47350bbeb8e929451b8a5b95b4c6388ba8" + }, + "demonstrations/raw/raw_npz/train_data_22.npz": { + "bytes": 4438534, + "sha256": "41c789f548478fb7f09d92eedb4592242a262e312632481cac5ce826deb76be7" + }, + "demonstrations/raw/raw_npz/train_data_220.npz": { + "bytes": 4044802, + "sha256": "c4c6f1ea4248bfb53b20fb9ce17f1626de0860829b1b04d68fb559787238538b" + }, + "demonstrations/raw/raw_npz/train_data_221.npz": { + "bytes": 4044802, + "sha256": "59a1d0ee324864910f1a42d2cba66d850a7fa78da1533cc4db467043285b6d90" + }, + "demonstrations/raw/raw_npz/train_data_222.npz": { + "bytes": 4438534, + "sha256": "8f2fef5b036c970b2f61bec9273865c2fc3155ca659742c30ea6c6ffc79d54f5" + }, + "demonstrations/raw/raw_npz/train_data_223.npz": { + "bytes": 4241668, + "sha256": "dc0ae4b3a5df2b2c30da2904584d3f7076c5449a90e14bde27c5f04ed0d8ae09" + }, + "demonstrations/raw/raw_npz/train_data_224.npz": { + "bytes": 4438534, + "sha256": "4e4fe5fbb473db83ca0254a84181ac4efe686987b23a803fa48fe50b9b29ab10" + }, + "demonstrations/raw/raw_npz/train_data_225.npz": { + "bytes": 4044802, + "sha256": "9d43664b6e61174348a9e375429586b88543b518ef3032edda3d515f6f8d9b88" + }, + "demonstrations/raw/raw_npz/train_data_226.npz": { + "bytes": 4044802, + "sha256": "72683d209e6a3737a53f416d0102379df6dc177189b60ac78afcaf7b958ce165" + }, + "demonstrations/raw/raw_npz/train_data_227.npz": { + "bytes": 4044802, + "sha256": "625565795215d33d1b524d58f1ec347c50f225d8fcf3c10a6dcd4354e1f600f5" + }, + "demonstrations/raw/raw_npz/train_data_228.npz": { + "bytes": 3847936, + "sha256": "0e1b9b3c94f4a2edbca5a82609f2c131c089b477af66287200e4262637dd3fcf" + }, + "demonstrations/raw/raw_npz/train_data_229.npz": { + "bytes": 4044802, + "sha256": "94871c40293acc0a381035f3166acb3fb942f522a04f50d74a522494d76bd23e" + }, + "demonstrations/raw/raw_npz/train_data_23.npz": { + "bytes": 4438534, + "sha256": "a76637a5bedf717bc26fb16e04bfe148ddfa5f7880e55cae3cd79ceb9f118b92" + }, + "demonstrations/raw/raw_npz/train_data_230.npz": { + "bytes": 4044802, + "sha256": "e0ab4febb026a1ea855636ab0c55959a1b92417c9fe8c6a9e6c0cc897e1d81a4" + }, + "demonstrations/raw/raw_npz/train_data_231.npz": { + "bytes": 4438534, + "sha256": "2de3e96f76a51bdb1f3629e7a074bd787d151dac30a33148adbd7f0ba28b781d" + }, + "demonstrations/raw/raw_npz/train_data_232.npz": { + "bytes": 4438534, + "sha256": "c79aa5a31b5f1e091b23c413706f5322faf505aa3d9bfe417d51ca82dc001b86" + }, + "demonstrations/raw/raw_npz/train_data_233.npz": { + "bytes": 4241668, + "sha256": "6726d2fa0e3fab4f54d8afacf4993faf25904b2d97923df3fbdf186cf3f08444" + }, + "demonstrations/raw/raw_npz/train_data_234.npz": { + "bytes": 4635400, + "sha256": "c6a9c6f98fa892ef14aef8227537c8e104265f925497c1bba12997ee6a266a35" + }, + "demonstrations/raw/raw_npz/train_data_235.npz": { + "bytes": 4438534, + "sha256": "25757dfc7fb8d251c83bab62c3f663f22b8b84577bc889e1ecb7440b0da75b59" + }, + "demonstrations/raw/raw_npz/train_data_236.npz": { + "bytes": 4635400, + "sha256": "f82514dafc212486587aaf8ed9ae8810ad496bea59a3d72e586b3c87d3db191b" + }, + "demonstrations/raw/raw_npz/train_data_237.npz": { + "bytes": 4241668, + "sha256": "d3cf499d8875dc59357c1e4675dbaf7cf8a1a2d0c6d8fc9f5178efb2361bf67e" + }, + "demonstrations/raw/raw_npz/train_data_238.npz": { + "bytes": 4635400, + "sha256": "7296c6eb0035c2264013b1d4981293f1ffa515e67b96d84fd5c81e2e0b527680" + }, + "demonstrations/raw/raw_npz/train_data_239.npz": { + "bytes": 4832266, + "sha256": "cec708606b02a6cfba1edf9b1f4db4104a218bd840305d9ac230a6a91bf91d90" + }, + "demonstrations/raw/raw_npz/train_data_24.npz": { + "bytes": 5029132, + "sha256": "eb3bbc2cd7077bf03a00656cbcff0144120fa651b378668e16efaf642936dc1f" + }, + "demonstrations/raw/raw_npz/train_data_240.npz": { + "bytes": 4241668, + "sha256": "a9178878f4f9fb1e9d3cb42a827741cde715028a849f1268e7c800f9e5958d4b" + }, + "demonstrations/raw/raw_npz/train_data_241.npz": { + "bytes": 4044802, + "sha256": "02e3bd9b323e4990efd8f0826490c12ff2b4b1c3cd9664a6fc2272d2289066fa" + }, + "demonstrations/raw/raw_npz/train_data_242.npz": { + "bytes": 4241668, + "sha256": "3a0d880045b1d69502257f00f3174735f9008fa102471ca0e43eeebb88418c9a" + }, + "demonstrations/raw/raw_npz/train_data_243.npz": { + "bytes": 3651070, + "sha256": "965d5b40d62a57f8a6abfae84104266da2d863a22f4b1c8a3febc63cb6f600c1" + }, + "demonstrations/raw/raw_npz/train_data_244.npz": { + "bytes": 4241668, + "sha256": "605bde7c2fd044d73e67fec535ced27beb7a21b5f51007ffe6657ba97cb7e4de" + }, + "demonstrations/raw/raw_npz/train_data_245.npz": { + "bytes": 4044802, + "sha256": "51f9592360985a782f409326f1994cbc38ec7629fe5543d1ee427c208422dbe2" + }, + "demonstrations/raw/raw_npz/train_data_246.npz": { + "bytes": 4044802, + "sha256": "72cc77b6306932ba89b8f44c5a1ac71f071feede303d8c50619c3cc6f193dbae" + }, + "demonstrations/raw/raw_npz/train_data_247.npz": { + "bytes": 4241668, + "sha256": "e86dbdb1ed3ae5cf3dc15bc5009ee7187d9106a73f07786ee039e5a926ae6df7" + }, + "demonstrations/raw/raw_npz/train_data_248.npz": { + "bytes": 4438534, + "sha256": "4d17976a64be286b3549e0d472fbc2830bfc763e5d03a97e875309eea235c47b" + }, + "demonstrations/raw/raw_npz/train_data_249.npz": { + "bytes": 4635400, + "sha256": "2f6804439f0ab4cc07773ebbfc471ecdcb3ed01304dc3ffbe860f1eb760b1190" + }, + "demonstrations/raw/raw_npz/train_data_25.npz": { + "bytes": 3847936, + "sha256": "a60ca4b3162d88649404e6b0d554bf8e701f58300f415bab35d5b6587d3bc856" + }, + "demonstrations/raw/raw_npz/train_data_250.npz": { + "bytes": 4635400, + "sha256": "75aa5fe8c8716558f7eae89a8f6dbfce58b1b55be91b2c70dcefbf0978c00d75" + }, + "demonstrations/raw/raw_npz/train_data_251.npz": { + "bytes": 4635400, + "sha256": "6c4db0db41b09daff95817308106ab0d0a88b032bca52125a3b0c48b4deeaa38" + }, + "demonstrations/raw/raw_npz/train_data_252.npz": { + "bytes": 5422864, + "sha256": "b97088387a5f38ebedb8d5bbca5cca13490753dd7f864d20d2ed443b6beba8d0" + }, + "demonstrations/raw/raw_npz/train_data_253.npz": { + "bytes": 4241668, + "sha256": "35ff51ad0b1f25abec128b9c9e81b4e63b2ffaab32473592a1fceefcad78aa04" + }, + "demonstrations/raw/raw_npz/train_data_254.npz": { + "bytes": 4241668, + "sha256": "4628316bf4af09c3f6e966163898a9e3c0b7bd29bf9436a3a0c1b69090dbf394" + }, + "demonstrations/raw/raw_npz/train_data_255.npz": { + "bytes": 3847936, + "sha256": "16fcac643e1890316d0a46674ff66b18ce019c69e6f1f17909fa2ac7d7c78ecf" + }, + "demonstrations/raw/raw_npz/train_data_256.npz": { + "bytes": 4438534, + "sha256": "155d57a104eb8a548624f8d702353fcd041c42b262a29e0c3f2ae42fbfa27cf2" + }, + "demonstrations/raw/raw_npz/train_data_257.npz": { + "bytes": 3847936, + "sha256": "38ea0eadd3f7f66d4179521677a0702d4aeca59230c6c277452797b7a33ca6a7" + }, + "demonstrations/raw/raw_npz/train_data_258.npz": { + "bytes": 4241668, + "sha256": "a9eb5bfca5d0eb1764e324f09d47da765f3bb0a160c20dd119b09ed5e0cf1cc3" + }, + "demonstrations/raw/raw_npz/train_data_259.npz": { + "bytes": 4832266, + "sha256": "04872a25e3741327756649438ca84316aa56355d381ddd8bfb19e6b78122ab00" + }, + "demonstrations/raw/raw_npz/train_data_26.npz": { + "bytes": 4340101, + "sha256": "c66fcc015cd79623fbbb9c17cd316d77c13c192264b17f5f072bd12db0c9ee52" + }, + "demonstrations/raw/raw_npz/train_data_260.npz": { + "bytes": 4340101, + "sha256": "c3186c02c99d11cb3c911e5849982503d3a05a7ff0213edf60df084b8a7f1d6d" + }, + "demonstrations/raw/raw_npz/train_data_261.npz": { + "bytes": 4438534, + "sha256": "58578118c1dab93c37a74003edb2ba2b2a6098a0432c87b058357c1aae9acc0e" + }, + "demonstrations/raw/raw_npz/train_data_262.npz": { + "bytes": 4635400, + "sha256": "140ad1f352754a3f6d04f2702cca211c0aa8b20b6b059772d334cbbea70b0785" + }, + "demonstrations/raw/raw_npz/train_data_263.npz": { + "bytes": 4044802, + "sha256": "9eeb043994c69f674723b71ce30d9d2b08285edef05ee8c512687266068e23a9" + }, + "demonstrations/raw/raw_npz/train_data_264.npz": { + "bytes": 4635400, + "sha256": "c464736390f9a8b524f80843eefa3b85f199c443b97561b12e79030b196aff19" + }, + "demonstrations/raw/raw_npz/train_data_265.npz": { + "bytes": 4438534, + "sha256": "0f3276ee17a2734394a0edddb778dcdc31a0ee08ef92d5db35f7054f6b572282" + }, + "demonstrations/raw/raw_npz/train_data_266.npz": { + "bytes": 4241668, + "sha256": "9a6dbbb752b8c06dc174262af6c808975b903156aca7a0bc218bbda0a19e6f08" + }, + "demonstrations/raw/raw_npz/train_data_267.npz": { + "bytes": 4832266, + "sha256": "3f03e65503440ced43e050d97a88e7e3fa17acf73a09581695140c2845bf950a" + }, + "demonstrations/raw/raw_npz/train_data_268.npz": { + "bytes": 3847936, + "sha256": "0700f9d14103da33ad22017e956743a22a0f8ad89b7a2f3d0a348e3f4423502b" + }, + "demonstrations/raw/raw_npz/train_data_269.npz": { + "bytes": 3847936, + "sha256": "dd038add22fa21442efd524dc236a7f158a670e47c9fc04803b0769b5d239ce4" + }, + "demonstrations/raw/raw_npz/train_data_27.npz": { + "bytes": 4241668, + "sha256": "cd72bdadf018f8cd2aa20aa83e68860730a84df03844c99396c5f3ae49533486" + }, + "demonstrations/raw/raw_npz/train_data_270.npz": { + "bytes": 4438534, + "sha256": "0d570a93be46f1a11ef71ae08166ea9fdc99a5b166687254c243aed75da43015" + }, + "demonstrations/raw/raw_npz/train_data_271.npz": { + "bytes": 4635400, + "sha256": "cd00de3e2781aba2e9395f1740927afe32d22b592b6407554af000b602efe621" + }, + "demonstrations/raw/raw_npz/train_data_272.npz": { + "bytes": 4044802, + "sha256": "d84abd8e513b2d57bd6992edd194fba9e31724826633d5c498828fc20449bf69" + }, + "demonstrations/raw/raw_npz/train_data_273.npz": { + "bytes": 4635400, + "sha256": "49a1c28d16615fd9d733c957353917874a3e4922de8aba642386dd98564e360e" + }, + "demonstrations/raw/raw_npz/train_data_274.npz": { + "bytes": 3847936, + "sha256": "0d8b297b9d359702367ba87d30f43ec48ae89f231450ad11f39fdb97cb67853c" + }, + "demonstrations/raw/raw_npz/train_data_28.npz": { + "bytes": 5029132, + "sha256": "b5320a7657c27e5d2fb13b4c4f98c01b94eccbd9fb30bc48bf21f10d32dd7fc5" + }, + "demonstrations/raw/raw_npz/train_data_29.npz": { + "bytes": 4044802, + "sha256": "44480d115355f8a5d76e46c4995fd090bda3a2a69b9b0850d822576e24ddc100" + }, + "demonstrations/raw/raw_npz/train_data_3.npz": { + "bytes": 4635400, + "sha256": "713d0bde7d5ba202d6e49b87b6b92f9f8f265883e98b89f4f64a10f93a8b7b39" + }, + "demonstrations/raw/raw_npz/train_data_30.npz": { + "bytes": 4438534, + "sha256": "35564e399d62452ae4ae7bef7a4ab4e7ffd6b7e14bca0b8be411127a1500c9e6" + }, + "demonstrations/raw/raw_npz/train_data_31.npz": { + "bytes": 4635400, + "sha256": "2e79eb8cac26cbe65bd6bea360aa0235bf8e8c80d590737fb921288c0068fa04" + }, + "demonstrations/raw/raw_npz/train_data_32.npz": { + "bytes": 4044802, + "sha256": "f7616c9ad1a1aa7403578c23962ea8dd47c3c557a0fdeb9be033585e9acf0969" + }, + "demonstrations/raw/raw_npz/train_data_33.npz": { + "bytes": 4832266, + "sha256": "f3b742cb21c1f3b570ac7a9d01511008cef31f7455fe360a664890923b1a0141" + }, + "demonstrations/raw/raw_npz/train_data_34.npz": { + "bytes": 4241668, + "sha256": "7f7e2931461c4948cfc4bac96c5deea8fd4e11153f1757667f12f9ffdf4ab11a" + }, + "demonstrations/raw/raw_npz/train_data_35.npz": { + "bytes": 4438534, + "sha256": "7f584bc1d0f132de30cf60e46e72992103fd1ed869310b8d80179cf82496ca71" + }, + "demonstrations/raw/raw_npz/train_data_36.npz": { + "bytes": 4241668, + "sha256": "36143726ba26431a4b196e37b5c00e46a83961ec048c451a65c1731108dd9696" + }, + "demonstrations/raw/raw_npz/train_data_37.npz": { + "bytes": 4635400, + "sha256": "d727ca4c244ef44d8861b255224ceb49ce0e851148817135353e62023deab5d3" + }, + "demonstrations/raw/raw_npz/train_data_38.npz": { + "bytes": 4635400, + "sha256": "8eed4560105df8799518ac5d3180875cca4a2d38b4ed7351111e672ac0d92154" + }, + "demonstrations/raw/raw_npz/train_data_39.npz": { + "bytes": 4438534, + "sha256": "cda5ac3d01bcbac63c9d8903db82e5b6be2e7788ba62f88b0a45a9027f440fab" + }, + "demonstrations/raw/raw_npz/train_data_4.npz": { + "bytes": 4635400, + "sha256": "e8900ae34148d591b52a07e35b087a41756dc40875c7fcf07142ac35c886f085" + }, + "demonstrations/raw/raw_npz/train_data_40.npz": { + "bytes": 4438534, + "sha256": "fa4ad02c303feae3cf067bae4b1c65bbfc7be6fe286f7b48980aa3f079fbf717" + }, + "demonstrations/raw/raw_npz/train_data_41.npz": { + "bytes": 4241668, + "sha256": "cb76da95fcd05e3ada4d458c2cc497b7f17d28a54bb936e1cb5df38adfcf4445" + }, + "demonstrations/raw/raw_npz/train_data_42.npz": { + "bytes": 4044802, + "sha256": "dec6fcff4fe73fef8427c965560b3404f544f1d9b6b7edbb3577bbd65377f99b" + }, + "demonstrations/raw/raw_npz/train_data_43.npz": { + "bytes": 4832266, + "sha256": "a7aecc5aed769c4cb9a6dff9838730e293e1f056530afb2bdc930c195ef0ac91" + }, + "demonstrations/raw/raw_npz/train_data_44.npz": { + "bytes": 4241668, + "sha256": "c944511da34496365c5b359db2010c5a0f42d2a6c392e8c4fef67aad540335d8" + }, + "demonstrations/raw/raw_npz/train_data_45.npz": { + "bytes": 4438534, + "sha256": "7d3a1c53e76f89eb6827766842c5269945518d17128c4d306f82e827762d9820" + }, + "demonstrations/raw/raw_npz/train_data_46.npz": { + "bytes": 5225998, + "sha256": "a95331f1016895127233337aba7835ec720d5c2086ac101088694ae7bbf0f667" + }, + "demonstrations/raw/raw_npz/train_data_47.npz": { + "bytes": 4241668, + "sha256": "8e9e566ea04f0e7946c73e02d0aedf8008fb46055c6a779ae34852b0987fb2ce" + }, + "demonstrations/raw/raw_npz/train_data_48.npz": { + "bytes": 4044802, + "sha256": "6e39d49739ea6998183bb739161de0d3bd70b403ea688a91db5ca9b98ed14995" + }, + "demonstrations/raw/raw_npz/train_data_49.npz": { + "bytes": 4438534, + "sha256": "7fef2d9842cabd054be217a5daa37bd8ca3a302e05d04394db979ce75539515e" + }, + "demonstrations/raw/raw_npz/train_data_5.npz": { + "bytes": 4044802, + "sha256": "b951945f3f698d14e9a37807ca77fbb7bea6afe5334c60c6cb451816cbc47d39" + }, + "demonstrations/raw/raw_npz/train_data_50.npz": { + "bytes": 4438534, + "sha256": "5ab30ad72cda954e4cfa52344b20500bc392419f5d215cd94f232a108f0f52c3" + }, + "demonstrations/raw/raw_npz/train_data_51.npz": { + "bytes": 3847936, + "sha256": "1c9475d8290d78ddd880a39211496b9d95cb9abfd6aac903b61e7c62e3a4653b" + }, + "demonstrations/raw/raw_npz/train_data_52.npz": { + "bytes": 4438534, + "sha256": "39832cfa3ead2636b73edd2704a2954fddf9f425aed445fb4f7586fb17860e0b" + }, + "demonstrations/raw/raw_npz/train_data_53.npz": { + "bytes": 4832266, + "sha256": "951d80d39c2400fcbc0d384adc342f87994c681fa7cb7f2e988bba9fba66dc61" + }, + "demonstrations/raw/raw_npz/train_data_54.npz": { + "bytes": 4241668, + "sha256": "fc0968808517611c7ebd275e572c954c86d9861c9216a9d1585b955244828965" + }, + "demonstrations/raw/raw_npz/train_data_55.npz": { + "bytes": 4241668, + "sha256": "730c6716d2a2980ce4e5883fca23b1919f92615a7450f241f75ea08d659fc2d3" + }, + "demonstrations/raw/raw_npz/train_data_56.npz": { + "bytes": 4438534, + "sha256": "37394a154b2f9c1a7121540c432e9d5bff504e5792c1116c584bf3bb4e6641eb" + }, + "demonstrations/raw/raw_npz/train_data_57.npz": { + "bytes": 4438534, + "sha256": "7704eaaf40c7a2dcea8b64cfe2d4b3f9e32990c0ebbadeb7d096bec52b7f21f3" + }, + "demonstrations/raw/raw_npz/train_data_58.npz": { + "bytes": 3847936, + "sha256": "325c1de37a64a8b3d45caa162733f64af3a1ae6906d76a6946d6cdeae9820338" + }, + "demonstrations/raw/raw_npz/train_data_59.npz": { + "bytes": 4438534, + "sha256": "ee08d0f108943b24d5d0742536916703a409c3c1eaaebf6ccdf73b5a6df97ff8" + }, + "demonstrations/raw/raw_npz/train_data_6.npz": { + "bytes": 4536967, + "sha256": "3d080746b440cae809adcee2898c40cdb32044dcd94b628dc1ec16c95d071c0f" + }, + "demonstrations/raw/raw_npz/train_data_60.npz": { + "bytes": 4241668, + "sha256": "55c9255dc842bdf0cea317e564d922cabba74688338aee131147bed1ef4a9125" + }, + "demonstrations/raw/raw_npz/train_data_61.npz": { + "bytes": 3847936, + "sha256": "379ddbe8eb09d1e55693180c1d5256215d305703903a8b90d182060e5b5b7988" + }, + "demonstrations/raw/raw_npz/train_data_62.npz": { + "bytes": 4832266, + "sha256": "ae3f74dfc9299d71ae86507f408149c402e33b69a5c04058c6a3b940991f647f" + }, + "demonstrations/raw/raw_npz/train_data_63.npz": { + "bytes": 4044802, + "sha256": "eb15280fe51fb290e33ff963cd4e952af96c1d08a7b2a25c366c1f0bfc70156d" + }, + "demonstrations/raw/raw_npz/train_data_64.npz": { + "bytes": 4438534, + "sha256": "a9cbc2686cb488ac1a40f0c1fff9eb99eb9039a3495f4d229c7127bf74c3a5a7" + }, + "demonstrations/raw/raw_npz/train_data_65.npz": { + "bytes": 5225998, + "sha256": "7962a5412e474ac2725ca0f011cd4a35b79c337646d5bc951ebe55d4d43ed854" + }, + "demonstrations/raw/raw_npz/train_data_66.npz": { + "bytes": 4438534, + "sha256": "180d71389b17cab2374d25f197811dae597e17bb653cdc1024deab98ce854a18" + }, + "demonstrations/raw/raw_npz/train_data_67.npz": { + "bytes": 4241668, + "sha256": "e8e212f683c1c7f735f32d77f578759d65ffda99510c5944f9566e2c112a9bec" + }, + "demonstrations/raw/raw_npz/train_data_68.npz": { + "bytes": 4635400, + "sha256": "b8588299b74a5ece659f8a98486c11b2d74e30fbb4259758a81579ead261adf5" + }, + "demonstrations/raw/raw_npz/train_data_69.npz": { + "bytes": 4241668, + "sha256": "ba878963d8a03e4d7ac64b1472ecee1637664766f4b371405e99f868a8d3be56" + }, + "demonstrations/raw/raw_npz/train_data_7.npz": { + "bytes": 4438534, + "sha256": "204354927c0c97883ef390ab205207e8849686c089983cd79d9c6c311518946f" + }, + "demonstrations/raw/raw_npz/train_data_70.npz": { + "bytes": 4044802, + "sha256": "c00c035ad562b7430c38677f718c247f1b6f5131a0da4697da79f022c786bf02" + }, + "demonstrations/raw/raw_npz/train_data_71.npz": { + "bytes": 4832266, + "sha256": "b675d10a6198f809bf7e899d89b47dc8e0fa8327f6e19c8b0b5dff2206e235e1" + }, + "demonstrations/raw/raw_npz/train_data_72.npz": { + "bytes": 4241668, + "sha256": "d3edb3a33a0e624a2b1d32497ee8c3c35b5fbd9115f88f243ae94d4ed6190ecb" + }, + "demonstrations/raw/raw_npz/train_data_73.npz": { + "bytes": 4536967, + "sha256": "91e30e47c4ce5d691c9772fc049929b2a2da6c0307725716eaa1b6ba6fc2b436" + }, + "demonstrations/raw/raw_npz/train_data_74.npz": { + "bytes": 5225998, + "sha256": "f6419b22ddaa2515991d015168eddca669bfeebcd25642b90e8c6dae60eb89e5" + }, + "demonstrations/raw/raw_npz/train_data_75.npz": { + "bytes": 4241668, + "sha256": "a1341585bad232ad73347f86ec6ff98fe4c4bf9617823a5abe3ca660d0df63ba" + }, + "demonstrations/raw/raw_npz/train_data_76.npz": { + "bytes": 4635400, + "sha256": "cc7137dbb32da2b7cb6662a5aad049dd437837965bda1ad207decea1b2b9d2a3" + }, + "demonstrations/raw/raw_npz/train_data_77.npz": { + "bytes": 4241668, + "sha256": "bdd07d47a5da836dd0217ef07701405a2d442da8ed8412b380fa16c06dad7526" + }, + "demonstrations/raw/raw_npz/train_data_78.npz": { + "bytes": 4241668, + "sha256": "ecebc5966faea7d2c4aee865c96604a8dbfc7a7726cc3774a545960e4942a80d" + }, + "demonstrations/raw/raw_npz/train_data_79.npz": { + "bytes": 4044802, + "sha256": "942e4e34b69cca483ff1ef9962209a4f79344e4ecccdda80b7038fb3c269aebf" + }, + "demonstrations/raw/raw_npz/train_data_8.npz": { + "bytes": 4241668, + "sha256": "09425e9fd5f214318bb041fb476172d44cd367c1a03331ca72367f02ccece425" + }, + "demonstrations/raw/raw_npz/train_data_80.npz": { + "bytes": 5127565, + "sha256": "3e0504d3abc9dafffe588f6f55314f5b4b306323b4254250bbb995862ea848be" + }, + "demonstrations/raw/raw_npz/train_data_81.npz": { + "bytes": 4733833, + "sha256": "88dbb571d02f53e76f2746104ac10e9a44109183689e05bc20369f86901aa006" + }, + "demonstrations/raw/raw_npz/train_data_82.npz": { + "bytes": 4635400, + "sha256": "c7c39bcb495615dfcecfc9e55eed11a0d87a268f222e707240aabe15ed7361b8" + }, + "demonstrations/raw/raw_npz/train_data_83.npz": { + "bytes": 4044802, + "sha256": "163f584763d383b6444e685632c739f70bbe030aff1181a4cfd78b1003b66404" + }, + "demonstrations/raw/raw_npz/train_data_84.npz": { + "bytes": 3847936, + "sha256": "b1fedb687e38768c8656792e1e550aa51d3757b8caf89d470cb5b7dd0b637234" + }, + "demonstrations/raw/raw_npz/train_data_85.npz": { + "bytes": 4635400, + "sha256": "4657b5b6e2226e727ba922c4263285fe5e05f8f1d275312f07b12ac9bf068ed6" + }, + "demonstrations/raw/raw_npz/train_data_86.npz": { + "bytes": 4438534, + "sha256": "6412b826f40f86db6a36a4c4e1669bcb241b8759098303aab061cef46fb9bf8e" + }, + "demonstrations/raw/raw_npz/train_data_87.npz": { + "bytes": 5029132, + "sha256": "c326017ac939b7419cb4582a34b37a1d0c285998e594c48862e469b493a20331" + }, + "demonstrations/raw/raw_npz/train_data_88.npz": { + "bytes": 4832266, + "sha256": "d6d8f7fed355f09c3e53b2d85a7306ec2a5179ad2068b159539bb61799f8306c" + }, + "demonstrations/raw/raw_npz/train_data_89.npz": { + "bytes": 3847936, + "sha256": "f99a96e0e447bebc32cf401d782c55bb121c36ab149ca96bd2096ed3ad8ae1ef" + }, + "demonstrations/raw/raw_npz/train_data_9.npz": { + "bytes": 3847936, + "sha256": "970f8d0a2ab9b4dc095246fe15f1e18d698376e785c4a51eccfb36aa8c5b184c" + }, + "demonstrations/raw/raw_npz/train_data_90.npz": { + "bytes": 4044802, + "sha256": "6c7fa5581c0e14c59896afd5e9cacc6f26e7d1141df63c29a790429211e462b9" + }, + "demonstrations/raw/raw_npz/train_data_91.npz": { + "bytes": 4832266, + "sha256": "91c5eb8532c325862df91f90df1e093445c87a7bc895803710d02cfcc0c0e9c2" + }, + "demonstrations/raw/raw_npz/train_data_92.npz": { + "bytes": 4340101, + "sha256": "41d874e92f9992a6e8f3dcb5b4925a4c6add49f1235f5c35562a277d986bc19f" + }, + "demonstrations/raw/raw_npz/train_data_93.npz": { + "bytes": 4832266, + "sha256": "ce5a044e1f7812eb74fcc64996523b165cf5e9b883232894868b20100ef93a86" + }, + "demonstrations/raw/raw_npz/train_data_94.npz": { + "bytes": 4438534, + "sha256": "5e0cb1448719e142d180c5a94ea9ffe78f96470e855e65dc4aab8308943e1374" + }, + "demonstrations/raw/raw_npz/train_data_95.npz": { + "bytes": 4241668, + "sha256": "438a3b55e03c2f81638919dd4e42eac5c5e4714f7414fc378f8252688bc2c814" + }, + "demonstrations/raw/raw_npz/train_data_96.npz": { + "bytes": 4635400, + "sha256": "7b9034eaf8daaddac273a8b8551d62c0289a507f65c7b46f6feb37529a0b8d31" + }, + "demonstrations/raw/raw_npz/train_data_97.npz": { + "bytes": 4044802, + "sha256": "303d4768a8b4e3fbae803c4e6f9a2650b37a13a68cd5b00290d1f141791d31e3" + }, + "demonstrations/raw/raw_npz/train_data_98.npz": { + "bytes": 3847936, + "sha256": "82536395dc50cbe35e3ef84d172470caa4e2d7275f331ce5b947b62c355f703f" + }, + "demonstrations/raw/raw_npz/train_data_99.npz": { + "bytes": 4635400, + "sha256": "05a2540c05ff7df5a9fb84b50af74be943d3fe9f05d6dc64f255659bd2b0e778" + }, + "demonstrations/raw/train_manifest.jsonl": { + "bytes": 45545, + "sha256": "0d60150ee4d550eaf9bc1878a86639a79115130bc7f08cb0624d731008592f07" + }, + "demonstrations/raw/val_manifest.jsonl": { + "bytes": 4560, + "sha256": "0004dbbff0a3b6e7f313688c3930e09cb7740b80030706d454d886846d57571e" + }, + "demonstrations/validation/collection.complete.json": { + "bytes": 3134, + "sha256": "ce3effc9d3267edf410642d0ecd3b5b7790c072e1ff5d0f79eeab4ae883fe1a1" + }, + "demonstrations/validation/dataset.audit.raw.json": { + "bytes": 2781, + "sha256": "9d43628d04ce4d13870705072f85ee8d2eae68ae53ae902c73b676f208713774" + }, + "demonstrations/validation/dataset.split.audit.json": { + "bytes": 32184, + "sha256": "9ba50f311a5f53e3188ad59bb0379b3dcd580402f0b482c0bd328acfc9d497e0" + }, + "evidence/collect_intercept.py": { + "bytes": 5452, + "sha256": "bd00e0d2fbb899f8e69473a7b9efea667ec829795c91f4ddec2ff8d10a0ff5fc" + }, + "evidence/collector.source.py": { + "bytes": 32673, + "sha256": "7072e7b65e5af4f6886cb79b73c22b0e63b0b37b5b410115740283346316df73" + }, + "evidence/convert_npz_task_to_rlds.py": { + "bytes": 5964, + "sha256": "a3cb8fe930fbc991d967fa63028a58c2d433c326bfd5009987f27c1289d4b014" + }, + "evidence/convert_rlds_to_lerobot.py": { + "bytes": 16785, + "sha256": "ea3ed7f42027a2fc5f179ba7afbfcd62e89989956966e5a54be05c2452daeb64" + }, + "evidence/latency.yaml": { + "bytes": 801, + "sha256": "68e4f5d7733e603b0caf55e3b914c3e941eaed7bce73385c5854c717de5c1250" + }, + "evidence/mikasa_dataset_dataset_builder.py": { + "bytes": 7443, + "sha256": "fa95f5530d0e25263edfd7eeab67bfbf4530be8cfa9eafe455a132e21eb0f276" + }, + "evidence/profile.source.json": { + "bytes": 2190, + "sha256": "31a9b15d6b04182439934f0b377cb3d09be16ce21f3cf95c1049918f8a5d4984" + }, + "provenance.json": { + "bytes": 6270, + "sha256": "b651c27549ff4cd0394fff009b7364991b25e6a3b6efb49b60febe81e5900578" + } +} diff --git a/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/provenance.json b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/provenance.json new file mode 100644 index 0000000000000000000000000000000000000000..7a4155d56b65b99236cfc6580247a16edc521286 --- /dev/null +++ b/latency-aware/intercept-grab-fast/mean_rtx3090_h1_s123_275ep_v1/provenance.json @@ -0,0 +1,364 @@ +{ + "task": "mikasa_intercept_grab_fast", + "teacher": { + "repo_id": "latency-sensitive-bench/benchmark-models", + "revision": "ba7e4f3b6047b82711de01432a7d5bf3895df8b4", + "path": "latency-aware/mikasa-intercept-grab-fast/small-policy/ppo-qwenoft-rtx3090-mean-h1-s123-v1", + "status": "complete_verified", + "local_checkpoint": "/home/ubuntu/lzj/mean-profiling/intercept/teacher-publication/checkpoint.pt", + "completed_env_steps": 149975040, + "completed_iterations": 2441, + "selected_env_steps": 32256000, + "selected_iteration": 525, + "tensor_count": 17, + "weights_only_export": true, + "tensor_equality_verified": true, + "hash_readback_verified": true, + "url": "https://huggingface.co/latency-sensitive-bench/benchmark-models/tree/ba7e4f3b6047b82711de01432a7d5bf3895df8b4/latency-aware/mikasa-intercept-grab-fast/small-policy/ppo-qwenoft-rtx3090-mean-h1-s123-v1", + "completed_utc": "2026-09-30T16:34:58.230455+00:00" + }, + "collection": { + "episodes": 275, + "unique_seeds": 275, + "rows": 12211, + "length_min": 37, + "length_max": 55, + "all_success_once": true, + "state_dim": 7, + "action_dim": 7, + "rgb_shape": [ + 128, + 128, + 6 + ], + "finite_numeric": true, + "latency_raw_frames": 2, + "applied_command_matches_source_issued_action": true, + "action_horizon": 1, + "dagger": false, + "raw_bytes": 1204453838, + "episode_seeds": [ + 0, + 1, + 10, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 11, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 12, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 13, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 14, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 15, + 220, + 221, + 222, + 223, + 224, + 225, + 226, + 227, + 228, + 229, + 16, + 230, + 231, + 232, + 233, + 234, + 235, + 236, + 237, + 238, + 239, + 17, + 240, + 241, + 242, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 18, + 250, + 251, + 252, + 253, + 254, + 255, + 256, + 257, + 258, + 259, + 19, + 260, + 261, + 262, + 263, + 264, + 265, + 266, + 267, + 268, + 269, + 2, + 100, + 270, + 271, + 272, + 273, + 274, + 30, + 31, + 32, + 33, + 34, + 101, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 102, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 103, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 104, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 105, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 106, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 107, + 95, + 96, + 97, + 98, + 99, + 108, + 109, + 3, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 4, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 5, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 6, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 7, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 8, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 9, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179 + ], + "train_episodes": 250, + "val_episodes": 25, + "train_rows": 11119, + "val_rows": 1092, + "teacher_checkpoint": "/home/ubuntu/lzj/mean-profiling/intercept/teacher-publication/checkpoint.pt", + "teacher_sha256": "e47526f03fad3ed251dd78f3cacfba8aa8b60bd1578f40bd7a1393e17298e973", + "fixed_latency_ms": 99.05021289731565, + "conversion_complete": true + }, + "split": { + "source": "originalTFDS episode_metadata.file_path,shuffle_files=false", + "train_rows": 11119, + "val_rows": 1092, + "unique_seeds": 275, + "split_intersection": 0 + }, + "profile": { + "mean_ms": 99.05021289731565, + "profile": "/home/ubuntu/lzj/profiles/intercept-published/profiles/qwenoft/1x-rtx3090/mikasa_intercept_grab_fast/instance_3a0d42681a03715c/profile.json", + "sha256": "31a9b15d6b04182439934f0b377cb3d09be16ce21f3cf95c1049918f8a5d4984" + }, + "runtime": { + "repo": "c3c6a39365a151e9b7a5e215452fd64e957c2b29", + "starvla": "ccca13c5177fe3d3c884b6e2de4965d916016649", + "runtime_fixes": [ + "mean-profile-preparation.patch", + "gym-language-contract.patch", + "loader-spawn-cache.patch", + "loader-spawn-test.patch", + "doom-mean-reset.patch" + ], + "pytorch3d": { + "revision": "33824be3cbc87a7dd1db0f6a9a9de9ac81b2d0ba", + "build": "transforms-only, no native render extension; QwenOFT uses transforms only" + }, + "decord": { + "version": "0.6.0", + "build": "official source CPU decoder CP310", + "wheel_sha256": "e193b356b1e984b4eff08d23b62e482c2c9e5037a6efdc0b1af47079ae2e4c47" + } + }, + "condition": "fixed_mean_RTX3090_profile", + "raw_format": "original unpickled per-episode NPZ arrays", + "viewer_configs": "metadata manifests with NPZ paths; not per-step arrays", + "conversion": "original NPZ->RLDS->LeRobot, actualTFDS250/25 splits, fps20", + "vla_training_status": "not started", + "closed_loop_evaluation_status": "pending" +}