print("Train/Test split: {:d}/{:d}".format(len(y_train), len(y_test)))
print("Codebook Size: {:d}".format(VOC_SIZE))
print("Pyramid level: {:d}".format(PYRAMID_LEVEL))
print("Building the codebook, it will take some time")
codebook = build_codebook(x_train_des, VOC_SIZE)
import cPickle
with open('./spm_lv1_codebook.pkl', 'w') as f:
cPickle.dump(codebook, f)
print("Spatial Pyramid Matching encoding")
x_train = [
spatial_pyramid_matching(x_train[i],
x_train_des[i],
codebook,
level=PYRAMID_LEVEL)
for i in xrange(len(x_train))
]
x_test = [
spatial_pyramid_matching(x_test[i],
x_test_des[i],
codebook,
level=PYRAMID_LEVEL)
for i in xrange(len(x_test))
]
x_train = np.asarray(x_train)
x_test = np.asarray(x_test)
svm_classifier(x_train, y_train, x_test, y_test)
X, y = load_my_data(args.train)
# to save time...
X = X[:200]
y = y[:200]
print("Codebook Size: {:d}".format(spm.VOC_SIZE))
print("Pyramid level: {:d}".format(spm.PYRAMID_LEVEL))
print("Dense SIFT feature extraction")
x_feature = [extract_DenseSift_descriptors(img) for img in X]
x_kp, x_des = zip(*x_feature)
print("Building the codebook, it will take some time")
codebook = build_codebook(x_des, spm.VOC_SIZE)
#import cPickle
#with open('./data/codebook_spm.pkl','w') as f:
# cPickle.dump(codebook, f)
print("Spatial Pyramid Matching encoding")
X = [
spm.spatial_pyramid_matching(X[i],
x_des[i],
codebook,
level=spm.PYRAMID_LEVEL)
for i in xrange(len(x_des))
]
X = np.asarray(X)
svm_classifier(X, y)
print "Training data load from {}".format(args.train)
print "Test data load from {}".format(args.test)
X, y = load_my_data(args.train)
# to save time...
X = X[:200]
y = y[:200]
print "Codebook Size: {:d}".format(spm.VOC_SIZE)
print "Pyramid level: {:d}".format(spm.PYRAMID_LEVEL)
print "Dense SIFT feature extraction"
x_feature = [extract_DenseSift_descriptors(img) for img in X]
x_kp, x_des = zip(*x_feature)
print "Building the codebook, it will take some time"
codebook = build_codebook(x_des, spm.VOC_SIZE)
#import cPickle
#with open('./data/codebook_spm.pkl','w') as f:
# cPickle.dump(codebook, f)
print "Spatial Pyramid Matching encoding"
X = [spm.spatial_pyramid_matching(X[i],
x_des[i],
codebook,
level=spm.PYRAMID_LEVEL)
for i in xrange(len(x_des))]
X = np.asarray(X)
svm_classifier(X, y)
x_train, y_train = load_cifar10_data(dataset='train')
x_test, y_test = load_cifar10_data(dataset='test')
print "SIFT feature extraction"
x_train = [extract_sift_descriptors(img) for img in x_train]
x_test = [extract_sift_descriptors(img) for img in x_test]
# Remove None in SIFT extraction
x_train = [each for each in zip(x_train, y_train) if each[0] != None]
x_train, y_train = zip(*x_train)
x_test = [each for each in zip(x_test, y_test) if each[0] != None]
x_test, y_test = zip(*x_test)
print "Train/Test split: {:d}/{:d}".format(len(y_train), len(y_test))
print "Codebook Size: {:d}".format(VOC_SIZE)
print "Building the codebook, it will take some time"
codebook = build_codebook(x_train, voc_size=VOC_SIZE)
import cPickle
with open('./bow_codebook.pkl','w') as f:
cPickle.dump(codebook, f)
print "Bag of words encoding"
x_train = [input_vector_encoder(x, codebook) for x in x_train]
x_train = np.asarray(x_train)
x_test = [input_vector_encoder(each, codebook) for each in x_test]
x_test = np.asarray(x_test)
svm_classifier(x_train, y_train, x_test, y_test)
def main():
######
# mat = get_data.read_data("C:/Users/Furkan/Desktop/Bitirme/dataset/video4.mp4")
######
print("Dataset has been reading...")
data = read_data()
labels = read_labels()
print("Dataset has been read.")
print('Applying contrast streching manipulation...')
contrasted_data, contrasted_labels = data_manipulation.apply_contrast(
data, labels)
print('Size of contrasted data: %d' % len(contrasted_data))
print('Applying rotation manipulation...')
rotated_data, rotated_labels = data_manipulation.apply_rotation(
contrasted_data, labels)
print('Size of rotated data: %d' % len(rotated_data))
print('Applying shifting manipulation...')
shifted_data, shifted_labels = data_manipulation.apply_shifting(
contrasted_data, labels)
print('Size of shifted data: %d' % len(shifted_data))
print('Applying flipping manipulation...')
flipped_data, flipped_labels = data_manipulation.apply_horizontal_flip(
contrasted_data, labels)
print('Size of shifted data: %d' % len(flipped_data))
print('Concatenating manipulated data')
concat_data = rotated_data + shifted_data + contrasted_data + flipped_data
# concat_data = data data For 2.5k sized Original data.
print("Reshaping images...")
reshaped_concat_data = reshape_list(concat_data)
print('Shape of data: %s' % str(reshaped_concat_data[0].shape))
print("PCA has been applying...")
data_pca = data_manipulation.pca(reshaped_concat_data)
print("PCA has been applied.")
data = data_pca
concat_labels = labels
print("Spliting dataset into training and test set...")
X_train, X_test, y_train, y_test = split_dataset(data,
concat_labels[:len(data)])
start = datetime.now()
print("Appyling K-Nearest Neighbours Classifier...")
knn_labels = classifier.knn_classifier(X_train, y_train, X_test)
print("Evaluating accuracy...")
classifier.evaluate(y_test, knn_labels)
cm_knn = confusion_matrix(y_test, knn_labels)
print("Confusion matrix: %s \n\t" % str(cm_knn))
print("Running time: %s" % str(datetime.now() - start))
start = datetime.now()
print("Appyling Support Vector Machines Classifier...")
svm_labels = classifier.svm_classifier(X_train, y_train, X_test)
print("Evaluating accuracy...")
classifier.evaluate(y_test, svm_labels)
cm_svm = confusion_matrix(y_test, svm_labels)
print("Confusion matrix: %s \n\t" % str(cm_svm))
print("Running time: %s" % str(datetime.now() - start))
start = datetime.now()
print("Appyling Naive Bayes Classifier...")
nbc_labels = classifier.naive_bayes_classifier(X_train, y_train, X_test)
print("Evaluating accuracy...")
classifier.evaluate(y_test, nbc_labels)
cm_nbc = confusion_matrix(y_test, nbc_labels)
print("Confusion matrix: %s \n\t" % str(cm_nbc))
print("Running time: %s" % str(datetime.now() - start))
start = datetime.now()
print("Appyling Decision Tree Classifier...")
dtc_labels = classifier.decision_tree_classifier(X_train, y_train, X_test)
print("Evaluating accuracy...")
classifier.evaluate(y_test, dtc_labels)
cm_dtc = confusion_matrix(y_test, dtc_labels)
print("Confusion matrix: %s \n\t" % str(cm_dtc))
print("Running time: %s" % str(datetime.now() - start))
start = datetime.now()
print("Appyling Random Forest Classifier...")
rfc_labels = classifier.random_forest_classifier(X_train, y_train, X_test)
print("Evaluating accuracy...")
classifier.evaluate(y_test, rfc_labels)
cm_rfc = confusion_matrix(y_test, rfc_labels)
print("Confusion matrix: %s \n\t" % str(cm_rfc))
print("Running time: %s" % str(datetime.now() - start))
"""print("Applying K-Means Clustering...")
results_dict = {}
recall = recall_score(true_Y, predictions, average=None)
precision = precision_score(true_Y, predictions, average=None)
f1 = f1_score(true_Y, predictions, average=None)
#auc = roc_auc_score(true_Y, predictions, average = 'micro')
print('recall:', str(recall))
print('precision', str(precision))
print('f1:', str(f1))
#print('auc:', str(auc)) a
return [recall, precision, f1]
###############################
####Support Vector Machine#####
###############################
support_vector_machine = classifier.svm_classifier(train_X_uncombined,
train_Y_uncombined)
svm_predictions = classifier.run_predictions(support_vector_machine,
test_X_uncombined,
test_Y_uncombined)
get_statistics(test_Y_uncombined, svm_predictions)
validate(support_vector_machine, test_X_uncombined, test_Y_uncombined)
# support_vector_machine_uncombined = classifier.svm_classifier(train_X_uncombined, train_Y_uncombined)
# svm_predictions_uncombined = classifier.run_predictions(support_vector_machine, test_X_uncombined, test_Y_uncombined)
# get_statistics(test_Y_uncombined, svm_predictions)
# validate(support_vector_machine, test_X_uncombined, test_Y_uncombined)
def find_errors(model, vector_data_file, label):
'''
returns a dictionary that tells you how many of each category the model incorrectly predicted.
