def test_get_trajs_from_data_2020_featurize(self):
# Ensure we can properly featurize states with updated dynamics and updated objects (i.e tomatoes)
params = copy.deepcopy(self.base_get_trajs_from_data_params)
params['layouts'] = ['inverse_marshmallow_experiment']
params['data_path'] = DUMMY_2020_CLEAN_HUMAN_DATA_PATH
params['featurize_states'] = True
trajectories, _ = get_trajs_from_data(**params)
def load_data(bc_params, verbose):
predict_orders = bc_params.get("predict_orders",
DEFAULT_BC_PARAMS["predict_orders"])
processed_trajs, _ = get_trajs_from_data(**bc_params["data_params"],
silent=not verbose,
include_orders=predict_orders)
observations, actions = processed_trajs[
"ep_observations"], processed_trajs["ep_actions"],
if predict_orders:
orders = processed_trajs["ep_orders"]
else:
orders = None
if bc_params['use_lstm']:
ep_lens = np.array([len(ob) for ob in observations])
observations = _pad(observations,
default=np.zeros(bc_params['observation_shape']))
observations = np.moveaxis(np.stack(np.moveaxis(observations, 0, 2)),
2, 0)
actions = _pad(actions, default=np.zeros(1))
actions = np.dstack(actions).transpose((2, 0, 1))
if predict_orders:
orders = _pad(orders, default=np.zeros(bc_params["orders_shape"]))
orders = np.moveaxis(np.stack(np.moveaxis(orders, 0, 2)), 2, 0)
else:
observations = np.vstack(observations)
ep_lens = None # not used in non recurrent networks
actions = np.vstack(actions)
if predict_orders: orders = np.vstack(orders)
return observations, ep_lens, actions, orders
def symmetric_bc(model_savename,
bc_params,
num_epochs=1000,
lr=1e-4,
adam_eps=1e-8):
"""DEPRECATED: Trains two BC models from the same data. Splits data 50-50 and uses each subset as training data for
one model and validation for the other."""
expert_trajs = get_trajs_from_data(bc_params["data_params"])
save_npz_file(expert_trajs, "temp")
train_dataset = ExpertDataset(expert_path="temp",
verbose=1,
train_fraction=0.5)
train_indices = train_dataset.train_loader.original_indices
val_indices = train_dataset.val_loader.original_indices
# Train BC model
train_model_save_dir = model_savename + "_train/"
bc_from_dataset_and_params(train_dataset, bc_params, train_model_save_dir,
num_epochs, lr, adam_eps)
# Switching testing and validation datasets (somewhat hacky)
indices_split = (val_indices, train_indices)
test_dataset = ExpertDataset(expert_path="temp",
verbose=1,
train_fraction=0.5,
indices_split=indices_split)
# Test BC model
test_model_save_dir = model_savename + "_test/"
bc_from_dataset_and_params(test_dataset, bc_params, test_model_save_dir,
num_epochs, lr, adam_eps)
def test_csv_to_df_to_trajs_integration(self):
# Ensure the output of 'csv_to_df_pickle' works as valid input to 'get_trajs_from_data'
params = copy.deepcopy(self.base_csv_to_df_params)
_ = csv_to_df_pickle(**params)
params = copy.deepcopy(self.base_get_trajs_from_data_params)
params['data_path'] = os.path.join(self.temp_data_dir,
'unittest_all.pickle')
params['layouts'] = ['inverse_marshmallow_experiment']
_ = get_trajs_from_data(**params)
def train_bc_agent(model_save_dir, bc_params, num_epochs=1000, lr=1e-4, adam_eps=1e-8):
# Extract necessary expert data and save in right format
expert_trajs = get_trajs_from_data(**bc_params["data_params"])
# Load the expert dataset
save_npz_file(expert_trajs, "temp.npz")
dataset = ExpertDataset(expert_path="temp.npz", verbose=1, train_fraction=0.85)
assert dataset is not None
assert dataset.train_loader is not None
return bc_from_dataset_and_params(dataset, bc_params, model_save_dir, num_epochs, lr, adam_eps)
def load_data(bc_params, verbose):
processed_trajs, _ = get_trajs_from_data(**bc_params["data_params"],
silent=not verbose)
inputs, targets = processed_trajs["ep_observations"], processed_trajs[
"ep_actions"]
if bc_params['use_lstm']:
seq_lens = np.array([len(seq) for seq in inputs])
seq_padded = _pad(inputs, default=np.zeros((len(inputs[0][0], ))))
targets_padded = _pad(targets, default=np.zeros(1))
seq_t = np.dstack(seq_padded).transpose((2, 0, 1))
targets_t = np.dstack(targets_padded).transpose((2, 0, 1))
return seq_t, seq_lens, targets_t
else:
return np.vstack(inputs), None, np.vstack(targets)
def setUp(self):
set_global_seed(0)
self.bc_params = get_default_bc_params()
self.bc_params["mdp_params"]["layout_name"] = "cramped_room"
self.bc_params["training_params"]["epochs"] = 1
self.model_dir = os.path.join(BC_SAVE_DIR, "test_model")
if not os.path.exists(self.model_dir):
os.makedirs(self.model_dir)
processed_trajs, _ = get_trajs_from_data(**
self.bc_params["data_params"],
silent=True)
self.dummy_input = np.vstack(processed_trajs["ep_observations"])[:1, :]
self.initial_states = [
np.zeros((1, self.bc_params['cell_size'])),
np.zeros((1, self.bc_params['cell_size']))
]
with open(BC_EXPECTED_DATA_PATH, "rb") as f:
self.expected = pickle.load(f)
def setUp(self):
set_global_seed(0)
self.bc_params = get_bc_params(
**{"data_path": DUMMY_2019_CLEAN_HUMAN_DATA_PATH})
self.bc_params["mdp_params"]["layout_name"] = "cramped_room"
self.bc_params["training_params"]["epochs"] = 1
self.model_dir = os.path.join(BC_SAVE_DIR, "test_model")
if not os.path.exists(self.model_dir):
os.makedirs(self.model_dir)
processed_trajs, _ = get_trajs_from_data(**
self.bc_params["data_params"],
silent=True)
self.dummy_input = np.vstack(processed_trajs["ep_states"])[:1, :]
self.initial_states = [
np.zeros((1, self.bc_params['cell_size'])),
np.zeros((1, self.bc_params['cell_size']))
]
with open(BC_EXPECTED_DATA_PATH, "rb") as f:
self.expected = pickle.load(f)
# Disable TF warnings and infos
tf.get_logger().setLevel('ERROR')
def test_get_trajs_from_data_2019_featurize(self):
params = copy.deepcopy(self.base_get_trajs_from_data_params)
params['featurize_states'] = True
trajectories, _ = get_trajs_from_data(**params)
def test_get_trajs_from_data_2019(self):
params = copy.deepcopy(self.base_get_trajs_from_data_params)
trajectories, _ = get_trajs_from_data(**params)
def get_dummy_input(bc_params):
#NOTE: can add caching if too slow, see: https://stackoverflow.com/questions/6358481/using-functools-lru-cache-with-dictionary-arguments
# no processing orders as they won't be used anyway
processed_trajs, _ = get_trajs_from_data(**bc_params["data_params"], include_orders=False, silent=True)
return np.vstack(processed_trajs["ep_observations"])[:1, :]
