new_model.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\tranalli\\AppData\\Local\\Continuum\\Anaconda3\\lib\\site-packages\\sklearn\\cross_validation.py:44: DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. Also note that the interface of the new CV iterators are different from that of this module. This module will be removed in 0.20.\n",
      "  \"This module will be removed in 0.20.\", DeprecationWarning)\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "import csv\n",
    "import random\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn import cross_validation, linear_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def calc_elo(win_team, lose_team, season):\n",
    "    winner_rank = get_elo(season, win_team)\n",
    "    loser_rank = get_elo(season, lose_team)\n",
    "\n",
    "    \"\"\"\n",
    "    This is originally from from:\n",
    "    http://zurb.com/forrst/posts/An_Elo_Rating_function_in_Python_written_for_foo-hQl\n",
    "    \"\"\"\n",
    "    rank_diff = winner_rank - loser_rank\n",
    "    exp = (rank_diff * -1) / 400\n",
    "    odds = 1 / (1 + math.pow(10, exp))\n",
    "    if winner_rank < 2100:\n",
    "        k = 32\n",
    "    elif winner_rank >= 2100 and winner_rank < 2400:\n",
    "        k = 24\n",
    "    else:\n",
    "        k = 16\n",
    "    new_winner_rank = round(winner_rank + (k * (1 - odds)))\n",
    "    new_rank_diff = new_winner_rank - winner_rank\n",
    "    new_loser_rank = loser_rank - new_rank_diff\n",
    "\n",
    "    return new_winner_rank, new_loser_rank\n",
    "\n",
    "\n",
    "def initialize_data():\n",
    "    for i in range(1985, prediction_year+1):\n",
    "        team_elos[i] = {}\n",
    "        team_stats[i] = {}\n",
    "\n",
    "\n",
    "def get_elo(season, team):\n",
    "    try:\n",
    "        return team_elos[season][team]\n",
    "    except:\n",
    "        try:\n",
    "            # Get the previous season's ending value.\n",
    "            team_elos[season][team] = team_elos[season-1][team]\n",
    "            return team_elos[season][team]\n",
    "        except:\n",
    "            # Get the starter elo.\n",
    "            team_elos[season][team] = base_elo\n",
    "            return team_elos[season][team]\n",
    "\n",
    "\n",
    "def predict_winner(team_1, team_2, model, season, stat_fields):\n",
    "    features = []\n",
    "\n",
    "    # Team 1\n",
    "    features.append(get_elo(season, team_1))\n",
    "    for stat in stat_fields:\n",
    "        features.append(get_stat(season, team_1, stat))\n",
    "\n",
    "    # Team 2\n",
    "    features.append(get_elo(season, team_2))\n",
    "    for stat in stat_fields:\n",
    "        features.append(get_stat(season, team_2, stat))\n",
    "\n",
    "    return model.predict_proba([features])\n",
    "\n",
    "\n",
    "def update_stats(season, team, fields):\n",
    "    \"\"\"\n",
    "    This accepts some stats for a team and udpates the averages.\n",
    "    First, we check if the team is in the dict yet. If it's not, we add it.\n",
    "    Then, we try to check if the key has more than 5 values in it.\n",
    "        If it does, we remove the first one\n",
    "        Either way, we append the new one.\n",
    "    If we can't check, then it doesn't exist, so we just add this.\n",
    "    Later, we'll get the average of these items.\n",
    "    \"\"\"\n",
    "    if team not in team_stats[season]:\n",
    "        team_stats[season][team] = {}\n",
    "\n",
    "    for key, value in fields.items():\n",
    "        # Make sure we have the field.\n",
    "        if key not in team_stats[season][team]:\n",
    "            team_stats[season][team][key] = []\n",
    "\n",
    "        if len(team_stats[season][team][key]) >= 9:\n",
    "            team_stats[season][team][key].pop()\n",
    "        team_stats[season][team][key].append(value)\n",
    "\n",
    "\n",
    "def get_stat(season, team, field):\n",
    "    if field == 'high_rank' or field == 'power_5':\n",
    "        try:\n",
    "            return team_stats[season][team][field][0]\n",
    "        except:\n",
    "            return 0\n",
    "    else:\n",
    "        try:\n",
    "            l = team_stats[season][team][field]\n",
    "            return sum(l) / float(len(l))\n",
    "        except:\n",
    "            return 0\n",
    "\n",
    "\n",
    "def build_team_dict():\n",
    "    team_ids = pd.read_csv(folder + '/Teams.csv')\n",
    "    team_id_map = {}\n",
    "    for index, row in team_ids.iterrows():\n",
    "        team_id_map[row['TeamID']] = row['TeamName']\n",
    "    return team_id_map\n",
    "\n",
    "\n",
    "def build_season_data(all_data):\n",
    "    # Calculate the elo for every game for every team, each season.\n",
    "    # Store the elo per season so we can retrieve their end elo\n",
    "    # later in order to predict the tournaments without having to\n",
    "    # inject the prediction into this loop.\n",
    "    print(\"Building season data.\")\n",
    "    for index, row in all_data.iterrows():\n",
    "        # Used to skip matchups where we don't have usable stats yet.\n",
    "        skip = 0\n",
    "\n",
    "        # Get starter or previous elos.\n",
    "        team_1_elo = get_elo(row['Season'], row['WTeamID'])\n",
    "        team_2_elo = get_elo(row['Season'], row['LTeamID'])\n",
    "\n",
    "        # Add 100 to the home team (# taken from Nate Silver analysis.)\n",
    "        if row['WLoc'] == 'H':\n",
    "            team_1_elo += 100\n",
    "        elif row['WLoc'] == 'A':\n",
    "            team_2_elo += 100\n",
    "\n",
    "        # We'll create some arrays to use later.\n",
    "        team_1_features = [team_1_elo]\n",
    "        team_2_features = [team_2_elo]\n",
    "\n",
    "        # Build arrays out of the stats we're tracking..\n",
    "        for field in stat_fields:\n",
    "            team_1_stat = get_stat(row['Season'], row['WTeamID'], field)\n",
    "            team_2_stat = get_stat(row['Season'], row['LTeamID'], field)\n",
    "            if team_1_stat is not 0 and team_2_stat is not 0:\n",
    "                team_1_features.append(team_1_stat)\n",
    "                team_2_features.append(team_2_stat)\n",
    "            else:\n",
    "                skip = 1\n",
    "\n",
    "        if skip == 0:  # Make sure we have stats.\n",
    "            # Randomly select left and right and 0 or 1 so we can train\n",
    "            # for multiple classes.\n",
    "            if random.random() > 0.5:\n",
    "                X.append([row['Season']] + [row['WTeamID']] + team_1_features + [row['LTeamID']] + team_2_features + [0])\n",
    "            else:\n",
    "                X.append([row['Season']] + [row['LTeamID']] + team_2_features + [row['WTeamID']] + team_1_features + [1])\n",
    "\n",
    "        # AFTER we add the current stuff to the prediction, update for\n",
    "        # next time. Order here is key so we don't fit on data from the\n",
    "        # same game we're trying to predict.\n",
    "        if row['WFTA'] != 0 and row['LFTA'] != 0:\n",
    "            stat_1_fields = {\n",
    "                'score': row['WScore'],\n",
    "                'fgp': row['WFGM'] / row['WFGA'] * 100,\n",
    "                'fga': row['WFGA'],\n",
    "                'fga3': row['WFGA3'],\n",
    "                '3pp': row['WFGM3'] / row['WFGA3'] * 100,\n",
    "                'ftp': row['WFTM'] / row['WFTA'] * 100,\n",
    "                'or': row['WOR'],\n",
    "                'dr': row['WDR'],\n",
    "                'ast': row['WAst'],\n",
    "                'to': row['WTO'],\n",
    "                'stl': row['WStl'],\n",
    "                'blk': row['WBlk'],\n",
    "                'pf': row['WPF'],\n",
    "                'form':row['Wform'],\n",
    "                'power_5':row['WTeam_p5'],\n",
    "                'high_rank':row['WTeam_rank']               \n",
    "            }\n",
    "            stat_2_fields = {\n",
    "                'score': row['LScore'],\n",
    "                'fgp': row['LFGM'] / row['LFGA'] * 100,\n",
    "                'fga': row['LFGA'],\n",
    "                'fga3': row['LFGA3'],\n",
    "                '3pp': row['LFGM3'] / row['LFGA3'] * 100,\n",
    "                'ftp': row['LFTM'] / row['LFTA'] * 100,\n",
    "                'or': row['LOR'],\n",
    "                'dr': row['LDR'],\n",
    "                'ast': row['LAst'],\n",
    "                'to': row['LTO'],\n",
    "                'stl': row['LStl'],\n",
    "                'blk': row['LBlk'],\n",
    "                'pf': row['LPF'],\n",
    "                'form':row['Lform'],\n",
    "                'power_5':row['LTeam_p5'],\n",
    "                'high_rank':row['LTeam_rank']\n",
    "            }\n",
    "            update_stats(row['Season'], row['WTeamID'], stat_1_fields)\n",
    "            update_stats(row['Season'], row['LTeamID'], stat_2_fields)\n",
    "\n",
    "        # Now that we've added them, calc the new elo.\n",
    "        new_winner_rank, new_loser_rank = calc_elo(\n",
    "            row['WTeamID'], row['LTeamID'], row['Season'])\n",
    "        team_elos[row['Season']][row['WTeamID']] = new_winner_rank\n",
    "        team_elos[row['Season']][row['LTeamID']] = new_loser_rank\n",
    "\n",
    "    return X\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "base_elo = 1600\n",
    "team_elos = {}  # Reset each year.\n",
    "team_stats = {}\n",
    "X = []\n",
    "y = []\n",
    "submission_data = []\n",
    "folder = 'data'\n",
    "results_folder = 'results'\n",
    "prediction_year = 2018\n",
    "stat_fields = ['score', 'fga', 'fgp', 'fga3', '3pp', 'ftp', 'or', 'dr',\n",
    "                   'ast', 'to', 'stl', 'blk', 'pf', 'form', 'power_5', 'high_rank']\n",
    "\n",
    "labels = ['Season', 't1','t1elo', 't1score', 't1fga', 't1fgp', 't1fga3', 't13pp', 't1ftp', 't1or', 't1dr',\n",
    "                   't1ast', 't1to', 't1stl', 't1blk', 't1pf', 't1form', 't1p5', 't1rank',\n",
    "                  't2', 't2elo', 't2score', 't2fga', \n",
    "                  't2fgp', 't2fga3', 't23pp', 't2ftp', 't2or', 't2dr',\n",
    "                   't2ast', 't2to', 't2stl', 't2blk', 't2pf', 't2form', 't2p5', 't2rank', 't2_win']\n",
    "\n",
    "initialize_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(82041, 34)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# read data\n",
    "season_data = pd.read_csv(folder + '/RegularSeasonDetailedResults.csv')\n",
    "season_data.columns\n",
    "season_data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(981, 40)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tourney_data = pd.read_csv(folder + '/NCAATourneyDetailedResults_2003_2017.csv')\n",
    "tourney_data.columns\n",
    "tourney_data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "conferences = pd.read_csv('Data/TeamConferences.csv')\n",
    "conferences.drop('ConfAbbrev', axis = 1, inplace = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "massey = pd.read_csv('Data/MasseyOrdinals.csv')\n",
    "preseason_rank = massey[['Season', 'RankingDayNum', 'TeamID', 'OrdinalRank']].groupby(['Season', 'TeamID'], as_index = False).agg(min)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(83022, 40)\n",
      "(83022, 54)\n"
     ]
    }
   ],
   "source": [
    "# combine data\n",
    "frames = [season_data, tourney_data]\n",
    "all_data = pd.concat(frames)\n",
    "print(all_data.shape)\n",
    "all_data.head()\n",
    "all_data['Wform'] = 1\n",
    "all_data['Lform'] = 0\n",
    "\n",
    "all_data = all_data.merge(conferences, left_on = ['Season', 'WTeamID'], right_on = ['Season', 'TeamID'], how = 'left')\n",
    "all_data.rename(columns = {'power_5':'WTeam_p5'}, inplace = True)\n",
    "all_data = all_data.merge(conferences, left_on = ['Season', 'LTeamID'], right_on = ['Season', 'TeamID'], how = 'left')\n",
    "all_data.rename(columns = {'power_5':'LTeam_p5'}, inplace = True)\n",
    "all_data['p5_diff'] = all_data['WTeam_p5'] - all_data['LTeam_p5']\n",
    "\n",
    "all_data = all_data.merge(preseason_rank, left_on = ['Season', 'WTeamID'], right_on = ['Season', 'TeamID'], how = 'left')\n",
    "all_data.rename(columns = {'OrdinalRank':'WTeam_rank'}, inplace = True)\n",
    "all_data = all_data.merge(preseason_rank, left_on = ['Season', 'LTeamID'], right_on = ['Season', 'TeamID'], how = 'left')\n",
    "all_data.rename(columns = {'OrdinalRank':'LTeam_rank'}, inplace = True)\n",
    "all_data['rank_diff'] = all_data['WTeam_rank'] - all_data['LTeam_rank']\n",
    "print(all_data.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Building season data.\n"
     ]
    }
   ],
   "source": [
    "# Build the working data.\n",
    "df = build_season_data(all_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(13305, 38)\n",
      "Index(['Season', 't1', 't1elo', 't1score', 't1fga', 't1fgp', 't1fga3', 't13pp',\n",
      "       't1ftp', 't1or', 't1dr', 't1ast', 't1to', 't1stl', 't1blk', 't1pf',\n",
      "       't1form', 't1p5', 't1rank', 't2', 't2elo', 't2score', 't2fga', 't2fgp',\n",
      "       't2fga3', 't23pp', 't2ftp', 't2or', 't2dr', 't2ast', 't2to', 't2stl',\n",
      "       't2blk', 't2pf', 't2form', 't2p5', 't2rank', 't2_win'],\n",
      "      dtype='object')\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>t2rank</th>\n",
       "      <th>t1rank</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>43</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>19</td>\n",
       "      <td>49</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>20</td>\n",
       "      <td>19</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>59</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>12</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   t2rank  t1rank\n",
       "0      43       7\n",
       "1      19      49\n",
       "2      20      19\n",
       "3      59       9\n",
       "4       1      12"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "preds = pd.DataFrame(df, columns = labels)\n",
    "\n",
    "print(preds.shape)\n",
    "\n",
    "print(preds.columns)\n",
    "drop_cols = ['Season', 't1', 't2', 't2_win']\n",
    "X = preds.drop(drop_cols, axis = 1)\n",
    "y = preds['t2_win']\n",
    "\n",
    "preds[['t2rank', 't1rank']].head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting on 13305 samples.\n",
      "Doing cross-validation.\n",
      "0.710031906853\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n",
       "          intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,\n",
       "          penalty='l2', random_state=None, solver='liblinear', tol=0.0001,\n",
       "          verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"Fitting on %d samples.\" % len(X))\n",
    "\n",
    "model = sklearn.linear_model.LogisticRegression()\n",
    "# model = RandomForestClassifier(max_depth = 2)\n",
    "\n",
    "# Check accuracy.\n",
    "print(\"Doing cross-validation.\")\n",
    "print(cross_validation.cross_val_score(model, np.array(X), np.array(y), cv=10, scoring='accuracy').mean())\n",
    "\n",
    "model.fit(X, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Getting teams.\n",
      "Predicting matchups.\n",
      "Writing 2278 results.\n",
      "Outputting readable results.\n"
     ]
    }
   ],
   "source": [
    "# Now predict tournament matchups.\n",
    "print(\"Getting teams.\")\n",
    "seeds = pd.read_csv(folder + '/NCAATourneySeeds.csv')\n",
    "# for i in range(2016, 2017):\n",
    "tourney_teams = []\n",
    "for index, row in seeds.iterrows():\n",
    "    if row['Season'] == prediction_year:\n",
    "        tourney_teams.append(row['TeamID'])\n",
    "\n",
    "# Build our prediction of every matchup.\n",
    "print(\"Predicting matchups.\")\n",
    "tourney_teams.sort()\n",
    "for team_1 in tourney_teams:\n",
    "    for team_2 in tourney_teams:\n",
    "        if team_1 < team_2:\n",
    "            prediction = predict_winner(\n",
    "                team_1, team_2, model, prediction_year, stat_fields)\n",
    "            label = str(prediction_year) + '_' + str(team_1) + '_' + \\\n",
    "                str(team_2)\n",
    "            submission_data.append([label, prediction[0][0]])\n",
    "\n",
    "# Write the results.\n",
    "print(\"Writing %d results.\" % len(submission_data))\n",
    "with open(results_folder + '/submission.csv', 'w') as f:\n",
    "    writer = csv.writer(f)\n",
    "    writer.writerow(['id', 'pred'])\n",
    "    writer.writerows(submission_data)\n",
    "\n",
    "# Now so that we can use this to fill out a bracket, create a readable\n",
    "# version.\n",
    "print(\"Outputting readable results.\")\n",
    "team_id_map = build_team_dict()\n",
    "readable = []\n",
    "less_readable = []  # A version that's easy to look up.\n",
    "for pred in submission_data:\n",
    "    parts = pred[0].split('_')\n",
    "    less_readable.append(\n",
    "        [team_id_map[int(parts[1])], team_id_map[int(parts[2])], pred[1]])\n",
    "    # Order them properly.\n",
    "    if pred[1] > 0.5:\n",
    "        winning = int(parts[1])\n",
    "        losing = int(parts[2])\n",
    "        proba = pred[1]\n",
    "    else:\n",
    "        winning = int(parts[2])\n",
    "        losing = int(parts[1])\n",
    "        proba = 1 - pred[1]\n",
    "    readable.append(\n",
    "        [\n",
    "            '%s beats %s: %f' %\n",
    "            (team_id_map[winning], team_id_map[losing], proba)\n",
    "        ]\n",
    "    )\n",
    "with open(results_folder + '/readable-predictions.csv', 'w') as f:\n",
    "    writer = csv.writer(f)\n",
    "    writer.writerows(readable)\n",
    "with open(results_folder + '/less-readable-predictions.csv', 'w') as f:\n",
    "    writer = csv.writer(f)\n",
    "    writer.writerows(less_readable)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}