ENEE324H_Final_Project_Report_Shareable.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "ENEE324H-Final-Project-Report-Shareable",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/ssaltwick/ENEE324-Project/blob/master/ENEE324H_Final_Project_Report_Shareable.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7pSqIAPEHDcG",
        "colab_type": "text"
      },
      "source": [
        "# ENEE324H Final Project\n",
        "## Sam Saltwick & Frank Lopez\n",
        "\n",
        "### Introduction\n",
        "Our project seeks to cluster basketball players into their respective positions based on a select grouping of their per game average statistics. \n",
        "\n",
        "To see the project in action, check out 'Try It Out' section below"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QkfYepC99EMa",
        "colab_type": "text"
      },
      "source": [
        "### Setup\n",
        "This section contains setup for the code to run, including package imports, data importing, and an enumeration definition."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g7PXGZxZ3bSJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import scipy.stats as stat\n",
        "import math\n",
        "import pandas as pd\n",
        "from enum import Enum\n",
        "from mpl_toolkits import mplot3d\n",
        "from itertools import combinations\n",
        "\n",
        "\n",
        "\n",
        "class Position(Enum):\n",
        "  PG = 0\n",
        "  SG = 1\n",
        "  SF = 2\n",
        "  PF = 3\n",
        "  C = 4\n",
        "  \n",
        "pos_names = {\n",
        "    Position.PG : \"PG\",\n",
        "    Position.SG : \"SG\",\n",
        "    Position.SF : \"SF\",\n",
        "    Position.PF : \"PF\",\n",
        "    Position.C : \"C\",\n",
        "}\n",
        "\n",
        "# Data is hosted on a github repo\n",
        "pg_url = 'https://raw.githubusercontent.com/ssaltwick/ENEE324-Project/master/data/Data-PG-clean.csv'\n",
        "sg_url = 'https://raw.githubusercontent.com/ssaltwick/ENEE324-Project/master/data/Data-SG-clean.csv'\n",
        "sf_url = 'https://raw.githubusercontent.com/ssaltwick/ENEE324-Project/master/data/Data-SF-clean.csv'\n",
        "pf_url = 'https://raw.githubusercontent.com/ssaltwick/ENEE324-Project/master/data/Data-PF-clean.csv'\n",
        "c_url = 'https://raw.githubusercontent.com/ssaltwick/ENEE324-Project/master/data/Data-C-Clean.csv'\n",
        "test_url = 'https://raw.githubusercontent.com/ssaltwick/ENEE324-Project/master/data/Data-Test-Clean.csv'\n",
        "\n",
        "urls = {\n",
        "    Position.PG : pg_url,\n",
        "    Position.SG : sg_url,\n",
        "    Position.SF : sf_url,\n",
        "    Position.PF : pf_url,\n",
        "    Position.C : c_url\n",
        "}\n",
        "\n",
        "# Get test data\n",
        "test_data = pd.read_csv(test_url).fillna(0)\n",
        "test_data['Player'] = test_data['Player'].str.split('\\\\').str[0]\n",
        "\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JXEoWZCPPwAf",
        "colab_type": "text"
      },
      "source": [
        "### Code\n",
        "\n",
        "Below is all of our code for the project. Collapse this section to hide it. It must stay above the testing cells for them to run properly."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A8aqt4cNEXGa",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\"\"\"\n",
        "  Evaluates a player against a position's likelihood.\n",
        "  params: positon = Position Enum\n",
        "          player = numpy array of stats\n",
        "\n",
        "\"\"\"\n",
        "def evaluate_likelihood(position, player, avgs, covs, prior):\n",
        "  mu = avgs[position]\n",
        "  sig = covs[position]\n",
        "  \n",
        "  p = (math.sqrt(2*math.pi)) ** 3\n",
        "  c = 1 / (p * math.sqrt(np.linalg.det(sig)))\n",
        "\n",
        "  \n",
        "  t = np.dot(np.transpose(player-mu), np.dot(sig, (player-mu)))\n",
        "  \n",
        "  \n",
        "  return c * math.exp(-0.5 * t)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o6sia2sREXK1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def guess_position(player, avgs, covs, prior, pos):\n",
        "  positions = {}\n",
        "  \n",
        "  for p in pos:\n",
        "    positions[p] = evaluate_likelihood(p, player, avgs, covs, prior) * prior[p]\n",
        "  \n",
        "  v = list(positions.values())\n",
        "  k = list(positions.keys())\n",
        "  return k[v.index(max(v))]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "swZTYPg-EMpU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def stage1(player, round1_stats, labels):\n",
        "  \n",
        "  positions = [Position.PG, Position.SG, Position.SF, Position.PF, Position.C]\n",
        "  bins = {}\n",
        "  \n",
        "  for l in labels:\n",
        "    tmp = [pos_names[x] for x in l]\n",
        "    bins[''.join(tmp)] = []\n",
        "    \n",
        "  data = {}\n",
        "  for p in positions:\n",
        "    data[p] = pd.read_csv(urls[p]).fillna(0)[round1_stats]  \n",
        "\n",
        "  total_players = 0\n",
        "  for p in positions:\n",
        "    total_players += data[p].shape[0]\n",
        "\n",
        "  # Defines an array of priors (each position's percentage of players)\n",
        "  # TODO: Update with actual priors),\n",
        "\n",
        "  prior = {}\n",
        "  avgs = {}\n",
        "  covs = {}\n",
        "\n",
        "\n",
        "  # TODO: Generate actual MEAN and COV for each position\n",
        "\n",
        "  for p in positions:\n",
        "    prior[p] = data[p].shape[0] / total_players\n",
        "\n",
        "  for p in positions:\n",
        "    avgs[p] = data[p].mean(0).to_numpy()\n",
        "    covs[p] = data[p].cov().to_numpy()\n",
        "\n",
        "  guess = guess_position(player[:,0], avgs, covs, prior, positions)\n",
        "    \n",
        "  for l in labels:\n",
        "    tmp = [pos_names[x] for x in l]\n",
        "    k = ''.join(tmp)\n",
        "    if guess in l:\n",
        "      bins[k].append(player)\n",
        "       \n",
        "  result = \"\"     \n",
        "  for k in bins.keys():\n",
        "    if bins[k]:\n",
        "      result = k\n",
        "      \n",
        "  return result\n",
        "  \n",
        "  "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HVr7Eb_DEOfQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def stage2(labels, stats, test_player):\n",
        "  \n",
        "  positions = [Position.PG, Position.SG, Position.SF, Position.PF, Position.C]\n",
        "  \n",
        "  test_player = test_player[stats].to_numpy()\n",
        "  \n",
        "  bins = {}\n",
        "  for p in labels:\n",
        "    bins[p] = []\n",
        "  \n",
        "  pos_names = {\n",
        "      Position.PG : \"PG\",\n",
        "      Position.SG : \"SG\",\n",
        "      Position.SF : \"SF\",\n",
        "      Position.PF : \"PF\",\n",
        "      Position.C : \"C\",\n",
        "  }\n",
        "  \n",
        "  \n",
        "  data = {}\n",
        "  for p in positions:\n",
        "    data[p] = pd.read_csv(urls[p]).fillna(0)[stats]  \n",
        "\n",
        "\n",
        "  total_players = 0\n",
        "  for p in positions:\n",
        "    total_players += data[p].shape[0]\n",
        "\n",
        "\n",
        "\n",
        "  # Defines an array of priors (each position's percentage of players)\n",
        "  # TODO: Update with actual priors),\n",
        "\n",
        "  prior = {}\n",
        "  avgs = {}\n",
        "  covs = {}\n",
        "\n",
        "\n",
        "  # TODO: Generate actual MEAN and COV for each position\n",
        "\n",
        "\n",
        "  for p in positions:\n",
        "    total_players += data[p].shape[0]\n",
        "\n",
        "  for p in positions:\n",
        "    prior[p] = data[p].shape[0] / total_players\n",
        "\n",
        "  for p in positions:\n",
        "    avgs[p] = data[p].mean(0).to_numpy()\n",
        "    covs[p] = data[p].cov().to_numpy()\n",
        "  \n",
        "  guess = guess_position(test_player.reshape(len(stats),), avgs, covs, prior, labels)\n",
        "\n",
        "  bins[guess].append(test_player)\n",
        "  \n",
        "  return pos_names[guess]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3bcoTrr1G-rl",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def run_model(selected_player, test_data):\n",
        "  # Retrieve selected player from test data\n",
        "  \n",
        "  \n",
        "  test_player = test_data.loc[test_data['Player'].str.lower() == selected_player.lower()]\n",
        "  print(test_player)\n",
        "  if test_player.empty:\n",
        "    print(\"Sorry, we do not have data on %s. Please try again\" % selected_player)\n",
        "    return -1\n",
        "  \n",
        "  player_name = test_player['Player'].tolist()[0]\n",
        "  test_pos = test_player['Pos'].to_string().split()[1]\n",
        "  status = 0\n",
        "\n",
        "  # print(\"Here is %s's stats for the 2018-2019 season\" % selected_player)\n",
        "  # print(test_player)\n",
        "  \n",
        "  [ ('3P%', 'STL', 'ORB', 'Height'), [['3PA', '3P%', '2P%', 'AST', 'STL', 'BLK', 'ORB', 'Height'], ['3PA', '3P%', '2P%', 'ORB', 'Height']]]\n",
        "  \n",
        "  \n",
        "  # Stage 1 - cluster into [PG, SF], [SG, PF], [C] based on \n",
        "  # 3PA, 2P%, AST, FT%, STL, BLK, ORB\n",
        "  s1_stats = ['3P%', 'STL', 'ORB', 'Height']\n",
        "  groups = [[Position.SG, Position.SF], [Position.PG, Position.PF, Position.C]]\n",
        "  s1_result = stage1(np.transpose(test_player[s1_stats].to_numpy()), s1_stats, groups)\n",
        "  \n",
        "  s1_worked = False\n",
        "  if test_pos in s1_result:\n",
        "    print(\"Stage 1 correctly categorized %s as %s\" % (player_name, s1_result))\n",
        "    s1_worked = True\n",
        "\n",
        "  # Stage 2 - Take whichever bin they were placed into and split based on \n",
        "  # [3P%, ORB, TRB], [2P%, TRB], [3PA]\n",
        "  \n",
        "  s2_stats = {\n",
        "      \"SGSF\" : ['3PA', '3P%', '2P%', 'AST', 'STL', 'BLK', 'ORB', 'Height'],\n",
        "      \"PGPFC\" : ['3PA', '3P%', '2P%', 'ORB', 'Height']\n",
        "  }\n",
        "\n",
        "  s2_result = \"Error\"\n",
        "  if s1_result == \"PGPFC\":\n",
        "    s2_result = stage2([Position.PG, Position.PF, Position.C], s2_stats[\"PGPFC\"], test_player)\n",
        "  elif s1_result == \"SGSF\":\n",
        "    s2_result = stage2([Position.SG, Position.SF], s2_stats[\"SGSF\"], test_player)\n",
        " \n",
        "\n",
        "  if s2_result == test_pos:\n",
        "    print(\"Stage 2 correctly categorized %s as a %s\" % (player_name, s2_result))\n",
        "    status = 1\n",
        "  else:\n",
        "    print(\"%s was categorized as a %s in stage 2 but is actually a %s. Try another player.\" %(player_name, s2_result, test_pos))\n",
        "    \n",
        "  return status\n",
        "  \n",
        "\n",
        "  "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x0KXVrkLHi7s",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def run_model_ncaa(selected_player, test_data):\n",
        "  # Retrieve selected player from test data\n",
        "\n",
        "  test_player = test_data.loc[test_data['Player'] == selected_player]\n",
        "  \n",
        "  status = 0\n",
        "\n",
        "  # print(\"Here is %s's stats for the 2018-2019 season\" % selected_player)\n",
        "  # print(test_player)\n",
        "  \n",
        "  [ ('3P%', 'STL', 'ORB', 'Height'), [['3PA', '3P%', '2P%', 'AST', 'STL', 'BLK', 'ORB', 'Height'], ['3PA', '3P%', '2P%', 'ORB', 'Height']]]\n",
        "  \n",
        "  \n",
        "  # Stage 1 - cluster into [PG, SF], [SG, PF], [C] based on \n",
        "  # 3PA, 2P%, AST, FT%, STL, BLK, ORB\n",
        "  s1_stats = ['3P%', 'STL', 'ORB', 'Height']\n",
        "  groups = [[Position.SG, Position.SF], [Position.PG, Position.PF, Position.C]]\n",
        "  s1_result = stage1(np.transpose(test_player[s1_stats].to_numpy()), s1_stats, groups)\n",
        "  \n",
        "  # Stage 2 - Take whichever bin they were placed into and split based on \n",
        "  # [3P%, ORB, TRB], [2P%, TRB], [3PA]\n",
        "  \n",
        "  s2_stats = {\n",
        "      \"SGSF\" : ['3PA', '3P%', '2P%', 'AST', 'STL', 'BLK', 'ORB', 'Height'],\n",
        "      \"PGPFC\" : ['3PA', '3P%', '2P%', 'ORB', 'Height']\n",
        "  }\n",
        "\n",
        "  s2_result = \"Error\"\n",
        "  if s1_result == \"PGPFC\":\n",
        "    s2_result = stage2([Position.PG, Position.PF, Position.C], s2_stats[\"PGPFC\"], test_player)\n",
        "  elif s1_result == \"SGSF\":\n",
        "    s2_result = stage2([Position.SG, Position.SF], s2_stats[\"SGSF\"], test_player)\n",
        " \n",
        "\n",
        "  return s2_result\n",
        "  \n",
        "\n",
        "  "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8OgvOwG7IM9b",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def umd_test():\n",
        "  \n",
        "  \n",
        "  players = {\n",
        "      \"Anthony Cowan\" : \"PG\",\n",
        "      \"Bruno Fernando\": \"C\",\n",
        "      \"Jalen Smith\" : \"PF\",\n",
        "      \"Eric Ayala\" : \"PG\",\n",
        "      \"Darryl Morsell\": \"SF\",\n",
        "      \"Aaron Wiggins\": \"SG\",\n",
        "      \"Serrel Smith Jr\": \"SG\",\n",
        "      \"Ricky Lindo\": \"SF\",\n",
        "      \"Joshua Tomaic\": \"SF\",\n",
        "      \"Ivan Bender\": \"PF\",\n",
        "  }\n",
        "  total = len(players.keys())\n",
        "  correct = 0\n",
        "  umd_url = 'https://raw.githubusercontent.com/ssaltwick/ENEE324-Project/master/data/Test-UMD.csv'\n",
        "  umd_data = pd.read_csv(umd_url).fillna(0)\n",
        "  umd_data['Player'] = umd_data['Player'].str.split('\\\\').str[0]\n",
        "  \n",
        "  for k,v in players.items():\n",
        "    res = run_model_ncaa(k, umd_data)\n",
        "    if res == v:\n",
        "      print(\"Correctly categorized %s as a %s\" % (k,v))\n",
        "      correct += 1\n",
        "    else:\n",
        "      print(\"%s was categorized as a %s but is actually a %s\" % (k,res,v))\n",
        "  \n",
        "  \n",
        "  print(\"Categorized {:.2%} of UMD players correctly.\".format(correct/total))\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qrOAQY_U9nPt",
        "colab_type": "text"
      },
      "source": [
        "### Try it Out\n",
        "To test out our model, enter an NBA player's name to see if the model guesses the correct position.\n",
        "\n",
        "\n",
        "After entering a player, select **Runtime > Run all** and the results will be displayed below. You **must** be signed in to a Google account to run all, or else Colab will complain about multiple users being able to edit the code.\n",
        "    \n",
        "After you've 'Run all' once, you don't have to do it again. To try out different players type in their name and then click the **Play Button** to the upper left of the code below.\n",
        "\n",
        "**NOTE: Spelling and Punctuation matter when entering player names**\n",
        "\n",
        "Here are some example players to try out.\n",
        "\n",
        "* James Harden\n",
        "* LeBron James\n",
        "* De'Aaron Fox\n",
        "* Al-Farouq Aminu\n",
        "* P.J. Tucker\n",
        "* CJ McCollum\n",
        "\n",
        "If you're having trouble with a specific player, reference our raw data with the link listed above, under *Data* "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q9UXvu872V3v",
        "colab_type": "code",
        "cellView": "both",
        "outputId": "931a2f14-1e6c-4f3f-ae2d-a8598ae927ee",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 119
        }
      },
      "source": [
        "selected_player = \"Giannis Antetokounmpo\" #@param {type:\"string\"}\n",
        "\n",
        "_ = run_model(selected_player, test_data)\n",
        "\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "    Unnamed: 0                 Player Pos    FG%  ...  STL  BLK   PTS  Height\n",
            "77          90  Giannis Antetokounmpo  PF  0.578  ...  1.3  1.5  27.7      83\n",
            "\n",
            "[1 rows x 15 columns]\n",
            "Stage 1 correctly categorized Giannis Antetokounmpo as PGPFC\n",
            "Stage 2 correctly categorized Giannis Antetokounmpo as a PF\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WX5zgqxhHxCa",
        "colab_type": "text"
      },
      "source": [
        "## Data \n",
        "For this project we used accumulated NBA player statistics from the year 2014 up until the previous season (2018-2019 season). We gathered the data from [basketball-reference.com](https://www.basketball-reference.com/). Our preliminary data included 11 stats, (FG%, 3PA,\t3P%,\t2P%,\tFT%,\tORB,\tTRB,\tAST,\tSTL, BLK,\tPTS), while our final data added **Height** to the original 11 statistics. Through exploratory data analysis we reduced to fewer statistics. This process is described in our approach section. The height data for each player was not included in the tables provided by basketball-reference, so we pulled each player's height from the basketball-reference information page for each player. Our raw data can be found [here](https://docs.google.com/spreadsheets/d/1-6pwAv2Xz1BJTd7Pb0yBK6wmOlAbqYu_X7MPdkgKyEs/edit?usp=sharing).\n",
        "\n",
        "We used the data from 2014-2018 to train our model for each position and then tested our model on the most player's recent season (2018-2019). To make sure the data we used was statistically significant, we only used players that played 30 games or more, while averaging at least 10 minutes played per game.\n",
        "\n",
        "\n",
        "## Approach\n",
        "\n",
        "In order to cluster our players into their positions, we used Bayes law to estimate the quantity P(Position | Player). Here we define a position as one of the 5 positions in basketball (PG, SG, SF, PF, C) and a player as a series of player statistics representing a player in the 2018-2019 season. For each player, we calculate this quantity 5 times, once for each position. Then with 5 values for each player, we take the maximum value and select the associated position as our player's position.\n",
        "\n",
        "Our application of Bayes law resulted in the calculation P(Player | Position) * P(Position). We chose to ignore the summation in the denominator as we are comparing these values against each other and selecting the maximum. Since we are comparing the values, we do not need them to sum to 1, so we do not need to calculate this denominator. The P(Player) value, or the prior, was simply calculated as (# players in position / # players). Our likelihood function (P(Player | Position)) was assumed to be a Gaussian distribution. This assumption is based on the fact that each statistic was found to be close to normally distributed across positions. According to Bayes Law, the product of our prior and our likelihood function gives us a value proportional to P(Position | Player). \n",
        "\n",
        "For our likelihood function, we used an N dimensional Gaussian distribution where the mean and covariance were found as the mean and covariance of our dataset, accumulated over all years that we used. The dimension of this function (N) changes based on the number of statistics used to develop the model. This process is discussed down below in regard to our two-stage process.\n",
        "\n",
        "### Initial One-Stage Approach\n",
        "\n",
        "Initially, we calculated the likelihood function of each player for each position and multiplied it by the probability of that position. This gave us a value for each position for each player proportional to the probability that each player belongs to each position. Each player is assigned to the position with the maximum value calculated above.\n",
        "\n",
        "After running our test data (without height) through this model, we found an accuracy of **41.01%**. Seeking to improve this accuracy, we thought of a different way to cluster our data.\n",
        "\n",
        "*Note:*\n",
        "We only ran this method without including height in our data. After realizing the two-stage method described below provided more accurate results, we did not specifically perform this approach again after adding height to our data.\n",
        "\n",
        "### Final Two-Stage Approach\n",
        "\n",
        "![Flowchart](https://github.com/ssaltwick/ENEE324-Project/blob/master/324H%20Project%20Flowchart.png?raw=true)\n",
        "\n",
        "Our final approach includes two stages. The first stage clusters players into \"bins\" that best fit their stats, while the second stage clusters each player into the position inside their respective bin that best fits their stats. \n",
        "\n",
        "The bins were determined through iterative testing, calculating the accuracy of all 51 partitions of the list of positions, [PG, SG, SF, PF, C], and finding the one that yielded the highest accuracy.\n",
        "\n",
        "*Example Partitions include:* \n",
        "\n",
        "    [PG], [SG], [SF], [PF], [C]\n",
        "    [PG, SG], [SF], [PF], [C]\n",
        "    [PG, SG, SF], [PF], [C]\n",
        "    [PG, SG, SF, PF], [C]\n",
        "    [PG, SG, SF, PF, C]\n",
        "    [PG, SG], [SF, PF, C]\n",
        "    [PG, SG, SF], [PF, C]\n",
        "\n",
        "To find the partition that produced the highest accuracy, we found the combination of statistics that yielded the highest percent accuracy for all 51 partitions. We did this through a two-stage process, as previously mentioned.\n",
        "\n",
        "**Stage 1**\n",
        "\n",
        "In Stage 1, we receive *m* values (*i1, i2, ..., im*) for each player, where *m* is the number of bins in the current partition. These values are proportional to the probability that each player belongs to each bin. Each player is assigned to the bin, *x*, that had the maximum value *ix*.\n",
        "\n",
        "For each partition, we wanted to find the stats that clustered players into each bin with the highest accuracy. To do this, we iterated through every possible combination of stats (FG%, 3PA,\t3P%,\t2P%,\tFT%,\tORB,\tTRB,\tAST,\tSTL, BLK,\tPTS, and Height) for sizes 1-12 and returned the combination with the highest percentage.\n",
        "\n",
        "\n",
        "**Stage 2**\n",
        "\n",
        "Stage 2 works similarly to Stage 1. However, instead of clustering players into bins, we found the stats that cluster players in each bin into the positions with the highest accuracy using the same method as Stage 1.\n",
        "\n",
        "Stage 2 generates *n* values (*j1, j2, ..., jn*), where *n* is the size of the current bin of the current partition. These values are proportional to the probability that each player belongs to each position inside the player's respective bin. Each player is assigned to the position inside their respective bin, *y*, that had the maximum value *jy*.\n",
        "\n",
        "**Total Accuracy**\n",
        "\n",
        "Our accuracy calculation is done by tallying the number of players that we clustered correctly and dividing it by the total number of players clustered.\n",
        "\n",
        "**Notes**\n",
        "\n",
        "For the One-Stage Model and Stage 1 and Stage 2 of the Two-Stage Model we found that using too many stats led to less accurate results. The reason for this is stats such as points, total rebounds and field goal percentage, had similar means and variances across all five positions, thus decreasing the accuracy.\n",
        "\n",
        "We ran this method both with and without height included in our data set as it provided more accurate results.\n",
        "\n",
        "The one-stage approach was one of the 51 partitions of the two-stage approach.\n",
        "\n",
        "## Results\n",
        "\n",
        "### One-Stage Approach Without Height\n",
        "\n",
        "Utilizing the One-Stage approach described above without height included in our data provided the following results:\n",
        "\n",
        "**Ideal Statistics**\n",
        "\n",
        "The statistics that yielded the highest accuracy (**41.01%**) in clustering players into all 5 positions were:\n",
        "\n",
        "*  Three point percentage\n",
        "*  Two point percentage\n",
        "*  Assists\n",
        "*  Free throw percentage\n",
        "*  Steals\n",
        "*  Blocks\n",
        "*  Offensive Rebounds\n",
        "\n",
        "\n",
        "### Two-Stage Approach Without Height\n",
        "\n",
        "Utilizing the Two-Stage approach described above without height included in our data provided the following results:\n",
        "\n",
        "**Ideal Partition**\n",
        "\n",
        "Our ideal partition resulted in the following three bins:\n",
        "\n",
        "    [PG, SF], [SG, PF], [C]\n",
        "    \n",
        "**Stage 1**\n",
        "\n",
        "The statistics that yielded the highest accuracy (**59.27%**) in clustering players into these three bins were:\n",
        "\n",
        "*  Three point attempts\n",
        "*  Two point percentage\n",
        "*  Assists\n",
        "*  Free throw percentage\n",
        "*  Steals\n",
        "*  Height\n",
        "*  Offensive rebounds\n",
        "\n",
        "**Stage 2**\n",
        "\n",
        "The statistics that yielded the highest accuracy in clustering players in the [PG, SF] bin into the *PG* and *SF* positions were:\n",
        "\n",
        "*  Three point percentage\n",
        "*  Offensive rebounds\n",
        "*  Total Rebounds\n",
        "\n",
        "The statistics that yielded the highest accuracy in clustering players in the [SG, PF] bin into the *SG*, and *PF* positions were: \n",
        "\n",
        "*  Two point percentage\n",
        "*  Total rebounds\n",
        "\n",
        "Since the [C] bin only holds one position (Center), all players clustered into that bin in Stage 1 are already clustered into a final position. Thus, Stage 2 has no effect on this bin.\n",
        "\n",
        "**Total Accuracy**\n",
        "\n",
        "Using the partition and stats for each stage mentioned above we achieved a peak accuracy of **48.31%** for this model.\n",
        "\n",
        "\n",
        "### Two-Stage Approach With Height\n",
        "\n",
        "Utilizing the Two-Stage approach described above provided the following results:\n",
        "\n",
        "**Ideal Partition**\n",
        "\n",
        "Our ideal partition resulted in the following two bins:\n",
        "\n",
        "    [SG, SF], [PG, PF, C]\n",
        "    \n",
        "**Stage 1**\n",
        "\n",
        "The statistics that yielded the highest accuracy (**81.74%**) in clustering players into these two bins were:\n",
        "\n",
        "*  Three point percentage\n",
        "*  Steals\n",
        "*  Offensive Rebounds\n",
        "*  Height\n",
        "\n",
        "**Stage 2**\n",
        "\n",
        "The statistics that yielded the highest accuracy in clustering players in the [SG, SF] bin into the *SG* and *SF* positions were:\n",
        "\n",
        "*  Three point attempts\n",
        "*  Three point percentage\n",
        "*  Two point percentage\n",
        "*  Assists\n",
        "*  Steals\n",
        "*  Blocks\n",
        "*  Offensive rebounds\n",
        "*  Height\n",
        "\n",
        "The statistics that yielded the highest accuracy in clustering players in the [PG, PF, C] bin into the *PG*, *PF*, and *C* positions were: \n",
        "\n",
        "*  Three point attempts\n",
        "*  Three point percentage\n",
        "*  Two point percentage\n",
        "*  Offensive rebounds\n",
        "*  Height\n",
        "\n",
        "**Total Accuracy**\n",
        "\n",
        "Using the partition and stats for each stage mentioned above we achieved a peak accuracy of **70.79%**.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yeOXNUewN8f6",
        "colab_type": "text"
      },
      "source": [
        "### NCAAM Extension\n",
        "\n",
        "As an extension of our results, we decided to test on a league other than the NBA. For this experiment we gathered data for the UMD men's basketball team and ran our model with their data. While this is only a sample of 10 players, we found an accuracy of **70%** which aligns well with our NBA accuracy.\n",
        "\n",
        "If we were to generalize this test to more NCAA teams, which wasn't done due to the lack of available data in a usable format, we could conclude more about this relationship. If we were to test on a larger sample of NCAAM basketball players and found that our model's accuracy remained at 70%, then we would conclude that the positional roles are similar across the two leagues. \n",
        "\n",
        "To see this test, hit **Runtime > Run all** and the output will appear below.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2JS_AOiOIOui",
        "colab_type": "code",
        "outputId": "b9ea1143-665e-4c80-d362-41149ef3214e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 204
        }
      },
      "source": [
        "umd_test()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Correctly categorized Anthony Cowan as a PG\n",
            "Correctly categorized Bruno Fernando as a C\n",
            "Correctly categorized Jalen Smith as a PF\n",
            "Eric Ayala was categorized as a SG but is actually a PG\n",
            "Darryl Morsell was categorized as a SG but is actually a SF\n",
            "Correctly categorized Aaron Wiggins as a SG\n",
            "Correctly categorized Serrel Smith Jr as a SG\n",
            "Correctly categorized Ricky Lindo as a SF\n",
            "Correctly categorized Joshua Tomaic as a SF\n",
            "Ivan Bender was categorized as a SF but is actually a PF\n",
            "Categorized 70.00% of UMD players correctly.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yLIXbUp5N7QO",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "### Analysis\n",
        "\n",
        "**Without Height**\n",
        "\n",
        "Our original method, a Single-Stage approach that clusters players directly into the 5 positions resulted in only **41.01%** accuracy. Using the Two-Stage approach without height resulted in **48.31%** accuracy. Our Two-Stage approach increased the accuracy of the model without height by over 7%.\n",
        "\n",
        "**Adding Height**\n",
        "\n",
        "Originally, we were not planning to use height as a statistic in our model. However, after some preliminary analysis, we realized the exclusion of height was severely limiting the accuracy of our model. \n",
        "\n",
        "Without height, the maximum accuracy we achieved was **48.31%** using the Two-Stage approach. Adding height to our data yielded an accuracy of **70.79%**, over a 20% increase.\n",
        "\n",
        "**Discussion**\n",
        "\n",
        "Considering that there are 5 different options for a player's position, if we randomly choose a position for each player the expected percent correct would be 20%. All three of our approaches for our model perform much better than this, with the Two-Stage approach with height successfully clustering over 3.5 times more players than a stochastic method would. Because of this comparison, we believe that our clustering process successfully works to better determine a player's position from their statistics.\n",
        "\n",
        "\n",
        "### Further Work\n",
        "\n",
        "Many further investigations into this topic are possible. The weakest point of the model is the assumption that the statistics for each distribution would be fairly normal. While this did appear to be true, plotting 3 statistics together with a Gaussian ellipsoid reveals that many players still fall outside of the models predicted range. Developing a different likelihood function through other statistic methods could definitely improve the accuracy of our model.\n",
        "\n",
        "Another extension of this would be extending our training data to include more NBA seasons. We only included 4 seasons of training data; however, including more (10+ seasons) could improve our accuracy. One reason this may not be the case is that the game of basketball has drastically changed over the years. As the game changes, the roles of each position changes with it, which would skew our results and over many years could result in an underfitted model. \n",
        "\n",
        "Alternatively, we could test our data on previous seasons to examine how well our position models hold up for years before they were trained on. "
      ]
    }
  ]
}