├── .DS_Store ├── 01 Linear Regression ├── Gradient_Descent_Demo.ipynb ├── Linear_Regression.ipynb └── Linear_Regression_with_Multiple_Features.ipynb ├── 02 Logistic Regression └── Logistic_Regression.ipynb ├── 03 Dimensionality Reduction └── PCA.ipynb ├── 04 PCA └── PCA.ipynb ├── 05 KNN └── K_Nearest_Neigbours.ipynb ├── 06 K-Means └── K_Means.ipynb ├── 07 Naive Bayes ├── Naive Bayes For Text Classification.ipynb └── Spam Classifier.ipynb ├── 08 Decision Trees ├── Decision Trees.ipynb └── Titanic Survival Prediction.ipynb └── 09 Ensemble Learning ├── Customer_Churn_Prediction.ipynb ├── Ensemble - Bagging.ipynb └── Ensemble Learning - Boosting.ipynb /.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/prateek27/machine-learning-essentials/ead6bf8c01764b86b12e1471255bb1e6cf7064b1/.DS_Store -------------------------------------------------------------------------------- /01 Linear Regression/Gradient_Descent_Demo.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "provenance": [] 7 | }, 8 | "kernelspec": { 9 | "name": "python3", 10 | "display_name": "Python 3" 11 | }, 12 | "language_info": { 13 | "name": "python" 14 | } 15 | }, 16 | "cells": [ 17 | { 18 | "cell_type": "code", 19 | "execution_count": null, 20 | "metadata": { 21 | "id": "PfFSSy_kpLSc" 22 | }, 23 | "outputs": [], 24 | "source": [ 25 | "import numpy as np \n", 26 | "import matplotlib.pyplot as plt" 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "source": [ 32 | "# Generate data using a dummy function \n", 33 | "X = np.arange(10)\n", 34 | "Y = (X-5)**2 + 3 \n", 35 | "\n", 36 | "print(X,Y)" 37 | ], 38 | "metadata": { 39 | "colab": { 40 | "base_uri": "https://localhost:8080/" 41 | }, 42 | "id": "cxRCoyRWp31i", 43 | "outputId": "1ac5d03b-7f79-4dd0-89b2-c98b65f1e8a9" 44 | }, 45 | "execution_count": null, 46 | "outputs": [ 47 | { 48 | "output_type": "stream", 49 | "name": "stdout", 50 | "text": [ 51 | "[0 1 2 3 4 5 6 7 8 9] [28 19 12 7 4 3 4 7 12 19]\n" 52 | ] 53 | } 54 | ] 55 | }, 56 | { 57 | "cell_type": "code", 58 | "source": [ 59 | "# Visualise \n", 60 | "plt.style.use(\"seaborn\")\n", 61 | "plt.plot(X,Y)\n", 62 | "plt.xlabel(\"X\")\n", 63 | "plt.ylabel(\"Y\")\n", 64 | "plt.show()" 65 | ], 66 | "metadata": { 67 | "colab": { 68 | "base_uri": "https://localhost:8080/", 69 | "height": 361 70 | }, 71 | "id": "L4q4bzPkqNno", 72 | "outputId": "da1944a4-4878-4301-8f68-08eeb8990813" 73 | }, 74 | "execution_count": null, 75 | "outputs": [ 76 | { 77 | "output_type": "display_data", 78 | "data": { 79 | "text/plain": [ 80 | "
" 81 | ], 82 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAe0AAAFYCAYAAAB+s6Q9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dd3SUZaI/8O+UTJJJmfReCCkQEkLvNRAQVEpABRGwXcvdxXr3d3bXn+uy1/tbV849e66sriK26yKKhqr0AJFiCIQWEiCd9J5Jb9N+fyQbYRVMwsw8U76fc/acdRLm/fIw8M37vs/7PBKDwWAAERERWTyp6ABEREQ0MCxtIiIiK8HSJiIishIsbSIiIivB0iYiIrISLG0iIiIrIRcd4G7q6lqN/p6enkqo1R1Gf1+6HcfZPDjO5sFxNg+Ocy9fX7c7fs3uzrTlcpnoCHaB42weHGfz4DibB8f5l9ldaRMREVkrljYREZGVYGkTERFZCZY2ERGRlWBpExERWQmWNhERkZVgaRMREVkJljYREZGVYGkTERFZCZY2ERGRlbCr0r6QW4f6pk7RMYiIiIbEbkq7s1uL93ZfxV+3XxQdhYiIaEjsprSdHeWIi/DC1cJ6FFe1iI5DREQ0aHZT2gCweEoYAOBgRqngJERERINnV6UdG+6JyBAVLuTWooZ7thIRkZWxq9KWSCRYOTcaBgNw5FyZ6DhERESDYlelDQDTEwLho3LC6atVaGnvER2HiIhowOyutGUyKe6bHAaNVo9jF8pFxyEiIhowuyttAJiZEAhXZwccv1iOrh6t6DhEREQDYpel7eggw/wJIWjv0uJUVpXoOERERANil6UNAPPGB0Mhl+LIuVJodXrRcYiIiH6R3Za2m1KBWQlBaGjpRuaNWtFxiIiIfpHdljYALJwcComkd7EVg8EgOg4REdFd2XVp+3o4Y9JIP5TVtiHnZqPoOERERHdl16UNAIunhAMADp7l0qZERGTZ7L60wwPcEBvuieslatys5kYiRERkuey+tAFg8dTejUQOcSMRIiKyYCxtAHHDvBDq54rzN2pR29QpOg4REdHPYmmjdyORxVPC+jYS4dk2ERFZJpZ2n4kj/eDt7oTTWVVo6eBGIkREZHlY2n3kMikWTg5Fj1aP49xIhIiILBBL+xazE4Lg4iTH8YsV6O7RiY5DRER0G5b2LRwVMswbH4K2Tg1OX+VGIkREZFlY2v9i/oQQOMilOHyuFDo9NxIhIiLLwdL+F+4uCswcHYj65i5k3qgTHYeIiKgfS/tn/LiRSAk3EiEiIovB0v4Z/p5KTBjhh9KaNlwrUYuOQ0REBIClfUeLp/QtbXq2RHASIiKiXiztO4gIdMfIMA/k3FSjpLpVdBwiIiKW9t0sntq7bechLm1KREQWQG7KN9+0aRMuXLgArVaL5557DsePH0dOTg48PDwAAE8//TTmzp1rygj3JD7CCyG+Ljh/vRYrZg+Hr4ez6EhERGTHTFbaZ8+eRX5+Pnbs2AG1Wo3k5GRMnToVr776KhITE011WKPq3UgkHFu/u4Yj58vw2IIY0ZGIiMiOmezy+KRJk/DOO+8AANzd3dHZ2QmdzvqWBp0U6wcvd0eculKJVm4kQkREApmstGUyGZRKJQAgJSUFs2fPhkwmw7Zt27B+/Xq88soraGxsNNXhjUYuk2LhpDD0aPU4cbFCdBwiIrJjEoOJVw9JTU3Fli1b8MknnyA7OxseHh6IjY3Fhx9+iOrqarzxxht3/LVarQ5yucyU8Qaks1uLp948AqlUgo9fXwAnhUmnAhAREf0sk7bPqVOn8MEHH+Cjjz6Cm5sbpk2b1v+1efPmYePGjXf99Wp1h9Ez+fq6oa5u8I9wzR0XhO9+KMHeE/mYNz7E6LlszVDHmQaH42weHGfz4Dj38vV1u+PXTHZ5vLW1FZs2bcKWLVv6Z4u/8MILKCsrAwBkZGQgOjraVIc3uvkTQiGXcSMRIiISx2Rn2gcOHIBarcbLL7/c/9qKFSvw8ssvw9nZGUqlEm+99ZapDm90KhcFZo4OQNrlSlzIrcPkWH/RkYiIyM6YrLRXrVqFVatW/eT15ORkUx3S5O6bHIbvL1fiYEYpJo30g0QiER2JiIjsCFdEGwR/LyXGj/BFSXUrbpQ2iY5DRER2hqU9SIv6NhI5mMGNRIiIyLxY2oMUGaTCiFAPZBc1oqy2TXQcIiKyIyztIVg8tW/bTp5tExGRGbG0h2D0cG8E+7og41ot6ps7RcchIiI7wdIeAolEgkWTw6A3GHD0fLnoOEREZCdY2kM0ZZQ/PN0ccfJKJdo6NaLjEBGRHWBpD1HvRiKh6NbocOISNxIhIiLTY2nfg9ljguDsKMexzDL0aKxv21EiIrIuLO174Owox7zxwWjp0OCH7GrRcYiIyMaxtO9R0oQQyGUSHDpXCr3epLucEhGRnWNp3yOVqyOmxweiVt2Ji3l1ouMQEZENY2kbwX2TQyFB79KmBgPPtomIyDRY2kYQ6O2CcTG+KK5qRV4ZNxIhIiLTYGkbyeL+jURKBSchIiJbxdI2kshgFWJCVMgqbEA5NxIhIiITYGkb0aKp4QCAQ+d4tk1ERMbH0jaihEhvBPm4IONaDRpbukTHISIiG8PSNiJp30YiOr0BR86XiY5DREQ2hqVtZFPj/OHhqsD3VyrR3sWNRIiIyHhY2kbWu5FIGLp7dEjjRiJERGRELG0TmDM2CM6OMhzNLIdGy41EiIjIOFjaJuDsKMfcccFoae/hRiJERGQ0LG0TSZoQ2reRSBk3EiEiIqNgaZuIp5sjpsYFoKaxA5fy60XHISIiG8DSNqFFk/+5tCk3EiEionvH0jahIB8XjI3yQVFlC/LLm0XHISIiK8fSNrHFU/vOts+WCE5CRETWjqVtYtEhHogKVuFKYQMq6riRCBERDR1L2wz+uW0nNxIhIqJ7wdI2gzHRPgjwUuJsDjcSISKioWNpm4FUIsGiKb0biaRmlouOQ0REVoqlbSbT4gKgclEg7XIFOriRCBERDQFL20wc5FIsmBSKrh4d0i5Xio5DRERWiKVtRnPHBsFJIcPR82XQaPWi4xARkZVhaZuR0skBc8cGo7m9B+k53EiEiIgGh6VtZkkTQyCTSnAooxR6Lm1KRESDwNI2My93J0yN80d1YweucCMRIiIaBJa2AD9uJMLFVoiIaOBY2gIE+7piTKQ3CiqakV/eJDoOERFZCZa2IIunhgMADp7l2TYREQ0MS1uQ6BAVIoPccbmgHlUN7aLjEBGRFWBpCyKRSLBoSu/Z9iHe2yYiogFgaQs0LtoH/l5KpOdUQ93aLToOERFZOJa2QFKpBIsmh0KrMyD1QpnoOEREZOFY2oJNjw+Au4sCaZcq0NmtFR2HiIgsmElLe9OmTVi1ahVWrlyJI0eOoKqqCuvWrcOaNWvw0ksvoaenx5SHtwoOchkWTAxBZ7cO33MjESIiuguTlfbZs2eRn5+PHTt24KOPPsKf//xnbN68GWvWrMH27dsRHh6OlJQUUx3eqswdFwxHhQxHzpdCq+NGIkRE9PNMVtqTJk3CO++8AwBwd3dHZ2cnMjIyMH/+fABAYmIi0tPTTXV4q+Li5IA5Y4LQ1NaDszk1ouMQEZGFkpvqjWUyGZRKJQAgJSUFs2fPxunTp6FQKAAA3t7eqKuru+t7eHoqIZfLjJ7N19fN6O95r1bfF4tjF8px9EI5liVGQyqViI50zyxxnG0Rx9k8OM7mwXG+O5OV9j+lpqYiJSUFn3zyCRYuXNj/umEAO1yp1R1Gz+Pr64a6ulajv68xTBnljx+yq3Es4ybGRvmIjnNPLHmcbQnH2Tw4zubBce51tx9cTDoR7dSpU/jggw+wdetWuLm5QalUoqurCwBQU1MDPz8/Ux7e6vxzI5FDZ0sEJyEiIktkstJubW3Fpk2bsGXLFnh4eAAApk+fjsOHDwMAjhw5glmzZpnq8FYpxM8VCZHeyCtvRkFFs+g4RERkYUx2efzAgQNQq9V4+eWX+1/7y1/+gtdffx07duxAUFAQli9fbqrDW63FU8KQVdiAQxml2LBitOg4RERkQUxW2qtWrcKqVat+8vqnn35qqkPahJhQD0QEuuNSXh2qGtoR6O0iOhIREVkIrohmYSQSCRZPCYMBwOFzXNqUiIh+xNK2QONjfOHn6YwfsqvQ3MaNRIiIqBdL2wL1biQS1reRSLnoOEREZCFY2hZqenwA3JUOOH6RG4kQEVEvlraFUjjIMH9iKDq7tdxIhIjIAnV0abDz+0Kz3sZkaVuwxHHBcFLIsD/9Jto6NaLjEBHRLb4+UYD96SVmXVeDpW3BXJ0dsHRGBNq7tNh9skh0HCIi6lNc1YJTV6oQ7OuCsdHmW3aapW3hkiaGINBbibTLFSip5pq8RESi6Q0GbDuSBwOAx5JiIJOar0pZ2hZOLpNiTVIMDAbgi6N5A9pohYiITOdMVhWKq1owOdYPI8M9zXpslrYViIvwwoQYXxRUNCM9p1p0HCIiu9XRpUHK94VQOEjxSGKU2Y/P0rYSq+ZHwUEuxTcnCvkIGBGRIHtOFaO1Q4Ml04fBy93J7MdnaVsJH5UzHpgWjub2Huw7Uyw6DhGR3SmrbcOxi+Xw93TGwklhQjKwtK3I4ilh8FE5ITWzHJX17aLjEBHZDYPB0DevCHg0KQYOcjH1ydK2Ig5yGR5NioZOb8D2VE5KIyIyl3PXa5FX1oSxUT5IiPQWloOlbWXGRvlg9HBvXLupxoXcOtFxiIhsXlePFjuO50Muk2J1UrTQLCxtKyORSPBoUjRkUgl2HM9Ht0YnOhIRkU379oebaGrrweIpYfDzcBaahaVthQK8lLhvchgaWrpxIL1EdBwiIptV3diBI+fK4O3uiPunhYuOw9K2Vg9OD4enmyMOZpSiVt0hOg4Rkc0xGAzYfjQPOr0Bq+dHw9FBJjoSS9taOSnkeCQxClqdHl8dKxAdh4jI5lzOr0d2cSNGDfPE+Bhf0XEAsLSt2uRYP4wI9cDlgnpkFdaLjkNEZDN6NDp8eSwfMqkEa5JiIJFIREcCwNK2ahKJBI8tiIFUIsH21HxotHrRkYiIbMKhjFLUN3dhwcRQBPm4iI7Tj6Vt5UL8XDFvfDBq1Z04cr5UdBwiIqtX39SJ/WdLoHJRYMmMYaLj3IalbQOWz4qAm9IB3/5wE40tXaLjEBFZtR3HC6DR6vFIYhScHeWi49yGpW0DlE4OeGhuJHo0enx9gpPSiIiGKru4ARfy6hAdosLUOH/RcX6CpW0jZowOxPAgd5y7XovrJWrRcYiIrI5Wp8f2o/mQSIDHFljO5LNbsbRthLRvUpoEwPajedDqOCmNiGgwUjPLUd3YgbnjghHm7yY6zs9iaduQiEB3zBoThIr6dpy4WCE6DhGR1VC3dmPvmWK4OjsgedZw0XHuiKVtY1bOGQ4XJzn2nC5Cc3uP6DhERFbhm7QCdPfosGLOcLg6O4iOc0csbRvjplRg+azh6OzWISWNk9KIiH5JXlkTzubUIDzADbMTgkTHuSuWtg2aOy4IoX6uOHO1GoUVzaLjEBFZLJ1ej21H8gAAaxfEQCq1vMlnt2Jp2yCZVIrHFsQAALYdzYNebxCciIjIMqVdqkR5XRtmjA5AZLBKdJxfxNK2UTGhHpga54+S6laczKoUHYeIyOK0dPRg98kiODvK8NDcKNFxBoSlbcMenhsFR4UMu74vQlunRnQcIiKLsuv7InR0a7F85nCoXBSi4wwIS9uGebo5YtmMCLR1arD7VJHoOEREFqO4qgWnrlQi2McFieODRccZMJa2jUuaGIIALyXSLlWgtKZVdBwiIuH0BgO2HcmDAcCaBTGQy6ynCq0nKQ2JXCbFmgXRMBh6J6UZDJyURkT27czVKhRXtWByrB9iwz1FxxkUlrYdiI/wxoQYXxSUN+NsTo3oOEREwnR0aZCSVgiFgxSPJFrH5LNbsbTtxKp5UXCQS/H1iQJ0dmtFxyEiEmLPqWK0dmiwZPoweLk7iY4zaCxtO+Hj4YwHpoajub0H3565KToOEZHZlde24fjFCvh5OmPhpDDRcYaEpW1HFk0Jg4/KCUczy1BZ3y46DhGR2RgMBnxxNA96gwFrkqLhILfO+rPO1DQkCgcZHp0fDZ3egO2pnJRGRPbj3PVa5JY1YWyUDxIifUTHGbI7lvbjjz+OkpISc2YhMxgb7YP44V64dlONi3l1ouMQEZlcV48WX58ogFwmxer51jf57FZ3LO3k5GQ8+eSTeO+996DRcDUtWyGRSLAmKQYyqQRfHctHt0YnOhIRkUl990MJ1K3dWDQlDH6eStFx7skdS3v58uXYu3cv1Go1kpOTcfr0aZSVlfX/j6xXgJcS900OQ0NLNw6k82oKEdmu6sYOHD5XCm93RzwwLVx0nHsmv9sX3dzc8Pvf/x5vvPEGXnrpJXh4eMBgMEAikeDYsWPmykgm8OD0cKTnVONgRilmJATCz8NZdCQiIqMyGHrn7+j0BqyaFw1HB5noSPfsrhPRMjMzkZyc3F/Sx44dw/Hjxwdc2Hl5eUhKSsK2bdsAAL/73e+wZMkSrFu3DuvWrUNaWto9/wZoaJwUcjySGAWtTo+vUvNFxyEiMrrLBfXILmpEbLgnJozwFR3HKO54pv2b3/wGubm52LhxIyZMmDDoN+7o6MCbb76JadOm3fb6q6++isTExMEnJaObHOuHtEsVuFxQj6zCBiREeouORERkFD0aHb5MzYdMKsGaBTGQSCSiIxnFHc+0Y2JisHv37iEVNgAoFAps3boVfn5+Qw5HpiWRSPDYghhIJRJ8mZoHjVYvOhIRkVEcOleK+uYuJE0MQbCPi+g4RnPH0n722Wchl9/1lvddyeVyODn9dIm4bdu2Yf369XjllVfQ2Ng45Pcn4wjxc8W88cGoUXfiyPlS0XGIiO5ZfVMn9qeXQOWiwNIZEaLjGNXQW3kIli1bBg8PD8TGxuLDDz/Eu+++izfeeOOO3+/pqYRcbvyJA76+bkZ/T2v2dHICzufW4rv0Ejw4Owo+RpqUxnE2D46zeXCczcMY47x1/3VotHo89XA8wkKsaxevX2LW0r71/va8efOwcePGu36/Wt1h9Ay+vm6oq+O+0v9qxazh+PTgDbyfchnPL4u/5/fjOJsHx9k8OM7mYYxxziluRPrVKkSFqBAfprLKP7e7/eBi1mVMX3jhhf5nvDMyMhAdHW3Ow9NdzEgIRESgO85dr8WNErXoOEREg6bV6bE9NQ8SAI8l2c7ks1uZ7Ew7Ozsbb7/9NioqKiCXy3H48GGsXbsWL7/8MpydnaFUKvHWW2+Z6vA0SFKJBGsXxuC//jcTX6TmYeOTkyCTcml6IrIeqZnlqGroQOK4YIQH2ObtDJOVdnx8PP7xj3/85PX77rvPVIekexQR6I5ZYwJx8koVjl+swIKJoaIjERENSFNbN/aeKYarswOSZw8XHcdkeCpFt1kxJxJKRzn2nCpCc3uP6DhERAPyzYkCdPfosGL2cLg6O4iOYzIsbbqNu1KB5NnD0dmtw860QtFxiIh+UV5ZE9JzahDu74bZY4JExzEpljb9xNxxQQjxdcXpq1UorGgWHYeI6I70egO+OJoHAHhsYQykUtubfHYrljb9hEwqxdqFMQCAbUfzoNcbBCciIvp5aZcrUFbbhhnxAYgKVomOY3IsbfpZMaEemBrnj5LqVpzKqhQdh4joJ1o6erDr+yI4O8rw0NxI0XHMgqVNd/Tw3Cg4KmTY+X0R2jo1ouMQEd1m1/dF6OjWYtnM4VC5OoqOYxYsbbojTzdHLJ0xDG2dGuw5VSQ6DhFRv+KqFpy6UokgHxfMGx8sOo7ZsLTprhZMDEWAlxInLlWgtMb6lgMkItujN/ROPjMAeCwpGnKZ/VSZ/fxOaUjkMinWLIiGwYDevyQGTkojIrHOXK1CUWULJo30Q+wwL9FxzIqlTb8oPsIb42N8kV/ejLPXakTHISI71tGlwc60QigcpFg1L0p0HLNjadOArJ4XBQe5FF8fL0Bnt1Z0HCKyU3tOF6OlQ4MHpw2Dl7uT6Dhmx9KmAfHxcMYDU8PR3N6Db8/cFB2HiOxQeV0bjl+ogJ+nM+6bHCY6jhAsbRqwRVPC4KNywtHMMlQ1tIuOQ0R2xGAwYPvRPOgNBjw6PxoOcvusL/v8XdOQKBxkeHR+NHR9ywZyUhoRmcv5G7W4UdqEMZHeGBPlIzqOMCxtGpSx0T6IH+6FazfVuJhXJzoOEdmBrh4tdhwvgFwmwaNJ0aLjCMXSpkGRSCRYkxQDmVSCr44VoFujEx2JiGzc/vQSqFu7sWhKGPw8laLjCMXSpkEL8FJi4eRQNLR04eDZEtFxiMiGVTd24FBGKbzcHfHA1GGi4wjH0qYhWTJ9GDxcFThwthS1TZ2i4xCRDTIYDPgyNR86vQGr50XDUSETHUk4ljYNiZNCjkfmRUGr02PHsXzRcYjIBl0paMDVogbEhntiwghf0XEsAkubhmxKrD9iQj1wKb8eWYUNouMQkQ3RaHXYnpoHmVSCNQtiIJFIREeyCCxtGjKJRILHFsRAKpHgy9Q8aLR60ZGIyEYczChFfXMX5k8IQbCPi+g4FoOlTfck1M8VieODUaPuxNHMMtFxiMgG1Dd34kB6CdxdFFg2M0J0HIvC0qZ7ljwrAm5KB3x75iYaW7pExyEiK7fjeAF6tHo8PDcSzo5y0XEsCkub7pnSyQEPzYlEt0aHr08UiI5DRFYs52YjLuTWISpYhWnxAaLjWByWNhnFjIRARAS649z1WuSWqkXHISIrpNHqsf1oHiRA/3wZuh1Lm4xCKpFg7cIYSABsO5oHnY6T0ohocL47XYSqhg7MGReM8AA30XEsEkubjCYi0B2zxgSioq4d+88Ui45DRFZE3dqNL4/cgIuTHCtmDxcdx2KxtMmoVsyJhIuTHJ/tv4aiyhbRcYjICmi0ery/Nxud3TqsnBMJV2cH0ZEsFkubjMpdqcAzS+Kg0+nxt51ZnE1ORHdlMBjwj8O5KChvxqyxwZgzNkh0JIvG0iajS4j0xpNL4tDc3oO/7brKncCI6I6OnC/D6atVGBbghhdXjeXKZ7+ApU0msWx2JGYmBKKkuhWf7L8Og8EgOhIRWZiswnp8faIAKlcFXliZACcFn8n+JSxtMgmJRIJ1C0cgOkSF8zdq8e2Zm6IjEZEFqahvxwd7cyCXSfHCigR4ujmKjmQVWNpkMg5yKX6dPBre7k7Yc7oYmTdqRUciIgvQ1qnB5pQr6OrR4cn7R2J4kLvoSFaDpU0m5e6iwEsPJcBRIcNH311DSXWr6EhEJJBWp8ffd19FXVMXHpw+DFNHcdWzwWBpk8mF+Lni2SWjoNHqsXlnFpraukVHIiIBDAYDvjiahxulTRgf44vls7gZyGCxtMksxkX7YuXcSKhbu/HurqvQaDmjnMjeHL9Yge8vVyLUzxXPPDiKy5QOAUubzGbxlDBMi/NHUWULPj14gzPKiexITnEjvkzNh7vSAS+u7L1lRoPH0iazkUgkeGLxSEQGueNsTg0OnC0RHYmIzKCqoR1/35MNqRTYsDIB3ion0ZGsFkubzMpBLsOGFaPh6eaIXd8X4VJenehIRGRC7V0abN55FZ3dWjy+aCSiglWiI1k1ljaZncrVES+uTICDgxQffnsNZbVtoiMRkQno9Hq8vycbNY0dWDwlDDNGB4qOZPVY2iREeIAb/u2BUejW6LA5JQst7T2iIxGRkX11rADXbqoxJtIbK+dEio5jE1jaJMzEkX5YPisCDS1deG/3VWi03IObyFakXarAsQvlCPZ1wbNL4yCVcqa4MbC0Sagl04dhcqwf8sub8Y/DuZxRTmQDrpeo8cXRPLg6984Ud3bkmuLGwtImoSQSCZ68PxbDAtxw+moVjpwvEx2JiO5BrboDf999FQDw6+R4+Ho4C05kW1jaJJyjgwwvrEyAylWBr08UIKuwXnQkIhqCzm4t3knJQnuXFuvuG4ERYZ6iI9kck5Z2Xl4ekpKSsG3bNgBAVVUV1q1bhzVr1uCll15CTw8nH1EvTzdHvLAiAXKZFFv25aCivl10JCIaBL3egC37clDV0IEFE0Mxe0yQ6Eg2yWSl3dHRgTfffBPTpk3rf23z5s1Ys2YNtm/fjvDwcKSkpJjq8GSFhge548n7R6KzW4fNKVfQ1qkRHYmIBuibtAJkFTYgPsILj8zjTHFTMVlpKxQKbN26FX5+fv2vZWRkYP78+QCAxMREpKenm+rwZKWmjgrAg9OHoa6pC3/ffRVaHWeUE1m6U1mVOHyuDIHeSjy/LB4yKe+8morJRlYul8PJ6fal6jo7O6FQKAAA3t7eqKvjalj0U8tnRWB8jC9ulDZh+9E8zignsmB5ZU34/FAuXJzkeHFlApROnCluSsJGdyD/EHt6KiGXG39ReV9fN6O/J/3UvYzz756YjN++ewpplysxIsIbD84cbsRktoWfZ/PgOP9UTWMH3t+bDQOA3z8xGfHRvvf8nhznuzNraSuVSnR1dcHJyQk1NTW3XTr/OWp1h9Ez+Pq6oa6u1ejvS7czxjj/alk83vzf89i6JxuuChniIryMlM528PNsHhznn+rs1uKtbRfQ3NaDdQtjEOThdM9jxHHudbcfXMx642H69Ok4fPgwAODIkSOYNWuWOQ9PVsZb5YQNKxIglQJ/35ONqgbOKCeyBHqDAVu/vYbyunYkjg9G4vgQ0ZHshslKOzs7G+vWrcPu3bvx+eefY926ddiwYQP27NmDNWvWoKmpCcuXLzfV4clGRIWo8Piikejs1mLzzqto7+KMciLRdp8swuWCesSGe+LR+dGi49gVicGCZ/mY4jIJL7+Yh7HH+ZsTBTiYUYpRwzzxyiNjODu1Dz/P5sFx/lF6djW2fncNfp7OeH39RLg6OxjtvTnOvSzm8jjRUK2cE4kxkd64dlONr44ViI5DZJcKK5rx6cEbcHaU46WHEoxa2DQwLG2yClKpBM8ujUOwjwuOXShH2qUK0ZGI7EpjSxf+tusqdHo9nl8Wh0BvF9GR7BJLm6yGs6McL/b9dP/F0TxcL1GLjkRkF7p7dNi8s3ff+9XzojF6uLfoSHaLpXBmuzoAABVXSURBVE1WxdfDGb9OjgcA/H33VdSa4LFAIvqR3mDAR/uvobSmDbPHBCJpImeKi8TSJqszIswT6+4bgfau3h2FOru1oiMR2ax9p4txIbcOMaEeWLtwBCQSiehIdo2lTVZp9pggLJgYiqqGDmzZlwO93mIfgiCyWueu12DfmZvwUTnh18nxkMtYGaLxT4Cs1iPzIhEf4YWswgZ8k8YZ5UTGVFzVgo/3X4ejQoYXH0qAm1IhOhKBpU1WTCaV4vll8Qj0VuLwuTKcyqoUHYnIJqhbu/G3nVnQavV4bmkcQnxdRUeiPixtsmrKvp2FXJzk+PxQLvLKmkRHIrJqPRod3t2Vhaa2HjyUGImxUT6iI9EtWNpk9fy9lPjV8ngYDMB7u6+ivqlTdCQiq2QwGPDpwRsormrF9PgALJocJjoS/QuWNtmE2GFeeGxBNFo7NNi8MwtdPZxRTjRY+9NLkHGtBpHB7nh80UjOFLdALG2yGYnjQ5A4Phjlde3Y+u016C13WX0ii3Mhtw67ThbBy90RG1YkwEHOerBE/FMhm/Lo/GjEhnviUn49dp8sEh2HyCqU1rRi63c5UDhI8eLKBKhcOFPcUrG0yabIZVL8+/J4+Hk6Y396CdJzqkVHIrJoze092LwzCz0aPZ55MA5h/nfeYYrEY2mTzXF1dsBLDyXA2VGOTw/cQGFls+hIRBZJo9XjvV1X0djSjeTZwzFhhK/oSPQLWNpkkwK9XfD8sjjo9Hr8bedVNLZ0iY5EZFEMBgP+99ANFFQ0Y8oofzw4LVx0JBoAljbZrNHDvbF6XjRa+i7/dffoREcishiHz5Xhh+xqRAS64cnFnCluLVjaZNOSJoZg9phAlNa04eP9nFFOBACXC+rxzYkCeLgqsGFFAhQOMtGRaIBY2mTTJBIJ1i4cgZhQD2Tm1mHf6WLRkYiEKq9rw5Z9OXCQS/HCygR4ujmKjkSDwNImmyeXSfHr5Hj4qJyw78xNnLteIzoSkRCtHT3YnNJ7q+ipB2IREeguOhINEkub7IKbUoEXH0qAo0KGT/Zfx83qFtGRiMxKq9Pjvd3ZqG/uwtIZwzA51l90JBoCljbZjRBfVzy3NA4arR6bU7Kgbu0WHYnILAwGA7Yd6d1QZ8IIXyydGSE6Eg0RS5vsytgoHzyUGImmth68uysLPRrOKCfbl5pZjpNXqhDm74p/e2AUpJwpbrVY2mR3Fk0Ow/T4ABRXteLTgzdg4IxysmHZRQ346ng+3F0UeHFl7y0isl4sbbI7EokEjy8agchgd2Rcq8H+9BLRkYhMoqqhHe/vzYFMKsULK0bDy91JdCS6RyxtsksOchk2rEiAl7sjdp0swoXcOtGRiIyqrVODd1Ky0NmtxZOLRyIyWCU6EhkBS5vslqrvcqHCQYqt3+WgtKZVdCQio9Dq9Hh/TzZq1Z24f2o4psUHiI5ERsLSJrsW5u+GZx4chR6NHv/91WVkFdaLjkR0T5rbuvFOShaul6gxNsoHK+YMFx2JjIilTXZvwgg/rF80Al09WvzPN1nYnpoHjVYvOhbRoGUV1uONT84hp7gRo4d745klnClua+SiAxBZgrljgzE80B1b9uUgNbMcuaVNeG5pHIJ8XERHI/pFGq0eKWmFOJpZBrlMgkfnRyNpYgg3AbFBPNMm6hPm74Y3Hp+E2WOCUFbbhv/87DxOXqnkI2Fk0aoa2vH/Ps/E0cwyBHgp8fr6iVgwKZSFbaN4pk10C0eFDE8sHon4CC98dvAGPjt4A9lFDXh88Ui4ODmIjkfUz2Aw4FRWFban5qFHo8fsMYF4dH4Mn8O2cSxtop8xcaQfIgLdsfXbHGTm1qG4qgXPLIlDTKiH6GhE6OjS4LNDuci8UQuloxz/tnwUJo70Ex2LzICXx4nuwFvlhP+zZhyWz4xAY2s33t5+EXtPF0On5yQ1Eie/vAl//OQcMm/UIjpEhT89NZmFbUd4pk10FzKpFEtnRmBkuCe2fpuDvaeLce1mI55dEgdvFVeXIvPR6fX47ocS7DvTuyf8spkReHB6OGRSnnvZE/5pEw1ATKgHNvad0eSXN/ef6RCZQ0NzFzZtv4S9p4vh5eaI364Zj2UzI1jYdohn2kQD5OLkgH9fFodTEV7YnpqHv+/J5uQfMrnMG7X47OANdHRrMXGELydF2jmWNtEgSCQSzB4ThOgQFbbszcHJK1XIL2/Gc0vjEObvJjoe2ZDuHh2+PJaPk1cqoZBL8cTikZiVEMhHuewcr60QDUGgtwv+7/qJWDAxFFUNHfivzzNx5HwZn+kmoyitacV//m/vOgGhfq5444ne9QNY2MQzbaIhcpBL8WhSNOIiPPHx/uv46lg+rt1sxFP3x8LdRSE6Hlkhg8GA1MxyfJNWAK3OgKSJIXh4biQc5Lz9Qr14pk10jxIiffCfT01G3DBPZBU24I1PziG7uEF0LLIyLe09eCclC18ey4ezoxwvP5yANUkxLGy6DUubyAhUro54ZdVYPJIYhfZODf664wq+PlEArY7PdNMvyyluxB8/OYeswgbEDfPEn56ajIRIH9GxyALx8jiRkUglEiyaEoaR4R7YsjcHhzJKcaNEjeeWxsHfSyk6HlkgrU6PXSeLcCijFDKpBI8kRmHh5FDuzEV3xDNtIiMbFuCOPz45CTNGB+BmdSs2fnoeZ65WcZIa3aZG3YE//+MCDmWUws/TGa+tm4BFU8JY2HRXPNMmMgEnhRxPPzAK8RHe+PzwDXy8/zqyixuxbuEIKJ34186eGQwG/JBdjW1H89Ddo8OM+ACsWRADZ0d+LuiX8VNCZEJTRvljeJA7PtyXg4xrNSis6H2mOzJYJToaCdDZrcU/Dufi7LUaODvK8OzSUZg6KkB0LLIiZi3tjIwMvPTSS4iOjgYAxMTE4A9/+IM5IxCZna+HM3772HjsO1OM/T+U4K1tF7F8VgTunxoOqZSXQu1FYUUztuzLQX1zFyKD3PHs0jj4ejiLjkVWxuxn2pMnT8bmzZvNfVgioeQyKVbMjkRsuBc++u4adp0swrWbjXhmSRw83RxFxyMT0usNOHC2BHtOFcNgMOCBaeFYNjMCchmnFNHg8VNDZEax4b2P84yL9sGN0ia88XEGLuXViY5FJqJu7cZ/f3UJu04Wwd3FAb95dBxWzolkYdOQSQxmnNKakZGBP/3pTwgLC0NzczM2bNiAGTNm3PH7tVod5FxYgGyQwWDAwfSb+HhvNnq0eiyePgxPL42HowM/77bibHYVNu+4hNYODabEBeDFVeO4Uh7dM7OWdk1NDS5cuIDFixejrKwM69evx5EjR6BQ/PwHua6u1egZfH3dTPK+dDuO88CU17Vhy74cVNS1I9jHBc8ti0OIr+uAfz3H2TwGM849Gh12nCjAiYsVcJBLsWpeFBLHBXPd8AHg57mXr++dNx8y6zUaf39/3H///ZBIJAgLC4OPjw9qamrMGYHIooT4uuIP6ydi3vhgVNS34z8/y8SxC+V8pttKlde14c3PM3HiYgWCfVzwh8cnYt74EBY2GY1ZJ6Lt27cPdXV1ePrpp1FXV4eGhgb4+/ubMwKRxVE4yLB24QjERXjh0wM38MXRPOQUN+KpB2Lh6sx9k62BwWBA2qUKfHW8ABqtHonjg7EqMQoK3u4gIzPr5fG2tjb85je/QUtLCzQaDTZs2IA5c+bc8ft5edx6cZyHRt3aja3f5uBGaRM8XBV4ZkkcYsM97/j9HGfzuNs4t3Vq8OmB67iUXw8XJzmeuj8W42J8zZzQNvDz3Otul8fNWtqDxdK2XhznodPrDTiYUYLdJ3sfEbr/Lo8IcZzN407jfKNEja3fXYO6tRsjwzz4CN894ue5191KmyuiEVkYqVSCB6YNw8hwT2zZm4P96SW4XqLGs0vj4MfFOCyCVqfH3tPFOJBeAolEghWzh3OxHDILPixIZKEig1TY+ORkTB3lj6LKFmz85BzO5lSLjmX36po68fYXF7E/vQTeKif8fu14PDh9GAubzIJn2kQWTOkkxzNLRiEuwgvbjubhw2+vIbu4EY9xgwkhzl6rxj8O56KzW4cpo/y5AQyZHT9tRBZOIpFgxuhARIWosGVvDn7IrkZB38Yjd7v3RcbT0aXBx99dw5nsajg6yPD0A7GYHh/AR7nI7DgRjUyC42waWp0eu08W4WBGKWRSCVYkRiE60B3DAt24NKaRGQwG1DV3IbdUjcPnylBZ347wADc8vzQO/l5K0fFsEv/d6MWJaEQ2Qi6T4uHEKIwa1rvxyDfH8gEADnIpIoPcERPqgZhQD0QGqeCo4DPCg6E3GFBZ3478sibkljUhr6wJTW09/V9fNCUMK2YP5w9HJBTPtMkkOM6m19GlRVljBzKzq5FX3oTy2jb88y+zTCpBeIBbb4mHeCA6VAUXJy7UciudXo/Smjbk9RV0XlkT2ru0/V93d1EgJkSFmFAPzBwfCid2tcnx341ePNMmskFKJzlmjgnGiCB3AEB7lwb55c3IK2tCflkTbla3oqiyBYcySiEBEOzrihGhvQUeE+oBD1f7ep5Yo9WhqLKlt6DLm1FQ0YzuHl3/131UTkiI9MGIsN6rFf6ezv33rFkmZClY2kQ2wsXJAWOjfDA2ygcA0N2jQ2Flc/9ZZGFlC8rr2nDsYjkAwN/TGdGhHhjRd0ndR+VkUxOrOru1KKxoRm7fDzFFVS3Q6n68sBjorez7Iab3aoS3yklgWqKBYWkT2ShHhQyjhnlh1DAvAL2T2G5WtSKvvLfE88ubcDqrCqezqgAAnm6O/ffEY0I9EOSttKoSb+3o6b/SkFvWhNKaVvzz5p9EAoT59d0uCFUhOsSD22SSVWJpE9kJuUyKqBAVokJUuH9qOPR6A8pq2/pLPK+sCRnXapBxrXfnPVdnB0SHqHrPxMM8EOrnCpnUcm7sNrZ09WXvLerK+vb+r8mkEkQG92aPDvFAVLCKz1OTTeCnmMhOSfsmq4UHuGHBxFAYDAZUN3bcNjHrUn49LuXXA+g9c48OVvWfiUcEusNBbp4SNxgMqFV39ufKLWtCfXNX/9cVDlKMGubZP/FueJA7d9gim8TSJiIAvYu4BHq7INDbBXPGBgMA6ps7kV/W3P8IVHZxI7KLGwH0nrkP73/MTIXIIJXRVmnTGwyoqGu/7QeI5vYfH79SOsoxNsoHMX0T68L9+Zw62QeWNhHdkY/KGT4qZ0yLDwAANLf3IP+WIv3n/wcAqUSC8ADXWx4z8xjwfuBanR4lNa1979mM/PLbH79SuSgwaaRf/1l+sK8LpFZ0v53IWFjaRDRgKhcFJo70w8SRfgB6l/csqPjxTPxmVSuKq1px+FwZACDY1wUxIT9ObvvntpU9mlsfv2pCQUUzejT6/uP4qJz6z6RjQj3gd8vjV0T2jKVNREOmdHJAQqQPEiL7HjO7tYzLmlBY0YyKunacuFQBAPD1cIK7UoGb1a3Q6X98/CrIx6X/MntMiAe83Pn4FdHPYWkTkdE4OsgQG+6J2HBPAH2Xvatb+yeP5Zc3o765C2H+bv3Ph0eHqOCm5ONXRAPB0iYik5HLpIgMViEyWIXFfY+ZaXV6zuwmGiKWNhGZjVQqgULKwiYaKj4jQUREZCVY2kRERFaCpU1ERGQlWNpERERWgqVNRERkJVjaREREVoKlTUREZCVY2kRERFaCpU1ERGQlWNpERERWgqVNRERkJSQGg8Hwy99GREREovFMm4iIyEqwtImIiKwES5uIiMhKsLSJiIisBEubiIjISrC0iYiIrITdlPaf//xnrFq1CqtXr0ZWVpboODZt06ZNWLVqFVauXIkjR46IjmPTurq6kJSUhF27domOYrP27duHpUuXYsWKFUhLSxMdxya1t7djw4YNWLduHVavXo1Tp06JjmSx5KIDmMO5c+dQUlKCHTt2oLCwEK+99hp27NghOpZNOnv2LPLz87Fjxw6o1WokJydj4cKFomPZrPfffx8qlUp0DJulVqvx3nvvYefOnejo6MDf/vY3zJ07V3Qsm7N7925ERETgP/7jP1BTU4PHH38chw4dEh3LItlFaaenpyMpKQkAEBkZiebmZrS1tcHV1VVwMtszadIkJCQkAADc3d3R2dkJnU4HmUwmOJntKSwsREFBAUvEhNLT0zFt2jS4urrC1dUVb775puhINsnT0xO5ubkAgJaWFnh6egpOZLns4vJ4fX39bR8CLy8v1NXVCUxku2QyGZRKJQAgJSUFs2fPZmGbyNtvv43f/e53omPYtPLycnR1deH555/HmjVrkJ6eLjqSTXrggQdQWVmJBQsWYO3atfjtb38rOpLFsosz7X/FlVtNLzU1FSkpKfjkk09ER7FJe/bswdixYxEaGio6is1ramrCu+++i8rKSqxfvx4nTpyARCIRHcum7N27F0FBQfj4449x48YNvPbaa5yncQd2Udp+fn6or6/v/+/a2lr4+voKTGTbTp06hQ8++AAfffQR3NzcRMexSWlpaSgrK0NaWhqqq6uhUCgQEBCA6dOni45mU7y9vTFu3DjI5XKEhYXBxcUFjY2N8Pb2Fh3Nply8eBEzZ84EAIwcORK1tbW8rXYHdnF5fMaMGTh8+DAAICcnB35+fryfbSKtra3YtGkTtmzZAg8PD9FxbNb//M//YOfOnfj666/x8MMP41e/+hUL2wRmzpyJs2fPQq/XQ61Wo6Ojg/dbTSA8PBxXrlwBAFRUVMDFxYWFfQd2caY9fvx4xMXFYfXq1ZBIJPjjH/8oOpLNOnDgANRqNV5++eX+195++20EBQUJTEU0NP7+/rjvvvvwyCOPAABef/11SKV2ca5jVqtWrcJrr72GtWvXQqvVYuPGjaIjWSxuzUlERGQl+CMjERGRlWBpExERWQmWNhERkZVgaRMREVkJljYREZGVYGkTEQDg6tWrSEpKQltbW/9rb775Jt5++22BqYjoVixtIgIAjB49GsuXL8df/vIXAEBmZibOnTt32zP3RCQWS5uI+j3//PPIzc1FamoqNm7ciLfeeguOjo6iYxFRHy6uQkS3KSoqwvLly/HEE0/g1VdfFR2HiG7BM20iuk1eXh5CQkJw8eJF7ohHZGFY2kTUr66uDn/961/x6aefws/PD59//rnoSER0C14eJ6J+zz77LBYvXozk5GQ0NjZi5cqV+OyzzxAeHi46GhGBZ9pE1Oerr74CACQnJwMAvLy88Morr+D3v/899Hq9yGhE1Idn2kRERFaCZ9pERERWgqVNRERkJVjaREREVoKlTUREZCVY2kRERFaCpU1ERGQlWNpERERWgqVNRERkJf4/3ek+LXKuYowAAAAASUVORK5CYII=\n" 83 | }, 84 | "metadata": {} 85 | } 86 | ] 87 | }, 88 | { 89 | "cell_type": "code", 90 | "source": [ 91 | "# Gradient Descent \n", 92 | "# init x with any random value \n", 93 | "x = 9\n", 94 | "lr = 0.1 \n", 95 | "\n", 96 | "plt.plot(X,Y)\n", 97 | "for i in range(30):\n", 98 | " grad = 2*(x-5)\n", 99 | " x = x - lr * grad \n", 100 | " y = (x-5)**2 + 3 \n", 101 | " plt.scatter(x,y)\n", 102 | " print(x)\n", 103 | "\n", 104 | "plt.show()" 105 | ], 106 | "metadata": { 107 | "colab": { 108 | "base_uri": "https://localhost:8080/", 109 | "height": 883 110 | }, 111 | "id": "vRn--jojqnnC", 112 | "outputId": "f1bc9bf9-73a8-413b-b4e1-d901ded9dd61" 113 | }, 114 | "execution_count": null, 115 | "outputs": [ 116 | { 117 | "output_type": "stream", 118 | "name": "stdout", 119 | "text": [ 120 | "8.2\n", 121 | "7.56\n", 122 | "7.048\n", 123 | "6.6384\n", 124 | "6.31072\n", 125 | "6.048576\n", 126 | "5.8388608\n", 127 | "5.67108864\n", 128 | "5.5368709119999995\n", 129 | "5.429496729599999\n", 130 | "5.34359738368\n", 131 | "5.274877906944\n", 132 | "5.2199023255552\n", 133 | "5.17592186044416\n", 134 | "5.140737488355328\n", 135 | "5.1125899906842625\n", 136 | "5.09007199254741\n", 137 | "5.072057594037927\n", 138 | "5.057646075230342\n", 139 | "5.046116860184274\n", 140 | "5.0368934881474186\n", 141 | "5.0295147905179345\n", 142 | "5.023611832414348\n", 143 | "5.018889465931478\n", 144 | "5.015111572745182\n", 145 | "5.012089258196146\n", 146 | "5.009671406556917\n", 147 | "5.007737125245534\n", 148 | "5.006189700196427\n", 149 | "5.004951760157142\n" 150 | ] 151 | }, 152 | { 153 | "output_type": "display_data", 154 | "data": { 155 | "text/plain": [ 156 | "
" 157 | ], 158 | "image/png": "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\n" 159 | }, 160 | "metadata": {} 161 | } 162 | ] 163 | }, 164 | { 165 | "cell_type": "code", 166 | "source": [], 167 | "metadata": { 168 | "id": "G1naw6EAsDpF" 169 | }, 170 | "execution_count": null, 171 | "outputs": [] 172 | } 173 | ] 174 | } -------------------------------------------------------------------------------- /03 Dimensionality Reduction /PCA.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 104, 6 | "id": "78ddcaf5", 7 | "metadata": { 8 | "slideshow": { 9 | "slide_type": "skip" 10 | } 11 | }, 12 | "outputs": [], 13 | "source": [ 14 | "# jupyter nbconvert ./PCA.ipynb --to slides --post serve" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "id": "9d341bed", 20 | "metadata": { 21 | "slideshow": { 22 | "slide_type": "slide" 23 | } 24 | }, 25 | "source": [ 26 | "# What is PCA?\n", 27 | "- PCA is a dimensionality reduction technique.\n", 28 | "- It is a Feature Extraction algorithm, not a feature selection.\n", 29 | "\n", 30 | " convert n features to k, where k" 117 | ] 118 | }, 119 | "metadata": { 120 | "needs_background": "light" 121 | }, 122 | "output_type": "display_data" 123 | } 124 | ], 125 | "source": [ 126 | "\n", 127 | "x, u = [0,0.4],[0,0.4]\n", 128 | "plt.scatter(X, y)\n", 129 | "plt.xlabel(\"Age\")\n", 130 | "plt.ylabel(\"Salaries\")\n", 131 | "plt.arrow(0, 0, 0.5, 0.5, width = 0.05, color='red')\n", 132 | "# plt.show()\n", 133 | "plt.savefig(\"./imgs/frame_with_dir.jpg\")" 134 | ] 135 | }, 136 | { 137 | "cell_type": "markdown", 138 | "id": "5181b00d", 139 | "metadata": { 140 | "slideshow": { 141 | "slide_type": "subslide" 142 | } 143 | }, 144 | "source": [ 145 | "**Now 2D data looks like this. Which feature would you choose?**\n", 146 | "\n", 147 | "\n", 148 | "\n", 149 | "\n", 150 | "**Idea:**\n", 151 | "1. Find the directions $f_1^{'}$ and $f_2^{'}$. such that spread on $f_1^{'}$ >> spread on $f_2^{'}$\n", 152 | "2. Drop $f_2^{'}$\n", 153 | "3. Project all data points onto $f_1^{'}$\n", 154 | "\n", 155 | " - Thus 2D -> 1D\n", 156 | " - It is like the rotation of axis\n", 157 | " \n", 158 | " \n", 159 | " \n", 160 | "
\n", 161 | "\n", 162 | "**Note:** \n", 163 | "Find a direction such that the variance of $x^{i}$ projected onto the direction is maximized." 164 | ] 165 | }, 166 | { 167 | "cell_type": "markdown", 168 | "id": "2a55c5cd", 169 | "metadata": { 170 | "slideshow": { 171 | "slide_type": "slide" 172 | } 173 | }, 174 | "source": [ 175 | "# PCA Objective - Maximizing Variance" 176 | ] 177 | }, 178 | { 179 | "cell_type": "markdown", 180 | "id": "4ea98365", 181 | "metadata": { 182 | "slideshow": { 183 | "slide_type": "subslide" 184 | } 185 | }, 186 | "source": [ 187 | "\n", 188 | "\n", 189 | "$\\Large u_1 : unit vector $, $\\large ||u|| = 1$\n", 190 | "\n", 191 | "\n", 192 | "\n", 193 | "\n", 194 | "$\\huge x_i^{'} = proj_{u1} (x_i) $\n", 195 | "\n", 196 | "$\\huge x_i^{'} = \\frac{u_1.x_i}{||u_1||} $\n", 197 | "\n", 198 | "$\\huge x_i^{'} = u_1^T.x_i $\n", 199 | "\n", 200 | "
\n", 201 | "Find $u_1$ such that var{$proj_{u1} (x_i)$} is maximum." 202 | ] 203 | }, 204 | { 205 | "cell_type": "markdown", 206 | "id": "c8c2b508", 207 | "metadata": { 208 | "slideshow": { 209 | "slide_type": "slide" 210 | } 211 | }, 212 | "source": [ 213 | "# PCA Objective - Minimizing Distances" 214 | ] 215 | }, 216 | { 217 | "cell_type": "markdown", 218 | "id": "5305afc2", 219 | "metadata": { 220 | "slideshow": { 221 | "slide_type": "subslide" 222 | } 223 | }, 224 | "source": [ 225 | "\n", 226 | "\n", 227 | "$\\Large min_{u_1} \\sum_{i=1}^{m} {d_i^2} $ \n", 228 | "\n", 229 | "\n", 230 | "\n", 231 | "
\n", 232 | "Find $u_1$ such that if we take all the distance sqaured from each point on $u_1$ , it should be minimized." 233 | ] 234 | }, 235 | { 236 | "cell_type": "markdown", 237 | "id": "0d911785", 238 | "metadata": { 239 | "slideshow": { 240 | "slide_type": "slide" 241 | } 242 | }, 243 | "source": [ 244 | "# Eigen Values and Eigen Vectors" 245 | ] 246 | }, 247 | { 248 | "cell_type": "markdown", 249 | "id": "1aba7e1e", 250 | "metadata": { 251 | "slideshow": { 252 | "slide_type": "subslide" 253 | } 254 | }, 255 | "source": [ 256 | "#### Equation : \n", 257 | "$\\Large \\lambda_1.v_1 = S.v_1$\n", 258 | "\n", 259 | "where:\n", 260 | "\n", 261 | "$\\lambda_1 : eigen value$\n", 262 | ", $v_1 : eigen vector$\n", 263 | ", $S : Covariance Matrix$" 264 | ] 265 | }, 266 | { 267 | "cell_type": "markdown", 268 | "id": "0f2e497f", 269 | "metadata": { 270 | "slideshow": { 271 | "slide_type": "slide" 272 | } 273 | }, 274 | "source": [ 275 | "# PCA Summary\n", 276 | "\n", 277 | "1. Column Standardise\n", 278 | "2. $ \\large S = \\frac{X^T.X}{m}$\n", 279 | "3. compute eigen values & eigenvectors of S.
\n", 280 | " $eigen(S) = (\\lambda_1 \\geq \\lambda_2 \\geq \\lambda_3 ... \\geq \\lambda_n$)\n", 281 | "and \n", 282 | "( $v_1, v_2, v_3 ... v_n$ )\n", 283 | "4. $u_1 = v_1$ and $u_2 = v_2 ...$" 284 | ] 285 | }, 286 | { 287 | "cell_type": "markdown", 288 | "id": "2d0c9050", 289 | "metadata": { 290 | "slideshow": { 291 | "slide_type": "slide" 292 | } 293 | }, 294 | "source": [ 295 | "# Understanding Eigen-values" 296 | ] 297 | } 298 | ], 299 | "metadata": { 300 | "celltoolbar": "Slideshow", 301 | "kernelspec": { 302 | "display_name": "Python 3", 303 | "language": "python", 304 | "name": "python3" 305 | }, 306 | "language_info": { 307 | "codemirror_mode": { 308 | "name": "ipython", 309 | "version": 3 310 | }, 311 | "file_extension": ".py", 312 | "mimetype": "text/x-python", 313 | "name": "python", 314 | "nbconvert_exporter": "python", 315 | "pygments_lexer": "ipython3", 316 | "version": "3.8.8" 317 | } 318 | }, 319 | "nbformat": 4, 320 | "nbformat_minor": 5 321 | } 322 | -------------------------------------------------------------------------------- /04 PCA/PCA.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 104, 6 | "id": "78ddcaf5", 7 | "metadata": { 8 | "slideshow": { 9 | "slide_type": "skip" 10 | } 11 | }, 12 | "outputs": [], 13 | "source": [ 14 | "# jupyter nbconvert ./PCA.ipynb --to slides --post serve" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "id": "9d341bed", 20 | "metadata": { 21 | "slideshow": { 22 | "slide_type": "slide" 23 | } 24 | }, 25 | "source": [ 26 | "# What is PCA?\n", 27 | "- PCA is a dimensionality reduction technique.\n", 28 | "- It is a Feature Extraction algorithm, not a feature selection.\n", 29 | "\n", 30 | " convert n features to k, where k" 117 | ] 118 | }, 119 | "metadata": { 120 | "needs_background": "light" 121 | }, 122 | "output_type": "display_data" 123 | } 124 | ], 125 | "source": [ 126 | "\n", 127 | "x, u = [0,0.4],[0,0.4]\n", 128 | "plt.scatter(X, y)\n", 129 | "plt.xlabel(\"Age\")\n", 130 | "plt.ylabel(\"Salaries\")\n", 131 | "plt.arrow(0, 0, 0.5, 0.5, width = 0.05, color='red')\n", 132 | "# plt.show()\n", 133 | "plt.savefig(\"./imgs/frame_with_dir.jpg\")" 134 | ] 135 | }, 136 | { 137 | "cell_type": "markdown", 138 | "id": "5181b00d", 139 | "metadata": { 140 | "slideshow": { 141 | "slide_type": "subslide" 142 | } 143 | }, 144 | "source": [ 145 | "**Now 2D data looks like this. Which feature would you choose?**\n", 146 | "\n", 147 | "\n", 148 | "\n", 149 | "\n", 150 | "**Idea:**\n", 151 | "1. Find the directions $f_1^{'}$ and $f_2^{'}$. such that spread on $f_1^{'}$ >> spread on $f_2^{'}$\n", 152 | "2. Drop $f_2^{'}$\n", 153 | "3. Project all data points onto $f_1^{'}$\n", 154 | "\n", 155 | " - Thus 2D -> 1D\n", 156 | " - It is like the rotation of axis\n", 157 | " \n", 158 | " \n", 159 | " \n", 160 | "
\n", 161 | "\n", 162 | "**Note:** \n", 163 | "Find a direction such that the variance of $x^{i}$ projected onto the direction is maximized." 164 | ] 165 | }, 166 | { 167 | "cell_type": "markdown", 168 | "id": "2a55c5cd", 169 | "metadata": { 170 | "slideshow": { 171 | "slide_type": "slide" 172 | } 173 | }, 174 | "source": [ 175 | "# PCA Objective - Maximizing Variance" 176 | ] 177 | }, 178 | { 179 | "cell_type": "markdown", 180 | "id": "4ea98365", 181 | "metadata": { 182 | "slideshow": { 183 | "slide_type": "subslide" 184 | } 185 | }, 186 | "source": [ 187 | "\n", 188 | "\n", 189 | "$\\Large u_1 : unit vector $, $\\large ||u|| = 1$\n", 190 | "\n", 191 | "\n", 192 | "\n", 193 | "\n", 194 | "$\\huge x_i^{'} = proj_{u1} (x_i) $\n", 195 | "\n", 196 | "$\\huge x_i^{'} = \\frac{u_1.x_i}{||u_1||} $\n", 197 | "\n", 198 | "$\\huge x_i^{'} = u_1^T.x_i $\n", 199 | "\n", 200 | "
\n", 201 | "Find $u_1$ such that var{$proj_{u1} (x_i)$} is maximum." 202 | ] 203 | }, 204 | { 205 | "cell_type": "markdown", 206 | "id": "c8c2b508", 207 | "metadata": { 208 | "slideshow": { 209 | "slide_type": "slide" 210 | } 211 | }, 212 | "source": [ 213 | "# PCA Objective - Minimizing Distances" 214 | ] 215 | }, 216 | { 217 | "cell_type": "markdown", 218 | "id": "5305afc2", 219 | "metadata": { 220 | "slideshow": { 221 | "slide_type": "subslide" 222 | } 223 | }, 224 | "source": [ 225 | "\n", 226 | "\n", 227 | "$\\Large min_{u_1} \\sum_{i=1}^{m} {d_i^2} $ \n", 228 | "\n", 229 | "\n", 230 | "\n", 231 | "
\n", 232 | "Find $u_1$ such that if we take all the distance sqaured from each point on $u_1$ , it should be minimized." 233 | ] 234 | }, 235 | { 236 | "cell_type": "markdown", 237 | "id": "0d911785", 238 | "metadata": { 239 | "slideshow": { 240 | "slide_type": "slide" 241 | } 242 | }, 243 | "source": [ 244 | "# Eigen Values and Eigen Vectors" 245 | ] 246 | }, 247 | { 248 | "cell_type": "markdown", 249 | "id": "1aba7e1e", 250 | "metadata": { 251 | "slideshow": { 252 | "slide_type": "subslide" 253 | } 254 | }, 255 | "source": [ 256 | "#### Equation : \n", 257 | "$\\Large \\lambda_1.v_1 = S.v_1$\n", 258 | "\n", 259 | "where:\n", 260 | "\n", 261 | "$\\lambda_1 : eigen value$\n", 262 | ", $v_1 : eigen vector$\n", 263 | ", $S : Covariance Matrix$" 264 | ] 265 | }, 266 | { 267 | "cell_type": "markdown", 268 | "id": "0f2e497f", 269 | "metadata": { 270 | "slideshow": { 271 | "slide_type": "slide" 272 | } 273 | }, 274 | "source": [ 275 | "# PCA Summary\n", 276 | "\n", 277 | "1. Column Standardise\n", 278 | "2. $ \\large S = \\frac{X^T.X}{m}$\n", 279 | "3. compute eigen values & eigenvectors of S.
\n", 280 | " $eigen(S) = (\\lambda_1 \\geq \\lambda_2 \\geq \\lambda_3 ... \\geq \\lambda_n$)\n", 281 | "and \n", 282 | "( $v_1, v_2, v_3 ... v_n$ )\n", 283 | "4. $u_1 = v_1$ and $u_2 = v_2 ...$" 284 | ] 285 | }, 286 | { 287 | "cell_type": "markdown", 288 | "id": "2d0c9050", 289 | "metadata": { 290 | "slideshow": { 291 | "slide_type": "slide" 292 | } 293 | }, 294 | "source": [ 295 | "# Understanding Eigen-values" 296 | ] 297 | } 298 | ], 299 | "metadata": { 300 | "celltoolbar": "Slideshow", 301 | "kernelspec": { 302 | "display_name": "Python 3", 303 | "language": "python", 304 | "name": "python3" 305 | }, 306 | "language_info": { 307 | "codemirror_mode": { 308 | "name": "ipython", 309 | "version": 3 310 | }, 311 | "file_extension": ".py", 312 | "mimetype": "text/x-python", 313 | "name": "python", 314 | "nbconvert_exporter": "python", 315 | "pygments_lexer": "ipython3", 316 | "version": "3.8.8" 317 | } 318 | }, 319 | "nbformat": 4, 320 | "nbformat_minor": 5 321 | } 322 | -------------------------------------------------------------------------------- /06 K-Means/K_Means.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "provenance": [] 7 | }, 8 | "kernelspec": { 9 | "name": "python3", 10 | "display_name": "Python 3" 11 | }, 12 | "language_info": { 13 | "name": "python" 14 | } 15 | }, 16 | "cells": [ 17 | { 18 | "cell_type": "code", 19 | "execution_count": null, 20 | "metadata": { 21 | "id": "Tx7p2psca6Bm" 22 | }, 23 | "outputs": [], 24 | "source": [ 25 | "# K-Means is an example of Hard Clustering, where every point belongs only to one cluster." 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "source": [ 31 | "import numpy as np\n", 32 | "from matplotlib import pyplot as plt\n", 33 | "from sklearn.datasets import make_blobs" 34 | ], 35 | "metadata": { 36 | "id": "DkDRsz8cbRut" 37 | }, 38 | "execution_count": null, 39 | "outputs": [] 40 | }, 41 | { 42 | "cell_type": "code", 43 | "source": [ 44 | "X,y = make_blobs(n_samples=500,n_features=2,centers=5,random_state=3)" 45 | ], 46 | "metadata": { 47 | "id": "u9BrV9JDbT6f" 48 | }, 49 | "execution_count": null, 50 | "outputs": [] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "source": [ 55 | "print(X.shape)" 56 | ], 57 | "metadata": { 58 | "colab": { 59 | "base_uri": "https://localhost:8080/" 60 | }, 61 | "id": "a_uX70OybaJ2", 62 | "outputId": "89278d43-beb3-4ef2-ca57-623c2373d034" 63 | }, 64 | "execution_count": null, 65 | "outputs": [ 66 | { 67 | "output_type": "stream", 68 | "name": "stdout", 69 | "text": [ 70 | "(500, 2)\n" 71 | ] 72 | } 73 | ] 74 | }, 75 | { 76 | "cell_type": "code", 77 | "source": [ 78 | "# not really needed\n", 79 | "np.unique(y)" 80 | ], 81 | "metadata": { 82 | "colab": { 83 | "base_uri": "https://localhost:8080/" 84 | }, 85 | "id": "FneaG_D2bdph", 86 | "outputId": "bdf08f81-0e07-415f-eabd-41c639472f37" 87 | }, 88 | "execution_count": null, 89 | "outputs": [ 90 | { 91 | "output_type": "execute_result", 92 | "data": { 93 | "text/plain": [ 94 | "array([0, 1, 2, 3, 4])" 95 | ] 96 | }, 97 | "metadata": {}, 98 | "execution_count": 5 99 | } 100 | ] 101 | }, 102 | { 103 | "cell_type": "code", 104 | "source": [ 105 | "# Data Visualise \n", 106 | "def normalise(X):\n", 107 | " u = X.mean(axis=0)\n", 108 | " std = X.std(axis=0)\n", 109 | " return (X-u)/std\n", 110 | "\n", 111 | "X = normalise(X)\n", 112 | "\n", 113 | "plt.scatter(X[:,0], X[:,1])\n", 114 | "plt.show()" 115 | ], 116 | "metadata": { 117 | "colab": { 118 | "base_uri": "https://localhost:8080/", 119 | "height": 265 120 | }, 121 | "id": "Y0cy--vRbgmF", 122 | "outputId": "c0fd9799-cf06-4007-a4b5-1dc11a2a0092" 123 | }, 124 | "execution_count": null, 125 | "outputs": [ 126 | { 127 | "output_type": "display_data", 128 | "data": { 129 | "text/plain": [ 130 | "
" 131 | ], 132 | "image/png": "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\n" 133 | }, 134 | "metadata": { 135 | "needs_background": "light" 136 | } 137 | } 138 | ] 139 | }, 140 | { 141 | "cell_type": "code", 142 | "source": [ 143 | "# Init the k-centers for k clusters \n", 144 | "\n", 145 | "k = 5\n", 146 | "colors = [\"green\",\"red\",\"blue\",\"yellow\",\"orange\"]\n", 147 | "n_features = 2\n", 148 | "\n", 149 | "def init(k):\n", 150 | " centroids = {}\n", 151 | " for i in range(k):\n", 152 | " center = 2*(2*np.random.random((n_features,)) - 1)\n", 153 | " \n", 154 | " centroids[i] = {\n", 155 | " 'center' : center,\n", 156 | " 'color' : colors[i],\n", 157 | " 'points' : []\n", 158 | " }\n", 159 | " return centroids\n", 160 | "\n", 161 | "centroids = init(k)" 162 | ], 163 | "metadata": { 164 | "id": "wWjVf-Bfbw0r" 165 | }, 166 | "execution_count": null, 167 | "outputs": [] 168 | }, 169 | { 170 | "cell_type": "code", 171 | "source": [ 172 | "def distance(p,q):\n", 173 | " return np.sqrt(np.sum((p-q)**2))\n", 174 | "\n", 175 | "# Step 2a\n", 176 | "def assignPtsToCluster(X,centroids):\n", 177 | " m = X.shape[0]\n", 178 | "\n", 179 | " # each point will be assigned to exactly one of the clusters \n", 180 | " for i in range(m):\n", 181 | " cdist = []\n", 182 | " cx = X[i]\n", 183 | " # find out distance of pt from each centroid\n", 184 | " for kx in range(k):\n", 185 | " d = distance(centroids[kx]['center'],cx)\n", 186 | " cdist.append(d)\n", 187 | "\n", 188 | " clusterId = np.argmin(cdist)\n", 189 | " #assign the point to the list of points that current_cluster holds\n", 190 | " centroids[clusterId]['points'].append(cx) " 191 | ], 192 | "metadata": { 193 | "id": "SGz40JEdevuG" 194 | }, 195 | "execution_count": null, 196 | "outputs": [] 197 | }, 198 | { 199 | "cell_type": "code", 200 | "source": [ 201 | "# Step 2b\n", 202 | "def updateClusters(centroids):\n", 203 | "\n", 204 | " # Update Every Centroid by taking a mean of points assigned to the cluster \n", 205 | " for kx in range(k):\n", 206 | " pts = np.array(centroids[kx]['points'])\n", 207 | "\n", 208 | " # if a cluster has non-zero points\n", 209 | " if pts.shape[0] > 0: \n", 210 | " newCenter = pts.mean(axis=0)\n", 211 | " centroids[kx]['center'] = newCenter \n", 212 | " centroids[kx]['points'] = [] #Clear the list for step 2a " 213 | ], 214 | "metadata": { 215 | "id": "8jpodvOxfSmY" 216 | }, 217 | "execution_count": null, 218 | "outputs": [] 219 | }, 220 | { 221 | "cell_type": "code", 222 | "source": [ 223 | "def plotClusters(centroids):\n", 224 | "\n", 225 | " for kx in range(k):\n", 226 | " pts = np.array(centroids[kx]['points'])\n", 227 | "\n", 228 | " # Plot the Points\n", 229 | " if(pts.shape[0]>0):\n", 230 | " plt.scatter(pts[:,0],pts[:,1],color=centroids[kx]['color'])\n", 231 | "\n", 232 | " # Plot the Cluster Center (Centroid)\n", 233 | " uk = centroids[kx]['center']\n", 234 | " plt.scatter(uk[0],uk[1],color='black',marker='*')" 235 | ], 236 | "metadata": { 237 | "id": "mzgL2qBjuYbU" 238 | }, 239 | "execution_count": null, 240 | "outputs": [] 241 | }, 242 | { 243 | "cell_type": "code", 244 | "source": [ 245 | "centroids = init(k)\n", 246 | "assignPtsToCluster(X,centroids)\n", 247 | "plotClusters(centroids)" 248 | ], 249 | "metadata": { 250 | "colab": { 251 | "base_uri": "https://localhost:8080/", 252 | "height": 265 253 | }, 254 | "id": "ObCJ5ZrHuZep", 255 | "outputId": "31334d3a-aac5-40d9-b81c-0af838c14018" 256 | }, 257 | "execution_count": null, 258 | "outputs": [ 259 | { 260 | "output_type": "display_data", 261 | "data": { 262 | "text/plain": [ 263 | "
" 264 | ], 265 | "image/png": "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\n" 266 | }, 267 | "metadata": { 268 | "needs_background": "light" 269 | } 270 | } 271 | ] 272 | }, 273 | { 274 | "cell_type": "code", 275 | "source": [ 276 | "assignPtsToCluster(X,centroids)\n", 277 | "plotClusters(centroids)\n", 278 | "updateClusters(centroids)" 279 | ], 280 | "metadata": { 281 | "colab": { 282 | "base_uri": "https://localhost:8080/", 283 | "height": 265 284 | }, 285 | "id": "MSEoYh8H2O3T", 286 | "outputId": "2a5193b2-a1ba-4c69-ea39-0ef0bd88f541" 287 | }, 288 | "execution_count": null, 289 | "outputs": [ 290 | { 291 | "output_type": "display_data", 292 | "data": { 293 | "text/plain": [ 294 | "
" 295 | ], 296 | "image/png": "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\n" 297 | }, 298 | "metadata": { 299 | "needs_background": "light" 300 | } 301 | } 302 | ] 303 | }, 304 | { 305 | "cell_type": "code", 306 | "source": [], 307 | "metadata": { 308 | "id": "nh1wK-ex2lKX" 309 | }, 310 | "execution_count": null, 311 | "outputs": [] 312 | } 313 | ] 314 | } -------------------------------------------------------------------------------- /07 Naive Bayes/Naive Bayes For Text Classification.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "b742be27", 6 | "metadata": {}, 7 | "source": [ 8 | "# Naive Bayes Classifier for Text Data\n", 9 | "\n", 10 | " " 11 | ] 12 | }, 13 | { 14 | "cell_type": "markdown", 15 | "id": "0df6d2a8", 16 | "metadata": {}, 17 | "source": [ 18 | "#### Multinomial Naive Bayes\n", 19 | "- Important is to compute the likelihood \n", 20 | "\n", 21 | "$$P(x_i|Y_i = c) = \\frac {count(x_i, Y_i = c)} {\\sum_{w \\in V}{count(w, Y_i=c)}} $$\n" 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": null, 27 | "id": "2e1977b2", 28 | "metadata": {}, 29 | "outputs": [], 30 | "source": [] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": null, 35 | "id": "bc032f5a", 36 | "metadata": {}, 37 | "outputs": [], 38 | "source": [] 39 | }, 40 | { 41 | "cell_type": "markdown", 42 | "id": "4bdc9be2", 43 | "metadata": {}, 44 | "source": [ 45 | "# Laplace Smoothing" 46 | ] 47 | }, 48 | { 49 | "cell_type": "markdown", 50 | "id": "187a8d0f", 51 | "metadata": {}, 52 | "source": [ 53 | "" 54 | ] 55 | }, 56 | { 57 | "cell_type": "code", 58 | "execution_count": null, 59 | "id": "c08e3ef6", 60 | "metadata": {}, 61 | "outputs": [], 62 | "source": [] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "execution_count": null, 67 | "id": "c181211a", 68 | "metadata": {}, 69 | "outputs": [], 70 | "source": [] 71 | }, 72 | { 73 | "cell_type": "markdown", 74 | "id": "ce330c2d", 75 | "metadata": {}, 76 | "source": [ 77 | "$$P(x_i|Y_i = c) = \\frac {count(x_i, Y_i = c) + \\alpha} {\\sum_{w \\in V}{count(w, Y_i=c)} + \\alpha |V|} $$" 78 | ] 79 | }, 80 | { 81 | "cell_type": "code", 82 | "execution_count": null, 83 | "id": "2065f18a", 84 | "metadata": {}, 85 | "outputs": [], 86 | "source": [] 87 | }, 88 | { 89 | "cell_type": "code", 90 | "execution_count": null, 91 | "id": "c755295b", 92 | "metadata": {}, 93 | "outputs": [], 94 | "source": [] 95 | }, 96 | { 97 | "cell_type": "markdown", 98 | "id": "ad0fe83b", 99 | "metadata": {}, 100 | "source": [ 101 | "# A Practical Example of Multinomial Naive Bayes" 102 | ] 103 | }, 104 | { 105 | "cell_type": "markdown", 106 | "id": "8c0ad33f", 107 | "metadata": {}, 108 | "source": [ 109 | "\n", 110 | " \n", 111 | " \n", 112 | " \n", 113 | " \n", 114 | " \n", 115 | " \n", 116 | " \n", 117 | " \n", 118 | " \n", 119 | " \n", 120 | " \n", 121 | " \n", 122 | " \n", 123 | " \n", 124 | " \n", 125 | " \n", 126 | " \n", 127 | " \n", 128 | " \n", 129 | " \n", 130 | " \n", 131 | " \n", 132 | " \n", 133 | " \n", 134 | " \n", 135 | " \n", 136 | " \n", 137 | " \n", 138 | " \n", 139 | " \n", 140 | " \n", 141 | " \n", 142 | " \n", 143 | "
docIDwords in documentc = China?
training set 1 Chinese Beijing Chinese yes
2 Chinese Chinese Shanghai yes
3 Chinese Macao yes
4 Tokyo Japan Chinese no
test set 5 Chinese Chinese Chinese Tokyo Japan ?
" 144 | ] 145 | }, 146 | { 147 | "cell_type": "code", 148 | "execution_count": null, 149 | "id": "71f0b1eb", 150 | "metadata": {}, 151 | "outputs": [], 152 | "source": [] 153 | }, 154 | { 155 | "cell_type": "code", 156 | "execution_count": null, 157 | "id": "7c419b85", 158 | "metadata": {}, 159 | "outputs": [], 160 | "source": [] 161 | }, 162 | { 163 | "cell_type": "code", 164 | "execution_count": null, 165 | "id": "2226f872", 166 | "metadata": {}, 167 | "outputs": [], 168 | "source": [] 169 | }, 170 | { 171 | "cell_type": "markdown", 172 | "id": "5a68e1bd", 173 | "metadata": {}, 174 | "source": [ 175 | "# Bernoulli Naive Bayes\n", 176 | "\n", 177 | "\n", 178 | "

\n", 179 | "\n", 180 | "1. Bernoulli doesn't talk about the frequency of a feature/word.\n", 181 | "1. It is only concerned about whether a word is present or not (1 or 0)." 182 | ] 183 | }, 184 | { 185 | "cell_type": "markdown", 186 | "id": "f75c721d", 187 | "metadata": {}, 188 | "source": [ 189 | "**Likelihood :**" 190 | ] 191 | }, 192 | { 193 | "cell_type": "markdown", 194 | "id": "31cc7a35", 195 | "metadata": {}, 196 | "source": [ 197 | "$$P(x_i|Y_i = c) = \\frac {count(d_i \\; contains \\; x_i, Y_i = c) + \\alpha} {{count(Y_i=c)} + 2.\\alpha \\, } $$" 198 | ] 199 | }, 200 | { 201 | "cell_type": "markdown", 202 | "id": "692c078a", 203 | "metadata": {}, 204 | "source": [ 205 | "**Prediction:**" 206 | ] 207 | }, 208 | { 209 | "cell_type": "markdown", 210 | "id": "4afee9a0", 211 | "metadata": {}, 212 | "source": [ 213 | "$$P(Y=1|X) = \\prod_{i=1}^{|V|} { P(x_i|Y=1)^b . \\big(1 - P(x_i|Y=spam)\\big)^{1-b}} * P(Y=1)$$" 214 | ] 215 | }, 216 | { 217 | "cell_type": "code", 218 | "execution_count": null, 219 | "id": "80f60524", 220 | "metadata": {}, 221 | "outputs": [], 222 | "source": [] 223 | }, 224 | { 225 | "cell_type": "code", 226 | "execution_count": null, 227 | "id": "b1f01fce", 228 | "metadata": {}, 229 | "outputs": [], 230 | "source": [] 231 | }, 232 | { 233 | "cell_type": "markdown", 234 | "id": "45b21dcc", 235 | "metadata": {}, 236 | "source": [ 237 | "## Example of Bernoulli Naive Bayes" 238 | ] 239 | }, 240 | { 241 | "cell_type": "markdown", 242 | "id": "afb80f67", 243 | "metadata": {}, 244 | "source": [ 245 | "\n", 246 | " \n", 247 | " \n", 248 | " \n", 249 | " \n", 250 | " \n", 251 | " \n", 252 | " \n", 253 | " \n", 254 | " \n", 255 | " \n", 256 | " \n", 257 | " \n", 258 | " \n", 259 | " \n", 260 | " \n", 261 | " \n", 262 | " \n", 263 | " \n", 264 | " \n", 265 | " \n", 266 | " \n", 267 | " \n", 268 | " \n", 269 | " \n", 270 | " \n", 271 | " \n", 272 | " \n", 273 | " \n", 274 | " \n", 275 | " \n", 276 | " \n", 277 | " \n", 278 | " \n", 279 | "
docIDwords in documentc = China?
training set 1 Chinese Beijing Chinese yes
2 Chinese Chinese Shanghai yes
3 Chinese Macao yes
4 Tokyo Japan Chinese no
test set 5 Chinese Chinese Chinese Tokyo Japan ?
" 280 | ] 281 | }, 282 | { 283 | "cell_type": "code", 284 | "execution_count": null, 285 | "id": "fb283260", 286 | "metadata": {}, 287 | "outputs": [], 288 | "source": [] 289 | }, 290 | { 291 | "cell_type": "code", 292 | "execution_count": null, 293 | "id": "17186f98", 294 | "metadata": {}, 295 | "outputs": [], 296 | "source": [] 297 | }, 298 | { 299 | "cell_type": "code", 300 | "execution_count": null, 301 | "id": "5bd8ea93", 302 | "metadata": {}, 303 | "outputs": [], 304 | "source": [] 305 | }, 306 | { 307 | "cell_type": "code", 308 | "execution_count": null, 309 | "id": "13d133ef", 310 | "metadata": {}, 311 | "outputs": [], 312 | "source": [] 313 | }, 314 | { 315 | "cell_type": "markdown", 316 | "id": "5c334eda", 317 | "metadata": {}, 318 | "source": [ 319 | "# Bias Variance Tradeoff " 320 | ] 321 | }, 322 | { 323 | "cell_type": "code", 324 | "execution_count": null, 325 | "id": "030837bf", 326 | "metadata": {}, 327 | "outputs": [], 328 | "source": [] 329 | }, 330 | { 331 | "cell_type": "code", 332 | "execution_count": null, 333 | "id": "ca46205a", 334 | "metadata": {}, 335 | "outputs": [], 336 | "source": [] 337 | }, 338 | { 339 | "cell_type": "code", 340 | "execution_count": null, 341 | "id": "3b3cfcd7", 342 | "metadata": {}, 343 | "outputs": [], 344 | "source": [] 345 | }, 346 | { 347 | "cell_type": "markdown", 348 | "id": "25edd7cf", 349 | "metadata": {}, 350 | "source": [ 351 | "# Gaussian Naive Bayes\n", 352 | "" 353 | ] 354 | }, 355 | { 356 | "cell_type": "code", 357 | "execution_count": null, 358 | "id": "1414e781", 359 | "metadata": {}, 360 | "outputs": [], 361 | "source": [] 362 | }, 363 | { 364 | "cell_type": "code", 365 | "execution_count": null, 366 | "id": "32ab6ad1", 367 | "metadata": {}, 368 | "outputs": [], 369 | "source": [] 370 | }, 371 | { 372 | "cell_type": "markdown", 373 | "id": "26944990", 374 | "metadata": {}, 375 | "source": [ 376 | "# Scikit Learn code for Naive Bayes" 377 | ] 378 | }, 379 | { 380 | "cell_type": "code", 381 | "execution_count": 5, 382 | "id": "99b564b7", 383 | "metadata": {}, 384 | "outputs": [], 385 | "source": [ 386 | "from sklearn.datasets import load_digits\n", 387 | "import matplotlib.pyplot as plt" 388 | ] 389 | }, 390 | { 391 | "cell_type": "code", 392 | "execution_count": 2, 393 | "id": "9c9a8f98", 394 | "metadata": {}, 395 | "outputs": [], 396 | "source": [ 397 | "digits = load_digits()" 398 | ] 399 | }, 400 | { 401 | "cell_type": "code", 402 | "execution_count": 4, 403 | "id": "5e687e3e", 404 | "metadata": {}, 405 | "outputs": [], 406 | "source": [ 407 | "X = digits.data\n", 408 | "y = digits.target" 409 | ] 410 | }, 411 | { 412 | "cell_type": "code", 413 | "execution_count": 6, 414 | "id": "67018a91", 415 | "metadata": {}, 416 | "outputs": [ 417 | { 418 | "data": { 419 | "text/plain": [ 420 | "(1797, 64)" 421 | ] 422 | }, 423 | "execution_count": 6, 424 | "metadata": {}, 425 | "output_type": "execute_result" 426 | } 427 | ], 428 | "source": [ 429 | "X.shape" 430 | ] 431 | }, 432 | { 433 | "cell_type": "code", 434 | "execution_count": 7, 435 | "id": "6cd49e35", 436 | "metadata": {}, 437 | "outputs": [ 438 | { 439 | "data": { 440 | "text/plain": [ 441 | "(1797,)" 442 | ] 443 | }, 444 | "execution_count": 7, 445 | "metadata": {}, 446 | "output_type": "execute_result" 447 | } 448 | ], 449 | "source": [ 450 | "y.shape" 451 | ] 452 | }, 453 | { 454 | "cell_type": "code", 455 | "execution_count": 12, 456 | "id": "8591ce65", 457 | "metadata": {}, 458 | "outputs": [ 459 | { 460 | "data": { 461 | "text/plain": [ 462 | "" 463 | ] 464 | }, 465 | "execution_count": 12, 466 | "metadata": {}, 467 | "output_type": "execute_result" 468 | }, 469 | { 470 | "data": { 471 | "image/png": "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\n", 472 | "text/plain": [ 473 | "
" 474 | ] 475 | }, 476 | "metadata": { 477 | "needs_background": "light" 478 | }, 479 | "output_type": "display_data" 480 | } 481 | ], 482 | "source": [ 483 | "plt.imshow(X[15].reshape(8,8), cmap=\"gray\")" 484 | ] 485 | }, 486 | { 487 | "cell_type": "code", 488 | "execution_count": 13, 489 | "id": "b9bf9de7", 490 | "metadata": {}, 491 | "outputs": [], 492 | "source": [ 493 | "from sklearn.model_selection import train_test_split" 494 | ] 495 | }, 496 | { 497 | "cell_type": "code", 498 | "execution_count": 14, 499 | "id": "5a19f993", 500 | "metadata": {}, 501 | "outputs": [], 502 | "source": [ 503 | "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)" 504 | ] 505 | }, 506 | { 507 | "cell_type": "code", 508 | "execution_count": 15, 509 | "id": "7355a199", 510 | "metadata": {}, 511 | "outputs": [], 512 | "source": [ 513 | "from sklearn.naive_bayes import MultinomialNB, BernoulliNB, GaussianNB" 514 | ] 515 | }, 516 | { 517 | "cell_type": "code", 518 | "execution_count": 16, 519 | "id": "1bca7e97", 520 | "metadata": {}, 521 | "outputs": [], 522 | "source": [ 523 | "mnb = MultinomialNB()\n", 524 | "bnb = BernoulliNB()\n", 525 | "gnb = GaussianNB()" 526 | ] 527 | }, 528 | { 529 | "cell_type": "code", 530 | "execution_count": 17, 531 | "id": "c6bb7ea0", 532 | "metadata": {}, 533 | "outputs": [ 534 | { 535 | "data": { 536 | "text/plain": [ 537 | "GaussianNB()" 538 | ] 539 | }, 540 | "execution_count": 17, 541 | "metadata": {}, 542 | "output_type": "execute_result" 543 | } 544 | ], 545 | "source": [ 546 | "mnb.fit(X_train, y_train)\n", 547 | "bnb.fit(X_train, y_train)\n", 548 | "gnb.fit(X_train, y_train)" 549 | ] 550 | }, 551 | { 552 | "cell_type": "code", 553 | "execution_count": 18, 554 | "id": "bd695746", 555 | "metadata": {}, 556 | "outputs": [ 557 | { 558 | "data": { 559 | "text/plain": [ 560 | "0.9111111111111111" 561 | ] 562 | }, 563 | "execution_count": 18, 564 | "metadata": {}, 565 | "output_type": "execute_result" 566 | } 567 | ], 568 | "source": [ 569 | "mnb.score(X_test, y_test)" 570 | ] 571 | }, 572 | { 573 | "cell_type": "code", 574 | "execution_count": 19, 575 | "id": "da6a9bfd", 576 | "metadata": {}, 577 | "outputs": [ 578 | { 579 | "data": { 580 | "text/plain": [ 581 | "0.8638888888888889" 582 | ] 583 | }, 584 | "execution_count": 19, 585 | "metadata": {}, 586 | "output_type": "execute_result" 587 | } 588 | ], 589 | "source": [ 590 | "bnb.score(X_test, y_test)" 591 | ] 592 | }, 593 | { 594 | "cell_type": "code", 595 | "execution_count": 20, 596 | "id": "182d7588", 597 | "metadata": {}, 598 | "outputs": [ 599 | { 600 | "data": { 601 | "text/plain": [ 602 | "0.8472222222222222" 603 | ] 604 | }, 605 | "execution_count": 20, 606 | "metadata": {}, 607 | "output_type": "execute_result" 608 | } 609 | ], 610 | "source": [ 611 | "gnb.score(X_test, y_test)" 612 | ] 613 | }, 614 | { 615 | "cell_type": "code", 616 | "execution_count": null, 617 | "id": "34bf7f7d", 618 | "metadata": {}, 619 | "outputs": [], 620 | "source": [] 621 | }, 622 | { 623 | "cell_type": "code", 624 | "execution_count": null, 625 | "id": "bfe95c1e", 626 | "metadata": {}, 627 | "outputs": [], 628 | "source": [] 629 | }, 630 | { 631 | "cell_type": "code", 632 | "execution_count": null, 633 | "id": "12e45472", 634 | "metadata": {}, 635 | "outputs": [], 636 | "source": [] 637 | }, 638 | { 639 | "cell_type": "code", 640 | "execution_count": null, 641 | "id": "fdcd1fd6", 642 | "metadata": {}, 643 | "outputs": [], 644 | "source": [] 645 | }, 646 | { 647 | "cell_type": "code", 648 | "execution_count": null, 649 | "id": "97f1706e", 650 | "metadata": {}, 651 | "outputs": [], 652 | "source": [] 653 | }, 654 | { 655 | "cell_type": "code", 656 | "execution_count": null, 657 | "id": "a9d49ec3", 658 | "metadata": {}, 659 | "outputs": [], 660 | "source": [] 661 | }, 662 | { 663 | "cell_type": "code", 664 | "execution_count": null, 665 | "id": "b72a931f", 666 | "metadata": {}, 667 | "outputs": [], 668 | "source": [] 669 | }, 670 | { 671 | "cell_type": "code", 672 | "execution_count": null, 673 | "id": "da356ad2", 674 | "metadata": {}, 675 | "outputs": [], 676 | "source": [] 677 | }, 678 | { 679 | "cell_type": "code", 680 | "execution_count": null, 681 | "id": "90610e4b", 682 | "metadata": {}, 683 | "outputs": [], 684 | "source": [] 685 | }, 686 | { 687 | "cell_type": "code", 688 | "execution_count": null, 689 | "id": "185c9a25", 690 | "metadata": {}, 691 | "outputs": [], 692 | "source": [] 693 | }, 694 | { 695 | "cell_type": "code", 696 | "execution_count": null, 697 | "id": "fcd33768", 698 | "metadata": {}, 699 | "outputs": [], 700 | "source": [] 701 | }, 702 | { 703 | "cell_type": "code", 704 | "execution_count": null, 705 | "id": "72355b8f", 706 | "metadata": {}, 707 | "outputs": [], 708 | "source": [] 709 | }, 710 | { 711 | "cell_type": "code", 712 | "execution_count": null, 713 | "id": "21f98f20", 714 | "metadata": {}, 715 | "outputs": [], 716 | "source": [] 717 | }, 718 | { 719 | "cell_type": "code", 720 | "execution_count": null, 721 | "id": "50dc6ea5", 722 | "metadata": {}, 723 | "outputs": [], 724 | "source": [] 725 | }, 726 | { 727 | "cell_type": "code", 728 | "execution_count": null, 729 | "id": "29ca6faa", 730 | "metadata": {}, 731 | "outputs": [], 732 | "source": [] 733 | } 734 | ], 735 | "metadata": { 736 | "kernelspec": { 737 | "display_name": "Python 3", 738 | "language": "python", 739 | "name": "python3" 740 | }, 741 | "language_info": { 742 | "codemirror_mode": { 743 | "name": "ipython", 744 | "version": 3 745 | }, 746 | "file_extension": ".py", 747 | "mimetype": "text/x-python", 748 | "name": "python", 749 | "nbconvert_exporter": "python", 750 | "pygments_lexer": "ipython3", 751 | "version": "3.8.8" 752 | } 753 | }, 754 | "nbformat": 4, 755 | "nbformat_minor": 5 756 | } 757 | -------------------------------------------------------------------------------- /08 Decision Trees/Decision Trees.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "46e436b7", 6 | "metadata": {}, 7 | "source": [ 8 | "# Decision Trees\n", 9 | "\n", 10 | "\n", 11 | "\n", 12 | "1. Decision trees are supervised models.\n", 13 | "1. Can be used for Both classification/regression tasks.\n", 14 | "1. They are simple tree like structure (hierarchical in nature).\n", 15 | "1. Decision trees can be thought as nested if else conditions. \n", 16 | "1. Highly interpretable models, easy to explain the workings.\n", 17 | "\n", 18 | "

\n", 19 | "\n" 20 | ] 21 | }, 22 | { 23 | "cell_type": "markdown", 24 | "id": "6f7b3ccb", 25 | "metadata": {}, 26 | "source": [ 27 | "# Why Decision Trees are popular?\n", 28 | "1. Easy to interpret and represent.\n", 29 | "1. Mimic human level thought. tries to take decisions like a human does.\n", 30 | "1. Ensemble models are made up of Decision trees that performs even better than individual Decision trees.\n", 31 | "1. When feature are categorical, Decision Trees are preffered over other models. " 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": null, 37 | "id": "5b0432f0", 38 | "metadata": {}, 39 | "outputs": [], 40 | "source": [] 41 | }, 42 | { 43 | "cell_type": "code", 44 | "execution_count": null, 45 | "id": "1830b8ea", 46 | "metadata": {}, 47 | "outputs": [], 48 | "source": [] 49 | }, 50 | { 51 | "cell_type": "code", 52 | "execution_count": null, 53 | "id": "dfd919e5", 54 | "metadata": {}, 55 | "outputs": [], 56 | "source": [] 57 | }, 58 | { 59 | "cell_type": "markdown", 60 | "id": "6b6c6815", 61 | "metadata": {}, 62 | "source": [ 63 | "# Decision Tree Example\n", 64 | "\n", 65 | "Q- Solve a Business Problem that wants to Predict whether a user clicks on an avdertisement of a car or not?\n", 66 | "\n", 67 | "\n", 68 | "\n", 69 | "

\n", 70 | "\n", 71 | "| Sex | Income | alreadyCar | Techy | Age |\n", 72 | "| ----------- | ----------- | ----------- | ----------- | ----------- |\n", 73 | "| M | <=5L | Yes | Yes | 18-25\n", 74 | "| F | 5L-15L | No | No | 25-50\n", 75 | "| | 15L+ | | | 50+\n" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": null, 81 | "id": "8bed2cfd", 82 | "metadata": {}, 83 | "outputs": [], 84 | "source": [] 85 | }, 86 | { 87 | "cell_type": "code", 88 | "execution_count": null, 89 | "id": "0137ced1", 90 | "metadata": {}, 91 | "outputs": [], 92 | "source": [] 93 | }, 94 | { 95 | "cell_type": "code", 96 | "execution_count": null, 97 | "id": "bb80770c", 98 | "metadata": {}, 99 | "outputs": [], 100 | "source": [] 101 | }, 102 | { 103 | "cell_type": "markdown", 104 | "id": "2b6e90e7", 105 | "metadata": {}, 106 | "source": [ 107 | "
\n", 108 | "\n", 109 | " \n", 110 | " Entropy is measure of randomness of a system.\n", 111 | " \n", 112 | " \n", 113 | "
" 114 | ] 115 | }, 116 | { 117 | "cell_type": "code", 118 | "execution_count": null, 119 | "id": "dbf28fb7", 120 | "metadata": {}, 121 | "outputs": [], 122 | "source": [] 123 | }, 124 | { 125 | "cell_type": "markdown", 126 | "id": "7f786299", 127 | "metadata": {}, 128 | "source": [ 129 | "# CODE : Entropy " 130 | ] 131 | }, 132 | { 133 | "cell_type": "code", 134 | "execution_count": 1, 135 | "id": "1dc24a72", 136 | "metadata": {}, 137 | "outputs": [], 138 | "source": [ 139 | "import numpy as np" 140 | ] 141 | }, 142 | { 143 | "cell_type": "code", 144 | "execution_count": 2, 145 | "id": "224d00cf", 146 | "metadata": {}, 147 | "outputs": [], 148 | "source": [ 149 | "def entropy(var):\n", 150 | " N = var.shape[0]\n", 151 | " values, counts = np.unique(var, return_counts=True )\n", 152 | " \n", 153 | " ent = 0.0\n", 154 | " \n", 155 | " for i in counts:\n", 156 | " p = i/N\n", 157 | " ent += (p * np.log2(p))\n", 158 | " \n", 159 | " return -ent" 160 | ] 161 | }, 162 | { 163 | "cell_type": "code", 164 | "execution_count": 3, 165 | "id": "635e0e79", 166 | "metadata": {}, 167 | "outputs": [], 168 | "source": [ 169 | "Y = np.array([1,0,0,1,0,1,0,1])" 170 | ] 171 | }, 172 | { 173 | "cell_type": "code", 174 | "execution_count": 4, 175 | "id": "28867b1b", 176 | "metadata": {}, 177 | "outputs": [], 178 | "source": [ 179 | "X = np.array([1,1,1,1,1,1,1])" 180 | ] 181 | }, 182 | { 183 | "cell_type": "code", 184 | "execution_count": 5, 185 | "id": "082b5ea3", 186 | "metadata": {}, 187 | "outputs": [ 188 | { 189 | "data": { 190 | "text/plain": [ 191 | "1.0" 192 | ] 193 | }, 194 | "execution_count": 5, 195 | "metadata": {}, 196 | "output_type": "execute_result" 197 | } 198 | ], 199 | "source": [ 200 | "entropy(Y)" 201 | ] 202 | }, 203 | { 204 | "cell_type": "code", 205 | "execution_count": 6, 206 | "id": "45553195", 207 | "metadata": {}, 208 | "outputs": [ 209 | { 210 | "data": { 211 | "text/plain": [ 212 | "-0.0" 213 | ] 214 | }, 215 | "execution_count": 6, 216 | "metadata": {}, 217 | "output_type": "execute_result" 218 | } 219 | ], 220 | "source": [ 221 | "entropy(X)" 222 | ] 223 | }, 224 | { 225 | "cell_type": "code", 226 | "execution_count": null, 227 | "id": "83dfef6c", 228 | "metadata": {}, 229 | "outputs": [], 230 | "source": [] 231 | }, 232 | { 233 | "cell_type": "code", 234 | "execution_count": null, 235 | "id": "fedecfd8", 236 | "metadata": {}, 237 | "outputs": [], 238 | "source": [] 239 | }, 240 | { 241 | "cell_type": "markdown", 242 | "id": "cf5be31d", 243 | "metadata": {}, 244 | "source": [ 245 | "# Information Gain" 246 | ] 247 | }, 248 | { 249 | "cell_type": "markdown", 250 | "id": "5d2b9507", 251 | "metadata": {}, 252 | "source": [ 253 | "\n", 254 | "\n", 255 | "\n", 256 | "

\n", 257 | "$$ Gain(Y, A) = H_D(Y) - \\sum_{i=1}^{k} \\frac{|D_i|} {|D|}{ H_{D_i}(Y)} $$" 258 | ] 259 | }, 260 | { 261 | "cell_type": "code", 262 | "execution_count": null, 263 | "id": "c182c047", 264 | "metadata": {}, 265 | "outputs": [], 266 | "source": [] 267 | }, 268 | { 269 | "cell_type": "markdown", 270 | "id": "5d8b3a16", 271 | "metadata": {}, 272 | "source": [ 273 | "# Golf Dataset\n", 274 | "\n", 275 | "" 276 | ] 277 | }, 278 | { 279 | "cell_type": "code", 280 | "execution_count": null, 281 | "id": "5bd3b92b", 282 | "metadata": {}, 283 | "outputs": [], 284 | "source": [] 285 | }, 286 | { 287 | "cell_type": "code", 288 | "execution_count": null, 289 | "id": "a20595cd", 290 | "metadata": {}, 291 | "outputs": [], 292 | "source": [] 293 | }, 294 | { 295 | "cell_type": "markdown", 296 | "id": "a46840bc", 297 | "metadata": {}, 298 | "source": [ 299 | "# CODE : Split Data" 300 | ] 301 | }, 302 | { 303 | "cell_type": "code", 304 | "execution_count": 7, 305 | "id": "d99f49fb", 306 | "metadata": {}, 307 | "outputs": [], 308 | "source": [ 309 | "import pandas as pd" 310 | ] 311 | }, 312 | { 313 | "cell_type": "code", 314 | "execution_count": 8, 315 | "id": "f4c23622", 316 | "metadata": {}, 317 | "outputs": [], 318 | "source": [ 319 | "df = pd.read_csv('golf.csv')" 320 | ] 321 | }, 322 | { 323 | "cell_type": "code", 324 | "execution_count": 9, 325 | "id": "54c8abba", 326 | "metadata": {}, 327 | "outputs": [ 328 | { 329 | "data": { 330 | "text/html": [ 331 | "
\n", 332 | "\n", 345 | "\n", 346 | " \n", 347 | " \n", 348 | " \n", 349 | " \n", 350 | " \n", 351 | " \n", 352 | " \n", 353 | " \n", 354 | " \n", 355 | " \n", 356 | " \n", 357 | " \n", 358 | " \n", 359 | " \n", 360 | " \n", 361 | " \n", 362 | " \n", 363 | " \n", 364 | " \n", 365 | " \n", 366 | " \n", 367 | " \n", 368 | " \n", 369 | " \n", 370 | " \n", 371 | " \n", 372 | " \n", 373 | " \n", 374 | " \n", 375 | " \n", 376 | " \n", 377 | " \n", 378 | " \n", 379 | " \n", 380 | " \n", 381 | " \n", 382 | " \n", 383 | " \n", 384 | " \n", 385 | " \n", 386 | " \n", 387 | " \n", 388 | " \n", 389 | " \n", 390 | " \n", 391 | " \n", 392 | " \n", 393 | " \n", 394 | " \n", 395 | " \n", 396 | " \n", 397 | " \n", 398 | "
OutlookTemperatureHumidityWindyPlay
0sunnyhothighFalseno
1sunnyhothighTrueno
2overcasthothighFalseyes
3rainymildhighFalseyes
4rainycoolnormalFalseyes
\n", 399 | "
" 400 | ], 401 | "text/plain": [ 402 | " Outlook Temperature Humidity Windy Play\n", 403 | "0 sunny hot high False no\n", 404 | "1 sunny hot high True no\n", 405 | "2 overcast hot high False yes\n", 406 | "3 rainy mild high False yes\n", 407 | "4 rainy cool normal False yes" 408 | ] 409 | }, 410 | "execution_count": 9, 411 | "metadata": {}, 412 | "output_type": "execute_result" 413 | } 414 | ], 415 | "source": [ 416 | "df.head()" 417 | ] 418 | }, 419 | { 420 | "cell_type": "code", 421 | "execution_count": 10, 422 | "id": "a4478e6e", 423 | "metadata": {}, 424 | "outputs": [], 425 | "source": [ 426 | "def divide_data(data, feature):\n", 427 | " # here we are working data frames.\n", 428 | " \n", 429 | " DATA = {}\n", 430 | " \n", 431 | " feat_values = list(data[feature].value_counts().index)\n", 432 | " occurence = list(data[feature].value_counts())\n", 433 | " \n", 434 | " for val in feat_values:\n", 435 | " DATA[val] = {'data' : pd.DataFrame([], columns = data.columns), 'len': 0}\n", 436 | " \n", 437 | " \n", 438 | " for ix in range(data.shape[0]):\n", 439 | " val = data[feature].iloc[ix]\n", 440 | " \n", 441 | " DATA[val]['data'] = DATA[val]['data'].append(data.iloc[ix])\n", 442 | " \n", 443 | " idx = feat_values.index(val)\n", 444 | " DATA[val]['len'] = occurence[idx]\n", 445 | " \n", 446 | " return DATA" 447 | ] 448 | }, 449 | { 450 | "cell_type": "code", 451 | "execution_count": 11, 452 | "id": "68913b46", 453 | "metadata": {}, 454 | "outputs": [ 455 | { 456 | "data": { 457 | "text/plain": [ 458 | "{'sunny': {'data': Outlook Temperature Humidity Windy Play\n", 459 | " 0 sunny hot high False no\n", 460 | " 1 sunny hot high True no\n", 461 | " 7 sunny mild high False no\n", 462 | " 8 sunny cool normal False yes\n", 463 | " 10 sunny mild normal True yes,\n", 464 | " 'len': 5},\n", 465 | " 'rainy': {'data': Outlook Temperature Humidity Windy Play\n", 466 | " 3 rainy mild high False yes\n", 467 | " 4 rainy cool normal False yes\n", 468 | " 5 rainy cool normal True no\n", 469 | " 9 rainy mild normal False yes\n", 470 | " 13 rainy mild high True no,\n", 471 | " 'len': 5},\n", 472 | " 'overcast': {'data': Outlook Temperature Humidity Windy Play\n", 473 | " 2 overcast hot high False yes\n", 474 | " 6 overcast cool normal True yes\n", 475 | " 11 overcast mild high True yes\n", 476 | " 12 overcast hot normal False yes,\n", 477 | " 'len': 4}}" 478 | ] 479 | }, 480 | "execution_count": 11, 481 | "metadata": {}, 482 | "output_type": "execute_result" 483 | } 484 | ], 485 | "source": [ 486 | "divide_data(df, 'Outlook')" 487 | ] 488 | }, 489 | { 490 | "cell_type": "code", 491 | "execution_count": null, 492 | "id": "5fcc80fd", 493 | "metadata": {}, 494 | "outputs": [], 495 | "source": [] 496 | }, 497 | { 498 | "cell_type": "markdown", 499 | "id": "b63a4ba2", 500 | "metadata": {}, 501 | "source": [ 502 | "# CODE : Information Gain" 503 | ] 504 | }, 505 | { 506 | "cell_type": "code", 507 | "execution_count": null, 508 | "id": "80762a03", 509 | "metadata": {}, 510 | "outputs": [], 511 | "source": [] 512 | }, 513 | { 514 | "cell_type": "code", 515 | "execution_count": 12, 516 | "id": "6d099d2d", 517 | "metadata": {}, 518 | "outputs": [], 519 | "source": [ 520 | "def information_gain(data, feature):\n", 521 | " examples = data.shape[0]\n", 522 | " \n", 523 | " DATA = divide_data(data, feature)\n", 524 | " \n", 525 | " keys = DATA.keys()\n", 526 | " \n", 527 | " \n", 528 | " ent_of_children = 0.0\n", 529 | " \n", 530 | " for key in keys:\n", 531 | " ent_of_children += ( (DATA[key]['len']/examples) * entropy(DATA[key]['data']['Play']) )\n", 532 | " \n", 533 | " info_gain = entropy(data['Play']) - ent_of_children\n", 534 | " return info_gain" 535 | ] 536 | }, 537 | { 538 | "cell_type": "code", 539 | "execution_count": 13, 540 | "id": "a4b2e0fd", 541 | "metadata": {}, 542 | "outputs": [ 543 | { 544 | "data": { 545 | "text/plain": [ 546 | "0.24674981977443933" 547 | ] 548 | }, 549 | "execution_count": 13, 550 | "metadata": {}, 551 | "output_type": "execute_result" 552 | } 553 | ], 554 | "source": [ 555 | "information_gain(df, 'Outlook')" 556 | ] 557 | }, 558 | { 559 | "cell_type": "code", 560 | "execution_count": 14, 561 | "id": "fe76c1f8", 562 | "metadata": {}, 563 | "outputs": [ 564 | { 565 | "data": { 566 | "text/plain": [ 567 | "0.04812703040826949" 568 | ] 569 | }, 570 | "execution_count": 14, 571 | "metadata": {}, 572 | "output_type": "execute_result" 573 | } 574 | ], 575 | "source": [ 576 | "information_gain(df, 'Windy')" 577 | ] 578 | }, 579 | { 580 | "cell_type": "code", 581 | "execution_count": 15, 582 | "id": "cc7ec047", 583 | "metadata": {}, 584 | "outputs": [ 585 | { 586 | "data": { 587 | "text/plain": [ 588 | "0.02922256565895487" 589 | ] 590 | }, 591 | "execution_count": 15, 592 | "metadata": {}, 593 | "output_type": "execute_result" 594 | } 595 | ], 596 | "source": [ 597 | "information_gain(df, 'Temperature')" 598 | ] 599 | }, 600 | { 601 | "cell_type": "code", 602 | "execution_count": 16, 603 | "id": "d7f6c7f9", 604 | "metadata": {}, 605 | "outputs": [ 606 | { 607 | "data": { 608 | "text/plain": [ 609 | "0.15183550136234159" 610 | ] 611 | }, 612 | "execution_count": 16, 613 | "metadata": {}, 614 | "output_type": "execute_result" 615 | } 616 | ], 617 | "source": [ 618 | "information_gain(df, 'Humidity')" 619 | ] 620 | }, 621 | { 622 | "cell_type": "code", 623 | "execution_count": null, 624 | "id": "ee7bb990", 625 | "metadata": {}, 626 | "outputs": [], 627 | "source": [] 628 | }, 629 | { 630 | "cell_type": "code", 631 | "execution_count": null, 632 | "id": "048f2724", 633 | "metadata": {}, 634 | "outputs": [], 635 | "source": [] 636 | }, 637 | { 638 | "cell_type": "markdown", 639 | "id": "01123d80", 640 | "metadata": {}, 641 | "source": [ 642 | "# Constructing a Decision Tree" 643 | ] 644 | }, 645 | { 646 | "cell_type": "markdown", 647 | "id": "8d00e2b3", 648 | "metadata": {}, 649 | "source": [ 650 | "" 651 | ] 652 | }, 653 | { 654 | "cell_type": "code", 655 | "execution_count": null, 656 | "id": "f95c18f5", 657 | "metadata": {}, 658 | "outputs": [], 659 | "source": [] 660 | }, 661 | { 662 | "cell_type": "code", 663 | "execution_count": null, 664 | "id": "12864330", 665 | "metadata": {}, 666 | "outputs": [], 667 | "source": [] 668 | }, 669 | { 670 | "cell_type": "code", 671 | "execution_count": null, 672 | "id": "62fe2268", 673 | "metadata": {}, 674 | "outputs": [], 675 | "source": [] 676 | }, 677 | { 678 | "cell_type": "markdown", 679 | "id": "ef39099d", 680 | "metadata": {}, 681 | "source": [ 682 | "\n", 683 | "


\n", 684 | "\n", 685 | "# Stopping Condition\n", 686 | "1. Pure Node\n", 687 | "2. Can't grow the tree anymore because of lack of points.\n", 688 | "3. If already reach a max depth." 689 | ] 690 | }, 691 | { 692 | "cell_type": "code", 693 | "execution_count": null, 694 | "id": "af16d86c", 695 | "metadata": {}, 696 | "outputs": [], 697 | "source": [] 698 | }, 699 | { 700 | "cell_type": "code", 701 | "execution_count": null, 702 | "id": "338e1435", 703 | "metadata": {}, 704 | "outputs": [], 705 | "source": [] 706 | }, 707 | { 708 | "cell_type": "markdown", 709 | "id": "0cf5738a", 710 | "metadata": {}, 711 | "source": [ 712 | "# CODE : Building a Decision Tree" 713 | ] 714 | }, 715 | { 716 | "cell_type": "code", 717 | "execution_count": null, 718 | "id": "2e5c50d1", 719 | "metadata": {}, 720 | "outputs": [], 721 | "source": [] 722 | }, 723 | { 724 | "cell_type": "code", 725 | "execution_count": 73, 726 | "id": "27d9a136", 727 | "metadata": {}, 728 | "outputs": [], 729 | "source": [ 730 | "class DecisionTree:\n", 731 | " \n", 732 | " # constructor\n", 733 | " def __init__(self, depth=0, max_depth=5):\n", 734 | " # Creating a Node\n", 735 | " self.children = {}\n", 736 | " self.fkey = None\n", 737 | " self.max_depth = max_depth\n", 738 | " self.depth = depth\n", 739 | " self.target = None\n", 740 | " \n", 741 | " def train(self, data):\n", 742 | " features = ['Outlook', 'Temperature', 'Humidity', 'Windy']\n", 743 | " \n", 744 | " info_gains = []\n", 745 | " \n", 746 | " for f in features:\n", 747 | " i_gain = information_gain(data, f)\n", 748 | " info_gains.append(i_gain)\n", 749 | " \n", 750 | " # finding the best feature\n", 751 | " self.fkey = features[np.argmax(info_gains)]\n", 752 | " \n", 753 | " #Spliting the Data\n", 754 | " DATA = divide_data(data, self.fkey)\n", 755 | " \n", 756 | " \n", 757 | " \n", 758 | " # Giving a target label to the Node\n", 759 | " labels = list(data['Play'].value_counts().index)\n", 760 | " freq = list(data['Play'].value_counts().values)\n", 761 | " \n", 762 | " self.target = labels[np.argmax(freq)]\n", 763 | " \n", 764 | " \n", 765 | " \n", 766 | " \n", 767 | " ###### STOPPING CONDITIONS ######\n", 768 | " \n", 769 | " have_data = 0\n", 770 | " keys = DATA.keys()\n", 771 | " \n", 772 | " for key in keys:\n", 773 | " if DATA[key]['len'] > 0:\n", 774 | " have_data +=1\n", 775 | " \n", 776 | " # 1. If it is pure node \n", 777 | " if have_data<2:\n", 778 | " return \n", 779 | " \n", 780 | " \n", 781 | " # 2. Early Stop if you have reached max depth\n", 782 | " if(self.depth >= self.max_depth):\n", 783 | " return\n", 784 | " \n", 785 | " \n", 786 | " print(\"\\t\"*self.depth + \"Making tree with - \", self.fkey)\n", 787 | " \n", 788 | " \n", 789 | " # Recursively train child Node\n", 790 | " for key in keys:\n", 791 | " new_data = DATA[key]['data']\n", 792 | " self.children[key] = DecisionTree(depth = self.depth + 1)\n", 793 | " self.children[key].train(new_data)\n", 794 | " \n", 795 | " return \n", 796 | " \n", 797 | " \n", 798 | " def predict(self, test):\n", 799 | " if self.children == {}:\n", 800 | " return self.target\n", 801 | " return self.children[test[self.fkey][0]].predict(test)" 802 | ] 803 | }, 804 | { 805 | "cell_type": "markdown", 806 | "id": "ddf41668", 807 | "metadata": {}, 808 | "source": [ 809 | "# Explore the Model" 810 | ] 811 | }, 812 | { 813 | "cell_type": "code", 814 | "execution_count": 74, 815 | "id": "b97cbf66", 816 | "metadata": {}, 817 | "outputs": [], 818 | "source": [ 819 | "model = DecisionTree()" 820 | ] 821 | }, 822 | { 823 | "cell_type": "code", 824 | "execution_count": 75, 825 | "id": "2e864622", 826 | "metadata": {}, 827 | "outputs": [ 828 | { 829 | "name": "stdout", 830 | "output_type": "stream", 831 | "text": [ 832 | "Making tree with - Outlook\n", 833 | "\tMaking tree with - Humidity\n", 834 | "\tMaking tree with - Windy\n" 835 | ] 836 | } 837 | ], 838 | "source": [ 839 | "model.train(df)" 840 | ] 841 | }, 842 | { 843 | "cell_type": "code", 844 | "execution_count": 76, 845 | "id": "816a2a32", 846 | "metadata": {}, 847 | "outputs": [ 848 | { 849 | "data": { 850 | "text/plain": [ 851 | "<__main__.DecisionTree at 0x7ff5d0abf100>" 852 | ] 853 | }, 854 | "execution_count": 76, 855 | "metadata": {}, 856 | "output_type": "execute_result" 857 | } 858 | ], 859 | "source": [ 860 | "model" 861 | ] 862 | }, 863 | { 864 | "cell_type": "code", 865 | "execution_count": 77, 866 | "id": "aac46af2", 867 | "metadata": {}, 868 | "outputs": [ 869 | { 870 | "data": { 871 | "text/plain": [ 872 | "'yes'" 873 | ] 874 | }, 875 | "execution_count": 77, 876 | "metadata": {}, 877 | "output_type": "execute_result" 878 | } 879 | ], 880 | "source": [ 881 | "model.target" 882 | ] 883 | }, 884 | { 885 | "cell_type": "code", 886 | "execution_count": 78, 887 | "id": "b24dfda6", 888 | "metadata": {}, 889 | "outputs": [ 890 | { 891 | "data": { 892 | "text/plain": [ 893 | "'Outlook'" 894 | ] 895 | }, 896 | "execution_count": 78, 897 | "metadata": {}, 898 | "output_type": "execute_result" 899 | } 900 | ], 901 | "source": [ 902 | "model.fkey" 903 | ] 904 | }, 905 | { 906 | "cell_type": "code", 907 | "execution_count": 79, 908 | "id": "0d77bf3e", 909 | "metadata": {}, 910 | "outputs": [ 911 | { 912 | "data": { 913 | "text/plain": [ 914 | "{'sunny': <__main__.DecisionTree at 0x7ff5d0f565e0>,\n", 915 | " 'rainy': <__main__.DecisionTree at 0x7ff5d0eebf70>,\n", 916 | " 'overcast': <__main__.DecisionTree at 0x7ff5d0abfb50>}" 917 | ] 918 | }, 919 | "execution_count": 79, 920 | "metadata": {}, 921 | "output_type": "execute_result" 922 | } 923 | ], 924 | "source": [ 925 | "model.children" 926 | ] 927 | }, 928 | { 929 | "cell_type": "code", 930 | "execution_count": 80, 931 | "id": "f322409e", 932 | "metadata": {}, 933 | "outputs": [ 934 | { 935 | "data": { 936 | "text/plain": [ 937 | "<__main__.DecisionTree at 0x7ff5d0f565e0>" 938 | ] 939 | }, 940 | "execution_count": 80, 941 | "metadata": {}, 942 | "output_type": "execute_result" 943 | } 944 | ], 945 | "source": [ 946 | "model.children['sunny']" 947 | ] 948 | }, 949 | { 950 | "cell_type": "code", 951 | "execution_count": 81, 952 | "id": "967c084b", 953 | "metadata": {}, 954 | "outputs": [ 955 | { 956 | "data": { 957 | "text/plain": [ 958 | "'Humidity'" 959 | ] 960 | }, 961 | "execution_count": 81, 962 | "metadata": {}, 963 | "output_type": "execute_result" 964 | } 965 | ], 966 | "source": [ 967 | "model.children['sunny'].fkey" 968 | ] 969 | }, 970 | { 971 | "cell_type": "code", 972 | "execution_count": 82, 973 | "id": "1b1b6a37", 974 | "metadata": {}, 975 | "outputs": [ 976 | { 977 | "data": { 978 | "text/plain": [ 979 | "{'high': <__main__.DecisionTree at 0x7ff5d0ad6280>,\n", 980 | " 'normal': <__main__.DecisionTree at 0x7ff5d0ed82e0>}" 981 | ] 982 | }, 983 | "execution_count": 82, 984 | "metadata": {}, 985 | "output_type": "execute_result" 986 | } 987 | ], 988 | "source": [ 989 | "model.children['sunny'].children" 990 | ] 991 | }, 992 | { 993 | "cell_type": "code", 994 | "execution_count": 83, 995 | "id": "6cae8ba8", 996 | "metadata": {}, 997 | "outputs": [ 998 | { 999 | "data": { 1000 | "text/plain": [ 1001 | "{}" 1002 | ] 1003 | }, 1004 | "execution_count": 83, 1005 | "metadata": {}, 1006 | "output_type": "execute_result" 1007 | } 1008 | ], 1009 | "source": [ 1010 | "model.children['sunny'].children['high'].children" 1011 | ] 1012 | }, 1013 | { 1014 | "cell_type": "code", 1015 | "execution_count": 84, 1016 | "id": "4a7937bd", 1017 | "metadata": {}, 1018 | "outputs": [ 1019 | { 1020 | "data": { 1021 | "text/plain": [ 1022 | "'yes'" 1023 | ] 1024 | }, 1025 | "execution_count": 84, 1026 | "metadata": {}, 1027 | "output_type": "execute_result" 1028 | } 1029 | ], 1030 | "source": [ 1031 | "model.children['overcast'].target" 1032 | ] 1033 | }, 1034 | { 1035 | "cell_type": "code", 1036 | "execution_count": 85, 1037 | "id": "f89676f6", 1038 | "metadata": {}, 1039 | "outputs": [ 1040 | { 1041 | "data": { 1042 | "text/plain": [ 1043 | "{}" 1044 | ] 1045 | }, 1046 | "execution_count": 85, 1047 | "metadata": {}, 1048 | "output_type": "execute_result" 1049 | } 1050 | ], 1051 | "source": [ 1052 | "model.children['overcast'].children" 1053 | ] 1054 | }, 1055 | { 1056 | "cell_type": "markdown", 1057 | "id": "39f6c4b7", 1058 | "metadata": {}, 1059 | "source": [ 1060 | "# Prediction Time" 1061 | ] 1062 | }, 1063 | { 1064 | "cell_type": "markdown", 1065 | "id": "6d61eae0", 1066 | "metadata": {}, 1067 | "source": [ 1068 | "" 1069 | ] 1070 | }, 1071 | { 1072 | "cell_type": "code", 1073 | "execution_count": null, 1074 | "id": "2a3ffda9", 1075 | "metadata": {}, 1076 | "outputs": [], 1077 | "source": [] 1078 | }, 1079 | { 1080 | "cell_type": "code", 1081 | "execution_count": 94, 1082 | "id": "39933506", 1083 | "metadata": {}, 1084 | "outputs": [], 1085 | "source": [ 1086 | "x_test = pd.DataFrame([['sunny', 'hot', 'normal', False]], columns=list(df.columns.values[:-1]))" 1087 | ] 1088 | }, 1089 | { 1090 | "cell_type": "code", 1091 | "execution_count": 95, 1092 | "id": "afbc0099", 1093 | "metadata": {}, 1094 | "outputs": [ 1095 | { 1096 | "data": { 1097 | "text/html": [ 1098 | "
\n", 1099 | "\n", 1112 | "\n", 1113 | " \n", 1114 | " \n", 1115 | " \n", 1116 | " \n", 1117 | " \n", 1118 | " \n", 1119 | " \n", 1120 | " \n", 1121 | " \n", 1122 | " \n", 1123 | " \n", 1124 | " \n", 1125 | " \n", 1126 | " \n", 1127 | " \n", 1128 | " \n", 1129 | " \n", 1130 | " \n", 1131 | "
OutlookTemperatureHumidityWindy
0sunnyhotnormalFalse
\n", 1132 | "
" 1133 | ], 1134 | "text/plain": [ 1135 | " Outlook Temperature Humidity Windy\n", 1136 | "0 sunny hot normal False" 1137 | ] 1138 | }, 1139 | "execution_count": 95, 1140 | "metadata": {}, 1141 | "output_type": "execute_result" 1142 | } 1143 | ], 1144 | "source": [ 1145 | "x_test" 1146 | ] 1147 | }, 1148 | { 1149 | "cell_type": "code", 1150 | "execution_count": 96, 1151 | "id": "eb24cda9", 1152 | "metadata": { 1153 | "scrolled": true 1154 | }, 1155 | "outputs": [ 1156 | { 1157 | "data": { 1158 | "text/plain": [ 1159 | "'yes'" 1160 | ] 1161 | }, 1162 | "execution_count": 96, 1163 | "metadata": {}, 1164 | "output_type": "execute_result" 1165 | } 1166 | ], 1167 | "source": [ 1168 | "model.predict(x_test)" 1169 | ] 1170 | }, 1171 | { 1172 | "cell_type": "code", 1173 | "execution_count": null, 1174 | "id": "ea650ab0", 1175 | "metadata": {}, 1176 | "outputs": [], 1177 | "source": [] 1178 | } 1179 | ], 1180 | "metadata": { 1181 | "kernelspec": { 1182 | "display_name": "Python 3", 1183 | "language": "python", 1184 | "name": "python3" 1185 | }, 1186 | "language_info": { 1187 | "codemirror_mode": { 1188 | "name": "ipython", 1189 | "version": 3 1190 | }, 1191 | "file_extension": ".py", 1192 | "mimetype": "text/x-python", 1193 | "name": "python", 1194 | "nbconvert_exporter": "python", 1195 | "pygments_lexer": "ipython3", 1196 | "version": "3.8.8" 1197 | } 1198 | }, 1199 | "nbformat": 4, 1200 | "nbformat_minor": 5 1201 | } 1202 | -------------------------------------------------------------------------------- /09 Ensemble Learning/Ensemble - Bagging.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "89848a92", 6 | "metadata": {}, 7 | "source": [ 8 | "# Ensemble Models 🎳\n", 9 | "\n", 10 | "
\n", 11 | "\n", 12 | " - Group/collection of things.\n", 13 | " - Multiple models combined together to create a powerful model.\n", 14 | " - Individual Models are known as Base Models.\n", 15 | " - More different base models are, the better results we can achieve.\n", 16 | " \n", 17 | "
\n", 18 | "\n", 19 | "### Types of Ensemble Models\n", 20 | "1. Bagging\n", 21 | "1. Boosting" 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": null, 27 | "id": "f03463a7", 28 | "metadata": {}, 29 | "outputs": [], 30 | "source": [] 31 | }, 32 | { 33 | "cell_type": "markdown", 34 | "id": "ff0a12e4", 35 | "metadata": {}, 36 | "source": [ 37 | "# Bootstrap Aggegration [Bagging]\n", 38 | "\n", 39 | "1. Bootstrap Sampling. i.e sampling with replacement\n", 40 | "1. Aggregation" 41 | ] 42 | }, 43 | { 44 | "cell_type": "code", 45 | "execution_count": null, 46 | "id": "a545a4c9", 47 | "metadata": {}, 48 | "outputs": [], 49 | "source": [] 50 | }, 51 | { 52 | "cell_type": "code", 53 | "execution_count": null, 54 | "id": "46f9e498", 55 | "metadata": {}, 56 | "outputs": [], 57 | "source": [] 58 | }, 59 | { 60 | "cell_type": "markdown", 61 | "id": "df684730", 62 | "metadata": {}, 63 | "source": [ 64 | "# Why Bagging helps?\n", 65 | " - Bagging reduces the variance of a model, while keeping the bias as low" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": null, 71 | "id": "d338d146", 72 | "metadata": {}, 73 | "outputs": [], 74 | "source": [] 75 | }, 76 | { 77 | "cell_type": "code", 78 | "execution_count": null, 79 | "id": "62c734af", 80 | "metadata": {}, 81 | "outputs": [], 82 | "source": [] 83 | }, 84 | { 85 | "cell_type": "markdown", 86 | "id": "f410822d", 87 | "metadata": {}, 88 | "source": [ 89 | "# 🌳 Random Forest \n", 90 | "\n", 91 | "\n", 92 | "\n", 93 | " - Random : Boostrap Sampling\n", 94 | " - Forest : Group of trees\n", 95 | " - RF = Decision Tree + Row Sampling + Feature Sampling" 96 | ] 97 | }, 98 | { 99 | "cell_type": "code", 100 | "execution_count": null, 101 | "id": "14192837", 102 | "metadata": {}, 103 | "outputs": [], 104 | "source": [] 105 | }, 106 | { 107 | "cell_type": "code", 108 | "execution_count": null, 109 | "id": "a0f4ae8e", 110 | "metadata": {}, 111 | "outputs": [], 112 | "source": [] 113 | }, 114 | { 115 | "cell_type": "markdown", 116 | "id": "34e53e05", 117 | "metadata": {}, 118 | "source": [ 119 | "# Bias Variance Tradeoff\n", 120 | "" 121 | ] 122 | }, 123 | { 124 | "cell_type": "code", 125 | "execution_count": null, 126 | "id": "20d62397", 127 | "metadata": {}, 128 | "outputs": [], 129 | "source": [] 130 | }, 131 | { 132 | "cell_type": "code", 133 | "execution_count": null, 134 | "id": "2ad1de75", 135 | "metadata": {}, 136 | "outputs": [], 137 | "source": [] 138 | }, 139 | { 140 | "cell_type": "markdown", 141 | "id": "f8f816dd", 142 | "metadata": {}, 143 | "source": [ 144 | "# CODE - Sklearn" 145 | ] 146 | }, 147 | { 148 | "cell_type": "code", 149 | "execution_count": 100, 150 | "id": "0312eb51", 151 | "metadata": {}, 152 | "outputs": [], 153 | "source": [ 154 | "from sklearn.datasets import load_breast_cancer" 155 | ] 156 | }, 157 | { 158 | "cell_type": "code", 159 | "execution_count": 101, 160 | "id": "282e817c", 161 | "metadata": {}, 162 | "outputs": [], 163 | "source": [ 164 | "cancer = load_breast_cancer()" 165 | ] 166 | }, 167 | { 168 | "cell_type": "code", 169 | "execution_count": 104, 170 | "id": "71f9914d", 171 | "metadata": {}, 172 | "outputs": [], 173 | "source": [ 174 | "X = cancer.data" 175 | ] 176 | }, 177 | { 178 | "cell_type": "code", 179 | "execution_count": 105, 180 | "id": "1428ee5d", 181 | "metadata": {}, 182 | "outputs": [], 183 | "source": [ 184 | "y = cancer.target" 185 | ] 186 | }, 187 | { 188 | "cell_type": "code", 189 | "execution_count": 109, 190 | "id": "54cfcecd", 191 | "metadata": {}, 192 | "outputs": [ 193 | { 194 | "data": { 195 | "text/plain": [ 196 | "(569, 30)" 197 | ] 198 | }, 199 | "execution_count": 109, 200 | "metadata": {}, 201 | "output_type": "execute_result" 202 | } 203 | ], 204 | "source": [ 205 | "X.shape" 206 | ] 207 | }, 208 | { 209 | "cell_type": "code", 210 | "execution_count": 110, 211 | "id": "3af4a40d", 212 | "metadata": {}, 213 | "outputs": [ 214 | { 215 | "name": "stdout", 216 | "output_type": "stream", 217 | "text": [ 218 | ".. _breast_cancer_dataset:\n", 219 | "\n", 220 | "Breast cancer wisconsin (diagnostic) dataset\n", 221 | "--------------------------------------------\n", 222 | "\n", 223 | "**Data Set Characteristics:**\n", 224 | "\n", 225 | " :Number of Instances: 569\n", 226 | "\n", 227 | " :Number of Attributes: 30 numeric, predictive attributes and the class\n", 228 | "\n", 229 | " :Attribute Information:\n", 230 | " - radius (mean of distances from center to points on the perimeter)\n", 231 | " - texture (standard deviation of gray-scale values)\n", 232 | " - perimeter\n", 233 | " - area\n", 234 | " - smoothness (local variation in radius lengths)\n", 235 | " - compactness (perimeter^2 / area - 1.0)\n", 236 | " - concavity (severity of concave portions of the contour)\n", 237 | " - concave points (number of concave portions of the contour)\n", 238 | " - symmetry\n", 239 | " - fractal dimension (\"coastline approximation\" - 1)\n", 240 | "\n", 241 | " The mean, standard error, and \"worst\" or largest (mean of the three\n", 242 | " worst/largest values) of these features were computed for each image,\n", 243 | " resulting in 30 features. For instance, field 0 is Mean Radius, field\n", 244 | " 10 is Radius SE, field 20 is Worst Radius.\n", 245 | "\n", 246 | " - class:\n", 247 | " - WDBC-Malignant\n", 248 | " - WDBC-Benign\n", 249 | "\n", 250 | " :Summary Statistics:\n", 251 | "\n", 252 | " ===================================== ====== ======\n", 253 | " Min Max\n", 254 | " ===================================== ====== ======\n", 255 | " radius (mean): 6.981 28.11\n", 256 | " texture (mean): 9.71 39.28\n", 257 | " perimeter (mean): 43.79 188.5\n", 258 | " area (mean): 143.5 2501.0\n", 259 | " smoothness (mean): 0.053 0.163\n", 260 | " compactness (mean): 0.019 0.345\n", 261 | " concavity (mean): 0.0 0.427\n", 262 | " concave points (mean): 0.0 0.201\n", 263 | " symmetry (mean): 0.106 0.304\n", 264 | " fractal dimension (mean): 0.05 0.097\n", 265 | " radius (standard error): 0.112 2.873\n", 266 | " texture (standard error): 0.36 4.885\n", 267 | " perimeter (standard error): 0.757 21.98\n", 268 | " area (standard error): 6.802 542.2\n", 269 | " smoothness (standard error): 0.002 0.031\n", 270 | " compactness (standard error): 0.002 0.135\n", 271 | " concavity (standard error): 0.0 0.396\n", 272 | " concave points (standard error): 0.0 0.053\n", 273 | " symmetry (standard error): 0.008 0.079\n", 274 | " fractal dimension (standard error): 0.001 0.03\n", 275 | " radius (worst): 7.93 36.04\n", 276 | " texture (worst): 12.02 49.54\n", 277 | " perimeter (worst): 50.41 251.2\n", 278 | " area (worst): 185.2 4254.0\n", 279 | " smoothness (worst): 0.071 0.223\n", 280 | " compactness (worst): 0.027 1.058\n", 281 | " concavity (worst): 0.0 1.252\n", 282 | " concave points (worst): 0.0 0.291\n", 283 | " symmetry (worst): 0.156 0.664\n", 284 | " fractal dimension (worst): 0.055 0.208\n", 285 | " ===================================== ====== ======\n", 286 | "\n", 287 | " :Missing Attribute Values: None\n", 288 | "\n", 289 | " :Class Distribution: 212 - Malignant, 357 - Benign\n", 290 | "\n", 291 | " :Creator: Dr. William H. Wolberg, W. Nick Street, Olvi L. Mangasarian\n", 292 | "\n", 293 | " :Donor: Nick Street\n", 294 | "\n", 295 | " :Date: November, 1995\n", 296 | "\n", 297 | "This is a copy of UCI ML Breast Cancer Wisconsin (Diagnostic) datasets.\n", 298 | "https://goo.gl/U2Uwz2\n", 299 | "\n", 300 | "Features are computed from a digitized image of a fine needle\n", 301 | "aspirate (FNA) of a breast mass. They describe\n", 302 | "characteristics of the cell nuclei present in the image.\n", 303 | "\n", 304 | "Separating plane described above was obtained using\n", 305 | "Multisurface Method-Tree (MSM-T) [K. P. Bennett, \"Decision Tree\n", 306 | "Construction Via Linear Programming.\" Proceedings of the 4th\n", 307 | "Midwest Artificial Intelligence and Cognitive Science Society,\n", 308 | "pp. 97-101, 1992], a classification method which uses linear\n", 309 | "programming to construct a decision tree. Relevant features\n", 310 | "were selected using an exhaustive search in the space of 1-4\n", 311 | "features and 1-3 separating planes.\n", 312 | "\n", 313 | "The actual linear program used to obtain the separating plane\n", 314 | "in the 3-dimensional space is that described in:\n", 315 | "[K. P. Bennett and O. L. Mangasarian: \"Robust Linear\n", 316 | "Programming Discrimination of Two Linearly Inseparable Sets\",\n", 317 | "Optimization Methods and Software 1, 1992, 23-34].\n", 318 | "\n", 319 | "This database is also available through the UW CS ftp server:\n", 320 | "\n", 321 | "ftp ftp.cs.wisc.edu\n", 322 | "cd math-prog/cpo-dataset/machine-learn/WDBC/\n", 323 | "\n", 324 | ".. topic:: References\n", 325 | "\n", 326 | " - W.N. Street, W.H. Wolberg and O.L. Mangasarian. Nuclear feature extraction \n", 327 | " for breast tumor diagnosis. IS&T/SPIE 1993 International Symposium on \n", 328 | " Electronic Imaging: Science and Technology, volume 1905, pages 861-870,\n", 329 | " San Jose, CA, 1993.\n", 330 | " - O.L. Mangasarian, W.N. Street and W.H. Wolberg. Breast cancer diagnosis and \n", 331 | " prognosis via linear programming. Operations Research, 43(4), pages 570-577, \n", 332 | " July-August 1995.\n", 333 | " - W.H. Wolberg, W.N. Street, and O.L. Mangasarian. Machine learning techniques\n", 334 | " to diagnose breast cancer from fine-needle aspirates. Cancer Letters 77 (1994) \n", 335 | " 163-171.\n" 336 | ] 337 | } 338 | ], 339 | "source": [ 340 | "print(cancer.DESCR)" 341 | ] 342 | }, 343 | { 344 | "cell_type": "code", 345 | "execution_count": 111, 346 | "id": "ca75e19f", 347 | "metadata": {}, 348 | "outputs": [], 349 | "source": [ 350 | "from sklearn.model_selection import train_test_split" 351 | ] 352 | }, 353 | { 354 | "cell_type": "code", 355 | "execution_count": 113, 356 | "id": "f51903eb", 357 | "metadata": {}, 358 | "outputs": [], 359 | "source": [ 360 | "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42)" 361 | ] 362 | }, 363 | { 364 | "cell_type": "code", 365 | "execution_count": 114, 366 | "id": "d3256177", 367 | "metadata": {}, 368 | "outputs": [], 369 | "source": [ 370 | "from sklearn.ensemble import RandomForestClassifier" 371 | ] 372 | }, 373 | { 374 | "cell_type": "code", 375 | "execution_count": 147, 376 | "id": "cd47985a", 377 | "metadata": {}, 378 | "outputs": [], 379 | "source": [ 380 | "model = RandomForestClassifier(n_estimators=200)" 381 | ] 382 | }, 383 | { 384 | "cell_type": "code", 385 | "execution_count": 148, 386 | "id": "953a3633", 387 | "metadata": {}, 388 | "outputs": [ 389 | { 390 | "data": { 391 | "text/plain": [ 392 | "RandomForestClassifier(n_estimators=200)" 393 | ] 394 | }, 395 | "execution_count": 148, 396 | "metadata": {}, 397 | "output_type": "execute_result" 398 | } 399 | ], 400 | "source": [ 401 | "model.fit(X_train, y_train)" 402 | ] 403 | }, 404 | { 405 | "cell_type": "code", 406 | "execution_count": 149, 407 | "id": "762c9ea1", 408 | "metadata": {}, 409 | "outputs": [ 410 | { 411 | "data": { 412 | "text/plain": [ 413 | "1.0" 414 | ] 415 | }, 416 | "execution_count": 149, 417 | "metadata": {}, 418 | "output_type": "execute_result" 419 | } 420 | ], 421 | "source": [ 422 | "model.score(X_train, y_train)" 423 | ] 424 | }, 425 | { 426 | "cell_type": "code", 427 | "execution_count": 150, 428 | "id": "d0b5d3bb", 429 | "metadata": {}, 430 | "outputs": [ 431 | { 432 | "data": { 433 | "text/plain": [ 434 | "0.9627659574468085" 435 | ] 436 | }, 437 | "execution_count": 150, 438 | "metadata": {}, 439 | "output_type": "execute_result" 440 | } 441 | ], 442 | "source": [ 443 | "model.score(X_test, y_test)" 444 | ] 445 | }, 446 | { 447 | "cell_type": "code", 448 | "execution_count": null, 449 | "id": "eaddfc3a", 450 | "metadata": {}, 451 | "outputs": [], 452 | "source": [] 453 | }, 454 | { 455 | "cell_type": "code", 456 | "execution_count": null, 457 | "id": "8f956910", 458 | "metadata": {}, 459 | "outputs": [], 460 | "source": [] 461 | } 462 | ], 463 | "metadata": { 464 | "kernelspec": { 465 | "display_name": "Python 3", 466 | "language": "python", 467 | "name": "python3" 468 | }, 469 | "language_info": { 470 | "codemirror_mode": { 471 | "name": "ipython", 472 | "version": 3 473 | }, 474 | "file_extension": ".py", 475 | "mimetype": "text/x-python", 476 | "name": "python", 477 | "nbconvert_exporter": "python", 478 | "pygments_lexer": "ipython3", 479 | "version": "3.8.8" 480 | } 481 | }, 482 | "nbformat": 4, 483 | "nbformat_minor": 5 484 | } 485 | -------------------------------------------------------------------------------- /09 Ensemble Learning/Ensemble Learning - Boosting.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "806fca1b", 6 | "metadata": {}, 7 | "source": [ 8 | "# Ensemble : Boosting Introduction\n", 9 | "\n", 10 | "
\n", 11 | "\n", 12 | "**Idea** : Combine multiple weak learners to form a strong learner to increase the model performance.\n", 13 | "\n", 14 | "\n", 15 | " \n", 16 | "\n", 17 | "**Bagging** : Models _(high var, low bias)_ + randomization + aggregation\n", 18 | "\n", 19 | "**Boosting** : Models _(low var, high bias)_ + additively combine\n", 20 | "\n", 21 | "
\n", 22 | "\n", 23 | "**Note : Bagging is Parallel. Boosting is Sequential.**\n", 24 | "\n", 25 | "
\n", 26 | "\n", 27 | "Most Popular Boosting algorithms are: \n", 28 | "- Gradient Boosting\n", 29 | "- Adaptive Boosting" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": null, 35 | "id": "5237e826", 36 | "metadata": {}, 37 | "outputs": [], 38 | "source": [] 39 | }, 40 | { 41 | "cell_type": "markdown", 42 | "id": "47aa8d07", 43 | "metadata": {}, 44 | "source": [ 45 | "# Boosting Intuition\n", 46 | "\n", 47 | "**Idea :** Boosting reduces high bias, while keeping the variance same." 48 | ] 49 | }, 50 | { 51 | "cell_type": "markdown", 52 | "id": "cf06836d", 53 | "metadata": {}, 54 | "source": [ 55 | "| Hours Studied | Bunked Lectures | Assignment Submitted | Marks |\n", 56 | "|:---------------:|:-----------------:|:----------------------:|:-------:|\n", 57 | "| 7 | 2 | 9 | 93 |\n", 58 | "| 2 | 5 | 4 | 65 |\n", 59 | "| 5 | 3 | 7 | 77 |\n", 60 | "| 6 | 1 | 8 | 85 |" 61 | ] 62 | }, 63 | { 64 | "cell_type": "code", 65 | "execution_count": null, 66 | "id": "66b846cb", 67 | "metadata": {}, 68 | "outputs": [], 69 | "source": [] 70 | }, 71 | { 72 | "cell_type": "code", 73 | "execution_count": null, 74 | "id": "43548fae", 75 | "metadata": {}, 76 | "outputs": [], 77 | "source": [] 78 | }, 79 | { 80 | "cell_type": "markdown", 81 | "id": "951702d3", 82 | "metadata": {}, 83 | "source": [ 84 | "# Boosting Example Walkthrough" 85 | ] 86 | }, 87 | { 88 | "cell_type": "markdown", 89 | "id": "b98f0b4d", 90 | "metadata": {}, 91 | "source": [ 92 | "| Hours Studied | Bunked Lectures | Assignment Submitted | Marks |\n", 93 | "|:---------------:|:-----------------:|:----------------------:|:-------:|\n", 94 | "| 7 | 2 | 9 | 93 |\n", 95 | "| 2 | 5 | 4 | 65 |\n", 96 | "| 5 | 3 | 7 | 77 |\n", 97 | "| 6 | 1 | 8 | 85 |" 98 | ] 99 | }, 100 | { 101 | "cell_type": "code", 102 | "execution_count": null, 103 | "id": "17bd14be", 104 | "metadata": {}, 105 | "outputs": [], 106 | "source": [] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": null, 111 | "id": "2e7064e8", 112 | "metadata": {}, 113 | "outputs": [], 114 | "source": [] 115 | }, 116 | { 117 | "cell_type": "markdown", 118 | "id": "bfa550da", 119 | "metadata": {}, 120 | "source": [ 121 | "# Concept of Pseudo-residuals" 122 | ] 123 | }, 124 | { 125 | "cell_type": "markdown", 126 | "id": "4a875446", 127 | "metadata": {}, 128 | "source": [ 129 | "" 130 | ] 131 | }, 132 | { 133 | "cell_type": "code", 134 | "execution_count": null, 135 | "id": "23cce5ca", 136 | "metadata": {}, 137 | "outputs": [], 138 | "source": [] 139 | }, 140 | { 141 | "cell_type": "code", 142 | "execution_count": null, 143 | "id": "a9a0e998", 144 | "metadata": {}, 145 | "outputs": [], 146 | "source": [] 147 | }, 148 | { 149 | "cell_type": "code", 150 | "execution_count": null, 151 | "id": "f6ab1435", 152 | "metadata": {}, 153 | "outputs": [], 154 | "source": [] 155 | }, 156 | { 157 | "cell_type": "markdown", 158 | "id": "55a0df68", 159 | "metadata": {}, 160 | "source": [ 161 | "# Gradient Boosting Algorithm" 162 | ] 163 | }, 164 | { 165 | "cell_type": "code", 166 | "execution_count": null, 167 | "id": "e48e0ef9", 168 | "metadata": {}, 169 | "outputs": [], 170 | "source": [] 171 | }, 172 | { 173 | "cell_type": "markdown", 174 | "id": "e23439ec", 175 | "metadata": {}, 176 | "source": [ 177 | "# Bias Variance Tradeoff\n", 178 | "- regularization" 179 | ] 180 | }, 181 | { 182 | "cell_type": "markdown", 183 | "id": "9b69eb01", 184 | "metadata": {}, 185 | "source": [ 186 | "" 187 | ] 188 | }, 189 | { 190 | "cell_type": "code", 191 | "execution_count": null, 192 | "id": "e194f86f", 193 | "metadata": {}, 194 | "outputs": [], 195 | "source": [] 196 | }, 197 | { 198 | "cell_type": "code", 199 | "execution_count": null, 200 | "id": "064d72b4", 201 | "metadata": {}, 202 | "outputs": [], 203 | "source": [] 204 | }, 205 | { 206 | "cell_type": "markdown", 207 | "id": "f3a45ec2", 208 | "metadata": {}, 209 | "source": [ 210 | "# Gradient Boosting Code" 211 | ] 212 | }, 213 | { 214 | "cell_type": "code", 215 | "execution_count": 121, 216 | "id": "338bc7e8", 217 | "metadata": {}, 218 | "outputs": [], 219 | "source": [ 220 | "from sklearn.datasets import make_regression" 221 | ] 222 | }, 223 | { 224 | "cell_type": "code", 225 | "execution_count": 124, 226 | "id": "3f7dfa31", 227 | "metadata": {}, 228 | "outputs": [], 229 | "source": [ 230 | "X, y = make_regression(n_samples=1000, n_features=10, n_informative=6, noise=2.0)" 231 | ] 232 | }, 233 | { 234 | "cell_type": "code", 235 | "execution_count": 125, 236 | "id": "cf825f6b", 237 | "metadata": {}, 238 | "outputs": [ 239 | { 240 | "data": { 241 | "text/plain": [ 242 | "(1000, 10)" 243 | ] 244 | }, 245 | "execution_count": 125, 246 | "metadata": {}, 247 | "output_type": "execute_result" 248 | } 249 | ], 250 | "source": [ 251 | "X.shape" 252 | ] 253 | }, 254 | { 255 | "cell_type": "code", 256 | "execution_count": 126, 257 | "id": "b332eb48", 258 | "metadata": {}, 259 | "outputs": [ 260 | { 261 | "data": { 262 | "text/plain": [ 263 | "(1000,)" 264 | ] 265 | }, 266 | "execution_count": 126, 267 | "metadata": {}, 268 | "output_type": "execute_result" 269 | } 270 | ], 271 | "source": [ 272 | "y.shape" 273 | ] 274 | }, 275 | { 276 | "cell_type": "code", 277 | "execution_count": 127, 278 | "id": "41b3bca2", 279 | "metadata": {}, 280 | "outputs": [], 281 | "source": [ 282 | "from sklearn.model_selection import train_test_split" 283 | ] 284 | }, 285 | { 286 | "cell_type": "code", 287 | "execution_count": 128, 288 | "id": "ccd80e1e", 289 | "metadata": {}, 290 | "outputs": [], 291 | "source": [ 292 | "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)" 293 | ] 294 | }, 295 | { 296 | "cell_type": "code", 297 | "execution_count": 129, 298 | "id": "44c37c8d", 299 | "metadata": {}, 300 | "outputs": [], 301 | "source": [ 302 | "from sklearn.ensemble import GradientBoostingRegressor" 303 | ] 304 | }, 305 | { 306 | "cell_type": "code", 307 | "execution_count": 136, 308 | "id": "dfa0854e", 309 | "metadata": {}, 310 | "outputs": [], 311 | "source": [ 312 | "M = [10, 50, 100, 200, 500, 1000]" 313 | ] 314 | }, 315 | { 316 | "cell_type": "code", 317 | "execution_count": 137, 318 | "id": "5692726d", 319 | "metadata": {}, 320 | "outputs": [], 321 | "source": [ 322 | "train_scores = []\n", 323 | "test_scores = []" 324 | ] 325 | }, 326 | { 327 | "cell_type": "code", 328 | "execution_count": 138, 329 | "id": "6977fb0d", 330 | "metadata": {}, 331 | "outputs": [], 332 | "source": [ 333 | "for m in M:\n", 334 | " model = GradientBoostingRegressor(n_estimators=m)\n", 335 | " model.fit(X_train, y_train)\n", 336 | " tr_sc = model.score(X_train, y_train)\n", 337 | " te_sc = model.score(X_test, y_test)\n", 338 | " \n", 339 | " train_scores.append(tr_sc)\n", 340 | " test_scores.append(te_sc)" 341 | ] 342 | }, 343 | { 344 | "cell_type": "code", 345 | "execution_count": 139, 346 | "id": "dbe6724f", 347 | "metadata": {}, 348 | "outputs": [ 349 | { 350 | "data": { 351 | "text/plain": [ 352 | "[0.5693298400680644,\n", 353 | " 0.9517023668196679,\n", 354 | " 0.9896131212623428,\n", 355 | " 0.9957854115756537,\n", 356 | " 0.9991338471481596,\n", 357 | " 0.999898854280583]" 358 | ] 359 | }, 360 | "execution_count": 139, 361 | "metadata": {}, 362 | "output_type": "execute_result" 363 | } 364 | ], 365 | "source": [ 366 | "train_scores" 367 | ] 368 | }, 369 | { 370 | "cell_type": "code", 371 | "execution_count": 140, 372 | "id": "c50a77c6", 373 | "metadata": {}, 374 | "outputs": [ 375 | { 376 | "data": { 377 | "text/plain": [ 378 | "[0.5165900903969471,\n", 379 | " 0.8747191986794813,\n", 380 | " 0.9369690789752081,\n", 381 | " 0.953364577019059,\n", 382 | " 0.9584623589008775,\n", 383 | " 0.960608551723134]" 384 | ] 385 | }, 386 | "execution_count": 140, 387 | "metadata": {}, 388 | "output_type": "execute_result" 389 | } 390 | ], 391 | "source": [ 392 | "test_scores" 393 | ] 394 | }, 395 | { 396 | "cell_type": "code", 397 | "execution_count": null, 398 | "id": "7547f6f8", 399 | "metadata": {}, 400 | "outputs": [], 401 | "source": [] 402 | }, 403 | { 404 | "cell_type": "code", 405 | "execution_count": null, 406 | "id": "6e5d8b22", 407 | "metadata": {}, 408 | "outputs": [], 409 | "source": [] 410 | }, 411 | { 412 | "cell_type": "code", 413 | "execution_count": null, 414 | "id": "921753f9", 415 | "metadata": {}, 416 | "outputs": [], 417 | "source": [] 418 | }, 419 | { 420 | "cell_type": "markdown", 421 | "id": "60c16771", 422 | "metadata": {}, 423 | "source": [ 424 | "# XGBoost" 425 | ] 426 | }, 427 | { 428 | "cell_type": "code", 429 | "execution_count": null, 430 | "id": "20754f16", 431 | "metadata": {}, 432 | "outputs": [], 433 | "source": [] 434 | }, 435 | { 436 | "cell_type": "code", 437 | "execution_count": null, 438 | "id": "a0696e8b", 439 | "metadata": {}, 440 | "outputs": [], 441 | "source": [] 442 | }, 443 | { 444 | "cell_type": "code", 445 | "execution_count": null, 446 | "id": "9205e929", 447 | "metadata": {}, 448 | "outputs": [], 449 | "source": [] 450 | }, 451 | { 452 | "cell_type": "code", 453 | "execution_count": null, 454 | "id": "26293441", 455 | "metadata": {}, 456 | "outputs": [], 457 | "source": [] 458 | }, 459 | { 460 | "cell_type": "code", 461 | "execution_count": null, 462 | "id": "0014f3b1", 463 | "metadata": {}, 464 | "outputs": [], 465 | "source": [] 466 | }, 467 | { 468 | "cell_type": "markdown", 469 | "id": "728a52b1", 470 | "metadata": {}, 471 | "source": [ 472 | "# Adaptive Boosting" 473 | ] 474 | }, 475 | { 476 | "cell_type": "markdown", 477 | "id": "01e037c2", 478 | "metadata": {}, 479 | "source": [ 480 | "upenn" 481 | ] 482 | }, 483 | { 484 | "cell_type": "code", 485 | "execution_count": null, 486 | "id": "ac6f12eb", 487 | "metadata": {}, 488 | "outputs": [], 489 | "source": [] 490 | }, 491 | { 492 | "cell_type": "code", 493 | "execution_count": null, 494 | "id": "9d950a73", 495 | "metadata": {}, 496 | "outputs": [], 497 | "source": [] 498 | }, 499 | { 500 | "cell_type": "markdown", 501 | "id": "84a319fb", 502 | "metadata": {}, 503 | "source": [ 504 | "# AdaBoost Code" 505 | ] 506 | }, 507 | { 508 | "cell_type": "code", 509 | "execution_count": null, 510 | "id": "b0accbca", 511 | "metadata": {}, 512 | "outputs": [], 513 | "source": [] 514 | } 515 | ], 516 | "metadata": { 517 | "kernelspec": { 518 | "display_name": "Python 3", 519 | "language": "python", 520 | "name": "python3" 521 | }, 522 | "language_info": { 523 | "codemirror_mode": { 524 | "name": "ipython", 525 | "version": 3 526 | }, 527 | "file_extension": ".py", 528 | "mimetype": "text/x-python", 529 | "name": "python", 530 | "nbconvert_exporter": "python", 531 | "pygments_lexer": "ipython3", 532 | "version": "3.8.8" 533 | } 534 | }, 535 | "nbformat": 4, 536 | "nbformat_minor": 5 537 | } 538 | --------------------------------------------------------------------------------