Tag: machine

Here is my code! I want to reduce the number of lines and make them look neater. This class implements the Naïve Bayes machine learning algorithm. Please help as much as possible. Many Thanks!

I tried to split more functions and then call them to do the work. Is there any way I can do more? Is there also a way to make the for loops more compact?

Import Heapq
Import sys
Import math as m
from the decimal import decimal

Class entry:
def __init __ (self, attributes):
self.attributes = attributes
self.diabetes = "yes" if "yes" in attributes "no" if "no" in attributes ""

def __str __ (self):
string = ""
for attributeNum attribute in enumerate (self.attributes):
if attributeNum == len (self.attributes) - 1:
String + = str (attribute)
otherwise:
String + = str (attribute) + & # 39 ;, & # 39;
Return string

def set_ifdiabetes (self, diabetes):
Auto diabetes = diabetes

defective Euclidean (self, other_entry):
sum = 0.0
for i in range (len (self.attributes)):
sum + = m.pow (float (self.attributes[i]) - float (other_entry.attributes[i]2)
Return m.sqrt (sum)

Class NB:
def __init __ (self, training_data, testing_data):
self.training_data = training_data
self.testing_data = testing_data

self.training_entries = []
        self.testing_entries = []

        self.diabetes_yes = []
        self.diabetes_no = []

        self.mu_diabetesyes = []
        self.mu_diabetesno = []

        self.sigma_diabetesyes = []
        self.sigma_diabetesno = []

        self.num_attributes = 0

self.p_diabetesyes = 0
self.p_diabetesno = 0

self.num_diabetesyes = 0
self.num_diabetesno = 0

def train (self):
self.traincleandata ()
self.get_mus ()
self.get_sigmas ()

def traincleandata (self):
for line in self.training_data:
if self.num_attributes == 0:
self.num_attributes = len (line.split (& # 39 ;, & # 39;))
for i in range (self.num_attributes):
self.diabetes_yes.append ([])
self.diabetes_no.append ([])
self.mu_diabetesyes.append (0.0)
self.mu_diabetesno.append (0.0)
self.sigma_diabetesyes.append (0.0)
self.sigma_diabetesno.append (0.0)
params = line.split (& # 39 ;, & # 39;)
cleanparams = getcleanparams (params)
entry = entry (cleanparams)
self.training_entries.append (entry)

if (entry.diabetes == "yes"):
for i in range (len (entry.attributes) - 1):
self.diabetes_yes[i].append (Decimal (entry.attributes[i]))
self.p_diabetesyes + = 1
self.num_diabetesyes + = 1
otherwise:
for i in range (len (entry.attributes) - 1):
self.diabetes_no[i].append (Decimal (entry.attributes[i]))
self.p_diabetesno + = 1
self.num_diabetesno + = 1

self.p_diabetesyes = decimal (self.p_diabetesyes) / len (self.training_entries)
self.p_diabetesno = decimal (self.p_diabetesno) / len (self.training_entries)

def get_mus (self):
for i in range (self.num_attributes - 1):
self.mu_diabetesyes[i] = sum (self.diabetes_yes[i]) / len (self.diabetes_yes[i])
self.mu_diabetesno[i] = Sum (self.diabetes_no[i]) / len (self.diabetes_no[i])

def get_sigmas (self):

sigSumYes = [0] * self.num_attributes
sigSumNo = [0] * self.num_attributes

for i in range (self.num_attributes - 1):
for j in range (self.num_diabetesyes):
sigSumYes[i] + = m.pow (self.diabetes_yes[i][j]    - self.mu_diabetesyes[i]2)
self.sigma_diabetesyes[i] = m.sqrt (sigSumYes[i] / (len (self.diabetes_yes[i]) - 1))
for j in range (self.num_diabetesno):
sigSumNo[i] + = m.pow (self.diabetes_no[i][j]    - self.mu_diabetesno[i]2)
self.sigma_diabetesno[i] = m.sqrt (sigSumNo[i] / (len (self.diabetes_no[i]) - 1))

Def-test (self):
self.testcleandata ()
self.testalgo ()

def testcleandata (self):
for line in self.testing_data:
params = line.split (& # 39 ;, & # 39;)
cleanparams = getcleanparams (params)
entry = entry (cleanparams)
self.testing_entries.append (entry)

def testalgo (self):
Counter = 1
P_diabetesyes = [0] * self.num_attributes
P_diabetesno = [0] * self.num_attributes
for the entry in self.testing_entries:
pYesEntry = 1
pNoEntry = 1
for i in range (self.num_attributes - 1):
P_diabetesyes[i] = Decimal number ((1 / (self.sigma_diabetesyes[i] * m.sqrt (2 * m.pi)) * m.pow (m.e, (-m.pow (Decimal (entry.attributes[i]) - self.mu_diabetesyes[i], 2) / (2 * m.pow (self.sigma_diabetesyes[i]2)))))
P_diabetesno[i] = Decimal number ((1 / (self.sigma_diabetesno[i] * m.sqrt (2 * m.pi)) * m.pow (m.e, (-m.pow (Decimal (entry.attributes[i]) -self.mu_diabetesno[i], 2) / (2 * m.pow (self.sigma_diabetesno[i]2)))))
pYesEntry * = float (P_diabetesyes[i])
pNoEntry * = float (P_diabetesno[i])

pYesEntry * = float (self.p_diabetesyes)
pNoEntry * = float (self.p_diabetesno)

entry.set_ifdiabetes ("yes") if (pYesEntry / pNoEntry> = 1) else entry.set_ifdiabetes ("no")
Counter + = 1

Class kNN:
def __init __ (self, training_data, testing_data, k):
self.k = k
self.training_data = training_data
self.testing_data = testing_data
self.training_entries = []
        self.testing_entries = []

    def __str __ (self):
string_to_return = & # 39; & # 39;
for the entry in self.training_entries:
string_to_return = string_to_return + str (input) + & # 39;  n & # 39;
return string_to_return

def train (self):
for line in self.training_data:
params = line.split (& # 39 ;, & # 39;)
self.training_entries.append (entry (getcleanparams (params))

Def-test (self):
Counter = 1
for line in self.testing_data:
params = line.split (& # 39 ;, & # 39;)
self.testing_entries.append (entry (getcleanparams (params))
for testEntry in self.testing_entries:
next []
            for trainEntry in self.training_entries:
current_entry = (testEntry.euclidean (trainEntry), str (trainEntry.diabetes), str (trainEntry))
next.append (current_entry)
heapq.heapify (next)
next.sort ()
next = closest[:int(self.k)]
            num_diabetes = 0
for entry in the immediate vicinity:
if (entry[1] == "yes"):
num_diabetes + = 1
testEntry.set_ifdiabetes ("yes") if (num_diabetes> = int (self.k) / 2) else testEntry.set_ifdiabetes ("no")
Counter + = 1

def compare (self):
for the entry in self.testing_entries:
to press("-----------")
print (entry.compare (self.training_entries[0]))
print (entry)
print (self.training_entries[0])


def getcleanparams (params):
params_nospaceortab = []
    for param in params:
params_nospaceortab.append (param.strip ())
return params_nospaceortab


if __name__ == & # 39; __ main __ & # 39 ;:
training_file = open (sys.argv[1])
testing_file = open (sys.argv[2])
classifier_input = sys.argv[3]

    training_lines = training_file.readlines ()
training_cleanlines = getcleanparams (training_lines)

testing_lines = testing_file.readlines ()
testing_cleanlines = getcleanparams (testing_lines)

if classifier_input == "NB":
Classifier = NB (training_cleanlines, testing_cleanlines)
classifier.train ()
classifier.test ()
for the entry in classifier.testing_entries:
print (entry.diabetes)
elif "NN" in classifier_input:
classifier = kNN (training_cleanlines, testing_cleanlines, (classifier_input.index (& # 39; NN & # 39;) - 1))
classifier.train ()
classifier.test ()
for the entry in classifier.testing_entries:
print (entry.diabetes)
otherwise:
print ("Error: unknown classifier type")
sys.exit ()