{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2019-08-11T07:05:09.512779Z", "start_time": "2019-08-11T07:05:09.496306Z" } }, "outputs": [], "source": [ "#!/usr/bin/python\n", "import random\n", "\n", "\n", "def makeTerrainData(n_points=5000):\n", " ###############################################################################\n", " # make the toy dataset\n", " random.seed(42)\n", " grade = [random.random() for ii in range(0, n_points)]\n", " bumpy = [random.random() for ii in range(0, n_points)]\n", " error = [random.random() for ii in range(0, n_points)]\n", " y = [round(grade[ii]*bumpy[ii]+0.3+0.1*error[ii])\n", " for ii in range(0, n_points)]\n", " for ii in range(0, len(y)):\n", " if grade[ii] > 0.8 or bumpy[ii] > 0.8:\n", " y[ii] = 1.0\n", "\n", "# split into train/test sets\n", " X = [[gg, ss] for gg, ss in zip(grade, bumpy)]\n", " split = int(0.75*n_points)\n", " X_train = X[0:split]\n", " X_test = X[split:]\n", " y_train = y[0:split]\n", " y_test = y[split:]\n", "\n", " grade_sig = [X_train[ii][0]\n", " for ii in range(0, len(X_train)) if y_train[ii] == 0]\n", " bumpy_sig = [X_train[ii][1]\n", " for ii in range(0, len(X_train)) if y_train[ii] == 0]\n", " grade_bkg = [X_train[ii][0]\n", " for ii in range(0, len(X_train)) if y_train[ii] == 1]\n", " bumpy_bkg = [X_train[ii][1]\n", " for ii in range(0, len(X_train)) if y_train[ii] == 1]\n", "\n", " training_data = {\"fast\": {\"grade\": grade_sig, \"bumpiness\": bumpy_sig}, \"slow\": {\n", " \"grade\": grade_bkg, \"bumpiness\": bumpy_bkg}}\n", "\n", " grade_sig = [X_test[ii][0]\n", " for ii in range(0, len(X_test)) if y_test[ii] == 0]\n", " bumpy_sig = [X_test[ii][1]\n", " for ii in range(0, len(X_test)) if y_test[ii] == 0]\n", " grade_bkg = [X_test[ii][0]\n", " for ii in range(0, len(X_test)) if y_test[ii] == 1]\n", " bumpy_bkg = [X_test[ii][1]\n", " for ii in range(0, len(X_test)) if y_test[ii] == 1]\n", "\n", " test_data = {\"fast\": {\"grade\": grade_sig, \"bumpiness\": bumpy_sig},\n", " \"slow\": {\"grade\": grade_bkg, \"bumpiness\": bumpy_bkg}}\n", "\n", " return X_train, y_train, X_test, y_test" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2019-08-11T07:05:42.088773Z", "start_time": "2019-08-11T07:05:41.864024Z" } }, "outputs": [], "source": [ "#!/usr/bin/python\n", "\n", "import base64\n", "import json\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import pylab as pl\n", "\n", "\n", "def prettyPicture(clf, X_test, y_test):\n", " x_min = 0.0\n", " x_max = 1.0\n", " y_min = 0.0\n", " y_max = 1.0\n", "\n", " # Plot the decision boundary. For that, we will assign a color to each\n", " # point in the mesh [x_min, m_max]x[y_min, y_max].\n", " h = .01 # step size in the mesh\n", " xx, yy = np.meshgrid(np.arange(x_min, x_max, h),\n", " np.arange(y_min, y_max, h))\n", " Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])\n", "\n", " # Put the result into a color plot\n", " Z = Z.reshape(xx.shape)\n", " plt.xlim(xx.min(), xx.max())\n", " plt.ylim(yy.min(), yy.max())\n", "\n", " plt.pcolormesh(xx, yy, Z, cmap=pl.cm.seismic)\n", "\n", " # Plot also the test points\n", " grade_sig = [X_test[ii][0]\n", " for ii in range(0, len(X_test)) if y_test[ii] == 0]\n", " bumpy_sig = [X_test[ii][1]\n", " for ii in range(0, len(X_test)) if y_test[ii] == 0]\n", " grade_bkg = [X_test[ii][0]\n", " for ii in range(0, len(X_test)) if y_test[ii] == 1]\n", " bumpy_bkg = [X_test[ii][1]\n", " for ii in range(0, len(X_test)) if y_test[ii] == 1]\n", "\n", " plt.scatter(grade_sig, bumpy_sig, color=\"b\", label=\"fast\")\n", " plt.scatter(grade_bkg, bumpy_bkg, color=\"r\", label=\"slow\")\n", " plt.legend()\n", " plt.xlabel(\"bumpiness\")\n", " plt.ylabel(\"grade\")\n", "\n", " #plt.savefig(\"test.png\",dpi=300)\n", "\n", "\n", "def output_image(name, format, bytes):\n", " image_start = \"BEGIN_IMAGE_f9825uweof8jw9fj4r8\"\n", " image_end = \"END_IMAGE_0238jfw08fjsiufhw8frs\"\n", " data = {}\n", " data['name'] = name\n", " data['format'] = format\n", " data['bytes'] = base64.encodestring(bytes)\n", " print(image_start+json.dumps(data)+image_end)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2019-08-11T07:06:13.246959Z", "start_time": "2019-08-11T07:06:13.233883Z" } }, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "%matplotlib inline" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "ExecuteTime": { "end_time": "2019-08-11T07:17:54.429655Z", "start_time": "2019-08-11T07:17:51.275517Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Training data lenth is 3750\n", "training time: 0.016 s\n", "predicting time: 0.002 s\n", "1108 1250\n", "Estimator num is 5\n", "The accuracy is 88.64 %\n", "training time: 0.029 s\n", "predicting time: 0.003 s\n", "1189 1250\n", "Estimator num is 10\n", "The accuracy is 95.12 %\n", "training time: 0.041 s\n", "predicting time: 0.005 s\n", "1194 1250\n", "Estimator num is 15\n", "The accuracy is 95.52 %\n", "training time: 0.055 s\n", "predicting time: 0.006 s\n", "1197 1250\n", "Estimator num is 20\n", "The accuracy is 95.76 %\n", "training time: 0.07 s\n", "predicting time: 0.007 s\n", "1197 1250\n", "Estimator num is 25\n", "The accuracy is 95.76 %\n", "training time: 0.08 s\n", "predicting time: 0.009 s\n", "1197 1250\n", "Estimator num is 30\n", "The accuracy is 95.76 %\n", "training time: 0.093 s\n", "predicting time: 0.013 s\n", "1199 1250\n", "Estimator num is 35\n", "The accuracy is 95.92 %\n", "training time: 0.106 s\n", "predicting time: 0.011 s\n", "1199 1250\n", "Estimator num is 40\n", "The accuracy is 95.92 %\n", "training time: 0.121 s\n", "predicting time: 0.013 s\n", "1199 1250\n", "Estimator num is 45\n", "The accuracy is 95.92 %\n", "training time: 0.132 s\n", "predicting time: 0.014 s\n", "1199 1250\n", "Estimator num is 50\n", "The accuracy is 95.92 %\n", "training time: 0.147 s\n", "predicting time: 0.016 s\n", "1199 1250\n", "Estimator num is 55\n", "The accuracy is 95.92 %\n", "training time: 0.162 s\n", "predicting time: 0.019 s\n", "1199 1250\n", "Estimator num is 60\n", "The accuracy is 95.92 %\n", "training time: 0.176 s\n", "predicting time: 0.019 s\n", "1199 1250\n", "Estimator num is 65\n", "The accuracy is 95.92 %\n", "training time: 0.193 s\n", "predicting time: 0.02 s\n", "1198 1250\n", "Estimator num is 70\n", "The accuracy is 95.84 %\n", "training time: 0.203 s\n", "predicting time: 0.021 s\n", "1199 1250\n", "Estimator num is 75\n", "The accuracy is 95.92 %\n", "training time: 0.221 s\n", "predicting time: 0.023 s\n", "1197 1250\n", "Estimator num is 80\n", "The accuracy is 95.76 %\n", "training time: 0.23 s\n", "predicting time: 0.025 s\n", "1198 1250\n", "Estimator num is 85\n", "The accuracy is 95.84 %\n", "training time: 0.246 s\n", "predicting time: 0.026 s\n", "1198 1250\n", "Estimator num is 90\n", "The accuracy is 95.84 %\n", "training time: 0.255 s\n", "predicting time: 0.028 s\n", "1198 1250\n", "Estimator num is 95\n", "The accuracy is 95.84 %\n", "The max acc is 95.92\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "from time import time\n", "from sklearn.ensemble import AdaBoostClassifier\n", "\n", "features_train, labels_train, features_test, labels_test = makeTerrainData()\n", "print(\"Training data lenth is\", len(features_train))\n", "acc_list = []\n", "estimators_list = []\n", "erange = range(5,100,5)\n", "for estimators in erange:\n", " clf = AdaBoostClassifier(n_estimators=estimators)\n", " t0 = time()\n", " clf = clf.fit(features_train, labels_train)\n", " print(\"training time:\", round(time()-t0, 3), \"s\")\n", "\n", " t1 = time()\n", " result = clf.predict(features_test)\n", " print(\"predicting time:\", round(time()-t1, 3), \"s\")\n", "\n", " corr = 0\n", " for x in range(0, len(result)):\n", " if result[x] == labels_test[x]:\n", " # print \"corr!\"\n", " corr = corr + 1\n", " print(corr, len(result))\n", " num = float(len(result))\n", " acc = 0.0\n", " acc = round(corr/num*100, 3)\n", " print(\"Estimator num is\", estimators)\n", " print(\"The accuracy is\", acc, \"%\")\n", " acc_list.append(acc)\n", " estimators_list.append(estimators)\n", "print (\"The max acc is\", max(acc_list))\n", "plt.figure()\n", "plt.plot(estimators_list, acc_list, \"o--\")\n", "#prettyPicture(clf, features_test, labels_test)\n", "#plt.legend()\n", "plt.xlabel(\"Num of estimator\")\n", "plt.ylabel(\"Accuracy\")\n", "plt.savefig(\"Adaboost_acc.png\",dpi=200)" ] }, { "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.3" }, "varInspector": { "cols": { "lenName": 16, "lenType": 16, "lenVar": 40 }, "kernels_config": { "python": { "delete_cmd_postfix": "", "delete_cmd_prefix": "del ", "library": "var_list.py", "varRefreshCmd": "print(var_dic_list())" }, "r": { "delete_cmd_postfix": ") ", "delete_cmd_prefix": "rm(", "library": "var_list.r", "varRefreshCmd": "cat(var_dic_list()) " } }, "types_to_exclude": [ "module", "function", "builtin_function_or_method", "instance", "_Feature" ], "window_display": false } }, "nbformat": 4, "nbformat_minor": 2 }