Upload P2 - Secom Notebook2 - Mercury.ipynb

P2 - Secom Notebook2 - Mercury.ipynb

@@ -0,0 +1,1571 @@
+{
+ "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": 85,
+   "metadata": {},
+   "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",
+    "import mercury as mr\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt\n",
+    "from scipy import stats\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "import warnings\n",
+    "warnings.filterwarnings('ignore')\n",
+    "from mlxtend.plotting import plot_confusion_matrix\n",
+    "from sklearn.metrics import confusion_matrix, accuracy_score, precision_score, recall_score, f1_score\n",
+    "from mlxtend.plotting import plot_confusion_matrix"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 86,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/mercury+json": {
+       "allow_download": true,
+       "code_uid": "App.0.40.24.1-rand8c10e2d9",
+       "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": 87,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 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": 88,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/mercury+json": {
+       "code_uid": "Text.0.40.15.11-rand39f89858",
+       "disabled": false,
+       "hidden": false,
+       "label": "Test Size Ratio",
+       "model_id": "271115d337014695a05d7e83307b4cc4",
+       "rows": 1,
+       "url_key": "",
+       "value": "0.25",
+       "widget": "Text"
+      },
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "271115d337014695a05d7e83307b4cc4",
+       "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.14-randf159337c",
+       "disabled": false,
+       "hidden": false,
+       "label": "Random State Integer",
+       "model_id": "87a237754fa24e11a17700de955552a8",
+       "rows": 1,
+       "url_key": "",
+       "value": "13",
+       "widget": "Text"
+      },
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "87a237754fa24e11a17700de955552a8",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "mercury.Text"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "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",
+    "\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",
+    "test_size_num = mr.Text(label=\"Test Size Ratio\", value='0.25')          # \n",
+    "test_size_num = float(test_size_num.value)\n",
+    "\n",
+    "random_state_num = mr.Text(label=\"Random State Integer\", value='13')          # \n",
+    "random_state_num = int(random_state_num.value)\n",
+    "\n",
+    "\n",
+    "X_train, X_test, y_train, y_test = train_test_split(\n",
+    "    features, labels, test_size = test_size_num, stratify=labels, random_state=random_state_num)\n",
+    "\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "skip"
+    }
+   },
+   "source": [
+    "#### **Feature Removal**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 89,
+   "metadata": {},
+   "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('------------------------------------------')\n",
+    "   print('FEATURE REMOVAL')\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 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 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 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 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": 90,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def outlier_removal(z_df, z_threshold=4):\n",
+    "    \n",
+    "    global outlier_var\n",
+    "\n",
+    "    print('------------------------------------------')\n",
+    "    print('OUTLIER REMOVAL')\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 removed from the dataset is:', 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": 91,
+   "metadata": {},
+   "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",
+    "    print('------------------------------------------')\n",
+    "    print('SCALING THE DATAFRAME')\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": 92,
+   "metadata": {},
+   "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('------------------------------------------')\n",
+    "    print('IMPUTATION PROCESS')\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('knn imputation has been applied')        \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('mean imputation has been applied')\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('median imputation has been applied')\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('most frequent imputation has been applied')\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 Reduction / Selection**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 93,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def feature_selection(method, X_train, y_train):\n",
+    "\n",
+    "    global feature_selection_var\n",
+    "    global selected_features\n",
+    "\n",
+    "    print('------------------------------------------')\n",
+    "    print('FEATURE SELECTION')\n",
+    "\n",
+    "    # if method is boruta, run boruta feature selection and return the selected features and the training set with only the 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",
+    "        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",
+    "        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": 94,
+   "metadata": {},
+   "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",
+    "    print('------------------------------------------')\n",
+    "    print('IMBALANCE TREATMENT')\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",
+    "        print('Shape of the training set after oversampling with SMOTE: ', X_train_res.shape)\n",
+    "        print('Value counts of the target variable after oversampling with SMOTE: \\n', y_train_res.value_counts())\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",
+    "        print('Shape of the training set after undersampling with RandomUnderSampler: ', X_train_res.shape)\n",
+    "        print('Value counts of the target variable after undersampling with RandomUnderSampler: \\n', y_train_res.value_counts())\n",
+    "        imbalance_var = '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",
+    "        print('Shape of the training set after oversampling with RandomOverSampler: ', X_train_res.shape)\n",
+    "        print('Value counts of the target variable after oversampling with RandomOverSampler: \\n', y_train_res.value_counts())\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",
+    "        print('Shape of the training set after no resampling: ', X_train_res.shape)\n",
+    "        print('Value counts of the target variable after no resampling: \\n', y_train_res.value_counts())\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": 95,
+   "metadata": {},
+   "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"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 96,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "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'])"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "skip"
+    }
+   },
+   "source": [
+    "#### **Evaluation Function**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 101,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#define a function that prints the strings below\n",
+    "def evaluate_models(model='random_forest'):\n",
+    "     \n",
+    "    print('--------------------------------------------------')\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",
+    "    evaluation_score_append['drop duplicates'] = drop_duplicates_var\n",
+    "    evaluation_score_append['missing values th'] = missing_values_threshold_var\n",
+    "    evaluation_score_append['variance th'] = variance_threshold_var\n",
+    "    evaluation_score_append['correlation th'] = correlation_threshold_var\n",
+    "    evaluation_score_append['outlier removal th'] = outlier_var\n",
+    "    evaluation_score_append['scaling method'] = scale_model_var\n",
+    "    evaluation_score_append['imputation method'] = imputation_var\n",
+    "    evaluation_score_append['feature selection'] = feature_selection_var\n",
+    "    evaluation_score_append['imbalance treatment'] = imbalance_var\n",
+    "\n",
+    "\n",
+    "    evaluation_score_append['model_variables'] = drop_duplicates_var + '_' + str(missing_values_threshold_var) + '_' + str(\n",
+    "        variance_threshold_var) + '_' + str(correlation_threshold_var) + '_' + str(\n",
+    "        outlier_var) + '_' + scale_model_var + '_' + imputation_var + '_' + feature_selection_var + '_' + imbalance_var\n",
+    "    \n",
+    "\n",
+    "    evaluation_count_append = pd.DataFrame(evaluation_count_append,\n",
+    "                                        columns=['Model', 'True Negatives', 'False Positives', 'False Negatives', 'True Positives'])\n",
+    "    \n",
+    "    evaluation_count_append['drop duplicates'] = drop_duplicates_var\n",
+    "    evaluation_count_append['missing values th'] = missing_values_threshold_var\n",
+    "    evaluation_count_append['variance th'] = variance_threshold_var\n",
+    "    evaluation_count_append['correlation th'] = correlation_threshold_var\n",
+    "    evaluation_count_append['outlier removal th'] = outlier_var\n",
+    "    evaluation_count_append['scaling method'] = scale_model_var\n",
+    "    evaluation_count_append['imputation method'] = imputation_var\n",
+    "    evaluation_count_append['feature selection'] = feature_selection_var\n",
+    "    evaluation_count_append['imbalance treatment'] = imbalance_var\n",
+    "        \n",
+    "    evaluation_count_append['model_variables'] = drop_duplicates_var + '_' + str(missing_values_threshold_var) + '_' + str(\n",
+    "        variance_threshold_var) + '_' + str(correlation_threshold_var) + '_' + str(\n",
+    "        outlier_var) + '_' + scale_model_var + '_' + imputation_var + '_' + feature_selection_var + '_' + imbalance_var\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": 103,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/mercury+json": {
+       "code_uid": "Text.0.40.15.8-rand3ea159f1",
+       "disabled": false,
+       "hidden": false,
+       "label": "Missing Value Threeshold",
+       "model_id": "1f155017a0e64a71ba2f1a737d93c61d",
+       "rows": 1,
+       "url_key": "",
+       "value": "50",
+       "widget": "Text"
+      },
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "1f155017a0e64a71ba2f1a737d93c61d",
+       "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.11-rand7772c265",
+       "disabled": false,
+       "hidden": false,
+       "label": "Variance Threshold",
+       "model_id": "6ae03558245f4658abc409261e88e273",
+       "rows": 1,
+       "url_key": "",
+       "value": "0.05",
+       "widget": "Text"
+      },
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "6ae03558245f4658abc409261e88e273",
+       "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.14-rand52a68a07",
+       "disabled": false,
+       "hidden": false,
+       "label": "Correlation Threshold",
+       "model_id": "325fdc5cafb046c89be6440a2a0e855c",
+       "rows": 1,
+       "url_key": "",
+       "value": "0.95",
+       "widget": "Text"
+      },
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "325fdc5cafb046c89be6440a2a0e855c",
+       "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.18-randd219fc2a",
+       "disabled": false,
+       "hidden": false,
+       "label": "Outlier Removal Threshold",
+       "model_id": "96591acea02b43f9a366ddfdfff1dfb5",
+       "url_key": "",
+       "value": 5,
+       "widget": "Select"
+      },
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "96591acea02b43f9a366ddfdfff1dfb5",
+       "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.25-rand7528f0a1",
+       "disabled": false,
+       "hidden": false,
+       "label": "Scaling Variables",
+       "model_id": "8fc6da55b85c4993bf420c86d2a23a2d",
+       "url_key": "",
+       "value": "standard",
+       "widget": "Select"
+      },
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "8fc6da55b85c4993bf420c86d2a23a2d",
+       "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.29-randb1225c9d",
+       "disabled": false,
+       "hidden": false,
+       "label": "Imputation Methods",
+       "model_id": "193450229f4543079d7a53267d8c1fe1",
+       "url_key": "",
+       "value": "median",
+       "widget": "Select"
+      },
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "193450229f4543079d7a53267d8c1fe1",
+       "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.34-rand9ae51452",
+       "disabled": false,
+       "hidden": false,
+       "label": "Feature Selection",
+       "model_id": "e556e5025dc14e9e867125680d35025f",
+       "url_key": "",
+       "value": "lasso",
+       "widget": "Select"
+      },
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "e556e5025dc14e9e867125680d35025f",
+       "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.38-rand84f919f9",
+       "disabled": false,
+       "hidden": false,
+       "label": "Imbalance Treatment",
+       "model_id": "29560b71dbf84b45a2a487c92c077ad4",
+       "url_key": "",
+       "value": "smote",
+       "widget": "Select"
+      },
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "29560b71dbf84b45a2a487c92c077ad4",
+       "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.42-rand98b2dc54",
+       "disabled": false,
+       "hidden": false,
+       "label": "Model Selection",
+       "model_id": "d90f6d906955444e9abf735d40442d91",
+       "url_key": "",
+       "value": "random_forest",
+       "widget": "Select"
+      },
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d90f6d906955444e9abf735d40442d91",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "mercury.Select"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "------------------------------------------\n",
+      "FEATURE REMOVAL\n",
+      "Shape of the dataframe is:  (1175, 590)\n",
+      "the number of columns dropped due to duplications is:  104\n",
+      "the number of columns dropped due to missing values is:  28\n",
+      "the number of columns dropped due to low variance is:  189\n",
+      "the number of columns dropped due to high correlation is:  90\n",
+      "Total number of columns to be dropped is:  411\n",
+      "New shape of the dataframe is:  (1175, 179)\n",
+      "<class 'list'>\n",
+      "------------------------------------------\n",
+      "OUTLIER REMOVAL\n",
+      "The z-score threshold is: 5\n",
+      "The number of outliers removed from the dataset is: 163\n",
+      "<class 'pandas.core.frame.DataFrame'>\n",
+      "------------------------------------------\n",
+      "SCALING THE DATAFRAME\n",
+      "The dataframe has been scaled using the standard scaling model\n",
+      "------------------------------------------\n",
+      "SCALING THE DATAFRAME\n",
+      "The dataframe has been scaled using the standard scaling model\n",
+      "------------------------------------------\n",
+      "IMPUTATION PROCESS\n",
+      "Number of missing values before imputation:  3380\n",
+      "median imputation has been applied\n",
+      "Number of missing values after imputation:  0\n",
+      "------------------------------------------\n",
+      "IMPUTATION PROCESS\n",
+      "Number of missing values before imputation:  1196\n",
+      "median imputation has been applied\n",
+      "Number of missing values after imputation:  0\n",
+      "------------------------------------------\n",
+      "FEATURE SELECTION\n",
+      "Selected method is:  lasso\n",
+      "Shape of the training set after feature selection with LassoCV:  (1175, 14)\n",
+      "------------------------------------------\n",
+      "IMBALANCE TREATMENT\n",
+      "Shape of the training set after oversampling with SMOTE:  (2194, 14)\n",
+      "Value counts of the target variable after oversampling with SMOTE: \n",
+      " pass/fail\n",
+      "0            1097\n",
+      "1            1097\n",
+      "dtype: int64\n"
+     ]
+    }
+   ],
+   "source": [
+    "# input train and test sets\n",
+    "input_train_set = X_train\n",
+    "input_test_set = X_test\n",
+    "\n",
+    "# Start widget section\n",
+    "\n",
+    "input_drop_duplicates = 'yes'\n",
+    "input_missing_values_threshold =  mr.Text(label=\"Missing Value Threeshold\", value='50')\n",
+    "input_missing_values_threshold = int(input_missing_values_threshold.value)\n",
+    "\n",
+    "input_variance_threshold = mr.Text(label=\"Variance Threshold\", value='0.05')          # \n",
+    "input_variance_threshold = float(input_variance_threshold.value)\n",
+    "\n",
+    "input_correlation_threshold = mr.Text(label=\"Correlation Threshold\", value='0.95')       # \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=5, choices=['none', 3, 4, 5])      # 'none' or zscore from 0 to 100\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=\"standard\", 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=\"median\", 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",
+    "# import feature selection variables\n",
+    "input_feature_selection = mr.Select(label=\"Feature Selection\", value=\"lasso\", 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=\"smote\", choices=['none', 'smote', 'undersampling', 'rose'])       # 'none', 'smote', 'undersampling', 'rose'\n",
+    "input_imbalance_treatment = str(input_imbalance_treatment.value)\n",
+    "\n",
+    "# input model\n",
+    "input_model = mr.Select(label=\"Model Selection\", value=\"random_forest\", choices=['random_forest', 'logistic_regression', 'knn', 'svm', 'naive_bayes','decision_tree','xgboost'])\n",
+    "input_model = str(input_model.value)\n",
+    "\n",
+    "# remove features using the function list_columns_to_drop\n",
+    "\n",
+    "dropped = columns_to_drop(input_train_set, input_drop_duplicates, input_missing_values_threshold, 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",
+    "\n",
+    "# remove outliers from train dataset\n",
+    "\n",
+    "X_train_dropped_outliers = outlier_removal(X_train2, input_outlier_removal_threshold)\n",
+    "\n",
+    "# scale the training and testing sets\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 features\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",
+    "# 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_selected, y_test)\n",
+    "y_pred_logistic_regression = train_model('logistic_regression', X_train_res, y_train_res, X_test_selected, y_test)\n",
+    "y_pred_knn = train_model('knn', X_train_res, y_train_res, X_test_selected, y_test)\n",
+    "y_pred_svm = train_model('svm', X_train_res, y_train_res, X_test_selected, y_test)\n",
+    "y_pred_naive_bayes = train_model('naive_bayes', X_train_res, y_train_res, X_test_selected, y_test)\n",
+    "y_pred_decision_tree = train_model('decision_tree', X_train_res, y_train_res, X_test_selected, y_test)\n",
+    "y_pred_xgboost = train_model('xgboost', X_train_res, y_train_res, X_test_selected, y_test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 113,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--------------------------------------------------\n"
+     ]
+    },
+    {
+     "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",
+       "      <th>drop duplicates</th>\n",
+       "      <th>missing values th</th>\n",
+       "      <th>variance th</th>\n",
+       "      <th>correlation th</th>\n",
+       "      <th>outlier removal th</th>\n",
+       "      <th>scaling method</th>\n",
+       "      <th>imputation method</th>\n",
+       "      <th>feature selection</th>\n",
+       "      <th>imbalance treatment</th>\n",
+       "      <th>model_variables</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>random_forest</td>\n",
+       "      <td>344</td>\n",
+       "      <td>22</td>\n",
+       "      <td>22</td>\n",
+       "      <td>4</td>\n",
+       "      <td>yes</td>\n",
+       "      <td>50</td>\n",
+       "      <td>0.05</td>\n",
+       "      <td>0.95</td>\n",
+       "      <td>5</td>\n",
+       "      <td>standard</td>\n",
+       "      <td>median</td>\n",
+       "      <td>lasso</td>\n",
+       "      <td>smote</td>\n",
+       "      <td>yes_50_0.05_0.95_5_standard_median_lasso_smote</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "           Model  True Negatives  False Positives  False Negatives  \\\n",
+       "0  random_forest             344               22               22   \n",
+       "\n",
+       "   True Positives drop duplicates  missing values th  variance th  \\\n",
+       "0               4             yes                 50         0.05   \n",
+       "\n",
+       "   correlation th  outlier removal th scaling method imputation method  \\\n",
+       "0            0.95                   5       standard            median   \n",
+       "\n",
+       "  feature selection imbalance treatment  \\\n",
+       "0             lasso               smote   \n",
+       "\n",
+       "                                  model_variables  \n",
+       "0  yes_50_0.05_0.95_5_standard_median_lasso_smote  "
+      ]
+     },
+     "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>Accuracy</th>\n",
+       "      <th>Precision</th>\n",
+       "      <th>Recall</th>\n",
+       "      <th>F1-score</th>\n",
+       "      <th>drop duplicates</th>\n",
+       "      <th>missing values th</th>\n",
+       "      <th>variance th</th>\n",
+       "      <th>correlation th</th>\n",
+       "      <th>outlier removal th</th>\n",
+       "      <th>scaling method</th>\n",
+       "      <th>imputation method</th>\n",
+       "      <th>feature selection</th>\n",
+       "      <th>imbalance treatment</th>\n",
+       "      <th>model_variables</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>random_forest</td>\n",
+       "      <td>0.89</td>\n",
+       "      <td>0.15</td>\n",
+       "      <td>0.15</td>\n",
+       "      <td>0.15</td>\n",
+       "      <td>yes</td>\n",
+       "      <td>50</td>\n",
+       "      <td>0.05</td>\n",
+       "      <td>0.95</td>\n",
+       "      <td>5</td>\n",
+       "      <td>standard</td>\n",
+       "      <td>median</td>\n",
+       "      <td>lasso</td>\n",
+       "      <td>smote</td>\n",
+       "      <td>yes_50_0.05_0.95_5_standard_median_lasso_smote</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "           Model  Accuracy  Precision  Recall  F1-score drop duplicates  \\\n",
+       "0  random_forest      0.89       0.15    0.15      0.15             yes   \n",
+       "\n",
+       "   missing values th  variance th  correlation th  outlier removal th  \\\n",
+       "0                 50         0.05            0.95                   5   \n",
+       "\n",
+       "  scaling method imputation method feature selection imbalance treatment  \\\n",
+       "0       standard            median             lasso               smote   \n",
+       "\n",
+       "                                  model_variables  \n",
+       "0  yes_50_0.05_0.95_5_standard_median_lasso_smote  "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "evaluation_score_output, evaluation_counts_output = evaluate_models(input_model)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "skip"
+    }
+   },
+   "source": [
+    "#### **Confusion Matrix**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 125,
+   "metadata": {},
+   "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>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>0.89</td>\n",
+       "      <td>0.15</td>\n",
+       "      <td>0.15</td>\n",
+       "      <td>0.15</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   Accuracy  Precision  Recall  F1-score\n",
+       "0      0.89       0.15    0.15      0.15"
+      ]
+     },
+     "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": [
+    "# create a np.array with selected_model values\n",
+    "\n",
+    "conf_matrix = np.array([[evaluation_counts_output['True Negatives'].values[0], evaluation_counts_output['False Positives'].values[0]],\n",
+    "                [evaluation_counts_output['False Negatives'].values[0], evaluation_counts_output['True Positives'].values[0]]])\n",
+    "\n",
+    "fig, ax = plot_confusion_matrix(\n",
+    "    conf_mat=conf_matrix,\n",
+    "    show_absolute=True,\n",
+    "    show_normed=True\n",
+    ")\n",
+    "\n",
+    "display(evaluation_score_output[['Accuracy', 'Precision', 'Recall', 'F1-score']])"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "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"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}