def classifyImage(self):
size = 25, 25
im = Image.open('input')
im.thumbnail(size, Image.ANTIALIAS)
im = im.convert('L')
width, height = im.size
pixels = im.load()
#Peter Code Begin
#invert, so that white is 0
for y in range(width):
for x in range(height):
pixels[x, y] = 255 - im.getpixel((x,y))
#Executing the nearest neighbor classifier
input_data = {"label" : "", "image": im}
NearestNeighbor.to_numpy([input_data])
NearestNeighbor.scale_down([input_data], 12, "average")
n = NearestNeighbor.NearestNeighbor()
result = n.classify_one(training_data, input_data)
#Peter Code End
#Added pop up window that displays result and is destroyed when the user clicks 'clear' (daniel)
#print(result)
message = Message(self.top, text = result)
message.config(bg = 'white', font = ('arial', 60, 'bold'))
message.pack()
def main():
global training_data
training_data = ImageDataSearch.get_data("emnist-letters-train.csv", range(1000, num_training_data+1000), "emnist-letters-mapping.txt")
NearestNeighbor.to_numpy(training_data)
NearestNeighbor.scale_down(training_data, 12, "average")
p = Draw()
def get_results(instance_filename):
coordinates_a = cdm.load_data_from_file(instance_filename)
distance_matrix = cdm.create_distance_matrix(instance_filename)
#method_dict [best_distance,worst_distance,avg_distamce,best_cycles]
method_dict = {i: [np.inf, -np.inf, 0, []] for i in [GC, RC, NN]}
for start_vertex in range(len(distance_matrix[0])):
#run every method with start_vertex
method_dict.get(GC).append(
gc.greedy_cycle(distance_matrix, start_vertex))
method_dict.get(RC).append(
rc.greedy_cycle(distance_matrix, start_vertex))
distance_matrix_cp = copy.deepcopy(distance_matrix)
method_dict.get(NN).append(
nn.nearest_neighbor_method(distance_matrix_cp, start_vertex))
#save results
for key, method in method_dict.items():
total_distance = 0
#calculate total distance for given method and start_vertex
for cycle in method[-1]:
cycle_distance = get_total_distance(cycle, distance_matrix)
total_distance = total_distance + cycle_distance
method[AVG] += total_distance
if total_distance > method[WORST]:
method[WORST] = total_distance
if total_distance < method[BEST]:
method.pop(CYCLES)
method[BEST] = total_distance
continue
#remove iteration cycle
method.pop()
for key, method in method_dict.items():
method[AVG] = method[AVG] / len(distance_matrix[0])
return method_dict
def folds(X_train, Y_train, k): #split folds
testScores=[]
newY=np.split(Y_train, K_FOLDS)
newX=np.split(X_train, K_FOLDS)
for i in range(0,5):
classifier = NN.NearestNeighbor()
classifier.train(conc(newX,i), conc(newY,i))
Yval_predict = classifier.predict(newX[i], k, 'L2')
num_correct = np.sum(Yval_predict == newY[i])
num_test=len(Y_train)
accuracy = float(num_correct) / len(newX[i])
print 'Got %d / %d correct => accuracy: %f' % (num_correct, len(newX[i]), accuracy)
testScores.append(accuracy)
mean=np.mean(np.asarray(testScores))
return mean
import load_full_CIFAR10 as load
import NearestNeighbor as NN
import numpy as np
#Xtr: training data
#Ytr: training labels
#Xte: test data
#Yte: test label
Xtr, Ytr, Xte, Yte = load.load_CIFAR10('cifar-10-batches-py/')
#flatten out all images to be one-dimensional
#training data
Xtr_rows = Xtr.reshape(Xtr.shape[0], 32 * 32 * 3)
#test data
Xte_rows = Xte.reshape(Xte.shape[0], 32 * 32 * 3)
#create a Nearest Neighbor classifier class
nn = NN.NearestNeighbor()
#train the classifier on the training images
nn.train(Xtr_rows, Ytr)
#predict labels on the test images
Yte_predict = nn.predict(Xte_rows)
#print the result
print 'accuracy: %f' % (np.mean(Yte_predict == Yte))
Xte = Xte[mask]
Yte = Yte[mask]
Xtr_rows = Xtr.reshape(Xtr.shape[0],
32 * 32 * 3) # Xtr_rows becomes 50000 x 3072
Xte_rows = Xte.reshape(Xte.shape[0],
32 * 32 * 3) # Xte_rows becomes 10000 x 3072
Xtr_rows = np.reshape(Xtr, (Xtr.shape[0], -1))
Xte_rows = np.reshape(Xte, (Xte.shape[0], -1))
Xtr_rows = Xtr_rows.astype(np.float32)
Xte_rows = Xte_rows.astype(np.float32)
Ytr = Ytr.astype(np.float32)
Yte = Yte.astype(np.float32)
if 1:
import NearestNeighbor
nn = NearestNeighbor.NearestNeighbor(
) # create a Nearest Neighbor classifier class
nn.train(Xtr_rows,
Ytr) # train the classifier on the training images and labels
Yte_predict = nn.predict(Xte_rows) # predict labels on the test images
# and now print the classification accuracy, which is the average number
# of examples that are correctly predicted (i.e. label matches)
print 'accuracy: %f' % (np.mean(Yte_predict == Yte))
if 0:
import KNearestNeighbor
knn = KNearestNeighbor.KNearestNeighbor()
# assume we have Xtr_rows, Ytr, Xte_rows, Yte as before
# recall Xtr_rows is 50,000 x 3072 matrix
num_val = num_training / 5
Xval_rows = Xtr_rows[:num_val, :] # take first 1000 for validation
from cs231n.data_utils import load_CIFAR10
from NearestNeighbor import *
# Load CIFAR10 dataset
Xtr, Ytr, Xte, Yte = load_CIFAR10('cs231n/data/cifar10')
# Take only first 10 images to train the model
Xtr = Xtr[0:10]
Ytr = Ytr[0:10]
# Flatten out all images to be one-dimensional array of 32 * 32 * 3 = 3072
Xtr_rows = Xtr.reshape(Xtr.shape[0], 32 * 32 * 3) # Xtr_rows becomes 10 x 3072
Xte_rows = Xte.reshape(Xte.shape[0],
32 * 32 * 3) # Xte_rows becomes 10000 x 3072
# Create a Nearest Neighbor classifier class
nn = NearestNeighbor()
# Train the classifier on the training images and labels
nn.train(Xtr_rows, Ytr)
# Predict labels on the test images
Yte_predict = nn.predict(Xte_rows, 2)
# Print the classification accuracy, which is the average number
# of examples that are correctly predicted (i.e. label matches)
print('accuracy: %f' % (np.mean(Yte_predict == Yte)))
if args.exhaustive:
exhaustiveStartTime = time.time()
best_path = ExhaustiveSearch.exhaustive_search(point_network)
exhaustiveTime = round(time.time() - exhaustiveStartTime, TIMING_PRECISION)
if best_path is None:
# abort program if user decides number of nodes is too long
print("Aborting...")
exit()
print_path(best_path)
if args.timing:
print("Exhaustive search execution time: {0}s".format(exhaustiveTime))
if args.nearest:
print("\n") # If nearest neighbors is also enabled print 2 newlines to separate
if args.nearest:
nearestStartTime = time.time()
print_path(NearestNeighbor.find_nearest_neighbor_path(point_network))
nearestTime = round(time.time() - nearestStartTime, TIMING_PRECISION)
if args.timing:
print("Nearest Neighbor execution time: {0}s".format(nearestTime))
labels_p2 = p2[0] data_p2 = p2[1] # Training data labels = np.concatenate((labels_p1[:300], labels_p2[:300]), axis=0) data = np.concatenate((data_p1[:300], data_p2[:300]), axis=0) # Test data test_labels = np.concatenate((labels_p1[300:400], labels_p2[300:400]), axis=0) test_data = np.concatenate((data_p1[300:400], data_p2[300:400]), axis=0) # Shuffle the data rng_state = np.random.get_state() np.random.shuffle(labels) np.random.set_state(rng_state) np.random.shuffle(data) # Train NN nn = NearestNeighbor() #print "data length:", len(data),"\nlabel length:", len(labels) #print type(data)," ", type(labels) k = nn.cross_validation(data, labels, 4) print "the highest value k is equal to :", k, "for testing." # Time to test out test_data/labels nn.train(data, labels, k) prediction = nn.predict(test_data) predictionAccuracy = '%f' % (np.mean(prediction == test_labels)) print "Test complete!\nThe accurracy is : ", predictionAccuracy
def runNN():
time.sleep(1)
NearestNeighbor.main()
time.sleep(1)
def tenFoldCV(chunked_data, clss_list, use_regression, k, k2, t, phi, kc, kc2,
ct, cphi, ke, ke2, et, ephi):
knn_missed = []
knn2_missed = []
cnn_missed = []
cnn2_missed = []
enn_missed = []
enn2_missed = []
for test_num in range(10):
print("\n\n\nFold: ", test_num + 1, "of 10 fold cross validation")
training_set = []
testing_set = chunked_data[test_num]
# make example set
for train in range(10):
if train != test_num:
for x in range(len(chunked_data[train])):
training_set.append(chunked_data[train][x])
validation_index = int((float(len(training_set)) * 8 / 10)) - 1
knn = nn.NearestNeighbor(training_set, k)
#knn.massSimilarity(int(sys.argv[16]),int(sys.argv[17]))
knn2 = nn.NearestNeighbor(training_set, k2)
knn2.massSimilarity(t, phi)
knn_missed.append(ms.testClassifier(knn, testing_set))
knn2_missed.append(ms.testClassifier(knn2, testing_set))
cnn = nn.NearestNeighbor(training_set, kc)
cnn.convertToCondensed()
#cnn.massSimilarity(int(sys.argv[18]),int(sys.argv[19]))
cnn2 = nn.NearestNeighbor(training_set, kc2)
cnn2.convertToCondensed()
cnn2.massSimilarity(ct, cphi)
cnn_missed.append(ms.testClassifier(cnn, testing_set))
cnn2_missed.append(ms.testClassifier(cnn2, testing_set))
enn = nn.NearestNeighbor(training_set[:validation_index], ke)
enn.convertToEdited(training_set[validation_index:])
#enn.massSimilarity(int(sys.argv[20]),int(sys.argv[21]))
enn2 = nn.NearestNeighbor(training_set[:validation_index], ke2)
enn2.convertToEdited(training_set[validation_index:])
enn2.massSimilarity(et, ephi)
enn_missed.append(ms.testClassifier(enn, testing_set))
enn2_missed.append(ms.testClassifier(enn2, testing_set))
ms.compareClassifiers(knn_missed, knn2_missed, 'knn', 'knn2')
ms.compareClassifiers(knn_missed, cnn_missed, 'knn', 'cnn')
ms.compareClassifiers(knn_missed, cnn2_missed, 'knn', 'cnn2')
ms.compareClassifiers(knn_missed, enn_missed, 'knn', 'enn')
ms.compareClassifiers(knn_missed, enn2_missed, 'knn', 'enn2')
ms.compareClassifiers(knn2_missed, cnn_missed, 'knn2', 'cnn')
ms.compareClassifiers(knn2_missed, cnn2_missed, 'knn2', 'cnn2')
ms.compareClassifiers(knn2_missed, enn_missed, 'knn2', 'enn')
ms.compareClassifiers(knn2_missed, enn2_missed, 'knn2', 'enn2')
ms.compareClassifiers(cnn_missed, cnn2_missed, 'cnn', 'cnn2')
ms.compareClassifiers(cnn_missed, enn_missed, 'cnn', 'enn')
ms.compareClassifiers(cnn_missed, enn2_missed, 'cnn', 'enn2')
ms.compareClassifiers(cnn2_missed, enn_missed, 'cnn2', 'enn')
ms.compareClassifiers(cnn2_missed, enn2_missed, 'cnn2', 'enn2')
ms.compareClassifiers(enn_missed, enn2_missed, 'enn', 'enn2')
test_digit_labels_list)
testing_digit_info_list_KN = extract_features_matrix(
test_digit_image_list, test_digit_labels_list)
if sys.argv[2] == "-b":
algo = "bayes"
guess = Bayes.naive_bayes_digit_training(training_digit_info_list,
testing_digit_info_list, 100)
elif sys.argv[2] == "-p":
algo = "perceptron"
guess = Perceptron.perceptron_digit_training(training_digit_info_list,
testing_digit_info_list,
100)
elif sys.argv[2] == "-k":
algo = "k-nearest"
guess = NearestNeighbor.nearest_neighbor(training_digit_info_list_KN,
testing_digit_info_list_KN)
end_time = time.time() - start_time
write_to_file("time-to-train.txt", end_time)
print algo
exit() # to delete - time training
accuracy = get_accuracy(guess, test_digit_labels_list)
print accuracy
write_to_file("results.txt", accuracy)
elif sys.argv[1] == "-f": # faces
print "faces"
train_face_image = "data/facedata/facedatatrain"
train_face_label = "data/facedata/facedatatrainlabels"
train_face_image_list = read_data(train_face_image, "face")
train_face_labels_list = read_labels(train_face_label)
np.random.shuffle(full_Xs)
X_train = X_train[full_Xs, :]
y_train = y_train[full_Xs]
num_test = 10000
mask = range(num_test)
X_test = X_test[mask]
y_test = y_test[mask]
X_test = np.reshape(X_test, (X_test.shape[0], -1))
#####################################################################################
## Predicting Test data set
#####################################################################################
#####################################################################################
classifier = NN.NearestNeighbor()
classifier.train(X_train, y_train)
#(5)KNN Classifier
y_test_predicted_5NN = classifier.predictKnn(X=X_test, l='L1', k=7)
# Compute and print the fraction of correctly predicted examples
num_correct = np.sum(y_test_predicted_5NN == y_test)
accuracy = float(num_correct) / num_test
print('Got %d / %d correct => accuracy: %f' %
(num_correct, num_test, accuracy))
answers_comparison = (y_test_predicted_5NN == y_test)
class_accuracy = []
for i in range(10):
idx = np.flatnonzero(y_test == i)
from NearestNeighbor import *
import numpy as np
data = np.loadtxt('Fitz4DManifold.txt')
data = np.transpose(np.array([data[:-1, 0], data[1:, 0]]))
nb = NearestNeighbor(data, 15)
symbols = nb.SeperateGraphs(colPlot=True)
#print(symbols)
