#!/usr/bin/env python3 import os import random import time import json from collections import deque from dataclasses import dataclass from pathlib import Path from typing import Any, Dict, List, Optional, Tuple import gymnasium as gym import numpy as np from PIL import Image import torch import torch.nn as nn import torch.optim as optim import tyro from torch.distributions.normal import Normal from torch.utils.tensorboard import SummaryWriter # Register ManiSkill custom envs in this repo. import vagen.env.primitive_skill.maniskill.env # noqa: F401 def layer_init(layer: nn.Module, std: float = np.sqrt(2), bias_const: float = 0.0) -> nn.Module: torch.nn.init.orthogonal_(layer.weight, std) torch.nn.init.constant_(layer.bias, bias_const) return layer @dataclass class Args: exp_name: str = "ppo_stack_threecube_vision" seed: int = 1 cuda: bool = True torch_deterministic: bool = True track: bool = False wandb_project_name: str = "vagen-threecube" wandb_entity: Optional[str] = None total_timesteps: int = 30_000_000 learning_rate: float = 1e-4 num_envs: int = 16 num_steps: int = 32 gamma: float = 0.99 gae_lambda: float = 0.95 update_epochs: int = 2 num_minibatches: int = 4 clip_coef: float = 0.1 clip_vloss: bool = True ent_coef: float = 0.0 vf_coef: float = 0.5 max_grad_norm: float = 0.5 target_kl: Optional[float] = 0.03 anneal_lr: bool = True norm_adv: bool = True image_size: int = 84 include_proprio: bool = True proprio_dim: int = 10 encoder_feature_dim: int = 512 freeze_encoder_steps: int = 200_000 sim_backend: str = "gpu" render_backend: str = "gpu" allow_backend_fallback: bool = True fallback_sim_backend: str = "cpu" fallback_render_backend: str = "cpu" force_cpu_sim_when_sync_vector: bool = True control_mode: str = "pd_ee_delta_pose" max_episode_steps: int = 3000 success_reward: float = 10.0 stage_reward: float = 2.0 step_penalty: float = 0.01 eval_interval: int = 500_000 eval_episodes: int = 1000 eval_deterministic: bool = True save_best_ckpt: bool = True log_window_size: int = 100 converge_success_threshold: float = 0.80 stop_training_on_converge: bool = True collect_after_converge: bool = True post_converge_target_trajs: int = 4000 post_converge_max_eval_episodes: int = 20000 logstd_min: float = -5.0 logstd_max: float = 2.0 max_abs_reward: float = 20.0 skip_nonfinite_minibatch: bool = True save_trajectories: bool = True traj_root: str = "trajectories/threecube/raw" max_traj_per_eval: int = 2000 batch_size: int = 0 minibatch_size: int = 0 num_iterations: int = 0 class ThreeCubeVisionWrapper(gym.Wrapper): """ Uses env.render() as RGB observation and keeps optional low-dim proprio. """ def __init__(self, env: gym.Env, image_size: int = 84, include_proprio: bool = True, proprio_dim: int = 10): super().__init__(env) self.image_size = int(image_size) self.include_proprio = bool(include_proprio) self.proprio_dim = int(proprio_dim) self.action_space = env.action_space self.observation_space = gym.spaces.Dict( { "image": gym.spaces.Box(0.0, 1.0, shape=(3, self.image_size, self.image_size), dtype=np.float32), "proprio": gym.spaces.Box(-np.inf, np.inf, shape=(self.proprio_dim,), dtype=np.float32), } ) self._last_info: Dict[str, Any] = {} self._prev_stage_score = 0.0 def _render_image(self) -> np.ndarray: frame = self.env.render() if frame is None: raise RuntimeError("env.render() returned None, cannot build visual observation.") arr = np.asarray(frame) # ManiSkill may return batched frames like (1, H, W, C) when num_envs=1. if arr.ndim == 4: if arr.shape[0] == 1: arr = arr[0] else: arr = arr[0] # Accept both HWC and CHW layouts. if arr.ndim == 3 and arr.shape[0] in (1, 3, 4) and arr.shape[-1] not in (1, 3, 4): arr = np.transpose(arr, (1, 2, 0)) if arr.ndim != 3: raise RuntimeError(f"Unexpected render output shape: {arr.shape}") if arr.shape[-1] == 1: arr = np.repeat(arr, 3, axis=-1) elif arr.shape[-1] == 4: arr = arr[..., :3] arr = np.asarray(arr, dtype=np.uint8) img = Image.fromarray(arr).convert("RGB") img = img.resize((self.image_size, self.image_size)) arr = np.asarray(img, dtype=np.float32) / 255.0 return np.transpose(arr, (2, 0, 1)) def _extract_proprio(self, info: Dict[str, Any]) -> np.ndarray: if not self.include_proprio: return np.zeros((self.proprio_dim,), dtype=np.float32) keys = [ "gripper_position", "red_cube_position", "green_cube_position", "purple_cube_position", ] vals: List[float] = [] for k in keys: if k not in info: continue v = np.asarray(info[k], dtype=np.float32).reshape(-1) vals.extend(v.tolist()) if len(vals) >= self.proprio_dim: break if len(vals) < self.proprio_dim: vals.extend([0.0] * (self.proprio_dim - len(vals))) return np.asarray(vals[: self.proprio_dim], dtype=np.float32) def _obs_dict(self, info: Dict[str, Any]) -> Dict[str, np.ndarray]: return {"image": self._render_image(), "proprio": self._extract_proprio(info)} def _stage_score(self, info: Dict[str, Any]) -> float: score = 0.0 for key in ("stage0_success", "stage1_success", "stage2_success"): if bool(info.get(key, False)): score += 1.0 return score def reset(self, *, seed: Optional[int] = None, options: Optional[Dict[str, Any]] = None): _, info = self.env.reset(seed=seed, options=options) info = info or {} self._last_info = info self._prev_stage_score = self._stage_score(info) return self._obs_dict(info), info def step(self, action): _, reward, terminated, truncated, info = self.env.step(action) info = info or {} info["is_success"] = bool(info.get("success", False)) stage_score = self._stage_score(info) stage_delta = max(0.0, stage_score - self._prev_stage_score) self._prev_stage_score = stage_score # Convert possible torch/numpy scalar to python scalar for gym wrappers compatibility. reward_scalar = float(np.asarray(reward).reshape(-1)[0]) terminated_scalar = bool(np.asarray(terminated).reshape(-1)[0]) truncated_scalar = bool(np.asarray(truncated).reshape(-1)[0]) shaped_reward = reward_scalar shaped_reward += stage_delta shaped_reward -= 0.01 if bool(info.get("success", False)): shaped_reward += 10.0 self._last_info = info return self._obs_dict(info), shaped_reward, terminated_scalar, truncated_scalar, info def make_env(args: Args, idx: int, run_name: str): def thunk(): backend_candidates: List[Tuple[str, str]] = [(args.sim_backend, args.render_backend)] if args.allow_backend_fallback: fallback_pair = (args.fallback_sim_backend, args.fallback_render_backend) if fallback_pair not in backend_candidates: backend_candidates.append(fallback_pair) env = None last_err: Optional[Exception] = None for sim_backend, render_backend in backend_candidates: try: env = gym.make( "StackThreeCube", num_envs=1, obs_mode="state", control_mode=args.control_mode, render_mode="rgb_array", sim_backend=sim_backend, render_backend=render_backend, enable_shadow=True, ) if (sim_backend, render_backend) != (args.sim_backend, args.render_backend): print( f"[env {idx}] backend fallback enabled: " f"using sim_backend={sim_backend}, render_backend={render_backend}" ) break except RuntimeError as e: last_err = e msg = str(e).lower() is_cuda_init_err = ("cuda failed" in msg) or ("physxgpusystem" in msg) if is_cuda_init_err and args.allow_backend_fallback: print( f"[env {idx}] backend {sim_backend}/{render_backend} init failed: {e}. " "Trying fallback backend..." ) continue raise if env is None: raise RuntimeError( f"Failed to create StackThreeCube env with candidates={backend_candidates}. " f"Last error: {last_err}" ) env = gym.wrappers.TimeLimit(env, max_episode_steps=int(args.max_episode_steps)) env = ThreeCubeVisionWrapper( env, image_size=args.image_size, include_proprio=args.include_proprio, proprio_dim=args.proprio_dim, ) env = gym.wrappers.RecordEpisodeStatistics(env) return env return thunk class Agent(nn.Module): def __init__( self, action_dim: int, proprio_dim: int, encoder_feature_dim: int = 512, logstd_min: float = -5.0, logstd_max: float = 2.0, ): super().__init__() self.logstd_min = float(logstd_min) self.logstd_max = float(logstd_max) self.encoder = nn.Sequential( layer_init(nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3)), nn.ReLU(), nn.MaxPool2d(kernel_size=3, stride=2, padding=1), layer_init(nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1)), nn.ReLU(), layer_init(nn.Conv2d(128, 256, kernel_size=3, stride=2, padding=1)), nn.ReLU(), layer_init(nn.Conv2d(256, 512, kernel_size=3, stride=2, padding=1)), nn.ReLU(), nn.AdaptiveAvgPool2d((1, 1)), nn.Flatten(), layer_init(nn.Linear(512, encoder_feature_dim)), nn.ReLU(), ) fusion_dim = encoder_feature_dim + int(proprio_dim) self.actor_mean = nn.Sequential( layer_init(nn.Linear(fusion_dim, 256)), nn.Tanh(), layer_init(nn.Linear(256, action_dim), std=0.01), ) self.actor_logstd = nn.Parameter(torch.zeros(1, action_dim)) self.critic = nn.Sequential( layer_init(nn.Linear(fusion_dim, 256)), nn.Tanh(), layer_init(nn.Linear(256, 1), std=1.0), ) def encode(self, image: torch.Tensor, proprio: torch.Tensor) -> torch.Tensor: z = self.encoder(image) return torch.cat([z, proprio], dim=-1) def get_value(self, image: torch.Tensor, proprio: torch.Tensor) -> torch.Tensor: h = self.encode(image, proprio) return self.critic(h) def get_action_and_value( self, image: torch.Tensor, proprio: torch.Tensor, action: Optional[torch.Tensor] = None, ): image = torch.nan_to_num(image, nan=0.0, posinf=1.0, neginf=0.0) proprio = torch.nan_to_num(proprio, nan=0.0, posinf=1e3, neginf=-1e3) h = self.encode(image, proprio) h = torch.nan_to_num(h, nan=0.0, posinf=1e3, neginf=-1e3) action_mean = self.actor_mean(h) action_mean = torch.nan_to_num(action_mean, nan=0.0, posinf=1.0, neginf=-1.0) action_logstd = self.actor_logstd.expand_as(action_mean) action_logstd = torch.clamp(action_logstd, self.logstd_min, self.logstd_max) action_std = torch.exp(action_logstd) probs = Normal(action_mean, action_std) if action is None: action = probs.sample() action = torch.clamp(action, -1.0, 1.0) return action, probs.log_prob(action).sum(1), probs.entropy().sum(1), self.critic(h) def save_eval_trajectories( args: Args, run_name: str, global_step: int, records: List[Dict[str, Any]], ) -> int: out_dir = Path(args.traj_root) / f"{run_name}" / f"step_{int(global_step)}" out_dir.mkdir(parents=True, exist_ok=True) frames_dir = out_dir / "frames" frames_dir.mkdir(parents=True, exist_ok=True) count = 0 traj_path = out_dir / "trajectories.jsonl" with traj_path.open("w", encoding="utf-8") as f: for rec in records[: int(args.max_traj_per_eval)]: if not rec.get("episode_success", False): continue episode_id = int(rec["episode_id"]) frame_paths: List[str] = [] for t, frame in enumerate(rec["frames"]): frame_path = frames_dir / f"ep_{episode_id:06d}_t_{t:05d}.png" Image.fromarray(frame).save(frame_path) frame_paths.append(str(frame_path)) item = { "state_format": "png_path", "frames": frame_paths, "robot_state": rec["robot_state"], "actions": rec["actions"], "rewards": rec["rewards"], "success": rec["success_flags"], "episode_return": rec["episode_return"], "episode_success": rec["episode_success"], "episode_id": episode_id, } f.write(json.dumps(item) + "\n") count += 1 metrics = { "global_step": int(global_step), "episodes": int(len(records)), "trajectory_saved_count": int(count), "success_rate": float(np.mean([1.0 if r.get("episode_success", False) else 0.0 for r in records])) if records else 0.0, } with (out_dir / "metrics.json").open("w", encoding="utf-8") as mf: json.dump(metrics, mf, ensure_ascii=False, indent=2) return count def evaluate_policy(args: Args, agent: Agent, device: torch.device, run_name: str, global_step: int) -> Dict[str, float]: eval_env = make_env(args, idx=0, run_name=f"{run_name}_eval")() episodes = int(args.eval_episodes) returns: List[float] = [] lengths: List[int] = [] successes: List[float] = [] records: List[Dict[str, Any]] = [] for ep in range(episodes): obs, info = eval_env.reset(seed=args.seed + 10_000 + ep) done = False ep_ret = 0.0 ep_len = 0 ep_frames: List[np.ndarray] = [] ep_actions: List[List[float]] = [] ep_rewards: List[float] = [] ep_success_flags: List[bool] = [] ep_robot_state: List[List[float]] = [] ep_frames.append(np.transpose((obs["image"] * 255.0).astype(np.uint8), (1, 2, 0))) ep_robot_state.append(obs["proprio"].astype(np.float32).tolist()) while not done: img_t = torch.tensor(obs["image"], dtype=torch.float32, device=device).unsqueeze(0) prop_t = torch.tensor(obs["proprio"], dtype=torch.float32, device=device).unsqueeze(0) with torch.no_grad(): if args.eval_deterministic: h = agent.encode(img_t, prop_t) action = agent.actor_mean(h) action = torch.clamp(action, -1.0, 1.0) else: action, _, _, _ = agent.get_action_and_value(img_t, prop_t) action_np = action.squeeze(0).cpu().numpy() next_obs, reward, term, trunc, info = eval_env.step(action_np) done = bool(term) or bool(trunc) ep_ret += float(reward) ep_len += 1 ep_actions.append(action_np.astype(np.float32).tolist()) ep_rewards.append(float(reward)) ep_success_flags.append(bool(info.get("is_success", False))) ep_frames.append(np.transpose((next_obs["image"] * 255.0).astype(np.uint8), (1, 2, 0))) ep_robot_state.append(next_obs["proprio"].astype(np.float32).tolist()) obs = next_obs ep_success = bool(any(ep_success_flags)) returns.append(ep_ret) lengths.append(ep_len) successes.append(1.0 if ep_success else 0.0) records.append( { "episode_id": ep, "frames": ep_frames, "robot_state": ep_robot_state, "actions": ep_actions, "rewards": ep_rewards, "success_flags": ep_success_flags, "episode_return": float(ep_ret), "episode_success": ep_success, } ) traj_count = 0 if args.save_trajectories: traj_count = save_eval_trajectories(args, run_name, global_step, records) eval_env.close() return { "success_rate": float(np.mean(successes)) if successes else 0.0, "episode_length": float(np.mean(lengths)) if lengths else 0.0, "reward_mean": float(np.mean(returns)) if returns else 0.0, "trajectory_saved_count": float(traj_count), } def collect_success_trajectories_after_converge( args: Args, agent: Agent, device: torch.device, run_name: str, global_step: int, ) -> int: target = int(args.post_converge_target_trajs) max_episodes = int(args.post_converge_max_eval_episodes) if target <= 0: return 0 out_dir = Path(args.traj_root) / f"{run_name}" / f"step_{int(global_step)}_converged_collect" out_dir.mkdir(parents=True, exist_ok=True) frames_dir = out_dir / "frames" frames_dir.mkdir(parents=True, exist_ok=True) traj_path = out_dir / "trajectories.jsonl" metrics_path = out_dir / "metrics.json" eval_env = make_env(args, idx=0, run_name=f"{run_name}_collect")() saved_count = 0 total_eval_episodes = 0 returns: List[float] = [] lengths: List[int] = [] success_hist: List[float] = [] with traj_path.open("w", encoding="utf-8") as f: while saved_count < target and total_eval_episodes < max_episodes: ep_id = total_eval_episodes obs, _ = eval_env.reset(seed=args.seed + 1_000_000 + ep_id) done = False ep_ret = 0.0 ep_len = 0 ep_frames: List[np.ndarray] = [] ep_actions: List[List[float]] = [] ep_rewards: List[float] = [] ep_success_flags: List[bool] = [] ep_robot_state: List[List[float]] = [] ep_frames.append(np.transpose((obs["image"] * 255.0).astype(np.uint8), (1, 2, 0))) ep_robot_state.append(obs["proprio"].astype(np.float32).tolist()) while not done: img_t = torch.tensor(obs["image"], dtype=torch.float32, device=device).unsqueeze(0) prop_t = torch.tensor(obs["proprio"], dtype=torch.float32, device=device).unsqueeze(0) with torch.no_grad(): if args.eval_deterministic: h = agent.encode(img_t, prop_t) action = torch.clamp(agent.actor_mean(h), -1.0, 1.0) else: action, _, _, _ = agent.get_action_and_value(img_t, prop_t) action_np = action.squeeze(0).cpu().numpy() next_obs, reward, term, trunc, info = eval_env.step(action_np) done = bool(term) or bool(trunc) ep_ret += float(reward) ep_len += 1 ep_actions.append(action_np.astype(np.float32).tolist()) ep_rewards.append(float(reward)) ep_success_flags.append(bool(info.get("is_success", False))) ep_frames.append(np.transpose((next_obs["image"] * 255.0).astype(np.uint8), (1, 2, 0))) ep_robot_state.append(next_obs["proprio"].astype(np.float32).tolist()) obs = next_obs ep_success = bool(any(ep_success_flags)) total_eval_episodes += 1 returns.append(ep_ret) lengths.append(ep_len) success_hist.append(1.0 if ep_success else 0.0) if ep_success: frame_paths: List[str] = [] for t, frame in enumerate(ep_frames): frame_path = frames_dir / f"ep_{saved_count:06d}_t_{t:05d}.png" Image.fromarray(frame).save(frame_path) frame_paths.append(str(frame_path)) item = { "state_format": "png_path", "frames": frame_paths, "robot_state": ep_robot_state, "actions": ep_actions, "rewards": ep_rewards, "success": ep_success_flags, "episode_return": float(ep_ret), "episode_success": True, "episode_id": int(saved_count), } f.write(json.dumps(item) + "\n") saved_count += 1 if saved_count % 100 == 0: print(f"[collect] saved {saved_count}/{target} successful trajectories") eval_env.close() metrics = { "global_step": int(global_step), "target_success_trajectories": target, "saved_success_trajectories": saved_count, "evaluated_episodes": total_eval_episodes, "success_rate_over_collection": float(np.mean(success_hist)) if success_hist else 0.0, "reward_mean_over_collection": float(np.mean(returns)) if returns else 0.0, "episode_length_over_collection": float(np.mean(lengths)) if lengths else 0.0, } with metrics_path.open("w", encoding="utf-8") as mf: json.dump(metrics, mf, ensure_ascii=False, indent=2) return saved_count def set_encoder_trainable(agent: Agent, trainable: bool) -> None: for p in agent.encoder.parameters(): p.requires_grad = bool(trainable) if __name__ == "__main__": args = tyro.cli(Args) args.batch_size = int(args.num_envs * args.num_steps) args.minibatch_size = int(args.batch_size // args.num_minibatches) args.num_iterations = int(args.total_timesteps // args.batch_size) run_name = f"StackThreeCube__{args.exp_name}__{args.seed}__{int(time.time())}" writer = SummaryWriter(f"runs/{run_name}") writer.add_text("hyperparameters", json.dumps(vars(args), indent=2)) print(f"[log] TensorBoard directory: runs/{run_name}") print(f"[log] Open with: tensorboard --logdir runs/{run_name} --port 6006") wandb = None if args.track: import wandb as _wandb wandb = _wandb wandb.init( project=args.wandb_project_name, entity=args.wandb_entity, sync_tensorboard=True, config=vars(args), name=run_name, monitor_gym=False, save_code=True, ) random.seed(args.seed) np.random.seed(args.seed) torch.manual_seed(args.seed) torch.backends.cudnn.deterministic = args.torch_deterministic device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu") # ManiSkill GPU PhysX cannot be instantiated multiple times via Gym SyncVectorEnv. # This script uses SyncVectorEnv for PPO collection, so force CPU physics here for stability. if args.force_cpu_sim_when_sync_vector and args.num_envs > 1 and str(args.sim_backend).lower() == "gpu": print( "[setup] Detected SyncVectorEnv + sim_backend=gpu with num_envs>1. " "This combination is unstable for ManiSkill (CUDA failed). " "Switching sim_backend/render_backend to cpu/cpu automatically." ) args.sim_backend = "cpu" args.render_backend = "cpu" envs = gym.vector.SyncVectorEnv([make_env(args, i, run_name, ) for i in range(args.num_envs)]) assert isinstance(envs.single_action_space, gym.spaces.Box), "Continuous action space is required." action_dim = int(np.prod(envs.single_action_space.shape)) agent = Agent( action_dim=action_dim, proprio_dim=int(envs.single_observation_space["proprio"].shape[0]), encoder_feature_dim=args.encoder_feature_dim, logstd_min=args.logstd_min, logstd_max=args.logstd_max, ).to(device) optimizer = optim.Adam(agent.parameters(), lr=args.learning_rate, eps=1e-5) obs_image = torch.zeros((args.num_steps, args.num_envs) + envs.single_observation_space["image"].shape, device=device) obs_prop = torch.zeros((args.num_steps, args.num_envs) + envs.single_observation_space["proprio"].shape, device=device) actions = torch.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape, device=device) logprobs = torch.zeros((args.num_steps, args.num_envs), device=device) rewards = torch.zeros((args.num_steps, args.num_envs), device=device) dones = torch.zeros((args.num_steps, args.num_envs), device=device) values = torch.zeros((args.num_steps, args.num_envs), device=device) global_step = 0 start_time = time.time() next_obs, _ = envs.reset(seed=args.seed) next_image = torch.tensor(next_obs["image"], dtype=torch.float32, device=device) next_image = torch.nan_to_num(next_image, nan=0.0, posinf=1.0, neginf=0.0) next_prop = torch.tensor(next_obs["proprio"], dtype=torch.float32, device=device) next_prop = torch.nan_to_num(next_prop, nan=0.0, posinf=1e3, neginf=-1e3) next_done = torch.zeros(args.num_envs, dtype=torch.float32, device=device) best_stable_sr = -1.0 eval_interval = max(1, int(args.eval_interval)) recent_train_rewards: deque = deque(maxlen=int(args.log_window_size)) recent_train_lengths: deque = deque(maxlen=int(args.log_window_size)) recent_train_success: deque = deque(maxlen=int(args.log_window_size)) stop_training = False for iteration in range(1, args.num_iterations + 1): if args.anneal_lr: frac = 1.0 - (iteration - 1.0) / args.num_iterations optimizer.param_groups[0]["lr"] = frac * args.learning_rate encoder_trainable = global_step >= int(args.freeze_encoder_steps) set_encoder_trainable(agent, encoder_trainable) for step in range(args.num_steps): global_step += args.num_envs obs_image[step] = next_image obs_prop[step] = next_prop dones[step] = next_done with torch.no_grad(): action, logprob, _, value = agent.get_action_and_value(next_image, next_prop) values[step] = value.flatten() actions[step] = action logprobs[step] = logprob next_obs, reward, terminations, truncations, infos = envs.step(action.cpu().numpy()) next_done_np = np.logical_or(terminations, truncations) reward_t = torch.tensor(reward, dtype=torch.float32, device=device).view(-1) reward_t = torch.clamp(torch.nan_to_num(reward_t, nan=0.0, posinf=args.max_abs_reward, neginf=-args.max_abs_reward), -args.max_abs_reward, args.max_abs_reward) rewards[step] = reward_t next_image = torch.tensor(next_obs["image"], dtype=torch.float32, device=device) next_image = torch.nan_to_num(next_image, nan=0.0, posinf=1.0, neginf=0.0) next_prop = torch.tensor(next_obs["proprio"], dtype=torch.float32, device=device) next_prop = torch.nan_to_num(next_prop, nan=0.0, posinf=1e3, neginf=-1e3) next_done = torch.tensor(next_done_np, dtype=torch.float32, device=device) if "final_info" in infos: final_infos = infos["final_info"] for info in final_infos: if info and "episode" in info: ep_r = float(info["episode"]["r"]) ep_l = float(info["episode"]["l"]) ep_s = 1.0 if bool(info.get("is_success", False)) else 0.0 recent_train_rewards.append(ep_r) recent_train_lengths.append(ep_l) recent_train_success.append(ep_s) writer.add_scalar("train/reward_mean", ep_r, global_step) writer.add_scalar("train/episode_length", ep_l, global_step) writer.add_scalar("train/success_rate", ep_s, global_step) with torch.no_grad(): next_value = agent.get_value(next_image, next_prop).reshape(1, -1) advantages = torch.zeros_like(rewards, device=device) lastgaelam = 0 for t in reversed(range(args.num_steps)): if t == args.num_steps - 1: nextnonterminal = 1.0 - next_done nextvalues = next_value else: nextnonterminal = 1.0 - dones[t + 1] nextvalues = values[t + 1] delta = rewards[t] + args.gamma * nextvalues * nextnonterminal - values[t] advantages[t] = lastgaelam = delta + args.gamma * args.gae_lambda * nextnonterminal * lastgaelam returns = advantages + values b_img = obs_image.reshape((-1,) + envs.single_observation_space["image"].shape) b_prop = obs_prop.reshape((-1,) + envs.single_observation_space["proprio"].shape) b_img = torch.nan_to_num(b_img, nan=0.0, posinf=1.0, neginf=0.0) b_prop = torch.nan_to_num(b_prop, nan=0.0, posinf=1e3, neginf=-1e3) b_actions = actions.reshape((-1,) + envs.single_action_space.shape) b_logprobs = logprobs.reshape(-1) b_advantages = advantages.reshape(-1) b_returns = returns.reshape(-1) b_values = values.reshape(-1) b_inds = np.arange(args.batch_size) clipfracs: List[float] = [] for epoch in range(args.update_epochs): np.random.shuffle(b_inds) for start in range(0, args.batch_size, args.minibatch_size): end = start + args.minibatch_size mb_inds = b_inds[start:end] _, newlogprob, entropy, newvalue = agent.get_action_and_value( b_img[mb_inds], b_prop[mb_inds], b_actions[mb_inds] ) logratio = newlogprob - b_logprobs[mb_inds] ratio = logratio.exp() with torch.no_grad(): old_approx_kl = (-logratio).mean() approx_kl = ((ratio - 1) - logratio).mean() clipfracs.append(((ratio - 1.0).abs() > args.clip_coef).float().mean().item()) mb_adv = b_advantages[mb_inds] if args.norm_adv: mb_adv = (mb_adv - mb_adv.mean()) / (mb_adv.std() + 1e-8) pg_loss1 = -mb_adv * ratio pg_loss2 = -mb_adv * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef) pg_loss = torch.max(pg_loss1, pg_loss2).mean() newvalue = newvalue.view(-1) if args.clip_vloss: v_loss_unclipped = (newvalue - b_returns[mb_inds]) ** 2 v_clipped = b_values[mb_inds] + torch.clamp( newvalue - b_values[mb_inds], -args.clip_coef, args.clip_coef ) v_loss_clipped = (v_clipped - b_returns[mb_inds]) ** 2 v_loss = 0.5 * torch.max(v_loss_unclipped, v_loss_clipped).mean() else: v_loss = 0.5 * ((newvalue - b_returns[mb_inds]) ** 2).mean() entropy_loss = entropy.mean() loss = pg_loss - args.ent_coef * entropy_loss + args.vf_coef * v_loss if args.skip_nonfinite_minibatch and (not torch.isfinite(loss)): print("[warn] non-finite loss detected, skip minibatch") optimizer.zero_grad(set_to_none=True) continue optimizer.zero_grad() loss.backward() nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm) if args.skip_nonfinite_minibatch: grad_ok = True for p in agent.parameters(): if p.grad is not None and (not torch.isfinite(p.grad).all()): grad_ok = False break if not grad_ok: print("[warn] non-finite gradients detected, skip optimizer step") optimizer.zero_grad(set_to_none=True) continue optimizer.step() if args.target_kl is not None and approx_kl > args.target_kl: break sps = int(global_step / max(1e-6, time.time() - start_time)) writer.add_scalar("losses/value_loss", v_loss.item(), global_step) writer.add_scalar("losses/policy_loss", pg_loss.item(), global_step) writer.add_scalar("losses/entropy", entropy_loss.item(), global_step) writer.add_scalar("losses/old_approx_kl", old_approx_kl.item(), global_step) writer.add_scalar("losses/approx_kl", approx_kl.item(), global_step) writer.add_scalar("losses/clipfrac", float(np.mean(clipfracs)) if clipfracs else 0.0, global_step) writer.add_scalar("charts/fps", sps, global_step) writer.add_scalar("charts/encoder_trainable", 1.0 if encoder_trainable else 0.0, global_step) train_reward_avg = float(np.mean(recent_train_rewards)) if recent_train_rewards else float("nan") train_len_avg = float(np.mean(recent_train_lengths)) if recent_train_lengths else float("nan") train_sr_avg = float(np.mean(recent_train_success)) if recent_train_success else float("nan") steps_to_eval = int(max(0, eval_interval - (global_step % eval_interval))) print( "step={} fps={} encoder_trainable={} " "train_reward@{}={:.3f} train_len@{}={:.1f} train_sr@{}={:.3f} " "loss_pi={:.4f} loss_v={:.4f} kl={:.6f} next_eval_in={}".format( global_step, sps, encoder_trainable, len(recent_train_rewards), train_reward_avg, len(recent_train_lengths), train_len_avg, len(recent_train_success), train_sr_avg, float(pg_loss.item()), float(v_loss.item()), float(approx_kl.item()), steps_to_eval, ) ) if wandb is not None: wandb.log( { "global_step": int(global_step), "train/reward_mean_window": train_reward_avg, "train/episode_length_window": train_len_avg, "train/success_rate_window": train_sr_avg, "losses/policy_loss": float(pg_loss.item()), "losses/value_loss": float(v_loss.item()), "losses/entropy": float(entropy_loss.item()), "losses/approx_kl": float(approx_kl.item()), "losses/clipfrac": float(np.mean(clipfracs)) if clipfracs else 0.0, "charts/fps": sps, "charts/encoder_trainable": 1.0 if encoder_trainable else 0.0, }, step=global_step, ) if global_step % eval_interval == 0: metrics = evaluate_policy(args, agent, device, run_name, global_step) writer.add_scalar("eval/success_rate", metrics["success_rate"], global_step) writer.add_scalar("eval/episode_length", metrics["episode_length"], global_step) writer.add_scalar("eval/reward_mean", metrics["reward_mean"], global_step) writer.add_scalar("eval/trajectory_saved_count", metrics["trajectory_saved_count"], global_step) writer.add_scalar("eval/fps", sps, global_step) print( "[eval] step={} success_rate={:.4f} episode_length={:.2f} " "reward_mean={:.4f} trajectory_saved_count={}".format( global_step, float(metrics["success_rate"]), float(metrics["episode_length"]), float(metrics["reward_mean"]), int(metrics["trajectory_saved_count"]), ) ) if wandb is not None: wandb.log( { "global_step": int(global_step), "eval/success_rate": metrics["success_rate"], "eval/episode_length": metrics["episode_length"], "eval/reward_mean": metrics["reward_mean"], "eval/trajectory_saved_count": metrics["trajectory_saved_count"], "eval/fps": sps, }, step=global_step, ) if metrics["success_rate"] > best_stable_sr: best_stable_sr = metrics["success_rate"] if args.save_best_ckpt: ckpt_dir = Path("runs") / run_name / "checkpoints" ckpt_dir.mkdir(parents=True, exist_ok=True) ckpt_path = ckpt_dir / f"best_sr_{best_stable_sr:.4f}_step_{global_step}.pt" torch.save( { "model": agent.state_dict(), "optimizer": optimizer.state_dict(), "global_step": global_step, "success_rate": best_stable_sr, "args": vars(args), }, ckpt_path, ) print(f"Saved best checkpoint to {ckpt_path}") if args.stop_training_on_converge and metrics["success_rate"] >= float(args.converge_success_threshold): print( f"[converged] eval success_rate={metrics['success_rate']:.4f} >= " f"threshold={args.converge_success_threshold:.4f}. Stop training." ) if args.collect_after_converge: collected = collect_success_trajectories_after_converge(args, agent, device, run_name, global_step) print(f"[collect] finished, saved {collected} successful trajectories") writer.add_scalar("collect/saved_success_trajectories", float(collected), global_step) if wandb is not None: wandb.log( { "global_step": int(global_step), "collect/saved_success_trajectories": float(collected), }, step=global_step, ) stop_training = True break if stop_training: print("[train] stopped after convergence-triggered collection.") envs.close() writer.close()