Modeling With NFL Data - A Quick Start Guide in Python

In this notebook, we will familiarize ourselves with weekly player data and design a system to aid in drafting a team for the upcoming season.

The general idea is to train a model that predicts total fantasy points given previous season fantasy data. We can use these predictions to rank players for the upcoming season.

• Data Prep
• Modeling
• Draft

The Notebook can be found here

Data Prep

The first step is to load the CSV containing our data. We will be using the famous pandas package for reading and manipulating data as DataFrames.

import pandas as pd

df = pd.read_csv("../data/draft/player_data.csv")

with pd.option_context("display.max_columns", None):
    display(df)

The dataset contains a row for each player for each week they have played.

There are 106 columns, some are informational (names, IDs, etc.), some are raw numeric player stats, and the rest are the principal components of a more extensive (more comprehensive) dataset.

We want to predict total fantasy points for the season, so we will need to create a column that follows our league rules (PPR, pure yardage, etc.).

For the sake of simplicity, let's stick to regular-season games and previously earned fantasy points. We will also ignore defensive players, offensive linemen, and kickers.

regular_season_df = df[(df["playoffs"] == 0) & 
    ~df["position_id"].isin({"OL",
                            "DEF",
                             "P", 
                             "K"})].
                             reset_index(drop=True)

# how many fantasy points is 1 of each worth
fantasy_weights = {
    "passing_int": -2,
    "passing_yds": 0.04,
    "passing_two_pt_md": 2,
    "passing_td": 4,
    "receiving_yds": 0.1,
    "receiving_td": 6,
    "receiving_rec": 1, # set to 0 for non-PPR
    "rushing_td": 6,
    "rushing_yds": 0.1,
}

def get_fantasy_points(game):
    return sum(game[column] * weight for column, weight in fantasy_weights.items() 
               if not pd.isna(game[column]))

# apply with axis="columns" will apply our fantasy points calculation 
# to each row in the DataFrame
regular_season_df["fantasy_points"] = regular_season_df.apply(
                                        get_fantasy_points, axis="columns")

regular_season_df = regular_season_df[
                    ["player_id", "name", "position_id", "season", "fantasy_points"]
                    ]

We now have the rows and columns we care about, but weekly. To make season level predictions, we will need to aggregate our features by season. Let's compute the seasonal average and total for the fantasy_points column.

seasonal_df = regular_season_df.groupby(
["player_id", "name", "position_id", "season"]).sum()
seasonal_df = seasonal_df.reset_index()
seasonal_df

We can explore the target distribution by position.

import matplotlib.pyplot as plt

seasonal_df.hist("fantasy_points", by="position_id", figsize=(8, 8))
plt.show()

Modeling

The model we are building is called an autoregressive model. It predicts future values based on past values. In our case, that means predicting next year's total fantasy points with one or more past season totals.

We will add several past season averages and totals (or "lags") to each row.

lag_features = ["fantasy_points"]
for lag in range(1, 6):
    shifted = seasonal_df.groupby("player_id").shift(lag)
    seasonal_df = seasonal_df.assign(**{f"lag_{column}_{lag}": shifted[column] 
                          for column in lag_features})
seasonal_df = seasonal_df.fillna(-1)
seasonal_df

We now have all the data we need for modeling. To fairly evaluate our future model, we must split the data into train and test sets.

We will use the 2018 and 2019 seasons for testing.

train_df = seasonal_df[seasonal_df["season"] < 2018].reset_index(drop=True)
test_df = seasonal_df[seasonal_df["season"] >= 2018].reset_index(drop=True)

We can look at the correlation plot to determine how many lags should be included in the model.

import seaborn as sns

sns.heatmap(train_df.corr()[["fantasy_points"]], annot=True)
plt.show()

As expected, the correlation decays as we look back at past seasons dropping below significance (~0.5) after ~2 seasons.

Let's define a simple modeling pipeline.

First, we need to import modules from scikit-learn (sklearn). sklearn includes a wealth of out-of-the-box machine learning algorithms with consistent interfaces for training and prediction.

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import ElasticNet
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import mean_absolute_error

We will use two previous seasons' fantasy points as features to our model. This is based on the correlation computed from before.

features = [
    "lag_fantasy_points_1", 
    "lag_fantasy_points_2", 
]

The Pipeline class is an abstraction that allows us to compose preprocessing and predictive algorithms to ensure consistent handling of train and test data.

Our pipeline will center and scale our inputs and feed them into a regularized Linear Regression.

pipeline = Pipeline([
    ("scaler", StandardScaler()),
    ("lr", ElasticNet())
])

The next step defines a grid search over a couple of regularization parameters controlling the strength of regularization as well as the type of regularization.

The grid search will ensure we find the best model to fit our data.

param_grid = {
    "lr__alpha": [0.001, 0.01, 0.1, 1, 10], # regularization strength
    "lr__l1_ratio": [0.1, 0.2, 0.5, 0.8, 0.9, 1.0] # type of regulariztion
}
grid = GridSearchCV(pipeline, 
                    n_jobs=-1,
                    param_grid=param_grid, 
                    scoring="neg_mean_absolute_error")
grid.fit(train_df[features], train_df["fantasy_points"])

print(f"Found best parameters: {grid.best_params_}")

Found best parameters: {'lr__alpha': 0.001, 'lr__l1_ratio': 1.0}

Finally, we can evaluate the trained model. We compare the train and test metrics to ensure we have not overfit to our training data.

train_mae = mean_absolute_error(train_df["fantasy_points"]
                                ,grid.predict(train_df[features]))

test_df["predicted_fantasy_points"] = grid.predict(test_df[features])
test_mae = mean_absolute_error(test_df["fantasy_points"]
                                ,test_df["predicted_fantasy_points"])

print(f"train mae: {train_mae}, test mae: {test_mae}")

train mae: 45.242530437086366, test mae: 45.825492952668036

The value of 45.8 indicates that, on average, we are ~46 points off (+-) the actual value.

Draft

All that's left to do is sort our test DataFrame by our predicted fantasy points and group by position.

Here we can see the top 10 projected players by position for the 2019 season.

draft_df = test_df[test_df["season"] == 2019].sort_values("predicted_fantasy_points"
                                                            , ascending=False)
positions, position_dfs = zip(*draft_df.groupby("position_id"))

rows = [{} for _ in range(10)]
for position, position_df in draft_df.groupby("position_id"):
    for i, (_, player) in enumerate(position_df.head(10).iterrows()):
        rows[i][position] = player["name"]
        rows[i][f"{position}_predicted"] = player["predicted_fantasy_points"]
        rows[i][f"{position}_points"] = player["fantasy_points"]

pd.DataFrame(rows)

We haven't accounted for injury (Ben Roethlisberger) or controversy (Antonio Brown) in this model. This shows that the real world is full of variables outside of our control, and model results should be considered informed guesses and not always taken at face value.

Other Gridironers have experimented with more complex models capable of quantifying uncertainty in predictions, which can hopefully allow us to begin accounting for the randomness inherent in these kinds of problems.

Next Steps

This is a straightforward model meant to get you up and running on your own. Other things that may be useful include

• Use raw features instead of (or in addition to) the simple autoregressive model may allow the model to exploit more granular patterns.
• Different features may be more useful in predicting performance for certain positions -- it may be worth experimenting with position-specific models.
• Linear regression and its variants are straightforward models, try other algorithms (random forests, gradient boosted trees, neural networks) to get a better sense of latent signal in the data.
• Players can have a meaningful effect on each other's fantasy performance, consider adding things like QB stats to receiver predictions.
• Rookies are left out of this ranking since they have no previous seasons in the NFL. What kind of dataset could we use to build a rookie model?
• We don't care about the raw number of points scored, but rather the ranking. There are models optimized for this specific use case.