def test_mdp_serialization(self):
# Where to store serialized states -- will be overwritten each timestep
dummy_path = os.path.join(TESTING_DATA_DIR, 'test_mdp_serialization',
'dummy.json')
# Get starting seed and random agent pair
seed = 47
random_pair = AgentPair(RandomAgent(all_actions=True),
RandomAgent(all_actions=True))
# Run rollouts with different seeds until sparse reward is achieved
sparse_reward = 0
while sparse_reward <= 0:
np.random.seed(seed)
state = self.base_mdp.get_standard_start_state()
for _ in range(1500):
# Ensure serialization and deserializations are inverses
reconstructed_state = OvercookedState.from_dict(
load_from_json(save_as_json(state.to_dict(), dummy_path)))
self.assertEqual(
state, reconstructed_state,
"\nState: \t\t\t{}\nReconstructed State: \t{}".format(
state, reconstructed_state))
# Advance state
joint_action, _ = zip(*random_pair.joint_action(state))
state, infos = self.base_mdp.get_state_transition(
state, joint_action)
sparse_reward += sum(infos['sparse_reward_by_agent'])
seed += 1
def check_transition(action, expected_path, recompute=False):
# Compute actual values
state = env.state
pred_state, _ = self.base_mdp.get_state_transition(state, action)
new_state, sparse_reward, _, _ = env.step(action)
self.assertEqual(pred_state, new_state,
'\n' + str(pred_state) + '\n' + str(new_state))
# Recompute expected values if desired
if recompute:
actual = {
"state": pred_state.to_dict(),
"reward": sparse_reward
}
save_as_json(actual, expected_path)
# Compute expected values
expected = load_from_json(expected_path)
expected_state = OvercookedState.from_dict(expected['state'])
expected_reward = expected['reward']
# Make sure everything lines up (note __eq__ is transitive)
self.assertTrue(
pred_state.time_independent_equal(expected_state),
'\n' + str(pred_state) + '\n' + str(expected_state))
self.assertEqual(sparse_reward, expected_reward)
def load_dict_from_unknown_filetype(filepath):
try:
# json.load
return load_from_json(filepath)
except:
# eval of str from file
return load_dict_from_file(filepath)
def setUp(self):
Recipe.configure({})
trajectory_path = os.path.join(TESTING_DATA_DIR, "test_visualizations",
"trajectory.json")
events_path = os.path.join(TESTING_DATA_DIR, "test_visualizations",
"expected_extracted_events.json")
self.trajectory1 = AgentEvaluator.load_traj_from_json(trajectory_path)
self.extracted_events1 = load_from_json(events_path)
def test_start_positions(self):
actual_start_state = self.base_mdp.get_standard_start_state()
expected_state_path = os.path.join(TESTING_DATA_DIR, "test_start_positions", "expected.json")
# NOTE: Uncomment the following line if expected start state deliberately changed
# save_as_json(actual_start_state.to_dict(), expected_state_path)
expected_start_state = OvercookedState.from_dict(load_from_json(expected_state_path))
self.assertEqual(actual_start_state, expected_start_state, '\n' + str(actual_start_state) + '\n' + str(expected_start_state))
def load_traj_from_json(filename):
traj_dict = load_from_json(filename)
traj_dict["ep_states"] = [[
OvercookedState.from_dict(ob) for ob in curr_ep_obs
] for curr_ep_obs in traj_dict["ep_states"]]
traj_dict["ep_actions"] = [[
tuple(tuple(a) if type(a) is list else a for a in j_a)
for j_a in ep_acts
] for ep_acts in traj_dict["ep_actions"]]
return traj_dict
def test_default_hud_data_from_trajectories(self):
traj_path = os.path.join(
TESTING_DATA_DIR, 'test_state_visualizer', 'test_trajectory.json'
) # NOTE: for test purposes reward is added here despite there was no soup delivery in trajectory
test_trajectory = AgentEvaluator.load_traj_from_json(traj_path)
hud_data_path = os.path.join(
TESTING_DATA_DIR, 'test_state_visualizer',
'expected_default_hud_data_from_trajectories.json')
expected_hud_data = load_from_json(hud_data_path)
result_hud_data = StateVisualizer().default_hud_data_from_trajectories(
test_trajectory)
self.assertEqual(json.dumps(result_hud_data, sort_keys=True),
json.dumps(expected_hud_data, sort_keys=True))
def load_frames_rectangles(json_path):
frames_json = load_from_json(json_path)
if "textures" in frames_json.keys(): # check if its format of soups.json
assert frames_json["textures"][0]["scale"] == 1 # not implemented support for scale here
frames = frames_json["textures"][0]["frames"]
else: # assume its format of objects.json, terrain.json and chefs.json
frames = []
for filename, frame_dict in frames_json["frames"].items():
frame_dict["filename"] = filename
frames.append(frame_dict)
result = {}
for frame_dict in frames:
assert not frame_dict.get("rotated") # not implemented support yet
assert not frame_dict.get("trimmed") # not implemented support yet
frame_name = frame_dict["filename"].split(".")[0]
frame = frame_dict["frame"]
rect = pygame.Rect(frame["x"], frame["y"], frame["w"], frame["h"])
result[frame_name] = rect
return result
def on_trajectory_selected(data):
traj_idx = int(data["trajectory_idx"] or 0)
trajectory_path = os.path.join(TRAJECTORIES_DIR, data["trajectory_file"])
trajectories = AgentEvaluator.load_traj_from_json(trajectory_path)
trajectories_json = load_from_json(trajectory_path)
trajectory_states = trajectories_json["ep_states"][traj_idx]
trajectory_rewards = trajectories_json["ep_rewards"][traj_idx]
scores = cumulative_rewards_from_rew_list(trajectory_rewards)
states = [{"state":state, "time_left": time_left, "score": score} for state, score, time_left in zip(trajectory_states, scores, reversed(range(len(trajectory_states))))]
terrain = trajectories_json["mdp_params"][traj_idx]["terrain"]
settings = copy.deepcopy(DEFAULT_EVENT_CHART_SETTINGS)
settings["show_cumulative_data"] = False
settings["chart_box_view_box"] = "0 0 800 150"
start_info = {
"terrain": terrain,
"state": states[0]
}
socketio.emit("replay_trajectory", {"start_info": start_info,
"states": states,
"max_trajectory_idx": len(trajectories["ep_states"])-1,
"trajectory_chart_events": extract_events(trajectories, traj_idx),
"trajectory_chart_settings": settings})
def test_temporary_orders_display(self):
for d in load_from_json(
os.path.join(
state_visualizer_dir,
"render_state_data_test_temporary_orders_display.json")):
test_render_state_from_dict(d)
def test_generated_layout_states(self):
for d in load_from_json(
os.path.join(state_visualizer_dir,
"render_state_data_test_generated_layout.json")):
test_render_state_from_dict(d)
def test_various_states(self):
for d in load_from_json(
os.path.join(state_visualizer_dir,
"render_state_data_test_various.json")):
test_render_state_from_dict(d)
def test_cooking_timer_display(self):
for d in load_from_json(
os.path.join(state_visualizer_dir,
"render_state_data_test_cooking_display.json")):
test_render_state_from_dict(d)
def load_traj_from_json(filename):
AgentEvaluator._configure_recipe_if_needed()
traj_dict = load_from_json(filename)
return AgentEvaluator.load_traj_from_json_obj(traj_dict)
