diff --git a/project.ipynb b/project.ipynb
old mode 100644
new mode 100755
index 47b5bfe..f8708b9
--- a/project.ipynb
+++ b/project.ipynb
@@ -20,7 +20,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -31,7 +31,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -44,7 +44,7 @@
     "import matplotlib.pyplot as plt\n",
     "\n",
     "# Machine Learning\n",
-    "from   sklearn.preprocessing import OneHotEncoder, MinMaxScaler, LabelEncoder\n",
+    "from   sklearn.preprocessing import OneHotEncoder, MinMaxScaler\n",
     "from   sklearn.model_selection import train_test_split, GridSearchCV\n",
     "from   sklearn.metrics import confusion_matrix , classification_report, accuracy_score, roc_auc_score, RocCurveDisplay\n",
     "from   sklearn.linear_model import LogisticRegression\n",
@@ -53,17 +53,20 @@
     "from   sklearn.neighbors import KNeighborsClassifier\n",
     "from   xgboost import XGBClassifier\n",
     "from   lightgbm import LGBMClassifier\n",
+    "from   imblearn.over_sampling import RandomOverSampler\n",
     "from   sklearn.feature_selection import SelectKBest, f_classif, RFECV\n",
     "from   sklearn.neural_network import MLPClassifier\n",
-    "from   sklearn.experimental import enable_iterative_imputer\n",
-    "from   sklearn.impute import IterativeImputer\n",
     "\n",
+    "# Keras\n",
+    "# from keras.models import Sequential\n",
+    "# from keras.layers import Dense\n",
+    "# from keras.optimizers import SGD, Adam, Adadelta, RMSprop\n",
+    "# import keras.backend as K\n",
     "\n",
     "input_file_name = \"data/Player Per Game.csv\"\n",
     "input_target_class = 'pos'\n",
     "nba_players = label = features = X = Y = None\n",
     "encoder = OneHotEncoder()\n",
-    "leEncoder = LabelEncoder()\n",
     "\n",
     "\n",
     "def visualizeData(nba_players):\n",
@@ -82,16 +85,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(12024, 18)"
+       "(25064, 22)"
       ]
      },
-     "execution_count": 6,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -99,16 +102,13 @@
    "source": [
     "nba_players = pd.read_csv(input_file_name).replace({\"C-SF\": \"C\", \"C-F\": \"C\", \"C-PF\": \"C\", \"PG-SG\": \"PG\",\"PG-SF\":\"PG\",  \"PF-SF\": \"PF\", \"PF-C\": \"PF\", \"SF-SG\": \"SF\", \"SF-PG\": \"SF\", \"PF-C\": \"PF\", \"SG-SF\": \"SG\", \"SG-PG\": \"SG\", \"SG-PF\": \"SG\", \"SF-C\": \"SF\", \"SG-SF\": \"SG\", \"SG-PG-SF\": \"SG\", \"SF-PF\": \"SF\",})\n",
     "nba_players.drop_duplicates(inplace=True)\n",
-    "nba_players = nba_players[nba_players['mp_per_game'] > 20]\n",
     "nba_players = nba_players[nba_players['pos'].isin([\"SG\", \"PF\", \"C\", \"SF\", \"PG\"])]\n",
     "dropColumns(nba_players, {'seas_id', 'season', 'player_id', 'player', 'birth_year','age',\n",
-    "       'experience', 'lg', 'tm', 'g', 'gs', 'mp_per_game', 'pf_per_game', 'ft_percent','fta_per_game', 'ft_per_game'})\n",
+    "       'experience', 'lg', 'tm', 'g', 'gs', 'mp_per_game'})\n",
     "features = list(nba_players.columns.delete(0))\n",
     "\n",
-    "imputer = IterativeImputer(max_iter=10, random_state=0)\n",
-    "\n",
     "for i in nba_players.columns[nba_players.isnull().any(axis=0)]:     #---Applying Only on variables with NaN values\n",
-    "   nba_players[i] = imputer.fit_transform(np.reshape(nba_players[i].values, (-1, 1)))\n",
+    "   nba_players[i].fillna(nba_players[i].mean(),inplace=True)\n",
     "\n",
     "\n",
     "x = nba_players[features].values\n",
@@ -123,7 +123,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
@@ -131,96 +131,105 @@
      "output_type": "stream",
      "text": [
       "<class 'pandas.core.frame.DataFrame'>\n",
-      "Index: 14664 entries, 2 to 30465\n",
-      "Data columns (total 19 columns):\n",
+      "Int64Index: 30567 entries, 0 to 31534\n",
+      "Data columns (total 23 columns):\n",
       " #   Column         Non-Null Count  Dtype  \n",
       "---  ------         --------------  -----  \n",
-      " 0   pos            14664 non-null  object \n",
-      " 1   fg_per_game    14664 non-null  float64\n",
-      " 2   fga_per_game   14664 non-null  float64\n",
-      " 3   fg_percent     14664 non-null  float64\n",
-      " 4   x3p_per_game   14664 non-null  float64\n",
-      " 5   x3pa_per_game  14664 non-null  float64\n",
-      " 6   x3p_percent    14664 non-null  float64\n",
-      " 7   x2p_per_game   14664 non-null  float64\n",
-      " 8   x2pa_per_game  14664 non-null  float64\n",
-      " 9   x2p_percent    14664 non-null  float64\n",
-      " 10  e_fg_percent   14664 non-null  float64\n",
-      " 11  orb_per_game   14664 non-null  float64\n",
-      " 12  drb_per_game   14664 non-null  float64\n",
-      " 13  trb_per_game   14664 non-null  float64\n",
-      " 14  ast_per_game   14664 non-null  float64\n",
-      " 15  stl_per_game   14664 non-null  float64\n",
-      " 16  blk_per_game   14664 non-null  float64\n",
-      " 17  tov_per_game   14664 non-null  float64\n",
-      " 18  pts_per_game   14664 non-null  float64\n",
-      "dtypes: float64(18), object(1)\n",
-      "memory usage: 2.2+ MB\n",
+      " 0   pos            30567 non-null  object \n",
+      " 1   fg_per_game    30567 non-null  float64\n",
+      " 2   fga_per_game   30567 non-null  float64\n",
+      " 3   fg_percent     30567 non-null  float64\n",
+      " 4   x3p_per_game   30567 non-null  float64\n",
+      " 5   x3pa_per_game  30567 non-null  float64\n",
+      " 6   x3p_percent    30567 non-null  float64\n",
+      " 7   x2p_per_game   30567 non-null  float64\n",
+      " 8   x2pa_per_game  30567 non-null  float64\n",
+      " 9   x2p_percent    30567 non-null  float64\n",
+      " 10  e_fg_percent   30567 non-null  float64\n",
+      " 11  ft_per_game    30567 non-null  float64\n",
+      " 12  fta_per_game   30567 non-null  float64\n",
+      " 13  ft_percent     30567 non-null  float64\n",
+      " 14  orb_per_game   30567 non-null  float64\n",
+      " 15  drb_per_game   30567 non-null  float64\n",
+      " 16  trb_per_game   30567 non-null  float64\n",
+      " 17  ast_per_game   30567 non-null  float64\n",
+      " 18  stl_per_game   30567 non-null  float64\n",
+      " 19  blk_per_game   30567 non-null  float64\n",
+      " 20  tov_per_game   30567 non-null  float64\n",
+      " 21  pf_per_game    30567 non-null  float64\n",
+      " 22  pts_per_game   30567 non-null  float64\n",
+      "dtypes: float64(22), object(1)\n",
+      "memory usage: 5.6+ MB\n",
       "     fg_per_game  fga_per_game  fg_percent  x3p_per_game  x3pa_per_game  \\\n",
       "pos                                                                       \n",
-      "C       4.933918      9.963770    0.497874      0.257389       0.751607   \n",
-      "PF      4.941384     10.534803    0.469000      0.504181       1.455618   \n",
-      "PG      4.717365     10.777645    0.434954      0.893437       2.543927   \n",
-      "SF      5.184779     11.394364    0.451752      0.816301       2.289198   \n",
-      "SG      5.188450     11.722637    0.439919      1.019711       2.840514   \n",
+      "C       2.923135      6.109922    0.466696      0.158731       0.477291   \n",
+      "PF      3.146323      6.852738    0.447991      0.320833       0.954840   \n",
+      "PG      3.191206      7.472175    0.412276      0.604925       1.773504   \n",
+      "SF      3.395543      7.653616    0.426897      0.537584       1.561153   \n",
+      "SG      3.447625      7.995579    0.414016      0.681488       1.953813   \n",
       "\n",
-      "     x3p_percent  x2p_per_game  x2pa_per_game  x2p_percent  e_fg_percent  \\\n",
-      "pos                                                                        \n",
-      "C       0.204928      4.817497       9.613193     0.504990      0.503265   \n",
-      "PF      0.241945      4.572286       9.464722     0.486198      0.487683   \n",
-      "PG      0.304418      3.953460       8.598603     0.458125      0.471075   \n",
-      "SF      0.295282      4.504624       9.491158     0.476378      0.485626   \n",
-      "SG      0.314532      4.296387       9.244225     0.466173      0.481456   \n",
+      "     x3p_percent  x2p_per_game  x2pa_per_game  x2p_percent  e_fg_percent  ...  \\\n",
+      "pos                                                                       ...   \n",
+      "C       0.214833      2.851092       5.886282     0.474706      0.472200  ...   \n",
+      "PF      0.234194      2.902069       6.122620     0.467458      0.466159  ...   \n",
+      "PG      0.286185      2.658914       5.909859     0.437794      0.448294  ...   \n",
+      "SF      0.274370      2.947175       6.353162     0.454245      0.458341  ...   \n",
+      "SG      0.290808      2.849334       6.286205     0.442734      0.453178  ...   \n",
+      "\n",
+      "     ft_percent  orb_per_game  drb_per_game  trb_per_game  ast_per_game  \\\n",
+      "pos                                                                       \n",
+      "C      0.661561      1.571495      3.380282      5.412887      1.057771   \n",
+      "PF     0.695075      1.426425      3.186789      4.971163      1.216492   \n",
+      "PG     0.767784      0.532775      1.774219      2.254920      3.691189   \n",
+      "SF     0.735083      1.007725      2.449734      3.628967      1.534342   \n",
+      "SG     0.760739      0.670560      1.872885      2.477198      2.076956   \n",
       "\n",
-      "     orb_per_game  drb_per_game  trb_per_game  ast_per_game  stl_per_game  \\\n",
-      "pos                                                                         \n",
-      "C        2.398640      5.436519      8.671343      1.785373      0.755345   \n",
-      "PF       2.047610      4.825207      7.398168      1.919946      0.862718   \n",
-      "PG       0.763512      2.581531      3.175116      5.365403      1.198089   \n",
-      "SF       1.395931      3.570006      5.168883      2.340533      0.991729   \n",
-      "SG       0.929310      2.682891      3.478721      3.055960      1.046833   \n",
+      "     stl_per_game  blk_per_game  tov_per_game  pf_per_game  pts_per_game  \n",
+      "pos                                                                       \n",
+      "C        0.488471      0.766070      1.167088     2.311127      7.458781  \n",
+      "PF       0.576649      0.494813      1.181158     2.185657      8.154123  \n",
+      "PG       0.847866      0.174860      1.517180     1.788543      8.581003  \n",
+      "SF       0.686111      0.340145      1.206385     1.951665      8.931147  \n",
+      "SG       0.731047      0.238915      1.269901     1.784951      9.186863  \n",
       "\n",
-      "     blk_per_game  tov_per_game  pts_per_game  \n",
-      "pos                                            \n",
-      "C        1.218234      1.820343     12.577401  \n",
-      "PF       0.730630      1.783171     12.821947  \n",
-      "PG       0.262589      2.151542     12.721956  \n",
-      "SF       0.488338      1.769335     13.679379  \n",
-      "SG       0.344959      1.818814     13.859234  \n",
-      "pos\n",
-      "SG    3238\n",
-      "PG    3006\n",
-      "SF    2963\n",
-      "PF    2948\n",
-      "C     2509\n",
-      "Name: count, dtype: int64\n"
+      "[5 rows x 22 columns]\n",
+      "SG    6379\n",
+      "PF    6282\n",
+      "C     6138\n",
+      "SF    5946\n",
+      "PG    5822\n",
+      "Name: pos, dtype: int64\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "fg_per_game      0.860670\n",
-       "fga_per_game     0.749044\n",
-       "fg_percent       0.374438\n",
-       "x3p_per_game     1.255505\n",
-       "x3pa_per_game    1.065179\n",
-       "x3p_percent     -0.252359\n",
-       "x2p_per_game     0.854352\n",
-       "x2pa_per_game    0.794591\n",
-       "x2p_percent      0.279731\n",
-       "e_fg_percent     0.164877\n",
-       "orb_per_game     1.092352\n",
-       "drb_per_game     1.212461\n",
-       "trb_per_game     1.392297\n",
-       "ast_per_game     1.443482\n",
-       "stl_per_game     1.203823\n",
-       "blk_per_game     2.504541\n",
-       "tov_per_game     0.760921\n",
-       "pts_per_game     0.892196\n",
+       "fg_per_game      1.015685\n",
+       "fga_per_game     0.935758\n",
+       "fg_percent      -0.449294\n",
+       "x3p_per_game     2.010991\n",
+       "x3pa_per_game    1.785295\n",
+       "x3p_percent      0.484556\n",
+       "x2p_per_game     1.190572\n",
+       "x2pa_per_game    1.153084\n",
+       "x2p_percent     -0.341590\n",
+       "e_fg_percent    -0.437402\n",
+       "ft_per_game      1.629558\n",
+       "fta_per_game     1.570396\n",
+       "ft_percent      -1.436705\n",
+       "orb_per_game     1.538010\n",
+       "drb_per_game     1.477636\n",
+       "trb_per_game     1.633362\n",
+       "ast_per_game     1.846789\n",
+       "stl_per_game     1.248359\n",
+       "blk_per_game     3.028837\n",
+       "tov_per_game     1.045606\n",
+       "pf_per_game      0.091628\n",
+       "pts_per_game     1.056928\n",
        "dtype: float64"
       ]
      },
-     "execution_count": 7,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -233,45 +242,37 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
+     "name": "stderr",
      "output_type": "stream",
      "text": [
-      "            Specs        Score\n",
-      "12   trb_per_game  2985.979641\n",
-      "13   ast_per_game  2356.845097\n",
-      "10   orb_per_game  2265.257237\n",
-      "11   drb_per_game  1989.769309\n",
-      "15   blk_per_game  1646.211476\n",
-      "4   x3pa_per_game   555.980284\n",
-      "2      fg_percent   544.312705\n",
-      "3    x3p_per_game   497.831603\n",
-      "14   stl_per_game   402.405629\n",
-      "5     x3p_percent   340.842662\n",
-      "8     x2p_percent   221.641119\n",
-      "16   tov_per_game   115.880705\n",
-      "9    e_fg_percent    90.639143\n",
-      "1    fga_per_game    66.479511\n",
-      "6    x2p_per_game    56.389629\n",
-      "17   pts_per_game    29.906770\n",
-      "0     fg_per_game    24.740448\n",
-      "7   x2pa_per_game    22.080921\n"
+      "/Users/michaeldavid/anaconda3/lib/python3.11/site-packages/sklearn/utils/validation.py:1143: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
+      "  y = column_or_1d(y, warn=True)\n"
      ]
     },
     {
-     "name": "stderr",
+     "name": "stdout",
      "output_type": "stream",
      "text": [
-      "C:\\Users\\User\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.10_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python310\\site-packages\\sklearn\\utils\\validation.py:1183: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
-      "  y = column_or_1d(y, warn=True)\n"
+      "            Specs        Score\n",
+      "16   ast_per_game  2336.868907\n",
+      "13   orb_per_game  1914.252827\n",
+      "18   blk_per_game  1673.675158\n",
+      "15   trb_per_game  1605.388320\n",
+      "14   drb_per_game  1035.885538\n",
+      "4   x3pa_per_game   880.559484\n",
+      "3    x3p_per_game   747.019180\n",
+      "12     ft_percent   560.848951\n",
+      "17   stl_per_game   519.001360\n",
+      "20    pf_per_game   359.370089\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -288,7 +289,7 @@
     }
    ],
    "source": [
-    "topFeatures = 18\n",
+    "topFeatures = 10\n",
     "selector = SelectKBest(score_func=f_classif, k=topFeatures)  \n",
     "fit = selector.fit(X_train, encoder.inverse_transform(y_train))\n",
     "\n",
@@ -323,23 +324,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Index(['fg_per_game', 'fga_per_game', 'fg_percent', 'x3pa_per_game',\n",
-      "       'x2p_per_game', 'x2pa_per_game', 'x2p_percent', 'e_fg_percent',\n",
+      "Index(['fga_per_game', 'fg_percent', 'x3pa_per_game', 'x2pa_per_game',\n",
+      "       'x2p_percent', 'e_fg_percent', 'fta_per_game', 'ft_percent',\n",
       "       'orb_per_game', 'drb_per_game', 'trb_per_game', 'ast_per_game',\n",
-      "       'stl_per_game', 'blk_per_game', 'tov_per_game', 'pts_per_game'],\n",
+      "       'stl_per_game', 'blk_per_game', 'pf_per_game', 'pts_per_game'],\n",
       "      dtype='object')\n"
      ]
     }
    ],
    "source": [
     "mask = rfecv.get_support()\n",
+    "# mask[2] = False\n",
+    "# mask[6] = mask[15] = True\n",
     "best_features = nba_players.columns[mask]\n",
     "print(best_features)  # choose using rfev selectKbest and featureInportance form classifiers\n",
     "X_old = X_train\n",
@@ -350,57 +353,33 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "C:\\Users\\User\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.10_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python310\\site-packages\\sklearn\\preprocessing\\_label.py:114: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
-      "  y = column_or_1d(y, warn=True)\n",
-      "C:\\Users\\User\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.10_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python310\\site-packages\\sklearn\\preprocessing\\_label.py:114: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
-      "  y = column_or_1d(y, warn=True)\n"
-     ]
-    },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "The accuracy of Training prediction is:  0.9989188290086494\n",
-      "The number of accurate predictions is:  12011\n",
-      "The accuracy of  Test prediction is:  0.6465909090909091\n",
-      "The number of accurate predictions is:  1707\n",
-      "The accuracy of prediction is:  0.5306818181818181\n",
-      "The number of accurate predictions is:  1401\n",
-      "The accuracy of prediction is:  0.5306818181818181\n",
-      "The number of accurate predictions is:  1401\n"
+      "The accuracy of prediction is:  0.520079956387425\n",
+      "The number of accurate predictions is:  2862\n",
+      "The accuracy of prediction is:  0.4592040705069962\n",
+      "The number of accurate predictions is:  2527\n",
+      "The accuracy of prediction is:  0.4344902780301654\n",
+      "The number of accurate predictions is:  2391\n",
+      "The accuracy of prediction is:  0.4344902780301654\n",
+      "The number of accurate predictions is:  2391\n"
      ]
     }
    ],
    "source": [
-    "model = XGBClassifier(\n",
-    "    objective='multi:softmax',\n",
-    "    num_class=5,\n",
-    "    learning_rate=0.015,\n",
-    "    subsample=0.7,\n",
-    "    max_depth=10,\n",
-    "    colsample_bytree=0.5,\n",
-    "    n_estimators=1000\n",
-    ")\n",
-    "Y_train = leEncoder.fit_transform(encoder.inverse_transform(y_train))\n",
-    "Y_test = leEncoder.fit_transform(encoder.inverse_transform(y_test))\n",
-    "model = model.fit(X_train, Y_train)\n",
-    "\n",
-    "predictions = model.predict(X_train)\n",
-    "accuracy = accuracy_score(Y_train, (predictions))\n",
-    "print(\"The accuracy of Training prediction is: \", accuracy)\n",
-    "accurate_predictions = accuracy_score(leEncoder.fit_transform(Y_train), predictions, normalize=False)\n",
-    "print(\"The number of accurate predictions is: \", accurate_predictions)\n",
+    "model = DecisionTreeClassifier()\n",
+    "model = model.fit(X_train, y_train)\n",
     "predictions = model.predict(X_test)\n",
-    "accuracy = accuracy_score(Y_test, (predictions))\n",
-    "print(\"The accuracy of  Test prediction is: \", accuracy)\n",
-    "accurate_predictions = accuracy_score(Y_test, predictions, normalize=False)\n",
+    "accuracy = accuracy_score(y_test, predictions)\n",
+    "print(\"The accuracy of prediction is: \", accuracy)\n",
+    "\n",
+    "# find number of accurate predictions\n",
+    "accurate_predictions = accuracy_score(y_test, predictions, normalize=False)\n",
     "print(\"The number of accurate predictions is: \", accurate_predictions)\n",
     "\n",
     "model = RandomForestClassifier()\n",
@@ -408,6 +387,18 @@
     "predictions = model.predict(X_test)\n",
     "accuracy = accuracy_score(y_test, predictions)\n",
     "print(\"The accuracy of prediction is: \", accuracy)\n",
+    "\n",
+    "# find number of accurate predictions\n",
+    "accurate_predictions = accuracy_score(y_test, predictions, normalize=False)\n",
+    "print(\"The number of accurate predictions is: \", accurate_predictions)\n",
+    "\n",
+    "model = ExtraTreesClassifier()\n",
+    "model = model.fit(X_train, y_train)\n",
+    "predictions = model.predict(X_test)\n",
+    "accuracy = accuracy_score(y_test, predictions)\n",
+    "print(\"The accuracy of prediction is: \", accuracy)\n",
+    "\n",
+    "# find number of accurate predictions\n",
     "accurate_predictions = accuracy_score(y_test, predictions, normalize=False)\n",
     "print(\"The number of accurate predictions is: \", accurate_predictions)\n",
     "\n",
@@ -415,129 +406,327 @@
     "model = model.fit(X_train, y_train)\n",
     "accuracy = accuracy_score(y_test, predictions)\n",
     "print(\"The accuracy of prediction is: \", accuracy)\n",
+    "\n",
+    "# find number of accurate predictions\n",
     "accurate_predictions = accuracy_score(y_test, predictions, normalize=False)\n",
     "print(\"The number of accurate predictions is: \", accurate_predictions)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/html": [
-       "<style>#sk-container-id-2 {color: black;}#sk-container-id-2 pre{padding: 0;}#sk-container-id-2 div.sk-toggleable {background-color: white;}#sk-container-id-2 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-2 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-2 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-2 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-2 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-2 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-2 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-2 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-2 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-2 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-2 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-2 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-2 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-2 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-2 div.sk-item {position: relative;z-index: 1;}#sk-container-id-2 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-2 div.sk-item::before, #sk-container-id-2 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-2 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-2 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-2 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-2 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-2 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-2 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-2 div.sk-label-container {text-align: center;}#sk-container-id-2 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-2 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-2\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>GridSearchCV(estimator=MLPClassifier(activation=&#x27;logistic&#x27;,\n",
-       "                                     learning_rate=&#x27;adaptive&#x27;,\n",
-       "                                     learning_rate_init=0.1, max_iter=3000,\n",
-       "                                     solver=&#x27;sgd&#x27;),\n",
-       "             param_grid={&#x27;alpha&#x27;: [0.0001, 0.05, 0.1, 0.3, 0.01],\n",
-       "                         &#x27;hidden_layer_sizes&#x27;: [(10, 30, 10), (12,), (12, 12),\n",
-       "                                                (12, 6, 3, 1), (12, 12, 12, 12),\n",
-       "                                                (12, 6, 12, 3, 12, 1)]})</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item sk-dashed-wrapped\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-4\" type=\"checkbox\" ><label for=\"sk-estimator-id-4\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">GridSearchCV</label><div class=\"sk-toggleable__content\"><pre>GridSearchCV(estimator=MLPClassifier(activation=&#x27;logistic&#x27;,\n",
-       "                                     learning_rate=&#x27;adaptive&#x27;,\n",
-       "                                     learning_rate_init=0.1, max_iter=3000,\n",
-       "                                     solver=&#x27;sgd&#x27;),\n",
-       "             param_grid={&#x27;alpha&#x27;: [0.0001, 0.05, 0.1, 0.3, 0.01],\n",
-       "                         &#x27;hidden_layer_sizes&#x27;: [(10, 30, 10), (12,), (12, 12),\n",
-       "                                                (12, 6, 3, 1), (12, 12, 12, 12),\n",
-       "                                                (12, 6, 12, 3, 12, 1)]})</pre></div></div></div><div class=\"sk-parallel\"><div class=\"sk-parallel-item\"><div class=\"sk-item\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-5\" type=\"checkbox\" ><label for=\"sk-estimator-id-5\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">estimator: MLPClassifier</label><div class=\"sk-toggleable__content\"><pre>MLPClassifier(activation=&#x27;logistic&#x27;, learning_rate=&#x27;adaptive&#x27;,\n",
-       "              learning_rate_init=0.1, max_iter=3000, solver=&#x27;sgd&#x27;)</pre></div></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-6\" type=\"checkbox\" ><label for=\"sk-estimator-id-6\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">MLPClassifier</label><div class=\"sk-toggleable__content\"><pre>MLPClassifier(activation=&#x27;logistic&#x27;, learning_rate=&#x27;adaptive&#x27;,\n",
-       "              learning_rate_init=0.1, max_iter=3000, solver=&#x27;sgd&#x27;)</pre></div></div></div></div></div></div></div></div></div></div>"
-      ],
-      "text/plain": [
-       "GridSearchCV(estimator=MLPClassifier(activation='logistic',\n",
-       "                                     learning_rate='adaptive',\n",
-       "                                     learning_rate_init=0.1, max_iter=3000,\n",
-       "                                     solver='sgd'),\n",
-       "             param_grid={'alpha': [0.0001, 0.05, 0.1, 0.3, 0.01],\n",
-       "                         'hidden_layer_sizes': [(10, 30, 10), (12,), (12, 12),\n",
-       "                                                (12, 6, 3, 1), (12, 12, 12, 12),\n",
-       "                                                (12, 6, 12, 3, 12, 1)]})"
-      ]
-     },
-     "execution_count": 34,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The accuracy of prediction is:  0.37180817108203\n",
+      "The number of accurate predictions is:  9319\n"
+     ]
     }
    ],
    "source": [
-    "parameter = {\n",
-    "    'hidden_layer_sizes': [(10,30,10),(12,), (12, 12), (12,6,3,1),(12,12,12,12),(12,6,12,3,12,1)],\n",
-    "    'alpha': [0.0001, 0.05, 0.1, 0.3, 0.01],\n",
-    "}\n",
-    "\n",
-    "\n",
-    "mlp = MLPClassifier(learning_rate='adaptive',learning_rate_init=0.1, activation='logistic', solver='sgd', max_iter=3000)\n",
-    "grid = GridSearchCV(estimator=mlp, param_grid=parameter,)\n",
-    "grid.fit(X_train,y_train)\n",
-    "# mlp.fit(X_train,y_train)\n",
-    "\n",
-    "# predictions = mlp.predict(X_train)\n",
-    "# # predictions = mlp.predict(X_test)\n",
-    "# accuracy = accuracy_score(y_train, predictions)\n",
-    "# print(\"The accuracy of prediction is: \", accuracy)\n",
-    "\n",
-    "# # find number of accurate predictions\n",
-    "# accurate_predictions = accuracy_score(y_train, predictions, normalize=False)\n",
-    "# # print(\"The number of accurate predictions is: \", accurate_predictions)\n",
-    "# # mlp.get_params"
+    "#https://towardsdatascience.com/17-rules-of-thumb-for-building-a-neural-network-93356f9930af\n",
+    "mlp = MLPClassifier(hidden_layer_sizes=(11,5, 2), activation='relu', solver='adam', max_iter=30000)\n",
+    "mlp.fit(X_train,y_train)\n",
+    "\n",
+    "predictions = mlp.predict(X_train)\n",
+    "# predictions = mlp.predict(X_test)\n",
+    "accuracy = accuracy_score(y_train, predictions)\n",
+    "print(\"The accuracy of prediction is: \", accuracy)\n",
+    "\n",
+    "# find number of accurate predictions\n",
+    "accurate_predictions = accuracy_score(y_train, predictions, normalize=False)\n",
+    "print(\"The number of accurate predictions is: \", accurate_predictions)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'alpha': 0.0001, 'hidden_layer_sizes': (12, 12)}\n",
-      "0.5818359906047095\n"
+      "       seas_id  season  player_id          player  birth_year  pos   age  \\\n",
+      "0        31136    2024       5025      A.J. Green         NaN   SG  24.0   \n",
+      "1        31137    2024       5027      AJ Griffin         NaN   SF  20.0   \n",
+      "2        31138    2024       4219    Aaron Gordon         NaN   PF  28.0   \n",
+      "3        31139    2024       4582   Aaron Holiday         NaN   PG  27.0   \n",
+      "4        31140    2024       4805   Aaron Nesmith         NaN   SF  24.0   \n",
+      "...        ...     ...        ...             ...         ...  ...   ...   \n",
+      "31545      200    1947        157     Walt Miller         NaN    F  31.0   \n",
+      "31546      201    1947        158   Warren Fenley         NaN    F  24.0   \n",
+      "31547      202    1947        159   Wilbert Kautz         NaN  G-F  31.0   \n",
+      "31548      203    1947        160  Woody Grimshaw         NaN    G  27.0   \n",
+      "31549      204    1947        161     Wyndol Gray         NaN  G-F  24.0   \n",
+      "\n",
+      "       experience   lg   tm  ...  ft_percent  orb_per_game  drb_per_game  \\\n",
+      "0               2  NBA  MIL  ...       1.000           0.0           0.5   \n",
+      "1               2  NBA  ATL  ...         NaN           0.3           1.0   \n",
+      "2              10  NBA  DEN  ...       0.250           1.8           3.0   \n",
+      "3               6  NBA  HOU  ...         NaN           0.0           0.0   \n",
+      "4               4  NBA  IND  ...       0.833           1.7           4.3   \n",
+      "...           ...  ...  ...  ...         ...           ...           ...   \n",
+      "31545           1  BAA  PIT  ...       0.500           NaN           NaN   \n",
+      "31546           1  BAA  BOS  ...       0.511           NaN           NaN   \n",
+      "31547           1  BAA  CHS  ...       0.534           NaN           NaN   \n",
+      "31548           1  BAA  PRO  ...       0.477           NaN           NaN   \n",
+      "31549           1  BAA  BOS  ...       0.581           NaN           NaN   \n",
+      "\n",
+      "       trb_per_game  ast_per_game  stl_per_game  blk_per_game  tov_per_game  \\\n",
+      "0               0.5           1.0           0.0           0.0           0.0   \n",
+      "1               1.3           0.5           0.3           0.0           0.5   \n",
+      "2               4.8           3.0           1.5           1.3           1.3   \n",
+      "3               0.0           0.0           0.0           0.0           0.0   \n",
+      "4               6.0           1.3           0.0           1.0           0.3   \n",
+      "...             ...           ...           ...           ...           ...   \n",
+      "31545           NaN           0.5           NaN           NaN           NaN   \n",
+      "31546           NaN           0.5           NaN           NaN           NaN   \n",
+      "31547           NaN           0.7           NaN           NaN           NaN   \n",
+      "31548           NaN           0.0           NaN           NaN           NaN   \n",
+      "31549           NaN           0.9           NaN           NaN           NaN   \n",
+      "\n",
+      "       pf_per_game  pts_per_game  \n",
+      "0              1.5           3.5  \n",
+      "1              0.3           4.3  \n",
+      "2              1.5          13.8  \n",
+      "3              0.0           0.0  \n",
+      "4              3.3          12.7  \n",
+      "...            ...           ...  \n",
+      "31545          1.3           1.9  \n",
+      "31546          1.8           2.6  \n",
+      "31547          2.3           5.1  \n",
+      "31548          1.2           2.9  \n",
+      "31549          1.9           6.4  \n",
+      "\n",
+      "[31550 rows x 35 columns]\n"
      ]
     }
    ],
    "source": [
-    "print(grid.best_params_)\n",
-    "print(grid.best_score_)"
+    "\n",
+    "# Import pandas and glob\n",
+    "import pandas as pd\n",
+    "import glob\n",
+    "\n",
+    "# Get a list of all the CSV files in a directory\n",
+    "files = glob.glob(\"data/Player Per Game.csv\")\n",
+    "\n",
+    "# Initialize an empty dataframe to hold the combined data\n",
+    "combined_df = pd.DataFrame()\n",
+    "\n",
+    "# Loop through the files and read each one into a dataframe\n",
+    "for file in files:\n",
+    "    df = pd.read_csv(file)\n",
+    "    # Concatenate the dataframe to the combined dataframe\n",
+    "    combined_df = pd.concat([combined_df, df], ignore_index=True)\n",
+    "\n",
+    "# Print the combined dataframe\n",
+    "print(combined_df)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Index(['seas_id', 'season', 'player_id', 'player', 'birth_year', 'pos', 'age',\n",
+       "       'experience', 'lg', 'tm', 'g', 'gs', 'mp_per_game', 'fg_per_game',\n",
+       "       'fga_per_game', 'fg_percent', 'x3p_per_game', 'x3pa_per_game',\n",
+       "       'x3p_percent', 'x2p_per_game', 'x2pa_per_game', 'x2p_percent',\n",
+       "       'e_fg_percent', 'ft_per_game', 'fta_per_game', 'ft_percent',\n",
+       "       'orb_per_game', 'drb_per_game', 'trb_per_game', 'ast_per_game',\n",
+       "       'stl_per_game', 'blk_per_game', 'tov_per_game', 'pf_per_game',\n",
+       "       'pts_per_game'],\n",
+       "      dtype='object')"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "\n",
-    "plt.plot(mlp.loss_curve_, label=\"Cost\")\n",
-    "plt.legend()\n",
-    "plt.show()\n"
+    "combined_df.columns"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "'seas_id', 'season', 'player_id', 'player', 'birth_year','age',\n",
+    "       'experience', 'lg', 'tm', 'g', 'gs', 'mp_per_game'"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(25064, 16)"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "X_train.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "The accuracy of prediction is:  0.5723484848484849\n",
-      "The number of accurate predictions is:  1511\n"
+      "Epoch 1/50\n",
+      "784/784 [==============================] - 3s 2ms/step - loss: 1.0253 - accuracy: 0.5426 - val_loss: 0.9543 - val_accuracy: 0.5748\n",
+      "Epoch 2/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.9417 - accuracy: 0.5806 - val_loss: 0.9290 - val_accuracy: 0.5826\n",
+      "Epoch 3/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.9267 - accuracy: 0.5845 - val_loss: 0.9238 - val_accuracy: 0.5915\n",
+      "Epoch 4/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.9151 - accuracy: 0.5918 - val_loss: 0.9052 - val_accuracy: 0.5949\n",
+      "Epoch 5/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.9071 - accuracy: 0.5959 - val_loss: 0.9416 - val_accuracy: 0.5751\n",
+      "Epoch 6/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.9024 - accuracy: 0.5981 - val_loss: 0.8916 - val_accuracy: 0.6026\n",
+      "Epoch 7/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8973 - accuracy: 0.6013 - val_loss: 0.9210 - val_accuracy: 0.5797\n",
+      "Epoch 8/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8953 - accuracy: 0.6013 - val_loss: 0.8939 - val_accuracy: 0.6008\n",
+      "Epoch 9/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8907 - accuracy: 0.6030 - val_loss: 0.8922 - val_accuracy: 0.5933\n",
+      "Epoch 10/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8886 - accuracy: 0.6045 - val_loss: 0.8842 - val_accuracy: 0.5995\n",
+      "Epoch 11/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8829 - accuracy: 0.6055 - val_loss: 0.8869 - val_accuracy: 0.6022\n",
+      "Epoch 12/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8835 - accuracy: 0.6080 - val_loss: 0.8826 - val_accuracy: 0.6024\n",
+      "Epoch 13/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8789 - accuracy: 0.6078 - val_loss: 0.8990 - val_accuracy: 0.6024\n",
+      "Epoch 14/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8742 - accuracy: 0.6092 - val_loss: 0.8920 - val_accuracy: 0.5993\n",
+      "Epoch 15/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8746 - accuracy: 0.6114 - val_loss: 0.9054 - val_accuracy: 0.5850\n",
+      "Epoch 16/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8694 - accuracy: 0.6159 - val_loss: 0.8761 - val_accuracy: 0.6071\n",
+      "Epoch 17/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8680 - accuracy: 0.6160 - val_loss: 0.8946 - val_accuracy: 0.5944\n",
+      "Epoch 18/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8647 - accuracy: 0.6167 - val_loss: 0.8777 - val_accuracy: 0.6160\n",
+      "Epoch 19/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8640 - accuracy: 0.6170 - val_loss: 0.8780 - val_accuracy: 0.6039\n",
+      "Epoch 20/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8597 - accuracy: 0.6165 - val_loss: 0.8746 - val_accuracy: 0.6091\n",
+      "Epoch 21/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8601 - accuracy: 0.6159 - val_loss: 0.8891 - val_accuracy: 0.6006\n",
+      "Epoch 22/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8590 - accuracy: 0.6151 - val_loss: 0.8759 - val_accuracy: 0.6177\n",
+      "Epoch 23/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8554 - accuracy: 0.6194 - val_loss: 0.8782 - val_accuracy: 0.6011\n",
+      "Epoch 24/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8515 - accuracy: 0.6220 - val_loss: 0.8779 - val_accuracy: 0.6080\n",
+      "Epoch 25/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8492 - accuracy: 0.6226 - val_loss: 0.8770 - val_accuracy: 0.6098\n",
+      "Epoch 26/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8464 - accuracy: 0.6225 - val_loss: 0.8768 - val_accuracy: 0.6088\n",
+      "Epoch 27/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8451 - accuracy: 0.6212 - val_loss: 0.8786 - val_accuracy: 0.6104\n",
+      "Epoch 28/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8436 - accuracy: 0.6261 - val_loss: 0.8769 - val_accuracy: 0.6086\n",
+      "Epoch 29/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8408 - accuracy: 0.6249 - val_loss: 0.8819 - val_accuracy: 0.6149\n",
+      "Epoch 30/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8377 - accuracy: 0.6289 - val_loss: 0.8850 - val_accuracy: 0.6024\n",
+      "Epoch 31/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8357 - accuracy: 0.6266 - val_loss: 0.8753 - val_accuracy: 0.6115\n",
+      "Epoch 32/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8316 - accuracy: 0.6304 - val_loss: 0.8760 - val_accuracy: 0.6106\n",
+      "Epoch 33/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8320 - accuracy: 0.6299 - val_loss: 0.8818 - val_accuracy: 0.6115\n",
+      "Epoch 34/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8275 - accuracy: 0.6294 - val_loss: 0.8771 - val_accuracy: 0.6180\n",
+      "Epoch 35/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8235 - accuracy: 0.6357 - val_loss: 0.8774 - val_accuracy: 0.6091\n",
+      "Epoch 36/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8219 - accuracy: 0.6329 - val_loss: 0.8893 - val_accuracy: 0.6071\n",
+      "Epoch 37/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8216 - accuracy: 0.6318 - val_loss: 0.8844 - val_accuracy: 0.6118\n",
+      "Epoch 38/50\n",
+      "784/784 [==============================] - 2s 2ms/step - loss: 0.8160 - accuracy: 0.6339 - val_loss: 0.8737 - val_accuracy: 0.6093\n",
+      "Epoch 39/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8116 - accuracy: 0.6397 - val_loss: 0.8877 - val_accuracy: 0.6118\n",
+      "Epoch 40/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8092 - accuracy: 0.6401 - val_loss: 0.8783 - val_accuracy: 0.6115\n",
+      "Epoch 41/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8084 - accuracy: 0.6388 - val_loss: 0.8858 - val_accuracy: 0.6133\n",
+      "Epoch 42/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8050 - accuracy: 0.6424 - val_loss: 0.9012 - val_accuracy: 0.6022\n",
+      "Epoch 43/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.8027 - accuracy: 0.6409 - val_loss: 0.8857 - val_accuracy: 0.6071\n",
+      "Epoch 44/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.7976 - accuracy: 0.6462 - val_loss: 0.9025 - val_accuracy: 0.6122\n",
+      "Epoch 45/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.7972 - accuracy: 0.6453 - val_loss: 0.8887 - val_accuracy: 0.6144\n",
+      "Epoch 46/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.7914 - accuracy: 0.6481 - val_loss: 0.8852 - val_accuracy: 0.6073\n",
+      "Epoch 47/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.7901 - accuracy: 0.6487 - val_loss: 0.9159 - val_accuracy: 0.6022\n",
+      "Epoch 48/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.7860 - accuracy: 0.6518 - val_loss: 0.8904 - val_accuracy: 0.6066\n",
+      "Epoch 49/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.7826 - accuracy: 0.6528 - val_loss: 0.8987 - val_accuracy: 0.6124\n",
+      "Epoch 50/50\n",
+      "784/784 [==============================] - 1s 2ms/step - loss: 0.7779 - accuracy: 0.6578 - val_loss: 0.8943 - val_accuracy: 0.6048\n",
+      "Training accuracy: [0.5425710082054138, 0.5806335806846619, 0.5845435857772827, 0.5918448567390442, 0.5959144830703735, 0.5981088280677795, 0.601260781288147, 0.6013405919075012, 0.602976381778717, 0.6044924855232239, 0.6054500341415405, 0.6079636216163635, 0.607804000377655, 0.6091605424880981, 0.6113948225975037, 0.615943193435669, 0.6160230040550232, 0.6167012453079224, 0.6169805526733398, 0.6165017485618591, 0.615943193435669, 0.6150654554367065, 0.6193743944168091, 0.6220076680183411, 0.6226460337638855, 0.6225263476371765, 0.6211698055267334, 0.6261171698570251, 0.6249201893806458, 0.6288700699806213, 0.6265959143638611, 0.630386233329773, 0.6299074292182922, 0.6293887495994568, 0.6356527209281921, 0.6328997611999512, 0.6317826509475708, 0.6338573098182678, 0.639682412147522, 0.6400814056396484, 0.6388445496559143, 0.6423555612564087, 0.6408793330192566, 0.6462256908416748, 0.6453080177307129, 0.6480609774589539, 0.6486993432044983, 0.6518113613128662, 0.6528487205505371, 0.6577960252761841]\n",
+      "Training loss: [1.0253432989120483, 0.9417043924331665, 0.9267209768295288, 0.9150730967521667, 0.9070940017700195, 0.9023607969284058, 0.8973389863967896, 0.895287811756134, 0.8906853795051575, 0.8886131048202515, 0.8829232454299927, 0.8835217952728271, 0.8788761496543884, 0.8742138147354126, 0.8745505809783936, 0.8694213032722473, 0.8680180311203003, 0.8646969795227051, 0.8639936447143555, 0.8597244024276733, 0.8601436018943787, 0.8590145111083984, 0.8553932309150696, 0.851494550704956, 0.8492430448532104, 0.8463982343673706, 0.8451324701309204, 0.8436098098754883, 0.8408382534980774, 0.8377318978309631, 0.8357376456260681, 0.831588625907898, 0.8319598436355591, 0.827456533908844, 0.8235229253768921, 0.8218597173690796, 0.8216383457183838, 0.8160205483436584, 0.8116257786750793, 0.8091821074485779, 0.8083667755126953, 0.8049963116645813, 0.8026672601699829, 0.7976315021514893, 0.7972183227539062, 0.7914347648620605, 0.7900691628456116, 0.7859517931938171, 0.7826489210128784, 0.7778622508049011]\n",
+      "Validation accuracy: [0.574777364730835, 0.5825912952423096, 0.5914955735206604, 0.5949482321739197, 0.5751408338546753, 0.6025804281234741, 0.579683780670166, 0.600763201713562, 0.5933127403259277, 0.5994911789894104, 0.6022169589996338, 0.602398693561554, 0.602398693561554, 0.5993094444274902, 0.5849536657333374, 0.6071233749389648, 0.5944030284881592, 0.6160275936126709, 0.6038524508476257, 0.6091222763061523, 0.6005815267562866, 0.6176630854606628, 0.6011266708374023, 0.6080319881439209, 0.6098491549491882, 0.6087588667869568, 0.6103943586349487, 0.6085771322250366, 0.6149373054504395, 0.602398693561554, 0.6114846467971802, 0.6105760335922241, 0.6114846467971802, 0.6180265545845032, 0.6091222763061523, 0.6071233749389648, 0.6118480563163757, 0.6093040108680725, 0.6118480563163757, 0.6114846467971802, 0.6133018136024475, 0.6022169589996338, 0.6071233749389648, 0.6122115254402161, 0.6143921613693237, 0.607305109500885, 0.6022169589996338, 0.6065782308578491, 0.6123932600021362, 0.6047610640525818]\n",
+      "Validation loss: [0.9543005228042603, 0.9290327429771423, 0.923751711845398, 0.9051579833030701, 0.9416499733924866, 0.8916309475898743, 0.9210068583488464, 0.8938611745834351, 0.892157256603241, 0.884227454662323, 0.8868556618690491, 0.8826276063919067, 0.8990178108215332, 0.8920494914054871, 0.9054058194160461, 0.8761034607887268, 0.8945696949958801, 0.8777459263801575, 0.8780338764190674, 0.8745801448822021, 0.8890933394432068, 0.8758707046508789, 0.8782291412353516, 0.8778796195983887, 0.8769698739051819, 0.876804769039154, 0.8785808682441711, 0.8769375681877136, 0.8819142580032349, 0.8850362300872803, 0.875283420085907, 0.8760201334953308, 0.8818275332450867, 0.8770513534545898, 0.8773949146270752, 0.8893070220947266, 0.8844382166862488, 0.873744010925293, 0.887718677520752, 0.878305196762085, 0.8857846260070801, 0.9012156128883362, 0.8857085704803467, 0.9025408029556274, 0.8886783719062805, 0.8851827383041382, 0.9158708453178406, 0.8904455900192261, 0.8986608982086182, 0.8943082094192505]\n"
      ]
     }
    ],
    "source": [
-    "predictions = mlp.predict(X_test)\n",
-    "# predictions = mlp.predict(X_test)\n",
-    "accuracy = accuracy_score(y_test, predictions)\n",
-    "print(\"The accuracy of prediction is: \", accuracy)\n",
+    "# Sample tf/keras model\n",
+    "from tensorflow.keras.models import Sequential\n",
+    "from tensorflow.keras.layers import InputLayer, Dense, Dropout\n",
+    "from tensorflow.keras.optimizers import Adam\n",
+    "# from tensorflow.keras.callbacks import ReduceLROnPlateau, EarlyStopping\n",
     "\n",
-    "# find number of accurate predictions\n",
-    "accurate_predictions = accuracy_score(y_test, predictions, normalize=False)\n",
-    "print(\"The number of accurate predictions is: \", accurate_predictions)"
+    "# Could also add dropout 0.1 layers in between\n",
+    "model = Sequential()\n",
+    "model.add(InputLayer(input_shape=(X_train.shape[1],)))\n",
+    "model.add(Dense(50, activation=\"relu\"))\n",
+    "model.add(Dense(100, activation=\"relu\"))\n",
+    "model.add(Dense(100, activation=\"relu\"))\n",
+    "model.add(Dense(50, activation=\"relu\"))\n",
+    "model.add(Dense(5, activation=\"softmax\"))\n",
+    "\n",
+    "model.compile(optimizer=Adam(learning_rate=0.001), loss='categorical_crossentropy', metrics=['accuracy'])\n",
+    "# Potentially add for preventing overfit\n",
+    "# reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.2, patience=1, min_lr=0.0001)\n",
+    "# early_stop = EarlyStopping(monitor='val_loss', min_delta=0, patience=2, verbose=0, mode='auto')\n",
+    "\n",
+    "history = model.fit(X_train, y_train, epochs=50, validation_data=(X_test, y_test)) #callbacks=[reduce_lr, early_stop]\n",
+    "\n",
+    "print(\"Training accuracy:\", history.history['accuracy'])\n",
+    "print(\"Training loss:\", history.history['loss'])\n",
+    "print(\"Validation accuracy:\", history.history['val_accuracy'])\n",
+    "print(\"Validation loss:\", history.history['val_loss'])"
    ]
   }
  ],
@@ -557,7 +746,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.11"
+   "version": "3.11.3"
   }
  },
  "nbformat": 4,