Update app to use mounted bucket at /data, add league stats to Compare tab

- Read data from /data (HF bucket mount) when available, fallback to ./data
- Add xG/PPDA/form comparison in Compare Teams tab
- Add league stats to VLM prediction context
- Remove bundled data files (now served from bucket)
- Add openai, pillow, numpy to requirements

app.py

@@ -4,16 +4,34 @@ Gradio app displaying pre-computed Qwen-VL 72B tactical assessments
 of UEFA Champions League matches on AMD MI300X.
 """
 
+import base64
 import json
+import os
 from pathlib import Path
 
 import gradio as gr
 import plotly.graph_objects as go
 
 APP_DIR = Path(__file__).resolve().parent
-RESULTS_PATH = APP_DIR / "data" / "vlm_results" / "results.json"
-DEMO_PATH = APP_DIR / "data" / "demo_matches.json"
-FRAMES_DIR = APP_DIR / "data" / "vlm_results" / "frames"
+
+# When running on HF Spaces with a mounted bucket, use /data directly
+HF_BUCKET_MOUNT = Path("/data")
+if HF_BUCKET_MOUNT.exists() and HF_BUCKET_MOUNT.is_dir():
+    DATA_DIR = HF_BUCKET_MOUNT
+else:
+    DATA_DIR = APP_DIR / "data"
+
+RESULTS_PATH = DATA_DIR / "vlm_results" / "results.json"
+DEMO_PATH = DATA_DIR / "demo_matches.json"
+FRAMES_DIR = DATA_DIR / "vlm_results" / "frames"
+CLIPS_DIR = DATA_DIR / "vlm_results" / "clips"
+INDEX_PATH = DATA_DIR / "frames_index.json"
+ALL_FRAMES_DIR = DATA_DIR / "frames"
+MATCH_STATS_PATH = DATA_DIR / "match_stats.json"
+
+VLM_BASE_URL = os.environ.get("VLM_BASE_URL", "")
+VLM_MODEL = os.environ.get("VLM_MODEL", "Qwen/Qwen2.5-VL-72B-Instruct")
+VLM_API_KEY = os.environ.get("VLM_API_KEY", "EMPTY")
 
 
 def load_results():
@@ -22,11 +40,30 @@ def load_results():
     with open(DEMO_PATH) as f:
         demos = json.load(f)
     demo_lookup = {d["match_id"]: d for d in demos}
+
+    # Load league stats for all teams
+    team_stats = {}
+    if MATCH_STATS_PATH.exists():
+        with open(MATCH_STATS_PATH) as f:
+            ms = json.load(f)
+        team_stats = ms.get("team_stats", {})
+
     for m in results["matches"]:
         demo = demo_lookup.get(m["match_id"], {})
         m["first_leg"] = demo.get("first_leg", "")
         m["odds"] = demo.get("odds", {})
         m["narrative"] = demo.get("narrative", "")
+        # Inject team stats if not already present
+        if not m.get("stats"):
+            home = m["home_team"]
+            away = m["away_team"]
+            stats = {}
+            if home in team_stats:
+                stats["home"] = {"team": home, **team_stats[home]}
+            if away in team_stats:
+                stats["away"] = {"team": away, **team_stats[away]}
+            if stats:
+                m["stats"] = stats
     return results
 
 
@@ -99,6 +136,145 @@ def make_prob_chart(match):
     return fig
 
 
+def make_formation_plot(match):
+    """Generate a pitch plot showing player positions from tactical keyframes."""
+    import numpy as np
+
+    home_team = match["home_team"]
+    away_team = match["away_team"]
+    match_id = match["match_id"]
+
+    # Find detection data
+    det_path = ALL_FRAMES_DIR / match_id / "detections.json"
+    if not det_path.exists():
+        # Try finding from metrics_context
+        ctx = match.get("metrics_context", {})
+        for side in ["home", "away"]:
+            analyzed = ctx.get(side, {}).get("matches_analyzed", [])
+            for m in analyzed:
+                p = ALL_FRAMES_DIR / m / "detections.json"
+                if p.exists():
+                    det_path = p
+                    break
+            if det_path.exists():
+                break
+
+    if not det_path.exists():
+        return None
+
+    import json as _json
+    with open(det_path) as f:
+        detections = _json.load(f)
+
+    tactical = detections.get("tactical_keyframes", [])
+    if not tactical:
+        return None
+
+    # Use the first tactical keyframe (most players visible)
+    best_frame = None
+    best_count = 0
+    for kf_name in tactical:
+        kf_data = detections["keyframes"].get(kf_name, {})
+        count = len(kf_data.get("players", []))
+        if count > best_count:
+            best_count = count
+            best_frame = kf_name
+            best_data = kf_data
+
+    if best_frame is None or best_count < 8:
+        return None
+
+    players = best_data["players"]
+    centers = []
+    for p in players:
+        bbox = p["bbox"]
+        cx = (bbox[0] + bbox[2]) / 2
+        cy = (bbox[1] + bbox[3]) / 2
+        centers.append([cx, cy])
+
+    centers = np.array(centers)
+
+    # Normalize to pitch coordinates (0-105 x 0-68)
+    x_min, x_max = centers[:, 0].min(), centers[:, 0].max()
+    y_min, y_max = centers[:, 1].min(), centers[:, 1].max()
+    x_range = x_max - x_min if x_max - x_min > 0 else 1
+    y_range = y_max - y_min if y_max - y_min > 0 else 1
+
+    pitch_x = (centers[:, 0] - x_min) / x_range * 100 + 2.5
+    pitch_y = (centers[:, 1] - y_min) / y_range * 64 + 2
+
+    # KMeans to split into two teams
+    from sklearn.cluster import KMeans
+    kmeans = KMeans(n_clusters=2, random_state=0, n_init=10).fit(centers)
+    labels = kmeans.labels_
+
+    # Left cluster = home, right = away
+    avg_x_0 = pitch_x[labels == 0].mean()
+    avg_x_1 = pitch_x[labels == 1].mean()
+    home_cluster = 0 if avg_x_0 < avg_x_1 else 1
+
+    home_x = pitch_x[labels == home_cluster]
+    home_y = pitch_y[labels == home_cluster]
+    away_x = pitch_x[labels != home_cluster]
+    away_y = pitch_y[labels != home_cluster]
+
+    # Build Plotly pitch figure
+    fig = go.Figure()
+
+    # Pitch outline
+    pitch_shapes = [
+        dict(type="rect", x0=0, y0=0, x1=105, y1=68, line=dict(color="#555", width=2)),
+        dict(type="line", x0=52.5, y0=0, x1=52.5, y1=68, line=dict(color="#555", width=1)),
+        dict(type="circle", x0=52.5-9.15, y0=34-9.15, x1=52.5+9.15, y1=34+9.15, line=dict(color="#555", width=1)),
+        # Penalty areas
+        dict(type="rect", x0=0, y0=13.84, x1=16.5, y1=54.16, line=dict(color="#555", width=1)),
+        dict(type="rect", x0=88.5, y0=13.84, x1=105, y1=54.16, line=dict(color="#555", width=1)),
+        # Goal areas
+        dict(type="rect", x0=0, y0=24.84, x1=5.5, y1=43.16, line=dict(color="#555", width=1)),
+        dict(type="rect", x0=99.5, y0=24.84, x1=105, y1=43.16, line=dict(color="#555", width=1)),
+    ]
+
+    fig.add_trace(go.Scatter(
+        x=home_x, y=home_y, mode="markers",
+        marker=dict(size=14, color="#3b82f6", line=dict(width=2, color="white")),
+        name=home_team,
+    ))
+    fig.add_trace(go.Scatter(
+        x=away_x, y=away_y, mode="markers",
+        marker=dict(size=14, color="#ef4444", line=dict(width=2, color="white")),
+        name=away_team,
+    ))
+
+    # Ball position
+    ball = best_data.get("ball")
+    if ball:
+        ball_cx = (ball["bbox"][0] + ball["bbox"][2]) / 2
+        ball_cy = (ball["bbox"][1] + ball["bbox"][3]) / 2
+        ball_px = (ball_cx - x_min) / x_range * 100 + 2.5
+        ball_py = (ball_cy - y_min) / y_range * 64 + 2
+        fig.add_trace(go.Scatter(
+            x=[ball_px], y=[ball_py], mode="markers",
+            marker=dict(size=10, color="#fbbf24", symbol="circle",
+                        line=dict(width=2, color="white")),
+            name="Ball",
+        ))
+
+    fig.update_layout(
+        plot_bgcolor="#1a1a1a",
+        paper_bgcolor="#111111",
+        font_color="white",
+        shapes=pitch_shapes,
+        xaxis=dict(range=[-2, 107], showgrid=False, zeroline=False, showticklabels=False),
+        yaxis=dict(range=[-2, 70], showgrid=False, zeroline=False, showticklabels=False, scaleanchor="x"),
+        margin=dict(l=10, r=10, t=40, b=10),
+        height=350,
+        title=dict(text=f"Formation — {best_frame}", font=dict(size=13)),
+        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1),
+    )
+
+    return fig
+
+
 def get_frame_images(match):
     images = []
     for fp in match.get("frames_used", []):
@@ -111,6 +287,281 @@ def get_frame_images(match):
     return images
 
 
+def get_match_clips(match):
+    """Get annotated video clips for a match's source matches."""
+    clips = []
+    for fp in match.get("frames_used", []):
+        parts = Path(fp).parts
+        if len(parts) >= 3:
+            match_dir = parts[2]
+            clip_dir = CLIPS_DIR / match_dir
+            if clip_dir.exists():
+                for mp4 in sorted(clip_dir.glob("*.mp4")):
+                    if str(mp4) not in clips:
+                        clips.append(str(mp4))
+    return clips
+
+
+def load_frame_index():
+    """Load the pre-built frame index for team comparison."""
+    if not INDEX_PATH.exists():
+        return {"teams": [], "matches": {}}
+    with open(INDEX_PATH) as f:
+        return json.load(f)
+
+
+FRAME_INDEX = load_frame_index()
+
+
+def get_team_list():
+    """Return sorted list of team names formatted for display."""
+    return [t.replace("_", " ") for t in FRAME_INDEX.get("teams", [])]
+
+
+def get_team_form(team: str, n: int = 3) -> tuple[list[str], dict]:
+    """Get last N matches for a team: frames + averaged metrics."""
+    team_pat = team.replace(" ", "_")
+    team_matches = []
+    for match_name, data in FRAME_INDEX.get("matches", {}).items():
+        if team_pat in (data["home"], data["away"]):
+            team_matches.append((match_name, data))
+
+    team_matches.sort(key=lambda x: x[1]["date"], reverse=True)
+    team_matches = team_matches[:n]
+
+    frames = []
+    metrics_list = []
+    for match_name, data in team_matches:
+        ann_dir = ALL_FRAMES_DIR / match_name / "annotated"
+        for fname in data["frames"][:2]:
+            fpath = ann_dir / fname
+            if fpath.exists():
+                frames.append(str(fpath))
+        if data.get("metrics"):
+            metrics_list.append(data["metrics"])
+
+    avg_metrics = {}
+    if metrics_list:
+        keys = ["avg_pressing_speed", "avg_def_line_movement", "avg_compactness_delta", "avg_transition_speed"]
+        for key in keys:
+            values = [m[key] for m in metrics_list if key in m]
+            if values:
+                avg_metrics[key] = round(sum(values) / len(values), 4)
+
+    return frames, avg_metrics
+
+
+def get_h2h(team_a: str, team_b: str) -> tuple[list[str], dict]:
+    """Get head-to-head frames and metrics between two teams."""
+    pat_a = team_a.replace(" ", "_")
+    pat_b = team_b.replace(" ", "_")
+    h2h_matches = []
+
+    for match_name, data in FRAME_INDEX.get("matches", {}).items():
+        if pat_a in (data["home"], data["away"]) and pat_b in (data["home"], data["away"]):
+            h2h_matches.append((match_name, data))
+
+    h2h_matches.sort(key=lambda x: x[1]["date"], reverse=True)
+
+    frames = []
+    metrics_list = []
+    for match_name, data in h2h_matches[:3]:
+        ann_dir = ALL_FRAMES_DIR / match_name / "annotated"
+        for fname in data["frames"][:2]:
+            fpath = ann_dir / fname
+            if fpath.exists():
+                frames.append(str(fpath))
+        if data.get("metrics"):
+            metrics_list.append(data["metrics"])
+
+    avg_metrics = {}
+    if metrics_list:
+        keys = ["avg_pressing_speed", "avg_def_line_movement", "avg_compactness_delta", "avg_transition_speed"]
+        for key in keys:
+            values = [m[key] for m in metrics_list if key in m]
+            if values:
+                avg_metrics[key] = round(sum(values) / len(values), 4)
+
+    return frames, avg_metrics
+
+
+def format_metrics_md(metrics: dict, team_name: str) -> str:
+    """Format metrics dict as markdown."""
+    if not metrics:
+        return f"*No metrics available for {team_name}*"
+    lines = [f"**{team_name}** (avg last 3 matches):"]
+    labels = {
+        "avg_pressing_speed": "Pressing Speed",
+        "avg_def_line_movement": "Defensive Line Movement",
+        "avg_compactness_delta": "Compactness Delta",
+        "avg_transition_speed": "Transition Speed",
+    }
+    for key, label in labels.items():
+        if key in metrics:
+            lines.append(f"- {label}: `{metrics[key]:.4f}`")
+    return "\n".join(lines)
+
+
+def format_league_stats_compare(team_name: str, stats: dict) -> str:
+    """Format league stats for a team in the Compare tab."""
+    if not stats:
+        return f"**{team_name}**\n\n*No league stats available*"
+    lines = [f"**{team_name}**", ""]
+    lines.append("| Metric | Value |")
+    lines.append("|--------|-------|")
+    if stats.get("xg_last5") is not None:
+        lines.append(f"| xG — Expected Goals/match | {stats['xg_last5']} |")
+    if stats.get("xga_last5") is not None:
+        lines.append(f"| xGA — Expected Goals Against/match | {stats['xga_last5']} |")
+    if stats.get("ppda") is not None:
+        lines.append(f"| PPDA — Passes Per Defensive Action | {stats['ppda']} |")
+    if stats.get("possession_pct") is not None:
+        lines.append(f"| Possession | {stats['possession_pct']}% |")
+    if stats.get("form") is not None:
+        lines.append(f"| Form (last 5) | {stats['form']} |")
+    if stats.get("goals_scored_last5") is not None:
+        lines.append(f"| Goals (last 5) | {stats['goals_scored_last5']}F / {stats.get('goals_conceded_last5', '-')}A |")
+    return "\n".join(lines)
+
+
+def compare_teams(team_a: str, team_b: str):
+    """Main comparison function — returns all outputs for the Compare tab."""
+    if not team_a or not team_b:
+        empty = [], "", [], "", [], "", "", ""
+        return empty
+
+    frames_a, metrics_a = get_team_form(team_a)
+    frames_b, metrics_b = get_team_form(team_b)
+    h2h_frames, h2h_metrics = get_h2h(team_a, team_b)
+
+    metrics_a_md = format_metrics_md(metrics_a, team_a)
+    metrics_b_md = format_metrics_md(metrics_b, team_b)
+
+    if h2h_frames:
+        h2h_md = f"**{len(h2h_frames)//2} prior matchups found**\n\n" + format_metrics_md(h2h_metrics, f"{team_a} vs {team_b} H2H")
+    else:
+        h2h_md = f"*No head-to-head matches found between {team_a} and {team_b} in the dataset.*"
+
+    # League stats
+    league_stats = {}
+    if MATCH_STATS_PATH.exists():
+        with open(MATCH_STATS_PATH) as f:
+            ms = json.load(f)
+        league_stats = ms.get("team_stats", {})
+
+    stats_a_md = format_league_stats_compare(team_a, league_stats.get(team_a, {}))
+    stats_b_md = format_league_stats_compare(team_b, league_stats.get(team_b, {}))
+
+    return frames_a, metrics_a_md, frames_b, metrics_b_md, h2h_frames, h2h_md, stats_a_md, stats_b_md
+
+
+def predict_matchup(team_a: str, team_b: str):
+    """Run live VLM inference on a custom matchup."""
+    if not VLM_BASE_URL:
+        return "**GPU Offline** — Connect AMD MI300X to enable live predictions. Set `VLM_BASE_URL` as a Space secret."
+
+    if not team_a or not team_b or team_a == team_b:
+        return "Select two different teams to predict."
+
+    try:
+        from openai import OpenAI
+
+        # Load league stats for context
+        league_stats = {}
+        if MATCH_STATS_PATH.exists():
+            with open(MATCH_STATS_PATH) as f:
+                ms = json.load(f)
+            league_stats = ms.get("team_stats", {})
+
+        frames_a, metrics_a = get_team_form(team_a)
+        frames_b, metrics_b = get_team_form(team_b)
+        h2h_frames, h2h_metrics = get_h2h(team_a, team_b)
+
+        content = []
+        if frames_a:
+            content.append({"type": "text", "text": f"--- {team_a.upper()} RECENT FORM ---"})
+            for fp in frames_a[:4]:
+                b64 = encode_frame(fp)
+                if b64:
+                    content.append({"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{b64}"}})
+
+        if frames_b:
+            content.append({"type": "text", "text": f"--- {team_b.upper()} RECENT FORM ---"})
+            for fp in frames_b[:4]:
+                b64 = encode_frame(fp)
+                if b64:
+                    content.append({"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{b64}"}})
+
+        if h2h_frames:
+            content.append({"type": "text", "text": f"--- HEAD-TO-HEAD ---"})
+            for fp in h2h_frames[:4]:
+                b64 = encode_frame(fp)
+                if b64:
+                    content.append({"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{b64}"}})
+
+        context_lines = [
+            f"=== MATCHUP: {team_a} vs {team_b} ===",
+            f"\n{team_a} tactical metrics (last 3 matches):",
+        ]
+        for k, v in metrics_a.items():
+            context_lines.append(f"  {k}: {v}")
+        context_lines.append(f"\n{team_b} tactical metrics (last 3 matches):")
+        for k, v in metrics_b.items():
+            context_lines.append(f"  {k}: {v}")
+        if h2h_metrics:
+            context_lines.append(f"\nHead-to-head metrics:")
+            for k, v in h2h_metrics.items():
+                context_lines.append(f"  {k}: {v}")
+
+        # Add league stats (xG, PPDA, possession, form)
+        stat_labels = {
+            "xg_last5": "Expected Goals (xG, last 5)",
+            "xga_last5": "Expected Goals Against (xGA, last 5)",
+            "ppda": "Passes Per Defensive Action (PPDA)",
+            "possession_pct": "Possession %",
+            "form": "Recent Form (last 5)",
+            "goals_scored_last5": "Goals Scored (last 5)",
+            "goals_conceded_last5": "Goals Conceded (last 5)",
+        }
+        for team_name, team_key in [(team_a, team_a), (team_b, team_b)]:
+            if team_key in league_stats:
+                context_lines.append(f"\n{team_name} league statistics:")
+                for stat_key, label in stat_labels.items():
+                    val = league_stats[team_key].get(stat_key)
+                    if val is not None:
+                        context_lines.append(f"  {label}: {val}")
+
+        content.append({"type": "text", "text": "\n".join(context_lines)})
+        content.append({"type": "text", "text": (
+            f"Based on {team_a}'s recent form, {team_b}'s recent form, and their head-to-head history, "
+            f"which team has the tactical advantage? Provide your assessment as: "
+            f"probabilities (home/draw/away), confidence, and 2-3 sentence reasoning."
+        )})
+
+        system_msg = (
+            "You are a tactical football analyst. Analyze the annotated frames showing "
+            "player positions, defensive lines, and team compactness. Also consider the "
+            "league statistics (xG, PPDA, possession, form) to assess underlying quality. "
+            "Compare the tactical patterns and statistical profiles of both teams to assess "
+            "who has the advantage."
+        )
+
+        client = OpenAI(base_url=VLM_BASE_URL, api_key=VLM_API_KEY)
+        response = client.chat.completions.create(
+            model=VLM_MODEL,
+            messages=[
+                {"role": "system", "content": system_msg},
+                {"role": "user", "content": content},
+            ],
+            max_tokens=512,
+            temperature=0.3,
+        )
+        return f"**VLM Prediction ({VLM_MODEL}):**\n\n{response.choices[0].message.content}"
+
+    except Exception as e:
+        return f"**Error:** {str(e)}"
+
+
 def format_edge_badge(match):
     edge = match["vlm_assessment"]["edge"]
     actual = result_key(match["actual_result"])
@@ -119,26 +570,28 @@ def format_edge_badge(match):
 
     correct = best_outcome == actual
     outcome_label = {"home": match["home_team"], "draw": "Draw", "away": match["away_team"]}
-    badge = f"**Edge: +{best_val*100:.0f}pp on {outcome_label[best_outcome]}**"
+    badge = f"Edge: +{best_val*100:.0f}pp on {outcome_label[best_outcome]}"
 
     if correct:
-        return f"### {badge}\n\nActual result: **{match['actual_score']}** ({match['actual_result'].replace('_', ' ')}) — CORRECT"
+        return f"## {badge}\n\nActual result: **{match['actual_score']}** ({match['actual_result'].replace('_', ' ')}) — CORRECT"
     else:
-        return f"### {badge}\n\nActual result: **{match['actual_score']}** ({match['actual_result'].replace('_', ' ')})"
+        return f"## {badge}\n\nActual result: **{match['actual_score']}** ({match['actual_result'].replace('_', ' ')})"
 
 
 def format_reasoning(match):
     a = match["vlm_assessment"]
     lines = []
-    lines.append(f"**Confidence:** {a['confidence']}")
+    lines.append(f"### Confidence: {a['confidence']}")
     lines.append("")
-    lines.append(f"**Reasoning:** {a['reasoning']}")
+    lines.append(f"### Reasoning")
+    lines.append(a['reasoning'])
     lines.append("")
-    lines.append("**Visual Evidence:**")
+    lines.append("### Visual Evidence")
     for ev in a.get("visual_evidence", []):
         lines.append(f"- {ev}")
     lines.append("")
-    lines.append(f"**Edge Signal:** {a['edge_signal']}")
+    lines.append(f"### Edge Signal")
+    lines.append(a['edge_signal'])
     return "\n".join(lines)
 
 
@@ -166,6 +619,35 @@ def format_metrics(match):
     return "\n".join(lines)
 
 
+def format_metrics_side(match, side):
+    ctx = match.get("metrics_context", {})
+    data = ctx.get(side, {})
+    metrics = data.get("metrics", {})
+    label = match["home_team"] if side == "home" else match["away_team"]
+    lines = []
+    lines.append(f"**{label}** (last 3 matches):")
+    lines.append("")
+    matches_analyzed = data.get("matches_analyzed", [])
+    if matches_analyzed:
+        lines.append(f"| Metric | Value |")
+        lines.append(f"|--------|-------|")
+        if "avg_pressing_speed" in metrics:
+            lines.append(f"| Pressing Speed | {metrics['avg_pressing_speed']:.4f} |")
+        if "avg_def_line_movement" in metrics:
+            lines.append(f"| Defensive Line Movement | {metrics['avg_def_line_movement']:.4f} |")
+        if "avg_compactness_delta" in metrics:
+            lines.append(f"| Compactness Delta | {metrics['avg_compactness_delta']:.3f} |")
+        if "avg_transition_speed" in metrics:
+            lines.append(f"| Transition Speed | {metrics['avg_transition_speed']:.4f} |")
+        lines.append("")
+        lines.append("*Matches analyzed:*")
+        for m in matches_analyzed:
+            lines.append(f"- {m.replace('_', ' ')}")
+    else:
+        lines.append("*No tactical data available*")
+    return "\n".join(lines)
+
+
 def format_stats(match):
     stats = match.get("stats", {})
     lines = []
@@ -186,9 +668,30 @@ def format_stats(match):
     return "\n".join(lines)
 
 
+def format_stats_side(match, side):
+    stats = match.get("stats", {})
+    s = stats.get(side, {})
+    label = match["home_team"] if side == "home" else match["away_team"]
+    lines = []
+    lines.append(f"**{label}:**")
+    lines.append("")
+    if not s:
+        lines.append("*No stats available*")
+        return "\n".join(lines)
+    lines.append(f"| Metric | Value |")
+    lines.append(f"|--------|-------|")
+    lines.append(f"| xG — Expected Goals/match | {s.get('xg_last5', '-')} |")
+    lines.append(f"| xGA — Expected Goals Against/match | {s.get('xga_last5', '-')} |")
+    lines.append(f"| PPDA — Passes Per Defensive Action | {s.get('ppda', '-')} |")
+    lines.append(f"| Possession | {s.get('possession_pct', '-')}% |")
+    lines.append(f"| Form (last 5) | {s.get('form', '-')} |")
+    lines.append(f"| Goals (last 5) | {s.get('goals_scored_last5', '-')}F / {s.get('goals_conceded_last5', '-')}A |")
+    return "\n".join(lines)
+
+
 def format_match_info(match):
     lines = []
-    lines.append(f"**{match['home_team']}** vs **{match['away_team']}**")
+    lines.append(f"## {match['home_team']} vs {match['away_team']}")
     lines.append(f"- Stage: {match['stage']}")
     lines.append(f"- Date: {match['date']}")
     if match.get("first_leg"):
@@ -208,76 +711,388 @@ def on_match_select(choice):
     match = MATCHES[idx]
 
     chart = make_prob_chart(match)
+    formation = make_formation_plot(match)
     frames = get_frame_images(match)
     edge_text = format_edge_badge(match)
     reasoning_text = format_reasoning(match)
-    metrics_text = format_metrics(match)
-    stats_text = format_stats(match)
+    metrics_home = format_metrics_side(match, "home")
+    metrics_away = format_metrics_side(match, "away")
+    stats_home = format_stats_side(match, "home")
+    stats_away = format_stats_side(match, "away")
     info_text = format_match_info(match)
 
-    return chart, frames, edge_text, reasoning_text, metrics_text, stats_text, info_text
+    return chart, formation, frames, edge_text, reasoning_text, metrics_home, metrics_away, stats_home, stats_away, info_text
+
+
+def update_video_for_match(match_choice):
+    idx = get_match_choices().index(match_choice)
+    match = MATCHES[idx]
+    clips = get_match_clips(match)
+    labels = []
+    for clip in clips:
+        p = Path(clip)
+        match_name = p.parent.name.replace("_", " ").rsplit(" ", 1)[0]
+        seq = p.stem.replace("_", " ").title()
+        labels.append(f"{match_name} — {seq}")
+    first_clip = clips[0] if clips else None
+    info = f"**{len(clips)} clips** from recent matches of {match['home_team']} and {match['away_team']}" if clips else "No clips available."
+    return (
+        first_clip,
+        gr.update(choices=labels, value=labels[0] if labels else None),
+        info,
+    )
+
+
+def select_clip_for_match(clip_label, match_choice):
+    idx = get_match_choices().index(match_choice)
+    match = MATCHES[idx]
+    clips = get_match_clips(match)
+    labels = []
+    for clip in clips:
+        p = Path(clip)
+        match_name = p.parent.name.replace("_", " ").rsplit(" ", 1)[0]
+        seq = p.stem.replace("_", " ").title()
+        labels.append(f"{match_name} — {seq}")
+    if clip_label in labels:
+        return clips[labels.index(clip_label)]
+    return clips[0] if clips else None
+
+
+def build_live_context(match_idx: int) -> str:
+    match = MATCHES[match_idx]
+    lines = []
+    lines.append(f"Match: {match['home_team']} vs {match['away_team']} ({match['stage']}, {match['date']})")
+    market = match["market_odds"]
+    lines.append(f"Market implied: {match['home_team']} {market['home']*100:.0f}% / Draw {market['draw']*100:.0f}% / {match['away_team']} {market['away']*100:.0f}%")
+    stats = match.get("stats", {})
+    for side in ["home", "away"]:
+        s = stats.get(side, {})
+        if s:
+            lines.append(f"{s['team']}: xG={s.get('xg_last5')}, PPDA={s.get('ppda')}, Poss={s.get('possession_pct')}%, Form={s.get('form')}")
+    ctx = match.get("metrics_context", {})
+    for side in ["home", "away"]:
+        data = ctx.get(side, {})
+        metrics = data.get("metrics", {})
+        if metrics:
+            lines.append(f"{data.get('team', side)} tactical: pressing={metrics.get('avg_pressing_speed', 0):.4f}, def_line={metrics.get('avg_def_line_movement', 0):.4f}, compactness={metrics.get('avg_compactness_delta', 0):.3f}, transition={metrics.get('avg_transition_speed', 0):.4f}")
+    a = match["vlm_assessment"]
+    lines.append(f"VLM assessment: H={a['probabilities']['home']:.0%} D={a['probabilities']['draw']:.0%} A={a['probabilities']['away']:.0%}")
+    lines.append(f"Edge: {a['edge']}")
+    lines.append(f"Reasoning: {a['reasoning']}")
+    return "\n".join(lines)
+
+
+def encode_frame(path: str, max_width: int = 512) -> str:
+    try:
+        import cv2
+        img = cv2.imread(path)
+        if img is None:
+            return ""
+        h, w = img.shape[:2]
+        if w > max_width:
+            scale = max_width / w
+            img = cv2.resize(img, (max_width, int(h * scale)))
+        _, buffer = cv2.imencode(".jpg", img, [cv2.IMWRITE_JPEG_QUALITY, 70])
+        return base64.b64encode(buffer).decode("utf-8")
+    except ImportError:
+        with open(path, "rb") as f:
+            return base64.b64encode(f.read()).decode("utf-8")
+
+
+def live_query(match_choice: str, user_question: str, history: list):
+    if not VLM_BASE_URL:
+        history.append({"role": "assistant", "content": "Live inference is not available — no VLM endpoint configured. Set VLM_BASE_URL as a Space secret."})
+        return history, history
+
+    if not user_question.strip():
+        return history, history
+
+    history.append({"role": "user", "content": user_question})
+
+    try:
+        from openai import OpenAI
+
+        idx = get_match_choices().index(match_choice)
+        match = MATCHES[idx]
+        context = build_live_context(idx)
+
+        frames = get_frame_images(match)
+        content = []
+        for frame_path in frames[:4]:
+            b64 = encode_frame(frame_path)
+            if b64:
+                content.append({"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{b64}"}})
+
+        content.append({"type": "text", "text": f"Match context:\n{context}\n\nUser question: {user_question}"})
+
+        system_msg = (
+            "You are a tactical football analyst for UEFA Champions League. "
+            "You have access to annotated match frames showing player positions (colored bounding boxes), "
+            "defensive lines, and compactness ellipses. You also have tactical metrics and match statistics. "
+            "Answer the user's question with specific references to what you observe in the frames and data. "
+            "Be concise but specific."
+        )
+
+        messages = [
+            {"role": "system", "content": system_msg},
+            {"role": "user", "content": content},
+        ]
+
+        client = OpenAI(base_url=VLM_BASE_URL, api_key=VLM_API_KEY)
+        response = client.chat.completions.create(
+            model=VLM_MODEL,
+            messages=messages,
+            max_tokens=512,
+            temperature=0.3,
+        )
+        answer = response.choices[0].message.content
+        history.append({"role": "assistant", "content": answer})
+
+    except Exception as e:
+        history.append({"role": "assistant", "content": f"Error: {str(e)}"})
+
+    return history, history
 
 
 correct, total = get_scorecard()
+live_available = bool(VLM_BASE_URL)
 
-with gr.Blocks(title="Offsides — Tactical Edge Detection") as demo:
+with gr.Blocks(
+    title="Offsides — Tactical Edge Detection",
+) as demo:
     gr.Markdown(f"""
 # Offsides — Tactical Edge Detection
 
-**Where the market gets it wrong.** Multimodal AI analyzes UEFA Champions League footage using YOLO + Qwen-VL 72B on AMD MI300X to detect mispriced prediction markets.
+**Where the market gets it wrong.** Multimodal AI analyzes UEFA Champions League footage to detect when prediction markets are mispriced.
 
 **Scorecard: {correct}/{total} correct edge calls** | Model: {RESULTS['model']} | Generated: {RESULTS['generated_at'][:10]}
+
+---
+
+`YouTube Highlights` → `Frame Extraction` → `YOLO Detection (YOLOv8m)` → `Annotation (OpenCV)` → `Tactical Reasoning (Qwen-VL 72B)` → `Edge Signal`
+
+**Powered by AMD Instinct MI300X** on ROCm via AMD Developer Cloud
+
+---
 """)
 
-    with gr.Row():
-        match_dropdown = gr.Dropdown(
-            choices=get_match_choices(),
-            value=get_match_choices()[0],
-            label="Select Match",
-            interactive=True,
-        )
+    with gr.Tabs():
+        with gr.TabItem("Pre-computed Results"):
+            with gr.Row():
+                match_dropdown = gr.Dropdown(
+                    choices=get_match_choices(),
+                    value=get_match_choices()[0],
+                    label="Select Match",
+                    interactive=True,
+                )
 
-    with gr.Row():
-        with gr.Column(scale=1):
-            prob_chart = gr.Plot(label="Probability Comparison")
-            edge_badge = gr.Markdown()
-            reasoning_box = gr.Markdown(label="VLM Assessment")
+            # Video Player
+            _init_clips = get_match_clips(MATCHES[0])
+            _init_labels = []
+            for _c in _init_clips:
+                _p = Path(_c)
+                _mn = _p.parent.name.replace("_", " ").rsplit(" ", 1)[0]
+                _init_labels.append(f"{_mn} — {_p.stem.replace('_', ' ').title()}")
 
-        with gr.Column(scale=1):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    video_player = gr.Video(
+                        value=_init_clips[0] if _init_clips else None,
+                        label="Tactical Overlay Clip",
+                        height=400,
+                        autoplay=True,
+                        loop=True,
+                    )
+                with gr.Column(scale=1):
+                    clip_dropdown = gr.Dropdown(
+                        choices=_init_labels,
+                        value=_init_labels[0] if _init_labels else None,
+                        label="Select Clip",
+                        interactive=True,
+                    )
+                    video_info = gr.Markdown(
+                        f"**{len(_init_clips)} clips** from recent matches of {MATCHES[0]['home_team']} and {MATCHES[0]['away_team']}"
+                        if _init_clips else "No clips available."
+                    )
+
+            # Annotated Frames Gallery
             frame_gallery = gr.Gallery(
                 label="Annotated Frames (analyzed by VLM)",
                 columns=2,
-                height=400,
+                height=350,
             )
-            with gr.Accordion("Tactical Metrics", open=False):
-                metrics_box = gr.Markdown()
-            with gr.Accordion("Match Statistics", open=False):
-                stats_box = gr.Markdown()
-
-    with gr.Row():
-        info_box = gr.Markdown()
-
-    match_dropdown.change(
-        fn=on_match_select,
-        inputs=[match_dropdown],
-        outputs=[prob_chart, frame_gallery, edge_badge, reasoning_box, metrics_box, stats_box, info_box],
-    )
 
-    demo.load(
-        fn=on_match_select,
-        inputs=[match_dropdown],
-        outputs=[prob_chart, frame_gallery, edge_badge, reasoning_box, metrics_box, stats_box, info_box],
-    )
+            # Formation Plot
+            formation_plot = gr.Plot(label="Formation Map")
 
-    gr.Markdown("""
----
-**Architecture:** YouTube highlights → Frame extraction → YOLO detection → Annotation (OpenCV) → Qwen-VL 72B reasoning (AMD MI300X via vLLM on ROCm)
+            # Tactical Metrics (side-by-side)
+            gr.Markdown("## Tactical Metrics", elem_classes=["section-heading"])
+            with gr.Row():
+                with gr.Column():
+                    metrics_home_box = gr.Markdown(elem_classes=["center-content"])
+                with gr.Column():
+                    metrics_away_box = gr.Markdown(elem_classes=["center-content"])
+
+            # Match Statistics (side-by-side)
+            gr.Markdown("## Match Statistics", elem_classes=["section-heading"])
+            with gr.Row():
+                with gr.Column():
+                    stats_home_box = gr.Markdown(elem_classes=["center-content"])
+                with gr.Column():
+                    stats_away_box = gr.Markdown(elem_classes=["center-content"])
 
-**How it works:** For each upcoming match, the system analyzes the most recent 3 matches for both teams. YOLO detects player positions and ball location. OpenCV renders tactical overlays (defensive lines, compactness ellipses, team colors). Qwen-VL reasons over these annotated frames alongside stats and market odds to identify where the market may be mispriced.
+            # Probability Comparison
+            with gr.Row():
+                gr.Column(scale=1)
+                with gr.Column(scale=2):
+                    prob_chart = gr.Plot(label="Probability Comparison")
+                gr.Column(scale=1)
+
+            # Edge + Reasoning + Info
+            edge_badge = gr.Markdown()
+            reasoning_box = gr.Markdown()
+            info_box = gr.Markdown()
+
+            match_dropdown.change(
+                fn=on_match_select,
+                inputs=[match_dropdown],
+                outputs=[prob_chart, formation_plot, frame_gallery, edge_badge, reasoning_box, metrics_home_box, metrics_away_box, stats_home_box, stats_away_box, info_box],
+            )
+            match_dropdown.change(
+                fn=update_video_for_match,
+                inputs=[match_dropdown],
+                outputs=[video_player, clip_dropdown, video_info],
+            )
+            clip_dropdown.change(
+                fn=select_clip_for_match,
+                inputs=[clip_dropdown, match_dropdown],
+                outputs=[video_player],
+            )
 
-Built for the AMD Developer Hackathon 2026 (Track 3: Vision & Multimodal AI)
+            demo.load(
+                fn=on_match_select,
+                inputs=[match_dropdown],
+                outputs=[prob_chart, formation_plot, frame_gallery, edge_badge, reasoning_box, metrics_home_box, metrics_away_box, stats_home_box, stats_away_box, info_box],
+            )
+
+        with gr.TabItem("Live Query" + (" (Active)" if live_available else " (Offline)")):
+            if not live_available:
+                gr.Markdown("""
+**Live inference is currently offline.** The AMD MI300X GPU is not connected.
+
+To enable live queries, set the `VLM_BASE_URL` Space secret to the vLLM endpoint
+(e.g., `http://<droplet-ip>:8000/v1`).
+""")
+            else:
+                gr.Markdown(f"""
+**Live VLM connected** — Ask tactical questions about any match. The model ({VLM_MODEL}) will reason
+over the annotated frames and tactical data in real time on AMD MI300X.
+""")
+
+            live_match = gr.Dropdown(
+                choices=get_match_choices(),
+                value=get_match_choices()[0],
+                label="Match Context",
+                interactive=True,
+            )
+            chatbot = gr.Chatbot(label="Tactical Q&A", height=400)
+            chat_state = gr.State([])
+            with gr.Row():
+                user_input = gr.Textbox(
+                    placeholder="Ask a tactical question (e.g., 'What's wrong with PSG's defensive line?')",
+                    label="Your Question",
+                    scale=4,
+                )
+                send_btn = gr.Button("Ask", variant="primary", scale=1)
+
+            send_btn.click(
+                fn=live_query,
+                inputs=[live_match, user_input, chat_state],
+                outputs=[chatbot, chat_state],
+            ).then(fn=lambda: "", outputs=[user_input])
+
+            user_input.submit(
+                fn=live_query,
+                inputs=[live_match, user_input, chat_state],
+                outputs=[chatbot, chat_state],
+            ).then(fn=lambda: "", outputs=[user_input])
+
+        with gr.TabItem("Compare Teams"):
+            gr.Markdown("""
+**Pick any two teams** to compare their recent tactical form, head-to-head history, and optionally get a live VLM prediction.
+50 UCL teams available with annotated frames from 273 matches.
+""")
+            with gr.Row():
+                team_a_dd = gr.Dropdown(
+                    choices=get_team_list(),
+                    value="Dortmund",
+                    label="Team A",
+                    interactive=True,
+                )
+                team_b_dd = gr.Dropdown(
+                    choices=get_team_list(),
+                    value="PSG",
+                    label="Team B",
+                    interactive=True,
+                )
+
+            with gr.Row():
+                compare_btn = gr.Button("Compare", variant="primary")
+
+            with gr.Row():
+                with gr.Column():
+                    gallery_a = gr.Gallery(label="Team A — Recent Form", columns=3, height=250)
+                    metrics_a_md = gr.Markdown()
+                with gr.Column():
+                    gallery_b = gr.Gallery(label="Team B — Recent Form", columns=3, height=250)
+                    metrics_b_md = gr.Markdown()
+
+            with gr.Row():
+                with gr.Column():
+                    h2h_gallery = gr.Gallery(label="Head-to-Head", columns=3, height=200)
+                    h2h_md = gr.Markdown()
+
+            gr.Markdown("## League Statistics", elem_classes=["section-heading"])
+            with gr.Row():
+                with gr.Column():
+                    league_stats_a_md = gr.Markdown(elem_classes=["center-content"])
+                with gr.Column():
+                    league_stats_b_md = gr.Markdown(elem_classes=["center-content"])
+
+            with gr.Row():
+                predict_btn = gr.Button(
+                    "Predict Winner (Live VLM)" if live_available else "Predict Winner (GPU Offline)",
+                    variant="secondary",
+                )
+            prediction_output = gr.Markdown()
+
+            compare_btn.click(
+                fn=compare_teams,
+                inputs=[team_a_dd, team_b_dd],
+                outputs=[gallery_a, metrics_a_md, gallery_b, metrics_b_md, h2h_gallery, h2h_md, league_stats_a_md, league_stats_b_md],
+            )
+            predict_btn.click(
+                fn=predict_matchup,
+                inputs=[team_a_dd, team_b_dd],
+                outputs=[prediction_output],
+            )
+
+    gr.Markdown("""
+---
+Built for the **AMD Developer Hackathon 2026** (Track 3: Vision & Multimodal AI)
 """)
 
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(
+        theme=gr.themes.Monochrome(font=gr.themes.GoogleFont("Inter")),
+        js="() => { document.documentElement.classList.add('dark'); }",
+        css="""
+            .center-content { display: flex !important; flex-direction: column !important; align-items: center !important; }
+            .center-content table { margin: 0 auto !important; }
+            .center-content th, .center-content td { padding: 8px 12px !important; }
+            .center-content th { text-align: left !important; font-weight: 600 !important; }
+            .center-content ul { text-align: left !important; }
+            .section-heading { text-align: center !important; }
+        """,
+    )

data/demo_matches.json

@@ -1,177 +0,0 @@
-[
-  {
-    "match_id": "Dortmund_vs_PSG_2024-05-07",
-    "home_team": "Dortmund",
-    "away_team": "PSG",
-    "date": "2024-05-07",
-    "stage": "Semi-final 2nd leg",
-    "first_leg": "PSG 0-1 Dortmund",
-    "actual_score": "1-0",
-    "actual_result": "home_win",
-    "odds": {"home": 4.33, "draw": 4.00, "away": 1.80},
-    "implied_prob": {"home": 0.23, "draw": 0.25, "away": 0.56},
-    "stats": {
-      "home": {
-        "team": "Dortmund",
-        "xg_last5": 1.52,
-        "xga_last5": 1.28,
-        "ppda": 10.2,
-        "possession_pct": 46,
-        "form": "WWLWW",
-        "goals_scored_last5": 9,
-        "goals_conceded_last5": 5
-      },
-      "away": {
-        "team": "PSG",
-        "xg_last5": 2.14,
-        "xga_last5": 0.72,
-        "ppda": 9.6,
-        "possession_pct": 58,
-        "form": "WWWWL",
-        "goals_scored_last5": 12,
-        "goals_conceded_last5": 3
-      }
-    },
-    "narrative": "PSG heavily favored to overturn 1st-leg deficit at home but Dortmund's compact defensive shape and rapid transitions from their recent knockout run suggested resilience the market underpriced."
-  },
-  {
-    "match_id": "Dortmund_vs_Atletico_Madrid_2024-04-16",
-    "home_team": "Dortmund",
-    "away_team": "Atletico Madrid",
-    "date": "2024-04-16",
-    "stage": "Quarter-final 2nd leg",
-    "first_leg": "Atletico Madrid 2-1 Dortmund",
-    "actual_score": "4-2",
-    "actual_result": "home_win",
-    "odds": {"home": 2.50, "draw": 3.60, "away": 2.75},
-    "implied_prob": {"home": 0.40, "draw": 0.28, "away": 0.36},
-    "stats": {
-      "home": {
-        "team": "Dortmund",
-        "xg_last5": 1.68,
-        "xga_last5": 1.34,
-        "ppda": 9.8,
-        "possession_pct": 48,
-        "form": "WLWDW",
-        "goals_scored_last5": 10,
-        "goals_conceded_last5": 6
-      },
-      "away": {
-        "team": "Atletico Madrid",
-        "xg_last5": 1.44,
-        "xga_last5": 0.96,
-        "ppda": 12.8,
-        "possession_pct": 52,
-        "form": "DWWWW",
-        "goals_scored_last5": 7,
-        "goals_conceded_last5": 4
-      }
-    },
-    "narrative": "Atletico held 1st-leg advantage and were favored on aggregate. Dortmund's explosive transition speed and Signal Iduna Park atmosphere fueled a 4-2 comeback the market didn't fully price in."
-  },
-  {
-    "match_id": "PSG_vs_Barcelona_2024-04-16",
-    "home_team": "PSG",
-    "away_team": "Barcelona",
-    "date": "2024-04-16",
-    "stage": "Quarter-final 2nd leg",
-    "first_leg": "Barcelona 3-2 PSG",
-    "actual_score": "4-1",
-    "actual_result": "home_win",
-    "odds": {"home": 2.10, "draw": 3.80, "away": 3.40},
-    "implied_prob": {"home": 0.48, "draw": 0.26, "away": 0.29},
-    "stats": {
-      "home": {
-        "team": "PSG",
-        "xg_last5": 2.06,
-        "xga_last5": 0.88,
-        "ppda": 9.4,
-        "possession_pct": 56,
-        "form": "WWWDW",
-        "goals_scored_last5": 11,
-        "goals_conceded_last5": 5
-      },
-      "away": {
-        "team": "Barcelona",
-        "xg_last5": 1.82,
-        "xga_last5": 1.22,
-        "ppda": 10.8,
-        "possession_pct": 60,
-        "form": "WWLWW",
-        "goals_scored_last5": 9,
-        "goals_conceded_last5": 6
-      }
-    },
-    "narrative": "Barcelona had 1st-leg advantage and high possession but PSG's aggressive pressing intensity and Dembele's pace on transitions created a 4-1 demolition the aggregate market didn't reflect."
-  },
-  {
-    "match_id": "Man_City_vs_Real_Madrid_2024-04-17",
-    "home_team": "Man City",
-    "away_team": "Real Madrid",
-    "date": "2024-04-17",
-    "stage": "Quarter-final 2nd leg",
-    "first_leg": "Real Madrid 3-3 Man City",
-    "actual_score": "1-1 (Real Madrid won on penalties)",
-    "actual_result": "draw",
-    "odds": {"home": 1.83, "draw": 4.00, "away": 4.33},
-    "implied_prob": {"home": 0.55, "draw": 0.25, "away": 0.23},
-    "stats": {
-      "home": {
-        "team": "Man City",
-        "xg_last5": 2.24,
-        "xga_last5": 0.86,
-        "ppda": 8.2,
-        "possession_pct": 64,
-        "form": "WWWWW",
-        "goals_scored_last5": 13,
-        "goals_conceded_last5": 4
-      },
-      "away": {
-        "team": "Real Madrid",
-        "xg_last5": 1.76,
-        "xga_last5": 1.08,
-        "ppda": 11.6,
-        "possession_pct": 52,
-        "form": "WDWWW",
-        "goals_scored_last5": 10,
-        "goals_conceded_last5": 5
-      }
-    },
-    "narrative": "Man City dominant favorites at home but Real Madrid's low-block + lethal transitions and penalty-shootout composure saw them through. City's high line was vulnerable to counter-attacks the market discounted."
-  },
-  {
-    "match_id": "Atletico_Madrid_vs_Inter_Milan_2024-03-13",
-    "home_team": "Atletico Madrid",
-    "away_team": "Inter Milan",
-    "date": "2024-03-13",
-    "stage": "Round of 16 2nd leg",
-    "first_leg": "Inter Milan 1-0 Atletico Madrid",
-    "actual_score": "2-1",
-    "actual_result": "home_win",
-    "odds": {"home": 2.20, "draw": 3.30, "away": 3.40},
-    "implied_prob": {"home": 0.45, "draw": 0.30, "away": 0.29},
-    "stats": {
-      "home": {
-        "team": "Atletico Madrid",
-        "xg_last5": 1.56,
-        "xga_last5": 0.92,
-        "ppda": 11.4,
-        "possession_pct": 50,
-        "form": "WWDWL",
-        "goals_scored_last5": 8,
-        "goals_conceded_last5": 5
-      },
-      "away": {
-        "team": "Inter Milan",
-        "xg_last5": 1.88,
-        "xga_last5": 0.78,
-        "ppda": 10.2,
-        "possession_pct": 54,
-        "form": "WWWWD",
-        "goals_scored_last5": 10,
-        "goals_conceded_last5": 3
-      }
-    },
-    "narrative": "Inter led on aggregate and had the best defensive record in Serie A. Atletico's high-energy pressing at home disrupted Inter's build-up play, creating chaos the market underestimated."
-  }
-]

data/vlm_results/results.json

@@ -1,481 +0,0 @@
-{
-  "generated_at": "2026-05-07T21:03:43.559765",
-  "model": "Qwen/Qwen2.5-VL-72B-Instruct",
-  "matches": [
-    {
-      "match_id": "Dortmund_vs_PSG_2024-05-07",
-      "home_team": "Dortmund",
-      "away_team": "PSG",
-      "date": "2024-05-07",
-      "stage": "Semi-final 2nd leg",
-      "market_odds": {
-        "home": 0.23,
-        "draw": 0.25,
-        "away": 0.56
-      },
-      "actual_result": "home_win",
-      "actual_score": "1-0",
-      "vlm_assessment": {
-        "probabilities": {
-          "home": 0.32,
-          "draw": 0.28,
-          "away": 0.4
-        },
-        "edge": {
-          "home": 0.09,
-          "draw": 0.03,
-          "away": -0.16
-        },
-        "reasoning": "Dortmund's aggressive pressing and high defensive line, as seen in Frame 3, combined with their compactness, suggest they can create chances against PSG. However, PSG\u2019s solid defensive structure and transition speed indicate they could exploit counter-attacks effectively.",
-        "visual_evidence": [
-          "In Frame 3, Dortmund's defensive line is very high up the pitch, indicating an aggressive approach which could lead to scoring opportunities but also leaves them vulnerable on the counter.",
-          "Frames 5 and 6 show PSG maintaining a compact defensive shape, limiting space for Barcelona to attack, suggesting they can neutralize Dortmund's offensive play.",
-          "The compactness delta for both teams indicates that while Dortmund presses aggressively, PSG remains organized defensively."
-        ],
-        "confidence": "medium",
-        "edge_signal": "The market underprices a Dortmund win due to their recent tactical success in pressing and creating chances against strong opponents. A 23% implied probability seems low given their form and tactical setup."
-      },
-      "frames_used": [
-        "data/frames/PSG_vs_Dortmund_2024-05-01/annotated/frame_001.jpg",
-        "data/frames/PSG_vs_Dortmund_2024-05-01/annotated/frame_000.jpg",
-        "data/frames/Dortmund_vs_Atletico_Madrid_2024-04-16/annotated/frame_002.jpg",
-        "data/frames/Dortmund_vs_Atletico_Madrid_2024-04-16/annotated/frame_006.jpg",
-        "data/frames/PSG_vs_Barcelona_2024-04-16/annotated/frame_002.jpg",
-        "data/frames/PSG_vs_Barcelona_2024-04-16/annotated/frame_005.jpg"
-      ],
-      "metrics_context": {
-        "home": {
-          "team": "Dortmund",
-          "matches_analyzed": [
-            "PSG_vs_Dortmund_2024-05-01",
-            "Dortmund_vs_Atletico_Madrid_2024-04-16",
-            "Atletico_Madrid_vs_Dortmund_2024-04-10"
-          ],
-          "metrics": {
-            "avg_pressing_speed": 0.0037,
-            "avg_def_line_movement": -0.0103,
-            "avg_compactness_delta": -0.2123,
-            "avg_transition_speed": 0.152
-          }
-        },
-        "away": {
-          "team": "PSG",
-          "matches_analyzed": [
-            "PSG_vs_Dortmund_2024-05-01",
-            "PSG_vs_Barcelona_2024-04-16",
-            "Barcelona_vs_PSG_2024-04-10"
-          ],
-          "metrics": {
-            "avg_pressing_speed": 0.003,
-            "avg_def_line_movement": -0.035,
-            "avg_compactness_delta": -0.047,
-            "avg_transition_speed": 0.141
-          }
-        }
-      },
-      "stats": {
-        "home": {
-          "team": "Dortmund",
-          "xg_last5": 1.52,
-          "xga_last5": 1.28,
-          "ppda": 10.2,
-          "possession_pct": 46,
-          "form": "WWLWW",
-          "goals_scored_last5": 9,
-          "goals_conceded_last5": 5
-        },
-        "away": {
-          "team": "PSG",
-          "xg_last5": 2.14,
-          "xga_last5": 0.72,
-          "ppda": 9.6,
-          "possession_pct": 58,
-          "form": "WWWWL",
-          "goals_scored_last5": 12,
-          "goals_conceded_last5": 3
-        }
-      },
-      "inference_time_s": 18.504204750061035
-    },
-    {
-      "match_id": "Dortmund_vs_Atletico_Madrid_2024-04-16",
-      "home_team": "Dortmund",
-      "away_team": "Atletico Madrid",
-      "date": "2024-04-16",
-      "stage": "Quarter-final 2nd leg",
-      "market_odds": {
-        "home": 0.4,
-        "draw": 0.28,
-        "away": 0.36
-      },
-      "actual_result": "home_win",
-      "actual_score": "4-2",
-      "vlm_assessment": {
-        "probabilities": {
-          "home": 0.45,
-          "draw": 0.25,
-          "away": 0.3
-        },
-        "edge": {
-          "home": 0.05,
-          "draw": -0.03,
-          "away": -0.06
-        },
-        "reasoning": "Dortmund has shown tactical flexibility and offensive prowess in recent matches, while Atletico Madrid's defensive solidity might be slightly overstated given their lower transition speed. The home advantage and current form suggest a slight edge for Dortmund.",
-        "visual_evidence": [
-          "In Frame 3, Dortmund's compactness ellipse shows a well-organized structure around the ball, indicating strong control and potential attacking opportunities.",
-          "Frames 5 and 6 show Atletico Madrid's vulnerability when facing a compact and aggressive opponent like Inter Milan, hinting at possible weaknesses against Dortmund's similar approach.",
-          "The defensive line of Dortmund is consistently positioned higher up the pitch, as seen in Frame 4, suggesting an aggressive pressing game which could disrupt Atletico Madrid's build-up play."
-        ],
-        "confidence": "medium",
-        "edge_signal": "The market slightly underprices a Dortmund win due to their tactical advantages and recent form. The higher implied probability for an Atletico Madrid win seems inflated compared to their tactical metrics."
-      },
-      "frames_used": [
-        "data/frames/Atletico_Madrid_vs_Dortmund_2024-04-10/annotated/frame_003.jpg",
-        "data/frames/Atletico_Madrid_vs_Dortmund_2024-04-10/annotated/frame_000.jpg",
-        "data/frames/Dortmund_vs_PSV_2024-03-13/annotated/frame_003.jpg",
-        "data/frames/Dortmund_vs_PSV_2024-03-13/annotated/frame_005.jpg",
-        "data/frames/Atletico_Madrid_vs_Inter_Milan_2024-03-13/annotated/frame_001.jpg",
-        "data/frames/Atletico_Madrid_vs_Inter_Milan_2024-03-13/annotated/frame_005.jpg"
-      ],
-      "metrics_context": {
-        "home": {
-          "team": "Dortmund",
-          "matches_analyzed": [
-            "Atletico_Madrid_vs_Dortmund_2024-04-10",
-            "Dortmund_vs_PSV_2024-03-13",
-            "PSV_vs_Dortmund_2024-02-20"
-          ],
-          "metrics": {
-            "avg_pressing_speed": 0.0033,
-            "avg_def_line_movement": -0.0267,
-            "avg_compactness_delta": -0.168,
-            "avg_transition_speed": 0.1557
-          }
-        },
-        "away": {
-          "team": "Atletico Madrid",
-          "matches_analyzed": [
-            "Atletico_Madrid_vs_Dortmund_2024-04-10",
-            "Atletico_Madrid_vs_Inter_Milan_2024-03-13",
-            "Inter_Milan_vs_Atletico_Madrid_2024-02-20"
-          ],
-          "metrics": {
-            "avg_pressing_speed": 0.0043,
-            "avg_def_line_movement": -0.0163,
-            "avg_compactness_delta": -0.3237,
-            "avg_transition_speed": 0.1473
-          }
-        }
-      },
-      "stats": {
-        "home": {
-          "team": "Dortmund",
-          "xg_last5": 1.68,
-          "xga_last5": 1.34,
-          "ppda": 9.8,
-          "possession_pct": 48,
-          "form": "WLWDW",
-          "goals_scored_last5": 10,
-          "goals_conceded_last5": 6
-        },
-        "away": {
-          "team": "Atletico Madrid",
-          "xg_last5": 1.44,
-          "xga_last5": 0.96,
-          "ppda": 12.8,
-          "possession_pct": 52,
-          "form": "DWWWW",
-          "goals_scored_last5": 7,
-          "goals_conceded_last5": 4
-        }
-      },
-      "inference_time_s": 12.080515146255493
-    },
-    {
-      "match_id": "PSG_vs_Barcelona_2024-04-16",
-      "home_team": "PSG",
-      "away_team": "Barcelona",
-      "date": "2024-04-16",
-      "stage": "Quarter-final 2nd leg",
-      "market_odds": {
-        "home": 0.48,
-        "draw": 0.26,
-        "away": 0.29
-      },
-      "actual_result": "home_win",
-      "actual_score": "4-1",
-      "vlm_assessment": {
-        "probabilities": {
-          "home": 0.52,
-          "draw": 0.24,
-          "away": 0.24
-        },
-        "edge": {
-          "home": 0.04,
-          "draw": -0.02,
-          "away": -0.05
-        },
-        "reasoning": "PSG's defensive solidity and transition speed suggest they can maintain their lead. Barcelona's pressing struggles indicate difficulty in breaking down PSG.",
-        "visual_evidence": [
-          "In Frame 1, PSG's defensive organization limits Barcelona's penetration despite trailing.",
-          "Frame 3 shows PSG maintaining a high defensive line and compact shape against Real Sociedad, indicating strong defensive discipline.",
-          "Barcelona's attacking structure in Frame 5 appears disjointed, suggesting potential difficulties in creating clear chances."
-        ],
-        "confidence": "medium",
-        "edge_signal": "The market slightly underprices PSG's win due to their defensive resilience and transition capabilities, which are not fully reflected in the current odds."
-      },
-      "frames_used": [
-        "data/frames/Barcelona_vs_PSG_2024-04-10/annotated/frame_005.jpg",
-        "data/frames/Barcelona_vs_PSG_2024-04-10/annotated/frame_002.jpg",
-        "data/frames/Real_Sociedad_vs_PSG_2024-03-05/annotated/frame_002.jpg",
-        "data/frames/Real_Sociedad_vs_PSG_2024-03-05/annotated/frame_004.jpg",
-        "data/frames/Barcelona_vs_Napoli_2024-03-12/annotated/frame_006.jpg",
-        "data/frames/Barcelona_vs_Napoli_2024-03-12/annotated/frame_000.jpg"
-      ],
-      "metrics_context": {
-        "home": {
-          "team": "PSG",
-          "matches_analyzed": [
-            "Barcelona_vs_PSG_2024-04-10",
-            "Real_Sociedad_vs_PSG_2024-03-05",
-            "PSG_vs_Real_Sociedad_2024-02-14"
-          ],
-          "metrics": {
-            "avg_pressing_speed": 0.0033,
-            "avg_def_line_movement": -0.0397,
-            "avg_compactness_delta": -0.0023,
-            "avg_transition_speed": 0.1257
-          }
-        },
-        "away": {
-          "team": "Barcelona",
-          "matches_analyzed": [
-            "Barcelona_vs_PSG_2024-04-10",
-            "Barcelona_vs_Napoli_2024-03-12",
-            "Napoli_vs_Barcelona_2024-02-21"
-          ],
-          "metrics": {
-            "avg_pressing_speed": 0.003,
-            "avg_def_line_movement": -0.0493,
-            "avg_compactness_delta": -0.0793,
-            "avg_transition_speed": 0.1457
-          }
-        }
-      },
-      "stats": {
-        "home": {
-          "team": "PSG",
-          "xg_last5": 2.06,
-          "xga_last5": 0.88,
-          "ppda": 9.4,
-          "possession_pct": 56,
-          "form": "WWWDW",
-          "goals_scored_last5": 11,
-          "goals_conceded_last5": 5
-        },
-        "away": {
-          "team": "Barcelona",
-          "xg_last5": 1.82,
-          "xga_last5": 1.22,
-          "ppda": 10.8,
-          "possession_pct": 60,
-          "form": "WWLWW",
-          "goals_scored_last5": 9,
-          "goals_conceded_last5": 6
-        }
-      },
-      "inference_time_s": 9.315885782241821
-    },
-    {
-      "match_id": "Man_City_vs_Real_Madrid_2024-04-17",
-      "home_team": "Man City",
-      "away_team": "Real Madrid",
-      "date": "2024-04-17",
-      "stage": "Quarter-final 2nd leg",
-      "market_odds": {
-        "home": 0.55,
-        "draw": 0.25,
-        "away": 0.23
-      },
-      "actual_result": "draw",
-      "actual_score": "1-1 (Real Madrid won on penalties)",
-      "vlm_assessment": {
-        "probabilities": {
-          "home": 0.58,
-          "draw": 0.22,
-          "away": 0.2
-        },
-        "edge": {
-          "home": 0.03,
-          "draw": -0.03,
-          "away": -0.03
-        },
-        "reasoning": "Man City's high pressing speed, compactness, and transition speed suggest they can dominate possession and create chances. However, Real Madrid's defensive resilience and ability to counter-attack pose a threat. The market slightly undervalues the draw.",
-        "visual_evidence": [
-          "In Frame 3, Man City's compactness and high defensive line indicate their aggressive approach to regain possession quickly.",
-          "Frames 5 and 6 show Real Madrid maintaining a solid defensive structure, limiting space for opponents to exploit.",
-          "The defensive line movement of both teams indicates a tactical battle for control in midfield."
-        ],
-        "confidence": "medium",
-        "edge_signal": "The market underprices the draw due to Man City's offensive dominance but overlooks Real Madrid's defensive solidity and potential for counter-attacks."
-      },
-      "frames_used": [
-        "data/frames/Real_Madrid_vs_Man_City_2024-04-09/annotated/frame_004.jpg",
-        "data/frames/Real_Madrid_vs_Man_City_2024-04-09/annotated/frame_001.jpg",
-        "data/frames/Man_City_vs_FC_Copenhagen_2024-03-06/annotated/frame_001.jpg",
-        "data/frames/Man_City_vs_FC_Copenhagen_2024-03-06/annotated/frame_003.jpg",
-        "data/frames/Real_Madrid_vs_RB_Leipzig_2024-03-06/annotated/frame_000.jpg",
-        "data/frames/Real_Madrid_vs_RB_Leipzig_2024-03-06/annotated/frame_002.jpg"
-      ],
-      "metrics_context": {
-        "home": {
-          "team": "Man City",
-          "matches_analyzed": [
-            "Real_Madrid_vs_Man_City_2024-04-09",
-            "Man_City_vs_FC_Copenhagen_2024-03-06",
-            "FC_Copenhagen_vs_Man_City_2024-02-13"
-          ],
-          "metrics": {
-            "avg_pressing_speed": 0.003,
-            "avg_def_line_movement": -0.0107,
-            "avg_compactness_delta": -0.1893,
-            "avg_transition_speed": 0.155
-          }
-        },
-        "away": {
-          "team": "Real Madrid",
-          "matches_analyzed": [
-            "Real_Madrid_vs_Man_City_2024-04-09",
-            "Real_Madrid_vs_RB_Leipzig_2024-03-06",
-            "RB_Leipzig_vs_Real_Madrid_2024-02-13"
-          ],
-          "metrics": {
-            "avg_pressing_speed": 0.0033,
-            "avg_def_line_movement": -0.035,
-            "avg_compactness_delta": -0.247,
-            "avg_transition_speed": 0.126
-          }
-        }
-      },
-      "stats": {
-        "home": {
-          "team": "Man City",
-          "xg_last5": 2.24,
-          "xga_last5": 0.86,
-          "ppda": 8.2,
-          "possession_pct": 64,
-          "form": "WWWWW",
-          "goals_scored_last5": 13,
-          "goals_conceded_last5": 4
-        },
-        "away": {
-          "team": "Real Madrid",
-          "xg_last5": 1.76,
-          "xga_last5": 1.08,
-          "ppda": 11.6,
-          "possession_pct": 52,
-          "form": "WDWWW",
-          "goals_scored_last5": 10,
-          "goals_conceded_last5": 5
-        }
-      },
-      "inference_time_s": 10.033257007598877
-    },
-    {
-      "match_id": "Atletico_Madrid_vs_Inter_Milan_2024-03-13",
-      "home_team": "Atletico Madrid",
-      "away_team": "Inter Milan",
-      "date": "2024-03-13",
-      "stage": "Round of 16 2nd leg",
-      "market_odds": {
-        "home": 0.45,
-        "draw": 0.3,
-        "away": 0.29
-      },
-      "actual_result": "home_win",
-      "actual_score": "2-1",
-      "vlm_assessment": {
-        "probabilities": {
-          "home": 0.4,
-          "draw": 0.32,
-          "away": 0.28
-        },
-        "edge": {
-          "home": -0.05,
-          "draw": 0.02,
-          "away": -0.01
-        },
-        "reasoning": "Inter Milan's higher xG and better defensive record suggest they could neutralize Atletico's attack. However, Atletico's pressing and compactness in their own half might limit Inter's chances. The first-leg result adds pressure on Atletico to score.",
-        "visual_evidence": [
-          "In Frame 2, we can see Inter Milan's compact defensive block, which limits Atletico Madrid's attacking options.",
-          "Frame 3 shows Atletico Madrid's high defensive line and aggressive pressing, which could disrupt Inter Milan's build-up play.",
-          "Frame 5 illustrates Inter Milan's ability to maintain possession and control the game when facing opposition."
-        ],
-        "confidence": "medium",
-        "edge_signal": "The market may slightly overprice an Atletico Madrid win due to home advantage and the need to overturn the deficit. A draw or an Inter Milan win seems more likely given their recent form and defensive solidity."
-      },
-      "frames_used": [
-        "data/frames/Inter_Milan_vs_Atletico_Madrid_2024-02-20/annotated/frame_002.jpg",
-        "data/frames/Inter_Milan_vs_Atletico_Madrid_2024-02-20/annotated/frame_003.jpg",
-        "data/frames/Atletico_Madrid_vs_Lazio_2023-12-13/annotated/frame_001.jpg",
-        "data/frames/Atletico_Madrid_vs_Lazio_2023-12-13/annotated/frame_005.jpg",
-        "data/frames/Inter_Milan_vs_Real_Sociedad_2023-12-12/annotated/frame_001.jpg",
-        "data/frames/Inter_Milan_vs_Real_Sociedad_2023-12-12/annotated/frame_000.jpg"
-      ],
-      "metrics_context": {
-        "home": {
-          "team": "Atletico Madrid",
-          "matches_analyzed": [
-            "Inter_Milan_vs_Atletico_Madrid_2024-02-20",
-            "Atletico_Madrid_vs_Lazio_2023-12-13",
-            "Feyenoord_vs_Atletico_Madrid_2023-12-12"
-          ],
-          "metrics": {
-            "avg_pressing_speed": 0.0037,
-            "avg_def_line_movement": -0.012,
-            "avg_compactness_delta": -0.4683,
-            "avg_transition_speed": 0.1453
-          }
-        },
-        "away": {
-          "team": "Inter Milan",
-          "matches_analyzed": [
-            "Inter_Milan_vs_Atletico_Madrid_2024-02-20",
-            "Inter_Milan_vs_Real_Sociedad_2023-12-12",
-            "Benfica_vs_Inter_Milan_2023-11-07"
-          ],
-          "metrics": {
-            "avg_pressing_speed": 0.0033,
-            "avg_def_line_movement": -0.055,
-            "avg_compactness_delta": -0.326,
-            "avg_transition_speed": 0.1163
-          }
-        }
-      },
-      "stats": {
-        "home": {
-          "team": "Atletico Madrid",
-          "xg_last5": 1.56,
-          "xga_last5": 0.92,
-          "ppda": 11.4,
-          "possession_pct": 50,
-          "form": "WWDWL",
-          "goals_scored_last5": 8,
-          "goals_conceded_last5": 5
-        },
-        "away": {
-          "team": "Inter Milan",
-          "xg_last5": 1.88,
-          "xga_last5": 0.78,
-          "ppda": 10.2,
-          "possession_pct": 54,
-          "form": "WWWWD",
-          "goals_scored_last5": 10,
-          "goals_conceded_last5": 3
-        }
-      },
-      "inference_time_s": 11.459537267684937
-    }
-  ]
-}

requirements.txt

@@ -1,2 +1,5 @@
 gradio>=4.0
 plotly>=5.0
+pillow>=10.0
+openai>=1.0
+numpy>=1.26