From bf2ffb0605e9bd5ee7bb3ed7d1c87366bc995a49 Mon Sep 17 00:00:00 2001 From: Kintu Christopher Date: Thu, 12 Mar 2020 10:45:00 +0300 Subject: [PATCH 1/5] This is my notebook.KC --- Assignment Colab/Christopher Kintu.ipynb | 1 + 1 file changed, 1 insertion(+) create mode 100644 Assignment Colab/Christopher Kintu.ipynb diff --git a/Assignment Colab/Christopher Kintu.ipynb b/Assignment Colab/Christopher Kintu.ipynb new file mode 100644 index 0000000..f038862 --- /dev/null +++ b/Assignment Colab/Christopher Kintu.ipynb @@ -0,0 +1 @@ +{"cells":[{"metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"cell_type":"code","source":"#First importing the necessary libraries helpful in building and/or testing the model\n#Three main libraries for a start: numpy, pandas, matplotlib.pyplot\n#numpy is for linear algebra, pandas for data processing\n\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Kintu Christopher\n## This is my assignment.\n## I am in to win the competition\n\n```import os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n for filename in filenames:\n print(os.path.join(dirname, filename))```\n \n \n"},{"metadata":{"trusted":true},"cell_type":"code","source":"\n# Input data files necessary for this assignment were obtained from \"../input/\" directory.\n\nimport os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n for filename in filenames:\n print(os.path.join(dirname, filename))\n\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#ignoring warnings: It is necessary to import while ignoring warnings\n\nimport warnings\nwarnings.filterwarnings('ignore')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# The data sets are loaded and read as below in form of csv files\nTrain = pd.read_csv(\"../input/ace-class-assignment/AMP_TrainSet.csv\")\nTest = pd.read_csv(\"../input/ace-class-assignment/Test.csv\")","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Data visualization\n## The data is loaded for viewing directly from the ACE_class_Assignment folder. This displays, in tabular format, the real values we are to work with."},{"metadata":{"trusted":true},"cell_type":"code","source":"#There is need to know how many dimensions our data has\n# This helps me to know how many rows or columns are in each data set and also how large the data set is.\n#Too many rows and columns require a longer time to train the model.\n\nTrain.shape, Test.shape\n\n# The Train data set has 12 columns and 3038 rows. \n# The Test data set has 758 rows and 11 columns\n#This means our Train data is large enough to train the algorithm without over training or under training","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Checking the column variables for the Train data set\n#This gives me an idea of the variables I am dealing with and how they are labelled.\n\nTrain.columns","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Similarly, checking for column variables for the Test data set\n\nTest.columns","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# It is good to also take a look at they data types for each data set. \n#Just incase there are strings that need to be converted into floats \n\n#First, the train data set\nTrain.dtypes\n\n#The data type of the train set is an object\n#The column variables are all floats and integers as shown below","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Similarly, for the Test data set\n\nTest.dtypes\n\n#It is an object, with floats and integers only. \n#This is good, we dont need to change anything.\n#We are good to go.","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Checking for quick statistical comparisons\n## This will quickly give me a view of the relationship between variables."},{"metadata":{"trusted":true},"cell_type":"code","source":"#We check out quick summary statistics for both data sets\n\nTrain.describe()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#summary statistics for the Test data set too\n\nTest.describe()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Attribute Correlations\n## It is important to check whether different attributes have a positive or negative correlation or none."},{"metadata":{"trusted":true},"cell_type":"code","source":"#Assuming a Gaussian distribution for both data stes; we shall use the pearson correlation\n\nTrain.corr(method = 'pearson')\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Correlation on the Test data set\n\nTest.corr(method = 'pearson')\n\n#A quci eyeball shows all variables have some form of correlation to each other. \n#There is no variable with zero correlation to another","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Plotting the data\n## Upon noticing some correlation, it is good to cisualize it in a heatmap"},{"metadata":{"trusted":true},"cell_type":"code","source":"# Visualizing correlations between attributes using heatmaps\n#import the necessary library; seaborn\n\nimport seaborn as sns\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#plot a heat map for the Test data set\nplt.figure(figsize=(6,6))\nsns.heatmap(Test.corr(method='pearson'))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Heat map for the Train data set\nplt.figure(figsize=(6,6))\nsns.heatmap(Train.corr(method='pearson'))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Testing for skewness of variables\n# This will be important incase some variables are skewed either positively or negatively since we are assuming a Gaussian distribution. Correcting for this skewness improves on the accuracy of the model."},{"metadata":{"trusted":true},"cell_type":"code","source":"#Skewness of distributions on the Train data set\nTrain.skew().plot(kind= 'bar')\n\n#The NT_EFC195 show a high right skew (above 1).\n#We shall have to correct for this to improve the model accuracy\n#This we shall do by finding the square root, cube root or a logarithmic transformation","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Testing for skewness on the Train Data set\n\nTest.skew().plot(kind= 'bar')\n\n# This data set also has a high positive skew for the NT_EFC195 variable as well","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Understanding my data\n# Different plots will give me a good insight into what to do next with the data I have.Plots like histograms, scatter plots are good to give a genearl view"},{"metadata":{"trusted":true},"cell_type":"code","source":"#Plotting a histogram for the Train Data\n\nplt.figure(figsize=(15,15))\nTrain.hist()\nplt.show()\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Plotting a histogram for the Test Data\n\nplt.figure(figsize=(15,15))\nTest.hist()\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Rug plots\n#The rugplots are like histograms except they show every single data point on the x-axis, allowing us to visualize all of the actual values\n#Both the Train and Test rugplots indicate some kind of left skew. This we need to take into account when designing the model","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"sns.distplot(Train, hist = False, kde = True, rug = True, color = 'darkblue', kde_kws={'linewidth': 3}, rug_kws={'color': 'black'})","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"sns.distplot(Test, hist = False, kde = True, rug = True, color = 'darkblue', kde_kws={'linewidth': 3}, rug_kws={'color': 'black'})","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Box plots","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Train\nTrain.plot(kind='box', subplots=True, layout=(12,12), sharex=False, sharey=False)\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Test\nTest.plot(kind='box', subplots=True, layout=(12,12), sharex=False, sharey=False)\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Scatter Plot matrix\n#scatter plot matrix shows the relationship between two variables as dots in two dimensions all at once","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"sns.pairplot(Train)\n#The scatter plot for the train dataset indicates a mixture of correlations for different variables. \n#Some have a positive strong correlation, others a negative correlation","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Test data scatter plot\nsns.pairplot(Test)\n#Similarly, some have aa positive correlation and negative correlation between different paired variables","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Preparing Data for machine learning"},{"metadata":{},"cell_type":"markdown","source":"# Rescaling Data"},{"metadata":{"trusted":true},"cell_type":"code","source":"#Rescaling\n#Since I might use features like regression and neural networks and algorithms that use distance measures like k-Nearest Neighbors. \n#I need to rescale my data using scikit-learn using the MinMaxScaler class","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#We rescale to make sure all our data values lie in a scale from 0 to 1\nfrom numpy import set_printoptions\nfrom sklearn.preprocessing import MinMaxScaler\n\narray = Train.values\n# separate array into input and output components\nX = array[:,0:11]\nY = array[:,11]\nscaler = MinMaxScaler(feature_range=(0, 1))\nrescaledX = scaler.fit_transform(X)\n# summarize transformed data\nset_printoptions(precision=3)\nprint(rescaledX[0:5,:])\n\n#Indeed all our data values have been rescaled","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# standardization of data\n```from sklearn.preprocessing import StandardScaler\n\narray2 = data.values\n#separate array into input and output components\nX = array2[:,0:8]\nY = array2[:,8]\nscaler = StandardScaler().fit(X)\nrescaledX = scaler.transform(X)\n# summarize transformed data\nset_printoptions(precision=3)\nprint(rescaledX[0:5,:])\n```\n\n# Normalization of data\n``from sklearn.preprocessing import Normalizer\n\narray3 = data.values\n#separate array into input and output components\nX = array3[:,0:8]\nY = array3[:,8]\nscaler = Normalizer().fit(X)\nnormalizedX = scaler.transform(X)\n#summarize transformed data\nset_printoptions(precision=3)\nprint(normalizedX[0:5,:])\nprint(type(normalizedX))#print the data type so we can know what we are \n#working with in the dataset.\n```\n\n```# Binarizing data\nfrom sklearn.preprocessing import Binarizer\n\narray4 = data.values\n#separate array into input and output components\nX = array4[:,0:11]\nY = array4[:,11]\nbinarizer = Binarizer(threshold=0.0).fit(X)\nbinaryX = binarizer.transform(X)\n#summarize transformed data\nset_printoptions(precision=3)\nprint(binaryX[0:5,:])\n```\n\n"},{"metadata":{},"cell_type":"markdown","source":"# Feature Selection"},{"metadata":{"trusted":true},"cell_type":"code","source":"#Using the Recursive elimination\n#from sklearn.feature_selection import RFE\n#from sklearn.linear_model import LogisticRegression\n\n#array_1 = Train.values\n#X = array_1[:,0:11]\n#Y = array_1[:,11]\n\n# Extracting features\n#model = LogisticRegression()\n#rfe = RFE(model, 3)\n#fit = rfe.fit(X, Y)\n#print(\"Num Features: \", fit.n_features_)\n#print(\"Selected Features:\", fit.support_)\n#print(\"Feature Ranking: \", fit.ranking_)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#evaluating perfomance\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.linear_model import LogisticRegression\n\narray = Train.values\nX = array[:,0:11]\nY = array[:,11]\ntest_size = 0.33\nseed = 10\nX_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=test_size, random_state=seed)\nmodel = LogisticRegression()\nmodel.fit(X_train, Y_train)\nresult = model.score(X_test, Y_test)\nprint(\"Accuracy: \", (result*100.0))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#model output","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#out = model.predict(Test.values)\n\n#KC = pd.DataFrame(out) #Converting to data frame\n#KC.columns=[\"CLASS\"] #Naming the column\n#KC.index.name=\"Index\" #Creating a column index\n#KC[\"CLASS\"]=KC[\"CLASS\"].map({0.0:False,1.0:True}) # Chaninging 0 to \"False\" 1 to \"True\"\n\n#KC.to_csv(\"KC_csv\") ## Writing a csv file\n#print(KC['CLASS'].unique())\n#print(KC['CLASS'].nunique())\n\n#printing the numbers of False and True\n#print(KC.groupby('CLASS').size()[0].sum()) #\n#print(KC.groupby('CLASS').size()[1].sum())","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"from sklearn.preprocessing import StandardScaler\n\narray2 = Train.values\n# separating array into input and output components\nX = array2[:,0:11]\nY = array2[:,11]\nscaler = StandardScaler().fit(X)\nrescaledX = scaler.transform(X)\n# transformed data should be summarized using the code below\nset_printoptions(precision=3)\nprint(rescaledX[0:5,:])","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Principal Component analysis feature"},{"metadata":{"trusted":true},"cell_type":"code","source":"#Training the model using PCA as the feature of choice\nfrom sklearn.decomposition import PCA\n\narray = Train.values\nX = array[:,0:11]\nY = array[:,11]\n\n# feature extraction\npca = PCA(n_components=3)\nfit = pca.fit(X)\n# summarize components\nprint(\"Explained Variance: \" , fit.explained_variance_ratio_)\nprint(fit.components_)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Output model using PCA as the feature"},{"metadata":{"trusted":true},"cell_type":"code","source":"out = model.predict(Test.values)\n\nKC2 = pd.DataFrame(out) #Converting the data to data frame\nKC2.columns=[\"CLASS\"] #Naming the column\nKC2.index.name=\"Index\" #Creating a column index\nKC2[\"CLASS\"]=KC2[\"CLASS\"].map({0.0:False,1.0:True}) # Chaninging 0 to \"False\" 1 to \"True\"\n\nKC2.to_csv(\"KC2_csv\") # obtaininng a csv file\nprint(KC2['CLASS'].unique())\nprint(KC2['CLASS'].nunique())\n\n#printing the numbers of False and True\nprint(KC2.groupby('CLASS').size()[0].sum()) #\nprint(KC2.groupby('CLASS').size()[1].sum())","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"","execution_count":null,"outputs":[]}],"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat":4,"nbformat_minor":4} \ No newline at end of file From 0750f88b1af0e91bdce6b96f2db7d84cb3d0cc0d Mon Sep 17 00:00:00 2001 From: Atwine Date: Thu, 12 Mar 2020 14:48:50 +0300 Subject: [PATCH 2/5] Make corrections --- .../Christopher Kintu-checkpoint.ipynb | 736 +++++++++++++++++ Assignment Colab/Christopher Kintu.ipynb | 737 +++++++++++++++++- .../Pandas Cookbook/Pandas-Cookbook | 1 + 3 files changed, 1473 insertions(+), 1 deletion(-) create mode 100644 Assignment Colab/.ipynb_checkpoints/Christopher Kintu-checkpoint.ipynb create mode 160000 Reading Material/Pandas Cookbook/Pandas-Cookbook diff --git a/Assignment Colab/.ipynb_checkpoints/Christopher Kintu-checkpoint.ipynb b/Assignment Colab/.ipynb_checkpoints/Christopher Kintu-checkpoint.ipynb new file mode 100644 index 0000000..cf97f38 --- /dev/null +++ b/Assignment Colab/.ipynb_checkpoints/Christopher Kintu-checkpoint.ipynb @@ -0,0 +1,736 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19", + "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5" + }, + "outputs": [], + "source": [ + "#First importing the necessary libraries helpful in building and/or testing the model\n", + "#Three main libraries for a start: numpy, pandas, matplotlib.pyplot\n", + "#numpy is for linear algebra, pandas for data processing\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Kintu Christopher\n", + "## This is my assignment.\n", + "## I am in to win the competition\n", + "\n", + "```import os\n", + "for dirname, _, filenames in os.walk('/kaggle/input'):\n", + " for filename in filenames:\n", + " print(os.path.join(dirname, filename))```\n", + " \n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# Input data files necessary for this assignment were obtained from \"../input/\" directory.\n", + "\n", + "import os\n", + "for dirname, _, filenames in os.walk('/kaggle/input'):\n", + " for filename in filenames:\n", + " print(os.path.join(dirname, filename))\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#ignoring warnings: It is necessary to import while ignoring warnings\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# The data sets are loaded and read as below in form of csv files\n", + "Train = pd.read_csv(\"../input/ace-class-assignment/AMP_TrainSet.csv\")\n", + "Test = pd.read_csv(\"../input/ace-class-assignment/Test.csv\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Data visualization\n", + "## The data is loaded for viewing directly from the ACE_class_Assignment folder. This displays, in tabular format, the real values we are to work with." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#There is need to know how many dimensions our data has\n", + "# This helps me to know how many rows or columns are in each data set and also how large the data set is.\n", + "#Too many rows and columns require a longer time to train the model.\n", + "\n", + "Train.shape, Test.shape\n", + "\n", + "# The Train data set has 12 columns and 3038 rows. \n", + "# The Test data set has 758 rows and 11 columns\n", + "#This means our Train data is large enough to train the algorithm without over training or under training" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Checking the column variables for the Train data set\n", + "#This gives me an idea of the variables I am dealing with and how they are labelled.\n", + "\n", + "Train.columns" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Similarly, checking for column variables for the Test data set\n", + "\n", + "Test.columns" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# It is good to also take a look at they data types for each data set. \n", + "#Just incase there are strings that need to be converted into floats \n", + "\n", + "#First, the train data set\n", + "Train.dtypes\n", + "\n", + "#The data type of the train set is an object\n", + "#The column variables are all floats and integers as shown below" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Similarly, for the Test data set\n", + "\n", + "Test.dtypes\n", + "\n", + "#It is an object, with floats and integers only. \n", + "#This is good, we dont need to change anything.\n", + "#We are good to go." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Checking for quick statistical comparisons\n", + "## This will quickly give me a view of the relationship between variables." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#We check out quick summary statistics for both data sets\n", + "\n", + "Train.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#summary statistics for the Test data set too\n", + "\n", + "Test.describe()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Attribute Correlations\n", + "## It is important to check whether different attributes have a positive or negative correlation or none." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Assuming a Gaussian distribution for both data stes; we shall use the pearson correlation\n", + "\n", + "Train.corr(method = 'pearson')\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Correlation on the Test data set\n", + "\n", + "Test.corr(method = 'pearson')\n", + "\n", + "#A quci eyeball shows all variables have some form of correlation to each other. \n", + "#There is no variable with zero correlation to another" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Plotting the data\n", + "## Upon noticing some correlation, it is good to cisualize it in a heatmap" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Visualizing correlations between attributes using heatmaps\n", + "#import the necessary library; seaborn\n", + "\n", + "import seaborn as sns\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#plot a heat map for the Test data set\n", + "plt.figure(figsize=(6,6))\n", + "sns.heatmap(Test.corr(method='pearson'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Heat map for the Train data set\n", + "plt.figure(figsize=(6,6))\n", + "sns.heatmap(Train.corr(method='pearson'))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Testing for skewness of variables\n", + "# This will be important incase some variables are skewed either positively or negatively since we are assuming a Gaussian distribution. Correcting for this skewness improves on the accuracy of the model." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Skewness of distributions on the Train data set\n", + "Train.skew().plot(kind= 'bar')\n", + "\n", + "#The NT_EFC195 show a high right skew (above 1).\n", + "#We shall have to correct for this to improve the model accuracy\n", + "#This we shall do by finding the square root, cube root or a logarithmic transformation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Testing for skewness on the Train Data set\n", + "\n", + "Test.skew().plot(kind= 'bar')\n", + "\n", + "# This data set also has a high positive skew for the NT_EFC195 variable as well" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Understanding my data\n", + "# Different plots will give me a good insight into what to do next with the data I have.Plots like histograms, scatter plots are good to give a genearl view" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Plotting a histogram for the Train Data\n", + "\n", + "plt.figure(figsize=(15,15))\n", + "Train.hist()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Plotting a histogram for the Test Data\n", + "\n", + "plt.figure(figsize=(15,15))\n", + "Test.hist()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Rug plots\n", + "#The rugplots are like histograms except they show every single data point on the x-axis, allowing us to visualize all of the actual values\n", + "#Both the Train and Test rugplots indicate some kind of left skew. This we need to take into account when designing the model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sns.distplot(Train, hist = False, kde = True, rug = True, color = 'darkblue', kde_kws={'linewidth': 3}, rug_kws={'color': 'black'})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sns.distplot(Test, hist = False, kde = True, rug = True, color = 'darkblue', kde_kws={'linewidth': 3}, rug_kws={'color': 'black'})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Box plots" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Train\n", + "Train.plot(kind='box', subplots=True, layout=(12,12), sharex=False, sharey=False)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Test\n", + "Test.plot(kind='box', subplots=True, layout=(12,12), sharex=False, sharey=False)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Scatter Plot matrix\n", + "#scatter plot matrix shows the relationship between two variables as dots in two dimensions all at once" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sns.pairplot(Train)\n", + "#The scatter plot for the train dataset indicates a mixture of correlations for different variables. \n", + "#Some have a positive strong correlation, others a negative correlation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Test data scatter plot\n", + "sns.pairplot(Test)\n", + "#Similarly, some have aa positive correlation and negative correlation between different paired variables" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Preparing Data for machine learning" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Rescaling Data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Rescaling\n", + "#Since I might use features like regression and neural networks and algorithms that use distance measures like k-Nearest Neighbors. \n", + "#I need to rescale my data using scikit-learn using the MinMaxScaler class" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#We rescale to make sure all our data values lie in a scale from 0 to 1\n", + "from numpy import set_printoptions\n", + "from sklearn.preprocessing import MinMaxScaler\n", + "\n", + "array = Train.values\n", + "# separate array into input and output components\n", + "X = array[:,0:11]\n", + "Y = array[:,11]\n", + "scaler = MinMaxScaler(feature_range=(0, 1))\n", + "rescaledX = scaler.fit_transform(X)\n", + "# summarize transformed data\n", + "set_printoptions(precision=3)\n", + "print(rescaledX[0:5,:])\n", + "\n", + "#Indeed all our data values have been rescaled" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# standardization of data\n", + "```from sklearn.preprocessing import StandardScaler\n", + "\n", + "array2 = data.values\n", + "#separate array into input and output components\n", + "X = array2[:,0:8]\n", + "Y = array2[:,8]\n", + "scaler = StandardScaler().fit(X)\n", + "rescaledX = scaler.transform(X)\n", + "# summarize transformed data\n", + "set_printoptions(precision=3)\n", + "print(rescaledX[0:5,:])\n", + "```\n", + "\n", + "# Normalization of data\n", + "``from sklearn.preprocessing import Normalizer\n", + "\n", + "array3 = data.values\n", + "#separate array into input and output components\n", + "X = array3[:,0:8]\n", + "Y = array3[:,8]\n", + "scaler = Normalizer().fit(X)\n", + "normalizedX = scaler.transform(X)\n", + "#summarize transformed data\n", + "set_printoptions(precision=3)\n", + "print(normalizedX[0:5,:])\n", + "print(type(normalizedX))#print the data type so we can know what we are \n", + "#working with in the dataset.\n", + "```\n", + "\n", + "```# Binarizing data\n", + "from sklearn.preprocessing import Binarizer\n", + "\n", + "array4 = data.values\n", + "#separate array into input and output components\n", + "X = array4[:,0:11]\n", + "Y = array4[:,11]\n", + "binarizer = Binarizer(threshold=0.0).fit(X)\n", + "binaryX = binarizer.transform(X)\n", + "#summarize transformed data\n", + "set_printoptions(precision=3)\n", + "print(binaryX[0:5,:])\n", + "```\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Feature Selection" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Using the Recursive elimination\n", + "#from sklearn.feature_selection import RFE\n", + "#from sklearn.linear_model import LogisticRegression\n", + "\n", + "#array_1 = Train.values\n", + "#X = array_1[:,0:11]\n", + "#Y = array_1[:,11]\n", + "\n", + "# Extracting features\n", + "#model = LogisticRegression()\n", + "#rfe = RFE(model, 3)\n", + "#fit = rfe.fit(X, Y)\n", + "#print(\"Num Features: \", fit.n_features_)\n", + "#print(\"Selected Features:\", fit.support_)\n", + "#print(\"Feature Ranking: \", fit.ranking_)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#evaluating perfomance\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.linear_model import LogisticRegression\n", + "\n", + "array = Train.values\n", + "X = array[:,0:11]\n", + "Y = array[:,11]\n", + "test_size = 0.33\n", + "seed = 10\n", + "X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=test_size, random_state=seed)\n", + "model = LogisticRegression()\n", + "model.fit(X_train, Y_train)\n", + "result = model.score(X_test, Y_test)\n", + "print(\"Accuracy: \", (result*100.0))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#model output" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#out = model.predict(Test.values)\n", + "\n", + "#KC = pd.DataFrame(out) #Converting to data frame\n", + "#KC.columns=[\"CLASS\"] #Naming the column\n", + "#KC.index.name=\"Index\" #Creating a column index\n", + "#KC[\"CLASS\"]=KC[\"CLASS\"].map({0.0:False,1.0:True}) # Chaninging 0 to \"False\" 1 to \"True\"\n", + "\n", + "#KC.to_csv(\"KC_csv\") ## Writing a csv file\n", + "#print(KC['CLASS'].unique())\n", + "#print(KC['CLASS'].nunique())\n", + "\n", + "#printing the numbers of False and True\n", + "#print(KC.groupby('CLASS').size()[0].sum()) #\n", + "#print(KC.groupby('CLASS').size()[1].sum())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.preprocessing import StandardScaler\n", + "\n", + "array2 = Train.values\n", + "# separating array into input and output components\n", + "X = array2[:,0:11]\n", + "Y = array2[:,11]\n", + "scaler = StandardScaler().fit(X)\n", + "rescaledX = scaler.transform(X)\n", + "# transformed data should be summarized using the code below\n", + "set_printoptions(precision=3)\n", + "print(rescaledX[0:5,:])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Principal Component analysis feature" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Training the model using PCA as the feature of choice\n", + "from sklearn.decomposition import PCA\n", + "\n", + "array = Train.values\n", + "X = array[:,0:11]\n", + "Y = array[:,11]\n", + "\n", + "# feature extraction\n", + "pca = PCA(n_components=3)\n", + "fit = pca.fit(X)\n", + "# summarize components\n", + "print(\"Explained Variance: \" , fit.explained_variance_ratio_)\n", + "print(fit.components_)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Output model using PCA as the feature" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "out = model.predict(Test.values)\n", + "\n", + "KC2 = pd.DataFrame(out) #Converting the data to data frame\n", + "KC2.columns=[\"CLASS\"] #Naming the column\n", + "KC2.index.name=\"Index\" #Creating a column index\n", + "KC2[\"CLASS\"]=KC2[\"CLASS\"].map({0.0:False,1.0:True}) # Chaninging 0 to \"False\" 1 to \"True\"\n", + "\n", + "KC2.to_csv(\"KC2_csv\") # obtaininng a csv file\n", + "print(KC2['CLASS'].unique())\n", + "print(KC2['CLASS'].nunique())\n", + "\n", + "#printing the numbers of False and True\n", + "print(KC2.groupby('CLASS').size()[0].sum()) #\n", + "print(KC2.groupby('CLASS').size()[1].sum())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.4" + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Assignment Colab/Christopher Kintu.ipynb b/Assignment Colab/Christopher Kintu.ipynb index f038862..cf97f38 100644 --- a/Assignment Colab/Christopher Kintu.ipynb +++ b/Assignment Colab/Christopher Kintu.ipynb @@ -1 +1,736 @@ -{"cells":[{"metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"cell_type":"code","source":"#First importing the necessary libraries helpful in building and/or testing the model\n#Three main libraries for a start: numpy, pandas, matplotlib.pyplot\n#numpy is for linear algebra, pandas for data processing\n\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Kintu Christopher\n## This is my assignment.\n## I am in to win the competition\n\n```import os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n for filename in filenames:\n print(os.path.join(dirname, filename))```\n \n \n"},{"metadata":{"trusted":true},"cell_type":"code","source":"\n# Input data files necessary for this assignment were obtained from \"../input/\" directory.\n\nimport os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n for filename in filenames:\n print(os.path.join(dirname, filename))\n\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#ignoring warnings: It is necessary to import while ignoring warnings\n\nimport warnings\nwarnings.filterwarnings('ignore')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# The data sets are loaded and read as below in form of csv files\nTrain = pd.read_csv(\"../input/ace-class-assignment/AMP_TrainSet.csv\")\nTest = pd.read_csv(\"../input/ace-class-assignment/Test.csv\")","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Data visualization\n## The data is loaded for viewing directly from the ACE_class_Assignment folder. This displays, in tabular format, the real values we are to work with."},{"metadata":{"trusted":true},"cell_type":"code","source":"#There is need to know how many dimensions our data has\n# This helps me to know how many rows or columns are in each data set and also how large the data set is.\n#Too many rows and columns require a longer time to train the model.\n\nTrain.shape, Test.shape\n\n# The Train data set has 12 columns and 3038 rows. \n# The Test data set has 758 rows and 11 columns\n#This means our Train data is large enough to train the algorithm without over training or under training","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Checking the column variables for the Train data set\n#This gives me an idea of the variables I am dealing with and how they are labelled.\n\nTrain.columns","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Similarly, checking for column variables for the Test data set\n\nTest.columns","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# It is good to also take a look at they data types for each data set. \n#Just incase there are strings that need to be converted into floats \n\n#First, the train data set\nTrain.dtypes\n\n#The data type of the train set is an object\n#The column variables are all floats and integers as shown below","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Similarly, for the Test data set\n\nTest.dtypes\n\n#It is an object, with floats and integers only. \n#This is good, we dont need to change anything.\n#We are good to go.","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Checking for quick statistical comparisons\n## This will quickly give me a view of the relationship between variables."},{"metadata":{"trusted":true},"cell_type":"code","source":"#We check out quick summary statistics for both data sets\n\nTrain.describe()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#summary statistics for the Test data set too\n\nTest.describe()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Attribute Correlations\n## It is important to check whether different attributes have a positive or negative correlation or none."},{"metadata":{"trusted":true},"cell_type":"code","source":"#Assuming a Gaussian distribution for both data stes; we shall use the pearson correlation\n\nTrain.corr(method = 'pearson')\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Correlation on the Test data set\n\nTest.corr(method = 'pearson')\n\n#A quci eyeball shows all variables have some form of correlation to each other. \n#There is no variable with zero correlation to another","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Plotting the data\n## Upon noticing some correlation, it is good to cisualize it in a heatmap"},{"metadata":{"trusted":true},"cell_type":"code","source":"# Visualizing correlations between attributes using heatmaps\n#import the necessary library; seaborn\n\nimport seaborn as sns\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#plot a heat map for the Test data set\nplt.figure(figsize=(6,6))\nsns.heatmap(Test.corr(method='pearson'))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Heat map for the Train data set\nplt.figure(figsize=(6,6))\nsns.heatmap(Train.corr(method='pearson'))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Testing for skewness of variables\n# This will be important incase some variables are skewed either positively or negatively since we are assuming a Gaussian distribution. Correcting for this skewness improves on the accuracy of the model."},{"metadata":{"trusted":true},"cell_type":"code","source":"#Skewness of distributions on the Train data set\nTrain.skew().plot(kind= 'bar')\n\n#The NT_EFC195 show a high right skew (above 1).\n#We shall have to correct for this to improve the model accuracy\n#This we shall do by finding the square root, cube root or a logarithmic transformation","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Testing for skewness on the Train Data set\n\nTest.skew().plot(kind= 'bar')\n\n# This data set also has a high positive skew for the NT_EFC195 variable as well","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Understanding my data\n# Different plots will give me a good insight into what to do next with the data I have.Plots like histograms, scatter plots are good to give a genearl view"},{"metadata":{"trusted":true},"cell_type":"code","source":"#Plotting a histogram for the Train Data\n\nplt.figure(figsize=(15,15))\nTrain.hist()\nplt.show()\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Plotting a histogram for the Test Data\n\nplt.figure(figsize=(15,15))\nTest.hist()\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Rug plots\n#The rugplots are like histograms except they show every single data point on the x-axis, allowing us to visualize all of the actual values\n#Both the Train and Test rugplots indicate some kind of left skew. This we need to take into account when designing the model","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"sns.distplot(Train, hist = False, kde = True, rug = True, color = 'darkblue', kde_kws={'linewidth': 3}, rug_kws={'color': 'black'})","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"sns.distplot(Test, hist = False, kde = True, rug = True, color = 'darkblue', kde_kws={'linewidth': 3}, rug_kws={'color': 'black'})","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Box plots","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Train\nTrain.plot(kind='box', subplots=True, layout=(12,12), sharex=False, sharey=False)\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Test\nTest.plot(kind='box', subplots=True, layout=(12,12), sharex=False, sharey=False)\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Scatter Plot matrix\n#scatter plot matrix shows the relationship between two variables as dots in two dimensions all at once","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"sns.pairplot(Train)\n#The scatter plot for the train dataset indicates a mixture of correlations for different variables. \n#Some have a positive strong correlation, others a negative correlation","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Test data scatter plot\nsns.pairplot(Test)\n#Similarly, some have aa positive correlation and negative correlation between different paired variables","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Preparing Data for machine learning"},{"metadata":{},"cell_type":"markdown","source":"# Rescaling Data"},{"metadata":{"trusted":true},"cell_type":"code","source":"#Rescaling\n#Since I might use features like regression and neural networks and algorithms that use distance measures like k-Nearest Neighbors. \n#I need to rescale my data using scikit-learn using the MinMaxScaler class","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#We rescale to make sure all our data values lie in a scale from 0 to 1\nfrom numpy import set_printoptions\nfrom sklearn.preprocessing import MinMaxScaler\n\narray = Train.values\n# separate array into input and output components\nX = array[:,0:11]\nY = array[:,11]\nscaler = MinMaxScaler(feature_range=(0, 1))\nrescaledX = scaler.fit_transform(X)\n# summarize transformed data\nset_printoptions(precision=3)\nprint(rescaledX[0:5,:])\n\n#Indeed all our data values have been rescaled","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# standardization of data\n```from sklearn.preprocessing import StandardScaler\n\narray2 = data.values\n#separate array into input and output components\nX = array2[:,0:8]\nY = array2[:,8]\nscaler = StandardScaler().fit(X)\nrescaledX = scaler.transform(X)\n# summarize transformed data\nset_printoptions(precision=3)\nprint(rescaledX[0:5,:])\n```\n\n# Normalization of data\n``from sklearn.preprocessing import Normalizer\n\narray3 = data.values\n#separate array into input and output components\nX = array3[:,0:8]\nY = array3[:,8]\nscaler = Normalizer().fit(X)\nnormalizedX = scaler.transform(X)\n#summarize transformed data\nset_printoptions(precision=3)\nprint(normalizedX[0:5,:])\nprint(type(normalizedX))#print the data type so we can know what we are \n#working with in the dataset.\n```\n\n```# Binarizing data\nfrom sklearn.preprocessing import Binarizer\n\narray4 = data.values\n#separate array into input and output components\nX = array4[:,0:11]\nY = array4[:,11]\nbinarizer = Binarizer(threshold=0.0).fit(X)\nbinaryX = binarizer.transform(X)\n#summarize transformed data\nset_printoptions(precision=3)\nprint(binaryX[0:5,:])\n```\n\n"},{"metadata":{},"cell_type":"markdown","source":"# Feature Selection"},{"metadata":{"trusted":true},"cell_type":"code","source":"#Using the Recursive elimination\n#from sklearn.feature_selection import RFE\n#from sklearn.linear_model import LogisticRegression\n\n#array_1 = Train.values\n#X = array_1[:,0:11]\n#Y = array_1[:,11]\n\n# Extracting features\n#model = LogisticRegression()\n#rfe = RFE(model, 3)\n#fit = rfe.fit(X, Y)\n#print(\"Num Features: \", fit.n_features_)\n#print(\"Selected Features:\", fit.support_)\n#print(\"Feature Ranking: \", fit.ranking_)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#evaluating perfomance\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.linear_model import LogisticRegression\n\narray = Train.values\nX = array[:,0:11]\nY = array[:,11]\ntest_size = 0.33\nseed = 10\nX_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=test_size, random_state=seed)\nmodel = LogisticRegression()\nmodel.fit(X_train, Y_train)\nresult = model.score(X_test, Y_test)\nprint(\"Accuracy: \", (result*100.0))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#model output","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#out = model.predict(Test.values)\n\n#KC = pd.DataFrame(out) #Converting to data frame\n#KC.columns=[\"CLASS\"] #Naming the column\n#KC.index.name=\"Index\" #Creating a column index\n#KC[\"CLASS\"]=KC[\"CLASS\"].map({0.0:False,1.0:True}) # Chaninging 0 to \"False\" 1 to \"True\"\n\n#KC.to_csv(\"KC_csv\") ## Writing a csv file\n#print(KC['CLASS'].unique())\n#print(KC['CLASS'].nunique())\n\n#printing the numbers of False and True\n#print(KC.groupby('CLASS').size()[0].sum()) #\n#print(KC.groupby('CLASS').size()[1].sum())","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"from sklearn.preprocessing import StandardScaler\n\narray2 = Train.values\n# separating array into input and output components\nX = array2[:,0:11]\nY = array2[:,11]\nscaler = StandardScaler().fit(X)\nrescaledX = scaler.transform(X)\n# transformed data should be summarized using the code below\nset_printoptions(precision=3)\nprint(rescaledX[0:5,:])","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Principal Component analysis feature"},{"metadata":{"trusted":true},"cell_type":"code","source":"#Training the model using PCA as the feature of choice\nfrom sklearn.decomposition import PCA\n\narray = Train.values\nX = array[:,0:11]\nY = array[:,11]\n\n# feature extraction\npca = PCA(n_components=3)\nfit = pca.fit(X)\n# summarize components\nprint(\"Explained Variance: \" , fit.explained_variance_ratio_)\nprint(fit.components_)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Output model using PCA as the feature"},{"metadata":{"trusted":true},"cell_type":"code","source":"out = model.predict(Test.values)\n\nKC2 = pd.DataFrame(out) #Converting the data to data frame\nKC2.columns=[\"CLASS\"] #Naming the column\nKC2.index.name=\"Index\" #Creating a column index\nKC2[\"CLASS\"]=KC2[\"CLASS\"].map({0.0:False,1.0:True}) # Chaninging 0 to \"False\" 1 to \"True\"\n\nKC2.to_csv(\"KC2_csv\") # obtaininng a csv file\nprint(KC2['CLASS'].unique())\nprint(KC2['CLASS'].nunique())\n\n#printing the numbers of False and True\nprint(KC2.groupby('CLASS').size()[0].sum()) #\nprint(KC2.groupby('CLASS').size()[1].sum())","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"","execution_count":null,"outputs":[]}],"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat":4,"nbformat_minor":4} \ No newline at end of file +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19", + "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5" + }, + "outputs": [], + "source": [ + "#First importing the necessary libraries helpful in building and/or testing the model\n", + "#Three main libraries for a start: numpy, pandas, matplotlib.pyplot\n", + "#numpy is for linear algebra, pandas for data processing\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Kintu Christopher\n", + "## This is my assignment.\n", + "## I am in to win the competition\n", + "\n", + "```import os\n", + "for dirname, _, filenames in os.walk('/kaggle/input'):\n", + " for filename in filenames:\n", + " print(os.path.join(dirname, filename))```\n", + " \n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# Input data files necessary for this assignment were obtained from \"../input/\" directory.\n", + "\n", + "import os\n", + "for dirname, _, filenames in os.walk('/kaggle/input'):\n", + " for filename in filenames:\n", + " print(os.path.join(dirname, filename))\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#ignoring warnings: It is necessary to import while ignoring warnings\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# The data sets are loaded and read as below in form of csv files\n", + "Train = pd.read_csv(\"../input/ace-class-assignment/AMP_TrainSet.csv\")\n", + "Test = pd.read_csv(\"../input/ace-class-assignment/Test.csv\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Data visualization\n", + "## The data is loaded for viewing directly from the ACE_class_Assignment folder. This displays, in tabular format, the real values we are to work with." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#There is need to know how many dimensions our data has\n", + "# This helps me to know how many rows or columns are in each data set and also how large the data set is.\n", + "#Too many rows and columns require a longer time to train the model.\n", + "\n", + "Train.shape, Test.shape\n", + "\n", + "# The Train data set has 12 columns and 3038 rows. \n", + "# The Test data set has 758 rows and 11 columns\n", + "#This means our Train data is large enough to train the algorithm without over training or under training" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Checking the column variables for the Train data set\n", + "#This gives me an idea of the variables I am dealing with and how they are labelled.\n", + "\n", + "Train.columns" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Similarly, checking for column variables for the Test data set\n", + "\n", + "Test.columns" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# It is good to also take a look at they data types for each data set. \n", + "#Just incase there are strings that need to be converted into floats \n", + "\n", + "#First, the train data set\n", + "Train.dtypes\n", + "\n", + "#The data type of the train set is an object\n", + "#The column variables are all floats and integers as shown below" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Similarly, for the Test data set\n", + "\n", + "Test.dtypes\n", + "\n", + "#It is an object, with floats and integers only. \n", + "#This is good, we dont need to change anything.\n", + "#We are good to go." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Checking for quick statistical comparisons\n", + "## This will quickly give me a view of the relationship between variables." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#We check out quick summary statistics for both data sets\n", + "\n", + "Train.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#summary statistics for the Test data set too\n", + "\n", + "Test.describe()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Attribute Correlations\n", + "## It is important to check whether different attributes have a positive or negative correlation or none." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Assuming a Gaussian distribution for both data stes; we shall use the pearson correlation\n", + "\n", + "Train.corr(method = 'pearson')\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Correlation on the Test data set\n", + "\n", + "Test.corr(method = 'pearson')\n", + "\n", + "#A quci eyeball shows all variables have some form of correlation to each other. \n", + "#There is no variable with zero correlation to another" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Plotting the data\n", + "## Upon noticing some correlation, it is good to cisualize it in a heatmap" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Visualizing correlations between attributes using heatmaps\n", + "#import the necessary library; seaborn\n", + "\n", + "import seaborn as sns\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#plot a heat map for the Test data set\n", + "plt.figure(figsize=(6,6))\n", + "sns.heatmap(Test.corr(method='pearson'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Heat map for the Train data set\n", + "plt.figure(figsize=(6,6))\n", + "sns.heatmap(Train.corr(method='pearson'))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Testing for skewness of variables\n", + "# This will be important incase some variables are skewed either positively or negatively since we are assuming a Gaussian distribution. Correcting for this skewness improves on the accuracy of the model." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Skewness of distributions on the Train data set\n", + "Train.skew().plot(kind= 'bar')\n", + "\n", + "#The NT_EFC195 show a high right skew (above 1).\n", + "#We shall have to correct for this to improve the model accuracy\n", + "#This we shall do by finding the square root, cube root or a logarithmic transformation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Testing for skewness on the Train Data set\n", + "\n", + "Test.skew().plot(kind= 'bar')\n", + "\n", + "# This data set also has a high positive skew for the NT_EFC195 variable as well" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Understanding my data\n", + "# Different plots will give me a good insight into what to do next with the data I have.Plots like histograms, scatter plots are good to give a genearl view" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Plotting a histogram for the Train Data\n", + "\n", + "plt.figure(figsize=(15,15))\n", + "Train.hist()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Plotting a histogram for the Test Data\n", + "\n", + "plt.figure(figsize=(15,15))\n", + "Test.hist()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Rug plots\n", + "#The rugplots are like histograms except they show every single data point on the x-axis, allowing us to visualize all of the actual values\n", + "#Both the Train and Test rugplots indicate some kind of left skew. This we need to take into account when designing the model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sns.distplot(Train, hist = False, kde = True, rug = True, color = 'darkblue', kde_kws={'linewidth': 3}, rug_kws={'color': 'black'})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sns.distplot(Test, hist = False, kde = True, rug = True, color = 'darkblue', kde_kws={'linewidth': 3}, rug_kws={'color': 'black'})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Box plots" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Train\n", + "Train.plot(kind='box', subplots=True, layout=(12,12), sharex=False, sharey=False)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Test\n", + "Test.plot(kind='box', subplots=True, layout=(12,12), sharex=False, sharey=False)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Scatter Plot matrix\n", + "#scatter plot matrix shows the relationship between two variables as dots in two dimensions all at once" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sns.pairplot(Train)\n", + "#The scatter plot for the train dataset indicates a mixture of correlations for different variables. \n", + "#Some have a positive strong correlation, others a negative correlation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Test data scatter plot\n", + "sns.pairplot(Test)\n", + "#Similarly, some have aa positive correlation and negative correlation between different paired variables" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Preparing Data for machine learning" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Rescaling Data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Rescaling\n", + "#Since I might use features like regression and neural networks and algorithms that use distance measures like k-Nearest Neighbors. \n", + "#I need to rescale my data using scikit-learn using the MinMaxScaler class" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#We rescale to make sure all our data values lie in a scale from 0 to 1\n", + "from numpy import set_printoptions\n", + "from sklearn.preprocessing import MinMaxScaler\n", + "\n", + "array = Train.values\n", + "# separate array into input and output components\n", + "X = array[:,0:11]\n", + "Y = array[:,11]\n", + "scaler = MinMaxScaler(feature_range=(0, 1))\n", + "rescaledX = scaler.fit_transform(X)\n", + "# summarize transformed data\n", + "set_printoptions(precision=3)\n", + "print(rescaledX[0:5,:])\n", + "\n", + "#Indeed all our data values have been rescaled" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# standardization of data\n", + "```from sklearn.preprocessing import StandardScaler\n", + "\n", + "array2 = data.values\n", + "#separate array into input and output components\n", + "X = array2[:,0:8]\n", + "Y = array2[:,8]\n", + "scaler = StandardScaler().fit(X)\n", + "rescaledX = scaler.transform(X)\n", + "# summarize transformed data\n", + "set_printoptions(precision=3)\n", + "print(rescaledX[0:5,:])\n", + "```\n", + "\n", + "# Normalization of data\n", + "``from sklearn.preprocessing import Normalizer\n", + "\n", + "array3 = data.values\n", + "#separate array into input and output components\n", + "X = array3[:,0:8]\n", + "Y = array3[:,8]\n", + "scaler = Normalizer().fit(X)\n", + "normalizedX = scaler.transform(X)\n", + "#summarize transformed data\n", + "set_printoptions(precision=3)\n", + "print(normalizedX[0:5,:])\n", + "print(type(normalizedX))#print the data type so we can know what we are \n", + "#working with in the dataset.\n", + "```\n", + "\n", + "```# Binarizing data\n", + "from sklearn.preprocessing import Binarizer\n", + "\n", + "array4 = data.values\n", + "#separate array into input and output components\n", + "X = array4[:,0:11]\n", + "Y = array4[:,11]\n", + "binarizer = Binarizer(threshold=0.0).fit(X)\n", + "binaryX = binarizer.transform(X)\n", + "#summarize transformed data\n", + "set_printoptions(precision=3)\n", + "print(binaryX[0:5,:])\n", + "```\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Feature Selection" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Using the Recursive elimination\n", + "#from sklearn.feature_selection import RFE\n", + "#from sklearn.linear_model import LogisticRegression\n", + "\n", + "#array_1 = Train.values\n", + "#X = array_1[:,0:11]\n", + "#Y = array_1[:,11]\n", + "\n", + "# Extracting features\n", + "#model = LogisticRegression()\n", + "#rfe = RFE(model, 3)\n", + "#fit = rfe.fit(X, Y)\n", + "#print(\"Num Features: \", fit.n_features_)\n", + "#print(\"Selected Features:\", fit.support_)\n", + "#print(\"Feature Ranking: \", fit.ranking_)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#evaluating perfomance\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.linear_model import LogisticRegression\n", + "\n", + "array = Train.values\n", + "X = array[:,0:11]\n", + "Y = array[:,11]\n", + "test_size = 0.33\n", + "seed = 10\n", + "X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=test_size, random_state=seed)\n", + "model = LogisticRegression()\n", + "model.fit(X_train, Y_train)\n", + "result = model.score(X_test, Y_test)\n", + "print(\"Accuracy: \", (result*100.0))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#model output" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#out = model.predict(Test.values)\n", + "\n", + "#KC = pd.DataFrame(out) #Converting to data frame\n", + "#KC.columns=[\"CLASS\"] #Naming the column\n", + "#KC.index.name=\"Index\" #Creating a column index\n", + "#KC[\"CLASS\"]=KC[\"CLASS\"].map({0.0:False,1.0:True}) # Chaninging 0 to \"False\" 1 to \"True\"\n", + "\n", + "#KC.to_csv(\"KC_csv\") ## Writing a csv file\n", + "#print(KC['CLASS'].unique())\n", + "#print(KC['CLASS'].nunique())\n", + "\n", + "#printing the numbers of False and True\n", + "#print(KC.groupby('CLASS').size()[0].sum()) #\n", + "#print(KC.groupby('CLASS').size()[1].sum())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.preprocessing import StandardScaler\n", + "\n", + "array2 = Train.values\n", + "# separating array into input and output components\n", + "X = array2[:,0:11]\n", + "Y = array2[:,11]\n", + "scaler = StandardScaler().fit(X)\n", + "rescaledX = scaler.transform(X)\n", + "# transformed data should be summarized using the code below\n", + "set_printoptions(precision=3)\n", + "print(rescaledX[0:5,:])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Principal Component analysis feature" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Training the model using PCA as the feature of choice\n", + "from sklearn.decomposition import PCA\n", + "\n", + "array = Train.values\n", + "X = array[:,0:11]\n", + "Y = array[:,11]\n", + "\n", + "# feature extraction\n", + "pca = PCA(n_components=3)\n", + "fit = pca.fit(X)\n", + "# summarize components\n", + "print(\"Explained Variance: \" , fit.explained_variance_ratio_)\n", + "print(fit.components_)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Output model using PCA as the feature" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "out = model.predict(Test.values)\n", + "\n", + "KC2 = pd.DataFrame(out) #Converting the data to data frame\n", + "KC2.columns=[\"CLASS\"] #Naming the column\n", + "KC2.index.name=\"Index\" #Creating a column index\n", + "KC2[\"CLASS\"]=KC2[\"CLASS\"].map({0.0:False,1.0:True}) # Chaninging 0 to \"False\" 1 to \"True\"\n", + "\n", + "KC2.to_csv(\"KC2_csv\") # obtaininng a csv file\n", + "print(KC2['CLASS'].unique())\n", + "print(KC2['CLASS'].nunique())\n", + "\n", + "#printing the numbers of False and True\n", + "print(KC2.groupby('CLASS').size()[0].sum()) #\n", + "print(KC2.groupby('CLASS').size()[1].sum())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.4" + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Reading Material/Pandas Cookbook/Pandas-Cookbook b/Reading Material/Pandas Cookbook/Pandas-Cookbook new file mode 160000 index 0000000..b45d95c --- /dev/null +++ b/Reading Material/Pandas Cookbook/Pandas-Cookbook @@ -0,0 +1 @@ +Subproject commit b45d95ccef24b020fdf28ecb5a07e3348bee62f1 From 22e916a2d6dee098b988f54d38607abd8467c728 Mon Sep 17 00:00:00 2001 From: Kintu Christopher Date: Mon, 16 Mar 2020 15:13:20 +0300 Subject: [PATCH 3/5] Edited notebook --- Thur 20 Feb/ACE_ClassML Pipeline.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Thur 20 Feb/ACE_ClassML Pipeline.ipynb b/Thur 20 Feb/ACE_ClassML Pipeline.ipynb index e55fe6d..260511d 100644 --- a/Thur 20 Feb/ACE_ClassML Pipeline.ipynb +++ b/Thur 20 Feb/ACE_ClassML Pipeline.ipynb @@ -3865,7 +3865,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.4" + "version": "3.6.9" }, "varInspector": { "cols": { From 8071cd4719464bb9b7e5b51d4f41e18112804a52 Mon Sep 17 00:00:00 2001 From: Kintu Christopher Date: Mon, 16 Mar 2020 15:29:54 +0300 Subject: [PATCH 4/5] This is the corrected notebook --- Assignment Colab/Christopher Kintu.ipynb | 737 +---------------------- 1 file changed, 1 insertion(+), 736 deletions(-) diff --git a/Assignment Colab/Christopher Kintu.ipynb b/Assignment Colab/Christopher Kintu.ipynb index cf97f38..f0cb391 100644 --- a/Assignment Colab/Christopher Kintu.ipynb +++ b/Assignment Colab/Christopher Kintu.ipynb @@ -1,736 +1 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19", - "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5" - }, - "outputs": [], - "source": [ - "#First importing the necessary libraries helpful in building and/or testing the model\n", - "#Three main libraries for a start: numpy, pandas, matplotlib.pyplot\n", - "#numpy is for linear algebra, pandas for data processing\n", - "\n", - "import pandas as pd\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Kintu Christopher\n", - "## This is my assignment.\n", - "## I am in to win the competition\n", - "\n", - "```import os\n", - "for dirname, _, filenames in os.walk('/kaggle/input'):\n", - " for filename in filenames:\n", - " print(os.path.join(dirname, filename))```\n", - " \n", - " \n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "# Input data files necessary for this assignment were obtained from \"../input/\" directory.\n", - "\n", - "import os\n", - "for dirname, _, filenames in os.walk('/kaggle/input'):\n", - " for filename in filenames:\n", - " print(os.path.join(dirname, filename))\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#ignoring warnings: It is necessary to import while ignoring warnings\n", - "\n", - "import warnings\n", - "warnings.filterwarnings('ignore')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# The data sets are loaded and read as below in form of csv files\n", - "Train = pd.read_csv(\"../input/ace-class-assignment/AMP_TrainSet.csv\")\n", - "Test = pd.read_csv(\"../input/ace-class-assignment/Test.csv\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Data visualization\n", - "## The data is loaded for viewing directly from the ACE_class_Assignment folder. This displays, in tabular format, the real values we are to work with." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#There is need to know how many dimensions our data has\n", - "# This helps me to know how many rows or columns are in each data set and also how large the data set is.\n", - "#Too many rows and columns require a longer time to train the model.\n", - "\n", - "Train.shape, Test.shape\n", - "\n", - "# The Train data set has 12 columns and 3038 rows. \n", - "# The Test data set has 758 rows and 11 columns\n", - "#This means our Train data is large enough to train the algorithm without over training or under training" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#Checking the column variables for the Train data set\n", - "#This gives me an idea of the variables I am dealing with and how they are labelled.\n", - "\n", - "Train.columns" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#Similarly, checking for column variables for the Test data set\n", - "\n", - "Test.columns" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# It is good to also take a look at they data types for each data set. \n", - "#Just incase there are strings that need to be converted into floats \n", - "\n", - "#First, the train data set\n", - "Train.dtypes\n", - "\n", - "#The data type of the train set is an object\n", - "#The column variables are all floats and integers as shown below" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#Similarly, for the Test data set\n", - "\n", - "Test.dtypes\n", - "\n", - "#It is an object, with floats and integers only. \n", - "#This is good, we dont need to change anything.\n", - "#We are good to go." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Checking for quick statistical comparisons\n", - "## This will quickly give me a view of the relationship between variables." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#We check out quick summary statistics for both data sets\n", - "\n", - "Train.describe()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#summary statistics for the Test data set too\n", - "\n", - "Test.describe()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Attribute Correlations\n", - "## It is important to check whether different attributes have a positive or negative correlation or none." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#Assuming a Gaussian distribution for both data stes; we shall use the pearson correlation\n", - "\n", - "Train.corr(method = 'pearson')\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#Correlation on the Test data set\n", - "\n", - "Test.corr(method = 'pearson')\n", - "\n", - "#A quci eyeball shows all variables have some form of correlation to each other. \n", - "#There is no variable with zero correlation to another" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Plotting the data\n", - "## Upon noticing some correlation, it is good to cisualize it in a heatmap" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Visualizing correlations between attributes using heatmaps\n", - "#import the necessary library; seaborn\n", - "\n", - "import seaborn as sns\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#plot a heat map for the Test data set\n", - "plt.figure(figsize=(6,6))\n", - "sns.heatmap(Test.corr(method='pearson'))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#Heat map for the Train data set\n", - "plt.figure(figsize=(6,6))\n", - "sns.heatmap(Train.corr(method='pearson'))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Testing for skewness of variables\n", - "# This will be important incase some variables are skewed either positively or negatively since we are assuming a Gaussian distribution. Correcting for this skewness improves on the accuracy of the model." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#Skewness of distributions on the Train data set\n", - "Train.skew().plot(kind= 'bar')\n", - "\n", - "#The NT_EFC195 show a high right skew (above 1).\n", - "#We shall have to correct for this to improve the model accuracy\n", - "#This we shall do by finding the square root, cube root or a logarithmic transformation" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#Testing for skewness on the Train Data set\n", - "\n", - "Test.skew().plot(kind= 'bar')\n", - "\n", - "# This data set also has a high positive skew for the NT_EFC195 variable as well" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Understanding my data\n", - "# Different plots will give me a good insight into what to do next with the data I have.Plots like histograms, scatter plots are good to give a genearl view" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#Plotting a histogram for the Train Data\n", - "\n", - "plt.figure(figsize=(15,15))\n", - "Train.hist()\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#Plotting a histogram for the Test Data\n", - "\n", - "plt.figure(figsize=(15,15))\n", - "Test.hist()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#Rug plots\n", - "#The rugplots are like histograms except they show every single data point on the x-axis, allowing us to visualize all of the actual values\n", - "#Both the Train and Test rugplots indicate some kind of left skew. This we need to take into account when designing the model" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "sns.distplot(Train, hist = False, kde = True, rug = True, color = 'darkblue', kde_kws={'linewidth': 3}, rug_kws={'color': 'black'})" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "sns.distplot(Test, hist = False, kde = True, rug = True, color = 'darkblue', kde_kws={'linewidth': 3}, rug_kws={'color': 'black'})" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#Box plots" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#Train\n", - "Train.plot(kind='box', subplots=True, layout=(12,12), sharex=False, sharey=False)\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#Test\n", - "Test.plot(kind='box', subplots=True, layout=(12,12), sharex=False, sharey=False)\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#Scatter Plot matrix\n", - "#scatter plot matrix shows the relationship between two variables as dots in two dimensions all at once" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "sns.pairplot(Train)\n", - "#The scatter plot for the train dataset indicates a mixture of correlations for different variables. \n", - "#Some have a positive strong correlation, others a negative correlation" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#Test data scatter plot\n", - "sns.pairplot(Test)\n", - "#Similarly, some have aa positive correlation and negative correlation between different paired variables" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Preparing Data for machine learning" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Rescaling Data" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#Rescaling\n", - "#Since I might use features like regression and neural networks and algorithms that use distance measures like k-Nearest Neighbors. \n", - "#I need to rescale my data using scikit-learn using the MinMaxScaler class" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#We rescale to make sure all our data values lie in a scale from 0 to 1\n", - "from numpy import set_printoptions\n", - "from sklearn.preprocessing import MinMaxScaler\n", - "\n", - "array = Train.values\n", - "# separate array into input and output components\n", - "X = array[:,0:11]\n", - "Y = array[:,11]\n", - "scaler = MinMaxScaler(feature_range=(0, 1))\n", - "rescaledX = scaler.fit_transform(X)\n", - "# summarize transformed data\n", - "set_printoptions(precision=3)\n", - "print(rescaledX[0:5,:])\n", - "\n", - "#Indeed all our data values have been rescaled" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# standardization of data\n", - "```from sklearn.preprocessing import StandardScaler\n", - "\n", - "array2 = data.values\n", - "#separate array into input and output components\n", - "X = array2[:,0:8]\n", - "Y = array2[:,8]\n", - "scaler = StandardScaler().fit(X)\n", - "rescaledX = scaler.transform(X)\n", - "# summarize transformed data\n", - "set_printoptions(precision=3)\n", - "print(rescaledX[0:5,:])\n", - "```\n", - "\n", - "# Normalization of data\n", - "``from sklearn.preprocessing import Normalizer\n", - "\n", - "array3 = data.values\n", - "#separate array into input and output components\n", - "X = array3[:,0:8]\n", - "Y = array3[:,8]\n", - "scaler = Normalizer().fit(X)\n", - "normalizedX = scaler.transform(X)\n", - "#summarize transformed data\n", - "set_printoptions(precision=3)\n", - "print(normalizedX[0:5,:])\n", - "print(type(normalizedX))#print the data type so we can know what we are \n", - "#working with in the dataset.\n", - "```\n", - "\n", - "```# Binarizing data\n", - "from sklearn.preprocessing import Binarizer\n", - "\n", - "array4 = data.values\n", - "#separate array into input and output components\n", - "X = array4[:,0:11]\n", - "Y = array4[:,11]\n", - "binarizer = Binarizer(threshold=0.0).fit(X)\n", - "binaryX = binarizer.transform(X)\n", - "#summarize transformed data\n", - "set_printoptions(precision=3)\n", - "print(binaryX[0:5,:])\n", - "```\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Feature Selection" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#Using the Recursive elimination\n", - "#from sklearn.feature_selection import RFE\n", - "#from sklearn.linear_model import LogisticRegression\n", - "\n", - "#array_1 = Train.values\n", - "#X = array_1[:,0:11]\n", - "#Y = array_1[:,11]\n", - "\n", - "# Extracting features\n", - "#model = LogisticRegression()\n", - "#rfe = RFE(model, 3)\n", - "#fit = rfe.fit(X, Y)\n", - "#print(\"Num Features: \", fit.n_features_)\n", - "#print(\"Selected Features:\", fit.support_)\n", - "#print(\"Feature Ranking: \", fit.ranking_)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#evaluating perfomance\n", - "from sklearn.model_selection import train_test_split\n", - "from sklearn.linear_model import LogisticRegression\n", - "\n", - "array = Train.values\n", - "X = array[:,0:11]\n", - "Y = array[:,11]\n", - "test_size = 0.33\n", - "seed = 10\n", - "X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=test_size, random_state=seed)\n", - "model = LogisticRegression()\n", - "model.fit(X_train, Y_train)\n", - "result = model.score(X_test, Y_test)\n", - "print(\"Accuracy: \", (result*100.0))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#model output" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#out = model.predict(Test.values)\n", - "\n", - "#KC = pd.DataFrame(out) #Converting to data frame\n", - "#KC.columns=[\"CLASS\"] #Naming the column\n", - "#KC.index.name=\"Index\" #Creating a column index\n", - "#KC[\"CLASS\"]=KC[\"CLASS\"].map({0.0:False,1.0:True}) # Chaninging 0 to \"False\" 1 to \"True\"\n", - "\n", - "#KC.to_csv(\"KC_csv\") ## Writing a csv file\n", - "#print(KC['CLASS'].unique())\n", - "#print(KC['CLASS'].nunique())\n", - "\n", - "#printing the numbers of False and True\n", - "#print(KC.groupby('CLASS').size()[0].sum()) #\n", - "#print(KC.groupby('CLASS').size()[1].sum())" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from sklearn.preprocessing import StandardScaler\n", - "\n", - "array2 = Train.values\n", - "# separating array into input and output components\n", - "X = array2[:,0:11]\n", - "Y = array2[:,11]\n", - "scaler = StandardScaler().fit(X)\n", - "rescaledX = scaler.transform(X)\n", - "# transformed data should be summarized using the code below\n", - "set_printoptions(precision=3)\n", - "print(rescaledX[0:5,:])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Principal Component analysis feature" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#Training the model using PCA as the feature of choice\n", - "from sklearn.decomposition import PCA\n", - "\n", - "array = Train.values\n", - "X = array[:,0:11]\n", - "Y = array[:,11]\n", - "\n", - "# feature extraction\n", - "pca = PCA(n_components=3)\n", - "fit = pca.fit(X)\n", - "# summarize components\n", - "print(\"Explained Variance: \" , fit.explained_variance_ratio_)\n", - "print(fit.components_)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Output model using PCA as the feature" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "out = model.predict(Test.values)\n", - "\n", - "KC2 = pd.DataFrame(out) #Converting the data to data frame\n", - "KC2.columns=[\"CLASS\"] #Naming the column\n", - "KC2.index.name=\"Index\" #Creating a column index\n", - "KC2[\"CLASS\"]=KC2[\"CLASS\"].map({0.0:False,1.0:True}) # Chaninging 0 to \"False\" 1 to \"True\"\n", - "\n", - "KC2.to_csv(\"KC2_csv\") # obtaininng a csv file\n", - "print(KC2['CLASS'].unique())\n", - "print(KC2['CLASS'].nunique())\n", - "\n", - "#printing the numbers of False and True\n", - "print(KC2.groupby('CLASS').size()[0].sum()) #\n", - "print(KC2.groupby('CLASS').size()[1].sum())" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.7.4" - }, - "varInspector": { - "cols": { - "lenName": 16, - "lenType": 16, - "lenVar": 40 - }, - "kernels_config": { - "python": { - "delete_cmd_postfix": "", - "delete_cmd_prefix": "del ", - "library": "var_list.py", - "varRefreshCmd": "print(var_dic_list())" - }, - "r": { - "delete_cmd_postfix": ") ", - "delete_cmd_prefix": "rm(", - "library": "var_list.r", - "varRefreshCmd": "cat(var_dic_list()) " - } - }, - "types_to_exclude": [ - "module", - "function", - "builtin_function_or_method", - "instance", - "_Feature" - ], - "window_display": false - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} +{"cells":[{"metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"cell_type":"code","source":"#First importing the necessary libraries helpful in building and/or testing the model\n#Three main libraries for a start: numpy, pandas, matplotlib.pyplot\n#numpy is for linear algebra, pandas for data processing\n\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Kintu Christopher\n## This is my assignment.\n## I am in to win the competition\n\n```import os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n for filename in filenames:\n print(os.path.join(dirname, filename))```\n \n \n"},{"metadata":{"trusted":true},"cell_type":"code","source":"\n# Input data files necessary for this assignment were obtained from \"../input/\" directory.\n\nimport os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n for filename in filenames:\n print(os.path.join(dirname, filename))\n\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#ignoring warnings: It is necessary to import while ignoring warnings\n\nimport warnings\nwarnings.filterwarnings('ignore')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# The data sets are loaded and read as below in form of csv files\nTrain = pd.read_csv(\"../input/ace-class-assignment/AMP_TrainSet.csv\")\nTest = pd.read_csv(\"../input/ace-class-assignment/Test.csv\")","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Data visualization\n## The data is loaded for viewing directly from the ACE_class_Assignment folder. This displays, in tabular format, the real values we are to work with."},{"metadata":{"trusted":true},"cell_type":"code","source":"#There is need to know how many dimensions our data has\n# This helps me to know how many rows or columns are in each data set and also how large the data set is.\n#Too many rows and columns require a longer time to train the model.\n\nTrain.shape, Test.shape\n\n# The Train data set has 12 columns and 3038 rows. \n# The Test data set has 758 rows and 11 columns\n#This means our Train data is large enough to train the algorithm without over training or under training","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Checking the column variables for the Train data set\n#This gives me an idea of the variables I am dealing with and how they are labelled.\n\nTrain.columns","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Similarly, checking for column variables for the Test data set\n\nTest.columns","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# It is good to also take a look at they data types for each data set. \n#Just incase there are strings that need to be converted into floats \n\n#First, the train data set\nTrain.dtypes\n\n#The data type of the train set is an object\n#The column variables are all floats and integers as shown below","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Similarly, for the Test data set\n\nTest.dtypes\n\n#It is an object, with floats and integers only. \n#This is good, we dont need to change anything.\n#We are good to go.","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Checking for quick statistical comparisons\n## This will quickly give me a view of the relationship between variables."},{"metadata":{"trusted":true},"cell_type":"code","source":"#We check out quick summary statistics for both data sets\n\nTrain.describe()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#summary statistics for the Test data set too\n\nTest.describe()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Attribute Correlations\n## It is important to check whether different attributes have a positive or negative correlation or none."},{"metadata":{"trusted":true},"cell_type":"code","source":"#Assuming a Gaussian distribution for both data stes; we shall use the pearson correlation\n\nTrain.corr(method = 'pearson')\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Correlation on the Test data set\n\nTest.corr(method = 'pearson')\n\n#A quci eyeball shows all variables have some form of correlation to each other. \n#There is no variable with zero correlation to another","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Plotting the data\n## Upon noticing some correlation, it is good to cisualize it in a heatmap"},{"metadata":{"trusted":true},"cell_type":"code","source":"# Visualizing correlations between attributes using heatmaps\n#import the necessary library; seaborn\n\nimport seaborn as sns\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#plot a heat map for the Test data set\nplt.figure(figsize=(6,6))\nsns.heatmap(Test.corr(method='pearson'))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Heat map for the Train data set\nplt.figure(figsize=(6,6))\nsns.heatmap(Train.corr(method='pearson'))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Testing for skewness of variables\n# This will be important incase some variables are skewed either positively or negatively since we are assuming a Gaussian distribution. Correcting for this skewness improves on the accuracy of the model."},{"metadata":{"trusted":true},"cell_type":"code","source":"#Skewness of distributions on the Train data set\nTrain.skew().plot(kind= 'bar')\n\n#The NT_EFC195 show a high right skew (above 1).\n#We shall have to correct for this to improve the model accuracy\n#This we shall do by finding the square root, cube root or a logarithmic transformation","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Testing for skewness on the Train Data set\n\nTest.skew().plot(kind= 'bar')\n\n# This data set also has a high positive skew for the NT_EFC195 variable as well","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Understanding my data\n# Different plots will give me a good insight into what to do next with the data I have.Plots like histograms, scatter plots are good to give a genearl view"},{"metadata":{"trusted":true},"cell_type":"code","source":"#Plotting a histogram for the Train Data\n\nplt.figure(figsize=(15,15))\nTrain.hist()\nplt.show()\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Plotting a histogram for the Test Data\n\nplt.figure(figsize=(15,15))\nTest.hist()\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Rug plots\n#The rugplots are like histograms except they show every single data point on the x-axis, allowing us to visualize all of the actual values\n#Both the Train and Test rugplots indicate some kind of left skew. This we need to take into account when designing the model","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"sns.distplot(Train, hist = False, kde = True, rug = True, color = 'darkblue', kde_kws={'linewidth': 3}, rug_kws={'color': 'black'})","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"sns.distplot(Test, hist = False, kde = True, rug = True, color = 'darkblue', kde_kws={'linewidth': 3}, rug_kws={'color': 'black'})","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Box plots","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Train\nTrain.plot(kind='box', subplots=True, layout=(12,12), sharex=False, sharey=False)\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Test\nTest.plot(kind='box', subplots=True, layout=(12,12), sharex=False, sharey=False)\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Scatter Plot matrix\n#scatter plot matrix shows the relationship between two variables as dots in two dimensions all at once","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#sns.pairplot(Train)\n#The scatter plot for the train dataset indicates a mixture of correlations for different variables. \n#Some have a positive strong correlation, others a negative correlation","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Test data scatter plot\n#sns.pairplot(Test)\n#Similarly, some have aa positive correlation and negative correlation between different paired variables","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Preparing Data for machine learning"},{"metadata":{},"cell_type":"markdown","source":"# Rescaling Data"},{"metadata":{"trusted":true},"cell_type":"code","source":"#Rescaling\n#Since I might use features like regression and neural networks and algorithms that use distance measures like k-Nearest Neighbors. \n#I need to rescale my data using scikit-learn using the MinMaxScaler class","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#We rescale to make sure all our data values lie in a scale from 0 to 1\n#from numpy import set_printoptions\n#from sklearn.preprocessing import MinMaxScaler\n\n#array = Train.values\n# separate array into input and output components\n#X = array[:,0:11]\n#Y = array[:,11]\n#scaler = MinMaxScaler(feature_range=(0, 1))\n#rescaledX = scaler.fit_transform(X)\n# summarize transformed data\n#set_printoptions(precision=3)\n#print(rescaledX[0:5,:])\n\n#Indeed all our data values have been rescaled","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# standardization of data\n```from sklearn.preprocessing import StandardScaler\n\narray2 = data.values\n#separate array into input and output components\nX = array2[:,0:8]\nY = array2[:,8]\nscaler = StandardScaler().fit(X)\nrescaledX = scaler.transform(X)\n# summarize transformed data\nset_printoptions(precision=3)\nprint(rescaledX[0:5,:])\n```\n\n# Normalization of data\n``from sklearn.preprocessing import Normalizer\n\narray3 = data.values\n#separate array into input and output components\nX = array3[:,0:8]\nY = array3[:,8]\nscaler = Normalizer().fit(X)\nnormalizedX = scaler.transform(X)\n#summarize transformed data\nset_printoptions(precision=3)\nprint(normalizedX[0:5,:])\nprint(type(normalizedX))#print the data type so we can know what we are \n#working with in the dataset.\n```\n\n```# Binarizing data\nfrom sklearn.preprocessing import Binarizer\n\narray4 = data.values\n#separate array into input and output components\nX = array4[:,0:11]\nY = array4[:,11]\nbinarizer = Binarizer(threshold=0.0).fit(X)\nbinaryX = binarizer.transform(X)\n#summarize transformed data\nset_printoptions(precision=3)\nprint(binaryX[0:5,:])\n```\n\n"},{"metadata":{},"cell_type":"markdown","source":"# using Standardized generation"},{"metadata":{"trusted":true},"cell_type":"code","source":"#standardizing data\n#from sklearn.preprocessing import StandardScaler\n\n#array2 = Train.values\n# separating array into input and output components\n#X = array2[:,0:11]\n#Y = array2[:,11]\n#scaler = StandardScaler().fit(X)\n#rescaledX = scaler.transform(X)\n\n# summarizing transformed data\n#set_printoptions(precision=3)\n#print(rescaledX[0:5,:])","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Binarizing data\n## This will help incase there are probabilities in the data that need to be turned into crisp values."},{"metadata":{"trusted":true},"cell_type":"code","source":"# binarization\n# It will turn data into 0s and 1s\nfrom numpy import set_printoptions\nfrom sklearn.preprocessing import Binarizer\n\narray4 = Train.values\n# separate array into input and output components\nX = array4[:,0:11]\nY = array4[:,11]\nbinarizer = Binarizer(threshold=0.0).fit(X)\nbinaryX = binarizer.transform(X)\n# summarize transformed data\nset_printoptions(precision=3)\nprint(binaryX[0:7,:]) #I am selecting the 7 best attributes out of the 11 to cover atleast 50% of the selected attributes\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Feature Selection"},{"metadata":{"trusted":true},"cell_type":"code","source":"#Using the Recursive elimination\n#from sklearn.feature_selection import RFE\n#from sklearn.linear_model import LogisticRegression\n\n#array_1 = Train.values\n#X = array_1[:,0:11]\n#Y = array_1[:,11]\n\n# Extracting features\n#model = LogisticRegression()\n#rfe = RFE(model, 3)\n#fit = rfe.fit(X, Y)\n#print(\"Num Features: \", fit.n_features_)\n#print(\"Selected Features:\", fit.support_)\n#print(\"Feature Ranking: \", fit.ranking_)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#evaluating perfomance\n#from sklearn.model_selection import train_test_split\n#from sklearn.linear_model import LogisticRegression\n\n#array = Train.values\n#X = array[:,0:11]\n#Y = array[:,11]\n#test_size = 0.33\n#seed = 10\n#X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=test_size, random_state=seed)\n#model = LogisticRegression()\n#model.fit(X_train, Y_train)\n#result = model.score(X_test, Y_test)\n#print(\"Accuracy: \", (result*100.0))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#model output","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#out = model.predict(Test.values)\n\n#KC = pd.DataFrame(out) #Converting to data frame\n#KC.columns=[\"CLASS\"] #Naming the column\n#KC.index.name=\"Index\" #Creating a column index\n#KC[\"CLASS\"]=KC[\"CLASS\"].map({0.0:False,1.0:True}) # Chaninging 0 to \"False\" 1 to \"True\"\n\n#KC.to_csv(\"KC_csv\") ## Writing a csv file\n#print(KC['CLASS'].unique())\n#print(KC['CLASS'].nunique())\n\n#printing the numbers of False and True\n#print(KC.groupby('CLASS').size()[0].sum()) #\n#print(KC.groupby('CLASS').size()[1].sum())","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#from sklearn.preprocessing import StandardScaler\n\n#array2 = Train.values\n# separating array into input and output components\n#X = array2[:,0:11]\n#Y = array2[:,11]\n#scaler = StandardScaler().fit(X)\n#rescaledX = scaler.transform(X)\n# transformed data should be summarized using the code below\n#set_printoptions(precision=3)\n#print(rescaledX[0:5,:])","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Principal Component analysis feature"},{"metadata":{"trusted":true},"cell_type":"code","source":"#Training the model using PCA as the feature of choice\n#from sklearn.decomposition import PCA\n\n#array = Train.values\n#X = array[:,0:11]\n#Y = array[:,11]\n\n# feature extraction\n#pca = PCA(n_components=3)\n#fit = pca.fit(X)\n# summarize components\n#print(\"Explained Variance: \" , fit.explained_variance_ratio_)\n#print(fit.components_)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Output model using PCA as the feature"},{"metadata":{"trusted":true},"cell_type":"code","source":"#out = model.predict(Test.values)\n\n#KC2 = pd.DataFrame(out) #Converting the data to data frame\n#KC2.columns=[\"CLASS\"] #Naming the column\n#KC2.index.name=\"Index\" #Creating a column index\n#KC2[\"CLASS\"]=KC2[\"CLASS\"].map({0.0:False,1.0:True}) # Chaninging 0 to \"False\" 1 to \"True\"\n\n#KC2.to_csv(\"KC2_csv\") # obtaininng a csv file\n#print(KC2['CLASS'].unique())\n#print(KC2['CLASS'].nunique())\n\n#printing the numbers of False and True\n#print(KC2.groupby('CLASS').size()[0].sum()) #\n#print(KC2.groupby('CLASS').size()[1].sum())","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#print(\"Hello\")","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# sklearn.feature_selection.SelectFromModel\n## Parameters for the model\n\n### estimator: object\n```The base estimator from which the transformer is built. This can be both a fitted (if prefit is set to True) or a non-fitted estimator. The estimator must have either a feature_importances_ or coef_ attribute after fitting.\nFeatures whose importance is greater or equal are kept while the others are discarded. If “median” (resp. “mean”), then the threshold value is the median (resp. the mean) of the feature importances. A scaling factor (e.g., “1.25*mean”) may also be used. If None and if the estimator has a parameter penalty set to l1, either explicitly or implicitly (e.g, Lasso), the threshold used is 1e-5. Otherwise, “mean” is used by default.\nWhether a prefit model is expected to be passed into the constructor directly or not. If True, transform must be called directly and SelectFromModel cannot be used with cross_val_score, GridSearchCV and similar utilities that clone the estimator. Otherwise train the model using fit and then transform to do feature selection.```"},{"metadata":{"trusted":true},"cell_type":"code","source":"from sklearn.feature_selection import SelectFromModel\nfrom sklearn.linear_model import LogisticRegression\n\narray6 = Train.values\nX = array6[:,0:11]\nY = array6[:,11]\n\n#fitting to the model\nselector = SelectFromModel(estimator=LogisticRegression()).fit(X, Y)\nselector.estimator_.coef_\narray6\nselector.threshold_\n\nselector.get_support()\narray6\nselector.transform(X)\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Logistic model output"},{"metadata":{"trusted":true},"cell_type":"code","source":"#model2 = model.predict(Test.values)\n\n#KC3 = pd.DataFrame(model2) #Converting the data to data frame\n#KC3.columns=[\"CLASS\"] #Naming the column\n#KC3.index.name=\"Index\" #Creating a column index\n#KC3[\"CLASS\"]=KC3[\"CLASS\"].map({0.0:False,1.0:True}) # Chaninging 0 to \"False\" 1 to \"True\"\n\n#KC3.to_csv(\"KC3_csv\") # obtaininng a csv file\n#print(KC3['CLASS'].unique())\n#print(KC3['CLASS'].nunique())\n\n#printing the numbers of False and True\n#print(KC3.groupby('CLASS').size()[0].sum()) \n#print(KC3.groupby('CLASS').size()[1].sum())","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Recursive feature model elimination"},{"metadata":{"trusted":true},"cell_type":"code","source":"#import numpy as np\n#from sklearn.feature_selection import RFE\n#from sklearn.svm import SVR\n#array8 = Train.values\n#array8 = Train.values\n#X = array8[:,0:11]\n#Y = array8[:,11]\n#estimator = SVR(kernel=\"linear\")\n#selector = RFE(estimator, 5, step=1)\n#selector = selector.fit(X, Y)\n#set_printoptions(precision=3)\n#print(estimator[0:7,:]) #To print out the chosen 7 attributes that best fit the data","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#from sklearn.linear_model import ElasticNet\n#from sklearn.datasets import make_regression\n#X, Y = Train(n_features=2, random_state=0)\n#regr = ElasticNet(random_state=0)\n#regr.fit(X, Y)\n#ElasticNet(random_state=0)\n#print(regr.coef_)\n#print(regr.intercept_)\n#print(regr.predict([[0, 0]]))\n\n#model2 = model.predict(Test.values)\n\n#KC3 = pd.DataFrame(model2) #Converting the data to data frame\n#KC3.columns=[\"CLASS\"] #Naming the column\n#KC3.index.name=\"Index\" #Creating a column index\n#KC3[\"CLASS\"]=KC3[\"CLASS\"].map({0.0:False,1.0:True}) # Chaninging 0 to \"False\" 1 to \"True\"\n\n#KC3.to_csv(\"KC3_csv\") # obtaininng a csv file\n#print(KC3['CLASS'].unique())\n#print(KC3['CLASS'].nunique())\n\n#printing the numbers of False and True\n#print(KC3.groupby('CLASS').size()[0].sum()) \n#print(KC3.groupby('CLASS').size()[1].sum())\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"from sklearn import linear_model\nreg = linear_model.Lasso(alpha=0.1)\nreg.fit([[0, 0], [1, 1]], [0, 1])\nLasso(alpha=0.1)\nreg.predict([[1, 1]])\narray([0.8])","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Comparison of different models\n## To select which model works best\n```A comparison of all models will enable me select out which models best suit the data.\nFrom these, I can pick out which one gives best accuracy and perfom an MCM statistics.```\n"},{"metadata":{},"cell_type":"markdown","source":"# Linear regression\n```Linear regression fits a linear model with coefficients to minimize the residual sum of squares between the observed targets in the dataset, and the targets predicted by the linear approximation. Linear regression will enable me fit the best line on the distributions in the data. There are more advanced ways to fit a line to data, but in general, I want the line to go through the \"middle\" of the points.```\n\n# Histogram-based Gradient Boosting Classification Tree\n```Although Gradient boosting is a greedy algorithm and can overfit a training dataset quickly, It can benefit from regularization methods that penalize various parts of the algorithm and generally improve the performance of the algorithm by reducing overfitting. I want to use this model to checkfo overfitting .```\n\n# K-fold\n```When we split the dataset into training and test set, we use only a subset of data and we know when we train on fewer observations the model will not perform well and overestimate the test error rate for the model to fit on the entire dataset. We correct for this by using a K-fold cross-validation with a specified number of kfolds. Cross-validation will give me a more accurate estimate of a model’s performance```\n\n# XGBClassifier\n```XGBoost is an efficient and easy to use an algorithm which delivers high performance and accuracy as compared to other algorithms. I added XGBClassifier because it has in-built L1 (Lasso Regression) and L2 (Ridge Regression) regularization which prevents the model from overfitting.```\n\n# RandomForestClassifier \n``` I added Random forest classifier because it is one of the most accurate learning algorithms available. For many data sets, it produces a highly accurate classifier. It runs efficiently on large databases. It can handle thousands of input variables without variable deletion. It will be a good basis to compare other models```\n\n# SGDClassifier\n``` Stochastic Gradient Descent (SGD) is a simple yet very efficient approach to discriminative learning of linear classifiers under convex loss functions such as (linear) Support Vector Machines and Logistic Regression. I chose to add it as one of the models has been successfully applied to large-scale and sparse machine learning problems often encountered in text classification and natural language processing. This classifier supports multi-class classification by combining multiple binary classifiers in a “one versus all” (OVA) scheme.```\n\n# DecisionTreeClassifier\n```Thi algorithm is simpler to understand, interpret and visualize. Effort required for Data preparation is minimal. Additionally, decision trees combined into an ensemble create some of the best binary classifiers.```\n\n# BaggingClassifier \n```Bagging takes the advantage of ensemble learning wherein multiple weak learner outperform a single strong learner. It helps reduce variance and thus helps us avoid overfitting. There is loss of interpretability of the model. There can possibly be a problem of high bias if not modeled properly.```\n\n# Coss validation score\n```Using cross validation can give me a hint of how well my model is doing, and it has the advantage of being very robust (as opposed to simple train-test split). It can be also used in hyper-tuning of parameters: for a given parameters, using the CV score to optimize its value in a robust way.```\n\n# LogisticRegression \n```I chose Logistic Regression because performs well when the dataset is linearly separable.Logistic regression is less prone to over-fitting but it can overfit in high dimensional datasets. Logistic Regression not only gives a measure of how relevant a predictor (coefficient size) is, but also its direction of association (positive or negative). Logistic regression is easier to implement, interpret and very efficient to train. It would work well in prediciting my model.```\n\n# KNeighborsClassifier\n```I chose this algorithm because it is simple and easy to implement. There's no need to build a model, tune several parameters, or make additional assumptions. The algorithm is versatile. It can be used for classification, regression, and search.```\n\n# LinearDiscriminantAnalysis\n```LDA in the binary-class case has been shown to be equivalent to linear regression with the class label as the output. This implies that LDA for binary-class classifications can be formulated as a least squares problem. It will give me a good comparison with the linear regression model already included.```\n\n# GaussianNB \n```I chose the naive Bayesian classifier because they are extremely fast for both training and prediction. They provide straightforward probabilistic prediction. This classifier needs less training data, highly scalable. It scales linearly with the number of predictors and data points. Can be used for both binary and mult-iclass classification problems. Can make probabilistic predictions. Handles continuous and discrete data. Not sensitive to irrelevant features. It would therefore be a good model to include in the testing algorithms```\n\n# SVC\n``I added this model beause SVM Classifiers offer good accuracy and perform faster prediction compared to Naïve Bayes algorithm.They willhelp me audit the naive bayes classifier. They also use less memory because they use a subset of training points in the decision phase. SVM works well with a clear margin of separation and with high dimensional space. Evenwhen my dimentional space is not that big, its worth a try.```\n\n# HistGradientBoostingClassifier\n```This is one of the ensemble methods. The goal of ensemble methods is to combine the predictions of several base estimators built with a given learning algorithm in order to improve generalizability / robustness over a single estimator. It will give me a good comparison with the model.```\n\n\n\n\n\n\n"},{"metadata":{"trusted":true},"cell_type":"code","source":"# Models comparison\nfrom sklearn import linear_model\nfrom sklearn.experimental import enable_hist_gradient_boosting\nfrom sklearn.model_selection import KFold\nfrom xgboost import XGBClassifier\nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn.linear_model import SGDClassifier\nfrom sklearn.tree import DecisionTreeClassifier\nfrom sklearn.ensemble import BaggingClassifier\nfrom sklearn.model_selection import cross_val_score\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.neighbors import KNeighborsClassifier\nfrom sklearn.discriminant_analysis import LinearDiscriminantAnalysis\nfrom sklearn.naive_bayes import GaussianNB\nfrom sklearn.svm import SVC\nfrom sklearn.ensemble import HistGradientBoostingClassifier","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Combining all models\nmodels = []\nmodels.append(('LR', LogisticRegression()))\nmodels.append(('LDA', LinearDiscriminantAnalysis()))\nmodels.append(('RFC',RandomForestClassifier()))\nmodels.append(('BAG',BaggingClassifier()))\nmodels.append(('XGB',XGBClassifier()))\nmodels.append(('SGD',SGDClassifier()))\nmodels.append(('HGB',HistGradientBoostingClassifier()))\nmodels.append(('NB', GaussianNB()))\nmodels.append(('SVM', SVC()))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# EStimating accuracy of the models\n## Model accuracy\n```The accuracy of the models is determined to inform the next step over which is the most \naccurate model to follow.```"},{"metadata":{"trusted":true},"cell_type":"code","source":"# The comparative accuracies of the models is determined\n\nresults = []\nnames = []\nscoring = 'accuracy'\n\nfor name, model in models:\n kfold = KFold(n_splits=10, random_state=7)\n cv_results = cross_val_score(model, X, Y, cv=kfold, scoring=scoring)\n results.append(cv_results)\n names.append(name)\n kc4 = (name, cv_results.mean(), cv_results.std())\n print(kc4)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Model chosen\n## NB', GaussianNB() \n```GaussianNB shows the highest accuracy, at 88%.\nI chose to test this further. Furtherstill, I choose this particular model because of the boxplot comparison\nIt has a small error from the mean. Thus its accuracy can be trusted to a better extent compared to other models```"},{"metadata":{},"cell_type":"markdown","source":"# Graph to show comparisons"},{"metadata":{"trusted":true},"cell_type":"code","source":"fig = plt.figure()\nfig.suptitle('Comparison of models')\nax = fig.add_subplot(111)\nplt.boxplot(results)\nax.set_xticklabels(names)\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Testing the model on Matthew's Correlation Coefficient\n``` To futher test for a better metric than accuracy, I will test the GaussianNB modle on Matthew's correlation```"},{"metadata":{"trusted":true},"cell_type":"code","source":"from sklearn.model_selection import train_test_split\nfrom sklearn.metrics import matthews_corrcoef\n\narray= Train.values\nX = array[:,0:11]\nY = array[:,11]\ntest_size = 0.33\nseed = 7\nX_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=test_size,\nrandom_state=seed)\n\nkintu_model2 = LogisticRegression()\nkintu_model2.fit(X_train, Y_train)\n\npredicted3= kintu_model2.predict(X_test)\ncomp_mat = matthews_corrcoef(Y_test, predicted3)\nprint(comp_mat)\n\n#Mathews correlation coefficient gives a moderate","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Generating the csv file\n``` I generate a csv file to enable me judge the accuracy of this model and submit to the competition.```"},{"metadata":{"trusted":true},"cell_type":"code","source":"#Generating a csv file\nkintu_df=pd.DataFrame(predicted3)\nkintu_df.columns=['CLASS']\nkintu_df.index.names=[\"Index\"]\nkintu_df['CLASS']=kintu_df['CLASS'].map({0.0:False, 1.0:True})\nkintu_df\nkintu_df.to_csv('KC_model2_csv')\nprint(kintu_df['CLASS'].unique())","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Re-testingLinear Regression\n```Running each model seperately to allow me change certain parameters \nthat are not possible tochange when doing an overall comparison```"},{"metadata":{"trusted":true},"cell_type":"code","source":"import numpy as np\nfrom sklearn.linear_model import LinearRegression\narray2 = Train.values\nreg = LinearRegression().fit(X, Y)\nreg.score(X, Y)\nscoring = ('Accuracy')\nreg.coef_\nreg.intercept_\nxp = reg.predict(X)\nxp\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"","execution_count":null,"outputs":[]}],"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat":4,"nbformat_minor":4} \ No newline at end of file From 27e9baee5b9e0287341ad860be80eefecf16eb20 Mon Sep 17 00:00:00 2001 From: Atwine Date: Fri, 27 Mar 2020 12:57:37 +0300 Subject: [PATCH 5/5] kintu --- Assignment Colab/Christopher Kintu.ipynb | 2395 +++++++++++++++++++++- pandas_exercises | 1 + 2 files changed, 2395 insertions(+), 1 deletion(-) create mode 160000 pandas_exercises diff --git a/Assignment Colab/Christopher Kintu.ipynb b/Assignment Colab/Christopher Kintu.ipynb index f0cb391..0fdd878 100644 --- a/Assignment Colab/Christopher Kintu.ipynb +++ b/Assignment Colab/Christopher Kintu.ipynb @@ -1 +1,2394 @@ -{"cells":[{"metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"cell_type":"code","source":"#First importing the necessary libraries helpful in building and/or testing the model\n#Three main libraries for a start: numpy, pandas, matplotlib.pyplot\n#numpy is for linear algebra, pandas for data processing\n\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Kintu Christopher\n## This is my assignment.\n## I am in to win the competition\n\n```import os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n for filename in filenames:\n print(os.path.join(dirname, filename))```\n \n \n"},{"metadata":{"trusted":true},"cell_type":"code","source":"\n# Input data files necessary for this assignment were obtained from \"../input/\" directory.\n\nimport os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n for filename in filenames:\n print(os.path.join(dirname, filename))\n\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#ignoring warnings: It is necessary to import while ignoring warnings\n\nimport warnings\nwarnings.filterwarnings('ignore')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# The data sets are loaded and read as below in form of csv files\nTrain = pd.read_csv(\"../input/ace-class-assignment/AMP_TrainSet.csv\")\nTest = pd.read_csv(\"../input/ace-class-assignment/Test.csv\")","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Data visualization\n## The data is loaded for viewing directly from the ACE_class_Assignment folder. This displays, in tabular format, the real values we are to work with."},{"metadata":{"trusted":true},"cell_type":"code","source":"#There is need to know how many dimensions our data has\n# This helps me to know how many rows or columns are in each data set and also how large the data set is.\n#Too many rows and columns require a longer time to train the model.\n\nTrain.shape, Test.shape\n\n# The Train data set has 12 columns and 3038 rows. \n# The Test data set has 758 rows and 11 columns\n#This means our Train data is large enough to train the algorithm without over training or under training","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Checking the column variables for the Train data set\n#This gives me an idea of the variables I am dealing with and how they are labelled.\n\nTrain.columns","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Similarly, checking for column variables for the Test data set\n\nTest.columns","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# It is good to also take a look at they data types for each data set. \n#Just incase there are strings that need to be converted into floats \n\n#First, the train data set\nTrain.dtypes\n\n#The data type of the train set is an object\n#The column variables are all floats and integers as shown below","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Similarly, for the Test data set\n\nTest.dtypes\n\n#It is an object, with floats and integers only. \n#This is good, we dont need to change anything.\n#We are good to go.","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Checking for quick statistical comparisons\n## This will quickly give me a view of the relationship between variables."},{"metadata":{"trusted":true},"cell_type":"code","source":"#We check out quick summary statistics for both data sets\n\nTrain.describe()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#summary statistics for the Test data set too\n\nTest.describe()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Attribute Correlations\n## It is important to check whether different attributes have a positive or negative correlation or none."},{"metadata":{"trusted":true},"cell_type":"code","source":"#Assuming a Gaussian distribution for both data stes; we shall use the pearson correlation\n\nTrain.corr(method = 'pearson')\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Correlation on the Test data set\n\nTest.corr(method = 'pearson')\n\n#A quci eyeball shows all variables have some form of correlation to each other. \n#There is no variable with zero correlation to another","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Plotting the data\n## Upon noticing some correlation, it is good to cisualize it in a heatmap"},{"metadata":{"trusted":true},"cell_type":"code","source":"# Visualizing correlations between attributes using heatmaps\n#import the necessary library; seaborn\n\nimport seaborn as sns\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#plot a heat map for the Test data set\nplt.figure(figsize=(6,6))\nsns.heatmap(Test.corr(method='pearson'))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Heat map for the Train data set\nplt.figure(figsize=(6,6))\nsns.heatmap(Train.corr(method='pearson'))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Testing for skewness of variables\n# This will be important incase some variables are skewed either positively or negatively since we are assuming a Gaussian distribution. Correcting for this skewness improves on the accuracy of the model."},{"metadata":{"trusted":true},"cell_type":"code","source":"#Skewness of distributions on the Train data set\nTrain.skew().plot(kind= 'bar')\n\n#The NT_EFC195 show a high right skew (above 1).\n#We shall have to correct for this to improve the model accuracy\n#This we shall do by finding the square root, cube root or a logarithmic transformation","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Testing for skewness on the Train Data set\n\nTest.skew().plot(kind= 'bar')\n\n# This data set also has a high positive skew for the NT_EFC195 variable as well","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Understanding my data\n# Different plots will give me a good insight into what to do next with the data I have.Plots like histograms, scatter plots are good to give a genearl view"},{"metadata":{"trusted":true},"cell_type":"code","source":"#Plotting a histogram for the Train Data\n\nplt.figure(figsize=(15,15))\nTrain.hist()\nplt.show()\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Plotting a histogram for the Test Data\n\nplt.figure(figsize=(15,15))\nTest.hist()\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Rug plots\n#The rugplots are like histograms except they show every single data point on the x-axis, allowing us to visualize all of the actual values\n#Both the Train and Test rugplots indicate some kind of left skew. This we need to take into account when designing the model","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"sns.distplot(Train, hist = False, kde = True, rug = True, color = 'darkblue', kde_kws={'linewidth': 3}, rug_kws={'color': 'black'})","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"sns.distplot(Test, hist = False, kde = True, rug = True, color = 'darkblue', kde_kws={'linewidth': 3}, rug_kws={'color': 'black'})","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Box plots","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Train\nTrain.plot(kind='box', subplots=True, layout=(12,12), sharex=False, sharey=False)\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Test\nTest.plot(kind='box', subplots=True, layout=(12,12), sharex=False, sharey=False)\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Scatter Plot matrix\n#scatter plot matrix shows the relationship between two variables as dots in two dimensions all at once","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#sns.pairplot(Train)\n#The scatter plot for the train dataset indicates a mixture of correlations for different variables. \n#Some have a positive strong correlation, others a negative correlation","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Test data scatter plot\n#sns.pairplot(Test)\n#Similarly, some have aa positive correlation and negative correlation between different paired variables","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Preparing Data for machine learning"},{"metadata":{},"cell_type":"markdown","source":"# Rescaling Data"},{"metadata":{"trusted":true},"cell_type":"code","source":"#Rescaling\n#Since I might use features like regression and neural networks and algorithms that use distance measures like k-Nearest Neighbors. \n#I need to rescale my data using scikit-learn using the MinMaxScaler class","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#We rescale to make sure all our data values lie in a scale from 0 to 1\n#from numpy import set_printoptions\n#from sklearn.preprocessing import MinMaxScaler\n\n#array = Train.values\n# separate array into input and output components\n#X = array[:,0:11]\n#Y = array[:,11]\n#scaler = MinMaxScaler(feature_range=(0, 1))\n#rescaledX = scaler.fit_transform(X)\n# summarize transformed data\n#set_printoptions(precision=3)\n#print(rescaledX[0:5,:])\n\n#Indeed all our data values have been rescaled","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# standardization of data\n```from sklearn.preprocessing import StandardScaler\n\narray2 = data.values\n#separate array into input and output components\nX = array2[:,0:8]\nY = array2[:,8]\nscaler = StandardScaler().fit(X)\nrescaledX = scaler.transform(X)\n# summarize transformed data\nset_printoptions(precision=3)\nprint(rescaledX[0:5,:])\n```\n\n# Normalization of data\n``from sklearn.preprocessing import Normalizer\n\narray3 = data.values\n#separate array into input and output components\nX = array3[:,0:8]\nY = array3[:,8]\nscaler = Normalizer().fit(X)\nnormalizedX = scaler.transform(X)\n#summarize transformed data\nset_printoptions(precision=3)\nprint(normalizedX[0:5,:])\nprint(type(normalizedX))#print the data type so we can know what we are \n#working with in the dataset.\n```\n\n```# Binarizing data\nfrom sklearn.preprocessing import Binarizer\n\narray4 = data.values\n#separate array into input and output components\nX = array4[:,0:11]\nY = array4[:,11]\nbinarizer = Binarizer(threshold=0.0).fit(X)\nbinaryX = binarizer.transform(X)\n#summarize transformed data\nset_printoptions(precision=3)\nprint(binaryX[0:5,:])\n```\n\n"},{"metadata":{},"cell_type":"markdown","source":"# using Standardized generation"},{"metadata":{"trusted":true},"cell_type":"code","source":"#standardizing data\n#from sklearn.preprocessing import StandardScaler\n\n#array2 = Train.values\n# separating array into input and output components\n#X = array2[:,0:11]\n#Y = array2[:,11]\n#scaler = StandardScaler().fit(X)\n#rescaledX = scaler.transform(X)\n\n# summarizing transformed data\n#set_printoptions(precision=3)\n#print(rescaledX[0:5,:])","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Binarizing data\n## This will help incase there are probabilities in the data that need to be turned into crisp values."},{"metadata":{"trusted":true},"cell_type":"code","source":"# binarization\n# It will turn data into 0s and 1s\nfrom numpy import set_printoptions\nfrom sklearn.preprocessing import Binarizer\n\narray4 = Train.values\n# separate array into input and output components\nX = array4[:,0:11]\nY = array4[:,11]\nbinarizer = Binarizer(threshold=0.0).fit(X)\nbinaryX = binarizer.transform(X)\n# summarize transformed data\nset_printoptions(precision=3)\nprint(binaryX[0:7,:]) #I am selecting the 7 best attributes out of the 11 to cover atleast 50% of the selected attributes\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Feature Selection"},{"metadata":{"trusted":true},"cell_type":"code","source":"#Using the Recursive elimination\n#from sklearn.feature_selection import RFE\n#from sklearn.linear_model import LogisticRegression\n\n#array_1 = Train.values\n#X = array_1[:,0:11]\n#Y = array_1[:,11]\n\n# Extracting features\n#model = LogisticRegression()\n#rfe = RFE(model, 3)\n#fit = rfe.fit(X, Y)\n#print(\"Num Features: \", fit.n_features_)\n#print(\"Selected Features:\", fit.support_)\n#print(\"Feature Ranking: \", fit.ranking_)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#evaluating perfomance\n#from sklearn.model_selection import train_test_split\n#from sklearn.linear_model import LogisticRegression\n\n#array = Train.values\n#X = array[:,0:11]\n#Y = array[:,11]\n#test_size = 0.33\n#seed = 10\n#X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=test_size, random_state=seed)\n#model = LogisticRegression()\n#model.fit(X_train, Y_train)\n#result = model.score(X_test, Y_test)\n#print(\"Accuracy: \", (result*100.0))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#model output","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#out = model.predict(Test.values)\n\n#KC = pd.DataFrame(out) #Converting to data frame\n#KC.columns=[\"CLASS\"] #Naming the column\n#KC.index.name=\"Index\" #Creating a column index\n#KC[\"CLASS\"]=KC[\"CLASS\"].map({0.0:False,1.0:True}) # Chaninging 0 to \"False\" 1 to \"True\"\n\n#KC.to_csv(\"KC_csv\") ## Writing a csv file\n#print(KC['CLASS'].unique())\n#print(KC['CLASS'].nunique())\n\n#printing the numbers of False and True\n#print(KC.groupby('CLASS').size()[0].sum()) #\n#print(KC.groupby('CLASS').size()[1].sum())","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#from sklearn.preprocessing import StandardScaler\n\n#array2 = Train.values\n# separating array into input and output components\n#X = array2[:,0:11]\n#Y = array2[:,11]\n#scaler = StandardScaler().fit(X)\n#rescaledX = scaler.transform(X)\n# transformed data should be summarized using the code below\n#set_printoptions(precision=3)\n#print(rescaledX[0:5,:])","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Principal Component analysis feature"},{"metadata":{"trusted":true},"cell_type":"code","source":"#Training the model using PCA as the feature of choice\n#from sklearn.decomposition import PCA\n\n#array = Train.values\n#X = array[:,0:11]\n#Y = array[:,11]\n\n# feature extraction\n#pca = PCA(n_components=3)\n#fit = pca.fit(X)\n# summarize components\n#print(\"Explained Variance: \" , fit.explained_variance_ratio_)\n#print(fit.components_)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Output model using PCA as the feature"},{"metadata":{"trusted":true},"cell_type":"code","source":"#out = model.predict(Test.values)\n\n#KC2 = pd.DataFrame(out) #Converting the data to data frame\n#KC2.columns=[\"CLASS\"] #Naming the column\n#KC2.index.name=\"Index\" #Creating a column index\n#KC2[\"CLASS\"]=KC2[\"CLASS\"].map({0.0:False,1.0:True}) # Chaninging 0 to \"False\" 1 to \"True\"\n\n#KC2.to_csv(\"KC2_csv\") # obtaininng a csv file\n#print(KC2['CLASS'].unique())\n#print(KC2['CLASS'].nunique())\n\n#printing the numbers of False and True\n#print(KC2.groupby('CLASS').size()[0].sum()) #\n#print(KC2.groupby('CLASS').size()[1].sum())","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#print(\"Hello\")","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# sklearn.feature_selection.SelectFromModel\n## Parameters for the model\n\n### estimator: object\n```The base estimator from which the transformer is built. This can be both a fitted (if prefit is set to True) or a non-fitted estimator. The estimator must have either a feature_importances_ or coef_ attribute after fitting.\nFeatures whose importance is greater or equal are kept while the others are discarded. If “median” (resp. “mean”), then the threshold value is the median (resp. the mean) of the feature importances. A scaling factor (e.g., “1.25*mean”) may also be used. If None and if the estimator has a parameter penalty set to l1, either explicitly or implicitly (e.g, Lasso), the threshold used is 1e-5. Otherwise, “mean” is used by default.\nWhether a prefit model is expected to be passed into the constructor directly or not. If True, transform must be called directly and SelectFromModel cannot be used with cross_val_score, GridSearchCV and similar utilities that clone the estimator. Otherwise train the model using fit and then transform to do feature selection.```"},{"metadata":{"trusted":true},"cell_type":"code","source":"from sklearn.feature_selection import SelectFromModel\nfrom sklearn.linear_model import LogisticRegression\n\narray6 = Train.values\nX = array6[:,0:11]\nY = array6[:,11]\n\n#fitting to the model\nselector = SelectFromModel(estimator=LogisticRegression()).fit(X, Y)\nselector.estimator_.coef_\narray6\nselector.threshold_\n\nselector.get_support()\narray6\nselector.transform(X)\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Logistic model output"},{"metadata":{"trusted":true},"cell_type":"code","source":"#model2 = model.predict(Test.values)\n\n#KC3 = pd.DataFrame(model2) #Converting the data to data frame\n#KC3.columns=[\"CLASS\"] #Naming the column\n#KC3.index.name=\"Index\" #Creating a column index\n#KC3[\"CLASS\"]=KC3[\"CLASS\"].map({0.0:False,1.0:True}) # Chaninging 0 to \"False\" 1 to \"True\"\n\n#KC3.to_csv(\"KC3_csv\") # obtaininng a csv file\n#print(KC3['CLASS'].unique())\n#print(KC3['CLASS'].nunique())\n\n#printing the numbers of False and True\n#print(KC3.groupby('CLASS').size()[0].sum()) \n#print(KC3.groupby('CLASS').size()[1].sum())","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Recursive feature model elimination"},{"metadata":{"trusted":true},"cell_type":"code","source":"#import numpy as np\n#from sklearn.feature_selection import RFE\n#from sklearn.svm import SVR\n#array8 = Train.values\n#array8 = Train.values\n#X = array8[:,0:11]\n#Y = array8[:,11]\n#estimator = SVR(kernel=\"linear\")\n#selector = RFE(estimator, 5, step=1)\n#selector = selector.fit(X, Y)\n#set_printoptions(precision=3)\n#print(estimator[0:7,:]) #To print out the chosen 7 attributes that best fit the data","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#from sklearn.linear_model import ElasticNet\n#from sklearn.datasets import make_regression\n#X, Y = Train(n_features=2, random_state=0)\n#regr = ElasticNet(random_state=0)\n#regr.fit(X, Y)\n#ElasticNet(random_state=0)\n#print(regr.coef_)\n#print(regr.intercept_)\n#print(regr.predict([[0, 0]]))\n\n#model2 = model.predict(Test.values)\n\n#KC3 = pd.DataFrame(model2) #Converting the data to data frame\n#KC3.columns=[\"CLASS\"] #Naming the column\n#KC3.index.name=\"Index\" #Creating a column index\n#KC3[\"CLASS\"]=KC3[\"CLASS\"].map({0.0:False,1.0:True}) # Chaninging 0 to \"False\" 1 to \"True\"\n\n#KC3.to_csv(\"KC3_csv\") # obtaininng a csv file\n#print(KC3['CLASS'].unique())\n#print(KC3['CLASS'].nunique())\n\n#printing the numbers of False and True\n#print(KC3.groupby('CLASS').size()[0].sum()) \n#print(KC3.groupby('CLASS').size()[1].sum())\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"from sklearn import linear_model\nreg = linear_model.Lasso(alpha=0.1)\nreg.fit([[0, 0], [1, 1]], [0, 1])\nLasso(alpha=0.1)\nreg.predict([[1, 1]])\narray([0.8])","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Comparison of different models\n## To select which model works best\n```A comparison of all models will enable me select out which models best suit the data.\nFrom these, I can pick out which one gives best accuracy and perfom an MCM statistics.```\n"},{"metadata":{},"cell_type":"markdown","source":"# Linear regression\n```Linear regression fits a linear model with coefficients to minimize the residual sum of squares between the observed targets in the dataset, and the targets predicted by the linear approximation. Linear regression will enable me fit the best line on the distributions in the data. There are more advanced ways to fit a line to data, but in general, I want the line to go through the \"middle\" of the points.```\n\n# Histogram-based Gradient Boosting Classification Tree\n```Although Gradient boosting is a greedy algorithm and can overfit a training dataset quickly, It can benefit from regularization methods that penalize various parts of the algorithm and generally improve the performance of the algorithm by reducing overfitting. I want to use this model to checkfo overfitting .```\n\n# K-fold\n```When we split the dataset into training and test set, we use only a subset of data and we know when we train on fewer observations the model will not perform well and overestimate the test error rate for the model to fit on the entire dataset. We correct for this by using a K-fold cross-validation with a specified number of kfolds. Cross-validation will give me a more accurate estimate of a model’s performance```\n\n# XGBClassifier\n```XGBoost is an efficient and easy to use an algorithm which delivers high performance and accuracy as compared to other algorithms. I added XGBClassifier because it has in-built L1 (Lasso Regression) and L2 (Ridge Regression) regularization which prevents the model from overfitting.```\n\n# RandomForestClassifier \n``` I added Random forest classifier because it is one of the most accurate learning algorithms available. For many data sets, it produces a highly accurate classifier. It runs efficiently on large databases. It can handle thousands of input variables without variable deletion. It will be a good basis to compare other models```\n\n# SGDClassifier\n``` Stochastic Gradient Descent (SGD) is a simple yet very efficient approach to discriminative learning of linear classifiers under convex loss functions such as (linear) Support Vector Machines and Logistic Regression. I chose to add it as one of the models has been successfully applied to large-scale and sparse machine learning problems often encountered in text classification and natural language processing. This classifier supports multi-class classification by combining multiple binary classifiers in a “one versus all” (OVA) scheme.```\n\n# DecisionTreeClassifier\n```Thi algorithm is simpler to understand, interpret and visualize. Effort required for Data preparation is minimal. Additionally, decision trees combined into an ensemble create some of the best binary classifiers.```\n\n# BaggingClassifier \n```Bagging takes the advantage of ensemble learning wherein multiple weak learner outperform a single strong learner. It helps reduce variance and thus helps us avoid overfitting. There is loss of interpretability of the model. There can possibly be a problem of high bias if not modeled properly.```\n\n# Coss validation score\n```Using cross validation can give me a hint of how well my model is doing, and it has the advantage of being very robust (as opposed to simple train-test split). It can be also used in hyper-tuning of parameters: for a given parameters, using the CV score to optimize its value in a robust way.```\n\n# LogisticRegression \n```I chose Logistic Regression because performs well when the dataset is linearly separable.Logistic regression is less prone to over-fitting but it can overfit in high dimensional datasets. Logistic Regression not only gives a measure of how relevant a predictor (coefficient size) is, but also its direction of association (positive or negative). Logistic regression is easier to implement, interpret and very efficient to train. It would work well in prediciting my model.```\n\n# KNeighborsClassifier\n```I chose this algorithm because it is simple and easy to implement. There's no need to build a model, tune several parameters, or make additional assumptions. The algorithm is versatile. It can be used for classification, regression, and search.```\n\n# LinearDiscriminantAnalysis\n```LDA in the binary-class case has been shown to be equivalent to linear regression with the class label as the output. This implies that LDA for binary-class classifications can be formulated as a least squares problem. It will give me a good comparison with the linear regression model already included.```\n\n# GaussianNB \n```I chose the naive Bayesian classifier because they are extremely fast for both training and prediction. They provide straightforward probabilistic prediction. This classifier needs less training data, highly scalable. It scales linearly with the number of predictors and data points. Can be used for both binary and mult-iclass classification problems. Can make probabilistic predictions. Handles continuous and discrete data. Not sensitive to irrelevant features. It would therefore be a good model to include in the testing algorithms```\n\n# SVC\n``I added this model beause SVM Classifiers offer good accuracy and perform faster prediction compared to Naïve Bayes algorithm.They willhelp me audit the naive bayes classifier. They also use less memory because they use a subset of training points in the decision phase. SVM works well with a clear margin of separation and with high dimensional space. Evenwhen my dimentional space is not that big, its worth a try.```\n\n# HistGradientBoostingClassifier\n```This is one of the ensemble methods. The goal of ensemble methods is to combine the predictions of several base estimators built with a given learning algorithm in order to improve generalizability / robustness over a single estimator. It will give me a good comparison with the model.```\n\n\n\n\n\n\n"},{"metadata":{"trusted":true},"cell_type":"code","source":"# Models comparison\nfrom sklearn import linear_model\nfrom sklearn.experimental import enable_hist_gradient_boosting\nfrom sklearn.model_selection import KFold\nfrom xgboost import XGBClassifier\nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn.linear_model import SGDClassifier\nfrom sklearn.tree import DecisionTreeClassifier\nfrom sklearn.ensemble import BaggingClassifier\nfrom sklearn.model_selection import cross_val_score\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.neighbors import KNeighborsClassifier\nfrom sklearn.discriminant_analysis import LinearDiscriminantAnalysis\nfrom sklearn.naive_bayes import GaussianNB\nfrom sklearn.svm import SVC\nfrom sklearn.ensemble import HistGradientBoostingClassifier","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Combining all models\nmodels = []\nmodels.append(('LR', LogisticRegression()))\nmodels.append(('LDA', LinearDiscriminantAnalysis()))\nmodels.append(('RFC',RandomForestClassifier()))\nmodels.append(('BAG',BaggingClassifier()))\nmodels.append(('XGB',XGBClassifier()))\nmodels.append(('SGD',SGDClassifier()))\nmodels.append(('HGB',HistGradientBoostingClassifier()))\nmodels.append(('NB', GaussianNB()))\nmodels.append(('SVM', SVC()))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# EStimating accuracy of the models\n## Model accuracy\n```The accuracy of the models is determined to inform the next step over which is the most \naccurate model to follow.```"},{"metadata":{"trusted":true},"cell_type":"code","source":"# The comparative accuracies of the models is determined\n\nresults = []\nnames = []\nscoring = 'accuracy'\n\nfor name, model in models:\n kfold = KFold(n_splits=10, random_state=7)\n cv_results = cross_val_score(model, X, Y, cv=kfold, scoring=scoring)\n results.append(cv_results)\n names.append(name)\n kc4 = (name, cv_results.mean(), cv_results.std())\n print(kc4)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Model chosen\n## NB', GaussianNB() \n```GaussianNB shows the highest accuracy, at 88%.\nI chose to test this further. Furtherstill, I choose this particular model because of the boxplot comparison\nIt has a small error from the mean. Thus its accuracy can be trusted to a better extent compared to other models```"},{"metadata":{},"cell_type":"markdown","source":"# Graph to show comparisons"},{"metadata":{"trusted":true},"cell_type":"code","source":"fig = plt.figure()\nfig.suptitle('Comparison of models')\nax = fig.add_subplot(111)\nplt.boxplot(results)\nax.set_xticklabels(names)\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Testing the model on Matthew's Correlation Coefficient\n``` To futher test for a better metric than accuracy, I will test the GaussianNB modle on Matthew's correlation```"},{"metadata":{"trusted":true},"cell_type":"code","source":"from sklearn.model_selection import train_test_split\nfrom sklearn.metrics import matthews_corrcoef\n\narray= Train.values\nX = array[:,0:11]\nY = array[:,11]\ntest_size = 0.33\nseed = 7\nX_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=test_size,\nrandom_state=seed)\n\nkintu_model2 = LogisticRegression()\nkintu_model2.fit(X_train, Y_train)\n\npredicted3= kintu_model2.predict(X_test)\ncomp_mat = matthews_corrcoef(Y_test, predicted3)\nprint(comp_mat)\n\n#Mathews correlation coefficient gives a moderate","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Generating the csv file\n``` I generate a csv file to enable me judge the accuracy of this model and submit to the competition.```"},{"metadata":{"trusted":true},"cell_type":"code","source":"#Generating a csv file\nkintu_df=pd.DataFrame(predicted3)\nkintu_df.columns=['CLASS']\nkintu_df.index.names=[\"Index\"]\nkintu_df['CLASS']=kintu_df['CLASS'].map({0.0:False, 1.0:True})\nkintu_df\nkintu_df.to_csv('KC_model2_csv')\nprint(kintu_df['CLASS'].unique())","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Re-testingLinear Regression\n```Running each model seperately to allow me change certain parameters \nthat are not possible tochange when doing an overall comparison```"},{"metadata":{"trusted":true},"cell_type":"code","source":"import numpy as np\nfrom sklearn.linear_model import LinearRegression\narray2 = Train.values\nreg = LinearRegression().fit(X, Y)\nreg.score(X, Y)\nscoring = ('Accuracy')\nreg.coef_\nreg.intercept_\nxp = reg.predict(X)\nxp\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"","execution_count":null,"outputs":[]}],"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat":4,"nbformat_minor":4} \ No newline at end of file +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19", + "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5" + }, + "outputs": [], + "source": [ + "#First importing the necessary libraries helpful in building and/or testing the model\n", + "#Three main libraries for a start: numpy, pandas, matplotlib.pyplot\n", + "#numpy is for linear algebra, pandas for data processing\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Kintu Christopher\n", + "## This is my assignment.\n", + "## I am in to win the competition\n", + "\n", + "```import os\n", + "for dirname, _, filenames in os.walk('/kaggle/input'):\n", + " for filename in filenames:\n", + " print(os.path.join(dirname, filename))```\n", + " \n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# Input data files necessary for this assignment were obtained from \"../input/\" directory.\n", + "\n", + "#import os\n", + "#for dirname, _, filenames in os.walk('/kaggle/input'):\n", + "# for filename in filenames:\n", + "# print(os.path.join(dirname, filename))\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "#ignoring warnings: It is necessary to import while ignoring warnings\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# The data sets are loaded and read as below in form of csv files\n", + "Train = pd.read_csv(\"../AMP Data Sets/AMP_TrainSet.csv\")\n", + "Test = pd.read_csv(\"../AMP Data Sets/Test.csv\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Data visualization\n", + "## The data is loaded for viewing directly from the ACE_class_Assignment folder. This displays, in tabular format, the real values we are to work with." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((3038, 12), (758, 11))" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#There is need to know how many dimensions our data has\n", + "# This helps me to know how many rows or columns are in each data set and also how large the data set is.\n", + "#Too many rows and columns require a longer time to train the model.\n", + "\n", + "Train.shape, Test.shape\n", + "\n", + "# The Train data set has 12 columns and 3038 rows. \n", + "# The Test data set has 758 rows and 11 columns\n", + "#This means our Train data is large enough to train the algorithm without over training or under training" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['FULL_Charge', 'FULL_AcidicMolPerc', 'FULL_AURR980107',\n", + " 'FULL_DAYM780201', 'FULL_GEOR030101', 'FULL_OOBM850104', 'NT_EFC195',\n", + " 'AS_MeanAmphiMoment', 'AS_DAYM780201', 'AS_FUKS010112', 'CT_RACS820104',\n", + " 'CLASS'],\n", + " dtype='object')" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Checking the column variables for the Train data set\n", + "#This gives me an idea of the variables I am dealing with and how they are labelled.\n", + "\n", + "Train.columns" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['FULL_Charge', 'FULL_AcidicMolPerc', 'FULL_AURR980107',\n", + " 'FULL_DAYM780201', 'FULL_GEOR030101', 'FULL_OOBM850104', 'NT_EFC195',\n", + " 'AS_MeanAmphiMoment', 'AS_DAYM780201', 'AS_FUKS010112',\n", + " 'CT_RACS820104'],\n", + " dtype='object')" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Similarly, checking for column variables for the Test data set\n", + "\n", + "Test.columns" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "FULL_Charge float64\n", + "FULL_AcidicMolPerc float64\n", + "FULL_AURR980107 float64\n", + "FULL_DAYM780201 float64\n", + "FULL_GEOR030101 float64\n", + "FULL_OOBM850104 float64\n", + "NT_EFC195 int64\n", + "AS_MeanAmphiMoment float64\n", + "AS_DAYM780201 float64\n", + "AS_FUKS010112 float64\n", + "CT_RACS820104 float64\n", + "CLASS int64\n", + "dtype: object" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# It is good to also take a look at they data types for each data set. \n", + "#Just incase there are strings that need to be converted into floats \n", + "\n", + "#First, the train data set\n", + "Train.dtypes\n", + "\n", + "#The data type of the train set is an object\n", + "#The column variables are all floats and integers as shown below" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "FULL_Charge float64\n", + "FULL_AcidicMolPerc float64\n", + "FULL_AURR980107 float64\n", + "FULL_DAYM780201 float64\n", + "FULL_GEOR030101 float64\n", + "FULL_OOBM850104 float64\n", + "NT_EFC195 int64\n", + "AS_MeanAmphiMoment float64\n", + "AS_DAYM780201 float64\n", + "AS_FUKS010112 float64\n", + "CT_RACS820104 float64\n", + "dtype: object" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Similarly, for the Test data set\n", + "\n", + "Test.dtypes\n", + "\n", + "#It is an object, with floats and integers only. \n", + "#This is good, we dont need to change anything.\n", + "#We are good to go." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Checking for quick statistical comparisons\n", + "## This will quickly give me a view of the relationship between variables." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FULL_ChargeFULL_AcidicMolPercFULL_AURR980107FULL_DAYM780201FULL_GEOR030101FULL_OOBM850104NT_EFC195AS_MeanAmphiMomentAS_DAYM780201AS_FUKS010112CT_RACS820104CLASS
count3038.0000003038.0000003038.0000003038.0000003038.0000003038.0000003038.0000003038.0000003038.0000003038.0000003038.0000003038.000000
mean2.0602378.5215200.97141073.6687600.994007-2.4329270.08854515.68323373.6508285.9113611.2352550.500000
std3.8199297.5866520.1074138.5274890.0313331.7072230.28413311.5756659.1660920.6936890.2100120.500082
min-16.0000000.0000000.68400042.7500000.866000-10.4320000.0000000.04100042.7780003.5330000.7850000.000000
25%0.0000002.5160000.89500068.2940000.974000-3.6060000.0000005.58750067.5560005.4592501.0820000.000000
50%2.0000007.1430000.96300074.0595000.994000-2.2965000.00000014.98850073.6970005.9255001.1840000.500000
75%4.00000013.1580001.04100079.3437501.011000-1.2832500.00000026.80775079.7780006.3820001.3510001.000000
max30.00000046.6670001.451000101.6820001.1960003.5760001.00000051.280000103.1670008.6620002.1920001.000000
\n", + "
" + ], + "text/plain": [ + " FULL_Charge FULL_AcidicMolPerc FULL_AURR980107 FULL_DAYM780201 \\\n", + "count 3038.000000 3038.000000 3038.000000 3038.000000 \n", + "mean 2.060237 8.521520 0.971410 73.668760 \n", + "std 3.819929 7.586652 0.107413 8.527489 \n", + "min -16.000000 0.000000 0.684000 42.750000 \n", + "25% 0.000000 2.516000 0.895000 68.294000 \n", + "50% 2.000000 7.143000 0.963000 74.059500 \n", + "75% 4.000000 13.158000 1.041000 79.343750 \n", + "max 30.000000 46.667000 1.451000 101.682000 \n", + "\n", + " FULL_GEOR030101 FULL_OOBM850104 NT_EFC195 AS_MeanAmphiMoment \\\n", + "count 3038.000000 3038.000000 3038.000000 3038.000000 \n", + "mean 0.994007 -2.432927 0.088545 15.683233 \n", + "std 0.031333 1.707223 0.284133 11.575665 \n", + "min 0.866000 -10.432000 0.000000 0.041000 \n", + "25% 0.974000 -3.606000 0.000000 5.587500 \n", + "50% 0.994000 -2.296500 0.000000 14.988500 \n", + "75% 1.011000 -1.283250 0.000000 26.807750 \n", + "max 1.196000 3.576000 1.000000 51.280000 \n", + "\n", + " AS_DAYM780201 AS_FUKS010112 CT_RACS820104 CLASS \n", + "count 3038.000000 3038.000000 3038.000000 3038.000000 \n", + "mean 73.650828 5.911361 1.235255 0.500000 \n", + "std 9.166092 0.693689 0.210012 0.500082 \n", + "min 42.778000 3.533000 0.785000 0.000000 \n", + "25% 67.556000 5.459250 1.082000 0.000000 \n", + "50% 73.697000 5.925500 1.184000 0.500000 \n", + "75% 79.778000 6.382000 1.351000 1.000000 \n", + "max 103.167000 8.662000 2.192000 1.000000 " + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#We check out quick summary statistics for both data sets\n", + "\n", + "Train.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FULL_ChargeFULL_AcidicMolPercFULL_AURR980107FULL_DAYM780201FULL_GEOR030101FULL_OOBM850104NT_EFC195AS_MeanAmphiMomentAS_DAYM780201AS_FUKS010112CT_RACS820104
count758.000000758.000000758.000000758.000000758.000000758.000000758.000000758.000000758.000000758.000000758.000000
mean2.0738798.9450910.97304673.8218910.994212-2.3979220.08443315.57006773.8442045.9044921.250189
std4.2306157.8144490.1106768.0295240.0323701.5971380.27821911.3625898.9151930.6569110.218102
min-13.0000000.0000000.69900047.0000000.889000-7.8440000.0000000.06000047.0000003.8430000.841000
25%-0.5000002.7217500.89400068.7402500.973000-3.4572500.0000005.70900068.3460005.4712501.096000
50%2.0000007.5000000.96500074.0695000.994000-2.2380000.00000015.05700073.6460005.9355001.188000
75%4.00000014.2302501.05350079.2847501.013000-1.3062500.00000025.29025080.0692506.3752501.378500
max30.00000044.1180001.431000102.9290001.1820002.0170001.00000050.098000102.9290007.5880002.283000
\n", + "
" + ], + "text/plain": [ + " FULL_Charge FULL_AcidicMolPerc FULL_AURR980107 FULL_DAYM780201 \\\n", + "count 758.000000 758.000000 758.000000 758.000000 \n", + "mean 2.073879 8.945091 0.973046 73.821891 \n", + "std 4.230615 7.814449 0.110676 8.029524 \n", + "min -13.000000 0.000000 0.699000 47.000000 \n", + "25% -0.500000 2.721750 0.894000 68.740250 \n", + "50% 2.000000 7.500000 0.965000 74.069500 \n", + "75% 4.000000 14.230250 1.053500 79.284750 \n", + "max 30.000000 44.118000 1.431000 102.929000 \n", + "\n", + " FULL_GEOR030101 FULL_OOBM850104 NT_EFC195 AS_MeanAmphiMoment \\\n", + "count 758.000000 758.000000 758.000000 758.000000 \n", + "mean 0.994212 -2.397922 0.084433 15.570067 \n", + "std 0.032370 1.597138 0.278219 11.362589 \n", + "min 0.889000 -7.844000 0.000000 0.060000 \n", + "25% 0.973000 -3.457250 0.000000 5.709000 \n", + "50% 0.994000 -2.238000 0.000000 15.057000 \n", + "75% 1.013000 -1.306250 0.000000 25.290250 \n", + "max 1.182000 2.017000 1.000000 50.098000 \n", + "\n", + " AS_DAYM780201 AS_FUKS010112 CT_RACS820104 \n", + "count 758.000000 758.000000 758.000000 \n", + "mean 73.844204 5.904492 1.250189 \n", + "std 8.915193 0.656911 0.218102 \n", + "min 47.000000 3.843000 0.841000 \n", + "25% 68.346000 5.471250 1.096000 \n", + "50% 73.646000 5.935500 1.188000 \n", + "75% 80.069250 6.375250 1.378500 \n", + "max 102.929000 7.588000 2.283000 " + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#summary statistics for the Test data set too\n", + "\n", + "Test.describe()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Attribute Correlations\n", + "## It is important to check whether different attributes have a positive or negative correlation or none." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FULL_ChargeFULL_AcidicMolPercFULL_AURR980107FULL_DAYM780201FULL_GEOR030101FULL_OOBM850104NT_EFC195AS_MeanAmphiMomentAS_DAYM780201AS_FUKS010112CT_RACS820104CLASS
FULL_Charge1.000000-0.612996-0.490977-0.434603-0.058725-0.2837580.0880680.355477-0.365374-0.0905700.2329290.534602
FULL_AcidicMolPerc-0.6129961.0000000.7947960.5414810.1152010.513344-0.143168-0.4315900.4496210.002334-0.213543-0.598816
FULL_AURR980107-0.4909770.7947961.0000000.5482530.3461390.462712-0.169540-0.4260970.4562600.032958-0.403599-0.584111
FULL_DAYM780201-0.4346030.5414810.5482531.0000000.0101180.334778-0.090058-0.4087930.8941910.055915-0.326792-0.554838
FULL_GEOR030101-0.0587250.1152010.3461390.0101181.0000000.319157-0.230417-0.160269-0.0290850.040480-0.151935-0.260470
FULL_OOBM850104-0.2837580.5133440.4627120.3347780.3191571.000000-0.230561-0.3362970.275640-0.4527690.155304-0.453287
NT_EFC1950.088068-0.143168-0.169540-0.090058-0.230417-0.2305611.0000000.178683-0.0368440.1459240.0808980.260702
AS_MeanAmphiMoment0.355477-0.431590-0.426097-0.408793-0.160269-0.3362970.1786831.000000-0.3223780.0255800.1715240.693552
AS_DAYM780201-0.3653740.4496210.4562600.894191-0.0290850.275640-0.036844-0.3223781.0000000.045562-0.256060-0.437168
AS_FUKS010112-0.0905700.0023340.0329580.0559150.040480-0.4527690.1459240.0255800.0455621.000000-0.4452840.033432
CT_RACS8201040.232929-0.213543-0.403599-0.326792-0.1519350.1553040.0808980.171524-0.256060-0.4452841.0000000.267652
CLASS0.534602-0.598816-0.584111-0.554838-0.260470-0.4532870.2607020.693552-0.4371680.0334320.2676521.000000
\n", + "
" + ], + "text/plain": [ + " FULL_Charge FULL_AcidicMolPerc FULL_AURR980107 \\\n", + "FULL_Charge 1.000000 -0.612996 -0.490977 \n", + "FULL_AcidicMolPerc -0.612996 1.000000 0.794796 \n", + "FULL_AURR980107 -0.490977 0.794796 1.000000 \n", + "FULL_DAYM780201 -0.434603 0.541481 0.548253 \n", + "FULL_GEOR030101 -0.058725 0.115201 0.346139 \n", + "FULL_OOBM850104 -0.283758 0.513344 0.462712 \n", + "NT_EFC195 0.088068 -0.143168 -0.169540 \n", + "AS_MeanAmphiMoment 0.355477 -0.431590 -0.426097 \n", + "AS_DAYM780201 -0.365374 0.449621 0.456260 \n", + "AS_FUKS010112 -0.090570 0.002334 0.032958 \n", + "CT_RACS820104 0.232929 -0.213543 -0.403599 \n", + "CLASS 0.534602 -0.598816 -0.584111 \n", + "\n", + " FULL_DAYM780201 FULL_GEOR030101 FULL_OOBM850104 \\\n", + "FULL_Charge -0.434603 -0.058725 -0.283758 \n", + "FULL_AcidicMolPerc 0.541481 0.115201 0.513344 \n", + "FULL_AURR980107 0.548253 0.346139 0.462712 \n", + "FULL_DAYM780201 1.000000 0.010118 0.334778 \n", + "FULL_GEOR030101 0.010118 1.000000 0.319157 \n", + "FULL_OOBM850104 0.334778 0.319157 1.000000 \n", + "NT_EFC195 -0.090058 -0.230417 -0.230561 \n", + "AS_MeanAmphiMoment -0.408793 -0.160269 -0.336297 \n", + "AS_DAYM780201 0.894191 -0.029085 0.275640 \n", + "AS_FUKS010112 0.055915 0.040480 -0.452769 \n", + "CT_RACS820104 -0.326792 -0.151935 0.155304 \n", + "CLASS -0.554838 -0.260470 -0.453287 \n", + "\n", + " NT_EFC195 AS_MeanAmphiMoment AS_DAYM780201 \\\n", + "FULL_Charge 0.088068 0.355477 -0.365374 \n", + "FULL_AcidicMolPerc -0.143168 -0.431590 0.449621 \n", + "FULL_AURR980107 -0.169540 -0.426097 0.456260 \n", + "FULL_DAYM780201 -0.090058 -0.408793 0.894191 \n", + "FULL_GEOR030101 -0.230417 -0.160269 -0.029085 \n", + "FULL_OOBM850104 -0.230561 -0.336297 0.275640 \n", + "NT_EFC195 1.000000 0.178683 -0.036844 \n", + "AS_MeanAmphiMoment 0.178683 1.000000 -0.322378 \n", + "AS_DAYM780201 -0.036844 -0.322378 1.000000 \n", + "AS_FUKS010112 0.145924 0.025580 0.045562 \n", + "CT_RACS820104 0.080898 0.171524 -0.256060 \n", + "CLASS 0.260702 0.693552 -0.437168 \n", + "\n", + " AS_FUKS010112 CT_RACS820104 CLASS \n", + "FULL_Charge -0.090570 0.232929 0.534602 \n", + "FULL_AcidicMolPerc 0.002334 -0.213543 -0.598816 \n", + "FULL_AURR980107 0.032958 -0.403599 -0.584111 \n", + "FULL_DAYM780201 0.055915 -0.326792 -0.554838 \n", + "FULL_GEOR030101 0.040480 -0.151935 -0.260470 \n", + "FULL_OOBM850104 -0.452769 0.155304 -0.453287 \n", + "NT_EFC195 0.145924 0.080898 0.260702 \n", + "AS_MeanAmphiMoment 0.025580 0.171524 0.693552 \n", + "AS_DAYM780201 0.045562 -0.256060 -0.437168 \n", + "AS_FUKS010112 1.000000 -0.445284 0.033432 \n", + "CT_RACS820104 -0.445284 1.000000 0.267652 \n", + "CLASS 0.033432 0.267652 1.000000 " + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Assuming a Gaussian distribution for both data stes; we shall use the pearson correlation\n", + "\n", + "Train.corr(method = 'pearson')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FULL_ChargeFULL_AcidicMolPercFULL_AURR980107FULL_DAYM780201FULL_GEOR030101FULL_OOBM850104NT_EFC195AS_MeanAmphiMomentAS_DAYM780201AS_FUKS010112CT_RACS820104
FULL_Charge1.000000-0.636153-0.512634-0.423297-0.041073-0.2675690.0480030.315226-0.333469-0.1173560.239915
FULL_AcidicMolPerc-0.6361531.0000000.8136350.5144320.1508810.474707-0.084944-0.3577580.4020340.141849-0.294068
FULL_AURR980107-0.5126340.8136351.0000000.5195870.4202890.453385-0.124539-0.3598450.4094380.142190-0.436791
FULL_DAYM780201-0.4232970.5144320.5195871.0000000.0826030.295562-0.095313-0.3310240.8478090.136920-0.341753
FULL_GEOR030101-0.0410730.1508810.4202890.0826031.0000000.348001-0.186815-0.1611730.0067090.053917-0.231629
FULL_OOBM850104-0.2675690.4747070.4533850.2955620.3480011.000000-0.193132-0.2687250.235712-0.3832450.080936
NT_EFC1950.048003-0.084944-0.124539-0.095313-0.186815-0.1931321.0000000.099988-0.0741330.1649650.071861
AS_MeanAmphiMoment0.315226-0.357758-0.359845-0.331024-0.161173-0.2687250.0999881.000000-0.2211530.0079110.144333
AS_DAYM780201-0.3334690.4020340.4094380.8478090.0067090.235712-0.074133-0.2211531.0000000.108141-0.250624
AS_FUKS010112-0.1173560.1418490.1421900.1369200.053917-0.3832450.1649650.0079110.1081411.000000-0.402763
CT_RACS8201040.239915-0.294068-0.436791-0.341753-0.2316290.0809360.0718610.144333-0.250624-0.4027631.000000
\n", + "
" + ], + "text/plain": [ + " FULL_Charge FULL_AcidicMolPerc FULL_AURR980107 \\\n", + "FULL_Charge 1.000000 -0.636153 -0.512634 \n", + "FULL_AcidicMolPerc -0.636153 1.000000 0.813635 \n", + "FULL_AURR980107 -0.512634 0.813635 1.000000 \n", + "FULL_DAYM780201 -0.423297 0.514432 0.519587 \n", + "FULL_GEOR030101 -0.041073 0.150881 0.420289 \n", + "FULL_OOBM850104 -0.267569 0.474707 0.453385 \n", + "NT_EFC195 0.048003 -0.084944 -0.124539 \n", + "AS_MeanAmphiMoment 0.315226 -0.357758 -0.359845 \n", + "AS_DAYM780201 -0.333469 0.402034 0.409438 \n", + "AS_FUKS010112 -0.117356 0.141849 0.142190 \n", + "CT_RACS820104 0.239915 -0.294068 -0.436791 \n", + "\n", + " FULL_DAYM780201 FULL_GEOR030101 FULL_OOBM850104 \\\n", + "FULL_Charge -0.423297 -0.041073 -0.267569 \n", + "FULL_AcidicMolPerc 0.514432 0.150881 0.474707 \n", + "FULL_AURR980107 0.519587 0.420289 0.453385 \n", + "FULL_DAYM780201 1.000000 0.082603 0.295562 \n", + "FULL_GEOR030101 0.082603 1.000000 0.348001 \n", + "FULL_OOBM850104 0.295562 0.348001 1.000000 \n", + "NT_EFC195 -0.095313 -0.186815 -0.193132 \n", + "AS_MeanAmphiMoment -0.331024 -0.161173 -0.268725 \n", + "AS_DAYM780201 0.847809 0.006709 0.235712 \n", + "AS_FUKS010112 0.136920 0.053917 -0.383245 \n", + "CT_RACS820104 -0.341753 -0.231629 0.080936 \n", + "\n", + " NT_EFC195 AS_MeanAmphiMoment AS_DAYM780201 \\\n", + "FULL_Charge 0.048003 0.315226 -0.333469 \n", + "FULL_AcidicMolPerc -0.084944 -0.357758 0.402034 \n", + "FULL_AURR980107 -0.124539 -0.359845 0.409438 \n", + "FULL_DAYM780201 -0.095313 -0.331024 0.847809 \n", + "FULL_GEOR030101 -0.186815 -0.161173 0.006709 \n", + "FULL_OOBM850104 -0.193132 -0.268725 0.235712 \n", + "NT_EFC195 1.000000 0.099988 -0.074133 \n", + "AS_MeanAmphiMoment 0.099988 1.000000 -0.221153 \n", + "AS_DAYM780201 -0.074133 -0.221153 1.000000 \n", + "AS_FUKS010112 0.164965 0.007911 0.108141 \n", + "CT_RACS820104 0.071861 0.144333 -0.250624 \n", + "\n", + " AS_FUKS010112 CT_RACS820104 \n", + "FULL_Charge -0.117356 0.239915 \n", + "FULL_AcidicMolPerc 0.141849 -0.294068 \n", + "FULL_AURR980107 0.142190 -0.436791 \n", + "FULL_DAYM780201 0.136920 -0.341753 \n", + "FULL_GEOR030101 0.053917 -0.231629 \n", + "FULL_OOBM850104 -0.383245 0.080936 \n", + "NT_EFC195 0.164965 0.071861 \n", + "AS_MeanAmphiMoment 0.007911 0.144333 \n", + "AS_DAYM780201 0.108141 -0.250624 \n", + "AS_FUKS010112 1.000000 -0.402763 \n", + "CT_RACS820104 -0.402763 1.000000 " + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Correlation on the Test data set\n", + "\n", + "Test.corr(method = 'pearson')\n", + "\n", + "#A quci eyeball shows all variables have some form of correlation to each other. \n", + "#There is no variable with zero correlation to another" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Plotting the data\n", + "## Upon noticing some correlation, it is good to cisualize it in a heatmap" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# Visualizing correlations between attributes using heatmaps\n", + "#import the necessary library; seaborn\n", + "\n", + "import seaborn as sns\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#plot a heat map for the Test data set\n", + "plt.figure(figsize=(6,6))\n", + "sns.heatmap(Test.corr(method='pearson'))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#Heat map for the Train data set\n", + "plt.figure(figsize=(6,6))\n", + "sns.heatmap(Train.corr(method='pearson'))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Testing for skewness of variables\n", + "# This will be important incase some variables are skewed either positively or negatively since we are assuming a Gaussian distribution. Correcting for this skewness improves on the accuracy of the model." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#Skewness of distributions on the Train data set\n", + "Train.skew().plot(kind= 'bar')\n", + "\n", + "#The NT_EFC195 show a high right skew (above 1).\n", + "#We shall have to correct for this to improve the model accuracy\n", + "#This we shall do by finding the square root, cube root or a logarithmic transformation" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#Testing for skewness on the Train Data set\n", + "\n", + "Test.skew().plot(kind= 'bar')\n", + "\n", + "# This data set also has a high positive skew for the NT_EFC195 variable as well" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Understanding my data\n", + "# Different plots will give me a good insight into what to do next with the data I have.Plots like histograms, scatter plots are good to give a genearl view" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#Plotting a histogram for the Train Data\n", + "\n", + "plt.figure(figsize=(15,15))\n", + "Train.hist()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY8AAAEICAYAAACnL3iHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO2deZgdVbW33x8JBEzATBpDGBoV0SASAQEVMQhKwAFUQBAhURDvp4gKeokjuQJeQEFBlEHEMA+CDCKgoPRFUJAEmRFkCJCQEJKQkA4IBNb3x9onXV05Y/eZunu9z1PPOVV7WrXXrr32VLtkZgRBEARBLazRagGCIAiC/kcYjyAIgqBmwngEQRAENRPGIwiCIKiZMB5BEARBzYTxCIIgCGomjEcQBEGVSOqUdHAJt40kdUka0my5WkEYjyAYZKQK8DlJwzLXNpB0uaRFkpZJuk/StArxdEgySf/MXR8r6WVJcxpzB0VlmZxkObJZaeYxsyfNbISZvZpk6kwybZn1J+mKdH1ySwQtgaQZks6v1n9LjUcDCnFXOp6RdI2kD9eQ7sGSHsxdGyNpoaQpmcJ5RS6uLdP1znS+UUaOwmGSjsiE+aqkxyU9L2mWpB0ybpJ0vKTF6ThekpLb2yRdJelZSUsk/VHSZjl5viFpQYr77Nz9HC3pXkkrJc0ol6eNoIH67pJ0d3Ir+gAk/2/NyHFwxm1ykmvfdL6HpLtSHi6S9BdJm2T89zqPJX1W0hOSVki6UtLojNuhqTy8JGlmLtxaki6TNKdYxSPpWynvlqey9a1SeQd8ADDgExmn84CngI2BMcABwDPF4ijC6yS9M3P+WeDxKsPWi6nAEuDAJqdbiYfJyCRpDPBe4NmWSVQvzKwlB9ABvIorfO/M9ZuAnwHDgaHAu4HdqojLgKHp/E3A14AuYFo16Sa3G4FjM+fnATPT/8nAQmABMCbj5yTgIaCzhGybpPQ60vl2wApga0DA/8ML0pDk/qUU3wbABOAB4L+S27bAQcBoYE3gaOBfmbR2xR/4zYFRQCdwXMZ9KrAbcBUwY6DoO+c2Azi/yHUD3pr+dwIHp/8fAZYCe6bztwLLgJ2TftYFPg1s1Nc8TmGWAzsCI4ALgYsz7p8C9gROK5S7jNtawNeBHYD5wOSc+38DW6U83Ax4Ati3SD78ALg1ldtrMte7gEm90KkB3wN+nLk+C/guMCdzbX3gcrysPw4clnHbFvh70sN84FRgrZzu/gv4d/LzC0AZ9+EpX/cFXga2KSLj53Hj+FyK6z3APSm+UzP+p6X8OTWVg38BO2fcO/Hn7taU5p+AsSXqoc6U33Ppfr4PTfqdW9AhMAx/Bp5Ox8+AYZl6Z27S78KUP3sCu+OGaQnwnYx8awDTgUeBxcClwOicfFOBJ4FFwHeT25SUd6+ksnB3Rf03swJpQiEemrv+TfxBX6NSupl4ngMm4ZXE08ConBJPB76Srg0B5qU4O0vIdhRwU+b8M8A/cgXfgPHp/G/AIRn3g4DbSsQ9OoUdk84vBH6Ucd8ZWFAk3Pk033g0XN/JbQZVGg/gY3jlsXvG317AXWXS7nUeAz8CLsycvyU9sOvm/B1Dznjk3FdVPGX8nAL8vMj1R4Av442XV4Bx6fqNST/7kgxlDXrowCvmIcBEvMLdhWQ88AptdioDawFvBh4Ddk3uWwPb44avA3gQ+HpOd9cAI4GNcAM0JeN+AF6pDgF+n73vjIynA2vjjYX/AFcCb8QbaAuBDyb/04CVwDfwBtpncCNSqIA78Yr5bcA6ZBoPFDceB+MGZrd07R94zyNrPH4I3JbkeQNeBxyd3CYneX6Q5Pliuv8L8YbN5sCLwCbJ/9dSXBvgRukM4KKcfL9Ksm8JvAS8o9yzU1L/zaxAmlCI88bjzen6Oyqlm3H/KnAn3jraM3N9clL4+4Db07XdgT+mAtJZRC6lgjYtc209/EHaDi/sXwX+SWpJpYK6Xcb/NsDyEve9JzA/c3438JnM+VgyxiVzvRXGo+H6LvcAsLrxuApvKOxSpMz8B/gpsBMwIufe6zxOaR6Zu9YFbJ271ifjkcrdP0k91sz1HVLeF1rK/wK+kf6PAo4D7sd7iHcB76lWD0mPu6Y4vktP47Ed8GQu7LeB35SI9+vAFTnd7ZA5vxSYnjm/EfhZ+r8fXrmumZNxQsb/4pwOLycZK9x4PE3Pns0/gAMyZed7GbcvA9cXK5d0G4/PARcBbwcezusQryOyDZhdM3k3GTcOhZ7LuimNbB0xm+6e84P07CmNTzovGGYDNsjd277lnp1SR0vmPNIY/8bApWY2G8+8zybnvYG/At8HHk9jz+/pZVJPp9/RVaRb4FQ8s+8ysyvzEZrZ34DRaa7hQODcMunvAIwDLstcW44X1ltwq38U3tOw5D4CNyAFlgEjCvMeBSRtgHffD89cLhYWvMC1jAbqe5Gkpen4Zo1i7YQPg9yavWhmj+EP7AS8klokaaakEclLX/I4H7YQvt76mYG39n+Tuz4V+JOZLUrnF6ZrmNlzZjbdzDbHy+xdwJX5cleGc/GKdz98uDfLxsD6GV0tBb6T0inM5V1TmEfCe2hjc3EsyPx/Ac9LJG2I6/KC5HYV3sP4aC58dv7mxSLnIzLn8zLPI/gQ4PqVZCnD74AP4UNW+bwhxf1EmfQWW5qET7JSRv6NgSsy+fwg3hgY1wf5i9KqCfNGFuIsE9LvkkrpFkiF5kG8BVaK8/CCsBNwRRl/U4HLzawrc+0gfPx1c7wL/zngGkmFwtKF904KrAd0ZQuzpDfgXeFfmtlFGb/FwoIbrFbSKH2PNbOR6fhJurYS796vQlLh/JXM5e/jxvvK7IR3kuk2M9vHzN6ATy7viLemoW95nA9bCF83/Ug6FG/UfNTMXspcXwfYB/hgqqQX4EMzWyq3Gijp6Sd4BTaa6rgcr7AfM7Mnc25PAY9ndDXSzNY1s92T+2l4L2hTM1sPNyzVPu8H4PXY79M9PYYbj6llQ5VnQq78bUR3Q7RmzOwF4Dp8frOY8Xgar/Trkd5T+BBZNq/XNrN51YhaS0JNNx5NKMRZPomPZz5US7pVcB7eXb02FYzVSOntDZyTc5qEj/k/bGavmdn1+Hjt+5L7/fhYZIEtyRgySaNww3G1mR2bi7tY2GfMbHEtN1dPmqxv8InAjty1TXCjkn2AVuDDjq8HfpsxMD0wszvwlmNhNVFf8rhHWElvxselH64ibEUkfQGfLN3ZzObmnPfEW6AT8TI4CXgH3us7UL6q752ShkpaF6/oHqm27JjZCrx1XewdiH8AyyUdKWkdSUNSWoUe5rrA80CXpLentKtlKvA/mXuahC9w2D2tbOoNbwQOk7SmpL3xfLq2l3EV+A4+rzKniNtFwPckvUHSWHx+o+olszlOB46VtDF4Q1PSHlWGfQbokFSVXWhFz6OhhRhA0rjUAjsK+LaZvVYp3VpuwMweBz5Id2u0GJ/Ex9Rvyl2/A/iopDfL+TA++XZfcj8XOFzShNQbOQKYme5rPXyO5VYzm14kzXOBgyRNlDQSXwUzs+CYHoa1cb0PlbS2Gv9CU8P1neN64O2SDkj3OxofBrnczFZmPZrZcnyVyQTgwlSp7SDpi5LeCJAqs0/gk5DQtzy+APi4pA9IGo5PlP4uyUHKg7XxubAhKezQTNzDkjvAWsm9sIx7/3SfH05Db3mm4nMMT5rZgsKBD9Puj/eArsAXEDyGt4Q/USSekpjZLDN7tMj1V/HFCZPwucRFwFm44QZf2PJZvAf2K+CSatKTtH2S8xfZezKzq/E5tv1qkT/D7cCmSc5jgb362gAzs6fN7JYSzsfgK9TuAe7F51yP6WVSJwNXA3+StBwvt9tVGfa36XexpDsr+q52cqReB/5wn1jk+j74WNxp+Fh0Fz7xdQ2ZCe8ScXbgXa4uvEW5EG8pTKkh3aGZazOBY3L+JgNzS6S/2oQ5XskfXcSv8ErjSfxheZA0GZdxPwEfaluS/hcm06em+1yR7rVwbJQJfzjegngeH/Melrsvyx3T+rG+V5swT+7vw+eUnsO7/2eRVs0l907SUt10PhqfCL8AeBe+YueZJNMc4HjSBGxf8xivJJ9MOryKtIonuc0oEnZGxn1OEfeO5PY43cssC8fpzX6++/uBz9vc0mo5+sNRqJSCIAgGPfIXVA82sx0q+R3sxPYkQRCURNL+Wn3HhC5J5RaUBIOAftPzSGO6ZxRxesJ8pU4wgAh9B0F702+MRxAEQdA+DK3spfGMHTvWOjo6yvpZsWIFw4cPb45ANdCOclUj0+zZsxeZv8fQFCrpuB3zsRLtLnOrddwu+TOQ5Wi2jnvQ6hl7M2Prrbe2Stx0000V/bSCdpSrGpmAWdZGOm7HfKxEu8vcah23S/4MZDmarePs0RY9j3alY/ofKvqZOaX1LZqgcZQrA0dssZJp0//AnOPyO2EEAPfOW8a0Cs9Q5F3/JVZbBUEQBDUTxiMIgiComTAeQRAEQc2E8QiCIAhqJoxHEARBUDOx2qqPVFpREqtJBj6VVuVFGQgGImE8giBoGWF4+y8xbBUEQRDUTBiPIAiCoGbCeARBEAQ1M6jnPKrZfiQIgiBYneh5BEEQBDUzqHseQRD0b2Lz0tYRxiMY1AyWoUtJZwMfAxaa2TvTtdHAJUAHMAfYx8yekyTgZGB34AVgmpnd2Qq5g/Ylhq2CYHAwE5iSuzYd+LOZbQr8OZ0D7AZsmo5DgNOaJGPQjwjjESDpbEkLJd2XuTZa0g2S/p1+R6XrknSKpEck3SNpq9ZJHlSLmd0MLMld3gM4J/0/B9gzc/3c9L2h24CRksY3R9Kgv1Bx2Cq6u4OCmcCpwLmZa4VW6XGSpqfzI+nZKt0Ob5Vu11Rpg3oxzszmp/8LgHHp/wTgqYy/uenafHJIOgTvnTBu3Dg6Ozu7I1/HP5jVF7LxFaOa+Lu6uirG0wzaRY56Uc2cx0yiYuk1/WH7BTO7WVJH7vIewOT0/xygE9fxqlYpcJukkZLGZyqhoB9iZibJehHuTOBMgG222cYmT568yu3nF1zFiff2bVp1zv6Ty7pX+lIh+IR5Vq5W0dnZ2RZy1IuKmo2KZdDS0FZpnla1yvrSMq62Zd3Grc1nCs9nGpZamK7PAzbM+NsgXQuCVfS2WdDUigUaU7n0tUsNfe+aN6JiqXdeNaJVmqdVrbJqWq6lOGKLlVW1rCu1nlvI1cBU4Lj0e1Xm+qGSLsZHDpZFAzDI0+elus2oWKAxlUtfKo4C1VYgpWhExVKnvBoQrdJ2WIpbjQyNHr6UdBE+WjBW0lzgKNxoXCrpIOAJYJ/k/Vp83vIRfO7y8w0VrsXUo4y0w/Bzs+ltrTcgKpagLNEqHUCY2X4lnHYu4teArzRWoupoB+MfFKe3S3ULFQusXrEcmJZzbk9ULP2C1Cr9O7CZpLmpJXoc8GFJ/wZ2SefgrdLH8Fbpr4Avt0DkIAhaTDVLdaO7O8Dpr63SIAhaRzWrraJiCYKg31LpU9FB74g3zIMgCIKaCeMRBEEQ1EwYjyAIgqBmwngEQRAENRPGIwiCIKiZAfsxqHi5KAiCoHFEzyMIgiComQHb8+gvtMO+R/2VgdS77A9b9wdBluh5BEEQBDUTxiMIgiComTAeQRAEQc302zmPgTTeHQRB0N+InkcQBEFQM/225zGYGKwrcaJ32U2symtvqtHPzCnDmyBJ82iI8ZA0BTgZGAKcZWbHVQgS9DNCxwOf0HF9qbQ1fH8z/nU3HpKGAL8APgzMBe6QdLWZPVBtHMWs+BFbrIw9+duEeug4aG9Cx0ElGtHz2BZ4xMweA0jfut4DiELXIPLGtpihrXOrps86rkbmoKUMiOd42d8v5cLbnobtv17Ufe5pX2DMboexTscklv39UlYuXcCY3Q5ruFwrlz3DvNMPYqNvXYXWGAL0v6FJ+cf/6hihtBcwxcwOTucHANuZ2aE5f4cAhwCjgY3T5VeBFwEBhQFCZYIZ0AX8u0TyawFbAK+l85XAs8CCIn43A9YB7k7xZnkdsD4wIp2/BCwEFqfzNwFvwI2vAc/j3/UG7+JvDKyXcXsiyTQU2BBYF1+s8B/gKWBFJu3RwITk93lgDp4vpDTHJrmXJLcs6wIbAcPwfJoDvJzzMwR4J4CZrblarlRBER0/C4xK91PgELzl+mg63wx4KP0uBhbheTwMeDzd16JM+C2S/MtrFK9QBp4FnixyfXbOfweeR08DY9J5ofy8BMwDluXiKLgbXray5WttXAevw8vfXGBpxn0Uft9rpXTn5dzfCIzHy8dzeNkplM/1gZG4/ucnmbPky86rZjYWQFJXzu86wC/N7KsUoaBj/Pv14/DncI0k8yHACWa2QeY5BpiU7reg2/WAfxWJvt66rUS+bPVVlg68rDxKT91tiOtvDt11RSk58uVxM7zOM7x8deH3+EoFWTY2szfUIHv9MLO6HsBe+Pho4fwA4NQSfg/HK+VP4Rm3JvBx4McZPzOA84FZVaTdgWf+0HS+DV4xf7iIv1fxCnjvnNt7ccUdiStbwNbApcl9KvAg8JZ0fhdwSCb8L4E/4Q/O64EbgZOS25vTPY/HK/FD8MI0IrlvjhfiHXHDdSFwcSbuTwF7AqcBM3Nyj8Urub3xAvlj4LYiefQr4Gbgljrq+FngypyfycDcImE7gYOzuk3/Z+X8zQF26YVsR+EP7hJgWKmykbk+Ezgm/Z9WyBe8ovxSKgsjS5SvB7LlC6+0H046HgJ8KLm/LblPwCvf3VK5+ijwAvDG5L4r8EwqB6NSXh2XkXVqCnsVMCN3H2XLTs7viHRfO1bScUEPZJ7jGnS7uETcddVtFeFK1h29kSWVmYeAyzPXhuINgUeAaZXkKFKWsnk3GvhLKf1VkG1orWF6ezRiqe483AIX2CBd64Gk1wM/BL5iZr8zsxVm9oqZ/d7MvlUPQcxsFnA/3iLKciBwG14IpubcfgycY2bHm9kic2ab2T7J/T3AH82s0KJeaWZnZsJvglekz5vZMuAK/MHGzB4zs5PMbL6ZvZrCrYW3OgD2B35vZjebWRfwfeBTktZN4X9nZldSvFXzKeB+M/stXihnAFtKenvBg6T34b2O35TNuMrkdTyU0i27piFJuG6/h7fYPt7buMzsNeA8vFGzaQlvL9CzfL0db3H/NOn3L8CteMUL/iwsNbPrUrn6A25c3pLcpwK/NrP7zew54GjcoBVkOsfMrqN4K7ls2cnxabzR9tcyWVDVc9wsKulW0uaSbpC0RNIzkr6Trs/An8mCvwMkPSFpsaTv5uKYIen8zPkOkv4maamkpyRNy3j/PbCDpFHpfApwD5leqKQ1JH0vpbcQ6Ej1XlnMbAlwOWmEQNIwST+R9GS6t9MlrZPcJkuaK+lISQtIz7akPSTdJel5SY+mxQ91pRHG4w5gU0mbSFoL2Be4uoi/9+Jd/CsaIAMAkrbHFfBIzulA4IJ07CppXPL/uiTXZWWivQ04UNK3JG1TxP0XwMckjUoF69PAdSXkm4Qbj4J8m+PDaAAkA/Uy8LZy91ki7Aq8W715SmsIcCpwKKsP09VKXsfDgb/3Mc56sANeyV0MXMrqDYOqSfn1ebyieqKEt+EUL189okp+AGYBD0r6hKQhkvbEh8buSe49dJj+j5M0pgqRayk7U4FzLTVVS3AHbjSHpqPUc9wsSuo2Gcgbgetx4/1W4M/5CCRNxHvtByR/Y1KcqyFpY/y5/Tk+XDwJH2Uo8B+8B7hvOj8QODcXzbR07ISPOhSewbJIGovXG/9Ml47D9Tgp3dsE4AeZIG+ie/j/EEnbJlm+hQ9z7sjqQ9x9pu7Gw8xW4hXUH/HhnUvN7P4iXscAi5L/ajizspdVLJL0Il6h/RK4suAgaQc8ky81s9l4BfvZ5DwKz5P5pSI2s/OBr+JDDP8HvF3SkRkvd+IGYXE6Xk0y9EDSenjL9n9SDwV8OGFZzusyfC6jEtmwhbzKhj0MuD3dc58oouMVwMmphbZU0pVlIyhOLfotxVTgutRqvxCYIumNNcaxvaSleOXwE+BzZrYw56dQvt5Oz/L1EN6i/5akNSV9BPggPv+Bmb2KP9QX4kbjQuBLydDD6vov/K9V/9nwPcKmSvGDwDnlIsvoeBxwLV553VqjbkvNTfaGcrr9GLDAzE40s/+Y2XIzu72IHHsB16Te2Ut47+w1ivNZ4EYzuyiNiCw2s7tyfs7FG5Ij8TzN583++JD1Y6k3eBKwr6RSC5VOSWXvbrwOOjz1uA4BvmFmS8xsOfAjuo0W6R6OMrOXzOxF4CDgbDO7wcxeM7N5ZlZs7qlPNOQNczO71szeZmZvMbNjS3hbDIwtk5H5OGupXMbiD9MR+PhsdmJ4KvAnMysMs1xIdyvmOVwR4yvIcoGZ7YJb9c8DR0vaNTlfio97r4vPezyKz9msInU5f4/PSfxvxqkrhcmyHtVN5q0Km8mr9YDlktbHjcd3S4StmayO8UpqTzMbmY498cniYhPya1JkErBG/a5GytO98d4kZvZ3fMKx0DAoNFLyMuXluc3MRuINiauBDxRJrmj5MrNX8Dmpj+LDF0fg5WFuknEX4IQUZi28wjkr9UBhdf0X/tek/1z4fNgD8HmdxytFaGbX4kNVHzGzdXqh23I9sqqpQrcb0r0woxgFOdbHF6iQ4llB8SHgauLEzG7BeyXfxY3Sizkv69Oz1/pjvBc3rkSUh6U8nmBm+5vZsyn+1wGzC40zvIeVnSR/1syyi1Uqyl4PWrk9yd/x1teejYg8jTmfhLcgvwyrCuE+wAclLUhjhN/A5wa2NLMXklyfrjKNV9Icwz10D01MAs5IczhdwOnA7oUwkobhLZS5+IRslvuBLTN+34yvRnq4CnHyYYfjY+n348suxwMPpHs+Gdg25cGQau61FzyJNw4KK9YK49YbU3oYqC98Eq8sf5nR7QS6Gwbz8YqtIxduk2LyJN39P+AASe8u4r5a+UrX7zGzD5rZGDPbFR+u+EdyngTcbGazUovwDuB2fEIacjpM/58xs1IVXJZqy86BVOh1VEG76fYpPJ8rMZ/MPE4api41JPgU3XNR5TgfbyTkh6zAV8NtnDnfCDe8z1QRb4FF+ArUzTONs9eb2YiMn/zwY7Wy94mWGY80VPMD4BeS9pT0utTV303SCXVM6jjgvyWtjRuqV4GJ+IM8CXgHPnF4YPL/38C0NKcxBkDSlvJ17kiaJumjktZNE2K74ePNhW7yHcDBktZJxuoQ0pi2pDXx+ZQXgalpUjbLBcDHJX0gVf4/BH6XuqpIGpruYwgwRNLamZ7bFcA7JX06+fkBcE/qrl6HV5qFe/4BPp46KQ2l1B0zexLPk+MljUhG81t4BX5bxusa6T4Kx7CM25o5t3K91KnA2fjyx8J9vh9vGGyR7vNy4FhJY1JZ2w8vC0XnpNLE5Vn0HF/Oky1fSHpXkvV1kr6JG+2Zye8dwAcKPY1klD5A95zHucBBkiamoZDvZcKSZF4bf26HpnQKxr9s2Unh34dXur8tcz8VaTfdAtcA4yV9XT65vK6k7YrEcxk+H7mDfK7uh5SuAy8AdpG0T3ruxmR6iFlOwV+kvLmI20XAN+RzgyPw4aZLahiqLyzc+BXw08IwnaQJmZGOYvwa+LyknVMdNUGZhTN1w5q0rKvUgY8LzsLHzRcAf8BbCPfiE1RP49Z9NHADPn55AzCqSFwd5JZj4hOW9+PzFNcDJxYJt09Ku7Bsblu8QlmGLwu8HTcqd+HvJHSldP6DtyKeS2534cNYv6d7SeH1wKYp3g+mcC+kOArHBzKyfBZv2a3AJ+RGZ9xmpPDZY4Z1L++bjU+SvgrckvJDeAF/BK+ktiKzJLVOOpxDkeWOeCvvtylvF+FzJBMr3M/cTJx5t2NKpD8Bb9FtUcTtWuAn6f8o3BjMSzq7FXh/xu9q+YJPqL4EvCtTvsbgFdG/8Dmfx4CvJv8/TnF3pTL01lx8hyZdLE/hjsi5H57K1PP4ypnscuOZRfJkWjVlJ7mfAZzXJN2e32TdvhMv86/Q3br/Wipjl9Jdd9yHt8wX48NNq+6PzNLxdP4B/Nl/PoWZmtFDKXlvKegEH6KajzcWn8UbeLOS/n9PiaW6ReJcGzc8jyVZHsSHuKD0sulP4s/78pTervV63gtH3V8SrAeS5gDbWPe8BKk3ssTMjpM0HTceR5aKo8HyDcEroO1wY9FlZj9pYvo74pXTuWZWWM5XNH8k7Y4bzt2TvCebWbFWWcuQdDj+Ts56ZvaxVstTCUnnAH81s7NSC/Z1Zra0UrjBQno+HiaztQmwnzV4axNJ44HxZnanfAXWbHy0YRotqDvy5VrSpXhv8GJJpwN3m9lpjZajUfSnLdn3oHus9hwaNFdSJTsDj5pZI8Z3K2JmN+O9miyl8mcP0rJMM7sNGJkesrZA0gb4BPNZrZalGuTr9HfEhwYws5fDcKzGqq1NzOxlfHntHo1O1Pz9qTvT/+V4C30CLag78uU6zQl9iO7XAFpdh/WZdjUeBvxJ0mz59gcA48xsvqT98e7n2yR1ZY5iy4Ebxb74eGaBQyXdI+lsdb801GzGmVlhifECuld0TCCzwgRvCU5opmAV+Bk+JFhqyeQqJH0np/PCUXTOokFsgg9B/EbSPyWdleYYgm5qLnP11q2kDuDd+LBTqWejkeTL9Rj8BdHCfEe7PYc1067GYwcz2wrfiuEraZgGWLVMdgSuiBGZY/NmCJaGKT5B96TjafjKhkn4+OaJzZCjHOZjke03HplD0seAhVbluydm9qOczgvHbg0WNctQfN7oNDN7Nz6/ML2J6Q9I6qnbNDl9OfB1M3s+l07Dn41ay3V/pS3mPMaOHWsdHR01h1uxYgXDhw/8Rl8j7nP27NmLrIkbqlWr41bodKCm2Wodt+vz2a5yQe2yNVvHPaj3DHxvjq233tp6w0033dSrcP2NRtwnVWw0Wc+jWh23QqcDNc1W67hdn892lcusdtmarePsMWA/Q9vf9sYPGsNg/YRvO1Dpy3kQ+d+f6bfGo2P6H+IDQoOc+MZ5ELSOisZD0ob4m6/j8ImmM83sZEmjgUvwF6fmAPuY2XNpSdrJ+HsFL+AvzNzZGPGDoG9UaoREyzgIilPNakZNdy8AACAASURBVKuV+FuwE4Ht8dVPE/EVJn82s03x7Y8LK052w7dy3hTfmqPfvgQTBEEQFKei8bDaX7xp65fSgiAIgr5T05xHlS/elHpBqMc3MpT59vG4cePo7OysSfAjtljJuHX8t7fUmmar6Orq6jeyBkEwOKjaeORfvPGpDcfMTFJNL4yYf7/hTIBtttnGJk+eXEtwpqWx6hPv7f2c/5z9a0uzVXR2dlJr/gRBlpi7DOpNVW+Yy7cSvxy4wMx+ly4/UxiOSr+Fr6211bePgyAAYu4yqDMVjUdqgfwaeND84zcFrqb7YyxT8S2gC9cPlLM9sCwzvBUEQQuIucug3lQz5vN+/NOV90oqfMP3O/hHcC6VdBD+9bB9ktu1eFf3Eby7+/m6ShwEQZ9o1txlNXOSrZjLa+c5xHaWLU9F42H+nV6VcN65iH8DvtJHuYIgaADNnLv8+QVXVZyTbMW8YzvPIbazbHnadVfdIAjqTMxdBvUkjEcQDAJi7jKoN/12b6sgCGqiLecuY+PK/ksYjyAYBMTcZVBvYtgqIH0+d6Gk+zLXRku6QdK/0++odF2STpH0SPr07latkzwIglYRPY8AYCZwKv4GcoHCy2PHSZqezo+k58tj2+Evj23XVGmbSHwXJgiKEz2PADO7GViSuxwvjwVBUJLoeQSl6NPLY9C7zS9reUmqL5tiZmnFBpv96WWwIChGGI+gIr15eSyFq3nzy1pekqrXVyRbscFmf3oZLAiKEcNWQSni5bEgCEoSxiMoRbw8FgRBSWLYKkDSRcBkYKykucBRxMaXQRsQLxG2L2E8AsxsvxJO8fJYEARFGdTGo5o1/JWIlk8QtI54D6d1DGrjEbQ39TDuQRA0hpgwD4IgCGomjEcQBEFQM2E8giAIgpoJ4xEEQRDUTBiPIAiCoGbCeARBEAQ1E8YjCIIgqJl4zyMIggFN/n2hI7ZY2WNH5niJsHdEzyMIgiCombbsefSnN4tj47YgykAwGImeRxAEQVAzYTyCIAiCmmnLYatg4FNqqCc/mRkEQXvSEOMhaQpwMjAEOMvMjmtEOv2BgToeHjqunmJloD+s+BksOo5t3XtH3Y2HpCHAL4APA3OBOyRdbWYP1DutoDWEjgc+oeOeDNRGYF9oRM9jW+ARM3sMQNLFwB7AoCh0c0/7AmN2O4x1OiZV5b+aVs/MKcP7Kla9GdQ6HiSEjoOyNMJ4TACeypzPBbbLe5J0CHBIOu2S9FCFeLcA1gSscOEwWAK8Hrgn53czYDGwCFgfGAY8XiLOOcDyCmlnWQO/x5F4/r0CLAPmAyuBLRZe8r1a4yzLTsczFr+XerJxH8I2SsccRkPute3T1PENSabVOm56vlZDI/RdR/3VKltfdNw3zKyuB7AXPj5aOD8AOLUO8c4BdsldewiYW8RvJ3Bw+j8DOL/aOCvIsBZwB3ADMBE3JG8Evg/s3ps4y6QlYI30f1a99VQvHaf7fTkdXen4bG/1AszqhV4mA69l0p8LXAq8p0S+PgY8kEvzGODPOb9vA57HGxnT8IbLT3N+9kjXZ6bzD2TkKBwGfDqT/jEpv5alPNk8E98w4OyU7gLg8Izb9qnsLQGeBX4LjM/d2/F4w2lx+q+M+5npmXkNmNYEHT9dTMe9fU6AdYGTUtgVwJPAZcB2GT+W3LL5/98Z94nA0pT3y4GbgPdl3DtSHIWwc4DpOTlGA1ekdJ4APptx2wm4N6WxOPmbUKV+10q6nZNkmFyk7NZFv/U4GrFUdx6wYeZ8g3RtIHAgsBHwSTN7wMxeM7OFZna0mV2b8TdJ0j2Slkm6RNLaAJJGSbpG0rOSnkv/NygEktQp6VhJtwIvAG+WtAmwmaTlkm6U9AtJ52fCbC/pb5KWSrpb0uQm5ENex+cCR5nZCDMbgVcazebplPa6eCX7L+CvknbO+dsRN/hvlvSezPWjgTdJ+iKAJAG/Ak4ys3uTn0eBfSRle+xTgYcLJ2b210I+JHk+hldC1ycvewNfSPKNBv4OnJeJbwawKd6i3An47zRxDTAKryA6kvty4DeZsIcAewJbAu8CPg58KeN+N/Bl4E4q01Y6ljQM+AtuyD8GrAe8A7gY2C3nfcusDszshBTHW4BbgReBTfBRiSuAP0l6by6Okek+9wK+L+nDGbdf4IZ0HLA/cJqkzZPbA8CuZjYyxf9v4LRM2BmU1i94Wfkcbljy1FO/faYRxuMOYFNJm0haC9gXuLoB6bSCXYDrzayrgr99gCl4AX0X3moFz+/f4AVnI7wQn5oLewBeSNbFWzUX4i2cMXjBO6DgUdIE4A94S3Y08E3gcklv6M3N1cAqHafznWgTHZsz18x+AJyFt86yTAWuAq5N/wvhXsIr9eMkrY/rYBRwbCbsArxVuSuApNHA+yh/71OBy8xsRTrfBLgFeNnMXgXOx1vDWf9Hm9lzZvYgbsCmJRmvM7PfmtnzZvYCXnbenwt7Yrr/ecCJdJc9zOwXZvZn4D9l5C3Qbjo+AG+I7mlm95nZq2a2wswuM7MZVcYxAzfW88xsiZktN7NTcONddODJzGYB9wOTACQNBz4NfN/MuszsFjxfDkj+nzGzrGF9FXhr5rycfl8GFqY4Xy0iTj3122fqbjzMbCVwKPBH4EHgUjO7v07RX5la2EslXQn8vk7xVssYfG6jEqeY2dNmtgSXcRKAmS02s8vN7AUzW45XTB/MhZ1pZvenfBwPvAc4xsxezhTUAp8DrjWza1Mv6AZ8CGb3Pt1lBXI6ngD8Xx11fGad4gH4HbBVeuCR9Dq8JXlBOvZNDZwzAczsdmAmXpkcC3zBzF7JxXku3gMFbxhdBbxULPGU7l7AOZnLFwNvwcvymniFcH3yPwrX+d0Z/3cDm1OcHfGKrcDmNYQtS510PLs3aZdgF+CPGSPcGz6MD/Xly9ilwPslrZMPIGl74J3AI+nS24CVZvZwxluPfJa0kaSleOPwm0Ch51ONfsuV/7rptx405A3zVJm9zczeYmbHVg5RNXua2ch07AlciU+i51kTn8iuN4tx5Vci2+V8ARgBXnlJOkPSE5KeB24GRqZlkQWyk5TrA0vM7NQS7hsDe2cM6lJghypl7BMFHePDG/vkjHpf4q2n8XgaHycemc4/hVf0f8J7bGsCH82l+T28pXheanXmuQKYLOn1uBE5t0z6n8InP/8vc20+3vM4Gq9c9ga+kdxGpN9lGf/L8F5oDyS9C/gB8K3M5RFFwo5IQ3A1Uwcd19N4jCXzXEmalGR5vshCjDuzz4SkXTNxzC9SxubjdeHozLVFkl7Eeyq/xOsa8Dx+Phe+h47M7Mk0bDUWL0//yoQt+C8Vtlz5r6t++0p/357kSWCspIJSCmPVG+NDPvXmRmDXQku2FxyBrwTbzszWw1uO4BVcAcv8nw+MTi3mAtlx6KfwSm5k5hhuzX+ZK2/UV9Jco16KCXh+Lk3nU/Ge8Eoz+w9wOZmhKwAzexFfmVe0lZ3c/4BXCmPM7NYy6U8FzjWzrE5/gPcmNwTWBv4H+EvScWE4dL2M//XIrdyT9FbgOuBrZvbXjFNXkbBdufR7S6t13KPhZmZ3pQr6U/gkdJatcs/EH9P1RRRvWI3HJ5mfy1wbi1fWR+ALMgr3ms9jKKKjJOMSvNd5VZonq0q/ZWikfmumXxsPM3sSuB04XtKINKn2Lbzw3pbxuoaktTNHtrCtmXMrt3z5PLzCvlzS2yWtIWmMpO9IqmaoaF28tbk0jZcfVeH+nsCHoWZIWitN6n084+V84OOSdpU0JMk/OTsJ3yKabdRL8UngTjNbkfLkQ8DnJC2QtAAfUtpd0tga4z0Xr1TOL+VB0oZ4pZPvmUwCLknj1ivNbCY+tzLRzJ7DGwxbZvxvScaQSdoYb8QcbWbZiXaSv5Jh60yzdfxn4CN9aLiB59veRa7vA/w9zSOtIs2rnITPIXw5XX4YGCpp04zXcvk8FF+gsV41+q1AM/VbGWvwcq56HWSW9uFL3RYC9+EtuN/iXdpF+BjtxEy4GXjrM3vMzcSZdzumghyvB36GG5EufAXOSXgrtIecmfTPT//Xx5cyduGF8EspzaGWW+aYzjfEu80r8Am0h/Ex0V9n/GyHD4sUlm/+AdioFXrJXf8bviplBN4y/O+ko4fx8eMb8cUAa2eOU4C78JUsc/EeQ8Ht1eR2F3B1Lq3JGZ0K73EchbeOl6Zy8m18Du5NuWNZyrd78BZrQQ+/xlfK/BvvQUwDbsmksTMwOp0fQ/dS3ULZXADcXCRfLkv6fDDl0XfS+ciUlwtT+fgn8Ha8spmSwk7Ay9s3S+jiv1K8E1JZux/4r4z7WikvbwW+mP6vUWcdP57inYI/j8vxXlpBj8Myce6W0//QMjKsja8i+hM+BzEkXZsOzMn4M+CtuWfoJnwV1L/xYeRjgTfjq7cW4mWrkMcdZJ7JdO1j+BDo2un8YuAiYDi+YGEZabk13hPaDG+YvwGfT7kzE9dx+PM6KqPfR4BrkvtmwD/wstuJNzjVSP32+tlvViVT5wprR2Ar4L5Wy9Lg+xxPd4W2Ll7xXgf8T6tly8hYqmIpZtSfTA/tWul6LUb95TIyTKb7PY8V6UG/LD1sW+HG41/AV3Phdk/XZ+HLe29P12/BDcro9JA/hrc8bymRftZ4FMrmS8BBJWQ9K1UaK9IxJXPf69P9HsAz9HwP4Ch6voPQhQ9bFNyFT84uSccJ9HwPoLNIvk6us44n4hX7o/i+WI1ouD1B9zsWlwPbZvwYPd/zWAFckHmG5qR8eCkdnfhS2uOTnw5WNx7CK+qvpvPR+BxI4V2T7HseX8UN6IqULxcDG2fcs+95PIMvuLiQbuOxoki+dDRSv71+9ltd+fRacFfygDYe6T7fg6/OWQPvhbwMvLvVcvXiPt6Lr5YpnH8b+HYZ/38DPpw57+pluiXLCXAGsF/m/CHcYO8HnFHKX1/SzPkbhS8bLZzPAca2WlfN1nWTZbsKX3X1EOkFy6Tzh1ogywb4cNyHgGuScVhE90hEj3xst6Nfz3k0gjR/0VXkuK5FIr0Jb1GsALbBJ0n/2SJZ+kKx7S4mFPOYxvU3wYcVCqwtaZak2yTt2WCZqpa1jxyE9yQLGP7C2mz5th/9lWblX01I6gDejc+TjjOzwrL7BfgLf83mZ/hQ32vpfAyw1HyZNLRJvpUijEcOM/uR9Xw7tXDk32Jtljy/x9+kfQD4jJmdViHIQGBf/MW67ItSP8HHiLcAfidpRYuNep+QtBNuPI7MXN7BzLbC5wK+ImnHooEHKI1suKWJ/cuBr5tZj6W25s1862saNcrzMfyFwHouZ24qYTzanPQi2eX4uO3vWi1PH6hl25p98QnJVZjZ9GTEh+MrmKbWwaiXkqmhW+ykdzTOAvYws8WF6+ZvDWNmC/H3SbatV5pNplf516iGW4ln6BlJ45P7eHzivJm8H/iEpDn4vMiH8DmikZkVn229tVNhFr+ljB071jo6Opqe7ooVKxg+vO22OwcaL9vs2bMXmdkbYNWy0nPxrrsBZ5rZyWk58SX4GP4cYB8zey4tyTwZn3B+Ad+Erex+OtXouF310Y5yVSNTVsfNoJyOW5GHgyHNZuu4B62edDEztt56a2sFN910U0vSrYZGy0Zmp16Kr+qaiK/mmJ6uT6d7Rcru+Fi9yKxSKndUo+N21Uc7ylWNTDR5N+ZyOm5FHg6GNJut4+wxqL9hfu+8ZWW/lz1Yvg5mPnE4P/1fLqmwlnwPfGkp+JuynfgY/R50vzl9m6SRksZb9wTkgKFj+h8qfld9sJSTdqTcx9QKegv9NIZBbTyC1alyRUqp1TQ9jIcyHwoaN24cnZ2dZdPu6uqq6KfZHLHFSsat47+laIXM7ZhXweAijEewivyKlOx+a2ZmkmqaIDPf5O1MgG222cYmT55c1n9nZyeV/NSbyp8BHsoRW6zkxHtLPypz9p9cV5mqoRV5FQRZYrVVANS8ImUgf/ArCIIqCOMRFDa0+zXwoPlGcAWupnvX2an427mF6wfK2R5YNhDnO4IgKE0MWwXga84PAO6VdFe69h18E7dLJR2E7yO0T3K7Fl9x9Qi+VPfzzRU3CIJWE8YjwPwLhaU+KJP/BnjhjdyvNFSoIAjamhi2CoIgCGomjEcQBEFQM2E8giAIgpoJ4xEEgwBJG0q6SdIDku6X9LV0fbSkGyT9O/2OStcl6RRJj0i6R9JWrb2DoN0I4xEEg4OVwBFmNhHfj+wrkibie5b92cw2xT9MND353w3YNB2H4F/bC4JVhPEIgkGAmc23tPOxmS2n+1vYe+D7lpF+Cx/aWrV/mZndhm8VPr7JYgdtTCzVDYJBRiv2L2vUXlzl9hwr7EnWzD3ABtOeY2E8gmAQ0ar9yxq1F1e53Y4Le5I1c++xwbTnWAxbBcEgIfYvC+pJxZ5HM74yFwSNovKuuYODKvYvO47V9y87VNLFwHb04/3LKpWB+N5H76hm2KqwSuNOSesCsyXdAEzDV2kcJ2k6vkrjSHqu0tgOX6WxXSOED4Kgavrl/mVh/NuXisYjvjIXBP2f2L8sqDc1zXn0cZVGEARBMECoerVVvVdp1PqJ0kbQjp8XLTCYlvwFQdD/qMp4lFulYWbze7NKo9ZPlDaCn19wVdt9XrTAYFry19+JCdlgMFJx2Cq+MhcEQRDkqabn0S9XaQRBEASNo5rVVv1ylUY1S/yO2KIJggRBEAxA4g3zIAiCoGZib6syVNN7icnQIAgGI9HzCIIgCGomjEcQBEFQM2E8giAIgpoJ4xEEQRDUTBiPIAiCoGZitVXQb4ntuoOgdUTPIwiCIKiZMB5BEARBzYTxCIIgCGom5jyCoMHETgWlaYd5q9BP74ieRxAEQVAz0fPoI/EhoMbRDq3SIAiK0xDjIWkKcDIwBDjLzI6rdxpRsbSWZug4aC2h46AcdR+2kjQE+AWwGzAR2E/SxHqnE7SO0PHAJ3QcVKIRPY9tgUfM7DEASRcDewAPVBvBQOpVDNBhrYbo+IgtVjJtAOm+FtqwnNRVx/1dt9XWSeXus58+6yWRf/ivjhFKewFTgF2AcfhXCNcAXgYOAU4wsw0kHZLOASYBc4FFwPrAMODxItFvAcwBltcg0hBgAjAqyfES8AywGBib0gQYk+QdBrwGPAfMA15N7usDbwIKGfZycl+aztcF3pbOH82kvw7ecusCHspc2yj9vgY8CxS+875Wuk/LpLUg4y5g43Q/ryW3ZzJumwDDUzwPs3peTQDekPLix8B0yxUCSQcC5wBfNLOzcuFX6djMDk7nBwDbmdmhOX9ZHW+Wuf9SZPVRYIsk673pfgv+xtOz8bNGxh3g33ieF6MDGE13/oKXiwfozv9sXK8C96T/a+Jl4fV42XoZLysLUpj1gZG4bucDT+fSfhOe/0OBZXh5LqRVTK5/lriHYnmVZ2Mze0MFP0VpgI6rkbfeDIY0e63jPmNmdT2AvYCz8IdiF/z756cmt8nA3CJhOoGD0/8ZwPkl4p4D7FKDLGsBs/Dvqm+CP/hT8Mr2cGBW8ndEujYl+elIYe4A1iomF7Ar8CIwLnNvC/FKZEzG30n4A9WZufYAcCxe+bwFr2Q+kdw68MpjVol7+l/gr7jxeEdKb0rmfr8O7JDinJwL+6Ukywa4EXkA+K+cn1HAv4D7CjoppePM+Sod97HsrHbPSeeLge9krh2czc90zYC3VpnOTOCYEm6F/B+alwuv2OcAFwId6dqG+LzAu9L5VHyo5ypgRi7uqSlvNwRGJD/nVCNXNXlVz6PeOm60vIM5zVYdjViqOy89HAU2SNdawQF4C39vM3vczF4xs+uBw4AfAmtIWg/4H+CrZnZ98jMH2AevSD5XLGIz+yPeqn9L5vLLwJXAvrBq3PgzwAW54B3ABWb2qpk9CtwCbF7lPU0Fjjaz58zsQeBXwLQk08tm9jPz786/WiLsiWY218zmAScWwmb4X+AUyreemq3jHwPflDSygWlUw+G4zj+Xyghm9pSZfc3M7knn55jZdRTvHX8c+HUK0wUcD3xG0uuaI35NtNNzHLQhjTAedwCb4t3yoXhFenUD0qmGDwPXmdmK3PXLgbXx1t/70v/fZT2kh/vaFEcP5HwUb+nnx4DPBQ5M/3fFW/D5oYufAQdKWlPSZsB7gRtzft4laa6k30gam9IdhQ/X3J3xdzfVG57Ny4WVtC2wDXB6hXjuADaVtImktWi8jmfhvdNvNjCNatgF+J2ZvVbRZ2mU+z8Mf14KfFnSEkmzJX26D+n0lWbrOOhn1N14mNlK4FB8/uBafB7gVklX1jutKhhL91zBKpKMi4Cbk59F6Vqe+cm9wD6SluJj6VcDPzKzpdkAZvY3YHQyCgfixiTPNfiwwIv4MMavzeyO5LYIeA/eO9oan0sp9FxGpN9lmbiWJT/VMKJI2BHJGA4BfgkcWqlyzOj4j8CDwKVmdn+VMpTjzDJuPwC+Kqle47vflLQ0c5yTc19UcKN7/m0MRcpTDVwPHCypQ9LrgSPT9ULP4xTckLwR+D4wU9L7S8RVLq/6TAN03FB5B3maLaEh73mY2bWS5uFj5qta1JJ2wOcU8qwJvNIAURbhLfUeSBqKG4Xf4q2/sZKGFjEg4+k5fHOpmX0uxdEBXCNpmZmdkQt3Hv7g7QR8AfhsJu3ReCVyKD52/ibgMknPmNkvU49nVjqQdCgwX9K6dE8Arwf8J/O/2gUEXcl/gfWALjMzSV8G7jGz26qJyMyuxRsHdcPMSj54ZnafpGuA6Xhl1ld+YmbfK+M+tkh5WEyR8lQDZ+NDQZ34s3ciPpQ1F8DM7sz4vVbSBcCngFvzEZXLq3pRTx03Q97BmmaraPb2JE/iFXWhBY2kwuqhJxqQ3o3AbpKG565/Gl9dcxvw9/T/U1kPScbdgD8XiziNeV+HP/x5zgO+DFxrZi/k3N4MvGpm55rZSjObC1wM7F7iHgorb9Yws+fwlu+WGfctgWpbhPeXCbsz8ElJCyQtwIfzTpR0apVxN4OjgC/ik/2t4EY8j3r13JjZa2Z2lJl1mNkGeN7Po/RcgtFzmCsI2oamGg8zexK4HThe0ghJw4Bv4b2ObIt3DUlrZ45hGbc1c27lek/n4a2636ahgjUl7YoPD8wws2VmtgyfMP+5pCnJTwdwaQp7XrGIJW2Ar85areI2s8eBDwLfLRL0YQ+uz0paQ9Kb8En1e1K820naLLmNSbJ2JjnBh8G+J2mUpLfjlenMjFzDJK2dTtdKeaRM2MMlTZC0Pr7KrBB2Gr56a1I6ZqV8KXYPLcHMHgEuwYf0WsFJeG/tHEkbA6S8PEnSu9L5min/1wCGpvwfktxGS3pLGiacmOL7YWGYUNJe6blYQ9JH8MUaMc8QtCeNWsZFiWW1eLf9t/gS00X4mOrEjPsMut9xKBxzM3Hm3coubcSXV56BL8V9Ea/sf4ovWX0Ef88B4CB8cvvF5PcMYFROrlfwoZ8uvAdwOvC65D6ZIsuQk1uPpaXAh/AJyWUpHy4E/g+ffH8KHx5ZkdyeBh4DbsCX0Q7Dhz+eT3IeXiTf83nUkdwEnAAsSccJpHd9isjcSYmlunUsH/cCd9FzKewN+DsahfvtUY5S+fkPfV+q+3JGl12pLG6WdGBJrufxpc8z8N7BXamM/CnpZjk+Z3VUphzMLJL/05Lb21K5ewHvaed199dUJp5P+lkG3Jcryz3yJ6PXU/DyfA+wVaP0VkXeTiH3bOXcN8Z78/ekMrZBH9M7G18if18J97rnTRVpvp3uEY1vtkoXDdd1qwVo+g37uxWP4sNHa+Erjia2WKbxhUKNT34/jL9YeALdxm06cHyr86+O9zwHn1fIXmub+03lZEGq7GY0uxIAdgS2yhmPovmDD3lelyrK7YHbW5hnZZ8tvOE4Nf3/EHBevfMp5173vKkizTfii16OHcjGYzBuyb5q2wUzexmfb9ijlQKZ2XxLk6VmthyfEJ6Q5CqsAjoH2LM1EjaNdrrfnYFHzawRc3EVMbOb8d5HllL5swdwrjm3ASMl9WViv7dU82xNBP6S/t9UxL0mSuRTlrrnTaU0zWyh+erJRiwCahv6vfGQ9B1JXUWO60oEmYAPDRWYS+smYFcjzbe8G58bGmdmhaWhC/DlzwMFA/6U3mcobG9Rt/uVdH+JcrF/lVHsC1yUOT9U0j2Szk7v27SCUvnTLmW6GjnupntxyieBddPcXitlCnpBvzceZvYjMxtR5Nit1bLVSlrhdTnwdTN7Putm3h+2ogH7JzuY2Vb4iravSNox69jX+zWzzUuUi/zb/quRXor7BD7EAnAavpPAJHyu68TeylUv+nF5+CbwQUn/xBeVZPePC/oRdd8YsTeMHTvWOjo6mprmihUrGD48v4K3PWmErLNnz15kTdxQLa/j/pL//UVOWF3WZutY0nvxVYy7pvNvA5jZ/5bwPwL4l/my5b6k2wFcY2bvLOJ2Br644qJ0/hC+51tfXvYsm2bGzwz8Paqf9CWtdqUtviTY0dHBrFmzmppmZ2cnkydPbmqavaURskpq6lh+Xsf9Jf/7i5ywuqzN1jGZLU3wHsW+ZF6QTTKNBZaYL0/+Nr5yqZFcjQ85XgxsByzrq+EInLYwHkEQ9H/MbGXaEeGP+Mqrs83sfkk/xJdjX40vaf9fSYZvD/SVvqQp6aIU51hJc/Fl02smeU7H35DfHV+q+wLw+b6kV02a6d2tWfg7Qa9J+jq+6uz5ElH2S8J4NJg2/MhPW3DvvGUVPw40WPOmP2NFtjQxsx9k/l8GXFbH9Par4G700UD1Is0F+C7EA5owHn1kIH31MAiCoFr6/WqrIAiCoPmE8QiCIAhqJoxHEARBUDNhPIIgCIKaCeMRBEEQ1EwYjyAIgqBmwngEAEiaI+leSXdJKnwCd7SkGyT9O/2OStcl6RRJj6TNArdqrfRBEDSbMB5Blp3MbJKZbZPOpwN/NrNN8Q/4TE/XdwM2p69n/wAABetJREFUTcch+MaBQRAMIsJ4BOVo9+9HBEHQIuIN86BA4fsaBpxhZmdS+/cjemw4l77TcQjAuHHj6OzsXOU2bh04YouVZQXK+m8VXV1dbSFHNfQnWYP+TxiPMgyyrUd2MLN5kt4I3CDpX1lHM7NkWKomGaAzAbbZZhvL7vj68wuu4sR7yxe/OftPLuveDPrzrrpB0Ehi2CoAwMzmpd+FwBX4J0WfKQxHpd+Fyfs8YMNM8A3StSAIBglhPAIkDZe0buE/8BHgPvxbCFOTt6nAVen/1cCBadXV9sQ3EoJg0BHDVgH4XMYVksDLxIVmdr2kO4BLJR0EPAHsk/zX/RsJQRD0LyoaD0lnAx8DFhY+uShpNHAJ0AHMAfYxs+fktc/JeMXyAjDNzO5sjOhBvTCzx4Ati1xfDOxc5Hrdv5EQBEH/opphq5nAlNy1WP8fBEEwiKloPMzsZmBJ7nKs/w+CIBjE9HbOo0/r/6H8OwDNoJo18ZXeQ6gH1dx3rN8PgqDd6POEeW/W/6dwJd8BaAbVrImv9I3telDNuwyxfj8Ignajt8bjGUnjzWx+rP/vG9W8iDhzyvAmSBIEQVA9vX3PI9b/B0EQDGKqWap7ETAZGCtpLnAUcByx/j8IgmDQUtF4mNl+JZz6/fr/QbZ3VRAEQd2I7UmCIAiCmgnjEQRBENRMGI8gCIKgZsJ4BEEQBDUTxiMIgiComTAeQRAEQc2E8QiCIAhqZsB+DKrSOxy+6eGAvf0gCIKGEj2PIAiCoGbCeARBEAQ1E8YjCIIgqJkY9O8H3DtvWdlvi8w57qNNlCYIgiB6HkEQBEEviJ5HEPQD4qNhQbvREOMhaQpwMjAEOMvMjqt3GrGdejfV5EW9h7aaoeMgCNqXug9bSRoC/ALYDZgI7CdpYr3TCVpH6DgIgkb0PLYFHjGzxwAkXQzsATxQbQTRq2h7+qzjIAj6N40wHhOApzLnc4Ht8p4kHQIckk67JD3UAFlKchiMBRY1M83eUg9ZdfxqlzbuQ3T10HHFeyoicyvoN+Vkp+NXk7UvOg6CsrRswtzMzgTObFX6kmaZ2TatSr8W+pOsWcrpuL/cU3+RE/qXrEH/pxFLdecBG2bON0jXgoFD6DgIBjmNMB53AJtK2kTSWsC+wNUNSCdoHaHjIBjk1H3YysxWSjoU+CO+jPNsM7u/3unUgZYNmfWCtpK1Tjpuq3sqQ3+RE/qXrEE/R2bWahmCIAiCfkZsTxIEQRDUTBiPIAiCoGYGrfGQNEPSPEl3pWP3VsuUR9IUSQ9JekTS9FbL0xsq3YOkYZIuSe63S+povpRVyTlN0rOZ8nJwi+Q8W9JCSfeVcJekU9J93CNpq2bLGAwOBq3xSPzUzCal49pWC5NlIGwBUuU9HAQ8Z2ZvBX4KNP3VwBry+pJMeTmrqUJ2MxOYUsZ9N2DTdBwCnNYEmYJByGA3Hu3Mqi1AzOxloLAFSH+imnvYAzgn/b8M2FmSmigj9KO8NrObgSVlvOwBnGvObcBISeObI10wmBjsxuPQ1LU/W9KoVguTo9gWIBNaJEtvqeYeVvkxs5XAMmBMU6QrIkOiVF5/OpWXyyRtWMS9HRgI5SboBwxo4yHpRkn3FTn2wLvzbwEmAfOBE1sqbNDu/B7oMLN3ATfQ3VsKgkHJgP4YlJntUo0/Sb8CrmmwOLUyELYAqeYeCn7mShoKvB5Y3BzxVpOhwGpymllWprOAE5ogV28YCOUm6AcM6J5HOXLjwJ8Eiq5eaSEDYQuQau7hamBq+r8X8Bdr/purFeXMlZdPAA82Ub5auBo4MK262h5YZmbzWy1UMPAY0D2PCpwgaRJgwBzgS60Vpyf9aJuXkpS6B0k/BGaZ2dXAr4HzJD2CTwTv26ZyHibpE8DKJOe0ZssJIOkiYDIwVtJc4ChgTQAzOx24FtgdeAR4Afh8K+QMBj6xPUkQBEFQM4N22CoIgiDoPWE8giAIgpoJ4xEEQRDUTBiPIAiCoGbCeARBEAQ1E8YjCIIgqJkwHkEQBEHN/H+tDqfmJZ2viQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#Plotting a histogram for the Test Data\n", + "\n", + "plt.figure(figsize=(15,15))\n", + "Test.hist()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "#Rug plots\n", + "#The rugplots are like histograms except they show every single data point on the x-axis, allowing us to visualize all of the actual values\n", + "#Both the Train and Test rugplots indicate some kind of left skew. This we need to take into account when designing the model" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "too many values to unpack (expected 2)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\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[0msns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdistplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mTrain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhist\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkde\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcolor\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'darkblue'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkde_kws\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0;34m'linewidth'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrug_kws\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0;34m'color'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'black'\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[0m", + "\u001b[0;32m/opt/anaconda3/lib/python3.7/site-packages/seaborn/distributions.py\u001b[0m in \u001b[0;36mdistplot\u001b[0;34m(a, bins, hist, kde, rug, fit, hist_kws, kde_kws, rug_kws, fit_kws, color, vertical, norm_hist, axlabel, label, ax)\u001b[0m\n\u001b[1;32m 229\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mkde\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 230\u001b[0m \u001b[0mkde_color\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mkde_kws\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"color\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcolor\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 231\u001b[0;31m \u001b[0mkdeplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvertical\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mvertical\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0max\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcolor\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mkde_color\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkde_kws\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 232\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mkde_color\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mcolor\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 233\u001b[0m \u001b[0mkde_kws\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"color\"\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mkde_color\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/opt/anaconda3/lib/python3.7/site-packages/seaborn/distributions.py\u001b[0m in \u001b[0;36mkdeplot\u001b[0;34m(data, data2, shade, vertical, kernel, bw, gridsize, cut, clip, legend, cumulative, shade_lowest, cbar, cbar_ax, cbar_kws, ax, **kwargs)\u001b[0m\n\u001b[1;32m 662\u001b[0m \u001b[0mwarn\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 663\u001b[0m \u001b[0mbivariate\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[0;32m--> 664\u001b[0;31m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mT\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 665\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mDataFrame\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\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[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 666\u001b[0m \u001b[0mwarn\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[0;31mValueError\u001b[0m: too many values to unpack (expected 2)" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sns.distplot(Train, hist = False, kde = True, rug = True, color = 'darkblue', kde_kws={'linewidth': 3}, rug_kws={'color': 'black'})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "too many values to unpack (expected 2)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\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[0msns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdistplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mTest\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhist\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkde\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrug\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcolor\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'darkblue'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkde_kws\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0;34m'linewidth'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrug_kws\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0;34m'color'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'black'\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[0m", + "\u001b[0;32m/opt/anaconda3/lib/python3.7/site-packages/seaborn/distributions.py\u001b[0m in \u001b[0;36mdistplot\u001b[0;34m(a, bins, hist, kde, rug, fit, hist_kws, kde_kws, rug_kws, fit_kws, color, vertical, norm_hist, axlabel, label, ax)\u001b[0m\n\u001b[1;32m 229\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mkde\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 230\u001b[0m \u001b[0mkde_color\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mkde_kws\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"color\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcolor\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 231\u001b[0;31m \u001b[0mkdeplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvertical\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mvertical\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0max\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcolor\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mkde_color\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkde_kws\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 232\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mkde_color\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mcolor\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 233\u001b[0m \u001b[0mkde_kws\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"color\"\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mkde_color\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/opt/anaconda3/lib/python3.7/site-packages/seaborn/distributions.py\u001b[0m in \u001b[0;36mkdeplot\u001b[0;34m(data, data2, shade, vertical, kernel, bw, gridsize, cut, clip, legend, cumulative, shade_lowest, cbar, cbar_ax, cbar_kws, ax, **kwargs)\u001b[0m\n\u001b[1;32m 662\u001b[0m \u001b[0mwarn\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 663\u001b[0m \u001b[0mbivariate\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[0;32m--> 664\u001b[0;31m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mT\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 665\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mDataFrame\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\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[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 666\u001b[0m \u001b[0mwarn\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[0;31mValueError\u001b[0m: too many values to unpack (expected 2)" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sns.distplot(Test, hist = False, kde = True, rug = True, color = 'darkblue', kde_kws={'linewidth': 3}, rug_kws={'color': 'black'})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Box plots" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Train\n", + "Train.plot(kind='box', subplots=True, layout=(12,12), sharex=False, sharey=False)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Test\n", + "Test.plot(kind='box', subplots=True, layout=(12,12), sharex=False, sharey=False)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Scatter Plot matrix\n", + "#scatter plot matrix shows the relationship between two variables as dots in two dimensions all at once" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#sns.pairplot(Train)\n", + "#The scatter plot for the train dataset indicates a mixture of correlations for different variables. \n", + "#Some have a positive strong correlation, others a negative correlation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Test data scatter plot\n", + "#sns.pairplot(Test)\n", + "#Similarly, some have aa positive correlation and negative correlation between different paired variables" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Preparing Data for machine learning" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Rescaling Data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Rescaling\n", + "#Since I might use features like regression and neural networks and algorithms that use distance measures like k-Nearest Neighbors. \n", + "#I need to rescale my data using scikit-learn using the MinMaxScaler class" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#We rescale to make sure all our data values lie in a scale from 0 to 1\n", + "#from numpy import set_printoptions\n", + "#from sklearn.preprocessing import MinMaxScaler\n", + "\n", + "#array = Train.values\n", + "# separate array into input and output components\n", + "#X = array[:,0:11]\n", + "#Y = array[:,11]\n", + "#scaler = MinMaxScaler(feature_range=(0, 1))\n", + "#rescaledX = scaler.fit_transform(X)\n", + "# summarize transformed data\n", + "#set_printoptions(precision=3)\n", + "#print(rescaledX[0:5,:])\n", + "\n", + "#Indeed all our data values have been rescaled" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# standardization of data\n", + "```from sklearn.preprocessing import StandardScaler\n", + "\n", + "array2 = data.values\n", + "#separate array into input and output components\n", + "X = array2[:,0:8]\n", + "Y = array2[:,8]\n", + "scaler = StandardScaler().fit(X)\n", + "rescaledX = scaler.transform(X)\n", + "# summarize transformed data\n", + "set_printoptions(precision=3)\n", + "print(rescaledX[0:5,:])\n", + "```\n", + "\n", + "# Normalization of data\n", + "``from sklearn.preprocessing import Normalizer\n", + "\n", + "array3 = data.values\n", + "#separate array into input and output components\n", + "X = array3[:,0:8]\n", + "Y = array3[:,8]\n", + "scaler = Normalizer().fit(X)\n", + "normalizedX = scaler.transform(X)\n", + "#summarize transformed data\n", + "set_printoptions(precision=3)\n", + "print(normalizedX[0:5,:])\n", + "print(type(normalizedX))#print the data type so we can know what we are \n", + "#working with in the dataset.\n", + "```\n", + "\n", + "```# Binarizing data\n", + "from sklearn.preprocessing import Binarizer\n", + "\n", + "array4 = data.values\n", + "#separate array into input and output components\n", + "X = array4[:,0:11]\n", + "Y = array4[:,11]\n", + "binarizer = Binarizer(threshold=0.0).fit(X)\n", + "binaryX = binarizer.transform(X)\n", + "#summarize transformed data\n", + "set_printoptions(precision=3)\n", + "print(binaryX[0:5,:])\n", + "```\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# using Standardized generation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#standardizing data\n", + "#from sklearn.preprocessing import StandardScaler\n", + "\n", + "#array2 = Train.values\n", + "# separating array into input and output components\n", + "#X = array2[:,0:11]\n", + "#Y = array2[:,11]\n", + "#scaler = StandardScaler().fit(X)\n", + "#rescaledX = scaler.transform(X)\n", + "\n", + "# summarizing transformed data\n", + "#set_printoptions(precision=3)\n", + "#print(rescaledX[0:5,:])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Binarizing data\n", + "## This will help incase there are probabilities in the data that need to be turned into crisp values." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# binarization\n", + "# It will turn data into 0s and 1s\n", + "from numpy import set_printoptions\n", + "from sklearn.preprocessing import Binarizer\n", + "\n", + "array4 = Train.values\n", + "# separate array into input and output components\n", + "X = array4[:,0:11]\n", + "Y = array4[:,11]\n", + "binarizer = Binarizer(threshold=0.0).fit(X)\n", + "binaryX = binarizer.transform(X)\n", + "# summarize transformed data\n", + "set_printoptions(precision=3)\n", + "print(binaryX[0:7,:]) #I am selecting the 7 best attributes out of the 11 to cover atleast 50% of the selected attributes\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Feature Selection" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Using the Recursive elimination\n", + "#from sklearn.feature_selection import RFE\n", + "#from sklearn.linear_model import LogisticRegression\n", + "\n", + "#array_1 = Train.values\n", + "#X = array_1[:,0:11]\n", + "#Y = array_1[:,11]\n", + "\n", + "# Extracting features\n", + "#model = LogisticRegression()\n", + "#rfe = RFE(model, 3)\n", + "#fit = rfe.fit(X, Y)\n", + "#print(\"Num Features: \", fit.n_features_)\n", + "#print(\"Selected Features:\", fit.support_)\n", + "#print(\"Feature Ranking: \", fit.ranking_)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#evaluating perfomance\n", + "#from sklearn.model_selection import train_test_split\n", + "#from sklearn.linear_model import LogisticRegression\n", + "\n", + "#array = Train.values\n", + "#X = array[:,0:11]\n", + "#Y = array[:,11]\n", + "#test_size = 0.33\n", + "#seed = 10\n", + "#X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=test_size, random_state=seed)\n", + "#model = LogisticRegression()\n", + "#model.fit(X_train, Y_train)\n", + "#result = model.score(X_test, Y_test)\n", + "#print(\"Accuracy: \", (result*100.0))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#model output" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#out = model.predict(Test.values)\n", + "\n", + "#KC = pd.DataFrame(out) #Converting to data frame\n", + "#KC.columns=[\"CLASS\"] #Naming the column\n", + "#KC.index.name=\"Index\" #Creating a column index\n", + "#KC[\"CLASS\"]=KC[\"CLASS\"].map({0.0:False,1.0:True}) # Chaninging 0 to \"False\" 1 to \"True\"\n", + "\n", + "#KC.to_csv(\"KC_csv\") ## Writing a csv file\n", + "#print(KC['CLASS'].unique())\n", + "#print(KC['CLASS'].nunique())\n", + "\n", + "#printing the numbers of False and True\n", + "#print(KC.groupby('CLASS').size()[0].sum()) #\n", + "#print(KC.groupby('CLASS').size()[1].sum())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#from sklearn.preprocessing import StandardScaler\n", + "\n", + "#array2 = Train.values\n", + "# separating array into input and output components\n", + "#X = array2[:,0:11]\n", + "#Y = array2[:,11]\n", + "#scaler = StandardScaler().fit(X)\n", + "#rescaledX = scaler.transform(X)\n", + "# transformed data should be summarized using the code below\n", + "#set_printoptions(precision=3)\n", + "#print(rescaledX[0:5,:])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Principal Component analysis feature" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Training the model using PCA as the feature of choice\n", + "#from sklearn.decomposition import PCA\n", + "\n", + "#array = Train.values\n", + "#X = array[:,0:11]\n", + "#Y = array[:,11]\n", + "\n", + "# feature extraction\n", + "#pca = PCA(n_components=3)\n", + "#fit = pca.fit(X)\n", + "# summarize components\n", + "#print(\"Explained Variance: \" , fit.explained_variance_ratio_)\n", + "#print(fit.components_)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Output model using PCA as the feature" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#out = model.predict(Test.values)\n", + "\n", + "#KC2 = pd.DataFrame(out) #Converting the data to data frame\n", + "#KC2.columns=[\"CLASS\"] #Naming the column\n", + "#KC2.index.name=\"Index\" #Creating a column index\n", + "#KC2[\"CLASS\"]=KC2[\"CLASS\"].map({0.0:False,1.0:True}) # Chaninging 0 to \"False\" 1 to \"True\"\n", + "\n", + "#KC2.to_csv(\"KC2_csv\") # obtaininng a csv file\n", + "#print(KC2['CLASS'].unique())\n", + "#print(KC2['CLASS'].nunique())\n", + "\n", + "#printing the numbers of False and True\n", + "#print(KC2.groupby('CLASS').size()[0].sum()) #\n", + "#print(KC2.groupby('CLASS').size()[1].sum())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#print(\"Hello\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# sklearn.feature_selection.SelectFromModel\n", + "## Parameters for the model\n", + "\n", + "### estimator: object\n", + "```The base estimator from which the transformer is built. This can be both a fitted (if prefit is set to True) or a non-fitted estimator. The estimator must have either a feature_importances_ or coef_ attribute after fitting.\n", + "Features whose importance is greater or equal are kept while the others are discarded. If “median” (resp. “mean”), then the threshold value is the median (resp. the mean) of the feature importances. A scaling factor (e.g., “1.25*mean”) may also be used. If None and if the estimator has a parameter penalty set to l1, either explicitly or implicitly (e.g, Lasso), the threshold used is 1e-5. Otherwise, “mean” is used by default.\n", + "Whether a prefit model is expected to be passed into the constructor directly or not. If True, transform must be called directly and SelectFromModel cannot be used with cross_val_score, GridSearchCV and similar utilities that clone the estimator. Otherwise train the model using fit and then transform to do feature selection.```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.feature_selection import SelectFromModel\n", + "from sklearn.linear_model import LogisticRegression\n", + "\n", + "array6 = Train.values\n", + "X = array6[:,0:11]\n", + "Y = array6[:,11]\n", + "\n", + "#fitting to the model\n", + "selector = SelectFromModel(estimator=LogisticRegression()).fit(X, Y)\n", + "selector.estimator_.coef_\n", + "array6\n", + "selector.threshold_\n", + "\n", + "selector.get_support()\n", + "array6\n", + "selector.transform(X)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Logistic model output" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#model2 = model.predict(Test.values)\n", + "\n", + "#KC3 = pd.DataFrame(model2) #Converting the data to data frame\n", + "#KC3.columns=[\"CLASS\"] #Naming the column\n", + "#KC3.index.name=\"Index\" #Creating a column index\n", + "#KC3[\"CLASS\"]=KC3[\"CLASS\"].map({0.0:False,1.0:True}) # Chaninging 0 to \"False\" 1 to \"True\"\n", + "\n", + "#KC3.to_csv(\"KC3_csv\") # obtaininng a csv file\n", + "#print(KC3['CLASS'].unique())\n", + "#print(KC3['CLASS'].nunique())\n", + "\n", + "#printing the numbers of False and True\n", + "#print(KC3.groupby('CLASS').size()[0].sum()) \n", + "#print(KC3.groupby('CLASS').size()[1].sum())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Recursive feature model elimination" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#import numpy as np\n", + "#from sklearn.feature_selection import RFE\n", + "#from sklearn.svm import SVR\n", + "#array8 = Train.values\n", + "#array8 = Train.values\n", + "#X = array8[:,0:11]\n", + "#Y = array8[:,11]\n", + "#estimator = SVR(kernel=\"linear\")\n", + "#selector = RFE(estimator, 5, step=1)\n", + "#selector = selector.fit(X, Y)\n", + "#set_printoptions(precision=3)\n", + "#print(estimator[0:7,:]) #To print out the chosen 7 attributes that best fit the data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#from sklearn.linear_model import ElasticNet\n", + "#from sklearn.datasets import make_regression\n", + "#X, Y = Train(n_features=2, random_state=0)\n", + "#regr = ElasticNet(random_state=0)\n", + "#regr.fit(X, Y)\n", + "#ElasticNet(random_state=0)\n", + "#print(regr.coef_)\n", + "#print(regr.intercept_)\n", + "#print(regr.predict([[0, 0]]))\n", + "\n", + "#model2 = model.predict(Test.values)\n", + "\n", + "#KC3 = pd.DataFrame(model2) #Converting the data to data frame\n", + "#KC3.columns=[\"CLASS\"] #Naming the column\n", + "#KC3.index.name=\"Index\" #Creating a column index\n", + "#KC3[\"CLASS\"]=KC3[\"CLASS\"].map({0.0:False,1.0:True}) # Chaninging 0 to \"False\" 1 to \"True\"\n", + "\n", + "#KC3.to_csv(\"KC3_csv\") # obtaininng a csv file\n", + "#print(KC3['CLASS'].unique())\n", + "#print(KC3['CLASS'].nunique())\n", + "\n", + "#printing the numbers of False and True\n", + "#print(KC3.groupby('CLASS').size()[0].sum()) \n", + "#print(KC3.groupby('CLASS').size()[1].sum())\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn import linear_model\n", + "reg = linear_model.Lasso(alpha=0.1)\n", + "reg.fit([[0, 0], [1, 1]], [0, 1])\n", + "Lasso(alpha=0.1)\n", + "reg.predict([[1, 1]])\n", + "array([0.8])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Comparison of different models\n", + "## To select which model works best\n", + "```A comparison of all models will enable me select out which models best suit the data.\n", + "From these, I can pick out which one gives best accuracy and perfom an MCM statistics.```\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Linear regression\n", + "```Linear regression fits a linear model with coefficients to minimize the residual sum of squares between the observed targets in the dataset, and the targets predicted by the linear approximation. Linear regression will enable me fit the best line on the distributions in the data. There are more advanced ways to fit a line to data, but in general, I want the line to go through the \"middle\" of the points.```\n", + "\n", + "# Histogram-based Gradient Boosting Classification Tree\n", + "```Although Gradient boosting is a greedy algorithm and can overfit a training dataset quickly, It can benefit from regularization methods that penalize various parts of the algorithm and generally improve the performance of the algorithm by reducing overfitting. I want to use this model to checkfo overfitting .```\n", + "\n", + "# K-fold\n", + "```When we split the dataset into training and test set, we use only a subset of data and we know when we train on fewer observations the model will not perform well and overestimate the test error rate for the model to fit on the entire dataset. We correct for this by using a K-fold cross-validation with a specified number of kfolds. Cross-validation will give me a more accurate estimate of a model’s performance```\n", + "\n", + "# XGBClassifier\n", + "```XGBoost is an efficient and easy to use an algorithm which delivers high performance and accuracy as compared to other algorithms. I added XGBClassifier because it has in-built L1 (Lasso Regression) and L2 (Ridge Regression) regularization which prevents the model from overfitting.```\n", + "\n", + "# RandomForestClassifier \n", + "``` I added Random forest classifier because it is one of the most accurate learning algorithms available. For many data sets, it produces a highly accurate classifier. It runs efficiently on large databases. It can handle thousands of input variables without variable deletion. It will be a good basis to compare other models```\n", + "\n", + "# SGDClassifier\n", + "``` Stochastic Gradient Descent (SGD) is a simple yet very efficient approach to discriminative learning of linear classifiers under convex loss functions such as (linear) Support Vector Machines and Logistic Regression. I chose to add it as one of the models has been successfully applied to large-scale and sparse machine learning problems often encountered in text classification and natural language processing. This classifier supports multi-class classification by combining multiple binary classifiers in a “one versus all” (OVA) scheme.```\n", + "\n", + "# DecisionTreeClassifier\n", + "```Thi algorithm is simpler to understand, interpret and visualize. Effort required for Data preparation is minimal. Additionally, decision trees combined into an ensemble create some of the best binary classifiers.```\n", + "\n", + "# BaggingClassifier \n", + "```Bagging takes the advantage of ensemble learning wherein multiple weak learner outperform a single strong learner. It helps reduce variance and thus helps us avoid overfitting. There is loss of interpretability of the model. There can possibly be a problem of high bias if not modeled properly.```\n", + "\n", + "# Coss validation score\n", + "```Using cross validation can give me a hint of how well my model is doing, and it has the advantage of being very robust (as opposed to simple train-test split). It can be also used in hyper-tuning of parameters: for a given parameters, using the CV score to optimize its value in a robust way.```\n", + "\n", + "# LogisticRegression \n", + "```I chose Logistic Regression because performs well when the dataset is linearly separable.Logistic regression is less prone to over-fitting but it can overfit in high dimensional datasets. Logistic Regression not only gives a measure of how relevant a predictor (coefficient size) is, but also its direction of association (positive or negative). Logistic regression is easier to implement, interpret and very efficient to train. It would work well in prediciting my model.```\n", + "\n", + "# KNeighborsClassifier\n", + "```I chose this algorithm because it is simple and easy to implement. There's no need to build a model, tune several parameters, or make additional assumptions. The algorithm is versatile. It can be used for classification, regression, and search.```\n", + "\n", + "# LinearDiscriminantAnalysis\n", + "```LDA in the binary-class case has been shown to be equivalent to linear regression with the class label as the output. This implies that LDA for binary-class classifications can be formulated as a least squares problem. It will give me a good comparison with the linear regression model already included.```\n", + "\n", + "# GaussianNB \n", + "```I chose the naive Bayesian classifier because they are extremely fast for both training and prediction. They provide straightforward probabilistic prediction. This classifier needs less training data, highly scalable. It scales linearly with the number of predictors and data points. Can be used for both binary and mult-iclass classification problems. Can make probabilistic predictions. Handles continuous and discrete data. Not sensitive to irrelevant features. It would therefore be a good model to include in the testing algorithms```\n", + "\n", + "# SVC\n", + "``I added this model beause SVM Classifiers offer good accuracy and perform faster prediction compared to Naïve Bayes algorithm.They willhelp me audit the naive bayes classifier. They also use less memory because they use a subset of training points in the decision phase. SVM works well with a clear margin of separation and with high dimensional space. Evenwhen my dimentional space is not that big, its worth a try.```\n", + "\n", + "# HistGradientBoostingClassifier\n", + "```This is one of the ensemble methods. The goal of ensemble methods is to combine the predictions of several base estimators built with a given learning algorithm in order to improve generalizability / robustness over a single estimator. It will give me a good comparison with the model.```\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Models comparison\n", + "from sklearn import linear_model\n", + "from sklearn.experimental import enable_hist_gradient_boosting\n", + "from sklearn.model_selection import KFold\n", + "from xgboost import XGBClassifier\n", + "from sklearn.ensemble import RandomForestClassifier\n", + "from sklearn.linear_model import SGDClassifier\n", + "from sklearn.tree import DecisionTreeClassifier\n", + "from sklearn.ensemble import BaggingClassifier\n", + "from sklearn.model_selection import cross_val_score\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.neighbors import KNeighborsClassifier\n", + "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n", + "from sklearn.naive_bayes import GaussianNB\n", + "from sklearn.svm import SVC\n", + "from sklearn.ensemble import HistGradientBoostingClassifier" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Combining all models\n", + "models = []\n", + "models.append(('LR', LogisticRegression()))\n", + "models.append(('LDA', LinearDiscriminantAnalysis()))\n", + "models.append(('RFC',RandomForestClassifier()))\n", + "models.append(('BAG',BaggingClassifier()))\n", + "models.append(('XGB',XGBClassifier()))\n", + "models.append(('SGD',SGDClassifier()))\n", + "models.append(('HGB',HistGradientBoostingClassifier()))\n", + "models.append(('NB', GaussianNB()))\n", + "models.append(('SVM', SVC()))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# EStimating accuracy of the models\n", + "## Model accuracy\n", + "```The accuracy of the models is determined to inform the next step over which is the most \n", + "accurate model to follow.```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# The comparative accuracies of the models is determined\n", + "\n", + "results = []\n", + "names = []\n", + "scoring = 'accuracy'\n", + "\n", + "for name, model in models:\n", + " kfold = KFold(n_splits=10, random_state=7)\n", + " cv_results = cross_val_score(model, X, Y, cv=kfold, scoring=scoring)\n", + " results.append(cv_results)\n", + " names.append(name)\n", + " kc4 = (name, cv_results.mean(), cv_results.std())\n", + " print(kc4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Model chosen\n", + "## NB', GaussianNB() \n", + "```GaussianNB shows the highest accuracy, at 88%.\n", + "I chose to test this further. Furtherstill, I choose this particular model because of the boxplot comparison\n", + "It has a small error from the mean. Thus its accuracy can be trusted to a better extent compared to other models```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Graph to show comparisons" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig = plt.figure()\n", + "fig.suptitle('Comparison of models')\n", + "ax = fig.add_subplot(111)\n", + "plt.boxplot(results)\n", + "ax.set_xticklabels(names)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Testing the model on Matthew's Correlation Coefficient\n", + "``` To futher test for a better metric than accuracy, I will test the GaussianNB modle on Matthew's correlation```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import matthews_corrcoef\n", + "\n", + "array= Train.values\n", + "X = array[:,0:11]\n", + "Y = array[:,11]\n", + "test_size = 0.33\n", + "seed = 7\n", + "X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=test_size,\n", + "random_state=seed)\n", + "\n", + "kintu_model2 = LogisticRegression()\n", + "kintu_model2.fit(X_train, Y_train)\n", + "\n", + "predicted3= kintu_model2.predict(X_test)\n", + "comp_mat = matthews_corrcoef(Y_test, predicted3)\n", + "print(comp_mat)\n", + "\n", + "#Mathews correlation coefficient gives a moderate" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Generating the csv file\n", + "``` I generate a csv file to enable me judge the accuracy of this model and submit to the competition.```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Generating a csv file\n", + "kintu_df=pd.DataFrame(predicted3)\n", + "kintu_df.columns=['CLASS']\n", + "kintu_df.index.names=[\"Index\"]\n", + "kintu_df['CLASS']=kintu_df['CLASS'].map({0.0:False, 1.0:True})\n", + "kintu_df\n", + "kintu_df.to_csv('KC_model2_csv')\n", + "print(kintu_df['CLASS'].unique())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Re-testingLinear Regression\n", + "```Running each model seperately to allow me change certain parameters \n", + "that are not possible tochange when doing an overall comparison```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from sklearn.linear_model import LinearRegression\n", + "array2 = Train.values\n", + "reg = LinearRegression().fit(X, Y)\n", + "reg.score(X, Y)\n", + "scoring = ('Accuracy')\n", + "reg.coef_\n", + "reg.intercept_\n", + "xp = reg.predict(X)\n", + "xp\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.4" + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/pandas_exercises b/pandas_exercises new file mode 160000 index 0000000..eb62966 --- /dev/null +++ b/pandas_exercises @@ -0,0 +1 @@ +Subproject commit eb629669319f161fbe4b82e8387771ae8b64789d