From 4c4c0a4752579c8f1e0394eeba26ce7c351220aa Mon Sep 17 00:00:00 2001 From: Luis Pineda Date: Mon, 8 Mar 2021 11:53:12 -0500 Subject: [PATCH 1/5] changed abstract Model to have is_ensemble and is_determinsitic as properties relying on abstract methods that must be implemented by subclasses. --- mbrl/models/base_models.py | 30 +++++++++++++++++++++--------- mbrl/models/gaussian_mlp.py | 30 +++++++++++++++++------------- mbrl/models/model_env.py | 2 +- tests/core/test_models.py | 31 ++++++++++++++++++++++++++++++- 4 files changed, 69 insertions(+), 24 deletions(-) diff --git a/mbrl/models/base_models.py b/mbrl/models/base_models.py index 54a1db51..39e5ab2c 100644 --- a/mbrl/models/base_models.py +++ b/mbrl/models/base_models.py @@ -111,7 +111,6 @@ def __init__( self.in_size = in_size self.out_size = out_size self.device = torch.device(device) - self.is_ensemble = False self.to(device) def forward(self, x: torch.Tensor, **kwargs) -> Tuple[torch.Tensor, torch.Tensor]: @@ -141,7 +140,6 @@ def loss( Returns: (tensor): a loss tensor. """ - pass @abc.abstractmethod def eval_score(self, model_in: torch.Tensor, target: torch.Tensor) -> torch.Tensor: @@ -166,23 +164,35 @@ def eval_score(self, model_in: torch.Tensor, target: torch.Tensor) -> torch.Tens Returns: (tensor): a non-reduced tensor score. """ - pass @abc.abstractmethod def save(self, path: str): """Saves the model to the given path. """ - pass @abc.abstractmethod def load(self, path: str): """Loads the model from the given path.""" + + @abc.abstractmethod + def _is_deterministic_impl(self): + # Subclasses must specify if model is _deterministic or not pass @abc.abstractmethod - def is_deterministic(self): - """Whether the model produces logvar predictions or not.""" + def _is_ensemble_impl(self): + # Subclasses must specify if they are ensembles or not pass + @property + def is_deterministic(self): + """Whether the model is deterministic or not.""" + return self._is_deterministic_impl() + + @property + def is_ensemble(self): + """Whether the model is an ensemble or not.""" + return self._is_ensemble_impl() + def update( self, model_in: torch.Tensor, @@ -277,7 +287,6 @@ def __init__( ): super().__init__(in_size, out_size, device) self.members = [] - self.is_ensemble = True for i in range(ensemble_size): model = hydra.utils.instantiate(member_cfg) self.members.append(model) @@ -483,8 +492,11 @@ def load(self, path: str): state_dict = torch.load(path) self.load_state_dict(state_dict) - def is_deterministic(self): - return self.members[0].is_deterministic() + def _is_ensemble_impl(self): + return True + + def _is_deterministic_impl(self): + return self.members[0].is_deterministic def sample_propagation_indices( self, batch_size: int, rng: torch.Generator diff --git a/mbrl/models/gaussian_mlp.py b/mbrl/models/gaussian_mlp.py index 3dc9e643..96a05e88 100644 --- a/mbrl/models/gaussian_mlp.py +++ b/mbrl/models/gaussian_mlp.py @@ -55,8 +55,9 @@ def __init__( activation_cls = nn.SiLU if use_silu else nn.ReLU self.num_members = None + self._is_ensemble = False if ensemble_size > 1: - self.is_ensemble = True + self._is_ensemble = True self.num_members = ensemble_size def create_linear_layer(l_in, l_out): @@ -77,13 +78,13 @@ def create_linear_layer(l_in, l_out): ) self.hidden_layers = nn.Sequential(*hidden_layers) - self.deterministic = deterministic + self._deterministic = deterministic if deterministic: self.mean_and_logvar = create_linear_layer(hid_size, out_size) else: self.mean_and_logvar = create_linear_layer(hid_size, 2 * out_size) logvar_shape = ( - (self.num_members, 1, out_size) if self.is_ensemble else (1, out_size) + (self.num_members, 1, out_size) if self._is_ensemble else (1, out_size) ) self.min_logvar = nn.Parameter( -10 * torch.ones(logvar_shape, requires_grad=True) @@ -116,12 +117,12 @@ def _default_forward( x = self.hidden_layers(x) mean_and_logvar = self.mean_and_logvar(x) self._maybe_toggle_layers_use_only_elite(only_elite) - if self.deterministic: + if self._deterministic: return mean_and_logvar, None else: mean = mean_and_logvar[..., : self.out_size] logvar = mean_and_logvar[..., self.out_size :] - if self.is_ensemble and self.elite_models is not None: + if self._is_ensemble and self.elite_models is not None: model_idx = self.elite_models if only_elite else range(self.num_members) assert not only_elite or (len(model_idx) != self.num_members), ( "If elite size == self.num_members, it's better " @@ -202,7 +203,7 @@ def forward( # type: ignore ) -> Tuple[torch.Tensor, torch.Tensor]: """Computes mean and logvar predictions for the given input. - When ``self.is_ensemble = True``, the model supports uncertainty propagation options + When ``self._is_ensemble = True``, the model supports uncertainty propagation options that can be used to aggregate the outputs of the different models in the ensemble. Valid propagation options are: @@ -250,7 +251,7 @@ def forward( # type: ignore the output to :func:`mbrl.math.propagate`. """ - if self.is_ensemble: + if self._is_ensemble: return self._forward_ensemble( x, propagation=propagation, @@ -261,7 +262,7 @@ def forward( # type: ignore def _mse_loss(self, model_in: torch.Tensor, target: torch.Tensor) -> torch.Tensor: pred_mean, _ = self.forward(model_in) - if self.is_ensemble: + if self._is_ensemble: assert model_in.ndim == 3 and target.ndim == 3 total_loss: torch.Tensor = 0.0 for i in range(self.num_members): @@ -274,7 +275,7 @@ def _mse_loss(self, model_in: torch.Tensor, target: torch.Tensor) -> torch.Tenso def _nll_loss(self, model_in: torch.Tensor, target: torch.Tensor) -> torch.Tensor: pred_mean, pred_logvar = self.forward(model_in) - if self.is_ensemble: + if self._is_ensemble: assert model_in.ndim == 3 and target.ndim == 3 nll: torch.Tensor = 0.0 for i in range(self.num_members): @@ -310,7 +311,7 @@ def loss(self, model_in: torch.Tensor, target: torch.Tensor) -> torch.Tensor: the model over the given input/target. If the model is an ensemble, returns the average over all models. """ - if self.deterministic: + if self._deterministic: return self._mse_loss(model_in, target) else: return self._nll_loss(model_in, target) @@ -334,7 +335,7 @@ def eval_score(self, model_in: torch.Tensor, target: torch.Tensor) -> torch.Tens assert model_in.ndim == 2 and target.ndim == 2 with torch.no_grad(): pred_mean, _ = self.forward(model_in) - if self.is_ensemble: + if self._is_ensemble: target = target.repeat((self.num_members, 1, 1)) return F.mse_loss(pred_mean, target, reduction="none") @@ -344,8 +345,11 @@ def save(self, path: str): def load(self, path: str): self.load_state_dict(torch.load(path)) - def is_deterministic(self): - return self.deterministic + def _is_deterministic_impl(self): + return self._deterministic + + def _is_ensemble_impl(self): + return self._is_ensemble def __len__(self): return self.num_members diff --git a/mbrl/models/model_env.py b/mbrl/models/model_env.py index bb8457f6..acfb9da3 100644 --- a/mbrl/models/model_env.py +++ b/mbrl/models/model_env.py @@ -186,7 +186,7 @@ def evaluate_action_sequences( actions_for_step, num_particles, dim=0 ) _, rewards, _, _ = self.step( - action_batch, sample=not self.dynamics_model.model.is_deterministic() + action_batch, sample=not self.dynamics_model.model.is_deterministic ) total_rewards += rewards diff --git a/tests/core/test_models.py b/tests/core/test_models.py index f72eb3a5..3b716ad2 100644 --- a/tests/core/test_models.py +++ b/tests/core/test_models.py @@ -9,6 +9,35 @@ import mbrl.models +def test_gaussian_mlp_and_basic_ensemble_properties(): + model_in_size = 2 + model_out_size = 2 + for det in [True, False]: + member_cfg = omegaconf.OmegaConf.create( + { + "_target_": "mbrl.models.GaussianMLP", + "device": "cpu", + "in_size": model_in_size, + "out_size": model_out_size, + "deterministic": det, + "ensemble_size": 1, + } + ) + ensemble = mbrl.models.BasicEnsemble( + 2, model_in_size, model_out_size, torch.device("cpu"), member_cfg + ) + + assert ensemble.is_deterministic == det + assert ensemble.is_ensemble + assert not ensemble.members[0].is_ensemble + + member_cfg["ensemble_size"] = 2 + ensemble = mbrl.models.BasicEnsemble( + 1, model_in_size, model_out_size, torch.device("cpu"), member_cfg + ) + assert ensemble.members[0].is_ensemble + + def test_basic_ensemble_gaussian_forward(): model_in_size = 2 model_out_size = 2 @@ -59,7 +88,7 @@ def _create_gaussian_ensemble_mock(ensemble_size, as_float=False): ) # With this we can use the output value to identify which model produced the output - def mock_fwd(_x): + def mock_fwd(_x, only_elite=False): output = _x.clone() if output.shape[0] == 1: output = output.repeat(ensemble_size, 1, 1) From ab4d820770e7a89de317621a7e017f9b0fb83fd7 Mon Sep 17 00:00:00 2001 From: Luis Pineda Date: Mon, 8 Mar 2021 11:57:29 -0500 Subject: [PATCH 2/5] created tests for common utils. So far, added test for create_dynamics_model. --- mbrl/util/common.py | 5 ++- tests/core/test_common_utils.py | 79 +++++++++++++++++++++++++++++++++ 2 files changed, 82 insertions(+), 2 deletions(-) create mode 100644 tests/core/test_common_utils.py diff --git a/mbrl/util/common.py b/mbrl/util/common.py index 446a1bfd..ec094fdd 100644 --- a/mbrl/util/common.py +++ b/mbrl/util/common.py @@ -14,8 +14,8 @@ def create_dynamics_model( cfg: Union[omegaconf.ListConfig, omegaconf.DictConfig], - obs_shape: Tuple[int], - act_shape: Tuple[int], + obs_shape: Tuple[int, ...], + act_shape: Tuple[int, ...], model_dir: Optional[Union[str, pathlib.Path]] = None, ): """Creates a dynamics model from a given configuration. @@ -41,6 +41,7 @@ def create_dynamics_model( -overrides -no_delta_list (list[int], optional): to be passed to the dynamics model wrapper -obs_process_fn (str, optional): a Python function to pre-process observations + -num_elites (int, optional): number of elite members for ensembles If ``cfg.dynamics_model.model.in_size`` is not provided, it will be automatically set to `obs_shape[0] + act_shape[0]`. If ``cfg.dynamics_model.model.out_size`` is not provided, diff --git a/tests/core/test_common_utils.py b/tests/core/test_common_utils.py new file mode 100644 index 00000000..e2e9c713 --- /dev/null +++ b/tests/core/test_common_utils.py @@ -0,0 +1,79 @@ +import omegaconf +import pytest + +import mbrl.models as models +import mbrl.util.common as utils + + +class MockModel(models.Model): + def __init__(self, x, y, in_size, out_size): + super().__init__(in_size, out_size, "cpu") + self.x = x + self.y = y + + def _is_deterministic_impl(self): + return True + + def _is_ensemble_impl(self): + return False + + def load(self, path): + pass + + def save(self, paht): + pass + + def loss(self, model_in, target): + pass + + def eval_score(self, model_in, target): + pass + + +def mock_obs_func(): + pass + + +def test_create_dynamics_model(): + cfg_dict = { + "dynamics_model": { + "model": { + "_target_": "tests.core.test_common_utils.MockModel", + "x": 1, + "y": 2, + } + }, + "algorithm": { + "learned_rewards": "true", + "terget_is_delta": "true", + "normalize": "true", + }, + "overrides": {}, + } + obs_shape = (10,) + act_shape = (1,) + + cfg = omegaconf.OmegaConf.create(cfg_dict) + dynamics_model = utils.create_dynamics_model(cfg, obs_shape, act_shape) + + assert isinstance(dynamics_model.model, MockModel) + assert dynamics_model.model.in_size == obs_shape[0] + act_shape[0] + assert dynamics_model.model.out_size == obs_shape[0] + 1 + assert dynamics_model.model.x == 1 and dynamics_model.model.y == 2 + assert dynamics_model.num_elites is None + assert dynamics_model.no_delta_list == [] + + # Check given input/output sizes, overrides active, and no learned rewards option + cfg.dynamics_model.model.in_size = 11 + cfg.dynamics_model.model.out_size = 7 + cfg.algorithm.learned_rewards = False + cfg.overrides.no_delta_list = [0] + cfg.overrides.num_elites = 8 + cfg.overrides.obs_process_fn = "tests.core.test_common_utils.mock_obs_func" + dynamics_model = utils.create_dynamics_model(cfg, obs_shape, act_shape) + + assert dynamics_model.model.in_size == 11 + assert dynamics_model.model.out_size == 7 + assert dynamics_model.num_elites == 8 + assert dynamics_model.no_delta_list == [0] + assert dynamics_model.obs_process_fn == mock_obs_func From 7a0f3dd994a394bd071dcfbaa94e53727829e95f Mon Sep 17 00:00:00 2001 From: Luis Pineda Date: Mon, 8 Mar 2021 13:13:28 -0500 Subject: [PATCH 3/5] added test for create_replay_buffers --- tests/core/test_common_utils.py | 53 +++++++++++++++++++++++++++++++++ 1 file changed, 53 insertions(+) diff --git a/tests/core/test_common_utils.py b/tests/core/test_common_utils.py index e2e9c713..2d1aff0c 100644 --- a/tests/core/test_common_utils.py +++ b/tests/core/test_common_utils.py @@ -2,6 +2,7 @@ import pytest import mbrl.models as models +import mbrl.replay_buffer as replay_buffer import mbrl.util.common as utils @@ -77,3 +78,55 @@ def test_create_dynamics_model(): assert dynamics_model.num_elites == 8 assert dynamics_model.no_delta_list == [0] assert dynamics_model.obs_process_fn == mock_obs_func + + +def test_create_replay_buffers(): + trial_length = 20 + num_trials = 10 + val_ratio = 0.1 + cfg_dict = { + "dynamics_model": {"model": {"ensemble_size": 1}}, + "algorithm": {}, + "overrides": { + "trial_length": trial_length, + "num_trials": num_trials, + "model_batch_size": 64, + "validation_ratio": val_ratio, + }, + } + cfg = omegaconf.OmegaConf.create(cfg_dict) + obs_shape = (6,) + act_shape = (4,) + + def _check_shapes(train_cap): + val_cap = int(val_ratio * train_cap) + assert train.obs.shape == (train_cap, obs_shape[0]) + assert val.obs.shape == (val_cap, obs_shape[0]) + assert train.next_obs.shape == (train_cap, obs_shape[0]) + assert val.next_obs.shape == (val_cap, obs_shape[0]) + assert train.action.shape == (train_cap, act_shape[0]) + assert val.action.shape == (val_cap, act_shape[0]) + assert train.reward.shape == (train_cap,) + assert val.reward.shape == (val_cap,) + assert train.done.shape == (train_cap,) + assert val.done.shape == (val_cap,) + + # Test reading from the above configuration and no bootstrap replay buffer + train, val = utils.create_replay_buffers( + cfg, obs_shape, act_shape, train_is_bootstrap=False + ) + assert isinstance(train, replay_buffer.IterableReplayBuffer) + assert isinstance(val, replay_buffer.IterableReplayBuffer) + + _check_shapes(num_trials * trial_length) + + # Now add a training bootstrap and override the dataset size + cfg_dict["algorithm"]["dataset_size"] = 1500 + cfg = omegaconf.OmegaConf.create(cfg_dict) + train, val = utils.create_replay_buffers( + cfg, obs_shape, act_shape, train_is_bootstrap=True + ) + assert isinstance(train, replay_buffer.BootstrapReplayBuffer) + assert isinstance(val, replay_buffer.IterableReplayBuffer) + + _check_shapes(1500) From 52c1da4cde9a256e5b3f4e776cf4efacd3c71b8b Mon Sep 17 00:00:00 2001 From: Luis Pineda Date: Mon, 8 Mar 2021 15:24:19 -0500 Subject: [PATCH 4/5] added test for rollout_model_env --- tests/core/test_common_utils.py | 56 +++++++++++++++++++++++++++++++++ 1 file changed, 56 insertions(+) diff --git a/tests/core/test_common_utils.py b/tests/core/test_common_utils.py index 2d1aff0c..e4355fc5 100644 --- a/tests/core/test_common_utils.py +++ b/tests/core/test_common_utils.py @@ -1,3 +1,4 @@ +import numpy as np import omegaconf import pytest @@ -130,3 +131,58 @@ def _check_shapes(train_cap): assert isinstance(val, replay_buffer.IterableReplayBuffer) _check_shapes(1500) + + +class MockModelEnv: + def __init__(self): + self.obs = None + + def reset(self, obs0, propagation_method=None, return_as_np=None): + self.obs = obs0 + return obs0 + + def step(self, action, sample=None): + next_obs = self.obs + action[:, :1] + reward = np.ones(next_obs.shape[0]) + done = np.zeros(next_obs.shape[0]) + self.obs = next_obs + return next_obs, reward, done, {} + + +class MockAgent: + def __init__(self, length): + self.actions = np.ones((length, 1)) + + def plan(self, obs): + return self.actions + + +def test_rollout_model_env(): + obs_size = 10 + plan_length = 20 + num_samples = 5 + model_env = MockModelEnv() + obs0 = np.zeros(obs_size) + agent = MockAgent(plan_length) + plan = 0 * agent.plan(obs0) # this should be ignored + + # Check rolling out with an agent + obs, rewards, actions = utils.rollout_model_env( + model_env, obs0, plan, agent, num_samples=num_samples + ) + + assert obs.shape == (plan_length + 1, num_samples, obs_size) + assert rewards.shape == (plan_length, num_samples) + assert actions.shape == (plan_length, 1) + + for i, o in enumerate(obs): + assert o.min() == i + + # Check rolling out with a given plan + plan = 2 * agent.plan(obs0) + obs, rewards, actions = utils.rollout_model_env( + model_env, obs0, plan, None, num_samples=num_samples + ) + + for i, o in enumerate(obs): + assert o.min() == 2 * i From 3a30b1e45aeec5baaa2bad53eda49eaa860da037 Mon Sep 17 00:00:00 2001 From: Luis Pineda Date: Mon, 8 Mar 2021 16:40:09 -0500 Subject: [PATCH 5/5] updated docs with more information about deterministic models --- docs/models.rst | 10 ++++++++++ notebooks/pets_example.ipynb | 34 ++++++++++++++++++++++++++++------ 2 files changed, 38 insertions(+), 6 deletions(-) diff --git a/docs/models.rst b/docs/models.rst index 1c9cbc19..75842e08 100644 --- a/docs/models.rst +++ b/docs/models.rst @@ -1,5 +1,15 @@ Models module ============= +This module provides implementations of common model architectures used in model-based RL, +including probabilistic and deterministic ensembles. All models in the library derive from +class :class:`mbrl.models.Model`. We provide a generic ensemble implementation, +:class:`mbrl.models.BasicEnsemble`, that can be used to produce epistemic uncertainty estimates +for any subclass of `Model`. For efficiency considerations, some specific model implementations +also provide their own ensemble implementations, without having to rely on BasicEnsemble. +One such model is :class:`mbrl.models.GaussianMLP`, which can be used as a single model or as +an ensemble. Additionally, it can be used as a deterministic model +trained with MSE loss, or a parameterized Gaussian with mean and log variance outputs, trained +with negative log-likelihood. .. automodule:: mbrl.models :members: diff --git a/notebooks/pets_example.ipynb b/notebooks/pets_example.ipynb index 4b8a8fc0..e057c804 100644 --- a/notebooks/pets_example.ipynb +++ b/notebooks/pets_example.ipynb @@ -13,7 +13,7 @@ "1. Gather data using an exploration policy\n", "2. Repeat:
\n", " 2.1. Train the dynamics model using all available data.
\n", - " 2.2. Do a trajectory on the environment, choosing actions using the planner over the dynamics model.\n", + " 2.2. Do a trajectory on the environment, choosing actions with the planner, using the dynamics model to simulate environment transitions.\n", " \n", "The ensemble model is trained to predict the environment's dynamics, and the planner tries to find high-reward trajectories over the model dynamics. \n", "\n", @@ -53,7 +53,7 @@ "source": [ "# Creating the environment\n", "\n", - "First we instantiate the environment and specify which reward function and termination function to use with the gym-like model wrapper, along with some utility objects." + "First we instantiate the environment and specify which reward function and termination function to use with the gym-like model wrapper, along with some utility objects. The termination function tells the wrapper if an observation should cause an episode to end or not, and it is an input used in some algorithms, like [MBPO](https://github.com/JannerM/mbpo/blob/master/mbpo/static/halfcheetah.py). The reward function is used to compute the value of the reward given an observation, and it's used by some algorithms, like [PETS](https://github.com/kchua/handful-of-trials/blob/77fd8802cc30b7683f0227c90527b5414c0df34c/dmbrl/controllers/MPC.py#L65)." ] }, { @@ -91,7 +91,7 @@ "source": [ "# Hydra configuration\n", "\n", - "MBRL-Lib uses [Hydra](https://github.com/facebookresearch/hydra) to manage configurations. For the purpose of this example, you can think of the configuration object as a dictionary with key/value pairs--and equivalent attributes--that specifying the model and algorithmic options. Our toolbox expects the configuration object to be organized as follows:" + "MBRL-Lib uses [Hydra](https://github.com/facebookresearch/hydra) to manage configurations. For the purpose of this example, you can think of the configuration object as a dictionary with key/value pairs--and equivalent attributes--that specify the model and algorithmic options. Our toolbox expects the configuration object to be organized as follows:" ] }, { @@ -101,7 +101,7 @@ "outputs": [], "source": [ "trial_length = 200\n", - "num_trials = 5\n", + "num_trials = 10\n", "device = \"cuda:0\"\n", "\n", "# Everything with \"???\" indicates an option with a missing value.\n", @@ -119,6 +119,7 @@ " \"use_silu\": True,\n", " \"in_size\": \"???\",\n", " \"out_size\": \"???\",\n", + " \"deterministic\": False\n", " }\n", " },\n", " # options for training the dynamics model\n", @@ -138,6 +139,13 @@ "cfg = omegaconf.OmegaConf.create(cfg_dict)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
Note: This example uses a probabilistic ensemble. You can also use a fully deterministic model with class GaussianMLP by setting ensemble_size=1, and deterministic=False.
" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -333,7 +341,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -410,7 +418,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -432,6 +440,20 @@ "plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Where to learn more about MBRL?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To learn about the other features of the library, please check out our [documentation](https://luisenp.github.io/mbrl-lib/). Also take a look at our provided implementations of [PETS](https://github.com/luisenp/mbrl-lib/blob/master/mbrl/algorithms/pets.py) and [MBPO](https://github.com/luisenp/mbrl-lib/blob/master/mbrl/algorithms/mbpo.py), and their configuration [files](https://github.com/luisenp/mbrl-lib/tree/master/conf)." + ] + }, { "cell_type": "code", "execution_count": null,