diff --git a/Assignment Colab/.ipynb_checkpoints/nsangi-olga-tendo-checkpoint.ipynb b/Assignment Colab/.ipynb_checkpoints/nsangi-olga-tendo-checkpoint.ipynb index 2d52262..70aaa15 100644 --- a/Assignment Colab/.ipynb_checkpoints/nsangi-olga-tendo-checkpoint.ipynb +++ b/Assignment Colab/.ipynb_checkpoints/nsangi-olga-tendo-checkpoint.ipynb @@ -4,8 +4,33 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "
\n", - " Please look out for these cells for corrections." + "## [Link to learn how to use Jupyter Makdown](https://www.earthdatascience.org/courses/intro-to-earth-data-science/file-formats/use-text-files/format-text-with-markdown-jupyter-notebook/)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# **ACE Class competition**\n", + "#### By Nsangi Olga Tendo\n", + "## Machine Learning Process:\n", + "- Have a peek of raw data\n", + "- Review of dimensions of thedataset.\n", + "#### 3. Review of attribues in the data set\n", + "#### 4. Review the data types of attributes in your data.\n", + "#### 5. Review of missing data(NAs)\n", + "#### 6. Summary of data using descriptive statistics.\n", + "#### 7. Understand the relationships in your data using correlations.\n", + "#### 8. Data Visualisation\n", + "#### 9. Review the skew of the distributions of each attribute.\n", + "#### 10.Spot checking classification algorithms\n", + "#### 11.Data preparation\n", + "#### 12.Feature selection\n", + "#### 13. Machine learning\n", + "\n", + "\n", + "
\n", + " Please use markdown better." ] }, { @@ -20,8 +45,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "/kaggle/input/ace-class-assignment/Test.csv\n", - "/kaggle/input/ace-class-assignment/AMP_TrainSet.csv\n" + "/kaggle/input/ace-class-assignment/AMP_TrainSet.csv\n", + "/kaggle/input/ace-class-assignment/Test.csv\n" ] } ], @@ -30,6 +55,7 @@ "# It is defined by the kaggle/python docker image: https://github.com/kaggle/docker-python\n", "# For example, here's several helpful packages to load in \n", "\n", + "#Importing the necessary libraries that are going to be used in the pipeline\n", "import numpy as np # linear algebra\n", "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n", "import matplotlib.pyplot as plt\n", @@ -52,7 +78,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Naming the Training and test dataset using." + "#### 1. Naming the Training and test dataset using." ] }, { @@ -72,7 +98,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Confirming that the data has been read in and assigned to variables Train and Test" + "#### Confirming that the data has been read in and assigned to variables Train and Test" ] }, { @@ -321,18 +347,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Dimensions of the data train set\n", - "### Checking for the number of rows and columns in the data sets\n", - "\n", - "
\n", - " \n", - " ## ??\n", - " \n", - " When you see these: \n", - " - I want to know if you understand the concept\n", - " - Why are you applying the concept\n", - " - What did you learn?\n", - " - I want to see that you know what you are doing." + "#### 2. Dimensions of the train and test data set\n", + "#### This helps in knowing the size of your data set and also give an intiution on what algorithms you could use incase the size is big or small." ] }, { @@ -343,7 +359,7 @@ { "data": { "text/plain": [ - "(3038, 12)" + "((3038, 12), (758, 11))" ] }, "execution_count": 4, @@ -352,14 +368,14 @@ } ], "source": [ - "Train.shape" + "Train.shape, Test.shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Establishing the attributes in the train data set" + "#### 3. Establishing the attributes in the train and test data set" ] }, { @@ -370,11 +386,16 @@ { "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')" + "(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'),\n", + " 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": 5, @@ -383,19 +404,17 @@ } ], "source": [ - "Train.columns" + "Train.columns, Test.columns" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Establishing the data types for each attribute in the train data set. This helps in finding out which column has data types like strings that may need to be converted to foating points or integers to represent categorical or ordinal values. This can be done using df.dtype method or the df.info() method as shown in the two cells below, tho the df.info() is more informative.\n", + "#### 4. Establishing the data types for each attribute in the train data set. This helps in finding out which columns have data types like strings that may need to be converted to foating points or integers to represent categorical or ordinal values since most machine learning algorithms take in integers or floats for inputs. This can be done using df.dtype method or the df.info() method as shown in the two cells below, tho the df.info() is more informative as its also tells the total number of instances for each column.\n", "\n", "
\n", - " \n", - " Why is everything so big? \n", - "

like this?" + " Please use markdown better." ] }, { @@ -406,19 +425,31 @@ { "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" + "(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,\n", + " 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": 6, @@ -427,7 +458,7 @@ } ], "source": [ - "Train.dtypes" + "Train.dtypes, Test.dtypes" ] }, { @@ -467,14 +498,59 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Statistical summary of the data in each column.\n", - "### This helps understand the distribution of each column as this method returns values like percentiles,standard deviation, minimum and maximum values of each attribute. This way you can also find out if you have negative values in any attribute. This also helps in understanding the scales at which each attribute is at." + "#### 5. Establishing if there are any missing values in the attributes of the data set. This helps to give an insight on how to handle the missing values, whether to remove rows that have missing values or establishing a method like the mean,median ect to impute the NAs. \n", + "\n", + "
\n", + "Good explanation, but use better markdown for presentation" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "FULL_Charge 0\n", + "FULL_AcidicMolPerc 0\n", + "FULL_AURR980107 0\n", + "FULL_DAYM780201 0\n", + "FULL_GEOR030101 0\n", + "FULL_OOBM850104 0\n", + "NT_EFC195 0\n", + "AS_MeanAmphiMoment 0\n", + "AS_DAYM780201 0\n", + "AS_FUKS010112 0\n", + "CT_RACS820104 0\n", + "CLASS 0\n", + "dtype: int64" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Train.isna().sum()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 6. Descriptive statistics summary of the data in each column.\n", + "#### This includes measures of central tendencies like teh mean, median and measures of spread like standard, variance, range and interquatile range. The smallest and largest values of each column are also returned. This helps in understanding the distribution of data in each column. This way you can also find out if you have negative values in any attribute. This also helps in understanding the scales at which each attribute is at.\n", + "\n", + "
\n", + " Good." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, "outputs": [ { "data": { @@ -668,7 +744,7 @@ "max 103.167000 8.662000 2.192000 1.000000 " ] }, - "execution_count": 8, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -681,27 +757,22 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### From the values above, there are no missing values since all counts in each column is equal. We can also observe that there are negative values in some attributes have a minimum values in negatives.\n", - "\n", - "
\n", - " \n", - " ## ??" + "#### From the values above, there are no missing values since all counts in each column is equal. We can also observe that there are negative values in some attributes have a minimum values in negatives." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Since this is a classification problem, its important to check out the propotions of the values in the class to be predicted as its possible one class may have more values as compared to the others.\n", + "#### Since this is a classification problem, its important to check out the propotions of the values in the class to be predicted as its possible one class may have more values as compared to the others. Incases where one class is higher than another class we could employe methods likes `SMOTE` to over sample the least represented class so as to have an un biased algorithm.\n", "\n", - "
\n", - " \n", - " ## ??" + "
\n", + " Good." ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -710,7 +781,7 @@ "Text(0, 0.5, 'Distirbution')" ] }, - "execution_count": 9, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, @@ -738,7 +809,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -750,7 +821,7 @@ "dtype: int64" ] }, - "execution_count": 10, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -764,58 +835,18 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### From above, the entries in the class attribute are equal." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Establishing if there are any missing values in the attributes of the data set. This helps to give an insight on how to handle the missing values, whether to remove rows that have missing values or establishing a method like the mean,median ect to impute the NAs. \n", + "#### From above, the entries in the class attribute are equal.\n", "\n", "
\n", - " \n", - " Good explanation." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "FULL_Charge 0\n", - "FULL_AcidicMolPerc 0\n", - "FULL_AURR980107 0\n", - "FULL_DAYM780201 0\n", - "FULL_GEOR030101 0\n", - "FULL_OOBM850104 0\n", - "NT_EFC195 0\n", - "AS_MeanAmphiMoment 0\n", - "AS_DAYM780201 0\n", - "AS_FUKS010112 0\n", - "CT_RACS820104 0\n", - "CLASS 0\n", - "dtype: int64" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Train.isna().sum()" + " Good." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Correlation between attributes.\n", - "## This is done to establish the relationship between variables and how they may change or may not change each other. The pearson's correlation method is going to be used since it assumes normal distribution on attributes involved. A value of 0 shows no correlation between the attributes, while a correlation of -1 or 1 shows full negative or positive correlation between variables." + "#### 7. Correlation between attributes.\n", + "#### This is done to establish the relationship between variables and how they may change or may not change each other. The pearson's correlation method is going to be used since it assumes normal distribution on attributes involved. A value of 0 shows no correlation between the attributes, while a correlation of -1 or 1 shows full negative or positive correlation between variables." ] }, { @@ -1114,7 +1145,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## From the summary above, AS_DAYM780201 and FULL_DAYM780201 are the strongest positively correlated with a correlation of 0.894191 while FULL_AcidicMolPerc and FULL_Charge are the strongest negatively correlated attributes. This correlation can further be observed by plotting a heat map using seaborn to show the correlation of attributes with each other as shown below" + "#### From the summary above, AS_DAYM780201 and FULL_DAYM780201 are the strongest positively correlated with a correlation of 0.894191 while FULL_AcidicMolPerc and FULL_Charge are the strongest negatively correlated attributes. This correlation can further be observed by plotting a heat map using seaborn to show the correlation of attributes with each other as shown below.\n", + "\n", + "
\n", + " Good.\n", + " When a variable is strongly correlated, what does it mean? Please learn more about this.\n", + " \n", + " Good visual" ] }, { @@ -1125,7 +1162,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 13, @@ -1154,19 +1191,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Using visualisation to understand the data at hand. Histograms, Density plots and Box and whisker plots are some of the plots used to understand the attribute distribution.\n", - "## Histograms were used.\n", + "#### 8. Using visualisation to understand the data at hand. Histograms, Density plots and Box and whisker plots are some of the plots used to understand the attribute distribution. Histograms were used. \n", + "

They're used to summarize discrete or continuous data by showing the number(frequency) of data points that fall within a specified range of values. Histograms graphically show center) of the data, spread (i.e., the scale) of the data, skewness of the data, presence of outliers and presence of multiple modes in the data\n", "\n", - "

\n", - " \n", - " ## ??" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Using Histograms" + "
\n", + " Good." ] }, { @@ -1196,19 +1225,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## From the histograms above, we can observe that attributes AS_MeanAmphiMoment, AS_DAYM780201, AS_FUKS010112, FULL_DAYM780201, FULL_GEOR030101, FULL_AURR980107,FULL_CHARGE have a normal. We can also tell from these plots that attribute CT_RACS820104 and FULL_AcidicMolPerc are skewed to the right. We can also tell that attributes NT_EFC195 and CLASS are categorical attributes. This can also be observed using density plots as shown below.\n", - "\n", - "
\n", - " \n", - " ## ??" + "#### From the histograms above, we can observe that attributes AS_MeanAmphiMoment, AS_DAYM780201, AS_FUKS010112, FULL_DAYM780201, FULL_GEOR030101, FULL_AURR980107,FULL_CHARGE have a normal. We can also tell from these plots that attribute CT_RACS820104 and FULL_AcidicMolPerc are skewed to the right. We can also tell that attributes NT_EFC195 and CLASS are categorical attributes. This can also be observed using density plots as shown below." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Using Density plots\n", - "### With the density plot, we can easily make comparisons between variables in each column because the plot is less cluttered." + "#### Using Density plots. Density plots are used to observe the distribution of a variable in a dataset. The peaks of a Density Plot help display where values are concentrated over the interval. Density plots give a more precise location and also gives a continuous distribution view. " ] }, { @@ -1248,12 +1272,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Checking for the skewness of the data. Since many machine learning algorithms assume normal distribution,this allows one to know what attributes need to be corrected of skewness to improve the accuracy of the model. Skewness can be observed with bar plots of .skew().\n", - "\n", - "
\n", - " Good explanation.\n", - " \n", - " So what did you findout?" + "#### From the above plots, FULL_Charge, FULL_AURR980107, FULL_DAYM780201, FULL_GEOR030101, CT_RACS820104, FULL_OOBM850104, AS_FUKS010112, AS_DAYM780201 show a normal distribution of variables. CLASS and NT_EFC195 are categorical data CLASS having equal number of instances while NT_EFC195 has a category that has almost all instances. \tFULL_AcidicMolPerc and AS_MeanAmphiMoment have more than one peak meaning that the data points are distribute at 2 peak for FULL_AcidicMolPerc and 3 peaks for AS_MeanAmphiMoment\t" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 9. Checking for the skewness of the data. Skewness is deviation from a normal distribution. The data may be skewed to the left or to the right of the normal distribution curve (bell shaped). Since many machine learning algorithms assume normal distribution,this allows one to know what attributes need to be corrected of skewness to improve the accuracy of the model. Skewness can be observed with bar plots of .skew()." ] }, { @@ -1264,7 +1290,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 16, @@ -1316,35 +1342,23 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Separating the train data set into output and input components" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [], - "source": [ - "A = Train.values\n", - "X = A[:, 0:11]\n", - "Y = A[:,11]" + "#### From the check above, attribute NT_EFC195 has skewed data and this could alter final results of the model. The data could be transformed or the attributed drop(not used in building a classifier." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Spot checking classification algorithms since its a classification problem at hand.\n", - "### This is done to know which algorithm is best suited for the problem at hand. Two linear machine learning algorithms(Logistic regression and Linear discriminant analysis) and four non-linear machine learning algorithm were used(k-nearest neighbors, naive bayes, support vector machines and classific regression tress. \n", + "#### 10. Spot checking classification algorithms since its a classification problem at hand.\n", + "#### This is done to know which algorithm is best suited for the problem at hand. Two linear machine learning algorithms(Logistic regression and Linear discriminant analysis) and four non-linear machine learning algorithm were used(k-nearest neighbors, naive bayes, support vector machines and classific regression tress. \n", "\n", - "
\n", - " \n", - " ## Less than 10 algorithms!!!" + "
\n", + " You have less than 10 algorithms." ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -1356,12 +1370,13 @@ "('KNN', 0.8690586462107053)\n", "('CART', 1.0)\n", "('NB', 0.8407203694376205)\n", - "('SVM', 0.8187103751493263)\n" + "('SVM', 0.8187103751493263)\n", + "('ABC', 0.8848771929251248)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1373,7 +1388,6 @@ } ], "source": [ - "from pandas import read_csv\n", "from matplotlib import pyplot\n", "from sklearn.model_selection import KFold\n", "from sklearn.model_selection import cross_val_score\n", @@ -1383,10 +1397,11 @@ "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n", "from sklearn.naive_bayes import GaussianNB\n", "from sklearn.svm import SVC\n", + "from sklearn.ensemble import AdaBoostClassifier\n", "from sklearn.metrics import matthews_corrcoef\n", "\n", "#split the dataset \n", - "#A = Train.values\n", + "A = Train.values\n", "# Separating A into output and input components\n", "X = A[:, 0:11]\n", "Y = A[:, 11]\n", @@ -1398,6 +1413,8 @@ "models.append(('CART', DecisionTreeClassifier()))\n", "models.append(('NB', GaussianNB()))\n", "models.append(('SVM', SVC()))\n", + "models.append(('ABC', AdaBoostClassifier()))\n", + "\n", "#print(models)\n", "\n", "# evaluate each model in turn\n", @@ -1429,20 +1446,20 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### From these results, it would suggest that both DecisionTreeClassifier, KNeighborsClassifier and GaussianNB are worthy of further study on this problem." + "#### From these results, it would suggest that both DecisionTreeClassifier, KNeighborsClassifier and GaussianNB are worthy of further study on this problem." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Data Preparation.\n", - "### This is important because this finds a way to best expose the structure of the problem to machine learning algorithim intended to be used. Since the data has attributes of varying scales, its important to use one of the methods for data preparation like rescaling, standardization, normalization or binarization for better prediction. Here, rescaling is used to have all the attribute on the same scale." + "#### **11. Data Preparation.**\n", + "#### This is important because this finds a way to best expose the structure of the problem to machine learning algorithim intended to be used. Since the data has attributes of varying scales, its important to use one of the methods for data preparation like rescaling, standardization, normalization or binarization for better prediction. Here, rescaling is used to have all the attribute on the same scale." ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -1477,13 +1494,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Standardization\n", - "### It is a useful technique to transform attributes with a Gaussian distribution and differing means and standard deviations to a standard Gaussian distribution with a mean of 0 and a standard deviation of 1" + "#### Standardization\n", + "#### It is a useful technique to transform attributes with a Gaussian distribution and differing means and standard deviations to a standard Gaussian distribution with a mean of 0 and a standard deviation of 1" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -1521,13 +1538,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Feature selection\n", - "### Statistical tests can be used to select those features that have the strongest relationship with the output variable. Feature selection is done on non transformed data using select k best using he univariate statistic F was used since it can work best with data containg negative values as opposed to chi2 that doesnt take in negative values." + "#### **12. Feature selection**\n", + "#### Statistical tests can be used to select those features that have the strongest relationship with the output variable. Feature selection is done on non transformed data using select k best using he univariate statistic F was used since it can work best with data containg negative values as opposed to chi2 that doesnt take in negative values." ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -1605,6 +1622,18 @@ " 234.274197\n", " 5.329249e-51\n", " \n", + " \n", + " 6\n", + " NT_EFC195\n", + " 221.390853\n", + " 2.189203e-48\n", + " \n", + " \n", + " 4\n", + " FULL_GEOR030101\n", + " 220.967065\n", + " 2.669597e-48\n", + " \n", " \n", "\n", "
" @@ -1618,10 +1647,12 @@ "0 FULL_Charge 1214.902838 3.404241e-224\n", "5 FULL_OOBM850104 785.124798 7.441087e-154\n", "8 AS_DAYM780201 717.317408 4.911002e-142\n", - "10 CT_RACS820104 234.274197 5.329249e-51" + "10 CT_RACS820104 234.274197 5.329249e-51\n", + "6 NT_EFC195 221.390853 2.189203e-48\n", + "4 FULL_GEOR030101 220.967065 2.669597e-48" ] }, - "execution_count": 22, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -1629,40 +1660,43 @@ "source": [ "from sklearn.feature_selection import SelectKBest, f_classif\n", "from numpy import set_printoptions\n", - "\n", + "# Separating A into output and input components\n", + "A = Train.values\n", + "X = A[:, 0:11]\n", + "Y = A[:, 11]\n", "#Feature Extraction\n", - "bestfeat = SelectKBest(score_func=f_classif, k=8)\n", - "fit = bestfeat.fit(X,Y)\n", + "bestfeat = SelectKBest(score_func=f_classif, k=10)\n", + "fit = bestfeat.fit(X,Y) #fitting f_classif test on predictors to get features that best predict\n", "\n", "set_printoptions(precision=3) # This sets the number of floating point output after rescaling the data\n", "selected_features = fit.transform(X)\n", - "\n", + "#Creating a dataframe to represent the order features selected starting from the best feature\n", "scores = pd.DataFrame(fit.scores_)\n", "pvalues = pd.DataFrame(fit.pvalues_)\n", "columns = pd.DataFrame(Train.columns[0:11])\n", "\n", - "selected_features = pd.concat([columns,scores, pvalues,], axis=1)\n", - "selected_features.columns = ['features', 'scores', 'pvalue']\n", - "selected_features.nlargest(8, \"scores\")" + "selected_features_dataframe = pd.concat([columns,scores, pvalues,], axis=1)\n", + "selected_features_dataframe.columns = ['features', 'scores', 'pvalue']\n", + "selected_features_dataframe.nlargest(10, \"scores\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### SelectKBest using the f statistic, gives scores to each attribute and takes the specified number of attributes with the highest scores. Attributes AS_MeanAmphiMoment, FULL_AcidicMolPerc, FULL_AURR980107, FULL_DAYM780201, FULL_Charge, FULL_OOBM850104, AS_DAYM780201 and CT_RACS820104 were the selected features." + "#### SelectKBest using the f statistic, gives scores to each attribute and takes the specified number of attributes with the highest scores. Attributes AS_MeanAmphiMoment, FULL_AcidicMolPerc, FULL_AURR980107, FULL_DAYM780201, FULL_Charge, FULL_OOBM850104, AS_DAYM780201 and CT_RACS820104 were the selected features." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Chi2 statistical test was used to since there were no negative values in the attributes after rescaling with the minmax scaler." + "#### Feature selection using SelectKBest, Chi2 statistical test since there are no negative values in the attributes after rescaling with the minmax scaler." ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -1740,23 +1774,37 @@ " 15.245249\n", " 9.441397e-05\n", " \n", + " \n", + " 10\n", + " CT_RACS820104\n", + " 15.146775\n", + " 9.946804e-05\n", + " \n", + " \n", + " 4\n", + " FULL_GEOR030101\n", + " 4.788691\n", + " 2.864719e-02\n", + " \n", " \n", "\n", "
" ], "text/plain": [ - " features scores pvalue\n", - "7 AS_MeanAmphiMoment 244.227728 4.708742e-55\n", - "6 NT_EFC195 188.197026 7.868482e-43\n", - "1 FULL_AcidicMolPerc 157.617513 3.751602e-36\n", - "2 FULL_AURR980107 54.231448 1.782118e-13\n", - "3 FULL_DAYM780201 37.311780 1.006747e-09\n", - "8 AS_DAYM780201 26.156224 3.148806e-07\n", - "5 FULL_OOBM850104 16.231433 5.605627e-05\n", - "0 FULL_Charge 15.245249 9.441397e-05" + " features scores pvalue\n", + "7 AS_MeanAmphiMoment 244.227728 4.708742e-55\n", + "6 NT_EFC195 188.197026 7.868482e-43\n", + "1 FULL_AcidicMolPerc 157.617513 3.751602e-36\n", + "2 FULL_AURR980107 54.231448 1.782118e-13\n", + "3 FULL_DAYM780201 37.311780 1.006747e-09\n", + "8 AS_DAYM780201 26.156224 3.148806e-07\n", + "5 FULL_OOBM850104 16.231433 5.605627e-05\n", + "0 FULL_Charge 15.245249 9.441397e-05\n", + "10 CT_RACS820104 15.146775 9.946804e-05\n", + "4 FULL_GEOR030101 4.788691 2.864719e-02" ] }, - "execution_count": 23, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -1766,328 +1814,186 @@ "from sklearn.feature_selection import chi2\n", "\n", "#Feature Extraction\n", - "test = SelectKBest(score_func=chi2, k=8)\n", - "fit = test.fit(rescaledX,Y)\n", + "test = SelectKBest(score_func=chi2, k=10)\n", + "fit = test.fit(rescaledX,Y) # fitting chi2 test on predictors to get features that best predict\n", "\n", "# Summary of scores \n", "set_printoptions(precision=3) # This sets the number of floating point output after rescaling the data\n", "#print(fit.scores_)\n", "selected_features1 = fit.transform(rescaledX)\n", - "\n", + "#Creating a dataframe to represent the order features selected starting from the best feature\n", "scores = pd.DataFrame(fit.scores_)\n", "pvalues = pd.DataFrame(fit.pvalues_)\n", "columns = pd.DataFrame(Train.columns[0:11])\n", "\n", - "selected_features1 = pd.concat([columns,scores, pvalues,], axis=1)\n", + "selected_features1 = pd.concat([columns,scores, pvalues], axis=1)\n", "selected_features1.columns = ['features', 'scores', 'pvalue']\n", - "selected_features1.nlargest(8, \"scores\")" + "selected_features1.nlargest(10, \"scores\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Feature selection using the recursive feature selection method with LG" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'rescaledX2' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mmodel\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mLogisticRegression\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mrfe\u001b[0m\u001b[0;34m=\u001b[0m \u001b[0mRFE\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mfit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrfe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrescaledX2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 6\u001b[0m \u001b[0mselectedfeaturesRFE\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrescaledX2\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfit\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msupport_\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mNameError\u001b[0m: name 'rescaledX2' is not defined" - ] - } - ], - "source": [ - "from sklearn.feature_selection import RFE\n", - "from sklearn.linear_model import LogisticRegression\n", - "model = LogisticRegression()\n", - "rfe= RFE(model,5)\n", - "fit = rfe.fit(rescaledX2, Y)\n", - "selectedfeaturesRFE = rescaledX2[:, fit.support_]\n", - "\n", - "print(\"Num_Feature:\", fit.n_features_)\n", - "print(\"Selected Features:\", fit.support_)\n", - "print(\"Feature Ranking:\", fit.ranking_)" + "#### From the dataframe above, AS_MeanAmphiMoment has the highest score of 244.227728 followed by NT_EFC195, then FULL_AcidicMolPerc and like that till the last attribute in dataframe, FULL_GEOR030101 that has lowwest score of 4.788691." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Evaluating Machine learning Alogorithms\n", - "## K-fold Cross Validation\n", - "### Cross validation is an approach that you can use to estimate the performance of a machine learning algorithm with less variance than a single train-test set split. It works by splitting the dataset into k-parts (e.g. k = 5 or k = 10). Each split of the data is called a fold. The algorithm is trained on k1 folds with one held back and tested on the held back fold. This is repeated so that each fold of the dataset is given a chance to be the held back test set. The choice of k must allow the size of each test partition to be large enough to be a reasonable sample of the problem, whilst allowing enough repetitions of the train-test evaluation of the algorithm to provide a fair estimate of the algorithms performance on unseen data. For modest sized datasets in the thousands or tens of thousands of records, k values of 3, 5 and 10 are common. In the example below we use 10-fold cross validation." - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'selected_features_train' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0mkfold\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mKFold\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn_splits\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnum_folds\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrandom_state\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0mmodel11\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mLogisticRegression\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mmodel11\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mselected_features_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0mresults\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcross_val_score\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel11\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mselected_features\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcv\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mkfold\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mNameError\u001b[0m: name 'selected_features_train' is not defined" - ] - } - ], - "source": [ - "from sklearn.model_selection import KFold\n", - "from sklearn.model_selection import cross_val_score\n", - "from sklearn.linear_model import LogisticRegression\n", - "\n", - "num_folds = 10\n", - "seed = 11\n", - "kfold = KFold(n_splits=num_folds, random_state=seed)\n", - "model11 = LogisticRegression()\n", - "model11.fit(selected_features_train, Y_train)\n", - "\n", - "results = cross_val_score(model11, selected_features, Y, cv=kfold)\n", - "Prediction = model11.predict(selected_features_train)\n", - "print(\"MCC:\", (matthews_corrcoef(Y_train, Prediction)))\n", - "print(\"Accuracy:\", (results.mean()*100.0))\n", - "#Assigning the preditions of the model to variable AssignmentOutPut\n", - "AssignmentOutPut11 = model11.predict(Test.values) \n", - "#Converting AssignmentOutPut to a dataframe since its output is an array\n", - "AssignmentOutPut11 = pd.DataFrame(AssignmentOutPut11)\n", - "\n", - "AssignmentOutPut11.columns = ['Class'] # Naming the output column\n", - "AssignmentOutPut11.index.name = \"Index\" #Creating a column called index\n", - "AssignmentOutPut11['Class'] = AssignmentOutPut11['Class'].map({0.0:False, 1.0:True}) # Converting 0.0 to false and 1.0 to true\n", - "\n", - "#Printing the number of False and Trues\n", - "print(AssignmentOutPut11.groupby('Class').size()[0].sum())\n", - "print(AssignmentOutPut11.groupby('Class').size()[1].sum())\n", - "\n", - "AssignmentOutPut11.to_csv('AssignmentOutPut1.csv') # Writing AssignmentOutPut1 to a csv file" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'selected_features_train' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0mkfold\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mKFold\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn_splits\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnum_folds\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrandom_state\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0mmodel22\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGaussianNB\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mmodel22\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mselected_features_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0mresults\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcross_val_score\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel22\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mselected_features\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcv\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mkfold\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mNameError\u001b[0m: name 'selected_features_train' is not defined" - ] - } - ], - "source": [ - "from sklearn.model_selection import KFold\n", - "from sklearn.model_selection import cross_val_score\n", - "from sklearn.naive_bayes import GaussianNB\n", - "\n", - "num_folds = 10\n", - "seed = 22\n", - "kfold = KFold(n_splits=num_folds, random_state=seed)\n", - "model22 = GaussianNB()\n", - "model22.fit(selected_features_train, Y_train)\n", - "\n", - "results = cross_val_score(model22, selected_features, Y, cv=kfold)\n", - "Prediction = model22.predict(selected_features_train)\n", - "print(\"MCC:\", (matthews_corrcoef(Y_train, Prediction)))\n", - "print(\"Accuracy:\", (results.mean()*100.0))\n", - "\n", - "#Assigning the preditions of the model to variable AssignmentOutPut\n", - "AssignmentOutPut22 = model22.predict(Test.values) \n", - "#Converting AssignmentOutPut to a dataframe since its output is an array\n", - "AssignmentOutPut22 = pd.DataFrame(AssignmentOutPut22)\n", - "\n", - "AssignmentOutPut22.columns = ['Class'] # Naming the output column\n", - "AssignmentOutPut22.index.name = \"Index\" #Creating a column called index\n", - "AssignmentOutPut22['Class'] = AssignmentOutPut22['Class'].map({0.0:False, 1.0:True}) # Converting 0.0 to false and 1.0 to true\n", - "\n", - "#Printing the number of False and Trues\n", - "print(AssignmentOutPut22.groupby('Class').size()[0].sum())\n", - "print(AssignmentOutPut22.groupby('Class').size()[1].sum())\n", - "\n", - "AssignmentOutPut22.to_csv('AssignmentOutPut22.csv') # Writing AssignmentOutPut1 to a csv file" + "#### Feature selection using the recursive feature selection method with LogisticRegression - it works by recursively removing attributes and building a model on those attributes that remain. It uses the model accuracy to identify which attributes (and combination of attributes) contribute the most to predicting the target attribute" ] }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 23, "metadata": {}, "outputs": [ { - "ename": "NameError", - "evalue": "name 'selected_features_train' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0mkfold\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mKFold\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn_splits\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnum_folds\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrandom_state\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0mmodel33\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mKNeighborsClassifier\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mmodel33\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mselected_features_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0mresults\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcross_val_score\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel33\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mselected_features\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcv\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mkfold\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mNameError\u001b[0m: name 'selected_features_train' is not defined" - ] - } - ], - "source": [ - "from sklearn.model_selection import KFold\n", - "from sklearn.model_selection import cross_val_score\n", - "from sklearn.neighbors import KNeighborsClassifier\n", - "\n", - "num_folds = 10\n", - "seed = 33\n", - "kfold = KFold(n_splits=num_folds, random_state=seed)\n", - "model33 = KNeighborsClassifier()\n", - "model33.fit(selected_features_train, Y_train)\n", - "\n", - "results = cross_val_score(model33, selected_features, Y, cv=kfold)\n", - "print(\"MCC:\", (matthews_corrcoef(Y_train, Prediction)))\n", - "print(\"Accuracy:\", (results.mean()*100.0))\n", - "\n", - "#Assigning the preditions of the model to variable AssignmentOutPut\n", - "AssignmentOutPut33 = model33.predict(Test.values) \n", - "#Converting AssignmentOutPut to a dataframe since its output is an array\n", - "AssignmentOutPut33 = pd.DataFrame(AssignmentOutPut33)\n", - "\n", - "AssignmentOutPut33.columns = ['Class'] # Naming the output column\n", - "AssignmentOutPut33.index.name = \"Index\" #Creating a column called index\n", - "AssignmentOutPut33['Class'] = AssignmentOutPut33['Class'].map({0.0:False, 1.0:True}) # Converting 0.0 to false and 1.0 to true\n", - "\n", - "#Printing the number of False and Trues\n", - "print(AssignmentOutPut33.groupby('Class').size()[0].sum())\n", - "print(AssignmentOutPut33.groupby('Class').size()[1].sum())\n", - "\n", - "AssignmentOutPut33.to_csv('AssignmentOutPut33.csv') # Writing AssignmentOutPut1 to a csv file" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'selected_features_train' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0mkfold\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mKFold\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn_splits\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnum_folds\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrandom_state\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0mmodel44\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mDecisionTreeClassifier\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mmodel44\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mselected_features_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0mresults\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcross_val_score\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel44\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mselected_features\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcv\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mkfold\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mNameError\u001b[0m: name 'selected_features_train' is not defined" - ] + "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", + "
Selected_FeaturesRFEFeature_Ranking
2FULL_AURR9801072
0FULL_Charge1
1FULL_AcidicMolPerc1
3FULL_DAYM7802011
4FULL_GEOR0301011
5FULL_OOBM8501041
6NT_EFC1951
7AS_MeanAmphiMoment1
8AS_DAYM7802011
9AS_FUKS0101121
\n", + "
" + ], + "text/plain": [ + " Selected_FeaturesRFE Feature_Ranking\n", + "2 FULL_AURR980107 2\n", + "0 FULL_Charge 1\n", + "1 FULL_AcidicMolPerc 1\n", + "3 FULL_DAYM780201 1\n", + "4 FULL_GEOR030101 1\n", + "5 FULL_OOBM850104 1\n", + "6 NT_EFC195 1\n", + "7 AS_MeanAmphiMoment 1\n", + "8 AS_DAYM780201 1\n", + "9 AS_FUKS010112 1" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "from sklearn.model_selection import KFold\n", - "from sklearn.model_selection import cross_val_score\n", - "from sklearn.tree import DecisionTreeClassifier\n", - "\n", - "num_folds = 10\n", - "seed = 44\n", - "kfold = KFold(n_splits=num_folds, random_state=seed)\n", - "model44 = DecisionTreeClassifier()\n", - "model44.fit(selected_features_train, Y_train)\n", - "\n", - "results = cross_val_score(model44, selected_features, Y, cv=kfold)\n", - "print(\"MCC:\", (matthews_corrcoef(Y_train, Prediction)))\n", - "print(\"Accuracy:\", (results.mean()*100.0))\n", - "\n", - "#Assigning the preditions of the model to variable AssignmentOutPut\n", - "AssignmentOutPut44 = model44.predict(Test.values) \n", - "#Converting AssignmentOutPut to a dataframe since its output is an array\n", - "AssignmentOutPut44 = pd.DataFrame(AssignmentOutPut44)\n", - "\n", - "AssignmentOutPut44.columns = ['Class'] # Naming the output column\n", - "AssignmentOutPut44.index.name = \"Index\" #Creating a column called index\n", - "AssignmentOutPut44['Class'] = AssignmentOutPut44['Class'].map({0.0:False, 1.0:True}) # Converting 0.0 to false and 1.0 to true\n", - "\n", - "#Printing the number of False and Trues\n", - "print(AssignmentOutPut44.groupby('Class').size()[0].sum())\n", - "print(AssignmentOutPut44.groupby('Class').size()[1].sum())\n", + "from sklearn.feature_selection import RFE\n", + "from sklearn.linear_model import LogisticRegression\n", + "model = LogisticRegression()\n", + "rfe= RFE(model,10)\n", + "fit = rfe.fit(standardizedX, Y) # fitting logistic regression on predictors to get features that best predict\n", + "selectedfeaturesRFE = standardizedX[:, fit.support_]\n", + "\n", + "#Creating a dataframe to represent the order features selected starting from the best feature\n", + "#Num_Features = pd.DataFrame(fit.n_features_)\n", + "Selected_FeaturesRFE = pd.DataFrame(fit.support_)\n", + "Feature_Ranking = pd.DataFrame(fit.ranking_)\n", + "columns = pd.DataFrame(Train.columns[0:11])\n", "\n", - "AssignmentOutPut44.to_csv('AssignmentOutPut44.csv') # Writing AssignmentOutPut1 to a csv file" + "selected_features2 = pd.concat([columns, Feature_Ranking], axis=1)\n", + "selected_features2.columns = ['Selected_FeaturesRFE', 'Feature_Ranking']\n", + "selected_features2.nlargest(10, \"Feature_Ranking\")" ] }, { - "cell_type": "code", - "execution_count": 29, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'selected_features_train' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0mkfold\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mKFold\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn_splits\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnum_folds\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrandom_state\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0mmodel55\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mSVC\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mmodel55\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mselected_features_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0mresults\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcross_val_score\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel55\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mselected_features\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcv\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mkfold\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mNameError\u001b[0m: name 'selected_features_train' is not defined" - ] - } - ], "source": [ - "from sklearn.model_selection import KFold\n", - "from sklearn.model_selection import cross_val_score\n", - "from sklearn.svm import SVC\n", - "\n", - "num_folds = 55\n", - "seed = 6\n", - "kfold = KFold(n_splits=num_folds, random_state=seed)\n", - "model55 = SVC()\n", - "model55.fit(selected_features_train, Y_train)\n", - "\n", - "results = cross_val_score(model55, selected_features, Y, cv=kfold)\n", - "print(\"MCC:\", (matthews_corrcoef(Y_train, Prediction)))\n", - "print(\"Accuracy:\", (results.mean()*100.0))\n", - "\n", - "#Assigning the preditions of the model to variable AssignmentOutPut\n", - "AssignmentOutPut55 = model55.predict(Test.values) \n", - "#Converting AssignmentOutPut to a dataframe since its output is an array\n", - "AssignmentOutPut55 = pd.DataFrame(AssignmentOutPut55)\n", - "\n", - "AssignmentOutPut55.columns = ['Class'] # Naming the output column\n", - "AssignmentOutPut55.index.name = \"Index\" #Creating a column called index\n", - "AssignmentOutPut55['Class'] = AssignmentOutPut55['Class'].map({0.0:False, 1.0:True}) # Converting 0.0 to false and 1.0 to true\n", - "\n", - "#Printing the number of False and Trues\n", - "print(AssignmentOutPut55.groupby('Class').size()[0].sum())\n", - "print(AssignmentOutPut55.groupby('Class').size()[1].sum())\n", - "\n", - "AssignmentOutPut55.to_csv('AssignmentOutPut55.csv') # Writing AssignmentOutPut1 to a csv file" + "#### From the dataframe above, FULL_AURR980107 has the highest rank of 2 followed by FULL_Charge, then FULL_AcidicMolPerc and like that till the last attribute in dataframe, AS_FUKS010112." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Evaluating Machine learning Alogorithms\n", - "## Split into Train and Test set" + "#### **13. Evaluating Machine learning Alogorithms** - the best way to evaluate the performance of an algorithm would be to make predictions for new data to which you already know the answers. Evaluation shoud be done on data that is not used to train the algorithm. The evaluation is an estimate that we can use to talk about how well we think the algorithm may actually do in practice.\n", + "#### **Split into Train and Test set**\n", + "#### It's the simplest method that we can use to evaluate the performance of a machine learning algorithm is to use dierent training and testing datasets. The train dataset is split it into two parts. The algorithm is trained on one part and predictions are made on the second part and evaluate the predictions against the expected results. The size of the split can depend on the size of your dataset, although it is common to use 67% of the data for training and the remaining 33% for testing. This algorithm evaluation technique is very fast. It is ideal for large datasets (millions of records) where there is strong evidence that both splits of the data are representative of the underlying problem. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Non rescaled data" + "#### **LogisticRegression** - Logistic regression is basically a supervised classification algorithm. Supervised learning is when a model learns from data that is already labeled. A supervised learning model takes in a set of input objects and output values. The model then trains on that data to learn how to map the inputs to the desired output so it can learn to make predictions on unseen data. In a classification problem, the target variable(or output), y, can take only discrete values for given set of features(or inputs), X. Logistic regression is a classification algorithm used to assign observations to a discrete set of classes. It is based on the concept of probability." ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -2121,9 +2027,8 @@ "print(\"MCC:\", (matthews_corrcoef(Y_train, Prediction)))\n", "print(\"Accuracy:\", (result*100.0))\n", "\n", - "#Assigning the preditions of the model to variable AssignmentOutPut\n", - "AssignmentOutPut1 = my_model1.predict(Test.values) \n", - "#Converting AssignmentOutPut to a dataframe since its output is an array\n", + "#Assigning the preditions of the model to variable AssignmentOutPut1\n", + "AssignmentOutPut1 = my_model1.predict(Test.values) #Converting AssignmentOutPut1 to a dataframe since its output is an array\n", "AssignmentOutPut1 = pd.DataFrame(AssignmentOutPut1)\n", "\n", "AssignmentOutPut1.columns = ['Class'] # Naming the output column\n", @@ -2137,9 +2042,16 @@ "AssignmentOutPut1.to_csv('AssignmentOutPut1.csv') # Writing AssignmentOutPut1 to a csv file" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### **KNeighborsClassifier** - k-Nearest-Neighbors (k-NN) is a supervised machine learning model. KNN models work by taking a data point and looking at the ‘k’ closest labeled data points. The data point is then assigned the label of the majority of the ‘k’ closest points. For example, if k = 5, and 3 of points are ‘green’ and 2 are ‘red’, then the data point in question would be labeled ‘green’, since ‘green’ is the majority " + ] + }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -2173,12 +2085,11 @@ "print(\"MCC:\", (matthews_corrcoef(Y_train, Prediction)))\n", "print(\"Accuracy:\", (result*100.0))\n", "\n", - "#Assigning the preditions of the model to variable AssignmentOutPut\n", + "#Assigning the preditions of the model to variable AssignmentOutPut2\n", "AssignmentOutPut2 = my_model2.predict(Test.values) \n", "#Converting AssignmentOutPut to a dataframe since its output is an array\n", - "AssignmentOutPut2 = pd.DataFrame(AssignmentOutPut2)\n", - "# Converting AssignmentOutPut to a dataframe since its output is an array\n", - "AssignmentOutPut2.columns = ['Class'] # Naming the out\n", + "AssignmentOutPut2 = pd.DataFrame(AssignmentOutPut2)# Converting AssignmentOutPut2 to a dataframe since its output is an array\n", + "AssignmentOutPut2.columns = ['Class'] # Naming the out put column\n", "AssignmentOutPut2.index.name = \"Index\" #Creating a column called index\n", "AssignmentOutPut2['Class'] = AssignmentOutPut2['Class'].map({0.0:False, 1.0:True}) # Converting 0.0 to false and 1.0 to true\n", "\n", @@ -2186,12 +2097,19 @@ "print(AssignmentOutPut2.groupby('Class').size()[0].sum())\n", "print(AssignmentOutPut2.groupby('Class').size()[1].sum())\n", "\n", - "AssignmentOutPut2.to_csv('AssignmentOutPut2.csv') # Writing AssignmentOutPut1 to a csv file" + "AssignmentOutPut2.to_csv('AssignmentOutPut2.csv') # Writing AssignmentOutPut2 to a csv file" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### **DecisionTreeClassifier** - its also a supervised learning algorithm that identifies ways to split a data set based on different conditions." ] }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -2199,9 +2117,9 @@ "output_type": "stream", "text": [ "MCC: 1.0\n", - "Accuracy: 90.72781655034895\n", - "387\n", - "371\n" + "Accuracy: 89.63110667996011\n", + "388\n", + "370\n" ] } ], @@ -2226,9 +2144,8 @@ "print(\"Accuracy:\", (result*100.0))\n", "AssignmentOutPut3 = my_model3.predict(Test.values) #Assigning the preditions of the model to variable AssignmentOutPut\n", "\n", - "AssignmentOutPut3 = pd.DataFrame(AssignmentOutPut3)\n", - "# Converting AssignmentOutPut to a dataframe since its output is an array\n", - "AssignmentOutPut3.columns = ['Class'] # Naming the out\n", + "AssignmentOutPut3 = pd.DataFrame(AssignmentOutPut3)# Converting AssignmentOutPut3 to a dataframe since its output is an array\n", + "AssignmentOutPut3.columns = ['Class'] # Naming the out put column\n", "AssignmentOutPut3.index.name = \"Index\" #Creating a column called index\n", "AssignmentOutPut3['Class'] = AssignmentOutPut3['Class'].map({0.0:False, 1.0:True}) # Converting 0.0 to false and 1.0 to true\n", "\n", @@ -2236,12 +2153,19 @@ "print(AssignmentOutPut3.groupby('Class').size()[0].sum())\n", "print(AssignmentOutPut3.groupby('Class').size()[1].sum())\n", "\n", - "AssignmentOutPut1.to_csv('AssignmentOutPut3.csv') # Writing AssignmentOutPut1 to a csv file\n" + "AssignmentOutPut1.to_csv('AssignmentOutPut3.csv') # Writing AssignmentOutPut3 to a csv file\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### **GaussianNB** - its a classification algorithm for binary (two-class) and multi-class classification problems. Naive Bayes calculates the probability of each class and the conditional probability of each class given each input value. These probabilities are estimated for new data and multiplied together, assuming that they are all independent" ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -2275,33 +2199,39 @@ "print(\"MCC:\", (matthews_corrcoef(Y_train, Prediction)))\n", "print(\"Accuracy:\", (result*100.0))\n", "\n", - "AssignmentOutPut4 = my_model4.predict(Test.values) #Assigning the preditions of the model to variable AssignmentOutPut\n", + "AssignmentOutPut4 = my_model4.predict(Test.values) #Assigning the preditions of the model to variable AssignmentOutPut4\n", "\n", - "AssignmentOutPut4 = pd.DataFrame(AssignmentOutPut4)\n", - "# Converting AssignmentOutPut to a dataframe since its output is an array\n", - "AssignmentOutPut4.columns = ['Class'] # Naming the out\n", + "AssignmentOutPut4 = pd.DataFrame(AssignmentOutPut4)# Converting AssignmentOutPut4 to a dataframe since its output is an array\n", + "AssignmentOutPut4.columns = ['Class'] # Naming the out put column\n", "AssignmentOutPut4.index.name = \"Index\" #Creating a column called index\n", "AssignmentOutPut4['Class'] = AssignmentOutPut4['Class'].map({0.0:False, 1.0:True}) # Converting 0.0 to false and 1.0 to true\n", "\n", - "AssignmentOutPut4.to_csv('AssignmentOutPut4.csv') # Writing AssignmentOutPut1 to a csv file\n", + "AssignmentOutPut4.to_csv('AssignmentOutPut4.csv') # Writing AssignmentOutPut4 to a csv file\n", "#Printing the number of False and Trues\n", "print(AssignmentOutPut4.groupby('Class').size()[0].sum())\n", "print(AssignmentOutPut4.groupby('Class').size()[1].sum())" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### **Support Vector Machines** - its also a supervised machine learning algorithm capable of performing classification, regression and outlier detection. They draw a line that best separates two classes. Data instances closest to the line that best separates the classes are called support vectors. " + ] + }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "MCC: 0.8164151115601915\n", - "Accuracy: 91.12662013958126\n", - "405\n", - "353\n" + "MCC: 0.8399582732206575\n", + "Accuracy: 92.82153539381855\n", + "379\n", + "379\n" ] } ], @@ -2317,30 +2247,36 @@ "test_size = 0.33\n", "seed = 5\n", "selected_features_train, selected_features_test, Y_train, Y_test = train_test_split(X, Y, test_size = test_size, random_state = seed)\n", - "my_model5 = SVC()\n", + "my_model5 = SVC(kernel = 'linear')\n", "my_model5.fit(selected_features_train, Y_train)\n", "result = my_model5.score(selected_features_test, Y_test)\n", "\n", "Prediction = my_model5.predict(selected_features_train)\n", "print(\"MCC:\", (matthews_corrcoef(Y_train, Prediction)))\n", "print(\"Accuracy:\", (result*100.0))\n", - "AssignmentOutPut5 = my_model5.predict(Test.values) #Assigning the preditions of the model to variable AssignmentOutPut\n", + "AssignmentOutPut5 = my_model5.predict(Test.values) #Assigning the preditions of the model to variable AssignmentOutPut5\n", "\n", - "AssignmentOutPut5 = pd.DataFrame(AssignmentOutPut5)\n", - "# Converting AssignmentOutPut to a dataframe since its output is an array\n", - "AssignmentOutPut5.columns = ['Class'] # Naming the out\n", + "AssignmentOutPut5 = pd.DataFrame(AssignmentOutPut5)# Converting AssignmentOutPut5 to a dataframe since its output is an array\n", + "AssignmentOutPut5.columns = ['Class'] # Naming the out put column\n", "AssignmentOutPut5.index.name = \"Index\" #Creating a column called index\n", "AssignmentOutPut5['Class'] = AssignmentOutPut5['Class'].map({0.0:False, 1.0:True}) # Converting 0.0 to false and 1.0 to true\n", "\n", - "AssignmentOutPut1.to_csv('AssignmentOutPut5.csv') # Writing AssignmentOutPut1 to a csv file\n", + "AssignmentOutPut1.to_csv('AssignmentOutPut5.csv') # Writing AssignmentOutPut5 to a csv file\n", "#Printing the number of False and Trues\n", "print(AssignmentOutPut5.groupby('Class').size()[0].sum())\n", "print(AssignmentOutPut5.groupby('Class').size()[1].sum())" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### **LinearDiscriminantAnalysis** - it is a dimensionality reduction technique used for the supervised classification problems. It too assumes a Gaussian distribution for the numerical input variables.It is used to project the features in higher dimension space into a lower dimension space." + ] + }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 29, "metadata": {}, "outputs": [ { @@ -2373,19 +2309,201 @@ "Prediction = my_model6.predict(selected_features_train)\n", "print(\"MCC:\", (matthews_corrcoef(Y_train, Prediction)))\n", "print(\"Accuracy:\", (result*100.0))\n", - "AssignmentOutPut6 = my_model6.predict(Test.values) #Assigning the preditions of the model to variable AssignmentOutPut\n", "\n", - "AssignmentOutPut6 = pd.DataFrame(AssignmentOutPut6)\n", - "# Converting AssignmentOutPut to a dataframe since its output is an array\n", - "AssignmentOutPut6.columns = ['Class'] # Naming the out\n", + "AssignmentOutPut6 = my_model6.predict(Test.values) #Assigning the preditions of the model to variable AssignmentOutPut\n", + "AssignmentOutPut6 = pd.DataFrame(AssignmentOutPut6)# Converting AssignmentOutPut6 to a dataframe since its output is an array\n", + "AssignmentOutPut6.columns = ['Class'] # Naming the out put column\n", "AssignmentOutPut6.index.name = \"Index\" #Creating a column called index\n", "AssignmentOutPut6['Class'] = AssignmentOutPut6['Class'].map({0.0:False, 1.0:True}) # Converting 0.0 to false and 1.0 to true\n", "\n", - "AssignmentOutPut6.to_csv('AssignmentOutPut6.csv') # Writing AssignmentOutPut1 to a csv file\n", + "AssignmentOutPut6.to_csv('AssignmentOutPut6.csv') # Writing AssignmentOutPut6 to a csv file\n", "#Printing the number of False and Trues\n", "print(AssignmentOutPut6.groupby('Class').size()[0].sum())\n", "print(AssignmentOutPut6.groupby('Class').size()[1].sum())" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### **Ada Boost** - it trains predictors sequentially, each trying to correct its predecessor. It works by weighting instances in the dataset by how easy or difficult they are to classify, allowing the algorithm to pay or less attention to them in the construction of subsequent models" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MCC: 0.8546905980754327\n", + "Confusion_matrix: [[475 30]\n", + " [ 43 455]]\n", + "385\n", + "373\n" + ] + } + ], + "source": [ + "from sklearn.ensemble import AdaBoostClassifier\n", + "from sklearn.tree import DecisionTreeClassifier\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import matthews_corrcoef\n", + "from sklearn.metrics import confusion_matrix\n", + "\n", + "A = Train.values\n", + "# Separating A into output and input components\n", + "\n", + "test_size = 0.33\n", + "seed = 6\n", + "# Split data into training and test sets to evaluate the model’s performance.\n", + "selected_features_train, selected_features_test, Y_train, Y_test = train_test_split(X, Y, test_size = test_size, random_state = seed)\n", + "# Construct and fit a model to the training set. max_depth=1 is used to tell the model that the forest to be composed of trees with a\n", + "# single decision node and two leaves. n_estimators is used to specify the total number of trees in the forest.\n", + "Model7 = AdaBoostClassifier(DecisionTreeClassifier(max_depth=1),n_estimators=200) \n", + "Model7.fit(selected_features_train, Y_train)\n", + "predictions = Model7.predict(selected_features_test)\n", + "print(\"MCC:\", (matthews_corrcoef(Y_test, predictions)))\n", + "print(\"Confusion_matrix:\", confusion_matrix(Y_test, predictions))\n", + "\n", + "AssignmentOutPut7 = Model7.predict(Test.values) #Assigning the preditions of the model to variable AssignmentOutPut7\n", + "AssignmentOutPut7 = pd.DataFrame(AssignmentOutPut7)# Converting AssignmentOutPut7 to a dataframe since its output is an array\n", + "AssignmentOutPut7.columns = ['Class'] # Naming the out put column\n", + "AssignmentOutPut7.index.name = \"Index\" #Creating a column called index\n", + "AssignmentOutPut7['Class'] = AssignmentOutPut7['Class'].map({0.0:False, 1.0:True}) # Converting 0.0 to false and 1.0 to true\n", + "\n", + "AssignmentOutPut7.to_csv('AssignmentOutPut7.csv') # Writing AssignmentOutPut7 to a csv file\n", + "#Printing the number of False and Trues\n", + "print(AssignmentOutPut7.groupby('Class').size()[0].sum())\n", + "print(AssignmentOutPut7.groupby('Class').size()[1].sum())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### **Principle component analysis** - PCA is a common way of speeding up a machine learning algorithm. Its mostly used when a machine learning algorithm is too slow because the input dimension is too high, then PCA is used to speed it up can be a reasonable choice. PCA can also be used for data visualization." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Using PCA for visualization of data.\n", + "from sklearn.decomposition import PCA\n", + "#A = Train.values\n", + "# Separating A into output and input components\n", + "features = ['FULL_Charge', 'FULL_AcidicMolPerc', 'FULL_AURR980107', 'FULL_DAYM780201', 'FULL_GEOR030101', 'FULL_OOBM850104', 'NT_EFC195', 'AS_MeanAmphiMoment', 'AS_DAYM780201', 'AS_FUKS010112', 'CT_RACS820104']\n", + "x =Train.loc[:, features].values\n", + "y =Train.loc[:,['CLASS']].values\n", + "pca = PCA(n_components=2)\n", + "principalComponents = pca.fit_transform(x)\n", + "principalDf = pd.DataFrame(principalComponents, columns = ['principal_component1', 'principal_component2'])\n", + "FinalDf = pd.concat([principalDf, Train[['CLASS']]], axis = 1)\n", + "FinalDf\n", + "\n", + "#The plot\n", + "fig = plt.figure(figsize = (8,8))\n", + "ax = fig.add_subplot(1,1,1) \n", + "ax.set_xlabel('Principal_Component1', fontsize = 10)\n", + "ax.set_ylabel('Principal_Component2', fontsize = 10)\n", + "ax.set_title('2 component PCA', fontsize = 15)\n", + "plt.scatter(FinalDf.iloc[:, 0], FinalDf.iloc[:, 1], c = FinalDf.iloc[:, 2], cmap ='Spectral') \n", + "#classes = [\"1.0\", \"0.0\"]\n", + "#colors = ['r','g', 'b']\n", + "#for CLASS, color in (classes,colors):\n", + "# indicesToKeep = FinalDf['CLASS'] == CLASS\n", + "# ax.scatter(FinalDf.loc[indicesToKeep, 'principal_component1'], FinalDf.loc[indicesToKeep, 'principal_component2'], c =color )\n", + "ax.legend()\n", + "ax.grid()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### **Using principle component analysis for machine learning**" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MCC: 0.7507336393432698\n", + "Socre: 0.8753738783649053\n", + "506\n", + "497\n" + ] + } + ], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "from sklearn.decomposition import PCA\n", + "A= Train.values\n", + "X = A[:, 0:11]\n", + "Y = A[:, 11]\n", + "#Make an instance of the Model\n", + "pca = PCA(.95)\n", + "#Splitting data\n", + "selected_features_train, selected_features_test, Y_train, Y_test = train_test_split(X, Y, test_size = test_size, random_state = seed)\n", + "pca = PCA(n_components=2)\n", + "principalComponents = pca.fit_transform(selected_features_train)\n", + "fit_train = pca.fit(selected_features_train) #Fit PCA on training set\n", + "\n", + "#Apply the mapping (transform) to both the training set and the test set.\n", + "selected_features_trainF = pca.transform(selected_features_train)\n", + "selected_features_testF = pca.transform(selected_features_test)\n", + "\n", + "#Importing the model\n", + "from sklearn.linear_model import LogisticRegression\n", + "Model8 = LogisticRegression()\n", + "Model8.fit(selected_features_trainF, Y_train)\n", + "\n", + "#Predicting new data\n", + "Pred = Model8.predict(selected_features_testF)\n", + "print(\"MCC:\", (matthews_corrcoef(Y_test, Pred)))\n", + "print(\"Socre:\", Model8.score(selected_features_testF, Y_test))\n", + "\n", + "AssignmentOutPut8 = Model8.predict(selected_features_testF) #Assigning the preditions of the model to variable AssignmentOutPut8\n", + "AssignmentOutPut8 = pd.DataFrame(AssignmentOutPut8)# Converting AssignmentOutPut8 to a dataframe since its output is an array\n", + "AssignmentOutPut8.columns = ['Class'] # Naming the out put column\n", + "AssignmentOutPut8.index.name = \"Index\" #Creating a column called index\n", + "AssignmentOutPut8['Class'] = AssignmentOutPut8['Class'].map({0.0:False, 1.0:True}) # Converting 0.0 to false and 1.0 to true\n", + "\n", + "AssignmentOutPut8.to_csv('AssignmentOutPut8.csv') # Writing AssignmentOutPut8 to a csv file\n", + "#Printing the number of False and Trues\n", + "print(AssignmentOutPut8.groupby('Class').size()[0].sum())\n", + "print(AssignmentOutPut8.groupby('Class').size()[1].sum())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### The Naive bayes(GaussianNB) algorithm with none rescaled or transformed data gave the best prediction from all the algorithms used." + ] } ], "metadata": { diff --git a/Assignment Colab/nsangi-olga-tendo(1).ipynb b/Assignment Colab/nsangi-olga-tendo(1).ipynb deleted file mode 100644 index d89b5b1..0000000 --- a/Assignment Colab/nsangi-olga-tendo(1).ipynb +++ /dev/null @@ -1,2491 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# **ACE Class competition**\n", - "#### By Nsangi Olga Tendo\n", - "## Machine Learning Process:\n", - "#### 1. Have a peek of raw data\n", - "#### 2. Review of dimensions of thedataset.\n", - "#### 3. Review of attribues in the data set\n", - "#### 4. Review the data types of attributes in your data.\n", - "#### 5. Review of missing data(NAs)\n", - "#### 6. Summary of data using descriptive statistics.\n", - "#### 7. Understand the relationships in your data using correlations.\n", - "#### 8. Data Visualisation\n", - "#### 9. Review the skew of the distributions of each attribute.\n", - "#### 10.Spot checking classification algorithms\n", - "#### 11.Data preparation\n", - "#### 12.Feature selection\n", - "#### 13. Machine learning" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19", - "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/kaggle/input/ace-class-assignment/AMP_TrainSet.csv\n", - "/kaggle/input/ace-class-assignment/Test.csv\n" - ] - } - ], - "source": [ - "# This Python 3 environment comes with many helpful analytics libraries installed\n", - "# It is defined by the kaggle/python docker image: https://github.com/kaggle/docker-python\n", - "# For example, here's several helpful packages to load in \n", - "\n", - "#Importing the necessary libraries that are going to be used in the pipeline\n", - "import numpy as np # linear algebra\n", - "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sns\n", - "\n", - "\n", - "# Input data files are available in the \"../input/\" directory.\n", - "# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the 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", - "# Any results you write to the current directory are saved as output.\n", - "import warnings\n", - "warnings.filterwarnings('ignore')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 1. Naming the Training and test dataset using." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "_cell_guid": "79c7e3d0-c299-4dcb-8224-4455121ee9b0", - "_uuid": "d629ff2d2480ee46fbb7e2d37f6b5fab8052498a" - }, - "outputs": [], - "source": [ - "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": [ - "#### Confirming that the data has been read in and assigned to variables Train and Test" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \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
05.00.0000.95174.8420.975-3.66300.28273.4445.6611.0411
14.05.4050.93171.5950.957-4.01110.60068.2226.5371.4531
25.55.4050.87373.5950.961-2.51200.59369.4444.9341.7221
35.04.1670.89566.2500.999-1.36200.61467.2224.3161.3821
47.58.5370.93264.7200.979-2.09100.61672.9444.5401.5391
55.07.6921.03078.9490.976-3.09110.51178.7785.9921.0911
63.06.8970.93078.5860.957-3.54410.38578.2226.2841.4671
72.05.8820.86876.5880.949-5.83200.15476.5886.4791.0861
87.02.6320.85760.4471.012-0.29200.18864.3333.8491.9251
99.00.0000.91165.8081.049-3.88800.36163.2226.3271.2161
\n", - "
" - ], - "text/plain": [ - " FULL_Charge FULL_AcidicMolPerc FULL_AURR980107 FULL_DAYM780201 \\\n", - "0 5.0 0.000 0.951 74.842 \n", - "1 4.0 5.405 0.931 71.595 \n", - "2 5.5 5.405 0.873 73.595 \n", - "3 5.0 4.167 0.895 66.250 \n", - "4 7.5 8.537 0.932 64.720 \n", - "5 5.0 7.692 1.030 78.949 \n", - "6 3.0 6.897 0.930 78.586 \n", - "7 2.0 5.882 0.868 76.588 \n", - "8 7.0 2.632 0.857 60.447 \n", - "9 9.0 0.000 0.911 65.808 \n", - "\n", - " FULL_GEOR030101 FULL_OOBM850104 NT_EFC195 AS_MeanAmphiMoment \\\n", - "0 0.975 -3.663 0 0.282 \n", - "1 0.957 -4.011 1 0.600 \n", - "2 0.961 -2.512 0 0.593 \n", - "3 0.999 -1.362 0 0.614 \n", - "4 0.979 -2.091 0 0.616 \n", - "5 0.976 -3.091 1 0.511 \n", - "6 0.957 -3.544 1 0.385 \n", - "7 0.949 -5.832 0 0.154 \n", - "8 1.012 -0.292 0 0.188 \n", - "9 1.049 -3.888 0 0.361 \n", - "\n", - " AS_DAYM780201 AS_FUKS010112 CT_RACS820104 CLASS \n", - "0 73.444 5.661 1.041 1 \n", - "1 68.222 6.537 1.453 1 \n", - "2 69.444 4.934 1.722 1 \n", - "3 67.222 4.316 1.382 1 \n", - "4 72.944 4.540 1.539 1 \n", - "5 78.778 5.992 1.091 1 \n", - "6 78.222 6.284 1.467 1 \n", - "7 76.588 6.479 1.086 1 \n", - "8 64.333 3.849 1.925 1 \n", - "9 63.222 6.327 1.216 1 " - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Train.head(10)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 2. Dimensions of the train and test data set\n", - "#### This helps in knowing the size of your data set and also give an intiution on what algorithms you could use incase the size is big or small." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "((3038, 12), (758, 11))" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Train.shape, Test.shape" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 3. Establishing the attributes in the train and test data set" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "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'),\n", - " 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": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Train.columns, Test.columns" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 4. Establishing the data types for each attribute in the train data set. This helps in finding out which columns have data types like strings that may need to be converted to foating points or integers to represent categorical or ordinal values since most machine learning algorithms take in integers or floats for inputs. This can be done using df.dtype method or the df.info() method as shown in the two cells below, tho the df.info() is more informative as its also tells the total number of instances for each column." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "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,\n", - " 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": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Train.dtypes, Test.dtypes" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "RangeIndex: 3038 entries, 0 to 3037\n", - "Data columns (total 12 columns):\n", - "FULL_Charge 3038 non-null float64\n", - "FULL_AcidicMolPerc 3038 non-null float64\n", - "FULL_AURR980107 3038 non-null float64\n", - "FULL_DAYM780201 3038 non-null float64\n", - "FULL_GEOR030101 3038 non-null float64\n", - "FULL_OOBM850104 3038 non-null float64\n", - "NT_EFC195 3038 non-null int64\n", - "AS_MeanAmphiMoment 3038 non-null float64\n", - "AS_DAYM780201 3038 non-null float64\n", - "AS_FUKS010112 3038 non-null float64\n", - "CT_RACS820104 3038 non-null float64\n", - "CLASS 3038 non-null int64\n", - "dtypes: float64(10), int64(2)\n", - "memory usage: 284.9 KB\n" - ] - } - ], - "source": [ - "Train.info()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 5. Establishing if there are any missing values in the attributes of the data set. This helps to give an insight on how to handle the missing values, whether to remove rows that have missing values or establishing a method like the mean,median ect to impute the NAs. " - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "FULL_Charge 0\n", - "FULL_AcidicMolPerc 0\n", - "FULL_AURR980107 0\n", - "FULL_DAYM780201 0\n", - "FULL_GEOR030101 0\n", - "FULL_OOBM850104 0\n", - "NT_EFC195 0\n", - "AS_MeanAmphiMoment 0\n", - "AS_DAYM780201 0\n", - "AS_FUKS010112 0\n", - "CT_RACS820104 0\n", - "CLASS 0\n", - "dtype: int64" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Train.isna().sum()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 6. Descriptive statistics summary of the data in each column.\n", - "#### This includes measures of central tendencies like teh mean, median and measures of spread like standard, variance, range and interquatile range. The smallest and largest values of each column are also returned. This helps in understanding the distribution of data in each column. This way you can also find out if you have negative values in any attribute. This also helps in understanding the scales at which each attribute is at." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "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": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Train.describe()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### From the values above, there are no missing values since all counts in each column is equal. We can also observe that there are negative values in some attributes have a minimum values in negatives." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Since this is a classification problem, its important to check out the propotions of the values in the class to be predicted as its possible one class may have more values as compared to the others. Incases where one class is higher than another class we could employe methods likes smote to over sample the least represented class so as to have an un biased algorithm." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'Distirbution')" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "Train.groupby('CLASS').size().plot(kind='bar', color='Purple',edgecolor = 'black')\n", - "# Plot formatting\n", - "plt.legend(title = 'Class')\n", - "plt.title('Bar Plot to show distribution of class variable')\n", - "plt.xlabel('Class')\n", - "plt.ylabel('Distirbution')" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "CLASS\n", - "0 1519\n", - "1 1519\n", - "dtype: int64" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Checking propotions of attribute class\n", - "Train.groupby('CLASS').size()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### From above, the entries in the class attribute are equal." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 7. Correlation between attributes.\n", - "#### This is done to establish the relationship between variables and how they may change or may not change each other. The pearson's correlation method is going to be used since it assumes normal distribution on attributes involved. A value of 0 shows no correlation between the attributes, while a correlation of -1 or 1 shows full negative or positive correlation between variables." - ] - }, - { - "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": [ - "Train.corr(method='pearson')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### From the summary above, AS_DAYM780201 and FULL_DAYM780201 are the strongest positively correlated with a correlation of 0.894191 while FULL_AcidicMolPerc and FULL_Charge are the strongest negatively correlated attributes. This correlation can further be observed by plotting a heat map using seaborn to show the correlation of attributes with each other as shown below" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize= (10,10))\n", - "sns.heatmap(Train.corr(method = 'pearson'), cmap='Purples', robust=True, square=True, annot= True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 8. Using visualisation to understand the data at hand. Histograms, Density plots and Box and whisker plots are some of the plots used to understand the attribute distribution. Histograms were used. They're used to summarize discrete or continuous data by showing the number(frequency) of data points that fall within a specified range of values. Histograms graphically show center) of the data, spread (i.e., the scale) of the data, skewness of the data, presence of outliers and presence of multiple modes in the data" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "Train.hist(figsize=(10,10))\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### From the histograms above, we can observe that attributes AS_MeanAmphiMoment, AS_DAYM780201, AS_FUKS010112, FULL_DAYM780201, FULL_GEOR030101, FULL_AURR980107,FULL_CHARGE have a normal. We can also tell from these plots that attribute CT_RACS820104 and FULL_AcidicMolPerc are skewed to the right. We can also tell that attributes NT_EFC195 and CLASS are categorical attributes. This can also be observed using density plots as shown below." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Using Density plots. Density plots are used to observe the distribution of a variable in a dataset. The peaks of a Density Plot help display where values are concentrated over the interval. Density plots give a more precise location and also gives a continuous distribution view. " - ] - }, - { - "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": [ - "Train.plot(kind='density', figsize=(10,10), subplots=True, layout=(4,3), sharex=False)\n", - "plt.show" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### From the above plots, FULL_Charge, FULL_AURR980107, FULL_DAYM780201, FULL_GEOR030101, CT_RACS820104, FULL_OOBM850104, AS_FUKS010112, AS_DAYM780201 show a normal distribution of variables. CLASS and NT_EFC195 are categorical data CLASS having equal number of instances while NT_EFC195 has a category that has almost all instances. \tFULL_AcidicMolPerc and AS_MeanAmphiMoment have more than one peak meaning that the data points are distribute at 2 peak for FULL_AcidicMolPerc and 3 peaks for AS_MeanAmphiMoment\t" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 9. Checking for the skewness of the data. Skewness is deviation from a normal distribution. The data may be skewed to the left or to the right of the normal distribution curve (bell shaped). Since many machine learning algorithms assume normal distribution,this allows one to know what attributes need to be corrected of skewness to improve the accuracy of the model. Skewness can be observed with bar plots of .skew()." - ] - }, - { - "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": [ - "Train.skew().plot(kind='bar', figsize=(10,6))" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "NT_EFC195\n", - "0 2769\n", - "1 269\n", - "dtype: int64" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# From above, attribute NT_EFC195 shows that its, skewed.\n", - "Train.groupby('NT_EFC195').size()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### From the check above, attribute NT_EFC195 has skewed data and this could alter final results of the model. The data could be transformed or the attributed drop(not used in building a classifier." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 10. Spot checking classification algorithms since its a classification problem at hand.\n", - "#### This is done to know which algorithm is best suited for the problem at hand. Two linear machine learning algorithms(Logistic regression and Linear discriminant analysis) and four non-linear machine learning algorithm were used(k-nearest neighbors, naive bayes, support vector machines and classific regression tress. " - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "('LR', 0.8342865299822478)\n", - "('LDA', 0.8377162908048379)\n", - "('KNN', 0.8690586462107053)\n", - "('CART', 1.0)\n", - "('NB', 0.8407203694376205)\n", - "('SVM', 0.8187103751493263)\n", - "('ABC', 0.8848771929251248)\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAEVCAYAAAAb/KWvAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAHONJREFUeJzt3X98XHWd7/HXm1DoVRBbW0Wh0F6t3jRBQCLuavyR1V2R9YKuLDYrCj6iePdq3AW9VzQ8tLIbf931Z8T1sgQR3QSQFbfeiyveTRCi4pKuyBYCWBClC2ixFWSxEOrn/nFO2ul0kkzSmTlzzryfj8c8HnPO+c6Zzzk9/cx3Pt+T7ygiMDOzYjkg6wDMzKz2nNzNzArIyd3MrICc3M3MCsjJ3cysgJzczcwKyMndKpJ0qaS/rtO+3yTp2jm2v0LS1nq8d95J+oCki7OOw5qfk3uLk3SdpB2SDm7Ue0bE30fEH5XEEJKe06j3V+LdkjZL+g9JWyV9TdIxjYphsSLiIxHxtqzjsObn5N7CJK0GXgoEcEqD3vPARrzPPD4L/AXwbmA58FzgG8AfZxnUfJrk3FlOOLm3trcANwKXAmfO1VDS/5R0v6T7JL2ttLct6TBJl0naJulnks6XdEC67SxJ35P0aUnbgQ3puol0+/XpW/xY0iOS3ljynu+R9Mv0fd9asv5SSV+Q9K30Nd+TdLikz6TfQm6XdPwsx7EWeCfQGxFjEfFYRDyafpv42AKP59eS7pb04nT9vWm8Z5bF+kVJ35H0G0nflXR0yfbPpq97WNImSS8t2bZB0lWSvirpYeCsdN1X0+1L022/SmO5SdIz0m3PkrRR0nZJWyS9vWy/V6bH+BtJt0rqmuvf3/LHyb21vQX4+/Tx6pnEUE7SScC5wKuA5wAvL2syBBwG/Od021uAt5ZsfxFwN/B0YLD0hRHxsvTpsRFxSERckS4fnu7zCKAPuFDSspKXng6cD6wAHgN+APxrunwV8KlZjvmVwNaI+JdZtld7PLcATwNGgMuBF5KcmzOAz0s6pKT9m4C/SmO7meR8z7gJOI7kG8QI8DVJS0u2n5oez1PLXgfJB/JhwKo0lv8G/DbdNgpsBZ4FnAZ8RNIrS157Shr3U4GNwOfnOB+WQ07uLUpSN3A0cGVEbALuAv5sluanA1+KiFsj4lHgwyX7aQPeCLw/In4TEfcAnwTeXPL6+yJiKCKeiIjfUp1p4IKImI6Ia4BHgOeVbL86IjZFxE7gamBnRFwWEbuAK4CKPXeSJHj/bG9a5fH8NCK+VPJeq9JYH4uIa4HHSRL9jP8bEddHxGPAAPD7klYBRMRXI+JX6bn5JHBw2XH+ICK+ERG/q3DuptPjeU5E7ErPx8PpvruB90XEzoi4Gbi47BgmIuKa9Bi+Ahw72zmxfHJyb11nAtdGxIPp8gizl2aeBdxbslz6fAVwEPCzknU/I+lxV2pfrV9FxBMly48Cpb3hX5Q8/22F5dK2e+0XeOYc71vN8ZS/FxEx1/vvPv6IeATYTnJOZ0pPU5IekvRrkp74ikqvreArwLeBy9Ny2SckLUn3vT0ifjPHMTxQ8vxRYKlr+sXi5N6CJP0nkt74yyU9IOkB4BzgWEmVenD3A0eWLK8qef4gSQ/y6JJ1RwH/XrLcTFOP/jNw5Bw15mqOZ6F2n6+0XLMcuC+tr7+P5N9iWUQ8FXgIUMlrZz136beaD0fEOuDFwGtJSkj3AcslHVrDY7CccXJvTa8DdgHrSOq9xwHtwA0kyaHclcBbJbVLehLwwZkN6df6K4FBSYemg4XnAl9dQDy/IKlv111E/AT4AjCq5H76g9KByfWSzqvR8ZQ7WVK3pINIau8/jIh7gUOBJ4BtwIGSPgg8pdqdSuqRdExaSnqY5ENpV7rv7wMfTY/t+STjFuU1eyswJ/fWdCZJDf3nEfHAzINkUO1N5V/PI+JbwOeAcWALyeAlJAOZAP3Af5AMmk6QlHguWUA8G4Avp3d8nL7IY1qId5Mc64XAr0nGG14PfDPdvr/HU24E+BBJOeYEkgFWSEoq3wLuJCmb7GRhJazDSQZbHwamgO+y50OoF1hN0ou/GvhQRHxnP47Bckb+sQ5bKEntwGbg4LK6uJWRdCnJ3TnnZx2LtRb33K0qkl6fljCWAR8HvunEbta8nNytWu8gqQ3fRVKv//NswzGzubgsY2ZWQO65m5kVkJO7mVkBObmbmRWQk7uZWQE5uZuZFZCTu5lZATm5m5kVkJO7mVkBObmbmRWQk7uZWQE5uZuZFZCTu5lZATm5m5kVkJO7mVkBZfZr5ytWrIjVq1dn9fZmZrm0adOmByNi5XztMkvuq1evZnJyMqu3NzPLJUk/q6adyzJmZgXk5G5mVkBO7mZmBeTkbmZWQE7uZmYFNG9yl3SJpF9K2jzLdkn6nKQtkm6R9ILah2lmZgtRTc/9UuCkOba/BlibPs4G/nb/wzIzs/0xb3KPiOuB7XM0ORW4LBI3Ak+V9MxaBWhmZgtXiz9iOgK4t2R5a7ru/vKGks4m6d1z1FFH1eCtQdKCXxMRNXnvWnD82clz7EWQ9/Pf7PHXIrlXOsKKRxARFwEXAXR1ddXkKGc7WZKa6kKYjePPTp5jL4K8n/9mj78Wd8tsBVaVLB8J3FeD/e5l+fLlSKr6ASyo/fLly2sdcqHiN1ssX/vZqEXPfSPwLkmXAy8CHoqIfUoy+2vHjh11/TRczFeshch7/GaLlfdrf/ny5ezYsWNBr1lITMuWLWP79rmGNRdn3uQuaRR4BbBC0lbgQ8ASgIj4InANcDKwBXgUeGvNozSzfTR7zbco8vrhNG9yj4jeebYH8M6aRWRNKa+9lyJr9pqvZSuzKX8tX/LaezFrVblJ7vGhp8CGw+q7fzOrOf/fzYay+vrW1dUVC/mxjnp/1az7V9k6Xtx73uOhuu067+d/MWWlatW7pFTP2KH+8ef92mm2/UvaFBFd87XLTc897/Thh+t/gWyo2+5zr55lJd9pZc3Is0KamRWQk7uZWQE5uZuZFZBr7mZmc8jr3T5O7laVvF7gZvsrrzdDOLlbVfJ6gReBP1htMZzczZqcP1htMTygamZWQE7uZmYF5LKMtYR61q1ds7Zm5ORuLaGedWvXrK0ZuSxjZlZATu5mZgXk5G5mVkCuuZvlQD2n5V22bFnd9m3ZcXI3a3ILHQj2b6gaOLk3lHtfZtYoTu4N4t6XmTWSk7uZ2Tzy+K3byd3MbA55/dadq+Sex09Ps3qZ6//DbNuaIelYY+Qmuef109OsXnx921xyk9zNLL/8rbvxnNzNrK78rTsbTu5WNfe+zPLDyd2q4t6XWb544jAzswKqKrlLOknSHZK2SDqvwvajJI1L+pGkWySdXPtQzcysWvMmd0ltwIXAa4B1QK+kdWXNzgeujIjjgfXAF2odqJmZVa+anvuJwJaIuDsiHgcuB04taxPAzA9JHgbcV7sQzcxsoaoZUD0CuLdkeSvworI2G4BrJfUDTwZeVZPozMxsUarpuVe6/638Nohe4NKIOBI4GfiKpH32LelsSZOSJrdt27bwaM3MrCrVJPetwKqS5SPZt+zSB1wJEBE/AJYCK8p3FBEXRURXRHStXLlycREXjKSKj/m2NYu8x29WVNUk95uAtZLWSDqIZMB0Y1mbnwOvBJDUTpLc3TWvQkQs+NFM8h6/2WI1e8dm3pp7RDwh6V3At4E24JKIuFXSBcBkRGwE3gP8naRzSEo2Z4X/F5tZgTV7iqvqL1Qj4hrgmrJ1Hyx5fhvwktqGZmZmi+W/UDUzKyDPLWMto141T096Zs3IPXdrCQsd8F1I++3bt2d8dInR0VE6Oztpa2ujs7OT0dHRrEOyDLnnblYAo6OjDAwMMDw8THd3NxMTE/T19QHQ29ubcXSWBWU14tvV1RWTk5N127+nnLXFyuO109nZydDQED09PbvXjY+P09/fz+bNmzOMbHaLKZPl7d+lHiRtioiueds5uZvtLY/XTltbGzt37mTJkiW7101PT7N06VJ27dqVYWRWa9Umd9fczQqgvb2diYmJvdZNTEzQ3t6eUUSWNSd3swIYGBigr6+P8fFxpqenGR8fp6+vj4GBgaxDs4x4QNWsAGYGTfv7+5mamqK9vZ3BwUEPprYw19zNyvjasWbmmruZWQtzcjczK6Dc19znuld2tm3+ym1mRZf7nrvnEzdLePoBK5X7nruZefoB21fue+5mBoODgwwPD9PT08OSJUvo6elheHiYwcHBrEOzjBT2VkizxcrjrZCefqB1+FZIsxbi6QesnJO7WQF4+oHsNduAtgdUzQrA0w9kqxkHtF1zNyuTx5q7ZauR8+m3/HzuZovl5G4L1cgBbQ+ompk1SDMOaDu5m5ntp2Yc0PaAqpnZfmrGAW3X3M3KuOZuzcw1dzOzFubkbmZWQE7uZmYF5AFVa1n+oRcrMid3a1lO1FZkLsuYmRVQVcld0kmS7pC0RdJ5s7Q5XdJtkm6VNFLbMM3MbCHmTe6S2oALgdcA64BeSevK2qwF3g+8JCI6gL+sQ6wtodmmDTWzfKqm5n4isCUi7gaQdDlwKnBbSZu3AxdGxA6AiPhlrQNtBc04baiZ5VM1ZZkjgHtLlrem60o9F3iupO9JulHSSZV2JOlsSZOSJrdt27a4iAvMv4NpZrVSTXKvdE9Y+W0GBwJrgVcAvcDFkp66z4siLoqIrojoWrly5UJjLbypqSm6u7v3Wtfd3c3U1FRGEZlZXlWT3LcCq0qWjwTuq9DmHyNiOiJ+CtxBkuxtAZpx2lCzRvF4U21Vk9xvAtZKWiPpIGA9sLGszTeAHgBJK0jKNHfXMtBW0IzThpo1wsx409DQEDt37mRoaIiBgQEn+P0REfM+gJOBO4G7gIF03QXAKelzAZ8iGWT9N2D9fPs84YQTwvY1MjISHR0dccABB0RHR0eMjIxkHdKC5D1+y0ZHR0eMjY3ttW5sbCw6Ojoyiqh5AZNRRd72lL9WM7Pd7ZP1vNbW/Br5M3V55yl/reF8t48tlsebas/J3WrGd/vYYnm8qfY8cZjVzEzvq6enZ/c6976sGs34M3V55+RuNTPT+6pUczebT29vr5N5DTm5W82492XWPHy3jJlZjvhuGTOzFubkbmZWQE7uZmYF5ORuZlZATu5mZgXk5G5mVkBO7mZmBeTkbmZWQE7uZmYF5ORuZlZATu5mZgXk5G5mVkBO7mZmBeTkbmZWQE7uZmYF5ORuZlZATu5mZgXk5G5mVkBO7mZmBeTkbmZWQE7uZmYF5ORuZlZATu5mZgXk5G5mVkBO7mZmBeTkbmZWQFUld0knSbpD0hZJ583R7jRJIamrdiGamdlCzZvcJbUBFwKvAdYBvZLWVWh3KPBu4Ie1DtLyY3R0lM7OTtra2ujs7GR0dDTrkMwaotmu/QOraHMisCUi7gaQdDlwKnBbWbu/Aj4BvLemEVpujI6OMjAwwPDwMN3d3UxMTNDX1wdAb29vxtGZ1U9TXvsRMecDOA24uGT5zcDny9ocD/xD+vw6oGuWfZ0NTAKTRx11VFixdHR0xNjY2F7rxsbGoqOjI6OIzBqjkdc+MBnz5O2IQEnb2Un6U+DVEfG2dPnNwIkR0Z8uHwCMAWdFxD2SrgPeGxGTc+23q6srJifnbGI509bWxs6dO1myZMnuddPT0yxdupRdu3ZlGJlZfTXy2pe0KSLmHdesZkB1K7CqZPlI4L6S5UOBTuA6SfcAvwds9KBq62lvb2diYmKvdRMTE7S3t2cUkVljNOO1X01yvwlYK2mNpIOA9cDGmY0R8VBErIiI1RGxGrgROGW+nrsVz8DAAH19fYyPjzM9Pc34+Dh9fX0MDAxkHZpZXTXjtT/vgGpEPCHpXcC3gTbgkoi4VdIFJLWfjXPvwVrFzMBRf38/U1NTtLe3Mzg46MFUK7xmvPbnrbnXi2vuZmYLV8uau5mZ5YyTu5lZATm5m5kVkJO7mVkBObmbpZptbhCz/VHN3DJmhdeUc4OY7QffCmkGdHZ2MjQ0RE9Pz+514+Pj9Pf3s3nz5gwjM9tbtbdCOrmb4XlxLD98n7vZAjTj3CBm+8PJ3YzmnBvEbH94QNWM5pwbxGx/uOZuZpYjrrmbmbUwJ3czswJycjczKyAndzOzAnJyNzMrICd3M7MCcnI3MysgJ3czswJycjczKyAndzOzAnJyNzMrICd3M7MCcnI3MysgJ3czswJycjczKyAndzOzAnJyNzMrICd3M7MCcnI3MyugqpK7pJMk3SFpi6TzKmw/V9Jtkm6R9M+Sjq59qGZmVq15k7ukNuBC4DXAOqBX0rqyZj8CuiLi+cBVwCdqHajlw+joKJ2dnbS1tdHZ2cno6GjWIZm1pAOraHMisCUi7gaQdDlwKnDbTIOIGC9pfyNwRi2DtHwYHR1lYGCA4eFhuru7mZiYoK+vD4De3t6MozNrLdWUZY4A7i1Z3pqum00f8K39CcryaXBwkOHhYXp6eliyZAk9PT0MDw8zODiYdWhmLaea5K4K66JiQ+kMoAv4X7NsP1vSpKTJbdu2VR+l5cLU1BTd3d17revu7mZqaiqjiBbGJSUrkmqS+1ZgVcnykcB95Y0kvQoYAE6JiMcq7SgiLoqIrojoWrly5WLitSbW3t7OxMTEXusmJiZob2/PKKLqzZSUhoaG2LlzJ0NDQwwMDDjBW35FxJwPkrr83cAa4CDgx0BHWZvjgbuAtfPtb+ZxwgknhBXLyMhIrFmzJsbGxuLxxx+PsbGxWLNmTYyMjGQd2rw6OjpibGxsr3VjY2PR0dGRUURmlQGTUUWOVdJ2bpJOBj4DtAGXRMSgpAvSN9ko6f8BxwD3py/5eUScMtc+u7q6YnJycuGfRtbURkdHGRwcZGpqivb2dgYGBnIxmNrW1sbOnTtZsmTJ7nXT09MsXbqUXbt2ZRiZ2d4kbYqIrvnaVXWfe0RcExHPjYhnR8Rguu6DEbExff6qiHhGRByXPuZM7PXkumm2ent72bx5M7t27WLz5s25SOyQ75KSWSWF+gtV101tsQYGBujr62N8fJzp6WnGx8fp6+tjYGAg69DMFqea2k09HvWoubtuavtjZGQkOjo64oADDoiOjo5cjBVY66GWNfd6qEfN3XVTMyu6mtbc88J1UzOzRKGSu+umZmaJauaWyY2ZOzP6+/t334o3ODiYmzs2zMxqpVA9d8jvrXhmrc63MddWoXruZpZPnlG09gp1t4yZ5VNnZydDQ0P09PTsXjc+Pk5/fz+bN2/OMLLmU+3dMk7uZpY538ZcvZa8FdLM8sm3Mdeek3uT8aCStSLfxlx7HlBtIh5Uslbl25hrzzX3JuJBJTObjwdUc8iDSmY2Hw+o5pAHlcysVpzcm4gHlcysVjyg2kQ8qGRmteKau5lZjrjmbmbWwpzczcwKyMndzKyAnNzNzArIyd3MrICc3M3MCsjJ3cysgJzczcwKyMndzKwGmu23GDz9gJnZfmrG32Lw9ANmZvupkb/F4PnczcwapJG/xeC5ZczMGqQZf4uhquQu6SRJd0jaIum8CtsPlnRFuv2HklbXOlAzs2bVjL/FMO+AqqQ24ELgD4GtwE2SNkbEbSXN+oAdEfEcSeuBjwNvrEfAZmbNphl/i2Hemruk3wc2RMSr0+X3A0TER0vafDtt8wNJBwIPACtjjp275m5mtnC1rLkfAdxbsrw1XVexTUQ8ATwEPK1CUGdLmpQ0uW3btire2szMFqOa5K4K68p75NW0ISIuioiuiOhauXJlNfGZmdkiVJPctwKrSpaPBO6brU1aljkM2F6LAM3MbOGqSe43AWslrZF0ELAe2FjWZiNwZvr8NGBsrnq7mZnV17x3y0TEE5LeBXwbaAMuiYhbJV0ATEbERmAY+IqkLSQ99vX1DNrMzOaW2V+oStoG/KyOb7ECeLCO+683x5+dPMcOjj9r9Y7/6IiYd9Ays+Reb5Imq7ldqFk5/uzkOXZw/Flrlvg9/YCZWQE5uZuZFVCRk/tFWQewnxx/dvIcOzj+rDVF/IWtuZuZtbIi99zNzFpWIZK7pEcqrNsg6d8l3SzpNknZTc9Wpop4fyLp65LWlbVZKWla0jsaF+0+cT5S8vzkNNaj0vgflfT0WdqGpE+WLL9X0oYGxn24pMsl3ZVeD9dIem667RxJOyUdVtL+FZIekvQjSbdL+pt0/VvTf6ObJT0u6d/S5x9r1LGUxDjrOS27nm6X9LeSMv//LmlA0q2Sbklj+5akj5a1OU7SVPr8Hkk3lG2/WVJtf95oASS9Pj33/yVdXi3pt2lcP5b0fUnPK2l/oqTr02nTb5d0saQn1TvOzP+x6+zTEXEccCrwvyUtme8FGft0RBwXEWuBK4AxSaX3s/4pcCOQ+QeVpFcCQ8BJEfHzdPWDwHtmecljwJ9IWtGI+EpJEnA1cF1EPDsi1gEfAJ6RNukl+Uvs15e99IaIOB44HnitpJdExJfSf6PjSKbh6EmX9/mdgwaY75zOXP/rgGOAlzcssgrSGWZfC7wgIp4PvAr4GPtOD74eGClZPlTSzPQm2f36xR69wAR7/7HmXel1cCzwZZLrC0nPAL4GvC8inge0A/8EHFrvIIue3AGIiJ8AjwLLso6lWhFxBXAt8Gclq3tJkueRkspn5mwYSS8F/g7444i4q2TTJcAbJS2v8LInSAaazmlAiOV6gOmI+OLMioi4OSJukPRs4BDgfGb50IyI3wI3s+9sqFmr9pweBCwFdtQ9ork9E3gwIh4DiIgHI+K7wK8lvaik3enA5SXLV7LnA6AXGG1EsJVIOgR4CclvWMz2l/hPYc+5fifw5Yj4AUAkroqIX9Q71pZI7pJeAPwkIn6ZdSwL9K/AzFe/VcDhEfEv7H2xN9rBwD8Cr4uI28u2PUKS4P9iltdeCLyptPzRIJ3Aplm2zSSLG4DnlZaVZkhaBqwFrq9bhIs31zk9R9LNwP3AnRFxc2ND28e1wCpJd0r6gqSZbxKjpIlS0u8Bv0o7ZDOuAv4kff5fgW82KuAKXgf8U0TcCWxPcwvAs9OyzF3AucCn0vVzXXt1VfTkfo6kO4AfAhsyjmUxSqdSXk+S1CHp1WRVmpkGvk/Sc6nkc8CZkp5SviEiHgYuA95dv/AWbD1weUT8Dvg6Selrxksl3ULy4zP/JyIeyCLAucxzTmfKMk8HnqzkV9IyExGPACcAZwPbgCsknUVyPZ+WjgmsZ9+e+XZgRxr/FMm38Kz0sudbRen/w5myzLOBv6QJbocsenL/dFrneiNwmaSlWQe0QMeTXMyQXERnSbqHZBbOYyWtzSCm35F8bX6hpA+Ub4yIX5PUS//7LK//DMkHw5PrFuG+biVJKnuR9HySHvl30vO6nr0/NG9Ia8PHAH8u6bgGxLoYc57TiJgmqfO+rJFBzRLLroi4LiI+BLwLeENE3AvcQzIm8Ab2dGJKXUHyLSXLkszTgD8ALk6vl/9BklvKf89iI3vOdcVrrxGKntwBiIivA5PsmZa46Ul6A/BHwGg68v7kiDgiIlZHxGrgo2Q0+2ZEPEoyMPYmSZV68J8C3kGFWUcjYjvJf97Zev71MAYcLOntMyskvRD4LMnPQ65OH88CjpB0dFnMd5Kc7/c1MOaqzXdO0wHlFwN3VdreKJKeV9YhOY49kweOAp8m6QFvrfDyq4FPkMxOm5XTgMsi4uj0elkF/JTkNy5KdbPnXH+e5Jvs7jEFSWdIOrzewRYluT9J0taSx7kV2lwAnNsMt4Mxe7znpHW7nwBnAH8QEdtIepNXl+3jH8jwrpk0oZwEnC/p1LJtD5LEe/AsL/8kycx5DZH+tsDrgT9UcivkrSRlulew73m9msofml8EXiZpTR1D3R+VzulMzX0zyQftFxoe1d4OAb6s5FbUW0ju4tmQbvsa0MHeA6m7RcRvIuLjEfF4QyKtbLb/hx9gT839x8BHgLcBpAOn64G/SW+FnAJeCjxc72D9F6pmZgXUDL1YMzOrMSd3M7MCcnI3MysgJ3czswJycjczKyAndzOzAnJyNzMrICd3M7MC+v9x2I3TbtEROgAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "from matplotlib import pyplot\n", - "from sklearn.model_selection import KFold\n", - "from sklearn.model_selection import cross_val_score\n", - "from sklearn.linear_model import LogisticRegression\n", - "from sklearn.tree import DecisionTreeClassifier\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 AdaBoostClassifier\n", - "from sklearn.metrics import matthews_corrcoef\n", - "\n", - "#split the dataset \n", - "A = Train.values\n", - "# Separating A into output and input components\n", - "X = A[:, 0:11]\n", - "Y = A[:, 11]\n", - "# prepare models and add them to a list\n", - "models = []\n", - "models.append(('LR', LogisticRegression()))\n", - "models.append(('LDA', LinearDiscriminantAnalysis()))\n", - "models.append(('KNN', KNeighborsClassifier()))\n", - "models.append(('CART', DecisionTreeClassifier()))\n", - "models.append(('NB', GaussianNB()))\n", - "models.append(('SVM', SVC()))\n", - "models.append(('ABC', AdaBoostClassifier()))\n", - "\n", - "#print(models)\n", - "\n", - "# evaluate each model in turn\n", - "results = []\n", - "names = []\n", - "scoring = 'accuracy'\n", - "\n", - "for name, model in models:\n", - " kfold = KFold(n_splits=20, 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", - " model.fit(X, Y)\n", - "\n", - " Prediction = model.predict(X)\n", - " msg = (name, matthews_corrcoef(Y, Prediction))\n", - " print(msg)\n", - "\n", - "# boxplot algorithm comparison\n", - "fig = pyplot.figure()\n", - "fig.suptitle('Algorithm Comparison')\n", - "ax = fig.add_subplot(111)\n", - "pyplot.boxplot(results)\n", - "ax.set_xticklabels(names)\n", - "pyplot.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### From these results, it would suggest that both DecisionTreeClassifier, KNeighborsClassifier and GaussianNB are worthy of further study on this problem." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### **11. Data Preparation.**\n", - "#### This is important because this finds a way to best expose the structure of the problem to machine learning algorithim intended to be used. Since the data has attributes of varying scales, its important to use one of the methods for data preparation like rescaling, standardization, normalization or binarization for better prediction. Here, rescaling is used to have all the attribute on the same scale." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[0.457 0. 0.348 0.545 0.33 0.483 0. 0.005 0.508 0.415 0.182]\n", - " [0.435 0.116 0.322 0.489 0.276 0.458 1. 0.011 0.421 0.586 0.475]\n", - " [0.467 0.116 0.246 0.523 0.288 0.565 0. 0.011 0.442 0.273 0.666]\n", - " [0.457 0.089 0.275 0.399 0.403 0.647 0. 0.011 0.405 0.153 0.424]\n", - " [0.511 0.183 0.323 0.373 0.342 0.595 0. 0.011 0.5 0.196 0.536]]\n" - ] - } - ], - "source": [ - "from numpy import set_printoptions\n", - "from sklearn.preprocessing import MinMaxScaler\n", - "\n", - "A = Train.values\n", - "# Separating A into output and input components\n", - "X = A[:, 0:11]\n", - "Y = A[:, 11]\n", - "scaler = MinMaxScaler(feature_range= (0,1))\n", - "rescaledX = scaler.fit_transform(X)\n", - "\n", - "# Summary of the transformed data\n", - "set_printoptions(precision = 3) # This sets the number of floating point output after rescaling the data\n", - "print(rescaledX[0:5, :]) # This is used as check to confirm that the data has been rescaled" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Standardization\n", - "#### It is a useful technique to transform attributes with a Gaussian distribution and differing means and standard deviations to a standard Gaussian distribution with a mean of 0 and a standard deviation of 1" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[ 7.697e-01 -1.123e+00 -1.900e-01 1.376e-01 -6.067e-01 -7.206e-01\n", - " -3.117e-01 -1.331e+00 -2.257e-02 -3.610e-01 -9.251e-01]\n", - " [ 5.079e-01 -4.109e-01 -3.763e-01 -2.432e-01 -1.181e+00 -9.245e-01\n", - " 3.208e+00 -1.303e+00 -5.924e-01 9.021e-01 1.037e+00]\n", - " [ 9.006e-01 -4.109e-01 -9.163e-01 -8.651e-03 -1.054e+00 -4.632e-02\n", - " -3.117e-01 -1.304e+00 -4.590e-01 -1.409e+00 2.318e+00]\n", - " [ 7.697e-01 -5.741e-01 -7.115e-01 -8.701e-01 1.594e-01 6.274e-01\n", - " -3.117e-01 -1.302e+00 -7.015e-01 -2.300e+00 6.989e-01]\n", - " [ 1.424e+00 2.041e-03 -3.670e-01 -1.050e+00 -4.790e-01 2.003e-01\n", - " -3.117e-01 -1.302e+00 -7.713e-02 -1.977e+00 1.447e+00]]\n" - ] - } - ], - "source": [ - "from numpy import set_printoptions\n", - "from sklearn.preprocessing import StandardScaler\n", - "B= Train.values\n", - "#Separating the array into intput and output components\n", - "X = B[:, 0:11]\n", - "Y = B[:, 11]\n", - "scaler2 = StandardScaler()\n", - "standardizedX = scaler2.fit_transform(X)\n", - "# A portion of the transformed data\n", - "set_printoptions(precision = 3) # This sets the number of floating point output after rescaling the data\n", - "print(standardizedX[0:5,:]) # This is used as check to confirm that the data has been rescaled" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### **12. Feature selection**\n", - "#### Statistical tests can be used to select those features that have the strongest relationship with the output variable. Feature selection is done on non transformed data using select k best using he univariate statistic F was used since it can work best with data containg negative values as opposed to chi2 that doesnt take in negative values." - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
featuresscorespvalue
7AS_MeanAmphiMoment2813.8681780.000000e+00
1FULL_AcidicMolPerc1697.2495654.220004e-295
2FULL_AURR9801071572.2806771.887905e-277
3FULL_DAYM7802011350.3007436.997934e-245
0FULL_Charge1214.9028383.404241e-224
5FULL_OOBM850104785.1247987.441087e-154
8AS_DAYM780201717.3174084.911002e-142
10CT_RACS820104234.2741975.329249e-51
6NT_EFC195221.3908532.189203e-48
4FULL_GEOR030101220.9670652.669597e-48
\n", - "
" - ], - "text/plain": [ - " features scores pvalue\n", - "7 AS_MeanAmphiMoment 2813.868178 0.000000e+00\n", - "1 FULL_AcidicMolPerc 1697.249565 4.220004e-295\n", - "2 FULL_AURR980107 1572.280677 1.887905e-277\n", - "3 FULL_DAYM780201 1350.300743 6.997934e-245\n", - "0 FULL_Charge 1214.902838 3.404241e-224\n", - "5 FULL_OOBM850104 785.124798 7.441087e-154\n", - "8 AS_DAYM780201 717.317408 4.911002e-142\n", - "10 CT_RACS820104 234.274197 5.329249e-51\n", - "6 NT_EFC195 221.390853 2.189203e-48\n", - "4 FULL_GEOR030101 220.967065 2.669597e-48" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from sklearn.feature_selection import SelectKBest, f_classif\n", - "from numpy import set_printoptions\n", - "# Separating A into output and input components\n", - "A = Train.values\n", - "X = A[:, 0:11]\n", - "Y = A[:, 11]\n", - "#Feature Extraction\n", - "bestfeat = SelectKBest(score_func=f_classif, k=10)\n", - "fit = bestfeat.fit(X,Y) #fitting f_classif test on predictors to get features that best predict\n", - "\n", - "set_printoptions(precision=3) # This sets the number of floating point output after rescaling the data\n", - "selected_features = fit.transform(X)\n", - "#Creating a dataframe to represent the order features selected starting from the best feature\n", - "scores = pd.DataFrame(fit.scores_)\n", - "pvalues = pd.DataFrame(fit.pvalues_)\n", - "columns = pd.DataFrame(Train.columns[0:11])\n", - "\n", - "selected_features_dataframe = pd.concat([columns,scores, pvalues,], axis=1)\n", - "selected_features_dataframe.columns = ['features', 'scores', 'pvalue']\n", - "selected_features_dataframe.nlargest(10, \"scores\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### SelectKBest using the f statistic, gives scores to each attribute and takes the specified number of attributes with the highest scores. Attributes AS_MeanAmphiMoment, FULL_AcidicMolPerc, FULL_AURR980107, FULL_DAYM780201, FULL_Charge, FULL_OOBM850104, AS_DAYM780201 and CT_RACS820104 were the selected features." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Feature selection using SelectKBest, Chi2 statistical test since there are no negative values in the attributes after rescaling with the minmax scaler." - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "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", - "
featuresscorespvalue
7AS_MeanAmphiMoment244.2277284.708742e-55
6NT_EFC195188.1970267.868482e-43
1FULL_AcidicMolPerc157.6175133.751602e-36
2FULL_AURR98010754.2314481.782118e-13
3FULL_DAYM78020137.3117801.006747e-09
8AS_DAYM78020126.1562243.148806e-07
5FULL_OOBM85010416.2314335.605627e-05
0FULL_Charge15.2452499.441397e-05
10CT_RACS82010415.1467759.946804e-05
4FULL_GEOR0301014.7886912.864719e-02
\n", - "
" - ], - "text/plain": [ - " features scores pvalue\n", - "7 AS_MeanAmphiMoment 244.227728 4.708742e-55\n", - "6 NT_EFC195 188.197026 7.868482e-43\n", - "1 FULL_AcidicMolPerc 157.617513 3.751602e-36\n", - "2 FULL_AURR980107 54.231448 1.782118e-13\n", - "3 FULL_DAYM780201 37.311780 1.006747e-09\n", - "8 AS_DAYM780201 26.156224 3.148806e-07\n", - "5 FULL_OOBM850104 16.231433 5.605627e-05\n", - "0 FULL_Charge 15.245249 9.441397e-05\n", - "10 CT_RACS820104 15.146775 9.946804e-05\n", - "4 FULL_GEOR030101 4.788691 2.864719e-02" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from sklearn.feature_selection import SelectKBest\n", - "from sklearn.feature_selection import chi2\n", - "\n", - "#Feature Extraction\n", - "test = SelectKBest(score_func=chi2, k=10)\n", - "fit = test.fit(rescaledX,Y) # fitting chi2 test on predictors to get features that best predict\n", - "\n", - "# Summary of scores \n", - "set_printoptions(precision=3) # This sets the number of floating point output after rescaling the data\n", - "#print(fit.scores_)\n", - "selected_features1 = fit.transform(rescaledX)\n", - "#Creating a dataframe to represent the order features selected starting from the best feature\n", - "scores = pd.DataFrame(fit.scores_)\n", - "pvalues = pd.DataFrame(fit.pvalues_)\n", - "columns = pd.DataFrame(Train.columns[0:11])\n", - "\n", - "selected_features1 = pd.concat([columns,scores, pvalues], axis=1)\n", - "selected_features1.columns = ['features', 'scores', 'pvalue']\n", - "selected_features1.nlargest(10, \"scores\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### From the dataframe above, AS_MeanAmphiMoment has the highest score of 244.227728 followed by NT_EFC195, then FULL_AcidicMolPerc and like that till the last attribute in dataframe, FULL_GEOR030101 that has lowwest score of 4.788691." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Feature selection using the recursive feature selection method with LogisticRegression - it works by recursively removing attributes and building a model on those attributes that remain. It uses the model accuracy to identify which attributes (and combination of attributes) contribute the most to predicting the target attribute" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "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", - "
Selected_FeaturesRFEFeature_Ranking
2FULL_AURR9801072
0FULL_Charge1
1FULL_AcidicMolPerc1
3FULL_DAYM7802011
4FULL_GEOR0301011
5FULL_OOBM8501041
6NT_EFC1951
7AS_MeanAmphiMoment1
8AS_DAYM7802011
9AS_FUKS0101121
\n", - "
" - ], - "text/plain": [ - " Selected_FeaturesRFE Feature_Ranking\n", - "2 FULL_AURR980107 2\n", - "0 FULL_Charge 1\n", - "1 FULL_AcidicMolPerc 1\n", - "3 FULL_DAYM780201 1\n", - "4 FULL_GEOR030101 1\n", - "5 FULL_OOBM850104 1\n", - "6 NT_EFC195 1\n", - "7 AS_MeanAmphiMoment 1\n", - "8 AS_DAYM780201 1\n", - "9 AS_FUKS010112 1" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from sklearn.feature_selection import RFE\n", - "from sklearn.linear_model import LogisticRegression\n", - "model = LogisticRegression()\n", - "rfe= RFE(model,10)\n", - "fit = rfe.fit(standardizedX, Y) # fitting logistic regression on predictors to get features that best predict\n", - "selectedfeaturesRFE = standardizedX[:, fit.support_]\n", - "\n", - "#Creating a dataframe to represent the order features selected starting from the best feature\n", - "#Num_Features = pd.DataFrame(fit.n_features_)\n", - "Selected_FeaturesRFE = pd.DataFrame(fit.support_)\n", - "Feature_Ranking = pd.DataFrame(fit.ranking_)\n", - "columns = pd.DataFrame(Train.columns[0:11])\n", - "\n", - "selected_features2 = pd.concat([columns, Feature_Ranking], axis=1)\n", - "selected_features2.columns = ['Selected_FeaturesRFE', 'Feature_Ranking']\n", - "selected_features2.nlargest(10, \"Feature_Ranking\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### From the dataframe above, FULL_AURR980107 has the highest rank of 2 followed by FULL_Charge, then FULL_AcidicMolPerc and like that till the last attribute in dataframe, AS_FUKS010112." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### **13. Evaluating Machine learning Alogorithms** - the best way to evaluate the performance of an algorithm would be to make predictions for new data to which you already know the answers. Evaluation shoud be done on data that is not used to train the algorithm. The evaluation is an estimate that we can use to talk about how well we think the algorithm may actually do in practice.\n", - "#### **Split into Train and Test set**\n", - "#### It's the simplest method that we can use to evaluate the performance of a machine learning algorithm is to use dierent training and testing datasets. The train dataset is split it into two parts. The algorithm is trained on one part and predictions are made on the second part and evaluate the predictions against the expected results. The size of the split can depend on the size of your dataset, although it is common to use 67% of the data for training and the remaining 33% for testing. This algorithm evaluation technique is very fast. It is ideal for large datasets (millions of records) where there is strong evidence that both splits of the data are representative of the underlying problem. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### **LogisticRegression** - Logistic regression is basically a supervised classification algorithm. Supervised learning is when a model learns from data that is already labeled. A supervised learning model takes in a set of input objects and output values. The model then trains on that data to learn how to map the inputs to the desired output so it can learn to make predictions on unseen data. In a classification problem, the target variable(or output), y, can take only discrete values for given set of features(or inputs), X. Logistic regression is a classification algorithm used to assign observations to a discrete set of classes. It is based on the concept of probability." - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "MCC: 0.8283116428616907\n", - "Accuracy: 91.92422731804587\n", - "387\n", - "371\n" - ] - } - ], - "source": [ - "from sklearn.model_selection import train_test_split\n", - "from sklearn.metrics import matthews_corrcoef\n", - "from sklearn.linear_model import LogisticRegression\n", - "\n", - "A = Train.values\n", - "# Separating A into output and input components\n", - "X = A[:, 0:11]\n", - "Y = A[:, 11]\n", - "test_size = 0.33\n", - "seed = 1\n", - "selected_features_train, selected_features_test, Y_train, Y_test = train_test_split(X, Y, test_size = test_size, random_state = seed)\n", - "my_model1 = LogisticRegression()\n", - "my_model1.fit(selected_features_train, Y_train)\n", - "result = my_model1.score(selected_features_test, Y_test)\n", - "\n", - "Prediction = my_model1.predict(selected_features_train)\n", - "print(\"MCC:\", (matthews_corrcoef(Y_train, Prediction)))\n", - "print(\"Accuracy:\", (result*100.0))\n", - "\n", - "#Assigning the preditions of the model to variable AssignmentOutPut1\n", - "AssignmentOutPut1 = my_model1.predict(Test.values) #Converting AssignmentOutPut1 to a dataframe since its output is an array\n", - "AssignmentOutPut1 = pd.DataFrame(AssignmentOutPut1)\n", - "\n", - "AssignmentOutPut1.columns = ['Class'] # Naming the output column\n", - "AssignmentOutPut1.index.name = \"Index\" #Creating a column called index\n", - "AssignmentOutPut1['Class'] = AssignmentOutPut1['Class'].map({0.0:False, 1.0:True}) # Converting 0.0 to false and 1.0 to true\n", - "\n", - "#Printing the number of False and Trues\n", - "print(AssignmentOutPut1.groupby('Class').size()[0].sum())\n", - "print(AssignmentOutPut1.groupby('Class').size()[1].sum())\n", - "\n", - "AssignmentOutPut1.to_csv('AssignmentOutPut1.csv') # Writing AssignmentOutPut1 to a csv file" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### **KNeighborsClassifier** - k-Nearest-Neighbors (k-NN) is a supervised machine learning model. KNN models work by taking a data point and looking at the ‘k’ closest labeled data points. The data point is then assigned the label of the majority of the ‘k’ closest points. For example, if k = 5, and 3 of points are ‘green’ and 2 are ‘red’, then the data point in question would be labeled ‘green’, since ‘green’ is the majority " - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "MCC: 0.8566012373350099\n", - "Accuracy: 90.62811565304088\n", - "397\n", - "361\n" - ] - } - ], - "source": [ - "from sklearn.model_selection import train_test_split\n", - "from sklearn.metrics import matthews_corrcoef\n", - "from sklearn.neighbors import KNeighborsClassifier\n", - "\n", - "A = Train.values\n", - "# Separating A into output and input components\n", - "X = A[:, 0:11]\n", - "Y = A[:, 11]\n", - "test_size = 0.33\n", - "seed = 2\n", - "selected_features_train, selected_features_test, Y_train, Y_test = train_test_split(X, Y, test_size = test_size, random_state = seed)\n", - "my_model2 = KNeighborsClassifier()\n", - "my_model2.fit(selected_features_train, Y_train)\n", - "result = my_model2.score(selected_features_test, Y_test)\n", - "\n", - "Prediction = my_model2.predict(selected_features_train)\n", - "print(\"MCC:\", (matthews_corrcoef(Y_train, Prediction)))\n", - "print(\"Accuracy:\", (result*100.0))\n", - "\n", - "#Assigning the preditions of the model to variable AssignmentOutPut2\n", - "AssignmentOutPut2 = my_model2.predict(Test.values) \n", - "#Converting AssignmentOutPut to a dataframe since its output is an array\n", - "AssignmentOutPut2 = pd.DataFrame(AssignmentOutPut2)# Converting AssignmentOutPut2 to a dataframe since its output is an array\n", - "AssignmentOutPut2.columns = ['Class'] # Naming the out put column\n", - "AssignmentOutPut2.index.name = \"Index\" #Creating a column called index\n", - "AssignmentOutPut2['Class'] = AssignmentOutPut2['Class'].map({0.0:False, 1.0:True}) # Converting 0.0 to false and 1.0 to true\n", - "\n", - "#Printing the number of False and Trues\n", - "print(AssignmentOutPut2.groupby('Class').size()[0].sum())\n", - "print(AssignmentOutPut2.groupby('Class').size()[1].sum())\n", - "\n", - "AssignmentOutPut2.to_csv('AssignmentOutPut2.csv') # Writing AssignmentOutPut2 to a csv file" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### **DecisionTreeClassifier** - its also a supervised learning algorithm that identifies ways to split a data set based on different conditions." - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "MCC: 1.0\n", - "Accuracy: 89.63110667996011\n", - "388\n", - "370\n" - ] - } - ], - "source": [ - "from sklearn.model_selection import train_test_split\n", - "from sklearn.metrics import matthews_corrcoef\n", - "from sklearn.tree import DecisionTreeClassifier\n", - "\n", - "A = Train.values\n", - "# Separating A into output and input components\n", - "X = A[:, 0:11]\n", - "Y = A[:, 11]\n", - "test_size = 0.33\n", - "seed = 3\n", - "selected_features_train, selected_features_test, Y_train, Y_test = train_test_split(X, Y, test_size = test_size, random_state = seed)\n", - "my_model3 = DecisionTreeClassifier()\n", - "my_model3.fit(selected_features_train, Y_train)\n", - "result = my_model3.score(selected_features_test, Y_test)\n", - "\n", - "Prediction = my_model3.predict(selected_features_train)\n", - "print(\"MCC:\", (matthews_corrcoef(Y_train, Prediction)))\n", - "print(\"Accuracy:\", (result*100.0))\n", - "AssignmentOutPut3 = my_model3.predict(Test.values) #Assigning the preditions of the model to variable AssignmentOutPut\n", - "\n", - "AssignmentOutPut3 = pd.DataFrame(AssignmentOutPut3)# Converting AssignmentOutPut3 to a dataframe since its output is an array\n", - "AssignmentOutPut3.columns = ['Class'] # Naming the out put column\n", - "AssignmentOutPut3.index.name = \"Index\" #Creating a column called index\n", - "AssignmentOutPut3['Class'] = AssignmentOutPut3['Class'].map({0.0:False, 1.0:True}) # Converting 0.0 to false and 1.0 to true\n", - "\n", - "#Printing the number of False and Trues\n", - "print(AssignmentOutPut3.groupby('Class').size()[0].sum())\n", - "print(AssignmentOutPut3.groupby('Class').size()[1].sum())\n", - "\n", - "AssignmentOutPut1.to_csv('AssignmentOutPut3.csv') # Writing AssignmentOutPut3 to a csv file\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### **GaussianNB** - its a classification algorithm for binary (two-class) and multi-class classification problems. Naive Bayes calculates the probability of each class and the conditional probability of each class given each input value. These probabilities are estimated for new data and multiplied together, assuming that they are all independent" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "MCC: 0.8417648773342619\n", - "Accuracy: 91.92422731804587\n", - "369\n", - "389\n" - ] - } - ], - "source": [ - "from sklearn.model_selection import train_test_split\n", - "from sklearn.metrics import matthews_corrcoef\n", - "from sklearn.naive_bayes import GaussianNB\n", - "\n", - "A = Train.values\n", - "# Separating A into output and input components\n", - "X = A[:, 0:11]\n", - "Y = A[:, 11]\n", - "test_size = 0.33\n", - "seed = 4\n", - "selected_features_train, selected_features_test, Y_train, Y_test = train_test_split(X, Y, test_size = test_size, random_state = seed)\n", - "my_model4 = GaussianNB()\n", - "my_model4.fit(selected_features_train, Y_train)\n", - "result = my_model4.score(selected_features_test, Y_test)\n", - "\n", - "Prediction = my_model4.predict(selected_features_train)\n", - "print(\"MCC:\", (matthews_corrcoef(Y_train, Prediction)))\n", - "print(\"Accuracy:\", (result*100.0))\n", - "\n", - "AssignmentOutPut4 = my_model4.predict(Test.values) #Assigning the preditions of the model to variable AssignmentOutPut4\n", - "\n", - "AssignmentOutPut4 = pd.DataFrame(AssignmentOutPut4)# Converting AssignmentOutPut4 to a dataframe since its output is an array\n", - "AssignmentOutPut4.columns = ['Class'] # Naming the out put column\n", - "AssignmentOutPut4.index.name = \"Index\" #Creating a column called index\n", - "AssignmentOutPut4['Class'] = AssignmentOutPut4['Class'].map({0.0:False, 1.0:True}) # Converting 0.0 to false and 1.0 to true\n", - "\n", - "AssignmentOutPut4.to_csv('AssignmentOutPut4.csv') # Writing AssignmentOutPut4 to a csv file\n", - "#Printing the number of False and Trues\n", - "print(AssignmentOutPut4.groupby('Class').size()[0].sum())\n", - "print(AssignmentOutPut4.groupby('Class').size()[1].sum())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### **Support Vector Machines** - its also a supervised machine learning algorithm capable of performing classification, regression and outlier detection. They draw a line that best separates two classes. Data instances closest to the line that best separates the classes are called support vectors. " - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "MCC: 0.8399582732206575\n", - "Accuracy: 92.82153539381855\n", - "379\n", - "379\n" - ] - } - ], - "source": [ - "from sklearn.model_selection import train_test_split\n", - "from sklearn.metrics import matthews_corrcoef\n", - "from sklearn.svm import SVC\n", - "\n", - "A = Train.values\n", - "# Separating A into output and input components\n", - "X = A[:, 0:11]\n", - "Y = A[:, 11]\n", - "test_size = 0.33\n", - "seed = 5\n", - "selected_features_train, selected_features_test, Y_train, Y_test = train_test_split(X, Y, test_size = test_size, random_state = seed)\n", - "my_model5 = SVC(kernel = 'linear')\n", - "my_model5.fit(selected_features_train, Y_train)\n", - "result = my_model5.score(selected_features_test, Y_test)\n", - "\n", - "Prediction = my_model5.predict(selected_features_train)\n", - "print(\"MCC:\", (matthews_corrcoef(Y_train, Prediction)))\n", - "print(\"Accuracy:\", (result*100.0))\n", - "AssignmentOutPut5 = my_model5.predict(Test.values) #Assigning the preditions of the model to variable AssignmentOutPut5\n", - "\n", - "AssignmentOutPut5 = pd.DataFrame(AssignmentOutPut5)# Converting AssignmentOutPut5 to a dataframe since its output is an array\n", - "AssignmentOutPut5.columns = ['Class'] # Naming the out put column\n", - "AssignmentOutPut5.index.name = \"Index\" #Creating a column called index\n", - "AssignmentOutPut5['Class'] = AssignmentOutPut5['Class'].map({0.0:False, 1.0:True}) # Converting 0.0 to false and 1.0 to true\n", - "\n", - "AssignmentOutPut1.to_csv('AssignmentOutPut5.csv') # Writing AssignmentOutPut5 to a csv file\n", - "#Printing the number of False and Trues\n", - "print(AssignmentOutPut5.groupby('Class').size()[0].sum())\n", - "print(AssignmentOutPut5.groupby('Class').size()[1].sum())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### **LinearDiscriminantAnalysis** - it is a dimensionality reduction technique used for the supervised classification problems. It too assumes a Gaussian distribution for the numerical input variables.It is used to project the features in higher dimension space into a lower dimension space." - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "MCC: 0.8376165100283083\n", - "Accuracy: 91.72482552342971\n", - "403\n", - "355\n" - ] - } - ], - "source": [ - "from sklearn.model_selection import train_test_split\n", - "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n", - "from sklearn.metrics import matthews_corrcoef\n", - "\n", - "A = Train.values\n", - "# Separating A into output and input components\n", - "X = A[:, 0:11]\n", - "Y = A[:, 11]\n", - "test_size = 0.33\n", - "seed = 6\n", - "selected_features_train, selected_features_test, Y_train, Y_test = train_test_split(X, Y, test_size = test_size, random_state = seed)\n", - "my_model6 = LinearDiscriminantAnalysis()\n", - "my_model6.fit(selected_features_train, Y_train)\n", - "result = my_model6.score(selected_features_test, Y_test)\n", - "\n", - "Prediction = my_model6.predict(selected_features_train)\n", - "print(\"MCC:\", (matthews_corrcoef(Y_train, Prediction)))\n", - "print(\"Accuracy:\", (result*100.0))\n", - "\n", - "AssignmentOutPut6 = my_model6.predict(Test.values) #Assigning the preditions of the model to variable AssignmentOutPut\n", - "AssignmentOutPut6 = pd.DataFrame(AssignmentOutPut6)# Converting AssignmentOutPut6 to a dataframe since its output is an array\n", - "AssignmentOutPut6.columns = ['Class'] # Naming the out put column\n", - "AssignmentOutPut6.index.name = \"Index\" #Creating a column called index\n", - "AssignmentOutPut6['Class'] = AssignmentOutPut6['Class'].map({0.0:False, 1.0:True}) # Converting 0.0 to false and 1.0 to true\n", - "\n", - "AssignmentOutPut6.to_csv('AssignmentOutPut6.csv') # Writing AssignmentOutPut6 to a csv file\n", - "#Printing the number of False and Trues\n", - "print(AssignmentOutPut6.groupby('Class').size()[0].sum())\n", - "print(AssignmentOutPut6.groupby('Class').size()[1].sum())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### **Ada Boost** - it trains predictors sequentially, each trying to correct its predecessor. It works by weighting instances in the dataset by how easy or difficult they are to classify, allowing the algorithm to pay or less attention to them in the construction of subsequent models" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "MCC: 0.8546905980754327\n", - "Confusion_matrix: [[475 30]\n", - " [ 43 455]]\n", - "385\n", - "373\n" - ] - } - ], - "source": [ - "from sklearn.ensemble import AdaBoostClassifier\n", - "from sklearn.tree import DecisionTreeClassifier\n", - "from sklearn.model_selection import train_test_split\n", - "from sklearn.metrics import matthews_corrcoef\n", - "from sklearn.metrics import confusion_matrix\n", - "\n", - "A = Train.values\n", - "# Separating A into output and input components\n", - "\n", - "test_size = 0.33\n", - "seed = 6\n", - "# Split data into training and test sets to evaluate the model’s performance.\n", - "selected_features_train, selected_features_test, Y_train, Y_test = train_test_split(X, Y, test_size = test_size, random_state = seed)\n", - "# Construct and fit a model to the training set. max_depth=1 is used to tell the model that the forest to be composed of trees with a\n", - "# single decision node and two leaves. n_estimators is used to specify the total number of trees in the forest.\n", - "Model7 = AdaBoostClassifier(DecisionTreeClassifier(max_depth=1),n_estimators=200) \n", - "Model7.fit(selected_features_train, Y_train)\n", - "predictions = Model7.predict(selected_features_test)\n", - "print(\"MCC:\", (matthews_corrcoef(Y_test, predictions)))\n", - "print(\"Confusion_matrix:\", confusion_matrix(Y_test, predictions))\n", - "\n", - "AssignmentOutPut7 = Model7.predict(Test.values) #Assigning the preditions of the model to variable AssignmentOutPut7\n", - "AssignmentOutPut7 = pd.DataFrame(AssignmentOutPut7)# Converting AssignmentOutPut7 to a dataframe since its output is an array\n", - "AssignmentOutPut7.columns = ['Class'] # Naming the out put column\n", - "AssignmentOutPut7.index.name = \"Index\" #Creating a column called index\n", - "AssignmentOutPut7['Class'] = AssignmentOutPut7['Class'].map({0.0:False, 1.0:True}) # Converting 0.0 to false and 1.0 to true\n", - "\n", - "AssignmentOutPut7.to_csv('AssignmentOutPut7.csv') # Writing AssignmentOutPut7 to a csv file\n", - "#Printing the number of False and Trues\n", - "print(AssignmentOutPut7.groupby('Class').size()[0].sum())\n", - "print(AssignmentOutPut7.groupby('Class').size()[1].sum())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### **Principle component analysis** - PCA is a common way of speeding up a machine learning algorithm. Its mostly used when a machine learning algorithm is too slow because the input dimension is too high, then PCA is used to speed it up can be a reasonable choice. PCA can also be used for data visualization." - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Using PCA for visualization of data.\n", - "from sklearn.decomposition import PCA\n", - "#A = Train.values\n", - "# Separating A into output and input components\n", - "features = ['FULL_Charge', 'FULL_AcidicMolPerc', 'FULL_AURR980107', 'FULL_DAYM780201', 'FULL_GEOR030101', 'FULL_OOBM850104', 'NT_EFC195', 'AS_MeanAmphiMoment', 'AS_DAYM780201', 'AS_FUKS010112', 'CT_RACS820104']\n", - "x =Train.loc[:, features].values\n", - "y =Train.loc[:,['CLASS']].values\n", - "pca = PCA(n_components=2)\n", - "principalComponents = pca.fit_transform(x)\n", - "principalDf = pd.DataFrame(principalComponents, columns = ['principal_component1', 'principal_component2'])\n", - "FinalDf = pd.concat([principalDf, Train[['CLASS']]], axis = 1)\n", - "FinalDf\n", - "\n", - "#The plot\n", - "fig = plt.figure(figsize = (8,8))\n", - "ax = fig.add_subplot(1,1,1) \n", - "ax.set_xlabel('Principal_Component1', fontsize = 10)\n", - "ax.set_ylabel('Principal_Component2', fontsize = 10)\n", - "ax.set_title('2 component PCA', fontsize = 15)\n", - "plt.scatter(FinalDf.iloc[:, 0], FinalDf.iloc[:, 1], c = FinalDf.iloc[:, 2], cmap ='Spectral') \n", - "#classes = [\"1.0\", \"0.0\"]\n", - "#colors = ['r','g', 'b']\n", - "#for CLASS, color in (classes,colors):\n", - "# indicesToKeep = FinalDf['CLASS'] == CLASS\n", - "# ax.scatter(FinalDf.loc[indicesToKeep, 'principal_component1'], FinalDf.loc[indicesToKeep, 'principal_component2'], c =color )\n", - "ax.legend()\n", - "ax.grid()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### **Using principle component analysis for machine learning**" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "MCC: 0.7507336393432698\n", - "Socre: 0.8753738783649053\n", - "506\n", - "497\n" - ] - } - ], - "source": [ - "from sklearn.model_selection import train_test_split\n", - "from sklearn.decomposition import PCA\n", - "A= Train.values\n", - "X = A[:, 0:11]\n", - "Y = A[:, 11]\n", - "#Make an instance of the Model\n", - "pca = PCA(.95)\n", - "#Splitting data\n", - "selected_features_train, selected_features_test, Y_train, Y_test = train_test_split(X, Y, test_size = test_size, random_state = seed)\n", - "pca = PCA(n_components=2)\n", - "principalComponents = pca.fit_transform(selected_features_train)\n", - "fit_train = pca.fit(selected_features_train) #Fit PCA on training set\n", - "\n", - "#Apply the mapping (transform) to both the training set and the test set.\n", - "selected_features_trainF = pca.transform(selected_features_train)\n", - "selected_features_testF = pca.transform(selected_features_test)\n", - "\n", - "#Importing the model\n", - "from sklearn.linear_model import LogisticRegression\n", - "Model8 = LogisticRegression()\n", - "Model8.fit(selected_features_trainF, Y_train)\n", - "\n", - "#Predicting new data\n", - "Pred = Model8.predict(selected_features_testF)\n", - "print(\"MCC:\", (matthews_corrcoef(Y_test, Pred)))\n", - "print(\"Socre:\", Model8.score(selected_features_testF, Y_test))\n", - "\n", - "AssignmentOutPut8 = Model8.predict(selected_features_testF) #Assigning the preditions of the model to variable AssignmentOutPut8\n", - "AssignmentOutPut8 = pd.DataFrame(AssignmentOutPut8)# Converting AssignmentOutPut8 to a dataframe since its output is an array\n", - "AssignmentOutPut8.columns = ['Class'] # Naming the out put column\n", - "AssignmentOutPut8.index.name = \"Index\" #Creating a column called index\n", - "AssignmentOutPut8['Class'] = AssignmentOutPut8['Class'].map({0.0:False, 1.0:True}) # Converting 0.0 to false and 1.0 to true\n", - "\n", - "AssignmentOutPut8.to_csv('AssignmentOutPut8.csv') # Writing AssignmentOutPut8 to a csv file\n", - "#Printing the number of False and Trues\n", - "print(AssignmentOutPut8.groupby('Class').size()[0].sum())\n", - "print(AssignmentOutPut8.groupby('Class').size()[1].sum())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### The Naive bayes(GaussianNB) algorithm with none rescaled or transformed data gave the best prediction from all the algorithms used." - ] - } - ], - "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.6.6" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/Assignment Colab/nsangi-olga-tendo.ipynb b/Assignment Colab/nsangi-olga-tendo.ipynb index 6a01977..bf41e4f 100644 --- a/Assignment Colab/nsangi-olga-tendo.ipynb +++ b/Assignment Colab/nsangi-olga-tendo.ipynb @@ -5,16 +5,22 @@ "metadata": {}, "source": [ "# **ACE Class competition**\n", - "#### By Nsangi Olga Tendo\n", + "#### *By Nsangi Olga Tendo 2019/HD07/24879U*\n", "## Machine Learning Process:\n", - "#### 1. Have a peek of raw data\n", - "#### 2. Review of dimensions of thedataset.\n", - "#### 3. Review of attribues in the data set\n", - "#### 4. Review the data types of attributes in your data.\n", - "#### 5. Review of missing data(NAs)\n", - "#### 6. Summary of data using descriptive statistics.\n", - "#### 7. Understand the relationships in your data using correlations.\n", - "#### 8. Review the skew of the distributions of each attribute." + "1. Have a peek of raw data\n", + "2. Review of dimensions of thedataset.\n", + "3. Review of attribues in the data set\n", + "4. Review the data types of attributes in your data.\n", + "5. Review of missing data(NAs)\n", + "6. Summary of data using descriptive statistics.\n", + "7. Understand the relationships in your data using correlations.\n", + "8. Data Visualisation\n", + "9. Review the skew of the distributions of each attribute.\n", + "10. Spot checking classification algorithms\n", + "11. Data preparation\n", + "12. Feature selection\n", + "13. Machine learning\n", + "14. References" ] }, { @@ -39,6 +45,7 @@ "# It is defined by the kaggle/python docker image: https://github.com/kaggle/docker-python\n", "# For example, here's several helpful packages to load in \n", "\n", + "#Importing the necessary libraries that are going to be used in the pipeline\n", "import numpy as np # linear algebra\n", "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n", "import matplotlib.pyplot as plt\n", @@ -61,7 +68,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Naming the Training and test dataset using." + "### 1. Naming the Training and test dataset using." ] }, { @@ -330,8 +337,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Dimensions of the train and test data set\n", - "#### This helps in knowing the size of your data set and also give an intiution on what algorithms you could use incase the size is big or small." + "### 2. Dimensions of the train and test data set.\n", + "This helps in knowing the size of your data set and also give an intiution on what algorithms you could use incase the size is big or small." ] }, { @@ -358,7 +365,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Establishing the attributes in the train and test data set" + "### 3. Establishing the attributes in the train and test data set." ] }, { @@ -394,7 +401,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Establishing the data types for each attribute in the train data set. This helps in finding out which columns have data types like strings that may need to be converted to foating points or integers to represent categorical or ordinal values since most machine learning algorithms take in integers or floats for inputs. This can be done using df.dtype method or the df.info() method as shown in the two cells below, tho the df.info() is more informative as its also tells the total number of instances for each column." + "### 4. Establishing the data types for each attribute in the train data set.\n", + "This helps in finding out which columns have data types like strings that may need to be converted to foating points or integers to represent categorical or ordinal values since most machine learning algorithms take in integers or floats for inputs. This can be done using df.dtype method or the df.info() method as shown in the two cells below, tho the df.info() is more informative as its also tells the total number of instances for each column." ] }, { @@ -478,14 +486,54 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Descriptive statistics summary of the data in each column.\n", - "#### This includes measures of central tendencies like teh mean, median and measures of spread like standard, variance, range and interquatile range. The smallest and largest values of each column are also returned. This helps in understanding the distribution of data in each column. This way you can also find out if you have negative values in any attribute. This also helps in understanding the scales at which each attribute is at." + "### 5. Establishing if there are any missing values in the attributes of the data set.\n", + "This helps to give an insight on how to handle the missing values, whether to remove rows that have missing values or establishing a method like the mean,median ect to impute the NAs. " ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "FULL_Charge 0\n", + "FULL_AcidicMolPerc 0\n", + "FULL_AURR980107 0\n", + "FULL_DAYM780201 0\n", + "FULL_GEOR030101 0\n", + "FULL_OOBM850104 0\n", + "NT_EFC195 0\n", + "AS_MeanAmphiMoment 0\n", + "AS_DAYM780201 0\n", + "AS_FUKS010112 0\n", + "CT_RACS820104 0\n", + "CLASS 0\n", + "dtype: int64" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Train.isna().sum()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 6. Descriptive statistics summary of the data in each column.\n", + "This includes measures of central tendencies like teh mean, median and measures of spread like standard, variance, range and interquatile range. The smallest and largest values of each column are also returned. This helps in understanding the distribution of data in each column. This way you can also find out if you have negative values in any attribute. This also helps in understanding the scales at which each attribute is at." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, "outputs": [ { "data": { @@ -679,7 +727,7 @@ "max 103.167000 8.662000 2.192000 1.000000 " ] }, - "execution_count": 8, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -692,19 +740,19 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### From the values above, there are no missing values since all counts in each column is equal. We can also observe that there are negative values in some attributes have a minimum values in negatives." + "From the values above, there are no missing values since all counts in each column is equal. We can also observe that there are negative values in some attributes have a minimum values in negatives." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### Since this is a classification problem, its important to check out the propotions of the values in the class to be predicted as its possible one class may have more values as compared to the others. Incases where one class is higher than another class we could employe methods likes smote to over sample the least represented class so as to have an un biased algorithm." + "Since this is a classification problem, its important to check out the propotions of the values in the class to be predicted as its possible one class may have more values as compared to the others. Incases where one class is higher than another class we could employe methods likes smote to over sample the least represented class so as to have an un biased algorithm." ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -713,7 +761,7 @@ "Text(0, 0.5, 'Distirbution')" ] }, - "execution_count": 9, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, @@ -741,7 +789,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -753,7 +801,7 @@ "dtype: int64" ] }, - "execution_count": 10, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -767,54 +815,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### From above, the entries in the class attribute are equal." + "From above, the entries in the class attribute are equal." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### Establishing if there are any missing values in the attributes of the data set. This helps to give an insight on how to handle the missing values, whether to remove rows that have missing values or establishing a method like the mean,median ect to impute the NAs. " - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "FULL_Charge 0\n", - "FULL_AcidicMolPerc 0\n", - "FULL_AURR980107 0\n", - "FULL_DAYM780201 0\n", - "FULL_GEOR030101 0\n", - "FULL_OOBM850104 0\n", - "NT_EFC195 0\n", - "AS_MeanAmphiMoment 0\n", - "AS_DAYM780201 0\n", - "AS_FUKS010112 0\n", - "CT_RACS820104 0\n", - "CLASS 0\n", - "dtype: int64" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Train.isna().sum()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Correlation between attributes.\n", - "#### This is done to establish the relationship between variables and how they may change or may not change each other. The pearson's correlation method is going to be used since it assumes normal distribution on attributes involved. A value of 0 shows no correlation between the attributes, while a correlation of -1 or 1 shows full negative or positive correlation between variables." + "### 7. Correlation between attributes.\n", + "This is done to establish the relationship between variables and how they may change or may not change each other. The pearson's correlation method is going to be used since it assumes normal distribution on attributes involved. A value of 0 shows no correlation between the attributes, while a correlation of -1 or 1 shows full negative or positive correlation between variables." ] }, { @@ -1113,7 +1122,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### From the summary above, AS_DAYM780201 and FULL_DAYM780201 are the strongest positively correlated with a correlation of 0.894191 while FULL_AcidicMolPerc and FULL_Charge are the strongest negatively correlated attributes. This correlation can further be observed by plotting a heat map using seaborn to show the correlation of attributes with each other as shown below" + "From the summary above, AS_DAYM780201 and FULL_DAYM780201 are the strongest positively correlated with a correlation of 0.894191 while FULL_AcidicMolPerc and FULL_Charge are the strongest negatively correlated attributes. This correlation can further be observed by plotting a heat map using seaborn to show the correlation of attributes with each other as shown below" ] }, { @@ -1124,7 +1133,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 13, @@ -1153,7 +1162,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Using visualisation to understand the data at hand. Histograms, Density plots and Box and whisker plots are some of the plots used to understand the attribute distribution. Histograms were used. They're used to summarize discrete or continuous data by showing the number(frequency) of data points that fall within a specified range of values. Histograms graphically show center) of the data, spread (i.e., the scale) of the data, skewness of the data, presence of outliers and presence of multiple modes in the data" + "### 8. Using visualisation to understand the data at hand. \n", + "Histograms, Density plots and Box and whisker plots are some of the plots used to understand the attribute distribution. Histograms were used. They're used to summarize discrete or continuous data by showing the number(frequency) of data points that fall within a specified range of values. Histograms graphically show center) of the data, spread (i.e., the scale) of the data, skewness of the data, presence of outliers and presence of multiple modes in the data" ] }, { @@ -1179,25 +1189,18 @@ "plt.show()" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### From the histograms above, we can observe that attributes AS_MeanAmphiMoment, AS_DAYM780201, AS_FUKS010112, FULL_DAYM780201, FULL_GEOR030101, FULL_AURR980107,FULL_CHARGE have a normal. We can also tell from these plots that attribute CT_RACS820104 and FULL_AcidicMolPerc are skewed to the right. We can also tell that attributes NT_EFC195 and CLASS are categorical attributes. This can also be observed using density plots as shown below." + "From the histograms above, we can observe that attributes AS_MeanAmphiMoment, AS_DAYM780201, AS_FUKS010112, FULL_DAYM780201, FULL_GEOR030101, FULL_AURR980107,FULL_CHARGE have a normal. We can also tell from these plots that attribute CT_RACS820104 and FULL_AcidicMolPerc are skewed to the right. We can also tell that attributes NT_EFC195 and CLASS are categorical attributes. This can also be observed using density plots as shown below." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### Using Density plots. Density plots are used to observe the distribution of a variable in a dataset. The peaks of a Density Plot help display where values are concentrated over the interval. Density plots give a more precise location and also gives a continuous distribution view. " + "Using Density plots. Density plots are used to observe the distribution of a variable in a dataset. The peaks of a Density Plot help display where values are concentrated over the interval. Density plots give a more precise location and also gives a continuous distribution view. " ] }, { @@ -1237,14 +1240,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### From the above plots, FULL_Charge, FULL_AURR980107, FULL_DAYM780201, FULL_GEOR030101, CT_RACS820104, FULL_OOBM850104, AS_FUKS010112, AS_DAYM780201 show a normal distribution of variables. CLASS and NT_EFC195 are categorical data CLASS having equal number of instances while NT_EFC195 has a category that has almost all instances. \tFULL_AcidicMolPerc and AS_MeanAmphiMoment have more than one peak meaning that the data points are distribute at 2 peak for FULL_AcidicMolPerc and 3 peaks for AS_MeanAmphiMoment\t" + "From the above plots, FULL_Charge, FULL_AURR980107, FULL_DAYM780201, FULL_GEOR030101, CT_RACS820104, FULL_OOBM850104, AS_FUKS010112, AS_DAYM780201 show a normal distribution of variables. CLASS and NT_EFC195 are categorical data CLASS having equal number of instances while NT_EFC195 has a category that has almost all instances. \tFULL_AcidicMolPerc and AS_MeanAmphiMoment have more than one peak meaning that the data points are distribute at 2 peak for FULL_AcidicMolPerc and 3 peaks for AS_MeanAmphiMoment\t" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### Checking for the skewness of the data. Skewness is deviation from a normal distribution. The data may be skewed to the left or to the right of the normal distribution curve (bell shaped). Since many machine learning algorithms assume normal distribution,this allows one to know what attributes need to be corrected of skewness to improve the accuracy of the model. Skewness can be observed with bar plots of .skew()." + "### 9. Checking for the skewness of the data. \n", + "Skewness is deviation from a normal distribution. The data may be skewed to the left or to the right of the normal distribution curve (bell shaped). Since many machine learning algorithms assume normal distribution,this allows one to know what attributes need to be corrected of skewness to improve the accuracy of the model. Skewness can be observed with bar plots of .skew()." ] }, { @@ -1255,7 +1259,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 16, @@ -1307,15 +1311,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### From the check above, attribute NT_EFC195 has skewed data and this could alter final results of the model. The data could be transformed or the attributed drop(not used in building a classifier." + "From the check above, attribute NT_EFC195 has skewed data and this could alter final results of the model. The data could be transformed or the attributed drop(not used in building a classifier." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### Spot checking classification algorithms since its a classification problem at hand.\n", - "#### This is done to know which algorithm is best suited for the problem at hand. Two linear machine learning algorithms(Logistic regression and Linear discriminant analysis) and four non-linear machine learning algorithm were used(k-nearest neighbors, naive bayes, support vector machines and classific regression tress. " + "### 10. Spot checking classification algorithms since its a classification problem at hand.\n", + "This is done to know which algorithm is best suited for the problem at hand. Two linear machine learning algorithms(Logistic regression and Linear discriminant analysis) and four non-linear machine learning algorithm were used(k-nearest neighbors, naive bayes, support vector machines and classific regression tress. " ] }, { @@ -1327,18 +1331,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "('LR', 0.8342865299822478)\n", + "('LCR', 0.8342865299822478)\n", "('LDA', 0.8377162908048379)\n", "('KNN', 0.8690586462107053)\n", "('CART', 1.0)\n", "('NB', 0.8407203694376205)\n", "('SVM', 0.8187103751493263)\n", - "('ABC', 0.8848771929251248)\n" + "('ABC', 0.8848771929251248)\n", + "('RFC', 1.0)\n", + "('GBC', 0.9355236060852458)\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAEVCAYAAAAb/KWvAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAHOlJREFUeJzt3X98JHWd5/HXmzAwpyLOOKMoDMycjl4mUUEi7mr8kdVdkfVAV1Ymiwo+onh7GndB70TDQ0d2469bf0ZcjyWI6CaArrjjHSx4m6BExSWzIjsQwQFRZgEdnBFkcSCMn/ujKjM9PZ2kk3R3dVW/n49HPx5dVd+u/lSl8ulvf77VVYoIzMysWA7KOgAzM6s9J3czswJycjczKyAndzOzAnJyNzMrICd3M7MCcnK3iiRdIumv67Tu0yVdO8fyl0vaXo/3zjtJ75d0UdZxWPNzcm9xkq6TtEvSoY16z4j4+4j4o5IYQtIzG/X+SrxL0lZJ/yFpu6SvSnpOo2JYrIj4cES8Nes4rPk5ubcwSWuBlwABnNyg9zy4Ee8zj88AfwG8C1gJPAv4BvDHWQY1nybZd5YTTu6t7c3ADcAlwBlzNZT0PyXdK+keSW8t7W1LOlzSpZJ2SPqZpPMkHZQuO1PSdyV9StJOYFM6byJd/p30LX4k6SFJp5W857sl/TJ937eUzL9E0uclXZ2+5ruSjpD06fRbyI8lHTfLdqwH3gH0RsRYRDwSEQ+n3yY+usDt+bWkOyW9KJ1/dxrvGWWxfkHStyT9RtK3JR1Tsvwz6eselLRF0ktKlm2S9DVJX5H0IHBmOu8r6fLl6bJfpbHcKOmp6bKnS9osaaekbZLeVrbeK9Jt/I2kWyR1zfX3t/xxcm9tbwb+Pn28aiYxlJN0InAO8ErgmcDLypoMAYcD/zld9mbgLSXLXwjcCTwFGCx9YUS8NH36vIh4QkRcnk4fka7zSKAPuEDSipKXvgE4D1gFPAJ8H/jXdPprwCdn2eZXANsj4l9mWV7t9twMPBkYAS4DXkCyb94IfE7SE0ranw78VRrbTST7e8aNwLEk3yBGgK9KWl6y/JR0e55U9jpIPpAPB9aksfw34LfpslFgO/B04FTgw5JeUfLak9O4nwRsBj43x/6wHHJyb1GSuoFjgCsiYgtwB/BnszR/A/DFiLglIh4GPlSynjbgNOB9EfGbiLgL+ATwppLX3xMRQxHxWET8lupMA+dHxHREXAU8BDy7ZPmVEbElInYDVwK7I+LSiNgDXA5U7LmTJMF7Z3vTKrfnpxHxxZL3WpPG+khEXAs8SpLoZ/zfiPhORDwCDAC/L2kNQER8JSJ+le6bTwCHlm3n9yPiGxHxuwr7bjrdnmdGxJ50fzyYrrsbeG9E7I6Im4CLyrZhIiKuSrfhy8DzZtsnlk9O7q3rDODaiLg/nR5h9tLM04G7S6ZLn68CDgF+VjLvZyQ97krtq/WriHisZPphoLQ3/IuS57+tMF3adr/1Ak+b432r2Z7y9yIi5nr/vdsfEQ8BO0n26UzpaUrSA5J+TdITX1XptRV8GbgGuCwtl31c0rJ03Tsj4jdzbMN9Jc8fBpa7pl8sTu4tSNJ/IumNv0zSfZLuA84GniepUg/uXuCokuk1Jc/vJ+lBHlMy72jg30umm+nSo/8MHDVHjbma7VmovfsrLdesBO5J6+vvJflbrIiIJwEPACp57az7Lv1W86GI2AC8CHgNSQnpHmClpMNquA2WM07urem1wB5gA0m991igHbieJDmUuwJ4i6R2SY8DPjCzIP1afwUwKOmwdLDwHOArC4jnFyT17bqLiJ8AnwdGlZxPf0g6MLlR0rk12p5yJ0nqlnQISe39BxFxN3AY8BiwAzhY0geAJ1a7Ukk9kp6TlpIeJPlQ2pOu+3vAR9Jtey7JuEV5zd4KzMm9NZ1BUkP/eUTcN/MgGVQ7vfzreURcDXwWGAe2kQxeQjKQCdAP/AfJoOkESYnn4gXEswn4UnrGxxsWuU0L8S6Sbb0A+DXJeMPrgG+my5e6PeVGgA+SlGOOJxlghaSkcjVwO0nZZDcLK2EdQTLY+iAwBXybfR9CvcBakl78lcAHI+JbS9gGyxn5Zh22UJLaga3AoWV1cSsj6RKSs3POyzoWay3uuVtVJL0uLWGsAD4GfNOJ3ax5Oblbtd5OUhu+g6Re/+fZhmNmc3FZxsysgNxzNzMrICd3M7MCcnI3MysgJ3czswJycjczKyAndzOzAnJyNzMrICd3M7MCcnI3MysgJ3czswJycjczKyAndzOzAnJyNzMrICd3M7MCyuxu56tWrYq1a9dm9fZmZrm0ZcuW+yNi9XztMkvua9euZXJyMqu3NzPLJUk/q6adyzJmZgXk5G5mVkBO7mZmBeTkbmZWQE7uZmYFNG9yl3SxpF9K2jrLckn6rKRtkm6W9Pzah2lmZgtRTc/9EuDEOZa/GlifPs4C/nbpYZmZ2VLMm9wj4jvAzjmanAJcGokbgCdJelqtAjQzs4WrxY+YjgTuLpnens67t7yhpLNIevccffTRNXhrkLTg10RETd67Fhx/dvIcexHkff83e/y1SO6VtrDiFkTEhcCFAF1dXTXZytl2lqSmOhBm4/izk+fYiyDv+7/Z46/F2TLbgTUl00cB99RgvftZuXIlkqp+AAtqv3LlylqHXKj4zRbLx342atFz3wy8U9JlwAuBByLigJLMUu3atauun4aL+Yq1EHmP32yx8n7sr1y5kl27di3oNQuJacWKFezcOdew5uLMm9wljQIvB1ZJ2g58EFgGEBFfAK4CTgK2AQ8Db6l5lGZ2gGav+RZFXj+c5k3uEdE7z/IA3lGziKwp5bX3UmTNXvO1bGV2yV/Ll7z2XsxaVW6Se3zwibDp8Pqu38xqzv+72VBWX9+6urpiITfrqPdXzbp/la3jwb3vPR6o26rzvv8XU1aqVr1LSvWMHeoff96PnWZbv6QtEdE1X7vc9NzzTh96sP4HyKa6rT736llW8plW1ox8VUgzswJycjczKyAndzOzAnLN3cxsDnk928fJ3aqS1wPcbKnyejKEk7tVJa8HeBH4g9UWw8ndrMn5g9UWwwOqZmYF5ORuZlZATu5mZgXk5G5mVkAeULWWUM8zTny2iTUjJ3drCfU848Rnm1gzclnGzKyA3HM3y4F6XpZ3xYoVdVu3ZcfJ3azJLbSc5HuoGji5N5R7X2bWKE7uDeLel5k1kpO7mdk88vit28ndzGwOef3WnavknsdPT7N6mev/YbZlzZB0rDFyk9zz+ulpVi8+vm0uuUnuZpZf/tbdeE7uZlZX/tadDSd3q5p7X2b54eRuVXHvyyxffOEwM7MCqiq5SzpR0m2Stkk6t8LyoyWNS/qhpJslnVT7UM3MrFrzJndJbcAFwKuBDUCvpA1lzc4DroiI44CNwOdrHaiZmVWvmp77CcC2iLgzIh4FLgNOKWsTwMztaA4H7qldiGZmtlDVDKgeCdxdMr0deGFZm03AtZL6gccDr6xJdGZmtijV9Nwrnf9WfhpEL3BJRBwFnAR8WdIB65Z0lqRJSZM7duxYeLRmZlaVapL7dmBNyfRRHFh26QOuAIiI7wPLgVXlK4qICyOiKyK6Vq9evbiIC0ZSxcd8y5pF3uM3K6pqkvuNwHpJ6yQdQjJgurmszc+BVwBIaidJ7u6aVyEiFvxoJnmP32yxmr1jM2/NPSIek/RO4BqgDbg4Im6RdD4wGRGbgXcDfyfpbJKSzZnh/2IzK7BmT3FV/UI1Iq4Criqb94GS57cCL65taGZmtlj+haqZWQE5uZuZFZCTu1lBjI6O0tnZSVtbG52dnYyOjmYdkmXIV4U0K4DR0VEGBgYYHh6mu7ubiYkJ+vr6AOjt7c04OsuCshrx7erqisnJybqt35ectVL1PB6a4Vjr7OxkaGiInp6evfPGx8fp7+9n69atGUY2u8WcGpj1fm4GkrZERNe87ZzcrRUUPbm3tbWxe/duli1btnfe9PQ0y5cvZ8+ePRlGZrVWbXJ3zd2sANrb25mYmNhv3sTEBO3t7RlFZFlzcreWMduvBpf6aIZbBA4MDNDX18f4+DjT09OMj4/T19fHwMBA1qFZRjygai1hIWWTZiizLNTMoGl/fz9TU1O0t7czODjowdQW5pq7WRkfO9bMXHM3M2thTu5mZgWU+5r7XOfKzrbMX7nNrOhy33P39cTNEr78gJXKfc/dzHz5ATtQ7nvuZgaDg4MMDw/T09PDsmXL6OnpYXh4mMHBwaxDs4wU9lRIs8XK46mQvvxA6/CpkGYtxJcfsHJO7mYF4MsPZK/ZBrQ9oGpWAL78QLaacUDbNXezMnmsuVu2Gnk9/Za/nrvZYjm520I1ckDbA6pmZg3SjAPaTu5mZkvUjAPaHlA1M1uiZhzQds3drIxr7tbMXHM3M2thTu5mZgXk5G5mVkBO7mZmBeTkbmZWQE7uZmYFVFVyl3SipNskbZN07ixt3iDpVkm3SBqpbZhmZrYQ8yZ3SW3ABcCrgQ1Ar6QNZW3WA+8DXhwRHcBf1iHWltBslw0tMkkVH/MtM8uDan6hegKwLSLuBJB0GXAKcGtJm7cBF0TELoCI+GWtA20FzXjZ0CLzD5WsyKopyxwJ3F0yvT2dV+pZwLMkfVfSDZJOrLQiSWdJmpQ0uWPHjsVFXGC+D6aZ1Uo1yb3Sd9HyLs/BwHrg5UAvcJGkJx3woogLI6IrIrpWr1690FgLb2pqiu7u7v3mdXd3MzU1lVFEZpZX1ST37cCakumjgHsqtPnHiJiOiJ8Ct5Eke1uAZrxsqFmjeLyptqpJ7jcC6yWtk3QIsBHYXNbmG0APgKRVJGWaO2sZaCtoxsuGmjXCzHjT0NAQu3fvZmhoiIGBASf4pYiIeR/AScDtwB3AQDrvfODk9LmAT5IMsv4bsHG+dR5//PFhBxoZGYmOjo446KCDoqOjI0ZGRrIOaUHyHr9lo6OjI8bGxvabNzY2Fh0dHRlF1LyAyagib/uSv1Yzs53tk/V1ra35NfI2dXnnS/5aw/lsH1ssjzfVnpO71YzP9rHF8nhT7fk2e1YzM72vnp6evfPc+7JqNONt6vLOyd1qZqb3Vanmbjaf3t5eJ/MacnK3mnHvy6x5+GwZM7Mc8dkyZmYtzMndzKyAnNzNzArIyd3MrICc3M3MCsjJ3cysgJzczcwKyMndzKyAnNzNzArIyd3MrICc3M3MCsjJ3cysgJzczcwKyMndzKyAnNzNzArIyd3MrICc3M3MCsjJ3cysgJzczcwKyMndzKyAnNzNzArIyd3MrICc3M3MCsjJ3cysgJzczcwKyMndzKyAqkrukk6UdJukbZLOnaPdqZJCUlftQjQzs4WaN7lLagMuAF4NbAB6JW2o0O4w4F3AD2odpOXH6OgonZ2dtLW10dnZyejoaNYhmTVEsx37B1fR5gRgW0TcCSDpMuAU4Naydn8FfBx4T00jtNwYHR1lYGCA4eFhuru7mZiYoK+vD4De3t6MozOrn6Y89iNizgdwKnBRyfSbgM+VtTkO+If0+XVA1yzrOguYBCaPPvrosGLp6OiIsbGx/eaNjY1FR0dHRhGZNUYjj31gMubJ2xGBkrazk/SnwKsi4q3p9JuAEyKiP50+CBgDzoyIuyRdB7wnIibnWm9XV1dMTs7ZxHKmra2N3bt3s2zZsr3zpqenWb58OXv27MkwMrP6auSxL2lLRMw7rlnNgOp2YE3J9FHAPSXThwGdwHWS7gJ+D9jsQdXW097ezsTExH7zJiYmaG9vzygis8ZoxmO/muR+I7Be0jpJhwAbgc0zCyPigYhYFRFrI2ItcANw8nw9dyuegYEB+vr6GB8fZ3p6mvHxcfr6+hgYGMg6NLO6asZjf94B1Yh4TNI7gWuANuDiiLhF0vkktZ/Nc6/BWsXMwFF/fz9TU1O0t7czODjowVQrvGY89uetudeLa+5mZgtXy5q7mZnljJO7mVkBObmbmRWQk7tZqtl+Pm62FNVcfsCs8Jry5+NmS+CzZcyAzs5OhoaG6Onp2TtvfHyc/v5+tm7dmmFkZvur9mwZJ3czfOkEyw+fCmm2AM3483GzpXByN6M5fz5uthQeUDWjOX8+brYUrrmbmeWIa+5mZi3Myd3MrICc3M3MCsjJ3cysgJzczcwKyMndzKyAnNzNzArIyd3MrICc3M3MCsjJ3cysgJzczcwKyMndzKyAnNzNzArIyd3MrICc3M3MCsjJ3cysgJzczcwKyMndzKyAnNzNzArIyd3MrICqSu6STpR0m6Rtks6tsPwcSbdKulnSP0s6pvahmplZteZN7pLagAuAVwMbgF5JG8qa/RDoiojnAl8DPl7rQC0fRkdH6ezspK2tjc7OTkZHR7MOyawlHVxFmxOAbRFxJ4Cky4BTgFtnGkTEeEn7G4A31jJIy4fR0VEGBgYYHh6mu7ubiYkJ+vr6AOjt7c04OrPWUk1Z5kjg7pLp7em82fQBVy8lKMunwcFBhoeH6enpYdmyZfT09DA8PMzg4GDWoZm1nGqSuyrMi4oNpTcCXcD/mmX5WZImJU3u2LGj+igtF6ampuju7t5vXnd3N1NTUxlFtDAuKVmRVJPctwNrSqaPAu4pbyTplcAAcHJEPFJpRRFxYUR0RUTX6tWrFxOvNbH29nYmJib2mzcxMUF7e3tGEVVvpqQ0NDTE7t27GRoaYmBgwAne8isi5nyQ1OXvBNYBhwA/AjrK2hwH3AGsn299M4/jjz8+rFhGRkZi3bp1MTY2Fo8++miMjY3FunXrYmRkJOvQ5tXR0RFjY2P7zRsbG4uOjo6MIjKrDJiMKnKskrZzk3QS8GmgDbg4IgYlnZ++yWZJ/w94DnBv+pKfR8TJc62zq6srJicnF/5pZE1tdHSUwcFBpqamaG9vZ2BgIBeDqW1tbezevZtly5btnTc9Pc3y5cvZs2dPhpGZ7U/Slojomq9dVee5R8RVEfGsiHhGRAym8z4QEZvT56+MiKdGxLHpY87EXk+um2art7eXrVu3smfPHrZu3ZqLxA75LimZVVKoX6i6bmqLNTAwQF9fH+Pj40xPTzM+Pk5fXx8DAwNZh2a2ONXUburxqEfN3XVTW4qRkZHo6OiIgw46KDo6OnIxVmCth1rW3OuhHjV3103NrOhqWnPPC9dNzcwShUrurpuamSWqubZMbsycmdHf37/3VLzBwcHcnLFhZlYrheq5Q35PxTNrdT6NubYK1XM3s3zyFUVrr1Bny5hZPnV2djI0NERPT8/eeePj4/T397N169YMI2s+1Z4t4+RuZpnzaczVa8lTIc0sn3wac+05uTcZDypZK/JpzLXnAdUm4kEla1U+jbn2XHNvIh5UMrP5eEA1hzyoZGbz8YBqDnlQycxqxcm9iXhQycxqxQOqTcSDSmZWK665m5nliGvuZmYtzMndzKyAnNzNzArIyd3MrICc3M3MCsjJ3cysgJzczcwKyMndzKyAnNzNzGqg2e7F4MsPmJktUTPei8GXHzAzW6JG3ovB13M3M2uQRt6LwdeWMTNrkGa8F0NVyV3SiZJuk7RN0rkVlh8q6fJ0+Q8kra11oGZmzaoZ78Uw74CqpDbgAuAPge3AjZI2R8StJc36gF0R8UxJG4GPAafVI2Azs2bTjPdimLfmLun3gU0R8ap0+n0AEfGRkjbXpG2+L+lg4D5gdcyxctfczcwWrpY19yOBu0umt6fzKraJiMeAB4AnVwjqLEmTkiZ37NhRxVubmdliVJPcVWFeeY+8mjZExIUR0RURXatXr64mPjMzW4Rqkvt2YE3J9FHAPbO1ScsyhwM7axGgmZktXDXJ/UZgvaR1kg4BNgKby9psBs5In58KjM1Vbzczs/qa92yZiHhM0juBa4A24OKIuEXS+cBkRGwGhoEvS9pG0mPfWM+gzcxsbpn9QlXSDuBndXyLVcD9dVx/vTn+7OQ5dnD8Wat3/MdExLyDlpkl93qTNFnN6ULNyvFnJ8+xg+PPWrPE78sPmJkVkJO7mVkBFTm5X5h1AEvk+LOT59jB8WetKeIvbM3dzKyVFbnnbmbWsgqR3CU9VGHeJkn/LukmSbdKyu7ybGWqiPcnkr4uaUNZm9WSpiW9vXHRHhDnQyXPT0pjPTqN/2FJT5mlbUj6RMn0eyRtamDcR0i6TNId6fFwlaRnpcvOlrRb0uEl7V8u6QFJP5T0Y0l/k85/S/o3uknSo5L+LX3+0UZtS0mMs+7TsuPpx5L+VlLm/++SBiTdIunmNLarJX2krM2xkqbS53dJur5s+U2Sant7owWQ9Lp03/+XdHqtpN+mcf1I0vckPbuk/QmSvpNeNv3Hki6S9Lh6x5n5H7vOPhURxwKnAP9b0rL5XpCxT0XEsRGxHrgcGJNUej7rnwI3AJl/UEl6BTAEnBgRP09n3w+8e5aXPAL8iaRVjYivlCQBVwLXRcQzImID8H7gqWmTXpJfYr+u7KXXR8RxwHHAayS9OCK+mP6NjiW5DEdPOn3AfQ4aYL59OnP8bwCeA7ysYZFVkF5h9jXA8yPiucArgY9y4OXBNwIjJdOHSZq5vEl2d7/YpxeYYP8fa96RHgfPA75Ecnwh6anAV4H3RsSzgXbgn4DD6h1k0ZM7ABHxE+BhYEXWsVQrIi4HrgX+rGR2L0nyPEpS+ZU5G0bSS4C/A/44Iu4oWXQxcJqklRVe9hjJQNPZDQixXA8wHRFfmJkRETdFxPWSngE8ATiPWT40I+K3wE0ceDXUrFW7Tw8BlgO76h7R3J4G3B8RjwBExP0R8W3g15JeWNLuDcBlJdNXsO8DoBcYbUSwlUh6AvBikntYzPZL/Ceyb1+/A/hSRHwfIBJfi4hf1DvWlkjukp4P/CQifpl1LAv0r8DMV781wBER8S/sf7A32qHAPwKvjYgfly17iCTB/8Usr70AOL20/NEgncCWWZbNJIvrgWeXlpVmSFoBrAe+U7cIF2+ufXq2pJuAe4HbI+KmxoZ2gGuBNZJul/R5STPfJEZJE6Wk3wN+lXbIZnwN+JP0+X8FvtmogCt4LfBPEXE7sDPNLQDPSMsydwDnAJ9M58917NVV0ZP72ZJuA34AbMo4lsUovZTyRpKkDkmvJqvSzDTwPZKeSyWfBc6Q9MTyBRHxIHAp8K76hbdgG4HLIuJ3wNdJSl8zXiLpZpKbz/yfiLgviwDnMs8+nSnLPAV4vJK7pGUmIh4CjgfOAnYAl0s6k+R4PjUdE9jIgT3zncCuNP4pkm/hWell37eK0v/DmbLMM4C/pAlOhyx6cv9UWuc6DbhU0vKsA1qg40gOZkgOojMl3UVyFc7nSVqfQUy/I/na/AJJ7y9fGBG/JqmX/vdZXv9pkg+Gx9ctwgPdQpJU9iPpuSQ98m+l+3Uj+39oXp/Whp8D/LmkYxsQ62LMuU8jYpqkzvvSRgY1Syx7IuK6iPgg8E7g9RFxN3AXyZjA69nXiSl1Ocm3lCxLMk8G/gC4KD1e/gdJbim/n8Vm9u3risdeIxQ9uQMQEV8HJtl3WeKmJ+n1wB8Bo+nI++Mj4siIWBsRa4GPkNHVNyPiYZKBsdMlVerBfxJ4OxWuOhoRO0n+eWfr+dfDGHCopLfNzJD0AuAzJLeHXJs+ng4cKemYsphvJ9nf721gzFWbb5+mA8ovAu6otLxRJD27rENyLPsuHjgKfIqkB7y9wsuvBD5OcnXarJwKXBoRx6THyxrgpyT3uCjVzb59/TmSb7J7xxQkvVHSEfUOtijJ/XGStpc8zqnQ5nzgnGY4HYzZ4z07rdv9BHgj8AcRsYOkN3ll2Tr+gQzPmkkTyonAeZJOKVt2P0m8h87y8k+QXDmvIdJ7C7wO+EMlp0LeQlKmezkH7tcrqfyh+QXgpZLW1THUpai0T2dq7ltJPmg/3/Co9vcE4EtKTkW9meQsnk3psq8CHew/kLpXRPwmIj4WEY82JNLKZvs/fD/7au4/Aj4MvBUgHTjdCPxNeirkFPAS4MF6B+tfqJqZFVAz9GLNzKzGnNzNzArIyd3MrICc3M3MCsjJ3cysgJzczcwKyMndzKyAnNzNzAro/wNIyFKiIllrtgAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1360,6 +1366,8 @@ "from sklearn.naive_bayes import GaussianNB\n", "from sklearn.svm import SVC\n", "from sklearn.ensemble import AdaBoostClassifier\n", + "from sklearn.ensemble import RandomForestClassifier\n", + "from sklearn.ensemble import GradientBoostingClassifier\n", "from sklearn.metrics import matthews_corrcoef\n", "\n", "#split the dataset \n", @@ -1369,13 +1377,15 @@ "Y = A[:, 11]\n", "# prepare models and add them to a list\n", "models = []\n", - "models.append(('LR', LogisticRegression()))\n", + "models.append(('LCR', LogisticRegression()))\n", "models.append(('LDA', LinearDiscriminantAnalysis()))\n", "models.append(('KNN', KNeighborsClassifier()))\n", "models.append(('CART', DecisionTreeClassifier()))\n", "models.append(('NB', GaussianNB()))\n", "models.append(('SVM', SVC()))\n", "models.append(('ABC', AdaBoostClassifier()))\n", + "models.append(('RFC', RandomForestClassifier()))\n", + "models.append(('GBC', GradientBoostingClassifier()))\n", "\n", "#print(models)\n", "\n", @@ -1415,8 +1425,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### **Data Preparation.**\n", - "#### This is important because this finds a way to best expose the structure of the problem to machine learning algorithim intended to be used. Since the data has attributes of varying scales, its important to use one of the methods for data preparation like rescaling, standardization, normalization or binarization for better prediction. Here, rescaling is used to have all the attribute on the same scale." + "### 11. Data Preparation.\n", + "This is important because this finds a way to best expose the structure of the problem to machine learning algorithim intended to be used. Since the data has attributes of varying scales, its important to use one of the methods for data preparation like rescaling, standardization, normalization or binarization for better prediction. Here, **rescaling** is used to have all the attribute on the same scale." ] }, { @@ -1457,7 +1467,7 @@ "metadata": {}, "source": [ "#### Standardization\n", - "#### It is a useful technique to transform attributes with a Gaussian distribution and differing means and standard deviations to a standard Gaussian distribution with a mean of 0 and a standard deviation of 1" + "It is a useful technique to transform attributes with a Gaussian distribution and differing means and standard deviations to a standard Gaussian distribution with a mean of 0 and a standard deviation of 1" ] }, { @@ -1500,8 +1510,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### **Feature selection**\n", - "#### Statistical tests can be used to select those features that have the strongest relationship with the output variable. Feature selection is done on non transformed data using select k best using he univariate statistic F was used since it can work best with data containg negative values as opposed to chi2 that doesnt take in negative values." + "### 12. Feature selection\n", + "Statistical tests can be used to select those features that have the strongest relationship with the output variable. Feature selection is done on non transformed data using select k best using he univariate statistic **F** was used since it can work best with data containg negative values as opposed to chi2 that doesnt take in negative values." ] }, { @@ -1646,14 +1656,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### SelectKBest using the f statistic, gives scores to each attribute and takes the specified number of attributes with the highest scores. Attributes AS_MeanAmphiMoment, FULL_AcidicMolPerc, FULL_AURR980107, FULL_DAYM780201, FULL_Charge, FULL_OOBM850104, AS_DAYM780201 and CT_RACS820104 were the selected features." + "SelectKBest using the f statistic, gives scores to each attribute and takes the specified number of attributes with the highest scores. Attributes AS_MeanAmphiMoment, FULL_AcidicMolPerc, FULL_AURR980107, FULL_DAYM780201, FULL_Charge, FULL_OOBM850104, AS_DAYM780201 and CT_RACS820104 were the selected features." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### Feature selection using SelectKBest, Chi2 statistical test since there are no negative values in the attributes after rescaling with the minmax scaler." + "Feature selection using SelectKBest, **Chi2** statistical test since there are no negative values in the attributes after rescaling with the minmax scaler." ] }, { @@ -1797,14 +1807,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### From the dataframe above, AS_MeanAmphiMoment has the highest score of 244.227728 followed by NT_EFC195, then FULL_AcidicMolPerc and like that till the last attribute in dataframe, FULL_GEOR030101 that has lowwest score of 4.788691." + "From the dataframe above, AS_MeanAmphiMoment has the highest score of 244.227728 followed by NT_EFC195, then FULL_AcidicMolPerc and like that till the last attribute in dataframe, FULL_GEOR030101 that has lowwest score of 4.788691." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### Feature selection using the recursive feature selection method with LogisticRegression - it works by recursively removing attributes and building a model on those attributes that remain. It uses the model accuracy to identify which attributes (and combination of attributes) contribute the most to predicting the target attribute" + "Feature selection using the **recursive feature selection** method with **LogisticRegression.**\n", + "It works by recursively removing attributes and building a model on those attributes that remain. It uses the model accuracy to identify which attributes (and combination of attributes) contribute the most to predicting the target attribute" ] }, { @@ -1934,23 +1945,26 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### From the dataframe above, FULL_AURR980107 has the highest rank of 2 followed by FULL_Charge, then FULL_AcidicMolPerc and like that till the last attribute in dataframe, AS_FUKS010112." + "From the dataframe above, FULL_AURR980107 has the highest rank of 2 followed by FULL_Charge, then FULL_AcidicMolPerc and like that till the last attribute in dataframe, AS_FUKS010112." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### **Evaluating Machine learning Alogorithms** - the best way to evaluate the performance of an algorithm would be to make predictions for new data to which you already know the answers. Evaluation shoud be done on data that is not used to train the algorithm. The evaluation is an estimate that we can use to talk about how well we think the algorithm may actually do in practice.\n", - "#### **Split into Train and Test set**\n", - "#### It's the simplest method that we can use to evaluate the performance of a machine learning algorithm is to use dierent training and testing datasets. The train dataset is split it into two parts. The algorithm is trained on one part and predictions are made on the second part and evaluate the predictions against the expected results. The size of the split can depend on the size of your dataset, although it is common to use 67% of the data for training and the remaining 33% for testing. This algorithm evaluation technique is very fast. It is ideal for large datasets (millions of records) where there is strong evidence that both splits of the data are representative of the underlying problem. " + "### 13. Evaluating Machine learning Alogorithms\n", + "The best way to evaluate the performance of an algorithm would be to make predictions for new data to which you already know the answers. Evaluation shoud be done on data that is not used to train the algorithm. The evaluation is an estimate that we can use to talk about how well we think the algorithm may actually do in practice.\n", + "### Split into Train and Test set\n", + "It's the simplest method that we can use to evaluate the performance of a machine learning algorithm is to use dierent training and testing datasets. The train dataset is split it into two parts. The algorithm is trained on one part and predictions are made on the second part and evaluate the predictions against the expected results. The size of the split can depend on the size of your dataset, although it is common to use 67% of the data for training and the remaining 33% for testing. This algorithm evaluation technique is very fast. It is ideal for large datasets (millions of records) where there is strong evidence that both splits of the data are representative of the underlying problem. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### **LogisticRegression** - Logistic regression is basically a supervised classification algorithm. Supervised learning is when a model learns from data that is already labeled. A supervised learning model takes in a set of input objects and output values. The model then trains on that data to learn how to map the inputs to the desired output so it can learn to make predictions on unseen data. In a classification problem, the target variable(or output), y, can take only discrete values for given set of features(or inputs), X. Logistic regression is a classification algorithm used to assign observations to a discrete set of classes. It is based on the concept of probability." + "### Logistic Regression\n", + "\n", + "Logistic regression is basically a supervised classification algorithm. Supervised learning is when a model learns from data that is already labeled. A supervised learning model takes in a set of input objects and output values. The model then trains on that data to learn how to map the inputs to the desired output so it can learn to make predictions on unseen data. In a classification problem, the target variable(or output), y, can take only discrete values for given set of features(or inputs), X. Logistic regression is a classification algorithm used to assign observations to a discrete set of classes. It is based on the concept of probability." ] }, { @@ -2008,7 +2022,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### **KNeighborsClassifier** - k-Nearest-Neighbors (k-NN) is a supervised machine learning model. KNN models work by taking a data point and looking at the ‘k’ closest labeled data points. The data point is then assigned the label of the majority of the ‘k’ closest points. For example, if k = 5, and 3 of points are ‘green’ and 2 are ‘red’, then the data point in question would be labeled ‘green’, since ‘green’ is the majority " + "### KNeighborsClassifier\n", + "\n", + "k-Nearest-Neighbors (k-NN) is a supervised machine learning model. KNN models work by taking a data point and looking at the ‘k’ closest labeled data points. The data point is then assigned the label of the majority of the ‘k’ closest points. For example, if k = 5, and 3 of points are ‘green’ and 2 are ‘red’, then the data point in question would be labeled ‘green’, since ‘green’ is the majority " ] }, { @@ -2066,7 +2082,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### **DecisionTreeClassifier** - its also a supervised learning algorithm that identifies ways to split a data set based on different conditions." + "### DecisionTreeClassifier\n", + "Its also a supervised learning algorithm that identifies ways to split a data set based on different conditions." ] }, { @@ -2079,9 +2096,9 @@ "output_type": "stream", "text": [ "MCC: 1.0\n", - "Accuracy: 89.43170488534396\n", - "390\n", - "368\n" + "Accuracy: 89.83050847457628\n", + "382\n", + "376\n" ] } ], @@ -2122,7 +2139,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### **GaussianNB** - its a classification algorithm for binary (two-class) and multi-class classification problems. Naive Bayes calculates the probability of each class and the conditional probability of each class given each input value. These probabilities are estimated for new data and multiplied together, assuming that they are all independent" + "### GaussianNB\n", + "Its a classification algorithm for binary (two-class) and multi-class classification problems. Naive Bayes calculates the probability of each class and the conditional probability of each class given each input value. These probabilities are estimated for new data and multiplied together, assuming that they are all independent" ] }, { @@ -2178,7 +2196,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### **Support Vector Machines** - its also a supervised machine learning algorithm capable of performing classification, regression and outlier detection. They draw a line that best separates two classes. Data instances closest to the line that best separates the classes are called support vectors. " + "### Support Vector Machines\n", + "Its also a supervised machine learning algorithm capable of performing classification, regression and outlier detection. They draw a line that best separates two classes. Data instances closest to the line that best separates the classes are called support vectors. " ] }, { @@ -2233,7 +2252,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### **LinearDiscriminantAnalysis** - it is a dimensionality reduction technique used for the supervised classification problems. It too assumes a Gaussian distribution for the numerical input variables.It is used to project the features in higher dimension space into a lower dimension space." + "### LinearDiscriminantAnalysis\n", + "It is a dimensionality reduction technique used for the supervised classification problems. It too assumes a Gaussian distribution for the numerical input variables.It is used to project the features in higher dimension space into a lower dimension space." ] }, { @@ -2288,21 +2308,79 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### **Ada Boost** - it trains predictors sequentially, each trying to correct its predecessor. It works by weighting instances in the dataset by how easy or difficult they are to classify, allowing the algorithm to pay or less attention to them in the construction of subsequent models" + "### RandomForestClassifier\n", + "Samples of the training dataset are taken with replacement, but the trees are constructed in a way that reduces the correlation between individual classiffiers. Specifically, rather than greedily choosing the best split point in the construction of each tree, only a random subset of features are considered for each split. Use of Random Forest for classiffication with 1000 trees and split points chosen from a random selection of 3 features is shown below" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MCC: 1.0\n", + "Accuracy: 93.02093718843469\n", + "386\n", + "372\n" + ] + } + ], + "source": [ + "from sklearn.ensemble import RandomForestClassifier\n", + "from sklearn.metrics import matthews_corrcoef\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "A = Train.values\n", + "# Separating A into output and input components\n", + "X = A[:, 0:11]\n", + "Y = A[:, 11]\n", + "\n", + "num_trees = 1000\n", + "\n", + "max_features = 3\n", + "\n", + "selected_features_train, selected_features_test, Y_train, Y_test = train_test_split(X, Y, test_size = test_size, random_state = seed)\n", + "my_model7 = RandomForestClassifier(n_estimators=num_trees, max_features=max_features)\n", + "my_model7.fit(selected_features_train, Y_train)\n", + "\n", + "Prediction = my_model7.predict(selected_features_train)\n", + "result = my_model7.score(selected_features_test, Y_test)\n", + "print(\"MCC:\", (matthews_corrcoef(Y_train, Prediction)))\n", + "print(\"Accuracy:\", (result*100.0))\n", + "\n", + "AssignmentOutPut7 = my_model7.predict(Test.values) #Assigning the preditions of the model to variable AssignmentOutPut7\n", + "AssignmentOutPut7 = pd.DataFrame(AssignmentOutPut7)# Converting AssignmentOutPut7 to a dataframe since its output is an array\n", + "AssignmentOutPut7.columns = ['Class'] # Naming the out put column\n", + "AssignmentOutPut7.index.name = \"Index\" #Creating a column called index\n", + "AssignmentOutPut7['Class'] = AssignmentOutPut7['Class'].map({0.0:False, 1.0:True}) # Converting 0.0 to false and 1.0 to true\n", + "\n", + "AssignmentOutPut7.to_csv('AssignmentOutPut7.csv') # Writing AssignmentOutPut7 to a csv file\n", + "#Printing the number of False and Trues\n", + "print(AssignmentOutPut7.groupby('Class').size()[0].sum())\n", + "print(AssignmentOutPut7.groupby('Class').size()[1].sum())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Ada Boost\n", + "It trains predictors sequentially, each trying to correct its predecessor. It works by weighting instances in the dataset by how easy or difficult they are to classify, allowing the algorithm to pay or less attention to them in the construction of subsequent models" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "MCC: 0.8546905980754327\n", - "Confusion_matrix: [[475 30]\n", - " [ 43 455]]\n", "385\n", "373\n" ] @@ -2313,45 +2391,107 @@ "from sklearn.tree import DecisionTreeClassifier\n", "from sklearn.model_selection import train_test_split\n", "from sklearn.metrics import matthews_corrcoef\n", - "from sklearn.metrics import confusion_matrix\n", + "#from sklearn.metrics import confusion_matrix\n", "\n", "A = Train.values\n", "# Separating A into output and input components\n", - "\n", + "X = A[:, 0:11]\n", + "Y = A[:, 11]\n", "test_size = 0.33\n", "seed = 6\n", "# Split data into training and test sets to evaluate the model’s performance.\n", "selected_features_train, selected_features_test, Y_train, Y_test = train_test_split(X, Y, test_size = test_size, random_state = seed)\n", "# Construct and fit a model to the training set. max_depth=1 is used to tell the model that the forest to be composed of trees with a\n", "# single decision node and two leaves. n_estimators is used to specify the total number of trees in the forest.\n", - "Model7 = AdaBoostClassifier(DecisionTreeClassifier(max_depth=1),n_estimators=200) \n", - "Model7.fit(selected_features_train, Y_train)\n", - "predictions = Model7.predict(selected_features_test)\n", + "Model8 = AdaBoostClassifier(DecisionTreeClassifier(max_depth=1),n_estimators=200) \n", + "Model8.fit(selected_features_train, Y_train)\n", + "predictions = Model8.predict(selected_features_test)\n", "print(\"MCC:\", (matthews_corrcoef(Y_test, predictions)))\n", - "print(\"Confusion_matrix:\", confusion_matrix(Y_test, predictions))\n", + "#print(\"Confusion_matrix:\", confusion_matrix(Y_test, predictions))\n", "\n", - "AssignmentOutPut7 = Model7.predict(Test.values) #Assigning the preditions of the model to variable AssignmentOutPut7\n", - "AssignmentOutPut7 = pd.DataFrame(AssignmentOutPut7)# Converting AssignmentOutPut7 to a dataframe since its output is an array\n", - "AssignmentOutPut7.columns = ['Class'] # Naming the out put column\n", - "AssignmentOutPut7.index.name = \"Index\" #Creating a column called index\n", - "AssignmentOutPut7['Class'] = AssignmentOutPut7['Class'].map({0.0:False, 1.0:True}) # Converting 0.0 to false and 1.0 to true\n", + "AssignmentOutPut8 = Model8.predict(Test.values) #Assigning the preditions of the model to variable AssignmentOutPut8\n", + "AssignmentOutPut8 = pd.DataFrame(AssignmentOutPut8)# Converting AssignmentOutPut8 to a dataframe since its output is an array\n", + "AssignmentOutPut8.columns = ['Class'] # Naming the out put column\n", + "AssignmentOutPut8.index.name = \"Index\" #Creating a column called index\n", + "AssignmentOutPut8['Class'] = AssignmentOutPut8['Class'].map({0.0:False, 1.0:True}) # Converting 0.0 to false and 1.0 to true\n", "\n", - "AssignmentOutPut7.to_csv('AssignmentOutPut7.csv') # Writing AssignmentOutPut7 to a csv file\n", + "AssignmentOutPut8.to_csv('AssignmentOutPut8.csv') # Writing AssignmentOutPut8 to a csv file\n", "#Printing the number of False and Trues\n", - "print(AssignmentOutPut7.groupby('Class').size()[0].sum())\n", - "print(AssignmentOutPut7.groupby('Class').size()[1].sum())" + "print(AssignmentOutPut8.groupby('Class').size()[0].sum())\n", + "print(AssignmentOutPut8.groupby('Class').size()[1].sum())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### **Principle component analysis** - PCA is a common way of speeding up a machine learning algorithm. Its mostly used when a machine learning algorithm is too slow because the input dimension is too high, then PCA is used to speed it up can be a reasonable choice. PCA can also be used for data visualization." + "### Stochastic Gradient Boosting\n", + "Stochastic Gradient Boosting (also called Gradient Boosting Machines). The example below demonstrates Stochastic Gradient Boosting for classification with 100 trees.\n" ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MCC: 1.0\n", + "Accuracy: 94.11764705882352\n", + "378\n", + "380\n" + ] + } + ], + "source": [ + "# Stochastic Gradient Boosting Classification\n", + "from sklearn.model_selection import KFold\n", + "from sklearn.model_selection import cross_val_score\n", + "from sklearn.ensemble import GradientBoostingClassifier\n", + "\n", + "A = Train.values\n", + "# Separating A into output and input components\n", + "X = A[:, 0:11]\n", + "Y = A[:, 11]\n", + "\n", + "seed = 7\n", + "num_trees = 100\n", + "\n", + "model9 = GradientBoostingClassifier(n_estimators=num_trees, random_state=seed)\n", + "selected_features_train, selected_features_test, Y_train, Y_test = train_test_split(X, Y, test_size = test_size, random_state = seed)\n", + "my_model9 = RandomForestClassifier(n_estimators=num_trees, max_features=max_features)\n", + "my_model9.fit(selected_features_train, Y_train)\n", + "\n", + "Prediction = my_model9.predict(selected_features_train)\n", + "result = my_model9.score(selected_features_test, Y_test)\n", + "print(\"MCC:\", (matthews_corrcoef(Y_train, Prediction)))\n", + "print(\"Accuracy:\", (result*100.0))\n", + "\n", + "AssignmentOutPut9 = my_model9.predict(Test.values) #Assigning the preditions of the model to variable AssignmentOutPut9\n", + "AssignmentOutPut9 = pd.DataFrame(AssignmentOutPut9)# Converting AssignmentOutPut9 to a dataframe since its output is an array\n", + "AssignmentOutPut9.columns = ['Class'] # Naming the out put column\n", + "AssignmentOutPut9.index.name = \"Index\" #Creating a column called index\n", + "AssignmentOutPut9['Class'] = AssignmentOutPut9['Class'].map({0.0:False, 1.0:True}) # Converting 0.0 to false and 1.0 to true\n", + "\n", + "AssignmentOutPut9.to_csv('AssignmentOutPut9.csv') # Writing AssignmentOutPut7 to a csv file\n", + "#Printing the number of False and Trues\n", + "print(AssignmentOutPut9.groupby('Class').size()[0].sum())\n", + "print(AssignmentOutPut9.groupby('Class').size()[1].sum())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Principle component analysis\n", + "**PCA** is a common way of speeding up a machine learning algorithm. Its mostly used when a machine learning algorithm is too slow because the input dimension is too high, then PCA is used to speed it up can be a reasonable choice. PCA can also be used for data visualization." + ] + }, + { + "cell_type": "code", + "execution_count": 33, "metadata": {}, "outputs": [ { @@ -2401,22 +2541,22 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### **Using principle component analysis for machine learning**" + "### Using principle component analysis for machine learning" ] }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "MCC: 0.7507336393432698\n", - "Socre: 0.8753738783649053\n", - "506\n", - "497\n" + "MCC: 0.7988133511876233\n", + "Socre: 0.8993020937188435\n", + "510\n", + "493\n" ] } ], @@ -2440,24 +2580,53 @@ "\n", "#Importing the model\n", "from sklearn.linear_model import LogisticRegression\n", - "Model8 = LogisticRegression()\n", - "Model8.fit(selected_features_trainF, Y_train)\n", + "Model10 = LogisticRegression()\n", + "Model10.fit(selected_features_trainF, Y_train)\n", "\n", "#Predicting new data\n", - "Pred = Model8.predict(selected_features_testF)\n", + "Pred = Model10.predict(selected_features_testF)\n", "print(\"MCC:\", (matthews_corrcoef(Y_test, Pred)))\n", - "print(\"Socre:\", Model8.score(selected_features_testF, Y_test))\n", + "print(\"Socre:\", Model10.score(selected_features_testF, Y_test))\n", "\n", - "AssignmentOutPut8 = Model8.predict(selected_features_testF) #Assigning the preditions of the model to variable AssignmentOutPut8\n", - "AssignmentOutPut8 = pd.DataFrame(AssignmentOutPut8)# Converting AssignmentOutPut8 to a dataframe since its output is an array\n", - "AssignmentOutPut8.columns = ['Class'] # Naming the out put column\n", - "AssignmentOutPut8.index.name = \"Index\" #Creating a column called index\n", - "AssignmentOutPut8['Class'] = AssignmentOutPut8['Class'].map({0.0:False, 1.0:True}) # Converting 0.0 to false and 1.0 to true\n", + "AssignmentOutPut10 = Model10.predict(selected_features_testF) #Assigning the preditions of the model to variable AssignmentOutPut10\n", + "AssignmentOutPut10 = pd.DataFrame(AssignmentOutPut10)# Converting AssignmentOutPut10 to a dataframe since its output is an array\n", + "AssignmentOutPut10.columns = ['Class'] # Naming the out put column\n", + "AssignmentOutPut10.index.name = \"Index\" #Creating a column called index\n", + "AssignmentOutPut10['Class'] = AssignmentOutPut10['Class'].map({0.0:False, 1.0:True}) # Converting 0.0 to false and 1.0 to true\n", "\n", - "AssignmentOutPut8.to_csv('AssignmentOutPut8.csv') # Writing AssignmentOutPut8 to a csv file\n", + "AssignmentOutPut10.to_csv('AssignmentOutPut9.csv') # Writing AssignmentOutPut10 to a csv file\n", "#Printing the number of False and Trues\n", - "print(AssignmentOutPut8.groupby('Class').size()[0].sum())\n", - "print(AssignmentOutPut8.groupby('Class').size()[1].sum())" + "print(AssignmentOutPut10.groupby('Class').size()[0].sum())\n", + "print(AssignmentOutPut10.groupby('Class').size()[1].sum())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Naive bayes(GaussianNB) algorithm with none rescaled or transformed data gave the best prediction from all the algorithms used." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 14. References for notes and code used in this notebook:\n", + "* Descriptive statistics\n", + "* Density_plots\n", + "\n", + "* Feature selection\n", + "\n", + "* cross_validation\n", + "* LinearDiscriminantAnalysis\n", + "* Stochastic Gradient Descent\n", + "* Nearest Neighbors\n", + "* Naive Bayes\n", + "* Decision tress\n", + "* Ada boost\n", + "* Random_forests\n", + "* Random_forests\n", + "* Support_vector_machines\n" ] } ],