Delete P2 - Secom Notebook - Mercury.ipynb

P2 - Secom Notebook - Mercury.ipynb

@@ -1,1553 +0,0 @@
-{
- "cells": [
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "source": [
-    "# **Classifying products in Semiconductor Industry**"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "source": [
-    "#### **Import the data**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# import pandas for data manipulation\n",
-    "# import numpy for numerical computation\n",
-    "# import seaborn for data visualization\n",
-    "# import matplotlib for data visualization\n",
-    "# import stats for statistical analysis\n",
-    "# import train_test_split for splitting data into training and testing sets\n",
-    "\n",
-    "\n",
-    "import pandas as pd\n",
-    "import numpy as np\n",
-    "import seaborn as sns\n",
-    "import matplotlib.pyplot as plt\n",
-    "from sklearn.model_selection import train_test_split\n",
-    "import mercury as mr"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "outputs": [
-    {
-     "data": {
-      "application/mercury+json": {
-       "allow_download": true,
-       "code_uid": "App.0.40.24.1-rand2c9ab9e7",
-       "continuous_update": false,
-       "description": "Recumpute everything dynamically",
-       "full_screen": true,
-       "model_id": "mercury-app",
-       "notify": "{}",
-       "output": "app",
-       "schedule": "",
-       "show_code": false,
-       "show_prompt": false,
-       "show_sidebar": true,
-       "static_notebook": false,
-       "title": "Secom Web App Demo",
-       "widget": "App"
-      },
-      "text/html": [
-       "<h3>Mercury Application</h3><small>This output won't appear in the web app.</small>"
-      ],
-      "text/plain": [
-       "mercury.App"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "app = mr.App(title=\"Secom Web App Demo\", description=\"Recumpute everything dynamically\", continuous_update=False)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "   \n",
-    "# Read the features data from the the url of csv into pandas dataframes and rename the columns to F1, F2, F3, etc.\n",
-    "# Read the labels data from the url of csv into pandas dataframes and rename the columns to pass/fail and date/time\n",
-    "\n",
-    "#url_data = 'https://archive.ics.uci.edu/ml/machine-learning-databases/secom/secom.data'\n",
-    "#url_labels = 'https://archive.ics.uci.edu/ml/machine-learning-databases/secom/secom_labels.data'\n",
-    "\n",
-    "url_data = 'secom_data.csv'\n",
-    "url_labels = 'secom_labels.csv'\n",
-    "\n",
-    "features = pd.read_csv(url_data,  delimiter=' ', header=None)\n",
-    "labels = pd.read_csv(url_labels,  delimiter=' ', names=['pass/fail', 'date_time'])\n",
-    "\n",
-    "prefix = 'F'\n",
-    "new_column_names = [prefix + str(i) for i in range(1, len(features.columns)+1)]\n",
-    "features.columns = new_column_names\n",
-    "\n",
-    "labels['pass/fail'] = labels['pass/fail'].replace({-1: 0, 1: 1})\n"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "source": [
-    "#### **Split the data**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Dropped date/time column from labels dataframe\n"
-     ]
-    }
-   ],
-   "source": [
-    "# if there is a date/time column, drop it from the features and labels dataframes, else continue\n",
-    "\n",
-    "if 'date_time' in labels.columns:\n",
-    "    labels = labels.drop(['date_time'], axis=1)\n",
-    "    print('Dropped date/time column from labels dataframe')\n",
-    "\n",
-    "\n",
-    "# Split the dataset and the labels into training and testing sets\n",
-    "# use stratify to ensure that the training and testing sets have the same percentage of pass and fail labels\n",
-    "# use random_state to ensure that the same random split is generated each time the code is run\n",
-    "\n",
-    "\n",
-    "X_train, X_test, y_train, y_test = train_test_split(features, labels, test_size=0.25, stratify=labels, random_state=13)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "source": [
-    "### **Functions**"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "source": [
-    "#### **Feature Removal**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "def columns_to_drop(df,drop_duplicates='yes', missing_values_threshold=100, variance_threshold=0, \n",
-    "                   correlation_threshold=1.1):\n",
-    "   \n",
-    "   print('Shape of the dataframe is: ', df.shape)\n",
-    "\n",
-    "    # Drop duplicated columns\n",
-    "   if drop_duplicates == 'yes':\n",
-    "      new_column_names = df.columns\n",
-    "      df = df.T.drop_duplicates().T\n",
-    "      print('the number of columns to be dropped due to duplications is: ', len(new_column_names) - len(df.columns))\n",
-    "      drop_duplicated = list(set(new_column_names) - set(df.columns))\n",
-    "\n",
-    "   elif drop_duplicates == 'no':\n",
-    "      df = df.T.T\n",
-    "      print('No columns were dropped due to duplications')   \n",
-    "\n",
-    "   # Print the percentage of columns in df with missing values more than or equal to threshold\n",
-    "   print('the number of columns to be dropped due to missing values is: ', len(df.isnull().mean()[df.isnull().mean() > missing_values_threshold/100].index))\n",
-    "      \n",
-    "   # Print into a list the columns to be dropped due to missing values\n",
-    "   drop_missing = list(df.isnull().mean()[df.isnull().mean() > missing_values_threshold/100].index)\n",
-    "\n",
-    "   # Drop columns with more than or equal to threshold missing values from df\n",
-    "   df.drop(drop_missing, axis=1, inplace=True)\n",
-    "    \n",
-    "   # Print the number of columns in df with variance less than threshold\n",
-    "   print('the number of columns to be dropped due to low variance is: ', len(df.var()[df.var() <= variance_threshold].index))\n",
-    "\n",
-    "   # Print into a list the columns to be dropped due to low variance\n",
-    "   drop_variance = list(df.var()[df.var() <= variance_threshold].index)\n",
-    "\n",
-    "   # Drop columns with more than or equal to threshold variance from df\n",
-    "   df.drop(drop_variance, axis=1, inplace=True)\n",
-    "\n",
-    "   # Print the number of columns in df with more than or equal to threshold correlation\n",
-    "      \n",
-    "   # Create correlation matrix and round it to 4 decimal places\n",
-    "   corr_matrix = df.corr().abs().round(4)\n",
-    "   upper = corr_matrix.where(np.triu(np.ones(corr_matrix.shape), k=1).astype(bool))\n",
-    "   to_drop = [column for column in upper.columns if any(upper[column] >= correlation_threshold)]\n",
-    "   print('the number of columns to be dropped due to high correlation is: ', len(to_drop))\n",
-    "\n",
-    "   # Print into a list the columns to be dropped due to high correlation\n",
-    "   drop_correlation = [column for column in upper.columns if any(upper[column] >= correlation_threshold)]\n",
-    "\n",
-    "   # Drop columns with more than or equal to threshold correlation from df\n",
-    "   df.drop(to_drop, axis=1, inplace=True)\n",
-    "   \n",
-    "   if drop_duplicates == 'yes':\n",
-    "      dropped = (drop_duplicated+drop_missing+drop_variance+drop_correlation)\n",
-    "\n",
-    "   elif drop_duplicates =='no':\n",
-    "      dropped = (drop_missing+drop_variance+drop_correlation)\n",
-    "   \n",
-    "   print('Total number of columns to be dropped is: ', len(dropped))\n",
-    "   print('New shape of the dataframe is: ', df.shape)\n",
-    "\n",
-    "   global drop_duplicates_var\n",
-    "   drop_duplicates_var = drop_duplicates\n",
-    "   \n",
-    "   global missing_values_threshold_var\n",
-    "   missing_values_threshold_var = missing_values_threshold\n",
-    "\n",
-    "   global variance_threshold_var\n",
-    "   variance_threshold_var = variance_threshold\n",
-    "\n",
-    "   global correlation_threshold_var\n",
-    "   correlation_threshold_var = correlation_threshold\n",
-    "   \n",
-    "   print(type(dropped))\n",
-    "   return dropped"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "source": [
-    "#### **Outlier Removal**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "def outlier_removal(z_df, z_threshold=4):\n",
-    "    \n",
-    "    global outlier_var\n",
-    "\n",
-    "    if z_threshold == 'none':\n",
-    "        print('No outliers were removed')\n",
-    "        outlier_var = 'none'\n",
-    "        return z_df\n",
-    "        \n",
-    "    else:\n",
-    "        print('The z-score threshold is:', z_threshold)\n",
-    "\n",
-    "        z_df_copy = z_df.copy()\n",
-    "\n",
-    "        z_scores = np.abs(stats.zscore(z_df_copy))\n",
-    "\n",
-    "     # Identify the outliers in the dataset using the z-score method\n",
-    "        outliers_mask = z_scores > z_threshold\n",
-    "        z_df_copy[outliers_mask] = np.nan\n",
-    "\n",
-    "        outliers_count = np.count_nonzero(outliers_mask)\n",
-    "        print('The number of outliers in the whole dataset is / was:', outliers_count)\n",
-    "\n",
-    "        outlier_var = z_threshold\n",
-    "\n",
-    "    print(type(z_df_copy))\n",
-    "    return z_df_copy"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "source": [
-    "#### **Scaling Methods**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# define a function to scale the dataframe using different scaling models\n",
-    "\n",
-    "def scale_dataframe(scale_model,df_fit, df_transform):\n",
-    "    \n",
-    "    global scale_model_var\n",
-    "\n",
-    "    if scale_model == 'robust':\n",
-    "        from sklearn.preprocessing import RobustScaler\n",
-    "        scaler = RobustScaler()\n",
-    "        scaler.fit(df_fit)\n",
-    "        df_scaled = scaler.transform(df_transform)\n",
-    "        df_scaled = pd.DataFrame(df_scaled, columns=df_transform.columns)\n",
-    "        print('The dataframe has been scaled using the robust scaling model')\n",
-    "        scale_model_var = 'robust'\n",
-    "        return df_scaled\n",
-    "    \n",
-    "    elif scale_model == 'standard':\n",
-    "        from sklearn.preprocessing import StandardScaler\n",
-    "        scaler = StandardScaler()\n",
-    "        scaler.fit(df_fit)\n",
-    "        df_scaled = scaler.transform(df_transform)\n",
-    "        df_scaled = pd.DataFrame(df_scaled, columns=df_transform.columns)\n",
-    "        print('The dataframe has been scaled using the standard scaling model')\n",
-    "        scale_model_var = 'standard'\n",
-    "        return df_scaled\n",
-    "    \n",
-    "    elif scale_model == 'normal':\n",
-    "        from sklearn.preprocessing import Normalizer\n",
-    "        scaler = Normalizer()\n",
-    "        scaler.fit(df_fit)\n",
-    "        df_scaled = scaler.transform(df_transform)\n",
-    "        df_scaled = pd.DataFrame(df_scaled, columns=df_transform.columns)\n",
-    "        print('The dataframe has been scaled using the normal scaling model')\n",
-    "        scale_model_var = 'normal'\n",
-    "        return df_scaled\n",
-    "    \n",
-    "    elif scale_model == 'minmax':\n",
-    "        from sklearn.preprocessing import MinMaxScaler\n",
-    "        scaler = MinMaxScaler()\n",
-    "        scaler.fit(df_fit)\n",
-    "        df_scaled = scaler.transform(df_transform)\n",
-    "        df_scaled = pd.DataFrame(df_scaled, columns=df_transform.columns)\n",
-    "        print('The dataframe has been scaled using the minmax scaling model')\n",
-    "        scale_model_var = 'minmax'\n",
-    "        return df_scaled\n",
-    "    \n",
-    "    elif scale_model == 'none':\n",
-    "        print('The dataframe has not been scaled')\n",
-    "        scale_model_var = 'none'\n",
-    "        return df_transform\n",
-    "    \n",
-    "    else:\n",
-    "        print('Please choose a valid scaling model: robust, standard, normal, or minmax')\n",
-    "        return None"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "source": [
-    "#### **Missing Value Imputation**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# define a function to impute missing values using different imputation models\n",
-    "\n",
-    "def impute_missing_values(imputation, df_fit, df_transform, n_neighbors=5):\n",
-    "\n",
-    "    print('Number of missing values before imputation: ', df_transform.isnull().sum().sum())\n",
-    "\n",
-    "    global imputation_var\n",
-    "\n",
-    "    if imputation == 'knn':\n",
-    "\n",
-    "        from sklearn.impute import KNNImputer\n",
-    "        imputer = KNNImputer(n_neighbors=n_neighbors)\n",
-    "        imputer.fit(df_fit)\n",
-    "        df_imputed = imputer.transform(df_transform)\n",
-    "        df_imputed = pd.DataFrame(df_imputed, columns=df_transform.columns)\n",
-    "        print('Number of missing values after imputation: ', df_imputed.isnull().sum().sum())\n",
-    "        imputation_var = 'knn'\n",
-    "        return df_imputed\n",
-    "    \n",
-    "    elif imputation == 'mean':\n",
-    "\n",
-    "        from sklearn.impute import SimpleImputer\n",
-    "        imputer = SimpleImputer(strategy='mean')\n",
-    "        imputer.fit(df_fit)\n",
-    "        df_imputed = imputer.transform(df_transform)\n",
-    "        df_imputed = pd.DataFrame(df_imputed, columns=df_transform.columns)\n",
-    "        print('Number of missing values after imputation: ', df_imputed.isnull().sum().sum())\n",
-    "        imputation_var = 'mean'\n",
-    "        return df_imputed\n",
-    "    \n",
-    "    elif imputation == 'median':\n",
-    "\n",
-    "        from sklearn.impute import SimpleImputer\n",
-    "        imputer = SimpleImputer(strategy='median')\n",
-    "        imputer.fit(df_fit)\n",
-    "        df_imputed = imputer.transform(df_transform)\n",
-    "        df_imputed = pd.DataFrame(df_imputed, columns=df_transform.columns)\n",
-    "        print('Number of missing values after imputation: ', df_imputed.isnull().sum().sum())\n",
-    "        imputation_var = 'median'\n",
-    "        return df_imputed\n",
-    "    \n",
-    "    elif imputation == 'most_frequent':\n",
-    "            \n",
-    "        from sklearn.impute import SimpleImputer\n",
-    "        imputer = SimpleImputer(strategy='most_frequent')\n",
-    "        imputer.fit(df_fit)\n",
-    "        df_imputed = imputer.transform(df_transform)\n",
-    "        df_imputed = pd.DataFrame(df_imputed, columns=df_transform.columns)\n",
-    "        print('Number of missing values after imputation: ', df_imputed.isnull().sum().sum())\n",
-    "        imputation_var = 'most_frequent'\n",
-    "        return df_imputed\n",
-    "    \n",
-    "    else:\n",
-    "        print('Please choose an imputation model from the following: knn, mean, median, most_frequent')\n",
-    "        df_imputed = df_transform.copy()\n",
-    "        return df_imputed\n"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "source": [
-    "#### **Feature Selection**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "def feature_selection(method, X_train, y_train):\n",
-    "\n",
-    "    global feature_selection_var\n",
-    "    global selected_features    \n",
-    "\n",
-    "    if method == 'boruta':\n",
-    "        print('Selected method is: ', method)\n",
-    "        from boruta import BorutaPy\n",
-    "        from sklearn.ensemble import RandomForestClassifier\n",
-    "        rf = RandomForestClassifier(n_estimators=100, n_jobs=-1)\n",
-    "        boruta_selector = BorutaPy(rf,n_estimators='auto', verbose=0, random_state=42)\n",
-    "        boruta_selector.fit(X_train.values, y_train.values.ravel())\n",
-    "        selected_feature_indices = boruta_selector.support_\n",
-    "        selected_columns = X_train.columns[selected_feature_indices]\n",
-    "        X_train_filtered = X_train.iloc[:, selected_feature_indices]\n",
-    "        print('Shape of the training set after feature selection with Boruta: ', X_train_filtered.shape)\n",
-    "        feature_selection_var = 'boruta'\n",
-    "        return X_train_filtered, selected_columns\n",
-    "    \n",
-    "    if method == 'none':\n",
-    "        print('Selected method is: ', method)\n",
-    "        X_train_filtered = X_train\n",
-    "        print('Shape of the training set after no feature selection: ', X_train_filtered.shape)\n",
-    "        feature_selection_var = 'none'\n",
-    "        selected_features = X_train_filtered.columns\n",
-    "        feature_selection_var = 'none'\n",
-    "        return X_train_filtered, selected_features        \n",
-    "    \n",
-    "    if method == 'lasso':\n",
-    "        print('Selected method is: ', method)\n",
-    "        from sklearn.linear_model import LassoCV\n",
-    "        from sklearn.feature_selection import SelectFromModel\n",
-    "        lasso = LassoCV().fit(X_train, y_train)\n",
-    "        model = SelectFromModel(lasso, prefit=True)\n",
-    "        X_train_filtered = model.transform(X_train)\n",
-    "        selected_features = X_train.columns[model.get_support()]\n",
-    "        print('Shape of the training set after feature selection with LassoCV: ', X_train_filtered.shape)\n",
-    "        feature_selection_var = 'lasso'\n",
-    "        return X_train_filtered, selected_features\n",
-    "    \n",
-    "    if method == 'pca':\n",
-    "        print('Selected method is: ', method)\n",
-    "        from sklearn.decomposition import PCA\n",
-    "        pca = PCA(n_components=15)\n",
-    "        X_train_pca = pca.fit_transform(X_train)\n",
-    "        selected_features = X_train.columns[pca.explained_variance_ratio_.argsort()[::-1]][:15]\n",
-    "        print('Shape of the training set after feature selection with PCA: ', X_train_pca.shape)\n",
-    "        feature_selection_var = 'pca'\n",
-    "        return X_train_pca, selected_features\n",
-    "    \n",
-    "    if method == 'rfe':\n",
-    "        print('Selected method is: ', method)\n",
-    "        from sklearn.feature_selection import RFE\n",
-    "        from sklearn.ensemble import RandomForestClassifier\n",
-    "        rfe_selector = RFE(estimator=RandomForestClassifier(n_estimators=100, n_jobs=-1), n_features_to_select=15, step=10, verbose=0)\n",
-    "        rfe_selector.fit(X_train, y_train)\n",
-    "        selected_features = X_train.columns[rfe_selector.support_]\n",
-    "        X_train_filtered = X_train.iloc[:, rfe_selector.support_]\n",
-    "        print('Shape of the training set after feature selection with RFE: ', X_train_filtered.shape)\n",
-    "        feature_selection_var = 'rfe'\n",
-    "        return X_train_filtered, selected_features\n",
-    "    "
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "source": [
-    "#### **Imbalance Treatment**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "#define a function to oversample and understamble the imbalance in the training set\n",
-    "\n",
-    "def imbalance_treatment(method, X_train, y_train):\n",
-    "\n",
-    "    global imbalance_var\n",
-    "\n",
-    "    if method == 'smote':        \n",
-    "        from imblearn.over_sampling import SMOTE\n",
-    "        sm = SMOTE(random_state=42)\n",
-    "        X_train_res, y_train_res = sm.fit_resample(X_train, y_train)\n",
-    "        imbalance_var = 'smote'\n",
-    "        return X_train_res, y_train_res\n",
-    "    \n",
-    "    if method == 'undersampling':\n",
-    "        from imblearn.under_sampling import RandomUnderSampler\n",
-    "        rus = RandomUnderSampler(random_state=42)\n",
-    "        X_train_res, y_train_res = rus.fit_resample(X_train, y_train)\n",
-    "        imbalance_var = 'random_undersampling'\n",
-    "        return X_train_res, y_train_res\n",
-    "    \n",
-    "    if method == 'rose':\n",
-    "        from imblearn.over_sampling import RandomOverSampler\n",
-    "        ros = RandomOverSampler(random_state=42)\n",
-    "        X_train_res, y_train_res = ros.fit_resample(X_train, y_train)\n",
-    "        imbalance_var = 'rose'\n",
-    "        return X_train_res, y_train_res\n",
-    "    \n",
-    "    \n",
-    "    if method == 'none':\n",
-    "        X_train_res = X_train\n",
-    "        y_train_res = y_train\n",
-    "        imbalance_var = 'none'\n",
-    "        return X_train_res, y_train_res\n",
-    "    \n",
-    "    else:\n",
-    "        print('Please choose a valid resampling method: smote, rose, undersampling or none')\n",
-    "        X_train_res = X_train\n",
-    "        y_train_res = y_train\n",
-    "        return X_train_res, y_train_res"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "source": [
-    "#### **Training Models**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 28,
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# define a function where you can choose the model you want to use to train the data\n",
-    "\n",
-    "def train_model(model, X_train, y_train, X_test, y_test):\n",
-    "\n",
-    "    global model_var\n",
-    "\n",
-    "    if model == 'random_forest':\n",
-    "        from sklearn.ensemble import RandomForestClassifier\n",
-    "        rfc = RandomForestClassifier(n_estimators=100, random_state=13)\n",
-    "        rfc.fit(X_train, y_train)\n",
-    "        y_pred = rfc.predict(X_test)\n",
-    "        model_var = 'random_forest'\n",
-    "        return y_pred\n",
-    "\n",
-    "    if model == 'logistic_regression':\n",
-    "        from sklearn.linear_model import LogisticRegression\n",
-    "        lr = LogisticRegression()\n",
-    "        lr.fit(X_train, y_train)\n",
-    "        y_pred = lr.predict(X_test)\n",
-    "        model_var = 'logistic_regression'\n",
-    "        return y_pred\n",
-    "    \n",
-    "    if model == 'knn':\n",
-    "        from sklearn.neighbors import KNeighborsClassifier\n",
-    "        knn = KNeighborsClassifier(n_neighbors=5)\n",
-    "        knn.fit(X_train, y_train)\n",
-    "        y_pred = knn.predict(X_test)\n",
-    "        model_var = 'knn'\n",
-    "        return y_pred\n",
-    "    \n",
-    "    if model == 'svm':\n",
-    "        from sklearn.svm import SVC\n",
-    "        svm = SVC()\n",
-    "        svm.fit(X_train, y_train)\n",
-    "        y_pred = svm.predict(X_test)\n",
-    "        model_var = 'svm'\n",
-    "        return y_pred\n",
-    "    \n",
-    "    if model == 'naive_bayes':\n",
-    "        from sklearn.naive_bayes import GaussianNB\n",
-    "        nb = GaussianNB()\n",
-    "        nb.fit(X_train, y_train)\n",
-    "        y_pred = nb.predict(X_test)\n",
-    "        model_var = 'naive_bayes'\n",
-    "        return y_pred\n",
-    "    \n",
-    "    if model == 'decision_tree':\n",
-    "        from sklearn.tree import DecisionTreeClassifier\n",
-    "        dt = DecisionTreeClassifier()\n",
-    "        dt.fit(X_train, y_train)\n",
-    "        y_pred = dt.predict(X_test)\n",
-    "        model_var = 'decision_tree'\n",
-    "        return y_pred\n",
-    "    \n",
-    "    if model == 'xgboost':\n",
-    "        from xgboost import XGBClassifier\n",
-    "        xgb = XGBClassifier()\n",
-    "        xgb.fit(X_train, y_train)\n",
-    "        y_pred = xgb.predict(X_test)\n",
-    "        model_var = 'xgboost'\n",
-    "        return y_pred\n",
-    "    \n",
-    "    else:\n",
-    "        print('Please choose a model from the following: random_forest, logistic_regression, knn, svm, naive_bayes, decision_tree, xgboost')\n",
-    "        return None"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "source": [
-    "#### **Evaluation Function**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "#define a function that prints the strings below\n",
-    "\n",
-    "from sklearn.metrics import confusion_matrix, accuracy_score, precision_score, recall_score, f1_score\n",
-    "\n",
-    "def evaluate_models(model='random_forest'):\n",
-    "\n",
-    "    all_models = ['random_forest', 'logistic_regression', 'knn', 'svm', 'naive_bayes', 'decision_tree', 'xgboost']\n",
-    "    evaluation_score_append = []\n",
-    "    evaluation_count_append = []\n",
-    "    \n",
-    "    for selected_model in all_models:\n",
-    "      \n",
-    "        if model == 'all' or model == selected_model:\n",
-    "\n",
-    "            evaluation_score = []\n",
-    "            evaluation_count = []\n",
-    "\n",
-    "            y_pred = globals()['y_pred_' + selected_model]  # Get the prediction variable dynamically\n",
-    "\n",
-    "            def namestr(obj, namespace):\n",
-    "                return [name for name in namespace if namespace[name] is obj]\n",
-    "\n",
-    "            model_name = namestr(y_pred, globals())[0]\n",
-    "            model_name = model_name.replace('y_pred_', '')            \n",
-    "\n",
-    "            cm = confusion_matrix(y_test, y_pred)\n",
-    "\n",
-    "            # create a dataframe with the results for each model\n",
-    "\n",
-    "            evaluation_score.append(model_name)\n",
-    "            evaluation_score.append(round(accuracy_score(y_test, y_pred), 2))\n",
-    "            evaluation_score.append(round(precision_score(y_test, y_pred, zero_division=0), 2))\n",
-    "            evaluation_score.append(round(recall_score(y_test, y_pred), 2))\n",
-    "            evaluation_score.append(round(f1_score(y_test, y_pred), 2))\n",
-    "            evaluation_score_append.append(evaluation_score)\n",
-    "\n",
-    "\n",
-    "            # create a dataframe with the true positives, true negatives, false positives and false negatives for each model\n",
-    "\n",
-    "            evaluation_count.append(model_name)\n",
-    "            evaluation_count.append(cm[0][0])\n",
-    "            evaluation_count.append(cm[0][1])\n",
-    "            evaluation_count.append(cm[1][0])\n",
-    "            evaluation_count.append(cm[1][1])\n",
-    "            evaluation_count_append.append(evaluation_count)\n",
-    "\n",
-    "        \n",
-    "    evaluation_score_append = pd.DataFrame(evaluation_score_append, \n",
-    "                                        columns=['Model', 'Accuracy', 'Precision', 'Recall', 'F1-score'])\n",
-    "    \n",
-    "  \n",
-    "\n",
-    "    evaluation_count_append = pd.DataFrame(evaluation_count_append,\n",
-    "                                        columns=['Model', 'True Negatives', 'False Positives', 'False Negatives', 'True Positives'])\n",
-    "    \n",
-    "   \n",
-    "    return evaluation_score_append, evaluation_count_append"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "source": [
-    "### **Input Variables**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 30,
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "outputs": [
-    {
-     "data": {
-      "application/mercury+json": {
-       "choices": [
-        "yes",
-        "no"
-       ],
-       "code_uid": "Select.0.40.16.25-randb785d2a5",
-       "disabled": false,
-       "hidden": false,
-       "label": "Drop Duplicates",
-       "model_id": "f5c9c8b77b8a4b92bfeaebfd09688f8a",
-       "url_key": "",
-       "value": "yes",
-       "widget": "Select"
-      },
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "f5c9c8b77b8a4b92bfeaebfd09688f8a",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "mercury.Select"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/mercury+json": {
-       "code_uid": "Text.0.40.15.28-rand76290b78",
-       "disabled": false,
-       "hidden": false,
-       "label": "Missing Value Threeshold",
-       "model_id": "2a1d81490e1e439ba214219a0bfa56b3",
-       "rows": 1,
-       "url_key": "",
-       "value": "80",
-       "widget": "Text"
-      },
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "2a1d81490e1e439ba214219a0bfa56b3",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "mercury.Text"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/mercury+json": {
-       "code_uid": "Text.0.40.15.31-rand3a34547a",
-       "disabled": false,
-       "hidden": false,
-       "label": "Variance Threshold",
-       "model_id": "e0e229e9864545099ba169ad272273f5",
-       "rows": 1,
-       "url_key": "",
-       "value": "0",
-       "widget": "Text"
-      },
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "e0e229e9864545099ba169ad272273f5",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "mercury.Text"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/mercury+json": {
-       "code_uid": "Text.0.40.15.34-rand79b594f6",
-       "disabled": false,
-       "hidden": false,
-       "label": "Correlation Threshold",
-       "model_id": "3c42c9d218934722a7c2ebcaa9715d34",
-       "rows": 1,
-       "url_key": "",
-       "value": "1",
-       "widget": "Text"
-      },
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "3c42c9d218934722a7c2ebcaa9715d34",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "mercury.Text"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/mercury+json": {
-       "choices": [
-        "none",
-        3,
-        4,
-        5
-       ],
-       "code_uid": "Select.0.40.16.38-randb65fcc34",
-       "disabled": false,
-       "hidden": false,
-       "label": "Outlier Removal Threshold",
-       "model_id": "577bf130efe0427f82fbb99a6e6f8796",
-       "url_key": "",
-       "value": "none",
-       "widget": "Select"
-      },
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "577bf130efe0427f82fbb99a6e6f8796",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "mercury.Select"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/mercury+json": {
-       "choices": [
-        "none",
-        "standard",
-        "minmax",
-        "robust"
-       ],
-       "code_uid": "Select.0.40.16.46-rand2e347045",
-       "disabled": false,
-       "hidden": false,
-       "label": "Scaling Variables",
-       "model_id": "1775424536e64ff899ca0d6ec93ea978",
-       "url_key": "",
-       "value": "none",
-       "widget": "Select"
-      },
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "1775424536e64ff899ca0d6ec93ea978",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "mercury.Select"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/mercury+json": {
-       "choices": [
-        "mean",
-        "median",
-        "knn",
-        "most_frequent"
-       ],
-       "code_uid": "Select.0.40.16.50-randa094eed0",
-       "disabled": false,
-       "hidden": false,
-       "label": "Imputation Methods",
-       "model_id": "a35dad0324ce44578f8ce2609662f4ec",
-       "url_key": "",
-       "value": "mean",
-       "widget": "Select"
-      },
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "a35dad0324ce44578f8ce2609662f4ec",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "mercury.Select"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/mercury+json": {
-       "choices": [
-        "none",
-        "lasso",
-        "rfe",
-        "pca",
-        "boruta"
-       ],
-       "code_uid": "Select.0.40.16.55-rande9681438",
-       "disabled": false,
-       "hidden": false,
-       "label": "Feature Selection",
-       "model_id": "ee69abf9627d44c09da90a79fe98c447",
-       "url_key": "",
-       "value": "none",
-       "widget": "Select"
-      },
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "ee69abf9627d44c09da90a79fe98c447",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "mercury.Select"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/mercury+json": {
-       "choices": [
-        "none",
-        "smote",
-        "undersampling",
-        "rose"
-       ],
-       "code_uid": "Select.0.40.16.59-randc218b629",
-       "disabled": false,
-       "hidden": false,
-       "label": "Imbalance Treatment",
-       "model_id": "d2da0edfb49d45e680d72f1cd59b956d",
-       "url_key": "",
-       "value": "none",
-       "widget": "Select"
-      },
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "d2da0edfb49d45e680d72f1cd59b956d",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "mercury.Select"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/mercury+json": {
-       "choices": [
-        "random_forest",
-        "logistic_regression",
-        "knn",
-        "svm",
-        "naive_bayes",
-        "decision_tree",
-        "xgboost"
-       ],
-       "code_uid": "Select.0.40.16.64-rand3f39df1a",
-       "disabled": false,
-       "hidden": false,
-       "label": "Model Selection",
-       "model_id": "c277aac8be5a4a21a048ea6cab3b9501",
-       "url_key": "",
-       "value": "xgboost",
-       "widget": "Select"
-      },
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "c277aac8be5a4a21a048ea6cab3b9501",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "mercury.Select"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "\n",
-    "evaluation_score_df = pd.DataFrame(columns=['Model', 'Accuracy', 'Precision', 'Recall', 'F1-score', 'model_variables'])\n",
-    "evaluation_count_df = pd.DataFrame(columns=['Model', 'True Negatives', 'False Positives', 'False Negatives', 'True Positives', 'model_variables'])\n",
-    "\n",
-    "#############################################################################################################\n",
-    "# reset the dataframe containing all results, evaluation_score_df and evaluation_count_df\n",
-    "\n",
-    "reset_results = 'no' # 'yes' or 'no'\n",
-    "\n",
-    "#############################################################################################################\n",
-    "\n",
-    "if reset_results == 'yes':\n",
-    "    evaluation_score_df = pd.DataFrame(columns=['Model', 'Accuracy', 'Precision', 'Recall', 'F1-score', 'model_variables'])\n",
-    "    evaluation_count_df = pd.DataFrame(columns=['Model', 'True Negatives', 'False Positives', 'False Negatives', 'True Positives', 'model_variables'])\n",
-    "    \n",
-    "\n",
-    "#############################################################################################################\n",
-    "\n",
-    "# input train and test sets\n",
-    "input_train_set = X_train\n",
-    "input_test_set = X_test\n",
-    "\n",
-    "\n",
-    "\n",
-    "# input feature removal variables\n",
-    "input_drop_duplicates = mr.Select(label=\"Drop Duplicates\", value=\"yes\", choices=[\"yes\", \"no\"])           # 'yes' or 'no'\n",
-    "input_drop_duplicates = str(input_drop_duplicates.value)\n",
-    "\n",
-    "input_missing_values_threshold = mr.Text(label=\"Missing Value Threeshold\", value='80')     # 0-100 (removes columns with more missing values than the threshold)\n",
-    "input_missing_values_threshold = int(input_missing_values_threshold.value)\n",
-    "\n",
-    "input_variance_threshold = mr.Text(label=\"Variance Threshold\", value='0')          # \n",
-    "input_variance_threshold = float(input_variance_threshold.value)\n",
-    "\n",
-    "input_correlation_threshold = mr.Text(label=\"Correlation Threshold\", value='1')       # \n",
-    "input_correlation_threshold = float(input_correlation_threshold.value)\n",
-    "\n",
-    "# input outlier removal variables\n",
-    "input_outlier_removal_threshold = mr.Select(label=\"Outlier Removal Threshold\", value=\"none\", choices=['none', 3, 4, 5])      # 'none' or zscore from 0 to 100\n",
-    "\n",
-    "if input_outlier_removal_threshold.value != 'none':\n",
-    "    input_outlier_removal_threshold = int(input_outlier_removal_threshold.value)\n",
-    "elif input_outlier_removal_threshold.value == 'none':\n",
-    "    input_outlier_removal_threshold = str(input_outlier_removal_threshold.value)\n",
-    "\n",
-    "# input scaling variables\n",
-    "input_scale_model = mr.Select(label=\"Scaling Variables\", value=\"none\", choices=['none', 'standard', 'minmax', 'robust'])              # 'none', 'normal', 'standard', 'minmax', 'robust'\n",
-    "input_scale_model = str(input_scale_model.value)\n",
-    "\n",
-    "# input imputation variables\n",
-    "input_imputation_method = mr.Select(label=\"Imputation Methods\", value=\"mean\", choices=['mean', 'median', 'knn', 'most_frequent'])          # 'mean', 'median', 'knn', 'most_frequent'\n",
-    "input_n_neighbors = 5                  # only for knn imputation\n",
-    "input_imputation_method = str(input_imputation_method.value)\n",
-    "\n",
-    "# input feature selection variables\n",
-    "input_feature_selection = mr.Select(label=\"Feature Selection\", value=\"none\", choices=['none', 'lasso', 'rfe', 'pca', 'boruta'])          # 'none', 'lasso', 'rfe', 'pca', 'boruta'\n",
-    "input_feature_selection = str(input_feature_selection.value)\n",
-    "\n",
-    "# input imbalance treatment variables\n",
-    "input_imbalance_treatment = mr.Select(label=\"Imbalance Treatment\", value=\"none\", choices=['none', 'smote', 'undersampling', 'rose'])       # 'none', 'smote', 'undersampling', 'rose'\n",
-    "input_imbalance_treatment = str(input_imbalance_treatment.value)\n",
-    "\n",
-    "\n",
-    "# input model\n",
-    "input_model = mr.Select(label=\"Model Selection\", value=\"xgboost\", choices=['random_forest', 'logistic_regression', 'knn', 'svm', 'naive_bayes','decision_tree','xgboost'])                      # 'all', 'random_forest', 'logistic_regression', 'knn', \n",
-    "                                        # 'svm', 'naive_bayes', # 'decision_tree', 'xgboost'\n",
-    "input_model = str(input_model.value)\n"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "source": [
-    "### **Transform Data**"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "source": [
-    "#### **Remove Features**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 31,
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Shape of the dataframe is:  (1175, 590)\n",
-      "the number of columns to be dropped due to duplications is:  104\n",
-      "the number of columns to be dropped due to missing values is:  8\n",
-      "the number of columns to be dropped due to low variance is:  12\n",
-      "the number of columns to be dropped due to high correlation is:  21\n",
-      "Total number of columns to be dropped is:  145\n",
-      "New shape of the dataframe is:  (1175, 445)\n",
-      "<class 'list'>\n",
-      "No outliers were removed\n",
-      "The dataframe has not been scaled\n",
-      "The dataframe has not been scaled\n",
-      "Number of missing values before imputation:  19977\n",
-      "Number of missing values after imputation:  0\n",
-      "Number of missing values before imputation:  6954\n",
-      "Number of missing values after imputation:  0\n",
-      "Selected method is:  none\n",
-      "Shape of the training set after no feature selection:  (1175, 445)\n"
-     ]
-    }
-   ],
-   "source": [
-    "# remove features using the function list_columns_to_drop\n",
-    "\n",
-    "dropped = columns_to_drop(input_train_set, \n",
-    "                               input_drop_duplicates, input_missing_values_threshold, \n",
-    "                               input_variance_threshold, input_correlation_threshold)\n",
-    "\n",
-    "# drop the columns from the training and testing sets and save the new sets as new variables\n",
-    "\n",
-    "X_train2 = input_train_set.drop(dropped, axis=1)\n",
-    "X_test2 = input_test_set.drop(dropped, axis=1)\n",
-    "\n",
-    "X_train_dropped_outliers = outlier_removal(X_train2, input_outlier_removal_threshold)\n",
-    "\n",
-    "\n",
-    "X_train_scaled = scale_dataframe(input_scale_model, X_train_dropped_outliers, X_train_dropped_outliers)\n",
-    "X_test_scaled = scale_dataframe(input_scale_model, X_train_dropped_outliers, X_test2)\n",
-    "\n",
-    "# impute the missing values in the training and testing sets using the function impute_missing_values\n",
-    "\n",
-    "X_train_imputed = impute_missing_values(input_imputation_method,X_train_scaled, X_train_scaled, input_n_neighbors)\n",
-    "X_test_imputed = impute_missing_values(input_imputation_method,X_train_scaled, X_test_scaled, input_n_neighbors)\n",
-    "\n",
-    "# select the features using the function feature_selection\n",
-    "\n",
-    "X_train_selected, selected_features = feature_selection(input_feature_selection, X_train_imputed, y_train)\n",
-    "\n",
-    "X_train_selected = pd.DataFrame(X_train_selected, columns=selected_features)\n",
-    "X_test_selected = X_test_imputed[selected_features]\n",
-    "\n",
-    "# treat imbalance in the training set using the function oversample\n",
-    "\n",
-    "X_train_res, y_train_res = imbalance_treatment(input_imbalance_treatment, X_train_selected, y_train)\n",
-    "\n"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "source": [
-    "### **Model Training**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 32,
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# train the model using the function train_model and save the predictions as new variables\n",
-    "\n",
-    "y_pred_random_forest = train_model('random_forest', X_train_res, y_train_res, X_test_imputed, y_test)\n",
-    "y_pred_logistic_regression = train_model('logistic_regression', X_train_res, y_train_res, X_test_imputed, y_test)\n",
-    "y_pred_knn = train_model('knn', X_train_res, y_train_res, X_test_imputed, y_test)\n",
-    "y_pred_svm = train_model('svm', X_train_res, y_train_res, X_test_imputed, y_test)\n",
-    "y_pred_naive_bayes = train_model('naive_bayes', X_train_res, y_train_res, X_test_imputed, y_test)\n",
-    "y_pred_decision_tree = train_model('decision_tree', X_train_res, y_train_res, X_test_imputed, y_test)\n",
-    "y_pred_xgboost = train_model('xgboost', X_train_res, y_train_res, X_test_imputed, y_test)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "skip"
-    }
-   },
-   "source": [
-    "#### **Evaluate and Save**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 33,
-   "metadata": {
-    "slideshow": {
-     "slide_type": "slide"
-    }
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>Model</th>\n",
-       "      <th>Accuracy</th>\n",
-       "      <th>Precision</th>\n",
-       "      <th>Recall</th>\n",
-       "      <th>F1-score</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>xgboost</td>\n",
-       "      <td>0.93</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>0.0</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "     Model  Accuracy  Precision  Recall  F1-score\n",
-       "0  xgboost      0.93        0.0     0.0       0.0"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>Model</th>\n",
-       "      <th>True Negatives</th>\n",
-       "      <th>False Positives</th>\n",
-       "      <th>False Negatives</th>\n",
-       "      <th>True Positives</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>xgboost</td>\n",
-       "      <td>364</td>\n",
-       "      <td>2</td>\n",
-       "      <td>26</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "     Model  True Negatives  False Positives  False Negatives  True Positives\n",
-       "0  xgboost             364                2               26               0"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 500x500 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "evaluation_score_output, evaluation_counts_output = evaluate_models(input_model)\n",
-    "\n",
-    "# check if the model has already been evaluated and if not, append the results to the dataframe\n",
-    "\n",
-    "evaluation_score_df = pd.concat([evaluation_score_output, evaluation_score_df], ignore_index=True)    \n",
-    "display(pd.DataFrame(evaluation_score_output))\n",
-    "\n",
-    "evaluation_count_df = pd.concat([evaluation_counts_output, evaluation_count_df], ignore_index=True)    \n",
-    "display(pd.DataFrame(evaluation_counts_output))\n",
-    "\n",
-    "from mlxtend.plotting import plot_confusion_matrix\n",
-    "\n",
-    "# select the model index and filter the row from evaluation_count_df dataframe\n",
-    "model_index = 0\n",
-    "\n",
-    "selected_model = evaluation_count_df[evaluation_count_df.index == model_index]\n",
-    "\n",
-    "# create a np.array with selected_model values\n",
-    "\n",
-    "\n",
-    "conf_matrix = np.array([[selected_model['True Negatives'].values[0], selected_model['False Positives'].values[0]],\n",
-    "                [selected_model['False Negatives'].values[0], selected_model['True Positives'].values[0]]])\n",
-    "\n",
-    "#change the size of the graph\n",
-    "\n",
-    "plt.rcParams['figure.figsize'] = [5, 5]\n",
-    "\n",
-    "fig, ax = plot_confusion_matrix(\n",
-    "    conf_mat=conf_matrix,\n",
-    "    show_absolute=True,\n",
-    "    show_normed=True\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "metadata": {
-    "slideshow": {
-     "slide_type": "slide"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Have the duplicates been removed? yes\n",
-      "What is the missing values threshold? 80\n",
-      "What is the variance threshold? 0.0\n",
-      "How many features have been removed? 145\n",
-      "---------------------\n",
-      "What is the outlier removal threshold? none\n",
-      "How many outliers have been removed? 0\n",
-      "---------------------\n",
-      "What is the scaling method? none\n",
-      "---------------------\n",
-      "What is the imputation method? mean\n",
-      "---------------------\n",
-      "What is the feature selection method? none\n",
-      "What is the number of features selected? 445\n",
-      "---------------------\n",
-      "What is the imbalance treatment method? none\n",
-      "---------------------\n",
-      "What is the model? xgboost\n"
-     ]
-    }
-   ],
-   "source": [
-    "print('Have the duplicates been removed?', drop_duplicates_var)\n",
-    "print('What is the missing values threshold?', missing_values_threshold_var)\n",
-    "print('What is the variance threshold?', variance_threshold_var)\n",
-    "print('How many features have been removed?', len(dropped))\n",
-    "print('---------------------')\n",
-    "print('What is the outlier removal threshold?', outlier_var)\n",
-    "print('How many outliers have been removed?', len(X_train2) - len(X_train_dropped_outliers))\n",
-    "print('---------------------')\n",
-    "print('What is the scaling method?', scale_model_var)\n",
-    "print('---------------------')\n",
-    "print('What is the imputation method?', imputation_var)\n",
-    "print('---------------------')\n",
-    "print('What is the feature selection method?', feature_selection_var)\n",
-    "print('What is the number of features selected?', len(selected_features))\n",
-    "print('---------------------')\n",
-    "print('What is the imbalance treatment method?', imbalance_var)\n",
-    "print('---------------------')\n",
-    "print('What is the model?', input_model)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "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.16"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}