ML_ClassifierComparison.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from sklearn.neighbors import LocalOutlierFactor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "changed csv:  data_20190303_1035_0.csv\n",
      "['data_20190301_1035_2.csv', 'data_20190303_1035_1.csv', 'data_20190309_1008_3.csv', 'data_20190309_1334_3.csv', 'data_20190309_1336_3.csv', 'data_20190309_1342_2.csv', 'data_20190309_1358_2.csv', 'data_20190309_1405_2.csv', 'data_20190309_1409_1.csv', 'data_20190309_1411_1.csv', 'data_20190309_1413_1.csv']\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import os\n",
    "import numpy as np\n",
    "\n",
    "# file_dir = os.getcwd()\n",
    "# raw_data_dir = os.path.join(file_dir, '/raw_data')\n",
    "file_list = []\n",
    "\n",
    "for root, dirs, files in os.walk('./raw_data'):\n",
    "    for file in files:\n",
    "        if os.path.splitext(file)[1] == '.csv':\n",
    "        # 排除掉readme.md等非csv文件\n",
    "            file_list.append(file)\n",
    "\n",
    "# print(file_list)  \n",
    "\n",
    "df = pd.DataFrame()\n",
    "\n",
    "for index, csv in enumerate(file_list):\n",
    "    \n",
    "    df_temp = pd.read_csv('./raw_data/'+csv)\n",
    "    if int(csv[-5]) == 0:\n",
    "        file_list[index] = csv[:-5] + '1' +csv[-4:]\n",
    "        print('changed csv: ', csv)\n",
    "    target_column = pd.DataFrame(np.array([int(file_list[index][-5])]*df_temp.shape[0]))\n",
    "    # 一开始写int(csv[-5])，是个bug！因为虽然修改了file_list但是循环过程中csv还是那个csv\n",
    "    # 构造target列，注意要使用二维的array [[1],[1]]这样是列 [[1,1]]这样是行\n",
    "    df_temp = pd.concat([df_temp, target_column], axis=1, ignore_index=True)\n",
    "    # 连接样本和target列\n",
    "    df = pd.concat([df, df_temp], ignore_index=True)\n",
    "    # 连接所有样本\n",
    "    \n",
    "print(file_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "target_column = df.iloc[:, -1]\n",
    "df = df.iloc[:, :-1]\n",
    "\n",
    "# 让脸部温度单独保存，环境温度设计为统一值\n",
    "ta = df.min(axis=1)\n",
    "\n",
    "df_face = pd.DataFrame()\n",
    "# df_face 脸部温度+其他区域温度置换为环境温度\n",
    "df_onlyface = pd.DataFrame()\n",
    "# df_onlyface 只有脸部温度点\n",
    "\n",
    "for i, minTa in zip(df.values, ta):\n",
    "    face = []\n",
    "    onlyface = []\n",
    "    for j in i:\n",
    "        try:\n",
    "        # 因为检查到有一些数字不是float是str，像21.42346.1，不知是什么原因导致的，\n",
    "            if j - minTa > 7:\n",
    "                face.append(j)\n",
    "#                 onlyface.append(j)\n",
    "            else:\n",
    "                face.append(minTa)\n",
    "        except:\n",
    "            j = float(j[:6])\n",
    "            if j - minTa > 7:\n",
    "                face.append(j)\n",
    "#                 onlyface.append(j)\n",
    "            else:\n",
    "                face.append(minTa)\n",
    "    face_todf = pd.DataFrame(face).T\n",
    "#     onlyface_todf = pd.DataFrame(onlyface).T\n",
    "    df_face = pd.concat([df_face, face_todf], axis = 0, ignore_index=True)\n",
    "#     df_onlyface = pd.concat([df_onlyface, onlyface_todf], axis = 0, ignore_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fit the model for outlier detection (default)\n",
    "clf = LocalOutlierFactor(n_neighbors=40, contamination=0.05)\n",
    "# use fit_predict to compute the predicted labels of the training samples\n",
    "# (when LOF is used for outlier detection, the estimator has no predict,\n",
    "# decision_function and score_samples methods).\n",
    "y_pred = clf.fit_predict(df_face)\n",
    "# n_errors = (y_pred != ground_truth).sum()\n",
    "X_scores = clf.negative_outlier_factor_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "min_index = np.argpartition(X_scores, int(df_face.shape[0]*0.05))[:int(df_face.shape[0]*0.05)]\n",
    "\n",
    "# 去除掉5%的异常样本\n",
    "df = df.drop(min_index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "target_column = target_column.iloc[df.index]\n",
    "# features是重新生成的，不是原来df的index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i, minTa in zip(df.values, ta):\n",
    "#     face = []\n",
    "    onlyface = []\n",
    "    for j in i:\n",
    "        try:\n",
    "        # 因为检查到有一些数字不是float是str，像21.42346.1，不知是什么原因导致的，\n",
    "            if j - minTa > 7:\n",
    "#                 face.append(j)\n",
    "                onlyface.append(j)\n",
    "#             else:\n",
    "#                 face.append(minTa)\n",
    "        except:\n",
    "            j = float(j[:6])\n",
    "            if j - minTa > 7:\n",
    "#                 face.append(j)\n",
    "                onlyface.append(j)\n",
    "#             else:\n",
    "#                 face.append(minTa)\n",
    "#     face_todf = pd.DataFrame(face).T\n",
    "    onlyface_todf = pd.DataFrame(onlyface).T\n",
    "#     df_face = pd.concat([df_face, face_todf], axis = 0, ignore_index=True)\n",
    "    df_onlyface = pd.concat([df_onlyface, onlyface_todf], axis = 0, ignore_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "skewness = pd.DataFrame(df_onlyface.skew(axis=1))\n",
    "maxTemp = pd.DataFrame(df_onlyface.max(axis=1))\n",
    "minTemp = pd.DataFrame(df_onlyface.min(axis=1))\n",
    "meanTemp = pd.DataFrame(df_onlyface.mean(axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 指定划分bin的点\n",
    "bins = [28.3, 28.6, 28.9, 29.2, 29.5,\n",
    " 29.8, 30.1, 30.4, 30.7, 31.0,  31.3,\n",
    " 31.6, 31.9, 32.2, 32.5,  32.8, 33.1,\n",
    " 33.4, 33.7, 34.0,  34.3, 34.6, 34.9,\n",
    " 35.2, 35.5, 35.8, 36.1, 36.4, 36.7]\n",
    "\n",
    "highest_bin_list = []\n",
    "for i in df_onlyface.values:\n",
    "    i = [j for j in i if not np.isnan(j)]\n",
    "    N, _ = np.histogram(np.clip(i,28.3,36.7), bins=bins)\n",
    "    highest_bin = (bins[N.argmax()]+bins[N.argmax()+1])/2\n",
    "    # 返回各区域频数N\n",
    "    highest_bin_list.append(highest_bin)\n",
    "\n",
    "modeTemp = pd.DataFrame(highest_bin_list, index=df_onlyface.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "features = pd.concat([skewness, maxTemp, minTemp, meanTemp, modeTemp, ta], axis=1, join=\"inner\")\n",
    "features.columns = ['skewness', 'maxTemp', 'minTemp', 'meanTemp', 'modeTemp', 'ta']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "featuresCorr = features.corr()\n",
    "fig = plt.figure(figsize=(10, 10))\n",
    "# plt.subplots((1,1,1)) # 设置画面大小\n",
    "sns.heatmap(featuresCorr, annot=True, vmax=1, square=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "features = features.drop([\"maxTemp\", \"minTemp\"], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "std = StandardScaler()\n",
    "features_scaler = std.fit_transform(features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64Index([  0,   1,   2,   3,   4,   5,   6,   7,   8,   9,\n",
       "            ...\n",
       "            752, 753, 754, 755, 756, 757, 758, 759, 760, 761],\n",
       "           dtype='int64', length=726)"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "train = features_scaler\n",
    "target = target_column.values\n",
    "\n",
    "train_X,test_X, train_y, test_y = train_test_split(train,\n",
    "                                                   target,\n",
    "                                                   test_size = 0.1,\n",
    "                                                   random_state = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
      "           metric_params=None, n_jobs=1, n_neighbors=3, p=2,\n",
      "           weights='uniform') \n",
      " [0.69230769 0.75       0.82608696] \n",
      "\n",
      "SVC(C=0.025, cache_size=200, class_weight=None, coef0=0.0,\n",
      "  decision_function_shape='ovr', degree=3, gamma='auto', kernel='linear',\n",
      "  max_iter=-1, probability=False, random_state=None, shrinking=True,\n",
      "  tol=0.001, verbose=False) \n",
      " [0.57692308 0.83333333 0.82608696] \n",
      "\n",
      "SVC(C=1, cache_size=200, class_weight=None, coef0=0.0,\n",
      "  decision_function_shape='ovr', degree=3, gamma=2, kernel='rbf',\n",
      "  max_iter=-1, probability=False, random_state=None, shrinking=True,\n",
      "  tol=0.001, verbose=False) \n",
      " [0.80769231 0.83333333 0.86956522] \n",
      "\n",
      "GaussianProcessClassifier(copy_X_train=True,\n",
      "             kernel=1**2 * RBF(length_scale=1), max_iter_predict=100,\n",
      "             multi_class='one_vs_rest', n_jobs=1, n_restarts_optimizer=0,\n",
      "             optimizer='fmin_l_bfgs_b', random_state=None,\n",
      "             warm_start=False) \n",
      " [0.88461538 0.875      0.91304348] \n",
      "\n",
      "DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=5,\n",
      "            max_features=None, max_leaf_nodes=None,\n",
      "            min_impurity_decrease=0.0, min_impurity_split=None,\n",
      "            min_samples_leaf=1, min_samples_split=2,\n",
      "            min_weight_fraction_leaf=0.0, presort=False, random_state=None,\n",
      "            splitter='best') \n",
      " [0.92307692 0.95833333 0.82608696] \n",
      "\n",
      "RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',\n",
      "            max_depth=5, max_features=1, max_leaf_nodes=None,\n",
      "            min_impurity_decrease=0.0, min_impurity_split=None,\n",
      "            min_samples_leaf=1, min_samples_split=2,\n",
      "            min_weight_fraction_leaf=0.0, n_estimators=10, n_jobs=1,\n",
      "            oob_score=False, random_state=None, verbose=0,\n",
      "            warm_start=False) \n",
      " [0.73076923 0.83333333 0.73913043] \n",
      "\n",
      "MLPClassifier(activation='relu', alpha=1, batch_size='auto', beta_1=0.9,\n",
      "       beta_2=0.999, early_stopping=False, epsilon=1e-08,\n",
      "       hidden_layer_sizes=(100,), learning_rate='constant',\n",
      "       learning_rate_init=0.001, max_iter=2000, momentum=0.9,\n",
      "       nesterovs_momentum=True, power_t=0.5, random_state=None,\n",
      "       shuffle=True, solver='adam', tol=0.0001, validation_fraction=0.1,\n",
      "       verbose=False, warm_start=False) \n",
      " [0.69230769 0.79166667 0.86956522] \n",
      "\n",
      "AdaBoostClassifier(algorithm='SAMME.R', base_estimator=None,\n",
      "          learning_rate=1.0, n_estimators=50, random_state=None) \n",
      " [0.57692308 0.79166667 0.82608696] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "from matplotlib.colors import ListedColormap\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.datasets import make_moons, make_circles, make_classification\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.gaussian_process import GaussianProcessClassifier\n",
    "from sklearn.gaussian_process.kernels import RBF\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis\n",
    "from sklearn.model_selection import cross_val_score\n",
    "\n",
    "names = [\"Nearest Neighbors\", \"Linear SVM\", \"RBF SVM\", \"Gaussian Process\",\n",
    "         \"Decision Tree\", \"Random Forest\", \"Neural Net\", \"AdaBoost\",\n",
    "         \"Naive Bayes\", \"QDA\"]\n",
    "\n",
    "classifiers = [\n",
    "    KNeighborsClassifier(3),\n",
    "    SVC(kernel=\"linear\", C=0.025),\n",
    "    SVC(gamma=2, C=1),\n",
    "    GaussianProcessClassifier(1.0 * RBF(1.0)),\n",
    "    DecisionTreeClassifier(max_depth=5),\n",
    "    RandomForestClassifier(max_depth=5, n_estimators=10, max_features=1),\n",
    "    MLPClassifier(alpha=1, max_iter=2000),\n",
    "    AdaBoostClassifier(),\n",
    "#     GaussianNB(),\n",
    "#     QuadraticDiscriminantAnalysis()\n",
    "]\n",
    "\n",
    "for i in classifiers:\n",
    "    i.fit(train_X, train_y)\n",
    "    print(i, '\\n', cross_val_score(i, test_X, test_y), '\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "GaussianProcessClassifier和DecisionTreeClassifier表现比较优异"
   ]
  }
 ],
 "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.6.5"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}