def generate_image( frame, true_dist ): # generates a batch of samples next to each other in one image! # test: generate some samples samples = session.run(fixed_noise_samples, feed_dict={real_data: fixed_data }) # [-1,1] ### for MNIST # (50, 784) samples_255 = ((samples + 1.) * (255. / 2)).astype('int32') # [0,255] samples_01 = ((samples + 1.) / 2.).astype('float32') # [0,1] imsaver.save_images(samples_255.reshape((BATCH_SIZE, IM_DIM, IM_DIM)), 'samples_{}.png'.format(frame)) ### for MNIST print("Iteration %d : \n" % frame) # compare generated to real ones real = tf.reshape(fixed_data, [BATCH_SIZE, IM_DIM, IM_DIM, 1]) ### for MNIST # real_gray = tf.image.rgb_to_grayscale(real) # tensor batch in&out returns original dtype = float [0,1] ### for MNIST pred = tf.reshape(samples_01, [BATCH_SIZE, IM_DIM, IM_DIM, 1]) ### for MNIST # pred_gray = tf.image.rgb_to_grayscale(pred) ### for MNIST ssimval = tf.image.ssim( real, pred, max_val=1.0 ) # in tensor batch, out tensor ssimvals (64,) ### for MNIST mseval_per_entry = tf.keras.metrics.mse( real, pred) # mse on grayscale, on [0,1] ### for MNIST mseval = tf.reduce_mean(mseval_per_entry, [1, 2]) ### for MNIST # ssimvals 0.2 to 0.75 :) # msevals 1-9 e -1 to -3 ssimval_list = ssimval.eval() # to numpy array # (64,) # (50,) mseval_list = mseval.eval() # (64,) # (50,) # print(ssimval_list) # print(mseval_list) for i in range(0, 3): plotter.plot('SSIM for sample %d' % (i + 1), ssimval_list[i]) plotter.plot('MSE for sample %d' % (i + 1), mseval_list[i]) print("sample %d \t MSE: %.5f \t SSIM: %.5f \r\n" % (i, mseval_list[i], ssimval_list[i]))
def generate_image( frame, true_dist ): # test: generates a batch of samples next to each other in one image! samples = session.run(fixed_noise_samples) # [-1,1] samples_255 = ((samples + 1.) * (255. / 2)).astype('int32') # [0,255] imsaver.save_images(samples_255.reshape((BATCH_SIZE, IM_DIM, IM_DIM)), 'samples_{}.png'.format(frame))
def generate_image(iteration): samples = session.run(all_fixed_noise_samples) samples = binarize(samples) #samples = ((samples+1.)*(255.99/2)).astype('int32') save_images.save_images( samples.reshape((BATCH_SIZE, NUM_NEURONS, NUM_BINS)), FOLDER + 'samples_{}.png'.format(iteration))
def generate_image(frame, true_dist): # generates a batch of samples next to each other in one image! samples = session.run(fixed_noise_samples, feed_dict={real_data: fixed_real_data, condition_data: fixed_labels}) # [-1,1] #for im in samples: # add a image for the samples # tf.summary.image("{}-image".format(grad.name.replace(":","_")), im) samples_255 = ((samples+1.)*(255./2)).astype('int32') # [0,255] samples_01 = ((samples+1.)/2.).astype('float32') # [0,1] for i in range(0, BATCH_SIZE): samples_255 = np.insert(samples_255, i*2, fixed_real_data_255[i,:], axis=0) # show cond digit next to generated sample imsaver.save_images(samples_255.reshape((2*BATCH_SIZE, 1, IM_DIM, IM_DIM)), 'samples_{}.jpg'.format(frame)) print("Iteration %d : \n" % frame) # compare generated to real one real = tf.reshape(fixed_real_data, [BATCH_SIZE,IM_DIM,IM_DIM,1]) pred = tf.reshape(samples_01, [BATCH_SIZE,IM_DIM,IM_DIM,1]) ssimval = tf.image.ssim(real, pred, max_val=1.0) # tensor batch in, out tensor of ssimvals (64,) mseval_per_entry = tf.keras.metrics.mse(real, pred) # mse on grayscale, on [0,1] mseval = tf.reduce_mean(mseval_per_entry, [1,2]) tf.summary.tensor_summary("SSIM values", ssimval) tf.summary.tensor_summary("MSE values", mseval) ssimval_list = ssimval.eval() # to numpy array # (50,) mseval_list = mseval.eval() # (50,) # print(ssimval_list) # print(mseval_list) for i in range (0,3): plotter.plot('SSIM for sample %d' % (i+1), ssimval_list[i]) plotter.plot('MSE for sample %d' % (i+1), mseval_list[i]) print("sample %d \t MSE: %.5f \t SSIM: %.5f \r\n" % (i, mseval_list[i], ssimval_list[i]))
def generate_image( frame, final ): # generates a batch of samples next to each other in one image! samples = session.run(fixed_noise_samples, feed_dict={ condition_data: fixed_cond_data, time_data: fixed_time_data }) # [0,1] samples_255 = ((samples) * 255.99).astype('uint8') # [0,1] -> [0,255] #print(samples.min()) #print(samples.max()) # add ground truth for i in range(0, BATCH_SIZE): samples_255 = np.insert(samples_255, i * 4, fixed_cond_2_data_255[i, :], axis=0) # cond_time left of sample samples_255 = np.insert(samples_255, i * 4 + 1, fixed_cond_data_255[i, :], axis=0) # cond left of sample samples_255 = np.insert(samples_255, i * 4 + 3, fixed_real_data_255[i, :], axis=0) # real right of sample imsaver.save_images(samples_255.reshape((4 * BATCH_SIZE, IM_DIM, IM_DIM)), 'samples_{}.jpg'.format(frame), alternate_viz=True, conds=True, gt=True, time=True) print("Iteration %d :" % frame) # compare generated to real one real = tf.reshape(fixed_cond_data, [BATCH_SIZE, IM_DIM, IM_DIM, 1]) pred = tf.reshape(samples, [BATCH_SIZE, IM_DIM, IM_DIM, 1]) ssim_vals = tf.image.ssim(real, pred, max_val=1.0) # on batch mse_vals = tf.reduce_mean(tf.keras.metrics.mse(real, pred), [1, 2]) # mse on grayscale, on [0,1] psnr_vals = tf.image.psnr(real, pred, max_val=1.0) # on batch, out tf.float32 ssim_avg = (tf.reduce_mean(ssim_vals)).eval() mse_avg = (tf.reduce_mean(mse_vals)).eval() psnr_avg = (tf.reduce_mean(psnr_vals)).eval() plotter.plot( 'SSIM avg', ssim_avg) # show average of ssim and mse vals over whole batch plotter.plot('MSE avg', mse_avg) plotter.plot('PSNR avg', psnr_avg) if (final): print('final iteration %d SSIM avg: %.2f MSE avg: %.2f' % (iteration, ssim_avg, mse_avg)) ssim_vals_list = ssim_vals.eval() mse_vals_list = mse_vals.eval() psnr_vals_list = psnr_vals.eval() print(ssim_vals_list) # save it in nohup.out print(mse_vals_list) print(psnr_vals_list)
def make_batch(imarr, save_fn, n=128): ims = imarr[:n] print(ims.shape) ims.reshape((n, 96, 96, -1)) #ims = ims.transpose(0, 3, 1, 2) ims = np.array([normalize(im) for im in ims]) print(ims.shape) #ims = np.flip(ims, 3) saver.save_images(ims, save_fn, luptonize=False, unnormalize=False)
def generate_image( frame, true_dist ): # generates a batch of samples next to each other in one image! # test: generate some samples samples = session.run(fixed_noise_samples, feed_dict={real_data_int: fixed_real_data_int}) # [-1,1] samples_255 = ((samples + 1.) * (255. / 2)).astype('int32') # [0,255] imsaver.save_images(samples_255.reshape((BATCH_SIZE, 3, IM_DIM, IM_DIM)), 'samples_{}.png'.format(frame)) ### for MNIST
def generate_image(frame, netG): fixed_noise_128 = torch.randn(128, 128) if use_cuda: fixed_noise_128 = fixed_noise_128.cuda(gpu) noisev = autograd.Variable(fixed_noise_128, volatile=True) samples = netG(noisev) samples = samples.view(-1, 3, 32, 32) samples = samples.mul(0.5).add(0.5) samples = samples.cpu().data.numpy() save_images.save_images(samples, './tmp/cifar10/samples_{}.jpg'.format(frame))
def generate_image(i, save, save_dir, random=False): if random == True: random_noise_z = tf.constant( np.random.normal(size=(args.z, args.z)).astype('float32')) random_noise_samples_z = G(args.z, DIM, OUTPUT_DIM, args.z, noise=random_noise_z) samples = session.run(random_noise_samples_z) else: samples = session.run(fixed_noise_samples_z) samples = ((samples + 1.) * (255. / 2)).astype('int32') save_images(samples.reshape((args.z, 3, 32, 32)), 'samples_{}'.format(i), args.save_dir)
def generate_image(frame, netG): noise = torch.randn(BATCH_SIZE, LATENT_DIM) if use_cuda: noise = noise.cuda(gpu) noisev = autograd.Variable(noise, volatile=True) ones = torch.ones(BATCH_SIZE, 28 * 28, 1) if use_cuda: ones = ones.cuda() seed = torch.bmm(ones, noisev.unsqueeze(1)) samples = netG(x, y, r, seed) samples = samples.view(BATCH_SIZE, 28, 28) # print samples.size() samples = samples.cpu().data.numpy() save_images.save_images(samples, 'tmp/mnist/samples_{}.png'.format(frame))
def generate_image(frame, final): # generates a batch of samples next to each other in one image! inference_start_time = time.time() # inference time analysis if(MODE == 'cond' or MODE == 'enc'): samples = session.run(fixed_noise_samples, feed_dict={condition_data: fixed_cond_data}) # [0,1] elif(MODE == 'plain'): samples = session.run(fixed_noise_samples) # [0,1] elif(MODE == 'vae'): samples = session.run(fixed_noise_samples, feed_dict={real_data: fixed_cond_data}) # [0,1] samples_noise = session.run(_noise_samples, feed_dict={real_data: fixed_cond_data}) # [0,1] noise_samples_255 = ((samples_noise)*255.).astype('uint8') # [0, 1] -> [0,255] inference_end_time = time.time() # inference time analysis inference_time = (inference_end_time - inference_start_time) print("The architecture took ", inference_time, "sec for the generation of ", BATCH_SIZE, "images") samples_255 = ((samples)*255.).astype('uint8') # [0, 1] -> [0,255] # print('samples 255') # print(samples_255.min()) # print(samples_255.max()) if(MODE == 'plain'): imsaver.save_images(samples_255.reshape((BATCH_SIZE, IM_DIM, IM_DIM)), 'samples_{}.jpg'.format(frame), alternate_viz=True) elif(MODE == 'vae'): for i in range(0, BATCH_SIZE): samples_255 = np.insert(samples_255, i*2, fixed_cond_data_255[i,:], axis=0) # real (cond digit) next to sample imsaver.save_images(samples_255.reshape((2*BATCH_SIZE, IM_DIM, IM_DIM)), 'samples_{}.jpg'.format(frame), alternate_viz=True, conds=True) imsaver.save_images(noise_samples_255.reshape((BATCH_SIZE, IM_DIM, IM_DIM)), 'noise_samples_{}.jpg'.format(frame), alternate_viz=True) else: # if(MODE == 'enc' or MODE == 'cond') add ground truth for i in range(0, BATCH_SIZE): samples_255 = np.insert(samples_255, i*3, fixed_cond_data_255[i,:], axis=0) # cond left of sample samples_255 = np.insert(samples_255, i*3+2, fixed_real_data_255[i,:], axis=0) # real right of sample imsaver.save_images(samples_255.reshape((3*BATCH_SIZE, IM_DIM, IM_DIM)), 'samples_{}.jpg'.format(frame), alternate_viz=True, conds=True, gt=True) print("Iteration %d :" % frame) # compare generated to real one real = tf.reshape(fixed_cond_data, [BATCH_SIZE,IM_DIM,IM_DIM,1]) pred = tf.reshape(samples, [BATCH_SIZE,IM_DIM,IM_DIM,1]) ssim_vals = tf.image.ssim(real, pred, max_val=1.0) # on batch mse_vals = tf.reduce_mean(tf.keras.metrics.mse(real, pred), [1,2]) # mse on grayscale, on [0,1] psnr_vals = tf.image.psnr(real, pred, max_val=1.0) # on batch, out tf.float32 ssim_avg = (tf.reduce_mean(ssim_vals)).eval() mse_avg = (tf.reduce_mean(mse_vals)).eval() psnr_avg = (tf.reduce_mean(psnr_vals)).eval() plotter.plot('SSIM avg', ssim_avg) # show average of ssim and mse vals over whole batch plotter.plot('MSE avg', mse_avg) plotter.plot('PSNR avg', psnr_avg) if(final): print('final iteration %d SSIM avg: %.2f MSE avg: %.2f' % (iteration, ssim_avg, mse_avg)) ssim_vals_list = ssim_vals.eval() mse_vals_list = mse_vals.eval() psnr_vals_list = psnr_vals.eval() print(ssim_vals_list) # save it in nohup.out print(mse_vals_list) print(psnr_vals_list)
def generate_image( frame, true_dist ): # generates a batch of samples next to each other in one image! samples = session.run(fixed_noise_samples, feed_dict={ real_data_int: fixed_real_data_int, cond_data_int: fixed_cond_data_int }) # [-1,1] samples_255 = ((samples + 1.) * (255. / 2)).astype('int32') # [0,255] samples_01 = ((samples + 1.) / 2.).astype('float32') # [0,1] for i in range(0, BATCH_SIZE): samples_255 = np.insert( samples_255, i * 2, fixed_cond_data_int[i], axis=0) # show last frame next to generated sample imsaver.save_images( samples_255.reshape((2 * BATCH_SIZE, 3, IM_DIM, IM_DIM)), 'samples_{}.jpg'.format(frame)) print("Iteration %d : \n" % frame) # compare generated to real one real = tf.reshape(fixed_real_data_norm01, [BATCH_SIZE, IM_DIM, IM_DIM, 3]) real_gray = tf.image.rgb_to_grayscale( real) # tensor batch in&out; returns original dtype = float [0,1] pred = tf.reshape(samples_01, [BATCH_SIZE, IM_DIM, IM_DIM, 3]) pred_gray = tf.image.rgb_to_grayscale(pred) ssimval = tf.image.ssim( real_gray, pred_gray, max_val=1.0) # tensor batch in, out tensor of ssimvals (64,) mseval_per_entry = tf.keras.metrics.mse( real_gray, pred_gray) # mse on grayscale, on [0,1] mseval = tf.reduce_mean(mseval_per_entry, [1, 2]) # ssimvals 0.2 to 0.75 :) # msevals 1-9 e -1 to -3 ssimval_list = ssimval.eval() # to numpy array # (64,) mseval_list = mseval.eval() # (64,) #print(ssimval_list) # print(mseval_list) for i in range(0, 3): plotter.plot('SSIM for sample %d' % (i + 1), ssimval_list[i]) plotter.plot('MSE for sample %d' % (i + 1), mseval_list[i]) print("sample %d \t MSE: %.5f \t SSIM: %.5f \r\n" % (i, mseval_list[i], ssimval_list[i]))
def evaluate_inference_via_optimization(n_samples): np.random.seed(1) tf.set_random_seed(1) samples = Generator(n_samples) session = tf.Session() session.run(tf.global_variables_initializer()) saver = tf.train.Saver() saver.restore(session, MAIN_DIR + 'models/' + MODE + '_final.ckpt') gen = inf_train_gen() data = gen.next() data = 2 * ((data / 255.) - .5) sample_z_dim = 128 z_var = tf.get_variable("z_var", shape=[n_samples, sample_z_dim], dtype=tf.float32, trainable=False) z_var_pl = tf.placeholder(dtype=tf.float32, shape=[n_samples, sample_z_dim], name="z_var_placeholder") z_var_assign = tf.assign(z_var, z_var_pl, name="z_var_assign") targets = data[np.random.randint(data.shape[0], size=n_samples)] g_loss = tf.nn.l2_loss(samples - targets) a = (samples + 1.) / 2. b = (targets + 1.) / 2. mse = ((a - b)**2) mse_2d = tf.reshape(mse, [n_samples, 32 * 32 * 3]) mse = tf.reduce_mean(mse_2d, axis=1, keep_dims=True) optimizer = tf.contrib.opt.ScipyOptimizerInterface(loss=g_loss, var_list=[z_var], method='L-BFGS-B', options={ 'maxiter': 5, 'disp': False }) # run the optimization from 3 different initializations results_images = [] results_errors = [] num_of_random_restarts = 3 for i in xrange(num_of_random_restarts): z_sample = np.random.normal(0, 1, size=(n_samples, sample_z_dim)) session.run(z_var_assign, {z_var_pl: z_sample}) optimizer.minimize(session) generated_samples = session.run(samples) generated_samples_mse = session.run(mse) results_images.append(generated_samples) results_errors.append(generated_samples_mse) # select the best out of all random restarts best_images = np.zeros_like(results_images[0]) best_images_errors = np.zeros_like(results_errors[0]) for image_index in xrange(n_samples): best_img = results_images[0][image_index] best_img_error = results_errors[0][image_index][0] for indep_run_index in xrange(1, num_of_random_restarts): if best_img_error > results_errors[indep_run_index][image_index][0]: best_img_error = results_errors[indep_run_index][image_index][ 0] best_img = results_images[indep_run_index][image_index] best_images[image_index] = best_img best_images_errors[image_index][0] = best_img_error best_images_errors_i = np.array(best_images_errors) best_images_errors = np.zeros((0, 1), dtype=np.float32) for i in xrange(1): best_images_errors = np.vstack( (best_images_errors, best_images_errors_i)) if not os.path.exists('/home/elfeki/Desktop/samples'): os.makedirs('/home/elfeki/Desktop/samples') sampled = (np.array(best_images[:BATCH_SIZE]).reshape(-1, 3, 32, 32) + 1) / 2. targeted = (np.array(targets[:BATCH_SIZE]).reshape(-1, 3, 32, 32) + 1) / 2. print sampled.shape, targeted.shape save_images(sampled, '/home/elfeki/Desktop/samples/sampled.jpg') save_images(targeted, '/home/elfeki/Desktop/samples/targeted.jpg') print('Evaluation Inference Via Optimization: {:.5f} +/- {:.5f}'.format( np.mean(best_images_errors), np.std(best_images_errors)))
def generate_image(session, frame, fixed_noise_samples_128): samples = session.run(fixed_noise_samples_128) samples = ((samples + 1.) * (255. / 2)).astype('int32') save_images( samples.reshape((128, 3, 32, 32))[:], MAIN_DIR + '/generated_images/' + MODE + '/samples_{}.jpg'.format(frame))
(BATCH_SIZE, output_dim)) # current frame # (50, 1024) fixed_cond_data = (fixed_data[:, 4, :]).reshape( (BATCH_SIZE, output_dim)) # only 1 last frame for now # (50, 1024) fixed_cond_2_data = (fixed_data[:, 3, :]).reshape( (BATCH_SIZE, output_dim)) # only 1 last frame for now # (50, 1024) fixed_time_data = ( fixed_data[:, (5 - TIMESTEPS):5, :] ) #.reshape((BATCH_SIZE, TIMESTEPS, output_dim)) # current frame # (50, 5, 1024) fixed_real_data_255 = ((fixed_real_data) * 255.).astype('uint8') # [0,255] fixed_cond_data_255 = ((fixed_cond_data) * 255.).astype('uint8') # [0,255] fixed_cond_2_data_255 = ((fixed_cond_2_data) * 255.).astype('uint8') # [0,255] fixed_real_data_gt = np.copy(fixed_real_data_255) fixed_cond_data_gt = np.copy(fixed_cond_data_255) fixed_cond_2_data_gt = np.copy(fixed_cond_2_data_255) imsaver.save_images(fixed_real_data_gt.reshape((BATCH_SIZE, IM_DIM, IM_DIM)), 'groundtruth_reals_grey.jpg', alternate_viz=True) imsaver.save_images(fixed_cond_data_gt.reshape((BATCH_SIZE, IM_DIM, IM_DIM)), 'groundtruth_conds_grey.jpg', alternate_viz=True) imsaver.save_images(fixed_cond_2_data_gt.reshape((BATCH_SIZE, IM_DIM, IM_DIM)), 'groundtruth_conds_2_grey.jpg', alternate_viz=True) if (START_ITER > 0): # get noise from saved model: variable, implicit float fixed_noise = tf.get_variable("noise", shape=[BATCH_SIZE, NOISE_DIM]) else: fixed_noise = tf.Variable(tf.random_normal(shape=[BATCH_SIZE, NOISE_DIM]), name='noise') if (TIMESTEPS == 2):
def generate_image( frame, final ): # generates a batch of samples next to each other in one image! inference_start_time = time.time() if (MODE == 'cond_ordered'): samples = session.run(fixed_noise_samples, feed_dict={condition_data: fixed_labels_array}) # [0,1] elif (MODE == 'cond'): samples = session.run(fixed_noise_samples, feed_dict={condition_data: sorted_labels}) # [0,1] elif (MODE == 'plain'): samples = session.run(fixed_noise_samples) # [0,1] else: samples = session.run(fixed_noise_samples, feed_dict={real_data: sorted_data}) # [0,1] inference_end_time = time.time() # inference time analysis inference_time = (inference_end_time - inference_start_time) print("The architecture took ", inference_time, "sec for the generation of ", BATCH_SIZE, "images") samples_255 = ((samples) * (255.)).astype('uint8') # [0,255] if (MODE == 'enc' or MODE == 'vae' or MODE == 'cond'): for i in range(0, BATCH_SIZE): samples_255 = np.insert(samples_255, i * 2, fixed_data_255[i, :], axis=0) # real (cond digit) next to sample imsaver.save_images(samples_255.reshape( (2 * BATCH_SIZE, IM_DIM, IM_DIM)), 'samples_{}.jpg'.format(frame), alternate_viz=True, conds=True) print("Iteration %d :" % frame) # compare generated to real one real = tf.reshape(sorted_data, [BATCH_SIZE, IM_DIM, IM_DIM, 1]) pred = tf.reshape(samples, [BATCH_SIZE, IM_DIM, IM_DIM, 1]) ssim_vals = tf.image.ssim(real, pred, max_val=1.0) # on batch mse_vals = tf.reduce_mean(tf.keras.metrics.mse(real, pred), [1, 2]) # mse on grayscale, on [0,1] psnr_vals = tf.image.psnr(real, pred, max_val=1.0) # on batch, out tf.float32 ssim_avg = (tf.reduce_mean(ssim_vals)).eval() mse_avg = (tf.reduce_mean(mse_vals)).eval() psnr_avg = (tf.reduce_mean(psnr_vals)).eval() plotter.plot( 'SSIM avg', ssim_avg) # show average of ssim and mse vals over whole batch plotter.plot('MSE avg', mse_avg) plotter.plot('PSNR avg', psnr_avg) if (final): print('final iteration %d SSIM avg: %.2f MSE avg: %.2f' % (iteration, ssim_avg, mse_avg)) ssim_vals_list = ssim_vals.eval() mse_vals_list = mse_vals.eval() psnr_vals_list = psnr_vals.eval() print(ssim_vals_list) # save it in nohup.out print(mse_vals_list) print(psnr_vals_list) else: imsaver.save_images(samples_255.reshape( (BATCH_SIZE, IM_DIM, IM_DIM)), 'samples_{}.jpg'.format(frame)) # , alternate_viz=True) if (MODE == 'vae'): noise_samples = session.run(more_noise_samples) # [0,1] noise_samples_255 = ((noise_samples) * (255.)).astype( 'uint8') # [0,255] imsaver.save_images( noise_samples_255.reshape((BATCH_SIZE, IM_DIM, IM_DIM)), 'noise_samples_{}.jpg'.format(frame)) # , alternate_viz=True) if (final): # calculate accuracy of samples (mnist classificator) if (MODE == 'cond_ordered'): _fixed_labels = np.zeros((fixed_labels_array.size, N_LABELS)) _fixed_labels[np.arange(fixed_labels_array.size), fixed_labels_array] = 1 # np to one-hot else: _fixed_labels = np.zeros((sorted_labels.size, N_LABELS)) _fixed_labels[np.arange(sorted_labels.size), sorted_labels] = 1 # np to one-hot accu = session.run(accuracy, feed_dict={x: samples, y: _fixed_labels}) print('Accuracy at step %d: %s' % (iteration, accu))
BATCH_SIZE = 10 # Batch size TARGET_SIZE = 300 OUT_DIM_FLOW = TARGET_SIZE * TARGET_SIZE * 2 gen = sintel.load_train_gen(BATCH_SIZE, (TARGET_SIZE, TARGET_SIZE, 3), (TARGET_SIZE, TARGET_SIZE, 2)) _data, _flow = next(gen) # images: (n, 6144) -- 3072 + 3072 + 3072 = three images for 32 # flows: (n, 4096) -- 2048 + 2048 = two flows for 32 outpath = "/home/linkermann/Desktop/MA/opticalFlow/opticalFlowGAN/data/gentest/" flows = _flow[0] # first from batch flow1 = flows[0:OUT_DIM_FLOW] # (2048,) for 32 flow2 = flows[OUT_DIM_FLOW:] # (2048,) for 32 flow1 = flow1.reshape(TARGET_SIZE, TARGET_SIZE, 2) flow2 = flow2.reshape(TARGET_SIZE, TARGET_SIZE, 2) # save flow # write_flo_file(flow, filename) # filename must be string and end in .flo. Flow must be in (w,h,2) format # fh.write_flo_file(flow1, outpath+'sample_sintel_flow.flo') # load flow from file # read_flo_file(filename) # flowfile = fh.read_flo_file(outpath+"sample_sintel_flow.flo") # show flow # computeImg(flow) flowimg = fh.computeFlowImg(flow1) # (200, 200, 3) # now color img!! :) flowimage_T = np.transpose(flowimg, [2, 0, 1]) # (3, 200, 200) save_images(flowimage_T.reshape((1, 3, TARGET_SIZE, TARGET_SIZE)), outpath + "flowsintel10.jpg")
def interpolate(state_dict, generator, preview=True, interpolate=False, large_sample=False, img_size=28, img_channel=1, large_dim=1024, samples=[ random.randint(0, args.bsize - 1), random.randint(0, args.bsize - 1) ]): """ Args: state_dict: saved copy of trained params generator: generator model preview: show preview of images in grid form in original size (to pick which to blow up) interpolate: create interpolation gif large_sample: create a large sample of an individual picture img_size: size of your input samples, e.g. 28 for MNIST img_channel: number of color channels, 3 for cifar large_dim: dimension to blow up samples to for interpolation samples: indices of the samples you want to interpolate """ x_d = img_size y_d = img_size c_d = img_channel #position = 2 x, y, r = mnist.get_coordinates(x_d, y_d, batch_size=args.bsize) x_large = large_dim y_large = large_dim generator_int = generator generator_int.load_state_dict( torch.load(state_dict, map_location=lambda storage, loc: storage)) noise = torch.randn(args.bsize, args.latdim) if preview: noise = noise.to(device) noisev = autograd.Variable(noise, volatile=True) ones = torch.ones(args.bsize, x_d * y_d, c_d) ones = ones.to(device) seed = torch.bmm(ones, noisev.unsqueeze(1)) gen_imgs = generator_int(x, y, r, seed) gen_imgs = gen_imgs.cpu().data.numpy() save_images.save_images(gen_imgs, 'generated_img/samples.png') if large_sample >= 0: assert args.sample < args.bsize, "Sample position is out of bounds" noise = noise.to(device) noisev = autograd.Variable(noise[large_sample], volatile=True) ones = torch.ones(1, x_large * y_large, 1).to(device) seed = torch.bmm(ones, noisev.unsqueeze(0).unsqueeze(0)) x, y, r = mnist.get_coordinates(x_large, y_large, batch_size=1) gen_imgs = generator_int(x, y, r, seed) gen_imgs = gen_imgs.cpu().data.numpy() save_images.save_images(gen_imgs, 'generated_img/large_sample.png') if interpolate: nbSteps = args.frames alphaValues = np.linspace(0, 1, nbSteps) images = [] noise = noise.to(device) noisev = autograd.Variable(noise[samples[0]], volatile=True) ones = torch.ones(1, x_large * y_large, 1).to(device) seed = torch.bmm(ones, noisev.unsqueeze(0).unsqueeze(0)) x, y, r = mnist.get_coordinates(x_large, y_large, batch_size=1) samples.append(samples[0]) for i in range(len(samples) - 1): for alpha in alphaValues: vector = noise[samples[i]].unsqueeze(0) * ( 1 - alpha) + noise[samples[i + 1]].unsqueeze(0) * alpha gen_imgs = generator_int(x, y, r, vector) if c_d == 3: gen_img_np = np.transpose(gen_imgs.data[0].numpy()) elif c_d == 1: gen_img_np = np.transpose(gen_imgs.data.numpy()).reshape( x_large, y_large, -1) images.append(gen_img_np) imageio.mimsave('generated_img/movie.gif', images)
import numpy as np import sys sys.path.append('/home/linkermann/Desktop/MA/opticalFlow/opticalFlowGAN') import tflib as lib from tflib.save_images import save_images #import tflib.SINTELdata as sintel import tflib.flow_handler as fh BATCH_SIZE = 10 # Batch size TARGET_SIZE = 300 OUT_DIM_FLOW = TARGET_SIZE*TARGET_SIZE*2 outpath = "/home/linkermann/Desktop/MA/opticalFlow/opticalFlowGAN/data/gentest/" flow = np.zeros((TARGET_SIZE,TARGET_SIZE,2)) flow[:,:,0] = ... flow[:,:,1] = ... # show flow # computeImg(flow) flowimg = fh.computeFlowImg(flow) # (TARGET_SIZE, TARGET_SIZE, 3) # now color img!! :) flowimage_T = np.transpose(flowimg, [2,0,1]) # (3, TARGET_SIZE, TARGET_SIZE) save_images(flowimage_T.reshape((1,3,TARGET_SIZE,TARGET_SIZE)), outpath+"flowfieldviz.jpg")
# Dataset iterator train_gen, dev_gen = sim_pop_activity.load(num_samples=NUM_SAMPLES, batch_size=BATCH_SIZE, dim=NUM_BINS,\ num_neurons=NUM_NEURONS, corr=CORR, group_size=GROUP_SIZE, refr_per=REFR_PER) def inf_train_gen(): while True: for (images, ) in train_gen(): yield images # Save a batch of ground-truth samples _x = next(inf_train_gen()) _x_r = session.run(real_data, feed_dict={real_data: _x}) _x_r = binarize(_x_r) #_x_r = ((_x_r+1.)*(255.99/2)).astype('int32') save_images.save_images(_x_r.reshape((BATCH_SIZE, NUM_NEURONS, NUM_BINS)), FOLDER + 'samples_groundtruth.png') #try to load trained parameters load() # Train loop session.run(tf.global_variables_initializer()) gen = inf_train_gen() start_time = time.time() for iteration in range(ITERS): # Train generator if iteration > 0: _ = session.run(gen_train_op) # Train critic disc_iters = CRITIC_ITERS