dataset-analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f300768",
   "metadata": {},
   "outputs": [],
   "source": [
    "#import libraries and configuration\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.decomposition import PCA\n",
    "from datetime import datetime\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.metrics import classification_report, confusion_matrix\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from sklearn.neighbors import KNeighborsRegressor\n",
    "from sklearn.cluster import KMeans\n",
    "from sklearn import metrics\n",
    "\n",
    "from sklearn.model_selection import GridSearchCV, KFold\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Dropout\n",
    "from keras.wrappers.scikit_learn import KerasClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from keras.optimizers import Adam\n",
    "from tensorflow import keras\n",
    "\n",
    "import sys\n",
    "import warnings\n",
    "\n",
    "warnings.filterwarnings('ignore')\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "174d6b6f-ca99-45f7-9738-1260c7fbd6aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "#retrieve data\n",
    "df = pd.read_csv('latestdata2.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c1dc1245-a8b0-4003-9f22-85aace2b6917",
   "metadata": {},
   "outputs": [],
   "source": [
    "#check the number of rows and columns in the df\n",
    "rows, columns = df.shape\n",
    "print('Number of rows: ', rows)\n",
    "print('Number of columns: ', columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c95bc05",
   "metadata": {},
   "outputs": [],
   "source": [
    "#check the columns names and data types\n",
    "print(df.dtypes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e7982b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "#View first five rows of dataset\n",
    "print(df.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6fad8631-283b-4327-9285-99e4a5a02480",
   "metadata": {},
   "outputs": [],
   "source": [
    "#check for missing data\n",
    "print(df.isnull().sum())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2618deae-b9fb-4c4b-a7e6-bfbee916acbd",
   "metadata": {},
   "source": [
    "#Data Cleaning - Coulumn Removal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ddcebb59-3ccf-4c6f-8d80-35c2c91837fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "#copy dataframe to new dataframe for cleaning\n",
    "raw = df.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f008e020-4bda-4e52-84ec-4141f8086591",
   "metadata": {},
   "outputs": [],
   "source": [
    "#check and remove duplicate columns\n",
    "raw = raw.drop(df[df.age == 'age'].index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1c0db88d",
   "metadata": {},
   "outputs": [],
   "source": [
    "#remove irrelevant columns\n",
    "\n",
    "raw.drop(\"Unnamed: 3\",axis=1,inplace=True)\n",
    "raw.drop(\"Unnamed: 21\",axis=1,inplace=True)\n",
    "raw.drop(\"Unnamed: 22\",axis=1,inplace=True)\n",
    "raw.drop(\"Unnamed: 23\",axis=1,inplace=True)\n",
    "raw.drop(\"Unnamed: 24\",axis=1,inplace=True)\n",
    "raw.drop(\"Unnamed: 25\",axis=1,inplace=True)\n",
    "raw.drop(\"Unnamed: 26\",axis=1,inplace=True)\n",
    "raw.drop(\"id\",axis=1,inplace=True)\n",
    "raw.drop(\"location\",axis=1,inplace=True)\n",
    "raw.drop(\"country\",axis=1,inplace=True)\n",
    "raw.drop(\"If_onset_approximated\",axis=1,inplace=True)\n",
    "raw.drop(\"case_in_country\",axis=1,inplace=True)\n",
    "raw.drop(\"reporting date\",axis=1,inplace=True)\n",
    "raw.drop(\"summary\",axis=1,inplace=True)\n",
    "raw.drop(\"source\",axis=1,inplace=True)\n",
    "raw.drop(\"link\",axis=1,inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "61461bb4-8c67-48a4-b726-78b2ba2caf05",
   "metadata": {},
   "outputs": [],
   "source": [
    "#print the modified dataset information\n",
    "nrows, ncolumns = raw.shape\n",
    "print(columns - ncolumns, 'irrelevant coulumns detected & removed.')\n",
    "print('updated number of rows: ', nrows)\n",
    "print('updated number of columns: ', ncolumns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3962d459",
   "metadata": {},
   "outputs": [],
   "source": [
    "#check the unique values in each column\n",
    "for i in raw.columns:\n",
    "    print('Column: ', i)\n",
    "    print('Unique Values: ', len(raw[i].unique()))\n",
    "    print(raw[i].unique())\n",
    "    print('######################################################')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1acef16-669e-4802-b2b2-0e4c665075a4",
   "metadata": {},
   "source": [
    "Data Cleaning"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c55e3bc2-a27a-43f4-a42b-480e6033f8f5",
   "metadata": {},
   "source": [
    "Fixing uniqueness in columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c08a4447-c079-4075-9f9b-41107994cbbf",
   "metadata": {},
   "outputs": [],
   "source": [
    "#fix uniqueness in columns death column\n",
    "raw['death'] = raw['death'].replace(regex=r'([0-9]+(/[0-9]+)+)', value='1')\n",
    "\n",
    "#fix uniqueness in columns recovered column\n",
    "raw['recovered'] = raw['recovered'].replace(regex=r'/2020+', value='/20')\n",
    "\n",
    "#fix uniqueness in columns recovered column\n",
    "raw['recovered'] = raw['recovered'].replace(regex=r'/1899', value='/20')\n",
    "\n",
    "#fix uniqueness in columns recovered column\n",
    "raw['hosp_visit_date'] = raw['hosp_visit_date'].replace(regex=r'2//2020+', value='2/05/2020')\n",
    "\n",
    "#fix uniqueness in columns recovered column\n",
    "raw['hosp_visit_date'] = raw['hosp_visit_date'].replace(regex=r'/2020+', value='/20')\n",
    "\n",
    "#fix uniqueness in columns recovered column\n",
    "raw['hosp_visit_date'] = raw['hosp_visit_date'].replace(regex=r'/2019+', value='/19')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52f8f057-1969-4c75-b962-f688cb4b36d4",
   "metadata": {},
   "source": [
    "Fix missing data for categorical data "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f65aa987-b40e-45aa-bcb0-d6569e830f39",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Fix missing data - gender\n",
    "raw['gender'] = raw['gender'].fillna(raw['gender'].mode()[0])\n",
    "#Fix missing data - wuhan\n",
    "raw['from Wuhan'] = raw['from Wuhan'].fillna(raw['from Wuhan'].mode()[0])\n",
    "#Fix missing data - symptom\n",
    "raw['symptom'] = raw['symptom'].fillna(raw['symptom'].mode()[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e8aa2cb-c844-49f9-9ff6-1414328e65a3",
   "metadata": {},
   "source": [
    "Fix missing data for date data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5e75f42c-eeba-4689-b56a-22b2f9be8fcc",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Fix missing data - exposure start\n",
    "raw['exposure_start'] = raw['exposure_start'].fillna(raw['exposure_start'].mode()[0])\n",
    "#Fix missing data - exposure start\n",
    "raw['exposure_end'] = raw['exposure_end'].fillna(raw['exposure_end'].mode()[0])\n",
    "#Fix missing data - hosp_visit_date\n",
    "raw['hosp_visit_date'] = raw['hosp_visit_date'].fillna(raw['hosp_visit_date'].mode()[0])\n",
    "#Fix missing data - recovered\n",
    "raw['recovered'] = raw['recovered'].replace('1', raw['recovered'].mode()[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd791876-7e1d-4d1e-b11f-e79faab97644",
   "metadata": {},
   "source": [
    "Fix missing data for numerical data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7b22c87b-3908-429e-891c-1164aff56322",
   "metadata": {},
   "outputs": [],
   "source": [
    "meanAge=raw['age'].mean()\n",
    "meanAge = int(meanAge)\n",
    "# Replace NaNs in column age with the\n",
    "# mean of values in the same column\n",
    "raw['age'].fillna(value=meanAge, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8897c22c-3f1c-448a-9625-3cb53f1813f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "#boxplot of average_age\n",
    "fig, ax = plt.subplots(figsize = (10,6))\n",
    "ax.set_title('Basic Plot')\n",
    "ax.boxplot(raw['age'], vert=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e70daec2-2bd5-422f-9cfa-73431004218d",
   "metadata": {},
   "outputs": [],
   "source": [
    "#check for missing values\n",
    "print(raw.isnull().sum())\n",
    "raw.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9db876cc-1d83-4773-83c2-385354c3a654",
   "metadata": {},
   "source": [
    "Dealing with outliers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c5183d14-42ab-41d1-949a-f8a989ca48c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "#using the interquartile range rule to deal with outliers\n",
    "\n",
    "def impute_outliers_IQR(raw):\n",
    "    q1=raw.quantile(0.25)\n",
    "    q3=raw.quantile(0.75)\n",
    "    IQR=q3-q1\n",
    "    upper = raw[~(raw>(q3+1.5*IQR))].max()\n",
    "    lower = raw[~(raw<(q1-1.5*IQR))].min()\n",
    "    raw = np.where(raw > upper,raw.median(), np.where(raw < lower, raw.median(),raw))\n",
    "    return raw\n",
    "\n",
    "raw['age'] = impute_outliers_IQR(raw['age'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7294630-f2e7-446b-8389-25d5c12d3066",
   "metadata": {},
   "outputs": [],
   "source": [
    "raw['age'].describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ec16ae2-652c-4cd8-81f1-94bfbee24336",
   "metadata": {},
   "source": [
    "Create the outcome column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ecddb1f2-fa8d-4a4b-8c96-ede3d2e5241a",
   "metadata": {},
   "outputs": [],
   "source": [
    "#for outcome, 0 is recovered, 1 is death\n",
    "raw['outcome'] = raw['death'].apply(lambda value : 0 if value == '0' else 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d8aa73a-5dfd-4715-9602-e217489b50ec",
   "metadata": {},
   "source": [
    "Convert gender to numerical value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f25bd2c9-3425-4c25-8ece-822e0846ee7c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#for outcome, 0 is male, 1 is female\n",
    "raw['sex'] = raw['gender'].apply(lambda value : 0 if value == 'male' else 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f19588be-84cd-4fb2-95d9-0522669c897e",
   "metadata": {},
   "source": [
    "End of Data Cleaning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb3dec45-0e67-493a-a588-39b354c590f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "raw.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec0a570b-6f96-422a-8fc2-5622af0a1d20",
   "metadata": {},
   "outputs": [],
   "source": [
    "raw.to_csv('latestdata2_clean.csv', columns=raw.columns, index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f29faa1-b61c-4896-acbc-5a37faae3a8f",
   "metadata": {},
   "source": [
    "columns = raw.columns\n",
    "print(columns)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "620e4db2-ee83-4655-8844-d1175ec6bef8",
   "metadata": {},
   "source": [
    "Clean Data for part 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a52eaad-d08e-4e61-9420-9e99438ad214",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_clean = raw.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6232aa1b-7f65-4500-8452-3d5e5280a06f",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_clean.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d29d362-3d75-4fb1-b768-e6d0e6044d40",
   "metadata": {},
   "source": [
    "Correlation Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a1f193c1-1661-42ae-9203-9f2a20125b09",
   "metadata": {},
   "outputs": [],
   "source": [
    "correlation = df_clean.corr()\n",
    "\n",
    "#to see in graph\n",
    "fig, ax = plt.subplots(figsize=(11, 9))\n",
    "plt.show(sns.heatmap(correlation, annot=True, cmap='coolwarm'))\n",
    "#to see in console\n",
    "print(df_clean[df_clean.columns[1:]].corr()['outcome'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c95a516-68e0-4d41-9e6d-653220b0f791",
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.catplot('outcome', 'age', data=df_clean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f6330309-49e5-463a-9260-dfc0c997eec6",
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.catplot('outcome', 'sex', data=df_clean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "06efb5e6-caa2-4510-bf77-e4625ae7383e",
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.catplot('outcome', 'from Wuhan', data=df_clean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f0a1c990-2b14-493d-b33d-a12c487ccff6",
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.catplot('outcome', 'visiting Wuhan', data=df_clean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b624523-446e-48a5-af67-084fd0b1775e",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_pca = df_clean.copy()\n",
    "\n",
    "# normalize the data - the StandardScaler is used standardize the dataset’s \n",
    "# features onto unit scale (mean = 0 and variance = 1) which is a requirement for the optimal performance \n",
    "scaler = StandardScaler()\n",
    "#x = scaled_newdf1.loc[:,].values\n",
    "df_pca = scaler.fit_transform(df_pca[['age','visiting Wuhan', 'from Wuhan', 'sex']])\n",
    "\n",
    "#check whether the normalized data has a mean of zero and a standard deviation of one.\n",
    "print('mean of normalized data: ',np.mean(df_pca))\n",
    "print('standard deviation of normalized data: ',np.std(df_pca))\n",
    "\n",
    "#perform PCA\n",
    "pca = PCA(n_components=2)\n",
    "PCA_val = pca.fit_transform(df_pca)\n",
    "data_PCA = pd.DataFrame(data = PCA_val,columns = ['Principal Component 1', 'Principal Component 2'])\n",
    "fig, ax = plt.subplots()\n",
    "ax.scatter(data_PCA['Principal Component 1'], data_PCA['Principal Component 2'], s = 5)\n",
    "ax.grid()\n",
    "#print(data_PCA['Principal Component 1'], data_PCA['Principal Component 2'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fb590b05-f6e4-4a8d-ae68-178c63ae8874",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Explained variation per principal component: {}'.format(pca.explained_variance_ratio_))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e30e9806-2be9-40f9-8186-b620d8c76c2f",
   "metadata": {},
   "source": [
    "Bayes Net"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34e0470e-6765-4f16-a7ea-ccc8677646e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Question 2A\n",
    "#P(Symptoms_onset=Date|visiting Wuhan=1)\n",
    "\n",
    "df_bayesA = df_clean.copy()\n",
    "\n",
    "#build a dataset by removing values of visiting Wuhan = 0\n",
    "df_bayesA.drop(df.loc[df_bayesA['visiting Wuhan']==0].index, inplace=True)\n",
    "\n",
    "#Get the number of rows of the new data set\n",
    "rows, columns = df_bayesA.shape\n",
    "\n",
    "#get count of N/A in reduced data set\n",
    "sumNa = df_bayesA['symptom_onset'].isna().sum()\n",
    "\n",
    "#P(Symptoms_onset=Date|visiting Wuhan=1) = 1-df_bayes.count(N/A)/df_bayes.rows\n",
    "probability = 1-(sumNa/rows)\n",
    "\n",
    "print('P(Symptoms_onset=Date|visiting Wuhan=1) = ',probability )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c0aef580-6b76-4ba6-a759-5318ce45009e",
   "metadata": {},
   "outputs": [],
   "source": [
    "#P(recovered=Date|Symptoms_onset=Date,visiting Wuhan=1)\n",
    "\n",
    "df_bayesB = df_clean.copy()\n",
    "\n",
    "#build a dataset by removing values of visiting Wuhan = 0\n",
    "df_bayesB.drop(df.loc[df_bayesB['visiting Wuhan']==0].index, inplace=True)\n",
    "\n",
    "#build a dataset by removing values of visiting symptom_onset = N/A\n",
    "df_bayesB['symptom_onset'].dropna(inplace=True)\n",
    "\n",
    "#Get the number of rows of the new data set\n",
    "rows, columns = df_bayesB.shape\n",
    "\n",
    "#get count of recovered = 0 in reduced data set\n",
    "sumFalsePatient = (df_bayesB['recovered'] == 0).sum()\n",
    "\n",
    "#P(recovered=Date|Symptoms_onset=Date,visiting Wuhan=1) = 1-df_bayes.count(falsePatient)/df_bayes.rows\n",
    "probability = 1-(sumFalsePatient/rows)\n",
    "\n",
    "print('P(recovered=Date|Symptoms_onset=Date,visiting Wuhan=1) = ',probability )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17766866-97bf-4368-a29f-c9995888cbc5",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Question 2C\n",
    "#P(outcome=1|visiting Wuhan=1)\n",
    "\n",
    "df_bayesC = df_clean.copy()\n",
    "\n",
    "#build a dataset by removing values of visiting Wuhan = 0\n",
    "df_bayesC.drop(df.loc[df_bayesC['visiting Wuhan']==0].index, inplace=True)\n",
    "\n",
    "#Get the number of rows of the new data set\n",
    "rows, columns = df_bayesC.shape\n",
    "\n",
    "#get count of death in reduced data set\n",
    "sumDeath = (df_bayesC['outcome'] == 1).sum()\n",
    "\n",
    "#P(outcome=1|visiting Wuhan=1) = df_bayesC.count(death)/df_bayes.rows\n",
    "probability = (sumDeath/rows)\n",
    "\n",
    "print('P(outcome=death|visiting Wuhan=1) = ',probability )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a1505ce8-5196-464b-a04d-5e4874e8a078",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Questoion 2D\n",
    "df_bayesD = df_clean.copy()\n",
    "\n",
    "def getInterval(date1,date2):\n",
    "    try:\n",
    "        if(date1 != '0' and date2 != '0'):\n",
    "            date1 = str(date1)\n",
    "            date2 = str(date2)\n",
    "            recoveredDate = datetime.strptime(date1, '%m/%d/%y')\n",
    "            admittedDate = datetime.strptime(date2, '%m/%d/%y')\n",
    "            interval = recoveredDate - admittedDate\n",
    "            return abs(interval.days)\n",
    "            #return interval.days\n",
    "        else:\n",
    "            #print(str(date1) + '#' + str(date2))\n",
    "            return 0\n",
    "    except:\n",
    "        #print(str(date1) + '#' + str(date2))\n",
    "        return 0\n",
    "\n",
    "df_bayesD.drop(df.loc[df_bayesD['visiting Wuhan']==0].index, inplace=True)\n",
    "#df_bayesD[\"recovery_admitted\"] = df_bayesD['recovered'].astype(str) +\"&&\"+ df_bayesD[\"hosp_visit_date\"]\n",
    "\n",
    "df_bayesD['recovery_interval'] = df_bayesD.apply(lambda row: getInterval(row.recovered, row.hosp_visit_date), axis=1)\n",
    "\n",
    "df_bayesD['recovery_interval'] = df_bayesD['recovery_interval'].replace(0, np.NaN)\n",
    "df_bayesD['recovery_interval'] = df_bayesD['recovery_interval'].replace(342, np.NaN)\n",
    "\n",
    "AverageRecoveryInterval = df_bayesD['recovery_interval'].mean()\n",
    "print('The average recovery time for a person who visited Wuhan is', AverageRecoveryInterval)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c52e2f39-651d-40f0-a5bd-9ee914eb8de9",
   "metadata": {},
   "source": [
    "Machine Learning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "79295acf-4384-454f-a29d-39108027ec82",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Question 3A\n",
    "\n",
    "df_KNNA = df_clean.copy()\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(df_KNNA[['age', 'sex', 'visiting Wuhan', 'from Wuhan']],df_KNNA['outcome'], test_size=0.25)\n",
    "classifier = KNeighborsClassifier(n_neighbors=3)\n",
    "classifier.fit(X_train, y_train)\n",
    "y_pred = classifier.predict(X_test)\n",
    "print('Classification Quality using KNN for K=3: ')\n",
    "print(confusion_matrix(y_test, y_pred))\n",
    "print(classification_report(y_test, y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8cf04c2e-b6c4-4669-abdd-f92221614969",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Question 3B\n",
    "\n",
    "df_KNNB = df_clean.copy()\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(df_KNNB[['age', 'sex', 'visiting Wuhan', 'from Wuhan', 'outcome']],df_KNNB['age'], test_size=0.25)\n",
    "reg = KNeighborsRegressor(n_neighbors=3) \n",
    "reg.fit(X_train, y_train) \n",
    "y_pred = reg.predict(X_test)\n",
    "\n",
    "print('Quality of Prediction using Regression:')\n",
    "print('Mean Absolute Error:', metrics.mean_absolute_error(y_test, y_pred))\n",
    "print('Mean Squared Error:', metrics.mean_squared_error(y_test, y_pred))\n",
    "print('Root Mean Squared Error:', np.sqrt(metrics.mean_squared_error(y_test, y_pred)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f62d6dc5-5a3c-487e-911e-0be0ad99cc5c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Import required module\n",
    "from sklearn.cluster import KMeans\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "df_KNNC = df_clean.copy()\n",
    "\n",
    "# Silhouette Score for K means\n",
    "# Import ElbowVisualizer\n",
    "from yellowbrick.cluster import KElbowVisualizer\n",
    "model = KMeans()\n",
    "# k is range of number of clusters.\n",
    "visualizer = KElbowVisualizer(model, k=(2,30),metric='silhouette', timings= True)\n",
    "visualizer.fit(df_KNNC[['age', 'sex', 'visiting Wuhan', 'from Wuhan', 'outcome']])        # Fit the data to the visualizer\n",
    "visualizer.show() \n",
    "\n",
    "pca = PCA(2)\n",
    "    \n",
    "#Transform the data\n",
    "df_KNNC = pca.fit_transform(df_KNNC[['age', 'sex', 'visiting Wuhan', 'from Wuhan', 'outcome']])\n",
    " \n",
    "df_KNNC.shape\n",
    " \n",
    "#Initialize the class object\n",
    "kmeans = KMeans(n_clusters= 3)\n",
    " \n",
    "#predict the labels of clusters.\n",
    "label = kmeans.fit_predict(df_KNNC)\n",
    " \n",
    "print(label)\n",
    "\n",
    "#Getting unique labels\n",
    "u_labels = np.unique(label)\n",
    " \n",
    "#plotting the results:\n",
    "for i in u_labels:\n",
    "    plt.scatter(df_KNNC[label == i , 0] , df_KNNC[label == i , 1] , label = i)\n",
    "\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "9d04bd13-06e5-4723-80dc-de8e5954b57d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best: 0.9447003914483589, using {'max_depth': 10, 'max_features': 2}\n"
     ]
    }
   ],
   "source": [
    "#Questoion 4C\n",
    "\n",
    "df_gridSearch = df_clean.copy()\n",
    "\n",
    "#Splitting Data into test and train set\n",
    "X_train, X_test, y_train, y_test = train_test_split(df_gridSearch[['age', 'sex', 'visiting Wuhan', 'from Wuhan']],df_gridSearch['outcome'], test_size=0.25, random_state = 42)\n",
    "\n",
    "# Transform the training data\n",
    "scaler = StandardScaler().fit(X_train)\n",
    "X_train = scaler.transform(X_train)\n",
    "\n",
    "#building the random forest classifier\n",
    "rfc = RandomForestClassifier()\n",
    "forest_params = [{'max_depth': list(range(10, 15)), 'max_features': list(range(0,14))}]\n",
    "\n",
    "#Initializing GridSearchCV() object\n",
    "grid_results = GridSearchCV(rfc, forest_params, cv = 10, scoring='accuracy')\n",
    "\n",
    "#fitting GridSearchCV() object with hyperparameters\n",
    "grid_results.fit(X_train, y_train)\n",
    "\n",
    "# Summarize the results in a readable format\n",
    "print(\"Best: {0}, using {1}\".format(grid_results.best_score_, grid_results.best_params_))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}