def main(args): # Set this value to export models for continual learning or batch training load_dataset = data_loader_home.load_dataset # Get the right architecture which was used for continual learning CAE = CAE_home_voxel_3 mlp = model_home.MLP2 # make the big model mpNet = End2EndMPNet(total_input_size=150008, AE_input_size=[1,32,32,32], mlp_input_size=78, \ output_size=7, AEtype='deep', n_tasks=1, n_memories=1, memory_strength=0.5, grad_step=1, \ CAE=CAE, MLP=mlp) # The model that performed well originally, load into the big end2end model model_path = args.model_path + args.model_name load_net_state(mpNet, model_path) # Get the weights from this model and create a copy of the weights in mlp_weights (to be copied over) MLP = mpNet.mlp #MLP # Save a copy of the encoder's state_dict() for loading into the annotated encoder later on encoder = mpNet.encoder obs, path_data = load_dataset(N=1, NP=1, folder=args.data_path) # read from the sample test mlp_input = np.loadtxt("test_sample.txt") mlp_input = mlp_input.reshape(1, 78) mlp_input = torch.from_numpy(mlp_input).type(torch.FloatTensor) mlp_input = Variable(mlp_input) mlp_outputs = [] for i in range(100): mlp_output = MLP(mlp_input) mlp_output = mlp_output.data.numpy() mlp_outputs.append(mlp_output) mlp_outputs = np.array(mlp_outputs) cpp_output = np.loadtxt("test_sample_output_cpp.txt") cpp_output = cpp_output.reshape(100, 7) print('mlp output:') print(mlp_outputs.mean(axis=0)) print('cpp_output:') print(cpp_output.mean(axis=0)) # compare encoder output cpp_output = np.loadtxt('obs_enc_cpp.txt') cpp_output = cpp_output.reshape(-1) enc_input = np.array(obs) enc_input = torch.from_numpy(enc_input).type(torch.FloatTensor) enc_input = Variable(enc_input) enc_output = encoder(enc_input).data.numpy() print('encoder output:') print(enc_output) print('cpp enc output:') print(cpp_output)
def main(args): # set seed torch_seed = np.random.randint(low=0, high=1000) np_seed = np.random.randint(low=0, high=1000) py_seed = np.random.randint(low=0, high=1000) torch.manual_seed(torch_seed) np.random.seed(np_seed) random.seed(py_seed) # Build the models if torch.cuda.is_available(): torch.cuda.set_device(args.device) # decide dataloader, MLP, AE based on env_type if args.env_type == 's2d': IsInCollision = plan_s2d.IsInCollision load_dataset = data_loader_2d.load_dataset load_test_dataset = data_loader_2d.load_test_dataset load_train_dataset = data_loader_2d.load_train_dataset normalize = utility_s2d.normalize unnormalize = utility_s2d.unnormalize CAE = CAE_2d MLP = model.MLP elif args.env_type == 'c2d': IsInCollision = plan_c2d.IsInCollision load_dataset = data_loader_2d.load_dataset load_test_dataset = data_loader_2d.load_test_dataset load_train_dataset = data_loader_2d.load_train_dataset normalize = utility_c2d.normalize unnormalize = utility_c2d.unnormalize CAE = CAE_2d MLP = model_c2d.MLP elif args.env_type == 'r3d': IsInCollision = plan_r3d.IsInCollision load_dataset = data_loader_r3d.load_dataset load_test_dataset = data_loader_r3d.load_test_dataset load_train_dataset = data_loader_r3d.load_train_dataset normalize = utility_r3d.normalize unnormalize = utility_r3d.unnormalize CAE = CAE_r3d MLP = model.MLP elif args.env_type == 'r2d': IsInCollision = plan_r2d.IsInCollision load_dataset = data_loader_r2d.load_dataset load_test_dataset = data_loader_r2d.load_test_dataset load_train_dataset = data_loader_r2d.load_train_dataset normalize = utility_r2d.normalize unnormalize = utility_r2d.unnormalize CAE = CAE_2d #MLP = model.MLP MLP = model_c2d.MLP args.world_size = [20., 20., np.pi] if args.memory_type == 'res': mpNet = End2EndMPNet(args.total_input_size, args.AE_input_size, args.mlp_input_size, \ args.output_size, 'deep', args.n_tasks, args.n_memories, args.memory_strength, args.grad_step, \ CAE, MLP) elif args.memory_type == 'prio_loss': mpNet = End2EndMPNet_loss(args.total_input_size, args.AE_input_size, args.mlp_input_size, \ args.output_size, 'deep', args.n_tasks, args.n_memories, args.memory_strength, args.grad_step, \ CAE, MLP) elif args.memory_type == 'prio_reward': mpNet = End2EndMPNet_reward(args.total_input_size, args.AE_input_size, args.mlp_input_size, \ args.output_size, 'deep', args.n_tasks, args.n_memories, args.memory_strength, args.grad_step, \ CAE, MLP) elif args.memory_type == 'prio_cover': mpNet = End2EndMPNet_cover(args.total_input_size, args.AE_input_size, args.mlp_input_size, \ args.output_size, 'deep', args.n_tasks, args.n_memories, args.memory_strength, args.grad_step, \ CAE, MLP) # load previously trained model if start epoch > 0 model_path='cmpnet_epoch_%d.pkl' %(args.start_epoch) if args.start_epoch > 0: load_net_state(mpNet, os.path.join(args.model_path, model_path)) torch_seed, np_seed, py_seed = load_seed(os.path.join(args.model_path, model_path)) # set seed after loading torch.manual_seed(torch_seed) np.random.seed(np_seed) random.seed(py_seed) if torch.cuda.is_available(): mpNet.cuda() mpNet.mlp.cuda() mpNet.encoder.cuda() if args.opt == 'Adagrad': mpNet.set_opt(torch.optim.Adagrad, lr=args.learning_rate) elif args.opt == 'Adam': mpNet.set_opt(torch.optim.Adam, lr=args.learning_rate) elif args.opt == 'SGD': mpNet.set_opt(torch.optim.SGD, lr=args.learning_rate, momentum=0.9) elif args.opt == 'ASGD': mpNet.set_opt(torch.optim.ASGD, lr=args.learning_rate) if args.start_epoch > 0: load_opt_state(mpNet, os.path.join(args.model_path, model_path)) # load train and test data print('loading...') obs, path_data = load_dataset(N=args.no_env, NP=args.no_motion_paths, folder=args.data_path) val_obs, val_dataset, val_targets, val_env_indices = load_train_dataset(N=10, NP=200, \ folder=args.data_path, s=args.unseen_s) seen_test_data = load_test_dataset(N=args.seen_N, NP=args.seen_NP, s=args.seen_s, sp=args.seen_sp, folder=args.data_path) unseen_test_data = load_test_dataset(N=args.unseen_N, NP=args.unseen_NP, s=args.unseen_s, sp=args.unseen_sp, folder=args.data_path) normalize_func=lambda x: normalize(x, args.world_size) unnormalize_func=lambda x: unnormalize(x, args.world_size) val_losses = [] seen_test_accs = [] unseen_test_accs = [] # Train the Models print('training...') for epoch in range(args.start_epoch+1,args.num_epochs+1): #data_all = [] num_path_trained = 0 print('epoch' + str(epoch)) dataset, targets, env_indices = [], [], [] path_ct = 0 for i in range(0,len(path_data)): print('epoch: %d, training... path: %d' % (epoch, i+1)) p_dataset, p_targets, p_env_indices = path_data[i] if len(p_dataset) == 0: # empty path continue dataset += p_dataset targets += p_targets env_indices += p_env_indices path_ct += 1 if path_ct % args.train_path != 0: continue bi = np.concatenate( (obs[env_indices], dataset), axis=1).astype(np.float32) bt = targets bi = torch.FloatTensor(bi) bt = torch.FloatTensor(bt) bi, bt = normalize(bi, args.world_size), normalize(bt, args.world_size) mpNet.zero_grad() bi=to_var(bi) bt=to_var(bt) #print('before training losses:') #print(mpNet.loss(mpNet(bi), bt)) mpNet.observe(bi, 0, bt) #print('after training losses:') #print(mpNet.loss(mpNet(bi), bt)) num_path_trained += 1 seen_test_suc_rate = 0. unseen_test_suc_rate = 0. torch.cuda.empty_cache() # free unused memory dataset, targets, env_indices = [], [], [] path_ct = 0 if i % args.test_frequency == 0: # after several training data, test mse loss, success rate on test data bi = np.concatenate( (val_obs[val_env_indices], val_dataset), axis=1).astype(np.float32) bt = val_targets bi = torch.FloatTensor(bi) bt = torch.FloatTensor(bt) bi, bt = normalize(bi, args.world_size), normalize(bt, args.world_size) bi=to_var(bi) bt=to_var(bt) loss = mpNet.loss(mpNet(bi), bt) print('validation loss: ' + str(loss)) val_losses.append(loss.data.item()) time_file = None fes_path_, valid_path_ = eval_tasks(mpNet, seen_test_data, time_file, IsInCollision, normalize_func, unnormalize_func, True) valid_path = valid_path_.flatten() fes_path = fes_path_.flatten() # notice different environments are involved seen_test_suc_rate += fes_path.sum() / valid_path.sum() fes_path_, valid_path_ = eval_tasks(mpNet, unseen_test_data, time_file, IsInCollision, normalize_func, unnormalize_func, True) valid_path = valid_path_.flatten() fes_path = fes_path_.flatten() # notice different environments are involved unseen_test_suc_rate += fes_path.sum() / valid_path.sum() print('seen accuracy: ' + str(seen_test_suc_rate)) print('unseen accuracy: ' + str(unseen_test_suc_rate)) seen_test_accs.append(seen_test_suc_rate) unseen_test_accs.append(unseen_test_suc_rate) # save and plot plot_util.plot(val_losses, title='validation loss during training', xlabel='every %d paths' % (args.test_frequency), \ ylabel='val loss', path=args.model_path+'val_loss.png') plot_util.plot(seen_test_accs, title='test accuracy on seen dataset', xlabel='every %d paths' % (args.test_frequency), \ ylabel='seen accuracy', path=args.model_path+'seen_test_accs.png') plot_util.plot(unseen_test_accs, title='test accuracy on unseen dataset', xlabel='every %d paths' % (args.test_frequency), \ ylabel='unseen accuracy', path=args.model_path+'unseen_test_accs.png') pickle.dump(val_losses, open(args.model_path+'val_loss.p', "wb" )) pickle.dump(seen_test_accs, open(args.model_path+'seen_accs.p', 'wb')) pickle.dump(unseen_test_accs, open(args.model_path+'unseen_accs.p', 'wb'))
def main(args): # set seed print(args.model_path) torch_seed = np.random.randint(low=0, high=1000) np_seed = np.random.randint(low=0, high=1000) py_seed = np.random.randint(low=0, high=1000) torch.manual_seed(torch_seed) np.random.seed(np_seed) random.seed(py_seed) # Build the models if torch.cuda.is_available(): torch.cuda.set_device(args.device) # setup evaluation function and load function if args.env_type == 's2d': IsInCollision = plan_s2d.IsInCollision load_test_dataset = data_loader_2d.load_test_dataset normalize = utility_s2d.normalize unnormalize = utility_s2d.unnormalize CAE = CAE_2d MLP = model.MLP eval_tasks = gem_eval.eval_tasks elif args.env_type == 'c2d': IsInCollision = plan_c2d.IsInCollision load_test_dataset = data_loader_2d.load_test_dataset normalize = utility_c2d.normalize unnormalize = utility_c2d.unnormalize CAE = CAE_2d MLP = model_c2d_simple.MLP eval_tasks = gem_eval.eval_tasks elif args.env_type == 'r3d': IsInCollision = plan_r3d.IsInCollision load_test_dataset = data_loader_r3d.load_test_dataset normalize = utility_r3d.normalize unnormalize = utility_r3d.unnormalize CAE = CAE_r3d MLP = model.MLP eval_tasks = gem_eval.eval_tasks elif args.env_type == 'r2d': IsInCollision = plan_r2d.IsInCollision load_test_dataset = data_loader_r2d.load_test_dataset normalize = utility_r2d.normalize unnormalize = utility_r2d.unnormalize CAE = CAE_2d #MLP = model.MLP MLP = model_c2d.MLP eval_tasks = gem_eval.eval_tasks args.world_size = [20., 20., np.pi] elif args.env_type == 'r2d_simple': IsInCollision = plan_r2d.IsInCollision load_test_dataset = data_loader_r2d.load_test_dataset normalize = utility_r2d.normalize unnormalize = utility_r2d.unnormalize CAE = CAE_2d #MLP = model.MLP MLP = model_c2d_simple.MLP eval_tasks = gem_eval.eval_tasks args.world_size = [20., 20., np.pi] elif args.env_type == 'home': import plan_home, data_loader_home IsInCollision = plan_home.IsInCollision load_test_dataset = data_loader_home.load_test_dataset normalize = utility_home.normalize unnormalize = utility_home.unnormalize CAE = CAE_home_voxel_3 MLP = model_home.MLP eval_tasks = gem_eval_ompl.eval_tasks elif args.env_type == 'home_mlp2': import plan_home, data_loader_home IsInCollision = plan_home.IsInCollision load_test_dataset = data_loader_home.load_test_dataset normalize = utility_home.normalize unnormalize = utility_home.unnormalize CAE = CAE_home_voxel_3 MLP = model_home.MLP2 eval_tasks = gem_eval_ompl.eval_tasks elif args.env_type == 'home_mlp3': import plan_home, data_loader_home IsInCollision = plan_home.IsInCollision load_test_dataset = data_loader_home.load_test_dataset normalize = utility_home.normalize unnormalize = utility_home.unnormalize CAE = CAE_home_voxel_3 MLP = model_home.MLP3 eval_tasks = gem_eval_ompl.eval_tasks elif args.env_type == 'home_mlp4': import plan_home, data_loader_home IsInCollision = plan_home.IsInCollision load_test_dataset = data_loader_home.load_test_dataset normalize = utility_home.normalize unnormalize = utility_home.unnormalize CAE = CAE_home_voxel_2 MLP = model_home.MLP eval_tasks = gem_eval_ompl.eval_tasks elif args.env_type == 'home_mlp5': import plan_home, data_loader_home IsInCollision = plan_home.IsInCollision load_test_dataset = data_loader_home.load_test_dataset normalize = utility_home.normalize unnormalize = utility_home.unnormalize CAE = CAE_home_voxel_3 MLP = model_home.MLP4 eval_tasks = gem_eval_ompl.eval_tasks if args.memory_type == 'res': mpNet = End2EndMPNet(args.total_input_size, args.AE_input_size, args.mlp_input_size, \ args.output_size, 'deep', args.n_tasks, args.n_memories, args.memory_strength, args.grad_step, \ CAE, MLP) elif args.memory_type == 'rand': pass if not os.path.exists(args.model_path): os.makedirs(args.model_path) # load previously trained model if start epoch > 0 model_path = 'cmpnet_epoch_%d.pkl' % (args.start_epoch) if args.start_epoch > 0: load_net_state(mpNet, os.path.join(args.model_path, model_path)) torch_seed, np_seed, py_seed = load_seed( os.path.join(args.model_path, model_path)) # set seed after loading torch.manual_seed(torch_seed) np.random.seed(np_seed) random.seed(py_seed) if torch.cuda.is_available(): mpNet.cuda() mpNet.mlp.cuda() mpNet.encoder.cuda() if args.opt == 'Adagrad': mpNet.set_opt(torch.optim.Adagrad, lr=args.learning_rate) elif args.opt == 'Adam': mpNet.set_opt(torch.optim.Adam, lr=args.learning_rate) elif args.opt == 'SGD': mpNet.set_opt(torch.optim.SGD, lr=args.learning_rate, momentum=0.9) if args.start_epoch > 0: load_opt_state(mpNet, os.path.join(args.model_path, model_path)) # load train and test data print('loading...') if args.seen_N > 0: seen_test_data = load_test_dataset(N=args.seen_N, NP=args.seen_NP, s=args.seen_s, sp=args.seen_sp, folder=args.data_path) if args.unseen_N > 0: unseen_test_data = load_test_dataset(N=args.unseen_N, NP=args.unseen_NP, s=args.unseen_s, sp=args.unseen_sp, folder=args.data_path) # test # testing print('testing...') seen_test_suc_rate = 0. unseen_test_suc_rate = 0. T = 1 for _ in range(T): # unnormalize function normalize_func = lambda x: normalize(x, args.world_size) unnormalize_func = lambda x: unnormalize(x, args.world_size) # seen if args.seen_N > 0: if args.use_local_reorder: time_file = os.path.join( args.model_path, 'time_seen_epoch_%d_mlp_local_reorder.p' % (args.start_epoch)) else: time_file = os.path.join( args.model_path, 'time_seen_epoch_%d_mlp.p' % (args.start_epoch)) fes_path_, valid_path_ = eval_tasks(mpNet, seen_test_data, args.model_path, time_file, \ IsInCollision, normalize_func, unnormalize_func, \ time_flag=True, local_reorder_setting=args.use_local_reorder) valid_path = valid_path_.flatten() fes_path = fes_path_.flatten( ) # notice different environments are involved seen_test_suc_rate += float(fes_path.sum()) / valid_path.sum() # unseen if args.unseen_N > 0: if args.use_local_reorder: time_file = os.path.join( args.model_path, 'time_unseen_epoch_%d_mlp_local_reorder.p' % (args.start_epoch)) else: time_file = os.path.join( args.model_path, 'time_unseen_epoch_%d_mlp.p' % (args.start_epoch)) fes_path_, valid_path_ = eval_tasks(mpNet, unseen_test_data, args.model_path, time_file, \ IsInCollision, normalize_func, unnormalize_func, \ time_flag=True, local_reorder_setting=args.use_local_reorder) valid_path = valid_path_.flatten() fes_path = fes_path_.flatten( ) # notice different environments are involved unseen_test_suc_rate += float(fes_path.sum()) / valid_path.sum() if args.seen_N > 0: seen_test_suc_rate = seen_test_suc_rate / T if args.use_local_reorder: fname = os.path.join( args.model_path, 'seen_accuracy_epoch_%d_local_reorder.txt' % (args.start_epoch)) else: fname = os.path.join( args.model_path, 'seen_accuracy_epoch_%d.txt' % (args.start_epoch)) f = open(fname, 'w') f.write(str(seen_test_suc_rate)) f.close() if args.unseen_N > 0: unseen_test_suc_rate = unseen_test_suc_rate / T # Save the models if args.use_local_reorder: fname = os.path.join( args.model_path, 'unseen_accuracy_epoch_%d_local_reorder.txt' % (args.start_epoch)) else: fname = os.path.join( args.model_path, 'unseen_accuracy_epoch_%d.txt' % (args.start_epoch)) f = open(fname, 'w') f.write(str(unseen_test_suc_rate)) f.close()
def main(args): # set seed torch_seed = np.random.randint(low=0, high=1000) np_seed = np.random.randint(low=0, high=1000) py_seed = np.random.randint(low=0, high=1000) torch.manual_seed(torch_seed) np.random.seed(np_seed) random.seed(py_seed) # Build the models if torch.cuda.is_available(): torch.cuda.set_device(args.device) # decide dataloader, MLP, AE based on env_type if args.env_type == 's2d': load_dataset = data_loader_2d.load_dataset normalize = utility_s2d.normalize unnormalize = utility_s2d.unnormalize CAE = CAE_2d MLP = model.MLP elif args.env_type == 'c2d': load_dataset = data_loader_2d.load_dataset normalize = utility_c2d.normalize unnormalize = utility_c2d.unnormalize CAE = CAE_2d MLP = model_c2d_simple.MLP elif args.env_type == 'r3d': load_dataset = data_loader_r3d.load_dataset normalize = utility_r3d.normalize unnormalize = utility_r3d.unnormalize CAE = CAE_r3d MLP = model.MLP elif args.env_type == 'r2d': load_dataset = data_loader_r2d.load_dataset normalize = utility_r2d.normalize unnormalize = utility_r2d.unnormalize CAE = CAE_2d #MLP = model.MLP MLP = model_c2d.MLP args.world_size = [20., 20., np.pi] elif args.env_type == 'r2d_simple': load_dataset = data_loader_r2d.load_dataset normalize = utility_r2d.normalize unnormalize = utility_r2d.unnormalize CAE = CAE_2d #MLP = model.MLP MLP = model_c2d_simple.MLP args.world_size = [20., 20., np.pi] elif args.env_type == 'home': import data_loader_home load_dataset = data_loader_home.load_dataset normalize = utility_home.normalize unnormalize = utility_home.unnormalize CAE = CAE_home_voxel_3 MLP = model_home.MLP elif args.env_type == 'home_mlp2': import data_loader_home load_dataset = data_loader_home.load_dataset normalize = utility_home.normalize unnormalize = utility_home.unnormalize CAE = CAE_home_voxel_3 MLP = model_home.MLP2 elif args.env_type == 'home_mlp3': import data_loader_home load_dataset = data_loader_home.load_dataset normalize = utility_home.normalize unnormalize = utility_home.unnormalize CAE = CAE_home_voxel_3 MLP = model_home.MLP3 elif args.env_type == 'home_mlp4': import data_loader_home load_dataset = data_loader_home.load_dataset normalize = utility_home.normalize unnormalize = utility_home.unnormalize CAE = CAE_home_voxel_2 MLP = model_home.MLP elif args.env_type == 'home_mlp5': import data_loader_home load_dataset = data_loader_home.load_dataset normalize = utility_home.normalize unnormalize = utility_home.unnormalize CAE = CAE_home_voxel_3 MLP = model_home.MLP if args.memory_type == 'res': mpNet = End2EndMPNet(args.total_input_size, args.AE_input_size, args.mlp_input_size, \ args.output_size, 'deep', args.n_tasks, args.n_memories, args.memory_strength, args.grad_step, \ CAE, MLP) elif args.memory_type == 'rand': pass # setup loss if args.env_type == 's2d': loss_f = mpNet.loss elif args.env_type == 'c2d': loss_f = mpNet.loss elif args.env_type == 'r3d': loss_f = mpNet.loss elif args.env_type == 'r2d': loss_f = mpNet.loss elif args.env_type == 'r2d_simple': loss_f = mpNet.loss elif args.env_type == 'home': loss_f = mpNet.pose_loss elif args.env_type == 'home_mlp2': loss_f = mpNet.pose_loss elif args.env_type == 'home_mlp3': loss_f = mpNet.pose_loss elif args.env_type == 'home_mlp4': loss_f = mpNet.pose_loss elif args.env_type == 'home_mlp5': loss_f = mpNet.pose_loss if not os.path.exists(args.model_path): os.makedirs(args.model_path) # load previously trained model if start epoch > 0 model_path = 'cmpnet_epoch_%d.pkl' % (args.start_epoch) if args.start_epoch > 0: load_net_state(mpNet, os.path.join(args.model_path, model_path)) torch_seed, np_seed, py_seed = load_seed( os.path.join(args.model_path, model_path)) # set seed after loading torch.manual_seed(torch_seed) np.random.seed(np_seed) random.seed(py_seed) if torch.cuda.is_available(): mpNet.cuda() mpNet.mlp.cuda() mpNet.encoder.cuda() if args.opt == 'Adagrad': mpNet.set_opt(torch.optim.Adagrad, lr=args.learning_rate) elif args.opt == 'Adam': mpNet.set_opt(torch.optim.Adam, lr=args.learning_rate) elif args.opt == 'SGD': mpNet.set_opt(torch.optim.SGD, lr=args.learning_rate, momentum=0.9) elif args.opt == 'ASGD': mpNet.set_opt(torch.optim.ASGD, lr=args.learning_rate) if args.start_epoch > 0: load_opt_state(mpNet, os.path.join(args.model_path, model_path)) # load train and test data print('loading...') obs, path_data = load_dataset(N=args.no_env, NP=args.no_motion_paths, folder=args.data_path) # use some path data as validation set val_single_path_data = path_data[-100:] # for each batch of validation dataset, use 10 paths val_path_data = [] for i in range(len(val_single_path_data)): j = 0 dataset = [] targets = [] env_indices = [] while j < 10: idx = (i + j) % len(val_single_path_data) p_dataset, p_targets, p_env_indices = val_single_path_data[idx] dataset += p_dataset targets += p_targets env_indices += p_env_indices j += 1 val_path_data.append([dataset, targets, env_indices]) # set training data again path_data = path_data[:-100] # print out data length: print('length of validation data:') print(len(val_path_data)) print('length of path data:') print(len(path_data)) # Train the Models print('training...') writer_fname = 'cont_%s_%f_%s' % (args.env_type, args.learning_rate, args.opt) writer = SummaryWriter('./runs/' + writer_fname) record_loss = 0. record_i = 0 val_record_loss = 0. val_record_i = 0 for epoch in range(args.start_epoch + 1, args.num_epochs + 1): data_all = [] num_path_trained = 0 print('epoch' + str(epoch)) dataset, targets, env_indices = [], [], [] path_ct = 0 for i in range(0, len(path_data)): print('epoch: %d, training... path: %d' % (epoch, i + 1)) p_dataset, p_targets, p_env_indices = path_data[i] if len(p_dataset) == 0: # empty path continue dataset = p_dataset targets = p_targets env_indices = p_env_indices path_ct += 1 if path_ct % args.train_path != 0: continue # record data_all += list(zip(dataset, targets, env_indices)) bi = np.array(dataset).astype(np.float32) bobs = np.array(obs[env_indices]).astype(np.float32) #bi = np.concatenate( (obs[env_indices], dataset), axis=1).astype(np.float32) bt = targets bi = torch.FloatTensor(bi) bobs = torch.FloatTensor(bobs) bt = torch.FloatTensor(bt) bi, bt = normalize(bi, args.world_size), normalize( bt, args.world_size) mpNet.zero_grad() bi = to_var(bi) bobs = to_var(bobs) bt = to_var(bt) print('before training losses:') print(loss_f(mpNet(bi, bobs), bt)) mpNet.observe(0, bi, bobs, bt, loss_f=loss_f) print('after training losses:') loss = loss_f(mpNet(bi, bobs), bt) print(loss) num_path_trained += 1 record_loss += loss.data record_i += 1 if record_i % 100 == 0: writer.add_scalar('train_loss', record_loss / 100, record_i) record_loss = 0. ###################################### # loss on validation set # use 10 paths in validation dataset to calculate val loss val_dataset, val_targets, val_env_indices = val_path_data[ i % len(val_path_data)] dataset = val_dataset targets = val_targets env_indices = val_env_indices bi = np.array(dataset).astype(np.float32) bobs = np.array(obs[env_indices]).astype(np.float32) #bi = np.concatenate( (obs[env_indices], dataset), axis=1).astype(np.float32) bt = targets bi = torch.FloatTensor(bi) bobs = torch.FloatTensor(bobs) bt = torch.FloatTensor(bt) bi, bt = normalize(bi, args.world_size), normalize( bt, args.world_size) bi = to_var(bi) bobs = to_var(bobs) bt = to_var(bt) print('validation losses:') loss = loss_f(mpNet(bi, bobs), bt) print(loss) val_record_loss += loss.data val_record_i += 1 if val_record_i % 100 == 0: writer.add_scalar('val_loss', val_record_loss / 100, val_record_i) val_record_loss = 0. ###################################### # perform rehersal when certain number of batches have passed if args.freq_rehersal and num_path_trained % args.freq_rehersal == 0: print('rehersal...') sample = random.sample(data_all, args.batch_rehersal) dataset, targets, env_indices = list(zip(*sample)) dataset, targets, env_indices = list(dataset), list( targets), list(env_indices) bi = np.array(dataset).astype(np.float32) bobs = np.array(obs[env_indices]).astype(np.float32) bt = targets bi = torch.FloatTensor(bi) bobs = torch.FloatTensor(bobs) bt = torch.FloatTensor(bt) bi, bt = normalize(bi, args.world_size), normalize( bt, args.world_size) mpNet.zero_grad() bi = to_var(bi) bobs = to_var(bobs) bt = to_var(bt) mpNet.observe(0, bi, bobs, bt, False, loss_f=loss_f) # train but don't remember dataset, targets, env_indices = [], [], [] path_ct = 0 # Save the models if epoch > 0: model_path = 'cmpnet_epoch_%d.pkl' % (epoch) save_state(mpNet, torch_seed, np_seed, py_seed, os.path.join(args.model_path, model_path)) # test writer.export_scalars_to_json("./all_scalars.json") writer.close()
def main(args): # set seed torch_seed = np.random.randint(low=0, high=1000) np_seed = np.random.randint(low=0, high=1000) py_seed = np.random.randint(low=0, high=1000) torch.manual_seed(torch_seed) np.random.seed(np_seed) random.seed(py_seed) # Create model directory # Build the models if torch.cuda.is_available(): torch.cuda.set_device(args.device) # Depending on env type, load the planning function if args.env_type == 's2d': load_raw_dataset = data_loader_2d.load_raw_dataset IsInCollision = plan_s2d.IsInCollision normalize = utility_s2d.normalize unnormalize = utility_s2d.unnormalize CAE = CAE_2d MLP = model.MLP elif args.env_type == 'c2d': load_raw_dataset = data_loader_2d.load_raw_dataset IsInCollision = plan_c2d.IsInCollision normalize = utility_c2d.normalize unnormalize = utility_c2d.unnormalize CAE = CAE_2d MLP = model_c2d_simple.MLP elif args.env_type == 'r3d': load_raw_dataset = data_loader_r3d.load_raw_dataset IsInCollision = plan_r3d.IsInCollision normalize = utility_r3d.normalize unnormalize = utility_r3d.unnormalize CAE = CAE_r3d MLP = model.MLP elif args.env_type == 'r2d': # 3d state space load_raw_dataset = data_loader_r2d.load_raw_dataset IsInCollision = plan_r2d.IsInCollision normalize = utility_r2d.normalize unnormalize = utility_r2d.unnormalize CAE = CAE_2d #MLP = model.MLP MLP = model_c2d_simple.MLP args.world_size = [20., 20., np.pi] mpNet = End2EndMPNet(args.total_input_size, args.AE_input_size, args.mlp_input_size, \ args.output_size, 'deep', args.n_tasks, args.n_memories, args.memory_strength, args.grad_step, \ CAE, MLP) model_path = 'mpNet_cont_train_epoch_%d.pkl' % (args.start_epoch) if args.start_epoch > 0: load_net_state(mpNet, os.path.join(args.model_path, model_path)) torch_seed, np_seed, py_seed = load_seed( os.path.join(args.model_path, model_path)) # set seed after loading torch.manual_seed(torch_seed) np.random.seed(np_seed) random.seed(py_seed) if torch.cuda.is_available(): mpNet.cuda() mpNet.mlp.cuda() mpNet.encoder.cuda() if args.opt == 'Adagrad': mpNet.set_opt(torch.optim.Adagrad, lr=args.learning_rate) elif args.opt == 'Adam': mpNet.set_opt(torch.optim.Adam, lr=args.learning_rate) elif args.opt == 'SGD': mpNet.set_opt(torch.optim.SGD, lr=args.learning_rate, momentum=0.9) elif args.opt == 'ASGD': mpNet.set_opt(torch.optim.ASGD, lr=args.learning_rate) #mpNet.set_opt(torch.optim.Adagrad, lr=1e-2) if args.start_epoch > 0: load_opt_state(mpNet, os.path.join(args.model_path, model_path)) # load train and test data print('loading...') obc, obs, paths, path_lengths = load_raw_dataset(N=args.no_env, NP=args.no_motion_paths, folder=args.data_path) obs = torch.from_numpy(obs).type(torch.FloatTensor) # Pretrain the Models, we do this only before hybrid training # and we don't do this for several epochs # set the number of paths trained before hybrid training # so that in each epoch, the total number up to now will be shown num_path_trained = 0 num_trained_samples = 0 data_all = [] # will record all data, even for each epoch while num_path_trained < args.pretrain_path: # pretrain # randomly select one env, and one path i = np.random.randint(low=0, high=len(paths)) j = np.random.randint(low=0, high=len(paths[0])) if path_lengths[i][j] == 0: # if the length is zero, then no point training on that continue print('pretraining... env: %d, path: %d' % (i + 1, j + 1)) pretrain_path = paths[i][j][:path_lengths[i][j]] # numpy dataset, targets, env_indices = transformToTrain(pretrain_path, \ len(pretrain_path), obs[i], i) num_trained_samples += len(targets) data_all += list(zip(dataset, targets, env_indices)) bi = np.concatenate((obs[i].numpy().reshape(1, -1).repeat( len(dataset), axis=0), dataset), axis=1).astype(np.float32) bi = torch.FloatTensor(bi) bt = torch.FloatTensor(targets) # normalize input and target with world_size bi = normalize(bi, args.world_size) bt = normalize(bt, args.world_size) mpNet.zero_grad() bi = to_var(bi) bt = to_var(bt) mpNet.observe(bi, 0, bt) num_path_trained += 1 print('continual training...') for epoch in range(1, args.num_epochs + 1): # Unlike number of trained paths, we print time for each epoch independently time_env = [] print('epoch' + str(epoch)) for i in range(len(paths)): time_path = [] for j in range(len(paths[i])): print('epoch: %d, training... env: %d, path: %d' % (epoch, i + 1, j + 1)) if path_lengths[i][j] == 0: continue time0 = time.time() fp = False path = [torch.from_numpy(paths[i][j][0]).type(torch.FloatTensor),\ torch.from_numpy(paths[i][j][path_lengths[i][j]-1]).type(torch.FloatTensor)] step_sz = DEFAULT_STEP # hybrid train # Note that path are list of tensors for t in range(args.MAX_NEURAL_REPLAN): # adaptive step size on replanning attempts if (t == 2): step_sz = 1.2 elif (t == 3): step_sz = 0.5 elif (t > 3): step_sz = 0.1 normalize_func = lambda x: normalize(x, args.world_size) unnormalize_func = lambda x: unnormalize( x, args.world_size) path = neural_replan(mpNet, path, obc[i], obs[i], IsInCollision, \ normalize_func, unnormalize_func, t==0, step_sz=step_sz) path = lvc(path, obc[i], IsInCollision, step_sz=step_sz) if feasibility_check(path, obc[i], IsInCollision, step_sz=0.01): fp = True print('feasible, ok!') break if time.time() - time0 >= 2.: # if it takes too long, then treat as failure break print('number of samples trained up to now: %d' % (num_trained_samples)) print('number of paths trained up to now: %d' % (num_path_trained)) if not fp: print('using demonstration...') # since this is complete replan, we are using the finest step size normalize_func = lambda x: normalize(x, args.world_size) path, added_path = complete_replan_global(mpNet, path, paths[i][j], path_lengths[i][j], \ obc[i], obs[i], i, normalize_func, step_sz=0.01) data_all += added_path num_trained_samples += len(added_path) num_path_trained += 1 # perform rehersal when certain number of batches have passed if num_path_trained % args.freq_rehersal == 0 and len( data_all) > args.batch_rehersal: print('rehersal...') sample = random.sample(data_all, args.batch_rehersal) dataset, targets, env_indices = list(zip(*sample)) dataset, targets, env_indices = list(dataset), list( targets), list(env_indices) bi = np.concatenate((obs[env_indices], dataset), axis=1).astype(np.float32) bt = targets bi = torch.FloatTensor(bi) bt = torch.FloatTensor(bt) bi, bt = normalize(bi, args.world_size), normalize( bt, args.world_size) mpNet.zero_grad() bi = to_var(bi) bt = to_var(bt) mpNet.observe(bi, 0, bt, False) # train but don't remember else: # neural planning is feasible, then we just put that in our data_all list # for rehersal # if include_suc_path is turned on, then add it into all_data for rehersal if args.include_suc_path: # convert path to numpy first for transformation path = [p.numpy() for p in path] dataset, targets, env_indices = transformToTrain(path, \ len(path), obs[i], i) data_all += list(zip(dataset, targets, env_indices)) time_spent = time.time() - time0 time_path.append(time_spent) print('it takes time: %f s' % (time_spent)) time_env.append(time_path) print('number of samples trained in total: %d' % (num_trained_samples)) # Save the models if epoch > 0: model_path = 'mpNet_cont_train_epoch_%d.pkl' % (epoch) save_state(mpNet, torch_seed, np_seed, py_seed, os.path.join(args.model_path, model_path)) num_train_sample_record = args.model_path + 'num_trained_samples_epoch_%d.txt' % ( epoch) num_train_path_record = args.model_path + 'num_trained_paths_epoch_%d.txt' % ( epoch) f = open(num_train_sample_record, 'w') f.write('%d\n' % (num_trained_samples)) f.close() f = open(num_train_path_record, 'w') f.write('%d\n' % (num_path_trained)) f.close() pickle.dump( time_env, open(args.model_path + 'planning_time_epoch_%d.txt' % (epoch), "wb"))
def main(args): # set seed torch_seed = np.random.randint(low=0, high=1000) np_seed = np.random.randint(low=0, high=1000) py_seed = np.random.randint(low=0, high=1000) torch.manual_seed(torch_seed) np.random.seed(np_seed) random.seed(py_seed) # Build the models if torch.cuda.is_available(): torch.cuda.set_device(args.device) # setup evaluation function if args.env_type == 's2d': IsInCollision = plan_s2d.IsInCollision load_test_dataset = data_loader_2d.load_test_dataset normalize = utility_s2d.normalize unnormalize = utility_s2d.unnormalize CAE = CAE_2d MLP = model.MLP elif args.env_type == 'c2d': IsInCollision = plan_c2d.IsInCollision load_test_dataset = data_loader_2d.load_test_dataset normalize = utility_c2d.normalize unnormalize = utility_c2d.unnormalize CAE = CAE_2d MLP = model_c2d_simple.MLP elif args.env_type == 'r3d': IsInCollision = plan_r3d.IsInCollision load_test_dataset = data_loader_r3d.load_test_dataset normalize = utility_r3d.normalize unnormalize = utility_r3d.unnormalize CAE = CAE_r3d MLP = model.MLP elif args.env_type == 'r2d': IsInCollision = plan_r2d.IsInCollision load_test_dataset = data_loader_r2d.load_test_dataset normalize = utility_r2d.normalize unnormalize = utility_r2d.unnormalize CAE = CAE_2d #MLP = model.MLP MLP = model_c2d_simple.MLP args.world_size = [20., 20., np.pi] if args.memory_type == 'res': mpNet = End2EndMPNet(args.total_input_size, args.AE_input_size, args.mlp_input_size, \ args.output_size, 'deep', args.n_tasks, args.n_memories, args.memory_strength, args.grad_step, \ CAE, MLP) elif args.memory_type == 'rand': pass # load previously trained model if start epoch > 0 model_path = 'mpNet_cont_train_epoch_%d.pkl' % (args.start_epoch) if args.start_epoch > 0: print('loading previous model...') load_net_state(mpNet, os.path.join(args.model_path, model_path)) torch_seed, np_seed, py_seed = load_seed( os.path.join(args.model_path, model_path)) # set seed after loading torch.manual_seed(torch_seed) np.random.seed(np_seed) random.seed(py_seed) if torch.cuda.is_available(): mpNet.cuda() mpNet.mlp.cuda() mpNet.encoder.cuda() if args.opt == 'Adagrad': mpNet.set_opt(torch.optim.Adagrad, lr=args.learning_rate) elif args.opt == 'Adam': mpNet.set_opt(torch.optim.Adam, lr=args.learning_rate) elif args.opt == 'SGD': mpNet.set_opt(torch.optim.SGD, lr=args.learning_rate, momentum=0.9) elif args.opt == 'ASGD': mpNet.set_opt(torch.optim.ASGD, lr=args.learning_rate) if args.start_epoch > 0: load_opt_state(mpNet, os.path.join(args.model_path, model_path)) # load train and test data print('loading...') seen_test_data = load_test_dataset(N=args.seen_N, NP=args.seen_NP, s=args.seen_s, sp=args.seen_sp, folder=args.data_path) unseen_test_data = load_test_dataset(N=args.unseen_N, NP=args.unseen_NP, s=args.unseen_s, sp=args.unseen_sp, folder=args.data_path) # test # testing print('testing...') seen_test_suc_rate = 0. unseen_test_suc_rate = 0. T = 1 for _ in range(T): # unnormalize function normalize_func = lambda x: normalize(x, args.world_size) unnormalize_func = lambda x: unnormalize(x, args.world_size) # seen time_file = os.path.join( args.model_path, 'time_seen_epoch_%d_mlp.p' % (args.start_epoch)) fes_path_, valid_path_ = eval_tasks(mpNet, seen_test_data, time_file, IsInCollision, normalize_func, unnormalize_func) valid_path = valid_path_.flatten() fes_path = fes_path_.flatten( ) # notice different environments are involved seen_test_suc_rate += fes_path.sum() / valid_path.sum() # unseen time_file = os.path.join( args.model_path, 'time_unseen_epoch_%d_mlp.p' % (args.start_epoch)) fes_path_, valid_path_ = eval_tasks(mpNet, unseen_test_data, time_file, IsInCollision, normalize_func, unnormalize_func) valid_path = valid_path_.flatten() fes_path = fes_path_.flatten( ) # notice different environments are involved unseen_test_suc_rate += fes_path.sum() / valid_path.sum() seen_test_suc_rate = seen_test_suc_rate / T unseen_test_suc_rate = unseen_test_suc_rate / T # Save the models f = open( os.path.join(args.model_path, 'seen_accuracy_epoch_%d.txt' % (args.start_epoch)), 'w') f.write(str(seen_test_suc_rate)) f.close() f = open( os.path.join(args.model_path, 'unseen_accuracy_epoch_%d.txt' % (args.start_epoch)), 'w') f.write(str(unseen_test_suc_rate)) f.close()
def main(args): # set seed torch_seed = np.random.randint(low=0, high=1000) np_seed = np.random.randint(low=0, high=1000) py_seed = np.random.randint(low=0, high=1000) torch.manual_seed(torch_seed) np.random.seed(np_seed) random.seed(py_seed) # Build the models if torch.cuda.is_available(): torch.cuda.set_device(args.device) # decide dataloader, MLP, AE based on env_type if args.env_type == 's2d': load_train_dataset = data_loader_2d.load_train_dataset normalize = utility_s2d.normalize unnormalize = utility_s2d.unnormalize CAE = CAE_2d MLP = model.MLP elif args.env_type == 'c2d': load_dataset = data_loader_2d.load_dataset normalize = utility_c2d.normalize unnormalize = utility_c2d.unnormalize CAE = CAE_2d MLP = model_c2d_simple.MLP elif args.env_type == 'r3d': load_dataset = data_loader_r3d.load_dataset normalize = utility_r3d.normalize unnormalize = utility_r3d.unnormalize CAE = CAE_r3d MLP = model.MLP elif args.env_type == 'r2d': load_dataset = data_loader_r2d.load_dataset normalize = utility_r2d.normalize unnormalize = utility_r2d.unnormalize CAE = CAE_2d MLP = model_c2d.MLP args.world_size = [20., 20., np.pi] if args.memory_type == 'res': mpNet = End2EndMPNet(args.total_input_size, args.AE_input_size, args.mlp_input_size, \ args.output_size, 'deep', args.n_tasks, args.n_memories, args.memory_strength, args.grad_step, \ CAE, MLP) elif args.memory_type == 'rand': pass # load previously trained model if start epoch > 0 model_path='cmpnet_epoch_%d.pkl' %(args.start_epoch) if args.start_epoch > 0: load_net_state(mpNet, os.path.join(args.model_path, model_path)) torch_seed, np_seed, py_seed = load_seed(os.path.join(args.model_path, model_path)) # set seed after loading torch.manual_seed(torch_seed) np.random.seed(np_seed) random.seed(py_seed) if torch.cuda.is_available(): mpNet.cuda() mpNet.mlp.cuda() mpNet.encoder.cuda() mpNet.set_opt(torch.optim.Adagrad, lr=args.learning_rate) if args.start_epoch > 0: load_opt_state(mpNet, os.path.join(args.model_path, model_path)) # load train and test data print('loading...') obstacles, dataset, targets, env_indices = load_train_dataset(N=args.no_env, NP=args.no_motion_paths, folder=args.data_path) # Train the Models print('training...') for epoch in range(args.start_epoch+1,args.num_epochs+1): print('epoch' + str(epoch)) for i in range(0, len(dataset), 100): # randomly pick 100 data print('epoch: %d, training... path: %d' % (epoch, i+1)) # record bi = np.concatenate( (obstacles[env_indices[i:i+100]], dataset[i:i+100]), axis=1).astype(np.float32) bt = targets[i:i+100] bi = torch.FloatTensor(bi) bt = torch.FloatTensor(bt) bi, bt = normalize(bi, args.world_size), normalize(bt, args.world_size) mpNet.zero_grad() bi=to_var(bi) bt=to_var(bt) mpNet.observe(bi, 0, bt, False) print('losses:') print(mpNet.loss(mpNet(bi), bt)) #num_path_trained += 1 # Save the models if epoch > 0: model_path='cmpnet_epoch_%d.pkl' %(epoch) save_state(mpNet, torch_seed, np_seed, py_seed, os.path.join(args.model_path,model_path))
def main(args): # Set this value to export models for continual learning or batch training load_dataset = data_loader_home.load_dataset # Get the right architecture which was used for continual learning CAE = CAE_home_voxel_3 mlp = model_home.MLP2 # make the big model mpNet = End2EndMPNet(total_input_size=150008, AE_input_size=[1,32,32,32], mlp_input_size=78, \ output_size=7, AEtype='deep', n_tasks=1, n_memories=1, memory_strength=0.5, grad_step=1, \ CAE=CAE, MLP=mlp) # The model that performed well originally, load into the big end2end model model_path = args.model_path+args.model_name load_net_state(mpNet, model_path) # Get the weights from this model and create a copy of the weights in mlp_weights (to be copied over) MLP2 = mpNet.mlp MLP2.cuda() mlp_weights = MLP2.state_dict() # Save a copy of the encoder's state_dict() for loading into the annotated encoder later on encoder_to_copy = mpNet.encoder #encoder_to_copy.cuda() torch.save(encoder_to_copy.state_dict(), 'encoder2_save.pkl') # do everything for the MLP on the GPU device = torch.device('cuda:%d'%(args.device)) encoder = Encoder_home_Annotated() #encoder.cuda() # Create the annotated model MLP = MLP_home_Annotated(78,7) MLP.cuda() # Create the python model with the new layer names MLP_to_copy = MLP_home(78,7) MLP_to_copy.cuda() # Copy over the mlp_weights into the Python model with the new layer names MLP_to_copy = copyMLP(MLP_to_copy, mlp_weights) print("Saving models...") # Load the encoder weights onto the gpu and then save the Annotated model encoder.load_state_dict(torch.load('encoder2_save.pkl', map_location='cpu')) encoder.save("encoder_annotated_test_cpu_2.pt") # Save the Python model with the weights copied over and the new layer names in a temp file torch.save(MLP_to_copy.state_dict(), 'mlp_no_dropout.pkl') # Because the layer names now match, can immediately load this state_dict() into the annotated model and then save it #MLP.load_state_dict(torch.load('mlp_no_dropout.pkl', map_location=device)) MLP.load_state_dict(torch.load('mlp_no_dropout.pkl', map_location=device)) MLP.save("mlp_annotated_test_gpu_2.pt") # Everything from here below just tests both models to see if the outputs match obs, path_data = load_dataset(N=1, NP=1, folder=args.data_path) # write test case obs_test = np.array([0.1,1.2,3.0,2.5,1.4,5.2,3.4,-1.]) #obs_test = obs_test.reshape((1,2,2,2)) np.savetxt('obs_voxel_test.txt', obs_test, delimiter='\n', fmt='%f') # write obstacle to flattened vector representation, then later be loaded in the C++ obs_out = obs.flatten() np.savetxt('obs_voxel.txt', obs_out, delimiter='\n', fmt='%f') obs = torch.from_numpy(obs).type(torch.FloatTensor) obs = Variable(obs) # h = mpNet.encoder(obs) h = encoder(obs) path_data = np.array([-0.08007369, 0.32780212, -0.01338363, 0.00726194, 0.00430644, -0.00323558, 0.18593094, 0.13094018, 0.18499476, 0.3250918, 0.52175426, 0.07388325, -0.49999127, 0.52322733]) path_data = np.array([path_data]) path_data = torch.from_numpy(path_data).type(torch.FloatTensor) test_input = torch.cat((path_data, h.data.cpu()), dim=1).cuda() # for MPNet1.0 test_input = Variable(test_input) for i in range(5): test_output = mpNet.mlp(test_input) test_output_save = MLP(test_input) print("output %d: " % i) print(test_output.data) print(test_output_save.data)
def main(args): # set seed torch_seed = np.random.randint(low=0, high=1000) np_seed = np.random.randint(low=0, high=1000) py_seed = np.random.randint(low=0, high=1000) torch.manual_seed(torch_seed) np.random.seed(np_seed) random.seed(py_seed) # Build the models if torch.cuda.is_available(): torch.cuda.set_device(args.device) # decide dataloader, MLP, AE based on env_type if args.env_type == 's2d': load_train_dataset = data_loader_2d.load_train_dataset normalize = utility_s2d.normalize unnormalize = utility_s2d.unnormalize CAE = CAE_2d MLP = model.MLP elif args.env_type == 'c2d': load_dataset = data_loader_2d.load_dataset normalize = utility_c2d.normalize unnormalize = utility_c2d.unnormalize CAE = CAE_2d MLP = model_c2d_simple.MLP elif args.env_type == 'r3d': load_dataset = data_loader_r3d.load_dataset normalize = utility_r3d.normalize unnormalize = utility_r3d.unnormalize CAE = CAE_r3d MLP = model.MLP elif args.env_type == 'r2d': load_dataset = data_loader_r2d.load_dataset normalize = utility_r2d.normalize unnormalize = utility_r2d.unnormalize CAE = CAE_2d MLP = model_c2d.MLP args.world_size = [20., 20., np.pi] elif args.env_type == 'home': import data_loader_home load_train_dataset = data_loader_home.load_train_dataset normalize = utility_home.normalize unnormalize = utility_home.unnormalize CAE = CAE_home_voxel_3 MLP = model_home.MLP elif args.env_type == 'home_mlp2': import data_loader_home load_train_dataset = data_loader_home.load_train_dataset normalize = utility_home.normalize unnormalize = utility_home.unnormalize CAE = CAE_home_voxel_3 MLP = model_home.MLP2 elif args.env_type == 'home_mlp3': import data_loader_home load_train_dataset = data_loader_home.load_train_dataset normalize = utility_home.normalize unnormalize = utility_home.unnormalize CAE = CAE_home_voxel_3 MLP = model_home.MLP3 elif args.env_type == 'home_mlp4': import data_loader_home load_train_dataset = data_loader_home.load_train_dataset normalize = utility_home.normalize unnormalize = utility_home.unnormalize CAE = CAE_home_voxel_3 MLP = model_home.MLP4 elif args.env_type == 'home_mlp5': import data_loader_home load_train_dataset = data_loader_home.load_train_dataset normalize = utility_home.normalize unnormalize = utility_home.unnormalize CAE = CAE_home_voxel_3 MLP = model_home.MLP5 if args.memory_type == 'res': mpNet = End2EndMPNet(args.total_input_size, args.AE_input_size, args.mlp_input_size, \ args.output_size, 'deep', args.n_tasks, args.n_memories, args.memory_strength, args.grad_step, \ CAE, MLP) elif args.memory_type == 'rand': pass # setup loss if args.env_type == 's2d': loss_f = mpNet.loss elif args.env_type == 'c2d': loss_f = mpNet.loss elif args.env_type == 'r3d': loss_f = mpNet.loss elif args.env_type == 'r2d': loss_f = mpNet.loss elif args.env_type == 'r2d_simple': loss_f = mpNet.loss elif args.env_type == 'home': loss_f = mpNet.pose_loss elif args.env_type == 'home_mlp2': loss_f = mpNet.pose_loss elif args.env_type == 'home_mlp3': loss_f = mpNet.pose_loss elif args.env_type == 'home_mlp4': loss_f = mpNet.pose_loss elif args.env_type == 'home_mlp5': loss_f = mpNet.pose_loss if not os.path.exists(args.model_path): os.makedirs(args.model_path) # load previously trained model if start epoch > 0 model_path = 'batch_mpnet_epoch_%d.pkl' % (args.start_epoch) if args.start_epoch > 0: load_net_state(mpNet, os.path.join(args.model_path, model_path)) torch_seed, np_seed, py_seed = load_seed( os.path.join(args.model_path, model_path)) # set seed after loading torch.manual_seed(torch_seed) np.random.seed(np_seed) random.seed(py_seed) if torch.cuda.is_available(): mpNet.cuda() mpNet.mlp.cuda() mpNet.encoder.cuda() if args.opt == 'Adagrad': mpNet.set_opt(torch.optim.Adagrad, lr=args.learning_rate) elif args.opt == 'Adam': mpNet.set_opt(torch.optim.Adam, lr=args.learning_rate) elif args.opt == 'SGD': mpNet.set_opt(torch.optim.SGD, lr=args.learning_rate, momentum=0.9) elif args.opt == 'ASGD': mpNet.set_opt(torch.optim.ASGD, lr=args.learning_rate) if args.start_epoch > 0: load_opt_state(mpNet, os.path.join(args.model_path, model_path)) # load train and test data print('loading...') obstacles, dataset, targets, env_indices = load_train_dataset( N=args.no_env, NP=args.no_motion_paths, folder=args.data_path) val_size = 1000 val_dataset = dataset[:-val_size] val_targets = targets[:-val_size] val_env_indices = env_indices[:-val_size] # Train the Models print('training...') writer_fname = '%s_%f_%s' % (args.env_type, args.learning_rate, args.opt) writer = SummaryWriter('./runs/' + writer_fname) record_loss = 0. record_i = 0 val_record_loss = 0. val_record_i = 0 for epoch in range(args.start_epoch + 1, args.num_epochs + 1): print('epoch' + str(epoch)) for i in range(0, len(dataset), args.batch_size): # randomly pick 100 data print('epoch: %d, training... path: %d' % (epoch, i + 1)) # record #bi = np.concatenate( (obstacles[env_indices[i:i+100]], dataset[i:i+100]), axis=1).astype(np.float32) bi = np.array(dataset[i:i + args.batch_size]).astype(np.float32) bobs = np.array(obstacles[env_indices[i:i + args.batch_size]]).astype( np.float32) bt = targets[i:i + args.batch_size] bi = torch.FloatTensor(bi) bobs = torch.FloatTensor(bobs) bt = torch.FloatTensor(bt) bi, bt = normalize(bi, args.world_size), normalize( bt, args.world_size) mpNet.zero_grad() bi = to_var(bi) bobs = to_var(bobs) bt = to_var(bt) print('before training losses:') print(loss_f(mpNet(bi, bobs), bt)) mpNet.observe(0, bi, bobs, bt, False, loss_f=loss_f) print('after training losses:') loss = loss_f(mpNet(bi, bobs), bt) print(loss) record_loss += loss.data record_i += 1 if record_i % 100 == 0: writer.add_scalar('train_loss', record_loss / 100, record_i) record_loss = 0. ###################################### # loss on validation set idx = i % val_size bi = np.array(val_dataset[idx:idx + 100]).astype(np.float32) bobs = np.array(obstacles[val_env_indices[idx:idx + 100]]).astype( np.float32) bt = val_targets[idx:idx + 100] bi = torch.FloatTensor(bi) bobs = torch.FloatTensor(bobs) bt = torch.FloatTensor(bt) bi, bt = normalize(bi, args.world_size), normalize( bt, args.world_size) mpNet.zero_grad() bi = to_var(bi) bobs = to_var(bobs) bt = to_var(bt) print('validation losses:') loss = loss_f(mpNet(bi, bobs), bt) print(loss) val_record_loss += loss.data val_record_i += 1 if val_record_i % 100 == 0: writer.add_scalar('val_loss', val_record_loss / 100, val_record_i) val_record_loss = 0. # Save the models every 50 epochs if epoch % 50 == 0: model_path = 'mpnet_epoch_%d.pkl' % (epoch) save_state(mpNet, torch_seed, np_seed, py_seed, os.path.join(args.model_path, model_path)) # test writer.export_scalars_to_json("./all_scalars.json") writer.close()