def main(): with open(ARGS.config) as f: model_params = json.load(f) model_params['pred_steps'] = ARGS.pred_steps lstm_multistep_regressor = tf.estimator.Estimator(model_fn=model_fn, params=model_params, model_dir=ARGS.log_dir) if ARGS.train: train_data = load_data(ARGS.data_dir, ARGS.data_transpose, edge=False, prefix='train') train_input_fn = tf.estimator.inputs.numpy_input_fn( x=train_data, batch_size=ARGS.batch_size, num_epochs=None, shuffle=True) lstm_multistep_regressor.train(input_fn=train_input_fn, steps=ARGS.train_steps) # Evaluation if ARGS.eval: valid_data = load_data(ARGS.data_dir, ARGS.data_transpose, edge=False, prefix='valid') eval_input_fn = tf.estimator.inputs.numpy_input_fn( x=valid_data, batch_size=ARGS.batch_size, num_epochs=1, shuffle=False) eval_results = lstm_multistep_regressor.evaluate( input_fn=eval_input_fn) if not ARGS.verbose: print('Evaluation results: {}'.format(eval_results)) # Prediction if ARGS.test: test_data = load_data(ARGS.data_dir, ARGS.data_transpose, edge=False, prefix='test') predict_input_fn = tf.estimator.inputs.numpy_input_fn( x=test_data, batch_size=ARGS.batch_size, shuffle=False) prediction = lstm_multistep_regressor.predict( input_fn=predict_input_fn) prediction = np.array([pred['next_steps'] for pred in prediction]) np.save( os.path.join(ARGS.log_dir, 'prediction_{}.npy'.format(ARGS.pred_steps)), prediction)
def main(): with open(ARGS.config) as f: model_params = json.load(f) seg_len = model_params['seg_len'] model_params['pred_steps'] = ARGS.pred_steps seq2seq_regressor = tf.estimator.Estimator(model_fn=model_fn, params=model_params, model_dir=ARGS.log_dir) if ARGS.train: train_data = load_data(ARGS.data_dir, ARGS.data_transpose, edge=False, prefix='train') features = {'time_series': train_data} train_input_fn = input_fn(features, seg_len, ARGS.pred_steps, ARGS.batch_size, 'train') seq2seq_regressor.train(input_fn=train_input_fn, steps=ARGS.train_steps) # Evaluation if ARGS.eval: valid_data = load_data(ARGS.data_dir, ARGS.data_transpose, edge=False, prefix='valid') features = {'time_series': valid_data} eval_input_fn = input_fn(features, seg_len, ARGS.pred_steps, ARGS.batch_size, 'eval') eval_results = seq2seq_regressor.evaluate(input_fn=eval_input_fn) if not ARGS.verbose: print('Evaluation results: {}'.format(eval_results)) # Prediction if ARGS.test: test_data = load_data(ARGS.data_dir, ARGS.data_transpose, edge=False, prefix='test') features = {'time_series': test_data} predict_input_fn = input_fn(features, seg_len, ARGS.pred_steps, ARGS.batch_size, 'test') prediction = seq2seq_regressor.predict(input_fn=predict_input_fn) prediction = np.array([pred['next_steps'] for pred in prediction]) np.save( os.path.join(ARGS.log_dir, 'prediction_{}.npy'.format(ARGS.pred_steps)), prediction)
def main(): with open(ARGS.config) as f: model_params = json.load(f) mlp_encoder_classifier = tf.estimator.Estimator(model_fn=encoder_model_fn, params=model_params, model_dir=ARGS.log_dir) if ARGS.train: train_data, train_edge = load_data(ARGS.data_dir, ARGS.data_transpose, edge=True, prefix='train') train_input_fn = tf.estimator.inputs.numpy_input_fn( x=train_data, y=train_edge, batch_size=ARGS.batch_size, num_epochs=None, shuffle=True) mlp_encoder_classifier.train(input_fn=train_input_fn, steps=ARGS.train_steps) # Evaluation if ARGS.eval: valid_data, valid_edge = load_data(ARGS.data_dir, ARGS.data_transpose, edge=True, prefix='valid') eval_input_fn = tf.estimator.inputs.numpy_input_fn(x=valid_data, y=valid_edge, num_epochs=1, shuffle=False) eval_results = mlp_encoder_classifier.evaluate(input_fn=eval_input_fn) if not ARGS.verbose: print('Evaluation results: {}'.format(eval_results)) # Predictoin if ARGS.test: test_data, test_edge = load_data(ARGS.data_dir, ARGS.data_transpose, edge=True, prefix='test') pred_input_fn = tf.estimator.inputs.numpy_input_fn(x=test_data, shuffle=False) prediction = mlp_encoder_classifier.predict(input_fn=pred_input_fn) predicted_edge_type = [pred['classes'] for pred in prediction] np.save(os.path.join(ARGS.log_dir, 'prediction.npy'), predicted_edge_type)
def main(): with open(ARGS.config) as f: model_params = json.load(f) # model_params['pred_steps'] = ARGS.pred_steps seg_len = 2 * len(model_params['cnn']['filters']) + 1 prefix = 'test' model_params['edge_type'] = model_params.get('edge_type', 1) # data contains edge_types if `edge=True`. data = load_data(ARGS.data_dir, ARGS.data_transpose, edge=model_params['edge_type'] > 1, prefix=prefix) print(f"\nData from {ARGS.data_dir} loaded.") # input_data: a list which is [time_segs, edge_types] if `edge_type` > 1, else [time_segs] input_data, expected_time_segs = preprocess_data( data, seg_len, ARGS.pred_steps, edge_type=model_params['edge_type']) print(f"Data processed.\n") nagents, ndims = expected_time_segs.shape[-2:] model_params.update({'nagents': nagents, 'ndims': ndims, 'pred_steps': ARGS.pred_steps, 'time_seg_len': seg_len}) model, inputs = gnn.build_model(model_params, return_inputs=True) print("Original model summary:") model.summary() print('\n') gnn.load_model(model, ARGS.log_dir) # Create Debug model outlayer_name = ARGS.layer_name outlayer_model = keras.Model( inputs=inputs, outputs=model.get_layer(outlayer_name).output) print(f"\nOutput up to {outlayer_name}\n") outlayer_model.summary() layer_output = outlayer_model.predict(input_data) np.save(os.path.join(ARGS.log_dir, f'{outlayer_name}_output'), layer_output) print(f"Layer {outlayer_name} output saved.")
def main(): with open(ARGS.config) as f: model_params = json.load(f) model_params['pred_steps'] = ARGS.pred_steps model_params['supervised'] = ARGS.supervised mlp_gnn_regressor = tf.estimator.Estimator(model_fn=model_fn, params=model_params, model_dir=ARGS.log_dir) # Training if ARGS.train: train_data, train_edge = load_data(ARGS.data_dir, ARGS.data_transpose, edge=True, prefix='train') train_input_fn = tf.estimator.inputs.numpy_input_fn( x=train_data, y=train_edge, batch_size=ARGS.batch_size, num_epochs=None, shuffle=True) mlp_gnn_regressor.train(input_fn=train_input_fn, steps=ARGS.train_steps) # Evaluation if ARGS.eval: valid_data, valid_edge = load_data(ARGS.data_dir, ARGS.data_transpose, edge=True, prefix='valid') eval_input_fn = tf.estimator.inputs.numpy_input_fn( x=valid_data, y=valid_edge, num_epochs=1, batch_size=ARGS.batch_size, shuffle=False) eval_results = mlp_gnn_regressor.evaluate(input_fn=eval_input_fn) if not ARGS.verbose: print('Evaluation results: {}'.format(eval_results)) # Prediction if ARGS.test: test_data, test_edge = load_data(ARGS.data_dir, ARGS.data_transpose, edge=True, prefix='test') predict_input_fn = tf.estimator.inputs.numpy_input_fn( x=test_data, batch_size=ARGS.batch_size, shuffle=False) prediction = mlp_gnn_regressor.predict(input_fn=predict_input_fn) prediction = [(pred['state_next_step'], pred['edge_type_prob']) for pred in prediction] state_next_step, edge_type_prob = zip(*prediction) np.save(os.path.join(ARGS.log_dir, 'prediction.npy'), state_next_step) np.save(os.path.join(ARGS.log_dir, 'infered_edge_type.npy'), edge_type_prob)
def main(): with open(ARGS.config) as f: model_params = json.load(f) model_params['pred_steps'] = ARGS.pred_steps seg_len = 2 * len(model_params['cnn']['filters']) + 1 cnn_multistep_regressor = tf.estimator.Estimator( model_fn=model_fn, params=model_params, model_dir=ARGS.log_dir) if ARGS.train: if model_params.get('edge_types', 0) > 1: train_data, train_edge = load_data(ARGS.data_dir, ARGS.data_transpose, edge=True, prefix='train') if ARGS.data_size: train_data, train_edge = train_data[:ARGS.data_size], train_edge[:ARGS.data_size] train_edge = gnn.utils.one_hot(train_edge, model_params['edge_types'], np.float32) features = {'time_series': train_data, 'edge_type': train_edge} else: train_data = load_data(ARGS.data_dir, ARGS.data_transpose, edge=False, prefix='train') if ARGS.data_size: train_data = train_data[:ARGS.data_size] features = {'time_series': train_data} train_input_fn = input_fn(features, seg_len, ARGS.pred_steps, ARGS.batch_size, 'train') cnn_multistep_regressor.train(input_fn=train_input_fn, steps=ARGS.train_steps) # Evaluation if ARGS.eval: if model_params.get('edge_types', 0) > 1: valid_data, valid_edge = load_data(ARGS.data_dir, ARGS.data_transpose, edge=True, prefix='valid') valid_edge = gnn.utils.one_hot(valid_edge, model_params['edge_types'], np.float32) features = {'time_series': valid_data, 'edge_type': valid_edge} else: valid_data = load_data(ARGS.data_dir, ARGS.data_transpose, edge=False, prefix='valid') features = {'time_series': valid_data} eval_input_fn = input_fn(features, seg_len, ARGS.pred_steps, ARGS.batch_size, 'eval') eval_results = cnn_multistep_regressor.evaluate(input_fn=eval_input_fn) if not ARGS.verbose: print('Evaluation results: {}'.format(eval_results)) # Prediction if ARGS.test: if model_params.get('edge_types', 0) > 1: test_data, test_edge = load_data(ARGS.data_dir, ARGS.data_transpose, edge=True, prefix='test') test_edge = gnn.utils.one_hot(test_edge, model_params['edge_types'], np.float32) features = {'time_series': test_data, 'edge_type': test_edge} else: test_data = load_data(ARGS.data_dir, ARGS.data_transpose, edge=False, prefix='test') features = {'time_series': test_data} predict_input_fn = input_fn(features, seg_len, ARGS.pred_steps, ARGS.batch_size, 'test') prediction = cnn_multistep_regressor.predict(input_fn=predict_input_fn) prediction = np.array([pred['next_steps'] for pred in prediction]) np.save(os.path.join(ARGS.log_dir, 'prediction_{}.npy'.format( ARGS.pred_steps)), prediction)
def main(): with open(ARGS.config) as f: model_params = json.load(f) # model_params['pred_steps'] = ARGS.pred_steps seg_len = 2 * len(model_params['cnn']['filters']) + 1 if ARGS.train: prefix = 'train' elif ARGS.eval: prefix = 'valid' elif ARGS.test: prefix = 'test' data = load_data(ARGS.data_dir, ARGS.data_transpose, prefix=prefix, size=ARGS.data_size, padding=ARGS.max_padding) input_data, expected_time_segs = preprocess_data( data, seg_len, ARGS.pred_steps, edge_type=model_params['edge_type']) print(f"\nData from {ARGS.data_dir} processed.\n") nagents, ndims = expected_time_segs.shape[-2:] model_params.update({ 'num_nodes': nagents, 'ndims': ndims, 'pred_steps': ARGS.pred_steps, 'time_seg_len': seg_len }) models = {'MPNN': gnn.MPNN, 'MFGNN': gnn.MFGNN} model = models[ARGS.model].build_model(model_params) # model.summary() gnn.utils.load_model(model, ARGS.log_dir) if ARGS.train: checkpoint = gnn.utils.save_model(model, ARGS.log_dir) # tb_callback = tf.keras.callbacks.TensorBoard(log_dir=ARGS.log_dir, histogram_freq=1) history = model.fit(input_data, expected_time_segs, epochs=ARGS.epochs, batch_size=ARGS.batch_size, callbacks=[checkpoint]) # print(history.history) elif ARGS.eval: result = model.evaluate(input_data, expected_time_segs, batch_size=ARGS.batch_size) # result = MSE print("Evaluating baseline...") baseline = eval_base_line(data) print('Baseline:', baseline, '\t| MSE / Baseline:', result / baseline) elif ARGS.test: prediction = model.predict(input_data) np.save( os.path.join(ARGS.log_dir, f'prediction_{ARGS.pred_steps}.npy'), prediction)
def main(): with open(ARGS.config) as f: model_params = json.load(f) # model_params['pred_steps'] = ARGS.pred_steps seg_len = 2 * len(model_params['cnn']['filters']) + 1 if ARGS.train: prefix = 'train' elif ARGS.eval: prefix = 'valid' elif ARGS.test: prefix = 'test' model_params['edge_type'] = model_params.get('edge_type', 1) # data contains edge_types if `edge=True`. data = load_data(ARGS.data_dir, ARGS.data_transpose, edge=model_params['edge_type'] > 1, prefix=prefix, size=ARGS.data_size) # input_data: a list which is [time_segs, edge_types] if `edge_type` > 1, else [time_segs] input_data, expected_time_segs = preprocess_data( data, seg_len, ARGS.pred_steps, edge_type=model_params['edge_type']) print(f"\nData from {ARGS.data_dir} processed.\n") nagents, ndims = expected_time_segs.shape[-2:] model_params.update({ 'nagents': nagents, 'ndims': ndims, 'pred_steps': ARGS.pred_steps, 'time_seg_len': seg_len }) model = gnn.build_model(model_params) # model.summary() gnn.load_model(model, ARGS.log_dir) if ARGS.train: checkpoint = gnn.save_model(model, ARGS.log_dir) # Freeze some of the layers according to train mode. if ARGS.train_mode > 0: model.conv1d.trainable = False if model_params['edge_type'] > 1: for edge_encoder in model.edge_encoders: edge_encoder.trainable = False else: model.edge_encoder.trainable = False if ARGS.train_mode > 1: model.node_encoder.trainable = False history = model.fit(input_data, expected_time_segs, epochs=ARGS.epochs, batch_size=ARGS.batch_size, callbacks=[checkpoint]) # print(history.history) elif ARGS.eval: result = model.evaluate(input_data, expected_time_segs, batch_size=ARGS.batch_size) # result = MSE baseline = eval_base_line(input_data) print('Baseline:', baseline, '\t| MSE / Baseline:', result / baseline) elif ARGS.test: prediction = model.predict(input_data) np.save( os.path.join(ARGS.log_dir, f'prediction_{ARGS.pred_steps}.npy'), prediction)
def main(): with open(ARGS.config) as f: model_params = json.load(f) model_params['pred_steps'] = ARGS.pred_steps seg_len = 2 * len(model_params['cnn']['filters']) + 1 cnn_multistep_regressor = tf.estimator.Estimator(model_fn=model_fn, params=model_params, model_dir=ARGS.log_dir) # Prediction if ARGS.test: if model_params.get('edge_types', 0) > 1: test_data, test_edge = load_data(ARGS.data_dir, ARGS.data_transpose, edge=True, prefix='test') test_edge = gnn.utils.one_hot(test_edge, model_params['edge_types'], np.float32) features = {'time_series': test_data, 'edge_type': test_edge} else: test_data = load_data(ARGS.data_dir, ARGS.data_transpose, edge=False, prefix='test') features = {'time_series': test_data} if not ARGS.dynamic_update: curr_time = time.time() predict_input_fn = input_fn(features, seg_len, ARGS.pred_steps, ARGS.batch_size, 'test') prediction = cnn_multistep_regressor.predict( input_fn=predict_input_fn) prediction = np.array([pred['next_steps'] for pred in prediction]) prediction = np.swapaxes(prediction, 0, 1) print('GNN execution time = %f' % (-curr_time + time.time())) #print(prediction.shape) print("===========================================================") print("===========================================================") # Instantiate Robotarium object N = test_data.shape[2] r = robotarium.Robotarium(number_of_agents=N, show_figure=False, save_data=False, update_time=0.3) # Create barrier certificates to avoid collision si_barrier_cert = create_single_integrator_barrier_certificate(N) # ------------------------- initalizing initial positions ------------------------ # initialize the the agents according to the simulation initial_goal_points = np.squeeze( np.swapaxes(test_data, 2, 3)[:, 0, :2, :]) initial_orientations = np.zeros((1, 20)) initial_goal_states = np.concatenate( [initial_goal_points, initial_orientations], axis=0) move_to_goal(r, N, si_barrier_cert, initial_goal_states) r.call_at_scripts_end() time.sleep(0.03) print('Step 1') print('error = %f' % (np.linalg.norm(r.get_poses()[:2, :] - initial_goal_points))) current_position = r.get_poses()[:2, :] current_velocities = unicycle_to_single_integrator( r.velocities, r.get_poses()) current_pos_vel = np.concatenate( [current_position, current_velocities], axis=0) pos_vel_log = np.swapaxes( np.expand_dims(np.expand_dims(current_pos_vel, axis=0), axis=0), 2, 3) for i in range(1, 8): print('Step %d' % (i + 1)) goal_points = np.squeeze(np.swapaxes(test_data, 2, 3)[:, i, :2, :]) goal_velocities = np.squeeze( np.swapaxes(test_data, 2, 3)[:, i, 2:, :]) apply_control(r, N, goal_velocities) current_position = r.get_poses()[:2, :] current_velocities = unicycle_to_single_integrator( r.velocities, r.get_poses()) current_pos_vel = np.concatenate( [current_position, current_velocities], axis=0) pos_vel_log = np.concatenate([ pos_vel_log, np.swapaxes( np.expand_dims(np.expand_dims(current_pos_vel, axis=0), axis=0), 2, 3) ], axis=1) print('error = %f' % (np.linalg.norm(r.get_poses()[:2, :] - goal_points))) # Always call this function at the end of your scripts! It will accelerate the # execution of your experiment # r.call_at_scripts_end() #------------- intialization end ---------------------- # -------------------- Prediction from Graph neural network ------------------------- pos_vel_log = pos_vel_log.astype(dtype=np.float32) for i in range(8, test_data.shape[1]): if ARGS.dynamic_update: curr_time = time.time() features = {'time_series': pos_vel_log[:, i - 8:i, :, :]} predict_input_fn = input_fn(features, seg_len, ARGS.pred_steps, ARGS.batch_size, 'test') prediction = cnn_multistep_regressor.predict( input_fn=predict_input_fn) prediction = np.array( [pred['next_steps'] for pred in prediction]) print( "------------------------------------------------------------------" ) print('GNN execution time = %f' % (-curr_time + time.time())) goal_velocities = np.squeeze( np.swapaxes(prediction, 2, 3)[:, :, 2:, :]) else: print(prediction.shape) goal_velocities = np.squeeze( np.swapaxes(prediction, 2, 3)[:, i - 8, 2:, :]) print('Step %d' % (i + 1)) goal_points = np.squeeze(np.swapaxes(test_data, 2, 3)[:, i, :2, :]) #goal_velocities = np.squeeze(np.swapaxes(prediction,2,3)[:,:,2:,:]) apply_control(r, N, goal_velocities) current_position = r.get_poses()[:2, :] current_velocities = unicycle_to_single_integrator( r.velocities, r.get_poses()) current_pos_vel = np.concatenate( [current_position, current_velocities], axis=0) pos_vel_log = np.concatenate([ pos_vel_log, np.swapaxes( np.expand_dims(np.expand_dims(current_pos_vel, axis=0), axis=0), 2, 3) ], axis=1) pos_vel_log = pos_vel_log.astype(dtype=np.float32) print('error = %f' % (np.linalg.norm(r.get_poses()[:2, :] - goal_points))) # Always call this function at the end of your scripts! It will accelerate the # execution of your experiment r.call_at_scripts_end()
def main(): with open(ARGS.config) as f: model_params = json.load(f) model_params['pred_steps'] = ARGS.pred_steps mlp_decoder_regressor = tf.estimator.Estimator(model_fn=decoder_model_fn, params=model_params, model_dir=ARGS.log_dir) if ARGS.train: train_data, train_edge = load_data(ARGS.data_dir, ARGS.data_transpose, edge=True, prefix='train') train_edge = gnn.utils.one_hot(train_edge, model_params['edge_types'], np.float32) train_input_fn = tf.estimator.inputs.numpy_input_fn( x={ 'time_series': train_data, 'edge_type': train_edge }, batch_size=ARGS.batch_size, num_epochs=None, shuffle=True) mlp_decoder_regressor.train(input_fn=train_input_fn, steps=ARGS.train_steps) # Evaluation if ARGS.eval: valid_data, valid_edge = load_data(ARGS.data_dir, ARGS.data_transpose, edge=True, prefix='valid') valid_edge = gnn.utils.one_hot(valid_edge, model_params['edge_types'], np.float32) eval_input_fn = tf.estimator.inputs.numpy_input_fn( x={ 'time_series': valid_data, 'edge_type': valid_edge }, batch_size=ARGS.batch_size, num_epochs=1, shuffle=False) eval_results = mlp_decoder_regressor.evaluate(input_fn=eval_input_fn) if not ARGS.verbose: print('Evaluation results: {}'.format(eval_results)) # Prediction if ARGS.test: test_data, test_edge = load_data(ARGS.data_dir, ARGS.data_transpose, edge=True, prefix='test') test_edge = gnn.utils.one_hot(test_edge, model_params['edge_types'], np.float32) predict_input_fn = tf.estimator.inputs.numpy_input_fn( x={ 'time_series': test_data, 'edge_type': test_edge }, batch_size=ARGS.batch_size, shuffle=False) prediction = mlp_decoder_regressor.predict(input_fn=predict_input_fn) prediction = np.array( [pred['state_next_steps'] for pred in prediction]) np.save( os.path.join(ARGS.log_dir, 'prediction_{}.npy'.format(ARGS.pred_steps)), prediction)