def test(opt): exp_name = opt.exp_name + '/' + os.path.basename( opt.datapath)[:-4] + '_' + opt.exp_id with open(os.path.join(opt.outdir, exp_name, 'config.yml'), 'r') as f: cfg = yaml.load(f) for k, v in cfg.items(): if not hasattr(opt, k): setattr(opt, k, v) real_img = Image.open(opt.datapath).convert('RGB') w, h = real_img.size if w < h: h_resize = min(opt.load_size, h) w_resize = round(w * h_resize / h) else: w_resize = min(opt.load_size, w) h_resize = round(h * w_resize / w) real_img = img2arr(real_img, (w_resize, h_resize)) real_images, nets, _, _ = build_models(real_img, opt, train=False) ckpt_dir = os.path.join(opt.outdir, exp_name, 'checkpoints') test_dir = os.path.join(opt.outdir, exp_name, 'sr_exp') gpu_options = tf.GPUOptions(visible_device_list=str(opt.gpu_id), allow_growth=True) config = tf.ConfigProto(gpu_options=gpu_options) with tf.Session(config=config) as sess: load_scale_ind = -3 load_net = 'ebm{}x{}'.format(real_images[load_scale_ind].shape[1], real_images[load_scale_ind].shape[0]) netE = nets[load_net] saver = tf.train.Saver() saver.restore(sess, os.path.join(ckpt_dir, load_net + '.ckpt')) os.makedirs(test_dir, exist_ok=True) write_image(real_img, os.path.join(test_dir, 'init_scale.png')) num_scales = int(math.log(opt.up_scale, 1. / opt.scale_factor)) cur_img = real_img final_shape = cur_img.shape[1] * opt.up_scale, cur_img.shape[ 0] * opt.up_scale write_image(imresize(real_img, new_shape=final_shape), os.path.join(test_dir, 'bicubic.png')) for scale_ind in range(num_scales): if scale_ind == num_scales - 1: cur_img = imresize(cur_img, new_shape=final_shape) else: cur_img = imresize(cur_img, 1. / opt.scale_factor) cur_img = test_single_scale(sess, netE, cur_img, test_dir, opt) write_image( cur_img, os.path.join( test_dir, 'syn{}x{}.png'.format(cur_img.shape[0], cur_img.shape[1])))
def sample(hps, sess): if hps.label_file is not None: label_list, total_classes = build_label_list_from_file(hps.label_file) if hps.conditional_type != "acgan": label_list = None class_latent_str = input("Enter %d class values (comma separated):" % total_classes) if class_latent_str == "": class_latent_str = "1." + ",0."*(total_classes-1) class_latent = [float(v) for v in class_latent_str.split(",")] tiled_class_latent_batch = [class_latent] * int(hps.batch_size) tiled_class_latent_many = [class_latent] * 10000 else: label_list = None total_classes = 0 tiled_class_latent_batch = None tiled_class_latent_many = None _, mapping_network, _, sampling_model = build_models(hps, hps.current_res_w, use_ema_sampling=True, num_classes=total_classes, label_list=label_list) sample_latent = tf.random_normal([int(hps.batch_size), 512], 0., 1.) if hps.map_cond: sample_latent = tf.concat([sample_latent, tiled_class_latent_batch], axis=-1) many_latent = tf.random_normal([10000, 512], 0., 1) if hps.map_cond: many_latent = tf.concat([many_latent, tiled_class_latent_many], axis=-1) average_w = tf.reduce_mean(mapping_network(many_latent), axis=0) intermediate_w = average_w + hps.psi_w*(mapping_network(sample_latent) - average_w) sample_img = sampling_model(1., intermediate_ws=intermediate_w) restore_models_and_optimizers(sess, None, None, mapping_network, sampling_model, None, None, None, hps.save_paths) return sample_img, intermediate_w
def sample_style_mix(hps, sess, mix_layer): tiled_class_latent_batch = None tiled_class_latent_many = None _, mapping_network, _, sampling_model = build_models(hps, hps.current_res_w, use_ema_sampling=True) sample_latent1 = tf.random_normal([int(hps.batch_size), 512], 0., 1.) if hps.map_cond: sample_latent1 = tf.concat([sample_latent1, tiled_class_latent_batch], axis=-1) sample_latent2 = tf.random_normal([int(hps.batch_size), 512], 0., 1.) if hps.map_cond: sample_latent2 = tf.concat([sample_latent2, tiled_class_latent_batch], axis=-1) many_latent = tf.random_normal([10000, 512], 0., 1) if hps.map_cond: many_latent = tf.concat([many_latent, tiled_class_latent_many], axis=-1) average_w = tf.reduce_mean(mapping_network(many_latent), axis=0) intermediate_w1 = average_w + hps.psi_w*(mapping_network(sample_latent1) - average_w) sample_img1 = sampling_model(1., intermediate_ws=intermediate_w1) intermediate_w2 = mapping_network(sample_latent2) #average_w + hps.psi_w*(mapping_network(sample_latent2) - average_w) sample_img2 = sampling_model(1., intermediate_ws=intermediate_w2) sample_img_mix = sampling_model(1., intermediate_ws=[intermediate_w1, intermediate_w2], crossover_list=[mix_layer]) restore_models_and_optimizers(sess, None, None, mapping_network, sampling_model, None, None, None, hps.save_paths) return [sample_img1, sample_img2, sample_img_mix], [intermediate_w1, intermediate_w2]
def save_sampling_graph(hps, save_paths, graph_dir): _, mapping_network, _, sampling_model = build_models(hps, hps.current_res_w, use_ema_sampling=True, num_classes=0, label_list=None) #sample_latent = tf.placeholder(tf.float32, shape=[1, 512], name="input_latent") # tf.random_normal sample_latent = tf.random_normal([1, 512], 0., 1., name="z") intermediate_w = tf.identity(mapping_network(sample_latent), "w") sample_img_tensor = sampling_model(1., intermediate_ws=intermediate_w) saver = tf.train.Saver() with tf.Session() as sess: alpha = restore_models_and_optimizers_and_alpha( sess, None, None, mapping_network, sampling_model, None, None, None, save_paths) sample_img_tensor = tf.clip_by_value( sample_img_tensor, -1., 1.) # essential due to how tf.summary.image scales values sample_img_tensor = tf.cast((sample_img_tensor + 1) * 127.5, tf.uint8, name="out") #png_tensor = tf.image.encode_png(tf.squeeze(sample_img_tensor, axis=0), name="output") tf.saved_model.simple_save(sess, graph_dir, inputs={'z': sample_latent}, outputs={'out': sample_img_tensor}) """
def sample_with_intermediate(hps_path, intermediate, save_paths): with open(hps_path, "r") as f: hps_dict = json.load(f) hps = TrainHps(**hps_dict) print("******************************") print("Resolution (w): %d, Alpha %.02f" % (hps.current_res_w, 1.0)) print("******************************") # if hps.label_file is not None: # label_list, total_classes = build_label_list_from_file(hps.label_file) # if hps.conditional_type != "acgan": # label_list = None # class_latent_str = input("Enter %d class values (comma separated):" % total_classes) # if class_latent_str == "": # class_latent_str = "1." + ",0."*(total_classes-1) # class_latent = [float(v) for v in class_latent_str.split(",")] # tiled_class_latent_batch = [class_latent] # tiled_class_latent_many = [class_latent] * 10000 # else: # label_list = None # total_classes = 0 # tiled_class_latent_batch = None # tiled_class_latent_many = None _, _, _, sampling_model = build_models(hps, hps.current_res_w, use_ema_sampling=True, num_classes=0, label_list=None) sample_img_tensor = sampling_model(1., intermediate_ws=intermediate) with tf.Session() as sess: alpha = restore_models_and_optimizers_and_alpha( sess, None, None, None, sampling_model, None, None, None, save_paths) sample_img_tensor = tf.clip_by_value( sample_img_tensor, -1., 1.) # essential due to how tf.summary.image scales values sample_img_tensor = tf.cast((sample_img_tensor + 1) * 127.5, tf.uint8) images = sess.run(sample_img_tensor) return images
def predict_images(): """ Detects the drones in the image set given in project's path TO_PREDICT_PATH. """ pred_list = os.listdir(TO_PREDICT_PATH) classifier, regressor = build_models() classifier.load_weights(CLASS_MODEL_PATH) regressor.load_weights(REGRESSOR_MODEL_PATH) (y_resized, x_resized) = UNIFORM_IMG_SIZE IoU_values = [] for image in pred_list: sample_image1 = cv2.imread(TO_PREDICT_PATH + '/' + image) sample_image = sample_image1.astype(np.float32) / 255.0 (y_sample_shape, x_sample_shape, _) = sample_image.shape sample_image_resized = cv2.resize(sample_image, UNIFORM_IMG_SIZE, interpolation=cv2.INTER_CUBIC) x_ratio = x_sample_shape / x_resized y_ratio = y_sample_shape / y_resized anchors_along_x = int((x_resized - FIRST_ANCHOR_X) / ANCHOR_STEP_X) + 1 # On scaled image anchors_along_y = int((y_resized - FIRST_ANCHOR_Y) / ANCHOR_STEP_Y) + 1 Drones = [] Drones_marks = [] boxes = [] iterator = 0 keras_input = [] iterator_max = 100 remaining_anchors = anchors_along_x * anchors_along_y * len(BOX_SCALES) * len(BOX_SIZES) print("Initial remaining anchors to iterate: ", remaining_anchors) for i in range(anchors_along_x): for j in range(anchors_along_y): for boxSize in BOX_SIZES: for boxScale in BOX_SCALES: width = round(boxSize * boxScale) height = round(boxSize / boxScale) anchor_x = FIRST_ANCHOR_X + i * ANCHOR_STEP_X anchor_y = FIRST_ANCHOR_Y + j * ANCHOR_STEP_Y box = cut_on_edges(UNIFORM_IMG_SIZE, [anchor_x - width/2, anchor_x + width/2, anchor_y - height/2, anchor_y + height/2]) boxes.append(box) keras_input.append(cv2.resize(sample_image_resized[box[2]:box[3], box[0]:box[1], 0:3], KERAS_IMG_SIZE, interpolation=cv2.INTER_CUBIC)) iterator += 1 if iterator == min(remaining_anchors, iterator_max): k = 0 classifier_pred = classifier.predict_on_batch(np.array(keras_input)) regressor_pred = regressor.predict_on_batch(np.array(keras_input)) for pred in classifier_pred: if pred[1] >= 0.90: [box_x_min, box_x_max, box_y_min, box_y_max] = boxes[k] box_w = box_x_max - box_x_min box_h = box_y_max - box_y_min [reg_box_x_min, reg_box_x_max, reg_box_y_min, reg_box_y_max] = \ regressor_pred[k] reg_box_x_min *= box_w reg_box_x_max *= box_w reg_box_y_min *= box_h reg_box_y_max *= box_h reg_box_x_min += box_x_min reg_box_x_max += box_x_min reg_box_y_min += box_y_min reg_box_y_max += box_y_min Drones.append([reg_box_x_min, reg_box_x_max, reg_box_y_min, reg_box_y_max]) Drones_marks.append(pred[1]) k += 1 keras_input = [] boxes = [] remaining_anchors -= iterator iterator = 0 print("Remaining anchors to iterate: ", remaining_anchors) Drones = NMS(Drones, Drones_marks, IoU_threshold=0.1) # Draw the predicted rectangles for drone in Drones: drone = [int(drone[0] * x_ratio), int(drone[1] * x_ratio), int(drone[2] * y_ratio), int(drone[3] * y_ratio)] cv2.rectangle(sample_image1, (drone[0], drone[2]), (drone[1], drone[3]), (255, 0, 0), 2) labeled_anchor_boxes = get_label_anchor_box(image) for labeled_anchor_box in labeled_anchor_boxes: cv2.rectangle(sample_image1, (labeled_anchor_box[0], labeled_anchor_box[2]), (labeled_anchor_box[1], labeled_anchor_box[3]), (0, 255, 0), 2) cv2.imwrite(PREDICTED_PATH + '/' + image, sample_image1) # Calculate IoU values for drone in Drones: drone = [int(drone[0] * x_ratio), int(drone[1] * x_ratio), int(drone[2] * y_ratio), int(drone[3] * y_ratio)] current_IoU = [] for labeled_anchor_box in labeled_anchor_boxes: current_IoU.append(calculate_IoU(drone, labeled_anchor_box)) IoU_values.append(max(np.array(current_IoU))) print("Length of Drones: " + str(len(Drones))) print("Next image...") print("Mean IoU value: " + str(mean(np.array(IoU_values)))) print("All images predicted!")