Merge branch 'main' of https://github.com/CSID-DGU/2026-1-CECD2-1-Deepgu-06

Author: calmkeep22

.gitignore

@@ -19,9 +19,12 @@ __pycache__/
 AI/ai_pipeline/videos/
 AI/ai_pipeline/data/
 AI/ai_pipeline/outputs/
+AI/ai_pipeline/bigru_frame_selector/outputs/
+*.npy
 PGL-SUM/data/
 PGL-SUM/Summaries/
 storage/
+*.csv
 
 # 영상 파일
 *.mp4
@@ -40,8 +43,12 @@ storage/
 !**/LICENSE.md
 CLAUDE.md
 
-# 발표 초안
-MIDTERM_PRESENTATION*.txt
+# 작업 메모/발표자료 텍스트 (requirements.txt, robots.txt 제외)
+*.txt
+!requirements.txt
+!**/requirements.txt
+!robots.txt
+!**/robots.txt
 
 # OS
 # frontend

AI/ai_pipeline/pipeline/candidate_selector.py

@@ -0,0 +1,28 @@
+def select_candidates(results, thresholds, verbose=True):
+    candidates = []
+    fight_threshold = thresholds["fight_candidate"]
+    fall_threshold = thresholds.get("fall_candidate")
+
+    for result in results:
+        fight_score = result["scores"]["fight_candidate_score"]
+        fall_score = result["scores"].get("fall_candidate_score")
+
+        candidate_types = []
+        if fight_score >= fight_threshold:
+            candidate_types.append("fight")
+        if fall_threshold is not None and fall_score is not None and fall_score >= fall_threshold:
+            candidate_types.append("fall")
+
+        if not candidate_types:
+            continue
+
+        result["candidate_types"] = candidate_types
+        if fall_score is None:
+            result["candidate_score"] = fight_score
+        else:
+            result["candidate_score"] = max(fight_score, fall_score)
+        candidates.append(result)
+
+    if verbose:
+        print(f" candidate clip 개수: {len(candidates)} / {len(results)}")
+    return candidates

AI/ai_pipeline/pipeline/event_merger.py

@@ -0,0 +1,56 @@
+from utils.video import clip_frame_span, frames_to_seconds
+
+
+def merge_candidate_events(candidates, clip_length, stride, fps, max_gap=1):
+    if not candidates:
+        return []
+
+    candidates = sorted(candidates, key=lambda item: item["clip_id"])
+    events = []
+    current_event = None
+
+    for candidate in candidates:
+        clip_id = candidate["clip_id"]
+        start_frame, end_frame = clip_frame_span(clip_id, clip_length, stride)
+        label = candidate["vlm_output"]["label"]
+
+        if label in {"normal", "uncertain"}:
+            continue
+
+        if (
+            current_event is None or
+            current_event["label"] != label or
+            clip_id - current_event["last_clip_id"] > max_gap
+        ):
+            if current_event is not None:
+                events.append(current_event)
+
+            current_event = {
+                "event_id": len(events),
+                "label": label,
+                "start_frame": start_frame,
+                "end_frame": end_frame,
+                "confidence": candidate["vlm_output"]["confidence"],
+                "evidence": candidate["vlm_output"]["evidence"],
+                "clip_ids": [clip_id],
+                "last_clip_id": clip_id
+            }
+            continue
+
+        current_event["end_frame"] = end_frame
+        current_event["clip_ids"].append(clip_id)
+        current_event["last_clip_id"] = clip_id
+        current_event["confidence"] = max(
+            current_event["confidence"],
+            candidate["vlm_output"]["confidence"]
+        )
+
+    if current_event is not None:
+        events.append(current_event)
+
+    for event in events:
+        event["start_time"] = frames_to_seconds(event["start_frame"], fps)
+        event["end_time"] = frames_to_seconds(event["end_frame"] + 1, fps)
+        event.pop("last_clip_id", None)
+
+    return events

AI/ai_pipeline/pipeline/filter.py

@@ -0,0 +1,16 @@
+def filter_clips(results, threshold=0.4):
+    """
+    results: main_pipeline 결과 리스트
+    """
+
+    candidates = []
+
+    for r in results:
+        score = r["scores"]["final_score"]
+
+        if score > threshold:
+            candidates.append(r)
+
+    print(f" candidate clip 개수: {len(candidates)} / {len(results)}")
+
+    return candidates

AI/ai_pipeline/pipeline/frame_sampler.py

@@ -0,0 +1,34 @@
+import numpy as np
+
+
+def sample_uniform_plus_center(clip_frames, num_samples=6):
+    total_frames = len(clip_frames)
+
+    if total_frames <= num_samples:
+        return clip_frames
+
+    base_count = max(2, num_samples - 2)
+    uniform_indices = np.linspace(0, total_frames - 1, base_count).astype(int).tolist()
+
+    center = total_frames // 2
+    extra_indices = [max(0, center - 1), min(total_frames - 1, center + 1)]
+    indices = sorted(set(uniform_indices + extra_indices))
+
+    if len(indices) > num_samples:
+        indices = indices[:num_samples]
+
+    return [clip_frames[i] for i in indices]
+
+
+def sample_from_candidates(candidates, num_samples=6, strategy="uniform_plus_center"):
+    for candidate in candidates:
+        clip = candidate["clip"]
+
+        if strategy == "uniform_plus_center":
+            sampled = sample_uniform_plus_center(clip, num_samples=num_samples)
+        else:
+            sampled = sample_uniform_plus_center(clip, num_samples=num_samples)
+
+        candidate["sampled_frames"] = sampled
+
+    return candidates

AI/ai_pipeline/pipeline/result_writer.py

@@ -0,0 +1,18 @@
+import json
+from pathlib import Path
+
+from utils.paths import ensure_dir
+
+
+def write_results(results_path, payload):
+    results_path = Path(results_path)
+    ensure_dir(results_path.parent)
+    with open(results_path, "w", encoding="utf-8") as f:
+        json.dump(payload, f, indent=2, ensure_ascii=False)
+
+
+def write_debug(debug_dir, clip_results):
+    debug_dir = ensure_dir(debug_dir)
+    debug_path = debug_dir / "clip_results.json"
+    with open(debug_path, "w", encoding="utf-8") as f:
+        json.dump(clip_results, f, indent=2, ensure_ascii=False)

AI/ai_pipeline/pipeline/scorer.py

@@ -0,0 +1,39 @@
+import torch
+
+FIGHT_IDX = [259, 314, 345, 395]
+ATTACK_IDX = [150, 152, 302]
+FALL_IDX = [122]
+ABNORMAL_IDX = [79, 149]
+
+
+def compute_scores(probs):
+
+    if isinstance(probs, torch.Tensor):
+        probs = probs.tolist()
+
+    # score 계산
+    fight_score = sum(probs[i] for i in FIGHT_IDX if i < len(probs))
+    attack_score = sum(probs[i] for i in ATTACK_IDX if i < len(probs))
+    fall_score = sum(probs[i] for i in FALL_IDX if i < len(probs))
+    abnormal_score = sum(probs[i] for i in ABNORMAL_IDX if i < len(probs))
+
+    # uncertainty
+    max_prob = max(probs)
+    uncertainty_score = 1 - max_prob
+
+    # final score
+    final_score = (
+        0.5 * uncertainty_score +
+        0.3 * fight_score +
+        0.1 * attack_score +
+        0.1 * fall_score
+    )
+
+    return {
+        "final_score": final_score,
+        "uncertainty": uncertainty_score,
+        "fight": fight_score,
+        "attack": attack_score,
+        "fall": fall_score,
+        "abnormal": abnormal_score
+    }

AI/ai_pipeline/scripts/inspect_results.py

@@ -0,0 +1,63 @@
+import argparse
+import json
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Inspect pipeline output JSON.")
+    parser.add_argument(
+        "--results-path",
+        default="/home/deepgu/test/outputs/results.json",
+        help="Path to results.json."
+    )
+    parser.add_argument(
+        "--top-k",
+        type=int,
+        default=10,
+        help="Number of candidate clips to print."
+    )
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    with open(args.results_path, "r", encoding="utf-8") as f:
+        payload = json.load(f)
+
+    print(f"video_path: {payload.get('video_path')}")
+    print(f"num_total_clips: {payload.get('num_total_clips')}")
+    print(f"num_candidate_clips: {payload.get('num_candidate_clips')}")
+    print(f"num_events: {len(payload.get('events', []))}")
+    print("=" * 60)
+
+    for event in payload.get("events", []):
+        print(
+            f"event_id={event['event_id']} "
+            f"label={event['label']} "
+            f"time=({event['start_time']:.2f}s ~ {event['end_time']:.2f}s) "
+            f"confidence={event['confidence']:.2f}"
+        )
+        print(f"evidence={event['evidence']}")
+        print("-" * 60)
+
+    print("Top candidate clips")
+    print("=" * 60)
+
+    candidate_clips = sorted(
+        payload.get("candidate_clips", []),
+        key=lambda item: item.get("candidate_score", 0.0),
+        reverse=True
+    )
+
+    for candidate in candidate_clips[:args.top_k]:
+        print(
+            f"clip_id={candidate['clip_id']} "
+            f"types={candidate['candidate_types']} "
+            f"candidate_score={candidate['candidate_score']:.4f} "
+            f"vlm_label={candidate['vlm_output']['label']} "
+            f"vlm_confidence={candidate['vlm_output']['confidence']:.2f}"
+        )
+
+
+if __name__ == "__main__":
+    main()

AI/ai_pipeline/scripts/run_pipeline.py

@@ -0,0 +1,52 @@
+import argparse
+import json
+import sys
+from pathlib import Path
+
+
+ROOT = Path("/home/deepgu/test")
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from pipeline.main_pipeline import run_pipeline
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Run the fight anomaly pipeline.")
+    parser.add_argument(
+        "--video-path",
+        default="/home/deepgu/test/data/raw_videos/Abuse007_x264.mp4",
+        help="Input video path."
+    )
+    parser.add_argument(
+        "--clip-dir",
+        default="/home/deepgu/test/data/clips",
+        help="Legacy all-clips directory. Ignored when outputs.root_dir is set in config."
+    )
+    parser.add_argument(
+        "--config-path",
+        default="/home/deepgu/test/configs/fight_pipeline_config.json",
+        help="Pipeline config path."
+    )
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+    results = run_pipeline(
+        video_path=args.video_path,
+        clip_dir=args.clip_dir,
+        config_path=args.config_path
+    )
+
+    print(json.dumps({
+        "video_path": results["video_path"],
+        "num_total_clips": results["num_total_clips"],
+        "num_candidate_clips": results["num_candidate_clips"],
+        "num_events": len(results["events"]),
+        "events": results["events"]
+    }, indent=2, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

AI/ai_pipeline/scripts/test_clip_generator.py

@@ -0,0 +1,22 @@
+import sys
+import os
+
+_AI_PIPELINE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+_KEYFRAME = os.path.normpath(os.path.join(_AI_PIPELINE, "../keyframe"))
+sys.path.insert(0, _AI_PIPELINE)
+sys.path.insert(0, _KEYFRAME)
+
+from pipeline.clip_generator import generate_clips
+
+video_path = "/home/deepgu/test/data/raw_videos/Abuse007_x264.mp4"
+output_dir = "/home/deepgu/test/data/clips"
+
+clips = generate_clips(
+    video_path=video_path,
+    output_dir=output_dir,
+    clip_len=16,
+    stride=8,
+    save=True
+)
+
+print(f"생성된 clip 개수: {len(clips)}")