def __init__(self): super(CollectOutputAndTarget, self).__init__() self.inputs = [] # collect x_input batches self.targets = [] # collect y_true batches self.outputs = [] # collect y_pred batches # the shape of these 2 variables will change according to batch shape # to handle the "last batch", specify `validate_shape=False` self.var_x_input = tf.Variable(0., validate_shape=False) self.var_y_true = tf.Variable(0., validate_shape=False) self.var_y_pred = tf.Variable(0., validate_shape=False) self.train_plotObj = Plot('train', title='Train Predictions')
def __init__(self, config, num_agents, num_landmarks, folder_dir): super(GameModule, self).__init__() self.batch_size = config.batch_size # scalar: num games in this batch self.using_utterances = config.use_utterances # bool: whether current batch allows utterances self.using_cuda = config.use_cuda self.num_agents = num_agents # scalar: number of agents in this batch self.num_landmarks = num_landmarks # scalar: number of landmarks in this batch self.num_entities = self.num_agents + self.num_landmarks # type: int self.world_dim = config.world_dim self.time_horizon = config.time_horizon self.num_epochs = config.num_epochs self.folder_dir = folder_dir if self.using_cuda: self.Tensor = torch.cuda.FloatTensor else: self.Tensor = torch.FloatTensor locations = torch.rand(self.batch_size, self.num_entities, 2) * config.world_dim self.colors = (torch.rand(self.batch_size, self.num_entities, 1) * config.num_colors).floor() self.shapes = (torch.rand(self.batch_size, self.num_entities, 1) * config.num_shapes).floor() goal_agents = self.Tensor(self.batch_size, self.num_agents, 1) goal_entities = (torch.rand(self.batch_size, self.num_agents, 1) * self.num_landmarks).floor().long() + self.num_agents goal_locations = self.Tensor(self.batch_size, self.num_agents, 2) if self.using_cuda: locations = locations.cuda() self.colors = self.colors.cuda() self.shapes = self.shapes.cuda() goal_entities = goal_entities.cuda() # [batch_size, num_entities, 2] self.locations = Variable(locations) # [batch_size, num_entities, 2] self.physical = Variable( torch.cat((self.colors, self.shapes), 2).float()) for b in range(self.batch_size): goal_agents[b, :, 0] = torch.randperm(self.num_agents) for b in range(self.batch_size): goal_locations[b] = self.locations.data[b][ goal_entities[b].squeeze()] # [batch_size, num_agents, 3] self.goals = Variable(torch.cat((goal_locations, goal_agents), 2)) goal_agents = Variable(goal_agents) if self.using_cuda: self.memories = { "physical": Variable( torch.zeros(self.batch_size, self.num_agents, self.num_entities, config.memory_size).cuda()), "action": Variable( torch.zeros(self.batch_size, self.num_agents, config.memory_size).cuda()) } else: self.memories = { "physical": Variable( torch.zeros(self.batch_size, self.num_agents, self.num_entities, config.memory_size)), "action": Variable( torch.zeros(self.batch_size, self.num_agents, config.memory_size)) } if self.using_utterances: if self.using_cuda: self.utterances = Variable( torch.zeros(self.batch_size, self.num_agents, config.vocab_size).cuda()) self.memories["utterance"] = Variable( torch.zeros(self.batch_size, self.num_agents, self.num_agents, config.memory_size).cuda()) else: self.utterances = Variable( torch.zeros(self.batch_size, self.num_agents, config.vocab_size)) self.memories["utterance"] = Variable( torch.zeros(self.batch_size, self.num_agents, self.num_agents, config.memory_size)) agent_baselines = self.locations[:, :self.num_agents, :] goals_by_landmark = torch.cat( (goal_entities.type(torch.FloatTensor), goal_agents), 2).float() sort_idxs = torch.sort(self.goals[:, :, 2])[1] self.sorted_goals = Variable(self.Tensor(self.goals.size())) # TODO: Bad for loop? for b in range(self.batch_size): self.sorted_goals[b] = self.goals[b][sort_idxs[b]] self.sorted_goals = self.sorted_goals[:, :, :2] # [batch_size, num_agents, num_entities, 2] self.observations = self.locations.unsqueeze( 1) - agent_baselines.unsqueeze(2) new_obs = self.goals[:, :, :2] - agent_baselines # [batch_size, num_agents, 2] [batch_size, num_agents, 1] self.observed_goals = torch.cat((new_obs, goal_agents), dim=2) self.plots_matrix = Plot(self.batch_size, self.time_horizon, self.num_entities, locations.shape[2], self.world_dim, self.num_agents, goals_by_landmark, self.folder_dir) self.plots_matrix.save_plot_matrix("start", locations, self.colors, self.shapes)
def test(): # Local Variables num_test_images = None # ----------------------------------------- # Network Testing Model - Importing Graph # ----------------------------------------- # Loads the dataset and restores a specified trained model. data = Dataloader() # Searches dataset images filenames if SELECTED_EVALUATION_SUBSET == 'test': _, _, _, _, num_test_images = data.get_test_data( test_split=args.test_split, test_file_path=args.test_file_path) elif SELECTED_EVALUATION_SUBSET == 'train': data.test_image_filenames, data.test_depth_filenames, _, _, num_test_images = data.get_train_data( ) model = Test(data) with tf.Session() as sess: print('\n[Test] Loading the model...') load_model(saver=tf.train.Saver(), sess=sess) # ============== # Testing Loop # ============== if args.debug: num_test_images = 5 # Only for testing! # TODO: Criar uma classe de test assim como fiz para train e valid, e declarar este objeto dentro dela if args.show_test_results: test_plot_obj = Plot(args.mode, title='Test Predictions') print("[Test] Generating Predictions...") pred_list, gt_list = [], [] timer = -time.time() for i in tqdm(range(num_test_images)): timer2 = -time.time() # Evalute the network for the given image # data.test_depth_filenames = [] # Only for testing the following condition!!! # FIXME: Atualmente, o código não dá suporte para esta situação if data.test_depth_filenames: # It's not empty feed_test = { model.tf_image_key: data.test_image_filenames[i], model.tf_depth_key: data.test_depth_filenames[i] } _, depth, depth_resized = sess.run(model.depth_op, feed_test) else: feed_test = {model.tf_image_key: data.test_image_filenames[i]} _, image, image_resized, pred, pred_up = sess.run( model.image_op + model.pred_op, feed_test) # Clips Predictions at 50, 80 meters try: pred_50, pred_80 = sess.run( [model.tf_pred_50, model.tf_pred_80], feed_test) except AttributeError: pred_50 = np.zeros((model.batch_size, ) + model.output_size.get_size()) pred_80 = np.zeros((model.batch_size, ) + model.output_size.get_size()) # Fill arrays for later on metrics evaluation if args.eval_tool == 'monodepth': pred_list.append(pred_up[0, :, :, 0]) gt_list.append(depth[:, :, 0]) # Saves the predictions and ground truth depth images as uint16 PNG Images if SAVE_TEST_DISPARITIES or args.eval_tool == 'monodepth' or args.eval_tool == 'kitti_depth': # Convert the Predictions Images from float32 to uint16 # print(data.test_image_filenames[i]) imsave_as_uint16_png( settings.output_tmp_pred_dir + 'pred' + str(i) + '.png', pred_up[0]) imsave_as_uint16_png( settings.output_tmp_gt_dir + 'gt' + str(i) + '.png', depth) timer2 += time.time() # Show Results if args.show_test_results: # TODO: Fazer um lista the 'images_to_display' e dar append das imagens na lista test_plot_obj.show_test_results( image=image, depth=depth[:, :, 0], image_resized=image_resized, depth_resized=depth_resized[:, :, 0], pred=pred[0, :, :, 0], pred_up=pred_up[0, :, :, 0], pred_50=pred_50[0, :, :, 0], pred_80=pred_80[0, :, :, 0], i=i + 1) # input("Continue...") # Testing Finished. timer += time.time() print("Time elapsed: {} s\n".format(timer)) # ========= # Results # ========= # Calculates Metrics if args.eval_tool: if data.test_depth_filenames: print( "[Test/Metrics] Calculating Metrics based on Test Predictions..." ) print('args.test_split:', args.test_split) print('args.test_file_path:', args.test_file_path) print('dataset_path:', data.dataset.dataset_path) print() # Invokes Evaluation Tools if args.eval_tool == 'monodepth': pred_depths, gt_depths = metrics.generate_depth_maps( pred_list, gt_list, data.dataset.dataset_path) metrics.evaluation_tool_monodepth(pred_depths, gt_depths) elif args.eval_tool == 'kitti_depth': metrics.evaluation_tool_kitti_depth(num_test_images) else: print( "[Test/Metrics] It's not possible to calculate metrics. There are no corresponding labels for generated predictions!" ) else: print("[Test/Metrics] Metrics calculation wasn't requested!")
def test(args): print('[%s] Selected mode: Test' % appName) # Local Variables numSamples = None # ----------------------------------------- # Network Testing Model - Importing Graph # ----------------------------------------- # Loads the dataset and restores a specified trained model. data = Dataloader(args) # Searches dataset images filenames if TEST_EVALUATE_SUBSET == 0: _, _, _, _, numSamples = data.getTestData() elif TEST_EVALUATE_SUBSET == 1: data.test_image_filenames, data.test_depth_filenames, tf_test_image_filenames, tf_test_depth_filenames, numSamples = data.getTrainData( ) model = Test(args, data) with tf.Session() as sess: print('\n[network/Testing] Loading the model...') # Use to load from *.ckpt file saver = tf.train.Saver() saver.restore(sess, args.model_path) # Use to load from npy file # net.load(model_data_path, sess) # ============== # Testing Loop # ============== if args.show_test_results: test_plotObj = Plot(args.mode, title='Test Predictions') timer = -time.time() pred_list, gt_list = [], [] for i in range(numSamples): # for i in range(5): # Only for testing! timer2 = -time.time() # Evalute the network for the given image # data.test_depth_filenames = [] # Only for testing the following condition!!! # FIXME: Atualmente, o código não dá suporte para esta situação if data.test_depth_filenames: # It's not empty feed_test = { model.tf_image_key: data.test_image_filenames[i], model.tf_depth_key: data.test_depth_filenames[i] } _, depth, depth_resized = sess.run(model.depth_op, feed_test) else: feed_test = {model.tf_image_key: data.test_image_filenames[i]} _, image, image_resized = sess.run(model.image_op, feed_test) pred, pred_up = sess.run(model.pred_op, feed_test) # Clips Predictions at 50, 80 meters try: pred_50, pred_80 = sess.run( [model.tf_pred_50, model.tf_pred_80], feed_test) except AttributeError: pred_50 = np.zeros((model.batch_size, ) + model.output_size.getSize()) pred_80 = np.zeros((model.batch_size, ) + model.output_size.getSize()) # Fill arrays for later on metrics evaluation pred_list.append(pred_up[0, :, :, 0]) gt_list.append(depth[:, :, 0]) # Saves the Test Predictions as uint16 PNG Images if SAVE_TEST_DISPARITIES: # Convert the Predictions Images from float32 to uint16 pred_up_uint16 = exposure.rescale_intensity(pred_up[0], out_range='float') pred_up_uint16 = img_as_uint(pred_up_uint16) depth_uint16 = exposure.rescale_intensity(depth, out_range='float') depth_uint16 = img_as_uint(depth_uint16) # Save PNG Images imageio.imsave("output/tmp/pred/pred" + str(i) + ".png", pred_up_uint16) imageio.imsave("output/tmp/gt/gt" + str(i) + ".png", depth_uint16) # Prints Testing Progress timer2 += time.time() print('step: %d/%d | t: %f | size(pred_list+gt_list): %d' % (i + 1, numSamples, timer2, total_size(pred_list) + total_size(gt_list))) # break # Test # Show Results if args.show_test_results: test_plotObj.showTestResults(image=image, depth=depth[:, :, 0], image_resized=image_resized, depth_resized=depth_resized[:, :, 0], pred=pred[0, :, :, 0], pred_up=pred_up[0, :, :, 0], pred_50=pred_50[0, :, :, 0], pred_80=pred_80[0, :, :, 0], i=i + 1) # input("Continue...") # Testing Finished. timer += time.time() print("\n[Network/Testing] Testing FINISHED! Time elapsed: %f s" % timer) # ========= # Results # ========= # Calculate Metrics if data.test_depth_filenames: print( "[Network/Testing] Calculating Metrics based on Testing Predictions..." ) pred_array = np.array(pred_list) gt_array = np.array(gt_list) # LainaMetrics.evaluate(pred_array, gt_array) # FIXME: # myMetrics.evaluate(pred_array, gt_array) # FIXME: MonodepthMetrics.evaluate(pred_array, gt_array) else: print( "[Network/Testing] It's not possible to calculate Metrics. There are no corresponding labels for Testing Predictions!" )