├── README.md ├── feature-encoding.ipynb ├── feature-scaling.ipynb └── missing-values-imputation.ipynb /README.md: -------------------------------------------------------------------------------- 1 | # Scikit-learn Tutorial 2 | 3 | ## Introduction 4 | [Scikit-learn](https://scikit-learn.org/stable/) is a free software machine learning library for the Python programming language. It features various classification, 5 | regression and clustering algorithms including support vector machines, random forests, gradient boosting and k-means and is 6 | designed to interoperate with the Python numerical and scientific libraries NumPy and SciPy. 7 | 8 | ## Repository description 9 | This repository contains 3 separate notebooks, each covering different aspects of data preprocessing for machine learning 10 | using scikit-learn, namely: 11 | - Feature encoding 12 | - Feature scaling 13 | - Missing values imputation 14 | 15 | ## Medium (Towards Data Science) articles 16 | - [Guide to Encoding Categorical Features using Scikit-Learn for Machine Learning](https://towardsdatascience.com/guide-to-encoding-categorical-features-using-scikit-learn-for-machine-learning-5048997a5c79) 17 | - [What is Feature Scaling & Why is it Important in Machine Learning?](https://towardsdatascience.com/what-is-feature-scaling-why-is-it-important-in-machine-learning-2854ae877048) 18 | - [Stop Wasting Useful Information When Imputing Missing Values](https://towardsdatascience.com/stop-wasting-useful-information-when-imputing-missing-values-d6ef91ef4c21) 19 | -------------------------------------------------------------------------------- /feature-scaling.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 0. Introduction" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Feature scaling is the process of normalising the range of features in a dataset. \n", 15 | "\n", 16 | "Real-world datasets often contain features that are varying in degrees of magnitude, range and units. Therefore, in order for machine learning models to interpret these features on the same scale, we have to perform feature scaling.\n", 17 | "\n", 18 | "In science, we all know the importance of comparing apples to apples and yet many people, especially beginners, have a tendency to overlook feature scaling as part of the preprocessing steps for machine learning. This has proven to cause models to make inaccurate predictions. \n", 19 | "\n", 20 | "In this tutorial, we will discuss why feature scaling is important, the difference between normalisation and standardisation as well as how feature scaling affects model accuracy. More specifically, we will explore the applications of 3 different types of scalers in the Scikit-learn library: \n", 21 | "\n", 22 | "1. [MixMaxScaler](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.MinMaxScaler.html)\n", 23 | "2. [StandardScaler](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html)\n", 24 | "3. [RobustScaler](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.RobustScaler.html)" 25 | ] 26 | }, 27 | { 28 | "cell_type": "markdown", 29 | "metadata": {}, 30 | "source": [ 31 | "# 1. Import libraries" 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": 1, 37 | "metadata": {}, 38 | "outputs": [], 39 | "source": [ 40 | "# Data wrangling\n", 41 | "import pandas as pd\n", 42 | "import numpy as np\n", 43 | "\n", 44 | "# Data visualisation\n", 45 | "import seaborn as sns\n", 46 | "import matplotlib.pyplot as plt\n", 47 | "\n", 48 | "# Machine learning\n", 49 | "from sklearn.model_selection import train_test_split\n", 50 | "from sklearn.preprocessing import MinMaxScaler, StandardScaler, RobustScaler\n", 51 | "from sklearn.neighbors import KNeighborsRegressor\n", 52 | "from sklearn.svm import SVR\n", 53 | "from sklearn.tree import DecisionTreeRegressor\n", 54 | "from sklearn.pipeline import make_pipeline\n", 55 | "from sklearn.metrics import mean_squared_error" 56 | ] 57 | }, 58 | { 59 | "cell_type": "markdown", 60 | "metadata": {}, 61 | "source": [ 62 | "# 2. Import dataset\n", 63 | "\n", 64 | "For the purpose of this tutorial, we will use one of the toy datasets in the Scikit-learn library, the [Boston house prices dataset](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_boston.html).\n", 65 | "\n", 66 | "You can find the description of the features [here](https://scikit-learn.org/stable/datasets/toy_dataset.html#boston-dataset)." 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": 2, 72 | "metadata": {}, 73 | "outputs": [ 74 | { 75 | "data": { 76 | "text/html": [ 77 | "
\n", 78 | "\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 | " \n", 105 | " \n", 106 | " \n", 107 | " \n", 108 | " \n", 109 | " \n", 110 | " \n", 111 | " \n", 112 | " \n", 113 | " \n", 114 | " \n", 115 | " \n", 116 | " \n", 117 | " \n", 118 | " \n", 119 | " \n", 120 | " \n", 121 | " \n", 122 | " \n", 123 | " \n", 124 | " \n", 125 | " \n", 126 | " \n", 127 | " \n", 128 | " \n", 129 | " \n", 130 | " \n", 131 | " \n", 132 | " \n", 133 | " \n", 134 | " \n", 135 | " \n", 136 | " \n", 137 | " \n", 138 | " \n", 139 | " \n", 140 | " \n", 141 | " \n", 142 | " \n", 143 | " \n", 144 | " \n", 145 | " \n", 146 | " \n", 147 | " \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 | "
CRIMZNINDUSCHASNOXRMAGEDISRADTAXPTRATIOBLSTATtarget
00.0063218.02.310.00.5386.57565.24.09001.0296.015.3396.904.9824.0
10.027310.07.070.00.4696.42178.94.96712.0242.017.8396.909.1421.6
20.027290.07.070.00.4697.18561.14.96712.0242.017.8392.834.0334.7
30.032370.02.180.00.4586.99845.86.06223.0222.018.7394.632.9433.4
40.069050.02.180.00.4587.14754.26.06223.0222.018.7396.905.3336.2
\n", 199 | "
" 200 | ], 201 | "text/plain": [ 202 | " CRIM ZN INDUS CHAS NOX RM AGE DIS RAD TAX \\\n", 203 | "0 0.00632 18.0 2.31 0.0 0.538 6.575 65.2 4.0900 1.0 296.0 \n", 204 | "1 0.02731 0.0 7.07 0.0 0.469 6.421 78.9 4.9671 2.0 242.0 \n", 205 | "2 0.02729 0.0 7.07 0.0 0.469 7.185 61.1 4.9671 2.0 242.0 \n", 206 | "3 0.03237 0.0 2.18 0.0 0.458 6.998 45.8 6.0622 3.0 222.0 \n", 207 | "4 0.06905 0.0 2.18 0.0 0.458 7.147 54.2 6.0622 3.0 222.0 \n", 208 | "\n", 209 | " PTRATIO B LSTAT target \n", 210 | "0 15.3 396.90 4.98 24.0 \n", 211 | "1 17.8 396.90 9.14 21.6 \n", 212 | "2 17.8 392.83 4.03 34.7 \n", 213 | "3 18.7 394.63 2.94 33.4 \n", 214 | "4 18.7 396.90 5.33 36.2 " 215 | ] 216 | }, 217 | "execution_count": 2, 218 | "metadata": {}, 219 | "output_type": "execute_result" 220 | } 221 | ], 222 | "source": [ 223 | "from sklearn.datasets import load_boston\n", 224 | "boston = load_boston()\n", 225 | "data = pd.DataFrame(boston.data, columns = boston.feature_names)\n", 226 | "data['target'] = boston.target\n", 227 | "data.head()" 228 | ] 229 | }, 230 | { 231 | "cell_type": "markdown", 232 | "metadata": {}, 233 | "source": [ 234 | "# 3. Examine data" 235 | ] 236 | }, 237 | { 238 | "cell_type": "code", 239 | "execution_count": 3, 240 | "metadata": {}, 241 | "outputs": [ 242 | { 243 | "name": "stdout", 244 | "output_type": "stream", 245 | "text": [ 246 | "\n", 247 | "RangeIndex: 506 entries, 0 to 505\n", 248 | "Data columns (total 14 columns):\n", 249 | " # Column Non-Null Count Dtype \n", 250 | "--- ------ -------------- ----- \n", 251 | " 0 CRIM 506 non-null float64\n", 252 | " 1 ZN 506 non-null float64\n", 253 | " 2 INDUS 506 non-null float64\n", 254 | " 3 CHAS 506 non-null float64\n", 255 | " 4 NOX 506 non-null float64\n", 256 | " 5 RM 506 non-null float64\n", 257 | " 6 AGE 506 non-null float64\n", 258 | " 7 DIS 506 non-null float64\n", 259 | " 8 RAD 506 non-null float64\n", 260 | " 9 TAX 506 non-null float64\n", 261 | " 10 PTRATIO 506 non-null float64\n", 262 | " 11 B 506 non-null float64\n", 263 | " 12 LSTAT 506 non-null float64\n", 264 | " 13 target 506 non-null float64\n", 265 | "dtypes: float64(14)\n", 266 | "memory usage: 55.5 KB\n" 267 | ] 268 | } 269 | ], 270 | "source": [ 271 | "# Missing values and data type\n", 272 | "\n", 273 | "data.info()" 274 | ] 275 | }, 276 | { 277 | "cell_type": "markdown", 278 | "metadata": {}, 279 | "source": [ 280 | "Hooray, no missing values!\n", 281 | "\n", 282 | "It also appears that all of our independent variables as well as the target variable are of the float64 data type. " 283 | ] 284 | }, 285 | { 286 | "cell_type": "code", 287 | "execution_count": 4, 288 | "metadata": {}, 289 | "outputs": [ 290 | { 291 | "data": { 292 | "text/html": [ 293 | "
\n", 294 | "\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 | " \n", 336 | " \n", 337 | " \n", 338 | " \n", 339 | " \n", 340 | " \n", 341 | " \n", 342 | " \n", 343 | " \n", 344 | " \n", 345 | " \n", 346 | " \n", 347 | " \n", 348 | " \n", 349 | " \n", 350 | " \n", 351 | " \n", 352 | " \n", 353 | " \n", 354 | " \n", 355 | " \n", 356 | " \n", 357 | " \n", 358 | " \n", 359 | " \n", 360 | " \n", 361 | " \n", 362 | " \n", 363 | " \n", 364 | " \n", 365 | " \n", 366 | " \n", 367 | " \n", 368 | " \n", 369 | " \n", 370 | " \n", 371 | " \n", 372 | " \n", 373 | " \n", 374 | " \n", 375 | " \n", 376 | " \n", 377 | " \n", 378 | " \n", 379 | " \n", 380 | " \n", 381 | " \n", 382 | " \n", 383 | " \n", 384 | " \n", 385 | " \n", 386 | " \n", 387 | " \n", 388 | " \n", 389 | " \n", 390 | " \n", 391 | " \n", 392 | " \n", 393 | " \n", 394 | " \n", 395 | " \n", 396 | " \n", 397 | " \n", 398 | " \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 | " \n", 448 | " \n", 449 | " \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 | "
countmeanstdmin25%50%75%max
CRIM506.03.6135248.6015450.006320.0820450.256513.67708388.9762
ZN506.011.36363623.3224530.000000.0000000.0000012.500000100.0000
INDUS506.011.1367796.8603530.460005.1900009.6900018.10000027.7400
CHAS506.00.0691700.2539940.000000.0000000.000000.0000001.0000
NOX506.00.5546950.1158780.385000.4490000.538000.6240000.8710
RM506.06.2846340.7026173.561005.8855006.208506.6235008.7800
AGE506.068.57490128.1488612.9000045.02500077.5000094.075000100.0000
DIS506.03.7950432.1057101.129602.1001753.207455.18842512.1265
RAD506.09.5494078.7072591.000004.0000005.0000024.00000024.0000
TAX506.0408.237154168.537116187.00000279.000000330.00000666.000000711.0000
PTRATIO506.018.4555342.16494612.6000017.40000019.0500020.20000022.0000
B506.0356.67403291.2948640.32000375.377500391.44000396.225000396.9000
LSTAT506.012.6530637.1410621.730006.95000011.3600016.95500037.9700
target506.022.5328069.1971045.0000017.02500021.2000025.00000050.0000
\n", 478 | "
" 479 | ], 480 | "text/plain": [ 481 | " count mean std min 25% 50% \\\n", 482 | "CRIM 506.0 3.613524 8.601545 0.00632 0.082045 0.25651 \n", 483 | "ZN 506.0 11.363636 23.322453 0.00000 0.000000 0.00000 \n", 484 | "INDUS 506.0 11.136779 6.860353 0.46000 5.190000 9.69000 \n", 485 | "CHAS 506.0 0.069170 0.253994 0.00000 0.000000 0.00000 \n", 486 | "NOX 506.0 0.554695 0.115878 0.38500 0.449000 0.53800 \n", 487 | "RM 506.0 6.284634 0.702617 3.56100 5.885500 6.20850 \n", 488 | "AGE 506.0 68.574901 28.148861 2.90000 45.025000 77.50000 \n", 489 | "DIS 506.0 3.795043 2.105710 1.12960 2.100175 3.20745 \n", 490 | "RAD 506.0 9.549407 8.707259 1.00000 4.000000 5.00000 \n", 491 | "TAX 506.0 408.237154 168.537116 187.00000 279.000000 330.00000 \n", 492 | "PTRATIO 506.0 18.455534 2.164946 12.60000 17.400000 19.05000 \n", 493 | "B 506.0 356.674032 91.294864 0.32000 375.377500 391.44000 \n", 494 | "LSTAT 506.0 12.653063 7.141062 1.73000 6.950000 11.36000 \n", 495 | "target 506.0 22.532806 9.197104 5.00000 17.025000 21.20000 \n", 496 | "\n", 497 | " 75% max \n", 498 | "CRIM 3.677083 88.9762 \n", 499 | "ZN 12.500000 100.0000 \n", 500 | "INDUS 18.100000 27.7400 \n", 501 | "CHAS 0.000000 1.0000 \n", 502 | "NOX 0.624000 0.8710 \n", 503 | "RM 6.623500 8.7800 \n", 504 | "AGE 94.075000 100.0000 \n", 505 | "DIS 5.188425 12.1265 \n", 506 | "RAD 24.000000 24.0000 \n", 507 | "TAX 666.000000 711.0000 \n", 508 | "PTRATIO 20.200000 22.0000 \n", 509 | "B 396.225000 396.9000 \n", 510 | "LSTAT 16.955000 37.9700 \n", 511 | "target 25.000000 50.0000 " 512 | ] 513 | }, 514 | "execution_count": 4, 515 | "metadata": {}, 516 | "output_type": "execute_result" 517 | } 518 | ], 519 | "source": [ 520 | "# Summary statistics\n", 521 | "\n", 522 | "data.describe().transpose()" 523 | ] 524 | }, 525 | { 526 | "cell_type": "markdown", 527 | "metadata": {}, 528 | "source": [ 529 | "We can clearly observe that our features span across different range of values. This is largely attributed to the different units in which these features were measured and recorded.\n", 530 | "\n", 531 | "This is where feature scaling can help us solve this issue." 532 | ] 533 | }, 534 | { 535 | "cell_type": "markdown", 536 | "metadata": {}, 537 | "source": [ 538 | "# 4. Understand the effects of different scalers\n", 539 | "\n", 540 | "In this section, we will learn the distinction between normalisation and standardisation. Subsequently, we will look at the effects of 3 different feature scaling techniques in Scikit-learn. " 541 | ] 542 | }, 543 | { 544 | "cell_type": "markdown", 545 | "metadata": {}, 546 | "source": [ 547 | "# 4.1 Theory\n", 548 | "\n", 549 | "Before we examine the effects of feature scaling, let us first go over some theories behind normalisation and standardisation." 550 | ] 551 | }, 552 | { 553 | "cell_type": "markdown", 554 | "metadata": {}, 555 | "source": [ 556 | "## 4.2.1 Normalisation\n", 557 | "\n", 558 | "Normalisation, also known as min-max scaling, is a scaling technique whereby the values in a column are shifted so that they are bounded between a fixed range of 0 and 1.\n", 559 | "\n", 560 | "X_new = (X - X_min) / (X_max - X_min)\n", 561 | "\n", 562 | "[MinMaxScaler](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.MinMaxScaler.html) is the Scikit-learn function for normalisation. " 563 | ] 564 | }, 565 | { 566 | "cell_type": "markdown", 567 | "metadata": {}, 568 | "source": [ 569 | "## 4.2.2 Standardisation\n", 570 | "\n", 571 | "On the other hand, standardisation or Z-score normalisation is another scaling technique whereby the values in a column are rescaled so that they demonstrate the properties of a standard Gaussian distribution, that is mean = 0 and variance = 1. \n", 572 | "\n", 573 | "X_new = (X - mean) / std\n", 574 | "\n", 575 | "[StandardScaler](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html) is the Scikit-learn function for standardisation.\n", 576 | "\n", 577 | "Unlike StandardScaler, [RobustScaler](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.RobustScaler.html) scales features using statistics that are robust to outliers. More specifically, this scaler removes the median and scales the data according to the quantile range or by default, the interquartile range, thus making it less susceptible to outliers. " 578 | ] 579 | }, 580 | { 581 | "cell_type": "markdown", 582 | "metadata": {}, 583 | "source": [ 584 | "## 4.2.3 Normalisation vs standardisation \n", 585 | "\n", 586 | "The choice between normalisation or standardisation comes down to the application.\n", 587 | "\n", 588 | "Standardisation is generally preferred over normalisation in most machine learning context as it is especially important in order to compare the similarities between features based on certain distance measures. This is most prominent in Principal Component Analysis (PCA) where we are interested in the components that maximise the variance.\n", 589 | "\n", 590 | "Normalisation, on the other hand, also offers many practical applications particularly in computer vision and image processing where pixel intensities have to be normalised to fit within a the RGB colour range between 0 and 255. Furthermore, neural network algorithms typically require data to be normalised to a 0-1 scale before model training. \n", 591 | "\n", 592 | "At the end of the day, there is no definitive answer as to whether you should normalise or standardise your data. One can always apply both techniques and compare the model performance for the best results. " 593 | ] 594 | }, 595 | { 596 | "cell_type": "markdown", 597 | "metadata": {}, 598 | "source": [ 599 | "# 4.2 Application \n", 600 | "\n", 601 | "Now that we have a theoretical understanding of feature scaling, let's see how they work in practice. " 602 | ] 603 | }, 604 | { 605 | "cell_type": "code", 606 | "execution_count": 5, 607 | "metadata": {}, 608 | "outputs": [ 609 | { 610 | "name": "stdout", 611 | "output_type": "stream", 612 | "text": [ 613 | "X shape: (506, 13)\n", 614 | "Y shape: (506,)\n" 615 | ] 616 | } 617 | ], 618 | "source": [ 619 | "# Get predictor and target variables\n", 620 | "X = data.drop('target', axis = 1)\n", 621 | "Y = data['target']\n", 622 | "\n", 623 | "# X, Y shape\n", 624 | "print(\"X shape: \", X.shape)\n", 625 | "print(\"Y shape: \", Y.shape)" 626 | ] 627 | }, 628 | { 629 | "cell_type": "code", 630 | "execution_count": 6, 631 | "metadata": {}, 632 | "outputs": [], 633 | "source": [ 634 | "# Instantiate MinMaxScaler, StandardScaler and RobustScaler\n", 635 | "\n", 636 | "norm = MinMaxScaler()\n", 637 | "standard = StandardScaler()\n", 638 | "robust = RobustScaler()" 639 | ] 640 | }, 641 | { 642 | "cell_type": "code", 643 | "execution_count": 7, 644 | "metadata": {}, 645 | "outputs": [], 646 | "source": [ 647 | "# MinMaxScaler\n", 648 | "normalised_features = norm.fit_transform(X)\n", 649 | "normalised_df = pd.DataFrame(normalised_features, index = X.index, columns = X.columns)\n", 650 | "\n", 651 | "# StandardScaler\n", 652 | "standardised_features = standard.fit_transform(X)\n", 653 | "standardised_df = pd.DataFrame(standardised_features, index = X.index, columns = X.columns)\n", 654 | "\n", 655 | "# RobustScaler\n", 656 | "robust_features = robust.fit_transform(X)\n", 657 | "robust_df = pd.DataFrame(robust_features, index = X.index, columns = X.columns)" 658 | ] 659 | }, 660 | { 661 | "cell_type": "markdown", 662 | "metadata": {}, 663 | "source": [ 664 | "To demonstrate the effects of different scalers, I have chosen to examine the following features in our dataset before and after implementing feature scaling: \n", 665 | "\n", 666 | "- ZN\n", 667 | "- AGE\n", 668 | "- TAX\n", 669 | "- B " 670 | ] 671 | }, 672 | { 673 | "cell_type": "code", 674 | "execution_count": 8, 675 | "metadata": { 676 | "scrolled": false 677 | }, 678 | "outputs": [ 679 | { 680 | "data": { 681 | "text/plain": [ 682 | "Text(0, 0.5, '')" 683 | ] 684 | }, 685 | "execution_count": 8, 686 | "metadata": {}, 687 | "output_type": "execute_result" 688 | }, 689 | { 690 | "data": { 691 | "image/png": "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\n", 692 | "text/plain": [ 693 | "
" 694 | ] 695 | }, 696 | "metadata": { 697 | "needs_background": "light" 698 | }, 699 | "output_type": "display_data" 700 | } 701 | ], 702 | "source": [ 703 | "# Create subplots\n", 704 | "fig, ax = plt.subplots(2, 2, figsize = (12, 9))\n", 705 | "\n", 706 | "# Original\n", 707 | "sns.boxplot(x = 'variable', y = 'value', data = pd.melt(data[['ZN', 'AGE', 'TAX', 'B']]), ax = ax[0, 0])\n", 708 | "ax[0, 0].set_title('Original')\n", 709 | "ax[0, 0].set_xlabel('')\n", 710 | "ax[0, 0].set_ylabel('')\n", 711 | "\n", 712 | "# MinMaxScaler\n", 713 | "sns.boxplot(x = 'variable', y = 'value', data = pd.melt(normalised_df[['ZN', 'AGE', 'TAX', 'B']]), ax = ax[0, 1])\n", 714 | "ax[0, 1].set_title('MinMaxScaler')\n", 715 | "ax[0, 1].set_xlabel('')\n", 716 | "ax[0, 1].set_ylabel('')\n", 717 | "\n", 718 | "# StandardScaler\n", 719 | "sns.boxplot(x = 'variable', y = 'value', data = pd.melt(standardised_df[['ZN', 'AGE', 'TAX', 'B']]), ax = ax[1, 0])\n", 720 | "ax[1, 0].set_title('StandardScaler')\n", 721 | "ax[1, 0].set_xlabel('')\n", 722 | "ax[1, 0].set_ylabel('')\n", 723 | "\n", 724 | "# RobustScaler\n", 725 | "sns.boxplot(x = 'variable', y = 'value', data = pd.melt(robust_df[['ZN', 'AGE', 'TAX', 'B']]), ax = ax[1, 1])\n", 726 | "ax[1, 1].set_title('RobustScaler')\n", 727 | "ax[1, 1].set_xlabel('')\n", 728 | "ax[1, 1].set_ylabel('')" 729 | ] 730 | }, 731 | { 732 | "cell_type": "markdown", 733 | "metadata": {}, 734 | "source": [ 735 | "As we can see, our original features have wildly different ranges.\n", 736 | "\n", 737 | "MinMaxScaler has rescaled our features so that their values are bounded between 0 and 1.\n", 738 | "\n", 739 | "StandardScaler and RobustScaler, on the other hand, have rescaled our features so that they are distributed around the mean of 0. " 740 | ] 741 | }, 742 | { 743 | "cell_type": "markdown", 744 | "metadata": {}, 745 | "source": [ 746 | "# 5. Compare model accuracy" 747 | ] 748 | }, 749 | { 750 | "cell_type": "markdown", 751 | "metadata": {}, 752 | "source": [ 753 | "I mentioned in the introduction of this tutorial that unscaled data can adversely impact a model's ability to make accurate predictions but so far, we have not discussed exactly how and why they do. In fact, feature scaling does not always improve a model's performance. Some models do not require feature scaling. \n", 754 | "\n", 755 | "In this section, we will explore the following classes of machine learning algorithms and discuss whether or not feature scaling impact their performance:\n", 756 | "\n", 757 | "1. Gradient descent based algorithms\n", 758 | "2. Distance-based algorithms\n", 759 | "3. Tree-based algorithms " 760 | ] 761 | }, 762 | { 763 | "cell_type": "markdown", 764 | "metadata": {}, 765 | "source": [ 766 | "# 5.1 Theory\n", 767 | "\n", 768 | "Let's first go over some concepts behind those algorithms and think about how and why feature scaling might be important to each of them." 769 | ] 770 | }, 771 | { 772 | "cell_type": "markdown", 773 | "metadata": {}, 774 | "source": [ 775 | "## 5.1.1 Gradient descent based algorithms\n", 776 | "\n", 777 | "Gradient desent is an iterative optimisation algorithm that takes us to the minimum of a function. Machine learning algorithms like linear regression and logistic regression rely on gradient descent to minimise their loss functions or in other words, to reduce the error between the predicted values and the actual values. \n", 778 | "\n", 779 | "Having features with varying range of values will cause different step sizes for each feature. Therefore, to ensure that gradient descent converges more smoothly and quickly, we need to scale our features so that they have a similar scale." 780 | ] 781 | }, 782 | { 783 | "cell_type": "markdown", 784 | "metadata": {}, 785 | "source": [ 786 | "## 5.1.2 Distance-based algorithms\n", 787 | "\n", 788 | "The underlying algorithms to distance-based models make them the most susceptible to unscaled data. \n", 789 | "\n", 790 | "Algorithms like k-nearest neighbours, support vector machines and k-means clustering use the distance between data points to determine their similarity. Hence, features with a greater magnitude will be given a higher weightage by the model. This is not an ideal scenario as we do not want our algorithm to be heavily biased towards a single feature.\n", 791 | "\n", 792 | "Evidently, it is important that we implement feature scaling to our data before fitting them to distance-based algorithms to ensure that all features contribute equally to the result. " 793 | ] 794 | }, 795 | { 796 | "cell_type": "markdown", 797 | "metadata": {}, 798 | "source": [ 799 | "## 5.1.3 Tree-based algorithms \n", 800 | "\n", 801 | "Each node in a classification and regression trees (CART) model, otherwise known as decision trees represents a single feature in a dataset. The tree splits each node in such a way that it increases the homogeneity of that node. This split is not affected by the other features in the dataset. \n", 802 | "\n", 803 | "For that reason, we can conclude that decision trees are invariant to the scale of the features and therefore do not require feature scaling. This includes other ensemble models that are also tree-based such as random forest and gradient boosting. " 804 | ] 805 | }, 806 | { 807 | "cell_type": "markdown", 808 | "metadata": {}, 809 | "source": [ 810 | "# 5.2 Proof of concept\n", 811 | "\n", 812 | "Now that we understand the types of models that are sensitive and insensitive to feature scaling, let us now convince ourselves with a concrete example using the Boston house prices dataset. \n", 813 | "\n", 814 | "Here, I have chosen 2 distance-based algorithms (KNN and SVR) as well as 1 tree-based algorithm (decision trees regressor) to predict the house prices.\n", 815 | "\n", 816 | "We should expect to see an improved model performance with feature scaling under KNN and SVR and a constant model performance under decision trees with and without feature scaling.\n", 817 | "\n", 818 | "Feel free to experiment with other types of models like linear regression, random forest and gradient boosting!" 819 | ] 820 | }, 821 | { 822 | "cell_type": "code", 823 | "execution_count": 9, 824 | "metadata": {}, 825 | "outputs": [], 826 | "source": [ 827 | "# Instantiate models \n", 828 | "knn = KNeighborsRegressor()\n", 829 | "svr = SVR()\n", 830 | "tree = DecisionTreeRegressor(max_depth = 10, random_state = 42)\n", 831 | "\n", 832 | "# Create a list which contains different scalers \n", 833 | "scalers = [norm, standard, robust]" 834 | ] 835 | }, 836 | { 837 | "cell_type": "code", 838 | "execution_count": 10, 839 | "metadata": {}, 840 | "outputs": [ 841 | { 842 | "name": "stdout", 843 | "output_type": "stream", 844 | "text": [ 845 | "X_train shape: (354, 13)\n", 846 | "Y_train shape: (354,)\n", 847 | "X_test shape: (152, 13)\n", 848 | "Y_test shape: (152,)\n" 849 | ] 850 | } 851 | ], 852 | "source": [ 853 | "# Train test split\n", 854 | "\n", 855 | "X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size = 0.3, random_state = 42)\n", 856 | "\n", 857 | "print(\"X_train shape: \", X_train.shape)\n", 858 | "print(\"Y_train shape: \", Y_train.shape)\n", 859 | "print(\"X_test shape: \", X_test.shape)\n", 860 | "print(\"Y_test shape: \", Y_test.shape)" 861 | ] 862 | }, 863 | { 864 | "cell_type": "markdown", 865 | "metadata": {}, 866 | "source": [ 867 | "Before we get started, I think it is important to highlight the good practice of first fitting the scalers to the training set and then use that to transform the data in the test set. This is to prevent any data leakage and misleading accuracy scores.\n", 868 | "\n", 869 | "Here, I will construct a pipeline which contains a scaler and a model to fit and transform the features and subsequently make predictions using each model. The accuracy of these predictions are then evaluated using root mean squared error. The smaller the error, the better the model performance. " 870 | ] 871 | }, 872 | { 873 | "cell_type": "markdown", 874 | "metadata": {}, 875 | "source": [ 876 | "## 5.2.1 KNN" 877 | ] 878 | }, 879 | { 880 | "cell_type": "code", 881 | "execution_count": 11, 882 | "metadata": {}, 883 | "outputs": [ 884 | { 885 | "data": { 886 | "text/html": [ 887 | "
\n", 888 | "\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 | "
RMSE
Original5.562872
MinMaxScaler4.667070
StandardScaler4.339935
RobustScaler4.232381
\n", 927 | "
" 928 | ], 929 | "text/plain": [ 930 | " RMSE\n", 931 | "Original 5.562872\n", 932 | "MinMaxScaler 4.667070\n", 933 | "StandardScaler 4.339935\n", 934 | "RobustScaler 4.232381" 935 | ] 936 | }, 937 | "execution_count": 11, 938 | "metadata": {}, 939 | "output_type": "execute_result" 940 | } 941 | ], 942 | "source": [ 943 | "knn_rmse = []\n", 944 | "\n", 945 | "# Without feature scaling\n", 946 | "knn.fit(X_train, Y_train)\n", 947 | "pred = knn.predict(X_test)\n", 948 | "knn_rmse.append(np.sqrt(mean_squared_error(Y_test, pred)))\n", 949 | "\n", 950 | "# Apply different scaling techniques and make predictions using KNN \n", 951 | "for scaler in scalers:\n", 952 | " pipe = make_pipeline(scaler, knn)\n", 953 | " pipe.fit(X_train, Y_train)\n", 954 | " pred = pipe.predict(X_test)\n", 955 | " knn_rmse.append(np.sqrt(mean_squared_error(Y_test, pred)))\n", 956 | "\n", 957 | "# Show results \n", 958 | "knn_df = pd.DataFrame({'RMSE': knn_rmse}, index = ['Original', 'MinMaxScaler', 'StandardScaler', 'RobustScaler'])\n", 959 | "knn_df" 960 | ] 961 | }, 962 | { 963 | "cell_type": "markdown", 964 | "metadata": {}, 965 | "source": [ 966 | "As expected, the errors are much smaller with feature scaling than without feature scaling. In other words, our model performed better using scaled features. \n", 967 | "\n", 968 | "In this instance, KNN performed best under RobustScaler. " 969 | ] 970 | }, 971 | { 972 | "cell_type": "markdown", 973 | "metadata": {}, 974 | "source": [ 975 | "## 5.2.2 SVR" 976 | ] 977 | }, 978 | { 979 | "cell_type": "code", 980 | "execution_count": 12, 981 | "metadata": {}, 982 | "outputs": [ 983 | { 984 | "data": { 985 | "text/html": [ 986 | "
\n", 987 | "\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 | "
RMSE
Original7.314623
MinMaxScaler5.255390
StandardScaler5.094817
RobustScaler5.404790
\n", 1026 | "
" 1027 | ], 1028 | "text/plain": [ 1029 | " RMSE\n", 1030 | "Original 7.314623\n", 1031 | "MinMaxScaler 5.255390\n", 1032 | "StandardScaler 5.094817\n", 1033 | "RobustScaler 5.404790" 1034 | ] 1035 | }, 1036 | "execution_count": 12, 1037 | "metadata": {}, 1038 | "output_type": "execute_result" 1039 | } 1040 | ], 1041 | "source": [ 1042 | "svr_rmse = []\n", 1043 | "\n", 1044 | "# Without feature scaling\n", 1045 | "svr.fit(X_train, Y_train)\n", 1046 | "pred = svr.predict(X_test)\n", 1047 | "svr_rmse.append(np.sqrt(mean_squared_error(Y_test, pred)))\n", 1048 | "\n", 1049 | "# Apply different scaling techniques and make predictions using SVR\n", 1050 | "for scaler in scalers:\n", 1051 | " pipe = make_pipeline(scaler, svr)\n", 1052 | " pipe.fit(X_train, Y_train)\n", 1053 | " pred = pipe.predict(X_test)\n", 1054 | " svr_rmse.append(np.sqrt(mean_squared_error(Y_test, pred)))\n", 1055 | "\n", 1056 | "# Show results\n", 1057 | "svr_df = pd.DataFrame({'RMSE': svr_rmse}, index = ['Original', 'MinMaxScaler', 'StandardScaler', 'RobustScaler'])\n", 1058 | "svr_df" 1059 | ] 1060 | }, 1061 | { 1062 | "cell_type": "markdown", 1063 | "metadata": {}, 1064 | "source": [ 1065 | "Similar to KNN, SVR also performed better with scaled features as seen by the lower errors.\n", 1066 | "\n", 1067 | "In this instance, SVR performed best under StandardScaler. " 1068 | ] 1069 | }, 1070 | { 1071 | "cell_type": "markdown", 1072 | "metadata": {}, 1073 | "source": [ 1074 | "## 5.2.3 Decision tree" 1075 | ] 1076 | }, 1077 | { 1078 | "cell_type": "code", 1079 | "execution_count": 13, 1080 | "metadata": {}, 1081 | "outputs": [ 1082 | { 1083 | "data": { 1084 | "text/html": [ 1085 | "
\n", 1086 | "\n", 1099 | "\n", 1100 | " \n", 1101 | " \n", 1102 | " \n", 1103 | " \n", 1104 | " \n", 1105 | " \n", 1106 | " \n", 1107 | " \n", 1108 | " \n", 1109 | " \n", 1110 | " \n", 1111 | " \n", 1112 | " \n", 1113 | " \n", 1114 | " \n", 1115 | " \n", 1116 | " \n", 1117 | " \n", 1118 | " \n", 1119 | " \n", 1120 | " \n", 1121 | " \n", 1122 | " \n", 1123 | " \n", 1124 | "
RMSE
Original3.318294
MinMaxScaler3.318294
StandardScaler3.318294
RobustScaler3.318294
\n", 1125 | "
" 1126 | ], 1127 | "text/plain": [ 1128 | " RMSE\n", 1129 | "Original 3.318294\n", 1130 | "MinMaxScaler 3.318294\n", 1131 | "StandardScaler 3.318294\n", 1132 | "RobustScaler 3.318294" 1133 | ] 1134 | }, 1135 | "execution_count": 13, 1136 | "metadata": {}, 1137 | "output_type": "execute_result" 1138 | } 1139 | ], 1140 | "source": [ 1141 | "tree_rmse = []\n", 1142 | "\n", 1143 | "# Without feature scaling\n", 1144 | "tree.fit(X_train, Y_train)\n", 1145 | "pred = tree.predict(X_test)\n", 1146 | "tree_rmse.append(np.sqrt(mean_squared_error(Y_test, pred)))\n", 1147 | "\n", 1148 | "# Apply different scaling techniques and make predictions using decision tree\n", 1149 | "for scaler in scalers:\n", 1150 | " pipe = make_pipeline(scaler, tree)\n", 1151 | " pipe.fit(X_train, Y_train)\n", 1152 | " pred = pipe.predict(X_test)\n", 1153 | " tree_rmse.append(np.sqrt(mean_squared_error(Y_test, pred)))\n", 1154 | "\n", 1155 | "# Show results \n", 1156 | "tree_df = pd.DataFrame({'RMSE': tree_rmse}, index = ['Original', 'MinMaxScaler', 'StandardScaler', 'RobustScaler'])\n", 1157 | "tree_df" 1158 | ] 1159 | }, 1160 | { 1161 | "cell_type": "markdown", 1162 | "metadata": {}, 1163 | "source": [ 1164 | "As expected, decision tree is insensitive to all feature scaling techniques as seen in the constant RMSE across scaled and unscaled features. " 1165 | ] 1166 | }, 1167 | { 1168 | "cell_type": "markdown", 1169 | "metadata": {}, 1170 | "source": [ 1171 | "# 6. Conclusion" 1172 | ] 1173 | }, 1174 | { 1175 | "cell_type": "markdown", 1176 | "metadata": {}, 1177 | "source": [ 1178 | "To summarise, feature scaling is the process of transforming the features in a dataset so that their values share a similar scale.\n", 1179 | "\n", 1180 | "In this tutorial, we have learned the difference between normalisation and standardisation as well as 3 different scalers in the Scikit-learn library: MinMaxScaler, StandardScaler and RobustScaler. \n", 1181 | "\n", 1182 | "We also learned that gradient descent and distance-based algorithms require feature scaling while tree-based algorithms do not. We managed to prove this via an example with the Boston house prices dataset and comparing the model accuracy with and without feature scaling." 1183 | ] 1184 | }, 1185 | { 1186 | "cell_type": "markdown", 1187 | "metadata": {}, 1188 | "source": [ 1189 | "# 7. References" 1190 | ] 1191 | }, 1192 | { 1193 | "cell_type": "markdown", 1194 | "metadata": {}, 1195 | "source": [ 1196 | "- [Feature Scaling for Machine Learning: Understanding the Difference Between Normalization vs. Standardization](https://www.analyticsvidhya.com/blog/2020/04/feature-scaling-machine-learning-normalization-standardization/)\n", 1197 | "- [Normalization vs Standardization](https://www.geeksforgeeks.org/normalization-vs-standardization/)" 1198 | ] 1199 | }, 1200 | { 1201 | "cell_type": "markdown", 1202 | "metadata": {}, 1203 | "source": [ 1204 | "# 8. Follow me on other platforms" 1205 | ] 1206 | }, 1207 | { 1208 | "cell_type": "markdown", 1209 | "metadata": {}, 1210 | "source": [ 1211 | "- [Facebook](https://www.facebook.com/chongjason914)\n", 1212 | "- [Instagram](https://www.instagram.com/chongjason914)\n", 1213 | "- [Twitter](https://www.twitter.com/chongjason914)\n", 1214 | "- [LinkedIn](https://www.linkedin.com/in/chongjason914)\n", 1215 | "- [YouTube](https://www.youtube.com/channel/UCQXiCnjatxiAKgWjoUlM-Xg?view_as=subscriber)\n", 1216 | "- [Medium](https://www.medium.com/@chongjason)" 1217 | ] 1218 | } 1219 | ], 1220 | "metadata": { 1221 | "kernelspec": { 1222 | "display_name": "Python 3", 1223 | "language": "python", 1224 | "name": "python3" 1225 | }, 1226 | "language_info": { 1227 | "codemirror_mode": { 1228 | "name": "ipython", 1229 | "version": 3 1230 | }, 1231 | "file_extension": ".py", 1232 | "mimetype": "text/x-python", 1233 | "name": "python", 1234 | "nbconvert_exporter": "python", 1235 | "pygments_lexer": "ipython3", 1236 | "version": "3.7.6" 1237 | } 1238 | }, 1239 | "nbformat": 4, 1240 | "nbformat_minor": 4 1241 | } 1242 | -------------------------------------------------------------------------------- /missing-values-imputation.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 0. Introduction" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Missing values is one of the most common problems that you will come across when performing data analysis. Furthermore, machine learning models require that a dataset does not contain any missing values before they can be fitted to the data. Therefore, it is crucial that we learn how to properly handle them.\n", 15 | "\n", 16 | "There are mainly two ways that we can deal with missing values in a dataset:\n", 17 | "\n", 18 | "1. If there are only a few rows with missing values or if a column has an overwhelming number of missing values, we can simply drop them from the dataset without running into the risk of losing too much information. \n", 19 | "2. An alternative approach to handling missing values is via imputation. Imputation is the process whereby the missing values in a dataset are replaced with some substituted values. \n", 20 | "\n", 21 | "For the purpose of this tutorial, we will examine the process of imputation and more specifically, we will learn the difference between a univariate approach to imputing versus a multivariate approach to imputing. \n", 22 | "\n", 23 | "Univariate imputation implies that we are only considering the values of a single column when performing imputation. Multivariate imputation, on the other hand, involves taking into account other features in the dataset when performing imputation.\n", 24 | "\n", 25 | "The multivariate approach to imputing is generally preferred over the univariate approach as it is more robust and provides our model with a more accurate representation of the missing values in order to make better predictions.\n", 26 | "\n", 27 | "In this tutorial, we will explore 3 different imputation techniques with reference to the [Titanic dataset](https://www.kaggle.com/c/titanic/data) on Kaggle:\n", 28 | "\n", 29 | "- [Simple imputer](https://scikit-learn.org/stable/modules/generated/sklearn.impute.SimpleImputer.html)\n", 30 | "- [Iterative imputer](https://scikit-learn.org/stable/modules/generated/sklearn.impute.IterativeImputer.html#sklearn.impute.IterativeImputer)\n", 31 | "- [KNN Imputer](https://scikit-learn.org/stable/modules/generated/sklearn.impute.KNNImputer.html)" 32 | ] 33 | }, 34 | { 35 | "cell_type": "markdown", 36 | "metadata": {}, 37 | "source": [ 38 | "# 1. Import libraries" 39 | ] 40 | }, 41 | { 42 | "cell_type": "code", 43 | "execution_count": 1, 44 | "metadata": {}, 45 | "outputs": [], 46 | "source": [ 47 | "# Data wrangling\n", 48 | "import pandas as pd\n", 49 | "import numpy as np \n", 50 | "\n", 51 | "# Data visualisation\n", 52 | "import seaborn as sns\n", 53 | "import matplotlib.pyplot as plt\n", 54 | "\n", 55 | "# Machine learning\n", 56 | "from sklearn.experimental import enable_iterative_imputer\n", 57 | "from sklearn.impute import SimpleImputer, IterativeImputer, KNNImputer\n", 58 | "from sklearn.preprocessing import OneHotEncoder\n", 59 | "from sklearn.compose import make_column_transformer\n", 60 | "from sklearn.pipeline import make_pipeline\n", 61 | "from sklearn.ensemble import RandomForestClassifier\n", 62 | "from sklearn.model_selection import cross_val_score\n", 63 | "\n", 64 | "# Remove warnings\n", 65 | "import warnings\n", 66 | "warnings.filterwarnings('ignore')" 67 | ] 68 | }, 69 | { 70 | "cell_type": "markdown", 71 | "metadata": {}, 72 | "source": [ 73 | "# 2. Prepare dataset" 74 | ] 75 | }, 76 | { 77 | "cell_type": "markdown", 78 | "metadata": {}, 79 | "source": [ 80 | "# 2.1 Import and read data" 81 | ] 82 | }, 83 | { 84 | "cell_type": "code", 85 | "execution_count": 2, 86 | "metadata": { 87 | "scrolled": false 88 | }, 89 | "outputs": [ 90 | { 91 | "data": { 92 | "text/html": [ 93 | "
\n", 94 | "\n", 107 | "\n", 108 | " \n", 109 | " \n", 110 | " \n", 111 | " \n", 112 | " \n", 113 | " \n", 114 | " \n", 115 | " \n", 116 | " \n", 117 | " \n", 118 | " \n", 119 | " \n", 120 | " \n", 121 | " \n", 122 | " \n", 123 | " \n", 124 | " \n", 125 | " \n", 126 | " \n", 127 | " \n", 128 | " \n", 129 | " \n", 130 | " \n", 131 | " \n", 132 | " \n", 133 | " \n", 134 | " \n", 135 | " \n", 136 | " \n", 137 | " \n", 138 | " \n", 139 | " \n", 140 | " \n", 141 | " \n", 142 | " \n", 143 | " \n", 144 | " \n", 145 | " \n", 146 | " \n", 147 | " \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 | "
PassengerIdSurvivedPclassNameSexAgeSibSpParchTicketFareCabinEmbarked
0103Braund, Mr. Owen Harrismale22.010A/5 211717.2500NaNS
1211Cumings, Mrs. John Bradley (Florence Briggs Th...female38.010PC 1759971.2833C85C
2313Heikkinen, Miss. Lainafemale26.000STON/O2. 31012827.9250NaNS
3411Futrelle, Mrs. Jacques Heath (Lily May Peel)female35.01011380353.1000C123S
4503Allen, Mr. William Henrymale35.0003734508.0500NaNS
\n", 203 | "
" 204 | ], 205 | "text/plain": [ 206 | " PassengerId Survived Pclass \\\n", 207 | "0 1 0 3 \n", 208 | "1 2 1 1 \n", 209 | "2 3 1 3 \n", 210 | "3 4 1 1 \n", 211 | "4 5 0 3 \n", 212 | "\n", 213 | " Name Sex Age SibSp \\\n", 214 | "0 Braund, Mr. Owen Harris male 22.0 1 \n", 215 | "1 Cumings, Mrs. John Bradley (Florence Briggs Th... female 38.0 1 \n", 216 | "2 Heikkinen, Miss. Laina female 26.0 0 \n", 217 | "3 Futrelle, Mrs. Jacques Heath (Lily May Peel) female 35.0 1 \n", 218 | "4 Allen, Mr. William Henry male 35.0 0 \n", 219 | "\n", 220 | " Parch Ticket Fare Cabin Embarked \n", 221 | "0 0 A/5 21171 7.2500 NaN S \n", 222 | "1 0 PC 17599 71.2833 C85 C \n", 223 | "2 0 STON/O2. 3101282 7.9250 NaN S \n", 224 | "3 0 113803 53.1000 C123 S \n", 225 | "4 0 373450 8.0500 NaN S " 226 | ] 227 | }, 228 | "execution_count": 2, 229 | "metadata": {}, 230 | "output_type": "execute_result" 231 | } 232 | ], 233 | "source": [ 234 | "data = pd.read_csv(\"C:/Users/Jason Chong/Documents/Kaggle/Titanic/train.csv\")\n", 235 | "data.head()" 236 | ] 237 | }, 238 | { 239 | "cell_type": "markdown", 240 | "metadata": {}, 241 | "source": [ 242 | "# 2.2 Drop unwanted columns " 243 | ] 244 | }, 245 | { 246 | "cell_type": "markdown", 247 | "metadata": {}, 248 | "source": [ 249 | "For the purpose of this tutorial, I proceeded to drop the PassengerId, Name, Ticket and Cabin columns from the original dataset. " 250 | ] 251 | }, 252 | { 253 | "cell_type": "code", 254 | "execution_count": 3, 255 | "metadata": { 256 | "scrolled": true 257 | }, 258 | "outputs": [ 259 | { 260 | "data": { 261 | "text/html": [ 262 | "
\n", 263 | "\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 | " \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 | " \n", 336 | " \n", 337 | " \n", 338 | " \n", 339 | " \n", 340 | " \n", 341 | " \n", 342 | " \n", 343 | " \n", 344 | " \n", 345 | " \n", 346 | " \n", 347 | "
SurvivedPclassSexAgeSibSpParchFareEmbarked
003male22.0107.2500S
111female38.01071.2833C
213female26.0007.9250S
311female35.01053.1000S
403male35.0008.0500S
\n", 348 | "
" 349 | ], 350 | "text/plain": [ 351 | " Survived Pclass Sex Age SibSp Parch Fare Embarked\n", 352 | "0 0 3 male 22.0 1 0 7.2500 S\n", 353 | "1 1 1 female 38.0 1 0 71.2833 C\n", 354 | "2 1 3 female 26.0 0 0 7.9250 S\n", 355 | "3 1 1 female 35.0 1 0 53.1000 S\n", 356 | "4 0 3 male 35.0 0 0 8.0500 S" 357 | ] 358 | }, 359 | "execution_count": 3, 360 | "metadata": {}, 361 | "output_type": "execute_result" 362 | } 363 | ], 364 | "source": [ 365 | "# Drop PassengerId, Name, Ticket and Cabin columns \n", 366 | "\n", 367 | "data = data.drop(['PassengerId', 'Name', 'Ticket', 'Cabin'], axis = 1)\n", 368 | "data.head()" 369 | ] 370 | }, 371 | { 372 | "cell_type": "markdown", 373 | "metadata": {}, 374 | "source": [ 375 | "# 2.3 Drop rows with missing Embarked values" 376 | ] 377 | }, 378 | { 379 | "cell_type": "code", 380 | "execution_count": 4, 381 | "metadata": {}, 382 | "outputs": [ 383 | { 384 | "data": { 385 | "text/plain": [ 386 | "Age 177\n", 387 | "Embarked 2\n", 388 | "dtype: int64" 389 | ] 390 | }, 391 | "execution_count": 4, 392 | "metadata": {}, 393 | "output_type": "execute_result" 394 | } 395 | ], 396 | "source": [ 397 | "# Missing data\n", 398 | "\n", 399 | "missing = data.isnull().sum()\n", 400 | "missing = missing[missing > 0].sort_values(ascending = False)\n", 401 | "missing" 402 | ] 403 | }, 404 | { 405 | "cell_type": "markdown", 406 | "metadata": {}, 407 | "source": [ 408 | "Because there are only two rows with missing Embarked values, I decided to simply drop those two rows from the dataset, leaving us with 177 rows with missing Age values. " 409 | ] 410 | }, 411 | { 412 | "cell_type": "code", 413 | "execution_count": 5, 414 | "metadata": {}, 415 | "outputs": [ 416 | { 417 | "name": "stdout", 418 | "output_type": "stream", 419 | "text": [ 420 | "Before: (891, 8)\n", 421 | "After: (889, 8)\n" 422 | ] 423 | } 424 | ], 425 | "source": [ 426 | "# Drop rows with missing Embarked values \n", 427 | "\n", 428 | "print(\"Before: \", data.shape)\n", 429 | "data = data.loc[data['Embarked'].notnull(), :]\n", 430 | "print(\"After: \", data.shape)" 431 | ] 432 | }, 433 | { 434 | "cell_type": "code", 435 | "execution_count": 6, 436 | "metadata": {}, 437 | "outputs": [ 438 | { 439 | "data": { 440 | "text/plain": [ 441 | "Age 177\n", 442 | "dtype: int64" 443 | ] 444 | }, 445 | "execution_count": 6, 446 | "metadata": {}, 447 | "output_type": "execute_result" 448 | } 449 | ], 450 | "source": [ 451 | "# Check missing values again\n", 452 | "\n", 453 | "missing = data.isnull().sum()\n", 454 | "missing[missing > 0]" 455 | ] 456 | }, 457 | { 458 | "cell_type": "markdown", 459 | "metadata": {}, 460 | "source": [ 461 | "# 3. Explore Age feature\n", 462 | "\n", 463 | "Before we perform imputation on the Age column, let's briefly explore the Age feature. " 464 | ] 465 | }, 466 | { 467 | "cell_type": "code", 468 | "execution_count": 7, 469 | "metadata": { 470 | "scrolled": false 471 | }, 472 | "outputs": [ 473 | { 474 | "data": { 475 | "text/plain": [ 476 | "Text(0.5, 1, 'Correlation between features')" 477 | ] 478 | }, 479 | "execution_count": 7, 480 | "metadata": {}, 481 | "output_type": "execute_result" 482 | }, 483 | { 484 | "data": { 485 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZgAAAE/CAYAAAB7ItUDAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOzdd3gU1frA8e+7m00hPSGFKl16EQVRqqACKmDDeq8FC/7kXntBBCmC6BUVkSJWBHuhWEF6UUCkN+kQAimkB1I2u+f3xyzJJtmQELLZkJzP8+xDZubszHt2l3nnnDNFlFJomqZpWkUzeToATdM0rXrSCUbTNE1zC51gNE3TNLfQCUbTNE1zC51gNE3TNLfQCUbTNE1zC51gaigROSIi/cr53h4i8o8bYmokIkpEvCp63VWFiDwmIvEikiki4Z6OR9PcSScYDxGRu0Vkk2NHc1JEfhWR7p6OyxXHTr/Z2Wml1Bql1KWejKmoiyE5iYgFeAu4TikVoJRKuoB1Vfn6appOMB4gIk8D7wCTgCigITADGFyOdRXbweidTpUVBfgCuzwdiBj0/3/NrfQPrJKJSDAwHnhcKfWDUuq0UsqqlPpRKfWco4yPiLwjIiccr3dExMexrLeIHBeRF0QkDvjE1TxH2RtFZKuIpIrIHyLSvoSYuojIn45yJ0XkPRHxdixb7Si2zdHauuPs9pze30pEVjrev0tEBjkt+1REpovIzyKSISIbRKRpKR/Tg456nxSRZ5zWZRKRF0XkoIgkicg3IhLmWHw2zlRHnN1E5KiIdHa8917HEX9rx/RDIrKgDOtFRK50fH6pIrJNRHo7LVspIhNEZJ2jfktEpLaLz7gFcLZbMVVEljvmtxSR30UkWUT+EZGhTu+5QUS2iEi6iMSIyFinVbqq71gRmef0/kKtHEesE0VkHXAGaCIiwSLykeOzjhWRV0XE7CjfTERWiUiaiJwSka9L+d40rTCllH5V4gvoD+QBXucoMx5YD0QCEcAfwATHst6O978O+AB+Jcy7DEgAugJm4D7gCODjWM8RoJ/j787AlYAX0AjYAzzpFI8CmjlN9waOO/62AAeAlwBv4BogA7jUsfxTIBno4lj/58BXJdS7kWNbXwL+QDsg0SnOJx2fS31HPd8HvizyXi+n9X0GPOP4ezZwEHjMadlTZVhvPSAJGIhxQHatYzrCsXylY70tHJ/7SmByKfXzckz7AzHAA47P5jLgFNDG6XNu59hueyAeGHKO+o4F5p1jeyuBY0Abx/YswAJHff0xfm8bgUcd5b8ERjm27wt09/T/H/26uF4eD6CmvYB7gLhSyhwEBjpNXw8ccfzdG8gFfJ2Wu5o3E0dScpr3D9DL8fcRHDtuF9t/EpjvNH2uBNMDiANMTsu/BMY6/v4U+NBp2UBgbwnbPbtDbOk07w3gI8ffe4C+TsvqAFYKEmPRHe4wYJHTex/CkdyAo8BlZVjvC8DcInEuBu5z/L0SeNlp2f8Bv5VSv7M7/DuANUXKvA+8UsL73wHedrUux7yxlJ5gxjstjwJyAD+neXcBKxx/f4aRmOt7+v+Nfl2cL91FVvmSgNqljJPUxdgBnnXUMe+sRKVUdpH3FJ13CfCMo1snVURSgQZF1gMY3Tci8pOIxIlIOsbYULFunnPEGqOUsheJt57TdJzT32eAgFLWGVNkXWdjvgSY71SfPYANY0fpyiqgh4hEY7TivgauFpFGQDCwtQzrvQS4vcjn2B0jCZW3fmddAnQtsu57gGgAEekqIitEJFFE0oDhlP17KYnzZ3sJRivmpNP238doyQA8Dwiw0dH1+eAFblurYXSCqXx/AtnAkHOUOYHxn/+sho55Z7m6BXbReTHARKVUiNOrllLqSxfvnQnsBZorpYIwuruklHo4x9pACg8YNwRiy/h+VxoUWdfZuscAA4rUyVcpFYuLz0QpdQBjh/9fYLVSKgMjGTwCrHVKiudabwxGC8Z5mb9SavIF1O+sGGBVkXUHKKUecyz/AlgENFBKBQOzKPheXP0GTgO1nKajXZRxfl8MRgumttP2g5RSbQCUUnFKqYeVUnWBR4EZ4nQ2oaaVRieYSqaUSgPGANNFZIiI1BIRi4gMEJE3HMW+BF4WkQjHgPEYYF5J6yzBB8Bwx1GwiIi/Y9A40EXZQCAdyBSRlsBjRZbHA01K2M4GjB3b84569AZuAr46z3idjXZ8Lm0wxifODi7PAiaKyCUAjs/n7Jl3iYDdRZyrgBGOf8HoJnKeLm2984CbROR6ETGLiK8YJznUv4D6nfUT0EJE/uX47CwicoWItHIsDwSSlVLZItIFuNvpva7quxXoKSINxTiZZOS5Nq6UOgksAaaISJDjZIemItILQERud6pnCkZysl1gnbUaRCcYD1BKvQU8DbyMsaOIwdjpLXAUeRXYBGwHdgCbHfPOZxubgIeB9zB2DgeA+0so/izGzisDIzEVPVtoLDDH0Y0y1HmBUioXGAQMwBigngH8Wym193ziLWKVI95lwJtKqSWO+VMxjuiXiEgGxsB8V0ccZ4CJwDpHnFc6rSuQgrOuik6Xtt4YjNPHX6Lgu3qOCvi/42hRXQfcidFKi6PgRA0wxnPGO2IaA3zj9N5i9VVK/Y7x3W0H/sZIYKX5N8bJGbsxfiffUdD9dwWwQUQyMT6fJ5RSh8tfY62mEaX0A8c0TdO0iqdbMJqmaZpb6ASjaZpWzYnIxyKSICI7S1guIvKuiBwQke0icllFbFcnGE3TtOrvU4yLvEsyAGjueD2CcWbpBdMJRtM0rZpTSq3GuKNGSQYDnynDeiBEROqco3yZ6ASjaZqm1aPwRbjHKXyxdLm4/a67P1surVanqS2a8KenQ6hQ3a4MK73QRcTf1156oYtInaAsT4dQoRpajnk6hArXsHmrsl6UXKry7i9vzNv3KEbX1lmzlVKzz2MVrupwwftufVt3TdO0i5wjmZxPQinqOIXvoFGfwncPKRfdRaZpmlZFiEXK9aoAi4B/O84muxJIc9zp4YLoFoymaVoVYfKqsN62QkTkS4y7oNcW41lOr2Dc6BSl1CzgF4w7nZ+9f98DFbFdnWA0TdOqCLG4p1NJKXVXKcsV8HhFb1cnGE3TtCrCXS0YT9EJRtM0rYqooPGUKkMnGE3TtCpCt2A0TdM0t9AtGE3TNM0tdAtG0zRNcwsx6wSjaZqmuYFJJxhN0zTNHcSkE4ymaZrmBmKuXnfv0glG0zStitBdZJqmaZpb6C4yTdM0zS10C0bTNE1zC32aciVr/8EkIgf2JjchidWdbnJZpvXbo4js3wtbVjbbhr1I+pbdANT71xCaj3wMgP2vzSR27oJKi7s0d/SrRdumFnKtik9/Pk1MvK1Ymf8ODSAowIRZYP/xPL5ccgbl9Iy5a7v4cts1tXh6agqnszz34FClFL9/PZGDO1dh8fblxvsnE92wTbFyJ4/u5OdPR2K1ZtO0bS+uvWMUIkJ8zB5++/wV8qw5mExmrr97LHUbt/dATQxKKX7+fBL7tq3G4u3LrQ9Pom6j4vWJPbyLHz4ciTU3hxYdenLDPS8hIiz9fip7Ni9HTCb8A8O49eHXCAqN9EBNDDs2r+PLj95E2W306HczA28tfCd2qzWXj6aO5ujBPfgHhjD82cnUjqxLXp6VOdMncPTQXuy2PLr1uZEbbn3QQ7Uo8Nffm5kx+0PsdjsDrruWO2+/tdDy7+Yv5Nclv2M2mwkOCuLZJ/9DVKTx+SckJDJl2nskJiYhAhPHjiY6KsoT1agRqvwpC8fn/MDGGx8qcXlE/574N2vEylbXseOx0bR9bywAltBgWrw8gnVXD2XtVbfT4uUReIUEVVLU59a2iYXIUBOj309j3m+nued6f5flZi/I5NWP0xn3UTqBtUx0bumdvyw00ESrRhaS0oonpsp2cOdqUhKOMHzCEgbcO4HfPh/rstziL8bS/97xDJ+whJSEIxzatRqA5d//j+43Ps6w0QvpMegJVvzwv0qMvrh921eTFHeUp974jSEPjGPRnPEuyy2aM47BD4zjqTd+IynuKPu3rwGg+8Bh/GfiQkZMmE/Ljr1ZsXBGZYZfiN1m4/PZr/PU6GlMePd7Nqz9jRMxhwqVWbN0AbX8g3ht5iKuvekevvtsKgCb/liKNS+X8VO/YfSUz1m1+HtOJVzwQw4viM1mY9rM95k0bgwfzpjGilVrOHosplCZZk2bMP3tKcx+byo9u1/FB5/MyV/2+lvvMPSWm/l41nu899b/CAkOqewqnJOYTOV6VVVVNzKH5LWbsCanlbg8alBfYucZLZPUDduwBAfhEx1BxHXdSVy2DmtKGnmp6SQuW0fk9T0qK+xz6tDcwvqduQAcPmHDz0cI8i/eNM42imAygZeZQk/Ivr1vLX5YeebCH5pdAfZvW0bbK4cgItRr0pGcrHQy0xIKlclMSyAnK5P6TTshIrS9cgj7ti4DQETIyToNQE5WBgHBnjvaB9izeTkdrx6MiNCgWUeyz6STkVq4PhmpCeRkZ9KwmVGfjlcPZvdmoz6+fgH55XJzslw+7LyyHNq/k8g69YmIro+XxUKX7tezZePKQmW2blzJVX1uBODyq/qyZ/tfKKUQEXKzs7DZ8rDm5ODlZcHXz/XBUGX5Z99+6tapQ53oaCwWC717dueP9RsKlenYvh2+vj4AtLr0UhJPJQFw9FgMNrudzp06AuDn55dfrqoQk5TrVVVV+S6y0vjWjSLreFz+dHZsHL71ovCtG0V2jNP84/H41q0aTeGQQBPJGfb86dQMO6GBJtJPu+omC6RRXTO7Dlr5+x8j47RvZiE1087xBM+3XgAyUuMJCovOnw4MiSYjJb5QoshIiScotKBMUGg0GanxAPQb+hJfTx3G8u9fRyk7/37+q8oL3oWMlHiCw51iDYsmPSWBwJCC+qSnJBAUWvB7Cg6LIiMlPn/69+/eYcu6hfj6BTDsxYIj6MqWmpxIWO2CuoSGR3J4385CZVKSCsqYzV741QogMyOVzt36smXjSp5+8Dpyc7K588FnCAgMrtT4izqVlExERO386dq1w9n7z/4Sy/+6ZCldOl8GwPHYWAL8/Rk7cTJx8fFc1rEDw+77F2az2e1xl1V1G+Q/ZwtGRDJEJL2kV2UFeS4ixb8QpRSUNL8KcPUTKim0d7/J4PlpqXh5CS0v8cLiBQOv8mPRmiy3xnheXAVf5PNXLtpa4vgkNq/6kr5DRzJi8ir63T6SXz4b5ZYwy8pVrEW/NZe/Jac6X3vbkzz/9go6dLuJ9Us/r+AIy660OB2lihdBOLx/FyaTmSkfLeb1WT+xeOE8EuOOuyfQMnL5Oyphn7x0xUr2HTjA7bfeDIDNZmfHrt08Oux+pr/9Jifj4liybLkboz1/NaoFo5QKBBCR8UAcMBfjf9o9QGBJ7xORR4BHAEaYIulvcl8/Z1ZsHH71o0lxTPvWiybnRALZsXGE9eqSX863fhTJqza6LY7S9L7Mh+4djOb4kZN5hAWaOOhYFhJoIjXTXuJ782ywbX8uHZp7k3ZaER5sYvSDxnhSaKCJl+8P4rXP0kk/XXkJ9O8Vn7N17TcA1GnUjvTkgtZiRmpcoaN9MFos6SkFZdJT4ghwlNn553yuvcNIKi07D+CXuS+7O/xi1i/9nE2rvgOgXuO2pCU5xZocR1BoRKHywWFRpDu1WNKS44vVGaB9txuY+9Zw+t7yHzdFfm6h4ZEknyqoS0pSAiFhES7LhNWOwmbLI+tMJv6BwWxY/SttO3XDy8tCUEgYzVp24MjB3URE16/sauSLCA8nMfFU/vSpU0mEh4UVK7d56za++Po7pkx+FW+LBTBaO82aNKZOtNFau+rKruz5Zx8DKif0MqnK4ynlUdbaXK+UmqGUylBKpSulZgK3llRYKTVbKXW5UupydyYXgIQfl1Pv3iEAhHTtQF56BjlxiSQuWUtEv+54hQThFRJERL/uJC5Z69ZYzmXl5hxe/SSdVz9JZ+t+K1e2NQbsG9c1k5WjiiUHHwv54zImgXZNLcQl2TiRaOO5aamMmpnGqJlppGTYefXTyk0uAJ373MOw0QsZNnohLTr2Y+f6BSiliD20FR+/wGLjKAHBkXj7+hN7aCtKKXauX0DzDn2NZSGRHNtnJP+je9cTFtmoUusCcGW/exgxYT4jJsyn9WV92bpuIUopYg4Y9SmaPAJDIvHx9SfmgFGfresW0uqyawA4FXckv9zeLSuIqNOkMqtSSOPmbYg/GUNifCx5Visb1y6m4xW9CpXpeEUv/ljxEwCb/lhGy3ZXICKERdRh7w5jPCYnO4tD+3YQXa+RB2pR4NIWzYk9cZKTcfFYrVZWrl5Lt65dCpU5cPAQ77w3g/GjXyI0pGD/c2nzZmRmniY1zRjT3bp9B5c0aFCp8ZemRrVgnNhE5B7gK4z29F1ApQwAdJw7hfBeXfCuHco1h1exf/w0xGKEfWz2VyT8uoqIAb3ovfd3bFlZbH/oJQCsKWnsnzSD7n8aR6X7J07HmlLyyQKVaedBK+2aWHj10WByrYo5v5zOX/byA0G8+kk63hbh8dsC8TIbCeafY3ms3pLjwahL1rRtLw7uWMWsl6/F4u3HDfdNyl/20YTBDBu9EID+d4/lpzkjycvNpknbnjRt2xOAAf+awNKvJ2G352H28qH/va7P2qosLTr0Yt/21bz13PV4+/hyy0MF9Xlv9M2MmDAfgEH3vcL3HzhOU27fgxbtjfos+fYtTp08jIiJkNp1GXzfWE9UAzDGVO55+AXeHvc4drud7n0HUa9hUxZ8MZNGzVrTsUsvevQbwgfvjGbkY4PwDwjm0WdeA+CaAUP5eNpYxjxxO0opul8ziAaNWnisLkZ9zIwY/jAjx4zDbrdx/bX9aHRJQz6d9wUtmjfjqq5dmP3xp2RlZzNh8hsAREZEMGHMKMxmM48Mu5/nR41BKUXzZk0ZeP21Hq1PUdVtDEbKMi4hIo2AqcDVGAlmHfCkUupIae/92XJp1Rj4qCCLJvzp6RAqVLcri3cvXMz8fUvuarwY1QmqQmNtFaCh5ZinQ6hwDZu3qrCssPvmvuXaX7aev6xKZqYytWAciWSwe0PRNE2r2WrkGIyItBCRZSKy0zHdXkQqfyRW0zStGqtuYzBlTZcfACMBK4BSajtwp7uC0jRNq4mqW4Ip6yB/LaXUxiLXnOS5IR5N07Qaqyoni/IoawvmlIg0xXFFlojcBpx0W1Sapmk1kLvuRSYi/UXkHxE5ICIvuljeUERWiMgWEdkuIgMroj5lbcE8DswGWopILHAY42JLTdM0rYK44zRlETED04FrgePAXyKySCm126nYy8A3SqmZItIa+AVodKHbLmuCOaqU6ici/oBJKZVxoRvWNE3TCnNTF1kX4IBS6hCAiHyFcVawc4JRwNnbzQcDFXLb7LImmMMi8hvwNVC1bt6jaZpWTbjpNOV6gPMzDY4DXYuUGQssEZH/AP5Av4rYcFlrcymwFKOr7LCIvCci3SsiAE3TNO3CiMgjIrLJ6fWI82IXbyl6QeddwKdKqfrAQGCuiFxwtivrhZZZwDfANyISinFV/yqg6tznWtM07SJX3i4ypdRsjHFyV44Dzjddq0/xLrBhQH/Huv4UEV+gNpDABShzhhKRXiIyA9gM+AJDL2TDmqZpWmFuug7mL6C5iDQWEW+MaxgXFSlzDOgLICKtMPbxiRdanzK1YETkMLAVoxXznFLqdClv0TRN086TO8ZglFJ5IjICWIzR6/SxUmqX4zEsm5RSi4BngA9E5CmM7rP7VQU8QKusg/wdlFJV4gFjmqZp1ZW7LrRUSv2Cceqx87wxTn/vxriZcYU6Z4IRkeeVUm8AE0WkWDZTSv23ogPSNE2rqarbzS5La8Hscfy7yd2BaJqm1XglPf/5IlXaI5N/dPy5XSm1pRLi0TRNq7Gq273IyjoG85aI1AG+Bb5SSu1yY0yapmk1UnXrIitTbZRSfYDeGKetzRaRHfp5MJqmaRWrpt6uH6VUHPCuiKwAngfGAK+W9r7q9ojhQaO7eTqECvXtqNWeDqFCPTQ0wNMhVKj0bG9Ph1Ch7n7hgq7bq5LW/tiqwtZV3VowZb0OphVwB3AbkAR8hXHetKZpmlZBqnJrpDzK2oL5BPgSuE4pVSF32dQ0TdMKq3EJxvEsgYNKqamVEI+maVrNVdO6yJRSNhEJFxFvpVRuZQSlaZpWE0lNug7GyVFgnYgsAvLvQ6aUesstUWmaptVANXKQH+PWzicwTmsOdF84mqZpNVeNG4MBUEqNc3cgmqZpWvVS1tOUV1D8CWgopa6p8Ig0TdNqqhraRfas09++wK1AXsWHo2maVnPV1C6yv4vMWiciq9wQj6ZpWo0lUgNbMCIS5jRpAi4Hot0SkaZpWk1VE1swwN8UjMHkAUeAYe4ISNM0raaqUacpi8gVQIxSqrFj+j6M8ZcjwG63R6dpmlaDVLcxmNLS5ftALoCI9AReA+YAacBs94amaZpWw4ipfK8qqrQuMrNSKtnx9x3AbKXU98D3IrLVvaFpmqbVLNWtBVNqghERL6VUHtAXeOQ83qtpmqadj5o0BoNxi/5VInIKyALWAIhIM4xuMk3TNK2C1KibXSqlJorIMqAOsEQpdfZMMhPwH3cH5+yOfrVo29RCrlXx6c+niYm3FSvz36EBBAWYMAvsP57Hl0vOoJzuP3BtF19uu6YWT09N4XRWsRsTVIr2H0wicmBvchOSWN3pJpdlWr89isj+vbBlZbNt2IukbzHOp6j3ryE0H/kYAPtfm0ns3AWVFndp7hkQSPvm3uRaFR8uSOfoyeLX4T5zbwjBASbMJmHfsVw++zkDpeCx24KpU9sMQC1fE2ey7YyZlVzs/ZVlx+Z1fPnRmyi7jR79bmbgrQ8UWm615vLR1NEcPbgH/8AQhj87mdqRdcnLszJn+gSOHtqL3ZZHtz43csOtD3qoFgX2bF3L/M8mo+w2uva5lX6DHyq0PM+ay+czRnL88G5qBYRw3xNvEhZRj3+2/8FPX72DLc+K2cvCoLufoXnbrh6qRWFPPNKUbp3Dyc6xMWnqP+w7mFmszLRJHQgP9SYn1w7AU2O2k5pmZUDfKP7vgSacSjJuDv/9z7H8tCSuUuMvUQ1rwaCUWu9i3j73hONa2yYWIkNNjH4/jcZ1zdxzvT+TP0svVm72gkyyHQ8UePTmADq39GbTHmNGaKCJVo0sJKUVT0yV6ficHzgyYx4dP37d5fKI/j3xb9aIla2uI6RrB9q+N5Y/rh6KJTSYFi+PYO2Vt6KUoseGH4j/cTl5qcU/h8rWvrk3UWFmXng3iab1Lfz7hiAmfFg8QUz/No3sHCOxjxgaTJc2PmzYmcPM7woaw3deF8CZHM8kfwC7zcbns1/nmbEzCA2PYsLz99KxSy/qNmiSX2bN0gXU8g/itZmL2LBmMd99NpXhz77Opj+WYs3LZfzUb8jJyWL0f26ja4/+1I6s67n62G18/8mrDH/pA0LCo3l71B207dyH6PpN88usX/EDfv5BjHrnVzb/8Qs/fvEW9z0xBf/AUB569j2CwyI5GbOf9197lLEzlnusLmdd2TmMBnVrceejG2lzaSDPPtacR57d4rLsuCl7+OdA8eSzfE0ib79/wN2hnrfqNgZzUaTLDs0trN9pJIrDJ2z4+QhB/sW/iLPJxWQCLzOF7p52e99a/LDyTPEbqlWy5LWbsCaX3LsYNagvsfOMlknqhm1YgoPwiY4g4rruJC5bhzUljbzUdBKXrSPy+h6VFfY5dbrUh3XbsgE4eNxKLV8hOKD4T+tscjGbwMsshVqXZ13RxpcNO7LdGu+5HNq/k8g69YmIro+XxUKX7tezZePKQmW2blzJVX1uBODyq/qyZ/tfKKUQEXKzs7DZ8rDm5ODlZcHXz98DtShw7MAOakc3pHZUA7y8LHTqNoCdmwoniZ1/L6dLz8EAdOh6Hft3bkApRf3GrQgOiwQgun4zrNYc8qyefyRUjyvD+W250eLY9U8GAf5ehId6eziqClLDziIDQESaAseVUjki0htoD3ymlEp1Z3BnhQSaSM6w50+nZtgJDTSRftpVN1kgjeqa2XXQyt//GP8Z2jezkJpp53iCZ1svZeFbN4qs4wXN9ezYOHzrReFbN4rsGKf5x+PxrRvliRCLCQ0yk5xekBRS0m2EBplIy7QXK/vMvSE0qWdh+4Ec/tqdU2hZi0sspJ+2E5/sue8pNTmRsNoFN6kIDY/k8L6dhcqkJBWUMZu98KsVQGZGKp279WXLxpU8/eB15OZkc+eDzxAQGFyp8ReVmpJASHhBfYLDozh2YEehMmnJBWXMZi98awVwOiOVgKDQ/DLbNv5OvUat8LJ4fkdeO9yHhFMFv52EpBxqh3uTlFI8+b30xKXY7bDyj0TmfH0sf36vq2rToU0wMSeymPbhwULr8yg3tWBEpD8wFTADHyqlJrsoMxQYi3Fovk0pdfeFbresqe97wOYY3P8IaAx8caEbLytXH7mro1+Ad7/J4PlpqXh5CS0v8cLiBQOv8mPRmiy3xlhRXA3yKaWgpPlVwPl8P1PmpfLklEQsZqF148I7qyvberb1AiV8psU+++JlBOHw/l2YTGamfLSY12f9xOKF80iMO+6eQMvK5RchRYq4qI9TnU/GHOCnL95i6ENjKjq6cnG5C3ZRzXFv7uG+//zN/724lQ5tgunfxzggW7cxiduHbeD+//7Npq0pjHryUrfGez5ETOV6nXudYgamAwOA1sBdItK6SJnmwEjgaqVUG+DJiqhPWROM3XGq8s3AO0qppzAG/l0SkUdEZJOIbNqzcU65Aut9mQ8vPxDEyw8EkZppJyywINSQQBOpLo6Oz8qzwbb9uXRo7k1EqJnwYBOjHwxi4mPBhAaaePn+IJddbFVBVmwcfvULjjh960WTcyLBaMk0cJpfP4qckwmeCBGAvlf4MX54GOOHh5GaYSMsyJy/LDTITGpGyd+PNQ+2/JNDp5Y++fNMJujcyocNuzybYELDI0k+VdBSTElKICQsosQyNlseWWcy8Q8MZsPqX2nbqRteXhaCQsJo1rIDRw569oYXIWFRpCYV1CctKZ7g0ML1CQkvKGOz5ZF9JtMO0r8AACAASURBVJNaAUbLKzUpjk/eeoK7/28StaMaVl7gRdwysC6fTO3MJ1M7cyo5l8jaBb+dyHAfTiUXb72cnZeVZeP3VQm0amE8KzE9Iw9rnpGRflxykkubVaFnKJqkfK9z6wIcUEodcjz2/itgcJEyDwPTlVIpAEqpCtm5lDXBWEXkLuA+4CfHPEtJhZVSs5VSlyulLm/V5b5yBbZycw6vfpLOq5+ks3W/lSvbGke7jeuaycpRpJ8ufMjiYyE/aZgE2jW1EJdk40SijeempTJqZhqjZqaRkmHn1U/Ti72/qkj4cTn17h0CQEjXDuSlZ5ATl0jikrVE9OuOV0gQXiFBRPTrTuKStR6Lc9lfWYyZlcyYWcls3pvD1R18AWha30JWjirWPebjXTAuYzJB++Y+nDxVcKZZmybenDxlIyW95MRUGRo3b0P8yRgS42PJs1rZuHYxHa/oVahMxyt68ccK47/Bpj+W0bLdFYgIYRF12LvDGI/Jyc7i0L4dRNdr5IFaFGjQtC2JccdISjhOXp6VLX/+SpvOfQqVadu5DxtXLwRg24YlNGvTFREh63Q6H7zxf9xw55M0ufQyT4Sf74dfTvDAE3/zwBN/s2b9KfpfYxxstbk0kMwzecW6x8wmCA4yRgDMZuGqK8I5dNR42rvzeE33LuEcjTlTSbXwmHpAjNP0ccc8Zy2AFiKyTkTWO7rULlhZL5Z8ABgOTFRKHRaRxsC8igigLHYetNKuiYVXHw0m16qY88vp/GUvPxDEq5+k420RHr8tEC+zkWD+OZbH6i1VpF/VSce5Uwjv1QXv2qFcc3gV+8dPQyzG13Bs9lck/LqKiAG96L33d2xZWWx/6CUArClp7J80g+5/fgfA/onTsaZUjUuRtu3PpX1zH974bzg5VsVHCwvObBs/PIwxs5LxsQhP3BWCxQtMIuw5nMuKTQXdll3b+rJhp2dbL2CMQdzz8Au8Pe5x7HY73fsOol7Dpiz4YiaNmrWmY5de9Og3hA/eGc3IxwbhHxDMo8+8BsA1A4by8bSxjHnidpRSdL9mEA0atfB4fW69/yXef+1R7HYbXXvfTJ0Gzfj12/do0LgNbS/vQ9fet/D5jJFMfHIAtQKC+dd//gfAmsVfcio+hiXzZ7Fk/iwAho+cTWBwuCerxJ+bkul2eRhfz+6Sf5ryWZ9M7cwDT/yNxWLirXHtMZsFs1nYtDWFH5ecBOC2m+rRvWs4NpsiPSOPiVP3eqoqxZT3Zpci8giFL4SfrZQ6ezsvl73YRaa9gOZAb6A+sEZE2l7oOLucbz++iIQCDZRS28tS/tHJyVWzqVBOg0Z383QIFerbUas9HUKFemhogKdDqFDp2Z4fVK9Ik175w9MhVLi1P/aqsP72Mx+/Uq79Za0Hx5UYg4h0A8Yqpa53TI8EUEq95lRmFrBeKfWpY3oZ8KJS6q/yxHNWmdKliKwUkSDHc2G2AZ+IyFsXsmFN0zStCJOpfK9z+wtoLiKNRcQbuBNYVKTMAqAPgIjUxugyO3TB1SljuWClVDpwC/CJUqoz0O9CN65pmqY5ESnf6xwcJ2iNABYDe4BvlFK7RGS8iAxyFFsMJInIbmAF8JxSKulCq1PWMRgvEakDDAVGXehGNU3TtOLc9cAxpdQvwC9F5o1x+lsBTzteFaasCWY8RoZbq5T6S0SaAPsrMhBN07QarwpflV8eZUowSqlvgW+dpg9hPNlS0zRNqyjV7F5kZb1VjC8wDGgD+J6dr5Ty/K1iNU3TqonSrsq/2JS1NnOBaOB6YBXGedIZ7gpK0zStRnLPlfweU9YE00wpNRo4rZSaA9wAtHNfWJqmaTVQTbybMmB1/JsqIm2BOKCRWyLSNE2rqWrSEy2dzHZcwT8a4wKdAKBq3FpV0zStuqhpT7QEUEp96PhzFdDkXGU1TdO0cqrC3V3lcc4EIyLnvOhGKaVvF6NpmlZRqvCAfXmU1oKpQg9K0DRNq+ZqUgtGKTWusgLRNE2r8arZIH9Z76Y8R0RCnKZDReRj94WlaZpWA7nnbsoeU9bI2js/eMbxWM1O7glJ0zRNqw7KepqySURCzz6v2fFcmLK+V9M0TSuLatZFVtYkMQX4U0S+xXjU5lBgotui0jRNq4lq0iD/WUqpz0RkE3ANxvOdb1FK7S7Le7tdGXYB4VU91e0Rw7dP7OnpECrUV0EbPR1ChapX37f0QheRN964zNMhVG1VeDylPEq7DsYXGA40A3YAsxxPR9M0TdMqWg3rIpuDcR+yNcAAoBXwpLuD0jRNq5FqWBdZa6VUOwAR+QioXv0PmqZpVUkNa8GcvYsySqk8qWaV1zRNq1Jq0hgM0EFE0h1/C+DnmBZAKaWC3BqdpmlaDaKq2UF8abeKMVdWIJqmaTVeDRuD0TRN0yqLTjCapmmaO9SoLjJN0zStEukWjKZpmuYWugWjaZqmuUU1O025etVG0zTtIqZEyvUqjYj0F5F/ROSAiLx4jnK3iYgSkcsroj66BaNpmlZVuGEMRkTMwHTgWuA48JeILCp6w2IRCQT+C2yoqG3rFoymaVr11gU4oJQ6pJTKBb4CBrsoNwF4A8iuqA3rBKNpmlZFKDGV6yUij4jIJqfXI06rrQfEOE0fd8zLJyKdgAZKqZ8qsj66i0zTNK2qKOdZZEqp2cDsktbq6i0FmxQT8DZwf7k2fg46wWiaplURyj3XwRwHGjhN1wdOOE0HAm2BlY4bGkcDi0RkkFJq04Vs+KJIMEopfv96Igd3rsLi7cuN908mumGbYuVOHt3Jz5+OxGrNpmnbXlx7xyhEhPiYPfz2+SvkWXMwmcxcf/dY6jZu74GaFLhnQCDtm3uTa1V8uCCdoyeLP8ftmXtDCA4wYTYJ+47l8tnPGSgFj90WTJ3axm3iavmaOJNtZ8ys5MquAgDtP5hE5MDe5CYksbrTTS7LtH57FJH9e2HLymbbsBdJ32KMLdb71xCaj3wMgP2vzSR27oJKi7s0t/XxpU1jL3KtMHfxGY4n2IuV+b9bahHkb8IscDA2j6+XZ6MUdGruxcBuvkSFm3jzi9Mci7d5oAaFXdtJaBotWG3w00Y78anFy/RsK7RrJPhaYMr8gvoG1YIbrjBRyweycuHHDXYysiox+CJ2bP6DLz58E7vdTs9rh3DDrfcXWm615vLBO69w9OAeAgKDeezZ16gdVZc8q5U5Mydx+MBuTCYTdw97hpbtKuRkqYrjnutg/gKai0hjIBa4E7j77EKlVBpQuyAEWQk8e6HJBS6SMZiDO1eTknCE4ROWMODeCfz2+ViX5RZ/MZb+945n+IQlpCQc4dAu4/HGy7//H91vfJxhoxfSY9ATrPjhf5UYfXHtm3sTFWbmhXeT+PTHDP59g+ubUk//No0xs5IZNSOJwFomurTxAWDmd8b8MbOS2bQ7m017cioz/EKOz/mBjTc+VOLyiP498W/WiJWtrmPHY6Np+95YACyhwbR4eQTrrh7K2qtup8XLI/AKqRo3527d2IuIEBPjPs7ky6VZ3NnXz2W5j386w+S5mUz8LJOAWiYua2EB4ESSnQ9+PMPB455PLABNoyE0QJj1q51fN9np39n1f/sDJxSfLi2eSK/pYGLnEcVHS+ys222ndzvPXQxot9mY+/7rPDXmXSZO+5YNaxYTG3OoUJk1vy/EPyCQ12ct4LpBd/PNZ9MAWPX7fABeffdrnh07na8+eQe7vXh9PUpM5Xudg+MpxCOAxcAe4Bul1C4RGS8ig9xZnYsiwezftoy2Vw5BRKjXpCM5WelkpiUUKpOZlkBOVib1m3ZCRGh75RD2bV0GgIiQk3UagJysDAKCIyu9Ds46XerDum3GiRoHj1up5SsEBxT/KrJzjG5Sswm8zIJSxYpwRRtfNuyosJM+zlvy2k1Yk9NKXB41qC+x84yWSeqGbViCg/CJjiDiuu4kLluHNSWNvNR0EpetI/L6HpUV9jm1b+rFxt3Go5COnLTh5yME+RffqWbnGv+aTMZ3dPb7iU+2k5BSdXZczesJO48YwZ1IBh8L+PsWL3ciGU67+CnVDoIjCcb7jyYY6/OUQ/t3EVmnAZHR9fGyWOjS/Tq2bFhVqMzmjau4us+NAFx+VV/2bN+IUooTMYdp1f4KAIJCwqjlH8iRA7uLbcOT3HUdjFLqF6VUC6VUU6XURMe8MUqpRS7K9q6I1gtcJAkmIzWeoLDo/OnAkGgyUuILl0mJJyi0oExQaDQZqUaZfkNfYsX3b/Dei71Y/v3r9L756coJvAShQWaS0wuOblPSbYQGuf4qnrk3hHefiyAr185fuwu3VFpcYiH9tJ345KpxpOyKb90oso7H5U9nx8bhWy8K37pRZMc4zT8ej2/dKE+EWExIgImUjIIEkZqpCHFxAADw+C21mDw8iByrYst+q8synhboJ6RnFRydZGRBoOtGmUsJqYpL6xs7sRb1wMci+HlXdJRlk5KcQFjtgt9JWHgkKcmFDzZTncqYzV741QogMyONBo2as2XjKmy2PBLjYzlycA/JpwrvRzzODS0YTyp1DEZEooBJQF2l1AARaQ10U0p95PboznJ16F4kayuKlxHHyRObV31J36EjaXnZ9ezZ9Au/fDaKu5761B2RlonLUzpcVBFgyrxULF7w6C3BtG7sza5DufnLrmzr2dZLWbh6CqpSymVfsyrpQ6gCSopt+g9n8DLD/QNrcWkDL/YeKz6WdrFbvk1x3WUm2jUSYhIV6WcUdk99Va52BUX+R7ncXQA9+g3i5PHDjHvm34RHRtOsZXtM5qr1yCvlcu9w8SrLIP+nwCfAKMf0PuBroMQE4zgH+xGA+55+n943PVJS0RL9veJztq79BoA6jdqRnlxwtJuRGkdgSOFurqDQaNJTCsqkp8QR4Ciz88/5XHuHEX7LzgP4Ze7L5x3Phep7hR+9OhuHjYdjrYQFmTn7ROrQIDOpGSV3qVjzYMs/OXRq6ZOfYEwm6NzKh7GzPTO4X1ZZsXH41Y8mxTHtWy+anBMJZMfGEdarS3453/pRJK/a6JkggZ4dvLmqnXFYfjTeRmigCTBahiEBQtrpkveoeTbYcdBKu2ZVJ8Fc1kzo2NjYWZ1MUQT5CWf3zoF+nNcgfWY2/PCH8fu0eMGl9YUcDzXWQsMjC7U6kpMSCAmLcFkmrHYUNlseWWcy8Q8MRkS4a9gz+eVefeFBouo2rLTYy8JNZ5F5TFlqU1sp9Q1gh/wBo3P2ySilZiulLldKXV6e5ALQuc89DBu9kGGjF9KiYz92rl+AUorYQ1vx8QssNo4SEByJt68/sYe2opRi5/oFNO/Q11gWEsmxfcbO6+je9YRFNipXTBdi2V9Z+QPzm/fmcHUHoxO8aX0LWTmKtMzCCcbHu2BcxmSC9s19OHmqYOfVpok3J0/ZSEmvOn39riT8uJx69w4BIKRrB/LSM8iJSyRxyVoi+nXHKyQIr5AgIvp1J3HJWo/FuXpbLpPnZTJ5XibbD1jp0toYsG9Ux0xWriK9SILxtpA/LmMS48SA+OSq811sPqD4+Hc7H/9uZ1+som0jI9a6YZBjdT3WUhLn7rBuLYXthz3X0mzcvDUJJ2NIjI8lz2pl49oldOrSs1CZTl16sm6Fcb3gpj+W0ardFcY4bE42OdlGZt21dT1ms5l6DZpUeh3OqaZ1kQGnRSQcx+GPiFwJlDyq6wZN2/bi4I5VzHr5Wizeftxw36T8ZR9NGMyw0QsB6H/3WH6aM5K83GyatO1J07bGD2/Avyaw9OtJ2O15mL186H/v+MoMv5ht+3Np39yHN/4bTo5V8dHC9Pxl44eHMWZWMj4W4Ym7QrB4gUmEPYdzWbGp4LCza1tfNuz0fPdYx7lTCO/VBe/aoVxzeBX7x09DLMbP6tjsr0j4dRURA3rRe+/v2LKy2P7QSwBYU9LYP2kG3f/8DoD9E6djTanUn1WJdh3Oo01jL155MABrHsxbXPC5v3hvAJPnZeJjER4dXAsvs2AS2BeTx9ptRuuyfTMvbu/jR4CfMHxILWITbUz/4YynqsPBk9C0jmL4QBPWPPj5r4JE+OC1Jj7+3Zju015o3VCweMHjN5rYdlixdpeiYST0bmfsxI4lKpZs9lyCMZu9uOfh55gy7j/YbTZ69BtEvYZNmf/FLBo1a0WnLr3o2W8ws98ZwwvDh+AfGMTwZ4z9RUZqMlPGjUBMJkLDInn4Sc/uB1ypbg8ck9L6vUXkMmAaxoU4O4EI4Dal1PaybODTla56TS9eK1dWsUHBC3T7xJ6lF7qI/Pq657rZ3KFe/QBPh1CherXzXKJ1l6taBVZYVkjevqZc+8uw9j2qZGYqtQWjlNosIr2ASzHGyv5RSlXN02U0TdMuZtWsBVOWs8huKTKrhYikATuUUgmu3qNpmqadv+o2yF+WMZhhQDdghWO6N7AeI9GMV0rNdVNsmqZpNUpNPE3ZDrRSSsVD/nUxM4GuwGpAJxhN07QKUN1aMGWpTaOzycUhAWihlErm7IUcmqZpmlZEWVowa0TkJ+Bbx/StwGoR8Qdc3JNV0zRNK5eaNsgPPA7cAnR3TG8E6iilTgN93BWYpmlaTaMujttDllmptVHGhTIHMbrDbgb6YtzyWdM0TatA7rqbsqeU2IIRkRYYD6a5C0jCuP+YKKV0q0XTNM0Nqtsg/7m6yPYCa4CblFIHAETkqUqJStM0rQaqbqcpnytd3grEAStE5AMR6YvrO81rmqZpFUCJqVyvqqrEyJRS85VSdwAtgZXAU0CUiMwUkesqKT5N07Qao7qNwZRlkP+0UupzpdSNQH1gK/Ci2yPTNE2rYRRSrldVVZbTlPM5Lq583/HSNE3TKlBV7u4qj/NKMJqmaZr7VOXWSHnoBKNpmlZF6BaMpmma5ha6BaNpmqa5hW7BnCd/X3vphS4iDw2tXo+w/Sqoej1ieMALXTwdQoXqveo1T4dQoQ5ZrvZ0CG4QWGFr0i0YTdM0zS2q8jUt5VG92mOapmkXMaWkXK/SiEh/EflHRA6ISLHrGEXkaRHZLSLbRWSZiFxSEfXRCUbTNK0aExEzMB0YALQG7hKR1kWKbQEuV0q1B74D3qiIbesEo2maVkUoTOV6laILcEApdUgplQt8BQwutF2lViilzjgm12PcteWC6QSjaZpWRZT3VjEi8oiIbHJ6PeK02npAjNP0cce8kgwDfq2I+uhBfk3TtCqivGeRKaVmA7NLWOxqpcplQZF7gcuBXuUKpAidYDRN06oIN52mfBxo4DRdHzhRtJCI9ANGAb2UUjkVsWGdYDRN06oINyWYv4DmItIYiMV4UvHdzgVEpBPGTYz7K6USKmrDOsFomqZVEWU55fj816nyRGQEsBgwAx8rpXaJyHhgk1JqEfA/IAD4VoxrcY4ppQZd6LZ1gtE0Tasi3HUlv1LqF+CXIvPGOP3dzx3b1QlG0zStitC3itE0TdPcQicYTdM0zS3cMQbjSTrBaJqmVRF23YLRNE3T3EF3kWmapmluobvINE3TNLfQLRhN0zTNLXQLxgOUUvz8+ST2bVuNxduXWx+eRN1GbYqViz28ix8+HIk1N4cWHXpywz0vISIs/X4qezYvR0wm/APDuPXh1wgKjfRATQw7Nq/jy4/eRNlt9Oh3MwNvfaDQcqs1l4+mjubowT34B4Yw/NnJ1I6sS16elTnTJ3D00F7stjy69bmRG2590EO1KOy2Pr60aexFrhXmLj7D8YTij8r+v1tqEeRvwixwMDaPr5dnoxR0au7FwG6+RIWbePOL0xyLt3mgBgXafzCJyIG9yU1IYnWnm1yWaf32KCL798KWlc22YS+SvmU3APX+NYTmIx8DYP9rM4mdu6DS4i7Juh3/8OYXP2Gz27m55xU8cENvl+WW/rWD52d8wbwxj9O6cX1SM0/z/PQv2HX4ODddfRkv/muwy/dVti2bNvDJ7Hex2+30ve4Gbh56b6Hlu3du5ZPZ0zh6+BBPvfAK3br3zl+WmBDPzHdfJykxARHhpXFvEBlVp5JrULLq1oK5KG7Xv2/7apLijvLUG78x5IFxLJoz3mW5RXPGMfiBcTz1xm8kxR1l//Y1AHQfOIz/TFzIiAnzadmxNysWzqjM8Aux22x8Pvt1nho9jQnvfs+Gtb9xIuZQoTJrli6gln8Qr81cxLU33cN3n00FYNMfS7Hm5TJ+6jeMnvI5qxZ/z6mEYvesq3StG3sREWJi3MeZfLk0izv7+rks9/FPZ5g8N5OJn2USUMvEZS0sAJxIsvPBj2c4eNyzieWs43N+YOOND5W4PKJ/T/ybNWJlq+vY8dho2r43FgBLaDAtXh7BuquHsvaq22nx8gi8QoIqKWrXbHY7r89dxLSnHuD7iU/x24ZtHIqNL1budFYOXy79g7ZNCu6J6GOx8NjN1/LUHQMrM+RzstlsfDjzbUaN+x9vz/yMtauXEXPsSKEytSOiePypl+jeu/jF6dPemsjgW+9i6vvzeO3t9wkODq2kyGumiyLB7Nm8nI5XD0ZEaNCsI9ln0slILXw/tozUBHKyM2nYrBMiQserB7N78zIAfP0C8svl5mR59Bjh0P6dRNapT0R0fbwsFrp0v54tG1cWKrN140qu6nMjAJdf1Zc92/9CKYWIkJudhc2WhzUnBy8vC75+/h6oRWHtm3qxcbcVgCMnbfj5CEH+xT/l7FzjX5MJzCZQjhuGxyfbSUgp3uLxlOS1m7Amp5W4PGpQX2LnGS2T1A3bsAQH4RMdQcR13Ulctg5rShp5qekkLltH5PU9Kitsl3YeiqF+ZDj1I8OweHlxfZcOrNyyp1i5GfOXcN+AnvhYCjo1/Hy86dSiEd6WqtPRcWDfHqLr1iOqTl0sFgtX9+zLX+vXFioTGVWHRo2bYiryfPuYY0ew22x06HQFAH5+tfDx9a202MvCXY9M9pQy/3JEJBrjyWgK+EspFee2qIrISIknODw6fzooLJr0lAQCQwq6udJTEggKjcqfDg6LIiOl4Ejt9+/eYcu6hfj6BTDsxTmVE7gLqcmJhNUuqEtoeCSH9+0sVCYlqaCM2eyFX60AMjNS6dytL1s2ruTpB68jNyebOx98hoDA4EqN35WQABMpGdb86dRMRUiAifTTxVskj99Si0uivdh9xMqW/dZiyy8GvnWjyDpe8PPPjo3Dt14UvnWjyI5xmn88Ht+6Ua5WUWkSU9KJDiv4jUSGBbHzYEyhMnuPniA+OY2eHVsx97c1lR3ieUlOOkXt2gX/78NrR7D/n91leu/J2Bhq+QfwxqujSIiPo33Hztxz/6OYzWZ3hXveqs5hVsUoUwtGRB4CNgK3ALcB60Wk0jr/lctn4xTO2kq5KON0BHPtbU/y/Nsr6NDtJtYv/byCIyy70uJ0lCpeBOHw/l2YTGamfLSY12f9xOKF80iMO+6eQC+Qy3oC0384w0vvp+NlFi5tUHWOjM+HFPu+HPUtab4Hufyf4xSn3W5nypc/8fSdN1ReUBfA1ecpZeyTsNls7N21nfuGPc7r77xPfNwJVi6tkAc3Vpjq1oIpaxfZc0AnpdT9Sqn7gM7ACyUVdn5859IFJT1k7dzWL/2c90bfzHujbyYwJJK0pIIjw/TkOIJCIwqVDw6LIt2pxZKWHF+ohXNW+243sGvTknLFVBFCwyNJPlVQl5SkBELCIkosY7PlkXUmE//AYDas/pW2nbrh5WUhKCSMZi07cORg2Y7eKlrPDt68eG8AL94bQNppRWhgwU8pJEBIO13yjjXPBjsOWmnX7OJMMFmxcfjVL2iF+taLJudEgtGSaeA0v34UOScr7NEa5RIZGkScU3dfQnI6EU7jQqezczkYG8/Dk2dzw7Ovs+NgDE+++xm7D1fNA5fw2hGcOlXwmSadSiQ0vHaZ39uoaXOi6tTFbPaiS7ceHDq4z12hlkt5H5lcVZU1wRwHMpymMyj8jOdClFKzlVKXK6Uu7zfkkZKKndOV/e5hxIT5jJgwn9aX9WXruoUopYg5sBUfv8BiySMwJBIfX39iDmxFKcXWdQtpddk1AJyKO5Jfbu+WFUTUaVKumCpC4+ZtiD8ZQ2J8LHlWKxvXLqbjFYWfTtrxil78seInADb9sYyW7a5ARAiLqMPeHcZ4TE52Fof27SC6XiMP1AJWb8tl8rxMJs/LZPsBK11aGwP2jeqYycpVpBdJMN4W8sdlTGKcGBCffHF2CCT8uJx69w4BIKRrB/LSM8iJSyRxyVoi+nXHKyQIr5AgIvp1J3HJ2lLW5l5tGtcnJuEUsYnJWPPyWLxxG706tcpfHljLl+XTRvPzmy/w85sv0K5pA975779p3bi+B6MuWbMWLTkZe5z4uBNYrVbWrV7GFV2vLtN7mzZvyenMDNLSUgHYuW0z9Rs2cmO056+6tWDKeggZC2wQkYUYre7BwEYReRpAKfWWm+IDoEWHXuzbvpq3nrsebx9fbnloUv6y90bfzIgJ8wEYdN8rfP+B4zTl9j1o0b4nAEu+fYtTJw8jYiKkdl0G3zfWneGek9nsxT0Pv8Db4x7HbrfTve8g6jVsyoIvZtKoWWs6dulFj35D+OCd0Yx8bBD+AcE8+sxrAFwzYCgfTxvLmCduRylF92sG0aBRC4/V5axdh/No09iLVx4MwJoH8xZn5S978d4AJs/LxMciPDq4Fl5mwSSwLyaPtduMUf/2zby4vY8fAX7C8CG1iE20Mf2HM56qDh3nTiG8Vxe8a4dyzeFV7B8/DXEMdB+b/RUJv64iYkAveu/9HVtWFtsfegkAa0oa+yfNoPuf3wGwf+J0rCklnyxQGbzMZl64ZxCPT/kYu10xqMflNK0Xxcz5v9O6UT16dWp9zvff8OzrnM7OwZpnY+WW3cx45kGa1PPcuJLZ7MVDjz3Jq6Ofxf7/7d13fFRV+vjxz5NJIPSQSgggCAEEFJCuVCm2XcsPhVVXcRfXviqWtSNVha8oioKyoqsoK2th106VJgoiRTqhqPQ0WiCBe6vezwAAIABJREFUZOb5/TGXkMAkGUImE5Ln/XrdV245985zMnfuueecWzweLut7FfXPa8RHU6fQOLEZHTp3ZcvmDYwd9QxHMg6zfNkSpn/4DuMnvY/L5eK2wfcy/KmHQJXzmzSjz+W+L0MPlrJcGykO8aeNWESeK2y5qg4vaNnHP3qC2whdwuJrZhad6Bzy0bc5wQ6hRF35eMdgh1Ciei54IdghlKhtsf7VNs4lFzaJK7FSYeG6QtqWC9G9pY/LNssAv2oweQsQEakNHNBg914aY0w5U95qMIX2wYjIUBFp7oxXFpF5wFZgn4gE5BWbxhhTUZW3PpiiOvkHApuc8UFO+higB/B8QSsZY4w5c6rFG8qqoprIjudpCrsc+LequoENInJuXmNqjDFlVHl74VhRNZhjItJKRGKAXkDeG0iqBi4sY4ypeMpbE1lRtZAHgU/wNou9oqrbAUTkKmBlgGMzxpgKpSw3dxVHoQWMqi4FmvuY/zXwdaCCMsaYiqhCXUV2gohEichrIrJCRH4WkVdFJCrQwRljTEXi0eINZZW/j4r5CEgB+uN92GUKMD1QQRljTEVU3vpg/C1gIlV1pKpud4ZRQEQgAzPGmIomUJcpi8gVIrJJRLaIyBM+llcWkenO8qUi0rAk8uNvAfOdiPxJREKcYQDwVUkEYIwxJnBExAW8AVwJtABuEpFTH0I3GNivqk2AV4AxJfHZRd3Jf1hEDgF3AdOAY87wETCkJAIwxhjj5UGKNRShI7BFVbep6nG8x+9rT0lzLXDiTYyfAL3F14uPzlBRV5HVONsPMMYY458AXaacQP7Xq+wEOhWURlVzROQgEAWkns0HF1rAiEhzVd0oIhf7Wq6qK87mw40xxpxU3A57EbkTyPvyrcmqeuJtj742empR5k+aM1bUjZYP4w16XAEfetnZBmCMMcaruJccO4VJQa8P3gnUzzNdD9hdQJqdzmPAagHpxYvmpKI6+d8WkTqq2ktVewH/AjKAtXgvVzbGGFNCAnQV2U9Aoog0EpFKwJ+Az09J8zneBxqD99g+ryReyVJUAfMmcBxARLoDL+DtCDpIwaWlMcaYYlCkWEOh21TNAe4HZgIbgP+o6joRGSEi1zjJpgBRIrIFb8vVaZcyF0dRTWQuVT1RTRqIt13vU+BTEVlVEgEYY4zxCtRd+b4e76WqQ/OMZwE3lvTnFlnAiEioUwL2Jn8nkl+P6y9vrxg+lFUp2CGUqIR64cEOoUSVt1cMz+/xZLBDKFHNNn4b7BDKtAr1sEvg38ACEUkFMoFFACLSBG8zmTHGmBJSoQoYVR0tInOBeGBWnk6fEODvgQ7OGGMqEk8Zfq5YcRTZzKWqP/qYtzkw4RhjTMVVoWowxhhjSo8VMMYYYwKiLL/bpTisgDHGmDKiLL/bpTisgDHGmDLCmsiMMcYERHlrIvP3hWPGGGPMGbEajDHGlBHWRGaMMSYgrIAxxhgTEOWtD8YKGGOMKSOsBmOMMSYgPJ5gR1CyrIAxxpgywmowxhhjAsIKGGOMMQFhnfxBsGbF9/x7ykuox023PtdzVf+/5FuenX2cKa8+y29bN1CtRgR3P/oi0bF1ycnJ5r03RvLbto143Dl06fUHru7/1yDl4qQNqxYz4/0XUY+bTr360+faO/Itz8k+zocTn2Tn9vVUrR7BoAdfIjImgU2/LOHLj8bjzsnGFRrGNTc/QmKrTkHKRX592wqN6wjZbvhymYd9B05P072VcGFDITwMxs042dhcsypc3SGEqpUh8zh8sdTD4SC+CPX7NZt4adqXuD0eru/egb9c3dNnujk/reEfE6fxwdD7aNGoHgcyjvCPN6axbvtO/njpxTxx67WlG3gBLvrn88Re1ZPjyWksbPtHn2lavPI0sVf0wJ2ZxerBT3Bo5XoAEm69jsQn7wEg6YVJ7Jr631KLuyDLly9n8luT8Hg89Lv8CgYMGJhv+YzPPmXmzJm4XCHUqhXBQw8NITYujq1btzLxjQkcPXqUkJAQBg68ie49egQpF75psaswZfMZZmX+Tn6P282Hk8cw5NkJjHztU5Yu/pbdO7blS7Nozn+pWq0mL0z6nL5/vIVP3n8VgOVL5pCdc5wRr/6HZ8d9yIKZn5KavDsY2cjl8bj59N1R3Pn4JB5/6XNWLvmavTu35kvz43efUaVaTZ4e/w09rrqVL6a9DEC1GrW549HX+cfYGdx8z2g+nFg2XqfbuA7Uri68+Y2Hb5Z7uKKd791qy27lX3NO78W8rHUIa39Vpszy8P16Dz0vDN6Pxe3xMGbq50wY8hc+HT2Eb5euZtuufaelO5J5jH/PWUKr8+vnzqscFsY91/dlyMCrSjPkIu187zOW/eGOApfHXNGdak0aMv+Cfqy551lavT4MgLDatWj6zP18f+kAFl9yI02fuZ/QiJqlFLVvbrebSRPfYPiIUUx6czILF8zn999/y5fm/MZNGP/qa7wx8U0u7dqVd96ZAkB45co8/MhjTHpzMiNGjmby5DfJyMgIRjYKpFq8oawq8wXMtqS1xMbXI6ZOPULDwujY9XJWLpufL82qZfO5pNcfAGh/SW82/PITqoqIcDwrE7c7h+xjxwgNDSO8SrUg5OKk37esIbpOA6Lj6hMaGkbbLleydvm8fGnW/jyPjt29Z7+tO/Ujae1SVJV6jS6gVmQsAHXqNSE7+xg52cdLPQ+nSkwQ1v7q3ct3p0PlMKgWfnq63elwJOv0+dE14ddk7/q/JXu3Fyxrt+2gXmwU9WIjCQsN5fKOrZm/csNp6SbOmMWgK7tTOexkI0CVypVo27QhlcLKVsNA+uLlZKcX/IbzuGt6s+sDb83kwNLVhNWqSeU6McT060rK3O/J3n+QnAOHSJn7PbGXdyutsH3avHkTdevGEx8fT1hYGN279+DHH37Il6Z169aEh3t3wObNm5OamgpAQr16JCQkABAVFUVERAQHD5atN797PMUbyiq/CxgRSRCRS0Sk+4khkIGdcCA9hcjoOrnTtaNiOZCWnC/N/rSTaVyuUKpUrU7G4QO069KbSuFVePiv/Xjszqu4/LpbqV6jVmmEXaAD+5OJiDqZn1pRcRzcnz8/B9NPpnG5QgmvWp0jh/O3Oa1eNpuEhhcQGlYp8EEXoUYV4VDmydOow5lQo4r/6ycfUJrV8xYqTROgcphQJUjZStl/iDqRJ/eR2MiaJO/PfxDa+Ntu9qUfpHubC0o7vIAIrxtH5s69udNZu/YSnhBHeN04snbkmb9zH+F144IRYq60tDSio2Nyp6Ojo0lLSysw/ayZM2nfvv1p8zdt2kR2Tg7x8fEBibO4ylsNxq9TLREZAwwE1gNuZ7YCCwMUVy6fbZJy6hnu6WkEYXvSOkJCXIybMpOjGYd58enBtLioEzF16gUmWH/43BvklCQ+8pMnz3t2bOHLaS9z91OTSzq6oJi3Wul3cQgXNhR2pCiHjmrQOjt9fjt5/vcej4dx//6S4XfcWHpBBZic9nty9sGC5geRf8cDr3nz5pKUlMSYsWPzzU9PT2PcS2N5+JFHCQkpW404FbWT/zqgmaoe8yexiNwJ3Anw2HOvcc2A4nes146KJT315FnU/rRkIiJjfKaJjI7D7c4h82gG1WrUYunCb2jVtguhoWHUjIikSfPW/Lp1fVALmIjIOA6knczPwbR91KqdPz8RUd40EVF1cLtzyDqaQdXq3rPqA2l7efflB7n53ueJjmtQqrHndXEToU0j7w97z36lZhXhxOG5RhXOqJM+Iws+W+Kt54eFQrN6wrHsko7YP7G1a7I3T3NScvohYvL0OxzJOs7WXfv424vewj3tYAYPvfY+4x+4jRaNgnjichYyd+2lSr067HemwxPqcGx3Mlm79hLZo2NuuvB6caQvWBacIB3R0dGkpqbkTqemphIVGXlaupUrVzB9+keMGfN/hOWp5R89eoRhzw3l1tsG0bx52auBluXaSHH4W3xvA8L83aiqTlbV9qra/mwKF4BGiS3Zt2cHKft2kZOdzbLFM2nTIf+VH2069GDJd18CsHzJXJpf2AERITImno1rvP0xx7Iy2bZ5DXUSGp5VPGerfuNWpOz9nbTkneTkZLPyh29o2a5XvjSt2vVi2cL/AbB66SyatOyEiJB55BD/HHsvV//pIc5vdnEwws+1YovyzmwP78z2sHmX0qqht7CpGwnHsn33tRQkb3NYl+bCL9uD9ytr2ageO5JT2ZWSTnZODjOXraZH25MHohpVw5k34Vm+eulxvnrpcS5sXP+cLlwAkr+YR8KfrwMgolNrcg4d5tjeFFJmLSamT1dCI2oSGlGTmD5dSZm1OKixNm3ajF27d7N3716ys7NZuHABnTp3zpdm69YtvD5hAkOHDiMiIiJ3fnZ2NqNGjuSy3n3o1q1UWvjPmHq0WENZVWgNRkQm4D0tPQqsEpG5QG4tRlUfCGx43j6IW/72OK8Mvw+Px0PX3teQ0KAx/502iYZNWtCmYw+69bmOf45/lifvuYZq1Wtx1yMvAHDZlQN4Z8Iwhj54I6pK18uuoX7DpoEOucj89L/9Kd564S48Hjedel5PfP0mfPPx69Rv1JJW7XvRqef/48OJTzL6oSupWr0Wt/79/wBYNPPfpO7bwawZbzJrxpsA3P3kZGrUigpmlti6BxrHK3dfFUJ2Dnz108lex7/2DeGd2d7pXhcJLRoIYaFw3x9CWL1dWbxOaRALPS/0nuv8nqLMWhG8H0yoy8Xjt1zDfePeweNRrunWnsYJcUyaMZsWDRPo0bZFoetf/egYjmQdIzvHzfyV65n4yF85PyG4/RZtpo4jqkdHKkXX5rLtC0gaMQFxLkT4ffJHJH+zgJgre9Bz42zcmZn8csdTAGTvP0jS8xPp+sMnACSNfoPs/cHtFHe5XNxzz708+8zTeDwe+vbrx3nnNWTq1PdJTEykc+cuTJnyNllZmbzwwmgAYmJieO654SxatJC1a9dw6PAh5syZDcCQIY/QuHHjYGYpnzJcVhSLFNamKiKDCltZVd8r6gMWrz9Srv5lh7KC36leklZvKVtt0GfrgXr/C3YIJWp+j7JxKXpJabbx22CHUOKaNG5UYpc9jv20eEXMP/qHFDsGEYkEpgMNgV+BAaq6/5Q0bYBJQE28/fCjVXV6UdsutAZzogARkWpAlqq6nWkXUPlMM2KMMaZgQeqDeQKYq6ovisgTzvTjp6Q5CtymqkkiUhf4WURmqqqPW6pP8vf0dS6Q98LTKsAcP9c1xhjjB49HizWcpWuBE61R7+G9qCsfVd2sqknO+G4gGYg5Nd2p/L2KLFxVc295VdUMEanq57rGGGP8EKQaTJyq7vF+vu4RkdjCEotIR6ASsLWwdOB/AXNERC5W1RXOB7QDgvi0KGOMKX+KW8DkvTXEMVlVJ+dZPgeoc9qK8PQZfk48MBUYpKpFPkPA3wLmQeBjETnxIK94vDdeGmOMKSGeYpYwTmFS4J3XqtqnoGUisk9E4p3aSzze5i9f6WoCXwHPqOqP/sRVZAEjIiF4q0PNgWZ4bzvfqKpBuhXOGGPKp6LrBAHxOTAIeNH5e9qlmCJSCZgBvK+qH/u74SI7+Z1q0DhVzVbVtaq6xgoXY4wpeaparOEsvQj0FZEkoK8zjYi0F5G3nTQDgO7A7SKyyhnaFLVhf5vIZolIf+AzDfbDiIwxppwKxpORVTUN6O1j/nLgDmf8A+CDM922vwXMw0A1IEdEsvA2k6mqBvflEMYYU46Ut/N3vwoYVa0R6ECMMaaiK2+PivH7zUgiUhtIBHJfJaWqAX9cvzHGVBRl+cGVxeHv+2DuwHupcj1gFdAZ+AG4LHChGWNMxVLOWsj8flTMg0AH4DdV7QW0BVIKX8UYY8yZCNKjYgLG3yayLFXNEhFEpLKqbhSRZgGNzBhjKpgK2ckP7BSRCOC/wGwR2Q/sLmIdY4wxZyBIN1oGjL9XkV3vjA4Tke+AWkD5e7GDMcYEUXEfFVNWFfVGy3DgbqAJsAaYoqoLSiMwY4wx57aiajDvAdnAIuBKoAXeDn9jjDElrKL1wbRQ1QsBRGQKsOxMP6BB2O/FiavMuvlxnw8aPWeNHXtxsEMoUdvCLg12CCWqvL1ieFPzK4IdQolrkr2pxLZVlq8IK46iCpjch1qqao5Iib162hhjzCnKWQWmyAKmtYgccsYFqOJM27PIjDGmhFWoO/lV1VVagRhjTEVXoa4iM8YYU3oqVA3GGGNM6bECxhhjTECUs/LFChhjjCkrrAZjjDEmICrajZbGGGNKSUW70dIYY0wpsRqMMcaYgLA+GGOMMQFhBYwxxpiAsDv5jTHGBER5q8GEBDsAY4wx5ZMVMMYYU0aoarGGsyEikSIyW0SSnL+1C0lbU0R2icjr/mzbChhjjCkjPB4t1nCWngDmqmoiMNeZLshIYIG/Gz4n+mB++nkFEye/jcfj4cp+ffnTjf3zLf9kxv/4ZtZsXC4XtWrW5NGH/k5cbCwAyckpjJvwOikpaYjA6GHPUicuLhjZyOfBOxvTpV0UWcfcPP/qJjZvzTgtzYTnWxNVuxLHjnsAGDL0Fw4czObK3nHc+5fzSU07DsCnX+3iy1l7SzX+vNasWMK0t1/C4/HQve91XN3/9nzLs7OP88/xz/Hb1g1Ur1GLex59gei4uuRkZ/PepOfZvmU9ISEh3Dz4EZpf2D44mchj5fKlvDv5NTweD737Xc31A/6cb/n6tat4d/IEftu+jSGPP0eXrj1zl6Uk72PSa2NIS0lGRHhq+Fhi4+JLOQf5LV++nMlvTcLj8dDv8isYMGBgvuUzPvuUmTNn4nKFUKtWBA89NITYuDi2bt3KxDcmcPToUUJCQhg48Ca69+gRpFycdNE/nyf2qp4cT05jYds/+kzT4pWnib2iB+7MLFYPfoJDK9cDkHDrdSQ+eQ8ASS9MYtfU/5Za3P4IUh/MtUBPZ/w9YD7w+KmJRKQdEAd8C/j1Qy3zBYzb7WbCpLcYM2o40VFR3D/kMbp06sh5DernpmnS+HzeeGUc4eGV+eLrb/jnu+/xzOOPATDm5fHcPPBG2rVtQ2ZmJiLBr7R1bhdJ/bpV+dNdy2jZrAaP3pPInY+u9Jl2+LgNbNpyeuEzb1EKr7y1JdChFsnjdjP1rTE8OvwNIqPiGPHYbbTp2J2E+ufnplk0+39Uq16DMW/+l6WLZvKf9ydw72MvsGD2DABGvTadQwfSeXnEAwx96X1CQoL3Hbndbt6e9ApDR71MZHQMTwy5k/adu1K/QcPcNNExcdw35Ck+/+yj09af8PJo+g+8ldZtO5CZeZSQIO9vbrebSRPfYNTo54mOjmbIQw/QuXNnGjQ4LzfN+Y2bMP7VqwkPD+err77knXem8MSTTxFeuTIPP/IYCQkJpKWl8eAD93Nxu3ZUr149iDmCne99xq8TP6DNO2N8Lo+5ojvVmjRk/gX9iOjUmlavD2PJpQMIq12Lps/cz+LO/VFVui39jH1fzCPnwCGf2wmGIN1oGaeqe5zP3yMisacmEO+BcxxwK9Db3w0H/2hbhE2bk6gbH098nTqEhYXRs3tXlvy4NF+aNhddSHh4ZQAuaNaMlNQ0AH77fQduj4d2bdsAUKVKldx0wdStcxTfzvPWONZtOkz1aqFE1a4U5KiKZ1vSOmLj6xNbpx6hYWF07NqPlUvz16BXLFvApb3+AED7S3qz4ZdlqCq7d2zngos6AFAzIpKq1Wrw65b1pZ6HvLZs3kCdugnExdclLCyMS7v35qcfF+dLExsXT8NGjQk55RXiO37/FY/bTeu23jxVqVKVyuHhpRa7L5s3b6Ju3Xji4+MJCwuje/ce/PjDD/nStG7dmnAnzubNm5OamgpAQr16JCQkABAVFUVERAQHDx4s3Qz4kL54OdnpBccRd01vdn3grZkcWLqasFo1qVwnhph+XUmZ+z3Z+w+Sc+AQKXO/J/bybqUVtl/U4ynWICJ3isjyPMOdebcrInNEZK2P4Vo/Q7sX+FpVd5xJfvyqwYiIALcA56vqCBFpANRR1WVn8mHFkZqWTkxMdO50dHQUGzclFZj+m1lz6NjuYgB27tpF9WrVGDb6Rfbu28fFbVozeNCtuFzBfVFndFRlklOP5U4npx0jOqoSafuPn5b2qQeb4fHA/CUpvDf999z5PS6JpnXLWuzYncmEt7fm215p2p+eTGT0ySbHyKhYtiatzZfmQJ40LlcoVapWJ+PwQeo3TGTlsgV06taP9NR9/Lp1A+mp+zi/aatSzUNe6WmpREefPIGLio4haZN/hd6eXTuoWq06Y0c9TfK+vVzUph233H5XUPe3tLQ0oqNjcqejo6PZtGlTgelnzZxJ+/ant35s2rSJ7Jwc4uOD29znj/C6cWTuPNlknLVrL+EJcYTXjSNrR575O/cRXjf4zeV5Fbc/RVUnA5MLWd6noGUisk9E4p3aSzyQ7CNZF6CbiNwLVAcqiUiGqhbWX+N3DWai8wE3OdOHgTf8XPesKKf/w085ccw157v5bN6yhRv7Xw+A2+1hzbr13DX4dt545SX27N3LrLnzAhitf3yG72O/Gv7SBgb9/WfufWIVrVvW4ope3h/D98vSuHHwUm5/4GeWr9rP0w81C2i8hfIRt5ySQ1+1fgG69bmGyKhYhj9yG9OmjKNJ84sICXLh76uJ4tT8FMTtdrNx3S8MGnwfY8a/xb69u5k/55uSDvGM+GxyKeAHNG/eXJKSkuh/ww355qenpzHupbEMGfJwUJsv/SU+8qeqPvNd1p79FYyryIDPgUHO+CDgfz7iukVVG6hqQ+BR4P2iChfwv4DppKr3AVnOh+0HCmzTyVtdm/bRf/z8CN9ioqJISUnNnU5NTSMqMvK0dCtWrWba9E8Y8exTVAoLA7y1nSbnNyK+Th1cLheXdO5E0tZtZxVPcf2/q+ry7qvtePfVdqSmHyc2+mRTXWxUZVLTT6+9nJiXmelm9oJkLmhaA4BDh3PIzvHuVF/M2kOzJjVKIQe+1Y6KJT11X+50eloyEZExBaZxu3PIPJpBtRq1cLlCuWnwI4wYP40Hn3qZo0cyiKvboFTjP1VUdAypqSdP4NJSU6gdFV3IGvnXbdg4kbj4urhcoXTs0o1tWzcHKlS/REdHk5qakjudmprq8/ezcuUKpk//iKHPDSMs7ORP++jRIwx7bii33jaI5s0vKJWYz1bmrr1UqVcndzo8oQ7Hdid7azL188yvF8exPb5O1oNHPVqs4Sy9CPQVkSSgrzONiLQXkbfPZsP+FjDZIuLCOV8VkRjAU1BiVZ2squ1Vtf3NfxpwNvHRrGkiu3bvYc/efWRnZzN/4WK6dOqYL82WrdsY//pERjz7FLUjIk6um9iEjIwjHHDajVf9sobz6tcnGD77ejd/efBn/vLgzyz6MZUrLvPu6C2b1SDjaM5pzWOuEKhV09uC6XIJl3SIYttvRwDy9dd07RjFbzuOllIuTtcosQXJe3aQsm8XOdnZLFs8i7Ydu+dL07Zjd77/7ksAli+ZywUXdkBEOHYsi2NZmQCsW/UjLpcr38UBwdCkaXP27NrJvr27yc7O5vuFc+nQ6VK/1m2c2JwjGYc5ePAAAGtXr6BenosDgqFp02bs2r2bvXv3kp2dzcKFC+jUuXO+NFu3buH1CRMYOnQYEXl+P9nZ2YwaOZLLevehW7fup266zEr+Yh4Jf74OgIhOrck5dJhje1NImbWYmD5dCY2oSWhETWL6dCVl1uIitla6glHAqGqaqvZW1UTnb7ozf7mq3uEj/b9U9X5/tu3vVWSvATOAWBEZDdwAPOPnumfF5XJx/91/48mhw/F43Fzetw8Nz2vAvz6YRtPEJlzSqSOT3/kXmVlZjHxxLACxMTGMHPo0LpeLOwffzj+eHoqqktikMVdd3rc0wi7UD8vT6dI+kumTO+ZepnzCu6+24y8P/kxYWAgvD78Il0twuYTlq/bzxaw9ANzwxwS6dorC7VYOHc5h9Ksbg5UVXK5QbvnbY4wb/nc8bjfd+lxDQoPGzJj2Jg2bXEDbjj3o3udaJo8fyuN3X0e1GjW5+5HnATh8IJ1xw+9HQkKoHRnL3x4aEbR8nOByhXLHPQ8x6tlH8Xg8XNb3Kuqf14iPpk6hcWIzOnTuypbNGxg76hmOZBxm+bIlTP/wHcZPeh+Xy8Vtg+9l+FMPgSrnN2lGn8t9X0Zbevlxcc899/LsM0/j8Xjo268f553XkKlT3ycxMZHOnbswZcrbZGVl8sILowGIiYnhueeGs2jRQtauXcOhw4eYM2c2AEOGPELjxo2DmSXaTB1HVI+OVIquzWXbF5A0YgIS5j2U/T75I5K/WUDMlT3ouXE27sxMfrnjKQCy9x8k6fmJdP3hEwCSRr9B9v7gX7SQl0cLPG8/J4m/7Xci0hzv5WmC96acDf6s93vShrLVyHmWbn64bFWpz9bYsRcHO4QSVSMseLW5QKgi5Ss/m5pfEewQStzV2Zv866Tzw/X3JxXreDnj9cQSi6EkFVmDca5//kVVWwHBO1U2xphyrrw97LLIAkZVPSKyWkQaqOrvRaU3xhhTPGXtqraz5W8fTDywTkSWAUdOzFTVawISlTHGVEAeT/nqg/G3gBke0CiMMcZUvCYyAFX1++mZxhhjikfL2VVkft0HIyKdReQnEckQkeMi4haRsvOEOGOMKQeCdKNlwPh7o+XreB8TkwRUAe5w5hljjDE++f24flXdIiIuVXUD74rIkgDGZYwxFU5Zro0Uh78FzFERqQSsEpGxwB6gWuDCMsaYiqe83cnvbxPZrU7a+/Feplwf6F/oGsYYY85IeeuDKbQGc+LmSlX9zZmVhV2ybIwxAaHl7D6YomowuS+sFpFPAxyLMcZUaBWqBkP+d2MF9znqxhhTzpW3+2CKKmC0gHFjjDElrLivTC6riipgWjs3VApQJc/NlQKoqtYMaHTGGFOBlLc+mEILGFVby4fZAAAH+klEQVQN7gvSjTGmAinL/SnF4feNlsYYYwKrovXBGGOMKSVWgzHGGBMQ5a0PRsrLG9RE5E5VnRzsOEqK5adsK2/5gfKXp/KWn3ORv4+KORfcGewASpjlp2wrb/mB8pen8pafc055KmCMMcaUIVbAGGOMCYjyVMCUt7ZWy0/ZVt7yA+UvT+UtP+ecctPJb4wxpmwpTzUYY4wxZUjQChgReVpE1onILyKySkQ6lcA2rxGRJ0oovowS2o7byd9aEflYRKoWknaYiDxaEp8bDCJyvYioiDQPdixnytf+KCJvi0gLZ7nP/UFEOovIUmedDSIyrFQD9x2T3/vcGWzzdhF5vSTiO1t58ndiaBjsmIxvQbnRUkS6AH8ALlbVYyISDVTyc91QVc3xtUxVPwc+L7lIS0SmqrYBEJEPgbuBl4MbUsDcBCwG/gQMC24o/itof1TVO/xY/T1ggKquFhEX0CyQsfqp2PuciLhU1R3I4EpAbv7OxDmSt3IlWDWYeCBVVY8BqGqqqu4WkV+dHzci0l5E5jvjw0RksojMAt53zhhbntiYiMwXkXYnzrJEpJazrRBneVUR2SEiYSLSWES+FZGfRWTRibNtEWkkIj+IyE8iMjJA+V4ENHE+7zbnbHm1iEw9NaGI/M2JZbWIfHriLFREbnTOTFeLyEJnXksRWeaczf0iIokBir9AIlIduBQYjLeAQURCRGSiUzP4UkS+FpEbnGXtRGSB8z3MFJH40o45j4L2x/ki0v5EIhEZJyIrRGSuiMQ4s2OBPc56blVd76QdJiJTRWSeiCSJyN9KOU8n5N3n/uv8v9eJSO49IiKSISIjRGQp0EVEOojIEmcfWyYiNZykdZ3fTpKIjA1CXgokIg2d3/MKZ7jEmd9TRL4TkWnAGmfen/P8Xt5yTgxMIKhqqQ9AdWAVsBmYCPRw5v8KRDvj7YH5zvgw4GegijM9BBjujMcDm53x24HXnfH/Ab2c8YHA2874XCDRGe8EzHPGPwduc8bvAzJKKK8Zzt9QJ6Z7gJbApjx5jcyTz0ed8ag82xgF/N0ZXwMkOOMRzt8JwC3OeKUT/6dS/k7/DExxxpcAFwM3AF/jPZGpA+x35oU5aWLyfD/vBGNfLGJ/nA+0d8Y1z/94aJ79bKiTrxnAXUB4nu9yNVAFiAZ2AHVLKT+n7XOn7GdVgLUn9jEnbwPy7D/bgA7OdE1nO7c782sB4cBvQP0gfV9u5/taBcxw5lXN879PBJY74z2BI0AjZ/oC4AsgzJmeiPO7t6Hkh6A0kalqhoi0A7oBvYDpUnTfyeeqmumM/weYDTwHDAA+9pF+Ot4D13d4z6gnOmfZlwAfi+S+rLOy8/dSoL8zPhUYc6b5KkAVEVnljC8CpuA9EH2iqqkAqpruY71WIjIKiMB7AJzpzP8e+JeI/Af4zJn3A/C0iNQDPlPVpBKK/UzcBIx3xj9ypsOAj9X7iNi9IvKds7wZ0AqY7XwPLpxaQDD4uT968O5TAB/g/O9VdYTTDNUPuBlvvns66f7n7LOZTt47kuc15AHka58DeEBErnfG6+M9EKfhPWCfeCV6M2CPqv4EoKqHAJzvaa6qHnSm1wPn4S04S5uvJrIw4HURaYM3P03zLFumqtud8d5AO+AnJ09VgOQAx1thBe1hl+ptC50PzBeRNcAgIIeTzXbhp6xyJM+6u0QkTUQuwluI3OXjIz4HXhCRSLw71DygGnDAx86Zu+liZqcwp/0YxLtnF/VZ/wKuU2/b/u04By1VvVu8F0RcDawSkTaqOs1p3rgamCkid6jqvBLOR4FEJAq4DG+hqHgLDMV7Vu9zFWCdqnYppRCLVMD+WOgqedbdCkwSkX8CKc7/I1+aAqYDxdc+1xPoA3RR1aPibX4+8RvL0pN9E4Xtm8fyjLspWw/LHQLsA1rjPYZk5Vl2JM+4AO+p6pOlGFuFFZQ+GBFpdko/QRu8Ve5f8RYGcLI2UZCPgH8AtVR1zakLVTUDWAa8Cnyp3vbxQ8B2EbnRiUNEpLWzyvc4fQfALWeeqzMyFxhw4kDkFIKnqgHsEZGwvPGISGNVXaqqQ4FUoL6InA9sU9XX8BasFwU4/lPdALyvquepakNVrQ9sd+Lr7/TFxHHyzH4TECPeznXE2zfW0teGS0Mh+2NeIXjzCd6aymJn3avlZHU4Ee+B94Azfa2IhDvfc0/gpwCE769awH6ncGkOdC4g3Ua8fS0dAESkhoiUpYKkILXw1rw8wK14T3J8mQvcICKx4P3tich5pRRjhROsTv7qwHsisl5EfgFa4G2zHg68KiKL8P5QC/MJ3gLhP4WkmY63b2B6nnm3AINFZDWwDrjWmf8gcJ+I/IR3Zw0YVV0HjAYWOHH4usLnWWAp3qbAjXnm/5+IrBGRtcBCvO38A4G1TrNIc+D9QMbvw02cXlv5FKgL7MTb3v8W3vwcVNXjeA/WY5z8r8LbdBksBe2PeR0BWorIz3hrayOc+bcCm5z//VS8/TQn9t1lwFfAj8BIVd0d2GwU6lsg1MnfSCem0zjfzUBggvPdzOb01oSyaCIwSER+xNs8dsRXIvVehPEMMMv5X8zG249rAsDu5DcBJSLVnT6OKLwH3EtVdW+w4wo08d4Pk6GqLwU7FmOC5Vyo+ppz25ciEoH36qSRFaFwMcZ4WQ3GGGNMQNizyIwxxgSEFTDGGGMCwgoYY4wxAWEFjDHGmICwAsYYY0xAWAFjjDEmIP4/Wc8T0FhzQtQAAAAASUVORK5CYII=\n", 486 | "text/plain": [ 487 | "
" 488 | ] 489 | }, 490 | "metadata": { 491 | "needs_background": "light" 492 | }, 493 | "output_type": "display_data" 494 | } 495 | ], 496 | "source": [ 497 | "# Plot heatmap \n", 498 | "\n", 499 | "correlation = data.corr()\n", 500 | "plt.figure(figsize = (7, 5))\n", 501 | "sns.heatmap(correlation, annot = True, fmt = '.2f', cmap = 'coolwarm')\n", 502 | "plt.title('Correlation between features')" 503 | ] 504 | }, 505 | { 506 | "cell_type": "code", 507 | "execution_count": 8, 508 | "metadata": {}, 509 | "outputs": [ 510 | { 511 | "data": { 512 | "text/plain": [ 513 | "Fare 0.093143\n", 514 | "Survived -0.082446\n", 515 | "Parch -0.187896\n", 516 | "SibSp -0.307351\n", 517 | "Pclass -0.365902\n", 518 | "Name: Age, dtype: float64" 519 | ] 520 | }, 521 | "execution_count": 8, 522 | "metadata": {}, 523 | "output_type": "execute_result" 524 | } 525 | ], 526 | "source": [ 527 | "# Age correlation with other features \n", 528 | "\n", 529 | "correlation['Age'].sort_values(ascending = False)[1:]" 530 | ] 531 | }, 532 | { 533 | "cell_type": "markdown", 534 | "metadata": {}, 535 | "source": [ 536 | "As we can see, the Age feature is slightly positively correlated with the Fare feature. In other words, passengers that are older generally pay a higher fare. " 537 | ] 538 | }, 539 | { 540 | "cell_type": "code", 541 | "execution_count": 9, 542 | "metadata": {}, 543 | "outputs": [ 544 | { 545 | "data": { 546 | "text/plain": [ 547 | "Text(0.5, 1.0, 'Passenger Age Distribution')" 548 | ] 549 | }, 550 | "execution_count": 9, 551 | "metadata": {}, 552 | "output_type": "execute_result" 553 | }, 554 | { 555 | "data": { 556 | "image/png": "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\n", 557 | "text/plain": [ 558 | "
" 559 | ] 560 | }, 561 | "metadata": { 562 | "needs_background": "light" 563 | }, 564 | "output_type": "display_data" 565 | } 566 | ], 567 | "source": [ 568 | "# Plot passenger age distribution\n", 569 | "\n", 570 | "plt.figure(figsize = (8, 5))\n", 571 | "sns.distplot(data['Age'], label = 'Skewness: {:.2f}'.format(data['Age'].skew()))\n", 572 | "plt.legend(loc = 'best')\n", 573 | "plt.title('Passenger Age Distribution')" 574 | ] 575 | }, 576 | { 577 | "cell_type": "code", 578 | "execution_count": 10, 579 | "metadata": {}, 580 | "outputs": [ 581 | { 582 | "data": { 583 | "text/plain": [ 584 | "count 712.000000\n", 585 | "mean 29.642093\n", 586 | "std 14.492933\n", 587 | "min 0.420000\n", 588 | "25% 20.000000\n", 589 | "50% 28.000000\n", 590 | "75% 38.000000\n", 591 | "max 80.000000\n", 592 | "Name: Age, dtype: float64" 593 | ] 594 | }, 595 | "execution_count": 10, 596 | "metadata": {}, 597 | "output_type": "execute_result" 598 | } 599 | ], 600 | "source": [ 601 | "# Age summary statistics \n", 602 | "\n", 603 | "data['Age'].describe()" 604 | ] 605 | }, 606 | { 607 | "cell_type": "markdown", 608 | "metadata": {}, 609 | "source": [ 610 | "# 4. Missing values imputation\n", 611 | "\n", 612 | "In this section, we will look at 3 different imputation techniques:\n", 613 | "\n", 614 | "1. Simple imputer\n", 615 | "2. Iterative imputer\n", 616 | "3. KNN Imputer\n", 617 | "\n", 618 | "Here, I have created a sample dataframe to demonstrate the differences between the 3 techniques. " 619 | ] 620 | }, 621 | { 622 | "cell_type": "code", 623 | "execution_count": 11, 624 | "metadata": {}, 625 | "outputs": [ 626 | { 627 | "data": { 628 | "text/html": [ 629 | "
\n", 630 | "\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 | " \n", 663 | " \n", 664 | " \n", 665 | " \n", 666 | " \n", 667 | " \n", 668 | " \n", 669 | " \n", 670 | " \n", 671 | " \n", 672 | " \n", 673 | " \n", 674 | " \n", 675 | " \n", 676 | " \n", 677 | " \n", 678 | " \n", 679 | " \n", 680 | " \n", 681 | " \n", 682 | " \n", 683 | " \n", 684 | " \n", 685 | " \n", 686 | " \n", 687 | " \n", 688 | " \n", 689 | " \n", 690 | "
SibSpFareAge
017.250022.0
1171.283338.0
207.925026.0
3153.100035.0
408.050035.0
508.4583NaN
\n", 691 | "
" 692 | ], 693 | "text/plain": [ 694 | " SibSp Fare Age\n", 695 | "0 1 7.2500 22.0\n", 696 | "1 1 71.2833 38.0\n", 697 | "2 0 7.9250 26.0\n", 698 | "3 1 53.1000 35.0\n", 699 | "4 0 8.0500 35.0\n", 700 | "5 0 8.4583 NaN" 701 | ] 702 | }, 703 | "execution_count": 11, 704 | "metadata": {}, 705 | "output_type": "execute_result" 706 | } 707 | ], 708 | "source": [ 709 | "# Create sample dataframe\n", 710 | "\n", 711 | "df = pd.DataFrame({'SibSp': [1, 1, 0, 1, 0, 0], \n", 712 | " 'Fare': [7.25, 71.2833, 7.925, 53.1, 8.05, 8.4583], \n", 713 | " 'Age': [22, 38, 26, 35, 35, np.nan]})\n", 714 | "df" 715 | ] 716 | }, 717 | { 718 | "cell_type": "markdown", 719 | "metadata": {}, 720 | "source": [ 721 | "# 4.1 Simple imputer\n", 722 | "\n", 723 | "Simple imputer follows a univariate approach to imputing missing values i.e. it only takes a single feature into consideration. Some of the most common uses of simple imputer are:\n", 724 | "\n", 725 | "- Mean\n", 726 | "- Median\n", 727 | "- Most frequent (mode)" 728 | ] 729 | }, 730 | { 731 | "cell_type": "code", 732 | "execution_count": 12, 733 | "metadata": {}, 734 | "outputs": [ 735 | { 736 | "name": "stdout", 737 | "output_type": "stream", 738 | "text": [ 739 | "Average age: 31.2\n" 740 | ] 741 | }, 742 | { 743 | "data": { 744 | "text/plain": [ 745 | "array([[ 1. , 7.25 , 22. ],\n", 746 | " [ 1. , 71.2833, 38. ],\n", 747 | " [ 0. , 7.925 , 26. ],\n", 748 | " [ 1. , 53.1 , 35. ],\n", 749 | " [ 0. , 8.05 , 35. ],\n", 750 | " [ 0. , 8.4583, 31.2 ]])" 751 | ] 752 | }, 753 | "execution_count": 12, 754 | "metadata": {}, 755 | "output_type": "execute_result" 756 | } 757 | ], 758 | "source": [ 759 | "print(\"Average age: \", df['Age'].mean())\n", 760 | "simple_imp = SimpleImputer(missing_values = np.nan, strategy = 'mean')\n", 761 | "simple_imp.fit_transform(df)" 762 | ] 763 | }, 764 | { 765 | "cell_type": "markdown", 766 | "metadata": {}, 767 | "source": [ 768 | "As we can see, simple imputer has filled the missing value in the Age column with the average age which is 31.2." 769 | ] 770 | }, 771 | { 772 | "cell_type": "markdown", 773 | "metadata": {}, 774 | "source": [ 775 | "# 4.2 Iterative imputer\n", 776 | "\n", 777 | "Iterative imputer is an example of a multivariate approach to imputation. It models the missing values in a column by using information from the other columns in a dataset. More specifically, it treats the column with missing values as a target variable while the remaining columns are used are predictor variables to predict the target variable. \n", 778 | "\n", 779 | "In our sample data frame, the Age column has one missing value on row 6 and is therefore assigned as the target variable in this scenario. This leaves the SibSp and Fare columns as our predictor variables. \n", 780 | "\n", 781 | "Iterative imputer will use the first 5 rows of the data frame to train a predictive model. Once the model is ready, it will then values in the SibSp and Fare columns of row 6 as inputs and predict the Age value for that row." 782 | ] 783 | }, 784 | { 785 | "cell_type": "code", 786 | "execution_count": 13, 787 | "metadata": { 788 | "scrolled": true 789 | }, 790 | "outputs": [ 791 | { 792 | "data": { 793 | "text/plain": [ 794 | "array([[ 1. , 7.25 , 22. ],\n", 795 | " [ 1. , 71.2833 , 38. ],\n", 796 | " [ 0. , 7.925 , 26. ],\n", 797 | " [ 1. , 53.1 , 35. ],\n", 798 | " [ 0. , 8.05 , 35. ],\n", 799 | " [ 0. , 8.4583 , 28.50639495]])" 800 | ] 801 | }, 802 | "execution_count": 13, 803 | "metadata": {}, 804 | "output_type": "execute_result" 805 | } 806 | ], 807 | "source": [ 808 | "iterative_imp = IterativeImputer()\n", 809 | "iterative_imp.fit_transform(df)" 810 | ] 811 | }, 812 | { 813 | "cell_type": "markdown", 814 | "metadata": {}, 815 | "source": [ 816 | "As we can see, the value predicted under iterative imputer is different to that under simple imputer.\n", 817 | "\n", 818 | "This is a more accurate approach to predict the missing Age value as it takes other features in our dataframe into account. " 819 | ] 820 | }, 821 | { 822 | "cell_type": "markdown", 823 | "metadata": {}, 824 | "source": [ 825 | "# 4.3 KNN imputer\n", 826 | "\n", 827 | "Last but not least, we have KNN Imputer which is another multivariate imputation technique. KNN Imputer scans our dataframe for k nearest observations to the row with missing value. It will then proceed to fill the missing value with the average of those nearest observations. \n", 828 | "\n", 829 | "Here, I have set k to equal to 2 or in other words, I want KNN imputer to look for 2 observations that are nearest to row 6 and fill the missing age with the average age of those 2 rows." 830 | ] 831 | }, 832 | { 833 | "cell_type": "code", 834 | "execution_count": 14, 835 | "metadata": {}, 836 | "outputs": [ 837 | { 838 | "data": { 839 | "text/plain": [ 840 | "array([[ 1. , 7.25 , 22. ],\n", 841 | " [ 1. , 71.2833, 38. ],\n", 842 | " [ 0. , 7.925 , 26. ],\n", 843 | " [ 1. , 53.1 , 35. ],\n", 844 | " [ 0. , 8.05 , 35. ],\n", 845 | " [ 0. , 8.4583, 30.5 ]])" 846 | ] 847 | }, 848 | "execution_count": 14, 849 | "metadata": {}, 850 | "output_type": "execute_result" 851 | } 852 | ], 853 | "source": [ 854 | "knn_imp = KNNImputer(n_neighbors = 2)\n", 855 | "knn_imp.fit_transform(df)" 856 | ] 857 | }, 858 | { 859 | "cell_type": "markdown", 860 | "metadata": {}, 861 | "source": [ 862 | "As a result, KNN imputer has taken row 3 and row 5 as the nearest observations for row 6.\n", 863 | "\n", 864 | "Therefore, the average age between row 3 and row 5 is (26 + 35) / 2 = 30.5. " 865 | ] 866 | }, 867 | { 868 | "cell_type": "markdown", 869 | "metadata": {}, 870 | "source": [ 871 | "# 5. Model accuracy under simple imputer and iterative imputer\n", 872 | "\n", 873 | "Now that we have a better understanding of how the different imputers work, we can move on to apply these techniques to our Titanic dataset and compare the model accuracy under each approach.\n", 874 | "\n", 875 | "We should expect to see our model perform better under multivariate imputation than univariate imputation as multivariate imputation provides a more accurate prediction of the missing values and thus allowing our model to make better predictions. \n", 876 | "\n", 877 | "In this section, we will build a column transformer which consists of a OneHotEncoder for encoding the Sex and Embarked columns as well as an imputer to impute the missing values in the Age column.\n", 878 | "\n", 879 | "Following that, we will chain the column transformer with a random forest classifier to predict the surival of the passengers on the Titanic. Finally, we will perform 10-fold cross-validation to compare the prediction results under univariate imputation versus under multivariate imputation. " 880 | ] 881 | }, 882 | { 883 | "cell_type": "code", 884 | "execution_count": 15, 885 | "metadata": {}, 886 | "outputs": [ 887 | { 888 | "data": { 889 | "text/html": [ 890 | "
\n", 891 | "\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 | " \n", 931 | " \n", 932 | " \n", 933 | " \n", 934 | " \n", 935 | " \n", 936 | " \n", 937 | " \n", 938 | " \n", 939 | " \n", 940 | " \n", 941 | " \n", 942 | " \n", 943 | " \n", 944 | " \n", 945 | " \n", 946 | " \n", 947 | " \n", 948 | " \n", 949 | " \n", 950 | " \n", 951 | " \n", 952 | " \n", 953 | " \n", 954 | " \n", 955 | " \n", 956 | " \n", 957 | " \n", 958 | " \n", 959 | " \n", 960 | " \n", 961 | " \n", 962 | " \n", 963 | " \n", 964 | " \n", 965 | " \n", 966 | " \n", 967 | " \n", 968 | " \n", 969 | " \n", 970 | " \n", 971 | " \n", 972 | " \n", 973 | " \n", 974 | " \n", 975 | "
SurvivedPclassSexAgeSibSpParchFareEmbarked
003male22.0107.2500S
111female38.01071.2833C
213female26.0007.9250S
311female35.01053.1000S
403male35.0008.0500S
\n", 976 | "
" 977 | ], 978 | "text/plain": [ 979 | " Survived Pclass Sex Age SibSp Parch Fare Embarked\n", 980 | "0 0 3 male 22.0 1 0 7.2500 S\n", 981 | "1 1 1 female 38.0 1 0 71.2833 C\n", 982 | "2 1 3 female 26.0 0 0 7.9250 S\n", 983 | "3 1 1 female 35.0 1 0 53.1000 S\n", 984 | "4 0 3 male 35.0 0 0 8.0500 S" 985 | ] 986 | }, 987 | "execution_count": 15, 988 | "metadata": {}, 989 | "output_type": "execute_result" 990 | } 991 | ], 992 | "source": [ 993 | "data.head()" 994 | ] 995 | }, 996 | { 997 | "cell_type": "code", 998 | "execution_count": 16, 999 | "metadata": {}, 1000 | "outputs": [], 1001 | "source": [ 1002 | "# Get predictor and target variables \n", 1003 | "\n", 1004 | "X = data.drop('Survived', axis = 1)\n", 1005 | "Y = data['Survived']" 1006 | ] 1007 | }, 1008 | { 1009 | "cell_type": "code", 1010 | "execution_count": 17, 1011 | "metadata": {}, 1012 | "outputs": [ 1013 | { 1014 | "name": "stdout", 1015 | "output_type": "stream", 1016 | "text": [ 1017 | "X shape: (889, 7)\n", 1018 | "Y shape: (889,)\n" 1019 | ] 1020 | } 1021 | ], 1022 | "source": [ 1023 | "# Predictor and target variables shape\n", 1024 | "\n", 1025 | "print(\"X shape: \", X.shape)\n", 1026 | "print(\"Y shape: \", Y.shape)" 1027 | ] 1028 | }, 1029 | { 1030 | "cell_type": "markdown", 1031 | "metadata": {}, 1032 | "source": [ 1033 | "# 5.1 Univariate imputation (simple imputer)" 1034 | ] 1035 | }, 1036 | { 1037 | "cell_type": "code", 1038 | "execution_count": 18, 1039 | "metadata": {}, 1040 | "outputs": [ 1041 | { 1042 | "data": { 1043 | "text/plain": [ 1044 | "0.8043156281920327" 1045 | ] 1046 | }, 1047 | "execution_count": 18, 1048 | "metadata": {}, 1049 | "output_type": "execute_result" 1050 | } 1051 | ], 1052 | "source": [ 1053 | "# Instantiate OneHotEncoder for Sex and Embarked columns\n", 1054 | "ohe = OneHotEncoder()\n", 1055 | "\n", 1056 | "# Instantiate simple imputer \n", 1057 | "simple_imp = SimpleImputer(missing_values = np.nan, strategy = 'mean')\n", 1058 | "\n", 1059 | "# Instantiate model\n", 1060 | "rf = RandomForestClassifier()\n", 1061 | "\n", 1062 | "# Make column transformer with simple imputer\n", 1063 | "column_transform = make_column_transformer(\n", 1064 | " (ohe, ['Sex', 'Embarked']),\n", 1065 | " (simple_imp, ['Age']),\n", 1066 | " remainder = 'passthrough')\n", 1067 | "\n", 1068 | "# Pipeline\n", 1069 | "pipe = make_pipeline(column_transform, rf)\n", 1070 | "\n", 1071 | "# 10-fold cross-validation\n", 1072 | "cross_val_score(pipe, X, Y, cv = 10, scoring = 'accuracy').mean()" 1073 | ] 1074 | }, 1075 | { 1076 | "cell_type": "markdown", 1077 | "metadata": {}, 1078 | "source": [ 1079 | "# 5.2 Multivariate imputation (iterative imputer)" 1080 | ] 1081 | }, 1082 | { 1083 | "cell_type": "code", 1084 | "execution_count": 19, 1085 | "metadata": {}, 1086 | "outputs": [ 1087 | { 1088 | "data": { 1089 | "text/plain": [ 1090 | "0.8099336057201226" 1091 | ] 1092 | }, 1093 | "execution_count": 19, 1094 | "metadata": {}, 1095 | "output_type": "execute_result" 1096 | } 1097 | ], 1098 | "source": [ 1099 | "# Instantiate OneHotEncoder for Sex and Embarked columns\n", 1100 | "ohe = OneHotEncoder()\n", 1101 | "\n", 1102 | "# Instantiate iterative imputer\n", 1103 | "iterative_imp = IterativeImputer()\n", 1104 | "\n", 1105 | "# Instantiate model\n", 1106 | "rf = RandomForestClassifier()\n", 1107 | "\n", 1108 | "# Make column transformer with iterative imputer\n", 1109 | "column_transform = make_column_transformer(\n", 1110 | " (ohe, ['Sex', 'Embarked']),\n", 1111 | " (iterative_imp, ['Age']),\n", 1112 | " remainder = 'passthrough')\n", 1113 | "\n", 1114 | "# Pipeline\n", 1115 | "pipe = make_pipeline(column_transform, rf)\n", 1116 | "\n", 1117 | "# 10-fold cross-validation \n", 1118 | "cross_val_score(pipe, X, Y, cv = 10, scoring = 'accuracy').mean()" 1119 | ] 1120 | }, 1121 | { 1122 | "cell_type": "markdown", 1123 | "metadata": {}, 1124 | "source": [ 1125 | "Although not a drastic difference, we can conclude that our model performed better under multivariate imputation as it achieved a higher mean cross-validation score." 1126 | ] 1127 | }, 1128 | { 1129 | "cell_type": "markdown", 1130 | "metadata": {}, 1131 | "source": [ 1132 | "# 6. Conclusion" 1133 | ] 1134 | }, 1135 | { 1136 | "cell_type": "markdown", 1137 | "metadata": {}, 1138 | "source": [ 1139 | "In this tutorial, we have learned the difference between univariate imputation and multivariate imputation. In addition, We also looked at 3 different imputation techniques within Scikit-learn which include simple imputer, iterative imputer and KNN imputer. \n", 1140 | "\n", 1141 | "After comparing the prediction accuracy of our model using simple imputer versus iterative imputer, we can conclude that multivariate imputation results in better model predictions due to its lower mean cross-validation score." 1142 | ] 1143 | }, 1144 | { 1145 | "cell_type": "markdown", 1146 | "metadata": {}, 1147 | "source": [ 1148 | "# 7. References\n", 1149 | "\n", 1150 | "- [Scikit-learn imputation of missing values](https://scikit-learn.org/stable/modules/impute.html)\n", 1151 | "- [Impute missing values using KNNImputer and IterativeImputer](https://www.youtube.com/watch?v=m_qKhnaYZlc)" 1152 | ] 1153 | }, 1154 | { 1155 | "cell_type": "markdown", 1156 | "metadata": {}, 1157 | "source": [ 1158 | "# 8. Follow me on other platforms \n", 1159 | "\n", 1160 | "- [Facebook](https://www.facebook.com/chongjason914)\n", 1161 | "- [Instagram](https://www.instagram.com/chongjason914)\n", 1162 | "- [Twitter](https://www.twitter.com/chongjason914)\n", 1163 | "- [LinkedIn](https://www.linkedin.com/in/chongjason914)\n", 1164 | "- [YouTube](https://www.youtube.com/channel/UCQXiCnjatxiAKgWjoUlM-Xg?view_as=subscriber)\n", 1165 | "- [Medium](https://www.medium.com/@chongjason)" 1166 | ] 1167 | } 1168 | ], 1169 | "metadata": { 1170 | "kernelspec": { 1171 | "display_name": "Python 3", 1172 | "language": "python", 1173 | "name": "python3" 1174 | }, 1175 | "language_info": { 1176 | "codemirror_mode": { 1177 | "name": "ipython", 1178 | "version": 3 1179 | }, 1180 | "file_extension": ".py", 1181 | "mimetype": "text/x-python", 1182 | "name": "python", 1183 | "nbconvert_exporter": "python", 1184 | "pygments_lexer": "ipython3", 1185 | "version": "3.7.6" 1186 | } 1187 | }, 1188 | "nbformat": 4, 1189 | "nbformat_minor": 4 1190 | } 1191 | --------------------------------------------------------------------------------