BISIMULATION METRIC FOR MODEL PREDICTIVE CONTROL

## Abstract

Abstract Model-based reinforcement learning has shown promise for improving sample efficiency and decision-making in complex environments. However, existing methods face challenges in training stability, robustness to noise, and computational efficiency. In this paper, we propose Bisimulation Metric for Model Predictive Control (BS-MPC), a novel approach that incorporates bisimulation metric loss in its objective function to directly optimize the encoder. This time-step-wise direct optimization enables the learned encoder to extract intrinsic information from the original state space while discarding irrelevant details and preventing the gradients and errors from diverging. BS-MPC improves training stability, robustness against input noise, and computational efficiency by reducing training time. We evaluate BS-MPC on both continuous control and image-based tasks from the DeepMind Control Suite, demonstrating superior performance and robustness compared to state-of-the-art baseline methods.
Our code is available through https://github.com/purewater0901/BSMPC .

## 1 Introduction

Reinforcement learning (RL) has become a central framework for solving complex sequential decision-making problems in diverse fields such as robotics, autonomous driving, and game playing. Among RL methods, model-based reinforcement learning (MBRL) gets its attention thanks to its ability to achieve higher sample efficiency and better generalization. Representation learning further enhances MBRL by encoding high-dimensional information into compact latent spaces, which can accelerate learning by focusing on essential aspects of the environment. However, achieving stable and robust representations remains a challenge, especially in high-dimensional or partially observable environments, where noise and irrelevant features can degrade performance.

One prominent MBRL method, Temporal Difference Model Predictive Control (TD-MPC) (Hansen et al., ), combines temporal difference learning with model predictive control to improve policy performance by simulating future trajectories in the learned latent space. TD-MPC sets itself apart from other methods by leveraging the learned latent value function as a long-term reward estimate to approximate cumulative rewards, allowing for the efficient computation of optimal actions.
Despite its successes, TD-MPC suffers from several limitations, including instability during training, vulnerability to noise, and expensive computational costs, which are shown in Fig 1.
The first graph illustrates TD-MPC’s performance degradation during training, demonstrating a notable collapse after a certain number of steps. The second set of results focuses on an image-based task, where the addition of background noise (adding a completely irrelevant image to the background) led to TD-MPC’s failure to achieve a high reward in the noisy environment. The third picture shows that TD-MPC suffers from a long calculation time.
These problems are attributed to the encoder’s training method and the objective function’s structure.

To address these issues, we introduce Bisimulation Metric for Model Predictive Control (BS-MPC), a new approach that leverages $\pi^{*}$-bisimulation metric (on-policy bisimulation metric) (Zhang et al., ) to improve the stability and robustness of latent space representations. Bisimulation metrics measure behavioral equivalence between states by comparing their immediate rewards and next state distributions, providing a formal way to ensure that the learned latent representations retain meaningful and essential information from the original states.
In BS-MPC, we minimize the mean square error between the on-policy bisimulation metric and $\ell_{1}$-distance in latent space at each time step, directly optimizing the encoder to improve stability and noise resistance.
Integration of the bisimulation metric gives BS-MPC a theoretical guarantee, ensuring that the difference in cumulative rewards between the original state space and the learned latent space can be upper-bounded over a trajectory. This value function difference bound validates the fidelity of the encoder projection.
Additionally, the proposed method reduces training time by making the computation of the objective function parallelizable, leading to less computational cost than TD-MPC.
All these performance improvements are also summarized in Fig 1.

We implement BS-MPC using the Model Predictive Path Integral (MPPI) (Williams et al., ; ) framework and evaluate its performance on a variety of continuous control tasks from DeepMind Control Suite (Tassa et al., ). Our results show that BS-MPC outperforms existing model-free and model-based methods in terms of performance and robustness, making it a promising new approach for model-based reinforcement learning.

Figure: Figure 1: Three open problems of TD-MPC. (Left) TD-MPC initially performs well but collapses after 4 million steps, while BS-MPC steadily improves. (Middle) With added distraction in the input image, TD-MPC fails to gain rewards, whereas BS-MPC remains robust. (Right) BS-MPC reduces training time by removing sequential computation in objective function.
Refer to caption: extracted/5905356/figures/tdmpc_open_problems.png

## 2 Related Work

#### Reinforcement Learning

Reinforcement Learning (RL) (Sutton & Barto, ) has two main approaches: model-free methods (Silver et al., ; Fujimoto et al., ; Haarnoja et al., ; Schulman et al., ; ; Kalashnkov et al., ; Kalashnikov et al., ; Mnih et al., ; Hessel et al., ; Yarats et al., ; ; Laskin et al., ) and model-based methods (Sutton, ; Hafner et al., ; ; ; Luo et al., ; Janner et al., ; Chua et al., ; Schrittwieser et al., ; Wang & Ba, ).
While model-free methods focus on learning the value function and policy, model-based methods aim to learn the underlying model of the environment, using this learned model to compute optimal actions.
This paper focuses on the model-based approach, specifically methods that combine planning and MBRL (Hansen et al., ; ), which learns the underlying model in the latent space and applies sampling-based Model Predictive Control (MPC) (Williams et al., ; Kobilarov, ) to solve the trajectory optimization problem. Several variants of TD-MPC have been proposed (Lancaster et al., ; Zhao et al., ; Chitnis et al., ; Feng et al., ; Wan et al., ), but none fully address all the challenges outlined in Fig. 1.
To the best of our knowledge, BS-MPC is the first approach to tackle all three open problems in TD-MPC, as discussed in Section 1.

#### Representation Learning

Learning models in the latent space is an efficient way to approximate internal models, especially for image-based tasks. One approach to learning latent space projections is by training both the encoder and decoder to minimize the reconstruction loss (Lange & Riedmiller, ; Lange et al., ; Hafner et al., ; ; Lee et al., ). However, this method often suffers model errors and instability and has difficulties in long-term predictions. An alternative approach is to train only the encoder to obtain the latent representation. Bisimulation (Larsen & Skou, ) is a state abstraction technique defined in Markov Decision Processes (MDPs) that clusters states producing identical reward sequences for any given action sequence.
Ferns et al. (); Ferns & Precup () defined a bisimulation metric that measures the similarity between two states based on the Wasserstein distance between their empirically measured transition distributions. However, computing this metric can be computationally expensive in high-dimensional spaces. To address this, Castro () proposed an on-policy bisimulation metric, which considers the distribution of future states under the current policy, providing a scalable way to measure state similarity. Zhang et al. () extend this idea to $\pi^{*}$-bisimulation metric by minimizing
MSE loss between bisimulation metric and $\ell_{1}$-distance in latent space to train the encoder. Following this approach, we use the on-policy bisimulation metric to train the encoder in model-based reinforcement learning architecture.

## 3 Preliminaries

This section provides a brief introduction to reinforcement learning and its associated notations, along with an explanation of bisimulation concepts.

### 3.1 Reinforcement Learning

Reinforcement Learning (RL) aims to optimize agents that interact with a Markov Decision Process (MDP) defined by a tuple $({\mathcal{S}},{\mathcal{A}},\mathcal{P},{\mathcal{R}},\rho_{0},\gamma)$, where ${\mathcal{S}}$ represents the set of all possible states, ${\mathcal{A}}$ is the set of possible actions, ${\mathcal{R}}$ is a reward function, $\rho_{0}$ is the initial state distribution, and $\gamma$ is the discount factor. When action $a\in{\mathcal{A}}$ is executed at state $s\in{\mathcal{S}}$, the next state is generated according to $s^{\prime}\sim\mathcal{P}(\cdot|s,a)$, and the agent receives stochastic reward with mean $r(s,a)\in\mathbb{R}$.

The Q-function $Q^{\pi}(s,a)$ for a policy $\pi(\cdot|s)$ represents the discounted long-term reward attained by executing $a$ given observation history $s$ and then following policy $\pi$ thereafter.
$Q^{\pi}$ satisfies the Bellman recurrence:
$Q^{\pi}(s,a)=\mathbb{B}^{\pi}Q^{\pi}(s,a)=r(s,a)+\gamma\mathbb{E}_{s^{\prime}
\sim P(\cdot|s,a),a^{\prime}\sim\pi(\cdot|s^{\prime})}\left[Q_{h+1}(s^{\prime}
,a^{\prime})\right]\,.$
The value function $V^{\pi}$ considers the expectation of the Q-function over the policy $V^{\pi}(h)=\mathbb{E}_{a\sim\pi(\cdot|s)}\left[Q^{\pi}(s,a)\right]$. Meanwhile, the Q-function of the optimal policy $Q^{*}$ satisfies: $Q^{*}(s,a)=r(s,a)+\gamma\mathbb{E}_{s^{\prime}\sim P(\cdot|s,a)}\left[\max_{a^
{\prime}}Q^{*}(s^{\prime},a^{\prime})\right]$, and the optimal value function is $V^{*}(s)=\max_{a}Q^{*}(s,a)$. Finally, the expected cumulative reward is given by $J(\pi)=\mathbb{E}_{s_{1}\sim\rho_{1}}\left[V^{\pi}(s_{1})\right]$.
The goal of RL is to optimize a policy $\pi(\cdot\mid s)$ that maximizes the cumulative reward
$\pi^{*}(\cdot\mid s)=\underset{\pi}{\operatorname{argmax}}\;J(\pi)$.

In large-scale or continuous environments, solving reinforcement learning (RL) problems can be challenging due to the prohibitively high computational cost. To address this issue, function approximation is often employed to estimate value functions and policies.
With function approximation, we present $Q^{\pi},\pi$ as $Q_{\theta^{Q}},\pi_{\psi}$, with $\theta^{Q}$ and $\psi$ as their parameters. With a replay buffer $\mathcal{{\mathcal{B}}}$, the policy evaluation and improvement steps at iteration $k$ can be expressed as:

$$ $\begin{split}\theta^{Q}_{k+1}\leftarrow&\underset{\theta^{Q}}{\operatorname{ argmin}}\;\mathbb{E}_{(s,a,r,s^{\prime})\sim\mathcal{{\mathcal{B}}}}\left[ \left(Q_{\theta^{Q}}(s,a)-{\mathcal{R}}(s,a)-\gamma\mathbb{E}_{a^{\prime}\sim \pi_{\theta^{\pi}_{k}}(\cdot|s)}[Q_{\bar{\theta}^{Q}_{k}}(s,a^{\prime})]\right )^{2}\right]\\ \psi_{k+1}\leftarrow&\underset{\psi}{\operatorname{argmax}}\;\mathbb{E}_{s\sim \mathcal{{\mathcal{B}}},a\sim\pi_{\psi}(\cdot|s)}\left[Q_{\theta^{Q}_{k+1}}(s, a)\right]\,,\end{split}$ (1) $$

where $\bar{\theta}^{Q}_{k}$ are target parameters that are a slow-moving copy of $\theta^{Q}_{k}$. Note that in this paper, we denote $\bar{\bullet}$ as target parameters in this paper.

### 3.2 Bisimulation Metric

When working with high-dimensional state problems, it is often helpful to group ”similar” states into the same set. Bisimulation is a type of state abstraction that groups state $s_{i}$ and $s_{j}$ if they are ”behaviorally equivalent” (Li et al., ). A more concise definition states that two states are bisimilar if they yield the same immediate rewards and have equivalent distributions over future bisimilar states(Larsen & Skou, ; Givan et al., ). Bisimulation metric quantifies the bisimilarity of two states $s_{i}$ and $s_{j}$. It is defined with $p$-th Wasserstein metric $W_{p}(\mathcal{P}_{1},\mathcal{P}_{2})$, which represents the distance between two probability distribution $\mathcal{P}_{1}$ and $\mathcal{P}_{2}$:

###### Definition 1 .

(Bisimulation metric (Ferns et al., )). The following metric exists and is unique, given $R:S\times A\rightarrow[0,1]$ and $c\in(0,1)$ for continuous MDPs:

$$ $d(s_{i},s_{j})=\max_{a\in\mathcal{A}}(1-c)|{\mathcal{R}}(s_{i},a)-{\mathcal{R} }(s_{j},a)|+cW_{1}(\mathcal{P}(\cdot|s_{i},a),\mathcal{P}(\cdot|s_{j},a)).$ (2) $$

In high-dimensional and continuous environments, analytically computing the max operation in Eq. 2 is challenging. In response to this difficulty, Castro () proposed a new approach, known as the on-policy bisimulation metric (or $\pi$-bisimulation).

###### Definition 2 .

(On-Policy bisimulation metric (Castro, )). Given a fixed policy $\pi$, the following bisimulation metric uniquely exists

$$ $d(s_{i},s_{j})=|r_{s_{i}}^{\pi}-r_{s_{j}}^{\pi}|+\gamma W_{1}(\mathcal{P}^{\pi }(\cdot|s_{i}),\mathcal{P}^{\pi}(\cdot|s_{j})).$ (3) $$

where

$$ $r_{s}^{\pi}=\sum_{a}\pi(a|s){\mathcal{R}}(s,a),\quad\mathcal{P}^{\pi}(\cdot|s) =\sum_{a}\pi(a|s)\sum_{s^{\prime}\in S}\mathcal{P}(s^{\prime}|s,a)$ (4) $$

Recently, (Zhang et al., ) extended the concept of the on-policy bisimulation metric (referred to as the $\pi^{*}$-bisimulation metric) to learn a comparable metric in the latent space ${\mathcal{Z}}$. In their approach, the encoder $\phi$ is learned by minimizing the mean square error between the on-policy bisimulation metric and $\ell_{1}$-distance in the latent space.

$$ $J(\phi)=\left(\|\phi(s_{i})-\phi(s_{j})\|_{1}-|r_{s_{i}}^{\pi}-r_{s_{j}}^{\pi} |-\gamma W_{2}\left(\hat{\mathcal{P}}(\cdot|\bar{\phi}(s_{i}),a_{i}),\hat{ \mathcal{P}}(\cdot|\bar{\phi}(s_{j}),a_{j})\right)\right)^{2}$ (5) $$

where the latent dynamics model $\hat{\mathcal{P}}$ is modeled with a Gaussian distribution. In Eq. 5, 2-Wasserstein metric $W_{2}$ is used because it has a convenient closed form for Gaussian distribution.
Following this approach, we train our encoder similarly by including this MSE loss (Eq. 5) in our objective function.

###### Definition 1 .

###### Definition 2 .

## 4 Bisimulation metric for model predictive control

We introduce Bisimulation Metric Model Predictive Control (BS-MPC), a robust and efficient model-based reinforcement learning algorithm. This section provides a detailed explanation of the BS-MPC algorithm. Furthermore, we present a theoretical analysis that bounds the suboptimality of cumulative rewards in the learned latent space under our architecture. Finally, we highlight three key distinctions between BS-MPC and TD-MPC that contribute to their performance differences.

### 4.1 Bisimulation Metric for Model Predictive Control

We introduce BS-MPC, an improvement over TD-MPC that employs $\pi^{*}$-bisimulation metrics to train the encoder. The training flow for BS-MPC is detailed in Appendix C.

#### Components

BS-MPC shares the same five core components as TD-MPC: encoder, latent dynamics, reward, state-action value and policy.

$$ $\begin{split}\textbf{Encoder:}&\quad z_{k}=h_{\theta^{h}}(s_{k})\qquad\hskip 2 1.33955pt\textbf{Latent dynamics:}\quad z_{k+1}=d_{\theta^{d}}(z_{k},a_{k})\\ \textbf{Reward:}&\quad\hat{r}_{k}={\mathcal{R}}_{\theta^{R}}(z_{k},a_{k}) \qquad\textbf{State-action value:}\quad\hat{Q}_{k}=Q_{\theta^{Q}}(z_{k},a_{k}) \\ \textbf{Policy:}&\quad\hat{a}_{k}\sim\pi_{\psi}(z_{k})\end{split}$ (6) $$

When the input $s_{k}$ is a state vector, the encoder is modeled as a multi-layer perceptron (MLP) and as a convolutional neural network (CNN) when $s_{k}$ is an image.
Given the latent state $z_{k}$ and action $a_{k}$, we compute the next latent state $z_{k+1}$ using the latent dynamics model $d_{\theta^{d}}(z_{k},a_{k})$, parameterized by $\theta^{d}$.
In BS-MPC, the latent dynamics are modeled using an MLP.
We also model the latent dynamics model with an MLP. BS-MPC estimates the reward $\hat{r}_{k}$ and state-action value $\hat{Q}_{k}$ based on $z_{k}$ and $a_{k}$, modeling both ${\mathcal{R}}_{\theta^{\mathcal{R}}}$ and $Q_{\theta^{Q}}$ with MLPs. Finally, we train a policy that outputs the estimated optimal action $\hat{a}_{k}$ given $z_{k}$; the policy is also parameterized as an MLP.

At each time step $k$, the original observation $s_{k}$ is encoded into the latent state $z_{k}$. Using $z_{k}$ and the action $a_{k}$, we compute the rewards, state-action values, and the next latent state. As highlighted in prior work, these values are computed in the latent space rather than the original observation space, as the latent state $z_{k}$ captures the essential information from the high-dimensional original state. Since the latent space typically has more compact dimensions, this approach is commonly used in image-based tasks where input images are high-dimensional. However, state-based tasks, despite being represented more compactly, also benefit from this structure by utilizing latent states learned through temporal consistency (Zhao et al., ).

#### Objective function

We jointly train the encoder, latent dynamics model, reward model, and state-action value model. BS-MPC minimizes the following loss function:

$$ $\theta^{*}=\arg\min_{\theta}{\mathcal{L}}(\theta)=\arg\min_{\theta}\;\mathbb{E }_{(s,a,r,s^{\prime})\sim\mathcal{{\mathcal{B}}}}\left[\sum_{k=0}^{H}\lambda^{ k}{\mathcal{L}}_{k}(\theta)\right]$ (7) $$

where $\theta=[\theta^{\mathcal{R}},\theta^{Q},\theta^{d},\theta^{h}]$. This objective function is identical to the one proposed in TD-MPC.
However, BS-MPC has an additional bisimulation metric loss term at every time step, as shown in Eq. 5.

$$ $\begin{split}&{\mathcal{L}}_{k}(\theta)=c_{1}\underbrace{||{\mathcal{R}}_{ \theta^{\mathcal{R}}}(z_{k},a_{k})-r_{k}||^{2}_{2}}_{\text{(A) reward loss}}+c _{2}\underbrace{\left\|Q_{\theta^{Q}}(z_{k},a_{k})-\left(r_{k}+\gamma Q_{\bar{ \theta}^{Q}}(z_{k+1},\pi_{\theta^{\pi}}(z_{k+1}))\right)\right\|_{2}^{2}}_{ \text{(B) state-action value loss}}\\ &+c_{3}\underbrace{\left\|d_{\theta^{d}}(z_{k},a_{k})-h_{\bar{\theta}^{h}}(s_{ k+1})\right\|_{2}^{2}}_{\text{(C) consistency loss}}+c_{4}\underbrace{\left(\| h_{\theta^{h}}(s_{k})-h_{\theta^{h}}(\acute{s}_{k})\|_{1}-|r_{k}-\acute{r}_{k} |-\gamma||\bar{z}_{k+1}-\bar{\acute{z}}_{k+1}||_{2}^{2}\right)^{2}}_{\text{(D) bisimulation metric loss}}\end{split}$ (8) $$

where $\acute{\bullet}_{k}=\mathrm{permute}(\bullet_{k})$ and $\bar{z}_{k+1}=d_{\bar{\theta}^{d}}(z_{k},a_{k})$. $c_{1},c_{2},c_{3},c_{4}$ are parameters that can change the weight of each loss.
The last term is an expansion of Eq. 5, under the assumption that the model outputs deterministic predictions, corresponding to a Dirac delta distribution (i.e., a Gaussian distribution with zero variance).
As in TD-MPC, we use the same three loss components: (A) reward loss, (B) state-value action loss, and (C) consistency loss. Each training loss aims to update its corresponding parameters, i.e. reward parameter $\theta^{{\mathcal{R}}}$, state-action value parameter $\theta^{Q}$, and dynamics parameter $\theta^{d}$. These losses also help to update the encoder parameter $\theta^{h}$ by using the derivative of the composition function. In addition to these losses, BS-MPC includes a bisimulation metric loss in its objective function, which explicitly depends on the encoder parameters $\theta^{h}$. This bisimulation metric loss (D) is designed to train the encoder to learn a representation space where the $\ell_{1}$-distance corresponds to the $\pi^{*}$-bisimulation metric.

For policy training, we use the following loss function to update the policy parameter $\psi$.

$$ $\psi^{*}=\arg\min_{\psi}{\mathcal{J}}_{\pi}(\psi)=\arg\min_{\psi}\;-\sum_{k=0} ^{H}\lambda^{k}Q_{\theta^{Q}}\left(z_{k},\pi_{\psi}(\bar{z}_{k})\right)$ (9) $$

In Section. 4.3, we give details about the benefit of using Eq. 8 as the objective function for BS-MPC and the differences between our approach and TD-MPC.

#### Model Predictive Control with Learned Model

Following TD-MPC, our method has a closed-loop controller using the learned latent dynamics model, reward model, state-value function, and prior policy to compute the optimal action.
Due to the high affinity between reinforcement learning and sampling-based planners, we design a closed-loop controller using MPPI, a type of sampling-based MPC, following the approach of TD-MPC. MPPI is a derivative-free method that samples a large number of trajectories, calculates the weight for each, and then generates the optimal trajectory by taking the weighted average of these trajectories. This framework enables us to solve the local trajectory optimization problem.

First, it encodes the current observed state $s_{t}$ into the latent space with the trained encoder $z_{t}=h_{\theta^{h}}(s_{t})$.
After that, we sample $M$ action sets from Gaussian distribution ${\mathcal{N}}(\mu^{0},\sigma^{0})$ based on the initial mean$\mu^{0}$ and standard deviation $\sigma^{0}$, and each set contains $H$ length actions $a^{j}_{t:t+H}$ where $j\in M$.
Starting from the initial latent state $z_{t}$, we use the learned latent dynamics $z_{t+1}=d_{\theta^{d}}(z_{t},a_{t})$ and sample $M$ trajectories.
We then calculate the weight of each trajectory based on its cost and compute the weighted mean of the sampled trajectories to get the updated optimal trajectory.
The parameter $\mu_{k}$ and $\sigma_{k}$ is updated by maximizing the following equations:

$$ $\mu^{k+1},\sigma^{k+1}=\arg\max_{(\mu,\sigma)}\mathbb{E}_{(a_{t},a_{t+1},\dots ,a_{t+H})\sim\mathcal{N}(\mu,\sigma^{2})}\left[\gamma^{H}V(z_{t+H})+\sum_{h=t} ^{H-1}\gamma^{h}R_{\theta^{R}}(z_{h},a_{h})\right]$ (10) $$

where $V(z_{t+H})=Q_{\theta^{Q}}\left(z_{t+H},\pi_{\psi}(z_{t+h})\right)$.
We continue this calculation until it reaches the given number of iterations. More details can be found in (Hansen et al., ; Williams et al., ; ).

### 4.2 Theoretical Analysis

It is important to measure the quality of the learned representation space.
In this section, we show that BS-MPC upper-bounds expected cumulative reward by leveraging value function bounds derived from the on-policy bisimulation metric. This property, absent in TD-MPC, strongly differentiates BS-MPC.

We assume that the learned policy in BS-MPC continuously improves throughout training and eventually converges to the optimal policy $\pi^{*}$, which supports Theorem 1.

###### Theorem 1 .

(Theorem 1 in (Zhang et al., ))
Let’s assume a policy $\pi$ in BS-MPC continuously improves over time, converging to the optimal policy $\pi^{*}$. Under this assumption, the following bisimulation metric has a least fixed point $\tilde{d}$ and that is a $\pi^{*}$-bisimulation metric.

$$ $d(s_{i},s_{j})=(1-c)|r_{s_{i}}^{\pi}-r_{s_{j}}^{\pi}|+cW_{p}(d)(\mathcal{P}^{ \pi}(\cdot|s_{i}),\mathcal{P}^{\pi}(\cdot|s_{j})).$ (11) $$

where $W_{p}(d)(\mathcal{P}_{i},\mathcal{P}_{j})=\left(\inf_{\gamma^{\prime}\in\Gamma
(\mathcal{P}_{i},\mathcal{P}_{j})}\int_{\mathcal{S}\times\mathcal{S}}d(s_{i},s
_{j})^{p}\,d\gamma^{\prime}(s_{i},s_{j})\right)^{1/p}$ and $\Gamma(\mathcal{P}_{i},\mathcal{P}_{j})$ is the set of all couplings of ${\mathcal{P}}_{i}$ and ${\mathcal{P}}_{j}$.

Proof can be found in (Zhang et al., ).
Under this $\pi^{*}$-bisimulation metric, we can divide the latent space into $n$ partitions based on some $\epsilon>0$, where $\frac{1}{n}<(1-c)\epsilon$. Let $\phi$ represent the encoder that maps each original state from the state space $\mathcal{S}$ to a corresponding $\epsilon$-cluster.
With these notations, (Zhang et al., ) shows the following value bound based on bisimulation metrics.

###### Theorem 2 .

(Theorem 2 in (Zhang et al., ))
Consider an MDP $\bar{\mathcal{M}}$, which is formed by clustering states within an $\epsilon$-neighborhood, along with an encoder $\phi$ that maps states from the original MDP $\mathcal{M}$ to these clusters. Under the same assumption in Theorem 1, optimal value functions for the two MDPs are bounded by

$$ $|V^{*}(s)-V^{*}(\phi(s))|\leq\frac{2\epsilon+2{\mathcal{L}}}{(1-\gamma)(1-c)}$ (12) $$

where $\mathcal{L}:=\sup_{s_{i},s_{j}\in\mathcal{S}}|\left\|\phi(s_{i})-\phi(s_{j})
\right\|-\tilde{d}(s_{i},s_{j})|$ is the learning error for encoder $\phi$.
Note that this theorem assumes access to the true dynamics model ${\mathcal{P}}$ and reward function ${\mathcal{R}}$.

Proof can also be found in (Zhang et al., ). This result demonstrates that the optimal value function in the original state space and the optimal value function in the latent space, projected by the $\pi^{*}$-bisimulation metric, is bounded from above.
Leveraging Theorem 1 and Theorem 2, we can bound the cumulative reward of a trajectory under the original MDP $\mathcal{M}$ and the latent MDP $\bar{\mathcal{M}}$.

###### Theorem 3 .

Consider a trajectory $\tau=(s_{0},a_{0},s_{1},a_{1},\dots,s_{H-1},a_{H-1},s_{H})$ in the original state space $\mathcal{S}$, and its corresponding encoded trajectory $\phi(\tau)=(z_{0},a_{0},z_{1},a_{1},\dots,z_{H-1},a_{H-1},z_{H})$, where $a_{k}\sim\pi^{*}(\cdot\mid s_{k})$ and $z_{k}=\phi(s_{k})$, with $\phi$ defined as in Theorem 2. Under the same assumption as in Theorem 1 and Theorem 2, the following expected cumulative rewards

$$ $\displaystyle\mathbf{S}(\tau)$ $\displaystyle=\mathbb{E}_{\tau}\left[\gamma^{H}V^{*}(s_{H})+\sum_{h=0}^{H-1} \gamma^{h}R(s_{h},a_{h})\right],$ $\displaystyle\mathbf{S}(\phi(\tau))$ $\displaystyle=\mathbb{E}_{\tau}\left[\gamma^{H}V^{*}(\phi(s_{H}))+\sum_{h=0}^{ H-1}\gamma^{h}R(\phi(s_{h}),a_{h})\right]$ $$

can be bounded as follows:

$$ $\left|\mathbf{S}(\tau)-\mathbf{S}(\phi(\tau))\right|\leq\frac{2\gamma^{H}( \epsilon+\mathcal{L})}{(1-\gamma)(1-c)}+\frac{2\epsilon(1-\gamma^{H})}{(1- \gamma)(1-c)}.$ (13) $$

Proof can be found in Appendix A. This theorem states that if the cluster radius $\epsilon$ and the encoder error $\mathcal{L}$ are sufficiently small, the learned representation space $\mathcal{Z}$ does not change the original cumulative rewards over the same trajectory $\tau$. This suggests that the latent space retains essential information from the original space.

###### Theorem 1 .

###### Theorem 2 .

###### Theorem 3 .

### 4.3 Difference between BS-MPC and TD-MPC

The main difference between BS-MPC and TD-MPC lies in its objective function and computation flow. Specifically, BS-MPC updates the encoder parameter by minimizing MSE loss between on-policy bisimulation metric and $\ell_{1}$-distance in the latent space at every time step $k$, which is shown in Eq. 7. These differences result in the following improvements.

#### Improved training stability

In TD-MPC, the encoder is only updated indirectly through gradients propagated from the latent dynamics loss, as the objective function lacks explicit encoder loss term and only consists of the first three terms in Eq. 8. This indirect update makes it challenging to effectively optimize the encoder parameters at each training step, potentially leading to significant inconsistencies in the latent dynamics and destabilizing the learning process. Such model inconsistencies have also been reported in Zhao et al. ().
In contrast, BS-MPC has an explicit encoder loss in its objective function thanks to the inclusion of bisimulation metric loss. This allows the gradients of the encoder parameters to be directly computed from the objective function, ensuring continuous improvement of the encoder. As a result, the learned encoder effectively maps the original state $s$ to the latent space $z$, leading to reduced model discrepancies. The encoder update difference is shown in Fig. 2 and Fig. 2.

#### Theoretical support of the latent space

The encoder in BS-MPC generates a latent representation $\mathcal{Z}$ where the $\ell_{1}$-distance corresponds to the bisimulation metric. This indicates that the encoder efficiently filters out irrelevant information from the original state $s$ and preserves intrinsic details in the latent state $z$. Consequently, BS-MPC exhibits robust resilience to noise. Additionally, this property guarantees that the cumulative reward difference between the learned representation space and the original space over a trajectory is upper-bounded, as discussed in Section 4.2. In contrast, the encoder in TD-MPC lacks theoretical guarantees in its learned representation space, potentially leading to the projection of irrelevant details into the latent space. This absence of theoretical validity in the encoder contributes to increased sensitivity to noise, as shown in our experimental results (Section. 5.3).

#### Ease of parallelization

TD-MPC predicts the latent state $\hat{z}_{k+1}$ by applying the dynamics model to the previous predicted latent state $\hat{z}_{k}$, introducing a sequential dependency that hinders parallel computation (see Lines 12 to 17 of Algorithm 2 in Hansen et al. ()). In contrast, BS-MPC generates the predicted latent state $\hat{z}_{k+1}$ by encoding the current state into the latent state $z_{k}=h_{\theta^{h}}(s_{k})$ and using it as input to the dynamics model, which removes the sequential dependency and allows for parallel computation across time steps. Fig. 2 and Fig. 2 show the calculation flow difference between TD-MPC and BS-MPC. Consequently, BS-MPC achieves faster computational times compared to TD-MPC.

Figure: (a) TD-MPC calculation flow
Refer to caption: extracted/5905356/figures/tdmpc_gradient_flow.png

## 5 Experiments

We evaluate BS-MPC across various continuous control tasks using the DeepMind Control Suite (DM Control (Tassa et al., )). The inputs in these experiments include both high-dimensional state vectors and images, with some tasks set in sparse-reward environments. The objective of this section is to demonstrate that BS-MPC maintains its performance over time and remains robust to noise. Additionally, we aim to confirm that it outperforms TD-MPC in terms of computational efficiency.
In this experiment, we focus specifically on comparing BS-MPC with TD-MPC. For a fair comparison, BS-MPC uses the same model architecture as TD-MPC, with an identical number of parameters and tuning parameters set to the same values. We also run BS-MPC and TD-MPC using the same random seeds. The only difference between BS-MPC and TD-MPC is explicit encoder loss in the objective function with an additional parameter $c_{4}$. We adopt the same environmental settings as those used in the original TD-MPC paper (Hansen et al., ). Detailed experimental configurations are provided in Appendix E.

For the baselines, we use the model-free RL algorithm SAC (Haarnoja et al., ; ; ), the model-based RL algorithm Dreamer-v3 (Hafner et al., ), and the planning-based model-based RL approach TD-MPC Hansen et al. (), evaluating them on both state-based and image-based tasks. In addition to these algorithms, we also compare BS-MPC with DrQ-v2 (Yarats et al., ) and CURL (Laskin et al., ) on image-based tasks. For a more strong baseline comparison, we compare BS-MPC with TD-MPC2 (Hansen et al., ) in Appendix D. We publicly release the value of episode return at each time step and code for training BS-MPC agents.

### 5.1 Result on state-based tasks

We evaluate BS-MPC across 26 diverse continuous control tasks with state inputs, comparing its performance to other baseline methods. In this setting, agents have direct access to all internal states of the environment.

Fig. 3 shows the average performance of each algorithm across 10 tasks, along with the individual scores from 9 specific tasks.
We ran 10 million time steps for the dog experiment and 8 million time steps for the humanoid experiment.
For the other tasks, the experiments were run for 4 million time steps. The results demonstrate that BS-MPC consistently outperforms existing model-based and model-free reinforcement learning methods, particularly in high-dimensional environments.
On complex tasks involving dog and humanoid environments, BS-MPC significantly outperforms TD-MPC, SAC, and Dreamer-v3. In particular, BS-MPC achieves higher episode returns early in training and maintains superior performance throughout, whereas the other methods either plateau or display instability.
TD-MPC performs well in the early stages of training, achieving competitive results up to approximately 1 million steps. However, in many tasks, its performance suddenly collapses after this point, leading to high variance and reduced episode returns. It is important to note that BS-MPC and TD-MPC share the exact same model architecture, hyperparameters, and number of parameters. The only difference between them lies in the cost function: BS-MPC explicitly minimizes the bisimulation metric loss at every time step to train the encoder, whereas TD-MPC only calculates the encoder loss at the initial time step.
Appendix. B shows all the results from 26 continuous control tasks, computation time comparison, and detailed analysis of the training failure of TD-MPC.

Figure: Figure 3: Performance comparison on the average over 26 state-based tasks and 9 DM Control tasks with state input. At each evaluation step, the episode return is computed over 10 episodes. The results are averaged over 3 seeds, with shaded regions representing the standard deviation. Results for SAC and Dreamer-v3 are obtained from (Hansen et al., ), and results for TD-MPC are reproduced using their official code with the same architecture and hyperparameters for BS-MPC. We use the same seeds for evaluation.
Refer to caption: extracted/5905356/figures/main_state_result.png

### 5.2 Results on image-based tasks

Next, we evaluate BS-MPC and other baseline methods on image-based tasks from 10 DM Control environments. In these tasks, the encoders of both BS-MPC and TD-MPC are modeled by CNN to project high-dimensional image data into a compact latent space. To ensure a fair comparison, we use the same model architecture, hyperparameters, and number of parameters for both BS-MPC and TD-MPC, and we use identical seeds for evaluation. We run 3 million environmental steps for all tasks.
Fig. 4 shows the results across 10 image-based tasks. BS-MPC demonstrates performance competitive with TD-MPC, DrQ-v2 and Dreamer-v3, consistently outperforming CURL and SAC.

Figure: Figure 4: Performance comparison on 10 DM Control image-based tasks. At each evaluation step, the episode return is computed over 10 episodes. The results are averaged over 3 seeds, with shaded regions representing the standard deviation. Results for DrQ-v2 are obtained from their official results, and results for CURL, SAC and Dreamer-v3 are obtained from Dreamer-v3 code (Hafner et al., ).
Refer to caption: extracted/5905356/figures/main_image_result.png

### 5.3 Resutls on Image input with distractions

Finally, we evaluate the robustness of the proposed method in the presence of distracting information. The goal of this experiment is to show that BS-MPC has better resilience against irrelevant data in the input. We benchmark BS-MPC on 5 DM Control tasks by introducing irrelevant information into the input as noise. Following (Zhang et al., ; ), driving videos from the Kinetics dataset (Kay et al., ) are used as background for the original images. In this experiment, the same parameters and architecture as in Section 5.2 are employed, and the performance of BS-MPC is compared to that of TD-MPC.

Figure 5 shows the experimental results, which reveal that BS-MPC constantly outperforms TD-MPC in every environment. Since TD-MPC does not have an explicit objective function for its encoder, its encoder simply learns representation space to keep the latent dynamics consistent. Therefore, its encoder struggles to filter out the noise during training.
BS-MPC, however, learns its encoder by minimizing the bisimulation metric loss to retain bisimulation information in the learned representation space. This architectural modification enhances performance and increases robustness to noise compared to TD-MPC.

Figure: Figure 5: Performance comparison on 5 DM Control image-based tasks with distracted information from Kinetics dataset. At each evaluation step, the episode return is computed over 10 episodes. The results are averaged over 5 seeds, with shaded regions representing the standard deviation. (Top) Original Image. (Middle) Distracted Image. (Bottom) Performance results. BS-MPC constantly outperforms TD-MPC when the input is disturbed.
Refer to caption: extracted/5905356/figures/distractor_result.png

## 6 Conclusion

In this paper, we propose a novel model-based reinforcement learning method called Bisimulation Metric for Model Predictive Control (BS-MPC). While inheriting several properties from TD-MPC, our approach differentiates it from the previous method in three key areas: inclusion of explicit encoder loss term, adaptation of bisimulation metric, and parallelizing the computational flow. These improvements stabilize the learning process and enhance the model’s robustness to noise while reducing the training time. Experimental results on continuous control tasks from DM Control demonstrate that BS-MPC has superior stability and robustness, whereas TD-MPC and other baselines fail to achieve comparable performance.

#### Limitations.

Despite the theoretical foundations and experimental results supporting BS-MPC, it has one notable limitation: the need for extensive parameter tuning of $c_{4}$ across different environments. In this paper, we employ a grid search to identify the optimal parameter values; however, future research should focus on developing methods for automatic parameter adjustment.

## Appendix A Proof of Theorem 3

Our proof uses the following Lemma.

###### Lemma 1 .

Assume action $a$ is sampled from optimal policy $a\sim\pi^{*}(\cdot|s)$.
With the same assumption in Theorem 2, the difference between $R(s,a)$ and $R(\phi(s),a)$ under the $\pi^{*}$-bisimulation metric has the following upper bound.

$$ $(1-c)|R(s,a)-R(\phi(s),a)|\leq 2\epsilon$ (14) $$

###### Proof.

From Theorem 1, the fixed point $\tilde{d}$ satisfies

$$ $\tilde{d}(s,\phi(s))=(1-c)|R(s,a)-R(\phi(s),a)|+cW_{p}(d)(\mathcal{P}^{\pi^{*} }(\cdot|s_{i}),\mathcal{P}^{\pi^{*}}(\cdot|s_{j})).$ (15) $$

Since the second term is always positive, we can get

$$ $\begin{split}(1-c)|R(s,a)-R(\phi(s),a)|&\leq\tilde{d}(s,\phi(s))\\ &\leq 2\epsilon\end{split}$ (16) $$

∎

###### Theorem 3 .

Consider a trajectory $\tau=(s_{0},a_{0},s_{1},a_{1},\dots,a_{H-1},s_{H})$ in the original state space ${\mathcal{S}}$, and its corresponding encoded trajectory $\phi(\tau)=(z_{0},a_{0},z_{1},a_{1},\dots,a_{H-1},z_{H})$, where $a_{k}\sim\pi^{*}(\cdot|s_{k})$ and $z_{k}=\phi(s_{k})$, with $\phi$ defined in Theorem 2.
Under the assumption that both the reward model and dynamics model have no approximation error, the cumulative rewards $\mathbf{S}(\tau)=\mathbb{E}_{\tau}\left[\gamma^{H}V^{*}(s_{H})+\sum_{h=0}^{H-1
}\gamma^{h}R(s_{h},a_{h})\right]$ and $\mathbf{S}(\phi(\tau))=\mathbb{E}_{\tau}\left[\gamma^{H}V^{*}(\phi(s_{H}))+
\sum_{h=0}^{H-1}\gamma^{h}R(\phi(s_{h}),a_{h})\right]$ can be bounded as follows.

$$ $|\mathbf{S}(\tau)-\mathbf{S}(\phi(\tau))|\leq\frac{2\gamma^{H}(\epsilon+{ \mathcal{L}})}{(1-\gamma)(1-c)}+\frac{2\epsilon(1-\gamma^{H-1})}{(1-\gamma)(1- c)}$ (17) $$

###### Proof.

Simply calculating the difference between $\mathbf{S}(\tau)$ and $\mathbf{S}(\phi(\tau)$

$$ $\begin{split}\left|\mathbf{S}(\tau)-\mathbf{S}(\phi(\tau))\right|&=\left| \mathbb{E}_{\tau}\left[\gamma^{H}\left(V^{*}(s_{H})-V^{*}(\phi(s_{H}))\right)+ \sum_{h=0}^{H-1}\gamma^{h}(R(s_{h},a_{h})-R(\phi(s_{h}),a_{h}))\right]\right| \\ &=\left|\mathbb{E}_{\tau}\left[\gamma^{H}\left(V^{*}(s_{H})-V^{*}(\phi(s_{H})) \right)\right]+\mathbb{E}_{\tau}\left[\sum_{h=0}^{H-1}\gamma^{h}(R(s_{h},a_{h} )-R(\phi(s_{h}),a_{h}))\right]\right|\\ &\leq\left\lvert\mathbb{E}_{\tau}\left[\gamma^{H}\left(V^{*}(s_{H})-V^{*}(\phi (s_{H}))\right)\right]\right\rvert+\left|\mathbb{E}_{\tau}\left[\sum_{h=0}^{H- 1}\gamma^{h}(R(s_{h},a_{h})-R(\phi(s_{h}),a_{h}))\right]\right|\\ &\hskip 227.62204pt\text{(Triangle inequality)}\\ &\leq\mathbb{E}_{\tau}\left[\gamma^{H}\left\lvert V^{*}(s_{H})-V^{*}(\phi(s_{H }))\right\rvert\right]+\mathbb{E}_{\tau}\left[\sum_{h=0}^{H-1}\gamma^{h}\left \lvert R(s_{h},a_{h})-R(\phi(s_{h}),a_{h})\right\rvert\right]\\ &\hskip 227.62204pt\text{(Jensen's inequality)}\\ &=\gamma^{H}\mathbb{E}_{\tau}\left[\left\lvert V^{*}(s_{H})-V^{*}(\phi(s_{H})) \right\rvert\right]+\sum_{h=0}^{H-1}\gamma^{h}\mathbb{E}_{\tau}\left[\left \lvert R(s_{h},a_{h})-R(\phi(s_{h}),a_{h})\right\rvert\right]\\ &\leq\frac{2\gamma^{H}(\epsilon+{\mathcal{L}})}{(1-\gamma)(1-c)}+\frac{2 \epsilon}{1-c}\sum_{h=0}^{H-1}\gamma^{h}\quad\text{(From Theorem~{}\ref{thm: optimal-value-bound} and Lemma~{}\ref{cor:reward-bound})}\\ &\leq\frac{2\gamma^{H}(\epsilon+{\mathcal{L}})}{(1-\gamma)(1-c)}+\frac{2 \epsilon(1-\gamma^{H-1})}{(1-\gamma)(1-c)}\end{split}$ (18) $$

∎

###### Lemma 1 .

###### Proof.

###### Theorem 3 .

###### Proof.

## Appendix B Additional Experimental Results

### B.1 All state-based tasks result

Figure: Figure 6: State-based tasks result from DMControl Suite. Performance comparison on 26 DM Control tasks with state input. At each evaluation step, the episode return is computed over 10 episodes. The results are averaged over 3 seeds, with shaded regions representing the standard deviation.
Refer to caption: extracted/5905356/figures/all_state_result.png

### B.2 Computational Time

Table. 1 shows the computational time of BS-MPC and TD-MPC. We use RTX-4090 for our experiments.

**Table 1: Computational time between BS-MPC and TD-MPC in state-based tasks. The table shows how many hours the training takes.**
|  | Cartpole-Swingup | Cheetah-run | Finger-Spin | Walker-run |
| --- | --- | --- | --- | --- |
| BS-MPC | 2.0 | 4.0 | 8.3 | 8.3 |
| TD-MPC | 2.4 | 4.8 | 10.0 | 10.1 |

### B.3 Detailed analysis for the failure of TD-MPC

In this section, we analyze the reason why TD-MPC failed to achieve the same performance as BS-MPC in our experiments. First, we look at the losses of both BS-MPC and TD-MPC in the Humanoid-Walk environment. Fig 7 shows the average value of each loss over the batches. From this image, it can be observed that the consistency loss in TD-MPC gradually increases and diverges. In contrast, BS-MPC has much smaller values for every component, resulting in more stable performance. One possible cause is that TD-MPC fails to learn the encoder, leading to large errors, which in turn result in the failure to train the latent dynamics model properly. BS-MPC, on the contrary, has explicit encoder loss in its objective function, thus enabling it to actively update the encoder. Fig 8 shows the learned Q values and gradient norm of the objective function. As it shows, TD-MPC is vulnerable to exploding gradients, which leads to the divergence of the loss. Moreover, the learned Q values drop significantly when the gradient norm explodes.

Figure: Figure 7: Comparative analysis of loss components between BS-MPC and TD-MPC across training steps in Humanoid-walk environment. Each graph presents different loss types—consistency loss, reward loss, value loss, encoder loss, and total loss—plotted against training steps. Note that TD-MPC does not have encoder loss, and it only exists in BS-MPC. See Eq. 8 for more details.
Refer to caption: extracted/5905356/figures/humanoid_walk_loss_analysis.png

Figure: Figure 8: Average values of the learned Q functions and gradient norm of the loss function between BS-MPC and TD-MPC across training steps in Humanoid-walk environment.
Refer to caption: extracted/5905356/figures/humanoid_walk_q_analysis.png

## Appendix C BS-MPC training algorithm flow

The training algorithm flow is described in Algorithm. 1.

Figure: Algorithm 1 BS-MPC (Model training)

## Appendix D BS-MPC vs TD-MPC2

TD-MPC2 (Hansen et al., ) is the successor of TD-MPC Hansen et al. (), and it modifies the architecture by increasing the model size and adapting distributional reinforcement learning to its cost function. Although it fixes some open problems in TD-MPC, it still suffers from long calculation time due to the model size expansion. Moreover, it has less theoretical background to support the encoder validity.

We compare BS-MPC with TD-MPC2 on both state-based and image-based tasks from the DMControl suite. Figure 9 shows the results for state-based tasks. Both BS-MPC and TD-MPC2 resolve the issue of performance divergence observed in TD-MPC; however, TD-MPC2 requires significantly more parameters and employs more complex model architectures.
Fig 10 shows the results for image-based tasks. Although TD-MPC2 converges faster than BS-MPC in some tasks (e.g., quadruped-run and walker-run), BS-MPC achieves comparable or slightly better overall performance.
In these experiments, we use the same number of parameters and model architecture as in TD-MPC.

Figure: Figure 9: Comparison with TD-MPC2 in state-based tasks from DMControl Suite. Results for TD-MPC2 are obtained from their official repository. The results are averaged over 3 seeds, with shaded regions representing the standard deviation. The first picture shows the average performance across 26 continuous control tasks from DM Control environment.
Refer to caption: extracted/5905356/figures/tdmpc2_state_result.png

Figure: Figure 10: Comparison with TD-MPC2 in image-based tasks from DMControl Suite. Results for TD-MPC2 are obtained from their official repository. The results are averaged over 3 seeds, with shaded regions representing the standard deviation.
Refer to caption: extracted/5905356/figures/tdmpc2_image_result.png

## Appendix E Implementation Details

Here we give details about the hyper-parameters and model architectures.

### E.1 Hyperparameters

Shared Parameters: First, we outline the parameters that are common to both TD-MPC and BS-MPC. They are described in Table. 2.

**Table 2: Hyperparameters used for TD-MPC and BS-MPC in the experiment.**
| Hyperparameter | Value |
| --- | --- |
| Discount factor ($\gamma$) | 0.99 |
| Seed steps | 5,000 |
| Replay buffer size | 1,000,000 (state-based tasks) |
|  | 100,000 (image-based tasks) |
| Sampling technique | Uniform Sampling |
| Planning horizon ($H$) | 5 |
| Initial parameters ($\mu^{0},\sigma^{0}$) | (0, 2) |
| Population size | 512 |
| Elite fraction | 64 |
| MPPI Update Iterations | 12 (Humanoid, Dog) |
|  | 6 (otherwise) |
| Policy fraction | 5% |
| Number of particles | 1 |
| Temperature ($\tau$) | 0.5 |
| Latent dimension | 100 (Humanoid, Dog) |
|  | 50 (otherwise) |
| Learning rate | 3e-4 (pixels) |
|  | 1e-3 (otherwise) |
| Optimizer ($\theta$) | Adam ($\beta_{1}=0.9,\beta_{2}=0.999$) |
| Temporal coefficient ($\lambda$) | 0.5 |
| Reward loss coefficient ($c_{1}$) | 0.5 |
| Value loss coefficient ($c_{2}$) | 0.1 |
| Consistency loss coefficient ($c_{3}$) | 0.5 |
| Exploration schedule ($\epsilon$) | 0.5 $\to$ 0.05 (25k steps) |
| Planning horizon schedule | 1 $\to$ 5 (25k steps) |
| Batch size | 512 (State-based tasks) |
|  | 256 (Image-based tasks) |
| Momentum coefficient ($\zeta$) | 0.99 |
| Steps per gradient update | 1 |
| Target parameter $\bar{\theta}$ update frequency | 2 |

BS-MPC specific parameters: Next, we list the parameter that is used for tuning the weight for bisimulation metric loss $(c_{4})$.
We change the value based on the environment and tune the weighting coefficient $c_{4}$ across ${10^{-8},0.0001,0.001,0.01,0.1,0.5}$ with grid search.
All of the numbers are listed in Table. 3.

**Table 3: Bisimulation metric parameter used in the experiment.**
| Environment | Value ($c_{4}$) |
| --- | --- |
| Acrobot | 0.0001 |
| Cartpole | 0.5 |
| Cheetah | 0.001 |
| Cup | 0.5 |
| Finger | 0.001 |
| Fish | 0.001 |
| Hopper | 0.1 |
| Humanoid | 0.001 |
| Pendulum | 0.01 |
| Quadruped | 0.1 |
| Reacher | 0.01 |
| Walker | 0.001 |
| Dog | $10^{-8}$ |

### E.2 Model Architecture

In our experiments, both BS-MPC and TD-MPC utilize the same model architecture and the number of trainable parameters. We employ multi-layer perceptrons (MLPs) to represent the underlying environment models ${\mathcal{P}}$ and ${\mathcal{R}}$, the state-action value function $Q$, and the policy $\pi$. The architecture details are shown in Table. 4. More details can be found in our official code.

**Table 4: Model Architecture used in the experiment.**
| Models | Number of Layers | Hidden Dim | Activation |
| --- | --- | --- | --- |
| Latent Model Dynamics ${\mathcal{P}}$ | 3 | 512 | ELU |
| Reward Model ${\mathcal{R}}$ | 3 | 512 | ELU |
| State-action value function $Q$ | 3 | 512 | ELU + LayerNorm |
| Policy $\pi$ | 3 | 512 | ELU |

## Peer Reviews

confidence: 3
contribution: 2
initial_rating: 6
presentation: 2
questions: Could the authors expand on the sensitivity of BS-MPC to the parameter c4 and potential ways to reduce this dependency?

How does BS-MPC perform in scenarios with dynamic backgrounds that align with the movement instead of pure noise?

Are there additional computational costs associated with bisimulation metric loss, especially in high-dimensional latent spaces?
soundness: 3
strengths: The paper provides a new perspective by integrating the bisimulation metric to address known challenges in MBRL, particularly around stability and robustness to noise. The experimental results demonstrate how BS-MPC performs well in both state-based and image-based tasks, showing increased resilience to noise and achieving faster training times due to parallel computation. The theoretical analysis adds depth by bounding cumulative rewards in the learned latent space, suggesting that BS-MPC retains meaningful state information effectively.
summary: This paper presents a new method for model-based reinforcement learning (MBRL) called BS-MPC. The key innovation lies in incorporating a bisimulation metric loss into the objective function to improve encoder stability, robustness to noise, and computational efficiency. By using the bisimulation metric, BS-MPC aims to ensure behavioral equivalence in the latent space, maintaining key characteristics of the original state space. The method is benchmarked against the Temporal Difference Model Predictive Control (TD-MPC) and other model-free and model-based methods on various tasks, showing superior stability and resilience to noise.
weaknesses: While the theoretical foundations are thorough, certain explanations, particularly on encoder stability and noise resilience, could be made clearer to broaden accessibility. The parameters require extensive tuning, which may be impractical for real-world applications lacking automated parameter selection. Additionally, the approach to introducing perturbations, particularly with visual distractions, doesn’t seem entirely effective. It would be beneficial to test perturbations that are more representative of realistic environmental changes, which could better showcase BS-MPC’s resilience.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: When you say BS-MPC improves computation efficiency, what does it mean? Is it compared to TD-MPC?
It is surprising to me because BS-MPC has one additional loss term compared to TD-MPC and why is BS-MPC faster to run? 

With the above question, I'd like to know the latency overhead of BS loss term in the training.
soundness: 3
strengths: The paper is well-written and easy to follow. The overall presentation is good. The approach is sound and makes sense to the reviewer. The experimental results look promising, compared to TD-MPC.
summary: This paper proposes BS-MPC, a model-based reinforcement learning approach that introduces bisimulation metrics (loss) on top of TD-MPC. Compare to TD-MPC, BS-MPC has an explicit encoder loss term, the adaptation of bisimulation metric, and parallelizing the BS loss. The authors found that their approach can improve training stability, robustness against input noise, and computation efficiency, which is validated on a set of simulation environments.
weaknesses: However, the major weakness is its novelty. 
1. The whole framework is based on TD-MPC. The difference is the authors introduce the Bisimulation metric and its corresponding loss design, which are from the existing literature, as stated in the paper. 
2. It is also a common way to introduce additional regularization loss terms for the encoder of model-based RL. 
3. The theoretical analysis mainly borrows from the existing work and does not have any major significant result. It would be great if the authors could provide "Under the BS loss training error, what's the performance gap between the final converged policy by their approach and the ideally optimal policy", and "Theoretically, how much performance gain could their approach improve, compared to TD-MPC."

---

confidence: 4
contribution: 2
initial_rating: 6
presentation: 3
questions: “We assume that the learned policy in BS-MPC continuously improves throughout training and eventually converges to the optimal policy π∗, which supports Theorem 1.”
This seems to be a very strong assumption. For example, by looking at the training curve, the return does not improve monotonically, and we have no information about if the learned policy is converging to the optimal policy. How do you explain such a strong assumption? Is it possible to remove it for the theoretical results?

In Fig. 4, why do all non-MPC based methods only have results till 10M steps?
soundness: 3
strengths: The paper is clearly written and well presented. The proposed bisimulation metric seems to work well on the experiments considered, compared to TD-MPC and other baselines. The supplementary sections are comprehensive.
summary: This paper considers model based reinforcement learning and proposes bisimulation metric to improve over temporal differential MPC method. The authors show theoretical analysis of the expected cumulative rewards in the latent space, and empirically demonstrate enhancement over TD-MPC and other baselines on several continuous control tasks.
weaknesses: The novelty of the paper seems ambiguous. It seems that both on-policy bisimulation and TD-MPC methods are well studied for model based RL, and the authors plug bisimulation into TD-MPC. 

There are several typos in the paper.
“In BS-MPC, the latent dynamics are modeled using an MLP. We also model the latent dynamics model with an MLP” I believe BS-MPC should be TD-MPC.
“we sample M action sets from Gaussian distribution N (μ0, σ0) based on the initial meanμ0 and standard deviation σ0” Missing spacing between mean and \mu_0

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: 1- Based on your case studies, your method does not seem to change the episode return that much, except for a few cases like dog walk, dog trot and humanoid walk. In your Appendix, you provide a rough explanation of why that may be. Looking at Figure 7 and 8, it appears that loss, and consequently the gradient, explode (in TD-MPC), however, in RL, gradient clipping is used to tackle this issue. When you compared your method to TD-MPC, did you employ gradient clipping for it or not? It does not appear to be a fair comparison if you didn't, and perhaps that is why your method did not do significantly better in other case studies; as loss did not *explode*.  

2- I suggest you revise the experiments' section, and run all case studies on TD-MPC2 rather than TD-MPC. I realize it is touched upon in appendix D, however since TD-MPC2 is the updated version, I suspect it would make for a more fair comparison. Moreover, adding a thorough comparison would certainly present your method better; between training time, sample complexity, number of parameters used, and hyper parameter tuning and different configurations; it will strengthen your case if you could show how it might fail. I would also like to know the rationale behind using TD-MPC in the main body and mentioning TD-MPC2 in the appendix.  
To the best of my knowledge, TD-MPC2 can have many parameters, since it can be used on different domains. Thus, it is not an apple to apple comparison, unless it is specifically mentioned in the paper.


3- Is there any theoretical results on why your method requires less parameters, and converges faster? or is it mainly based off of experiments? Since Theorem 3 only offers an upper bound for expected cumulative rewards for the optimal policy. 

4- I suggest a more rigorous approach for robustness, such as comparing the Lipschitz constant of your controller to TD-MPC's.

5- I believe if you can theoretically confirm in which case studies your method is going to perform better than TD-MPC, it will strengthen your paper significantly.
soundness: 3
strengths: Paper is well written, all ideas are clearly explained. Overall, paper is mathematically rigorous. Authors do a good job in walking the reader through the preliminaries, highlighting distinctions, and presenting their work.

Furthermore, paper presents more than 20 case studies, which helps immensely in comparing their performance to the state of the art methods.
summary: This paper is concerned with a new, model-based reinforcement learning method, which utilizes bi-simulation metric. This formulation helps with the stability of training and helps with the robustness of the controller. General idea is that they seek to find states that "behave" similarly, and intuition behind it is that one can use similar control input for similar states, which simplifies the controller and make it more interpretable. Authors learn an encoder which maps states of the environment to another domain, in which similar states are identified, and are mapped to the same representation (roughly speaking). Then, this representation is utilized to train a controller. Novelty of this work is to add the encoder loss directly into the training procedure.
weaknesses: Improvements and contributions seem incremental, and overall not that beneficial according to the case studies (Figure 6), one only sees improvements in few case studies (such as humanoid walk, dog walk and trot), and basically identical to TD-MPC in others (such as humanoid stand, pendulum, cheetah). 
The only major contribution is adding the bi-simulation metric loss to the loss function, the other two contribution naturally follow from this addition. 

As authors have mentioned, the hyper parameters play a huge role, and one wonders how much time is needed to tune these parameters.

Meta-review: The paper presents Bisimulation Metric for Model Predictive Control (BS-MPC), a technique for model-based reinforcement learning that uses a bi-simulation metric to improve encoder stability, robustness to noise, and computational efficiency. The benefits of BS-MPC are demonstrated via experiments on both continuous control and image-based tasks from the DeepMind Control Suite.

Decision: Accept (Poster)