{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "ec35aa40-97b0-526b-68d4-202c8df37a80"
      },
      "source": [
        "## Introduction ##\n",
        "Hello! This is my first Kaggle notebook. I hope you like it. I'm from Argentina and I want to get some experience while I have some fun with March Madness. So let's start."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "ce39e796-2e2e-39e0-39ec-4f77dd148c2e"
      },
      "outputs": [],
      "source": [
        "#Added by me\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import random\n",
        "import statsmodels.api as sm\n",
        "import matplotlib.pyplot as plt\n",
        "from patsy import dmatrices\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn import metrics\n",
        "from sklearn import preprocessing\n",
        "\n",
        "# This Python 3 environment comes with many helpful analytics libraries installed\n",
        "# It is defined by the kaggle/python docker image: https://github.com/kaggle/docker-python\n",
        "# For example, here's several helpful packages to load in \n",
        "\n",
        "import numpy as np # linear algebra\n",
        "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n",
        "\n",
        "#Agregados m\u00edos\n",
        "from keras.wrappers.scikit_learn import KerasRegressor\n",
        "from sklearn.model_selection import cross_val_score\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.model_selection import KFold\n",
        "from sklearn.neighbors import KNeighborsClassifier\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from sklearn.pipeline import Pipeline\n",
        "from keras.models import Sequential\n",
        "from keras.layers import Dense\n",
        "\n",
        "# Input data files are available in the \"../input/\" directory.\n",
        "# For example, running this (by clicking run or pressing Shift+Enter) will list the files in the input directory\n",
        "\n",
        "from subprocess import check_output\n",
        "print(check_output([\"ls\", \"../input\"]).decode(\"utf8\"))\n",
        "\n",
        "# Any results you write to the current directory are saved as output."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "57b7d6e1-734b-3e34-49c9-f577417a4808"
      },
      "source": [
        "## Processing data ##\n",
        "### Data comparison ###"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "9db33d3b-0088-ed8e-1674-bc14dbe163ff"
      },
      "outputs": [],
      "source": [
        "tourney_data=pd.read_csv(\"../input/TourneyDetailedResults.csv\")\n",
        "tourney_data.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "06224a13-5098-42c7-3d37-85042b684dff"
      },
      "outputs": [],
      "source": [
        "%matplotlib inline"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "1e545e3d-2d58-d96d-bc96-de030a4d4416"
      },
      "outputs": [],
      "source": [
        "tourney_data=tourney_data.groupby(['Season']).mean()\n",
        "\n",
        "tourney_data.plot(y='Wscore')\n",
        "tourney_data.plot(y='Wfga')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "db9c46b7-caf7-2f86-663d-5a9c5b097be7"
      },
      "source": [
        "# Feature Engineering #"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "d54f9650-b76d-9385-955d-393ce35ba597"
      },
      "outputs": [],
      "source": [
        "detailed_data=pd.read_csv(\"../input/TourneyDetailedResults.csv\")\n",
        "\n",
        "training_data = pd.DataFrame()\n",
        "training_data[[\"Season\",\"team1\", \"team2\"]] =detailed_data[[\"Season\",\"Wteam\", \"Lteam\"]].copy()\n",
        "training_data[\"pred\"] = 1\n",
        "\n",
        "for index, row in training_data.iterrows():\n",
        "    if random.randint(0,1)==1:\n",
        "        temp=row['team1']\n",
        "        training_data.set_value(index,'team1',row['team2'])\n",
        "        training_data.set_value(index,'team2',temp)\n",
        "        training_data.set_value(index,'pred',0)\n",
        "\n",
        "def loadInTraining(name,data):\n",
        "    new_training_data=pd.merge(training_data,data,how=\"inner\",left_on=[\"Season\",\"team1\"], right_on=[\"Season\",\"team\"])\n",
        "    new_training_data=new_training_data.drop(\"team\",axis=1)\n",
        "    new_training_data=new_training_data.rename(columns={name: name+\"1\"})\n",
        "    \n",
        "    new_training_data=pd.merge(new_training_data,data,how=\"inner\",left_on=[\"Season\",\"team2\"], right_on=[\"Season\",\"team\"])\n",
        "    new_training_data=new_training_data.drop(\"team\",axis=1)\n",
        "    new_training_data=new_training_data.rename(columns={name: name+\"2\"})\n",
        "    \n",
        "    return new_training_data"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "fa96adf3-aa00-82a5-45c9-959f05754456"
      },
      "source": [
        "**PPG - Points Per Game**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "e0831f56-2ef7-4f6a-06c6-ce2d47b482f5"
      },
      "outputs": [],
      "source": [
        "season_data=pd.read_csv(\"../input/RegularSeasonDetailedResults.csv\")\n",
        "\n",
        "ppg_data_a=pd.DataFrame()\n",
        "ppg_data_a[[\"Season\",\"team\",\"score\"]]=season_data[[\"Season\",\"Wteam\",\"Wscore\"]]\n",
        "ppg_data_b=pd.DataFrame()\n",
        "ppg_data_b[[\"Season\",\"team\",\"score\"]]=season_data[[\"Season\",\"Lteam\",\"Lscore\"]]\n",
        "\n",
        "ppg_data=pd.concat((ppg_data_a,ppg_data_b),axis=0)\n",
        "ppg_data=ppg_data.groupby([\"Season\",\"team\"])[\"score\"].agg(['sum','count']).reset_index()\n",
        "ppg_data[\"PPG\"]=ppg_data[\"sum\"]/ppg_data[\"count\"]\n",
        "\n",
        "ppg_data=ppg_data[[\"Season\",\"team\",\"PPG\"]]\n",
        "training_data=loadInTraining(\"PPG\",ppg_data)\n",
        "training_data.head()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "fae51698-c4fe-9963-4e76-ec82fc1ceee5"
      },
      "source": [
        "**RPG - Received Per Game**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "f69a99d2-8228-c19e-1f8d-f95c0632d4bc"
      },
      "outputs": [],
      "source": [
        "season_data=pd.read_csv(\"../input/RegularSeasonDetailedResults.csv\")\n",
        "\n",
        "rpg_data_a=pd.DataFrame()\n",
        "rpg_data_a[[\"Season\",\"team\",\"score\"]]=season_data[[\"Season\",\"Wteam\",\"Lscore\"]]\n",
        "rpg_data_b=pd.DataFrame()\n",
        "rpg_data_b[[\"Season\",\"team\",\"score\"]]=season_data[[\"Season\",\"Lteam\",\"Wscore\"]]\n",
        "\n",
        "rpg_data=pd.concat((rpg_data_a,rpg_data_b),axis=0)\n",
        "rpg_data=rpg_data.groupby([\"Season\",\"team\"])[\"score\"].agg(['sum','count']).reset_index()\n",
        "rpg_data[\"RPG\"]=rpg_data[\"sum\"]/rpg_data[\"count\"]\n",
        "\n",
        "rpg_data=rpg_data[[\"Season\",\"team\",\"RPG\"]]\n",
        "training_data=loadInTraining(\"RPG\",rpg_data)\n",
        "training_data.head()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "ef736d77-02dc-ae86-f4f3-51fbd418c5ef"
      },
      "source": [
        "**REC - Record (W/L)**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "0d6f1f41-1d22-b72d-b16d-a1d8931a10d1"
      },
      "outputs": [],
      "source": [
        "season_data=pd.read_csv(\"../input/RegularSeasonDetailedResults.csv\")\n",
        "\n",
        "rec_data_w=pd.DataFrame()\n",
        "rec_data_w[[\"Season\",\"team\",\"W\"]]=season_data[[\"Season\",\"Wteam\",\"Wscore\"]]\n",
        "rec_data_l=pd.DataFrame()\n",
        "rec_data_l[[\"Season\",\"team\",\"L\"]]=season_data[[\"Season\",\"Lteam\",\"Lscore\"]]\n",
        "\n",
        "rec_data_w=rec_data_w.groupby([\"Season\",\"team\"])[\"W\"].count().reset_index()\n",
        "rec_data_l=rec_data_l.groupby([\"Season\",\"team\"])[\"L\"].count().reset_index()\n",
        "rec_data=pd.merge(rec_data_w,rec_data_l,how=\"outer\",on=[\"Season\",\"team\"])\n",
        "rec_data=rec_data.fillna(0)\n",
        "rec_data[\"REC\"]=rec_data[\"W\"]/(rec_data[\"W\"]+rec_data[\"L\"])\n",
        "\n",
        "rec_data=rec_data[[\"Season\",\"team\",\"REC\"]]\n",
        "\n",
        "training_data=loadInTraining(\"REC\",rec_data)\n",
        "training_data.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "e148ef4d-18b8-e8d8-ca39-e057260915a6"
      },
      "source": [
        "**eFG% - Effective Field Goal Percentage**\n",
        "\n",
        "Four Factors - Dean Oliver"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "9ecc2cc7-4bc0-94b3-708d-7d971c77ea5e"
      },
      "outputs": [],
      "source": [
        "season_data=pd.read_csv(\"../input/RegularSeasonDetailedResults.csv\")\n",
        "\n",
        "efg_data_w=pd.DataFrame()\n",
        "efg_data_w[[\"Season\",\"team\",\"fga\",\"fg\",\"3p\"]]=season_data[[\"Season\",\"Wteam\",\"Wfga\",\"Wfgm\",\"Wfgm3\"]]\n",
        "efg_data_l=pd.DataFrame()\n",
        "efg_data_l[[\"Season\",\"team\",\"fga\",\"fg\",\"3p\"]]=season_data[[\"Season\",\"Lteam\",\"Lfga\",\"Lfgm\",\"Lfgm3\"]]\n",
        "\n",
        "efg_data=pd.concat((efg_data_w,efg_data_l),axis=0)\n",
        "efg_data=efg_data.groupby([\"Season\",\"team\"]).sum().reset_index()\n",
        "efg_data[\"eFG%\"]=(efg_data[\"fg\"]+0.5*efg_data[\"3p\"])/efg_data[\"fga\"]\n",
        "\n",
        "efg_data=efg_data[[\"Season\",\"team\",\"eFG%\"]]\n",
        "training_data=loadInTraining(\"eFG%\",efg_data)\n",
        "training_data.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "559cdb52-243b-c2fb-4fb0-e6f036355770"
      },
      "source": [
        "**dFG% - Effective Defensive Field Goal Percentage**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "2aaf75eb-8662-71dd-1bb3-66513edb191a"
      },
      "outputs": [],
      "source": [
        "season_data=pd.read_csv(\"../input/RegularSeasonDetailedResults.csv\")\n",
        "\n",
        "efg_data_w=pd.DataFrame()\n",
        "efg_data_w[[\"Season\",\"team\",\"fga\",\"fg\",\"3p\"]]=season_data[[\"Season\",\"Wteam\",\"Lfga\",\"Lfgm\",\"Lfgm3\"]]\n",
        "efg_data_l=pd.DataFrame()\n",
        "efg_data_l[[\"Season\",\"team\",\"fga\",\"fg\",\"3p\"]]=season_data[[\"Season\",\"Lteam\",\"Wfga\",\"Wfgm\",\"Wfgm3\"]]\n",
        "\n",
        "efg_data=pd.concat((efg_data_w,efg_data_l),axis=0)\n",
        "efg_data=efg_data.groupby([\"Season\",\"team\"]).sum().reset_index()\n",
        "efg_data[\"dFG%\"]=(efg_data[\"fg\"]+0.5*efg_data[\"3p\"])/efg_data[\"fga\"]\n",
        "\n",
        "efg_data=efg_data[[\"Season\",\"team\",\"dFG%\"]]\n",
        "training_data=loadInTraining(\"dFG%\",efg_data)\n",
        "training_data.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "8fcab66e-a867-c896-0326-2e576e04a46b"
      },
      "source": [
        "**TOV% - Turnover Percentage**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "ca18c3bd-9da0-1e35-403d-d34b404d2e6c"
      },
      "outputs": [],
      "source": [
        "season_data=pd.read_csv(\"../input/RegularSeasonDetailedResults.csv\")\n",
        "\n",
        "tov_data_w=pd.DataFrame()\n",
        "tov_data_w[[\"Season\",\"team\",\"fga\",\"fta\",\"tov\"]]=season_data[[\"Season\",\"Wteam\",\"Wfga\",\"Wfta\",\"Wto\"]]\n",
        "tov_data_l=pd.DataFrame()\n",
        "tov_data_l[[\"Season\",\"team\",\"fga\",\"fta\",\"tov\"]]=season_data[[\"Season\",\"Lteam\",\"Lfga\",\"Lfta\",\"Lto\"]]\n",
        "\n",
        "tov_data=pd.concat((tov_data_w,tov_data_l),axis=0)\n",
        "tov_data=tov_data.groupby([\"Season\",\"team\"]).sum().reset_index()\n",
        "tov_data[\"TOV%\"]=tov_data[\"tov\"]/(tov_data[\"fga\"]+0.44*tov_data[\"fta\"]+tov_data[\"tov\"])\n",
        "\n",
        "tov_data=tov_data[[\"Season\",\"team\",\"TOV%\"]]\n",
        "training_data=loadInTraining(\"TOV%\",tov_data)\n",
        "training_data.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "71a0105c-ca02-4b89-2e0e-9bde4781de39"
      },
      "source": [
        "**dTO% - Defensive Turnover Percentage**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "8d12dc63-f8a3-1627-1dfb-c0567844639a"
      },
      "outputs": [],
      "source": [
        "season_data=pd.read_csv(\"../input/RegularSeasonDetailedResults.csv\")\n",
        "\n",
        "tov_data_w=pd.DataFrame()\n",
        "tov_data_w[[\"Season\",\"team\",\"fga\",\"fta\",\"tov\"]]=season_data[[\"Season\",\"Wteam\",\"Lfga\",\"Lfta\",\"Lto\"]]\n",
        "tov_data_l=pd.DataFrame()\n",
        "tov_data_l[[\"Season\",\"team\",\"fga\",\"fta\",\"tov\"]]=season_data[[\"Season\",\"Lteam\",\"Wfga\",\"Wfta\",\"Wto\"]]\n",
        "\n",
        "tov_data=pd.concat((tov_data_w,tov_data_l),axis=0)\n",
        "tov_data=tov_data.groupby([\"Season\",\"team\"]).sum().reset_index()\n",
        "tov_data[\"dTO%\"]=tov_data[\"tov\"]/(tov_data[\"fga\"]+0.44*tov_data[\"fta\"]+tov_data[\"tov\"])\n",
        "\n",
        "tov_data=tov_data[[\"Season\",\"team\",\"dTO%\"]]\n",
        "training_data=loadInTraining(\"dTO%\",tov_data)\n",
        "training_data.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "2313651c-f318-aa4c-467b-f93374c3367c"
      },
      "source": [
        "**ORB% - Offensive Rebound Percentage**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "7113f043-fb32-9489-207e-ec59dbafa992"
      },
      "outputs": [],
      "source": [
        "season_data=pd.read_csv(\"../input/RegularSeasonDetailedResults.csv\")\n",
        "\n",
        "orb_data_w=pd.DataFrame()\n",
        "orb_data_w[[\"Season\",\"team\",\"or\",\"odr\"]]=season_data[[\"Season\",\"Wteam\",\"Wor\",\"Ldr\"]]\n",
        "orb_data_l=pd.DataFrame()\n",
        "orb_data_l[[\"Season\",\"team\",\"or\",\"odr\"]]=season_data[[\"Season\",\"Lteam\",\"Lor\",\"Wdr\"]]\n",
        "\n",
        "orb_data=pd.concat((orb_data_w,orb_data_l),axis=0)\n",
        "orb_data=orb_data.groupby([\"Season\",\"team\"]).sum().reset_index()\n",
        "orb_data[\"ORB%\"]=orb_data[\"or\"]/(orb_data[\"or\"]+orb_data[\"odr\"])\n",
        "\n",
        "orb_data=orb_data[[\"Season\",\"team\",\"ORB%\"]]\n",
        "training_data=loadInTraining(\"ORB%\",orb_data)\n",
        "training_data.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "3b7ac165-1cdf-ad57-a583-14c93368c9f6"
      },
      "source": [
        "**DRB% - Defensive Rebound Percentage**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "56d5a609-f3f8-bad5-8d15-b4cba0be56d4"
      },
      "outputs": [],
      "source": [
        "season_data=pd.read_csv(\"../input/RegularSeasonDetailedResults.csv\")\n",
        "\n",
        "drb_data_w=pd.DataFrame()\n",
        "drb_data_w[[\"Season\",\"team\",\"dr\",\"oor\"]]=season_data[[\"Season\",\"Wteam\",\"Wdr\",\"Lor\"]]\n",
        "drb_data_l=pd.DataFrame()\n",
        "drb_data_l[[\"Season\",\"team\",\"dr\",\"oor\"]]=season_data[[\"Season\",\"Lteam\",\"Ldr\",\"Wor\"]]\n",
        "\n",
        "drb_data=pd.concat((drb_data_w,drb_data_l),axis=0)\n",
        "drb_data=drb_data.groupby([\"Season\",\"team\"]).sum().reset_index()\n",
        "drb_data[\"DRB%\"]=drb_data[\"dr\"]/(drb_data[\"dr\"]+drb_data[\"oor\"])\n",
        "\n",
        "drb_data=drb_data[[\"Season\",\"team\",\"DRB%\"]]\n",
        "training_data=loadInTraining(\"DRB%\",drb_data)\n",
        "training_data.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "36c7fa35-04cd-ff6b-598f-a36227a13e7a"
      },
      "source": [
        "**FTR - Free Throw Rate**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "78e07857-9410-cfb4-2b80-b6cd9c6ff21e"
      },
      "outputs": [],
      "source": [
        "season_data=pd.read_csv(\"../input/RegularSeasonDetailedResults.csv\")\n",
        "\n",
        "ftr_data_w=pd.DataFrame()\n",
        "ftr_data_w[[\"Season\",\"team\",\"ft\",\"fga\"]]=season_data[[\"Season\",\"Wteam\",\"Wftm\",\"Wfga\"]]\n",
        "ftr_data_l=pd.DataFrame()\n",
        "ftr_data_l[[\"Season\",\"team\",\"ft\",\"fga\"]]=season_data[[\"Season\",\"Lteam\",\"Lftm\",\"Lfga\"]]\n",
        "\n",
        "ftr_data=pd.concat((ftr_data_w,ftr_data_l),axis=0)\n",
        "ftr_data=ftr_data.groupby([\"Season\",\"team\"]).sum().reset_index()\n",
        "ftr_data[\"FTR\"]=ftr_data[\"ft\"]/ftr_data[\"fga\"]\n",
        "\n",
        "ftr_data=ftr_data[[\"Season\",\"team\",\"FTR\"]]\n",
        "training_data=loadInTraining(\"FTR\",ftr_data)\n",
        "training_data.head()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "f9cff636-1c9a-41c5-00eb-560f2e4eda90"
      },
      "source": [
        "**SdN - Seed Number**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "707befe9-d758-43c6-63a4-2808083b24d0"
      },
      "outputs": [],
      "source": [
        "seed_data=pd.read_csv(\"../input/TourneySeeds.csv\")\n",
        "\n",
        "seed_data[\"SdN\"]=[int(str(x)[1:3]) for x in seed_data[\"Seed\"]]\n",
        "seed_data[\"team\"]=seed_data[\"Team\"]\n",
        "\n",
        "seed_data=seed_data[[\"Season\",\"team\",\"SdN\"]]\n",
        "training_data=loadInTraining(\"SdN\",seed_data)\n",
        "training_data.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "e89dde96-3d06-a5b4-dfc3-c7a288038a18"
      },
      "source": [
        "**dFT - Defensive Free Throw Rate**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "08bf48c7-18d8-d4a1-1490-01aaa1a6729e"
      },
      "outputs": [],
      "source": [
        "season_data=pd.read_csv(\"../input/RegularSeasonDetailedResults.csv\")\n",
        "\n",
        "ftr_data_w=pd.DataFrame()\n",
        "ftr_data_w[[\"Season\",\"team\",\"ft\",\"fga\"]]=season_data[[\"Season\",\"Wteam\",\"Lftm\",\"Lfga\"]]\n",
        "ftr_data_l=pd.DataFrame()\n",
        "ftr_data_l[[\"Season\",\"team\",\"ft\",\"fga\"]]=season_data[[\"Season\",\"Lteam\",\"Wftm\",\"Wfga\"]]\n",
        "\n",
        "ftr_data=pd.concat((ftr_data_w,ftr_data_l),axis=0)\n",
        "ftr_data=ftr_data.groupby([\"Season\",\"team\"]).sum().reset_index()\n",
        "ftr_data[\"dFT\"]=ftr_data[\"ft\"]/ftr_data[\"fga\"]\n",
        "\n",
        "ftr_data=ftr_data[[\"Season\",\"team\",\"dFT\"]]\n",
        "training_data=loadInTraining(\"dFT\",ftr_data)\n",
        "training_data.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "4fde03a5-b403-e287-93dc-90417c2efab6"
      },
      "source": [
        "## Model sketch ##"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "7482edd0-2056-0705-bff6-39d14bbba801"
      },
      "outputs": [],
      "source": [
        "X = pd.DataFrame()\n",
        "X = training_data.loc[training_data[\"Season\"]<2013].copy()\n",
        "X = X.reindex_axis(sorted(X.columns), axis=1)\n",
        "\n",
        "\n",
        "Xval=pd.DataFrame()\n",
        "Xval = X[:323]\n",
        "X=X[323:]\n",
        "\n",
        "Xtest=pd.DataFrame()\n",
        "Xtest=training_data.loc[training_data[\"Season\"]>=2013].copy()\n",
        "Xtest = Xtest.reindex_axis(sorted(Xtest.columns), axis=1)\n",
        "\n",
        "y = pd.DataFrame()\n",
        "y[\"pred\"]=X[\"pred\"]\n",
        "\n",
        "yval = pd.DataFrame()\n",
        "yval[\"pred\"]=Xval[\"pred\"]\n",
        "\n",
        "ytest = pd.DataFrame()\n",
        "ytest[\"pred\"]=Xtest[\"pred\"]\n",
        "yseeds=ytest.copy()\n",
        "\n",
        "X = X.drop([\"Season\",\"team1\",\"team2\",\"pred\"],axis=1)\n",
        "Xval = Xval.drop([\"Season\",\"team1\",\"team2\",\"pred\"],axis=1)\n",
        "Xseeds=Xtest.copy().drop([\"pred\"],axis=1)\n",
        "Xtest = Xtest.drop([\"Season\",\"team1\",\"team2\",\"pred\"],axis=1)\n",
        "\n",
        "X.head()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "d9131a93-29a4-a846-b119-c083c71c41d5"
      },
      "outputs": [],
      "source": [
        "def normalize(df):\n",
        "    result = df.copy()\n",
        "    for feature_name in df.columns:\n",
        "        max_value = df[feature_name].max()\n",
        "        min_value = df[feature_name].min()\n",
        "        if max_value>1:\n",
        "            result[feature_name] = (df[feature_name] - min_value) / (max_value - min_value)\n",
        "    return result\n",
        "\n",
        "X=normalize(X)\n",
        "Xval=normalize(Xval)\n",
        "Xtest=normalize(Xtest)\n",
        "Xval.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "b2556f9e-223d-a860-c577-7bb915a80409"
      },
      "source": [
        "**Feature reduction**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "acc2bcc3-e0b0-84c2-2180-f9edca235463"
      },
      "outputs": [],
      "source": [
        "Xforest=X.copy()\n",
        "yforest=y.copy()\n",
        "forest=RandomForestClassifier(n_estimators=30)\n",
        "forest.fit(Xforest,yforest)\n",
        "\n",
        "table=pd.concat((pd.DataFrame(Xforest.iloc[:, 0:].columns, columns = ['variable']), \n",
        "           pd.DataFrame(forest.feature_importances_, columns = ['importance'])), \n",
        "          axis = 1).sort_values(by='importance', ascending = False)[:20].reset_index()\n",
        "table=table.drop(\"index\",axis=1)\n",
        "table=table.groupby([table.variable.str[:3]]).sum().reset_index().sort_values(by='importance',ascending=False).reset_index()\n",
        "table=table.drop(\"index\",axis=1)\n",
        "table"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "914341e8-aa96-f3f1-ef15-17713ba9d00d"
      },
      "outputs": [],
      "source": [
        "def reduction(X,features,cant):\n",
        "    delete=features.shape[0]-cant\n",
        "    features=features.sort_values(by=\"importance\",ascending=True).reset_index().drop(\"index\",axis=1)\n",
        "    for i in range(0,delete):\n",
        "        pattern=features.loc[i][\"variable\"]\n",
        "        col=[col for col in X.columns if str(pattern) in col]\n",
        "        X=X.drop(col[0],1)\n",
        "        X=X.drop(col[1],1)\n",
        "    return X\n",
        "        \n",
        "reduct_to=7\n",
        "#X=reduction(X,table,reduct_to)\n",
        "#Xval=reduction(Xval,table,reduct_to)\n",
        "#Xtest=reduction(Xtest,table,reduct_to)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "d680e110-cab5-5d2f-2fc1-f20958b4ad98"
      },
      "source": [
        "**Knn**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "1e7fbbd0-031b-1f24-571a-6d5ce8f96f43"
      },
      "outputs": [],
      "source": [
        "n_neighbors=135\n",
        "knn=KNeighborsClassifier(n_neighbors=n_neighbors, p=2)\n",
        "knn=knn.fit(X,y)\n",
        "\n",
        "knn.score(X,y)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "d1242963-3154-0daa-8bec-5f2de61f2f05"
      },
      "outputs": [],
      "source": [
        "predict=knn.predict(Xval)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "38419127-d64d-cb02-3895-0f5c79fdc99b"
      },
      "outputs": [],
      "source": [
        "accuracy=metrics.accuracy_score(yval, predict)\n",
        "accuracy\n",
        "#print (metrics.classification_report(yval, predict))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "4ba5218e-3099-c69c-4305-60f43a1b1635"
      },
      "source": [
        "##  Test set ##"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "234d52f1-922b-6d24-27d0-b0ede72b21a7"
      },
      "outputs": [],
      "source": [
        "predict_test=knn.predict(Xtest)\n",
        "probs = knn.predict_proba(Xtest)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "df02350f-a5ff-63e2-ef76-bc3c37a3b0b8"
      },
      "outputs": [],
      "source": [
        "xtr=pd.concat((probs,predic_test,ytest),axis=0)\n",
        "xtr=xtr.loc[xtr[]]\n",
        "\n",
        "#accuracy_xtreme=metrics.accuracy_score(ytest,probs)\n",
        "#accuracy_xtreme"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "162d2f50-dac4-8322-1a0c-420e54f4f00c"
      },
      "outputs": [],
      "source": [
        "accuracy_test=metrics.accuracy_score(ytest, predict_test)\n",
        "accuracy_test\n",
        "\n",
        "#print (metrics.classification_report(ytest, predict))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "d72c9665-f5c9-0349-e26f-97a2ad38c70e"
      },
      "source": [
        "#Create submission file#"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "10a93929-fc90-f81f-c32d-d54f4118cf41"
      },
      "outputs": [],
      "source": [
        "bestScore=pd.Series.from_csv(\"../working/BestCase.csv\")\n",
        "if bestScore.values[0]>accuracy_test:\n",
        "    grabar=False\n",
        "else:\n",
        "    grabar=True\n",
        "    scoreTest=pd.Series(accuracy_test,index=[\"accuracy\"])\n",
        "    scoreTest.to_csv(\"../working/BestCase.csv\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "321689e0-9b10-e354-d621-ea609553edcb"
      },
      "outputs": [],
      "source": [
        "if grabar:\n",
        "    tourney_seeds=pd.read_csv(\"../input/TourneySeeds.csv\")\n",
        "    tourney_seeds.head()\n",
        "    model=knn\n",
        "    submission=pd.DataFrame()\n",
        "    Xseeds.head()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "612d4893-d646-615a-9196-c5e1d02303f6"
      },
      "outputs": [],
      "source": [
        "def getValues(seeds,team,year):\n",
        "    seeds_season=seeds.copy().reset_index().drop(\"index\",1)\n",
        "    seeds_season=seeds_season.loc[seeds_season[\"Season\"]==year]\n",
        "    seeds_season=seeds_season.loc[(seeds_season[\"team1\"]==team) | (seeds_season[\"team2\"]==team)].reset_index()\n",
        "    if seeds_season.loc[0][\"team1\"]==team:\n",
        "        values=seeds_season.loc[0].drop([\"Season\"])\n",
        "        values=values.drop([col for col in X.columns if str(\"2\") in col])\n",
        "    else:\n",
        "        values=seeds_season.loc[0].drop([\"Season\"])\n",
        "        values=values.drop([col for col in X.columns if str(\"1\") in col])\n",
        "    values=values.drop([\"index\",\"team1\",\"team2\"])\n",
        "    return values"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "0543d699-646f-9003-f0fb-e23c07bd1758"
      },
      "outputs": [],
      "source": [
        "def getDataFrame(one,two):\n",
        "    one=pd.DataFrame({'variable':one.index, 'value':one.values})\n",
        "    one=one.set_index([\"variable\"]).transpose()\n",
        "    one=one.rename(columns= lambda x: str(x)[:-1])\n",
        "    one=one.rename(columns= lambda x: str(x+\"1\"))\n",
        "    \n",
        "    two=pd.DataFrame({'variable':two.index, 'value':two.values})\n",
        "    two=two.set_index([\"variable\"]).transpose()\n",
        "    two=two.rename(columns= lambda x: str(x)[:-1])\n",
        "    two=two.rename(columns= lambda x: str(x+\"2\"))\n",
        "\n",
        "    frame=pd.concat((one,two),axis=1)\n",
        "    frame = frame.reindex_axis(sorted(frame.columns), axis=1)\n",
        "    frame=frame.reset_index().drop(\"index\",axis=1)\n",
        "    frame= frame.rename_axis(None,axis=1)\n",
        "    return frame"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "a0802e43-9f5e-2c80-dca8-7309933b2560"
      },
      "outputs": [],
      "source": [
        "#2013\n",
        "if grabar:\n",
        "    seeds_2013=tourney_seeds.loc[tourney_seeds[\"Season\"] == 2013]\n",
        "    seeds_2013=seeds_2013.sort_values(\"Team\", ascending=[1])\n",
        "    seeds_2013.head()\n",
        "\n",
        "    submission_2013=pd.DataFrame()\n",
        "    submission_2013 = pd.DataFrame(columns=('id', 'pred'))\n",
        "    for index in range(0,seeds_2013.shape[0]):\n",
        "        for index2 in range(0,seeds_2013.shape[0]):\n",
        "            if seeds_2013.iloc[index][\"Team\"]<seeds_2013.iloc[index2][\"Team\"]:\n",
        "                    team1=seeds_2013.iloc[index][\"Team\"]\n",
        "                    values1=getValues(Xseeds,team1,2013)\n",
        "                    team2=seeds_2013.iloc[index2][\"Team\"]\n",
        "                    values2=getValues(Xseeds,team2,2013)\n",
        "                    ids=\"2013_\" + str(team1) + \"_\" + str(team2)\n",
        "                    probs=model.predict_proba(getDataFrame(values1,values2))\n",
        "                    pred=probs[0][0]\n",
        "                    submission_2013.loc[submission_2013.shape[0]]=[ids,pred]\n",
        "\n",
        "    submission = pd.concat((submission, submission_2013), axis=0)\n",
        "    submission.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "1669e259-9c60-5d91-b893-be5e951d63a8"
      },
      "outputs": [],
      "source": [
        "#2014\n",
        "if grabar:\n",
        "    seeds_2014=tourney_seeds.loc[tourney_seeds[\"Season\"] == 2014]\n",
        "    seeds_2014=seeds_2014.sort_values(\"Team\", ascending=[1])\n",
        "    seeds_2014.head()\n",
        "\n",
        "    submission_2014=pd.DataFrame()\n",
        "    submission_2014 = pd.DataFrame(columns=('id', 'pred'))\n",
        "    for index in range(0,seeds_2014.shape[0]):\n",
        "        for index2 in range(0,seeds_2014.shape[0]):\n",
        "            if seeds_2014.iloc[index][\"Team\"]<seeds_2014.iloc[index2][\"Team\"]:\n",
        "                    team1=seeds_2014.iloc[index][\"Team\"]\n",
        "                    values1=getValues(Xseeds,team1,2014)\n",
        "                    team2=seeds_2014.iloc[index2][\"Team\"]\n",
        "                    values2=getValues(Xseeds,team2,2014)\n",
        "                    ids=\"2014_\" + str(team1) + \"_\" + str(team2)\n",
        "                    probs=model.predict_proba(getDataFrame(values1,values2))\n",
        "                    pred=probs[0][0]\n",
        "                    submission_2014.loc[submission_2014.shape[0]]=[ids,pred]\n",
        "                \n",
        "    submission = pd.concat((submission, submission_2014), axis=0)\n",
        "    submission.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "044aa240-0308-4d1a-24fb-94a5afbdb8fa"
      },
      "outputs": [],
      "source": [
        "#2015\n",
        "if grabar:\n",
        "    seeds_2015=tourney_seeds.loc[tourney_seeds[\"Season\"] == 2015]\n",
        "    seeds_2015=seeds_2015.sort_values(\"Team\", ascending=[1])\n",
        "    seeds_2015.head()\n",
        "\n",
        "    submission_2015=pd.DataFrame()\n",
        "    submission_2015 = pd.DataFrame(columns=('id', 'pred'))\n",
        "    for index in range(0,seeds_2015.shape[0]):\n",
        "        for index2 in range(0,seeds_2015.shape[0]):\n",
        "            if seeds_2015.iloc[index][\"Team\"]<seeds_2015.iloc[index2][\"Team\"]:\n",
        "                    team1=seeds_2015.iloc[index][\"Team\"]\n",
        "                    values1=getValues(Xseeds,team1,2015)\n",
        "                    team2=seeds_2015.iloc[index2][\"Team\"]\n",
        "                    values2=getValues(Xseeds,team2,2015)\n",
        "                    ids=\"2015_\" + str(team1) + \"_\" + str(team2)\n",
        "                    probs=model.predict_proba(getDataFrame(values1,values2))\n",
        "                    pred=probs[0][0]\n",
        "                    submission_2015.loc[submission_2015.shape[0]]=[ids,pred]\n",
        "                \n",
        "    submission = pd.concat((submission, submission_2015), axis=0)\n",
        "    submission.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "440873cd-0887-69a1-c0ba-d49e2d5568b2"
      },
      "outputs": [],
      "source": [
        "#2016\n",
        "if grabar:\n",
        "    \n",
        "    seeds_2016=tourney_seeds.loc[tourney_seeds[\"Season\"] == 2016]\n",
        "    seeds_2016=seeds_2016.sort_values(\"Team\", ascending=[1])\n",
        "    seeds_2016.head()\n",
        "\n",
        "    submission_2016=pd.DataFrame()\n",
        "    submission_2016 = pd.DataFrame(columns=('id', 'pred'))\n",
        "    for index in range(0,seeds_2016.shape[0]):\n",
        "        for index2 in range(0,seeds_2016.shape[0]):\n",
        "            if seeds_2016.iloc[index][\"Team\"]<seeds_2016.iloc[index2][\"Team\"]:\n",
        "                    team1=seeds_2016.iloc[index][\"Team\"]\n",
        "                    values1=getValues(Xseeds,team1,2016)\n",
        "                    team2=seeds_2016.iloc[index2][\"Team\"]\n",
        "                    values2=getValues(Xseeds,team2,2016)\n",
        "                    ids=\"2016_\" + str(team1) + \"_\" + str(team2)\n",
        "                    probs=model.predict_proba(getDataFrame(values1,values2))\n",
        "                    pred=probs[0][0]\n",
        "                    submission_2016.loc[submission_2016.shape[0]]=[ids,pred]\n",
        "                \n",
        "    submission = pd.concat((submission, submission_2016), axis=0)\n",
        "    submission.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "f1a42fd8-d0eb-b06b-309f-1cadd94d0da9"
      },
      "outputs": [],
      "source": [
        "if grabar:\n",
        "    submission.to_csv('../working/submission.csv', index=False)"
      ]
    }
  ],
  "metadata": {
    "_change_revision": 0,
    "_is_fork": false,
    "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": 0
}