add evaluation agents and some example configs
This commit is contained in:
allenzren
@@ -0,0 +1,116 @@
|
||||
"""
|
||||
Parent eval agent class.
|
||||
|
||||
"""
|
||||
|
||||
import os
|
||||
import numpy as np
|
||||
import torch
|
||||
import hydra
|
||||
import logging
|
||||
import random
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
from env.gym_utils import make_async
|
||||
|
||||
|
||||
class EvalAgent:
|
||||
|
||||
def __init__(self, cfg):
|
||||
super().__init__()
|
||||
self.cfg = cfg
|
||||
self.device = cfg.device
|
||||
self.seed = cfg.get("seed", 42)
|
||||
random.seed(self.seed)
|
||||
np.random.seed(self.seed)
|
||||
torch.manual_seed(self.seed)
|
||||
|
||||
# Make vectorized env
|
||||
self.env_name = cfg.env.name
|
||||
env_type = cfg.env.get("env_type", None)
|
||||
self.venv = make_async(
|
||||
cfg.env.name,
|
||||
env_type=env_type,
|
||||
num_envs=cfg.env.n_envs,
|
||||
asynchronous=True,
|
||||
max_episode_steps=cfg.env.max_episode_steps,
|
||||
wrappers=cfg.env.get("wrappers", None),
|
||||
robomimic_env_cfg_path=cfg.get("robomimic_env_cfg_path", None),
|
||||
shape_meta=cfg.get("shape_meta", None),
|
||||
use_image_obs=cfg.env.get("use_image_obs", False),
|
||||
render=cfg.env.get("render", False),
|
||||
render_offscreen=cfg.env.get("save_video", False),
|
||||
obs_dim=cfg.obs_dim,
|
||||
action_dim=cfg.action_dim,
|
||||
**cfg.env.specific if "specific" in cfg.env else {},
|
||||
)
|
||||
if not env_type == "furniture":
|
||||
self.venv.seed(
|
||||
[self.seed + i for i in range(cfg.env.n_envs)]
|
||||
) # otherwise parallel envs might have the same initial states!
|
||||
# isaacgym environments do not need seeding
|
||||
self.n_envs = cfg.env.n_envs
|
||||
self.n_cond_step = cfg.cond_steps
|
||||
self.obs_dim = cfg.obs_dim
|
||||
self.action_dim = cfg.action_dim
|
||||
self.act_steps = cfg.act_steps
|
||||
self.horizon_steps = cfg.horizon_steps
|
||||
self.max_episode_steps = cfg.env.max_episode_steps
|
||||
self.reset_at_iteration = cfg.env.get("reset_at_iteration", True)
|
||||
self.furniture_sparse_reward = (
|
||||
cfg.env.specific.get("sparse_reward", False)
|
||||
if "specific" in cfg.env
|
||||
else False
|
||||
) # furniture specific, for best reward calculation
|
||||
|
||||
# Build model and load checkpoint
|
||||
self.model = hydra.utils.instantiate(cfg.model)
|
||||
|
||||
# Eval params
|
||||
self.n_steps = cfg.n_steps
|
||||
self.best_reward_threshold_for_success = (
|
||||
len(self.venv.pairs_to_assemble)
|
||||
if env_type == "furniture"
|
||||
else cfg.env.best_reward_threshold_for_success
|
||||
)
|
||||
|
||||
# Logging, rendering
|
||||
self.logdir = cfg.logdir
|
||||
self.render_dir = os.path.join(self.logdir, "render")
|
||||
self.result_path = os.path.join(self.logdir, "result.npz")
|
||||
os.makedirs(self.render_dir, exist_ok=True)
|
||||
self.n_render = cfg.render_num
|
||||
self.render_video = cfg.env.get("save_video", False)
|
||||
assert self.n_render <= self.n_envs, "n_render must be <= n_envs"
|
||||
assert not (
|
||||
self.n_render <= 0 and self.render_video
|
||||
), "Need to set n_render > 0 if saving video"
|
||||
|
||||
def run(self):
|
||||
pass
|
||||
|
||||
def reset_env_all(self, verbose=False, options_venv=None, **kwargs):
|
||||
if options_venv is None:
|
||||
options_venv = [
|
||||
{k: v for k, v in kwargs.items()} for _ in range(self.n_envs)
|
||||
]
|
||||
obs_venv = self.venv.reset_arg(options_list=options_venv)
|
||||
# convert to OrderedDict if obs_venv is a list of dict
|
||||
if isinstance(obs_venv, list):
|
||||
obs_venv = {
|
||||
key: np.stack([obs_venv[i][key] for i in range(self.n_envs)])
|
||||
for key in obs_venv[0].keys()
|
||||
}
|
||||
if verbose:
|
||||
for index in range(self.n_envs):
|
||||
logging.info(
|
||||
f"<-- Reset environment {index} with options {options_venv[index]}"
|
||||
)
|
||||
return obs_venv
|
||||
|
||||
def reset_env(self, env_ind, verbose=False):
|
||||
task = {}
|
||||
obs = self.venv.reset_one_arg(env_ind=env_ind, options=task)
|
||||
if verbose:
|
||||
logging.info(f"<-- Reset environment {env_ind} with task {task}")
|
||||
return obs
|
||||
@@ -0,0 +1,119 @@
|
||||
"""
|
||||
Evaluate pre-trained/DPPO-fine-tuned diffusion policy.
|
||||
|
||||
"""
|
||||
|
||||
import os
|
||||
import numpy as np
|
||||
import torch
|
||||
import logging
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
from util.timer import Timer
|
||||
from agent.eval.eval_agent import EvalAgent
|
||||
|
||||
|
||||
class EvalDiffusionAgent(EvalAgent):
|
||||
|
||||
def __init__(self, cfg):
|
||||
super().__init__(cfg)
|
||||
|
||||
def run(self):
|
||||
|
||||
# Start training loop
|
||||
timer = Timer()
|
||||
|
||||
# Prepare video paths for each envs --- only applies for the first set of episodes if allowing reset within iteration and each iteration has multiple episodes from one env
|
||||
options_venv = [{} for _ in range(self.n_envs)]
|
||||
if self.render_video:
|
||||
for env_ind in range(self.n_render):
|
||||
options_venv[env_ind]["video_path"] = os.path.join(
|
||||
self.render_dir, f"itr-{self.itr}_trial-{env_ind}.mp4"
|
||||
)
|
||||
|
||||
# Reset env before iteration starts
|
||||
self.model.eval()
|
||||
firsts_trajs = np.zeros((self.n_steps + 1, self.n_envs))
|
||||
prev_obs_venv = self.reset_env_all(options_venv=options_venv)
|
||||
firsts_trajs[0] = 1
|
||||
reward_trajs = np.empty((0, self.n_envs))
|
||||
|
||||
# Collect a set of trajectories from env
|
||||
for step in range(self.n_steps):
|
||||
if step % 10 == 0:
|
||||
print(f"Processed step {step} of {self.n_steps}")
|
||||
|
||||
# Select action
|
||||
with torch.no_grad():
|
||||
cond = {
|
||||
"state": torch.from_numpy(prev_obs_venv["state"])
|
||||
.float()
|
||||
.to(self.device)
|
||||
}
|
||||
samples = self.model(cond=cond)
|
||||
output_venv = (
|
||||
samples.trajectories.cpu().numpy()
|
||||
) # n_env x horizon x act
|
||||
action_venv = output_venv[:, : self.act_steps]
|
||||
|
||||
# Apply multi-step action
|
||||
obs_venv, reward_venv, done_venv, info_venv = self.venv.step(action_venv)
|
||||
reward_trajs = np.vstack((reward_trajs, reward_venv[None]))
|
||||
firsts_trajs[step + 1] = done_venv
|
||||
prev_obs_venv = obs_venv
|
||||
|
||||
# Summarize episode reward --- this needs to be handled differently depending on whether the environment is reset after each iteration. Only count episodes that finish within the iteration.
|
||||
episodes_start_end = []
|
||||
for env_ind in range(self.n_envs):
|
||||
env_steps = np.where(firsts_trajs[:, env_ind] == 1)[0]
|
||||
for i in range(len(env_steps) - 1):
|
||||
start = env_steps[i]
|
||||
end = env_steps[i + 1]
|
||||
if end - start > 1:
|
||||
episodes_start_end.append((env_ind, start, end - 1))
|
||||
if len(episodes_start_end) > 0:
|
||||
reward_trajs_split = [
|
||||
reward_trajs[start : end + 1, env_ind]
|
||||
for env_ind, start, end in episodes_start_end
|
||||
]
|
||||
num_episode_finished = len(reward_trajs_split)
|
||||
episode_reward = np.array(
|
||||
[np.sum(reward_traj) for reward_traj in reward_trajs_split]
|
||||
)
|
||||
if (
|
||||
self.furniture_sparse_reward
|
||||
): # only for furniture tasks, where reward only occurs in one env step
|
||||
episode_best_reward = episode_reward
|
||||
else:
|
||||
episode_best_reward = np.array(
|
||||
[
|
||||
np.max(reward_traj) / self.act_steps
|
||||
for reward_traj in reward_trajs_split
|
||||
]
|
||||
)
|
||||
avg_episode_reward = np.mean(episode_reward)
|
||||
avg_best_reward = np.mean(episode_best_reward)
|
||||
success_rate = np.mean(
|
||||
episode_best_reward >= self.best_reward_threshold_for_success
|
||||
)
|
||||
else:
|
||||
episode_reward = np.array([])
|
||||
num_episode_finished = 0
|
||||
avg_episode_reward = 0
|
||||
avg_best_reward = 0
|
||||
success_rate = 0
|
||||
log.info("[WARNING] No episode completed within the iteration!")
|
||||
|
||||
# Log loss and save metrics
|
||||
time = timer()
|
||||
log.info(
|
||||
f"eval: num episode {num_episode_finished:4d} | success rate {success_rate:8.4f} | avg episode reward {avg_episode_reward:8.4f} | avg best reward {avg_best_reward:8.4f}"
|
||||
)
|
||||
np.savez(
|
||||
self.result_path,
|
||||
num_episode=num_episode_finished,
|
||||
eval_success_rate=success_rate,
|
||||
eval_episode_reward=avg_episode_reward,
|
||||
eval_best_reward=avg_best_reward,
|
||||
time=time,
|
||||
)
|
||||
@@ -0,0 +1,122 @@
|
||||
"""
|
||||
Evaluate pre-trained/DPPO-fine-tuned pixel-based diffusion policy.
|
||||
|
||||
"""
|
||||
|
||||
import os
|
||||
import numpy as np
|
||||
import torch
|
||||
import logging
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
from util.timer import Timer
|
||||
from agent.eval.eval_agent import EvalAgent
|
||||
|
||||
|
||||
class EvalImgDiffusionAgent(EvalAgent):
|
||||
|
||||
def __init__(self, cfg):
|
||||
super().__init__(cfg)
|
||||
|
||||
# Set obs dim - we will save the different obs in batch in a dict
|
||||
shape_meta = cfg.shape_meta
|
||||
self.obs_dims = {k: shape_meta.obs[k]["shape"] for k in shape_meta.obs}
|
||||
|
||||
def run(self):
|
||||
|
||||
# Start training loop
|
||||
timer = Timer()
|
||||
|
||||
# Prepare video paths for each envs --- only applies for the first set of episodes if allowing reset within iteration and each iteration has multiple episodes from one env
|
||||
options_venv = [{} for _ in range(self.n_envs)]
|
||||
if self.render_video:
|
||||
for env_ind in range(self.n_render):
|
||||
options_venv[env_ind]["video_path"] = os.path.join(
|
||||
self.render_dir, f"itr-{self.itr}_trial-{env_ind}.mp4"
|
||||
)
|
||||
|
||||
# Reset env before iteration starts
|
||||
self.model.eval()
|
||||
firsts_trajs = np.zeros((self.n_steps + 1, self.n_envs))
|
||||
prev_obs_venv = self.reset_env_all(options_venv=options_venv)
|
||||
firsts_trajs[0] = 1
|
||||
reward_trajs = np.empty((0, self.n_envs))
|
||||
|
||||
# Collect a set of trajectories from env
|
||||
for step in range(self.n_steps):
|
||||
if step % 10 == 0:
|
||||
print(f"Processed step {step} of {self.n_steps}")
|
||||
|
||||
# Select action
|
||||
with torch.no_grad():
|
||||
cond = {
|
||||
key: torch.from_numpy(prev_obs_venv[key]).float().to(self.device)
|
||||
for key in self.obs_dims
|
||||
} # batch each type of obs and put into dict
|
||||
samples = self.model(cond=cond)
|
||||
output_venv = (
|
||||
samples.trajectories.cpu().numpy()
|
||||
) # n_env x horizon x act
|
||||
action_venv = output_venv[:, : self.act_steps]
|
||||
|
||||
# Apply multi-step action
|
||||
obs_venv, reward_venv, done_venv, info_venv = self.venv.step(action_venv)
|
||||
reward_trajs = np.vstack((reward_trajs, reward_venv[None]))
|
||||
firsts_trajs[step + 1] = done_venv
|
||||
prev_obs_venv = obs_venv
|
||||
|
||||
# Summarize episode reward --- this needs to be handled differently depending on whether the environment is reset after each iteration. Only count episodes that finish within the iteration.
|
||||
episodes_start_end = []
|
||||
for env_ind in range(self.n_envs):
|
||||
env_steps = np.where(firsts_trajs[:, env_ind] == 1)[0]
|
||||
for i in range(len(env_steps) - 1):
|
||||
start = env_steps[i]
|
||||
end = env_steps[i + 1]
|
||||
if end - start > 1:
|
||||
episodes_start_end.append((env_ind, start, end - 1))
|
||||
if len(episodes_start_end) > 0:
|
||||
reward_trajs_split = [
|
||||
reward_trajs[start : end + 1, env_ind]
|
||||
for env_ind, start, end in episodes_start_end
|
||||
]
|
||||
num_episode_finished = len(reward_trajs_split)
|
||||
episode_reward = np.array(
|
||||
[np.sum(reward_traj) for reward_traj in reward_trajs_split]
|
||||
)
|
||||
if (
|
||||
self.furniture_sparse_reward
|
||||
): # only for furniture tasks, where reward only occurs in one env step
|
||||
episode_best_reward = episode_reward
|
||||
else:
|
||||
episode_best_reward = np.array(
|
||||
[
|
||||
np.max(reward_traj) / self.act_steps
|
||||
for reward_traj in reward_trajs_split
|
||||
]
|
||||
)
|
||||
avg_episode_reward = np.mean(episode_reward)
|
||||
avg_best_reward = np.mean(episode_best_reward)
|
||||
success_rate = np.mean(
|
||||
episode_best_reward >= self.best_reward_threshold_for_success
|
||||
)
|
||||
else:
|
||||
episode_reward = np.array([])
|
||||
num_episode_finished = 0
|
||||
avg_episode_reward = 0
|
||||
avg_best_reward = 0
|
||||
success_rate = 0
|
||||
log.info("[WARNING] No episode completed within the iteration!")
|
||||
|
||||
# Log loss and save metrics
|
||||
time = timer()
|
||||
log.info(
|
||||
f"eval: num episode {num_episode_finished:4d} | success rate {success_rate:8.4f} | avg episode reward {avg_episode_reward:8.4f} | avg best reward {avg_best_reward:8.4f}"
|
||||
)
|
||||
np.savez(
|
||||
self.result_path,
|
||||
num_episode=num_episode_finished,
|
||||
eval_success_rate=success_rate,
|
||||
eval_episode_reward=avg_episode_reward,
|
||||
eval_best_reward=avg_best_reward,
|
||||
time=time,
|
||||
)
|
||||
@@ -0,0 +1,117 @@
|
||||
"""
|
||||
Evaluate pre-trained/fine-tuned Gaussian/GMM policy.
|
||||
|
||||
"""
|
||||
|
||||
import os
|
||||
import numpy as np
|
||||
import torch
|
||||
import logging
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
from util.timer import Timer
|
||||
from agent.eval.eval_agent import EvalAgent
|
||||
|
||||
|
||||
class EvalGaussianAgent(EvalAgent):
|
||||
|
||||
def __init__(self, cfg):
|
||||
super().__init__(cfg)
|
||||
|
||||
def run(self):
|
||||
|
||||
# Start training loop
|
||||
timer = Timer()
|
||||
|
||||
# Prepare video paths for each envs --- only applies for the first set of episodes if allowing reset within iteration and each iteration has multiple episodes from one env
|
||||
options_venv = [{} for _ in range(self.n_envs)]
|
||||
if self.render_video:
|
||||
for env_ind in range(self.n_render):
|
||||
options_venv[env_ind]["video_path"] = os.path.join(
|
||||
self.render_dir, f"itr-{self.itr}_trial-{env_ind}.mp4"
|
||||
)
|
||||
|
||||
# Reset env before iteration starts
|
||||
self.model.eval()
|
||||
firsts_trajs = np.zeros((self.n_steps + 1, self.n_envs))
|
||||
prev_obs_venv = self.reset_env_all(options_venv=options_venv)
|
||||
firsts_trajs[0] = 1
|
||||
reward_trajs = np.empty((0, self.n_envs))
|
||||
|
||||
# Collect a set of trajectories from env
|
||||
for step in range(self.n_steps):
|
||||
if step % 10 == 0:
|
||||
print(f"Processed step {step} of {self.n_steps}")
|
||||
|
||||
# Select action
|
||||
with torch.no_grad():
|
||||
cond = {
|
||||
"state": torch.from_numpy(prev_obs_venv["state"])
|
||||
.float()
|
||||
.to(self.device)
|
||||
}
|
||||
samples = self.model(cond=cond, deterministic=True)
|
||||
output_venv = samples.cpu().numpy()
|
||||
action_venv = output_venv[:, : self.act_steps]
|
||||
|
||||
# Apply multi-step action
|
||||
obs_venv, reward_venv, done_venv, info_venv = self.venv.step(action_venv)
|
||||
reward_trajs = np.vstack((reward_trajs, reward_venv[None]))
|
||||
firsts_trajs[step + 1] = done_venv
|
||||
prev_obs_venv = obs_venv
|
||||
|
||||
# Summarize episode reward --- this needs to be handled differently depending on whether the environment is reset after each iteration. Only count episodes that finish within the iteration.
|
||||
episodes_start_end = []
|
||||
for env_ind in range(self.n_envs):
|
||||
env_steps = np.where(firsts_trajs[:, env_ind] == 1)[0]
|
||||
for i in range(len(env_steps) - 1):
|
||||
start = env_steps[i]
|
||||
end = env_steps[i + 1]
|
||||
if end - start > 1:
|
||||
episodes_start_end.append((env_ind, start, end - 1))
|
||||
if len(episodes_start_end) > 0:
|
||||
reward_trajs_split = [
|
||||
reward_trajs[start : end + 1, env_ind]
|
||||
for env_ind, start, end in episodes_start_end
|
||||
]
|
||||
num_episode_finished = len(reward_trajs_split)
|
||||
episode_reward = np.array(
|
||||
[np.sum(reward_traj) for reward_traj in reward_trajs_split]
|
||||
)
|
||||
if (
|
||||
self.furniture_sparse_reward
|
||||
): # only for furniture tasks, where reward only occurs in one env step
|
||||
episode_best_reward = episode_reward
|
||||
else:
|
||||
episode_best_reward = np.array(
|
||||
[
|
||||
np.max(reward_traj) / self.act_steps
|
||||
for reward_traj in reward_trajs_split
|
||||
]
|
||||
)
|
||||
avg_episode_reward = np.mean(episode_reward)
|
||||
avg_best_reward = np.mean(episode_best_reward)
|
||||
success_rate = np.mean(
|
||||
episode_best_reward >= self.best_reward_threshold_for_success
|
||||
)
|
||||
else:
|
||||
episode_reward = np.array([])
|
||||
num_episode_finished = 0
|
||||
avg_episode_reward = 0
|
||||
avg_best_reward = 0
|
||||
success_rate = 0
|
||||
log.info("[WARNING] No episode completed within the iteration!")
|
||||
|
||||
# Log loss and save metrics
|
||||
time = timer()
|
||||
log.info(
|
||||
f"eval: num episode {num_episode_finished:4d} | success rate {success_rate:8.4f} | avg episode reward {avg_episode_reward:8.4f} | avg best reward {avg_best_reward:8.4f}"
|
||||
)
|
||||
np.savez(
|
||||
self.result_path,
|
||||
num_episode=num_episode_finished,
|
||||
eval_success_rate=success_rate,
|
||||
eval_episode_reward=avg_episode_reward,
|
||||
eval_best_reward=avg_best_reward,
|
||||
time=time,
|
||||
)
|
||||
@@ -0,0 +1,120 @@
|
||||
"""
|
||||
Evaluate pre-trained/fine-tuned Gaussian/GMM pixel-based policy.
|
||||
|
||||
"""
|
||||
|
||||
import os
|
||||
import numpy as np
|
||||
import torch
|
||||
import logging
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
from util.timer import Timer
|
||||
from agent.eval.eval_agent import EvalAgent
|
||||
|
||||
|
||||
class EvalImgGaussianAgent(EvalAgent):
|
||||
|
||||
def __init__(self, cfg):
|
||||
super().__init__(cfg)
|
||||
|
||||
# Set obs dim - we will save the different obs in batch in a dict
|
||||
shape_meta = cfg.shape_meta
|
||||
self.obs_dims = {k: shape_meta.obs[k]["shape"] for k in shape_meta.obs.keys()}
|
||||
|
||||
def run(self):
|
||||
|
||||
# Start training loop
|
||||
timer = Timer()
|
||||
|
||||
# Prepare video paths for each envs --- only applies for the first set of episodes if allowing reset within iteration and each iteration has multiple episodes from one env
|
||||
options_venv = [{} for _ in range(self.n_envs)]
|
||||
if self.render_video:
|
||||
for env_ind in range(self.n_render):
|
||||
options_venv[env_ind]["video_path"] = os.path.join(
|
||||
self.render_dir, f"itr-{self.itr}_trial-{env_ind}.mp4"
|
||||
)
|
||||
|
||||
# Reset env before iteration starts
|
||||
self.model.eval()
|
||||
firsts_trajs = np.zeros((self.n_steps + 1, self.n_envs))
|
||||
prev_obs_venv = self.reset_env_all(options_venv=options_venv)
|
||||
firsts_trajs[0] = 1
|
||||
reward_trajs = np.empty((0, self.n_envs))
|
||||
|
||||
# Collect a set of trajectories from env
|
||||
for step in range(self.n_steps):
|
||||
if step % 10 == 0:
|
||||
print(f"Processed step {step} of {self.n_steps}")
|
||||
|
||||
# Select action
|
||||
with torch.no_grad():
|
||||
cond = {
|
||||
key: torch.from_numpy(prev_obs_venv[key]).float().to(self.device)
|
||||
for key in self.obs_dims
|
||||
}
|
||||
samples = self.model(cond=cond, deterministic=True)
|
||||
output_venv = samples.cpu().numpy()
|
||||
action_venv = output_venv[:, : self.act_steps]
|
||||
|
||||
# Apply multi-step action
|
||||
obs_venv, reward_venv, done_venv, info_venv = self.venv.step(action_venv)
|
||||
reward_trajs = np.vstack((reward_trajs, reward_venv[None]))
|
||||
firsts_trajs[step + 1] = done_venv
|
||||
prev_obs_venv = obs_venv
|
||||
|
||||
# Summarize episode reward --- this needs to be handled differently depending on whether the environment is reset after each iteration. Only count episodes that finish within the iteration.
|
||||
episodes_start_end = []
|
||||
for env_ind in range(self.n_envs):
|
||||
env_steps = np.where(firsts_trajs[:, env_ind] == 1)[0]
|
||||
for i in range(len(env_steps) - 1):
|
||||
start = env_steps[i]
|
||||
end = env_steps[i + 1]
|
||||
if end - start > 1:
|
||||
episodes_start_end.append((env_ind, start, end - 1))
|
||||
if len(episodes_start_end) > 0:
|
||||
reward_trajs_split = [
|
||||
reward_trajs[start : end + 1, env_ind]
|
||||
for env_ind, start, end in episodes_start_end
|
||||
]
|
||||
num_episode_finished = len(reward_trajs_split)
|
||||
episode_reward = np.array(
|
||||
[np.sum(reward_traj) for reward_traj in reward_trajs_split]
|
||||
)
|
||||
if (
|
||||
self.furniture_sparse_reward
|
||||
): # only for furniture tasks, where reward only occurs in one env step
|
||||
episode_best_reward = episode_reward
|
||||
else:
|
||||
episode_best_reward = np.array(
|
||||
[
|
||||
np.max(reward_traj) / self.act_steps
|
||||
for reward_traj in reward_trajs_split
|
||||
]
|
||||
)
|
||||
avg_episode_reward = np.mean(episode_reward)
|
||||
avg_best_reward = np.mean(episode_best_reward)
|
||||
success_rate = np.mean(
|
||||
episode_best_reward >= self.best_reward_threshold_for_success
|
||||
)
|
||||
else:
|
||||
episode_reward = np.array([])
|
||||
num_episode_finished = 0
|
||||
avg_episode_reward = 0
|
||||
avg_best_reward = 0
|
||||
success_rate = 0
|
||||
log.info("[WARNING] No episode completed within the iteration!")
|
||||
|
||||
# Log loss and save metrics
|
||||
time = timer()
|
||||
log.info(
|
||||
f"eval: num episode {num_episode_finished:4d} | success rate {success_rate:8.4f} | avg episode reward {avg_episode_reward:8.4f} | avg best reward {avg_best_reward:8.4f}"
|
||||
)
|
||||
np.savez(
|
||||
self.result_path,
|
||||
num_episode=num_episode_finished,
|
||||
eval_success_rate=success_rate,
|
||||
eval_episode_reward=avg_episode_reward,
|
||||
eval_best_reward=avg_best_reward,
|
||||
time=time,
|
||||
)
|
||||
Reference in New Issue
Block a user