def circle_fitting():
x = np.array([[2, 2], [2, -2], [-2, 2], [-2, -2], [3, 3], [3, -3], [-3, 3],
[-3, -3], [0, 0], [1, 1], [1, -1], [-1, 1], [-1, -1],
[1.5, 1.5], [-1.5, 1.5], [1.5, -1.5], [-1.5, -1.5]])
labels = np.append(np.ones((8, 1)), np.zeros((9, 1))).reshape((17, 1))
data = np.concatenate((x, x[:, 0].reshape(17, 1)**2), axis=1)
perceptron = classification.PerceptronClassifier(data, labels)
perceptron.train()
print("Accuracy = {}".format(perceptron.test_set_accuracy()))
t = np.linspace(-20, 20, 100)
plt.plot(
t, -(perceptron.weights[0] + perceptron.weights[1] * t +
perceptron.weights[3] * t**2) / perceptron.weights[2])
plt.scatter(x[:8, 0], x[:8, 1], c="b")
plt.scatter(x[8:, 0], x[8:, 1], c="r")
plt.show()
def parabola_fitting():
x = np.linspace(-5, 5, 22).reshape((22, 1))
data = np.concatenate((x, x**2, x**2 + 1), axis=1)
data = np.concatenate((data, np.concatenate((x, x**2, x**2 - 1), axis=1)),
axis=0)
labels = np.append(np.ones(22), np.zeros(22)).reshape((44, 1))
perceptron = classification.PerceptronClassifier(data, labels)
perceptron.train()
print("Accuracy = {}".format(perceptron.test_set_accuracy()))
# print(perceptron.classify(np.array([3, 3])))
# print(perceptron.classify(np.array([-3, -3])))
# print(perceptron.classify(np.array([0.5, 0.5])))
# print(perceptron.classify(np.array([-0.5, 0])))
t = np.linspace(-20, 20, 100)
plt.plot(
t, -(perceptron.weights[0] + perceptron.weights[1] * t +
perceptron.weights[2] * t**2) / perceptron.weights[3])
plt.scatter(x, x**2 + 1, c="b")
plt.scatter(x, x**2 - 1, c="r")
plt.show()
def generate_error_descriptions(self):
# TODO: Fix the error description method in all the classifiers. Problem with sample size and shape.
feature_matrix = self.data_set.raw_feature_matrix()
labels = self.data_set.feature_matrix_labels()
# Logistic Regression
cls1 = cls.LogisticRegressionClassifier(feature_matrix, labels, shuffle=False)
cls1.apply_feature_scaling(self.selected_feature_scaling_type)
cls1.train(accuracy_threshold=self.get_accuracy_threshold())
# KNN
k_value = self.get_k_value()
print("Using K value of {}".format(k_value))
cls2 = cls.KNearestNeighborsClassifier(feature_matrix, labels, k_value, shuffle=False)
cls2.apply_feature_scaling(self.selected_feature_scaling_type)
# Perceptron
cls3 = cls.PerceptronClassifier(feature_matrix, labels, shuffle=False)
cls3.apply_feature_scaling(self.selected_feature_scaling_type)
cls3.train(accuracy_threshold=self.get_accuracy_threshold())
# SVM
cls4 = cls.SvmClassifier(feature_matrix, labels, self.get_regularization_param(), shuffle=False)
cls4.apply_feature_scaling(self.selected_feature_scaling_type)
cls4.train()
# LDA
cls5 = cls.LdaClassifier(feature_matrix, labels, shuffle=False)
cls5.apply_feature_scaling(self.selected_feature_scaling_type)
cls5.train()
# MLP
cls6 = cls.ANNClassifier(feature_matrix, labels, shuffle=False)
cls6.apply_feature_scaling(self.selected_feature_scaling_type)
cls6.train()
errd1 = cls1.error_description()
errd2 = cls2.error_description()
errd3 = cls3.error_description()
errd4 = cls4.error_description()
errd5 = cls5.error_description()
errd6 = cls6.error_description()
unique_labels = self.data_set.unique_labels().flatten()
text_labels = []
for label in unique_labels:
for trial_class in self.trial_classes:
if trial_class.label == label:
text_labels.append(trial_class.name)
label_count = unique_labels.size
plot_data = np.vstack((
errd1.as_row_array(),
errd2.as_row_array(),
errd3.as_row_array(),
errd4.as_row_array(),
errd5.as_row_array(),
errd6.as_row_array()
))
plot_data = plot_data.transpose()
x = np.arange(6)
plt.title("Error Description")
for i in range(label_count):
plt.bar(x + 0.25 * i, plot_data[i], width=0.25, label=text_labels[i])
plt.xticks(x + 0.125, ("Logistic Regression", "kNN", "Perceptron", "SVM", "LDA", "MLP"))
plt.ylabel("Error Percent")
plt.legend(loc="best")
plt.show()
def generate_performance_report(self):
feature_matrix = self.data_set.raw_feature_matrix()
labels = self.data_set.feature_matrix_labels()
# Logistic Regression
cls1 = cls.LogisticRegressionClassifier(feature_matrix, labels, shuffle=False)
cls1.apply_feature_scaling(self.selected_feature_scaling_type)
cls1.train(accuracy_threshold=self.get_accuracy_threshold())
# KNN
k_value = self.get_k_value()
print("Using K value of {}".format(k_value))
cls2 = cls.KNearestNeighborsClassifier(feature_matrix, labels, k_value, shuffle=False)
cls2.apply_feature_scaling(self.selected_feature_scaling_type)
# Perceptron
cls3 = cls.PerceptronClassifier(feature_matrix, labels, shuffle=False)
cls3.apply_feature_scaling(self.selected_feature_scaling_type)
cls3.train(accuracy_threshold=self.get_accuracy_threshold())
# SVM
cls4 = cls.SvmClassifier(feature_matrix, labels, self.get_regularization_param(), shuffle=False)
cls4.apply_feature_scaling(self.selected_feature_scaling_type)
cls4.train()
# LDA
cls5 = cls.LdaClassifier(feature_matrix, labels, shuffle=False)
cls5.apply_feature_scaling(self.selected_feature_scaling_type)
cls5.train()
# MLP
cls6 = cls.ANNClassifier(feature_matrix, labels, shuffle=False)
cls6.apply_feature_scaling(self.selected_feature_scaling_type)
cls6.train()
# Get performance measure from each
prm1 = cls1.performance_measure()
prm2 = cls2.performance_measure()
prm3 = cls3.performance_measure()
prm4 = cls4.performance_measure()
prm5 = cls5.performance_measure()
prm6 = cls6.performance_measure()
plot_data = np.vstack((
prm1.as_row_array(),
prm2.as_row_array(),
prm3.as_row_array(),
prm4.as_row_array(),
prm5.as_row_array(),
prm6.as_row_array()
))
plot_data = np.transpose(plot_data)
x = np.arange(6)
plt.title("Classifiers' Accuracy")
plt.bar(x + 0.0, plot_data[0], width=0.25, label="Training Accuracy")
plt.bar(x + 0.25, plot_data[1], width=0.25, label="Cross Validation Accuracy")
plt.bar(x + 0.5, plot_data[2], width=0.25, label="Testing Accuracy")
plt.xticks(x + 0.125, ("Logistic Regression", "kNN", "Perceptron", "SVM", "LDA", "MLP"))
plt.ylabel("Accuracy %")
plt.legend(loc="best")
plt.show()
def train_classifier_clicked(self):
print("train classifier clicked")
if self.data_set is None:
self.extract_features_clicked()
else:
print("*"*10 + "Using existing feature matrix, re-extract if changes were made" + "*"*10)
accuracy_threshold = self.get_accuracy_threshold()
regularization_param = self.get_regularization_param()
selected_classifier = self.classifier_type_combo.currentText()
feature_matrix = self.data_set.raw_feature_matrix()
labels = self.data_set.feature_matrix_labels()
# Train Classifier
if selected_classifier == cls.LogisticRegressionClassifier.NAME:
classifier = cls.LogisticRegressionClassifier(feature_matrix, labels, shuffle=False)
classifier.apply_feature_scaling(self.selected_feature_scaling_type)
self.classifier = classifier
cost = classifier.train(accuracy_threshold=accuracy_threshold)
plt.plot(cost)
plt.xlabel("Iteration Number")
plt.ylabel("Training Set Cost")
plt.title("Gradient Descent Cost Curve")
plt.show()
print("Training set accuracy = {}".format(classifier.training_set_accuracy()))
print("Logistic Regression trained successfully, test set accuracy = {}".format(classifier.test_set_accuracy()))
print("Cross validation accuracy = {}".format(classifier.test_set_accuracy()))
elif selected_classifier == cls.KNearestNeighborsClassifier.NAME:
k_value = self.get_k_value()
print("Using K value of {}".format(k_value))
classifier = cls.KNearestNeighborsClassifier(feature_matrix, labels, k_value, shuffle=False)
classifier.apply_feature_scaling(self.selected_feature_scaling_type)
self.classifier = classifier
print("KNN training set accuracy = {}".format(classifier.training_set_accuracy()))
print("KNN test set accuracy = {}".format(classifier.test_set_accuracy()))
print("KNN cross validation accuracy = {}".format(classifier.cross_validation_accuracy()))
k_values, accuracy = classifier.cross_validation_learning_curve()
plt.plot(k_values, accuracy)
plt.xlabel("K Neighbors")
plt.ylabel("Accuracy")
plt.title("Accuracy graph for K values")
plt.show()
elif selected_classifier == cls.PerceptronClassifier.NAME:
classifier = cls.PerceptronClassifier(feature_matrix, labels, shuffle=False)
classifier.apply_feature_scaling(self.selected_feature_scaling_type)
self.classifier = classifier
classifier.train(accuracy_threshold=accuracy_threshold)
print("Perceptron training set accuracy = {}".format(classifier.training_set_accuracy()))
print("Perceptron test set accuracy = {}".format(classifier.test_set_accuracy()))
print("Perceptron Cross validation accuracy = {}".format(classifier.cross_validation_accuracy()))
elif selected_classifier == cls.SvmClassifier.NAME:
classifier = cls.SvmClassifier(feature_matrix, labels, regularization_param, shuffle=False)
classifier.apply_feature_scaling(self.selected_feature_scaling_type)
self.classifier = classifier
classifier.train()
print("SVM training set accuracy = {}".format(classifier.training_set_accuracy()))
print("SVM test set accuracy = {}".format(classifier.test_set_accuracy()))
print("SVM cross validation accuracy = {}".format(classifier.cross_validation_accuracy()))
elif selected_classifier == cls.LdaClassifier.NAME:
classifier = cls.LdaClassifier(feature_matrix, labels, shuffle=False)
classifier.apply_feature_scaling(self.selected_feature_scaling_type)
self.classifier = classifier
classifier.train()
print("LDA training set accuracy = {}".format(classifier.training_set_accuracy()))
print("LDA test set accuracy = {}".format(classifier.test_set_accuracy()))
print("LDA cross validation accuracy = {}".format(classifier.cross_validation_accuracy()))
# TODO: Learning curves
elif selected_classifier == cls.ANNClassifier.NAME:
classifier = cls.ANNClassifier(feature_matrix, labels, shuffle=False)
classifier.apply_feature_scaling(self.selected_feature_scaling_type)
self.classifier = classifier
classifier.train()
print("MLP training set accuracy = {}".format(classifier.training_set_accuracy()))
print("MLP test set accuracy = {}".format(classifier.test_set_accuracy()))
print("MLP cross validation accuracy = {}".format(classifier.cross_validation_accuracy()))
elif selected_classifier == cls.VotingClassifier.NAME:
classifier = cls.VotingClassifier(feature_matrix, labels, DEFAULT_VOTING_CLASSIFIERS, shuffle=False)
classifier.apply_feature_scaling(self.selected_feature_scaling_type)
self.classifier = classifier
self.classifier.train()
print("VOTING training set accuracy = {}".format(classifier.training_set_accuracy()))
print("VOTING test set accuracy = {}".format(classifier.test_set_accuracy()))
print("VOTING cross validation accuracy = {}".format(classifier.cross_validation_accuracy()))
self.root_directory_changed = False
# print(classifier.classify(np.array([-2, -2])))
# print(classifier.classify(np.array([-2, 2])))
# print(classifier.classify(np.array([2, -2])))
#
# knn = classification.KNearestNeighborsClassifier(data, labels)
# print(f"KNN Accuracy = {knn.test_set_accuracy(2)}")
# print(f"Logistic Regression Accuracy = {classifier.test_set_accuracy()}")
#
# print(knn.classify(np.array([[2], [2]])))
# print(knn.classify(np.array([[-2], [-2]])))
# print(knn.classify(np.array([[-2], [2]])))
# print(knn.classify(np.array([[2], [-2]])))
#
# # print("Accuracy = {}".format(classifier.test_set_accuracy())
# plt.plot(cost[0])
# plt.plot(cost[1])
# plt.plot(cost[2])
# plt.plot(cost[3])
perceptron = classification.PerceptronClassifier(data, labels)
perceptron.train()
print(perceptron.test_set_accuracy())
print(perceptron.classify(np.array([[2, 2], [-2, -2], [-2, 2], [2, -2]])))
print()
plt.show()