Upload 16 files

encoder.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f931d3e82fc7ab6868eb41036e2c84c14dc0efb7920b70d0a0a547f7e4975155
+size 1604

gda.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1062eb7b2283f57c001ad6546390ac969fec7aa91d55182947db1307887cc256
+size 3224

health_status_classification.ipynb

@@ -0,0 +1,569 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "7abd29b8",
+   "metadata": {},
+   "source": [
+    "# Health Status Classification\n",
+    "\n",
+    "This notebook classifies individuals into \"Healthy\" or \"Patient\" categories using SVM and Random Forest classifiers. It includes:\n",
+    "- Data preprocessing\n",
+    "- Training of classifiers\n",
+    "- Comparison of performance metrics\n",
+    "- Visualization of results\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "299604b4",
+   "metadata": {},
+   "source": [
+    "## Data Preprocessing"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "22ee7ce2",
+   "metadata": {},
+   "source": [
+    "### 1. Import Dependecies"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 252,
+   "id": "76a44a0d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.preprocessing import StandardScaler, LabelEncoder\n",
+    "from sklearn.svm import SVC\n",
+    "from sklearn.ensemble import RandomForestClassifier\n",
+    "from sklearn.metrics import classification_report, confusion_matrix, accuracy_score\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a27c6dc7",
+   "metadata": {},
+   "source": [
+    "### 2. Load Dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 253,
+   "id": "3772870e",
+   "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>Patient No.</th>\n",
+       "      <th>Gender</th>\n",
+       "      <th>Age</th>\n",
+       "      <th>Family history</th>\n",
+       "      <th>Height</th>\n",
+       "      <th>Weight</th>\n",
+       "      <th>BMI</th>\n",
+       "      <th>Obese/non obese</th>\n",
+       "      <th>Cholesterol</th>\n",
+       "      <th>Triglycerides level</th>\n",
+       "      <th>HDL level</th>\n",
+       "      <th>LDL level</th>\n",
+       "      <th>VLDL level</th>\n",
+       "      <th>Health_status</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1</td>\n",
+       "      <td>Female</td>\n",
+       "      <td>65</td>\n",
+       "      <td>No</td>\n",
+       "      <td>1.64</td>\n",
+       "      <td>64</td>\n",
+       "      <td>23.80</td>\n",
+       "      <td>Non-obese</td>\n",
+       "      <td>145</td>\n",
+       "      <td>119</td>\n",
+       "      <td>60</td>\n",
+       "      <td>66.0</td>\n",
+       "      <td>19.0</td>\n",
+       "      <td>healthy</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2</td>\n",
+       "      <td>Female</td>\n",
+       "      <td>50</td>\n",
+       "      <td>Yes</td>\n",
+       "      <td>1.70</td>\n",
+       "      <td>70</td>\n",
+       "      <td>24.22</td>\n",
+       "      <td>Non-obese</td>\n",
+       "      <td>220</td>\n",
+       "      <td>107</td>\n",
+       "      <td>69</td>\n",
+       "      <td>134.0</td>\n",
+       "      <td>17.0</td>\n",
+       "      <td>healthy</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>3</td>\n",
+       "      <td>Female</td>\n",
+       "      <td>45</td>\n",
+       "      <td>No</td>\n",
+       "      <td>1.67</td>\n",
+       "      <td>63</td>\n",
+       "      <td>22.59</td>\n",
+       "      <td>Non-obese</td>\n",
+       "      <td>190</td>\n",
+       "      <td>251</td>\n",
+       "      <td>42</td>\n",
+       "      <td>108.0</td>\n",
+       "      <td>40.0</td>\n",
+       "      <td>healthy</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>4</td>\n",
+       "      <td>Female</td>\n",
+       "      <td>48</td>\n",
+       "      <td>No</td>\n",
+       "      <td>1.61</td>\n",
+       "      <td>79</td>\n",
+       "      <td>30.48</td>\n",
+       "      <td>Obese</td>\n",
+       "      <td>228</td>\n",
+       "      <td>185</td>\n",
+       "      <td>65</td>\n",
+       "      <td>134.0</td>\n",
+       "      <td>29.0</td>\n",
+       "      <td>healthy</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>5</td>\n",
+       "      <td>Male</td>\n",
+       "      <td>74</td>\n",
+       "      <td>No</td>\n",
+       "      <td>1.76</td>\n",
+       "      <td>83</td>\n",
+       "      <td>26.79</td>\n",
+       "      <td>Non-obese</td>\n",
+       "      <td>157</td>\n",
+       "      <td>113</td>\n",
+       "      <td>49</td>\n",
+       "      <td>90.0</td>\n",
+       "      <td>18.0</td>\n",
+       "      <td>healthy</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   Patient No.  Gender  Age Family history  Height  Weight    BMI  \\\n",
+       "0            1  Female   65             No    1.64      64  23.80   \n",
+       "1            2  Female   50            Yes    1.70      70  24.22   \n",
+       "2            3  Female   45             No    1.67      63  22.59   \n",
+       "3            4  Female   48             No    1.61      79  30.48   \n",
+       "4            5    Male   74             No    1.76      83  26.79   \n",
+       "\n",
+       "  Obese/non obese  Cholesterol  Triglycerides level  HDL level  LDL level  \\\n",
+       "0       Non-obese          145                  119         60       66.0   \n",
+       "1       Non-obese          220                  107         69      134.0   \n",
+       "2       Non-obese          190                  251         42      108.0   \n",
+       "3           Obese          228                  185         65      134.0   \n",
+       "4       Non-obese          157                  113         49       90.0   \n",
+       "\n",
+       "   VLDL level Health_status  \n",
+       "0        19.0       healthy  \n",
+       "1        17.0       healthy  \n",
+       "2        40.0       healthy  \n",
+       "3        29.0       healthy  \n",
+       "4        18.0       healthy  "
+      ]
+     },
+     "execution_count": 253,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Load dataset\n",
+    "data = pd.read_excel(r'colelithiasis_dataset.xlsx')\n",
+    "data.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "7edf91ac",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<class 'pandas.core.frame.DataFrame'>\n",
+      "RangeIndex: 100 entries, 0 to 99\n",
+      "Data columns (total 14 columns):\n",
+      " #   Column               Non-Null Count  Dtype  \n",
+      "---  ------               --------------  -----  \n",
+      " 0   Patient No.          100 non-null    int64  \n",
+      " 1   Gender               100 non-null    object \n",
+      " 2   Age                  100 non-null    int64  \n",
+      " 3   Family history       100 non-null    object \n",
+      " 4   Height               100 non-null    float64\n",
+      " 5   Weight               100 non-null    int64  \n",
+      " 6   BMI                  100 non-null    float64\n",
+      " 7   Obese/non obese      100 non-null    object \n",
+      " 8   Cholesterol          100 non-null    int64  \n",
+      " 9   Triglycerides level  100 non-null    int64  \n",
+      " 10  HDL level            100 non-null    int64  \n",
+      " 11  LDL level            100 non-null    float64\n",
+      " 12  VLDL level           100 non-null    float64\n",
+      " 13  Health_status        100 non-null    object \n",
+      "dtypes: float64(4), int64(6), object(4)\n",
+      "memory usage: 11.1+ KB\n"
+     ]
+    }
+   ],
+   "source": [
+    "data.info()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "aae142a0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Health_status\n",
+       "patient    60\n",
+       "healthy    40\n",
+       "Name: count, dtype: int64"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "data['Health_status'].value_counts()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "aafe0526",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Drop unnecessary columns (e.g., Patient No.)\n",
+    "data = data.drop(columns=['Patient No.'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c7907326",
+   "metadata": {},
+   "source": [
+    "### 3. Feature Encoding"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "7f22b9a6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Encode categorical variables\n",
+    "le_health_status = LabelEncoder()\n",
+    "data['Health_status'] = le_health_status.fit_transform(data['Health_status']) # 0 for healthy, 1 for patient\n",
+    "le_gender = LabelEncoder()\n",
+    "data['Gender'] = le_gender.fit_transform(data['Gender']) # 0 for Female, 1 for Male\n",
+    "le_family_history = LabelEncoder()\n",
+    "data['Family history'] = le_family_history.fit_transform(data['Family history']) # 0 for No, 1 for Yes\n",
+    "le_obese = LabelEncoder()\n",
+    "data['Obese/non obese'] = le_obese.fit_transform(data['Obese/non obese']) # 0 for Non-obese, 1 for Obese"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bcf93f5f",
+   "metadata": {},
+   "source": [
+    "### 4. Split features and target"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "eab4be22",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Features and target\n",
+    "X = data.drop(columns=['Health_status'])\n",
+    "y = data['Health_status']\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c5ed059c",
+   "metadata": {},
+   "source": [
+    "### 5. Split data into training and testing sets"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 244,
+   "id": "cdeca4f2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Split the data\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0558f2c8",
+   "metadata": {},
+   "source": [
+    "### 6. Scalling the features"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 245,
+   "id": "a037923f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Scale the features using StandardScaler\n",
+    "scaler = StandardScaler()\n",
+    "X_train = scaler.fit_transform(X_train)\n",
+    "X_test = scaler.transform(X_test)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d934c22c",
+   "metadata": {},
+   "source": [
+    "## Training of classifiers"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c7fd1e71",
+   "metadata": {},
+   "source": [
+    "### 1. Support Vector Machine (SVM)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 246,
+   "id": "aca26b71",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# SVM Classifier\n",
+    "svm_model = SVC(kernel='linear', C=0.9, random_state=42)\n",
+    "svm_model.fit(X_train, y_train)\n",
+    "svm_preds = svm_model.predict(X_test)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e8bfefa5",
+   "metadata": {},
+   "source": [
+    "### 2. Random Forest Classifier"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 247,
+   "id": "a5ad9d40",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Random Forest Classifier\n",
+    "rf_model = RandomForestClassifier(n_estimators=100, class_weight='balanced', random_state=42)\n",
+    "rf_model.fit(X_train, y_train)\n",
+    "rf_preds = rf_model.predict(X_test)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e3fb4a5a",
+   "metadata": {},
+   "source": [
+    "## Comparison of performance metrics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 249,
+   "id": "2ddc5b12",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Performance Metrics for SVM\n",
+      "Accuracy: 0.65\n",
+      "\n",
+      "Classification Report:\n",
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.55      0.75      0.63         8\n",
+      "           1       0.78      0.58      0.67        12\n",
+      "\n",
+      "    accuracy                           0.65        20\n",
+      "   macro avg       0.66      0.67      0.65        20\n",
+      "weighted avg       0.68      0.65      0.65        20\n",
+      "\n",
+      "\n",
+      "Performance Metrics for Random Forest\n",
+      "Accuracy: 0.7\n",
+      "\n",
+      "Classification Report:\n",
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.60      0.75      0.67         8\n",
+      "           1       0.80      0.67      0.73        12\n",
+      "\n",
+      "    accuracy                           0.70        20\n",
+      "   macro avg       0.70      0.71      0.70        20\n",
+      "weighted avg       0.72      0.70      0.70        20\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "def print_metrics(y_true, y_pred, model_name):\n",
+    "    print(f\"\\nPerformance Metrics for {model_name}\")\n",
+    "    print(\"Accuracy:\", accuracy_score(y_true, y_pred))\n",
+    "    print(\"\\nClassification Report:\")\n",
+    "    print(classification_report(y_true, y_pred))\n",
+    "\n",
+    "print_metrics(y_test, svm_preds, \"SVM\")\n",
+    "print_metrics(y_test, rf_preds, \"Random Forest\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "38eefbb6",
+   "metadata": {},
+   "source": [
+    "## Visualization of results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 251,
+   "id": "f74a2f74",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x500 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Confusion Matrices\n",
+    "svm_cm = confusion_matrix(y_test, svm_preds)\n",
+    "rf_cm = confusion_matrix(y_test, rf_preds)\n",
+    "\n",
+    "fig, axes = plt.subplots(1, 2, figsize=(12, 5))\n",
+    "sns.heatmap(svm_cm, annot=True, fmt='d', cmap='Blues', ax=axes[0])\n",
+    "axes[0].set_title('SVM Confusion Matrix')\n",
+    "axes[0].set_xlabel('Predicted')\n",
+    "axes[0].set_ylabel('Actual')\n",
+    "\n",
+    "sns.heatmap(rf_cm, annot=True, fmt='d', cmap='Greens', ax=axes[1])\n",
+    "axes[1].set_title('Random Forest Confusion Matrix')\n",
+    "axes[1].set_xlabel('Predicted')\n",
+    "axes[1].set_ylabel('Actual')\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3a2c284f",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "ml_env",
+   "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.13.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

lr_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3afb60ab51259121d4188b2e23fa705e3f6c100a4965e4769e0812d36677d3b6
+size 1391

main.py

@@ -0,0 +1,314 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+import joblib
+from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
+from plotly import graph_objects as go
+
+st.set_page_config(layout="wide")
+
+# Load Dataset
+def load_data():
+    data = pd.read_excel(r'Model Training/colelithiasis_dataset.xlsx')  # Update with your dataset file path
+    data.drop('Patient No.', axis=1, inplace=True)
+    return data
+
+# Initialize Session State
+if "data" not in st.session_state:
+    st.session_state.data = load_data()
+
+def introduction_page():
+    st.title("Introduction")
+    st.markdown("""
+    ## Project Overview
+    This project analyzes the Colelithiasis dataset to perform exploratory data analysis (EDA) and prediction using pre-trained machine learning models. The goal is to provide insights into the data and make predictions efficiently.
+
+    ## Objectives
+    - Perform EDA to uncover patterns and insights.
+    - Use pre-trained machine learning models for predictions.
+    - Create an interactive Streamlit application.
+    """)
+
+def stats_page():
+    st.title("Exploratory Data Analysis")
+
+    # Dataset Overview
+    st.subheader("Dataset Overview")
+    st.dataframe(st.session_state.data.head())
+
+    # Summary Statistics
+    st.subheader("Summary Statistics")
+    st.write(st.session_state.data.describe())
+
+    # Correlation Matrix
+    st.subheader("Correlation Analysis")
+
+    # encode the target variable
+    data = st.session_state.data.copy()
+    data['Health_status'].replace({'healthy': 0, 'patient': 1}, inplace=True)
+
+    # apply ordinal encoding to the categorical columns
+    categorical_columns = ['Gender','Family history','Obese/non obese']
+    encoder = joblib.load('Model Training\encoder.pkl')
+    data[categorical_columns] = encoder.transform(data[categorical_columns])
+    
+    correlation = data.corr()
+    plt.figure(figsize=(5, 3))
+    # reduce the font size of the heatmap
+    sns.set(font_scale=0.5)
+    sns.heatmap(correlation, annot=True, cmap="coolwarm", fmt=".2f")
+    st.pyplot(plt, use_container_width=False)
+
+def eda_page():
+    st.title("Exploratory Data Analysis")
+
+    # Interactive Visualizations
+    st.subheader("Visualizations")
+    chart_type = st.selectbox("Choose Chart Type", ["Histogram", "Scatter Plot", "Box Plot"])
+
+    if chart_type == "Histogram":
+        column = st.selectbox("Choose Column for Visualization", st.session_state.data.columns)
+        fig = go.Figure()
+        fig.add_trace(go.Histogram(x=st.session_state.data[column], name=column, marker_color="indigo"))
+        fig.update_layout(
+            title=dict(text="Histogram Analysis", x=0.5, font=dict(size=22)),
+            xaxis_title=column,
+            yaxis_title="Count",
+            legend=dict(title="Legend", orientation="h", x=0.5, xanchor="center"),
+            bargap=0.2,
+            hovermode="x unified",
+            template="plotly_dark"
+        )
+        st.plotly_chart(fig)
+
+    elif chart_type == "Scatter Plot":
+        x_col = st.selectbox("Choose X-axis Column", st.session_state.data.columns)
+        y_col = st.selectbox("Choose Y-axis Column", st.session_state.data.columns)
+        fig = go.Figure()
+        fig.add_trace(go.Scatter(
+            x=st.session_state.data[x_col],
+            y=st.session_state.data[y_col],
+            mode="markers",
+            marker=dict(size=10, color="purple", line=dict(width=1, color="white")),
+            name=f"{y_col} vs {x_col}"
+        ))
+        fig.update_layout(
+            title=dict(text="Scatter Plot Analysis", x=0.5, font=dict(size=22)),
+            xaxis_title=x_col,
+            yaxis_title=y_col,
+            legend=dict(title="Legend", orientation="h", x=0.5, xanchor="center"),
+            hovermode="closest",
+            template="plotly_dark"
+        )
+        st.plotly_chart(fig)
+
+    elif chart_type == "Box Plot":
+        column = st.selectbox("Choose Column for Visualization", st.session_state.data.columns)
+        fig = go.Figure()
+        fig.add_trace(go.Box(
+            y=st.session_state.data[column],
+            name=column,
+            boxmean="sd",
+            marker_color="teal"
+        ))
+        fig.update_layout(
+            title=dict(text="Boxplot Analysis", x=0.5, font=dict(size=22)),
+            yaxis_title=column,
+            legend=dict(title="Legend", orientation="h", x=0.5, xanchor="center"),
+            hovermode="y",
+            template="plotly_dark"
+        )
+        st.plotly_chart(fig)
+
+
+def model_page():
+    st.title("Model Evaluation")
+    test_data = pd.read_excel(r'Model Training\test_data.xlsx')  
+
+
+    # encode the target variable
+    test_data['Health_status'].replace({'healthy': 0, 'patient': 1}, inplace=True)
+
+    # apply ordinal encoding to the categorical columns
+    categorical_columns = ['Gender','Family history','Obese/non obese']
+    encoder = joblib.load('Model Training\encoder.pkl')
+
+    X = test_data.drop( columns=['Health_status'])
+    X[categorical_columns] = encoder.transform(X[categorical_columns])
+    y = test_data['Health_status']
+
+    # apply standard scalling to numberical features in X
+    numerical_columns = [col_name for col_name in X.columns if col_name not in categorical_columns]
+    scaler = joblib.load('Model Training\scaler.pkl')  
+    X[numerical_columns] = scaler.transform(X[numerical_columns])
+
+    # Model Selection
+    st.text("Model Selection")
+    model_choice = st.selectbox("Choose a Pre-trained Model", ["SVM - Linear", "SVM - Polynomial", "SVM - RBF",
+                                                                 "Random Forest","Random Forest Boosted", "Logistic Regression", "GDA"])
+ 
+    # Load pre-trained model
+    model = None
+    if model_choice == "SVM - Linear":
+        model = joblib.load('Model Training\svm_model_linear.pkl')
+    elif model_choice == "SVM - Polynomial":
+        model = joblib.load('Model Training\svm_model_poly.pkl')
+    elif model_choice == "SVM - RBF":
+        model = joblib.load('Model Training\svm_model_rbf.pkl')
+    elif model_choice == "Random Forest":
+        model = joblib.load('Model Training\rf_model.pkl')
+    elif model_choice == "Random Forest Boosted":
+        model = joblib.load('Model Training\rf_boosted.pkl')
+    elif model_choice == "Logistic Regression":
+        model = joblib.load('Model Training\lr_model.pkl')
+    elif model_choice == "GDA":
+        model = joblib.load('Model Training\gda.pkl')
+
+
+    if model:
+        # Make Predictions
+        y_pred = model.predict(X)
+        col1, col2 = st.columns(2)
+        with col1:
+            st.subheader("### Predictions on the Test Data:")
+            st.dataframe(pd.DataFrame({"Actual": y, "Predicted": y_pred}))
+
+        with col2:
+            st.subheader("Classification Report")
+            report = classification_report(y, y_pred, output_dict=True)
+            report_df = pd.DataFrame(report).transpose().reset_index()
+            report_df.drop('support', axis=1, inplace=True)
+            report_df.set_index(['index'], inplace=True)
+            report_df.rename(index={'0.0': 'Negative', '1.0': 'Positive'}, inplace=True)
+            report_df.iloc[report_df.index.get_loc('accuracy'), 0:2] = ''
+            st.table(report_df)
+
+        st.subheader("Confusion Matrix")
+        conf_matrix = confusion_matrix(y, y_pred)
+        # Generate text annotations for the confusion matrix
+        text_annotations = np.array([[str(value) for value in row] for row in conf_matrix])
+
+        col1, col2 = st.columns(2)
+        with col1:
+            # Create the heatmap using seaborn
+            plt.figure(figsize=(3 , 3))
+            sns.heatmap(conf_matrix, annot=text_annotations, fmt="", cmap="Blues", cbar=False, square=True)
+            plt.xlabel("Predicted")
+            plt.ylabel("Actual")
+            plt.title("Confusion Matrix")
+            st.pyplot(plt)
+
+ 
+def prediction_page():
+    st.title("Get Your Diagnosis")
+    st.subheader("Symptoms Entry Form")
+    # Model Selection
+    model_choice = st.selectbox("Choose a Pre-trained Model", ["SVM - Linear", "SVM - Polynomial", "SVM - RBF",
+                                                                "Random Forest","Random Forest Boosted", "Logistic Regression", "GDA"])
+
+    # Load pre-trained model
+    model = None
+    if model_choice == "SVM - Linear":
+        model = joblib.load('Model Training\svm_model_linear.pkl')
+    elif model_choice == "SVM - Polynomial":
+        model = joblib.load('Model Training\svm_model_poly.pkl')
+    elif model_choice == "SVM - RBF":
+        model = joblib.load('Model Training\svm_model_rbf.pkl')
+    elif model_choice == "Random Forest":
+        model = joblib.load('Model Training\rf_model.pkl')
+    elif model_choice == "Random Forest Boosted":
+        model = joblib.load('Model Training\rf_boosted.pkl')
+    elif model_choice == "Logistic Regression":
+        model = joblib.load('Model Training\lr_model.pkl')
+    elif model_choice == "GDA":
+        model = joblib.load('Model Training\gda.pkl')
+
+    with st.form(key="health_data_form"):
+        col1, col2, col3, col4 = st.columns(4)
+
+        with col1:
+            # Categorical features with dropdown selection
+            gender = st.selectbox("Gender", ["Male", "Female"], key="gender")
+            weight = st.number_input("Weight (kg)", min_value=0, step=1, key="weight")
+            cholesterol = st.number_input("Cholesterol (mg/dL)", min_value=0, step=1, key="cholesterol")
+        with col2:
+            family_history = st.selectbox("Family History of Illness", ["Yes", "No"], key="family_history")
+            bmi = st.number_input("BMI", min_value=0.0, step=0.1, key="bmi")
+            triglycerides = st.number_input("Triglycerides Level (mg/dL)", min_value=0, step=1, key="triglycerides")
+            
+        with col3:
+            height = st.number_input("Height (cm)", min_value=0.0, step=0.1, key="height")
+            obese_status = st.selectbox("Obese/Non Obese", ["Obese", "Non-Obese"], key="obese_status")
+            ldl = st.number_input("LDL Level (mg/dL)", min_value=0.0, step=0.1, key="ldl")
+
+        with col4:
+            vldl = st.number_input("VLDL Level (mg/dL)", min_value=0.0, step=0.1, key="vldl")
+
+
+        
+        # Submit button
+        submit_button = st.form_submit_button(label="Submit" )
+
+    if submit_button:
+        # Create a DataFrame directly with the user input data
+        data = pd.DataFrame({
+            "Gender": [gender],
+            "Family history": [family_history],
+            "Height": [height],
+            "Weight": [weight],
+            "BMI": [bmi],
+            "Obese/non obese": [obese_status],
+            "Cholesterol": [cholesterol],
+            "Triglycerides": [triglycerides],
+            "LDL level": [ldl],
+            "VLDL level": [vldl]
+        })
+        
+
+        columns = ['Gender', 'Family history', 'Height', 'Weight', 'BMI', 'Obese/non obese', 'Cholesterol', 'Triglycerides level', 'LDL level', 'VLDL level']
+        data = data.reindex(columns=columns, fill_value=0)
+        
+        categorical_columns = ['Gender','Family history','Obese/non obese']
+        numerical_columns = [col_name for col_name in data.columns if col_name not in categorical_columns]
+        # Encoding categorical data
+        encoder = joblib.load('Model Training\encoder.pkl')  
+        data[categorical_columns] = encoder.transform(data[categorical_columns])
+
+        # Scaling the numeric features
+        scaler = joblib.load('Model Training\scaler.pkl')
+        data[numerical_columns] = scaler.transform(data[numerical_columns])
+
+    
+        
+        prediction = int(model.predict(data)[0])
+        st.write(f"### Predicted Diagnosis: {'Positive' if prediction == 1 else 'Negative'}")
+        
+
+def conclusion_page():
+    st.title("Conclusion")
+    st.markdown("""
+    ## Key Takeaways
+    - Comprehensive EDA provides actionable insights into the data.
+    - Pre-trained machine learning models allow efficient predictions.
+    - The interactive app makes the analysis accessible and engaging.
+
+    Thank you for exploring this project!
+    """)
+
+# Sidebar Navigation Menu with radio buttons for page selection
+page = st.sidebar.radio("Navigation Menu", ["Introduction","Descriptive Statistics", "Data Analytics", "Model Evaluation", "Get Your Diagnosis", "Conclusion"])
+
+if page == "Introduction":
+    introduction_page()
+elif page == "Descriptive Statistics":
+    stats_page()
+elif page == "Data Analytics":
+    eda_page()
+elif page == "Model Evaluation":
+    model_page()
+elif page == "Get Your Diagnosis":
+    prediction_page()
+elif page == "Conclusion":
+    conclusion_page()

rf_boosted.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5bcff453f23629ac8c235105320385407489a939858ec303db312ebb934f704e
+size 179112

rf_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:994d9d2dbee5adf22ee6434a0a778a0dae2f37c4883e414948a9b3fed3f53482
+size 562377

scaler.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:125d5da89197d1212608fa958179f4601f9e98f7efe03640a72cbbd33ecc84e1
+size 1183

svm_model_linear.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7636d9a64fcdc959b7d3d614e7d2567c4da70539e6147558dbedf8159b0ef637
+size 9611

svm_model_poly.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1dcb91962b964f4d63a0acefbe2842d3d72af04c54e2c8a9341bea9688b9e027
+size 8203

svm_model_rbf.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ddd0af20c80ecad7f8770169f9c8ba98aecf7271b20eddd5ca5d838a04edfecc
+size 9019