def main(): """Main function for the Task 8""" k_value = get_input_k() while k_value > 8: print("Please enter a value of k within 8") k_value = get_input_k() folder = get_input_folder() print(global_constants.LINE_SEPARATOR) print("User Inputs summary") print(global_constants.LINE_SEPARATOR) print("k-value: {}\nFolder: {}".format(k_value, folder)) print(global_constants.LINE_SEPARATOR) dim_red = DimensionReduction(None, "NMF", k_value, image_metadata=True, folder_metadata=folder) w, h, model = dim_red.execute() # printing the term weight print_tw(w, h, image_metadata=True) # save to csv filename = "task8" + "_" + str(k_value) CSVReader().save_to_csv(w, h, filename, image_metadata=True) print("Please check the CSV file: output/{}.csv".format(filename))
def main(): """Main function for the task 4""" feature_extraction_model = get_input_feature_extractor_model() dimension_reduction_model = get_input_dimensionality_reduction_model() k_value = get_input_k() label = get_input_image_label() folder = get_input_folder() image_name = get_input_image(folder) m_value = get_input_m() if dimension_reduction_model != "NMF": dist_func = "euclidean" elif feature_extraction_model in ["CM", "LBP"]: dist_func = "nvsc1" else: dist_func = "euclidean" # dist_func = "cosine" # dist_func = "chebyshev" # dist_func = "manhattan" # dist_func = "chi_square" # dist_func = "euclidean" print(global_constants.LINE_SEPARATOR) print("User Inputs summary") print(global_constants.LINE_SEPARATOR) print("Feature Extraction Model: {}\nDimensionality Reduction Model: {}\nk-value: {}\nLabel: {}\nFolder: {}\n" "Image: {}\nm-value: {}".format(feature_extraction_model, dimension_reduction_model, k_value, label, folder, image_name, m_value)) print(global_constants.LINE_SEPARATOR) # Saves the returned model filename = "{0}_{1}_{2}_{3}".format(feature_extraction_model, dimension_reduction_model, label.replace(" ", ''), str(k_value)) model = model_interact.load_model(filename=filename) if not model: print("Please run Task 3 for {}, {}, {} and {}".format(feature_extraction_model, dimension_reduction_model, label, k_value)) sys.exit(1) # Compute the reduced dimensions for the new query image and find m similar images dim_reduction = DimensionReduction(feature_extraction_model, dimension_reduction_model, k_value, label) result = dim_reduction.find_m_similar_images(model, m_value, folder, image_name, dist_func) print(global_constants.LINE_SEPARATOR) print("Similar Images") print(global_constants.LINE_SEPARATOR) for rec in result: print(rec) print(global_constants.LINE_SEPARATOR) title = { "Feature Extraction": feature_extraction_model, "Dimension Reduction": dimension_reduction_model, "k": k_value, "Label": label, "Distance": dist_func } show_images(os.path.abspath(os.path.join(folder, image_name)), result, title)
def dimension_reduction(): # save_model_file() constants = GlobalConstants() model = Model() features = model.load_model('cm_np') redn = DimensionReduction(dimension_reduction_model=constants.PCA, extractor_model=constants.CM, matrix=features, conversion=True, k_value=500) redn.execute() pass
def get_x_train(fea_ext_mod, dim_red_mod, k_value, train_set): model_interact = Model() dim_reduction = DimensionReduction(fea_ext_mod, dim_red_mod, k_value, folder_metadata=train_set, metadata_collection="labelled") obj_lat, feat_lat, model = dim_reduction.execute() filename = "{0}_{1}_{2}_{3}".format(fea_ext_mod, dim_red_mod, str(k_value), os.path.basename(train_set)) model_interact.save_model(model=model, filename=filename) return obj_lat
def get_y(fea_ext_mod, dim_red_mod, k_value, collection_name, red_dim=None, obj_lat=None): dim_red = DimensionReduction(fea_ext_mod, dim_red_mod, k_value) if collection_name == 'unlabelled': aspect = dim_red.get_metadata( "imageName", red_dim['imageId'].tolist())['aspectOfHand'].tolist() else: aspect = dim_red.get_metadata_collection( "imageName", obj_lat['imageId'].tolist(), collection_name)['aspectOfHand'].tolist() return [i.split(' ')[0] for i in aspect]
def run_task3(feature_extraction_model, dimension_reduction_model, label, k_value): """Main function for the Task3""" # Performs the dimensionality reduction dim_reduction = DimensionReduction(feature_extraction_model, dimension_reduction_model, k_value, label) obj_feature = dim_reduction.get_object_feature_matrix() obj_lat, feat_lat, model = dim_reduction.execute() # Saves the returned model filename = "{0}_{1}_{2}_{3}".format(feature_extraction_model, dimension_reduction_model, label.replace(" ", ''), str(k_value)) model_interact.save_model(model=model, filename=filename)
def get_x_test(fea_ext_mod, dim_red_mod, k_value, train_set, test_set): model_interact = Model() dim_reduction = DimensionReduction(fea_ext_mod, dim_red_mod, k_value) filename = "{0}_{1}_{2}_{3}".format(fea_ext_mod, dim_red_mod, str(k_value), os.path.basename(train_set)) model = model_interact.load_model(filename=filename) red_dims = [] unlabelled_image_list = os.listdir(test_set) for image in unlabelled_image_list: red_dim = dim_reduction.compute_query_image(model, test_set, image) red_dims.append(red_dim[0]) df = pd.DataFrame({ "imageId": unlabelled_image_list, "reducedDimensions": red_dims }) return df
def compute_latent_semantic_for_label(fea_ext_mod, dim_red_mod, label, k_value, folder): # p2task5.run_task3(fea_ext_mod, dim_red_mod, label, k_value) dim_reduction = DimensionReduction(fea_ext_mod, dim_red_mod, k_value, label, folder_metadata=folder, metadata_collection="labelled") obj_lat, feat_lat, model = dim_reduction.execute() # Saves the returned model filename = "{0}_{1}_{2}_{3}_{4}".format(fea_ext_mod, dim_red_mod, label, str(k_value), os.path.basename(folder)) model_interact.save_model(model=model, filename=filename) return obj_lat, feat_lat, model
def run_task4(feature_extraction_model, dimension_reduction_model, folder, image_name, dist_func, label, k_value, m_value): """Main function for the Task4""" # Saves the returned model filename = "{0}_{1}_{2}_{3}".format(feature_extraction_model, dimension_reduction_model, label.replace(" ", ''), str(k_value)) model = model_interact.load_model(filename=filename) # Compute the reduced dimensions for the new query image and find m similar images dim_reduction = DimensionReduction(feature_extraction_model, dimension_reduction_model, k_value, label) obj_feature = dim_reduction.get_object_feature_matrix() result = dim_reduction.find_m_similar_images(model, m_value, folder, image_name, dist_func) return result
def main(): """Main function for the Task3""" feature_extraction_model = get_input_feature_extractor_model() dimension_reduction_model = get_input_dimensionality_reduction_model() k_value = get_input_k() label = get_input_image_label() print(global_constants.LINE_SEPARATOR) print("User Inputs summary") print(global_constants.LINE_SEPARATOR) print( "Feature Extraction Model: {}\nDimensionality Reduction Model: {}\nk-value: {}" .format(feature_extraction_model, dimension_reduction_model, k_value)) print(global_constants.LINE_SEPARATOR) print(global_constants.LINE_SEPARATOR) print("Saving the metadata to MongoDB") print(global_constants.LINE_SEPARATOR) csv_reader.save_hand_csv_mongo("HandInfo.csv") print(global_constants.LINE_SEPARATOR) # Performs the dimensionality reduction dim_reduction = DimensionReduction(feature_extraction_model, dimension_reduction_model, k_value, label) obj_lat, feat_lat, model = dim_reduction.execute() # Saves the returned model filename = "{0}_{1}_{2}_{3}".format(feature_extraction_model, dimension_reduction_model, label.replace(" ", ''), str(k_value)) model_interact.save_model(model=model, filename=filename) # Printing the term weight pairs data_tw = print_tw(obj_lat, feat_lat) # save term weight pairs to csv filename = "task3_{}_{}_{}_{}".format(feature_extraction_model, dimension_reduction_model, label, k_value) csv_reader.save_to_csv(obj_lat, feat_lat, filename) print("Please check the CSV file: output/{}.csv".format(filename))
def main(): """Main function for the task 1""" feature_extraction_model = get_input_feature_extractor_model() dimension_reduction_model = get_input_dimensionality_reduction_model() k_value = get_input_k() print(global_constants.LINE_SEPARATOR) print("User Inputs summary") print(global_constants.LINE_SEPARATOR) print( "Feature Extraction Model: {}\nDimensionality Reduction Model: {}\nk-value: {}" .format(feature_extraction_model, dimension_reduction_model, k_value)) print(global_constants.LINE_SEPARATOR) # Performs the dimensionality reduction dim_reduction = DimensionReduction(feature_extraction_model, dimension_reduction_model, k_value) obj_lat, feat_lat = save_model(dim_reduction, feature_extraction_model, dimension_reduction_model, k_value) # Print term weight pairs to terminal data_tw = print_tw(obj_lat, feat_lat) # save term weight pairs to csv filename = "task1" + '_' + feature_extraction_model + '_' + dimension_reduction_model + '_' + str( k_value) CSVReader().save_to_csv(obj_lat, feat_lat, filename) print("Please check the CSV file: output/{}.csv".format(filename)) data = dim_reduction.get_object_feature_matrix() title = { "Feature Extraction": feature_extraction_model, "Dimensionality Reduction": dimension_reduction_model, "k": k_value, } if k_value <= 20: print("Generating Visualization ...") show_data_ls(data, data_tw, title) print("Generating Visualization ...") show_feature_ls(data, feat_lat, title)
def main(): feature_extraction_model = task6.feature_extraction_model dimension_reduction_model = task6.dimension_reduction_model k_value_for_ss_similarity = 10 given_k_value = get_input_k() print(global_constants.LINE_SEPARATOR) print("User Inputs summary") print(global_constants.LINE_SEPARATOR) print("k-value: {}".format(given_k_value)) print(global_constants.LINE_SEPARATOR) dim_reduction = DimensionReduction(feature_extraction_model, dimension_reduction_model, k_value_for_ss_similarity) # original feature vectors obj_feat_matrix = dim_reduction.get_object_feature_matrix() # get the img IDs from the database for images in the fit model img_set = pd.DataFrame({"imageId": obj_feat_matrix['imageId']}) # get the metadata for each image with given subject id subject_data = dim_reduction.get_metadata("imageName", list(set(img_set["imageId"].tolist()))) # unique subject IDs in dataset dataset_subject_ids = set((subject_data)["id"]) subject_subject_matrix = [] m_value = len(img_set) starttime = time.time() model = task6.load_model(dim_reduction, feature_extraction_model, dimension_reduction_model, k_value_for_ss_similarity) folder = path.basename(path.dirname(obj_feat_matrix['path'][0])) for i, subjectid in enumerate(dataset_subject_ids): given_subject_images = dim_reduction.get_metadata("id", list([subjectid]))["imageName"].tolist() image_list_for_subject = list(set(given_subject_images).intersection(set(img_set["imageId"].tolist()))) similar_subjects = task6.find_similar_subjects(subjectid, image_list_for_subject, model, img_set, dim_reduction, m_value, folder) subject_subject_matrix.append(np.asarray(list(similar_subjects.values()))) print("\nTime taken to create subject subject matrix: {}\n".format(time.time() - starttime)) # perform nmf on subject_subject_matrix # given_k_value = 1 matrix = pd.DataFrame(data={'imageId': list(dataset_subject_ids), 'featureVector': subject_subject_matrix}) dim_red = DimensionReduction(None, "NMF", given_k_value, subject_subject=True, matrix=matrix) w, h, model = dim_red.execute() # display latent semantics # printing the term weight print_tw(w, h, subject_subject=True) # save to csv filename = "task7" + '_' + str(given_k_value) CSVReader().save_to_csv(w, None, filename, subject_subject=True) print("Please check the CSV file: output/{}.csv".format(filename))
def main(): """Main function for the script""" feature_extraction_model = "HOG" dimension_reduction_model = "PCA" k_value = get_input_k("k") K_value = get_input_k("K") folder = get_input_folder("Folder") dim_k_value = 40 query_images = get_input_image_list(folder) start = time.time() dim_red = DimensionReduction(feature_extraction_model, dimension_reduction_model, dim_k_value, folder_metadata=folder, metadata_collection="labelled") obj_feat = dim_red.get_object_feature_matrix() features_list = np.array(obj_feat['featureVector'].tolist()) images_list = np.array(obj_feat['imageId']) cos_sim = cosine_similarity(features_list) sim_graph = sim_graph_from_sim_max(cos_sim, images_list, k_value) results = ppr(sim_graph, images_list, query_images) results = results[:K_value] print("Top {} images from Personalized page Rank are:".format(K_value)) for r in results: r["path"] = os.path.abspath(os.path.join(folder, r['imageId'])) print(r) query_images_list = [ os.path.abspath(os.path.join(folder, img)) for img in query_images ] title = {"Model": "Personalized Page Rank", "k": k_value, "K": K_value} show_images_ppr(query_images_list, title, results) print("Execution time: {} seconds".format(time.time() - start))
def main(): fea_ext_mod = "HOG" dim_red_mod = "PCA" dist_func = "euclidean" k_value = 30 training_set = os.path.abspath(get_input_folder("Labelled")) test_set = os.path.abspath(get_input_folder("Classify")) # training_set = os.path.abspath('Dataset3\Labelled\Set1') # test_set = os.path.abspath('Dataset3\\Unlabelled\Set 1') label = "dorsal" obj_lat, feat_lat, model = compute_latent_semantic_for_label( fea_ext_mod, dim_red_mod, label, k_value, training_set) filename = "p3task1_{0}_{1}_{2}_{3}".format(fea_ext_mod, dim_red_mod, label, str(k_value)) csv_reader.save_to_csv(obj_lat, feat_lat, filename) label_p = 'palmar' obj_lat_p, feat_lat_p, model_p = compute_latent_semantic_for_label( fea_ext_mod, dim_red_mod, label_p, k_value, training_set) filename = "p3task1_{0}_{1}_{2}_{3}".format(fea_ext_mod, dim_red_mod, label_p, str(k_value)) csv_reader.save_to_csv(obj_lat_p, feat_lat_p, filename) x_train = obj_lat['reducedDimensions'].tolist() x_train += (obj_lat_p['reducedDimensions'].tolist()) red_dim_unlabelled_images = reduced_dimensions_for_unlabelled_folder( fea_ext_mod, dim_red_mod, k_value, label, training_set, test_set) x_test = red_dim_unlabelled_images['reducedDimensions'].tolist() dim_red = DimensionReduction(fea_ext_mod, dim_red_mod, k_value) labelled_aspect = dim_red.get_metadata_collection( "imageName", obj_lat['imageId'].tolist(), "labelled")['aspectOfHand'].tolist() y_train = [i.split(' ')[0] for i in labelled_aspect] labelled_aspect = dim_red.get_metadata_collection( "imageName", obj_lat_p['imageId'].tolist(), "labelled")['aspectOfHand'].tolist() y_train += ([i.split(' ')[0] for i in labelled_aspect]) unlabelled_aspect = dim_red.get_metadata_collection( "imageName", red_dim_unlabelled_images['imageId'].tolist(), "unlabelled")['aspectOfHand'].tolist() y_test = [i.split(' ')[0] for i in unlabelled_aspect] # makes into arrays and transforms the training labels into 1 for "dorsal", -1 for "palmar" data points x_train = np.array(x_train) y_train = list(map(lambda x: 1 if x == "dorsal" else -1, y_train)) y_train = np.array(y_train) # shuffling the training data indices = np.arange(x_train.shape[0]) np.random.shuffle(indices) x_train = x_train[indices] y_train = y_train[indices] x_test = np.array(x_test) # creates the SVM classifier clf = SupportVectorMachine(gaussian_kernel, C=500) clf.fit(x_train, y_train) predictions = clf.predict(x_test) # transforms the testing labels into 1 for "dorsal", -1 for "palmar" data points y_test = list(map(lambda x: 1 if x == "dorsal" else -1, y_test)) # calculates and prints the results onto the console correct = np.sum(predictions == y_test) print("---------------------------") accuracy = (correct / len(predictions)) * 100 print("Accuracy: " + str(accuracy) + "%") unlabelled_images = red_dim_unlabelled_images['imageId'] predicted_labels = list( map(lambda x: "dorsal" if x == 1 else "palmar", predictions)) actual_labels = list( map(lambda x: "dorsal" if x == 1 else "palmar", y_test)) print("---------------------------") print("Results:") print("Image ID, Prediction, Actual") for image_id, p, a in zip(unlabelled_images, predicted_labels, actual_labels): print("(" + image_id + ", " + p + ", " + a + ")")
def main(): fea_ext_mod = "HOG" dim_red_mod = "SVD" dist_func = "euclidean" k_value = get_input_k("k-value") training_set = os.path.abspath(get_input_folder("Labelled")) test_set = os.path.abspath(get_input_folder("Classify")) label = "dorsal" obj_lat, feat_lat, model = compute_latent_semantic_for_label( fea_ext_mod, dim_red_mod, label, k_value, training_set) filename = "p3task1_{0}_{1}_{2}_{3}".format(fea_ext_mod, dim_red_mod, label, str(k_value)) csv_reader.save_to_csv(obj_lat, feat_lat, filename) x_train = obj_lat['reducedDimensions'].tolist() red_dim_unlabelled_images = reduced_dimensions_for_unlabelled_folder( fea_ext_mod, dim_red_mod, k_value, label, training_set, test_set) x_test = red_dim_unlabelled_images['reducedDimensions'].tolist() dim_red = DimensionReduction(fea_ext_mod, dim_red_mod, k_value) labelled_aspect = dim_red.get_metadata_collection( "imageName", obj_lat['imageId'].tolist(), "labelled")['aspectOfHand'].tolist() y_train = [i.split(' ')[0] for i in labelled_aspect] label_p = 'palmar' obj_lat_p, feat_lat_p, model_p = compute_latent_semantic_for_label( fea_ext_mod, dim_red_mod, label_p, k_value, training_set) filename = "p3task1_{0}_{1}_{2}_{3}".format(fea_ext_mod, dim_red_mod, label_p, str(k_value)) csv_reader.save_to_csv(obj_lat_p, feat_lat_p, filename) x_train += (obj_lat_p['reducedDimensions'].tolist()) labelled_aspect = dim_red.get_metadata_collection( "imageName", obj_lat_p['imageId'].tolist(), "labelled")['aspectOfHand'].tolist() y_train += ([i.split(' ')[0] for i in labelled_aspect]) zip_train = list(zip(x_train, y_train)) random.shuffle(zip_train) x_train, y_train = zip(*zip_train) unlabelled_aspect = dim_red.get_metadata_collection( "imageName", red_dim_unlabelled_images['imageId'].tolist(), "unlabelled")['aspectOfHand'].tolist() y_test = [i.split(' ')[0] for i in unlabelled_aspect] lr = LogisticRegression(penalty='l2', random_state=np.random.RandomState(42), solver='lbfgs', max_iter=300, multi_class='ovr', class_weight='balanced', n_jobs=-1, l1_ratio=0) lr.fit(x_train, y_train) # y_pred = lr.predict(x_test) predictions = lr.predict(x_test) unlabelled_images = red_dim_unlabelled_images['imageId'].tolist() predicted_labels = list(predictions) actual_labels = list(y_test) print("---------------------------") print(" Results:") print("---------------------------") print(" Accuracy:", lr.score(x_test, y_test)) print("---------------------------") print(" Image ID | Prediction | Actual") for image_id, p, a in zip(unlabelled_images, predicted_labels, actual_labels): print(" " + image_id + " | " + p + " | " + a)
def main(): # given subject id given_subject_id = get_input_subject_id() k_value = 40 master_folder = "Hands" dim_reduction = DimensionReduction(feature_extraction_model, dimension_reduction_model, k_value) # original feature vectors obj_feat_matrix = dim_reduction.get_object_feature_matrix() # extract model saved from task 1 model = load_model(dim_reduction, feature_extraction_model, dimension_reduction_model, k_value) # get the img IDs from the database for images in the fit model img_set = pd.DataFrame({"imageId": obj_feat_matrix['imageId']}) # image count to rank against current image m_value = len(img_set) print(global_constants.LINE_SEPARATOR) print("User Inputs summary") print(global_constants.LINE_SEPARATOR) print("Query Subject Id: {}".format(given_subject_id)) print(global_constants.LINE_SEPARATOR) # given_subject_id = 55 # similar subjects to find similar_subject_count = 3 # get metadata for given subject's images metadata = dim_reduction.get_metadata("id", list([given_subject_id])) # get a list of img IDs for the particular subject in the dataset image_list_for_given_subject = random.sample( list(set(metadata["imageName"].tolist())), 5) image_list = list(set(img_set["imageId"].tolist())) starttime = time.time() # method call to find similar subjects subject_similarity = find_similar_subjects(given_subject_id, image_list_for_given_subject, model, img_set, dim_reduction, m_value, master_folder) # sort the similarity scores in descending order sorted_subject_similarity = sorted(subject_similarity.items(), key=operator.itemgetter(1), reverse=True) print() print("Subject : Score") list_subjects = [] max = similar_subject_count counter = 0 while counter < max: subject = sorted_subject_similarity[counter] if subject[0] != given_subject_id: print(subject[0], " : ", subject[1]) list_subjects.append([subject[0], subject[1]]) else: max += 1 counter += 1 print() # print(sorted_subject_similarity) image_list_for_similar_subjects_abs_path = [] similarity_scores = [] folder_path = os.path.dirname(obj_feat_matrix['path'][0]) # create list of images for each subject to visualize most similar subjects for subject in (sorted_subject_similarity): if subject[0] != given_subject_id: metadata = dim_reduction.get_metadata("id", list([subject[0]])) similarity_scores.append(subject[1]) image_list_for_similar_subject = list( set(metadata["imageName"].tolist()).intersection( set(img_set["imageId"].tolist()))) image_list_for_one_similar_subject_abs_path = [] for image in image_list_for_similar_subject: image_list_for_one_similar_subject_abs_path.append( (os.path.join(folder_path, image))) image_list_for_similar_subjects_abs_path.append( image_list_for_one_similar_subject_abs_path) similar_subject_count -= 1 if (similar_subject_count <= 0): break # Create image list for given subject image_list_for_given_subject_abs_path = [] # pick 5 images of given subject at random from master dataset for image in image_list_for_given_subject: image_list_for_given_subject_abs_path.append( os.path.abspath(os.path.join(master_folder, image))) output_path = os.path.abspath(os.path.join("output")) if not os.path.exists(output_path): os.makedirs(output_path) fig_filename = os.path.join( output_path, "task6_{0}_{1}_{2}_{3}_{4}.png".format(feature_extraction_model, dimension_reduction_model, str(k_value), dist_func, given_subject_id)) # show images on a plot imgvwr.show_subjectwise_images(given_subject_id, image_list_for_given_subject_abs_path, list_subjects, image_list_for_similar_subjects_abs_path, fig_filename) print("\nTime taken for task 6: {}\n".format(time.time() - starttime))
def main(): """Main function for the script""" feature_extraction_model = "HOG" # feature_extraction_models = ["CM", "HOG"] feature_extraction_model_1 = "CM" dimension_reduction_model = "PCA" k_value = 10 dim_k_value = 40 # K_value = 20 # lab_folder = "Dataset3/Labelled/Set1" # unlab_folder = "Dataset3/Unlabelled/Set 2" lab_folder = get_input_folder("Labelled Folder") unlab_folder = get_input_folder("Classify") start = time.time() # ================================================================================================================ # labelled Images dim_red = DimensionReduction(feature_extraction_model, dimension_reduction_model, dim_k_value, folder_metadata=lab_folder, metadata_collection="labelled") obj_feat_lab = dim_red.get_object_feature_matrix() features_list_lab = np.array(obj_feat_lab['featureVector'].tolist()) images_list_lab = np.array(obj_feat_lab['imageId']) # filtering the labelled set dorsal_list, palmar_list = filter_images_by_label(images_list_lab) # unlabelled images dim_red = DimensionReduction(feature_extraction_model, dimension_reduction_model, dim_k_value, folder_metadata=unlab_folder, metadata_collection="unlabelled") obj_feat_unlab = dim_red.get_object_feature_matrix() features_list_unlab = np.array(obj_feat_unlab['featureVector'].tolist()) images_list_unlab = np.array(obj_feat_unlab['imageId']) # ================================================================================================================ # labelled Images dim_red = DimensionReduction(feature_extraction_model_1, dimension_reduction_model, dim_k_value, folder_metadata=lab_folder, metadata_collection="labelled") obj_feat_lab_1 = dim_red.get_object_feature_matrix() features_list_lab_1 = np.array(obj_feat_lab_1['featureVector'].tolist()) # images_list_lab = np.array(obj_feat_lab_1['imageId']) # filtering the labelled set # unlabelled images dim_red = DimensionReduction(feature_extraction_model_1, dimension_reduction_model, dim_k_value, folder_metadata=unlab_folder, metadata_collection="unlabelled") obj_feat_unlab_1 = dim_red.get_object_feature_matrix() features_list_unlab_1 = np.array( obj_feat_unlab_1['featureVector'].tolist()) # images_list_unlab = np.array(obj_feat_unlab['imageId']) features_list_lab = np.concatenate( (features_list_lab, features_list_lab_1), axis=1) features_list_unlab = np.concatenate( (features_list_unlab, features_list_unlab_1), axis=1) # ================================================================================================================ dorsal_list, palmar_list = filter_images_by_label(images_list_lab) features_list = np.concatenate((features_list_lab, features_list_unlab)) images_list = np.concatenate((images_list_lab, images_list_unlab)) images_list = list(images_list) # Finding Similarity Matrix cos_sim = cosine_similarity(features_list) sim_graph = np.empty((0, len(cos_sim))) for row in cos_sim: k_largest = np.argsort(-np.array(row))[1:k_value + 1] sim_graph_row = [d if i in k_largest else 0 for i, d in enumerate(row)] sim_graph = np.append(sim_graph, np.array([sim_graph_row]), axis=0) row_sums = sim_graph.sum(axis=1) sim_graph = sim_graph / row_sums[:, np.newaxis] idx = 0 results_dorsal = ppr(sim_graph, images_list, dorsal_list) results_palmar = ppr(sim_graph, images_list, palmar_list) final_results = {} for img in images_list_unlab: if results_dorsal[img] < results_palmar[img]: final_results[img] = "dorsal" else: final_results[img] = "palmar" actual_labels = fetch_actual_labels(images_list_unlab) print("Classification") no_correct = 0 correctly_classified = [] incorrectly_classified = [] print("| ImageId | Prediction | Actual |") for r in final_results: print("| {} | {} | {} |".format(r, final_results[r], actual_labels[r])) if final_results[r] == actual_labels[r]: correctly_classified.append(r) no_correct += 1 else: incorrectly_classified.append(r) print("Correctly classified: {}\n".format(correctly_classified)) print("InCorrectly classified: {}\n".format(incorrectly_classified)) print("Classification Accuracy: {}%".format(no_correct / len(images_list_unlab) * 100)) print("Execution time: {} seconds".format(time.time() - start))
def main(): """Main function for the script""" start = time.time() feature_extraction_model = "HOG" # feature_extraction_models = ["CM", "HOG"] feature_extraction_model_1 = "CM" dimension_reduction_model = "PCA" k_value = 5 dim_k_value = 40 # K_value = 20 lab_folder = "Dataset3/Labelled/Set1" unlab_folder = "Dataset3/Unlabelled/Set 2" # ================================================================================================================ # labelled Images dim_red = DimensionReduction(feature_extraction_model, dimension_reduction_model, dim_k_value, folder_metadata=lab_folder, metadata_collection="labelled") obj_feat_lab = dim_red.get_object_feature_matrix() features_list_lab = np.array(obj_feat_lab['featureVector'].tolist()) images_list_lab = np.array(obj_feat_lab['imageId']) # filtering the labelled set dorsal_list, palmar_list = filter_images_by_label(images_list_lab) # unlabelled images dim_red = DimensionReduction(feature_extraction_model, dimension_reduction_model, dim_k_value, folder_metadata=unlab_folder, metadata_collection="unlabelled") obj_feat_unlab = dim_red.get_object_feature_matrix() # features_list_unlab = np.array(obj_feat_unlab['featureVector'].tolist()) images_list_unlab = np.array(obj_feat_unlab['imageId']) # ================================================================================================================ # labelled Images dim_red = DimensionReduction(feature_extraction_model_1, dimension_reduction_model, dim_k_value, folder_metadata=lab_folder, metadata_collection="labelled") obj_feat_lab_1 = dim_red.get_object_feature_matrix() features_list_lab_1 = np.array(obj_feat_lab_1['featureVector'].tolist()) # images_list_lab = np.array(obj_feat_lab_1['imageId']) # filtering the labelled set # # unlabelled images # dim_red = DimensionReduction(feature_extraction_model_1, dimension_reduction_model, dim_k_value, # folder_metadata=unlab_folder, # metadata_collection="unlabelled") # obj_feat_unlab_1 = dim_red.get_object_feature_matrix() # features_list_unlab_1 = np.array(obj_feat_unlab_1['featureVector'].tolist()) # # images_list_unlab = np.array(obj_feat_unlab['imageId']) # ================================================================================================================ features_list_lab = np.concatenate( (features_list_lab, features_list_lab_1), axis=1) # features_list_unlab = np.concatenate((features_list_unlab, features_list_unlab_1), axis=1) # mongo_wrap = MongoWrapper() # res = mongo_wrap.find(feature_extraction_model.lower(), {"imageId": que}) # res1 = mongo_wrap.find(feature_extraction_model_1.lower(), ) dorsal_list, palmar_list = filter_images_by_label(images_list_lab) # features_list = np.concatenate((features_list_lab, features_list_unlab)) # print(features_list.shape) feature_list = features_list_lab # images_list = np.concatenate((images_list_lab, images_list_unlab)) # images_list = list(images_list) # Finding Similarity Matrix mongo_wrap = MongoWrapper() final_results = {} for img in images_list_unlab: # print(len(images_list_lab)) images_list = np.concatenate((images_list_lab, [img])) # print(images_list) res = mongo_wrap.find(feature_extraction_model.lower(), {"imageId": img})[0] res1 = mongo_wrap.find(feature_extraction_model_1.lower(), {"imageId": img})[0] feature_query = np.concatenate( (np.array(res["featureVector"]), np.array(res1["featureVector"]))) features_list = np.vstack((feature_list, feature_query)) cos_sim = cosine_similarity(features_list) sim_graph = np.empty((0, len(cos_sim))) for row in cos_sim: k_largest = np.argsort(-np.array(row))[1:k_value + 1] # sim_graph_row = [d if i in k_largest else 0 for i, d in enumerate(row)] sim_graph_row = [ d if i in k_largest else 0 for i, d in enumerate(row) ] sim_graph = np.append(sim_graph, np.array([sim_graph_row]), axis=0) row_sums = sim_graph.sum(axis=1) sim_graph = sim_graph / row_sums[:, np.newaxis] idx = 0 results = ppr(sim_graph, images_list, [img]) dorsal_count = 0 palmar_count = 0 # print("{}: {}".format(img, results)) for r in results: if r != img: # print("{} {}".format(" " * 10, r)) if r in dorsal_list: dorsal_count += 1 elif r in palmar_list: palmar_count += 1 if dorsal_count + palmar_count >= 5: if dorsal_count > palmar_count: final_results[img] = "dorsal" else: final_results[img] = "palmar" break # results_dorsal = ppr(sim_graph, images_list, dorsal_list) # results_palmar = ppr(sim_graph, images_list, palmar_list) # for img in images_list_unlab: # if results_dorsal[img] < results_palmar[img]: # final_results[img] = "dorsal" # else: # final_results[img] = "palmar" actual_labels = fetch_actual_labels(final_results.keys()) print("Classification") no_correct = 0 print(len(final_results)) for r in final_results: print("Image Id: {}, Label:{} Actual Label: {}".format( r, final_results[r], actual_labels[r])) if final_results[r] == actual_labels[r]: no_correct += 1 print("Classification Accuracy: {}".format( (no_correct / len(final_results)) * 100)) # for palm in # print("Clustering Results") # for r in results: # r["path"] = os.path.abspath(os.path.join(lab_folder, r['imageId'])) # print(r) # query_images_list = [os.path.abspath(os.path.join(folder, img)) for img in query_images] # title = {"Model": "Personalized Page Rank", "k": k_value, "K": K_value} # show_images_ppr(query_images_list, title, results) print("Execution time: {} seconds".format(time.time() - start))
def main(): k = get_input_k("C") training_set = get_input_folder("Labelled") test_set = get_input_folder("Classify") k_value = 30 dim_reduction = DimensionReduction(feature_extraction_model, dimension_reduction_model, k_value) # obj_lat, feat_lat, model = dim_reduction.execute() label = 'dorsal' obj_lat, feat_lat, model = p3task1.compute_latent_semantic_for_label( feature_extraction_model, dimension_reduction_model, label, k_value, training_set) label_p = 'palmar' obj_lat_p, feat_lat_p, model_p = p3task1.compute_latent_semantic_for_label( feature_extraction_model, dimension_reduction_model, label_p, k_value, training_set) red_dim = p3task1.reduced_dimensions_for_unlabelled_folder( feature_extraction_model, dimension_reduction_model, k_value, label, training_set, test_set) #input for project df = obj_lat[['reducedDimensions', 'imageId']] df_p = obj_lat_p[['reducedDimensions', 'imageId']] #inputt for scikit tf = obj_lat['reducedDimensions'] tf_p = obj_lat_p['reducedDimensions'] a = [] a_p = [] for x in tf: a.append(x) for x in tf_p: a_p.append(x) X = df.values Y = df_p.values # k clusters # k=5 # km = KMeans(n_clusters=k, random_state=0, n_init=30, init='k-means++', precompute_distances=True, n_jobs=-1).fit(a) km_p = KMeans(n_clusters=k, random_state=0, n_init=30, init='k-means++', precompute_distances=True, n_jobs=-1).fit(a_p) # print(km.labels_) counter = np.zeros(k) counter_p = np.zeros(k) for k_m in km.labels_: counter[k_m] += 1 # print(counter) for k_m_p in km_p.labels_: counter_p[k_m_p] += 1 # print(counter_p) # d_cluster = km.predict(red_dim['reducedDimensions'].tolist()) p_cluster = km_p.predict(red_dim['reducedDimensions'].tolist()) unlabelled_aspect = dim_reduction.get_metadata_collection( "imageName", red_dim['imageId'].tolist(), "unlabelled")['aspectOfHand'].tolist() y_test = [i.split(' ')[0] for i in unlabelled_aspect] #min max test good = 0 bad = 0 # for ind in range(len(red_dim['reducedDimensions'])): # cc_dorsal = km.cluster_centers_[d_cluster[ind]] # cc_palmar = km_p.cluster_centers_[p_cluster[ind]] # dist_dorsal = np.linalg.norm(red_dim['reducedDimensions'][ind]-cc_dorsal) # dist_palmar = np.linalg.norm(red_dim['reducedDimensions'][ind]-cc_palmar) # if dist_dorsal<dist_palmar: # #print(red_dim['imageId'][ind], label, y_test[ind]) # if y_test[ind] == label: # good +=1 # else: # bad+=1 # else: # #print(red_dim['imageId'][ind], 'palmar', y_test[ind]) # if y_test[ind] == label_p: # good +=1 # else: # bad+=1 # print ("good",good) # print("bad",bad) # km.score() def kmeans_implementation(X): random = np.random.choice(len(X), size=k, replace=False) centroid = {} classes = {} classes2 = {} # for cen in range(k): # for im in range(0,len(X)): # distance=[np.linalg.norm(np.asarray(X[im][0]) - np.asarray(centroid[0])))] for i in range(k): centroid[i] = X[random[i]][0] for iter in range(500): for i in range(k): classes[i] = [] classes2[i] = [] distance = [] for x in X: # print(x[1]) distance = [ np.linalg.norm( np.asarray(x[0]) - np.asarray(centroid[ind])) for ind in range(len(centroid)) ] classification = distance.index(min(distance)) classes[classification].append(x) classes2[classification].append(x[0]) previous = dict(centroid) for classification in classes2: centroid[classification] = np.average(classes2[classification], axis=0) opti = 0 for c in centroid: og_c = previous[c] current = centroid[c] if (np.array_equal(current, og_c)): opti += 1 if (opti == (k)): # print(iter) break return classes, centroid classes, centroid = kmeans_implementation(X) classes_p, centroid_p = kmeans_implementation(Y) #predict loop red_dimension is the query folder def predict_class(red_dim, centroid): query_classes = {} for i in range(k): query_classes[i] = [] for ind in range(len(red_dim['reducedDimensions'])): cluster_distance = [] cluster_distance = [ np.linalg.norm(red_dim['reducedDimensions'][ind] - np.asarray(centroid[q])) for q in range(len(centroid)) ] query_classification = cluster_distance.index( min(cluster_distance)) query_classes[query_classification].append(red_dim['imageId'][ind]) return query_classes query_classes_dorsal = predict_class(red_dim, centroid) query_classes_palmar = predict_class(red_dim, centroid) correct = 0 wrong = 0 def centroid_mean(centroid): res_list = [0] * k_value mean_centroid = [] for i in range(k): res_list = [a + b for a, b in zip(res_list, centroid[i])] for x in res_list: mean_centroid.append(x / k) return mean_centroid mean_centroid_dorsal = centroid_mean(centroid) mean_centroid_palmar = centroid_mean(centroid_p) dorsal_images = [] palmar_images = [] for ind in range(len(red_dim['reducedDimensions'])): image_center_dorsal = 0 image_center_palmar = 0 image_name = red_dim['imageId'][ind] for i in range(k): if (image_name in query_classes_dorsal[i]): image_center_dorsal = i if (image_name in query_classes_palmar[i]): image_center_palmar = i dorsal_distance = np.linalg.norm(red_dim['reducedDimensions'][ind] - centroid[image_center_dorsal]) palmar_distance = np.linalg.norm(red_dim['reducedDimensions'][ind] - centroid_p[image_center_palmar]) if dorsal_distance < palmar_distance: #print(red_dim['imageId'][ind], label, y_test[ind])ยด dorsal_images.append(red_dim['imageId'][ind]) if y_test[ind] == label: correct += 1 else: wrong += 1 else: #print(red_dim['imageId'][ind], 'palmar', y_test[ind]) palmar_images.append(red_dim['imageId'][ind]) if y_test[ind] == label_p: correct += 1 else: wrong += 1 print("correct" + str(correct)) print("wrong" + str(wrong)) print("\nClick here: http://localhost:{0}/result\n".format(port_g)) print("\nClick here: http://localhost:{0}/dorsal\n".format(port_g)) print("\nClick here: http://localhost:{0}/palmar\n".format(port_g)) # APP_ROOT = os.path.dirname(os.path.abspath(__file__)) @app.route('/Dataset2/<filename>') def send_image(filename): return send_from_directory((training_set), filename) @app.route('/test_set/<filename>') def send_image_result(filename): return send_from_directory((test_set), filename) @app.route('/dorsal') def get_gallery(): image_names = [classes, k] return render_template("demo.html", image_names=image_names) @app.route('/palmar') def get_gallery_p(): image_names_p = [classes_p, k] return render_template("demo_p.html", image_names_p=image_names_p) @app.route('/result') def get_gallery_result(): results = [dorsal_images, palmar_images] return render_template("task2.html", results=results) app.run(port=port_g)