Data_Mining_Algorithms/NaiveBayes.py at master · ayushd96/Data_Mining_Algorithms · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
# %%
import csv
import math
import random
import pandas as pd
import time
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix

def loadCsv(filename):

    data = pd.read_csv("pulsar_stars.csv")
    dataset = data.values.tolist()
    return dataset

def separateByClass(dataset):
	separated = {}
	for i in range(len(dataset)):
		vector = dataset[i]
		if (vector[-1] not in separated):
			separated[vector[-1]] = []
		separated[vector[-1]].append(vector)
	return separated


def mean(numbers):
    return sum(numbers)/float(len(numbers))


def stdev(numbers):
    avg = mean(numbers)
    variance = sum([pow(x-avg,2) for x in numbers])/float(len(numbers)-1)
    return math.sqrt(variance)


def summarize(dataset):
	summaries = [(mean(attribute), stdev(attribute)) for attribute in zip(*dataset)]
	del summaries[-1]
	return summaries


def summarizeByClass(dataset):
	separated = separateByClass(dataset)
	summaries = {}
	for classValue, instances in separated.items():
		summaries[classValue] = summarize(instances)
	return summaries


def calculateProbability(x, mean, stdev):
	exponent = math.exp(-(math.pow(x-mean,2)/(2*math.pow(stdev,2))))
	return (1/(math.sqrt(2*math.pi)*stdev))*exponent


def calculateClassProbabilities(summaries, inputVector):
	probabilities = {}
	for classValue, classSummaries in summaries.items():
		probabilities[classValue] = 1
		for i in range(len(classSummaries)):
			mean, stdev = classSummaries[i]
			x = inputVector[i]
			probabilities[classValue] *= calculateProbability(x, mean, stdev)
	return probabilities

def predict(summaries, inputVector):
	probabilities = calculateClassProbabilities(summaries, inputVector)
	bestLabel, bestProb = None, -1
	for classValue, probability in probabilities.items():
		if bestLabel is None or probability > bestProb:
			bestProb = probability
			bestLabel = classValue
	return bestLabel


def getPredictions(summaries, testSet):
	predictions = []
	for i in range(len(testSet)):
		result = predict(summaries, testSet[i])
		predictions.append(result)
	return predictions


def getAccuracy(testSet, predictions):
	correct = 0
	for x in range(len(testSet)):
		if testSet[x][-1] == predictions[x]:
			correct += 1
	return (correct/float(len(testSet)))*100.0


def main():
    start = time.time()
    filename = 'pulsar_stars.csv'
    dataset = loadCsv(filename)
    trainingSet, testSet = train_test_split(dataset, test_size = 0.25)


    summaries = summarizeByClass(trainingSet)

    predictions = getPredictions(summaries, testSet)
    accuracy = getAccuracy(testSet, predictions)
    testSet_confusion_matrix = pd.DataFrame(testSet)
    testSet_confusion_matrix = testSet_confusion_matrix.iloc[:,-1]
    testSet_confusion_matrix = testSet_confusion_matrix.values.tolist()
    cm = confusion_matrix(testSet_confusion_matrix, predictions)

    end = time.time()
    TP = cm[0][0]
    FP = cm[0][1]
    FN = cm[1][0]
    TN = cm[1][1]

    Sensitivity = TP / (TP + FN)
    Specificity = TN / (TN + FP)
    Precision = TP / (TP+FP)
    Recall = TP / (TP+FN)


    print('-------------------------------------------------------------')
    print('Naive Bayes ----- >')
    print('-------------------------------------------------------------')
    print(f'Total length of dataset ----- > {len(dataset)}')
    print(f'Length of Training set ------ > {len(trainingSet)}')
    print(f'Length of Testing set ------ > {len(testSet)}')
    print(f' Confusion Matrix for Naive Bayes:' )
    print(cm)
    print('Accuracy of Naive Bayes algorithm: {0}%'.format(accuracy))
    print('\n')
    print(f'Sensitivity obtained for Naive bayes : {Sensitivity}')
    print(f'Specificity obtained for Naive bayes : {Specificity}\n')
    print(f'Precision : {Precision}')
    print(f'Recall : {Recall} \n')

    print(f'Time taken to model Naive Bayes ------- > {end-start}s \n')

main()


# %%
import csv
import math
import random
import pandas as pd
import time
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix

def loadCsv(filename):

    data = pd.read_csv("pulsar_stars.csv")
    #data.iloc[:,-1] = data.iloc[:,-1].map({'M':1,'B':0})
    dataset = data.values.tolist()
    return dataset