ENEE324_Project.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "ENEE324 Project",
      "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/ENEE324_Project.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G3SiNnHMZTLB",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "This program uses data from the 2014-2018 NBA seasons to classify players by \n",
        "position.\n",
        "\n",
        "\n",
        "Previous year's game statistics are used to generate a likelihood function\n",
        "for each position. Then a certain player can be tested against each of these \n",
        "functions to guess their position.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DiZoa_hUOrT0",
        "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",
        "from sklearn.mixture import GaussianMixture\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "51h41PKoHmzw",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "# Defines an enumeration for player positions\n",
        "\n",
        "class Position(Enum):\n",
        "  PG = 0\n",
        "  SG = 1\n",
        "  SF = 2\n",
        "  PF = 3\n",
        "  C = 4\n",
        "  "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "abRojhXGTPi8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VUXyVnzNANst",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# fig = plt.figure()\n",
        "# ax = plt.axes(projection='3d')\n",
        "\n",
        "# ax.scatter3D(data[Position.PG]['3PA'],data[Position.PG]['2P%'],data[Position.PG]['BLK'])\n",
        "# # your ellispsoid and center in matrix form\n",
        "# A = covs[Position.PG]\n",
        "# center = avgs[Position.PG]\n",
        "\n",
        "# # find the rotation matrix and radii of the axes\n",
        "# U, s, rotation = np.linalg.svd(A)\n",
        "# radii = 1.0/np.sqrt(s)\n",
        "\n",
        "# # now carry on with EOL's answer\n",
        "# u = np.linspace(0.0, 2.0 * np.pi, 100)\n",
        "# v = np.linspace(0.0, np.pi, 100)\n",
        "# x = radii[0] * np.outer(np.cos(u), np.sin(v))\n",
        "# y = radii[1] * np.outer(np.sin(u), np.sin(v))\n",
        "# z = radii[2] * np.outer(np.ones_like(u), np.cos(v))\n",
        "# for i in range(len(x)):\n",
        "#     for j in range(len(x)):\n",
        "#         [x[i,j],y[i,j],z[i,j]] = np.dot([x[i,j],y[i,j],z[i,j]], rotation) + center\n",
        "\n",
        "\n",
        "\n",
        "# ax.plot_wireframe(x, y, z,  rstride=4, cstride=4, color='b', alpha=0.2)\n",
        "# plt.show()\n",
        "# plt.close(fig)\n",
        "# del fig\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Dk8qTLauO201",
        "colab_type": "code",
        "cellView": "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",
        "  # print(sig.shape, mu.shape, player.shape)\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": "AR8WjRv8MES6",
        "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": "d0G_q--v1du9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def compare_position(actual, guessed):\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",
        "# Guard, Forward, Center\n",
        "\n",
        "#   if guessed == Position.PG or guessed == Position.SG:\n",
        "#     if actual == \"PG\" or actual == \"SG\":\n",
        "#       return 1\n",
        "#   if guessed == Position.SF or guessed == Position.PF:\n",
        "#     if actual == \"SF\" or actual == \"PF\":\n",
        "#       return 1\n",
        "#   if guessed == Position.C:\n",
        "#     if actual == \"C\":\n",
        "#       return 1\n",
        "#   return 0\n",
        "\n",
        "# (PG, SG, SF) or (PF, C)\n",
        "#   if guessed == Position.PG or guessed == Position.SG or guessed == Position.SF:\n",
        "#     if actual == \"PG\" or actual == \"SG\" or actual == \"SF\":\n",
        "#       return 1\n",
        "#   if guessed == Position.C or guessed == Position.PF:\n",
        "#     if actual == \"SF\" or actual == \"PF\":\n",
        "#       return 1\n",
        "#   return 0\n",
        "\n",
        "# (PG, SG), SF, (PF, C)\n",
        "#   if guessed == Position.PG or guessed == Position.SG:\n",
        "#     if actual == \"PG\" or actual == \"SG\":\n",
        "#       return 1\n",
        "#   if guessed == Position.C or guessed == Position.PF:\n",
        "#     if actual == \"C\" or actual == \"PF\":\n",
        "#       return 1\n",
        "#   if guessed == Position.SF:\n",
        "#     if actual == \"SF\":\n",
        "#       return 1\n",
        "#   return 0\n",
        "\n",
        "# Just SF\n",
        "# if guess == Position.SF:\n",
        "#   if actual == \"SF\":\n",
        "#     return 1\n",
        "# return 0\n",
        "\n",
        "\n",
        "# PG, SG, SF, PF, C\n",
        "  if pos_names[guessed] == actual:\n",
        "    # print(\"Position %s Guessed Correctly\" % actual)\n",
        "    return 1\n",
        "  else:\n",
        "    # print(\"Position Guessed Incorrectly- Actual: %s     Guessed: %s\" %(actual, pos_names[guessed]))\n",
        "    return 0\n",
        "      \n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3d2H3RVnIzU3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Load Data\n",
        "pg_url = 'https://raw.githubusercontent.com/ssaltwick/ENEE324-Project/master/data/Data%20-%20PG-clean.csv'\n",
        "sg_url = 'https://raw.githubusercontent.com/ssaltwick/ENEE324-Project/master/data/Data%20-%20SG-clean.csv'\n",
        "sf_url = 'https://raw.githubusercontent.com/ssaltwick/ENEE324-Project/master/data/Data%20-%20SF-clean.csv'\n",
        "pf_url = 'https://raw.githubusercontent.com/ssaltwick/ENEE324-Project/master/data/Data%20-%20PF-clean.csv'\n",
        "c_url = 'https://raw.githubusercontent.com/ssaltwick/ENEE324-Project/master/data/Data%20-%20C-Clean.csv'\n",
        "test_url = 'https://raw.githubusercontent.com/ssaltwick/ENEE324-Project/master/data/Data%20-%20Test-Clean.csv'\n",
        "\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",
        "test_data = pd.read_csv(test_url).dropna()\n",
        "#2p%, 3pa, ft%\n",
        "\n",
        "\n",
        "# Selected Stats (Best so far)\n",
        "#stats = ['3PA', '3P%', '2P%',  'BLK']"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VncRTV95RtMJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def find_best_stats(num_stats):\n",
        "  # All stats\n",
        "  all_stats = ['3PA', '3P%','2P%', 'PTS', 'AST', 'FT%', 'STL', 'BLK', 'ORB','TRB']\n",
        "  combos = list(combinations(all_stats,num_stats))\n",
        "\n",
        "  results = {}\n",
        "  for stats in combos:\n",
        "    stats = list(stats)\n",
        "    data = {\n",
        "        Position.PG : pd.read_csv(pg_url).dropna()[stats],\n",
        "        Position.SG : pd.read_csv(sg_url).dropna()[stats],\n",
        "        Position.SF : pd.read_csv(sf_url).dropna()[stats],\n",
        "        Position.PF : pd.read_csv(pf_url).dropna()[stats],\n",
        "        Position.C : pd.read_csv(c_url).dropna()[stats]\n",
        "    }\n",
        "\n",
        "    total_players = data[Position.PG].shape[0] + data[Position.SG].shape[0] + \\\n",
        "      data[Position.SF].shape[0] + data[Position.PF].shape[0] + data[Position.C].shape[0]\n",
        "\n",
        "\n",
        "    # Defines an array of priors (each position's percentage of players)\n",
        "    # TODO: Update with actual priors),\n",
        "    prior = {\n",
        "        Position.PG : data[Position.PG].shape[0] / total_players,\n",
        "        Position.SG : data[Position.SG].shape[0] / total_players,\n",
        "        Position.SF : data[Position.SF].shape[0] / total_players,\n",
        "        Position.PF : data[Position.PF].shape[0] / total_players,\n",
        "        Position.C : data[Position.C].shape[0] / total_players\n",
        "    }\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "    # TODO: Generate actual MEAN and COV for each position\n",
        "\n",
        "    avgs = {\n",
        "        Position.PG : data[Position.PG].mean(0).to_numpy(),\n",
        "        Position.SG : data[Position.SG].mean(0).to_numpy(),\n",
        "        Position.SF : data[Position.SF].mean(0).to_numpy(),\n",
        "        Position.PF : data[Position.PF].mean(0).to_numpy(),\n",
        "        Position.C : data[Position.C].mean(0).to_numpy()\n",
        "    }\n",
        "\n",
        "    covs = {\n",
        "        Position.PG : data[Position.PG].cov().to_numpy(),\n",
        "        Position.SG : data[Position.SG].cov().to_numpy(),\n",
        "        Position.SF : data[Position.SF].cov().to_numpy(),\n",
        "        Position.PF : data[Position.PF].cov().to_numpy(),\n",
        "        Position.C : data[Position.C].cov().to_numpy()\n",
        "    }\n",
        "\n",
        "    # Display stat with minimum variance \n",
        "    # print(np.argmin(np.diag(covs[Position.PG])))\n",
        "    # print(np.argmin(np.diag(covs[Position.SG])))\n",
        "    # print(np.argmin(np.diag(covs[Position.SF])))\n",
        "    # print(np.argmin(np.diag(covs[Position.PF])))\n",
        "    # print(np.argmin(np.diag(covs[Position.C])))\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "    test_frame = test_data[['Pos'] + stats]\n",
        "\n",
        "    sample_size = test_frame.shape[0]\n",
        "    num_correct = 0.0\n",
        "\n",
        "\n",
        "    for i in range(0,sample_size):\n",
        "\n",
        "      test_player = test_frame.to_numpy()[i,0:]\n",
        "\n",
        "      guess = guess_position(test_player[1:], avgs, covs, prior)\n",
        "\n",
        "      num_correct += compare_position(test_player[0], guess)\n",
        "\n",
        "    percent_correct = (num_correct / sample_size)\n",
        "\n",
        "\n",
        "    results[''.join(stats)] = percent_correct\n",
        "\n",
        "    #print(''.join(stats))\n",
        "    #print('Guessed {:.2%}  of players correct'.format(percent_correct))\n",
        "\n",
        "\n",
        "\n",
        "  v = list(results.values())\n",
        "  k = list(results.keys())\n",
        "\n",
        "  best = k[v.index(max(v))]  \n",
        "  print(\"Best result using %s with %s accuracy\" % (best, max(v)))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oi1elmR8RaMc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def compare_positions(num_stats, compare):\n",
        "  all_stats = ['3PA', '3P%','2P%', 'PTS', 'AST', 'FT%', 'STL', 'BLK', 'ORB','TRB']\n",
        "  combos = list(combinations(all_stats,num_stats))\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",
        "  results = {}\n",
        "  for stats in combos:\n",
        "    stats = list(stats)\n",
        "    data = {}\n",
        "    \n",
        "    for p in compare:\n",
        "      data[p] = pd.read_csv(urls[p]).dropna()[stats]  \n",
        "      \n",
        "      \n",
        "\n",
        "    total_players = 0\n",
        "    for p in compare:\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",
        "\n",
        "    # TODO: Generate actual MEAN and COV for each position\n",
        "\n",
        "\n",
        "    for p in compare:\n",
        "      total_players += data[p].shape[0]\n",
        "    \n",
        "    for p in compare:\n",
        "      prior[p] = data[p].shape[0] / total_players\n",
        "      \n",
        "    for p in compare:\n",
        "      avgs[p] = data[p].mean(0).to_numpy()\n",
        "      covs[p] = data[p].cov().to_numpy()\n",
        "      \n",
        "    \n",
        "    # Display stat with minimum variance \n",
        "    # print(np.argmin(np.diag(covs[Position.PG])))\n",
        "    # print(np.argmin(np.diag(covs[Position.SG])))\n",
        "    # print(np.argmin(np.diag(covs[Position.SF])))\n",
        "    # print(np.argmin(np.diag(covs[Position.PF])))\n",
        "    # print(np.argmin(np.diag(covs[Position.C])))\n",
        "\n",
        "\n",
        "    test_frame = test_data[['Pos'] + stats]\n",
        "\n",
        "    fd = False\n",
        "    for p in compare:\n",
        "      fd |= test_frame['Pos'] == pos_names[p]\n",
        "  \n",
        "    test_frame = test_frame.loc[fd]\n",
        "    sample_size = test_frame.shape[0]\n",
        "    num_correct = 0.0\n",
        "\n",
        "\n",
        "    for i in range(0,sample_size):\n",
        "\n",
        "      test_player = test_frame.to_numpy()[i,0:]\n",
        "\n",
        "      guess = guess_position(test_player[1:], avgs, covs, prior, compare)\n",
        "\n",
        "      num_correct += compare_position(test_player[0], guess)\n",
        "\n",
        "    percent_correct = (num_correct / sample_size)\n",
        "\n",
        "\n",
        "    results[''.join(stats)] = percent_correct\n",
        "\n",
        "    #print(''.join(stats))\n",
        "    #print('Guessed {:.2%}  of players correct'.format(percent_correct))\n",
        "\n",
        "\n",
        "\n",
        "  v = list(results.values())\n",
        "  k = list(results.keys())\n",
        "\n",
        "  best = k[v.index(max(v))]  \n",
        "  print(\"Best result comparing %s using %s with %s accuracy\" % (''.join(str(compare)), best, max(v)))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R4KIZhT6U5yZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# positions = [Position.PG, Position.SG, Position.SF, Position.PF, Position.C]\n",
        "\n",
        "# for i in range (1,6):\n",
        "#   combos = list(combinations(positions,i))\n",
        "  \n",
        "#   for c in combos[5:]:\n",
        "#     compare_positions(4, c)\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ou_kKGnfcTBU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# for i in range(1,11):\n",
        "#   compare_positions(i, [Position.PG, Position.SG, Position.SF])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "60U3sH410Uvm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def calculate_correct(bins, total):\n",
        "  num_correct = 0\n",
        "  for k in bins.keys():\n",
        "    for p in bins[k]:\n",
        "      if p[1] in k:\n",
        "        num_correct += 1\n",
        "        \n",
        "  return (num_correct / total)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6SZ16pk9iXa-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def stage1(round1_stats, labels):\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",
        "  b1 = [Position.PG, Position.SG, Position.SF]\n",
        "  b2 = [Position.PF, Position.C]\n",
        "  \n",
        "  \n",
        "\n",
        "  \n",
        "  positions = [Position.PG, Position.SG, Position.SF, Position.PF, Position.C]\n",
        "  \n",
        "\n",
        "  bins = {}\n",
        "  \n",
        "  for l in labels:\n",
        "    tmp = [pos_names[x] for x in l]\n",
        "    bins[''.join(tmp)] = []\n",
        "    \n",
        "  \n",
        "  data = {}\n",
        "  for p in positions:\n",
        "    data[p] = pd.read_csv(urls[p]).dropna()[round1_stats]  \n",
        "\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",
        "\n",
        "  test_frame = test_data[['Player'] + ['Pos'] + round1_stats]\n",
        "\n",
        "  sample_size = test_frame.shape[0]\n",
        "\n",
        "\n",
        "\n",
        "  for i in range(0,sample_size):\n",
        "\n",
        "    test_player = test_frame.to_numpy()[i,0:]\n",
        "    \n",
        "    guess = guess_position(test_player[2:], avgs, covs, prior, positions)\n",
        "    \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(test_player)\n",
        "       \n",
        "\n",
        "  percent_correct = calculate_correct(bins, sample_size)\n",
        "      \n",
        "  print(\"Stage 1 clustered {:.2%} correctly\".format(percent_correct))\n",
        "  \n",
        "  return percent_correct, bins\n",
        "  \n",
        "  "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pUQXp2Hc_nLR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def stage2(labels, stats, names):\n",
        "  \n",
        "  positions = [Position.PG, Position.SG, Position.SF, Position.PF, Position.C]\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]).dropna()[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",
        "    \n",
        "    \n",
        "  items = pd.read_csv(test_url).dropna()[['Player', 'Pos'] + stats]\n",
        "  items = items[items['Player'].isin(names)]\n",
        "  \n",
        "  items = items.values\n",
        "\n",
        "  sample_size = items.shape[0]\n",
        "  \n",
        "  \n",
        "\n",
        "  for i in range(0,sample_size):\n",
        "\n",
        "    test_player = items[i]\n",
        "    \n",
        "    guess = guess_position(test_player[2:], avgs, covs, prior, labels)\n",
        "\n",
        "    bins[guess].append(test_player)\n",
        "\n",
        "  num_correct = 0\n",
        "  for k in bins.keys():\n",
        "    for v in bins[k]:\n",
        "      if v[1] == pos_names[k]:\n",
        "        num_correct += 1\n",
        "  \n",
        "  \n",
        "  percent_correct = num_correct / sample_size;\n",
        "      \n",
        "  # print(\"Stage 2 clustered {:.2%} correctly\".format(percent_correct))\n",
        "  \n",
        "  return percent_correct, bins"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wSuBu4n2j4MK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Find best stage 1 stats\n",
        "\n",
        "def find_best_s1_stats():\n",
        "  used_pos = [[Position.PG, Position.SG],[Position.SF], [Position.PF, Position.C]]\n",
        "  round1_stats = ['3PA', '3P%', '2P%', 'BLK']\n",
        "  all_stats = ['3PA', '3P%','2P%', 'PTS', 'AST', 'FT%', 'STL', 'BLK', 'ORB','TRB']\n",
        "\n",
        "\n",
        "\n",
        "  for i in range (1,11):\n",
        "    combos = list(combinations(all_stats,i))\n",
        "\n",
        "    m = (0,0)\n",
        "    for c in combos:\n",
        "      pc, _ = stage1(list(c), used_pos)\n",
        "      if pc > m[0]:\n",
        "        m = (pc, c)\n",
        "\n",
        "    print(m)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z36O1LM3attm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "find_best_s1_stats()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V5Pbe2GqPFwg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def accuracy(splits):\n",
        "  num_correct = 0\n",
        "  total = 0\n",
        "\n",
        "  for split in splits.values():\n",
        "    for k in split.keys():\n",
        "      for v in split[k]:\n",
        "        if v[1] == pos_names[k]:\n",
        "          num_correct += 1\n",
        "        total += 1\n",
        "      \n",
        "  return num_correct/total"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1F52y2wXjIGB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# BEST SO FAR\n",
        "# PGSGSF / PFC\n",
        "# ['3P%', 'AST', 'FT%', 'STL', 'BLK', 'ORB'], ['3PA', 'BLK']\n",
        "\n",
        "\n",
        "used_pos = [[Position.PG, Position.SG],[Position.SF], [Position.PF, Position.C]]\n",
        "best_stats = [['3P%', 'AST', 'FT%', 'STL', 'BLK', 'ORB'], ['3P%', 'AST', 'FT%', 'STL', 'BLK', 'ORB'], ['3PA', 'BLK']]\n",
        "stage1_stats = ['3PA', '2P%', 'TRB']\n",
        "\n",
        "\n",
        "pc, first_split, a, p, c = stage1(stage1_stats, used_pos)\n",
        "\n",
        "all_stats = ['3PA', '3P%','2P%', 'PTS', 'AST', 'FT%', 'STL', 'BLK', 'ORB','TRB']\n",
        "stats = []\n",
        "\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",
        "s = []\n",
        "for k in first_split.keys():\n",
        "  s.append(first_split[k])\n",
        "\n",
        "names = []\n",
        "\n",
        "for i in range(len(s)):\n",
        "  names.append([s[0] for s in s[i]])\n",
        "  \n",
        "\n",
        "\n",
        "\n",
        "for i in range(len(best_stats)):\n",
        "  stats.append(best_stats[i])\n",
        "    \n",
        "    \n",
        "    \n",
        "    \n",
        "splits = {}    \n",
        "# i = 0\n",
        "# for k in names.keys():\n",
        "#   _, splits[k] = stage2(used_pos[i], stats[i], names[i])\n",
        "#   i += 1\n",
        "  \n",
        "# acc = accuracy(splits)\n",
        "\n",
        "\n",
        "# print(\"Predicted {:2%} of player's positions correctly\".format(acc))\n",
        "\n",
        "# Find best # of stats\n",
        "for i in range(1,9):\n",
        "  combos = list(combinations(all_stats,i))\n",
        "  m = (0,0)\n",
        "  for c in combos:\n",
        "    pc, sec_split2 = stage2(used_pos[1], list(c), names[1])\n",
        "    if pc > m[0]:\n",
        "      m = (pc, c)\n",
        "\n",
        "  print(m)\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}