What Is Naive Bayes Algorithm In Machine Learning?

  • Rohit Dwivedi
  • Apr 29, 2020
  • Machine Learning
  • Updated on: Jan 18, 2021
What Is Naive Bayes Algorithm In Machine Learning? title banner

Consider a case where you have created features, you know about the importance of features and you are supposed to make a classification model that is to be presented in a very short period of time? 

 

What will you do? You have a very large volume of data points and very less few features in your data set. In that situation if I had to make such a model I would have used ‘Naive Bayes’, that is considered to be a really fast algorithm when it comes for classification tasks. 

 

In this blog, I am trying to explain how the algorithm works that can be used in these kinds of scenarios. If you want to know what is classification and other such algorithms you can refer here.

 

Naive Bayes is a machine learning model that is used for large volumes of data, even if you are working with data that has millions of data records the recommended approach is Naive Bayes. It gives very good results when it comes to NLP tasks such as sentimental analysis. It is a fast and uncomplicated classification algorithm.

 

To understand the naive Bayes classifier we need to understand the Bayes theorem. So let’s first discuss the Bayes Theorem. 

 

Bayes Theorem

 

It is a theorem that works on conditional probability. Conditional probability is the probability that something will happen, given that something else has already occurred. The conditional probability can give us the probability of an event using its prior knowledge. 

 

Conditional probability:

 

formula for conditional probability in Naive Bayes Classifier

Conditional Probability

Where, 

P(A): The probability of hypothesis H being true. This is known as the prior probability.

P(B): The probability of the evidence.

P(A|B): The probability of the evidence given that hypothesis is true.  

P(B|A): The probability of the hypothesis given that the evidence is true.

 

 

Naive Bayes Classifier

 

  • It is a kind of classifier that works on Bayes theorem.

  • Prediction of membership probabilities is made for every class such as the probability of data points associated to a particular class.

  • The class having maximum probability is appraised as the most suitable class.

  • This is also referred as Maximum A Posteriori (MAP). 
  • The MAP for a hypothesis is: 

    • 𝑀𝐴𝑃 (𝐻) = max 𝑃((𝐻|𝐸))  

    • 𝑀𝐴𝑃 (𝐻) = max 𝑃((𝐻|𝐸)  ∗ (𝑃(𝐻)) /𝑃(𝐸))  

    • 𝑀𝐴𝑃 (𝐻) = max(𝑃(𝐸|𝐻) ∗ 𝑃(𝐻))

    • 𝑃 (𝐸) is evidence probability, and it is used to normalize the result. The result will not be affected by removing 𝑃(𝐸).

 

  • NB classifiers conclude that all the variables or features are not related to each other.

  • The Existence or absence of a variable does not impact the existence or absence of any other variable.

  • Example:  

    • Fruit may be observed to be an apple if it is red, round, and about 4″ in diameter.

    • In this case also even if all the features are interrelated to each other, and NB classifier will observe all of these independently contributing to the probability that the fruit is an apple.  

  • We experiment with the hypothesis in real datasets, given multiple features. 

  • So, computation becomes complex.

 

 

Types Of Naive Bayes Algorithms

 

1. Gaussian Naïve Bayes:  When characteristic values are continuous in nature then an assumption is made that the values linked with each class are dispersed according to Gaussian that is Normal Distribution.

 

2. Multinomial Naïve Bayes: Multinomial Naive Bayes is favored to use on data that is multinomial distributed. It is widely used in text classification in NLP.  Each event in text classification constitutes the presence of a word in a document.

 

3. Bernoulli Naïve Bayes:  When data is dispensed according to the multivariate Bernoulli distributions then Bernoulli Naive Bayes is used. That means there exist multiple features but each one is assumed to contain a binary value. So, it requires features to be binary-valued.

 

Advantages And Disadvantages Of Naive Bayes

 

Advantages:

 

  • It is a highly extensible algorithm which is very fast.

  • It can be used for both binaries as well as multiclass classification.

  • It has mainly three different types of algorithms that are GaussianNB, MultinomialNB, BernoulliNB.

  • It is a famous algorithm for spam email classification.

  • It can be easily trained on small datasets and can be used for large volumes of data as well.

 

 

Disadvantages:

 

  • The main disadvantage of the NB is considering all the variables independent that contributes to the probability. 

 

 

Applications of Naive Bayes Algorithms

 

  • Real-time Prediction:  Being a fast learning algorithm can be used to make predictions in real-time as well.

  • MultiClass Classification:  It can be used for multi-class classification problems also.

  • Text Classification: As it has shown good results in predicting multi-class classification so it has more success rates compared to all other algorithms. As a result, it is majorly used in sentiment analysis & spam detection.

 

 

Hands-On Problem Statement

 

The problem statement is to classify patients as diabetic or non-diabetic. The dataset can be downloaded from the Kaggle website that is ‘PIMA INDIAN DIABETES DATABASE’. The datasets had several different medical predictor features and a target that is ‘Outcome’. Predictor variables include the number of pregnancies the patient has had, their BMI, insulin level, age, and so on.


import numpy as np
import pandas as pd
import seaborn as sns
sns.set(color_codes=True)
import matplotlib.pyplot as plt
%matplotlib inline
from sklearn.preprocessing import StandardScaler
 
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn import metrics
 
colnames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
pima_df = pd.read_csv("pima-indians-diabetes.data", names= colnames)
 
X = data.drop(Outcome”, axis = 1)
Y = data[ [“outcome”] ]
X_train, X_test, Y_train, Y_test = train_test_split(X,Y, test_size= 0.2, random_state = 1)
 
model = GaussianNB()
model.fit(X_train, Y_train)
Y_pred = model.predict(X_test)

Code implementation of importing and splitting the data


STEPS-

 

  • Initially, all the necessary libraries are imported like numpy, pandas, train-test_split, GaussianNB, metrics.
  • Since it is a data file with no header, we will supply the column names that have been obtained from the above URL 
  • Created a python list of column names called "names".
  • Initialized predictor variables and the target that is X and Y respectively.
  • Transformed the data using StandardScaler.
  • Split the data into training and test sets.
  • Created an object for GaussianNB.
  • Fitted the data in the model to train it.
  • Made predictions on the test set and stored it in a ‘predictor’ variable.


For doing the exploratory data analysis of the dataset you can look for the techniques.


from sklearn import metrics
 
# make predictions
predicted = model.predict(X_test)
from sklearn.metrics import accuracy_score, confusion_matrix
metrics.confusion_matrix(predicted, y_test)

confusion matrix of the diabetes dataset

Confusion-matrix & model score test data


  • Imported accuracy_score and confusion_matrix from sklearn.metrics. Printed the confusion matrix between predicted and actual that tells us the actual performance of the model.
  • Calculated the model_score of the testing data to know how good is the model performing in generalizing the two classes which came out to be 74%.

 

model_score = model.score(X_test, y_test)
model_score

 

model score for the diabetic dataset

 

Evaluation of the model


y_predictProb = model.predict_proba(X_test)
from sklearn.metrics import auc, roc_curve
fpr, tpr, thresholds = roc_curve(y_test, y_predictProb[::,1])
roc_auc = auc(fpr, tpr)
roc_auc

 

receiver operating characteristic score

Roc_score


  • Imported auc, roc_curve again from sklearn.metrics.
  • Printed roc_auc score between false positive and true positive that came out to be 79%.
  • Imported matplotlib.pyplot library to plot the roc_curve.
  • Printed the roc_curve.
plt.plot(fpr, tpr, color='darkorange', label='ROC curve (area = %0.2f)' % roc_auc)
plt.plot([0, 1], [0, 1], color='navy', linestyle='--')
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver operating characteristic')
plt.legend(loc="lower right")

 

Roc curve is shown with the help of matplotlib library

Roc_curve


The receiver operating characteristic curve also known as roc_curve is a plot that tells about the interpretation potential of a binary classifier system. It is plotted between the true positive rate and the false positive rate at different thresholds. The ROC curve area was found to be 0.80.

 

For the python file and also the used dataset in the above problem you can refer to the Github link here that contains both. 

 

Conclusion

 

In this blog, I have discussed Naive Bayes algorithms used for classification tasks in different contexts. I have discussed what is the role of Bayes theorem in NB Classifier, different characteristics of NB, advantages, and disadvantages of NB, application of NB, and in the last I have taken a problem statement from Kaggle that is about classifying patients as diabetic or not. 

0%

Comments