initial commit

.dockerignore

@@ -0,0 +1,11 @@
+checkpoints_dx/
+checkpoints_dy/
+.idea/
+.vscode/
+__pycache__/
+gru_test_results.csv
+lightgbt_test_data_results.csv
+sample_nfl_plays_actual_output.csv
+sample_nfl_plays.csv
+train_data_analysis.py
+README.md

.gitattributes

@@ -0,0 +1,9 @@
+sample_nfl_plays.csv filter=lfs diff=lfs merge=lfs -text
+sample_nfl_plays_actual_output.csv filter=lfs diff=lfs merge=lfs -text
+cross_attn_best_weight_dx.pt filter=lfs diff=lfs merge=lfs -text
+cross_attn_best_weight_dy.pt filter=lfs diff=lfs merge=lfs -text
+gru_scaler.joblib filter=lfs diff=lfs merge=lfs -text
+lightGBT_dx_model.txt filter=lfs diff=lfs merge=lfs -text
+lightGBT_dy_model.txt filter=lfs diff=lfs merge=lfs -text
+train_input/* filter=lfs diff=lfs merge=lfs -text
+train_output/* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,8 @@
+__pycache__/*
+.idea/*
+.vscode/*
+checkpoints_dx/*
+checkpoints_dy/*
+train_input/*
+train_output/*
+

Dockerfile

@@ -0,0 +1,14 @@
+FROM python:3.14.3-slim
+
+WORKDIR /app
+
+COPY requirements.txt ./
+
+RUN pip3 install --no-cache-dir --break-system-packages -r requirements.txt
+
+
+COPY gru_scaler.joblib app.py  gru_app_predict.py lightGBT_app_predict.py gru.py lightGBT.py ./
+COPY cross_attn_best_weight_dx.pt cross_attn_best_weight_dy.pt ./
+COPY lightGBT_dx_model.txt lightGBT_dy_model.txt ./
+
+CMD ["python3", "app.py", "--port", "7860"]

README.md

@@ -0,0 +1,214 @@
+# 📘 NFL Player Trajectory Prediction — Spatiotemporal Modeling (Kaggle Big Data Bowl 2026)
+
+## 📌 Overview
+This project is based on a Kaggle competition focused on predicting player positions in the NFL after the quarterback releases the ball.  
+The challenge involves forecasting the next **N frames (on an average 11)** of movement for selected players using their past tracking data.
+
+Player movement during a downfield pass is highly dynamic and uncertain — outcomes range from completions to interceptions. Understanding these trajectories helps the NFL analyze behavior of receivers, defenders, and passers during critical moments of a play.
+
+---
+
+## 🏈 Problem Description
+During a pass play:
+
+- The quarterback (QB) receives the snap.
+- At the moment the ball is thrown, the prediction window begins.
+- Tracking data provides positions and physical attributes for all players near the action.
+- Not all 22 players are relevant — only those within the vicinity of the play (often 10–14 players).
+
+### 🎯 Goal
+Predict the **next N (20–40)** positions *(x, y)* for a subset of players (**P_pred ≤ P**) given:
+
+- Their historical movement prior to the pass  
+- Ball landing location  
+- Player roles (Passer, Targeted Receiver, Defense, etc.)  
+- Game- and play-level context  
+
+---
+
+## 📂 Input Features
+Each frame includes tracking data before the pass is thrown:
+
+- `game_id`: Game identifier, unique (numeric)  
+- `play_id`: Play identifier, not unique across games (numeric)  
+- `player_to_predict`: Whether or not the x/y prediction for this player will be scored (bool)  
+- `nfl_id`: Player identification number, unique across players (numeric)  
+- `frame_id`: Frame identifier for each play/type, starting at 1 for each game_id/play_id/file type (input or output) (numeric)  
+- `play_direction`: Direction that the offense is moving (left or right)  
+- `absolute_yardline_number`: Distance from end zone for possession team (numeric) (how far from the score zone)
+- `player_name`: Player name (text)  
+- `player_height`: Player height (ft-in)  
+- `player_weight`: Player weight (lbs)  
+- `player_birth_date`: Birth date (yyyy-mm-dd)  
+- `player_position`: Player's position (role on the field)  
+- `player_side`: Team player is on (Offense or Defense)  
+- `player_role`: Role on the play (Defensive Coverage, Targeted Receiver, Passer, Other Route Runner)  
+- `x`: Player position along the long axis of the field (0–120 yards)  
+- `y`: Player position along the short axis of the field (0–53.3 yards)  
+- `s`: Speed in yards/second (numeric)  
+- `a`: Acceleration in yards/second² (numeric)  
+- `o`: Orientation of player (degrees)  
+- `dir`: Angle of player motion (degrees)  
+- `num_frames_output`: Number of frames to predict in output data for the given game_id/play_id/nfl_id (numeric)  
+- `ball_land_x`: Ball landing x-position (0–120 yards)  
+- `ball_land_y`: Ball landing y-position (0–53.3 yards)
+
+---
+
+## 🛠 Feature Engineering
+
+Feature engineering is performed using the `NFLFeatureTransformer` class, which normalizes numerical fields and adds several new features.
+
+### 🔹 Angle-Based Features
+-  
+- `sin_dir`, `cos_dir`  
+- `sin_o`, `cos_o`  
+- `angle_between_ball_land_and_player`  
+- `angle_between_ball_land_and_player_orient`  
+- `sin_angle_between_ball_land_and_player`  
+- `cos_angle_between_ball_land_and_player`  
+- `sin_angle_between_ball_land_and_player_orient`  
+- `cos_angle_between_ball_land_and_player_orient`  
+- `sin_change_in_o` 
+- `cos_change_in_o` 
+- `change_in_dir`
+- `sin_change_in_dir` 
+- `cos_change_in_dir`
+- `change_in_o`
+- `angle_between_orientation_and_player`
+       
+
+These help the model understand relative direction and orientation with respect to the ball.
+
+### 🔹 Distance & Physics Features
+
+- `velocity_x`, `velocity_y`  
+- `acc_x`, `acc_y`  
+- `distance_to_x`, `distance_to_y`  
+- `distance_to_sideline`,
+- `distance_to_ball_land_x`, `distance_to_ball_land_y`  
+- `absolute_yardline_number`
+- `distance_between_the_reciever` 
+- `distance_between_the_passer`
+- `distance_to_defense` 
+- `distance_to_defense_x` 
+- `distance_to_defense_y`
+- `distance_to_offense`
+- `distance_to_offense_x` 
+- `distance_to_offense_y`
+- `nearest_teammate_dis` 
+- `nearest_teammate_dis_x`
+- `nearest_teammate_dis_y`,
+- `required_velocity_x` 
+- `required_velocity_y` 
+- `required_acc_x`
+- `required_acc_y` 
+- `proj_x_acc` 
+- `proj_y_acc` 
+- `proj_x_velocity`
+- `proj_y_velocity`
+- `required_speed` 
+- `required_acceleration`
+
+
+These features capture how players move in relation to the field and ball landing location.
+
+### 🔹 Temporal Change Features
+
+- `time_left`  
+- `required_speed`, `required_acceleration`  
+- `change_in_x`, `change_in_y`  
+- `change_in_speed`  
+- `change_in_acceleration`  
+- `change_in_o`  
+- `change_in_dir`
+- `proj_x_acc_diff` 
+- `proj_y_acc_diff`
+- `proj_x_velocity_diff` 
+- `proj_y_velocity_diff`
+- `required_speed_diff` 
+- `required_velocity_x_diff`
+- `required_velocity_y_diff` 
+- `required_acc_x_diff`
+- `required_acc_y_diff` 
+
+
+These model short-term motion dynamics and evolution of movement.
+
+
+---
+
+## 📁 Project files
+
+- `gru.py` 
+- `lightGBT.py` 
+
+Each python file represents a separate modeling approach to the same prediction task.
+
+---
+
+## 🔷 Model 1: LightGBT
+
+### 🧱 Architecture
+
+This approach combines:
+
+1. Takes the last given frame and uses that data to predict the next `num_frames_output`.
+2. We predict the residual from the last known x and y positions.
+3. Uses a separate model dx_model , dy_model to predict the residuals.
+
+
+## 🔷 Model 2: RNN With Cross Attention and MLP
+
+### 🧱 Architecture
+
+This approach combines:
+
+Uses Two Models to find dx , dy from the last known x and y positions.
+
+1. **Spatial Encoder**  
+   - Operates on `[T, P, din]`  
+   - Captures relationships among players at a given time frame  
+
+2. **GRU Layer**  
+   - Operates on `[P, T, din]`  
+   - Models temporal evolution for each player's trajectory  (taken only on the players to predict)
+   - Takes cross attention with Spatial Encoder at each time t.
+
+3. **MLP Layer**  
+   - Operates on `[P*T, din]`  
+   - outputs the change in displacment dx, dy
+
+
+Input is fed as:
+
+- `[P, T, din]`
+
+Where:
+
+- `P`: total players under focus  
+- `T`: total time steps  
+- `din`: input feature dimension  
+
+
+### 📉 Loss Function
+
+- **Mean Squared Error (MSE)**
+
+### 📊 Performance
+
+- **RMSE: 1.71 yards** on physics first order linear exerpolation
+- **RMSE: 0.66 yards** on LightGBT
+- **RMSE: 0.60 yards** on RNN With Cross Attention and MLP
+
+---
+
+## 🚀 Future Work
+- Explore graph neural networks for player–player interaction modeling.  
+
+---
+
+## 🎉 Conclusion
+
+This project applies deep feature engineering, transformers, and recurrent architectures to model complex NFL player movement in pass plays.  
+The lightGBT approach is lot simpler and acheives slightly better performance.

app.py

@@ -0,0 +1,48 @@
+from flask import Flask, request, Response
+import pandas as pd
+import gru_app_predict
+import lightGBT_app_predict
+import os
+import logging
+import argparse
+
+app = Flask(__name__)
+
+logging.basicConfig(level=logging.INFO)
+
+
+@app.route('/nfl/health')
+def health_check():
+    return 'dont worry i m there'
+
+@app.route('/nfl/gru_predict_play', methods=['POST']) 
+def gru_predict__play():
+    csv_file = request.files['file'] 
+    df = pd.read_csv(csv_file.stream)
+    res_df = gru_app_predict.predict(df)
+
+    return  Response(
+        res_df.to_csv(index=False),
+        mimetype="text/csv",
+        headers={"Content-Disposition": "attachment; filename=gru_predict.csv"}
+    )
+
+@app.route('/nfl/lightGBT_predict_play', methods=['POST']) 
+def lightGBT_predict_play():
+    csv_file = request.files['file'] 
+    df = pd.read_csv(csv_file.stream) 
+
+    res_df = lightGBT_app_predict.predict(df)
+
+    return  Response(
+        res_df.to_csv(index=False),
+        mimetype="text/csv",
+        headers={"Content-Disposition": "attachment; filename=lightGBT_predict.csv"}
+    )
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description="Run the FastAPI application.")
+    parser.add_argument("--port", type=int, default=5050, help="Port to run the app on")
+    args = parser.parse_args()
+    app.run(host='0.0.0.0', port=args.port)

cross_attn_best_weight_dx.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:16fef2a972fc1694de301174a9cd9b50d076bd7ff660510bfa8eae7b48a707d2
+size 2510996

cross_attn_best_weight_dy.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e7847d5469de0861b311ff21db1349234a60cff1f60de77b7133153ed5ed3de3
+size 2510996

gru.py

@@ -0,0 +1,973 @@
+import numpy as np
+import pandas as pd
+import torch
+
+
+MODEL_INPUT_FEATURES = ['frame_id', 'absolute_yardline_number', 
+       'player_height', 'player_weight', 'x', 'y', 's', 'a', 'dir', 'o',
+       'num_frames_output', 'ball_land_x', 'ball_land_y', 'sin_dir', 'cos_dir',
+       'sin_o', 'cos_o', 'velocity_x', 'velocity_y', 'acc_x', 'acc_y',
+       'distance_to_sideline', 'distance_to_ball_land',
+       'distance_to_ball_land_x', 'distance_to_ball_land_y',
+       'angle_between_ball_land_and_player',
+       'angle_between_ball_land_and_player_orient',
+       'sin_angle_between_ball_land_and_player',
+       'cos_angle_between_ball_land_and_player',
+       'sin_angle_between_ball_land_and_player_orient',
+       'cos_angle_between_ball_land_and_player_orient', 'time_left',
+       'required_speed', 'required_acceleration', 'change_in_x', 'change_in_y',
+       'change_in_speed', 'change_in_acceleration', 'change_in_o',
+       'sin_change_in_o', 'cos_change_in_o', 'change_in_dir',
+       'sin_change_in_dir', 'cos_change_in_dir',
+       'distance_between_the_reciever', 'distance_between_the_passer',
+       'distance_to_defense', 'distance_to_defense_x', 'distance_to_defense_y',
+       'distance_to_offense', 'distance_to_offense_x', 'distance_to_offense_y',
+       'nearest_teammate_dis', 'nearest_teammate_dis_x',
+       'nearest_teammate_dis_y', 'player_role_Defensive Coverage',
+       'player_role_Other Route Runner', 'player_role_Passer',
+       'player_role_Targeted Receiver', 'player_role_unknown',
+       'required_velocity_x', 'required_velocity_y', 'required_acc_x',
+       'required_acc_y', 'required_speed_diff', 'required_velocity_x_diff',
+       'required_velocity_y_diff', 'required_acc_x_diff',
+       'required_acc_y_diff', 'proj_x_acc', 'proj_y_acc', 'proj_x_velocity',
+       'proj_y_velocity', 'proj_x_acc_diff', 'proj_y_acc_diff',
+       'proj_x_velocity_diff', 'proj_y_velocity_diff',
+       'angle_between_orientation_and_player', 'player_age']
+
+MODEL_OUTPUTS = ['x', 'y']
+
+TRAIN_INPUT_FILE_PATH=f'train_input'
+TRAIN_OUTPUT_FILE_PATH=f'train_output'
+
+DX_CHECKPOINT_DIR = f'checkpoints_dx'
+DY_CHECKPOINT_DIR = f'checkpoints_dy'
+
+BEST_DX_MODEL_CHECKPOINT = f'cross_attn_best_weight_dx.pt'
+BEST_DY_MODEL_CHECKPOINT = f'cross_attn_best_weight_dy.pt'
+
+JOBLIB_FILE_PATH = f'gru_scaler.joblib'
+
+
+from enum import Enum
+class ModelType(Enum):
+    DX_MODEL = 1
+    DY_MODEL = 2
+
+from datetime import date
+from scipy.spatial.distance import cdist
+
+class NFLFeatureTransformer:
+
+    def _convert_to_radians(self, degrees):
+        return degrees * np.pi / 180
+        
+    def _convert_to_degrees(self, radians):
+        return radians * 180 / np.pi
+
+    def _sin(self, X):
+        return np.sin(self._convert_to_radians(X))
+
+    def _cos(self, X):
+        return np.cos(self._convert_to_radians(X))
+
+    def _x_component(self, magnitude, direction):
+        return magnitude * self._sin(direction)
+
+    def _y_component(self, magnitude, direction):
+        return magnitude * self._cos(direction)
+
+    def _distance_between_two_points(self, x1, y1, x2, y2):
+        return np.sqrt((x2 - x1)**2 + (y2 - y1)**2)
+
+   
+    def _angle_between_two_points(self, x1, y1, x2, y2):
+        num = x2 - x1
+        denom = (y2-y1)+1e-6 
+        angle_in_radians = np.arctan2(num, denom)
+        angle = self._convert_to_degrees(angle_in_radians)
+        return (angle + 360) % 360
+    
+    def _angle_between_two_vectors(self, x1, y1, x2, y2):
+        denom = np.sqrt((x1**2)+(y1**2)) * np.sqrt((x2**2)+(y2**2)) + 1e-6
+        dot = x1*x2 + y1*y2
+        cos_angle = dot / denom
+        cos_angle = np.clip(cos_angle, -1.0, 1.0)
+        angle_in_radians = np.arccos(cos_angle)
+        return self._convert_to_degrees(angle_in_radians)
+
+    def _convert_to_inches(self, X):
+        splits = X.str.split('-', expand=True)
+        feet = splits.iloc[:,0].astype(np.float32)
+        inches = splits.iloc[:,1].astype(np.float32)
+        return feet * 12 + inches
+    
+    MAXIMUM_X = 120
+    MAXIMUM_Y = 53.3
+
+    #measured along diagonal
+    MAXIMUM_DIS = 131.30
+
+    #measures short change in angle like (1 degree - 359 degree gives -358 degree/360 gives a larger value)
+    def _change_in_angle(self, prev, curr):
+        return ((curr - prev +180) % 360) - 180
+    
+    def reflect_input_coordinates(self, X, play_direction):
+        if play_direction == 'left':
+            X['x'] = self.MAXIMUM_X - X['x']
+            X['dir'] = (360 - X['dir']) % 360
+            X['o'] = (360 - X['o']) % 360
+            X['ball_land_x'] = self.MAXIMUM_X - X['ball_land_x']
+        return X
+    
+    def reflect_output_coordinates(self, Y, play_direction):
+        if play_direction == 'left':
+            Y['x'] = self.MAXIMUM_X - Y['x']
+        return Y
+    
+    
+    def transform_X(self, X, prev_frame, total_frames):
+
+        X['x'] = X['x'].bfill().ffill()
+        X['y'] = X['y'].bfill().ffill()
+        X['s'] = X['s'].bfill().ffill()
+        X['a'] = X['a'].bfill().ffill()
+        X['dir'] = X['dir'].bfill().ffill()
+        X['o'] = X['o'].bfill().ffill()
+        X['player_height'] = X['player_height'].bfill().ffill()
+
+        prev_x_ = prev_frame['x'].bfill().ffill().values
+        prev_y_ = prev_frame['y'].bfill().ffill().values
+        prev_s_ = prev_frame['s'].bfill().ffill().values
+        prev_a_ = prev_frame['a'].bfill().ffill().values
+        prev_dir_ = prev_frame['dir'].bfill().ffill().values
+        prev_o_ = prev_frame['o'].bfill().ffill().values
+
+        player_role_categories = ['Defensive Coverage', 'Other Route Runner', 'Passer', 'Targeted Receiver', 'unknown']
+        X['player_role'] = X['player_role'].fillna('unknown')
+        X['player_role'] = pd.Categorical(X['player_role'], categories=player_role_categories)
+
+        offense_indices = X['player_side'] == 'Offense'
+        defense_indices = X['player_side'] == 'Defense'
+        targeted_reciever = X[X['player_role'] == 'Targeted Receiver']
+        passer = X[X['player_role'] == 'Passer']
+
+        if np.any(defense_indices):
+            defense_x_ = X[defense_indices]['x'].values
+            defense_y_ = X[defense_indices]['y'].values
+            defense_pos = np.column_stack((defense_x_, defense_y_))
+
+        if np.any(offense_indices):
+            offense_x_ = X[offense_indices]['x'].values
+            offense_y_ = X[offense_indices]['y'].values
+            offense_pos = np.column_stack((offense_x_, offense_y_))
+
+            
+        X['sin_dir'] = self._sin(X['dir'])
+        X['cos_dir'] = self._cos(X['dir'])
+        X['sin_o'] = self._sin(X['o'])
+        X['cos_o'] = self._cos(X['o'])
+        X['velocity_x'] = self._x_component(X['s'], X['dir']) 
+        X['velocity_y'] = self._y_component(X['s'], X['dir']) 
+
+        X['acc_x'] = self._x_component(X['a'], X['dir']) 
+        X['acc_y'] = self._y_component(X['a'], X['dir']) 
+
+        X['distance_to_sideline'] = np.minimum(X['y'], self.MAXIMUM_Y - X['y'])
+        
+
+        X['distance_to_ball_land'] = self._distance_between_two_points(X['x'], X['y'], X['ball_land_x'],X['ball_land_y']) 
+        X['distance_to_ball_land_x'] = X['x'] - X['ball_land_x']
+        X['distance_to_ball_land_y'] = X['y'] - X['ball_land_y']
+
+        X['angle_between_ball_land_and_player'] = (
+            self._angle_between_two_vectors(X['sin_dir'], X['cos_dir'], X['distance_to_ball_land_x'], X['distance_to_ball_land_y'] ) 
+        )
+
+        X['angle_between_ball_land_and_player_orient'] = (
+            self._angle_between_two_vectors(X['sin_o'], X['cos_o'], X['distance_to_ball_land_x'], X['distance_to_ball_land_y'] )
+        )
+
+        X['sin_angle_between_ball_land_and_player'] = self._sin(X['angle_between_ball_land_and_player'])
+        X['cos_angle_between_ball_land_and_player'] = self._cos(X['angle_between_ball_land_and_player'])
+
+        X['sin_angle_between_ball_land_and_player_orient'] = self._sin(X['angle_between_ball_land_and_player_orient'])
+        X['cos_angle_between_ball_land_and_player_orient'] = self._cos(X['angle_between_ball_land_and_player_orient'])
+
+        
+        X['time_left'] = (total_frames - (X['frame_id'] - 1)) / 10
+        X['required_speed'] = (X['distance_to_ball_land'] / X['time_left']) 
+        X['required_acceleration'] = ((X['required_speed'] - X['s']) / X['time_left'])
+
+        
+        X['change_in_x'] = (X['x'] - prev_x_) 
+        X['change_in_y'] = (X['y'] - prev_y_) 
+        X['change_in_speed'] = (X['s'] - prev_s_) 
+        X['change_in_acceleration'] = (X['a'] - prev_a_)
+
+        X['change_in_o'] = self._change_in_angle(X['o'], prev_o_)
+        X['sin_change_in_o'] = self._sin(X['change_in_o'])
+        X['cos_change_in_o'] = self._cos(X['change_in_o'])
+        
+        X['change_in_dir'] = self._change_in_angle(X['dir'] , prev_dir_)
+        X['sin_change_in_dir'] = self._sin(X['change_in_dir'])
+        X['cos_change_in_dir'] = self._cos(X['change_in_dir'])
+
+        
+        if targeted_reciever.empty:
+            X['distance_between_the_reciever'] = self.MAXIMUM_DIS
+        else:
+            X['distance_between_the_reciever'] = (
+                self._distance_between_two_points(X['x'], X['y'], targeted_reciever['x'].values, targeted_reciever['y'].values) 
+            )
+
+        if passer.empty:
+            X['distance_between_the_passer'] = self.MAXIMUM_DIS
+        else:
+            X['distance_between_the_passer'] = self._distance_between_two_points(X['x'], X['y'], passer['x'].values, passer['y'].values) 
+
+        
+        if np.any(offense_indices) and np.any(defense_indices):
+            cross_distance_matrix = cdist(offense_pos, defense_pos, metric='euclidean')
+            
+            offense_distance_matrix = cdist(offense_pos, offense_pos, metric='euclidean')
+            np.fill_diagonal(offense_distance_matrix, self.MAXIMUM_DIS)
+            
+            defense_distance_matrix = cdist(defense_pos, defense_pos, metric='euclidean')
+            np.fill_diagonal(defense_distance_matrix, self.MAXIMUM_DIS)
+            
+            X.loc[offense_indices, ['distance_to_defense']] = np.min(cross_distance_matrix, axis=1)
+            X.loc[offense_indices, ['distance_to_defense_x']] = defense_pos[np.argmin(cross_distance_matrix, axis=1), 0]
+            X.loc[offense_indices, ['distance_to_defense_y']] = defense_pos[np.argmin(cross_distance_matrix, axis=1), 1]
+
+            X.loc[offense_indices, ['distance_to_offense']] = 0
+            X.loc[offense_indices, ['distance_to_offense_x']] = 0
+            X.loc[offense_indices, ['distance_to_offense_y']] = 0
+            
+            X.loc[offense_indices, ['nearest_teammate_dis']] = np.min(offense_distance_matrix, axis=1)
+            X.loc[offense_indices, ['nearest_teammate_dis_x']] = offense_pos[np.argmin(offense_distance_matrix, axis=1), 0]
+            X.loc[offense_indices, ['nearest_teammate_dis_y']] = offense_pos[np.argmin(offense_distance_matrix, axis=1), 1]
+            
+
+        
+            X.loc[defense_indices, ['distance_to_offense']] = np.min(cross_distance_matrix, axis=0)
+            X.loc[defense_indices, ['distance_to_offense_x']] = offense_pos[np.argmin(cross_distance_matrix, axis=0), 0]
+            X.loc[defense_indices, ['distance_to_offense_y']] = offense_pos[np.argmin(cross_distance_matrix, axis=0), 1]
+
+            X.loc[defense_indices, ['distance_to_defense']] = 0
+            X.loc[defense_indices, ['distance_to_defense_x']] = 0 
+            X.loc[defense_indices, ['distance_to_defense_y']] = 0 
+
+            X.loc[defense_indices, ['nearest_teammate_dis']] = np.min(defense_distance_matrix, axis=1)
+            X.loc[defense_indices, ['nearest_teammate_dis_x']] = defense_pos[np.argmin(defense_distance_matrix, axis=1), 0]
+            X.loc[defense_indices, ['nearest_teammate_dis_y']] = defense_pos[np.argmin(defense_distance_matrix, axis=1), 1]
+        else:
+            if np.any(offense_indices):
+                offense_distance_matrix = cdist(offense_pos, offense_pos, metric='euclidean')
+                np.fill_diagonal(offense_distance_matrix, self.MAXIMUM_DIS)
+                X.loc[offense_indices, ['distance_to_defense']] = self.MAXIMUM_DIS
+                X.loc[offense_indices, ['distance_to_defense_x']] = self.MAXIMUM_DIS
+                X.loc[offense_indices, ['distance_to_defense_y']] = self.MAXIMUM_DIS
+                
+                X.loc[offense_indices, ['distance_to_offense']] = 0
+                X.loc[offense_indices, ['distance_to_offense_x']] = 0
+                X.loc[offense_indices, ['distance_to_offense_y']] = 0
+               
+                X.loc[offense_indices, ['nearest_teammate_dis']] = np.min(offense_distance_matrix, axis=1)
+                X.loc[offense_indices, ['nearest_teammate_dis_x']] = offense_pos[np.argmin(offense_distance_matrix, axis=1), 0]
+                X.loc[offense_indices, ['nearest_teammate_dis_y']] = offense_pos[np.argmin(offense_distance_matrix, axis=1), 1]
+            
+            if np.any(defense_indices):
+                defense_distance_matrix = cdist(defense_pos, defense_pos, metric='euclidean')
+                np.fill_diagonal(defense_distance_matrix, self.MAXIMUM_DIS)
+                X.loc[defense_indices, ['distance_to_offense']] = self.MAXIMUM_DIS
+                X.loc[defense_indices, ['distance_to_offense_x']] = self.MAXIMUM_DIS
+                X.loc[defense_indices, ['distance_to_offense_y']] = self.MAXIMUM_DIS
+
+                X.loc[defense_indices, ['distance_to_defense']] = 0
+                X.loc[defense_indices, ['distance_to_defense_x']] = 0
+                X.loc[defense_indices, ['distance_to_defense_y']] = 0
+                
+                X.loc[defense_indices, ['nearest_teammate_dis']] =  np.min(defense_distance_matrix, axis=1)
+                X.loc[defense_indices, ['nearest_teammate_dis_x']] = defense_pos[np.argmin(defense_distance_matrix, axis=1), 0]
+                X.loc[defense_indices, ['nearest_teammate_dis_y']] = defense_pos[np.argmin(defense_distance_matrix, axis=1), 1]
+        
+        
+        X = pd.get_dummies(X, columns=['player_role'], dtype=np.float32)
+
+        X['required_velocity_x'] = X['distance_to_ball_land_x'] / X['time_left']
+        X['required_velocity_y'] = X['distance_to_ball_land_y'] / X['time_left']
+        
+        X['required_acc_x'] = (X['required_velocity_x'] - X['velocity_x']) / X['time_left']
+        X['required_acc_y'] = (X['required_velocity_y'] - X['velocity_y']) / X['time_left']
+
+        X['required_speed_diff'] = X['required_speed'] - X['s']
+        X['required_velocity_x_diff'] = X['required_velocity_x'] - X['velocity_x']
+        X['required_velocity_y_diff'] = X['required_velocity_y'] - X['velocity_y']
+        
+        X['required_acc_x_diff'] = X['required_acc_x'] - X['acc_x']
+        X['required_acc_y_diff'] = X['required_acc_y'] - X['acc_y']
+
+        X['proj_x_acc'] = X['x'] + X['velocity_x']*X['time_left'] + 0.5*X['acc_x']*(X['time_left']**2)
+        X['proj_y_acc'] = X['y'] + X['velocity_y']*X['time_left'] + 0.5*X['acc_y']*(X['time_left']**2)
+
+        X['proj_x_velocity'] = X['x'] + X['velocity_x']*X['time_left']
+        X['proj_y_velocity'] = X['y'] + X['velocity_y']*X['time_left']
+
+        X['proj_x_acc_diff'] = X['ball_land_x'] - X['proj_x_acc']
+        X['proj_y_acc_diff'] = X['ball_land_y'] - X['proj_y_acc']
+
+        X['proj_x_velocity_diff'] = X['ball_land_x'] - X['proj_x_velocity']
+        X['proj_y_velocity_diff'] = X['ball_land_y'] - X['proj_y_velocity']
+
+
+        X['angle_between_orientation_and_player'] = self._change_in_angle(X['o'], X['dir'])
+        year = date.today().year
+        
+        parsed = pd.to_datetime(X['player_birth_date'], format="%Y-%m-%d")
+       
+        X['player_age'] = year - parsed.dt.year
+        X['player_height'] = self._convert_to_inches(X['player_height']) 
+        X['player_weight'] = X['player_weight']
+
+        X['absolute_yardline_number'] = np.clip(X['absolute_yardline_number'], 0, 100.0)
+
+        return X
+
+    
+from torch.utils.data import Dataset, get_worker_info
+import os
+import random
+
+class NFLDataset(Dataset):
+    def __init__(self, input_groups, output_groups, nfl_feature_transformer, shuffle=True):
+        self.nfl_feature_transformer = nfl_feature_transformer
+        self.input_groups = input_groups
+        self.output_groups = output_groups
+        
+        self.indices = list(range(len(input_groups)))
+        if shuffle:
+            random.shuffle(self.indices)
+        self.input_groups = input_groups
+        self.output_groups = output_groups
+        
+    def _get_output_array(self, dx, dy):
+        numpy_array = np.column_stack((dx, dy)).astype(np.float32)
+        return np.expand_dims(numpy_array, axis=1)
+
+    def _get_input_array(self, df):
+        model_input_features = MODEL_INPUT_FEATURES
+        numpy_array = df[model_input_features].to_numpy().astype(np.float32)
+        return np.expand_dims(numpy_array, axis=1)
+
+        
+    def __len__(self):
+        return len(self.input_groups)
+
+    def __getitem__(self, indx):
+        val_indx = self.indices[indx]
+        input_df = self.input_groups[val_indx].copy()
+        output_df = self.output_groups[val_indx].copy()
+
+        play_direction = input_df.iloc[0]['play_direction']
+
+        input_df = self.nfl_feature_transformer.reflect_input_coordinates(input_df, play_direction)
+        output_df = self.nfl_feature_transformer.reflect_output_coordinates(output_df, play_direction)
+
+        given_frames = input_df['frame_id'].max()
+        output_frames = input_df['num_frames_output'].iloc[0]
+
+        total_frames = given_frames + output_frames
+
+        min_frame_start = max(given_frames - 10, 1)
+        
+        prev_frame = None
+        x = None
+        for f in range(min_frame_start, given_frames+1):
+            
+            grouped_frame = input_df[input_df['frame_id'] == f].sort_values(by=['nfl_id'], ascending=[True]).reset_index(drop=True)
+
+            prev_frame = grouped_frame if prev_frame is None else prev_frame
+            transformed_input_df = self.nfl_feature_transformer.transform_X(grouped_frame, prev_frame, total_frames)
+            input_array = self._get_input_array(transformed_input_df)
+            x = input_array if x is None else np.concat((x, input_array), axis=1)
+            prev_frame = grouped_frame
+        
+        
+        num_output = prev_frame['num_frames_output'].iloc[0] # type: ignore
+        players_to_predict = prev_frame['player_to_predict'].values.tolist() # type: ignore
+
+        x_last = prev_frame[prev_frame['player_to_predict']]['x'].values # type: ignore
+        y_last = prev_frame[prev_frame['player_to_predict']]['y'].values # type: ignore
+
+        y = None
+        for  f in range(1, output_frames+1):
+        
+            grouped_frame = output_df[output_df['frame_id'] == f].sort_values(by=['nfl_id'], ascending=[True]).reset_index(drop=True)
+            
+            dx = grouped_frame['x'] - x_last
+            dy = grouped_frame['y'] - y_last
+            
+            output_tensor = self._get_output_array(dx, dy)
+            y = output_tensor if y is None else np.concat((y, output_tensor), axis=1)
+            
+        return x, y, players_to_predict, num_output
+    
+    
+import os
+def get_train_file_paths():
+        
+    def get_output_file(input_filename):
+        return input_filename.replace('input', 'output')
+    
+    input_file_paths = []
+    output_file_paths = []
+    input_files_dir = TRAIN_INPUT_FILE_PATH
+    for w in range(1, 19):
+        input_filename = f'input_2023_w{w:02d}.csv'
+        if  os.path.isfile(f'{input_files_dir}/{input_filename}'):
+            output_filename = get_output_file(input_filename)
+            input_file_path = os.path.join(TRAIN_INPUT_FILE_PATH, input_filename)
+            output_file_path = os.path.join(TRAIN_OUTPUT_FILE_PATH, output_filename)
+            input_file_paths.append(input_file_path)
+            output_file_paths.append(output_file_path)
+        else:
+            raise Exception(f'input file for week {w} does not exist')
+            
+    return (input_file_paths, output_file_paths)
+
+import random
+import pandas as pd
+from concurrent.futures import ThreadPoolExecutor
+
+def load_file(file_path):
+    return pd.read_csv(file_path)
+    
+def get_input_output_df():
+    input_file_paths, output_file_paths = get_train_file_paths()
+   
+    with ThreadPoolExecutor(max_workers = 8) as executor:
+        input_dfs = executor.map(load_file, input_file_paths)
+        input_df = pd.concat(input_dfs, axis=0)
+
+    with ThreadPoolExecutor(max_workers = 8) as executor:
+        output_dfs = executor.map(load_file, output_file_paths)
+        output_df = pd.concat(output_dfs, axis=0)
+
+    return input_df.reset_index(drop=True), output_df.reset_index(drop=True)
+
+
+import random
+def split_train_test(input_df, output_df, nfl_feature_transformer, test_ratio = 0.2):
+    
+    input_groups = [group for _, group in input_df.groupby(by=['game_id', 'play_id'], sort=True)]
+    output_groups = [group for _, group in output_df.groupby(by=['game_id', 'play_id'], sort=True)]
+
+    n_groups = len(input_groups)
+
+    test_start = int(n_groups - n_groups*(test_ratio))
+
+    train_input_groups, train_output_groups = input_groups[:test_start], output_groups[:test_start]
+    train_data = NFLDataset(train_input_groups, train_output_groups, nfl_feature_transformer)
+    
+
+    test_input_groups, test_output_groups =  input_groups[test_start:], output_groups[test_start:]
+    test_data = NFLDataset(test_input_groups, test_output_groups, nfl_feature_transformer, shuffle=False)
+    
+    return train_data, test_data
+
+
+
+# %%
+from torch.nn import TransformerEncoder, TransformerEncoderLayer, GRU, Linear, Module, MSELoss, MultiheadAttention, Sequential, Linear, ReLU, Dropout
+from positional_encodings.torch_encodings import PositionalEncoding1D
+
+class SpatialTemporalLayer(Module):
+    def __init__(self, d_model, nhead, spatial_encoder_layers, dropout, in_features):
+
+        super().__init__()
+
+        features_to_predict = 2
+        dim_feedforward = 2*d_model
+       
+        transformer_encoder_layer = TransformerEncoderLayer(d_model=d_model, nhead=nhead, dim_feedforward=dim_feedforward, 
+                                                            dropout=dropout, batch_first=True)
+
+        self.se_input_projection = Linear(in_features = in_features, out_features = d_model)
+        
+        self.spatial_encoder = TransformerEncoder(encoder_layer=transformer_encoder_layer,enable_nested_tensor=False, num_layers=spatial_encoder_layers)
+        
+        self.temporal_encoder = GRU(input_size=d_model, hidden_size=d_model, num_layers=1, batch_first=True)
+        self.temporal_decoder = GRU(input_size=features_to_predict, hidden_size=d_model, num_layers=1, batch_first=True)
+        self.td_output_projection = Linear(in_features = d_model, out_features = features_to_predict)
+
+        self.cross_attn = MultiheadAttention(embed_dim=d_model, num_heads=nhead, batch_first=True)
+        self.gate = Linear(2 * d_model, d_model)
+
+        self.mlp = Sequential(
+                            Linear(d_model, 2*d_model),
+                            ReLU(),
+                            Linear(2*d_model, 2*d_model),
+                            ReLU(),
+                            Linear(2*d_model, 1)
+                )
+
+        self.mse_loss = MSELoss(reduction='mean')
+        self.sum_se = MSELoss(reduction='sum')
+
+        self.pos_enc = PositionalEncoding1D(d_model)
+        
+
+    #x must be [P, T, din] T-> time in a play_id , P --> number of players of that play_id, din --> input_feature
+    #y must be in [P, T, 2]
+    def forward(self, x, y, predict_bool, num_output):
+
+        #converts to d_model
+        x_projected = self.se_input_projection(x)
+
+        time_encodings = self.pos_enc(x_projected)
+        x_encodings_added = time_encodings + x_projected
+
+        x_permuted = x_encodings_added.permute(1, 0, 2)
+        
+        se_output = self.spatial_encoder(x_permuted)
+
+        predict_players_x = x_projected[predict_bool, :, :]
+        
+        no_players = predict_players_x.shape[0]
+        d_model = predict_players_x.shape[2]
+        time = predict_players_x.shape[1]
+        
+        hidden_state = torch.zeros(1, no_players, d_model, device=predict_players_x.device)
+        for t in range(time):
+            query = predict_players_x[:,t, :]
+            key = se_output[t, :,:]
+            value = se_output[t, :,:]
+            
+            cross_attn_output = self.cross_attn(query, key, value, need_weights=False)[0].unsqueeze(0)
+
+            combined = torch.cat([hidden_state, cross_attn_output], dim=-1)   
+            g = torch.sigmoid(self.gate(combined))
+
+            hidden_state = g * hidden_state + (1 - g) * cross_attn_output
+
+            gru_output, hidden_state = self.temporal_encoder(predict_players_x[:,t:t+1, :], hidden_state)
+           
+        time_expanded_state = gru_output.repeat(1, num_output, 1)
+        encodings = self.pos_enc(time_expanded_state)
+        encodings_added = time_expanded_state + encodings
+
+        preds = self.mlp(encodings_added)
+       
+        preds_reshaped = preds.reshape(-1, 1)
+        preds_detached=preds_reshaped.detach()
+
+        if y is None:
+            return preds_detached
+        
+        actual_reshaped = y.reshape(-1, 1)
+        
+        return self.mse_loss(preds_reshaped, actual_reshaped), self.sum_se(preds_reshaped, actual_reshaped), preds_detached
+
+def checkpoint_state(epoch, model, optimizer, checkpoint_dir):
+    directory = checkpoint_dir
+    checkpoint = {'model_state': model.state_dict(), 'optimizer_state': optimizer.state_dict()}
+
+    new_file_name = f'checkpoint-{epoch}.pt'
+    old_file_name = f'checkpoint-{epoch - 1}.pt'
+
+    # flush previous checkpoints
+    for item in os.listdir(directory):
+        item_path = os.path.join(directory, item)
+        if os.path.isfile(item_path) and item.startswith('checkpoint-') and item != old_file_name:
+            os.remove(item_path)
+
+    file_path = os.path.join(directory, new_file_name)
+
+    torch.save(checkpoint, file_path)
+
+def setup_state_from_checkpoint(model, optimizer, checkpoint_dir, best_model_checkpoint_loc, device='cuda'):
+    latest_epoch = -1
+    directory = checkpoint_dir
+    for item in os.listdir(directory):
+        item_path = os.path.join(directory, item)
+        if os.path.isfile(item_path) and item.startswith('checkpoint-'):
+            epoch = int(item.removeprefix('checkpoint-').removesuffix('.pt'))
+            latest_epoch = max(epoch, latest_epoch)
+
+    if latest_epoch == -1:
+        print('no existing checkpoint found')
+        return 0, math.inf
+
+    print(f'resuming states with {latest_epoch} checkpoint')
+    checkpoint_pt = torch.load(os.path.join(directory, f'checkpoint-{latest_epoch}.pt'), map_location=device)
+    model.load_state_dict(checkpoint_pt['model_state'])
+    if 'optimizer_state' in checkpoint_pt:
+        optimizer.load_state_dict(checkpoint_pt['optimizer_state'], )
+
+    best_val = 0
+    if os.path.isfile(best_model_checkpoint_loc):
+        ckpt = torch.load(best_model_checkpoint_loc)
+        best_val = ckpt['best_val']
+
+    return latest_epoch + 1, best_val
+
+def scale_features(std_scaler, X):
+    p, t, din = X.shape[0], X.shape[1], X.shape[2]
+    X_reshaped = X.reshape(p * t, din)
+    X_scaled = std_scaler.transform(X_reshaped).reshape(p, t, din)
+    return torch.tensor(X_scaled, dtype=torch.float32)
+
+
+import math
+class ValidationDatasetMetric:
+
+    def __init__(self, model, validation_dataset, std_scaler, model_type = ModelType.DX_MODEL):
+        self.model = model
+        self.validation_dataset = validation_dataset
+        self.std_scaler = std_scaler
+        self.model_type = model_type
+        batch_size = 1
+        self.validation_dataset_dataloader = DataLoader(validation_dataset, batch_size=batch_size, pin_memory=True, in_order=False)
+
+    def get_metrics(self):
+        
+        self.model.eval()
+        self.model.to('cuda')
+
+        loop = tqdm(self.validation_dataset_dataloader, total=len(self.validation_dataset_dataloader), desc=f"validating {self.model_type}")
+
+        se_sum = 0
+        instances = 0
+        with torch.no_grad():
+            for (x, y, predict_bool, num_output) in loop:
+
+                x_ = scale_features(self.std_scaler, x.squeeze(0)).to('cuda')
+
+                if self.model_type == ModelType.DX_MODEL:
+                    y_ = y[0,:,:,0]
+                else:
+                    y_ = y[0,:,:,1]
+
+                y_ = torch.as_tensor(y_, dtype=torch.float32, device='cuda')
+                predict_bool_ = torch.tensor(predict_bool, device='cuda')
+                num_output_ = int(num_output.item())
+
+                output = self.model(x_, y_, predict_bool_, num_output_)
+
+                se_sum+= output[1].item()
+                instances+=y_.numel()
+                
+                del output
+
+        mse = (se_sum / instances)
+        rmse = math.sqrt(mse)
+        return mse, rmse, se_sum, instances
+    
+    
+
+    def evaluate(self):
+        avg_mse, avg_rmse, se_sum, instances = self.get_metrics()
+        return {'valid_mse': avg_mse , 'valid_rmse': avg_rmse, 'se_sum':se_sum, 'instances' : instances}
+
+
+
+
+
+from torch.utils.data import DataLoader
+import time
+from torch.nn.utils import clip_grad_norm_
+from tqdm import tqdm
+import math
+
+class Runner:
+
+    def __init__(self, model, train_data, test_data, std_scaler, model_type = ModelType.DX_MODEL, lr=5e-5, wd=1e-4):
+        
+
+        batch_size = 1
+        self.train_data_loader = DataLoader(train_data, batch_size=batch_size, pin_memory=True, in_order=False)
+        self.model = model
+
+        self.std_scaler = std_scaler
+
+        self.validation_dataset_metric = ValidationDatasetMetric(self.model, test_data, std_scaler, model_type=model_type)
+
+        self.model_type = model_type
+
+        if self.model_type == ModelType.DX_MODEL:
+            self.best_model_checkpoint_loc = BEST_DX_MODEL_CHECKPOINT
+            self.checkpoint_dir = DX_CHECKPOINT_DIR
+        else:
+            self.best_model_checkpoint_loc = BEST_DY_MODEL_CHECKPOINT
+            self.checkpoint_dir = DY_CHECKPOINT_DIR
+
+        self.trainable_params = []
+        for _, param in self.model.named_parameters():
+            self.trainable_params.append(param)
+
+        self.optimizer = torch.optim.AdamW(self.trainable_params, lr=lr, weight_decay=wd)
+
+
+
+    def run(self):
+
+        resume = False
+        new_lr = 1e-5
+        self.model.to('cuda')
+        
+        if resume:
+            start_epoch, best_val = setup_state_from_checkpoint(self.model, self.optimizer, self.checkpoint_dir, self.best_model_checkpoint_loc)
+            for param_group in self.optimizer.param_groups:
+                param_group['lr'] = new_lr
+        else:
+             start_epoch = 0
+             best_val = math.inf
+
+        end_epoch = start_epoch + 10
+        for epoch in range(start_epoch, end_epoch):
+
+            loop = tqdm(self.train_data_loader, total=len(self.train_data_loader), desc=f"Epoch {epoch}")
+            start = time.perf_counter()
+
+            se_sum = 0
+            instances = 0
+            step = 0
+            for (x, y, predict_bool, num_output) in loop:
+                    
+                x_ = scale_features(self.std_scaler, x.squeeze(0)).to('cuda')
+                if self.model_type == ModelType.DX_MODEL:
+                    y_ = y[0,:,:,0]
+                else:
+                    y_ = y[0,:,:,1]
+
+                y_ = torch.as_tensor(y_, dtype=torch.float32, device='cuda')
+                predict_bool_ = torch.tensor(predict_bool, device='cuda')
+        
+                num_output_ = int(num_output.item())
+                
+                output = self.model(x_, y_, predict_bool_, num_output_)
+                
+                se_sum+= output[1].item()
+        
+                instances+=y_.numel()
+                
+                mse_loss = output[0]
+                mse_loss.backward()
+
+                gradient_before_clipping = clip_grad_norm_(self.trainable_params, max_norm=1, foreach=True)
+                self.optimizer.step()
+                self.optimizer.zero_grad()
+
+       
+                loop.set_postfix({
+                    'gradient': gradient_before_clipping.item(),
+                    'step': step,
+                    'loss': mse_loss.item(),
+                    'learning_rates': '[' + ','.join(
+                        [str(param_group['lr']) for param_group in self.optimizer.state_dict()['param_groups']]) + ']'
+                    }
+                )
+
+                
+                step += 1
+
+                del output, mse_loss, x_, y_, predict_bool_
+
+                
+            mse = se_sum / instances
+            rmse = math.sqrt(mse)
+            metrics = self.validation_dataset_metric.evaluate()
+            valid_mse = metrics['valid_mse']
+            valid_rmse = metrics['valid_rmse']
+            
+            score = valid_rmse
+            if score < best_val:
+                torch.save({'model_state': self.model.state_dict(), 'best_val': score}, self.best_model_checkpoint_loc)
+                best_val = score
+
+            end = time.perf_counter()
+            print(f'{{ step {step} train_avg_mse: {mse}, train_avg_rmse : {rmse} \n valid_avg_mse: {valid_mse} valid_avg_rmse:{valid_rmse} took {end - start:.3f} seconds}}')
+            checkpoint_state(epoch, self.model, self.optimizer, self.checkpoint_dir)
+            self.model.train()
+            se_sum = 0
+            instances = 0
+
+def train(model, train_data, test_data, std_scaler, model_type = ModelType.DX_MODEL):
+    runner = Runner(model, train_data, test_data, std_scaler, model_type, lr=1e-4, wd=1e-4)
+    runner.run()
+
+def evaluate_metrics(dx_model, dy_model, test_data, std_scaler):
+   
+    dx_checkpoint_pt = torch.load(BEST_DX_MODEL_CHECKPOINT, map_location='cpu')
+    dx_model.load_state_dict(dx_checkpoint_pt['model_state'])
+    
+    dx_validation_dataset_metric = ValidationDatasetMetric(dx_model, test_data, std_scaler, model_type=ModelType.DX_MODEL)
+    dx_metrics = dx_validation_dataset_metric.evaluate()
+
+    dy_checkpoint_pt = torch.load(BEST_DY_MODEL_CHECKPOINT, map_location='cpu')
+    dy_model.load_state_dict(dy_checkpoint_pt['model_state'])
+
+    dy_validation_dataset_metric = ValidationDatasetMetric(dy_model, test_data, std_scaler, model_type=ModelType.DY_MODEL)
+    dy_metrics = dy_validation_dataset_metric.evaluate()
+
+    total_se_sum = dx_metrics['se_sum'] + dy_metrics['se_sum']
+    total_instances = dx_metrics['instances'] + dy_metrics['instances']
+    avg_mse = total_se_sum / total_instances if total_instances > 0 else 0
+    avg_rmse = math.sqrt(avg_mse)
+
+    avg_rmse_x = np.sqrt(dx_metrics['se_sum'] / dx_metrics['instances'])
+    avg_rmse_y = np.sqrt(dy_metrics['se_sum'] / dy_metrics['instances'])
+    print(f'model rmse on the test dataset on dx {avg_rmse_x}')
+    print(f'model rmse on the test dataset on dy {avg_rmse_y}')
+    print(f'model rmse on test dataset: {avg_rmse}')
+
+def predict(dx_model, dy_model, test_data, std_scaler):
+    
+    dx_checkpoint_pt = torch.load(BEST_DX_MODEL_CHECKPOINT, map_location='cpu')
+    dx_model.load_state_dict(dx_checkpoint_pt['model_state'])
+    
+    dy_checkpoint_pt = torch.load(BEST_DY_MODEL_CHECKPOINT, map_location='cpu')
+    dy_model.load_state_dict(dy_checkpoint_pt['model_state'])
+
+    dx_model.eval()
+    dx_model.to('cuda')
+
+    dy_model.eval()
+    dy_model.to('cuda')
+
+    n = len(test_data)
+
+    preds = []
+    with torch.no_grad():
+        for t in tqdm(range(n), total=n, desc = 'predict'):
+            input_df = test_data.input_groups[t]
+            output_df = test_data.output_groups[t]
+
+            (x, _, predict_bool, num_output) = test_data[t]
+            x_ = scale_features(std_scaler, x).to('cuda') # type: ignore
+            
+            predict_bool_ = torch.tensor(predict_bool, device='cuda')
+            num_output_ = int(num_output.item())
+
+            dx = dx_model(x_, None, predict_bool_, num_output_)
+
+            dy = dy_model(x_, None, predict_bool_, num_output_)
+            
+            predict_players = input_df[input_df['player_to_predict']]
+            max_frame_id = predict_players['frame_id'].max()
+            predict_players_last_frame = predict_players[predict_players['frame_id'] == max_frame_id]
+
+            predict_players_output_frames = ( predict_players_last_frame.merge(output_df, on=['nfl_id'], how='left')
+                                                    .sort_values(by=['nfl_id', 'frame_id_y']).reset_index(drop=True) 
+                                                )
+            
+            f = 1
+            if predict_players_output_frames['play_direction'].iloc[0] == 'left':
+                f = -1
+
+            pred_x =  predict_players_output_frames['x_x'].values + f*dx[:,0].cpu().numpy()
+            pred_y =  predict_players_output_frames['y_x'].values + dy[:,0].cpu().numpy() 
+
+            game_id = predict_players_output_frames['game_id_x'].values
+            play_id = predict_players_output_frames['play_id_x'].values
+            nfl_id =  predict_players_output_frames['nfl_id'].values
+            frame_id = predict_players_output_frames['frame_id_y'].values
+            player_position = predict_players_output_frames['player_position'].values
+            player_role = predict_players_output_frames['player_role'].values
+            x_last = predict_players_output_frames['x_x'].values
+            y_last = predict_players_output_frames['y_x'].values
+            play_direction = predict_players_output_frames['play_direction'].values
+
+            actual_x = predict_players_output_frames['x_y'].values
+            actual_y = predict_players_output_frames['y_y'].values
+
+            pred_x = np.clip(pred_x, 0.0, 120.0)
+            pred_y = np.clip(pred_y, 0.0, 53.3)
+
+            columns = np.column_stack([game_id, play_id, nfl_id, frame_id, player_position, 
+                          player_role,play_direction,x_last, y_last, actual_x, actual_y, pred_x, pred_y])
+            
+            preds.append(columns)
+                       
+    combined = np.concat(preds, axis=0)
+    df = pd.DataFrame(combined, columns=['game_id', 'play_id', 'nfl_id','frame_id', 'player_position', 
+                                       'player_role','play_direction', 'x_last', 'y_last', 
+                                       'actual_x', 'actual_y', 'pred_x', 'pred_y'])
+    
+    df.to_csv('gru_test_data_results.csv', index=False)
+    print('results published')
+    
+
+
+def train_test():
+    import joblib
+    from sklearn.preprocessing import StandardScaler
+
+    def save_joblib(train_data):
+    
+        def get_x(n):
+            x,_,_,_ = train_data[n]
+            p = x.shape[0]
+            t = x.shape[1] 
+            din = x.shape[2]
+
+            print(n)
+            return x.reshape(p*t, din)
+        
+        percentage_of_sample = 0.02
+        sample_n = int(len(train_data)*percentage_of_sample)
+        sample_range = range(sample_n)
+        with ThreadPoolExecutor(max_workers = 12) as executor:
+                all_x = executor.map(get_x, sample_range)
+                combined_x = np.concat(list(all_x),axis=0)
+        
+        std_scaler = StandardScaler()
+        std_scaler.fit(combined_x)
+        
+        joblib.dump(std_scaler, JOBLIB_FILE_PATH)
+        return std_scaler
+
+
+    def load_scaler():
+        return joblib.load(JOBLIB_FILE_PATH)
+
+
+    print('loading dataframes...')
+    input_df, output_df = get_input_output_df()
+
+    print('splitting train test...')
+    nfl_feature_transformer = NFLFeatureTransformer()
+    train_data, test_data = split_train_test(input_df, output_df, nfl_feature_transformer, 0.02)
+
+
+    if not os.path.isfile(JOBLIB_FILE_PATH):
+        print('fitting scaler and saving joblib...')
+        std_scaler = save_joblib(train_data)
+    else:
+        print('loading scaler from joblib...')
+        std_scaler = load_scaler()
+
+
+    dx_model = SpatialTemporalLayer(d_model=128, nhead=8, spatial_encoder_layers=2, dropout=0.0, in_features=len(MODEL_INPUT_FEATURES))
+    dy_model = SpatialTemporalLayer(d_model=128, nhead=8, spatial_encoder_layers=2, dropout=0.0, in_features=len(MODEL_INPUT_FEATURES))
+
+    print('training models...')
+    # train(dx_model, train_data, test_data,  std_scaler, model_type=ModelType.DX_MODEL)
+    # train(dy_model, train_data, test_data,  std_scaler, model_type=ModelType.DY_MODEL)
+
+    # print('predicting test_data...')
+    # predict(dx_model, dy_model, test_data, std_scaler)
+
+    print('evaluating models...')
+    evaluate_metrics(dx_model, dy_model, test_data, std_scaler)
+
+
+if __name__ == '__main__':
+    train_test()
+
+
+
+
+
+
+

gru_app_predict.py

@@ -0,0 +1,191 @@
+from gru import NFLFeatureTransformer, SpatialTemporalLayer, scale_features, MODEL_INPUT_FEATURES
+from torch.utils.data import Dataset
+import os
+import numpy as np
+import joblib
+import torch
+import pandas as pd
+
+
+class NFLDataset(Dataset):
+    def __init__(self, input_groups, nfl_feature_transformer):
+        self.nfl_feature_transformer = nfl_feature_transformer
+        self.input_groups = input_groups
+        
+        
+    def _get_output_array(self, dx, dy):
+        numpy_array = np.column_stack((dx, dy)).astype(np.float32)
+        return np.expand_dims(numpy_array, axis=1)
+
+    def _get_input_array(self, df):
+        model_input_features = MODEL_INPUT_FEATURES
+        numpy_array = df[model_input_features].to_numpy().astype(np.float32)
+        return np.expand_dims(numpy_array, axis=1)
+
+        
+    def __len__(self):
+        return len(self.input_groups)
+
+    def __getitem__(self, indx):
+        input_df = self.input_groups[indx].copy()
+
+        play_direction = input_df.iloc[0]['play_direction']
+
+        input_df = self.nfl_feature_transformer.reflect_input_coordinates(input_df, play_direction)
+
+        given_frames = input_df['frame_id'].max()
+        output_frames = input_df['num_frames_output'].iloc[0]
+
+        total_frames = given_frames + output_frames
+
+        min_frame_start = max(given_frames - 10, 1)
+        
+        prev_frame = None
+        x = None
+        for f in range(min_frame_start, given_frames+1):
+            
+            grouped_frame = input_df[input_df['frame_id'] == f].sort_values(by=['nfl_id'], ascending=[True]).reset_index(drop=True)
+
+            prev_frame = grouped_frame if prev_frame is None else prev_frame
+            transformed_input_df = self.nfl_feature_transformer.transform_X(grouped_frame, prev_frame, total_frames)
+            input_array = self._get_input_array(transformed_input_df)
+            x = input_array if x is None else np.concat((x, input_array), axis=1)
+            prev_frame = grouped_frame
+        
+        
+        num_output = prev_frame['num_frames_output'].iloc[0] # type: ignore
+        players_to_predict = prev_frame['player_to_predict'].values.tolist() # type: ignore
+
+        return x, players_to_predict, num_output
+    
+    
+
+
+JOBLIB_FILE_PATH = f'gru_scaler.joblib'
+BEST_DX_MODEL_CHECKPOINT = f'cross_attn_best_weight_dx.pt'
+BEST_DY_MODEL_CHECKPOINT = f'cross_attn_best_weight_dy.pt'
+
+BASE_COLS = ['game_id', 'play_id', 'player_to_predict', 'nfl_id', 'frame_id',
+       'play_direction', 'absolute_yardline_number', 'player_name',
+       'player_height', 'player_weight', 'player_birth_date',
+       'player_position', 'player_side', 'player_role', 'x', 'y', 's', 'a',
+       'dir', 'o', 'num_frames_output', 'ball_land_x', 'ball_land_y']
+
+MANDATORY_COLS=['game_id', 'play_id', 'nfl_id']
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+
+nfl_feature_transformer = NFLFeatureTransformer()
+
+std_scaler = joblib.load(JOBLIB_FILE_PATH)
+
+
+dx_model = SpatialTemporalLayer(d_model=128, nhead=8, spatial_encoder_layers=2, dropout=0.0, in_features=len(MODEL_INPUT_FEATURES))
+dy_model = SpatialTemporalLayer(d_model=128, nhead=8, spatial_encoder_layers=2, dropout=0.0, in_features=len(MODEL_INPUT_FEATURES))
+
+dx_checkpoint_pt = torch.load(BEST_DX_MODEL_CHECKPOINT, map_location='cpu')
+dx_model.load_state_dict(dx_checkpoint_pt['model_state'])
+
+dy_checkpoint_pt = torch.load(BEST_DY_MODEL_CHECKPOINT, map_location='cpu')
+dy_model.load_state_dict(dy_checkpoint_pt['model_state'])
+
+
+device = 'cpu'
+
+dx_model.eval()
+dx_model.to(device)
+
+dy_model.eval()
+dy_model.to(device)
+
+def predict(df):
+
+    given_input_cols = set(df.columns)
+    for c in MANDATORY_COLS:
+        if c not in given_input_cols:
+            raise Exception(f'{c} is missing in input')
+        elif df[c].isna().any():
+            raise Exception(f'{c} in input contains nan')
+        
+    
+    for c in BASE_COLS:
+        if c not in df:
+            raise Exception(f'{c} is not there in input')
+        if df[c].isna().all():
+            raise Exception(f'{c} in input contains nan')
+    
+    input_groups = [group for _, group in df.groupby(by=['game_id', 'play_id'], sort=True)]
+    test_data = NFLDataset(input_groups, nfl_feature_transformer)
+    
+    
+    n = len(test_data)
+
+    preds = []
+    with torch.no_grad():
+        for i in range(n):
+
+            df = test_data.input_groups[i]
+
+            (x, predict_bool, num_output) = test_data[i]
+            x_ = scale_features(std_scaler, x).to(device)
+            
+            predict_bool_ = torch.tensor(predict_bool, device=device)
+            num_output_ = int(num_output.item())
+            
+            dx = dx_model(x_, None, predict_bool_, num_output_)
+
+            dy = dy_model(x_, None, predict_bool_, num_output_)
+            
+            predict_players = df[df['player_to_predict']]
+            
+            #this makes sure that last available data is fetched
+            predict_players_last_frame = predict_players.sort_values(by=['frame_id']).groupby(by=['nfl_id'], 
+                                                                                              as_index=False, sort=False).last()
+            
+            num_frames_output = predict_players['num_frames_output'].iloc[0]
+
+            output_frames_n = list(range(1, num_frames_output+1))
+
+            output_frames = pd.DataFrame(output_frames_n, columns=['frame_id'])
+
+
+            predict_players_output_frames = (predict_players_last_frame.merge(output_frames, how='cross')
+                                                    .sort_values(by=['nfl_id', 'frame_id_y']).reset_index(drop=True) 
+                                                )
+            
+            f = 1
+            if predict_players_output_frames['play_direction'].iloc[0] == 'left':
+                f = -1
+
+            pred_x =  predict_players_output_frames['x'].values + f*dx[:,0].cpu().numpy()
+            pred_y =  predict_players_output_frames['y'].values + dy[:,0].cpu().numpy() 
+
+            game_id = predict_players_output_frames['game_id'].values
+            play_id = predict_players_output_frames['play_id'].values
+            nfl_id =  predict_players_output_frames['nfl_id'].values
+            frame_id = predict_players_output_frames['frame_id_y'].values
+            player_position = predict_players_output_frames['player_position'].values
+            player_role = predict_players_output_frames['player_role'].values
+            x_last = predict_players_output_frames['x'].values
+            y_last = predict_players_output_frames['y'].values
+            play_direction = predict_players_output_frames['play_direction'].values
+
+            pred_x = np.clip(pred_x, 0.0, 120.0)
+            pred_y = np.clip(pred_y, 0.0, 53.3)
+
+
+            columns = np.column_stack([game_id, play_id, nfl_id, frame_id, player_position, 
+                          player_role,play_direction,x_last, y_last, pred_x, pred_y])
+            
+            preds.append(columns)
+    
+    combined = np.concat(preds, axis=0)
+    df = pd.DataFrame(combined, columns=['game_id', 'play_id', 'nfl_id','frame_id', 'player_position', 
+                                       'player_role','play_direction', 'x_last', 'y_last', 'pred_x', 'pred_y'])
+    
+    return df.sort_values(by=['game_id', 'play_id', 'nfl_id', 'frame_id'])
+
+
+
+

gru_scaler.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7a742bc33a451acc019b5528661c03576818d62b81849b3a4bcf27d2514af651
+size 2463

lightGBT.py

@@ -0,0 +1,594 @@
+import os
+import pandas as pd
+from concurrent.futures import ThreadPoolExecutor
+from scipy.spatial.distance import cdist
+import numpy as np
+from datetime import date
+import lightgbm as lgb
+
+
+MAXIMUM_X = 120
+MAXIMUM_Y = 53.3
+MAXIMUM_DIS = 131.30
+BASE_COLS = []
+
+#The features s, a represent the spped and acceleration
+#the s and a are calculated from r, where r = <x(t), y(t)>
+#so the function is a vector valued function in terms of time t
+#velocity is given by <x'(t), y'(t)>
+#acceleration is given by <x"(t), y"(t)>
+#the s and a given here are the magnitude of these vectors
+#the absolute yardline number refers to the distance to score endzone of the offense, calculated from the line of scrimmage
+
+BASE_COLS = ['game_id', 'play_id', 'player_to_predict', 'nfl_id', 'frame_id',
+       'play_direction', 'absolute_yardline_number', 'player_name',
+       'player_height', 'player_weight', 'player_birth_date',
+       'player_position', 'player_side', 'player_role', 'x', 'y', 's', 'a',
+       'dir', 'o', 'num_frames_output', 'ball_land_x', 'ball_land_y']
+
+MANDATORY_COLS=['game_id', 'play_id', 'nfl_id']
+
+MODEL_NUMERICAL_INPUTS = ['frame_id', 'absolute_yardline_number', 'player_height',
+       'player_weight', 'x_last', 'y_last', 's', 'a', 'dir',
+       'o', 'num_frames_output', 'ball_land_x', 'ball_land_y', 'x_prev',
+       'y_prev', 'o_prev', 'dir_prev', 's_prev', 'a_prev',
+       'nearest_offense_dis', 'nearest_offense_dis_x', 'nearest_offense_dis_y',
+       'nearest_defense_dis', 'nearest_defense_dis_x', 'nearest_defense_dis_y',
+       'receiver_x', 'receiver_y', 'height', 'velocity_x', 'velocity_y',
+       'acc_x', 'acc_y', 'sin_o', 'cos_o', 'sin_dir', 'cos_dir', 'change_in_x',
+       'change_in_y', 'change_in_s', 'change_in_a', 'change_in_o',
+       'change_in_dir', 'dist_between_ball_land_and_player',
+       'dist_x_between_ball_and_player', 'dist_y_between_ball_and_player',
+       'angle_between_ball_and_dir', 'sin_angle_between_ball_and_dir',
+       'cos_angle_between_ball_and_dir', 'angle_between_ball_and_o',
+       'sin_angle_between_ball_and_o', 'cos_angle_between_ball_and_o',
+       'distance_to_sideline', 'distance_to_receiver',
+       'distance_x_to_receiver', 'distance_y_to_receiver',
+       'angle_between_dir_and_receiver', 'sin_angle_between_dir_and_receiver',
+       'cos_angle_between_dir_and_receiver', 'angle_between_o_and_receiver',
+       'sin_angle_between_o_and_receiver', 'cos_angle_between_o_and_receiver',
+       'time_left', 'required_speed', 'required_velocity_x',
+       'required_velocity_y', 'required_acc_x', 'required_acc_y',
+       'required_speed_diff', 'required_velocity_x_diff',
+       'required_velocity_y_diff', 'required_acc_x_diff',
+       'required_acc_y_diff', 'proj_x_acc', 'proj_y_acc', 'proj_x_velocity',
+       'proj_y_velocity', 'proj_x_acc_diff', 'proj_y_acc_diff',
+       'proj_x_velocity_diff', 'proj_y_velocity_diff', 'player_age']
+                          
+MODEL_CAT_INPUTS = ['player_role']
+
+MODEL_OUTPUTS = ['dx', 'dy']
+
+TRAIN_INPUT_FILE_PATH = 'train_input'
+TRAIN_OUTPUT_FILE_PATH = 'train_output'
+
+
+def get_train_file_paths():
+        
+    def get_output_file(input_filename):
+        return input_filename.replace('input', 'output')
+    
+    input_file_paths = []
+    output_file_paths = []
+    input_files_dir = TRAIN_INPUT_FILE_PATH
+    for w in range(1, 19):
+        input_filename = f'input_2023_w{w:02d}.csv'
+        if  os.path.isfile(f'{input_files_dir}/{input_filename}'):
+            output_filename = get_output_file(input_filename)
+            input_file_path = os.path.join(TRAIN_INPUT_FILE_PATH, input_filename)
+            output_file_path = os.path.join(TRAIN_OUTPUT_FILE_PATH, output_filename)
+            input_file_paths.append(input_file_path)
+            output_file_paths.append(output_file_path)
+        else:
+            raise Exception(f'input file for week {w} does not exist')
+            
+    return (input_file_paths, output_file_paths)
+
+
+def load_file(file_path):
+    return pd.read_csv(file_path)
+    
+def get_input_output_df():
+    input_file_paths, output_file_paths = get_train_file_paths()
+   
+    with ThreadPoolExecutor(max_workers = 8) as executor:
+        input_dfs = executor.map(load_file, input_file_paths)
+        input_df = pd.concat(input_dfs, axis=0)
+
+    with ThreadPoolExecutor(max_workers = 8) as executor:
+        output_dfs = executor.map(load_file, output_file_paths)
+        output_df = pd.concat(output_dfs, axis=0)
+
+    return input_df.reset_index(drop=True), output_df.reset_index(drop=True)
+
+def reflect_input_player_positions(df):
+    mask = df['play_direction'] == 'left'
+    df.loc[mask, 'x'] = 120 - df.loc[mask, 'x']
+    df.loc[mask, 'dir'] = (360 - df.loc[mask, 'dir']) % 360
+    df.loc[mask, 'o'] = (360 - df.loc[mask, 'o']) % 360
+    df.loc[mask, 'ball_land_x'] = 120 - df.loc[mask, 'ball_land_x']
+    return df
+
+def reflect_output_player_positions(df):
+    mask = df['play_direction'] == 'left'
+    df.loc[mask, 'x'] = 120 - df.loc[mask, 'x']
+    return df
+
+
+def add_nearest_dis_info(df):
+    plays =  df.groupby(['game_id', 'play_id'], as_index=False)
+    res = []
+    for _, per_play in plays:
+        per_play = per_play.copy()
+        coords = per_play[['x_last', 'y_last']].to_numpy()
+        if coords.shape[0] == 1:
+            per_play['nearest_offense_dis'] = MAXIMUM_DIS
+            per_play['nearest_defense_dis'] = MAXIMUM_DIS
+            per_play['nearest_offense_dis_x'] = MAXIMUM_DIS
+            per_play['nearest_offense_dis_y'] = MAXIMUM_DIS
+            per_play['nearest_defense_dis_x'] = MAXIMUM_DIS
+            per_play['nearest_defense_dis_y'] = MAXIMUM_DIS
+        else:
+            distance = cdist(coords, coords, metric='euclidean')
+            np.fill_diagonal(distance, MAXIMUM_DIS)
+                
+            offense_indices = (per_play['player_side'] == 'Offense')
+            defense_indices = (per_play['player_side'] == 'Defense')
+                
+            if np.any(offense_indices):
+                per_play.loc[:,['nearest_offense_dis']] = np.min(distance[:,offense_indices], axis=-1)
+                
+                idx = np.argmin(distance[:,offense_indices], axis=-1)
+                per_play.loc[:,['nearest_offense_dis_x']] = coords[offense_indices,][idx,0]
+                per_play.loc[:,['nearest_offense_dis_y']] = coords[offense_indices,][idx,1]
+            else:
+                per_play.loc[:,['nearest_offense_dis']] = MAXIMUM_DIS
+                per_play.loc[:,['nearest_offense_dis_x']] = MAXIMUM_X
+                per_play.loc[:,['nearest_offense_dis_y']] = MAXIMUM_Y
+    
+            if np.any(defense_indices):
+                per_play.loc[:,['nearest_defense_dis']] = np.min(distance[:,defense_indices],axis=-1)
+                
+                idx = np.argmin(distance[:,defense_indices], axis=-1)
+                per_play.loc[:,['nearest_defense_dis_x']] = coords[defense_indices,][idx,0]
+                per_play.loc[:,['nearest_defense_dis_y']] = coords[defense_indices][idx,1]
+            else:
+                per_play.loc[:,['nearest_defense_dis']] = MAXIMUM_DIS
+                per_play.loc[:,['nearest_defense_dis_x']] = MAXIMUM_X
+                per_play.loc[:,['nearest_defense_dis_y']] = MAXIMUM_Y
+        
+        res.append(per_play)
+                
+    return pd.concat(res, axis=0)
+
+
+def add_reciever_info(df):
+    receiver = df.loc[df['player_role'] == 'Targeted Receiver',['game_id', 'play_id', 'x_last', 'y_last']]
+
+    receiver = receiver.rename(columns = {'x_last': 'receiver_x', 'y_last':'receiver_y'})
+
+    #if a play has no targeted receiever we leave with nan
+    return df.merge(receiver, on=['game_id', 'play_id'], how='left')
+
+
+def get_last_frame(df):
+    
+    df_sorted = df.sort_values(['game_id', 'play_id', 'nfl_id', 'frame_id']).reset_index(drop=True)
+    
+    group_by_cols = ['game_id', 'play_id', 'nfl_id']
+
+    feature_cols = ['x', 'y', 'o', 'dir', 's', 'a']
+    
+    df_sorted[[f'{c}_prev' for c in feature_cols]] = df_sorted.groupby(group_by_cols)[feature_cols].shift(1)
+
+    #last() takes non none values from the last possible col
+    #so even if last frame misses a feature , value is taken from the previous available one
+    df_last_frame = df_sorted.groupby(group_by_cols, as_index=False).last()
+
+    df_last_frame = df_last_frame.rename(columns={'x':'x_last', 'y':'y_last'})
+    
+    return df_last_frame
+
+def clean_and_extract_features(df):
+   
+    def convert_to_radians(degrees):
+        return degrees * np.pi / 180
+        
+    def convert_to_degrees(radians):
+        return radians * 180 / np.pi
+
+    def sin(theta):
+        return np.sin(convert_to_radians(theta))
+
+    def cos(theta):
+        return np.cos(convert_to_radians(theta))
+
+    def distance_between_two_points(x1, y1, x2, y2):
+        return np.sqrt((x2 - x1)**2 + (y2 - y1)**2)
+    
+    def angle_between_two_vectors(x1, y1, x2, y2):
+        denom = np.sqrt((x1**2)+(y1**2)) * np.sqrt((x2**2)+(y2**2)) + 1e-6
+        dot = x1*x2 + y1*y2
+        cos_angle = dot / denom
+        cos_angle = np.clip(cos_angle, -1.0, 1.0)
+        angle_in_radians = np.arccos(cos_angle)
+        return convert_to_degrees(angle_in_radians)
+
+    def convert_to_inches(X):
+        splits = X.str.split('-', expand=True)
+        feet = splits.iloc[:,0].astype(np.float32)
+        inches = splits.iloc[:,1].astype(np.float32)
+        return feet * 12 + inches
+
+    #returns the shortest angle when curr = 1degree prev = 359degree, change is 2degree
+    def change_in_angle(curr, prev):
+        return ((curr - prev +180) % 360) - 180
+    
+    df['x_last'] = df['x_last'].bfill().ffill()
+    df['x_prev'] = df['x_prev'].bfill().ffill()
+    df['y_last'] = df['y_last'].bfill().ffill()
+    df['y_prev'] = df['y_prev'].bfill().ffill()
+    df['s'] = df['s'].bfill().ffill()
+    df['s_prev'] = df['s_prev'].bfill().ffill()
+    df['a'] = df['a'].bfill().ffill()
+    df['a_prev'] = df['a_prev'].bfill().ffill()
+    df['dir'] = df['dir'].bfill().ffill()
+    df['dir_prev'] = df['dir_prev'].bfill().ffill()
+    df['o'] = df['o'].bfill().ffill()
+    df['o_prev'] = df['o_prev'].bfill().ffill()
+    df['receiver_x'] = df['receiver_x'].bfill().ffill()
+    df['receiver_y'] = df['receiver_y'].bfill().ffill()
+    df['player_height'] = df['player_height'].bfill().ffill()
+
+    df['velocity_x'] = df['s'] * sin(df['dir'])
+    df['velocity_y'] = df['s'] * cos(df['dir'])
+    df['acc_x'] = df['a'] * sin(df['dir'])
+    df['acc_y'] = df['a'] * cos(df['dir'])
+
+    df['sin_o'] = sin(df['o'])
+    df['cos_o'] = cos(df['o'])
+    
+    df['sin_dir'] = sin(df['dir'])
+    df['cos_dir'] = cos(df['dir'])
+
+    df['change_in_x'] = df['x_last'] - df['x_prev']
+    df['change_in_y'] = df['y_last'] - df['y_prev']
+    df['change_in_s'] = df['s'] - df['s_prev']
+    df['change_in_a'] = df['a'] - df['a_prev']
+    df['change_in_o'] = change_in_angle(df['o'], df['o_prev'])
+    df['change_in_dir'] = change_in_angle(df['dir'], df['dir_prev'])
+    
+    df['dist_between_ball_land_and_player'] = distance_between_two_points(
+        df['x_last'], df['y_last'], df['ball_land_x'], df['ball_land_y']
+    )
+    df['dist_x_between_ball_and_player'] = df['ball_land_x'] - df['x_last']
+    df['dist_y_between_ball_and_player'] = df['ball_land_y'] - df['y_last']
+
+    df['angle_between_ball_and_dir'] = angle_between_two_vectors(
+        df['sin_dir'], df['cos_dir'], df['dist_x_between_ball_and_player'], df['dist_y_between_ball_and_player']
+    )
+
+    df['sin_angle_between_ball_and_dir'] = sin(df['angle_between_ball_and_dir'])
+    df['cos_angle_between_ball_and_dir'] = cos(df['angle_between_ball_and_dir'])
+
+    df['angle_between_ball_and_o'] = angle_between_two_vectors(
+        df['sin_o'], df['cos_o'], df['dist_x_between_ball_and_player'], df['dist_y_between_ball_and_player']
+    )
+    
+    df['sin_angle_between_ball_and_o'] = sin(df['angle_between_ball_and_o'])
+    df['cos_angle_between_ball_and_o'] = cos(df['angle_between_ball_and_o'])
+            
+    df['distance_to_sideline'] = np.minimum(df['y_last'], MAXIMUM_Y - df['y_last'])
+
+    df['player_height'] = convert_to_inches(df['player_height'])
+
+    
+    df['distance_to_receiver'] = distance_between_two_points(df['x_last'], df['y_last'], df['receiver_x'], df['receiver_y'])
+    df['distance_x_to_receiver'] = df['x_last'] - df['receiver_x']
+    df['distance_y_to_receiver'] = df['y_last'] - df['receiver_y']
+    df['angle_between_dir_and_receiver'] = angle_between_two_vectors(
+        df['sin_dir'], df['cos_dir'], df['distance_x_to_receiver'], df['distance_y_to_receiver']
+    )
+
+    df['sin_angle_between_dir_and_receiver'] = sin(df['angle_between_dir_and_receiver'])
+    df['cos_angle_between_dir_and_receiver'] = cos(df['angle_between_dir_and_receiver'])
+
+    df['angle_between_o_and_receiver'] = angle_between_two_vectors(df['sin_o'], df['cos_o'], df['distance_x_to_receiver'], df['distance_y_to_receiver'])
+
+    df['sin_angle_between_o_and_receiver'] = sin(df['angle_between_o_and_receiver'])
+    df['cos_angle_between_o_and_receiver'] = cos(df['angle_between_o_and_receiver'])
+    
+
+    df['time_left'] =  (df['num_frames_output'] - (df['frame_id'] - 1) )/10
+        
+    df['required_speed'] = df['dist_between_ball_land_and_player'] / df['time_left']
+    df['required_velocity_x'] = df['dist_x_between_ball_and_player'] / df['time_left']
+    df['required_velocity_y'] = df['dist_y_between_ball_and_player'] / df['time_left']
+    df['required_acc_x'] = (df['required_velocity_x'] - df['velocity_x']) / df['time_left']
+    df['required_acc_y'] = (df['required_velocity_y'] - df['velocity_y']) / df['time_left']
+
+    df['required_speed_diff'] = df['required_speed'] - df['s']
+    df['required_velocity_x_diff'] = df['required_velocity_x'] - df['velocity_x']
+    df['required_velocity_y_diff'] = df['required_velocity_y'] - df['velocity_y']
+    df['required_acc_x_diff'] = df['required_acc_x'] - df['acc_x']
+    df['required_acc_y_diff'] = df['required_acc_y'] - df['acc_y']
+
+    df['proj_x_acc'] = df['x_last'] + df['velocity_x']*df['time_left'] + 0.5*df['acc_x']*(df['time_left']**2)
+    df['proj_y_acc'] = df['y_last'] + df['velocity_y']*df['time_left'] + 0.5*df['acc_y']*(df['time_left']**2)
+
+    df['proj_x_velocity'] = df['x_last'] + df['velocity_x']*df['time_left']
+    df['proj_y_velocity'] = df['y_last'] + df['velocity_y']*df['time_left']
+
+    df['proj_x_acc_diff'] = df['ball_land_x'] - df['proj_x_acc']
+    df['proj_y_acc_diff'] = df['ball_land_y'] - df['proj_y_acc']
+
+    df['proj_x_velocity_diff'] = df['ball_land_x'] - df['proj_x_velocity']
+    df['proj_y_velocity_diff'] = df['ball_land_y'] - df['proj_y_velocity']
+
+    year = date.today().year
+    s = pd.to_datetime(df['player_birth_date'])
+    df['player_age'] = year - s.dt.year
+
+    df['absolute_yardline_number'] = np.clip(df['absolute_yardline_number'], 0, 100.0)
+
+    return df
+
+def get_train_df(input_df, output_df):
+    input_df = input_df.copy()
+    input_df = reflect_input_player_positions(input_df)
+
+    output_df = output_df.copy()
+    
+    df_last_frame = get_last_frame(input_df)
+    df_last_frame = add_nearest_dis_info(df_last_frame)
+    df_last_frame = add_reciever_info(df_last_frame)
+    
+    cols = ['game_id', 'play_id', 'nfl_id', 'absolute_yardline_number', 'player_height', 'player_weight', 'player_birth_date',
+            'play_direction','player_position', 'player_role', 'x_last', 'y_last', 's', 'a', 'dir', 'o', 'num_frames_output', 'ball_land_x', 
+            'ball_land_y', 'x_prev', 'y_prev', 'o_prev', 'dir_prev', 's_prev', 'a_prev', 'nearest_offense_dis', 'nearest_offense_dis_x', 
+            'nearest_offense_dis_y', 'nearest_defense_dis', 'nearest_defense_dis_x', 'nearest_defense_dis_y', 'receiver_x', 'receiver_y']
+    
+    df_last_frame = df_last_frame[cols]
+    
+    df_merged = output_df.merge(df_last_frame, on=['game_id', 'play_id', 'nfl_id'], how='left')
+
+    df_merged = reflect_output_player_positions(df_merged)
+    
+    X_df = clean_and_extract_features(df_merged)
+
+    X_df['player_role'] = X_df['player_role'].astype('category')
+
+    dx = X_df['x'] - X_df['x_last']
+    dy = X_df['y'] - X_df['y_last']
+    Y_df = pd.DataFrame({'dx' : dx, 'dy' :dy})
+
+    return X_df, Y_df
+
+def get_train_valid_split(X_df, Y_df, test_ratio=0.2):
+    tr = X_df.shape[0]
+    test_s = int(tr*(1-test_ratio))
+    X_df_train = X_df[:test_s]
+    Y_df_train = Y_df[:test_s]
+
+    X_df_valid = X_df[test_s:]
+    Y_df_valid = Y_df[test_s:]
+
+    return X_df_train, Y_df_train, X_df_valid, Y_df_valid
+
+def create_output_frames(df):
+    num_frames = df['num_frames_output'].iloc[0]
+    frame_id = pd.Series(np.arange(1, num_frames+1), name='frame_id')
+    return df.merge(frame_id, how='cross')
+
+def get_params(is_pred=True):
+    
+    params = {
+                'task':'train', 
+                'objective':'regression', 
+                'bagging_freq' : 1,
+                'bagging_fraction' : 0.75,
+                'learning_rate' : 0.05,
+                'device_type' : 'gpu',
+                'num_threads':8,
+                'n_estimators':2000,
+                'seed' : 42,
+                'max_depth':80,
+                'max_leaves' : 100,
+                'min_data_in_leaf' : 200,
+                'feature_fraction' : 0.80,
+                'lambda_l1' : 0.5,
+                'lambda_l2' : 0.5,
+                'early_stopping_rounds' : 100,
+                'early_stopping_min_delta' : 0.001,
+                'verbose':-1,
+                'metric' :'rmse'
+             }
+    
+    if is_pred:
+        params['task'] = 'predict'
+
+    return params
+
+def get_test_df(input_df):
+    df = input_df.copy()
+    
+    df = reflect_input_player_positions(df)
+    df_last_frame = get_last_frame(df)
+    df_last_frame = add_nearest_dis_info(df_last_frame)
+    df_last_frame = add_reciever_info(df_last_frame)
+    
+    df_last_frame = df_last_frame[df_last_frame['player_to_predict']].reset_index(drop=True)
+    
+    num_frames_output = df_last_frame['num_frames_output'].values
+
+    df_with_output_frames = df_last_frame.loc[df_last_frame.index.repeat(num_frames_output)]
+
+    df_with_output_frames['frame_id'] =  df_with_output_frames.groupby(level=0).cumcount() + 1
+
+    X_df = clean_and_extract_features(df_with_output_frames.reset_index(drop=True))
+
+    X_df['player_role'] = X_df['player_role'].astype('category')
+
+    return X_df
+
+def calculate_rmse(X_df, Y_df, dx_train, dy_train):
+
+    dx_features = dx_train.feature_name()
+    dy_features = dy_train.feature_name()
+
+
+    pred_dx = dx_train.predict(X_df[dx_features])
+    pred_dy = dy_train.predict(X_df[dy_features])
+
+    n = Y_df.size
+    residual = (pred_dx - Y_df['dx'])**2 + (pred_dy - Y_df['dy'])**2
+
+    residual_avg = np.sum(residual) / n
+
+    return np.sqrt(residual_avg)
+
+def publish_results(X_df, Y_df, dx_model, dy_model):
+    
+    dx_features = dx_model.feature_name()
+    dy_features = dy_model.feature_name()
+
+    pred_dx = dx_model.predict(X_df[dx_features])
+    pred_dy = dy_model.predict(X_df[dy_features])
+    
+    game_id = X_df['game_id'].values
+    play_id = X_df['play_id'].values
+    nfl_id =  X_df['nfl_id'].values
+    frame_id = X_df['frame_id'].values
+    player_position = X_df['player_position'].values
+    player_role = X_df['player_role'].values
+    x_last = X_df['x_last'].values
+    y_last = X_df['y_last'].values
+    actual_x = X_df['x'].values
+    actual_y = X_df['y'].values
+    play_direction = X_df['play_direction'].values
+
+    pred_x = pred_dx + x_last
+    pred_y = pred_dy + y_last
+
+    mask = (play_direction == 'left')
+
+    if np.any(mask):
+        pred_x[mask] =  120 - pred_x[mask]
+        actual_x[mask] = 120 - actual_x[mask] 
+
+    pred_x = np.clip(pred_x, 0.0, 120.0)
+    pred_y = np.clip(pred_y, 0.0, 53.3)
+  
+
+    preds = np.column_stack([game_id, play_id, nfl_id, frame_id, player_position, 
+                    player_role, play_direction, x_last, y_last, actual_x, actual_y, pred_x, pred_y])
+    
+        
+    df = pd.DataFrame(preds, columns=['game_id', 'play_id', 'nfl_id','frame_id', 'player_position', 
+                                    'player_role','play_direction', 
+                                    'x_last', 'y_last', 'actual_x', 'actual_y', 'pred_x', 'pred_y'])
+    
+    df.to_csv('lightGBT_test_data_results.csv', index=False)
+    print('results published')
+    
+
+def train(input_df, output_df):
+    given_input_cols = set(input_df.columns)
+    for c in MANDATORY_COLS:
+        if c not in given_input_cols:
+            raise Exception(f'{c} is missing in input_df')
+        elif input_df[c].isna().any():
+            raise Exception(f'{c} in input_df contains nan')
+        
+    
+    given_output_cols = set(output_df.columns)
+    for c in MANDATORY_COLS:
+        if c not in given_output_cols:
+            raise Exception(f'{c} is missing in output_df')
+        elif output_df[c].isna().any():
+            raise Exception(f'{c} in output_df contains nan')
+    
+    for c in BASE_COLS:
+        if c not in input_df.columns:
+            input_df[c] = np.nan
+    
+    print('getting train_df, valid_df')
+    X_df, Y_df = get_train_df(input_df, output_df)
+    
+    
+    print('splitting train test')
+    X_train_df, Y_train_df, X_valid_df, Y_valid_df = get_train_valid_split(X_df, Y_df, test_ratio=0.05)
+
+    filt_cols = ['player_birth_date', 'x', 'y', 'game_id', 'play_id', 'nfl_id', 'play_direction', 'player_position']
+    X_train_filt_df = X_train_df.drop(columns=filt_cols)
+    X_valid_filt_df = X_valid_df.drop(columns=filt_cols)
+    
+    print('training started')
+    train_set_dx = lgb.Dataset(data=X_train_filt_df, label=Y_train_df['dx'])
+    train_sub_set_dx = lgb.Dataset(data=X_train_filt_df[:50000], label=Y_train_df['dx'][:50000], reference=train_set_dx)
+    valid_set_dx = lgb.Dataset(data=X_valid_filt_df, label=Y_valid_df['dx'], reference=train_set_dx)
+    
+    train_set_dy = lgb.Dataset(data=X_train_filt_df, label=Y_train_df['dy'])
+    train_sub_set_dy = lgb.Dataset(data=X_train_filt_df[:50000], label=Y_train_df['dy'][:50000], reference=train_set_dy)
+    valid_set_dy = lgb.Dataset(data=X_valid_filt_df, label=Y_valid_df['dy'], reference=train_set_dy)
+    
+    params = get_params(False)
+    
+    dx_model = lgb.train(params = params, 
+                     train_set=train_set_dx, 
+                     valid_sets=[train_sub_set_dx, valid_set_dx],
+                     valid_names=['train', 'valid'],
+                     callbacks=[
+                         lgb.log_evaluation(period=10)
+                     ]
+                    )
+
+    dy_model = lgb.train(params = params, 
+                         train_set=train_set_dy, 
+                         valid_sets=[train_sub_set_dy, valid_set_dy], 
+                         valid_names=['train', 'valid'],
+                         callbacks=[
+                               lgb.log_evaluation(period=10) 
+                         ]
+                        )
+
+    publish_results(X_valid_df, Y_valid_df, dx_model, dy_model)
+
+    train_rmse = calculate_rmse(X_train_df, Y_train_df, dx_model, dy_model)
+    valid_rmse = calculate_rmse(X_valid_df, Y_valid_df, dx_model, dy_model)
+
+    print(f'rmse on the training set is :{train_rmse}')
+    print(f'rmse on the validation set is :{valid_rmse}')
+    return dx_model, dy_model
+
+def get_features_by_importance(model):
+    sort_index = np.argsort(-model.feature_importance(importance_type='gain'))
+    return np.array(model.feature_name())[sort_index]
+
+
+def train_test():
+    print('started')
+
+    input_df, output_df = get_input_output_df()
+
+    print('fetched input and output')
+
+    dx_model, dy_model = train(input_df, output_df)
+
+    dx_model.save_model('lightGBT_dx_model.txt', num_iteration=dx_model.best_iteration)
+    print('model lightGBT_dx_model saved')
+
+    dy_model.save_model('lightGBT_dy_model.txt', num_iteration=dy_model.best_iteration)
+    print('model lightGBT_dy_model saved')
+
+    dx_model_feature_importance = get_features_by_importance(dx_model)
+    dy_model_feature_importance = get_features_by_importance(dy_model)
+
+    print(f'top 15 features for dx_model: {dx_model_feature_importance[:15]}')
+    print(f'top 15 features for dy_model: {dy_model_feature_importance[:15]}')
+
+if __name__ == '__main__':
+    train_test()
+
+
+

lightGBT_app_predict.py

@@ -0,0 +1,74 @@
+
+from lightGBT import get_test_df
+import lightgbm as lgb
+import numpy as np
+import pandas as pd
+
+dx_model = lgb.Booster(model_file='lightGBT_dx_model.txt')
+dy_model = lgb.Booster(model_file='lightGBT_dy_model.txt')
+
+BASE_COLS = ['game_id', 'play_id', 'player_to_predict', 'nfl_id', 'frame_id',
+       'play_direction', 'absolute_yardline_number', 'player_name',
+       'player_height', 'player_weight', 'player_birth_date',
+       'player_position', 'player_side', 'player_role', 'x', 'y', 's', 'a',
+       'dir', 'o', 'num_frames_output', 'ball_land_x', 'ball_land_y']
+
+MANDATORY_COLS=['game_id', 'play_id', 'nfl_id']
+
+def predict(df):
+    given_input_cols = set(df.columns)
+    for c in MANDATORY_COLS:
+        if c not in given_input_cols:
+            raise Exception(f'{c} is missing in input')
+        elif df[c].isna().any():
+            raise Exception(f'{c} in input contains nan')
+        
+    
+    for c in BASE_COLS:
+        if c not in df:
+            raise Exception(f'{c} is not there in input')
+        if df[c].isna().all():
+            raise Exception(f'{c} in input contains all nan')
+    
+   
+    X_df = get_test_df(df)
+
+    dx_features = dx_model.feature_name()
+    dy_features = dy_model.feature_name()
+
+    pred_dx = dx_model.predict(X_df[dx_features])
+    pred_dy = dy_model.predict(X_df[dy_features])
+    
+    game_id = X_df['game_id'].values
+    play_id = X_df['play_id'].values
+    nfl_id =  X_df['nfl_id'].values
+    frame_id = X_df['frame_id'].values
+    player_position = X_df['player_position'].values
+    player_role = X_df['player_role'].values
+    x_last = X_df['x_last'].values
+    y_last = X_df['y_last'].values
+    
+    play_direction = X_df['play_direction'].values
+
+    pred_x = pred_dx + x_last
+    pred_y = pred_dy + y_last
+
+    mask = (play_direction == 'left')
+
+    if np.any(mask):
+        pred_x[mask] =  120 - pred_x[mask]
+
+    pred_x = np.clip(pred_x, 0.0, 120.0)
+    pred_y = np.clip(pred_y, 0.0, 53.3)
+  
+
+    preds = np.column_stack([game_id, play_id, nfl_id, frame_id, player_position, 
+                    player_role, play_direction, x_last, y_last, pred_x, pred_y])
+    
+        
+    df = pd.DataFrame(preds, columns=['game_id', 'play_id', 'nfl_id','frame_id', 'player_position', 
+                                    'player_role','play_direction', 
+                                    'x_last', 'y_last', 'pred_x', 'pred_y'])
+    
+    return df.sort_values(by=['game_id', 'play_id', 'nfl_id', 'frame_id'])
+    

lightGBT_dx_model.txt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5186c1e3ca4573bd4a9b9908a597e1c831134e7181cddfef1321e294bc84bdfe
+size 6107979

lightGBT_dy_model.txt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ed6054cfd765fd19c82060a54939bbe709e06f2f6e5c5d2777866892092258d8
+size 9111426

requirements.txt

@@ -0,0 +1,11 @@
+numpy
+pandas
+scikit-learn
+scipy
+lightgbm
+matplotlib
+seaborn
+torch
+tqdm
+positional-encodings
+flask

sample_nfl_plays.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:30076e216d103880823b4e6b4681caad5cff83ee2982547446894b71a9e6dc99
+size 163040

sample_nfl_plays_actual_output.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ab9a9658472ebcaf960aa38e99c93e1e45131016aa3aa3cc283d56251a5f0a8b
+size 6426

train_data_analysis.py

@@ -0,0 +1,239 @@
+
+from collections import Counter
+import numpy as np
+import seaborn as sns
+import matplotlib.pyplot as plt
+import pandas as pd
+from concurrent.futures import ThreadPoolExecutor
+import os
+
+
+TRAIN_INPUT_FILE_PATH = 'C:/Users/vigne/nfl/train_input'
+TRAIN_OUTPUT_FILE_PATH = 'C:/Users/vigne/nfl/train_output'
+
+
+def get_train_file_paths():
+        
+    def get_output_file(input_filename):
+        return input_filename.replace('input', 'output')
+    
+    input_file_paths = []
+    output_file_paths = []
+    input_files_dir = TRAIN_INPUT_FILE_PATH
+    for w in range(1, 19):
+        input_filename = f'input_2023_w{w:02d}.csv'
+        if  os.path.isfile(f'{input_files_dir}/{input_filename}'):
+            output_filename = get_output_file(input_filename)
+            input_file_path = os.path.join(TRAIN_INPUT_FILE_PATH, input_filename)
+            output_file_path = os.path.join(TRAIN_OUTPUT_FILE_PATH, output_filename)
+            input_file_paths.append(input_file_path)
+            output_file_paths.append(output_file_path)
+        else:
+            raise Exception(f'input file for week {w} does not exist')
+            
+    return (input_file_paths, output_file_paths)
+
+def load_file(file_path):
+    return pd.read_csv(file_path)
+    
+def get_input_output_df():
+    input_file_paths, output_file_paths = get_train_file_paths()
+   
+    with ThreadPoolExecutor(max_workers = 8) as executor:
+        input_dfs = executor.map(load_file, input_file_paths)
+        input_df = pd.concat(input_dfs, axis=0)
+
+    with ThreadPoolExecutor(max_workers = 8) as executor:
+        output_dfs = executor.map(load_file, output_file_paths)
+        output_df = pd.concat(output_dfs, axis=0)
+
+    return input_df.reset_index(drop=True), output_df.reset_index(drop=True)
+
+def plot_distribution_of_features(input_df, output_df):
+    predict_players_position = Counter()
+    predict_players_role = Counter()
+    predict_players_side = Counter()
+    
+    num_frames_to_predict = Counter()
+    no_players_prediction_in_a_play = Counter()
+    
+
+    plays = input_df.groupby(['game_id', 'play_id'], as_index = False)
+    
+    per_play_change_in_dists = []
+    per_frame_change_in_dists = []
+    per_frame_change_in_x_dists = []
+    per_frame_change_in_y_dists = []
+    for _, play in plays:
+
+        predict_players = play[play['player_to_predict']]
+        
+        no_players_prediction_in_a_play[predict_players['nfl_id'].nunique()]+=1
+
+        
+        num_frames_output = play['num_frames_output'].iloc[0].item()
+        num_frames_to_predict[num_frames_output]+=1
+        
+        predict_players_last_frame = predict_players.groupby(['nfl_id'], as_index=False).last()
+        for index, p_l in predict_players_last_frame.iterrows():
+            game_id = p_l['game_id']
+            play_id = p_l['play_id']
+            p_nfl_id = p_l['nfl_id']
+            p_output = output_df[(output_df['game_id'] == game_id) & (output_df['play_id'] == play_id) & (output_df['nfl_id'] == p_nfl_id)]
+            
+            
+            s = np.array([p_l['x'], p_l['y']])
+            
+            total_dis = 0
+            for _,p_o in p_output.iterrows():
+                e = np.array([p_o['x'].item(), p_o['y'].item()])
+                current_dis = np.linalg.norm(e - s)
+                per_frame_change_in_dists.append(current_dis)
+                per_frame_change_in_x_dists.append(np.abs(e[0] - s[0]))
+                per_frame_change_in_y_dists.append(np.abs(e[1] - s[1]))
+            
+                total_dis+= current_dis
+                s = e
+    
+            per_play_change_in_dists.append(total_dis)
+    
+    
+            position = p_l['player_position']
+            role = p_l['player_role']
+            side = p_l['player_side']
+            
+            predict_players_position[position]+=1
+            predict_players_role[role]+=1
+            predict_players_side[side]+=1
+            
+    def plot_bargraph(dict_items, name):
+        plt.figure(figsize=(10, 6))
+        df = pd.DataFrame(list(dict_items), columns = [name, 'count'])
+        df = df.sort_values(by='count', ascending=False)
+        sns.barplot(data=df, x=name, y='count')
+        plt.show()
+
+    
+    plot_bargraph(predict_players_position.items(), 'predict_player position')
+    plot_bargraph(predict_players_role.items(), 'predict_player role')
+    plot_bargraph(predict_players_side.items(), 'predict_player side')
+
+    plot_bargraph(no_players_prediction_in_a_play.items(), 'num of player to predict in a play')
+    plot_bargraph(num_frames_to_predict.items(), 'num of frames to predict in a play')
+
+
+    def plot_density_plot(data, title, x):
+        plt.figure(figsize=(10, 6))
+        sns.kdeplot(data, fill=True, color="dodgerblue")
+        plt.title(title)
+        plt.xlabel(x)
+        plt.ylabel('Density')
+        plt.show()
+    
+   
+    plot_density_plot(per_play_change_in_dists, 'total distance moved by a player in a play', 'distance')
+    plot_density_plot(per_frame_change_in_dists, 'distance moved by a player per frame', 'distance')
+    plot_density_plot(per_frame_change_in_x_dists, 'distance moved by a player along x per frame', 'distance')
+    plot_density_plot(per_frame_change_in_y_dists, 'distance moved by a player along y per frame', 'distance')
+
+
+def get_last_frame(df):
+    
+    df_sorted = df.sort_values(['game_id', 'play_id', 'nfl_id', 'frame_id']).reset_index(drop=True)
+    
+    group_by_cols = ['game_id', 'play_id', 'nfl_id']
+
+    feature_cols = ['x', 'y', 'o', 'dir', 's', 'a']
+    
+    df_sorted[[f'{c}_prev' for c in feature_cols]] = df_sorted.groupby(group_by_cols)[feature_cols].shift(1)
+
+    #last() takes non none values from the last possible col
+    #so even if last frame misses a feature , value is taken from the previous available one
+    df_last_frame = df_sorted.groupby(group_by_cols, as_index=False).last()
+
+    df_last_frame = df_last_frame.rename(columns={'x':'x_last', 'y':'y_last'})
+    
+    return df_last_frame
+
+
+def predict_physics_baseline(input_df, output_df):
+
+    def convert_to_radians(degrees):
+        return degrees * np.pi / 180
+
+    def sin(theta):
+        return np.sin(convert_to_radians(theta))
+    
+    def cos(theta):
+        return np.cos(convert_to_radians(theta))
+    
+
+    input_df = input_df.copy()
+    
+    output_df = output_df.copy()
+    
+    df_last_frame = get_last_frame(input_df)
+
+    df_last_frame = df_last_frame[['game_id', 'play_id', 'nfl_id', 'x_last', 'y_last', 'o', 'dir', 's', 'a', 'num_frames_output']]
+    
+    df = output_df.merge(df_last_frame, on=['game_id', 'play_id', 'nfl_id'], how='left')
+
+    sum_ = 0
+    for _, group_df in df.groupby(['game_id', 'play_id', 'nfl_id'], as_index=False):
+
+        group_df = group_df.sort_values('frame_id').reset_index(drop=True)
+
+        prev = (group_df.iloc[0]['x'], group_df.iloc[0]['y'])
+        for row in group_df.itertuples():
+            dt = 0.1
+
+            velocity_x = row.s * sin(row.dir)
+            velocity_y_ = row.s * cos(row.dir)
+            acc_x_ = row.a * sin(row.dir)
+            acc_y_ = row.a * cos(row.dir)
+
+            proj_x = prev[0] + velocity_x*dt + 0.5*acc_x_*(dt**2)
+            proj_y = prev[1] + velocity_y_*dt + 0.5*acc_y_*(dt**2)
+            
+            sum_+= (row.x - proj_x)**2 + (row.y - proj_y)**2
+            prev = (proj_x, proj_y)
+       
+    num_ele = df.shape[0]*2
+    rmse = np.sqrt(sum_ / num_ele)
+    print(f'RMSE of the simple physics based model is {rmse}')
+
+
+input_df, output_df = get_input_output_df()
+POSITION_MAPPING = [
+    "FS --> Free Safety",
+    "SS --> Strong Safety",
+    "CB --> Cornerback",
+    "MLB --> Middle Linebacker",
+    "WR --> Wide Receiver",
+    "TE --> Tight End",
+    "QB --> Quarterback",
+    "OLB --> Outside Linebacker",
+    "ILB --> Inside Linebacker",
+    "RB --> Running Back",
+    "DE --> Defensive End",
+    "FB --> Fullback",
+    "NT --> Nose Tackle",
+    "DT --> Defensive Tackle",
+    "S --> Safety",
+    "T --> Tackle",
+    "LB --> Linebacker",
+    "P --> Punter",
+    "K --> Kicker"
+]
+
+PLAYER_ROLES = ['Defensive Coverage' 'Other Route Runner' 'Passer' 'Targeted Receiver']
+
+PLAYER_SIDES = ['Defense', 'Offense']
+
+print(f'player positions are {POSITION_MAPPING}')
+print(f'player roles are {PLAYER_ROLES}')
+print(f'player roles are {PLAYER_SIDES}')
+
+# plot_distribution_of_features(input_df[:1_000_00], output_df)
+
+predict_physics_baseline(input_df, output_df)