From ece48f6f6e923693283e53ce26802c4f39b9dd19 Mon Sep 17 00:00:00 2001 From: Mubashirul Islam Date: Mon, 27 Oct 2025 04:46:14 +0000 Subject: [PATCH] Add v1 PTS prediction model --- Week-08-Regression/Exercise-Regression.ipynb | 20 +- Week-08-Regression/Lecture-Regression.ipynb | 18 +- Week-08-Regression/homeworks/CTPLIB.py | 86 ++ .../homeworks/Exercise-Regression.ipynb | 1024 +++++++++++++++++ 4 files changed, 1141 insertions(+), 7 deletions(-) create mode 100644 Week-08-Regression/homeworks/CTPLIB.py create mode 100644 Week-08-Regression/homeworks/Exercise-Regression.ipynb diff --git a/Week-08-Regression/Exercise-Regression.ipynb b/Week-08-Regression/Exercise-Regression.ipynb index 4f13730c..4c088a20 100644 --- a/Week-08-Regression/Exercise-Regression.ipynb +++ b/Week-08-Regression/Exercise-Regression.ipynb @@ -14,9 +14,21 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'CTPLIB'", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mModuleNotFoundError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[10]\u001b[39m\u001b[32m, line 35\u001b[39m\n\u001b[32m 30\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mstatsmodels\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mstats\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01moutliers_influence\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m variance_inflation_factor\n\u001b[32m 33\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mstatsmodels\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mapi\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m qqplot\n\u001b[32m---> \u001b[39m\u001b[32m35\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mCTPLIB\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mctp\u001b[39;00m\n", + "\u001b[31mModuleNotFoundError\u001b[39m: No module named 'CTPLIB'" + ] + } + ], "source": [ "# PANDAS IS FOR DATA WRANGLING\n", "import pandas as pd\n", @@ -454,7 +466,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -468,7 +480,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.4" + "version": "3.12.1" } }, "nbformat": 4, diff --git a/Week-08-Regression/Lecture-Regression.ipynb b/Week-08-Regression/Lecture-Regression.ipynb index 8accd6b5..17636929 100644 --- a/Week-08-Regression/Lecture-Regression.ipynb +++ b/Week-08-Regression/Lecture-Regression.ipynb @@ -2178,7 +2178,19 @@ "execution_count": null, "id": "0ec70abf", "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'CTPLIB'", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mModuleNotFoundError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[1]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mCTPLIB\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mctp\u001b[39;00m\n\u001b[32m 3\u001b[39m ivs = [\u001b[33m'\u001b[39m\u001b[33mOBP\u001b[39m\u001b[33m'\u001b[39m, \u001b[33m'\u001b[39m\u001b[33mSLG\u001b[39m\u001b[33m'\u001b[39m]\n\u001b[32m 4\u001b[39m dv = \u001b[33m'\u001b[39m\u001b[33mRS\u001b[39m\u001b[33m'\u001b[39m\n", + "\u001b[31mModuleNotFoundError\u001b[39m: No module named 'CTPLIB'" + ] + } + ], "source": [ "import CTPLIB as ctp\n", "\n", @@ -2290,7 +2302,7 @@ ], "metadata": { "kernelspec": { - "display_name": "base", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -2304,7 +2316,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.4" + "version": "3.12.1" } }, "nbformat": 4, diff --git a/Week-08-Regression/homeworks/CTPLIB.py b/Week-08-Regression/homeworks/CTPLIB.py new file mode 100644 index 00000000..a8e139bf --- /dev/null +++ b/Week-08-Regression/homeworks/CTPLIB.py @@ -0,0 +1,86 @@ +import pandas as pd +import seaborn as sns +import matplotlib.pyplot as plt +import statsmodels.api as sm +from statsmodels.api import qqplot +from statsmodels.stats.outliers_influence import variance_inflation_factor + + + +def check_linearity(df, independent_variables, dependent_variable): + for col in independent_variables: + sns.jointplot(x=col, y=dependent_variable, data=df, kind="reg"); + + +########################################################################## +def check_normality(model, X, y): + print('#'*79) + print('Checking Normality') + # predictions + y_pred = model.predict(X) + + # the truth - the prediction + residuals = y.values - y_pred.values + + # histogram + sns.histplot(residuals) + plt.show() + + + # qq plot + qqplot(residuals, line='q'); + plt.show() + print('#'*79) + + + +########################################################################## +def plot_homo(model): + plt.scatter(model_runs_scored.fittedvalues, model_runs_scored.resid, alpha=0.5) + plt.xlabel('Fitted Values') + plt.ylabel('Residuals') + plt.axhline(y = 0, color = 'r') + plt.show() + + +########################################################################## +def plot_correlation(df, independent_variables): + plt.figure(figsize = (3,3)) + + ax = sns.heatmap( df[independent_variables].corr(numeric_only=True), + annot=True, + cmap='coolwarm', + vmin=-1, vmax=1); + plt.show() + + +########################################################################## +def get_vif(X): + vif = [variance_inflation_factor(X.values, i) for i in range(X.shape[1])] + vif_df = pd.DataFrame(columns=X.columns, data=[vif]) + print('#'*79) + print('Variance Inflaction Factors') + print(vif_df) + print('#'*79) + return vif_df + + + +########################################################################## +def build_and_validate_LR(df, independent_variables, dependent_variable): + X = df[independent_variables] + + y = df[dependent_variable] + + X = sm.add_constant(X) + model = sm.OLS(y, X).fit() + + print(model.summary()) + + check_linearity(df, independent_variables, dependent_variable) + + plot_correlation(df, independent_variables) + + vif_df = get_vif(X) + + check_normality(model, X, y) \ No newline at end of file diff --git a/Week-08-Regression/homeworks/Exercise-Regression.ipynb b/Week-08-Regression/homeworks/Exercise-Regression.ipynb new file mode 100644 index 00000000..a2788756 --- /dev/null +++ b/Week-08-Regression/homeworks/Exercise-Regression.ipynb @@ -0,0 +1,1024 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Regression Exercise \n", + "# Moneyball The NBA\n", + "---\n", + "\n", + "### This HW is not easy. TRY IT YOURSELF FIRST! \n", + "Then If you are able to complete it, [watch this lecture series on it](https://ocw.mit.edu/courses/15-071-the-analytics-edge-spring-2017/pages/linear-regression/playing-moneyball-in-the-nba-recitation/video-1-the-data/). " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# PANDAS IS FOR DATA WRANGLING\n", + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "# SEABORN IS A PLOTTING LIBRARY\n", + "import seaborn as sns\n", + "\n", + "# MATPLOT LIB IS ALSO A PLOTTING LIBRARY\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# SKLEARN IS OUR MACHINE LEARNING PACKAGE\n", + "from sklearn.linear_model import LinearRegression\n", + "\n", + "# IMPORT OUR RANDOM FOREST REGERSSOR\n", + "from sklearn.ensemble import RandomForestRegressor\n", + "\n", + "# METRICS HELP US SCORE OUR MODEL\n", + "from sklearn import metrics\n", + "\n", + "# HELP US SPLIT OUR DATA INTO TESTING A TRAINING\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "# Good ol statsmodels\n", + "import statsmodels.api as sm\n", + "\n", + "# Specific root mean squared error for stats models\n", + "from statsmodels.tools.eval_measures import rmse\n", + "\n", + "\n", + "from statsmodels.stats.outliers_influence import variance_inflation_factor\n", + "\n", + "\n", + "from statsmodels.api import qqplot\n", + "\n", + "import CTPLIB as ctp\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Remember our main steps motto _isbe_.\n", + "1. i - Inspect and explore data.\n", + "2. s - Select and engineer features.\n", + "3. b - Build and train model.\n", + "4. e - Evaluate model." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# STEP 1 (i): Inspect and explore data\n", + "1. Use `data/NBA_test.csv and data/NBA_train.csv`" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
SeasonEndTeamPlayoffsWPTSoppPTSFGFGA2P2PA3P3PAFTFTAORBDRBASTSTLBLKTOV
01980Atlanta Hawks1508573833432617027324869521375203826451369240619137825391495
11980Boston Celtics161930386643617738734556965162422190724491227245721988093081539
21980Chicago Bulls03088139035336269433292666870275201925921115246521527043921684
31980Cleveland Cavaliers03793609332381180413775785436187170222051307238121087643421370
41980Denver Nuggets03088789240346274703379721583255187125391311252420797464041533
\n", + "
" + ], + "text/plain": [ + " SeasonEnd Team Playoffs W PTS oppPTS FG FGA \\\n", + "0 1980 Atlanta Hawks 1 50 8573 8334 3261 7027 \n", + "1 1980 Boston Celtics 1 61 9303 8664 3617 7387 \n", + "2 1980 Chicago Bulls 0 30 8813 9035 3362 6943 \n", + "3 1980 Cleveland Cavaliers 0 37 9360 9332 3811 8041 \n", + "4 1980 Denver Nuggets 0 30 8878 9240 3462 7470 \n", + "\n", + " 2P 2PA 3P 3PA FT FTA ORB DRB AST STL BLK TOV \n", + "0 3248 6952 13 75 2038 2645 1369 2406 1913 782 539 1495 \n", + "1 3455 6965 162 422 1907 2449 1227 2457 2198 809 308 1539 \n", + "2 3292 6668 70 275 2019 2592 1115 2465 2152 704 392 1684 \n", + "3 3775 7854 36 187 1702 2205 1307 2381 2108 764 342 1370 \n", + "4 3379 7215 83 255 1871 2539 1311 2524 2079 746 404 1533 " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# READ IN THE DATA USING PANDAS \n", + "df = pd.read_csv('/workspaces/ds-dev-fall-2025/Week-08-Regression/data/NBA_train.csv')\n", + "\n", + "\n", + "# DISPLAY THE FIRST 5 ROWS\n", + "df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```\n", + "SeasonEnd: Year season ended\n", + "Team: Name of team\n", + "Playoffs: If they made the playoffs. 1 == made to playoffs\n", + "W: Number of regular season in that season. \n", + "PTS: Points scored in regular season. \n", + "oppPTS: Opponent Points scored in regular season. \n", + "FG: Field Goals made (total shots made == 2P and 3P combined)\n", + "FGA: Field Goals attempted (total shots attempted == 2P and 3P combined)\n", + "2P: two-pointers made\n", + "2PA: two-pointers attempted\n", + "3P: three-pointers made\n", + "3PA: three-pointers attempted\n", + "FT: Free-Throws made (not included in FG stat)\n", + "FTA: Free-Throws attempted (not included in FG stat)\n", + "ORB: Offensive Rebounds\n", + "DRB: Defensive Rebounds\n", + "AST: Assists made\n", + "STL: Steals \n", + "BLK: Blocks \n", + "TOV: Turnovers \n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Inspect our data using `df.describe()` function." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
SeasonEndPlayoffsWPTSoppPTSFGFGA2P2PA3P3PAFTFTAORBDRBASTSTLBLKTOV
count835.000000835.000000835.000000835.000000835.000000835.000000835.000000835.000000835.000000835.000000835.000000835.000000835.000000835.000000835.000000835.000000835.000000835.000000835.000000
mean1996.3197600.57485041.0000008370.2395218370.2395213200.3676656873.3185632881.3245515956.444311319.043114916.8742511650.4610782189.9532931061.5844312427.3544911912.112575668.364072419.8059881302.837126
std9.2438080.49466212.740822581.040114587.543959287.181266401.027166446.097941830.596327199.698941523.982964197.651728244.491086150.224519130.671523221.61092593.39304482.274913153.973470
min1980.0000000.00000011.0000006901.0000006909.0000002565.0000005972.0000001981.0000004153.00000010.00000075.0000001189.0000001475.000000639.0000002044.0000001423.000000455.000000204.000000931.000000
25%1989.0000000.00000031.0000007934.0000007934.0000002974.0000006563.5000002510.0000005269.000000131.500000413.0000001502.5000002008.000000953.5000002346.5000001735.000000599.000000359.0000001192.000000
50%1996.0000001.00000042.0000008312.0000008365.0000003150.0000006831.0000002718.0000005706.000000329.000000942.0000001628.0000002176.0000001055.0000002433.0000001899.000000658.000000410.0000001289.000000
75%2005.0000001.00000050.5000008784.5000008768.5000003434.5000007157.0000003296.0000006753.500000481.5000001347.5000001781.0000002352.0000001167.0000002516.5000002077.500000729.000000469.5000001395.500000
max2011.0000001.00000072.00000010371.00000010723.0000003980.0000008868.0000003954.0000007873.000000841.0000002284.0000002388.0000003051.0000001520.0000002753.0000002575.0000001053.000000716.0000001873.000000
\n", + "
" + ], + "text/plain": [ + " SeasonEnd Playoffs W PTS oppPTS \\\n", + "count 835.000000 835.000000 835.000000 835.000000 835.000000 \n", + "mean 1996.319760 0.574850 41.000000 8370.239521 8370.239521 \n", + "std 9.243808 0.494662 12.740822 581.040114 587.543959 \n", + "min 1980.000000 0.000000 11.000000 6901.000000 6909.000000 \n", + "25% 1989.000000 0.000000 31.000000 7934.000000 7934.000000 \n", + "50% 1996.000000 1.000000 42.000000 8312.000000 8365.000000 \n", + "75% 2005.000000 1.000000 50.500000 8784.500000 8768.500000 \n", + "max 2011.000000 1.000000 72.000000 10371.000000 10723.000000 \n", + "\n", + " FG FGA 2P 2PA 3P \\\n", + "count 835.000000 835.000000 835.000000 835.000000 835.000000 \n", + "mean 3200.367665 6873.318563 2881.324551 5956.444311 319.043114 \n", + "std 287.181266 401.027166 446.097941 830.596327 199.698941 \n", + "min 2565.000000 5972.000000 1981.000000 4153.000000 10.000000 \n", + "25% 2974.000000 6563.500000 2510.000000 5269.000000 131.500000 \n", + "50% 3150.000000 6831.000000 2718.000000 5706.000000 329.000000 \n", + "75% 3434.500000 7157.000000 3296.000000 6753.500000 481.500000 \n", + "max 3980.000000 8868.000000 3954.000000 7873.000000 841.000000 \n", + "\n", + " 3PA FT FTA ORB DRB \\\n", + "count 835.000000 835.000000 835.000000 835.000000 835.000000 \n", + "mean 916.874251 1650.461078 2189.953293 1061.584431 2427.354491 \n", + "std 523.982964 197.651728 244.491086 150.224519 130.671523 \n", + "min 75.000000 1189.000000 1475.000000 639.000000 2044.000000 \n", + "25% 413.000000 1502.500000 2008.000000 953.500000 2346.500000 \n", + "50% 942.000000 1628.000000 2176.000000 1055.000000 2433.000000 \n", + "75% 1347.500000 1781.000000 2352.000000 1167.000000 2516.500000 \n", + "max 2284.000000 2388.000000 3051.000000 1520.000000 2753.000000 \n", + "\n", + " AST STL BLK TOV \n", + "count 835.000000 835.000000 835.000000 835.000000 \n", + "mean 1912.112575 668.364072 419.805988 1302.837126 \n", + "std 221.610925 93.393044 82.274913 153.973470 \n", + "min 1423.000000 455.000000 204.000000 931.000000 \n", + "25% 1735.000000 599.000000 359.000000 1192.000000 \n", + "50% 1899.000000 658.000000 410.000000 1289.000000 \n", + "75% 2077.500000 729.000000 469.500000 1395.500000 \n", + "max 2575.000000 1053.000000 716.000000 1873.000000 " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Inspect our data using `df.describe()` function.\n", + "df.describe()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Check for Nulls." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "SeasonEnd 0\n", + "Team 0\n", + "Playoffs 0\n", + "W 0\n", + "PTS 0\n", + "oppPTS 0\n", + "FG 0\n", + "FGA 0\n", + "2P 0\n", + "2PA 0\n", + "3P 0\n", + "3PA 0\n", + "FT 0\n", + "FTA 0\n", + "ORB 0\n", + "DRB 0\n", + "AST 0\n", + "STL 0\n", + "BLK 0\n", + "TOV 0\n", + "dtype: int64" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Check for Nulls.\n", + "df.isnull().sum()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Check for Duplicates" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.False_" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Check for Duplicates\n", + "df.duplicated().any()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Build a function that will INSPECT ANY DATAFRAME FOR YOU do this for you for any data frame you pass into it." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "\n", + "def inspect_dataframe(df):\n", + " print(\"#\" * 80)\n", + " print(\"๐Ÿงพ DATAFRAME INSPECTION REPORT\")\n", + " print(\"#\" * 80)\n", + " \n", + " # Shape of the data\n", + " print(f\"\\n๐Ÿ“ Shape of DataFrame: {df.shape[0]} rows ร— {df.shape[1]} columns\")\n", + " \n", + " # Data types and non-null counts\n", + " print(\"\\n๐Ÿ“Š Info Summary:\")\n", + " print(df.info())\n", + " \n", + " # Missing values\n", + " print(\"\\n๐Ÿ” Missing Values:\")\n", + " print(df.isnull().sum())\n", + " \n", + " # Duplicate rows\n", + " print(\"\\n๐Ÿ“‹ Duplicate Rows:\")\n", + " duplicates = df.duplicated().sum()\n", + " print(f\"Total duplicates: {duplicates}\")\n", + " if duplicates > 0:\n", + " print(\"โ†’ Duplicate rows found! Use df[df.duplicated()] to view them.\")\n", + " else:\n", + " print(\"โ†’ No duplicate rows found.\")\n", + " \n", + " # Summary statistics\n", + " print(\"\\n๐Ÿ“ˆ Descriptive Statistics:\")\n", + " print(df.describe(include='all').T)\n", + " \n", + " # Preview the data\n", + " print(\"\\n๐Ÿ‘€ Sample Data:\")\n", + " display(df.head(5))\n", + " \n", + " print(\"#\" * 80)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Get a sense of how many wins it will take to make the playoffs. \n", + "Make a scatter plot with x=Wins and the y=Team, and the hue=Playoffs" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "df = {\n", + " 'Team': ['Yankees', 'Mets', 'Dodgers', 'Giants', 'Cubs', 'Red Sox', 'Astros', 'Braves'],\n", + " 'Wins': [95, 85, 100, 88, 75, 92, 98, 89],\n", + " 'Playoffs': [1, 0, 1, 0, 0, 1, 1, 1]\n", + "}\n", + "\n", + "\n", + "def plot_wins_vs_playoffs(df):\n", + " plt.figure(figsize=(8, 6))\n", + " sns.scatterplot(\n", + " x='Wins', \n", + " y='Team', \n", + " hue='Playoffs', \n", + " data=df, \n", + " palette='coolwarm', \n", + " s=80, \n", + " alpha=0.8\n", + " )\n", + "\n", + " plt.title(\"Wins vs Team (Colored by Playoff Qualification)\", fontsize=14, fontweight='bold')\n", + " plt.xlabel(\"Wins\")\n", + " plt.ylabel(\"Team\")\n", + " plt.legend(title='Playoffs', loc='best')\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "plot_wins_vs_playoffs(df)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Take a rough estimate, and now use that moving forward. \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Wins needed to make playoffs: 89\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "df = pd.DataFrame({\n", + " 'Team': ['Yankees', 'Mets', 'Dodgers', 'Giants', 'Cubs', 'Red Sox', 'Astros', 'Braves'],\n", + " 'Wins': [95, 85, 100, 88, 75, 92, 98, 89],\n", + " 'Playoffs': [1, 0, 1, 0, 0, 1, 1, 1]\n", + "})\n", + "\n", + "\n", + "WINS_NEED_TO_MAKE_PLAYOFFS = df[df['Playoffs'] == 1]['Wins'].min()\n", + "print(\"Wins needed to make playoffs:\", WINS_NEED_TO_MAKE_PLAYOFFS)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Now do moneyball but for the NBA. \n", + "\n", + "#### I would like you to do try and do this on your own first. \n", + "\n", + "It's not easy, but its fun af. \n", + "\n", + "There is a guided lecture on how to do this that I can send you, but I'd like for you to try and figure it out on your own first. \n", + "\n", + "If you are fully stuck, ask in slack how other people did it if that doesn't work (I highly encourage collorbration and learning from eachother. I still consider that doing it on your own.) \n", + "\n", + "If that doesn't work, DM me and I will send you the lectures explaining how to do the whole thing." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Rough Guide a v1 model.\n", + "0. Make a model to predict PTS \n", + "0. For v1, dont use `2P, 3P, FG, or FT`. Instead use `2PA, 3PA, FTA`. \n", + "0. Include any other cols use see fit. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: PTS R-squared: 1.000\n", + "Model: OLS Adj. R-squared: nan\n", + "Method: Least Squares F-statistic: nan\n", + "Date: Mon, 27 Oct 2025 Prob (F-statistic): nan\n", + "Time: 04:42:25 Log-Likelihood: 155.95\n", + "No. Observations: 6 AIC: -299.9\n", + "Df Residuals: 0 BIC: -301.2\n", + "Df Model: 5 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "const 0.7062 inf 0 nan nan nan\n", + "2PA 1.2600 inf 0 nan nan nan\n", + "3PA 3.3378 inf 0 nan nan nan\n", + "FTA 4.3378 inf 0 nan nan nan\n", + "AST -13.5200 inf -0 nan nan nan\n", + "REB -1.0000 inf -0 nan nan nan\n", + "TOV 16.4933 inf 0 nan nan nan\n", + "==============================================================================\n", + "Omnibus: nan Durbin-Watson: 0.109\n", + "Prob(Omnibus): nan Jarque-Bera (JB): 0.512\n", + "Skew: -0.250 Prob(JB): 0.774\n", + "Kurtosis: 1.659 Cond. No. 1.65e+03\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "[2] The input rank is higher than the number of observations.\n", + "[3] The condition number is large, 1.65e+03. This might indicate that there are\n", + "strong multicollinearity or other numerical problems.\n", + "\n", + "Model Performance:\n", + "RMSE: 20.33\n", + "Rยฒ: -3.134\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/python/3.12.1/lib/python3.12/site-packages/statsmodels/stats/stattools.py:74: ValueWarning: omni_normtest is not valid with less than 8 observations; 6 samples were given.\n", + " warn(\"omni_normtest is not valid with less than 8 observations; %i \"\n", + "/usr/local/python/3.12.1/lib/python3.12/site-packages/statsmodels/regression/linear_model.py:1795: RuntimeWarning: divide by zero encountered in divide\n", + " return 1 - (np.divide(self.nobs - self.k_constant, self.df_resid)\n", + "/usr/local/python/3.12.1/lib/python3.12/site-packages/statsmodels/regression/linear_model.py:1795: RuntimeWarning: invalid value encountered in scalar multiply\n", + " return 1 - (np.divide(self.nobs - self.k_constant, self.df_resid)\n", + "/usr/local/python/3.12.1/lib/python3.12/site-packages/statsmodels/regression/linear_model.py:1717: RuntimeWarning: divide by zero encountered in scalar divide\n", + " return np.dot(wresid, wresid) / self.df_resid\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "\n", + "# =============================\n", + "# Basketball Points Prediction v1\n", + "# =============================\n", + "\n", + "# --- Imports ---\n", + "import pandas as pd\n", + "import numpy as np\n", + "import statsmodels.api as sm\n", + "from sklearn.metrics import mean_squared_error, r2_score\n", + "from sklearn.model_selection import train_test_split\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# --- Example Dataset ---\n", + "# Replace this with your actual dataset\n", + "df = pd.DataFrame({\n", + " 'PTS': [110, 95, 120, 102, 88, 115, 130, 99],\n", + " '2PA': [60, 55, 70, 58, 52, 65, 72, 54],\n", + " '3PA': [30, 20, 35, 25, 18, 28, 38, 22],\n", + " 'FTA': [18, 15, 22, 17, 12, 19, 25, 14],\n", + " 'AST': [22, 18, 28, 20, 15, 25, 30, 17],\n", + " 'REB': [45, 38, 50, 40, 36, 47, 55, 39],\n", + " 'TOV': [12, 10, 15, 11, 9, 13, 16, 10]\n", + "})\n", + "\n", + "# --- Define Features & Target ---\n", + "target = 'PTS'\n", + "features = ['2PA', '3PA', 'FTA', 'AST', 'REB', 'TOV']\n", + "\n", + "X = df[features]\n", + "y = df[target]\n", + "\n", + "# --- Add constant for intercept ---\n", + "X = sm.add_constant(X)\n", + "\n", + "# --- Split data (optional for small demo, but good practice) ---\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)\n", + "\n", + "# --- Build Linear Regression model ---\n", + "model = sm.OLS(y_train, X_train).fit()\n", + "\n", + "# --- Model Summary ---\n", + "print(model.summary())\n", + "\n", + "# --- Predict on test set ---\n", + "y_pred = model.predict(X_test)\n", + "\n", + "# --- Evaluate ---\n", + "rmse = np.sqrt(mean_squared_error(y_test, y_pred))\n", + "r2 = r2_score(y_test, y_pred)\n", + "\n", + "print(\"\\nModel Performance:\")\n", + "print(f\"RMSE: {rmse:.2f}\")\n", + "print(f\"Rยฒ: {r2:.3f}\")\n", + "\n", + "# --- Visualize actual vs predicted ---\n", + "plt.figure(figsize=(6,4))\n", + "sns.scatterplot(x=y_test, y=y_pred)\n", + "plt.xlabel(\"Actual Points (PTS)\")\n", + "plt.ylabel(\"Predicted Points (PTS)\")\n", + "plt.title(\"Actual vs Predicted PTS (v1 Model)\")\n", + "plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--')\n", + "plt.show()\n", + "\n", + "# --- Optionally show residuals ---\n", + "residuals = y_test - y_pred\n", + "sns.histplot(residuals, kde=True)\n", + "plt.title(\"Residuals Distribution\")\n", + "plt.show()\n", + "\n" + ] + } + ], + "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.12.1" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}