Upload P2 - Secom Notebook - Mercury.ipynb

P2 - Secom Notebook - Mercury.ipynb

@@ -0,0 +1,1434 @@
+{
+ "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": 2,
+   "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 scipy import stats\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "import mercury as mr"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "skip"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/mercury+json": {
+       "allow_download": true,
+       "code_uid": "App.0.40.24.1-rande8c4e67c",
+       "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": 4,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "skip"
+    }
+   },
+   "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 = '..\\Dataset\\secom_data.csv'\n",
+    "url_labels = '..\\Dataset\\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": 5,
+   "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": 6,
+   "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": 7,
+   "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": 8,
+   "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": 9,
+   "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": [
+    "#### **Imbalance Treatment**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "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",
+    "        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 = '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",
+    "        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": 11,
+   "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": 12,
+   "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='all'):\n",
+    "    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('What is the correlation threshold?', correlation_threshold_var)\n",
+    "    print('What is the outlier removal threshold?', outlier_var)\n",
+    "    print('What is the scaling method?', scale_model_var)\n",
+    "    print('What is the imputation method?', imputation_var) \n",
+    "    print('What is the imbalance treatment?', imbalance_var)\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": 14,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "skip"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/mercury+json": {
+       "choices": [
+        "yes",
+        "no"
+       ],
+       "code_uid": "Select.0.40.16.25-rand036599f5",
+       "disabled": false,
+       "hidden": false,
+       "label": "Drop Duplicates",
+       "model_id": "5fecbac257a74b428ee00725045f2f1a",
+       "url_key": "",
+       "value": "yes",
+       "widget": "Select"
+      },
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "5fecbac257a74b428ee00725045f2f1a",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "mercury.Select"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/mercury+json": {
+       "code_uid": "Slider.0.40.26.28-rand8662cf24",
+       "disabled": false,
+       "hidden": false,
+       "label": "Missing Value Threeshold",
+       "max": 100,
+       "min": 0,
+       "model_id": "6a2670f9135442b0bc97dc794af3af46",
+       "step": 1,
+       "url_key": "",
+       "value": 80,
+       "widget": "Slider"
+      },
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "6a2670f9135442b0bc97dc794af3af46",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "mercury.Slider"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/mercury+json": {
+       "choices": [
+        0,
+        0.01,
+        0.05,
+        0.1
+       ],
+       "code_uid": "Select.0.40.16.31-rand1afeeedb",
+       "disabled": false,
+       "hidden": false,
+       "label": "Variance Threshold",
+       "model_id": "59ec4772499d416088166b4dba0a473d",
+       "url_key": "",
+       "value": 0,
+       "widget": "Select"
+      },
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "59ec4772499d416088166b4dba0a473d",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "mercury.Select"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/mercury+json": {
+       "choices": [
+        1,
+        0.95,
+        0.9,
+        0.8
+       ],
+       "code_uid": "Select.0.40.16.34-rand09f1eb56",
+       "disabled": false,
+       "hidden": false,
+       "label": "Correlation Threshold",
+       "model_id": "cdf52ecc5c7247f3bf67809ca9a76e06",
+       "url_key": "",
+       "value": 1,
+       "widget": "Select"
+      },
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "cdf52ecc5c7247f3bf67809ca9a76e06",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "mercury.Select"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/mercury+json": {
+       "choices": [
+        "none",
+        3,
+        4,
+        5
+       ],
+       "code_uid": "Select.0.40.16.38-rand12ce2c73",
+       "disabled": false,
+       "hidden": false,
+       "label": "Outlier Removal Threshold",
+       "model_id": "2bb20270437540978d58f2a176876560",
+       "url_key": "",
+       "value": "none",
+       "widget": "Select"
+      },
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2bb20270437540978d58f2a176876560",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "mercury.Select"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/mercury+json": {
+       "choices": [
+        "none",
+        "normal",
+        "standard",
+        "minmax",
+        "robust"
+       ],
+       "code_uid": "Select.0.40.16.46-rand3811f110",
+       "disabled": false,
+       "hidden": false,
+       "label": "Scaling Variables",
+       "model_id": "e42256d4973d4777b895e2d8dbf32294",
+       "url_key": "",
+       "value": "none",
+       "widget": "Select"
+      },
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "e42256d4973d4777b895e2d8dbf32294",
+       "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-rande797a66e",
+       "disabled": false,
+       "hidden": false,
+       "label": "Imputation Methods",
+       "model_id": "f0776e7846b54620b4a297e68b02c1d9",
+       "url_key": "",
+       "value": "mean",
+       "widget": "Select"
+      },
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f0776e7846b54620b4a297e68b02c1d9",
+       "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.55-randec8ea8f6",
+       "disabled": false,
+       "hidden": false,
+       "label": "Imbalance Treatment",
+       "model_id": "e314e975c8e347aabc4e43958d9fa498",
+       "url_key": "",
+       "value": "none",
+       "widget": "Select"
+      },
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "e314e975c8e347aabc4e43958d9fa498",
+       "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.60-rand7c34da2c",
+       "disabled": false,
+       "hidden": false,
+       "label": "Model Selection",
+       "model_id": "589c61ee60be41f9b72132986d3ea249",
+       "url_key": "",
+       "value": "random_forest",
+       "widget": "Select"
+      },
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "589c61ee60be41f9b72132986d3ea249",
+       "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.Slider(label=\"Missing Value Threeshold\", value=80, min=0, max=100)     # 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.Select(label=\"Variance Threshold\", value=0, choices=[0, 0.01, 0.05, 0.1])          # \n",
+    "input_variance_threshold = float(input_variance_threshold.value)\n",
+    "\n",
+    "input_correlation_threshold = mr.Select(label=\"Correlation Threshold\", value=1, choices=[1, 0.95, 0.9, 0.8])       # \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', 'normal', '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 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=\"random_forest\", 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": 15,
+   "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",
+      "Shape of the training set after no resampling:  (1175, 445)\n",
+      "Value counts of the target variable after no resampling: \n",
+      " pass/fail\n",
+      "0            1097\n",
+      "1              78\n",
+      "dtype: int64\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",
+    "# 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_imputed, y_train)\n",
+    "\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "skip"
+    }
+   },
+   "source": [
+    "### **Model Training**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "skip"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# disable warnings\n",
+    "\n",
+    "import warnings\n",
+    "warnings.filterwarnings('ignore')\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_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": 17,
+   "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",
+      "What is the correlation threshold? 1.0\n",
+      "What is the outlier removal threshold? none\n",
+      "What is the scaling method? none\n",
+      "What is the imputation method? mean\n",
+      "What is the imbalance treatment? none\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>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>random_forest</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  random_forest      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>random_forest</td>\n",
+       "      <td>366</td>\n",
+       "      <td>0</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  \\\n",
+       "0  random_forest             366                0               26   \n",
+       "\n",
+       "   True Positives  \n",
+       "0               0  "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 400x400 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'] = [4, 4]\n",
+    "\n",
+    "fig, ax = plot_confusion_matrix(\n",
+    "    conf_mat=conf_matrix,\n",
+    "    show_absolute=True,\n",
+    "    show_normed=True\n",
+    ")"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### **Plot Evaluation**"
+   ]
+  }
+ ],
+ "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
+}