diff --git a/README.md b/README.md
index d2c65b5..40602f7 100644
--- a/README.md
+++ b/README.md
@@ -56,6 +56,7 @@ Then I would train the model on all the games I can on a game-by-game basis. So
- could be useful for comparing the accuracy of my model. in particular "Distribution of the deviation of the final margin of victory from the Vegas spread"
- for example, perhaps avg spread difference between vegas and reality is ~10 so a model with an average difference of 8 would be good
- a concise little overview on features from a datascience.exchange comment about predicting matches (NOTE: not spread): https://datascience.stackexchange.com/questions/102827/how-to-predict-the-winner-of-a-future-sports-match
+- article on when you need to scale data for ml: https://www.baeldung.com/cs/normalization-vs-standardization
# TODO:
@@ -89,6 +90,18 @@ score differential is wrong? look at first game. the number for the 2 teams dont
- gradient boosting (better with non-linear)?
- [x] some sort of basic analysis to see how it performed. including manually comparing to vegas spread (maybe I can find an average difference? https://www.theonlycolors.com/2020/9/29/21492301/vegas-always-knows-a-mathematical-deep-dive)
- 9-10 pt avg difference (?). normaly distrubution means ~68% will be within 1 std deviation (identified as 14-15). could be a little lower because 1,2, etc. are within 14-15, but could be higher because ~32% will be more than 14-15.
+- [x] add function to create matchups from 2 teams so we can predict next week's games.
+ - using the running_avg df to merge, similar to how we're merging the game_id to get the final training df
+ - in practice the merged records should share a week but in theory they could be different (week 12 detroit vs. week 6 ravens etc.).
+- [x] cli
+ - [x] download data
+ - [x] train model
+ - what to do with it? save configuration then recreate it when needed? pickle?
+ - [x] predict spread
+- [ ] github workflow
+ - [ ] periodically update the data (and release?)
+ - [ ] periodically train the model (and release? what? the configuration... as what filetype? json?)
+ - [ ] periodically get upcoming games and make predictions. publish on github pages. get booky spread too?
- [ ] improve features/model. either at game aggregation level or team @ week aggregation level
- [ ] W/L record or games played and win pct? (win and loss column on game aggregation)
- [ ] success rate (calculate success (0 or 1) from each play).
@@ -97,9 +110,11 @@ score differential is wrong? look at first game. the number for the 2 teams dont
- [x] total points scored/allowed
- [ ] maybe dont use first ~3 games? small sample size but dont want to throw out too much data.
- [ ] games played (could be used as confidence in record/stats)
-- [x] add function to create matchups from 2 teams so we can predict next week's games.
- - using the running_avg df to merge, similar to how we're merging the game_id to get the final training df
- - in practice the merged records should share a week but in theory they could be different (week 12 detroit vs. week 6 ravens etc.).
+- [ ] rethink exposing build_running_avg_dataframe, build_training_dataframe instead of doing that inside train_model (with side effect of saving the build_running_avg_dataframe (to disk?) somewhere).
+ - just need to see how its actually used
+ - I guess its good for development purposes? maybe just make the df arg in train_model(df) optional and build from ground up if not provided which will be used in cli/deployment but developing can pass it df? idk
+- [ ] write script that gets upcoming games and makes prediction from model.
+ - try to find a good source for the schedule (nflfastR for that too maybe?).
# Current status:
@@ -123,6 +138,29 @@ score differential is wrong? look at first game. the number for the 2 teams dont
# Stray thoughts:
+- model name idea: caliper. (like measuring the "spread")
+- save model by pickeling with joblib/dump or save the configuration like:
+
+```python
+ # Save essential components (assumes linreg - does it work the same for others?)
+ coefficients = model.coef_
+ intercept = model.intercept_
+ # assumes using minmaxscaler (but maybe im not)
+ scaler_params = {'min_values': scaler.min_, 'scale_values': scaler.scale_}
+
+ # Recreate the model
+ recreated_model = LinearRegression()
+ recreated_model.coef_ = coefficients
+ recreated_model.intercept_ = intercept
+
+ # Recreate the scaler
+ recreated_scaler = MinMaxScaler()
+ recreated_scaler.min_ = scaler_params['min_values']
+ recreated_scaler.scale_ = scaler_params['scale_values']
+```
+
+- I think saving the configuration is probably better if I can.
+
- What should the model's be guess _exactly_ and what does that say about how the teams are modeled in the input? the spread consists of 2 numbers (usually the inverse of each). 1 for each team. Maybe just predict the hometeam?
- probably need to squash 2 teams into 1 line like: home_team_pass_off, home_team_pass_def, away_team_pass_off, away_team_pass_def, etc.
- Are lots of features bad? What about redundant or mostly redundant features (pass yards, rush yards, total yards (total yards are either equal or very similar to pass+rush yards)). Which should I pick in that case (probably the less aggregated ones)?
diff --git a/nfl_analytics/assets/trained_model.joblib b/nfl_analytics/assets/trained_model.joblib
new file mode 100644
index 0000000..4df8b1a
Binary files /dev/null and b/nfl_analytics/assets/trained_model.joblib differ
diff --git a/nfl_analytics/assets/trained_scaler.joblib b/nfl_analytics/assets/trained_scaler.joblib
new file mode 100644
index 0000000..0fd9fb7
Binary files /dev/null and b/nfl_analytics/assets/trained_scaler.joblib differ
diff --git a/nfl_analytics/config.py b/nfl_analytics/config.py
new file mode 100644
index 0000000..01b025f
--- /dev/null
+++ b/nfl_analytics/config.py
@@ -0,0 +1,53 @@
+DATA_DIR = "data"
+ASSET_DIR = "assets"
+START_YEAR = 1999
+FEATURES = [
+ "away_rushing_avg",
+ "home_rushing_avg",
+ "away_passing_avg",
+ "home_passing_avg",
+ "away_sack_yards_avg",
+ "home_sack_yards_avg",
+ "away_score_differential_post_avg",
+ "home_score_differential_post_avg",
+ "away_points_scored_avg",
+ "home_points_scored_avg",
+ "away_points_allowed_avg",
+ "home_points_allowed_avg",
+ "away_mean_epa_avg",
+ "home_mean_epa_avg",
+]
+TEAMS = [
+ "WAS",
+ "ARI",
+ "BUF",
+ "NYJ",
+ "ATL",
+ "CAR",
+ "CIN",
+ "CLE",
+ "NYG",
+ "DAL",
+ "DET",
+ "KC",
+ "CHI",
+ "GB",
+ "BAL",
+ "HOU",
+ "IND",
+ "JAX",
+ "SEA",
+ "LA",
+ "LV",
+ "DEN",
+ "MIA",
+ "LAC",
+ "PHI",
+ "NE",
+ "PIT",
+ "SF",
+ "MIN",
+ "TB",
+ "NO",
+ "TEN",
+]
diff --git a/nfl_analytics/data.py b/nfl_analytics/data.py
index 7795aae..5f855c5 100644
--- a/nfl_analytics/data.py
+++ b/nfl_analytics/data.py
@@ -1,32 +1,65 @@
+"""
+Handles fetching and loading the play by play data. Essentially,
+everything before tranforming it.
+"""
+
import urllib.request
+from urllib.error import HTTPError
import os
-import pandas as pd
import sqlite3
+import pandas as pd
-def get():
- years = range(1999, 2024)
+from nfl_analytics.config import DATA_DIR
- save_directory = "data"
- os.makedirs(save_directory, exist_ok=True)
+
+def download_data(years=range(1999, 2024)):
+ os.makedirs(DATA_DIR, exist_ok=True)
for year in years:
# year gets parsed from this filename and depends on this format
filename = f"play_by_play_{year}.csv.gz"
url = f"https://github.com/nflverse/nflverse-data/releases/download/pbp/{filename}"
- save_path = os.path.join(save_directory, filename)
+ save_path = os.path.join(DATA_DIR, filename)
print(f"Downloading {url}")
- urllib.request.urlretrieve(url, save_path)
+
+ try:
+ urllib.request.urlretrieve(url, save_path)
+ except HTTPError as e:
+ print(
+ f"Error: Failed to download data for {year}. HTTP Error {e.code}: {e.reason}. Season for that year may not exist yet."
+ )
-def load_pandas():
+def load_dataframe():
script_dir = os.path.dirname(os.path.abspath(__file__))
- data_directory = os.path.join(script_dir, "data")
+ data_directory = os.path.join(script_dir, DATA_DIR)
+ if not os.path.exists(data_directory):
+ raise FileNotFoundError(f"Data directory '{data_directory}' not found.")
+
+ files = os.listdir(data_directory)
+
+ if not files:
+ raise FileNotFoundError(f"No data files found in the data directory.")
+
+ # This wont pick on updated data (downlaoded new data but still have combined, so it will use that)
+ # # load saved combined from disk if exists
+ # combined_file_path = os.path.join(
+ # data_directory, "combined", "play_by_play_combined.parquet.gzip"
+ # )
+ # if not skip_combined and os.path.exists(combined_file_path):
+ # print(f"Reading combined file {combined_file_path}")
+ # combined_df = pd.read_parquet(combined_file_path)
+ # return combined_df
+ # else:
+ # print("Combined file does not exist. Loading individual files.")
+
+ # make combined dataframe from individual files
combined_df = pd.DataFrame()
- for filename in os.listdir(data_directory):
+ for filename in files:
if filename.endswith(".csv.gz"):
print(f"Reading {filename}")
file_path = os.path.join(data_directory, filename)
@@ -37,6 +70,9 @@ def load_pandas():
df["year"] = year
combined_df = pd.concat([combined_df, df], ignore_index=True)
+ if combined_df.empty:
+ raise FileNotFoundError("No data loaded from the files.")
+
return combined_df
@@ -46,12 +82,14 @@ def get_year_from_filename(filename):
def load_sqlite():
+ db_dir = "/tmp/nfl-analytics.db"
# load into pandas first and use to_sql to infer datatypes
- df = load_pandas()
+ df = load_dataframe()
+
+ print(f"Loading into SQLite database: {db_dir}")
table_name = "plays"
- db_conn = sqlite3.connect(database="/tmp/nfl-analytics.db")
- # TODO: remove drop table after developing?
+ db_conn = sqlite3.connect(database=db_dir)
db_conn.execute(f"DROP TABLE IF EXISTS {table_name}")
df.to_sql(table_name, db_conn, index=False)
@@ -59,30 +97,6 @@ def load_sqlite():
print(cursor.fetchall())
-# def build():
-# # TODO: do all the things the dev notebook is doing. splitting into nice functions as necessary
-# # For example, could make a function for each time in notebook we are initializing a new dataframe (just a rough guide).
-# pass
-
-
-class Pipeline:
- def __init__(self, debug=False):
- self.debug = debug
- # self.df = pd.DataFrame()
-
- def _fetch_play_by_play(self, years=range(1999, 2024)):
- pass
-
- def _load(self):
- pass
-
- def _build(self):
- pass
-
- # def stuffthatbuildcalls (so I can run in the dev notebook)
- # if debug: true, print stuff
-
-
if __name__ == "__main__":
- get()
+ download_data()
load_sqlite()
diff --git a/nfl_analytics/dataframes.py b/nfl_analytics/dataframes.py
new file mode 100644
index 0000000..70d461e
--- /dev/null
+++ b/nfl_analytics/dataframes.py
@@ -0,0 +1,233 @@
+"""
+Builds the dataframes used for training and prediction.
+Handles everything between getting the data and training/using the model.
+"""
+
+from nfl_analytics.data import load_dataframe
+import pandas as pd
+
+
+def build_training_dataframe(df_running_avg=None):
+ if df_running_avg is None:
+ df_running_avg = build_running_avg_dataframe()
+
+ # Create a new column 'is_home' to indicate whether the team is playing at home
+ df_running_avg["is_home"] = df_running_avg.apply(
+ lambda row: True if row["team"] == row["home_team"] else False, axis=1
+ )
+
+ # Group by game_id and is_home and aggregate using the first value
+ squashed_df = (
+ df_running_avg.groupby(["game_id", "is_home"])[
+ [
+ "rushing_avg",
+ "passing_avg",
+ "yards_gained_avg",
+ "sack_yards_avg",
+ "passing_yards_defense_avg",
+ "rushing_yards_defense_avg",
+ "yards_gained_defense_avg",
+ "sack_yards_defense_avg",
+ "score_differential_post_avg",
+ "points_scored_avg",
+ "points_allowed_avg",
+ "mean_epa_avg",
+ ]
+ ]
+ .first()
+ .unstack()
+ )
+
+ squashed_df.columns = [
+ f"{'home' if is_home else 'away'}_{col}" for col, is_home in squashed_df.columns
+ ]
+ squashed_df.reset_index(inplace=True)
+
+ # Merge with the original DataFrame to get the rest of the columns
+ return pd.merge(
+ df_running_avg[
+ [
+ "game_id",
+ "week",
+ "year",
+ "team",
+ "home_team",
+ "away_team",
+ "home_spread",
+ ]
+ ],
+ squashed_df,
+ on="game_id",
+ )
+
+
+def build_running_avg_dataframe(df_raw=None):
+ """
+ Builds a dataframe with weakly running averages for each team by year.
+ Used to create prediction inputs and build the training dataset
+ """
+ if df_raw is None:
+ df_raw = load_dataframe()
+
+ df_sacks = add_sack_yards(df_raw)
+ # df_game is team games stats by team: week 1, DET, 250 pass, 120 run, etc.
+ df_game_posteam = df_sacks.groupby(["game_id", "posteam"])
+ df_game = aggregate_game_stats(df_sacks, df_game_posteam)
+ df_game = adjust_game_dataframe(df_game, df_game_posteam)
+ df_running_avg = df_game[
+ [
+ "game_id",
+ "team",
+ "week",
+ "year",
+ "home_team",
+ "away_team",
+ "score_differential_post",
+ ]
+ ].copy()
+
+ # Set the home_spread
+ # This will be our target variable. It's the spread relative to the home team. We want this because we need to predict a single spread value (which we can then invert for the away team's spread).
+ df_running_avg["home_spread"] = df_game.apply(
+ lambda row: -row["score_differential_post"]
+ if row["team"] != row["home_team"]
+ else row["score_differential_post"],
+ axis=1,
+ )
+
+ # Get the running average for each team by team and year
+ # Uses lambda and shift to not include current row in running average
+ # Expand is an expanding window function that gets everything from the first to current row
+ df_running_avg[
+ [
+ "rushing_avg",
+ "passing_avg",
+ "yards_gained_avg",
+ "sack_yards_avg",
+ "passing_yards_defense_avg",
+ "rushing_yards_defense_avg",
+ "yards_gained_defense_avg",
+ "sack_yards_defense_avg",
+ "score_differential_post_avg",
+ "points_scored_avg",
+ "points_allowed_avg",
+ "mean_epa_avg",
+ ]
+ ] = (
+ df_game.groupby(["team", "year"])[
+ [
+ "rushing_yards",
+ "passing_yards",
+ "yards_gained",
+ "sack_yards",
+ "passing_yards_defense",
+ "rushing_yards_defense",
+ "yards_gained_defense",
+ "sack_yards_defense",
+ "score_differential_post",
+ "points_scored",
+ "points_allowed",
+ "mean_epa",
+ ]
+ ]
+ .apply(lambda x: x.shift().expanding().mean())
+ .reset_index(level=[0, 1], drop=True)
+ )
+
+ return df_running_avg
+
+
+def add_sack_yards(df_raw):
+ df = df_raw.copy()
+ # Sack yards would be necessary to get accurate TEAM passing stats.
+ # Team passing yards are sum(passing_yards) - sum(sack_yards)
+ # Player passing stats are simply sum(passing_yards).
+ df["sack_yards"] = pd.NA
+
+ # Set sack_yards to yards_gained for rows where sack is not equal to 0
+ df.loc[df["sack"] != 0, "sack_yards"] = df["yards_gained"]
+
+ return df
+
+
+def aggregate_game_stats(df_sacks, df_game_posteam):
+ # Group by game and team and combine offensive and defensive stats into single record
+
+ # Separate offensive and defensive stats
+ offensive_stats = (
+ df_game_posteam[
+ ["passing_yards", "rushing_yards", "yards_gained", "sack_yards"]
+ ]
+ .sum()
+ .reset_index()
+ )
+ defensive_stats = (
+ df_sacks.groupby(["game_id", "defteam"])[
+ ["passing_yards", "rushing_yards", "yards_gained", "sack_yards"]
+ ]
+ .sum()
+ .reset_index()
+ )
+
+ # Rename columns for defensive stats to distinguish them
+ defensive_stats.rename(
+ columns={
+ "defteam": "team",
+ "passing_yards": "passing_yards_defense",
+ "rushing_yards": "rushing_yards_defense",
+ "yards_gained": "yards_gained_defense",
+ "sack_yards": "sack_yards_defense",
+ },
+ inplace=True,
+ )
+
+ return pd.merge(
+ offensive_stats,
+ defensive_stats,
+ left_on=["game_id", "posteam"],
+ right_on=["game_id", "team"],
+ )
+
+
+def adjust_game_dataframe(df_game, df_game_posteam):
+ df = df_game.copy()
+
+ # Add home_team, away_team, home_score, away_score
+ df[["home_team", "away_team", "home_score", "away_score"]] = (
+ df_game_posteam[["home_team", "away_team", "home_score", "away_score"]]
+ .first()
+ .reset_index(drop=True)
+ )
+
+ df["points_scored"] = df.apply(
+ lambda row: row["home_score"]
+ if row["posteam"] == row["home_team"]
+ else row["away_score"],
+ axis=1,
+ )
+ df["points_allowed"] = df.apply(
+ lambda row: row["away_score"]
+ if row["posteam"] == row["home_team"]
+ else row["home_score"],
+ axis=1,
+ )
+
+ df.drop(["posteam"], axis=1, inplace=True)
+
+ # sets score differential to last value for each game and team
+ df[["score_differential_post", "week", "year"]] = (
+ df_game_posteam[["score_differential_post", "week", "year"]]
+ .last()
+ .reset_index(drop=True)
+ )
+
+ df["mean_epa"] = df_game_posteam["epa"].mean().reset_index(drop=True)
+
+ return df
+
+
+if __name__ == "__main__":
+ df_running_avg = build_running_avg_dataframe()
+ print(df_running_avg.tail())
+ df_train = build_training_dataframe()
+ print(df_train.tail())
diff --git a/nfl_analytics/data_dev.ipynb b/nfl_analytics/dev_notebook.ipynb
similarity index 91%
rename from nfl_analytics/data_dev.ipynb
rename to nfl_analytics/dev_notebook.ipynb
index edccb38..fa6ad43 100644
--- a/nfl_analytics/data_dev.ipynb
+++ b/nfl_analytics/dev_notebook.ipynb
@@ -7,17 +7,17 @@
},
{
"cell_type": "code",
- "execution_count": 1,
+ "execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
- "from nfl_analytics.data import load_pandas\n",
+ "from nfl_analytics.data import load_dataframe\n",
"import pandas as pd"
]
},
{
"cell_type": "code",
- "execution_count": 2,
+ "execution_count": 3,
"metadata": {},
"outputs": [
{
@@ -29,494 +29,13 @@
"Reading play_by_play_2006.csv.gz\n",
"Reading play_by_play_2014.csv.gz\n",
"Reading play_by_play_2020.csv.gz\n",
- "Reading play_by_play_2016.csv.gz\n",
- "Reading play_by_play_2008.csv.gz\n",
- "Reading play_by_play_2004.csv.gz\n",
- "Reading play_by_play_2000.csv.gz\n",
- "Reading play_by_play_2012.csv.gz\n",
- "Reading play_by_play_2010.csv.gz\n",
- "Reading play_by_play_2002.csv.gz\n",
- "Reading play_by_play_2007.csv.gz\n",
- "Reading play_by_play_2019.csv.gz\n",
- "Reading play_by_play_2015.csv.gz\n",
- "Reading play_by_play_2023.csv.gz\n",
- "Reading play_by_play_2009.csv.gz\n",
- "Reading play_by_play_2017.csv.gz\n",
- "Reading play_by_play_2005.csv.gz\n",
- "Reading play_by_play_2021.csv.gz\n",
- "Reading play_by_play_1999.csv.gz\n",
- "Reading play_by_play_2001.csv.gz\n",
- "Reading play_by_play_2013.csv.gz\n",
- "Reading play_by_play_2011.csv.gz\n",
- "Reading play_by_play_2003.csv.gz\n"
+ "Reading play_by_play_2016.csv.gz\n"
]
- },
- {
- "data": {
- "text/html": [
- "\n",
- "\n",
- "
\n",
- " \n",
- " \n",
- " | \n",
- " play_id | \n",
- " game_id | \n",
- " old_game_id | \n",
- " home_team | \n",
- " away_team | \n",
- " season_type | \n",
- " week | \n",
- " posteam | \n",
- " posteam_type | \n",
- " defteam | \n",
- " ... | \n",
- " home_opening_kickoff | \n",
- " qb_epa | \n",
- " xyac_epa | \n",
- " xyac_mean_yardage | \n",
- " xyac_median_yardage | \n",
- " xyac_success | \n",
- " xyac_fd | \n",
- " xpass | \n",
- " pass_oe | \n",
- " year | \n",
- "
\n",
- " \n",
- " \n",
- " \n",
- " | 0 | \n",
- " 1 | \n",
- " 2022_01_BAL_NYJ | \n",
- " 2022091107 | \n",
- " NYJ | \n",
- " BAL | \n",
- " REG | \n",
- " 1 | \n",
- " NaN | \n",
- " NaN | \n",
- " NaN | \n",
- " ... | \n",
- " 1 | \n",
- " 0.000000 | \n",
- " NaN | \n",
- " NaN | \n",
- " NaN | \n",
- " NaN | \n",
- " NaN | \n",
- " NaN | \n",
- " NaN | \n",
- " 2022 | \n",
- "
\n",
- " \n",
- " | 1 | \n",
- " 43 | \n",
- " 2022_01_BAL_NYJ | \n",
- " 2022091107 | \n",
- " NYJ | \n",
- " BAL | \n",
- " REG | \n",
- " 1 | \n",
- " NYJ | \n",
- " home | \n",
- " BAL | \n",
- " ... | \n",
- " 1 | \n",
- " -0.443521 | \n",
- " NaN | \n",
- " NaN | \n",
- " NaN | \n",
- " NaN | \n",
- " NaN | \n",
- " NaN | \n",
- " NaN | \n",
- " 2022 | \n",
- "
\n",
- " \n",
- " | 2 | \n",
- " 68 | \n",
- " 2022_01_BAL_NYJ | \n",
- " 2022091107 | \n",
- " NYJ | \n",
- " BAL | \n",
- " REG | \n",
- " 1 | \n",
- " NYJ | \n",
- " home | \n",
- " BAL | \n",
- " ... | \n",
- " 1 | \n",
- " 1.468819 | \n",
- " NaN | \n",
- " NaN | \n",
- " NaN | \n",
- " NaN | \n",
- " NaN | \n",
- " 0.440373 | \n",
- " -44.037291 | \n",
- " 2022 | \n",
- "
\n",
- " \n",
- " | 3 | \n",
- " 89 | \n",
- " 2022_01_BAL_NYJ | \n",
- " 2022091107 | \n",
- " NYJ | \n",
- " BAL | \n",
- " REG | \n",
- " 1 | \n",
- " NYJ | \n",
- " home | \n",
- " BAL | \n",
- " ... | \n",
- " 1 | \n",
- " -0.492192 | \n",
- " 0.727261 | \n",
- " 6.988125 | \n",
- " 6.0 | \n",
- " 0.60693 | \n",
- " 0.227598 | \n",
- " 0.389904 | \n",
- " 61.009598 | \n",
- " 2022 | \n",
- "
\n",
- " \n",
- " | 4 | \n",
- " 115 | \n",
- " 2022_01_BAL_NYJ | \n",
- " 2022091107 | \n",
- " NYJ | \n",
- " BAL | \n",
- " REG | \n",
- " 1 | \n",
- " NYJ | \n",
- " home | \n",
- " BAL | \n",
- " ... | \n",
- " 1 | \n",
- " -0.325931 | \n",
- " NaN | \n",
- " NaN | \n",
- " NaN | \n",
- " NaN | \n",
- " NaN | \n",
- " 0.443575 | \n",
- " -44.357494 | \n",
- " 2022 | \n",
- "
\n",
- " \n",
- "
\n",
- "
5 rows × 373 columns
\n",
- "
\n",
- "\n",
- "
\n",
- " \n",
- " \n",
- " | \n",
- " game_id | \n",
- " old_game_id | \n",
- " year | \n",
- " week | \n",
- " posteam | \n",
- "
\n",
- " \n",
- " \n",
- " \n",
- " | 0 | \n",
- " 2022_01_BAL_NYJ | \n",
- " 2022091107 | \n",
- " 2022 | \n",
- " 1 | \n",
- " NaN | \n",
- "
\n",
- " \n",
- " | 1 | \n",
- " 2022_01_BAL_NYJ | \n",
- " 2022091107 | \n",
- " 2022 | \n",
- " 1 | \n",
- " NYJ | \n",
- "
\n",
- " \n",
- " | 2 | \n",
- " 2022_01_BAL_NYJ | \n",
- " 2022091107 | \n",
- " 2022 | \n",
- " 1 | \n",
- " NYJ | \n",
- "
\n",
- " \n",
- " | 3 | \n",
- " 2022_01_BAL_NYJ | \n",
- " 2022091107 | \n",
- " 2022 | \n",
- " 1 | \n",
- " NYJ | \n",
- "
\n",
- " \n",
- " | 4 | \n",
- " 2022_01_BAL_NYJ | \n",
- " 2022091107 | \n",
- " 2022 | \n",
- " 1 | \n",
- " NYJ | \n",
- "
\n",
- " \n",
- " | 5 | \n",
- " 2022_01_BAL_NYJ | \n",
- " 2022091107 | \n",
- " 2022 | \n",
- " 1 | \n",
- " NYJ | \n",
- "
\n",
- " \n",
- " | 6 | \n",
- " 2022_01_BAL_NYJ | \n",
- " 2022091107 | \n",
- " 2022 | \n",
- " 1 | \n",
- " NYJ | \n",
- "
\n",
- " \n",
- " | 7 | \n",
- " 2022_01_BAL_NYJ | \n",
- " 2022091107 | \n",
- " 2022 | \n",
- " 1 | \n",
- " BAL | \n",
- "
\n",
- " \n",
- " | 8 | \n",
- " 2022_01_BAL_NYJ | \n",
- " 2022091107 | \n",
- " 2022 | \n",
- " 1 | \n",
- " BAL | \n",
- "
\n",
- " \n",
- " | 9 | \n",
- " 2022_01_BAL_NYJ | \n",
- " 2022091107 | \n",
- " 2022 | \n",
- " 1 | \n",
- " BAL | \n",
- "
\n",
- " \n",
- "
\n",
- "
\n",
- "\n",
- "
\n",
- " \n",
- " \n",
- " | \n",
- " | \n",
- " epa | \n",
- "
\n",
- " \n",
- " | year | \n",
- " posteam | \n",
- " | \n",
- "
\n",
- " \n",
- " \n",
- " \n",
- " | 1999 | \n",
- " ARI | \n",
- " -0.100310 | \n",
- "
\n",
- " \n",
- " | ATL | \n",
- " -0.073998 | \n",
- "
\n",
- " \n",
- " | BAL | \n",
- " -0.043631 | \n",
- "
\n",
- " \n",
- " | BUF | \n",
- " -0.014478 | \n",
- "
\n",
- " \n",
- " | CAR | \n",
- " 0.059887 | \n",
- "
\n",
- " \n",
- " | ... | \n",
- " ... | \n",
- " ... | \n",
- "
\n",
- " \n",
- " | 2023 | \n",
- " SEA | \n",
- " 0.015927 | \n",
- "
\n",
- " \n",
- " | SF | \n",
- " 0.119782 | \n",
- "
\n",
- " \n",
- " | TB | \n",
- " -0.007973 | \n",
- "
\n",
- " \n",
- " | TEN | \n",
- " -0.031331 | \n",
- "
\n",
- " \n",
- " | WAS | \n",
- " -0.084474 | \n",
- "
\n",
- " \n",
- "
\n",
- "
797 rows × 1 columns
\n",
- "