jblitzar/github-python · Datasets at Hugging Face

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]

"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]