{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "![MLU Logo](../data/MLU_Logo.png)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Machine Learning Accelerator - Tabular Data - Lecture 1\n", "\n", "\n", "## Exploratory data analysis\n", "\n", "In this notebook, we go through basic steps of exploratory data analysis (EDA), performing initial data investigations to discover patterns, spot anomalies, and look for insights to inform later ML modeling choices.\n", "\n", "1. Read the dataset\n", "2. Overall Statistics\n", "3. Univariate Statistics: Basic Plots\n", "4. Multivariate Statistics: Scatter Plots and Correlations\n", "5. Handling Missing Values\n", " * Drop columns with missing values\n", " * Drop rows with missing values\n", " * Impute (fill-in) missing values with .fillna()\n", " * Impute (fill-in) missing values with sklearn's SimpleImputer\n", " \n", "__Austin Animal Center Dataset__:\n", "\n", "In this exercise, we are working with pet adoption data from __Austin Animal Center__. We have two datasets that cover intake and outcome of animals. Intake data is available from [here](https://data.austintexas.gov/Health-and-Community-Services/Austin-Animal-Center-Intakes/wter-evkm) and outcome is from [here](https://data.austintexas.gov/Health-and-Community-Services/Austin-Animal-Center-Outcomes/9t4d-g238). \n", "\n", "In order to work with a single table, we joined the intake and outcome tables using the \"Animal ID\" column and created a single __review.csv__ file. We also didn't consider animals with multiple entries to the facility to keep our dataset simple. If you want to see the original datasets and the merged data with multiple entries, they are available under data/review folder: Austin_Animal_Center_Intakes.csv, Austin_Animal_Center_Outcomes.csv and Austin_Animal_Center_Intakes_Outcomes.csv.\n", "\n", "__Dataset schema:__ \n", "- __Pet ID__ - Unique ID of pet\n", "- __Outcome Type__ - State of pet at the time of recording the outcome (0 = not placed, 1 = placed). This is the field to predict.\n", "- __Sex upon Outcome__ - Sex of pet at outcome\n", "- __Name__ - Name of pet \n", "- __Found Location__ - Found location of pet before entered the center\n", "- __Intake Type__ - Circumstances bringing the pet to the center\n", "- __Intake Condition__ - Health condition of pet when entered the center\n", "- __Pet Type__ - Type of pet\n", "- __Sex upon Intake__ - Sex of pet when entered the center\n", "- __Breed__ - Breed of pet \n", "- __Color__ - Color of pet \n", "- __Age upon Intake Days__ - Age of pet when entered the center (days)\n", "- __Age upon Outcome Days__ - Age of pet at outcome (days)\n" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\u001b[33mWARNING: You are using pip version 21.3.1; however, version 22.3.1 is available.\n", "You should consider upgrading via the '/home/ec2-user/anaconda3/envs/pytorch_p39/bin/python -m pip install --upgrade pip' command.\u001b[0m\n", "Note: you may need to restart the kernel to use updated packages.\n" ] } ], "source": [ "%pip install -q -r ../requirements.txt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1. Read the dataset\n", "(Go to top)\n", "\n", "Let's read the dataset into a dataframe, using Pandas." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The shape of the dataset is: (95485, 13)\n" ] } ], "source": [ "import pandas as pd\n", "\n", "import warnings\n", "warnings.filterwarnings(\"ignore\")\n", " \n", "df = pd.read_csv('../data/review/review_dataset.csv')\n", "\n", "print('The shape of the dataset is:', df.shape)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2. Overall Statistics\n", "(Go to top)\n", "\n", "We will look at number of rows, columns and some simple statistics of the dataset." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
Pet IDOutcome TypeSex upon OutcomeNameFound LocationIntake TypeIntake ConditionPet TypeSex upon IntakeBreedColorAge upon Intake DaysAge upon Outcome Days
0A7940111.0Neutered MaleChunkAustin (TX)Owner SurrenderNormalCatNeutered MaleDomestic Shorthair MixBrown Tabby/White730730
1A7763591.0Neutered MaleGizmo7201 Levander Loop in Austin (TX)StrayNormalDogIntact MaleChihuahua Shorthair MixWhite/Brown365365
2A6747540.0Intact MaleNaN12034 Research in Austin (TX)StrayNursingCatIntact MaleDomestic Shorthair MixOrange Tabby66
3A6897241.0Neutered Male*Donatello2300 Waterway Bnd in Austin (TX)StrayNormalCatIntact MaleDomestic Shorthair MixBlack6060
4A6809691.0Neutered Male*Zeus4701 Staggerbrush Rd in Austin (TX)StrayNursingCatIntact MaleDomestic Shorthair MixWhite/Orange Tabby760
\n", "
" ], "text/plain": [ " Pet ID Outcome Type Sex upon Outcome Name \\\n", "0 A794011 1.0 Neutered Male Chunk \n", "1 A776359 1.0 Neutered Male Gizmo \n", "2 A674754 0.0 Intact Male NaN \n", "3 A689724 1.0 Neutered Male *Donatello \n", "4 A680969 1.0 Neutered Male *Zeus \n", "\n", " Found Location Intake Type Intake Condition \\\n", "0 Austin (TX) Owner Surrender Normal \n", "1 7201 Levander Loop in Austin (TX) Stray Normal \n", "2 12034 Research in Austin (TX) Stray Nursing \n", "3 2300 Waterway Bnd in Austin (TX) Stray Normal \n", "4 4701 Staggerbrush Rd in Austin (TX) Stray Nursing \n", "\n", " Pet Type Sex upon Intake Breed Color \\\n", "0 Cat Neutered Male Domestic Shorthair Mix Brown Tabby/White \n", "1 Dog Intact Male Chihuahua Shorthair Mix White/Brown \n", "2 Cat Intact Male Domestic Shorthair Mix Orange Tabby \n", "3 Cat Intact Male Domestic Shorthair Mix Black \n", "4 Cat Intact Male Domestic Shorthair Mix White/Orange Tabby \n", "\n", " Age upon Intake Days Age upon Outcome Days \n", "0 730 730 \n", "1 365 365 \n", "2 6 6 \n", "3 60 60 \n", "4 7 60 " ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Print the first five rows\n", "# NaN means missing data\n", "df.head()" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "RangeIndex: 95485 entries, 0 to 95484\n", "Data columns (total 13 columns):\n", " # Column Non-Null Count Dtype \n", "--- ------ -------------- ----- \n", " 0 Pet ID 95485 non-null object \n", " 1 Outcome Type 95485 non-null float64\n", " 2 Sex upon Outcome 95484 non-null object \n", " 3 Name 59138 non-null object \n", " 4 Found Location 95485 non-null object \n", " 5 Intake Type 95485 non-null object \n", " 6 Intake Condition 95485 non-null object \n", " 7 Pet Type 95485 non-null object \n", " 8 Sex upon Intake 95484 non-null object \n", " 9 Breed 95485 non-null object \n", " 10 Color 95485 non-null object \n", " 11 Age upon Intake Days 95485 non-null int64 \n", " 12 Age upon Outcome Days 95485 non-null int64 \n", "dtypes: float64(1), int64(2), object(10)\n", "memory usage: 9.5+ MB\n" ] } ], "source": [ "# Let's see the data types and non-null values for each column\n", "df.info()" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
Outcome TypeAge upon Intake DaysAge upon Outcome Days
count95485.00000095485.00000095485.000000
mean0.564005703.436959717.757313
std0.4958891052.2521971055.023160
min0.0000000.0000000.000000
25%0.00000030.00000060.000000
50%1.000000365.000000365.000000
75%1.000000730.000000730.000000
max1.0000009125.0000009125.000000
\n", "
" ], "text/plain": [ " Outcome Type Age upon Intake Days Age upon Outcome Days\n", "count 95485.000000 95485.000000 95485.000000\n", "mean 0.564005 703.436959 717.757313\n", "std 0.495889 1052.252197 1055.023160\n", "min 0.000000 0.000000 0.000000\n", "25% 0.000000 30.000000 60.000000\n", "50% 1.000000 365.000000 365.000000\n", "75% 1.000000 730.000000 730.000000\n", "max 1.000000 9125.000000 9125.000000" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# This prints basic statistics for numerical columns\n", "df.describe()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's separate model features and model target." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Index(['Pet ID', 'Outcome Type', 'Sex upon Outcome', 'Name', 'Found Location',\n", " 'Intake Type', 'Intake Condition', 'Pet Type', 'Sex upon Intake',\n", " 'Breed', 'Color', 'Age upon Intake Days', 'Age upon Outcome Days'],\n", " dtype='object')\n" ] } ], "source": [ "print(df.columns)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Model features: Index(['Pet ID', 'Sex upon Outcome', 'Name', 'Found Location', 'Intake Type',\n", " 'Intake Condition', 'Pet Type', 'Sex upon Intake', 'Breed', 'Color',\n", " 'Age upon Intake Days', 'Age upon Outcome Days'],\n", " dtype='object')\n", "Model target: Outcome Type\n" ] } ], "source": [ "model_features = df.columns.drop('Outcome Type')\n", "model_target = 'Outcome Type'\n", "\n", "print('Model features: ', model_features)\n", "print('Model target: ', model_target)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can explore the features set further, figuring out first what features are numerical or categorical. Beware that some integer-valued features could actually be categorical features, and some categorical features could be text features. " ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Numerical columns: Index(['Age upon Intake Days', 'Age upon Outcome Days'], dtype='object')\n", "\n", "Categorical columns: Index(['Pet ID', 'Sex upon Outcome', 'Name', 'Found Location', 'Intake Type',\n", " 'Intake Condition', 'Pet Type', 'Sex upon Intake', 'Breed', 'Color'],\n", " dtype='object')\n" ] } ], "source": [ "import numpy as np\n", "numerical_features_all = df[model_features].select_dtypes(include=np.number).columns\n", "print('Numerical columns:',numerical_features_all)\n", "\n", "print('')\n", "\n", "categorical_features_all = df[model_features].select_dtypes(include='object').columns\n", "print('Categorical columns:',categorical_features_all)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3. Basic Plots\n", "(Go to top)\n", "\n", "In this section, we examine our data with plots. Important note: These plots ignore null (missing) values. We will learn how to deal with missing values in the next section.\n", "\n", "\n", "__Bar plots__: These plots show counts of categorical data fields. __value_counts()__ function yields the counts of each unique value. It is useful for categorical variables.\n", "\n", "First, let's look at the distribution of the model target." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1.0 53854\n", "0.0 41631\n", "Name: Outcome Type, dtype: int64" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df[model_target].value_counts()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__plot.bar()__ addition to the __value_counts()__ function makes a bar plot of the values." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "%matplotlib inline\n", "\n", "df[model_target].value_counts().plot.bar()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now onto the categorical features, exploring number of unique values per feature." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "A794011 1\n", "A666713 1\n", "A725018 1\n", "A757574 1\n", "A737442 1\n", " ..\n", "A758938 1\n", "A779434 1\n", "A699290 1\n", "A779183 1\n", "A815419 1\n", "Name: Pet ID, Length: 95485, dtype: int64\n", "Neutered Male 30244\n", "Spayed Female 28145\n", "Intact Female 13724\n", "Intact Male 13646\n", "Unknown 9725\n", "Name: Sex upon Outcome, dtype: int64\n", "Bella 338\n", "Luna 313\n", "Max 311\n", "Daisy 239\n", "Lucy 223\n", " ... \n", "Ewok 1\n", "*Clouseau 1\n", "*Minky 1\n", "Tigger Lily 1\n", "*Squanchy 1\n", "Name: Name, Length: 17468, dtype: int64\n", "Austin (TX) 14833\n", "Travis (TX) 1402\n", "7201 Levander Loop in Austin (TX) 644\n", "Outside Jurisdiction 607\n", "Del Valle (TX) 426\n", " ... \n", "Cherry Creek On Brodie Ln in Austin (TX) 1\n", "Cameron Rd At Parmer Ln in Austin (TX) 1\n", "303 W. Mlk in Austin (TX) 1\n", "131 Totvia Drive in Bastrop (TX) 1\n", "1311 Hyman in Austin (TX) 1\n", "Name: Found Location, Length: 43951, dtype: int64\n", "Stray 70203\n", "Owner Surrender 15146\n", "Public Assist 5236\n", "Wildlife 4554\n", "Euthanasia Request 235\n", "Abandoned 111\n", "Name: Intake Type, dtype: int64\n", "Normal 81912\n", "Injured 5386\n", "Sick 4291\n", "Nursing 3172\n", "Aged 352\n", "Other 189\n", "Feral 97\n", "Pregnant 63\n", "Medical 21\n", "Behavior 2\n", "Name: Intake Condition, dtype: int64\n", "Dog 48719\n", "Cat 40082\n", "Other 6115\n", "Bird 553\n", "Livestock 16\n", "Name: Pet Type, dtype: int64\n", "Intact Male 33369\n", "Intact Female 32515\n", "Neutered Male 10521\n", "Unknown 9725\n", "Spayed Female 9354\n", "Name: Sex upon Intake, dtype: int64\n", "Domestic Shorthair Mix 27689\n", "Domestic Shorthair 5076\n", "Pit Bull Mix 5017\n", "Chihuahua Shorthair Mix 4963\n", "Labrador Retriever Mix 4789\n", " ... \n", "Carolina Dog/Border Collie 1\n", "Swedish Vallhund 1\n", "Plott Hound/Dachshund 1\n", "Miniature Schnauzer/Labrador Retriever 1\n", "Airedale Terrier/Standard Poodle 1\n", "Name: Breed, Length: 2395, dtype: int64\n", "Black/White 9688\n", "Black 8528\n", "Brown Tabby 6077\n", "Brown 4440\n", "White 3312\n", " ... \n", "Chocolate/Gold 1\n", "Torbie/Calico 1\n", "Yellow/Red 1\n", "Orange/Gray 1\n", "Tortie Point/Seal Point 1\n", "Name: Color, Length: 567, dtype: int64\n" ] } ], "source": [ "for c in categorical_features_all: \n", " print(df[c].value_counts())\n", " " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Based on the number of unique values (unique IDs for example won't be very useful to visualize, for example), for some categorical features, let's see some bar plot visualizations. For simplicity and speed, here we only show box plots for those features with less than 50 unique values." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Sex upon Outcome\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAE7CAYAAAA//e0KAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAe80lEQVR4nO3de7xcZX3v8c+XIHKX2xYpRIMQsfFCiBGwaquiEKAeUFGhKjlIxXME662t0VcVqtKKVu0BhRYlGrwFvPAi1SBQ5IhWuSTcwSIpl0MiQiDcsWDge/5Yz2YPm9nZMzvJPLOZ7/v1mteeedaa2b9Zr73nO2s9z3qWbBMREYNtg9oFREREfQmDiIhIGERERMIgIiJIGEREBAmDiIgANqxdwERtt912njZtWu0yIiImlaVLl95le2h0+6QNg2nTprFkyZLaZURETCqSbm3XnsNEERGRMIiIiIRBRESQMIiICBIGERFBwiAiIuggDCRtLOlSSVdJuk7S35f2nSVdImmZpDMkbVTan1keLyvLp7W81sdK+w2S9mtpn1Palkmatx7eZ0RErEEnewaPAK+zvTswE5gjaW/gBOBLtncF7gGOLOsfCdxT2r9U1kPSDOBQ4EXAHOBkSVMkTQG+AuwPzAAOK+tGRESPjHvSmZur3zxYHj6j3Ay8DviL0r4AOA44BTio3Af4PvBlSSrtC20/AtwsaRmwZ1lvme2bACQtLOtevzZvbDzT5v14fb58x2757IG1S4iI6KzPoHyDvxK4Ezgf+C/gXturyyrLgR3L/R2B2wDK8vuAbVvbRz1nrPaIiOiRjsLA9mO2ZwI70Xybf+H6LGosko6StETSkpUrV9YoISLiaamr0US27wUuBF4BbCVp+DDTTsCKcn8FMBWgLH8WcHdr+6jnjNXe7vefanu27dlDQ0+ZZykiIiaok9FEQ5K2Kvc3Ad4A/JomFA4pq80Fzi73F5XHlOU/Lf0Oi4BDy2ijnYHpwKXAZcD0MjppI5pO5kXr4L1FRESHOpm1dAdgQRn1swFwpu0fSboeWCjpM8AVwGll/dOAb5YO4lU0H+7Yvk7SmTQdw6uBo20/BiDpGOBcYAow3/Z16+wdRkTEuDoZTXQ1sEeb9psYGQ3U2v7fwFvHeK3jgePbtC8GFndQb0RErAc5AzkiIhIGERGRMIiICBIGERFBwiAiIkgYREQECYOIiCBhEBERdHYGcjzNZTrviMieQUREJAwiIiJhEBERJAwiIoKEQUREkDCIiAgSBhERQcIgIiJIGEREBAmDiIggYRARESQMIiKChEFERJAwiIgIEgYREUHCICIi6CAMJE2VdKGk6yVdJ+kDpf04SSskXVluB7Q852OSlkm6QdJ+Le1zStsySfNa2neWdElpP0PSRuv6jUZExNg62TNYDXzE9gxgb+BoSTPKsi/ZnlluiwHKskOBFwFzgJMlTZE0BfgKsD8wAzis5XVOKK+1K3APcOQ6en8REdGBccPA9u22Ly/3HwB+Dey4hqccBCy0/Yjtm4FlwJ7ltsz2TbYfBRYCB0kS8Drg++X5C4CDJ/h+IiJiArrqM5A0DdgDuKQ0HSPpaknzJW1d2nYEbmt52vLSNlb7tsC9tlePao+IiB7pOAwkbQ78APig7fuBU4BdgJnA7cAX1keBo2o4StISSUtWrly5vn9dRMTA6CgMJD2DJgi+bfuHALbvsP2Y7ceBr9IcBgJYAUxtefpOpW2s9ruBrSRtOKr9KWyfanu27dlDQ0OdlB4RER3oZDSRgNOAX9v+Ykv7Di2rvQm4ttxfBBwq6ZmSdgamA5cClwHTy8ihjWg6mRfZNnAhcEh5/lzg7LV7WxER0Y0Nx1+FVwLvAq6RdGVp+zjNaKCZgIFbgPcC2L5O0pnA9TQjkY62/RiApGOAc4EpwHzb15XX+yiwUNJngCtowiciInpk3DCw/QtAbRYtXsNzjgeOb9O+uN3zbN/EyGGmiIjosZyBHBERCYOIiEgYREQECYOIiCBhEBERJAwiIoKEQUREkDCIiAgSBhERQcIgIiJIGEREBAmDiIggYRARESQMIiKChEFERJAwiIgIEgYREUHCICIiSBhERAQJg4iIIGEQEREkDCIigoRBRESQMIiICBIGERFBwiAiIuggDCRNlXShpOslXSfpA6V9G0nnS7qx/Ny6tEvSiZKWSbpa0qyW15pb1r9R0tyW9pdJuqY850RJWh9vNiIi2utkz2A18BHbM4C9gaMlzQDmARfYng5cUB4D7A9ML7ejgFOgCQ/gWGAvYE/g2OEAKeu8p+V5c9b+rUVERKfGDQPbt9u+vNx/APg1sCNwELCgrLYAOLjcPwg43Y2Lga0k7QDsB5xve5Xte4DzgTll2Za2L7Zt4PSW14qIiB7oqs9A0jRgD+ASYHvbt5dFvwO2L/d3BG5redry0ram9uVt2iMiokc6DgNJmwM/AD5o+/7WZeUbvddxbe1qOErSEklLVq5cub5/XUTEwOgoDCQ9gyYIvm37h6X5jnKIh/LzztK+Apja8vSdStua2ndq0/4Utk+1Pdv27KGhoU5Kj4iIDnQymkjAacCvbX+xZdEiYHhE0Fzg7Jb2w8uoor2B+8rhpHOBfSVtXTqO9wXOLcvul7R3+V2Ht7xWRET0wIYdrPNK4F3ANZKuLG0fBz4LnCnpSOBW4G1l2WLgAGAZ8DBwBIDtVZI+DVxW1vuU7VXl/vuAbwCbAOeUW0RE9Mi4YWD7F8BY4/73abO+gaPHeK35wPw27UuAF49XS0RErB85AzkiIhIGERGRMIiICBIGERFBwiAiIkgYREQECYOIiCBhEBERJAwiIoKEQUREkDCIiAgSBhERQcIgIiJIGEREBAmDiIggYRARESQMIiKChEFERJAwiIgIEgYREUHCICIiSBhERAQJg4iIIGEQEREkDCIigg7CQNJ8SXdKural7ThJKyRdWW4HtCz7mKRlkm6QtF9L+5zStkzSvJb2nSVdUtrPkLTRunyDERExvk72DL4BzGnT/iXbM8ttMYCkGcChwIvKc06WNEXSFOArwP7ADOCwsi7ACeW1dgXuAY5cmzcUERHdGzcMbF8ErOrw9Q4CFtp+xPbNwDJgz3JbZvsm248CC4GDJAl4HfD98vwFwMHdvYWIiFhba9NncIykq8thpK1L247AbS3rLC9tY7VvC9xre/Wo9oiI6KGJhsEpwC7ATOB24AvrqqA1kXSUpCWSlqxcubIXvzIiYiBMKAxs32H7MduPA1+lOQwEsAKY2rLqTqVtrPa7ga0kbTiqfazfe6rt2bZnDw0NTaT0iIhoY0JhIGmHlodvAoZHGi0CDpX0TEk7A9OBS4HLgOll5NBGNJ3Mi2wbuBA4pDx/LnD2RGqKiIiJ23C8FSR9F3gNsJ2k5cCxwGskzQQM3AK8F8D2dZLOBK4HVgNH236svM4xwLnAFGC+7evKr/gosFDSZ4ArgNPW1ZuLiIjOjBsGtg9r0zzmB7bt44Hj27QvBha3ab+JkcNMERFRQc5AjoiIhEFERCQMIiKChEFERNBBB3LEIJk278e1SwDgls8eWLuEbIsBkz2DiIhIGERERMIgIiJIGEREBAmDiIggYRARESQMIiKChEFERJAwiIgIEgYREUHCICIiSBhERAQJg4iIIGEQEREkDCIigoRBRESQMIiICBIGERFBwiAiIkgYREQEHYSBpPmS7pR0bUvbNpLOl3Rj+bl1aZekEyUtk3S1pFktz5lb1r9R0tyW9pdJuqY850RJWtdvMiIi1qyTPYNvAHNGtc0DLrA9HbigPAbYH5hebkcBp0ATHsCxwF7AnsCxwwFS1nlPy/NG/66IiFjPxg0D2xcBq0Y1HwQsKPcXAAe3tJ/uxsXAVpJ2APYDzre9yvY9wPnAnLJsS9sX2zZwestrRUREj0y0z2B727eX+78Dti/3dwRua1lveWlbU/vyNu0REdFDa92BXL7Rex3UMi5JR0laImnJypUre/ErIyIGwkTD4I5yiIfy887SvgKY2rLeTqVtTe07tWlvy/aptmfbnj00NDTB0iMiYrQNJ/i8RcBc4LPl59kt7cdIWkjTWXyf7dslnQv8Q0un8b7Ax2yvknS/pL2BS4DDgZMmWFNExHoxbd6Pa5cAwC2fPXC9vfa4YSDpu8BrgO0kLacZFfRZ4ExJRwK3Am8rqy8GDgCWAQ8DRwCUD/1PA5eV9T5le7hT+n00I5Y2Ac4pt4iI6KFxw8D2YWMs2qfNugaOHuN15gPz27QvAV48Xh0REbH+5AzkiIhIGERERMIgIiJIGEREBAmDiIggYRARESQMIiKChEFERJAwiIgIEgYREUHCICIiSBhERAQJg4iIIGEQEREkDCIigoRBRESQMIiICBIGERFBwiAiIkgYREQECYOIiCBhEBERJAwiIoKEQUREkDCIiAjWMgwk3SLpGklXSlpS2raRdL6kG8vPrUu7JJ0oaZmkqyXNanmduWX9GyXNXbu3FBER3VoXewavtT3T9uzyeB5wge3pwAXlMcD+wPRyOwo4BZrwAI4F9gL2BI4dDpCIiOiN9XGY6CBgQbm/ADi4pf10Ny4GtpK0A7AfcL7tVbbvAc4H5qyHuiIiYgxrGwYGzpO0VNJRpW1727eX+78Dti/3dwRua3nu8tI2VntERPTIhmv5/FfZXiHp2cD5kv6zdaFtS/Ja/o4nlMA5CuC5z33uunrZiIiBt1Z7BrZXlJ93AmfRHPO/oxz+ofy8s6y+Apja8vSdSttY7e1+36m2Z9uePTQ0tDalR0REiwmHgaTNJG0xfB/YF7gWWAQMjwiaC5xd7i8CDi+jivYG7iuHk84F9pW0dek43re0RUREj6zNYaLtgbMkDb/Od2z/RNJlwJmSjgRuBd5W1l8MHAAsAx4GjgCwvUrSp4HLynqfsr1qLeqKiIguTTgMbN8E7N6m/W5gnzbtBo4e47XmA/MnWktERKydnIEcEREJg4iISBhERAQJg4iIIGEQEREkDCIigoRBRESQMIiICBIGERFBwiAiIkgYREQECYOIiCBhEBERJAwiIoKEQUREkDCIiAgSBhERQcIgIiJIGEREBAmDiIggYRARESQMIiKChEFERJAwiIgIEgYREUHCICIi6KMwkDRH0g2SlkmaV7ueiIhB0hdhIGkK8BVgf2AGcJikGXWriogYHH0RBsCewDLbN9l+FFgIHFS5poiIgdEvYbAjcFvL4+WlLSIiekC2a9eApEOAObb/sjx+F7CX7WNGrXcUcFR5uBtwQ08LfartgLsq19Avsi1GZFuMyLYY0S/b4nm2h0Y3blijkjZWAFNbHu9U2p7E9qnAqb0qajySltieXbuOfpBtMSLbYkS2xYh+3xb9cpjoMmC6pJ0lbQQcCiyqXFNExMDoiz0D26slHQOcC0wB5tu+rnJZEREDoy/CAMD2YmBx7Tq61DeHrPpAtsWIbIsR2RYj+npb9EUHckRE1NUvfQYREVFRwiAiIhIG3ZC0qaRPSPpqeTxd0p/XrquGbIsnk/Q8Sa8v9zeRtEXtmmqQ9AJJF0i6tjx+qaS/q11XjC99Bl2QdAawFDjc9oslbQr80vbMupX1XrbFCEnvoTkZchvbu0iaDvyL7X0ql9Zzkn4G/A3wr7b3KG3X2n5x3crqkPRM4C3ANFoG7Nj+VK2axpI9g+7sYvtzwB8AbD8MqG5J1WRbjDgaeCVwP4DtG4FnV62onk1tXzqqbXWVSvrD2TTzrK0GHmq59Z2+GVo6STwqaRPAAJJ2AR6pW1I12RYjHrH9qNRkoaQNKdtlAN1V/haG/y4OAW6vW1JVO9meU7uITiQMunMs8BNgqqRv03wb/J9VK6on22LEzyR9HNhE0huA9wH/VrmmWo6mGU//QkkrgJuBd9YtqapfSnqJ7WtqFzKe9Bl0SdK2wN40h0Qutt0PE09VkW3RkLQBcCSwL822OBf4mgf4n0vSZsAGth+oXUtNkq4HdqUJxUdo/j5s+6VVC2sjYdABSbPWtNz25b2qpbZsi2hH0ofXtNz2F3tVSz+R9Lx27bZv7XUt48lhos58YQ3LDLyuV4X0gWyLQtI1rKFvoB+//a1HAzmUtgN/CVxEM9KuLzuOh2XPIGKCxvrWN6wfv/1Fb0k6Ang18ArgAeDnwEW2z65aWBsJgy5JejHNdZo3Hm6zfXq9iurJtojRJG1M03/yIp78d/HuakX1AUnPAd4G/DWwte2+25PKeQZdkHQscFK5vRb4HPA/qhZVSbbFCEl7S7pM0oOSHpX0mKT7a9dVyTeB5wD7AT+juVDVwHYiS/qapF8Cp9Aclj8E2LpuVe0lDLpzCLAP8DvbRwC7A8+qW1I12RYjvgwcBtwIbEJznPgrVSuqZ1fbnwAesr0AOBDYq3JNNW1Lc42We4FVwF22+/IkvIRBd35v+3FgtaQtgTt58uU6B0m2RQvby4Apth+z/XVgUpxotB78ofy8txxGfBaDezY2tt9key+aPeetgAslLa9bVXsZTdSdJZK2Ar5KMy/Pg8CvqlZUT7bFiIfL5VqvlPQ5mjNuB/WL1qmStgY+QXPp2s2BT9YtqZ4yeeOrgT+lCYOf0nQi9510IE+QpGnAlravrl1LbYO+LcqoojuBZwAfovk2fHLZW4gBJunLNB/+P7f929r1rEnCoAM50ao9SS/lqbMx/rBaQVFNTjobm6TtgZeXh5favrNmPWNJGHRA0uPAtcDwdAuts3Pa9sCcaDVM0nzgpcB1wOOl2YM4hLAcCvg08DyaYByecmDLqoX1UPkfuRI4h5FpF55g++8rlFWdpLcC/wT8X5pt8mrgb2x/v2Zd7SQMOiDpgzSjZ+4DFgJn2X6walGVSbre9ozadfQDScuANwPXDOp8RJJ2pxlRNYemD+m7wAWDuj2GSboKeMPw3oCkIeDfbe9et7KnGtROrq7Y/mfbrwLeTzNi5gJJZ0qaWbeyqn4lKWHQuA24dpA/+GxfZXteubjRaTRz+F8vaSDPPWmxwajDQnfTp5+7GU3UBds3STqbZiz5u4AX0OwaD6LTaQLhd/T5bIw98LfA4nKVryeu6TCIx8nLN989gJcAy2k61gfZTySdS7OnBPB2YHHFesaUw0QdkPR84FCabzu30Rwq+rHt31ctrKJyaOTDwDWM9BkM5Hw8ks6jGVo7elsMzHFySe+mmW5hY+D7wJn92lHaa5LeQnO9D2hGFZ1Vs56xJAw6UDrHrqa5hN39jJqpckC/Af7K9itq19EPBvkav8NaBlkMfxkY/T8y6IeL+l4OE3XmU4z8cW9es5A+coWk79Bc0av10MggDi1dLGlf2+fVLqSi19YuoB9JejNwAs1Z2KKPR5plzyAmRNLX2zQP6tDSB4DNgEfLrW//4aO3yuHUN9r+de1axpMwiIhYTyT9h+1Xjr9mfX05xCn6n6QXSLpA0rXl8Usl/V3tumpQ452SPlEeT5W0Z+26oi8skXSGpMMkvXn4VruodhIGMVFfBT5GmaWyzEt0aNWK6jmZ5kpWf1EeP8iATmFdzrgdt22AbAk8DOwLvLHc/rxqRWNIB3IHMu9KW5vavlR60qwDfTlPew/sZXuWpCsAbN9TZjEdRB8DvtdB26D4iO1VrQ2Sdq5VzJokDDozfIm63WgmnFpUHr8RuLRKRfXdJWkXyigrSYfQTN08iP4gaQoj22KIlvMNBoGk/YEDgB0lndiyaEsG90sCwL9J2t/2/QCS/pgmGPtuKHLCoAPDJw9JugiYZfuB8vg44McVS6vpaOBU4IWSVgA3A++oW1I1JwJnAc+WdDzNPFaD1n/yW2AJzaVPl7a0P0Azrfeg+geaQDiQ5svk6fTp/0lGE3VB0g3AS20/Uh4/E7ja9m51K+sdSXvbvrjl8WY0868M7HVuASS9kOYyoKKZoK3vhxKuD+Wqdw/Zfqw8ngI80/bDdSurR9LBNFOWbAG8xfZv6lbUXvYMunM6cKmk4dPJDwYW1CunipOBWZCzkCWdZ3vf8vBNtv+xakH94Tzg9TSd6NDM43Ue8CfVKqpA0kk8+SzsZwH/BRwjCdt/VaeysSUMumD7eEnn0MxJDnCE7Stq1lRBa4/xxtWq6A9DLfffCiQMYOPW6d1tPyhp05oFVbJk1OOlbdfqIwmD7m0K3G/765KGJO1s++baRfXQBuUatxu03H8iIEaPnHiayzHWp3pI0qzhq/9JehkwcBM62p50RwzSZ9AFSccCs4HdbL9A0h8B35ssZxiuC5JuoRkpozaLbfv5va2oHkn3AhcxcgWri1qXD+LkbJJeTjOr729ptstzgLfb7vtvxuuDpFcCx/HUq+D13f9JwqALkq6kmav9ctt7lLarB3QO/4En6c/WtNz2z3pVSz+R9AyakTMAN9j+Q816apL0nzSjqZYCjw232767WlFjyGGi7jxq25KGx5NvVrugqGdQP+w7sBswg6ZPaVbpMD29ck213Gf7nNpFdCJh0J0zJf0rsJWk9wDvppmWISJ44lDqa2jCYDGwP/ALmpF4g+hCSZ8HfsiTp3q/vF5J7eUwUYfUzLuwE/BCmnlGBJxr+/yqhUX0EUnXALsDV9jeXdL2wLdsv6FyaVVIurDcHf6gHe4zeF2lksaUPYMOlcNDi22/BBjYAJC0zZqWD9hoIqCZiM3298ZrGxC/t/24pNXlBLQ7gam1i+q1lvnMflR+GlgJ/KJfRx9m1tLuXF5GSwyypTRjqJfS/HH/Brix3B/IESM0E7F10jYIlkjaiubw6VLgcuBXVSuqY4ty27zctqAZiXiOpL6c3TeHibpQRgZMB24BHmJkl2/gRhNJ+ipwlu3F5fH+wMG231u3st5pmZztbcAZLYu2BGbYHuhrGkiaBmxZpjcPntiz/nfbs2rXMlrCoAuSnteu3fat7dqfziRdUw6ZrbHt6UzS7sBMmmtkf7Jl0QPAhbbvqVFXTZIusL3PeG2DTNIVw0PT+0n6DLpg+1ZJrwKmD5+BTLMLOIh+W65s9q3y+B00JxoNDNtXAVeVuaqeMjlb1eJ6TNLGNGfnbzfqrPQtgR2rFdZnJL0W6MsvCQmDLrSegQx8HXgGzYfhwJyB3OIw4FiaqZtNc/btYVUrqieTs8F7gQ8Cf0TTVzAcBvcDX65UUzVlVNXowy7b0HxhOrz3FY0vh4m6kDOQn0rSZrYfql1HTZKutD1zvLZBIOn9tk+qXUdtbQ4pG7i7n/9XsmfQnZyBXEj6E+BrNIfJnluOn7/X9vvqVlZFJmcrbJ9U/jam0fL5MmhnIE/GfsSEQXfanYH8tco11fIlYD/KJUBtXyXpT+uWVM0Hge9JetLkbFUrqkTSN4FdgCsZmYvHDO4ZyJNGwqALtv9J0htojoPuBnxykM9Atn1bc2L2Ex4ba92nM9uXlSudZXK2pk9thnP8edJJGHRB0gm2P0rLGcgtbYPmtnI4wGWWyg8AA3mpxyKTszWupdkzur12IdGddCB3QdLlo08WGdQOZEnbAf+HZhSNaEbPfKAfp+Zd38aanM32ITXrqqHMxTMTuJQnT8w2cNd2mGyyZ9ABSf8beB/wfEmtZ1NuAfxHnaqqs+131C6iTxzCyORsRwxPzla5plqOq11ATEzCoDPfAc6hucbtvJb2BwZxYrbi4jLUdj7wkwE/RpzJ2Ypc42HyShh0wPZ9wH2SRvcNbC5pc9v/r0Zdlb2A5hDRu4GTJJ0JfMP2b+qWVcXoydkeZMAmZ5P0AO2vCT08f9eWPS4pupQ+gy60nFUomo7CnWlGjryoamGVlVPsvwVsBlwFzLM9UB+GwzI5W0xW2TPoQpuJ2WbR9CUMHEnbAu8E3gXcAbyf5pyDmcD3aIJyILROxGb7ltFtEZNBwmAt2L5c0l6166jkV8A3aaatXt7SvkTSv1SqqacyOVs8nSQMutBy9SJoLgw0iwGbqbPFbmN1Gts+odfFVJLJ2eJpI30GXSjjyYetprnIzQ9s/3ediuop03f/LfAimv4TAPrx2q7rWyZni6eDhMEESNrU9sO166hJ0nk0V/f6a+B/AXOBlQN6NvbwxH3TGODJ2WJySxh0QdIrgNOAzW0P9EydkpbaflnrGdiSLrM9cNeIHmtyNtt/Va2oiC6lz6A7/0xm6hw2PBHb7ZIOpOk72aZiPTVlcraY9BIGXcpMnU/4jKRnAR8BTqIZQfOhuiVVk8nZYtJLGHQnM3UWtn9U7t4HvLZmLX1gO+B6SZmcLSat9Bl0ITN1jpD0fJpt8QrgcZrzDj5k+6aqhVUg6c/atWeenphMEgYxIZIuBr4CfLc0HQq83/agnoQXMaklDDog6ZNrWGzbn+5ZMX2i3XUcJF1le/daNfVaJmeLp5OEQQckfaRN82bAkcC2tjfvcUnVSToBuAdYSPOB+HZga+DzAAM8tXfEpJQw6JKkLWg6jo8EzgS+YPvOulX1nqSb17DYtp/fs2IiYq1lNFGHJG0DfBh4B7AAmGX7nrpV1WN7YGYljRgEG9QuYDKQ9HngMuAB4CW2jxvUIJD0cknPaXl8uKSzJZ1YAjMiJqEcJuqApMdpxo+v5skdhgPXUSjpcuD1tleVs68X0lzLYCbwx4N4EfiIp4McJuqA7exBjZjS0jn8duBU2z8AflCuiRwRk1A+5KJbUyQNf4nYB/hpy7J8uYiYpPLPG936LvAzSXcBvwd+DiBpV5qpKSJiEkqfQXRN0t7ADsB5th8qbS+gmdr78qrFRcSEJAwiIiJ9BhERkTCIiAgSBhERQcIgIiJIGEREBPD/AVp0jUChzOfvAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Intake Type\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Intake Condition\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Pet Type\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Sex upon Intake\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAE+CAYAAABvMHy5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAge0lEQVR4nO3de5gcdZ3v8feHAHIRTMAR2QS5RjCiBAwQ9ehRUAigC66o8LiSRda4K3i8HVdwVRDkrJdVjyByjBIJ6hrxwhI1GCLidQWSYLjLOstlSQSJJFwEBQOf80f9hmmGnpnuSdLVQ39ez9NPqr9V1f3tpphvV/0uJdtERERv26TuBCIion4pBhERkWIQEREpBhERQYpBRESQYhAREbRQDCRtIekqSddIukHSR0v8fEm3SlpRHtNLXJLOktQv6VpJ+zW81mxJvy2P2Q3xF0m6ruxzliRthM8aERHD2LSFbR4GDrL9R0mbAb+QdElZ937b3x6y/WHA1PI4EDgXOFDSdsCpwAzAwHJJC22vLdu8DbgSWATMAi4hIiI6YtQzA1f+WJ5uVh4jjVQ7Erig7HcFMFHSjsChwBLba0oBWALMKuu2tX2FqxFwFwBHjf0jRUREu1o5M0DSBGA5sAdwju0rJf0jcKakjwCXASfbfhiYDNzRsPvKEhspvrJJvFkec4A5AFtvvfWL9tprr1bSj4iIYvny5X+w3Tc03lIxsP0oMF3SROAiSXsDpwB3AZsDc4EPAKdvsIyb5zG3vBczZszwsmXLNubbRUQ85Ui6vVm8rd5Etu8FLgdm2b6zXAp6GPgKcEDZbBWwU8NuU0pspPiUJvGIiOiQVnoT9ZUzAiRtCbwa+E251k/p+XMUcH3ZZSFwXOlVNBO4z/adwGLgEEmTJE0CDgEWl3X3S5pZXus44OIN+SEjImJkrVwm2hGYX9oNNgEutP19ST+W1AcIWAH8Q9l+EXA40A88BBwPYHuNpDOApWW7022vKcvvAM4HtqTqRZSeRBERHaTxOoV12gwiItonabntGUPjGYEcEREpBhERkWIQERGkGEREBC0OOnsq2uXkH9SdAgC3ffyIulOIiMiZQUREpBhERAQpBhERQYpBRESQYhAREfRwb6IYlJ5VEZEzg4iISDGIiIgUg4iIIMUgIiJIMYiICFIMIiKCFIOIiCDFICIiSDGIiAhSDCIighSDiIighWIgaQtJV0m6RtINkj5a4rtKulJSv6RvStq8xJ9WnveX9bs0vNYpJX6zpEMb4rNKrF/SyRvhc0ZExAhaOTN4GDjI9j7AdGCWpJnAJ4DP2t4DWAucULY/AVhb4p8t2yFpGnAM8HxgFvAFSRMkTQDOAQ4DpgHHlm0jIqJDRi0GrvyxPN2sPAwcBHy7xOcDR5XlI8tzyvqDJanEF9h+2PatQD9wQHn0277F9iPAgrJtRER0SEttBuUX/ArgbmAJ8F/AvbbXlU1WApPL8mTgDoCy/j5g+8b4kH2GizfLY46kZZKWrV69upXUIyKiBS0VA9uP2p4OTKH6Jb/XxkxqhDzm2p5he0ZfX18dKUREPCW11ZvI9r3A5cCLgYmSBm6OMwVYVZZXATsBlPXPAO5pjA/ZZ7h4RER0SCu9ifokTSzLWwKvBm6iKgpHl81mAxeX5YXlOWX9j227xI8pvY12BaYCVwFLgamld9LmVI3MCzfAZ4uIiBa1ctvLHYH5pdfPJsCFtr8v6UZggaSPAb8Gzivbnwd8VVI/sIbqjzu2b5B0IXAjsA440fajAJJOAhYDE4B5tm/YYJ8wIiJGNWoxsH0tsG+T+C1U7QdD438G3jDMa50JnNkkvghY1EK+ERGxEWQEckREpBhERESKQUREkGIQERGkGEREBCkGERFBikFERJBiEBERpBhERAQpBhERQYpBRESQYhAREaQYREQEKQYREUGKQUREkGIQERGkGEREBCkGERFBikFERJBiEBERpBhERAQpBhERQQvFQNJOki6XdKOkGyS9q8RPk7RK0oryOLxhn1Mk9Uu6WdKhDfFZJdYv6eSG+K6Srizxb0rafEN/0IiIGF4rZwbrgPfZngbMBE6UNK2s+6zt6eWxCKCsOwZ4PjAL+IKkCZImAOcAhwHTgGMbXucT5bX2ANYCJ2ygzxcRES0YtRjYvtP21WX5AeAmYPIIuxwJLLD9sO1bgX7ggPLot32L7UeABcCRkgQcBHy77D8fOGqMnyciIsagrTYDSbsA+wJXltBJkq6VNE/SpBKbDNzRsNvKEhsuvj1wr+11Q+LN3n+OpGWSlq1evbqd1CMiYgQtFwNJTwe+A7zb9v3AucDuwHTgTuDTGyPBRrbn2p5he0ZfX9/GfruIiJ6xaSsbSdqMqhB83fZ3AWz/vmH9l4Dvl6ergJ0adp9SYgwTvweYKGnTcnbQuH1ERHRAK72JBJwH3GT7Mw3xHRs2ex1wfVleCBwj6WmSdgWmAlcBS4GppefQ5lSNzAttG7gcOLrsPxu4eP0+VkREtKOVM4OXAm8BrpO0osQ+SNUbaDpg4Dbg7QC2b5B0IXAjVU+kE20/CiDpJGAxMAGYZ/uG8nofABZI+hjwa6riExERHTJqMbD9C0BNVi0aYZ8zgTObxBc128/2LVS9jSIiogYZgRwRESkGERGRYhAREaQYREQEKQYREUGKQUREkGIQERGkGEREBCkGERFBikFERJBiEBERpBhERAQpBhERQYpBRESQYhAREaQYREQEKQYREUGKQUREkGIQERGkGEREBCkGERFBikFERNBCMZC0k6TLJd0o6QZJ7yrx7SQtkfTb8u+kEpeksyT1S7pW0n4NrzW7bP9bSbMb4i+SdF3Z5yxJ2hgfNiIimmvlzGAd8D7b04CZwImSpgEnA5fZngpcVp4DHAZMLY85wLlQFQ/gVOBA4ADg1IECUrZ5W8N+s9b/o0VERKtGLQa277R9dVl+ALgJmAwcCcwvm80HjirLRwIXuHIFMFHSjsChwBLba2yvBZYAs8q6bW1fYdvABQ2vFRERHdBWm4GkXYB9gSuBHWzfWVbdBexQlicDdzTstrLERoqvbBJv9v5zJC2TtGz16tXtpB4RESNouRhIejrwHeDdtu9vXFd+0XsD5/YktufanmF7Rl9f38Z+u4iIntFSMZC0GVUh+Lrt75bw78slHsq/d5f4KmCnht2nlNhI8SlN4hER0SGt9CYScB5wk+3PNKxaCAz0CJoNXNwQP670KpoJ3FcuJy0GDpE0qTQcHwIsLuvulzSzvNdxDa8VEREdsGkL27wUeAtwnaQVJfZB4OPAhZJOAG4H3ljWLQIOB/qBh4DjAWyvkXQGsLRsd7rtNWX5HcD5wJbAJeUREREdMmoxsP0LYLh+/wc32d7AicO81jxgXpP4MmDv0XKJiIiNIyOQIyIixSAiIlIMIiKCFIOIiCDFICIiSDGIiAhSDCIighSDiIggxSAiIkgxiIgIUgwiIoIUg4iIIMUgIiJIMYiICFIMIiKCFIOIiCDFICIiSDGIiAhSDCIighSDiIggxSAiIkgxiIgIWigGkuZJulvS9Q2x0yStkrSiPA5vWHeKpH5JN0s6tCE+q8T6JZ3cEN9V0pUl/k1Jm2/IDxgREaNr5czgfGBWk/hnbU8vj0UAkqYBxwDPL/t8QdIESROAc4DDgGnAsWVbgE+U19oDWAucsD4fKCIi2jdqMbD9M2BNi693JLDA9sO2bwX6gQPKo9/2LbYfARYAR0oScBDw7bL/fOCo9j5CRESsr/VpMzhJ0rXlMtKkEpsM3NGwzcoSGy6+PXCv7XVD4k1JmiNpmaRlq1evXo/UIyKi0ViLwbnA7sB04E7g0xsqoZHYnmt7hu0ZfX19nXjLiIiesOlYdrL9+4FlSV8Cvl+ergJ2ath0SokxTPweYKKkTcvZQeP2ERHRIWM6M5C0Y8PT1wEDPY0WAsdIepqkXYGpwFXAUmBq6Tm0OVUj80LbBi4Hji77zwYuHktOERExdqOeGUj6BvAK4JmSVgKnAq+QNB0wcBvwdgDbN0i6ELgRWAecaPvR8jonAYuBCcA82zeUt/gAsEDSx4BfA+dtqA8XERGtGbUY2D62SXjYP9i2zwTObBJfBCxqEr+FqrdRRETUJCOQIyIixSAiIlIMIiKCFIOIiCDFICIiSDGIiAhSDCIighSDiIggxSAiIkgxiIgIUgwiIoIUg4iIIMUgIiJIMYiICFIMIiKCFIOIiCDFICIiSDGIiAhSDCIighSDiIggxSAiIkgxiIgIYNPRNpA0D3gNcLftvUtsO+CbwC7AbcAbba+VJOBzwOHAQ8Df2b667DMb+FB52Y/Znl/iLwLOB7YEFgHvsu0N9Pki2rLLyT+oOwUAbvv4EXWnED2mlTOD84FZQ2InA5fZngpcVp4DHAZMLY85wLnwePE4FTgQOAA4VdKkss+5wNsa9hv6XhERsZGNWgxs/wxYMyR8JDC/LM8HjmqIX+DKFcBESTsChwJLbK+xvRZYAswq67a1fUU5G7ig4bUiIqJDxtpmsIPtO8vyXcAOZXkycEfDditLbKT4yibxpiTNkbRM0rLVq1ePMfWIiBhqvRuQyy/6jlzjtz3X9gzbM/r6+jrxlhERPWHUBuRh/F7SjrbvLJd67i7xVcBODdtNKbFVwCuGxH9S4lOabB8RNUtjem8Z65nBQmB2WZ4NXNwQP06VmcB95XLSYuAQSZNKw/EhwOKy7n5JM0tPpOMaXisiIjqkla6l36D6Vf9MSSupegV9HLhQ0gnA7cAby+aLqLqV9lN1LT0ewPYaSWcAS8t2p9seaJR+B4NdSy8pj4iIrtELZ0mjFgPbxw6z6uAm2xo4cZjXmQfMaxJfBuw9Wh4REbHxZARyRESkGERERIpBRESQYhAREaQYREQEKQYREUGKQUREkGIQERGkGEREBCkGERFBikFERJBiEBERpBhERAQpBhERQYpBRESQYhAREaQYREQEKQYREUGKQUREkGIQERGkGEREBCkGERHBehYDSbdJuk7SCknLSmw7SUsk/bb8O6nEJeksSf2SrpW0X8PrzC7b/1bS7PX7SBER0a4NcWbwStvTbc8oz08GLrM9FbisPAc4DJhaHnOAc6EqHsCpwIHAAcCpAwUkIiI6Y2NcJjoSmF+W5wNHNcQvcOUKYKKkHYFDgSW219heCywBZm2EvCIiYhjrWwwMXCppuaQ5JbaD7TvL8l3ADmV5MnBHw74rS2y4eEREdMim67n//7C9StKzgCWSftO40rYleT3f43Gl4MwBeM5znrOhXjYiouet15mB7VXl37uBi6iu+f++XP6h/Ht32XwVsFPD7lNKbLh4s/eba3uG7Rl9fX3rk3pERDQYczGQtLWkbQaWgUOA64GFwECPoNnAxWV5IXBc6VU0E7ivXE5aDBwiaVJpOD6kxCIiokPW5zLRDsBFkgZe599s/1DSUuBCSScAtwNvLNsvAg4H+oGHgOMBbK+RdAawtGx3uu0165FXRES0aczFwPYtwD5N4vcABzeJGzhxmNeaB8wbay4REbF+MgI5IiJSDCIiIsUgIiJIMYiICFIMIiKCFIOIiCDFICIiSDGIiAhSDCIighSDiIggxSAiIkgxiIgIUgwiIoIUg4iIIMUgIiJIMYiICFIMIiKCFIOIiCDFICIiSDGIiAhSDCIighSDiIigi4qBpFmSbpbUL+nkuvOJiOglXVEMJE0AzgEOA6YBx0qaVm9WERG9oyuKAXAA0G/7FtuPAAuAI2vOKSKiZ3RLMZgM3NHwfGWJRUREB8h23Tkg6Whglu2/L8/fAhxo+6Qh280B5pSnewI3dzTRJ3sm8Ieac+gW+S4G5bsYlO9iULd8Fzvb7hsa3LSOTJpYBezU8HxKiT2B7bnA3E4lNRpJy2zPqDuPbpDvYlC+i0H5LgZ1+3fRLZeJlgJTJe0qaXPgGGBhzTlFRPSMrjgzsL1O0knAYmACMM/2DTWnFRHRM7qiGADYXgQsqjuPNnXNJasukO9iUL6LQfkuBnX1d9EVDcgREVGvbmkziIiIGqUYREREikGMnaSdJb2qLG8paZu6c4qIsUkxaIOk50q6TNL15fkLJX2o7rzqIOltwLeBL5bQFODfa0uoRpK2kvRhSV8qz6dKek3deUW9xttxkQbkNkj6KfB+4Iu29y2x623vXW9mnSdpBdWcUlc2fBfX2X5BrYnVQNI3geXAcbb3lrQV8B+2p9ebWT0kPQ14PbALDT0WbZ9eV051GG/HRc4M2rOV7auGxNbVkkn9Hi6TCgIgaVOgV39Z7G77k8BfAGw/BKjelGp1MdVEk+uABxsevWZcHRddM85gnPiDpN0pf/TKnEp31ptSbX4q6YPAlpJeDbwD+F7NOdXlEUlbMnhc7A48XG9KtZpie1bdSXSBcXVc5DJRGyTtRjVw5CXAWuBW4G9t31ZnXnWQtAlwAnAI1a+dxcCX3YMHVCmGH6K6F8elwEuBv7P9kzrzqoukucDZtq+rO5c6jbfjIsVgDCRtDWxi+4G6c4nuIGl7YCZVYbzCdjfMTlkLSTcCe1D9WHqY6jux7RfWmlgNxtNxkWLQAknvHWm97c90Kpe6SbqOEdoGeul/eEn7jbTe9tWdyqWbSNq5Wdz27Z3OpQ7j9bhIm0Fr0n9+UNd2javBp0dYZ+CgTiXSZf4e+BlVz5lebDgel8dFzgwiYoOSdDzwMuDFwAPAz4Gf2b641sRiRCkGbZC0BVWj6fOBLQbitt9aW1I1kTQTOBt4HrA51dTjD9rettbEaiJpb6qGwsbj4oL6MqqfpGcDbwT+NzDJds+dYY+n4yLjDNrzVeDZwKHAT6lG3fZqI/LngWOB3wJbUl0aOKfWjGoi6VSqwng28Ergk8Bf15pUjSR9WdJ/AOdSXYo+GphUb1adN96OixSD9uxh+8NUv4DnA0cAB9acU21s9wMTbD9q+ytAr/YtPxo4GLjL9vHAPsAz6k2pVttTnSneC6wB/mC7FwdnjqvjIg3I7flL+ffecvp3F/CsGvOp00PlFqUrJH2SavBdr/64+JPtxyStk7QtcDdPvKd3T7H9OgBJz6M6i75c0gTbU+rNrOPG1XGRYtCeuZImAR+mukfz04GP1JtSbd5C9evvJOA9VAf562vNqD7LJE0EvkQ1F80fgV/VmlGNymRsLwNeDkwEfkzViNxrxtVxkQbkiA1I0i7AtravrTuXukj6PNUf/5/b/l3d+XSD8XBcpBi0IIPOnqz8+jsD2JnqDHNglGnP9CYar4OLOkHSDsD+5elVtu+uM5+6SHohT5699bu1JTSCFIMWSHoMWAFcwuDw+sfZ/mgNadVKUj/wN8B1vTgfETx+XFwPDEwx0Hhc2HZXDi7a2CS9AfhX4CdU38nLgPfb/nadeXWapHnAC4EbgMdK2N3aFT3FoAWS9qHqRjmL6trfN4DLevWPIICky4GDbT826sZPUZLeTdVj5D5gAXCR7T/WmlQXkHQN8OqBswFJfcCPbO9Tb2adJelG29PqzqNVKQZtkvQSqsLwKuADthfWnFItJO1PdZnopzRMy9ujl8x2A46hmsP/duD/2F5Ra1I1GnqTozLD7TW9duMjSecBn7Z9Y925tCK9idpQfuHsC7wAWEnVVaxXnUnVO2ILqhHIPcv2LZIuphp89xbguVSXFXvVDyUtpjqDBngTsKjGfOpyAfArSXcxDmZvzZlBCyS9lWpY/RZU9/29sFcbxAb06u0+Gw05I7iD6lLRD2z/qdbEuoCk11PN3w9Vr6KL6synDqVd7b3AdQy2GXTt7K0pBi1oaCgc+I/4hC/NdtcOMd9YykCzH9m+tO5c6lKOi2upbvN4P08+LnruklkMkvQr2y+uO49WpRi0QNL/HGm97Z92KpduIekBYGvgkfLoxa6lpzHyvR16rpcZgKS/AT5BNTpf9OCxASDpC1SD7r7HE9vV0rU0Ip76yuWR19q+qe5c6iTpK03C6VoaTy2SBLwZ2NX2GZJ2Ana0fVXNqUXNJP3S9ktH3zK6SYpBjImkc6kaxQ6y/bwyZ9OltvcfZdd4ipP0Oaqp3v+dcXB5ZGOR9Fyqabx3sL13GY3817Y/VnNqTfXqLJNjUkZWjhrrEQfaPhH4M4DttfR4F9N43LbAQ8AhwGvLoxdvl/ol4BTKbMdlXqJjas1oBBln0J5TgG+1EOsFf5E0gdKAWsZg9NRo5MxZNaz32V7TGJC0a13J1Ggr21dVV1Qf17X3dUgxaIGkw4DDgcmSzmpYtS1d/B93IzsLuAh4lqQzqaZl+FC9KXXcwG0c96SalG1gNPprgV5uO/mepMNs3w+P39fgW0CvjUv5g6TdGfzBdDTVfT+6UtoMWlDmJpoOnM4T71/wAHB5uUTScyTtRXUnJ1HN1dSTvUck/Qw4wvYD5fk2VIPPXl5vZvWQdATwT1R3AtyTaiTum3ttio4yKHEu8BJgLXAr1feQQWfjXblb0YO2Hy3PJwBPs/1QvZl1jqRLbR9Slk+x/S9151Q3STcDL7T9cHn+NOBa23vWm1l9JB1FVRC2AV5v+z/rzahzJM20fUXD862BTQZ+LHSrXCZqz6VUE9QNzEy5ZYm9pLaMOq+vYfkNQM8XA6pfvldJGphy4Shgfn3p1EPS2TxxEN4zgP8CTpKE7f9VT2Yd9wVgPxhfo5BTDNqzReMUxbb/KGmrOhOqQU4lh7B9pqRLqObtBzje9q/rzKkmy4Y8X15LFvVrbDHeorYs2pRi0J4HJe03cAcrSS8Cem1Sst0kLaQ64AeWH9eL8zQVWwH32/6KpD5Ju9q+te6kOsl2z50NDWOTMu5mk4blxwvE0J5W3SJtBm0oc/gvAH5H9R/32cCbbPfML6DM0/Rkkk4FZgB72n6upL8CvtWro3AlvRQ4jSffEnW3OvPqFEm3UXWzVpPVXfs9pBi0SdJmVD0kAG62/Zc684n6SVpBdZ+Lq23vW2LXduu89RubpN8A76G6TPToQNz2PbUlFaPKZaL27QlMo7oWuF9pGLug5pyiXo/YtqSB/uRb151Qze6zfUndSUR7UgzaUC4HvIKqGCwCDgN+QdWbJHrXhZK+CEyU9DbgrVRTEfSqyyV9CvguT5yb6Or6UorR5DJRGyRdB+wD/Nr2PpJ2AL5m+9U1p9Zxkt5g+1ujxZ7qyuytU4C9qObiEbDY9pJaE6uRpMvL4sAfl4E2g4NqSilakGLQBklX2T5A0nLglVQjkG+yvVfNqXWcpKtt7zdarBcMvQF8r2qYq2mg4dTAauAXvdSzStJ2I63v1t5EuUzUnmWSJlJdAlhONfjsV7Vm1GGZp6mpqyXtb3tp3YnUbJsmsZ2Bf5Z0mu0FnU6oJsupCqGA51BNRSGqu579N9CVk/blzGCMJO0CbFumpe0ZmafpyUrvmanAbcCDDF4W6cneREOVX8o/6rWzRklfAi6yvag8Pww4yvbb682suRSDNki6zPbBo8V6QeZpGiRp52bxbp2QrA6Sfj3Q7bZXNLt82M2XFHNzmxZI2qL8unmmpEmStiuPXYDJNadXl0up5mYasCXwo5pyqVX5o78T1V3fbqe6sUv+3yokvZLqUkmv+Z2kD0napTz+mWrAaldKm0Fr3g68G/grquuBAw1k9wOfrymnumWepqJxBDLwFWAz4GtAT41ALr3thl5q2I7qD+Bxnc+odscCp1Ld98PAz0qsK+UyURskvdP22XXn0Q0k/RJ455B5mj4/XmZo3JAyArnS5HKZgXtsP1hHPt1C0tbj4TvImUEbbJ8t6SXALjR8dz06AvndwLckPWGeplozqk9GIJM2kqHK34ovA08HnlM6X7zd9jvqzay5FIM2SPoqsDuwgsE5V0wPjkC2vbTc6SzzNDUfgfzlmnOK+n0WOJRyO1Tb10jq2rvfpRi0ZwYwzbm2NiDzNAG2/1XSq6nakPYEPtLLI5BjkO07qkHqj3t0uG3rlmLQnuupLod07U2tOyXzNA2S9AnbHwCWNIlF77qjXCpyme34XUDX3ic8DchtKHOuTAeu4okTcPXcDV0yT9OgYabm6LkG5HgiSc8EPkd1q1xRdcd+V7dO5Z0zg/acVncCXeRPth+TtK4MQLubqq99z5D0j8A7qO741jgSfRvgl/VkFV3Ett9cdxKtSjFoQy/exWsEPT9PE/BvwCXAvwAnN8Qf6NbJyKKjrijdjucBP+z2tsZcJmqBpAdofiP4gTlotu1wSl2lV+dpGiDpOc3itv+707lE9yjTm7+KqnfZ/sCFwPm2/7PWxIaRYhBjknmaBjWMvBVVz6pdqbraPr/WxKJrlCk5vgZsDVwDnGy7q86kc5ko2iJpC2AryjxNDE7NsS09Ok9Tk8nI9qNqS4geJml74G+BtwC/B95JNeZgOvAtumwq6xSDaFfmaRqF7aslHVh3HlG7XwFfpZq2emVDfJmk/1dTTsPKZaIYk8zTNKjhDl9QzVa6H7C97UNrSim6gCR1e6NxoxSDGLPM01QpA/AGrKO6yc13bP+5noyiG0jqA/4JeD5VWxIA3Xov6FwmijHJPE2DbH8UQNJWvXhznxjW14FvAq8B/gGYTXVP6K6UM4MYE0k3kXmaAJD0YuA84Om2u352yugMScttv6hxNLqkpbb3rzu3ZnI3phirgXmaAv4v1eyU90A1OyXQtbNTRscMzOJ7p6QjJO1LdbOfrpTLRDFWzwRulNTz8zTB+JqdMjrmY5KeAbwPOJuq+/V76k1peCkGMVan1Z1AFxlXs1NGZ9j+flm8D3hlnbm0Im0GEetpvM1OGZ0haTeq4+LFwGNU4w7eY/uWWhMbRopBtCXzNEW0RtIVwDnAN0roGKr7hnflgMQUg4gxkvSREVbb9hkdSya6TrN7Wki6xvY+deU0khSDiDGS9L4m4a2BE6hGID+9wylFF5H0CWAtsIDqbPpNwCTgUwDdNs15ikHEBiBpG6qG4xOopir+tO27680q6iTp1hFW2/ZuHUumBelNFLEeJG0HvBd4MzAf2M/22nqzim5gu6tmJR1NBp1FjJGkTwFLgQeAF9g+LYUgJO0v6dkNz4+TdLGks8qPh66Uy0QRYyTpMaoBd+t4Yg+r9KzqYZKuBl5le42kl1O1GbyT6j4Gz7N9dJ35DSeXiSLGyHbOrKOZCQ2Nw28C5tr+DvCdck/krpSDOSJiw5ogaeCH9sHAjxvWde0P8K5NLCJinPoG8FNJfwD+BPwcQNIeVFNTdKW0GUREbGCSZgI7ApfafrDEnks1zfnVtSY3jBSDiIhIm0FERKQYREQEKQYREUGKQUREAP8f8LZ1XRO8qckAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "%matplotlib inline\n", "\n", "for c in categorical_features_all:\n", " if len(df[c].value_counts()) < 50:\n", " print(c)\n", " df[c].value_counts().plot.bar()\n", " plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__Histograms:__ Histograms show distribution of numeric data. Data is divided into \"buckets\" or \"bins\"." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Age upon Intake Days\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Age upon Outcome Days\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "%matplotlib inline\n", "\n", "for c in numerical_features_all:\n", " print(c)\n", " df[c].plot.hist(bins=5)\n", " plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If for some histograms the values are heavily placed in the first bin, it is good to check for outliers, either checking the min-max values of those particular features and/or explore value ranges." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Age upon Intake Days\n", "min: 0 max: 9125\n", "Age upon Outcome Days\n", "min: 0 max: 9125\n" ] } ], "source": [ "for c in numerical_features_all:\n", " print(c)\n", " print('min:', df[c].min(), 'max:', df[c].max())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "With __value_counts()__ function, we can increase the number of histogram bins to 10 for more bins for a more refined view of the numerical features." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Age upon Intake Days\n", "(-9.126, 912.5] 74835\n", "(912.5, 1825.0] 10647\n", "(1825.0, 2737.5] 3471\n", "(2737.5, 3650.0] 3998\n", "(3650.0, 4562.5] 1234\n", "(4562.5, 5475.0] 1031\n", "(5475.0, 6387.5] 183\n", "(6387.5, 7300.0] 79\n", "(7300.0, 8212.5] 5\n", "(8212.5, 9125.0] 2\n", "Name: Age upon Intake Days, dtype: int64\n", "Age upon Outcome Days\n", "(-9.126, 912.5] 74642\n", "(912.5, 1825.0] 10699\n", "(1825.0, 2737.5] 3465\n", "(2737.5, 3650.0] 4080\n", "(3650.0, 4562.5] 1263\n", "(4562.5, 5475.0] 1061\n", "(5475.0, 6387.5] 187\n", "(6387.5, 7300.0] 81\n", "(7300.0, 8212.5] 5\n", "(8212.5, 9125.0] 2\n", "Name: Age upon Outcome Days, dtype: int64\n" ] } ], "source": [ "for c in numerical_features_all: \n", " print(c)\n", " print(df[c].value_counts(bins=10, sort=False))\n", " plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If any outliers are identified as very likely wrong values, dropping them could improve the numerical values histograms, and later overall model performance. While a good rule of thumb is that anything not in the range of (Q1 - 1.5 IQR) and (Q3 + 1.5 IQR) is an outlier, other rules for removing 'outliers' should be considered as well. For example, removing any values in the upper 1%. " ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Age upon Intake Days\n", "Age upon Outcome Days\n" ] } ], "source": [ "for c in numerical_features_all:\n", " print(c)\n", " \n", " # Drop values below Q1 - 1.5 IQR and beyond Q3 + 1.5 IQR\n", " #Q1 = df[c].quantile(0.25)\n", " #Q3 = df[c].quantile(0.75)\n", " #IQR = Q3 - Q1\n", " #print (Q1 - 1.5*IQR, Q3 + 1.5*IQR)\n", " \n", " #dropIndexes = df[df[c] > Q3 + 1.5*IQR].index\n", " #df.drop(dropIndexes , inplace=True)\n", " #dropIndexes = df[df[c] < Q1 - 1.5*IQR].index\n", " #df.drop(dropIndexes , inplace=True)\n", " \n", " # Drop values beyond 90% of max()\n", " dropIndexes = df[df[c] > df[c].max()*9/10].index\n", " df.drop(dropIndexes , inplace=True)\n" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Age upon Intake Days\n", "(-6.936, 693.5] 61425\n", "(693.5, 1387.0] 18400\n", "(1387.0, 2080.5] 5657\n", "(2080.5, 2774.0] 3471\n", "(2774.0, 3467.5] 2557\n", "(3467.5, 4161.0] 1962\n", "(4161.0, 4854.5] 1148\n", "(4854.5, 5548.0] 596\n", "(5548.0, 6241.5] 183\n", "(6241.5, 6935.0] 63\n", "Name: Age upon Intake Days, dtype: int64\n", "Age upon Outcome Days\n", "(-6.936, 693.5] 61208\n", "(693.5, 1387.0] 18490\n", "(1387.0, 2080.5] 5643\n", "(2080.5, 2774.0] 3465\n", "(2774.0, 3467.5] 2600\n", "(3467.5, 4161.0] 2004\n", "(4161.0, 4854.5] 1196\n", "(4854.5, 5548.0] 604\n", "(5548.0, 6241.5] 187\n", "(6241.5, 6935.0] 65\n", "Name: Age upon Outcome Days, dtype: int64\n" ] } ], "source": [ "for c in numerical_features_all:\n", " print(c)\n", " print(df[c].value_counts(bins=10, sort=False))\n", " plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's see the histograms again, with more bins for vizibility." ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Age upon Intake Days\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Age upon Outcome Days\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "for c in numerical_features_all:\n", " print(c)\n", " df[c].plot.hist(bins=100)\n", " plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 4. Scatter Plots and Correlation\n", "(Go to top)\n", "\n", "### Scatter plot\n", "Scatter plots are simple 2D plots of two numerical variables that can be used to examine the relationship between two variables. " ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", "\n", "fig, axes = plt.subplots(len(numerical_features_all), len(numerical_features_all), figsize=(16, 16), sharex=False, sharey=False)\n", "for i in range(0,len(numerical_features_all)):\n", " for j in range(0,len(numerical_features_all)):\n", " axes[i,j].scatter(x = df[numerical_features_all[i]], y = df[numerical_features_all[j]])\n", "fig.tight_layout()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Scatterplot with Identification\n", "\n", "We can also add the target values, 0 or 1, to our scatter plot." ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEGCAYAAACUzrmNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAA4+ElEQVR4nO2de5wU1ZX4v2cYEGVYnmZCGBQE1kSNCoOoP90saERlDRokCr5QiWSNJgprIkYNoKiQsL5C1KASUSKg4oOwGMMS0ODG12BAhCCDoPIQiOJjVERmzu+Pe4vpafpRPd010z1zvp9PfaruuXWqTkNPnT517zlXVBXDMAzDSEVRYxtgGIZh5D/mLAzDMIy0mLMwDMMw0mLOwjAMw0iLOQvDMAwjLcWNbUAUdO7cWbt3715v/c8++4w2bdrkzqAIKSRbweyNGrM3Wpq6vRUVFf9U1QMTdqpqk9vKy8s1G5YsWZKVfkNSSLaqmr1RY/ZGS1O3F3hNkzxX7TWUYRiGkRZzFoZhGEZazFkYhmEYaYlsgFtEDgXmxogOAX4JPOzl3YGNwDmqulNEBLgLGAx8Dlysqsv9tUYCN/jrTFLVmZna89VXX7Fp0yZ27dqV9tx27dqxZs2aTG+RE1q3bk1ZWRktW7ZslPsbhmEkIjJnoaprgaMBRKQFsBl4ChgHLFbVySIyzrevBU4HevvtWOBe4FgR6QiMB/oBClSIyHxV3ZmJPZs2baJt27Z0794d55eS8+mnn9K2bdtMLp8TVJUPPviATZs20aNHjwa/v2EYBcgBB8AXX5Cwyt/UqTB4MHz+eda3aajXUCcD61X1HeBMIIgMZgJn+eMzgYf9oPxLQHsR6QKcCixS1Q+9g1gEnJapAbt27aJTp05pHUVjIiJ06tQpVPRjGIYB7HUUkmAL+nOBaANUnRWRGcByVZ0mIh+pansvF2CnqrYXkQXAZFVd5vsW4yKOAUBrVZ3k5TcCX6jq1Lh7jAZGA5SWlpbPmTOnjg3t2rWjV69eoeytrq6mRYsW9f24WVNZWcnHH38c6tyqqipKSkoitih3mL3RYvZGSz7a+8+tX9F5y8qEfVVlZezWjnT8erjX2gMHDqxQ1X6J+iJPyhORVsAQ4Lr4PlVVEcmJt1LV6cB0gH79+umAAQPq9K9Zsyb0q6XGeg0V0Lp1a/r06RPq3KVLlxL/WfMZszdazN5oyUd7W7SA3TWDKCImmsC9s39+6lRO/vm5VFdnf5+GeA11Oi6q2Obb2/zrJfx+u5dvBrrF6JV5WTJ5QfKnP/2JQw89lF69ejF58uTGNscwjAKnpgY68l7Cvr9zJDU1ublPQziLEcDsmPZ8YKQ/Hgk8EyO/SBzHAR+r6lbgOWCQiHQQkQ7AIC+LlE8/hQcegGuvdftPP83+mtXV1VxxxRU8++yzrF69mtmzZ7N69ersL2wYRrOlqAg+oYwa2DvIrUANUE1LinL0lI/UWYhIG+AU4MkY8WTgFBFZB3zXtwEWAm8DlcD9wI8BVPVD4GbgVb/d5GWR8be/taBrV7j6avjVr9y+a1dYtiy7677yyiv06tWLQw45hFatWjF8+HCeeeaZ9IqGYRhJmD7d7eOji6D90EO5uU+kYxaq+hnQKU72AW52VPy5ClyR5DozgBlR2BjPp5/C2WfvT1VVreyzz9x+8GDYsgXqO761efNmunWrfaNWVlbGyy+/nIW1hmE0d0aNguuugx07XHTRAhdVfEIZxcWVXHhhbu5jGdxxzJ1L0nd8NTWu3zAMI5/Yvh0efhg68x41uP3DD8NRR+XuHuYs4li3Dj7/PHEuxmefQWVl/a/dtWtX3nuvNlTctGkTXbt2rf8FDcMwPBdeCDu1jCJVdmpZziKKAHMWcfTuDQcckHg2b5s2EDJVIyHHHHMM69atY8OGDezevZs5c+YwZMiQ+l/QMAyjgWiSix9lw7nnwpgxifuKilx/fSkuLmbatGmceuqpVFdXc+mll3L44YfX/4KGYWRPRQU8+mjy/vPOg/Ly6PR9VYlEP1H3vuNogOTpdJiziKNtW5g37wuGDTuAmhr36qlNG+coFi6s/+B2wODBgxk8eHBujDUMI3veeQfuvDPxYGWLFnDCCakf9tnqw95yHWHljYG9hkrA8cdXs2UL3HUXjBvn9lu2wIknNrZlhmHknLPOgoMOStx30EGuP0L9iZemnhF5y+j8mDFpziIJJSVuStptt7l9npWDMQwjVxQVwa9/ve8feUmJk6fLastSf8KM/nUS6gKCxLobpvcP8SGix5yFYRjG0KHQuXNd2YEHwve/3yD6B5M4ekgmbwzMWRiGYcRHB2Gjihzpb6Z/wnIdm8mPqALMWRiGYThio4NMooos9W+80e3jo4igPWlSZmZEhTkLwzAMqI0OILOoIkv9m26CVq1qowuojSpatYLrr8/MjKgwZ9GAXHrppXzta1/jiCOOaGxTDMNIxNChMGNG5lFFlvpffukiiIN5mRrcftIkJ88XLM8inooKWj30kHP1iUiXYJOCiy++mCuvvJKLLrqo/vYZhhEdRUVwySWNon/99XD99f0BZVP9LYgMcxbxvPMOre65J6sEm2R85zvfYePGjdnZZxhGbrn5Zpg2LXn/lVfWDiwkokAysLPFnEU8Z52FlpUh7767b1+YBB3DMAqLigpXtjVVfxoKIQM7W2zMIp6iIr6cNKn+CTqGYRQWjz2WVf8NPf6Qsn/it1L3Fwr25EvAniFDskvQMQyjcGjVCs44I3HfkCHJxy89t2w4L2UG9oQ15+XAyMbHnEUisk3QMQyjsJg3L7H88cdDqfchcfSQTF6I2NMvGdkm6CRgxIgRHH/88axdu5aysjIefPDBrK9pGEYOSBRdhIgqAt7gvIQZ2G/QNKIKMGeRnGwTdBIwe/Zstm7dyldffcWmTZsYNWpU1tc0DCNHxEcXIaOKYP2y+CgiaJ9zTtaW5QWROgsRaS8iT4jIP0RkjYgcLyIdRWSRiKzz+w7+XBGRu0WkUkRWikjfmOuM9OevE5GRUdpch2wTdAzDKBxio4sMoopnnnH7ILqAulHF3Lm5NbOxiDqyuAv4k6p+EzgKWAOMAxaram9gsW8DnA709tto4F4AEekIjAeOBfoD4wMHEzlBgo2NVRhG82DePLdwTcioIkDVRRB9+AM1uP055zSJ9Iq9RJZnISLtgO8AFwOo6m5gt4icCQzwp80ElgLXAmcCD6uqAi/5qKSLP3eRqn7or7sIOA2YnalNqopIfs961qb07TKMQqNVK/jrX+ulOncuMPc84DxW5tSo/ECiejiJyNHAdGA1LqqoAK4CNqtqe3+OADtVtb2ILAAmq+oy37cY50QGAK1VdZKX3wh8oapT4+43GheRUFpaWj5nzpw69pSUlFBaWkq7du3SOozq6mpatGhR/w9fT1SVjz/+mG3btlFVVRVKp6qqipICWpnJ7I2WZmnv22/Dzp3J+zt0gEMOSd4fIukuqNrQ1P99Bw4cWKGq/RL1RZnBXQz0BX6iqi+LyF3UvnICQFVVRHLirVR1Os450a9fPx0wYECd/mBQefPmzWmvtWvXLlq3bp0LszKmdevWHHXUUbRs2TLU+UuXLiX+s+YzZm+0NEt7f/hDdP365BnUPXtCZWVy/YED02dg+x/VzfLf1xOls9gEbFLVoEj7EzhnsU1EuqjqVv+aKciz3wx0i9Ev87LN1L62CuRLMzWmZcuW9OjRI9S5S5cupU+fPpnewjCMRuDTF1dS8vU2Sfur/m8lqX5bX8dV3MpdSfvHcxUTs7CvqRDZyK2qvg+8JyKHetHJuFdS84FgRtNIwM8lYD5wkZ8VdRzwsapuBZ4DBolIBz+wPcjLDMMwmPvHA3ibHgkzqNfTk7l/PCCl/mTuTJmBfRN35srUgibqaT4/Af4gIiuBo4FbgcnAKSKyDviubwMsBN4GKoH7gR8D+IHtm4FX/XZTMNhtGIaxbh18i1UJ+w5jZco3UAHDuCojeXMk0qqzqvp3INFgyckJzlXgiiTXmQHMyKlxhmE0CXr3hlZtDmD9Zz3oyQYEFxVU0pNWbQ6gV6/013iaO6nhLopgr36NlxsOSyAwDKOgOfdclwp1WFx0cTgrKSpy/an45jfdPj6KCNpHHpkzUwsacxaGYRQ0bdvCwoXQuq0buwA3VtG67QEsXLjvagPxrFnj9k/7sQuoG1WsWBGJ2QWHOQvDMAqeE0+ELVtg6d2r+GT/r/H83SvZssXJw6DqIohhXEUNbn/kkU0rAztbbKU8wzCaBCUlMOonB8BPtlGfEp0ugrgTuJOncmpZ08AiC8MwDCMtFlkYhpEdFRXw6KPJ+887b2+5jITcfDNMm8bur+Djj6Gmxg1Yt2sHrVoCV14JN96YXN+X70n0xmhvVra9T8qatM5CRHriMrG/FJEBwJG4gn8fRWuaYRgFwTvvwJ13uqd8PC1awAknpHYWFRXo9u20Ag4MZDXATl9uI0TtprTlOoysCfMaah5QLSK9cLWXugEpfkYYhtGsOOssOOigxH0HHeT6U7B83GMp+1fekLp/Yp0qQZn3G+EI4yxqVHUP8H3gN6r6M6BLtGYZhlEwxK9ZHxBy7fofnN+KP3JGwnIb8xnC0OGpFyGawLspy3VM4N30n8FISxhn8ZWIjMDVcVrgZeFKohqG0TyIXbM+IOTa9e+/D0OZl7DvbB7n/ffT335SkughmdzInDDO4hLgeOAWVd0gIj2AR6I1yzCMgiI+uggZVQB8/etQTd3oIogqqmnF17+e/vbx0YVFFbknjLPoCVytqrMBVHWDqk6J1izDMAqO2OgiZFQBtSuYxkcXZ+M6nnwy3O3jowiLKnJLGGdxLrBORH4lIt+M2iDDMAqUILqA0FEFQN++bv3qILqA2qjinHPS12YKZsUG0QXUjSps1mxuSPu/qaoXAH2A9cBDIvI3ERktIm0jt84wjMJi6FCYMSN0VBEwd67LoP5Z93m8KCfy8+6Ps2KFX9c6BIFDmEQ3aqiNKsxR5I5QSXmq+omIPAHsD1yNmxn1MxG5W1V/E6F9hmEUEkVFcMkl9VI98khYu6EV8FfW1kPfOQYXTYz3m5E70kYWIjJERJ7CLWXaEuivqqcDRwH/Fa15hmHkPd/4BoigCTZEXH8q/HlJ9cXS6vKBMJHF2cAdqvpCrFBVPxeR+tTrMgyjKbFjR+oM6h070l7CMrDznzBjFiPjHUVM3+Lcm2QYRiHx1vNbU/avX5a6f2Ka66frNxqGMK+hjhORV0WkSkR2i0i1iHzSEMYZhpH/XHxNZ3ZTnDCDejfFXDS2cyK1vUxA02Rg2yh1PhBmbts0YASwDjfA/UPgt2EuLiIbReQNEfm7iLzmZR1FZJGIrPP7Dl4uInK3iFSKyEoR6RtznZH+/HUiMjLTD2kYRnRs2AAdSRw9dGQrGzemv8akDOVGwxNqIrSqVgItVLVaVX8PnJbBPQaq6tGq2s+3xwGLVbU3sNi3AU4HevttNHAvOOeCm9hwLNAfGB84GMMwGp8ePeBz6kYXQVTxOZ3p3j39NeKjC4sq8o8wzuJzEWkF/N0n5o0JqZeMM4GZ/ngmcFaM/GF1vAS0F5EuwKnAIlX9UFV3AovIzFkZhhEhDz3k9vHRRdB++OFw14mPIiyqyC9E02StiMjBwDagFTAGaAfc46ONdLobgJ24Hwq/U9XpIvKRqrb3/QLsVNX2IrIAmKyqy3zfYuBaYADQWlUnefmNwBeqOjXuXqNxEQmlpaXlc+bMCfcvkICqqipK0q3ynicUkq1g9kZNY9m7aRNs2wZ9WY6gKMJy+lJaCmVlyfUCe4MlK8qpXbuiArcGRqqlMBqapv59GDhwYEXMW6C6qGraDbcmyYFhzo3T6+r3XwNWAN8BPoo7Z6ffLwBOjJEvBvoB1wA3xMhvBK5Jdd/y8nLNhiVLlmSl35AUkq2qZm/UNKa9lZWq3z16h+5B9LtH79DKyvQ6sfaC6gTQatAJoBCdrfWlqX8fgNc0yXM16eskP+A8QUT+CawF3hKRHSLyy7BeSlU3+/124CncmMM2/3oJv9/uT98MdSp/lXlZMrlhGHlEz56w6PXOtNAaFr3emZ49M9NXhfGqFKkyXtVKdeQZqcYexgAnAMeoakdV7YAbZD7Bj1ukRETaBPWjRKQNMAhYBczHrY2B3z/jj+cDF3kndRzwsapuBZ4DBolIBz+wPcjLDMMwjAYilbO4EBihqhsCgaq+DVwAXBTi2qXAMhFZAbwC/I+q/gmYDJwiIuuA7/o2wELgbaASuB/4sb/nh8DNwKt+u8nLDMMAuPlmKC1124oVtcfBdvPNqfWzLbdh5TqaBanKfbRU1X/GC1V1h4ikXSnPO5ajEsg/AE5OIFfgiiTXmgHMSHdPw2iWVFTAdv82d8+e2uPY/jRkW27DynU0fVJFFrvr2WcYRkPy2GNZ9f927IqU/ff/LHW/letoHqRyFkeJyCcJtk+BbzeUgYZhpKFVKzjjjMR9Q4a4/hT85I4jU5bb+NHU1KsPWbmO5kFSZ6GqLVT1XxJsbVU17WsowzAakHnzEsuDNUtToApdSRw9dGVFqFlJVq6j6ZNNJrZhGPlCougiRFQBbvx5G0cmLLexjSNDjU9buY6mjzkLw2gqxEcXIaIKgN/4tS7jo4ug/bvfhbu9leto2pizMIymQqtW0K6dOw4ZVQBccQW0b18bXUBtVNG+PVx2WWr94DVVEF0E+kFUYcl1TYNQzkJEDhaR7/rj/YNkO8Mw8oyePeHEE0NHFQE7d8L06VDGCmpw++nTnTwMgUOYhHMUk+LkRuGTdllVEbkMV6CvI9ATV27jPhLkShiG0ciIwF//Wi/Vyy6Dyy47EtAkq1OkxjkG5x3G+81oOoSJLK7Alf34BEBV1+EKAxqGkQsuvxwOOCD5dvnlqfVjMqipqLAMbCMS0kYWwJequlv8F0ZEitl3SrVhGPWlogK++CJ1fxpiM6UliTysfhi50fwIE1k8LyK/APYXkVOAx4E/RmuWYTQjXnghq/4f/euSlP0//XbqfsvANsIQxlmMA3YAbwA/whX8uyFKowyjWdG6NfTtm7ivXz/Xn4Lpbw1ImUH9mzcGpNS3DGwjDGmdharWqOr9qvoDVR3mj+3bYxi55MUXE8tDDlb3InH0kEwej2VgG+lI6yxE5AwReV1EPgxqQ4nIJw1hnGE0GxJFFyGiioCNDNib4wC1UcFGBoTStwxsIx1hXkPdiVukqFNMbah/idYsw2iGxEcXIaOKQYPcPj6KCNrf+16421sGtpGKMM7iPWCVvXoyjIiJjS4yiCqe8+tGxkYRsVHF/Pmp9S0D2whDGGfxc2ChiFwnImODLWrDDKNZ8uKL0Lt3xol1qi6CeINDqcFFFd/7XvgHvWVgG+kIk2dxC1AFtAbCFZsxDKN+tG4Nb71VL9X582Hp0hKKVNmQ/vR9sAxsIxVhnMU3VPWIyC0xjEKlogIefTR5/3nnQXl58n6f8JroR/zehLhUP/Fj9adORQcOzEzfMEIQxlksFJFBqvrnyK0xjELknXfgzjuhpmbfvhYt4IQTUjsLcrsGdn0yuA0jHWHGLC4H/iQiu/y02YymzopICz/1doFv9xCRl0WkUkTmikgrL9/Ptyt9f/eYa1zn5WtF5NQMP6NhRMtZZ8FBByXuO+gg15+Cif82O3X/KWn6U/ZaBraRG8Ik5bVV1SJVbe2PM506exWwJqY9BbhDVXsBO4FRXj4K2Onld/jzEJHDgOHA4cBpwD0i0iKD+xtGtBQVwa9/DSUldeUlJU5elPrPbMJfh6fOoF40PLW+ZWAbDUDY9SyGiMhUvyVZGT6hXhnwH8ADvi3AScAT/pSZwFn++Ezfxvef7M8/E5ijql+q6gagEugf1gbDaBCGDoXOnevKDjwQvv/9UOpHkzh6SCaPxzKwjaiRdOkTIjIZOAb4gxeNAF5T1evSXlzkCeA2oC1wDXAx8JKPHhCRbsCzqnqEiKwCTlPVTb5vPXAsMMHrzPLyB73OE3H3Go1bd4PS0tLyOXPmpP3wyaiqqqIk/ldinlJItkITt3fnTti40Y1dFBVBjx5uCbo0BEVly9m3umwFbqwj1ZBHrH5VWRklmzZlpN+YNOnvQx6Qqb0DBw6sUNV+CTtVNeUGrASKYtotgJUh9M4A7vHHA4AFQGegMuacbriEP4BVQFlM33p//jTgghj5g8CwVPcuLy/XbFiyZElW+g1JIdmq2sTtra5W7d5dFVR79HDtEFx+uVM5gtla4+YtaQ3oEcxWUB0zJrW+V9EJoEumTt2rPwH29uUrTfr7kAdkai8uEEj4XA27Bnf7mON2IXVOAIaIyEZgDu71011Ae78mBrhV9zb7483eeQRrZrQDPoiVJ9AxjPwhGLuAUGMVAffc405dxfA6GdSrGE5REdx+e2r92AzsAMvANnJNmG/zbcDrIvKQiMwEKnCJeilR1etUtUxVu+MGqP+iqucDS4Bh/rSRwDP+eL5v4/v/4j3dfGC4ny3VA+gNvBLq0xlGQzN0KMyYEXqsIqC6GsaMcWMUNbj9mDFOHobAIWzFMrCNaEibZ6Gqs0VkKW7cAuBaVX0/i3teC8wRkUnA67jXSvj9IyJSCXyIczCo6psi8hiwGtgDXKGqIf+EDKOBKSqCSy6pl+rttwO3DweG80Y99FVh6dJyilQtA9vIOWmdhYh8H/crf75vtxeRs1T16bA3UdWlwFJ//DYJZjOp6i7gB0n0byFENGMYhmFEQ5gM7vGq+lTQUNWPRGQ88HRkVhnNi2zLZWSrP2sW3HEHe2pg54fw5Zew337QoSMw+oewaRNccEFy/VyW66iPvmE0AGGcRaJxjTB6hhGObMtlZKu/ciW6fDnFwIGx8neBzz+HDenL8uWyXEd99A0jasIMcL8mIreLSE+/3Q4JJoQbRn3JslxGtvqfXncre5L8/lGEql/cmlL/Im5O2T8qTb+V6zAKgTDO4ifAbmAubgrsLuDHURplNDOyLJeRrf7cecXcU/zThOUydsjXmDsvdSD9CDekLLcxgxtS6lu5DqMQCOMsBqvqOFXtp6rHqOovcCU8DCN3ZFkuIxv9detg7J4p+0QXeyjmPS2jsjL97U9KEj0kk8dj5TqMfCeMs0hU1iNtqQ/DyIj46CBsVJED/d69Yf82xdxFbXShwJ1cTVER9OqV/vYvxEUXQVTwQpqoIiA+urCowsg3kv4licjpIvIboKuI3B2zPYTLdzCM3BIbHWQSVWSpf+65zqdcS210sYdixnHb3v5UHHyw28dHEUE7jLOBfaMIiyqMfCLVz64twGu4MYqKmG0+YGtKGLmnnuUystVv2xYWLoQ2bd3YBcBvi6+mTdtievfedygkno0b3T6ILqBuVLFuXWr92HIdsfpWrsPIJ5L+NanqClWdCfRU1Zkx25OqurMBbTSaE/Usl5Gt/oknwpYtUDJtCq9++xLaTrvNtUMW7FR1EcRJ3EwNbt+rV/gHfXDeJKxch5GfhMmXWCci+3xlVfWQCOwxmjtZlMvIVr+kBEb9qBh+NGNvbZtMcBHEDcANPF8PfecY3J+alesw8o0wziK2tnlrXEmOjtGYYxj1wGdgJ2XMmHpnYDN1KgwcaBnYRrMnTCHBD+JEd4pIBfDLaEwyjAxZuRKWL0/dn4ZsM6UtA9to6qQdARSRvjFbPxH5T6zch5FP3HorFCf5ShYXu/4UPDjsv1P2P3Ju6n7LwDaaA2Gmi/x3zHYbUA6cE6VRhpERxcXw058m7rv66uSOxDP6ybFJM6gBLn58bEp9y8A2mgNpnYWqDozZTlHVy1R1bUMYZxihmTJlX6dQXAy33ZZWtaYG/o3E0cM/KEtYnzAey8A2mjopnYWIHCEiM0XkNb/NFJFvN5RxhhGaRNFFiKgC3ASqvzE2YQb1Z5SGStewDGyjqZMqg/tM4CngeeBSvz0PPOn7DCO/iI0uQkYVANOnu318dBG0H3oo3O0tA9toyqT6zXQTcIqqzlDVlX6bAZzi+wwjv4iNLkJGFQCjRrnqIEF0AS4q+BtjKS6GCy9MrW8Z2EZzIJWzKFbVjfFCL2sZlUGGkRVTprikvJBRRcD27fDww/Dv/Dc1uP3DD8NRR4XTtwxso6mTylnsEZF9VpQRkYMJUUhQRFqLyCsiskJE3hSRiV7eQ0ReFpFKEZkrIq28fD/frvT93WOudZ2XrxURq0tlJKe42JX7CBlVxHLhhbBMx1KkyjIdmzaiiEcVxqtSpMp4VXMURpMilbMYD/yviFwsIt/22yXAnwmXkPclcJKqHgUcDZwmIscBU4A7VLUXsBMY5c8fBez08jv8eYjIYcBw4HDgNOAeEWmR4ec0DMMwsiDpzy9VfVpENgD/hVstD+BN4BxVXZHuwqqqQJVvtvSbAicB53n5TGACcC9wpj8GeAKYJiLi5XNU9Utgg4hUAv2Bv4X7iEbkVFTAo48m7z/vvNRrYGern225jWzLfRhGM0A0wj8CHwFUAL2A3wK/Bl7y0QMi0g14VlWPEJFVwGmqusn3rQeOxTmQl1R1lpc/6HWeiLvXaGA0QGlpafmcOXPqbXdVVRUlYcuNNjJ5YetHH8H69cn7e/aE9u2BJPZmoJ+QihBLwqdzVkmoKiujZNOm1Pp5RF58HzLA7I2WTO0dOHBghar2S9ipqpFvQHtgCXAiUBkj7was8sergLKYvvVAZ2AacEGM/EFgWKr7lZeXazYsWbIkK/2GJC9sra5W7d5d1f3+rrv16OH6PQntzUA/EeMZoTWJdEFrQCcwIqX+BH9eIv0lU6fqBBcoFwR58X3IALM3WjK1F3hNkzxXM1xdpn6o6kfeWRwPtBeR4PVXGbDZH2/GOQ98fzvgg1h5Ah0jH4hf0jQg7NKmWepP5NE05TZSvOIidbmOoN8wmjuROQsROVBE2vvj/XH5GWtwTmOYP20k8Iw/nu/b+P6/eE83HxjuZ0v1AHoDr0Rlt1FPYpc0DchkadQs9X/MiIzk8SRLoNsaStswmj5hqs4eKCK/EJHpIjIj2EJcuwuwRERWAq8Ci1R1AXAtMNYPVHfCvVbC7zt5+VhgHICqvgk8BqwG/gRcoarVmX1MI3Lio4OwUUWO9KfHRRdBVDE9TVQRkKxcxxYKY6zCMKImzF/iM7hXQv8L/E/MlhJ1Gd99VPVIVT1CVW/y8rdVtb+q9lLVH6ib5YSq7vLtXr7/7Zhr3aKqPVX1UFV9tj4f1GgAYqODTKKKLPW7dHH7+CgiaB+0T7ZQYqxch2EkJ4yzOEBVr1XVx1R1XrBFbplReATRAWQWVWSpv2WL2wfRBdSNKt55J7W+leswjPSE+WtcICKDI7fEaBoMHeoyqDONKrLUV3URxI8ZQQ1uf9BB4R/0ycp1FMiMWcOInDA1Ea4CfiEiu4GvvExV9V+iM8soWIqKXG2mRtB3EcSjwKP8rh76zmE4rzHeb0uX1ssUw2hyhFmDu21DGGI0ItlmUM+aBXfckbx/zBi44ILk/RFmYIfSNwwjLaGqrYnIEOA7vrnUz2oymgrvvAN33knCJeFatIATTkjtLFauhOXLU/enQYl5sIeQ51rfMIzUhJk6Oxn3Kmq1364SkczqPxv5zVlnJZ8ydNBBrj8Vt96avMprcbHrT8ENnJ+yf2La/tSk6zcMIz1hBrgHU7sI0gxc5df/iNYso0HJNgM70ZKmASEWIbqFWWkysGel1E+VgW1LmxpGbgg7t7F9zHG7COwwGptsM7BjlzQNyGBp0/9MEj0kk8eTLCfCciUMIzeEcRa3Aa+LyEMiMhNXRfaWaM0yGpxsM7ATRRcZLG36QFx0EUQFD6SJKgKSZWBbVGEYuSHtk0BVZwPHAU/i1pk4XlXnRm2Y0Qhkm4EdG11kEFWUlrp9fBQRtMvKwt3eMrANIzrCvoY6Hhjgt+OjMsZoZLLNwI6NLjKIKt5/3+2D6ALqRhXvvZda3zKwDSN6wsyGugf4T+AN3JoTPxKR30ZtmNFIZJuBPWWKS6oLGVUEqLoI4j85nxrcvqws+wxscxSGkRvC/PQ7CfiWLxeOH7d4M1KrjMYj2wzs4mLnbOqBiyBmAbO4vx76iTKwDcPIDWGcRSVwEBCUY+vmZUZTIY/XwLYMbMPID8I4i7bAGhF5Bff33B94TUTmA6jqkAjtMxqCbDO4sQxsw2jqhHEWv4zcCqNxCTK4N27cty9EBvdELuCXKaa4TuSClK+EJpL6SzYRe6VkGI1NmKmzz6faGsJII2KyzOCewCNpMqgfSaNvGdiGke+EmQ31qYh84rddIlItIp80hHFGA5JlBvePSFxVNpk8HsvANoz8Jkxk0VZV/8WvX7E/cDZwT+SWGQ1LlhncD8ZFF0FU8GCaqCLAMrANI7/JKOtKHU8Dp0ZjjtGo1DODu1s3t4+PIoL2IYeEu71lYBtG/hLmNdTQmG2YL1m+K4ReNxFZIiKrReRNEbnKyzuKyCIRWef3HbxcRORuEakUkZUi0jfmWiP9+etEZGQWn9dIRT0zuN991+2D6ALqRhXr16fWtwxsw8h/wjwNvheznQp8CpwZQm8P8F+qehiuttQVInIYMA5YrKq9gcW+DXA60Ntvo4F7wTkX3GSYY3HTdscHDsaIgCzWwD7kEBdN1OD2hxxiGdiG0VQIs6xqvdJ5VXUrsNUffyoia4CuOEczwJ82E1gKXOvlD/tM8ZdEpL2IdPHnLlLVDwFEZBFuTY3Z9bHLSEMWGdwugngEeIQH6qFvGdiGkb+INsBPNxHpDrwAHAG8q6rtvVyAnaraXkQWAJNVdZnvW4xzIgOA1qo6yctvBL5Q1alx9xiNi0goLS0tnzNnTr3traqqoiR+GmmeUki2gtkbNWZvtDR1ewcOHFihqv0S9YUrC5oFIlICzAOuVtVPRGrzcVVVRSQn3kpVpwPTAfr166cDBgyo97WWLl1KRvrZlsvIQj9jWxPRgOU6cmJvA2L2RovZGy25tDdSZyEiLXGO4g+q+qQXbxORLqq61b9m2u7lm3F1pwLKvGwzta+tAvnSKO3OmGzLZeSg3Ea2WLkOwzBSEWY2VKmIPCgiz/r2YSIyKoSeAA8Ca1T19piu+UAwo2kk8EyM/CI/K+o44GM/7vEcMEhEOviB7UFelj8E5TISEaJcRtb6WTKR07LsT3d9wzAKnTCzoR7CPZy/4dtvAVeH0DsBuBA4SUT+7rfBwGTgFBFZB3zXtwEWAm/jKtreD/wYwA9s3wy86rebgsHuvCHLchlZ62fJBJ5NU27j2TT6Vq7DMJo6YZ5CnVX1MdzfPaq6B6hOp6Sqy1RVVPVIVT3abwtV9QNVPVlVe6vqd4MHv0/4u0JVe6rqt1X1tZhrzVDVXn77fT0/a7RkWS4ja/0suT5J9JBMHo+V6zCMpk0YZ/GZiHTC/3AMXhFFalUhkmW5jKz1s2RKXHQRRAVT0kQVAVauwzCaNmGeRGNx4wk9ReRF4GHgJ5FaVajUs1xGzvTrSfv2bh8fRQTtTp3CXcfKdRhG0yVMIcHlwL8D/w/4EXC4qq6M2rCCpJ7lMnKmX0927nT7ILqAulHFP/+ZWt/KdRhG0ydUbShgCHAo8K/A90TkZBH5WtTGFST1LJeRM/16ouoiiOs5jRrcvlMnK9dhGIYjTJ7FKOB4YIlvDwAqgB4icpOqhqtB3VzIolxGTvSzwEUQLpqYTO00tbBYuQ7DaLqEcRbFwLdUdRu4vAvcuMWxuBIe5iyyJdsM8AbMwDYMo3kSxll0CxyFZ7uXfSgiX0VkV/MiBxncloFtGEaUhBlBXSoiC/yaEiNxM6OeF5E2wEeRWtdcyDKDeyLnZtmfGsvANgwjjLO4Avg9cLTfZqrq5ar6maoOjNC25kOWGdwTmJMmgzp1BV7LwDYMIx1hps6qqs5T1TGqOgZXCPC3DWBb8yLLDO4rk0QPyeTxWAa2YRipCDWRX0T6iMivRGQjcBPwj0itao5kmcF9X1x0EUQF96WJKgIsA9swjFQkfRKJyL+KyHgR+QfwG+A93GJJA1X1Nw1mYXOinhncZ5/t9vFRRNA+//xwt7cMbMMwkpHqZ+s/gJOAM1T1RO8g0hYQNLKgnhncTzzh9kF0AXWjilmzUutbBrZhGOlI9TQailtDe4mI3C8iJ2OzKKOnnhncqi6CuJJzqcHtzz/fMrANw8gNSfMsVPVp4Gk/RfZM3BoWXxORe4GnVPXPDWJhcyOLDO5Zs4BZc4A53FsPfcvANgwjGWFmQ32mqo+q6vdwS5q+DlwbuWWGYRhG3pDRGtyquhOY7rfmSaLSHKtXw/Ll7rhjRzjggLr9Y8bABRckv6aV6zAMI8/JyFkYpC7NAbB9+76ylekrulu5DsMw8pmGWTChKZGqNEciiovh1ltTnjKRE7LsT42V6zAMI1sicxYiMkNEtovIqhhZRxFZJCLr/L6Dl4uI3C0ilSKyUkT6xuiM9Oev87WpGpdkpTlatkx8/tVXO4eRggksS1NuY1kafSvXYRhGtEQZWTwEcet0wjhgsar2Bhb7NsDpQG+/jQY3mUdEOuIm5RwL9AfGBw6mUUlUmqNrV1chNpbiYrjttlCXnJQkekgm3/e8zOSGYRiZEJmzUNUXgA/jxGcCM/3xTOCsGPnDvg7VS0B7EekCnAosUtUP/eD6IvZ1QA1PotIcU6fCVVfVPS9EVBEQH12EjSpq9a1ch2EY0SEa4SwZEekOLFDVI3z7I1Vt748F2Kmq7UVkATBZVZf5vsW46bkDgNaqOsnLbwS+UNWpCe41GheVUFpaWj5nTriaSImoqqqiJP41UyLeeAN274b99oMjjnCy5cvdzCMR6Ns3tT51Vb7BWrpQtVe+lRK2cChFRdCnT3Jb1651tn6DCrrE9G0FtuDWwUizHEaDEfrfNk8we6PF7I2WTO0dOHBghar2S9ipqpFtQHdgVUz7o7j+nX6/ADgxRr4Y6AdcA9wQI78RuCbdfcvLyzUblixZEu7Exx9XBdUnnqiVjR3rZNdck9E9nbtQ3eMP9sBeWRhb66vf0IT+t80TzN5oMXujJVN7gdc0yXO1oWdDbfOvl/D7YJ7pZqBbzHllXpZMnh8kKs0xZYrLwA45VhGgCvvv78YoXLmNE9h/fyvXYRhGftDQzmI+EMxoGgk8EyO/yM+KOg74WFW3As8Bg0Skgx/YHuRl+UFQmiO24F9xsXMgIccqYvn8cxivyyhSZbwu4/PPM9NXhfGqXl/NURiGkTMiS8oTkdm4MYfOIrIJN6tpMvCYiIwC3gHO8acvBAYDlcDnwCUA6tb5vhl41Z93k6rGD5pHR3y29rZtsGZNbXu//WD9+r2JeJaBbRhGUyUyZ6GqI5J0nZzgXMUt35roOjOAGTk0LTzpsrXjsAxswzCaKpbBnYpMs7WTMJFvpelPp28YhtG4mLNIRbJs7TiSvSCqzXVYnVLfMrANw8h3zFmkI1G2dgaD15PSRBW152UmNwzDaEjMWaQjUbb2VVfVac/njDqZ08E+TFQRYBnYhmHkM+YswhAbXRx4IEyeXKf9A+axJ8FcgSCqSFZjcN/zU7cNwzAaC3MWYQiiC3D74uI67d3airv4KeCigWAfRBW7d6e+fDArNoguavW1Tr9hGEZjYc4iLPHZ2nHta76awu/lEiZxqM+g/hYtW1oGtmEYTQNbKS8sQbZ2snZxMZfU1KaDjPdbJjjHoPXWNwzDiAqLLAzDMIy0mLMAmDXLjUKLuK2iAhXJybb3moZhGAWMvYYCuO8+2LOnjihXj3cr12EYRlPAIguAHTsivbyV6zAMo9AxZwFQWRnJZS2xzjCMpoI5C4Camsge55ZYZxhGU8CcRURYVGEYRlPCnAVQncNrxboGiyoMw2gqmLPIAYliByvXYRhGU8KmzuaYGtxUWSvXYRhGU8IiixxQE7NNog8HlynjVc1RGIbRZDBnUQ9ifUBQ9K8FSpEq43U5773XSIYZhmFERME4CxE5TUTWikiliIxrbHvAOYqbcWMTFkUYhtGUKQhnISItgN8CpwOHASNE5LBcXf9iRqXsj/cDwSsncxSGYTQXCsJZAP2BSlV9W1V3A3OAM3N18Vk8UGdJ01TEvnaycQnDMJoLogXwtBORYcBpqvpD374QOFZVr4w5ZzQwGqC0tLR8zpw5oa9fUQEdeYce/BOAqrIySjZtSnjuVmAL5ZSX1/PD5JiqqipKgvXACwCzN1rM3mhp6vYOHDiwQlX7JexU1bzfgGHAAzHtC4Fpyc4vLy/XTHATXFX3gNaALpk6da+wGnQCKGR0yQZjyZIljW1CRpi90WL2RktTtxd4TZM8VwvlNdRmoFtMu8zLckr82IWNSxiGYTgKxVm8CvQWkR4i0goYDszP1cUDRxCMXYA5CsMwjFgKwlmo6h7gSuA5YA3wmKq+mdt7uH0QXYxklDkKwzAMT8GU+1DVhcDCaO8B8ABLly7lEf0vHonyZoZhGAVEQUQWhmEYRuNizsIwDMNIizkLwzAMIy3mLAzDMIy0FEQGd6aIyA7gnSwu0Rl8Onf+U0i2gtkbNWZvtDR1ew9W1QMTdTRJZ5EtIvKaJkt5zzMKyVYwe6PG7I2W5myvvYYyDMMw0mLOwjAMw0iLOYvETG9sAzKgkGwFszdqzN5oabb22piFYRiGkRaLLAzDMIy0mLMwDMMw0mLOIgYROU1E1opIpYiMa0Q7ZojIdhFZFSPrKCKLRGSd33fwchGRu73NK0Wkb4zOSH/+OhEZGaG93URkiYisFpE3ReSqfLVZRFqLyCsissLbOtHLe4jIy96mub4UPiKyn29X+v7uMde6zsvXisipubY1zu4WIvK6iCzId3tFZKOIvCEifxeR17ws774LMfdpLyJPiMg/RGSNiByfr/aKyKH+3zXYPhGRqxvE3mSrIjW3DWgBrAcOAVoBK4DDGsmW7wB9gVUxsl8B4/zxOGCKPx4MPAsIcBzwspd3BN72+w7+uENE9nYB+vrjtsBbwGH5aLO/Z4k/bgm87G14DBju5fcBl/vjHwP3+ePhwFx/fJj/juwH9PDfnRYRfifGAo8CC3w7b+0FNgKd42R5912IsW0m8EN/3Apon8/2xtjdAngfOLgh7I3sgxTaBhwPPBfTvg64rhHt6U5dZ7EW6OKPuwBr/fHvgBHx5wEjgN/FyOucF7HtzwCn5LvNwAHAcuBYXJZrcfx3AbeGyvH+uNifJ/Hfj9jzIrCzDFgMnAQs8PfPZ3s3sq+zyMvvAtAO2ICf7JPv9sbZOAh4saHstddQtXQF3otpb/KyfKFUVbf64/eBUn+czO5G+Tz+tUcf3C/2vLTZv9L5O7AdWIT7lf2RukW24u+71ybf/zHQqaFs9dwJ/Bz2LuTYKc/tVeDPIlIhIqO9LC+/C7goawfwe/+a7wERaZPH9sYyHJjtjyO315xFAaLup0DezXkWkRJgHnC1qn4S25dPNqtqtaoejfvF3h/4ZuNalBwROQPYrqoVjW1LBpyoqn2B04ErROQ7sZ359F3ARV99gXtVtQ/wGe41zl7yzF4A/BjVEODx+L6o7DVnUctmoFtMu8zL8oVtItIFwO+3e3kyuxv084hIS5yj+IOqPlkINqvqR8AS3Guc9iISrBwZe9+9Nvn+dsAHDWjrCcAQEdkIzMG9irorj+1FVTf7/XbgKZxDztfvwiZgk6q+7NtP4JxHvtobcDqwXFW3+Xbk9pqzqOVVoLefZdIKF+LNb2SbYpkPBDMWRuLGBQL5RX7Ww3HAxz4cfQ4YJCId/MyIQV6Wc0REgAeBNap6ez7bLCIHikh7f7w/bmxlDc5pDEtia/AZhgF/8b/c5gPD/eyjHkBv4JVc2gqgqtepapmqdsd9J/+iqufnq70i0kZE2gbHuP/DVeThdwFAVd8H3hORQ73oZGB1vtobwwhqX0EFdkVrb5QDMIW24WYOvIV7h319I9oxG9gKfIX75TMK9955MbAO+F+goz9XgN96m98A+sVc51Kg0m+XRGjvibiwdyXwd78NzkebgSOB172tq4BfevkhuIdnJS6038/LW/t2pe8/JOZa1/vPsBY4vQG+FwOonQ2Vl/Z6u1b47c3g7ygfvwsx9zkaeM1/J57GzQ7KZ3vb4KLFdjGyyO21ch+GYRhGWuw1lGEYhpEWcxaGYRhGWsxZGIZhGGkxZ2EYhmGkxZyFYRiGkRZzFkZeIyJniYiKSN5mWadDRC4WkWlpzukuIueFuNYA8ZVn62HHBBHZ7KuVrhORJ0XksPpcy2h+mLMw8p0RwDK/b8p0B9I6ixxwh6oeraq9gbnAX0TkwAa4r1HgmLMw8hZfa+pEXFLi8Bh5kYjcI279gUUislBEhvm+chF53hexey4ogRB33YeC8327yu8HiMgLIvI/4tZ8uE9EinzfCHFrNKwSkSmxuiJyi7j1MV4SkdL4+yW4990i8n8i8naMHZOBf/O/+sf4SOOvIrLcb/8vwbWOEVf8rmeYzx2Pqs4F/ox3UiLySxF51X/G6T7rt6eILI+5Z++gLSKTxa1hslJEpqa7n1HYmLMw8pkzgT+p6lvAByJS7uVDcb/EDwMuxNV2CupT/QYYpqrlwAzglgzv2R/4ib92T2CoiHwDmIKry3Q0cIyInOXPbwO8pKpHAS8Al4W4RxecEzwD5yTAFa/7q//Vfweuts8p6grynQvcHXsB7zzuw/0bvZvF515ObSHFaap6jKoeAewPnKGq64GPReRof84luAqtnYDvA4er6pHApJD3MwqU4vSnGEajMQJXNA9cEb0RQAXuQfu4qtYA74vIEn/OocARwCIRAbc4zFYy4xVVfRtARGb7e30FLFXVHV7+B9wCVU8Du3FrTOBtOyXEPZ72tq9OEYm0BKb5h3Q18K8xfd8CpgODVHWLiBxB/T+3xBwPFJGf49b56Igr1/FH4AHgEhEZi3Nc/XGlz3cBD/oxlHqNoxiFgzkLIy8RkY64X/LfFhHFPQBVRH6WSg14U1WPT3P5Pfio2r9mahXTF1//Jl09nK+0tmZONeH+pr6MOZYk54wBtgFHeVt3xfRtxdWA6gNsIfznTkQf4DURaQ3cg6sd9J6ITPD3AFdNeDzwF6BCVT8AEJH+uMJ7w4Arcf9fRhPFXkMZ+cow4BFVPVhVu6tqN9yKZv8GvAic7ccuSnEF9sAVyDtQRPa+lhKRwxNceyMQvNIagvsVH9BfXOXhItyv6GW4gnz/LiKdRaQFLsJ5PoefFeBT3JK0Ae2ArT4CuRDnLAM+Av4DuE1EBhD+c9dBRM7GVRudTa1j+KcfK9o7pqOqu3AVSe8Ffu91S3CF7BbiHNtRmX1co9AwZ2HkKyNwayHEMs/L5+Gq8a4GZuHeu3+sqrtxD7kpIrICV/12n4Fh4H7cw38Fbrzjs5i+V4FpuLLlG4Cn1JV0HocrC74C9+v6GXLLSqDaD5SPwf3KH+lt/Gacjahbx+AMXEXRPoT73ABj/CD6OuAC4CRV3aFubY/7cZV4n8P9O8TyB9xKfX/27bbAAhFZiXOoY+v7wY3CwKrOGgWJiJSoapUfaH0FOEHd2gTZXHMAcI2qnpEDE5sUInINLpK4sbFtMRoHG7MwCpUF4hYxagXcnK2jMJIjIk/hZobZmEQzxiILwzAMIy02ZmEYhmGkxZyFYRiGkRZzFoZhGEZazFkYhmEYaTFnYRiGYaTl/wMWipzSxZ5jcwAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import seaborn as sns\n", "\n", "X1 = df[[numerical_features_all[0], numerical_features_all[1]]][df[model_target] == 0]\n", "X2 = df[[numerical_features_all[0], numerical_features_all[1]]][df[model_target] == 1]\n", "\n", "plt.scatter(X1.iloc[:,0], \n", " X1.iloc[:,1], \n", " s=50, \n", " c='blue', \n", " marker='o', \n", " label='0')\n", "\n", "plt.scatter(X2.iloc[:,0], \n", " X2.iloc[:,1], \n", " s=50, \n", " c='red', \n", " marker='v', \n", " label='1')\n", "\n", "plt.xlabel(numerical_features_all[0])\n", "plt.ylabel(numerical_features_all[1])\n", "plt.legend()\n", "plt.grid()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Scatterplots with identification, can sometimes help identify whether or not we can get good separation between the data points, based on these two numerical features alone. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Correlation Matrix Heatmat\n", "We plot the correlation matrix. Correlation scores are calculated for numerical fields. " ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
 Age upon Intake DaysAge upon Outcome Days
Age upon Intake Days1.0000000.998839
Age upon Outcome Days0.9988391.000000
\n" ], "text/plain": [ "" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cols=[numerical_features_all[0], numerical_features_all[1]]\n", "#print(df[cols].corr())\n", "df[cols].corr().style.background_gradient(cmap='tab20c')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Similar to scatterplots, but now the correlation matrix values can more clearly pinpoint relationships between the numerical features. Correlation values of -1 means perfect negative correlation, 1 means perfect positive correlation, and 0 means there is no relationship between the two numerical features." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### A fancy example using Seaborn" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from string import ascii_letters\n", "import numpy as np\n", "import pandas as pd\n", "import seaborn as sns\n", "import matplotlib.pyplot as plt\n", "\n", "sns.set(style=\"white\")\n", "\n", "# Generate a large random dataset\n", "rs = np.random.RandomState(33)\n", "d = pd.DataFrame(data=rs.normal(size=(100, 26)),\n", " columns=list(ascii_letters[26:]))\n", "\n", "# Compute the correlation matrix\n", "corr = d.corr()\n", "\n", "# Generate a mask for the upper triangle\n", "mask = np.triu(np.ones_like(corr, dtype=np.bool))\n", "\n", "# Set up the matplotlib figure\n", "f, ax = plt.subplots(figsize=(11, 9))\n", "\n", "# Generate a custom diverging colormap\n", "cmap = sns.diverging_palette(220, 10, as_cmap=True)\n", "\n", "# Draw the heatmap with the mask and correct aspect ratio\n", "sns.heatmap(corr, mask=mask, cmap=cmap, vmax=.3, center=0,\n", " square=True, linewidths=.5, cbar_kws={\"shrink\": .5})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Also, more exploratory data analysis might reveal other important hidden atributes and/or relationships of the model features considered. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 5. Handling Missing Values\n", "(Go to top)\n", "\n", " * Drop columns with missing values\n", " * Drop rows with missing values\n", " * Impute (fill-in) missing values with .fillna()\n", " * Impute (fill-in) missing values with sklearn's SimpleImputer\n", "\n", "Let's first check the number of missing (nan) values for each column." ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Pet ID 0\n", "Outcome Type 0\n", "Sex upon Outcome 1\n", "Name 36343\n", "Found Location 0\n", "Intake Type 0\n", "Intake Condition 0\n", "Pet Type 0\n", "Sex upon Intake 1\n", "Breed 0\n", "Color 0\n", "Age upon Intake Days 0\n", "Age upon Outcome Days 0\n", "dtype: int64" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df.isna().sum()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's explore a few options dealing with missing values, when there are values missing on many features, both numerical and categorical types. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Drop columns with missing values\n", "(Go to Handling Missing Values)\n", "\n", "We can drop some feautures/columns if we think there is significant amount of missing data in those features. Here we \n", "are dropping features having more than 20% missing values.\n", "\n", "__Hint:__ You can also use __inplace=True__ parameter to drop features inplace without assignment.\n" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Pet ID 0.000000\n", "Outcome Type 0.000000\n", "Sex upon Outcome 0.000010\n", "Name 0.380706\n", "Found Location 0.000000\n", "Intake Type 0.000000\n", "Intake Condition 0.000000\n", "Pet Type 0.000000\n", "Sex upon Intake 0.000010\n", "Breed 0.000000\n", "Color 0.000000\n", "Age upon Intake Days 0.000000\n", "Age upon Outcome Days 0.000000\n", "dtype: float64\n", "Index(['Name'], dtype='object')\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
Pet IDOutcome TypeSex upon OutcomeFound LocationIntake TypeIntake ConditionPet TypeSex upon IntakeBreedColorAge upon Intake DaysAge upon Outcome Days
0A7940111.0Neutered MaleAustin (TX)Owner SurrenderNormalCatNeutered MaleDomestic Shorthair MixBrown Tabby/White730730
1A7763591.0Neutered Male7201 Levander Loop in Austin (TX)StrayNormalDogIntact MaleChihuahua Shorthair MixWhite/Brown365365
2A6747540.0Intact Male12034 Research in Austin (TX)StrayNursingCatIntact MaleDomestic Shorthair MixOrange Tabby66
3A6897241.0Neutered Male2300 Waterway Bnd in Austin (TX)StrayNormalCatIntact MaleDomestic Shorthair MixBlack6060
4A6809691.0Neutered Male4701 Staggerbrush Rd in Austin (TX)StrayNursingCatIntact MaleDomestic Shorthair MixWhite/Orange Tabby760
\n", "
" ], "text/plain": [ " Pet ID Outcome Type Sex upon Outcome \\\n", "0 A794011 1.0 Neutered Male \n", "1 A776359 1.0 Neutered Male \n", "2 A674754 0.0 Intact Male \n", "3 A689724 1.0 Neutered Male \n", "4 A680969 1.0 Neutered Male \n", "\n", " Found Location Intake Type Intake Condition \\\n", "0 Austin (TX) Owner Surrender Normal \n", "1 7201 Levander Loop in Austin (TX) Stray Normal \n", "2 12034 Research in Austin (TX) Stray Nursing \n", "3 2300 Waterway Bnd in Austin (TX) Stray Normal \n", "4 4701 Staggerbrush Rd in Austin (TX) Stray Nursing \n", "\n", " Pet Type Sex upon Intake Breed Color \\\n", "0 Cat Neutered Male Domestic Shorthair Mix Brown Tabby/White \n", "1 Dog Intact Male Chihuahua Shorthair Mix White/Brown \n", "2 Cat Intact Male Domestic Shorthair Mix Orange Tabby \n", "3 Cat Intact Male Domestic Shorthair Mix Black \n", "4 Cat Intact Male Domestic Shorthair Mix White/Orange Tabby \n", "\n", " Age upon Intake Days Age upon Outcome Days \n", "0 730 730 \n", "1 365 365 \n", "2 6 6 \n", "3 60 60 \n", "4 7 60 " ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "threshold = 2/10\n", "print((df.isna().sum()/len(df.index)))\n", "columns_to_drop = df.loc[:,list(((df.isna().sum()/len(df.index))>=threshold))].columns \n", "print(columns_to_drop)\n", "\n", "df_columns_dropped = df.drop(columns_to_drop, axis = 1) \n", "df_columns_dropped.head()" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Pet ID 0\n", "Outcome Type 0\n", "Sex upon Outcome 1\n", "Found Location 0\n", "Intake Type 0\n", "Intake Condition 0\n", "Pet Type 0\n", "Sex upon Intake 1\n", "Breed 0\n", "Color 0\n", "Age upon Intake Days 0\n", "Age upon Outcome Days 0\n", "dtype: int64" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df_columns_dropped.isna().sum()" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(95462, 12)" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df_columns_dropped.shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note the reduced size of the dataset features. This can sometimes lead to underfitting models -- not having enough features to build a good model able to capture the pattern in the dataset, especially when dropping features that are essential to the task at hand. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Drop rows with missing values\n", "(Go to Handling Missing Values)\n", "\n", "Here, we simply drop rows that have at least one missing value. There are other drop options to explore, depending on specific problems." ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [], "source": [ "df_missing_dropped = df.dropna()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's check the missing values below." ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Pet ID 0\n", "Outcome Type 0\n", "Sex upon Outcome 0\n", "Name 0\n", "Found Location 0\n", "Intake Type 0\n", "Intake Condition 0\n", "Pet Type 0\n", "Sex upon Intake 0\n", "Breed 0\n", "Color 0\n", "Age upon Intake Days 0\n", "Age upon Outcome Days 0\n", "dtype: int64" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df_missing_dropped.isna().sum()" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(59118, 13)" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df_missing_dropped.shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This approach can dramatically reduce the number of data samples. This can sometimes lead to overfitting models -- especially when the number of features is greater or comparable to the number of data samples. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Impute (fill-in) missing values with .fillna()\n", "(Go to Handling Missing Values)\n", "\n", "Rather than dropping rows (data samples) and/or columns (features), another strategy to deal with missing values would be to actually complete the missing values with new values: imputation of missing values.\n", "\n", "__Imputing Numerical Values:__ The easiest way to impute numerical values is to get the __average (mean) value__ for the corresponding column and use that as the new value for each missing record in that column. " ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Age upon Intake Days 0\n", "Age upon Outcome Days 0\n", "dtype: int64\n", "Age upon Intake Days 0\n", "Age upon Outcome Days 0\n", "dtype: int64\n" ] } ], "source": [ "# Impute numerical features by using the mean per feature to replace the nans\n", "\n", "# Assign our df to a new df \n", "df_imputed = df.copy()\n", "print(df_imputed[numerical_features_all].isna().sum())\n", "\n", "# Impute our two numerical features with the means. \n", "df_imputed[numerical_features_all] = df_imputed[numerical_features_all].fillna(df_imputed[numerical_features_all].mean())\n", "\n", "print(df_imputed[numerical_features_all].isna().sum())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__Imputing Categorical Values:__ We can impute categorical values by getting the most common (mode) value for the corresponding column and use that as the new value for each missing record in that column. " ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Pet ID 0\n", "Sex upon Outcome 1\n", "Name 36343\n", "Found Location 0\n", "Intake Type 0\n", "Intake Condition 0\n", "Pet Type 0\n", "Sex upon Intake 1\n", "Breed 0\n", "Color 0\n", "dtype: int64\n", "Pet ID 0 A047759\n", "1 A134067\n", "2 A141142\n", "3 A163459\n", "4 A165752\n", " ... \n", "95457 A819862\n", "95458 A819864\n", "95459 A819865\n", "95460 A819895\n", "95461 A819908\n", "Name: Pet ID, Length: 95462, dtype: object\n", "Sex upon Outcome 0 Neutered Male\n", "Name: Sex upon Outcome, dtype: object\n", "Name 0 Bella\n", "Name: Name, dtype: object\n", "Found Location 0 Austin (TX)\n", "Name: Found Location, dtype: object\n", "Intake Type 0 Stray\n", "Name: Intake Type, dtype: object\n", "Intake Condition 0 Normal\n", "Name: Intake Condition, dtype: object\n", "Pet Type 0 Dog\n", "Name: Pet Type, dtype: object\n", "Sex upon Intake 0 Intact Male\n", "Name: Sex upon Intake, dtype: object\n", "Breed 0 Domestic Shorthair Mix\n", "Name: Breed, dtype: object\n", "Color 0 Black/White\n", "Name: Color, dtype: object\n", "Pet ID 0\n", "Sex upon Outcome 0\n", "Name 0\n", "Found Location 0\n", "Intake Type 0\n", "Intake Condition 0\n", "Pet Type 0\n", "Sex upon Intake 0\n", "Breed 0\n", "Color 0\n", "dtype: int64\n" ] } ], "source": [ "# Impute categorical features by using the mode per feature to replace the nans\n", "\n", "# Assign our df to a new df \n", "df_imputed_c = df.copy()\n", "print(df_imputed_c[categorical_features_all].isna().sum())\n", "\n", "for c in categorical_features_all:\n", " # Find the mode per each feature\n", " mode_impute = df_imputed_c[c].mode()\n", " print(c, mode_impute)\n", "\n", " # Impute our categorical features with the mode\n", " # \"inplace=True\" parameter replaces missing values in place (no need for left handside assignment)\n", " df_imputed_c[c].fillna(False, inplace=True)\n", "\n", "print(df_imputed_c[categorical_features_all].isna().sum())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can also create a new category, such as \"Missing\", for alll or elected categorical features." ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Pet ID 0\n", "Sex upon Outcome 1\n", "Name 36343\n", "Found Location 0\n", "Intake Type 0\n", "Intake Condition 0\n", "Pet Type 0\n", "Sex upon Intake 1\n", "Breed 0\n", "Color 0\n", "dtype: int64\n", "Pet ID 0\n", "Sex upon Outcome 0\n", "Name 0\n", "Found Location 0\n", "Intake Type 0\n", "Intake Condition 0\n", "Pet Type 0\n", "Sex upon Intake 0\n", "Breed 0\n", "Color 0\n", "dtype: int64\n" ] } ], "source": [ "# Impute categorical features by using a placeholder value\n", "\n", "# Assign our df to a new df \n", "df_imputed = df.copy()\n", "print(df_imputed[categorical_features_all].isna().sum())\n", "\n", "# Impute our categorical features with a new category named \"Missing\". \n", "df_imputed[categorical_features_all]= df_imputed[categorical_features_all].fillna(\"Missing\")\n", "\n", "print(df_imputed[categorical_features_all].isna().sum())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Impute (fill-in) missing values with sklearn's __SimpleImputer__\n", "(Go to Handling Missing Values)\n", "\n", "A more elegant way to implement imputation is using sklearn's __SimpleImputer__, a class implementing .fit() and .transform() methods.\n" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Age upon Intake Days 0\n", "Age upon Outcome Days 0\n", "dtype: int64\n", "Age upon Intake Days 0\n", "Age upon Outcome Days 0\n", "dtype: int64\n" ] } ], "source": [ "# Impute numerical columns by using the mean per column to replace the nans\n", "\n", "from sklearn.impute import SimpleImputer\n", "\n", "# Assign our df to a new df\n", "df_sklearn_imputed = df.copy()\n", "print(df_sklearn_imputed[numerical_features_all].isna().sum())\n", "\n", "imputer = SimpleImputer(strategy='mean')\n", "df_sklearn_imputed[numerical_features_all] = imputer.fit_transform(df_sklearn_imputed[numerical_features_all])\n", "\n", "print(df_sklearn_imputed[numerical_features_all].isna().sum())" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Index(['Name', 'Sex upon Intake'], dtype='object')\n", "Name 36343\n", "Sex upon Intake 1\n", "dtype: int64\n", "Name 0\n", "Sex upon Intake 0\n", "dtype: int64\n" ] } ], "source": [ "# Impute categorical columns by using the mode per column to replace the nans\n", "\n", "# Pick some categorical features you desire to impute with this approach\n", "categoricals_missing_values = df[categorical_features_all].loc[:,list(((df[categorical_features_all].isna().sum()/len(df.index)) > 0.0))].columns \n", "columns_to_impute = categoricals_missing_values[1:3]\n", "print(columns_to_impute)\n", "\n", "from sklearn.impute import SimpleImputer\n", "\n", "# Assign our df to a new df\n", "df_sklearn_imputer = df.copy()\n", "print(df_sklearn_imputer[columns_to_impute].isna().sum())\n", "\n", "imputer = SimpleImputer(strategy='most_frequent')\n", "df_sklearn_imputer[columns_to_impute] = imputer.fit_transform(df_sklearn_imputer[columns_to_impute])\n", "\n", "print(df_sklearn_imputer[columns_to_impute].isna().sum())" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Index(['Name', 'Sex upon Intake'], dtype='object')\n", "Name 36343\n", "Sex upon Intake 1\n", "dtype: int64\n", "Name 0\n", "Sex upon Intake 0\n", "dtype: int64\n" ] } ], "source": [ "# Impute categorical columns by using a placeholder \"Missing\"\n", "\n", "# Pick some categorical features you desire to impute with this approach\n", "categoricals_missing_values = df[categorical_features_all].loc[:,list(((df[categorical_features_all].isna().sum()/len(df.index)) > 0.0))].columns \n", "columns_to_impute = categoricals_missing_values[1:3]\n", "print(columns_to_impute)\n", "\n", "from sklearn.impute import SimpleImputer\n", "\n", "# Assign our df to a new df\n", "df_sklearn_imputer = df.copy()\n", "print(df_sklearn_imputer[columns_to_impute].isna().sum())\n", "\n", "imputer = SimpleImputer(strategy='constant', fill_value = \"Missing\")\n", "df_sklearn_imputer[columns_to_impute] = imputer.fit_transform(df_sklearn_imputer[columns_to_impute])\n", "\n", "print(df_sklearn_imputer[columns_to_impute].isna().sum())" ] } ], "metadata": { "kernelspec": { "display_name": "conda_pytorch_p39", "language": "python", "name": "conda_pytorch_p39" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.13" } }, "nbformat": 4, "nbformat_minor": 4 }