clearing stale __init__

README.md

@@ -1,10 +1,22 @@
 # InteractionImitation
-Imitation Learning with the INTERACTION Dataset
+Imitation Learning with the [Interaction Dataset](https://interaction-dataset.com/) via the [InteractionSimulator](https://github.com/sisl/InteractionSimulator) gym environments.
+
+Code for "[SHAIL: Safety-Aware Hierarchical Adversarial Imitation Learning for Autonomous Driving in Urban Environments](https://arxiv.org/abs/2204.01922)".
+If you find this repository useful, please cite the paper:
+
+```
+@article{jamgochian2022shail,
+  author = {Arec Jamgochian and Etienne Buehrle and Johannes Fischer and Mykel J. Kochenderfer},
+  title = {{SHAIL}: Safety-Aware Hierarchical Adversarial Imitation Learning for Autonomous Driving in Urban Environments},
+  journal = {arXiv:2204.01922 [cs]},
+  year = {2022}
+}
+```
 
 ## Getting started
-Clone InteractionSimulator and pip install the module.
+Clone the `InteractionSimulator` with the `shail` tag and pip install the module.
 ```
-git clone https://github.com/sisl/InteractionSimulator.git
+git clone --branch shail https://github.com/sisl/InteractionSimulator.git
 cd InteractionSimulator
 pip install -e .
 cd ..

eval_experiments.py

@@ -6,12 +6,12 @@ import json
 
 activations = [torch.nn.Tanh, torch.nn.LeakyReLU]
 
-def main(method:str='expert', folder:str=None, locations=[(0,0)], skip_running=False, save_videos:bool=False, videos_folder:str='videos', first_seed_only:bool=False):
+def main(method:str='expert', folder:str=None, locations=[(0,0)], skip_running=False):
     
     exclude_keys_from_policy_kwargs = {'learning_rate', 'learning_rate_decay', 'clip_ratio', 'iterations_per_epoch', 'option'}
     policy_kwargs = {}
 
-    if method in ['expert', 'expert_agent', 'idm']:
+    if method in ['expert', 'idm']:
         env, env_kwargs ='NRasterizedRouteIncrementingAgent', {}
     elif method in ['bc','gail']:
         env='NormalizedContinuousEvalEnv' 
@@ -30,13 +30,8 @@ def main(method:str='expert', folder:str=None, locations=[(0,0)], skip_running=F
     if folder is not None:
         files = [os.path.join(folder, f) for f in os.listdir(folder) if os.path.isfile(os.path.join(folder, f))]
         files = [f for f in files if f.endswith('.pt')]
-
-        if first_seed_only:
-            files = files[:1]
-
         with open(os.path.join(folder, 'config.json'), 'rb') as f:
             config = json.load(f)
-            
         print('%i policy files found in %s folder' %(len(files), folder))
         print('found policy config', config['policy'])
 
@@ -55,8 +50,7 @@ def main(method:str='expert', folder:str=None, locations=[(0,0)], skip_running=F
                                 policy_file=policy_file, 
                                 policy_kwargs=policy_kwargs,
                                 env=env, 
-                                env_kwargs=env_kwargs,
-                                videos_folder=None if not save_videos else videos_folder)
+                                env_kwargs=env_kwargs)
         outfolder = os.path.dirname(outbase)
     else:
         locstr = 'loc_'+'_'.join([f'r{ro}t{tr}' for (ro,tr) in locations])

generate_videos.sh

@@ -1,20 +0,0 @@
-# can add --skip_running if you've already run the saved policies through the test environments and have appropriate
-# metrics in the out folder. Doing so will generate average metrics quickly.
-
-# Experiment A
-python -m eval_experiments 
-python -m eval_experiments --method expert_agent --save_videos --first_seed_only
-python -m eval_experiments --method idm --save_videos --first_seed_only
-python -m eval_experiments --method bc --folder='test_policies/bc/expA' --save_videos --first_seed_only
-python -m eval_experiments --method gail --folder='test_policies/gail/expA' --save_videos --first_seed_only
-python -m eval_experiments --method hail --folder='test_policies/hail/expA' --save_videos --first_seed_only
-python -m eval_experiments --method shail --folder='test_policies/shail/expA' --save_videos --first_seed_only
-
-# Experiment B
-python -m eval_experiments --locations='[(0,4)]' 
-python -m eval_experiments --method expert_agent --locations='[(0,4)]' --save_videos --first_seed_only
-python -m eval_experiments --method idm --locations='[(0,4)]' --save_videos --first_seed_only
-python -m eval_experiments --method bc --folder='test_policies/bc/expB' --locations='[(0,4)]' --save_videos --first_seed_only
-python -m eval_experiments --method gail --folder='test_policies/gail/expB' --locations='[(0,4)]' --save_videos --first_seed_only
-python -m eval_experiments --method hail --folder='test_policies/hail/expB' --locations='[(0,4)]' --save_videos --first_seed_only
-python -m eval_experiments --method shail --folder='test_policies/shail/expB' --locations='[(0,4)]' --save_videos --first_seed_only

src/__init__.py

@@ -1 +0,0 @@
-

src/eval_main.py

@@ -5,7 +5,6 @@ import intersim
 from intersim.envs import Intersimple
 from stable_baselines3.common.base_class import BaseAlgorithm
 from src.baselines import IDMRulePolicy
-from src.data.expert import NormalizedIntersimpleExpert
 from src.evaluation import IntersimpleEvaluation
 import src.gail.options as options_envs
 from src.evaluation.metrics import divergence, visualize_distribution, rwse
@@ -41,8 +40,6 @@ def load_policy(method:str,
     ml = torch.device('cpu') if not torch.cuda.is_available() else None
     if method == 'idm':
         policy = IDMRulePolicy(env, **policy_kwargs)
-    elif method == 'expert_agent':
-        policy = NormalizedIntersimpleExpert(env, **policy_kwargs)
     elif method == 'bc':
         policy = SetPolicy(env.action_space.shape[-1], **policy_kwargs)
         policy.load_state_dict(torch.load(policy_file, map_location=ml))
@@ -180,8 +177,7 @@ def evaluate_policy(locations:List[Tuple[int,int]],
     env_kwargs:dict,
     method: str,
     policy_file: str,
-    policy_kwargs:dict,
-    videos_folder: Optional[str] = None) -> List[Dict[str,list]]:
+    policy_kwargs:dict) -> List[Dict[str,list]]:
     """
     Evaluate policy on an incrementing agent environment at all locations. 
     Return metrics for that policy
@@ -234,13 +230,7 @@ def evaluate_policy(locations:List[Tuple[int,int]],
         policy = load_policy(method, policy_file, policy_kwargs, eval_env)
 
         # run policy on environment
-        policy_videos_folder = None
-        if videos_folder is not None:
-            policy_videos_folder = os.path.join(videos_folder, method, f'loc{iround}', f'track{track}')
-            os.makedirs(policy_videos_folder, exist_ok=True)
-        policy_metrics[i] = evaluator.evaluate(
-            policy, videos_folder=policy_videos_folder
-        )
+        policy_metrics[i] = evaluator.evaluate(policy)
     
     return policy_metrics
         
@@ -374,8 +364,7 @@ def eval_main(
     policy_kwargs: dict={},
     env: str='NRasterizedRouteIncrementingAgent', 
     env_kwargs: dict={},
-    seed: int=0,
-    videos_folder: Optional[str]=None):
+    seed: int=0):
     """
     Test a particular model at different testing locations/tracks and compute average metrics 
     over all files. 
@@ -421,7 +410,7 @@ def eval_main(
     else:
 
         # evaluate it on the given roundabouts
-        policy_metrics = evaluate_policy(locations, env, env_kwargs, method, policy_file, policy_kwargs, videos_folder=videos_folder)
+        policy_metrics = evaluate_policy(locations, env, env_kwargs, method, policy_file, policy_kwargs)
         smetrics = summary_metrics(policy_metrics)
         save_metrics(smetrics, outbase+'_summary.pkl')
         cmetrics = comparison_metrics(policy_metrics, expert_metrics, outbase=outbase)

src/evaluation/evaluation.py

@@ -9,8 +9,6 @@ from tqdm import tqdm
 from src.util.wrappers import IntersimpleTimeLimit
 from src.options.envs import OptionsEnv
 from src.safe_options.options import SafeOptionsEnv
-from src.evaluation.vec_env import CallbackWhenDoneVecEnv
-import matplotlib.pyplot as plt
 
 class IntersimpleEvaluation:
     """
@@ -82,7 +80,7 @@ class IntersimpleEvaluation:
         with open(filestr, 'wb') as f:
             pickle.dump(self._metrics, f)     
 
-    def evaluate(self, policy, filestr: Optional[str] = None, videos_folder: Optional[str] = None) -> Dict[str, list]:
+    def evaluate(self, policy, filestr: Optional[str] = None) -> Dict[str, list]:
         """
         Evaluate a policy on the incrementing agent evaluation environment
         
@@ -90,8 +88,6 @@ class IntersimpleEvaluation:
             policy (BaseClass.BaseAlgorithm): policy in which policy.predict(observation)[0] returns an action
             filestr (str): path-like string to dump metrics to or None
         """
-        self.videos_folder = videos_folder
-
         self.reset()
         if self.use_pbar:
             self.pbar = tqdm(total=self.n_episodes)
@@ -101,11 +97,10 @@ class IntersimpleEvaluation:
 
         evaluate_policy(
             policy, 
-            self.env if self.videos_folder is None else CallbackWhenDoneVecEnv([lambda: self.env], self.done_callback),
+            self.env,
             n_eval_episodes=self.n_episodes,
             callback=self.evaluate_options_policy_callback if self.is_options_env else self.evaluate_policy_callback,
-            return_episode_rewards=False,
-            render=self.videos_folder is not None,
+            return_episode_rewards=False
         )
         if self.use_pbar:
             self.pbar.close()
@@ -151,14 +146,6 @@ class IntersimpleEvaluation:
         if done and self.use_pbar:
             self.pbar.update(1)
     
-    def done_callback(self, info):
-        if self.is_options_env:
-            info = info['ll']['infos'][0]
-        agent = info['agent']
-        filestr = os.path.join(self.videos_folder, f'agent{agent}')
-        self.env.close(filestr=filestr)
-        plt.close('all')
-    
     def post_proc(self):
         """
         Postprocess and metrics after simulation episodes

src/evaluation/vec_env.py

@@ -1,30 +0,0 @@
-from stable_baselines3.common.vec_env import DummyVecEnv
-from stable_baselines3.common.vec_env.base_vec_env import VecEnvStepReturn
-from copy import deepcopy
-import numpy as np
-
-class CallbackWhenDoneVecEnv(DummyVecEnv):
-    """DummyVecEnv that calls `done_callback` before resetting the wrapped environment."""
-
-    def __init__(self, env_fns, done_callback):
-        assert len(env_fns) == 1 # for now
-        super().__init__(env_fns)
-        self.done_callback = done_callback
-
-    def step_wait(self) -> VecEnvStepReturn:
-        for env_idx in range(self.num_envs):
-            obs, self.buf_rews[env_idx], self.buf_dones[env_idx], self.buf_infos[env_idx] = self.envs[env_idx].step(
-                self.actions[env_idx]
-            )
-            if self.buf_dones[env_idx]:
-                # save final observation where user can get it, then reset
-                self.buf_infos[env_idx]["terminal_observation"] = obs
-
-                self.done_callback(deepcopy(self.buf_infos[env_idx]))
-                
-                obs = self.envs[env_idx].reset()
-            self._save_obs(env_idx, obs)
-        return (self._obs_from_buf(), np.copy(self.buf_rews), np.copy(self.buf_dones), deepcopy(self.buf_infos))
-    
-    def render(self, mode='post'):
-        super().render(mode)

src/options/envs.py

@@ -45,7 +45,6 @@ class OptionsEnv(Wrapper):
         self.options = options
         self.action_space = gym.spaces.Discrete(len(options))
         self.max_plan_length = max(t for _, t in options)
-        self.render_mode = None
     
     def plan(self, option):
         target_v, t = option
@@ -86,13 +85,10 @@ class OptionsEnv(Wrapper):
         n_steps = k + 1
         return observations, actions, rewards, env_done, plan_done, infos, n_steps
 
-    def render(self, mode='post'):
-        self.render_mode = mode
-
-    def step(self, action):
+    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], self.render_mode)
+        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-1].item()

src/safe_options/options.py

@@ -225,8 +225,8 @@ class SafeOptionsEnv(OptionsEnv):
         }
         return obs
 
-    def step(self, action):
-        obs, reward, done, info = super().step(action)
+    def step(self, action, render_mode=None):
+        obs, reward, done, info = super().step(action, render_mode)
         obs = {
             'observation': obs,
             'safe_actions': self.safe_actions(),

src/util/wrappers.py

@@ -5,23 +5,14 @@ class Wrapper(gym.Wrapper):
     def __getattr__(self, name):
         return getattr(self.env, name)
 
-    def close(self, *args, **kwargs):
-        return self.env.close(*args, **kwargs)
-
 class TransformObservation(gym.wrappers.TransformObservation):
     def __getattr__(self, name):
         return getattr(self.env, name)
 
-    def close(self, *args, **kwargs):
-        return self.env.close(*args, **kwargs)
-
 class IntersimpleTimeLimit(gym.wrappers.TimeLimit):
     def __getattr__(self, name):
         return getattr(self.env, name)
 
-    def close(self, *args, **kwargs):
-        return self.env.close(*args, **kwargs)
-
 class CollisionPenaltyWrapper(Wrapper):
 
     def __init__(self, env, collision_distance, collision_penalty, *args, **kwargs):