classification in machine learning

classification may be defined as the process of predicting class or category from observed values or given data points. the categorized output can have the form such as "black" or "white" or "spam" or "no spam".

classification in machine learning is a supervised learning technique where an algorithm is trained with labeled data to predict the category of new data.

mathematically, classification is the task of approximating a mapping function (f) from input variables (x) to output variables (y). it is basically belongs to the supervised machine learning in which targets are also provided along with the input data set.

an example of classification problem can be the spam detection in emails. there can be only two categories of output, "spam" and "no spam"; hence this is a binary type classification.

to implement this classification, we first need to train the classifier. for this example, "spam" and "no spam" emails would be used as the training data. after successfully train the classifier, it can be used to detect an unknown email.

types of learners in classification

we have two types of learners in respective to classification problems −

lazy learners − as the name suggests, such kind of learners waits for the testing data to be appeared after storing the training data. classification is done only after getting the testing data. they spend less time on training but more time on predicting. examples of lazy learners are k-nearest neighbor and case-based reasoning.
eager learners − as opposite to lazy learners, eager learners construct classification model without waiting for the testing data to be appeared after storing the training data. they spend more time on training but less time on predicting. examples of eager learners are decision trees, nave bayes and artificial neural networks (ann).

classification algorithms in machine learning

the classification algorithm is a type of supervised learning technique that involves predicting a categorical target variable based on a set of input features. it is commonly used to solve problems such as spam detection, fraud detection, image recognition, sentiment analysis, and many others.

the goal of a classification model is to learn a mapping function (f) between the input features (x) and the target variable (y). this mapping function is often represented as a decision boundary, which separates different classes in the input feature space. once the model is trained, it can be used to predict the class of new, unseen examples.

the followings are some important ml classification algorithms −

logistic regression
k-nearest neighbors (knn)
support vector machine (svm)
decision tree
nave bayes
random forest

we will be discussing all these classification algorithms in detail in further chapters. however let's discuss these algorithms in brief as follows −

logistic regression

logistic regression is a popular algorithm used for binary classification problems, where the target variable is categorical with two classes. it models the probability of the target variable given the input features and predicts the class with the highest probability.

logistic regression is a type of generalized linear model, where the target variable follows a bernoulli distribution. the model consists of a linear function of the input features, which is transformed using the logistic function to produce a probability value between 0 and 1.

k-nearest neighbors (knn)

k-nearest neighbors (knn) is a supervised learning algorithm that can be used for both classification and regression problems. the main idea behind knn is to find the k-nearest data points to a given test data point and use these nearest neighbors to make a prediction. the value of k is a hyperparameter that needs to be tuned, and it represents the number of neighbors to consider.

for classification problems, the knn algorithm assigns the test data point to the class that appears most frequently among the k-nearest neighbors. in other words, the class with the highest number of neighbors is the predicted class.

for regression problems, the knn algorithm assigns the test data point the average of the k-nearest neighbors' values.

support vector machine (svm)

support vector machines (svms) are powerful yet flexible supervised machine learning algorithm which is used for both classification and regression. but generally, they are used in classification problems. in 1960s, svms were first introduced but later they got refined in 1990 also. svms have their unique way of implementation as compared to other machine learning algorithms. now a days, they are extremely popular because of their ability to handle multiple continuous and categorical variables.

decision tree

the decision tree algorithm is a hierarchical tree-based algorithm that is used to classify or predict outcomes based on a set of rules. it works by splitting the data into subsets based on the values of the input features. the algorithm recursively splits the data until it reaches a point where the data in each subset belongs to the same class or has the same value for the target variable. the resulting tree is a set of decision rules that can be used to make predictions or classify new data.

nave bayes

the nave bayes algorithm is a classification algorithm based on bayes' theorem. the algorithm assumes that the features are independent of each other, which is why it is called "naive." it calculates the probability of a sample belonging to a particular class based on the probabilities of its features. for example, a phone may be considered as smart if it has touch-screen, internet facility, good camera, etc. even if all these features are dependent on each other, but all these features independently contribute to the probability of that the phone is a smart phone.

random forest

random forest is a machine learning algorithm that uses an ensemble of decision trees to make predictions. the algorithm was first introduced by leo breiman in 2001. the key idea behind the algorithm is to create a large number of decision trees, each of which is trained on a different subset of the data. the predictions of these individual trees are then combined to produce a final prediction.

applications of classification in machine learning

some of the most important applications of classification algorithms are as follows −

speech recognition
handwriting recognition
biometric identification
document classification
image classification
spam filtering
fraud detection
facial recognition

building a classication model in machine learning

let us now take a look at the steps involved in building a classification model −

1. data preparation

the first step is to collect and preprocess the data. this involves cleaning the data, handling missing values, and converting categorical variables to numerical values.

2. feature extraction/selection

the next step is to extract or select relevant features from the data. this is an important step because the quality of the features can greatly impact the performance of the model. some common feature selection techniques include correlation analysis, feature importance ranking, and principal component analysis.

3. model selection

once the features are selected, the next step is to choose an appropriate classification algorithm. there are many different algorithms to choose from, each with its own strengths and weaknesses. some popular algorithms include logistic regression, decision trees, random forests, support vector machines, and neural networks

4. model training

after selecting a suitable algorithm, the next step is to train the model on the labeled training data. during training, the model learns the mapping function between the input features and the target variable. the model parameters are adjusted iteratively to minimize the difference between the predicted outputs and the actual outputs.

5. model evaluation

once the model is trained, the next step is to evaluate its performance on a separate set of validation data. this is done to estimate the model's accuracy and generalization performance. common evaluation metrics include accuracy, precision, recall, f1-score, and area under the receiver operating characteristic (roc) curve.

5. hyperparameter tuning

in many cases, the performance of the model can be further improved by tuning its hyperparameters. hyperparameters are settings that are chosen before training the model and control aspects such as the learning rate, regularization strength, and the number of hidden layers in a neural network. grid search, random search, and bayesian optimization are some common techniques used for hyperparameter tuning.

6. model deployment

once the model has been trained and evaluated, the final step is to deploy it in a production environment. this involves integrating the model into a larger system, testing it on realworld data, and monitoring its performance over time.

building a classification model with python

scikit-learn, a python library for machine learning can be used to build a classifier in python. the steps for building a classifier in python are as follows −

step 1: importing necessary python package

for building a classifier using scikit-learn, we need to import it. we can import it by using following script −

import sklearn

step 2: importing dataset

after importing necessary package, we need a dataset to build classification prediction model. we can import it from sklearn dataset or can use other one as per our requirement. we are going to use sklearns breast cancer wisconsin diagnostic database. we can import it with the help of following script −

from sklearn.datasets import load_breast_cancer

the following script will load the dataset;

data = load_breast_cancer()

we also need to organize the data and it can be done with the help of following scripts −

label_names = data['target_names']
labels = data['target']
feature_names = data['feature_names']
features = data['data']

the following command will print the name of the labels, malignant and 'benign' in case of our database.

print(label_names)

the output of the above command is the names of the labels −

['malignant' 'benign']

these labels are mapped to binary values 0 and 1. malignant cancer is represented by 0 and benign cancer is represented by 1.

the feature names and feature values of these labels can be seen with the help of following commands −

print(feature_names[0])

the output of the above command is the names of the features for label 0 i.e. malignant cancer −

mean radius

similarly, names of the features for label can be produced as follows −

print(feature_names[1])

the output of the above command is the names of the features for label 1 i.e. benign cancer −

mean texture

we can print the features for these labels with the help of following command −

print(features[0])

this will give the following output −

[1.799e+01 1.038e+01 1.228e+02 1.001e+03 1.184e-01 2.776e-01 3.001e-01
 1.471e-01 2.419e-01 7.871e-02 1.095e+00 9.053e-01 8.589e+00 1.534e+02
 6.399e-03 4.904e-02 5.373e-02 1.587e-02 3.003e-02 6.193e-03 2.538e+01
 1.733e+01 1.846e+02 2.019e+03 1.622e-01 6.656e-01 7.119e-01 2.654e-01
 4.601e-01 1.189e-01]

we can print the features for these labels with the help of following command −

print(features[1])

this will give the following output −

[2.057e+01 1.777e+01 1.329e+02 1.326e+03 8.474e-02 7.864e-02 8.690e-02
7.017e-02  1.812e-01 5.667e-02 5.435e-01 7.339e-01 3.398e+00 7.408e+01
5.225e-03  1.308e-02 1.860e-02 1.340e-02 1.389e-02 3.532e-03 2.499e+01
2.341e+01  1.588e+02 1.956e+03 1.238e-01 1.866e-01 2.416e-01 1.860e-01
2.750e-01  8.902e-02]

step 3: organizing data into training & testing sets

as we need to test our model on unseen data, we will divide our dataset into two parts: a training set and a test set. we can use train_test_split() function of sklearn python package to split the data into sets. the following command will import the function −

from sklearn.model_selection import train_test_split

now, next command will split the data into training & testing data. in this example, we are using taking 40 percent of the data for testing purpose and 60 percent of the data for training purpose −

train, test, train_labels, test_labels = 
   train_test_split(features,labels,test_size = 0.40, random_state = 42)

step 4: model evaluation

after dividing the data into training and testing we need to build the model. we will be using nave bayes algorithm for this purpose. the following commands will import the gaussiannb module −

from sklearn.naive_bayes import gaussiannb

now, initialize the model as follows −

gnb = gaussiannb()

next, with the help of following command we can train the model −

model = gnb.fit(train, train_labels)

now, for evaluation purpose we need to make predictions. it can be done by using predict() function as follows −

preds = gnb.predict(test)
print(preds)

this will give the following output −

[1 0 0 1 1 0 0 0 1 1 1 0 1 0 1 0 1 1 1 0 1 1 0 1 1 1 1 1 1 0 1 1 1 1 1 1 0
 1 0 1 1 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 0 0 1 1 0 0 1 1 1 0 0 1 1 0 0 1 0
 1 1 1 1 1 1 0 1 1 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 1 0 0 1 0 0 1 1 1 0 1 1 0
 1 1 0 0 0 1 1 1 0 0 1 1 0 1 0 0 1 1 0 0 0 1 1 1 0 1 1 0 0 1 0 1 1 0 1 0 0
 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 1 1 0 1 1 1 1 1 1 0 0
 0 1 1 0 1 0 1 1 1 1 0 1 1 0 1 1 1 0 1 0 0 1 1 1 1 1 1 1 1 0 1 1 1 1 1 0 1
 0 0 1 1 0 1]

the above series of 0s and 1s in output are the predicted values for the malignant and benign tumor classes.

step 5: finding accuracy

we can find the accuracy of the model build in previous step by comparing the two arrays namely test_labels and preds. we will be using the accuracy_score() function to determine the accuracy.

from sklearn.metrics import accuracy_score
print(accuracy_score(test_labels,preds))
0.951754385965

the above output shows that navebayes classifier is 95.17% accurate.

evaluation metrics for classification model

the job is not done even if you have finished implementation of your machine learning application or model. we must have to find out how effective our model is? there can be different evaluation/ performance metrics, but we must choose it carefully because the choice of metrics influences how the performance of a machine learning algorithm is measured and compared.

the following are some of the important classification evaluation metrics among which you can choose based upon your dataset and kind of problem −

confusion matrix

the confusion matrix is the easiest way to measure the performance of a classification problem where the output can be of two or more type of classes. a confusion matrix is nothing but a table with two dimensions viz. "actual" and "predicted" and furthermore, both the dimensions have "true positives (tp)", "true negatives (tn)", "false positives (fp)", "false negatives (fn)" as shown below −

the explanation of the terms associated with confusion matrix are as follows −

true positives (tp) − it is the case when both actual class & predicted class of data point is 1.
true negatives (tn) − it is the case when both actual class & predicted class of data point is 0.
false positives (fp) − it is the case when actual class of data point is 0 & predicted class of data point is 1.
false negatives (fn) − it is the case when actual class of data point is 1 & predicted class of data point is 0.

we can find the confusion matrix with the help of confusion_matrix() function of sklearn. with the help of the following script, we can find the confusion matrix of above built binary classifier −

from sklearn.metrics import confusion_matrix
preds = gnb.predict(test)
cm = confusion_matrix(test, preds)
print(cm)

output

[
   [ 73   7]
   [  4 144]
]

accuracy

it may be defined as the number of correct predictions made by our ml model. we can easily calculate it by confusion matrix with the help of following formula −

$$\mathrm{accuracy=\frac{tp+tn}{tp+fp+fn+tn}}$$

for above built binary classifier, tp + tn = 73+144 = 217 and tp+fp+fn+tn = 73+7+4+144=228.

hence, accuracy = 217/228 = 0.951754385965 which is same as we have calculated after creating our binary classifier.

precision

precision, used in document retrievals, may be defined as the number of correct documents returned by our ml model. we can easily calculate it by confusion matrix with the help of following formula −

$$\mathrm{precision=\frac{tp}{tp+fp}}$$

for the above built binary classifier, tp = 73 and tp+fp = 73+7 = 80.

hence, precision = 73/80 = 0.915

recall or sensitivity

recall may be defined as the number of positives returned by our ml model. we can easily calculate it by confusion matrix with the help of following formula −

$$\mathrm{recall=\frac{tp}{tp+fn}}$$

for above built binary classifier, tp = 73 and tp+fn = 73+4 = 77.

hence, precision = 73/77 = 0.94805

specificity

specificity, in contrast to recall, may be defined as the number of negatives returned by our ml model. we can easily calculate it by confusion matrix with the help of following formula −

$$\mathrm{specificity=\frac{tn}{tn+fp}}$$

for the above built binary classifier, tn = 144 and tn+fp = 144+7 = 151.

hence, precision = 144/151 = 0.95364

in the subsequent chapters, we will discuss some of the most popular classification algorithms in machine learning in detail.

Save or share this article