{
"cells": [
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"# Kernel method assignment 1\n",
"\n",
"Support Vector Machines (SVMs in short) are supervised machine learning algorithms that are used for classification and regression purposes. In this kernel, We build a Support Vector Machines classifier to classify a Pulsar star. We have used the **Predicting a Pulsar Star** dataset for this project. "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Introduction to Support Vector Machines\n",
"\n",
"\n",
"**Support Vector Machines** (SVMs in short) are machine learning algorithms that are used for classification and regression purposes. SVMs are one of the powerful machine learning algorithms for classification, regression and outlier detection purposes. An SVM classifier builds a model that assigns new data points to one of the given categories. Thus, it can be viewed as a non-probabilistic binary linear classifier.\n",
"\n",
"The original SVM algorithm was developed by Vladimir N Vapnik and Alexey Ya. Chervonenkis in 1963. At that time, the algorithm was in early stages. The only possibility is to draw hyperplanes for linear classifier. In 1992, Bernhard E. Boser, Isabelle M Guyon and Vladimir N Vapnik suggested a way to create non-linear classifiers by applying the kernel trick to maximum-margin hyperplanes. The current standard was proposed by Corinna Cortes and Vapnik in 1993 and published in 1995.\n",
"\n",
"SVMs can be used for linear classification purposes. In addition to performing linear classification, SVMs can efficiently perform a non-linear classification using the **kernel trick**. It enable us to implicitly map the inputs into high dimensional feature spaces.\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Support Vector Machines intuition\n",
"\n",
"Now, we should be familiar with some SVM terminology. \n",
"\n",
"\n",
"### Hyperplane\n",
"\n",
"A hyperplane is a decision boundary which separates between given set of data points having different class labels. The SVM classifier separates data points using a hyperplane with the maximum amount of margin. This hyperplane is known as the `maximum margin hyperplane` and the linear classifier it defines is known as the `maximum margin classifier`.\n",
"\n",
"\n",
"### Support Vectors\n",
"\n",
"Support vectors are the sample data points, which are closest to the hyperplane. These data points will define the separating line or hyperplane better by calculating margins.\n",
"\n",
"\n",
"### Margin\n",
"\n",
"A margin is a separation gap between the two lines on the closest data points. It is calculated as the perpendicular distance from the line to support vectors or closest data points. In SVMs, we try to maximize this separation gap so that we get maximum margin.\n",
"\n",
"The following diagram illustrates these concepts visually.\n",
"\n",
"\n",
"### Margin in SVM\n",
"\n",
"\n",
"\n",
"\n",
"### SVM Under the hood\n",
"\n",
"In SVMs, our main objective is to select a hyperplane with the maximum possible margin between support vectors in the given dataset. SVM searches for the maximum margin hyperplane in the following 2 step process –\n",
"\n",
"\n",
"1.\tGenerate hyperplanes which segregates the classes in the best possible way. There are many hyperplanes that might classify the data. We should look for the best hyperplane that represents the largest separation, or margin, between the two classes.\n",
"\n",
"2.\tSo, we choose the hyperplane so that distance from it to the support vectors on each side is maximized. If such a hyperplane exists, it is known as the **maximum margin hyperplane** and the linear classifier it defines is known as a **maximum margin classifier**. \n",
"\n",
"\n",
"The following diagram illustrates the concept of **maximum margin** and **maximum margin hyperplane** in a clear manner.\n",
"\n",
"\n",
"### Maximum margin hyperplane\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"### Problem with dispersed datasets\n",
"\n",
"\n",
"Sometimes, the sample data points are so dispersed that it is not possible to separate them using a linear hyperplane. \n",
"In such a situation, SVMs uses a `kernel trick` to transform the input space to a higher dimensional space as shown in the diagram below. It uses a mapping function to transform the 2-D input space into the 3-D input space. Now, we can easily segregate the data points using linear separation.\n",
"\n",
"\n",
"### Kernel trick - transformation of input space to higher dimensional space\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Kernel trick\n",
"\n",
"In practice, SVM algorithm is implemented using a `kernel`. It uses a technique called the `kernel trick`. In simple words, a `kernel` is just a function that maps the data to a higher dimension where data is separable. A kernel transforms a low-dimensional input data space into a higher dimensional space. So, it converts non-linear separable problems to linear separable problems by adding more dimensions to it. Thus, the kernel trick helps us to build a more accurate classifier. Hence, it is useful in non-linear separation problems."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can define a kernel function as follows-\n",
"\n",
"\n",
"### Kernel function\n",
"\n",
""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In the context of SVMs, there are 4 popular kernels – `Linear kernel`,`Polynomial kernel`,`Radial Basis Function (RBF) kernel` (also called Gaussian kernel) and `Sigmoid kernel`. These are described below -"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Linear kernel\n",
"\n",
"In linear kernel, the kernel function takes the form of a linear function as follows-\n",
"\n",
"**linear kernel : K(xi , xj ) = xiT xj**\n",
"\n",
"Linear kernel is used when the data is linearly separable. It means that data can be separated using a single line. It is one of the most common kernels to be used. It is mostly used when there are large number of features in a dataset. Linear kernel is often used for text classification purposes.\n",
"\n",
"Training with a linear kernel is usually faster, because we only need to optimize the C regularization parameter. When training with other kernels, we also need to optimize the γ parameter. So, performing a grid search will usually take more time.\n",
"\n",
"Linear kernel can be visualized with the following figure.\n",
"\n",
"#### Linear Kernel\n",
"\n",
""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Polynomial Kernel\n",
"\n",
"Polynomial kernel represents the similarity of vectors (training samples) in a feature space over polynomials of the original variables. The polynomial kernel looks not only at the given features of input samples to determine their similarity, but also combinations of the input samples.\n",
"\n",
"For degree-d polynomials, the polynomial kernel is defined as follows –\n",
"\n",
"**Polynomial kernel : K(xi , xj ) = (γxiT xj + r)d , γ > 0**\n",
"\n",
"Polynomial kernel is very popular in Natural Language Processing. The most common degree is d = 2 (quadratic), since larger degrees tend to overfit on NLP problems. It can be visualized with the following diagram.\n",
"\n",
"### Polynomial Kernel\n",
"\n",
""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Radial Basis Function Kernel\n",
"\n",
"Radial basis function kernel is a general purpose kernel. It is used when we have no prior knowledge about the data. The RBF kernel on two samples x and y is defined by the following equation –\n",
"\n",
"\n",
"#### Radial Basis Function kernel\n",
"\n",
""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The following diagram demonstrates the SVM classification with rbf kernel.\n",
"\n",
"#### SVM Classification with rbf kernel\n",
"\n",
""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## SVM Scikit-Learn libraries \n",
"\n",
"Scikit-Learn provides useful libraries to implement Support Vector Machine algorithm on a dataset. There are many libraries that can help us to implement SVM smoothly. We just need to call the library with parameters that suit to our needs. In this project, I am dealing with a classification task. So, I will mention the Scikit-Learn libraries for SVM classification purposes.\n",
"\n",
"First, there is a **LinearSVC()** classifier. As the name suggests, this classifier uses only linear kernel. In LinearSVC() classifier, we don’t pass the value of kernel since it is used only for linear classification purposes.\n",
"\n",
"Scikit-Learn provides two other classifiers - **SVC()** and **NuSVC()** which are used for classification purposes. These classifiers are mostly similar with some difference in parameters. **NuSVC()** is similar to **SVC()** but uses a parameter to control the number of support vectors. We pass the values of kernel, gamma and C along with other parameters. By default kernel parameter uses rbf as its value but we can pass values like poly, linear, sigmoid or callable function."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Dataset description\n",
"\n",
"I have used the **Predicting a Pulsar Star** dataset for this project.\n",
"\n",
"Pulsars are a rare type of Neutron star that produce radio emission detectable here on Earth. They are of considerable scientific interest as probes of space-time, the inter-stellar medium, and states of matter. Classification algorithms in particular are being adopted, which treat the data sets as binary classification problems. Here the legitimate pulsar examples form minority positive class and spurious examples form the majority negative class.\n",
"\n",
"The data set shared here contains 16,259 spurious examples caused by RFI/noise, and 1,639 real pulsar examples. Each row lists the variables first, and the class label is the final entry. The class labels used are 0 (negative) and 1 (positive).\n",
"\n",
"\n",
"### Attribute Information:\n",
"\n",
"\n",
"Each candidate is described by 8 continuous variables, and a single class variable. The first four are simple statistics obtained from the integrated pulse profile. The remaining four variables are similarly obtained from the DM-SNR curve . These are summarised below:\n",
"\n",
"1. Mean of the integrated profile.\n",
"\n",
"2. Standard deviation of the integrated profile.\n",
"\n",
"3. Excess kurtosis of the integrated profile.\n",
"\n",
"4. Skewness of the integrated profile.\n",
"\n",
"5. Mean of the DM-SNR curve.\n",
"\n",
"6. Standard deviation of the DM-SNR curve.\n",
"\n",
"7. Excess kurtosis of the DM-SNR curve.\n",
"\n",
"8. Skewness of the DM-SNR curve.\n",
"\n",
"9. Class"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Import libraries\n",
"\n",
"\n",
"I will start off by importing the required Python libraries."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"%matplotlib inline\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 # for data visualization\n",
"import seaborn as sns # for statistical data visualization\n",
"import os\n",
"import warnings\n",
"warnings.filterwarnings('ignore')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Import dataset "
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"data = '../../../assets/data/pulsar_stars.csv'\n",
"\n",
"df = pd.read_csv(data)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Exploratory data analysis\n",
"Now, we will explore the data to gain insights about the data. "
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(17898, 9)"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# view dimensions of dataset\n",
"\n",
"df.shape"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can see that there are 17898 instances and 9 variables in the data set."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"scrolled": true
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
Mean of the integrated profile
\n",
"
Standard deviation of the integrated profile
\n",
"
Excess kurtosis of the integrated profile
\n",
"
Skewness of the integrated profile
\n",
"
Mean of the DM-SNR curve
\n",
"
Standard deviation of the DM-SNR curve
\n",
"
Excess kurtosis of the DM-SNR curve
\n",
"
Skewness of the DM-SNR curve
\n",
"
target_class
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
140.562500
\n",
"
55.683782
\n",
"
-0.234571
\n",
"
-0.699648
\n",
"
3.199833
\n",
"
19.110426
\n",
"
7.975532
\n",
"
74.242225
\n",
"
0
\n",
"
\n",
"
\n",
"
1
\n",
"
102.507812
\n",
"
58.882430
\n",
"
0.465318
\n",
"
-0.515088
\n",
"
1.677258
\n",
"
14.860146
\n",
"
10.576487
\n",
"
127.393580
\n",
"
0
\n",
"
\n",
"
\n",
"
2
\n",
"
103.015625
\n",
"
39.341649
\n",
"
0.323328
\n",
"
1.051164
\n",
"
3.121237
\n",
"
21.744669
\n",
"
7.735822
\n",
"
63.171909
\n",
"
0
\n",
"
\n",
"
\n",
"
3
\n",
"
136.750000
\n",
"
57.178449
\n",
"
-0.068415
\n",
"
-0.636238
\n",
"
3.642977
\n",
"
20.959280
\n",
"
6.896499
\n",
"
53.593661
\n",
"
0
\n",
"
\n",
"
\n",
"
4
\n",
"
88.726562
\n",
"
40.672225
\n",
"
0.600866
\n",
"
1.123492
\n",
"
1.178930
\n",
"
11.468720
\n",
"
14.269573
\n",
"
252.567306
\n",
"
0
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" Mean of the integrated profile \\\n",
"0 140.562500 \n",
"1 102.507812 \n",
"2 103.015625 \n",
"3 136.750000 \n",
"4 88.726562 \n",
"\n",
" Standard deviation of the integrated profile \\\n",
"0 55.683782 \n",
"1 58.882430 \n",
"2 39.341649 \n",
"3 57.178449 \n",
"4 40.672225 \n",
"\n",
" Excess kurtosis of the integrated profile \\\n",
"0 -0.234571 \n",
"1 0.465318 \n",
"2 0.323328 \n",
"3 -0.068415 \n",
"4 0.600866 \n",
"\n",
" Skewness of the integrated profile Mean of the DM-SNR curve \\\n",
"0 -0.699648 3.199833 \n",
"1 -0.515088 1.677258 \n",
"2 1.051164 3.121237 \n",
"3 -0.636238 3.642977 \n",
"4 1.123492 1.178930 \n",
"\n",
" Standard deviation of the DM-SNR curve \\\n",
"0 19.110426 \n",
"1 14.860146 \n",
"2 21.744669 \n",
"3 20.959280 \n",
"4 11.468720 \n",
"\n",
" Excess kurtosis of the DM-SNR curve Skewness of the DM-SNR curve \\\n",
"0 7.975532 74.242225 \n",
"1 10.576487 127.393580 \n",
"2 7.735822 63.171909 \n",
"3 6.896499 53.593661 \n",
"4 14.269573 252.567306 \n",
"\n",
" target_class \n",
"0 0 \n",
"1 0 \n",
"2 0 \n",
"3 0 \n",
"4 0 "
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# let's preview the dataset\n",
"\n",
"df.head()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can see that there are 9 variables in the dataset. 8 are continuous variables and 1 is discrete variable. The discrete variable is `target_class` variable. It is also the target variable.\n",
"\n",
"\n",
"Now, I will view the column names to check for leading and trailing spaces."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Index([' Mean of the integrated profile',\n",
" ' Standard deviation of the integrated profile',\n",
" ' Excess kurtosis of the integrated profile',\n",
" ' Skewness of the integrated profile', ' Mean of the DM-SNR curve',\n",
" ' Standard deviation of the DM-SNR curve',\n",
" ' Excess kurtosis of the DM-SNR curve', ' Skewness of the DM-SNR curve',\n",
" 'target_class'],\n",
" dtype='object')"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# view the column names of the dataframe\n",
"\n",
"col_names = df.columns\n",
"\n",
"col_names"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can see that there are leading spaces (spaces at the start of the string name) in the dataframe. So, I will remove these leading spaces."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"# remove leading spaces from column names\n",
"\n",
"df.columns = df.columns.str.strip()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"I have removed the leading spaces from the column names. Let's again view the column names to confirm the same."
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Index(['Mean of the integrated profile',\n",
" 'Standard deviation of the integrated profile',\n",
" 'Excess kurtosis of the integrated profile',\n",
" 'Skewness of the integrated profile', 'Mean of the DM-SNR curve',\n",
" 'Standard deviation of the DM-SNR curve',\n",
" 'Excess kurtosis of the DM-SNR curve', 'Skewness of the DM-SNR curve',\n",
" 'target_class'],\n",
" dtype='object')"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# view column names again\n",
"\n",
"df.columns"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can see that the leading spaces are removed from the column name. But the column names are very long. So, I will make them short by renaming them."
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"# rename column names\n",
"\n",
"df.columns = ['IP Mean', 'IP Sd', 'IP Kurtosis', 'IP Skewness', \n",
" 'DM-SNR Mean', 'DM-SNR Sd', 'DM-SNR Kurtosis', 'DM-SNR Skewness', 'target_class']"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Index(['IP Mean', 'IP Sd', 'IP Kurtosis', 'IP Skewness', 'DM-SNR Mean',\n",
" 'DM-SNR Sd', 'DM-SNR Kurtosis', 'DM-SNR Skewness', 'target_class'],\n",
" dtype='object')"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# view the renamed column names\n",
"\n",
"df.columns"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can see that the column names are shortened. IP stands for `integrated profile` and DM-SNR stands for `delta modulation and signal to noise ratio`. Now, it is much more easy to work with the columns."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Our target variable is the `target_class` column. So, I will check its distribution."
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0 16259\n",
"1 1639\n",
"Name: target_class, dtype: int64"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# check distribution of target_class column\n",
"\n",
"df['target_class'].value_counts()"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0 0.908426\n",
"1 0.091574\n",
"Name: target_class, dtype: float64"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# view the percentage distribution of target_class column\n",
"\n",
"df['target_class'].value_counts()/np.float(len(df))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can see that percentage of observations of the class label `0` and `1` is 90.84% and 9.16%. So, this is a class imbalanced problem. I will deal with that in later section."
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"RangeIndex: 17898 entries, 0 to 17897\n",
"Data columns (total 9 columns):\n",
" # Column Non-Null Count Dtype \n",
"--- ------ -------------- ----- \n",
" 0 IP Mean 17898 non-null float64\n",
" 1 IP Sd 17898 non-null float64\n",
" 2 IP Kurtosis 17898 non-null float64\n",
" 3 IP Skewness 17898 non-null float64\n",
" 4 DM-SNR Mean 17898 non-null float64\n",
" 5 DM-SNR Sd 17898 non-null float64\n",
" 6 DM-SNR Kurtosis 17898 non-null float64\n",
" 7 DM-SNR Skewness 17898 non-null float64\n",
" 8 target_class 17898 non-null int64 \n",
"dtypes: float64(8), int64(1)\n",
"memory usage: 1.2 MB\n"
]
}
],
"source": [
"# view summary of dataset\n",
"\n",
"df.info()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can see that there are no missing values in the dataset and all the variables are numerical variables."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Explore missing values in variables"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"IP Mean 0\n",
"IP Sd 0\n",
"IP Kurtosis 0\n",
"IP Skewness 0\n",
"DM-SNR Mean 0\n",
"DM-SNR Sd 0\n",
"DM-SNR Kurtosis 0\n",
"DM-SNR Skewness 0\n",
"target_class 0\n",
"dtype: int64"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# check for missing values in variables\n",
"\n",
"df.isnull().sum()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can see that there are no missing values in the dataset."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Summary of numerical variables\n",
"\n",
"\n",
"- There are 9 numerical variables in the dataset.\n",
"\n",
"\n",
"- 8 are continuous variables and 1 is discrete variable. \n",
"\n",
"\n",
"- The discrete variable is `target_class` variable. It is also the target variable.\n",
"\n",
"\n",
"- There are no missing values in the dataset."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Outliers in numerical variables"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# draw boxplots to visualize outliers\n",
"\n",
"plt.figure(figsize=(24,20))\n",
"\n",
"\n",
"plt.subplot(4, 2, 1)\n",
"fig = df.boxplot(column='IP Mean')\n",
"fig.set_title('')\n",
"fig.set_ylabel('IP Mean')\n",
"\n",
"\n",
"plt.subplot(4, 2, 2)\n",
"fig = df.boxplot(column='IP Sd')\n",
"fig.set_title('')\n",
"fig.set_ylabel('IP Sd')\n",
"\n",
"\n",
"plt.subplot(4, 2, 3)\n",
"fig = df.boxplot(column='IP Kurtosis')\n",
"fig.set_title('')\n",
"fig.set_ylabel('IP Kurtosis')\n",
"\n",
"\n",
"plt.subplot(4, 2, 4)\n",
"fig = df.boxplot(column='IP Skewness')\n",
"fig.set_title('')\n",
"fig.set_ylabel('IP Skewness')\n",
"\n",
"\n",
"plt.subplot(4, 2, 5)\n",
"fig = df.boxplot(column='DM-SNR Mean')\n",
"fig.set_title('')\n",
"fig.set_ylabel('DM-SNR Mean')\n",
"\n",
"\n",
"plt.subplot(4, 2, 6)\n",
"fig = df.boxplot(column='DM-SNR Sd')\n",
"fig.set_title('')\n",
"fig.set_ylabel('DM-SNR Sd')\n",
"\n",
"\n",
"plt.subplot(4, 2, 7)\n",
"fig = df.boxplot(column='DM-SNR Kurtosis')\n",
"fig.set_title('')\n",
"fig.set_ylabel('DM-SNR Kurtosis')\n",
"\n",
"\n",
"plt.subplot(4, 2, 8)\n",
"fig = df.boxplot(column='DM-SNR Skewness')\n",
"fig.set_title('')\n",
"fig.set_ylabel('DM-SNR Skewness')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The above boxplots confirm that there are lot of outliers in these variables."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Handle outliers with SVMs\n",
"\n",
"\n",
"There are 2 variants of SVMs. They are `hard-margin variant of SVM` and `soft-margin variant of SVM`.\n",
"\n",
"\n",
"The `hard-margin variant of SVM` does not deal with outliers. In this case, we want to find the hyperplane with maximum margin such that every training point is correctly classified with margin at least 1. This technique does not handle outliers well.\n",
"\n",
"\n",
"Another version of SVM is called `soft-margin variant of SVM`. In this case, we can have a few points incorrectly classified or \n",
"classified with a margin less than 1. But for every such point, we have to pay a penalty in the form of `C` parameter, which controls the outliers. `Low C` implies we are allowing more outliers and `high C` implies less outliers.\n",
"\n",
"\n",
"The message is that since the dataset contains outliers, so the value of C should be high while training the model."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Check the distribution of variables\n",
"\n",
"\n",
"Now, I will plot the histograms to check distributions to find out if they are normal or skewed. "
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Text(0, 0.5, 'Number of pulsar stars')"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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",
"text/plain": [
"
"
],
"text/plain": [
" IP Mean IP Sd IP Kurtosis IP Skewness DM-SNR Mean \\\n",
"count 1.431800e+04 1.431800e+04 1.431800e+04 1.431800e+04 1.431800e+04 \n",
"mean 1.908113e-16 -6.550610e-16 1.042143e-17 3.870815e-17 -8.734147e-17 \n",
"std 1.000035e+00 1.000035e+00 1.000035e+00 1.000035e+00 1.000035e+00 \n",
"min -4.035499e+00 -3.181033e+00 -2.185946e+00 -5.744051e-01 -4.239001e-01 \n",
"25% -3.896291e-01 -6.069473e-01 -4.256221e-01 -3.188054e-01 -3.664918e-01 \n",
"50% 1.587461e-01 5.846646e-02 -2.453172e-01 -2.578142e-01 -3.372294e-01 \n",
"75% 6.267059e-01 6.501017e-01 -1.001238e-02 -1.419621e-01 -2.463724e-01 \n",
"max 3.151882e+00 7.621116e+00 7.008906e+00 1.054430e+01 7.025568e+00 \n",
"\n",
" DM-SNR Sd DM-SNR Kurtosis DM-SNR Skewness \n",
"count 1.431800e+04 1.431800e+04 1.431800e+04 \n",
"mean -1.617802e-16 -1.513588e-17 1.122785e-16 \n",
"std 1.000035e+00 1.000035e+00 1.000035e+00 \n",
"min -9.733707e-01 -2.455649e+00 -1.003411e+00 \n",
"25% -6.125457e-01 -5.641035e-01 -6.627590e-01 \n",
"50% -4.067482e-01 3.170446e-02 -2.059136e-01 \n",
"75% 1.078934e-01 5.362759e-01 3.256217e-01 \n",
"max 4.292181e+00 5.818557e+00 1.024613e+01 "
]
},
"execution_count": 24,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X_train.describe()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We now have `X_train` dataset ready to be fed into the Logistic Regression classifier. I will do it as follows."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Run SVM with default hyperparameters\n",
"\n",
"Default hyperparameter means C=1.0, kernel=`rbf` and gamma=`auto` among other parameters."
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model accuracy score with default hyperparameters: 0.9827\n"
]
}
],
"source": [
"# import SVC classifier\n",
"from sklearn.svm import SVC\n",
"\n",
"\n",
"# import metrics to compute accuracy\n",
"from sklearn.metrics import accuracy_score\n",
"\n",
"\n",
"# instantiate classifier with default hyperparameters\n",
"svc=SVC() \n",
"\n",
"\n",
"# fit classifier to training set\n",
"svc.fit(X_train,y_train)\n",
"\n",
"\n",
"# make predictions on test set\n",
"y_pred=svc.predict(X_test)\n",
"\n",
"\n",
"# compute and print accuracy score\n",
"print('Model accuracy score with default hyperparameters: {0:0.4f}'. format(accuracy_score(y_test, y_pred)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Run SVM with rbf kernel and C=100.0\n",
"\n",
"\n",
"We have seen that there are outliers in our dataset. So, we should increase the value of C as higher C means fewer outliers. \n",
"So, I will run SVM with kernel=`rbf` and C=100.0."
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model accuracy score with rbf kernel and C=100.0 : 0.9832\n"
]
}
],
"source": [
"# instantiate classifier with rbf kernel and C=100\n",
"svc=SVC(C=100.0) \n",
"\n",
"\n",
"# fit classifier to training set\n",
"svc.fit(X_train,y_train)\n",
"\n",
"\n",
"# make predictions on test set\n",
"y_pred=svc.predict(X_test)\n",
"\n",
"\n",
"# compute and print accuracy score\n",
"print('Model accuracy score with rbf kernel and C=100.0 : {0:0.4f}'. format(accuracy_score(y_test, y_pred)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can see that we obtain a higher accuracy with C=100.0 as higher C means less outliers.\n",
"\n",
"Now, I will further increase the value of C=1000.0 and check accuracy."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Run SVM with rbf kernel and C=1000.0\n"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model accuracy score with rbf kernel and C=1000.0 : 0.9816\n"
]
}
],
"source": [
"# instantiate classifier with rbf kernel and C=1000\n",
"svc=SVC(C=1000.0) \n",
"\n",
"\n",
"# fit classifier to training set\n",
"svc.fit(X_train,y_train)\n",
"\n",
"\n",
"# make predictions on test set\n",
"y_pred=svc.predict(X_test)\n",
"\n",
"\n",
"# compute and print accuracy score\n",
"print('Model accuracy score with rbf kernel and C=1000.0 : {0:0.4f}'. format(accuracy_score(y_test, y_pred)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In this case, we can see that the accuracy had decreased with C=1000.0"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Run SVM with linear kernel\n",
"\n",
"### Run SVM with linear kernel and C=1.0"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model accuracy score with linear kernel and C=1.0 : 0.9830\n"
]
}
],
"source": [
"# instantiate classifier with linear kernel and C=1.0\n",
"linear_svc=SVC(kernel='linear', C=1.0) \n",
"\n",
"\n",
"# fit classifier to training set\n",
"linear_svc.fit(X_train,y_train)\n",
"\n",
"\n",
"# make predictions on test set\n",
"y_pred_test=linear_svc.predict(X_test)\n",
"\n",
"\n",
"# compute and print accuracy score\n",
"print('Model accuracy score with linear kernel and C=1.0 : {0:0.4f}'. format(accuracy_score(y_test, y_pred_test)))\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Run SVM with linear kernel and C=100.0"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model accuracy score with linear kernel and C=100.0 : 0.9832\n"
]
}
],
"source": [
"# instantiate classifier with linear kernel and C=100.0\n",
"linear_svc100=SVC(kernel='linear', C=100.0) \n",
"\n",
"\n",
"# fit classifier to training set\n",
"linear_svc100.fit(X_train, y_train)\n",
"\n",
"\n",
"# make predictions on test set\n",
"y_pred=linear_svc100.predict(X_test)\n",
"\n",
"\n",
"# compute and print accuracy score\n",
"print('Model accuracy score with linear kernel and C=100.0 : {0:0.4f}'. format(accuracy_score(y_test, y_pred)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Run SVM with linear kernel and C=1000.0"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model accuracy score with linear kernel and C=1000.0 : 0.9832\n"
]
}
],
"source": [
"# instantiate classifier with linear kernel and C=1000.0\n",
"linear_svc1000=SVC(kernel='linear', C=1000.0) \n",
"\n",
"\n",
"# fit classifier to training set\n",
"linear_svc1000.fit(X_train, y_train)\n",
"\n",
"\n",
"# make predictions on test set\n",
"y_pred=linear_svc1000.predict(X_test)\n",
"\n",
"\n",
"# compute and print accuracy score\n",
"print('Model accuracy score with linear kernel and C=1000.0 : {0:0.4f}'. format(accuracy_score(y_test, y_pred)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can see that we can obtain higher accuracy with C=100.0 and C=1000.0 as compared to C=1.0."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Here, **y_test** are the true class labels and **y_pred** are the predicted class labels in the test-set."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Compare the train-set and test-set accuracy\n",
"\n",
"\n",
"Now, I will compare the train-set and test-set accuracy to check for overfitting."
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([0, 0, 1, ..., 0, 0, 0], dtype=int64)"
]
},
"execution_count": 31,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"y_pred_train = linear_svc.predict(X_train)\n",
"\n",
"y_pred_train"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Training-set accuracy score: 0.9783\n"
]
}
],
"source": [
"print('Training-set accuracy score: {0:0.4f}'. format(accuracy_score(y_train, y_pred_train)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can see that the training set and test-set accuracy are very much comparable."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Check for overfitting and underfitting"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Training set score: 0.9783\n",
"Test set score: 0.9830\n"
]
}
],
"source": [
"# print the scores on training and test set\n",
"\n",
"print('Training set score: {:.4f}'.format(linear_svc.score(X_train, y_train)))\n",
"\n",
"print('Test set score: {:.4f}'.format(linear_svc.score(X_test, y_test)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The training-set accuracy score is 0.9783 while the test-set accuracy to be 0.9830. These two values are quite comparable. So, there is no question of overfitting. \n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Compare model accuracy with null accuracy\n",
"\n",
"\n",
"So, the model accuracy is 0.9832. But, we cannot say that our model is very good based on the above accuracy. We must compare it with the **null accuracy**. Null accuracy is the accuracy that could be achieved by always predicting the most frequent class.\n",
"\n",
"So, we should first check the class distribution in the test set. "
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0 3306\n",
"1 274\n",
"Name: target_class, dtype: int64"
]
},
"execution_count": 34,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# check class distribution in test set\n",
"\n",
"y_test.value_counts()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can see that the occurences of most frequent class `0` is 3306. So, we can calculate null accuracy by dividing 3306 by total number of occurences."
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Null accuracy score: 0.9235\n"
]
}
],
"source": [
"# check null accuracy score\n",
"\n",
"null_accuracy = (3306/(3306+274))\n",
"\n",
"print('Null accuracy score: {0:0.4f}'. format(null_accuracy))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can see that our model accuracy score is 0.9830 but null accuracy score is 0.9235. So, we can conclude that our SVM classifier is doing a very good job in predicting the class labels."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Run SVM with polynomial kernel\n",
"\n",
"### Run SVM with polynomial kernel and C=1.0"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model accuracy score with polynomial kernel and C=1.0 : 0.9807\n"
]
}
],
"source": [
"# instantiate classifier with polynomial kernel and C=1.0\n",
"poly_svc=SVC(kernel='poly', C=1.0) \n",
"\n",
"\n",
"# fit classifier to training set\n",
"poly_svc.fit(X_train,y_train)\n",
"\n",
"\n",
"# make predictions on test set\n",
"y_pred=poly_svc.predict(X_test)\n",
"\n",
"\n",
"# compute and print accuracy score\n",
"print('Model accuracy score with polynomial kernel and C=1.0 : {0:0.4f}'. format(accuracy_score(y_test, y_pred)))\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" ### Run SVM with polynomial kernel and C=100.0"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model accuracy score with polynomial kernel and C=1.0 : 0.9824\n"
]
}
],
"source": [
"# instantiate classifier with polynomial kernel and C=100.0\n",
"poly_svc100=SVC(kernel='poly', C=100.0) \n",
"\n",
"\n",
"# fit classifier to training set\n",
"poly_svc100.fit(X_train, y_train)\n",
"\n",
"\n",
"# make predictions on test set\n",
"y_pred=poly_svc100.predict(X_test)\n",
"\n",
"\n",
"# compute and print accuracy score\n",
"print('Model accuracy score with polynomial kernel and C=1.0 : {0:0.4f}'. format(accuracy_score(y_test, y_pred)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Polynomial kernel gives poor performance. It may be overfitting the training set."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Run SVM with sigmoid kernel\n",
"\n",
"### Run SVM with sigmoid kernel and C=1.0"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model accuracy score with sigmoid kernel and C=1.0 : 0.8858\n"
]
}
],
"source": [
"# instantiate classifier with sigmoid kernel and C=1.0\n",
"sigmoid_svc=SVC(kernel='sigmoid', C=1.0) \n",
"\n",
"\n",
"# fit classifier to training set\n",
"sigmoid_svc.fit(X_train,y_train)\n",
"\n",
"\n",
"# make predictions on test set\n",
"y_pred=sigmoid_svc.predict(X_test)\n",
"\n",
"\n",
"# compute and print accuracy score\n",
"print('Model accuracy score with sigmoid kernel and C=1.0 : {0:0.4f}'. format(accuracy_score(y_test, y_pred)))\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Run SVM with sigmoid kernel and C=100.0"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model accuracy score with sigmoid kernel and C=100.0 : 0.8855\n"
]
}
],
"source": [
"# instantiate classifier with sigmoid kernel and C=100.0\n",
"sigmoid_svc100=SVC(kernel='sigmoid', C=100.0) \n",
"\n",
"\n",
"# fit classifier to training set\n",
"sigmoid_svc100.fit(X_train,y_train)\n",
"\n",
"\n",
"# make predictions on test set\n",
"y_pred=sigmoid_svc100.predict(X_test)\n",
"\n",
"\n",
"# compute and print accuracy score\n",
"print('Model accuracy score with sigmoid kernel and C=100.0 : {0:0.4f}'. format(accuracy_score(y_test, y_pred)))\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can see that sigmoid kernel is also performing poorly just like with polynomial kernel."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Comments\n",
"\n",
"\n",
"We get maximum accuracy with `rbf` and `linear` kernel with C=100.0. and the accuracy is 0.9832. Based on the above analysis we can conclude that our classification model accuracy is very good. Our model is doing a very good job in terms of predicting the class labels.\n",
"\n",
"\n",
"But, this is not true. Here, we have an imbalanced dataset. The problem is that accuracy is an inadequate measure for quantifying predictive performance in the imbalanced dataset problem.\n",
"\n",
"\n",
"So, we must explore alternative metrices that provide better guidance in selecting models. In particular, we would like to know the underlying distribution of values and the type of errors our classifer is making. \n",
"\n",
"\n",
"One such metric to analyze the model performance in imbalanced classes problem is `Confusion matrix`."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Confusion matrix\n",
"\n",
"\n",
"A confusion matrix is a tool for summarizing the performance of a classification algorithm. A confusion matrix will give us a clear picture of classification model performance and the types of errors produced by the model. It gives us a summary of correct and incorrect predictions broken down by each category. The summary is represented in a tabular form.\n",
"\n",
"\n",
"Four types of outcomes are possible while evaluating a classification model performance. These four outcomes are described below:-\n",
"\n",
"\n",
"**True Positives (TP)** – True Positives occur when we predict an observation belongs to a certain class and the observation actually belongs to that class.\n",
"\n",
"\n",
"**True Negatives (TN)** – True Negatives occur when we predict an observation does not belong to a certain class and the observation actually does not belong to that class.\n",
"\n",
"\n",
"**False Positives (FP)** – False Positives occur when we predict an observation belongs to a certain class but the observation actually does not belong to that class. This type of error is called **Type I error.**\n",
"\n",
"\n",
"\n",
"**False Negatives (FN)** – False Negatives occur when we predict an observation does not belong to a certain class but the observation actually belongs to that class. This is a very serious error and it is called **Type II error.**\n",
"\n",
"\n",
"\n",
"These four outcomes are summarized in a confusion matrix given below.\n"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Confusion matrix\n",
"\n",
" [[3289 17]\n",
" [ 44 230]]\n",
"\n",
"True Positives(TP) = 3289\n",
"\n",
"True Negatives(TN) = 230\n",
"\n",
"False Positives(FP) = 17\n",
"\n",
"False Negatives(FN) = 44\n"
]
}
],
"source": [
"# Print the Confusion Matrix and slice it into four pieces\n",
"\n",
"from sklearn.metrics import confusion_matrix\n",
"\n",
"cm = confusion_matrix(y_test, y_pred_test)\n",
"\n",
"print('Confusion matrix\\n\\n', cm)\n",
"\n",
"print('\\nTrue Positives(TP) = ', cm[0,0])\n",
"\n",
"print('\\nTrue Negatives(TN) = ', cm[1,1])\n",
"\n",
"print('\\nFalse Positives(FP) = ', cm[0,1])\n",
"\n",
"print('\\nFalse Negatives(FN) = ', cm[1,0])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The confusion matrix shows `3289 + 230 = 3519 correct predictions` and `17 + 44 = 61 incorrect predictions`.\n",
"\n",
"\n",
"In this case, we have\n",
"\n",
"\n",
"- `True Positives` (Actual Positive:1 and Predict Positive:1) - 3289\n",
"\n",
"\n",
"- `True Negatives` (Actual Negative:0 and Predict Negative:0) - 230\n",
"\n",
"\n",
"- `False Positives` (Actual Negative:0 but Predict Positive:1) - 17 `(Type I error)`\n",
"\n",
"\n",
"- `False Negatives` (Actual Positive:1 but Predict Negative:0) - 44 `(Type II error)`"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 41,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# visualize confusion matrix with seaborn heatmap\n",
"\n",
"cm_matrix = pd.DataFrame(data=cm, columns=['Actual Positive:1', 'Actual Negative:0'], \n",
" index=['Predict Positive:1', 'Predict Negative:0'])\n",
"\n",
"sns.heatmap(cm_matrix, annot=True, fmt='d', cmap='YlGnBu')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Classification metrices"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Classification Report\n",
"\n",
"\n",
"**Classification report** is another way to evaluate the classification model performance. It displays the **precision**, **recall**, **f1** and **support** scores for the model. I have described these terms in later.\n",
"\n",
"We can print a classification report as follows:-"
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" precision recall f1-score support\n",
"\n",
" 0 0.99 0.99 0.99 3306\n",
" 1 0.93 0.84 0.88 274\n",
"\n",
" accuracy 0.98 3580\n",
" macro avg 0.96 0.92 0.94 3580\n",
"weighted avg 0.98 0.98 0.98 3580\n",
"\n"
]
}
],
"source": [
"from sklearn.metrics import classification_report\n",
"\n",
"print(classification_report(y_test, y_pred_test))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Classification accuracy"
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {},
"outputs": [],
"source": [
"TP = cm[0,0]\n",
"TN = cm[1,1]\n",
"FP = cm[0,1]\n",
"FN = cm[1,0]"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Classification accuracy : 0.9830\n"
]
}
],
"source": [
"# print classification accuracy\n",
"\n",
"classification_accuracy = (TP + TN) / float(TP + TN + FP + FN)\n",
"\n",
"print('Classification accuracy : {0:0.4f}'.format(classification_accuracy))\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Classification error"
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Classification error : 0.0170\n"
]
}
],
"source": [
"# print classification error\n",
"\n",
"classification_error = (FP + FN) / float(TP + TN + FP + FN)\n",
"\n",
"print('Classification error : {0:0.4f}'.format(classification_error))\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Precision\n",
"\n",
"\n",
"**Precision** can be defined as the percentage of correctly predicted positive outcomes out of all the predicted positive outcomes. It can be given as the ratio of true positives (TP) to the sum of true and false positives (TP + FP). \n",
"\n",
"\n",
"So, **Precision** identifies the proportion of correctly predicted positive outcome. It is more concerned with the positive class than the negative class.\n",
"\n",
"\n",
"\n",
"Mathematically, precision can be defined as the ratio of `TP to (TP + FP)`.\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Precision : 0.9949\n"
]
}
],
"source": [
"# print precision score\n",
"\n",
"precision = TP / float(TP + FP)\n",
"\n",
"\n",
"print('Precision : {0:0.4f}'.format(precision))\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Recall\n",
"\n",
"\n",
"Recall can be defined as the percentage of correctly predicted positive outcomes out of all the actual positive outcomes.\n",
"It can be given as the ratio of true positives (TP) to the sum of true positives and false negatives (TP + FN). **Recall** is also called **Sensitivity**.\n",
"\n",
"\n",
"**Recall** identifies the proportion of correctly predicted actual positives.\n",
"\n",
"\n",
"Mathematically, **recall** can be defined as the ratio of `TP to (TP + FN)`.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Recall or Sensitivity : 0.9868\n"
]
}
],
"source": [
"recall = TP / float(TP + FN)\n",
"\n",
"print('Recall or Sensitivity : {0:0.4f}'.format(recall))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### True Positive Rate\n",
"\n",
"\n",
"**True Positive Rate** is synonymous with **Recall**.\n"
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True Positive Rate : 0.9868\n"
]
}
],
"source": [
"true_positive_rate = TP / float(TP + FN)\n",
"\n",
"\n",
"print('True Positive Rate : {0:0.4f}'.format(true_positive_rate))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### False Positive Rate"
]
},
{
"cell_type": "code",
"execution_count": 49,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False Positive Rate : 0.0688\n"
]
}
],
"source": [
"false_positive_rate = FP / float(FP + TN)\n",
"\n",
"\n",
"print('False Positive Rate : {0:0.4f}'.format(false_positive_rate))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Specificity"
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Specificity : 0.9312\n"
]
}
],
"source": [
"specificity = TN / (TN + FP)\n",
"\n",
"print('Specificity : {0:0.4f}'.format(specificity))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### f1-score\n",
"\n",
"\n",
"**f1-score** is the weighted harmonic mean of precision and recall. The best possible **f1-score** would be 1.0 and the worst \n",
"would be 0.0. **f1-score** is the harmonic mean of precision and recall. So, **f1-score** is always lower than accuracy measures as they embed precision and recall into their computation. The weighted average of `f1-score` should be used to \n",
"compare classifier models, not global accuracy.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Support\n",
"\n",
"\n",
"**Support** is the actual number of occurrences of the class in our dataset."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## ROC - AUC \n",
"\n",
"### ROC Curve\n",
"\n",
"\n",
"Another tool to measure the classification model performance visually is **ROC Curve**. ROC Curve stands for **Receiver Operating Characteristic Curve**. An **ROC Curve** is a plot which shows the performance of a classification model at various \n",
"classification threshold levels. \n",
"\n",
"\n",
"\n",
"The **ROC Curve** plots the **True Positive Rate (TPR)** against the **False Positive Rate (FPR)** at various threshold levels.\n",
"\n",
"\n",
"\n",
"**True Positive Rate (TPR)** is also called **Recall**. It is defined as the ratio of `TP to (TP + FN)`.\n",
"\n",
"\n",
"\n",
"**False Positive Rate (FPR)** is defined as the ratio of `FP to (FP + TN)`.\n",
"\n",
"\n",
"\n",
"In the ROC Curve, we will focus on the TPR (True Positive Rate) and FPR (False Positive Rate) of a single point. This will give us the general performance of the ROC curve which consists of the TPR and FPR at various threshold levels. So, an ROC Curve plots TPR vs FPR at different classification threshold levels. If we lower the threshold levels, it may result in more items being classified as positve. It will increase both True Positives (TP) and False Positives (FP).\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# plot ROC Curve\n",
"\n",
"from sklearn.metrics import roc_curve\n",
"\n",
"fpr, tpr, thresholds = roc_curve(y_test, y_pred_test)\n",
"\n",
"plt.figure(figsize=(6,4))\n",
"\n",
"plt.plot(fpr, tpr, linewidth=2)\n",
"\n",
"plt.plot([0,1], [0,1], 'k--' )\n",
"\n",
"plt.rcParams['font.size'] = 12\n",
"\n",
"plt.title('ROC curve for Predicting a Pulsar Star classifier')\n",
"\n",
"plt.xlabel('False Positive Rate (1 - Specificity)')\n",
"\n",
"plt.ylabel('True Positive Rate (Sensitivity)')\n",
"\n",
"plt.show()\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ROC curve help us to choose a threshold level that balances sensitivity and specificity for a particular context."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### ROC AUC\n",
"\n",
"\n",
"**ROC AUC** stands for **Receiver Operating Characteristic - Area Under Curve**. It is a technique to compare classifier performance. In this technique, we measure the `area under the curve (AUC)`. A perfect classifier will have a ROC AUC equal to 1, whereas a purely random classifier will have a ROC AUC equal to 0.5. \n",
"\n",
"\n",
"So, **ROC AUC** is the percentage of the ROC plot that is underneath the curve."
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"ROC AUC : 0.9171\n"
]
}
],
"source": [
"# compute ROC AUC\n",
"\n",
"from sklearn.metrics import roc_auc_score\n",
"\n",
"ROC_AUC = roc_auc_score(y_test, y_pred_test)\n",
"\n",
"print('ROC AUC : {:.4f}'.format(ROC_AUC))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Comments\n",
"\n",
"\n",
"- ROC AUC is a single number summary of classifier performance. The higher the value, the better the classifier.\n",
"\n",
"- ROC AUC of our model approaches towards 1. So, we can conclude that our classifier does a good job in classifying the pulsar star."
]
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Cross validated ROC AUC : 0.9756\n"
]
}
],
"source": [
"# calculate cross-validated ROC AUC \n",
"\n",
"from sklearn.model_selection import cross_val_score\n",
"\n",
"Cross_validated_ROC_AUC = cross_val_score(linear_svc, X_train, y_train, cv=10, scoring='roc_auc').mean()\n",
"\n",
"print('Cross validated ROC AUC : {:.4f}'.format(Cross_validated_ROC_AUC))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Stratified k-fold Cross Validation with shuffle split\n",
"\n",
"\n",
"k-fold cross-validation is a very useful technique to evaluate model performance. But, it fails here because we have a imbalnced dataset. So, in the case of imbalanced dataset, I will use another technique to evaluate model performance. It is called `stratified k-fold cross-validation`.\n",
"\n",
"\n",
"In `stratified k-fold cross-validation`, we split the data such that the proportions between classes are the same in each fold as they are in the whole dataset.\n",
"\n",
"\n",
"Moreover, I will shuffle the data before splitting because shuffling yields much better result."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Stratified k-Fold Cross Validation with shuffle split with linear kernel"
]
},
{
"cell_type": "code",
"execution_count": 54,
"metadata": {},
"outputs": [],
"source": [
"from sklearn.model_selection import KFold\n",
"\n",
"\n",
"kfold=KFold(n_splits=5, shuffle=True, random_state=0)\n",
"\n",
"\n",
"linear_svc=SVC(kernel='linear')\n",
"\n",
"\n",
"linear_scores = cross_val_score(linear_svc, X, y, cv=kfold)\n"
]
},
{
"cell_type": "code",
"execution_count": 55,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Stratified cross-validation scores with linear kernel:\n",
"\n",
"[0.98296089 0.97458101 0.97988827 0.97876502 0.97848561]\n"
]
}
],
"source": [
"# print cross-validation scores with linear kernel\n",
"\n",
"print('Stratified cross-validation scores with linear kernel:\\n\\n{}'.format(linear_scores))"
]
},
{
"cell_type": "code",
"execution_count": 56,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Average stratified cross-validation score with linear kernel:0.9789\n"
]
}
],
"source": [
"# print average cross-validation score with linear kernel\n",
"\n",
"print('Average stratified cross-validation score with linear kernel:{:.4f}'.format(linear_scores.mean()))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Stratified k-Fold Cross Validation with shuffle split with rbf kernel"
]
},
{
"cell_type": "code",
"execution_count": 57,
"metadata": {},
"outputs": [],
"source": [
"rbf_svc=SVC(kernel='rbf')\n",
"\n",
"\n",
"rbf_scores = cross_val_score(rbf_svc, X, y, cv=kfold)"
]
},
{
"cell_type": "code",
"execution_count": 58,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Stratified Cross-validation scores with rbf kernel:\n",
"\n",
"[0.97849162 0.97011173 0.97318436 0.9709416 0.96982397]\n"
]
}
],
"source": [
"# print cross-validation scores with rbf kernel\n",
"\n",
"print('Stratified Cross-validation scores with rbf kernel:\\n\\n{}'.format(rbf_scores))"
]
},
{
"cell_type": "code",
"execution_count": 59,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Average stratified cross-validation score with rbf kernel:0.9725\n"
]
}
],
"source": [
"# print average cross-validation score with rbf kernel\n",
"\n",
"print('Average stratified cross-validation score with rbf kernel:{:.4f}'.format(rbf_scores.mean()))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Comments\n",
"\n",
"\n",
"I obtain higher average stratified k-fold cross-validation score of 0.9789 with linear kernel but the model accuracy is 0.9832.\n",
"So, stratified cross-validation technique does not help to improve the model performance."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Hyperparameter Optimization using GridSearch CV"
]
},
{
"cell_type": "code",
"execution_count": 60,
"metadata": {},
"outputs": [],
"source": [
"# import GridSearchCV\n",
"from sklearn.model_selection import GridSearchCV\n",
"\n",
"\n",
"# import SVC classifier\n",
"from sklearn.svm import SVC\n",
"\n",
"\n",
"# instantiate classifier with default hyperparameters with kernel=rbf, C=1.0 and gamma=auto\n",
"svc=SVC() \n",
"\n",
"\n",
"\n",
"# declare parameters for hyperparameter tuning\n",
"parameters = [ {'C':[1, 10, 100, 1000], 'kernel':['linear']},\n",
" {'C':[1, 10, 100, 1000], 'kernel':['rbf'], 'gamma':[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]},\n",
" {'C':[1, 10, 100, 1000], 'kernel':['poly'], 'degree': [2,3,4] ,'gamma':[0.01,0.02,0.03,0.04,0.05]} \n",
" ]\n",
"\n",
"\n",
"\n",
"\n",
"grid_search = GridSearchCV(estimator = svc, \n",
" param_grid = parameters,\n",
" scoring = 'accuracy',\n",
" cv = 5,\n",
" verbose=0)\n",
"\n",
"\n",
"grid_search.fit(X_train, y_train)\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# examine the best model\n",
"\n",
"\n",
"# best score achieved during the GridSearchCV\n",
"print('GridSearch CV best score : {:.4f}\\n\\n'.format(grid_search.best_score_))\n",
"\n",
"\n",
"# print parameters that give the best results\n",
"print('Parameters that give the best results :','\\n\\n', (grid_search.best_params_))\n",
"\n",
"\n",
"# print estimator that was chosen by the GridSearch\n",
"print('\\n\\nEstimator that was chosen by the search :','\\n\\n', (grid_search.best_estimator_))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# calculate GridSearch CV score on test set\n",
"\n",
"print('GridSearch CV score on test set: {0:0.4f}'.format(grid_search.score(X_test, y_test)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Comments\n",
"\n",
"\n",
"- Our original model test accuracy is 0.9832 while GridSearch CV score on test-set is 0.9835.\n",
"\n",
"\n",
"- So, GridSearch CV helps to identify the parameters that will improve the performance for this particular model.\n",
"\n",
"\n",
"- Here, we should not confuse `best_score_` attribute of `grid_search` with the `score` method on the test-set. \n",
"\n",
"\n",
"- The `score` method on the test-set gives the generalization performance of the model. Using the `score` method, we employ a model trained on the whole training set.\n",
"\n",
"\n",
"- The `best_score_` attribute gives the mean cross-validation accuracy, with cross-validation performed on the training set."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Results and conclusion\n",
"\n",
"1. There are outliers in our dataset. So, as we increase the value of C to limit fewer outliers, the accuracy increased. This is true with different kinds of kernels.\n",
"\n",
"2.\tWe get maximum accuracy with `rbf` and `linear` kernel with C=100.0 and the accuracy is 0.9832. So, we can conclude that our model is doing a very good job in terms of predicting the class labels. But, this is not true. Here, we have an imbalanced dataset. Accuracy is an inadequate measure for quantifying predictive performance in the imbalanced dataset problem. So, we must explore `confusion matrix` that provide better guidance in selecting models. \n",
"\n",
"3.\tROC AUC of our model is very close to 1. So, we can conclude that our classifier does a good job in classifying the pulsar star.\n",
"\n",
"4.\tWe obtain higher average stratified k-fold cross-validation score of 0.9789 with linear kernel but the model accuracy is 0.9832. So, stratified cross-validation technique does not help to improve the model performance.\n",
"\n",
"5.\tOur original model test accuracy is 0.9832 while GridSearch CV score on test-set is 0.9835. So, GridSearch CV helps to identify the parameters that will improve the performance for this particular model.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Acknowledgments\n",
"\n",
"Thanks to PRASHANT BANERJEE for creating the open-source course [ SVM Classifier Tutorial ](https://www.kaggle.com/code/prashant111/svm-classifier-tutorial). It inspires the majority of the content in this chapter."
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3.8.6 64-bit",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.6"
},
"vscode": {
"interpreter": {
"hash": "e7e062254315b6c9f92abc9bc2bdcaf487fbb633b3956fd7c9b16e81ab674fff"
}
}
},
"nbformat": 4,
"nbformat_minor": 4
}