experiment/ucn/two-lines-detection

.gitignore

@@ -10,4 +10,16 @@ __pycache__/
 .env
 raspi/result/prediction_visual.png
 *.pt
-.venv/
+.venv/
+
+# 2ライン検知システムの出力ファイル
+data
+
+# ドキュメント
+docs/
+docs/*
+!raspi/line_detection/docs/
+!raspi/line_detection/docs/wandb_integration_spec_v2.md
+
+# ローカルディレクトリ
+**/*.local

pyproject.toml

@@ -4,4 +4,25 @@ version = "0.1.0"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12"
-dependencies = []
+dependencies = [
+    # YOLOv8とトラッキング
+    "ultralytics==8.4.72",
+    # 動画処理
+    "opencv-python>=4.8.1",
+    # 設定管理
+    "python-dotenv>=1.0.0",
+    # 数値演算
+    "numpy>=1.24.4,<2.0",
+    # 深層学習バックエンド
+    "torch>=2.2.2",
+    "torchvision>=0.17.2",
+    # データ処理
+    "pandas>=2.2.1",
+    "lap>=0.5.13",
+    "wandb>=0.28.0",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.1.1",
+]

raspi/common/event_matching.py

@@ -0,0 +1,125 @@
+"""GTと予測イベントの突合、および精度指標の算出。"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Sequence
+
+
+@dataclass(frozen=True)
+class PredictedEvent:
+    """検出方式が出力した1件の予測イベント。"""
+
+    event_id: str
+    direction: str  # "IN" or "OUT"
+    t_sec: float
+
+
+@dataclass(frozen=True)
+class GtEvent:
+    """GTの1物理イベント。raspi.common.ground_truth.GtEvent と同型。"""
+
+    event_id: str
+    direction: str
+    t_sec: float
+
+
+@dataclass(frozen=True)
+class MatchResult:
+    tp: int
+    fp: int
+    fn: int
+    tp_in: int
+    fp_in: int
+    fn_in: int
+    tp_out: int
+    fp_out: int
+    fn_out: int
+    precision: float | None
+    recall: float | None
+    f1: float | None
+
+
+def _match_direction(
+    predicted: Sequence[PredictedEvent],
+    gt: Sequence[GtEvent],
+    direction: str,
+    tolerance_sec: float,
+) -> tuple[int, int, int]:
+    predicted_in_direction = [
+        (index, event) for index, event in enumerate(predicted) if event.direction == direction
+    ]
+    gt_in_direction = [
+        (index, event) for index, event in enumerate(gt) if event.direction == direction
+    ]
+
+    candidates = []
+    for predicted_index, predicted_event in predicted_in_direction:
+        for gt_index, gt_event in gt_in_direction:
+            time_difference = abs(predicted_event.t_sec - gt_event.t_sec)
+            if time_difference <= tolerance_sec:
+                candidates.append(
+                    (
+                        time_difference,
+                        gt_event.event_id,
+                        predicted_event.event_id,
+                        predicted_index,
+                        gt_index,
+                    )
+                )
+
+    candidates.sort()
+    consumed_predicted: set[int] = set()
+    consumed_gt: set[int] = set()
+    tp = 0
+
+    for _, _, _, predicted_index, gt_index in candidates:
+        if predicted_index in consumed_predicted or gt_index in consumed_gt:
+            continue
+        consumed_predicted.add(predicted_index)
+        consumed_gt.add(gt_index)
+        tp += 1
+
+    fp = len(predicted_in_direction) - tp
+    fn = len(gt_in_direction) - tp
+    return tp, fp, fn
+
+
+def match_events(
+    predicted: Sequence[PredictedEvent],
+    gt: Sequence[GtEvent],
+    tolerance_sec: float,
+) -> MatchResult:
+    """予測イベントを方向別にGTへ1対1で突合し、全体の指標を返す。"""
+
+    tp_in, fp_in, fn_in = _match_direction(predicted, gt, "IN", tolerance_sec)
+    tp_out, fp_out, fn_out = _match_direction(predicted, gt, "OUT", tolerance_sec)
+
+    tp = tp_in + tp_out
+    fp = fp_in + fp_out
+    fn = fn_in + fn_out
+
+    precision = tp / (tp + fp) if tp + fp > 0 else None
+    recall = tp / (tp + fn) if tp + fn > 0 else None
+
+    if precision is None and recall is None:
+        f1 = None
+    elif precision is None or recall is None or precision + recall == 0:
+        f1 = 0.0
+    else:
+        f1 = 2 * precision * recall / (precision + recall)
+
+    return MatchResult(
+        tp=tp,
+        fp=fp,
+        fn=fn,
+        tp_in=tp_in,
+        fp_in=fp_in,
+        fn_in=fn_in,
+        tp_out=tp_out,
+        fp_out=fp_out,
+        fn_out=fn_out,
+        precision=precision,
+        recall=recall,
+        f1=f1,
+    )

raspi/common/frame_stats.py

@@ -0,0 +1,130 @@
+"""
+フレーム処理時間の統計ユーティリティ（両検出ロジック共通）
+
+W&B の summary に入れる速度指標（p95 / effective_fps / realtime_ok 等）を
+1 フレームごとの処理時間リストから算出する。
+"""
+
+from typing import Any, Dict, List, Sequence
+
+import numpy as np
+
+
+STAT_SUFFIXES = ("min", "max", "mean", "p50", "p95", "p99", "total")
+
+
+def compute_series_stats(values: Sequence[float], prefix: str) -> Dict[str, float]:
+    """任意のミリ秒系列を、指定した prefix の統計キーへ展開する。"""
+
+    if not values:
+        return {f"{prefix}_{suffix}": 0.0 for suffix in STAT_SUFFIXES}
+
+    arr = np.asarray(values, dtype=float)
+    return {
+        f"{prefix}_min": float(arr.min()),
+        f"{prefix}_max": float(arr.max()),
+        f"{prefix}_mean": float(arr.mean()),
+        f"{prefix}_p50": float(np.percentile(arr, 50)),
+        f"{prefix}_p95": float(np.percentile(arr, 95)),
+        f"{prefix}_p99": float(np.percentile(arr, 99)),
+        f"{prefix}_total": float(arr.sum()),
+    }
+
+
+def _timing_value(record: Any, key: str) -> float:
+    if isinstance(record, dict):
+        return float(record[key])
+    return float(getattr(record, key))
+
+
+def compute_timing_stats(records: Sequence[Any], source_fps: float) -> Dict[str, Any]:
+    """timing schema v2 のフェーズ別統計とリアルタイム指標を算出する。"""
+
+    phase_names = (
+        "read_ms",
+        "inference_tracking_ms",
+        "counting_logic_ms",
+        "core_ms",
+        "output_ms",
+        "end_to_end_ms",
+    )
+    stats: Dict[str, Any] = {}
+    for phase in phase_names:
+        stats.update(compute_series_stats([_timing_value(r, phase) for r in records], phase))
+
+    core_mean = stats["core_ms_mean"]
+    end_to_end_mean = stats["end_to_end_ms_mean"]
+    stats["core_effective_fps"] = 1000.0 / core_mean if core_mean > 0 else 0.0
+    stats["end_to_end_effective_fps"] = (
+        1000.0 / end_to_end_mean if end_to_end_mean > 0 else 0.0
+    )
+
+    budget_ms = 1000.0 / source_fps if source_fps > 0 else 0.0
+    miss_count = (
+        sum(_timing_value(r, "end_to_end_ms") > budget_ms for r in records)
+        if budget_ms > 0
+        else 0
+    )
+    stats["frame_budget_ms"] = budget_ms
+    stats["deadline_miss_count"] = int(miss_count)
+    stats["deadline_miss_rate"] = float(miss_count / len(records)) if records else 0.0
+    stats["core_realtime_ok"] = (
+        bool(stats["core_effective_fps"] >= source_fps) if source_fps > 0 else False
+    )
+    stats["end_to_end_realtime_ok"] = (
+        bool(records and source_fps > 0 and miss_count == 0)
+    )
+
+    # timing schema v1 互換。新しい比較・リアルタイム判定には上記の明示名を使う。
+    for suffix in STAT_SUFFIXES:
+        stats[f"frame_ms_{suffix}"] = stats[f"core_ms_{suffix}"]
+    stats["total_ms"] = stats["core_ms_total"]
+    stats["effective_fps"] = stats["core_effective_fps"]
+    stats["realtime_ok"] = stats["core_realtime_ok"]
+    return stats
+
+
+def compute_frame_stats(frame_ms_list: List[float], source_fps: float) -> Dict:
+    """
+    フレーム処理時間リストから速度統計を算出する。
+
+    Args:
+        frame_ms_list: 1 フレームあたりの処理時間（ミリ秒）のリスト
+        source_fps: 入力動画の FPS（realtime 判定の基準）
+
+    Returns:
+        dict: 速度統計。空リスト時は全て 0 / realtime_ok=False を返し例外を出さない。
+            - frame_ms_min / frame_ms_max / frame_ms_mean
+            - frame_ms_p50 / frame_ms_p95 / frame_ms_p99
+            - total_ms
+            - effective_fps (= 1000 / frame_ms_mean)
+            - realtime_ok (= effective_fps >= source_fps)
+    """
+    if not frame_ms_list:
+        return {
+            "frame_ms_min": 0.0,
+            "frame_ms_max": 0.0,
+            "frame_ms_mean": 0.0,
+            "frame_ms_p50": 0.0,
+            "frame_ms_p95": 0.0,
+            "frame_ms_p99": 0.0,
+            "total_ms": 0.0,
+            "effective_fps": 0.0,
+            "realtime_ok": False,
+        }
+
+    arr = np.asarray(frame_ms_list, dtype=float)
+    mean = float(arr.mean())
+    effective_fps = 1000.0 / mean if mean > 0 else 0.0
+
+    return {
+        "frame_ms_min": float(arr.min()),
+        "frame_ms_max": float(arr.max()),
+        "frame_ms_mean": mean,
+        "frame_ms_p50": float(np.percentile(arr, 50)),
+        "frame_ms_p95": float(np.percentile(arr, 95)),
+        "frame_ms_p99": float(np.percentile(arr, 99)),
+        "total_ms": float(arr.sum()),
+        "effective_fps": effective_fps,
+        "realtime_ok": bool(effective_fps >= source_fps) if source_fps > 0 else False,
+    }