Infrastructure- Maximize Difference Between 10 Brackets.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import march_madness_classes as mmc\n",
    "import march_madness_games as mmg\n",
    "import march_madness_models as mmm\n",
    "import march_madness_train_and_tune as mmtt\n",
    "import pandas as pd\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.linear_model import LogisticRegression as LogReg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# read in the dataset\n",
    "seeds = pd.read_csv(\"datasets/kaggle_data/TourneySeeds.csv\")\n",
    "slots = pd.read_csv(\"datasets/kaggle_data/TourneySlots.csv\")\n",
    "games = pd.read_csv(\"datasets/kaggle_data/TourneyCompactResults.csv\")\n",
    "\n",
    "seeds_arr = mmg.filter_into_seasons(seeds)\n",
    "slots_arr = mmg.filter_into_seasons(slots)\n",
    "games_arr = mmg.filter_into_seasons(games)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# extract predictors\n",
    "markov_data = pd.read_csv(\"datasets/our_data/stationary\", index_col=0)\n",
    "rpi = pd.read_csv(\"datasets/our_data/rpi\", index_col=0)\n",
    "bad_losses = pd.read_csv(\"datasets/our_data/bad_losses\", index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# get data into correct format\n",
    "predictor_names = [\"min_index_id\", \"max_index_id\", \"markov\", \"rpi\", \"bad_losses\"]\n",
    "predictor_dfs = [markov_data, rpi, bad_losses]                                        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# trian test split\n",
    "\n",
    "train_test_arr = []\n",
    "\n",
    "window   = 3\n",
    "min_year = 2001\n",
    "max_year = 2003\n",
    "\n",
    "year_range = range(min_year, max_year)\n",
    "\n",
    "# generate our train test split for each year\n",
    "for year in year_range:\n",
    "    # do the split for the current year\n",
    "    train_test_tuple = mmtt.train_test_split(window, \n",
    "                                             year, \n",
    "                                             seeds_arr, \n",
    "                                             slots_arr, \n",
    "                                             games_arr, \n",
    "                                             predictor_names, \n",
    "                                             predictor_dfs)\n",
    "    \n",
    "    # add to our array\n",
    "    train_test_arr.append(train_test_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# fit head to head models\n",
    "\n",
    "# our cross validated value of c, from variable selection notebook\n",
    "c = 1\n",
    "variables = [\"markov\",\"rpi\",\"bad_losses\"] \n",
    "\n",
    "# models and scalers to be fit\n",
    "models  = []\n",
    "scalers = []\n",
    "\n",
    "for year in year_range:\n",
    "        # get train data\n",
    "        train_x = train_test_arr[year - min_year][0][variables]\n",
    "        train_y = train_test_arr[year - min_year][1].values[:, 0]\n",
    "\n",
    "        # get cross validation set\n",
    "        cross_x = train_test_arr[year - min_year][2][variables]\n",
    "        cross_y = train_test_arr[year - min_year][3].values[:, 0]\n",
    "\n",
    "        # scaling\n",
    "        scaler = StandardScaler().fit(train_x)\n",
    "        scaled_train_x = scaler.transform(train_x)\n",
    "        scaled_cross_x = scaler.transform(cross_x)\n",
    "\n",
    "        # init model\n",
    "        model = LogReg(C=c)\n",
    "\n",
    "        # fit model\n",
    "        model.fit(scaled_train_x, train_y)\n",
    "        \n",
    "        # append to our lis of models\n",
    "        models.append(model)\n",
    "        scalers.append(scaler)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# run tournaments\n",
    "\n",
    "year = min_year\n",
    "unbiased_tourneys   = []\n",
    "top_seed_tourneys = []\n",
    "actual_tourneys   = []\n",
    "\n",
    "# analyze results for all simulations\n",
    "i = 0\n",
    "for year in year_range:\n",
    "    # get data from our db\n",
    "    seeds_year = seeds_arr[year-1985] \n",
    "    slots_year = slots_arr[year-1985] \n",
    "    games_year = games_arr[year-1985]\n",
    "    \n",
    "    # get actual models\n",
    "    actual_model = mmm.ActualTournament(games_arr[year-1985])\n",
    "    actual_tourneys.append(mmc.Tournament(seeds_year, slots_year, actual_model, include_scoring_dif=False))\n",
    "    \n",
    "    # get greedy models\n",
    "    unbiased_model = mmm.ModelPredictor(models[i], scalers[i], predictor_dfs, year, seeds_year, simulation=False)\n",
    "    unbiased_tourneys.append(mmc.Tournament(seeds_year, slots_year, unbiased_model, include_scoring_dif=False))\n",
    "    \n",
    "    # get top seed models\n",
    "    top_seed_model = mmm.BasicPredictor()\n",
    "    top_seed_tourneys.append(mmc.Tournament(seeds_year, slots_year, top_seed_model, include_scoring_dif=False))\n",
    "    \n",
    "    year = year + 1\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<module 'march_madness_models' from 'march_madness_models.py'>"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reload(mmm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "test_dif_bracket = mmm.ModelPredictor(models[0], scalers[0], predictor_dfs, 2001, seeds_arr[2001-1985], other_bracket_arr=[unbiased_tourneys[0].entire_bracket])\n",
    "test_dif_tourney = mmc.Tournament(seeds_arr[2001-1985], slots_arr[2001-1985], test_dif_bracket, include_scoring_dif=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "test_dif_bracket_2 = mmm.ModelPredictor(models[0], scalers[0], predictor_dfs, 2001, seeds_arr[2001-1985], other_bracket_arr=[unbiased_tourneys[0].entire_bracket, test_dif_tourney.entire_bracket])\n",
    "test_dif_tourney_2 = mmc.Tournament(seeds_arr[2001-1985], slots_arr[2001-1985], test_dif_bracket_2, include_scoring_dif=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1150, 0.6031746031746031)\n",
      "(1040, 0.5396825396825397)\n",
      "(1170, 0.5714285714285714)\n"
     ]
    }
   ],
   "source": [
    "print unbiased_tourneys[0].score_tournament(actual_tourneys[0])\n",
    "print test_dif_tourney.score_tournament(actual_tourneys[0])\n",
    "print test_dif_tourney_2.score_tournament(actual_tourneys[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(9, 4, 4)\n",
      "(18, 5, 9)\n",
      "(8, 2, 4)\n"
     ]
    }
   ],
   "source": [
    "print unbiased_tourneys[0].compare_to_dif_tournament(actual_tourneys[0], top_seed_tourneys[0], print_res=False)\n",
    "print test_dif_tourney.compare_to_dif_tournament(actual_tourneys[0], top_seed_tourneys[0], print_res=False)\n",
    "print test_dif_tourney_2.compare_to_dif_tournament(actual_tourneys[0], top_seed_tourneys[0], print_res=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(16, 3, 7)\n",
      "(7, 1, 3)\n"
     ]
    }
   ],
   "source": [
    "print test_dif_tourney.compare_to_dif_tournament(actual_tourneys[0], unbiased_tourneys[0], print_res=False)\n",
    "print test_dif_tourney_2.compare_to_dif_tournament(actual_tourneys[0], unbiased_tourneys[0], print_res=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(12, 5, 3)\n"
     ]
    }
   ],
   "source": [
    "print test_dif_tourney_2.compare_to_dif_tournament(actual_tourneys[0], test_dif_tourney, print_res=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "reload(mmc)\n",
    "ensemble_tournament = mmc.Ensemble(seeds_arr[2001-1985], \n",
    "                                   slots_arr[2001-1985], \n",
    "                                   models[0], \n",
    "                                   scalers[0],  \n",
    "                                   predictor_dfs, \n",
    "                                   2001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1150.,  1180.,  1040.,  1040.,   620.,  1090.,  1170.,   590.,\n",
       "        1080.,  1090.])"
      ]
     },
     "execution_count": 251,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ensemble_tournament.score_tournament(actual_tourneys[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0.,  12.,  16.,  16.,  12.,   5.,   7.,   9.,  13.,   5.],\n",
       "       [ 12.,   0.,   6.,   7.,   5.,  16.,  12.,  15.,   6.,  16.],\n",
       "       [ 16.,   6.,   0.,   1.,   8.,  11.,  12.,  17.,   4.,  11.],\n",
       "       [ 16.,   7.,   1.,   0.,   9.,  11.,  11.,  16.,   5.,  11.],\n",
       "       [ 12.,   5.,   8.,   9.,   0.,  17.,  15.,  12.,   6.,  17.],\n",
       "       [  5.,  16.,  11.,  11.,  17.,   0.,   5.,  12.,  12.,   0.],\n",
       "       [  7.,  12.,  12.,  11.,  15.,   5.,   0.,  10.,  10.,   5.],\n",
       "       [  9.,  15.,  17.,  16.,  12.,  12.,  10.,   0.,  18.,  12.],\n",
       "       [ 13.,   6.,   4.,   5.,   6.,  12.,  10.,  18.,   0.,  12.],\n",
       "       [  5.,  16.,  11.,  11.,  17.,   0.,   5.,  12.,  12.,   0.]])"
      ]
     },
     "execution_count": 252,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ensemble_tournament.compute_dif_matrix(actual_tourneys[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 10.55555556,  10.55555556,   9.55555556,   9.66666667,\n",
       "        11.22222222,   9.88888889,   9.66666667,  13.44444444,\n",
       "         9.55555556,   9.88888889])"
      ]
     },
     "execution_count": 253,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ensemble_tournament.avg_game_dif()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  9.,  19.,  18.,  18.,  21.,   7.,   8.,  17.,  16.,   7.])"
      ]
     },
     "execution_count": 254,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ensemble_tournament.compute_dif_vect(actual_tourneys[0], top_seed_tourneys[0])"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [Root]",
   "language": "python",
   "name": "Python [Root]"
  },
  "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}