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()