nueral_net.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "requested-christianity",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import sklearn\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.model_selection import train_test_split, StratifiedKFold, cross_val_score, learning_curve, ShuffleSplit, validation_curve\n",
    "from sklearn.metrics import plot_confusion_matrix\n",
    "import numpy as np\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.svm import SVC\n",
    "from imblearn.pipeline import Pipeline\n",
    "from category_encoders.one_hot import OneHotEncoder\n",
    "from sklearn.impute import SimpleImputer\n",
    "from imblearn.over_sampling import RandomOverSampler, SMOTE\n",
    "from mlxtend.evaluate import bias_variance_decomp\n",
    "from mlxtend.plotting import plot_decision_regions\n",
    "from sklearn.metrics import classification_report\n",
    "from imblearn.under_sampling import RandomUnderSampler\n",
    "\n",
    "from sklearn.datasets import make_classification\n",
    "from sklearn.model_selection import RepeatedStratifiedKFold\n",
    "from sklearn.model_selection import GridSearchCV ,cross_validate\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn import tree\n",
    "from sklearn.preprocessing import StandardScaler, MinMaxScaler\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.metrics import average_precision_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "cellular-sleep",
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_learn_curve(title=\"some title\", \n",
    "                   estimator=None, \n",
    "                   cv = None ,\n",
    "                   X=None,\n",
    "                   y=None,\n",
    "                   label_suffix =  None,\n",
    "                   color_= [],\n",
    "                   shape='o-'):\n",
    "    plt.title(title)\n",
    "    plt.ylim(0.0, 1.01)\n",
    "    plt.xlabel(\"Training examples\")\n",
    "    plt.ylabel(\"Score\")\n",
    "\n",
    "    train_sizes, train_scores, test_scores, fit_times, _ = \\\n",
    "        learning_curve(estimator, X, y, cv=cv, n_jobs=4,\n",
    "                       train_sizes=np.linspace(.1, 1.0, 10),\n",
    "                       return_times=True)\n",
    "    train_scores_mean =  1.0 - np.mean(train_scores, axis=1)\n",
    "    train_scores_std = np.std(train_scores, axis=1)\n",
    "    test_scores_mean =  1.0 - np.mean(test_scores, axis=1)\n",
    "    test_scores_std = np.std(test_scores, axis=1)\n",
    "    fit_times_mean = np.mean(fit_times, axis=1)\n",
    "    fit_times_std = np.std(fit_times, axis=1)\n",
    "\n",
    "\n",
    "    # Plot learning curve\n",
    "    plt.grid()\n",
    "    plt.fill_between(train_sizes,  train_scores_mean - train_scores_std,\n",
    "                         train_scores_mean + train_scores_std, alpha=0.1,\n",
    "                         color=\"r\")\n",
    "    plt.fill_between(train_sizes,  test_scores_mean - test_scores_std,\n",
    "                         test_scores_mean + test_scores_std, alpha=0.1,\n",
    "                         color=\"g\")\n",
    "    plt.plot(train_sizes, train_scores_mean, shape, color=color_[0],\n",
    "                 label=\"Training Error - {}\".format(label_suffix))\n",
    "    plt.plot(train_sizes, test_scores_mean,shape, color=color_[1],\n",
    "                 label=\"Cross-validation Error - {}\".format(label_suffix))\n",
    "    plt.legend(loc=\"best\")\n",
    "    plt.ylabel(\"Error\")\n",
    "    return plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "arctic-conclusion",
   "metadata": {},
   "outputs": [],
   "source": [
    "parent_dir = '/mnt/c/users/17752/Documents/GeorgiaTech/machine_learning'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "marine-income",
   "metadata": {},
   "source": [
    "# Liver Data "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "christian-electricity",
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "prospective-latter",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "liver_df = pd.read_csv(f\"{parent_dir}/data/liver.csv\")\n",
    "liver_df = pd.read_csv(f\"{parent_dir}/data/liver.csv\")\n",
    "liver_df.drop_duplicates(inplace=True)\n",
    "impute_Albumin_and_Globulin_Ratio = liver_df[~liver_df.Albumin_and_Globulin_Ratio.isna()].Albumin_and_Globulin_Ratio.mean()\n",
    "filt_ =  liver_df.Albumin_and_Globulin_Ratio.isna()\n",
    "liver_df.loc[filt_, \"Albumin_and_Globulin_Ratio\" ]= impute_Albumin_and_Globulin_Ratio\n",
    "assert sum(liver_df.Albumin_and_Globulin_Ratio.isna()) == 0 \n",
    "# format response \n",
    "liver_df.loc[(liver_df.Dataset ==2), \"Dataset\" ] = 0\n",
    "liver_df.head(10)\n",
    "liver_df.loc[:,\"Gender\"] = pd.get_dummies(liver_df.Gender, prefix='gender').drop(\"gender_Male\", axis =1  ).gender_Female\n",
    "X = liver_df.loc[:, \"Age\":\"Albumin_and_Globulin_Ratio\"]\n",
    "y = liver_df[\"Dataset\"]\n",
    "\n",
    "# get validation \n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1)\n",
    "\n",
    "\n",
    "#('over', SMOTE(sampling_strategy=\"minority\")\n",
    "#inital shot \n",
    "def get_liver_pipeline(iter_=1):\n",
    "    liver_steps = [('scaler', MinMaxScaler()),\n",
    "                   (\"model\",   MLPClassifier( max_iter=iter_ , solver =\"adam\", momentum=False\n",
    "                                             ))]\n",
    "\n",
    "    return Pipeline(steps=liver_steps)\n",
    "\n",
    "stratified_kfold = StratifiedKFold(n_splits = 5, random_state=42, shuffle=True)\n",
    "val_train_scores = []\n",
    "for i in range (1,100,1):\n",
    "    scores = cross_validate(get_liver_pipeline(i), X_train, y_train, cv=stratified_kfold,\n",
    "                   scoring=('accuracy'),\n",
    "                    return_train_score=True)\n",
    "    val = 1. - scores['test_score'].mean()\n",
    "    training = 1. - scores['train_score'].mean()\n",
    "    epoch = i\n",
    "    val_train_scores.append([training,val,epoch])\n",
    "    \n",
    "pd_val = pd.DataFrame(val_train_scores, columns=[\"Training\", \"Cross_Validation\",\"epoch\"])\n",
    "val_plot =pd_val.plot(y=[\"Training\", \"Cross_Validation\"],x=\"epoch\", title=\"MLP Learning Curve-SGD No Monentum\" )\n",
    "plt.ylim(0.0, 1.01)\n",
    "plt.ylabel('Error')\n",
    "plt.xlabel('Epoch')\n",
    "   \n",
    "    \n",
    "#adaptive moment estimation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "hungarian-robin",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "my_learn_curve(title=\" MLP \", \n",
    "               estimator=get_liver_pipeline(400), \n",
    "               cv=stratified_kfold, \n",
    "               X=X_train,\n",
    "               y=y_train,\n",
    "               label_suffix=\"Base MLP\", \n",
    "               color_=[\"red\",\"green\"],\n",
    "               shape = 'o-'  )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "developed-computer",
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_confusion_matrix(estimator= get_liver_pipeline(400).fit(X_train,y_train), X=X_test, y_true= y_test  , \n",
    "                      cmap=plt.cm.Blues,\n",
    "                       normalize=\"true\",\n",
    "                      display_labels = [\"Not Patient\" ,\"Patient\"]\n",
    "                        )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "loving-shirt",
   "metadata": {},
   "source": [
    "## Validation Curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "robust-freedom",
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bored-conclusion",
   "metadata": {},
   "outputs": [],
   "source": [
    "# cv = ShuffleSplit(n_splits=10, test_size=0.1, random_state=0)\n",
    "cv = RepeatedStratifiedKFold(n_splits=5, n_repeats=1, random_state=45)\n",
    "train_scores, valid_scores = validation_curve(get_liver_pipeline(50),\n",
    "                                              X_train,\n",
    "                                              y_train, \n",
    "                                              param_name =  \"model__max_iter\",\n",
    "                                            param_range =[ i for i in range (1,600,40)] ,\n",
    "                                            cv=cv)\n",
    "\n",
    "param_range =   np.array([ i for i in range (1,600,40)] )\n",
    "train_scores_mean =  np.mean(train_scores, axis=1)\n",
    "train_scores_std = np.std(train_scores, axis=1)\n",
    "test_scores_mean = np.mean(valid_scores, axis=1)\n",
    "test_scores_std = np.std(valid_scores, axis=1)\n",
    "\n",
    "plt.title(\"Complexity Curve\")\n",
    "plt.xlabel(\"Training Iterations\")\n",
    "plt.ylabel(\"Score\")\n",
    "plt.ylim(0.0, 1.1)\n",
    "lw = 2\n",
    "# semilogx\n",
    "plt.plot(param_range, train_scores_mean, label=\"Training score\",\n",
    "             color=\"darkorange\", lw=lw)\n",
    "\n",
    "plt.fill_between(param_range, train_scores_mean - train_scores_std,\n",
    "                 train_scores_mean + train_scores_std, alpha=0.2,\n",
    "                 color=\"darkorange\", lw=lw)\n",
    "plt.plot(param_range, test_scores_mean, label=\"Cross-validation score\",\n",
    "             color=\"navy\", lw=lw)\n",
    "plt.fill_between(param_range, test_scores_mean - test_scores_std,\n",
    "                 test_scores_mean + test_scores_std, alpha=0.2,\n",
    "                 color=\"navy\", lw=lw)\n",
    "plt.legend(loc=\"best\")\n",
    "\n",
    "\n",
    "plt.savefig(\"MLP_LIVER_MAX_ITER.pdf\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "starting-power",
   "metadata": {},
   "outputs": [],
   "source": [
    "# cv = ShuffleSplit(n_splits=10, test_size=0.1, random_state=0)\n",
    "cv = RepeatedStratifiedKFold(n_splits=5, n_repeats=1, random_state=45)\n",
    "train_scores, valid_scores = validation_curve(get_liver_pipeline(400),\n",
    "                                              X_train,\n",
    "                                              y_train, \n",
    "                                              param_name =  \"model__alpha\",\n",
    "                                            param_range =np.linspace(0.0001,1.,10) ,\n",
    "                                            cv=cv)\n",
    "\n",
    "param_range =   np.linspace(0.0001,2.,10)\n",
    "train_scores_mean =  np.mean(train_scores, axis=1)\n",
    "train_scores_std = np.std(train_scores, axis=1)\n",
    "test_scores_mean = np.mean(valid_scores, axis=1)\n",
    "test_scores_std = np.std(valid_scores, axis=1)\n",
    "\n",
    "plt.title(\"Complexity Curve MLP\")\n",
    "plt.xlabel(\"Alpha\")\n",
    "plt.ylabel(\"Score\")\n",
    "plt.ylim(0.0, 1.1)\n",
    "lw = 2\n",
    "# semilogx\n",
    "plt.plot(param_range, train_scores_mean, label=\"Training score\",\n",
    "             color=\"darkorange\", lw=lw)\n",
    "\n",
    "plt.fill_between(param_range, train_scores_mean - train_scores_std,\n",
    "                 train_scores_mean + train_scores_std, alpha=0.2,\n",
    "                 color=\"darkorange\", lw=lw)\n",
    "plt.plot(param_range, test_scores_mean, label=\"Cross-validation score\",\n",
    "             color=\"navy\", lw=lw)\n",
    "plt.fill_between(param_range, test_scores_mean - test_scores_std,\n",
    "                 test_scores_mean + test_scores_std, alpha=0.2,\n",
    "                 color=\"navy\", lw=lw)\n",
    "plt.legend(loc=\"best\")\n",
    "\n",
    "\n",
    "plt.savefig(\"MLP_LIVER_alpha_adam.pdf\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "streaming-homework",
   "metadata": {},
   "outputs": [],
   "source": [
    "MLPClassifier?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "acceptable-collapse",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'get_liver_pipeline' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-4-5cd4630aafe0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mget_liver_pipeline\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m50\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_params\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'get_liver_pipeline' is not defined"
     ]
    }
   ],
   "source": [
    "get_liver_pipeline(50).get_params()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "happy-shelf",
   "metadata": {},
   "source": [
    "## Grid Search Liver "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "prospective-premiere",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set the parameters by cross-validation\n",
    "\n",
    "\n",
    "\n",
    "tuned_parameters = {'model__activation': [\"logistic\",\"tanh\",\"relu\"], \n",
    "                    'model__alpha': np.linspace(0.0001,.5,15),\n",
    "                    \"model__solver\" : [\"sgd\",\"adam\",\"lbfgs\"],\n",
    "                    \"model__learning_rate\": [\"constant\", \"invscaling\"] ,\n",
    "                     \"model__max_iter\" : [ i for i in range(10,400,20)]}\n",
    "                    \n",
    "\n",
    "\n",
    "# define the evaluation procedure\n",
    "cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=2, random_state=45)\n",
    "# define the grid search procedure\n",
    "grid_search = GridSearchCV(estimator=get_liver_pipeline(1), param_grid=tuned_parameters, \n",
    "                           n_jobs=-1, cv=cv, \n",
    "                           scoring='average_precision')\n",
    "# execute the grid search\n",
    "grid_result_l = grid_search.fit(X_train, y_train)\n",
    "# summarize the best score and configuration\n",
    "print(\"Best: %f usin g %s\" % (grid_result_l.best_score_, grid_result_l.best_params_))\n",
    "# summarize all scores that were evaluated\n",
    "means = grid_result_l.cv_results_['mean_test_score']\n",
    "stds = grid_result_l.cv_results_['std_test_score']\n",
    "params = grid_result_l.cv_results_['params']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "random-registrar",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Best: 0.906910 usin g {'model__activation': 'logistic', 'model__alpha': 0.035807142857142864, 'model__learning_rate': 'invscaling', 'model__max_iter': 70, 'model__solver': 'lbfgs'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "stopped-amazon",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_liver_pipeline_final(iter_=70,):\n",
    "    liver_steps = [('scaler', MinMaxScaler()),\n",
    "                   (\"model\",   MLPClassifier( max_iter=iter_ ,\n",
    "                                             solver =\"lbfgs\",\n",
    "                                             learning_rate = \"invscaling\",\n",
    "                                             activation=\"logistic\",\n",
    "                                             alpha= 0.035807142857142864, \n",
    "                                             random_state = 12, \n",
    "                                             early_stopping=True\n",
    "                                             \n",
    "                                             ))]\n",
    "\n",
    "    return Pipeline(steps=liver_steps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "divine-thread",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'get_liver_pipeline_final' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-6-ffc9e7b9b7cb>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m my_learn_curve(title=\" Support Vector Machine\", \n\u001b[0;32m----> 2\u001b[0;31m                \u001b[0mestimator\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mget_liver_pipeline_final\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msolver_\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"sgd\"\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m                \u001b[0mcv\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mstratified_kfold\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m                \u001b[0mX\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m                \u001b[0my\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0my_train\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'get_liver_pipeline_final' is not defined"
     ]
    }
   ],
   "source": [
    "\n",
    "my_learn_curve(title=\" Support Vector Machine\", \n",
    "               estimator=get_liver_pipeline_final(solver_=\"adam\" ), \n",
    "               cv=stratified_kfold, \n",
    "               X=X_train,\n",
    "               y=y_train,\n",
    "               label_suffix=\"best-rbf\", \n",
    "               color_=[\"red\",\"green\"],\n",
    "               shape = 'o-'  )\n",
    "\n",
    "# my_learn_curve(title=\" Support Vector Machine\", \n",
    "#                estimator=liver_pipeline_linear.fit(X_train,y_train), \n",
    "#                cv=stratified_kfold,\n",
    "#                X=X_train,\n",
    "#                y=y_train ,\n",
    "#                label_suffix=\"rbf\", \n",
    "#                color_=[\"orange\",\"blue\"], shape = 'x-' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "grand-framework",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'memory': None,\n",
       " 'steps': [('scaler', MinMaxScaler()),\n",
       "  ('model',\n",
       "   MLPClassifier(activation='logistic', alpha=0.035807142857142864,\n",
       "                 early_stopping=True, learning_rate='invscaling', max_iter=70,\n",
       "                 random_state=12, solver='lbfgs'))],\n",
       " 'verbose': False,\n",
       " 'scaler': MinMaxScaler(),\n",
       " 'model': MLPClassifier(activation='logistic', alpha=0.035807142857142864,\n",
       "               early_stopping=True, learning_rate='invscaling', max_iter=70,\n",
       "               random_state=12, solver='lbfgs'),\n",
       " 'scaler__copy': True,\n",
       " 'scaler__feature_range': (0, 1),\n",
       " 'model__activation': 'logistic',\n",
       " 'model__alpha': 0.035807142857142864,\n",
       " 'model__batch_size': 'auto',\n",
       " 'model__beta_1': 0.9,\n",
       " 'model__beta_2': 0.999,\n",
       " 'model__early_stopping': True,\n",
       " 'model__epsilon': 1e-08,\n",
       " 'model__hidden_layer_sizes': (100,),\n",
       " 'model__learning_rate': 'invscaling',\n",
       " 'model__learning_rate_init': 0.001,\n",
       " 'model__max_fun': 15000,\n",
       " 'model__max_iter': 70,\n",
       " 'model__momentum': 0.9,\n",
       " 'model__n_iter_no_change': 10,\n",
       " 'model__nesterovs_momentum': True,\n",
       " 'model__power_t': 0.5,\n",
       " 'model__random_state': 12,\n",
       " 'model__shuffle': True,\n",
       " 'model__solver': 'lbfgs',\n",
       " 'model__tol': 0.0001,\n",
       " 'model__validation_fraction': 0.1,\n",
       " 'model__verbose': False,\n",
       " 'model__warm_start': False}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_liver_pipeline_final().get_params()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "furnished-masters",
   "metadata": {},
   "outputs": [],
   "source": [
    "stratified_kfold = StratifiedKFold(n_splits = 10, random_state=42, shuffle=True)\n",
    "val_train_scores = []\n",
    "for i in range (1,80,5):\n",
    "    scores = cross_validate(get_liver_pipeline_final(i), X_train, y_train, cv=stratified_kfold,\n",
    "                   scoring=('accuracy'),\n",
    "                    return_train_score=True)\n",
    "    val = 1. - scores['test_score'].mean()\n",
    "    training = 1. - scores['train_score'].mean()\n",
    "    epoch = i\n",
    "    val_train_scores.append([training,val,epoch])\n",
    "    \n",
    "pd_val = pd.DataFrame(val_train_scores, columns=[\"Training\", \"Cross_Validation\",\"epoch\"])\n",
    "val_plot =pd_val.plot(y=[\"Training\", \"Cross_Validation\"],x=\"epoch\", title=\"MLP Learning Curve-LBFGS\" )\n",
    "plt.ylim(0.0, 1.1)\n",
    "plt.ylabel('Error')\n",
    "plt.xlabel('Epoch')\n",
    "plt.savefig(\"MLP_FINAL_LIVER_LEARNING_CURVE.pdf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "transsexual-freeze",
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_confusion_matrix(estimator= get_liver_pipeline_final( ).fit(X_train,y_train), X=X_test, y_true= y_test  , \n",
    "                      cmap=plt.cm.Blues,\n",
    "                       normalize=\"true\",\n",
    "                      display_labels = [\"Not Patient\" ,\"Patient\"]\n",
    "                        )\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "european-separate",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_liver_pipeline_base():\n",
    "    liver_steps = [('scaler', MinMaxScaler()),\n",
    "                   (\"model\",   MLPClassifier(\n",
    "                                             solver =\"sgd\",\n",
    "                                             activation=\"logistic\",\n",
    "                                             random_state = 12\n",
    "                                             ))]\n",
    "\n",
    "    return Pipeline(steps=liver_steps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "sound-regulation",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7117181488738253"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "trained-windsor",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7117181488738253\n",
      "0.910525480393755\n",
      "0.8744202551854581\n"
     ]
    }
   ],
   "source": [
    "base = get_liver_pipeline_base()\n",
    "print(average_precision_score(y_train, base.fit(X_train,y_train).predict_proba(X_train)[:,1]))\n",
    "print(average_precision_score(y_train, final_liver.predict_proba(X_train)[:,1]))\n",
    "print(average_precision_score(y_test, final_liver.predict_proba(X_test)[:,1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "still-blind",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8744202551854581"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "solar-helen",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'memory': None, 'steps': [('scaler', MinMaxScaler()), ('model', MLPClassifier(activation='logistic', alpha=0.035807142857142864,\n",
      "              early_stopping=True, learning_rate='invscaling', max_iter=70,\n",
      "              random_state=12, solver='lbfgs'))], 'verbose': False, 'scaler': MinMaxScaler(), 'model': MLPClassifier(activation='logistic', alpha=0.035807142857142864,\n",
      "              early_stopping=True, learning_rate='invscaling', max_iter=70,\n",
      "              random_state=12, solver='lbfgs'), 'scaler__copy': True, 'scaler__feature_range': (0, 1), 'model__activation': 'logistic', 'model__alpha': 0.035807142857142864, 'model__batch_size': 'auto', 'model__beta_1': 0.9, 'model__beta_2': 0.999, 'model__early_stopping': True, 'model__epsilon': 1e-08, 'model__hidden_layer_sizes': (100,), 'model__learning_rate': 'invscaling', 'model__learning_rate_init': 0.001, 'model__max_fun': 15000, 'model__max_iter': 70, 'model__momentum': 0.9, 'model__n_iter_no_change': 10, 'model__nesterovs_momentum': True, 'model__power_t': 0.5, 'model__random_state': 12, 'model__shuffle': True, 'model__solver': 'lbfgs', 'model__tol': 0.0001, 'model__validation_fraction': 0.1, 'model__verbose': False, 'model__warm_start': False}\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.55      0.29      0.38       131\n",
      "           1       0.76      0.90      0.83       325\n",
      "\n",
      "    accuracy                           0.73       456\n",
      "   macro avg       0.66      0.60      0.60       456\n",
      "weighted avg       0.70      0.73      0.70       456\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.71      0.36      0.48        33\n",
      "           1       0.78      0.94      0.85        81\n",
      "\n",
      "    accuracy                           0.77       114\n",
      "   macro avg       0.74      0.65      0.67       114\n",
      "weighted avg       0.76      0.77      0.75       114\n",
      "\n"
     ]
    }
   ],
   "source": [
    "final_liver = get_liver_pipeline_final().fit(X_train,y_train)\n",
    "print(final_liver.get_params())\n",
    "print(classification_report(y_train, final_liver.predict(X_train) ))\n",
    "print(classification_report(y_test, final_liver.predict(X_test) ))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "loose-sixth",
   "metadata": {},
   "source": [
    "## Census Data "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "regional-finding",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data shape is (26029, 15)\n",
      "Test data shape is (6508, 15)\n"
     ]
    }
   ],
   "source": [
    "census_df = pd.read_csv(f\"{parent_dir}/data/adult.csv\")\n",
    "census_df.drop_duplicates(inplace=True)\n",
    "# # Deleting duplicates \n",
    "census_df.duplicated().sum()\n",
    "#Replacing '?' for nans\n",
    "census_df = census_df.replace('?', np.NaN)\n",
    "# Mapping already our target variable in  1 and 0.\n",
    "census_df.income = census_df.income.map({'<=50K':0, '>50K':1})\n",
    "\n",
    "train_data, test_data = train_test_split(census_df,\n",
    "                                         test_size=0.2,\n",
    "                                         stratify=census_df['income'],\n",
    "                                         random_state=65)\n",
    "print('Train data shape is {}'.format(train_data.shape))\n",
    "print('Test data shape is {}'.format(test_data.shape))\n",
    "X_c_train = train_data.drop('income', axis=1)\n",
    "y_c_train = train_data['income']\n",
    "X_c_test= test_data.drop('income', axis=1)\n",
    "y_c_test= test_data['income']\n",
    "\n",
    "#Transforming categorical columns\n",
    "categorical_columns= X_c_train.select_dtypes(object).columns\n",
    "\n",
    "\n",
    "\n",
    "def get_census_pipeline(iter_=1):\n",
    "    liver_steps = [('encoding', OneHotEncoder(cols=categorical_columns)),\n",
    "         ('imputer',SimpleImputer(missing_values=np.NaN, strategy='most_frequent')),\n",
    "         ('scaler', StandardScaler()),\n",
    "                   (\"model\",   MLPClassifier( max_iter=iter_ , solver =\"adam\"\n",
    "                                             ))]\n",
    "    return Pipeline(steps=liver_steps)\n",
    "\n",
    "\n",
    "\n",
    "stratified_kfold = StratifiedKFold(n_splits = 5, random_state=42, shuffle=True)\n",
    "val_train_scores = []\n",
    "for i in range (1,200,25):\n",
    "    scores = cross_validate(get_census_pipeline(i), X_c_train, y_c_train, cv=stratified_kfold,\n",
    "                   scoring=('accuracy'),\n",
    "                    return_train_score=True)\n",
    "    val = 1. - scores['test_score'].mean()\n",
    "    training = 1. - scores['train_score'].mean()\n",
    "    epoch = i\n",
    "    val_train_scores.append([training,val,epoch])\n",
    "    \n",
    "pd_val = pd.DataFrame(val_train_scores, columns=[\"Training\", \"Cross_Validation\",\"epoch\"])\n",
    "val_plot =pd_val.plot(y=[\"Training\", \"Cross_Validation\"],x=\"epoch\", title=\"MLP Learning Curve-SGD No Monentum\" )\n",
    "plt.ylim(0.0, 1.01)\n",
    "plt.ylabel('Error')\n",
    "plt.xlabel('Epoch')\n",
    "plt.savefig(\"MLP_BASE_CENSUS_LEARNING_CURVE_SGD.pdf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "alive-volunteer",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_census_pipeline(iter_=1):\n",
    "    liver_steps = [('encoding', OneHotEncoder(cols=categorical_columns)),\n",
    "         ('imputer',SimpleImputer(missing_values=np.NaN, strategy='most_frequent')),\n",
    "         ('scaler', StandardScaler()),\n",
    "                   (\"model\",   MLPClassifier( max_iter=iter_ , solver =\"adam\"\n",
    "                                             ))]\n",
    "    return Pipeline(steps=liver_steps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "supposed-contamination",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<module 'matplotlib.pyplot' from '/home/flufylobster/anaconda3/envs/ML39/lib/python3.9/site-packages/matplotlib/pyplot.py'>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "my_learn_curve(title=\" Support Vector Machine\", \n",
    "               estimator=get_census_pipeline(50), \n",
    "               cv=stratified_kfold,\n",
    "               X=X_c_train, \n",
    "               y=y_c_train,  \n",
    "               label_suffix=\"linear\", \n",
    "               color_=[\"orange\",\"blue\"],\n",
    "               shape = 'o-'  )\n",
    "\n",
    "\n",
    "# my_learn_curve(title=\" Support Vector Machine\", \n",
    "#                estimator=census_pipeline_rbf, \n",
    "#                cv=stratified_kfold,\n",
    "#                X=X_c_train, \n",
    "#                y=y_c_train,  \n",
    "#                label_suffix=\"rbf\", \n",
    "#                color_=[\"orange\",\"blue\"],\n",
    "#                shape = 'x-'  )\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "expressed-acoustic",
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_confusion_matrix(estimator= census_pipeline_rbf.fit(X_c_train,y_c_train),\n",
    "                      X=X_c_train,\n",
    "                      y_true= y_c_train  , \n",
    "                      cmap=plt.cm.Blues,\n",
    "                       normalize=\"true\",\n",
    "                      display_labels = [\"Not Patient\" ,\"Patient\"]\n",
    "                        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "silent-capture",
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_confusion_matrix(estimator= census_pipeline_linear.fit(X_c_train,y_c_train),\n",
    "                      X=X_c_train,\n",
    "                      y_true= y_c_train  , \n",
    "                      cmap=plt.cm.Blues,\n",
    "                       normalize=\"true\",\n",
    "                      display_labels = [\"Not Patient\" ,\"Patient\"]\n",
    "                        )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "agreed-wholesale",
   "metadata": {},
   "source": [
    "## Complexity \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "swiss-solid",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# cv = ShuffleSplit(n_splits=10, test_size=0.1, random_state=0)\n",
    "cv = RepeatedStratifiedKFold(n_splits=5, n_repeats=1, random_state=45)\n",
    "train_scores, valid_scores = validation_curve(get_census_pipeline(1),\n",
    "                                              X_c_train,\n",
    "                                              y_c_train, \n",
    "                                              param_name =  \"model__max_iter\",\n",
    "                                            param_range =[ i for i in range (1,50,5)] ,\n",
    "                                            cv=cv)\n",
    "\n",
    "param_range =   np.array([ i for i in range (1,50,5)])\n",
    "train_scores_mean =  np.mean(train_scores, axis=1)\n",
    "train_scores_std = np.std(train_scores, axis=1)\n",
    "test_scores_mean = np.mean(valid_scores, axis=1)\n",
    "test_scores_std = np.std(valid_scores, axis=1)\n",
    "\n",
    "plt.title(\"Complexity Curve\")\n",
    "plt.xlabel(\"Training Iterations\")\n",
    "plt.ylabel(\"Score\")\n",
    "plt.ylim(0.0, 1.1)\n",
    "lw = 2\n",
    "# semilogx\n",
    "plt.plot(param_range, train_scores_mean, label=\"Training score\",\n",
    "             color=\"darkorange\", lw=lw)\n",
    "\n",
    "plt.fill_between(param_range, train_scores_mean - train_scores_std,\n",
    "                 train_scores_mean + train_scores_std, alpha=0.2,\n",
    "                 color=\"darkorange\", lw=lw)\n",
    "plt.plot(param_range, test_scores_mean, label=\"Cross-validation score\",\n",
    "             color=\"navy\", lw=lw)\n",
    "plt.fill_between(param_range, test_scores_mean - test_scores_std,\n",
    "                 test_scores_mean + test_scores_std, alpha=0.2,\n",
    "                 color=\"navy\", lw=lw)\n",
    "plt.legend(loc=\"best\")\n",
    "plt.savefig(\"MLP_CENSUS_MAX_ITER.pdf\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "minor-economics",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "labeled-rainbow",
   "metadata": {},
   "outputs": [],
   "source": [
    "# cv = ShuffleSplit(n_splits=10, test_size=0.1, random_state=0)\n",
    "cv = RepeatedStratifiedKFold(n_splits=5, n_repeats=1, random_state=45)\n",
    "train_scores, valid_scores = validation_curve(census_pipeline_rbf,\n",
    "                                              X_c_train,\n",
    "                                              y_c_train, \n",
    "                                              param_name =  \"model__gamma\",\n",
    "                                            param_range = np.linspace(1e-3,1.,5),\n",
    "                                            cv=cv)\n",
    "\n",
    "param_range =  np.linspace(1e-3,1.,5)\n",
    "\n",
    "train_scores_mean =  np.mean(train_scores, axis=1)\n",
    "train_scores_std = np.std(train_scores, axis=1)\n",
    "test_scores_mean = np.mean(valid_scores, axis=1)\n",
    "test_scores_std = np.std(valid_scores, axis=1)\n",
    "\n",
    "\n",
    "plt.title(\"Complexity Curve SVM \")\n",
    "plt.xlabel(\"Gamma Values\")\n",
    "plt.ylabel(\"Score\")\n",
    "plt.ylim(0.0, 1.1)\n",
    "lw = 2\n",
    "# semilogx\n",
    "plt.semilogx(param_range, train_scores_mean, label=\"Training score\",\n",
    "             color=\"darkorange\", lw=lw)\n",
    "\n",
    "plt.fill_between(param_range, train_scores_mean - train_scores_std,\n",
    "                 train_scores_mean + train_scores_std, alpha=0.2,\n",
    "                 color=\"darkorange\", lw=lw)\n",
    "plt.semilogx(param_range, test_scores_mean, label=\"Cross-validation score\",\n",
    "             color=\"navy\", lw=lw)\n",
    "plt.fill_between(param_range, test_scores_mean - test_scores_std,\n",
    "                 test_scores_mean + test_scores_std, alpha=0.2,\n",
    "                 color=\"navy\", lw=lw)\n",
    "plt.legend(loc=\"best\")\n",
    "\n",
    "\n",
    "plt.savefig(\"complexity_svc_gamma.pdf\")\n",
    "\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bottom-sample",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "handled-forty",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best: 0.773440 usin g {'model__activation': 'relu', 'model__alpha': 0.42858571428571435, 'model__learning_rate': 'invscaling', 'model__max_iter': 19, 'model__solver': 'adam'}\n"
     ]
    }
   ],
   "source": [
    "# Set the parameters by cross-validation\n",
    "\n",
    "\n",
    "\n",
    "tuned_parameters = {'model__activation': [\"logistic\",\"tanh\",\"relu\"], \n",
    "                    'model__alpha': np.linspace(0.0001,.5,15),\n",
    "                    \"model__solver\" : [\"sgd\",\"adam\",\"lbfgs\"],\n",
    "                    \"model__learning_rate\": [\"constant\", \"invscaling\"] ,\n",
    "                     \"model__max_iter\" : [ i for i in range(1,20,2)]}\n",
    "                    \n",
    "\n",
    "\n",
    "# define the evaluation procedure\n",
    "cv = RepeatedStratifiedKFold(n_splits=5, n_repeats=1, random_state=45)\n",
    "# define the grid search procedure\n",
    "grid_search = GridSearchCV(estimator=get_census_pipeline(1), param_grid=tuned_parameters, \n",
    "                           n_jobs=-1, cv=cv, \n",
    "                           scoring='average_precision')\n",
    "# execute the grid search\n",
    "grid_result_l = grid_search.fit(X_c_train, y_c_train)\n",
    "# summarize the best score and configuration\n",
    "print(\"Best: %f usin g %s\" % (grid_result_l.best_score_, grid_result_l.best_params_))\n",
    "# summarize all scores that were evaluated\n",
    "means = grid_result_l.cv_results_['mean_test_score']\n",
    "stds = grid_result_l.cv_results_['std_test_score']\n",
    "params = grid_result_l.cv_results_['params']\n",
    "# Best: 0.773440 usin g {'model__activation': 'relu', 'model__alpha': 0.42858571428571435, 'model__learning_rate': 'invscaling', 'model__max_iter': 19, 'model__solver': 'adam'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "enclosed-birmingham",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "spoken-screening",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_census_pipeline_final(iter_=19):\n",
    "    liver_steps = [('encoding', OneHotEncoder(cols=categorical_columns)),\n",
    "         ('imputer',SimpleImputer(missing_values=np.NaN, strategy='most_frequent')),\n",
    "         ('scaler', StandardScaler()),\n",
    "                   (\"model\",   MLPClassifier( max_iter=iter_ ,\n",
    "                                             solver =\"adam\",\n",
    "                                             activation=\"relu\",\n",
    "                                             alpha=0.42858571428571435,\n",
    "                                             learning_rate=\"invscaling\",\n",
    "                                             random_state = 12, \n",
    "                                             ))]\n",
    "    return Pipeline(steps=liver_steps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cellular-graham",
   "metadata": {},
   "outputs": [],
   "source": [
    "params = grid_result.cv_results_['params']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "compact-tobacco",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<module 'matplotlib.pyplot' from '/home/flufylobster/anaconda3/envs/ML39/lib/python3.9/site-packages/matplotlib/pyplot.py'>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "my_learn_curve(title=\" Support Vector Machine\", \n",
    "               estimator=get_census_pipeline_final(), \n",
    "               cv=stratified_kfold,\n",
    "               X=X_c_train, \n",
    "               y=y_c_train,  \n",
    "               label_suffix=\"rbf\", \n",
    "               color_=[\"orange\",\"blue\"],\n",
    "               shape = 'x-'  )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "affecting-accommodation",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_census_pipeline_base():\n",
    "    liver_steps = [('encoding', OneHotEncoder(cols=categorical_columns)),\n",
    "         ('imputer',SimpleImputer(missing_values=np.NaN, strategy='most_frequent')),\n",
    "         ('scaler', StandardScaler()),\n",
    "                   (\"model\",   MLPClassifier(solver = \"sgd\",\n",
    "                                             random_state = 12, \n",
    "                                             ))]\n",
    "    return Pipeline(steps=liver_steps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "generic-passage",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(grid_result.best_estimator_.get_params())\n",
    "print(classification_report(y_c_train, grid_result.best_estimator_.predict(X_c_train) ))\n",
    "print(classification_report(y_c_test, grid_result.best_estimator_.predict(X_c_test) ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "bored-jungle",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<sklearn.metrics._plot.confusion_matrix.ConfusionMatrixDisplay at 0x7ff6956fc310>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_confusion_matrix(estimator=  get_census_pipeline_final().fit(X_c_train, y_c_train),\n",
    "                      X=X_c_train,\n",
    "                      y_true= y_c_train  , \n",
    "                      cmap=plt.cm.Blues,\n",
    "                       normalize=\"true\",\n",
    "                      display_labels = [\"<$50k\" ,\"> $50k\"]\n",
    "                        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "thousand-hypothetical",
   "metadata": {},
   "outputs": [],
   "source": [
    "base_c?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "governing-making",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8145254254606573\n",
      "0.8096232693462557\n",
      "0.7755352405370302\n"
     ]
    }
   ],
   "source": [
    "base_c = get_census_pipeline_base()\n",
    "print(average_precision_score(y_c_train, base_c.fit(X_c_train,y_c_train).predict_proba(X_c_train)[:,1]))\n",
    "print(average_precision_score(y_c_train,get_census_pipeline_final().fit(X_c_train, y_c_train).predict_proba(X_c_train)[:,1]))\n",
    "print(average_precision_score(y_c_test,get_census_pipeline_final().fit(X_c_train, y_c_train).predict_proba(X_c_test)[:,1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "spectacular-trading",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.90      0.93      0.91     19758\n",
      "           1       0.76      0.66      0.71      6271\n",
      "\n",
      "    accuracy                           0.87     26029\n",
      "   macro avg       0.83      0.80      0.81     26029\n",
      "weighted avg       0.86      0.87      0.86     26029\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.89      0.92      0.91      4940\n",
      "           1       0.72      0.63      0.68      1568\n",
      "\n",
      "    accuracy                           0.85      6508\n",
      "   macro avg       0.81      0.78      0.79      6508\n",
      "weighted avg       0.85      0.85      0.85      6508\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#format test data\n",
    "X_c_test= test_data.drop('income', axis=1)\n",
    "y_c_test= test_data['income']\n",
    "print(classification_report(y_c_train, get_census_pipeline_final().fit(X_c_train, y_c_train).predict(X_c_train) ))\n",
    "print(classification_report(y_c_test, get_census_pipeline_final().fit(X_c_train, y_c_train).predict(X_c_test) ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "forward-memorabilia",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# stratified_kfold = StratifiedKFold(n_splits = 5, random_state=42, shuffle=True)\n",
    "# val_train_scores = []\n",
    "# for i in range (1,30,2):\n",
    "#     scores = cross_validate(get_census_pipeline_final(i), X_c_train, y_c_train, cv=stratified_kfold,\n",
    "#                    scoring=('accuracy'),\n",
    "#                     return_train_score=True)\n",
    "#     val = 1. - scores['test_score'].mean()\n",
    "#     training = 1. - scores['train_score'].mean()\n",
    "#     epoch = i\n",
    "#     val_train_scores.append([training,val,epoch])\n",
    "    \n",
    "pd_val = pd.DataFrame(val_train_scores, columns=[\"Training\", \"Cross_Validation\",\"epoch\"])\n",
    "val_plot =pd_val.plot(y=[\"Training\", \"Cross_Validation\"],x=\"epoch\", title=\"MLP Learning Curve Adam\" )\n",
    "plt.grid()\n",
    "plt.ylim(0.0, 1.01)\n",
    "plt.ylabel('Error')\n",
    "plt.xlabel('Epoch')\n",
    "plt.savefig(\"MLP_final_CENSUS_LEARNING_CURVE_adam.pdf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eleven-nepal",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}