Website Notebook- FINAL.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Website Notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Standard imports\n",
    "# If any of these don't work, try doing `pip install _____`, or try looking up the error message.\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import json\n",
    "import time\n",
    "import os.path\n",
    "from os import path\n",
    "import math\n",
    "import datetime\n",
    "import unidecode\n",
    "import requests\n",
    "from bs4 import BeautifulSoup\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Modules from sportsrefernece.ncaab for college basketball\n",
    "from sportsreference.ncaab.boxscore import Boxscore as NCAAB_Boxscore\n",
    "from sportsreference.ncaab.conferences import Conferences as NCAAB_Conferences\n",
    "from sportsreference.ncaab.rankings import Rankings as NCAAB_Rankings\n",
    "from sportsreference.ncaab.roster import Player as NCAAB_Player\n",
    "from sportsreference.ncaab.roster import Roster as NCAAB_Roster\n",
    "from sportsreference.ncaab.schedule import Schedule as NCAAB_Schedule\n",
    "from sportsreference.ncaab.teams import Teams as NCAAB_Teams\n",
    "\n",
    "# Modules from sportsrefernece.nba for NBA basketball\n",
    "from sportsreference.nba.boxscore import Boxscore as NBA_Boxscore\n",
    "from sportsreference.nba.roster import Player as NBA_Player\n",
    "from sportsreference.nba.roster import Roster as NBA_Roster\n",
    "from sportsreference.nba.schedule import Schedule as NBA_Schedule\n",
    "from sportsreference.nba.teams import Teams as NBA_Teams"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hi everyone! In this notebook, we will be constructing a variety of different machine learning models to predict NBA rookie statlines from different college players input from the Anvil App!\n",
    "\n",
    "Let's get started!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A. College Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**In order for us to pass up college stats for this player to be viewed in the front-end, we will need to:**\n",
    "1. Clean the name\n",
    "2. Find the college player stats for the input name\n",
    "    - If they don't exist, tell the user that they don't, and provide the correct error message"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Find college player stats for input name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This method should hopefully reduce the number of failure cases.\n",
    "def convert_nba_ncaa_name(name: str) -> str:\n",
    "    \"\"\"\n",
    "    Converts the format of the NBA player_id to the NCAA player_id.\n",
    "\n",
    "    You may want to elaborate on the logic on this function to reduce the number of failure cases later.\n",
    "    \"\"\"\n",
    "    return unidecode.unidecode(name.lower().replace(\" \", \"-\") + \"-1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Find the college player stats for the input name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_college_stats(player_name: str) -> dict:\n",
    "    \"\"\"\n",
    "    Return a dictionary with the following keys:\n",
    "    \n",
    "    success: If the player was correctly found (boolean)\n",
    "    data: Player data (pd.Dataframe)\n",
    "    error: Error message, if success is false (string)\n",
    "    \"\"\"\n",
    "    response = {}\n",
    "    clean_name = convert_nba_ncaa_name(player_name)\n",
    "    \n",
    "    # Checking if player does exist with current name\n",
    "    try:\n",
    "        player_data = NCAAB_Player(clean_name).dataframe\n",
    "    except TypeError:\n",
    "        response['success'] = False\n",
    "        response['data'] = None\n",
    "        response['error'] = \"This player doesn't exist (or its name is not in the correct format). Please try a different player name.\"\n",
    "        return response\n",
    "\n",
    "    player_data.rename(columns=lambda x: 'NCAAB_' + x, inplace=True)\n",
    "    last_year = player_data.iloc[[player_data.shape[0] - 2]]\n",
    "    last_year.set_index(pd.Index(data=[player_name], name='Name'), inplace=True)\n",
    "    \n",
    "    response['success'] = True\n",
    "    response['data'] = last_year # Change for Matt's formatting\n",
    "    response['error'] = None\n",
    "    return response"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ayton = get_college_stats('Deandre Ayton')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ayton['data']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: anvil-uplink in ./env/lib/python3.6/site-packages\n",
      "Requirement already satisfied: future in ./env/lib/python3.6/site-packages (from anvil-uplink)\n",
      "Requirement already satisfied: six in ./env/lib/python3.6/site-packages (from anvil-uplink)\n",
      "Requirement already satisfied: argparse in ./env/lib/python3.6/site-packages (from anvil-uplink)\n",
      "Requirement already satisfied: ws4py in ./env/lib/python3.6/site-packages (from anvil-uplink)\n",
      "\u001b[33mYou are using pip version 9.0.3, however version 20.1.1 is available.\n",
      "You should consider upgrading via the 'pip install --upgrade pip' command.\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "# Pip install the library if you don't currently have it\n",
    "!pip install anvil-uplink"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Making front-end endpoint for retrieving college data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Connecting to wss://anvil.works/uplink\n",
      "Anvil websocket open\n",
      "Authenticated OK\n"
     ]
    }
   ],
   "source": [
    "import anvil.server\n",
    "anvil.server.connect(\"GNJSCKQAJWGXCULZ5AFCTV5W-GAZKXCLKC2XXURJE\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@anvil.server.callable\n",
    "def get_college(name):\n",
    "    \"\"\"\n",
    "    Making the front-end to back-end connection, and passing up college data.\n",
    "    \"\"\"\n",
    "    response = get_college_stats(name)\n",
    "    if not response['success']:\n",
    "        return response\n",
    "    \n",
    "    column_names = ['NCAAB_' + name for name in ['points', 'total_rebounds', 'assists', 'steals', 'blocks', 'games_played']]\n",
    "    \n",
    "    def rename_cols(name):\n",
    "        \"\"\"\n",
    "        Rename columns\n",
    "        \"\"\"\n",
    "        new_names = {\n",
    "            'NCAAB_points': 'pts',\n",
    "            'NCAAB_total_rebounds': 'reb',\n",
    "            'NCAAB_assists': 'ast',\n",
    "            'NCAAB_steals': 'stl',\n",
    "            'NCAAB_blocks': 'blk',\n",
    "        }\n",
    "        if name == 'Name':\n",
    "            return name\n",
    "        return new_names[name]\n",
    "    \n",
    "    new_data = response['data']\n",
    "    per_game = (new_data[column_names] / int(new_data['NCAAB_games_played'].values)).drop(columns=['NCAAB_games_played'])\n",
    "    renamed = per_game.iloc[0].apply(lambda x: round(x, 2)).rename(lambda x: rename_cols(x))\n",
    "    renamed['Name'] = name\n",
    "    response['data'] = [renamed.to_dict()]\n",
    "    return response"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "get_college('Ben Simmons')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "get_college('Stephen Curry')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# B. Clean/Process Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Splitting data\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "data = pd.read_csv('player_data.csv')\n",
    "NBA_col = ['NBA_points', 'NBA_total_rebounds', 'NBA_assists', 'NBA_steals', 'NBA_blocks']\n",
    "train, test = data.drop(columns=NBA_col), data[NBA_col].set_index(pd.Index(data=data['name'], name='name'))\n",
    "train.set_index('name', inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_null(df):\n",
    "    \"\"\"\n",
    "    Returns all columns that have a null value in the player's data\n",
    "    \"\"\"\n",
    "    return df.columns[df.isna().any()].tolist()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**In order for us to make predictions from the college data to be rendering in the front-end, we first need to:**\n",
    "1. Drop unneeded columns\n",
    "2. Clean the data the same way we did in our initial data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Drop unneeded columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def drop_columns(data: pd.DataFrame) -> pd.DataFrame:\n",
    "    \"\"\"\n",
    "    Drops the columns from the input college data.\n",
    "    \"\"\"\n",
    "    def drop_for_nans(data):\n",
    "        # Drops columns due to NaNs inside the data.\n",
    "        drop_col = [\n",
    "            'NCAAB_box_plus_minus',\n",
    "            'NCAAB_defensive_box_plus_minus',\n",
    "            'NCAAB_offensive_box_plus_minus',\n",
    "            'NCAAB_player_efficiency_rating',\n",
    "            'NCAAB_three_point_percentage',\n",
    "        ]\n",
    "        return data.drop(columns=drop_col)\n",
    "    \n",
    "    def drop_for_qual(data):\n",
    "        # Drops columns due to qualitative data\n",
    "        qual_drop = [\n",
    "            'NCAAB_conference', \n",
    "            'NCAAB_player_id',\n",
    "            'NCAAB_team_abbreviation',\n",
    "        ]\n",
    "        return data.drop(columns=qual_drop)\n",
    "    \n",
    "    return drop_for_nans(drop_for_qual(data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "curry = get_college_stats('Stephen Curry')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_curry = drop_columns(curry['data'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "check_null(new_curry)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Clean the data the same way we did initially"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def clean_qualitative(data: pd.DataFrame) -> pd.DataFrame:\n",
    "    \"\"\"\n",
    "    Cleans the qualitative columns (height, position)\n",
    "    \"\"\"\n",
    "\n",
    "    def convert_height(height: str) -> int:\n",
    "        \"\"\"\n",
    "        Convert height from string to int (6-11 -> 83)\n",
    "        \"\"\"\n",
    "        feet, inches = height.split(\"-\")\n",
    "        return int(feet) * 12 + int(inches)\n",
    "\n",
    "    def clean_position(position: str) -> str:\n",
    "        \"\"\"\n",
    "        If the player has a hypened position, remove the second one.\n",
    "        \"\"\"\n",
    "        return position.split('-')[0]\n",
    "    \n",
    "    def one_hot_position(player):\n",
    "        \"\"\"\n",
    "        Applies one hot encoding to the player's position.\n",
    "        \"\"\"\n",
    "        positions = positions = ['Center', 'Forward', 'Guard']\n",
    "        player[positions] = pd.DataFrame([\n",
    "            [int(p == player['NCAAB_position']) for p in positions]\n",
    "        ], index=player.index)\n",
    "        return player\n",
    "    \n",
    "    data['NCAAB_height'] = data['NCAAB_height'].apply(convert_height)\n",
    "    data['NCAAB_position'] = data['NCAAB_position'].apply(clean_position)\n",
    "    return one_hot_position(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clean_curry = clean_qualitative(new_curry)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "check_null(clean_curry)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def feature_extraction(data: pd.DataFrame) -> pd.DataFrame:\n",
    "    \"\"\"\n",
    "    Takes the columns we've qualitative selected from the dataset to be our features for our model.\n",
    "    \"\"\"\n",
    "    columns_to_keep = [\n",
    "        'NCAAB_assists',\n",
    "        'NCAAB_blocks',\n",
    "        'NCAAB_field_goal_attempts',\n",
    "        'NCAAB_field_goal_percentage',\n",
    "        'NCAAB_field_goals',\n",
    "        'NCAAB_free_throw_attempt_rate',\n",
    "        'NCAAB_free_throw_attempts',\n",
    "        'NCAAB_free_throw_percentage',\n",
    "        'NCAAB_free_throws',\n",
    "        'NCAAB_games_played',\n",
    "        'NCAAB_games_started',\n",
    "        'NCAAB_height',\n",
    "        'NCAAB_personal_fouls',\n",
    "        'NCAAB_points',\n",
    "        'NCAAB_steal_percentage',\n",
    "        'NCAAB_steals',\n",
    "        'NCAAB_three_point_attempt_rate',\n",
    "        'NCAAB_three_point_attempts',\n",
    "        'NCAAB_total_rebound_percentage',\n",
    "        'NCAAB_total_rebounds',\n",
    "        'NCAAB_turnover_percentage',\n",
    "        'NCAAB_turnovers',\n",
    "        'NCAAB_two_point_attempts',\n",
    "        'NCAAB_two_point_percentage',\n",
    "        'NCAAB_win_shares',\n",
    "        'Guard',\n",
    "        'Forward',\n",
    "        'Center',\n",
    "    ]\n",
    "    return data[columns_to_keep]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "final_curry = feature_extraction(clean_curry)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "check_null(final_curry)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extra_cleaning(player_data, train=False):\n",
    "    \"\"\"\n",
    "    Cleans the player's data further if there's any NaN values (older players).\n",
    "    \"\"\"\n",
    "    def check_null(df):\n",
    "        \"\"\"\n",
    "        Returns all columns that have a null value in the player's data\n",
    "        \"\"\"\n",
    "        return df.columns[df.isna().any()].tolist()\n",
    "    \n",
    "    columns = check_null(player_data)\n",
    "    if columns:\n",
    "        for column in columns:\n",
    "            # Replace value with the average of our training set\n",
    "            player_data.loc[:, column] = train.mean()[column]\n",
    "    return player_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def format_data(player_data, train):\n",
    "    \"\"\"\n",
    "    Returns the processed data in correct format for inputting into our models.\n",
    "    \"\"\"\n",
    "    cols_dropped = drop_columns(player_data)\n",
    "    clean_data = clean_qualitative(cols_dropped)\n",
    "    featured_data = feature_extraction(clean_data)\n",
    "    final_data = extra_cleaning(featured_data, train)\n",
    "    return final_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "format_data(curry['data'], train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# C. Make Models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**In order for us to make our predictions, we first take a look at all the different models we've made for the project.**\n",
    "\n",
    "1. LinearRegression\n",
    "2. K-Means\n",
    "3. DecisionTrees\n",
    "4. Neural Networks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(train, test, test_size=0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Re-shuffle data\n",
    "def shuffle(train, test):\n",
    "    \"\"\"\n",
    "    Shuffe the data around for re-trying results.\n",
    "    \"\"\"\n",
    "    X_train, X_test, y_train, y_test = train_test_split(train, test, test_size=0.2)\n",
    "    return X_train, X_test, y_train, y_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loss function\n",
    "def RMSE(y, y_pred):\n",
    "    \"\"\"\n",
    "    Calculates the root mean squared error of the model's predictions.\n",
    "    \"\"\"\n",
    "    return np.sqrt(np.mean((y - y_pred) ** 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Total loss function\n",
    "def all_RMSE(y, y_pred):\n",
    "    \"\"\"\n",
    "    Calculates the RMSE by each of the different stats, and the total RMSE\n",
    "    \"\"\"\n",
    "    rmses = {}\n",
    "    for num, name in enumerate(y_pred.columns):\n",
    "        rmses[name] = RMSE(y[:, num], y_pred[name])\n",
    "    rmses['Total RMSE'] = sum(rmses.values())\n",
    "    return pd.Series(rmses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Standardize our data\n",
    "def standardize(train, test):\n",
    "    \"\"\"\n",
    "    Standardize both train and test based off of train's means and std's.\n",
    "    \"\"\"\n",
    "    means, stds = train.mean(), train.std()\n",
    "    norm_train = (train - means) / stds\n",
    "    norm_test = (test - means) / stds\n",
    "    return norm_train, norm_test, means, stds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1A. Linear Regression (without standardization)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = shuffle(train, test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create model\n",
    "from sklearn.linear_model import LinearRegression\n",
    "linear_model = LinearRegression()\n",
    "linear_model.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make predictions\n",
    "y_pred = linear_model.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# RMSE for points\n",
    "RMSE(y_test.values[:, 0], y_pred[:, 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Total RMSE\n",
    "all_RMSE(y_pred, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1B. Linear Regression (with standardization)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = shuffle(train, test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Standardize data\n",
    "norm_X_train, norm_X_test, _, _ = standardize(X_train, X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create model\n",
    "from sklearn.linear_model import LinearRegression\n",
    "linear_model = LinearRegression()\n",
    "linear_model.fit(norm_X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make predictions\n",
    "y_pred = linear_model.predict(norm_X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# RMSE for points\n",
    "RMSE(y_test.values[:, 0], y_pred[:, 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Total RMSE\n",
    "all_RMSE(y_pred, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. K-Means"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Shuffle the data up\n",
    "X_train, X_test, y_train, y_test = shuffle(train, test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Standardize data\n",
    "norm_X_train, norm_X_test, _, _ = standardize(X_train, X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fit model and produce labels\n",
    "from sklearn.cluster import KMeans\n",
    "k_means_cluster = KMeans(n_clusters=120, max_iter=10000, n_init=100).fit(norm_X_train.values)\n",
    "X_copy = norm_X_train.copy(deep=True)\n",
    "X_copy['label'] = k_means_cluster.labels_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Find the predicted labels of the test set\n",
    "label_pred = k_means_cluster.predict(norm_X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_predictions(labels, X_copy, y_train):\n",
    "    \"\"\"\n",
    "    Finds the predictions for these different players\n",
    "    \"\"\"\n",
    "    all_preds = []\n",
    "    for label in label_pred:\n",
    "        similar_players = X_copy[X_copy['label'] == label].index\n",
    "        similar_avg_stats = y_train.loc[similar_players].mean()\n",
    "        all_preds.append(similar_avg_stats.values)\n",
    "    return np.array(all_preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Find stat predictions for the test set\n",
    "y_pred = find_predictions(label_pred, X_copy, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# RMSE for points\n",
    "RMSE(y_test.values[:, 0], y_pred[:, 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Total RMSE\n",
    "all_RMSE(y_pred, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2B. Run K-Means multiple times for long-term RMSEs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_x_times(x):\n",
    "    \"\"\"\n",
    "    Runs K-Means 'x' number of times to average the RMSEs.\n",
    "    \"\"\"\n",
    "    total_avg = []\n",
    "    for _ in range(10):\n",
    "        # Shuffle the data up\n",
    "        X_train, X_test, y_train, y_test = shuffle(train, test)\n",
    "\n",
    "        # Standardize data\n",
    "        norm_X_train, norm_X_test, _, _ = standardize(X_train, X_test)\n",
    "\n",
    "        # Fit model and produce labels\n",
    "        from sklearn.cluster import KMeans\n",
    "        k_means_cluster = KMeans(n_clusters=120, max_iter=10000, n_init=100).fit(norm_X_train.values)\n",
    "        X_copy = norm_X_train.copy(deep=True)\n",
    "        X_copy['label'] = k_means_cluster.labels_\n",
    "\n",
    "        # Find the predicted labels of the test set\n",
    "        label_pred = k_means_cluster.predict(norm_X_test)\n",
    "\n",
    "        def find_predictions(labels, X_copy, y_train):\n",
    "            \"\"\"\n",
    "            Finds the predictions for these different players\n",
    "            \"\"\"\n",
    "            all_preds = []\n",
    "            for label in label_pred:\n",
    "                similar_players = X_copy[X_copy['label'] == label].index\n",
    "                similar_avg_stats = y_train.loc[similar_players].mean()\n",
    "                all_preds.append(similar_avg_stats.values)\n",
    "            return np.array(all_preds)\n",
    "\n",
    "        # Find stat predictions for the test set\n",
    "        y_pred = find_predictions(label_pred, X_copy, y_train)\n",
    "        total_avg.append(all_RMSE(y_pred, y_test).values)\n",
    "        \n",
    "    return np.array(total_avg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "avgs = run_x_times(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(5):\n",
    "    print(np.mean(avgs[:, i]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Decision Trees"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Shuffle data\n",
    "X_train, X_test, y_train, y_test = shuffle(train, test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Standardize data\n",
    "norm_X_train, norm_X_test, _, _ = standardize(X_train, X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create model\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "DTR = DecisionTreeRegressor(min_samples_split=5, max_depth=15)\n",
    "DTR.fit(norm_X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Training RMSE\n",
    "all_RMSE(DTR.predict(norm_X_train), y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test total RMSE\n",
    "all_RMSE(DTR.predict(norm_X_test), y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 Trying variety of different Decision Trees"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.tree import DecisionTreeRegressor\n",
    "from sklearn.ensemble import ExtraTreesRegressor\n",
    "from sklearn.ensemble import RandomForestRegressor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "DT_errors = []\n",
    "ET_errors = []\n",
    "RF_errors = []\n",
    "\n",
    "def fit_predict_error(model, X_train, y_train, X_test, y_test):\n",
    "    model.fit(X_train, y_train)\n",
    "    return RMSE(model.predict(X_test), y_test)\n",
    "\n",
    "for i in range(1, 25):\n",
    "    DTR = DecisionTreeRegressor(max_depth=i)\n",
    "    error = fit_predict_error(DTR, norm_X_train, y_train, norm_X_test, y_test)\n",
    "    DT_errors.append(error.values)\n",
    "    \n",
    "    ETR = ExtraTreesRegressor(max_depth=i)\n",
    "    error = fit_predict_error(ETR, norm_X_train, y_train, norm_X_test, y_test)\n",
    "    ET_errors.append(error.values)\n",
    "    \n",
    "    RFR = RandomForestRegressor(max_depth=i)\n",
    "    error = fit_predict_error(RFR, norm_X_train, y_train, norm_X_test, y_test)\n",
    "    RF_errors.append(error.values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'DT_errors' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-5-50c49b36f1d1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;31m# Plotting RMSE's for points\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfigsize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m8\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mDT_errors\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'Decision Tree Error'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mET_errors\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'Extra Trees Error'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mRF_errors\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'Random Forest Error'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'DT_errors' is not defined"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 720x576 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Plotting RMSE's for points\n",
    "plt.figure(figsize=(10, 8))\n",
    "plt.plot(np.array(DT_errors)[:, 0], label='Decision Tree Error')\n",
    "plt.plot(np.array(ET_errors)[:, 0], label='Extra Trees Error')\n",
    "plt.plot(np.array(RF_errors)[:, 0], label='Random Forest Error')\n",
    "plt.legend()\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Neural Networks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Shuffle the data up\n",
    "X_train, X_test, y_train, y_test = shuffle(train, test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Standardize data\n",
    "norm_X_train, norm_X_test, x_means, x_stds = standardize(X_train, X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'y_train' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-6-d73af938b7fb>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxes\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msubplots\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfigsize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m15\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mcol_num\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_train\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m     \u001b[0msns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdistplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_train\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miloc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcol_num\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_frame\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0max\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0maxes\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcol_num\u001b[0m \u001b[0;34m//\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcol_num\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m;\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'y_train' is not defined"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x720 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Y-value skewness\n",
    "import seaborn as sns\n",
    "\n",
    "fig, axes = plt.subplots(2, 3, figsize=(15, 10))\n",
    "for col_num in range(len(y_train.columns)):\n",
    "    sns.distplot(y_train.iloc[:, col_num].to_frame(), ax=axes[col_num // 3][col_num % 3]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### STANDARDIZE Y-VALUES (this is because y_values are so skewed)\n",
    "norm_y_train, _, y_means, y_stds = standardize(y_train, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "# Import libraries for model\n",
    "import keras\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_nn_arch():\n",
    "    \"\"\"\n",
    "    Make basic neural network architecture for our dataset.\n",
    "    \"\"\"\n",
    "    model = Sequential()\n",
    "    model.add(Dense(35, activation='tanh', input_shape=(28,)))\n",
    "    model.add(Dense(15, activation='tanh', input_shape=(35,)))\n",
    "    model.add(Dense(1, activation='tanh', input_shape=(15,)))\n",
    "    # For a mean squared error regression problem\n",
    "    model.compile(\n",
    "        optimizer=keras.optimizers.SGD(\n",
    "            lr=0.001,\n",
    "            momentum=0.9,\n",
    "            nesterov=True\n",
    "        ), #How to Learn\n",
    "        loss='mse', # What to Learn\n",
    "    )\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create and fit Neural Network\n",
    "model = make_nn_arch()\n",
    "model.fit(\n",
    "    x=norm_X_train,\n",
    "    y=norm_y_train['NBA_points'], \n",
    "    epochs=100,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loss function\n",
    "def RMSE(y, y_pred):\n",
    "    \"\"\"\n",
    "    Calculates the root mean squared error of the model's predictions.\n",
    "    \"\"\"\n",
    "    return np.sqrt(np.mean((y - y_pred) ** 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make predictions\n",
    "y_pred = model.predict(norm_X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# RMSE for points\n",
    "RMSE(((y_pred * y_stds['NBA_points']) + y_means['NBA_points']).flatten(), y_test['NBA_points'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1 Make Neural Networks for all stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_all_and_predict():\n",
    "    \n",
    "    rmses = []\n",
    "    \n",
    "    for column in y_train.columns:\n",
    "\n",
    "        # Create and fit Neural Network\n",
    "        model = make_nn_arch()\n",
    "        model.fit(\n",
    "            x=norm_X_train,\n",
    "            y=norm_y_train[column], \n",
    "            epochs=100,\n",
    "        )\n",
    "        y_pred = model.predict(norm_X_test)\n",
    "\n",
    "        # RMSE by stat category\n",
    "        rmse = RMSE(((y_pred * y_stds[column]) + y_means[column]).flatten(), y_test[column])\n",
    "        rmses.append(rmse)\n",
    "    \n",
    "    return rmses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "rmses = train_all_and_predict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "rmses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# D. Training the final models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "####################\n",
    "### FINAL MODELS ###\n",
    "####################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Train your best models here! Remove any comments if you don't need them.\n",
    "\n",
    "# Standardize data\n",
    "\n",
    "# Split data\n",
    "\n",
    "# Train models\n",
    "\n",
    "# Predict\n",
    "\n",
    "# Calculate RMSE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Standardize data\n",
    "X_means, X_stds = train.mean(), train.std()\n",
    "y_means, y_stds = test.mean(), test.std()\n",
    "X_norm = (train - X_means) / X_stds\n",
    "y_norm = (test - y_means) / y_stds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_all(X_train, y_train):\n",
    "    \"\"\"\n",
    "    Trains all 5 Neural Networks we need for the 5 stat categories.\n",
    "    \"\"\"\n",
    "    models = {}\n",
    "    \n",
    "    for column in y_train.columns:\n",
    "\n",
    "        # Create and fit Neural Network\n",
    "        model = make_nn_arch()\n",
    "        model.fit(\n",
    "            x=X_train,\n",
    "            y=y_train[column], \n",
    "            epochs=100,\n",
    "        )\n",
    "        models[column] = model\n",
    "        \n",
    "    return models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# {\"Points\": NeuralNetworkObject, \"Rebounds\"...}\n",
    "nn_models = train_all(X_norm, y_norm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@anvil.server.callable\n",
    "def get_predicts(name):\n",
    "    \"\"\"\n",
    "    Return a one-item list with the dictionary in it.\n",
    "    If doesn't exist, return empty list\n",
    "    \"\"\"\n",
    "\n",
    "    def rename_cols(name):\n",
    "        \"\"\"\n",
    "        Rename columns\n",
    "        \"\"\"\n",
    "        new_names = {\n",
    "            'NBA_points': 'pts',\n",
    "            'NBA_total_rebounds': 'reb',\n",
    "            'NBA_assists': 'ast',\n",
    "            'NBA_steals': 'stl',\n",
    "            'NBA_blocks': 'blk',\n",
    "        }\n",
    "        if name == 'Name':\n",
    "            return name\n",
    "        return new_names[name]\n",
    "    \n",
    "    player_data = format_data(get_college_stats(name)['data'], train)\n",
    "    player_norm = (player_data - X_means) / X_stds\n",
    "    \n",
    "    preds = {}\n",
    "    preds['Name'] = name\n",
    "    \n",
    "    # Make predictions and de-standardize\n",
    "    for model_name in nn_models.keys():\n",
    "        stat_pred = nn_models[model_name].predict(player_norm)\n",
    "        preds[rename_cols(model_name)] = max(int((stat_pred * y_stds[model_name]) + y_means[model_name]), 0) / 25 # Non-zero predictions, and making them per-game stats\n",
    "    \n",
    "    return [preds]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run():\n",
    "    while True:\n",
    "        name = input()\n",
    "        if name == 'exit' or name == 'quit':\n",
    "            break\n",
    "        print(get_predicts(name))\n",
    "# name = 'Stephen Curry'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "run()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = get_college_stats('Stephen Curry')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "format_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "format_data(get_college_stats('Stephen Curry')['data'], train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "NCAAB_Player('stephen-curry-1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s['data']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "run()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "get_college('Zion Williamson')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}