# train autoencoder with fine-tuning print "\ntrain autoencoder with fine-tuning ==========\n" autoencoder.fine_tune(fine_tuning_iterator, supervised=True, learning_rate=0.02, max_epoch=10000, tied=True) #autoencoder.fine_tune(fine_tuning_iterator, supervised = False, learning_rate = 0.02, max_epoch = 6000) # encode data (with fine-tuning) tuned_encoded_datas = autoencoder.encode(datas) print "encoder (with fine-tuning)================" print tuned_encoded_datas # predict data( based on fine tuning ) predicted_datas = autoencoder.predict(datas) print "predicted ================" print predicted_datas predicted_labels = predicted_datas.argmax(1) eval_array = (predicted_labels == labels) correct_count = len(np.where(eval_array == True)[0]) error_count = len(np.where(eval_array == False)[0]) correct_rate = float(correct_count) / (correct_count + error_count) error_rate = float(error_count) / (correct_count + error_count) print "correct: {}({})\terror: {}({})".format(correct_count, "%.2f" % correct_rate, error_count, "%.2f" % error_rate) autoencoder.close() #visualize encoded datas colors = ["red", "green", "blue"]
# Compiling model.compile(loss=args.loss, optimizer="adam") # Fitting model.fit(completeTrainGen, steps_per_epoch, n_epochs=args.e, batch_size=args.bs, wandb=args.wandb) # Saving model.save_models() print("Done training") print("\nCreating embeddings...") E_train = model.predict(X_train) E_train_flatten = E_train.reshape((-1, np.prod(output_shape_model))) # Read images query_map = loader.get_files(QueryDir) query_names, query_paths, imgs_query, query_classes = loader.get_data_paths( query_map) gallery_map = loader.get_files(GalleryDir) gallery_names, gallery_paths, imgs_gallery, gallery_classes = loader.get_data_paths( gallery_map) # Normalize all images print("Normalizing query images") imgs_query = normalize_img(imgs_query) print("Normalizing gallery images") imgs_gallery = normalize_img(imgs_gallery)
train_x_with_noise = add_noise(train_x, 2) test_x_with_noise = add_noise(train_x, 2) ae = AutoEncoder([25, 15], 10, [10, 25], activation='tanh', solver='lbfgs', eta=0.0001, max_iterations=30000, tol=0.0000001, verbose=True) ae.fit(train_x_with_noise, train_x) for i in range(32): prediction_1 = ae.predict(train_x_with_noise[i]) prediction_2 = ae.predict(train_x[i]) prediction_3 = ae.predict(test_x_with_noise[i]) plt.figure() plt.subplot(3, 2, 1) plt.imshow(train_x_with_noise[i].reshape(7, 5), 'gray_r') plt.title("Train Input noise", fontsize=15) plt.xticks([]) plt.yticks([]) plt.subplot(3, 2, 2) plt.imshow(prediction_1.reshape(7, 5), 'gray_r') plt.title('Predicted noise', fontsize=15) plt.xticks([]) plt.yticks([]) plt.subplot(3, 2, 3)
transform_binary_matrix(rating_df, user2idx, movie2idx) print( f'Positive Feedback: {stat["pos"]}', f'\tNegative Feedback: {stat["neg"]}' ) rating_matrix_train, rating_matrix_val =\ split_matrix(rating_matrix, user2idx, movie2idx) print( f'Train: {rating_matrix_train.count_nonzero()}\t', f'Validation Size: {rating_matrix_val.count_nonzero()}' ) # Train Auto Encoder Model X = rating_matrix_train.toarray() model = AutoEncoder(input_dim=len(movie2idx), encoding_dim=20) model.train(X) # Make Prediction recommendations = model.predict(X, n=100) # Evaluate precison_100 = n_precision(recommendations, rating_matrix_val, 100) recall_100 = n_recall(recommendations, rating_matrix_val, 100) print(f'P@100 : {precison_100:.2%}') print(f'R@100 : {recall_100:.2%}') # Save Recommendation np.savez('./output/rec_auto.npz', recommendations)
feat_extractor = AutoEncoder(exp=args.exp, weights_path=args.weights_path) print("loading features ... ", end='') sys.stdout.flush() for set_ in [k for k in anno.keys() if k != "tags"]: imid_list = sorted(list(anno[set_].keys())) # only for reproducibility X[set_] = None Y[set_] = [None for _ in range(len(imid_list))] if args.exp == 1: for i, imid in tqdm(enumerate(imid_list), total=len(imid_list)): # set image features fname = splitext(anno[set_][imid]["file_name"])[0] + ".dat" x = load(join(args.features_path, set_, fname)) x = normalize_rows(x.reshape(1, -1)).squeeze() x = feat_extractor.predict(kind="img", x=x) if i == 0: n_samples = len(imid_list) n_dim = x.shape[0] X[set_] = np.empty((n_samples, n_dim), dtype=np.float32) X[set_][i] = x # set word embeddings (OOV tags are set to the zero vector) tags = anno[set_][imid]["tags"] y = [[0] * vec_dim if vecs[w] is None else vecs[w] for w in tags] y = normalize_rows(np.array(y, dtype=np.float32)) y = [t.reshape(1, -1) for t in y] y = feat_extractor.predict(kind="text", y=y) Y[set_][i] = y elif args.exp == 2:
# Declare the model autoencoder = AutoEncoder() x_train_noisy, x_train = build_dataset() # train the autoencoder model autoencoder.fit(x_train_noisy, x_train, epochs=100000, batch_size=128, shuffle=True, validation_data=(x_test_noisy, x_test), verbose=1) # visaulize decoed denoise image decoded_imgs = autoencoder.predict(x_test) n = 10 plt.figure(figsize=(20, 4)) for i in range(n): # display original ax = plt.subplot(2, n, i + 1) plt.imshow(x_test_noisy[i].reshape(256, 256)) plt.gray() ax.get_xaxis().set_visible(False) ax.get_yaxis().set_visible(False) # display reconstruction ax = plt.subplot(2, n, i + 1 + n) plt.imshow(decoded_imgs[i].reshape(256, 256))
output_shape_model = tuple( [int(x) for x in model.encoder.output.shape[1:]]) # Loading model model.load_models(loss='mse', optimizer="adam") # Convert images to numpy array of right dimensions print("\nConverting to numpy array of right dimensions") X_query = np.array(QueryImgs).reshape((-1, ) + input_shape_model) X_gallery = np.array(GalleryImgs).reshape((-1, ) + input_shape_model) print(">>> X_query.shape = " + str(X_query.shape)) print(">>> X_gallery.shape = " + str(X_gallery.shape)) # Create embeddings using model print("\nCreating embeddings") E_query = model.predict(X_query) E_query_flatten = E_query.reshape((-1, np.prod(output_shape_model))) E_gallery = model.predict(X_gallery) E_gallery_flatten = E_gallery.reshape((-1, np.prod(output_shape_model))) print("\nComputing pairwise distance between query and gallery images") # Define the distance between query - gallery features vectors pairwise_dist = spatial.distance.cdist(E_query_flatten, E_gallery_flatten, args.metric, p=2.) print('\nComputed distances and got c-dist {}'.format(pairwise_dist.shape)) print("\nCalculating indices and gallery matches...") indices = np.argsort(pairwise_dist, axis=-1)