Adding the pre-requisites

README.md

@@ -1,15 +1,26 @@
 ---
 title: SceneSolver
-emoji: 🦀
-colorFrom: red
-colorTo: gray
+author: samxkevin
 sdk: gradio
-sdk_version: 6.26.0
-python_version: '3.12'
+sdk_version: 5.49.1
 app_file: app.py
-pinned: false
 license: mit
-short_description: Multimodal Video Anomaly Detection & AI assistance
+short_description: Multimodal surveillance analysis and evidence synthesis
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# SceneSolver
+
+SceneSolver is a multimodal surveillance-analysis system. The public demo exposes the inference pipeline while the trained model assets remain in the author's Hugging Face repositories.
+
+## Pipeline
+
+AE anomaly signal → TimeSformer binary gate → TimeSformer multi-class classification → YOLO weapon detection → audio features → tracking/behavior extraction → fusion reasoning → RL3033 temporal reasoning → optional LLaVA contextual explanation.
+
+## Model sources
+
+- `samxkevin/scenesolver-assets`
+- `samxkevin/SceneDescriptionModel`
+
+## Notes
+
+The system is an experimental/research project. Results are not definitive conclusions and require human review.

app.py

@@ -0,0 +1,203 @@
+import json
+import os
+import traceback
+from functools import lru_cache
+
+import gradio as gr
+import spaces
+
+from scenesolver_core import SceneSolverPipeline, frame_to_timestamp
+
+APP_TITLE = "SceneSolver"
+APP_SUBTITLE = "Multimodal surveillance analysis and evidence synthesis"
+
+CSS = """
+:root {
+  --bg: #000000;
+  --panel: #0b0b0b;
+  --line: #222222;
+  --muted: #8a8a8a;
+  --text: #f2f2f2;
+  --accent: #ff8c00;
+}
+body, .gradio-container { background: var(--bg) !important; color: var(--text) !important; }
+.gradio-container { max-width: 1180px !important; }
+.ss-header { padding: 28px 0 18px; border-bottom: 1px solid var(--line); margin-bottom: 24px; }
+.ss-kicker { font: 700 12px/1.2 ui-monospace, SFMono-Regular, Menlo, monospace; letter-spacing: .16em; color: var(--accent); text-transform: uppercase; }
+.ss-title { font: 400 42px/1.1 Georgia, 'Times New Roman', serif; margin-top: 8px; }
+.ss-subtitle { color: var(--muted); font: 15px/1.6 Georgia, 'Times New Roman', serif; max-width: 780px; }
+.ss-note { color: #777; font: 12px/1.55 ui-monospace, SFMono-Regular, Menlo, monospace; }
+.ss-section { color: #ddd; font: 700 12px/1.2 ui-monospace, SFMono-Regular, Menlo, monospace; letter-spacing: .12em; text-transform: uppercase; margin: 18px 0 10px; }
+#result pre { max-height: 520px; overflow: auto; }
+footer { display: none !important; }
+"""
+
+@lru_cache(maxsize=1)
+def get_pipeline():
+    return SceneSolverPipeline()
+
+
+def _jsonable(value):
+    if hasattr(value, "tolist"):
+        return value.tolist()
+    if isinstance(value, dict):
+        return {str(k): _jsonable(v) for k, v in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_jsonable(v) for v in value]
+    try:
+        json.dumps(value)
+        return value
+    except TypeError:
+        return str(value)
+
+
+def _summary(results):
+    s0 = results.get("stage0") or {}
+    s1 = results.get("stage1") or {}
+    s2 = results.get("stage2") or {}
+    s3 = results.get("stage3") or {}
+    s4 = results.get("stage4") or {}
+    s5 = results.get("stage5") or {}
+    s6 = results.get("stage6") or {}
+    s7 = results.get("stage7") or {}
+    s8 = results.get("stage8") or {}
+    fps = float(s0.get("fps", 25.0))
+
+    def ts(idx):
+        return frame_to_timestamp(int(idx or 0), fps)
+
+    risk = float(s7.get("final_risk", s6.get("fused_risk", 0.0)))
+    data = {
+        "status": results.get("status", "UNKNOWN"),
+        "risk_level": results.get("risk_label_final", s6.get("risk_level", "LOW")),
+        "final_risk": risk,
+        "peak_timestamp": ts(s0.get("peak_frame_idx", 0)),
+        "anomaly_window": f"{ts(s0.get('anomaly_start_frame', 0))} -> {ts(s0.get('anomaly_end_frame', 0))}",
+        "timeformer_binary": {
+            "classification": s1.get("classification", "Unknown"),
+            "confidence": float(s1.get("confidence", 0.0)),
+        },
+        "anomaly_class": {
+            "class": s2.get("class", "Skipped"),
+            "confidence": float(s2.get("confidence", 0.0)),
+            "top3": s2.get("top3", []),
+        },
+        "weapon": {
+            "detected": bool(s3.get("weapon_flag", False)),
+            "dominant_class": s3.get("dominant_class", "None"),
+            "count": int(s3.get("weapon_count", 0)),
+        },
+        "audio": {
+            "status": s4.get("status", "N/A"),
+            "score": float(s4.get("audio_score", 0.0)),
+        },
+        "motion": {
+            "intensity": float(s5.get("motion_intensity", 0.0)),
+            "behaviors": s5.get("behaviors", []),
+        },
+        "fusion": {
+            "risk": float(s6.get("fused_risk", 0.0)),
+            "level": s6.get("risk_level", "LOW"),
+            "reasoning": s6.get("reasoning_trace", []),
+        },
+        "rl3033": {
+            "risk": float(s7.get("final_risk", risk)),
+            "status": s7.get("status", ""),
+            "interpretation": s7.get("interpretation", ""),
+        },
+        "llava": {
+            "narrative": s8.get("unified_narrative") or s8.get("description", "")
+        } if s8 else None,
+    }
+    return data
+
+
+@spaces.GPU
+
+def analyze_video(video_path, include_llava):
+    if not video_path:
+        raise gr.Error("Please upload a video first.")
+    try:
+        pipeline = get_pipeline()
+        results = pipeline.analyze(
+            video_path=video_path,
+            base_output_dir="/tmp/scenesolver_space",
+            enable_llava=bool(include_llava),
+            enable_rl=True,
+            enable_tracking=True,
+        )
+        summary = _summary(results)
+        top_frame = None
+        s0 = results.get("stage0") or {}
+        frames = s0.get("frames") or []
+        indices = s0.get("sampled_indices") or []
+        if frames and indices:
+            peak_idx = int(s0.get("peak_score_idx", 0))
+            frame_idx = indices[min(peak_idx, len(indices) - 1)]
+            frame_idx = min(int(frame_idx), len(frames) - 1)
+            top_frame = frames[frame_idx]
+
+        pdf_path = results.get("pdf_path_local") or results.get("pdf_path")
+        if not pdf_path or not os.path.exists(pdf_path):
+            pdf_path = None
+
+        return (
+            summary,
+            top_frame,
+            json.dumps(_jsonable(summary), indent=2),
+            pdf_path,
+        )
+    except Exception as exc:
+        traceback.print_exc()
+        raise gr.Error(f"Analysis failed: {exc}")
+
+
+with gr.Blocks(title=APP_TITLE, css=CSS, theme=gr.themes.Base()) as demo:
+    gr.HTML(f"""
+    <div class='ss-header'>
+      <div class='ss-kicker'>Scene Solver v3</div>
+      <div class='ss-title'>{APP_TITLE}</div>
+      <div class='ss-subtitle'>{APP_SUBTITLE}. The pipeline combines anomaly detection,
+      temporal video understanding, weapon detection, audio and motion signals,
+      rule-based fusion, temporal reasoning, and optional multimodal explanation.</div>
+      <div class='ss-note'>This is a research/demo system. ML outputs are investigative aids and require human review.</div>
+    </div>
+    """)
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.HTML("<div class='ss-section'>Input</div>")
+            video = gr.Video(label="CCTV / surveillance video", sources=["upload"], height=280)
+            include_llava = gr.Checkbox(
+                value=False,
+                label="Enable LLaVA contextual explanation",
+                info="Adds the final multimodal narrative stage and may take substantially longer.",
+            )
+            analyse = gr.Button("Analyse Footage", variant="primary")
+            gr.Markdown(
+                "**Pipeline:** AE → TimeSformer Binary → TimeSformer Multi-class → YOLO → Audio → Tracking → Fusion → RL3033 → optional LLaVA",
+                elem_classes=["ss-note"],
+            )
+
+        with gr.Column(scale=1):
+            gr.HTML("<div class='ss-section'>Assessment</div>")
+            result = gr.JSON(label="Structured result", elem_id="result")
+            frame = gr.Image(label="Peak anomaly frame", interactive=False)
+            result_text = gr.Code(label="JSON export", language="json", interactive=False)
+            report = gr.File(label="Generated forensic PDF", interactive=False)
+
+    analyse.click(
+        fn=analyze_video,
+        inputs=[video, include_llava],
+        outputs=[result, frame, result_text, report],
+        api_name="analyze",
+        queue=True,
+    )
+
+    gr.Markdown(
+        "Public demo derived from the SceneSolver project. Model checkpoints are loaded from the author's public Hugging Face repositories.",
+        elem_classes=["ss-note"],
+    )
+
+if __name__ == "__main__":
+    demo.queue(max_size=2).launch()

requirements.txt

@@ -0,0 +1,20 @@
+gradio>=5.0,<6.0
+spaces>=0.38.0
+huggingface_hub>=0.34.0
+numpy
+opencv-python-headless
+torch
+torchvision
+transformers>=4.45
+accelerate
+safetensors
+Pillow
+tqdm
+matplotlib
+reportlab
+stable-baselines3
+ultralytics
+lap
+librosa
+openai-whisper
+cohere>=5.0.0