def mode_8(sess, graph, save_path): """ to find high-openshot-penalty data in 1000 real data """ real_data = np.load(FLAGS.data_path)[:, :FLAGS.seq_length, :, :] print('real_data.shape', real_data.shape) data_factory = DataFactory(real_data) train_data, valid_data = data_factory.fetch_data() # placeholder tensor real_data_t = graph.get_tensor_by_name('real_data:0') matched_cond_t = graph.get_tensor_by_name('matched_cond:0') # result tensor heuristic_penalty_pframe = graph.get_tensor_by_name( 'Critic/C_inference/heuristic_penalty/Min:0') # 'Generator/G_loss/C_inference/linear_result/Reshape:0') if not os.path.exists(save_path): os.makedirs(save_path) real_hp_pframe_all = [] for batch_id in range(train_data['A'].shape[0] // FLAGS.batch_size): index_id = batch_id * FLAGS.batch_size real_data = train_data['B'][index_id:index_id + FLAGS.batch_size] cond_data = train_data['A'][index_id:index_id + FLAGS.batch_size] # real feed_dict = {real_data_t: real_data, matched_cond_t: cond_data} real_hp_pframe = sess.run(heuristic_penalty_pframe, feed_dict=feed_dict) real_hp_pframe_all.append(real_hp_pframe) real_hp_pframe_all = np.concatenate(real_hp_pframe_all, axis=0) print(real_hp_pframe_all.shape) real_hp_pdata = np.mean(real_hp_pframe_all, axis=1) mean_ = np.mean(real_hp_pdata) std_ = np.std(real_hp_pdata) print(mean_) print(std_) concat_AB = np.concatenate([train_data['A'], train_data['B']], axis=-1) recoverd = data_factory.recover_data(concat_AB) for i, v in enumerate(real_hp_pdata): if v > (mean_ + 2 * std_): print('bad', i, v) game_visualizer.plot_data(recoverd[i], recoverd.shape[1], file_path=save_path + 'bad_' + str(i) + '_' + str(v) + '.mp4', if_save=True) if v < 0.0025: print('good', i, v) game_visualizer.plot_data(recoverd[i], recoverd.shape[1], file_path=save_path + 'good_' + str(i) + '_' + str(v) + '.mp4', if_save=True) print('!!Completely Saved!!')
def main(_): with tf.get_default_graph().as_default() as graph: real_data = np.load(FLAGS.data_path)[:, :FLAGS.seq_length, :, :] print('real_data.shape', real_data.shape) # normalize data_factory = DataFactory(real_data) train_data, valid_data = data_factory.fetch_data() print(train_data['A'].shape) print(valid_data['A'].shape) # config setting config = TrainingConfig() config.show() # train training(train_data, valid_data, data_factory, config, graph)
def main(_): real_data = np.load(FLAGS.data_path)[:, :FLAGS.seq_length, :, :] print('real_data.shape', real_data.shape) # normalize data_factory = DataFactory(real_data) train_data, valid_data = data_factory.fetch_data() print(train_data['A'].shape) print(valid_data['A'].shape) # config setting config = TrainingConfig() baseline_graph = None if FLAGS.baseline_checkpoint is not None: baseline_graph = tf.Graph() default_graph = tf.Graph() training(train_data, valid_data, data_factory, config, default_graph, baseline_graph)
def mode_1(sess, graph, save_path, is_valid=FLAGS.is_valid): """ to collect results Saved Result ------------ results_A_fake_B : float, numpy ndarray, shape=[n_latents=100, n_conditions=128*9, length=100, features=23] Real A + Fake B results_A_real_B : float, numpy ndarray, shape=[n_conditions=128*9, length=100, features=23] Real A + Real B results_critic_scores : float, numpy ndarray, shape=[n_latents=100, n_conditions=128*9] critic scores for each input data """ # placeholder tensor latent_input_t = graph.get_tensor_by_name('latent_input:0') team_a_t = graph.get_tensor_by_name('team_a:0') G_samples_t = graph.get_tensor_by_name('G_samples:0') matched_cond_t = graph.get_tensor_by_name('matched_cond:0') # result tensor result_t = graph.get_tensor_by_name( 'Generator/G_inference/conv_result/conv1d/Maximum:0') # critic_scores_t = graph.get_tensor_by_name( # 'Critic/C_inference_1/conv_output/Reshape:0') critic_scores_t = graph.get_tensor_by_name( 'Critic/C_inference_1/linear_result/BiasAdd:0') if not os.path.exists(save_path): os.makedirs(save_path) real_data = np.load(FLAGS.data_path)[:, :FLAGS.seq_length, :, :] print('real_data.shape', real_data.shape) # normalize data_factory = DataFactory(real_data) # result collector results_A_fake_B = [] results_A_real_B = [] results_critic_scores = [] # shuffle the data train_data, valid_data = data_factory.fetch_data() if is_valid: target_data = valid_data else: target_data = train_data target_data = np.load('ADD-100.npy') team_AB = np.concatenate( [ # ball target_data[:, :, 0, :3].reshape( [target_data.shape[0], target_data.shape[1], 1 * 3]), # team A players target_data[:, :, 1:6, :2].reshape( [target_data.shape[0], target_data.shape[1], 5 * 2]), # team B players target_data[:, :, 6:11, :2].reshape( [target_data.shape[0], target_data.shape[1], 5 * 2]) ], axis=-1 ) team_AB = data_factory.normalize(team_AB) print(team_AB.shape) dummy_AB = np.zeros(shape=[98, 100, 23]) team_AB = np.concatenate([team_AB, dummy_AB], axis=0) team_A = team_AB[:, :, :13] team_B = team_AB[:, :, 13:] # for idx in range(0, FLAGS.batch_size, FLAGS.batch_size): real_samples = team_B real_conds = team_A # generate result temp_critic_scores = [] temp_A_fake_B = [] for i in range(FLAGS.n_latents): latents = z_samples(FLAGS.batch_size) feed_dict = { latent_input_t: latents, team_a_t: real_conds } result = sess.run( result_t, feed_dict=feed_dict) feed_dict = { G_samples_t: result, matched_cond_t: real_conds } critic_scores = sess.run( critic_scores_t, feed_dict=feed_dict) temp_A_fake_B.append(data_factory.recover_data( np.concatenate([real_conds, result], axis=-1))) temp_critic_scores.append(critic_scores) results_A_fake_B.append(temp_A_fake_B) results_critic_scores.append(temp_critic_scores) # concat along with conditions dimension (axis=1) results_A_fake_B = np.concatenate(results_A_fake_B, axis=1) results_critic_scores = np.concatenate(results_critic_scores, axis=1) results_A = data_factory.recover_BALL_and_A( real_conds) results_real_B = data_factory.recover_B( real_samples) results_A_real_B = np.concatenate([results_A, results_real_B], axis=-1) # saved as numpy print(np.array(results_A_fake_B).shape) print(np.array(results_A_real_B).shape) print(np.array(results_critic_scores).shape) np.save(save_path + 'results_A_fake_B.npy', np.array(results_A_fake_B)[:, :30].astype(np.float32).reshape([FLAGS.n_latents, 30, FLAGS.seq_length, 23])) np.save(save_path + 'results_A_real_B.npy', np.array(results_A_real_B)[:30].astype(np.float32).reshape([30, FLAGS.seq_length, 23])) np.save(save_path + 'results_critic_scores.npy', np.array(results_critic_scores)[:, :30].astype(np.float32).reshape([FLAGS.n_latents, 30])) print('!!Completely Saved!!')
def mode_4(sess, graph, save_path, is_valid=FLAGS.is_valid): """ to analize code, only change first dimension for comparison Saved Result ------------ results_A_fake_B : float, numpy ndarray, shape=[n_latents=11, n_conditions=128*9, length=100, features=23] Real A + Fake B results_A_real_B : float, numpy ndarray, shape=[n_latents=11, n_conditions=128*9, length=100, features=23] Real A + Real B results_critic_scores : float, numpy ndarray, shape=[n_latents=11, n_conditions=128*9] critic scores for each input data """ target_dims = 0 n_latents = 11 # placeholder tensor latent_input_t = graph.get_tensor_by_name('latent_input:0') team_a_t = graph.get_tensor_by_name('team_a:0') G_samples_t = graph.get_tensor_by_name('G_samples:0') matched_cond_t = graph.get_tensor_by_name('matched_cond:0') # result tensor result_t = graph.get_tensor_by_name( 'Generator/G_inference/conv_result/conv1d/Maximum:0') critic_scores_t = graph.get_tensor_by_name( 'Critic/C_inference_1/linear_result/BiasAdd:0') # 'Generator/G_loss/C_inference/linear_result/Reshape:0') if not os.path.exists(save_path): os.makedirs(save_path) real_data = np.load(FLAGS.data_path)[:, :FLAGS.seq_length, :, :] print('real_data.shape', real_data.shape) # normalize data_factory = DataFactory(real_data) # result collector results_A_fake_B = [] results_A_real_B = [] results_critic_scores = [] # shuffle the data train_data, valid_data = data_factory.fetch_data() if is_valid: target_data = valid_data else: target_data = train_data latents = z_samples(FLAGS.batch_size) for idx in range(0, FLAGS.n_conditions, FLAGS.batch_size): real_samples = target_data['B'][idx:idx + FLAGS.batch_size] real_conds = target_data['A'][idx:idx + FLAGS.batch_size] # generate result temp_critic_scores = [] temp_A_fake_B = [] for i in range(n_latents): latents[:, target_dims] = -2.5 + 0.5 * i feed_dict = { latent_input_t: latents, team_a_t: real_conds } result = sess.run( result_t, feed_dict=feed_dict) feed_dict = { G_samples_t: result, matched_cond_t: real_conds } critic_scores = sess.run( critic_scores_t, feed_dict=feed_dict) temp_A_fake_B.append(data_factory.recover_data( np.concatenate([real_conds, result], axis=-1))) temp_critic_scores.append(critic_scores) results_A_fake_B.append(temp_A_fake_B) results_critic_scores.append(temp_critic_scores) # concat along with conditions dimension (axis=1) results_A_fake_B = np.concatenate(results_A_fake_B, axis=1) results_critic_scores = np.concatenate(results_critic_scores, axis=1) results_A = data_factory.recover_BALL_and_A( target_data['A'][:FLAGS.n_conditions]) results_real_B = data_factory.recover_B( target_data['B'][:FLAGS.n_conditions]) results_A_real_B = np.concatenate([results_A, results_real_B], axis=-1) # saved as numpy print(np.array(results_A_fake_B).shape) print(np.array(results_A_real_B).shape) print(np.array(results_critic_scores).shape) np.save(save_path + 'results_A_fake_B.npy', np.array(results_A_fake_B).astype(np.float32).reshape([n_latents, FLAGS.n_conditions, FLAGS.seq_length, 23])) np.save(save_path + 'results_A_real_B.npy', np.array(results_A_real_B).astype(np.float32).reshape([FLAGS.n_conditions, FLAGS.seq_length, 23])) np.save(save_path + 'results_critic_scores.npy', np.array(results_critic_scores).astype(np.float32).reshape([n_latents, FLAGS.n_conditions])) print('!!Completely Saved!!')