| """Train new PPO goal-reaching policies on the ROM (Sim2Sim campaign, Case 2). |
| |
| Copies the release GoalEnv dynamics, reward and PPO hyperparameters (rl_script/rl_train_goal_reach.py) |
| into a Gymnasium env, because SB3 2.7 needs Gymnasium. Only the training-noise config and the seed change. |
| |
| Configs: |
| nonoise : no action noise; powertrain fixed at tau0=1000, omega0=2600. |
| release : release semantics. N(0,0.05) on throttle and steering each step; tau0, omega0 drawn once |
| at env construction with sd 50 and 100. |
| robust : N(0,0.10) action noise; tau0, omega0 redrawn every episode with sd 100 and 200; |
| actuation delay drawn every episode uniform from {0,1,2} control steps (0-0.2 s). |
| |
| Usage: python train_ppo.py --config release --seed 11 --out policies/release_s11 |
| """ |
| import argparse |
| import json |
| import platform |
| import time |
| from pathlib import Path |
|
|
| import gymnasium as gym |
| import numpy as np |
| import torch as th |
| from gymnasium import spaces |
| from stable_baselines3 import PPO |
| from stable_baselines3.common.callbacks import BaseCallback |
| from stable_baselines3.common.vec_env import DummyVecEnv |
|
|
| CONFIGS = { |
| 'nonoise': dict(act_sigma=0.0, tau_sigma=0.0, omega_sigma=0.0, powertrain_redraw='never', delay_steps=[0]), |
| 'release': dict(act_sigma=0.05, tau_sigma=50.0, omega_sigma=100.0, powertrain_redraw='construction', delay_steps=[0]), |
| 'robust': dict(act_sigma=0.10, tau_sigma=100.0, omega_sigma=200.0, powertrain_redraw='episode', delay_steps=[0, 1, 2]), |
| } |
|
|
|
|
| class GoalEnvG(gym.Env): |
| """Release GoalEnv (same constants, dynamics, reward, termination), Gymnasium API, configurable noise.""" |
|
|
| def __init__(self, cfg, seed): |
| super().__init__() |
| self.cfg = cfg |
| self.rng = np.random.default_rng(seed) |
| self.action_space = spaces.Box(low=np.array([0.2, -1.0]), high=np.array([0.5, 1.0]), shape=(2,), dtype=np.float32) |
| self.observation_space = spaces.Box(low=-np.inf, high=np.inf, shape=(4,), dtype=np.float32) |
| self.r_wheel, self.i_wheel, self.gamma = 0.47, 6.69, 1 / 3 |
| self.c1, self.c0, self.car_length = 1e-4, 0.02, 1.0 |
| self.dt, self.max_steps = 0.1, 400 |
| self._draw_powertrain() |
| self.old_distance = 0.0 |
|
|
| def _draw_powertrain(self): |
| self.tau_0 = 1000 + self.rng.normal(0, self.cfg['tau_sigma']) |
| self.omega_0 = 2600 + self.rng.normal(0, self.cfg['omega_sigma']) |
|
|
| def f_vdot(self, alpha, v): |
| omega_m = v / (self.r_wheel * self.gamma) |
| f1_m = -self.tau_0 * omega_m / self.omega_0 + self.tau_0 |
| T_fun = alpha * f1_m - self.c1 * omega_m - self.c0 |
| return T_fun * self.gamma / self.i_wheel * self.r_wheel |
|
|
| def relative_state_to_goal(self): |
| x, y, theta, v = self.state[:4] |
| rot_mat = np.array([[np.cos(theta), np.sin(theta)], [-np.sin(theta), np.cos(theta)]]) |
| relative_pos = np.dot(rot_mat, np.array(self.goal) - np.array([x, y])) |
| relative_theta = np.arctan2(relative_pos[1], relative_pos[0]) |
| return np.array([relative_pos[0], relative_pos[1], relative_theta, v], dtype=np.float32) |
|
|
| def reset(self, seed=None, options=None): |
| if self.cfg['powertrain_redraw'] == 'episode': |
| self._draw_powertrain() |
| self.delay = int(self.rng.choice(self.cfg['delay_steps'])) |
| self.queue = [np.array([0.0, 0.0])] * self.delay |
| r = self.rng.uniform(10.0, 20.0) |
| theta = self.rng.uniform(0, 2 * np.pi) |
| self.goal = [r * np.cos(theta), r * np.sin(theta)] |
| self.state = np.array([0, 0, 0, 0.0], dtype=np.float32) |
| self.steps = 0 |
| self.old_distance = np.sqrt(self.goal[0] ** 2 + self.goal[1] ** 2) |
| return self.relative_state_to_goal(), {} |
|
|
| def step(self, action): |
| self.queue.append(np.asarray(action, dtype=np.float64)) |
| alpha, beta = self.queue.pop(0) |
| if self.cfg['act_sigma'] > 0: |
| alpha = alpha + self.rng.normal(0, self.cfg['act_sigma']) |
| beta = beta + self.rng.normal(0, self.cfg['act_sigma']) |
| x, y, theta, v = self.state |
| x_dot = np.cos(theta) * v |
| y_dot = np.sin(theta) * v |
| theta_dot = v * np.tan(beta * 0.7) / self.car_length |
| v_dot = self.f_vdot(alpha, v) |
| x += x_dot * self.dt |
| y += y_dot * self.dt |
| theta += theta_dot * self.dt |
| v += v_dot * self.dt |
| v = np.clip(v, 0.0, 5.0) |
| self.state = np.array([x, y, theta, v], dtype=np.float32) |
| self.steps += 1 |
| distance = np.sqrt((x - self.goal[0]) ** 2 + (y - self.goal[1]) ** 2) |
| progress = self.old_distance - distance |
| reward = 0.0 |
| if progress > 0: |
| reward = progress * 50 |
| if progress < 0.1: |
| reward -= 100 |
| done = False |
| if distance < 1.0: |
| reward += self.max_steps * 15 |
| done = True |
| if self.steps >= self.max_steps: |
| reward -= 1000 * distance |
| done = True |
| self.old_distance = distance |
| |
| return self.relative_state_to_goal(), float(reward), done, False, {'velocity': float(v)} |
|
|
|
|
| class SaveEvery(BaseCallback): |
| def __init__(self, every, out): |
| super().__init__() |
| self.every, self.out, self.k = every, Path(out), 0 |
| self.ep_returns, self.cur = [], 0.0 |
|
|
| def _on_step(self): |
| self.cur += float(self.locals['rewards'][0]) |
| if self.locals['dones'][0]: |
| self.ep_returns.append(self.cur) |
| self.cur = 0.0 |
| if self.n_calls % self.every == 0: |
| self.k += 1 |
| self.model.save(self.out / f'ckpt_{self.k}.zip') |
| return True |
|
|
|
|
| def main(): |
| p = argparse.ArgumentParser() |
| p.add_argument('--config', choices=list(CONFIGS), required=True) |
| p.add_argument('--seed', type=int, required=True) |
| p.add_argument('--out', required=True) |
| p.add_argument('--timesteps', type=int, default=2_000_000) |
| p.add_argument('--save-every', type=int, default=500_000) |
| a = p.parse_args() |
| th.set_num_threads(1) |
| out = Path(a.out) |
| out.mkdir(parents=True, exist_ok=False) |
| cfg = CONFIGS[a.config] |
| env = GoalEnvG(cfg, seed=a.seed + 7) |
| vec = DummyVecEnv([lambda: env]) |
| model = PPO('MlpPolicy', vec, learning_rate=3e-4, n_steps=env.max_steps * 3, batch_size=64, n_epochs=20, |
| gamma=0.99, clip_range=0.2, verbose=0, seed=a.seed, device='cpu', |
| policy_kwargs=dict(net_arch=dict(pi=[64, 128, 128, 64], vf=[64, 128, 128, 64]), activation_fn=th.nn.ReLU)) |
| cb = SaveEvery(a.save_every, out) |
| t0 = time.time() |
| model.learn(total_timesteps=a.timesteps, callback=cb) |
| rets = np.array(cb.ep_returns) |
| meta = dict(config=a.config, config_values=cfg, seed=a.seed, env_seed=a.seed + 7, timesteps=a.timesteps, |
| save_every=a.save_every, wall_s=time.time() - t0, |
| fixed_construction_powertrain=dict(tau0=env.tau_0, omega0=env.omega_0) if cfg['powertrain_redraw'] == 'construction' else None, |
| episodes=len(rets), mean_return_last100=float(rets[-100:].mean()) if len(rets) else None, |
| hyperparameters=dict(learning_rate=3e-4, n_steps=1200, batch_size=64, n_epochs=20, gamma=0.99, clip_range=0.2, |
| net_arch=[64, 128, 128, 64], activation='ReLU'), |
| versions=dict(python=platform.python_version(), torch=th.__version__, numpy=np.__version__, |
| sb3=__import__('stable_baselines3').__version__)) |
| np.save(out / 'episode_returns.npy', rets.astype(np.float32)) |
| (out / 'train_meta.json').write_text(json.dumps(meta, indent=2) + '\n') |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
