text
stringlengths 0
93.6k
|
---|
"y-axis-title": "Success rate",},)
|
return auc, wandb_plot
|
hl_auc, hl_plot = _get_auc(steps=hl_steps, task_success=task_success, max_x=max_hl_steps, title="High-level-step-curve")
|
wandb.log({"efficiency_curve_high_level_steps": hl_plot, "hl_auc": hl_auc})
|
ll_auc_max_steps = 5000
|
ll_auc, ll_plot = _get_auc(steps=ll_steps, task_success=task_success, max_x=ll_auc_max_steps, title="Low-level-step-curve")
|
wandb.log({"efficiency_curve_low_level_steps": ll_plot, "ll_auc": ll_auc})
|
ll_auc_gtDone, ll_plot_gtDone = _get_auc(steps=ll_steps_gtDone, task_success=task_success_gtDone, max_x=ll_auc_max_steps, title="Low-level-step-curve-gtDone")
|
wandb.log({"efficiency_curve_low_level_steps_gtDone": ll_plot_gtDone, "ll_auc_gtDone": ll_auc_gtDone})
|
def calculcate_metric_means(episode_infos):
|
columns = sorted(list(episode_infos.values())[0][0].keys())
|
scene_logs = defaultdict(dict)
|
for scene_id in sorted(episode_infos.keys()):
|
for column in columns:
|
if isinstance(episode_infos[scene_id][0].get(column, None), str):
|
continue
|
elif isinstance(episode_infos[scene_id][0].get(column, None), (np.ScalarType)):
|
d = np.nanmean([e.get(column, np.nan) for e in episode_infos[scene_id]])
|
# NOTE: if value is not defined for an episode, we take the mean over those that have the value!
|
# e,g, [steps]_gtDone are only defined for successful episodes
|
scene_logs[scene_id][column] = d
|
else:
|
continue
|
print(column, d)
|
return scene_logs
|
def log_summary_table(episode_infos):
|
def _check_float(v):
|
try:
|
float(v)
|
return True
|
except:
|
return False
|
scene_logs = calculcate_metric_means(episode_infos)
|
data = []
|
scenes = list(scene_logs.keys())
|
columns = ["scene_id"]
|
for k in scene_logs[scenes[0]].keys():
|
# only take metrics that exist for all scenes
|
if all([k in scene_logs[s] for s in scenes]):
|
columns.append(k)
|
for scene_id in sorted(scenes):
|
data.append([scene_id] + [scene_logs[scene_id][c] for c in columns[1:]])
|
avg_row = ["Overall avg"]
|
avg_dict = {}
|
for i, column_values in enumerate(np.array(data).T):
|
if _check_float(column_values[0]):
|
d = np.mean(column_values.astype(float))
|
avg_dict[f"avg_{columns[i]}"] = d
|
avg_row.append(str(d))
|
data.append(avg_row)
|
avg_dict["overview_table"] = wandb.Table(columns=columns, data=np.array(data).astype(str))
|
wandb.log(avg_dict)
|
def evaluate_scene(config_file: str, cfg, scene_id: str, tot_ep: int) -> list:
|
episode_infos = []
|
high_level_env = create_env(cfg, agent=cfg["agent"], config_file=config_file, scene_id=scene_id, control_freq=cfg["control_freq"], cheap=cfg["cheap"], seed=cfg["seed"])
|
for i in range(cfg["num_episodes_per_scene"]):
|
done = False
|
obs = high_level_env.reset(config_file=config_file, scene_id=scene_id, episode_num=i)
|
print("########################################")
|
print(f"{scene_id} - Starting episode {i + 1} in scene {scene_id}, {tot_ep + 1} overall. Task: {high_level_env.unwrapped.task.task_description}")
|
print("########################################")
|
while not done:
|
high_level_env.visualize(obs)
|
done, task_success, episode_info = high_level_env.take_action(obs=obs, task_description=high_level_env.unwrapped.task.task_description)
|
# env adds last action to the figure title, that's why we log it after the env step
|
wandb.log({"bev_maps": high_level_env.unwrapped.f})
|
obs = high_level_env.get_state(compute_scene_graph=True)
|
pprint(episode_info)
|
high_level_env.visualize(obs)
|
if "failure_reason" in episode_info:
|
high_level_env.env.f.suptitle(f"{high_level_env.env.f._suptitle.get_text()}, {episode_info['failure_reason']}")
|
episode_info["bev_maps"] = high_level_env.unwrapped.f
|
episode_info["num_low_level_steps_with_open_cost"] = episode_info["num_low_level_steps"] + high_level_env.env.config["magic_open_cost"] * episode_info["magic_open_actions"]
|
if episode_info.get("num_low_level_steps_gtDone", None) is not None:
|
episode_info["num_low_level_steps_with_open_cost_gtDone"] = episode_info["num_low_level_steps_gtDone"] + high_level_env.env.config["magic_open_cost"] * episode_info["magic_open_actions_gtDone"]
|
episode_info["task_success_gtDone"] = True
|
else:
|
episode_info["num_low_level_steps_with_open_cost_gtDone"] = episode_info["num_low_level_steps_with_open_cost"]
|
episode_info["task_success_gtDone"] = task_success
|
episode_info["episode_step"] = tot_ep
|
episode_info["spl"] = episode_info["task_success"] * (episode_info["shortest_dist"] / max(episode_info["shortest_dist"], episode_info["dist_travelled"]))
|
pprint(episode_info)
|
# episode_info["rgb"] = wandb.Video((255 * np.transpose(np.stack(high_level_env.env.rgb_frames, axis=0), (0, 3, 1, 2))).astype(np.uint8), fps=6)
|
wandb.log({k: float(v) if isinstance(v, bool) else v for k, v in episode_info.items()})
|
episode_infos.append(episode_info)
|
successes = [e["task_success"] for e in episode_infos]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.