feat(training): release V0.8 自调参 Agent

training_server/tests/test_server.py

@@ -1,3 +1,4 @@
+import json
 import subprocess
 import sys
 import tempfile
@@ -64,13 +65,7 @@ out.write_bytes(b'onnx')
         self.assertTrue((trainer_root / "scripts" / "train.py").is_file())
         self.assertTrue(
             (
-                trainer_root
-                / "src"
-                / "assets"
-                / "robots"
-                / "unitree_go2"
-                / "xmls"
-                / "go2.xml"
+                trainer_root / "src" / "assets" / "robots" / "unitree_go2" / "xmls" / "go2.xml"
             ).is_file()
         )
 
@@ -92,6 +87,15 @@ out.write_bytes(b'onnx')
         )
         self.assertEqual(command[-2:], ["--gpu-ids", "[0,2]"])
 
+    def test_resolves_reward_preset_to_inline_validated_trainer_argument(self):
+        preset_id = "f" * 32
+        reward_config = {"weights": {"pose": 1.2}, "params": {}}
+        self.manager.preset_resolver = lambda value: reward_config if value == preset_id else None
+        config = self.manager.parse_config(self.payload(rewardPresetId=preset_id))
+        command = self.manager.command_for(config)
+        index = command.index("--reward-config-json")
+        self.assertEqual(json.loads(command[index + 1]), reward_config)
+
     def test_requires_local_host_origin_and_bearer_token(self):
         handler = object.__new__(TrainingRequestHandler)
         handler.access_token = "secret-token-1234"

training_server/tests/test_tuning.py

@@ -0,0 +1,195 @@
+import math
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from tuning.advisor import AdvisorConfig, DeepSeekAdvisor  # noqa: E402
+from tuning.schema import (  # noqa: E402
+    BASE_REWARD_CONFIGURATION,
+    RewardConfigError,
+    merge_proposal,
+    validate_configuration,
+    validate_proposal,
+)
+from tuning.scoring import (  # noqa: E402
+    DEFAULT_OBJECTIVE_WEIGHTS,
+    EvaluationError,
+    score_evaluation,
+)
+from tuning.storage import TuningStorage  # noqa: E402
+
+
+class RewardSchemaTest(unittest.TestCase):
+    def test_baseline_is_complete_and_energy_is_disabled(self):
+        config = validate_configuration(BASE_REWARD_CONFIGURATION)
+        self.assertEqual(len(config["weights"]), 16)
+        self.assertEqual(config["weights"]["electrical_power"], 0.0)
+
+    def test_sparse_proposal_constraints(self):
+        patch = validate_proposal(
+            {
+                "weights": {"track_linear_velocity": 1.2, "foot_slip": -0.3},
+                "params": {"foot_gait.period": 0.65},
+            },
+            BASE_REWARD_CONFIGURATION,
+        )
+        merged = merge_proposal(BASE_REWARD_CONFIGURATION, patch)
+        self.assertEqual(merged["weights"]["track_linear_velocity"], 1.2)
+        with self.assertRaises(RewardConfigError):
+            validate_proposal({"weights": {"track_linear_velocity": 0}}, BASE_REWARD_CONFIGURATION)
+        with self.assertRaises(RewardConfigError):
+            validate_proposal({"weights": {"foot_slip": 0.2}}, BASE_REWARD_CONFIGURATION)
+        with self.assertRaises(RewardConfigError):
+            validate_proposal(
+                {"weights": {"track_linear_velocity": 3.0}}, BASE_REWARD_CONFIGURATION
+            )
+        with self.assertRaises(RewardConfigError):
+            validate_proposal({"params": {"foot_gait.period": math.nan}}, BASE_REWARD_CONFIGURATION)
+        with self.assertRaises(RewardConfigError):
+            validate_proposal(
+                {
+                    "weights": {
+                        "pose": 1.1,
+                        "foot_gait": 0.6,
+                        "foot_slip": -0.3,
+                        "soft_landing": -0.002,
+                    },
+                    "params": {"foot_gait.period": 0.65},
+                },
+                BASE_REWARD_CONFIGURATION,
+            )
+
+    def test_cross_parameter_order(self):
+        with self.assertRaises(RewardConfigError):
+            validate_proposal(
+                {"params": {"pose.walking_threshold": 0.5, "pose.running_threshold": 0.4}},
+                BASE_REWARD_CONFIGURATION,
+            )
+
+
+class ScoringTest(unittest.TestCase):
+    baseline = {
+        "linear_velocity_rmse": 0.3,
+        "angular_velocity_rmse": 0.2,
+        "mean_action_acc": 0.1,
+        "orientation_error": 0.2,
+        "fall_rate": 0.1,
+        "slip_velocity": 0.2,
+        "mechanical_power": 100.0,
+    }
+
+    def test_improvement_and_safety_gate(self):
+        better = {key: value * 0.8 for key, value in self.baseline.items()}
+        scored = score_evaluation(self.baseline, better, DEFAULT_OBJECTIVE_WEIGHTS)
+        self.assertTrue(scored["eligible"])
+        self.assertGreater(scored["score"], 0)
+        unsafe = dict(better, fall_rate=0.2)
+        scored = score_evaluation(self.baseline, unsafe)
+        self.assertFalse(scored["eligible"])
+        self.assertEqual(scored["score"], -1.0)
+
+    def test_rejects_missing_and_nonfinite_metrics(self):
+        with self.assertRaises(EvaluationError):
+            score_evaluation(self.baseline, {"fall_rate": 0.1})
+        bad = dict(self.baseline, mechanical_power=math.inf)
+        with self.assertRaises(EvaluationError):
+            score_evaluation(self.baseline, bad)
+
+
+class AdvisorTest(unittest.TestCase):
+    class Output:
+        weights = {"pose": 1.1}
+        params = {}
+        rationale = "improve posture"
+        expected_impact = {"posture": "better"}
+        confidence = 0.7
+
+    class Result:
+        output = None
+
+        @staticmethod
+        def usage():
+            return type("Usage", (), {"requests": 1, "input_tokens": 10, "output_tokens": 5})()
+
+    class Agent:
+        def __init__(self, output):
+            self.output = output
+
+        def run_sync(self, _prompt):
+            result = AdvisorTest.Result()
+            result.output = self.output
+            return result
+
+    def test_structured_result_is_revalidated_locally(self):
+        advisor = DeepSeekAdvisor(AdvisorConfig("fake"))
+        advisor._cached_agent = self.Agent(self.Output())
+        proposal = advisor.propose({"trials": []}, BASE_REWARD_CONFIGURATION)
+        self.assertEqual(proposal["patch"]["weights"]["pose"], 1.1)
+        self.assertEqual(proposal["usage"]["input_tokens"], 10)
+
+    def test_invalid_model_patch_is_rejected(self):
+        output = self.Output()
+        output.weights = {"track_linear_velocity": -1.0}
+        advisor = DeepSeekAdvisor(AdvisorConfig("fake"))
+        advisor._cached_agent = self.Agent(output)
+        with self.assertRaises(RewardConfigError):
+            advisor.propose({"trials": []}, BASE_REWARD_CONFIGURATION)
+
+
+class StorageTest(unittest.TestCase):
+    def setUp(self):
+        self.temporary = tempfile.TemporaryDirectory()
+        self.storage = TuningStorage(Path(self.temporary.name) / "state.sqlite3")
+
+    def tearDown(self):
+        self.temporary.cleanup()
+
+    def test_persists_session_trial_proposal_and_metrics(self):
+        session = self.storage.create_session(
+            "approval", {"taskId": "Unitree-Go2-Flat"}, DEFAULT_OBJECTIVE_WEIGHTS, False
+        )
+        trial = self.storage.create_trial(
+            session["id"], 0, 0, 10, BASE_REWARD_CONFIGURATION, None, "trial-000-rung-0"
+        )
+        proposal = self.storage.create_proposal(
+            session["id"],
+            trial["id"],
+            {"weights": {"pose": 1.1}, "params": {}},
+            "test",
+            {},
+            0.8,
+        )
+        self.assertTrue(self.storage.decide_proposal(proposal["id"], "approved", None))
+        self.assertFalse(self.storage.decide_proposal(proposal["id"], "approved", None))
+        points = [
+            ("Train/reward", step, float(step), 50.0 if step == 50 else float(step % 7))
+            for step in range(100)
+        ]
+        self.storage.insert_metrics(trial["id"], points)
+        sampled = self.storage.metrics(trial["id"], max_points=10)[0]["points"]
+        self.assertEqual(len(sampled), 10)
+        self.assertEqual(sampled[0]["step"], 0)
+        self.assertEqual(sampled[-1]["step"], 99)
+        self.assertIn(50.0, [point["value"] for point in sampled])
+        reopened = TuningStorage(self.storage.path)
+        self.assertEqual(reopened.get_session(session["id"])["mode"], "approval")
+
+    def test_recovery_marks_inflight_records(self):
+        session = self.storage.create_session(
+            "automatic", {"taskId": "Unitree-Go2-Flat"}, DEFAULT_OBJECTIVE_WEIGHTS, True
+        )
+        trial = self.storage.create_trial(
+            session["id"], 0, 0, 10, BASE_REWARD_CONFIGURATION, None, "trial-000-rung-0"
+        )
+        self.storage.update_session(session["id"], state="running")
+        self.storage.update_trial(trial["id"], state="training")
+        self.storage.recover_interrupted()
+        self.assertEqual(self.storage.get_session(session["id"])["state"], "interrupted")
+        self.assertEqual(self.storage.get_trial(trial["id"])["state"], "interrupted")
+
+
+if __name__ == "__main__":
+    unittest.main()

training_server/tests/test_tuning_manager.py

@@ -0,0 +1,195 @@
+import sys
+import tempfile
+import time
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from tuning.manager import TuningManager  # noqa: E402
+from tuning.process import GpuLease  # noqa: E402
+from tuning.schema import BASE_REWARD_CONFIGURATION  # noqa: E402
+from tuning.scoring import score_evaluation  # noqa: E402
+from tuning.storage import now_iso  # noqa: E402
+
+BASE_METRICS = {
+    "linear_velocity_rmse": 0.3,
+    "angular_velocity_rmse": 0.2,
+    "mean_action_acc": 0.1,
+    "orientation_error": 0.2,
+    "fall_rate": 0.1,
+    "slip_velocity": 0.2,
+    "mechanical_power": 100.0,
+}
+
+
+class FakeAdvisor:
+    def capability(self):
+        return {
+            "configured": True,
+            "apiKeyConfigured": True,
+            "frameworkInstalled": True,
+            "model": "fake",
+            "baseUrl": "https://example.invalid",
+        }
+
+    def propose(self, _context, previous):
+        value = min(2.4, previous["weights"]["pose"] * 1.05)
+        return {
+            "patch": {"weights": {"pose": value}, "params": {}},
+            "rationale": "fake",
+            "expectedImpact": {},
+            "confidence": 0.8,
+            "promptHash": "abc",
+            "usage": {},
+            "model": "fake",
+        }
+
+    def test_connection(self):
+        return {"ok": True, "model": "fake", "outputType": "fake"}
+
+
+class FakeTuningManager(TuningManager):
+    def _execute_trial(self, session, trial, resume_checkpoint=None):
+        del resume_checkpoint
+        factor = max(0.5, 1.0 - 0.03 * trial["number"] - 0.01 * trial["rung"])
+        metrics = {key: value * factor for key, value in BASE_METRICS.items()}
+        trials = self.storage.list_trials(session["id"])
+        baseline = next(
+            (item for item in trials if item["number"] == 0 and item["rung"] == 0), None
+        )
+        if baseline and baseline["evaluation"]:
+            scored = score_evaluation(
+                baseline["evaluation"]["metrics"], metrics, session["objectiveWeights"]
+            )
+        else:
+            scored = {"score": 0.0, "eligible": True, "components": {}}
+        root = self._session_root(session["id"])
+        run = root / trial["runDir"]
+        run.mkdir(parents=True, exist_ok=True)
+        (run / "model_1.pt").write_bytes(b"checkpoint")
+        (run / "policy.onnx").write_bytes(b"onnx")
+        evaluation = {"metrics": metrics, "score": scored}
+        self.storage.update_trial(
+            trial["id"],
+            state="completed",
+            started_at=now_iso(),
+            ended_at=now_iso(),
+            message="fake complete",
+            checkpoint_path=str((run / "model_1.pt").relative_to(root)),
+            policy_path=str((run / "policy.onnx").relative_to(root)),
+            evaluation=evaluation,
+            score=scored["score"],
+            eligible=scored["eligible"],
+        )
+        return self.storage.get_trial(trial["id"])
+
+
+class TuningManagerTest(unittest.TestCase):
+    def setUp(self):
+        self.temporary = tempfile.TemporaryDirectory()
+        self.root = Path(self.temporary.name)
+        (self.root / "trainer" / "scripts").mkdir(parents=True)
+        (self.root / "trainer" / "scripts" / "evaluate.py").write_text("", encoding="utf-8")
+        self.manager = FakeTuningManager(
+            self.root / "trainer",
+            sys.executable,
+            self.root / "data",
+            GpuLease(),
+            advisor=FakeAdvisor(),
+        )
+
+    def tearDown(self):
+        self.manager.shutdown()
+        self.temporary.cleanup()
+
+    @staticmethod
+    def payload(mode="automatic"):
+        return {
+            "taskId": "Unitree-Go2-Flat",
+            "mode": mode,
+            "runName": "test",
+            "numEnvs": 16,
+            "gpuIds": [0],
+            "trialCount": 4,
+            "initialIterations": 1,
+            "middleIterations": 2,
+            "finalIterations": 3,
+            "evalNumEnvs": 8,
+            "evalSteps": 10,
+        }
+
+    def wait_terminal(self, session_id, timeout=5):
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            session = self.manager.detail(session_id)
+            if session["state"] in {"succeeded", "failed", "cancelled"}:
+                return session
+            time.sleep(0.01)
+        self.fail("session did not finish")
+
+    def test_automatic_session_runs_rungs_and_persists_best_artifact(self):
+        session = self.manager.create(self.payload())
+        completed = self.wait_terminal(session["id"])
+        self.assertEqual(completed["state"], "succeeded", completed["message"])
+        self.assertGreaterEqual(len(completed["trials"]), 7)
+        self.assertTrue(self.manager.best_artifact(session["id"]).is_file())
+        self.assertEqual(len(self.manager.storage.list_presets()), 1)
+
+    def test_approval_session_waits_and_accepts_modified_patch(self):
+        session = self.manager.create(self.payload("approval"))
+        deadline = time.monotonic() + 3
+        while time.monotonic() < deadline:
+            detail = self.manager.detail(session["id"])
+            if detail["state"] == "awaiting_approval":
+                break
+            time.sleep(0.01)
+        else:
+            self.fail("session did not wait for approval")
+        proposal = detail["proposals"][-1]
+        patch = {"weights": {"pose": 1.1}, "params": {}}
+        approved = self.manager.approve(
+            session["id"], proposal["id"], {"feedback": "ok", "patch": patch}
+        )
+        self.assertEqual(approved["proposals"][-1]["state"], "approved")
+        self.manager.cancel(session["id"])
+        self.assertEqual(self.wait_terminal(session["id"])["state"], "cancelled")
+
+    def test_resume_discards_only_interrupted_trial_and_continues(self):
+        mode, config, objective, fallback = self.manager.parse_create(self.payload())
+        session = self.manager.storage.create_session(mode, config, objective, fallback)
+        baseline = self.manager.storage.create_trial(
+            session["id"],
+            0,
+            0,
+            1,
+            BASE_REWARD_CONFIGURATION,
+            None,
+            "trial-000-rung-0",
+        )
+        self.manager._execute_trial(self.manager.storage.get_session(session["id"]), baseline)
+        interrupted = self.manager.storage.create_trial(
+            session["id"],
+            1,
+            0,
+            1,
+            baseline["rewardConfig"],
+            None,
+            "trial-001-rung-0",
+        )
+        self.manager.storage.update_trial(interrupted["id"], state="interrupted")
+        self.manager.storage.update_session(session["id"], state="interrupted")
+        self.manager.resume(session["id"])
+        completed = self.wait_terminal(session["id"])
+        self.assertEqual(completed["state"], "succeeded", completed["message"])
+        self.assertNotIn(interrupted["id"], [trial["id"] for trial in completed["trials"]])
+
+    def test_create_validation_and_agent_capability(self):
+        self.assertTrue(self.manager.capability()["configured"])
+        with self.assertRaisesRegex(Exception, "只支持"):
+            self.manager.parse_create({"taskId": "Other"})
+        self.assertEqual(self.manager.test_agent()["model"], "fake")
+
+
+if __name__ == "__main__":
+    unittest.main()