From feaf61d1f9ea01310d009c8a044efc340d2f09d8 Mon Sep 17 00:00:00 2001 From: Christina Yu <89359672+Yishany@users.noreply.github.com> Date: Wed, 8 Jun 2022 22:51:08 -0700 Subject: [PATCH 1/5] Add files via upload EDA analysis draft 1 --- ExploratoryDataAnalysis.ipynb | 1102 +++++++++++++++++++++++++++++++++ 1 file changed, 1102 insertions(+) create mode 100644 ExploratoryDataAnalysis.ipynb diff --git a/ExploratoryDataAnalysis.ipynb b/ExploratoryDataAnalysis.ipynb new file mode 100644 index 0000000..70ba995 --- /dev/null +++ b/ExploratoryDataAnalysis.ipynb @@ -0,0 +1,1102 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exploratory Data Analysis \n", + "\n", + "This file is composed of components of the EDA process for preliminary exploration of your data. This code is not a complete EDA, but rather a preliminary examination of data. Please see the Table of Contents to explore different areas of EDA.\n", + "***\n", + "\n", + "##### **Input:** .csv file with entire dataset. Will need to interpolate prior to using unsupervised learning if NaN exist in your dataset\n", + "##### **Output:** Figures for EDA\n", + "##### **Dependencies:** \n", + "***\n", + "\n", + "##### Format of input: \n", + ".csv file with entire dataset \n", + "***\n", + "\n", + "**Check:** \n", + "* Will need to interpolate data/remove NaN before doing any unsupervised learning for EDA\n", + "\n", + "**Sources:**\n", + "\n", + "***\n", + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Table of Contents\n", + "\n", + "#### Exploratory Data Analysis\n", + "* [Cleaning and Filtering Data](#read)\n", + "* [Correlation Plots](#corr)\n", + "* [Covariance Matrix](#cov)\n", + "* [Missing Data Analysis](#miss)\n", + "* [Outlier Analysis](#out)\n", + "* [Histograms of Features](#hist)\n", + "\n", + "#### Unsupervised Learning\n", + "* [Clustering](#cluster)\n", + " * [KNN Clustering](#knn)\n", + " * [Hierarchical Clustering](#hic)\n", + "* [Principal Component Analysis (PCA)](#pca)\n", + "\n", + "\n", + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Read data:\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'filename' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mpandas\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mnumpy\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread_csv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilename\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m#Change filename\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mNameError\u001b[0m: name 'filename' is not defined" + ] + } + ], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "data = pd.read_csv(filename) #Change filename" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Preliminary Exploratory Data Analysis:\n", + "\n", + "https://github.com/dformoso/sklearn-classification/blob/master/Data%20Science%20Workbook%20-%20Census%20Income%20Dataset.ipynb" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "238595" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(data)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "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", + " \n", + " \n", + " \n", + "
ECGApple WatchEmpaticaGarminFitbitMibandBiovotionSkin Tone
count221475.00000012791.000000138252.00000036625.00000010861.00000020632.000000160841.000000238595.000000
mean90.54972689.57923588.96212184.41821284.25338486.71379486.9385793.638509
std20.56801817.02151815.87316615.43022616.89886714.53644016.9823741.669205
min24.17400036.00000048.20000039.00000046.00000045.00000045.0000001.000000
25%76.35500078.00000077.63000073.00000070.00000074.00000075.0000002.000000
50%89.29100089.00000087.43000084.00000081.00000087.00000086.0000004.000000
75%101.030000100.00000099.12000096.00000095.00000098.00000098.0000005.000000
max240.000000155.000000178.740000134.000000180.000000128.000000168.0000006.000000
\n", + "
" + ], + "text/plain": [ + " ECG Apple Watch Empatica Garmin Fitbit \\\n", + "count 221475.000000 12791.000000 138252.000000 36625.000000 10861.000000 \n", + "mean 90.549726 89.579235 88.962121 84.418212 84.253384 \n", + "std 20.568018 17.021518 15.873166 15.430226 16.898867 \n", + "min 24.174000 36.000000 48.200000 39.000000 46.000000 \n", + "25% 76.355000 78.000000 77.630000 73.000000 70.000000 \n", + "50% 89.291000 89.000000 87.430000 84.000000 81.000000 \n", + "75% 101.030000 100.000000 99.120000 96.000000 95.000000 \n", + "max 240.000000 155.000000 178.740000 134.000000 180.000000 \n", + "\n", + " Miband Biovotion Skin Tone \n", + "count 20632.000000 160841.000000 238595.000000 \n", + "mean 86.713794 86.938579 3.638509 \n", + "std 14.536440 16.982374 1.669205 \n", + "min 45.000000 45.000000 1.000000 \n", + "25% 74.000000 75.000000 2.000000 \n", + "50% 87.000000 86.000000 4.000000 \n", + "75% 98.000000 98.000000 5.000000 \n", + "max 128.000000 168.000000 6.000000 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.describe()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Correlation Plots\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "corr = data.corr()\n", + "sns.heatmap(corr, \n", + " xticklabels=corr.columns,\n", + " yticklabels=corr.columns)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#Correlation Plot\n", + "corr = data.corr()\n", + "sns.heatmap(corr, \n", + " xticklabels=corr.columns,\n", + " yticklabels=corr.columns)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Covariance Matrix\n", + "\n", + "\n", + "Compute pairwise covariance of columns\n", + "\n", + "Covariance is a measure of how much two random variables vary together. It’s similar to variance, but where variance tells you how a single variable varies, co variance tells you how two variables vary together.\n", + "*Covariance must be scaled.*\n", + "\n", + "- Python: https://www.geeksforgeeks.org/python-pandas-dataframe-cov/\n", + "- Math/Interpretation: https://www.statisticshowto.datasciencecentral.com/covariance/" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'data' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m#Need to standardize scale:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mcv_df\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdrop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m#drop all columns that are non-numeric\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0msklearn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpreprocessing\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mStandardScaler\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0msc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mStandardScaler\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mcv_np\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcv_df\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'data' is not defined" + ] + } + ], + "source": [ + "#Need to standardize scale:\n", + "cv_df = data.drop(columns=[]) #drop all columns that are non-numeric\n", + "from sklearn.preprocessing import StandardScaler\n", + "sc = StandardScaler()\n", + "cv_np = sc.fit_transform(cv_df)\n", + "cv_df = pd.DataFrame(cv_np)\n", + "#cv_df.columns = [] #name columns if desired\n", + "\n", + "#covariance \n", + "cv_df.cov()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Check for missing values\n", + "\n", + "#### Very cool package for missing values (includes heatmaps of missing, bar graphs, and matrices of missing values):\n", + "https://github.com/ResidentMario/missingno" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'missingno'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "Input \u001b[0;32mIn [13]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mmissingno\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mmsno\u001b[39;00m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;66;03m#Check for missing data\u001b[39;00m\n\u001b[1;32m 4\u001b[0m msno\u001b[38;5;241m.\u001b[39mmatrix(data)\n", + "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'missingno'" + ] + } + ], + "source": [ + "import missingno as msno\n", + "\n", + "#Check for missing data\n", + "msno.matrix(data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot Distribution of Each Feature\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Outcome variable \n", + "\n", + "To look at how the outcome variable is balanced:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'outcomevariablehere' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Input \u001b[0;32mIn [12]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m plt\u001b[38;5;241m.\u001b[39mstyle\u001b[38;5;241m.\u001b[39muse(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mseaborn-whitegrid\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 2\u001b[0m fig \u001b[38;5;241m=\u001b[39m plt\u001b[38;5;241m.\u001b[39mfigure(figsize\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m20\u001b[39m,\u001b[38;5;241m1\u001b[39m)) \n\u001b[0;32m----> 3\u001b[0m sns\u001b[38;5;241m.\u001b[39mcountplot(y\u001b[38;5;241m=\u001b[39m\u001b[43moutcomevariablehere\u001b[49m, data\u001b[38;5;241m=\u001b[39mdata)\n", + "\u001b[0;31mNameError\u001b[0m: name 'outcomevariablehere' is not defined" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.style.use('seaborn-whitegrid')\n", + "fig = plt.figure(figsize=(20,1)) \n", + "sns.countplot(y=outcomevariablehere, data=data); #put outcomevariable here" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot distributions by outcome class \n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'outcome_a' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Input \u001b[0;32mIn [10]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mseaborn\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01msns\u001b[39;00m\n\u001b[1;32m 4\u001b[0m \u001b[38;5;66;03m# Sort dataframe by outcome\u001b[39;00m\n\u001b[1;32m 5\u001b[0m \n\u001b[1;32m 6\u001b[0m \u001b[38;5;66;03m#Plot outcome variables\u001b[39;00m\n\u001b[0;32m----> 7\u001b[0m sns\u001b[38;5;241m.\u001b[39mdistplot(\u001b[43moutcome_a\u001b[49m[[X1]], hist\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m, rug\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m 8\u001b[0m sns\u001b[38;5;241m.\u001b[39mdistplot(outcome_b[[X1]], hist\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m, rug\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m 9\u001b[0m sns\u001b[38;5;241m.\u001b[39mdistplot(outcome_c[[X1]], hist\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m, rug\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n", + "\u001b[0;31mNameError\u001b[0m: name 'outcome_a' is not defined" + ] + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "# Sort dataframe by outcome\n", + "\n", + "#Plot outcome variables\n", + "sns.distplot(outcome_a[[X1]], hist=False, rug=True)\n", + "sns.distplot(outcome_b[[X1]], hist=False, rug=True)\n", + "sns.distplot(outcome_c[[X1]], hist=False, rug=True)\n", + "\n", + "plt.title()\n", + "plt.xlabel()\n", + "plt.legend(labels=[])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot all variables at once:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Outlier Analysis\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sns.boxplot(y=variablehere, x=variablehere, data=data, palette=\"Set1\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot histograms of all variables in data" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "def makehist(datainput, label, color):\n", + " fig = plt.figure(figsize=(16,4))\n", + " mean = datainput.mean(axis = 0) #changeoutcomevar\n", + " plt.hist(datainput, bins=(20), align='mid', color=color, alpha=0.5)\n", + " plt.axvline(x=mean, color=color, linestyle='-')\n", + " plt.xlabel(label)\n", + " plt.ylabel('Frequency')\n", + " plt.title((label + ' Histogram'))\n", + " plt.tight_layout()\n", + " plt.savefig((filesource + label + '.png'), dpi=100) #change filesource or add as input to function if variable\n", + " print(('Saved plot of ' + label))" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved plot of Mean\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "makehist(data['Variable'], 'Variable', 'green')\n", + "#Repeat above command for each numeric Variable in data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot boxplot of all variables in data" + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "metadata": {}, + "outputs": [], + "source": [ + "def makeboxplot(datainput, label):\n", + " fig = plt.figure(figsize =(16, 4))\n", + " plt.boxplot(datainput)\n", + " plt.title((label + ' Box Plot'))\n", + " plt.savefig((filesource + label + '.png'), dpi=100) #change filesource or add as input to function if variable\n", + " print(('Saved plot of ' + label))" + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved plot of Mean\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "makeboxplot(data['Variable'], 'Variable')\n", + "#Repeat above command for each numeric Variable in data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot leafplot of all variables in data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def makeleafplot(datainput, label):\n", + " fig = plt.figure(figsize =(16, 4))\n", + " plt.stem(datainput)\n", + " plt.title((label + ' Leaf Plot'))\n", + " plt.savefig((filesource + label + '.png'), dpi=100) #change filesource or add as input to function if variable\n", + " print(('Saved plot of ' + label))" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "makeleafplot(data['Variable'], 'Variable')\n", + "#Repeat above command for each numeric Variable in data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Unsupervised Learning Section- " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Clustering\n", + "\n", + "\n", + "https://www.neuroelectrics.com/blog/clustering-methods-in-exploratory-analysis/" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dfc = data.drop(columns=[]) # drop all non-numeric columns\n", + "dfc.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### KNN Clustering:\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.cluster import KMeans\n", + "# create kmeans object\n", + "kmeans = KMeans(n_clusters=3)# fit kmeans object to data\n", + "kmeans.fit(dfc)# print location of clusters learned by kmeans object\n", + "#print(kmeans.cluster_centers_)# save new clusters for chart\n", + "y_km = kmeans.fit_predict(dfc)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "labels = kmeans.labels_\n", + "dfc['clusters'] = labels" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Hierarchical Clustering\n", + "\n", + "\n", + "*Agglomerative (data points are clustered using a bottim-up approach starting with individual data points)\n", + "\n", + "\n", + "https://stackabuse.com/hierarchical-clustering-with-python-and-scikit-learn/" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import scipy.cluster.hierarchy as shc\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.figure(figsize=(10, 7))\n", + "plt.title(\"Data Dendograms\")\n", + "dend = shc.dendrogram(shc.linkage(dfc, method='ward'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.cluster import AgglomerativeClustering\n", + "from scipy.cluster.hierarchy import dendrogram, linkage\n", + "\n", + "cluster = AgglomerativeClustering(n_clusters=3, affinity='euclidean', linkage='ward')\n", + "cluster.fit_predict(dfc)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(cluster.labels_)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## PCA (Prinicipal Component Analysis)\n", + "\n", + "https://cmdlinetips.com/2018/03/pca-example-in-python-with-scikit-learn/\n", + "\n", + "https://scikit-learn.org/stable/tutorial/statistical_inference/unsupervised_learning.html\n", + "\n", + "PCA selects the successive components that explain the maximum variance in the signal.\n", + "This is useful to us because we have a large amount of features. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Need to scale prior to doing PCA\n", + "\n", + "from sklearn.preprocessing import StandardScaler\n", + "sc = StandardScaler()\n", + "sdfc = sc.fit_transform(dfc)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "from sklearn import decomposition\n", + "pca = decomposition.PCA()\n", + "pca.fit(sdfc)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "print(pca.explained_variance_ratio_)\n", + "print(pca.singular_values_) " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pca.n_components = 9\n", + "pc = pca.fit(dfc)\n", + "\n", + "result=pd.DataFrame(pca.transform(dfc), columns=['PCA%i' % i for i in range(9)], index=dfc.index)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pcft = pca.fit_transform(dfc)\n", + "\n", + "pc_df = pd.DataFrame(data=pcft, columns= ['PC1', 'PC2', 'PC3', 'PC4', 'PC5', 'PC6', 'PC7', 'PC8', 'PC9'])\n", + "\n", + "#Example below:\n", + "#pc_df['Cluster'] = data['Definition']\n", + "#pc_df['Status'] = data['Status']\n", + "#pc_df['Gender'] = data['Gender']\n", + "pc_df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "\n", + "import seaborn as sns\n", + "dfvar = pd.DataFrame({'var':pca.explained_variance_ratio_,\n", + " 'PC':['PC1','PC2','PC3','PC4', 'PC5', 'PC6', 'PC7', 'PC8', 'PC9']})\n", + "sns.barplot(x='PC',y=\"var\", \n", + " data=dfvar, color=\"c\");\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Install matplotlib widget Ipython magic: https://github.com/matplotlib/jupyter-matplotlib\n", + "\n", + "Problems with matplotlib widget not working: https://github.com/matplotlib/jupyter-matplotlib/issues/66" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib widget \n", + "\n", + "import matplotlib.pyplot as plt\n", + "from mpl_toolkits.mplot3d import axes3d, Axes3D #<-- Note the capitalization! \n", + "\n", + "\n", + "pc_df[insertvarhere]=pd.Categorical(pc_df[insertvarhere]) #need to change insertvarhere\n", + "my_color=pc_df[insertvarhere].cat.codes #need to change insertvarhere\n", + "\n", + "# Plot initialisation\n", + "fig = plt.figure()\n", + "ax = Axes3D(fig) \n", + "ax.scatter(result['PCA0'], result['PCA1'], result['PCA2'], c=my_color, cmap='Accent', s=60)\n", + "\n", + "#make simple, bare axis lines through space:\n", + "xAxisLine = ((min(result['PCA0']), max(result['PCA0'])), (0, 0), (0,0))\n", + "ax.plot(xAxisLine[0], xAxisLine[1], xAxisLine[2], 'r')\n", + "yAxisLine = ((0, 0), (min(result['PCA1']), max(result['PCA1'])), (0,0))\n", + "ax.plot(yAxisLine[0], yAxisLine[1], yAxisLine[2], 'r')\n", + "zAxisLine = ((0, 0), (0,0), (min(result['PCA2']), max(result['PCA2'])))\n", + "ax.plot(zAxisLine[0], zAxisLine[1], zAxisLine[2], 'r')\n", + " \n", + "# label the axes\n", + "ax.set_xlabel(\"PC1\")\n", + "ax.set_ylabel(\"PC2\")\n", + "ax.set_zlabel(\"PC3\")\n", + "ax.set_title(\"PCA\")\n", + "#ax.legend()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sns.lmplot( x=\"PC1\", y=\"PC5\",\n", + " data=pc_df, \n", + " fit_reg=False, \n", + " hue=Variable, # color by change variable here\n", + " legend=True,\n", + " scatter_kws={\"s\": 80,'alpha':0.3}) # specify the point size" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/christinayu/opt/anaconda3/lib/python3.8/site-packages/sklearn/utils/deprecation.py:143: FutureWarning: The sklearn.datasets.samples_generator module is deprecated in version 0.22 and will be removed in version 0.24. The corresponding classes / functions should instead be imported from sklearn.datasets. Anything that cannot be imported from sklearn.datasets is now part of the private API.\n", + " warnings.warn(message, FutureWarning)\n", + "/Users/christinayu/opt/anaconda3/lib/python3.8/site-packages/matplotlib/collections.py:922: RuntimeWarning: invalid value encountered in sqrt\n", + " scale = np.sqrt(self._sizes) * dpi / 72.0 * self._factor\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.98318212 0.00850037 0.00831751]\n", + "[3.78521638 0.03272613 0.03202212]\n", + "[0.98318212 0.00850037]\n", + "[3.78521638 0.03272613]\n" + ] + }, + { + "ename": "TypeError", + "evalue": "loop of ufunc does not support argument 0 of type NoneType which has no callable sqrt method", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;31mAttributeError\u001b[0m: 'NoneType' object has no attribute 'sqrt'", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 24\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 25\u001b[0m \u001b[0mX_new\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpca\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 26\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscatter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_new\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX_new\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmarker\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'o'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 27\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 28\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/matplotlib/pyplot.py\u001b[0m in \u001b[0;36mscatter\u001b[0;34m(x, y, s, c, marker, cmap, norm, vmin, vmax, alpha, linewidths, verts, edgecolors, plotnonfinite, data, **kwargs)\u001b[0m\n\u001b[1;32m 2888\u001b[0m \u001b[0mverts\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcbook\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdeprecation\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_deprecated_parameter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2889\u001b[0m edgecolors=None, *, plotnonfinite=False, data=None, **kwargs):\n\u001b[0;32m-> 2890\u001b[0;31m __ret = gca().scatter(\n\u001b[0m\u001b[1;32m 2891\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmarker\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmarker\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcmap\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcmap\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnorm\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2892\u001b[0m \u001b[0mvmin\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mvmin\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvmax\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mvmax\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0malpha\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0malpha\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlinewidths\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlinewidths\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/mpl_toolkits/mplot3d/axes3d.py\u001b[0m in \u001b[0;36mscatter\u001b[0;34m(self, xs, ys, zs, zdir, s, c, depthshade, *args, **kwargs)\u001b[0m\n\u001b[1;32m 2310\u001b[0m \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mzs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcopy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2311\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2312\u001b[0;31m \u001b[0mpatches\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscatter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mxs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mys\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2313\u001b[0m art3d.patch_collection_2d_to_3d(patches, zs=zs, zdir=zdir,\n\u001b[1;32m 2314\u001b[0m depthshade=depthshade)\n", + "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/matplotlib/__init__.py\u001b[0m in \u001b[0;36minner\u001b[0;34m(ax, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1436\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0minner\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1437\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1438\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msanitize_sequence\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1439\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1440\u001b[0m \u001b[0mbound\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_sig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/matplotlib/cbook/deprecation.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*inner_args, **inner_kwargs)\u001b[0m\n\u001b[1;32m 409\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mdeprecation_addendum\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 410\u001b[0m **kwargs)\n\u001b[0;32m--> 411\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minner_args\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0minner_kwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 412\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 413\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/matplotlib/axes/_axes.py\u001b[0m in \u001b[0;36mscatter\u001b[0;34m(self, x, y, s, c, marker, cmap, norm, vmin, vmax, alpha, linewidths, verts, edgecolors, plotnonfinite, **kwargs)\u001b[0m\n\u001b[1;32m 4486\u001b[0m \u001b[0moffsets\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumn_stack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4487\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 4488\u001b[0;31m collection = mcoll.PathCollection(\n\u001b[0m\u001b[1;32m 4489\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mscales\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4490\u001b[0m \u001b[0mfacecolors\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcolors\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/matplotlib/collections.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, paths, sizes, **kwargs)\u001b[0m\n\u001b[1;32m 953\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 954\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_paths\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpaths\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 955\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_sizes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msizes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 956\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstale\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 957\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/matplotlib/collections.py\u001b[0m in \u001b[0;36mset_sizes\u001b[0;34m(self, sizes, dpi)\u001b[0m\n\u001b[1;32m 920\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_sizes\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msizes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 921\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_transforms\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_sizes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 922\u001b[0;31m \u001b[0mscale\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_sizes\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mdpi\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0;36m72.0\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_factor\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 923\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_transforms\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscale\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 924\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_transforms\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscale\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mTypeError\u001b[0m: loop of ufunc does not support argument 0 of type NoneType which has no callable sqrt method" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/christinayu/opt/anaconda3/lib/python3.8/site-packages/matplotlib/collections.py:922: RuntimeWarning: invalid value encountered in sqrt\n", + " scale = np.sqrt(self._sizes) * dpi / 72.0 * self._factor\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from mpl_toolkits.mplot3d import Axes3D\n", + "from sklearn.datasets.samples_generator import make_blobs\n", + "\n", + "X, y = make_blobs(n_samples=10000, n_features=3, centers=[[3,3, 3], [0,0,0], [1,1,1], [2,2,2]], cluster_std=[0.2, 0.1, 0.2, 0.2], \n", + " random_state =9)\n", + "fig = plt.figure()\n", + "ax = Axes3D(fig, rect=[0, 0, 1, 1], elev=30, azim=20)\n", + "plt.scatter(X[:, 0], X[:, 1], X[:, 2],marker='o')\n", + "\n", + "\n", + "from sklearn.decomposition import PCA\n", + "pca = PCA(n_components=3)\n", + "pca.fit(X)\n", + "print (pca.explained_variance_ratio_)\n", + "print (pca.explained_variance_)\n", + "\n", + "\n", + "pca = PCA(n_components=2)\n", + "pca.fit(X)\n", + "print (pca.explained_variance_ratio_)\n", + "print (pca.explained_variance_)\n", + "\n", + "X_new = pca.transform(X)\n", + "plt.scatter(X_new[:, 0], X_new[:, 1],marker='o')\n", + "plt.show()\n", + "\n", + "pca = PCA(n_components=0.95)\n", + "pca.fit(X)\n", + "print (pca.explained_variance_ratio_)\n", + "print (pca.explained_variance_)\n", + "print (pca.n_components_)\n", + "\n", + "pca = PCA(n_components='mle')\n", + "pca.fit(X)\n", + "print (pca.explained_variance_ratio_)\n", + "print (pca.explained_variance_)\n", + "print (pca.n_components_)" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "c2a0d16ab2ef21d9ffd61da4743bf5eccc7864478b6988e54f4be7517ca730a8" + }, + "kernelspec": { + "display_name": "Python 3.8.5 ('base')", + "language": "python", + "name": "python3" + }, + "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.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From e7c8864129d3fec94bb541f4331b86e6907561f9 Mon Sep 17 00:00:00 2001 From: Christina Yu Date: Fri, 15 Jul 2022 13:43:19 +0800 Subject: [PATCH 2/5] Update 5 ML regression codes --- Model_development.ipynb | 838 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 838 insertions(+) create mode 100644 Model_development.ipynb diff --git a/Model_development.ipynb b/Model_development.ipynb new file mode 100644 index 0000000..a91e206 --- /dev/null +++ b/Model_development.ipynb @@ -0,0 +1,838 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Model Development \n", + "\n", + "This file is composed of components of the module development process for preliminary exploration of your data. This code is not a complete module development, but rather a preliminary examination of data. Please see the Table of Contents to explore different areas of MD.\n", + "***\n", + "\n", + "##### **Input:** .csv file with entire dataset. Will need to interpolate prior to using unsupervised learning if NaN exist in your dataset\n", + "##### **Output:** Figures for EDA\n", + "##### **Dependencies:** \n", + "***\n", + "\n", + "##### Format of input: \n", + ".csv file with entire dataset \n", + "***\n", + "\n", + "**Check:** \n", + "* Will need to interpolate data/remove NaN before doing any unsupervised learning for EDA\n", + "\n", + "**Sources:**\n", + "\n", + "***\n", + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Table of Contents\n", + "\n", + "#### ML classification\n", + "* SVM\n", + "* Random Forest\n", + "* XGBoost\n", + "\n", + "#### Plot Visualization\n", + "* ROC-plot\n", + "* LOSO-CV\n", + "\n", + "#### Unsupervised Learning\n", + "* [Clustering](#cluster)\n", + " * [KNN Clustering](#knn)\n", + " * [Hierarchical Clustering](#hic)\n", + "* [Principal Component Analysis (PCA)](#pca)\n", + "\n", + "\n", + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Read data:\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'filename' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mpandas\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mnumpy\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread_csv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilename\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m#Change filename\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mNameError\u001b[0m: name 'filename' is not defined" + ] + } + ], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "data = pd.read_csv(filename) #Change filename" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Preliminary Exploratory Data Analysis:\n", + "\n", + "https://github.com/dformoso/sklearn-classification/blob/master/Data%20Science%20Workbook%20-%20Census%20Income%20Dataset.ipynb" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "238595" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(data)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "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", + " \n", + " \n", + " \n", + "
ECGApple WatchEmpaticaGarminFitbitMibandBiovotionSkin Tone
count221475.00000012791.000000138252.00000036625.00000010861.00000020632.000000160841.000000238595.000000
mean90.54972689.57923588.96212184.41821284.25338486.71379486.9385793.638509
std20.56801817.02151815.87316615.43022616.89886714.53644016.9823741.669205
min24.17400036.00000048.20000039.00000046.00000045.00000045.0000001.000000
25%76.35500078.00000077.63000073.00000070.00000074.00000075.0000002.000000
50%89.29100089.00000087.43000084.00000081.00000087.00000086.0000004.000000
75%101.030000100.00000099.12000096.00000095.00000098.00000098.0000005.000000
max240.000000155.000000178.740000134.000000180.000000128.000000168.0000006.000000
\n", + "
" + ], + "text/plain": [ + " ECG Apple Watch Empatica Garmin Fitbit \\\n", + "count 221475.000000 12791.000000 138252.000000 36625.000000 10861.000000 \n", + "mean 90.549726 89.579235 88.962121 84.418212 84.253384 \n", + "std 20.568018 17.021518 15.873166 15.430226 16.898867 \n", + "min 24.174000 36.000000 48.200000 39.000000 46.000000 \n", + "25% 76.355000 78.000000 77.630000 73.000000 70.000000 \n", + "50% 89.291000 89.000000 87.430000 84.000000 81.000000 \n", + "75% 101.030000 100.000000 99.120000 96.000000 95.000000 \n", + "max 240.000000 155.000000 178.740000 134.000000 180.000000 \n", + "\n", + " Miband Biovotion Skin Tone \n", + "count 20632.000000 160841.000000 238595.000000 \n", + "mean 86.713794 86.938579 3.638509 \n", + "std 14.536440 16.982374 1.669205 \n", + "min 45.000000 45.000000 1.000000 \n", + "25% 74.000000 75.000000 2.000000 \n", + "50% 87.000000 86.000000 4.000000 \n", + "75% 98.000000 98.000000 5.000000 \n", + "max 128.000000 168.000000 6.000000 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.describe()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Correlation Plots\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "corr = data.corr()\n", + "sns.heatmap(corr, \n", + " xticklabels=corr.columns,\n", + " yticklabels=corr.columns)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Unsupervised Learning Section- " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Clustering\n", + "\n", + "\n", + "https://www.neuroelectrics.com/blog/clustering-methods-in-exploratory-analysis/" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dfc = data.drop(columns=[]) # drop all non-numeric columns\n", + "dfc.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### KNN Clustering:\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.cluster import KMeans\n", + "# create kmeans object\n", + "kmeans = KMeans(n_clusters=3)# fit kmeans object to data\n", + "kmeans.fit(dfc)# print location of clusters learned by kmeans object\n", + "#print(kmeans.cluster_centers_)# save new clusters for chart\n", + "y_km = kmeans.fit_predict(dfc)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "labels = kmeans.labels_\n", + "dfc['clusters'] = labels" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Hierarchical Clustering\n", + "\n", + "\n", + "*Agglomerative (data points are clustered using a bottim-up approach starting with individual data points)\n", + "\n", + "\n", + "https://stackabuse.com/hierarchical-clustering-with-python-and-scikit-learn/" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import scipy.cluster.hierarchy as shc\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.figure(figsize=(10, 7))\n", + "plt.title(\"Data Dendograms\")\n", + "dend = shc.dendrogram(shc.linkage(dfc, method='ward'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.cluster import AgglomerativeClustering\n", + "from scipy.cluster.hierarchy import dendrogram, linkage\n", + "\n", + "cluster = AgglomerativeClustering(n_clusters=3, affinity='euclidean', linkage='ward')\n", + "cluster.fit_predict(dfc)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(cluster.labels_)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## PCA (Prinicipal Component Analysis)\n", + "\n", + "https://cmdlinetips.com/2018/03/pca-example-in-python-with-scikit-learn/\n", + "\n", + "https://scikit-learn.org/stable/tutorial/statistical_inference/unsupervised_learning.html\n", + "\n", + "PCA selects the successive components that explain the maximum variance in the signal.\n", + "This is useful to us because we have a large amount of features. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Need to scale prior to doing PCA\n", + "\n", + "from sklearn.preprocessing import StandardScaler\n", + "sc = StandardScaler()\n", + "sdfc = sc.fit_transform(dfc)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "from sklearn import decomposition\n", + "pca = decomposition.PCA()\n", + "pca.fit(sdfc)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "print(pca.explained_variance_ratio_)\n", + "print(pca.singular_values_) " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pca.n_components = 9\n", + "pc = pca.fit(dfc)\n", + "\n", + "result=pd.DataFrame(pca.transform(dfc), columns=['PCA%i' % i for i in range(9)], index=dfc.index)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pcft = pca.fit_transform(dfc)\n", + "\n", + "pc_df = pd.DataFrame(data=pcft, columns= ['PC1', 'PC2', 'PC3', 'PC4', 'PC5', 'PC6', 'PC7', 'PC8', 'PC9'])\n", + "\n", + "#Example below:\n", + "#pc_df['Cluster'] = data['Definition']\n", + "#pc_df['Status'] = data['Status']\n", + "#pc_df['Gender'] = data['Gender']\n", + "pc_df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "\n", + "import seaborn as sns\n", + "dfvar = pd.DataFrame({'var':pca.explained_variance_ratio_,\n", + " 'PC':['PC1','PC2','PC3','PC4', 'PC5', 'PC6', 'PC7', 'PC8', 'PC9']})\n", + "sns.barplot(x='PC',y=\"var\", \n", + " data=dfvar, color=\"c\");\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Install matplotlib widget Ipython magic: https://github.com/matplotlib/jupyter-matplotlib\n", + "\n", + "Problems with matplotlib widget not working: https://github.com/matplotlib/jupyter-matplotlib/issues/66" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "from mpl_toolkits.mplot3d import axes3d, Axes3D #<-- Note the capitalization! \n", + "\n", + "\n", + "pc_df[insertvarhere]=pd.Categorical(pc_df[insertvarhere]) #need to change insertvarhere\n", + "my_color=pc_df[insertvarhere].cat.codes #need to change insertvarhere\n", + "\n", + "# Plot initialisation\n", + "fig = plt.figure()\n", + "ax = Axes3D(fig) \n", + "ax.scatter(result['PCA0'], result['PCA1'], result['PCA2'], c=my_color, cmap='Accent', s=60)\n", + "\n", + "#make simple, bare axis lines through space:\n", + "xAxisLine = ((min(result['PCA0']), max(result['PCA0'])), (0, 0), (0,0))\n", + "ax.plot(xAxisLine[0], xAxisLine[1], xAxisLine[2], 'r')\n", + "yAxisLine = ((0, 0), (min(result['PCA1']), max(result['PCA1'])), (0,0))\n", + "ax.plot(yAxisLine[0], yAxisLine[1], yAxisLine[2], 'r')\n", + "zAxisLine = ((0, 0), (0,0), (min(result['PCA2']), max(result['PCA2'])))\n", + "ax.plot(zAxisLine[0], zAxisLine[1], zAxisLine[2], 'r')\n", + " \n", + "# label the axes\n", + "ax.set_xlabel(\"PC1\")\n", + "ax.set_ylabel(\"PC2\")\n", + "ax.set_zlabel(\"PC3\")\n", + "ax.set_title(\"PCA\")\n", + "#ax.legend()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sns.lmplot( x=\"PC1\", y=\"PC5\",\n", + " data=pc_df, \n", + " fit_reg=False, \n", + " hue=Variable, # color by change variable here\n", + " legend=True,\n", + " scatter_kws={\"s\": 80,'alpha':0.3}) # specify the point size" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/christinayu/opt/anaconda3/lib/python3.8/site-packages/sklearn/utils/deprecation.py:143: FutureWarning: The sklearn.datasets.samples_generator module is deprecated in version 0.22 and will be removed in version 0.24. The corresponding classes / functions should instead be imported from sklearn.datasets. Anything that cannot be imported from sklearn.datasets is now part of the private API.\n", + " warnings.warn(message, FutureWarning)\n", + "/Users/christinayu/opt/anaconda3/lib/python3.8/site-packages/matplotlib/collections.py:922: RuntimeWarning: invalid value encountered in sqrt\n", + " scale = np.sqrt(self._sizes) * dpi / 72.0 * self._factor\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.98318212 0.00850037 0.00831751]\n", + "[3.78521638 0.03272613 0.03202212]\n", + "[0.98318212 0.00850037]\n", + "[3.78521638 0.03272613]\n" + ] + }, + { + "ename": "TypeError", + "evalue": "loop of ufunc does not support argument 0 of type NoneType which has no callable sqrt method", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;31mAttributeError\u001b[0m: 'NoneType' object has no attribute 'sqrt'", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 24\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 25\u001b[0m \u001b[0mX_new\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpca\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 26\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscatter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_new\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX_new\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmarker\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'o'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 27\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 28\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/matplotlib/pyplot.py\u001b[0m in \u001b[0;36mscatter\u001b[0;34m(x, y, s, c, marker, cmap, norm, vmin, vmax, alpha, linewidths, verts, edgecolors, plotnonfinite, data, **kwargs)\u001b[0m\n\u001b[1;32m 2888\u001b[0m \u001b[0mverts\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcbook\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdeprecation\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_deprecated_parameter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2889\u001b[0m edgecolors=None, *, plotnonfinite=False, data=None, **kwargs):\n\u001b[0;32m-> 2890\u001b[0;31m __ret = gca().scatter(\n\u001b[0m\u001b[1;32m 2891\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmarker\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmarker\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcmap\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcmap\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnorm\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2892\u001b[0m \u001b[0mvmin\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mvmin\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvmax\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mvmax\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0malpha\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0malpha\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlinewidths\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlinewidths\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/mpl_toolkits/mplot3d/axes3d.py\u001b[0m in \u001b[0;36mscatter\u001b[0;34m(self, xs, ys, zs, zdir, s, c, depthshade, *args, **kwargs)\u001b[0m\n\u001b[1;32m 2310\u001b[0m \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mzs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcopy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2311\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2312\u001b[0;31m \u001b[0mpatches\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscatter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mxs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mys\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2313\u001b[0m art3d.patch_collection_2d_to_3d(patches, zs=zs, zdir=zdir,\n\u001b[1;32m 2314\u001b[0m depthshade=depthshade)\n", + "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/matplotlib/__init__.py\u001b[0m in \u001b[0;36minner\u001b[0;34m(ax, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1436\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0minner\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1437\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1438\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msanitize_sequence\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1439\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1440\u001b[0m \u001b[0mbound\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_sig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/matplotlib/cbook/deprecation.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*inner_args, **inner_kwargs)\u001b[0m\n\u001b[1;32m 409\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mdeprecation_addendum\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 410\u001b[0m **kwargs)\n\u001b[0;32m--> 411\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minner_args\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0minner_kwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 412\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 413\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/matplotlib/axes/_axes.py\u001b[0m in \u001b[0;36mscatter\u001b[0;34m(self, x, y, s, c, marker, cmap, norm, vmin, vmax, alpha, linewidths, verts, edgecolors, plotnonfinite, **kwargs)\u001b[0m\n\u001b[1;32m 4486\u001b[0m \u001b[0moffsets\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumn_stack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4487\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 4488\u001b[0;31m collection = mcoll.PathCollection(\n\u001b[0m\u001b[1;32m 4489\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mscales\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4490\u001b[0m \u001b[0mfacecolors\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcolors\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/matplotlib/collections.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, paths, sizes, **kwargs)\u001b[0m\n\u001b[1;32m 953\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 954\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_paths\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpaths\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 955\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_sizes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msizes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 956\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstale\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 957\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/matplotlib/collections.py\u001b[0m in \u001b[0;36mset_sizes\u001b[0;34m(self, sizes, dpi)\u001b[0m\n\u001b[1;32m 920\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_sizes\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msizes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 921\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_transforms\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_sizes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 922\u001b[0;31m \u001b[0mscale\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_sizes\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mdpi\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0;36m72.0\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_factor\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 923\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_transforms\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscale\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 924\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_transforms\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscale\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mTypeError\u001b[0m: loop of ufunc does not support argument 0 of type NoneType which has no callable sqrt method" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/christinayu/opt/anaconda3/lib/python3.8/site-packages/matplotlib/collections.py:922: RuntimeWarning: invalid value encountered in sqrt\n", + " scale = np.sqrt(self._sizes) * dpi / 72.0 * self._factor\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from mpl_toolkits.mplot3d import Axes3D\n", + "from sklearn.datasets.samples_generator import make_blobs\n", + "\n", + "X, y = make_blobs(n_samples=10000, n_features=3, centers=[[3,3, 3], [0,0,0], [1,1,1], [2,2,2]], cluster_std=[0.2, 0.1, 0.2, 0.2], \n", + " random_state =9)\n", + "fig = plt.figure()\n", + "ax = Axes3D(fig, rect=[0, 0, 1, 1], elev=30, azim=20)\n", + "plt.scatter(X[:, 0], X[:, 1], X[:, 2],marker='o')\n", + "\n", + "\n", + "from sklearn.decomposition import PCA\n", + "pca = PCA(n_components=3)\n", + "pca.fit(X)\n", + "print (pca.explained_variance_ratio_)\n", + "print (pca.explained_variance_)\n", + "\n", + "\n", + "pca = PCA(n_components=2)\n", + "pca.fit(X)\n", + "print (pca.explained_variance_ratio_)\n", + "print (pca.explained_variance_)\n", + "\n", + "X_new = pca.transform(X)\n", + "plt.scatter(X_new[:, 0], X_new[:, 1],marker='o')\n", + "plt.show()\n", + "\n", + "pca = PCA(n_components=0.95)\n", + "pca.fit(X)\n", + "print (pca.explained_variance_ratio_)\n", + "print (pca.explained_variance_)\n", + "print (pca.n_components_)\n", + "\n", + "pca = PCA(n_components='mle')\n", + "pca.fit(X)\n", + "print (pca.explained_variance_ratio_)\n", + "print (pca.explained_variance_)\n", + "print (pca.n_components_)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Random Forest\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x=df.iloc[:,:-1]\n", + "y=df.iloc[:,-1:]\n", + "\n", + "\n", + "from sklearn.ensemble import RandomForestRegressor\n", + "\n", + "regressor = RandomForestRegressor(n_estimators = 100, random_state = 0)\n", + "# regression fit\n", + "regressor.fit(x,y)\n", + "\n", + "# predict the result\n", + "Y_pred = regressor.predict(np.array([6.5]).reshape(1,1))\n", + "\n", + "# Visualization\n", + "X_grid = np.arrange(min(x), max(x), 0.01)\n", + "X_grid = X_grid.reshape((len(X_grid),1))\n", + "plt.scatter(x,y,color = 'blue')\n", + "\n", + "ply.plot(X_grid, regressor.predict(X_grid), color = 'green')\n", + "plt.title('Random Forest Regression')\n", + "plt.xlabel('Wearable Devices')\n", + "plt.ylabel('Medical Stats')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## SVM\n", + "\n", + "Support Vector regression is a type of Support vector machine that supports linear and non-linear regression\n", + "see tutorial here: https://medium.com/pursuitnotes/support-vector-regression-in-6-steps-with-python-c4569acd062d\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Feature Scaling\n", + "from sklearn.preprocessing import StandardScaler\n", + "sc_X = StandardScaler()\n", + "sc_y = StandardScaler()\n", + "X = sc_X.fit_transform(X)\n", + "y = sc_y.fit_transform(y)\n", + "\n", + "# Fitting the Support Vector Regression Model to the data\n", + "from sklearn.svm import SVR\n", + "regressor = SVR(kernel='rbf')\n", + "regressor.fit(X,y)\n", + "#5 Predicting a new result\n", + "y_pred = regressor.predict(6.5)\n", + "\n", + "#6 Visualization\n", + "plt.scatter(X, y, color = 'red')\n", + "plt.plot(X, regressor.predict(X), color = 'green')\n", + "plt.title('Medical Data for SVM/SVR Model')\n", + "plt.xlabel('Wearable Devices')\n", + "plt.ylabel('Medical Stats')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## XGBoost\n", + "\n", + "The results of the regression problems are continuous or real values. Some commonly used regression algorithms are Linear Regression and Decision Tree" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import xgboost as xg\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import mean_squared_error as MSE\n", + "\n", + "X, y = dataset.iloc[:, :-1], dataset.iloc[:, -1]\n", + "\n", + "# Splitting\n", + "train_X, test_X, train_y, test_y = train_test_split(X, y, test_size = 0.3, random_state = 123)\n", + " \n", + "xgb_r = xg.XGBRegressor(objective ='reg:linear', n_estimators = 10, seed = 123)\n", + " \n", + "# Fit the model\n", + "xgb_r.fit(train_X, train_y)\n", + " \n", + "# Prediction\n", + "pred = xgb_r.predict(test_X)\n", + "\n", + "rmse = np.sqrt(MSE(test_y, pred))\n", + "print(\"RMSE : % f\" %(rmse))\n" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "c2a0d16ab2ef21d9ffd61da4743bf5eccc7864478b6988e54f4be7517ca730a8" + }, + "kernelspec": { + "display_name": "Python 3.8.5 ('base')", + "language": "python", + "name": "python3" + }, + "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.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From cf1e3eaf4c98d05da7ea79d600f70b03607dc80f Mon Sep 17 00:00:00 2001 From: Christina Yu Date: Fri, 15 Jul 2022 13:43:51 +0800 Subject: [PATCH 3/5] Delete ExploratoryDataAnalysis.ipynb --- ExploratoryDataAnalysis.ipynb | 1102 --------------------------------- 1 file changed, 1102 deletions(-) delete mode 100644 ExploratoryDataAnalysis.ipynb diff --git a/ExploratoryDataAnalysis.ipynb b/ExploratoryDataAnalysis.ipynb deleted file mode 100644 index 70ba995..0000000 --- a/ExploratoryDataAnalysis.ipynb +++ /dev/null @@ -1,1102 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exploratory Data Analysis \n", - "\n", - "This file is composed of components of the EDA process for preliminary exploration of your data. This code is not a complete EDA, but rather a preliminary examination of data. Please see the Table of Contents to explore different areas of EDA.\n", - "***\n", - "\n", - "##### **Input:** .csv file with entire dataset. Will need to interpolate prior to using unsupervised learning if NaN exist in your dataset\n", - "##### **Output:** Figures for EDA\n", - "##### **Dependencies:** \n", - "***\n", - "\n", - "##### Format of input: \n", - ".csv file with entire dataset \n", - "***\n", - "\n", - "**Check:** \n", - "* Will need to interpolate data/remove NaN before doing any unsupervised learning for EDA\n", - "\n", - "**Sources:**\n", - "\n", - "***\n", - "***" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Table of Contents\n", - "\n", - "#### Exploratory Data Analysis\n", - "* [Cleaning and Filtering Data](#read)\n", - "* [Correlation Plots](#corr)\n", - "* [Covariance Matrix](#cov)\n", - "* [Missing Data Analysis](#miss)\n", - "* [Outlier Analysis](#out)\n", - "* [Histograms of Features](#hist)\n", - "\n", - "#### Unsupervised Learning\n", - "* [Clustering](#cluster)\n", - " * [KNN Clustering](#knn)\n", - " * [Hierarchical Clustering](#hic)\n", - "* [Principal Component Analysis (PCA)](#pca)\n", - "\n", - "\n", - "***" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Read data:\n", - "" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'filename' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mpandas\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mnumpy\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread_csv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilename\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m#Change filename\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;31mNameError\u001b[0m: name 'filename' is not defined" - ] - } - ], - "source": [ - "import pandas as pd\n", - "import numpy as np\n", - "data = pd.read_csv(filename) #Change filename" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Preliminary Exploratory Data Analysis:\n", - "\n", - "https://github.com/dformoso/sklearn-classification/blob/master/Data%20Science%20Workbook%20-%20Census%20Income%20Dataset.ipynb" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "238595" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(data)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "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", - " \n", - " \n", - " \n", - "
ECGApple WatchEmpaticaGarminFitbitMibandBiovotionSkin Tone
count221475.00000012791.000000138252.00000036625.00000010861.00000020632.000000160841.000000238595.000000
mean90.54972689.57923588.96212184.41821284.25338486.71379486.9385793.638509
std20.56801817.02151815.87316615.43022616.89886714.53644016.9823741.669205
min24.17400036.00000048.20000039.00000046.00000045.00000045.0000001.000000
25%76.35500078.00000077.63000073.00000070.00000074.00000075.0000002.000000
50%89.29100089.00000087.43000084.00000081.00000087.00000086.0000004.000000
75%101.030000100.00000099.12000096.00000095.00000098.00000098.0000005.000000
max240.000000155.000000178.740000134.000000180.000000128.000000168.0000006.000000
\n", - "
" - ], - "text/plain": [ - " ECG Apple Watch Empatica Garmin Fitbit \\\n", - "count 221475.000000 12791.000000 138252.000000 36625.000000 10861.000000 \n", - "mean 90.549726 89.579235 88.962121 84.418212 84.253384 \n", - "std 20.568018 17.021518 15.873166 15.430226 16.898867 \n", - "min 24.174000 36.000000 48.200000 39.000000 46.000000 \n", - "25% 76.355000 78.000000 77.630000 73.000000 70.000000 \n", - "50% 89.291000 89.000000 87.430000 84.000000 81.000000 \n", - "75% 101.030000 100.000000 99.120000 96.000000 95.000000 \n", - "max 240.000000 155.000000 178.740000 134.000000 180.000000 \n", - "\n", - " Miband Biovotion Skin Tone \n", - "count 20632.000000 160841.000000 238595.000000 \n", - "mean 86.713794 86.938579 3.638509 \n", - "std 14.536440 16.982374 1.669205 \n", - "min 45.000000 45.000000 1.000000 \n", - "25% 74.000000 75.000000 2.000000 \n", - "50% 87.000000 86.000000 4.000000 \n", - "75% 98.000000 98.000000 5.000000 \n", - "max 128.000000 168.000000 6.000000 " - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "data.describe()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Correlation Plots\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "import seaborn as sns\n", - "corr = data.corr()\n", - "sns.heatmap(corr, \n", - " xticklabels=corr.columns,\n", - " yticklabels=corr.columns)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "#Correlation Plot\n", - "corr = data.corr()\n", - "sns.heatmap(corr, \n", - " xticklabels=corr.columns,\n", - " yticklabels=corr.columns)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Covariance Matrix\n", - "\n", - "\n", - "Compute pairwise covariance of columns\n", - "\n", - "Covariance is a measure of how much two random variables vary together. It’s similar to variance, but where variance tells you how a single variable varies, co variance tells you how two variables vary together.\n", - "*Covariance must be scaled.*\n", - "\n", - "- Python: https://www.geeksforgeeks.org/python-pandas-dataframe-cov/\n", - "- Math/Interpretation: https://www.statisticshowto.datasciencecentral.com/covariance/" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'data' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m#Need to standardize scale:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mcv_df\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdrop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m#drop all columns that are non-numeric\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0msklearn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpreprocessing\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mStandardScaler\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0msc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mStandardScaler\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mcv_np\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcv_df\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mNameError\u001b[0m: name 'data' is not defined" - ] - } - ], - "source": [ - "#Need to standardize scale:\n", - "cv_df = data.drop(columns=[]) #drop all columns that are non-numeric\n", - "from sklearn.preprocessing import StandardScaler\n", - "sc = StandardScaler()\n", - "cv_np = sc.fit_transform(cv_df)\n", - "cv_df = pd.DataFrame(cv_np)\n", - "#cv_df.columns = [] #name columns if desired\n", - "\n", - "#covariance \n", - "cv_df.cov()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Check for missing values\n", - "\n", - "#### Very cool package for missing values (includes heatmaps of missing, bar graphs, and matrices of missing values):\n", - "https://github.com/ResidentMario/missingno" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "ename": "ModuleNotFoundError", - "evalue": "No module named 'missingno'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", - "Input \u001b[0;32mIn [13]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mmissingno\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mmsno\u001b[39;00m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;66;03m#Check for missing data\u001b[39;00m\n\u001b[1;32m 4\u001b[0m msno\u001b[38;5;241m.\u001b[39mmatrix(data)\n", - "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'missingno'" - ] - } - ], - "source": [ - "import missingno as msno\n", - "\n", - "#Check for missing data\n", - "msno.matrix(data)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Plot Distribution of Each Feature\n", - "" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Outcome variable \n", - "\n", - "To look at how the outcome variable is balanced:" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'outcomevariablehere' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "Input \u001b[0;32mIn [12]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m plt\u001b[38;5;241m.\u001b[39mstyle\u001b[38;5;241m.\u001b[39muse(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mseaborn-whitegrid\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 2\u001b[0m fig \u001b[38;5;241m=\u001b[39m plt\u001b[38;5;241m.\u001b[39mfigure(figsize\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m20\u001b[39m,\u001b[38;5;241m1\u001b[39m)) \n\u001b[0;32m----> 3\u001b[0m sns\u001b[38;5;241m.\u001b[39mcountplot(y\u001b[38;5;241m=\u001b[39m\u001b[43moutcomevariablehere\u001b[49m, data\u001b[38;5;241m=\u001b[39mdata)\n", - "\u001b[0;31mNameError\u001b[0m: name 'outcomevariablehere' is not defined" - ] - }, - { - "data": { - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.style.use('seaborn-whitegrid')\n", - "fig = plt.figure(figsize=(20,1)) \n", - "sns.countplot(y=outcomevariablehere, data=data); #put outcomevariable here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Plot distributions by outcome class \n", - "" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'outcome_a' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "Input \u001b[0;32mIn [10]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mseaborn\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01msns\u001b[39;00m\n\u001b[1;32m 4\u001b[0m \u001b[38;5;66;03m# Sort dataframe by outcome\u001b[39;00m\n\u001b[1;32m 5\u001b[0m \n\u001b[1;32m 6\u001b[0m \u001b[38;5;66;03m#Plot outcome variables\u001b[39;00m\n\u001b[0;32m----> 7\u001b[0m sns\u001b[38;5;241m.\u001b[39mdistplot(\u001b[43moutcome_a\u001b[49m[[X1]], hist\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m, rug\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m 8\u001b[0m sns\u001b[38;5;241m.\u001b[39mdistplot(outcome_b[[X1]], hist\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m, rug\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m 9\u001b[0m sns\u001b[38;5;241m.\u001b[39mdistplot(outcome_c[[X1]], hist\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m, rug\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n", - "\u001b[0;31mNameError\u001b[0m: name 'outcome_a' is not defined" - ] - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "import seaborn as sns\n", - "\n", - "# Sort dataframe by outcome\n", - "\n", - "#Plot outcome variables\n", - "sns.distplot(outcome_a[[X1]], hist=False, rug=True)\n", - "sns.distplot(outcome_b[[X1]], hist=False, rug=True)\n", - "sns.distplot(outcome_c[[X1]], hist=False, rug=True)\n", - "\n", - "plt.title()\n", - "plt.xlabel()\n", - "plt.legend(labels=[])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Plot all variables at once:" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Outlier Analysis\n", - "" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "sns.boxplot(y=variablehere, x=variablehere, data=data, palette=\"Set1\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Plot histograms of all variables in data" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": {}, - "outputs": [], - "source": [ - "def makehist(datainput, label, color):\n", - " fig = plt.figure(figsize=(16,4))\n", - " mean = datainput.mean(axis = 0) #changeoutcomevar\n", - " plt.hist(datainput, bins=(20), align='mid', color=color, alpha=0.5)\n", - " plt.axvline(x=mean, color=color, linestyle='-')\n", - " plt.xlabel(label)\n", - " plt.ylabel('Frequency')\n", - " plt.title((label + ' Histogram'))\n", - " plt.tight_layout()\n", - " plt.savefig((filesource + label + '.png'), dpi=100) #change filesource or add as input to function if variable\n", - " print(('Saved plot of ' + label))" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Saved plot of Mean\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "makehist(data['Variable'], 'Variable', 'green')\n", - "#Repeat above command for each numeric Variable in data" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Plot boxplot of all variables in data" - ] - }, - { - "cell_type": "code", - "execution_count": 117, - "metadata": {}, - "outputs": [], - "source": [ - "def makeboxplot(datainput, label):\n", - " fig = plt.figure(figsize =(16, 4))\n", - " plt.boxplot(datainput)\n", - " plt.title((label + ' Box Plot'))\n", - " plt.savefig((filesource + label + '.png'), dpi=100) #change filesource or add as input to function if variable\n", - " print(('Saved plot of ' + label))" - ] - }, - { - "cell_type": "code", - "execution_count": 118, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Saved plot of Mean\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "makeboxplot(data['Variable'], 'Variable')\n", - "#Repeat above command for each numeric Variable in data" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Plot leafplot of all variables in data" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "def makeleafplot(datainput, label):\n", - " fig = plt.figure(figsize =(16, 4))\n", - " plt.stem(datainput)\n", - " plt.title((label + ' Leaf Plot'))\n", - " plt.savefig((filesource + label + '.png'), dpi=100) #change filesource or add as input to function if variable\n", - " print(('Saved plot of ' + label))" - ] - }, - { - "cell_type": "code", - "execution_count": 116, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "makeleafplot(data['Variable'], 'Variable')\n", - "#Repeat above command for each numeric Variable in data" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Unsupervised Learning Section- " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Clustering\n", - "\n", - "\n", - "https://www.neuroelectrics.com/blog/clustering-methods-in-exploratory-analysis/" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "dfc = data.drop(columns=[]) # drop all non-numeric columns\n", - "dfc.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### KNN Clustering:\n", - "" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from sklearn.cluster import KMeans\n", - "# create kmeans object\n", - "kmeans = KMeans(n_clusters=3)# fit kmeans object to data\n", - "kmeans.fit(dfc)# print location of clusters learned by kmeans object\n", - "#print(kmeans.cluster_centers_)# save new clusters for chart\n", - "y_km = kmeans.fit_predict(dfc)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "labels = kmeans.labels_\n", - "dfc['clusters'] = labels" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Hierarchical Clustering\n", - "\n", - "\n", - "*Agglomerative (data points are clustered using a bottim-up approach starting with individual data points)\n", - "\n", - "\n", - "https://stackabuse.com/hierarchical-clustering-with-python-and-scikit-learn/" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import scipy.cluster.hierarchy as shc\n", - "import matplotlib.pyplot as plt\n", - "\n", - "plt.figure(figsize=(10, 7))\n", - "plt.title(\"Data Dendograms\")\n", - "dend = shc.dendrogram(shc.linkage(dfc, method='ward'))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from sklearn.cluster import AgglomerativeClustering\n", - "from scipy.cluster.hierarchy import dendrogram, linkage\n", - "\n", - "cluster = AgglomerativeClustering(n_clusters=3, affinity='euclidean', linkage='ward')\n", - "cluster.fit_predict(dfc)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "print(cluster.labels_)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## PCA (Prinicipal Component Analysis)\n", - "\n", - "https://cmdlinetips.com/2018/03/pca-example-in-python-with-scikit-learn/\n", - "\n", - "https://scikit-learn.org/stable/tutorial/statistical_inference/unsupervised_learning.html\n", - "\n", - "PCA selects the successive components that explain the maximum variance in the signal.\n", - "This is useful to us because we have a large amount of features. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Need to scale prior to doing PCA\n", - "\n", - "from sklearn.preprocessing import StandardScaler\n", - "sc = StandardScaler()\n", - "sdfc = sc.fit_transform(dfc)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "from sklearn import decomposition\n", - "pca = decomposition.PCA()\n", - "pca.fit(sdfc)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "print(pca.explained_variance_ratio_)\n", - "print(pca.singular_values_) " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "pca.n_components = 9\n", - "pc = pca.fit(dfc)\n", - "\n", - "result=pd.DataFrame(pca.transform(dfc), columns=['PCA%i' % i for i in range(9)], index=dfc.index)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "pcft = pca.fit_transform(dfc)\n", - "\n", - "pc_df = pd.DataFrame(data=pcft, columns= ['PC1', 'PC2', 'PC3', 'PC4', 'PC5', 'PC6', 'PC7', 'PC8', 'PC9'])\n", - "\n", - "#Example below:\n", - "#pc_df['Cluster'] = data['Definition']\n", - "#pc_df['Status'] = data['Status']\n", - "#pc_df['Gender'] = data['Gender']\n", - "pc_df.head()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib inline\n", - "\n", - "import seaborn as sns\n", - "dfvar = pd.DataFrame({'var':pca.explained_variance_ratio_,\n", - " 'PC':['PC1','PC2','PC3','PC4', 'PC5', 'PC6', 'PC7', 'PC8', 'PC9']})\n", - "sns.barplot(x='PC',y=\"var\", \n", - " data=dfvar, color=\"c\");\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Install matplotlib widget Ipython magic: https://github.com/matplotlib/jupyter-matplotlib\n", - "\n", - "Problems with matplotlib widget not working: https://github.com/matplotlib/jupyter-matplotlib/issues/66" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib widget \n", - "\n", - "import matplotlib.pyplot as plt\n", - "from mpl_toolkits.mplot3d import axes3d, Axes3D #<-- Note the capitalization! \n", - "\n", - "\n", - "pc_df[insertvarhere]=pd.Categorical(pc_df[insertvarhere]) #need to change insertvarhere\n", - "my_color=pc_df[insertvarhere].cat.codes #need to change insertvarhere\n", - "\n", - "# Plot initialisation\n", - "fig = plt.figure()\n", - "ax = Axes3D(fig) \n", - "ax.scatter(result['PCA0'], result['PCA1'], result['PCA2'], c=my_color, cmap='Accent', s=60)\n", - "\n", - "#make simple, bare axis lines through space:\n", - "xAxisLine = ((min(result['PCA0']), max(result['PCA0'])), (0, 0), (0,0))\n", - "ax.plot(xAxisLine[0], xAxisLine[1], xAxisLine[2], 'r')\n", - "yAxisLine = ((0, 0), (min(result['PCA1']), max(result['PCA1'])), (0,0))\n", - "ax.plot(yAxisLine[0], yAxisLine[1], yAxisLine[2], 'r')\n", - "zAxisLine = ((0, 0), (0,0), (min(result['PCA2']), max(result['PCA2'])))\n", - "ax.plot(zAxisLine[0], zAxisLine[1], zAxisLine[2], 'r')\n", - " \n", - "# label the axes\n", - "ax.set_xlabel(\"PC1\")\n", - "ax.set_ylabel(\"PC2\")\n", - "ax.set_zlabel(\"PC3\")\n", - "ax.set_title(\"PCA\")\n", - "#ax.legend()\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "sns.lmplot( x=\"PC1\", y=\"PC5\",\n", - " data=pc_df, \n", - " fit_reg=False, \n", - " hue=Variable, # color by change variable here\n", - " legend=True,\n", - " scatter_kws={\"s\": 80,'alpha':0.3}) # specify the point size" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/christinayu/opt/anaconda3/lib/python3.8/site-packages/sklearn/utils/deprecation.py:143: FutureWarning: The sklearn.datasets.samples_generator module is deprecated in version 0.22 and will be removed in version 0.24. The corresponding classes / functions should instead be imported from sklearn.datasets. Anything that cannot be imported from sklearn.datasets is now part of the private API.\n", - " warnings.warn(message, FutureWarning)\n", - "/Users/christinayu/opt/anaconda3/lib/python3.8/site-packages/matplotlib/collections.py:922: RuntimeWarning: invalid value encountered in sqrt\n", - " scale = np.sqrt(self._sizes) * dpi / 72.0 * self._factor\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[0.98318212 0.00850037 0.00831751]\n", - "[3.78521638 0.03272613 0.03202212]\n", - "[0.98318212 0.00850037]\n", - "[3.78521638 0.03272613]\n" - ] - }, - { - "ename": "TypeError", - "evalue": "loop of ufunc does not support argument 0 of type NoneType which has no callable sqrt method", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;31mAttributeError\u001b[0m: 'NoneType' object has no attribute 'sqrt'", - "\nThe above exception was the direct cause of the following exception:\n", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 24\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 25\u001b[0m \u001b[0mX_new\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpca\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 26\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscatter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_new\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX_new\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmarker\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'o'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 27\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 28\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/matplotlib/pyplot.py\u001b[0m in \u001b[0;36mscatter\u001b[0;34m(x, y, s, c, marker, cmap, norm, vmin, vmax, alpha, linewidths, verts, edgecolors, plotnonfinite, data, **kwargs)\u001b[0m\n\u001b[1;32m 2888\u001b[0m \u001b[0mverts\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcbook\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdeprecation\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_deprecated_parameter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2889\u001b[0m edgecolors=None, *, plotnonfinite=False, data=None, **kwargs):\n\u001b[0;32m-> 2890\u001b[0;31m __ret = gca().scatter(\n\u001b[0m\u001b[1;32m 2891\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmarker\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmarker\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcmap\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcmap\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnorm\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnorm\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2892\u001b[0m \u001b[0mvmin\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mvmin\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvmax\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mvmax\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0malpha\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0malpha\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlinewidths\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlinewidths\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/mpl_toolkits/mplot3d/axes3d.py\u001b[0m in \u001b[0;36mscatter\u001b[0;34m(self, xs, ys, zs, zdir, s, c, depthshade, *args, **kwargs)\u001b[0m\n\u001b[1;32m 2310\u001b[0m \u001b[0mzs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mzs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcopy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2311\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2312\u001b[0;31m \u001b[0mpatches\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscatter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mxs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mys\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2313\u001b[0m art3d.patch_collection_2d_to_3d(patches, zs=zs, zdir=zdir,\n\u001b[1;32m 2314\u001b[0m depthshade=depthshade)\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/matplotlib/__init__.py\u001b[0m in \u001b[0;36minner\u001b[0;34m(ax, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1436\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0minner\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1437\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1438\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msanitize_sequence\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1439\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1440\u001b[0m \u001b[0mbound\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_sig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/matplotlib/cbook/deprecation.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*inner_args, **inner_kwargs)\u001b[0m\n\u001b[1;32m 409\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mdeprecation_addendum\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 410\u001b[0m **kwargs)\n\u001b[0;32m--> 411\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minner_args\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0minner_kwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 412\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 413\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/matplotlib/axes/_axes.py\u001b[0m in \u001b[0;36mscatter\u001b[0;34m(self, x, y, s, c, marker, cmap, norm, vmin, vmax, alpha, linewidths, verts, edgecolors, plotnonfinite, **kwargs)\u001b[0m\n\u001b[1;32m 4486\u001b[0m \u001b[0moffsets\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumn_stack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4487\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 4488\u001b[0;31m collection = mcoll.PathCollection(\n\u001b[0m\u001b[1;32m 4489\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mscales\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4490\u001b[0m \u001b[0mfacecolors\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcolors\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/matplotlib/collections.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, paths, sizes, **kwargs)\u001b[0m\n\u001b[1;32m 953\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 954\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_paths\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpaths\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 955\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_sizes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msizes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 956\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstale\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 957\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.8/site-packages/matplotlib/collections.py\u001b[0m in \u001b[0;36mset_sizes\u001b[0;34m(self, sizes, dpi)\u001b[0m\n\u001b[1;32m 920\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_sizes\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msizes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 921\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_transforms\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_sizes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 922\u001b[0;31m \u001b[0mscale\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_sizes\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mdpi\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0;36m72.0\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_factor\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 923\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_transforms\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscale\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 924\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_transforms\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscale\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mTypeError\u001b[0m: loop of ufunc does not support argument 0 of type NoneType which has no callable sqrt method" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/christinayu/opt/anaconda3/lib/python3.8/site-packages/matplotlib/collections.py:922: RuntimeWarning: invalid value encountered in sqrt\n", - " scale = np.sqrt(self._sizes) * dpi / 72.0 * self._factor\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAATYAAAEuCAYAAAAEOT5fAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAACGIElEQVR4nO29d3wj9Z3//xpVS5bk3tb2uu16m3ft9RaWGu5gIZQACSkk5CBHcikXElK+SUhIbws5QsjvyKVdErg0EtIgsCFAYEPd4m2sy7p3y5at3svM/P4wn9mRNDMaybIle+f5eOyDxGojaealz+ddXm+KZVkoKCgorCVUuT4ABQUFhWyjCJuCgsKaQxE2BQWFNYcibAoKCmsORdgUFBTWHIqwKSgorDk0WXgOpV5EQUEhV1BCf1RWbAoKCmsORdgUFBTWHIqwKSgorDkUYVNQUFhzKMKmoKCw5lCETUFBYc2hCJuCgsKaQxE2BQWFNYcibAoKCmsORdgUFBTWHIqwKSgorDkUYVNQUFhzKMKmoKCw5lCETUFBYc2hCJuCgsKaQxE2BQWFNYcibAoKCmsORdgUFBTWHIqwKSgorDkUYVNQUFhzKMKmoKCw5lCETUFBYc2hCJuCgsKaQxG2VQrLsmBZZaSrgoIQ2RiYrLDCRCIRRCIRqNVqUBQFlUoV91/yT0HhfEURtlVGNBqF3++HTqfjxIum6aT7KYKncD6jCNsqIhwOY35+HmazmRMrAEliRbaoDMMkbVeJuKlUqjjBE3oeBYXViiJsqwSapuF0OjE+Po4dO3ZI3pcvUPz/TUSOZVnEYrGkxyiCp7BWUIRtFcAwDPx+v6BIpYOY4JHnI4JntVoBADU1NQCQJHbKtlYh31GELc9hWRZ+vx8Mw0Cj0YBhmGV5Hf7qjGxhVSpVnOAJPUaJ4ynkI4qw5TFE1GiahlqtFoyZLQdE3Mj/5v+Xf2xAenE8RfAUVgpF2PIUlmURCAQQjUahVqsBLArGStWupXodJY6nkM8owpaHsCyLYDDIiRq56FUq1bJtRfksRWSWKnhKHE8hGyjCloeEw2GEw+E4UQNWbsW2HK8jN3GRCMMwiEajKCwsVLa1CrJRhC3PcLvd8Pv9MJlMSRfvSl3MK7nlJa/H/y+BrFxHRkawffv2pMcoiQsFMRRhyyMikQjm5uYQDodhNptzdhwrLWxSx0H+q1Kda2tWCpAVUqEIW54QjUYRCASgVqvzQlTymWzE8aQ6NxRWP4qw5QE0TSMQCICiKK6sIxXLKX75smJLl0zjeMq2du2hCFuOYRgGPp8PALiLKteikg/HkG1S1eMpRgJrC0XYcggRNZZluVq1lSrpkOJ8unDTLUD2eDygKApFRUVKHC+PUYQtR5ACXJqmodGc+xryZbWUD8eQS8S2tS6XCxqNBhaLRSlAzmMUYcsBRNRisRi3UiPIXbEpMbbckShaBKk4nmIksLIowrbCsCwLl8sFlmWh0WgEa9VSiUo0GsXp06fBsiy0Wi1MJhNMJhMKCwthMpniTCgzId+ELZ8ufpZlRY9HalurJC5WFkXYVphwOIyenh60trZCq9Um3c5vQBeCZVmcOXMGTU1NqKmpQSQSgd/vh8/ng81mw8jICCKRCDQaTZzYmUwm6PV62RdMvghbvhwHQUrYxFCMBFYeRdhWkHA4jGAwKFmrRqyChGBZFqFQCM3NzSgvLwcA6HQ66HQ6lJSUxN2XWIj7fD4sLCxgfHwcoVAIarU6SfAKCgokSyUUzpGJsImhGAksH4qwrRCRSIQrwJWKo0kJ29DQEFQqFWcAKYVWq0VxcTGKi4vj/h6LxTjBczgcmJiYQCgUgkql4sQOWBTGbF7Ea4WV+EzSEbxwOIy5uTk0NDQoRgI8FGFbAUhXAf+kExMvsa3o5OQkotEoDAbDkrZnGo0GRUVFKCoqivs7TdOc4NntdjidTrz22mugKAqFhYVxKzyj0XheXizAygibGEKCF4vF4PF4uGNT4niLKMK2zBDB4Pc7Sq3YhITNZrPBbrdjx44dXNIg26jValgsFlgsFhQWFoKiKLS1tXG25D6fDx6PB1arFYFAAABgNBo5sSOCx+/pzBb5dAEyDJN3xyNnsM/5VoCsCNsyQgpwE5u409mKut1uTExMoKOjIyedCSqVCmazOakpn2EYBAIB+Hw++P1+zM3Nwe/3AwAMBkOc4BHLobVAvm3PibCJkc3EhdDz5CuKsC0TQl0FhFRbUXKb3+9Hf38/duzYwRXxrkRnghzxVKlUnHDxITV6Pp8PPp8P8/Pz3MwGIcFL/GwSWQtZ0eUklbCJsdTEBf+/ic+RDyjCtgyQi5thGMELV85WNBKJoKenB1u3bkVBQUHc7ct9sS/lNfgxuaqqKu7vxFuNrPDsdjt8Ph8YhkFBQUGS4PG7MfKJtSJsYkhlx1dTPV5+nj2rGJZlYbPZYLVa0dzcLHgfqVo1IipnzpzBhg0bklZE+S5sUs9pNBphNBrj/k5KWIjgTU5OwufzgaZp6PV6aLVahEIhuFwuFBYWCtb+rSRrXdikyDSOp9FoVvyHShG2LMKfVRAKhUQvAKmSDoZhEAqFsGnTJpSWlgo+dqWmVa0EFEXBYDDAYDCgoqKC+zvLsgiHw7DZbJiZmcH09DR8Ph9isRh0Ol3SCk+n063I8Z7PwiZGqo6LXJg6KMKWJciFGA6HodFoJIVHbCvKsiwGBgagVqtRXV0t+NjVumLL5BgKCgpQVFQEj8eDbdu2cbdFIhEuhme1WuHz+RCNRpelvSwRRdjkk8vzSBG2LBGJRLiuglRmkWLCNj4+DoqiJFcf54uwSaHT6VBaWpq0ol2u9jI+irClTy4+L0XYsgC/q4AET6WETSjGZrVa4fF40NbWhuPHj4s+Vmobmy3y6cIF5B+P3PaysbExbgpY4govsb0skXwUtlSZ5fMRRdiWCH9WATnhUwmbSqWKyyw5HA7MzMxwtWpS8EVxOS+yfFmxZeM4MmkvSxQ8g8HArWTzaYXEMEzOEyr5iCJsS4DfVZCYJpe7FfX5fBgeHkZ7e7usX15lK5o95LSXuVwuTE9PIxgMgqIohMNhTE5Oori4OC/ay5StqDCKsGWIWFcBkHq7SIQjFAqht7cXbW1tsrN6irAtP/z2Mj4Mw6CrqwsGgwEejwczMzMIBoMAVq69LBFF2IRRhC0DGIbB5OQkioqKBFdZqb5IshU9c+YMNm3alFTbBYhvM/Ol8+B8RKVSQa1Wo6qqCnq9nvs7v73M5/NhdnY2rp+Wn7TIdnvZahC2XKAIW5qwLAu/34+hoSHs3bs34+ew2WxobW1N2gYB58RLTDSJ6ORTEPt8QegHR6y9jGEYrtuC317GsiwMBkOS4GWSBFCETRhF2NKAiBqpsM4keM+yLCYnJ5MKUvnI7SVdLvJtxZZPAp7Od0487pazvUwRNmEUYZMJv6uAmEVKneRiwjAyMgKdTif56ywlLGQ1Fw6HMTs7y10A2ay8zydhy5fjIGTDtijT9rJEwdNqtatC2JQYW55CTjhS+8SvVUvnpJqamkIwGMT69esxNTUler9UTfIkPlddXY3Z2Vmu8j6x1chkMmVUCpBPwpZvLGeJTar2MrKl5beXhcNhsCyLkpKSFW8vy2cUYZNBJBLh5gXIrVVLZH5+HvPz82hvb0cwGEyZNZV67unpaTQ3N6O2tjbuIotEIvB6vfD5fJiZmUnqrTSbzZzgSW1vFGETJxcFuqS9rKCggJt1QY7lxIkTKC8vRywWE20vW45Vfb6jCFsK+K1S/BNaTncBuQjcbjfGxsa4Alw5BbxCwkKSDkajEZWVlUm363Q6lJWVoaysLO4xpLfS6/ViamoKfr8fsVgsbntjNpvz2i4oX8inzgNyHKWlpXHWVkB8e9nc3ByGh4fj2sv4W9pM28vSPc6VRDmLJUicVcBHrrAFg0HOLJJsC1OtiMRun5ycBADBTKrUc+n1euj1+iTB429v+PGcgoICBINBTE9PcxeA0rZzjnwRNkA8eSCnvWx+fh6jo6MZt5flM4qwiSDWVUCQs+oKhULo6enBli1b4n5R5TxWaO6Bw+HAunXrEA6HASxt9SC1vQmFQjh27BgikQgmJia4THAmDrgKy0u6cd5stpflM4qwCUDTNPr6+lBVVZW0xCfIibH19vaiubk5aV6A3NUegT/3wOFwLGsdGwlgazQaNDU1cX/nZ+y8Xi8WFhbiarKWc8ZBvl9EuSRbWVG57WVTU1Oc12BiHV6u28v4KMKWAJnK5PF44lYyiUiJE6l3a2xsjNv+EVJtRfnPzd/KajSaFek8EEIqYydVhMpPWmTSZqQkMaRZ7pifVHsZETy328310wLgBK+wsBAWiwUGg2HZjk8MRdh4EEFiGAYajSYjTzViFqnVakWFUe6KLRqNoru7G5s3b+ZWjvmWseTXZPETGolDXfhTrHLVV7lWycUqSc70Mp/PB7VanRTnWwkUYXsDfldBqmntgLg4TUxMgGEYmEymlHMNpJ6bpmn09PSgsbEx7tcy34RNDLGhLlJ9lfytDRE8hdUFPyaXy/NUETacW12QrgIgswD/7OwsXC4Xtm/fjv7+/pSrMikmJydRVlaW1HbFF7Z8Kj2Qi1RfJRE8vnMGaV8bHh7mtrSrIXitkFvOe2EjMaJIJJK2WST/dqfTienpabS3t8uqVZPC6/WCoijU19enfN21Al/w+PMeFhYWMD09DaPRGBfLSQxeK4KnwOe8F7ZwOJwkasC57aAYiWaRg4ODaG9vX/JgY5vNhlAohMbGRsGLdLVsRbOFSqWCTqdDTU1N3N+FsnXBYDBOIMm/1VyPtdpR5ormALGuAgCyB7KEw2H09vZi27ZtcR5dqdqihCBlHdXV1ZLuHmtxxSaG2Ocglq2jaZqL3/HrsfgFqEsd6KKQ/5y3wiY0q4CPnK1oJBLBmTNn0NraisLCwqTb01lZ8cs6FhYWJN09zqcVG5Der75arRasxyIFqKQGjwx00Wg03JaWxPCyPbJvuVgN54GyYltBiDtGbW2taOZNTkmG1WpFS0tLUhW3nMfzSSzrSOXusRpO6HxDrAA1FovF1eCRFqPEnkqz2Zx3TeT5blmUy+TWeSdsJDYTiUTSmiTFh2VZzMzMoKCgQLAZnTw+lbCRSdnd3d1xZR25Npo8n9BoNIItRtFolBM8/ozSQCCA3t7evHDNyHdhyyXnlbCRammWZVPG0NRqtWjyYHR0FBqNRrKiWu5s0YGBAZSXl8eVdcgxmlRYXrRaLUpKSuKKS1mWxauvvoqamhp4vd5l8cJLB0XYxDlvhI3fVUAKcOVmPflMT08jEAigrq4O8/Pzoo9PFeSnKArj4+NQq9Woq6uT9drkccqKLTeQmaKJggeAs4by+XywWq3wer1xXnj8GF62rKEUYRPnvBC2xK4CQH7Wk8/CwgLm5ubQ3t7OiaTU46PRqOjtsVgMHo8HO3bsSIpDSIliYoHu+UC+BPKlYkY6nQ6lpaUoLS2Nuz9f8PjOt4lW35kI3moQNiXGtkwIdRUA6RfgejwejI6OoqOjY0ktVwDgcrkQDoexfft2wRNTKvPJF71QKAS9Xq+YQ64Q6QbD5XrhTU1NxXnhJQqemDWUImzirOkrInEAC/9DloqhAfEFusFgEGfPnsX27du5uEmmLriBQAADAwMwm82iX3qqGBvLsrDb7RgeHoZGo4nzSiPbnWxbB+WKfFqVkq3oUpHywguHw5y9O98Ljwge//tdDcKWK9a0sIXD4bgBLHxSCRPZqvJLMfjJgky2stFolDOeHB8fzyhBQIa5DA8PY9euXTAYDEnWQTabLc5Jg1wMZrNZaTtaAisx9pAIXqI1FPHC8/l8nBdeNBrl3GT49u6K2K1hYQuHw6JdBYC8FRdN0zhz5gyam5uTKtzTTT4wDIPu7m40NTXBbDZnnCCIxWIIhULYvXs3V2YgZh0k1lhOUVRSQFupwk9NtlZs6SLmhbewsACr1Yri4uI4wVsJ8890jj0XrElhi0QiOH36NDZv3iz6warVasngPkVR8Hg8aGlpETWLlLtiY1kWZ8+eRUVFBbf1yKSkg4gjCTynQqyxnN92ZLfb46rwidiR0W78NrHznXxzU2FZFnq9HpWVlZJeeDabDYFAACzLrqgXXi4/qzUnbKRVyufzSd4v1YptbGwMKpUK69atE3283BF6Y2Nj0Gg0cWUd6a7YWJZFf38/ysvLMTs7K/q6chBrOyJFqaRU4dSpU1zJAn87e75Os8o3YROLsUl54QWDQS6Gx/fC44csiOAt9b0qfmxZgqZpBAKBuIHGYhklqeTBxMQEYrGYZIFlKmEjt8/OzsLr9WL79u1Jt4sJm9Btk5OToCgKdXV1SxY2MfhFqTMzM9izZw8oioqbV8qfZrUSCYt8Sx6sBmETQ6VScYKX+DxkMeD1emG1WgXNP1dTjHbNCBvDMNwqTaVSccIlJmxiwkKmQe3YsQPHjx/P+HjIlKqpqSl0dHQI1qrJbZtaWFiA3W5He3v7ip5UJKZEShYSM3gkYeH1epc1YZEvFxLDMHlzLED2yj2kzD+JNVRijFauF54SY1sCRNRIqxSQXjkHweVycdOglnrCkLT9vn37BLdtcldsPp+Pq59LPKblXM3ImX0qN2FBZrOu9oTFal+xpYvUXAPilJLohVdYWBi3pRWb8rbcrHphI4FSmqbjBERuOQfB7/djYGAgziwyU6LRKAYGBrgp20LI6S6IRCKc11umfYeeYBSTziC21ojXzQUjNAq08UOhM23dkpOwSLQN4q/uVqLHcinkm7DlYq6rmODxzT8dDgfC4XBaw72zyaoWNiJqsVgs6QuWs2IjwhIOh9HT04OtW7cuOQvIMAzOnDmDpqYmTE1NSb6+VFaUpml0d3djw4YNSTGRdCjQqmEp0MLmDaPKsvjrOekMwKDVYHTej9bqQsRoFizU0KlVYAFo1aqs96TKSVjweyxJ5pdlWcRiMcmwwkqRj1vRfPoR4Jt/EueaXLFqhY3fVaBSqZJOOLnuHcSbbePGjUkxhnS/GJZl0dfXh8rKSpSVlWFiYkL0vqlWlIFAAE1NTXG9h3Lxh2PwhqIIRWmo3kikHBtzoLXShMdPTmHSFUR5YQGKjToMzXsRitIIRWnsWl8CmmFQVWREMMZyJ+dyXsxiLhokYTE7OwuPx4OjR4+CYRgYDIa4Fd5Kju4737ai2UCJsaWJVFcBIK+Aloy4q6+vF519mOpk5t8+OjoKnU6Hurq6lL9YUltRstJLdP2QC82wGJrzYtodQoFGjd4ZN/qsHtQWF+DwiB3lFj1iNI3XJ+3Yt6EUtSVmhGMMJl1BjM77sL2ORjhEo8/qRXFhARorUtfMZRN+jyWp1dq4caNkwiLRBXc5sneKsKWHUseWJh6PBzabDZWVlZIFuKlsgwKBANavXx9X68OHbBfFXoNfUmK1WuHz+biyjlRfqlRW1uVypdwSC4kmzbA4OemEQadGlKWgVasQpmM4NeVCKBRC35QPHhaY9YdQgBACAAZss9hW40Z9WQGGZym0VBWBZhZXeqWFWhSb8qdAN1XCwuv1wu12Jw124Qezl5KwUIRt9bDqhI1sUebn50UFCUi9YiPbxPXr10s+h9TJQ24n2T+hsg6p50506PV6vRgfH8fOnTtx8uTJlMfFjzmxLIsz0y4wNIsozWLa4cdfTk3D5Qth0hcvggyAwBv/OwzghDWI161BbKkwoMJSgGf7vOgwMzBoVNBrVAhGaBh0uYlvyQkHiJUrZDthoQjb6mFVCRvpKtBqtSldZKWSB2R1lWpoh5x+Uv7ovXSC24nPHQ6H0dfXh7a2tpRZWRLYj6t184ZwdMwJpz+K+uICHBt1YNoRhCMi73hiAEYWgigrKoBeS2HGG8PhEQe2rqdQadIDyG3gPhMyTVjwV3iJPx6KsMlH2YrKgKSSKYrirHqkEJtZYLfbudXViRMnJJ8jVWYVAAYGBpJG78mBn3UkGdCNGzeKDpcRe2wkxmBk3ocKsx6bKk2YdAYx7QrAF44gJDyyQRQ/Czh9Iei1KkTYCIrdIezUqGE25E/mLRuIJSz4HmkTExPw+XxgGIbrr2QYBrFYLG8EJV+OIx9ZFcJGCnBJqxSAlIKjVqsRDofj/ub1ejEyMsKtrlJtc6RWbDRNw+PxoLm5WbQhPVXLFcMwXCa1pqZGNIEh9Fjy3DqNCnUlRpgKNLigqRTPnx2APRCEVqtGWaEaYS8N6U/qHGoAgUgUZWYLarQxFBVoUFciPtdhLSHlkUYSFiRDe/jwYQArk7CQIt+FTVmxSSDUVSBntmbiaisUCnFbPblThcSEjYiRwWBIsjOSC1l1jY2NQa/Xizbbiz2Wf1ymgsWvsUCnwfXt1Xj+7BwiMQYbK8144tQ0QAGzPuHPy0ABei1As8DGShP2NZeiqbwQ9ZhHc7PwBK7zCX7CgmVZFBYWoqWlJa7diJ+wSBzMTMb2LcdFns/Cluse37wWNlKAm0mFNV+UotEozpw5g82bN8dt9Yi4pMp6JjI6OoqCggJZsT6x5yfxOZVKldQgnwqp4tmWChOmnUEEozTmfWGYDHqsM+lRXxJD/6wfwRhgKQCCEaDSrEWFuQBhmka5UYt3X9CAzvUlODrmgs8LqFX5E0/KB/jfpVj1vdhgZq1Wm9RSttTi2nwWNkBZsQlCBrDEYrGMvjyyYuMbPAqZRUqJplBm1Wq1wu/3o62tDUNDQ7LswYW+YFKecOGFF6Z9ApAVWzQaRTQajdsC+cIxtFSaEY3RsBi0uPvNxZj3RTDlCGBzpRknZzwwatWoLzHiog3l0KopaNVqzLgC2FFfDFOBFpduLENfjzXnv7qEfAnYy0keiA1mFptipdfr45IVUjMOEsl3YcsleSlsUrMK5KJWqxGLxdDb24vKysq4uAn/PlKtOom1cA6HI66sQ+5Al8STLxQKYXx8HMXFxRn1pZIJWL29vTAYDHFbIFZnRGmRGZWVxeioL4YvHIMnFMW2dRZ4gzG0rivGmzaWY8DmQ12JAU3lhXAFIqBZFpo3jnM5WqrWAkvJiopNsSIJC6/XK5iwIKIn1GGhCJs4eSlsjz/+OObn5/Gud71LdtV/IiqVCl6vF5WVlaitrRW9j1wXXL/fj6GhobiyjlSPF+ouIBnQpqYm2O120cemen/Dw8NobGzk3lssFlvM5tmcmJ2dw9TYCLciCKsNoLQGtK0vR+f6dVCpVPBHYojSi8dWbNRh/5b4eFq+CFs+HAMh272iqRIWQoaQfPeMWCyWN6vZfCMvhY34mMmpMRNbbc3NzYGmaTQ3N4s+h9xG+UgkItgkn+6kKpZl0dvbi7q6OhQVFUkOXJZ6fz6fD2azOc7/XqPRoLi4GMXFxXGvR+yT3B4vxsbGOE98P6sDpS9EMVWWk4zeamSl6tj4CYtEB1ySsHC5XAgGgzh8+HBcwoKI3nIlLNJBibElUFhYyPUAiiG1jZyfn4fD4Uh5scoRJtIkv2HDhqSyjnRni46MjMBoNKK6uhqhUChlL6nQ7bOzs4jFYnGWQFLPITT1iN+CxPfTUqvV3IURDoclZ0Kcj+S6QJefsKipqcHCwgIuuuiiuITF/Pw8RkZGEIlEuIQFP4a3km4girAlYDKZZAtbIm63G+Pj42hvb8epU6ckn0POVnJ6ehq1tbWCLhvpCBuxW25ra0v7sQSPx4OpqSnB4TLpwG9Bqqmp4f5OtrNerxfBYBD9/f3o7+/nAtz8C2QlYzu5XnkQcjWlKhVyEhYzMzNxU+gTZ1jk2hIq26xaYRO68AOBAPr7+7Fjxw5Zv0yptqJ2ux0ajUYyRifU3ZB4jC6XC9PT09i5c2dcuUAqUeWv2MLhMDe0eXp6elliT/ztrM/nQ1VVFUpKSuKG+PJHvBELcPKvoKAgb0RoOcj1ii1dpBIW5PscHx9PK2GxWli1wpYoSpFIBN3d3di6datsO2IpcZmZmUEkEpH0Q5Oz6goGgxgbG8OOHTvifhVTBef5z01KVjZu3Mhtr/mj/ZbrYiPPnbidDURo6NTAybEFHBq3Y19NTHA7SwRvKduffEoerDZhE0JqKLOchEU6P2DKVjSBdIWNDDYWioNJIeYA4nA4YLVa0dDQAI/HI/l4KWFjWRYjIyOCYit3xUZmkpLVE3nscl3wVncIpUYtGJGnt3nD+OlLY7igqQQURcEe02J9UxPMBRpEaQZDcx6U6xiEgn5YrVYc7+6HQUWjoKAgbnW3GieWrwVhEyNVwkIoHis0wyJfyEthM5vNsoWNYRj09PRg3bp1abvNCnm2kbKOjo4O+P3+tONgBJZl4XA4UFVVJdh2JdevbWpqCiqVKm47vFylGNOuIH704igqCnUYn3Xj9n1m/HVgAjTD4K0d61CoU0NFAXZ/BIFwDNdur8b2dRacmHBhd0MxrO4QfnfcivfsrUdrfSl6rR4cGprCO3auw+bKAm418PLZGejZMMoLzq0GzGYzNHojprw0WqtMKNDmX8xnLQubGFIdFvyBzIkJi9LSUtTX1+foqPNU2AoLC7llsBikAHdwcBAWiyUuCM4nVa1b4na2p6cH27Ztg06nQygUkj03IZGhoSEUFBRkPMyCoii4XC7Mz88n+bxJue/KgWFYqATapUqNOuxtLIHDF0GPLYRRexDhqBaTDj8+8fvXUWzQ4sotlRizB/BEcLGot8qix1Pdi3NO9zWXYHO1GX88MYWP/csGhKMMaov0sBi0eH7Ihe3rLPhdvwOHBsK4eWct+n1hNGl1uMRYAJfLhSOjI3i0x4edVVrc0l4Gi8WCSCSypPeaTfIpeZDrLbpQeRFwLmGR6+8sL4VNo9HI8lubn5+HVqtFQ0OD4H3kDE2ORBYNy/jbWTI8JZPMJbAYnwuHwygpKUm5VRWDYRhMTk5i165dSRcTfyua7gpiyhnEL16dwFVbK3BBUykiMQbjjgCqLXqY9BroNSo4glFsKdeBZoH37K3DV//ag/5ZD1oqTPCEoqgvMeDIyAJeGnaiolCNf91SiXv/3o+7/rUFvz46gRlnEHZ/FCcnnQhGGBTq1Himz4YrN1dgxh3AuqIChKI0XuhfgHpzJaxVBWhdX44b65tw3NUHtUGDyuoqhAJ+uFwu+P1+zM/Po6CgIC52t9Lb2XxaseVr1wFJWOR68E1eChuAlINEvF4vAoEAN61cCLm9oKRwtqamJm47m4mwOZ1OWK1WdHR0YHp6OqNfrlgsBofDgZaWFkEnklRbUYc/gj+enMH+LZVoLIv3d4sxLKI0g1B08bj6Zr344T9HEaEZvLOzFsFoDPOeEIacUTBDLrw83oN/9s8jRAMlRg3+etqKwTkv/G8kg+f9NH7XZQUAPPDMWTgCDHxRFn89M8e95n1/HwIN4MSEB3oNUG4qwO6GYpgKNDg97cZjJ6axodKE/37XDrz/kgZMOoIoLy2FqrwMOp0Ofr8fzc3NXDaPNJiTAdl8+6DlzM7mepXEJ1+FLV/IS2FLdVI6HA643W5UVVVJfrkkDieWlSMxtuHhYRiNxiTroHSFLRAIxLnpykkQJEJE1mKxiGZ3+cImJP7+CI0pZxAOfyRJ2BrLjLj7za0waBc/t5byQjSXGfHE61YcGrQhEgNUFAtvmEHPXBBWtxs0Fr3anut3iL4XABh3CZe+0AC0KiDGAMEYMOkK4fmzNuxpLMWcJ4QJrRoUBdz79wFUWwow6Qxi5/pi1BQVcO9XqtiYX40/OTmJUCgEjUYTJ3bZKE7Np62oImzS5KWwSeHz+TA0NISGhgYEg0HJ+6Ya6KJSqeDxeKDVarFt2zbB2+XG2KLRKHp6erBlyxYuO5RJLGxkZISbpym2QqAoSvK46ksM+PybW0UD8Ebdosnm77umYNRr8PZdtXiqexZ/77HBoFVhS40ZWhXgDkZAAaCwaB2+FKIMoKeA8Btvqdvqh9UdQpWlABc1l6CkUAdHIIJDA/OIxhi8NLSAd+5KPaUrsRqfEIvFuNUd301jKdvZXG+v+OSzsOXDyjZvhU2n0yESicSlkEOhEHp7e9HW1sa5IkiRSph8Ph/8fr+odZAcYWQYhsvMNjY2xmWPUhXwJjI7Owu/34/t27djdHRUcqByqudNlVWkGRaDNj9MejWu316Nj7ypEd97bhiuAI2Xh10AgEoD4JZ99KkhokYBMGkBe4CGM+DHpDMIk16DvY2l3P/eXrOYSc70ItFoNKL230Tw5ufn48b3yanVUoRNHmSVnSvyVtiMRiP8fj8nbLFYDN3d3di0aROMRiM3HVwKqc4Cn8+H6elpFBcXS8bg5Ajb0NAQiouL47ZI5PZUx0i2kqRdSo4lUjbKPTRqFT5xRQv8kRh++uIo/tYzC3843kbcJr0gXhLeN9pQWQCeMANfOIITEy5c3FKGN20oRaVFn/Vf/lTbWVKrJbadpWlaEbZVQt4Km8lkgs/n4zIsZ86cQUNDA1c+IWfQipg4hMNh9Pb2YuPGjbBaraKPl9MdEAwGuYG+QrfLaXSPRCJcuxTxZ5PaxqYSXLkU6jX4xasT+NGLI4gyiyuplYD/iTC8/9q8ITSVG/DAP4bxxJk5fO7qVpRSQCjKiJaoZAOxWq3EaVY2mw0OhyMpWZGLYmNF2KTJa2EjPYl9fX0oLy+P+5WVc3ELiV/iRKhU4iiFy+VCNBrF5s2bRe2/UyUPyDT6DRs2wGAwxD1WKsYmlTwQY9oVxMOvTeDtO9dhU/XiRdxSYUR9iQEbKwsRidF4YdAp67mWgxgDTDiD8IVj2FRViAqzHvZ5N35wZAFXhYy4sV3+XIhskDjNiqZprF+/HjqdjhO8TLaz2UARNmnyVthIke7IyAj0en1SFbOcFVvifUjGcd26dSgpKUE0Gk0pjmInpt/vx/DwMAoKCkRPMDnCNjAwgMrKyqSuCanVIv+2VBcOw7D4yctjKDZqcUFjCTzBGELRxelYr43Y8fAr42BYFhsqTPjDiSnJ51puGkoLwIKCVqPGDe3rUGnWw+dUQU0BT52Zw0XNZagw565th2RFDQYDDAZDRtvZbFkH5buw5XrLntfC1t3djV27dglmLDPZig4NDaGwsJDLnsmJgQlBMqBbt25FX1+f7NdPhCRHhNxD5MTYIpEIJiYmuAvHaDQmnVAMy8IRiIIC0FReiG/duAUatQrhKI0/n5rFwIIPkSiLBV8InuBSc5+ZU6RfdPIdXQjiM/s3YGu1GU93z+H48DyiDNBYYcz5cJlUXSyptrN86yDSO8u3DkpHqPJd2HJN3gqb3W7Hj3/8Y7zwwgsZbfOAc21XADA9PY1IJIKtW7em9RyJEKcNqXmiBKk4mcPhQDQaRVNTk2j2TSorSrawlZWV8Pv9nN8b/wIjF87nrtrIxc80ahVs3jC8oSgu21CGo2MOOOgI/mVTBV4edmLGHUYukvXuMDA874cvTKO8UIdAlMEzfTa4vCFUGFW464oWFOpze7pm0nkgNpw5FApJbmfJdye2nc13YVNWbAIcPXoU//znP/GZz3xG1DFAzgdHhibb7XbMzc2hvb09qedSzvOQE5plWQwMDKCsrExwOEwiYnGyQCCAoaEhyT7SVCs2l8uF6upqNDY2xr0Hmqbh8/ng8XgwOzsbV79lNpthLDThOy/Owh6gEWNY1BUXoMKkw19OWxGKRFFl1mJ9iR5HJ6RLabKNTgWoVUClWYe/ds/BbNDik1e04Fj/JJ4bdOKex3vx+Te3ospSgEiMwS9eHUdbrQUXtyzNdDMdstVSRVFUyu2sw+HAxMQEt53lr+7IVPp8FTaljk2Exx57DB/4wAeWfBKpVCqEQiHYbDZ0dHRk5BLKnz06OTkJlmVluxYIiVMsFuMKeScnJzMq6bDb7VwgO/FiU6vVSW6qpH7L4/FgfM6J4Vk3dBSNKKvCFc2FODZLY2zeB1eIAc0ymPWujCU4BUCFc5lRT4iGWsVgyhnANw/2Y0ddETYXU/CEaWyvKuBq86I0g5GFAMpM8gZfZ4vl7hVNZztLrINisVjG29nlRFmxCfBf//Vf+PnPf465ubnUd5aAYRjMz89j165dsqe/J0K2fQ6HA3a7PWnVl+qxfOEiyYuGhgaYzeaU200h0fN4PJifn4fFYpF9HPz6rdKyctSeDqCsUIeb2qvRWqqG+rVx/O2sA2oAmeeI04d941+RQYOaIj1oGthUbcJ/Xt6MI6MOFGjU2FvJYl+dHhtbzg3lKdRr8I0btkCrXtmLJ1dN8ELb2YmJCUSjUZjNZvh8PtHtrNlshl6vz7nQrDR5KWzAYrnHyMhIxo+naRqjo6MoKiqKm/6eLmq1Gl6vFyMjI9i5c6fgL6LUtPfEYS4mkwmVlZWCt/MREj1S77ZhwwbMzs5m9H40ahXufnMr9BoVaosNCEVpPNbjhtNPo8iowYI/OYFAAUuOuxk0QPiNp2awuFJTUcDm6kJYDDoEozRu3rMOb+ushVpFobl80WFlZmYGGoGkgU6z8iuTfOoVZVkWer0elZWV3PkEyN/Oms3mjGbarhby9p3JcdElwfnEk41lWfT09KCqqiqlrxu5v9Qv2sDAALZv3y6YppdyEOEnD/jtUomPFSLxNtK21dLSAoPBsKQ4BhENAOi1ehGJMSgxanFNWxVomsWvjk2fOw4AlSYtHP4oIgkvKVfw9Gqgvb4Y/jCNMYcf3hADDQWUm3VorTTB6olgyObDc/3zeMfuxf7QKM1A/cZ3ki+rjXyzLRI7HzPJzhLRy9Z2Ntefk2xhoyjqzQC+j0Wjh/9lWfZe/u0sy+Kuu+7CwYMHYTQa8fDDD6Ozs5O7naZp7N69G7W1tXjyySdTvl469uCJX8TQ0BBMJhOqqqowPDyc6n2JChPDMPB4PGhpaeE82hKREjZym8fjweTkZNwwF/LacmrVyHsqLS1FWVkZgsFgSmEbWfDjuT4b3rmrDsVG8bqp7hkPqi166DQqzHkjaK+14I4L6/F/hyehUgGWAi0sBRo4g9GkfWqhjoIvUe0AaLEoiOE3/n9DaQE2lBnhCccwMOdDUYEKHXXFmPaE4Ysy8IZjCMdYdNQVgWYWm/+//EQfNlaa8OamlRsXl4p8E7Z0BEgqO0t6Z202G3fN8W2/M9nO5vpzkiVsFEWpAfwAwH4AUwCOURT1BMuyveQ+f/vb3zA4OIjBwUEcOXIEH/nIR3DkyBHuOb7//e9jy5YtkjME+JhMJlkuuom2RFNTU1xZRyQSkVXEKyRMZNaAwWBI+vXjk2rVRdN0UruU3McS8bJarYhEIlzblpwylcE5H46MOnF5a4WksN28cx26xp2I0iyu3lKBn748jht2VOPiRjNsvjC8URWcIRpNZYVwBKPwBCKIMkC5SQdvKAajFghEF49TBUCrBqI0UFOsw6w3ArCAPxDCb7pmoKaAKAuUGNQo0LCIxBhc31YNhmXx+OlZzLhC+OqTffjKdZuxqcqE+lIDWDZ/ZpuuZmETgp+dXWvbWblHtRfAEMuyIwBAUdSjAG4EwAnb448/jttuuw0URWHfvn1wuVywWq2oqanB1NQUnnrqKdxzzz144IEHZL2g3BF8fOFaWFjgMqAURS2pn3RiYgJqtRoWiyVje3Dyi7h9+/a4dimCVJ0buc3j8WB6ejrOHlxOE/wVmyvQUV+EyhSV+oV6De65ZhMYFnjqzCyKjVrsay7F/iY9ggE/Do4DNk8YwRgD+6gDJSY9vnLtJmyqNuNXRyexvsSAn70yjhjDgmGBdUV6nJn2osigRUd9KWY9IUw6g7AYGNzcXgGbN4RJexCdZSw04Siso/1QafX49AVleGU6hgCzOFfhfRctuiJPT09LHv9Kcr7YFkltZ8ncCqntrNC5vtLIFbZaAJO8/z8F4AL+Haanp+PKIOrq6jA9PY2amhp84hOfwHe+8x14vV7ZB0aa4KXg2wp5vV6Mjo6io6OD+8Iz7Sedn5+H0+nEjh07MDIykpE9OMuy6O/vh0ajER0yk6ofNBaL4ezZs2hra4v7ZZTj86ZRq1BlkTeGkNzvPXvr0VJZiG8/PYBrW83YU6XGXVdswNlZL77z90G8e28dLt5Qho66YgDALbvrMLbgf6Mezoh/2VSOYqMGM+4RVBcZYPdHcN32aljdIZgLNHj/xQ2gGRbOQJRrjTrwt36cnnBhe5MWF1bT8HjdeO2117jVAU3T0Gg0iMViebE6OB+ETQytVis4pzRxO8uyLHbv3r2ix5aI3DNF6NuMuyKFLlCKovDkk0+isrISu3btwqFDh2QfWDqTqsLhMPr6+tDW1ha3LZUzpi5RmLxeL8bGxjiBzHTuwdTUYt+lVF9gqud2uVzYunVrUlZ3ucbvGXVqbKuxoKO+CM2lekRiITzy2gQu2VCGB96xHUUGDXdh230RfPaP3Zh2h/GpK1twXVs1vvePIZyecuOX/74LFWYdvCE6acWoUVNx/Z637KnDJRvK0NZUivueGYDDr8eXrtsBk5aC1+vF1NQU3G43urq6QNN00pBmMmd1JVhrW9FsILSdzYeVrVxhmwLAr0qtAzDDv0NdXR0mJ88t6qamprBu3Tr84Q9/wBNPPIGDBw8iFArB4/Hgve99L371q19JvqDBYEAoFJK8DxnGMjQ0hNbW1ozKOvgrNiGBzETYHA4HN13q+PHjoo+VWnlNTk5Cp9OhrCy5sj7R3SObVJr1+PSVG2Gz2TAxF8CrI3ZoVRRu7lx01njsxDQsBRr8S2sFOhuKQU24UWVeTD5cuqEMrmAU60sXvweDNvXp1VReiKbyQoSjNCadQTgDUcy5QyiuNuP1eRqPnQ7h5m0l2LahAff+fRBbKwvwlhoT5h0uPHp4BBW6KJpLdHFil8+xn2yRL8KWr8j99o8B2EhRVBOAaQC3AHgP/w433HADHnroIdxyyy04cuQIioqKUFNTgwMHDuDAgQMAgEOHDuH+++9PKWpAavdaYFFUxsfHUV9fnzQGTC5EmBLtjPi3pxNjI+1S/C2x3McSSLJAqp1sudtWKIqCRa/CnZc34+tPnUWUYfDeC9bjhbPzKDfpcfXWKnz2qta4x1wk0d7EsixiDAutOv4zidEMemY8+NPJGTj8EXiCUXzyD914a8c62LxhjDjCODsfwuG5cTx/1obReSP8UeB1qx9Tdhpb1hXjnfu3clshrjI/HEVUXYDGyiKYzWaodEaUFRVm1H2SjyjCJo0sYWNZNkZR1J0A/o7Fco+fsyzbQ1HUh3/4wx/iwx/+MK699locPHgQGzZsgNFoxC9+8YusHKDU8t/hcECv16O6ujrj5yfC1dfXh5qamrh0OCDfHhyIb5cinQ6pjCoTLb7J9qutrQ1nz54VfNxKLPOJeDr8ESz4oijUa6BWUfj2TdsEC2YTGVnw47vPDuH2C9djb2MJ/nxyBn89M4evXr8ZDW8MmJnzhHD/s4PoGnPB5g1Do6ZQbdEjRjN4eWgB/3FJE9weD1iWxZ9OTiMUYzE070ffnH/RXlyvxrZqMx4+PIWzs1585qqNmIoWomvOBYc/jO5pDz54gQpzkzb86Og89CoW1zTpsLehCI1VxdzqLhs2QitNvgvbatmKgmXZgwAOJvztRwB+CCy+kR/84AeSz3H55Zfj8ssvl/V6qT4Y0reZ7vT3RNRqNWZnZ6HX65OmVAGp5wsQYSPtUuvXr0/KJomJc+JWNBKJxG2Fc9lMTIRtyzoL/u2Celzeutj0L1U6wicSY+ALxxCMxMgTAljMvFrdIbxjVy0eOz6No2NO+MIx0CwQi7GwukJvGE6GcGbqFMIxFiwAjQooNmhQYtRi3B4ECyAYofHTV8Zg1qkRirF44LkhaNQUXp/2otKsw6gjiEPjYWyosCDKOhCjgWdn1JiO0fhUNYXZ2VkMDg4mZfaIBVQ+C0e+C1uuyftAhJAoLCwsYGFhAbW1tYhGpeucxLoTCH6/H4FAQNDzDUgdYyMxupGRERQWFqKqqirp8VItV0S8+J0FxNk31y4JLMui0qzHHRcLD6SWolCvwS27a7Gzvhjz3jBuaq9GlUWHL/6lFw5fBI+fngHLLuqdpUALX3jxMw7zPupA7Nz7jzBAlV6DGXuQa5pn2cXG+XCMQbFBg1NTbnz0siZctaUKRQYNvvbkWbzQb0P3tB7v2rUOI/YAhub9GLKH8fPX/fjytVugUlFJmb25uTkEAgFQFBVXs5Xr6eZ8FGGTJq+FraCgAOFwOK4uhl/W4XK5ZCUYhLoTgMWGcpfLhfr6+pRDl8WgKAputxvhcDiuXYp/u9hJyH/u4eFhlJSUcMkCOaUqZEIW/7X4tW5LIdPH+0IxnJ5244nTVrwy7EBt8aKf2Hv21uHH/xzBjCeS9Jh5v7wi3ElX/HdNA9BRAE2z8ASj8AZj+OnLY2ipNKGlohDv2l2LbxwcgDPgx4I/ApYF1hUVQK9VYcoZQoxhoVNRooWqxAKKlDEEg0G88sor0Ov1cas7ZebBOXL9Y0zIa2ErLCyEz+fjhC0UCsVt1ZZSgBsKhXD27FnU1dVJXsSpkgeRSAR2ux179+5N2xCTbPdmZ2cRCoWwYcOGuNukYFkWsVhMNAZIRC5TscskQcGyLL773BBeHrJjQ6URNMNizB5AiVGLXx2e4FZl2YR0dC1GC1gMzgcwshDAPyjgQ5c1Yku1CTOuEKIxBgU6Nbats+Df9tXDpNekbKRPtIByOp248MILBUf4URQl6KqxXOSrsBFWTYwtF5Ai3YqKiqTxe0Bmcw+AcwNdWltbEQ6HJQcvSyUPIpEIZmdnUV1dLVpeIFVzRvzinE5nUh9pKsj2VqPRCJoAAEg6br7I8R+TroMvH184hoNnZlFfaoAnGMOrw3a4g1HcsKMGZr0WMYbBC/0LGLUHV2QKFgsg9oYf0i9eHccnr9iILTVmnJxw4eevTWDcEYBORUGboc043wIq0SSSrO4WFhYwOjqKSCQCnS6+FMVkMmVFkPLJaSSRXIsakOfCVlhYCL/fz8Wf6uvr4wwU5QqbkCdabW0tiouLsbCwkFEBLrEIr6mpkTzBpFZsxOdt9+7dadVd0TSNkpISnDp1CiqVKq5hmT8shH+CJYqd0BY2k9XdS4ML+MVrEwhEYjDrtagtNuBNreX4fdc0Bmw++CM0gtHF11rpTYovwuIbfxtAqUGNYoMWRq0KC94QPvjrk7D7o7jnmk14687sTL5SqVSwWCywWCxxf+ev7sbGxrjJa4pn2vKyKoRtcHAQRUVFgoF5ObVufPEbGRmB0WiMG+iSrrCRdqmKigoYDAbJxn4pYRwdHeUycHIhcbXW1lZO2MlKYW5uDkNDQ4jFYlzzPvlHvPMTLx6x1R2Z4JUYn0x8/LZ1FmyqMgEsC1eIxj3XbsKcO4RHu6YQjuVHvMURpOEI0ig2qBGKqhCM0gBFYcgm3dmSDfR6PfR6fZyVfGKT+fj4OMLhMLRabdLqbq3U3a00eS1sJpMJr7/+Oi6++GI0NCRn5tLdis7OziIQCKCtrU32cwgJE2mXqqurg9PpzGjFNzw8DIvFkjKry4dhGK5nkpzwYlbgwWAwzn8rFApBrVYneeeT50mcmzA4OIiNGzeKJijI/StNOjz4zh1xx/m37llE80TUCCoAkRgLVzSKrdUmfOaqjWhbZ0n5uGU5FpEm80gkwq3uJiYm4PP5wLJsUhtZQYG8HuBckQ8rz7wWtrm5OTz//PO4/fbbBT+sdJIHbrcbU1NTcS4Z/NvFSHwNfrsUucBTFeEmPj9JFrS0tKT0iyMQUVOpVCl/xSmKgtFohNFojMvy8c0Gp6amuG1+4oUzOjqK6urqJO8u/rFQFIXvPz+CV0ed+I+L16OlohBPddtwbNyFS1pKoNVQebNiA4C3d67D46etAIAykw5basyg00yOeMIsPva701hnKcDnrm5FtifTkxY6fhsdwzAIBAJJ80oDgQB6e3vjVndrvY0sHfL2k+jq6sJLL72ET3/606LzCuSu2ILBIEZGRrBjxw5BTzS5KzahdqlUnQmJRbher5cznYzFYrIzj2RLqNVqMw4aC5kN8i8cp9OJwcFBBINBWCwWhEIhQWdV8sMw6w3DH6Hx4PMjUFEUxh0B0AzQvs6Ef20tw7N9C8gHbdNSi6P9tCoKEZpFn9WLTz52Bq5AFF+6bjN2rS9O+Rwsy2IuwGB0IYBpZwiBKA3TCowD5MdQSfgEAF555RVUV1dzP1I+nw8MwySFIFbSJCCfyFth++Mf/4j3v//9khe+nC+MTJdqa2sTXMLLbZkSapcit8sVRn5ngUajSdrmiUGefymiJnV85MIJBAKw2+249NJLwbIsty1aWFjgShr429jP/GsTxpxh/PjlMcy/0XblD8fAMAye6VsAnQeiBiyaWx6fdANY3JKaC7Sw6N+wO48xODHhws9eGcc7d63Dm1orRJ+npViNOy9vRoVZvyKiJgVFUYIWQuRHivj4BYPBpGn0y20SkA9CmrfCduDAATzyyCNcPCsTSI1YcXFxUraKICd5QNO0aLuUnMezLMtldpubm7lkgZzkB03TnEvwcqb3SQnM1q1buaxq4raIpmku6D0/Pw+v14toNIr/2KyHsbAIZ+wWfP+VWfziyIzYy+Qck16Nd+5ah+u316BrwgmWZfH3njl0z3hg1KkFhW3GFYJes+hx9+ZtVQLPurJIefgVFhaisLAwrn86FovFmQR4vV7OAooveEajccmilC/WTnkrbMC5rGimDA8Pw2AwiM4rAFJvZymKQiQSQVlZWVJWFpCfVSWdBfzsmJxasVgsBq1Wu+zxk4GBAdTU1Ij+AADgHIX59+FPNS92LyCwDEW42YICcGFzKZ48M4d/nF2AKxgBQOHL121CoV6DqwVEa9IRwF2/PwODVoWPbFnxQxZEbMaGGBqNRnDeQTAY5ATParUiGAxyK3j+6m41mgTktbCRmYmZQDKB1dXVks+RSpjm5ubAMAyam5sFb5cjbE6nE5FIJK6zQM5jKYqCz+dLchzJNlarFdFoFHV1dWk/lt+O9OunJvNm+ymEmgLmfGHEGBYUBextLEWUZtBUbkTbOgsKBbaXWrUKWrUKBq0aKlV+iLZYi2A68BNM/B/sWCzGJZiETAIsFgsXc82HlZkYaQlbppOqJicncdttt2F2dhYqlQof/OAHcdddd6V8vcLCwozG5zmdTlitVnR0dMDtdqdckYmtmkjandSACZFKnKRarqReOxqNYv369Zifn8fY2Jhg9jIbLTt+vx/j4+PYvXv3kk7U/jkfxh1BqNUUWJpFgYaCuUCDBX8UTJ6IXYwFXp/04P6b23DxhjIUG7VwBaL40K9PQatR4ef/tjOpzaq6qAA/v20nWDqGvp4zOTryeJaznUqj0aC4uDjO3zDRJICUTVEUlbfDXdIZvyc2qYq7j9ikKo1Gg+9+97vo7OyE1+vFrl27sH//fmzdulXyNdMZwUc+0EAggMHBQbS3t0OtVsvKnApd0PxAf09Pj+hjpYQtGo1ibm4ONTU1aXcWAEBlZSWXCUvMXk5MTCAcDnMN2eTkSueXlMTVtm3btuQT0h2MosiggVGnxqw7hNoSAx7/8F78z4uj+MlL44jmYLFj1qsQiDBxq0i1msKvj01iR30Rio1aqKhFhxGpttFCvQbhMJ03K5SV7hOVaxIwPDwMmqZx8cUXr9ixiZHO2Sw2qYpDalIVuUDNZjO2bNmC6enplMKWztwDMvCDZC7JakZOgD5x1UTapYhpphRiqy6SLKioqJCMUSReLCRTSkSZwM9e8klsyA4EAklxErEap7Nnz6K2tlZyvKBc9jQU476btiJCM/j6wQE0ly0GogfnfDkRNQBoKCvE2MLi+VNq1OLDlzbihy+P4+ysDx9/9DQe/cBumAs0+Pm/7YRaRUk2xedLUBzIj5kCgHBxeL4056cjbEuaVEUYGxvDyZMnccEFcQ8VJJ0RfESMGhoa4i5UOSs2Pvx2qcRUulizuBAjIyMoKiqC0WhMaa1E4LcwyQ3YCrXs8H9JrVYrfD4faJqOq3EKBAJgGAa1tbWyXicVFEVha83i5/7rf++EVr34ubTXFeGZs3bufhoA4rad2cOkV+HDlzTgp6+M48yMF4YYixs7arClxoQv/XUAlRYd/vq6FXsbilFTVACKWvzcxPpl80nY8rkBPl9IR9gynlRF8Pl8uPnmm/Hggw9KZt8I6YzgGxoaQnFxcdxSmX+7FPxj5LdLEaSmvQsxOzuLYDCItra2lE32fMiFtdRtoVibFdnK2mw22Gw26PV6nDhxIuvOsQatGv5IDP8YWsD126vxdI8NZ6yL3+OOegtOTnlAThU1hbQTDhYdBY/ABHoVAL0KKDFQ+I/tapSFZ7CpmMLoghoXNy1+Fq1VZvzPu7fjL6esuP+5EVy6oRQHblxMd0q5oZBVUj4IXL6sivKZdK6gjCdVAYvxpptvvhm33nor3va2t8l6QWI0KQWx9o5Go9ykdD6pCmgJDMPA5XLFtUvxn0OusPE7CyiKSrkVJj8Gy1mEC5yrcdLr9RgfH8eePXtgMpni+hOFCnETHUPk8qeTVvzopXHs31KOD17agE/+oQfmAg3uvLwJX3j8LPQaFSpMWljdYcy4w5LOHxoK2FFvxomJxbm0lEqFRZvJRVRYtCx3BaNorjLhN3fsgkZFIRgM4oOVHlzR7EIhgjh8+DBOzLN4bCCGCxtMaC4twJs2lIqu0IBzYudwOKDT6RCLxZbsdbdU0i33WGlyLfxAesImNqnq2+QOYpOqWJbF+9//fmzZsgWf+tSnZL+gnAs8Go3C5XKJZvXktl35/X4MDQ2hvb096XXlxOnIsfA7CwB5w41JXG25i3BZlsXZs2dRX1/PxeqE+hPJVtbn88U5hiQWdEpli3etL8amqgVc0lKG1ioTKs2L272mskI8d9eFUFEUnIEIvn5wAFdt0ePUpBs2lxdzQSDGLG4PVBTAsICpQI0pZxjFBjVcQRqhKI0SowahKIMYzYIBUFtcAI2awocubeQmYZFyhnU154pV50/PQD0yiuICFd67VQ+/fwKHD4+hsLCQe2/DbhZzfhpXbalAgVaNcDiclDleitfdUlFWbKlJZ5iL4KSqH/3oRwAgOanqlVdewS9/+Uts374dHR0dAIBvf/vbuPbaa+W+tuAJ4vf74XK50NzcLPoLJqcIlqIo9PX1YfPmzYIlFHJtuhM7CwB5W+FoNMo5Ai8nMzMzoChKcGgNHynHEH67TigUSrLaIT2lW2vM+Pm/7eQe+9mrWqBRUaiynPt8+6w+nJhwY0CvwYNXlUKrLcfrbj0ePjyJGMNCr1HjM/tb8OKgHU92z6G9vghHR5yI0CwCERrlhXoY9WrY/RFctrEM779oPQq00p/hW3bU4IKmMlSYdQhGaFg9YTSWFiD0xnsbnlnA55+dQ4Rm0DswgrduL4PL5UJdXR3UarWs1V22vO7EyEYd21onrWCO0KSqD3/4w9z/pijhSVWXXHJJRl7oUidANBpFb28vqqqqJL9kORbbfr8fDQ0Nkm1XqVZ9w8PDKCoqigvik9cXEzbyd4/Hs+xFuKRZevfu3Rk9XqygMxKJcImK8fFxLtmTaKR41ZbKpOfc3ViMj/9LE0q1MXi9C9i5cycaKQo3tNcgxjBg2cUC2W3rzLiwuRQ/f3UCUQawGDT40CWNuKatEr4QjeMTLux/Y3XFsCz+ObiAV4aduHVPHZrKF39kaIbFgM2H9aUGVFn0sHnD+H9/7MGsJ4xb99bh9n2Lq1hTSQVKDnvhC9PY3lqP50bm8Y+hEG5ps2H99DRoFhjy6dBUaUFbfWlcZb6Q2AHiq7tMxU5ZsaUmP6rpJCDCwF/NkAxoU1MTQqHQkqYHjY6OQqPRSI7xS7XqisViCAaDgsNcpKzBaZpGU1MTXC4XpqamEI1GRQ0ilwIpg9m+fXvWV4U6nS6pGZvYZPt8PszPz2NkZCTpvZlMJhgMBtzQVoGuri5sTbBG1/Au3EKdBhe3lOIXr02g3KTDZ/e3cD2bFSZw4gUAP3tlAj98aQwxevH7+uI1i0OdHzo0ir+emUVLRSGu3FyO/35hFI5AFIU6NWZcIYSiNOz+KCpMWnzt+k3QqlVoKNLg+mcHYQ+x+ParXvz7hetRZdbi4TPj0KkD+Pa/RMBGFt9b4vg+vquG1OqOwL9vKsHLd2FbbTG2nGA0GhEMBrmYEMuyGBgYQFlZGcrLy2G1WiXnfkoxNzcHn88Hi8WSttkkwev1IhKJiM4sEHssvwiXNCwnVnin2u7JgVihNzQ0SPbMZhMhm+zE9zYzM4NAIIBIJAKLxQK73c69NzHx/f472uAIRFFfYhC8HQAmnUHo1Sro1Crc1H4utrbgCyNKs1jwRXB8woWFNyZjecM0jow58e//dwo2bwgWvQaTrhAK9Rp0lLG4bEMZfnd6ASxYPPzaOA7ctBUajRqFeg22btkEg1Yd9958Ph+XFVer1XFuKGazWdDYM93VXb7UseUzeS9sZFIVEbapqSmwLMvVy6nV6pSZUyFIu9TOnTsxMjKSkQsuSRZIDegQeiypV0tMFohVeJPtnsfjwfj4OHw+X1LmUqydZWpqChqNJq6WMBcIvbfp6Wk4nU7U1tZy2WTiGsuf42A2m6HT6VCo13D9nIEIjVOTbmxdZ0axYXEreGzMiZOTbuxqKELn+iI80zuPmqIClBXq8OkrN6Bz/QJ21hfhf/45Endsc54QaJqBL8rCisXxgIFoBM/6AM2kHTo1EKYX/xXq1Pj/3tmGKrMeBq1a9L0B8X2XMzMznGdaYhKGP+9AzuouHA5Do9GktG0/n8l7YeMX6drt9qRyDLktU/zle6IvWjqeagSWZblkwczMjKgwJj6WeLup1WrZ9WpC2z1+Ee7s7CyGhoaSinApioLVasWuXbtkvc5K4vf7MTk5iT179kCtVieZXxJ7pIWFBYyNjSESicRt9x542YajE16sLzXgkdsXkxRfOziAkYUAhhcCeL7fDoMGeP0NOyJPMIodtWY8/NoEN1yG4A7RohO0YgwL/pnx2T/3obHMiFv31uLN2yox5wmjtFALjUoFZyCKH704BlBAr9WL/7i4AVdsrkjquyT1hMTVOdWqnC9YkUgEVqsVnZ2dkrbtuShDyZeZosAqEDZiXeTz+TA8PBznXgukZw9O/pvYLiXHbDLxNfjJgtnZWdHHJyYPyK/schfhOhwOTE9PQ6/X4/Tp09x2yGKxZMV3aymQDPLWrVsFt51CMwFOT7nx8Kvj2L9Bhc0qP2xON0LhKBaci6tms9mM+iItRhbOPU+UBgbnfHAHY2AAnJgUH7ojdUnyb3OHYjg97UHfEx483WPDqSkPaJZFjaUAF7eU4OneefjCMRh1Kvz66BSu2Bzv78b3TOMjlYThr+6GhobQ2NiYlL3PxsjFbJEPK8dVIWw+nw+9vb3Ytm1bkk14OgNd1Gq1YLuUnLkH/Nvn5uYQCAS4ZIHU4/m3kcEty12EazQaMTc3h23btqGqqkqyn9Risaz4RKTh4WFUVlZKdp8Mzfvx8GuTuHZbBS5qKcMD/xjGoM2Ps7YA/nbnPjxQXYeXhx1oqy5EiZbGd/8xgldH3aBwToh0KsAZzCz+WlGoxrxfYlA2DRwedSISY8AAKNBEsLHChCKDBq2VhVBRwPsvXi/79cSSMPyV6+DgIAKBADeoR8ggMpdlKNl6jmyQ98JmMBjwgx/8AN/73vcEg99yR/AxDIPp6WkASPIdS2dSlc/n42Jz/F9CKWEjDrrA8okan8nJSej1eq4sQ6iflB//mZ6e5uI/iWUaYvMmMsXhcMDj8aCzs1Pyfj/85xheGXHg5KQbT320DJe3luPkpAfhGIOnzsxhX3MJjo+7cO/fB7F/cwWe6HMnNdsH5LcIJyElatzz815wZ10R9m8pxw28hMVS4a9cGYbBsWPHcMEFF0CtVnOJCpvNltL4IFFs0lnd5YtQpUteCxvLsvjnP/+Jjo6OpB5QgtwVm9PphM1mS2qXAuSZRcZiMa52LtHmR+rxpEA4cWzecuF2uzE3N5cyribku8W3RrLb7YKxraUMCIlGo+jv75c19f6KzeU4OeXGlZsXxfjfL1yPv5yahSMQwbEJJ77y5FkEowxYAL8/YU37WLLNq6N2vOmBV/H5azbire3CiRpnIAKaAcpN6f9YjI2NobKykvtxT5xEL2V8INYtImd1l04ZSj6R18L2X//1XygoKMDevXtF7yNH2FiWxfj4ODo7OwVXS0S4xCC39/T0oKmpKWnlKCVsJMBLTrLlhGRphdrC5CA0EYll2bitLDEZ1Gg0ScN9pV6TZVn09fWhublZ1lzMa9uqcG3b4opzzB6AuUADk16NcUcMfzhuRX542S5CAfCEFo/opYEFvLW9BvO+MO76fTcMWjW+/842OPxR3PHLU2BYFj+4ZTu2VMu3ivL7/Zifn8eePXtE75OqW4RkZslwl8RERTbKUBIfn0vyWth27twJo9EoaV2USthisRicTieamppEHWdTPYdarYbdbkdZWVncryRBSthomkZVVRX6+/sRiUSg1+u5uFY2x6Pxs7TZFFCKolBQUJC0QohGo9x2iJRpAMkdB6Qq32q1QqPRCM6NSCQQoXHg6UGYC9TY01CCrzzVDwrAvC+StfeVTfjJhReH7Ljsuy+jpqgAgzY/DFoV+ud8YFkgQjNgWRbTrpBsYSP9vZs3b077x0qsW4Q/X3ZycpKbL0u+O7LC418vcspQpqam8NRTT+HTn/50Wse5HOS1sO3fvx9zc3MYGRkRvY9ULygpTrVYLJI22qm2om63G9FoFI2NjWk9nohlc3MzF2uTWv0QwUunAJcwPj6eVEe1nGi1WtFgt8fj4RxVY7EYdDodfD4fWltbEQwGU3ZTHBtz4h/98wAoFOo1oBkW6jxZCaQiEGURiEax4I9CowI2Vxdhe60FGhWF/7ysASMLAextLJb9fFarFYWFhXErsaUiZ74s36E5cZKVUPyNYRh88YtfxPve976sHedSyGthA1KbTUpdIKOjo9wyO1XWU2zFRtqCSkpKRF9LrAg30bEj1eqHpPr5Bbj8rKVYiQixW8p1vZpQmQZN0+jq6sL69evh9/sxOzuLUCgEnU4X9/74F0xHfRE66opgLtDg3y+sx/pSAyoLdbjrDz3whFbCpjI7sCxwy3YL6EgY2oICnJ724J8DdvRavbjvrdtQWyy9JY9EIpyryHKTyqHZ5/MJ2lqRH6mzZ88iFArhuuuuW/ZjlUPawkYlD3SJu11soAsAPP3007jrrrtA0zQ+8IEP4O677075epmO4LPZbPB6vdixYwempqYyapkiyYKmpiY4nU7ZjycxtUR7bzGEVj+JwWCv1xs30IUIArBo8Z1pXG25GR0dRWVlJZqamuL+LuQDx8/sffua9ZyYv2V7NViWRVmhDt43hC1/SkGTKS5QwRVanLXwhb9N4PNOO2oKYpiZiyEUXayDe/fPuvDbOzpRWyJuPT8wMIDm5uacjr8Tc2gmZSj9/f343Oc+h5mZGbS1teErX/kKLrvsMlx55ZU5O2Yg/SlVSQNdent742YXiA10oWkaH/3oR/Hss8+irq4Oe/bswQ033JCVgS6JkJUPyb7JKedIvJ3ErJqammAwGLCwsCDy6GRhI0W4S8mAivnJ87OWo6Oj8Hg8KCwsxPT0NCd22WiczwZOpxNut1uwtEPKB44v5q/bInhxBmirNuJrV9YC2gIUmwrwy6NTePz0LCJ5OO/PzZutSjMs9BXrcWFbFTZuC+BHL47grz12RGMxdJ08jalCVVL7mFarhcPhQCwWW7HQQjrw58vW1tbijjvuwPj4OD7+8Y/j9OnTcLvduT7EtFdsSQNdHn/88R18cRIb6DI2NoYNGzZw8zlvueUWPP7441kTNuLZltguBaTOegptVUdGRmCxWFBRUYFgMCirHAQ4V4RLWrWySWLWcnR0FBaLBfX19UmZL36LDuk2WMkVHSntECqvEYOIuS2swQkvcN32DfiPB15BlGbRNevGw6fc6KxUY0MR8NQojcgS6tSWA51q0RiTxTl/X5VKhQqzDv5IDOUWI+65bhsu3eRAUYEGHfVFnBMKKZ4eGRlBJBJBOBzGunXrMD8/n1c/Vok4HA789Kc/xcsvv4yioiI0NDTk+pAApC9sSQNdSNErQWygi9Dfjxw5kvIF5UyqIismiqLQ3d2NlpaWJLPHdLaiNpsNfr9fVmcB/3byGjqdbtlFxOl0wm63cyUsQo3zROxGR0eTtnrk33LU1ZHSjqamJlmlHYl89NHX4fBH0GP1QqtabI0inLDROGHL4sFmkQgDWArU8ITiz7U7Hz2DplIjrt9RhSs3V+BNG8+tUoWcUIaGhgAAFouF+7EKhUJQq9VpldisBN/61rfwqU99KqvJjWyQrrAl/WSIVTUn3ifVoBcx5MTYyIppdHQUFRUVcdsbcrvc5IHP54vbxsp5PNnKCjl2LAeRSARnz57Fzp07RV9LbKvHX9kJdRtYLJYlx3SsVivUarWs0g4h6koMcAdjaCw1orbYiBF7AAALOp+K10Tgi9rehmJoVBReG3XijNWL/nkfnju7wDXtC+Hz+eBwOLBnzx5QFBX3YyVUYiPmhLIS9PT04MyZM3jooYdW5PXSIV1hSxrokmgzLTbQJRKJiA56kYKMipNCrVZzDhuJ7VLkdjkrtkw6C4BFgU7XsSNTWJZFd3c3Wltb014NqdVq0W4Dj8eDhYUFjI6OLsnwMhAIYGJiIqNMXiTG4ItP9EGrpvCz97Zj2zozNlQa8eOXxrGnoRi/PjaNSIzJ68QB4aot5Xj37lp0jbtxYtKFKAOoQKGuRPw749esCX3WUiU2Uk4o2ayX5L/u3Xffjfvvvz8vB8ukexUmDXS54YYb4u4gNtCloqICg4ODGB0dRW1tLR599FH85je/SfmCer0ekYh0YSZN01hYWMCuXbsEvzy5wkYyoOl0FgDggr3d3d1xGctsn0zAudhf4qo0U4TS/MQ40ePxxM030Ol0SRXribVMZGB1JgJ/ctKNQ4N2hKMMTky4cde/NuG9e+uxr6kUb/vxUURpBlo1ha9evwlffuIsYnmqcKVGLeY8Ydz5uzNQqVS4YUc16koMuKSlFBsqxc0+p6enufNHLkIlNkL1konGl0s1PvjrX/+K2tpaWfOBc0G6Mw+SBrps27Zth5yBLhqNBg899BCuvvpq0DSNO+64A9u2bVvyGyAtI1u3bk3L7DGRcDiM8vJywc4CKXEirVIXXXQRotEoPB5P3MnEb19ZahDfbrfD5XKlbCBfKnzjxMT5BmSYC98lhLw/t9uN0tLSjOMtW2vMaCkvRO+sF+EYgz+etKLUqMMvj0zC5g1DRVG4cUcVLttQhuc/eRGu+v8OIxTLv/2pIxCFIxB9Y2YqgzF7EF+9frPkY8LhMOdPt1TE6iXlGB+YTCbJYnZg8Zq799578be//S0vExoAQGXBHG5ZfzdZlsXOnTvx4osvJn2IsVgMJ0+eXByxtm6d6ECUUCiEgYEB7NixQ/B2m82Gvr4+XHbZZaJf1LFjx5JOOr4TrtgvH4mLEMEjQfzEIHCqX85wOIwTJ06gs7Mz5Ym3kpCLZXZ2FnNzcygoKODiPkKtVXJ4dcSBn786gTsurMfHH+tBJMagQKtCjUWPMUcQYIGHbtkOjYrC3X/pxbwvuozvMHN21plxZsYHrZrCsbsvg+qNc+vomBM/e3UCt++rx0XNi9vKM2fOoLq6WvCHdTnhlxCRf6T1j//98a2R7rvvPhgMBll1qCuA4AWb950HYkJD2qXq6+sRCARS9npKdRaQdqR0JwXJcewQK74lJ9HU1FRcnyW/j5Rs54g55qZNm/JK1IDFlXhhYSFcLhf27t0Lg8EQF/fht1aR4mIhS2w+FzWXchf8xS2leHHQjk9d0YKXh+0YnF+Mt/7qyCQOj7lw+cYyNJcb8eOXJ1b0ffPRqRYn2ofpxV95tQrYXmPCg+9ow/++Ool9jcWcqAHANw4OYMwexIQjiL/duQ8LCwtgGGbFRQ0QNz7gZ9WJNdLvf/97WK1WdHd34xe/+AX8fv+KzdFIl7wXNuBc1pEftxkdHYXRaER1dTXGxsYynllAkgU9PT2yj4eIWqZFuGJBfLJNIEOKaZqG0WjkgsGJ7S75wtmzZ9HY2Mg13/NXpCRBxHeacLvdmJycRDgchk6nixPzRHff77+j7Y3YmgrrSww4OuZClVmPYJQBw7J4dcSJd3SuQ4FmcRZGeIUKdm/bW4e37KjGgM2Ha9sqoVOrcGbKiU//sQ+OQBRGKoLhnlO4okQFEx3F5GSIe4/Xb6/CT14ex/Xbq0DTNIaGhrh5u/kARVGCHQdbtmzBRz/6UVx11VX4zW9+g89//vP4zne+g4svvjiHRyvMqhA2UqRLYjf8dikg/To14NyKjyQLSEmKnFUb6SzIZmmH2GSn6elpTE5Owmw248yZM4hEInEZS9Lgn6tYh9VqBUVR3KQtMcScJvhB7rm5OS7InbhVZ1kWhwbt2FpjxoEbt8AbiuEHL47i+rYqXLKhDN9521Y82jWNpjIDnulbyLoTyK17anFjezVuf/gkgjEGvzo2hffsrcVVWyvw0pADu9cXY0d9KR774F70Wr3Y1VAEvUbNdVN4PB6uxKZdy+AX15XAbAa6u7tRVVWVUb3fStPd3Y1QKIT/+Z//ydvYGmFVCJvRaITP50NRUVFSuxSQWtiEvoSRkRGYzWZu+U/ET2oFttJOuCSgvGvXLq42iT/qLTFjKbXyWQ6CweCSm7TF3H2J2JF6LVuAwe+6QqBZ4DeHR3HXFRvx/Xecm+P645fG0TfrxZkZLw598iLsve8l0My51ZsKEPRwo6jFZnUpNCoK/29/C/QaNd7UWo6ne21gWMAfpnH/c314adCOQr0a60uN+M5bt+KilnNhB6nWOJvNxjnHzM7OcnEti8UCk8mU89kUfGKxGL74xS/ikUceyfiYHA4H3vWud2FsbAyNjY34/e9/LxgXb2xs5IrHNRoNurq60n6tVSFsJpOJm0GZ2C4FLJ48pJVJDjabDT6fLy6ZkErY+G1Ty9EulQiJq23evDmu4FJs1JvUymcpdkhyji/btXsajSbJVicSo/GniZMYWQhiW9Fi0ohkpC0WC/bVG3B21otLW0qhU6uwzqLDpGtxLGOlWYd37arFE6etmPVGUGbUoMigxYg9iBjDwqBTwR+m47JgFIAigwYsC3zjhsUByu/9xQl0W71oKDWgo86CTdUmFGjUYAE4AzG4gh784eQMPvGvLZLvT6VSobCwEHa7HTt37oTZbJYs0RAzhVxJ/u///g8XX3wxNm+Wzu5Kce+99+KKK67A3XffjXvvvRf33nsv7rvvPsH7vvDCC3E/dumyaoTN6/UKtksB8lx0CSRZkNjDSJ5DLHunUqm4beByF+ECiwNPysrKRDO9iQitfITskPhtVWRlkMmFMjo6irKysrg44XKi06jxi9vjV4b8qVw3tMRwcZkFTNSNP75wDA7foqhRAFyBGP73lXF8+dpNuPGNmQQ0w+LbTw9iwhnAOztr8dczs3hrew2+/fQAZtxhaFQUfGEaGhWFYoMOwQiN09OLU66ua6vEnZcv9jx/84bNeGtHNf73lQmM2gO4equ8pvXJyUkUFxdz9WdSllZ8U0h+t0GmWed0cTqd+PGPf4yXXnppSc/z+OOP49ChQwCA22+/HZdffrmosC2VVSFshYWFeOaZZ3DLLbcIFqbKFTZ+siDxRJDTXeB0Ornl8XJuEebn5+Hz+ZYcUJayQyLbWFLLlM6F4nK54HQ6c+7/xh9lV11djY1YFLu3//gI/G94HmgogAIDmgFsc1ZMT9OwWCwoLCzEl65t5Z5r/5ZFMfmXTeWY84TRNe7EN/42CL1GheZyIwr1Gnzrhs04NenGe/eea77RaVS4sLkUFzaXQi6hUAgzMzOyatbETCFJ1pk0zi+lWyQVBw4cwF133bXkH7G5uTku81pTUwObTbjpl6IoXHXVVaAoCh/60IfwwQ9+MO3XWhXCNjY2hmAwiM9+9rOCt6cykgTOJQsaGxsFU9RS4kjcc51OJwYHBxEMBpctphUMBjE8PIzOzs5lEU+xmE9ieQZ/m8cvz4jFYpz/W77Ef/iwLIsLymPoswEqCvjuO7ZhY6UJs64ANhRR3Iqdb+bJX71qNBpUWfS4bns1N3OBvM8bdlTjhh1Ln0LV39+PjRs3ZrylFOs2ILFXMZeXTMIRvb29OHHiBL7//e/Luv+VV16J2dnZpL9/61vfkv2ar7zyCtatWwebzYb9+/dj8+bNuOyyy2Q/HlgFwnbo0CH09PTgnnvukewsSLVii0ajKC0tFfW3SmXvXVxcHLdajEQiXNEtmTOq0Wg4Iciky0AsrrbciJVnCFlFR6NRWCwWeDyL27J8s9MZHx/HzTtr8MFr1yMUo1FtWcw2NpQuhi9S+b/xzTzJ95jN78Jms0GlUmWtJY4gFntNHMScKOiJNZN8GIbB5z//efzXf/2XbBF+7rnnRG+rqqqC1WpFTU0NrFar6LVIzsHKykq89a1vxdGjR9emsL3vfe+TTA6k2orabDYwDBNnm5SIkDgSe28hJ1ydTofy8nLBmJbH4+GsgvjBX7IFEhO7wcFBVFZWrljcSorEbR6wWNphs9lQU1PDiQFZvUr1kK4UxMZ99+7db3zG0nEnsclOZPXqcDgwPj6e1FRusVgyEvRYLIbh4eEV3cILDWLmCzq/ZpJsZbVaLWKxGLq7u1FdXY2LLrooK8dyww034JFHHsHdd9+NRx55BDfeeGPSfchgGWJX9swzz+DLX/5y2q+V9y1VAPCTn/wELpcLH/nIRwRvj0Qi6O3tFYxJ+f1+9Pb2QqfTobW1VXSCE2kuJ0JF2qVUKtWSfrH5pQsejyfJM55sgex2O2ZmZvJ2ixcMBnH69Gns3r076dedX6Xu8XgQCAS4hmv+zIblzCQzDIOuri5s2bIlbouWDUjGkqzQvV5vRtu8/v5+mEwm1NbWZvX4sgF/hd7X14evf/3rGB4eRltbGy644AJcfvnluOaaa5b0Gna7He985zsxMTGB9evX47HHHkNpaSlmZmbwgQ98AAcPHsTIyAje+ta3Ali8dt7znvfgnnvukXra1dlSBSxmRRMNLfmIrdhIsmDLli0YHx9PqzuBpmlQFLXkDKhQ6UJiAJ8IXkVFBVeMK7Y9yAXEtUOstEPI+02oFg2AYEwrG4yNjaG8vDzrogbEZyzFzDzHxsYkzTzdbjc3qSsfSVyhd3V1QavV4o477sCpU6cQCoWW/BplZWX4xz/+kfT3devW4eDBgwAWJ7qdPn16ya+VH1dOClLZg0t1FjQ0NHAlDXL7Scl/l6sIl78FIiuNXbt2Qa1Ww+PxxG0PiPMCWfnkYrDH2NgYSkpK0toiiwk6Gc/Hj2kt1eiSeJGtxDQnPlJzG/idBjRNc1bfDodjRc0gM2FmZgZ//vOfcfjwYRQUFODNb35zrg8pbZYkbBRFlV555ZUpK4nFplN95jOfwV//+lfodDq0tLTgF7/4heDFQwp0JY4j6W+jo6MwmUzcL6zctiuhsXnLycDAAKqrq7n3zV9x8J0X+Gl9o9EYl6RYzovE5XLBbrdnJS7EHwJC4L/HRKPLxIys0PfMMAz6+vokbatWEqG43ejoKEKhxV7RbJh5Licsy+JLX/oSvvrVr2bU5pVqEp3UFLtsstQV292pKomlplPt378fBw4cgEajwec+9zkcOHBAsGAv3UlV8/Pzcb2kgDx770gkIsuxI1vMzs4iHA5j06ZNosck5LwQDAbh8XjgdDrjgtt8sctG/yi/tGO5REPqPSY2zPNbjoiRJ7GDz1eDgGAwiLm5OezduxcqlSruPYq1xuUyEXPkyBE4nU4kGsjKQc4kOrEpdtlmqcJ24+233w5AvJL46NGjotOprrrqKu5++/btwx/+8AfBFzGZTFyMJhV+vx+jo6NxvaSAvH7SpTh2pIvf78fY2Jio668Y/GZykq0Uu0iEhCCd1zp79iwaGhpEEy7LhVTDPN/I0+fzcVu8mZmZnEzjkoJYfbe2tiYdk1R5Bonb8c08ExMxy3GO0jSNL3zhC/jZz36W0Wcoda0TxKbYEcHPFksVtqpUlcRyp1P9/Oc/x7ve9S7BF5G7YovFYiBzTtPtLNBoNJifn49z2Vgu1wyaptHT0yN4nJkg1T9KhECoNIMIgdB7nJ2dBcuyWT/hloJer0dFRQUqKirAMAyOHTuGbdu2gWGYuBKblRKCVNhsNq7cQi5iiRgh59tst1X96le/wgUXXJCxs7Wca11sit2KCxtFUc8BECq3lszBEuRMp/rWt74FjUaDW2+9VfA5zObUA12Axak5JFmQiNSKjaZpFBUVoaOjgwv8Tk1NcdsfInTZioP09/ejpqYmLW/7TOALAUHI3juxWV6tVnOryXxlZGQEVVVVXGxyKUaey0E0GsXIyEhWEhoajUbQv0+qrYq8T7k/zi6XC//zP/+DF198MePjlHOtZzqtLl1SfrMsy4rOqqcoas5qtRZJVRKLTa0iPPLII3jyySfxj3/8Q/QNyhnBF4lEUFxcLFrNLOYAwrf3LigoQGFhIbf9SaxfEtripVusabVaQdO04DStlUBoRcBvlh8bG8P8/DwKCgowNDQUV5qRL1s8El8UEw0xI0+SkU008uQLQbYSMUNDQ2hsbFy2LLZYWxU/Njk1NRVnaUVWsUKr9HvvvRcf+9jHZJsuCJHqWpd7n2yw1J+sJx555JH/J1VJvGfPHtHpVE8//TTuu+8+/POf/0xy7OCj1Wol42Pz8/MZdxZIjc0Tq18iYkfKFhJ7Ry0Wi2A8y+/3c/5luc5+8eE3yxNn4sbGRtE6NP6qZ6W3eCQL2tbWltZnKCYEZPSg3W6PG13Hf4/prtJdLheCweCSLH4yQY6ZJ3+VbjKZ8PLLL8NiseDIkSP43ve+t6TXl7rWCWJT7LLNUoXt3mefffb//exnP+MqiQHEVRJLTae68847EQ6HsX//fgCLCQQy8SoRlmUFHW5JsoDUhIkhtBUlnQXpbkmEtnjk5CErgkAgAK1WG+eF1tfXlzSzNJ9wu93cGEOVSiVqX04EfWBgYFliPVKMjIyguro6K177/KJUOdlKOaYHDMOgv78f27dvz5sfLykzT4fDgYcffhjhcBj79u3D1q1b8dBDD2VU6Cx2rcuZYpdtVkVLFQC0t7fjpZdeijtZyJSqLVu2YHJyEnV1daJfiNPpxMLCAjZu3AgA3LZUp9Mt2xaLH8+amlr05Cf1WXzBy4cLIBaLoaurCzt27JBcPSfCj/WQLftybfHcbjcGBwfTziRnA/6qx+PxJJlAkj7g8fFxAEBTU9OKHl+mHDx4EH/605/w61//muvU2bFjR96EHWSweluqAOEgZKadBStl703iWeFwGCUlJdi2bRtisRgnAGLB+2w63cqlv78f69evT0vUAGlnELLFEyq6JVlnudA0jbNnz6a9Bc0Wcow8ieBVV1fHtcbl46R0YFGsv/nNb+LJJ58ERVHQ6XSyPQBTFeIeOnQIN954Iyfwb3vb2zJqZs+UVSNsWq2Wm3cILFZzFxYWyu4sILfLHZuXLXw+HyYnJ7m4mlarFQ3eezyeuJ5DfoJiOcVubm4ONE1nLdYhtsUjgW2Xy8UV3RLXjFRZ55GREdTU1OTVuDd+bJJlWZw8eRKbN2/mWuNISxVpG+NvZXPRGpfID37wA9x8881pJ7LkFOICwKWXXoonn3wym4csm1UjbEajEX6/H3q9XrSzIFXLFE3TXLJgJU6sWCyGnp4ebNu2Le3ZoyQG4vF4kmy9idhlI1MZCoW4soTlXAkJBbbFss6JiZhIJAK3253X5Sezs7MwGAzcdyhm5Dk/P580Z5VfmrGSx/vYY4/h8OHDaT9WTiFurlk1wka6D/R6fUadBeT2TJIFmcCyLPr6+lBfX59Ru49YEzkRu4mJCc40kB/nSacYlWVZzrUjFysIqawzf6iJ3W6HyWTCwMBA3sUmgcVY6tjYmGj5iVRGNtHIMxu+b6lgWRZf/vKX8ZWvfCWjrhK5RfevvfYa2tvbsW7dOtx///0ZF/5mwqoTtrm5OcGK/VT24BRFIRgMor+/n1vxWCyWZRO56elpqFSqrNboCNVniRWjyinLGBsbQ1FR0ZJql5YDfjxrYGAApaWlnLmlx+PBwsJC2iaey8ng4CCam5vT+nEQMvLkT6rilxLxs+vZEPWjR4/CZrPhpptuyujxcopsOzs7MT4+DpPJhIMHD+Kmm27C4OBgRq+XCatG2IxGI37zm9/gYx/7mGhnQSQiPCSXCN6+ffu4rQ/f259vDZQNsSOe8yuxdRITO9KCMzMzA6/Xy002Iu+RZVmutCNfcblc8Hq92LhxIyiKEt2uk+C9mInncsZSHQ4HIpGIaGF4OohNqhLrH01cqcsRddIP+tOf/jTjHwE5Rbb8rpprr70W//mf/4mFhYUljdRLh1UjbMPDw6ioqIgrPOQjthUlnQUkrqbVamEymbgvgtjmZEvsSFxt+/btOcuGiQ1s4ZtbkphQb29vXJwnX2rsSBZUylFYjoknv68y2+1UDMNgYGBg2V2Ps2nk+etf/xq7d+9GW1tbxscjpxB3dnYWVVVVoCgKR48eBcMwWZ/zIEV+nMUpeOKJJzA9PY0Pf/jDovcREzYSV5MahExsc5YqdqkmYeUSfnO/2+3Gli1bUF1dHddmNDg4GGf8mEtzy6GhIdTW1qYdA5ISdRKzy9b7HB0dRU1NzYq7nwDpGXkajUYcP34cRqMRDz300JL6QclrpyrE/cMf/oAf/vCH0Gg0MBgMePTRR1c0JroqCnS/+c1vIhgMoqWlBe94xzsE7+N2uzE3NxdnvZzNIly+2PELUflpfK/Xi0AggC1btizptZaTubk5zM3NiVbGC73PWCwW9z4zcblNB6fTiZGRkWUbQQjEv08S0yKZSjkmnn6/Hz09PbzBMfkJeZ+PP/44fvvb32J6ehoGgwFNTU34xje+saSVW54geIKsCmEDgO9///tQqVR43/veJ3g7CZ4TUSE1a8vZWcC/OBYWFrCwsACDwRC37VnOBEW6hEIhnDx5Ert3705LmPiTm4gQLJeTL03TOHbsGNrb21d8JcTPVJL3KmTiqdPpcOLECbS2ti67Q0u2GBgYwIc+9CG88sorUKvVGB0dRVlZWdzKdpWyujsPTCaT6ORoILmzgDh2LOevKdnG6vV6TExMYN++fSgoKBDdxuZS7Ehpx6ZNm9JebZGAfKLLLXmfDocDY2NjS+4uABYzjHV1dTnZ3ollKhN7R71eLyiKgs1mQzAYXLayjGzBsiy+8IUv4L777uPOO1KDloo77rgDTz75JCorK9Hd3S343Cth9Z0uq0rYRkdHRW9P7CwQc+zINiSu1tTUxLUjpROzWymxGx8fh8ViScv0UAqp7gKPxwOXy4WJiYm4FQ+/u0AIh8OBQCAgapWeCxJNPCORCI4fP44dO3Zwq7t0TTxXmr///e+wWCx405velPZj3/e+9+HOO+/EbbfdJnj7Sll9p8uSrySHw4F3vetdGQ90Idx///34zGc+g/n5ecGUcKqBLkTYVrIIFwAmJiag1+tFs7VA+gmKbIsdeY3lnuIkZVvu8Xji5hfwW6ksFgvUajUGBgbQ0dGRF2IgRn9/P1paWjhRT9fEc6Vr7cLhML7xjW/g8ccfz+hzveyyyzA2NiZ6+0pZfafLkq+ae++9F0sZ6AIAk5OTePbZZ7F+/XrR15Ezgm+5x+Yl4na7YbPZMqoFExM7EsvKltjRNI3e3l5s3749J0Fu/opHqJWKbO/cbjd0Oh2mpqaWtep+KdjtdjAMI1qzlsrEk98al0kNWib88Ic/xE033SR5bS2FlbL6TpclC9vjjz+OQ4cOAchsoAsAfPKTn8R3vvMdQaNKghwX3Wg0ylXTL/dWIBqNoq+vL6sTnIScMlKJXar6s/7+ftTX1+dV+UliKxWJ0W3ZsiVuJie/bzTTgTTZgqZpDA4Oyna/IAj1AfNb45bTxHN2dha/+93vMuoHlctKWX2ny5KFbW5uDksZ6PLEE0+gtrYW7e3tkq8jtWIjcbVdu3ZxMZ75+Xn4/X6uHYX8y8aFwbIsuru70dzcvOxB7lRilzhcmS8CDocD0Wh0WayXs0UsFuO2oAUFBTAYDEkGnmIDacj7XIlY1sjICGprazOatZmInG6RpQ5sYVkWX/3qV/HFL35xWc/RlbL6ThdZwiY10EVOulhM1QOBAL71rW/hmWeeSfkcZrNZcAQfETWVSgWtVguj0Ri3FeDHPYizLX8VkMmWZ3x8PM4yaaWRI3b9/f3w+/0oLy/HxMRE3nUWEAYHB7F+/XpRwRAbSEPEju9WzI/ZZVPsiNXScsYoxQqLhVbrckw8jx8/junpadx8883LdszAyll9p4uss1xqoMumTZu4YGG6A12Gh4cxOjrKrdampqbQ2dmJo0ePcsFngtikKpIsEIurCcU9yIXBbzTmT6OSGr3ncrkwPz+fdz2WfLGrqanBiRMn0N7eDr1ezwkAv+JezjZ2ubHb7QiFQmnPBtDpdCgvL49LMokF7vmxyUxmjpLZoJs3b17xLVY6Jp5E7Obm5lBdXY3Pf/7z+OEPf7jkMMm73/1uHDp0CAsLC6irq8PXvvY1rvB9Ja2+02XJBbqf+cxn2LKyMi554HA48J3vfCfuPrFYDK2trfjHP/6B2tpa7NmzB7/5zW+SbEwaGxvR1dUlmBWNxWLYs2dPXDtINotw+bVKHo8HoVAoKXOnUqlw/Phx7Ny5MytbkuWC1JQRG3Q+iVbeHo8nJ2IXi8Vw7NixZf0s+QaeHo8nLksp1xFkcnISoVBI8LPMF/gmng8//DAef/xxTE9P44ILLkBnZyfe8573rPhgmRVkeToP7HY7+853vhMTExPcQJfS0tK4gS7Aorf6Jz7xCa637J57kseSSgkby7Lo6OjAyy+/DOBcEa5Go1mWizAxc+d2u+F2u1FYWIjy8vK4lV0+4fF4cPbs2bRaffij6YgQLLfY9fb2ori4eMXjMXwDT4/Hk+RWbDabuSxlKBTCqVOnsGfPnry1907E6/XiyiuvxAsvvIBgMIgTJ05g8+bNeVUbmGVWd0sVEbaXXnoJLMty9t4r1aA9OjqKWCyGuro67qIgLTf8AS3Zai3KBNKOtH379iVnQZdT7BYWFjA1NbXsrhhy4TtleDweriQjHA6joqICNTU1MJvNed0TSvjyl7+MpqYmfPSjH03rcak6DHI9w0CC1d1SRVEUdxGkcuzINg6HA3a7HZ2dnVCpVEk1WSQTy28tIn2U5N9KCPDAwADq6uqyUtoh5PoqNnQ4HbGLRqMYHBxc1gb3dBFyypibm8PU1BQKCwsFDTxXwustXQYHB/Hiiy/i3nvvTfuxqToMgNzOMEiXVSNswKKIRKNRbijKSvyChsNh9Pf3Y+fOnYKvJ1Ztz2+OHxkZ4bJZfAHIptjZbDZEIhHU1tZm7TkTkSN2qRIUAwMDaGxszLstPJ9YLMbZz/OPM9Hrzev1Aoj3QMvVVCqWZXHPPffgO9/5Tkar6FQdBquNVSVsBQUFCIfDK7YtIPVqra2taQW4xfooiQBkUmgrRTgcxvDwcE7mbaYjdhqNBtFoFDU1NVwoIR8ZHh5GXV1dkvimMvBMrD/LtrGlFM899xwMBkNG/aByyeUMg3RZNTE2AGhoaEBLSwsuuOAC7Nq1C52dnZxL53IwPDwMAGhpaVmW50/0PiNxLP52J9UKgIx9a2hoWFGH0nQJh8Po6upCXV0dt3XPp9ITgsfjwcDAwJJ+JPjCTmKUiSP4sml6EIlE8K//+q/485//jIaGhoyfZ2xsDNdff71gjM3j8XBtgAcPHsRdd921ojMMJFjdyQNg8YQZHx/HsWPHcOzYMRw/fhzz8/NoampCZ2cnOjs7sXPnTpSWli5Z7Ox2O8bGxlY8FiR2UfDLTvixnfHxcYTD4TiDzXyku7sb5eXlcfWJYu81cWu3UmLHMAy6urqwdevWjCaLpXruRE+7bIUn/vu//xt+vx9f//rXl3SMUsKWiFQFwwqz+oVNCIZhMDg4GCd2Ho8HGzdu5FZ1HR0dMJvNsgWKGDJ2dnbmRSyIv90hFwUArvi2ra0NRUVFeZu1m5+fx8zMTMq2OSC3Yjc+Po5oNIoNGzZk/bmF4Icn+C6+iZblUll2m82GG264AYcPH+ZsszJFStgSZxi8/e1vx/j4eD4kgNamsAkRi8XQ19eHo0ePoqurC6dOnUIoFMKWLVuwc+dO7Nq1Czt27BDsG2UYBidPnkRTU1PWvMuWg0gkgq6uLlRWViIcDnMzRrM9UHmpRKNRdHV1YdeuXRmXwayE2AWDQZw+fTrnNWv8xBMRO35nAb+kiGVZ3Hnnnbj66qtxyy23LOl1+R0GVVVVSR0GDz30UNwMgwceeAAXXXRRNt7yUjl/hE2ISCSCM2fO4OjRozh+/DhOnz4NhmGwfft2Tuy2bduGAwcO4KqrrsqXL02Uvr4+mM1m1NXVcX/ju0bw67H4F8RK+4F1d3dLThfLlGyKHcuyOHXqFBoaGvLyx4xfUkS+3wMHDsDpdGJhYQEPPPAA9uzZk9SGeJ5wfgtbIuRkOXXqFI4dO4auri4cPnwYNE3jiiuu4LaxmzdvznlAO5H5+XlMT0/LKnAVq7Tn19gt11R1m82G2dlZ7NixI+vPLUSmYjc3N4eFhYW8zvIlEovFcNNNN+Gaa66Bw+HAiRMn8MlPfhJvfvObc31oK40ibFJMTk7i+uuvx5///GdMTExwMbv+/n6YTCZ0dHRwCYoNGzbkbLsSDodx4sSJJW3tYrFYXCaW3zCeLXcMYqG9lOPMBqnEzmg0YmhoKOfHmS6//e1vcezYMW7knVwmJydx2223YXZ2FiqVCh/84Adx1113xd0nX+cYiKAImxRHjhxBLBbDxRdfHPd3lmXhcDhw/Phxbhs7NDSEsrIyTug6Ozuxfv36Zd/iLWdpRzQajdvqLNXL7syZM6iqqsqZtZMUfLEbHx/nauxylY1NF5/PhyuuuAIvvPBC2llJq9UKq9WKzs5OeL1e7Nq1C3/5y18401dgsa/7v//7v3Hw4EEcOXIEd911V17MMRBBEbZswbIs5ubm4jKx4+PjWLduHXbu3InOzk7s3r0b1dXVWd3iTUxMIBgMrlhDM98KiKzs5HjZzc3NwWazYfv27StynJnicrkwPDyMzs7OuAxl4spuJQtt5fCVr3wF9fX1+PjHP77k57rxxhtx5513Yv/+/dzfPvShD+Hyyy/Hu9/9bgCL1mSHDh3KC581AVZ3r2g+QVEUqqur8Za3vAVvectbACyuAqampjix++lPf4rZ2Vk0NjbG1diVl5dnJHZkivlyD2Thk4mXXUFBAUZGRvLOry4RhmHQ39+PtrY2rg+ZiBdpS+Ov7PgT5HMpdiMjIzh06BBeffXVJT/X2NgYTp48iQsuuCDu7/k6xyAdFGHLEiqVCuvXr8f69es511KGYTA8PIxjx47hxRdfxPe+9z04HA5s3LiRy8R2dHSgqKhIUuzIQJZt27blvHxDyOSRb+/U19cHlUqF7u7upJVdPjE+Po6KigpJwwB+u1g+iB2ZD3rgwIEl9xn7fD7cfPPNePDBB5OGPufrHIN0UIRtGVGpVNi4cSM2btyI97znPQAWRers2bM4duwYnnrqKXzzm9/kZmmSlV1HR0dc8P7IkSOor6/PejV8tiD23TRNo6ysDNu2bYsTu6mpKW7kXqJLcS4IBAKw2WzYs2dP2o/Npdi98MIL0Gg0uOKKK5b0PNFoFDfffDNuvfVWvO1tb0u6PV/nGKSDEmPLA6LRKLq7u7nkxKlTpxCLxbBt2zZYLBa8/vrr+Mtf/pKT6ehyIdna3bt3C64m+PNFc+llRxIwzc3NccNUso1UNjYTsYtEIrjiiivw2GOPyZ7iLgTLsrj99ttRWlqKBx98UPA+Tz31FB566CEuefDxj38cR48ezfg1lxklebCaCIVCeP755/Ef//EfuPzyy3H27FmoVCq0t7dz29gtW7asmNGmFCzL4vXXX8e6devihq7IeRwpPCX/ltvLzmq1wul0xmUBVwo5YkeGRyfygx/8AG63G9/85jeXdAwvv/wyLr300rg5s9/+9rcxMTEBYLHLgHQ0PP3009wcg5WM7aaJImyrjdtuuw233norrr76ai5rd/z4cXR1daGrqwt9fX0wGAzo6OjgxK61tXXFa+xmZ2dht9uzUuDKbyki/0j/5FKbxUl7l9iqMhekEjuSbb/11lvx2muv5dV82DxBEbbVhs/nk4yrsSwLl8uF48ePc90Tg4ODKC4u5oRu586daGpqWrakQ6otaDYQahbPxMuup6cHZWVled96RMTO7XbjS1/6Eo4dOwaWZXHZZZdh165duPXWW/PaomqFUYTtfIBlWczPz6Orq4uL2Y2NjaGqqoqrsdu1axfWrVu3ZLFjWRanT59GXV3ditvXpOtl53Q6MTY2ho6OjlWV4Tt16hS+8IUv4Omnn0ZfXx+OHz+OG2+8Ma0t/xpHEbbzFZZlMT09HSd2pFaJrOp27dqFioqKtC76XMarhJDa1jmdTmzatAllZWV5NadACoZhcN111+F73/te2i1Nclqn8nhASzoowqZwDoZhMDY2xlk7dXV1wW63o6WlJW4bW1xcLCh2xLNuz549eVGNLwbDMDh79iyi0Si0Wm3cnAL+yi7X9YFC/P73v8crr7yCn/70p2k/Vk7r1KFDh3D//fevmgEtIiidBwrnUKlUaG5uRnNzM+flRdM0BgcHcfToUTzzzDM4cOAAfD4fWltbk2rsvv71r+MTn/hEXosasOiz5vP54uas8oey8CdQJboU51Ls/H4/HnjgATz33HMZPb6mpobrFDCbzdiyZQump6fzZnW93CgrNgVJYrEYenp6uOTEqVOn4Ha7UVRUhHe84x3o7OzEjh07BHtGcw3Lsjhx4gQ2bNgQN4BFiHzzsvv617+O6upqfOITn1jyc42NjeGyyy7jukEIhw4dws0334y6urpVMaBFBGUrqrB0pqencd111+HBBx9Eb28vjh07hjNnzgAAtm/fzq3stm3blnMbIDIib/PmzRk9XsjLTq1WJ4ldtgV9bGwMt912G1577bWstE696U1vwj333JPUZZDHA1rSQRE2haXz6KOPoqKiIq6th9SenTx5knM76enpgU6nw86dO9HR0YHdu3ejtbV1xbauxA8u2zHA5fayY1kWt956K/7zP/8TV1111ZKONRqN4vrrr8fVV1+NT33qUynvn0cDWtJBETbC008/jbvuugs0TeMDH/gA7r777lwf0pqDZVl4PJ64GruBgQGYzWbs3LmTS1C0tLQsy/auu7sblZWVK+IHF41Gk1Z2mXrZHTp0CD/5yU/w5z//eUkrQTmtU3k8oCUdFGEDFmMpra2tePbZZ1FXV4c9e/bgt7/97XkTVM0lLMvCbrejq6uLE7uRkRFUVFTE1djV1dUtSezsdjumpqZkTcVaLjLxsotGo7jiiivw6KOPLnlSlpzWqTwe0JIOirABi9Osv/rVr+Lvf/87AODAgQMAgM9//vO5PKzzFpZlMTs7i2PHjnE1dpOTk6itreVWdbt27ZI9GJumaRw7dgwdHR15Z5XE97LzeDycl10wGMTw8DBmZ2cRCoVw77335vpQVxNKuQcgbKKXx7bHax6KolBTU4MbbrgBN9xwA4DF2jP+3Ikf/ehHsNlscaadnZ2dgoOxR0dHsW7durwTNUDcy663txddXV14+umnUVxcjNdffx0XX3wx7rnnnhwe7ermvBO2tWCit9ZRqVRobGxEY2Mj3vGOdwBYFLuhoSEcPXoUL7zwAu6//3643W5s3LiREzoA+NWvfoWf/OQnuTz8tNDr9di5cycefvhhHDhwAO9973sxPT29GrOTecV5J2xrwUTvfESlUqG1tRWtra1473vfC2AxQ3n27FkcPXoUTzzxBB577DFs3LgRH/jAB7htbHt7e1pDaHLB66+/joGBAfz4xz8GRVGoq6uLmxcrRSgUwmWXXYZwOIxYLIa3v/3t+NrXvhZ3n1U2dSornHfCtmfPHgwODmJ0dBS1tbV49NFH8Zvf/CbXh6WQARqNBm1tbWhra0M4HIbJZMK3vvUtnDlzBseOHcNvf/tb3H333WAYBm1tbdzKrq2tLWfuvYkwDIO7774b3/3udzNKmOj1ejz//PMwmUyIRqO45JJLcM0112Dfvn3cff72t79hcHAQg4ODOHLkCD7ykY+s+fDLeSdsGo0GDz30EK6++mrQNI077rgjL6qt77jjDjz55JOorKxEd3d3rg9n1VFeXo7bbrsNOp2OSzgA58wsT58+jWPHjuEnP/kJenp6oNFo0N7ezond5s2bc+LR9qc//QktLS0ZD7+hKIqztopGo4hGo0mr08cffxy33XYbKIrCvn374HK5YLVaV9VwlnQ577Ki+cqLL74Ik8mE2267TRG2ZYZlWXi9Xpw4cYIrOzl79iwKCwvjauyWezC23+/HFVdcgWeffRZVVVUZPw9N09i1axeGhobw0Y9+FPfdd1/c7ddffz3uvvtuXHLJJQCAK664Avfdd18+u+Kmg5IVzWcuu+wyjI2N5fowzgsoioLFYsHll1+Oyy+/HMCi2DmdTm4w9je+8Q0MDQ2hpKQkLhPb0NCQtYLi733ve7j99tuXJGoAoFarcerUKbhcLrz1rW9Fd3c32trauNvPx4SZImwKCli80EtLS7F//35ueDDLsrDZbFzZyaOPPspZdXd0dHBb3pqamrSFYmJiAn//+9/x2muvZe09FBcX4/LLL8fTTz8dJ2znY8JMETYFBREoikJVVRWuv/56XH/99QAWxW5ycpLrnvjf//1fzM7OYv369XErO6nB2CzL4p577sE3v/nNJRsFzM/PQ6vVori4GMFgEM899xw+97nPxd3nhhtuwEMPPYRbbrkFR44cQVFR0ZqOrwGKsCkopAVFUdxgbOKWwTAMRkZGcOzYMbz00kt48MEH4XQ60dLSwgndzp07ucHYL730EqLRKN785jcv+XisVituv/120DQNhmHwzne+E9dffz1+9KMfAVhsnbr22mtx8OBBbNiwgZs6tdZRkgd5xNjYGK6//nolebAGoGka/f39nEPxiRMn4Pf70draiq6uLjzzzDPYuHFjrg9zLaD0iuYz7373u3Ho0CEsLCygqqoKX/va1/D+978/14elkEWi0ShOnTqFF154AZ/97GdzfThrBUXYFOQjZxiIgkIeIChs+TfBQiEv0Gg0+O53v4u+vj4cPnwYP/jBD9Db25vrwzpvCYVC2Lt3L9rb27Ft2zZ85StfSbrPoUOHUFRUhI6ODnR0dODrX/96Do40P1CSBwqCnO/DQPINOa1TAHDppZeu9qlTWUFZsSmkZGxsDCdPnsQFF1yQ60M5b5HTOqVwDkXYFCTx+Xy4+eab8eCDD8ZNOFJYeWiaRkdHByorK7F//37BH5rXXnsN7e3tuOaaa9DT05ODo8wPFGFTECUajeLmm2/GrbfemjThSGHlIa1TU1NTOHr0aFJZUGdnJ8bHx3H69Gl87GMfw0033ZSbA80DFGFTEIRlWbz//e/Hli1bZE04Ulg5+K1TfMigZwC49tprEY1GsbCwkItDzDmKsCkI8sorr+CXv/wlnn/+eS7LdvDgwVwf1nnL/Pw8XC4XAHCtU4nzUmdnZ7mG96NHj4JhGJSVla30oeYFSlZUQZBLLrlE0BUi18hxjF2LyGmd+sMf/hA3derRRx89bxMMSoGuwqqCZVn4/f64sofvf//7SWUPCucNSoGuwupHKXtQkIMibAqrDjllDwrnN4qwKaw6UpU9KCgowqawahEre1BQUIRNYVUhp+xBQUEp91BYVYiVPSgo8FHKPRQUFFYzSrmHgoLC+YEibAoKCmsORdgUFBTWHIqwKSgorDkUYVNQUFhzZKPcQ2nUU1BQyCuUFZuCgsKaQxE2BQWFNYcibAoKCmsORdgUFBTWHIqwKSgorDkUYVNQUFhz/P/Eeg3y3JW5dQAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from mpl_toolkits.mplot3d import Axes3D\n", - "from sklearn.datasets.samples_generator import make_blobs\n", - "\n", - "X, y = make_blobs(n_samples=10000, n_features=3, centers=[[3,3, 3], [0,0,0], [1,1,1], [2,2,2]], cluster_std=[0.2, 0.1, 0.2, 0.2], \n", - " random_state =9)\n", - "fig = plt.figure()\n", - "ax = Axes3D(fig, rect=[0, 0, 1, 1], elev=30, azim=20)\n", - "plt.scatter(X[:, 0], X[:, 1], X[:, 2],marker='o')\n", - "\n", - "\n", - "from sklearn.decomposition import PCA\n", - "pca = PCA(n_components=3)\n", - "pca.fit(X)\n", - "print (pca.explained_variance_ratio_)\n", - "print (pca.explained_variance_)\n", - "\n", - "\n", - "pca = PCA(n_components=2)\n", - "pca.fit(X)\n", - "print (pca.explained_variance_ratio_)\n", - "print (pca.explained_variance_)\n", - "\n", - "X_new = pca.transform(X)\n", - "plt.scatter(X_new[:, 0], X_new[:, 1],marker='o')\n", - "plt.show()\n", - "\n", - "pca = PCA(n_components=0.95)\n", - "pca.fit(X)\n", - "print (pca.explained_variance_ratio_)\n", - "print (pca.explained_variance_)\n", - "print (pca.n_components_)\n", - "\n", - "pca = PCA(n_components='mle')\n", - "pca.fit(X)\n", - "print (pca.explained_variance_ratio_)\n", - "print (pca.explained_variance_)\n", - "print (pca.n_components_)" - ] - } - ], - "metadata": { - "interpreter": { - "hash": "c2a0d16ab2ef21d9ffd61da4743bf5eccc7864478b6988e54f4be7517ca730a8" - }, - "kernelspec": { - "display_name": "Python 3.8.5 ('base')", - "language": "python", - "name": "python3" - }, - "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.8.5" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} From af0590751ad7c4417ff7ddfeb0ce0e13c07d71dd Mon Sep 17 00:00:00 2001 From: Christina Yu Date: Thu, 28 Jul 2022 21:18:26 +0800 Subject: [PATCH 4/5] Update Model_development.ipynb --- Model_development.ipynb | 67 +++++++++++++++++++++++++++++++++++++++-- 1 file changed, 65 insertions(+), 2 deletions(-) diff --git a/Model_development.ipynb b/Model_development.ipynb index a91e206..f9676ba 100644 --- a/Model_development.ipynb +++ b/Model_development.ipynb @@ -80,7 +80,7 @@ "source": [ "import pandas as pd\n", "import numpy as np\n", - "data = pd.read_csv(filename) #Change filename" + "data = pd.read_csv('/Users/christinayu/Desktop/AppleWatch.csv') " ] }, { @@ -807,7 +807,70 @@ "pred = xgb_r.predict(test_X)\n", "\n", "rmse = np.sqrt(MSE(test_y, pred))\n", - "print(\"RMSE : % f\" %(rmse))\n" + "print(\"RMSE : % f\" %(rmse))\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## ROC and PR Curves\n", + "\n", + "Interpret the results of classification using Receiver Operating Characteristics (ROC) and Precision-Recall (PR) Curves in Python\n", + "\n", + "Sensitivity: The probability that the model predicts a positive outcome for an observation when indeed the outcome is positive. This is also called the “true positive rate.”\n", + "Specificity: The probability that the model predicts a negative outcome for an observation when indeed the outcome is negative. This is also called the “true negative rate.”" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'plotly'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mimport\u001b[0m \u001b[0mplotly\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexpress\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mpx\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mpandas\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0msklearn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinear_model\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mLogisticRegression\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0msklearn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmetrics\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mroc_curve\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mauc\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0msklearn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdatasets\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mmake_classification\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'plotly'" + ] + } + ], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn import metrics\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# we use the dataset from previous \n", + "X = data['Time']\n", + "y = data['Rate']\n", + "\n", + "#split the dataset into training (80%) and testing (20%) sets\n", + "X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=0) \n", + "\n", + "#instantiate the model\n", + "log_regression = LogisticRegression()\n", + "\n", + "#fit the model using the training data\n", + "log_regression.fit(X_train,y_train)\n", + "\n", + "#define metrics\n", + "y_pred_probaldata = log_regression.predict_proba(X_test)[::,1]\n", + "fpr, tpr, _ = metrics.roc_curve(y_test, y_pred_probaldata)\n", + "\n", + "#plot ROC curve\n", + "plt.plot(fpr,tpr)\n", + "plt.ylabel('True Positive Rate')\n", + "plt.xlabel('False Positive Rate')\n", + "plt.show()\n", + "\n" ] } ], From f3a9a03163c5c67685b85c555d02a7545192531c Mon Sep 17 00:00:00 2001 From: Christina Yu Date: Fri, 5 Aug 2022 18:11:47 +0800 Subject: [PATCH 5/5] Update Model_development.ipynb --- Model_development.ipynb | 208 ++++++++-------------------------------- 1 file changed, 40 insertions(+), 168 deletions(-) diff --git a/Model_development.ipynb b/Model_development.ipynb index f9676ba..7995eee 100644 --- a/Model_development.ipynb +++ b/Model_development.ipynb @@ -57,30 +57,18 @@ "metadata": {}, "source": [ "## Read data:\n", - "" + "\n", + "We use Data through this link for our module development: https://physionet.org/content/bigideaslab-step-hr-smartwatch/1.0/" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'filename' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mpandas\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mnumpy\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread_csv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilename\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m#Change filename\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;31mNameError\u001b[0m: name 'filename' is not defined" - ] - } - ], + "outputs": [], "source": [ "import pandas as pd\n", - "import numpy as np\n", - "data = pd.read_csv('/Users/christinayu/Desktop/AppleWatch.csv') " + "df = pd.read_csv('/Users/christinayu/Desktop/AppleWatch.csv')" ] }, { @@ -343,21 +331,24 @@ ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "dfc = data.drop(columns=[]) # drop all non-numeric columns\n", - "dfc.head()" + "### KNN Clustering:\n", + "" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "### KNN Clustering:\n", - "" + "import pandas as pd\n", + "df = pd.read_csv('/Users/christinayu/Desktop/AppleWatch.csv')\n", + "from sklearn.cluster import KMeans\n", + "from sklearn import datasets\n", + "import matplotlib.pyplot as plt" ] }, { @@ -366,12 +357,8 @@ "metadata": {}, "outputs": [], "source": [ - "from sklearn.cluster import KMeans\n", - "# create kmeans object\n", - "kmeans = KMeans(n_clusters=3)# fit kmeans object to data\n", - "kmeans.fit(dfc)# print location of clusters learned by kmeans object\n", - "#print(kmeans.cluster_centers_)# save new clusters for chart\n", - "y_km = kmeans.fit_predict(dfc)" + "df.info()\n", + "df.describe()" ] }, { @@ -380,8 +367,24 @@ "metadata": {}, "outputs": [], "source": [ - "labels = kmeans.labels_\n", - "dfc['clusters'] = labels" + "X = df.iloc[:,0:2]\n", + "estimator = KMeans(n_clusters=3)\n", + "estimator.fit(X)\n", + "label_pred = estimator.labels_\n", + "\n", + "print (estimator.inertia_)\n", + "x0 = X[label_pred == 0]\n", + "x1 = X[label_pred == 1]\n", + "x2 = X[label_pred == 2]\n", + "x0.info()\n", + "\n", + "plt.scatter(x0['0'], x0['1'], c = \"red\", marker='o', label='ECG Data') \n", + "plt.scatter(x1['0'], x1['1'], c = \"green\", marker='*', label='Apple Watch') \n", + "plt.scatter(x2['0'], x2['1'], c = \"blue\", marker='+', label='SKBone')\n", + "plt.xlabel('Rate (beat per minute)') \n", + "plt.ylabel('Time (per minute)') \n", + "plt.legend() \n", + "plt.show()" ] }, { @@ -407,8 +410,8 @@ "import matplotlib.pyplot as plt\n", "\n", "plt.figure(figsize=(10, 7))\n", - "plt.title(\"Data Dendograms\")\n", - "dend = shc.dendrogram(shc.linkage(dfc, method='ward'))" + "plt.title(\"Hierarchical Clustering\")\n", + "dend = shc.dendrogram(shc.linkage(X, method='ward'))" ] }, { @@ -421,7 +424,7 @@ "from scipy.cluster.hierarchy import dendrogram, linkage\n", "\n", "cluster = AgglomerativeClustering(n_clusters=3, affinity='euclidean', linkage='ward')\n", - "cluster.fit_predict(dfc)" + "cluster.fit_predict(X)" ] }, { @@ -447,88 +450,6 @@ "This is useful to us because we have a large amount of features. " ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Need to scale prior to doing PCA\n", - "\n", - "from sklearn.preprocessing import StandardScaler\n", - "sc = StandardScaler()\n", - "sdfc = sc.fit_transform(dfc)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "from sklearn import decomposition\n", - "pca = decomposition.PCA()\n", - "pca.fit(sdfc)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "print(pca.explained_variance_ratio_)\n", - "print(pca.singular_values_) " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "pca.n_components = 9\n", - "pc = pca.fit(dfc)\n", - "\n", - "result=pd.DataFrame(pca.transform(dfc), columns=['PCA%i' % i for i in range(9)], index=dfc.index)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "pcft = pca.fit_transform(dfc)\n", - "\n", - "pc_df = pd.DataFrame(data=pcft, columns= ['PC1', 'PC2', 'PC3', 'PC4', 'PC5', 'PC6', 'PC7', 'PC8', 'PC9'])\n", - "\n", - "#Example below:\n", - "#pc_df['Cluster'] = data['Definition']\n", - "#pc_df['Status'] = data['Status']\n", - "#pc_df['Gender'] = data['Gender']\n", - "pc_df.head()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib inline\n", - "\n", - "import seaborn as sns\n", - "dfvar = pd.DataFrame({'var':pca.explained_variance_ratio_,\n", - " 'PC':['PC1','PC2','PC3','PC4', 'PC5', 'PC6', 'PC7', 'PC8', 'PC9']})\n", - "sns.barplot(x='PC',y=\"var\", \n", - " data=dfvar, color=\"c\");\n" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -538,55 +459,6 @@ "Problems with matplotlib widget not working: https://github.com/matplotlib/jupyter-matplotlib/issues/66" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "from mpl_toolkits.mplot3d import axes3d, Axes3D #<-- Note the capitalization! \n", - "\n", - "\n", - "pc_df[insertvarhere]=pd.Categorical(pc_df[insertvarhere]) #need to change insertvarhere\n", - "my_color=pc_df[insertvarhere].cat.codes #need to change insertvarhere\n", - "\n", - "# Plot initialisation\n", - "fig = plt.figure()\n", - "ax = Axes3D(fig) \n", - "ax.scatter(result['PCA0'], result['PCA1'], result['PCA2'], c=my_color, cmap='Accent', s=60)\n", - "\n", - "#make simple, bare axis lines through space:\n", - "xAxisLine = ((min(result['PCA0']), max(result['PCA0'])), (0, 0), (0,0))\n", - "ax.plot(xAxisLine[0], xAxisLine[1], xAxisLine[2], 'r')\n", - "yAxisLine = ((0, 0), (min(result['PCA1']), max(result['PCA1'])), (0,0))\n", - "ax.plot(yAxisLine[0], yAxisLine[1], yAxisLine[2], 'r')\n", - "zAxisLine = ((0, 0), (0,0), (min(result['PCA2']), max(result['PCA2'])))\n", - "ax.plot(zAxisLine[0], zAxisLine[1], zAxisLine[2], 'r')\n", - " \n", - "# label the axes\n", - "ax.set_xlabel(\"PC1\")\n", - "ax.set_ylabel(\"PC2\")\n", - "ax.set_zlabel(\"PC3\")\n", - "ax.set_title(\"PCA\")\n", - "#ax.legend()\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "sns.lmplot( x=\"PC1\", y=\"PC5\",\n", - " data=pc_df, \n", - " fit_reg=False, \n", - " hue=Variable, # color by change variable here\n", - " legend=True,\n", - " scatter_kws={\"s\": 80,'alpha':0.3}) # specify the point size" - ] - }, { "cell_type": "code", "execution_count": 1, @@ -879,7 +751,7 @@ "hash": "c2a0d16ab2ef21d9ffd61da4743bf5eccc7864478b6988e54f4be7517ca730a8" }, "kernelspec": { - "display_name": "Python 3.8.5 ('base')", + "display_name": "Python 3", "language": "python", "name": "python3" },