FireAI_012_CarEvaluation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "np.random.seed(37) # 使得每次运行得到的随机数都一样"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 1728 entries, 0 to 1727\n",
      "Data columns (total 7 columns):\n",
      "0    1728 non-null object\n",
      "1    1728 non-null object\n",
      "2    1728 non-null object\n",
      "3    1728 non-null object\n",
      "4    1728 non-null object\n",
      "5    1728 non-null object\n",
      "6    1728 non-null object\n",
      "dtypes: object(7)\n",
      "memory usage: 94.6+ KB\n",
      "None\n",
      "       0      1  2  3      4     5      6\n",
      "0  vhigh  vhigh  2  2  small   low  unacc\n",
      "1  vhigh  vhigh  2  2  small   med  unacc\n",
      "2  vhigh  vhigh  2  2  small  high  unacc\n",
      "3  vhigh  vhigh  2  2    med   low  unacc\n",
      "4  vhigh  vhigh  2  2    med   med  unacc\n"
     ]
    }
   ],
   "source": [
    "# 准备数据集\n",
    "dataset_path='D:\\PyProjects\\DataSet\\CarEvaluation/car.data'\n",
    "df=pd.read_csv(dataset_path,header=None)\n",
    "print(df.info()) # 加载没有问题\n",
    "# 原数据集包含有1728个样本，每一个样本含有6个features, 一个label\n",
    "print(df.head())\n",
    "raw_set=df.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['high' 'low' 'med' 'vhigh']\n",
      "['high' 'low' 'med' 'vhigh']\n",
      "['2' '3' '4' '5more']\n",
      "['2' '4' 'more']\n",
      "['big' 'med' 'small']\n",
      "['high' 'low' 'med']\n",
      "['acc' 'good' 'unacc' 'vgood']\n",
      "[[3 3 0 0 2 1]\n",
      " [3 3 0 0 2 2]\n",
      " [3 3 0 0 2 0]\n",
      " [3 3 0 0 1 1]\n",
      " [3 3 0 0 1 2]]\n",
      "[2 2 2 2 2]\n"
     ]
    }
   ],
   "source": [
    "# 数据集中的特征向量包括有多个String，故而type是object，需要转换为数值\n",
    "from sklearn import preprocessing\n",
    "label_encoder=[] # 放置每一列的encoder\n",
    "encoded_set = np.empty(raw_set.shape)\n",
    "for i,_ in enumerate(raw_set[0]):\n",
    "#     encoder=preprocessing.LabelEncoder()\n",
    "#     encoder.fit(raw_set[:,i]) # 用某一列来fit这个encoder\n",
    "#     encoded_set[:,i]=encoder.transform(raw_set[:,i]) # 用同样的这一列来transform\n",
    "#     label_encoder.append(encoder)\n",
    "    \n",
    "    # 上面fit和tranform都是在同一个向量上操作，故而可以整合\n",
    "    encoder=preprocessing.LabelEncoder()\n",
    "    encoded_set[:,i]=encoder.fit_transform(raw_set[:,i])\n",
    "    print(encoder.classes_)\n",
    "    label_encoder.append(encoder)\n",
    "\n",
    "dataset_X = encoded_set[:, :-1].astype(int)\n",
    "dataset_y = encoded_set[:, -1].astype(int)\n",
    "# print(dataset_X.shape) # (1728, 6)\n",
    "# print(dataset_y.shape) #(1728,)\n",
    "print(dataset_X[:5]) # 可以看出每个特征向量都将string转变为int\n",
    "print(dataset_y[:5]) # 检查没有问题\n",
    "\n",
    "# 将数据集拆分为train set 和test set\n",
    "from sklearn.model_selection import train_test_split\n",
    "train_X, test_X, train_y, test_y=train_test_split(dataset_X,dataset_y,\n",
    "                                                  test_size=0.3,random_state=42)\n",
    "# print(train_X.shape) # (1209, 6)\n",
    "# print(train_y.shape) # (1209,)\n",
    "# print(test_X.shape) # (519, 6) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\dingr\\appdata\\local\\programs\\python\\python35\\lib\\site-packages\\sklearn\\cross_validation.py:41: DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. Also note that the interface of the new CV iterators are different from that of this module. This module will be removed in 0.20.\n",
      "  \"This module will be removed in 0.20.\", DeprecationWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "准确率：89.19%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\dingr\\appdata\\local\\programs\\python\\python35\\lib\\site-packages\\sklearn\\metrics\\classification.py:1135: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples.\n",
      "  'precision', 'predicted', average, warn_for)\n",
      "c:\\users\\dingr\\appdata\\local\\programs\\python\\python35\\lib\\site-packages\\sklearn\\metrics\\classification.py:1135: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples.\n",
      "  'precision', 'predicted', average, warn_for)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "精确度：88.49%\n",
      "召回率：89.19%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\dingr\\appdata\\local\\programs\\python\\python35\\lib\\site-packages\\sklearn\\metrics\\classification.py:1135: UndefinedMetricWarning: F-score is ill-defined and being set to 0.0 in labels with no predicted samples.\n",
      "  'precision', 'predicted', average, warn_for)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F1  值：88.32%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\dingr\\appdata\\local\\programs\\python\\python35\\lib\\site-packages\\sklearn\\metrics\\classification.py:1135: UndefinedMetricWarning: F-score is ill-defined and being set to 0.0 in labels with no predicted samples.\n",
      "  'precision', 'predicted', average, warn_for)\n"
     ]
    }
   ],
   "source": [
    "# 建立随机森林分类器\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "rf_classifier=RandomForestClassifier(n_estimators=200,max_depth=8,random_state=37)\n",
    "rf_classifier.fit(train_X,train_y) # 用训练集进行训练\n",
    "\n",
    "# 用测试集评估模型的准确率，精确率，召回率，F1值：\n",
    "def print_model_evaluations(classifier,test_X, test_y,cv=5):\n",
    "    '''print evaluation indicators of classifier on test_set.\n",
    "    those indicators include: accuracy, precision, recall F1-measure'''\n",
    "    from sklearn.cross_validation import cross_val_score\n",
    "    accuracy=cross_val_score(classifier,test_X,test_y,\n",
    "                             scoring='accuracy',cv=cv)\n",
    "    print('准确率：{:.2f}%'.format(accuracy.mean()*100))\n",
    "    precision=cross_val_score(classifier,test_X,test_y,\n",
    "                             scoring='precision_weighted',cv=cv)\n",
    "    print('精确度：{:.2f}%'.format(precision.mean()*100))\n",
    "    recall=cross_val_score(classifier,test_X,test_y,\n",
    "                             scoring='recall_weighted',cv=cv)\n",
    "    print('召回率：{:.2f}%'.format(recall.mean()*100))\n",
    "    f1=cross_val_score(classifier,test_X,test_y,\n",
    "                             scoring='f1_weighted',cv=cv)\n",
    "    print('F1  值：{:.2f}%'.format(f1.mean()*100))\n",
    "\n",
    "print_model_evaluations(rf_classifier,test_X,test_y)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[108   2   7   1]\n",
      " [  9   8   0   2]\n",
      " [  3   0 355   0]\n",
      " [  3   0   0  21]]\n",
      "**************************************************\n",
      "             precision    recall  f1-score   support\n",
      "\n",
      "          0       0.88      0.92      0.90       118\n",
      "          1       0.80      0.42      0.55        19\n",
      "          2       0.98      0.99      0.99       358\n",
      "          3       0.88      0.88      0.88        24\n",
      "\n",
      "avg / total       0.95      0.95      0.94       519\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# 打印模型的混淆矩阵和各个类别的评价指标\n",
    "# 使用sklearn 模块计算混淆矩阵\n",
    "from sklearn.metrics import confusion_matrix\n",
    "test_y_pred=rf_classifier.predict(test_X)\n",
    "confusion_mat = confusion_matrix(test_y, test_y_pred)\n",
    "print(confusion_mat) #看看混淆矩阵长啥样\n",
    "print('*'*50)\n",
    "from sklearn.metrics import classification_report\n",
    "print(classification_report(test_y, test_y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3. 3. 0. 0. 2. 1.]]\n",
      "output: [2], class: unacc\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\dingr\\appdata\\local\\programs\\python\\python35\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n"
     ]
    }
   ],
   "source": [
    "# 看起来该随机森林分类器的分类效果还是很不错的，\n",
    "# 那么可以用这个比较理想的模型来预测新数据，\n",
    "new_sample=['vhigh','vhigh','2','2','small','low']\n",
    "# 在把这个样本输入模型之前，需要将样本中的string转变为int\n",
    "# 采用和上面train set相同的encoder来编码\n",
    "encoded_sample=np.empty(np.array(new_sample).shape)\n",
    "for i,item in enumerate(new_sample):\n",
    "    encoded_sample[i]=int(label_encoder[i].transform([item])) \n",
    "    # 这儿的item一定要加【】,否则报错。而且要转变为int类型\n",
    "print(encoded_sample.reshape(1,-1)) # 和上面打印的print(encoder.classes_)对应一致\n",
    "\n",
    "# 用成熟分类模型对该新样本进行分类，得到分类结果：\n",
    "output=rf_classifier.predict(encoded_sample.reshape(1,-1))\n",
    "print('output: {}, class: {}'.format(output,\n",
    "       label_encoder[-1].inverse_transform(output)[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n_estimators optimization results-------->>>\n",
      "train scores: \n",
      "  [[0.78549223 0.80144778 0.80785124 0.79338843 0.80165289]\n",
      " [0.8        0.80972079 0.81095041 0.81921488 0.83057851]\n",
      " [0.8134715  0.81075491 0.81095041 0.81404959 0.81714876]\n",
      " [0.80621762 0.81282316 0.81095041 0.81921488 0.82231405]\n",
      " [0.80932642 0.81075491 0.80991736 0.81818182 0.81301653]\n",
      " [0.80621762 0.81178904 0.80681818 0.81714876 0.80165289]\n",
      " [0.80621762 0.80868666 0.8088843  0.81921488 0.80371901]\n",
      " [0.80725389 0.81282316 0.80681818 0.81921488 0.80268595]\n",
      " [0.80621762 0.81385729 0.80681818 0.82128099 0.80371901]\n",
      " [0.80725389 0.81178904 0.80371901 0.82128099 0.80371901]\n",
      " [0.80518135 0.81178904 0.80371901 0.82128099 0.80578512]\n",
      " [0.80725389 0.81178904 0.80268595 0.82128099 0.80165289]\n",
      " [0.80829016 0.81385729 0.80371901 0.82128099 0.80578512]\n",
      " [0.80414508 0.81178904 0.80371901 0.82128099 0.80578512]\n",
      " [0.80414508 0.81178904 0.80578512 0.82128099 0.80475207]\n",
      " [0.80725389 0.81282316 0.80578512 0.82128099 0.80578512]\n",
      " [0.80725389 0.81282316 0.80578512 0.82128099 0.80578512]\n",
      " [0.80829016 0.81282316 0.80681818 0.82231405 0.80475207]\n",
      " [0.80829016 0.81282316 0.80681818 0.82128099 0.80268595]\n",
      " [0.80725389 0.81385729 0.80681818 0.82128099 0.79855372]]\n",
      "--------------------------------------------------------------------------------\n",
      "valid scores: \n",
      "  [[0.77459016 0.79338843 0.80082988 0.76763485 0.80497925]\n",
      " [0.79918033 0.79338843 0.80497925 0.80082988 0.8340249 ]\n",
      " [0.81967213 0.80578512 0.80082988 0.78008299 0.82572614]\n",
      " [0.79918033 0.80991736 0.7966805  0.78838174 0.82572614]\n",
      " [0.81557377 0.80991736 0.80082988 0.78838174 0.81742739]\n",
      " [0.80737705 0.80165289 0.79253112 0.79253112 0.81742739]\n",
      " [0.80737705 0.80578512 0.80082988 0.78838174 0.81742739]\n",
      " [0.80737705 0.80578512 0.79253112 0.80082988 0.81742739]\n",
      " [0.80327869 0.80165289 0.79253112 0.80082988 0.81742739]\n",
      " [0.80737705 0.80578512 0.79253112 0.80082988 0.81742739]\n",
      " [0.80327869 0.80578512 0.79253112 0.80082988 0.81742739]\n",
      " [0.80327869 0.80578512 0.79253112 0.80082988 0.81742739]\n",
      " [0.80737705 0.80165289 0.79253112 0.80082988 0.81742739]\n",
      " [0.79508197 0.79752066 0.79253112 0.80082988 0.81742739]\n",
      " [0.79918033 0.79752066 0.79253112 0.80082988 0.81742739]\n",
      " [0.79918033 0.80991736 0.79253112 0.80082988 0.81742739]\n",
      " [0.79918033 0.80578512 0.79253112 0.80082988 0.81742739]\n",
      " [0.80737705 0.80991736 0.79253112 0.80082988 0.81742739]\n",
      " [0.80327869 0.80578512 0.79253112 0.80082988 0.81742739]\n",
      " [0.80327869 0.80578512 0.79253112 0.80082988 0.81327801]]\n"
     ]
    }
   ],
   "source": [
    "# 提升模型的分类效果：优化模型的某个参数，\n",
    "# 第一步：优化n_estimators参数\n",
    "from sklearn.model_selection import validation_curve\n",
    "optimize_classifier1=RandomForestClassifier(max_depth=4,random_state=37)\n",
    "parameter_grid=np.linspace(20,400,20).astype(int)\n",
    "train_scores,valid_scores=validation_curve(optimize_classifier1,train_X,train_y,\n",
    "                                           'n_estimators',parameter_grid,cv=5) \n",
    "# cv=4，会输出4列结果，cv=5，会输出5列结果，\n",
    "# 故而输出的结果train_scores 的shape为（parameter_grid.shape[0],cv）\n",
    "\n",
    "# 打印优化结果\n",
    "print('n_estimators optimization results-------->>>')\n",
    "print('train scores: \\n ',train_scores)\n",
    "print('-'*80)\n",
    "print('valid scores: \\n ',valid_scores)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义一个绘图函数，绘制train scores 和valid scores\n",
    "def plot_valid_curve(grid_arr,train_scores,valid_scores,\n",
    "                     title=None,x_label=None,y_label=None):\n",
    "    '''plot train_scores and valid_scores into a line graph'''\n",
    "    assert train_scores.shape==valid_scores.shape, \\\n",
    "        'expect train_scores and valid_scores have same shape'\n",
    "    assert grid_arr.shape[0]==train_scores.shape[0], \\\n",
    "        'expect grid_arr has the same first dim with train_scores'\n",
    "    plt.figure()\n",
    "    plt.plot(grid_arr, 100*np.average(train_scores, axis=1), \n",
    "             color='blue',marker='v',label='train_scores')\n",
    "    plt.plot(grid_arr, 100*np.average(valid_scores, axis=1), \n",
    "             color='red',marker='s',label='valid_scores')\n",
    "    plt.title(title) if title is not None else None\n",
    "    plt.xlabel(x_label) if x_label is not None else None\n",
    "    plt.ylabel(y_label) if y_label is not None else None\n",
    "    plt.legend()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_valid_curve(parameter_grid,train_scores,valid_scores,\n",
    "                 title='n_estimators optimization graph',\n",
    "                 x_label='Num of estimators',y_label='Accuracy%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 第二步：对n_estimators做进一步细致优化\n",
    "# 图中可以看出，n_estimators在100以内所得到的准确率最高，故而需要进一步做更精细的优化\n",
    "parameter_grid2=np.linspace(20,120,20).astype(int)\n",
    "train_scores,valid_scores=validation_curve(optimize_classifier1,train_X,train_y,\n",
    "                                           'n_estimators',parameter_grid2,cv=5) \n",
    "plot_valid_curve(parameter_grid2,train_scores,valid_scores,\n",
    "                 title='2nd n_estimators optimization graph',\n",
    "                 x_label='Num of estimators',y_label='Accuracy%')\n",
    "# 从图中可以看出准确率最高的点是第6,7，12附近，对应的estimators是46,51,77，\n",
    "# 故而后面暂定为50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2  3  4  5  6  7  8  9 10 11 13]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 第三步：对max_depth进行优化：\n",
    "optimize_classifier2=RandomForestClassifier(n_estimators=50,random_state=37)\n",
    "parameter_grid3=np.linspace(2,13,11).astype(int)\n",
    "print(parameter_grid3) # [ 2  3  4  5  6  7  8  9 10 11 13]\n",
    "train_scores3,valid_scores3=validation_curve(optimize_classifier2,train_X,train_y,\n",
    "                                           'max_depth',parameter_grid3,cv=5) \n",
    "plot_valid_curve(parameter_grid3,train_scores3,valid_scores3,\n",
    "                 title='max_depth optimization graph',\n",
    "                 x_label='Num of max_depth',y_label='Accuracy%')\n",
    "# 从图中可以看出，取max_depth=10，11,13时准确率一样，故而取max_depth=10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 前面都是优化随机森林分类器的内置参数，但是没有考虑训练集的大小对模型效果的影响\n",
    "# 前面都是用traiin_X来优化模型，train_X含有1209个样本，\n",
    "# 下面考察一下训练集样本大小对模型效果的影响--即学习曲线\n",
    "from sklearn.model_selection import learning_curve\n",
    "# optimize_classifier3=RandomForestClassifier(random_state=37)\n",
    "optimize_classifier3=RandomForestClassifier(n_estimators=50,\n",
    "                                            max_depth=10,\n",
    "                                            random_state=37)\n",
    "parameter_grid4=np.array([0.1,0.2,0.3,0.4,0.5,0.6,0.7,.8,.9,1.]) # dataset最多有1728个样本\n",
    "train_sizes,train_scores4,valid_scores4=learning_curve(optimize_classifier3,\n",
    "                                                       dataset_X,dataset_y,\n",
    "                                          train_sizes=parameter_grid4,cv=5) \n",
    "# print(train_sizes) # [ 138  276  414  552  691  829  967 1105 1243 1382]\n",
    "# 最大也只能到dataset_X样本数的80%，即1728*0.8=1382\n",
    "plot_valid_curve(parameter_grid4,train_scores4,valid_scores4,\n",
    "                 title='train_size optimization graph',\n",
    "                 x_label='Num of train_size',y_label='Accuracy%')\n",
    "# 可以看出，在train_size=1382时得到的准确率最大，约为80%左右。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "准确率：89.32%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\dingr\\appdata\\local\\programs\\python\\python35\\lib\\site-packages\\sklearn\\metrics\\classification.py:1135: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples.\n",
      "  'precision', 'predicted', average, warn_for)\n",
      "c:\\users\\dingr\\appdata\\local\\programs\\python\\python35\\lib\\site-packages\\sklearn\\metrics\\classification.py:1135: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples.\n",
      "  'precision', 'predicted', average, warn_for)\n",
      "c:\\users\\dingr\\appdata\\local\\programs\\python\\python35\\lib\\site-packages\\sklearn\\metrics\\classification.py:1135: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples.\n",
      "  'precision', 'predicted', average, warn_for)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "精确度：88.49%\n",
      "召回率：89.32%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\dingr\\appdata\\local\\programs\\python\\python35\\lib\\site-packages\\sklearn\\metrics\\classification.py:1135: UndefinedMetricWarning: F-score is ill-defined and being set to 0.0 in labels with no predicted samples.\n",
      "  'precision', 'predicted', average, warn_for)\n",
      "c:\\users\\dingr\\appdata\\local\\programs\\python\\python35\\lib\\site-packages\\sklearn\\metrics\\classification.py:1135: UndefinedMetricWarning: F-score is ill-defined and being set to 0.0 in labels with no predicted samples.\n",
      "  'precision', 'predicted', average, warn_for)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F1  值：88.45%\n",
      "confusion_mat: ------->>>>>\n",
      "[[ 71   7   5   0]\n",
      " [  1   9   0   1]\n",
      " [  0   0 235   0]\n",
      " [  1   0   0  16]]\n",
      "**************************************************\n",
      "classification report: -------->>>>>>\n",
      "             precision    recall  f1-score   support\n",
      "\n",
      "          0       0.97      0.86      0.91        83\n",
      "          1       0.56      0.82      0.67        11\n",
      "          2       0.98      1.00      0.99       235\n",
      "          3       0.94      0.94      0.94        17\n",
      "\n",
      "avg / total       0.96      0.96      0.96       346\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\dingr\\appdata\\local\\programs\\python\\python35\\lib\\site-packages\\sklearn\\metrics\\classification.py:1135: UndefinedMetricWarning: F-score is ill-defined and being set to 0.0 in labels with no predicted samples.\n",
      "  'precision', 'predicted', average, warn_for)\n"
     ]
    }
   ],
   "source": [
    "# 用所有最优参数来重新构建模型，并判断此模型的好坏\n",
    "train_X, test_X, train_y, test_y=train_test_split(dataset_X,dataset_y,\n",
    "                                                  test_size=0.2,random_state=42)\n",
    "# 最佳训练集大小为80%\n",
    "\n",
    "rf_classifier=RandomForestClassifier(n_estimators=50,max_depth=10,random_state=37)\n",
    "rf_classifier.fit(train_X,train_y) # 用训练集进行训练\n",
    "print_model_evaluations(rf_classifier,test_X,test_y)    \n",
    "test_y_pred=rf_classifier.predict(test_X)\n",
    "confusion_mat = confusion_matrix(test_y, test_y_pred)\n",
    "print('confusion_mat: ------->>>>>')\n",
    "print(confusion_mat) #看看混淆矩阵长啥样\n",
    "print('*'*50)\n",
    "print('classification report: -------->>>>>>')\n",
    "print(classification_report(test_y, test_y_pred))"
   ]
  },
  {
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}