Upload soccer_feature_engineering.py

soccer_feature_engineering.py

@@ -1,157 +1,207 @@
 """
-Soccer Feature Engineering Pipeline
-====================================
+Soccer Feature Engineering Pipeline - Competition Version
+===========================================================
 Engineers 33 match-level, team-level features from SkillCorner dynamic_events.csv.
 Based on the Kaggle Soccer Feature Engineering Hackathon requirements.
 
-Input:  SkillCorner opendata repository (or any folder with *_dynamic_events.csv)
-Output: features.csv — one row per team per match, 35 columns (match_id, team_id + 33 features)
+This script uses the EXACT column naming convention from the reference notebook
+by Dev0907 to ensure full compatibility with competition evaluation.
 
-All features are raw aggregated counts or cumulative distances — no percentages,
-no ratios, fully competition-compliant.
+Input:  SkillCorner opendata repository (or any folder with *_dynamic_events.csv)
+Output: features.csv - one row per team per match
 """
 
 import glob
-import json
 import os
 
-import numpy as np
 import pandas as pd
 
 
 def discover_dynamic_events_files(data_root="/app/opendata/data/matches"):
     """Dynamically discover all *_dynamic_events.csv files via glob."""
-    pattern = os.path.join(data_root, "*", "*_dynamic_events.csv")
+    pattern = os.path.join(data_root, "**", "*_dynamic_events.csv")
     files = glob.glob(pattern, recursive=True)
     files.sort()
     return files
 
 
-def load_matches_metadata(data_root="/app/opendata/data"):
-    """Load matches.json to get home/away team mapping."""
-    path = os.path.join(data_root, "matches.json")
-    with open(path, "r") as f:
-        matches = json.load(f)
-    mapping = {}
-    for m in matches:
-        mapping[str(m["id"])] = {
-            "home_team_id": m["home_team"]["id"],
-            "away_team_id": m["away_team"]["id"],
-            "home_team_name": m["home_team"]["short_name"],
-            "away_team_name": m["away_team"]["short_name"],
-        }
-    return mapping
-
-
-def compute_features_for_match(dynamic_events_path, match_meta=None):
+def compute_team_features(df, team):
     """
-    Compute all 33 features for a single match's dynamic_events.csv.
-    Returns a DataFrame with one row per team.
+    Compute 33 aggregated match-level features for a single team in a single match.
+    Uses EXACT column names from the reference notebook by Dev0907.
     """
-    df = pd.read_csv(dynamic_events_path, low_memory=False)
     match_id = df["match_id"].iloc[0]
-    team_ids = sorted(df["team_id"].unique().tolist())
 
-    records = []
-    for team_id in team_ids:
-        rec = {"match_id": match_id, "team_id": int(team_id)}
-
-        pp = df[(df["event_type"] == "player_possession") & (df["team_id"] == team_id)].copy()
-        obe = df[(df["event_type"] == "on_ball_engagement") & (df["team_id"] == team_id)].copy()
-        obr = df[(df["event_type"] == "off_ball_run") & (df["team_id"] == team_id)].copy()
-
-        # DIMENSION 1 — ATTACKING STRUCTURE (att1–att5)
-        passes = pp[pp["pass_outcome"].notna()]
-        rec["att1"] = int((passes["third_end"] == "attacking_third").sum())
-        rec["att2"] = int(((pp["carry"] == True) & (pp["third_end"] == "attacking_third")).sum())
-        pass_opp_bypassed = passes["n_opponents_bypassed"].fillna(0).clip(lower=0)
-        rec["att3"] = float(pass_opp_bypassed.sum())
-        rec["att4"] = int((passes["last_line_break"] == True).sum())
-        rec["att5"] = int((passes["third_start"] == "attacking_third").sum())
-
-        # DIMENSION 2 — BUILD-UP PROFILE (att6–att10)
-        phase_counts = pp["team_in_possession_phase_type"].value_counts()
-        rec["att6"] = int(phase_counts.get("build_up", 0))
-        rec["att7"] = int(phase_counts.get("direct", 0))
-        rec["att8"] = int(phase_counts.get("set_play", 0))
-        rec["att9"] = int(phase_counts.get("quick_break", 0))
-        rec["att10"] = int(phase_counts.get("transition", 0))
-
-        # DIMENSION 3 — POSSESSION QUALITY (att11–att20)
-        rec["att11"] = int((pp["one_touch"] == True).sum())
-        rec["att12"] = int((pp["quick_pass"] == True).sum())
-        rec["att13"] = int(pp["lead_to_shot"].sum())
-        rec["att14"] = int(pp["lead_to_goal"].sum())
-        rec["att15"] = float(pp["delta_to_last_defensive_line_gain"].fillna(0).clip(lower=0).sum())
-        rec["att16"] = float(pp["last_defensive_line_height_gain"].fillna(0).clip(lower=0).sum())
-        rec["att17"] = int((pp["forward_momentum"] == True).sum())
-        rec["att18"] = float(pp["n_passing_options"].fillna(0).sum())
-        rec["att19"] = float(pp["n_passing_options_dangerous_difficult"].fillna(0).sum())
-        rec["att20"] = int((obr["event_subtype"] == "run_ahead_of_the_ball").sum())
-
-        # DIMENSION 4 — PRESSING & DEFENSIVE SHAPE (def1–def7)
-        rec["def1"] = int(len(obe))
-        rec["def2"] = int((obe["event_subtype"] == "counter_press").sum())
-        rec["def3"] = int((obe["event_subtype"] == "recovery_press").sum())
-        chain_starts = obe[obe["index_in_pressing_chain"] == 1.0]
-        rec["def4"] = float(chain_starts["pressing_chain_length"].fillna(0).sum())
-        rec["def5"] = int(len(chain_starts))
-        rec["def6"] = float(obe["pressing_chain_length"].max() if len(obe) > 0 else 0)
-        rec["def7"] = int((obe["stop_possession_danger"] == True).sum())
-
-        # DIMENSION 5 — OFF-BALL MOVEMENT INTELLIGENCE (run1–run5 + gng)
-        rec["run1"] = int((obr["break_defensive_line"] == True).sum())
-        rec["run2"] = int((obr["push_defensive_line"] == True).sum())
-        rec["run3"] = int((obr["event_subtype"] == "behind").sum())
-        rec["run4"] = int((obr["event_subtype"] == "overlap").sum())
-        rec["run5"] = int((obr["third_start"] == "attacking_third").sum())
-        rec["att_give_and_go_initiated"] = int((pp["initiate_give_and_go"] == True).sum())
-
-        records.append(rec)
-
-    return pd.DataFrame(records)
+    team_df = df[df["team_id"] == team]
+    poss = team_df[team_df["event_type"] == "player_possession"]
+    obe = team_df[team_df["event_type"] == "on_ball_engagement"]
+    obr = team_df[team_df["event_type"] == "off_ball_run"]
+
+    passes = poss[poss["pass_outcome"].notna()]
+
+    # DIMENSION 1: ATTACKING STRUCTURE
+    att1 = int((passes["third_end"] == "attacking_third").sum())
+
+    carries = poss[poss["carry"] == True]
+    att2 = int((carries["third_end"] == "attacking_third").sum())
+
+    att3 = int(passes["n_opponents_bypassed"].clip(lower=0).sum())
+
+    att4 = int(passes["last_line_break"].sum()) if "last_line_break" in passes.columns else 0
+
+    att5 = int((passes["third_start"] == "attacking_third").sum())
+
+    # DIMENSION 2: BUILD-UP PROFILE
+    att6 = int((poss["team_in_possession_phase_type"] == "build_up").sum())
+    att7 = int((poss["team_in_possession_phase_type"] == "direct").sum())
+    att8 = int((poss["team_in_possession_phase_type"] == "set_play").sum())
+    att9 = int((poss["team_in_possession_phase_type"] == "quick_break").sum())
+    att10 = int((poss["team_in_possession_phase_type"] == "transition").sum())
+
+    # DIMENSION 3: POSSESSION QUALITY
+    att11 = int(poss["one_touch"].sum())
+    att12 = int(poss["quick_pass"].sum())
+    att13 = int(poss["lead_to_shot"].sum())
+    att14 = int(poss["lead_to_goal"].sum())
+    att15 = float(round(poss["delta_to_last_defensive_line_gain"].clip(lower=0).sum(), 2))
+    att16 = float(round(poss["last_defensive_line_height_gain"].clip(lower=0).sum(), 2))
+    att17 = int(poss["forward_momentum"].sum())
+    att18 = int(poss["n_passing_options"].sum())
+    att19 = int(poss["n_passing_options_dangerous_difficult"].sum())
+    att20 = int((obr["event_subtype"] == "run_ahead_of_the_ball").sum())
+
+    # DIMENSION 4: PRESSING & DEFENSIVE SHAPE
+    def1 = int(len(obe))
+    def2 = int((obe["event_subtype"] == "counter_press").sum())
+    def3 = int((obe["event_subtype"] == "recovery_press").sum())
+
+    chains = obe[obe["pressing_chain_length"].notna()]
+    chain_starts = chains[chains["index_in_pressing_chain"] == 1.0]
+    def4 = int(chain_starts["pressing_chain_length"].sum())
+    def5 = int(len(chain_starts))
+    def6 = int(chains["pressing_chain_length"].max()) if len(chains) > 0 else 0
+
+    def7 = int(obe["stop_possession_danger"].sum())
+
+    # DIMENSION 5: OFF-BALL MOVEMENT INTELLIGENCE
+    run1 = int(obr["break_defensive_line"].sum())
+    run2 = int(obr["push_defensive_line"].sum())
+    run3 = int((obr["event_subtype"] == "behind").sum())
+    run4 = int((obr["event_subtype"] == "overlap").sum())
+    run5 = int((obr["third_start"] == "attacking_third").sum())
+    gng = int(poss["initiate_give_and_go"].sum()) if "initiate_give_and_go" in poss.columns else 0
+
+    return {
+        "match_id": match_id,
+        "team_id": team,
+        # Attacking Structure
+        "att1_passes_into_final_third": att1,
+        "att2_carries_into_attacking_third": att2,
+        "att3_opponents_bypassed_by_passes": att3,
+        "att4_last_line_break_passes": att4,
+        "att5_passes_in_attacking_third": att5,
+        # Build-Up Profile
+        "att6_buildup_phase_events": att6,
+        "att7_direct_phase_events": att7,
+        "att8_setplay_events": att8,
+        "att9_quickbreak_events": att9,
+        "att10_transition_events": att10,
+        # Possession Quality
+        "att11_one_touch_passes": att11,
+        "att12_quick_passes": att12,
+        "att13_possessions_leading_to_shot": att13,
+        "att14_possessions_leading_to_goal": att14,
+        "att15_def_line_depth_total_pushed_m": att15,
+        "att16_def_line_height_total_pushed_m": att16,
+        "att17_forward_momentum_possessions": att17,
+        "att18_passing_options_total": att18,
+        "att19_dangerous_difficult_pass_options": att19,
+        "att20_runs_ahead_of_ball": att20,
+        # Defensive Pressing
+        "def1_total_defensive_engagements": def1,
+        "def2_counter_press_actions": def2,
+        "def3_recovery_press_actions": def3,
+        "def4_pressing_chain_total_length": def4,
+        "def5_pressing_chains_initiated": def5,
+        "def6_max_pressing_chain_length": def6,
+        "def7_danger_stopped": def7,
+        # Off-Ball Movement
+        "run1_line_breaking_runs": run1,
+        "run2_line_pushing_runs": run2,
+        "run3_runs_behind_defense": run3,
+        "run4_overlap_runs": run4,
+        "run5_attacking_third_runs": run5,
+        "att_give_and_go_initiated": gng,
+    }
 
 
 def run_pipeline(data_root="/app/opendata/data/matches", output_path="/app/features.csv"):
     files = discover_dynamic_events_files(data_root)
     print(f"Discovered {len(files)} dynamic_events.csv files")
 
-    all_dfs = []
+    records = []
     for f in files:
         try:
-            match_df = compute_features_for_match(f)
-            all_dfs.append(match_df)
-            print(f"  ✓ {os.path.basename(f)} -> {len(match_df)} rows")
+            df = pd.read_csv(f, low_memory=False)
+            match_id = df["match_id"].iloc[0]
+            teams = sorted(df["team_id"].unique().tolist())
+            for team in teams:
+                features = compute_team_features(df, team)
+                records.append(features)
+            print(f"  match {match_id}: {len(teams)} teams")
         except Exception as e:
-            print(f"  ✗ {os.path.basename(f)} -> ERROR: {e}")
+            print(f"  ERROR {os.path.basename(f)}: {e}")
 
-    if not all_dfs:
+    if not records:
         raise ValueError("No valid match files processed.")
 
-    features_df = pd.concat(all_dfs, ignore_index=True)
-
-    feature_cols = (
-        [f"att{i}" for i in range(1, 21)] +
-        [f"def{i}" for i in range(1, 8)] +
-        [f"run{i}" for i in range(1, 6)] +
-        ["att_give_and_go_initiated"]
-    )
-    ordered_cols = ["match_id", "team_id"] + feature_cols
-    features_df = features_df[[c for c in ordered_cols if c in features_df.columns]]
-
-    for col in features_df.columns:
-        if features_df[col].dtype == float:
-            rounded = features_df[col].round(2)
-            if (rounded == rounded.astype(int)).all():
-                features_df[col] = rounded.astype(int)
-            else:
-                features_df[col] = rounded
+    features_df = pd.DataFrame(records)
+
+    # Ensure exact column order as in reference notebook
+    col_order = [
+        "match_id", "team_id",
+        "att1_passes_into_final_third",
+        "att2_carries_into_attacking_third",
+        "att3_opponents_bypassed_by_passes",
+        "att4_last_line_break_passes",
+        "att5_passes_in_attacking_third",
+        "att6_buildup_phase_events",
+        "att7_direct_phase_events",
+        "att8_setplay_events",
+        "att9_quickbreak_events",
+        "att10_transition_events",
+        "att11_one_touch_passes",
+        "att12_quick_passes",
+        "att13_possessions_leading_to_shot",
+        "att14_possessions_leading_to_goal",
+        "att15_def_line_depth_total_pushed_m",
+        "att16_def_line_height_total_pushed_m",
+        "att17_forward_momentum_possessions",
+        "att18_passing_options_total",
+        "att19_dangerous_difficult_pass_options",
+        "att20_runs_ahead_of_ball",
+        "def1_total_defensive_engagements",
+        "def2_counter_press_actions",
+        "def3_recovery_press_actions",
+        "def4_pressing_chain_total_length",
+        "def5_pressing_chains_initiated",
+        "def6_max_pressing_chain_length",
+        "def7_danger_stopped",
+        "run1_line_breaking_runs",
+        "run2_line_pushing_runs",
+        "run3_runs_behind_defense",
+        "run4_overlap_runs",
+        "run5_attacking_third_runs",
+        "att_give_and_go_initiated",
+    ]
+
+    features_df = features_df[col_order]
 
     features_df.to_csv(output_path, index=False)
-    print(f"\nWrote {len(features_df)} rows × {len(features_df.columns)} columns to {output_path}")
+    print(f"\nWrote {len(features_df)} rows x {len(features_df.columns)} columns to {output_path}")
     print(f"Shape: {features_df.shape}")
     return features_df
 
 
 if __name__ == "__main__":
-    run_pipeline()
+    run_pipeline()