├── .gitignore ├── LICENSE ├── README.md ├── chapter2 ├── Housing.ipynb └── datasets │ └── housing │ ├── housing.csv │ └── housing.tgz ├── chapter3 └── mnist.ipynb ├── chapter4 ├── lin_reg.ipynb ├── logistic_reg.ipynb ├── poly_reg.ipynb └── regularized_models.ipynb └── data_fetcher └── data_fetcher.py /.gitignore: -------------------------------------------------------------------------------- 1 | *.bak 2 | *.ckpt 3 | *.old 4 | *.pyc 5 | .DS_Store 6 | .ipynb_checkpoints 7 | checkpoint 8 | logs/* 9 | tf_logs/* 10 | images/**/*.png 11 | images/**/*.dot 12 | my_* 13 | datasets/flowers 14 | datasets/lifesat/lifesat.csv 15 | datasets/spam 16 | datasets/words 17 | 18 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Apache License 2 | Version 2.0, January 2004 3 | http://www.apache.org/licenses/ 4 | 5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 6 | 7 | 1. Definitions. 8 | 9 | "License" shall mean the terms and conditions for use, reproduction, 10 | and distribution as defined by Sections 1 through 9 of this document. 11 | 12 | "Licensor" shall mean the copyright owner or entity authorized by 13 | the copyright owner that is granting the License. 14 | 15 | "Legal Entity" shall mean the union of the acting entity and all 16 | other entities that control, are controlled by, or are under common 17 | control with that entity. For the purposes of this definition, 18 | "control" means (i) the power, direct or indirect, to cause the 19 | direction or management of such entity, whether by contract or 20 | otherwise, or (ii) ownership of fifty percent (50%) or more of the 21 | outstanding shares, or (iii) beneficial ownership of such entity. 22 | 23 | "You" (or "Your") shall mean an individual or Legal Entity 24 | exercising permissions granted by this License. 25 | 26 | "Source" form shall mean the preferred form for making modifications, 27 | including but not limited to software source code, documentation 28 | source, and configuration files. 29 | 30 | "Object" form shall mean any form resulting from mechanical 31 | transformation or translation of a Source form, including but 32 | not limited to compiled object code, generated documentation, 33 | and conversions to other media types. 34 | 35 | "Work" shall mean the work of authorship, whether in Source or 36 | Object form, made available under the License, as indicated by a 37 | copyright notice that is included in or attached to the work 38 | (an example is provided in the Appendix below). 39 | 40 | "Derivative Works" shall mean any work, whether in Source or Object 41 | form, that is based on (or derived from) the Work and for which the 42 | editorial revisions, annotations, elaborations, or other modifications 43 | represent, as a whole, an original work of authorship. For the purposes 44 | of this License, Derivative Works shall not include works that remain 45 | separable from, or merely link (or bind by name) to the interfaces of, 46 | the Work and Derivative Works thereof. 47 | 48 | "Contribution" shall mean any work of authorship, including 49 | the original version of the Work and any modifications or additions 50 | to that Work or Derivative Works thereof, that is intentionally 51 | submitted to Licensor for inclusion in the Work by the copyright owner 52 | or by an individual or Legal Entity authorized to submit on behalf of 53 | the copyright owner. For the purposes of this definition, "submitted" 54 | means any form of electronic, verbal, or written communication sent 55 | to the Licensor or its representatives, including but not limited to 56 | communication on electronic mailing lists, source code control systems, 57 | and issue tracking systems that are managed by, or on behalf of, the 58 | Licensor for the purpose of discussing and improving the Work, but 59 | excluding communication that is conspicuously marked or otherwise 60 | designated in writing by the copyright owner as "Not a Contribution." 61 | 62 | "Contributor" shall mean Licensor and any individual or Legal Entity 63 | on behalf of whom a Contribution has been received by Licensor and 64 | subsequently incorporated within the Work. 65 | 66 | 2. Grant of Copyright License. Subject to the terms and conditions of 67 | this License, each Contributor hereby grants to You a perpetual, 68 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 69 | copyright license to reproduce, prepare Derivative Works of, 70 | publicly display, publicly perform, sublicense, and distribute the 71 | Work and such Derivative Works in Source or Object form. 72 | 73 | 3. Grant of Patent License. Subject to the terms and conditions of 74 | this License, each Contributor hereby grants to You a perpetual, 75 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 76 | (except as stated in this section) patent license to make, have made, 77 | use, offer to sell, sell, import, and otherwise transfer the Work, 78 | where such license applies only to those patent claims licensable 79 | by such Contributor that are necessarily infringed by their 80 | Contribution(s) alone or by combination of their Contribution(s) 81 | with the Work to which such Contribution(s) was submitted. If You 82 | institute patent litigation against any entity (including a 83 | cross-claim or counterclaim in a lawsuit) alleging that the Work 84 | or a Contribution incorporated within the Work constitutes direct 85 | or contributory patent infringement, then any patent licenses 86 | granted to You under this License for that Work shall terminate 87 | as of the date such litigation is filed. 88 | 89 | 4. Redistribution. You may reproduce and distribute copies of the 90 | Work or Derivative Works thereof in any medium, with or without 91 | modifications, and in Source or Object form, provided that You 92 | meet the following conditions: 93 | 94 | (a) You must give any other recipients of the Work or 95 | Derivative Works a copy of this License; and 96 | 97 | (b) You must cause any modified files to carry prominent notices 98 | stating that You changed the files; and 99 | 100 | (c) You must retain, in the Source form of any Derivative Works 101 | that You distribute, all copyright, patent, trademark, and 102 | attribution notices from the Source form of the Work, 103 | excluding those notices that do not pertain to any part of 104 | the Derivative Works; and 105 | 106 | (d) If the Work includes a "NOTICE" text file as part of its 107 | distribution, then any Derivative Works that You distribute must 108 | include a readable copy of the attribution notices contained 109 | within such NOTICE file, excluding those notices that do not 110 | pertain to any part of the Derivative Works, in at least one 111 | of the following places: within a NOTICE text file distributed 112 | as part of the Derivative Works; within the Source form or 113 | documentation, if provided along with the Derivative Works; or, 114 | within a display generated by the Derivative Works, if and 115 | wherever such third-party notices normally appear. The contents 116 | of the NOTICE file are for informational purposes only and 117 | do not modify the License. You may add Your own attribution 118 | notices within Derivative Works that You distribute, alongside 119 | or as an addendum to the NOTICE text from the Work, provided 120 | that such additional attribution notices cannot be construed 121 | as modifying the License. 122 | 123 | You may add Your own copyright statement to Your modifications and 124 | may provide additional or different license terms and conditions 125 | for use, reproduction, or distribution of Your modifications, or 126 | for any such Derivative Works as a whole, provided Your use, 127 | reproduction, and distribution of the Work otherwise complies with 128 | the conditions stated in this License. 129 | 130 | 5. Submission of Contributions. Unless You explicitly state otherwise, 131 | any Contribution intentionally submitted for inclusion in the Work 132 | by You to the Licensor shall be under the terms and conditions of 133 | this License, without any additional terms or conditions. 134 | Notwithstanding the above, nothing herein shall supersede or modify 135 | the terms of any separate license agreement you may have executed 136 | with Licensor regarding such Contributions. 137 | 138 | 6. Trademarks. This License does not grant permission to use the trade 139 | names, trademarks, service marks, or product names of the Licensor, 140 | except as required for reasonable and customary use in describing the 141 | origin of the Work and reproducing the content of the NOTICE file. 142 | 143 | 7. Disclaimer of Warranty. Unless required by applicable law or 144 | agreed to in writing, Licensor provides the Work (and each 145 | Contributor provides its Contributions) on an "AS IS" BASIS, 146 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 147 | implied, including, without limitation, any warranties or conditions 148 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A 149 | PARTICULAR PURPOSE. You are solely responsible for determining the 150 | appropriateness of using or redistributing the Work and assume any 151 | risks associated with Your exercise of permissions under this License. 152 | 153 | 8. Limitation of Liability. In no event and under no legal theory, 154 | whether in tort (including negligence), contract, or otherwise, 155 | unless required by applicable law (such as deliberate and grossly 156 | negligent acts) or agreed to in writing, shall any Contributor be 157 | liable to You for damages, including any direct, indirect, special, 158 | incidental, or consequential damages of any character arising as a 159 | result of this License or out of the use or inability to use the 160 | Work (including but not limited to damages for loss of goodwill, 161 | work stoppage, computer failure or malfunction, or any and all 162 | other commercial damages or losses), even if such Contributor 163 | has been advised of the possibility of such damages. 164 | 165 | 9. Accepting Warranty or Additional Liability. While redistributing 166 | the Work or Derivative Works thereof, You may choose to offer, 167 | and charge a fee for, acceptance of support, warranty, indemnity, 168 | or other liability obligations and/or rights consistent with this 169 | License. However, in accepting such obligations, You may act only 170 | on Your own behalf and on Your sole responsibility, not on behalf 171 | of any other Contributor, and only if You agree to indemnify, 172 | defend, and hold each Contributor harmless for any liability 173 | incurred by, or claims asserted against, such Contributor by reason 174 | of your accepting any such warranty or additional liability. 175 | 176 | END OF TERMS AND CONDITIONS 177 | 178 | APPENDIX: How to apply the Apache License to your work. 179 | 180 | To apply the Apache License to your work, attach the following 181 | boilerplate notice, with the fields enclosed by brackets "[]" 182 | replaced with your own identifying information. (Don't include 183 | the brackets!) The text should be enclosed in the appropriate 184 | comment syntax for the file format. We also recommend that a 185 | file or class name and description of purpose be included on the 186 | same "printed page" as the copyright notice for easier 187 | identification within third-party archives. 188 | 189 | Copyright [yyyy] [name of copyright owner] 190 | 191 | Licensed under the Apache License, Version 2.0 (the "License"); 192 | you may not use this file except in compliance with the License. 193 | You may obtain a copy of the License at 194 | 195 | http://www.apache.org/licenses/LICENSE-2.0 196 | 197 | Unless required by applicable law or agreed to in writing, software 198 | distributed under the License is distributed on an "AS IS" BASIS, 199 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 200 | See the License for the specific language governing permissions and 201 | limitations under the License. 202 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # handsOnMLBookCode 2 | Contains code for the book "Hands-On Machine Learning with Scikit-Learn & Tensorflow" 3 | -------------------------------------------------------------------------------- /chapter2/datasets/housing/housing.tgz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ashishps1/handsOnMLBookCode/4b3d00e5a0556ae914585aefb0571d11f35b26d4/chapter2/datasets/housing/housing.tgz -------------------------------------------------------------------------------- /chapter3/mnist.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import numpy as np\n", 10 | "from sklearn.datasets import fetch_openml\n", 11 | "mnist = fetch_openml('mnist_784', version=1, cache=True)" 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 2, 17 | "metadata": {}, 18 | "outputs": [ 19 | { 20 | "data": { 21 | "text/plain": [ 22 | "array([5, 0, 4, ..., 4, 5, 6], dtype=int8)" 23 | ] 24 | }, 25 | "execution_count": 2, 26 | "metadata": {}, 27 | "output_type": "execute_result" 28 | } 29 | ], 30 | "source": [ 31 | "mnist.target = mnist.target.astype(np.int8)\n", 32 | "mnist.target" 33 | ] 34 | }, 35 | { 36 | "cell_type": "code", 37 | "execution_count": 3, 38 | "metadata": {}, 39 | "outputs": [], 40 | "source": [ 41 | "X, y = mnist['data'], mnist['target']" 42 | ] 43 | }, 44 | { 45 | "cell_type": "code", 46 | "execution_count": 4, 47 | "metadata": {}, 48 | "outputs": [ 49 | { 50 | "data": { 51 | "text/plain": [ 52 | "(70000, 784)" 53 | ] 54 | }, 55 | "execution_count": 4, 56 | "metadata": {}, 57 | "output_type": "execute_result" 58 | } 59 | ], 60 | "source": [ 61 | "X.shape" 62 | ] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "execution_count": 5, 67 | "metadata": {}, 68 | "outputs": [ 69 | { 70 | "data": { 71 | "text/plain": [ 72 | "(70000,)" 73 | ] 74 | }, 75 | "execution_count": 5, 76 | "metadata": {}, 77 | "output_type": "execute_result" 78 | } 79 | ], 80 | "source": [ 81 | "y.shape" 82 | ] 83 | }, 84 | { 85 | "cell_type": "code", 86 | "execution_count": 6, 87 | "metadata": {}, 88 | "outputs": [], 89 | "source": [ 90 | "%matplotlib inline\n", 91 | "import matplotlib as mpl\n", 92 | "import matplotlib.pyplot as plt" 93 | ] 94 | }, 95 | { 96 | "cell_type": "code", 97 | "execution_count": 7, 98 | "metadata": {}, 99 | "outputs": [ 100 | { 101 | "data": { 102 | "image/png": "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\n", 103 | "text/plain": [ 104 | "
" 105 | ] 106 | }, 107 | "metadata": { 108 | "needs_background": "light" 109 | }, 110 | "output_type": "display_data" 111 | } 112 | ], 113 | "source": [ 114 | "some_digit = X[36000]\n", 115 | "some_digit_image = some_digit.reshape(28, 28)\n", 116 | "plt.imshow(some_digit_image, cmap = mpl.cm.binary,\n", 117 | " interpolation=\"nearest\")\n", 118 | "plt.axis(\"off\")\n", 119 | "plt.show()" 120 | ] 121 | }, 122 | { 123 | "cell_type": "code", 124 | "execution_count": 8, 125 | "metadata": {}, 126 | "outputs": [ 127 | { 128 | "data": { 129 | "text/plain": [ 130 | "9" 131 | ] 132 | }, 133 | "execution_count": 8, 134 | "metadata": {}, 135 | "output_type": "execute_result" 136 | } 137 | ], 138 | "source": [ 139 | "y[36000]" 140 | ] 141 | }, 142 | { 143 | "cell_type": "code", 144 | "execution_count": 9, 145 | "metadata": {}, 146 | "outputs": [], 147 | "source": [ 148 | "X_train, X_test, y_train, y_test = X[:60000], X[60000:], y[:60000], y[60000:]" 149 | ] 150 | }, 151 | { 152 | "cell_type": "code", 153 | "execution_count": 10, 154 | "metadata": {}, 155 | "outputs": [], 156 | "source": [ 157 | "import numpy as np\n", 158 | "\n", 159 | "shuffle_index = np.random.permutation(60000)\n", 160 | "X_train, y_train = X_train[shuffle_index], y_train[shuffle_index]" 161 | ] 162 | }, 163 | { 164 | "cell_type": "code", 165 | "execution_count": 11, 166 | "metadata": {}, 167 | "outputs": [], 168 | "source": [ 169 | "y_train_5 = (y_train == 5)\n", 170 | "y_test_5 = (y_test == 5)" 171 | ] 172 | }, 173 | { 174 | "cell_type": "code", 175 | "execution_count": 12, 176 | "metadata": {}, 177 | "outputs": [ 178 | { 179 | "data": { 180 | "text/plain": [ 181 | "SGDClassifier(alpha=0.0001, average=False, class_weight=None,\n", 182 | " early_stopping=False, epsilon=0.1, eta0=0.0, fit_intercept=True,\n", 183 | " l1_ratio=0.15, learning_rate='optimal', loss='hinge', max_iter=5,\n", 184 | " n_iter=None, n_iter_no_change=5, n_jobs=None, penalty='l2',\n", 185 | " power_t=0.5, random_state=42, shuffle=True, tol=-inf,\n", 186 | " validation_fraction=0.1, verbose=0, warm_start=False)" 187 | ] 188 | }, 189 | "execution_count": 12, 190 | "metadata": {}, 191 | "output_type": "execute_result" 192 | } 193 | ], 194 | "source": [ 195 | "from sklearn.linear_model import SGDClassifier\n", 196 | "\n", 197 | "sgd_clf = SGDClassifier(max_iter=5, tol=-np.infty, random_state=42)\n", 198 | "sgd_clf.fit(X_train, y_train_5)" 199 | ] 200 | }, 201 | { 202 | "cell_type": "code", 203 | "execution_count": 13, 204 | "metadata": {}, 205 | "outputs": [ 206 | { 207 | "data": { 208 | "text/plain": [ 209 | "array([False])" 210 | ] 211 | }, 212 | "execution_count": 13, 213 | "metadata": {}, 214 | "output_type": "execute_result" 215 | } 216 | ], 217 | "source": [ 218 | "sgd_clf.predict([some_digit])" 219 | ] 220 | }, 221 | { 222 | "cell_type": "code", 223 | "execution_count": 14, 224 | "metadata": {}, 225 | "outputs": [ 226 | { 227 | "data": { 228 | "text/plain": [ 229 | "array([0.96475, 0.95985, 0.93095])" 230 | ] 231 | }, 232 | "execution_count": 14, 233 | "metadata": {}, 234 | "output_type": "execute_result" 235 | } 236 | ], 237 | "source": [ 238 | "from sklearn.model_selection import cross_val_score\n", 239 | "cross_val_score(sgd_clf, X_train, y_train_5, cv=3, scoring=\"accuracy\")" 240 | ] 241 | }, 242 | { 243 | "cell_type": "code", 244 | "execution_count": 15, 245 | "metadata": {}, 246 | "outputs": [ 247 | { 248 | "name": "stdout", 249 | "output_type": "stream", 250 | "text": [ 251 | "0.96475\n", 252 | "0.95985\n", 253 | "0.93095\n" 254 | ] 255 | } 256 | ], 257 | "source": [ 258 | "from sklearn.model_selection import StratifiedKFold\n", 259 | "from sklearn.base import clone\n", 260 | "\n", 261 | "skfolds = StratifiedKFold(n_splits=3, random_state=42)\n", 262 | "\n", 263 | "for train_index, test_index in skfolds.split(X_train, y_train_5):\n", 264 | " clone_clf = clone(sgd_clf)\n", 265 | " X_train_folds = X_train[train_index]\n", 266 | " y_train_folds = (y_train_5[train_index])\n", 267 | " X_test_fold = X_train[test_index]\n", 268 | " y_test_fold = (y_train_5[test_index])\n", 269 | "\n", 270 | " clone_clf.fit(X_train_folds, y_train_folds)\n", 271 | " y_pred = clone_clf.predict(X_test_fold)\n", 272 | " n_correct = sum(y_pred == y_test_fold)\n", 273 | " print(n_correct / len(y_pred))" 274 | ] 275 | }, 276 | { 277 | "cell_type": "code", 278 | "execution_count": 16, 279 | "metadata": {}, 280 | "outputs": [], 281 | "source": [ 282 | "from sklearn.model_selection import cross_val_predict\n", 283 | "\n", 284 | "y_train_pred = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3)" 285 | ] 286 | }, 287 | { 288 | "cell_type": "code", 289 | "execution_count": 17, 290 | "metadata": {}, 291 | "outputs": [ 292 | { 293 | "data": { 294 | "text/plain": [ 295 | "array([False, False, False, ..., False, False, False])" 296 | ] 297 | }, 298 | "execution_count": 17, 299 | "metadata": {}, 300 | "output_type": "execute_result" 301 | } 302 | ], 303 | "source": [ 304 | "y_train_pred" 305 | ] 306 | }, 307 | { 308 | "cell_type": "code", 309 | "execution_count": 18, 310 | "metadata": {}, 311 | "outputs": [ 312 | { 313 | "data": { 314 | "text/plain": [ 315 | "array([[52576, 2003],\n", 316 | " [ 886, 4535]], dtype=int64)" 317 | ] 318 | }, 319 | "execution_count": 18, 320 | "metadata": {}, 321 | "output_type": "execute_result" 322 | } 323 | ], 324 | "source": [ 325 | "from sklearn.metrics import confusion_matrix\n", 326 | "\n", 327 | "confusion_matrix(y_train_5, y_train_pred)" 328 | ] 329 | }, 330 | { 331 | "cell_type": "code", 332 | "execution_count": 19, 333 | "metadata": {}, 334 | "outputs": [ 335 | { 336 | "data": { 337 | "text/plain": [ 338 | "0.6936371979198531" 339 | ] 340 | }, 341 | "execution_count": 19, 342 | "metadata": {}, 343 | "output_type": "execute_result" 344 | } 345 | ], 346 | "source": [ 347 | "from sklearn.metrics import precision_score, recall_score, f1_score\n", 348 | "\n", 349 | "precision_score(y_train_5, y_train_pred)" 350 | ] 351 | }, 352 | { 353 | "cell_type": "code", 354 | "execution_count": 20, 355 | "metadata": {}, 356 | "outputs": [ 357 | { 358 | "data": { 359 | "text/plain": [ 360 | "0.8365615200147575" 361 | ] 362 | }, 363 | "execution_count": 20, 364 | "metadata": {}, 365 | "output_type": "execute_result" 366 | } 367 | ], 368 | "source": [ 369 | "recall_score(y_train_5, y_train_pred)" 370 | ] 371 | }, 372 | { 373 | "cell_type": "code", 374 | "execution_count": 21, 375 | "metadata": {}, 376 | "outputs": [ 377 | { 378 | "data": { 379 | "text/plain": [ 380 | "0.75842461744293" 381 | ] 382 | }, 383 | "execution_count": 21, 384 | "metadata": {}, 385 | "output_type": "execute_result" 386 | } 387 | ], 388 | "source": [ 389 | "f1_score(y_train_5, y_train_pred)" 390 | ] 391 | }, 392 | { 393 | "cell_type": "code", 394 | "execution_count": 22, 395 | "metadata": {}, 396 | "outputs": [], 397 | "source": [ 398 | "y_scores = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3,\n", 399 | " method=\"decision_function\")" 400 | ] 401 | }, 402 | { 403 | "cell_type": "code", 404 | "execution_count": 23, 405 | "metadata": {}, 406 | "outputs": [], 407 | "source": [ 408 | "from sklearn.metrics import precision_recall_curve\n", 409 | "\n", 410 | "precisions, recalls, thresholds = precision_recall_curve(y_train_5, y_scores)" 411 | ] 412 | }, 413 | { 414 | "cell_type": "code", 415 | "execution_count": 24, 416 | "metadata": {}, 417 | "outputs": [ 418 | { 419 | "data": { 420 | "image/png": "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\n", 421 | "text/plain": [ 422 | "
" 423 | ] 424 | }, 425 | "metadata": { 426 | "needs_background": "light" 427 | }, 428 | "output_type": "display_data" 429 | } 430 | ], 431 | "source": [ 432 | "def plot_precision_recall_vs_threshold(precisions, recalls, thresholds):\n", 433 | " plt.plot(thresholds, precisions[:-1], \"b--\", label=\"Precision\", linewidth=2)\n", 434 | " plt.plot(thresholds, recalls[:-1], \"g-\", label=\"Recall\", linewidth=2)\n", 435 | " plt.xlabel(\"Threshold\", fontsize=16)\n", 436 | " plt.legend(loc=\"upper left\", fontsize=16)\n", 437 | " plt.ylim([0, 1])\n", 438 | "\n", 439 | "plt.figure(figsize=(8, 4))\n", 440 | "plot_precision_recall_vs_threshold(precisions, recalls, thresholds)\n", 441 | "plt.xlim([-700000, 700000])\n", 442 | "plt.show()" 443 | ] 444 | }, 445 | { 446 | "cell_type": "code", 447 | "execution_count": 25, 448 | "metadata": {}, 449 | "outputs": [], 450 | "source": [ 451 | "from sklearn.metrics import roc_curve\n", 452 | "\n", 453 | "fpr, tpr, thresholds = roc_curve(y_train_5, y_scores)" 454 | ] 455 | }, 456 | { 457 | "cell_type": "code", 458 | "execution_count": 26, 459 | "metadata": {}, 460 | "outputs": [ 461 | { 462 | "data": { 463 | "image/png": "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\n", 464 | "text/plain": [ 465 | "
" 466 | ] 467 | }, 468 | "metadata": { 469 | "needs_background": "light" 470 | }, 471 | "output_type": "display_data" 472 | } 473 | ], 474 | "source": [ 475 | "def plot_roc_curve(fpr, tpr, label=None):\n", 476 | " plt.plot(fpr, tpr, linewidth=2, label=label)\n", 477 | " plt.plot([0, 1], [0, 1], 'k--')\n", 478 | " plt.axis([0, 1, 0, 1])\n", 479 | " plt.xlabel('False Positive Rate', fontsize=16)\n", 480 | " plt.ylabel('True Positive Rate', fontsize=16)\n", 481 | "\n", 482 | "plt.figure(figsize=(8, 6))\n", 483 | "plot_roc_curve(fpr, tpr)\n", 484 | "plt.show()" 485 | ] 486 | }, 487 | { 488 | "cell_type": "code", 489 | "execution_count": 27, 490 | "metadata": {}, 491 | "outputs": [ 492 | { 493 | "data": { 494 | "text/plain": [ 495 | "0.9627684176223876" 496 | ] 497 | }, 498 | "execution_count": 27, 499 | "metadata": {}, 500 | "output_type": "execute_result" 501 | } 502 | ], 503 | "source": [ 504 | "from sklearn.metrics import roc_auc_score\n", 505 | "\n", 506 | "roc_auc_score(y_train_5, y_scores)" 507 | ] 508 | }, 509 | { 510 | "cell_type": "code", 511 | "execution_count": 28, 512 | "metadata": {}, 513 | "outputs": [ 514 | { 515 | "data": { 516 | "text/plain": [ 517 | "array([9], dtype=int8)" 518 | ] 519 | }, 520 | "execution_count": 28, 521 | "metadata": {}, 522 | "output_type": "execute_result" 523 | } 524 | ], 525 | "source": [ 526 | "sgd_clf.fit(X_train, y_train)\n", 527 | "sgd_clf.predict([some_digit])" 528 | ] 529 | }, 530 | { 531 | "cell_type": "code", 532 | "execution_count": 29, 533 | "metadata": {}, 534 | "outputs": [ 535 | { 536 | "data": { 537 | "text/plain": [ 538 | "array([[-793986.29255518, -367032.45961275, -633999.0056186 ,\n", 539 | " -142712.1310201 , -104087.70587353, -313757.18624295,\n", 540 | " -745392.44541636, -232751.71442494, -301826.62749662,\n", 541 | " -12778.35333429]])" 542 | ] 543 | }, 544 | "execution_count": 29, 545 | "metadata": {}, 546 | "output_type": "execute_result" 547 | } 548 | ], 549 | "source": [ 550 | "some_digit_scores = sgd_clf.decision_function([some_digit])\n", 551 | "some_digit_scores" 552 | ] 553 | }, 554 | { 555 | "cell_type": "code", 556 | "execution_count": 30, 557 | "metadata": {}, 558 | "outputs": [ 559 | { 560 | "data": { 561 | "text/plain": [ 562 | "9" 563 | ] 564 | }, 565 | "execution_count": 30, 566 | "metadata": {}, 567 | "output_type": "execute_result" 568 | } 569 | ], 570 | "source": [ 571 | "np.argmax(some_digit_scores)" 572 | ] 573 | }, 574 | { 575 | "cell_type": "code", 576 | "execution_count": 31, 577 | "metadata": {}, 578 | "outputs": [ 579 | { 580 | "data": { 581 | "text/plain": [ 582 | "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int8)" 583 | ] 584 | }, 585 | "execution_count": 31, 586 | "metadata": {}, 587 | "output_type": "execute_result" 588 | } 589 | ], 590 | "source": [ 591 | "sgd_clf.classes_" 592 | ] 593 | }, 594 | { 595 | "cell_type": "code", 596 | "execution_count": 32, 597 | "metadata": {}, 598 | "outputs": [ 599 | { 600 | "data": { 601 | "text/plain": [ 602 | "array([9], dtype=int8)" 603 | ] 604 | }, 605 | "execution_count": 32, 606 | "metadata": {}, 607 | "output_type": "execute_result" 608 | } 609 | ], 610 | "source": [ 611 | "from sklearn.multiclass import OneVsOneClassifier\n", 612 | "ovo_clf = OneVsOneClassifier(SGDClassifier(max_iter=5, tol=-np.infty, random_state=42))\n", 613 | "ovo_clf.fit(X_train, y_train)\n", 614 | "ovo_clf.predict([some_digit])" 615 | ] 616 | }, 617 | { 618 | "cell_type": "code", 619 | "execution_count": 33, 620 | "metadata": {}, 621 | "outputs": [ 622 | { 623 | "data": { 624 | "text/plain": [ 625 | "45" 626 | ] 627 | }, 628 | "execution_count": 33, 629 | "metadata": {}, 630 | "output_type": "execute_result" 631 | } 632 | ], 633 | "source": [ 634 | "len(ovo_clf.estimators_)" 635 | ] 636 | }, 637 | { 638 | "cell_type": "code", 639 | "execution_count": 35, 640 | "metadata": {}, 641 | "outputs": [ 642 | { 643 | "data": { 644 | "text/plain": [ 645 | "array([0.90756849, 0.91029551, 0.90958644])" 646 | ] 647 | }, 648 | "execution_count": 35, 649 | "metadata": {}, 650 | "output_type": "execute_result" 651 | } 652 | ], 653 | "source": [ 654 | "from sklearn.preprocessing import StandardScaler\n", 655 | "scaler = StandardScaler()\n", 656 | "X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))\n", 657 | "cross_val_score(sgd_clf, X_train_scaled, y_train, cv=3, scoring=\"accuracy\")" 658 | ] 659 | }, 660 | { 661 | "cell_type": "code", 662 | "execution_count": 36, 663 | "metadata": {}, 664 | "outputs": [ 665 | { 666 | "data": { 667 | "text/plain": [ 668 | "array([[5743, 2, 21, 10, 8, 42, 43, 9, 41, 4],\n", 669 | " [ 1, 6480, 45, 29, 6, 46, 8, 13, 105, 9],\n", 670 | " [ 59, 40, 5302, 107, 85, 21, 95, 60, 171, 18],\n", 671 | " [ 52, 42, 131, 5333, 2, 247, 36, 57, 133, 98],\n", 672 | " [ 21, 26, 44, 10, 5346, 10, 56, 37, 75, 217],\n", 673 | " [ 67, 48, 34, 178, 72, 4595, 117, 30, 184, 96],\n", 674 | " [ 35, 25, 45, 2, 40, 82, 5644, 6, 39, 0],\n", 675 | " [ 28, 19, 74, 32, 45, 10, 5, 5826, 17, 209],\n", 676 | " [ 49, 160, 69, 157, 12, 160, 60, 30, 5000, 154],\n", 677 | " [ 46, 29, 32, 83, 164, 31, 2, 208, 74, 5280]],\n", 678 | " dtype=int64)" 679 | ] 680 | }, 681 | "execution_count": 36, 682 | "metadata": {}, 683 | "output_type": "execute_result" 684 | } 685 | ], 686 | "source": [ 687 | "y_train_pred = cross_val_predict(sgd_clf, X_train_scaled, y_train, cv=3)\n", 688 | "conf_mx = confusion_matrix(y_train, y_train_pred)\n", 689 | "conf_mx" 690 | ] 691 | }, 692 | { 693 | "cell_type": "code", 694 | "execution_count": 37, 695 | "metadata": {}, 696 | "outputs": [ 697 | { 698 | "data": { 699 | "image/png": "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\n", 700 | "text/plain": [ 701 | "
" 702 | ] 703 | }, 704 | "metadata": { 705 | "needs_background": "light" 706 | }, 707 | "output_type": "display_data" 708 | } 709 | ], 710 | "source": [ 711 | "plt.matshow(conf_mx, cmap=plt.cm.gray)\n", 712 | "plt.show()" 713 | ] 714 | }, 715 | { 716 | "cell_type": "code", 717 | "execution_count": 38, 718 | "metadata": {}, 719 | "outputs": [], 720 | "source": [ 721 | "row_sums = conf_mx.sum(axis=1, keepdims=True)\n", 722 | "norm_conf_mx = conf_mx / row_sums" 723 | ] 724 | }, 725 | { 726 | "cell_type": "code", 727 | "execution_count": 39, 728 | "metadata": {}, 729 | "outputs": [], 730 | "source": [ 731 | "np.fill_diagonal(norm_conf_mx, 0)" 732 | ] 733 | }, 734 | { 735 | "cell_type": "code", 736 | "execution_count": 40, 737 | "metadata": {}, 738 | "outputs": [ 739 | { 740 | "data": { 741 | "image/png": "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\n", 742 | "text/plain": [ 743 | "
" 744 | ] 745 | }, 746 | "metadata": { 747 | "needs_background": "light" 748 | }, 749 | "output_type": "display_data" 750 | } 751 | ], 752 | "source": [ 753 | "plt.matshow(norm_conf_mx, cmap=plt.cm.gray)\n", 754 | "plt.show()" 755 | ] 756 | }, 757 | { 758 | "cell_type": "code", 759 | "execution_count": 41, 760 | "metadata": {}, 761 | "outputs": [ 762 | { 763 | "data": { 764 | "text/plain": [ 765 | "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n", 766 | " metric_params=None, n_jobs=None, n_neighbors=5, p=2,\n", 767 | " weights='uniform')" 768 | ] 769 | }, 770 | "execution_count": 41, 771 | "metadata": {}, 772 | "output_type": "execute_result" 773 | } 774 | ], 775 | "source": [ 776 | "from sklearn.neighbors import KNeighborsClassifier\n", 777 | "\n", 778 | "y_train_large = (y_train >= 7)\n", 779 | "y_train_odd = (y_train % 2 == 1)\n", 780 | "y_multilabel = np.c_[y_train_large, y_train_odd]\n", 781 | "\n", 782 | "knn_clf = KNeighborsClassifier()\n", 783 | "knn_clf.fit(X_train, y_multilabel)" 784 | ] 785 | }, 786 | { 787 | "cell_type": "code", 788 | "execution_count": 42, 789 | "metadata": {}, 790 | "outputs": [ 791 | { 792 | "data": { 793 | "text/plain": [ 794 | "array([[ True, True]])" 795 | ] 796 | }, 797 | "execution_count": 42, 798 | "metadata": {}, 799 | "output_type": "execute_result" 800 | } 801 | ], 802 | "source": [ 803 | "knn_clf.predict([some_digit])" 804 | ] 805 | }, 806 | { 807 | "cell_type": "code", 808 | "execution_count": null, 809 | "metadata": {}, 810 | "outputs": [], 811 | "source": [] 812 | } 813 | ], 814 | "metadata": { 815 | "kernelspec": { 816 | "display_name": "Python 3", 817 | "language": "python", 818 | "name": "python3" 819 | }, 820 | "language_info": { 821 | "codemirror_mode": { 822 | "name": "ipython", 823 | "version": 3 824 | }, 825 | "file_extension": ".py", 826 | "mimetype": "text/x-python", 827 | "name": "python", 828 | "nbconvert_exporter": "python", 829 | "pygments_lexer": "ipython3", 830 | "version": "3.7.3" 831 | } 832 | }, 833 | "nbformat": 4, 834 | "nbformat_minor": 2 835 | } 836 | -------------------------------------------------------------------------------- /chapter4/lin_reg.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 13, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import numpy as np\n", 10 | "\n", 11 | "X = 2 * np.random.rand(100, 1)\n", 12 | "y = 4 + 3 * X + np.random.randn(100, 1)" 13 | ] 14 | }, 15 | { 16 | "cell_type": "code", 17 | "execution_count": 14, 18 | "metadata": {}, 19 | "outputs": [], 20 | "source": [ 21 | "%matplotlib inline\n", 22 | "import matplotlib as mpl\n", 23 | "import matplotlib.pyplot as plt" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": 15, 29 | "metadata": {}, 30 | "outputs": [ 31 | { 32 | "data": { 33 | "image/png": "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\n", 34 | "text/plain": [ 35 | "
" 36 | ] 37 | }, 38 | "metadata": { 39 | "needs_background": "light" 40 | }, 41 | "output_type": "display_data" 42 | } 43 | ], 44 | "source": [ 45 | "plt.plot(X, y, \"b.\")\n", 46 | "plt.xlabel(\"$x_1$\", fontsize=18)\n", 47 | "plt.ylabel(\"$y$\", rotation=0, fontsize=18)\n", 48 | "plt.axis([0, 2, 0, 15])\n", 49 | "plt.show()" 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": 16, 55 | "metadata": {}, 56 | "outputs": [], 57 | "source": [ 58 | "X_b = np.c_[np.ones((100, 1)), X] # add x0 = 1 to each instance\n", 59 | "theta_best = np.linalg.inv(X_b.T.dot(X_b)).dot(X_b.T).dot(y)" 60 | ] 61 | }, 62 | { 63 | "cell_type": "code", 64 | "execution_count": 17, 65 | "metadata": {}, 66 | "outputs": [ 67 | { 68 | "data": { 69 | "text/plain": [ 70 | "array([[4.3359712 ],\n", 71 | " [2.89954411]])" 72 | ] 73 | }, 74 | "execution_count": 17, 75 | "metadata": {}, 76 | "output_type": "execute_result" 77 | } 78 | ], 79 | "source": [ 80 | "theta_best" 81 | ] 82 | }, 83 | { 84 | "cell_type": "code", 85 | "execution_count": 18, 86 | "metadata": {}, 87 | "outputs": [ 88 | { 89 | "data": { 90 | "text/plain": [ 91 | "array([[ 4.3359712 ],\n", 92 | " [10.13505942]])" 93 | ] 94 | }, 95 | "execution_count": 18, 96 | "metadata": {}, 97 | "output_type": "execute_result" 98 | } 99 | ], 100 | "source": [ 101 | "X_new = np.array([[0], [2]])\n", 102 | "X_new_b = np.c_[np.ones((2, 1)), X_new] # add x0 = 1 to each instance\n", 103 | "y_predict = X_new_b.dot(theta_best)\n", 104 | "y_predict" 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": 19, 110 | "metadata": {}, 111 | "outputs": [ 112 | { 113 | "data": { 114 | "image/png": "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\n", 115 | "text/plain": [ 116 | "
" 117 | ] 118 | }, 119 | "metadata": { 120 | "needs_background": "light" 121 | }, 122 | "output_type": "display_data" 123 | } 124 | ], 125 | "source": [ 126 | "plt.plot(X_new, y_predict, \"r-\")\n", 127 | "plt.plot(X, y, \"b.\")\n", 128 | "plt.axis([0, 2, 0, 15])\n", 129 | "plt.show()" 130 | ] 131 | }, 132 | { 133 | "cell_type": "code", 134 | "execution_count": 20, 135 | "metadata": {}, 136 | "outputs": [ 137 | { 138 | "data": { 139 | "text/plain": [ 140 | "(array([4.3359712]), array([[2.89954411]]))" 141 | ] 142 | }, 143 | "execution_count": 20, 144 | "metadata": {}, 145 | "output_type": "execute_result" 146 | } 147 | ], 148 | "source": [ 149 | "from sklearn.linear_model import LinearRegression\n", 150 | "lin_reg = LinearRegression()\n", 151 | "lin_reg.fit(X, y)\n", 152 | "lin_reg.intercept_, lin_reg.coef_" 153 | ] 154 | }, 155 | { 156 | "cell_type": "code", 157 | "execution_count": 21, 158 | "metadata": {}, 159 | "outputs": [ 160 | { 161 | "data": { 162 | "text/plain": [ 163 | "array([[ 4.3359712 ],\n", 164 | " [10.13505942]])" 165 | ] 166 | }, 167 | "execution_count": 21, 168 | "metadata": {}, 169 | "output_type": "execute_result" 170 | } 171 | ], 172 | "source": [ 173 | "lin_reg.predict(X_new)" 174 | ] 175 | }, 176 | { 177 | "cell_type": "code", 178 | "execution_count": 22, 179 | "metadata": {}, 180 | "outputs": [], 181 | "source": [ 182 | "eta = 0.1\n", 183 | "n_iter = 1000\n", 184 | "m = 100\n", 185 | "theta = np.random.randn(2, 1)" 186 | ] 187 | }, 188 | { 189 | "cell_type": "code", 190 | "execution_count": 23, 191 | "metadata": {}, 192 | "outputs": [], 193 | "source": [ 194 | "for iter in range(n_iter):\n", 195 | " gradients = 2 / m * X_b.T.dot(X_b.dot(theta) - y)\n", 196 | " theta = theta - eta * gradients" 197 | ] 198 | }, 199 | { 200 | "cell_type": "code", 201 | "execution_count": 24, 202 | "metadata": {}, 203 | "outputs": [ 204 | { 205 | "data": { 206 | "text/plain": [ 207 | "array([[4.3359712 ],\n", 208 | " [2.89954411]])" 209 | ] 210 | }, 211 | "execution_count": 24, 212 | "metadata": {}, 213 | "output_type": "execute_result" 214 | } 215 | ], 216 | "source": [ 217 | "theta" 218 | ] 219 | }, 220 | { 221 | "cell_type": "code", 222 | "execution_count": 27, 223 | "metadata": {}, 224 | "outputs": [], 225 | "source": [ 226 | "n_epochs = 100\n", 227 | "t0, t1 = 5, 50 # learning schedule hyperparameters\n", 228 | "\n", 229 | "def learning_schedule(t):\n", 230 | " return t0 / (t + t1)\n", 231 | "\n", 232 | "theta = np.random.randn(2,1)\n", 233 | "\n", 234 | "for epoch in range(n_epochs):\n", 235 | " for i in range(m):\n", 236 | " random_index = np.random.randint(m)\n", 237 | " xi = X_b[random_index:random_index+1]\n", 238 | " yi = y[random_index:random_index+1]\n", 239 | " gradients = 2 * xi.T.dot(xi.dot(theta) - yi)\n", 240 | " eta = learning_schedule(epoch * m + i)\n", 241 | " theta = theta - eta * gradients" 242 | ] 243 | }, 244 | { 245 | "cell_type": "code", 246 | "execution_count": 28, 247 | "metadata": {}, 248 | "outputs": [ 249 | { 250 | "data": { 251 | "text/plain": [ 252 | "array([[4.30706448],\n", 253 | " [2.89758724]])" 254 | ] 255 | }, 256 | "execution_count": 28, 257 | "metadata": {}, 258 | "output_type": "execute_result" 259 | } 260 | ], 261 | "source": [ 262 | "theta" 263 | ] 264 | }, 265 | { 266 | "cell_type": "code", 267 | "execution_count": 29, 268 | "metadata": {}, 269 | "outputs": [ 270 | { 271 | "data": { 272 | "text/plain": [ 273 | "SGDRegressor(alpha=0.0001, average=False, early_stopping=False, epsilon=0.1,\n", 274 | " eta0=0.1, fit_intercept=True, l1_ratio=0.15,\n", 275 | " learning_rate='invscaling', loss='squared_loss', max_iter=50,\n", 276 | " n_iter=None, n_iter_no_change=5, penalty=None, power_t=0.25,\n", 277 | " random_state=42, shuffle=True, tol=-inf, validation_fraction=0.1,\n", 278 | " verbose=0, warm_start=False)" 279 | ] 280 | }, 281 | "execution_count": 29, 282 | "metadata": {}, 283 | "output_type": "execute_result" 284 | } 285 | ], 286 | "source": [ 287 | "from sklearn.linear_model import SGDRegressor\n", 288 | "sgd_reg = SGDRegressor(max_iter=50, tol=-np.infty, penalty=None, eta0=0.1, random_state=42)\n", 289 | "sgd_reg.fit(X, y.ravel())" 290 | ] 291 | }, 292 | { 293 | "cell_type": "code", 294 | "execution_count": 30, 295 | "metadata": {}, 296 | "outputs": [ 297 | { 298 | "data": { 299 | "text/plain": [ 300 | "(array([4.33831529]), array([2.91230574]))" 301 | ] 302 | }, 303 | "execution_count": 30, 304 | "metadata": {}, 305 | "output_type": "execute_result" 306 | } 307 | ], 308 | "source": [ 309 | "sgd_reg.intercept_, sgd_reg.coef_" 310 | ] 311 | }, 312 | { 313 | "cell_type": "code", 314 | "execution_count": null, 315 | "metadata": {}, 316 | "outputs": [], 317 | "source": [] 318 | } 319 | ], 320 | "metadata": { 321 | "kernelspec": { 322 | "display_name": "Python 3", 323 | "language": "python", 324 | "name": "python3" 325 | }, 326 | "language_info": { 327 | "codemirror_mode": { 328 | "name": "ipython", 329 | "version": 3 330 | }, 331 | "file_extension": ".py", 332 | "mimetype": "text/x-python", 333 | "name": "python", 334 | "nbconvert_exporter": "python", 335 | "pygments_lexer": "ipython3", 336 | "version": "3.7.3" 337 | } 338 | }, 339 | "nbformat": 4, 340 | "nbformat_minor": 2 341 | } 342 | -------------------------------------------------------------------------------- /chapter4/logistic_reg.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 5, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import numpy as np\n", 10 | "import numpy.random as rnd\n", 11 | "\n", 12 | "np.random.seed(42)" 13 | ] 14 | }, 15 | { 16 | "cell_type": "code", 17 | "execution_count": 6, 18 | "metadata": {}, 19 | "outputs": [ 20 | { 21 | "data": { 22 | "text/plain": [ 23 | "['data', 'target', 'target_names', 'DESCR', 'feature_names', 'filename']" 24 | ] 25 | }, 26 | "execution_count": 6, 27 | "metadata": {}, 28 | "output_type": "execute_result" 29 | } 30 | ], 31 | "source": [ 32 | "from sklearn import datasets\n", 33 | "iris = datasets.load_iris()\n", 34 | "list(iris.keys())" 35 | ] 36 | }, 37 | { 38 | "cell_type": "code", 39 | "execution_count": 7, 40 | "metadata": {}, 41 | "outputs": [], 42 | "source": [ 43 | "X = iris[\"data\"][:, 3:] # petal width\n", 44 | "y = (iris[\"target\"] == 2).astype(np.int) # 1 if Iris-Virginica, else 0" 45 | ] 46 | }, 47 | { 48 | "cell_type": "code", 49 | "execution_count": 9, 50 | "metadata": {}, 51 | "outputs": [ 52 | { 53 | "data": { 54 | "text/plain": [ 55 | "LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n", 56 | " intercept_scaling=1, max_iter=100, multi_class='warn',\n", 57 | " n_jobs=None, penalty='l2', random_state=42, solver='liblinear',\n", 58 | " tol=0.0001, verbose=0, warm_start=False)" 59 | ] 60 | }, 61 | "execution_count": 9, 62 | "metadata": {}, 63 | "output_type": "execute_result" 64 | } 65 | ], 66 | "source": [ 67 | "from sklearn.linear_model import LogisticRegression\n", 68 | "log_reg = LogisticRegression(solver=\"liblinear\", random_state=42)\n", 69 | "log_reg.fit(X, y)" 70 | ] 71 | }, 72 | { 73 | "cell_type": "code", 74 | "execution_count": 10, 75 | "metadata": {}, 76 | "outputs": [], 77 | "source": [ 78 | "%matplotlib inline\n", 79 | "import matplotlib as mpl\n", 80 | "import matplotlib.pyplot as plt" 81 | ] 82 | }, 83 | { 84 | "cell_type": "code", 85 | "execution_count": 11, 86 | "metadata": {}, 87 | "outputs": [ 88 | { 89 | "data": { 90 | "text/plain": [ 91 | "[]" 92 | ] 93 | }, 94 | "execution_count": 11, 95 | "metadata": {}, 96 | "output_type": "execute_result" 97 | }, 98 | { 99 | "data": { 100 | "image/png": "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\n", 101 | "text/plain": [ 102 | "
" 103 | ] 104 | }, 105 | "metadata": { 106 | "needs_background": "light" 107 | }, 108 | "output_type": "display_data" 109 | } 110 | ], 111 | "source": [ 112 | "X_new = np.linspace(0, 3, 1000).reshape(-1, 1)\n", 113 | "y_proba = log_reg.predict_proba(X_new)\n", 114 | "\n", 115 | "plt.plot(X_new, y_proba[:, 1], \"g-\", linewidth=2, label=\"Iris-Virginica\")\n", 116 | "plt.plot(X_new, y_proba[:, 0], \"b--\", linewidth=2, label=\"Not Iris-Virginica\")" 117 | ] 118 | }, 119 | { 120 | "cell_type": "code", 121 | "execution_count": 12, 122 | "metadata": {}, 123 | "outputs": [ 124 | { 125 | "data": { 126 | "text/plain": [ 127 | "array([1, 0])" 128 | ] 129 | }, 130 | "execution_count": 12, 131 | "metadata": {}, 132 | "output_type": "execute_result" 133 | } 134 | ], 135 | "source": [ 136 | "log_reg.predict([[1.7], [1.5]])" 137 | ] 138 | }, 139 | { 140 | "cell_type": "code", 141 | "execution_count": 13, 142 | "metadata": {}, 143 | "outputs": [ 144 | { 145 | "data": { 146 | "text/plain": [ 147 | "LogisticRegression(C=10, class_weight=None, dual=False, fit_intercept=True,\n", 148 | " intercept_scaling=1, max_iter=100, multi_class='multinomial',\n", 149 | " n_jobs=None, penalty='l2', random_state=42, solver='lbfgs',\n", 150 | " tol=0.0001, verbose=0, warm_start=False)" 151 | ] 152 | }, 153 | "execution_count": 13, 154 | "metadata": {}, 155 | "output_type": "execute_result" 156 | } 157 | ], 158 | "source": [ 159 | "X = iris[\"data\"][:, (2, 3)] # petal length, petal width\n", 160 | "y = iris[\"target\"]\n", 161 | "\n", 162 | "softmax_reg = LogisticRegression(multi_class=\"multinomial\",solver=\"lbfgs\", C=10, random_state=42)\n", 163 | "softmax_reg.fit(X, y)" 164 | ] 165 | }, 166 | { 167 | "cell_type": "code", 168 | "execution_count": 14, 169 | "metadata": {}, 170 | "outputs": [ 171 | { 172 | "data": { 173 | "text/plain": [ 174 | "array([2])" 175 | ] 176 | }, 177 | "execution_count": 14, 178 | "metadata": {}, 179 | "output_type": "execute_result" 180 | } 181 | ], 182 | "source": [ 183 | "softmax_reg.predict([[5, 2]])" 184 | ] 185 | }, 186 | { 187 | "cell_type": "code", 188 | "execution_count": 15, 189 | "metadata": {}, 190 | "outputs": [ 191 | { 192 | "data": { 193 | "text/plain": [ 194 | "array([[6.38014896e-07, 5.74929995e-02, 9.42506362e-01]])" 195 | ] 196 | }, 197 | "execution_count": 15, 198 | "metadata": {}, 199 | "output_type": "execute_result" 200 | } 201 | ], 202 | "source": [ 203 | "softmax_reg.predict_proba([[5, 2]])" 204 | ] 205 | }, 206 | { 207 | "cell_type": "code", 208 | "execution_count": null, 209 | "metadata": {}, 210 | "outputs": [], 211 | "source": [] 212 | } 213 | ], 214 | "metadata": { 215 | "kernelspec": { 216 | "display_name": "Python 3", 217 | "language": "python", 218 | "name": "python3" 219 | }, 220 | "language_info": { 221 | "codemirror_mode": { 222 | "name": "ipython", 223 | "version": 3 224 | }, 225 | "file_extension": ".py", 226 | "mimetype": "text/x-python", 227 | "name": "python", 228 | "nbconvert_exporter": "python", 229 | "pygments_lexer": "ipython3", 230 | "version": "3.7.3" 231 | } 232 | }, 233 | "nbformat": 4, 234 | "nbformat_minor": 2 235 | } 236 | -------------------------------------------------------------------------------- /chapter4/poly_reg.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import numpy as np\n", 10 | "import numpy.random as rnd\n", 11 | "\n", 12 | "np.random.seed(42)" 13 | ] 14 | }, 15 | { 16 | "cell_type": "code", 17 | "execution_count": 2, 18 | "metadata": {}, 19 | "outputs": [], 20 | "source": [ 21 | "m = 100\n", 22 | "X = 6 * np.random.rand(m, 1) - 3\n", 23 | "y = 0.5 * X**2 + X + 2 + np.random.randn(m, 1)" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": 4, 29 | "metadata": {}, 30 | "outputs": [], 31 | "source": [ 32 | "%matplotlib inline\n", 33 | "import matplotlib as mpl\n", 34 | "import matplotlib.pyplot as plt" 35 | ] 36 | }, 37 | { 38 | "cell_type": "code", 39 | "execution_count": 5, 40 | "metadata": {}, 41 | "outputs": [ 42 | { 43 | "data": { 44 | "image/png": "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\n", 45 | "text/plain": [ 46 | "
" 47 | ] 48 | }, 49 | "metadata": { 50 | "needs_background": "light" 51 | }, 52 | "output_type": "display_data" 53 | } 54 | ], 55 | "source": [ 56 | "plt.plot(X, y, \"b.\")\n", 57 | "plt.xlabel(\"$x_1$\", fontsize=18)\n", 58 | "plt.ylabel(\"$y$\", rotation=0, fontsize=18)\n", 59 | "plt.axis([-3, 3, 0, 10])\n", 60 | "plt.show()" 61 | ] 62 | }, 63 | { 64 | "cell_type": "code", 65 | "execution_count": 6, 66 | "metadata": {}, 67 | "outputs": [ 68 | { 69 | "data": { 70 | "text/plain": [ 71 | "array([-0.75275929])" 72 | ] 73 | }, 74 | "execution_count": 6, 75 | "metadata": {}, 76 | "output_type": "execute_result" 77 | } 78 | ], 79 | "source": [ 80 | "from sklearn.preprocessing import PolynomialFeatures\n", 81 | "poly_features = PolynomialFeatures(degree=2, include_bias=False)\n", 82 | "X_poly = poly_features.fit_transform(X)\n", 83 | "X[0]" 84 | ] 85 | }, 86 | { 87 | "cell_type": "code", 88 | "execution_count": 7, 89 | "metadata": {}, 90 | "outputs": [ 91 | { 92 | "data": { 93 | "text/plain": [ 94 | "array([-0.75275929, 0.56664654])" 95 | ] 96 | }, 97 | "execution_count": 7, 98 | "metadata": {}, 99 | "output_type": "execute_result" 100 | } 101 | ], 102 | "source": [ 103 | "X_poly[0]" 104 | ] 105 | }, 106 | { 107 | "cell_type": "code", 108 | "execution_count": 9, 109 | "metadata": {}, 110 | "outputs": [ 111 | { 112 | "data": { 113 | "text/plain": [ 114 | "(array([1.78134581]), array([[0.93366893, 0.56456263]]))" 115 | ] 116 | }, 117 | "execution_count": 9, 118 | "metadata": {}, 119 | "output_type": "execute_result" 120 | } 121 | ], 122 | "source": [ 123 | "from sklearn.linear_model import LinearRegression\n", 124 | "lin_reg = LinearRegression()\n", 125 | "lin_reg.fit(X_poly, y)\n", 126 | "lin_reg.intercept_, lin_reg.coef_" 127 | ] 128 | }, 129 | { 130 | "cell_type": "code", 131 | "execution_count": 10, 132 | "metadata": {}, 133 | "outputs": [], 134 | "source": [ 135 | "from sklearn.metrics import mean_squared_error\n", 136 | "from sklearn.model_selection import train_test_split\n", 137 | "\n", 138 | "def plot_learning_curves(model, X, y):\n", 139 | " X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=10)\n", 140 | " train_errors, val_errors = [], []\n", 141 | " for m in range(1, len(X_train)):\n", 142 | " model.fit(X_train[:m], y_train[:m])\n", 143 | " y_train_predict = model.predict(X_train[:m])\n", 144 | " y_val_predict = model.predict(X_val)\n", 145 | " train_errors.append(mean_squared_error(y_train[:m], y_train_predict))\n", 146 | " val_errors.append(mean_squared_error(y_val, y_val_predict))\n", 147 | "\n", 148 | " plt.plot(np.sqrt(train_errors), \"r-+\", linewidth=2, label=\"train\")\n", 149 | " plt.plot(np.sqrt(val_errors), \"b-\", linewidth=3, label=\"val\")\n", 150 | " plt.legend(loc=\"upper right\", fontsize=14) # not shown in the book\n", 151 | " plt.xlabel(\"Training set size\", fontsize=14) # not shown\n", 152 | " plt.ylabel(\"RMSE\", fontsize=14) # not shown" 153 | ] 154 | }, 155 | { 156 | "cell_type": "code", 157 | "execution_count": 11, 158 | "metadata": {}, 159 | "outputs": [ 160 | { 161 | "data": { 162 | "image/png": "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\n", 163 | "text/plain": [ 164 | "
" 165 | ] 166 | }, 167 | "metadata": { 168 | "needs_background": "light" 169 | }, 170 | "output_type": "display_data" 171 | } 172 | ], 173 | "source": [ 174 | "lin_reg = LinearRegression()\n", 175 | "plot_learning_curves(lin_reg, X, y)\n", 176 | "plt.axis([0, 80, 0, 3]) # not shown in the book\n", 177 | "plt.show()" 178 | ] 179 | }, 180 | { 181 | "cell_type": "code", 182 | "execution_count": 12, 183 | "metadata": {}, 184 | "outputs": [ 185 | { 186 | "data": { 187 | "image/png": "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\n", 188 | "text/plain": [ 189 | "
" 190 | ] 191 | }, 192 | "metadata": { 193 | "needs_background": "light" 194 | }, 195 | "output_type": "display_data" 196 | } 197 | ], 198 | "source": [ 199 | "from sklearn.pipeline import Pipeline\n", 200 | "\n", 201 | "polynomial_regression = Pipeline([\n", 202 | " (\"poly_features\", PolynomialFeatures(degree=10, include_bias=False)),\n", 203 | " (\"lin_reg\", LinearRegression()),\n", 204 | " ])\n", 205 | "\n", 206 | "plot_learning_curves(polynomial_regression, X, y)\n", 207 | "plt.axis([0, 80, 0, 3]) # not shown\n", 208 | "plt.show() " 209 | ] 210 | }, 211 | { 212 | "cell_type": "code", 213 | "execution_count": null, 214 | "metadata": {}, 215 | "outputs": [], 216 | "source": [] 217 | } 218 | ], 219 | "metadata": { 220 | "kernelspec": { 221 | "display_name": "Python 3", 222 | "language": "python", 223 | "name": "python3" 224 | }, 225 | "language_info": { 226 | "codemirror_mode": { 227 | "name": "ipython", 228 | "version": 3 229 | }, 230 | "file_extension": ".py", 231 | "mimetype": "text/x-python", 232 | "name": "python", 233 | "nbconvert_exporter": "python", 234 | "pygments_lexer": "ipython3", 235 | "version": "3.7.3" 236 | } 237 | }, 238 | "nbformat": 4, 239 | "nbformat_minor": 2 240 | } 241 | -------------------------------------------------------------------------------- /chapter4/regularized_models.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 2, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import numpy as np\n", 10 | "import numpy.random as rnd\n", 11 | "\n", 12 | "np.random.seed(42)" 13 | ] 14 | }, 15 | { 16 | "cell_type": "code", 17 | "execution_count": 5, 18 | "metadata": {}, 19 | "outputs": [], 20 | "source": [ 21 | "np.random.seed(42)\n", 22 | "m = 20\n", 23 | "X = 3 * np.random.rand(m, 1)\n", 24 | "y = 1 + 0.5 * X + np.random.randn(m, 1) / 1.5" 25 | ] 26 | }, 27 | { 28 | "cell_type": "code", 29 | "execution_count": 6, 30 | "metadata": {}, 31 | "outputs": [ 32 | { 33 | "data": { 34 | "text/plain": [ 35 | "array([[1.55071465]])" 36 | ] 37 | }, 38 | "execution_count": 6, 39 | "metadata": {}, 40 | "output_type": "execute_result" 41 | } 42 | ], 43 | "source": [ 44 | "from sklearn.linear_model import Ridge\n", 45 | "ridge_reg = Ridge(alpha=1, solver=\"cholesky\", random_state=42)\n", 46 | "ridge_reg.fit(X, y)\n", 47 | "ridge_reg.predict([[1.5]])" 48 | ] 49 | }, 50 | { 51 | "cell_type": "code", 52 | "execution_count": 7, 53 | "metadata": {}, 54 | "outputs": [ 55 | { 56 | "data": { 57 | "text/plain": [ 58 | "array([1.49905184])" 59 | ] 60 | }, 61 | "execution_count": 7, 62 | "metadata": {}, 63 | "output_type": "execute_result" 64 | } 65 | ], 66 | "source": [ 67 | "from sklearn.linear_model import SGDRegressor\n", 68 | "sgd_reg = SGDRegressor(max_iter=50, tol=-np.infty, penalty=\"l2\", random_state=42)\n", 69 | "sgd_reg.fit(X, y.ravel())\n", 70 | "sgd_reg.predict([[1.5]])" 71 | ] 72 | }, 73 | { 74 | "cell_type": "code", 75 | "execution_count": 8, 76 | "metadata": {}, 77 | "outputs": [ 78 | { 79 | "data": { 80 | "text/plain": [ 81 | "array([1.53788174])" 82 | ] 83 | }, 84 | "execution_count": 8, 85 | "metadata": {}, 86 | "output_type": "execute_result" 87 | } 88 | ], 89 | "source": [ 90 | "from sklearn.linear_model import Lasso\n", 91 | "lasso_reg = Lasso(alpha=0.1)\n", 92 | "lasso_reg.fit(X, y)\n", 93 | "lasso_reg.predict([[1.5]])" 94 | ] 95 | }, 96 | { 97 | "cell_type": "code", 98 | "execution_count": 9, 99 | "metadata": {}, 100 | "outputs": [ 101 | { 102 | "data": { 103 | "text/plain": [ 104 | "array([1.54333232])" 105 | ] 106 | }, 107 | "execution_count": 9, 108 | "metadata": {}, 109 | "output_type": "execute_result" 110 | } 111 | ], 112 | "source": [ 113 | "from sklearn.linear_model import ElasticNet\n", 114 | "elastic_net = ElasticNet(alpha=0.1, l1_ratio=0.5, random_state=42)\n", 115 | "elastic_net.fit(X, y)\n", 116 | "elastic_net.predict([[1.5]])" 117 | ] 118 | }, 119 | { 120 | "cell_type": "code", 121 | "execution_count": null, 122 | "metadata": {}, 123 | "outputs": [], 124 | "source": [] 125 | } 126 | ], 127 | "metadata": { 128 | "kernelspec": { 129 | "display_name": "Python 3", 130 | "language": "python", 131 | "name": "python3" 132 | }, 133 | "language_info": { 134 | "codemirror_mode": { 135 | "name": "ipython", 136 | "version": 3 137 | }, 138 | "file_extension": ".py", 139 | "mimetype": "text/x-python", 140 | "name": "python", 141 | "nbconvert_exporter": "python", 142 | "pygments_lexer": "ipython3", 143 | "version": "3.7.3" 144 | } 145 | }, 146 | "nbformat": 4, 147 | "nbformat_minor": 2 148 | } 149 | -------------------------------------------------------------------------------- /data_fetcher/data_fetcher.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | import os 4 | import tarfile 5 | from six.moves import urllib 6 | 7 | DOWNLOAD_ROOT = "https://raw.githubusercontent.com/ageron/handson-ml/master/" 8 | HOUSING_PATH = os.path.join("datasets", "housing") 9 | HOUSING_URL = DOWNLOAD_ROOT + "datasets/housing/housing.tgz" 10 | 11 | def fetch_housing_data(housing_url=HOUSING_URL, housing_path=HOUSING_PATH): 12 | if not os.path.isdir(housing_path): 13 | os.makedirs(housing_path) 14 | tgz_path = os.path.join(housing_path, "housing.tgz") 15 | urllib.request.urlretrieve(housing_url, tgz_path) 16 | housing_tgz = tarfile.open(tgz_path) 17 | housing_tgz.extractall(path=housing_path) 18 | housing_tgz.close() 19 | 20 | fetch_housing_data() 21 | --------------------------------------------------------------------------------