'medical'),
("""What did the beaver say to the log?""", 'medical'),
("""Where in the world do you come up with these questions????""",
'real-life'),
("""even though i also agree that the girls on Love Hina are pretty scrumptious""",
'real-life'),
("""I miss Aaliyah, she was a great singer.""", 'medical'),
("""and the blond says Great they already put me on my first murder mystery case""",
'real-life'),
]
if __name__ == '__main__':
sample = input()
docs = [item[0] for item in train_data]
labels = [item[1] for item in train_data]
dataset, df, N, vocab = create_dataset(docs, labels)
t1 = build_tree(dataset)
vector = process_document(sample, df, N, vocab)
cl = NaiveBayes(get_words)
for item in train_data:
cl.train(item[0], item[1])
# cl.classify_document(sample)
# cos = rank_documents(doc, sim_func= cosine) isto i za pears
[6.7, 3.1, 4.4, 1.4, 2], [6.0, 2.7, 5.1, 1.6, 2],
[6.5, 3.0, 5.5, 1.8, 0], [6.1, 3.0, 4.9, 1.8, 0],
[5.6, 3.0, 4.1, 1.3, 2], [4.7, 3.2, 1.6, 0.2, 1],
[6.6, 3.0, 4.4, 1.4, 2]]
from decision_tree_learning import build_tree, entropy, classify
if __name__ == '__main__':
x = input().split(', ')
test_case = list(map(float, x[:-1])) + [int(x[-1])]
test1 = dataset[:int(len(dataset) * 0.3)]
test2 = dataset[int(len(dataset) * 0.3):int(len(dataset) * 0.6)]
test3 = dataset[int(len(dataset) * 0.6):]
drvo1 = build_tree(test1, entropy)
drvo2 = build_tree(test2, entropy)
drvo3 = build_tree(test3, entropy)
glasovi = {0: 0, 1: 0, 2: 0}
klasa1 = max(classify(test_case, drvo1).items(), key=lambda x: x[1])[0]
klasa1 = ''
max = 0
for x in classify(test_case, drvo1).items():
if x[1] > max:
max = x[1]
klasa1 = x[0]
klasa2 = ''
max = 0
[600.0, 29.4, 32.0, 37.2, 41.5, 15.0, 'Bream'],
[145.0, 22.0, 24.0, 25.5, 25.0, 15.0, 'Perch'],
[1100.0, 40.1, 43.0, 45.5, 27.5, 16.3, 'Perch']]
from math import log10
log2 = lambda x: log10(x) / log10(2)
if __name__ == "__main__":
test_case = input()
test_case = [float(x) for x in test_case.split(', ')[:-1]] + [test_case.split(', ')[-1]]
from decision_tree_learning import build_tree, classify, entropy
lista = []
for x in data:
if x[-1] == 'Roach':
lista.append(x)
lista2 = []
for x in data:
if x[-1] == 'Pike':
lista2.append(x)
train_data = lista[0:40] + lista2[0:40]
tree = build_tree(train_data, entropy)
print(max(classify(test_case, tree).items(), key=lambda x: x[1])[0])
['google', 'UK', 'no', 21, 'Premium'],
['(direct)', 'New Zealand', 'no', 12, 'None'],
['(direct)', 'UK', 'no', 21, 'Basic'],
['google', 'USA', 'no', 24, 'Premium'],
['slashdot', 'France', 'yes', 19, 'None'],
['digg', 'USA', 'no', 18, 'None'],
['google', 'UK', 'no', 18, 'None'],
['kiwitobes', 'UK', 'no', 19, 'None'],
['digg', 'New Zealand', 'yes', 12, 'Basic'],
['slashdot', 'UK', 'no', 21, 'None'],
['google', 'UK', 'yes', 18, 'Basic'],
['kiwitobes', 'France', 'yes', 19, 'Basic']]
test_cases = [['google', 'MK', 'no', 24, 'Unknown'],
['google', 'MK', 'no', 15, 'Unknown'],
['digg', 'UK', 'yes', 21, 'Unknown'],
['digg', 'UK', 'no', 25, 'Unknown']]
if __name__ == '__main__':
tree = build_tree(my_data, entropy)
print(tree)
for row in test_cases:
result = classify(row, tree)
# Opcija 1
import operator
class_name = max(result.items(), key=operator.itemgetter(1))[0]
# Opcija 2
class_name = max(result.items(), key=lambda x: x[1])[0]
print(row)
print(class_name)
[6.7, 3.1, 4.4, 1.4, 2], [6.0, 2.7, 5.1, 1.6, 2],
[6.5, 3.0, 5.5, 1.8, 0], [6.1, 3.0, 4.9, 1.8, 0],
[5.6, 3.0, 4.1, 1.3, 2], [4.7, 3.2, 1.6, 0.2, 1],
[6.6, 3.0, 4.4, 1.4, 2]]
from decision_tree_learning import build_tree, classify, entropy
if __name__ == '__main__':
x = input().split(', ')
test_case = list(map(float, x[:-1])) + [int(x[-1])]
mnoz1 = dataset[:int(len(dataset) * 0.3)]
mnoz2 = dataset[int(len(dataset) * 0.3):int(len(dataset) * 0.6)]
mnoz3 = dataset[int(len(dataset) * 0.6):]
drvo1 = build_tree(mnoz1, entropy)
drvo2 = build_tree(mnoz2, entropy)
drvo3 = build_tree(mnoz3, entropy)
glasovi = {0: 0, 1: 0, 2: 0}
klasa1 = max(classify(test_case, drvo1).items(), key=lambda x: x[1])[0]
klasa2 = max(classify(test_case, drvo2).items(), key=lambda x: x[1])[0]
klasa3 = max(classify(test_case, drvo3).items(), key=lambda x: x[1])[0]
glasovi[klasa1] += 1
glasovi[klasa2] += 1
glasovi[klasa3] += 1
sorted_klasi = list(
sorted(glasovi.items(), key=lambda x: x[1], reverse=True))
if __name__ == "__main__":
att1 = float(input())
att2 = float(input())
att3 = float(input())
att4 = float(input())
planttype = input()
testCase = [att1, att2, att3, att4, planttype]
from decision_tree_learning import build_tree, classify, entropy
golemina = len(trainingData) // 2
set1 = trainingData[:golemina]
set2 = trainingData[golemina:]
drvo1 = build_tree(set1, entropy)
drvo2 = build_tree(set2, entropy)
prediction1 = classify(testCase, drvo1)
prediction2 = classify(testCase, drvo2)
class1 = ''
max_value = 0
# Alternativno resenie e upotreba na lista i sort na listata za da se sortiraat klasite
# possible_values = []
for x in prediction1.items():
if x[1] > max_value:
max_value = x[1]
class1 = x[0]
# possible_values = [x[0]]
elif x[1] == max_value:
if __name__ == '__main__':
train = dataset[:int(len(dataset) * 0.8)]
test = dataset[int(len(dataset) * 0.8):]
column_ind = int(input())
train_new = []
for x in train:
row_new = x[:]
row_new.pop(column_ind)
train_new.append(row_new)
test_new = []
for x in test:
row_new = x[:]
row_new.pop(column_ind)
test_new.append(row_new)
drvo1 = build_tree(train, entropy)
drvo2 = build_tree(train_new, entropy)
brojach = 0
for x in test:
klasa = max(classify(x, drvo1).items(), key=lambda x: x[1])[0]
if klasa == x[-1]:
brojach += 1
print(brojach / len(test))
brojach2 = 0
for x in test_new:
klasa = max(classify(x, drvo2).items(), key=lambda x: x[1])[0]
if klasa == x[-1]:
brojach2 += 1
if __name__ == "__main__":
column_ind = int(input())
# Vashiot kod tuka
divide = (len(dataset) * 80) // 100
train_data = dataset[:divide]
test_data = dataset[divide:]
copy_train_data = copy.deepcopy(train_data)
copy_test_data = copy.deepcopy(train_data)
t1 = build_tree(train_data)
t2 = build_tree(del_column(copy_train_data, column_ind))
total = len(test_data)
hits_t1 = 0
for item in test_data:
prediction1 = get_max_prediction_custom(classify(item, t1))
if prediction1 == item[-1]:
hits_t1 += 1
del_column(copy_test_data, column_ind)
sample = input()
from document_classification import NaiveBayes, get_words
classifier = NaiveBayes(get_words)
for train_sample in train_data:
classifier.train(train_sample[0], train_sample[1])
class1 = classifier.classify_document(sample)
print(f'Klasa so Naiven baesov klasifikator: {class1}')
from decision_tree_learning import build_tree, classify,\
print_tree, entropy
from tf_idf import create_dataset, process_document
documents = [t[0] for t in train_data]
labels = [t[1] for t in train_data]
dataset, df, N, vocab = create_dataset(documents, labels)
tree = build_tree(dataset, entropy)
# print_tree(tree)
sample_vector = process_document(sample, df, N, vocab)
class2 = sorted(classify(sample_vector, tree).items(),
key=lambda x: x[1])[0][0]
print(f'Klasa dobiena so drva na odluka: {class2}')
if class1 == class2:
print('Dvata klasifikatori predviduvaat ista klasa')
else:
print('Dvata klasifikatori ne predviduvaat ista klasa')
