wip: checkpoint paused Go2 FL four-skill development

This commit is contained in:
2026-10-16 17:39:37 +08:00
parent 37d1b03b1a
commit 77c2978700
29 changed files with 4071 additions and 51 deletions
+5 -3
View File
@@ -1,8 +1,10 @@
# SkillFactory v0.0.2
仓库:[chenlin/SkillFactory](https://gitea.robotquan.com/chenlin/SkillFactory)。真实机器人部件资产导入、仿真控制与技能训练;当前主线为 **Go2 FL有辅助单腿接触周期仿真功能版0.4.2**,不是整机或实机技能。
> **0.5.0四技能开发已按用户要求暂停(2026-10-16)**:仅WIP检查点,尚无合格训练候选/新版本验收;[进度与证据](docs/current_status.md)、[恢复前置](docs/next_stage.md)。不要自动使用原48小时剩余预算继续运行。
## 当前基线
仓库:[chenlin/SkillFactory](https://gitea.robotquan.com/chenlin/SkillFactory)。真实机器人部件资产导入、仿真控制与技能训练;上一已封包基线为 **Go2 FL有辅助单腿接触周期仿真功能版0.4.2**,不是整机或实机技能。
## 上一已封包基线(0.4.2)
- 可调用Python/CLI:启动、查询、有限命令队列、安全停止;默认解析控制,可选冻结u256残差。
- 0.4.2实测解析S1 GUI/headless各6连续周期、27000tick,完整轨迹与0.4.1逐字节一致。GUI截图33.98FPS;物理推进仅GUI **0.07060×**、headless **0.18325×**,不是实时仿真。
@@ -16,7 +18,7 @@
3. [0.4.2实测结果](docs/contact_cycle_sim_performance_v042_result.md) / [证据路径](docs/evidence_index.md)。
4. [软硬件描述v2](docs/software_hardware_spec.md):Schema与静态校验已实现,通用运行adapter尚未实现。
独立已封包交付:`performance_v042/deliveries/go2_fl_contact_cycle_sim-0.4.2/`,真实GUI演示入口`bash demo_gui.sh`。运行会创建新的有限会话/输出,整理任务本身不启动仿真。训练默认RTX5080,CPU回归不等于物理验证;[执行边界](docs/execution_authority.md)。
独立已封包交付:`performance_v042/deliveries/go2_fl_contact_cycle_sim-0.4.2/`,在该独立目录内运行`bash demo_gui.sh`。仓库根同名脚本现为未完成0.5.0开发入口,默认冻结权重尚未提供,不作为当前交付;旧根入口副本为`demo_gui_v042.sh`。运行会创建新的有限会话/输出,整理任务本身不启动仿真。训练默认RTX5080,CPU回归不等于物理验证;[执行边界](docs/execution_authority.md)。
## 文件保留原则
+494
View File
@@ -0,0 +1,494 @@
{
"format": "skillfactory.four-skills-paused-progress.v1",
"status": "paused_by_user_not_accepted",
"paused_at": "2026-10-16T17:29:13+08:00",
"recorded_at": "2026-10-16T17:37:59.908314+08:00",
"base_commit": "37d1b03b1a97170014cfc58258a8a82da2f59fb2",
"current_development_revision": 2,
"qualified_candidate": false,
"revision2_native_validation": "not_run",
"independent_evaluation_seeds_executed": [],
"three_sequences_five_loops": "not_run",
"native_illegal_switch_and_airborne_stop_probes": "not_run",
"training_weights_status": "u218revision1 diagnostic only; incompatible config identity withrevision2; no resume permission",
"automatic_continuation": false,
"resume_requires_new_user_instruction": true,
"original_stage_grant_reusable": false,
"pause_check": {
"native_four_skill_processes_alive": false,
"gpu_compute_processes": [],
"pending_reviewer": "stopped"
},
"reserved_launches_NOT_actual_Kit_instances": 9,
"reserved_physics_calls_NOT_actual_total": 640000,
"actual_total_physics_calls": null,
"actual_total_limitation": "Some failed/cancelled attempts lack final worker counters. Last progress is not a final total; no guessed aggregate.",
"verification": {
"current_new_cpu_suite": {
"passed": 139,
"failed": 0,
"seconds": 5.71,
"command": "/home/cen/miniconda3/envs/linker_sim_isaac/bin/python scripts/test_cpu.py tests/test_four_skills*.py"
},
"earlier_full_retained_cpu_suite_before_latest_revision2_changes": {
"passed": 1726,
"skipped": 3,
"seconds": 115.59
},
"syntax_ast_and_bash": "passed",
"git_diff_check": "passed",
"prior_protected_files_unchanged": 363,
"last_revision2_independent_review": "stopped at user pause; not an approval",
"validation_during_pause_was_CPU_only": true
},
"important_local_artifacts_not_in_git": [
{
"path": "logs/four_skills_v050/training01/latest.pt",
"exists": true,
"bytes": 604987,
"sha256": "1937c363d2f9236caee832ae4ae599ca02b05b8c0d5e094e60ff30c641b9bbc7"
},
{
"path": "logs/four_skills_v050/training01/source_snapshot/configs/four_skills/v050.json",
"exists": true,
"bytes": 3063,
"sha256": "2868f4cc72eadb8a3f539ce51962a888921a70c3355caba031be92cd6df6d684"
},
{
"path": "logs/four_skills_v050/training01/source_snapshot/source/SkillFactory/SkillFactory/tasks/manager_based/four_skills/mdp.py",
"exists": true,
"bytes": 18807,
"sha256": "2c40efefbb4acd5272eade52025ed9d3845f52df43ebd688aec274cc049a652a"
},
{
"path": "logs/four_skills_v050/training01/parent-intervention.json",
"exists": true,
"bytes": 443,
"sha256": "059eff8736c892f36096544489712c3c5d146103e8ae37262b3a3a02f2c88590"
},
{
"path": "logs/four_skills_v050/gui-bootstrap02/live-kit-original-speed.mp4",
"exists": true,
"bytes": 7276434,
"sha256": "3c2c68e18c397ce0d2aaa059a42d425c5b79b9a2ba2fca0b671695a92b92ff84"
},
{
"path": "logs/four_skills_v050/gui-bootstrap02/gui-evidence.json",
"exists": true,
"bytes": 6146,
"sha256": "dff5209df437a428889986532fad286d8154321d79274ed060187b7ae6f23905"
},
{
"path": "logs/four_skills_v050/PAUSED.json",
"exists": true,
"bytes": 461,
"sha256": "812a5e5e36f89ba06ad1211a3f191d464e2c1459a4286bdbccb58e33bb911075"
}
],
"native_data_distribution": "Original approximately602MiB under ignored logs/four_skills_v050; not committed. Source clone is not a complete runtime/evidence package.",
"new_default_demo_weights_present": false,
"next_steps_after_explicit_resume": [
"Re-register bounded resumed scope, never silently revive old scope/grants.",
"Finish review and native revision2 analytic/GUI validation plus bounded training preflight.",
"Fresh GPU training, development candidate selection/freeze, untouched independent-seed paired evaluation.",
"Three directions/holds each5continuousloops; native illegal switch/airborne-safe-stop; genuine GUI/video/package acceptance."
],
"attempts": [
{
"name": "bootstrap01",
"mode": "smoke",
"development_revision": 1,
"output": "logs/four_skills_v050/bootstrap01",
"reserved_calls_no_refund": 15000,
"original_supervisor_success": false,
"original_worker_functional_success": null,
"original_worker_training_complete": null,
"owned_cleanup": true,
"waited_exit": true,
"native_returncode": 1,
"final_physics_calls": null,
"last_durable_completed_update": null,
"last_durable_training_environment_transitions": null,
"physics_calls_at_last_complete_update_NOT_final_total": null,
"reason_or_scope": "Private worker rejected parent identity before Kit startup.",
"receipts": [
{
"path": "logs/four_skills_v050/bootstrap01/worker-result.json",
"exists": false,
"bytes": null,
"sha256": null
},
{
"path": "logs/four_skills_v050/bootstrap01/supervisor-result.json",
"exists": true,
"bytes": 15987,
"sha256": "6f692b9e82febc5bcba872eb14f210fc61ce85f8db850235ac0df5bbc706767a"
},
{
"path": "logs/four_skills_v050/bootstrap01/progress.jsonl",
"exists": false,
"bytes": null,
"sha256": null
},
{
"path": "logs/four_skills_v050/bootstrap01/stdout.log",
"exists": true,
"bytes": 884,
"sha256": "89bf194d516358aafe2bd2cb0bb0d9fd89872a9e37761af2e9d6c27aa4895220"
}
]
},
{
"name": "bootstrap02",
"mode": "smoke",
"development_revision": 1,
"output": "logs/four_skills_v050/bootstrap02",
"reserved_calls_no_refund": 15000,
"original_supervisor_success": false,
"original_worker_functional_success": null,
"original_worker_training_complete": null,
"owned_cleanup": true,
"waited_exit": true,
"native_returncode": 1,
"final_physics_calls": null,
"last_durable_completed_update": null,
"last_durable_training_environment_transitions": null,
"physics_calls_at_last_complete_update_NOT_final_total": null,
"reason_or_scope": "Exact parent entry check rejected relative script path before Kit startup.",
"receipts": [
{
"path": "logs/four_skills_v050/bootstrap02/worker-result.json",
"exists": false,
"bytes": null,
"sha256": null
},
{
"path": "logs/four_skills_v050/bootstrap02/supervisor-result.json",
"exists": true,
"bytes": 15987,
"sha256": "12facf0ccd312858116e9c48d7217cbd2e648b12687dbc621941c5b81d878f47"
},
{
"path": "logs/four_skills_v050/bootstrap02/progress.jsonl",
"exists": false,
"bytes": null,
"sha256": null
},
{
"path": "logs/four_skills_v050/bootstrap02/stdout.log",
"exists": true,
"bytes": 922,
"sha256": "8b567f2887b88854c301feee4190b8c33e959cba8ac25328033d1ad22cd7162b"
}
]
},
{
"name": "bootstrap03",
"mode": "smoke",
"development_revision": 1,
"output": "logs/four_skills_v050/bootstrap03",
"reserved_calls_no_refund": 15000,
"original_supervisor_success": false,
"original_worker_functional_success": false,
"original_worker_training_complete": null,
"owned_cleanup": true,
"waited_exit": true,
"native_returncode": 1,
"final_physics_calls": null,
"last_durable_completed_update": null,
"last_durable_training_environment_transitions": null,
"physics_calls_at_last_complete_update_NOT_final_total": null,
"reason_or_scope": "Inherited reward configuration field missing, before environment construction.",
"receipts": [
{
"path": "logs/four_skills_v050/bootstrap03/worker-result.json",
"exists": true,
"bytes": 1143,
"sha256": "ed7567b822caff9c5e3cc171548af4fb0b5817726d302cb6cdb0c739c190aaf9"
},
{
"path": "logs/four_skills_v050/bootstrap03/supervisor-result.json",
"exists": true,
"bytes": 17125,
"sha256": "2f93b8b25929d6254e3adc660392a589afbed20753d3505d0e532d2ebedb3378"
},
{
"path": "logs/four_skills_v050/bootstrap03/progress.jsonl",
"exists": false,
"bytes": null,
"sha256": null
},
{
"path": "logs/four_skills_v050/bootstrap03/stdout.log",
"exists": true,
"bytes": 1699,
"sha256": "19d1a54329bbaff3d32f700bf8a8d1560113bdf0b05e1239e23d89e643aebce4"
}
]
},
{
"name": "bootstrap04",
"mode": "smoke",
"development_revision": 1,
"output": "logs/four_skills_v050/bootstrap04",
"reserved_calls_no_refund": 15000,
"original_supervisor_success": true,
"original_worker_functional_success": true,
"original_worker_training_complete": null,
"owned_cleanup": true,
"waited_exit": true,
"native_returncode": 0,
"final_physics_calls": 4505,
"last_durable_completed_update": null,
"last_durable_training_environment_transitions": null,
"physics_calls_at_last_complete_update_NOT_final_total": null,
"reason_or_scope": "Revision1 analytic one-loop native bootstrap passed.",
"receipts": [
{
"path": "logs/four_skills_v050/bootstrap04/worker-result.json",
"exists": true,
"bytes": 1830,
"sha256": "6e785679ff57a42e0212aa0bf91639e00c674886a285ae03a430fe5b6c5234df"
},
{
"path": "logs/four_skills_v050/bootstrap04/supervisor-result.json",
"exists": true,
"bytes": 24900,
"sha256": "17904697960a2edd049c601843db1766254d105633ae3a7b22e77c6edbd0f166"
},
{
"path": "logs/four_skills_v050/bootstrap04/progress.jsonl",
"exists": false,
"bytes": null,
"sha256": null
},
{
"path": "logs/four_skills_v050/bootstrap04/stdout.log",
"exists": true,
"bytes": 6313,
"sha256": "b19e11182fad35fb9b6eea4d001a439357e1627862bc5d20a1177e3b5ef46401"
}
]
},
{
"name": "training-preflight01",
"mode": "train",
"development_revision": 1,
"output": "logs/four_skills_v050/training-preflight01",
"reserved_calls_no_refund": 160000,
"original_supervisor_success": false,
"original_worker_functional_success": false,
"original_worker_training_complete": null,
"owned_cleanup": true,
"waited_exit": true,
"native_returncode": 1,
"final_physics_calls": null,
"last_durable_completed_update": null,
"last_durable_training_environment_transitions": null,
"physics_calls_at_last_complete_update_NOT_final_total": null,
"reason_or_scope": "One feedback sample triggered more than one skill transition; first optimizer not reached.",
"receipts": [
{
"path": "logs/four_skills_v050/training-preflight01/worker-result.json",
"exists": true,
"bytes": 1291,
"sha256": "1372ecfd1c21ffa656cc0d64f2c275eec24a1861eae1bd90212ac1061596b0dd"
},
{
"path": "logs/four_skills_v050/training-preflight01/supervisor-result.json",
"exists": true,
"bytes": 18640,
"sha256": "4d011db41acac7b89f5287dc67f0b2ffbfa3bebe46ec6181faa28facc90795b1"
},
{
"path": "logs/four_skills_v050/training-preflight01/progress.jsonl",
"exists": false,
"bytes": null,
"sha256": null
},
{
"path": "logs/four_skills_v050/training-preflight01/stdout.log",
"exists": true,
"bytes": 6959,
"sha256": "64eb605f55a06bad197f8aa5ea7568b07de8158619eda2f64250b4354c41227f"
}
]
},
{
"name": "training-preflight02",
"mode": "train",
"development_revision": 1,
"output": "logs/four_skills_v050/training-preflight02",
"reserved_calls_no_refund": 160000,
"original_supervisor_success": true,
"original_worker_functional_success": false,
"original_worker_training_complete": true,
"owned_cleanup": true,
"waited_exit": true,
"native_returncode": 0,
"final_physics_calls": 640,
"last_durable_completed_update": 2,
"last_durable_training_environment_transitions": 16384,
"physics_calls_at_last_complete_update_NOT_final_total": 640,
"reason_or_scope": "Two-update native GPU preflight completed, not full four-skill qualification.",
"receipts": [
{
"path": "logs/four_skills_v050/training-preflight02/worker-result.json",
"exists": true,
"bytes": 1087,
"sha256": "f75a8724f241f45312219505466ff6d5009cda0605a237023d3b0922d68fc416"
},
{
"path": "logs/four_skills_v050/training-preflight02/supervisor-result.json",
"exists": true,
"bytes": 19262,
"sha256": "ba82e0452bbaa62fac710e0abe91fd35011102a755d53af7dfc758e439ede4dc"
},
{
"path": "logs/four_skills_v050/training-preflight02/progress.jsonl",
"exists": true,
"bytes": 894,
"sha256": "646d133f94859a7fc589ae4b1039aa5df3a49c59cc900b610a559ebe7aed4729"
},
{
"path": "logs/four_skills_v050/training-preflight02/stdout.log",
"exists": true,
"bytes": 7672,
"sha256": "997256f46a5b08af663123ab32c5347eef39317b12fa6043887f2f43b64f4814"
}
]
},
{
"name": "gui-bootstrap01",
"mode": "gui",
"development_revision": 1,
"output": "logs/four_skills_v050/gui-bootstrap01",
"reserved_calls_no_refund": 50000,
"original_supervisor_success": false,
"original_worker_functional_success": true,
"original_worker_training_complete": null,
"owned_cleanup": true,
"waited_exit": true,
"native_returncode": 0,
"final_physics_calls": 4505,
"last_durable_completed_update": null,
"last_durable_training_environment_transitions": null,
"physics_calls_at_last_complete_update_NOT_final_total": null,
"reason_or_scope": "Physical loop complete, but ffmpeg SIGINT exit255 caused original task failure; not reclassified.",
"receipts": [
{
"path": "logs/four_skills_v050/gui-bootstrap01/worker-result.json",
"exists": true,
"bytes": 2498,
"sha256": "d749ebe6b7691dbce8363a2ac536f59de9cb8c0aed8ab97e90198a306c219236"
},
{
"path": "logs/four_skills_v050/gui-bootstrap01/supervisor-result.json",
"exists": true,
"bytes": 38207,
"sha256": "e9e2a18d81573b9532437b902302cf9978ef2db4c2a9b5e5e3c83d36d50ddacc"
},
{
"path": "logs/four_skills_v050/gui-bootstrap01/progress.jsonl",
"exists": false,
"bytes": null,
"sha256": null
},
{
"path": "logs/four_skills_v050/gui-bootstrap01/stdout.log",
"exists": true,
"bytes": 1514145,
"sha256": "5e6eba93078052290a6b822066dc10a1ca2a313ab5a66437e3ca8ffff997c56f"
}
]
},
{
"name": "gui-bootstrap02",
"mode": "gui",
"development_revision": 1,
"output": "logs/four_skills_v050/gui-bootstrap02",
"reserved_calls_no_refund": 50000,
"original_supervisor_success": true,
"original_worker_functional_success": true,
"original_worker_training_complete": null,
"owned_cleanup": true,
"waited_exit": true,
"native_returncode": 0,
"final_physics_calls": 4505,
"last_durable_completed_update": null,
"last_durable_training_environment_transitions": null,
"physics_calls_at_last_complete_update_NOT_final_total": null,
"reason_or_scope": "Revision1 analytic small-tier one-loop GUI/video/normal-close bootstrap passed; ready PNGs have one-frame UI lag.",
"receipts": [
{
"path": "logs/four_skills_v050/gui-bootstrap02/worker-result.json",
"exists": true,
"bytes": 8435,
"sha256": "90475a39ff06c60faadc3e9749e907ef0b0795d492feba07608b12b779e4c80d"
},
{
"path": "logs/four_skills_v050/gui-bootstrap02/supervisor-result.json",
"exists": true,
"bytes": 37719,
"sha256": "16f492331a1202812d502298ada2ff39958b96d1d30ea26f6eef36933b8edc26"
},
{
"path": "logs/four_skills_v050/gui-bootstrap02/progress.jsonl",
"exists": false,
"bytes": null,
"sha256": null
},
{
"path": "logs/four_skills_v050/gui-bootstrap02/stdout.log",
"exists": true,
"bytes": 25482,
"sha256": "6f9925e76924ae40523551b0153a368e81ce80d8abdea3fb9225ca5ec42ec756"
}
]
},
{
"name": "training01",
"mode": "train",
"development_revision": 1,
"output": "logs/four_skills_v050/training01",
"reserved_calls_no_refund": 160000,
"original_supervisor_success": false,
"original_worker_functional_success": null,
"original_worker_training_complete": null,
"owned_cleanup": true,
"waited_exit": true,
"native_returncode": -15,
"final_physics_calls": null,
"last_durable_completed_update": 218,
"last_durable_training_environment_transitions": 1785856,
"physics_calls_at_last_complete_update_NOT_final_total": 69760,
"reason_or_scope": "Parent stopped at218completeupdates after confirmed hold-liveness/phase-reward defects; no candidate. Final worker receipt absent.",
"receipts": [
{
"path": "logs/four_skills_v050/training01/worker-result.json",
"exists": false,
"bytes": null,
"sha256": null
},
{
"path": "logs/four_skills_v050/training01/supervisor-result.json",
"exists": true,
"bytes": 109066,
"sha256": "6c4549f159049875713580030b5361d7fe7db78214640d844712ce0b1a5142f5"
},
{
"path": "logs/four_skills_v050/training01/progress.jsonl",
"exists": true,
"bytes": 103056,
"sha256": "c78c4af2ca31654382bc22a4aca9cd17f26136c133a91449ccf4cf68b5541a11"
},
{
"path": "logs/four_skills_v050/training01/stdout.log",
"exists": true,
"bytes": 112391,
"sha256": "6d6d6e1e9c6e34a1528d2d456eee01f487d3000b8884f6abc49b2e05cccd09da"
}
]
}
]
}
+28
View File
@@ -0,0 +1,28 @@
{
"format": "skillfactory.four-skills.v0.5.0",
"task_id": "SkillFactory-Go2FL-FourSkills-v0",
"development_revision": 2,
"physics_dt_s": 0.002,
"decimation": 5,
"residual_limit_rad": 0.05,
"observation_dim": 48,
"skills": ["support", "retract", "swing", "plant"],
"transition_seconds": {"support": 0.0, "retract_unload": 1.0, "retract_lift": 0.6, "swing": 1.4, "plant_lower": 0.8, "plant_reload": 2.2},
"clearance_m": 0.05,
"swing_arc_m": 0.01,
"gate": {"support_normal_weight_fraction_min": 0.5, "support_contact_ratio_min": 0.8, "support_dwell_s": 0.2, "air_gap_min_m": 0.01, "air_normal_max_N": 2.0, "air_dwell_s": 0.1, "unload_remaining_fraction_max": 0.8, "swing_signed_progress_min_fraction": 0.5, "landing_error_max_m": 0.05, "root_height_error_max_m": 0.1, "tilt_max_rad": 0.6, "penetration_max_m": 0.002, "normalized_effort_velocity_max": 1.00001, "joint_excess_max_rad": 0.01, "original_late_lift_gap_min_m": 0.02, "original_reload_check_progress": 0.8, "negative_normal_tolerance_N": 0.5, "auxiliary_vertical_max_N": 140.0, "auxiliary_lever_arm_max_m": 0.06},
"hold_watchdog": "Each legitimate skill/hold request fixes its own intrinsic transition plus requested hold plus2s slack deadline; readiness flicker never extends it. First-readiness deadline and0.2s bad-hold protection remain. Completed held endpoints may persist indefinitely within run budget.",
"reward": "Original phase_objective (ground-level unload tracking, Fn-aware lift/swing, touchdown impact and load restoration) plus0.5ready minus0.02residual_energy minus10failure; no sampled force parameters in actor/critic.",
"transition_deadline_extra_s": 2.0,
"hold_max_s": 10.0,
"force": {"tiers_N": {"none": 0.0, "small": 1.5, "medium": 4.0, "full": 8.0}, "slot_s": 2.0, "active_probability": 0.8, "onset_offset_s": [0.2, 0.5], "duration_s": [0.5, 1.3], "ramp_s": 0.15, "frame": "world", "body": "virtual_payload", "point": "actual_payload_COM", "couple_Nm": [0.0, 0.0, 0.0], "actor_sees_parameters": false},
"training": {"seed": 105011, "validation_seed": 115011, "independent_seeds": [125011, 125023, 125039, 125053, 125069, 125083, 125101, 125113], "num_envs": 128, "horizon": 64, "updates": 256, "max_wall_s": 64800, "checkpoint_interval": 16, "validation_interval": 64, "tier_updates": [[1, 32, "none"], [33, 96, "small"], [97, 176, "medium"], [177, 256, "full"]], "algorithm": {"learning_rate": 0.0003, "adam_eps": 0.00001, "gamma": 0.99, "gae_lambda": 0.95, "clip_ratio": 0.2, "epochs": 4, "minibatch_size": 1024, "value_coefficient": 0.5, "max_gradient_norm": 1.0, "target_kl": 0.03}},
"sequences": [
{"id": "x_forward", "direction_m": [0.024, 0.010], "holds_s": [0.5, 0.3, 0.4, 0.5], "loops": 5},
{"id": "diagonal", "direction_m": [0.020, 0.024], "holds_s": [1.0, 0.5, 0.8, 0.7], "loops": 5},
{"id": "y_forward", "direction_m": [0.010, 0.024], "holds_s": [1.5, 0.8, 1.0, 1.0], "loops": 5}
],
"acceptance": {"central_all_three_sequences_five_loops_required": true, "independent_cases_per_tier": 8, "minimum_success_fraction_each_tier": 0.875, "no_disturbance_success_fraction": 1.0, "candidate_selection": "development-only success fraction then task reward; no independent-seed reselection", "improvement_claim": "only paired independent outcomes; ties or worse are not improvement"},
"auxiliary": "UNCHANGED original CycleState active equivalent-other-leg vertical support only during unloading/flight, kp1800,kd120,max140N; same bounded passive XY/rotation guide and exactly zero vertical guide; skill-local progress drives original fraction, not central force labels. No stronger auxiliary or external-force cancellation feedforward.",
"scope": "aided floating-root Go2 FL single leg, simulation truth; no hardware, sim2real, multi-leg or whole-robot claim"
}
+15 -8
View File
@@ -1,13 +1,20 @@
#!/usr/bin/env bash
# Genuine live Kit window, not the offline FK animation. No training.
# Genuine live four-skill Kit demo; explicit fresh bounded session, no training.
set -euo pipefail
ROOT=$(cd -- "$(dirname -- "$0")" && pwd)
: "${DISPLAY:?A local graphical DISPLAY is required for the real Kit window}"
OUT=${SKILL_DEMO_OUTPUT:-$(mktemp -d "${TMPDIR:-/tmp}/go2-fl-gui.XXXXXXXX")}
OUT=${SKILL_DEMO_OUTPUT:-$(mktemp -d "${TMPDIR:-/tmp}/go2-fl-four-skills.XXXXXXXX")}
mkdir -p "$OUT"
CLI="$ROOT/scripts/go2_fl_skill.py"
echo "Live GUI S1 (analytic); new simulation evidence: $OUT"
echo "Close Kit while running = ABORT. After completion, final frame stays (max 10 min)."
/usr/bin/python3.12 "$CLI" authorize --registration "$OUT/session/registration.json"
/usr/bin/python3.12 "$CLI" run --registration "$OUT/session/registration.json" --output "$OUT/S1" --sequence S1 --controller analytic --gui
/usr/bin/python3.12 "$CLI" status --output "$OUT/S1"
CONTROLLER=${SKILL_CONTROLLER:-trained}
CHECKPOINT=${SKILL_CHECKPOINT:-"$ROOT/releases/go2_fl_four_skills-0.5.0/weights.pt"}
ARGS=(gui --new-session "$OUT/session" --name demo --controller "$CONTROLLER"
--tier "${SKILL_TIER:-small}" --sequence "${SKILL_SEQUENCE:-0}" --loops 5)
if [[ "$CONTROLLER" == trained ]]; then
[[ -f "$CHECKPOINT" ]] || { echo "Frozen0.5.0 weights not found: $CHECKPOINT" >&2; exit 2; }
ARGS+=(--checkpoint "$CHECKPOINT")
fi
if [[ -n ${SKILL_STOP_SKILL:-} ]]; then ARGS+=(--stop-skill "$SKILL_STOP_SKILL"); fi
echo "Go2 FL four skills0.5.0 | $CONTROLLER | real Kit window and original-speed recording"
echo "Output: $OUT/session/demo"
echo "SAFE STOP plants then supports; closing while active=ABORT. Not1x real-time physics."
/usr/bin/python3.12 "$ROOT/scripts/four_skills.py" "${ARGS[@]}"
+13
View File
@@ -0,0 +1,13 @@
#!/usr/bin/env bash
# Genuine live Kit window, not the offline FK animation. No training.
set -euo pipefail
ROOT=$(cd -- "$(dirname -- "$0")" && pwd)
: "${DISPLAY:?A local graphical DISPLAY is required for the real Kit window}"
OUT=${SKILL_DEMO_OUTPUT:-$(mktemp -d "${TMPDIR:-/tmp}/go2-fl-gui.XXXXXXXX")}
mkdir -p "$OUT"
CLI="$ROOT/scripts/go2_fl_skill.py"
echo "Live GUI S1 (analytic); new simulation evidence: $OUT"
echo "Close Kit while running = ABORT. After completion, final frame stays (max 10 min)."
/usr/bin/python3.12 "$CLI" authorize --registration "$OUT/session/registration.json"
/usr/bin/python3.12 "$CLI" run --registration "$OUT/session/registration.json" --output "$OUT/S1" --sequence S1 --controller analytic --gui
/usr/bin/python3.12 "$CLI" status --output "$OUT/S1"
+3 -1
View File
@@ -1,9 +1,11 @@
# 文档入口
**当前0.5.0四技能开发已暂停,未完成验收。** 先读[状态与本机证据](current_status.md)、[恢复交接](next_stage.md);[四技能合同](four_skills_v050.md)不是完成声明。旧0.4.2原包保持不变。
## 下一阶段必读
1. [当前状态](current_status.md):已验证能力、历史失败及未验证项。
2. [下一阶段](next_stage.md):现有接口集成优先,不默认扩训/扩域。
2. [下一阶段](next_stage.md):等待用户明确恢复;先复核并验证revision2修正。
3. [公开接口](go2_fl_skill_v4_api.md) / [运行与CPU回归](contact_cycle_runtime.md)。
4. [0.4.2实测结果](contact_cycle_sim_performance_v042_result.md) / [证据索引](evidence_index.md)。
5. [执行边界](execution_authority.md):自主预设护栏,新会话/绑定/输出,不复用旧grant。
+31 -18
View File
@@ -1,26 +1,39 @@
# 当前状态:Go2 FL仿真功能版0.4.2
# 当前状态:四技能0.5.0开发检查点,用户已暂停
阶段已完成;本次仅整理文件,没有新Kit运行、物理验证或训练。
**暂停时间:2026-10-16 17:29 +08。本次是WIP源码提交,不是已验收发布。** 未启动暂停前计划的revision2原生验证/新训练。原生任务均已退出,GPU compute进程为空,最后一项只读复核已停止;只有用户明确要求恢复后才能继续,不能消耗原48小时剩余额度。
## 已验证基线
## 已完成
| 版本 | 实测范围 | 不可外推 |
|---|---|---|
| 0.4.2当前源码 | 解析S1 GUI/headless各6周期、27000tick;70张量及完整轨迹文件与0.4.1相同 | 未重验nominal20/S2/S3/u256、新绘制节拍的原生故障注入 |
| 0.4.1历史 | 解析S1 GUI/headless各6周期;真实提前关窗2040tick按预期中止并清理 | 中止不是完整成功,旧GUI资格不自动继承到0.4.2 |
| 0.4.0历史 | 解析20周期、三条6周期切换、u256 S1、停止/非法拒绝、独立目录公开接口复现 | 不是当前源码完整矩阵、全命令域或全GUI资格 |
- 新增support/retract/swing/plant、保持/查询/合法切换/安全停止的统一接口,以及反馈驱动中央组合器。
- 新增48D技能条件残差PPO;actor/critic不读取外力采样参数、承重目标或辅助力标签。保留原解析参考、±0.05rad残差和原辅助,随机真实外力固定为0/≤1.5/≤4/≤8N四档。
- 暂停提交前新CPU测试**139 passed**、AST/bash语法与diff检查通过;363个旧保护文件哈希不变。较早全套1726passed/3skipped属于最新revision2修改之前,不当作当前原生或全套资格。
- **revision1实测**:`bootstrap04`无扰动解析1闭环4505tick通过;`gui-bootstrap02`小扰动解析1闭环4505tick、真实Kit窗口/原速录像、完成后render-only保留及正常退出通过。reset11/pose14在闭环期间不变。不是三组×五闭环或训练策略资格;原ready截图存在一帧UI滞后,不把它当精确帧对齐证据。
- RTX5080训练预检完成2次更新/16384环境转移;正式`training01`完成**218次更新、1785856条环境转移**后有依据中止。最后完整更新记录69760共享物理调用;缺少最终worker报告,**终态实际总调用未知**,不把最后进度当最终计数。
- 独立源码复核发现:短暂ready可永久关闭保持完成超时,奖励可能偏向提前离地/不恢复承重。暂停前已实现revision2修正、恢复原相位/辅助保护、强化离线审计和截图同步;**这些最新修改尚未完成原生复验及最终独立复核**。
[0.4.2完整结果](contact_cycle_sim_performance_v042_result.md):真实GUI截图33.98FPS,全段绘制提交35.30次/秒;GUI54模拟秒耗时764.863墙钟秒,RTF **0.07060×**;headless294.679秒,RTF **0.18325×**。GPU整卡均值39.74%/133.43W,含桌面客户端,不是进程独占指标或GPU100%。
## 原始尝试(均保留)
该阶段11Kit、67500实际物理调用、73500预留、0训练;结束57个owned身份均不存活。原始CPU验收1557passed/6skipped属于当时交付物,不是本次精简后测试集的数量。独立包及最终封装凭据见[证据索引](evidence_index.md)。
证据根:`logs/four_skills_v050/`;9次登记、640000预留调用不是实际物理调用数。
## 必须保留的限制与失败
| 目录 | 原结果 |
|---|---|
| `bootstrap01` / `bootstrap02` | 私有worker父身份/相对入口路径校验失败;原件保留 |
| `bootstrap03` | 配置继承奖励字段缺失,环境构造前失败 |
| `bootstrap04` | revision1解析1闭环通过 |
| `training-preflight01` | 中央训练驱动同一反馈样本重复切换,首个优化前失败;修复另建目录 |
| `training-preflight02` | 2更新预检通过,不代表四技能训练完成 |
| `gui-bootstrap01` | 物理闭环完成,但ffmpeg SIGINT退出255使任务失败;不回溯改判 |
| `gui-bootstrap02` | revision1真实GUI/录像/正常退出通过 |
| `training01` | u218后父级因确认的源码缺陷中止;owned清理、wait通过,native退出-15,最终worker报告缺失 |
- `accepted_skill=false`。对象为浮动根Go2 FL单腿、3kg合成负载、仿真真值、有界XY/转动辅助,竖直guide为0;有限单seed功能通过不等于独立鲁棒验收、无辅助平衡、整机或实机能力。
- 原46D残差PPO冻结u256完成256更新、名义9秒开发验证128/128通过,解析本身也能完成任务。v3有限矩阵双方6/6,没有功能通过率学习增益,不预设追加训练必要。
- 严格P1双方均在首周期根XY超过30mm而失败;P2虽执行20行,但10组初态全部失配,不能支持学习策略优越性。P2修复只有CPU资格。
- RootXY-v2完成81更新;u64功能128/128通过但126/128仍超过30mm,无合格候选,不可发布或恢复。扫描竞态最终修复尚未完成端到端训练验证。
- ff-01 u256三周期物理完成但GPU监督失败;0.4.2首个独立headless退出观察器也异常,确切瞬时原因未知。后续通过不改写旧失败。
- 旧Reach1.0.1/站立1.0.0不变。站立120秒漂移30.78mm超30mm仅获候选专属豁免,不能移用于本任务。
## 权重与录像位置
下一步见[下一阶段](next_stage.md)。历史逐次过程已归档,不再在当前状态追加旧准备/预算记录。
- 诊断权重:`logs/four_skills_v050/training01/latest.pt`(u218)。**不是候选,不可发布,不可直接恢复训练**;原revision1配置/源码在该目录`source_snapshot/`。当前revision2运行器会拒绝其旧config身份。
- 真实原速录像:`logs/four_skills_v050/gui-bootstrap02/live-kit-original-speed.mp4`;同目录PNG、`gui-evidence.json`、原轨迹/监督结果保留。
- 可恢复索引及关键文件SHA256:[暂停清单](../archives/four_skills_v050_pause.json)。约602MiB原始日志、权重、录像及来源快照是本机产物,**未加入Git**;源码clone不包含这些实物。
## 尚未完成
revision2原生闭环/GUI复验、新训练、冻结合格候选、8独立seed×4档×2控制器配对评估、三组不同方向/时长各连续五闭环、真实非法切换/空中安全停止探针、最终打包和新版本验收均未完成。独立评估种子尚未执行;没有学习提升或四技能已达标结论。
`demo_gui.sh`现为0.5.0开发入口,默认需要**尚不存在的正式冻结权重**,不是可交付演示。旧入口副本为`demo_gui_v042.sh`;已封包0.4.2仍在`performance_v042/deliveries/go2_fl_contact_cycle_sim-0.4.2/`,原包/证据未改动。[0.4.2历史实测](contact_cycle_sim_performance_v042_result.md)仍只限定解析S1,历史`accepted_skill=false`/严格RootXY失败不变。
+9 -1
View File
@@ -2,7 +2,15 @@
相对路径以仓库根为准。以下均为历史已发生运行,不是可复用grant;本次整理不产生新的物理资格。
## 当前0.4.2
## 四技能0.5.0暂停检查点(未验收)
[当前状态](current_status.md) / [逐尝试与关键产物SHA256](../archives/four_skills_v050_pause.json)。本机根`logs/four_skills_v050/`保存9次登记的原始失败/通过结果、source_snapshot、原始轨迹、录像及诊断检查点;未加入Git。
- `training01/latest.pt`为revision1的u218诊断权重,不是候选;缺失最终worker报告,最后69760物理调用快照不是最终总数。
- `gui-bootstrap02/`为revision1小扰动解析1闭环真实Kit/录像/正常退出证据,不代表当前revision2或三组五闭环通过。
- `PAUSED.json`为用户暂停标记;独立种子矩阵、revision2原生复验与最终打包均未执行。不能自动恢复旧grant。
## 上一已封包0.4.2
[实测报告](contact_cycle_sim_performance_v042_result.md)。限定当前源码解析S1 GUI/headless,各27000tick;`accepted_skill=false`。
+5 -1
View File
@@ -1,5 +1,9 @@
# 执行与授权边界
## 最新:2026-10-16用户要求暂停
四技能0.5.0的48小时自主执行已暂停,只允许收尾、记录进度和Git提交。所有原生任务与只读子任务已停止;本机`logs/four_skills_v050/PAUSED.json`阻止继续使用阶段登记。等待用户新的明确恢复指令,不自行删除标记、延长旧截止、复用已消费grant或以剩余预算自动重跑。当前revision2尚未原生复验,u218仅诊断权重;详见[交接](next_stage.md)。下列为通常/历史边界,不覆盖最新暂停要求。
用户已明确后续预算无需逐次请批;在**当前用户目标范围内**自主执行,不以等待预算批准阻塞。但不限总预算不等于取消保护、自动扩域或无界后台任务。
## 每次真实运行仍需
@@ -11,7 +15,7 @@
`go2_fl_skill.py authorize`是调用方显式创建新的≤12小时有限会话,只登记而不启动Kit。各run仍新建approval并串行受监督执行;公开接口上限详见[API](go2_fl_skill_v4_api.md)。不把历史任务剩余预算当新运行授权。
## 本次及已完成阶段
## 旧整理及已完成阶段(历史)
本次仅文件整理/CPU回归,不启动仿真或训练,不改变技术方向。上一阶段0.4.2已完成,当前不自动追加RootXY、训练、扰动/噪声、形态、整机/硬件、sim2real或通用adapter。
+41
View File
@@ -0,0 +1,41 @@
# Go2 FL四技能0.5.0:本轮固定合同
**状态:2026-10-16 17:29按用户要求暂停,未完成验收。** 本文是开发合同,不是完成声明;实际进度与恢复前置见[current_status.md](current_status.md)和[next_stage.md](next_stage.md)。旧0.4.2及证据保留。功能达标优先,不追求精度;不能据CPU测试、revision1试跑或旧周期结果声称当前revision2通过。原48小时预算不构成暂停后的自动继续许可。
## 对外合同
中央仅能调用`support/retract/swing/plant`、查询、保持、切换、安全停止,不下发承重目标、外力标签/参数或辅助力。
- `support`:从初始化接触或完成plant进入,固定命令地面支点,维持真实接触/根高度。
- `retract`:仅从ready support进入;内部先卸载1秒再收腿0.6秒,离地后可保持。
- `swing`:仅从ready retract或ready swing进入;接收有限世界XY位移目标,1.4秒内部平滑轨迹,真实空中移动后可保持。
- `plant`:从ready retract/swing进入;内部0.8秒落地+2.2秒恢复承重,真实接触稳定后ready;此后才允许support。
- 保持不reset、不改物理状态、不重锚,ready也继续执行当前低层控制;中央按真实ready与保持计时推进,不按预编相位时钟强行切换。非法切换拒绝且零控制状态变更。
- 安全停止请求在support/plant稳定支撑后停止;空中请求走plant→support反馈闭环,不以关窗冒充安全停止;立即安全失败优先中止并留部分轨迹。
## 物理与功能门槛(首跑前固定)
`configs/four_skills/v050.json`为机器合同。撑地/落地Fn≥0.5W、真实接触比例≥80%、连续稳定至少0.2秒;收腿/摆动gap≥10mm、Fn≤2N连续至少0.1秒;卸载至少下降20%;摆动各非零命令轴实际有向进度≥50%。落地误差≤50mm、根高度误差≤100mm、tilt≤0.6rad、穿透≤2mm、归一化力矩/速度≤1.00001、关节超界≤0.01rad。保留原瞬时相位保护:抬腿末段gap≥20mm、摆动gap≥10mm、reload进度>80%时Fn≥0.5W;接触获取/过早离地、负法向力及辅助几何/140N上限继续保护。误差完整记录,不以修改门槛获得通过。
沿用同一Go2FL资产/3kg载荷、500Hz PhysX/最高100Hz控制、原±0.05rad残差及原辅助:有界被动XY/转动guide,guideZ=0;原等效其他腿主动竖向支撑按卸载/飞行分数施加,kp1800/kd120/max140N,不增强,不把它当无辅助平衡。原辅助明确计入轨迹和报告。
## 外力与学习
环境独立采样真实世界系payload COM力,零附加力偶;各2秒slot内80%概率施加,时机随机、持续0.5–1.3秒、0.15秒平滑升降,方向各向同性。幅值四档none/≤1.5/≤4/≤8N;采样种子/环境/episode独立,成对控制器重放同一扰动。actor48D仅接收允许仿真传感状态、技能/空间目标/进度、解析参考与过去残差,**没有采样外力向量、标签、未来时机、承重目标或辅助力标签**。可视化/审计单独读取施加外力,不回流策略。
优先原解析IK+新共享四技能条件残差PPO(RTX5080),不加载旧46D权重冒充训练;解析零残差为基线。按none→small→medium→full分档课程,开发seed选候选并在独立seed前冻结。未优于配对解析基线不宣称提升。
## 验收与交付
- 三组不同方向/保持时长,分别连续5闭环,整个序列初始化后无reset/瞬移/状态覆盖。
- 独立8seed×4外力档,解析/训练策略相同初态/扰动,报告所有成功/失败/未运行。无扰动8/8,其余每档≥7/8为本阶段限定目标;扩大样本必须在看独立结果前另登记,不按结果重选候选。
- 真实Kit窗口显示技能、ready/保持、接触、施加外力、辅助和训练/序列状态;真实画面/动作/正常退出及原速Kit录像单独验证,不拿FK/GIF或CPU替代。
- 保存新版本源码/权重/示例/一键demo/独立验收命令/简洁报告;旧版本原件不改写。首个失败留档,定位后新目录修复复验,禁止盲目重复。
## 时间与预算
本轮开始2026-10-16 16:07:37 +08,硬截止2026-10-18 16:07:37 +08;最后6小时不启动新训练。初始训练上限128环境×64 horizon×256更新(2097152环境转移),单训练≤18小时,定期检查点;必要技术迭代须记录差异/原因/新上限。任务初始护栏64次Kit启动、300万共享物理调用、120GiB新增逻辑产物。独立评估前已另存scope-amendment-01将启动上限改为96:固定8seed×4档×2控制器本身需要64启动,另外留开发/训练/GUI空间;单周期预留15000调用,300万/120GiB/48h不变,原scope原字节保留。单运行独立上限、预留清理,GPU串行,CPU复核可并行;达到目标即结束,不耗满预算。原始运行证据集中`logs/four_skills_v050/`,不堆逐次修复文档。
## 开发修正(独立种子尚未使用)
training01因独立源码复核确认的保持活性/奖励漏洞在218完整更新后由父级中止;权重仅留诊断,不进入候选。一次短暂ready不再永久关闭保持完成看门狗;奖励改为复用原分相位目标,不能靠提前离地或reload继续悬空获奖。恢复原过早离地/末抬腿/摆动/reload及辅助几何瞬时保护,不放宽任何冻结功能数值。修正后拟定的新目录训练上限仍128×64×256、RTX5080、≤18小时,尚未启动,等待用户恢复。这是有依据的新开发迭代计划,不恢复旧失败目录或复用旧grant。原累计训练/预扣保留。后续独立评估须使用development_revision=2合同;旧开发版结果不冒充修正版资格。
+18 -19
View File
@@ -1,26 +1,25 @@
# 下一阶段交接
# 暂停后的恢复交接
## 默认方向:集成现有仿真功能接口
**当前等待用户新的恢复指令。不要自动继续,也不要因原48小时尚有余额而启动任何Kit或训练。** 本机`logs/four_skills_v050/PAUSED.json`已阻止复用本阶段运行登记;暂停前只读复核也已停止。
1. 先读[当前状态](current_status.md)与[公开API](go2_fl_skill_v4_api.md),以已封包0.4.2为基线,确认上层启动、状态查询、队列和停止的使用需求。
2. 先做CPU静态/生命周期回归:按[运行说明](contact_cycle_runtime.md)执行`python scripts/test_cpu.py`;CPU通过不证明物理成功。
3. 如需修改当前源码,先固定受影响范围和验收项。0.4.2只重新验证了解析S1 GUI/headless,不能借0.4.0完整矩阵声称新版本全域或u256合格。
4. 确需真实验证时,按[执行边界](execution_authority.md)创建新有限会话、新绑定、新输出;保留逐500Hz安全/证据及监督退出清理,不复用旧grant或失败目录。
## 恢复时先读
## 尚未具备的证据
1. [当前进度/全部尝试/缺失证据](current_status.md)。
2. [四技能合同及开发修正](four_skills_v050.md);机器配置`configs/four_skills/v050.json`为development_revision=2。
3. [暂停索引](../archives/four_skills_v050_pause.json):原始结果、诊断权重、录像及SHA256。原件在本机`logs/`,未随Git分发。
- 当前源码nominal20/S2/S3/u256以及新高频绘制节拍下的原生提前关闭、visualizer故障、安全停止/查看超时资格。
- 1×实时物理:现有GUI0.07060×、headless0.18325×。若目标是吞吐优化,另固定范围并以相同协议/开销比较,不以渲染FPS替代物理速度。
- 多seed、全命令域、无辅助平衡、整机/实机、sim2real或通用v2运行adapter。
## 经用户明确恢复后再执行
以上是证据缺口,不是自动待执行的仿真矩阵或训练任务。本次整理不启动Kit,不耗用旧预算。
1. 重新确认目标、时间/存储/调用护栏;旧scope、grant、失败目录、暂停前预留均不能直接作为新授权。记录新的恢复决定和有限登记,不静默删除暂停标记或延长旧截止。
2. 完成revision2修复的独立复核。重点是保持完成看门狗、分相位奖励/原相位保护、停止请求在下一观察之前路由,以及强化审计与实际显示帧的对齐。最后一次复核被用户暂停,不能称已批准。
3. 用新目录进行revision2解析无扰动闭环及GUI基础验证,再做有上限的训练预检。检查实际四技能控制采样、真实保持完成、失败原因、原辅助、每步保护及退出清理,不只看reward或优化器更新数。
4. 只有修复通过后才新建RTX5080训练。u218是有缺陷revision1的诊断权重,不是候选/续训许可;当前CLI没有恢复旧训练的资格。保留所有旧失败及预扣。
5. 在开发seed上选择并冻结合格权重,然后才执行未使用的独立seed配对矩阵、三组×五连续闭环和真实非法切换/空中安全停止探针。解析/训练采用相同任务、观察初态及真实施加扰动;完整报告失败、未运行和比较范围,不预设优于解析。
6. 最后实测`demo_gui.sh`与真实Kit录像/正常退出,打包新源码/权重/命令及简洁验收报告。必须明确辅助和物理推进速度;窗口约30FPS不等于1×物理实时。
## 非默认方向
## 文件与验收边界
不为当前功能目标继续RootXY精度优化或追加训练。若后续明确选择此方向,须先回归扫描器竞态、监督器与候选提交路径,再重新固定独立实验;不得恢复不可选取u64、改写旧门槛/失败/账本或把P2失配当有效比较。原[配方](contact_cycle_rootxy_v2_plan.md)与[启动合同](contact_cycle_rootxy_v2_launch.md)仅保留为绑定输入和实现参考。
## 后续文件约定
- 当前结论只更新`current_status.md`,后续步骤只更新本文,证据位置只更新`evidence_index.md`。
- 测试留可复用契约、边界和安全回归;任务临时探针/第N次修复报告放运行目录,不再堆入`docs/`和`tests/`。
- 历史过程见[归档](README.md#历史资料),恢复到临时目录查看,不覆盖当前文件。
- `legs/four_skills/`:协议/力采样/48D模型;`tasks/manager_based/four_skills/`:真实环境、动作、安全与GUI。
- `scripts/four_skills.py`:有限会话与监督;`four_skills_runtime.py`:认证worker、训练与执行;`audit_four_skills.py`:CPU只读原轨迹/配对审计。
- 现有CPU回归入口仍为`python scripts/test_cpu.py`,新回归为`tests/test_four_skills*.py`。CPU通过不是原生或技能验收;不要为提交而重跑GPU。
- 0.4.2原包、历史严格RootXY失败、原权重/账本/源码及全部旧尝试保持不变。未来只更新状态、本文和证据索引,不恢复堆积逐次修复文档。
+216
View File
@@ -0,0 +1,216 @@
#!/usr/bin/env python3
"""Independent CPU-only audit of complete four-skill original500Hz traces.
This checks physical tensors, not the actor's reward or ready/success labels.
It never launches Kit, creates authority, alters traces or selects a candidate.
"""
import argparse
import importlib.util
import json
import math
from pathlib import Path
import sys
import torch
ROOT = Path(__file__).resolve().parents[1]
def audit(run):
run = Path(run)
config = json.loads((ROOT / 'configs/four_skills/v050.json').read_text())
approval = json.loads((run / 'approval.json').read_text())
worker = json.loads((run / 'worker-result.json').read_text())
supervisor = json.loads((run / 'supervisor-result.json').read_text())
trace = torch.load(run / 'trace.pt', map_location='cpu', weights_only=True)
initial = torch.load(run / 'initial-state.pt', map_location='cpu', weights_only=True)
reasons = []
def require(test, reason):
if not bool(test):
reasons.append(reason)
count = len(trace['tick'])
require(count > 0, 'empty_trace')
require(torch.equal(trace['tick'][:, 0], torch.arange(1, count + 1)), 'physical_clock_not_contiguous')
require(count == worker.get('actual_ticks'), 'actual_call_trace_count_mismatch')
require(all(bool(torch.isfinite(v).all()) for v in trace.values() if v.is_floating_point()), 'nonfinite_evidence')
require(not trace['failed'].any(), 'runtime_failure_in_trace')
require(trace['limit_ratio'].max() <= 1.00001, 'effort_velocity')
require(trace['joint_excess'].max() <= .01, 'joint_limits')
require(trace['height_error'].max() <= .1, 'root_height')
require(trace['tilt'].max() <= .6, 'tilt')
require(trace['gap'].min() >= -.002, 'penetration')
require(trace['guide'][..., 2].abs().max() == 0, 'vertical_guide')
if 'auxiliary' in trace:
auxiliary = trace['auxiliary']
az = auxiliary[..., 2]
require(az.sum(-1).max() <= 140., 'auxiliary_force')
require(az.min() >= -1e-6 and auxiliary[..., :2].abs().max() <= 1e-6
and auxiliary[..., 5].abs().max() <= 1e-6
and (auxiliary[..., 3:].norm(dim=-1) <= .06*az.clamp_min(0)+1e-6).all(), 'auxiliary_geometry')
else:
require(False, 'missing_auxiliary_evidence')
require(trace['normal'][..., 2].min() >= -.5, 'negative_normal')
require(worker.get('initialization_counters') == worker.get('final_counters'), 'reset_or_pose_write')
require(worker['physics_counts']['initialization'] == 0, 'unexpected_initialization_physics')
require(worker['physics_counts']['completed'] == count, 'unrecorded_physics')
transitions = json.loads((run / 'transitions.json').read_text())
sequence = config['sequences'][approval['sequence']]
loops = approval.get('loops') or (1 if approval['mode'] == 'smoke' else sequence['loops'])
require(worker.get('requested_loops') == loops, 'approved_loop_count_mismatch')
require(approval['config_sha256'] == __import__('hashlib').sha256((ROOT / 'configs/four_skills/v050.json').read_bytes()).hexdigest(), 'approved_config_changed')
expected_edges = [('support', 'retract'), ('retract', 'swing'), ('swing', 'plant'), ('plant', 'support')] * loops
require([(e['from'], e['to']) for e in transitions] == expected_edges, 'missing_or_illegal_transitions')
require(all(e['feedback_ready'] and e['feedback_hold_complete'] for e in transitions), 'switch_without_feedback')
kinds = trace['skill'][:, 0]
starts = [0] + (kinds[1:] != kinds[:-1]).nonzero().flatten().add(1).tolist()
ends = starts[1:] + [count]
require(len(starts) == 4 * loops + 1, 'incomplete_skill_segments')
require([int(kinds[i]) for i in starts] == [0, 1, 2, 3] * loops + [0], 'actual_skill_order_mismatch')
require(torch.equal(trace['time_s'][:, 0], trace['tick'][:, 0].float() * .002), 'time_tick_mismatch')
require(torch.equal(trace['episode_id'][:, 0], initial['episode_id'][0].expand(count)), 'episode_changed_during_composition')
for j, start in enumerate(starts[1:]):
if j < len(transitions):
require(transitions[j]['at_tick'] == int(trace['tick'][start, 0]) - 1, 'transition_tick_mismatch')
for start, end in zip(starts, ends):
expected_age = torch.arange(1, end - start + 1).float() * .002
require(torch.allclose(trace['age_s'][start:end, 0], expected_age, rtol=0., atol=.001), 'segment_age_mismatch')
age = trace['age_s'][:, 0]
expected_phase = torch.where(kinds == 0, 0, torch.where(kinds == 1,
torch.where(age < 1., 1, 2), torch.where(kinds == 2, 3, torch.where(age < .8, 4, 5))))
if 'phase' in trace:
require(torch.equal(trace['phase'][:, 0], expected_phase), 'intrinsic_phase_mismatch')
else:
require(False, 'missing_phase_evidence')
require(not (((expected_phase == 2) & (age > 1.54)) & (trace['gap'][:, 0] < .02)).any(), 'original_late_lift_floor')
require(not ((expected_phase == 3) & (trace['gap'][:, 0] < .01)).any(), 'original_swing_clearance')
require(not (((expected_phase == 5) & (age > 2.56)) &
(trace['normal'][:, 0, 2] < .5*trace['weight'][:, 0])).any(), 'original_reload_deadline')
holds = sequence['holds_s']
windows = []
swing_index = 0
for index, (start, end) in enumerate(zip(starts, ends)):
kind = int(kinds[start])
name = config['skills'][kind]
hold = holds[kind]
dwell = .2 if kind in (0, 3) else .1
window = math.ceil((hold + dwell) / .002) - 1
if end - start < window:
require(False, f'{index}:{name}:incomplete_hold_window')
continue
part = slice(end - window, end)
normal = trace['normal'][part, 0, 2]
gap = trace['gap'][part, 0]
weight = trace['weight'][part, 0]
row = {'segment': index, 'skill': name, 'ticks': end-start,
'checked_hold_dwell_s': window*.002, 'normal_min_N': float(normal.min()),
'normal_max_N': float(normal.max()), 'gap_min_m': float(gap.min())}
if kind in (0, 3):
contact_fraction = float((normal >= .5 * weight).float().mean())
require(contact_fraction >= .8, f'{index}:{name}:support_contact_fraction')
require(bool(((normal >= .5 * weight) & (gap <= .002)).all()), f'{index}:{name}:continuous_support_dwell_and_hold')
require(float(normal.mean()) >= .5 * float(weight.mean()), f'{index}:{name}:support_mean_load')
row['contact_fraction'] = contact_fraction
if kind == 3:
error = (trace['foot'][part] - trace['target'][part]).norm(dim=-1)
require(error.max() <= .05, f'{index}:landing_error')
row['landing_error_max_m'] = float(error.max())
else:
require(bool((gap >= .01).all() and (normal <= 2.).all()), f'{index}:{name}:air_hold')
if kind == 1:
unload = (trace['age_s'][start:end, 0] >= .9) & (trace['age_s'][start:end, 0] <= 1.)
first_normal = initial['normal'][0, 2] if start == 0 else trace['normal'][start-1, 0, 2]
remain = trace['normal'][start:end, 0, 2][unload]
require(len(remain) and remain.mean() <= .8 * first_normal, f'{index}:unload')
else:
command = torch.tensor(sequence['direction_m']) * (1 if swing_index % 2 == 0 else -1)
entry = trace['foot'][start-1, 0, :2]
displacement = trace['foot'][end-1, 0, :2] - entry
directed = (trace['foot'][part, 0, :2] - entry) * command.sign()
require((directed >= .5 * command.abs()).all(), f'{index}:continuous_signed_swing_hold')
require(((displacement * command.sign()) >= .5 * command.abs()).all(), f'{index}:signed_swing')
row['actual_xy_m'] = displacement.tolist()
row['command_xy_m'] = command.tolist()
swing_index += 1
windows.append(row)
# Reconstruct the exact private disturbance schedule, then compare to the
# original applied wrench tensor at each pre-step clock (not reward labels).
schedule_doc = json.loads((run / 'force-schedule.json').read_text())
spec = importlib.util.spec_from_file_location('four_force_audit', ROOT / 'source/SkillFactory/SkillFactory/legs/four_skills/forces.py')
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
row = schedule_doc['rows'][0]
require(schedule_doc['seed'] == approval['seed'], 'schedule_seed_not_approved')
require(row['tier'] == approval['tier'], 'schedule_tier_not_approved')
require(row['env_id'] == 0 and row['episode_id'] == int(initial['episode_id'][0]), 'schedule_episode_not_initial_state')
runtime = json.loads((run / 'runtime-identity.json').read_text())
payload_index = runtime['payload_body_index']
require(len(runtime['body_names']) == trace['external'].shape[-2], 'body_index_layout_mismatch')
require(runtime['body_names'][payload_index] == 'virtual_payload', 'wrong_external_force_body')
schedule = module.ForceSchedule(schedule_doc['seed'], [row['env_id']], row['tier'], 'cpu',
duration_s=schedule_doc['duration_s'], episode_ids=[row['episode_id']])
require(schedule.manifest() == schedule_doc, 'force_manifest_parameters_changed')
times = torch.cat((initial['time_s'][:1], trace['time_s'][:-1, 0]))
# CPU batched audit is in chunks, preserving every original sample.
maximum_force_difference = 0.
for start in range(0, count, 2048):
end = min(count, start + 2048)
predicted = torch.stack([schedule.at(t.reshape(1))[0] for t in times[start:end]])
actual = trace['external'][start:end, 0]
expected = torch.zeros_like(actual)
expected[:, payload_index, :3] = predicted
maximum_force_difference = max(maximum_force_difference, float((expected - actual).abs().max()))
require(maximum_force_difference <= 2e-6, 'sampled_force_not_actually_applied')
tier_cap = config['force']['tiers_N'][approval['tier']]
require(trace['external'][..., :3].norm(dim=-1).max() <= tier_cap + .000001, 'force_out_of_approved_tier_range')
require(supervisor['success'] and supervisor['owned_cleanup'] and supervisor['waited_exit'], 'supervision_or_cleanup')
require(worker.get('functional_success') and worker.get('completed_loops') == loops, 'incomplete_original_result')
return {'passed': not reasons, 'failure_reasons': reasons, 'run': str(run.resolve()),
'physics_ticks': count, 'requested_loops': loops, 'windows': windows,
'max_force_reconstruction_difference_N': maximum_force_difference,
'scope': 'CPU physical-tensor audit; runtime continuity separately requires original hooks/supervisor'}
def compare_pair(analytic, trained):
a, b = Path(analytic), Path(trained)
aa = json.loads((a / 'approval.json').read_text())
ab = json.loads((b / 'approval.json').read_text())
conditions = {k: aa[k] == ab[k] for k in ('seed', 'sequence', 'loops', 'tier', 'config_sha256', 'mode')}
identity_file = b / 'checkpoint-identity.json'
trained_identity = json.loads(identity_file.read_text()) if identity_file.exists() else {}
controllers = (aa['controller'] == 'analytic' and aa['checkpoint'] is None
and ab['controller'] == 'trained' and bool(ab['checkpoint_sha256'])
and trained_identity.get('sha256') == ab['checkpoint_sha256']
and type(trained_identity.get('update')) is int and trained_identity['update'] > 0
and trained_identity.get('identity', {}).get('config_sha256') == ab['config_sha256'])
integrity = {name: json.loads((p / 'supervisor-result.json').read_text())['success'] for name, p in [('analytic', a), ('trained', b)]}
sa = json.loads((a / 'force-schedule.json').read_text())
sb = json.loads((b / 'force-schedule.json').read_text())
ia = torch.load(a / 'initial-state.pt', weights_only=True, map_location='cpu')
ib = torch.load(b / 'initial-state.pt', weights_only=True, map_location='cpu')
fields = ['root', 'joint_pos', 'joint_vel', 'normal', 'foot', 'target', 'reference', 'q_ik', 'actor_observation']
equality = {k: torch.equal(ia[k], ib[k]) for k in fields}
ta = torch.load(a / 'trace.pt', weights_only=True, map_location='cpu')
tb = torch.load(b / 'trace.pt', weights_only=True, map_location='cpu')
shared = min(len(ta['tick']), len(tb['tick']))
force_prefix_equal = torch.equal(ta['external'][:shared], tb['external'][:shared])
return {'paired': sa == sb and all(equality.values()) and all(conditions.values()) and controllers and all(integrity.values()) and force_prefix_equal,
'approved_conditions_equal': conditions, 'analytic_vs_frozen_trained': controllers,
'runtime_integrity': integrity, 'common_prefix_ticks': shared, 'applied_force_common_prefix_equal': force_prefix_equal,
'analytic_physical_audit_passed': audit(a)['passed'], 'trained_physical_audit_passed': audit(b)['passed'],
'disturbance_schedule_equal': sa == sb,
'observed_initial_state_equal': equality,
'limitation': 'observed physical/controller state, not a proof of complete hidden PhysX state identity'}
if __name__ == '__main__':
p = argparse.ArgumentParser(description=__doc__)
p.add_argument('run', type=Path)
p.add_argument('--pair', type=Path)
p.add_argument('--output', type=Path)
args = p.parse_args()
result = compare_pair(args.run, args.pair) if args.pair else audit(args.run)
text = json.dumps(result, indent=2, allow_nan=False) + '\n'
if args.output:
args.output.write_text(text)
print(text)
raise SystemExit(0 if result.get('passed', result.get('paired', False)) else 1)
+44
View File
@@ -0,0 +1,44 @@
"""Public-interface examples for an already supervised four-skill runtime.
`advance` is the certified owner's one-control-step callback. It owns actor
inference,500Hz safety/evidence, deadlines and cleanup. The central client below
never receives desired support loads or sampled force parameters, and cannot
reset/teleport the robot. Do not construct an unsupervised Kit here.
"""
from SkillFactory.legs.four_skills.api import CentralComposer
def compose(service, advance, *, direction_m=(.024, .010), holds_s=(.5, .3, .4, .5), loops=5):
program = CentralComposer(service, {'direction_m': direction_m, 'holds_s': holds_s, 'loops': loops})
for _ in range(12000):
if program.update():
return {'completed_loops': program.completed_loops, 'safe_stop': program.safely_stopped,
'status': service.query()}
advance()
service.request_stop()
raise TimeoutError('Central command budget exhausted; owner must finish safe cleanup')
def hold_then_switch(service, advance):
"""Illustrate calls individually; all transitions use actual ready feedback."""
def wait():
for _ in range(2000):
status = service.query()
if status['failed']:
raise RuntimeError(str(status['failure_reasons']))
if status['ready'] and status['hold_complete']:
return status
advance()
raise TimeoutError('Skill feedback not ready; no forced transition or state overwrite')
service.hold(.8)
wait()
service.call('retract', hold_seconds=.5)
wait()
service.switch('swing', direction_m=[.020, .024], hold_seconds=1.)
wait()
service.call('plant', hold_seconds=.7)
wait()
service.call('support', hold_seconds=.8)
wait()
service.request_stop()
return service.query()
+410
View File
@@ -0,0 +1,410 @@
#!/usr/bin/env python3
"""New v0.5.0 stage CLI: finite fresh runs, strict GPU/process ownership.
No simulation or authority is created on import. Normal callers use the public
skill service; the private worker path requires a live parent socket handoff.
"""
import argparse
import ctypes
from datetime import datetime, timezone
import fcntl
import hashlib
import json
import os
from pathlib import Path
import signal
import socket
import struct
import subprocess
import sys
import time
import traceback
from types import SimpleNamespace
ROOT = Path(__file__).resolve().parents[1]
STAGE = ROOT / 'logs/four_skills_v050'
CONFIG = ROOT / 'configs/four_skills/v050.json'
START = '2026-10-16T16:07:37+08:00'
DEADLINE = '2026-10-18T16:07:37+08:00'
def clock():
return time.clock_gettime(time.CLOCK_BOOTTIME)
def sha(path):
return hashlib.sha256(Path(path).read_bytes()).hexdigest()
def write(path, value):
path = Path(path)
temp = path.with_suffix(path.suffix + '.pending')
data = json.dumps(value, sort_keys=True, indent=2, allow_nan=False).encode() + b'\n'
with temp.open('wb') as stream:
stream.write(data)
stream.flush()
os.fsync(stream.fileno())
os.replace(temp, path)
def sources():
files = [p for base, pattern in [('source', '*.py'), ('scripts', '*.py'), ('configs', '*.json')]
for p in (ROOT / base).rglob(pattern) if '__pycache__' not in p.parts]
for directory in ('legs/go2_fl', 'support/go2_fl_3kg_v0', 'go2_fl'):
files += [p for p in (ROOT / 'assets/generated' / directory).rglob('*')
if p.is_file() and '__pycache__' not in p.parts]
files += [ROOT / 'docs/four_skills_v050.md', ROOT / 'demo_gui.sh', ROOT / 'demo_gui_v042.sh']
return {p.relative_to(ROOT).as_posix(): sha(p) for p in sorted(files)}
def scope():
STAGE.mkdir(exist_ok=True)
if (STAGE / 'PAUSED.json').exists():
raise PermissionError('Stage paused by user; a new explicit resume instruction is required')
p = STAGE / 'scope.json'
if not p.exists():
remaining = datetime.fromisoformat(DEADLINE).timestamp() - time.time()
value = {'format': 'skillfactory.four-skills-stage.v050', 'started_wall': START,
'deadline_wall': DEADLINE, 'boot_id': Path('/proc/sys/kernel/random/boot_id').read_text().strip(),
'deadline_boottime': clock() + remaining, 'train_cutoff_boottime': clock() + remaining - 21600,
'max_kit_launches': 64, 'max_reserved_physics_calls': 3000000,
'max_owned_bytes': 120 << 30, 'user_authorized_hours': 48,
'preserve_original_versions': True, 'scope': 'single aided Go2FL only'}
with p.open('x') as stream:
stream.write(json.dumps(value, indent=2) + '\n')
value = json.loads(p.read_text())
if value['boot_id'] != Path('/proc/sys/kernel/random/boot_id').read_text().strip():
raise RuntimeError('Stage boot changed; stop, do not revive old grants')
if clock() >= value['deadline_boottime']:
raise TimeoutError('48h stage deadline reached; no new work')
amendment = STAGE / 'scope-amendment-01.json'
if amendment.exists():
update = json.loads(amendment.read_text())
if (update.get('format') != 'skillfactory.four-skills-budget-amendment.v1'
or update.get('original_scope_sha256') != sha(p)
or update.get('max_kit_launches') != 96):
raise ValueError('Invalid recorded stage budget amendment')
value['max_kit_launches'] = 96
value['amendment_sha256'] = sha(amendment)
return value
def new_session(path, mode):
"""Explicit future caller invocation, never revival of the48h stage grant."""
global STAGE
if mode not in ('gui', 'evaluate', 'probe'):
raise PermissionError('Standalone sessions cannot authorize training')
path = Path(path)
if (not path.is_absolute() or path != path.resolve() or path.exists() or not path.parent.is_dir()
or path.is_relative_to(ROOT / 'releases') or path.is_relative_to(ROOT / 'performance_v042')
or path.is_relative_to(Path('/home/cen/sf-deliveries'))
or (path.is_relative_to(ROOT) and not path.is_relative_to(ROOT / 'logs/four_skills_v050_sessions'))
or (path.is_relative_to(Path('/home/cen/sf-runs')) and path.parent != Path('/home/cen/sf-runs'))):
raise ValueError('Fresh canonical session outside protected evidence/source trees required')
path.mkdir()
STAGE = path
value = {'format': 'skillfactory.four-skills-explicit-session.v050',
'issued_wall': datetime.now().astimezone().isoformat(),
'boot_id': Path('/proc/sys/kernel/random/boot_id').read_text().strip(),
'deadline_boottime': clock() + 3600, 'train_cutoff_boottime': clock(),
'max_kit_launches': 1, 'max_reserved_physics_calls': 50000,
'max_owned_bytes': 8 << 30, 'training_authorized': False,
'scope': 'explicit caller invocation; not a48h-task extension or old-grant reuse'}
write(path / 'scope.json', value)
return value
def tree_bytes(path):
total = 0
for base, dirs, files in os.walk(path, followlinks=False):
dirs[:] = [d for d in dirs if not Path(base, d).is_symlink()]
for name in files:
p = Path(base, name)
try:
if p.is_symlink():
raise RuntimeError('Symlink inside owned outputs')
total += p.stat().st_size
except FileNotFoundError:
continue # atomic publication disappearance, never permission denial
return total
class Guard:
def __init__(self, payload, *, worker=False):
self.p = payload
self.interrupted = False
self.next_slow = 0
self.worker = worker
def __call__(self, *, cleanup=False):
if not cleanup and (self.interrupted or (Path(self.p['output']) / 'cancel.request').exists()
or (Path(self.p['output']).parent / 'PAUSED.json').exists()):
raise InterruptedError('Cooperative cancellation')
end = self.p['deadline_boottime'] if cleanup else self.p['deadline_boottime'] - 120
if clock() >= end:
raise TimeoutError('Run/stage deadline; reserve cleanup')
if cleanup or clock() < self.next_slow:
return
self.next_slow = clock() + 1
if tree_bytes(self.p['output']) > self.p['max_owned_bytes']:
raise RuntimeError('Owned artifact cap exceeded')
if os.statvfs(self.p['output']).f_bavail * os.statvfs(self.p['output']).f_frsize < 8 << 30:
raise RuntimeError('Minimum free disk headroom8GiB')
for relative, digest in self.p['sources'].items():
if sha(ROOT / relative) != digest:
raise RuntimeError('Bound runtime source changed: ' + relative)
def reserve(args, sc):
p = STAGE / 'ledger.json'
ledger = json.loads(p.read_text()) if p.exists() else {'launches': 0, 'reserved_physics_calls': 0, 'runs': []}
calls = 160000 if args.mode == 'train' else 50000
if args.mode in ('smoke', 'probe') or args.loops == 1:
calls = 15000
if ledger['launches'] + 1 > sc['max_kit_launches'] or ledger['reserved_physics_calls'] + calls > sc['max_reserved_physics_calls']:
raise RuntimeError('Stage cap exhausted; do not silently extend')
if args.mode == 'train' and clock() >= sc['train_cutoff_boottime']:
raise TimeoutError('Final6h: no new training')
duration = 64800 if args.mode == 'train' else 2400
output = (STAGE / args.name).absolute()
if (not args.name or Path(args.name).name != args.name or args.name.startswith('.')
or output.exists() or output.parent != STAGE or output.resolve() != output):
raise ValueError('Fresh unused simple run name required')
if tree_bytes(STAGE) > sc['max_owned_bytes']:
raise RuntimeError('Stage storage cap')
checkpoint = None if args.checkpoint is None else str(args.checkpoint.resolve(strict=True))
if args.controller == 'trained' and checkpoint is None:
raise ValueError('Trained controller requires explicit immutable checkpoint')
if args.controller == 'analytic' and checkpoint is not None:
raise ValueError('Analytic controller cannot load weights')
if args.mode == 'train' and args.controller != 'analytic':
raise ValueError('Fresh training is not checkpoint resume')
output.mkdir()
payload = {'format': 'skillfactory.four-skills-run.v050', 'mode': args.mode, 'output': str(output),
'seed': args.seed, 'sequence': args.sequence, 'loops': args.loops,
'tier': args.tier, 'controller': args.controller, 'checkpoint': checkpoint,
'stop_skill': args.stop_skill or ('retract' if args.mode == 'probe' else None),
'checkpoint_sha256': None if checkpoint is None else sha(checkpoint),
'sources': sources(), 'config_sha256': sha(CONFIG), 'boot_id': sc['boot_id'],
'deadline_boottime': min(clock() + duration, sc['deadline_boottime']),
'max_physics_calls': calls, 'max_owned_bytes': (32 if args.mode == 'train' else 8) << 30,
'updates': args.updates, 'parent_pid': os.getpid(), 'issued_boottime': clock(),
'stage_amendment_sha256': sc.get('amendment_sha256')}
ledger['launches'] += 1
ledger['reserved_physics_calls'] += calls
ledger['runs'].append({'name': args.name, 'mode': args.mode, 'reserved_calls': calls,
'output': str(output), 'refunded': False})
write(p, ledger)
write(output / 'approval.json', payload)
snapshot = output / 'source_snapshot'
for relative in payload['sources']:
dest = snapshot / relative
dest.parent.mkdir(parents=True, exist_ok=True)
dest.write_bytes((ROOT / relative).read_bytes())
return payload
def supervise(args):
import evaluate_cycle_sim_residual as owner
import rootxy_launch_v2 as ownership
from skill_launch_v4 import capture_gpu
sc = new_session(args.new_session, args.mode) if args.new_session else scope()
with (STAGE / 'serial.lock').open('a') as lock:
fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
payload = reserve(args, sc)
out = Path(payload['output'])
guard = Guard(payload)
# No child command before this exact dedicated-supervisor snapshot.
owned = owner.OwnedProcesses()
gpu_identity = capture_gpu()
write(out / 'gpu-identity.json', gpu_identity)
gpu = ownership.GPUOwnership(gpu_identity)
environment = {k: v for k, v in os.environ.items() if k not in
('VIRTUAL_ENV', 'CONDA_PREFIX', 'PYTHONEXE', 'PYTHONHOME', 'args')}
environment.update(PYTHONDONTWRITEBYTECODE='1', PYTEST_DISABLE_PLUGIN_AUTOLOAD='1',
CUDA_VISIBLE_DEVICES=gpu_identity['uuid'],
SKILLFACTORY_GO2_ASSET_DIR=str(ROOT / 'assets/generated/go2_fl'),
SKILLFACTORY_LEG_BUNDLE=str(ROOT / 'assets/generated/legs/go2_fl'),
PYTHONPATH=os.pathsep.join([str(ROOT / 'source/SkillFactory'), str(ROOT / 'scripts'),
environment.get('PYTHONPATH', '')]))
(out / 'native').mkdir()
redirects = owner.native_redirects(out / 'native' / 'runtime', preparation=True)
for p in redirects.values():
Path(p).mkdir(parents=True, exist_ok=True)
environment.update(redirects)
policy = {'artifact_root': str(out), 'mount_identity': owner.mount_identity(out),
'native_paths': owner.native_paths(out), 'shared_native_paths': owner.shared_native_paths(),
'task_owned_cache_paths': sorted(redirects.values()), 'free_space_paths': owner.free_space_paths(out),
'free_space_mount_identities': {p: owner.mount_identity(Path(p)) for p in owner.free_space_paths(out)},
'check_interval_seconds': 1., 'min_free_bytes': 8 << 30,
'max_native_growth_bytes': 16 << 30}
write(out / 'native-policy.json', policy)
monitor = owner.NativeMonitor(policy, SimpleNamespace(boottime=clock, STORAGE_SCOPE='four-skills-v050-monitored-not-quota'))
child = capture = None
errors = []
clean = waited = False
parent, channel = socket.socketpair()
old_handlers = {}
try:
if ctypes.CDLL(None).prctl(36, 1, 0, 0, 0) != 0:
raise RuntimeError('Subreaper setup failed')
for sig in (signal.SIGTERM, signal.SIGINT):
old_handlers[sig] = signal.signal(sig, lambda *_: setattr(guard, 'interrupted', True))
command = owner.launch_command([str(Path(__file__).resolve()), '--_worker-fd', str(channel.fileno())], environment)
write(out / 'invocation.json', {'command': command, 'cwd': str(ROOT), 'launch_identity': owner.launch_identity()})
child = subprocess.Popen(command, cwd=ROOT, env=environment, stdout=subprocess.PIPE,
stderr=subprocess.STDOUT, start_new_session=True, pass_fds=(channel.fileno(),))
owned.attach(child)
channel.close()
capture = owner.StdoutCapture(child.stdout, out / 'stdout.log', SimpleNamespace(STDOUT_BYTES=8 << 20))
packet = json.dumps(payload).encode()
parent.sendall(struct.pack('!I', len(packet)) + packet)
parent.close()
next_heartbeat = 0
while child.poll() is None or not capture.eof:
guard()
capture.check()
gpu.check(owned)
monitor.check()
if clock() >= next_heartbeat:
write(out / 'supervisor-heartbeat.json', {'boottime': clock(), 'owned': sorted(owned.known),
'gpu': gpu.clients().__str__(), 'deadline': payload['deadline_boottime']})
next_heartbeat = clock() + 5
time.sleep(.05)
child.wait()
waited = True
if child.returncode != 0:
errors.append('worker_nonzero:' + str(child.returncode))
except BaseException:
errors.append(traceback.format_exc())
finally:
parent.close()
channel.close()
try:
if child is not None:
if child.poll() is None and errors:
# File cancellation survives SDK signal-handler changes;
# allow Python evidence/checkpoint finalizers first.
write(out / 'cancel.request', {'reason': errors[-1][-4096:]})
until = min(clock() + 15, payload['deadline_boottime'] - 10)
while child.poll() is None and clock() < until:
if capture is not None:
capture.pump()
time.sleep(.05)
clean = owner.cleanup_group(child, payload['deadline_boottime'], SimpleNamespace(boottime=clock),
owned, lambda: capture.pump() if capture else None)
child.wait(timeout=max(.1, payload['deadline_boottime'] - clock()))
waited = True
if capture is not None:
capture.close()
if capture.discarded or capture.error or not capture.eof:
errors.append('incomplete_stdout')
final_gpu = gpu.check(owned, final=True)
guard(cleanup=True)
monitor.check(force=True)
except BaseException:
errors.append('cleanup:' + traceback.format_exc())
final_gpu = None
worker = json.loads((out / 'worker-result.json').read_text()) if (out / 'worker-result.json').exists() else None
if worker is not None and not worker.get('success'):
errors.append('worker_reported_failure:' + str(worker.get('error', worker.get('close_error', 'incomplete')))[-4096:])
success = bool(not errors and clean and waited and worker and worker.get('success')
and worker.get('postclose_identity_verified') and child.returncode == 0)
result = {'success': success, 'functional_success': bool(success and worker.get('functional_success')),
'training_complete': bool(success and worker.get('training_complete')),
'owned_cleanup': clean, 'waited_exit': waited,
'returncode': None if child is None else child.returncode, 'errors': errors,
'gpu_final': final_gpu, 'owned_identities': sorted(owned.known),
'native_monitor': monitor.report(), 'accepted_skill': False}
write(out / 'supervisor-result.json', result)
for sig, handler in old_handlers.items():
signal.signal(sig, handler)
print(json.dumps({'output': str(out), 'success': success,
'functional_success': result['functional_success'],
'training_complete': result['training_complete'], 'errors': errors}), flush=True)
return 0 if success else 1
def supervisor_command_matches(command, cwd):
if len(command) < 3:
return False
try:
script = Path(command[1].decode())
if not script.is_absolute():
script = Path(cwd) / script
return (script.resolve() == Path(__file__).resolve()
and command[2].decode() in ('smoke', 'evaluate', 'train', 'gui', 'probe'))
except (UnicodeError, OSError, ValueError):
return False
def worker(fd):
channel = socket.socket(fileno=fd)
peer_pid, peer_uid, _ = struct.unpack('3i', channel.getsockopt(socket.SOL_SOCKET, socket.SO_PEERCRED, 12))
import evaluate_cycle_sim_residual as owner
command = Path(f'/proc/{peer_pid}/cmdline').read_bytes().split(b'\0')
if (peer_uid != os.getuid() or not owner.ancestor(peer_pid, os.getpid())
or Path(f'/proc/{peer_pid}/exe').resolve() != Path('/usr/bin/python3.12')
or not supervisor_command_matches(command, Path(f'/proc/{peer_pid}/cwd').resolve())):
raise PermissionError('Authenticated exact live sole ancestor supervisor required')
channel.settimeout(30)
def receive(n):
chunks = b''
while len(chunks) < n:
part = channel.recv(n - len(chunks))
if not part:
raise EOFError('Incomplete parent handoff')
chunks += part
return chunks
size = struct.unpack('!I', receive(4))[0]
if size > 4 << 20:
raise ValueError('Oversized handoff')
payload = json.loads(receive(size))
channel.close()
if payload['parent_pid'] != peer_pid or payload['format'] != 'skillfactory.four-skills-run.v050':
raise PermissionError('Wrong run identity')
if payload != json.loads((Path(payload['output']) / 'approval.json').read_text()):
raise PermissionError('Exact new approval required')
claim = Path(payload['output']) / 'worker-claim'
with claim.open('x'):
pass
guard = Guard(payload, worker=True)
for sig in (signal.SIGTERM, signal.SIGINT):
signal.signal(sig, lambda *_: setattr(guard, 'interrupted', True))
guard()
from four_skills_runtime import run
return run(payload, guard, write)
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--_worker-fd', type=int, help=argparse.SUPPRESS)
parser.add_argument('mode', nargs='?', choices=('smoke', 'evaluate', 'train', 'gui', 'probe', 'scope'))
parser.add_argument('--name')
parser.add_argument('--new-session', type=Path,
help='Explicit fresh<=1h nontraining invocation; no old stage-grant reuse')
parser.add_argument('--controller', choices=('analytic', 'trained'), default='analytic')
parser.add_argument('--checkpoint', type=Path)
parser.add_argument('--tier', choices=('none', 'small', 'medium', 'full'), default='none')
parser.add_argument('--seed', type=int, default=115011)
parser.add_argument('--sequence', type=int, choices=(0, 1, 2), default=0)
parser.add_argument('--loops', type=int, choices=(1, 2, 3, 4, 5))
parser.add_argument('--updates', type=int)
parser.add_argument('--stop-skill', choices=('retract', 'swing'))
args = parser.parse_args()
if args._worker_fd is not None:
return worker(args._worker_fd)
if args.mode == 'scope':
print(json.dumps(scope(), indent=2))
return 0
if args.mode is None or args.name is None:
parser.error('Fresh --name and run mode required')
if args.mode == 'train':
args.seed = 105011
if args.updates is not None and not 1 <= args.updates <= 256:
parser.error('Updates in1..256')
return supervise(args)
if __name__ == '__main__':
raise SystemExit(main())
+474
View File
@@ -0,0 +1,474 @@
"""Authenticated Isaac worker for the additive four-skill stage.
Imported by four_skills.py only after private socket handoff. No old run grant,
checkpoint identity, accepted flag or legacy task is reinterpreted.
"""
import importlib
import json
import math
import os
from pathlib import Path
import sys
import time
import traceback
ROOT = Path(__file__).resolve().parents[1]
TASK = 'SkillFactory.tasks.manager_based.four_skills.'
LEG = 'SkillFactory.legs.four_skills.'
def verify_project_imports():
expected = ROOT / 'source/SkillFactory/SkillFactory'
paths = {}
for name, module in tuple(sys.modules.items()):
if (name == 'SkillFactory' or name.startswith('SkillFactory.')) and getattr(module, '__file__', None):
path = Path(module.__file__).resolve()
if not path.is_relative_to(expected):
raise RuntimeError('Imported project source outside current copy: ' + name)
paths[name] = str(path)
return paths
def normalize_scene(cfg, binding):
from SkillFactory.tasks.manager_based.four_skills.cfg import FourSkillsEnvCfg
if type(cfg) is not FourSkillsEnvCfg or cfg.scene.num_envs not in (1, 128):
raise ValueError('Exact new stage config, scalar or128envs required')
if cfg.scene.clone_in_fabric is not False:
raise ValueError('Non-fabric scene required')
# Same pinned SDK normalization mechanics; independent new config identity,
# not a fake RootXY instance or expanded old evaluator allowlist.
for name in binding.NORMALIZATION_SOURCES:
rel, expected = binding.ISAAC_PINS[name]
p = binding._module_file(name)
if p != binding.ISAAC_ROOT / rel or binding.sha256(p.read_bytes()) != expected:
raise ValueError('Installed scene normalizer drift: ' + name)
regex = '/World/envs/env_.*'
for name in ('ground', 'light', 'robot', 'foot_contact', 'mount_wrench'):
entity = getattr(cfg.scene, name)
entity.prim_path = entity.prim_path.format(ENV_REGEX_NS=regex)
if name in ('ground', 'light', 'robot'):
entity.spawn.spawn_path = entity.prim_path.replace(regex, '/World/envs/env_0')
elif name == 'foot_contact':
for field in ('filter_prim_paths_expr', 'sensor_shape_prim_expr', 'filter_shape_prim_expr'):
if hasattr(entity, field) and getattr(entity, field):
setattr(entity, field, [p.format(ENV_REGEX_NS=regex) for p in getattr(entity, field)])
for obj, name, value in binding._reference_updates(cfg):
setattr(obj, name, value)
binding.canonical_config(cfg)
class Trace:
def __init__(self, output, guard, *, full=True):
self.output, self.guard, self.full = Path(output), guard, full
self.frames = []
self.initial = None
self.maximum = {'limit_ratio': 0., 'joint_excess_rad': 0., 'height_error_m': 0.,
'tilt_rad': 0., 'external_N': 0., 'guideZ_N': 0.}
self.ticks = 0
self.failure_frames = []
def snapshot(self, s):
import torch
phase, progress, target, _, fraction = s.reference()
ratio = torch.maximum((s.robot.data.applied_torque.torch[:, s.joints] / s.effort).abs().amax(-1),
(s.robot.data.joint_vel.torch[:, s.joints] / s.speed).abs().amax(-1))
values = {'tick': s.substeps, 'time_s': s.time, 'skill': s.skill, 'age_s': s.age,
'weight': s.weight, 'episode_id': torch.tensor(s.episode_ids, device=s.env.device),
'phase': phase,
'ready': s.ready, 'held_s': s.held, 'hold_required_s': s.hold_required,
'hold_deadline_s': s.hold_deadline, 'hold_completed': s.hold_completed,
'dwell_s': s.dwell, 'bad_hold_s': s.bad_hold,
'unload_passed': s.unload_passed, 'unload_min_N': s.unload_min,
'unload_initial_N': s.unload_initial, 'failed': s.failed,
'root': torch.cat(s.root(), -1), 'joint_pos': s.q(),
'joint_vel': s.robot.data.joint_vel.torch[:, s.joints],
'applied_torque': s.robot.data.applied_torque.torch[:, s.joints],
'foot': s.foot_center(), 'normal': s.contact(),
'gap': s.foot_center()[:, 2] - s.bundle['foot']['radius'],
'target': target, 'progress': progress, 'fixture_fraction': fraction,
'external': s.external, 'guide': s.guide, 'auxiliary': s.auxiliary,
'reference': s.controller.action, 'q_ik': s.controller.q_ik,
'residual': s.residual_request, 'effective_residual_rad': s.effective_residual_rad,
'actor_observation': s.policy(), 'limit_ratio': ratio,
'joint_excess': torch.maximum(s.lower - s.q(), s.q() - s.upper).clamp(min=0).amax(-1),
'height_error': (s.root()[0][:, 2] - s.base_origin[:, 2]).abs(),
'tilt': s.tilt()}
return {k: v.detach().cpu().clone() for k, v in values.items()}
def __call__(self, s):
import torch
# Training keeps aggregates and complete first offending snapshots,
# evaluation retains every500Hz original tensor with no thinning.
if self.full or bool(s.failed.any()):
frame = self.snapshot(s)
if self.full:
self.frames.append(frame)
elif len(self.failure_frames) < 256:
self.failure_frames.append(frame)
self.ticks += 1
if self.full:
values = self.frames[-1]
for dest, src in [('limit_ratio', 'limit_ratio'), ('joint_excess_rad', 'joint_excess'),
('height_error_m', 'height_error'), ('tilt_rad', 'tilt')]:
self.maximum[dest] = max(self.maximum[dest], float(values[src].max()))
self.maximum['external_N'] = max(self.maximum['external_N'], float(values['external'][..., :3].norm(dim=-1).max()))
self.maximum['guideZ_N'] = max(self.maximum['guideZ_N'], float(values['guide'][..., 2].abs().max()))
def save(self):
import torch
self.guard(cleanup=True)
if self.initial is not None:
torch.save(self.initial, self.output / 'initial-state.pt')
if self.frames:
torch.save({k: torch.stack([f[k] for f in self.frames]) for k in self.frames[0]}, self.output / 'trace.pt')
if self.failure_frames:
torch.save(self.failure_frames, self.output / 'training-failure-frames.pt')
class TrainingComposer:
def __init__(self, env):
import torch
self.env = env
self.loops = torch.zeros(env.num_envs, dtype=torch.long, device=env.device)
self.episodes = list(env.s.episode_ids)
self.skill_counts = [0] * 4
self.transition_count = 0
def update(self):
import torch
s, service = self.env.s, self.env.service
for i, episode in enumerate(s.episode_ids):
if episode != self.episodes[i]:
self.loops[i] = 0
self.episodes[i] = episode
allowed = s.ready & (s.held + 1e-6 >= s.hold_required) & ~s.failed & ~s.stopped
kinds = s.skill.clone() # one decision per row, even after service mutation
# Only public skill calls mutate reference goals. No force arguments.
for skill in range(4):
ids = (allowed & (kinds == skill)).nonzero().flatten()
self.skill_counts[skill] += int((kinds == skill).sum())
if not len(ids):
continue
next_skill = ('retract', 'swing', 'plant', 'support')[skill]
self.transition_count += len(ids)
if skill == 1:
for variant, vector in enumerate(((.024, .010), (.020, .024), (.010, .024))):
for sign in (1, -1):
selected = ids[(ids % 3 == variant) & (torch.where(self.loops[ids] % 2 == 0, 1, -1) == sign)]
if len(selected):
service.call('swing', hold_seconds=(.3, .6, 1.)[variant],
direction_m=[sign*x for x in vector], env_ids=selected)
else:
hold = (.4, 0., .5, .8)[skill]
service.call(next_skill, hold_seconds=hold, env_ids=ids)
if skill == 3:
self.loops[ids] += 1
def reject_probe(env):
import torch
def snapshot():
s = env.s
values = [s.q(), *s.root(), s.controller.q_ik, s.controller.action, s.skill, s.substeps,
s.age, s.held, s.hold_required, s.ground_target, s.controller.refreshes,
torch.get_rng_state(), *torch.cuda.get_rng_state_all()]
return [v.detach().cpu().clone() for v in values]
before = snapshot()
counts = (env.runtime_hooks.completed_steps, env.runtime_hooks.reset_calls, env.runtime_hooks.pose_write_calls)
rejected = False
reason = None
try:
env.service.call('plant') # support->plant is illegal, even if ready.
except ValueError as error:
rejected, reason = True, str(error)
after = snapshot()
unchanged = all(torch.equal(a, b) for a, b in zip(before, after)) and counts == (
env.runtime_hooks.completed_steps, env.runtime_hooks.reset_calls, env.runtime_hooks.pose_write_calls)
if not rejected or not unchanged:
raise RuntimeError('Illegal public switch was not rejected atomically')
return {'rejected': rejected, 'reason': reason, 'carried_state_and_rng_equal': unchanged,
'physical_calls_added': 0}
def execute_single(env, payload, output, guard, trace, model=None):
import torch
from SkillFactory.legs.four_skills.api import CentralComposer
config = env.cfg.four_parameters
sequence = dict(config['sequences'][payload['sequence']])
if payload['mode'] == 'smoke':
sequence['loops'] = 1
if payload.get('loops') is not None:
sequence['loops'] = payload['loops']
composer = CentralComposer(env.service, sequence)
observation = env.reset(seed=payload['seed'])[0]['policy']
trace.initial = trace.snapshot(env.s)
if payload['mode'] == 'probe':
(output / 'illegal-switch-probe.json').write_text(json.dumps(reject_probe(env), indent=2))
initial_counts = {'resets': env.runtime_hooks.reset_calls, 'pose_writes': env.runtime_hooks.pose_write_calls}
(output / 'force-schedule.json').write_text(json.dumps(env.s.forces.manifest(), indent=2))
(output / 'initial-counters.json').write_text(json.dumps(initial_counts))
outcome = {'functional_success': False, 'requested_loops': sequence['loops'], 'completed_loops': 0}
try:
while env.s.time[0] < 240:
guard()
status = env.service.query()
if (payload.get('stop_skill') == status['skill'] and status['ready'] and not status['stop_requested']):
env.service.request_stop()
finished = composer.update()
env.central_progress = {'completed_loops': composer.completed_loops, 'requested_loops': composer.loops,
'stop_requested': env.service.query()['stop_requested']}
if finished:
outcome['functional_success'] = not composer.safely_stopped
outcome['safe_stop_success'] = composer.safely_stopped
break
# The public switch may have changed skill/reference at this same
# physical clock; actor must consume the post-command observation.
observation = env.s.policy()
with torch.no_grad():
action = torch.zeros(1, 3, device=env.device) if model is None else model.act(observation, deterministic=True)[0]
observation, _, terminated, _, _ = env.step(action)
observation = observation['policy']
if bool(terminated.any()):
break
outcome.update(completed_loops=composer.completed_loops, status=env.service.query(),
transitions=composer.transitions,
actual_ticks=env.total_ticks, maximum=trace.maximum,
initialization_counters=initial_counts,
final_counters={'resets': env.runtime_hooks.reset_calls,
'pose_writes': env.runtime_hooks.pose_write_calls})
outcome['no_rollout_reset_or_pose_write'] = initial_counts == outcome['final_counters']
outcome['functional_success'] &= outcome['no_rollout_reset_or_pose_write']
if outcome.get('safe_stop_success'):
outcome['safe_stop_success'] &= (outcome['no_rollout_reset_or_pose_write']
and outcome['status']['skill'] == 'support'
and outcome['status']['ready'] and outcome['status']['stopped'])
return outcome
finally:
trace.save()
(output / 'transitions.json').write_text(json.dumps(composer.transitions, indent=2))
(output / 'public-call-receipts.json').write_text(json.dumps(env.s.transitions, indent=2))
def train(env, payload, output, guard, trace):
import torch
from SkillFactory.legs.four_skills.model import FourSkillActorCritic, save_checkpoint
from SkillFactory.legs.standing_ppo import ppo_step
torch.set_num_threads(4)
cfg = env.cfg.four_parameters['training']
torch.manual_seed(cfg['seed'])
torch.cuda.manual_seed_all(cfg['seed'])
model = FourSkillActorCritic().to(env.device)
initial_actor = {k: v.detach().clone() for k, v in model.actor.named_parameters()}
opt = torch.optim.Adam(model.parameters(), lr=cfg['algorithm']['learning_rate'], eps=cfg['algorithm']['adam_eps'])
identity = {'task': env.cfg.four_parameters['task_id'], 'config_sha256': payload['config_sha256'],
'source_sha256': payload['sources'], 'train_seed': cfg['seed'],
'observation': 'four-skills-48-fixed-si-v1', 'device': torch.cuda.get_device_name(0)}
save_checkpoint(output / 'untrained.pt', model, opt, identity, 0)
x = env.reset(seed=cfg['seed'])[0]['policy']
trace.initial = trace.snapshot(env.s)
driver = TrainingComposer(env)
driver.update()
failures = {k: 0 for k in env.s.failure_masks}
history = []
total_transitions = 0
skill_control_samples = [0] * 4
update_limit = payload.get('updates') or cfg['updates']
for update in range(1, update_limit + 1):
guard()
tier = next(t for start, end, t in cfg['tier_updates'] if start <= update <= end)
if tier != env.s.force_tier:
env.s.force_tier = tier
# New training episodes at explicit curriculum boundary, not a hold
# reset, and not a paired independent evaluation.
x = env.reset()[0]['policy']
data = {key: torch.empty(cfg['horizon'], env.num_envs, *shape, device=env.device, dtype=dtype)
for key, shape, dtype in [('features', (48,), torch.float32), ('latent', (3,), torch.float32),
('log_prob', (), torch.float32), ('value', (), torch.float32), ('reward', (), torch.float32),
('next_value', (), torch.float32), ('done', (), torch.bool)]}
update_failures = 0
with torch.no_grad():
for step in range(cfg['horizon']):
guard()
x = env.s.policy() # already post-command from previous boundary.
for k, n in enumerate(torch.bincount(env.s.skill, minlength=4).cpu().tolist()):
skill_control_samples[k] += n
action, latent, logp, value = model.act(x)
obs, reward, terminated, truncated, info = env.step(action)
# Advance exactly once, then bootstrap the very state that the
# next actor will see. Terminal snapshots remain pre-reset.
driver.update()
nx = env.s.policy()
nv = model.value(nx)
timeout = truncated & ~terminated
if bool(timeout.any()):
nv[timeout] = model.value(info['terminal_observation']['policy'][timeout])
nv[terminated] = 0
for key, v in [('features', x), ('latent', latent), ('log_prob', logp), ('value', value),
('reward', reward), ('next_value', nv), ('done', terminated | truncated)]:
data[key][step].copy_(v)
for reason, count in info['failure_counts'].items():
failures[reason] = failures.get(reason, 0) + count
update_failures += int(terminated.sum())
x = nx
guard()
# Physical rollout only, GPU optimizer only. No saved robot trace replay.
metrics = ppo_step(model, opt, data, cfg['algorithm'])
total_transitions += cfg['horizon'] * env.num_envs
row = {'update': update, 'tier': tier, 'environment_transitions': total_transitions,
'actual_physics_calls': env.total_ticks, 'episode_failures': update_failures,
'mean_reward': float(data['reward'].mean()), 'learner': metrics,
'skill_control_samples': skill_control_samples[:],
'feedback_skill_samples': driver.skill_counts[:], 'transitions': driver.transition_count,
'state_diagnostics': {'current_skill_counts': torch.bincount(env.s.skill, minlength=4).cpu().tolist(),
'ready_count': int(env.s.ready.sum()), 'max_age_s': float(env.s.age.max()),
'max_held_s': float(env.s.held.max()), 'min_gap_m': float((env.s.foot_center()[:, 2]-env.s.bundle['foot']['radius']).min())}}
history.append(row)
with (output / 'progress.jsonl').open('a') as stream:
stream.write(json.dumps(row, allow_nan=False) + '\n')
save_checkpoint(output / 'latest.pt', model, opt, identity, update, row)
if update % cfg['checkpoint_interval'] == 0 or update == update_limit:
save_checkpoint(output / f'checkpoint_u{update:04d}.pt', model, opt, identity, update, row)
torch.save(trace.snapshot(env.s), output / f'state_u{update:04d}.pt')
print(json.dumps({'training': row}), flush=True)
changed = {k: float((v.detach() - initial_actor[k]).abs().max()) for k, v in model.actor.named_parameters()}
trace.save()
return {'training_complete': True, 'updates': len(history), 'optimizer_device': env.device,
'environment_transitions': total_transitions, 'actual_ticks': env.total_ticks,
'failures': failures, 'actor_parameter_max_changes': changed,
'skill_control_samples': skill_control_samples, 'feedback_skill_samples': driver.skill_counts,
'transition_count': driver.transition_count,
'candidate_selection_pending_development_validation': True, 'functional_success': False}
def run(payload, guard, write):
import torch
from isaaclab.app import AppLauncher
output = Path(payload['output'])
gui = payload['mode'] == 'gui'
launcher = app = env = hooks = paint = trace = None
result = {'success': False, 'functional_success': False, 'mode': payload['mode']}
code = 1
try:
options = {'visualizer': 'kit'} if gui else {}
launcher = AppLauncher(headless=not gui, device='cuda:0', fast_shutdown=True,
kit_args=f'--/log/file={output / "native" / "kit.log"}', **options)
app = launcher.app
import evaluate_cycle_sim_residual as owner
from SkillFactory.legs.contact_cycle_sim import evaluation_binding as binding
from SkillFactory.tasks.manager_based.contact_cycle_sim.evaluation_env import RuntimeHooks
from SkillFactory.tasks.manager_based.four_skills.cfg import FourSkillsEnvCfg
from SkillFactory.tasks.manager_based.four_skills.env import FourSkillsEnv
for name in dict.fromkeys((*binding.REQUIRED_RUNTIME, *binding.ISAAC_PINS)):
importlib.import_module(name)
verify_project_imports()
owner.preimport_replicator()
owner.preimport_constructor_modules(binding)
owner.physx_constructor_export(binding, resolve=True)
if torch.cuda.get_device_name(0) != 'NVIDIA GeForce RTX 5080':
raise RuntimeError('Only approved RTX5080, no CPU training fallback')
cfg = FourSkillsEnvCfg()
cfg.scene.num_envs = 128 if payload['mode'] == 'train' else 1
cfg.training_mode = payload['mode'] == 'train'
cfg.force_tier = payload['tier']
cfg.seed = payload['seed']
cfg.sim.device = 'cuda:0'
if gui:
from isaaclab_visualizers.kit import KitVisualizerCfg
cfg.sim.visualizer_cfgs = [KitVisualizerCfg()]
owner.preforward_video_recorder(cfg, importlib.import_module(owner.TASK + 'evaluation_env'))
owner.preimport_config_references(cfg, binding)
normalize_scene(cfg, binding)
before = binding.canonical_config(cfg)
(output / 'effective-config-before.json').write_bytes(before)
trace = Trace(output, guard, full=not cfg.training_mode)
def before_step(h):
guard()
if h.attempted_steps > payload['max_physics_calls']:
raise RuntimeError('Physical call cap exhausted before call')
with RuntimeHooks.isaac(before_step=before_step) as hooks:
env = FourSkillsEnv(cfg, runtime_hooks=hooks, guard=guard, record=trace)
write(output / 'runtime-identity.json', {
'task': cfg.four_parameters['task_id'], 'torch': str(torch.__version__),
'device': torch.cuda.get_device_name(0), 'num_envs': env.num_envs,
'physics_dt_s': env.physics_dt, 'decimation': cfg.decimation,
'payload_body_index': env.s.payload, 'body_names': list(env.s.robot.body_names),
'joint_order': list(env.s.bundle['joint_order']), 'fixed_base': bool(env.s.robot.is_fixed_base),
'effective_weight_N': env.s.weight.cpu().tolist(),
'auxiliary_parameters': cfg.cycle_parameters['support'],
'guide_stiffness': cfg.support_parameters['guide_stiffness'],
'guide_damping': cfg.support_parameters['guide_damping'],
'guide_wrench_limit': cfg.support_parameters['guide_wrench_limit']})
actual = binding.canonical_config(cfg)
(output / 'effective-config-actual.json').write_bytes(actual)
if before != actual:
raise RuntimeError('Constructor changed effective bound config')
if gui:
from SkillFactory.tasks.manager_based.four_skills.gui import Presentation
paint = Presentation(app, env, output)
paint.controller_label = payload['controller']
env.paint = paint
model = None
if payload.get('checkpoint'):
from SkillFactory.legs.four_skills.model import load_policy
model, ckpt = load_policy(payload['checkpoint'], 'cuda:0', payload['checkpoint_sha256'])
if (ckpt['identity'].get('config_sha256') != payload['config_sha256']
or ckpt['identity'].get('task') != cfg.four_parameters['task_id']):
raise RuntimeError('Frozen new-stage checkpoint/config/task identity mismatch')
write(output / 'checkpoint-identity.json', {'sha256': payload['checkpoint_sha256'],
'update': ckpt['update'], 'identity': ckpt['identity']})
if cfg.training_mode:
result.update(train(env, payload, output, guard, trace))
else:
result.update(execute_single(env, payload, output, guard, trace, model))
guard()
write(output / 'runtime-project-imports.json', verify_project_imports())
if binding.canonical_config(env.cfg) != actual or env.cfg is not cfg:
raise RuntimeError('Actual config changed during rollout')
if gui:
paint.finish(result['functional_success'], safely_stopped=result.get('safe_stop_success', False))
result['gui'] = paint.report()
result['physics_counts'] = {'attempted': hooks.attempted_steps, 'completed': hooks.completed_steps,
'rollout': hooks.rollout_steps, 'initialization': hooks.initialization_steps,
'resets': hooks.reset_calls, 'pose_writes': hooks.pose_write_calls,
'violations': hooks.violations}
if hooks.violations:
raise RuntimeError('Runtime reset/pose/ownership violation')
torch.save(trace.snapshot(env.s), output / 'terminal-state.pt')
env.close()
env = None
result['success'] = True # integrity only; task function is separate.
result['postclose_identity_verified'] = True
code = 0
except BaseException:
result.update(success=False, error=traceback.format_exc())
traceback.print_exc()
finally:
if hooks is not None:
result['physics_counts'] = {'attempted': hooks.attempted_steps, 'completed': hooks.completed_steps,
'rollout': hooks.rollout_steps, 'initialization': hooks.initialization_steps,
'resets': hooks.reset_calls, 'pose_writes': hooks.pose_write_calls,
'violations': hooks.violations}
if trace is not None:
try:
trace.save()
except BaseException:
result.update(success=False, trace_save_error=traceback.format_exc())
code = 1
if env is not None:
try:
if trace is not None:
torch.save(trace.snapshot(env.s), output / 'terminal-state.pt')
env.close()
except BaseException:
result.update(success=False, close_error=traceback.format_exc())
code = 1
if paint is not None:
try:
paint.release()
except BaseException:
result.update(success=False, gui_release_error=traceback.format_exc())
code = 1
write(output / 'worker-result.json', result)
if app is not None:
app.close(exit_code=code)
return code
@@ -0,0 +1 @@
"""Additive four-skill simulation contract; legacy cycle identities are unchanged."""
@@ -0,0 +1,109 @@
"""Public in-process skill service and feedback-only central composition.
No requested force, support load, external-force metadata or privileged callbacks
cross this seam. The same service is used by training, evaluation and the demo.
"""
import math
SKILLS = ('support', 'retract', 'swing', 'plant')
LEGAL = {'support': ('retract',), 'retract': ('swing', 'plant'),
'swing': ('swing', 'plant'), 'plant': ('support',)}
def seconds(value):
if type(value) not in (int, float) or not math.isfinite(value) or not 0 <= value <= 10:
raise ValueError('hold_seconds must be finite in [0,10]')
return float(value)
def direction(value):
if (not isinstance(value, (list, tuple)) or len(value) != 2
or any(type(x) not in (int, float) or not math.isfinite(x) for x in value)
or not .008 <= math.hypot(*value) <= .04):
raise ValueError('swing direction_m must be finite XY, norm .008..04m')
return tuple(float(x) for x in value)
class SkillService:
def __init__(self, state):
self._state = state
def call(self, skill, *, hold_seconds=0., direction_m=None, env_ids=None):
if skill not in SKILLS:
raise ValueError('Unknown skill')
duration = seconds(hold_seconds)
vector = direction(direction_m) if skill == 'swing' else None
if skill != 'swing' and direction_m is not None:
raise ValueError('Only swing accepts a spatial direction')
# State validates all selected rows before mutating any row.
return self._state.request(skill, duration, vector, env_ids)
switch = call
def hold(self, duration, *, env_ids=None):
return self._state.hold(seconds(duration), env_ids)
def query(self, *, env_ids=None):
return self._state.query(env_ids)
def request_stop(self, *, env_ids=None):
return self._state.request_stop(env_ids)
class CentralComposer:
"""Feedback-driven scalar demo/evaluation program; no physics/state writes.
A/B are fixed *commanded* ground endpoints. Direction reverses every other
loop rather than accumulating root/foot drift or reanchoring measured landings.
"""
def __init__(self, service, sequence):
self.service = service
self.vector = direction(sequence['direction_m'])
holds = sequence['holds_s']
if not isinstance(holds, (list, tuple)) or len(holds) != 4:
raise ValueError('Four skill holds required')
self.holds = tuple(seconds(x) for x in holds)
self.loops = sequence['loops']
if type(self.loops) is not int or not 1 <= self.loops <= 5:
raise ValueError('One to five loops required')
self.completed_loops = 0
self.started = self.finished = self.safely_stopped = False
self.transitions = []
def update(self):
status = self.service.query()
if not self.started:
self.service.hold(self.holds[0])
self.started = True
status = self.service.query()
if status['failed']:
raise RuntimeError('Central feedback failure: ' + ','.join(status['failure_reasons']))
if status['stop_requested'] and self.completed_loops < self.loops:
self.safely_stopped = bool(status['stopped'] and status['skill'] == 'support' and status['ready'])
self.finished = self.safely_stopped
return self.finished
if self.finished or not status['ready'] or not status['hold_complete']:
return self.finished
skill = status['skill']
if skill == 'support':
if self.completed_loops == self.loops:
self.service.request_stop()
self.finished = bool(self.service.query()['stopped'])
return self.finished
next_skill, hold, vector = 'retract', self.holds[1], None
elif skill == 'retract':
sign = 1 if self.completed_loops % 2 == 0 else -1
next_skill, hold = 'swing', self.holds[2]
vector = [sign * x for x in self.vector]
elif skill == 'swing':
next_skill, hold, vector = 'plant', self.holds[3], None
elif skill == 'plant':
self.completed_loops += 1
next_skill, hold, vector = 'support', self.holds[0], None
else:
raise RuntimeError('Invalid public skill feedback')
self.service.call(next_skill, hold_seconds=hold, direction_m=vector)
self.transitions.append({'from': skill, 'to': next_skill,
'at_tick': status['tick'], 'completed_loops': self.completed_loops,
'feedback_ready': True, 'feedback_hold_complete': True})
return False
@@ -0,0 +1,179 @@
"""Pure, precomputed true-force schedules; never policy observations.
Forces are world-frame Newtons applied at the payload COM with zero requested
couple. This module does not apply forces or depend on simulation/Kit imports.
"""
import hashlib
import json
import math
import random
from collections.abc import Sequence
from numbers import Real
from types import MappingProxyType
import torch
_TIER_MAX_N = MappingProxyType({"none": 0.0, "small": 1.5, "medium": 4.0, "full": 8.0})
_SLOT_S = 2.0
_RAMP_S = 0.15
_ACTIVE_PROBABILITY = 0.8
def _integer(value, name):
if type(value) is not int:
raise TypeError(f"{name} must be an exact int (not bool)")
return value
def _integers(values, name, *, unique=False):
if not isinstance(values, Sequence) or isinstance(values, (str, bytes)):
raise TypeError(f"{name} must be a sequence of exact ints")
result = [_integer(value, name) for value in values]
if unique and len(set(result)) != len(result):
raise ValueError(f"{name} must be unique")
return result
def _tier(value):
if not isinstance(value, str) or value not in _TIER_MAX_N:
raise ValueError(f"unknown force tier: {value!r}")
return value
class ForceSchedule:
"""Episode-keyed schedules independent of row ordering and global RNG state.
``env_ids`` are immutable identities. ``reset(ids, ...)`` instead selects row
indices; only those rows change. A tier change affects only selected rows.
Evaluation pairs must use the same seed, environment and episode identities.
The manifest is audit data, not an actor observation.
"""
def __init__(self, seed: int, env_ids: Sequence[int], tier: str, device,
duration_s: float = 300, episode_ids: Sequence[int] | None = None):
self._seed = _integer(seed, "seed")
self._env_ids = _integers(env_ids, "env_ids", unique=True)
tier = _tier(tier)
if (isinstance(duration_s, bool) or not isinstance(duration_s, Real)
or not math.isfinite(duration_s) or duration_s <= 0):
raise ValueError("duration_s must be finite and positive")
self._duration_s = float(duration_s)
episodes = ([0] * len(self._env_ids) if episode_ids is None
else _integers(episode_ids, "episode_ids"))
if len(episodes) != len(self._env_ids):
raise ValueError("episode_ids must match env_ids length")
self._device = torch.device(device)
self._slot_count = max(1, math.ceil(self._duration_s / _SLOT_S))
self._rows = []
batch = len(self._env_ids)
# Float64 timing avoids rounding away short ramps late in an episode.
self._onsets = torch.empty((batch, self._slot_count), dtype=torch.float64,
device=self._device)
self._ends = torch.empty_like(self._onsets)
self._peaks = torch.empty((batch, self._slot_count, 3), dtype=torch.float64,
device=self._device)
for row, episode in enumerate(episodes):
record = self._sample(self._env_ids[row], episode, tier)
self._store(row, record)
self._rows.append(record)
def _sample(self, env_id, episode_id, tier):
key = json.dumps([self._seed, env_id, episode_id], separators=(",", ":"))
digest = hashlib.sha256(key.encode("ascii")).digest()
rng = random.Random(int.from_bytes(digest, "big"))
maximum = _TIER_MAX_N[tier]
events = []
for slot in range(self._slot_count):
active = rng.random() < _ACTIVE_PROBABILITY
onset = slot * _SLOT_S + rng.uniform(0.2, 0.5)
duration = rng.uniform(0.5, 1.3)
amplitude = rng.uniform(0.25 * maximum, maximum)
# Uniform azimuth and uniform z give an isotropic 3-D unit vector.
z = rng.uniform(-1.0, 1.0)
azimuth = rng.uniform(0.0, 2.0 * math.pi)
radial = math.sqrt(max(0.0, 1.0 - z * z))
direction = [radial * math.cos(azimuth), radial * math.sin(azimuth), z]
events.append({
"slot_index": slot, "slot_start_s": slot * _SLOT_S,
"active": active, "onset_s": onset, "duration_s": duration,
"end_s": onset + duration, "amplitude_N": amplitude,
"direction_world": direction,
"peak_force_world_N": [amplitude * v if active else 0.0 for v in direction],
"truncated_by_horizon": onset + duration > self._duration_s,
"onset_beyond_horizon": onset > self._duration_s,
})
return {"env_id": env_id, "episode_id": episode_id, "tier": tier,
"maximum_amplitude_N": maximum, "events": events}
def _store(self, row, record):
events = record["events"]
self._onsets[row] = torch.tensor([e["onset_s"] for e in events],
dtype=torch.float64, device=self._device)
self._ends[row] = torch.tensor([e["end_s"] for e in events],
dtype=torch.float64, device=self._device)
self._peaks[row] = torch.tensor([e["peak_force_world_N"] for e in events],
dtype=torch.float64, device=self._device)
def at(self, time: torch.Tensor) -> torch.Tensor:
"""Return float32 [B, 3] world force; accept only times in [0, horizon]."""
if not isinstance(time, torch.Tensor):
raise TypeError("time must be a torch.Tensor")
if time.ndim != 1 or time.shape[0] != len(self._env_ids):
raise ValueError("time must have shape [number of environments]")
if time.dtype == torch.bool or time.is_complex():
raise TypeError("time must contain real, non-boolean numbers")
time = time.to(device=self._device, dtype=torch.float64)
if not bool(torch.isfinite(time).all()) or bool((time < 0).any()):
raise ValueError("time must be finite and nonnegative")
if bool((time > self._duration_s).any()):
raise ValueError("time exceeds registered duration_s")
slots = (time / _SLOT_S).floor().long().clamp(max=self._slot_count - 1)
rows = torch.arange(len(self._env_ids), device=self._device)
onset = self._onsets[rows, slots]
end = self._ends[rows, slots]
# A raised cosine on each edge has max slope A*pi/(2*0.15),
# or 83.776 N/s at 8 N, below the 100 N/s contract.
edge = torch.minimum(time - onset, end - time).clamp(0.0, _RAMP_S)
envelope = 0.5 * (1.0 - torch.cos(math.pi * edge / _RAMP_S))
return (self._peaks[rows, slots] * envelope[:, None]).to(torch.float32)
def reset(self, ids: Sequence[int], episode_ids: Sequence[int],
tier: str | None = None):
"""Resample selected row indices using explicit episode identities."""
ids = _integers(ids, "ids", unique=True)
episodes = _integers(episode_ids, "episode_ids")
if len(ids) != len(episodes):
raise ValueError("episode_ids must match ids length")
if any(row < 0 or row >= len(self._env_ids) for row in ids):
raise ValueError("ids contains an out-of-range row index")
if tier is not None:
tier = _tier(tier)
records = [self._sample(self._env_ids[row], episode,
self._rows[row]["tier"] if tier is None else tier)
for row, episode in zip(ids, episodes)]
for row, record in zip(ids, records):
self._store(row, record)
self._rows[row] = record
def manifest(self) -> dict:
"""Return detached, JSON-serializable parameters and every sampled slot."""
return json.loads(json.dumps({
"schema": "four_skills_force_schedule_v0.5.0",
"seed": self._seed, "duration_s": self._duration_s,
"rng": "python.Random; SHA256(ASCII compact JSON [seed,env_id,episode_id]) big-endian seed",
"frame": "world", "application_point": "payload_com",
"requested_couple_Nm": [0.0, 0.0, 0.0],
"tier_maxima_N": dict(_TIER_MAX_N),
"slot_duration_s": _SLOT_S, "active_probability": _ACTIVE_PROBABILITY,
"onset_offset_uniform_s": [0.2, 0.5],
"duration_uniform_s": [0.5, 1.3],
"amplitude_uniform_fraction_of_max": [0.25, 1.0],
"direction_distribution": "isotropic 3D: uniform z in [-1,1], azimuth in [0,2*pi]",
"envelope": "raised cosine rise and fall; constant plateau",
"rise_s": _RAMP_S, "fall_s": _RAMP_S,
"maximum_force_derivative_N_per_s": 8.0 * math.pi / (2.0 * _RAMP_S),
"horizon_rule": "sample slots starting before horizon without clipping; at(horizon) allowed",
"rows": self._rows,
}, allow_nan=False))
@@ -0,0 +1,265 @@
"""Pure-Torch 48D four-skills residual policy; no simulator or robot-data imports."""
import hashlib
import io
import json
import math
import os
from pathlib import Path
import tempfile
import torch
from torch import nn
from torch.distributions import Normal
FEATURE_VERSION = "four-skills-48-fixed-si-v1"
FEATURE_DIM = 48
CHECKPOINT_FORMAT = "skillfactory.four-skills-ppo.v1"
def _model_config(hidden, initial_std):
if type(hidden) is not int or hidden < 8:
raise ValueError("hidden must be an integer >= 8")
if type(initial_std) not in (int, float) or not math.isfinite(initial_std) or not 0.02 <= initial_std <= 0.5:
raise ValueError("initial_std must be finite and in [0.02, 0.5]")
return {"hidden": hidden, "initial_std": float(initial_std)}
def features(x):
"""Validate q3,qdot3,wrench6,gravity3,omega3,root-error3,root-vel3,
foot-relative3,foot-vel3,contact3,gap1,skill4,target-relative3,progress1,
analytic-reference3,previous-residual3, in that order. No privileged labels.
"""
if (
not isinstance(x, torch.Tensor)
or x.layout != torch.strided
or x.device.type == "meta"
or x.ndim != 2
or x.shape[0] < 1
or x.shape[1] != FEATURE_DIM
or x.dtype != torch.float32
or not torch.isfinite(x).all()
):
raise ValueError("features must be finite float32 [B,48], B >= 1")
return x
class FourSkillActorCritic(nn.Module):
"""Actor and critic see the same state; the environment maps tanh output to ±0.05 rad."""
feature_version = FEATURE_VERSION
def __init__(self, hidden=128, initial_std=0.08):
super().__init__()
self.model_config = _model_config(hidden, initial_std)
offset = torch.zeros(FEATURE_DIM, dtype=torch.float32)
offset[:3] = torch.tensor([0.0, 0.8, -1.5])
scale = torch.ones(FEATURE_DIM, dtype=torch.float32)
scale[:3] = 0.5
scale[3:6] = 10.0
scale[6:12] = torch.tensor([50.0, 50.0, 50.0, 5.0, 5.0, 5.0])
scale[15:18] = 5.0
scale[18:21] = 0.1
scale[21:24] = 0.5
scale[24:27] = 0.4
scale[30:33] = 50.0
scale[33] = 0.05
scale[38:41] = 0.4
self.register_buffer("offset", offset)
self.register_buffer("scale", scale)
self.actor = nn.Sequential(
nn.Linear(FEATURE_DIM, hidden), nn.Tanh(), nn.Linear(hidden, hidden), nn.Tanh(), nn.Linear(hidden, 3)
)
self.critic = nn.Sequential(
nn.Linear(FEATURE_DIM, hidden), nn.Tanh(), nn.Linear(hidden, hidden), nn.Tanh(), nn.Linear(hidden, 1)
)
self.float()
for module in self.modules():
if isinstance(module, nn.Linear):
nn.init.orthogonal_(module.weight, math.sqrt(2))
nn.init.zeros_(module.bias)
# Exact analytic baseline prior, independent of state and random seed.
nn.init.zeros_(self.actor[-1].weight)
nn.init.zeros_(self.actor[-1].bias)
nn.init.orthogonal_(self.critic[-1].weight, 1.0)
self.log_std = nn.Parameter(torch.full((3,), math.log(initial_std), dtype=torch.float32))
def distribution_value(self, x):
x = features(x)
try:
x = x.to(device=self.offset.device)
except (RuntimeError, TypeError) as exc:
raise ValueError("Cannot move features to model device") from exc
x = ((x - self.offset) / self.scale).clamp(-10, 10)
return Normal(
self.actor(x), self.log_std.clamp(math.log(0.02), math.log(0.5)).exp(), validate_args=False
), self.critic(x).squeeze(-1)
def act(self, x, deterministic=False):
if type(deterministic) is not bool:
raise ValueError("deterministic must be bool")
dist, value = self.distribution_value(x)
latent = dist.mean if deterministic else dist.sample()
# PPO stores fixed Gaussian latents: the tanh Jacobian cancels in ratios.
return latent.tanh(), latent, dist.log_prob(latent).sum(-1), value
def evaluate(self, x, latent):
x = features(x)
if (
not isinstance(latent, torch.Tensor)
or latent.layout != torch.strided
or latent.device.type == "meta"
or latent.shape != (len(x), 3)
or latent.dtype != torch.float32
or not torch.isfinite(latent).all()
):
raise ValueError("latent must be finite float32 [B,3]")
try:
latent = latent.to(device=self.offset.device)
except (RuntimeError, TypeError) as exc:
raise ValueError("Cannot move latent to model device") from exc
dist, value = self.distribution_value(x)
return dist.log_prob(latent).sum(-1), value
def value(self, x):
return self.distribution_value(x)[1]
def _plain_tree(value):
"""Snapshot only weights-only-safe data, rejecting nonfinite tensors or metadata."""
if type(value) is torch.Tensor:
if value.layout != torch.strided or value.device.type == "meta" or not torch.isfinite(value).all():
raise ValueError("Checkpoint contains nonfinite or unsupported tensor")
return value.detach().cpu().clone()
if type(value) is dict:
if any(type(key) not in (str, int) for key in value):
raise ValueError("Checkpoint dictionary keys must be strings or integers")
return {key: _plain_tree(item) for key, item in value.items()}
if type(value) in (list, tuple):
return type(value)(_plain_tree(item) for item in value)
if value is None or type(value) in (str, bool, int):
return value
if type(value) is float and math.isfinite(value):
return value
raise ValueError("Checkpoint must contain only finite tensors and plain data")
def _canonical_identity(identity):
if type(identity) is not dict or not identity:
raise ValueError("identity must be a nonempty plain dictionary")
try:
return json.dumps(identity, sort_keys=True, separators=(",", ":"), allow_nan=False)
except (TypeError, ValueError) as exc:
raise ValueError("identity must contain canonical JSON data") from exc
def _validate_payload(payload):
keys = {"format", "features", "feature_dim", "model_config", "model", "optimizer", "identity", "update", "metrics", "rng"}
if type(payload) is not dict or set(payload) != keys:
raise ValueError("Malformed four-skills checkpoint fields")
if payload["format"] != CHECKPOINT_FORMAT or payload["features"] != FEATURE_VERSION:
raise ValueError("Wrong four-skills checkpoint format or feature version")
if type(payload["feature_dim"]) is not int or payload["feature_dim"] != FEATURE_DIM:
raise ValueError("Wrong four-skills feature dimension; legacy policies are incompatible")
config = payload["model_config"]
if type(config) is not dict or set(config) != {"hidden", "initial_std"}:
raise ValueError("Malformed model_config")
_model_config(**config)
if type(payload["update"]) is not int or payload["update"] < 0:
raise ValueError("update must be a nonnegative integer")
_canonical_identity(payload["identity"])
if payload["metrics"] is not None and type(payload["metrics"]) is not dict:
raise ValueError("metrics must be a dictionary or None")
if type(payload["model"]) is not dict or type(payload["optimizer"]) is not dict:
raise ValueError("Malformed model or optimizer state")
if set(payload["optimizer"]) != {"state", "param_groups"}:
raise ValueError("Malformed optimizer state")
if type(payload["optimizer"]["state"]) is not dict or type(payload["optimizer"]["param_groups"]) is not list:
raise ValueError("Malformed optimizer state")
rng = payload["rng"]
if type(rng) is not dict or set(rng) != {"cpu", "cuda"} or type(rng["cuda"]) is not list:
raise ValueError("Malformed RNG state")
for state in [rng["cpu"], *rng["cuda"]]:
if not isinstance(state, torch.Tensor) or state.dtype != torch.uint8 or state.ndim != 1 or state.numel() == 0:
raise ValueError("RNG state must contain nonempty uint8 vectors")
if rng["cpu"].shape != torch.get_rng_state().shape:
raise ValueError("Invalid CPU RNG state size")
def _load_model_state(model, state):
expected = model.state_dict()
if set(state) != set(expected):
raise ValueError("Wrong four-skills model state fields")
for key, value in state.items():
if not isinstance(value, torch.Tensor) or value.shape != expected[key].shape or value.dtype != expected[key].dtype:
raise ValueError(f"Invalid model tensor: {key}")
for key in ("offset", "scale"):
if not torch.equal(state[key].cpu(), expected[key].cpu()):
raise ValueError("Checkpoint changes fixed SI normalization")
model.load_state_dict(state, strict=True)
def save_checkpoint(path, model, optimizer, identity, update, metrics=None):
"""Atomically publish a finite, plain-data checkpoint (no simulator resume state)."""
if not isinstance(model, FourSkillActorCritic) or not isinstance(optimizer, torch.optim.Optimizer):
raise ValueError("Expected FourSkillActorCritic and Torch optimizer")
payload = {
"format": CHECKPOINT_FORMAT,
"features": FEATURE_VERSION,
"feature_dim": FEATURE_DIM,
"model_config": model.model_config,
"model": dict(model.state_dict()),
"optimizer": optimizer.state_dict(),
"identity": identity,
"update": update,
"metrics": metrics,
"rng": {"cpu": torch.get_rng_state(), "cuda": torch.cuda.get_rng_state_all() if torch.cuda.is_available() else []},
}
payload = _plain_tree(payload)
_validate_payload(payload)
# Validate architecture and fixed buffers before creating/replacing any artifact.
with torch.random.fork_rng(devices=[]):
check = FourSkillActorCritic(**payload["model_config"])
_load_model_state(check, payload["model"])
path = Path(path)
path.parent.mkdir(parents=True, exist_ok=True)
temporary = None
try:
with tempfile.NamedTemporaryFile(dir=path.parent, delete=False) as stream:
temporary = Path(stream.name)
torch.save(payload, stream)
stream.flush()
os.fsync(stream.fileno())
os.replace(temporary, path)
finally:
if temporary is not None:
temporary.unlink(missing_ok=True)
def load_policy(path, device="cpu", expected_sha256=None, expected_identity=None):
"""Verify optional digest before deserialization; return an eval model and payload."""
contents = Path(path).read_bytes()
if expected_sha256 is not None:
if (
type(expected_sha256) is not str
or len(expected_sha256) != 64
or any(c not in "0123456789abcdefABCDEF" for c in expected_sha256)
or hashlib.sha256(contents).hexdigest() != expected_sha256.lower()
):
raise ValueError("Checkpoint SHA256 mismatch or malformed expected digest")
try:
payload = torch.load(io.BytesIO(contents), map_location="cpu", weights_only=True)
except Exception as exc:
raise ValueError("Cannot read a weights-only four-skills checkpoint") from exc
payload = _plain_tree(payload)
_validate_payload(payload)
if expected_identity is not None and _canonical_identity(payload["identity"]) != _canonical_identity(expected_identity):
raise ValueError("Four-skills checkpoint identity mismatch")
with torch.random.fork_rng(devices=[]):
model = FourSkillActorCritic(**payload["model_config"])
_load_model_state(model, payload["model"])
try:
model.to(device=device)
except (RuntimeError, TypeError, ValueError, AssertionError) as exc:
raise ValueError(f"Cannot move four-skills model to device {device!r}") from exc
return model.eval(), payload
@@ -0,0 +1 @@
"""Direct-construction four-skill task. Import only after Isaac AppLauncher."""
@@ -0,0 +1,70 @@
"""Additive physical config: all original asset/auxiliary limits remain unchanged."""
import json
from pathlib import Path
from isaaclab.envs import mdp as base_mdp
from isaaclab.managers import ObservationGroupCfg, ObservationTermCfg, RewardTermCfg, TerminationTermCfg
from isaaclab.utils.configclass import configclass
from SkillFactory.tasks.manager_based.contact_cycle_sim.cfg import SimContactCycleEnvCfg, RewardsCfg as CycleRewardsCfg
from SkillFactory.tasks.manager_based.single_leg_anchor.mdp.actions import BoundedJointPositionActionCfg
from . import mdp
ROOT = Path(__file__).resolve().parents[6]
@configclass
class ObservationsCfg:
@configclass
class Policy(ObservationGroupCfg):
state = ObservationTermCfg(func=mdp.observation)
def __post_init__(self):
self.enable_corruption = False
self.concatenate_terms = True
policy = Policy()
@configclass
class RewardsCfg:
task = RewardTermCfg(func=mdp.reward, weight=1.)
@configclass
class TerminationsCfg:
time_out = TerminationTermCfg(func=base_mdp.time_out, time_out=True)
failed = TerminationTermCfg(func=mdp.failed)
@configclass
class FourSkillsEnvCfg(SimContactCycleEnvCfg):
four_config: str = str(ROOT / 'configs/four_skills/v050.json')
four_parameters: dict | None = None
force_tier: str = 'none'
training_mode: bool = False
observations = ObservationsCfg()
rewards = RewardsCfg()
terminations = TerminationsCfg()
def __post_init__(self):
self.four_parameters = json.loads(Path(self.four_config).read_text())
if self.four_parameters['format'] != 'skillfactory.four-skills.v0.5.0':
raise ValueError('Require independent four-skill configuration')
# The inherited constructor configures its own old reward terms before
# environment construction; use those only during that config phase.
skill_rewards = self.rewards
self.rewards = CycleRewardsCfg()
super().__post_init__()
self.rewards = skill_rewards
# Each environment owns a deterministic independently sampled real force
# schedule; legacy named scenarios are not superimposed.
self.cycle_parameters['events'] = []
self.scene.num_envs = 1
self.sim.dt = .002
self.decimation = 5
self.episode_length_s = 120.
self.actions.joint_position = BoundedJointPositionActionCfg(
class_type=mdp.FourSkillAction, asset_name='robot',
joint_names=self.leg_bundle['joint_order'], scale=.5,
preserve_order=True, use_default_offset=True)
@@ -0,0 +1,139 @@
"""Explicit 500Hz safety stepping. Evaluation never autoresets or writes poses."""
import torch
from isaaclab.envs import ManagerBasedRLEnv
from SkillFactory.legs.four_skills.api import SkillService
from .mdp import state
class FourSkillsEnv(ManagerBasedRLEnv):
def __init__(self, cfg, *, runtime_hooks, guard=lambda: None, record=None, paint=None):
self.runtime_hooks = runtime_hooks
self.guard, self.record, self.paint = guard, record, paint
self._reset_allowed = False
self._initial_reset_done = False
self.total_ticks = 0
super().__init__(cfg)
self.s = state(self)
self.service = SkillService(self.s)
if (self._physics_handles_decimation or self.recorder_manager.active_terms
or self.physics_dt != .002 or self.cfg.decimation != 5
or self.s.robot.is_fixed_base or self.cfg.sim.physics.solver_type != 0
or self.cfg.sim.physics.enable_external_forces_every_iteration
or self.cfg.cycle_parameters['support'] != {'kp_N_m': 1800., 'kd_Ns_m': 120., 'max_N': 140.}):
raise RuntimeError('Require original aided floating-root PGS,500Hz/100Hz,unchanged auxiliary')
self.runtime_hooks.mode = 'locked'
self.runtime_hooks.guard_composer(self.s.robot.permanent_wrench_composer)
# Guard sensor and action resets as well as SDK pose writers.
for obj in [self.s.controller, self.action_manager, self.observation_manager,
*self.scene.sensors.values(), *self.s.robot.actuators.values()]:
self.runtime_hooks.guard_object(obj, ('reset',))
def _reset_idx(self, ids):
if not self._reset_allowed:
raise RuntimeError('No reset/pose overwrite inside held skills or composition')
self.runtime_hooks.require_initialization('four_skills._reset_idx')
ManagerBasedRLEnv._reset_idx(self, ids)
if hasattr(self, '_cycle_state'):
self._cycle_state.reset(ids)
def reset(self, seed=None, env_ids=None, options=None):
if self._initial_reset_done and not self.cfg.training_mode:
raise RuntimeError('Exactly one initial reset for continuous evaluation')
if options is not None:
raise ValueError('No reset state options')
self._reset_allowed = True
try:
with self.runtime_hooks.scope('initialization'):
result = ManagerBasedRLEnv.reset(self, seed=seed, env_ids=env_ids)
self.s.controller.refresh(torch.arange(self.num_envs, device=self.device))
self._initial_reset_done = True
return result
finally:
self._reset_allowed = False
def reset_to(self, *args, **kwargs):
raise RuntimeError('No reset_to/state teleport API')
def _training_reset(self, ids):
if not self.cfg.training_mode:
raise RuntimeError('Training reset prohibited during evaluation')
self._reset_allowed = True
try:
with self.runtime_hooks.scope('initialization'):
self._reset_idx(ids)
self.scene.write_data_to_sim()
self.sim.forward()
self.scene.update(0.)
self.s.controller.refresh(ids)
finally:
self._reset_allowed = False
def step(self, action):
if not self._initial_reset_done:
raise RuntimeError('Initialize once before controls')
if (not isinstance(action, torch.Tensor) or action.shape != (self.num_envs, 3)
or action.dtype != torch.float32 or action.device != torch.device(self.device)
or not bool(torch.isfinite(action).all())):
raise ValueError('Finite float32[B,3] residual action required')
s = self.s
if bool(s.failed.any()) or (not self.cfg.training_mode and bool(s.stopped.any())):
raise RuntimeError('Never advance a failed/stopped session')
self.guard()
self.action_manager.process_action(action)
advanced = 0
for _ in range(self.cfg.decimation):
self.guard()
if self.paint is not None and self.paint.closed:
raise InterruptedError('gui_window_closed_before_completion')
self._sim_step_counter += 1
with self.runtime_hooks.wrench_update(s.robot.permanent_wrench_composer):
self.action_manager.apply_action()
self.scene.write_data_to_sim()
with self.runtime_hooks.scope('rollout'):
self.sim.step(render=False)
self.scene.update(dt=self.physics_dt)
s.after_physics(self.physics_dt)
self.total_ticks += 1
advanced += 1
if self.record is not None:
self.record(s)
# Preserve offending tick before any next physical step, including
# shortened training controls. Only new training episodes may reset.
if bool(s.failed.any()) or (not self.cfg.training_mode and bool(s.stopped.any())):
break
if self.paint is not None:
self.paint.check_health()
self.paint.update(self)
self.sim.render(skip_app_pumping=not self.render_enabled)
self.paint.check_health()
self.paint.after_render()
if self.paint.closed:
raise InterruptedError('gui_window_closed_before_completion')
elif self.sim.is_rendering and self._sim_step_counter % self.cfg.sim.render_interval == 0:
self.sim.render(skip_app_pumping=not self.render_enabled)
self.episode_length_buf += 1
self.common_step_counter += 1
s.controller.refresh(torch.arange(self.num_envs, device=self.device))
reward = s.reward()
terminated = s.failed.clone()
truncated = s.time >= self.cfg.episode_length_s
terminal = s.policy().clone()
info = {'ticks_advanced': advanced, 'terminal_observation': {'policy': terminal},
'terminal_ids': torch.arange(self.num_envs, device=self.device),
'failure_counts': {k: int(v.sum()) for k, v in s.failure_masks.items()}}
if self.cfg.training_mode:
ids = (terminated | truncated).nonzero().flatten()
if len(ids):
self._training_reset(ids)
if not self.cfg.training_mode and not bool(s.failed.any()):
# Route stops AFTER old-command physical evidence/reward and BEFORE
# the next observation/inference. Never apply an old-skill residual
# to a newly switched skill in the same step.
pending = (s.stop_requested & s.ready & ((s.skill == 1) | (s.skill == 2))).nonzero().flatten()
supported = (s.stop_requested & s.ready & (s.skill == 3)).nonzero().flatten()
if len(pending):
self.service.call('plant', hold_seconds=0., env_ids=pending)
if len(supported):
self.service.call('support', hold_seconds=0., env_ids=supported)
self.obs_buf = {'policy': s.policy()}
return self.obs_buf, reward, terminated, truncated, info
@@ -0,0 +1,262 @@
"""Genuine live Kit presentation and owned-X11 original-speed recording.
Only camera/light/UI and nonphysical force-line prims are written. No Robot
poses, rigid-body fields, material/physics parameters, or control state writes.
"""
import ctypes
import json
import os
from pathlib import Path
import re
import signal
import subprocess
import time
from SkillFactory.tasks.manager_based.contact_cycle_sim import skill_gui_v041 as base
FFMPEG = Path('/home/cen/isaacsim-6.0.1/kit/python/lib/python3.12/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2')
def owned_window():
text = subprocess.check_output(['xprop', '-root', '_NET_CLIENT_LIST'], text=True)
for wid in re.findall(r'0x[0-9a-f]+', text):
try:
info = subprocess.check_output(['xprop', '-id', wid, '_NET_WM_PID', '_NET_WM_NAME'],
text=True, stderr=subprocess.DEVNULL)
match = re.search(r'_NET_WM_PID\(CARDINAL\) = (\d+)', info)
if match is None or int(match[1]) != os.getpid():
continue
geo = subprocess.check_output(['xwininfo', '-id', wid], text=True, stderr=subprocess.DEVNULL)
def value(label):
return int(re.search(label + r':\s+(-?\d+)', geo)[1])
if value('Width') >= 800 and value('Height') >= 600 and 'IsViewable' in geo:
return {'id': wid, 'pid': os.getpid(), 'x': value('Absolute upper-left X'),
'y': value('Absolute upper-left Y'), 'width': value('Width'),
'height': value('Height'), 'xprop': info, 'xwininfo': geo}
except subprocess.CalledProcessError:
continue # disappearing window is not interpreted as successful capture
return None
def wm_close(window):
class Data(ctypes.Union):
_fields_ = [('b', ctypes.c_char * 20), ('s', ctypes.c_short * 10), ('l', ctypes.c_long * 5)]
class ClientMessage(ctypes.Structure):
_fields_ = [('type', ctypes.c_int), ('serial', ctypes.c_ulong), ('send_event', ctypes.c_int),
('display', ctypes.c_void_p), ('window', ctypes.c_ulong),
('message_type', ctypes.c_ulong), ('format', ctypes.c_int), ('data', Data)]
class Event(ctypes.Union):
_fields_ = [('xclient', ClientMessage), ('padding', ctypes.c_long * 24)]
lib = ctypes.CDLL('libX11.so.6')
lib.XOpenDisplay.argtypes = [ctypes.c_char_p]
lib.XOpenDisplay.restype = ctypes.c_void_p
display = lib.XOpenDisplay(os.environ['DISPLAY'].encode())
if not display:
raise RuntimeError('No actual X11 display')
lib.XInternAtom.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_int]
lib.XInternAtom.restype = ctypes.c_ulong
event = Event()
event.xclient.type = 33
event.xclient.display = display
event.xclient.window = int(window['id'], 16)
event.xclient.message_type = lib.XInternAtom(display, b'WM_PROTOCOLS', False)
event.xclient.format = 32
event.xclient.data.l[0] = lib.XInternAtom(display, b'WM_DELETE_WINDOW', False)
lib.XSendEvent.argtypes = [ctypes.c_void_p, ctypes.c_ulong, ctypes.c_int, ctypes.c_long, ctypes.POINTER(Event)]
lib.XSendEvent(display, int(window['id'], 16), False, 0, ctypes.byref(event))
lib.XFlush.argtypes = [ctypes.c_void_p]
lib.XFlush(display)
lib.XCloseDisplay.argtypes = [ctypes.c_void_p]
lib.XCloseDisplay(display)
class Presentation(base.LivePresentation):
def __init__(self, app, env, output):
base.prepare_native()
self.output = Path(output)
self.window_info = None
self.video = self.video_log = None
self.video_command = None
self.video_exit = None
self.captures = []
self.seen = set()
self.created = time.monotonic()
self.first_tick_wall = None
self.final_carry_equal = False
super().__init__(app, env.guard, lambda value: None)
self.env = env
self.initial_render_generation = env.sim.render_generation
self.attach(env)
self.expected_visualizer = next(v for v in env.sim.visualizers if v.cfg.visualizer_type == 'kit')
self.window.title = 'Go2 FL | four skills 0.5.0 | LIVE PhysX'
self.window.height = 350
self.message.text = 'Aided single leg | original auxiliary | real force | no resets'
self.arrow = base.UsdGeom.BasisCurves.Define(base.omni.usd.get_context().get_stage(), '/World/ActualExternalForce')
self.arrow.CreateTypeAttr('linear')
self.arrow.CreateCurveVertexCountsAttr([2])
self.arrow.CreateWidthsAttr([.004])
self.arrow.SetWidthsInterpolation('constant')
self.arrow.CreateDisplayColorAttr([(1., .05, .03)])
with self.window.frame:
# Rebuild with a separate explicit safety request; OS close remains
# immediate abort while physics is active, never a safe-stop claim.
with base.ui.VStack(spacing=4):
self.mode = base.ui.Label('', height=24)
self.phase = base.ui.Label('', height=24)
self.cycle = base.ui.Label('', height=24)
self.progress = base.ui.ProgressBar(height=14)
self.contact = base.ui.Label('', height=24)
self.position = base.ui.Label('', height=24)
self.message = base.ui.Label('Aided fixture | truth sensing | no pose reset', height=24)
base.ui.Button('Request SAFE STOP (plant then support)', clicked_fn=env.service.request_stop, height=28)
base.ui.Button('Close window (ABORT while running)', clicked_fn=self.request_close, height=28)
for name in ('Simulation Output Settings', 'Semantics Schema Editor', 'Layer', 'Render Settings'):
panel = base.ui.Workspace.get_window(name)
if panel is not None:
panel.visible = False
def check_health(self):
v = self.expected_visualizer
if (not self.app.is_running() or v not in self.env.sim.visualizers
or not v.is_running() or v.is_training_paused()):
raise RuntimeError('Actual bound Kit visualizer closed/removed/paused')
def update(self, env):
from SkillFactory.legs.four_skills.api import SKILLS
s = env.s
tick = int(s.substeps[0])
self.last_tick = tick
self.render_updates = env.sim.render_generation - self.initial_render_generation
if self.window is not None:
skill = SKILLS[int(s.skill[0])]
self.mode.text = 'Control: ' + getattr(self, 'controller_label', 'analytic') + ' | ' + skill.upper()
self.phase.text = f'Ready: {bool(s.ready[0])} | hold {float(s.held[0]):.2f}/{float(s.hold_required[0]):.2f}s'
central = getattr(env, 'central_progress', {})
loops = f"loop {central.get('completed_loops', 0)}/{central.get('requested_loops', '?')}"
self.cycle.text = f'{loops} | tick {tick} | sim {float(s.time[0]):.2f}s | 500Hz safety'
self.progress.model.set_value(min(float(s.held[0]) / max(.1, float(s.hold_required[0])), 1.))
normal = float(s.contact()[0, 2])
gap = float(s.foot_center()[0, 2] - s.bundle['foot']['radius'])
force = s.actual_external[0].tolist()
auxiliary = float(s.auxiliary[0, s.payload, 2])
self.contact.text = f'Contact Fn {normal:.2f}N | gap {gap*1000:.1f}mm | auxiliaryZ {auxiliary:.1f}N'
self.position.text = f'REAL external world N: {force[0]:+.2f}, {force[1]:+.2f}, {force[2]:+.2f}'
if hasattr(self, 'arrow'):
pos = s.root()[0][0].detach().cpu().tolist()
end = [p + .025 * f for p, f in zip(pos, force)]
self.arrow.GetPointsAttr().Set([base.Gf.Vec3f(*pos), base.Gf.Vec3f(*end)])
if tick and self.window_info is None:
self.window_info = owned_window()
if self.window_info is not None:
self.start_video()
if tick and self.first_tick_wall is None:
self.first_tick_wall = time.monotonic()
def after_render(self):
from SkillFactory.legs.four_skills.api import SKILLS
s = self.env.s
key = (int(s.skill[0]), bool(s.ready[0]))
capture_key = key
label = f'{SKILLS[key[0]]}-' + ('ready' if key[1] else 'enter')
if float(s.actual_external.norm()) > .5 and 'external-force' not in self.seen:
capture_key, label = 'external-force', 'external-force'
if self.window_info is not None and self.last_tick > 5 and capture_key not in self.seen:
import torch
before = torch.cat((s.q(), *s.root()), -1).clone()
counts = (self.env.runtime_hooks.completed_steps, self.env.runtime_hooks.reset_calls,
self.env.runtime_hooks.pose_write_calls)
# UI/compositor is one displayed frame behind after a single paint.
# Synchronize only by rendering the SAME verified physical state.
for _ in range(3):
self.env.sim.render()
self.check_health()
time.sleep(.05)
if (not torch.equal(before, torch.cat((s.q(), *s.root()), -1))
or counts != (self.env.runtime_hooks.completed_steps, self.env.runtime_hooks.reset_calls,
self.env.runtime_hooks.pose_write_calls)):
raise RuntimeError('Presentation synchronization advanced physics')
self.capture(label)
self.seen.add(capture_key)
def start_video(self):
w = self.window_info
self.video_command = [str(FFMPEG), '-hide_banner', '-y', '-f', 'x11grab', '-framerate', '30',
'-video_size', f'{w["width"]//2*2}x{w["height"]//2*2}',
'-i', f'{os.environ["DISPLAY"]}+{w["x"]},{w["y"]}', '-an', '-c:v', 'libx264',
'-preset', 'ultrafast', '-crf', '25', '-pix_fmt', 'yuv420p', '-t', '2400',
str(self.output / 'live-kit-original-speed.mp4')]
self.video_log = (self.output / 'screen-video.log').open('w')
self.video = subprocess.Popen(self.video_command, stdin=subprocess.PIPE,
stdout=self.video_log, stderr=subprocess.STDOUT)
(self.output / 'actual-window.json').write_text(json.dumps(w, indent=2))
def capture(self, label):
from PIL import ImageGrab
w = self.window_info
image = ImageGrab.grab(xdisplay=os.environ['DISPLAY'])
image = image.crop((w['x'], w['y'], w['x'] + w['width'], w['y'] + w['height']))
path = self.output / (label + '.png')
image.save(path)
self.captures.append({'path': path.name, 'tick': self.last_tick, 'wall_time': time.time(),
'state': self.env.service.query()})
def finish(self, complete, *, safely_stopped=False):
import torch
self.protocol_completed = complete
if not complete and not safely_stopped:
return
self.message.text = ('SEQUENCE COMPLETE' if complete else 'SAFE STOP (not full sequence)') + ' | physical state retained | normal close'
before = torch.cat((self.env.s.q(), *self.env.s.root()), -1).clone()
counts = (self.env.runtime_hooks.completed_steps, self.env.runtime_hooks.reset_calls,
self.env.runtime_hooks.pose_write_calls)
end = time.monotonic() + 5
while not self.closed and time.monotonic() < end:
self.guard()
self.check_health()
self.env.sim.render()
time.sleep(1/30)
self.capture('final-retained')
self.final_carry_equal = torch.equal(before, torch.cat((self.env.s.q(), *self.env.s.root()), -1))
self.hold_no_physics = counts == (self.env.runtime_hooks.completed_steps, self.env.runtime_hooks.reset_calls,
self.env.runtime_hooks.pose_write_calls)
if not self.final_carry_equal or not self.hold_no_physics:
raise RuntimeError('Final render-only view changed physical state')
if self.window_info is None:
raise RuntimeError('No verified owned actual Kit window')
wm_close(self.window_info)
close_deadline = time.monotonic() + 10
while not self.closed and time.monotonic() < close_deadline:
self.guard()
self.env.sim.render()
if not self.closed:
raise RuntimeError('Actual WM_DELETE not observed')
self.close_reason = 'actual_WM_DELETE_after_completion'
self.stop_video()
def stop_video(self):
if self.video is not None:
if self.video.poll() is None:
# ffmpeg SIGINT normally returns255 even after finalizing MP4;
# explicit stdin quit is the documented clean exit0 path.
self.video.stdin.write(b'q\n')
self.video.stdin.flush()
self.video.stdin.close()
self.video_exit = self.video.wait(timeout=30)
if self.video_log is not None and not self.video_log.closed:
self.video_log.close()
if self.video_exit != 0:
raise RuntimeError('Real Kit recording did not exit cleanly')
def report(self):
result = {'genuine_Kit_window': self.window_info, 'protocol_completed': self.protocol_completed,
'render_updates': self.render_updates, 'close_reason': self.close_reason,
'final_carry_equal': self.final_carry_equal, 'hold_no_physics': self.hold_no_physics,
'video_command': self.video_command, 'video_waited_exit': self.video_exit,
'captures': self.captures, 'recording_fps_is_not_simulation_rtf': True}
(self.output / 'gui-evidence.json').write_text(json.dumps(result, indent=2))
return result
def release(self):
self.stop_video()
self.report()
super().release()
@@ -0,0 +1,398 @@
"""Skill-local references and real state feedback; no force-sampling actor labels."""
import json
from pathlib import Path
import torch
from isaaclab.utils.math import axis_angle_from_quat
from SkillFactory.legs.contact_cycle.mechanics import inverse_rotate, reduce_to_com
from SkillFactory.legs.contact_cycle.task import phase_failures, phase_objective
from SkillFactory.legs.contact_cycle_sim.config import combine
from SkillFactory.legs.contact_cycle_sim.reference import ReferenceController
from SkillFactory.legs.four_skills.api import LEGAL, SKILLS
from SkillFactory.legs.four_skills.forces import ForceSchedule
from SkillFactory.tasks.manager_based.contact_cycle.mdp import CycleState
from SkillFactory.tasks.manager_based.single_leg_anchor.mdp.actions import BoundedJointPositionAction
def smooth(x):
x = x.clamp(0, 1)
return x.square() * (3 - 2 * x)
def hold_watchdog(ready, held, required, completed, age, deadline):
"""A brief ready edge cannot buy an unlimited unfinished requested hold."""
completed = completed | (ready & (held + 1e-6 >= required))
return completed, ~completed & (age > deadline)
class FourSkillState(CycleState):
def __init__(self, env):
super().__init__(env)
n, d = env.num_envs, env.device
self.config = env.cfg.four_parameters
self.skill = torch.zeros(n, dtype=torch.long, device=d)
self.age = torch.zeros(n, device=d)
self.age_ticks = torch.zeros(n, device=d, dtype=torch.long)
self.dwell = torch.zeros(n, device=d)
self.held = torch.zeros(n, device=d)
self.hold_required = torch.zeros(n, device=d)
self.ready = torch.zeros(n, dtype=torch.bool, device=d)
self.ever_ready = torch.zeros_like(self.ready)
self.hold_completed = torch.zeros_like(self.ready)
self.hold_timed_out = torch.zeros_like(self.ready)
self.hold_deadline = torch.full((n,), 2., device=d)
self.stop_requested = torch.zeros_like(self.ready)
self.stopped = torch.zeros_like(self.ready)
self.failed = torch.zeros_like(self.ready)
self.functional_failed = torch.zeros_like(self.ready)
self.bad_hold = torch.zeros(n, device=d)
self.unload_initial = self.weight.clone()
self.unload_min = self.weight.clone()
self.unload_passed = torch.ones_like(self.ready)
self.ground_target = self.origin.clone()
self.entry_ground = self.origin.clone()
self.swing_start = self.origin.clone()
self.swing_delta = torch.zeros(n, 3, device=d)
self.entry_foot = self.foot_center().clone()
self.episode_ids = [0] * n
self.forces = ForceSchedule(env.cfg.seed, list(range(n)), env.cfg.force_tier, d,
duration_s=300., episode_ids=self.episode_ids)
self.controller = ReferenceController(self, env.cfg.residual_parameters['reference'])
self.residual_request = torch.zeros(n, 3, device=d)
self.reference_used = torch.zeros_like(self.residual_request)
self.effective_residual_rad = torch.zeros_like(self.residual_request)
self.controller.reset(torch.arange(n, device=d))
self.lower = self.time.new_tensor([j['limits']['lower'] for j in self.bundle['joints']])
self.upper = self.time.new_tensor([j['limits']['upper'] for j in self.bundle['joints']])
self.speed = self.time.new_tensor([j['limits']['velocity'] for j in self.bundle['joints']])
self.failure_masks = {}
self.transitions = []
self.force_tier = env.cfg.force_tier
self.actual_external = torch.zeros(n, 3, device=d)
def reset(self, ids):
# CycleState.__init__ calls the virtual reset before additive fields exist.
super().reset(ids)
if not hasattr(self, 'skill'):
return
self.skill[ids] = 0
self.age_ticks[ids] = 0
for v in (self.age, self.dwell, self.held, self.hold_required, self.bad_hold):
v[ids] = 0
for v in (self.ready, self.ever_ready, self.hold_completed, self.hold_timed_out,
self.stop_requested, self.stopped, self.failed, self.functional_failed):
v[ids] = False
self.hold_deadline[ids] = 2.
self.ground_target[ids] = self.origin[ids]
self.entry_ground[ids] = self.origin[ids]
self.entry_foot[ids] = self.foot_center()[ids]
self.swing_delta[ids] = 0
self.unload_initial[ids] = self.weight[ids]
self.unload_min[ids] = self.weight[ids]
self.unload_passed[ids] = True
rows = ids.cpu().tolist()
for i in rows:
self.episode_ids[i] += 1
self.forces.reset(rows, [self.episode_ids[i] for i in rows], tier=self.force_tier)
self.residual_request[ids] = 0
self.reference_used[ids] = 0
self.effective_residual_rad[ids] = 0
self.controller.reset(ids)
def ids(self, ids):
if ids is None:
return torch.arange(self.env.num_envs, device=self.env.device)
if isinstance(ids, torch.Tensor):
x = ids
else:
if not isinstance(ids, (list, tuple)) or any(type(i) is not int for i in ids):
raise ValueError('Exact integer environment indices required')
x = torch.tensor(ids, device=self.env.device, dtype=torch.long)
if (x.ndim != 1 or x.dtype not in (torch.int32, torch.int64) or not len(x)
or bool((x < 0).any() or (x >= self.env.num_envs).any()) or len(x.unique()) != len(x)):
raise ValueError('Invalid/duplicate environment indices')
return x.to(device=self.env.device, dtype=torch.long)
def reference(self):
if not hasattr(self, 'skill'):
return super().reference()
t, k = self.age, self.skill
phase = torch.zeros_like(k)
progress = torch.zeros_like(t)
target = self.ground_target.clone()
force = self.weight.clone()
fraction = torch.zeros_like(t)
# Same six original physical subphases, now owned by the active skill,
# with indefinitely held endpoints, not by a global periodic timer.
retract = k == 1
u, lift = smooth(t / 1.), smooth((t - 1.) / .6)
phase = torch.where(retract, torch.where(t < 1., 1, 2), phase)
progress = torch.where(retract, torch.where(t < 1., t, ((t - 1.) / .6).clamp(0, 1)), progress)
target[:, 2] += torch.where(retract, .05 * lift, 0.)
force = torch.where(retract, self.weight * (1 - u), force)
fraction = torch.where(retract, u, fraction)
swing = k == 2
p = (t / 1.4).clamp(0, 1)
swung = self.swing_start + self.swing_delta * smooth(p)[:, None]
swung[:, 2] = self.origin[:, 2] + .05 + .01 * torch.sin(torch.pi * p).square()
target = torch.where(swing[:, None], swung, target)
phase = torch.where(swing, 3, phase)
progress = torch.where(swing, p, progress)
force = torch.where(swing, 0., force)
fraction = torch.where(swing, 1., fraction)
plant = k == 3
lower, reload = smooth(t / .8), smooth((t - .8) / 2.2)
target[:, 2] += torch.where(plant, .05 * (1 - lower), 0.)
phase = torch.where(plant, torch.where(t < .8, 4, 5), phase)
progress = torch.where(plant, torch.where(t < .8, (t / .8).clamp(0, 1), ((t - .8) / 2.2).clamp(0, 1)), progress)
force = torch.where(plant, self.weight * reload, force)
fraction = torch.where(plant, 1 - reload, fraction)
return phase, progress, target, force, fraction
def apply_loads(self):
# Original guide/auxiliary formula, exactly ONE COM composer submission.
# No old deterministic events or extra cancellation feedforward.
_, _, _, _, fraction = self.reference()
pos, quat, vel, omega = self.root()
target, target_vel = self.port_reference()
identity = torch.zeros_like(quat)
identity[:, 3] = 1
com = self.robot.data.body_com_pos_w.torch
disp = torch.cat((pos - target, axis_angle_from_quat(quat)), -1)
velocity = torch.cat((vel - target_vel, omega), -1)
raw = (-self.stiffness * disp - self.damping * velocity).clamp(-self.wrench_limit, self.wrench_limit)
if not self.env.cfg.guide_enabled:
raw.zero_()
self.guide.zero_()
self.guide[:, self.payload] = reduce_to_com(raw[:, :3], raw[:, 3:], identity, pos, com[:, self.payload])
support = self.cc['support']
fz = fraction * (self.weight + support['kp_N_m'] * (target[:, 2] - pos[:, 2])
+ support['kd_Ns_m'] * (target_vel[:, 2] - vel[:, 2]))
force = torch.zeros_like(pos)
if self.env.cfg.auxiliary_enabled:
force[:, 2] = fz.clamp(0, support['max_N'])
self.auxiliary.zero_()
self.auxiliary[:, self.payload] = reduce_to_com(force, torch.zeros_like(force), identity, pos, com[:, self.payload])
self.actual_external = self.forces.at(self.time)
self.external.zero_()
self.external[:, self.payload, :3] = self.actual_external
total = self.external + self.guide + self.auxiliary
self.robot.permanent_wrench_composer.set_forces_and_torques_index(
forces=total[..., :3], torques=total[..., 3:], body_ids=self.all_bodies,
positions=None, is_global=True)
def after_physics(self, dt):
self.substeps += 1
self.time[:] = self.substeps * dt
self.age_ticks += 1
self.age[:] = self.age_ticks * dt
self.sensed = self.raw_sensors()
normal = self.contact()[:, 2]
gap = self.foot_center()[:, 2] - self.bundle['foot']['radius']
_, self.edge_on = self.latch.update(normal, dt)
self.acquisition.update(self.time, gap, normal, self.weight, dt)
phase = self.reference()[0]
self.edge_off = self.separation.update(gap, self.latch.contact, phase, dt)
self.impact = torch.where(phase == 4, torch.maximum(self.impact, normal), torch.zeros_like(normal))
g = self.config['gate']
support = (normal >= .5 * self.weight) & self.latch.contact & (gap <= .002)
airborne = (gap >= .01) & (normal <= 2.)
final = torch.where(self.skill == 0, self.age >= 0.,
torch.where(self.skill == 1, self.age >= 1.6,
torch.where(self.skill == 2, self.age >= 1.4, self.age >= 3.)))
good = torch.where((self.skill == 0) | (self.skill == 3), support, airborne)
retract_unload = (self.skill == 1) & (self.age <= 1.002)
self.unload_min = torch.where(retract_unload, torch.minimum(self.unload_min, normal), self.unload_min)
self.unload_passed |= (self.skill == 1) & (self.unload_min <= .8 * self.unload_initial)
good &= (self.skill != 1) | self.unload_passed
disp = self.foot_center() - self.entry_foot
requested = self.swing_delta
directed = ((disp[:, :2] * requested[:, :2].sign()) >= .5 * requested[:, :2].abs()) | (requested[:, :2].abs() < 1e-6)
good &= (self.skill != 2) | directed.all(-1)
land_error = (self.foot_center() - self.ground_target).norm(dim=-1)
good &= (self.skill != 3) | (land_error <= .05)
dwell_required = torch.where((self.skill == 0) | (self.skill == 3), .2, .1)
self.dwell = torch.where(good & final, self.dwell + dt, 0.)
self.ready = self.dwell + 1e-6 >= dwell_required
self.ever_ready |= self.ready
self.held = torch.where(self.ready, self.held + dt, 0.)
self.hold_completed, hold_expired = hold_watchdog(
self.ready, self.held, self.hold_required, self.hold_completed, self.age, self.hold_deadline)
self.hold_timed_out |= hold_expired
self.bad_hold = torch.where(self.ever_ready & ~good, self.bad_hold + dt, 0.)
deadline = torch.where(self.skill == 0, 2., torch.where(self.skill == 1, 3.6,
torch.where(self.skill == 2, 3.4, 5.)))
self.functional_failed |= ((~self.ever_ready & (self.age > deadline))
| self.hold_timed_out | (self.bad_hold > .2))
self.stopped |= self.stop_requested & (self.skill == 0) & self.ready
masks = self.safety()
self.failure_masks = {**masks, 'skill_completion_or_hold': self.functional_failed,
'requested_hold_timeout': self.hold_timed_out}
all_failed = torch.stack(list(self.failure_masks.values())).any(0)
self.failed |= all_failed
def safety(self):
pos, quat, velocity, omega = self.root()
gap = self.foot_center()[:, 2] - self.bundle['foot']['radius']
ratio = torch.maximum((self.robot.data.applied_torque.torch[:, self.joints] / self.effort).abs().amax(-1),
(self.robot.data.joint_vel.torch[:, self.joints] / self.speed).abs().amax(-1))
excess = torch.maximum(self.lower - self.q(), self.q() - self.upper).clamp(min=0).amax(-1)
finite = torch.isfinite(torch.cat((self.raw_sensors(), pos, quat, velocity, omega,
self.foot_center(), self.contact(),
self.robot.data.applied_torque.torch[:, self.joints],
ratio[:, None], excess[:, None],
self.controller.q_ik, self.controller.action, self.residual_request,
self.guide.flatten(1), self.auxiliary.flatten(1),
self.external.flatten(1)), -1)).all(-1)
phase, progress, _, _, _ = self.reference()
auxiliary_z = self.auxiliary[..., 2]
original_phase = phase_failures(phase, progress, gap, self.contact()[:, 2], self.weight)
return {**original_phase, 'premature_separation': self.separation.premature,
'nonfinite': ~finite, 'contact_acquisition_timeout': self.acquisition.failed,
'negative_normal': self.contact()[:, 2] < -.5,
'auxiliary_force': auxiliary_z.sum(-1) > 140.,
'auxiliary_geometry': ((self.auxiliary[..., :2].abs().amax(dim=(-1, -2)) > 1e-6)
| (auxiliary_z.amin(-1) < -1e-6)
| (self.auxiliary[..., 5].abs().amax(-1) > 1e-6)
| (self.auxiliary[..., 3:].norm(dim=-1) > .06 * auxiliary_z.clamp_min(0) + 1e-6).any(-1)),
'auxiliary_support_phase': (phase == 0) & (self.auxiliary.abs().amax(dim=(-1, -2)) > 1e-6),
'effort_velocity': ratio > 1.00001,
'joint_limit': excess > .01, 'vertical_guide': self.guide[..., 2].abs().amax(-1) != 0,
'penetration': gap < -.002, 'root_height': (pos[:, 2] - self.base_origin[:, 2]).abs() > .1,
'tilt': self.tilt() > .6}
def request(self, skill, hold, vector, ids=None):
ids = self.ids(ids)
old = self.skill[ids].cpu().tolist()
if any(skill not in LEGAL[SKILLS[i]] for i in old):
raise ValueError('Illegal skill transition')
if bool((~self.ready[ids] | self.failed[ids] | self.stopped[ids]
| (self.held[ids] + 1e-6 < self.hold_required[ids])).any()):
raise ValueError('Transition requires ready, completed hold, live healthy skill')
before = self.substeps[ids].clone()
self.entry_ground[ids] = self.ground_target[ids]
self.entry_foot[ids] = self.foot_center()[ids]
if skill == 'retract':
self.unload_initial[ids] = self.contact()[ids, 2].clamp(min=1.)
self.unload_min[ids] = self.unload_initial[ids]
self.unload_passed[ids] = False
if skill == 'swing':
delta = self.time.new_tensor([*vector, 0.])
self.swing_start[ids] = self.ground_target[ids]
self.swing_start[ids, 2] = self.origin[ids, 2] + .05
self.swing_delta[ids] = delta
self.ground_target[ids] += delta
self.ground_target[ids, 2] = self.origin[ids, 2]
self.skill[ids] = SKILLS.index(skill)
self.age[ids] = self.dwell[ids] = self.held[ids] = self.bad_hold[ids] = 0
self.age_ticks[ids] = 0
self.ready[ids] = self.ever_ready[ids] = self.hold_completed[ids] = self.hold_timed_out[ids] = False
self.hold_required[ids] = hold
self.hold_deadline[ids] = self.time.new_tensor([2., 3.6, 3.4, 5.])[self.skill[ids]] + hold
self.controller.refresh(ids)
if not torch.equal(before, self.substeps[ids]):
raise RuntimeError('Transition advanced physical clock')
if self.env.num_envs == 1:
self.transitions.append({'from': SKILLS[old[0]], 'to': skill, 'tick': int(before[0]),
'hold_s': hold, 'direction_m': vector})
return {'accepted': True, 'skill': skill, 'env_ids': ids.cpu().tolist()}
def hold(self, duration, ids=None):
ids = self.ids(ids)
if bool((self.failed[ids] | self.stopped[ids]).any()):
raise ValueError('Cannot hold failed/stopped skill')
self.hold_required[ids] = duration
self.held[ids] = 0
self.hold_completed[ids] = self.ready[ids] & (duration == 0)
intrinsic = self.time.new_tensor([0., 1.6, 1.4, 3.])[self.skill[ids]]
self.hold_deadline[ids] = torch.maximum(self.age[ids], intrinsic) + duration + 2.
return {'accepted': True, 'hold_seconds': duration}
def request_stop(self, ids=None):
ids = self.ids(ids)
self.stop_requested[ids] = True
self.hold_required[ids] = 0
self.stopped[ids] |= self.ready[ids] & (self.skill[ids] == 0)
return {'accepted': True, 'safe_support_required': True}
def query(self, ids=None):
ids = self.ids(ids)
rows = []
for i in ids.cpu().tolist():
rows.append({'skill': SKILLS[int(self.skill[i])], 'tick': int(self.substeps[i]),
'ready': bool(self.ready[i]), 'hold_complete': bool(self.held[i] + 1e-6 >= self.hold_required[i]),
'held_s': float(self.held[i]), 'age_s': float(self.age[i]),
'failed': bool(self.failed[i]), 'stopped': bool(self.stopped[i]),
'stop_requested': bool(self.stop_requested[i]),
'failure_reasons': [k for k, v in self.failure_masks.items() if bool(v[i])],
'normal_N': float(self.contact()[i, 2]),
'gap_m': float(self.foot_center()[i, 2] - self.bundle['foot']['radius'])})
return rows[0] if len(rows) == 1 else rows
def policy(self):
_, progress, target, _, _ = self.reference()
pos, quat, vel, omega = self.root()
foot = self.foot_center()
gravity = torch.zeros_like(pos)
gravity[:, 2] = -1
# Explicit field allowlist. No forces, desired normal load, fixture
# labels, random seeds/onsets/durations or future disturbance values.
return torch.cat((self.q(), self.robot.data.joint_vel.torch[:, self.joints], self.mount_wrench(),
inverse_rotate(quat, gravity), inverse_rotate(quat, omega),
pos - self.base_origin, vel, inverse_rotate(quat, foot - pos), self.point_velocity(),
self.contact(), (foot[:, 2] - self.bundle['foot']['radius'])[:, None],
torch.nn.functional.one_hot(self.skill, 4).float(),
target - self.base_origin, progress[:, None],
self.controller.action, self.residual_request), -1)
def reward(self):
phase, progress, target, desired_force, _ = self.reference()
center = self.foot_center()
gap = center[:, 2] - self.bundle['foot']['radius']
# Reuse the old phase-correct objective: ground tracking while unloading,
# Fn-aware airborne lift/swing, and load restoration throughout reload.
task, violation = phase_objective(phase, progress, (center - target).norm(dim=-1), gap,
self.contact()[:, 2], desired_force, self.slip_velocity(), self.impact, self.weight,
self.cc['contact_transition']['unload_tracking_scale_m'])
return (task + .5 * self.ready.float() - .02 * self.residual_request.square().mean(-1)
- 10 * (self.failed | violation).float())
def state(env):
if not hasattr(env, '_cycle_state'):
env._cycle_state = FourSkillState(env)
if not isinstance(env._cycle_state, FourSkillState):
raise RuntimeError('Wrong additive four-skill state')
return env._cycle_state
def observation(env):
return state(env).policy()
def reward(env):
return state(env).reward()
def failed(env):
return state(env).failed
class FourSkillAction(BoundedJointPositionAction):
def __init__(self, cfg, env):
super().__init__(cfg, env)
state(env)
def process_actions(self, actions):
s = state(self._env)
full, request, delta = combine(s.controller.action, actions, .05, .5)
super().process_actions(full)
s.reference_used.copy_(s.controller.action)
s.residual_request.copy_(request)
s.effective_residual_rad.copy_(delta)
s.executed.copy_(self.raw_actions)
def apply_actions(self):
state(self._env).apply_loads()
super().apply_actions()
+90
View File
@@ -0,0 +1,90 @@
"""CPU-only public command validation and exact supervisor-entry regression."""
import importlib.util
from pathlib import Path
import sys
import pytest
ROOT = Path(__file__).resolve().parents[1]
def load(name, path):
spec = importlib.util.spec_from_file_location(name, ROOT / path)
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
return module
api = load('four_api', 'source/SkillFactory/SkillFactory/legs/four_skills/api.py')
cli = load('four_cli', 'scripts/four_skills.py')
runtime = load('four_runtime', 'scripts/four_skills_runtime.py')
def test_paused_stage_cannot_create_or_reuse_authority(tmp_path, monkeypatch):
monkeypatch.setattr(cli, 'STAGE', tmp_path)
(tmp_path / 'PAUSED.json').write_text('{"reason":"user"}')
with pytest.raises(PermissionError, match='paused by user'):
cli.scope()
assert not (tmp_path / 'scope.json').exists()
def test_exact_supervisor_command_relative_and_absolute():
script = ROOT / 'scripts/four_skills.py'
for name in (str(script), 'scripts/four_skills.py'):
assert cli.supervisor_command_matches([b'/usr/bin/python3.12', name.encode(), b'smoke'], ROOT)
assert not cli.supervisor_command_matches([b'python', b'/tmp/four_skills.py', b'smoke'], ROOT)
assert not cli.supervisor_command_matches([b'python', str(script).encode(), b'--_worker-fd'], ROOT)
assert not cli.supervisor_command_matches([b'python', b'scripts/four_skills.py', b'smoke'], '/tmp')
assert not cli.supervisor_command_matches([b'python'], ROOT)
class Sink:
def __init__(self):
self.calls = []
def request(self, *args):
self.calls.append(args)
return args
@pytest.mark.parametrize('kwargs', [dict(skill='unknown'), dict(skill='support', direction_m=[.01, .02]),
dict(skill='swing', direction_m=[0., 0.]), dict(skill='swing', direction_m=[.1, 0.]),
dict(skill='swing', direction_m=[True, .02]), dict(skill='support', hold_seconds=True),
dict(skill='support', hold_seconds=float('nan')), dict(skill='support', hold_seconds=11),
dict(skill='support', external_force=[1, 2, 3]), dict(skill='support', desired_force=50)])
def test_invalid_public_command_never_mutates_state(kwargs):
state = Sink()
service = api.SkillService(state)
with pytest.raises((ValueError, TypeError)):
service.call(**kwargs)
assert state.calls == []
def test_public_fields_only_and_legal_graph():
s = Sink()
api.SkillService(s).call('swing', hold_seconds=.3, direction_m=[.02, .01])
assert s.calls == [('swing', .3, (.02, .01), None)]
assert api.LEGAL == {'support': ('retract',), 'retract': ('swing', 'plant'),
'swing': ('swing', 'plant'), 'plant': ('support',)}
def test_training_composer_one_transition_per_row_per_feedback_sample():
from types import SimpleNamespace
import torch
s = SimpleNamespace(episode_ids=[0, 0], skill=torch.tensor([0, 2]),
ready=torch.ones(2, dtype=torch.bool), held=torch.ones(2), hold_required=torch.zeros(2),
failed=torch.zeros(2, dtype=torch.bool), stopped=torch.zeros(2, dtype=torch.bool))
calls = []
class Service:
def call(self, skill, *, env_ids, **kwargs):
assert bool(s.ready[env_ids].all())
calls.append((skill, env_ids.tolist()))
s.skill[env_ids] = api.SKILLS.index(skill)
s.ready[env_ids] = False
env = SimpleNamespace(s=s, service=Service(), num_envs=2, device='cpu')
driver = runtime.TrainingComposer(env)
driver.update()
assert calls == [('retract', [0]), ('plant', [1])]
assert driver.transition_count == 2
driver.update()
assert len(calls) == 2
+141
View File
@@ -0,0 +1,141 @@
"""Synthetic counterexamples for evidence checking, not physical success proof."""
import copy
import hashlib
import importlib.util
import json
from pathlib import Path
import pytest
import torch
from SkillFactory.legs.four_skills.forces import ForceSchedule
ROOT = Path(__file__).resolve().parents[1]
spec = importlib.util.spec_from_file_location('four_auditor', ROOT / 'scripts/audit_four_skills.py')
auditor = importlib.util.module_from_spec(spec)
spec.loader.exec_module(auditor)
def js(path, value):
path.write_text(json.dumps(value))
def smooth(x):
x = x.clamp(0, 1)
return x.square() * (3 - 2*x)
@pytest.fixture
def run(tmp_path):
out = tmp_path / 'analytic'
out.mkdir()
sizes = [350, 1000, 950, 1850, 350]
kinds = [0, 1, 2, 3, 0]
count = sum(sizes)
skill = torch.cat([torch.full((n,), k, dtype=torch.long) for k, n in zip(kinds, sizes)])
age = torch.cat([torch.arange(1, n+1).float()*.002 for n in sizes])
foot = torch.zeros(count, 1, 3)
foot[..., 2] = .02
fn = torch.ones(count, 1) * 50
a, b, c, d = 350, 1350, 2300, 4150
foot[a:b, 0, 2] += .05 * smooth((age[a:b]-1)/.6)
fn[a:b, 0] *= 1-smooth(age[a:b])
p = smooth(age[b:c]/1.4)
foot[b:c, 0, :2] = p[:, None]*torch.tensor([.024, .010])
foot[b:c, 0, 2] = .07
fn[b:c] = 0
foot[c:, 0, :2] = torch.tensor([.024, .010])
foot[c:d, 0, 2] += .05*(1-smooth(age[c:d]/.8))
fn[c:d, 0] *= smooth((age[c:d]-.8)/2.2)
normal = torch.zeros(count, 1, 3)
normal[..., 2] = fn
zero = torch.zeros(count, 1)
t = {'tick': torch.arange(1, count+1)[:, None],
'time_s': (torch.arange(1, count+1).float()*.002)[:, None],
'skill': skill[:, None], 'age_s': age[:, None], 'episode_id': torch.ones(count, 1, dtype=torch.long),
'weight': torch.ones(count, 1)*50, 'failed': zero.bool(), 'root': torch.zeros(count, 1, 13),
'joint_pos': torch.zeros(count, 1, 3), 'joint_vel': torch.zeros(count, 1, 3),
'normal': normal, 'foot': foot, 'gap': foot[..., 2]-.02, 'target': foot.clone(),
'reference': torch.zeros(count, 1, 3), 'q_ik': torch.zeros(count, 1, 3),
'actor_observation': torch.zeros(count, 1, 48), 'external': torch.zeros(count, 1, 2, 6),
'guide': torch.zeros(count, 1, 2, 6), 'auxiliary': torch.zeros(count, 1, 2, 6),
'phase': torch.where(skill == 0, 0, torch.where(skill == 1, torch.where(age < 1., 1, 2),
torch.where(skill == 2, 3, torch.where(age < .8, 4, 5))))[:, None],
'limit_ratio': zero.clone(),
'joint_excess': zero.clone(), 'height_error': zero.clone(), 'tilt': zero.clone()}
initial = {k: v[0].clone() for k, v in t.items()}
initial['time_s'].zero_()
torch.save(t, out/'trace.pt')
torch.save(initial, out/'initial-state.pt')
approval = {'seed': 115011, 'sequence': 0, 'loops': 1, 'mode': 'evaluate', 'tier': 'none',
'config_sha256': hashlib.sha256((ROOT/'configs/four_skills/v050.json').read_bytes()).hexdigest(),
'controller': 'analytic', 'checkpoint': None, 'checkpoint_sha256': None}
js(out/'approval.json', approval)
counters = {'resets': 11, 'pose_writes': 14}
js(out/'worker-result.json', {'actual_ticks': count, 'requested_loops': 1, 'completed_loops': 1,
'functional_success': True, 'initialization_counters': counters, 'final_counters': counters,
'physics_counts': {'initialization': 0, 'completed': count}})
js(out/'supervisor-result.json', {'success': True, 'owned_cleanup': True, 'waited_exit': True})
js(out/'runtime-identity.json', {'payload_body_index': 0, 'body_names': ['virtual_payload', 'foot']})
js(out/'force-schedule.json', ForceSchedule(115011, [0], 'none', 'cpu', episode_ids=[1]).manifest())
js(out/'transitions.json', [dict(zip(('from', 'to', 'at_tick'), (old, new, tick)),
feedback_ready=True, feedback_hold_complete=True) for old, new, tick in
[('support', 'retract', a), ('retract', 'swing', b), ('swing', 'plant', c), ('plant', 'support', d)]])
assert auditor.audit(out)['passed']
return out
def change_trace(run, change):
t = torch.load(run/'trace.pt', weights_only=True)
change(t)
torch.save(t, run/'trace.pt')
return auditor.audit(run)
def test_actual_tensor_skill_order_cannot_be_replaced_by_claimed_json(run):
result = change_trace(run, lambda t: t['skill'].__setitem__(slice(350, 1350), 3))
assert not result['passed'] and 'actual_skill_order_mismatch' in result['failure_reasons']
@pytest.mark.parametrize('field', ['time_s', 'episode_id'])
def test_timestamps_and_episode_identity_are_not_unchecked_labels(run, field):
result = change_trace(run, lambda t: t[field].__setitem__((100, 0), t[field][100, 0]+1))
assert not result['passed']
def test_transition_tick_must_equal_actual_tensor_boundary(run):
edges = json.loads((run/'transitions.json').read_text())
edges[0]['at_tick'] += 1
js(run/'transitions.json', edges)
assert 'transition_tick_mismatch' in auditor.audit(run)['failure_reasons']
def test_support_ratio_alone_cannot_hide_interrupted_continuous_hold(run):
result = change_trace(run, lambda t: t['normal'].__setitem__((340, 0, 2), 0.))
assert not result['passed']
assert any('continuous_support' in reason for reason in result['failure_reasons'])
def test_swing_progress_must_persist_through_hold_not_only_last_frame(run):
result = change_trace(run, lambda t: t['foot'].__setitem__((slice(2100, 2299), 0, slice(0, 2)), 0.))
assert any('continuous_signed_swing_hold' in reason for reason in result['failure_reasons'])
def test_zero_requested_couple_is_verified_not_just_net_force(run):
result = change_trace(run, lambda t: t['external'].__setitem__((20, 0, 0, 3), .1))
assert 'sampled_force_not_actually_applied' in result['failure_reasons']
def test_schedule_tier_must_equal_approval(run):
js(run/'force-schedule.json', ForceSchedule(115011, [0], 'small', 'cpu', episode_ids=[1]).manifest())
assert 'schedule_tier_not_approved' in auditor.audit(run)['failure_reasons']
def test_same_initial_tensors_and_force_schedule_do_not_pair_different_tasks(run, tmp_path):
import shutil
other = tmp_path/'trained'
shutil.copytree(run, other)
a = json.loads((other/'approval.json').read_text())
a.update(controller='trained', checkpoint='/example/weights.pt', checkpoint_sha256='a'*64, sequence=1)
js(other/'approval.json', a)
result = auditor.compare_pair(run, other)
assert not result['paired'] and not result['approved_conditions_equal']['sequence']
+208
View File
@@ -0,0 +1,208 @@
"""CPU synthetic schedule tests, not simulator, hardware or task-success proof."""
import importlib.util
import json
import math
from pathlib import Path
import random
import pytest
import torch
PATH = (Path(__file__).resolve().parents[1]
/ "source/SkillFactory/SkillFactory/legs/four_skills/forces.py")
SPEC = importlib.util.spec_from_file_location("four_skills_forces", PATH)
MODULE = importlib.util.module_from_spec(SPEC)
SPEC.loader.exec_module(MODULE)
ForceSchedule = MODULE.ForceSchedule
def schedule(**kwargs):
options = dict(seed=137, env_ids=[10, 20, 30], tier="full", device="cpu")
options.update(kwargs)
return ForceSchedule(**options)
def test_paired_analytic_trained_schedules_are_identical_and_order_independent():
analytic = schedule(episode_ids=[3, 4, 5])
trained = schedule(episode_ids=[3, 4, 5])
assert analytic.manifest() == trained.manifest()
for t in torch.linspace(0, 300, 501, dtype=torch.float64):
assert torch.equal(analytic.at(t.repeat(3)), trained.at(t.repeat(3)))
reordered = schedule(env_ids=[30, 10, 20], episode_ids=[5, 3, 4])
rows = analytic.manifest()["rows"]
assert reordered.manifest()["rows"] == [rows[2], rows[0], rows[1]]
alone = schedule(env_ids=[20], episode_ids=[4])
assert alone.manifest()["rows"] == [rows[1]]
assert schedule(seed=138).manifest()["rows"] != schedule().manifest()["rows"]
def test_reset_order_subset_and_tiers_preserve_unselected_rows():
first, second = schedule(), schedule()
before = first.manifest()["rows"]
first.reset([2, 0], [9, 7], tier="small")
second.reset([0], [7], tier="small")
second.reset([2], [9], tier="small")
assert first.manifest() == second.manifest()
assert first.manifest()["rows"][1] == before[1]
expected = schedule(env_ids=[10, 30], episode_ids=[7, 9], tier="small")
assert [first.manifest()["rows"][i] for i in [0, 2]] == expected.manifest()["rows"]
first.reset([0], [8])
assert first.manifest()["rows"][0]["tier"] == "small"
first.reset([0], [7])
assert first.manifest() == second.manifest()
for t in [0.4, 8.5, 32.9, 99.4]:
assert torch.equal(first.at(torch.full((3,), t)), second.at(torch.full((3,), t)))
@pytest.mark.parametrize("tier,maximum", [("none", 0), ("small", 1.5), ("medium", 4), ("full", 8)])
def test_event_bounds_nonoverlap_and_force_bounds(tier, maximum):
s = schedule(tier=tier)
manifest = s.manifest()
assert manifest["tier_maxima_N"] == dict(none=0, small=1.5, medium=4, full=8)
assert manifest["frame"] == "world"
assert manifest["application_point"] == "payload_com"
assert manifest["requested_couple_Nm"] == [0, 0, 0]
for row in manifest["rows"]:
previous_end = -1
for e in row["events"]:
assert 0.2 - 1e-12 <= e["onset_s"] - e["slot_start_s"] <= 0.5 + 1e-12
assert 0.5 <= e["duration_s"] <= 1.3
assert 0.25 * maximum <= e["amplitude_N"] <= maximum
assert math.isclose(sum(v*v for v in e["direction_world"]), 1, abs_tol=1e-14)
assert previous_end < e["onset_s"]
assert e["end_s"] < e["slot_start_s"] + 2
previous_end = e["end_s"]
for t in torch.linspace(0, 300, 1001):
force = s.at(t.repeat(3))
assert force.shape == (3, 3) and force.dtype == torch.float32
assert force.device.type == "cpu"
assert bool((force.norm(dim=1) <= maximum + 1e-6).all())
def test_isotropic_directions_active_probability_and_uniform_sampling_sanity():
# Fixed seed, broad statistical checks: implementation still defines the distribution.
s = schedule(env_ids=list(range(40)))
events = [e for r in s.manifest()["rows"] for e in r["events"]]
directions = torch.tensor([e["direction_world"] for e in events], dtype=torch.float64)
assert bool((directions.mean(0).abs() < 0.035).all())
assert bool(((directions.square().mean(0) - 1/3).abs() < 0.025).all())
assert 0.77 < sum(e["active"] for e in events) / len(events) < 0.83
assert abs(sum(e["amplitude_N"] for e in events) / len(events) - 5) < 0.12
def test_raised_cosine_values_ramp_bound_inactive_and_gaps():
s = schedule(env_ids=[10])
events = s.manifest()["rows"][0]["events"]
active = next(e for e in events if e["active"])
inactive = next(e for e in events if not e["active"])
peak = torch.tensor(active["peak_force_world_N"], dtype=torch.float32)
start, end = active["onset_s"], active["end_s"]
for t, scale in [(start, 0), (start + .075, .5), (start + .15, 1),
(end - .15, 1), (end - .075, .5), (end, 0)]:
torch.testing.assert_close(s.at(torch.tensor([t], dtype=torch.float64))[0],
scale * peak, atol=1e-6, rtol=1e-6)
for t in [0, active["slot_start_s"], end + .05,
inactive["onset_s"] + .2, 300]:
assert torch.equal(s.at(torch.tensor([t], dtype=torch.float64)), torch.zeros(1, 3))
# Sample both ramps at high resolution, measuring vector (not component) slope.
times = torch.cat([torch.linspace(start - .01, start + .16, 1701, dtype=torch.float64),
torch.linspace(end - .16, end + .01, 1701, dtype=torch.float64)])
values = torch.stack([s.at(t.reshape(1))[0] for t in times])
for segment in [slice(0, 1701), slice(1701, 3402)]:
rates = values[segment].diff(dim=0).norm(dim=1) / times[segment].diff()
assert rates.max() <= 100
assert s.manifest()["maximum_force_derivative_N_per_s"] < 100
def test_no_global_rng_mutation_on_construct_reset_or_query():
python_state = random.getstate()
torch_state = torch.random.get_rng_state().clone()
s = schedule()
s.reset([1, 0], [5, 9], tier="medium")
s.at(torch.tensor([1., 2., 3.]))
s.manifest()
assert random.getstate() == python_state
assert torch.equal(torch.random.get_rng_state(), torch_state)
def test_manifest_is_complete_detached_and_reconstructs_force():
s = schedule(duration_s=3.1)
manifest = json.loads(json.dumps(s.manifest(), allow_nan=False))
for i, row in enumerate(manifest["rows"]):
assert len(row["events"]) == 2
for event in row["events"]:
assert event["truncated_by_horizon"] == (event["end_s"] > 3.1)
assert event["onset_beyond_horizon"] == (event["onset_s"] > 3.1)
t = min(3.1, event["onset_s"] + .1)
edge = max(0, min(.15, t - event["onset_s"], event["end_s"] - t))
scale = .5 * (1 - math.cos(math.pi * edge / .15))
expected = torch.tensor(event["peak_force_world_N"]) * scale
result = s.at(torch.full((3,), t, dtype=torch.float64))[i]
torch.testing.assert_close(result, expected, atol=1e-6, rtol=1e-6)
manifest["rows"][0]["events"][0]["amplitude_N"] = -1
assert s.manifest()["rows"][0]["events"][0]["amplitude_N"] >= 2
short = schedule(duration_s=.1)
assert all(r["events"][0]["onset_beyond_horizon"] for r in short.manifest()["rows"])
assert torch.equal(short.at(torch.full((3,), .1, dtype=torch.float64)), torch.zeros(3, 3))
s.at(torch.full((3,), 3.1, dtype=torch.float64))
with pytest.raises(ValueError, match="exceeds"):
s.at(torch.full((3,), 3.10000001, dtype=torch.float64))
@pytest.mark.parametrize("kwargs,error", [
({"seed": True}, TypeError), ({"seed": 1.0}, TypeError),
({"env_ids": [1, True]}, TypeError), ({"env_ids": [1., 2]}, TypeError),
({"env_ids": [1, 1]}, ValueError), ({"env_ids": "12"}, TypeError),
({"episode_ids": [1]}, ValueError), ({"episode_ids": [0, 0, False]}, TypeError),
({"tier": "large"}, ValueError), ({"tier": []}, ValueError),
({"duration_s": True}, ValueError), ({"duration_s": "300"}, ValueError),
({"duration_s": 0}, ValueError), ({"duration_s": -1}, ValueError),
({"duration_s": float("nan")}, ValueError), ({"duration_s": float("inf")}, ValueError),
])
def test_constructor_bad_inputs(kwargs, error):
with pytest.raises(error):
schedule(**kwargs)
@pytest.mark.parametrize("time,error", [
([0, 0, 0], TypeError), (torch.zeros(3, 1), ValueError),
(torch.zeros(2), ValueError), (torch.tensor([0, 0, -1]), ValueError),
(torch.tensor([0., float("nan"), 0]), ValueError),
(torch.tensor([0., float("inf"), 0]), ValueError),
(torch.tensor([0, 301, 0]), ValueError), (torch.ones(3, dtype=torch.bool), TypeError),
(torch.zeros(3, dtype=torch.complex64), TypeError),
])
def test_at_bad_inputs(time, error):
with pytest.raises(error):
schedule().at(time)
@pytest.mark.parametrize("ids,episodes,tier,error", [
([0, 0], [1, 2], None, ValueError), ([3], [0], None, ValueError),
([-1], [0], None, ValueError), ([True], [0], None, TypeError),
([1.0], [0], None, TypeError), ([0], [True], None, TypeError),
([0], [], None, ValueError), ([0], [0], "unknown", ValueError),
([0, 9], [1, 2], "small", ValueError),
])
def test_reset_bad_inputs_do_not_mutate(ids, episodes, tier, error):
s = schedule()
before = s.manifest()
with pytest.raises(error):
s.reset(ids, episodes, tier)
assert s.manifest() == before
def test_empty_batch_empty_reset_and_integer_times():
empty = schedule(env_ids=[])
assert empty.at(torch.empty(0)).shape == (0, 3)
empty.reset([], [])
assert empty.manifest()["rows"] == []
s = schedule()
before = s.manifest()
s.reset([], [], tier="none")
assert s.manifest() == before
assert s.at(torch.zeros(3, dtype=torch.int64)).shape == (3, 3)
# No unspecified nonnegative constraint on integer identity keys.
assert schedule(seed=-1, env_ids=[-10], episode_ids=[-3]).manifest()["seed"] == -1
+314
View File
@@ -0,0 +1,314 @@
"""Synthetic CPU-only four-skills seam tests: no Kit, robot data, or physical claims."""
import hashlib
import importlib.util
from pathlib import Path
import sys
import types
import pytest
import torch
ROOT = Path(__file__).resolve().parents[1]
LEGS = ROOT / "source/SkillFactory/SkillFactory/legs"
SPEC = importlib.util.spec_from_file_location("_four_skills_model_test", LEGS / "four_skills/model.py")
model_module = importlib.util.module_from_spec(SPEC)
SPEC.loader.exec_module(model_module)
FourSkillActorCritic = model_module.FourSkillActorCritic
features = model_module.features
save_checkpoint = model_module.save_checkpoint
load_policy = model_module.load_policy
@pytest.fixture(autouse=True)
def cpu_only():
# Small synthetic matrices do not benefit from a large host thread pool.
previous = torch.get_num_threads()
torch.set_num_threads(1)
yield
torch.set_num_threads(previous)
def test_four_skills_model_shapes_zero_baseline_and_shared_inputs():
model = FourSkillActorCritic(hidden=16)
x = torch.randn(7, 48)
assert features(x) is x
action, latent, logp, value = model.act(x, deterministic=True)
assert action.shape == latent.shape == (7, 3)
assert logp.shape == value.shape == (7,)
assert not action.any() and not latent.any()
assert torch.isfinite(logp).all() and torch.isfinite(value).all()
assert torch.equal(value, model.value(x))
assert model.actor[0].in_features == model.critic[0].in_features == 48
assert model.feature_version == "four-skills-48-fixed-si-v1"
assert model.model_config == {"hidden": 16, "initial_std": 0.08}
assert model.critic[-1].weight.any()
assert not torch.optim.Adam(model.parameters()).state
def test_four_skills_model_fixed_si_order_and_actor_critic_normalization():
model = FourSkillActorCritic(hidden=8)
expected_offset = torch.zeros(48)
expected_offset[:3] = torch.tensor([0.0, 0.8, -1.5])
expected_scale = torch.tensor(
[0.5] * 3 + [10.0] * 3 + [50.0] * 3 + [5.0] * 3
+ [1.0] * 3 + [5.0] * 3 + [0.1] * 3 + [0.5] * 3
+ [0.4] * 3 + [1.0] * 3 + [50.0] * 3 + [0.05]
+ [1.0] * 4 + [0.4] * 3 + [1.0] + [1.0] * 3 + [1.0] * 3
)
assert torch.equal(model.offset, expected_offset)
assert torch.equal(model.scale, expected_scale)
seen = []
handles = [net[0].register_forward_pre_hook(lambda _, args: seen.append(args[0]))
for net in (model.actor, model.critic)]
normalized = torch.linspace(-2, 2, 48).expand(2, -1)
model.value(expected_offset + expected_scale * normalized)
for handle in handles:
handle.remove()
assert len(seen) == 2
assert torch.allclose(seen[0], normalized, atol=1e-6)
assert torch.equal(seen[0], seen[1])
def test_four_skills_model_latent_logp_tanh_and_std_bounds():
model = FourSkillActorCritic(hidden=8)
x = torch.randn(11, 48)
action, latent, logp, value = model.act(x)
assert latent.any() and action.abs().max() <= 1
assert torch.equal(action, latent.tanh())
evaluated_logp, evaluated_value = model.evaluate(x, latent)
assert torch.equal(logp, evaluated_logp) and torch.equal(value, evaluated_value)
expected = torch.distributions.Normal(torch.zeros_like(latent), 0.08).log_prob(latent).sum(-1)
assert torch.allclose(logp, expected, atol=1e-6)
for log_std, expected_std in [(-100.0, 0.02), (100.0, 0.5)]:
with torch.no_grad():
model.log_std.fill_(log_std)
assert torch.allclose(model.distribution_value(x)[0].stddev, torch.full_like(latent, expected_std))
@pytest.mark.parametrize("kwargs", [
{"hidden": True}, {"hidden": 8.0}, {"hidden": 7}, {"hidden": 0}, {"hidden": -1},
{"initial_std": True}, {"initial_std": "0.08"}, {"initial_std": 0.0},
{"initial_std": float("nan")}, {"initial_std": float("inf")},
{"initial_std": 0.019}, {"initial_std": 0.501},
])
def test_four_skills_model_rejects_invalid_args(kwargs):
with pytest.raises(ValueError):
FourSkillActorCritic(**kwargs)
@pytest.mark.parametrize("bad", [
torch.zeros(2, 46), torch.zeros(2, 32), torch.zeros(48), torch.zeros(0, 48),
torch.zeros(2, 48, dtype=torch.float64), torch.zeros(2, 48, dtype=torch.int64),
torch.full((2, 48), float("nan")), torch.full((2, 48), float("inf")), [[0.0] * 48],
torch.empty(2, 48, device="meta"), torch.zeros(2, 48).to_sparse(),
])
def test_four_skills_model_rejects_bad_features(bad):
model = FourSkillActorCritic(hidden=8)
for method in (features, model.act, model.value):
with pytest.raises(ValueError, match="features"):
method(bad)
@pytest.mark.parametrize("bad", [torch.zeros(2, 4), torch.zeros(3, 3),
torch.zeros(2, 3, dtype=torch.float64),
torch.full((2, 3), float("nan")), None,
torch.empty(2, 3, device="meta")])
def test_four_skills_model_rejects_bad_latents(bad):
with pytest.raises(ValueError, match="latent"):
FourSkillActorCritic(hidden=8).evaluate(torch.zeros(2, 48), bad)
def test_four_skills_model_exact_types_and_global_default_dtype():
with pytest.raises(ValueError, match="bool"):
FourSkillActorCritic(hidden=8).act(torch.zeros(2, 48), deterministic=1)
default = FourSkillActorCritic()
assert default.model_config == {"hidden": 128, "initial_std": 0.08}
for std in (0.02, 0.5):
assert FourSkillActorCritic(hidden=8, initial_std=std).model_config["initial_std"] == std
previous = torch.get_default_dtype()
try:
torch.set_default_dtype(torch.float64)
model = FourSkillActorCritic(hidden=8)
assert all(p.dtype == torch.float32 for p in model.parameters())
assert model.value(torch.zeros(2, 48, dtype=torch.float32)).dtype == torch.float32
finally:
torch.set_default_dtype(previous)
def test_four_skills_model_generic_standing_ppo_step_synthetic():
# Private test namespace avoids SkillFactory.__init__ (Kit registration), even
# when this test is invoked directly rather than through scripts/test_cpu.py.
name = "_four_skills_cpu_legs"
package = types.ModuleType(name)
package.__path__ = [str(LEGS)]
sys.modules[name] = package
try:
spec = importlib.util.spec_from_file_location(name + ".standing_ppo", LEGS / "standing_ppo.py")
standing = importlib.util.module_from_spec(spec)
spec.loader.exec_module(standing)
torch.manual_seed(23)
model = FourSkillActorCritic(hidden=8)
optimizer = torch.optim.Adam(model.parameters(), lr=3e-4)
x = torch.randn(3, 4, 48)
with torch.no_grad():
_, latent, logp, value = model.act(x.flatten(0, 1))
data = {"features": x, "latent": latent.reshape(3, 4, 3),
"log_prob": logp.reshape(3, 4), "value": value.reshape(3, 4),
"next_value": torch.zeros(3, 4), "reward": torch.randn(3, 4),
"done": torch.zeros(3, 4, dtype=torch.bool)}
cfg = {"gamma": 0.99, "gae_lambda": 0.95, "epochs": 2, "minibatch_size": 4,
"target_kl": 1.0, "clip_ratio": 0.2, "value_coefficient": 0.5, "max_gradient_norm": 1.0}
result = standing.ppo_step(model, optimizer, data, cfg)
assert result["minibatches"] == 6 and result["sampling_log_prob_error"] == 0
assert optimizer.state and model.actor[-1].weight.any()
assert all(torch.isfinite(p).all() for p in model.parameters())
finally:
for module in list(sys.modules):
if module == name or module.startswith(name + "."):
del sys.modules[module]
@pytest.fixture
def checkpoint(tmp_path):
torch.manual_seed(7)
model = FourSkillActorCritic(hidden=8)
optimizer = torch.optim.Adam(model.parameters(), lr=3e-4)
# Exercise nonempty Adam moments without robot data or a training run.
x = torch.randn(4, 48)
logp, value = model.evaluate(x, torch.randn(4, 3) * 0.08)
(value.square().mean() - logp.mean()).backward()
optimizer.step()
path = tmp_path / "policy.pt"
identity = {"task": "go2-fl-four-skills-v0.5.0", "source": "synthetic", "seed": 7}
save_checkpoint(path, model, optimizer, identity, 1, {"loss": 0.25})
return path, model, optimizer, identity, x
def assert_tree_equal(left, right):
assert type(left) is type(right)
if isinstance(left, torch.Tensor):
assert torch.equal(left, right)
elif isinstance(left, dict):
assert left.keys() == right.keys()
for key in left:
assert_tree_equal(left[key], right[key])
elif isinstance(left, (list, tuple)):
assert len(left) == len(right)
for a, b in zip(left, right):
assert_tree_equal(a, b)
else:
assert left == right
def test_four_skills_model_checkpoint_exact_roundtrip(checkpoint):
path, model, optimizer, identity, x = checkpoint
rng = torch.get_rng_state().clone()
digest = hashlib.sha256(path.read_bytes()).hexdigest()
loaded, payload = load_policy(path, expected_sha256=digest, expected_identity=dict(reversed(list(identity.items()))))
assert not loaded.training and next(loaded.parameters()).device.type == "cpu"
assert torch.equal(rng, torch.get_rng_state()) # loading does not reseed callers
assert payload["format"] == "skillfactory.four-skills-ppo.v1"
assert payload["features"] == model.feature_version and payload["feature_dim"] == 48
assert payload["update"] == 1 and payload["metrics"] == {"loss": 0.25}
assert_tree_equal(dict(model.state_dict()), dict(loaded.state_dict()))
assert_tree_equal(optimizer.state_dict(), payload["optimizer"])
assert torch.equal(payload["rng"]["cpu"], rng)
assert payload["rng"]["cuda"] == []
for a, b in zip(model.act(x, deterministic=True), loaded.act(x, deterministic=True)):
assert torch.equal(a, b)
with pytest.raises(ValueError, match="identity"):
load_policy(path, expected_identity={**identity, "source": "wrong"})
with pytest.raises(ValueError, match="device"):
load_policy(path, device="not-a-device")
def test_four_skills_model_digest_checked_before_torch_load(checkpoint, monkeypatch):
path, *_ = checkpoint
calls = []
monkeypatch.setattr(torch, "load", lambda *args, **kwargs: calls.append(args))
with pytest.raises(ValueError, match="SHA256"):
load_policy(path, expected_sha256="0" * 64)
assert not calls
@pytest.mark.parametrize("field,value", [
("format", "skillfactory.standing-ppo-checkpoint.v1"),
("features", "contact-cycle-sim-46-fixed-si-v1"), ("feature_dim", 46), ("feature_dim", 32),
("feature_dim", 48.0), ("model_config", {"hidden": True, "initial_std": 0.08}),
("model_config", {"hidden": 8, "initial_std": float("nan")}),
("model_config", {"hidden": 8, "initial_std": 0.08, "extra": 1}),
("update", True), ("update", -1), ("rng", {}), ("optimizer", {}), ("identity", {}),
("rng", {"cpu": torch.zeros(2, dtype=torch.uint8), "cuda": []}),
("identity", {"not_json": torch.zeros(1)}), ("metrics", {"loss": float("inf")}),
])
def test_four_skills_model_rejects_malformed_checkpoint(checkpoint, field, value):
path, *_ = checkpoint
payload = torch.load(path, weights_only=True)
payload[field] = value
torch.save(payload, path)
with pytest.raises(ValueError):
load_policy(path)
@pytest.mark.parametrize("corruption", ["nonfinite", "optimizer_nonfinite", "shape", "dtype", "scale", "missing", "extra"])
def test_four_skills_model_rejects_corrupt_state(checkpoint, corruption):
path, *_ = checkpoint
payload = torch.load(path, weights_only=True)
state = payload["model"]
if corruption == "nonfinite":
state["critic.0.weight"][0, 0] = float("inf")
elif corruption == "optimizer_nonfinite":
next(iter(payload["optimizer"]["state"].values()))["exp_avg"].flatten()[0] = float("nan")
elif corruption == "shape":
state["actor.0.weight"] = torch.zeros(8, 46)
elif corruption == "dtype":
state["log_std"] = state["log_std"].double()
elif corruption == "scale":
state["scale"][0] = 1.0
elif corruption == "missing":
del state["log_std"]
else:
state["extra"] = torch.zeros(1)
torch.save(payload, path)
with pytest.raises(ValueError):
load_policy(path)
@pytest.mark.parametrize("corruption", ["parameter", "optimizer", "metrics", "custom"])
def test_four_skills_model_atomic_nonfinite_and_custom_object_rejection(checkpoint, corruption):
path, model, optimizer, identity, _ = checkpoint
original = path.read_bytes()
metrics = None
if corruption == "parameter":
with torch.no_grad():
next(model.parameters()).flatten()[0] = float("nan")
elif corruption == "optimizer":
next(iter(optimizer.state.values()))["exp_avg"].flatten()[0] = float("inf")
elif corruption == "metrics":
metrics = {"loss": float("nan")}
else:
metrics = {"custom": object()}
with pytest.raises(ValueError):
save_checkpoint(path, model, optimizer, identity, 2, metrics)
assert path.read_bytes() == original
assert list(path.parent.iterdir()) == [path]
def test_four_skills_model_atomic_replace_failure_cleanup(checkpoint, monkeypatch):
path, model, optimizer, identity, _ = checkpoint
original = path.read_bytes()
def fail_replace(*args):
raise OSError("synthetic replace failure")
monkeypatch.setattr(model_module.os, "replace", fail_replace)
with pytest.raises(OSError, match="synthetic"):
save_checkpoint(path, model, optimizer, identity, 2)
assert path.read_bytes() == original
assert list(path.parent.iterdir()) == [path]
def test_four_skills_model_rejects_unreadable_checkpoint(tmp_path):
path = tmp_path / "bad.pt"
path.write_bytes(b"not a torch checkpoint")
with pytest.raises(ValueError, match="weights-only"):
load_policy(path)
+88
View File
@@ -0,0 +1,88 @@
"""Synthetic safety fault injection, never native physical acceptance."""
import ast
from pathlib import Path
from types import SimpleNamespace as NS
import pytest
import torch
ROOT = Path(__file__).resolve().parents[1]
PATH = ROOT / 'source/SkillFactory/SkillFactory/tasks/manager_based/four_skills/mdp.py'
tree = ast.parse(PATH.read_text())
method = next(n for c in tree.body if isinstance(c, ast.ClassDef) and c.name == 'FourSkillState'
for n in c.body if isinstance(n, ast.FunctionDef) and n.name == 'safety')
from SkillFactory.legs.contact_cycle.task import phase_failures, phase_objective
namespace = {'torch': torch, 'phase_failures': phase_failures}
exec(compile(ast.fix_missing_locations(ast.Module(body=[method], type_ignores=[])), str(PATH), 'exec'), namespace)
def fake_state():
torque = torch.zeros(1, 3)
q = torch.zeros(1, 3)
return NS(root=lambda: (torch.tensor([[0., 0., .3]]), torch.tensor([[0., 0., 0., 1.]]),
torch.zeros(1, 3), torch.zeros(1, 3)),
foot_center=lambda: torch.tensor([[0., 0., .02]]), bundle={'foot': {'radius': .02}},
robot=NS(data=NS(applied_torque=NS(torch=torque), joint_vel=NS(torch=torch.zeros(1, 3)))),
joints=[0, 1, 2], effort=torch.ones(3) * 20, speed=torch.ones(3) * 20,
lower=torch.ones(3) * -2, upper=torch.ones(3) * 2, q=lambda: q,
raw_sensors=lambda: torch.zeros(1, 18), contact=lambda: torch.tensor([[0., 0., 50.]]),
guide=torch.zeros(1, 2, 6), auxiliary=torch.zeros(1, 2, 6), external=torch.zeros(1, 2, 6),
base_origin=torch.tensor([[0., 0., .3]]), acquisition=NS(failed=torch.tensor([False])),
separation=NS(premature=torch.tensor([False])), weight=torch.tensor([50.]),
reference=lambda: (torch.tensor([0]), torch.tensor([0.]), None, None, None),
controller=NS(q_ik=torch.zeros(1, 3), action=torch.zeros(1, 3)),
residual_request=torch.zeros(1, 3), tilt=lambda: torch.zeros(1))
@pytest.mark.parametrize('bad', [float('nan'), float('inf'), -float('inf')])
def test_nonfinite_torque_fails_closed_not_nan_comparison_bypass(bad):
s = fake_state()
assert not any(bool(x.any()) for x in namespace['safety'](s).values())
s.robot.data.applied_torque.torch[0, 1] = bad
assert namespace['safety'](s)['nonfinite'].tolist() == [True]
def test_original_actuator_collision_and_guide_limits_preserved():
s = fake_state()
s.robot.data.applied_torque.torch[0, 0] = 21
assert namespace['safety'](s)['effort_velocity'].item()
s = fake_state()
s.guide[0, 0, 2] = .001
assert namespace['safety'](s)['vertical_guide'].item()
s = fake_state()
s.foot_center = lambda: torch.tensor([[0., 0., .0179]])
assert namespace['safety'](s)['penetration'].item()
def test_brief_ready_cannot_disable_requested_hold_watchdog():
method = next(n for n in tree.body if isinstance(n, ast.FunctionDef) and n.name == 'hold_watchdog')
ns = {'torch': torch}
exec(compile(ast.fix_missing_locations(ast.Module(body=[method], type_ignores=[])), str(PATH), 'exec'), ns)
completed = torch.tensor([False])
deadline = torch.tensor([4.])
required = torch.tensor([.4])
expired = torch.tensor([False])
# Even granting brief ready intervals directly, no0.4s hold can complete.
for tick in range(1, 2501):
ready = torch.tensor([tick % 100 < 26])
held = torch.tensor([.002 * (tick % 100) if bool(ready[0]) else 0.])
completed, now_expired = ns['hold_watchdog'](ready, held, required, completed,
torch.tensor([tick * .002]), deadline)
expired |= now_expired
assert expired.item() and not completed.item()
# A genuinely completed hold stays complete during indefinite endpoint hold;
# the separate existing bad-hold rule still owns later physical failures.
completed, expired = ns['hold_watchdog'](torch.tensor([True]), torch.tensor([.5]), required,
torch.tensor([False]), torch.tensor([3.]), deadline)
assert completed.item() and not expired.item()
completed, expired = ns['hold_watchdog'](torch.tensor([False]), torch.tensor([0.]), required,
completed, torch.tensor([100.]), deadline)
assert completed.item() and not expired.item()
def test_phase_reward_does_not_pay_for_early_lift_during_unload():
def score(gap):
return phase_objective(torch.tensor([1]), torch.tensor([.5]), torch.tensor([gap]),
torch.tensor([gap]), torch.tensor([25.]), torch.tensor([25.]), torch.zeros(1),
torch.zeros(1), torch.tensor([50.]))[0]
assert score(0.).item() > score(.01).item()