def main(args): """ parameters """ RESULTS_DIR = ss.path.DATADIR + "vae/" + args.results_path # network architecture ADD_NOISE = args.add_noise n_hidden = args.n_hidden dim_img = IMAGE_SIZE_MNIST**2 # number of pixels for a MNIST image dim_z = args.dim_z # train n_epochs = args.num_epochs batch_size = args.batch_size learn_rate = args.learn_rate # Plot PRR = args.PRR # Plot Reproduce Result PRR_n_img_x = args.PRR_n_img_x # number of images along x-axis in a canvas PRR_n_img_y = args.PRR_n_img_y # number of images along y-axis in a canvas PRR_resize_factor = args.PRR_resize_factor # resize factor for each image in a canvas PMLR = args.PMLR # Plot Manifold Learning Result PMLR_n_img_x = args.PMLR_n_img_x # number of images along x-axis in a canvas PMLR_n_img_y = args.PMLR_n_img_y # number of images along y-axis in a canvas PMLR_resize_factor = args.PMLR_resize_factor # resize factor for each image in a canvas PMLR_z_range = args.PMLR_z_range # range for random latent vector PMLR_n_samples = args.PMLR_n_samples # number of labeled samples to plot a map from input data space to the latent space """ prepare MNIST data """ train_total_data, train_size, _, _, test_data, test_labels = mnist_data.prepare_MNIST_data( ) n_samples = train_size """ build graph """ # input placeholders # In denoising-autoencoder, x_hat == x + noise, otherwise x_hat == x x_hat = tf.placeholder(tf.float32, shape=[None, dim_img], name='input_img') x = tf.placeholder(tf.float32, shape=[None, dim_img], name='target_img') # dropout keep_prob = tf.placeholder(tf.float32, name='keep_prob') # input for PMLR z_in = tf.placeholder(tf.float32, shape=[None, dim_z], name='latent_variable') # network architecture y, z, loss, neg_marginal_likelihood, KL_divergence = vae.autoencoder( x_hat, x, dim_img, dim_z, n_hidden, keep_prob) # optimization train_op = tf.train.AdamOptimizer(learn_rate).minimize(loss) """ training """ # Plot for reproduce performance if PRR: PRR = plot_utils.Plot_Reproduce_Performance(RESULTS_DIR, PRR_n_img_x, PRR_n_img_y, IMAGE_SIZE_MNIST, IMAGE_SIZE_MNIST, PRR_resize_factor) x_PRR = test_data[0:PRR.n_tot_imgs, :] x_PRR_img = x_PRR.reshape(PRR.n_tot_imgs, IMAGE_SIZE_MNIST, IMAGE_SIZE_MNIST) PRR.save_images(x_PRR_img, name='input.jpg') if ADD_NOISE: x_PRR = x_PRR * np.random.randint(2, size=x_PRR.shape) x_PRR += np.random.randint(2, size=x_PRR.shape) x_PRR_img = x_PRR.reshape(PRR.n_tot_imgs, IMAGE_SIZE_MNIST, IMAGE_SIZE_MNIST) PRR.save_images(x_PRR_img, name='input_noise.jpg') # Plot for manifold learning result if PMLR and dim_z == 2: PMLR = plot_utils.Plot_Manifold_Learning_Result( RESULTS_DIR, PMLR_n_img_x, PMLR_n_img_y, IMAGE_SIZE_MNIST, IMAGE_SIZE_MNIST, PMLR_resize_factor, PMLR_z_range) x_PMLR = test_data[0:PMLR_n_samples, :] id_PMLR = test_labels[0:PMLR_n_samples, :] if ADD_NOISE: x_PMLR = x_PMLR * np.random.randint(2, size=x_PMLR.shape) x_PMLR += np.random.randint(2, size=x_PMLR.shape) decoded = vae.decoder(z_in, dim_img, n_hidden) # train total_batch = int(n_samples / batch_size) min_tot_loss = 1e99 with tf.Session() as sess: sess.run(tf.global_variables_initializer(), feed_dict={keep_prob: 0.9}) for epoch in range(n_epochs): # Random shuffling np.random.shuffle(train_total_data) train_data_ = train_total_data[:, :-mnist_data.NUM_LABELS] # Loop over all batches for i in range(total_batch): # Compute the offset of the current minibatch in the data. offset = (i * batch_size) % (n_samples) batch_xs_input = train_data_[offset:(offset + batch_size), :] batch_xs_target = batch_xs_input # add salt & pepper noise if ADD_NOISE: batch_xs_input = batch_xs_input * np.random.randint( 2, size=batch_xs_input.shape) batch_xs_input += np.random.randint( 2, size=batch_xs_input.shape) _, tot_loss, loss_likelihood, loss_divergence = sess.run( (train_op, loss, neg_marginal_likelihood, KL_divergence), feed_dict={ x_hat: batch_xs_input, x: batch_xs_target, keep_prob: 0.9 }) # print cost every epoch print( "epoch %d: L_tot %03.2f L_likelihood %03.2f L_divergence %03.2f" % (epoch, tot_loss, loss_likelihood, loss_divergence)) # if minimum loss is updated or final epoch, plot results if min_tot_loss > tot_loss or epoch + 1 == n_epochs: min_tot_loss = tot_loss # Plot for reproduce performance if PRR: y_PRR = sess.run(y, feed_dict={x_hat: x_PRR, keep_prob: 1}) y_PRR_img = y_PRR.reshape(PRR.n_tot_imgs, IMAGE_SIZE_MNIST, IMAGE_SIZE_MNIST) PRR.save_images(y_PRR_img, name="/PRR_epoch_%02d" % (epoch) + ".jpg") # Plot for manifold learning result if PMLR and dim_z == 2: y_PMLR = sess.run(decoded, feed_dict={ z_in: PMLR.z, keep_prob: 1 }) y_PMLR_img = y_PMLR.reshape(PMLR.n_tot_imgs, IMAGE_SIZE_MNIST, IMAGE_SIZE_MNIST) PMLR.save_images(y_PMLR_img, name="/PMLR_epoch_%02d" % (epoch) + ".jpg") # plot distribution of labeled images z_PMLR = sess.run(z, feed_dict={ x_hat: x_PMLR, keep_prob: 1 }) PMLR.save_scattered_image(z_PMLR, id_PMLR, name="/PMLR_map_epoch_%02d" % (epoch) + ".jpg")
def main(args): """ parameters """ RESULTS_DIR = args['results_path'] # network architecture ADD_NOISE = args['add_noise'] n_hidden = args['n_hidden'] dim_img = IMAGE_SIZE_MNIST**2 # number of pixels for a MNIST image dim_z = args['dim_z'] # train n_epochs = args['num_epochs'] batch_size = args['batch_size'] learn_rate = args['learn_rate'] # Plot PMLR = args['PMLR'] # Plot Manifold Learning Result PMLR_n_img_x = args[ 'PMLR_n_img_x'] # number of images along x-axis in a canvas PMLR_n_img_y = args[ 'PMLR_n_img_y'] # number of images along y-axis in a canvas PMLR_resize_factor = args[ 'PMLR_resize_factor'] # resize factor for each image in a canvas PMLR_z_range = args['PMLR_z_range'] # range for random latent vector DEVICE = args['DEVICE'] # set device p_zeroed = args['p_zeroed'] """ prepare Ascent_MNIST data """ dataset = Ascent_MNISTdataset() train_loader = torch.utils.data.DataLoader(dataset, batch_size=args['batch_size'], shuffle=True, num_workers=0) # Teacher classifier model_path = 'C://Users//KIMHAKBIN//Documents//PycharmProjects//Activation_Maximization//pretrained//mnist.pth.tar' classifier = LeNet5() load_checkpoints(classifier, model_path, DEVICE) # encoder AutoEncoder = VAEcore.autoencoder(dim_img, dim_z, n_hidden, p_zeroed) # networks networks = (classifier, AutoEncoder) # optimizer optimizer = optim.Adam(AutoEncoder.parameters(), learn_rate) # Plot for manifold learning result if PMLR and dim_z == 2: PMLR = plot_utils.Plot_Manifold_Learning_Result( RESULTS_DIR, PMLR_n_img_x, PMLR_n_img_y, IMAGE_SIZE_MNIST, IMAGE_SIZE_MNIST, PMLR_resize_factor, PMLR_z_range) # train per epoch min_trn_loss = 1e99 for epoch in range(1, n_epochs + 1): trn_acc, trn_loss = train_epoch(networks, optimizer, train_loader, batch_size) print('Iteration:', epoch, '\t', 'Accuaracy:', trn_acc, '\t', 'Loss:', trn_loss) # if minimum loss is updated or final epoch, plot results if min_trn_loss > np.sum(trn_loss) or epoch + 1 == n_epochs: min_trn_loss = np.sum(trn_loss) # Plot for manifold learning result if PMLR and dim_z == 2: AutoEncoder.eval() # p_zeroed를 0으로 만들어 줘야함 z = torch.from_numpy(PMLR.z).float() y_PMLR = AutoEncoder.Decoder(z) y_PMLR_img = y_PMLR.reshape(PMLR.n_tot_imgs, IMAGE_SIZE_MNIST, IMAGE_SIZE_MNIST) y_PMLR_img = y_PMLR_img.detach().numpy() PMLR.save_images(y_PMLR_img, name="/PMLR_epoch_%02d" % (epoch) + ".jpg") print('Training Finish!!')
def build_model(self): # some parameters image_dims = [self.input_height, self.input_width, self.c_dim] bs = self.batch_size """ Graph Input """ # images self.inputs = tf.placeholder(tf.float32, [bs] + image_dims, name='real_images') # noises self.z = tf.placeholder(tf.float32, [bs, self.z_dim], name='z') """ Loss Function """ # output of D for real images D_real, D_real_logits, _ = self.discriminator(self.inputs, is_training=True, reuse=False) # output of D for fake images G = self.generator(self.z, is_training=True, reuse=False) D_fake, D_fake_logits, _ = self.discriminator(G, is_training=True, reuse=True) # get loss for discriminator d_loss_real = -tf.reduce_mean(D_real_logits) d_loss_fake = tf.reduce_mean(D_fake_logits) self.d_loss = d_loss_real + d_loss_fake # get loss for generator self.g_loss = -d_loss_fake """ Training """ # divide trainable variables into a group for D and a group for G t_vars = tf.trainable_variables() d_vars = [var for var in t_vars if 'd_' in var.name] g_vars = [var for var in t_vars if 'g_' in var.name] # optimizers with tf.control_dependencies(tf.get_collection( tf.GraphKeys.UPDATE_OPS)): self.d_optim = tf.train.AdamOptimizer(self.learning_rate, beta1=self.beta1) \ .minimize(self.d_loss, var_list=d_vars) self.g_optim = tf.train.AdamOptimizer(self.learning_rate*5, beta1=self.beta1) \ .minimize(self.g_loss, var_list=g_vars) # weight clipping self.clip_D = [ p.assign(tf.clip_by_value(p, -0.01, 0.01)) for p in d_vars ] """" Testing """ # for test self.fake_images = self.generator(self.z, is_training=False, reuse=True) self.z_in = tf.placeholder(tf.float32, [1, self.z_dim], name='z_in') self.y_out = self.generator(self.z_in, is_training=False, reuse=True) self.y0 = tf.placeholder(tf.float32, [1, 28, 28, 1], name='y0') self.f = tf.reduce_sum(tf.square(self.y_out - self.y0)) self.gradient = tf.gradients(ys=self.f, xs=self.z_in) """ Summary """ d_loss_real_sum = tf.summary.scalar("d_loss_real", d_loss_real) d_loss_fake_sum = tf.summary.scalar("d_loss_fake", d_loss_fake) d_loss_sum = tf.summary.scalar("d_loss", self.d_loss) g_loss_sum = tf.summary.scalar("g_loss", self.g_loss) # final summary operations self.g_sum = tf.summary.merge([d_loss_fake_sum, g_loss_sum]) self.d_sum = tf.summary.merge([d_loss_real_sum, d_loss_sum]) # Plot for manifold learning result if self.z_dim == 2: self.PMLR = plot_utils.Plot_Manifold_Learning_Result( self.result_dir, 20, 20, 28, 28, 1.0, 1.0) #change to 1 # saver to save model self.saver = tf.train.Saver(max_to_keep=1000)
def build_model(self): # some parameters image_dims = [self.input_height, self.input_width, self.c_dim] bs = self.batch_size """ Graph Input """ # images self.inputs = tf.placeholder(tf.float32, [bs] + image_dims, name='real_images') # noises self.z = tf.placeholder(tf.float32, [bs, self.z_dim], name='z') """ Loss Function """ # output of D for real images D_real, D_real_logits, _ = self.discriminator(self.inputs, is_training=True, reuse=False) # output of D for fake images G = self.generator(self.z, is_training=True, reuse=False) D_fake, D_fake_logits, _ = self.discriminator(G, is_training=True, reuse=True) # get loss for discriminator d_loss_real = - tf.reduce_mean(D_real_logits) d_loss_fake = tf.reduce_mean(D_fake_logits) self.d_loss = d_loss_real + d_loss_fake # get loss for generator self.g_loss = - d_loss_fake """ Gradient Penalty """ # This is borrowed from https://github.com/kodalinaveen3/DRAGAN/blob/master/DRAGAN.ipynb alpha = tf.random_uniform(shape=self.inputs.get_shape(), minval=0.,maxval=1.) differences = G - self.inputs # This is different from MAGAN interpolates = self.inputs + (alpha * differences) _,D_inter,_=self.discriminator(interpolates, is_training=True, reuse=True) gradients = tf.gradients(D_inter, [interpolates])[0] slopes = tf.sqrt(tf.reduce_sum(tf.square(gradients), reduction_indices=[1])) gradient_penalty = tf.reduce_mean((slopes - 1.) ** 2) self.d_loss += self.lambd * gradient_penalty """ Training """ # divide trainable variables into a group for D and a group for G t_vars = tf.trainable_variables() d_vars = [var for var in t_vars if 'd_' in var.name] g_vars = [var for var in t_vars if 'g_' in var.name] # optimizers with tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS)): self.d_optim = tf.train.AdamOptimizer(self.learning_rate, beta1=self.beta1) \ .minimize(self.d_loss, var_list=d_vars) self.g_optim = tf.train.AdamOptimizer(self.learning_rate*5, beta1=self.beta1) \ .minimize(self.g_loss, var_list=g_vars) """" Testing """ # for test self.fake_images = self.generator(self.z, is_training=False, reuse=True) self.z_in = tf.placeholder(tf.float32, [1, self.z_dim], name='z_in') self.y_out = self.generator(self.z_in, is_training=False, reuse=True) self.y0 = tf.placeholder(tf.float32, [1, 28, 28, 1], name='y0') self.f = tf.reduce_sum(tf.square(self.y_out - self.y0)) self.gradient = tf.gradients(ys = self.f, xs = self.z_in) """ Summary """ d_loss_real_sum = tf.summary.scalar("d_loss_real", d_loss_real) d_loss_fake_sum = tf.summary.scalar("d_loss_fake", d_loss_fake) d_loss_sum = tf.summary.scalar("d_loss", self.d_loss) g_loss_sum = tf.summary.scalar("g_loss", self.g_loss) # final summary operations self.g_sum = tf.summary.merge([d_loss_fake_sum, g_loss_sum]) self.d_sum = tf.summary.merge([d_loss_real_sum, d_loss_sum]) # Plot for manifold learning result if self.z_dim == 2: self.PMLR = plot_utils.Plot_Manifold_Learning_Result(check_folder(self.result_dir + '/' + self.model_dir), 20, 20, 28, 28, 1.0, 1.0) #change to 1 # saver to save model self.saver = tf.train.Saver(max_to_keep=1000)
def main(args): """ parameters """ RESULTS_DIR = args.results_path # network architecture n_hidden = args.n_hidden dim_img = IMAGE_SIZE_MNIST**2 # number of pixels for a MNIST image dim_z = 2 # to visualize learned manifold # train n_epochs = args.num_epochs batch_size = args.batch_size learn_rate = args.learn_rate # Plot PRR = args.PRR # Plot Reproduce Result PRR_n_img_x = args.PRR_n_img_x # number of images along x-axis in a canvas PRR_n_img_y = args.PRR_n_img_y # number of images along y-axis in a canvas PRR_resize_factor = args.PRR_resize_factor # resize factor for each image in a canvas PMLR = args.PMLR # Plot Manifold Learning Result PMLR_n_img_x = args.PMLR_n_img_x # number of images along x-axis in a canvas PMLR_n_img_y = args.PMLR_n_img_y # number of images along y-axis in a canvas PMLR_resize_factor = args.PMLR_resize_factor # resize factor for each image in a canvas PMLR_z_range = args.PMLR_z_range # range for random latent vector PMLR_n_samples = args.PMLR_n_samples # number of labeled samples to plot a map from input data space to the latent space """ prepare MNIST data """ train_total_data, train_size, _, _, test_data, test_labels = mnist_data.prepare_MNIST_data( ) n_samples = train_size """ build graph """ # input placeholders # In denoising-autoencoder, x_hat == x + noise, otherwise x_hat == x x_hat = tf.placeholder(tf.float32, shape=[None, dim_img], name='input_img') x = tf.placeholder(tf.float32, shape=[None, dim_img], name='target_img') x_id = tf.placeholder(tf.float32, shape=[None, 10], name='input_img_label') # dropout keep_prob = tf.placeholder(tf.float32, name='keep_prob') # input for PMLR z_in = tf.placeholder(tf.float32, shape=[None, dim_z], name='latent_variable') # samples drawn from prior distribution z_sample = tf.placeholder(tf.float32, shape=[None, dim_z], name='prior_sample') z_id = tf.placeholder(tf.float32, shape=[None, 10], name='prior_sample_label') # network architecture y, z, neg_marginal_likelihood, D_loss, G_loss = aae.adversarial_autoencoder( x_hat, x, x_id, z_sample, z_id, dim_img, dim_z, n_hidden, keep_prob) # optimization t_vars = tf.trainable_variables() d_vars = [var for var in t_vars if "discriminator" in var.name] g_vars = [var for var in t_vars if "MLP_encoder" in var.name] ae_vars = [ var for var in t_vars if "MLP_encoder" or "MLP_decoder" in var.name ] train_op_ae = tf.train.AdamOptimizer(learn_rate).minimize( neg_marginal_likelihood, var_list=ae_vars) train_op_d = tf.train.AdamOptimizer(learn_rate / 5).minimize( D_loss, var_list=d_vars) train_op_g = tf.train.AdamOptimizer(learn_rate).minimize(G_loss, var_list=g_vars) """ training """ # Plot for reproduce performance if PRR: PRR = plot_utils.Plot_Reproduce_Performance(RESULTS_DIR, PRR_n_img_x, PRR_n_img_y, IMAGE_SIZE_MNIST, IMAGE_SIZE_MNIST, PRR_resize_factor) x_PRR = test_data[0:PRR.n_tot_imgs, :] x_PRR_img = x_PRR.reshape(PRR.n_tot_imgs, IMAGE_SIZE_MNIST, IMAGE_SIZE_MNIST) PRR.save_images(x_PRR_img, name='input.jpg') # Plot for manifold learning result if PMLR and dim_z == 2: PMLR = plot_utils.Plot_Manifold_Learning_Result( RESULTS_DIR, PMLR_n_img_x, PMLR_n_img_y, IMAGE_SIZE_MNIST, IMAGE_SIZE_MNIST, PMLR_resize_factor, PMLR_z_range) x_PMLR = test_data[0:PMLR_n_samples, :] id_PMLR = test_labels[0:PMLR_n_samples, :] decoded = aae.decoder(z_in, dim_img, n_hidden) # train total_batch = int(n_samples / batch_size) min_tot_loss = 1e99 with tf.Session() as sess: sess.run(tf.global_variables_initializer(), feed_dict={keep_prob: 0.9}) for epoch in range(n_epochs): # Random shuffling np.random.shuffle(train_total_data) train_data_ = train_total_data[:, :-mnist_data.NUM_LABELS] train_label_ = train_total_data[:, -mnist_data.NUM_LABELS:] # Loop over all batches for i in range(total_batch): # Compute the offset of the current minibatch in the data. offset = (i * batch_size) % (n_samples) batch_xs_input = train_data_[offset:(offset + batch_size), :] batch_ids_input = train_label_[offset:(offset + batch_size), :] batch_xs_target = batch_xs_input # draw samples from prior distribution if args.prior_type == 'mixGaussian': z_id_ = np.random.randint(0, 10, size=[batch_size]) samples = prior.gaussian_mixture(batch_size, dim_z, label_indices=z_id_) elif args.prior_type == 'swiss_roll': z_id_ = np.random.randint(0, 10, size=[batch_size]) samples = prior.swiss_roll(batch_size, dim_z, label_indices=z_id_) elif args.prior_type == 'normal': samples, z_id_ = prior.gaussian(batch_size, dim_z, use_label_info=True) else: raise Exception("[!] There is no option for " + args.prior_type) z_id_one_hot_vector = np.zeros((batch_size, 10)) z_id_one_hot_vector[np.arange(batch_size), z_id_] = 1 # reconstruction loss _, loss_likelihood = sess.run( (train_op_ae, neg_marginal_likelihood), feed_dict={ x_hat: batch_xs_input, x: batch_xs_target, x_id: batch_ids_input, z_sample: samples, z_id: z_id_one_hot_vector, keep_prob: 0.9 }) # discriminator loss _, d_loss = sess.run( (train_op_d, D_loss), feed_dict={ x_hat: batch_xs_input, x: batch_xs_target, x_id: batch_ids_input, z_sample: samples, z_id: z_id_one_hot_vector, keep_prob: 0.9 }) # generator loss for _ in range(2): _, g_loss = sess.run( (train_op_g, G_loss), feed_dict={ x_hat: batch_xs_input, x: batch_xs_target, x_id: batch_ids_input, z_sample: samples, z_id: z_id_one_hot_vector, keep_prob: 0.9 }) tot_loss = loss_likelihood + d_loss + g_loss # print cost every epoch print( "epoch %d: L_tot %03.2f L_likelihood %03.2f d_loss %03.2f g_loss %03.2f" % (epoch, tot_loss, loss_likelihood, d_loss, g_loss)) # if minimum loss is updated or final epoch, plot results if epoch % 2 == 0 or min_tot_loss > tot_loss or epoch + 1 == n_epochs: min_tot_loss = tot_loss # Plot for reproduce performance if PRR: y_PRR = sess.run(y, feed_dict={x_hat: x_PRR, keep_prob: 1}) y_PRR_img = y_PRR.reshape(PRR.n_tot_imgs, IMAGE_SIZE_MNIST, IMAGE_SIZE_MNIST) PRR.save_images(y_PRR_img, name="/PRR_epoch_%02d" % (epoch) + ".jpg") # Plot for manifold learning result if PMLR and dim_z == 2: y_PMLR = sess.run(decoded, feed_dict={ z_in: PMLR.z, keep_prob: 1 }) y_PMLR_img = y_PMLR.reshape(PMLR.n_tot_imgs, IMAGE_SIZE_MNIST, IMAGE_SIZE_MNIST) PMLR.save_images(y_PMLR_img, name="/PMLR_epoch_%02d" % (epoch) + ".jpg") # plot distribution of labeled images z_PMLR = sess.run(z, feed_dict={ x_hat: x_PMLR, keep_prob: 1 }) PMLR.save_scattered_image(z_PMLR, id_PMLR, name="/PMLR_map_epoch_%02d" % (epoch) + ".jpg")
def main(args): np.random.seed(1337) """ parameters """ RESULTS_DIR = args.results_path # network architecture n_hidden = args.n_hidden # train n_epochs = args.num_epochs batch_size = args.batch_size learn_rate = args.learn_rate # Plot PRR = args.PRR # Plot Reproduce Result PRR_n_img_x = args.PRR_n_img_x # number of images along x-axis in a canvas PRR_n_img_y = args.PRR_n_img_y # number of images along y-axis in a canvas PRR_resize_factor = args.PRR_resize_factor # resize factor for each image in a canvas PMLR = args.PMLR # Plot Manifold Learning Result PMLR_n_img_x = args.PMLR_n_img_x # number of images along x-axis in a canvas PMLR_n_img_y = args.PMLR_n_img_y # number of images along y-axis in a canvas PMLR_resize_factor = args.PMLR_resize_factor # resize factor for each image in a canvas PMLR_z_range = args.PMLR_z_range # range for random latent vector PMLR_n_samples = args.PMLR_n_samples # number of labeled samples to plot a map from input data space to the latent space """ prepare MNIST data """ ''' esense_files = [ "AAU_livingLab4_202481591532165_1541682359", "fabio_1-202481588431654_1541691060", "alemino_ZRH_202481601716927_1541691041", "IMDEA_wideband_202481598624002_1541682492" ] b esense_folder = "./datadumps/esense_data_jan2019/" #train_data, train_labels, test_data, test_labels, bw_labels, pos_labels = spec_data.gendata() for ei,efile in enumerate(esense_files): print efile if ei==0: train_data, train_labels,_ = esense_seqload.gendata(esense_folder+efile) else: dtrain_data, dtrain_labels,_ = esense_seqload.gendata(esense_folder+efile) train_data = np.vstack((train_data,dtrain_data)) train_labels = np.vstack((train_labels,dtrain_labels)) ''' #train_data, train_labels, _,_,_,_,_ = synthetic_data.gendata() train_data, train_labels, _, _, _ = hackrf_data.gendata( "./datadumps/sample_hackrf_data.csv") #train_data, train_labels = rawdata.gendata() #Split the data train_data, train_labels = shuffle_in_unison_inplace( train_data, train_labels) splitval = int(train_data.shape[0] * 0.5) test_data = train_data[:splitval] test_labels = train_labels[:splitval] train_data = train_data[splitval:] train_labels = train_labels[splitval:] #Semsup splitting splitval = int(train_data.shape[0] * 0.2) train_data_sup = train_data[:splitval] train_data = train_data[splitval:] train_labels_sup = train_labels[:splitval] train_labels = train_labels[splitval:] n_samples = train_data.shape[0] tsamples = train_data.shape[1] fsamples = train_data.shape[2] dim_img = [tsamples, fsamples] nlabels = train_labels.shape[1] print(nlabels) encoder = "CNN" #encoder="LSTM" dim_z = args.dimz # to visualize learned manifold enable_sel = False """ build graph """ # input placeholders x_hat = tf.placeholder(tf.float32, shape=[None, tsamples, fsamples], name='input_img') x = tf.placeholder(tf.float32, shape=[None, tsamples, fsamples], name='target_img') x_id = tf.placeholder(tf.float32, shape=[None, nlabels], name='input_img_label') # dropout keep_prob = tf.placeholder(tf.float32, name='keep_prob') # input for PMLR z_in = tf.placeholder(tf.float32, shape=[None, dim_z], name='latent_variable') # samples drawn from prior distribution z_sample = tf.placeholder(tf.float32, shape=[None, dim_z], name='prior_sample') cat_sample = tf.placeholder(tf.float32, shape=[None, nlabels], name='prior_sample_label') # network architecture #y, z, neg_marginal_likelihood, D_loss, G_loss = aae.adversarial_autoencoder(x_hat, x, x_id, z_sample, z_id, dim_img, # dim_z, n_hidden, keep_prob) y, z, neg_marginal_likelihood, D_loss, G_loss, cat_gen_loss, cat = spec_aae.adversarial_autoencoder_semsup_cat_nodimred( x_hat, x, x_id, z_sample, cat_sample, dim_img, dim_z, n_hidden, keep_prob, nlabels=nlabels, vdim=2) # optimization t_vars = tf.trainable_variables() d_vars = [ var for var in t_vars if "discriminator" or "discriminator_cat" in var.name ] g_vars = [var for var in t_vars if encoder + "_encoder_cat" in var.name] ae_vars = [ var for var in t_vars if encoder + "_encoder_cat" or "CNN_decoder" in var.name ] train_op_ae = tf.train.AdamOptimizer(learn_rate).minimize( neg_marginal_likelihood, var_list=ae_vars) train_op_d = tf.train.AdamOptimizer(learn_rate / 2.0).minimize( D_loss, var_list=d_vars) train_op_g = tf.train.AdamOptimizer(learn_rate).minimize(G_loss, var_list=g_vars) train_op_cat = tf.train.AdamOptimizer(learn_rate).minimize(cat_gen_loss, var_list=g_vars) """ training """ # Plot for reproduce performance if PRR: PRR = plot_utils.Plot_Reproduce_Performance(RESULTS_DIR, PRR_n_img_x, PRR_n_img_y, tsamples, fsamples, PRR_resize_factor) x_PRR = test_data[0:PRR.n_tot_imgs, :] x_PRR_img = x_PRR.reshape(PRR.n_tot_imgs, tsamples, fsamples) PRR.save_images(x_PRR_img, name='input.jpg') # Plot for manifold learning result if PMLR and dim_z == 2: PMLR = plot_utils.Plot_Manifold_Learning_Result( RESULTS_DIR, PMLR_n_img_x, PMLR_n_img_y, tsamples, fsamples, PMLR_resize_factor, PMLR_z_range) x_PMLR = test_data[0:PMLR_n_samples, :] id_PMLR = test_labels[0:PMLR_n_samples, :] decoded = spec_aae.decoder(z_in, dim_img, n_hidden) else: x_PMLR = test_data[0:PMLR_n_samples, :] id_PMLR = test_labels[0:PMLR_n_samples, :] z_in = tf.placeholder(tf.float32, shape=[None, dim_z], name='latent_variable') # train total_batch = int(n_samples / batch_size) min_tot_loss = 1e99 prev_loss = 1e99 saver = tf.train.Saver() with tf.Session() as sess: sess.run(tf.global_variables_initializer(), feed_dict={keep_prob: 0.9}) for epoch in range(n_epochs): # Random shuffling train_data_, train_label_ = shuffle_in_unison_inplace( train_data, train_labels) train_data_sup_, train_labels_sup_ = shuffle_in_unison_inplace( train_data_sup, train_labels_sup) # Loop over all batches for i in range(total_batch): # Compute the offset of the current minibatch in the data. offset = (i * batch_size) % (n_samples) offset_sup = (i * batch_size) % (train_data_sup.shape[0]) batch_xs_input = train_data_[offset:(offset + batch_size), :] batch_ids_input = train_label_[offset:(offset + batch_size), :] batch_xs_sup_input = train_data_sup_[offset_sup:( offset_sup + batch_size), :] batch_ids_sup_input = train_labels_sup_[offset_sup:( offset_sup + batch_size), :] batch_xs_target = batch_xs_input batch_xs_sup_target = batch_xs_sup_input # draw samples from prior distribution if dim_z > 2: if enable_sel: if args.prior_type == 'mixGaussian': z_id_ = np.random.randint(0, nlabels, size=[batch_size]) samples = np.zeros((batch_size, dim_z)) for el in range(dim_z / 2): samples_ = prior.gaussian_mixture( batch_size, 2, n_labels=nlabels, label_indices=z_id_, y_var=(1.0 / nlabels)) samples[:, el * 2:(el + 1) * 2] = samples_ elif args.prior_type == 'swiss_roll': z_id_ = np.random.randint(0, nlabels, size=[batch_size]) samples = np.zeros((batch_size, dim_z)) for el in range(dim_z / 2): samples_ = prior.swiss_roll( batch_size, 2, label_indices=z_id_) samples[:, el * 2:(el + 1) * 2] = samples_ elif args.prior_type == 'normal': samples, z_id_ = prior.gaussian( batch_size, dim_z, n_labels=nlabels, use_label_info=True) else: raise Exception("[!] There is no option for " + args.prior_type) else: z_id_ = np.random.randint(0, nlabels, size=[batch_size]) samples = np.random.normal( 0.0, 1, (batch_size, dim_z)).astype(np.float32) else: if args.prior_type == 'mixGaussian': z_id_ = np.random.randint(0, nlabels, size=[batch_size]) samples = prior.gaussian_mixture(batch_size, dim_z, n_labels=nlabels, label_indices=z_id_, y_var=(1.0 / nlabels)) elif args.prior_type == 'swiss_roll': z_id_ = np.random.randint(0, nlabels, size=[batch_size]) samples = prior.swiss_roll(batch_size, dim_z, label_indices=z_id_) elif args.prior_type == 'normal': samples, z_id_ = prior.gaussian(batch_size, dim_z, n_labels=nlabels, use_label_info=True) else: raise Exception("[!] There is no option for " + args.prior_type) z_id_one_hot_vector = np.zeros((batch_size, nlabels)) z_id_one_hot_vector[np.arange(batch_size), z_id_] = 1 # reconstruction loss _, loss_likelihood0 = sess.run( (train_op_ae, neg_marginal_likelihood), feed_dict={ x_hat: batch_xs_input, x: batch_xs_target, z_sample: samples, cat_sample: z_id_one_hot_vector, keep_prob: 0.9 }) _, loss_likelihood1 = sess.run( (train_op_ae, neg_marginal_likelihood), feed_dict={ x_hat: batch_xs_sup_input, x: batch_xs_sup_target, z_sample: samples, cat_sample: batch_ids_sup_input, keep_prob: 0.9 }) loss_likelihood = loss_likelihood0 + loss_likelihood1 # discriminator loss _, d_loss = sess.run( (train_op_d, D_loss), feed_dict={ x_hat: batch_xs_input, x: batch_xs_target, z_sample: samples, cat_sample: z_id_one_hot_vector, keep_prob: 0.9 }) # generator loss for _ in range(2): _, g_loss = sess.run( (train_op_g, G_loss), feed_dict={ x_hat: batch_xs_input, x: batch_xs_target, z_sample: samples, cat_sample: z_id_one_hot_vector, keep_prob: 0.9 }) # supervised phase _, cat_loss = sess.run( (train_op_cat, cat_gen_loss), feed_dict={ x_hat: batch_xs_sup_input, x: batch_xs_sup_target, x_id: batch_ids_sup_input, keep_prob: 0.9 }) tot_loss = loss_likelihood + d_loss + g_loss + cat_loss # print cost every epoch print( "epoch %d: L_tot %03.2f L_likelihood %03.4f d_loss %03.2f g_loss %03.2f " % (epoch, tot_loss, loss_likelihood, d_loss, g_loss)) #for v in sess.graph.get_operations(): # print(v.name) # if minimum loss is updated or final epoch, plot results if epoch % 2 == 0 or min_tot_loss > tot_loss or epoch + 1 == n_epochs: min_tot_loss = tot_loss # Plot for reproduce performance if PRR: y_PRR = sess.run(y, feed_dict={x_hat: x_PRR, keep_prob: 1}) save_subimages([x_PRR[:10], y_PRR[:10]], "./results/Reco_%02d" % (epoch)) #y_PRR_img = y_PRR.reshape(PRR.n_tot_imgs, tsamples, fsamples) #PRR.save_images(y_PRR_img, name="/PRR_epoch_%02d" %(epoch) + ".jpg") # Plot for manifold learning result if PMLR and dim_z == 2: y_PMLR = sess.run(decoded, feed_dict={ z_in: PMLR.z, keep_prob: 1 }) y_PMLR_img = y_PMLR.reshape(PMLR_n_img_x, PMLR_n_img_x, tsamples, fsamples) save_subimages(y_PMLR_img, "./results/Mani_%02d" % (epoch)) #y_PMLR_img = y_PMLR.reshape(PMLR.n_tot_imgs, fsamples, tsamples) #PMLR.save_images(y_PMLR_img, name="/PMLR_epoch_%02d" % (epoch) + ".jpg") # plot distribution of labeled images z_PMLR = sess.run(z, feed_dict={ x_hat: x_PMLR, keep_prob: 1 }) PMLR.save_scattered_image(z_PMLR, id_PMLR, name="/PMLR_map_epoch_%02d" % (epoch) + ".jpg", N=nlabels) else: retcat, test_cat_loss, test_ll = sess.run( (cat, cat_gen_loss, neg_marginal_likelihood), feed_dict={ x_hat: x_PMLR, x_id: id_PMLR, x: x_PMLR, keep_prob: 1 }) print( "Accuracy: ", 100.0 * np.sum(np.argmax(retcat, 1) == np.argmax(id_PMLR, 1)) / retcat.shape[0], test_cat_loss, test_ll) save_loss = test_cat_loss + test_ll if prev_loss > save_loss and (epoch % 100 == 0): # and epoch!=0: prev_loss = save_loss #save_graph(sess,"./savedmodels/","saved_checkpoint","checkpoint_state","input_graph.pb","output_graph.pb",encoder+"_encoder_cat/zout/BiasAdd,"+encoder+"_encoder_cat/catout/Softmax,CNN_decoder/reshaped/Reshape,discriminator_cat_1/add_2,discriminator_1/add_2") save_path = saver.save( sess, "./savedmodels_allsensors/allsensors.ckpt") tf.train.write_graph(sess.graph_def, "./savedmodels_allsensors/", "allsensors.pb", as_text=False)
def main(args): # torch.manual_seed(222) # torch.cuda.manual_seed_all(222) # np.random.seed(222) device = torch.device('cuda') RESULTS_DIR = args.results_path ADD_NOISE = args.add_noise n_hidden = args.n_hidden dim_img = IMAGE_SIZE_MNIST**2 # number of pixels for a MNIST image dim_z = args.dim_z # train n_epochs = args.num_epochs batch_size = args.batch_size learn_rate = args.learn_rate # Plot PRR = args.PRR # Plot Reproduce Result PRR_n_img_x = args.PRR_n_img_x # number of images along x-axis in a canvas PRR_n_img_y = args.PRR_n_img_y # number of images along y-axis in a canvas PRR_resize_factor = args.PRR_resize_factor # resize factor for each image in a canvas PMLR = args.PMLR # Plot Manifold Learning Result PMLR_n_img_x = args.PMLR_n_img_x # number of images along x-axis in a canvas PMLR_n_img_y = args.PMLR_n_img_y # number of images along y-axis in a canvas PMLR_resize_factor = args.PMLR_resize_factor # resize factor for each image in a canvas PMLR_z_range = args.PMLR_z_range # range for random latent vector PMLR_n_samples = args.PMLR_n_samples # number of labeled samples to plot a map from input data space to the latent space """ prepare MNIST data """ train_total_data, train_size, _, _, test_data, test_labels = mnist_data.prepare_MNIST_data( ) n_samples = train_size """ create network """ keep_prob = 0.99 encoder = vae.Encoder(dim_img, n_hidden, dim_z, keep_prob).to(device) decoder = vae.Decoder(dim_z, n_hidden, dim_img, keep_prob).to(device) # + operator will return but .extend is inplace no return. optimizer = torch.optim.Adam(list(encoder.parameters()) + list(decoder.parameters()), lr=learn_rate) # vae.init_weights(encoder, decoder) """ training """ # Plot for reproduce performance if PRR: PRR = plot_utils.Plot_Reproduce_Performance(RESULTS_DIR, PRR_n_img_x, PRR_n_img_y, IMAGE_SIZE_MNIST, IMAGE_SIZE_MNIST, PRR_resize_factor) x_PRR = test_data[0:PRR.n_tot_imgs, :] x_PRR_img = x_PRR.reshape(PRR.n_tot_imgs, IMAGE_SIZE_MNIST, IMAGE_SIZE_MNIST) PRR.save_images(x_PRR_img, name='input.jpg') print('saved:', 'input.jpg') if ADD_NOISE: x_PRR = x_PRR * np.random.randint(2, size=x_PRR.shape) x_PRR += np.random.randint(2, size=x_PRR.shape) x_PRR_img = x_PRR.reshape(PRR.n_tot_imgs, IMAGE_SIZE_MNIST, IMAGE_SIZE_MNIST) PRR.save_images(x_PRR_img, name='input_noise.jpg') print('saved:', 'input_noise.jpg') x_PRR = torch.from_numpy(x_PRR).float().to(device) # Plot for manifold learning result if PMLR and dim_z == 2: PMLR = plot_utils.Plot_Manifold_Learning_Result( RESULTS_DIR, PMLR_n_img_x, PMLR_n_img_y, IMAGE_SIZE_MNIST, IMAGE_SIZE_MNIST, PMLR_resize_factor, PMLR_z_range) x_PMLR = test_data[0:PMLR_n_samples, :] id_PMLR = test_labels[0:PMLR_n_samples, :] if ADD_NOISE: x_PMLR = x_PMLR * np.random.randint(2, size=x_PMLR.shape) x_PMLR += np.random.randint(2, size=x_PMLR.shape) z_ = torch.from_numpy(PMLR.z).float().to(device) x_PMLR = torch.from_numpy(x_PMLR).float().to(device) # train total_batch = int(n_samples / batch_size) min_tot_loss = np.inf for epoch in range(n_epochs): # Random shuffling np.random.shuffle(train_total_data) train_data_ = train_total_data[:, :-mnist_data.NUM_LABELS] # Loop over all batches encoder.train() decoder.train() for i in range(total_batch): # Compute the offset of the current minibatch in the data. offset = (i * batch_size) % (n_samples) batch_xs_input = train_data_[offset:(offset + batch_size), :] batch_xs_target = batch_xs_input # add salt & pepper noise if ADD_NOISE: batch_xs_input = batch_xs_input * np.random.randint( 2, size=batch_xs_input.shape) batch_xs_input += np.random.randint(2, size=batch_xs_input.shape) batch_xs_input, batch_xs_target = torch.from_numpy(batch_xs_input).float().to(device), \ torch.from_numpy(batch_xs_target).float().to(device) assert not torch.isnan(batch_xs_input).any() assert not torch.isnan(batch_xs_target).any() y, z, tot_loss, loss_likelihood, loss_divergence = \ vae.get_loss(encoder, decoder, batch_xs_input, batch_xs_target) optimizer.zero_grad() tot_loss.backward() optimizer.step() # print cost every epoch print( "epoch %d: L_tot %03.2f L_likelihood %03.2f L_divergence %03.2f" % (epoch, tot_loss.item(), loss_likelihood.item(), loss_divergence.item())) encoder.eval() decoder.eval() # if minimum loss is updated or final epoch, plot results if min_tot_loss > tot_loss.item() or epoch + 1 == n_epochs: min_tot_loss = tot_loss.item() # Plot for reproduce performance if PRR: y_PRR = vae.get_ae(encoder, decoder, x_PRR) y_PRR_img = y_PRR.reshape(PRR.n_tot_imgs, IMAGE_SIZE_MNIST, IMAGE_SIZE_MNIST) PRR.save_images(y_PRR_img.detach().cpu().numpy(), name="/PRR_epoch_%02d" % (epoch) + ".jpg") print('saved:', "/PRR_epoch_%02d" % (epoch) + ".jpg") # Plot for manifold learning result if PMLR and dim_z == 2: y_PMLR = decoder(z_) y_PMLR_img = y_PMLR.reshape(PMLR.n_tot_imgs, IMAGE_SIZE_MNIST, IMAGE_SIZE_MNIST) PMLR.save_images(y_PMLR_img.detach().cpu().numpy(), name="/PMLR_epoch_%02d" % (epoch) + ".jpg") print('saved:', "/PMLR_epoch_%02d" % (epoch) + ".jpg") # plot distribution of labeled images z_PMLR = vae.get_z(encoder, x_PMLR) PMLR.save_scattered_image(z_PMLR.detach().cpu().numpy(), id_PMLR, name="/PMLR_map_epoch_%02d" % (epoch) + ".jpg") print('saved:', "/PMLR_map_epoch_%02d" % (epoch) + ".jpg")
def build_model(self): # some parameters image_dims = [self.input_height, self.input_width, self.c_dim] bs = self.batch_size """ Graph Input """ # images self.inputs = tf.placeholder(tf.float32, [bs] + image_dims, name='real_images') # noises self.z = tf.placeholder(tf.float32, [bs, self.z_dim], name='z') """ Loss Function """ # encoding self.mu, sigma = self.encoder(self.inputs, is_training=True, reuse=False) # sampling by re-parameterization technique z = self.mu + sigma * tf.random_normal(tf.shape(self.mu), 0, 1, dtype=tf.float32) # decoding out = self.decoder(z, is_training=True, reuse=False) self.out = tf.clip_by_value(out, 1e-8, 1 - 1e-8) # loss marginal_likelihood = tf.reduce_sum(self.inputs * tf.log(self.out) + (1 - self.inputs) * tf.log(1 - self.out), [1, 2]) KL_divergence = 0.5 * tf.reduce_sum(tf.square(self.mu) + tf.square(sigma) - tf.log(1e-8 + tf.square(sigma)) - 1, [1]) self.neg_loglikelihood = -tf.reduce_mean(marginal_likelihood) self.KL_divergence = tf.reduce_mean(KL_divergence) ELBO = -self.neg_loglikelihood - self.KL_divergence self.loss = -ELBO """ Training """ # optimizers t_vars = tf.trainable_variables() with tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS)): self.optim = tf.train.AdamOptimizer(self.learning_rate*5, beta1=self.beta1) \ .minimize(self.loss, var_list=t_vars) """" Testing """ # for test self.fake_images = self.decoder(self.z, is_training=False, reuse=True) self.z_in = tf.placeholder(tf.float32, [1, self.z_dim], name='z_in') self.y_out = self.decoder(self.z_in, is_training=False, reuse=True) self.y0 = tf.placeholder(tf.float32, [1, 28, 28, 1], name='y0') self.f = tf.reduce_sum(tf.square(self.y_out - self.y0)) self.gradient = tf.gradients(ys = self.f, xs = self.z_in) """ Summary """ nll_sum = tf.summary.scalar("nll", self.neg_loglikelihood) kl_sum = tf.summary.scalar("kl", self.KL_divergence) loss_sum = tf.summary.scalar("loss", self.loss) # final summary operations self.merged_summary_op = tf.summary.merge_all() # Plot for manifold learning result if self.z_dim == 2: self.PMLR = plot_utils.Plot_Manifold_Learning_Result(self.result_dir, 20, 20, 28, 28, 1.0, 2.0) # saver to save model self.saver = tf.train.Saver(max_to_keep = 1000)