predicting_nba_games.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "## Predicting NBA Games and Gathering Data with Machine Learning and Python"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "34fc876d43184fdb"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# import libraries\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import TimeSeriesSplit\n",
    "from sklearn.feature_selection import SequentialFeatureSelector\n",
    "from sklearn.linear_model import RidgeClassifier\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.metrics import accuracy_score"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "17413718318892ea"
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Read In NBA Data"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "48464eac34d3c6b2"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# read in data\n",
    "nba_df = pd.read_csv(\"nba_games.csv\", index_col=0)\n",
    "\n",
    "# sort values based on data\n",
    "nba_df = nba_df.sort_values('date')\n",
    "nba_df = nba_df.reset_index(drop=True)"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "a776495a1ca89413"
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Delete Extraneous Columns"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "1ffe96231ca6c7e2"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# delete desired columns\n",
    "del nba_df[\"mp.1\"]\n",
    "del nba_df[\"mp_opp.1\"]\n",
    "del nba_df[\"index_opp\"]"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "1d55a75ff6aaadae"
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Create a Function which will Add a Target Column"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "9f65105e537c317c"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def target_add(team):\n",
    "    \"\"\"\n",
    "    :param team: current team being looked at\n",
    "    :return: team with updated columns\n",
    "    \"\"\"\n",
    "    \n",
    "    # pull the 'won' column from the next game and pull back one row\n",
    "    team['target'] = team['won'].shift(-1)\n",
    "    return team\n",
    "\n",
    "# call function for each team\n",
    "nba_df = nba_df.groupby(\"team\", group_keys=False).apply(target_add)"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "21a72bc0569fcc34"
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Begin Fixing Dataframe for Training Models"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "9b95fbf131e54136"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# turn NaN values of the target column into 2\n",
    "nba_df['target'][pd.isnull(nba_df['target'])] = 2\n",
    "\n",
    "# turn False values into 0s and True values into 1s for target column\n",
    "nba_df['target'] = nba_df['target'].astype(int, errors=\"ignore\")"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "c3561b46fc7cb140"
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Get Rid of NaN Values"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "bcde402bb55ccd29"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# get nulls\n",
    "null = pd.isnull(nba_df)\n",
    "nulls = null.sum()\n",
    "nulls = nulls[nulls > 0]\n",
    "\n",
    "# check valid columns\n",
    "valid_columns = nba_df.columns[~nba_df.columns.isin(nulls.index)]\n",
    "\n",
    "# copy only the valid columns\n",
    "nba_df = nba_df[valid_columns].copy()"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "fc32eda0557aada0"
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Begin Machine Learning"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "c83c3251bb5cbffb"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# initialize models\n",
    "r = RidgeClassifier(alpha=1)\n",
    "split = TimeSeriesSplit(n_splits=3)\n",
    "\n",
    "# pick 30 features for the model to choose\n",
    "sfs = SequentialFeatureSelector(r, n_features_to_select=30, direction=\"forward\", cv=split)"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "22f8c777a5a4073c"
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Define Columns to Remove"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "74c5cd758c8bfc5"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# get rid of columns which won't be scaled\n",
    "remove_columns = [\"season\", \"date\", \"won\", \"target\", \"team\", \"team_opp\"]\n",
    "\n",
    "# get columns that will be scaled\n",
    "preferred_columns = nba_df.columns[~nba_df.columns.isin(remove_columns)]\n",
    "\n",
    "# define scaler \n",
    "scaler = MinMaxScaler()\n",
    "nba_df[preferred_columns] = scaler.fit_transform(nba_df[preferred_columns])"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "e249d0df4d1403bb"
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Fit the Selector"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "b44c05d690e14279"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# run the feature selector to get the 30 best features from the dataframe\n",
    "sfs.fit(nba_df[preferred_columns], nba_df['target'])"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "20ecd945c7098a47"
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Get Back Predictor Columns that We should be Using"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "afafba40f7fb5cba"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# get back columns\n",
    "best_predictors = list(preferred_columns[sfs.get_support()])"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "f467de3ad0df994f"
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Create Backtest Function"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "735091e26abcf106"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def b_test(data, model, predictors, start=2, step=1):\n",
    "    \"\"\"\n",
    "    Function will split data up to have previous seasons and future seasons and train on \n",
    "    each successive season\n",
    "    \"\"\"\n",
    "    \n",
    "    # list of data frames, where each dataframe is the predictions for single season\n",
    "    predictions = []\n",
    "    \n",
    "    # create list of seasons\n",
    "    seasons = sorted(data['season'].unique())\n",
    "    \n",
    "    # traverse through seasons\n",
    "    for i in range(start, len(seasons), step):\n",
    "        season = seasons[i]\n",
    "        \n",
    "        # all data that comes before current season\n",
    "        train = data[data['season'] < season]\n",
    "        \n",
    "        # current season data\n",
    "        test = data[data['season'] == season]\n",
    "        \n",
    "        # model will make judgments on who wins game\n",
    "        model.fit(train[predictors], train['target'])\n",
    "        \n",
    "        # change from numpy array\n",
    "        pred = model.predict(test[predictors])\n",
    "        pred = pd.Series(pred, index=test.index)\n",
    "        \n",
    "        combined = pd.concat([test['target'], pred], axis=1)\n",
    "        combined.columns = ['actual', 'predicted']\n",
    "        \n",
    "        predictions.append(combined)\n",
    "    \n",
    "    # return the predictions\n",
    "    return pd.concat(predictions)\n",
    "\n",
    "\n",
    "# call function\n",
    "nba_predictions = b_test(nba_df, r, best_predictors)\n",
    "\n",
    "# check to make sure the 2s aren't collected\n",
    "nba_predictions = nba_predictions[nba_predictions['actual'] != 2]"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "c187b2dce937b236"
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Get Accuracy Score for Predictions"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "a59320bfa765a0f8"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# get accuracy score\n",
    "accuracy_score(nba_predictions['actual'], nba_predictions['predicted'])"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "17a0dd95993d41c6"
  },
  {
   "cell_type": "markdown",
   "source": [
    "An alright score, not too bad. "
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "2cf45a7061312bc1"
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Use NBA Team Home Advantage Knowledge to Improve Model"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "5d7df88abd971b22"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# group accuracy by home column\n",
    "nba_df.groupby(\"home\").apply(lambda x: x[x['won'] == 1].shape[0] / x.shape[0])"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "ec07c0fd0f0d109d"
  },
  {
   "cell_type": "markdown",
   "source": [
    "There is somewhat of an advantage for playing at home, as seen by the 57% winning percentage"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "a2f91b0fa1d94c7e"
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Creating a Dataframe for Rolling Averages"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "d75f6ff1e9f6a617"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# create a rolling dataframe\n",
    "nba_df_rolling = nba_df[list(preferred_columns) + [\"won\", \"team\", \"season\"]]"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "9bda5b4be9adcdb"
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Write a Function that Gets Rolling Team Averages"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "707e0dc0f27ba27e"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def team_averages(team):\n",
    "    \"\"\"\n",
    "    :param team: current team looking at\n",
    "    :return: rolling dataframe for team\n",
    "    \"\"\"\n",
    "    \n",
    "    rolling = team.rolling(10).mean()\n",
    "    return rolling\n",
    "\n",
    "# overwrite by grouping based upon team and season \n",
    "nba_df_rolling = nba_df_rolling.groupby([\"team\", \"season\"], group_keys=False).apply(team_averages)"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "f0b9575a068bc3c8"
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Remove NaN Values from the Rolling Dataframe"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "41d4a54b97ea5d7e"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# get rolling columns\n",
    "rolling_cols = [f\"{col}_10\" for col in nba_df_rolling.columns]\n",
    "nba_df_rolling.columns = rolling_cols\n",
    "\n",
    "# combine dataframes\n",
    "nba_df = pd.concat([nba_df, nba_df_rolling], axis=1)\n",
    "\n",
    "# drop rows with missing values\n",
    "nba_df = nba_df.dropna()"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "756c01e9f1b8bee4"
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Add Opponent Information"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "91cd609c5921b261"
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Create Shifting Column Function and Adding Column Function"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "720a7ca87b48ffce"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def shift_col(team, col_name):\n",
    "    \"\"\"\n",
    "    :param team: \n",
    "    :param col_name: \n",
    "    :return: dataframe with shifted column\n",
    "    \"\"\"\n",
    "\n",
    "    next_col = team[col_name].shift(-1)\n",
    "    return next_col\n",
    "\n",
    "\n",
    "def add_col(dataframe, col_name):\n",
    "    \"\"\"\n",
    "    :param dataframe: a dataframe\n",
    "    :param col_name: a column name\n",
    "    :return: adds a column to dataframe\n",
    "    \"\"\"\n",
    "    \n",
    "    return dataframe.groupby(\"team\", group_keys=False).apply(lambda x: shift_col(x, col_name))\n",
    "\n",
    "# find if the next game is home or away\n",
    "nba_df[\"home_next\"] = add_col(nba_df, \"home\")\n",
    "nba_df[\"team_opp_next\"] = add_col(nba_df, \"team_opp\")\n",
    "nba_df[\"date_next\"] = add_col(nba_df, \"date\")\n",
    "\n",
    "\n",
    "# make a copy for good measure\n",
    "nba_df = nba_df.copy()"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "5e709720bbae62b8"
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Get Information for Team's Previous 10 Games"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "3d559996f1ec1899"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "full = nba_df.merge(nba_df[rolling_cols + [\"team_opp_next\", \"date_next\", \"team\"]],\n",
    "                    left_on=[\"team\", \"date_next\"], right_on=[\"team_opp_next\", \"date_next\"])"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "2f6ff3424a3e77e9"
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Find Out Our New Preferred Columns"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "5e09c31ac7084583"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# get removed columns\n",
    "removed_columns = list(full.columns[full.dtypes == \"object\"]) + remove_columns\n",
    "\n",
    "# get preferred columns\n",
    "preferred_columns = full.columns[~full.columns.isin(removed_columns)]\n",
    "\n",
    "# fit to the feature selector\n",
    "sfs.fit(full[preferred_columns], full['target'])"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "63bcfe85a703b59a"
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Get Final Predictions"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "d1cd088b48e998b7"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# get the best predictors\n",
    "best_predictors = list(preferred_columns[sfs.get_support()])\n",
    "\n",
    "# predict \n",
    "nba_predictions = b_test(full, r, best_predictors)\n",
    "\n",
    "# get accuracy score\n",
    "score = accuracy_score(nba_predictions['actual'], nba_predictions['predicted'])\n",
    "print(score)"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "d34158d4163d3acd"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false
   },
   "id": "72a8817633bf8263"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}