def train_classifier(self, agent: AutoEncoder): mlp = MLP(30).to(self.dev) agent.to(self.dev) for i in range(int(self.cfg.nsteps)): X, y = map( lambda x: x.to(self.dev), self.dataset.sample_with_label(int(self.cfg.bsize)), ) latent = agent.encode(X) mlp.train(latent, y) acc = mlp.compute_acc(latent, y) self.tb.add_scalar("Accuracy-Post", acc, global_step=i) # self.writer.add((acc.item(), agent.name), step=i) return mlp
# assume the input dimension is input_d # the network is like input_d -> 4 -> 2 -> 4 -> input_d autoencoder = AutoEncoder() # train autoencoder without fine-tuning print "\ntrain autoencoder without fine-tuning ==========\n" autoencoder.fit([4, 2], iterator, stacked=True, learning_rate=0.02, max_epoch=5000, tied=True, activation="tanh") # encode data (without fine-tuning) encoded_datas = autoencoder.encode(datas) print "encoder (without fine-tuning) ================" print encoded_datas # 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)================"
def evaluate_experiment(path_dti: str, path_mtm: str, data_x: Tensor, data_y: Tensor) -> pd.DataFrame: result_df_container = [] for path_dti in glob.glob(f"{path_dti}/*"): for i in range(2): ae = AutoEncoder(30, False, False, 0.001, "bruh", pre_latent_dim=49) repres = ae.encode(data_x).detach() results = evaluate_representations(repres, data_y, 10, (30, ), args, "Random features") results["Agent"] = i result_df_container.append(results) for i in range(2): ae = AutoEncoder(30, False, False, 0.001, "bruh", pre_latent_dim=49) ae.load_state_dict( torch.load(path_dti + ("/baseline.pt" if i == 0 else "/baseline_2.pt"))) repres = ae.encode(data_x).detach() results = evaluate_representations(repres, data_y, 10, (30, ), args, "AE") results["Agent"] = i result_df_container.append(results) for i in range(3): ae = AutoEncoder(30, False, False, 0.001, "bruh", pre_latent_dim=49) ae.load_state_dict( torch.load(path_dti + f"/{string.ascii_uppercase[i]}.pt")) repres = ae.encode(data_x).detach() results = evaluate_representations(repres, data_y, 10, (30, ), args, "DTI") results["Agent"] = i result_df_container.append(results) for path_mtm in glob.glob(f"{path_mtm}/*"): for i in range(3): ae = AutoEncoder(30, False, False, 0.001, "bruh", pre_latent_dim=49) ae.load_state_dict( torch.load(path_mtm + f"/{string.ascii_uppercase[i]}.pt")) repres = ae.encode(data_x).detach() results = evaluate_representations(repres, data_y, 10, (30, ), args, "AE+MTM") results["Agent"] = i result_df_container.append(results) results = pd.concat(result_df_container) return results
mnist_dataset = MnistWrapper.load_default() # ----------normal relu pretraining---------- print 'Training model with normal relu' folder = 'test/mnist_ae_relu_inf' ae = AutoEncoder(mnist_dataset, encode, decode, None, folder) ae.build_models() num_epoch = 30 lr_schedule = utils.generate_decay_lr_schedule(num_epoch, 0.1, 1) ae.train(128, num_epoch, lr_schedule) ae.save_models() ae.test_models(utils.vis_mnist) ae.log() encoded_dataset = ae.encode(MnistWrapper) encoded_dataset.dump_to_h5(os.path.join(folder, 'encoded_mnist.h5')) encoded_dataset.plot_data_dist(os.path.join(folder, 'encoded_plot.png')) # ----------truncate relu and fine-tune---------- print 'Training model with relu-%d' % RELU_MAX new_folder = 'test/mnist_ae_relu_%d' % RELU_MAX ae = AutoEncoder(mnist_dataset, encode, decode, RELU_MAX, new_folder) ae.build_models(folder) # load previously trained ae mnist_dataset.plot_data_dist(os.path.join(new_folder, 'original_mnist_plot.png')) # num_epoch = 2 # lr_schedule = utils.generate_decay_lr_schedule(num_epoch, 0.1, 1) ae.train(128, num_epoch, lr_schedule) ae.save_models()
# train autoencoder # assume the input dimension is input_d # the network is like input_d -> 4 -> 2 -> 4 -> input_d autoencoder = AutoEncoder() autoencoder.fit([4, 2], iterator, stacked=True, learning_rate=0.1, max_epoch=5000) autoencoder.fine_tune(iterator, learning_rate=0.1, supervised=False) # after training # encode data encoded_datas = autoencoder.encode(datas) print "encoder ================" print encoded_datas # decode data decoded_datas = autoencoder.decode(encoded_datas) print "decoder ================" print decoded_datas # reconstruct data (encode and decode data) reconstructed_datas = autoencoder.reconstruct(datas) print "reconstruct ================" print reconstructed_datas autoencoder.close()
def train_autoencoder_and_log( autoencoder: AutoEncoder, train_loader: DataLoader, test_loader: DataLoader, ) -> None: """Train the autoencoder and log data to disc.""" if os.path.exists(config.LOG_DIR): shutil.rmtree(config.LOG_DIR) os.mkdir(config.LOG_DIR) train_losses = [] test_losses = [] test_images = _get_sample_digits(test_loader) all_encodings = [] all_reconstructions = [] for i in tqdm(range(config.STEPS)): # Train autoencoder.train_step(steps=1) # collect train and test losses train_losses.append(autoencoder.evaluate(train_loader)) test_losses.append(autoencoder.evaluate(test_loader)) # collect and save train encodings encodings = None for images, _ in train_loader: encodings_ = autoencoder.encode(images) if encodings is None: encodings = encodings_ else: encodings = torch.cat((encodings, encodings_), 0) all_encodings.append(encodings) # collect the sample reconstructions reconstructions = autoencoder.autoencode(test_images) all_reconstructions.append(reconstructions) def save(filename, object): filename = os.path.join(config.LOG_DIR, filename) np.save(filename, object) # Format and save data train_losses = np.array(train_losses) save("train_losses.npy", train_losses) test_losses = np.array(test_losses) save("test_losses.npy", test_losses) test_images = (test_images.numpy() + 1) / 2 save("test_images.npy", test_images) all_encodings = np.array([x.numpy() for x in all_encodings]) save("encodings.npy", all_encodings) all_reconstructions = np.array([x.numpy() for x in all_reconstructions]) all_reconstructions = (all_reconstructions + 1) / 2 save("reconstructions.npy", all_reconstructions) labels = [x.numpy() for __, x in train_loader] labels = np.array(labels, dtype=int).flatten() save("labels.npy", labels)
from dataset_wrapper import Cifar10Wrapper import keras.backend as K def compare_dataset(): d1 = Cifar10Wrapper.load_from_h5('prod/test_relu6/encoded_cifar10.h5') d2 = Cifar10Wrapper.load_from_h5( 'prod/cifar10_ae2_relu_6/encoded_cifar10.h5') return d1, d2 if __name__ == '__main__': K.set_session(utils.create_session()) cifar10_dataset = Cifar10Wrapper.load_default() folder = 'prod/test_relu6' ae = AutoEncoder(cifar10_dataset, encode, decode, RELU_MAX, folder) ae.build_models(folder) # load previously trained ae # num_epoch = 2 # lr_schedule = utils.generate_decay_lr_schedule(num_epoch, 0.1, 1) # ae.train(128, num_epoch, lr_schedule) # ae.save_models() # ae.test_models(utils.vis_cifar10) # ae.log() encoded_dataset = ae.encode(Cifar10Wrapper) # encoded_dataset.dump_to_h5(os.path.join(folder, 'encoded_cifar10.h5')) # encoded_dataset.plot_data_dist(os.path.join(folder, 'encoded_plot.png'))
drop_last=True) model = AutoEncoder(input_dim=21, latent_dim=5) criterion = nn.MSELoss() optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, weight_decay=1e-5) AutoEncoder.fit(model, num_epochs, dataloader, criterion, optimizer) for ccs_item in tqdm(mv.ccs_items()): print('ccs item:', ccs_item) while mv.is_ccs(ccs_item): u = mv.pick_random_user() print('user:', u) rated_ncs_items_by_u = mv.rated_ncs_items(u) u_rated_latents = [ model.encode(mv.features(m)) for m in rated_ncs_items_by_u ] ccs_latent = model.encode(mv.features(ccs_item)) cosine_sims = [ cosine(r_latent, ccs_latent) for r_latent in u_rated_latents ] sorted_idxs = np.argsort(cosine_sims) top10_ncs_items = rated_ncs_items_by_u[sorted_idxs][:10] top10_ncs_ratings = [mv.rating(u, m) for m in top10_ncs_items] mean_top10 = np.mean(top10_ncs_ratings) mv.append_rating(user=u, item=ccs_item, rating=mean_top10) # print(f"\nccs_item:{ccs_item} | user:{u} | rating:{mean_top10} | rcount:{mv.rating_count(ccs_item)}")
stl10_dataset = STL10Wrapper.load_from_h5('data/stl10.h5') # ----------normal relu pretraining---------- print 'Training model with normal relu' folder = 'prod/stl10_ae_%d_inf' % LATENT_DIM ae = AutoEncoder(stl10_dataset, encode, decode, None, folder) ae.build_models() num_epoch = 150 lr_schedule = utils.generate_decay_lr_schedule(num_epoch, 0.1, 1) ae.train(128, num_epoch, lr_schedule) ae.save_models() ae.test_models(utils.vis_stl10) ae.log() encoded_dataset = ae.encode(STL10Wrapper) encoded_dataset.dump_to_h5(os.path.join(folder, 'encoded_stl10.h5')) # encoded_dataset.plot_data_dist(os.path.join(folder, 'encoded_plot.png')) # ----------truncate relu and fine-tune---------- print 'Training model with relu-%d' % RELU_MAX new_folder = 'prod/stl10_ae_%d_relu%d' % (LATENT_DIM, RELU_MAX) ae = AutoEncoder(stl10_dataset, encode, decode, RELU_MAX, new_folder) ae.build_models(folder) # load previously trained ae ae.train(96, num_epoch, lr_schedule) ae.save_models() ae.log() ae.test_models(utils.vis_stl10) encoded_dataset = ae.encode(STL10Wrapper)
X_raw, y_raw = load_eeg_raw("{}data/raw/".format(base_path)) elif data_name == "syn": X_raw, y_raw = load_one_syn_raw("{}data/raw/".format(base_path), data_idx) elif data_name == "har": X_raw, y_raw = load_har_raw("{}data/raw/".format(base_path)) else: assert(False) print("y_raw: {}".format(y_raw.shape)) X_sliding = sliding_window(X_raw, args["window_size"]) X_variable = Variable(torch.Tensor(X_sliding), requires_grad=False).to(device) auto_encoder = AutoEncoder(input_dim=X_sliding.shape[1], hidden_sizes=args["hidden_sizes"], latent_dim=args["latent_dim"], ).to(device) auto_encoder.load_state_dict(torch.load(checkpoint_path, map_location=device)) z = auto_encoder.encode(X_variable).detach().numpy() print(z.shape) def find_peaks(z): dists = np.sqrt(np.sum(np.diff(z, axis=0) ** 2, axis=1)) print(dists.shape) def mean(xs): return sum(xs) * 1. / len(xs) # inspect width, i.e. for t we inspect [t-d, t+d] d = 50 indices = [ i for i in range(d, dists.shape[0] - d)