├── .gitignore ├── Chapter01 ├── .keep └── Pandas.ipynb ├── Chapter02 ├── .keep ├── README.md ├── classification.ipynb └── regression.ipynb ├── Chapter03 ├── .keep ├── Linear Classifiers.ipynb ├── Linear Regression.ipynb └── README.md ├── Chapter04 ├── .keep ├── README.md ├── category encoding.ipynb ├── imputation.ipynb └── scaling et al.ipynb ├── Chapter05 ├── .keep ├── Digits Embedding.ipynb ├── KNN Digit.ipynb └── README.md ├── Chapter06 ├── .keep ├── README.md ├── Text Classification.ipynb └── Tokenization.ipynb ├── Chapter07 ├── .keep ├── Activation Functions.ipynb ├── Convolutions.ipynb ├── Neural Networks.ipynb └── README.md ├── Chapter08 ├── .keep ├── Car Prices.ipynb └── Hastie Classifier.ipynb ├── Chapter09 ├── .keep ├── Multi Target & Calibration.ipynb └── Target Scaling.ipynb ├── Chapter10 ├── .keep └── Imbalanced Data.ipynb ├── Chapter11 ├── .keep └── Clustering.ipynb ├── Chapter12 ├── .keep └── Outliers.ipynb ├── Chapter13 ├── .keep ├── README.md ├── RecSys.ipynb ├── artist_recommender.pkl └── recsys.pkl ├── README.md └── requirements.txt /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Distribution / packaging 10 | .Python 11 | build/ 12 | develop-eggs/ 13 | dist/ 14 | downloads/ 15 | eggs/ 16 | .eggs/ 17 | lib/ 18 | lib64/ 19 | parts/ 20 | sdist/ 21 | var/ 22 | wheels/ 23 | *.egg-info/ 24 | .installed.cfg 25 | *.egg 26 | MANIFEST 27 | 28 | # PyInstaller 29 | # Usually these files are written by a python script from a template 30 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 31 | *.manifest 32 | *.spec 33 | 34 | # Installer logs 35 | pip-log.txt 36 | pip-delete-this-directory.txt 37 | 38 | # Unit test / coverage reports 39 | htmlcov/ 40 | .tox/ 41 | .coverage 42 | .coverage.* 43 | .cache 44 | nosetests.xml 45 | coverage.xml 46 | *.cover 47 | .hypothesis/ 48 | .pytest_cache/ 49 | 50 | # Translations 51 | *.mo 52 | *.pot 53 | 54 | # Django stuff: 55 | *.log 56 | local_settings.py 57 | db.sqlite3 58 | 59 | # Flask stuff: 60 | instance/ 61 | .webassets-cache 62 | 63 | # Scrapy stuff: 64 | .scrapy 65 | 66 | # Sphinx documentation 67 | docs/_build/ 68 | 69 | # PyBuilder 70 | target/ 71 | 72 | # Jupyter Notebook 73 | .ipynb_checkpoints 74 | 75 | # pyenv 76 | .python-version 77 | 78 | # celery beat schedule file 79 | celerybeat-schedule 80 | 81 | # SageMath parsed files 82 | *.sage.py 83 | 84 | # Environments 85 | .env 86 | .venv 87 | env/ 88 | venv/ 89 | ENV/ 90 | env.bak/ 91 | venv.bak/ 92 | 93 | # Spyder project settings 94 | .spyderproject 95 | .spyproject 96 | 97 | # Rope project settings 98 | .ropeproject 99 | 100 | # mkdocs documentation 101 | /site 102 | 103 | # mypy 104 | .mypy_cache/ 105 | 106 | .DS_Store 107 | **/.DS_Store 108 | 109 | # Data sets 110 | chapters/ch06/data/** 111 | -------------------------------------------------------------------------------- /Chapter01/.keep: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/Hands-On-Machine-Learning-with-scikit-learn-and-Scientific-Python-Toolkits/2dc4f5164d75adfc298767f14f5aeafe45d0b385/Chapter01/.keep -------------------------------------------------------------------------------- /Chapter01/Pandas.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Pandas\n", 8 | "\n", 9 | "Pandas is an open source library providing data analysis tools for the Python programming language. If this definition doesn't say much, I'd say you can think of Pandas for now as Python's response to spread sheets. Having that said, it is clear now why I decided to dedicate this section to Pandas, since you will be using it to create or load the data you are going to use with Scikit-learn. You will also use it to analyse and visualize the data and alter the values of columns before applying your machine learning algorithms to them." 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": 9, 15 | "metadata": {}, 16 | "outputs": [], 17 | "source": [ 18 | "# It's common to import pandas as pd\n", 19 | "\n", 20 | "import pandas as pd" 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": 10, 26 | "metadata": {}, 27 | "outputs": [], 28 | "source": [ 29 | "# This is how to create a dataframe \n", 30 | "\n", 31 | "polygons_data_frame = pd.DataFrame(\n", 32 | " {\n", 33 | " 'Name': ['Triangle', 'Quadrilateral', 'Pentagon', 'Hexagon'],\n", 34 | " 'Sides': [3, 4, 5, 6],\n", 35 | " }\n", 36 | ")" 37 | ] 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": 11, 42 | "metadata": {}, 43 | "outputs": [ 44 | { 45 | "data": { 46 | "text/html": [ 47 | "
\n", 48 | "\n", 61 | "\n", 62 | " \n", 63 | " \n", 64 | " \n", 65 | " \n", 66 | " \n", 67 | " \n", 68 | " \n", 69 | " \n", 70 | " \n", 71 | " \n", 72 | " \n", 73 | " \n", 74 | " \n", 75 | " \n", 76 | " \n", 77 | " \n", 78 | " \n", 79 | " \n", 80 | " \n", 81 | " \n", 82 | " \n", 83 | " \n", 84 | " \n", 85 | " \n", 86 | "
NameSides
0Triangle3
1Quadrilateral4
2Pentagon5
\n", 87 | "
" 88 | ], 89 | "text/plain": [ 90 | " Name Sides\n", 91 | "0 Triangle 3\n", 92 | "1 Quadrilateral 4\n", 93 | "2 Pentagon 5" 94 | ] 95 | }, 96 | "execution_count": 11, 97 | "metadata": {}, 98 | "output_type": "execute_result" 99 | } 100 | ], 101 | "source": [ 102 | "# Showing first 3 rows of the dataframe \n", 103 | "\n", 104 | "polygons_data_frame.head(3)" 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": 12, 110 | "metadata": {}, 111 | "outputs": [], 112 | "source": [ 113 | "# Creating another dataframe\n", 114 | "\n", 115 | "polygons = {\n", 116 | " 'Name': [\n", 117 | " 'Triangle', 'Quadrilateral', 'Pentagon', 'Hexagon', 'Heptagon', 'Octagon', \n", 118 | " 'Nonagon', 'Decagon', 'Hendecagon', 'Dodecagon', 'Tridecagon', 'Tetradecagon'\n", 119 | " ],\n", 120 | " 'Sides': range(3, 15, 1),\n", 121 | "}\n", 122 | "\n", 123 | "polygons_data_frame = pd.DataFrame(polygons)" 124 | ] 125 | }, 126 | { 127 | "cell_type": "code", 128 | "execution_count": 13, 129 | "metadata": {}, 130 | "outputs": [ 131 | { 132 | "data": { 133 | "text/html": [ 134 | "
\n", 135 | "\n", 148 | "\n", 149 | " \n", 150 | " \n", 151 | " \n", 152 | " \n", 153 | " \n", 154 | " \n", 155 | " \n", 156 | " \n", 157 | " \n", 158 | " \n", 159 | " \n", 160 | " \n", 161 | " \n", 162 | " \n", 163 | " \n", 164 | " \n", 165 | " \n", 166 | " \n", 167 | " \n", 168 | " \n", 169 | " \n", 170 | " \n", 171 | " \n", 172 | " \n", 173 | " \n", 174 | " \n", 175 | " \n", 176 | " \n", 177 | " \n", 178 | " \n", 179 | " \n", 180 | " \n", 181 | " \n", 182 | " \n", 183 | " \n", 184 | " \n", 185 | " \n", 186 | " \n", 187 | " \n", 188 | " \n", 189 | " \n", 190 | " \n", 191 | " \n", 192 | " \n", 193 | " \n", 194 | " \n", 195 | " \n", 196 | " \n", 197 | " \n", 198 | " \n", 199 | " \n", 200 | " \n", 201 | " \n", 202 | " \n", 203 | " \n", 204 | " \n", 205 | " \n", 206 | " \n", 207 | " \n", 208 | " \n", 209 | " \n", 210 | " \n", 211 | " \n", 212 | " \n", 213 | " \n", 214 | " \n", 215 | " \n", 216 | " \n", 217 | " \n", 218 | "
NameSides
0Triangle3
1Quadrilateral4
2Pentagon5
3Hexagon6
4Heptagon7
5Octagon8
6Nonagon9
7Decagon10
8Hendecagon11
9Dodecagon12
10Tridecagon13
11Tetradecagon14
\n", 219 | "
" 220 | ], 221 | "text/plain": [ 222 | " Name Sides\n", 223 | "0 Triangle 3\n", 224 | "1 Quadrilateral 4\n", 225 | "2 Pentagon 5\n", 226 | "3 Hexagon 6\n", 227 | "4 Heptagon 7\n", 228 | "5 Octagon 8\n", 229 | "6 Nonagon 9\n", 230 | "7 Decagon 10\n", 231 | "8 Hendecagon 11\n", 232 | "9 Dodecagon 12\n", 233 | "10 Tridecagon 13\n", 234 | "11 Tetradecagon 14" 235 | ] 236 | }, 237 | "execution_count": 13, 238 | "metadata": {}, 239 | "output_type": "execute_result" 240 | } 241 | ], 242 | "source": [ 243 | "polygons_data_frame" 244 | ] 245 | }, 246 | { 247 | "cell_type": "code", 248 | "execution_count": 14, 249 | "metadata": {}, 250 | "outputs": [ 251 | { 252 | "data": { 253 | "text/html": [ 254 | "
\n", 255 | "\n", 268 | "\n", 269 | " \n", 270 | " \n", 271 | " \n", 272 | " \n", 273 | " \n", 274 | " \n", 275 | " \n", 276 | " \n", 277 | " \n", 278 | " \n", 279 | " \n", 280 | " \n", 281 | " \n", 282 | " \n", 283 | " \n", 284 | " \n", 285 | " \n", 286 | " \n", 287 | " \n", 288 | " \n", 289 | " \n", 290 | " \n", 291 | " \n", 292 | " \n", 293 | " \n", 294 | " \n", 295 | " \n", 296 | " \n", 297 | " \n", 298 | " \n", 299 | " \n", 300 | " \n", 301 | " \n", 302 | " \n", 303 | "
NameSides
7Decagon10
9Dodecagon12
8Hendecagon11
4Heptagon7
3Hexagon6
\n", 304 | "
" 305 | ], 306 | "text/plain": [ 307 | " Name Sides\n", 308 | "7 Decagon 10\n", 309 | "9 Dodecagon 12\n", 310 | "8 Hendecagon 11\n", 311 | "4 Heptagon 7\n", 312 | "3 Hexagon 6" 313 | ] 314 | }, 315 | "execution_count": 14, 316 | "metadata": {}, 317 | "output_type": "execute_result" 318 | } 319 | ], 320 | "source": [ 321 | "polygons_data_frame.sort_values('Name').head(5)" 322 | ] 323 | }, 324 | { 325 | "cell_type": "code", 326 | "execution_count": 15, 327 | "metadata": {}, 328 | "outputs": [], 329 | "source": [ 330 | "polygons_data_frame['Length of Name'] = polygons_data_frame['Name'].apply(len) " 331 | ] 332 | }, 333 | { 334 | "cell_type": "code", 335 | "execution_count": 16, 336 | "metadata": {}, 337 | "outputs": [], 338 | "source": [ 339 | "# polygons_data_frame['Length of Name'] = polygons_data_frame['Name'].apply(lambda n: len(n)**2)" 340 | ] 341 | }, 342 | { 343 | "cell_type": "code", 344 | "execution_count": 17, 345 | "metadata": {}, 346 | "outputs": [ 347 | { 348 | "data": { 349 | "text/html": [ 350 | "
\n", 351 | "\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 | " \n", 399 | " \n", 400 | " \n", 401 | " \n", 402 | " \n", 403 | " \n", 404 | " \n", 405 | " \n", 406 | " \n", 407 | " \n", 408 | " \n", 409 | " \n", 410 | " \n", 411 | " \n", 412 | " \n", 413 | " \n", 414 | " \n", 415 | " \n", 416 | " \n", 417 | " \n", 418 | " \n", 419 | " \n", 420 | " \n", 421 | " \n", 422 | " \n", 423 | " \n", 424 | " \n", 425 | " \n", 426 | " \n", 427 | " \n", 428 | " \n", 429 | " \n", 430 | " \n", 431 | " \n", 432 | " \n", 433 | " \n", 434 | " \n", 435 | " \n", 436 | " \n", 437 | " \n", 438 | " \n", 439 | " \n", 440 | " \n", 441 | " \n", 442 | " \n", 443 | " \n", 444 | " \n", 445 | " \n", 446 | " \n", 447 | "
NameSidesLength of Name
3Hexagon67
5Octagon87
6Nonagon97
7Decagon107
0Triangle38
2Pentagon58
4Heptagon78
9Dodecagon129
8Hendecagon1110
10Tridecagon1310
11Tetradecagon1412
1Quadrilateral413
\n", 448 | "
" 449 | ], 450 | "text/plain": [ 451 | " Name Sides Length of Name\n", 452 | "3 Hexagon 6 7\n", 453 | "5 Octagon 8 7\n", 454 | "6 Nonagon 9 7\n", 455 | "7 Decagon 10 7\n", 456 | "0 Triangle 3 8\n", 457 | "2 Pentagon 5 8\n", 458 | "4 Heptagon 7 8\n", 459 | "9 Dodecagon 12 9\n", 460 | "8 Hendecagon 11 10\n", 461 | "10 Tridecagon 13 10\n", 462 | "11 Tetradecagon 14 12\n", 463 | "1 Quadrilateral 4 13" 464 | ] 465 | }, 466 | "execution_count": 17, 467 | "metadata": {}, 468 | "output_type": "execute_result" 469 | } 470 | ], 471 | "source": [ 472 | "polygons_data_frame.sort_values('Length of Name')" 473 | ] 474 | }, 475 | { 476 | "cell_type": "markdown", 477 | "metadata": {}, 478 | "source": [ 479 | "# Comparing apply's performance to vectorizatopn " 480 | ] 481 | }, 482 | { 483 | "cell_type": "code", 484 | "execution_count": 18, 485 | "metadata": {}, 486 | "outputs": [], 487 | "source": [ 488 | "# s = pd.Series(['hello world' for i in range(100000)])" 489 | ] 490 | }, 491 | { 492 | "cell_type": "code", 493 | "execution_count": 19, 494 | "metadata": {}, 495 | "outputs": [], 496 | "source": [ 497 | "# %timeit -n100 s.str.len()" 498 | ] 499 | }, 500 | { 501 | "cell_type": "code", 502 | "execution_count": 20, 503 | "metadata": {}, 504 | "outputs": [], 505 | "source": [ 506 | "# %timeit -n100 s.apply(lambda x: len(x))" 507 | ] 508 | }, 509 | { 510 | "cell_type": "markdown", 511 | "metadata": {}, 512 | "source": [ 513 | "# Scatter Plots" 514 | ] 515 | }, 516 | { 517 | "cell_type": "code", 518 | "execution_count": 21, 519 | "metadata": {}, 520 | "outputs": [], 521 | "source": [ 522 | "import matplotlib.pyplot as plt" 523 | ] 524 | }, 525 | { 526 | "cell_type": "code", 527 | "execution_count": 22, 528 | "metadata": {}, 529 | "outputs": [ 530 | { 531 | "data": { 532 | "text/plain": [ 533 | "" 534 | ] 535 | }, 536 | "execution_count": 22, 537 | "metadata": {}, 538 | "output_type": "execute_result" 539 | }, 540 | { 541 | "data": { 542 | "image/png": "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\n", 543 | "text/plain": [ 544 | "
" 545 | ] 546 | }, 547 | "metadata": { 548 | "needs_background": "light" 549 | }, 550 | "output_type": "display_data" 551 | } 552 | ], 553 | "source": [ 554 | "polygons_data_frame.plot(\n", 555 | " title='Sides vs Length of Name',\n", 556 | " kind='scatter',\n", 557 | " x='Sides',\n", 558 | " y='Length of Name',\n", 559 | ")" 560 | ] 561 | }, 562 | { 563 | "cell_type": "code", 564 | "execution_count": 23, 565 | "metadata": {}, 566 | "outputs": [ 567 | { 568 | "name": "stderr", 569 | "output_type": "stream", 570 | "text": [ 571 | "/Users/tarek/anaconda3/envs/scikitbook/lib/python3.6/site-packages/ipykernel_launcher.py:11: UserWarning: Matplotlib is currently using module://ipykernel.pylab.backend_inline, which is a non-GUI backend, so cannot show the figure.\n", 572 | " # This is added back by InteractiveShellApp.init_path()\n" 573 | ] 574 | }, 575 | { 576 | "data": { 577 | "image/png": "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\n", 578 | "text/plain": [ 579 | "
" 580 | ] 581 | }, 582 | "metadata": { 583 | "needs_background": "light" 584 | }, 585 | "output_type": "display_data" 586 | } 587 | ], 588 | "source": [ 589 | "fig, ax = plt.subplots(figsize=(12, 6));\n", 590 | "\n", 591 | "polygons_data_frame.plot(\n", 592 | " title='Sides vs Length of Name',\n", 593 | " kind='scatter',\n", 594 | " x='Sides',\n", 595 | " y='Length of Name',\n", 596 | " ax=ax,\n", 597 | ")\n", 598 | "\n", 599 | "fig.show()" 600 | ] 601 | }, 602 | { 603 | "cell_type": "code", 604 | "execution_count": 24, 605 | "metadata": {}, 606 | "outputs": [ 607 | { 608 | "data": { 609 | "text/html": [ 610 | "
\n", 611 | "\n", 624 | "\n", 625 | " \n", 626 | " \n", 627 | " \n", 628 | " \n", 629 | " \n", 630 | " \n", 631 | " \n", 632 | " \n", 633 | " \n", 634 | " \n", 635 | " \n", 636 | " \n", 637 | " \n", 638 | " \n", 639 | " \n", 640 | " \n", 641 | " \n", 642 | " \n", 643 | " \n", 644 | " \n", 645 | " \n", 646 | " \n", 647 | " \n", 648 | " \n", 649 | " \n", 650 | " \n", 651 | " \n", 652 | " \n", 653 | "
NameSidesLength of Name
9Dodecagon129
8Hendecagon1110
2Pentagon58
\n", 654 | "
" 655 | ], 656 | "text/plain": [ 657 | " Name Sides Length of Name\n", 658 | "9 Dodecagon 12 9\n", 659 | "8 Hendecagon 11 10\n", 660 | "2 Pentagon 5 8" 661 | ] 662 | }, 663 | "execution_count": 24, 664 | "metadata": {}, 665 | "output_type": "execute_result" 666 | } 667 | ], 668 | "source": [ 669 | "polygons_data_frame.sample(n=3)" 670 | ] 671 | }, 672 | { 673 | "cell_type": "code", 674 | "execution_count": null, 675 | "metadata": {}, 676 | "outputs": [], 677 | "source": [] 678 | }, 679 | { 680 | "cell_type": "code", 681 | "execution_count": null, 682 | "metadata": {}, 683 | "outputs": [], 684 | "source": [] 685 | } 686 | ], 687 | "metadata": { 688 | "hide_input": false, 689 | "kernelspec": { 690 | "display_name": "Python 3", 691 | "language": "python", 692 | "name": "python3" 693 | }, 694 | "language_info": { 695 | "codemirror_mode": { 696 | "name": "ipython", 697 | "version": 3 698 | }, 699 | "file_extension": ".py", 700 | "mimetype": "text/x-python", 701 | "name": "python", 702 | "nbconvert_exporter": "python", 703 | "pygments_lexer": "ipython3", 704 | "version": "3.6.9" 705 | }, 706 | "toc": { 707 | "base_numbering": 1, 708 | "nav_menu": {}, 709 | "number_sections": true, 710 | "sideBar": true, 711 | "skip_h1_title": false, 712 | "title_cell": "Table of Contents", 713 | "title_sidebar": "Contents", 714 | "toc_cell": false, 715 | "toc_position": {}, 716 | "toc_section_display": true, 717 | "toc_window_display": false 718 | } 719 | }, 720 | "nbformat": 4, 721 | "nbformat_minor": 2 722 | } 723 | -------------------------------------------------------------------------------- /Chapter02/.keep: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/Hands-On-Machine-Learning-with-scikit-learn-and-Scientific-Python-Toolkits/2dc4f5164d75adfc298767f14f5aeafe45d0b385/Chapter02/.keep -------------------------------------------------------------------------------- /Chapter02/README.md: -------------------------------------------------------------------------------- 1 | # Chapter 2: Making Decisions with Trees 2 | 3 | This chapter will introduce you to our first supervised learning algorithm in this book - decision trees. This was picked to be introduced early on since it is a versatile and easy to understand algorithm. You will also see later on that it is used as the building block for numerous advanced algorithms, such as Random Forest and Gradient Boosted Trees. 4 | 5 | In each chapter you will learn about general machine learning and statistical concepts in parallel to the main topic of the chapter. Thus, you will get to know about data splitting, model evaluation and hyper-parameter tuning. 6 | 7 | By the end of this chapter, you will have a very good understanding of the following topics: 8 | 9 | - How do decision trees learn? 10 | - What are the best ways to split your data? 11 | - How to use cross-validation to get more reliable scores? 12 | - What are hyper-parameters and how to tune them? 13 | - Visualising the tree's decision boundaries. 14 | - Using decision trees for regression. 15 | 16 | 17 | -------------------------------------------------------------------------------- /Chapter02/regression.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Decision Trees: Regression" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": {}, 14 | "outputs": [], 15 | "source": [ 16 | "import numpy as np\n", 17 | "import pandas as pd" 18 | ] 19 | }, 20 | { 21 | "cell_type": "markdown", 22 | "metadata": {}, 23 | "source": [ 24 | "## Creating Height Dataset" 25 | ] 26 | }, 27 | { 28 | "cell_type": "code", 29 | "execution_count": 3, 30 | "metadata": {}, 31 | "outputs": [], 32 | "source": [ 33 | "import numpy as np\n", 34 | "import pandas as pd\n", 35 | "\n", 36 | "n = 200\n", 37 | "\n", 38 | "height_pop1_f = np.random.normal(loc=155, scale=4, size=n)\n", 39 | "height_pop1_m = np.random.normal(loc=175, scale=5, size=n)\n", 40 | "height_pop2_f = np.random.normal(loc=165, scale=15, size=n)\n", 41 | "height_pop2_m = np.random.normal(loc=185, scale=12, size=n)\n", 42 | "\n", 43 | "height_f = np.concatenate([height_pop1_f, height_pop2_f])\n", 44 | "height_m = np.concatenate([height_pop1_m, height_pop2_m])\n", 45 | "\n", 46 | "df_height = pd.DataFrame(\n", 47 | " {\n", 48 | " 'Gender': [1 for i in range(height_f.size)] + [2 for i in range(height_m.size)],\n", 49 | " 'Height': np.concatenate((height_f, height_m))\n", 50 | " }\n", 51 | ")\n", 52 | "\n", 53 | "# df_height['Gender (text)'] = df_height['Gender'].apply(lambda g: {1: 'F', 2: 'M'}.get(g, 'N/A'))" 54 | ] 55 | }, 56 | { 57 | "cell_type": "code", 58 | "execution_count": 4, 59 | "metadata": {}, 60 | "outputs": [ 61 | { 62 | "data": { 63 | "text/html": [ 64 | "
\n", 65 | "\n", 78 | "\n", 79 | " \n", 80 | " \n", 81 | " \n", 82 | " \n", 83 | " \n", 84 | " \n", 85 | " \n", 86 | " \n", 87 | " \n", 88 | " \n", 89 | " \n", 90 | " \n", 91 | " \n", 92 | " \n", 93 | " \n", 94 | " \n", 95 | " \n", 96 | " \n", 97 | " \n", 98 | " \n", 99 | " \n", 100 | " \n", 101 | " \n", 102 | " \n", 103 | "
GenderHeight
2521195.379347
7162181.509895
1341163.911061
\n", 104 | "
" 105 | ], 106 | "text/plain": [ 107 | " Gender Height\n", 108 | "252 1 195.379347\n", 109 | "716 2 181.509895\n", 110 | "134 1 163.911061" 111 | ] 112 | }, 113 | "execution_count": 4, 114 | "metadata": {}, 115 | "output_type": "execute_result" 116 | } 117 | ], 118 | "source": [ 119 | "df_height.sample(3)" 120 | ] 121 | }, 122 | { 123 | "cell_type": "code", 124 | "execution_count": 5, 125 | "metadata": {}, 126 | "outputs": [ 127 | { 128 | "name": "stderr", 129 | "output_type": "stream", 130 | "text": [ 131 | "/Users/tarek/anaconda3/envs/scikitbook/lib/python3.6/site-packages/ipykernel_launcher.py:17: UserWarning: Matplotlib is currently using module://ipykernel.pylab.backend_inline, which is a non-GUI backend, so cannot show the figure.\n" 132 | ] 133 | }, 134 | { 135 | "data": { 136 | "image/png": "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\n", 137 | "text/plain": [ 138 | "
" 139 | ] 140 | }, 141 | "metadata": { 142 | "needs_background": "light" 143 | }, 144 | "output_type": "display_data" 145 | } 146 | ], 147 | "source": [ 148 | "fig, ax = plt.subplots(1, 1, figsize=(10, 5))\n", 149 | "\n", 150 | "df_height[df_height['Gender'] == 1]['Height'].plot(\n", 151 | " label='Female', kind='hist', \n", 152 | " bins=10, alpha=0.7, ax=ax\n", 153 | ")\n", 154 | "df_height[df_height['Gender'] == 2]['Height'].plot(\n", 155 | " label='Male', kind='hist', \n", 156 | " bins=10, alpha=0.7, ax=ax\n", 157 | ")\n", 158 | "\n", 159 | "# ax.set_xlim(140, 200)\n", 160 | "ax.legend()\n", 161 | "ax.set_title('Height Distribution')\n", 162 | "ax.set_xlabel('Height (in centimeters)')\n", 163 | "\n", 164 | "fig.show()" 165 | ] 166 | }, 167 | { 168 | "cell_type": "code", 169 | "execution_count": 6, 170 | "metadata": {}, 171 | "outputs": [ 172 | { 173 | "data": { 174 | "text/html": [ 175 | "
\n", 176 | "\n", 193 | "\n", 194 | " \n", 195 | " \n", 196 | " \n", 197 | " \n", 198 | " \n", 199 | " \n", 200 | " \n", 201 | " \n", 202 | " \n", 203 | " \n", 204 | " \n", 205 | " \n", 206 | " \n", 207 | " \n", 208 | " \n", 209 | " \n", 210 | " \n", 211 | " \n", 212 | " \n", 213 | " \n", 214 | " \n", 215 | " \n", 216 | " \n", 217 | " \n", 218 | " \n", 219 | " \n", 220 | " \n", 221 | " \n", 222 | "
Height
meanmedian
Gender
1160.9157.0
2179.4177.3
\n", 223 | "
" 224 | ], 225 | "text/plain": [ 226 | " Height \n", 227 | " mean median\n", 228 | "Gender \n", 229 | "1 160.9 157.0\n", 230 | "2 179.4 177.3" 231 | ] 232 | }, 233 | "execution_count": 6, 234 | "metadata": {}, 235 | "output_type": "execute_result" 236 | } 237 | ], 238 | "source": [ 239 | "# df_height['Gender (text)'] = df_height['Gender'].apply(lambda g: {1: 'F', 2: 'M'}.get(g, 'N/A'))\n", 240 | "\n", 241 | "df_height.groupby('Gender')[['Height']].agg([np.mean, np.median]).round(1)" 242 | ] 243 | }, 244 | { 245 | "cell_type": "markdown", 246 | "metadata": {}, 247 | "source": [ 248 | "## Splitting Data then applying the Regressor" 249 | ] 250 | }, 251 | { 252 | "cell_type": "code", 253 | "execution_count": 7, 254 | "metadata": {}, 255 | "outputs": [ 256 | { 257 | "data": { 258 | "text/plain": [ 259 | "DecisionTreeRegressor(ccp_alpha=0.0, criterion='mse', max_depth=None,\n", 260 | " max_features=None, max_leaf_nodes=None,\n", 261 | " min_impurity_decrease=0.0, min_impurity_split=None,\n", 262 | " min_samples_leaf=1, min_samples_split=2,\n", 263 | " min_weight_fraction_leaf=0.0, presort='deprecated',\n", 264 | " random_state=None, splitter='best')" 265 | ] 266 | }, 267 | "execution_count": 7, 268 | "metadata": {}, 269 | "output_type": "execute_result" 270 | } 271 | ], 272 | "source": [ 273 | "from sklearn.model_selection import train_test_split\n", 274 | "\n", 275 | "df_train, df_test = train_test_split(df_height, test_size=0.3, random_state=22)\n", 276 | "\n", 277 | "x_train = df_train[['Gender']]\n", 278 | "x_test = df_test[['Gender']]\n", 279 | "\n", 280 | "y_train = df_train['Height']\n", 281 | "y_test = df_test['Height']\n", 282 | "\n", 283 | "from sklearn.tree import DecisionTreeRegressor\n", 284 | "\n", 285 | "clf = DecisionTreeRegressor()\n", 286 | "\n", 287 | "clf.fit(x_train, y_train)\n", 288 | "\n" 289 | ] 290 | }, 291 | { 292 | "cell_type": "code", 293 | "execution_count": 8, 294 | "metadata": {}, 295 | "outputs": [ 296 | { 297 | "name": "stdout", 298 | "output_type": "stream", 299 | "text": [ 300 | "\n", 301 | "criterion=mse:\n", 302 | "\n", 303 | "|--- Gender <= 1.5\n", 304 | "| |--- value: [160.8]\n", 305 | "|--- Gender > 1.5\n", 306 | "| |--- value: [179.7]\n", 307 | "\n", 308 | "MSE: 131.8\n", 309 | "MAE: 8.8\n", 310 | "\n", 311 | "criterion=mae:\n", 312 | "\n", 313 | "|--- Gender <= 1.5\n", 314 | "| |--- value: [157.2]\n", 315 | "|--- Gender > 1.5\n", 316 | "| |--- value: [177.7]\n", 317 | "\n", 318 | "MSE: 140.3\n", 319 | "MAE: 8.1\n" 320 | ] 321 | } 322 | ], 323 | "source": [ 324 | "from sklearn.tree import export_text\n", 325 | "from sklearn.metrics import mean_squared_error, mean_absolute_error\n", 326 | "\n", 327 | "\n", 328 | "for criterion in ['mse', 'mae']:\n", 329 | " rgrsr = DecisionTreeRegressor(criterion=criterion)\n", 330 | " rgrsr.fit(x_train, y_train)\n", 331 | "\n", 332 | " print(f'\\ncriterion={criterion}:\\n')\n", 333 | " print(export_text(rgrsr, feature_names=['Gender'], spacing=3, decimals=1))\n", 334 | " \n", 335 | " y_test_pred = rgrsr.predict(x_test)\n", 336 | " \n", 337 | " print('MSE:', round(mean_squared_error(y_test, y_test_pred), 1))\n", 338 | " print('MAE:', round(mean_absolute_error(y_test, y_test_pred), 1))" 339 | ] 340 | }, 341 | { 342 | "cell_type": "code", 343 | "execution_count": 9, 344 | "metadata": {}, 345 | "outputs": [ 346 | { 347 | "data": { 348 | "text/plain": [ 349 | "230 189.715860\n", 350 | "140 149.980960\n", 351 | "172 150.570729\n", 352 | "782 193.298542\n", 353 | "406 172.337001\n", 354 | " ... \n", 355 | "491 172.981764\n", 356 | "502 180.858260\n", 357 | "358 167.625938\n", 358 | "356 157.478166\n", 359 | "132 154.342254\n", 360 | "Name: Height, Length: 560, dtype: float64" 361 | ] 362 | }, 363 | "execution_count": 9, 364 | "metadata": {}, 365 | "output_type": "execute_result" 366 | } 367 | ], 368 | "source": [ 369 | "y_train" 370 | ] 371 | }, 372 | { 373 | "cell_type": "code", 374 | "execution_count": 10, 375 | "metadata": {}, 376 | "outputs": [ 377 | { 378 | "name": "stdout", 379 | "output_type": "stream", 380 | "text": [ 381 | "\n", 382 | "Emphasis on below 150:\n", 383 | "\n", 384 | "|--- Gender <= 1.5\n", 385 | "| |--- value: [152.7]\n", 386 | "|--- Gender > 1.5\n", 387 | "| |--- value: [179.7]\n", 388 | "\n", 389 | "MSE: 170.5\n", 390 | "MAE: 9.0\n", 391 | "\n", 392 | "Emphasis on above 150:\n", 393 | "\n", 394 | "|--- Gender <= 1.5\n", 395 | "| |--- value: [162.6]\n", 396 | "|--- Gender > 1.5\n", 397 | "| |--- value: [179.7]\n", 398 | "\n", 399 | "MSE: 132.7\n", 400 | "MAE: 9.1\n" 401 | ] 402 | } 403 | ], 404 | "source": [ 405 | "from sklearn.tree import export_text\n", 406 | "from sklearn.metrics import mean_squared_error, mean_absolute_error\n", 407 | "\n", 408 | "\n", 409 | "for who_gets_more_weight in ['below 150', 'above 150']:\n", 410 | " rgrsr = DecisionTreeRegressor(criterion='mse')\n", 411 | " if who_gets_more_weight == 'below 150':\n", 412 | " sample_weight = y_train.apply(lambda h: 10 if h <= 150 else 1)\n", 413 | " else:\n", 414 | " sample_weight = y_train.apply(lambda h: 10 if h > 150 else 1)\n", 415 | " rgrsr.fit(x_train, y_train, sample_weight=sample_weight)\n", 416 | "\n", 417 | " print(f'\\nEmphasis on {who_gets_more_weight}:\\n')\n", 418 | " print(export_text(rgrsr, feature_names=['Gender'], spacing=3, decimals=1))\n", 419 | " \n", 420 | " y_test_pred = rgrsr.predict(x_test)\n", 421 | " \n", 422 | " print('MSE:', round(mean_squared_error(y_test, y_test_pred), 1))\n", 423 | " print('MAE:', round(mean_absolute_error(y_test, y_test_pred), 1))" 424 | ] 425 | }, 426 | { 427 | "cell_type": "code", 428 | "execution_count": null, 429 | "metadata": {}, 430 | "outputs": [], 431 | "source": [] 432 | } 433 | ], 434 | "metadata": { 435 | "kernelspec": { 436 | "display_name": "Python 3", 437 | "language": "python", 438 | "name": "python3" 439 | }, 440 | "language_info": { 441 | "codemirror_mode": { 442 | "name": "ipython", 443 | "version": 3 444 | }, 445 | "file_extension": ".py", 446 | "mimetype": "text/x-python", 447 | "name": "python", 448 | "nbconvert_exporter": "python", 449 | "pygments_lexer": "ipython3", 450 | "version": "3.6.9" 451 | } 452 | }, 453 | "nbformat": 4, 454 | "nbformat_minor": 2 455 | } 456 | -------------------------------------------------------------------------------- /Chapter03/.keep: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/Hands-On-Machine-Learning-with-scikit-learn-and-Scientific-Python-Toolkits/2dc4f5164d75adfc298767f14f5aeafe45d0b385/Chapter03/.keep -------------------------------------------------------------------------------- /Chapter03/README.md: -------------------------------------------------------------------------------- 1 | # Chapter 3: Making Decisions with Linear Equations 2 | 3 | The linear models are possibly the most commonly used algorithms in statistics and machine learning. They are used for both regression and classification. Thus, in this chapter we will start by looking into the basic least-squares algorithm, then will move on to more advanced algorithms as the chapter progresses. 4 | 5 | The secondary topics that you will get introduced to in parallel to the linear model are regularisation and regression intervals. Regularisation is a very powerful concept that you will meet over and over again throughout your machine learning journey. Thus, I decided to introduce it early on in the book. The concept of regression intervals is also a very useful tool to quantify your uncertaining about your productions. 6 | 7 | By the end of this chapter, you will have a very good understanding of the following topics: 8 | - Understanding linear models and their history 9 | - Learn about regression models evaluations criteria (MSE, MAE and R^2) 10 | - How to engineer new features and find their Importances (e.g. Polynomial features) 11 | - What is regularisation? What are solvers? 12 | - Using your first Generalised Linear Model, i.e. Logistic regression 13 | - Additional linear models (Stochastics Gradient Descent, Elastic-net, RANSAC, etc) 14 | - Finding regression intervals 15 | 16 | 17 | -------------------------------------------------------------------------------- /Chapter04/.keep: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/Hands-On-Machine-Learning-with-scikit-learn-and-Scientific-Python-Toolkits/2dc4f5164d75adfc298767f14f5aeafe45d0b385/Chapter04/.keep -------------------------------------------------------------------------------- /Chapter04/README.md: -------------------------------------------------------------------------------- 1 | # Preparing Your Data 2 | 3 | In real life, it will often be the case that the data is not as clean as you would like it to be. Sometimes, even clean data can still be preprocessed in ways to make things easier for our machine learning algorithm. 4 | 5 | -------------------------------------------------------------------------------- /Chapter04/category encoding.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Category Encoding" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 26, 13 | "metadata": {}, 14 | "outputs": [], 15 | "source": [ 16 | "# pip install category_encoders" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 27, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "import numpy as np\n", 26 | "import pandas as pd" 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": 28, 32 | "metadata": {}, 33 | "outputs": [], 34 | "source": [ 35 | "import category_encoders as ce" 36 | ] 37 | }, 38 | { 39 | "cell_type": "code", 40 | "execution_count": 29, 41 | "metadata": {}, 42 | "outputs": [], 43 | "source": [ 44 | "df = pd.DataFrame(\n", 45 | " {\n", 46 | " 'Size': np.random.choice(['XS', 'S', 'M', 'L', 'XL', 'XXL'], 10),\n", 47 | " 'Brand': np.random.choice(['Nike', 'Puma', 'Adidas', 'Le Coq', 'Reebok'], 10),\n", 48 | " }\n", 49 | ")" 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": 30, 55 | "metadata": {}, 56 | "outputs": [ 57 | { 58 | "data": { 59 | "text/html": [ 60 | "
\n", 61 | "\n", 74 | "\n", 75 | " \n", 76 | " \n", 77 | " \n", 78 | " \n", 79 | " \n", 80 | " \n", 81 | " \n", 82 | " \n", 83 | " \n", 84 | " \n", 85 | " \n", 86 | " \n", 87 | " \n", 88 | " \n", 89 | " \n", 90 | " \n", 91 | " \n", 92 | " \n", 93 | " \n", 94 | " \n", 95 | " \n", 96 | " \n", 97 | " \n", 98 | " \n", 99 | " \n", 100 | " \n", 101 | " \n", 102 | " \n", 103 | " \n", 104 | "
SizeBrand
5LPuma
7XSAdidas
3XLPuma
0LReebok
\n", 105 | "
" 106 | ], 107 | "text/plain": [ 108 | " Size Brand\n", 109 | "5 L Puma\n", 110 | "7 XS Adidas\n", 111 | "3 XL Puma\n", 112 | "0 L Reebok" 113 | ] 114 | }, 115 | "execution_count": 30, 116 | "metadata": {}, 117 | "output_type": "execute_result" 118 | } 119 | ], 120 | "source": [ 121 | "df.sample(n=4)" 122 | ] 123 | }, 124 | { 125 | "cell_type": "markdown", 126 | "metadata": {}, 127 | "source": [ 128 | "# Splitting the Dataset" 129 | ] 130 | }, 131 | { 132 | "cell_type": "code", 133 | "execution_count": 31, 134 | "metadata": {}, 135 | "outputs": [], 136 | "source": [ 137 | "from sklearn.model_selection import train_test_split\n", 138 | "df_train, df_test = train_test_split(df, test_size=0.5)" 139 | ] 140 | }, 141 | { 142 | "cell_type": "code", 143 | "execution_count": 32, 144 | "metadata": {}, 145 | "outputs": [ 146 | { 147 | "data": { 148 | "text/plain": [ 149 | "(['XS', 'S', 'XXL', 'L'], ['XL', 'XS', 'S', 'L'])" 150 | ] 151 | }, 152 | "execution_count": 32, 153 | "metadata": {}, 154 | "output_type": "execute_result" 155 | } 156 | ], 157 | "source": [ 158 | "df_train['Size'].value_counts().index.values.tolist(), df_test['Size'].value_counts().index.values.tolist(), " 159 | ] 160 | }, 161 | { 162 | "cell_type": "code", 163 | "execution_count": 33, 164 | "metadata": {}, 165 | "outputs": [ 166 | { 167 | "data": { 168 | "text/plain": [ 169 | "(['Puma', 'Nike', 'Adidas'], ['Adidas', 'Le Coq', 'Puma', 'Reebok'])" 170 | ] 171 | }, 172 | "execution_count": 33, 173 | "metadata": {}, 174 | "output_type": "execute_result" 175 | } 176 | ], 177 | "source": [ 178 | "df_train['Brand'].value_counts().index.values.tolist(), df_test['Brand'].value_counts().index.values.tolist(), " 179 | ] 180 | }, 181 | { 182 | "cell_type": "markdown", 183 | "metadata": {}, 184 | "source": [ 185 | "# One-Hot Encoding" 186 | ] 187 | }, 188 | { 189 | "cell_type": "code", 190 | "execution_count": 34, 191 | "metadata": {}, 192 | "outputs": [], 193 | "source": [ 194 | "from category_encoders.one_hot import OneHotEncoder\n", 195 | "encoder = OneHotEncoder(use_cat_names=True, handle_unknown='return_nan')\n", 196 | "x_train = encoder.fit_transform(df_train)\n", 197 | "x_test = encoder.transform(df_test)" 198 | ] 199 | }, 200 | { 201 | "cell_type": "code", 202 | "execution_count": 35, 203 | "metadata": {}, 204 | "outputs": [ 205 | { 206 | "data": { 207 | "text/html": [ 208 | "
\n", 209 | "\n", 222 | "\n", 223 | " \n", 224 | " \n", 225 | " \n", 226 | " \n", 227 | " \n", 228 | " \n", 229 | " \n", 230 | " \n", 231 | " \n", 232 | " \n", 233 | " \n", 234 | " \n", 235 | " \n", 236 | " \n", 237 | " \n", 238 | " \n", 239 | " \n", 240 | " \n", 241 | " \n", 242 | " \n", 243 | " \n", 244 | " \n", 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 | "
SizeBrand
8XXLAdidas
4XSNike
5LPuma
2XSNike
1SPuma
\n", 258 | "
" 259 | ], 260 | "text/plain": [ 261 | " Size Brand\n", 262 | "8 XXL Adidas\n", 263 | "4 XS Nike\n", 264 | "5 L Puma\n", 265 | "2 XS Nike\n", 266 | "1 S Puma" 267 | ] 268 | }, 269 | "execution_count": 35, 270 | "metadata": {}, 271 | "output_type": "execute_result" 272 | } 273 | ], 274 | "source": [ 275 | "df_train" 276 | ] 277 | }, 278 | { 279 | "cell_type": "code", 280 | "execution_count": 36, 281 | "metadata": {}, 282 | "outputs": [ 283 | { 284 | "data": { 285 | "text/html": [ 286 | "
\n", 287 | "\n", 300 | "\n", 301 | " \n", 302 | " \n", 303 | " \n", 304 | " \n", 305 | " \n", 306 | " \n", 307 | " \n", 308 | " \n", 309 | " \n", 310 | " \n", 311 | " \n", 312 | " \n", 313 | " \n", 314 | " \n", 315 | " \n", 316 | " \n", 317 | " \n", 318 | " \n", 319 | " \n", 320 | " \n", 321 | " \n", 322 | " \n", 323 | " \n", 324 | " \n", 325 | " \n", 326 | " \n", 327 | " \n", 328 | " \n", 329 | " \n", 330 | " \n", 331 | " \n", 332 | " \n", 333 | " \n", 334 | " \n", 335 | "
SizeBrand
6SLe Coq
9XLAdidas
3XLPuma
0LReebok
7XSAdidas
\n", 336 | "
" 337 | ], 338 | "text/plain": [ 339 | " Size Brand\n", 340 | "6 S Le Coq\n", 341 | "9 XL Adidas\n", 342 | "3 XL Puma\n", 343 | "0 L Reebok\n", 344 | "7 XS Adidas" 345 | ] 346 | }, 347 | "execution_count": 36, 348 | "metadata": {}, 349 | "output_type": "execute_result" 350 | } 351 | ], 352 | "source": [ 353 | "df_test" 354 | ] 355 | }, 356 | { 357 | "cell_type": "code", 358 | "execution_count": 37, 359 | "metadata": {}, 360 | "outputs": [ 361 | { 362 | "data": { 363 | "text/html": [ 364 | "
\n", 365 | "\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 | " \n", 399 | " \n", 400 | " \n", 401 | " \n", 402 | " \n", 403 | " \n", 404 | " \n", 405 | " \n", 406 | " \n", 407 | " \n", 408 | " \n", 409 | " \n", 410 | " \n", 411 | " \n", 412 | " \n", 413 | " \n", 414 | " \n", 415 | " \n", 416 | " \n", 417 | " \n", 418 | " \n", 419 | " \n", 420 | " \n", 421 | " \n", 422 | " \n", 423 | " \n", 424 | " \n", 425 | " \n", 426 | " \n", 427 | " \n", 428 | " \n", 429 | " \n", 430 | " \n", 431 | " \n", 432 | " \n", 433 | " \n", 434 | " \n", 435 | " \n", 436 | " \n", 437 | " \n", 438 | " \n", 439 | " \n", 440 | " \n", 441 | " \n", 442 | " \n", 443 | "
Size_XXLSize_XSSize_LSize_SBrand_AdidasBrand_NikeBrand_Puma
60.00.00.01.0NaNNaNNaN
9NaNNaNNaNNaN1.00.00.0
3NaNNaNNaNNaN0.00.01.0
00.00.01.00.0NaNNaNNaN
70.01.00.00.01.00.00.0
\n", 444 | "
" 445 | ], 446 | "text/plain": [ 447 | " Size_XXL Size_XS Size_L Size_S Brand_Adidas Brand_Nike Brand_Puma\n", 448 | "6 0.0 0.0 0.0 1.0 NaN NaN NaN\n", 449 | "9 NaN NaN NaN NaN 1.0 0.0 0.0\n", 450 | "3 NaN NaN NaN NaN 0.0 0.0 1.0\n", 451 | "0 0.0 0.0 1.0 0.0 NaN NaN NaN\n", 452 | "7 0.0 1.0 0.0 0.0 1.0 0.0 0.0" 453 | ] 454 | }, 455 | "execution_count": 37, 456 | "metadata": {}, 457 | "output_type": "execute_result" 458 | } 459 | ], 460 | "source": [ 461 | "x_test" 462 | ] 463 | }, 464 | { 465 | "cell_type": "markdown", 466 | "metadata": {}, 467 | "source": [ 468 | "Setting the unknown values to zero" 469 | ] 470 | }, 471 | { 472 | "cell_type": "code", 473 | "execution_count": 38, 474 | "metadata": {}, 475 | "outputs": [], 476 | "source": [ 477 | "encoder = ce.one_hot.OneHotEncoder(use_cat_names=True, handle_unknown='value')\n", 478 | "x_train = encoder.fit_transform(df_train)\n", 479 | "x_test = encoder.transform(df_test)" 480 | ] 481 | }, 482 | { 483 | "cell_type": "code", 484 | "execution_count": 39, 485 | "metadata": {}, 486 | "outputs": [ 487 | { 488 | "data": { 489 | "text/html": [ 490 | "
\n", 491 | "\n", 504 | "\n", 505 | " \n", 506 | " \n", 507 | " \n", 508 | " \n", 509 | " \n", 510 | " \n", 511 | " \n", 512 | " \n", 513 | " \n", 514 | " \n", 515 | " \n", 516 | " \n", 517 | " \n", 518 | " \n", 519 | " \n", 520 | " \n", 521 | " \n", 522 | " \n", 523 | " \n", 524 | " \n", 525 | " \n", 526 | " \n", 527 | " \n", 528 | " \n", 529 | " \n", 530 | " \n", 531 | " \n", 532 | " \n", 533 | " \n", 534 | " \n", 535 | " \n", 536 | " \n", 537 | " \n", 538 | " \n", 539 | " \n", 540 | " \n", 541 | " \n", 542 | " \n", 543 | " \n", 544 | " \n", 545 | " \n", 546 | " \n", 547 | " \n", 548 | " \n", 549 | "
Size_XXLSize_XSSize_LSize_SBrand_AdidasBrand_NikeBrand_Puma
00010000
70100100
60001000
\n", 550 | "
" 551 | ], 552 | "text/plain": [ 553 | " Size_XXL Size_XS Size_L Size_S Brand_Adidas Brand_Nike Brand_Puma\n", 554 | "0 0 0 1 0 0 0 0\n", 555 | "7 0 1 0 0 1 0 0\n", 556 | "6 0 0 0 1 0 0 0" 557 | ] 558 | }, 559 | "execution_count": 39, 560 | "metadata": {}, 561 | "output_type": "execute_result" 562 | } 563 | ], 564 | "source": [ 565 | "x_test.sample(n=3)" 566 | ] 567 | }, 568 | { 569 | "cell_type": "markdown", 570 | "metadata": {}, 571 | "source": [ 572 | "# Ordinal Encoder" 573 | ] 574 | }, 575 | { 576 | "cell_type": "code", 577 | "execution_count": 40, 578 | "metadata": {}, 579 | "outputs": [], 580 | "source": [ 581 | "df_size = df[['Size']].copy()\n", 582 | "df_size_train, df_size_test = train_test_split(df_size, test_size=0.5)\n", 583 | "\n", 584 | "from category_encoders.ordinal import OrdinalEncoder\n", 585 | "\n", 586 | "oencoder = OrdinalEncoder(\n", 587 | " mapping= [\n", 588 | " {\n", 589 | " 'col': 'Size', \n", 590 | " 'mapping': {'XS': 1, 'S': 2, 'M': 3, 'L': 4, 'XL': 5}\n", 591 | " }\n", 592 | " ]\n", 593 | ")\n", 594 | "\n", 595 | "df_train.loc[:, 'Size [Ordinal Encoded]'] = oencoder.fit_transform(df_train['Size'])['Size'].values\n", 596 | "df_test.loc[:, 'Size [Ordinal Encoded]'] = oencoder.transform(df_test['Size'])['Size'].values" 597 | ] 598 | }, 599 | { 600 | "cell_type": "code", 601 | "execution_count": 41, 602 | "metadata": {}, 603 | "outputs": [ 604 | { 605 | "data": { 606 | "text/html": [ 607 | "
\n", 608 | "\n", 621 | "\n", 622 | " \n", 623 | " \n", 624 | " \n", 625 | " \n", 626 | " \n", 627 | " \n", 628 | " \n", 629 | " \n", 630 | " \n", 631 | " \n", 632 | " \n", 633 | " \n", 634 | " \n", 635 | " \n", 636 | " \n", 637 | " \n", 638 | " \n", 639 | " \n", 640 | " \n", 641 | " \n", 642 | " \n", 643 | " \n", 644 | " \n", 645 | " \n", 646 | " \n", 647 | " \n", 648 | " \n", 649 | " \n", 650 | " \n", 651 | " \n", 652 | " \n", 653 | " \n", 654 | " \n", 655 | " \n", 656 | " \n", 657 | " \n", 658 | " \n", 659 | " \n", 660 | " \n", 661 | " \n", 662 | "
SizeBrandSize [Ordinal Encoded]
6SLe Coq2
9XLAdidas5
3XLPuma5
0LReebok4
7XSAdidas1
\n", 663 | "
" 664 | ], 665 | "text/plain": [ 666 | " Size Brand Size [Ordinal Encoded]\n", 667 | "6 S Le Coq 2\n", 668 | "9 XL Adidas 5\n", 669 | "3 XL Puma 5\n", 670 | "0 L Reebok 4\n", 671 | "7 XS Adidas 1" 672 | ] 673 | }, 674 | "execution_count": 41, 675 | "metadata": {}, 676 | "output_type": "execute_result" 677 | } 678 | ], 679 | "source": [ 680 | "df_test.head(5)" 681 | ] 682 | }, 683 | { 684 | "cell_type": "code", 685 | "execution_count": null, 686 | "metadata": {}, 687 | "outputs": [], 688 | "source": [] 689 | } 690 | ], 691 | "metadata": { 692 | "kernelspec": { 693 | "display_name": "Python 3", 694 | "language": "python", 695 | "name": "python3" 696 | }, 697 | "language_info": { 698 | "codemirror_mode": { 699 | "name": "ipython", 700 | "version": 3 701 | }, 702 | "file_extension": ".py", 703 | "mimetype": "text/x-python", 704 | "name": "python", 705 | "nbconvert_exporter": "python", 706 | "pygments_lexer": "ipython3", 707 | "version": "3.6.9" 708 | } 709 | }, 710 | "nbformat": 4, 711 | "nbformat_minor": 2 712 | } 713 | -------------------------------------------------------------------------------- /Chapter05/.keep: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/Hands-On-Machine-Learning-with-scikit-learn-and-Scientific-Python-Toolkits/2dc4f5164d75adfc298767f14f5aeafe45d0b385/Chapter05/.keep -------------------------------------------------------------------------------- /Chapter05/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/Hands-On-Machine-Learning-with-scikit-learn-and-Scientific-Python-Toolkits/2dc4f5164d75adfc298767f14f5aeafe45d0b385/Chapter05/README.md -------------------------------------------------------------------------------- /Chapter06/.keep: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/Hands-On-Machine-Learning-with-scikit-learn-and-Scientific-Python-Toolkits/2dc4f5164d75adfc298767f14f5aeafe45d0b385/Chapter06/.keep -------------------------------------------------------------------------------- /Chapter06/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/Hands-On-Machine-Learning-with-scikit-learn-and-Scientific-Python-Toolkits/2dc4f5164d75adfc298767f14f5aeafe45d0b385/Chapter06/README.md -------------------------------------------------------------------------------- /Chapter06/Tokenization.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Tokenization" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": {}, 14 | "outputs": [], 15 | "source": [ 16 | "lines = [\n", 17 | " 'How to tokenize?\\nLike a boss.',\n", 18 | " 'Google is accessible via http://www.google.com',\n", 19 | " '1000 new followers! #TwitterFamous',\n", 20 | "]" 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": 2, 26 | "metadata": {}, 27 | "outputs": [ 28 | { 29 | "data": { 30 | "text/plain": [ 31 | "['How to tokenize?\\nLike a boss.',\n", 32 | " 'Google is accessible via http://www.google.com',\n", 33 | " '1000 new followers! #TwitterFamous']" 34 | ] 35 | }, 36 | "execution_count": 2, 37 | "metadata": {}, 38 | "output_type": "execute_result" 39 | } 40 | ], 41 | "source": [ 42 | "lines" 43 | ] 44 | }, 45 | { 46 | "cell_type": "code", 47 | "execution_count": 3, 48 | "metadata": {}, 49 | "outputs": [ 50 | { 51 | "name": "stdout", 52 | "output_type": "stream", 53 | "text": [ 54 | "['How', 'to', 'tokenize?', 'Like', 'a', 'boss.']\n", 55 | "['Google', 'is', 'accessible', 'via', 'http://www.google.com']\n", 56 | "['1000', 'new', 'followers!', '#TwitterFamous']\n" 57 | ] 58 | } 59 | ], 60 | "source": [ 61 | "for line in lines:\n", 62 | " print(line.split())" 63 | ] 64 | }, 65 | { 66 | "cell_type": "code", 67 | "execution_count": 4, 68 | "metadata": {}, 69 | "outputs": [ 70 | { 71 | "name": "stdout", 72 | "output_type": "stream", 73 | "text": [ 74 | "['How', 'to', 'tokenize', 'Like', 'a', 'boss']\n", 75 | "['Google', 'is', 'accessible', 'via', 'http', 'www', 'google', 'com']\n", 76 | "['1000', 'new', 'followers', 'TwitterFamous']\n" 77 | ] 78 | } 79 | ], 80 | "source": [ 81 | "import re\n", 82 | "\n", 83 | "_token_pattern = r\"\\w+\"\n", 84 | "token_pattern = re.compile(_token_pattern)\n", 85 | " \n", 86 | "for line in lines:\n", 87 | " print(token_pattern.findall(line))" 88 | ] 89 | }, 90 | { 91 | "cell_type": "code", 92 | "execution_count": 5, 93 | "metadata": {}, 94 | "outputs": [ 95 | { 96 | "name": "stdout", 97 | "output_type": "stream", 98 | "text": [ 99 | "['how', 'to', 'tokenize', 'like', 'a', 'boss']\n", 100 | "['google', 'is', 'accessible', 'via', '_url_']\n", 101 | "['_num_', 'new', 'followers', '_hashtag_']\n" 102 | ] 103 | } 104 | ], 105 | "source": [ 106 | "_token_pattern = r\"\\w+\"\n", 107 | "token_pattern = re.compile(_token_pattern)\n", 108 | "\n", 109 | "def tokenizer(line):\n", 110 | " line = line.lower()\n", 111 | " line = re.sub(r'http[s]?://[\\w\\/\\-\\.\\?]+','_url_', line)\n", 112 | " line = re.sub(r'\\d+:\\d+','_time_', line)\n", 113 | " line = re.sub(r'#\\w+', '_hashtag_', line)\n", 114 | " line = re.sub(r'\\d+','_num_', line)\n", 115 | " return token_pattern.findall(line)\n", 116 | "\n", 117 | "for line in lines:\n", 118 | " print(tokenizer(line))" 119 | ] 120 | }, 121 | { 122 | "cell_type": "code", 123 | "execution_count": 6, 124 | "metadata": {}, 125 | "outputs": [ 126 | { 127 | "name": "stdout", 128 | "output_type": "stream", 129 | "text": [ 130 | "['How', 'to', 'tokenize', 'Like', 'boss']\n", 131 | "['Google', 'is', 'accessible', 'via', 'http', 'www', 'google', 'com']\n", 132 | "['1000', 'new', 'followers', 'TwitterFamous']\n" 133 | ] 134 | } 135 | ], 136 | "source": [ 137 | "import re\n", 138 | "\n", 139 | "_token_pattern = r\"(?u)\\b\\w\\w+\\b\"\n", 140 | "token_pattern = re.compile(_token_pattern)\n", 141 | " \n", 142 | "for line in lines:\n", 143 | " print(token_pattern.findall(line))" 144 | ] 145 | }, 146 | { 147 | "cell_type": "code", 148 | "execution_count": 7, 149 | "metadata": {}, 150 | "outputs": [], 151 | "source": [ 152 | "from sklearn.feature_extraction.text import CountVectorizer\n", 153 | "\n", 154 | "vec = CountVectorizer(lowercase=True, tokenizer=tokenizer)\n", 155 | "\n", 156 | "x = vec.fit_transform(lines)" 157 | ] 158 | }, 159 | { 160 | "cell_type": "code", 161 | "execution_count": 8, 162 | "metadata": {}, 163 | "outputs": [ 164 | { 165 | "name": "stdout", 166 | "output_type": "stream", 167 | "text": [ 168 | "['how', 'to', 'tokenize', 'like', 'boss', 'google', 'is', 'accessible', 'via', '_url_', '_num_', 'new', 'followers', '_hashtag_']\n" 169 | ] 170 | } 171 | ], 172 | "source": [ 173 | "print(list(vec.vocabulary_.keys()))" 174 | ] 175 | }, 176 | { 177 | "cell_type": "code", 178 | "execution_count": 9, 179 | "metadata": {}, 180 | "outputs": [ 181 | { 182 | "data": { 183 | "text/html": [ 184 | "
\n", 185 | "\n", 198 | "\n", 199 | " \n", 200 | " \n", 201 | " \n", 202 | " \n", 203 | " \n", 204 | " \n", 205 | " \n", 206 | " \n", 207 | " \n", 208 | " \n", 209 | " \n", 210 | " \n", 211 | " \n", 212 | " \n", 213 | " \n", 214 | " \n", 215 | " \n", 216 | " \n", 217 | " \n", 218 | " \n", 219 | " \n", 220 | " \n", 221 | " \n", 222 | " \n", 223 | " \n", 224 | " \n", 225 | " \n", 226 | " \n", 227 | " \n", 228 | " \n", 229 | " \n", 230 | " \n", 231 | " \n", 232 | " \n", 233 | " \n", 234 | " \n", 235 | " \n", 236 | " \n", 237 | " \n", 238 | " \n", 239 | " \n", 240 | " \n", 241 | " \n", 242 | " \n", 243 | " \n", 244 | " \n", 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 | " \n", 280 | " \n", 281 | " \n", 282 | " \n", 283 | " \n", 284 | " \n", 285 | " \n", 286 | " \n", 287 | " \n", 288 | "
_hashtag__num__url_accessiblebossfollowersgooglehowislikenewtotokenizevia
doc-id
000001001010110
100110010100001
211000100001000
\n", 289 | "
" 290 | ], 291 | "text/plain": [ 292 | " _hashtag_ _num_ _url_ accessible boss followers google how is \\\n", 293 | "doc-id \n", 294 | "0 0 0 0 0 1 0 0 1 0 \n", 295 | "1 0 0 1 1 0 0 1 0 1 \n", 296 | "2 1 1 0 0 0 1 0 0 0 \n", 297 | "\n", 298 | " like new to tokenize via \n", 299 | "doc-id \n", 300 | "0 1 0 1 1 0 \n", 301 | "1 0 0 0 0 1 \n", 302 | "2 0 1 0 0 0 " 303 | ] 304 | }, 305 | "execution_count": 9, 306 | "metadata": {}, 307 | "output_type": "execute_result" 308 | } 309 | ], 310 | "source": [ 311 | "df = pd.DataFrame(\n", 312 | " x.todense(), \n", 313 | " columns=vec.get_feature_names(),\n", 314 | ")\n", 315 | "\n", 316 | "df.index.name = 'doc-id'\n", 317 | "\n", 318 | "df" 319 | ] 320 | }, 321 | { 322 | "cell_type": "code", 323 | "execution_count": 10, 324 | "metadata": {}, 325 | "outputs": [], 326 | "source": [ 327 | "flight_delayed_lines = [\n", 328 | " 'Flight was delayed, I am not happy',\n", 329 | " 'Flight was not delayed, I am happy'\n", 330 | "]" 331 | ] 332 | }, 333 | { 334 | "cell_type": "code", 335 | "execution_count": 11, 336 | "metadata": {}, 337 | "outputs": [ 338 | { 339 | "data": { 340 | "text/html": [ 341 | "
\n", 342 | "\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 | "
amdelayedflighthappynotwas
doc-id
0111111
1111111
\n", 397 | "
" 398 | ], 399 | "text/plain": [ 400 | " am delayed flight happy not was\n", 401 | "doc-id \n", 402 | "0 1 1 1 1 1 1\n", 403 | "1 1 1 1 1 1 1" 404 | ] 405 | }, 406 | "execution_count": 11, 407 | "metadata": {}, 408 | "output_type": "execute_result" 409 | } 410 | ], 411 | "source": [ 412 | "from sklearn.feature_extraction.text import CountVectorizer\n", 413 | "\n", 414 | "vec = CountVectorizer(ngram_range=(1,1))\n", 415 | "\n", 416 | "x = vec.fit_transform(flight_delayed_lines)\n", 417 | "\n", 418 | "df = pd.DataFrame(\n", 419 | " x.todense(), \n", 420 | " columns=vec.get_feature_names(),\n", 421 | ")\n", 422 | "\n", 423 | "df.index.name = 'doc-id'\n", 424 | "\n", 425 | "df" 426 | ] 427 | }, 428 | { 429 | "cell_type": "code", 430 | "execution_count": 12, 431 | "metadata": {}, 432 | "outputs": [ 433 | { 434 | "data": { 435 | "text/html": [ 436 | "
\n", 437 | "\n", 450 | "\n", 451 | " \n", 452 | " \n", 453 | " \n", 454 | " \n", 455 | " \n", 456 | " \n", 457 | " \n", 458 | " \n", 459 | " \n", 460 | " \n", 461 | " \n", 462 | " \n", 463 | " \n", 464 | " \n", 465 | " \n", 466 | " \n", 467 | " \n", 468 | " \n", 469 | " \n", 470 | " \n", 471 | " \n", 472 | " \n", 473 | " \n", 474 | " \n", 475 | " \n", 476 | " \n", 477 | " \n", 478 | " \n", 479 | " \n", 480 | " \n", 481 | " \n", 482 | " \n", 483 | " \n", 484 | " \n", 485 | " \n", 486 | " \n", 487 | " \n", 488 | " \n", 489 | " \n", 490 | " \n", 491 | " \n", 492 | " \n", 493 | " \n", 494 | " \n", 495 | " \n", 496 | " \n", 497 | " \n", 498 | " \n", 499 | "
am happyam notdelayed amflight wasnot delayednot happywas delayedwas not
doc-id
001110110
110111001
\n", 500 | "
" 501 | ], 502 | "text/plain": [ 503 | " am happy am not delayed am flight was not delayed not happy \\\n", 504 | "doc-id \n", 505 | "0 0 1 1 1 0 1 \n", 506 | "1 1 0 1 1 1 0 \n", 507 | "\n", 508 | " was delayed was not \n", 509 | "doc-id \n", 510 | "0 1 0 \n", 511 | "1 0 1 " 512 | ] 513 | }, 514 | "execution_count": 12, 515 | "metadata": {}, 516 | "output_type": "execute_result" 517 | } 518 | ], 519 | "source": [ 520 | "from sklearn.feature_extraction.text import CountVectorizer\n", 521 | "\n", 522 | "vec = CountVectorizer(ngram_range=(2,2))\n", 523 | "\n", 524 | "x = vec.fit_transform(flight_delayed_lines)\n", 525 | "\n", 526 | "df = pd.DataFrame(\n", 527 | " x.todense(), \n", 528 | " columns=vec.get_feature_names(),\n", 529 | ")\n", 530 | "\n", 531 | "df.index.name = 'doc-id'\n", 532 | "\n", 533 | "df" 534 | ] 535 | }, 536 | { 537 | "cell_type": "code", 538 | "execution_count": 13, 539 | "metadata": {}, 540 | "outputs": [ 541 | { 542 | "data": { 543 | "text/html": [ 544 | "
\n", 545 | "\n", 558 | "\n", 559 | " \n", 560 | " \n", 561 | " \n", 562 | " \n", 563 | " \n", 564 | " \n", 565 | " \n", 566 | " \n", 567 | " \n", 568 | " \n", 569 | " \n", 570 | " \n", 571 | " \n", 572 | " \n", 573 | " \n", 574 | " \n", 575 | " \n", 576 | " \n", 577 | " \n", 578 | " \n", 579 | " \n", 580 | " \n", 581 | " \n", 582 | " \n", 583 | " \n", 584 | " \n", 585 | " \n", 586 | " \n", 587 | " \n", 588 | " \n", 589 | " \n", 590 | " \n", 591 | " \n", 592 | " \n", 593 | " \n", 594 | " \n", 595 | " \n", 596 | " \n", 597 | " \n", 598 | " \n", 599 | " \n", 600 | " \n", 601 | " \n", 602 | " \n", 603 | " \n", 604 | " \n", 605 | " \n", 606 | " \n", 607 | " \n", 608 | " \n", 609 | " \n", 610 | " \n", 611 | " \n", 612 | " \n", 613 | " \n", 614 | " \n", 615 | " \n", 616 | " \n", 617 | " \n", 618 | " \n", 619 | " \n", 620 | " \n", 621 | " \n", 622 | " \n", 623 | " \n", 624 | " \n", 625 | " \n", 626 | " \n", 627 | " \n", 628 | " \n", 629 | " \n", 630 | " \n", 631 | " \n", 632 | " \n", 633 | " \n", 634 | " \n", 635 | " \n", 636 | " \n", 637 | " \n", 638 | " \n", 639 | " \n", 640 | " \n", 641 | " \n", 642 | " \n", 643 | " \n", 644 | " \n", 645 | " \n", 646 | " \n", 647 | " \n", 648 | " \n", 649 | " \n", 650 | " \n", 651 | " \n", 652 | " \n", 653 | " \n", 654 | " \n", 655 | " \n", 656 | " \n", 657 | " \n", 658 | " \n", 659 | "
amdelhapi anotwas, iam ham nappy...notot dot hs des not det hat wawasyed,
doc-id
01111111011...1011001111
11111111101...1100110111
\n", 660 | "

2 rows × 37 columns

\n", 661 | "
" 662 | ], 663 | "text/plain": [ 664 | " am del hap i a not was , i am h am n appy ... not \\\n", 665 | "doc-id ... \n", 666 | "0 1 1 1 1 1 1 1 0 1 1 ... 1 \n", 667 | "1 1 1 1 1 1 1 1 1 0 1 ... 1 \n", 668 | "\n", 669 | " ot d ot h s de s no t de t ha t wa was yed, \n", 670 | "doc-id \n", 671 | "0 0 1 1 0 0 1 1 1 1 \n", 672 | "1 1 0 0 1 1 0 1 1 1 \n", 673 | "\n", 674 | "[2 rows x 37 columns]" 675 | ] 676 | }, 677 | "execution_count": 13, 678 | "metadata": {}, 679 | "output_type": "execute_result" 680 | } 681 | ], 682 | "source": [ 683 | "from sklearn.feature_extraction.text import CountVectorizer\n", 684 | "\n", 685 | "vec = CountVectorizer(analyzer='char', ngram_range=(4,4))\n", 686 | "\n", 687 | "x = vec.fit_transform(flight_delayed_lines)\n", 688 | "\n", 689 | "df = pd.DataFrame(\n", 690 | " x.todense(), \n", 691 | " columns=vec.get_feature_names(),\n", 692 | ")\n", 693 | "\n", 694 | "df.index.name = 'doc-id'\n", 695 | "\n", 696 | "df" 697 | ] 698 | }, 699 | { 700 | "cell_type": "code", 701 | "execution_count": 14, 702 | "metadata": {}, 703 | "outputs": [], 704 | "source": [ 705 | "lines_fruits = [\n", 706 | " 'I like apples',\n", 707 | " 'I like oranges',\n", 708 | " 'I like pears',\n", 709 | "]" 710 | ] 711 | }, 712 | { 713 | "cell_type": "code", 714 | "execution_count": 15, 715 | "metadata": {}, 716 | "outputs": [], 717 | "source": [ 718 | "from IPython.display import display_html\n", 719 | "\n", 720 | "def display_side_by_side(*args):\n", 721 | " \n", 722 | " html_str=''\n", 723 | " \n", 724 | " for df in args:\n", 725 | " html_str += df.to_html()\n", 726 | " html_str += ''.join([' ' for i in range(20)])\n", 727 | " \n", 728 | " html_str = html_str.replace('table','table style=\"display:inline;\"')\n", 729 | " \n", 730 | " display_html(html_str, raw=True)" 731 | ] 732 | }, 733 | { 734 | "cell_type": "code", 735 | "execution_count": 16, 736 | "metadata": { 737 | "scrolled": false 738 | }, 739 | "outputs": [ 740 | { 741 | "data": { 742 | "text/html": [ 743 | "\n", 744 | " \n", 745 | " \n", 746 | " \n", 747 | " \n", 748 | " \n", 749 | " \n", 750 | " \n", 751 | " \n", 752 | " \n", 753 | " \n", 754 | " \n", 755 | " \n", 756 | " \n", 757 | " \n", 758 | " \n", 759 | " \n", 760 | " \n", 761 | " \n", 762 | " \n", 763 | " \n", 764 | " \n", 765 | " \n", 766 | " \n", 767 | " \n", 768 | " \n", 769 | " \n", 770 | " \n", 771 | " \n", 772 | " \n", 773 | " \n", 774 | " \n", 775 | " \n", 776 | " \n", 777 | " \n", 778 | " \n", 779 | " \n", 780 | " \n", 781 | " \n", 782 | " \n", 783 | " \n", 784 | " \n", 785 | " \n", 786 | " \n", 787 | " \n", 788 | "
applesilikeorangespears
CountVectorizer
01.01.01.00.00.0
10.01.01.01.00.0
20.01.01.00.01.0
                    \n", 789 | " \n", 790 | " \n", 791 | " \n", 792 | " \n", 793 | " \n", 794 | " \n", 795 | " \n", 796 | " \n", 797 | " \n", 798 | " \n", 799 | " \n", 800 | " \n", 801 | " \n", 802 | " \n", 803 | " \n", 804 | " \n", 805 | " \n", 806 | " \n", 807 | " \n", 808 | " \n", 809 | " \n", 810 | " \n", 811 | " \n", 812 | " \n", 813 | " \n", 814 | " \n", 815 | " \n", 816 | " \n", 817 | " \n", 818 | " \n", 819 | " \n", 820 | " \n", 821 | " \n", 822 | " \n", 823 | " \n", 824 | " \n", 825 | " \n", 826 | " \n", 827 | " \n", 828 | " \n", 829 | " \n", 830 | " \n", 831 | " \n", 832 | " \n", 833 | "
applesilikeorangespears
TfidfVectorizer
00.770.450.450.000.00
10.000.450.450.770.00
20.000.450.450.000.77
                    " 834 | ] 835 | }, 836 | "metadata": {}, 837 | "output_type": "display_data" 838 | } 839 | ], 840 | "source": [ 841 | "from sklearn.feature_extraction.text import CountVectorizer\n", 842 | "\n", 843 | "vec = CountVectorizer(token_pattern=r'\\w+')\n", 844 | "\n", 845 | "x = vec.fit_transform(lines_fruits)\n", 846 | "\n", 847 | "df1 = pd.DataFrame(\n", 848 | " x.todense().astype(float).round(2), \n", 849 | " columns=vec.get_feature_names(),\n", 850 | ")\n", 851 | "\n", 852 | "df1.index.name = 'CountVectorizer'\n", 853 | "\n", 854 | "from sklearn.feature_extraction.text import TfidfVectorizer\n", 855 | "\n", 856 | "vec = TfidfVectorizer(token_pattern=r'\\w+')\n", 857 | "\n", 858 | "x = vec.fit_transform(lines_fruits)\n", 859 | "\n", 860 | "df2 = pd.DataFrame(\n", 861 | " x.todense().round(2), \n", 862 | " columns=vec.get_feature_names(),\n", 863 | ")\n", 864 | "\n", 865 | "df2.index.name = 'TfidfVectorizer'\n", 866 | "\n", 867 | "\n", 868 | "display_side_by_side(df1, df2)" 869 | ] 870 | }, 871 | { 872 | "cell_type": "code", 873 | "execution_count": 17, 874 | "metadata": {}, 875 | "outputs": [ 876 | { 877 | "data": { 878 | "text/html": [ 879 | "
\n", 880 | "\n", 893 | "\n", 894 | " \n", 895 | " \n", 896 | " \n", 897 | " \n", 898 | " \n", 899 | " \n", 900 | " \n", 901 | " \n", 902 | " \n", 903 | " \n", 904 | " \n", 905 | " \n", 906 | " \n", 907 | " \n", 908 | " \n", 909 | " \n", 910 | " \n", 911 | " \n", 912 | " \n", 913 | " \n", 914 | " \n", 915 | " \n", 916 | " \n", 917 | " \n", 918 | " \n", 919 | " \n", 920 | " \n", 921 | " \n", 922 | " \n", 923 | " \n", 924 | " \n", 925 | " \n", 926 | " \n", 927 | " \n", 928 | " \n", 929 | " \n", 930 | "
applesilikeorangespears
CountVectorizer
01.01.01.00.00.0
10.01.01.01.00.0
\n", 931 | "
" 932 | ], 933 | "text/plain": [ 934 | " apples i like oranges pears\n", 935 | "CountVectorizer \n", 936 | "0 1.0 1.0 1.0 0.0 0.0\n", 937 | "1 0.0 1.0 1.0 1.0 0.0" 938 | ] 939 | }, 940 | "execution_count": 17, 941 | "metadata": {}, 942 | "output_type": "execute_result" 943 | } 944 | ], 945 | "source": [ 946 | "from sklearn.feature_extraction.text import CountVectorizer\n", 947 | "\n", 948 | "vec = CountVectorizer(token_pattern=r'\\w+')\n", 949 | "\n", 950 | "x = vec.fit_transform(lines_fruits)\n", 951 | "\n", 952 | "df1 = pd.DataFrame(\n", 953 | " x.todense().astype(float).round(2), \n", 954 | " columns=vec.get_feature_names(),\n", 955 | ")\n", 956 | "\n", 957 | "df1.index.name = 'CountVectorizer'\n", 958 | "\n", 959 | "df1.head(2)" 960 | ] 961 | }, 962 | { 963 | "cell_type": "code", 964 | "execution_count": 18, 965 | "metadata": {}, 966 | "outputs": [ 967 | { 968 | "data": { 969 | "text/html": [ 970 | "
\n", 971 | "\n", 984 | "\n", 985 | " \n", 986 | " \n", 987 | " \n", 988 | " \n", 989 | " \n", 990 | " \n", 991 | " \n", 992 | " \n", 993 | " \n", 994 | " \n", 995 | " \n", 996 | " \n", 997 | " \n", 998 | " \n", 999 | " \n", 1000 | " \n", 1001 | " \n", 1002 | " \n", 1003 | " \n", 1004 | " \n", 1005 | " \n", 1006 | " \n", 1007 | " \n", 1008 | " \n", 1009 | " \n", 1010 | " \n", 1011 | " \n", 1012 | " \n", 1013 | " \n", 1014 | " \n", 1015 | " \n", 1016 | " \n", 1017 | " \n", 1018 | " \n", 1019 | " \n", 1020 | " \n", 1021 | " \n", 1022 | " \n", 1023 | " \n", 1024 | " \n", 1025 | " \n", 1026 | " \n", 1027 | " \n", 1028 | " \n", 1029 | "
applesilikeorangespears
doc-id
00.7674950.4532950.4532950.0000000.000000
10.0000000.4532950.4532950.7674950.000000
20.0000000.4532950.4532950.0000000.767495
\n", 1030 | "
" 1031 | ], 1032 | "text/plain": [ 1033 | " apples i like oranges pears\n", 1034 | "doc-id \n", 1035 | "0 0.767495 0.453295 0.453295 0.000000 0.000000\n", 1036 | "1 0.000000 0.453295 0.453295 0.767495 0.000000\n", 1037 | "2 0.000000 0.453295 0.453295 0.000000 0.767495" 1038 | ] 1039 | }, 1040 | "execution_count": 18, 1041 | "metadata": {}, 1042 | "output_type": "execute_result" 1043 | } 1044 | ], 1045 | "source": [ 1046 | "from sklearn.feature_extraction.text import TfidfVectorizer\n", 1047 | "\n", 1048 | "vec = TfidfVectorizer(token_pattern=r'\\w+')\n", 1049 | "\n", 1050 | "x = vec.fit_transform(lines_fruits)\n", 1051 | "\n", 1052 | "df = pd.DataFrame(\n", 1053 | " x.todense(), \n", 1054 | " columns=vec.get_feature_names(),\n", 1055 | ")\n", 1056 | "\n", 1057 | "df.index.name = 'doc-id'\n", 1058 | "\n", 1059 | "df" 1060 | ] 1061 | }, 1062 | { 1063 | "cell_type": "code", 1064 | "execution_count": 19, 1065 | "metadata": {}, 1066 | "outputs": [], 1067 | "source": [ 1068 | "import spacy\n", 1069 | "\n", 1070 | "nlp = spacy.load('en_core_web_md')\n", 1071 | "\n", 1072 | "\n", 1073 | "terms = ['I', 'like', 'apples', 'oranges', 'pears']\n", 1074 | "vectors = [\n", 1075 | " nlp(term).vector.tolist() for term in terms\n", 1076 | "]" 1077 | ] 1078 | }, 1079 | { 1080 | "cell_type": "code", 1081 | "execution_count": 20, 1082 | "metadata": {}, 1083 | "outputs": [ 1084 | { 1085 | "data": { 1086 | "text/plain": [ 1087 | "300" 1088 | ] 1089 | }, 1090 | "execution_count": 20, 1091 | "metadata": {}, 1092 | "output_type": "execute_result" 1093 | } 1094 | ], 1095 | "source": [ 1096 | "len(vectors[terms.index('apples')])" 1097 | ] 1098 | }, 1099 | { 1100 | "cell_type": "code", 1101 | "execution_count": 21, 1102 | "metadata": {}, 1103 | "outputs": [ 1104 | { 1105 | "data": { 1106 | "text/plain": [ 1107 | "0 -0.633400\n", 1108 | "1 0.189810\n", 1109 | "2 -0.535440\n", 1110 | "3 -0.526580\n", 1111 | "4 -0.300010\n", 1112 | " ... \n", 1113 | "295 0.068773\n", 1114 | "296 -0.238810\n", 1115 | "297 -1.178400\n", 1116 | "298 0.255040\n", 1117 | "299 0.611710\n", 1118 | "Name: apples, Length: 300, dtype: float64" 1119 | ] 1120 | }, 1121 | "execution_count": 21, 1122 | "metadata": {}, 1123 | "output_type": "execute_result" 1124 | } 1125 | ], 1126 | "source": [ 1127 | "pd.Series(vectors[terms.index('apples')]).rename('apples')" 1128 | ] 1129 | }, 1130 | { 1131 | "cell_type": "code", 1132 | "execution_count": 22, 1133 | "metadata": {}, 1134 | "outputs": [ 1135 | { 1136 | "data": { 1137 | "text/html": [ 1138 | "
\n", 1139 | "\n", 1152 | "\n", 1153 | " \n", 1154 | " \n", 1155 | " \n", 1156 | " \n", 1157 | " \n", 1158 | " \n", 1159 | " \n", 1160 | " \n", 1161 | " \n", 1162 | " \n", 1163 | " \n", 1164 | " \n", 1165 | " \n", 1166 | " \n", 1167 | " \n", 1168 | " \n", 1169 | " \n", 1170 | " \n", 1171 | " \n", 1172 | " \n", 1173 | " \n", 1174 | " \n", 1175 | " \n", 1176 | " \n", 1177 | " \n", 1178 | " \n", 1179 | " \n", 1180 | " \n", 1181 | " \n", 1182 | " \n", 1183 | " \n", 1184 | " \n", 1185 | " \n", 1186 | " \n", 1187 | " \n", 1188 | " \n", 1189 | " \n", 1190 | " \n", 1191 | " \n", 1192 | " \n", 1193 | " \n", 1194 | " \n", 1195 | " \n", 1196 | " \n", 1197 | " \n", 1198 | " \n", 1199 | " \n", 1200 | " \n", 1201 | " \n", 1202 | " \n", 1203 | " \n", 1204 | " \n", 1205 | "
Ilikeapplesorangespears
I0.0000000.4445090.7955730.8117590.795573
like0.4445090.0000000.6701290.7228250.670129
apples0.7955730.6701290.0000000.2219060.000000
oranges0.8117590.7228250.2219060.0000000.221906
pears0.7955730.6701290.0000000.2219060.000000
\n", 1206 | "
" 1207 | ], 1208 | "text/plain": [ 1209 | " I like apples oranges pears\n", 1210 | "I 0.000000 0.444509 0.795573 0.811759 0.795573\n", 1211 | "like 0.444509 0.000000 0.670129 0.722825 0.670129\n", 1212 | "apples 0.795573 0.670129 0.000000 0.221906 0.000000\n", 1213 | "oranges 0.811759 0.722825 0.221906 0.000000 0.221906\n", 1214 | "pears 0.795573 0.670129 0.000000 0.221906 0.000000" 1215 | ] 1216 | }, 1217 | "execution_count": 22, 1218 | "metadata": {}, 1219 | "output_type": "execute_result" 1220 | } 1221 | ], 1222 | "source": [ 1223 | "from sklearn.metrics.pairwise import cosine_similarity\n", 1224 | "from sklearn.metrics.pairwise import cosine_distances\n", 1225 | "\n", 1226 | "pd.DataFrame(\n", 1227 | " cosine_distances(vectors),\n", 1228 | " index=terms,\n", 1229 | " columns=terms,\n", 1230 | ")" 1231 | ] 1232 | }, 1233 | { 1234 | "cell_type": "code", 1235 | "execution_count": 23, 1236 | "metadata": {}, 1237 | "outputs": [ 1238 | { 1239 | "data": { 1240 | "text/html": [ 1241 | "\n", 1318 | " \n", 1319 | " \n", 1320 | " \n", 1321 | " \n", 1322 | " \n", 1323 | " \n", 1324 | " \n", 1325 | " \n", 1326 | " \n", 1327 | " \n", 1328 | " \n", 1329 | " \n", 1330 | " \n", 1331 | " \n", 1332 | " \n", 1333 | " \n", 1334 | " \n", 1335 | " \n", 1336 | " \n", 1337 | " \n", 1338 | " \n", 1339 | " \n", 1340 | " \n", 1341 | " \n", 1342 | " \n", 1343 | " \n", 1344 | " \n", 1345 | " \n", 1346 | " \n", 1347 | " \n", 1348 | " \n", 1349 | " \n", 1350 | " \n", 1351 | " \n", 1352 | " \n", 1353 | " \n", 1354 | " \n", 1355 | " \n", 1356 | " \n", 1357 | " \n", 1358 | "
I like apples oranges pears
I10.560.20.190.2
like0.5610.330.280.33
apples0.20.3310.781
oranges0.190.280.7810.78
pears0.20.3310.781
" 1359 | ], 1360 | "text/plain": [ 1361 | "" 1362 | ] 1363 | }, 1364 | "execution_count": 23, 1365 | "metadata": {}, 1366 | "output_type": "execute_result" 1367 | } 1368 | ], 1369 | "source": [ 1370 | "import seaborn as sns\n", 1371 | "from sklearn.metrics.pairwise import cosine_similarity\n", 1372 | "\n", 1373 | "cm = sns.light_palette(\"Gray\", as_cmap=True)\n", 1374 | "\n", 1375 | "pd.DataFrame(\n", 1376 | " cosine_similarity(vectors),\n", 1377 | " index=terms,\n", 1378 | " columns=terms,\n", 1379 | ").round(2).style.background_gradient(cmap=cm)" 1380 | ] 1381 | }, 1382 | { 1383 | "cell_type": "code", 1384 | "execution_count": null, 1385 | "metadata": {}, 1386 | "outputs": [], 1387 | "source": [] 1388 | }, 1389 | { 1390 | "cell_type": "code", 1391 | "execution_count": null, 1392 | "metadata": {}, 1393 | "outputs": [], 1394 | "source": [] 1395 | }, 1396 | { 1397 | "cell_type": "code", 1398 | "execution_count": null, 1399 | "metadata": {}, 1400 | "outputs": [], 1401 | "source": [] 1402 | } 1403 | ], 1404 | "metadata": { 1405 | "kernelspec": { 1406 | "display_name": "Python 3", 1407 | "language": "python", 1408 | "name": "python3" 1409 | }, 1410 | "language_info": { 1411 | "codemirror_mode": { 1412 | "name": "ipython", 1413 | "version": 3 1414 | }, 1415 | "file_extension": ".py", 1416 | "mimetype": "text/x-python", 1417 | "name": "python", 1418 | "nbconvert_exporter": "python", 1419 | "pygments_lexer": "ipython3", 1420 | "version": "3.6.9" 1421 | } 1422 | }, 1423 | "nbformat": 4, 1424 | "nbformat_minor": 2 1425 | } 1426 | -------------------------------------------------------------------------------- /Chapter07/.keep: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/Hands-On-Machine-Learning-with-scikit-learn-and-Scientific-Python-Toolkits/2dc4f5164d75adfc298767f14f5aeafe45d0b385/Chapter07/.keep -------------------------------------------------------------------------------- /Chapter07/README.md: -------------------------------------------------------------------------------- 1 | # Chapter 7: Neural Networks; Here Comes the Deep Learning 2 | 3 | The term deep learning refers to deep Artificial Neural Networks (ANNs). The latter concept comes in different forms and shapes. In this chapter, we are going to cover one subset of feedforward neural networks known as the Multilayer Perceptron (MLP). It is one of the most commonly used types and is implemented by scikit-learn. As its name suggests, it is composed of multiple layers, and it is a feedforward network as there are no cyclic connections between its layers. The more layers there are, the deeper the network is. These deep networks can exist in multiple forms, such as MLP, Convolutional Neural Networks (CNNs), or Long Short-Term Memory (LSTM). The latter two are not implemented by scikit-learn, yet this will not stop us from discussing the main concepts behind CNNs and manually mimicking them using the tools from the scientific Python ecosystem. 4 | 5 | In this chapter, we are going to cover the following topics: 6 | 7 | - Getting to know MLP 8 | - Classifying items of clothing 9 | - Untangling convolutions 10 | - MLP regressors 11 | -------------------------------------------------------------------------------- /Chapter08/.keep: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/Hands-On-Machine-Learning-with-scikit-learn-and-Scientific-Python-Toolkits/2dc4f5164d75adfc298767f14f5aeafe45d0b385/Chapter08/.keep -------------------------------------------------------------------------------- /Chapter09/.keep: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/Hands-On-Machine-Learning-with-scikit-learn-and-Scientific-Python-Toolkits/2dc4f5164d75adfc298767f14f5aeafe45d0b385/Chapter09/.keep -------------------------------------------------------------------------------- /Chapter09/Target Scaling.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Target Scaling" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 14, 13 | "metadata": {}, 14 | "outputs": [], 15 | "source": [ 16 | "x = np.random.uniform(low=5, high=20, size=100)\n", 17 | "e = np.random.normal(loc=0, scale=0.5, size=100)" 18 | ] 19 | }, 20 | { 21 | "cell_type": "code", 22 | "execution_count": 15, 23 | "metadata": {}, 24 | "outputs": [], 25 | "source": [ 26 | "y = (x + e) ** 3 " 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": 16, 32 | "metadata": {}, 33 | "outputs": [ 34 | { 35 | "name": "stderr", 36 | "output_type": "stream", 37 | "text": [ 38 | "/Users/tarek/anaconda3/envs/scikitbook/lib/python3.6/site-packages/ipykernel_launcher.py:10: UserWarning: Matplotlib is currently using module://ipykernel.pylab.backend_inline, which is a non-GUI backend, so cannot show the figure.\n", 39 | " # Remove the CWD from sys.path while we load stuff.\n" 40 | ] 41 | }, 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 | "fig, ax = plt.subplots(1, 1, figsize=(10, 8))\n", 57 | "\n", 58 | "pd.DataFrame({'x': x, 'y': y}).plot(\n", 59 | " title='Y is non-linear',\n", 60 | " kind='scatter',\n", 61 | " x='x', y='y', \n", 62 | " color='k', ax=ax\n", 63 | ")\n", 64 | "\n", 65 | "fig.show()" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": 17, 71 | "metadata": {}, 72 | "outputs": [], 73 | "source": [ 74 | "x = x.reshape((x.shape[0],1))" 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": 18, 80 | "metadata": {}, 81 | "outputs": [], 82 | "source": [ 83 | "from sklearn.model_selection import train_test_split\n", 84 | "\n", 85 | "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25)" 86 | ] 87 | }, 88 | { 89 | "cell_type": "code", 90 | "execution_count": 19, 91 | "metadata": {}, 92 | "outputs": [], 93 | "source": [ 94 | "from sklearn.linear_model import Ridge\n", 95 | "\n", 96 | "rgs = Ridge()\n", 97 | "rgs.fit(x_train, y_train)\n", 98 | "y_pred = rgs.predict(x_test)" 99 | ] 100 | }, 101 | { 102 | "cell_type": "code", 103 | "execution_count": 20, 104 | "metadata": {}, 105 | "outputs": [ 106 | { 107 | "name": "stdout", 108 | "output_type": "stream", 109 | "text": [ 110 | "MAE=704, R2=0.883232\n" 111 | ] 112 | } 113 | ], 114 | "source": [ 115 | "from sklearn.metrics import mean_absolute_error\n", 116 | "from sklearn.metrics import r2_score\n", 117 | "\n", 118 | "print(\n", 119 | " 'MAE={:.0f}, R2={:2f}'.format(\n", 120 | " mean_absolute_error(y_test, y_pred),\n", 121 | " r2_score(y_test, y_pred),\n", 122 | " )\n", 123 | ")" 124 | ] 125 | }, 126 | { 127 | "cell_type": "code", 128 | "execution_count": 21, 129 | "metadata": {}, 130 | "outputs": [], 131 | "source": [ 132 | "class YTransformer:\n", 133 | " \n", 134 | " def __init__(self, power=1):\n", 135 | " self.power = power\n", 136 | " \n", 137 | " def fit(self, x, y):\n", 138 | " pass\n", 139 | " \n", 140 | " def transform(self, x, y):\n", 141 | " return x, np.power(y, self.power)\n", 142 | " \n", 143 | " def inverse_transform(self, x, y):\n", 144 | " return x, np.power(y, 1/self.power)\n", 145 | " \n", 146 | " \n", 147 | " def fit_transform(self, x, y):\n", 148 | " return self.transform(x, y)" 149 | ] 150 | }, 151 | { 152 | "cell_type": "code", 153 | "execution_count": 22, 154 | "metadata": {}, 155 | "outputs": [ 156 | { 157 | "name": "stdout", 158 | "output_type": "stream", 159 | "text": [ 160 | "Trasfomed y^1.00: MAE=704, R2=0.88\n", 161 | "Trasfomed y^0.50: MAE=378, R2=0.96\n", 162 | "Trasfomed y^0.33: MAE=339, R2=0.96\n", 163 | "Trasfomed y^0.25: MAE=359, R2=0.95\n", 164 | "Trasfomed y^0.20: MAE=400, R2=0.93\n" 165 | ] 166 | } 167 | ], 168 | "source": [ 169 | "from sklearn.linear_model import Ridge\n", 170 | "from sklearn.metrics import mean_absolute_error\n", 171 | "from sklearn.metrics import r2_score\n", 172 | "\n", 173 | "for power in [1, 1/2, 1/3, 1/4, 1/5]:\n", 174 | "\n", 175 | " yt = YTransformer(power)\n", 176 | " _, y_train_t = yt.fit_transform(None, y_train)\n", 177 | " _, y_test_t = yt.transform(None, y_test)\n", 178 | " \n", 179 | " rgs = Ridge()\n", 180 | "\n", 181 | " rgs.fit(x_train, y_train_t)\n", 182 | " y_pred_t = rgs.predict(x_test)\n", 183 | " \n", 184 | " _, y_pred = yt.inverse_transform(None, y_pred_t)\n", 185 | "\n", 186 | " print(\n", 187 | " 'Trasfomed y^{:.2f}: MAE={:.0f}, R2={:.2f}'.format(\n", 188 | " power,\n", 189 | " mean_absolute_error(y_test, y_pred),\n", 190 | " r2_score(y_test, y_pred),\n", 191 | " )\n", 192 | " )" 193 | ] 194 | }, 195 | { 196 | "cell_type": "code", 197 | "execution_count": null, 198 | "metadata": {}, 199 | "outputs": [], 200 | "source": [] 201 | } 202 | ], 203 | "metadata": { 204 | "kernelspec": { 205 | "display_name": "Python 3", 206 | "language": "python", 207 | "name": "python3" 208 | }, 209 | "language_info": { 210 | "codemirror_mode": { 211 | "name": "ipython", 212 | "version": 3 213 | }, 214 | "file_extension": ".py", 215 | "mimetype": "text/x-python", 216 | "name": "python", 217 | "nbconvert_exporter": "python", 218 | "pygments_lexer": "ipython3", 219 | "version": "3.6.9" 220 | } 221 | }, 222 | "nbformat": 4, 223 | "nbformat_minor": 2 224 | } 225 | -------------------------------------------------------------------------------- /Chapter10/.keep: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/Hands-On-Machine-Learning-with-scikit-learn-and-Scientific-Python-Toolkits/2dc4f5164d75adfc298767f14f5aeafe45d0b385/Chapter10/.keep -------------------------------------------------------------------------------- /Chapter11/.keep: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/Hands-On-Machine-Learning-with-scikit-learn-and-Scientific-Python-Toolkits/2dc4f5164d75adfc298767f14f5aeafe45d0b385/Chapter11/.keep -------------------------------------------------------------------------------- /Chapter12/.keep: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/Hands-On-Machine-Learning-with-scikit-learn-and-Scientific-Python-Toolkits/2dc4f5164d75adfc298767f14f5aeafe45d0b385/Chapter12/.keep -------------------------------------------------------------------------------- /Chapter13/.keep: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/Hands-On-Machine-Learning-with-scikit-learn-and-Scientific-Python-Toolkits/2dc4f5164d75adfc298767f14f5aeafe45d0b385/Chapter13/.keep -------------------------------------------------------------------------------- /Chapter13/README.md: -------------------------------------------------------------------------------- 1 | # Chapter 13: Recommender System; Getting to Know Their Taste 2 | 3 | In this chapter, we will learn about the different approaches used by recommender systems. We will mainly use a sister library to scikit-learn called Surprise. Surprise is a toolkit that implements different collaborative filtering algorithms. So, we will start by learning the differences between the collaborative filtering algorithms and the content-based filtering algorithms used in a recommendation engine. We will also learn how to package our trained models to be used by other software without the need for retraining. The following topics will be discussed here: 4 | 5 | - The different recommendation paradigms 6 | - Downloading Surprise and the dataset 7 | - Using KNN-inspired algorithms 8 | - Using baseline algorithms 9 | - Using singular value decomposition 10 | - Deploying machine learning models in production 11 | -------------------------------------------------------------------------------- /Chapter13/artist_recommender.pkl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/Hands-On-Machine-Learning-with-scikit-learn-and-Scientific-Python-Toolkits/2dc4f5164d75adfc298767f14f5aeafe45d0b385/Chapter13/artist_recommender.pkl -------------------------------------------------------------------------------- /Chapter13/recsys.pkl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/Hands-On-Machine-Learning-with-scikit-learn-and-Scientific-Python-Toolkits/2dc4f5164d75adfc298767f14f5aeafe45d0b385/Chapter13/recsys.pkl -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | # Hands-On Machine Learning with Scikit-Learn and Scientific Python Toolkits 5 | 6 | Hands-On Machine Learning with Scikit-Learn and Scientific Python Toolkits 7 | 8 | This is the code repository for [Hands-On Machine Learning with Scikit-Learn and Scientific Python Toolkits](https://www.packtpub.com/data/hands-on-machine-learning-with-scikit-learn?utm_source=github&utm_medium=repository&utm_campaign=9781838826048), published by Packt. 9 | 10 | **A practical guide to implementing supervised and unsupervised machine learning algorithms in Python** 11 | 12 | ## What is this book about? 13 | Machine learning is applied everywhere, from business to research and academia, while Scikit-Learn is a versatile library that is popular among machine learning practitioners. This book serves as a practical guide for anyone looking to provide hands-on machine learning solutions with Scikit-Learn and Python toolkits. 14 | 15 | The book begins with an explanation of machine learning concepts and fundamentals, and strikes a balance between theoretical concepts and their applications. Each chapter covers a different set of algorithms, and shows you how to use them to solve real-life problems. You’ll also learn various key supervised and unsupervised machine learning algorithms using practical examples. Whether it is an instance-based learning algorithm, Bayesian estimation, a deep neural network, a tree-based ensemble, or a recommendation system, you’ll gain a thorough understanding of its theory and learn when to apply it. As you advance, you’ll learn how to deal with unlabeled data and when to use different clustering and anomaly detection algorithms. 16 | 17 | By the end of this machine learning book, you’ll have learnt how to take a data-driven approach to provide end-to-end machine learning solutions. You’ll also have discovered how to formulate the problem at hand, prepare required data, and evaluate and deploy models in production. 18 | 19 | This book goes beyond Scikit-Learn, and introduces you to complementary libraries such as NumPy, Pandas, SpaCy, imbalanced-learn, and Scikit-Surprise. The theoretical knowledge in this book should also prepare you to use libraries not mentioned here such as Tensor Flow and Pytorch. 20 | 21 | In this repo, you will find the code examples used in the book. I also include here parts of the code omitted in the book, such as the data visualization styling, additional formatting, etc. 22 | 23 | This book covers the following exciting features: 24 | * Understand when to use supervised, unsupervised, or reinforcement learning algorithms 25 | * Find out how to collect and prepare your data for machine learning tasks 26 | * Tackle imbalanced data and optimize your algorithm for a bias or variance tradeoff 27 | * Apply supervised and unsupervised algorithms to overcome various machine learning challenges 28 | * Employ best practices for tuning your algorithm’s hyper parameters 29 | * Discover how to use neural networks for classification and regression 30 | * Build, evaluate, and deploy your machine learning solutions to production 31 | 32 | If you feel this book is for you, get your [copy](https://www.amazon.com/dp/1838826041) today! 33 | 34 | https://www.packtpub.com/ 35 | 36 | ## Book Reviews 37 | 38 | ### From [GoodReads](https://www.goodreads.com/book/show/54539914-hands-on-machine-learning-with-scikit-learn-and-scientific-python-toolki): 39 | 40 | Ali Faizan rated it: 5 out of 5 stars. 41 | > For a machine learning noob like me, it was pleasing to see that the book did not dive straight into the nitty-gritty of machine learning algorithms: it first established the raison d’être for machine learning and cohesively captured the whole gamut of developing a machine learning model. This helped me quite a bit to understand the bigger picture later on in the book where it demonstrated the practical use of various machine learning algorithms. I'll happily recommend this book to anyone interested in scikit-learn, and machine learning in general too 42 | 43 | Paul Schmidt rated it: 5 out of 5 stars. 44 | > This book is information rich with practical examples. I whom never read or touched this area was suprised to learn the weight that data analysis had on machine learning. Yes, this book also teaches you about data analysis. Throughout the chapters you learn what not to do when building machine learning and deep learning models. The author teaches you what not to do by analysing the data at hand and improving the models upon that knowledge. The book is very information rich and can easily be reread from chapter to chapter. There are some things to keep in mind, this book is not for python beginners and i urge you to know some of the basics from the pandas and matplotlib modules. In other words this book is strongly recommended. 45 | 46 | ### From [Amazon](https://www.amazon.com/Machine-Learning-scikit-learn-Scientific-Toolkits-ebook/dp/B08BTFY8YW/): 47 | 48 | Przemyslaw Chojecki rated it: 5 out of 5 stars. 49 | > If you've already did a couple of data science projects, had a basic understanding of Python, did some visualisation and want to go deeper into some details of what it means to analyse data, then this book is for you. This is a practical guide to both supervised and unsupervised learning with plenty of examples in code. The main focus is on imperfect data and how to make sense of these imperfections through various machine learning algorithms. The author discusses standard data science algorithms using scikit-learn library which gives a coherent overview of the subjest. You will learn decision trees, KNN classification, Naive Bayes and much more; applied to classical datasets like Iris dataset, Boston housing prices or Fashion-MNIST. Recommended for beginning data scientists! 50 | 51 | 52 | Adam Powell rated it: 5 out of 5 stars. 53 | > The perfect read for an analyst that wants to transition into machine learning. It broadly covers all the key algorithms with an insightful practitioner's perspective. Highly recommended! 54 | 55 | ## Instructions and Navigations 56 | All of the code is organized into folders. 57 | 58 | The code will look like the following: 59 | ``` 60 | import numpy as np 61 | import scipy as sp 62 | import pandas as pd 63 | import seaborn as sns 64 | import matplotlib.pyplot as plt 65 | 66 | ``` 67 | 68 | **Following is what you need for this book:** 69 | This book is for machine learning data scientists who want to master the theoretical and practical sides of machine learning algorithms and understand how to use them to solve real-life problems. Working knowledge of Python and a basic understanding of underlying mathematical and statistical concepts is required. Nevertheless, this book will walk you through the new concepts to cater to both new and experienced data scientists. 70 | 71 | With the following software and hardware list you can run all code files present in the book (Chapter 1-13). 72 | 73 | ### Software and Hardware List 74 | 75 | | Chapter | Software required | OS required | 76 | | -------- | -------------------------------------------------------------------------------------| -----------------------------------| 77 | | 1 - 13 | Python 3.x, Jupyter Notebook/Google Colab | Windows, Mac OS X, and Linux (Any) | 78 | 79 | 80 | # Running the code 81 | 82 | You will need Python 3.x installed on your computer. It is a good practice to set up a virtual environment to install the required libraries into. It's up to you whether you wish to use Python's venv module, the virtual environment provided by Anaconda, or any other option you like. We'll be using pip to install the libraries needed in the book, but once more, it is up to you whether you prefer to use conda or any other alternatives. 83 | 84 | We suggest you create a conda environment first, then install the required libs there: 85 | 86 | ``` 87 | conda create -n scikitbook python=3.6 88 | conda activate scikitbook 89 | pip install --upgrade -r requirements.txt 90 | ``` 91 | 92 | You need to do the above steps once. 93 | Then to activate the environment: 94 | 95 | ``` 96 | conda activate scikitbook 97 | ``` 98 | 99 | And to run Jupyter: 100 | 101 | ``` 102 | jupyter notebook 103 | ``` 104 | 105 | We also provide a PDF file that has color images of the screenshots/diagrams used in this book. [Click here to download it](https://static.packt-cdn.com/downloads/9781838826048_ColorImages.pdf). 106 | 107 | 108 | ### Related products 109 | * Python Machine Learning - Third Edition [[Packt]](https://www.packtpub.com/data/python-machine-learning-third-edition?utm_source=github&utm_medium=repository&utm_campaign=9781789955750) [[Amazon]](https://www.amazon.com/dp/1789955750) 110 | 111 | * Mastering Machine Learning Algorithms - Second Edition [[Packt]](https://www.packtpub.com/data/mastering-machine-learning-algorithms-second-edition?utm_source=github&utm_medium=repository&utm_campaign=9781838820299) [[Amazon]](https://www.amazon.com/dp/B0843PMXPV) 112 | 113 | ## Get to Know the Author 114 | **Tarek Amr** 115 | has 8 years of experience in data science and machine learning. After finishing his postgraduate degree at the University of East Anglia, he worked in a number of startups and scaleup companies in Egypt and in the Netherlands. This is his second data-related book. His previous book is about data visualization using D3.js. He enjoys giving talks and writing about different computer science and business concepts and explaining them to a wider audience. He can be reached on twitter at [@gr33ndata](https://twitter.com/gr33ndata). He is happy to respond to all questions related to this book. Feel free to reach him if any parts of the book need clarifications or if you would like to discuss any of the concepts there in more detail. 116 | 117 | You can also find the book's page on Good Reads [here](https://www.goodreads.com/book/show/54539914-hands-on-machine-learning-with-scikit-learn-and-scientific-python-toolki), your book reviews are highly appreciated. 118 | 119 | # Book Citation 120 | 121 | Please make sure to cite the book if you use it in your research: 122 | 123 | BiBTeX: 124 | 125 | ``` 126 | @book{amr2020hands, 127 | title={Hands-On Machine Learning with scikit-learn and Scientific Python Toolkits: A practical guide to implementing supervised and unsupervised machine learning algorithms in Python}, 128 | author={Amr, Tarek}, 129 | isbn={9781838823580}, 130 | url={https://books.google.nl/books?id=GlbzDwAAQBAJ}, 131 | year={2020}, 132 | publisher={Packt Publishing, Limited} 133 | } 134 | ``` 135 | 136 | ### Suggestions and Feedback 137 | [Click here](https://docs.google.com/forms/d/e/1FAIpQLSdy7dATC6QmEL81FIUuymZ0Wy9vH1jHkvpY57OiMeKGqib_Ow/viewform) if you have any feedback or suggestions. 138 | ### Download a free PDF 139 | 140 | If you have already purchased a print or Kindle version of this book, you can get a DRM-free PDF version at no cost.
Simply click on the link to claim your free PDF. 141 |

https://packt.link/free-ebook/9781838826048

142 | -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | appnope==0.1.0 2 | attrs==19.3.0 3 | backcall==0.1.0 4 | bleach==3.3.0 5 | blis==0.4.1 6 | catalogue==1.0.0 7 | category-encoders==2.1.0 8 | certifi==2024.7.4 9 | chardet==3.0.4 10 | cycler==0.10.0 11 | cymem==2.0.3 12 | decorator==4.4.1 13 | defusedxml==0.6.0 14 | en-core-web-md==2.2.5 15 | entrypoints==0.3 16 | idna==3.7 17 | imageio==2.6.1 18 | imbalanced-learn==0.6.2 19 | importlib-metadata==0.23 20 | ipykernel==5.1.3 21 | ipython==8.10.0 22 | ipython-genutils==0.2.0 23 | ipywidgets==7.5.1 24 | jedi==0.15.1 25 | Jinja2==3.1.5 26 | joblib==1.2.0 27 | jsonschema==3.2.0 28 | jupyter==1.0.0 29 | jupyter-client==5.3.4 30 | jupyter-console==6.0.0 31 | jupyter-core==4.11.2 32 | kiwisolver==1.1.0 33 | MarkupSafe==1.1.1 34 | matplotlib==3.1.2 35 | mistune==2.0.3 36 | mkl-fft==1.0.15 37 | mkl-random==1.1.0 38 | mkl-service==2.3.0 39 | more-itertools==7.2.0 40 | murmurhash==1.0.2 41 | nbconvert==6.5.1 42 | nbformat==4.4.0 43 | networkx==2.4 44 | numpy==1.22.0 45 | notebook==6.4.12 46 | pandas==0.25.3 47 | pandocfilters==1.4.2 48 | parso==0.5.1 49 | patsy==0.5.1 50 | pexpect==4.7.0 51 | pickleshare==0.7.5 52 | Pillow==10.3.0 53 | plac==1.1.3 54 | preshed==3.0.2 55 | prometheus-client==0.7.1 56 | prompt-toolkit==2.0.10 57 | ptyprocess==0.6.0 58 | Pygments==2.15.0 59 | pyparsing==2.4.5 60 | pyrsistent==0.15.5 61 | python-dateutil==2.8.1 62 | pytz==2019.3 63 | PyWavelets==1.1.1 64 | pyzmq==18.1.1 65 | qtconsole==4.6.0 66 | requests==2.32.2 67 | scikit-image==0.16.2 68 | scikit-learn==0.22 69 | scipy==1.10.0 70 | seaborn==0.9.0 71 | Send2Trash==1.5.0 72 | six==1.13.0 73 | spacy==2.2.3 74 | srsly==1.0.1 75 | statsmodels==0.10.2 76 | terminado==0.8.3 77 | testpath==0.4.4 78 | thinc==7.3.1 79 | tornado==6.4.1 80 | tqdm==4.66.3 81 | traitlets==4.3.3 82 | urllib3==1.26.19 83 | wasabi==0.6.0 84 | wcwidth==0.1.7 85 | webencodings==0.5.1 86 | widgetsnbextension==3.5.1 87 | zipp==3.19.1 88 | --------------------------------------------------------------------------------