feat: build Pozify-native coach summary SFT datasets

scripts/build_coach_summary_sft_dataset.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+import sys
+
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "src"))
+
+from pozify.coach_summary_sft_dataset import (  # noqa: E402
+    build_sft_row_from_run_dir,
+    collect_run_dirs,
+    split_sft_rows,
+    write_jsonl,
+)
+
+
+def build_arg_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Build Pozify-native SFT train/eval JSONL files from run artifacts."
+    )
+    parser.add_argument(
+        "--runs-dir",
+        default=str(ROOT / "runs"),
+        help="Directory containing Pozify run artifact folders.",
+    )
+    parser.add_argument(
+        "--train-output",
+        default=str(ROOT / "data/sft/coach_summary_train.jsonl"),
+        help="Destination for the train JSONL file.",
+    )
+    parser.add_argument(
+        "--eval-output",
+        default=str(ROOT / "data/sft/coach_summary_eval.jsonl"),
+        help="Destination for the eval JSONL file.",
+    )
+    parser.add_argument(
+        "--eval-count",
+        type=int,
+        default=10,
+        help="Number of examples to reserve for eval.",
+    )
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=7,
+        help="Shuffle seed for train/eval split.",
+    )
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_arg_parser()
+    args = parser.parse_args(argv)
+
+    run_dirs = collect_run_dirs(Path(args.runs_dir))
+    rows = [build_sft_row_from_run_dir(run_dir) for run_dir in run_dirs]
+    train_rows, eval_rows = split_sft_rows(
+        rows,
+        eval_count=args.eval_count,
+        seed=args.seed,
+    )
+    write_jsonl(Path(args.train_output), train_rows)
+    write_jsonl(Path(args.eval_output), eval_rows)
+    print(
+        {
+            "runs_dir": args.runs_dir,
+            "row_count": len(rows),
+            "train_count": len(train_rows),
+            "eval_count": len(eval_rows),
+            "train_output": args.train_output,
+            "eval_output": args.eval_output,
+        }
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

src/pozify/coach_summary_sft_dataset.py

@@ -0,0 +1,231 @@
+from __future__ import annotations
+
+from dataclasses import asdict
+import json
+from pathlib import Path
+import random
+from typing import Any
+
+from pozify.contracts import (
+    CoachSummary,
+    ExerciseClassification,
+    IssueMarker,
+    IssueMarkers,
+    Rep,
+    RepAnalysis,
+    RepAnalysisItem,
+    Reps,
+    UserProfile,
+    Variation,
+)
+from pozify.knowledge_cards import retrieve_cards
+from pozify.slm.prompting import build_summary_evidence
+
+
+SYSTEM_PROMPT = (
+    "You are Pozify's grounded coach-summary model. "
+    "Use only the provided structured evidence and knowledge cards. "
+    "Return coach_summary.json as JSON only."
+)
+
+
+def _load_json(path: Path) -> dict[str, Any]:
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(payload, dict):
+        raise ValueError(f"{path} must contain a JSON object")
+    return payload
+
+
+def _profile_from_dict(payload: dict[str, Any]) -> UserProfile:
+    return UserProfile(
+        goal=str(payload["goal"]),
+        experience_level=str(payload["experience_level"]),
+        intended_exercise=str(payload.get("intended_exercise", "auto")),
+        intended_variation=payload.get("intended_variation"),
+        known_limitations=[str(item) for item in payload.get("known_limitations", [])],
+        equipment=str(payload.get("equipment", "unknown")),
+    )
+
+
+def _classification_from_dict(payload: dict[str, Any]) -> ExerciseClassification:
+    return ExerciseClassification(
+        exercise=str(payload["exercise"]),
+        confidence=float(payload["confidence"]),
+        window_predictions=list(payload.get("window_predictions", [])),
+        fallback_required=bool(payload.get("fallback_required", False)),
+    )
+
+
+def _reps_from_dict(payload: dict[str, Any]) -> Reps:
+    return Reps(
+        exercise=str(payload["exercise"]),
+        reps=[
+            Rep(
+                rep_id=int(item["rep_id"]),
+                start_frame=int(item["start_frame"]),
+                mid_frame=int(item["mid_frame"]),
+                end_frame=int(item["end_frame"]),
+                start_sec=float(item["start_sec"]),
+                mid_sec=float(item["mid_sec"]),
+                end_sec=float(item["end_sec"]),
+            )
+            for item in payload.get("reps", [])
+        ],
+        partial_reps=list(payload.get("partial_reps", [])),
+    )
+
+
+def _analysis_from_dict(payload: dict[str, Any]) -> RepAnalysis:
+    return RepAnalysis(
+        exercise=str(payload["exercise"]),
+        items=[
+            RepAnalysisItem(
+                rep_id=int(item["rep_id"]),
+                duration_sec=float(item["duration_sec"]),
+                range_of_motion_score=float(item["range_of_motion_score"]),
+                stability_score=float(item["stability_score"]),
+                symmetry_score=float(item["symmetry_score"]),
+                metrics=dict(item.get("metrics", {})),
+                variation_hints=[str(value) for value in item.get("variation_hints", [])],
+            )
+            for item in payload.get("items", [])
+        ],
+        aggregate_metrics=dict(payload.get("aggregate_metrics", {})),
+    )
+
+
+def _variation_from_dict(payload: dict[str, Any]) -> Variation:
+    return Variation(
+        exercise=str(payload["exercise"]),
+        detected_variation=str(payload["detected_variation"]),
+        variation_confidence=float(payload["variation_confidence"]),
+        not_issues=[str(item) for item in payload.get("not_issues", [])],
+    )
+
+
+def _issues_from_dict(payload: dict[str, Any]) -> IssueMarkers:
+    return IssueMarkers(
+        issues=[
+            IssueMarker(
+                rep_id=int(item["rep_id"]),
+                issue=str(item["issue"]),
+                severity=float(item["severity"]),
+                start_frame=int(item["start_frame"]),
+                end_frame=int(item["end_frame"]),
+                start_sec=float(item["start_sec"]),
+                end_sec=float(item["end_sec"]),
+                affected_joints=[str(value) for value in item.get("affected_joints", [])],
+                evidence=dict(item.get("evidence", {})),
+            )
+            for item in payload.get("issues", [])
+        ]
+    )
+
+
+def _summary_from_dict(payload: dict[str, Any]) -> CoachSummary:
+    return CoachSummary(
+        summary=str(payload["summary"]),
+        what_you_did=[str(item) for item in payload.get("what_you_did", [])],
+        what_looked_good=[str(item) for item in payload.get("what_looked_good", [])],
+        what_changed_across_reps=[
+            str(item) for item in payload.get("what_changed_across_reps", [])
+        ],
+        valid_variation_vs_issue=[
+            str(item) for item in payload.get("valid_variation_vs_issue", [])
+        ],
+        top_fixes=[str(item) for item in payload.get("top_fixes", [])],
+        next_session_plan=[str(item) for item in payload.get("next_session_plan", [])],
+        confidence_notes=[str(item) for item in payload.get("confidence_notes", [])],
+    )
+
+
+def build_sft_row_from_run_dir(run_dir: Path) -> dict[str, Any]:
+    profile = _profile_from_dict(_load_json(run_dir / "user_profile.json"))
+    classification = _classification_from_dict(
+        _load_json(run_dir / "exercise_classification.json")
+    )
+    reps = _reps_from_dict(_load_json(run_dir / "reps.json"))
+    analysis = _analysis_from_dict(_load_json(run_dir / "rep_analysis.json"))
+    variation = _variation_from_dict(_load_json(run_dir / "variation.json"))
+    issues = _issues_from_dict(_load_json(run_dir / "issue_markers.json"))
+    summary = _summary_from_dict(_load_json(run_dir / "coach_summary.json"))
+
+    cards = retrieve_cards(
+        profile=profile,
+        classification=classification,
+        variation=variation,
+        issues=issues,
+    )
+    evidence = build_summary_evidence(
+        profile=profile,
+        classification=classification,
+        reps=reps,
+        analysis=analysis,
+        variation=variation,
+        issues=issues,
+        cards=cards,
+    )
+    return {
+        "messages": [
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {
+                "role": "user",
+                "content": json.dumps(evidence, ensure_ascii=False, indent=2),
+            },
+            {
+                "role": "assistant",
+                "content": json.dumps(asdict(summary), ensure_ascii=False, indent=2),
+            },
+        ],
+        "metadata": {
+            "run_dir": str(run_dir),
+            "exercise": classification.exercise,
+            "goal": profile.goal,
+            "equipment": profile.equipment,
+            "issue_count": len(issues.issues),
+            "variation": variation.detected_variation,
+        },
+    }
+
+
+def collect_run_dirs(runs_dir: Path) -> list[Path]:
+    run_dirs = []
+    for child in sorted(runs_dir.iterdir()):
+        if not child.is_dir():
+            continue
+        required = [
+            "user_profile.json",
+            "exercise_classification.json",
+            "reps.json",
+            "rep_analysis.json",
+            "variation.json",
+            "issue_markers.json",
+            "coach_summary.json",
+        ]
+        if all((child / filename).is_file() for filename in required):
+            run_dirs.append(child)
+    return run_dirs
+
+
+def split_sft_rows(
+    rows: list[dict[str, Any]],
+    *,
+    eval_count: int,
+    seed: int = 7,
+) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+    ordered = list(rows)
+    rng = random.Random(seed)
+    rng.shuffle(ordered)
+    eval_count = max(0, min(eval_count, len(ordered)))
+    eval_rows = ordered[:eval_count]
+    train_rows = ordered[eval_count:]
+    return train_rows, eval_rows
+
+
+def write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as handle:
+        for row in rows:
+            handle.write(json.dumps(row, ensure_ascii=False))
+            handle.write("\n")
+

tests/test_coach_summary_sft_dataset.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+import sys
+import tempfile
+import unittest
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from pozify.coach_summary_sft_dataset import (  # noqa: E402
+    build_sft_row_from_run_dir,
+    collect_run_dirs,
+    split_sft_rows,
+    write_jsonl,
+)
+
+
+def _write_json(path: Path, payload: dict) -> None:
+    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+
+
+class CoachSummarySftDatasetTests(unittest.TestCase):
+    def test_build_sft_row_from_run_dir(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            run_dir = Path(temp_dir) / "run-001"
+            run_dir.mkdir()
+            _write_json(
+                run_dir / "user_profile.json",
+                {
+                    "goal": "beginner_practice",
+                    "experience_level": "beginner",
+                    "intended_exercise": "push_up",
+                    "intended_variation": None,
+                    "known_limitations": [],
+                    "equipment": "bodyweight",
+                },
+            )
+            _write_json(
+                run_dir / "exercise_classification.json",
+                {
+                    "exercise": "push_up",
+                    "confidence": 0.8,
+                    "window_predictions": [],
+                    "fallback_required": False,
+                },
+            )
+            _write_json(
+                run_dir / "reps.json",
+                {
+                    "exercise": "push_up",
+                    "reps": [
+                        {
+                            "rep_id": 1,
+                            "start_frame": 0,
+                            "mid_frame": 10,
+                            "end_frame": 20,
+                            "start_sec": 0.0,
+                            "mid_sec": 0.3,
+                            "end_sec": 0.7,
+                        }
+                    ],
+                    "partial_reps": [],
+                },
+            )
+            _write_json(
+                run_dir / "rep_analysis.json",
+                {
+                    "exercise": "push_up",
+                    "items": [
+                        {
+                            "rep_id": 1,
+                            "duration_sec": 0.7,
+                            "range_of_motion_score": 0.8,
+                            "stability_score": 0.82,
+                            "symmetry_score": 0.84,
+                            "metrics": {"body_line_score": 0.79},
+                            "variation_hints": ["wide_grip_push_up"],
+                        }
+                    ],
+                    "aggregate_metrics": {"pose_valid_ratio": 0.93},
+                },
+            )
+            _write_json(
+                run_dir / "variation.json",
+                {
+                    "exercise": "push_up",
+                    "detected_variation": "wide_grip_push_up",
+                    "variation_confidence": 0.77,
+                    "not_issues": ["wide_hand_placement"],
+                },
+            )
+            _write_json(
+                run_dir / "issue_markers.json",
+                {
+                    "issues": [
+                        {
+                            "rep_id": 1,
+                            "issue": "hip_sag",
+                            "severity": 0.8,
+                            "start_frame": 10,
+                            "end_frame": 16,
+                            "start_sec": 0.3,
+                            "end_sec": 0.53,
+                            "affected_joints": ["left_hip", "right_hip"],
+                            "evidence": {"body_line_score": 0.61},
+                        }
+                    ]
+                },
+            )
+            _write_json(
+                run_dir / "coach_summary.json",
+                {
+                    "summary": "Example grounded summary.",
+                    "what_you_did": ["You completed 1 `push_up` rep."],
+                    "what_looked_good": ["The setup looked organized."],
+                    "what_changed_across_reps": ["Not enough reps for a strong trend."],
+                    "valid_variation_vs_issue": [
+                        "The detected variation was `wide_grip_push_up` and `wide_hand_placement` stayed context only."
+                    ],
+                    "top_fixes": ["Keep shoulders, hips, and ankles moving as one line."],
+                    "next_session_plan": ["Repeat the set with the same setup."],
+                    "confidence_notes": ["Confidence is moderate."],
+                },
+            )
+
+            row = build_sft_row_from_run_dir(run_dir)
+
+        self.assertEqual(len(row["messages"]), 3)
+        self.assertEqual(row["messages"][0]["role"], "system")
+        self.assertIn("knowledge_cards", row["messages"][1]["content"])
+        self.assertIn("Example grounded summary.", row["messages"][2]["content"])
+        self.assertEqual(row["metadata"]["exercise"], "push_up")
+
+    def test_collect_split_and_write_jsonl(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            runs_dir = Path(temp_dir) / "runs"
+            runs_dir.mkdir()
+            for index in range(2):
+                run_dir = runs_dir / f"run-{index:03d}"
+                run_dir.mkdir()
+                for filename in [
+                    "user_profile.json",
+                    "exercise_classification.json",
+                    "reps.json",
+                    "rep_analysis.json",
+                    "variation.json",
+                    "issue_markers.json",
+                    "coach_summary.json",
+                ]:
+                    _write_json(run_dir / filename, {})
+            collected = collect_run_dirs(runs_dir)
+            train_rows, eval_rows = split_sft_rows(
+                [{"id": 1}, {"id": 2}, {"id": 3}],
+                eval_count=1,
+                seed=5,
+            )
+            output_path = Path(temp_dir) / "dataset.jsonl"
+            write_jsonl(output_path, train_rows)
+
+            written_lines = output_path.read_text(encoding="utf-8").splitlines()
+
+        self.assertEqual(len(collected), 2)
+        self.assertEqual(len(eval_rows), 1)
+        self.assertEqual(len(train_rows), 2)
+        self.assertEqual(len(written_lines), 2)
+
+
+if __name__ == "__main__":
+    unittest.main()