coding.py.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Wifi datasets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Loading packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.io import loadmat\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import os as os\n",
    "# Evaluation of the model\n",
    "from sklearn.model_selection import KFold, train_test_split\n",
    "from sklearn.svm import SVC \n",
    "from sklearn.metrics import classification_report, confusion_matrix \n",
    "from sklearn.model_selection import GridSearchCV \n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import plot_confusion_matrix\n",
    "import plotly.express as px\n",
    "import ipywidgets as widgets\n",
    "from ipywidgets import interact, interact_manual\n",
    "from IPython.core.debugger import set_trace"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Converting `mat` files to `csv`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Convert mat to .csv (do not run)\n",
    "#path_file = \"./feature_matrices/\"\n",
    "#entries = os.listdir(path_file)\n",
    "#for entry in entries:\n",
    "#    x = loadmat(entry)\n",
    "#    data = pd.DataFrame(x['features'])\n",
    "#    data.to_csv(entry.split(\".mat\")[0]+\".csv\",index=False)   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Feature relationship"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b9550c6e21b4428bbc4530e0ed58a085",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Dropdown(description='feature1', options=('fe1', 'fe2', 'fe3', 'fe4', 'fe5', 'fe6', 'fe7…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "######--------------------- Select the dataset ---------------------######\n",
    "df = pd.read_csv(\"./feature_matrices/2_class_features_ideal.csv\")\n",
    "#df = pd.read_csv(\"./feature_matrices/2_class_features_least_ideal.csv\")\n",
    "#df = pd.read_csv(\"./feature_matrices/2_class_features_movingdoors.csv\")\n",
    "#df = pd.read_csv(\"./feature_matrices/2_class_features_occupant_variability.csv\")\n",
    "#df = pd.read_csv(\"./feature_matrices/5_class_feature_matrix_chamber.csv\")\n",
    "#df = pd.read_csv(\"./feature_matrices/5_class_feature_matrix.csv\")\n",
    "#df = pd.read_csv(\"./feature_matrices/identifying_people_features.csv\")\n",
    "######--------------------- Select the dataset ---------------------######\n",
    "\n",
    "df['class'], _ = pd.factorize(df['class'])\n",
    "# Plot features distributions\n",
    "@interact\n",
    "def get_column(feature1 = list(df.select_dtypes('number').columns[:-1]),\n",
    "              feature2 = list(df.select_dtypes('number').columns[:-1])):\n",
    "    aux = pd.DataFrame(df[[feature1, feature2, \"class\"]])\n",
    "    aux.columns = [\"feature1\", \"feature2\",\"class\"]\n",
    "    fig = px.scatter(aux, y=\"feature1\", x=\"feature2\", color='class')\n",
    "    fig.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Classifying using holdout"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.99      0.98      0.99      2805\n",
      "           1       0.97      0.99      0.98      1615\n",
      "\n",
      "    accuracy                           0.99      4420\n",
      "   macro avg       0.98      0.99      0.98      4420\n",
      "weighted avg       0.99      0.99      0.99      4420\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "######--------------------- Select the dataset ---------------------######\n",
    "#data = pd.read_csv(\"./feature_matrices/2_class_features_ideal.csv\")\n",
    "#data = pd.read_csv(\"./feature_matrices/2_class_features_least_ideal.csv\")\n",
    "#data = pd.read_csv(\"./feature_matrices/2_class_features_movingdoors.csv\")\n",
    "#data = pd.read_csv(\"./feature_matrices/2_class_features_occupant_variability.csv\")\n",
    "#data = pd.read_csv(\"./feature_matrices/5_class_feature_matrix_chamber.csv\")\n",
    "#data = pd.read_csv(\"./feature_matrices/5_class_feature_matrix.csv\")\n",
    "data = pd.read_csv(\"./feature_matrices/identifying_people_features.csv\")\n",
    "######--------------------- Select the dataset ---------------------######\n",
    "\n",
    "data['class'], _ = pd.factorize(data['class'])\n",
    "X = data.drop([\"class\"], axis=1)\n",
    "y = data[\"class\"]\n",
    "\n",
    "# Get training and test sets\n",
    "x_train, x_test, y_train, y_test = train_test_split(X, y,\n",
    "                                                    test_size=0.20,\n",
    "                                                    random_state=0)\n",
    "# SVC with default parameters values\n",
    "model = SVC(kernel=\"poly\") \n",
    "model.fit(x_train, y_train)\n",
    "predictions = model.predict(x_test) \n",
    "print(classification_report(y_test, predictions)) \n",
    "plot_confusion_matrix(model, x_test, y_test, normalize=\"pred\") \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. Attribute selection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.99      0.98      0.99      2805\n",
      "           1       0.96      0.99      0.97      1615\n",
      "\n",
      "    accuracy                           0.98      4420\n",
      "   macro avg       0.98      0.98      0.98      4420\n",
      "weighted avg       0.98      0.98      0.98      4420\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.feature_selection import SelectKBest\n",
    "from sklearn.ensemble import ExtraTreesClassifier\n",
    "from sklearn.feature_selection import mutual_info_classif\n",
    "\n",
    "######--------------------- Select the dataset ---------------------######\n",
    "data = pd.read_csv(\"./feature_matrices/2_class_features_ideal.csv\")\n",
    "#data = pd.read_csv(\"./feature_matrices/2_class_features_least_ideal.csv\")\n",
    "#data = pd.read_csv(\"./feature_matrices/2_class_features_movingdoors.csv\")\n",
    "#data = pd.read_csv(\"./feature_matrices/2_class_features_occupant_variability.csv\")\n",
    "#data = pd.read_csv(\"./feature_matrices/5_class_feature_matrix_chamber.csv\")\n",
    "#data = pd.read_csv(\"./feature_matrices/5_class_feature_matrix.csv\")\n",
    "#data = pd.read_csv(\"./feature_matrices/identifying_people_features.csv\")\n",
    "######--------------------- Select the dataset ---------------------######\n",
    "\n",
    "data['class'], _ = pd.factorize(data['class'])\n",
    "X = data.drop([\"class\"], axis=1)\n",
    "y = data[\"class\"]\n",
    "\n",
    "model = ExtraTreesClassifier(n_estimators=50)\n",
    "model.fit(X,y)\n",
    "feat_importances = model.feature_importances_  \n",
    "#feat_importances = pd.Series(model.feature_importances_, index=X.columns)\n",
    "#feat_importances.nlargest(5).plot(kind='barh')\n",
    "#indices = np.argsort(model.feature_importances_)[::-1]\n",
    "#plt.show()\n",
    "indices = np.argsort(mutual_info_classif(X, y, discrete_features=True))[::-1]\n",
    "\n",
    "X = X[np.array(X.columns[indices][0:49])]\n",
    "\n",
    "x_train, x_test, y_train, y_test = train_test_split(X, y,\n",
    "                                                    test_size=0.20,\n",
    "                                                    random_state=0)\n",
    "# SVC with default parameters values\n",
    "model = SVC(kernel=\"poly\") \n",
    "model.fit(x_train, y_train)\n",
    "predictions = model.predict(x_test) \n",
    "print(classification_report(y_test, predictions)) \n",
    "plot_confusion_matrix(model, x_test, y_test, normalize=\"pred\") \n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. PCA analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.97      0.96      0.97      2805\n",
      "           1       0.93      0.95      0.94      1615\n",
      "\n",
      "    accuracy                           0.96      4420\n",
      "   macro avg       0.95      0.96      0.95      4420\n",
      "weighted avg       0.96      0.96      0.96      4420\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.feature_selection import SelectKBest\n",
    "from sklearn.ensemble import ExtraTreesClassifier\n",
    "from sklearn.feature_selection import mutual_info_classif\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "\n",
    "######--------------------- Select the dataset ---------------------######\n",
    "data = pd.read_csv(\"./feature_matrices/2_class_features_ideal.csv\")\n",
    "#data = pd.read_csv(\"./feature_matrices/2_class_features_least_ideal.csv\")\n",
    "#data = pd.read_csv(\"./feature_matrices/2_class_features_movingdoors.csv\")\n",
    "#data = pd.read_csv(\"./feature_matrices/2_class_features_occupant_variability.csv\")\n",
    "#data = pd.read_csv(\"./feature_matrices/5_class_feature_matrix_chamber.csv\")\n",
    "#data = pd.read_csv(\"./feature_matrices/5_class_feature_matrix.csv\")\n",
    "#data = pd.read_csv(\"./feature_matrices/identifying_people_features.csv\")\n",
    "######--------------------- Select the dataset ---------------------######\n",
    "\n",
    "\n",
    "data['class'], _ = pd.factorize(data['class'])\n",
    "X = data.drop([\"class\"], axis=1)\n",
    "y = data[\"class\"]\n",
    "\n",
    "x_train, x_test, y_train, y_test = train_test_split(X, y,\n",
    "                                                    test_size=0.20,\n",
    "                                                    random_state=0)\n",
    "\n",
    "scaler = StandardScaler()\n",
    "# Fit on training set only.\n",
    "scaler.fit(x_train)\n",
    "\n",
    "# Apply transform to both the training set and the test set.\n",
    "x_train = scaler.transform(x_train)\n",
    "x_test = scaler.transform(x_test)\n",
    "\n",
    "pca = PCA(.9)\n",
    "pca.fit(x_train)\n",
    "x_train = pca.transform(x_train)\n",
    "x_test = pca.transform(x_test)\n",
    "\n",
    "# SVC with default parameters values\n",
    "model = SVC(kernel=\"poly\") \n",
    "model.fit(x_train, y_train)\n",
    "predictions = model.predict(x_test) \n",
    "print(classification_report(y_test, predictions)) \n",
    "plot_confusion_matrix(model, x_test, y_test, normalize=\"pred\") \n",
    "plt.show()\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. GridSearch methodology"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Searching more appropriate SVC parameters\n",
    "# Method for each csv file:\n",
    "# 1. Split the data into the train and test sets (70% for training and 30% for testing)\n",
    "# 2. Use GridsearchCV to find out better parameters for Support Vector Classifier\n",
    "#       C: [0.1, 1, 10, 100, 1000, 10000]  \n",
    "#       gamma: [1, 0.1, 0.01, 0.001, 0.0001, 0.00001, 1 / (x_train.shape[0] * x_train.var())[0]] \n",
    "#       kernel: [‘linear’, ‘poly’, ‘rbf’, ‘sigmoid’, ‘precomputed’]\n",
    "# 3. Built a SVC using the best parameter setting with whole training set\n",
    "# 4. Use the tuned SVC to get the predictions for each instance from the testing set\n",
    "\n",
    "\n",
    "path_file = \"./feature_matrices/\"\n",
    "entries = os.listdir(path_file)\n",
    "results = pd.DataFrame()\n",
    "for entry in entries:\n",
    "    df = pd.read_csv(path_file+entry)\n",
    "    print(path_file+entry)\n",
    "    df['class'], _ = pd.factorize(df['class'])\n",
    "    X = df.drop([\"class\"], axis=1)\n",
    "    y = df[\"class\"]\n",
    "\n",
    "    # Step - 1: Sample rows (80% for training, 20% for testing)\n",
    "    x_train, x_test, y_train, y_test = train_test_split(X, y,\n",
    "                                                        test_size=0.20,\n",
    "                                                        random_state=0,\n",
    "                                                        stratify=y)\n",
    "    test_p = pd.concat([x_test, y_test], axis=1)\n",
    "    test_p.to_csv(\"./test_\"+entry, index=False)\n",
    "\n",
    "    # Step - 2: Applying GridsearchCV \n",
    "    # defining parameter range \n",
    "    param_grid = {'C': [0.1, 1, 10, 100, 1000], \n",
    "                  'gamma': [1, 0.1, 0.01, 0.001, 0.0001, 1 / (x_train.shape[0] * x_train.var())[0]],  \n",
    "                  'kernel': ['linear', 'poly', 'rbf', 'sigmoid']} \n",
    "\n",
    "    # Running the grid search\n",
    "    grid = GridSearchCV(SVC(), param_grid, refit = True, cv=5, verbose=2)\n",
    "\n",
    "    # Step - 3: Building the SVC using the best parameter setting with whole training set\n",
    "    grid.fit(x_train, y_train) \n",
    "\n",
    "    # print best parameter after tuning \n",
    "    print(grid.best_params_) \n",
    "\n",
    "    # Step - 4: Using the tuned SVC to get the predictions for each instance from the testing set\n",
    "    grid_predictions = grid.predict(x_test)\n",
    "    print(classification_report(y_test, grid_predictions))\n",
    "    bp = np.transpose(pd.DataFrame([entry,grid.best_params_[\"C\"], grid.best_params_[\"gamma\"], grid.best_params_[\"kernel\"]]))\n",
    "    bp.columns=[\"file\",\"C\", \"gamma\", \"kernel\"]\n",
    "    results = results.append(pd.DataFrame(bp))\n",
    "    \n",
    "results.to_csv(\"./gridSearch_result.csv\",index=False)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.1 Results of GridSearch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dataset| Kernel | Gamma | C\n",
    "-------|--------|-------|-------\n",
    "identifying_people_features.csv | poly | 1 | 0.1\n",
    "2_class_features_ideal.csv | poly | 0.0001 | 0.1 \n",
    "5_class_feature_matrix.csv | poly | 0.0001 | 0.1\n",
    "5_class_feature_matrix_chamber.csv | poly | 0.0001 | 0.1\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8. Using tuned parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.99      1.00      1.00      1128\n",
      "           1       0.97      0.99      0.98      1096\n",
      "           2       0.99      0.98      0.99      1218\n",
      "           3       0.98      0.97      0.98      1050\n",
      "           4       0.99      0.98      0.98      1108\n",
      "\n",
      "    accuracy                           0.98      5600\n",
      "   macro avg       0.98      0.98      0.98      5600\n",
      "weighted avg       0.98      0.98      0.98      5600\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "######--------------------- Select the dataset ---------------------######\n",
    "#data = pd.read_csv(\"./feature_matrices/identifying_people_features.csv\")\n",
    "#data = pd.read_csv(\"./feature_matrices/2_class_features_ideal.csv\")\n",
    "#data = pd.read_csv(\"./feature_matrices/5_class_feature_matrix.csv\")\n",
    "data = pd.read_csv(\"./feature_matrices/5_class_feature_matrix_chamber.csv\")\n",
    "######--------------------- Select the dataset ---------------------######\n",
    "\n",
    "data['class'], _ = pd.factorize(data['class'])\n",
    "X = data.drop([\"class\"], axis=1)\n",
    "y = data[\"class\"]\n",
    "\n",
    "# Get training and test sets\n",
    "x_train, x_test, y_train, y_test = train_test_split(X, y,\n",
    "                                                    test_size=0.20,\n",
    "                                                    random_state=0)\n",
    "# SVC with default parameters values\n",
    "#model = SVC(kernel=\"poly\", gamma=1, C=0.1) # for identifying_people_features.csv\n",
    "#model = SVC(kernel=\"poly\", gamma=0.0001, C=0.1) # for 2_class_features_ideal.csv\n",
    "#model = SVC(kernel=\"poly\", gamma=0.0001, C=0.1) # for 5_class_feature_matrix.csv\n",
    "model = SVC(kernel=\"poly\", gamma=0.0001, C=0.1) # for 5_class_feature_matrix_chamber.csv\n",
    "\n",
    "model.fit(x_train, y_train)\n",
    "predictions = model.predict(x_test) \n",
    "print(classification_report(y_test, predictions)) \n",
    "plot_confusion_matrix(model, x_test, y_test, normalize=\"pred\") \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}