From a3b9b3e250323af71f69f1b67c44f8318813a840 Mon Sep 17 00:00:00 2001 From: ebuehrle <43623224+ebuehrle@users.noreply.github.com> Date: Tue, 15 Feb 2022 11:01:52 +0100 Subject: [PATCH] Port TRPO, PPO, GAIL --- .../etienne/intersimple/trpo_speed_lidar.py | 52 ++++ scratch/etienne/trpo/.gitignore | 232 ++++++++++++++++++ .../etienne/trpo/bc-intersimple-setobs2.py | 78 ++++++ scratch/etienne/trpo/core/discriminator.py | 74 ++++++ scratch/etienne/trpo/core/gail.py | 125 ++++++++++ scratch/etienne/trpo/core/optimization.py | 39 +++ scratch/etienne/trpo/core/policy.py | 96 ++++++++ scratch/etienne/trpo/core/ppo.py | 72 ++++++ scratch/etienne/trpo/core/reparam_module.py | 162 ++++++++++++ scratch/etienne/trpo/core/sampling.py | 73 ++++++ .../etienne/trpo/core/test_optimization.py | 23 ++ scratch/etienne/trpo/core/trpo.py | 79 ++++++ scratch/etienne/trpo/core/value.py | 48 ++++ scratch/etienne/trpo/core/value_estimation.py | 40 +++ .../etienne/trpo/gail-intersimple-minobs.py | 74 ++++++ .../etienne/trpo/gail-intersimple-minobs2.py | 100 ++++++++ .../etienne/trpo/gail-intersimple-normobs.py | 74 ++++++ .../etienne/trpo/gail-intersimple-setobs.py | 74 ++++++ .../gail-intersimple-setobs2-recurrent.py | 97 ++++++++ .../etienne/trpo/gail-intersimple-setobs2.py | 101 ++++++++ scratch/etienne/trpo/gail-intersimple.py | 54 ++++ scratch/etienne/trpo/gail-options-minobs.py | 97 ++++++++ scratch/etienne/trpo/gail-options-setobs.py | 97 ++++++++ scratch/etienne/trpo/gail-options-setobs2.py | 98 ++++++++ scratch/etienne/trpo/gail-pendulum.py | 39 +++ .../trpo/gail-ppo-intersimple-minobs.py | 75 ++++++ .../trpo/gail-ppo-intersimple-normobs.py | 75 ++++++ .../trpo/gail-ppo-intersimple-setobs2.py | 102 ++++++++ scratch/etienne/trpo/gail-ppo-intersimple.py | 55 +++++ .../etienne/trpo/gail-ppo-options-minobs.py | 96 ++++++++ .../etienne/trpo/gail-ppo-options-setobs.py | 96 ++++++++ .../etienne/trpo/gail-ppo-options-setobs2.py | 97 ++++++++ .../intersimple-expert-action-profiles.ipynb | 175 +++++++++++++ .../trpo/intersimple-expert-rollout-minobs.py | 54 ++++ .../intersimple-expert-rollout-minobs2.py | 53 ++++ .../intersimple-expert-rollout-normobs.py | 54 ++++ .../trpo/intersimple-expert-rollout-setobs.py | 54 ++++ .../intersimple-expert-rollout-setobs2.py | 53 ++++ .../trpo/intersimple-expert-rollout.py | 25 ++ scratch/etienne/trpo/options/options.py | 201 +++++++++++++++ scratch/etienne/trpo/options/test_options.py | 54 ++++ .../etienne/trpo/ppo-intersimple-minobs.py | 63 +++++ .../etienne/trpo/ppo-intersimple-minobs2.py | 62 +++++ .../etienne/trpo/ppo-intersimple-normobs.py | 61 +++++ scratch/etienne/trpo/ppo-intersimple.py | 41 ++++ scratch/etienne/trpo/ppo-options-minobs.py | 89 +++++++ scratch/etienne/trpo/ppo-pendulum.py | 27 ++ scratch/etienne/trpo/readme.md | 7 + .../sb3/sb3-ppo-intersimple-nocollision.py | 55 +++++ .../sb3/sb3-ppo-intersimple-nocollision2.py | 58 +++++ .../trpo/sb3/sb3-ppo-intersimple-rollout.py | 28 +++ .../etienne/trpo/sb3/sb3-ppo-intersimple.py | 23 ++ scratch/etienne/trpo/sb3/sb3-ppo-pendulum.py | 6 + .../etienne/trpo/sb3/sb3-trpo-intersimple.py | 16 ++ scratch/etienne/trpo/sb3/sb3-trpo-pendulum.py | 8 + .../etienne/trpo/trpo-intersimple-minobs.py | 88 +++++++ .../etienne/trpo/trpo-intersimple-minobs2.py | 87 +++++++ .../etienne/trpo/trpo-intersimple-normobs.py | 62 +++++ .../etienne/trpo/trpo-intersimple-setobs.py | 90 +++++++ .../etienne/trpo/trpo-intersimple-setobs2.py | 87 +++++++ scratch/etienne/trpo/trpo-intersimple.py | 42 ++++ scratch/etienne/trpo/trpo-options-minobs.py | 91 +++++++ scratch/etienne/trpo/trpo-pendulum-rollout.py | 17 ++ scratch/etienne/trpo/trpo-pendulum.py | 30 +++ scratch/etienne/trpo/trpo-walker.py | 26 ++ .../etienne/trpo/wgail-intersimple-minobs.py | 76 ++++++ .../etienne/trpo/wgail-intersimple-minobs2.py | 75 ++++++ .../etienne/trpo/wgail-intersimple-setobs2.py | 77 ++++++ scratch/etienne/trpo/wgail-intersimple.py | 56 +++++ scratch/etienne/trpo/wgail-options-setobs.py | 101 ++++++++ scratch/etienne/trpo/wgail-options-setobs2.py | 100 ++++++++ scratch/etienne/trpo/wgail-pendulum.py | 40 +++ .../trpo/wgail-ppo-intersimple-minobs.py | 77 ++++++ .../trpo/wgail-ppo-intersimple-setobs2.py | 78 ++++++ scratch/etienne/trpo/wgail-ppo-intersimple.py | 57 +++++ .../etienne/trpo/wgail-ppo-options-setobs.py | 98 ++++++++ .../etienne/trpo/wgail-ppo-options-setobs2.py | 99 ++++++++ scratch/etienne/trpo/wgail-ppo-pendulum.py | 44 ++++ scratch/etienne/trpo/wrappers.py | 74 ++++++ 79 files changed, 5633 insertions(+) create mode 100644 scratch/etienne/intersimple/trpo_speed_lidar.py create mode 100644 scratch/etienne/trpo/.gitignore create mode 100644 scratch/etienne/trpo/bc-intersimple-setobs2.py create mode 100644 scratch/etienne/trpo/core/discriminator.py create mode 100644 scratch/etienne/trpo/core/gail.py create mode 100644 scratch/etienne/trpo/core/optimization.py create mode 100644 scratch/etienne/trpo/core/policy.py create mode 100644 scratch/etienne/trpo/core/ppo.py create mode 100644 scratch/etienne/trpo/core/reparam_module.py create mode 100644 scratch/etienne/trpo/core/sampling.py create mode 100644 scratch/etienne/trpo/core/test_optimization.py create mode 100644 scratch/etienne/trpo/core/trpo.py create mode 100644 scratch/etienne/trpo/core/value.py create mode 100644 scratch/etienne/trpo/core/value_estimation.py create mode 100644 scratch/etienne/trpo/gail-intersimple-minobs.py create mode 100644 scratch/etienne/trpo/gail-intersimple-minobs2.py create mode 100644 scratch/etienne/trpo/gail-intersimple-normobs.py create mode 100644 scratch/etienne/trpo/gail-intersimple-setobs.py create mode 100644 scratch/etienne/trpo/gail-intersimple-setobs2-recurrent.py create mode 100644 scratch/etienne/trpo/gail-intersimple-setobs2.py create mode 100644 scratch/etienne/trpo/gail-intersimple.py create mode 100644 scratch/etienne/trpo/gail-options-minobs.py create mode 100644 scratch/etienne/trpo/gail-options-setobs.py create mode 100644 scratch/etienne/trpo/gail-options-setobs2.py create mode 100644 scratch/etienne/trpo/gail-pendulum.py create mode 100644 scratch/etienne/trpo/gail-ppo-intersimple-minobs.py create mode 100644 scratch/etienne/trpo/gail-ppo-intersimple-normobs.py create mode 100644 scratch/etienne/trpo/gail-ppo-intersimple-setobs2.py create mode 100644 scratch/etienne/trpo/gail-ppo-intersimple.py create mode 100644 scratch/etienne/trpo/gail-ppo-options-minobs.py create mode 100644 scratch/etienne/trpo/gail-ppo-options-setobs.py create mode 100644 scratch/etienne/trpo/gail-ppo-options-setobs2.py create mode 100644 scratch/etienne/trpo/intersimple-expert-action-profiles.ipynb create mode 100644 scratch/etienne/trpo/intersimple-expert-rollout-minobs.py create mode 100644 scratch/etienne/trpo/intersimple-expert-rollout-minobs2.py create mode 100644 scratch/etienne/trpo/intersimple-expert-rollout-normobs.py create mode 100644 scratch/etienne/trpo/intersimple-expert-rollout-setobs.py create mode 100644 scratch/etienne/trpo/intersimple-expert-rollout-setobs2.py create mode 100644 scratch/etienne/trpo/intersimple-expert-rollout.py create mode 100644 scratch/etienne/trpo/options/options.py create mode 100644 scratch/etienne/trpo/options/test_options.py create mode 100644 scratch/etienne/trpo/ppo-intersimple-minobs.py create mode 100644 scratch/etienne/trpo/ppo-intersimple-minobs2.py create mode 100644 scratch/etienne/trpo/ppo-intersimple-normobs.py create mode 100644 scratch/etienne/trpo/ppo-intersimple.py create mode 100644 scratch/etienne/trpo/ppo-options-minobs.py create mode 100644 scratch/etienne/trpo/ppo-pendulum.py create mode 100644 scratch/etienne/trpo/readme.md create mode 100644 scratch/etienne/trpo/sb3/sb3-ppo-intersimple-nocollision.py create mode 100644 scratch/etienne/trpo/sb3/sb3-ppo-intersimple-nocollision2.py create mode 100644 scratch/etienne/trpo/sb3/sb3-ppo-intersimple-rollout.py create mode 100644 scratch/etienne/trpo/sb3/sb3-ppo-intersimple.py create mode 100644 scratch/etienne/trpo/sb3/sb3-ppo-pendulum.py create mode 100644 scratch/etienne/trpo/sb3/sb3-trpo-intersimple.py create mode 100644 scratch/etienne/trpo/sb3/sb3-trpo-pendulum.py create mode 100644 scratch/etienne/trpo/trpo-intersimple-minobs.py create mode 100644 scratch/etienne/trpo/trpo-intersimple-minobs2.py create mode 100644 scratch/etienne/trpo/trpo-intersimple-normobs.py create mode 100644 scratch/etienne/trpo/trpo-intersimple-setobs.py create mode 100644 scratch/etienne/trpo/trpo-intersimple-setobs2.py create mode 100644 scratch/etienne/trpo/trpo-intersimple.py create mode 100644 scratch/etienne/trpo/trpo-options-minobs.py create mode 100644 scratch/etienne/trpo/trpo-pendulum-rollout.py create mode 100644 scratch/etienne/trpo/trpo-pendulum.py create mode 100644 scratch/etienne/trpo/trpo-walker.py create mode 100644 scratch/etienne/trpo/wgail-intersimple-minobs.py create mode 100644 scratch/etienne/trpo/wgail-intersimple-minobs2.py create mode 100644 scratch/etienne/trpo/wgail-intersimple-setobs2.py create mode 100644 scratch/etienne/trpo/wgail-intersimple.py create mode 100644 scratch/etienne/trpo/wgail-options-setobs.py create mode 100644 scratch/etienne/trpo/wgail-options-setobs2.py create mode 100644 scratch/etienne/trpo/wgail-pendulum.py create mode 100644 scratch/etienne/trpo/wgail-ppo-intersimple-minobs.py create mode 100644 scratch/etienne/trpo/wgail-ppo-intersimple-setobs2.py create mode 100644 scratch/etienne/trpo/wgail-ppo-intersimple.py create mode 100644 scratch/etienne/trpo/wgail-ppo-options-setobs.py create mode 100644 scratch/etienne/trpo/wgail-ppo-options-setobs2.py create mode 100644 scratch/etienne/trpo/wgail-ppo-pendulum.py create mode 100644 scratch/etienne/trpo/wrappers.py diff --git a/scratch/etienne/intersimple/trpo_speed_lidar.py b/scratch/etienne/intersimple/trpo_speed_lidar.py new file mode 100644 index 0000000..74c5413 --- /dev/null +++ b/scratch/etienne/intersimple/trpo_speed_lidar.py @@ -0,0 +1,52 @@ +# %% +from sb3_contrib import TRPO +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools + +model_name = "trpo_speed_lidar" + +#def reward(state, action, info): +# speed = state[2].item() +# r = speed if speed < 10 else (10 - 5 * (speed - 10)) +# return 0.1 * r + +env = IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), +) + +# %% +model = TRPO( + "MlpPolicy", env, + learning_rate=1e-4, + verbose=1, + tensorboard_log='runs/', + #use_sde=True, + #sde_sample_freq=4, +) +model.learn(total_timesteps=1000000) +model.save(model_name) + +print('Done training.') + +del model # remove to demonstrate saving and loading + +# %% +model = TRPO.load(model_name) + +obs = env.reset() +while True: + action, _states = model.predict(obs) + obs, rewards, done, info = env.step(action) + env.render(mode='post') + if done: + break + +env.close(filestr='render/'+model_name) + +# %% diff --git a/scratch/etienne/trpo/.gitignore b/scratch/etienne/trpo/.gitignore new file mode 100644 index 0000000..7491629 --- /dev/null +++ b/scratch/etienne/trpo/.gitignore @@ -0,0 +1,232 @@ +PyTorch-Reparam-Module +cg.ipynb +vec-env.ipynb +*.zip +*.pt +*.mp4 +*.pkl +runs/ + +# Created by https://www.toptal.com/developers/gitignore/api/linux,macos,python,visualstudiocode +# Edit at https://www.toptal.com/developers/gitignore?templates=linux,macos,python,visualstudiocode + +### Linux ### +*~ + +# temporary files which can be created if a process still has a handle open of a deleted file +.fuse_hidden* + +# KDE directory preferences +.directory + +# Linux trash folder which might appear on any partition or disk +.Trash-* + +# .nfs files are created when an open file is removed but is still being accessed +.nfs* + +### macOS ### +# General +.DS_Store +.AppleDouble +.LSOverride + +# Icon must end with two \r +Icon + + +# Thumbnails +._* + +# Files that might appear in the root of a volume +.DocumentRevisions-V100 +.fseventsd +.Spotlight-V100 +.TemporaryItems +.Trashes +.VolumeIcon.icns +.com.apple.timemachine.donotpresent + +# Directories potentially created on remote AFP share +.AppleDB +.AppleDesktop +Network Trash Folder +Temporary Items +.apdisk + +### Python ### +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintainted in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +#.idea/ + +### VisualStudioCode ### +.vscode/* +!.vscode/settings.json +!.vscode/tasks.json +!.vscode/launch.json +!.vscode/extensions.json +!.vscode/*.code-snippets + +# Local History for Visual Studio Code +.history/ + +# Built Visual Studio Code Extensions +*.vsix + +### VisualStudioCode Patch ### +# Ignore all local history of files +.history +.ionide + +# Support for Project snippet scope + +# End of https://www.toptal.com/developers/gitignore/api/linux,macos,python,visualstudiocode \ No newline at end of file diff --git a/scratch/etienne/trpo/bc-intersimple-setobs2.py b/scratch/etienne/trpo/bc-intersimple-setobs2.py new file mode 100644 index 0000000..da9c51d --- /dev/null +++ b/scratch/etienne/trpo/bc-intersimple-setobs2.py @@ -0,0 +1,78 @@ +# %% +import torch +from core.policy import SetPolicy +from tqdm import tqdm + +expert_data = torch.load('intersimple-expert-data-setobs2.pt') +states, actions, _, dones = expert_data + +policy = SetPolicy(actions.shape[-1]) + +policy = policy.cuda() +optim = torch.optim.Adam(policy.parameters(), lr=1e-4) +states = states[~dones].cuda() +actions = actions[~dones].cuda() + +for _ in tqdm(range(10000)): + optim.zero_grad() + loss = -policy.log_prob(policy(states), actions).mean() + loss.backward() + optim.step() + + print('Loss', loss) + +torch.save(policy.state_dict(), 'bc-intersimple-setobs2.pt') + +# %% +import numpy as np +from core.policy import SetPolicy +from wrappers import Setobs, TransformObservation, CollisionPenaltyWrapper +from intersim.envs import IntersimpleLidarFlatRandom +from intersim.envs.intersimple import speed_reward +import functools + +policy = SetPolicy(actions.shape[-1]) +policy.load_state_dict(torch.load('bc-intersimple-setobs2.pt')) + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +env = Setobs( + TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlatRandom( + n_rays=5, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, + ), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10)) +) + +obs = env.reset() +env.render(mode='post') +for i in range(300): + #action, _ = policy.predict(torch.tensor(obs)) + action = policy.sample(policy(torch.tensor(obs, dtype=torch.float32))) + obs, reward, done, _ = env.step(action) + env.render(mode='post') + print('step', i, 'reward', reward) + if done: + break +env.close() + +# %% diff --git a/scratch/etienne/trpo/core/discriminator.py b/scratch/etienne/trpo/core/discriminator.py new file mode 100644 index 0000000..8074c32 --- /dev/null +++ b/scratch/etienne/trpo/core/discriminator.py @@ -0,0 +1,74 @@ +import torch +import torch.nn as nn + +class Discriminator(nn.Module): + + def __init__(self): + super().__init__() + self.nn = nn.Sequential( + nn.LazyLinear(50), + nn.Tanh(), + nn.LazyLinear(50), + nn.Tanh(), + nn.LazyLinear(1), + ) + + def forward(self, states, actions): + return self.nn(torch.cat((states, actions), dim=-1)).squeeze(-1) + +class DeepsetDiscriminator(nn.Module): + + def __init__(self): + super().__init__() + self.elem = nn.Sequential( + nn.LazyLinear(10), + nn.Tanh(), + nn.LazyLinear(10), + nn.Tanh(), + nn.LazyLinear(10), + ) + self.glob = nn.Sequential( + nn.LazyLinear(10), + nn.Tanh(), + nn.LazyLinear(10), + nn.Tanh(), + nn.LazyLinear(1), + ) + + def forward(self, states, actions): + actions = actions.unsqueeze(-2) + actions = actions.expand(*actions.shape[:-2], states.shape[-2], actions.shape[-1]) + sa = torch.cat((states, actions), dim=-1) + return self.glob(self.elem(sa).sum(-2)).squeeze(-1) + +class RecurrentDiscriminator(nn.Module): + + def __init__(self): + super().__init__() + self.state_dim = 10 + self.state = nn.Sequential( + nn.LazyLinear(10), + nn.Tanh(), + nn.LazyLinear(10), + nn.Tanh(), + nn.LazyLinear(self.state_dim), + ) + self.glob = nn.Sequential( + nn.LazyLinear(10), + nn.Tanh(), + nn.LazyLinear(1), + ) + + def forward(self, states, actions): + actions = actions.unsqueeze(-2) + batch_size = actions.shape[:-2] + set_size = states.shape[-2] + action_dim = actions.shape[-1] + actions = actions.expand(*batch_size, set_size, action_dim) + sa = torch.cat((states, actions), dim=-1) + + state = torch.zeros((*batch_size, self.state_dim)) + for i in range(set_size): + state = state + self.state(torch.cat((state, sa[..., i, :]), dim=-1)) + + return self.glob(state).squeeze(-1) diff --git a/scratch/etienne/trpo/core/gail.py b/scratch/etienne/trpo/core/gail.py new file mode 100644 index 0000000..d630bd4 --- /dev/null +++ b/scratch/etienne/trpo/core/gail.py @@ -0,0 +1,125 @@ +import torch +import torch.nn.functional as F +from dataclasses import dataclass +from core.reparam_module import ReparamPolicy +from core.sampling import rollout +from core.trpo import trpo_step +from core.ppo import ppo_step +from tqdm import tqdm + +class TerminalLogger: + def add_scalar(self, key, scalar, i=None): + if i is not None: + print('Iteration', i, end=' ') + print(key, scalar) + +@dataclass +class Buffer: + states: torch.Tensor + actions: torch.Tensor + rewards: torch.Tensor + dones: torch.Tensor + +def roll_buffer(buffer, *args, **kwargs): + return Buffer( + torch.roll(buffer.states, *args, **kwargs), + torch.roll(buffer.actions, *args, **kwargs), + torch.roll(buffer.rewards, *args, **kwargs), + torch.roll(buffer.dones, *args, **kwargs), + ) + +def gail(env_fn, expert_data, discriminator, disc_opt, disc_iters, policy, value, + v_opt, v_iters, epochs, rollout_episodes, rollout_steps, gamma, + gae_lambda, delta, backtrack_coeff, backtrack_iters, cg_iters=10, cg_damping=0.1, wasserstein=False, wasserstein_c=None, logger=TerminalLogger()): + + policy(torch.zeros(env_fn(0).observation_space.shape)) + policy = ReparamPolicy(policy) + + logger.add_scalar('expert/mean_episode_length', (~expert_data.dones).sum() / expert_data.states.shape[0]) + logger.add_scalar('expert/mean_reward_per_episode', expert_data.rewards[~expert_data.dones].sum() / expert_data.states.shape[0]) + + for epoch in tqdm(range(epochs)): + generator_data = Buffer(*rollout(env_fn, policy, rollout_episodes, rollout_steps)) + + logger.add_scalar('gen/mean_episode_length', (~generator_data.dones).sum() / generator_data.states.shape[0], epoch) + logger.add_scalar('gen/mean_reward_per_episode', generator_data.rewards[~generator_data.dones].sum() / generator_data.states.shape[0], epoch) + + discriminator, loss = train_discriminator(expert_data, generator_data, discriminator, disc_opt, disc_iters, wasserstein, wasserstein_c) + if wasserstein: + generator_data.rewards = discriminator(generator_data.states, generator_data.actions) + else: + generator_data.rewards = -F.logsigmoid(discriminator(generator_data.states, generator_data.actions)) + logger.add_scalar('disc/final_loss', loss, epoch) + logger.add_scalar('disc/mean_reward_per_episode', generator_data.rewards[~generator_data.dones].sum() / generator_data.states.shape[0], epoch) + + value, policy = trpo_step(value, policy, generator_data.states, generator_data.actions, generator_data.rewards, generator_data.dones, gamma, gae_lambda, delta, backtrack_coeff, backtrack_iters, v_opt, v_iters, cg_iters, cg_damping) + expert_data = roll_buffer(expert_data, shifts=-3, dims=0) + + return value, policy + +def gail_ppo(env_fn, expert_data, discriminator, disc_opt, disc_iters, policy, value, + v_opt, v_iters, epochs, rollout_episodes, rollout_steps, gamma, + gae_lambda, clip_ratio, pi_opt, pi_iters, target_kl=None, max_grad_norm=None, wasserstein=False, wasserstein_c=None, logger=TerminalLogger()): + + logger.add_scalar('expert/mean_episode_length', (~expert_data.dones).sum() / expert_data.states.shape[0]) + logger.add_scalar('expert/mean_reward_per_episode', expert_data.rewards[~expert_data.dones].sum() / expert_data.states.shape[0]) + + for epoch in range(epochs): + generator_data = Buffer(*rollout(env_fn, policy, rollout_episodes, rollout_steps)) + + logger.add_scalar('gen/mean_episode_length', (~generator_data.dones).sum() / generator_data.states.shape[0], epoch) + logger.add_scalar('gen/mean_reward_per_episode', generator_data.rewards[~generator_data.dones].sum() / generator_data.states.shape[0], epoch) + + discriminator, loss = train_discriminator(expert_data, generator_data, discriminator, disc_opt, disc_iters, wasserstein, wasserstein_c) + if wasserstein: + generator_data.rewards = discriminator(generator_data.states, generator_data.actions) + else: + generator_data.rewards = -F.logsigmoid(discriminator(generator_data.states, generator_data.actions)) + logger.add_scalar('disc/final_loss', loss, epoch) + logger.add_scalar('disc/mean_reward_per_episode', generator_data.rewards[~generator_data.dones].sum() / generator_data.states.shape[0], epoch) + + value, policy = ppo_step(value, policy, generator_data.states, generator_data.actions, generator_data.rewards, generator_data.dones, clip_ratio, gamma, gae_lambda, pi_opt, pi_iters, v_opt, v_iters, target_kl, max_grad_norm) + expert_data = roll_buffer(expert_data, shifts=-3, dims=0) + + return value, policy + +def train_discriminator(expert_data, generator_data, discriminator, disc_opt, disc_iters, wasserstein, wasserstein_c=None): + + n_expert_samples = (~expert_data.dones).sum() + n_generator_samples = (~generator_data.dones).sum() + n_samples = torch.minimum(n_expert_samples, n_generator_samples) + + gen_states = generator_data.states[~generator_data.dones][:n_samples] + gen_actions = generator_data.actions[~generator_data.dones][:n_samples] + exp_states = expert_data.states[~expert_data.dones][:n_samples] + exp_actions = expert_data.actions[~expert_data.dones][:n_samples] + + states = torch.cat((exp_states, gen_states), dim=0).detach() + actions = torch.cat((exp_actions, gen_actions), dim=0).detach() + labels = torch.cat((torch.zeros(n_samples), torch.ones(n_samples))).detach() + + # print('Batch augmentation on') + # random_states = torch.rand_like(gen_states) + # random_actions = torch.rand_like(gen_actions) + # states = torch.cat((exp_states, gen_states, random_states), dim=0).detach() + # actions = torch.cat((exp_actions, gen_actions, random_actions), dim=0).detach() + # labels = torch.cat((torch.zeros(n_samples), torch.ones(n_samples), torch.ones(n_samples))).detach() + + for _ in range(disc_iters): + disc_opt.zero_grad() + pred = discriminator(states, actions) + + if wasserstein: + loss = -(pred * (1 - labels) - pred * labels).mean() + else: + loss = F.binary_cross_entropy(torch.sigmoid(pred), labels) + + loss.backward() + disc_opt.step() + + if wasserstein_c is not None: + with torch.no_grad(): + for param in discriminator.parameters(): + param.clamp_(-wasserstein_c, wasserstein_c) + + return discriminator, loss diff --git a/scratch/etienne/trpo/core/optimization.py b/scratch/etienne/trpo/core/optimization.py new file mode 100644 index 0000000..4057214 --- /dev/null +++ b/scratch/etienne/trpo/core/optimization.py @@ -0,0 +1,39 @@ +import torch + +def conjugate_gradient(A, b, max_iters, res_tol=1e-10): + x = torch.zeros_like(b) + r = b - A(x) + p = r + + rTr = r.T @ r + + for _ in range(max_iters): + Ap = A(p) + alpha = rTr / (p.T @ Ap) + x = x + alpha * p + + r = r - alpha * Ap + if torch.norm(r) < res_tol: + break + + rTrnew = r.T @ r + beta = rTrnew / rTr + p = r + beta * p + rTr = rTrnew + + return x + +def line_search(f, x0, dx, g0, alpha, condition, max_steps=10, c1=0.1): + assert 0 < alpha < 1 + + f0 = f(x0) + for _ in range(max_steps): + x = x0 + dx + + if (f(x) > f0 + c1 * g0.T @ dx) and condition(x): + return x + + dx *= alpha + + print('Line search failed, returning x0') + return x0 diff --git a/scratch/etienne/trpo/core/policy.py b/scratch/etienne/trpo/core/policy.py new file mode 100644 index 0000000..579e72b --- /dev/null +++ b/scratch/etienne/trpo/core/policy.py @@ -0,0 +1,96 @@ +import torch +import torch.nn as nn +from torch.distributions import Independent, Normal, Categorical +from torch.distributions.kl import kl_divergence + +class BasePolicy(nn.Module): + + def __init__(self, action_dim): + super().__init__() + self.action_dim = action_dim + + def torch_dist(self, dist): + return Independent(Normal(dist[..., :self.action_dim], dist[..., self.action_dim:].exp()), 1) + + def sample(self, dist): + return self.torch_dist(dist).sample() + + def predict(self, states): + return self.sample(self.forward(states)) + + def log_prob(self, dist, actions): + return self.torch_dist(dist).log_prob(actions) + + def kl_divergence(self, dist1, dist2): + d1 = self.torch_dist(dist1) + d2 = self.torch_dist(dist2) + return kl_divergence(d1, d2) + +class Policy(BasePolicy): + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.nn = nn.Sequential( + nn.LazyLinear(50), + nn.Tanh(), + nn.LazyLinear(50), + nn.Tanh(), + nn.LazyLinear(2 * self.action_dim), + ) + + def forward(self, states): + return self.nn(states) + +class DiscretePolicy(BasePolicy): + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.nn = nn.Sequential( + nn.LazyLinear(50), + nn.Tanh(), + nn.LazyLinear(50), + nn.Tanh(), + nn.LazyLinear(self.action_dim), + ) + + def forward(self, states): + return self.nn(states) + + def torch_dist(self, dist): + return Categorical(logits=dist) + +class SetPolicy(Policy): + + def forward(self, states): + batch_size = states.shape[:-2] + states = torch.cat((states[..., :1, [0, 1]], states[..., :, [2, 5]]), axis=-2).reshape(*batch_size, -1) + return super().forward(states) + +class SetDiscretePolicy(DiscretePolicy): + + def forward(self, states): + batch_size = states.shape[:-2] + states = torch.cat((states[..., :1, [0, 1]], states[..., :, [2, 5]]), axis=-2).reshape(*batch_size, -1) + return super().forward(states) + +class DeepSetPolicy(BasePolicy): + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.elem = nn.Sequential( + nn.LazyLinear(10), + nn.Tanh(), + nn.LazyLinear(10), + nn.Tanh(), + nn.LazyLinear(10), + ) + self.glob = nn.Sequential( + nn.LazyLinear(10), + nn.Tanh(), + nn.LazyLinear(10), + nn.Tanh(), + nn.LazyLinear(2 * self.action_dim), + ) + + def forward(self, states): + return self.glob(self.elem(states).sum(-2)) diff --git a/scratch/etienne/trpo/core/ppo.py b/scratch/etienne/trpo/core/ppo.py new file mode 100644 index 0000000..c742061 --- /dev/null +++ b/scratch/etienne/trpo/core/ppo.py @@ -0,0 +1,72 @@ +import torch +from core.sampling import rollout +from core.value_estimation import gae + +def ppo(env_fn, value, policy, epochs, rollout_episodes, rollout_steps, gamma, gae_lambda, clip_ratio, pi_opt, pi_iters, v_opt, v_iters, target_kl=None, max_grad_norm=None): + + for epoch in range(epochs): + policy.eval() + states, actions, rewards, dones = rollout(env_fn, policy, rollout_episodes, rollout_steps) + + print('mean', states[~dones].mean(0)) + print('std', states[~dones].std(0)) + + print(f'Iteration {epoch} mean episode length {(~dones).sum() / states.shape[0]}') + print(f'Iteration {epoch} mean reward per episode {rewards[~dones].sum() / states.shape[0]}') + + policy.train() + value.train() + value, policy = ppo_step(value, policy, states, actions, rewards, dones, clip_ratio, gamma, gae_lambda, pi_opt, pi_iters, v_opt, v_iters, target_kl, max_grad_norm) + + return value, policy + +def ppo_step(value, policy, states, actions, rewards, dones, clip_ratio, gamma, gae_lambda, pi_opt, pi_iters, v_opt, v_iters, target_kl, max_grad_norm): + + states = states.detach() + actions = actions.detach() + rewards = rewards.detach() + dones = dones.detach() + + advantages, returns, valid = gae(states, rewards, value(states), dones, gamma, gae_lambda) + advantages = advantages.detach() + returns = returns.detach() + + # update value function + + for _ in range(v_iters): + v_opt.zero_grad() + value_loss = (value(states) - returns).pow(2)[valid].mean() + value_loss.backward() + v_opt.step() + + # update policy + + old_dist = policy(states).detach() + old_logprob = policy.log_prob(old_dist, actions).detach() + + def g(advantages, clip_ratio): + return torch.where(advantages >= 0, (1 + clip_ratio) * advantages, (1 - clip_ratio) * advantages) + + def L(states, actions, advantages, clip_ratio): + return torch.minimum( + (policy.log_prob(policy(states), actions) - old_logprob).exp() * advantages, + g(advantages, clip_ratio) + )[valid].mean() + + for _ in range(pi_iters): + pi_opt.zero_grad() + ppo_loss = -L(states, actions, advantages, clip_ratio) + ppo_loss.backward() + + if max_grad_norm: + torch.nn.utils.clip_grad_norm(policy.parameters(), max_grad_norm) + + pi_opt.step() + + kl = policy.kl_divergence(policy(states), old_dist)[valid].mean() + if target_kl and kl > target_kl: + break + + print('KL', kl.item()) + + return value, policy diff --git a/scratch/etienne/trpo/core/reparam_module.py b/scratch/etienne/trpo/core/reparam_module.py new file mode 100644 index 0000000..5bcd613 --- /dev/null +++ b/scratch/etienne/trpo/core/reparam_module.py @@ -0,0 +1,162 @@ +# Source: https://github.com/SsnL/PyTorch-Reparam-Module + +import torch +import torch.nn as nn +import warnings +import types +from collections import namedtuple +from contextlib import contextmanager + +class ReparamModule(nn.Module): + def __init__(self, module): + super(ReparamModule, self).__init__() + self.module = module + + param_infos = [] + shared_param_memo = {} + shared_param_infos = [] + params = [] + param_numels = [] + param_shapes = [] + for m in self.modules(): + for n, p in m.named_parameters(recurse=False): + if p is not None: + if p in shared_param_memo: + shared_m, shared_n = shared_param_memo[p] + shared_param_infos.append((m, n, shared_m, shared_n)) + else: + shared_param_memo[p] = (m, n) + param_infos.append((m, n)) + params.append(p.detach()) + param_numels.append(p.numel()) + param_shapes.append(p.size()) + + assert len(set(p.dtype for p in params)) <= 1, \ + "expects all parameters in module to have same dtype" + + # store the info for unflatten + self._param_infos = tuple(param_infos) + self._shared_param_infos = tuple(shared_param_infos) + self._param_numels = tuple(param_numels) + self._param_shapes = tuple(param_shapes) + + # flatten + flat_param = nn.Parameter(torch.cat([p.reshape(-1) for p in params], 0)) + self.register_parameter('flat_param', flat_param) + self.param_numel = flat_param.numel() + del params + del shared_param_memo + + # deregister the names as parameters + for m, n in self._param_infos: + delattr(m, n) + for m, n, _, _ in self._shared_param_infos: + delattr(m, n) + + # register the views as plain attributes + self._unflatten_param(self.flat_param) + + # now buffers + # they are not reparametrized. just store info as (module, name, buffer) + buffer_infos = [] + for m in self.modules(): + for n, b in m.named_buffers(recurse=False): + if b is not None: + buffer_infos.append((m, n, b)) + + self._buffer_infos = tuple(buffer_infos) + self._traced_self = None + + def trace(self, example_input, **trace_kwargs): + assert self._traced_self is None, 'This ReparamModule is already traced' + + if isinstance(example_input, torch.Tensor): + example_input = (example_input,) + example_input = tuple(example_input) + example_param = (self.flat_param.detach().clone(),) + example_buffers = (tuple(b.detach().clone() for _, _, b in self._buffer_infos),) + + self._traced_self = torch.jit.trace_module( + self, + inputs=dict( + _forward_with_param=example_param + example_input, + _forward_with_param_and_buffers=example_param + example_buffers + example_input, + ), + **trace_kwargs, + ) + + # replace forwards with traced versions + self._forward_with_param = self._traced_self._forward_with_param + self._forward_with_param_and_buffers = self._traced_self._forward_with_param_and_buffers + return self + + def clear_views(self): + for m, n in self._param_infos: + setattr(m, n, None) # This will set as plain attr + + def _apply(self, *args, **kwargs): + if self._traced_self is not None: + self._traced_self._apply(*args, **kwargs) + return self + return super(ReparamModule, self)._apply(*args, **kwargs) + + def _unflatten_param(self, flat_param): + ps = (t.view(s) for (t, s) in zip(flat_param.split(self._param_numels), self._param_shapes)) + for (m, n), p in zip(self._param_infos, ps): + setattr(m, n, p) # This will set as plain attr + for (m, n, shared_m, shared_n) in self._shared_param_infos: + setattr(m, n, getattr(shared_m, shared_n)) + + @contextmanager + def unflattened_param(self, flat_param): + saved_views = [getattr(m, n) for m, n in self._param_infos] + self._unflatten_param(flat_param) + yield + # Why not just `self._unflatten_param(self.flat_param)`? + # 1. because of https://github.com/pytorch/pytorch/issues/17583 + # 2. slightly faster since it does not require reconstruct the split+view + # graph + for (m, n), p in zip(self._param_infos, saved_views): + setattr(m, n, p) + for (m, n, shared_m, shared_n) in self._shared_param_infos: + setattr(m, n, getattr(shared_m, shared_n)) + + @contextmanager + def replaced_buffers(self, buffers): + for (m, n, _), new_b in zip(self._buffer_infos, buffers): + setattr(m, n, new_b) + yield + for m, n, old_b in self._buffer_infos: + setattr(m, n, old_b) + + def _forward_with_param_and_buffers(self, flat_param, buffers, *inputs, **kwinputs): + with self.unflattened_param(flat_param): + with self.replaced_buffers(buffers): + return self.module(*inputs, **kwinputs) + + def _forward_with_param(self, flat_param, *inputs, **kwinputs): + with self.unflattened_param(flat_param): + return self.module(*inputs, **kwinputs) + + def forward(self, *inputs, flat_param=None, buffers=None, **kwinputs): + if flat_param is None: + flat_param = self.flat_param + if buffers is None: + return self._forward_with_param(flat_param, *inputs, **kwinputs) + else: + return self._forward_with_param_and_buffers(flat_param, tuple(buffers), *inputs, **kwinputs) + + +class ReparamPolicy(ReparamModule): + + def sample(self, *args, **kwargs): + return self.module.sample(*args, **kwargs) + + def log_prob(self, *args, **kwargs): + return self.module.log_prob(*args, **kwargs) + + def kl_divergence(self, *args, **kwargs): + return self.module.kl_divergence(*args, **kwargs) + + def predict(self, *args, **kwargs): + return self.module.predict(*args, **kwargs) diff --git a/scratch/etienne/trpo/core/sampling.py b/scratch/etienne/trpo/core/sampling.py new file mode 100644 index 0000000..66fbbef --- /dev/null +++ b/scratch/etienne/trpo/core/sampling.py @@ -0,0 +1,73 @@ +import torch +import gym +from stable_baselines3.common.vec_env import DummyVecEnv as VecEnv +from tqdm import tqdm + +def rollout(env_fn, policy, n_episodes, max_steps_per_episode): + env = env_fn(0) + states = torch.zeros(n_episodes, max_steps_per_episode + 1, *env.observation_space.shape) + actions = torch.zeros(n_episodes, max_steps_per_episode + 1, *env.action_space.shape) + rewards = torch.zeros(n_episodes, max_steps_per_episode + 1) + dones = torch.ones(n_episodes, max_steps_per_episode + 1, dtype=bool) + + env = VecEnv(list(map(lambda i: (lambda: env_fn(i)), range(n_episodes)))) + + states[:, 0] = torch.tensor(env.reset()).clone().detach() + dones[:, 0] = False + + for s in range(max_steps_per_episode): + actions[:, s] = policy.sample(policy(states[:, s])).clone().detach() + + clipped_actions = actions[:, s] + if isinstance(env.action_space, gym.spaces.Box): + clipped_actions = torch.clamp(clipped_actions, torch.from_numpy(env.action_space.low), torch.from_numpy(env.action_space.high)) + + o, r, d, _ = env.step(clipped_actions) + states[:, s + 1] = torch.tensor(o).clone().detach() + rewards[:, s] = torch.tensor(r).clone().detach() + dones[:, s + 1] = torch.tensor(d).clone().detach() + + dones = dones.cumsum(1) > 0 + + states = states[:, :max_steps_per_episode] + actions = actions[:, :max_steps_per_episode] + rewards = rewards[:, :max_steps_per_episode] + dones = dones[:, :max_steps_per_episode] + + return states, actions, rewards, dones + + +def rollout_sb3(env, policy, n_episodes, max_steps_per_episode): + states = torch.zeros(n_episodes, max_steps_per_episode + 1, *env.observation_space.shape) + actions = torch.zeros(n_episodes, max_steps_per_episode + 1, *env.action_space.shape) + rewards = torch.zeros(n_episodes, max_steps_per_episode + 1) + dones = torch.ones(n_episodes, max_steps_per_episode + 1, dtype=bool) + + for e in tqdm(range(n_episodes)): + states[e, 0] = torch.tensor(env.reset()).clone().detach() + dones[e, 0] = False + + for s in range(max_steps_per_episode): + action, _ = policy.predict(states[e, s]) + actions[e, s] = torch.tensor(action).clone().detach() + + clipped_actions = actions[e, s] + if isinstance(env.action_space, gym.spaces.Box): + clipped_actions = torch.clamp(clipped_actions, torch.from_numpy(env.action_space.low), torch.from_numpy(env.action_space.high)) + + o, r, d, _ = env.step(clipped_actions) + states[e, s + 1] = torch.tensor(o).clone().detach() + rewards[e, s] = torch.tensor(r).clone().detach() + dones[e, s + 1] = torch.tensor(d).clone().detach() + + if d: + break + + dones = dones.cumsum(1) > 0 + + states = states[:, :max_steps_per_episode] + actions = actions[:, :max_steps_per_episode] + rewards = rewards[:, :max_steps_per_episode] + dones = dones[:, :max_steps_per_episode] + + return states, actions, rewards, dones diff --git a/scratch/etienne/trpo/core/test_optimization.py b/scratch/etienne/trpo/core/test_optimization.py new file mode 100644 index 0000000..aa49bb5 --- /dev/null +++ b/scratch/etienne/trpo/core/test_optimization.py @@ -0,0 +1,23 @@ +import torch +from optimization import conjugate_gradient + +def test_cg_eye(): + A = torch.eye(2) + b = torch.tensor([1., 2.]) + x1 = conjugate_gradient(lambda x: A @ x, b, 2) + x2 = torch.inverse(A) @ b + assert torch.allclose(x1, x2) + +def test_cg_eyep1(): + A = torch.eye(2) + 1 + b = torch.tensor([1., 2.]) + x1 = conjugate_gradient(lambda x: A @ x, b, 2) + x2 = torch.inverse(A) @ b + assert torch.allclose(x1, x2, atol=1e-7) + +def test_cg3(): + A = torch.tensor([[4., 2.], [2., 4.]]) + b = torch.tensor([2., 1.]) + x1 = conjugate_gradient(lambda x: A @ x, b, 100) + x2 = torch.inverse(A) @ b + assert torch.allclose(x1, x2) diff --git a/scratch/etienne/trpo/core/trpo.py b/scratch/etienne/trpo/core/trpo.py new file mode 100644 index 0000000..d91e363 --- /dev/null +++ b/scratch/etienne/trpo/core/trpo.py @@ -0,0 +1,79 @@ +import torch +from core.reparam_module import ReparamPolicy +from core.sampling import rollout +from core.value_estimation import gae +from core.optimization import conjugate_gradient, line_search + +def trpo(env_fn, value, policy, epochs, rollout_episodes, rollout_steps, gamma, gae_lambda, delta, backtrack_coeff, backtrack_iters, v_opt, v_iters, cg_iters=10, cg_damping=0.1): + + policy(torch.zeros(env_fn(0).observation_space.shape)) + policy = ReparamPolicy(policy) + + for epoch in range(epochs): + policy.eval() + states, actions, rewards, dones = rollout(env_fn, policy, rollout_episodes, rollout_steps) + + print('mean', states[~dones].mean(0)) + print('std', states[~dones].std(0)) + + print(f'Iteration {epoch} mean episode length {(~dones).sum() / states.shape[0]}') + print(f'Iteration {epoch} mean reward per episode {rewards[~dones].sum() / states.shape[0]}') + + policy.train() + value.train() + value, policy = trpo_step(value, policy, states, actions, rewards, dones, gamma, gae_lambda, delta, backtrack_coeff, backtrack_iters, v_opt, v_iters, cg_iters, cg_damping) + + return value, policy + +def trpo_step(value, policy, states, actions, rewards, dones, gamma, gae_lambda, delta, backtrack_coeff, backtrack_iters, v_opt, v_iters, cg_iters=10, cg_damping=0.1): + + states = states.detach() + actions = actions.detach() + rewards = rewards.detach() + dones = dones.detach() + + advantages, returns, valid = gae(states, rewards, value(states), dones, gamma, gae_lambda) + advantages = advantages.detach() + returns = returns.detach() + + # update value function + + for _ in range(v_iters): + v_opt.zero_grad() + value_loss = (value(states) - returns).pow(2)[valid].mean() + value_loss.backward() + v_opt.step() + + # compute policy gradient + + plogprob = policy.log_prob(policy(states), actions) + surrogate_advantage = (plogprob * advantages)[valid].sum() / states.shape[0] + g = torch.cat(torch.autograd.grad(surrogate_advantage, policy.flat_param)).detach() + + def Hx(x): + kl = policy.kl_divergence(policy(states), policy(states).detach())[valid].mean() + dKL = torch.cat(torch.autograd.grad(kl, policy.flat_param, create_graph=True)) + H_x = torch.cat(torch.autograd.grad(dKL.T @ x, policy.flat_param)).detach() + return H_x + cg_damping * x + + x = conjugate_gradient(Hx, g, cg_iters) + npg = torch.sqrt(2 * delta / (x.T @ Hx(x))) * x + + # perform line search + + def L(theta): + rplogprob = policy.log_prob(policy(states, flat_param=theta), actions) + return ((rplogprob - plogprob.detach()).exp() * advantages)[valid].sum() / advantages.shape[0] + + condition = lambda theta: policy.kl_divergence(policy(states, flat_param=theta), policy(states))[valid].mean() < delta + + x0 = policy.flat_param + g0 = torch.cat(torch.autograd.grad(L(x0), x0)) + theta = line_search(L, x0, npg, g0, backtrack_coeff, condition, max_steps=backtrack_iters) + + # update policy parameters + + with torch.no_grad(): + policy.flat_param.copy_(theta) + + return value, policy diff --git a/scratch/etienne/trpo/core/value.py b/scratch/etienne/trpo/core/value.py new file mode 100644 index 0000000..2be3b78 --- /dev/null +++ b/scratch/etienne/trpo/core/value.py @@ -0,0 +1,48 @@ +import torch +import torch.nn as nn +from torch.distributions import Normal +from torch.distributions.kl import kl_divergence + +class Value(nn.Module): + + def __init__(self): + super().__init__() + self.nn = nn.Sequential( + nn.LazyLinear(50), + nn.Tanh(), + nn.LazyLinear(50), + nn.Tanh(), + nn.LazyLinear(1), + ) + + def forward(self, states): + return self.nn(states).squeeze(-1) + +class SetValue(Value): + + def forward(self, states): + batch_size = states.shape[:-2] + states = torch.cat((states[..., :1, [0, 1]], states[..., :, [2, 5]]), axis=-2).reshape(*batch_size, -1) + return super().forward(states) + +class DeepSetValue(nn.Module): + + def __init__(self): + super().__init__() + self.elem = nn.Sequential( + nn.LazyLinear(10), + nn.Tanh(), + nn.LazyLinear(10), + nn.Tanh(), + nn.LazyLinear(10), + ) + self.glob = nn.Sequential( + nn.LazyLinear(10), + nn.Tanh(), + nn.LazyLinear(10), + nn.Tanh(), + nn.LazyLinear(1), + ) + + def forward(self, states): + return self.glob(self.elem(states).sum(-2)).squeeze(-1) diff --git a/scratch/etienne/trpo/core/value_estimation.py b/scratch/etienne/trpo/core/value_estimation.py new file mode 100644 index 0000000..b558ac2 --- /dev/null +++ b/scratch/etienne/trpo/core/value_estimation.py @@ -0,0 +1,40 @@ +from operator import index +import torch + +def gae(states, rewards, values, dones, gamma, gae_lambda): + assert rewards.shape == values.shape == dones.shape + n_episodes, n_steps = rewards.shape + + valid = ~dones + valid[..., -1] = False + + td = rewards + gamma * torch.roll(values, shifts=-1, dims=1) - values + adv = td.repeat(n_steps, 1, 1).transpose(0, 1) + assert adv.shape == (n_episodes, n_steps, n_steps) + + step_start, step = torch.meshgrid(torch.arange(n_steps), torch.arange(n_steps), indexing='ij') + past = step < step_start + + # add up discounted temporal differences + discount = torch.minimum(torch.tensor(gamma).log() * (step - step_start), torch.tensor(0.)).exp() + discount = discount * ~past + discount = discount * valid.unsqueeze(1) + + adv = adv * discount + adv = adv.cumsum(2) # eq. (14) + assert adv.shape == (n_episodes, n_steps, n_steps) + + # add up discounted k-advantages + lambda_discount = torch.minimum(torch.tensor(gae_lambda).log() * (step - step_start), torch.tensor(0.)).exp() + lambda_discount = lambda_discount * ~past + lambda_discount = lambda_discount * valid.unsqueeze(1) + + adv = adv * lambda_discount + adv = adv.sum(2) / (lambda_discount.sum(2) + 1e-10) # eq. (16) + + adv = (adv - adv[valid].mean()) / adv[valid].std() + assert adv.shape == rewards.shape == values.shape + + returns = adv + values + + return adv, returns, valid diff --git a/scratch/etienne/trpo/gail-intersimple-minobs.py b/scratch/etienne/trpo/gail-intersimple-minobs.py new file mode 100644 index 0000000..bfeed96 --- /dev/null +++ b/scratch/etienne/trpo/gail-intersimple-minobs.py @@ -0,0 +1,74 @@ +import gym +from core.gail import gail, Buffer +from core.value import Value +from core.policy import Policy +from core.discriminator import Discriminator +import torch.optim +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools +from wrappers import CollisionPenaltyWrapper, Minobs +import numpy as np +from gym.wrappers import TransformObservation + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [Minobs(TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, +), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10))) for _ in range(30)] +env_fn = lambda i: envs[i] + +policy = Policy(env_fn(0).action_space.shape[0]) + +value = Value() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-4) + +discriminator = Discriminator() +disc_opt = torch.optim.Adam(discriminator.parameters(), lr=1e-3) + +expert_data = torch.load('intersimple-expert-data-minobs.pt') +expert_data = Buffer(*expert_data) + +value, policy = gail( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=100, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=4000, + rollout_episodes=30, + rollout_steps=200, + gamma=0.99, + gae_lambda=0.9, + delta=0.01, + backtrack_coeff=0.8, + backtrack_iters=10, +) + +torch.save(policy.state_dict(), 'gail-intersimple-minobs.pt') diff --git a/scratch/etienne/trpo/gail-intersimple-minobs2.py b/scratch/etienne/trpo/gail-intersimple-minobs2.py new file mode 100644 index 0000000..0e1cf76 --- /dev/null +++ b/scratch/etienne/trpo/gail-intersimple-minobs2.py @@ -0,0 +1,100 @@ +# %% +import gym +from core.gail import gail, Buffer +from core.value import Value +from core.policy import Policy +from core.discriminator import Discriminator +import torch.optim +from intersim.envs import IntersimpleLidarFlatRandom +from intersim.envs.intersimple import speed_reward +import functools +from wrappers import CollisionPenaltyWrapper, Minobs +import numpy as np +from gym.wrappers import TransformObservation +from core.reparam_module import ReparamPolicy +from torch.utils.tensorboard import SummaryWriter + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [Minobs(TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlatRandom( + n_rays=5, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, +), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10))) for _ in range(50)] +env_fn = lambda i: envs[i] + +policy = Policy(env_fn(0).action_space.shape[0]) + +value = Value() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-4, weight_decay=1e-3) + +discriminator = Discriminator() +disc_opt = torch.optim.Adam(discriminator.parameters(), lr=1e-3, weight_decay=1e-5) + +expert_data = torch.load('intersimple-expert-data-minobs2.pt') +expert_data = Buffer(*expert_data) + +# %% +value, policy = gail( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=500, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=800, + rollout_episodes=50, + rollout_steps=200, + gamma=0.99, + gae_lambda=0.9, + delta=0.01, + backtrack_coeff=0.8, + backtrack_iters=10, + logger=SummaryWriter(comment='minobs2'), +) + +torch.save(policy.state_dict(), 'gail-intersimple-minobs2.pt') + +# %% +policy = Policy(env_fn(0).action_space.shape[0]) +policy(torch.zeros(env_fn(0).observation_space.shape)) +policy = ReparamPolicy(policy) +policy.load_state_dict(torch.load('gail-intersimple-minobs2.pt')) + +env = env_fn(0) +env.random_skip = False +obs = env.reset() +env.render(mode='post') +for i in range(300): + #action, _ = policy.predict(torch.tensor(obs)) + action = policy.sample(policy(torch.tensor(obs, dtype=torch.float32))) + obs, reward, done, _ = env.step(action) + env.render(mode='post') + print('step', i, 'reward', reward) + if done: + break +env.close() + +# %% diff --git a/scratch/etienne/trpo/gail-intersimple-normobs.py b/scratch/etienne/trpo/gail-intersimple-normobs.py new file mode 100644 index 0000000..1ed0bd4 --- /dev/null +++ b/scratch/etienne/trpo/gail-intersimple-normobs.py @@ -0,0 +1,74 @@ +import gym +from core.gail import gail, Buffer +from core.value import Value +from core.policy import Policy +from core.discriminator import Discriminator +import torch.optim +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools +from wrappers import CollisionPenaltyWrapper +import numpy as np +from gym.wrappers import TransformObservation + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, +), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10)) for _ in range(30)] +env_fn = lambda i: envs[i] + +policy = Policy(env_fn(0).action_space.shape[0]) + +value = Value() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-4) + +discriminator = Discriminator() +disc_opt = torch.optim.Adam(discriminator.parameters(), lr=1e-4) + +expert_data = torch.load('intersimple-expert-data-normobs.pt') +expert_data = Buffer(*expert_data) + +value, policy = gail( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=10, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=4000, + rollout_episodes=30, + rollout_steps=100, + gamma=0.99, + gae_lambda=0.9, + delta=0.01, + backtrack_coeff=0.8, + backtrack_iters=10, +) + +torch.save(policy.state_dict(), 'gail-intersimple-normobs.pt') diff --git a/scratch/etienne/trpo/gail-intersimple-setobs.py b/scratch/etienne/trpo/gail-intersimple-setobs.py new file mode 100644 index 0000000..add36e1 --- /dev/null +++ b/scratch/etienne/trpo/gail-intersimple-setobs.py @@ -0,0 +1,74 @@ +import gym +from core.gail import gail, Buffer +from core.value import SetValue +from core.policy import SetPolicy +from core.discriminator import DeepsetDiscriminator +import torch.optim +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools +from wrappers import CollisionPenaltyWrapper, Setobs +import numpy as np +from gym.wrappers import TransformObservation + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [Setobs(TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, +), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10))) for _ in range(30)] +env_fn = lambda i: envs[i] + +policy = SetPolicy(env_fn(0).action_space.shape[0]) + +value = SetValue() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-4) + +discriminator = DeepsetDiscriminator() +disc_opt = torch.optim.Adam(discriminator.parameters(), lr=1e-3) + +expert_data = torch.load('intersimple-expert-data-setobs.pt') +expert_data = Buffer(*expert_data) + +value, policy = gail( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=500, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=4000, + rollout_episodes=30, + rollout_steps=200, + gamma=0.99, + gae_lambda=0.9, + delta=0.01, + backtrack_coeff=0.8, + backtrack_iters=10, +) + +torch.save(policy.state_dict(), 'gail-intersimple-setobs.pt') diff --git a/scratch/etienne/trpo/gail-intersimple-setobs2-recurrent.py b/scratch/etienne/trpo/gail-intersimple-setobs2-recurrent.py new file mode 100644 index 0000000..69732e6 --- /dev/null +++ b/scratch/etienne/trpo/gail-intersimple-setobs2-recurrent.py @@ -0,0 +1,97 @@ +# %% +import gym +from core.gail import gail, Buffer +from core.value import SetValue +from core.policy import SetPolicy +from core.discriminator import RecurrentDiscriminator +import torch.optim +from intersim.envs import IntersimpleLidarFlatRandom +from intersim.envs.intersimple import speed_reward +import functools +from wrappers import CollisionPenaltyWrapper, Setobs +import numpy as np +from gym.wrappers import TransformObservation +from core.reparam_module import ReparamPolicy + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [Setobs(TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlatRandom( + n_rays=5, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, +), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10))) for _ in range(50)] +env_fn = lambda i: envs[i] + +policy = SetPolicy(env_fn(0).action_space.shape[0]) + +value = SetValue() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-4, weight_decay=1e-3) + +discriminator = RecurrentDiscriminator() +disc_opt = torch.optim.Adam(discriminator.parameters(), lr=1e-3, weight_decay=1e-5) + +expert_data = torch.load('intersimple-expert-data-setobs2.pt') +expert_data = Buffer(*expert_data) + +# %% +value, policy = gail( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=500, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=800, + rollout_episodes=50, + rollout_steps=200, + gamma=0.99, + gae_lambda=0.9, + delta=0.01, + backtrack_coeff=0.8, + backtrack_iters=10, +) + +torch.save(policy.state_dict(), 'gail-intersimple-setobs-recurrent.pt') + +# %% +policy = SetPolicy(env_fn(0).action_space.shape[0]) +policy(torch.zeros(env_fn(0).observation_space.shape)) +policy = ReparamPolicy(policy) +policy.load_state_dict(torch.load('gail-intersimple-setobs-recurrent.pt')) + +env = env_fn(0) +obs = env.reset() +env.render(mode='post') +for i in range(300): + #action, _ = policy.predict(torch.tensor(obs)) + action = policy.sample(policy(torch.tensor(obs, dtype=torch.float32))) + obs, reward, done, _ = env.step(action) + env.render(mode='post') + print('step', i, 'reward', reward) + if done: + break +env.close() + +# %% diff --git a/scratch/etienne/trpo/gail-intersimple-setobs2.py b/scratch/etienne/trpo/gail-intersimple-setobs2.py new file mode 100644 index 0000000..5a0c51b --- /dev/null +++ b/scratch/etienne/trpo/gail-intersimple-setobs2.py @@ -0,0 +1,101 @@ +# %% +import gym +from core.gail import gail, Buffer +from core.value import SetValue +from core.policy import SetPolicy +from core.discriminator import DeepsetDiscriminator +import torch.optim +from intersim.envs import IntersimpleLidarFlatRandom +from intersim.envs.intersimple import speed_reward +import functools +from wrappers import CollisionPenaltyWrapper, Setobs +import numpy as np +from gym.wrappers import TransformObservation +from core.reparam_module import ReparamPolicy +from torch.utils.tensorboard import SummaryWriter + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [Setobs(TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlatRandom( + n_rays=5, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, + random_skip=True, +), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10))) for _ in range(50)] +env_fn = lambda i: envs[i] + +policy = SetPolicy(env_fn(0).action_space.shape[0]) + +value = SetValue() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-4, weight_decay=1e-3) + +discriminator = DeepsetDiscriminator() +disc_opt = torch.optim.Adam(discriminator.parameters(), lr=1e-3, weight_decay=1e-5) + +expert_data = torch.load('intersimple-expert-data-setobs2.pt') +expert_data = Buffer(*expert_data) + +# %% +value, policy = gail( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=500, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=800, + rollout_episodes=50, + rollout_steps=200, + gamma=0.99, + gae_lambda=0.9, + delta=0.01, + backtrack_coeff=0.8, + backtrack_iters=10, + logger=SummaryWriter(comment='setobs2-batchaug'), +) + +torch.save(policy.state_dict(), 'gail-intersimple-setobs2.pt') + +# %% +policy = SetPolicy(env_fn(0).action_space.shape[0]) +policy(torch.zeros(env_fn(0).observation_space.shape)) +policy = ReparamPolicy(policy) +policy.load_state_dict(torch.load('gail-intersimple-setobs2.pt')) + +env = env_fn(0) +env.random_skip = False +obs = env.reset() +env.render(mode='post') +for i in range(300): + #action, _ = policy.predict(torch.tensor(obs)) + action = policy.sample(policy(torch.tensor(obs, dtype=torch.float32))) + obs, reward, done, _ = env.step(action) + env.render(mode='post') + print('step', i, 'reward', reward) + if done: + break +env.close() + +# %% diff --git a/scratch/etienne/trpo/gail-intersimple.py b/scratch/etienne/trpo/gail-intersimple.py new file mode 100644 index 0000000..4fac87e --- /dev/null +++ b/scratch/etienne/trpo/gail-intersimple.py @@ -0,0 +1,54 @@ +import gym +from core.gail import gail, Buffer +from core.value import Value +from core.policy import Policy +from core.discriminator import Discriminator +import torch.optim +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools +from wrappers import CollisionPenaltyWrapper + +envs = [CollisionPenaltyWrapper(IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, +), collision_distance=6, collision_penalty=100) for _ in range(30)] +env_fn = lambda i: envs[i] + +policy = Policy(env_fn(0).action_space.shape[0]) + +value = Value() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-4) + +discriminator = Discriminator() +disc_opt = torch.optim.Adam(discriminator.parameters(), lr=1e-4) + +expert_data = torch.load('intersimple-expert-data.pt') +expert_data = Buffer(*expert_data) + +value, policy = gail( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=10, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=4000, + rollout_episodes=30, + rollout_steps=100, + gamma=0.99, + gae_lambda=0.9, + delta=0.01, + backtrack_coeff=0.8, + backtrack_iters=10, +) + +torch.save(policy.state_dict(), 'gail-intersimple.pt') diff --git a/scratch/etienne/trpo/gail-options-minobs.py b/scratch/etienne/trpo/gail-options-minobs.py new file mode 100644 index 0000000..ca9ef13 --- /dev/null +++ b/scratch/etienne/trpo/gail-options-minobs.py @@ -0,0 +1,97 @@ +import gym +from options.options import gail +from core.gail import Buffer +from core.value import Value +from core.policy import DiscretePolicy +from core.discriminator import Discriminator +import torch.optim +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools +from wrappers import CollisionPenaltyWrapper, TransformObservation, Minobs +import numpy as np +from options.options import OptionsEnv +from torch.utils.tensorboard import SummaryWriter +from core.reparam_module import ReparamPolicy + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [OptionsEnv(Minobs( + TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, + ), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10)) +), options=[(0, 5), (1, 5), (2, 5), (4, 5), (8, 5)]) for _ in range(60)] + +env_fn = lambda i: envs[i] +policy = DiscretePolicy(env_fn(0).action_space.n) +value = Value() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-4) + +discriminator = Discriminator() +disc_opt = torch.optim.Adam(discriminator.parameters(), lr=1e-3) + +expert_data = torch.load('intersimple-expert-data-minobs.pt') +expert_data = Buffer(*expert_data) + +value, policy = gail( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=100, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=50, + rollout_episodes=60, + rollout_steps=60, + gamma=0.99, + gae_lambda=0.9, + delta=0.01, + backtrack_coeff=0.8, + backtrack_iters=10, + logger=SummaryWriter(comment='-options-minobs'), +) + +torch.save(policy.state_dict(), 'gail-options-minobs.pt') + +# %% +policy = DiscretePolicy(env_fn(0).action_space.n) +policy(torch.zeros(env_fn(0).observation_space.shape)) +policy = ReparamPolicy(policy) +policy.load_state_dict(torch.load('gail-options-minobs.pt')) + +env = env_fn(0) +obs = env.reset() +env.render(mode='post') +for i in range(300): + #action, _ = policy.predict(torch.tensor(obs)) + action = policy.sample(policy(torch.tensor(obs, dtype=torch.float32))) + obs, reward, done, _ = env.step(action, render_mode='post') + print('step', i, 'reward', reward) + if done: + break +env.close() diff --git a/scratch/etienne/trpo/gail-options-setobs.py b/scratch/etienne/trpo/gail-options-setobs.py new file mode 100644 index 0000000..c9ca49c --- /dev/null +++ b/scratch/etienne/trpo/gail-options-setobs.py @@ -0,0 +1,97 @@ +import gym +from options.options import gail +from core.gail import Buffer +from core.value import SetValue +from core.policy import SetDiscretePolicy +from core.discriminator import DeepsetDiscriminator +import torch.optim +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools +from wrappers import CollisionPenaltyWrapper, TransformObservation, Setobs +import numpy as np +from options.options import OptionsEnv +from torch.utils.tensorboard import SummaryWriter +from core.reparam_module import ReparamPolicy + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [OptionsEnv(Setobs( + TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, + ), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10)) +), options=[(0, 5), (1, 5), (2, 5), (4, 5), (8, 5)]) for _ in range(60)] + +env_fn = lambda i: envs[i] +policy = SetDiscretePolicy(env_fn(0).action_space.n) +value = SetValue() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-4) + +discriminator = DeepsetDiscriminator() +disc_opt = torch.optim.Adam(discriminator.parameters(), lr=1e-3, weight_decay=1e-3) + +expert_data = torch.load('intersimple-expert-data-setobs.pt') +expert_data = Buffer(*expert_data) + +value, policy = gail( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=100, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=150, + rollout_episodes=60, + rollout_steps=60, + gamma=0.99, + gae_lambda=0.9, + delta=0.01, + backtrack_coeff=0.8, + backtrack_iters=10, + logger=SummaryWriter(comment='gail-options-setobs'), +) + +torch.save(policy.state_dict(), 'gail-options-setobs.pt') + +# %% +policy = SetDiscretePolicy(env_fn(0).action_space.n) +policy(torch.zeros(env_fn(0).observation_space.shape)) +policy = ReparamPolicy(policy) +policy.load_state_dict(torch.load('gail-options-setobs.pt')) + +env = env_fn(0) +obs = env.reset() +env.render(mode='post') +for i in range(300): + #action, _ = policy.predict(torch.tensor(obs)) + action = policy.sample(policy(torch.tensor(obs, dtype=torch.float32))) + obs, reward, done, _ = env.step(action, render_mode='post') + print('step', i, 'reward', reward) + if done: + break +env.close() diff --git a/scratch/etienne/trpo/gail-options-setobs2.py b/scratch/etienne/trpo/gail-options-setobs2.py new file mode 100644 index 0000000..267b179 --- /dev/null +++ b/scratch/etienne/trpo/gail-options-setobs2.py @@ -0,0 +1,98 @@ +# %% +import gym +from options.options import gail +from core.gail import Buffer +from core.value import SetValue +from core.policy import SetDiscretePolicy +from core.discriminator import DeepsetDiscriminator +import torch.optim +from intersim.envs import IntersimpleLidarFlatRandom +from intersim.envs.intersimple import speed_reward +import functools +from wrappers import CollisionPenaltyWrapper, TransformObservation, Setobs +import numpy as np +from options.options import OptionsEnv +from torch.utils.tensorboard import SummaryWriter +from core.reparam_module import ReparamPolicy + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [OptionsEnv(Setobs( + TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlatRandom( + n_rays=5, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, + ), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10)) +), options=[(0, 5), (1, 5), (2, 5), (4, 5), (6, 5), (8, 5)]) for _ in range(60)] + +env_fn = lambda i: envs[i] +policy = SetDiscretePolicy(env_fn(0).action_space.n) +value = SetValue() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-4) + +discriminator = DeepsetDiscriminator() +disc_opt = torch.optim.Adam(discriminator.parameters(), lr=1e-3, weight_decay=1e-4) + +expert_data = torch.load('intersimple-expert-data-setobs2.pt') +expert_data = Buffer(*expert_data) + +# %% +value, policy = gail( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=100, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=200, + rollout_episodes=60, + rollout_steps=60, + gamma=0.99, + gae_lambda=0.9, + delta=0.01, + backtrack_coeff=0.8, + backtrack_iters=10, + logger=SummaryWriter(comment='gail-options-setobs2'), +) + +torch.save(policy.state_dict(), 'gail-options-setobs2.pt') + +# %% +policy = SetDiscretePolicy(env_fn(0).action_space.n) +policy(torch.zeros(env_fn(0).observation_space.shape)) +policy = ReparamPolicy(policy) +policy.load_state_dict(torch.load('gail-options-setobs2.pt')) + +env = env_fn(0) +obs = env.reset() +env.render(mode='post') +for i in range(300): + #action, _ = policy.predict(torch.tensor(obs)) + action = policy.sample(policy(torch.tensor(obs, dtype=torch.float32))) + obs, reward, done, _ = env.step(action, render_mode='post') + print('step', i, 'reward', reward) + if done: + break +env.close() diff --git a/scratch/etienne/trpo/gail-pendulum.py b/scratch/etienne/trpo/gail-pendulum.py new file mode 100644 index 0000000..9e3a6ee --- /dev/null +++ b/scratch/etienne/trpo/gail-pendulum.py @@ -0,0 +1,39 @@ +import gym +from core.gail import gail, Buffer +from core.value import Value +from core.policy import Policy +from core.discriminator import Discriminator +import torch.optim + +env_fn = lambda _: gym.make('Pendulum-v0') +policy = Policy(env_fn(0).action_space.shape[0]) +value = Value() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-3) +discriminator = Discriminator() +disc_opt = torch.optim.Adam(discriminator.parameters(), lr=1e-3) + +expert_data = torch.load('trpo-pendulum-expert-data.pt') +expert_data = Buffer(*expert_data) + +gail( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=10, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=100, + rollout_episodes=20, + rollout_steps=250, + gamma=0.99, + gae_lambda=0.9, + delta=0.01, + backtrack_coeff=0.8, + backtrack_iters=10, +) + + +torch.save(policy.state_dict(), 'gail-pendulum.pt') diff --git a/scratch/etienne/trpo/gail-ppo-intersimple-minobs.py b/scratch/etienne/trpo/gail-ppo-intersimple-minobs.py new file mode 100644 index 0000000..46bcb18 --- /dev/null +++ b/scratch/etienne/trpo/gail-ppo-intersimple-minobs.py @@ -0,0 +1,75 @@ +import gym +from core.gail import gail_ppo, Buffer +from core.value import Value +from core.policy import Policy +from core.discriminator import Discriminator +import torch.optim +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools +from wrappers import CollisionPenaltyWrapper, Minobs +import numpy as np +from gym.wrappers import TransformObservation + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [Minobs(TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, +), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10))) for _ in range(30)] +env_fn = lambda i: envs[i] + +policy = Policy(env_fn(0).action_space.shape[0]) +pi_opt = torch.optim.Adam(policy.parameters(), lr=3e-4) + +value = Value() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-3, weight_decay=1e-3) + +discriminator = Discriminator() +disc_opt = torch.optim.Adam(discriminator.parameters(), lr=1e-3) + +expert_data = torch.load('intersimple-expert-data-minobs.pt') +expert_data = Buffer(*expert_data) + +value, policy = gail_ppo( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=100, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=4000, + rollout_episodes=30, + rollout_steps=100, + gamma=0.99, + gae_lambda=0.9, + clip_ratio=0.2, + pi_opt=pi_opt, + pi_iters=100, +) + +torch.save(policy.state_dict(), 'gail-ppo-intersimple-minobs.pt') diff --git a/scratch/etienne/trpo/gail-ppo-intersimple-normobs.py b/scratch/etienne/trpo/gail-ppo-intersimple-normobs.py new file mode 100644 index 0000000..028328a --- /dev/null +++ b/scratch/etienne/trpo/gail-ppo-intersimple-normobs.py @@ -0,0 +1,75 @@ +import gym +from core.gail import gail_ppo, Buffer +from core.value import Value +from core.policy import Policy +from core.discriminator import Discriminator +import torch.optim +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools +from wrappers import CollisionPenaltyWrapper +import numpy as np +from gym.wrappers import TransformObservation + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, +), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10)) for _ in range(30)] +env_fn = lambda i: envs[i] + +policy = Policy(env_fn(0).action_space.shape[0]) +pi_opt = torch.optim.Adam(policy.parameters(), lr=3e-4) + +value = Value() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-3) + +discriminator = Discriminator() +disc_opt = torch.optim.Adam(discriminator.parameters(), lr=1e-3) + +expert_data = torch.load('intersimple-expert-data-normobs.pt') +expert_data = Buffer(*expert_data) + +value, policy = gail_ppo( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=100, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=4000, + rollout_episodes=30, + rollout_steps=100, + gamma=0.99, + gae_lambda=0.9, + clip_ratio=0.2, + pi_opt=pi_opt, + pi_iters=100, +) + +torch.save(policy.state_dict(), 'gail-ppo-intersimple-normobs.pt') diff --git a/scratch/etienne/trpo/gail-ppo-intersimple-setobs2.py b/scratch/etienne/trpo/gail-ppo-intersimple-setobs2.py new file mode 100644 index 0000000..4715256 --- /dev/null +++ b/scratch/etienne/trpo/gail-ppo-intersimple-setobs2.py @@ -0,0 +1,102 @@ +# %% +import gym +from core.gail import gail_ppo, Buffer +from core.value import SetValue +from core.policy import SetPolicy +from core.discriminator import DeepsetDiscriminator +import torch.optim +from intersim.envs import IntersimpleLidarFlatRandom +from intersim.envs.intersimple import speed_reward +import functools +from wrappers import CollisionPenaltyWrapper, Setobs +import numpy as np +from gym.wrappers import TransformObservation +from core.reparam_module import ReparamPolicy +from torch.utils.tensorboard import SummaryWriter + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [Setobs(TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlatRandom( + n_rays=5, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, + random_skip=True, +), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10))) for _ in range(50)] +env_fn = lambda i: envs[i] + +policy = SetPolicy(env_fn(0).action_space.shape[0]) +pi_opt = torch.optim.Adam(policy.parameters(), lr=3e-4) + +value = SetValue() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-4, weight_decay=1e-3) + +discriminator = DeepsetDiscriminator() +disc_opt = torch.optim.Adam(discriminator.parameters(), lr=1e-3, weight_decay=1e-5) + +expert_data = torch.load('intersimple-expert-data-setobs2.pt') +expert_data = Buffer(*expert_data) + +# %% +value, policy = gail_ppo( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=500, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=800, + rollout_episodes=50, + rollout_steps=200, + gamma=0.99, + gae_lambda=0.9, + clip_ratio=0.2, + pi_opt=pi_opt, + pi_iters=100, + logger=SummaryWriter(comment='-ppo-setobs2'), +) + +torch.save(policy.state_dict(), 'gail-ppo-intersimple-setobs2.pt') + +# %% +policy = SetPolicy(env_fn(0).action_space.shape[0]) +policy(torch.zeros(env_fn(0).observation_space.shape)) +policy = ReparamPolicy(policy) +policy.load_state_dict(torch.load('gail-ppo-intersimple-setobs2.pt')) + +env = env_fn(0) +env.random_skip = False +obs = env.reset() +env.render(mode='post') +for i in range(300): + #action, _ = policy.predict(torch.tensor(obs)) + action = policy.sample(policy(torch.tensor(obs, dtype=torch.float32))) + obs, reward, done, _ = env.step(action) + env.render(mode='post') + print('step', i, 'reward', reward) + if done: + break +env.close() + +# %% diff --git a/scratch/etienne/trpo/gail-ppo-intersimple.py b/scratch/etienne/trpo/gail-ppo-intersimple.py new file mode 100644 index 0000000..833c028 --- /dev/null +++ b/scratch/etienne/trpo/gail-ppo-intersimple.py @@ -0,0 +1,55 @@ +import gym +from core.gail import gail_ppo, Buffer +from core.value import Value +from core.policy import Policy +from core.discriminator import Discriminator +import torch.optim +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools +from wrappers import CollisionPenaltyWrapper + +envs = [CollisionPenaltyWrapper(IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, +), collision_distance=6, collision_penalty=100) for _ in range(30)] +env_fn = lambda i: envs[i] + +policy = Policy(env_fn(0).action_space.shape[0]) +pi_opt = torch.optim.Adam(policy.parameters(), lr=3e-4) + +value = Value() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-3) + +discriminator = Discriminator() +disc_opt = torch.optim.Adam(discriminator.parameters(), lr=3e-4) + +expert_data = torch.load('intersimple-expert-data.pt') +expert_data = Buffer(*expert_data) + +value, policy = gail_ppo( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=10, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=4000, + rollout_episodes=30, + rollout_steps=100, + gamma=0.99, + gae_lambda=0.9, + clip_ratio=0.2, + pi_opt=pi_opt, + pi_iters=100, +) + +torch.save(policy.state_dict(), 'gail-ppo-intersimple.pt') diff --git a/scratch/etienne/trpo/gail-ppo-options-minobs.py b/scratch/etienne/trpo/gail-ppo-options-minobs.py new file mode 100644 index 0000000..b264135 --- /dev/null +++ b/scratch/etienne/trpo/gail-ppo-options-minobs.py @@ -0,0 +1,96 @@ +import gym +from options.options import gail_ppo, Buffer +from core.value import Value +from core.policy import DiscretePolicy +from core.discriminator import Discriminator +import torch.optim +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools +from wrappers import CollisionPenaltyWrapper, TransformObservation, Minobs +import numpy as np +from options.options import OptionsEnv +from torch.utils.tensorboard import SummaryWriter + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [OptionsEnv(Minobs( + TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, + ), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10)) +), options=[(0, 5), (1, 5), (2, 5), (4, 5), (8, 5)]) for _ in range(60)] + +env_fn = lambda i: envs[i] + +policy = DiscretePolicy(env_fn(0).action_space.n) +pi_opt = torch.optim.Adam(policy.parameters(), lr=3e-4) + +value = Value() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-3) + +discriminator = Discriminator() +disc_opt = torch.optim.Adam(discriminator.parameters(), lr=1e-3) + +expert_data = torch.load('intersimple-expert-data-minobs.pt') +expert_data = Buffer(*expert_data) + +value, policy = gail_ppo( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=100, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=50, + rollout_episodes=60, + rollout_steps=60, + gamma=0.99, + gae_lambda=0.9, + clip_ratio=0.2, + pi_opt=pi_opt, + pi_iters=100, + logger=SummaryWriter(comment='gail-ppo-options-minobs'), +) + +torch.save(policy.state_dict(), 'gail-ppo-options-minobs.pt') + +# %% +policy = DiscretePolicy(env_fn(0).action_space.n) +policy(torch.zeros(env_fn(0).observation_space.shape)) +policy.load_state_dict(torch.load('gail-ppo-options-minobs.pt')) + +env = env_fn(0) +obs = env.reset() +env.render(mode='post') +for i in range(300): + action = policy.sample(policy(torch.tensor(obs, dtype=torch.float32))) + obs, reward, done, _ = env.step(action, render_mode='post') + print('step', i, 'reward', reward) + if done: + break +env.close() \ No newline at end of file diff --git a/scratch/etienne/trpo/gail-ppo-options-setobs.py b/scratch/etienne/trpo/gail-ppo-options-setobs.py new file mode 100644 index 0000000..4f2d463 --- /dev/null +++ b/scratch/etienne/trpo/gail-ppo-options-setobs.py @@ -0,0 +1,96 @@ +import gym +from options.options import gail_ppo, Buffer +from core.value import SetValue +from core.policy import SetDiscretePolicy +from core.discriminator import DeepsetDiscriminator +import torch.optim +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools +from wrappers import CollisionPenaltyWrapper, TransformObservation, Setobs +import numpy as np +from options.options import OptionsEnv +from torch.utils.tensorboard import SummaryWriter + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [OptionsEnv(Setobs( + TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, + ), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10)) +), options=[(0, 5), (1, 5), (2, 5), (4, 5), (8, 5)]) for _ in range(60)] + +env_fn = lambda i: envs[i] + +policy = SetDiscretePolicy(env_fn(0).action_space.n) +pi_opt = torch.optim.Adam(policy.parameters(), lr=3e-4) + +value = SetValue() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-3) + +discriminator = DeepsetDiscriminator() +disc_opt = torch.optim.Adam(discriminator.parameters(), lr=1e-3, weight_decay=1e-3) + +expert_data = torch.load('intersimple-expert-data-setobs.pt') +expert_data = Buffer(*expert_data) + +value, policy = gail_ppo( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=100, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=150, + rollout_episodes=60, + rollout_steps=60, + gamma=0.99, + gae_lambda=0.9, + clip_ratio=0.2, + pi_opt=pi_opt, + pi_iters=100, + logger=SummaryWriter(comment='gail-ppo-options-setobs'), +) + +torch.save(policy.state_dict(), 'gail-ppo-options-setobs.pt') + +# %% +policy = SetDiscretePolicy(env_fn(0).action_space.n) +policy(torch.zeros(env_fn(0).observation_space.shape)) +policy.load_state_dict(torch.load('gail-ppo-options-setobs.pt')) + +env = env_fn(0) +obs = env.reset() +env.render(mode='post') +for i in range(300): + action = policy.sample(policy(torch.tensor(obs, dtype=torch.float32))) + obs, reward, done, _ = env.step(action, render_mode='post') + print('step', i, 'reward', reward) + if done: + break +env.close() \ No newline at end of file diff --git a/scratch/etienne/trpo/gail-ppo-options-setobs2.py b/scratch/etienne/trpo/gail-ppo-options-setobs2.py new file mode 100644 index 0000000..7d19fc1 --- /dev/null +++ b/scratch/etienne/trpo/gail-ppo-options-setobs2.py @@ -0,0 +1,97 @@ +# %% +import gym +from options.options import gail_ppo, Buffer +from core.value import SetValue +from core.policy import SetDiscretePolicy +from core.discriminator import DeepsetDiscriminator +import torch.optim +from intersim.envs import IntersimpleLidarFlatRandom +from intersim.envs.intersimple import speed_reward +import functools +from wrappers import CollisionPenaltyWrapper, TransformObservation, Setobs +import numpy as np +from options.options import OptionsEnv +from torch.utils.tensorboard import SummaryWriter + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [OptionsEnv(Setobs( + TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlatRandom( + n_rays=5, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, + ), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10)) +), options=[(0, 5), (1, 5), (2, 5), (4, 5), (6, 5), (8, 5)]) for _ in range(60)] + +env_fn = lambda i: envs[i] + +policy = SetDiscretePolicy(env_fn(0).action_space.n) +pi_opt = torch.optim.Adam(policy.parameters(), lr=3e-4) + +value = SetValue() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-3) + +discriminator = DeepsetDiscriminator() +disc_opt = torch.optim.Adam(discriminator.parameters(), lr=1e-3, weight_decay=1e-4) + +expert_data = torch.load('intersimple-expert-data-setobs2.pt') +expert_data = Buffer(*expert_data) + +# %% +value, policy = gail_ppo( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=100, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=200, + rollout_episodes=60, + rollout_steps=60, + gamma=0.99, + gae_lambda=0.9, + clip_ratio=0.2, + pi_opt=pi_opt, + pi_iters=100, + logger=SummaryWriter(comment='gail-ppo-options-setobs2'), +) + +torch.save(policy.state_dict(), 'gail-ppo-options-setobs2.pt') + +# %% +policy = SetDiscretePolicy(env_fn(0).action_space.n) +policy(torch.zeros(env_fn(0).observation_space.shape)) +policy.load_state_dict(torch.load('gail-ppo-options-setobs2.pt')) + +env = env_fn(0) +obs = env.reset() +env.render(mode='post') +for i in range(300): + action = policy.sample(policy(torch.tensor(obs, dtype=torch.float32))) + obs, reward, done, _ = env.step(action, render_mode='post') + print('step', i, 'reward', reward) + if done: + break +env.close() \ No newline at end of file diff --git a/scratch/etienne/trpo/intersimple-expert-action-profiles.ipynb b/scratch/etienne/trpo/intersimple-expert-action-profiles.ipynb new file mode 100644 index 0000000..00255c8 --- /dev/null +++ b/scratch/etienne/trpo/intersimple-expert-action-profiles.ipynb @@ -0,0 +1,175 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "states torch.Size([2048, 200, 5, 6]) torch.float32\n", + "actions torch.Size([2048, 200, 1]) torch.float32\n", + "rewards torch.Size([2048, 200]) torch.float32\n", + "dones torch.Size([2048, 200]) torch.bool\n" + ] + } + ], + "source": [ + "states, actions, rewards, dones = torch.load('intersimple-expert-data-setobs2.pt')\n", + "#states, actions, rewards, dones = torch.load('intersimple-expert-data-minobs.pt')\n", + "print('states', states.shape, states.dtype)\n", + "print('actions', actions.shape, actions.dtype)\n", + "print('rewards', rewards.shape, rewards.dtype)\n", + "print('dones', dones.shape, dones.dtype)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "i = 52\n", + "plt.plot(actions[i, ~dones[i, :], 0])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "for a, d in zip(actions.squeeze(), dones):\n", + " plt.plot(a[~d])\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(states[:, :, 0, 0].T)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(states[~dones][:, 0, 0].numpy(), density=True, bins=100)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "interpreter": { + "hash": "6c7a4ac80dd345f83235e10baa3acc437d966916e1cc075a45b91bb9cc030938" + }, + "kernelspec": { + "display_name": "Python 3.9.7 64-bit ('.venv': venv)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/scratch/etienne/trpo/intersimple-expert-rollout-minobs.py b/scratch/etienne/trpo/intersimple-expert-rollout-minobs.py new file mode 100644 index 0000000..0a00f67 --- /dev/null +++ b/scratch/etienne/trpo/intersimple-expert-rollout-minobs.py @@ -0,0 +1,54 @@ +import torch +import functools +from core.sampling import rollout_sb3 +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +from intersim.expert import NormalizedIntersimpleExpert +from wrappers import CollisionPenaltyWrapper, Minobs +import numpy as np +from gym.wrappers import TransformObservation + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +env = IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), +) + +policy = NormalizedIntersimpleExpert(env, mu=0.001) + +env = Minobs(TransformObservation( + CollisionPenaltyWrapper( + env, + collision_distance=6, collision_penalty=100 + ), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10) +)) +expert_data = rollout_sb3(env, policy, n_episodes=64, max_steps_per_episode=200) + +states, actions, rewards, dones = expert_data +print(f'Expert mean episode length {(~dones).sum() / states.shape[0]}') +print(f'Expert mean reward per episode {rewards[~dones].sum() / states.shape[0]}') +print(f'Observation mean', states[~dones].mean(0)) +print(f'Observation std', states[~dones].std(0)) + +torch.save(expert_data, 'intersimple-expert-data-minobs.pt') diff --git a/scratch/etienne/trpo/intersimple-expert-rollout-minobs2.py b/scratch/etienne/trpo/intersimple-expert-rollout-minobs2.py new file mode 100644 index 0000000..b65ad11 --- /dev/null +++ b/scratch/etienne/trpo/intersimple-expert-rollout-minobs2.py @@ -0,0 +1,53 @@ +import torch +import functools +from core.sampling import rollout_sb3 +from intersim.envs import IntersimpleLidarFlatRandom +from intersim.envs.intersimple import speed_reward +from intersim.expert import NormalizedIntersimpleExpert +from wrappers import CollisionPenaltyWrapper, Minobs +import numpy as np +from gym.wrappers import TransformObservation + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +env = IntersimpleLidarFlatRandom( + n_rays=5, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), +) + +policy = NormalizedIntersimpleExpert(env, mu=0.001) + +env = Minobs(TransformObservation( + CollisionPenaltyWrapper( + env, + collision_distance=6, collision_penalty=100 + ), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10) +)) +expert_data = rollout_sb3(env, policy, n_episodes=2048, max_steps_per_episode=200) + +states, actions, rewards, dones = expert_data +print(f'Expert mean episode length {(~dones).sum() / states.shape[0]}') +print(f'Expert mean reward per episode {rewards[~dones].sum() / states.shape[0]}') +print(f'Observation mean', states[~dones].mean(0)) +print(f'Observation std', states[~dones].std(0)) + +torch.save(expert_data, 'intersimple-expert-data-minobs2.pt') diff --git a/scratch/etienne/trpo/intersimple-expert-rollout-normobs.py b/scratch/etienne/trpo/intersimple-expert-rollout-normobs.py new file mode 100644 index 0000000..e9340ae --- /dev/null +++ b/scratch/etienne/trpo/intersimple-expert-rollout-normobs.py @@ -0,0 +1,54 @@ +import torch +import functools +from core.sampling import rollout_sb3 +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +from intersim.expert import NormalizedIntersimpleExpert +from wrappers import CollisionPenaltyWrapper +import numpy as np +from gym.wrappers import TransformObservation + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +env = IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), +) + +policy = NormalizedIntersimpleExpert(env, mu=0.001) + +env = TransformObservation( + CollisionPenaltyWrapper( + env, + collision_distance=6, collision_penalty=100 + ), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10) +) +expert_data = rollout_sb3(env, policy, n_episodes=64, max_steps_per_episode=200) + +states, actions, rewards, dones = expert_data +print(f'Expert mean episode length {(~dones).sum() / states.shape[0]}') +print(f'Expert mean reward per episode {rewards[~dones].sum() / states.shape[0]}') +print(f'Observation mean', states[~dones].mean(0)) +print(f'Observation std', states[~dones].std(0)) + +torch.save(expert_data, 'intersimple-expert-data-normobs.pt') diff --git a/scratch/etienne/trpo/intersimple-expert-rollout-setobs.py b/scratch/etienne/trpo/intersimple-expert-rollout-setobs.py new file mode 100644 index 0000000..0ab531b --- /dev/null +++ b/scratch/etienne/trpo/intersimple-expert-rollout-setobs.py @@ -0,0 +1,54 @@ +import torch +import functools +from core.sampling import rollout_sb3 +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +from intersim.expert import NormalizedIntersimpleExpert +from wrappers import CollisionPenaltyWrapper, Setobs +import numpy as np +from gym.wrappers import TransformObservation + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +env = IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), +) + +policy = NormalizedIntersimpleExpert(env, mu=0.001) + +env = Setobs(TransformObservation( + CollisionPenaltyWrapper( + env, + collision_distance=6, collision_penalty=100 + ), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10) +)) +expert_data = rollout_sb3(env, policy, n_episodes=64, max_steps_per_episode=200) + +states, actions, rewards, dones = expert_data +print(f'Expert mean episode length {(~dones).sum() / states.shape[0]}') +print(f'Expert mean reward per episode {rewards[~dones].sum() / states.shape[0]}') +print(f'Observation mean', states[~dones].mean(0)) +print(f'Observation std', states[~dones].std(0)) + +torch.save(expert_data, 'intersimple-expert-data-setobs.pt') diff --git a/scratch/etienne/trpo/intersimple-expert-rollout-setobs2.py b/scratch/etienne/trpo/intersimple-expert-rollout-setobs2.py new file mode 100644 index 0000000..16ecd67 --- /dev/null +++ b/scratch/etienne/trpo/intersimple-expert-rollout-setobs2.py @@ -0,0 +1,53 @@ +import torch +import functools +from core.sampling import rollout_sb3 +from intersim.envs import IntersimpleLidarFlatRandom +from intersim.envs.intersimple import speed_reward +from intersim.expert import NormalizedIntersimpleExpert +from wrappers import CollisionPenaltyWrapper, Setobs +import numpy as np +from gym.wrappers import TransformObservation + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +env = IntersimpleLidarFlatRandom( + n_rays=5, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), +) + +policy = NormalizedIntersimpleExpert(env, mu=0.001) + +env = Setobs(TransformObservation( + CollisionPenaltyWrapper( + env, + collision_distance=6, collision_penalty=100 + ), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10) +)) +expert_data = rollout_sb3(env, policy, n_episodes=2048, max_steps_per_episode=200) + +states, actions, rewards, dones = expert_data +print(f'Expert mean episode length {(~dones).sum() / states.shape[0]}') +print(f'Expert mean reward per episode {rewards[~dones].sum() / states.shape[0]}') +print(f'Observation mean', states[~dones].mean(0)) +print(f'Observation std', states[~dones].std(0)) + +torch.save(expert_data, 'intersimple-expert-data-setobs2.pt') diff --git a/scratch/etienne/trpo/intersimple-expert-rollout.py b/scratch/etienne/trpo/intersimple-expert-rollout.py new file mode 100644 index 0000000..ac0501c --- /dev/null +++ b/scratch/etienne/trpo/intersimple-expert-rollout.py @@ -0,0 +1,25 @@ +import torch +import functools +from core.sampling import rollout_sb3 +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +from intersim.expert import NormalizedIntersimpleExpert +from wrappers import CollisionPenaltyWrapper + +env = CollisionPenaltyWrapper(IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), +), collision_distance=6, collision_penalty=100) +policy = NormalizedIntersimpleExpert(env.env, mu=0.001) + +expert_data = rollout_sb3(env, policy, n_episodes=64, max_steps_per_episode=200) + +states, actions, rewards, dones = expert_data +print(f'Expert mean episode length {(~dones).sum() / states.shape[0]}') +print(f'Expert mean reward per episode {rewards[~dones].sum() / states.shape[0]}') + +torch.save(expert_data, 'intersimple-expert-data.pt') diff --git a/scratch/etienne/trpo/options/options.py b/scratch/etienne/trpo/options/options.py new file mode 100644 index 0000000..af0414a --- /dev/null +++ b/scratch/etienne/trpo/options/options.py @@ -0,0 +1,201 @@ +import gym +import numpy as np +import torch +from stable_baselines3.common.vec_env import DummyVecEnv as VecEnv + +from core.reparam_module import ReparamPolicy +from tqdm import tqdm +from core.gail import Buffer, train_discriminator, roll_buffer, TerminalLogger +from dataclasses import dataclass +from core.trpo import trpo_step +from core.ppo import ppo_step +import torch.nn.functional as F + +@dataclass +class OptionsRollout: + hl: Buffer + ll: Buffer + +def gail(env_fn, expert_data, discriminator, disc_opt, disc_iters, policy, value, + v_opt, v_iters, epochs, rollout_episodes, rollout_steps, gamma, + gae_lambda, delta, backtrack_coeff, backtrack_iters, cg_iters=10, cg_damping=0.1, wasserstein=False, wasserstein_c=None, logger=TerminalLogger()): + + policy(torch.zeros(env_fn(0).observation_space.shape)) + policy = ReparamPolicy(policy) + + logger.add_scalar('expert/mean_episode_length', (~expert_data.dones).sum() / expert_data.states.shape[0]) + logger.add_scalar('expert/mean_reward_per_episode', expert_data.rewards[~expert_data.dones].sum() / expert_data.states.shape[0]) + + for epoch in tqdm(range(epochs)): + hl_data, ll_data = rollout(env_fn, policy, rollout_episodes, rollout_steps) + generator_data = OptionsRollout(Buffer(*hl_data), Buffer(*ll_data)) + + generator_data.ll.actions += 0.1 * torch.randn_like(generator_data.ll.actions) + + logger.add_scalar('gen/mean_episode_length', (~generator_data.ll.dones).sum() / generator_data.ll.states.shape[0], epoch) + logger.add_scalar('gen/mean_reward_per_episode', generator_data.hl.rewards[~generator_data.hl.dones].sum() / generator_data.hl.states.shape[0], epoch) + + discriminator, loss = train_discriminator(expert_data, generator_data.ll, discriminator, disc_opt, disc_iters, wasserstein, wasserstein_c) + if wasserstein: + generator_data.ll.rewards = discriminator(generator_data.ll.states, generator_data.ll.actions) + else: + generator_data.ll.rewards = -F.logsigmoid(discriminator(generator_data.ll.states, generator_data.ll.actions)) + logger.add_scalar('disc/final_loss', loss, epoch) + logger.add_scalar('disc/mean_reward_per_episode', generator_data.ll.rewards[~generator_data.ll.dones].sum() / generator_data.ll.states.shape[0], epoch) + + #assert generator_data.ll.rewards.shape == generator_data.ll.dones.shape + generator_data.hl.rewards = torch.where(~generator_data.ll.dones, generator_data.ll.rewards, torch.tensor(0.)).sum(-1) + + value, policy = trpo_step(value, policy, generator_data.hl.states, generator_data.hl.actions, generator_data.hl.rewards, generator_data.hl.dones, gamma, gae_lambda, delta, backtrack_coeff, backtrack_iters, v_opt, v_iters, cg_iters, cg_damping) + expert_data = roll_buffer(expert_data, shifts=-3, dims=0) + + return value, policy + +def gail_ppo(env_fn, expert_data, discriminator, disc_opt, disc_iters, policy, value, + v_opt, v_iters, epochs, rollout_episodes, rollout_steps, gamma, + gae_lambda, clip_ratio, pi_opt, pi_iters, target_kl=None, max_grad_norm=None, wasserstein=False, wasserstein_c=None, logger=TerminalLogger()): + + logger.add_scalar('expert/mean_episode_length', (~expert_data.dones).sum() / expert_data.states.shape[0]) + logger.add_scalar('expert/mean_reward_per_episode', expert_data.rewards[~expert_data.dones].sum() / expert_data.states.shape[0]) + + for epoch in range(epochs): + hl_data, ll_data = rollout(env_fn, policy, rollout_episodes, rollout_steps) + generator_data = OptionsRollout(Buffer(*hl_data), Buffer(*ll_data)) + + generator_data.ll.actions += 0.1 * torch.randn_like(generator_data.ll.actions) + + logger.add_scalar('gen/mean_episode_length', (~generator_data.ll.dones).sum() / generator_data.ll.states.shape[0], epoch) + logger.add_scalar('gen/mean_reward_per_episode', generator_data.hl.rewards[~generator_data.hl.dones].sum() / generator_data.hl.states.shape[0], epoch) + + discriminator, loss = train_discriminator(expert_data, generator_data.ll, discriminator, disc_opt, disc_iters, wasserstein, wasserstein_c) + if wasserstein: + generator_data.ll.rewards = discriminator(generator_data.ll.states, generator_data.ll.actions) + else: + generator_data.ll.rewards = -F.logsigmoid(discriminator(generator_data.ll.states, generator_data.ll.actions)) + logger.add_scalar('disc/final_loss', loss, epoch) + logger.add_scalar('disc/mean_reward_per_episode', generator_data.ll.rewards[~generator_data.ll.dones].sum() / generator_data.ll.states.shape[0], epoch) + + #assert generator_data.ll.rewards.shape == generator_data.ll.dones.shape + generator_data.hl.rewards = torch.where(~generator_data.ll.dones, generator_data.ll.rewards, torch.tensor(0.)).sum(-1) + + value, policy = ppo_step(value, policy, generator_data.hl.states, generator_data.hl.actions, generator_data.hl.rewards, generator_data.hl.dones, clip_ratio, gamma, gae_lambda, pi_opt, pi_iters, v_opt, v_iters, target_kl, max_grad_norm) + expert_data = roll_buffer(expert_data, shifts=-3, dims=0) + + return value, policy + +def rollout(env_fn, policy, n_episodes, max_steps_per_episode): + env = env_fn(0) + + states = torch.zeros(n_episodes, max_steps_per_episode + 1, *env.observation_space.shape) + actions = torch.zeros(n_episodes, max_steps_per_episode + 1, *env.action_space.shape) + rewards = torch.zeros(n_episodes, max_steps_per_episode + 1) + dones = torch.ones(n_episodes, max_steps_per_episode + 1, dtype=bool) + + ll_states = torch.zeros(n_episodes, max_steps_per_episode, env.max_plan_length + 1, *env.observation_space.shape) + ll_actions = torch.zeros(n_episodes, max_steps_per_episode, env.max_plan_length + 1, *env.ll_action_space.shape) + ll_rewards = torch.zeros(n_episodes, max_steps_per_episode, env.max_plan_length + 1) + ll_dones = torch.ones(n_episodes, max_steps_per_episode, env.max_plan_length + 1, dtype=bool) + + env = VecEnv(list(map(lambda i: (lambda: env_fn(i)), range(n_episodes)))) + + states[:, 0] = torch.tensor(env.reset()).clone().detach() + dones[:, 0] = False + + for s in tqdm(range(max_steps_per_episode), 'Rollout'): + actions[:, s] = policy.sample(policy(states[:, s])).clone().detach() + + clipped_actions = actions[:, s] + if isinstance(env.action_space, gym.spaces.Box): + clipped_actions = torch.clamp(clipped_actions, torch.from_numpy(env.action_space.low), torch.from_numpy(env.action_space.high)) + + o, r, d, info = env.step(clipped_actions) + states[:, s + 1] = torch.tensor(o).clone().detach() + rewards[:, s] = torch.tensor(r).clone().detach() + dones[:, s + 1] = torch.tensor(d).clone().detach() + + ll_states[:, s] = torch.from_numpy(np.stack([i['ll']['observations'] for i in info])).clone().detach() + ll_actions[:, s] = torch.from_numpy(np.stack([i['ll']['actions'] for i in info])).clone().detach() + ll_rewards[:, s] = torch.from_numpy(np.stack([i['ll']['rewards'] for i in info])).clone().detach() + ll_dones[:, s] = torch.from_numpy(np.stack([i['ll']['plan_done'] for i in info])).clone().detach() + + dones = dones.cumsum(1) > 0 + + states = states[:, :max_steps_per_episode] + actions = actions[:, :max_steps_per_episode] + rewards = rewards[:, :max_steps_per_episode] + dones = dones[:, :max_steps_per_episode] + + return (states, actions, rewards, dones), (ll_states, ll_actions, ll_rewards, ll_dones) + +class OptionsEnv(gym.Wrapper): + + def __init__(self, env, options): + super().__init__(env) + self.ll_action_space = env.action_space + self.options = options + self.action_space = gym.spaces.Discrete(len(options)) + self.max_plan_length = max(t for _, t in options) + + def plan(self, option): + target_v, t = option + current_v = self.env._env.state[self.env._agent, 1].item() + dt = self.env._env._dt + a = (target_v - current_v) / (t * dt) + a = self.env._normalize(a) + a = a * np.ones((t,)) + a += 0.01 * np.random.randn(*a.shape) + a = np.clip(a, self.ll_action_space.low, self.ll_action_space.high) + return a + + def execute_plan(self, obs, option, render_mode=None): + observations = np.zeros((self.max_plan_length + 1, *self.env.observation_space.shape)) + actions = np.zeros((self.max_plan_length + 1, *self.ll_action_space.shape)) + rewards = np.zeros((self.max_plan_length + 1,)) + env_done = np.ones((self.max_plan_length + 1,), dtype=bool) + plan_done = np.ones((self.max_plan_length + 1,), dtype=bool) + infos = [] + + observations[0] = obs + env_done[0] = False + for k, u in enumerate(self.plan(option)): + plan_done[k] = False + o, r, d, i = super().step(u) + actions[k] = u + rewards[k] = r + env_done[k+1] = d + infos.append(i) + observations[k+1] = o + + if render_mode is not None: + self.env.render(render_mode) + + if d: + break + + n_steps = k + 1 + return observations, actions, rewards, env_done, plan_done, infos, n_steps + + def step(self, action, render_mode=None): + a = int(action) + assert a == action + ll_obs, ll_actions, ll_rewards, ll_env_done, ll_plan_done, ll_infos, ll_steps = self.execute_plan(self.last_obs, self.options[a], render_mode) + hl_obs = ll_obs[ll_steps] + hl_reward = (ll_rewards * ~ll_plan_done).sum().item() + hl_done = ll_env_done[ll_steps].item() + hl_infos = { + 'll': { + 'observations': ll_obs, + 'actions': ll_actions, + 'rewards': ll_rewards, + 'env_done': ll_env_done, + 'plan_done': ll_plan_done, + 'infos': ll_infos, + 'steps': ll_steps, + } + } + self.last_obs = hl_obs + return hl_obs, hl_reward, hl_done, hl_infos + + def reset(self, *args, **kwargs): + self.last_obs = super().reset(*args, **kwargs) + return self.last_obs diff --git a/scratch/etienne/trpo/options/test_options.py b/scratch/etienne/trpo/options/test_options.py new file mode 100644 index 0000000..269eb43 --- /dev/null +++ b/scratch/etienne/trpo/options/test_options.py @@ -0,0 +1,54 @@ +from intersim.envs import IntersimpleLidarFlat +from options import OptionsEnv +import gym +import numpy as np + +def test_obs_shape(): + options = [(0, 5), (5, 5), (10, 5)] + env = OptionsEnv(IntersimpleLidarFlat(n_rays=5), options) + assert env.reset().shape == (36,) + +def test_act_space(): + options = [(0, 5), (5, 5), (10, 5)] + env = OptionsEnv(IntersimpleLidarFlat(n_rays=5), options) + assert env.action_space == gym.spaces.Discrete(3) + +def test_plan(): + options = [(0, 5), (5, 5), (10, 5)] + env = OptionsEnv(IntersimpleLidarFlat(n_rays=5), options) + env.reset() + plan = env.plan(options[0]) + assert np.allclose(plan, -13.998268127441406 * np.ones((5,))) + +def test_plan2(): + options = [(0, 5), (5, 5), (10, 5)] + env = OptionsEnv(IntersimpleLidarFlat(n_rays=5), options) + obs = env.reset() + states, actions, rewards, dones, plan_done, infos, n_steps = env.execute_plan(obs, options[0]) + assert states.shape == (6, 36) + assert rewards.shape == (6,) + assert dones.shape == (6,) + assert len(infos) == 5 + +def test_step(): + options = [(0, 5), (5, 5), (10, 5)] + env = OptionsEnv(IntersimpleLidarFlat(n_rays=5), options) + env.reset() + obs, reward, done, _ = env.step(0) + assert obs.shape == (36,) + assert reward == 5.0 + assert done == False + +def test_ll_step(): + options = [(0, 5), (5, 5), (10, 5)] + env = OptionsEnv(IntersimpleLidarFlat(n_rays=5), options) + env.reset() + _, _, _, info = env.step(0) + assert info['ll']['observations'].shape == (6, 36) + assert info['ll']['actions'].shape == (6, 1) + assert info['ll']['rewards'].shape == (6,) + assert info['ll']['env_done'].shape == (6,) + assert info['ll']['plan_done'].shape == (6,) + assert info['ll']['plan_done'][5] == True + assert info['ll']['steps'] == 5 + assert len(info['ll']['infos']) == 5 diff --git a/scratch/etienne/trpo/ppo-intersimple-minobs.py b/scratch/etienne/trpo/ppo-intersimple-minobs.py new file mode 100644 index 0000000..89f61a6 --- /dev/null +++ b/scratch/etienne/trpo/ppo-intersimple-minobs.py @@ -0,0 +1,63 @@ +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools + +from core.ppo import ppo +from core.value import Value +from core.policy import Policy +import torch.optim +import numpy as np +from gym.wrappers import TransformObservation + +from wrappers import Minobs + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [Minobs(TransformObservation(IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), +), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10))) for _ in range(30)] + +env_fn = lambda i: envs[i] +policy = Policy(env_fn(0).action_space.shape[0]) +value = Value() +pi_opt = torch.optim.Adam(policy.parameters(), lr=3e-4) +v_opt = torch.optim.Adam(value.parameters(), lr=1e-3) + +value, policy = ppo( + env_fn=env_fn, + value=value, + policy=policy, + epochs=50, + rollout_episodes=30, + rollout_steps=200, + gamma=0.99, + gae_lambda=0.9, + clip_ratio=0.2, + pi_opt=pi_opt, + pi_iters=100, + v_opt=v_opt, + v_iters=1000, +) + +torch.save(policy.state_dict(), 'ppo-intersimple.pt') diff --git a/scratch/etienne/trpo/ppo-intersimple-minobs2.py b/scratch/etienne/trpo/ppo-intersimple-minobs2.py new file mode 100644 index 0000000..5bed6b3 --- /dev/null +++ b/scratch/etienne/trpo/ppo-intersimple-minobs2.py @@ -0,0 +1,62 @@ +from intersim.envs import IntersimpleLidarFlatRandom +from intersim.envs.intersimple import speed_reward +import functools + +from core.ppo import ppo +from core.value import Value +from core.policy import Policy +import torch.optim +import numpy as np +from gym.wrappers import TransformObservation + +from wrappers import Minobs + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [Minobs(TransformObservation(IntersimpleLidarFlatRandom( + n_rays=5, + reward=functools.partial( + speed_reward, + collision_penalty=1000 + ), +), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10))) for _ in range(30)] + +env_fn = lambda i: envs[i] +policy = Policy(env_fn(0).action_space.shape[0]) +value = Value() +pi_opt = torch.optim.Adam(policy.parameters(), lr=3e-4) +v_opt = torch.optim.Adam(value.parameters(), lr=1e-3, weight_decay=1e-3) + +value, policy = ppo( + env_fn=env_fn, + value=value, + policy=policy, + epochs=50, + rollout_episodes=30, + rollout_steps=100, + gamma=0.99, + gae_lambda=0.9, + clip_ratio=0.2, + pi_opt=pi_opt, + pi_iters=100, + v_opt=v_opt, + v_iters=1000, +) + +torch.save(policy.state_dict(), 'ppo-intersimple.pt') diff --git a/scratch/etienne/trpo/ppo-intersimple-normobs.py b/scratch/etienne/trpo/ppo-intersimple-normobs.py new file mode 100644 index 0000000..2e623de --- /dev/null +++ b/scratch/etienne/trpo/ppo-intersimple-normobs.py @@ -0,0 +1,61 @@ +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools + +from core.ppo import ppo +from core.value import Value +from core.policy import Policy +import torch.optim +import numpy as np +from gym.wrappers import TransformObservation + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [TransformObservation(IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=10 + ), +), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10)) for _ in range(30)] + +env_fn = lambda i: envs[i] +policy = Policy(env_fn(0).action_space.shape[0]) +value = Value() +pi_opt = torch.optim.Adam(policy.parameters(), lr=3e-4) +v_opt = torch.optim.Adam(value.parameters(), lr=1e-3) + +value, policy = ppo( + env_fn=env_fn, + value=value, + policy=policy, + epochs=50, + rollout_episodes=30, + rollout_steps=100, + gamma=0.99, + gae_lambda=0.9, + clip_ratio=0.2, + pi_opt=pi_opt, + pi_iters=100, + v_opt=v_opt, + v_iters=1000, +) + +torch.save(policy.state_dict(), 'ppo-intersimple.pt') diff --git a/scratch/etienne/trpo/ppo-intersimple.py b/scratch/etienne/trpo/ppo-intersimple.py new file mode 100644 index 0000000..d060c52 --- /dev/null +++ b/scratch/etienne/trpo/ppo-intersimple.py @@ -0,0 +1,41 @@ +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools + +from core.ppo import ppo +from core.value import Value +from core.policy import Policy +import torch.optim + +envs = [IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=10 + ), +) for _ in range(30)] + +env_fn = lambda i: envs[i] +policy = Policy(env_fn(0).action_space.shape[0]) +value = Value() +pi_opt = torch.optim.Adam(policy.parameters(), lr=3e-4) +v_opt = torch.optim.Adam(value.parameters(), lr=1e-3) + +value, policy = ppo( + env_fn=env_fn, + value=value, + policy=policy, + epochs=50, + rollout_episodes=30, + rollout_steps=100, + gamma=0.99, + gae_lambda=0.9, + clip_ratio=0.2, + pi_opt=pi_opt, + pi_iters=100, + v_opt=v_opt, + v_iters=1000, +) + +torch.save(policy.state_dict(), 'ppo-intersimple.pt') diff --git a/scratch/etienne/trpo/ppo-options-minobs.py b/scratch/etienne/trpo/ppo-options-minobs.py new file mode 100644 index 0000000..38aa899 --- /dev/null +++ b/scratch/etienne/trpo/ppo-options-minobs.py @@ -0,0 +1,89 @@ +# %% +import gym +from core.sampling import rollout +from core.ppo import ppo +from core.value import Value +from core.policy import DiscretePolicy +import torch.optim +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools +import numpy as np +from wrappers import CollisionPenaltyWrapper, TransformObservation + +from wrappers import Minobs +from options.options import OptionsEnv + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [OptionsEnv(Minobs( + TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, + ), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10)) +), options=[(0, 5), (5, 5), (10, 5)]) for _ in range(50)] + +env_fn = lambda i: envs[i] +policy = DiscretePolicy(env_fn(0).action_space.n) +value = Value() +pi_opt = torch.optim.Adam(policy.parameters(), lr=3e-4) +v_opt = torch.optim.Adam(value.parameters(), lr=1e-3) + +# %% +value, policy = ppo( + env_fn=env_fn, + value=value, + policy=policy, + epochs=50, + rollout_episodes=30, + rollout_steps=20, + gamma=0.99, + gae_lambda=0.95, + clip_ratio=0.2, + pi_opt=pi_opt, + pi_iters=100, + v_opt=v_opt, + v_iters=1000, +) + +torch.save(policy.state_dict(), 'ppo-options-minobs.pt') + +# %% +policy = DiscretePolicy(env_fn(0).action_space.n) +policy(torch.zeros(env_fn(0).observation_space.shape)) +policy.load_state_dict(torch.load('ppo-options-minobs.pt')) + +env = env_fn(0) +obs = env.reset() +env.render(mode='post') +for i in range(300): + #action, _ = policy.predict(torch.tensor(obs)) + action = policy.sample(policy(torch.tensor(obs, dtype=torch.float32))) + obs, reward, done, _ = env.step(action, render_mode='post') + print('step', i, 'reward', reward) + if done: + break +env.close() + +# %% diff --git a/scratch/etienne/trpo/ppo-pendulum.py b/scratch/etienne/trpo/ppo-pendulum.py new file mode 100644 index 0000000..9af7973 --- /dev/null +++ b/scratch/etienne/trpo/ppo-pendulum.py @@ -0,0 +1,27 @@ +import gym +from core.ppo import ppo +from core.value import Value +from core.policy import Policy +import torch.optim + +env_fn = lambda _: gym.make('Pendulum-v0') +policy = Policy(env_fn(0).action_space.shape[0]) +value = Value() +pi_opt = torch.optim.Adam(policy.parameters(), lr=3e-4) +v_opt = torch.optim.Adam(value.parameters(), lr=1e-3) + +ppo( + env_fn=env_fn, + value=value, + policy=policy, + epochs=300, + rollout_episodes=100, + rollout_steps=200, + gamma=0.99, + gae_lambda=0.9, + clip_ratio=0.2, + pi_opt=pi_opt, + pi_iters=100, + v_opt=v_opt, + v_iters=1000, +) diff --git a/scratch/etienne/trpo/readme.md b/scratch/etienne/trpo/readme.md new file mode 100644 index 0000000..26ecbb0 --- /dev/null +++ b/scratch/etienne/trpo/readme.md @@ -0,0 +1,7 @@ +| | TRPO | PPO | GAIL | GAIL PPO | WGAIL | WGAIL PPO | +|---------------------|------|-------|-------|----------|-------|-----------| +| Pendulum | -120 | -1000 | -120 | -1000 | -120 | -1000 | +| intersimple-minobs | +1@30| | +6@26 | +1@20 | -7000@26, -2000@60 | -6000@30, -5000@60 | +| intersimple-setobs | | | -200@20 | | | | +| intersimple-minobs2 | | | -1500@800 | | | | +| intersimple-setobs2 | | | -500@800 | -750@800 | -1300@800 | -2500@600, unstable | diff --git a/scratch/etienne/trpo/sb3/sb3-ppo-intersimple-nocollision.py b/scratch/etienne/trpo/sb3/sb3-ppo-intersimple-nocollision.py new file mode 100644 index 0000000..77f3424 --- /dev/null +++ b/scratch/etienne/trpo/sb3/sb3-ppo-intersimple-nocollision.py @@ -0,0 +1,55 @@ +from stable_baselines3 import PPO +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools +from gym import Wrapper + +model_name = "ppo_speed_lidar_nocollision" + +env = IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, +) + +class CollisionPenaltyWrapper(Wrapper): + + def __init__(self, env, collision_distance, collision_penalty, *args, **kwargs): + super().__init__(env, *args, **kwargs) + self.penalty = collision_penalty + self.distance = collision_distance + + def step(self, action): + obs, reward, done, info = super().step(action) + reward = -self.penalty if (obs.reshape(-1, 6)[1:, 0] < self.distance).any() else reward + + self.env._rewards.pop() + self.env._rewards.append(reward) + + return obs, reward, done, info + +env = CollisionPenaltyWrapper(env, collision_distance=6, collision_penalty=100) + +model = PPO( + "MlpPolicy", env, + learning_rate=1e-4, + verbose=1, +) +model.learn(total_timesteps=100000) +model.save(model_name) + +model = PPO.load(model_name) +obs = env.reset() +env.render(mode='post') +for i in range(200): + action, _ = model.predict(obs) + obs, reward, done, _ = env.step(action) + env.render(mode='post') + print('step', i, 'front distance', obs.reshape(-1, 6)[3, 0], 'reward', reward) + if done: + break +env.close() diff --git a/scratch/etienne/trpo/sb3/sb3-ppo-intersimple-nocollision2.py b/scratch/etienne/trpo/sb3/sb3-ppo-intersimple-nocollision2.py new file mode 100644 index 0000000..0e576bd --- /dev/null +++ b/scratch/etienne/trpo/sb3/sb3-ppo-intersimple-nocollision2.py @@ -0,0 +1,58 @@ +from stable_baselines3 import PPO +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools +from gym import Wrapper + +model_name = "ppo_speed_lidar_nocollision" + +env = IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, +) + +class CollisionPenaltyWrapper(Wrapper): + + def __init__(self, env, collision_distance, collision_penalty, last_reward_weight, *args, **kwargs): + super().__init__(env, *args, **kwargs) + self.penalty = collision_penalty + self.distance = collision_distance + self.last_reward = -collision_penalty + self.last_reward_weight = last_reward_weight + + def step(self, action): + obs, reward, done, info = super().step(action) + reward = -self.penalty if (obs.reshape(-1, 6)[1:, 0] < self.distance).any() else reward + reward = self.last_reward_weight * self.last_reward + (1 - self.last_reward_weight) * self.last_reward + + self.env._rewards.pop() + self.env._rewards.append(reward) + + return obs, reward, done, info + +env = CollisionPenaltyWrapper(env, collision_distance=6, collision_penalty=10, last_reward_weight=0.9) + +model = PPO( + "MlpPolicy", env, + learning_rate=1e-4, + verbose=1, +) +model.learn(total_timesteps=100000) +model.save(model_name) + +model = PPO.load(model_name) +obs = env.reset() +env.render(mode='post') +for i in range(200): + action, _ = model.predict(obs) + obs, reward, done, _ = env.step(action) + env.render(mode='post') + print('step', i, 'front distance', obs.reshape(-1, 6)[3, 0], 'reward', reward) + if done: + break +env.close() diff --git a/scratch/etienne/trpo/sb3/sb3-ppo-intersimple-rollout.py b/scratch/etienne/trpo/sb3/sb3-ppo-intersimple-rollout.py new file mode 100644 index 0000000..eee73fe --- /dev/null +++ b/scratch/etienne/trpo/sb3/sb3-ppo-intersimple-rollout.py @@ -0,0 +1,28 @@ +import sys +sys.path.append('..') + +from stable_baselines3 import PPO +from core.sampling import rollout_sb3 +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools +import torch +from wrappers import CollisionPenaltyWrapper + +model = PPO.load('sb3-ppo-intersimple') +env = CollisionPenaltyWrapper(IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), +), collision_distance=6, collision_penalty=100) + +expert_data = rollout_sb3(env, model, n_episodes=200, max_steps_per_episode=200) + +states, actions, rewards, dones = expert_data +print(f'Expert mean episode length {(~dones).sum() / states.shape[0]}') +print(f'Expert mean reward per episode {rewards[~dones].sum() / states.shape[0]}') + +torch.save(expert_data, 'sb3-ppo-intersimple-expert-data.pt') diff --git a/scratch/etienne/trpo/sb3/sb3-ppo-intersimple.py b/scratch/etienne/trpo/sb3/sb3-ppo-intersimple.py new file mode 100644 index 0000000..76d91ae --- /dev/null +++ b/scratch/etienne/trpo/sb3/sb3-ppo-intersimple.py @@ -0,0 +1,23 @@ +from stable_baselines3 import PPO +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools + +env = IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), +) + +model = PPO( + "MlpPolicy", env, + learning_rate=1e-4, + verbose=1, + use_sde=False, + sde_sample_freq=4, +) +model.learn(total_timesteps=100000) +model.save('sb3-ppo-intersimple') diff --git a/scratch/etienne/trpo/sb3/sb3-ppo-pendulum.py b/scratch/etienne/trpo/sb3/sb3-ppo-pendulum.py new file mode 100644 index 0000000..c57e359 --- /dev/null +++ b/scratch/etienne/trpo/sb3/sb3-ppo-pendulum.py @@ -0,0 +1,6 @@ +from stable_baselines3 import PPO +from stable_baselines3.common.env_util import make_vec_env + +env = make_vec_env("Pendulum-v0", n_envs=4) +model = PPO("MlpPolicy", env, verbose=1) +model.learn(total_timesteps=250000) diff --git a/scratch/etienne/trpo/sb3/sb3-trpo-intersimple.py b/scratch/etienne/trpo/sb3/sb3-trpo-intersimple.py new file mode 100644 index 0000000..ef1266b --- /dev/null +++ b/scratch/etienne/trpo/sb3/sb3-trpo-intersimple.py @@ -0,0 +1,16 @@ +from sb3_contrib import TRPO +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools + +env = IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), +) + +model = TRPO("MlpPolicy", env, use_sde=False, sde_sample_freq=4, verbose=1) +model.learn(total_timesteps=250000) diff --git a/scratch/etienne/trpo/sb3/sb3-trpo-pendulum.py b/scratch/etienne/trpo/sb3/sb3-trpo-pendulum.py new file mode 100644 index 0000000..9f65f30 --- /dev/null +++ b/scratch/etienne/trpo/sb3/sb3-trpo-pendulum.py @@ -0,0 +1,8 @@ +from sb3_contrib import TRPO +import gym +from gym.wrappers import TransformObservation + +env = TransformObservation(gym.make('Pendulum-v0'), lambda obs: obs) + +model = TRPO("MlpPolicy", env, verbose=1) +model.learn(total_timesteps=250000) diff --git a/scratch/etienne/trpo/trpo-intersimple-minobs.py b/scratch/etienne/trpo/trpo-intersimple-minobs.py new file mode 100644 index 0000000..93081d9 --- /dev/null +++ b/scratch/etienne/trpo/trpo-intersimple-minobs.py @@ -0,0 +1,88 @@ +# %% +import gym +from core.sampling import rollout +from core.trpo import trpo +from core.value import Value +from core.policy import Policy +import torch.optim +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools +import numpy as np +from gym.wrappers import TransformObservation +from wrappers import CollisionPenaltyWrapper +from core.reparam_module import ReparamPolicy + +from wrappers import Minobs + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [Minobs(TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, +), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10))) for _ in range(50)] + +env_fn = lambda i: envs[i] +policy = Policy(env_fn(0).action_space.shape[0]) +value = Value() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-4, weight_decay=1e-3) + +# %% +value, policy = trpo( + env_fn=env_fn, + value=value, + policy=policy, + epochs=50, + rollout_episodes=30, + rollout_steps=100, + gamma=0.99, + gae_lambda=0.95, + delta=0.01, + backtrack_coeff=0.9, + backtrack_iters=50, + v_opt=v_opt, + v_iters=1000, + cg_damping=0.1, +) + +torch.save(policy.state_dict(), 'trpo-intersimple-minobs.pt') + +# %% +policy = Policy(env_fn(0).action_space.shape[0]) +policy(torch.zeros(env_fn(0).observation_space.shape)) +policy = ReparamPolicy(policy) +policy.load_state_dict(torch.load('trpo-intersimple-minobs.pt')) + +env = env_fn(0) +obs = env.reset() +env.render(mode='post') +for i in range(300): + #action, _ = policy.predict(torch.tensor(obs)) + action = policy.sample(policy(torch.tensor(obs, dtype=torch.float32))) + obs, reward, done, _ = env.step(action) + env.render(mode='post') + print('step', i, 'reward', reward) + if done: + break +env.close() diff --git a/scratch/etienne/trpo/trpo-intersimple-minobs2.py b/scratch/etienne/trpo/trpo-intersimple-minobs2.py new file mode 100644 index 0000000..58f6b28 --- /dev/null +++ b/scratch/etienne/trpo/trpo-intersimple-minobs2.py @@ -0,0 +1,87 @@ +# %% +import gym +from core.sampling import rollout +from core.trpo import trpo +from core.value import Value +from core.policy import Policy +import torch.optim +from intersim.envs import IntersimpleLidarFlatRandom +from intersim.envs.intersimple import speed_reward +import functools +import numpy as np +from gym.wrappers import TransformObservation +from wrappers import CollisionPenaltyWrapper +from core.reparam_module import ReparamPolicy + +from wrappers import Minobs + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [Minobs(TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlatRandom( + n_rays=5, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, +), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10))) for _ in range(50)] + +env_fn = lambda i: envs[i] +policy = Policy(env_fn(0).action_space.shape[0]) +value = Value() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-4, weight_decay=1e-3) + +# %% +value, policy = trpo( + env_fn=env_fn, + value=value, + policy=policy, + epochs=200, + rollout_episodes=30, + rollout_steps=100, + gamma=0.99, + gae_lambda=0.95, + delta=0.01, + backtrack_coeff=0.9, + backtrack_iters=50, + v_opt=v_opt, + v_iters=1000, + cg_damping=0.1, +) + +torch.save(policy.state_dict(), 'trpo-intersimple-minobs2.pt') + +# %% +policy = Policy(env_fn(0).action_space.shape[0]) +policy(torch.zeros(env_fn(0).observation_space.shape)) +policy = ReparamPolicy(policy) +policy.load_state_dict(torch.load('trpo-intersimple-minobs2.pt')) + +env = env_fn(0) +obs = env.reset() +env.render(mode='post') +for i in range(300): + #action, _ = policy.predict(torch.tensor(obs)) + action = policy.sample(policy(torch.tensor(obs, dtype=torch.float32))) + obs, reward, done, _ = env.step(action) + env.render(mode='post') + print('step', i, 'reward', reward) + if done: + break +env.close() diff --git a/scratch/etienne/trpo/trpo-intersimple-normobs.py b/scratch/etienne/trpo/trpo-intersimple-normobs.py new file mode 100644 index 0000000..aeb527a --- /dev/null +++ b/scratch/etienne/trpo/trpo-intersimple-normobs.py @@ -0,0 +1,62 @@ +import gym +from core.sampling import rollout +from core.trpo import trpo +from core.value import Value +from core.policy import Policy +import torch.optim +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools +import numpy as np +from gym.wrappers import TransformObservation + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [TransformObservation(IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=10 + ), +), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10)) for _ in range(50)] + +env_fn = lambda i: envs[i] +policy = Policy(env_fn(0).action_space.shape[0]) +value = Value() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-4, weight_decay=1e-3) + +value, policy = trpo( + env_fn=env_fn, + value=value, + policy=policy, + epochs=4000, + rollout_episodes=30, + rollout_steps=100, + gamma=0.99, + gae_lambda=0.95, + delta=0.01, + backtrack_coeff=0.9, + backtrack_iters=50, + v_opt=v_opt, + v_iters=1000, + cg_damping=0.1, +) + +#rollout(env_fn, policy, n_episodes=9, max_steps_per_episode=200, render=True) diff --git a/scratch/etienne/trpo/trpo-intersimple-setobs.py b/scratch/etienne/trpo/trpo-intersimple-setobs.py new file mode 100644 index 0000000..62545ee --- /dev/null +++ b/scratch/etienne/trpo/trpo-intersimple-setobs.py @@ -0,0 +1,90 @@ +# %% +import gym +from core.sampling import rollout +from core.trpo import trpo +from core.value import SetValue +from core.policy import DeepSetPolicy +import torch.optim +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools +import numpy as np +from gym.wrappers import TransformObservation +from wrappers import CollisionPenaltyWrapper +from core.reparam_module import ReparamPolicy + +from wrappers import Setobs + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [Setobs(TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, +), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10))) for _ in range(50)] + +env_fn = lambda i: envs[i] +policy = DeepSetPolicy(env_fn(0).action_space.shape[0]) +value = SetValue() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-4, weight_decay=1e-3) + +# %% +value, policy = trpo( + env_fn=env_fn, + value=value, + policy=policy, + epochs=150, + rollout_episodes=30, + rollout_steps=100, + gamma=0.99, + gae_lambda=0.95, + delta=0.01, + backtrack_coeff=0.9, + backtrack_iters=50, + v_opt=v_opt, + v_iters=1000, + cg_damping=0.1, +) + +torch.save(policy.state_dict(), 'trpo-intersimple-setobs.pt') + +# %% +policy = DeepSetPolicy(env_fn(0).action_space.shape[0]) +policy(torch.zeros(env_fn(0).observation_space.shape)) +policy = ReparamPolicy(policy) +policy.load_state_dict(torch.load('trpo-intersimple-setobs.pt')) + +env = env_fn(0) +obs = env.reset() +env.render(mode='post') +for i in range(300): + #action, _ = policy.predict(torch.tensor(obs)) + action = policy.sample(policy(torch.tensor(obs, dtype=torch.float32))) + obs, reward, done, _ = env.step(action) + env.render(mode='post') + print('step', i, 'reward', reward) + if done: + break +env.close() + +# %% diff --git a/scratch/etienne/trpo/trpo-intersimple-setobs2.py b/scratch/etienne/trpo/trpo-intersimple-setobs2.py new file mode 100644 index 0000000..778e9d3 --- /dev/null +++ b/scratch/etienne/trpo/trpo-intersimple-setobs2.py @@ -0,0 +1,87 @@ +# %% +import gym +from core.sampling import rollout +from core.trpo import trpo +from core.value import DeepSetValue +from core.policy import DeepSetPolicy +import torch.optim +from intersim.envs import IntersimpleLidarFlatRandom +from intersim.envs.intersimple import speed_reward +import functools +import numpy as np +from gym.wrappers import TransformObservation +from wrappers import CollisionPenaltyWrapper +from core.reparam_module import ReparamPolicy + +from wrappers import Setobs + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [Setobs(TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlatRandom( + n_rays=5, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, +), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10))) for _ in range(50)] + +env_fn = lambda i: envs[i] +policy = DeepSetPolicy(env_fn(0).action_space.shape[0]) +value = DeepSetValue() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-4, weight_decay=1e-3) + +# %% +value, policy = trpo( + env_fn=env_fn, + value=value, + policy=policy, + epochs=200, + rollout_episodes=30, + rollout_steps=100, + gamma=0.99, + gae_lambda=0.95, + delta=0.01, + backtrack_coeff=0.9, + backtrack_iters=50, + v_opt=v_opt, + v_iters=1000, + cg_damping=0.1, +) + +torch.save(policy.state_dict(), 'trpo-intersimple-setobs2.pt') + +# %% +policy = DeepSetPolicy(env_fn(0).action_space.shape[0]) +policy(torch.zeros(env_fn(0).observation_space.shape)) +policy = ReparamPolicy(policy) +policy.load_state_dict(torch.load('trpo-intersimple-setobs2.pt')) + +env = env_fn(0) +obs = env.reset() +env.render(mode='post') +for i in range(300): + #action, _ = policy.predict(torch.tensor(obs)) + action = policy.sample(policy(torch.tensor(obs, dtype=torch.float32))) + obs, reward, done, _ = env.step(action) + env.render(mode='post') + print('step', i, 'reward', reward) + if done: + break +env.close() diff --git a/scratch/etienne/trpo/trpo-intersimple.py b/scratch/etienne/trpo/trpo-intersimple.py new file mode 100644 index 0000000..e242a98 --- /dev/null +++ b/scratch/etienne/trpo/trpo-intersimple.py @@ -0,0 +1,42 @@ +import gym +from core.sampling import rollout +from core.trpo import trpo +from core.value import Value +from core.policy import Policy +import torch.optim +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools + +envs = [IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=10 + ), +) for _ in range(50)] + +env_fn = lambda i: envs[i] +policy = Policy(env_fn(0).action_space.shape[0]) +value = Value() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-4, weight_decay=1e-3) + +value, policy = trpo( + env_fn=env_fn, + value=value, + policy=policy, + epochs=4000, + rollout_episodes=30, + rollout_steps=100, + gamma=0.99, + gae_lambda=0.95, + delta=0.01, + backtrack_coeff=0.9, + backtrack_iters=50, + v_opt=v_opt, + v_iters=1000, + cg_damping=0.1, +) + +#rollout(env_fn, policy, n_episodes=9, max_steps_per_episode=200, render=True) diff --git a/scratch/etienne/trpo/trpo-options-minobs.py b/scratch/etienne/trpo/trpo-options-minobs.py new file mode 100644 index 0000000..eaee086 --- /dev/null +++ b/scratch/etienne/trpo/trpo-options-minobs.py @@ -0,0 +1,91 @@ +# %% +import gym +from core.sampling import rollout +from core.trpo import trpo +from core.value import Value +from core.policy import DiscretePolicy +import torch.optim +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools +import numpy as np +from wrappers import CollisionPenaltyWrapper, TransformObservation +from core.reparam_module import ReparamPolicy + +from wrappers import Minobs +from options.options import OptionsEnv + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [OptionsEnv(Minobs( + TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, + ), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10)) +), options=[(0, 5), (5, 5), (10, 5)]) for _ in range(50)] + +env_fn = lambda i: envs[i] +policy = DiscretePolicy(env_fn(0).action_space.n) +value = Value() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-4, weight_decay=1e-3) + +# %% +value, policy = trpo( + env_fn=env_fn, + value=value, + policy=policy, + epochs=50, + rollout_episodes=30, + rollout_steps=20, + gamma=0.99, + gae_lambda=0.95, + delta=0.01, + backtrack_coeff=0.9, + backtrack_iters=50, + v_opt=v_opt, + v_iters=1000, + cg_damping=0.1, +) + +torch.save(policy.state_dict(), 'trpo-options-minobs.pt') + +# %% +policy = DiscretePolicy(env_fn(0).action_space.n) +policy(torch.zeros(env_fn(0).observation_space.shape)) +policy = ReparamPolicy(policy) +policy.load_state_dict(torch.load('trpo-options-minobs.pt')) + +env = env_fn(0) +obs = env.reset() +env.render(mode='post') +for i in range(300): + #action, _ = policy.predict(torch.tensor(obs)) + action = policy.sample(policy(torch.tensor(obs, dtype=torch.float32))) + obs, reward, done, _ = env.step(action, render_mode='post') + print('step', i, 'reward', reward) + if done: + break +env.close() + +# %% diff --git a/scratch/etienne/trpo/trpo-pendulum-rollout.py b/scratch/etienne/trpo/trpo-pendulum-rollout.py new file mode 100644 index 0000000..f45640a --- /dev/null +++ b/scratch/etienne/trpo/trpo-pendulum-rollout.py @@ -0,0 +1,17 @@ +import gym +from core.gail import gail +from core.reparam_module import ReparamPolicy +from core.value import Value +from core.policy import Policy +from core.discriminator import Discriminator +import torch.optim +from core.sampling import rollout + +env_fn = lambda _: gym.make('Pendulum-v0') +policy = Policy(env_fn(0).action_space.shape[0]) +policy(torch.zeros(env_fn(0).observation_space.shape)) +policy = ReparamPolicy(policy) +policy.load_state_dict(torch.load('trpo-pendulum.pt')) + +expert_data = rollout(env_fn, policy, n_episodes=20, max_steps_per_episode=200) +torch.save(expert_data, 'trpo-pendulum-expert-data.pt') diff --git a/scratch/etienne/trpo/trpo-pendulum.py b/scratch/etienne/trpo/trpo-pendulum.py new file mode 100644 index 0000000..8233c83 --- /dev/null +++ b/scratch/etienne/trpo/trpo-pendulum.py @@ -0,0 +1,30 @@ +import gym +from gym.wrappers import TransformObservation +from core.trpo import trpo +from core.value import Value +from core.policy import Policy +import torch.optim + +env_fn = lambda _: TransformObservation(gym.make('Pendulum-v0'), lambda obs: obs) +policy = Policy(env_fn(0).action_space.shape[0]) +value = Value() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-3, weight_decay=1e-4) + +value, policy = trpo( + env_fn=env_fn, + value=value, + policy=policy, + epochs=100, + rollout_episodes=20, + rollout_steps=250, + gamma=0.99, + gae_lambda=0.9, + delta=0.01, + backtrack_coeff=0.8, + backtrack_iters=10, + v_opt=v_opt, + v_iters=1000, +) + + +torch.save(policy.state_dict(), 'trpo-pendulum.pt') diff --git a/scratch/etienne/trpo/trpo-walker.py b/scratch/etienne/trpo/trpo-walker.py new file mode 100644 index 0000000..59681d6 --- /dev/null +++ b/scratch/etienne/trpo/trpo-walker.py @@ -0,0 +1,26 @@ +import gym +from core.trpo import trpo +from core.value import Value +from core.policy import Policy +import torch.optim + +env_fn = lambda _: gym.make('BipedalWalker-v3') +policy = Policy(env_fn(0).action_space.shape[0]) +value = Value() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-2) + +trpo( + env_fn=env_fn, + value=value, + policy=policy, + epochs=1000, + rollout_episodes=20, + rollout_steps=250, + gamma=0.99, + gae_lambda=0.9, + delta=0.01, + backtrack_coeff=0.8, + backtrack_iters=10, + v_opt=v_opt, + v_iters=1000, +) diff --git a/scratch/etienne/trpo/wgail-intersimple-minobs.py b/scratch/etienne/trpo/wgail-intersimple-minobs.py new file mode 100644 index 0000000..b36988e --- /dev/null +++ b/scratch/etienne/trpo/wgail-intersimple-minobs.py @@ -0,0 +1,76 @@ +import gym +from core.gail import gail, Buffer +from core.value import Value +from core.policy import Policy +from core.discriminator import Discriminator +import torch.optim +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools +from wrappers import CollisionPenaltyWrapper, Minobs +import numpy as np +from gym.wrappers import TransformObservation + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [Minobs(TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, +), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10))) for _ in range(30)] +env_fn = lambda i: envs[i] + +policy = Policy(env_fn(0).action_space.shape[0]) + +value = Value() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-4, weight_decay=1e-3) + +discriminator = Discriminator() +disc_opt = torch.optim.Adam(discriminator.parameters(), lr=1e-3, weight_decay=1e-2) + +expert_data = torch.load('intersimple-expert-data-minobs.pt') +expert_data = Buffer(*expert_data) + +value, policy = gail( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=100, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=4000, + rollout_episodes=30, + rollout_steps=200, + gamma=0.99, + gae_lambda=0.9, + delta=0.01, + backtrack_coeff=0.8, + backtrack_iters=10, + wasserstein=True, + wasserstein_c=1., +) + +torch.save(policy.state_dict(), 'wgail-intersimple-minobs.pt') diff --git a/scratch/etienne/trpo/wgail-intersimple-minobs2.py b/scratch/etienne/trpo/wgail-intersimple-minobs2.py new file mode 100644 index 0000000..733a95c --- /dev/null +++ b/scratch/etienne/trpo/wgail-intersimple-minobs2.py @@ -0,0 +1,75 @@ +import gym +from core.gail import gail, Buffer +from core.value import Value +from core.policy import Policy +from core.discriminator import Discriminator +import torch.optim +from intersim.envs import IntersimpleLidarFlatRandom +from intersim.envs.intersimple import speed_reward +import functools +from wrappers import CollisionPenaltyWrapper, Minobs +import numpy as np +from gym.wrappers import TransformObservation + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [Minobs(TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlatRandom( + n_rays=5, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, +), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10))) for _ in range(50)] +env_fn = lambda i: envs[i] + +policy = Policy(env_fn(0).action_space.shape[0]) + +value = Value() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-4, weight_decay=1e-3) + +discriminator = Discriminator() +disc_opt = torch.optim.RMSprop(discriminator.parameters(), lr=1e-3, weight_decay=1e-5) + +expert_data = torch.load('intersimple-expert-data-minobs2.pt') +expert_data = Buffer(*expert_data) + +value, policy = gail( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=500, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=4000, + rollout_episodes=50, + rollout_steps=200, + gamma=0.99, + gae_lambda=0.9, + delta=0.01, + backtrack_coeff=0.8, + backtrack_iters=10, + wasserstein=True, + wasserstein_c=0.1, +) + +torch.save(policy.state_dict(), 'wgail-intersimple-minobs2.pt') diff --git a/scratch/etienne/trpo/wgail-intersimple-setobs2.py b/scratch/etienne/trpo/wgail-intersimple-setobs2.py new file mode 100644 index 0000000..95b8ebc --- /dev/null +++ b/scratch/etienne/trpo/wgail-intersimple-setobs2.py @@ -0,0 +1,77 @@ +import gym +from core.gail import gail, Buffer +from core.value import SetValue +from core.policy import SetPolicy +from core.discriminator import DeepsetDiscriminator +import torch.optim +from intersim.envs import IntersimpleLidarFlatRandom +from intersim.envs.intersimple import speed_reward +import functools +from wrappers import CollisionPenaltyWrapper, Setobs +import numpy as np +from gym.wrappers import TransformObservation +from torch.utils.tensorboard import SummaryWriter + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [Setobs(TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlatRandom( + n_rays=5, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, +), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10))) for _ in range(50)] +env_fn = lambda i: envs[i] + +policy = SetPolicy(env_fn(0).action_space.shape[0]) + +value = SetValue() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-4, weight_decay=1e-3) + +discriminator = DeepsetDiscriminator() +disc_opt = torch.optim.RMSprop(discriminator.parameters(), lr=1e-3) + +expert_data = torch.load('intersimple-expert-data-setobs2.pt') +expert_data = Buffer(*expert_data) + +value, policy = gail( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=500, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=800, + rollout_episodes=50, + rollout_steps=200, + gamma=0.99, + gae_lambda=0.9, + delta=0.01, + backtrack_coeff=0.8, + backtrack_iters=10, + wasserstein=True, + wasserstein_c=100., + logger=SummaryWriter(comment='-wgail-setobs2'), +) + +torch.save(policy.state_dict(), 'wgail-intersimple-setobs2.pt') diff --git a/scratch/etienne/trpo/wgail-intersimple.py b/scratch/etienne/trpo/wgail-intersimple.py new file mode 100644 index 0000000..793cb60 --- /dev/null +++ b/scratch/etienne/trpo/wgail-intersimple.py @@ -0,0 +1,56 @@ +import gym +from core.gail import gail, Buffer +from core.value import Value +from core.policy import Policy +from core.discriminator import Discriminator +import torch.optim +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools +from wrappers import CollisionPenaltyWrapper + +envs = [CollisionPenaltyWrapper(IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, +), collision_distance=6, collision_penalty=100) for _ in range(30)] +env_fn = lambda i: envs[i] + +policy = Policy(env_fn(0).action_space.shape[0]) + +value = Value() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-4) + +discriminator = Discriminator() +disc_opt = torch.optim.RMSprop(discriminator.parameters(), lr=1e-4) + +expert_data = torch.load('intersimple-expert-data.pt') +expert_data = Buffer(*expert_data) + +value, policy = gail( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=10, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=4000, + rollout_episodes=30, + rollout_steps=100, + gamma=0.99, + gae_lambda=0.9, + delta=0.01, + backtrack_coeff=0.8, + backtrack_iters=10, + wasserstein=True, + wasserstein_c=1., +) + +torch.save(policy.state_dict(), 'wgail-intersimple.pt') diff --git a/scratch/etienne/trpo/wgail-options-setobs.py b/scratch/etienne/trpo/wgail-options-setobs.py new file mode 100644 index 0000000..89944ed --- /dev/null +++ b/scratch/etienne/trpo/wgail-options-setobs.py @@ -0,0 +1,101 @@ +# %% +import gym +from options.options import gail +from core.gail import Buffer +from core.value import SetValue +from core.policy import SetDiscretePolicy +from core.discriminator import DeepsetDiscriminator +import torch.optim +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools +from wrappers import CollisionPenaltyWrapper, TransformObservation, Setobs +import numpy as np +from options.options import OptionsEnv +from torch.utils.tensorboard import SummaryWriter +from core.reparam_module import ReparamPolicy + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [OptionsEnv(Setobs( + TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, + ), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10)) +), options=[(0, 5), (1, 5), (2, 5), (4, 5), (8, 5)]) for _ in range(60)] + +env_fn = lambda i: envs[i] +policy = SetDiscretePolicy(env_fn(0).action_space.n) +value = SetValue() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-4) + +discriminator = DeepsetDiscriminator() +disc_opt = torch.optim.Adam(discriminator.parameters(), lr=1e-3, weight_decay=1e-3) + +expert_data = torch.load('intersimple-expert-data-setobs.pt') +expert_data = Buffer(*expert_data) + +# %% +value, policy = gail( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=100, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=150, + rollout_episodes=60, + rollout_steps=60, + gamma=0.99, + gae_lambda=0.9, + delta=0.01, + backtrack_coeff=0.8, + backtrack_iters=10, + wasserstein=True, + wasserstein_c=1., + logger=SummaryWriter(comment='wgail-options-setobs'), +) + +torch.save(policy.state_dict(), 'wgail-options-setobs.pt') + +# %% +policy = SetDiscretePolicy(env_fn(0).action_space.n) +policy(torch.zeros(env_fn(0).observation_space.shape)) +policy = ReparamPolicy(policy) +policy.load_state_dict(torch.load('wgail-options-setobs.pt')) + +env = env_fn(0) +obs = env.reset() +env.render(mode='post') +for i in range(300): + #action, _ = policy.predict(torch.tensor(obs)) + action = policy.sample(policy(torch.tensor(obs, dtype=torch.float32))) + obs, reward, done, _ = env.step(action, render_mode='post') + print('step', i, 'reward', reward) + if done: + break +env.close() diff --git a/scratch/etienne/trpo/wgail-options-setobs2.py b/scratch/etienne/trpo/wgail-options-setobs2.py new file mode 100644 index 0000000..6f7b2af --- /dev/null +++ b/scratch/etienne/trpo/wgail-options-setobs2.py @@ -0,0 +1,100 @@ +# %% +import gym +from options.options import gail +from core.gail import Buffer +from core.value import SetValue +from core.policy import SetDiscretePolicy +from core.discriminator import DeepsetDiscriminator +import torch.optim +from intersim.envs import IntersimpleLidarFlatRandom +from intersim.envs.intersimple import speed_reward +import functools +from wrappers import CollisionPenaltyWrapper, TransformObservation, Setobs +import numpy as np +from options.options import OptionsEnv +from torch.utils.tensorboard import SummaryWriter +from core.reparam_module import ReparamPolicy + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [OptionsEnv(Setobs( + TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlatRandom( + n_rays=5, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, + ), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10)) +), options=[(0, 5), (1, 5), (2, 5), (4, 5), (6, 5), (8, 5)]) for _ in range(60)] + +env_fn = lambda i: envs[i] +policy = SetDiscretePolicy(env_fn(0).action_space.n) +value = SetValue() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-4) + +discriminator = DeepsetDiscriminator() +disc_opt = torch.optim.Adam(discriminator.parameters(), lr=1e-3, weight_decay=1e-3) + +expert_data = torch.load('intersimple-expert-data-setobs2.pt') +expert_data = Buffer(*expert_data) + +# %% +value, policy = gail( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=100, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=200, + rollout_episodes=60, + rollout_steps=60, + gamma=0.99, + gae_lambda=0.9, + delta=0.01, + backtrack_coeff=0.8, + backtrack_iters=10, + wasserstein=True, + wasserstein_c=1., + logger=SummaryWriter(comment='wgail-options-setobs2'), +) + +torch.save(policy.state_dict(), 'wgail-options-setobs2.pt') + +# %% +policy = SetDiscretePolicy(env_fn(0).action_space.n) +policy(torch.zeros(env_fn(0).observation_space.shape)) +policy = ReparamPolicy(policy) +policy.load_state_dict(torch.load('wgail-options-setobs2.pt')) + +env = env_fn(0) +obs = env.reset() +env.render(mode='post') +for i in range(300): + #action, _ = policy.predict(torch.tensor(obs)) + action = policy.sample(policy(torch.tensor(obs, dtype=torch.float32))) + obs, reward, done, _ = env.step(action, render_mode='post') + print('step', i, 'reward', reward) + if done: + break +env.close() diff --git a/scratch/etienne/trpo/wgail-pendulum.py b/scratch/etienne/trpo/wgail-pendulum.py new file mode 100644 index 0000000..e79bd46 --- /dev/null +++ b/scratch/etienne/trpo/wgail-pendulum.py @@ -0,0 +1,40 @@ +import gym +from core.gail import gail, Buffer +from core.value import Value +from core.policy import Policy +from core.discriminator import Discriminator +import torch.optim + +env_fn = lambda _: gym.make('Pendulum-v0') +policy = Policy(env_fn(0).action_space.shape[0]) +value = Value() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-3) +discriminator = Discriminator() +disc_opt = torch.optim.Adam(discriminator.parameters(), lr=1e-3, weight_decay=1e-3) + +expert_data = torch.load('trpo-pendulum-expert-data.pt') +expert_data = Buffer(*expert_data) + +gail( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=10, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=100, + rollout_episodes=20, + rollout_steps=200, + gamma=0.99, + gae_lambda=0.9, + delta=0.01, + backtrack_coeff=0.8, + backtrack_iters=10, + wasserstein=True, + wasserstein_c=100., +) + +torch.save(policy.state_dict(), 'gail-pendulum.pt') diff --git a/scratch/etienne/trpo/wgail-ppo-intersimple-minobs.py b/scratch/etienne/trpo/wgail-ppo-intersimple-minobs.py new file mode 100644 index 0000000..45d0143 --- /dev/null +++ b/scratch/etienne/trpo/wgail-ppo-intersimple-minobs.py @@ -0,0 +1,77 @@ +import gym +from core.gail import gail_ppo, Buffer +from core.value import Value +from core.policy import Policy +from core.discriminator import Discriminator +import torch.optim +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools +from wrappers import CollisionPenaltyWrapper, Minobs +import numpy as np +from gym.wrappers import TransformObservation + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [Minobs(TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, +), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10))) for _ in range(30)] +env_fn = lambda i: envs[i] + +policy = Policy(env_fn(0).action_space.shape[0]) +pi_opt = torch.optim.RMSprop(policy.parameters(), lr=3e-4) + +value = Value() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-3, weight_decay=1e-3) + +discriminator = Discriminator() +disc_opt = torch.optim.RMSprop(discriminator.parameters(), lr=1e-3, weight_decay=1e-5) + +expert_data = torch.load('intersimple-expert-data-minobs.pt') +expert_data = Buffer(*expert_data) + +value, policy = gail_ppo( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=100, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=4000, + rollout_episodes=30, + rollout_steps=100, + gamma=0.99, + gae_lambda=0.9, + clip_ratio=0.2, + pi_opt=pi_opt, + pi_iters=100, + wasserstein=True, + wasserstein_c=1., +) + +torch.save(policy.state_dict(), 'wgail-ppo-intersimple-minobs.pt') diff --git a/scratch/etienne/trpo/wgail-ppo-intersimple-setobs2.py b/scratch/etienne/trpo/wgail-ppo-intersimple-setobs2.py new file mode 100644 index 0000000..30b69a0 --- /dev/null +++ b/scratch/etienne/trpo/wgail-ppo-intersimple-setobs2.py @@ -0,0 +1,78 @@ +import gym +from core.gail import gail_ppo, Buffer +from core.value import SetValue +from core.policy import SetPolicy +from core.discriminator import DeepsetDiscriminator +import torch.optim +from intersim.envs import IntersimpleLidarFlatRandom +from intersim.envs.intersimple import speed_reward +import functools +from wrappers import CollisionPenaltyWrapper, Setobs +import numpy as np +from gym.wrappers import TransformObservation +from torch.utils.tensorboard import SummaryWriter + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [Setobs(TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlatRandom( + n_rays=5, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, +), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10))) for _ in range(50)] +env_fn = lambda i: envs[i] + +policy = SetPolicy(env_fn(0).action_space.shape[0]) +pi_opt = torch.optim.Adam(policy.parameters(), lr=3e-4) + +value = SetValue() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-4, weight_decay=1e-3) + +discriminator = DeepsetDiscriminator() +disc_opt = torch.optim.RMSprop(discriminator.parameters(), lr=1e-3) + +expert_data = torch.load('intersimple-expert-data-setobs2.pt') +expert_data = Buffer(*expert_data) + +value, policy = gail_ppo( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=500, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=800, + rollout_episodes=50, + rollout_steps=200, + gamma=0.99, + gae_lambda=0.9, + clip_ratio=0.2, + pi_opt=pi_opt, + pi_iters=100, + wasserstein=True, + wasserstein_c=100., + logger=SummaryWriter(comment='-wgail-ppo-setobs2'), +) + +torch.save(policy.state_dict(), 'wgail-ppo-intersimple-setobs2.pt') diff --git a/scratch/etienne/trpo/wgail-ppo-intersimple.py b/scratch/etienne/trpo/wgail-ppo-intersimple.py new file mode 100644 index 0000000..8b75715 --- /dev/null +++ b/scratch/etienne/trpo/wgail-ppo-intersimple.py @@ -0,0 +1,57 @@ +import gym +from core.gail import gail_ppo, Buffer +from core.value import Value +from core.policy import Policy +from core.discriminator import Discriminator +import torch.optim +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools +from collision_penalty import CollisionPenaltyWrapper + +envs = [CollisionPenaltyWrapper(IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, +), collision_distance=6, collision_penalty=100) for _ in range(30)] +env_fn = lambda i: envs[i] + +policy = Policy(env_fn(0).action_space.shape[0]) +pi_opt = torch.optim.RMSprop(policy.parameters(), lr=3e-4) + +value = Value() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-3) + +discriminator = Discriminator() +disc_opt = torch.optim.RMSprop(discriminator.parameters(), lr=3e-4) + +expert_data = torch.load('intersimple-expert-data.pt') +expert_data = Buffer(*expert_data) + +value, policy = gail_ppo( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=10, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=4000, + rollout_episodes=30, + rollout_steps=100, + gamma=0.99, + gae_lambda=0.9, + clip_ratio=0.2, + pi_opt=pi_opt, + pi_iters=100, + wasserstein=True, + wasserstein_c=1., +) + +torch.save(policy.state_dict(), 'wgail-ppo-intersimple.pt') diff --git a/scratch/etienne/trpo/wgail-ppo-options-setobs.py b/scratch/etienne/trpo/wgail-ppo-options-setobs.py new file mode 100644 index 0000000..fa89bf0 --- /dev/null +++ b/scratch/etienne/trpo/wgail-ppo-options-setobs.py @@ -0,0 +1,98 @@ +import gym +from options.options import gail_ppo, Buffer +from core.value import SetValue +from core.policy import SetDiscretePolicy +from core.discriminator import DeepsetDiscriminator +import torch.optim +from intersim.envs import IntersimpleLidarFlat +from intersim.envs.intersimple import speed_reward +import functools +from wrappers import CollisionPenaltyWrapper, TransformObservation, Setobs +import numpy as np +from options.options import OptionsEnv +from torch.utils.tensorboard import SummaryWriter + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [OptionsEnv(Setobs( + TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlat( + n_rays=5, + agent=51, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, + ), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10)) +), options=[(0, 5), (1, 5), (2, 5), (4, 5), (8, 5)]) for _ in range(60)] + +env_fn = lambda i: envs[i] + +policy = SetDiscretePolicy(env_fn(0).action_space.n) +pi_opt = torch.optim.Adam(policy.parameters(), lr=3e-4) + +value = SetValue() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-3) + +discriminator = DeepsetDiscriminator() +disc_opt = torch.optim.Adam(discriminator.parameters(), lr=1e-3, weight_decay=1e-3) + +expert_data = torch.load('intersimple-expert-data-setobs.pt') +expert_data = Buffer(*expert_data) + +value, policy = gail_ppo( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=100, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=150, + rollout_episodes=60, + rollout_steps=60, + gamma=0.99, + gae_lambda=0.9, + clip_ratio=0.2, + pi_opt=pi_opt, + pi_iters=100, + wasserstein=True, + wasserstein_c=1., + logger=SummaryWriter(comment='wgail-ppo-options-setobs'), +) + +torch.save(policy.state_dict(), 'wgail-ppo-options-setobs.pt') + +# %% +policy = SetDiscretePolicy(env_fn(0).action_space.n) +policy(torch.zeros(env_fn(0).observation_space.shape)) +policy.load_state_dict(torch.load('wgail-ppo-options-setobs.pt')) + +env = env_fn(0) +obs = env.reset() +env.render(mode='post') +for i in range(300): + action = policy.sample(policy(torch.tensor(obs, dtype=torch.float32))) + obs, reward, done, _ = env.step(action, render_mode='post') + print('step', i, 'reward', reward) + if done: + break +env.close() \ No newline at end of file diff --git a/scratch/etienne/trpo/wgail-ppo-options-setobs2.py b/scratch/etienne/trpo/wgail-ppo-options-setobs2.py new file mode 100644 index 0000000..ea6fbfa --- /dev/null +++ b/scratch/etienne/trpo/wgail-ppo-options-setobs2.py @@ -0,0 +1,99 @@ +# %% +import gym +from options.options import gail_ppo, Buffer +from core.value import SetValue +from core.policy import SetDiscretePolicy +from core.discriminator import DeepsetDiscriminator +import torch.optim +from intersim.envs import IntersimpleLidarFlatRandom +from intersim.envs.intersimple import speed_reward +import functools +from wrappers import CollisionPenaltyWrapper, TransformObservation, Setobs +import numpy as np +from options.options import OptionsEnv +from torch.utils.tensorboard import SummaryWriter + +obs_min = np.array([ + [-1000, -1000, 0, -np.pi, -1e-1, 0.], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], + [0, -np.pi, -20, -20, -np.pi, -1e-1], +]).reshape(-1) + +obs_max = np.array([ + [1000, 1000, 20, np.pi, 1e-1, 0.], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], + [50, np.pi, 20, 20, np.pi, 1e-1], +]).reshape(-1) + +envs = [OptionsEnv(Setobs( + TransformObservation(CollisionPenaltyWrapper(IntersimpleLidarFlatRandom( + n_rays=5, + reward=functools.partial( + speed_reward, + collision_penalty=0 + ), + stop_on_collision=False, + ), collision_distance=6, collision_penalty=100), lambda obs: (obs - obs_min) / (obs_max - obs_min + 1e-10)) +), options=[(0, 5), (1, 5), (2, 5), (4, 5), (6, 5), (8, 5)]) for _ in range(60)] + +env_fn = lambda i: envs[i] + +policy = SetDiscretePolicy(env_fn(0).action_space.n) +pi_opt = torch.optim.Adam(policy.parameters(), lr=3e-4) + +value = SetValue() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-3) + +discriminator = DeepsetDiscriminator() +disc_opt = torch.optim.Adam(discriminator.parameters(), lr=1e-3, weight_decay=1e-3) + +expert_data = torch.load('intersimple-expert-data-setobs2.pt') +expert_data = Buffer(*expert_data) + +# %% +value, policy = gail_ppo( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=100, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=200, + rollout_episodes=60, + rollout_steps=60, + gamma=0.99, + gae_lambda=0.9, + clip_ratio=0.2, + pi_opt=pi_opt, + pi_iters=100, + wasserstein=True, + wasserstein_c=1., + logger=SummaryWriter(comment='wgail-ppo-options-setobs2'), +) + +torch.save(policy.state_dict(), 'wgail-ppo-options-setobs2.pt') + +# %% +policy = SetDiscretePolicy(env_fn(0).action_space.n) +policy(torch.zeros(env_fn(0).observation_space.shape)) +policy.load_state_dict(torch.load('wgail-ppo-options-setobs2.pt')) + +env = env_fn(0) +obs = env.reset() +env.render(mode='post') +for i in range(300): + action = policy.sample(policy(torch.tensor(obs, dtype=torch.float32))) + obs, reward, done, _ = env.step(action, render_mode='post') + print('step', i, 'reward', reward) + if done: + break +env.close() \ No newline at end of file diff --git a/scratch/etienne/trpo/wgail-ppo-pendulum.py b/scratch/etienne/trpo/wgail-ppo-pendulum.py new file mode 100644 index 0000000..2b4e05c --- /dev/null +++ b/scratch/etienne/trpo/wgail-ppo-pendulum.py @@ -0,0 +1,44 @@ +import gym +from core.gail import gail_ppo, Buffer +from core.value import Value +from core.policy import Policy +from core.discriminator import Discriminator +import torch.optim + +env_fn = lambda _: gym.make('Pendulum-v0') + +policy = Policy(env_fn(0).action_space.shape[0]) +pi_opt = torch.optim.RMSprop(policy.parameters(), lr=3e-4) + +value = Value() +v_opt = torch.optim.Adam(value.parameters(), lr=1e-3) + +discriminator = Discriminator() +disc_opt = torch.optim.Adam(discriminator.parameters(), lr=1e-3, weight_decay=1e-3) + +expert_data = torch.load('trpo-pendulum-expert-data.pt') +expert_data = Buffer(*expert_data) + +gail_ppo( + env_fn=env_fn, + expert_data=expert_data, + discriminator=discriminator, + disc_opt=disc_opt, + disc_iters=10, + policy=policy, + value=value, + v_opt=v_opt, + v_iters=1000, + epochs=100, + rollout_episodes=20, + rollout_steps=200, + gamma=0.99, + gae_lambda=0.9, + clip_ratio=0.2, + pi_opt=pi_opt, + pi_iters=100, + wasserstein=True, + wasserstein_c=100., +) + +torch.save(policy.state_dict(), 'gail-pendulum.pt') diff --git a/scratch/etienne/trpo/wrappers.py b/scratch/etienne/trpo/wrappers.py new file mode 100644 index 0000000..3916e75 --- /dev/null +++ b/scratch/etienne/trpo/wrappers.py @@ -0,0 +1,74 @@ +import numpy as np +import gym + +class Wrapper(gym.Wrapper): + def __getattr__(self, name): + return getattr(self.env, name) + +class TransformObservation(gym.wrappers.TransformObservation): + def __getattr__(self, name): + return getattr(self.env, name) + +class CollisionPenaltyWrapper(Wrapper): + + def __init__(self, env, collision_distance, collision_penalty, *args, **kwargs): + super().__init__(env, *args, **kwargs) + self.penalty = collision_penalty + self.distance = collision_distance + + def step(self, action): + obs, reward, done, info = super().step(action) + reward = -self.penalty if (obs.reshape(-1, 6)[1:, 0] < self.distance).any() else reward + + self.env._rewards.pop() + self.env._rewards.append(reward) + + return obs, reward, done, info + +class Minobs(Wrapper): + """ Meant to be used as wrapper around LidarObservation """ + + def __init__(self, env, *args, **kwargs): + super().__init__(env, *args, **kwargs) + n_rays = int(self.observation_space.shape[0] / 6) - 1 + self.observation_space = gym.spaces.Box(low=-np.inf, high=np.inf, shape=((1 + n_rays) * 2,)) + + def minobs(self, obs): + """ ego v, psidot ; (for each ray,) rel. distance, rel. velocity in ego forward direction """ + obs = obs.reshape(-1, 6) + obs = np.concatenate((obs[:1, [2, 4]], obs[1:, [0, 2]]), axis=0) + return obs.reshape(-1) + + def reset(self): + return self.minobs(super().reset()) + + def step(self, action): + obs, reward, done, info = super().step(action) + return self.minobs(obs), reward, done, info + +class Setobs(Wrapper): + """ Meant to be used as wrapper around LidarObservation """ + + def __init__(self, env, *args, **kwargs): + super().__init__(env, *args, **kwargs) + self.n_rays = int(self.observation_space.shape[0] / 6) - 1 + self.observation_space = gym.spaces.Box(low=-np.inf, high=np.inf, shape=(self.n_rays, 6)) + + def obs(self, obs): + obs = obs.reshape(-1, 6) + + ego = obs[:1, [2, 4]] # v, psidot + ego = np.tile(ego, (self.n_rays, 1)) + + other = obs[1:, [0, 1, 2]] # distance, angle, velocity component in ego forward direction + other = np.stack((other[:, 0], np.cos(other[:, 1]), np.sin(other[:, 1]), other[:, 2]), axis=-1) + + obs = np.concatenate((ego, other), axis=-1) + return obs + + def reset(self): + return self.obs(super().reset()) + + def step(self, action): + obs, reward, done, info = super().step(action) + return self.obs(obs), reward, done, info